birl.peg

// BIRL Grammar
// ==========================
// Generated for peg.js
//

program
  = bl* begin_program ws* bl* program:(expression)* end_program bl*
  {
    return {
      type: 'File',
      program: {
        type: 'Program',
        body: program,
      },
    }
  }

begin_program = 'HORA DO SHOW'
end_program = 'BIRL'

// TOMA ESSES PESOS SEU MERDA
// Types
// ==========================
//

char_type = 'FRANGO'
short_type = 'MONSTRINHO'
int_type = 'MONSTRO'
long_type = 'MONSTRAO'
float_type = 'TRAPEZIO'
double_type = 'TRAPEZIO DESCENDENTE'
unsigned_type = 'BICEPS MONSTRO'

types
 = (char_type /
    short_type /
    int_type /
    long_type /
    float_type /
    double_type /
    unsigned_type)

// TOMA ESSA FUNÇÃO SEU FRANGO!
// Standard functions
// ==========================
//

print_func
  = 'CE QUER VER ESSA PORRA?'

standard_functions
  = (print_func)

// NÃO É ÁGUA COM MÚSCULO
// Useless tokens
// ==========================
//

birl
  = 'BIRL'

// DERRUBAR ARVORE NO IBIRAPUERA
// function tokens
// ==========================
//

function_pre_call
  = 'AJUDA O MALUCO TA DOENTE'

function_pre_declaration
  = 'OH O HOME AI PO'

return_expression
  = ident* 'BORA CUMPADI' ws+
    return_expression:(value / operation_expression / unary_operation / var_identifier / function_call / function_declaration) ws* bl?
  {
    return {
      type: 'ReturnStatement',
      argument: return_expression,
    }
  }

call_args
 = (unary_operation / member_call_statement / function_call / operation / value / var_identifier)

arg_list
  = head:call_args tail:(ws? ',' ws? call_args)*
  {
    var array = [head]
    for (var t in tail) {
        array.push(tail[t][3])
    }
    return array
  }

standard_function_call
  = function_name:standard_functions ws* '(' ws* args:arg_list? ws* ')'
  {
    /* VIRA console.log MONSTRAO */
    return {
      type: 'CallExpression',
      arguments: args,
      callee: {
        type: 'MemberExpression',
        object: {
          type: 'Identifier',
          name: 'console',
        },
        property: {
          type: 'Identifier',
          name: 'log',
        },
      },
    }
  }

function_call
  = function_pre_call ws callee:var_identifier '(' args:arg_list ')'
  {
    return {
      type: 'CallExpression',
      callee,
      arguments: args,
    }
  }

simple_function_call
  = callee:var_identifier '(' ws* args:arg_list? ws* ')'
  {
    return {
      type: 'CallExpression',
      callee,
      arguments: args,
    }
  }

arg_declaration_list
  = head:( types ws+ var_identifier) tail:(ws* ',' ws+ types ws var_identifier)* ws*
  {
    var array = [head[2]]
    for (var t in tail) {
        const arg = tail[t];
        array.push(arg[5]);
    }
    return array
  }

function_declaration
  = function_pre_declaration ws+ types ws+ function_identifier:var_identifier ws* '(' params:arg_declaration_list ')' ws* bl
    ident* body:mandatory_block
    ident* birl
  {
    return {
      type: 'FunctionDeclaration',
      id: function_identifier,
      params,
      body,
    }
  }

// TRAPEZIO DESCENDENTE
// member expressions
// ==========================
//

member_statement
  = head:var_identifier '.' tail:(var_identifier '.')* final:var_identifier
  {
    const initial = head;
    tail.push([final])
    return tail.reduce((acc, value) => {
      return {
        type: 'MemberExpression',
        object: acc,
        property: value[0],
      }
    }, initial);
  }

member_call_statement
  = callee:(member_statement)
    args:(
      ("(" (ws* arg_list ws*)? ")") /
      ("[" ws* arg_list ws* "]")
    )*
  {
    let result = callee;
    args.forEach((arg) => {
      if (arg && arg[0] == "(") {
        const a = arg[1] ? arg[1][1] : null;
        result = {
          type: "CallExpression",
          arguments: a,
          callee: result,
        };
      }
      if (arg && arg[0] == "[") {
        result = {
          type: 'MemberExpression',
          object: result,
          property: arg[2].pop(), /* Because js is amazing, sike */
        };
      }
    });
    return result;
  }

