def toDialect(self, writer):
writer = writer.newChildWriter()
srcType = self.source.check(writer.context)
elemType = srcType.checkIterator(writer.context)
itemName = self.v1 if self.v2 is None else self.v2
writer.context.registerValue(Variable(itemName, elemType))
if self.v2 is not None:
writer.context.registerValue(
Variable(self.v1, IntegerType.instance))
super().toDialect(writer)
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):
record = super(FetchManyStatement, self).interpret(context)
context = context.newChildContext()
context.registerValue(Variable(self.name, CursorType(self.typ)))
context.setValue(self.name, record)
self.stmts.interpret(context)
return None
def toEDialect(self, writer):
writer.append("sorted ")
if self.desc:
writer.append("descending ")
self.source.toDialect(writer)
if self.key is not None:
typ = self.source.check(writer.context)
itemType = typ.itemType
local = self.contextualizeWriter(writer, itemType)
local.append(" with ")
keyExp = self.key
if isinstance(keyExp, UnresolvedIdentifier):
try:
keyExp = keyExp.resolve(writer.context, False)
except:
pass # TODO add warning
if isinstance(keyExp, ArrowExpression):
for arg in keyExp.args:
param = Variable(arg, itemType)
local.context.registerValue(param)
keyExp.toDialect(local)
elif isinstance(keyExp, InstanceExpression):
keyExp.toDialect(local, False)
else:
keyExp.toDialect(local)
writer.append(" as key")
def interpret(self, context):
record = super(ReadStatement, self).interpret(context)
context = context.newChildContext()
context.registerValue(Variable(self.name, TextType.instance))
context.setValue(self.name, record)
self.stmts.interpret(context)
return None
def getIterator(self, context):
for value in self.source:
child = context.newChildContext()
child.registerValue(Variable(self.name, self.itemType))
child.setValue(self.name, value)
value = self.expression.interpret(child)
yield value
def interpret(self, context):
if context.getRegisteredValue(INamedInstance,
self.parameter.getName()) is None:
context.registerValue(
Variable(self.parameter.getName(), self.getExpression()))
context.setValue(self.parameter.getName(),
self.getExpression().interpret(context))
return None
def readRegisteredValue(self, klass, name):
actual = self.instances.get(name, None)
# not very pure, but avoids a lot of complexity when registering a value
if actual is None:
attr = self.getRegisteredDeclaration(AttributeDeclaration, name)
typ = attr.getType()
actual = Variable(name, typ)
self.instances[name] = actual
return actual
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 checkAssignValue(self, context, valueType):
actual = context.getRegisteredValue(INamedInstance, self.name)
if actual is None:
context.registerValue(Variable(self.name, valueType))
return valueType
else:
# need to check type compatibility
actualType = actual.getType(context)
actualType.checkAssignableFrom(context, valueType)
return actualType
def interpret(self, context):
if isinstance(self.declaration, ConcreteMethodDeclaration):
method = self.declaration
method.register(context)
typ = MethodType(method)
context.registerValue( Variable(method.getName(), typ))
context.setValue(method.getName(), ClosureValue(context, typ))
return None
else:
raise SyntaxError("Unsupported:" + type(self.declaration).__name__)
def toDialect(self, writer, expression):
if expression is not None:
try:
actual = writer.context.getRegisteredValue(
INamedInstance, self.name)
if actual is None:
typ = expression.check(writer.context)
writer.context.registerValue(Variable(self.name, typ))
except:
pass
writer.append(self.name)
def check(self, context):
actual = context.getRegisteredValue(INamedInstance, self.parameter.getName())
if actual is None:
actualType = self.getExpression().check(context)
context.registerValue(Variable(self.parameter.getName(), actualType))
else:
# need to check type compatibility
actualType = actual.getType(context)
newType = self.getExpression().check(context)
actualType.checkAssignableFrom(context, newType)
return VoidType.instance
def doProcessCategory(self, annotation, context, declaration):
fieldName = annotation.getArgument("name")
fieldType = annotation.getArgument("type")
if not isinstance(fieldName, TextLiteral):
raise SyntaxError("WidgetField requires a Text value for argument 'name'")
elif not isinstance(fieldType, (TypeExpression, TypeLiteral)):
raise SyntaxError("WidgetField requires a Type value for argument 'type'")
else:
name = str(fieldName)
typ = fieldType.typ
context.registerValue(Variable(name[1:-1], typ), False)
def checkResource(self, context):
expressionType = self.expression.check(context)
if not isinstance(expressionType, ResourceType):
raise SyntaxError("Not a resource!")
actual = context.getRegisteredValue(INamedInstance, self.name)
if actual is None:
context.registerValue(Variable(self.name, expressionType))
else:
# need to check type compatibility
actualType = actual.getType(context)
actualType.checkAssignableFrom(context, expressionType)
return VoidType.instance
def interpret(self, context):
value = self.expression.interpret(context)
if not isinstance(value, TupleValue):
raise SyntaxError("Expecting a tuple expression, got " +
type(value).__name__)
i = 1
for name in self.names:
item = value.getItem(context, IntegerValue(i))
i += 1
if context.getRegisteredValue(INamedInstance, name) is None:
context.registerValue(Variable(name, item.itype))
context.setValue(name, item)
return None
def toDialect(self, writer, typ):
writer.append(" then with ").append(self.name)
if writer.dialect is Dialect.O:
writer.append(" {")
else:
writer.append(":")
writer = writer.newChildWriter()
writer.context.registerValue(Variable(self.name, typ))
writer.newLine().indent()
self.statements.toDialect(writer)
writer.dedent()
if writer.dialect is Dialect.O:
writer.append("}")
def toDialect(self, writer):
super(ReadStatement, self).toDialect(writer)
writer.append(" then with ").append(self.name)
if writer.dialect is Dialect.O:
writer.append(" {")
else:
writer.append(":")
writer = writer.newChildWriter()
writer.context.registerValue(Variable(self.name, TextType.instance))
writer.newLine().indent()
self.stmts.toDialect(writer)
writer.dedent()
if writer.dialect is Dialect.O:
writer.append("}")
def toDialect(self, writer):
super(FetchManyStatement, self).toDialect(writer)
writer.append(" then with ").append(self.name)
if writer.dialect is Dialect.O:
writer.append(" {")
else:
writer.append(":")
writer = writer.newChildWriter()
writer.context.registerValue(Variable(self.name, CursorType(self.typ)))
writer.newLine().indent()
self.stmts.toDialect(writer)
writer.dedent()
if writer.dialect is Dialect.O:
writer.append("}")
def doSetMember(self, context, attrName, value, allowSetter):
decl = context.getRegisteredDeclaration(AttributeDeclaration, attrName)
setter = self.declaration.findSetter(context, attrName) if allowSetter else None
if setter is not None:
activeSetters.__dict__[attrName] = context
# use attribute name as parameter name for incoming value
context = context.newInstanceContext(self, None).newChildContext()
context.registerValue(Variable(attrName, decl.getType()))
context.setValue(attrName, value)
value = setter.interpret(context)
value = self.autocast(decl, value)
self.values[attrName] = value
if self.storable is not None and decl.storable:
# TODO convert object graph if(value instanceof IInstance)
self.storable.setData(attrName, value.getStorableData())
def check(self, context):
itype = self.expression.check(context)
if itype != TupleType.instance:
raise SyntaxError("Expecting a tuple expression, got " +
itype.getName())
for name in self.names:
actual = context.getRegistered(name)
if actual is None:
actualType = self.expression.check(context)
context.registerValue(Variable(name, actualType))
else:
# need to check type compatibility
actualType = actual.getType(context)
newType = self.expression.check(context)
actualType.checkAssignableFrom(context, newType)
return VoidType.instance
def toDialect(self, writer):
super().toDialect(writer)
resultType = self.resolveAndCheck(writer.context)
writer.append(" then")
writer = writer.newChildWriter()
if self.resultName is not None:
writer.append(" with ").append(self.resultName)
writer.context.registerValue(Variable(self.resultName, resultType))
if writer.dialect is Dialect.O:
writer.append(" {")
else:
writer.append(":")
writer = writer.newLine().indent()
self.andThen.toDialect(writer)
writer = writer.dedent()
if writer.dialect is Dialect.O:
writer.append("}")
def filteredToDialect(self, writer, source):
writer = writer.newChildWriter()
sourceType = source.check(writer.context)
itemType = sourceType.itemType
writer.context.registerValue(Variable(self.itemName, itemType))
if writer.dialect is Dialect.O:
writer.append("filtered (")
source.toDialect(writer)
writer.append(") with (") \
.append(self.itemName) \
.append(") where (")
self.predicate.toDialect(writer)
writer.append(")")
else:
source.toDialect(writer)
writer.append(" filtered with ") \
.append(self.itemName) \
.append(" where ")
self.predicate.toDialect(writer)
def checkFilter(self, context, itemType):
child = context.newChildContext()
child.registerValue(Variable(self.itemName, itemType))
return self.predicate.check(child)
def registerArrowArgs(self, context, itemType):
for arg in self.args:
context.registerValue(Variable(arg, itemType))
return context
def checkFilter(self, context, itemType):
if self.args is None or len(self.args) != 1:
raise SyntaxError("Expecting 1 parameter only!")
context = context.newChildContext()
context.registerValue(Variable(self.args[0], itemType))
return self.statements.check(context, None)
def check(self, context):
elemType = self.source.check(context).checkIterator(context)
child = context.newChildContext()
context.registerValue(Variable(self.name, elemType))
itemType = self.expression.check(child)
return IteratorType(itemType)
def assign(self, context, expression):
value = expression.interpret(context)
if context.getRegisteredValue(INamedInstance, self.name) is None:
itype = expression.check(context)
context.registerValue(Variable(self.name, itype))
context.setValue(self.name, value)
def callback(text):
local = context.newChildContext()
local.registerValue(
Variable(self.thenWith.name, TextType.instance))
local.setValue(self.thenWith.name, TextValue(text))
self.thenWith.statements.interpret(local)
def check(self, context):
super(FetchManyStatement, self).check(context)
context = context.newChildContext()
context.registerValue(Variable(self.name, CursorType(self.typ)))
self.stmts.check(context, None)
return VoidType.instance