PegLegParser (org.singlefilejava:single-file-java 1.1.0 API)

java.lang.Object
- org.sfj.PegLegParser<V>

Type Parameters:

V - Value stack type.

All Implemented Interfaces:

Supplier<PegLegParser<V>>

Direct Known Subclasses:

JsonPegParser
```
public class PegLegParser<V>
extends Object
implements Supplier<PegLegParser<V>>
```
This class implements a complete PEG parser, a la https://en.wikipedia.org/wiki/Parsing_expression_grammar
I have long been a big fan of the Parboiled parser framework ( https://github.com/sirthias/parboiled/wiki ), especially for quick and dirty things. But I also always disliked the proxying/byte code manipulation in it. A looong while ago I looked at building one myself with just anon classes, around Java 6 timeframe, but it was super clunky. For a while now I have wanted to take another swing at it using lambdas; it seemed like a way to do all of what Parboiled (and Rats!, etc) did without needing anything too exotic.
Turns out, yup, works pretty well. An approach like this will never be the quickest parser to run, I mean, there is no packrat processing, no memoization, etc. So it is not a speed demon. But the intention was to make it super expressive and a speed demon to write parsers.
See the PegLeParser.adoc file for an overview on how it works, and see the unit test class for a set of example grammars.

Author:

cschanck

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`PegLegParser.CharTerminal<V>` Terminal based on some set of characters.
`static interface`	`PegLegParser.Exec` An execution, which return true to continue parsing, false to stop.
`class`	`PegLegParser.ParentRule`
`static interface`	`PegLegParser.PegLegRule<V>` A Rule.
`static class`	`PegLegParser.Ref<V>` Random holder class for intra rule parser data manipulation.
`static class`	`PegLegParser.RuleReturn<V>` Rule return.
`static class`	`PegLegParser.SourceFrame`
`static class`	`PegLegParser.SourcePosition`
`static interface`	`PegLegParser.TerminalRule<V>` Terminal rule, with optional ignoring of case.
`static class`	`PegLegParser.Values<V>` Stack of values.

Field Summary

Fields
Modifier and Type Field and Description

PegLegParser.SourcePosition farthestSuccessfulPos

Fields
Modifier and Type	Field and Description
`PegLegParser.SourcePosition`	`farthestSuccessfulPos`

Constructor Summary

Constructors
Constructor and Description

PegLegParser()

Constructors
Constructor and Description
`PegLegParser()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`PegLegParser.PegLegRule<V>`	`anyChar()` Rule with matches any character.
`PegLegParser.CharTerminal<V>`	`anyOf(CharSequence string)` Generates a rule which matches any single char in the char sequence.
`PegLegParser.CharTerminal<V>`	`ch(char ch)` Generate a terminal rule for a specific character.
`PegLegParser.CharTerminal<V>`	`charRange(char from, char to)` Generate a terminal rule for a range of characters.
`PegLegParser.CharTerminal<V>`	`dictionaryOf(String... strings)` Dictionary lookup, optimized.
`PegLegParser.PegLegRule<V>`	`empty()` Returns true, matches nothing, consumes nothing.
`PegLegParser.PegLegRule<V>`	`eof()`
`PegLegParser.PegLegRule<V>`	`eol()`
`protected IllegalArgumentException`	`error(String message)`
`PegLegParser.Exec`	`ex(Runnable del)` Execs a blob of code, always continues parsing.
`PegLegParser.ParentRule`	`firstOf(Object... objs)` Core PEG rule "Choice", here called firstOf.
`PegLegParser<V>`	`get()` Get context object at the moment.
`String`	`getFailureMessage()`
`PegLegParser.SourcePosition`	`getFarthestSuccessfulPos()`
`PegLegParser.RuleReturn<V>`	`getLastReturn()` Last rule return.
`PegLegParser.RuleReturn<V>`	`getLastSuccessfulReturn()`
`String`	`getWhiteSpace()`
`Optional<String>`	`match()` The last rule's matched literal.
`PegLegParser.PegLegRule<V>`	`named(String name, PegLegParser.PegLegRule<V> del)` name a rule
`PegLegParser.CharTerminal<V>`	`noneOf(CharSequence string)` Rule that matches any character not contained in the char sequence specified.
`PegLegParser.PegLegRule<V>`	`nothing()` Always fails to match, consumes nothing
`PegLegParser.ParentRule`	`onePlusOf(Object... objs)` Core PEG rule "OneOrMore", matches the given set of rules, greedily, one or more times.
`PegLegParser.ParentRule`	`optOf(Object... objs)` Core PEG rule "Optional", matches the given set of rules, greedily, zero or one times.
`PegLegParser.RuleReturn<V>`	`parse(PegLegParser.PegLegRule<V> rule)` A Parsing entry point.
`List<String>`	`parseTrail()`
`PegLegParser.ParentRule`	`seqOf(Object... objs)` Core PEG rule: "Sequence".
`void`	`setLineSeparator(String sep)`
`void`	`setWhiteSpace(String whiteSpace)`
`PegLegParser.CharTerminal<V>`	`str(CharSequence string)` Generate a rule for a specific string (char sequence)
`PegLegParser.Exec`	`testExec(PegLegParser.Exec del)` Execs a blob of code, stops parsing if returns false.
`PegLegParser.ParentRule`	`testNotOf(Object... objs)` Core PEG rule: "TestNot".
`PegLegParser.ParentRule`	`testOf(Object... objs)` Core PEG Rule, "Test" returns true if sequence of rules matches, but does not consume input.
`PegLegParser.ParentRule`	`timesOf(int min, int max, Object... objs)` Rule with matches only if matches set of rules between min and max times.
`PegLegParser.ParentRule`	`timesOf(int many, Object... objs)` Rule with matches only if matches set of rules exactly many times.
`PegLegParser<V>`	`using(CharSequence input)` Reset parser for given input.
`PegLegParser.Values<V>`	`values()` Value stack.
`PegLegParser.PegLegRule<V>`	`ws()` Whitespace rule.
`PegLegParser.CharTerminal<V>`	`ws(char ch)` Generates a rule for the char, allowing any amount of preceding/following whitespace.
`PegLegParser.CharTerminal<V>`	`ws(CharSequence string)` Generates a rule for the char sequence, allowing any amount of preceding/following whitespace.
`PegLegParser.ParentRule`	`zeroPlusOf(Object... objs)` Core PEG rule "ZeroOrMore", matches the given set of rules, greedily, zero or more times.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - farthestSuccessfulPos
```
public PegLegParser.SourcePosition farthestSuccessfulPos
```
- Constructor Detail
  - PegLegParser
```
public PegLegParser()
```
- Method Detail
  - parseTrail
```
public List<String> parseTrail()
```
  - match
```
public Optional<String> match()
```
    The last rule's matched literal.
    
    Returns:
    
    last match literal
  - getLastReturn
```
public PegLegParser.RuleReturn<V> getLastReturn()
```
    Last rule return.
    
    Returns:
    
    rule return
  - getLastSuccessfulReturn
```
public PegLegParser.RuleReturn<V> getLastSuccessfulReturn()
```
  - setWhiteSpace
```
public void setWhiteSpace(String whiteSpace)
```
  - setLineSeparator
```
public void setLineSeparator(String sep)
```
  - getWhiteSpace
```
public String getWhiteSpace()
```
  - using
```
public PegLegParser<V> using(CharSequence input)
```
    Reset parser for given input.
    
    Parameters:
    
    input - string input
    
    Returns:
    
    this parser.
  - get
```
public PegLegParser<V> get()
```
    Get context object at the moment.
    
    Specified by:
    
    get in interface Supplier<PegLegParser<V>>
    
    Returns:
    
    context object
  - error
```
protected IllegalArgumentException error(String message)
```
  - ch
```
public PegLegParser.CharTerminal<V> ch(char ch)
```
    Generate a terminal rule for a specific character.
    
    Parameters:
    
    ch - char
    
    Returns:
    
    rule
  - charRange
```
public PegLegParser.CharTerminal<V> charRange(char from,
                                              char to)
```
    Generate a terminal rule for a range of characters.
    
    Parameters:
    
    from - lower bound
    
    to - upper bound.
    
    Returns:
    
    rule
  - str
```
public PegLegParser.CharTerminal<V> str(CharSequence string)
```
    Generate a rule for a specific string (char sequence)
    
    Parameters:
    
    string - char sequence
    
    Returns:
    
    rule
  - ws
```
public PegLegParser.CharTerminal<V> ws(CharSequence string)
```
    Generates a rule for the char sequence, allowing any amount of preceding/following whitespace.
    
    Parameters:
    
    string - char sequence
    
    Returns:
    
    rule
  - ws
```
public PegLegParser.CharTerminal<V> ws(char ch)
```
    Generates a rule for the char, allowing any amount of preceding/following whitespace.
    
    Parameters:
    
    ch - character
    
    Returns:
    
    rule
  - ws
```
public PegLegParser.PegLegRule<V> ws()
```
    Whitespace rule. matches zero or more whitespace chars.
    
    Returns:
    
    rule
  - anyOf
```
public PegLegParser.CharTerminal<V> anyOf(CharSequence string)
```
    Generates a rule which matches any single char in the char sequence.
    
    Parameters:
    
    string - candidate chars.
    
    Returns:
    
    rule
  - dictionaryOf
```
public PegLegParser.CharTerminal<V> dictionaryOf(String... strings)
```
    Dictionary lookup, optimized.
    
    Parameters:
    
    strings - set of strings to match
    
    Returns:
    
    rule
  - noneOf
```
public PegLegParser.CharTerminal<V> noneOf(CharSequence string)
```
    Rule that matches any character not contained in the char sequence specified.
    
    Parameters:
    
    string - char sequence not to match
    
    Returns:
    
    rule
  - eof
```
public PegLegParser.PegLegRule<V> eof()
```
  - eol
```
public PegLegParser.PegLegRule<V> eol()
```
  - seqOf
```
public PegLegParser.ParentRule seqOf(Object... objs)
```
    Core PEG rule: "Sequence". Matches a list of sub rules in order. All must match, or none do. Probably the most important rule.
    
    Parameters:
    
    objs - rules/string literals/char literals/execs
    
    Returns:
    
    sequence rule
  - firstOf
```
public PegLegParser.ParentRule firstOf(Object... objs)
```
    Core PEG rule "Choice", here called firstOf. Tries each sub rule in turn, return first match.
    
    Parameters:
    
    objs - rules/string literals/char literals/execs
    
    Returns:
    
    rule
  - testOf
```
public PegLegParser.ParentRule testOf(Object... objs)
```
    Core PEG Rule, "Test" returns true if sequence of rules matches, but does not consume input.
    
    Parameters:
    
    objs - rules/string literals/char literals/execs
    
    Returns:
    
    rule
  - testNotOf
```
public PegLegParser.ParentRule testNotOf(Object... objs)
```
    Core PEG rule: "TestNot". Matches in set of sub rules does not match, does not consume input.
    
    Parameters:
    
    objs - rules/string literals/char literals/execs
    
    Returns:
    
    rule
  - timesOf
```
public PegLegParser.ParentRule timesOf(int min,
                                       int max,
                                       Object... objs)
```
    Rule with matches only if matches set of rules between min and max times. Greedy, but stops at max.
    
    Parameters:
    
    min - min times to match
    
    max - max times to match
    
    objs - rules/string literals/char literals/execs
    
    Returns:
    
    rule
  - timesOf
```
public PegLegParser.ParentRule timesOf(int many,
                                       Object... objs)
```
    Rule with matches only if matches set of rules exactly many times.
    
    Parameters:
    
    many - times to match
    
    objs - rules/string literals/char literals/execs
    
    Returns:
    
    rule
  - zeroPlusOf
```
public PegLegParser.ParentRule zeroPlusOf(Object... objs)
```
    Core PEG rule "ZeroOrMore", matches the given set of rules, greedily, zero or more times.
    
    Parameters:
    
    objs - rules/string literals/char literals/execs
    
    Returns:
    
    rule
  - onePlusOf
```
public PegLegParser.ParentRule onePlusOf(Object... objs)
```
    Core PEG rule "OneOrMore", matches the given set of rules, greedily, one or more times.
    
    Parameters:
    
    objs - rules/string literals/char literals/execs
    
    Returns:
    
    rule
  - optOf
```
public PegLegParser.ParentRule optOf(Object... objs)
```
    Core PEG rule "Optional", matches the given set of rules, greedily, zero or one times.
    
    Parameters:
    
    objs - rules/string literals/char literals/execs
    
    Returns:
    
    rule
  - testExec
```
public PegLegParser.Exec testExec(PegLegParser.Exec del)
```
    Execs a blob of code, stops parsing if returns false.
    
    Parameters:
    
    del - delegate
    
    Returns:
    
    Exec
  - ex
```
public PegLegParser.Exec ex(Runnable del)
```
    Execs a blob of code, always continues parsing.
    
    Parameters:
    
    del - delegate call
    
    Returns:
    
    exec
  - anyChar
```
public PegLegParser.PegLegRule<V> anyChar()
```
    Rule with matches any character.
    
    Returns:
    
    rule
  - nothing
```
public PegLegParser.PegLegRule<V> nothing()
```
    Always fails to match, consumes nothing
    
    Returns:
    
    rule
  - empty
```
public PegLegParser.PegLegRule<V> empty()
```
    Returns true, matches nothing, consumes nothing.
    
    Returns:
    
    rule
  - values
```
public PegLegParser.Values<V> values()
```
    Value stack.
    
    Returns:
    
    value stack
  - parse
```
public PegLegParser.RuleReturn<V> parse(PegLegParser.PegLegRule<V> rule)
```
    A Parsing entry point.
    
    Parameters:
    
    rule - rule to start with
    
    Returns:
    
    rule return value
  - getFarthestSuccessfulPos
```
public PegLegParser.SourcePosition getFarthestSuccessfulPos()
```
  - getFailureMessage
```
public String getFailureMessage()
```
  - named
```
public PegLegParser.PegLegRule<V> named(String name,
                                        PegLegParser.PegLegRule<V> del)
```
    name a rule
    
    Parameters:
    
    name - name
    
    del - delegate
    
    Returns:
    
    rule

Class PegLegParser<V>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

farthestSuccessfulPos

Constructor Detail

PegLegParser

Method Detail

parseTrail

match

getLastReturn

getLastSuccessfulReturn

setWhiteSpace

setLineSeparator

getWhiteSpace

using

get

error

ch

charRange

str

ws

ws

ws

anyOf

dictionaryOf

noneOf

eof

eol

seqOf

firstOf

testOf

testNotOf

timesOf

timesOf

zeroPlusOf

onePlusOf

optOf

testExec

ex

anyChar

nothing

empty

values

parse

getFarthestSuccessfulPos

getFailureMessage

named