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); }