Syntax analysis (compiler step just after lexer).

npm i @jlguenego/syntax-analysis 

You should use Typescript in order to check your grammar in a easier way.

const t = defineTerminalAlphabet(['a', 'b'] as const); const nt = defineNonTerminalAlphabet(['S', 'A'] as const); const spec: CFGSpecifications<typeof nt, typeof t> = { nt, t, productions: [ {LHS: 'S', RHS: ['a', 'A', 'a', 'a']}, {LHS: 'S', RHS: ['b', 'A', 'b', 'a']}, {LHS: 'A', RHS: []}, {LHS: 'A', RHS: ['b']}, ], startSymbol: 'S', }; export const cfg = new ContextFreeGrammar(spec); // coming from a lexer (ex: @jlguenego/lexer) const sentence: Sentence = 'abaa'.split('').map(str => ({ name: str, })); // the real job: get the parse tree. const parseTree = parse(sentence, cfg, { method: 'LLk', lookaheadTokenNbr: 2, });

• BFS1: Naive Breadth First Search with nothing else (very slow, may take many days...).
• BFS2: Like BFS1 with 2 checks for speeding BFS (slow, may take many hours...).
  • checks the length of sentential form
  • checks the sentence prefix of the sentential form
• BFS3: Like BFS2 with LeftMost Derivation strategy (not so slow, mak take some minutes...).

• DFS1: Leftmost derivation strategy. (not so slow execpt for left recursive grammar)

• DFS2: Like DFS1 but use one lookahead terminal to speed up a little bit.

• LL1: Like DFS2 but use a LL1 table to know exactly wich production rule to use for the next sentential form. This one is linear O(ng), n is the size of the string to parse, and g is the size of the grammar.

  • Warning: the grammar must be LL(1) compatible. So you may have to refactor your grammar in some case:
    • Convert left recursion to right recursion.
    • Left factoring

• LLk: This one do not use anymore search tree algorithm with possible backtracking but a k predictive algorithm, exactly as described in the Aho Ullman book (see Theory). It parses real LLk grammars (ie not only the strong LLk grammar), k can be any integer ≥ 1.

• LR0: Use an LR0 automaton, and decide to shift or reduce without lookahead.
• LR1: Use an LR1 automaton, and decide to shift or reduce with one lookahead.
• SLR1: Use the LR0 automaton augmented with the FOLLOW terminals, and decide to shift or reduce with one lookahead.
• LALR1: Use the LALR1 automaton (constructed with the "Lazy Merging" technique), and decide to shift or reduce with one lookahead.

Note about grammar: LR0 < SLR1 < LALR1 < LR1.

• @jlguenego/lexer
• @jlguenego/tree

• Stanford CS143
• Theory of Parsing, Translation and Compiling: Compiling vol. 1 - Aho Ullman

Jean-Louis GUENEGO jlguenego@gmail.com