diff --git a/org.alloytools.alloy.application/src/main/java/ca/uwaterloo/watform/dash4whole/DashCopy.java b/org.alloytools.alloy.application/src/main/java/ca/uwaterloo/watform/dash4whole/DashCopy.java new file mode 100644 index 000000000..db3d4ab38 --- /dev/null +++ b/org.alloytools.alloy.application/src/main/java/ca/uwaterloo/watform/dash4whole/DashCopy.java @@ -0,0 +1,216 @@ +package ca.uwaterloo.watform.dash4whole; + +import java.util.*; + +import java.nio.file.Path; +import java.nio.file.Paths; +import java.nio.file.Files; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileWriter; + +import edu.mit.csail.sdg.alloy4.Version; + +import edu.mit.csail.sdg.alloy4.A4Reporter; +import edu.mit.csail.sdg.alloy4viz.VizGUI; +import edu.mit.csail.sdg.ast.Command; +import edu.mit.csail.sdg.parser.CompModule; +import edu.mit.csail.sdg.translator.A4Options; +import edu.mit.csail.sdg.translator.A4Solution; +import edu.mit.csail.sdg.translator.TranslateAlloyToKodkod; + +import ca.uwaterloo.watform.core.DashOptions; +import ca.uwaterloo.watform.core.DashErrors; +// import ca.uwaterloo.watform.parser.DashUtil; +import ca.uwaterloo.watform.core.DashUtilFcns; +import ca.uwaterloo.watform.parser.DashModule; +import ca.uwaterloo.watform.mainfunctions.MainFunctions; + + + + +public class DashCopy { + + public static void main(String args[]) throws Exception { + + if(args.length == 0) { + //System.out.println("Arguments: (-m traces|tcmc|electrum) (-single) (-reach) (-c #) (-p) (-t) (-r) filename(s)"); + System.out.println("Arguments: (-m traces|tcmc|electrum) (-c #) (-p) (-t) (-r) filename(s)"); + + System.out.println("-m traces|tcmc|electrum is verification method"); + //System.out.println("-single includes single event input fact"); + //System.out.println("-reach includes reachability fact (for tcmc only)"); + //System.out.println("-enough includes enoughOperations pred"); + System.out.println("-c # is cmdnum to execute"); + System.out.println("-t is translateOnly"); + System.out.println("-r is resolveOnly"); + System.out.println("-e is echo file from internal parsed data"); + System.out.println("expects .dsh or .als file"); + System.out.println("if given a .als files, it ignores other options and runs all its commands"); + System.exit(0); + } + + // simple roll-our-own argument parser + // to avoid having to import an external package + + List filelist = new ArrayList<>(); + + // default values + String method = "traces"; + Integer cmdnum = 0; + Boolean translateOnly = false; + Boolean printOnly = false; + Boolean resolveOnly = false; + + for (int i=0; i 0) { + System.err.println("Expected a Dash file with 'dsh' or 'als' extension: "+filename); + break; + } else { + filename = filename + ".dsh"; + } + } + + Path f = Paths.get(filename); + + if (Files.notExists(f)) { + System.err.println(filename + " : does not exist"); + return; + } + + Path directory = f.toAbsolutePath().getParent(); + if (directory.toString() != null) + DashOptions.dashModelLocation = directory.toString(); + + + System.out.println("Reading: " + filename ); + + A4Reporter rep = new A4Reporter(); + + if (filename.endsWith(".als")) { + try { + CompModule c = MainFunctions.parseAlloyFileAndResolveAll(filename, rep); + System.out.println("Parsed Alloy file"); + // will raise an exception if problems + System.out.println("Resolved Alloy file"); + executeCommands(c,cmdnum,rep); + } catch (Exception e) { + DashUtilFcns.handleException(e); + } + } + else { + try { + DashModule d = MainFunctions.parseDashFile(filename, rep); + System.out.println("Parsed Dash file"); + if (d == null) DashErrors.emptyFile(filename); + if (printOnly) { + System.out.println(d.toStringAlloy()); + } else { + d = MainFunctions.resolveDash(d, rep); + System.out.println("Resolved Dash"); + + DashModule dcopy = MainFunctions.copyDash(d); + System.out.println("Deep copy of Dash+ model created"); + } + } catch (Exception e) { + DashUtilFcns.handleException(e); + } + } + } + } + + @SuppressWarnings("resource" ) + + public static void executeCommands(CompModule c, Integer cmdnum, A4Reporter rep) { + // Choose some default options for how you want to execute the commands + A4Options options = new A4Options(); + + List commands = c.getAllCommands(); + // this is an annoying way to convert a list to an array + Integer i = 1; + for (Command cmd : commands) { + if (i == cmdnum | cmdnum == 0) { + System.out.println("Executing command: " + cmd); + A4Solution ans = null; + try { + ans = MainFunctions.executeCommand(cmd,c,rep, options); + } catch (Exception e) { + DashUtilFcns.handleException(e); + } + if (ans.satisfiable()) { + if (cmd.expects == 1) + System.out.println("Result: SAT (CORRECT)"); + else if (cmd.expects == 0) + System.out.println("Result: SAT (INCORRECT)"); + else + System.out.println("Result: SAT (nothing expected)"); + } else { + if (cmd.expects == 0) + System.out.println("Result: UNSAT (CORRECT)"); + else if (cmd.expects == 1) + System.out.println("Result: UNSAT (INCORRECT)"); + else + System.out.println("Result: UNSAT (nothing expected)"); + } + + } + i++; + } + if (cmdnum >= i) { + System.err.println("Command number: " + cmdnum + " does not exist in file"); + } + } +} + diff --git a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/alloyasthelper/ExprHelper.java b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/alloyasthelper/ExprHelper.java index 9a9657931..0ff97a4f5 100644 --- a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/alloyasthelper/ExprHelper.java +++ b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/alloyasthelper/ExprHelper.java @@ -557,4 +557,32 @@ else if (isExprBinary(exp) || isExprBadJoin(exp)) { return false; } } -} \ No newline at end of file + + + // implementing a copy constructor for Expr for deep copy + + public static Expr copyExpr(Expr e) { + if(isExprVar(e)) { + return createVar(getVarName((ExprVar) e)); + } + else if(isExprUnary(e)) { + return createUnaryExpr(getUnaryOp(e), getSub(e)); + } + else if(isExprBinary(e)) { + return createBinaryExpr(getLeft(e), getBinaryOp(e), getRight(e)); + } + else { + return e; + } + } +} + + + + + + + + + + diff --git a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/ast/DashExpr.java b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/ast/DashExpr.java index 08f184aea..39ce2ed4f 100644 --- a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/ast/DashExpr.java +++ b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/ast/DashExpr.java @@ -21,6 +21,12 @@ public DashExpr(Pos p, Expr e) { this.pos = p; this.exp = e; } + + //copy constructor + public DashExpr(DashExpr other) { + this.pos = other.pos; + this.exp = other.exp; + } public String toString(String name) { String s = new String(); s += name + " {\n"; diff --git a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/ast/DashInit.java b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/ast/DashInit.java index 0007497f1..2c5b73619 100644 --- a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/ast/DashInit.java +++ b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/ast/DashInit.java @@ -17,6 +17,11 @@ public class DashInit extends DashExpr { public DashInit(Pos p, Expr i) { super(p,i); } + // copy constructor + public DashInit(DashInit other) { + super(other.pos, other.exp); + } + public String toString() { return super.toString(DashStrings.initName); } diff --git a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/ast/DashInv.java b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/ast/DashInv.java index e4a2eb5fc..7d9b827ae 100644 --- a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/ast/DashInv.java +++ b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/ast/DashInv.java @@ -21,6 +21,17 @@ public DashInv(Pos p, String n, Expr inv) { this.name = n; } + // copy cons for deep copy + public DashInv(DashInv other) { + super(other.pos, other.exp); + if(other.name == null) { + this.name = new String(); + } + else { + this.name = new String(other.name); + } + } + public String toString() { return super.toString(DashStrings.invName + " "+name); } diff --git a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/ast/DashState.java b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/ast/DashState.java index 8287aa280..3c3982b2f 100644 --- a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/ast/DashState.java +++ b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/ast/DashState.java @@ -53,6 +53,32 @@ public DashState(Pos p, String n, String prm, DashStrings.StateKind k, DashStrin //System.out.println("here1 " + (this.param == null)); } + + // copy constructor for deep copy + public DashState(DashState other) { + this.pos = other.pos; + if(other.name == null) { + this.name = new String(); + } + else { + this.name = new String(other.name); + } + if(other.param == null) { + this.param = new String(); + } + else { + this.param = new String(other.param); + } + this.kind = other.kind; + this.def = other.def; + if(other.items == null) { + this.items = new ArrayList(); + } + else { + this.items = new ArrayList(other.items); + } + } + /* // basic state - default or non-default // 3 args diff --git a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/core/DashRef.java b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/core/DashRef.java index 909c61163..60fc9c941 100644 --- a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/core/DashRef.java +++ b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/core/DashRef.java @@ -105,6 +105,31 @@ public DashRef(Pos p, DashRefKind k, String n, List prmValues) { //return createJoin(processRef(), createJoinList(ll)); } + //copy constructor for deep copy + public DashRef(DashRef other) { + super(Pos.UNKNOWN, Type.FORMULA); + this.kind = other.kind; + if(other.name == null) { + this.name = new String(); + } + else { + this.name = new String(other.name); + } + if(other.paramValues == null) { + this.paramValues = new ArrayList(); + } + else { + this.paramValues = new ArrayList(other.paramValues); + } + } + + // default constructor for deep copy + public DashRef() { + super(Pos.UNKNOWN, Type.FORMULA); + this.name = ""; + this.paramValues = new ArrayList(); + } + public static DashRef createStateDashRef(Pos p, String n, List prmValues) { return new DashRef(p, DashRefKind.STATE,n, prmValues); } diff --git a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/mainfunctions/MainFunctions.java b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/mainfunctions/MainFunctions.java index 5668865d1..58c89766f 100644 --- a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/mainfunctions/MainFunctions.java +++ b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/mainfunctions/MainFunctions.java @@ -145,4 +145,36 @@ public static A4Solution executeCommand(Command cmd, CompModule alloy, A4Reporte A4Solution ans = TranslateAlloyToKodkod.execute_command(rep, alloy.getAllReachableSigs(), cmd, options); return ans; } -} \ No newline at end of file + + // creating a deep copy of a Dash+ model + public static DashModule copyDash(DashModule d) { + if(d == null){ + DashErrors.emptyModule(); + return d; + } + else { + + assert(d.hasRoot()); + + try { + + DashModule dcopy = new DashModule(d, ""); + return dcopy; + } + catch(Exception e) { + System.out.println("\nIn catch block of MainFunctions.copyDash() method\n"); + e.printStackTrace(System.out); + return null; + } + } + } +} + + + + + + + + + diff --git a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/parser/DashModule.java b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/parser/DashModule.java index 349994d3e..ad6e595a1 100644 --- a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/parser/DashModule.java +++ b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/parser/DashModule.java @@ -106,6 +106,30 @@ public DashModule(CompModule world, String filename, String path) { // this should be fine initializeDashModule(); } + + // Copy constructor to create deep copy + public DashModule(DashModule other, String filename) { + + super(null, filename, ""); + + this.root = new DashState(other.root); + + if(filename != null){ + this.filename = new String(filename); + } + else { + this.filename = new String(); + } + + this.stateTable = new StateTable(other.stateTable); + this.transTable = new TransTable(other.transTable); + this.eventTable = new EventTable(other.eventTable); + this.varTable = new VarTable(other.varTable); + this.predTable = new PredTable(other.predTable); + + initializeDashModule(); + } + private void initializeDashModule() { //assert (!DashOptions.isElectrum && (DashOptions.isTcmc || DashOptions.isTraces)); // do the open stmts for Dash after we know how many buffers @@ -711,6 +735,31 @@ public List getAllEnvironmentalEventNames() { return eventTable.getAllEnvironmentalEvents(); } + // for debugging + public String stateTableToString() { + return stateTable.toString(); + } + + public String transTableToString() { + return transTable.toString(); + } + + public String varTableToString() { + return varTable.toString(); + } + + public String predTableToString() { + return predTable.toString(); + } + + public String eventTableToString() { + return eventTable.toString(); + } + +} + + + + -} \ No newline at end of file diff --git a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/parser/EventTable.java b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/parser/EventTable.java index a04c13ef2..3bce5f4a1 100644 --- a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/parser/EventTable.java +++ b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/parser/EventTable.java @@ -2,6 +2,7 @@ import java.util.List; import java.util.ArrayList; +import java.util.Map; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.Collections; @@ -42,6 +43,21 @@ public EventElement( this.params = prms; this.paramsIdx = prmsIdx; } + + //copy constructor for deep copy + public EventElement(EventElement other) { + this.kind = other.kind; + if(other.params != null) { + this.params = new ArrayList(other.params); + this.paramsIdx = new ArrayList(other.paramsIdx); + } + else { + this.params = null; + this.paramsIdx = null; + } + } + + public String toString() { String s = new String(); s += "kind: "+kind+"\n"; @@ -55,6 +71,17 @@ public EventTable() { this.table = new LinkedHashMap(); } + + //copy constructor for deep copy + public EventTable(EventTable other) { + this.table = new LinkedHashMap(); + if(other.table != null) { + for (Map.Entry entry : other.table.entrySet()) { + this.table.put(new String(entry.getKey()), new EventElement(entry.getValue())); + } + } + } + public String toString() { String s = new String("EVENT TABLE\n"); for (String k:table.keySet()) { diff --git a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/parser/PredTable.java b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/parser/PredTable.java index d35e6596b..eb3439c20 100644 --- a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/parser/PredTable.java +++ b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/parser/PredTable.java @@ -2,6 +2,7 @@ import java.util.Set; import java.util.List; +import java.util.Map; import java.util.ArrayList; import java.util.HashMap; import java.util.LinkedHashMap; @@ -21,6 +22,7 @@ import static ca.uwaterloo.watform.core.DashStrings.*; import ca.uwaterloo.watform.core.DashRef; import ca.uwaterloo.watform.dashtoalloy.Common; +import ca.uwaterloo.watform.alloyasthelper.ExprHelper; import ca.uwaterloo.watform.parser.StateTable; import ca.uwaterloo.watform.parser.VarTable; @@ -33,6 +35,17 @@ public PredTable() { this.predTable = new LinkedHashMap(); } + //copy constructor for deep copy + public PredTable(PredTable other) { + this.predTable = new LinkedHashMap(); + + if(other.predTable != null){ + for (Map.Entry entry : other.predTable.entrySet()) { + this.predTable.put(new String(entry.getKey()), new PredElement(entry.getValue())); + } + } + } + public class PredElement implements Serializable { // this expression must be resolved in the context of the guard/action @@ -45,6 +58,12 @@ public PredElement( Expr e) { this.exp = e; } + + //copy constructor + public PredElement(PredElement other) { + this.exp = ExprHelper.copyExpr(other.exp); + } + public String toString() { String s = new String(); s += "exp: "+exp.toString() + "\n"; diff --git a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/parser/StateTable.java b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/parser/StateTable.java index 291f5684d..dd0759705 100644 --- a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/parser/StateTable.java +++ b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/parser/StateTable.java @@ -111,6 +111,85 @@ public StateElement( //this.conditions = condL; } + + // copy constructor to create a deep copy + public StateElement(StateElement other){ + + this.kind = other.kind; + if(other.param != null) { + this.param = new String(other.param); + } + else { + this.param = null; + } + + + if(other.params != null) { + this.params = new ArrayList(); + this.paramsIdx = new ArrayList(other.paramsIdx); + for(String s: other.params) { + this.params.add(new String(s)); + } + } + else { + this.params = null; + this.paramsIdx = null; + } + this.def = other.def; + + if(other.parent == null) { + this.parent = null; + } + else { + this.parent = new String(other.parent); + } + + + if(other.immChildren != null) { + this.immChildren = new ArrayList(); + for(String s: other.immChildren){ + this.immChildren.add(new String(s)); + } + } + else { + this.immChildren = null; + } + + if(other.origInvariants == null) { + this.origInvariants = null; + } + else { + this.origInvariants = new ArrayList(other.origInvariants); + } + if(other.origInits == null) { + this.origInits = null; + } + else { + this.origInits = new ArrayList(other.origInits); + } + + + if(other.entered != null) { + this.entered = new ArrayList(); + for(Expr e: other.entered){ + this.entered.add(ExprHelper.copyExpr(e)); + } + } + else { + this.entered = null; + } + + if(this.exited != null) { + this.exited = new ArrayList(); + for(Expr e: other.exited){ + this.exited.add(ExprHelper.copyExpr(e)); + } + } + else { + this.exited = null; + } + } + public String toString() { String s = new String(); s += "kind: "+kind +"\n"; @@ -131,6 +210,50 @@ public StateTable() { this.table = new HashMap(); this.isResolved = false; } + + //copy constructor for deep copy + public StateTable(StateTable other) { + this.isResolved = other.isResolved; + this.table = new HashMap(); + + if(other.table != null) { + for (HashMap.Entry entry : other.table.entrySet()) { + this.table.put(new String(entry.getKey()), new StateElement(entry.getValue())); + } + } + this.root = new String(other.root); + + if(other.inits != null) { + this.inits = new ArrayList(); + for(Expr e: other.inits) { + this.inits.add(ExprHelper.copyExpr(e)); + } + } + else { + this.inits = null; + } + + if(other.invs != null) { + this.invs = new ArrayList(); + for(Expr e: other.invs) { + this.invs.add(ExprHelper.copyExpr(e)); + } + } + else { + this.invs = null; + } + + if(other.allParamsInOrder != null){ + this.allParamsInOrder = new ArrayList(); + for(String s: other.allParamsInOrder) { + this.allParamsInOrder.add(new String(s)); + } + } + else { + this.allParamsInOrder = null; + } + } + public void setRoot(String s) { root = s; } diff --git a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/parser/TransTable.java b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/parser/TransTable.java index 68ed4e728..dc25afffe 100644 --- a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/parser/TransTable.java +++ b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/parser/TransTable.java @@ -77,6 +77,52 @@ public TransElement( this.sendList = sl; this.doList = dl; } + + //copy constructor for deep copy (after resolve) + public TransElement(TransElement other){ + if(other.src != null) { + this.src = new DashRef(other.src); + } + else { + this.src = null; + } + + if(other.dest != null) { + this.dest = new DashRef(other.dest); + } + else { + this.dest = null; + } + + if(other.when != null) { + this.when = ExprHelper.copyExpr(other.when); + } + else { + this.when = null; + } + + if(other.on != null) { + this.on = new DashRef(other.on); + } + else { + this.on = null; + } + + if(other.send != null) { + this.send = new DashRef(other.send); + } + else { + this.send = null; + } + + if(other.act != null) { + this.act = ExprHelper.copyExpr(other.act); + } + else { + this.act = null; + } + } + public String toString() { String s = new String(); s += "params: " + NoneStringIfNeeded(params) +"\n"; @@ -114,6 +160,19 @@ public TransTable() { table = new HashMap(); isResolved = false; } + + //copy constructor for deep copy + public TransTable(TransTable other) { + this.table = new HashMap(); + this.isResolved = other.isResolved; + + if(other.table != null) { + for (HashMap.Entry entry : other.table.entrySet()) { + this.table.put(new String(entry.getKey()), new TransElement(entry.getValue())); + } + } + } + public boolean add( String tfqn, List params, diff --git a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/parser/VarTable.java b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/parser/VarTable.java index a37258f9f..e1f0fa864 100644 --- a/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/parser/VarTable.java +++ b/org.alloytools.alloy.dash/src/main/java/ca/uwaterloo/watform/parser/VarTable.java @@ -2,6 +2,7 @@ import java.util.Set; import java.util.List; +import java.util.Map; import java.util.ArrayList; import java.util.HashMap; import java.util.LinkedHashMap; @@ -21,6 +22,7 @@ import static ca.uwaterloo.watform.core.DashStrings.*; import ca.uwaterloo.watform.core.DashRef; import ca.uwaterloo.watform.dashtoalloy.Common; +import ca.uwaterloo.watform.alloyasthelper.ExprHelper; import ca.uwaterloo.watform.parser.StateTable; import ca.uwaterloo.watform.parser.EventTable; @@ -40,6 +42,25 @@ public VarTable() { this.bufferTable = new LinkedHashMap(); } + //copy constructor for deep copy + public VarTable(VarTable other) { + this.varTable = new LinkedHashMap(); + + if(other.varTable != null){ + for (Map.Entry entry : other.varTable.entrySet()) { + this.varTable.put(new String(entry.getKey()), new VarElement(entry.getValue())); + } + } + + this.bufferTable = new LinkedHashMap(); + + if(other.bufferTable != null){ + for (Map.Entry entry : other.bufferTable.entrySet()) { + this.bufferTable.put(new String(entry.getKey()), new BufferElement(entry.getValue())); + } + } + } + public class VarElement implements Serializable { private IntEnvKind kind; private List params; @@ -57,6 +78,21 @@ public VarElement( this.paramsIdx = prmsIdx; this.typ = t; } + + //copy constructor for deep copy + public VarElement(VarElement other) { + this.kind = other.kind; + if(other.params != null) { + this.params = new ArrayList(other.params); + this.paramsIdx = new ArrayList(other.paramsIdx); + } + else { + this.params = null; + this.paramsIdx = null; + } + this.typ = other.typ; + } + public String toString() { String s = new String(); s += "kind: "+kind+"\n"; @@ -183,6 +219,27 @@ public BufferElement( this.element = e; this.index = idx; } + + //copy constructor for deep copy + public BufferElement(BufferElement other) { + this.kind = other.kind; + if(other.params != null) { + this.params = new ArrayList(other.params); + this.paramsIdx = new ArrayList(other.paramsIdx); + } + else { + this.params = null; + this.paramsIdx = null; + } + if(other.element != null){ + this.element = new String(other.element); + } + else { + other.element = new String(); + } + this.index = other.index; + } + public String toString() { String s = new String(); s += "kind: "+kind+"\n";