member_expression = member_expression:(member_call_statement)
  {
    return member_expression;
  }

// ELE QUE A GENTE QUER
// if expressions
// ==========================
//

condition_expressions = (
  operation /
  function_call /
  variable_name /
  value
)

mandatory_block
  = head:(inner_block_expressions) bl* tail:(inner_block_expressions)* bl*
  {
    const block_expressions = [head];
    for (var t in tail) {
      block_expressions.push(tail[t]);
    }
    return {
      type: 'BlockStatement',
      body: block_expressions,
    };
  }

else_if_block
  = ident* 'QUE NAO VAI DAR O QUE?' ws+ test:condition_expressions ws* bl
    ident* block:mandatory_block
    ident* alternate:(else_block /else_if_block)?
  {
    return {
      type: 'IfStatement',
      test,
      consequent: block,
      alternate,
    }
  }

else_block
  = ident* 'NAO VAI DAR NAO' ws* bl
    ident* block:mandatory_block
  {
    return block
  }

if_expression =
    ident* 'ELE QUE A GENTE QUER?'
    ws+ test:condition_expressions ws* bl
    ident* consequent:(mandatory_block)
    alternate:(else_block / else_if_block)?
    ident* birl
    { return {
        type: 'IfStatement',
        test,
        consequent,
        alternate,
      }
    }

// OS EXERCICIOS SEU FRANGO
// operations
// ==========================
//

sum_operator = '+'
minus_operator = '-'
mult_operator = '*'
division_operator = '/'
modulo_operator = '%'
lt_operator = '<'
lte_operator = lt_operator '='
gt_operator = '>'
gte_operator = gt_operator '='
equal_operator = '=='
nequal_operator = '!='
or_operator = '||'
and_operator = '&&'

operators
  = (
    sum_operator /
    minus_operator /
    mult_operator /
    division_operator /
    modulo_operator /
    lt_operator /
    lte_operator /
    gt_operator /
    gte_operator /
    equal_operator /
    nequal_operator /
    or_operator /
    and_operator
 )

operation_expression = op:operation
  {
    return op
  }

operation
  = head:Factor tail:(_ (operators) _ Factor)+ {
    if (tail.length == 0) {
      return head;
    }
    const result = {
      type: 'BinaryExpression',
      left: head,
    };
    return tail.reduce(function(result, element) {
      const expr = {
        type: 'BinaryExpression',
        operator: element[1],
        left: result,
        right: element[3],
      };
      return expr;
    }, head);
  }

operation_values
  = (unary_operation /
     member_call_statement /
     simple_function_call /
     function_call /
     var_identifier /
     value)

Factor
  = expr:("(" _ operation _ ")" / operation_values)
  {
    if (expr.length) {
      return expr[2];
    }
    return expr;
  }

_ "whitespace"
  = [ \t\n\r]*

unary_operators = operator:('++' / '--')
  {
    return operator
  }

unary_operation = var_identifier:var_identifier operator:unary_operators
  {
    return {
      type: 'UpdateExpression',
      argument: var_identifier,
      operator,
    }
  }

// BORA DE NOVO PORRA
// loops
// ==========================
//

continue = ident:ident* 'VAMO MONSTRO'
  {
    return {
      type: 'ContinueStatement'
    }
  }

break = ident:ident* 'SAI FILHO DA PUTA'
  {
    return {
      type: 'BreakStatement',
    }
  }

for_block
  = head:(inner_block_expressions) bl* tail:(inner_block_expressions)* bl*
  {
    const block_expressions = [head];
    for (var t in tail) {
      block_expressions.push(tail[t]);
    }
    return {
      type: 'BlockStatement',
      body: block_expressions,
    };
  }

for_loop
  = ident* 'MAIS QUERO MAIS' ws+ '(' ws*
    init:(var_attribution / var_declaration) ws* ';'
    ws* test:condition_expressions ws* ';'
    ws* update:(operation / unary_operation) ws* ')' ws* bl*
    ident* body:for_block
    ident* birl
  {
    return {
      type: 'ForStatement',
      init,
      test,
      update,
      body,
    }
  }

