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)