parser-transform

{LRParser,LRParsingTable,Grammar,CanonicalCollection,LRParserGenerator} = require 'syntax-cli' {EntryType} = LRParsingTable SpecialSymbols = require 'syntax-cli/dist/special-symbols.js' Stream = require 'stream' vm = require 'vm' class StreamingLRParserGenerator extends LRParserGenerator constructor: ({grammar,options = {}}) -> super {grammar,options} @context = yytext: '' yyleng: 0 __: null __handler: [] context = vm.createContext @context @vm = eval: (code) -> vm.runInContext code, context return This is in `traits`. buildSemanticAction: (production) -> # action is the text action = @getSemanticActionCode production return null unless action # args is the Array containing the argument names args = @getSemanticActionParams production # Save the action, they are injected later. # "__handler[1]", "__handler[2]", etc. index = production.getNumber() name = "__handler[#{index}]" handler = @vm.eval "__handler[#{index}] = async function (#{args}) {\n#{action}\n}" name generateModuleInclude: -> moduleInclude = @_grammar.getModuleInclude() if moduleInclude? @vm.eval moduleInclude return Replaces the "template" class StreamingLRParser constructor: (generator) -> @_generator = generator @_grammar = generator._grammar @_table = generator.getTable() @_stack = [] @_startingState = @_table._canonicalCollection .getStartingState() .getNumber() @_stack.push @_startingState @_shiftedToken = null return _peek: LRParser::_peek _shift: LRParser::_shift _reduce: (entry,token) -> productionNumber = entry.slice(1) production = this._grammar.getProduction(productionNumber) hasSemanticAction = production.hasSemanticAction() semanticValueArgs = if hasSemanticAction then [] else null locationArgs = if hasSemanticAction and this._grammar.shouldCaptureLocations() then [] else null # Pop 2x symbols from the stack (RHS + state number for each), # unless it's an ε-production for which nothing to pop. unless production.isEpsilon() rhsLengh = production.getRHS().length while rhsLengh-- # Pop state number this._stack.pop() # Pop production symbol. stackEntry = this._stack.pop() if (hasSemanticAction) semanticValueArgs.unshift(stackEntry.semanticValue) if (locationArgs) locationArgs.unshift(stackEntry.loc) previousState = @_peek() symbolToReduceWith = production.getLHS().getSymbol() reduceStackEntry = {symbol: symbolToReduceWith} if hasSemanticAction @_generator.context.yytext = if token then token.value else '' @_generator.context.yyleng = if token then token.value.length else 0 semanticActionArgs = if locationArgs isnt null semanticValueArgs.concat(locationArgs) else semanticValueArgs # Run corresponding semantic action, result is in $$ (__). handler = @_generator.context.__handler[productionNumber] await handler(semanticActionArgs...).catch console.error reduceStackEntry.semanticValue = @_generator.context.__ if (locationArgs) reduceStackEntry.loc = CodeUnit.getSandbox().$$loc # Then push LHS. this._stack.push(reduceStackEntry) nextState = this._table.get()[previousState][symbolToReduceWith] # And push the next state (goto) this._stack.push(nextState) return class ParserTransform extends Stream.Transform constructor: (grammar,options = {}) -> options.objectMode = true super options generator = new StreamingLRParserGenerator {grammar} generator.generateParserData() generator.context.emit = (chunk) => @push chunk @parser = new StreamingLRParser generator return _transform: (chunk,encoding,next) -> token = type: if chunk.eof then SpecialSymbols.EOF else chunk.token value: chunk.text line: chunk.line column: chunk.column unless @parser._stack.length >= 1 next new Error "Parser stack too small" return state = @parser._peek() column = token.type entry = @parser._table.get()[state][column] unless entry next new Error "Unexpected token #{column} in state #{state} at line #{token.line} column #{token.column}" return switch LRParsingTable.getEntryType(entry) when EntryType.SHIFT @parser._shift token, entry @parser._shiftedToken = token next() when EntryType.REDUCE do => try await @parser._reduce entry, @parser._shiftedToken # Don't advance tokens on reduce. @_transform chunk,encoding,next catch error next error return when EntryType.SR_CONFLICT next new Error "ConflictError: shift-reduce in #{state}, #{column}" when EntryType.RR_CONFLICT next new Error "ConflictError: reduce-reduce in #{state}, #{column}" when EntryType.ACCEPT # Pop starting production and its state number. @parser._stack.pop() parsed = @parser._stack.pop() unless @parser._stack.length is 1 and @parser._stack[0] is @parser._startingState and chunk.eof next new Error "Unexpected token #{token}" return result = {status: 'accept'} if parsed.hasOwnProperty 'semanticValue' result.value = parsed.semanticValue @emit 'success', result next() return _final: (next) -> do => error = null try while @parser._stack.length > 1 await new Promise (resolve) => @_transform eof:true, null, resolve catch error if error? next error else next() return return module.exports = ParserTransform