brasa-lang 0.1.0__tar.gz

brasa_lang-0.1.0/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: brasa-lang
+Version: 0.1.0
+Summary: Brasa programming language
+Author: Adriano
+Requires-Python: >=3.10

brasa_lang-0.1.0/README.md

@@ -0,0 +1,3 @@
+# Brasa
+
+This is a high-level programming language which provides an more robust alternative to VisuAlg and Portugol.

brasa_lang-0.1.0/brasa/__init__.py

@@ -0,0 +1 @@
+

brasa_lang-0.1.0/brasa/cli.py

@@ -0,0 +1,14 @@
+# brasa/cli.py
+
+import sys
+from brasa.runner import run_file
+from brasa.repl import repl
+
+def main():
+  if len(sys.argv) > 1:
+    run_file(sys.argv[1])
+  else:
+    repl()
+
+if __name__=='__main__':
+  main()

brasa_lang-0.1.0/brasa/core/nodes/basics.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+
+@dataclass
+class Program:
+  statements:list[any]
+
+@dataclass
+class Identifier:
+  name:str
+
+@dataclass
+class Block:
+  statements:any

brasa_lang-0.1.0/brasa/core/nodes/operators.py

@@ -0,0 +1,14 @@
+from dataclasses import dataclass
+
+from brasa.core.types.operators import BinaryOperationEnum,UnaryOperationEnum
+
+@dataclass
+class BinaryOperation:
+  left:any
+  op:BinaryOperationEnum
+  right:any
+
+@dataclass
+class UnaryOperation:
+  op:UnaryOperationEnum
+  expr:any

brasa_lang-0.1.0/brasa/core/nodes/statements.py

@@ -0,0 +1,85 @@
+from dataclasses import dataclass
+
+from brasa.core.nodes.types import Type
+from brasa.core.nodes.values import Value
+
+# ---------------- VARIABLES ----------------
+
+@dataclass
+class VariableDeclarationStatement:
+  id:str
+  type:Type
+  expr:Value
+  is_const:bool
+
+@dataclass
+class AssignmentStatement:
+  target:str
+  expr:Value
+
+@dataclass
+class CompoundAssignmentStatement:
+  target:any
+  op:any
+  expr:any
+
+@dataclass
+class PostfixStatement:
+  target:any
+  op:any
+
+@dataclass
+class IndexExpression:
+  base:any
+  index:any
+
+# ---------------- CONTROL FLOW ----------------
+
+@dataclass
+class IfStatement:
+  condition:any
+  then_block:any
+  else_branch:any
+
+@dataclass
+class WhileStatement:
+  condition:any
+  body:any
+
+@dataclass
+class BreakStatement:
+  pass
+
+@dataclass
+class ContinueStatement:
+  pass
+
+# ---------------- FUNCTIONS ----------------
+
+@dataclass
+class FunctionDeclaration:
+  name:str
+  params:any
+  return_type:any
+  body:any
+
+@dataclass
+class LambdaExpression:
+  params:any
+  return_type:any
+  body:any
+
+@dataclass
+class CallExpression:
+  callee:any
+  args:any
+
+@dataclass
+class ReturnStatement:
+  expr:any
+
+# ---------------- REMOVE LATER ----------------
+
+@dataclass
+class PrintStatement:
+  expr:Value

brasa_lang-0.1.0/brasa/core/nodes/types.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+
+@dataclass
+class Type:
+  pass
+
+@dataclass
+class IntegerType(Type):
+  pass
+
+@dataclass
+class FloatType(Type):
+  pass
+
+@dataclass
+class StringType:
+  pass
+
+@dataclass
+class NullableType(Type):
+  base_type:Type
+
+@dataclass
+class BooleanType(Type):
+  pass
+
+@dataclass
+class ArrayType(Type):
+  element_type:Type
+  size:int
+
+@dataclass
+class VoidType(Type):
+  pass
+
+@dataclass
+class FunctionType(Type):
+  param_types:list[Type]
+  return_type:Type

brasa_lang-0.1.0/brasa/core/nodes/values.py