while_loop
  = ident* 'NEGATIVA BAMBAM' ws+ '(' ws* test:condition_expressions ws* ')' ws* bl
    ident* body:for_block
    ident* birl
  {
    return {
        type: 'WhileStatement',
        test,
        body,
    }
  }

// BIRRRLLL É TREZE PORRA
// values and expression
// ==========================
//

inner_block_expressions = block:(continue / break / expression / expression_statement) bl?
  {
    return block
  }

expression_statement = expression:(
    var_attribution /
    member_expression /
    function_call /
    standard_function_call /
    simple_function_call /
    operation_expression /
    unary_operation /
    value
  )
  {
    return {
      type: 'ExpressionStatement',
      expression,
    }
  }

// Expression is probably overused, migrating to expression_statement
expression
  = ident:ident* expression:(
    for_loop /
    while_loop /
    var_declaration /
    function_declaration /
    if_expression /
    return_expression /
    expression_statement
  ) bl?
  {
    return expression;
  }

value
  = (number / string)

array
  = '[' ws* elements:arg_list? ws* ']'
  {
    return {
      type: "ArrayExpression",
      elements,
    }
  }

object
  = '{' ws* bl* ws* key_values:(
          (value ws* ':' ws* call_args ws* bl*)
          (',' ws* bl* ws* value ws* ':' ws* call_args)*
        )* ws* ','? ws* bl*
    ws* '}'
  {
    const values = [key_values[0][0]].concat(key_values[0][1]);
    const properties = values.map((keyValueArray) => {
      if (keyValueArray.length > 0) {
        const isHead = keyValueArray[0] !== ',';
        const key = isHead ? keyValueArray[0] : keyValueArray[4];
        const value = isHead ? keyValueArray[4] : keyValueArray[8];
        return {
          type: 'ObjectProperty',
          key,
          value,
        }
      }
    });
    return {
      type: 'ObjectExpression',
      properties,
    }
  }

iterable
  = array

var_values
  = (operation / value / array / object / function_call)

attribution_operators = ('=' / '-=' / '+=')

var_attribution
  = var_identifier:var_identifier ws* operator:(attribution_operators) ws* value:var_values
  {
    return {
      type: 'AssignmentExpression',
      operator,
      left: var_identifier,
      right: value,
    }
  }


var_declaration
  = type:types ws variable_name:variable_name ws* '=' ws* value:var_values
  {
    return {
      type: 'VariableDeclaration',
      kind: 'var',
      declarations: [
        {
          type: 'VariableDeclarator',
          id: {
            type: 'Identifier',
            name: variable_name,
          },
          init: value,
        }
      ]
    }
  }

var_identifier
  = variable_name:variable_name
  {
    return {
      type: 'Identifier',
      name: variable_name,
    }
  }

ident
  = '  '

variable_name
  = head:[a-zA-Z_] tail:[a-zA-Z0-9_]* { return head + tail.join("") }

string
  = quotation_mark chars:char* quotation_mark
  {
    return {
      type: 'StringLiteral',
      value: chars.join(""),
    };
  }

number = num:[0-9]+ tail:('.' [0-9]*)? {
  let value = parseInt(num.join(""), 10);
  if (tail) {
    const floatValue = value + '.' + tail[1].join("");
    value = parseFloat(floatValue, 10);
  }
  return {
    type: 'NumericLiteral',
    value,
  }
}

char
  = unescaped
  / escape
    sequence:(
        '"'
      / "\\"
      / "/"
      / "b" { return "\b"; }
      / "f" { return "\f"; }
      / "n" { return "\n"; }
      / "r" { return "\r"; }
      / "t" { return "\t"; }
      / "u" digits:$(HEXDIG HEXDIG HEXDIG HEXDIG) {
          return String.fromCharCode(parseInt(digits, 16));
        }
    )
    { return sequence; }

escape         = "\\"
quotation_mark = '"'
unescaped      = [\x20-\x21\x23-\x5B\x5D-\u10FFFF]
HEXDIG = [0-9a-f]i
bl = [\n]+
ws = [ \t\r]+