/trunk/compiler/ooasCompiler/src/org/momut/ooas/parser/ooaCustomParser.java - Diff - OoasTools - MoMuT Open Source Repository

Revision 9

Added by Willibald K. over 8 years ago

remove support for Qualitative Action Systems, rename UlyssesType to Type

     import org.momut.ooas.ast.expressions.ListConstructor;
     import org.momut.ooas.ast.expressions.MapConstructor;
     import org.momut.ooas.ast.expressions.ObjectConstructor;
     import org.momut.ooas.ast.expressions.QValConstructor;
     import org.momut.ooas.ast.expressions.Quantifier;
     import org.momut.ooas.ast.expressions.SetConstructor;
     import org.momut.ooas.ast.expressions.TernaryOperator;
-...
     import org.momut.ooas.ast.expressions.UnaryOperator;
     import org.momut.ooas.ast.expressions.UnresolvedIdentifierExpression;
     import org.momut.ooas.ast.expressions.ValueExpression;
     import org.momut.ooas.ast.expressions.QValConstructor.QValDeriv;
     import org.momut.ooas.ast.identifiers.AttributeIdentifier;
     import org.momut.ooas.ast.identifiers.ConstantIdentifier;
     import org.momut.ooas.ast.identifiers.EnumIdentifier;
-...
     import org.momut.ooas.ast.identifiers.Identifier;
     import org.momut.ooas.ast.identifiers.IdentifierKind;
     import org.momut.ooas.ast.identifiers.IdentifierList;
     import org.momut.ooas.ast.identifiers.LandmarkIdentifier;
     import org.momut.ooas.ast.identifiers.LocalVariableIdentifier;
     import org.momut.ooas.ast.identifiers.MainModule;
     import org.momut.ooas.ast.identifiers.MethodIdentifier;
-...
     import org.momut.ooas.ast.statements.KillStatement;
     import org.momut.ooas.ast.statements.NondetBlock;
     import org.momut.ooas.ast.statements.PrioBlock;
     import org.momut.ooas.ast.statements.QualitativeConstraintStatement;
     import org.momut.ooas.ast.statements.SeqBlock;
     import org.momut.ooas.ast.statements.SkipStatement;
     import org.momut.ooas.ast.statements.Statement;
     import org.momut.ooas.ast.statements.QualitativeConstraintStatement.QualitativeConstraintOperation;
     import org.momut.ooas.ast.types.AnyType;
     import org.momut.ooas.ast.types.BoolType;
     import org.momut.ooas.ast.types.CharType;
     import org.momut.ooas.ast.types.EnumType;
-...
     import org.momut.ooas.ast.types.MapType;
     import org.momut.ooas.ast.types.OoActionSystemType;
     import org.momut.ooas.ast.types.OpaqueType;
     import org.momut.ooas.ast.types.QrType;
     import org.momut.ooas.ast.types.TupleType;
     import org.momut.ooas.ast.types.TypeKind;
     import org.momut.ooas.ast.types.UlyssesType;
     import org.momut.ooas.ast.types.Type;
     import org.momut.ooas.ast.types.ValuedEnumType;
     import org.momut.ooas.ast.types.FunctionType.FunctionTypeEnum;
     import org.momut.ooas.utils.exceptions.ArgumentException;
-...
     				new ParserError(pState.filename, aToken, aMessage));
+    	}
     	/* add warning message to state */
     	private void doWarning(Token id1, String p)
+    	{
     		pState.AddWarningMessage(new ParserWarning(pState.filename, id1, p));
+    	}
     //	/* add warning message to state */
     //	private void doWarning(Token id1, String p)
     //	{
     //		pState.AddWarningMessage(new ParserWarning(pState.filename, id1, p));
     //	}
     	private void doError(String aMessage)