@@ -0,0 +1,36 @@
+from dataclasses import dataclass
+
+@dataclass
+class Value:
+  pass
+
+@dataclass
+class IntegerValue(Value):
+  value:int
+
+@dataclass
+class FloatValue(Value):
+  value:float
+
+@dataclass
+class StringLiteral:
+  value:str
+
+@dataclass
+class NullValue(Value):
+  pass
+
+@dataclass
+class BooleanValue(Value):
+  value:bool
+
+@dataclass
+class ArrayValue(Value):
+  elements:list[Value]
+
+@dataclass
+class FunctionValue:
+  params:any
+  body:any
+  return_type:any
+  closure_scope:any

brasa_lang-0.1.0/brasa/core/types/lvalues.py

@@ -0,0 +1,33 @@
+class LValue:
+  def get(self,interpreter):
+    raise NotImplementedError
+
+  def set(self,interpreter,value):
+    raise NotImplementedError
+
+class VarLValue(LValue):
+  def __init__(self,name):
+    self.name = name
+
+  def get(self,interpreter):
+    var_id = interpreter.current_scope.lookup(self.name)
+    return interpreter.world.get_value(var_id)
+
+  def set(self,interpreter,value):
+    var_id = interpreter.current_scope.lookup(self.name)
+    interpreter.world.set_value(var_id,value)
+
+class IndexLValue(LValue):
+  def __init__(self,base,index_expr):
+    self.base=base
+    self.index_expr=index_expr
+
+  def get(self,interpreter):
+    arr=self.base.get(interpreter)
+    index=interpreter.visit(self.index_expr)
+    return arr[index]
+
+  def set(self,interpreter,value):
+    arr=self.base.get(interpreter)
+    index=interpreter.visit(self.index_expr)
+    arr[index]=value

brasa_lang-0.1.0/brasa/core/types/operators.py

@@ -0,0 +1,21 @@
+from enum import Enum, auto
+
+class BinaryOperationEnum(Enum):
+  ADD = auto()
+  SUB = auto()
+  MUL = auto()
+  DIV = auto()
+
+  GT = auto()
+  LT = auto()
+  GE = auto()
+  LE = auto()
+  EQ = auto()
+  NE = auto()
+
+  AND = auto()
+  OR = auto()
+
+class UnaryOperationEnum(Enum):
+  NEG = auto()
+  NOT = auto()

brasa_lang-0.1.0/brasa/interpreter/interpreter.py

