rockstar.peg

/*
PEG grammar for Rockstar (https://codewithrockstar.com)
Created using PEG.js        https://pegjs.org
After updating, run pegjs -o rockstar-parser.js rockstar.peg
*/

{
  /* initialiser code - this is JS that runs before the parser is generated */

  const keywords = new Set([
    // common variable prefixes
    'a', 'an', 'the', 'my', 'your', 'our',

    // pronouns
    'it', 'he', 'she', 'him', 'her', 'they', 'them', 'ze', 'hir', 'zie', 'zir', 'xe', 'xem', 've', 'ver',

    // literal values
    'mysterious',
    'null', 'nothing', 'nowhere', 'nobody', 'gone',
    'true', 'right', 'yes', 'ok',
    'false', 'wrong', 'no', 'lies',
    'maybe', 'definitely', // reserved for future use
    'empty', 'silent', 'silence',

    // assignment
    'let', 'be', 'put', 'into', 'in', // expression
    'is', 'are', 'was', 'were', 'say', 'says', 'said', // poetic

    // operations
    'at', 'rock', 'with', 'roll', 'into', 'push', 'pop', 'like', // arrays
    'cut', 'split', 'shatter', 'join', 'unite', 'cast', 'burn', // strings
    'build', 'up', 'knock', 'down', // increment/decrement
    'plus', 'with', 'minus', 'without', 'times', 'of', 'over', 'between', // arithmetic
    'and', // list arithmetic
    'turn', 'up', 'down', 'round', 'around', // rounding
    'and', 'or', 'nor', 'not', // logical

    // comparison
    'is', "isn't", 'isnt', "ain't", 'aint',
    'arent', "aren't", 'wasnt', "wasn't", 'werent', "weren't",
    'not',
    'than',
    'higher', 'greater', 'bigger', 'stronger',
    'lower', 'less', 'smaller', 'weaker',
    'as',
    'high', 'great', 'big', 'strong',
    'low', 'little', 'small', 'weak',

    // input/output
    'listen', 'to',
    'say', 'shout', 'whisper', 'scream',

    // control flow
    'if', 'else',
    'while', 'until',
    'break', 'continue',
    'break', 'it', 'down',
    'take', 'it', 'to', 'the', 'top',
    'take',

    // functions
    'takes', 'wants',
    'give', 'return', 'send', 'back',
    'taking',
  ])

  function isKeyword(string) {
    return keywords.has(string.toLowerCase());
  }
}

program = p:line * { return { list: p.filter(item => item) } }

line = _* s:statement (EOL+ / EOF) { return s }
  /
    EOL { return null }

whitespace  = [ \t]
comment     = '(' [^)]* ')' / '{' [^\}]* '}' / '[' [^\]]* ']'
_           = (whitespace / comment)+

noise 	= (_ / [;,?!&.])
EOL = 	noise* '\r'? '\n'
EOF = !.

ignore_rest_of_line = (_[^\n]*)?

statement   = _* s:(break / continue / function / function_call
			/ function_return / loop / conditional / operation / expression) { return s }

break = 'break'i ignore_rest_of_line {
	return { 'break' : {} }
}

continue = ('continue'i ignore_rest_of_line / 'take it to the top'i) {
	return { 'continue' : {} }
}

takes = ('takes'i / 'wants'i)
function = name:variable _ takes _ args:variable_list EOL body:block EOL
	{ return { 'function': {
    	name: name,
        args: args.map(arg => arg),
        body: body
    } } }


expression_list_separator = (_? ', and'i _ / _?('&' / ',' / "'n'"i)_?)

variable_list_separator   = expression_list_separator / _ 'and'i _

variable_list = head:variable variable_list_separator tail:variable_list
	{ return [head].concat(tail) }
  / arg:variable { return [arg] }

function_call = name:variable _ 'taking'i _ args:expression_list
	{ return { 'call': { name: name, args: Array.isArray(args) ? args : [args] } } }

expression_list = head:simple_expression expression_list_separator tail:expression_list
	{ return [head].concat(tail) }
  / arg:simple_expression { return [arg] }

