package jcircus.newutil; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Vector; import javax.swing.JOptionPane; import jcircus.anns.MuCallAnn; import jcircus.complementaryenvs.CallsAndParamsEnv; import jcircus.parallelism.Consumer; import jcircus.parallelism.CopyProcessAnn; import net.sourceforge.czt.circus.ast.Action1; import net.sourceforge.czt.circus.ast.Action2; import net.sourceforge.czt.circus.ast.ActionPara; import net.sourceforge.czt.circus.ast.AssignmentCommand; import net.sourceforge.czt.circus.ast.AssignmentPairs; import net.sourceforge.czt.circus.ast.BasicAction; import net.sourceforge.czt.circus.ast.BasicProcess; import net.sourceforge.czt.circus.ast.CallAction; import net.sourceforge.czt.circus.ast.CallProcess; import net.sourceforge.czt.circus.ast.ChaosAction; import net.sourceforge.czt.circus.ast.CircusAction; import net.sourceforge.czt.circus.ast.CircusActionList; import net.sourceforge.czt.circus.ast.CircusCommand; import net.sourceforge.czt.circus.ast.CircusProcess; import net.sourceforge.czt.circus.ast.Communication; import net.sourceforge.czt.circus.ast.ExtChoiceAction; import net.sourceforge.czt.circus.ast.GuardedAction; import net.sourceforge.czt.circus.ast.HideAction; import net.sourceforge.czt.circus.ast.IfGuardedCommand; import net.sourceforge.czt.circus.ast.IntChoiceAction; import net.sourceforge.czt.circus.ast.InterleaveAction; import net.sourceforge.czt.circus.ast.MuAction; import net.sourceforge.czt.circus.ast.ParAction; import net.sourceforge.czt.circus.ast.ParallelAction; import net.sourceforge.czt.circus.ast.ParamAction; import net.sourceforge.czt.circus.ast.ParamProcess; import net.sourceforge.czt.circus.ast.PrefixingAction; import net.sourceforge.czt.circus.ast.Process1; import net.sourceforge.czt.circus.ast.Process2; import net.sourceforge.czt.circus.ast.ProcessPara; import net.sourceforge.czt.circus.ast.RenameAction; import net.sourceforge.czt.circus.ast.SeqAction; import net.sourceforge.czt.circus.ast.SkipAction; import net.sourceforge.czt.circus.ast.StopAction; import net.sourceforge.czt.circus.ast.VarDeclCommand; import net.sourceforge.czt.circus.util.Factory; import net.sourceforge.czt.z.ast.Decl; import net.sourceforge.czt.z.ast.Expr; import net.sourceforge.czt.z.ast.NarrSect; import net.sourceforge.czt.z.ast.Para; import net.sourceforge.czt.z.ast.Pred; import net.sourceforge.czt.z.ast.Spec; import net.sourceforge.czt.z.ast.VarDecl; import net.sourceforge.czt.z.ast.ZDeclList; import net.sourceforge.czt.z.ast.ZExprList; import net.sourceforge.czt.z.ast.ZName; import net.sourceforge.czt.z.ast.ZNameList; import net.sourceforge.czt.z.ast.ZParaList; import net.sourceforge.czt.z.ast.ZSect; public class CallUtil { static FactoryUtil pf = new FactoryUtil (); public static Vector muCalls (CircusAction action, CircusProcess process, Spec spec) { if (action instanceof Action2) { Vector mucalls = muCalls (((Action2)action).getLeftAction(), process, spec); mucalls.addAll(muCalls (((Action2)action).getRightAction(), process, spec)); return mucalls; } else if (action instanceof Action1 && !(action instanceof MuAction)) { return muCalls (((Action1)action).getCircusAction(), process, spec); } else if (action instanceof MuAction) { String muname = ((MuAction)action).getZName().toString(); Vector mucalls = new Vector (); mucalls.addElement(muname); mucalls.addAll(muCalls(((MuAction)action).getCircusAction(), process, spec)); return mucalls; } else if (action instanceof CallAction) { /*if (action.getAnn(MuCallAnn.class) == null) {}*/ return new Vector (); //return muCalls (getContentOfCallAction ((CallAction)action, process, spec), process, spec); } else if (action instanceof AssignmentCommand) { return new Vector (); } else if (action instanceof IfGuardedCommand) { CircusActionList cal = ((IfGuardedCommand) action).getGuardedActionList(); int size = cal.size(); Vector igccalls = new Vector (); for (int i = 0; i < size; i++) { GuardedAction ga = (GuardedAction) cal.get(i); igccalls.addAll(muCalls (ga, process, spec)); } return igccalls; } else if (action instanceof VarDeclCommand) { return muCalls (((VarDeclCommand)action).getCircusAction(), process, spec); } else if (action instanceof BasicAction) { return new Vector (); } else { ExceptionUtil.throwImplementationException("CallUtil.muCalls", action.getClass()); return new Vector (); } } public CircusAction transformCallActionsIntoRealActions (CircusAction action, CircusProcess process, Spec spec) { if (action instanceof CallAction) { return getContentOfCallAction (((CallAction)action), process, spec); } else if (action instanceof Action2) { ((Action2)action).setLeftAction(transformCallActionsIntoRealActions (((Action2)action).getLeftAction(), process, spec)); ((Action2)action).setRightAction(transformCallActionsIntoRealActions (((Action2)action).getRightAction(), process, spec)); return action; } else return action; } private static void transformToMuAction (CircusAction action) { } private static Vector callsWithoutDuplicates (Vector callsvec) { Vector callsvec2 = new Vector (); for (int i = 0; i < callsvec.size(); i++) { if (!callsvec2.contains(callsvec.elementAt(i))) callsvec2.add(callsvec.elementAt(i)); } return callsvec2; } public static Vector recursiveCalls (CircusProcess process, Spec spec) { Vector callsvecRec = new Vector (); Vector actionParaNames = new Vector (); BasicProcess bp; if (process instanceof ParamProcess) { bp = ((ParamProcess)process).getCircusBasicProcess(); } else { bp = (BasicProcess)process; } ZParaList paras = bp.getZParaList(); Vector alreadySeen; for (int i = 0; i < paras.size(); i++) { if (paras.get(i) instanceof ActionPara) { ActionPara actionPara = ((ActionPara)paras.get(i)); alreadySeen = new Vector (); CircusAction action = ((ActionPara)paras.get(i)).getCircusAction(); String paraName = actionPara.getName().toString(); HashMap allCalls = calls (action, process, spec); boolean hasRecursiveCall = allCalls.keySet().contains(paraName);//hasRecursiveCall (action, process, paraName, alreadySeen); if (hasRecursiveCall) { callsvecRec.add(((ActionPara)paras.get(i)).getName().toString()); } System.out.print(""); } } return callsvecRec; } public static Vector recursiveCalls (CircusAction action, CircusProcess process, Spec spec) { Vector all = recursiveCalls (process, spec); HashMap fromAction = calls (action, process, spec); Vector ret = new Vector (); for (int i = 0; i < all.size(); i++) { if (fromAction.keySet().contains(all.elementAt(i))) { if (fromAction.get(all.elementAt(i)) > 1) { ret.addElement(all.elementAt(i)); } } } return ret; } public static HashMap calls (CircusAction action, CircusProcess process, Spec spec) { Vector mucalls = muCalls (action, process, spec); return calls (action, process, new HashMap (), mucalls/*new Vector ()*/, spec); } public static HashMap calls (CircusAction action, CircusProcess process, HashMap callsvec, Vector mucalls, Spec spec) { if (action instanceof PrefixingAction) { HashMap callsvec2 = new HashMap (); callsvec2.putAll(callsvec); callsvec2.putAll(calls (((PrefixingAction)action).getCircusAction(), process, callsvec, mucalls, spec)); return callsvec2; } else if (action instanceof Action2) { Action2 action2 = (Action2) pf.createCircusAction(action); HashMap callsvec2 = new HashMap (); callsvec2.putAll(callsvec); callsvec2.putAll(calls (action2.getLeftAction(), process, callsvec, mucalls, spec)); callsvec2.putAll(calls (action2.getRightAction(), process, callsvec, mucalls, spec)); return callsvec2; } else if (action instanceof CallAction) { String name = ((CallAction)action).getName().toString(); //HashMap callsvec2 = new HashMap (); //callsvec2.putAll(callsvec); if (!callsvec.keySet().contains(name)) { callsvec.put(name, 1); if (!mucalls.contains(name)) callsvec.putAll(calls (getContentOfCallAction ((CallAction)action, process, spec), process, callsvec, mucalls, spec)); return callsvec; } else if (callsvec.keySet().contains(name)) { callsvec.put(name, callsvec.get(name) + 1); return callsvec; } else return callsvec; } else if (action instanceof CircusCommand) { if (action instanceof AssignmentCommand) { return new HashMap (); } else if (action instanceof IfGuardedCommand) { CircusActionList cal = ((IfGuardedCommand) action).getGuardedActionList(); int size = cal.size(); HashMap igccalls = new HashMap (); for (int i = 0; i < size; i++) { GuardedAction ga = (GuardedAction) cal.get(i); igccalls.putAll(calls (ga, process, callsvec, mucalls, spec)); } return igccalls; } else if (action instanceof VarDeclCommand) { return calls (((VarDeclCommand)action).getCircusAction(), process, callsvec, mucalls, spec); } else { ExceptionUtil.throwImplementationException("CallUtil.calls", action.getClass()); return callsvec; } } else if (action instanceof ParamAction) { return calls (((ParamAction)action).getCircusAction(), process, callsvec, mucalls, spec); } else if (action instanceof GuardedAction) { return calls (((GuardedAction)action).getCircusAction(), process, callsvec, mucalls, spec); } else if (action instanceof MuAction) { mucalls.addElement(((MuAction)action).getZName().toString()); return calls (((MuAction)action).getCircusAction(), process, callsvec, mucalls, spec); } else if (action instanceof BasicAction) { return new HashMap (); } else { ExceptionUtil.throwImplementationException("CallUtil.calls", action.getClass()); return callsvec; } } public static CircusAction seqVersionOfAction (CircusAction action) { Factory f = new Factory (); if (action instanceof PrefixingAction) { SeqAction seq = f.createSeqAction(); Communication c = ((PrefixingAction)action).getCommunication(); CircusAction ca = ((PrefixingAction)action).getCircusAction(); seq.setLeftAction (f.createPrefixingAction (f.createSkipAction(), c)); seq.setRightAction(seqVersionOfAction (((PrefixingAction) action).getCircusAction())); seq.getAnns().addAll(action.getAnns()); return seq; } else if (action instanceof ExtChoiceAction) { ExtChoiceAction eca = f.createExtChoiceAction(); Action2 action2 = (Action2)action; CircusAction left = action2.getLeftAction(); CircusAction right = action2.getRightAction(); if (left instanceof PrefixingAction || right instanceof PrefixingAction) { if (left instanceof PrefixingAction && !(right instanceof PrefixingAction)) { CircusAction pfLeft = ((PrefixingAction)left).getCircusAction (); pfLeft = seqVersionOfAction (pfLeft); ((PrefixingAction)left).setCircusAction(pfLeft); eca.setLeftAction (left); eca.setRightAction (seqVersionOfAction (right)); //eca.getAnns().addAll(action.getAnns()); //return eca; } else if (!(left instanceof PrefixingAction) && right instanceof PrefixingAction) { CircusAction pfRight = ((PrefixingAction)right).getCircusAction (); pfRight = seqVersionOfAction (pfRight); ((PrefixingAction)right).setCircusAction(pfRight); eca.setRightAction (right); eca.setLeftAction (seqVersionOfAction (left)); //eca.setRightAction (right); //eca.getAnns().addAll(action.getAnns()); //return eca; } else /*if (left instanceof PrefixingAction && right instanceof PrefixingAction)*/ { CircusAction pfLeft = ((PrefixingAction)left).getCircusAction (); CircusAction pfRight = ((PrefixingAction)right).getCircusAction (); pfLeft = seqVersionOfAction (pfLeft); pfRight = seqVersionOfAction (pfRight); ((PrefixingAction)left).setCircusAction(pfLeft); ((PrefixingAction)right).setCircusAction(pfRight); eca.setLeftAction (left); eca.setRightAction (right); eca.getAnns().addAll(action.getAnns()); return eca; } /*eca.setLeftAction (left); eca.setRightAction (right);*/ eca.getAnns().addAll(action.getAnns()); return eca; } else { eca.setLeftAction(seqVersionOfAction (left)); eca.setRightAction(seqVersionOfAction (right)); eca.getAnns().addAll(action.getAnns()); return eca; } } else if (action instanceof IntChoiceAction) { IntChoiceAction eca = f.createIntChoiceAction(); Action2 action2 = (Action2)action; eca.setLeftAction(seqVersionOfAction (action2.getLeftAction())); eca.setRightAction(seqVersionOfAction (action2.getRightAction())); eca.getAnns().addAll(action.getAnns()); return eca; } else if (action instanceof ParallelAction) { ParallelAction eca = f.createParallelAction(); Action2 action2 = (Action2)action; eca.setLeftAction(seqVersionOfAction (action2.getLeftAction())); eca.setRightAction(seqVersionOfAction (action2.getRightAction())); eca.setLeftNameSet(((ParallelAction)action).getLeftNameSet()); eca.setRightNameSet(((ParallelAction)action).getRightNameSet()); eca.setChannelSet(((ParallelAction)action).getChannelSet()); eca.getAnns().addAll(action.getAnns()); return eca; } else if (action instanceof InterleaveAction) { InterleaveAction eca = f.createInterleaveAction(); Action2 action2 = (Action2)action; eca.setLeftAction(seqVersionOfAction (action2.getLeftAction())); eca.setRightAction(seqVersionOfAction (action2.getRightAction())); eca.getAnns().addAll(action.getAnns()); return eca; } else if (action instanceof SeqAction) { SeqAction eca = f.createSeqAction(); Action2 action2 = (Action2)action; eca.setLeftAction(seqVersionOfAction (action2.getLeftAction())); eca.setRightAction(seqVersionOfAction (action2.getRightAction())); eca.getAnns().addAll(action.getAnns()); return eca; } else if (action instanceof MuAction) { MuAction mu = f.createMuAction(); mu.setName(((MuAction)action).getName()); mu.setCircusAction(seqVersionOfAction (((MuAction)action).getCircusAction())); mu.getAnns().addAll(action.getAnns()); return mu; } else if (action instanceof CallAction) { CallAction ca = f.createCallAction(f.createZName (((CallAction)action).getZName().toString()), f.createZExprList()); ca.getAnns().addAll(action.getAnns()); return ca; } else if (action instanceof RenameAction) { //CallAction ca = f.createRenameAction(f.createZName (((RenameAction)action).getZName().toString()), f.createZExprList()); RenameAction ra = f.createRenameAction(); ra.setAssignmentPairs(((RenameAction)action).getAssignmentPairs()); ra.setCircusAction(seqVersionOfAction (((RenameAction)action).getCircusAction())); ra.getAnns().addAll(action.getAnns()); return ra; } else if (action instanceof GuardedAction) { GuardedAction ga = f.createGuardedAction (); ga.setPred(((GuardedAction)action).getPred()); ga.setCircusAction(seqVersionOfAction (((GuardedAction)action).getCircusAction())); return ga; } /*else if (action instanceof HideAction) { //TODO return }*/ else { return action; /*SkipAction skp = f.createSkipAction(); return skp;*/ } } public static CircusAction getContentOfCallAction (CallAction ca, CircusProcess process, Spec spec) { //Só vai retornar o conteúdo do primeiro nível. //Ex: Se A ^= B, e B = a -> SKIP, o conteúdo de A será B. E o conteúdo de B será a -> SKIP //Favor não mexer nesta condição, //pois pode dar Stack Overflow caso façamos o conteúdo do conteúdo //da ação ser retornado no caso de o conteúdo ser uma ação de chamada Factory f = new Factory (); String actionName = ca.getName().toString(); CircusAction returnedAction = null; if (process instanceof BasicProcess) { List actionParas = (List ) ((BasicProcess)process).getZParaList(); int size = actionParas.size(); for (int i = 0; i < size; i++) { Para para = actionParas.get(i); if (para instanceof ActionPara) { if (((ActionPara)para).getZName().toString().equals(actionName)) { CircusAction currentaction = ((ActionPara)para).getCircusAction(); /*if (ca.getZExprList() != null) { if (ca.getZExprList().size() > 0) { ZExprList exprs = ca.getZExprList(); ZDeclList params = pf.createZDeclList(((ParamAction)currentaction).getZDeclList()); params = DeclUtil.renameDecls2pNameIndex(params, actionName); returnedAction = ExprUtil.actionWithUpdatedExpression(params, exprs, currentaction); } }*/ //else { returnedAction = pf.createCircusAction(currentaction); //} } } } } else if (process instanceof ParamProcess) { List actionParas = (List ) ((ParamProcess)process).getCircusBasicProcess().getZParaList(); //falta testar esta linha int size = actionParas.size(); for (int i = 0; i < size; i++) { Para para = actionParas.get(i); if (para instanceof ActionPara) { if (((ActionPara)para).getZName().toString().equals(actionName)) { returnedAction = pf.createCircusAction(((ActionPara)para).getCircusAction()); returnedAction.getAnns().addAll(((ActionPara)para).getCircusAction().getAnns()); } } } } else if (process instanceof Process2) { CircusAction content1 = pf.createCircusAction (getContentOfCallAction (ca, ((Process2)process).getLeftProcess(), spec)); CircusAction content2 = pf.createCircusAction (getContentOfCallAction (ca, ((Process2)process).getRightProcess(), spec)); if (content1 != null) { returnedAction = content1; } else if (content2 != null) { returnedAction = content2; } } else if (process instanceof CallProcess) { CircusProcess contentOfProcess = ProcessUtil.getContentOfCallProcess (process, spec); returnedAction = pf.createCircusAction(getContentOfCallAction (ca, contentOfProcess, spec)); } if (returnedAction == null) { if (/*actionName.equals("X") ||*/ca.getAnn(MuCallAnn.class) != null) { System.out.println ("*******************\nAction " + actionName + " was not found on process, in the first search. " + "If it starts with \"X\", then no problem, it is a recursive action.\n*******************\n"); } else { ExceptionUtil.throwException("CallUtil.getContentOfCallAction :: CallAction is null... Cannot return anything for the content of " + ca.getZName().toString()); } } return returnedAction; } public static CircusAction expandAction (Vector actionNames, CircusAction action, CircusProcess process, Spec spec) { Vector mucalls = muCalls (action, process, spec); HashMap calls = calls (action, process, spec); CircusAction step1 = expandAction (mucalls, actionNames, action, process, new Consumer (toVectorString (calls.keySet().toArray())/*new Vector ()*/), spec, new CallsAndParamsEnv ()); //CircusAction step2 = expandActionStep2 (mucalls, actionNames, step1, process, new Consumer (toVectorString (calls.keySet().toArray())/*new Vector ()*/), spec); //CircusAction returnaction = return step1; } public static CircusAction transformParamAction (ParamAction action, CallAction callaction, Spec spec, Consumer c, String actionname) { ZExprList exprlist = callaction.getZExprList(); return transformParamAction (action, exprlist, spec, c, actionname); } public static CircusAction transformParamAction (ParamAction action, ZExprList exprlist, Spec spec, Consumer c, String actionname) { Factory f = new Factory (); FactoryUtil fu = new FactoryUtil (); ZDeclList declList = fu.createZDeclList(action.getZDeclList()); AssignmentCommand assig = f.createAssignmentCommand (); AssignmentPairs pairs = f.createAssignmentPairs(); ZNameList namelist = f.createZNameList(); int size = declList.size(); for (int i = 0; i < size; i++) { Decl decl = declList.get(i); if (decl instanceof VarDecl) { VarDecl vardecl = (VarDecl)decl; ZNameList declsvardecl = vardecl.getZNameList(); for (int j = 0; j < declsvardecl.size(); j++) { ZName name = (ZName) declsvardecl.get(j); namelist.add(name); } } } pairs.setLHS(namelist); pairs.setRHS(exprlist); assig.setAssignmentPairs(pairs); SeqAction almostfinalaction = f.createSeqAction(); almostfinalaction.setLeftAction(assig); CircusAction accccc = action.getCircusAction(); almostfinalaction.setRightAction(fu.createCircusAction (action.getCircusAction())); VarDeclCommand finalaction = f.createVarDeclCommand(); finalaction.setDeclList(declList); finalaction.setCircusAction(almostfinalaction); System.out.println (PrinterUtil.printAction(finalaction, spec)); if (c.callStatus(actionname) != Consumer.NORMALCALL && c.callStatus(actionname) != Consumer.RECSTART ) { return almostfinalaction; } return finalaction; } public static void addMuCallAnns (CircusAction action, CircusProcess process, Spec spec) { Vector mucalls = muCalls (action, process, spec); addMuCallAnns (action, process, spec, mucalls); } public static void addMuCallAnns (CircusAction action, CircusProcess process, Spec spec, Vector mucalls) { if (action instanceof Action2) { CircusAction left = ((Action2)action).getLeftAction(); CircusAction right = ((Action2)action).getRightAction(); addMuCallAnns (left, process, spec, mucalls); addMuCallAnns (right, process, spec, mucalls); } else if (action instanceof Action1) { CircusAction act1 = ((Action1)action).getCircusAction(); addMuCallAnns (act1, process, spec, mucalls); } else if (action instanceof CallAction) { String actionname = ((CallAction)action).getZName().toString(); if (mucalls.contains(actionname)) { action.getAnns().add(new MuCallAnn ()); } } else if (action instanceof CircusCommand) { if (action instanceof AssignmentCommand) { //Não faz nada } else if (action instanceof IfGuardedCommand) { CircusActionList cal = ((IfGuardedCommand) action).getGuardedActionList(); int size = cal.size(); for (int i = 0; i < size; i++) { GuardedAction ga = (GuardedAction) cal.get(i); addMuCallAnns (ga, process, spec, mucalls); } } else if (action instanceof VarDeclCommand) { addMuCallAnns (((VarDeclCommand)action).getCircusAction(), process, spec, mucalls); } else { ExceptionUtil.throwImplementationException("CallUtil.addMuCallAnns", action.getClass()); } } else if (action instanceof BasicAction) { //Não faz nada } else { ExceptionUtil.throwImplementationException("CallUtil.addMuCallAnns", action.getClass()); } } private static AssignmentCommand recStartAssignmentCommand (ZDeclList decllist, ZExprList exprs, String actionname) { Factory f = new Factory (); FactoryUtil fu = new FactoryUtil (); Vector vecnames = DeclUtil.declListAsVector(decllist); ZNameList names = f.createZNameList(); int size = exprs.size(); for (int i = 0; i < size; i++) { String paramname = "p" + actionname + i; //String paramname = vecnames.elementAt(i); names.add(f.createZName(paramname)); } AssignmentPairs asspairs = f.createAssignmentPairs(names, fu.createZExprList(exprs)); AssignmentCommand asscomm = f.createAssignmentCommand(); asscomm.setAssignmentPairs(asspairs); return asscomm; } private static AssignmentCommand recCallAssignmentCommand (ParamAction action, ZExprList exprs, String actionname) { Vector targetvars = ParamUtil.getParamVars (action); Factory f = new Factory (); FactoryUtil fu = new FactoryUtil (); ZNameList names = f.createZNameList (); ZExprList newexprs = fu.createZExprList (exprs); int size = exprs.size(); Vector vecnames = DeclUtil.declListAsVector(action.getZDeclList()); for (int i = 0; i < size; i++) { String paramname = "p" + actionname + i; //String paramname = vecnames.elementAt(i); names.add(f.createZName(paramname)); Expr currentexpr = newexprs.get(i); ExprUtil.replaceVarName (targetvars.get(i), paramname, currentexpr); } AssignmentPairs asspairs = f.createAssignmentPairs(names, newexprs); AssignmentCommand asscomm = f.createAssignmentCommand(); asscomm.setAssignmentPairs(asspairs); return asscomm; } /*public static CallsAndParamsEnv originalCallsAndParamsEnv (CircusAction action, CallsAndParamsEnv cape) { if (action instanceof CallAction) { CallAction callaction = (CallAction)action; //if (callaction.getZExprList().size() > 0) { //CallsAndParamsEnv newcape = new CallsAndParamsEnv (cape); //} } }*/ public static CircusAction expandAction (Vector mus, Vector actionNames, CircusAction action, CircusProcess process, Consumer c, Spec spec, CallsAndParamsEnv cape) { Factory f = new Factory (); FactoryUtil fu = new FactoryUtil (); if (action instanceof ParamAction) { ParamAction pact = f.createParamAction(); pact.setCircusAction(fu.createCircusAction (expandAction (mus, actionNames, ((ParamAction)action).getCircusAction(), process, c, spec, cape))); pact.setDeclList(fu.createZDeclList(((ParamAction)action).getZDeclList())); return pact; } else if (action instanceof CallAction) { String callName = ((CallAction)action).getName().toString(); if (mus.contains(callName)) { action.getAnns().add(new MuCallAnn ()); } if (action.getAnn(MuCallAnn.class) != null) { return fu.createCircusAction (action); } CircusAction content = getContentOfCallAction ((CallAction)action, process, spec); CircusAction updatedContent = pf.createCircusAction (content); Vector paramvars = new Vector (); if (content instanceof ParamAction) { paramvars = ParamUtil.getParamVars((ParamAction)content); updatedContent = ((ParamAction)updatedContent).getCircusAction (); ZDeclList decls2beupdated = pf.createZDeclList(((ParamAction)content).getZDeclList()); ZExprList newactexprs = ExprUtil.pActname2ExprList (decls2beupdated.size(), ((CallAction)action).getName().toString()); updatedContent = ExprUtil.actionWithUpdatedExpression (decls2beupdated, newactexprs, updatedContent, process, spec, mus, actionNames, c); System.out.println ("content :: " + PrinterUtil.printAction(content, spec)); System.out.println ("updatedContent :: " + PrinterUtil.printAction(updatedContent, spec)); System.out.print (""); } if (c.callStatus (((CallAction)action).getName().toString()) == Consumer.RECSTART) { c.incrementStatus(((CallAction)action).getName().toString()); MuAction mu = f.createMuAction(); mu.setName(f.createZName("X" + ((CallAction)action).getName().toString())); CircusAction act = fu.createCircusAction (expandAction (new Vector (mus), actionNames, updatedContent, process, c, spec, cape)); mu.getAnns().addAll(act.getAnns()); mu.setCircusAction (act); if (((CallAction)action).getZExprList() != null) { if (((CallAction)action).getZExprList().size() > 0) { AssignmentCommand asscomm = recStartAssignmentCommand (((ParamAction)content).getZDeclList(), ((CallAction)action).getZExprList(), ((CallAction)action).getZName().toString()); SeqAction seq = f.createSeqAction(); seq.setLeftAction(asscomm); seq.setRightAction (mu); ZDeclList newdecllist = fu.createZDeclList (DeclUtil.correspondentRenamedDeclList(((ParamAction)content).getZDeclList(), ((CallAction)action).getName().toString())); VarDeclCommand vdc = f.createVarDeclCommand(); vdc.setDeclList(newdecllist); vdc.setCircusAction(seq); c.decrementStatus(((CallAction)action).getName().toString()); return vdc; } } c.decrementStatus(((CallAction)action).getName().toString()); return mu; } else if (c.callStatus (((CallAction)action).getName().toString()) == Consumer.RECCALL) { c.incrementStatus(((CallAction)action).getName().toString()); CallAction act2 = f.createCallAction (); act2.setName(f.createZName("X" + ((CallAction)action).getName().toString())); act2.setExprList (fu.createZExprList (((CallAction)action).getZExprList())); act2.getAnns().add(new MuCallAnn ()); if (((CallAction)action).getZExprList() != null) { if (((CallAction)action).getZExprList().size() > 0 && content instanceof ParamAction) { ZExprList exprs = ExprUtil.fromVectorToRefExpr(paramvars); //updatedContent = ExprUtil.actionWithUpdatedExpression(decls2beupdated, updatedContent); AssignmentCommand asscomm = recCallAssignmentCommand ((ParamAction)content, ((CallAction)action).getZExprList(), ((CallAction)action).getName().toString()); SeqAction seq = f.createSeqAction(); seq.setLeftAction(asscomm); seq.setRightAction (act2); VarDeclCommand vdc = f.createVarDeclCommand (); vdc.setDeclList(fu.createZDeclList(((ParamAction)content).getZDeclList())); vdc.setCircusAction(seq); c.decrementStatus(((CallAction)action).getName().toString()); return vdc; } } c.decrementStatus(((CallAction)action).getName().toString()); return act2; } else if (c.callStatus (((CallAction)action).getName().toString()) == Consumer.NORMALCALL) { CircusAction normalcallreturn = fu.createCircusAction ( expandAction ( new Vector (mus), actionNames, content, process, c, spec, cape) ); return normalcallreturn; } else { return action; } /* if (content instanceof ParamAction) { paramvars = ParamUtil.getParamVars((ParamAction)content); updatedContent = ((ParamAction)updatedContent).getCircusAction (); ZDeclList decls2beupdated = pf.createZDeclList(((ParamAction)content).getZDeclList()); ZExprList newactexprs = ExprUtil.pActname2ExprList (decls2beupdated.size(), ((CallAction)action).getName().toString()); updatedContent = ExprUtil.actionWithUpdatedExpression (decls2beupdated, newactexprs, updatedContent, process, spec, mus, actionNames, c); System.out.println ("content :: " + PrinterUtil.printAction(content, spec)); System.out.println ("updatedContent :: " + PrinterUtil.printAction(updatedContent, spec)); System.out.print (""); } */ } else if (action instanceof PrefixingAction) { PrefixingAction pa = f.createPrefixingAction(); pa.setCommunication(fu.createCommunication(((PrefixingAction)action).getCommunication())); pa.setCircusAction(expandAction (new Vector (mus), actionNames, ((Action1)action).getCircusAction(), process, c, spec, cape)); return pa; } else if (action instanceof MuAction) { Vector newmus = new Vector (mus); newmus.addElement (((MuAction)action).getName().toString()); MuAction mu = f.createMuAction (); mu.setName(((MuAction)action).getName()); mu.setCircusAction(expandAction (newmus, actionNames, ((MuAction)action).getCircusAction(), process, c, spec, cape)); return mu; } /* TODO os outros elses de Action1: HideAction, e etc * */ else if (action instanceof GuardedAction) { GuardedAction ga = f.createGuardedAction (); ga.setPred(((GuardedAction)action).getPred()); ga.setCircusAction(expandAction (new Vector (mus), actionNames, ((GuardedAction)action).getCircusAction(), process, c, spec, cape)); return ga; } else if (action instanceof CircusCommand) { if (action instanceof AssignmentCommand) { AssignmentPairs apa = ((AssignmentCommand)action).getAssignmentPairs(); AssignmentPairs ap = f.createAssignmentPairs(apa.getLHS(), apa.getRHS()); return f.createAssignmentCommand(ap); } else if (action instanceof VarDeclCommand) { CircusAction caction = expandAction (new Vector (mus), actionNames, ((VarDeclCommand)action).getCircusAction(), process, c, spec, cape); VarDeclCommand vdc = f.createVarDeclCommand (); vdc.setCircusAction(caction); vdc.setDeclList(((VarDeclCommand)action).getDeclList()); vdc.getAnns().addAll(action.getAnns()); return vdc; } else if (action instanceof IfGuardedCommand) { CircusActionList cal = ((IfGuardedCommand) action).getGuardedActionList(); IfGuardedCommand newgc = f.createIfGuardedCommand(); CircusActionList gal = f.createCircusActionList(); int size = cal.size(); for (int i = 0; i < size; i++) { GuardedAction ga = (GuardedAction) cal.get(i); GuardedAction newga = f.createGuardedAction(); newga.setPred(ga.getPred()); newga.setCircusAction(expandAction (new Vector (mus), actionNames, fu.createCircusAction(ga.getCircusAction()), process, c, spec, cape)); gal.add(newga); } newgc.setActionList(gal); return newgc; } else { ExceptionUtil.throwImplementationException("CallUtil.expandAction", action.getClass()); return action; } } else if (action instanceof Action2) { Action2 action2 = ((Action2)action); /*Consumer cleft = new Consumer (c); Consumer cright = new Consumer (c); if ( !(action instanceof SeqAction) //action instanceof ParAction ) { action2.setLeftAction(expandAction (new Vector (mus), actionNames, ((Action2)action).getLeftAction(), process, cleft, spec)); action2.setRightAction(expandAction (new Vector (mus), actionNames, ((Action2)action).getRightAction(), process, cright, spec)); System.out.print (""); } else {*/ action2.setLeftAction(expandAction (new Vector (mus), actionNames, ((Action2)action).getLeftAction(), process, c, spec, cape)); action2.setRightAction(expandAction (new Vector (mus), actionNames, ((Action2)action).getRightAction(), process, c, spec, cape)); //} if (action instanceof ParallelAction) { ((ParallelAction)action2).setChannelSet(((ParallelAction)action).getChannelSet()); ((ParallelAction)action2).setLeftNameSet(((ParallelAction)action).getLeftNameSet()); ((ParallelAction)action2).setRightNameSet(((ParallelAction)action).getRightNameSet()); } else if (action instanceof InterleaveAction) { ((InterleaveAction)action2).setLeftNameSet(((InterleaveAction)action).getLeftNameSet()); ((InterleaveAction)action2).setRightNameSet(((InterleaveAction)action).getRightNameSet()); } return action2; } else if (action instanceof SkipAction) { return f.createSkipAction(); } else if (action instanceof StopAction) { return f.createStopAction(); } else if (action instanceof ChaosAction) { return f.createChaosAction(); } else { //return f.createSkipAction(); return action; } } private static Vector toVectorString (Object [] o) { Vector vec = new Vector (); for (int i = 0; i < o.length; i++) { vec.addElement((String)o[i]); } return vec; } public static ActionPara similarExpandedAndRecursiveActionPara (ActionPara para, CircusProcess process, Spec spec) { Factory f = new Factory (); FactoryUtil fu = new FactoryUtil(); CircusAction action = para.getCircusAction(); action.getAnns().addAll(para.getCircusAction().getAnns()); Vector calls = toVectorString (calls (action, process, spec).keySet().toArray()); Consumer c = new Consumer (calls); Vector actionNames = new Vector (); String actionName = para.getZName().toString(); actionNames.addElement(actionName); if (calls.contains(para.getName().toString()) && !(action instanceof ParamAction) && !(para.getName().toString().contains("$$mainAction"))) { c.setStatus(Consumer.RECSTART, para.getName().toString()); MuAction mu = f.createMuAction(); mu.setName(f.createZName ("X" + para.getName().toString())); Vector mucalls = muCalls (action, process, spec); CircusAction action3 = fu.createCircusAction (expandAction (mucalls, actionNames, action, process, c, spec, new CallsAndParamsEnv ())); action3.getAnns().addAll(para.getCircusAction().getAnns()); mu.setCircusAction(action3); para.setCircusAction(mu); return para; } else { return para; } } //NOVOS MÉTODOS public static void expandCallsOnMainActions (Spec spec, boolean expanded) { ZSect zSect; if (spec.getSect().get(0) instanceof NarrSect) zSect = (ZSect) spec.getSect().get(1); else zSect = (ZSect) spec.getSect().get(0); ZParaList paras = (ZParaList) zSect.getParaList(); for (int i = 0; i < paras.size(); i++) { if (paras.get(i) instanceof ProcessPara) { ProcessPara para = (ProcessPara) paras.get(i); //Aqui vai invocar os visitadores dos paragrafos que nao forem narrativos (com texto), ou de tags de Latex String paraName = para.getZName().toString(); CircusProcess process = ((ProcessPara)para).getCircusProcess(); System.out.println (PrinterUtil.specAsString (spec)); expandCallsOnMainActions (process, paraName, spec); } } //expanded = true; } public static void transformActionParasToRecursive (ZParaList paralist, CircusProcess process, Spec spec) { int size = paralist.size(); FactoryUtil fu = new FactoryUtil (); for (int i = 0; i < size; i++) { Para para = paralist.get(i); if (para instanceof ActionPara) { String name = ((ActionPara)para).getZName().toString(); paralist.set(i, similarExpandedAndRecursiveActionPara ((ActionPara)para, process, spec)); System.out.print (""); } } System.out.print (""); } private static void expandCallsOnMainActions (CircusProcess process, String paraName, Spec spec) { FactoryUtil fu = new FactoryUtil (); if (process instanceof BasicProcess) { ZParaList paras = ((BasicProcess)process).getZParaList(); CircusAction mainactantes = ((BasicProcess)process).getMainAction(); //transformActionParasToRecursive (paras, process, spec); CircusAction mainAction = fu.createCircusAction (((BasicProcess)process).getMainAction()); Vector actionNames = new Vector (); actionNames.add(paraName); mainAction = expandAction (actionNames, mainAction, process, spec); ActionUtil.setOrAddValidMainActionPara (mainAction, (BasicProcess)process); System.out.println (PrinterUtil.specAsString(spec)); System.out.print(""); } else if (process instanceof Process2) { CircusProcess left = ((Process2)process).getLeftProcess(); CircusProcess right = ((Process2)process).getRightProcess(); expandCallsOnMainActions (left, paraName, spec); expandCallsOnMainActions (right, paraName, spec); } else if (process instanceof Process1) { CircusProcess process1 = ((Process1)process).getCircusProcess(); expandCallsOnMainActions (process1, paraName, spec); } else { //ExceptionUtil.throwImplementationException ("CallUtil.expandCallsOnMainActions", process.getClass ()); } } }