@@ -0,0 +1,301 @@
+from brasa.runtime.scope import Scope
+from brasa.runtime.world import World
+
+from brasa.core.nodes.values import FunctionValue
+from brasa.core.types.operators import BinaryOperationEnum,UnaryOperationEnum
+
+from brasa.interpreter.signals import BreakSignal,ContinueSignal,ReturnSignal
+
+class Interpreter:
+  def __init__(self):
+    self.current_scope=Scope()
+    self.world=World()
+
+  def visit(self,node):
+    method_name=f'visit_{type(node).__name__}'
+    visitor=getattr(
+      self,
+      method_name,
+      self.generic_visit
+    )
+
+    return visitor(node)
+
+  def generic_visit(self, node):
+    raise Exception(f'Method visit_{type(node).__name__} does not exist.')
+
+  # ---------------- BASICS ----------------
+
+  def visit_Program(self,node):
+    for statement in node.statements:
+      self.visit(statement)
+
+  def visit_Block(self, node):
+    old_scope = self.current_scope
+    self.current_scope = Scope(parent=old_scope)
+
+    for stmt in node.statements:
+      self.visit(stmt)
+
+    self.current_scope = old_scope
+
+  # ---------------- VARIABLES ----------------
+
+  def visit_Identifier(self, node):
+    var_id = self.current_scope.lookup(node.name)
+    return self.world.get_value(var_id)
+
+  def visit_VariableDeclarationStatement(self,node):
+    value = self.visit(node.expr) if node.expr is not None else None
+
+    var_id=self.world.create(
+      type_=node.type,
+      value=value,
+      is_const=node.is_const
+    )
+
+    self.current_scope.declare(node.id.name,var_id)
+
+  def visit_AssignmentStatement(self,node):
+    # var_id = self.current_scope.lookup(node.id.name)
+
+    # if self.world.is_const(var_id):
+    #   raise Exception(f"Cannot assign to const '{node.id.name}'")
+
+    # value = self.visit(node.expr)
+    # self.world.set_value(var_id, value)
+    value = self.visit(node.expr)
+    node.target.set(self, value)
+
+  def visit_CompoundAssignmentStatement(self, node):
+  #   var_id = self.current_scope.lookup(node.id.name)
+  #   current=self.world.get_value(var_id)
+  #   value = self.visit(node.expr)
+
+  #   if node.op == BinaryOperationEnum.ADD:
+  #     result = current + value
+  #   elif node.op == BinaryOperationEnum.SUB:
+  #     result = current - value
+  #   elif node.op == BinaryOperationEnum.MUL:
+  #     result = current * value
+  #   elif node.op == BinaryOperationEnum.DIV:
+  #     result = current / value
+
+  #   self.world.set_value(var_id,result)
+    current = node.target.get(self)
+    value = self.visit(node.expr)
+
+    if node.op==BinaryOperationEnum.ADD:
+        result=current+value
+    elif node.op==BinaryOperationEnum.SUB:
+        result=current-value
+    elif node.op==BinaryOperationEnum.MUL:
+        result= current*value
+    elif node.op==BinaryOperationEnum.DIV:
+        result=current/value
+
+    node.target.set(self,result)
+
+  def visit_PostfixStatement(self,node):
+    # var_id = self.current_scope.lookup(node.id.name)
+    # current=self.world.get_value(var_id)
+
+    # if node.op==BinaryOperationEnum.ADD:
+    #   self.world.set_value(var_id,current+1)
+    # else:
+    #   self.world.set_value(var_id,current-1)
+    current=node.target.get(self)
+
+    if node.op==BinaryOperationEnum.ADD:
+      new_value=current+1
+    else:
+      new_value=current-1
+
+    node.target.set(self,new_value)
+
+    return current
+
+  # ---------------- VALUES ----------------
+
+  def visit_IntegerValue(self,node):
+    return node.value
+
+  def visit_FloatValue(self,node):
+    return node.value
+
+  def visit_StringLiteral(self,node):
+    return node.value
+
+  def visit_NullValue(self,node):
+    return None
+
+  def visit_BooleanValue(self,node):
+    return node.value
+
+  def visit_ArrayValue(self,node):
+    return [self.visit(elem) for elem in node.elements]
+
+  def visit_IndexExpression(self, node):
+    arr = self.visit(node.base)
+    index = self.visit(node.index)
+    return arr[index]
+
+  # ---------------- OPERATORS ----------------
+
+  def visit_BinaryOperation(self, node):
+    op = node.op
+
+    if op == BinaryOperationEnum.AND:
+      left=self.visit(node.left)
+
+      if not left:
+        return False
+
+      right=self.visit(node.right)
+      return bool(right)
+
+    if node.op == BinaryOperationEnum.OR:
+      left = self.visit(node.left)
+
+      if left:
+        return True
+
+      right = self.visit(node.right)
+      return bool(right)
+
+    left = self.visit(node.left)
+    right = self.visit(node.right)
+
+    if op == BinaryOperationEnum.ADD:
+      return left + right
+    if op == BinaryOperationEnum.SUB:
+      return left - right
+    if op == BinaryOperationEnum.MUL:
+      return left * right
+    if op == BinaryOperationEnum.DIV:
+      return left / right
+
+    if op == BinaryOperationEnum.GT:
+      return left > right
+    if op == BinaryOperationEnum.LT:
+      return left < right
+    if op == BinaryOperationEnum.GE:
+      return left >= right
+    if op == BinaryOperationEnum.LE:
+      return left <= right
+    if op == BinaryOperationEnum.EQ:
+      return left == right
+    if op == BinaryOperationEnum.NE:
+      return left != right
+
+    raise Exception(f"Unknown operator: {op}")
+
+  def visit_UnaryOperation(self, node):
+    value = self.visit(node.expr)
+
+    if node.op == UnaryOperationEnum.NEG:
+      return -value
+
+    if node.op == UnaryOperationEnum.NOT:
+      return not value
+
+    raise Exception(f"Unknown unary operator: {node.op}")
+
+  # ---------------- CONTROL FLOW ----------------
+
+  def visit_IfStatement(self, node):
+    condition = self.visit(node.condition)
+
+    if condition:
+      return self.visit(node.then_block)
+
+    if node.else_branch:
+      return self.visit(node.else_branch)
+
+  def visit_WhileStatement(self, node):
+    while self.visit(node.condition):
+      try:
+        self.visit(node.body)
+
+      except ContinueSignal:
+        continue
+
+      except BreakSignal:
+        break
+
+  def visit_BreakStatement(self, node):
+    raise BreakSignal()
+
+  def visit_ContinueStatement(self, node):
+    raise ContinueSignal()
+
+  # ---------------- FUNCTIONS ----------------
+
+  def visit_FunctionDeclaration(self, node):
+    func=FunctionValue(
+      params=node.params,
+      body=node.body,
+      return_type=node.return_type,
+      closure_scope=self.current_scope
+    )
+
+    var_id=self.world.create(
+      type_=None,
+      value=func,
+      is_const=True
+    )
+
+    self.current_scope.declare(node.name.name, var_id)
+
+  def visit_LambdaExpression(self, node):
+    return FunctionValue(
+      params=node.params,
+      body=node.body,
+      return_type=node.return_type,
+      closure_scope=self.current_scope,
+    )
+  
+  def visit_CallExpression(self, node):
+    func=self.visit(node.callee)
+    args=[self.visit(arg) for arg in node.args]
+
+    new_scope=Scope(parent=func.closure_scope)
+
+    for param, arg in zip(func.params, args):
+      var_id = self.world.create(type_=param[0], value=arg)
+      new_scope.declare(param[1].name, var_id)
+
+    old_scope=self.current_scope
+    self.current_scope=new_scope
+
+    try:
+      self.visit(func.body)
+      result=None
+    except ReturnSignal as r:
+      result=r.value
+
+    self.current_scope=old_scope
+
+    return result
+
+  def visit_ReturnStatement(self, node):
+    value=None
+
+    if node.expr:
+      value=self.visit(node.expr)
+
+    raise ReturnSignal(value)
+
+  # ---------------- REMOVE LATER ----------------
+
+  def visit_PrintStatement(self, node):
+    value = self.visit(node.expr)
+
+    if value is None:
+      print('nulo')
+    elif value is True:
+      print('verdadeiro')
+    elif value is False:
+      print('falso')
+    else:
+      print(value)

