public CoreClassifier parseType(
EnvironmentImpl environment,
string name)
{
CSTNode node = null;
List <object> nodes = null;
try {
nodes = compileOclStream(name, "", new StreamWriter(new MemoryStream()), typeof(CSTTypeCS));
node = (CSTNode)nodes[0];
} catch (Exception e) {
Console.WriteLine(e.Message);
}
if (node != null)
{
CSTTypeCS typeNode = (CSTTypeCS)node;
parsedTypes.Add(typeNode.getAst().getFullPathName(), nodes);
return(typeNode.getAst());
}
else
{
return(null);
}
}
private CoreClassifier checkResult(CSTNode rootNode, String expectedTypeName)
{
CSTArgumentCS argument = (CSTArgumentCS)rootNode;
OclExpression ast = argument.getAst();
Assert.AreEqual(expectedTypeName, ast.getType().getName());
return(ast.getType());
}
protected VariableDeclaration getVariableDeclaration(String literal)
{
CSTNode node = parseOK(literal, this.getCurrentMethodName());
Assert.IsTrue(node is CSTVariableDeclarationCS);
CSTVariableDeclarationCS variable = (CSTVariableDeclarationCS)node;
return((VariableDeclaration)variable.getAst());
}
public CollectionLiteralExp doTestOK(String literal)
{
CSTNode node = parseOK(literal, this.getCurrentMethodName());
Assert.IsTrue(node is CSTCollectionLiteralExpCS);
CSTCollectionLiteralExpCS literalExp = (CSTCollectionLiteralExpCS)node;
Assert.IsNotNull(literalExp.getAst());
Assert.IsTrue(literalExp.getAst() is CollectionLiteralExp);
return((CollectionLiteralExp)literalExp.getAst());
}
public TupleLiteralExp doTestOK(String literal, String typeName, String callerMethodName)
{
CSTNode node = parseOK(literal, callerMethodName);
Assert.IsTrue(node is CSTTupleLiteralExpCS);
CSTTupleLiteralExpCS literalExp = (CSTTupleLiteralExpCS)node;
Assert.IsNotNull(literalExp.getAst());
Assert.IsTrue(literalExp.getAst() is TupleLiteralExp);
Assert.AreEqual(typeName, literalExp.getAst().getType().getName());
return((TupleLiteralExp)literalExp.getAst());
}
protected virtual List <object> getConstraints(CSTNode rootNode)
{
if (rootNode is CSTClassifierContextDeclCS)
{
CSTClassifierContextDeclCS context = (CSTClassifierContextDeclCS)rootNode;
List <object> constraints = context.getConstraintsNodesCS();
return(constraints);
}
else
{
return(null);
}
}
protected List <object> parseNode(OCLWorkbenchParser parser, Type nodeClass)
{
List <object> result = null;
CSTNode node = null;
if (nodeClass == null)
{
result = parser.expressionStream();
}
else if (nodeClass == typeof(CSTExpressionInOclCS))
{
node = parser.expressionInOCLCS();
}
else if (nodeClass == typeof(CSTTypeCS))
{
node = parser.typeCS();
}
else if (nodeClass == typeof(CSTContextDeclarationCS))
{
node = parser.contextDeclarationCS();
}
else if (nodeClass == typeof(CSTArgumentCS))
{
List <object> arguments = parser.argumentsCS();
node = (CSTNode)arguments[0];
}
else if (nodeClass == typeof(CSTLiteralExpCS))
{
node = parser.literalExpCS();
}
else if (nodeClass == typeof(CSTVariableDeclarationCS))
{
node = parser.variableDeclarationCS();
}
else if (nodeClass == typeof(CSTVariableDeclarationCS))
{
node = parser.variableDeclarationCS();
}
else if (nodeClass == typeof(CSTClassifierAttributeCallExpC))
{
node = parser.classifierAttributeCallExpCS();
}
if ((result == null) && (node != null))
{
result = new List <object>();
result.Add(node);
}
return(result);
}
protected List <object> doTestContextOK(String expression, String testName)
{
source = testName;
CSTNode rootNode = parseOK(expression, testName);
Assert.IsNotNull(rootNode);
if (rootNode != null)
{
return(getConstraints(rootNode));
}
else
{
return(null);
}
}
private void doTestPackageOK(String expression, String testName)
{
try {
rootNode = getRootNode(expression, testName);
oclSemanticAnalyzer.analyze(environment, rootNode);
}
catch (OCLSemanticException ex) {
OCLWorkbenchToken token = ex.getNode().getToken();
Console.WriteLine(token.getFilename() + ":" + token.getLine() + "[" + token.getColumn() + "]" + ex.Message);
throw new AssertFailedException();
}
catch (Exception e) {
Console.WriteLine(e.Message);
throw new AssertFailedException();
}
}
public void doTestEnumOK(String enumFullName, String enumName, String enumLiteral, String source)
{
CSTNode node = parseOK(enumFullName + "::" + enumLiteral, source);
Assert.IsTrue(node is CSTClassifierAttributeCallExpCS);
CSTClassifierAttributeCallExpCS literalExp = (CSTClassifierAttributeCallExpCS)node;
Assert.IsNotNull(literalExp.getAst());
Assert.IsTrue(literalExp.getAst() is EnumLiteralExp);
EnumLiteralExp ast = (EnumLiteralExp)literalExp.getAst();
Assert.AreEqual(enumLiteral, ast.getReferredEnumLiteral().getName());
Assert.IsNotNull(ast.getType());
Assert.AreEqual(enumName, ast.getType().getName());
}
private void doTestReal(String expectedValueStr, double expectedValue)
{
CSTNode node = parseOK(expectedValueStr, this.getCurrentMethodName());
Assert.IsTrue(node is CSTRealLiteralExpCS);
CSTRealLiteralExpCS literalExp = (CSTRealLiteralExpCS)node;
Assert.IsNotNull(literalExp.getAst());
Assert.IsTrue(literalExp.getAst() is RealLiteralExp);
RealLiteralExp ast = (RealLiteralExp)literalExp.getAst();
Assert.AreEqual(expectedValue, Double.Parse(ast.getRealSymbol(), CultureInfo.InvariantCulture));
CoreClassifier type = ast.getType();
Assert.IsNotNull(type);
Assert.AreEqual("Real", type.getName());
}
private void doTestString(String input, String expectedValue)
{
CSTNode node = parseOK(input, this.getCurrentMethodName());
Assert.IsTrue(node is CSTStringLiteralExpCS);
CSTStringLiteralExpCS literalExp = (CSTStringLiteralExpCS)node;
Assert.IsNotNull(literalExp.getAst());
Assert.IsTrue(literalExp.getAst() is StringLiteralExp);
StringLiteralExp ast = (StringLiteralExp)literalExp.getAst();
Assert.AreEqual(expectedValue, ast.getStringSymbol());
CoreClassifier type = ast.getType();
Assert.IsNotNull(type);
Assert.AreEqual("String", type.getName());
}
public void testClassifier_05()
{
try {
rootNode = getRootNode("package MyExample::package_1::package_1_1 context Product inv: expression context Rental inv: exp context Film inv: exp context Product inv: expression endpackage" +
" package java context Integer inv: expression endpackage", "testClassifier_05");
oclSemanticAnalyzer.analyze(environment, rootNode);
}
catch (OCLSemanticException ex) {
OCLWorkbenchToken token = ex.getNode().getToken();
Console.WriteLine(token.getFilename() + ":" + token.getLine() + "[" + token.getColumn() + "]" + ex.Message);
throw new AssertFailedException();
}
catch (Exception e) {
Console.WriteLine(e.Message);
throw new AssertFailedException();
}
}
private void doTestBoolean(bool expectedValue)
{
CSTNode node = parseOK(expectedValue.ToString().ToLower(), this.getCurrentMethodName());
Assert.IsTrue(node is CSTBooleanLiteralExpCS);
CSTBooleanLiteralExpCS literalExp = (CSTBooleanLiteralExpCS)node;
Assert.IsNotNull(literalExp.getAst());
Assert.IsTrue(literalExp.getAst() is BooleanLiteralExp);
BooleanLiteralExp ast = (BooleanLiteralExp)literalExp.getAst();
Assert.AreEqual(expectedValue, ast.isBooleanSymbol());
CoreClassifier type = ast.getType();
Assert.IsNotNull(type);
Assert.AreEqual("Boolean", type.getName());
}
private void doTestInteger(int expectedValue)
{
CSTNode node = parseOK(expectedValue.ToString(CultureInfo.InvariantCulture), this.getCurrentMethodName());
Assert.IsTrue(node is CSTIntegerLiteralExpCS);
CSTIntegerLiteralExpCS literalExp = (CSTIntegerLiteralExpCS)node;
Assert.IsNotNull(literalExp.getAst());
Assert.IsTrue(literalExp.getAst() is IntegerLiteralExp);
IntegerLiteralExp ast = (IntegerLiteralExp)literalExp.getAst();
Assert.AreEqual(expectedValue, ast.getIntegerSymbol());
CoreClassifier type = ast.getType();
Assert.IsNotNull(type);
Assert.AreEqual("Integer", type.getName());
}
private CSTNode getClassifierRootNode(String source, String inputName)
{
OCLWorkbenchParser parser;
StreamWriter err;
StringReader inR = new StringReader(source);
String inName = inputName;
err = new StreamWriter(Console.OpenStandardOutput());
err.Flush();
HashSet <Exception> errorsList = new HashSet <Exception>();
OCLWorkbenchLexer lexer = new OCLWorkbenchLexer(inR, inName, err, errorsList);
parser = new OCLWorkbenchParser(inName, lexer, err, errorsList);
CSTNode result = null;
try {
result = parser.contextDeclarationCS();
} catch (antlr.RecognitionException e) {
err.WriteLine(parser.getFilename() + ":" +
"[" + e.getLine() + ", " + e.getColumn() + "]: " +
e.Message);
throw e;
} catch (antlr.TokenStreamRecognitionException e) {
err.WriteLine(parser.getFilename() + ":" +
"[" + e.recog.getLine() + ", " + e.recog.getColumn() + "]: " +
e.recog.Message);
throw e;
} catch (antlr.TokenStreamException ex) {
err.WriteLine(parser.getFilename() + ":" + ex.Message);
throw ex;
} finally {
err.Flush();
}
if (parser.getErrorCount() != 0)
{
throw new Exception("syntatic errors in compilation");
}
return(result);
}
public CoreClassifier doParseTestOK(String stream, String inputName, String resultName, Type className)
{
try {
CSTNode node = parseOK(stream, inputName);
Assert.IsTrue(node is CSTTypeCS);
CSTTypeCS type = (CSTTypeCS)node;
CoreClassifier ast = type.getAst();
Assert.IsNotNull(ast);
Assert.AreEqual(resultName, ast.getName());
Assert.IsTrue(className.IsInstanceOfType(ast));
return(ast);
}
catch (Exception e) {
Console.WriteLine(e.StackTrace);
throw new AssertFailedException();
}
return(null);
}
public void analyzeFeatureDefinitions(Environment context, CSTNode rootNode)
{
oclSemanticAnalyzerVisitor = new OCLDefinedFeaturesVisitor(context, constraintSourceTracker);
rootNode.accept(oclSemanticAnalyzerVisitor);
}
public OCLSemanticException(CSTNode node, string message)
: base(message, new SourceLocation(node.getToken()))
{
this.node = node;
}
protected CoreClassifier doTestOK(String expression, String expectedTypeName, String testName)
{
CSTNode rootNode = parseOK(expression, testName);
return(checkResult(rootNode, expectedTypeName));
}
public void analyze(Environment context, CSTNode rootNode)
{
oclSemanticAnalyzerVisitor = getSemanticAnalyzerVisitor(context);
rootNode.accept(oclSemanticAnalyzerVisitor);
}
public void doAction(OCLSemanticAnalyzer analyzer, EnvironmentImpl environment, CSTNode node)
{
analyzer.analyze(environment, node);
}
public OCLMultipleSemanticExceptions(CSTNode node, string message) : base(node, message)
{
exceptions = new List <OCLSemanticException>();
}
public void doAction(OCLSemanticAnalyzer analyzer, Environment environment, CSTNode node)
{
analyzer.analyzeFeatureDefinitions(environment, node);
}
public ConcreteSyntaxTree(CSTNode root = null) : base(root)
{
}
protected override List <object> getConstraints(CSTNode rootNode)
{
return(null);
}