def buildArray(l):
assert (isinstance(l, list))
assert (all(map(lambda x: isinstance(x, Interpreter.InAtom), l)))
kvs = [(Interpreter.Symbol('Length'), Interpreter.Number(len(l)))]
for i in range(0, len(l)):
kvs.append((Interpreter.Number(float(i)), l[i]))
return Interpreter.Dict(kvs)
def Pow(a, b):
assert (isinstance(a, Interpreter.InAtom))
assert (isinstance(b, Interpreter.InAtom))
Utils.testNumber(a, 'Pow')
Utils.testNumber(b, 'Pow')
return Interpreter.Number(math.pow(a.value, b.value))
def Mod(a, b):
assert (isinstance(a, Interpreter.InAtom))
assert (isinstance(b, Interpreter.InAtom))
Utils.testNumber(a, 'Mod')
Utils.testNumber(b, 'Mod')
res = math.fmod(a.value, b.value)
return Interpreter.Number(res)
def GetModule():
return Application.Module(
'Core:Data:Number', {
'pi': Interpreter.Number(3.1415926535897931),
'e': Interpreter.Number(2.7182818284590451),
'is-number?': Interpreter.BuiltIn(IsNumber),
'add': Interpreter.BuiltIn(Add),
'inc': Interpreter.BuiltIn(Inc),
'sub': Interpreter.BuiltIn(Sub),
'dec': Interpreter.BuiltIn(Dec),
'mul': Interpreter.BuiltIn(Mul),
'div': Interpreter.BuiltIn(Div),
'mod': Interpreter.BuiltIn(Mod),
'lt': Interpreter.BuiltIn(Lt),
'lte': Interpreter.BuiltIn(Lte),
'gt': Interpreter.BuiltIn(Gt),
'gte': Interpreter.BuiltIn(Gte),
'sin': Interpreter.BuiltIn(Sin),
'cos': Interpreter.BuiltIn(Cos),
'tan': Interpreter.BuiltIn(Tan),
'ctg': Interpreter.BuiltIn(Ctg),
'asin': Interpreter.BuiltIn(ASin),
'acos': Interpreter.BuiltIn(ACos),
'atan': Interpreter.BuiltIn(ATan),
'actg': Interpreter.BuiltIn(ACtg),
'rad2deg': Interpreter.BuiltIn(Rad2Deg),
'deg2rad': Interpreter.BuiltIn(Deg2Rad),
'exp': Interpreter.BuiltIn(Exp),
'log': Interpreter.BuiltIn(Log),
'ln': Interpreter.BuiltIn(Ln),
'lg': Interpreter.BuiltIn(Lg),
'sqrt': Interpreter.BuiltIn(Sqrt),
'pow': Interpreter.BuiltIn(Pow),
'abs': Interpreter.BuiltIn(Abs),
'ceill': Interpreter.BuiltIn(Ceill),
'floor': Interpreter.BuiltIn(Floor)
}, {}, [
'pi', 'e', 'is-number?', 'add', 'inc', 'sub', 'dec', 'mul', 'div',
'mod', 'lt', 'lte', 'gt', 'gte', 'sin', 'cos', 'tan', 'ctg',
'asin', 'acos', 'actg', 'rad2deg', 'deg2rad', 'exp', 'log', 'ln',
'lg', 'sqrt', 'pow', 'abs', 'ceill', 'floor'
])
def argStarAsList(arg_star):
assert (isinstance(arg_star, Interpreter.Dict))
length = arg_star.get(Interpreter.Symbol('Length'))
assert (length)
new_ls = []
for i in range(0, length.value):
new_item = arg_star.get(Interpreter.Number(i))
assert (new_item)
new_ls.append(new_item)
return new_ls
def Sub(a, b, va_star):
assert (isinstance(a, Interpreter.InAtom))
assert (isinstance(b, Interpreter.InAtom))
assert (isinstance(va_star, Interpreter.InAtom))
Utils.testNumber(a, 'Sub')
Utils.testNumber(b, 'Sub')
res = a.value - b.value
va = Utils.argStarAsList(va_star)
map(lambda x: Utils.testNumber(x, 'Sub'), va)
for i in va:
res = res - i.value
return Interpreter.Number(res)
def Lg(a):
assert (isinstance(a, Interpreter.InAtom))
Utils.testNumber(a, 'Lg')
return Interpreter.Number(math.log(a.value, 10))
def Ctg(a):
assert (isinstance(a, Interpreter.InAtom))
Utils.testNumber(a, 'Ctg')
return Interpreter.Number(1 / math.tan(a.value))
def Inc(a):
assert (isinstance(a, Interpreter.InAtom))
Utils.testNumber(a, 'Inc')
return Interpreter.Number(a.value + 1)
def Ceill(a):
assert (isinstance(a, Interpreter.InAtom))
Utils.testNumber(a, 'Ceill')
return Interpreter.Number(math.ceil(a.value))
def Floor(a):
assert (isinstance(a, Interpreter.InAtom))
Utils.testNumber(a, 'Floor')
return Interpreter.Number(math.floor(a.value))
def ASin(a):
assert (isinstance(a, Interpreter.InAtom))
Utils.testNumber(a, 'ASin')
return Interpreter.Number(math.asin(a.value))
def Abs(a):
assert (isinstance(a, Interpreter.InAtom))
Utils.testNumber(a, 'Abs')
return Interpreter.Number(math.fabs(a.value))
def Dec(a):
assert (isinstance(a, Interpreter.InAtom))
Utils.testNumber(a, 'Dec')
return Interpreter.Number(a.value - 1)
def ACtg(a):
assert (isinstance(a, Interpreter.InAtom))
Utils.testNumber(a, 'ACtg')
return Interpreter.Number(math.pi / 2 - math.atan(a.value))
def Exp(a):
assert (isinstance(a, Interpreter.InAtom))
Utils.testNumber(a, 'Exp')
return Interpreter.Number(math.exp(a.value))
def Deg2Rad(a):
assert (isinstance(a, Interpreter.InAtom))
Utils.testNumber(a, 'Deg2Rad')
return Interpreter.Number(math.radians(a.value))
def Rad2Deg(a):
assert (isinstance(a, Interpreter.InAtom))
Utils.testNumber(a, 'Rad2Deg')
return Interpreter.Number(math.degrees(a.value))
def Sqrt(a):
assert (isinstance(a, Interpreter.InAtom))
Utils.testNumber(a, 'Sqrt')
return Interpreter.Number(math.sqrt(a.value))
import Lexer as lx
import Parser as px
import Interpreter as ix
##################################################
# RUN
##################################################
global_symbol_table = ix.SymbolTable()
global_symbol_table.set("null", ix.Number(0))
def run(fn, text):
lexer = lx.Lexer(fn, text)
tokens, error = lexer.make_tokens()
if error: return None, error
# generate AST
parser = px.Parser(tokens)
ast = parser.parse()
if ast.error: return None, ast.error
# Run program
interpreter = ix.Interpreter()
context = ix.Context('<program>')
context.symbol_table = global_symbol_table
result = interpreter.visit(ast.node, context)
return result.value, result.error