brasa_lang-0.1.0/brasa/interpreter/signals.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+
+@dataclass
+class BreakSignal(Exception):
+  pass
+
+@dataclass
+class ContinueSignal(Exception):
+  pass
+
+@dataclass
+class ReturnSignal(Exception):
+  value:any

brasa_lang-0.1.0/brasa/parser/ast_builder.py

@@ -0,0 +1,300 @@
+from lark import Transformer,v_args
+
+from brasa.core.nodes.basics import *
+from brasa.core.nodes.statements import *
+from brasa.core.nodes.types import *
+from brasa.core.nodes.values import *
+from brasa.core.types.lvalues import *
+
+from brasa.core.nodes.operators import BinaryOperation,UnaryOperation
+from brasa.core.types.operators import BinaryOperationEnum,UnaryOperationEnum
+
+class ASTBuilder(Transformer):
+  # ---------------- PROGRAM ----------------
+
+  def program(self,statements):
+    return Program(statements=statements)
+
+  @v_args(inline=True)
+  def statement(self, item):
+    return item
+
+  def block(self,statements):
+    return Block(list(statements))
+
+  # ---------------- VARIABLES ----------------
+
+  def ID(self,name):
+    return Identifier(name=str(name))
+
+  @v_args(inline=True)
+  def var_declaration(self,const,type_,id,expr):
+    return VariableDeclarationStatement(
+      id=id,
+      type=type_,
+      expr=expr,
+      is_const=const is not None
+    )
+
+  @v_args(inline=True)
+  def var_declaration_null(self,const,type_,id):
+    return VariableDeclarationStatement(
+      id=id,
+      type=type_,
+      expr=NullValue(),
+      is_const=const is not None
+    )
+
+  @v_args(inline=True)
+  def assigment(self,id,expr):
+    return AssignmentStatement(
+      target=id,
+      expr=expr
+    )
+
+  @v_args(inline=True)
+  def compound_assignment(self,id,op,expr):
+    return CompoundAssignmentStatement(
+      target=id,
+      op=op,
+      expr=expr
+    )
+
+  @v_args(inline=True)
+  def postfix(self,id,op):
+    return PostfixStatement(
+      target=id,
+      op=op
+    )
+
+  def OP_POSTFIX(self, token):
+    return token.value
+
+  @v_args(inline=True)
+  def var_lvalue(self, id_):
+    return VarLValue(id_.name)
+
+
+  @v_args(inline=True)
+  def index_lvalue(self, base, index):
+    return IndexLValue(base, index)
+
+  # ---------------- TYPES ----------------
+
+  def int_type(self,_):
+    return IntegerType()
+
+  def float_type(self,_):
+    return FloatType()
+
+  @v_args(inline=True)
+  def nullable_type(self,type_):
+    return NullableType(base_type=type_)
+
+  def string_type(self,_):
+    return StringType()
+
+  def bool_type(self, _):
+    return BooleanType()
+
+  def void_type(self, _):
+    return VoidType()
+
+  @v_args(inline=True)
+  def array_type(self,element_type,size):
+    return ArrayType(
+      element_type=element_type,
+      size=size
+    )
+
+  # ---------------- LITERALS ----------------
+
+  @v_args(inline=True)
+  def integer_literal(self,value):
+    return IntegerValue(value=int(value))
+
+  @v_args(inline=True)
+  def float_literal(self,value):
+    return FloatValue(value=float(value))
+
+  @v_args(inline=True)
+  def string_literal(self, token):
+    return StringLiteral(value=token[1:-1])
+
+  def null_literal(self,_):
+    return NullValue()
+
+  def true_literal(self, _):
+    return BooleanValue(True)
+
+  def false_literal(self, _):
+    return BooleanValue(False)
+
+  @v_args(inline=True)
+  def array_literal(self,*elements):
+    if len(elements)==1 and elements[0] is None:
+      elements=[]
+
+    return ArrayValue(elements=elements)
+
+  @v_args(inline=True)
+  def index_expr(self, base, index):
+    return IndexExpression(base, index)
+
+  # ---------------- CONTROL FLOW ----------------
+
+  @v_args(inline=True)
+  def if_statement(self, cond, then_block, else_branch=None):
+    return IfStatement(cond, then_block, else_branch)
+
+  @v_args(inline=True)
+  def while_statement(self, condition, body):
+    return WhileStatement(condition, body)
+
+  def break_statement(self, _):
+    return BreakStatement()
+
+  def continue_statement(self, _):
+    return ContinueStatement()
+
+  # ---------------- OPERATORS ----------------
+
+  # ---------------- MATH ----------------
+
+  @v_args(inline=True)
+  def add(self, left, right):
+    return BinaryOperation(left, BinaryOperationEnum.ADD, right)
+
+  @v_args(inline=True)
+  def sub(self, left, right):
+    return BinaryOperation(left, BinaryOperationEnum.SUB, right)
+
+  @v_args(inline=True)
+  def mul(self, left, right):
+    return BinaryOperation(left, BinaryOperationEnum.MUL, right)
+
+  @v_args(inline=True)
+  def div(self, left, right):
+    return BinaryOperation(left, BinaryOperationEnum.DIV, right)
+
+  @v_args(inline=True)
+  def neg(self, value):
+      return UnaryOperation(UnaryOperationEnum.NEG, value)
+
+  @v_args(inline=True)
+  def OP_ASSIGN(self, token):
+    return {
+      '+=': BinaryOperationEnum.ADD,
+      '-=': BinaryOperationEnum.SUB,
+      '*=': BinaryOperationEnum.MUL,
+      '/=': BinaryOperationEnum.DIV,
+    }[token]
+
+  @v_args(inline=True)
+  def OP_POSTFIX(self, token):
+    if token=='++':
+      return BinaryOperationEnum.ADD
+
+    return BinaryOperationEnum.SUB
+
+  # ---------------- COMPARISONS ----------------
+
+  @v_args(inline=True)
+  def gt(self, left, right):
+    return BinaryOperation(left, BinaryOperationEnum.GT, right)
+
+  @v_args(inline=True)
+  def lt(self, left, right):
+    return BinaryOperation(left, BinaryOperationEnum.LT, right)
+
+  @v_args(inline=True)
+  def ge(self, left, right):
+    return BinaryOperation(left, BinaryOperationEnum.GE, right)
+
+  @v_args(inline=True)
+  def le(self, left, right):
+    return BinaryOperation(left, BinaryOperationEnum.LE, right)
+
+  @v_args(inline=True)
+  def eq(self, left, right):
+    return BinaryOperation(left, BinaryOperationEnum.EQ, right)
+
+  @v_args(inline=True)
+  def ne(self, left, right):
+    return BinaryOperation(left, BinaryOperationEnum.NE, right)
+
+  # ---------------- LOGICAL ----------------
+
+  @v_args(inline=True)
+  def and_op(self, left, right):
+    return BinaryOperation(left, BinaryOperationEnum.AND, right)
+
+  @v_args(inline=True)
+  def or_op(self, left, right):
+    return BinaryOperation(left, BinaryOperationEnum.OR, right)
+
+  @v_args(inline=True)
+  def not_op(self, value):
+    return UnaryOperation(UnaryOperationEnum.NOT, value)
+
+  # ---------------- FUNCTION ----------------
+
+  @v_args(inline=True)
+  def func_declaration(self,func_name,parameters,return_type,block):
+    return FunctionDeclaration(
+      name=func_name,
+      params=[] if parameters is None else parameters,
+      return_type=VoidType() if return_type is None else return_type,
+      body=block
+    )
+
+  @v_args(inline=True)
+  def func_type(self, params=None, return_type=None):
+    if params is None:
+      params = []
+    return FunctionType(params, return_type)
+
+  @v_args(inline=True)
+  def call_func(self,id,parameters):
+    return CallExpression(
+      callee=id,
+      args=[] if parameters is None else parameters
+    )
+
+  @v_args(inline=True)
+  def return_type(self, type_):
+    return type_
+
+  def args_list(self, params):
+    return params
+
+  def param_list(self, params):
+    return params
+
+  @v_args(inline=True)
+  def param(self, type_, name):
+    return (type_, name)
+
+  @v_args(inline=True)
+  def return_statement(self, expr=None):
+    return ReturnStatement(expr)
+
+  @v_args(inline=True)
+  def lambda_expr(self, params=None, return_type=None, body=None):
+    if params is None:
+      params = []
+
+    if return_type is None:
+      return_type = VoidType()
+
+    return LambdaExpression(
+      params=params,
+      return_type=return_type,
+      body=body
+    )
+
+  # ---------------- REMOVE LATER ----------------
+
+  @v_args(inline=True)
+  def print_variable(self,expr):
+    return PrintStatement(expr)

