def eval(self):
if self.value == "int":
try:
int(self.exp.eval())
return True
except:
return False
elif self.value == "float":
try:
float(self.exp.eval())
return True
except:
return False
elif self.value == "str":
try:
str(self.exp.eval())
return True
except:
return False
elif self.value == "bool":
try:
bool(self.exp.eval())
return True
except:
return False
else:
error(errors.INVALIDTYPE, "", {
"type": "operationtype, typegived, typewanted",
"typewanted": "integer, string, float, boolean",
"typegived": self.value,
"operationtype": "CanBe Function"
})
sys.exit(1)
def ifelse(p):
if type(p[0]) == IfElse:
error(errors.UNEXPECTEDSYNTAX, "Alone Else", {"type": ""})
sys.exit(1)
elif type(p[0]) == IfElseIf:
return IfElseIfElse(If(p[0].ifcondition, p[0].ifstatementlist),
p[0].elseifs, p[1])
else:
return IfElse(p[0], p[1])
def expressionlist(p):
var = self.var.get(p[0].value)
if var is not None:
return var.get(int(p[2].value))
else:
error(errors.NOTDECLARED, "Variable is not declared.", {
"type": "token",
"token": p[0]
})
sys.exit(1)
def membervar2(p):
var = self.var.get(p[0].value)
if var is not None:
return MemberType(p[2].value, var, [p[4]])
else:
error(errors.NOTDECLARED, "Variable is not declared.", {
"type": "token",
"token": p[0]
})
sys.exit(1)
def eval(self):
try:
return float(self.exp.eval())
except:
error(errors.IMPOSSIBLEOPERATION, "", {
"type": "operationtype, value",
"operationtype": "Become Float",
"value": self.exp.eval()
})
sys.exit(1)
def callmember(self, membre, param):
self.paramMember = param
try:
return eval("self." + membre + "()")
except AttributeError:
error(
errors.NOTDECLARED, "Unknown Member", {
"type": "typeerror, member",
"member": membre,
"typeerror": self.name
})
sys.exit(1)
def length(self):
nbarg = 0
if len(self.paramMember) != nbarg:
error(
errors.NUMBERARG, "", {
"type": "nbwanted, nbgived, member",
"member": "length",
"nbgived": len(self.paramMember),
"nbwanted": nbarg
})
sys.exit(1)
return len(self.exp.eval())
def uniqueop(p):
var = self.var.get(p[0].value)
if var is not None:
if p[1].gettokentype() == "INCREMENT":
return Increment(var)
else:
return Decrement(var)
else:
error(errors.NOTDECLARED, "Variable is not declared.", {
"type": "token",
"token": p[0]
})
sys.exit(1)
def programvar3(p):
var = self.var.get(p[0].value)
if var is not None:
if type(var) == Variable:
error(errors.INVALIDTYPE, "Cannot have complex type.", {
"type": "token",
"token": p[0]
})
sys.exit(1)
return AffectionVar(var, List(p[3]))
else:
var = ListVar(p[0].value, List(p[3]))
self.var.add(var)
return var
def eval(self):
var = self.var.exp.var
if len(var) <= self.indice:
values = self.var.exp.getexpression()
value = []
for i in values:
value.append(i.eval())
error(errors.INDEXOUTOFRANGE, "", {
"type": "max, index",
"index": self.indice,
"max": len(var)-1
})
sys.exit(1)
self.value, self.kind = var[self.indice].value, var[self.indice].kind
return self.value
def __init__(self, name, var, param=None):
if param is None:
param = []
self.name = name
self.var = var
try:
self.kind = typesOfMembers[self.name](None)
except KeyError:
error(
errors.NOTDECLARED, "Unknown Member", {
"type": "typeerror, member",
"member": self.name,
"typeerror": self.var.gettype().tostr()
})
sys.exit(1)
self.param = param
def eval(self):
try:
self.var.value = self.var.value - 1
return self.var.value
except:
try:
self.var.value = self.var.expression().decrement()
return self.var.value
except:
error(
errors.IMPOSSIBLEOPERATION, "", {
"type": "operationtype, var",
"operationtype": "Decrease",
"var": self.var
})
sys.exit(1)
def eval(self):
try:
return self.left.eval() / self.right.eval()
except:
try:
return self.left.div(self.right)
except:
error(
errors.IMPOSSIBLEOPERATION, "", {
"type": "values, types, operationtype",
"operationtype": "Division",
"values": [self.left.eval(),
self.right.eval()],
"types":
[self.left.kind.tostr(),
self.right.kind.tostr()]
})
sys.exit(1)
def eval(self):
try:
self.var.value = self.var.value / self.right.eval()
return self.var.value
except:
try:
self.var.value = self.var.expression().div(self.right.eval())
return self.var.value
except:
error(
errors.IMPOSSIBLEOPERATION, "", {
"type": "values, types, operationtype",
"operationtype": "Division Affection",
"values": [self.var.eval().eval(),
self.right.eval()],
"types":
[self.var.kind.tostr(),
self.right.kind.tostr()]
})
sys.exit(1)
def programvar(p):
if type(p[2]) == List:
error(errors.EXPECTEDSYNTAX, "Expected hook around List.", {
"type": "token",
"token": p[0]
})
sys.exit(1)
var = self.var.get(p[0].value)
if var is not None:
if type(var) == ListVar:
error(errors.INVALIDTYPE, "Cannot have basic type.", {
"type": "token",
"token": p[0]
})
sys.exit(1)
return AffectionVar(var, p[2])
else:
var = Variable(p[0].value, p[2])
self.var.add(var)
return var
def expression(p):
if p[0].gettokentype() == 'FLOAT':
return ExpressionBase(float(p[0].value), "float")
elif p[0].gettokentype() == 'STRING':
return ExpressionBase(str(p[0].value)[1:-1], "string")
elif p[0].gettokentype() == 'BOOLEAN':
if p[0].value == "false":
return ExpressionBase(False, "boolean")
return ExpressionBase(True, "boolean")
elif p[0].gettokentype() == 'IDENTIFIER':
var = self.var.get(p[0].value)
if var is not None:
return ExpressionBase(var.value, var.kind, var)
else:
error(errors.NOTDECLARED, "Variable is not declared.", {
"type": "token",
"token": p[0]
})
sys.exit(1)
else:
return ExpressionBase(int(p[0].value), "integer")
def eval(self):
if self.right.kind == "string":
self.kind = "string"
try:
self.var.value = self.var.value + self.right.eval()
return self.var.value
except:
try:
self.var.value = self.var.expression().sum(self.right.eval())
return self.var.value
except:
error(
errors.IMPOSSIBLEOPERATION, "", {
"type": "values, types, operationtype",
"operationtype": "Addition Affection",
"values": [self.var.eval().eval(),
self.right.eval()],
"types":
[self.var.kind.tostr(),
self.right.kind.tostr()]
})
sys.exit(1)
def affectionop(p):
var = self.var.get(p[0].value)
op = p[1]
if var is not None:
if op.gettokentype() == 'SUMAFF':
return SumAffector(var, p[2])
elif op.gettokentype() == 'SUBAFF':
return SubAffector(var, p[2])
elif op.gettokentype() == 'MULAFF':
return MulAffector(var, p[2])
elif op.gettokentype() == 'MODAFF':
return ModAffector(var, p[2])
elif op.gettokentype() == 'POWAFF':
return PowAffector(var, p[2])
elif op.gettokentype() == 'DIVEUAFF':
return DivEuAffector(var, p[2])
else:
return DivAffector(var, p[2])
else:
error(errors.NOTDECLARED, "Variable is not declared.", {
"type": "token",
"token": p[0]
})
sys.exit(1)
def remove(self):
nbarg = 1
if len(self.paramMember) != nbarg:
error(
errors.NUMBERARG, "", {
"type": "nbwanted, nbgived, member",
"member": "length",
"nbgived": len(self.paramMember),
"nbwanted": nbarg
})
sys.exit(1)
if type(self.paramMember[0].kind) != IntType:
error(
errors.INVALIDTYPE, "", {
"type": "typewanted, typegived, member",
"member": "remove",
"typegived": self.paramMember[0].kind.tostr(),
"typewanted": IntType(None).tostr()
})
sys.exit(1)
self.eval()
value = self.var[self.paramMember[0].eval()]
del self.var[self.paramMember[0].eval()]
return value.eval()
def ifelseif(p):
if type(p[0]) == IfElse:
error(errors.UNEXPECTEDSYNTAX, "Alone ElseIf", {"type": ""})
sys.exit(1)
return IfElseIf(p[0], p[1])
