def check(self, context):
named = context.getRegistered(self.name)
if isinstance(named, MethodDeclarationMap):
method = named.getFirst()
return MethodType(method)
else:
raise SyntaxError("No method with name:" + self.name)
def checkReference(self, context):
finder = MethodFinder(context, self)
method = finder.findBest(False)
if method is not None:
return MethodType(method)
else:
return None
def readValue(self, name):
decl = self.getDeclaration()
if decl.hasAttribute(self, name):
return self.instance.getMemberValue(self.calling, name)
elif decl.hasMethod(self, name):
method = decl.getMemberMethodsMap(self, name).getFirst()
return ClosureValue(self, MethodType(method))
else:
return None
def interpret(self, context):
if context.hasValue(self.name):
return context.getValue(self.name)
else:
named = context.getRegistered(self.name)
if isinstance(named, MethodDeclarationMap):
decl = named.getFirst()
return ClosureValue(context, MethodType(decl))
else:
raise SyntaxError("No method with name:" + self.name)
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 getTargetAtomicType(context, itype):
decl = context.getRegisteredDeclaration(IDeclaration, itype.typeName)
if decl is None:
raise SyntaxError("Unknown identifier: " + itype.typeName)
elif isinstance(decl, MethodDeclarationMap):
if len(decl) == 1:
return MethodType(decl.getFirst())
else:
raise SyntaxError("Ambiguous identifier: " + itype.typeName)
else:
return decl.getType(context)
def interpretReference(self, context):
# resolve parent to keep clarity
parent = self.resolveParent(context)
instance = parent.interpret(context)
if instance is None or instance is NullValue.instance:
raise NullReferenceError()
elif isinstance(instance, IInstance):
category = instance.getDeclaration()
methods = category.getMemberMethodsMap(context, self.name)
method = methods.getFirst() # TODO check prototype
return ClosureValue(context.newInstanceContext(instance, None, True), MethodType(method))
else:
raise SyntaxError("Should never get here!")
def interpret(self, context):
if context.hasValue(self.name):
v = context.getValue(self.name)
# TODO not sure why interpret is needed in Python only
if isinstance(v, IExpression):
v = v.interpret(context)
return v
else:
named = context.getRegistered(self.name)
if isinstance(named, MethodDeclarationMap):
decl = named.getFirst()
return ClosureValue(context, MethodType(decl))
else:
raise SyntaxError("No value or method with name:" + self.name)
def checkCategoryMember(self, context, decl, name):
if decl.storable and "dbId" == name:
return AnyType.instance
elif decl.hasAttribute(context, name):
ad = context.getRegisteredDeclaration(AttributeDeclaration, name)
if ad is None:
raise SyntaxError("Missing attribute:" + name)
else:
return ad.getType(context)
elif "text" == name:
return TextType.instance
elif decl.hasMethod(context, name):
method = decl.getMemberMethodsMap(context, name).getFirst()
return MethodType(method)
else:
raise SyntaxError("No attribute:" + name + " in category:" +
self.typeName)
def check(self, context):
expression = self.expression
if isinstance(expression, UnresolvedSelector):
parent = expression.parent
if parent is not None:
typ = parent.check(context)
if isinstance(typ, CategoryType):
expression = UnresolvedIdentifier(expression.name, Dialect.O)
context = context.newInstanceContext(None, typ, True)
else:
raise SyntaxError("Not a method: " + str(self.expression))
if isinstance(expression, UnresolvedIdentifier):
name = expression.name
named = context.getRegistered(name)
if isinstance(named, MethodDeclarationMap):
method = named.getFirst()
return MethodType(method)
else:
raise SyntaxError("No method with name:" + name)
else:
return SyntaxError("Not implemented !")
def check(self, context):
from prompto.declaration.CategoryDeclaration import CategoryDeclaration
named = context.getRegistered(self.name)
if named is None:
named = context.getRegisteredDeclaration(IDeclaration, self.name)
if named is None:
raise SyntaxError("Unknown identifier:" + self.name)
elif isinstance(named, Variable): # local variable
return named.getType(context)
elif isinstance(named, LinkedVariable): # linked variable
return named.getType(context)
elif isinstance(named, IParameter): # named argument
return named.getType(context)
elif isinstance(named, CategoryDeclaration): # any p with x
return named.getType(context)
elif isinstance(named, AttributeDeclaration): # in category method
return named.getType(context)
elif isinstance(named, MethodDeclarationMap): # global method or closure
method = named.getFirst()
return MethodType(method)
else:
raise SyntaxError(self.name + " is not a value or method:" + type(named).__name__)
def resolve(self, context, onError=None):
if self.resolved is None:
typ = self.anyfy()
if isinstance(typ, NativeType):
self.resolved = typ
else:
if (isinstance(context, CategoryType)):
raise SyntaxError("what!!")
decl = context.getRegisteredDeclaration(
IDeclaration, typ.typeName)
if decl is None:
if onError is not None:
onError(typ)
return None
else:
raise SyntaxError("Unknown type:" + typ.typeName)
elif isinstance(decl, MethodDeclarationMap):
self.resolved = MethodType(decl.getFirst())
else:
found = decl.getType(context)
self.resolved = typ if type(found) == type(typ) else found
return self.resolved
def interpret(self, context):
expression = self.expression
if isinstance(expression, UnresolvedSelector):
parent = expression.parent
if parent is not None:
value = parent.interpret(context)
if isinstance(value, IInstance):
expression = UnresolvedIdentifier(expression.name, Dialect.O)
context = context.newInstanceContext(value, None, True)
else:
return NullValue.instance
if isinstance(expression, UnresolvedIdentifier):
name = expression.name
if context.hasValue(name):
return context.getValue(name)
else:
named = context.getRegistered(name)
if isinstance(named, MethodDeclarationMap):
decl = named.getFirst()
return ClosureValue(context, MethodType(decl))
else:
raise SyntaxError("No method with name:" + name)
def interpretReference(self, context):
declaration = self.findDeclaration(context)
return ClosureValue(context, MethodType(declaration))
def getType(self, context):
method = self.getDeclaration(context)
return MethodType(method)