this.state = state;
State.currentState = state;
- // Don't clear the state!! Do clear the IR-related state
- this.state.stTypes = null;
-
if (er == null) {
throw new IRException("IRBuilder.build: Received null ErrorReporter");
} else {
} else {
rule.addQuantifier(quantifier);
}
- }
+ }
}
/* get guard expr */
boolean ok = true;
ParseNodeVector constraints = pn.getChildren();
-
+
for (int i = 0; i < constraints.size(); i++) {
ParseNode constraint = constraints.elementAt(i);
assert constraint.getLabel().equals("constraint");
}
/* do any post checks... (type constraints, etc?) */
-
- return ok;
+
+ Iterator consiterator = state.vConstraints.iterator();
+
+ while (consiterator.hasNext()) {
+ Constraint cons = (Constraint) consiterator.next();
+
+ final SymbolTable consst = cons.getSymbolTable();
+ SemanticAnalyzer sa = new SemanticAnalyzer() {
+ public IRErrorReporter getErrorReporter() { return er; }
+ public SymbolTable getSymbolTable() { return consst; }
+ };
+
+ TypeDescriptor constype = cons.getLogicStatement().typecheck(sa);
+
+ if (constype == null) {
+ System.out.println("Failed attempting to type constraint");
+ ok = false;
+ } else if (constype != ReservedTypeDescriptor.INT) {
+ er.report(null, "Type of guard must be 'int' not '" + constype.getSymbol() + "'");
+ ok = false;
+ }
+ }
+
+ return ok;
}
private boolean parse_constraint(ParseNode pn) {
assert qn.getLabel().equals("quantifier");
Quantifier quantifier = parse_quantifier(qn);
if (quantifier == null) {
+ System.out.println("Failed parsing quantifier");
ok = false;
} else {
constraint.addQuantifier(quantifier);
}
}
}
-
+
/* get body */
LogicStatement logicexpr = parse_body(pn.getChild("body"));
if (logicexpr == null) {
+ System.out.println("Failed parsing logical expression");
ok = false;
} else {
constraint.setLogicStatement(logicexpr);
assert sts.empty();
/* add to vConstraints */
- vConstraints.addElement(constraint);
+ vConstraints.addElement(constraint);
return ok;
}
SetDescriptor set = parse_set(pn.getChild("set"));
assert set != null;
sq.setSet(set);
+ vd.setSet(set);
vd.setType(set.getType());
/* return to caller */
return sq;
- } else if (pn.getChild("relatiion") != null) { /* for < v1, v2 > in Relation */
+ } else if (pn.getChild("relation") != null) { /* for < v1, v2 > in Relation */
RelationQuantifier rq = new RelationQuantifier();
/* get vars */
rq.setRelation(rd);
vd1.setType(rd.getDomain().getType());
+ vd1.setSet(rd.getDomain());
vd2.setType(rd.getRange().getType());
+ vd2.setSet(rd.getRange());
return rq;
} else if (pn.getChild("for") != null) { /* for j = x to y */
ForQuantifier fq = new ForQuantifier();
/* grab var */
VarDescriptor vd = reserveName(pn.getChild("var"));
-
+
if (vd == null) {
return null;
}
+ vd.setSet(lookupSet("int", false));
vd.setType(ReservedTypeDescriptor.INT);
fq.setVar(vd);
Expr lower = parse_expr(pn.getChild("lower").getChild("expr"));
Expr upper = parse_expr(pn.getChild("upper").getChild("expr"));
+
if ((lower == null) || (upper == null)) {
return null;
}
-
+ vd.setBounds(lower,upper);
fq.setBounds(lower, upper);
return fq;
} else {
throw new IRException("not supported yet");
}
-
}
private LogicStatement parse_body(ParseNode pn) {
return new LogicStatement(LogicStatement.OR, left, right);
} else if (pn.getChild("not") != null) {
/* NOT body */
- LogicStatement left = parse_body(pn.getChild("not").getChild("left").getChild("body"));
+ LogicStatement left = parse_body(pn.getChild("not").getChild("body"));
if (left == null) {
return null;
if (pn.getChild("inclusion") != null) {
ParseNode in = pn.getChild("inclusion");
- /* get quantiifer var */
- VarDescriptor vd = parse_quantifiervar(in.getChild("quantifiervar"));
+ /* Expr */
+ Expr expr = parse_expr(in.getChild("expr"));
- if (vd == null) {
+ if (expr == null) {
return null;
}
return null;
}
- return new InclusionPredicate(vd, setexpr);
- } else if (pn.getChild("sizeof") != null) {
- ParseNode sizeof = pn.getChild("sizeof");
+ return new InclusionPredicate(expr, setexpr);
+ } else if (pn.getChild("expr") != null) {
+ Expr expr = parse_expr(pn.getChild("expr"));
- /* get set expr */
- SetExpr setexpr = parse_setexpr(sizeof.getChild("setexpr"));
-
- if (setexpr == null) {
- return null;
- }
-
- /* get comparison operator */
- String compareop = sizeof.getChild("compare").getTerminal();
- Opcode opcode = Opcode.decodeFromString(opname);
-
- if (opcode == null) {
- er.report(pn, "Unsupported operation: " + opname);
- return null;
- }
-
-
-
- return new InclusionPredicate(vd, setexpr);
- } else if (pn.getChild("comparison") != null) {
- ParseNode cn = pn.getChild("comparison");
-
- /* get the expr's */
- Expr left = parse_expr(cn.getChild("left").getChild("expr"));
- Expr right = parse_expr(cn.getChild("right").getChild("expr"));
-
- if ((left == null) || (right == null)) {
+ if (expr == null) {
return null;
}
- /* get comparison operator */
- String comparison = cn.getChild("compare").getTerminal();
- assert comparison != null;
-
- return new ComparisonPredicate(comparison, left, right);
+ return new ExprPredicate(expr);
} else {
throw new IRException();
}
String rangesetname = pn.getChild("range").getChild("type").getTerminal();
assert rangesetname != null;
- /* get domain multiplicity */
- String domainmult = pn.getChild("domain").getChild("mult").getTerminal();
- assert domainmult != null;
+ /* get domain multiplicity */
+ String domainmult;
+ if (pn.getChild("domain").getChild("domainmult") != null)
+ domainmult = pn.getChild("domain").getChild("domainmult").getChild("mult").getTerminal();
+ //assert domainmult != null;
/* get range multiplicity */
- String rangemult = pn.getChild("range").getChild("mult").getTerminal();
- assert rangemult != null;
+ String rangemult;
+ if (pn.getChild("range").getChild("domainrange") != null)
+ rangemult = pn.getChild("range").getChild("domainrange").getChild("mult").getTerminal();
+ //assert rangemult != null;
/* NOTE: it is assumed that the sets have been parsed already so that the
set namespace is fully populated. any missing setdescriptors for the set
} else if (t instanceof StructureTypeDescriptor) {
StructureTypeDescriptor type = (StructureTypeDescriptor) t;
- TypeDescriptor subtype = type.getSubType();
+ TypeDescriptor subtype = type.getSuperType();
// check that the subtype is valid
if (subtype instanceof MissingTypeDescriptor) {
er.report(null, "Undefined subtype '" + subtype.getSymbol() + "'");
ok = false;
} else {
- type.setSubType(newtype);
+ type.setSuperType(newtype);
}
}
if (newtype == null) {
// type never defined
// #TBD#: replace new ParseNode with original parsenode
- er.report(null, "Undefined type '" + fieldtype.getSymbol() + "'");
- ok = false;
+
+ if (!field.getPtr()) {
+ /* Pointer types don't have to be defined */
+ er.report(null, "Undefined type '" + fieldtype.getSymbol() + "'");
+ ok = false;
+ }
} else {
assert newtype != null;
field.setType(newtype);
}
- }
+ }
}
Iterator labels = type.getLabels();
} else if (t instanceof StructureTypeDescriptor) {
StructureTypeDescriptor type = (StructureTypeDescriptor)t;
- TypeDescriptor subtype = type.getSubType();
+ TypeDescriptor subtype = type.getSuperType();
Iterator fields = type.getFields();
while (fields.hasNext()) {
}
}
}
-
- } else {
+ } else {
throw new IRException("shouldn't be any other typedescriptor classes");
}
-
}
// #TBD#: need to make sure that no cycles exist in any of the declarations or subtypes
return false;
}
- stGlobals.add(new VarDescriptor(name, name, td));
+ stGlobals.add(new VarDescriptor(name, name, td,true));
return true;
}
}
/* lookup the type to get the type descriptor */
- type.setSubType(lookupType(subtype, CREATE_MISSING));
+ type.setSuperType(lookupType(subtype, CREATE_MISSING));
+ } else if (pn.getChild("subclass") != null) {
+ // has a subtype, lets try to resolve it
+ String subclass = pn.getChild("subclass").getTerminal();
+
+ if (subclass.equals(typename)) {
+ // Semantic Error: cyclic inheritance
+ er.report(pn, "Cyclic inheritance prohibited");
+ ok = false;
+ }
+
+ /* lookup the type to get the type descriptor */
+ type.setSuperType(lookupType(subclass, CREATE_MISSING));
+ type.setSubClass(true);
}
// set the current type so that the recursive parses on the labels
return null;
}
- RelationExpr re = new RelationExpr();
+ String relname = pn.getChild("name").getTerminal();
+ boolean inverse = pn.getChild("inv") != null;
+ Expr expr = parse_expr(pn.getChild("expr"));
- /* get quantitifer var */
- VarDescriptor vd = parse_quantifiervar(pn.getChild("quantifiervar"));
-
- if (vd == null) {
+ if (expr == null) {
return null;
}
-
- // #TBD#: bad name
- re.setDomain(vd);
-
- /* grab list of relations */
- ParseNodeVector relations = pn.getChild("relations").getChildren();
- assert relations.size() >= 1;
-
- // #TBD#: verify that the relations are in the correct order and that the
- // first relation is getting the correct "inv" assigned from "expr"
-
- /* lets verify that these relations are defined */
- for (int i = 0; i < relations.size(); i++) {
- ParseNode rn = relations.elementAt(i);
- String relname = rn.getLabel();
- boolean inverse = rn.getChild("inv") != null;
-
- RelationDescriptor relation = lookupRelation(relname);
+
+ RelationDescriptor relation = lookupRelation(relname);
- if (relation == null) {
- /* Semantic Error: relation not definied" */
- er.report(rn, "Undefined relation '" + relname + "'");
- return null;
- }
+ if (relation == null) {
+ /* Semantic Error: relation not definied" */
+ er.report(pn, "Undefined relation '" + relname + "'");
+ return null;
+ }
- re.setRelation(relation, inverse);
+ /* add usage so correct sets are created */
+ relation.addUsage(inverse ? RelationDescriptor.INVIMAGE : RelationDescriptor.IMAGE);
- /* if we are not at end of list then create new relation and
- replace it to chain the relations */
- if (i + 1 < relations.size()) {
- re = new RelationExpr(re); // should create relation with domain as older 're'
- }
- }
-
- return re;
+ return new RelationExpr(expr, relation, inverse);
}
private SizeofExpr parse_sizeof(ParseNode pn) {
} else if (pn.getChild("dot") != null) {
VarDescriptor vd = parse_quantifiervar(pn.getChild("dot").getChild("quantifiervar"));
RelationDescriptor relation = lookupRelation(pn.getChild("dot").getChild("relation").getTerminal());
+ relation.addUsage(RelationDescriptor.IMAGE);
return new ImageSetExpr(vd, relation);
} else if (pn.getChild("dotinv") != null) {
VarDescriptor vd = parse_quantifiervar(pn.getChild("dotinv").getChild("quantifiervar"));
RelationDescriptor relation = lookupRelation(pn.getChild("dotinv").getChild("relation").getTerminal());
+ relation.addUsage(RelationDescriptor.INVIMAGE);
return new ImageSetExpr(ImageSetExpr.INVERSE, vd, relation);
+ } else if (pn.getChild("dotset") != null) {
+ ImageSetExpr ise = (ImageSetExpr) parse_setexpr(pn.getChild("dotset").getChild("setexpr"));
+ RelationDescriptor relation = lookupRelation(pn.getChild("dotset").getChild("relation").getTerminal());
+ relation.addUsage(RelationDescriptor.IMAGE);
+ return new ImageSetExpr(ise, relation);
+ } else if (pn.getChild("dotinvset") != null) {
+ ImageSetExpr ise = (ImageSetExpr) parse_setexpr(pn.getChild("dotinvset").getChild("setexpr"));
+ RelationDescriptor relation = lookupRelation(pn.getChild("dotinvset").getChild("relation").getTerminal());
+ relation.addUsage(RelationDescriptor.INVIMAGE);
+ return new ImageSetExpr(ImageSetExpr.INVERSE, ise, relation);
} else {
throw new IRException();
}
/* do semantic check and if valid, add it to symbol table
and add it to the quantifier as well */
if (sts.peek().contains(varname)) {
- return new VarDescriptor(varname);
+ VarDescriptor vdold=(VarDescriptor)sts.peek().get(varname);
+ return vdold;
+ /* Dan was creating a new VarDescriptor...This seems
+ like the wrong thing to do. We'll just lookup the
+ other one.
+ --------------------------------------------------
+ VarDescriptor vd=new VarDescriptor(varname);
+ vd.setSet(vdold.getSet()); return vd;*/
} else {
/* Semantic Error: undefined variable */
er.report(pn, "Undefined variable '" + varname + "'");
projects / repair.git / blobdiff