brasa_lang-0.1.0/brasa/repl.py

@@ -0,0 +1,52 @@
+from brasa.runner import Interpreter
+from brasa.runner import run_code
+
+import readline
+
+readline.read_history_file('.brasa_history')
+readline.write_history_file('.brasa_history')
+
+def repl():
+  interpreter=Interpreter()
+  buffer=''
+
+  print(r'''
+==========================================================
+ _______    _______        __        ________     __      
+|   _  "\  /"      \      /""\      /"       )   /""\     
+(. |_)  :)|:        |    /    \    (:   \___/   /    \    
+|:     \/ |_____/   )   /' /\  \    \___  \    /' /\  \   
+(|  _  \\  //      /   //  __'  \    __/  \\  //  __'  \  
+|: |_)  :)|:  __   \  /   /  \\  \  /" \   :)/   /  \\  \ 
+(_______/ |__|  \___)(___/    \___)(_______/(___/    \___)
+
+==========================================================
+
+Type "exit" or "quit" to leave Brasa Interactive Environment
+  ''')
+
+  while True:
+    try:
+      prompt='>>> ' if not buffer else '... '
+      line=input(prompt)
+
+      if line.strip() in {'exit','quit'}:
+        break
+
+      buffer+=line+'\n'
+
+      try:
+        result=run_code(
+          buffer,
+          interpreter=interpreter
+        )
+
+        buffer=''
+
+        if result is not None:
+          print(result)
+      except Exception:
+        continue
+    except KeyboardInterrupt:
+      print('\nKeyboardInterrupt')
+      buffer=''

