def interpret(self, context: Context): parent = context.getParentContext() try: context.setParentContext(self.calling) return self.expression.interpret(context) except: context.setParentContext(parent)
def check(self, context: Context): resultType = self.resolveAndCheck(context) context = context.newChildContext() if self.resultName is not None: context.registerValue(Variable(self.resultName, resultType)) self.andThen.check(context, VoidType.instance) return VoidType.instance
def interpret(self, context: Context): resultType = self.resolveAndCheck(context) resultValue = super().interpret(context) context = context.newChildContext() if self.resultName is not None: context.registerValue(Variable(self.resultName, resultType)) context.setValue(self.resultName, resultValue) self.andThen.interpret(context) return None
def newLocalInstanceContext(self, context: Context, declaration: IMethodDeclaration): instance = context.getClosestInstanceContext() if instance is not None: required = declaration.memberOf.getType(context) actual = instance.instanceType if not required.isAssignableFrom(context, actual): instance = None if instance is None: declaring = declaration.memberOf.getType(context) instance = context.newInstanceContext(declaring, False) return instance.newChildContext()
def testMethodWith(self): statement = "print \"a\" with \"1\" as value" stmt = self.parse(statement, ECleverParser.statement) self.assertIsNotNone(stmt) writer = CodeWriter(Dialect.E, Context.newGlobalContext()) stmt.toDialect(writer) self.assertEquals(statement, str(writer))
def newLocalCheckContext(self, context: Context, declaration): if self.parent is not None: return self.newInstanceCheckContext(context) elif declaration.memberOf is not None: return self.newLocalInstanceContext(context, declaration) else: return context.newLocalContext()
def testMethodWith(self): statement = "print(\"a\", value = \"1\");" stmt = self.parse(statement, OParser.statement) self.assertIsNotNone(stmt) writer = CodeWriter(Dialect.O, Context.newGlobalContext()) stmt.toDialect(writer) self.assertEquals(statement, str(writer) + ";")
def testSimpleDictLiteral(self): statement = "< \"john\" : 1234, eric : 5678 >" literal = self.parse(statement, OParser.literal_expression) self.assertIsNotNone(literal) self.assertIsInstance(literal, DictLiteral) writer = CodeWriter(Dialect.O, Context.newGlobalContext()) literal.toDialect(writer) self.assertEquals('<"john":1234, eric:5678>', str(writer))
def newInstanceCheckContext(self, context: Context): from prompto.type.CategoryType import CategoryType from prompto.type.TypeType import TypeType from prompto.declaration.IDeclaration import IDeclaration from prompto.declaration.SingletonCategoryDeclaration import SingletonCategoryDeclaration typ = self.parent.check(context) # if calling singleton method, parent is the singleton type if isinstance(typ, TypeType): decl = context.getRegisteredDeclaration(IDeclaration, typ.typ.typeName) if isinstance(decl, SingletonCategoryDeclaration): typ = decl.getType(context) if isinstance(typ, CategoryType): context = context.newInstanceContext(None, typ) return context.newChildContext() else: return context.newChildContext()
def testNativeSymbol(self): statement = 'ENTITY_1 = "1";' symbol = self.parse(statement, OParser.native_symbol) self.assertIsNotNone(symbol) self.assertIsInstance(symbol, NativeSymbol) writer = CodeWriter(Dialect.O, Context.newGlobalContext()) symbol.toDialect(writer) self.assertEquals(statement, str(writer) + ";")
def testNativeSymbol(self): statement = "ENTITY_1 with \"1\" as value" symbol = self.parse(statement, ECleverParser.native_symbol) self.assertIsNotNone(symbol) self.assertIsInstance(symbol, NativeSymbol) writer = CodeWriter(Dialect.E, Context.newGlobalContext()) symbol.toDialect(writer) self.assertEquals(statement, str(writer))
def testCanParseAndTranslateMultilineElements(self): jsx = "return <a>\n\t<b/>\n\t<b/>\n</a>" parser = ECleverParser(text=jsx) stmt = parser.doParse(parser.return_statement, True) self.assertIsNotNone(stmt.expression) writer = CodeWriter(Dialect.E, Context.newGlobalContext()) stmt.toDialect(writer) out = str(writer) self.assertEqual(jsx, out)
def testComplexArgumentAssignment(self): statement = "\"person\" + p.name as value" as_ = self.parse(statement,ECleverParser.argument_assignment) self.assertEquals("value",as_.getName()) exp = as_.getExpression() self.assertIsInstance(exp, PlusExpression) writer = CodeWriter(Dialect.E, Context.newGlobalContext()) as_.toDialect(writer) self.assertEquals(statement, str(writer))
def testSimpleArgumentAssignment(self): statement = "p.name as value" as_ = self.parse(statement,ECleverParser.argument_assignment) self.assertEquals("value",as_.getName()) exp = as_.getExpression() self.assertIsNotNone(exp) writer = CodeWriter(Dialect.E, Context.newGlobalContext()) as_.toDialect(writer) self.assertEquals("p.name as value",str(writer))
def getStaticMemberValue(self, context:Context, name:str): from prompto.declaration.EnumeratedNativeDeclaration import EnumeratedNativeDeclaration decl = context.getRegisteredDeclaration(IDeclaration, self.typeName) if not isinstance (decl, EnumeratedNativeDeclaration): raise SyntaxError(self.typeName + " is not an enumerated type!") if "symbols" == name: return decl.getSymbols() else: raise SyntaxError("Unknown member:" + name)
def testRange(self): statement = "[1..100]" rl = self.parse(statement, OParser.range_literal) self.assertIsNotNone(rl) self.assertEquals("1", str(rl.getFirst())) self.assertEquals("100", str(rl.getLast())) writer = CodeWriter(Dialect.O, Context.newGlobalContext()) rl.toDialect(writer) self.assertEquals(statement, str(writer))
def testCanParseAndTranslateMultilineAttributes(self): jsx = "return <a \n\tx=\"abc\"\n\ty=\"def\"\n\tz=\"stuff\" />" parser = ECleverParser(text=jsx) stmt = parser.doParse(parser.return_statement, True) self.assertIsNotNone(stmt.expression) writer = CodeWriter(Dialect.E, Context.newGlobalContext()) stmt.toDialect(writer) out = str(writer) self.assertEqual(jsx, out)
def testArgumentAssignmentList1Arg(self): statement = "with \"person\" + p.name as value" ls = self.parse(statement, ECleverParser.argument_assignment_list) as_ = ls[0] self.assertEqual("value", as_.getName()) exp = as_.getExpression() self.assertIsInstance(exp, PlusExpression) writer = CodeWriter(Dialect.E, Context.newGlobalContext()) as_.toDialect(writer) self.assertEqual("\"person\" + p.name as value", str(writer))
def getCategoryCandidates(self, context: Context): from prompto.declaration.ConcreteCategoryDeclaration import ConcreteCategoryDeclaration from prompto.type.CategoryType import CategoryType itype = self.checkParent(context) if not isinstance(itype, CategoryType): raise SyntaxError(self.parent.toString() + " is not a category") cd = context.getRegisteredDeclaration(ConcreteCategoryDeclaration, itype.typeName) if cd is None: raise SyntaxError("Unknown category:" + itype.typeName) return cd.getMemberMethods(context, self.name)
def testMethod1Extended1Statement(self): statement = "method printName ( Object(name) o ) { print ( value = \"object\" + o.name ); }" ad = self.parse(statement, OParser.concrete_method_declaration) self.assertIsNotNone(ad) self.assertEquals("printName", ad.getName()) self.assertIsNotNone(ad.parameters) expected = ExtendedParameter(CategoryType("Object"), "o", IdentifierList("name")) self.assertTrue(expected in ad.parameters) self.assertIsNotNone(ad.getStatements()) writer = CodeWriter(Dialect.O, Context.newGlobalContext()) ad.getStatements()[0].toDialect(writer) self.assertEquals("print(value = \"object\" + o.name)", str(writer))
def testMethod1Array1Statement(self): statement = "method printName ( Option[] options ) { print ( value = \"array\" + options ); }" ad = self.parse(statement, OParser.concrete_method_declaration) self.assertIsNotNone(ad) self.assertEquals("printName", ad.getName()) self.assertIsNotNone(ad.parameters) expected = CategoryParameter(ListType(CategoryType("Option")), "options") self.assertTrue(expected in ad.parameters) self.assertIsNotNone(ad.getStatements()) writer = CodeWriter(Dialect.O, Context.newGlobalContext()) ad.getStatements()[0].toDialect(writer) self.assertEquals("print(value = \"array\" + options)", str(writer))
def testMethod1Parameter1Statement(self): statement = "method printName ( Person p ) { print ( value = \"person\" + p.name); }" ad = self.parse(statement, OParser.concrete_method_declaration) self.assertIsNotNone(ad) self.assertEquals("printName", ad.getName()) self.assertIsNotNone(ad.parameters) expected = CategoryParameter(CategoryType("Person"), "p") self.assertTrue(expected in ad.parameters) self.assertIsNotNone(ad.getStatements()) writer = CodeWriter(Dialect.O, Context.newGlobalContext()) ad.getStatements()[0].toDialect(writer) self.assertEquals("print(value = \"person\" + p.name)", str(writer))
def newInstanceContext(self, context: Context): from prompto.type.CategoryType import CategoryType from prompto.expression.CategorySymbol import CategorySymbol from prompto.value.ConcreteInstance import ConcreteInstance from prompto.value.NativeInstance import NativeInstance from prompto.declaration.SingletonCategoryDeclaration import SingletonCategoryDeclaration value = self.parent.interpret(context) if value is None or value is NullValue.instance: from prompto.error.NullReferenceError import NullReferenceError raise NullReferenceError() if isinstance(value, TypeValue): typ = value.value if isinstance(typ, CategoryType): decl = typ.getDeclaration(context) if isinstance(decl, SingletonCategoryDeclaration): value = context.loadSingleton(value.value) if isinstance(value, CategorySymbol): value = value.interpret(context) if isinstance(value, TypeValue): return context.newChildContext() elif isinstance(value, (ConcreteInstance, NativeInstance)): context = context.newInstanceContext(value, None) return context.newChildContext() else: context = context.newBuiltInContext(value) return context.newChildContext()
def testMethod1Array1Statement(self): statement = "define printName as method receiving Option[] options doing:\r\n" \ + "\tprint with \"array\" + args as value" ad = self.parse(statement,ECleverParser.concrete_method_declaration) self.assertIsNotNone(ad) self.assertEquals("printName",ad.getName()) self.assertIsNotNone(ad.parameters) expected = CategoryParameter(ListType(CategoryType("Option")), "options") self.assertTrue(expected in ad.parameters) self.assertIsNotNone(ad.getStatements()) writer = CodeWriter(Dialect.E, Context.newGlobalContext()) ad.getStatements()[0].toDialect(writer) self.assertEquals("print with \"array\" + args as value",str(writer))
def testMethodCallWith(self): statement = "print with \"person\" + p.name as value" mc = self.parse(statement,ECleverParser.method_call_statement) self.assertIsNotNone(mc) self.assertEquals("print",mc.caller.getName()) self.assertIsNotNone(mc.arguments) arg = mc.arguments[0] self.assertEquals("value",arg.getName()) exp = arg.getExpression() self.assertIsInstance(exp, PlusExpression) writer = CodeWriter(Dialect.E, Context.newGlobalContext()) mc.toDialect(writer) self.assertEquals("print with \"person\" + p.name as value",str(writer))
def testMethod1Extended1Statement(self): statement = "define printName as method receiving Object o with attribute name doing:\r\n" \ + "\tprint with \"object\" + o.name as value" ad = self.parse(statement,ECleverParser.concrete_method_declaration) self.assertIsNotNone(ad) self.assertEquals("printName",ad.getName()) self.assertIsNotNone(ad.parameters) expected = ExtendedParameter(CategoryType("Object"), "o", IdentifierList("name")) self.assertTrue(expected in ad.parameters) self.assertIsNotNone(ad.getStatements()) writer = CodeWriter(Dialect.E, Context.newGlobalContext()) ad.getStatements()[0].toDialect(writer) self.assertEquals("print with \"object\" + o.name as value",str(writer))
def loadDependency(self, name): if self.coreContext is None: self.coreContext = Context.newGlobalContext() allStmts = None files = self.listLibraryFiles(name) if files is not None: for file in files: resourceName = name + "/" + file stmts = self.parseResource(resourceName) if allStmts is None: allStmts = stmts else: allStmts.extend(stmts) allStmts.register(self.coreContext)
def compareResourceOMO(self, resourceName): expected = self.getResourceAsString(resourceName, 'r') # print(expected) # parse o source code dlo = self.parseOString(expected) context = Context.newGlobalContext() dlo.register(context) # rewrite as p writer = CodeWriter(Dialect.M, context) dlo.toDialect(writer) p = str(writer) # print(p) # parse p source code dlp = self.parseMString(p) context = Context.newGlobalContext() dlp.register(context) # rewrite as o writer = CodeWriter(Dialect.O, context) dlp.toDialect(writer) actual = str(writer) # print(actual) # ensure equivalent self.assertEquivalent(expected, actual)
def compareResourceEOE(self, resourceName): expected = self.getResourceAsString(resourceName, 'r') # print(expected) # parse e source code dle = self.parseEString(expected) context = Context.newGlobalContext() dle.register(context) # rewrite as o writer = CodeWriter(Dialect.O, context) dle.toDialect(writer) o = str(writer) # print(o) # parse o source code dlo = self.parseOString(o) context = Context.newGlobalContext() dlo.register(context) # rewrite as e writer = CodeWriter(Dialect.E, context) dlo.toDialect(writer) actual = str(writer) # print(actual) # ensure equivalent self.assertEquivalent(expected, actual)
def compareResourceEME(self, resourceName): expected = self.getResourceAsString(resourceName, 'r') # print(expected) # parse e source code dle = self.parseEString(expected) context = Context.newGlobalContext() dle.register(context) # rewrite as p writer = CodeWriter(Dialect.M, context) dle.toDialect(writer) p = unicode(writer) # print(p) # parse p source code dlp = self.parseMString(p) context = Context.newGlobalContext() dlp.register(context) # rewrite as e writer = CodeWriter(Dialect.E, context) dlp.toDialect(writer) actual = unicode(writer) # print(actual) # ensure equivalent self.assertEquivalent(expected, actual)