return = 'return'i / 'give back'i / 'send'i / 'give'i

function_return = return _ e:expression (_ 'back'i)?
	{ return { 'return': { 'expression' : e } } }

operation = readline / output / crement / mutation / assignment / rounding

readline
  = 'listen to'i _ target:assignable
    { return { assign: { expression: { listen : ''}, target: target } } }
	/ 'listen'i
    { return { 'listen' : ''} }

continuation = EOL _* s:statement { return s };

block 	= head:statement tail:(continuation)+
    {
          return { list : [head].concat(tail) }
        }
    / s:statement { return s }

consequent 	= _ s:statement { return s }
      / EOL s:block { return s }

alternate 	= _ 'else'i _ a:statement { return a }
      / EOL+ _* 'else'i _ a:statement { return a }
      / EOL+ _* 'else'i EOL a:block { return a }
            / EOL { return null }

conditional = 'if'i _ e:expression c:consequent? a:alternate?  {
          return {
              'conditional': {
                  'condition' : e,
                    'consequent' : c,
                    'alternate' : a
                }
            };
        }

loopable 	= _ s:statement { return s }
      		/ EOL s:block EOL { return s }

loop 	= 'while'i _ e:expression c:loopable
          { return { 'while_loop': {
            'condition': e,
            'consequent': c
         } }; }
         /
         'until'i _ e:expression c:loopable
          { return { 'until_loop': {
            'condition': e,
            'consequent': c
         } }; }

output      = ('say'i/'shout'i/'whisper'i/'scream'i) _ e:expression
                {return {'output': e}}

simple_expression  =   function_call / constant / lookup / literal / pronoun

literal = constant / number / string

constant = null / true / false / empty_string / mysterious

true 	= ('true'i / 'ok'i / 'right'i / 'yes'i) !letter { return { constant: true } }

false 	= ('false'i / 'lies'i / 'wrong'i / 'no'i) !letter { return { constant: false } }

null 	= ('null'i / 'nothing'i / 'nowhere'i / 'nobody'i / 'gone'i) { return { constant: null } }

empty_string = ('empty'i / 'silent'i / 'silence'i) { return { constant: "" } }

mysterious = 'mysterious'i  { return '__MYSTERIOUS__' }

number      = n:$('-'?[0-9]+ ('.' [0-9]+)?) '.'?
                { return {number: parseFloat(n)} }
      /
              n:$('.' [0-9]+)
                { return {number: parseFloat(n) } }