brasa_lang-0.1.0/brasa/runner.py

@@ -0,0 +1,48 @@
+from pathlib import Path
+
+from lark import Lark
+
+from brasa.parser.ast_builder import ASTBuilder
+from brasa.interpreter.interpreter import Interpreter
+
+def load_grammar(grammar_path):
+  with open(
+    grammar_path,
+    'r',
+    encoding='utf-8'
+  ) as g:
+    parser=Lark(
+      g.read(),
+      start='start',
+      maybe_placeholders=True
+    )
+
+  return parser
+
+def run_code(
+  code:str,
+  interpreter=None
+):
+  parser=load_grammar(
+    Path(__file__).parent/'parser'/'grammar.lark'
+  )
+
+  raw_tree=parser.parse(code)
+  ast=ASTBuilder().transform(raw_tree)
+
+  if interpreter is None:
+    interpreter = Interpreter()
+
+  return interpreter.visit(ast)
+
+def run_file(file_path:str):
+  file_path=Path(file_path).resolve()
+
+  if not file_path.exists():
+    print(f'Error: File "{file_path}" does not exist.')
+    return
+
+  with open(file_path,'r') as f:
+    code=f.read()
+
+  run_code(code)

brasa_lang-0.1.0/brasa/runtime/scope.py

@@ -0,0 +1,21 @@
+class Scope:
+  def __init__(self, parent=None):
+    self.parent = parent
+    self.symbols = {} # variable name -> entity id
+
+  # ---------------- DECLARE ----------------
+  def declare(self, name, var_id):
+    if name in self.symbols:
+      raise Exception(f'Error: Variable "{name}" has already been declared in this scope')
+
+    self.symbols[name] = var_id
+
+  # ---------------- LOOKUP ----------------
+  def lookup(self, name):
+    if name in self.symbols:
+      return self.symbols[name]
+
+    if self.parent:
+      return self.parent.lookup(name)
+
+    raise Exception(f'Variable "{name}" has not been found')

