Merge pull request #115 from davidmclifton/julia-remove-globals

Julia remove globals

Author: DmitrySoshnikov

examples/calc-loc.jl.bnf

@@ -77,5 +77,5 @@ exp
   ;
 
 number
-  : NUMBER { $$ = tryparse(Int, yytext) }
+  : NUMBER { $$ = tryparse(Int, parserdata.yytext) }
   ;

src/plugins/julia/julia-parser-generator-trait.js

@@ -150,8 +150,8 @@ const JuliaParserGeneratorTrait = {
       // Replace $1, $2, @1, ... $$ with _1, _2, _1loc, ... __, etc.
       .replace(/\$(\d+)/g, '_$1')
       .replace(/@(\d+)/g, '_$1loc')
-      .replace(/\$\$/g, 'global __res')
-      .replace(/@\$/g, '__loc');
+      .replace(/\$\$/g, 'parserdata.__res')
+      .replace(/@\$/g, 'parserdata.__loc');
 
     if (this._grammar.shouldCaptureLocations()) {
       action = this.createLocationPrologue(production) + action;
@@ -163,13 +163,13 @@ const JuliaParserGeneratorTrait = {
   createLocationPrologue(production) {
     // Code that goes within the handler itself to handle the location data
     if (production.isEpsilon()) {
-      return 'global __loc = null\n';
+      return 'parserdata.__loc = null\n';
     }
 
     const start = 1;
     const end = production.getRHS().length;
 
-    return `global __loc = yyloc(_${start}loc, _${end}loc)\n`;
+    return `parserdata.__loc = yyloc(_${start}loc, _${end}loc)\n`;
   },
 
   /**
@@ -276,7 +276,7 @@ const JuliaParserGeneratorTrait = {
    * Julia language specific lex rules handler declarations.
    */
   generateLexHandlers() {
-    const handlers = this._generateHandlers(
+    const handlers = this._generateLexHandlers(
       this._lexHandlers,
       '_lexRule',
     );
@@ -287,7 +287,7 @@ const JuliaParserGeneratorTrait = {
    * Julia language specific handler declarations.
    */
   generateProductionHandlers() {
-    const handlers = this._generateHandlers(
+    const handlers = this._generateProductionHandlers(
       this._productionHandlers,
       '_handler',
     );
@@ -320,21 +320,28 @@ const JuliaParserGeneratorTrait = {
   },
 
   /**
-   * Generates function declarations for handlers.
+   * Generates function declarations for production handlers.
    *
    * Example:
    *
-   * function _handler1(_1, _2)
-   *   _res = _1 + _2;
+   * function _handler1(parserdata, _1, _2)
+   *   parserdata._res = _1 + _2;
    * end
-   *
-   * Or:
+   */
+  _generateProductionHandlers(handlers, name) {
+    return handlers.map(({args, action}, index) => {
+      return `function ${name}${index + 1}(parserdata, ${args}) \n${action}\n end`
+    });
+  },
+
+  /**
+   * Generates function declarations for lexical handlers.
    *
    * function _lexRule1()
    *   return "NUMBER";
    * end
    */
-  _generateHandlers(handlers, name) {
+  _generateLexHandlers(handlers, name) {
     return handlers.map(({args, action}, index) => {
       return `function ${name}${index + 1}(${args}) \n${action}\n end`
     });

src/plugins/julia/templates/lr.template.jl

@@ -26,41 +26,40 @@ export parse
 # Shared includes
 using DataStructures
 
-# Constants and globals
+# Basic constants and globals - should capture locations is inserted by the parser generator based on parameters given to the command line
 const EOF = "\$"
-yytext = ""
-yylength = 0
-__res = nothing
-__loc = nothing
-should_capture_locations = {{{CAPTURE_LOCATIONS}}}
+const should_capture_locations = {{{CAPTURE_LOCATIONS}}}
 
 # Types
 struct SyntaxError <: Exception
-    msg::AbstractString
+    msg::String
 end
 
 function Base.showerror(io::IO, err::SyntaxError)
     print(io, err.msg)
 end
 
 Base.@kwdef mutable struct yyLoc
-    startoffset
-    endoffset
-    startline
-    endline
-    startcolumn
-    endcolumn
+    startoffset::Int
+    endoffset::Int
+    startline::Int
+    endline::Int
+    startcolumn::Int
+    endcolumn::Int
 end
 
 Base.@kwdef mutable struct StackEntry
-    symbol
-    semanticvalue
-    loc
+    symbol::Int
+    semanticvalue::Any
+    loc::Union{yyLoc, Nothing}
 end
 
-# --------------------------------------------------------------
-# Module includes provided by the grammar.
-{{{MODULE_INCLUDE}}}
+Base.@kwdef mutable struct ParserData
+    yytext::String
+    yylength::Int = 0
+    __res = nothing
+    __loc = nothing
+end
 
 # --------------------------------------------------------------
 # Tokenizer.
@@ -102,40 +101,46 @@ end
 
 {{{PRODUCTION_HANDLERS}}}
 
+# Constant mappings inserted by the parser generator by processing the grammar definition 
+const productions = {{{PRODUCTIONS}}} # [[1, 2, "handler1"], [3, 4, "handler2], ...] i.e. Vector{Vector{Union{Integer, String}}}
+const table = {{{TABLE}}} # i.e. Dict{Int, String}
+
 # blank stand-ins for begin and end
 function parsebegin() end
 
 function parseend(value) end
 
+# --------------------------------------------------------------
+# Module includes provided by the grammar.
+{{{MODULE_INCLUDE}}}
+
 #=
   Primary parsing function
     ss - the code to parse, in a String
     onParseBegin - a function to call when parsing begins
     onParseEnd - a function to call when parsing ends, should accept as a single argument with the parsed value result
 =#
-# Q for Dmetry: ok to default tokenizer here? other implementations throw but I wanted to keep the parse interface to only the string required
-function parse(ss::AbstractString; tokenizerInitFunction::Function = inittokenizer, onparsebegin::Function = parsebegin, onparseend::Function = parseend)
-    # constants inserted by the parser generator
-    productions = {{{PRODUCTIONS}}} # [[1, 2, "handler1"], [3, 4, "handler2], ...] i.e. Vector{Vector{Union{Integer, String}}}
-    table = {{{TABLE}}} # i.e. Dict{Int, String}
+function parse(ss::AbstractString; tokenizerinitfunction::Function = inittokenizer, onparsebegin::Function = parsebegin, onparseend::Function = parseend)
+    # initialize our parser data
+    parserdata = ParserData(yytext = "", yylength = 0, __res = nothing, __loc = nothing)
 
     # initialization and prep for parsing
     !isnothing(onparsebegin) && onparsebegin()
-    tokenizerData = tokenizerInitFunction(ss)
-    stack = Stack{Union{StackEntry,Integer}}()
+    tokenizerdata = tokenizerinitfunction(ss)
+    stack = Stack{Union{StackEntry,Int}}()
     push!(stack, 0)
 
     # begin parsing
-    token = getnexttoken!(tokenizerData)
+    token = getnexttoken!(parserdata, tokenizerdata)::Token
     shiftedtoken = nothing
-    while hasmoretokens(tokenizerData) || !isempty(stack)
+    while hasmoretokens(tokenizerdata) || !isempty(stack)
         # get a token and look it up in our parsing table
         isnothing(token) && unexpectedendofinput()
         state = first(stack)
         column = token.type
         entry = get(table[state+1], column, nothing)
         if isnothing(entry)
-            unexpectedtoken(tokenizerData, token)
+            unexpectedtoken(tokenizerdata, token)
             break
         end
 
@@ -144,7 +149,7 @@ function parse(ss::AbstractString; tokenizerInitFunction::Function = inittokeniz
             push!(stack, StackEntry(symbol = token.type, semanticvalue = token.value, loc = yyloc(token)))
             push!(stack, tryparse(Int, SubString(entry, 2)))
             shiftedtoken = token
-            token = getnexttoken!(tokenizerData)
+            token = getnexttoken!(parserdata, tokenizerdata)::Token
 
             # found "reduce" instruction, which starts with r then has <production number> to reduce by - i.e. r2 means "reduce by production 2"
         elseif entry[1] == 'r'
@@ -161,12 +166,12 @@ function parse(ss::AbstractString; tokenizerInitFunction::Function = inittokeniz
                     pop!(stack)
 
                     # pop the stack entry
-                    stackEntry = pop!(stack)
+                    stackentry = pop!(stack)
 
                     # collection all the semantic values from the stack to the argument list, which will be passed to the action handler
                     if hassemanticaction
-                        pushfirst!(semanticvalueargs, stackEntry.semanticvalue)
-                        should_capture_locations && pushfirst!(locationargs, stackEntry.loc)
+                        pushfirst!(semanticvalueargs, stackentry.semanticvalue)
+                        should_capture_locations && pushfirst!(locationargs, stackentry.loc)
                     end
                     rhslength -= 1
                 end
@@ -175,19 +180,19 @@ function parse(ss::AbstractString; tokenizerInitFunction::Function = inittokeniz
             symboltoproducewith = production[1]
             reducestackentry = StackEntry(symbol = symboltoproducewith, semanticvalue = nothing, loc = nothing)
             if hassemanticaction
-                global yytext = isnothing(shiftedtoken) ? nothing : shiftedtoken.value
-                global yylength = isnothing(shiftedtoken) ? 0 : length(shiftedtoken.value)
+                parserdata.yytext = isnothing(shiftedtoken) ? nothing : shiftedtoken.value
+                parserdata.yylength = isnothing(shiftedtoken) ? 0 : length(shiftedtoken.value)
                 semanticactionhandler = getfield(SyntaxParser, Symbol(production[3]))
                 semanticactionargs = semanticvalueargs
                 if should_capture_locations
                     semanticactionargs = vcat(semanticactionargs, locationargs)
                 end
 
                 # call the handler the result is put in __res, which is accessed/assigned to by for example $$ = <something> in the grammar
-                semanticactionhandler(semanticactionargs...)
-                reducestackentry.semanticvalue = __res
+                semanticactionhandler(parserdata, semanticactionargs...)
+                reducestackentry.semanticvalue = parserdata.__res
                 if should_capture_locations
-                    reducestackentry.loc = __loc
+                    reducestackentry.loc = parserdata.__loc
                 end
             end
             push!(stack, reducestackentry)
@@ -200,8 +205,8 @@ function parse(ss::AbstractString; tokenizerInitFunction::Function = inittokeniz
             parsed = pop!(stack)
 
             # Check for if the stack has other stuff on it, which would be bad
-            if length(stack) != 1 || first(stack) != 0 || hasmoretokens(tokenizerData)
-                unexpectedtoken(tokenizerData, token)
+            if length(stack) != 1 || first(stack) != 0 || hasmoretokens(tokenizerdata)
+                unexpectedtoken(tokenizerdata, token)
             end
 
             # success!
@@ -215,19 +220,19 @@ function parse(ss::AbstractString; tokenizerInitFunction::Function = inittokeniz
     return nothing
 end
 
-function unexpectedtoken(tokenizerData::TokenizerData, token::Token)
-    if token.type == tokenizerData.EOF_TOKEN.type
+function unexpectedtoken(tokenizerdata::TokenizerData, token::Token)
+    if token.type == EOF_TOKEN.type
         unexpectedendofinput()
     else
-        throwunexpectedtoken(tokenizerData, token.value, token.startline, token.startcolumn)
+        throwunexpectedtoken(tokenizerdata, token.value, token.startline, token.startcolumn)
     end
 end
 
 function unexpectedendofinput()
     parseerror("Unexpected end of input.")
 end
 
-function parseerror(message::AbstractString)
+function parseerror(message)
     throw(SyntaxError(message))
 end