def min(self):
result_of_condition = self.condition.eval()
from Parser.StandardParser import StandardParser
if result_of_condition:
return StandardParser(self.then_block, self.context).parse().min()
else:
return StandardParser(self.else_block, self.context).parse().min()
def regular_notation(self):
if self.advance_string("if"):
condition = self.advance_until("then")
then_block = ''
else_block = ''
count = 1
while count > 0:
if self.advance_string("if"):
then_block += "if"
count += 1
elif self.advance_string("else"):
count -= 1
if count > 0:
then_block += "else"
else:
then_block += self.current_char
self.advance()
while self.current_char is not None:
else_block += self.current_char
self.advance()
if count > 0:
return None
c = BoolParser(condition, self.context).parse()
from Parser.StandardParser import StandardParser
t = StandardParser(then_block, self.context).parse()
e = StandardParser(else_block, self.context).parse()
if c is None or t is None or e is None:
return None
return IfThenElse(c, t, e)
return None
def main():
context = Context(FoundationContext.simple())
while True:
try:
text = input('llama> ')
except EOFError:
break
if not text:
continue
inter = StandardParser(text, context)
result = inter.to_cli()
if result is not None:
print(result)
def main():
context = Context(FoundationContext.simple())
while True:
try:
text = input('llama> ')
except EOFError:
break
if not text:
continue
inter = StandardParser(text, context)
result = inter.to_cli()
if result is not None:
print(result)
def get(self):
self.context = Context(self.get_parent_context())
if len(self.parameters) < len(self.applied):
raise Exception("Invalid Not All Parameters Applied.")
for i in range(len(self.applied)):
if isinstance(self.applied[i], Var):
self.context.setValueForVar(self.parameters[i], self.applied[i].get())
else:
self.context.setValueForVar(self.parameters[i], self.applied[i])
if len(self.parameters) != len(self.applied):
result = Function(self.parameters[len(self.applied):], self.context, self.code, False)
from Parser.StandardParser import StandardParser
parser = StandardParser(self.code, self.context)
parsed = parser.parse()
if parsed is None:
return Nil()
self.applied = []
return parsed
def parse_array(self):
if self.current_char == "[":
self.advance()
items = []
item = self.next_item()
while item is not None:
items.append(item)
item = self.next_item()
self.skip_whitespace()
if self.current_char == "]":
self.advance()
from Parser.StandardParser import StandardParser
parsed_items = []
for item in items:
parser = StandardParser(item, self.context)
parsed = parser.parse()
if parsed is None:
return None
parsed_items.append(parsed)
return Array(parsed_items)
return None
def parse_array(self):
if self.current_char == "[":
self.advance()
items = []
item = self.next_item()
while item is not None:
items.append(item)
item = self.next_item()
self.skip_whitespace()
if self.current_char == "]":
self.advance()
from Parser.StandardParser import StandardParser
parsed_items = []
for item in items:
parser = StandardParser(item, self.context)
parsed = parser.parse()
if parsed is None:
return None
parsed_items.append(parsed)
return Array(parsed_items)
return None
def get(self):
self.context = Context(self.get_parent_context())
if len(self.parameters) < len(self.applied):
raise Exception("Invalid Not All Parameters Applied.")
for i in range(len(self.applied)):
if isinstance(self.applied[i], Var):
self.context.setValueForVar(self.parameters[i],
self.applied[i].get())
else:
self.context.setValueForVar(self.parameters[i],
self.applied[i])
if len(self.parameters) != len(self.applied):
result = Function(self.parameters[len(self.applied):],
self.context, self.code, False)
from Parser.StandardParser import StandardParser
parser = StandardParser(self.code, self.context)
parsed = parser.parse()
if parsed is None:
return Nil()
self.applied = []
return parsed
def parse_call(self):
pattern = re.compile("[ ]+")
expressions_as_string_array = pattern.split(self.text)
while "" in expressions_as_string_array:
expressions_as_string_array.remove("")
expressions_as_array = []
if len(expressions_as_string_array) > 1:
for expression_as_string in expressions_as_string_array:
from Parser.StandardParser import StandardParser
parser = StandardParser(expression_as_string, self.context)
parsed = parser.parse()
if parsed is None:
return None
expressions_as_array.append(parsed)
if len(expressions_as_array) > 0 and expressions_as_array[0].type(
) == Function:
func = expressions_as_array[0]
params = expressions_as_array[1:]
if isinstance(func, Var):
func = func.get()
func.apply(params)
self.finish()
return func.get()
return None
def parse_declaration(self):
if self.advance_string("let"):
name_field = self.advance_until("=")
parser = VariableParser(name_field, self.context)
parsed_var = parser.parse()
remaining = self.text[self.pos:]
from Parser.StandardParser import StandardParser
parsed_remaining = StandardParser(remaining, self.context).parse()
self.finish()
if parsed_var is None or parsed_remaining is None:
return None
parsed_var.set(parsed_remaining)
return parsed_var
else:
return None
def type(self):
from Parser.StandardParser import StandardParser
parsed_then = StandardParser(self.then_block, self.context).parse()
return parsed_then.type()
def type(self):
from Parser.StandardParser import StandardParser
parsed_then = StandardParser(self.then_block, self.context).parse()
return parsed_then.type()