def inferType(self, context):
inferred = None
# first pass: get less specific type
for current in self.values():
if inferred is None or inferred is NullType.instance:
inferred = current
elif inferred.isAssignableFrom(context, current):
inferred = current if current is DecimalType.instance else inferred
elif current.isAssignableFrom(context, inferred):
inferred = current
else:
common = self.inferCommonBaseType(context, inferred, current)
if common is not None:
inferred = common
else:
raise SyntaxError("Incompatible types: " +
inferred.typeName + " and " +
current.typeName)
if inferred is None:
return VoidType.instance
# second pass: check compatible
for current in self.values():
if not inferred.isAssignableFrom(context, current):
raise SyntaxError("Incompatible types: " + inferred.typeName +
" and " + current.typeName)
return inferred
def check(self, context):
if not context.isWithResourceContext():
raise SyntaxError("Not a resource context!")
sourceType = self.resource.check(context)
if not isinstance(sourceType, ResourceType):
raise SyntaxError("Not a readable resource!")
return TextType.instance
def checkQuery(self, context):
if getattr(self.left, "checkQuery", None) is None:
raise SyntaxError("Not a predicate: " + str(self.left))
if getattr(self.right, "checkQuery", None) is None:
raise SyntaxError("Not a predicate: " + str(self.right))
self.left.checkQuery(context)
self.right.checkQuery(context)
def checkAttribute(self, context):
decl = context.findAttribute(self.name)
if decl is None:
raise SyntaxError("Expected an attribute, found: " + self.name)
if not decl.storable:
raise SyntaxError(self.name + " is not storable")
return decl
def inferType(self, context):
if len(self) == 0:
return VoidType.instance
inferred = None
# first pass: get less specific type
for t in self.values():
if t is NullType.instance:
continue
elif inferred is None:
inferred = t
elif inferred.isAssignableFrom(context, t):
continue
elif t.isAssignableFrom(context, inferred):
inferred = t
else:
raise SyntaxError("Incompatible types: " + inferred.typeName +
" and " + t.typeName)
if inferred is None:
return NullType.instance
# second pass: check compatible
for t in self.itervalues():
if not inferred.isAssignableFrom(context, t):
raise SyntaxError("Incompatible types: " + inferred.typeName +
" and " + t.typeName)
return inferred
def interpretQuery(self, context, query):
if getattr(self.left, "interpretQuery", None) is None:
raise SyntaxError("Not a predicate: " + str(self.left))
self.left.interpretQuery(context, query)
if getattr(self.right, "interpretQuery", None) is None:
raise SyntaxError("Not a predicate: " + str(self.right))
self.right.interpretQuery(context, query)
query.And()
def check(self, context):
try:
value = context.getValue(self.name)
if isinstance(value, CodeValue):
return value.check(context)
else:
raise SyntaxError("Expected code, found:" + str(value))
except PromptoError, e:
raise SyntaxError(e.getMessage())
def getStaticMemberValue(self, context, name):
from prompto.declaration.EnumeratedCategoryDeclaration import EnumeratedCategoryDeclaration
decl = context.getRegisteredDeclaration(IDeclaration, self.typeName)
if not isinstance(decl, EnumeratedCategoryDeclaration):
raise SyntaxError(self.typeName + " is not an enumerated type!")
if "symbols" == name:
return decl.getSymbols()
else:
raise SyntaxError("Unknown member:" + name)
def check(self, context):
firstType = None if self.first is None else self.first.check(context)
lastType = None if self.last is None else self.last.check(context)
if firstType is not None and not isinstance(firstType, IntegerType):
raise SyntaxError(str(firstType) + " is not an integer")
if lastType is not None and not isinstance(lastType, IntegerType):
raise SyntaxError(str(lastType) + " is not an integer")
parentType = self.parent.check(context)
return parentType.checkSlice(context)
def interpretValue(self, context, lval, rval):
if isinstance(lval, BooleanValue):
if isinstance(rval, BooleanValue):
return BooleanValue.ValueOf(lval.getValue() or rval.getValue())
else:
raise SyntaxError("Illegal: Boolean and " +
type(rval).__name__)
else:
raise SyntaxError("Illegal: " + type(lval).__name__ + " + " +
type(rval).__name__)
def check(self, context):
listType = self.source.check(context)
if not isinstance(listType, IterableType):
raise SyntaxError("Expecting an iterable type as data source!")
itemType = listType.itemType
arrow = self.predicate.toArrowExpression()
filterType = arrow.checkFilter(context, itemType)
if filterType is not BooleanType.instance:
raise SyntaxError("Filtering expression must return a boolean!")
return ListType(itemType)
def interpret(self, context):
lval = self.left.interpret(context)
if not isinstance(lval, BooleanValue):
raise SyntaxError("Illegal: " + type(lval).__name__ +
" and ..., expected a Boolean ")
if lval is BooleanValue.FALSE:
return lval
rval = self.right.interpret(context)
if not isinstance(rval, BooleanValue):
raise SyntaxError("Illegal: Boolean and " + type(rval).__name__)
return rval
def toPredicate(self, context):
decl = context.findAttribute(self.name)
if decl is None:
raise SyntaxError("Unknown identifier:" + self.name)
elif decl.getType(context)!=BooleanType.instance:
raise SyntaxError("Expected a Boolean, found: " + decl.getType(context).typeName)
else:
from prompto.expression.EqualsExpression import EqualsExpression
from prompto.grammar.EqOp import EqOp
from prompto.literal.BooleanLiteral import BooleanLiteral
return EqualsExpression(self, EqOp.EQUALS, BooleanLiteral("true"))
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 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 getCategoryCandidates(self, 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 checkAttribute(self, context, name):
decl = context.getRegisteredDeclaration(IDeclaration, self.typeName)
if decl is None:
raise SyntaxError("Unknown category:" + self.typeName)
from prompto.declaration.CategoryDeclaration import CategoryDeclaration
from prompto.declaration.EnumeratedNativeDeclaration import EnumeratedNativeDeclaration
if isinstance(decl, EnumeratedNativeDeclaration):
return decl.typ.checkMember(context, name)
elif isinstance(decl, CategoryDeclaration):
return self.checkCategoryMember(context, decl, name)
else:
raise SyntaxError("Not a category:" + self.typeName)
def checkStaticMember(self, context, name):
from prompto.declaration.SingletonCategoryDeclaration import SingletonCategoryDeclaration
decl = context.getRegisteredDeclaration(IDeclaration, self.typeName)
if decl is None:
raise SyntaxError("Unknown category:" + self.typeName)
if isinstance(decl, IEnumeratedDeclaration):
return decl.getType(context).checkStaticMember(context, name)
elif isinstance(decl, SingletonCategoryDeclaration):
return self.checkCategoryMember(context, decl, name)
else:
raise SyntaxError("No attribute:" + name + " in category:" +
self.typeName)
def makeArgument(self, context, declaration):
parameter = self.parameter
# when 1st argument, can be unnamed
if parameter is None:
if len(declaration.getArguments()) == 0:
raise SyntaxError("Method has no argument")
parameter = declaration.getArguments()[0]
else:
parameter = declaration.getArguments().find(self.getName())
if parameter is None:
raise SyntaxError("Method has no argument:" + self.getName())
expression = ContextualExpression(context, self.getExpression())
return Argument(parameter, expression)
def check(self, context):
resContext = context if isinstance(
context, ResourceContext) else context.newResourceContext()
resourceType = self.resource.check(resContext)
if not isinstance(resourceType, ResourceType):
raise SyntaxError("Not a resource!")
if self.thenWith is None:
return VoidType.instance
else:
if isinstance(context, ResourceContext):
raise SyntaxError(
"Then with is only supported in simple read !")
return self.thenWith.check(resContext, TextType.instance)
def interpret(self, context):
o = self.parent.interpret(context)
if o is None:
raise NullReferenceError()
if isinstance(o, ISliceable):
fi = None if self.first is None else self.first.interpret(context)
if fi is not None and not isinstance(fi, IntegerValue):
raise SyntaxError("Illegal sliced type: " + str(fi))
li = None if self.last is None else self.last.interpret(context)
if li is not None and not isinstance(li, IntegerValue):
raise SyntaxError("Illegal sliced type: " + str(li))
return o.slice(fi, li)
else:
raise SyntaxError("Illegal sliced object: " + self.parent)
def Multiply(self, context, value):
from prompto.value.IntegerValue import IntegerValue
if isinstance(value, IntegerValue):
from prompto.value.TextValue import TextValue
count = value.IntegerValue()
if count < 0:
raise SyntaxError("Negative repeat count:" + count)
if count == 0:
return TextValue("")
if count == 1:
return TextValue(self.value)
return TextValue(self.value * count)
else:
raise SyntaxError("Illegal: Character * " + type(value).__name__)
def check(self, context):
from prompto.declaration.EnumeratedCategoryDeclaration import EnumeratedCategoryDeclaration
cd = context.getRegisteredDeclaration(EnumeratedCategoryDeclaration,
self.itype.typeName)
if cd is None:
raise SyntaxError("Unknown category " + self.itype.typeName)
if self.arguments is not None:
context = context.newLocalContext()
for argument in self.arguments:
if not cd.hasAttribute(context, argument.getName()):
raise SyntaxError("\"" + argument.getName() + \
"\" is not an attribute of " + self.itype.typeName)
argument.check(context)
return self.itype
def Multiply(self, context, value):
if isinstance(value, IntegerValue):
count = value.IntegerValue()
if count < 0:
raise SyntaxError("Negative repeat count:" + count)
elif count == 0:
return ListValue(self.itype.itemType)
elif count == 1:
return self
else:
result = []
for i in range(1, count + 1):
result.extend(self.items)
return ListValue(self.itype.itemType, items=result)
else:
raise SyntaxError("Illegal: List * " + type(value).__name__)
def filter(o):
local.setValue(self.args[0], o)
result = self.statements.interpret(local)
if isinstance(result, BooleanValue):
return result.value
else:
raise SyntaxError("Expecting a Boolean result!")
def __lt__(self, other):
self.context.setValue(self.arrow.args[0], self.value)
self.context.setValue(self.arrow.args[1], other.value)
result = self.arrow.statements.interpret(self.context)
if not isinstance(result, IntegerValue):
raise SyntaxError("Expected an Integer, got a " + result.itype)
return result.value < 0
def Add(self, context, value):
if isinstance(value, PeriodValue):
return self.plusPeriod(value)
elif isinstance(value, TimeValue):
return self.plusTime(value)
else:
raise SyntaxError("Illegal: Date + " + type(value).__name__)
def getMemberMethods(self, context, name):
from prompto.declaration.ConcreteCategoryDeclaration import ConcreteCategoryDeclaration
cd = self.getDeclaration(context)
if not isinstance(cd, ConcreteCategoryDeclaration):
raise SyntaxError("Unknown category:" + self.typeName)
else:
return cd.getMemberMethodsMap(context, name).values()
def checkDerived(self, context):
if self.derivedFrom is not None:
for category in self.derivedFrom:
cd = context.getRegisteredDeclaration(
ConcreteCategoryDeclaration, category)
if cd is None:
raise SyntaxError("Unknown category: \"" + category + "\"")
def getSortKeyReader(self, context, itemType):
if len(self.args) == 1:
return self.getSortKeyReader1Arg(context, itemType)
elif len(self.args) == 2:
return self.getSortKeyReader2Args(context, itemType)
else:
raise SyntaxError("Expecting 1 or 2 parameters only!")
