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)