+    	{
-...
     	/* create a named type; we're on top-level here */
     	 void createNamedType(Token aName, UlyssesType aType)
     	 void createNamedType(Token aName, Type aType)
+    	{
     		// precond..
     		assert(aName != null);
-...
+    	}
     	/* add var symbol to the current action system */
     	void createAttribute(Token varname, boolean isStatic, boolean isObs, boolean isCtr, UlyssesType aType, Expression anExpr)
     	void createAttribute(Token varname, boolean isStatic, boolean isObs, boolean isCtr, Type aType, Expression anExpr)
+    	{
     		if (!TosIsActionSystem())
     			return;
-...
     	/* create an int type */
     	@SuppressWarnings("unchecked")
     	UlyssesType createIntType(Token rangeLow, Token rangeHigh)
     	Type createIntType(Token rangeLow, Token rangeHigh)
+    	{
     		int low = 0;
     		int high = 0;
-...
     	/* create a float type */
     	 @SuppressWarnings("unchecked")
     	UlyssesType createFloatType(Token rangeLow, Token rangeHigh)
     	Type createFloatType(Token rangeLow, Token rangeHigh)
+    	{
     		float low = 0;
     		float high = 0;
-...
+    	}
     	/* create a list of an enumerated type */
     	 UlyssesType createListEnumType(Token alistelem)
     	 Type createListEnumType(Token alistelem)
+    	{
     		final EnumType hiddenEnumType = new EnumType(null);
-...
+    	}
     	/* add a new enum symbol to a list with an anonymous enumerated type */
     	 void addToListEnumType(UlyssesType aTypeSymbol, Token otherlistelem)
     	 void addToListEnumType(Type aTypeSymbol, Token otherlistelem)
+    	{
     		final EnumType enumtype = (EnumType)((ListType)aTypeSymbol).innerType();
     		addToEnumType(enumtype, otherlistelem, null);
+    	}
     	/* create a new enumerated type */
     	 UlyssesType createEnumType(Token aRangeValue, Token anIntegerValue)
     	 Type createEnumType(Token aRangeValue, Token anIntegerValue)
+    	{
     		EnumType result;
-...
+    	}
     	/* add a new enum symbol to the enumerated type */
     	 void addToEnumType(UlyssesType aTypeSymbol, Token otherRangeValue, Token anIntegerValue)
     	 void addToEnumType(Type aTypeSymbol, Token otherRangeValue, Token anIntegerValue)
+    	{
     		final EnumType anEnum = (EnumType)aTypeSymbol;
     		if (anEnum.symbolTable().Defined(otherRangeValue.getText()))
-...
+    	}
     	/* get a named type */
     	 UlyssesType getNamedType(Token aType)
     	 Type getNamedType(Token aType)
+    	{
     		UlyssesType result = null;
     		Type result = null;
     		final Identifier sym = pState.Lookup(aType);
     		if (sym == null)
+    		{
-...
     	/* create a list type */
     	 @SuppressWarnings("unchecked")
     	UlyssesType createListType(Token numOfElements, UlyssesType innertype)
     	Type createListType(Token numOfElements, Type innertype)
+    	{
     		if (innertype == null)
     			doError(numOfElements, "List type lacks proper element type (null)");
-...
     	/* create a map type */
     	 @SuppressWarnings("unchecked")
     	UlyssesType createMapType(Token numOfElements, UlyssesType mapfromtype, UlyssesType maptotype)
     	Type createMapType(Token numOfElements, Type mapfromtype, Type maptotype)
+    	{
     		if (mapfromtype == null)
     			doError(numOfElements, "Map: From-type not set (null)");
-...
+    	}
     	/* create a tuple type */
     	 UlyssesType createTupleType(UlyssesType aType)
     	 Type createTupleType(Type aType)
+    	{
     		final TupleType result = new TupleType(null);
     		addToTupleType(result, aType);
-...
+    	}
     	/* add inner type to tuple */
     	 void addToTupleType(UlyssesType aTypeSymbol, UlyssesType anotherType)
     	 void addToTupleType(Type aTypeSymbol, Type anotherType)
+    	{
     		final TupleType tuple = (TupleType)aTypeSymbol;
     		if (anotherType != null)
-...
     			doError("Unknown inner type in tuple");
+    	}
     	/* create a QR type */
     	UlyssesType createQrType(Token alandmark)
+    	{
     		final QrType result = new QrType(null);
     		addToQrType(result, alandmark);
     		return result;
+    	}
     	/* add another landmark to QR type */
     	protected void addToQrType(UlyssesType aTypeSymbol, Token otherlandmark)
+    	{
     		final Identifier sym = pState.Lookup(otherlandmark);
     		if (sym != null)
+    		{
     			doError(otherlandmark, String.format("Redifinition of %s", otherlandmark.getText()));
     			return;
+    		}
     		final LandmarkIdentifier lndmrk = new LandmarkIdentifier(otherlandmark, (QrType)aTypeSymbol, GetScope());
     		((QrType)aTypeSymbol).AddLandmark(lndmrk);
+    	}
     	/* gets called after a simple type has been constructed. used to define an internal name*/
     	 void fixupSimpleType(UlyssesType aTypeSymbol)
     	 void fixupSimpleType(Type aTypeSymbol)
+    	{
     		if (aTypeSymbol != null)
     			aTypeSymbol.SetupAnonymousName();
+    	}
     	/* gets called after a simple or complex type has been constructed. used to define an internal name */
     	 void fixupComplexType(UlyssesType aTypeSymbol)
     	 void fixupComplexType(Type aTypeSymbol)
+    	{
     		if (aTypeSymbol != null)
     			aTypeSymbol.SetupAnonymousName();
-...
     			return null;
+    		}
     		final FunctionType funtype = new FunctionType(FunctionTypeEnum.Method, new LinkedList<UlyssesType>(), null);
     		final FunctionType funtype = new FunctionType(FunctionTypeEnum.Method, new LinkedList<Type>(), null);
     		final MethodIdentifier msym = new MethodIdentifier(mname, funtype, GetScope());
     		// funtype.SetTypeIdentifier(msym); -- the type of this function doesn't have a name!
-...
     	/* add a return type to a method */
     	 void setMethodReturnType(FunctionIdentifier newMethod, UlyssesType rt)
     	 void setMethodReturnType(FunctionIdentifier newMethod, Type rt)
+    	{
     		if (newMethod == null)
     			return;
-...
+    	}
     	/* add a parameter to a method */
     	 void addMethodParameter(FunctionIdentifier newMethod, Token paramName, UlyssesType atype)
     	 void addMethodParameter(FunctionIdentifier newMethod, Token paramName, Type atype)
+    	{
     		if (newMethod == null)
     			return;
-...
     			return null;
+    		}
     		final FunctionType atype = new FunctionType(actionType, new LinkedList<UlyssesType>(), null);
     		final FunctionType atype = new FunctionType(actionType, new LinkedList<Type>(), null);
     		final NamedActionIdentifier action = new NamedActionIdentifier(actionname, atype, GetScope());
     		// atype.SetTypeIdentifier(action); -- the type of this action doesn't have a name!
-...
+    	}
     	/* add block var */
     	 void addBlockVariable(Block seqList, Token varname, UlyssesType aType)
     	 void addBlockVariable(Block seqList, Token varname, Type aType)
+    	{
     		if (aType == null)
+    		{
-...
+    		}
+    	}
     	 QualitativeConstraintStatement createTwoVarConstraintStatement(Token id1, Token id2, QualitativeConstraintOperation op)
+    	{
     		Identifier var1 = pState.Lookup(id1);
     		if (var1 == null)
+    		{
     			var1 = new ExpressionVariableIdentifier(id1.getText(), id1.getLine(), id1.getCharPositionInLine());
     			var1.SetType(new AnyType((ExpressionVariableIdentifier)var1));
     			GetScope().AddIdentifier(var1, null);
     			doWarning(id1, String.format("Free variable in qualitative constraint: '%s'.", id1.getText()));
+    		}
     		Identifier var2 = pState.Lookup(id2);
     		if (var2 == null)
+    		{
     			var2 = new ExpressionVariableIdentifier(id2.getText(), id2.getLine(), id2.getCharPositionInLine());
     			var2.SetType(new AnyType((ExpressionVariableIdentifier)var2));
     			GetScope().AddIdentifier(var2, null);
     			doWarning(id1, String.format("Free variable in qualitative constraint: '%s'.", id2.getText()));
+    		}
     		final QualitativeConstraintStatement result = new QualitativeConstraintStatement(var1, var2, op, id1.getLine(), id1.getCharPositionInLine());
     		return result;
+    	}
     	 QualitativeConstraintStatement createQualEqualConstraintStatement(Token id1, Token id2)
+    	{
     		return createTwoVarConstraintStatement(id1, id2, QualitativeConstraintOperation.Equal);
+    	}
     	 QualitativeConstraintStatement createQualArithConstraintStatement(Token id1, Token id2, Token id3, Token op)
+    	{
     		Identifier var1 = pState.Lookup(id1);
     		if (var1 == null)
+    		{
     			var1 = new ExpressionVariableIdentifier(id1.getText(), id1.getLine(), id1.getCharPositionInLine());
     			var1.SetType(new AnyType((ExpressionVariableIdentifier)var1));
     			GetScope().AddIdentifier(var1, null);
     			doWarning(id1, String.format("Free variable in qualitative constraint: '%s'.", id1.getText()));
+    		}
     		Identifier var2 = pState.Lookup(id2);
     		if (var2 == null)
+    		{
     			var2 = new ExpressionVariableIdentifier(id2.getText(), id2.getLine(), id2.getCharPositionInLine());
     			var2.SetType(new AnyType((ExpressionVariableIdentifier)var2));
     			GetScope().AddIdentifier(var2, null);
     			doWarning(id1, String.format("Free variable in qualitative constraint: '%s'.", id2.getText()));
+    		}
     		Identifier var3 = pState.Lookup(id3);
     		if (var3 == null)
+    		{
     			var3 = new ExpressionVariableIdentifier(id3.getText(), id3.getLine(), id3.getCharPositionInLine());
     			var3.SetType(new AnyType((ExpressionVariableIdentifier)var3));
     			GetScope().AddIdentifier(var3, null);
     			doWarning(id1, String.format("Free variable in qualitative constraint: '%s'.", id3.getText()));
+    		}
     		QualitativeConstraintOperation operation;
     		switch (op.getType())
+    		{
     		case ooaParser.T_SUM:
     			operation = QualitativeConstraintOperation.Sum;
     			break;
     		case ooaParser.T_DIFF:
     			operation = QualitativeConstraintOperation.Diff;
     			break;
     		case ooaParser.T_PROD:
     			operation = QualitativeConstraintOperation.Prod;
     			break;
     		default:
     			doError(op, String.format("'%s' unknown operation", op.getText()));
     			return null;
+    		}
     		final QualitativeConstraintStatement result = new QualitativeConstraintStatement(var1, var2, var3, operation, id1.getLine(), id1.getCharPositionInLine());
     		return result;
+    	}
     	 QualitativeConstraintStatement createQualDerivConstraintStatement(Token id1, Token derivid)
+    	{
     		return createTwoVarConstraintStatement(id1, derivid, QualitativeConstraintOperation.Deriv);
+    	}
     	/* creates a general binary operator without any children */
     	 BinaryOperator createBinaryOperator(ExpressionKind akind)
+    	{
-...
+    	}
     	/* add a bound variable to the quantifier */
     	 void addBoundVarToQuantifierExpression(Quantifier result, Token id, UlyssesType id_type)
     	 void addBoundVarToQuantifierExpression(Quantifier result, Token id, Type id_type)
+    	{
     		/*note: this might be a bit harsh, but for now it's easier to demand uniquely named vars,
                     without any hiding. Could be fixed in searching only the first resolve level for
-...
+    	}
     	/* add list comprehension variable */
     	 void addListComprVar(ListConstructor result, Token id, UlyssesType t1)
     	 void addListComprVar(ListConstructor result, Token id, Type t1)
+    	{
     		final Identifier sym = pState.Lookup(id);
     		if (sym != null)
-...
+    	}
     	/* add local set compr. variable */
     	 void addSetComprVar(SetConstructor _set, Token id1, UlyssesType t1)
     	 void addSetComprVar(SetConstructor _set, Token id1, Type t1)
+    	{
     		final Identifier sym = pState.Lookup(id1);
     		if (sym != null)
-...
     		return new ObjectConstructor(atype, aname.getText(), anid.getLine(), anid.getCharPositionInLine());
+    	}
     	 void setQualitativeDerivDec(QValConstructor result)
+    	{
     		result.SetDerivation(QValDeriv.Dec);
+    	}
     	 void setQualitativeDerivInc(QValConstructor result)
+    	{
     		result.SetDerivation(QValDeriv.Inc);
+    	}
     	 void setQualitativeDerivSteady(QValConstructor result)
+    	{
     		result.SetDerivation(QValDeriv.Steady);
+    	}
     	 void setQualitativeDerivDontCare(QValConstructor result)
+    	{
     		result.SetDerivation(QValDeriv.DonTCare);
+    	}
     	 void setQualitativeValueRangeInfinity(QValConstructor result, boolean p)
+    	{
     		throw new NotImplementedException();
+    	}
     	 void setQualitativeValueRange(QValConstructor result, Expression expr2)
+    	{
     		result.AddRange(expr2);
+    	}
     	 void setQualitativeValueInfinity(QValConstructor result, boolean minus)
+    	{
     		throw new NotImplementedException();
+    	}
     	 void setQualitativeValueLandmark(QValConstructor result, Expression expr)
+    	{
     		result.SetValue(expr);
+    	}
     	 void setQualitativeValueDontCare(QValConstructor result)
+    	{
     		throw new NotImplementedException();
+    	}
     	 QValConstructor createQualitativeValue(Token aval)
+    	{
     		return new QValConstructor(aval.getLine(), aval.getCharPositionInLine());
+    	}
     	/* add a local variable to a named action */
     	 void addLocalVariableToNamedAction(FunctionIdentifier newMethod, Token id1, UlyssesType t1)
     	 void addLocalVariableToNamedAction(FunctionIdentifier newMethod, Token id1, Type t1)
+    	{
     		if (t1 == null)
+    		{

Also available in: Unified diff

Project

General

Profile

OoasTools

Revision 9

Added by Willibald K. over 8 years ago