def execute_Rajale(self, exec_ctx):
list_ = exec_ctx.symbol_table.get("list")
index = exec_ctx.symbol_table.get("index")
if not isinstance(list_, List):
return RTResult().failure(RTError(
self.pos_start, self.pos_end,
"Motri me tenes que dar una lista pa rajar un elemento",
exec_ctx
))
if not isinstance(index, Number):
return RTResult().failure(RTError(
self.pos_start, self.pos_end,
"CAPO dame el index en el segundo argumento",
exec_ctx
))
try:
element = list_.elements.pop(index.value)
except:
return RTResult().failure(RTError(
self.pos_start, self.pos_end,
detailsMessages["outOfIndex"],
exec_ctx
))
return RTResult().success(element)
def execute_Argentina(self, exec_ctx):
import ctypes
import os
from playsound import playsound
print("\n¡VIVA LA PATRIA!\n\n¡VIVA!\n")
notDone = True
try:
imageUri = os.path.abspath(os.environ["CheLangPath"]) + "\\assets\\Argentina.jpg"
soundUri = os.path.abspath(os.environ["CheLangPath"]) + "\\assets\\Malvinas.mp3"
os.startfile(imageUri)
ctypes.windll.user32.SystemParametersInfoW(20, 0, imageUri , 0)
playsound(soundUri)
notDone = False
except (KeyboardInterrupt, SystemExit):
notDone = False
return RTResult().success(Empty())
except:
if notDone:
try:
imageUri = os.path.abspath(os.getcwd()) + "\\assets\\Argentina.jpg"
soundUri = os.path.abspath(os.getcwd()) + "\\assets\\Malvinas.mp3"
os.startfile(imageUri)
ctypes.windll.user32.SystemParametersInfoW(20, 0, imageUri , 0)
playsound(soundUri)
except FileNotFoundError:
print("Pasó algo, no pude cargar las cosas... Para mi es culpa del kernel imperialista...")
except:
return RTResult().success(Empty())
return RTResult().success(Empty())
finally:
return RTResult().success(Empty())
def execute_Campora(self, exec_ctx):
import os
from playsound import playsound
print("\nAGUANTE CRISTIIINA PAPAAA!")
print("\nNESTOR KIRCHNER\n1950 - SIEEEMPRE\n")
print("\nLA PATRIA ES EL OOTRO\n✌ ✌ ✌ ✌ ✌ ✌ ✌ ✌ ✌ ✌ ✌ ✌\n")
notDone = True
global inflacion
inflacion += .2
try:
soundUri = os.path.abspath(
os.environ["CheLangPath"]) + "\\assets\\Peron.mp3"
playsound(soundUri)
notDone = False
except (KeyboardInterrupt, SystemExit):
notDone = False
return RTResult().success(Empty())
except:
if notDone:
try:
soundUri = os.path.abspath(
os.getcwd()) + "\\assets\\Peron.mp3"
playsound(soundUri)
except FileNotFoundError:
print(
"Pasó algo, no pude cargar las cosas... Para mi es culpa del kernel imperialista..."
)
except:
return RTResult().success(Empty())
return RTResult().success(Empty())
finally:
return RTResult().success(Empty())
def execute_Correme(self, exec_ctx):
fn = exec_ctx.symbol_table.get("fn")
if not isinstance(fn, String):
return RTResult().failure(
RTError(self.pos_start, self.pos_end, "Dame un string papá",
exec_ctx))
if fn.value[-4:] != ".che":
return RTResult().failure(
RTError(self.pos_start, self.pos_end,
"CAPO tiene que ser un archivo .che , que te pensas?",
exec_ctx))
fn = os.path.abspath(fn.value)
try:
with open(fn, "r") as f:
script = f.read()
except Exception as e:
return RTResult().failure(
RTError(
self.pos_start, self.pos_end,
f"Que pasó perro? No arrancó? Algo va mal en \"{fn}\"\n" +
str(e), exec_ctx))
from CheLang.cheLangCompiler import run
_, error = run(fn, script)
if error:
return RTResult().failure(
RTError(
self.pos_start, self.pos_end,
f"Che \"{fn}\" no funcó, fijate que onda.\n" +
error.as_string(), exec_ctx))
return RTResult().success(Empty())
def execute_HalloEbribodi(self, exec_ctx):
import os
from playsound import playsound
notDone = True
try:
soundUri = os.path.abspath(
os.environ["CheLangPath"]) + "\\assets\\HalloEbribodi.mp3"
playsound(soundUri)
notDone = False
except (KeyboardInterrupt, SystemExit):
notDone = False
return RTResult().success(String("Seriusli"))
except:
if notDone:
try:
soundUri = os.path.abspath(
os.getcwd()) + "\\assets\\HalloEbribodi.mp3"
playsound(soundUri)
except FileNotFoundError:
print(
"Pasó algo, no pude cargar las cosas... Para mi es culpa del kernel imperialista..."
)
except:
return RTResult().success(String("Seriusli"))
return RTResult().success(String("Seriusli"))
finally:
return RTResult().success(String("Seriusli"))
def execute_Viborita(self, exec_ctx):
ev = exec_ctx.symbol_table.get("value")
if isinstance(ev, String):
return RTResult().success(String(str(eval(ev.value))))
else:
return RTResult().failure(
RTError(self.pos_start, self.pos_end,
"Capo dame un string pa evaluar, dale?", exec_ctx))
def visit_ReturnNode(self, node, context):
res = RTResult()
if node.node_to_return:
value = res.register(self.visit(node.node_to_return, context))
if res.should_return() : return res
else:
value = Number.null
return res.success_return(value)
def take_item(self, other):
res = RTResult()
if isinstance(other, Number):
try:
return res.success(self.elements[other.value])
except:
return res.failure(
RTError(other.pos_start, other.pos_end,
detailsMessages["outOfIndex"], self.context))
else:
return res.failure(Value.illegal_operation(self, other))
def execute_Boludear(self, exec_ctx):
from time import sleep
n = exec_ctx.symbol_table.get("value")
if isinstance(n, Number):
sleep(n.value)
else:
return RTResult().failure(
RTError(
self.pos_start, self.pos_end,
"Flaco dame una cantidad de segundos, no cualquier cosa",
exec_ctx))
return RTResult().success(Empty())
def execute_TaLargo(self, exec_ctx):
value = exec_ctx.symbol_table.get("value")
if isinstance(value, List):
return RTResult().success(Number(len(value.elements)))
if isinstance(value, String):
return RTResult().success(Number(len(value.value)))
return RTResult().failure(
RTError(self.pos_start, self.pos_end,
"Che el TaLargo tiene que tener una lista o un string",
exec_ctx))
def visit_ListNode(self, node, context):
res = RTResult()
elements = []
for element_node in node.element_nodes:
elements.append(res.register(self.visit(element_node, context)))
# if res.error: return res
if res.should_return(): return res
return res.success(
List(elements).set_context(context).set_pos(node.pos_start, node.pos_end)
)
def visit_FuncDefNode(self, node, context):
res = RTResult()
func_name = node.var_name_tok.value if node.var_name_tok else None
body_node = node.body_node
arg_names = [arg_name.value for arg_name in node.arg_name_toks]
func_value = Function(func_name, body_node, arg_names, node.should_auto_return).set_context(context).set_pos(node.pos_start, node.pos_end)
if node.var_name_tok:
context.symbol_table.set(func_name, func_value)
return res.success(func_value)
def execute_Agregale(self, exec_ctx):
list_ = exec_ctx.symbol_table.get("list")
value = exec_ctx.symbol_table.get("value")
if not isinstance(list_, List):
return RTResult().failure(
RTError(
self.pos_start, self.pos_end,
"Motri me tenes que dar una lista pa poner un elemento",
exec_ctx))
list_.elements.append(value)
return RTResult().success(list_)
def visit_VarAccessNode(self,node,context):
res = RTResult()
var_name = node.var_name_tok.value
value = context.symbol_table.get(var_name)
if not value:
return res.failure(RTError(
node.pos_start, node.pos_end,
detailsMessages["unknownVariable"] + var_name + "'",
context
))
value = value.copy().set_context(context).set_pos(node.pos_start, node.pos_end)
return res.success(value)
def execute_Sumate(self, exec_ctx):
arg = exec_ctx.symbol_table.get("list").copy()
if isinstance(arg, List):
try:
for i, n in enumerate(arg.elements):
arg.elements[i] = n.value
return RTResult().success(Number(sum(arg.elements)))
except:
return RTResult().failure(
RTError(self.pos_start, self.pos_end,
"Capo pasame una lista CON SOLO NUMEROS, dale?",
exec_ctx))
else:
return RTResult().failure(
RTError(self.pos_start, self.pos_end,
"Capo pasame una lista, dale?", exec_ctx))
def execute_Chorro(self, exec_ctx):
from time import sleep
print("\nSi entra el chorro no lo podes amasijar en el patio porque despues dicen que se cayo de la medianera.", end="\n\n")
sleep(4)
print("Vos lo tenes que llevar al lugar mas recóndito de tu casa.", end="\n\n")
sleep(2)
print("Al ultimo dormitorio.", end="\n\n")
sleep(1.5)
print("Y si es posible al sótano.", end="\n\n")
sleep(1.5)
print("Bien escondido.", end="\n\n")
sleep(2)
print("Y ahí lo reventas a balazos. Le tiras todos los tiros.", end="\n\n")
sleep(3)
print("No uno, porque vas a ser habil tirador y te comes un garron de la gran flauta.", end="\n\n")
sleep(3)
print("Vos estabas en un estado de emocion violenta y de locura.", end="\n\n")
sleep(2)
print("Lo rreventaste a tiros, le vaciaste todo el cargador.", end="\n\n")
sleep(2)
print("Le zapateas arriba. Lo meas. Para demostrar tu estado de locura y de inconsciencia temporal.", end="\n\n")
sleep(3.3)
print("¿Me explico?", end="\n\n")
sleep(1.5)
print("Ademas tenes que tener una botella de chiv va a mano, te tomas media botella,", end="\n\n")
sleep(3)
print("y si tenes un sobre de cocaina, papoteate y vas al juzgado así. *Movimientos epilepticos*", end="\n\n")
sleep(3)
print("Sos inimputable hermano.", end="\n\n")
sleep(2.3)
print("En diez dias salis.", end="\n\n")
sleep(1)
return RTResult().success(Empty())
def visit_WhileNode(self, node, context):
res = RTResult()
elements = []
# aca ta el loop
while True:
condition = res.register(self.visit(node.condition_node, context))
# if res.error: return res
if res.should_return(): return res
if not condition.is_true(): break
value = res.register(self.visit(node.body_node, context))
# if res.error: return res
if res.should_return() and res.loop_should_continue == False and res.loop_should_break == False: return res
if res.loop_should_continue:
continue
if res.loop_should_break:
break
elements.append(value)
return res.success(
Empty() if node.should_return_null else
List(elements).set_context(context).set_pos(node.pos_start, node.pos_end)
)
def execute_Metele(self, exec_ctx):
listA = exec_ctx.symbol_table.get("listA")
listB = exec_ctx.symbol_table.get("listB")
if not isinstance(listA, List):
return RTResult().failure(
RTError(self.pos_start, self.pos_end,
"Tiene que ser una lista el primer argumento crack",
exec_ctx))
if not isinstance(listB, List):
return RTResult().failure(
RTError(self.pos_start, self.pos_end,
"También tiene que ser una lista el segundo crack",
exec_ctx))
listA.elements.extend(listB.elements)
return RTResult().success(listA)
def execute_TraemeNumerito(self, exec_ctx):
while True:
text = input(exec_ctx.symbol_table.get('inputValue?') or "Tirame un numero: ")
try:
number = int(text)
break
except ValueError:
print(f"'{text}' tiene que ser un numero tarao, mandale denuevo")
return RTResult().success(Number(number))
def visit_CallListNode(self, node, context):
res = RTResult()
value_to_call = res.register(self.visit(node.list_to_call, context))
if res.should_return(): return res
value_to_call = value_to_call.copy().set_pos(node.pos_start, node.pos_end)
listIndex = res.register(self.visit(node.listIndex, context))
if res.should_return(): return res
listIndex = listIndex.copy().set_pos(node.pos_start, node.pos_end)
return_value = res.register(value_to_call.take_item(listIndex))
if res.should_return(): return res
return_value = return_value.copy().set_context(context).set_pos(node.pos_start,node.pos_end)
return res.success(return_value)
def execute_ElMasGrande(self, exec_ctx):
from time import sleep
print("\nEl mas grande. Quien va a ser el mas grande papa?.",
end="\n\n")
sleep(1)
print("\nEl Diego, Hermano", end="\n\n")
sleep(2)
print("\nY me llenan, mira, mira...", end="\n\n")
sleep(1)
print("\nSe me caen las lagrimas.", end="\n\n")
sleep(1)
print("\nEl Diego, loco.", end="\n\n")
sleep(3)
print("\nEl Dieeeego...", end="\n\n")
sleep(1)
print("\nEl Diegote.", end="\n\n")
sleep(3)
print("\nEl que lo bardeaba a...", end="\n\n")
sleep(4)
print("\nA los Grondona...", end="\n\n")
sleep(2)
print("\nEse es el mas grande de toda la vida...", end="\n\n")
sleep(1)
print("\nDe toda la historia.", end="\n\n")
sleep(2)
print("\nEl Diego Armando Maradona...", end="\n\n")
sleep(1)
print("\nAca papa", end="\n\n")
sleep(1)
print("\nAca chabon", end="\n\n")
sleep(2)
print("\nFenomeno...", end="\n\n")
sleep(1)
print("\nDrogadicto", end="\n\n")
sleep(1)
print("\nLo que sea Papa", end="\n\n")
sleep(1)
print("\nYo te llevo en el alma, loco.", end="\n\n")
sleep(2)
print("\nEste es el mas grande", end="\n\n")
sleep(1)
print("\nEste se la jugo por la Argentina", end="\n\n")
sleep(1)
print("\nPeron robo", end="\n\n")
sleep(1)
print("\nTodos robaron, este...", end="\n\n")
sleep(1)
print("\nCon el tobillo asi con Brasil, hizo asi", end="\n\n")
sleep(1)
print("\nCani, Cani", end="\n\n")
sleep(2)
print("\nY quien?", end="\n\n")
sleep(1)
print("\nEl futbolero lo entiende, hermano.", end="\n\n")
sleep(1)
return RTResult().success(Empty())
def execute_AFlotantito(self, exec_ctx):
n = exec_ctx.symbol_table.get("value")
if isinstance(n, String):
try:
ret = float(n.value)
return RTResult().success(Number(ret))
except:
return RTResult().failure(
RTError(
self.pos_start, self.pos_end,
"Flaco no se que me pasaste pero no se puede hacer numerito",
exec_ctx))
elif isinstance(n, Number):
return RTResult().success(Number(float(n.value)))
else:
return RTResult().failure(
RTError(self.pos_start, self.pos_end,
"Capo pasame un numerito o un string, dale?",
exec_ctx))
def visit_CallNode(self, node, context):
res = RTResult()
args = []
value_to_call = res.register(self.visit(node.node_to_call, context))
if res.should_return(): return res
value_to_call = value_to_call.copy().set_pos(node.pos_start, node.pos_end)
for arg_node in node.arg_nodes:
args.append(res.register(self.visit(arg_node, context)))
if res.should_return(): return res
return_value = res.register(value_to_call.execute(args))
if res.should_return(): return res
return_value = return_value.copy().set_context(context).set_pos(node.pos_start,node.pos_end)
return res.success(return_value)
def execute(self, args):
res = RTResult()
exec_ctx = self.generate_new_context()
method_name = f'execute_{self.name}'
method = getattr(self, method_name, self.no_visit_method)
res.register(self.check_and_populate_args(method.arg_names, args, exec_ctx))
if res.should_return(): return res
return_value = res.register(method(exec_ctx))
if res.should_return(): return res
return res.success(return_value)
def execute(self, args):
from CheLang.Interpreter import Interpreter
res = RTResult()
interpreter = Interpreter()
exec_ctx = self.generate_new_context()
res.register(self.check_and_populate_args(self.arg_names, args, exec_ctx))
if res.should_return(): return res
value = res.register(interpreter.visit(self.body_node, exec_ctx))
if res.should_return() and res.func_return_value == None: return res
ret_value = (value if self.should_auto_return else None) or res.func_return_value or Empty()
return res.success(ret_value)
def check_args(self, arg_names, args):
res = RTResult()
final_arg_names = []
for arg_name in arg_names:
if not arg_name[-1] == "?":
final_arg_names.append(arg_name)
if len(args) > len(arg_names):
return res.failure(
RTError(
self.pos_start, self.pos_end,
f"Che me pasaste como {len(args) - len(arg_names)} argumentos, son menos en {self} viste",
self.context))
if len(args) < len(final_arg_names):
return res.failure(
RTError(
self.pos_start, self.pos_end,
f"Che me pasaste como {len(final_arg_names) - len(args)} argumentos, son más en {self} viste",
self.context))
return res.success(None)
def visit_BinOpNode(self, node, context):
res = RTResult()
left = res.register(self.visit(node.left_node, context))
# if res.error: return res
if res.should_return(): return res
right = res.register(self.visit(node.right_node, context))
# if res.error: return res
if res.should_return(): return res
if node.op_tok.type == TT_PLUS:
result, error = left.added_to(right)
elif node.op_tok.type == TT_MINUS:
result, error = left.subbed_by(right)
elif node.op_tok.type == TT_MUL:
result, error = left.multed_by(right)
elif node.op_tok.type == TT_MOD:
result, error = left.modded_by(right)
elif node.op_tok.type == TT_DIV:
result, error = left.dived_by(right)
elif node.op_tok.type == TT_POW:
result, error = left.powed_by(right)
elif node.op_tok.type == TT_EE:
result, error = left.get_comparison_ee(right)
elif node.op_tok.type == TT_NE:
result, error = left.get_comparison_ne(right)
elif node.op_tok.type == TT_LT:
result, error = left.get_comparison_lt(right)
elif node.op_tok.type == TT_GT:
result, error = left.get_comparison_gt(right)
elif node.op_tok.type == TT_LTE:
result, error = left.get_comparison_lte(right)
elif node.op_tok.type == TT_GTE:
result, error = left.get_comparison_gte(right)
elif node.op_tok.type == TT_MM:
result, error = left.get_comparison_mm(right)
elif node.op_tok.matches(TT_KEYWORD, "y"):
result, error = left.anded_by(right)
elif node.op_tok.matches(TT_KEYWORD, "o"):
result, error = left.ored_by(right)
if error:
return res.failure(error)
else:
return res.success(result.set_pos(node.pos_start,node.pos_end))
def visit_VarAssignNode(self, node, context):
res = RTResult()
var_name = node.var_name_tok
value = res.register(self.visit(node.value_node, context))
# if res.error: return res
if res.should_return(): return res
for var in var_name:
if var.value.lower() == "dolar":
return res.failure(LanguageThingError(
var.pos_start, var.pos_end,
detailsMessages["dolarVarAssign"]
))
context.symbol_table.set(var.value,value)
return res.success(value)
def visit_UnaryOpNode(self, node, context):
res = RTResult()
number = res.register(self.visit(node.node, context))
# if res.error: return res
if res.should_return(): return res
error = None
if node.op_tok.type == TT_MINUS:
number, error = number.multed_by(Number(-1))
if node.op_tok.matches(TT_KEYWORD, "no"):
number, error = number.notted()
if error:
return res.failure(error)
else:
return res.success(number.set_pos(node.pos_start,node.pos_end))
def execute_Dolar(self, exec_ctx):
d = datetime.datetime.now()
dolar = 193 + ((d - START_TIME).total_seconds() / 2) * inflacion
return RTResult().success(Number(float("{:.2f}".format(dolar))))