brasa_lang-0.1.0/brasa/runtime/world.py

@@ -0,0 +1,35 @@
+class World:
+  def __init__(self):
+    self.next_id = 0
+
+    self.types = {} # entity id -> Type
+    self.values = {} # entity id -> Value
+    self.const = set() # (entity id)[]
+
+  # ---------------- CREATE VARIABLE ----------------
+  def create(self, type_, value, is_const=False):
+    var_id = self.next_id
+    self.next_id += 1
+    self.types[var_id] = type_
+    self.values[var_id] = value
+
+    if is_const:
+      self.const.add(var_id)
+
+    return var_id
+
+  # ---------------- GETTERS ----------------
+  def get_type(self, var_id):
+    return self.types[var_id]
+
+  def get_value(self, var_id):
+    return self.values[var_id]
+
+  def set_value(self, var_id, value):
+    if var_id in self.const:
+      raise Exception('Cannot modify const variable')
+
+    self.values[var_id] = value
+
+  def is_const(self, var_id):
+    return var_id in self.const

brasa_lang-0.1.0/brasa_lang.egg-info/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: brasa-lang
+Version: 0.1.0
+Summary: Brasa programming language
+Author: Adriano
+Requires-Python: >=3.10

brasa_lang-0.1.0/brasa_lang.egg-info/SOURCES.txt

@@ -0,0 +1,29 @@
+README.md
+pyproject.toml
+brasa/__init__.py
+brasa/cli.py
+brasa/repl.py
+brasa/runner.py
+brasa/core/__init__.py
+brasa/core/nodes/__init__.py
+brasa/core/nodes/basics.py
+brasa/core/nodes/operators.py
+brasa/core/nodes/statements.py
+brasa/core/nodes/types.py
+brasa/core/nodes/values.py
+brasa/core/types/__init__.py
+brasa/core/types/lvalues.py
+brasa/core/types/operators.py
+brasa/interpreter/__init__.py
+brasa/interpreter/interpreter.py
+brasa/interpreter/signals.py
+brasa/parser/__init__.py
+brasa/parser/ast_builder.py
+brasa/runtime/__init__.py
+brasa/runtime/scope.py
+brasa/runtime/world.py
+brasa_lang.egg-info/PKG-INFO
+brasa_lang.egg-info/SOURCES.txt
+brasa_lang.egg-info/dependency_links.txt
+brasa_lang.egg-info/entry_points.txt
+brasa_lang.egg-info/top_level.txt

brasa_lang-0.1.0/brasa_lang.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

brasa_lang-0.1.0/brasa_lang.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+brasa = brasa.cli:main

brasa_lang-0.1.0/brasa_lang.egg-info/top_level.txt

@@ -0,0 +1 @@
+brasa

brasa_lang-0.1.0/pyproject.toml

@@ -0,0 +1,12 @@
+[project]
+name = "brasa-lang"
+version = "0.1.0"
+description = "Brasa programming language"
+authors = [{name="Adriano"}]
+requires-python = ">=3.10"
+
+[project.scripts]
+brasa = "brasa.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["brasa*"]

brasa_lang-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+