def check(self, context):
itype = self.source.check(context)
if not isinstance(itype, (ListType, TupleType, SetType)):
raise SyntaxError("Unsupported type: " + str(itype))
return type
def checkQuery(self, context):
if getattr(self.expression, "checkQuery", None) is None:
raise SyntaxError("Not a predicate: " + str(self.expression))
self.expression.checkQuery(context)
def interpretQuery(self, context, query):
if getattr(self.expression, "interpretQuery", None) is None:
raise SyntaxError("Not a predicate: " + str(self.expression))
self.expression.interpretQuery(context, query)
query.Not()
def check(self, context):
actual = self.expression.check(context)
if not self.itype.getDerivedFrom().isAssignableFrom(context, actual):
raise SyntaxError("Cannot assign " + actual.getName() + " to " + self.itype.getDerivedFrom().getName())
return self.itype
def CompareTo(self, context, value):
if isinstance(value, TimeValue):
return cmp(self.value, value.value)
else:
raise SyntaxError("Illegal comparison: Time + " +
type(value).__name__)
def setItem(self, context, index, value):
if isinstance(index, TextValue):
self.values[index.value] = value
else:
raise SyntaxError("No such item:" + index.toString())
def register(self, context):
actual = context.getRegisteredValue(INamedInstance, self.name)
if actual is not None:
raise SyntaxError("Duplicate argument: \"" + self.name + "\"")
context.registerValue(self)
def checkSlice(self, context):
raise SyntaxError("Cannot slice " + self.typeName)
def checkIterator(self, context):
raise SyntaxError("Cannot iterate over " + self.typeName)
def checkMember(self, context, name):
from prompto.type.TextType import TextType
if "text" == name:
return TextType.instance
else:
raise SyntaxError("Cannot read member from " + self.typeName)
def checkStaticMember(self, context, name):
raise SyntaxError("Cannot read member from " + self.typeName)
def checkItem(self, context, itemType):
from prompto.type.EnumeratedNativeType import EnumeratedNativeType
if isinstance(itemType, EnumeratedNativeType):
return self.checkContainsAllOrAny(context, itemType.derivedFrom)
else:
raise SyntaxError("Cannot read item from " + self.typeName)
def checkQuery(self, context):
decl = self.left.checkAttribute(context)
if not decl.storable:
raise SyntaxError(decl.name + " is not storable")
rt = self.right.check(context)
return self.checkOperator(context, decl.getType(), rt)
def asMutable(self, context, mutable: bool):
if mutable:
raise SyntaxError("Cannot mutate " + self.typeName)
else:
return self
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 checkRange(self, context, other):
raise SyntaxError("Cannot create range of " + self.typeName + " and " +
other.typeName)
def getItem(self, context, index):
if isinstance(index, TextValue):
# TODO autocreate
return self.values.get(index.value, NullValue.instance)
else:
raise SyntaxError("No such item:" + index.toString())
def newRange(self, left, right):
raise SyntaxError("Cannot create range of " + self.typeName)
def Add(self, context, value):
if isinstance(value, DocumentValue):
return DocumentValue.merge(self, value)
else:
raise SyntaxError("Illegal: Document + " + type(value).__name__)
def checkAssignableFrom(self, context, other):
if not self.isAssignableFrom(context, other):
raise SyntaxError("Type: " + self.typeName +
" is not compatible with: " + other.typeName)
def check(self, context):
actual = context.getRegisteredDeclaration(IMethodDeclaration,
self.name)
if actual is None:
raise SyntaxError("Unknown method: \"" + self.name + "\"")
def hasItem(self, context, value):
if isinstance(value, TextValue):
return self.value.get(value.value, None) is not None
else:
raise SyntaxError("Only Text key is supported by " +
type(self).__name__)
def Add(self, context, value):
if isinstance(value, PeriodValue):
return self.plus(value)
else:
raise SyntaxError("Illegal: Time + " + type(value).__name__)
def setItem(self, context, item, value):
if isinstance(item, TextValue):
self.value[item.value] = value
else:
raise SyntaxError("No such item:" + str(item))
def check(self, context):
itype = self.expression.check(context)
if not isinstance(itype, BooleanType):
raise SyntaxError("Cannot negate " + itype.getName())
return BooleanType.instance
def checkConstructorContext(self, context):
if not isinstance(context, ResourceContext):
raise SyntaxError("Not a resource context!")
def interpretValue(self, context, val):
if isinstance(val, BooleanValue):
return val.getNot()
else:
raise SyntaxError("Illegal: not " + type(val).__name__)
def checkUnique(self, context):
actual = context.getRegisteredDeclaration(IDeclaration, self.typeName)
if actual is not None:
raise SyntaxError("Duplicate name: \"" + self.typeName + "\"")
def check(self, context):
itype = self.expression.check(context)
if not CategoryType("Error").isAssignableFrom(context, itype):
raise SyntaxError(itype.getName() + " does not extend Error")
return VoidType.instance
def interpret(self, context):
symbol = context.getRegisteredValue(Symbol, self.name)
if symbol is None:
raise SyntaxError("Unknown symbol:" + self.name)
return symbol.interpret(context)