string      = '"' s:$[^"]* '"'
                { return {string: s}}

expression = boolean

boolean = nor

nor = lhs:or _ 'nor'i _ rhs:nor {
	return { 'binary' : { op: 'nor', lhs: lhs, rhs: rhs } } }
	/ or

or = lhs:and _ 'or'i _ rhs:or {
	return { 'binary': {
        op: 'or',
        lhs: lhs,
        rhs: rhs
    } }
 }
 /and

and = lhs:equality_check _ 'and'i _ rhs:and {
	return { 'binary': {
        op: 'and',
        lhs: lhs,
        rhs: rhs
    } }
 }
 /
 equality_check

eq = isnt { return 'ne' }
   / is   { return 'eq' }

equality_check = lhs:not c:eq rhs:equality_check
	{
      return {
          comparison: {
              comparator: c,
                lhs: lhs,
                rhs: rhs
            }
        };
    }
	/
    not

 not = 'not'i _ e:not { return { 'not': { expression: e} } }
 	/ comparison

comparison = lhs:arithmetic c:comparator rhs:comparison
  {
      return {
          comparison: {
              comparator: c,
                lhs: lhs,
                rhs: rhs
            }
        };
    }
    /
    arithmetic

greater = ('higher'i / 'greater'i / 'bigger'i / 'stronger'i)
smaller = ('lower'i / 'less'i / 'smaller'i / 'weaker'i)
great   = ('high'i / 'great'i / 'big'i / 'strong'i)
small   = ('low'i / 'little'i / 'small'i / 'weak'i)

comparator 	= is greater _ 'than'i     _ { return 'gt' }
            / is smaller _ 'than'i     _ { return 'lt' }
            / is 'as'i _ great _ 'as'i _ { return 'ge' }
            / is 'as'i _ small _ 'as'i _ { return 'le' }


arithmetic         = first:product_simple rest:((add / subtract) product_expression_list)+
                { return rest.reduce(function(memo, curr) {
                      return { binary: { op: curr[0], lhs: memo, rhs: curr[1]} };
                }, first); }
            / product_simple

product     = first:simple_expression rest:((multiply / divide) expression_list)+
                { return rest.reduce(function(memo, curr) {
                    return { binary: { op: curr[0], lhs: memo, rhs: curr[1]} };
                }, first); }

product_simple = product / simple_expression

product_expression_list = product / expression_list

// Note that operator aliases explicitly include a trailing space,
// otherwise 'with' is a prefix code for 'without' and confuses the parser.
add 		= _* ('+' / 'plus 'i / 'with 'i) _*       { return '+' }
subtract 	= _* ('-' / 'minus 'i / 'without 'i) _*   { return '-' }
multiply 	= _* ('*' / 'times 'i / 'of 'i) _*        { return '*' }
divide 		= _* ('/' / 'over 'i / 'between 'i) _*    { return '/' }

compoundable_operator = add / subtract / multiply / divide

pronoun = pronoun:(
    'they'i / 'them'i
    / 'she'i / 'him'i / 'her'i / 'hir'i / 'zie'i / 'zir'i / 'xem'i / 'ver'i
    / 'ze'i / 've'i / 'xe'i / 'it'i / 'he'i
    ) &(is / _ / EOL / EOF)
    { return { pronoun: pronoun.toLowerCase() } }

common_prefix = ( 'an'i / 'a'i / 'the'i / 'my'i / 'your'i / 'our'i)

uppercase_letter = [A-ZÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞĀĂĄĆĈĊČĎĐĒĔĖĘĚĜĞĠĢĤĦĨĪĬĮİIJĴĶĸĹĻĽĿŁŃŅŇŊŌŎŐŒŔŖŘŚŜŞŠŢŤŦŨŪŬŮŰŲŴŶŸŹŻŽ]
lowercase_letter = [a-zàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþāăąćĉċčďđēĕėęěĝğġģĥħĩīĭįıijĵķĸĺļľŀłńņňŋōŏőœŕŗřśŝşšţťŧũūŭůűųŵŷÿźżžʼnß]

letter = uppercase_letter / lowercase_letter

common_variable = prefix:common_prefix _ name:$(letter+)
        { return (prefix + '_' + name).toLowerCase() };

is = ("'s"i / "'re"i / _ ('=' / 'is'i / 'was'i / 'are'i / 'were'i)) _

isnt = _ (
  'isnt'i   / "isn't"i   /
  'aint'i   / "ain't"i   /
  'arent'i  / "aren't"i  /
  'wasnt'i  / "wasn't"i  /
  'werent'i / "weren't"i
  ) _

push  = ('rock'i / 'push'i )
pop   = ('roll'i / 'pop'i)
into  = _ ('into'i / 'in'i) _

delist = pop _ v:variable
  { return { delist: { variable: v } }; }

lookup
  = d:delist { return d; }
  / v:variable _ 'at'i _ i:expression
    { return { lookup: { variable: v, index: i } }; }
  / v:variable
    { return { lookup: { variable: v } }; }

indexer = _ 'at'i _ i:expression { return i };

assignable
  = v:variable i:indexer?
    { return { variable: v, index: i }; }

assignment = target:assignable is _* e:(literal / poetic_number)
    { return { assign: { target: target, expression: e} }; }

  / target:assignable _ ('says 'i / 'say 'i / 'said 'i) e:poetic_string
    { return { assign: { target: target, expression: e} }; }

  / 'put'i _ e:expression into target:assignable
    { return { assign: { target: target, expression: e} }; }


  / 'let'i _ target:assignable _ 'be'i o:compoundable_operator e:(expression_list / expression) {
      return { assign: {
        target: target,
        expression: { binary: {  op: o, lhs: { lookup: target }, rhs: e } }
      } };
    }

  / 'let'i _ t:assignable _ 'be'i _ e:expression
    { return { assign: { target: t, expression: e} }; }

  / push _ e:expression into v:variable
    { return { enlist: { variable: v, expression: e } }; }

  / push _ v:variable _ 'like'i _ e:(literal / poetic_number)
    { return { enlist: { variable: v, expression: e } }; }

  / push _ v:variable (_ 'with'i)? _ e:(expression_list / expression)
    { return { enlist: { variable: v, expression: e } }; }

  / push _ v:variable
    { return { enlist: { variable: v } }; }

  / e:delist into target:assignable
    { return { assign: { target: target, expression: e } }; }

poetic_string = s:$[^\r\n]*
  { return { string: s} }

poetic_number = poetic_digit_separator* n:poetic_digits poetic_digit_separator* d:poetic_decimal? poetic_digit_separator*

  { return { number: parseFloat(d?n+'.'+d:n)}}

poetic_decimal = '.' poetic_decimal_digit_separator* d:poetic_decimal_digits poetic_decimal_digit_separator* {return d}
        /
                '.' poetic_decimal_digit_separator*

poetic_digit_separator = ( _ / [0-9\',;:?!+_/] )

poetic_digits =
  poetic_digit_separator* head:poetic_digit poetic_digit_separator+ tail:poetic_digits
      { return head + tail }
  /
    d: poetic_digit
      { return d }

poetic_decimal_digit_separator = ( _ / poetic_digit_separator / '.')
poetic_decimal_digits =
  poetic_decimal_digit_separator* head:poetic_digit poetic_decimal_digit_separator+ tail:poetic_decimal_digits
      { return head + tail }
  /
    d: poetic_digit
      { return d }

poetic_digit = t:[A-Za-z\-']+
  { return (t.filter(c => /[A-Za-z\-]/.test(c)).length%10).toString()}

variable = common_variable / proper_variable / pronoun / simple_variable

simple_variable = name:$(letter letter*) !{ return isKeyword(name) } { return name.toLowerCase() }

proper_noun = noun:$(uppercase_letter letter*) !{ return isKeyword(noun) } { return noun }

proper_variable = head:$(proper_noun (' ' $proper_noun)*)
  { return head.replace(/ /g, '_').toLowerCase()  }

crement = increment / decrement

increment = 'build'i _ v:variable _ t:('up'i noise*)+
  { return {
      increment: {
          variable: v,
            multiple: t.length
        }
    }; }

decrement = 'knock'i _ v:variable _ t:('down'i noise*)+
  { return {
      decrement: {
          variable: v,
            multiple: t.length
        }
    }; }


split = ('cut'i / 'split'i / 'shatter'i) { return 'split' }
cast = ('cast'i / 'burn'i) { return 'cast' }
join = ('join'i / 'unite'i) { return 'join' }

mutator = split / cast / join
modifier =  _ ('with'i / 'using'i) _ m:expression { return m }

mutation
    = op:mutator _ s:expression into t:assignable m:modifier?
        { return { assign: { target: t, expression: { mutation: { type: op, source: s, modifier: m } } } } ; }
	/ op:mutator _ s:assignable m:modifier?
        { return { assign: { target: s, expression: { mutation: { type: op, source: { lookup: s }, modifier: m } } } } ; }

rounding = floor / ceil / math_round

floor
  = 'turn'i _ v:variable _ 'down'i
    { return { rounding: { variable: v, direction: 'down'  } }; }
  / 'turn'i _ 'down'i _ v:variable
    { return { rounding: { variable: v, direction: 'down'  } }; }

ceil
  = 'turn'i _ v:variable _ 'up'i
    { return { rounding: { variable: v, direction: 'up'  } }; }
  / 'turn'i _ 'up'i _ v:variable
    { return { rounding: { variable: v, direction: 'up' } }; }

math_round
  = 'turn'i _ v:variable _ ('round'i/'around'i)
    { return { rounding: { variable: v, direction: 'nearest' } }; }
  / 'turn'i _ ('round'i/'around'i) _ v:variable
    { return { rounding: { variable: v, direction: 'nearest' } }; }