def visitTernaryExpression(self,
ctx: siliconParser.TernaryExpressionContext):
condition = self.visit(ctx.expression(0))
if condition.asBoolean():
return SiliconValue(self.visit(ctx.expression(1)))
else:
return SiliconValue(self.visit(ctx.expression(2)))
def visitInExpression(self, ctx: siliconParser.InExpressionContext):
lhs = self.visit(ctx.expression(0))
rhs = self.visit(ctx.expression(0))
if rhs.isList():
for val in rhs.asList():
if val == lhs:
return SiliconValue(True)
return SiliconValue(False)
raise Exception("Invalid In Expression")
def lt(self, ctx: siliconParser.CompExpressionContext):
lhs = self.visit(ctx.expression(0))
rhs = self.visit(ctx.expression(1))
if lhs.isNumber() and rhs.isNumber():
return SiliconValue(lhs.asDouble() < rhs.asDouble())
if lhs.isString() or rhs.isString():
return SiliconValue(lhs.asString() < rhs.asString())
raise Exception("Eval Exception")
def subtract(self, ctx: siliconParser.AddExpressionContext):
lhs = self.visit(ctx.expression(0))
rhs = self.visit(ctx.expression(1))
if lhs.isNumber() and rhs.isNumber():
return SiliconValue(lhs.asDouble() - rhs.asDouble())
if lhs.isList():
l = lhs.asList()
l.remove(rhs)
return SiliconValue(l)
raise Exception("Eval Exception")
def resolveIndexes(self, val, indexes):
for ec in indexes:
idx = self.visit(ec)
if not idx.isNumber() or (not val.isList() and not val.isString()):
raise Exception("resolveIndexes Exception")
i = idx.asDouble().intValue()
if val.isString():
val = SiliconValue(val.asString()[i, i + 1])
else:
val = val.asList()[i]
return val
def visitAndExpression(self, ctx: siliconParser.AndExpressionContext):
lhs = self.visit(ctx.expression(0))
rhs = self.visit(ctx.expression(1))
if not lhs.isBoolean() or not rhs.isBoolean():
raise Exception("Invalid Type")
raise SiliconValue(lhs.asBoolean() and rhs.asBoolean())
def visitPowerExpression(self, ctx: siliconParser.PowerExpressionContext):
lhs = self.visit(ctx.expression(0))
rhs = self.visit(ctx.expression(1))
if lhs.isNumber() and rhs.isNumber():
return SiliconValue(pow(lhs.asDouble(), rhs.asDouble()))
raise Exception("EvalException")
def visitList2(self, ctx: siliconParser.List2Context):
l = list()
if ctx.exprList():
for ex in ctx.exprList().expression():
l.append(self.visit(ex))
return SiliconValue(l)
def neq(self, ctx: siliconParser.EqExpressionContext):
lhs = self.visit(ctx.expression(0))
rhs = self.visit(ctx.expression(1))
if lhs == None:
raise Exception("eq Exception")
return SiliconValue(not lhs == rhs)
def modulus(self, ctx: siliconParser.MultExpressionContext):
lhs = self.visit(ctx.expression(0))
rhs = self.visit(ctx.expression(1))
if lhs.isNumber() and rhs.isNumber():
return SiliconValue(lhs.asDouble() % rhs.asDouble())
raise Exception("Eval Exception")
def visitStringExpression(self,
ctx: siliconParser.StringExpressionContext):
text = ctx.getText()
text = text[1:len(text) - 1].replace('\\\\(.)', '$1')
val = SiliconValue(text)
if ctx.indexes():
exps = ctx.indexes().expression()
val = self.resolveIndexes(val, exps)
return val
def setAtIndex(self, ctx: ParserRuleContext, indexes: list,
val: SiliconValue, newVal: SiliconValue):
if not val.isList():
raise Exception('setAtIndex Exception' + ctx.getText())
for i in range(len(indexes) - 1):
idx = self.visit(indexes[i])
if not idx.isNumber:
raise Exception('setAtIndex Exception: Not a number' +
ctx.getText())
val = val.asList()[int(idx.asDouble())]
idx = self.visit(indexes[len(indexes) - 1])
if not idx.isNumber():
raise Exception('setAtIndex Exception: Not a number ' +
ctx.getText())
val.asList()[int(idx.asDouble())] = newVal
def add(self, ctx: siliconParser.AddExpressionContext):
lhs = self.visit(ctx.expression(0))
rhs = self.visit(ctx.expression(1))
if lhs == None or rhs == None:
raise Exception("Eval Exception")
if lhs.isNumber() and rhs.isNumber():
return SiliconValue(lhs.asDouble() + rhs.asDouble())
if lhs.isList():
l = lhs.asList()
l.append(rhs)
return SiliconValue(l)
if lhs.isString():
return SiliconValue(lhs.asString() + "" + rhs.asString())
if rhs.isString():
return SiliconValue(lhs.asString() + "" + rhs.asString())
return SiliconValue(lhs.asString() + rhs.asString())
def multiply(self, ctx: siliconParser.MultExpressionContext):
lhs = self.visit(ctx.expression(0))
rhs = self.visit(ctx.expression(1))
if lhs == None or rhs == None:
print("lhs " + lhs + " rhs " + rhs)
raise Exception("Evalexception")
if lhs.isNumber() and rhs.isNumber():
return SiliconValue(lhs.asDouble() * rhs.asDouble())
if lhs.isString() and rhs.isNumber():
return SiliconValue(
lhs.asString() * int(rhs.asDouble())
) # TODO : Fix needs as a big number can cause crash
if lhs.isList() and rhs.isNumber():
total = []
for i in range(int(rhs.asDouble())):
total.append(lhs.asList())
return SiliconValue(total)
raise Exception(ctx)
def visitBoolExpression(self, ctx: siliconParser.BoolExpressionContext):
return SiliconValue(bool(ctx.getText()))
def visitNotExpression(self, ctx: siliconParser.NotExpressionContext):
v = self.visit(ctx.expression())
if not v.isBoolean():
raise Exception(ctx)
return SiliconValue(not v.asBoolean())
def visitUnaryMinusExpression(
self, ctx: siliconParser.UnaryMinusExpressionContext):
v = self.visit(ctx.expression())
if not v.isNumber():
raise Exception("EvalException")
return SiliconValue(-1 * v.asDouble())
def visitNumberExpression(self,
ctx: siliconParser.NumberExpressionContext):
val = ctx.getText()
if '.' in val:
return SiliconValue(float(val))
return SiliconValue(int(val))
