def test_empty_alternative():
p = Parser("""
E ::= "a"
|
""")
p.parse()
assert p.rules[Nonterminal("E")].alternatives == [[Terminal("a")], []]
def test_empty_alternative():
p = Parser("""
E ::= "a"
|
""")
p.parse()
assert p.rules[Nonterminal("E")].alternatives == [[Terminal("a")],[]]
def test_multiple_rules():
p = Parser("""
E ::= A
A ::= \"a\"
""")
p.parse()
assert p.rules[Nonterminal("E")].alternatives == [[Nonterminal("A")]]
assert p.rules[Nonterminal("A")].alternatives == [[Terminal("a")]]
def test_multiple_rules():
p = Parser("""
E ::= A
A ::= \"a\"
""")
p.parse()
assert p.rules[Nonterminal("E")].alternatives == [[Nonterminal("A")]]
assert p.rules[Nonterminal("A")].alternatives == [[Terminal("a")]]
def __init__(self,
grammar=None,
lr_type=LR0,
whitespaces=False,
startsymbol=None):
if grammar:
logging.debug("Parsing Grammar")
parser = Parser(grammar, whitespaces)
parser.parse()
filename = "".join([
os.path.dirname(__file__), "/../pickle/",
str(hash(grammar) ^ hash(whitespaces)), ".pcl"
])
try:
logging.debug("Try to unpickle former stategraph")
f = open(filename, "r")
start = time.time()
self.graph = pickle.load(f)
end = time.time()
logging.debug("unpickling done in %s", end - start)
except IOError:
logging.debug("could not unpickle old graph")
logging.debug("Creating Stategraph")
self.graph = StateGraph(parser.start_symbol, parser.rules,
lr_type)
logging.debug("Building Stategraph")
self.graph.build()
logging.debug("Pickling")
pickle.dump(self.graph, open(filename, "w"))
if lr_type == LALR:
self.graph.convert_lalr()
logging.debug("Creating Syntaxtable")
self.syntaxtable = SyntaxTable(lr_type)
self.syntaxtable.build(self.graph)
self.stack = []
self.ast_stack = []
self.all_changes = []
self.undo = []
self.last_shift_state = 0
self.validating = False
self.last_status = False
self.error_node = None
self.whitespaces = whitespaces
self.status_by_version = {}
self.errornode_by_version = {}
self.indentation_based = False
self.pm = PluginManager()
self.pm.loadplugins(self)
self.pm.do_incparse_init()
self.previous_version = None
logging.debug("Incremental parser done")
def test_option_rule():
p = Parser("""
A ::= "a" [ "b" ] "g"
""")
p.parse()
print(p.rules)
assert p.rules[Nonterminal("A")].alternatives == [[Terminal("a"), Nonterminal("A_option")]]
assert p.rules[Nonterminal("A_option")].alternatives == [[Terminal("b"), Terminal("g")],
[Terminal("g")]]
def test_loop_rule():
p = Parser("""
A ::= "a" { "b" } "g"
""")
p.parse()
print(p.rules)
assert p.rules[Nonterminal("A")].alternatives == [[Terminal("a"), Nonterminal("A_loop")]]
assert p.rules[Nonterminal("A_loop")].alternatives == [[Terminal("b"), Nonterminal("A_loop")],
[Terminal("g")]]
def test_group_rule():
p = Parser("""
A ::= "a" ( "b" | "c" ) "g"
""")
p.parse()
print(p.rules)
assert p.rules[Nonterminal("A")].alternatives == [[Terminal("a"), Nonterminal("A_group1")]]
assert p.rules[Nonterminal("A_group1")].alternatives == [[Terminal("b"), Nonterminal("A_group2")],
[Terminal("c"), Nonterminal("A_group2")]]
assert p.rules[Nonterminal("A_group2")].alternatives == [[Terminal("g")]]
def test_option_rule():
p = Parser("""
A ::= "a" [ "b" ] "g"
""")
p.parse()
print(p.rules)
assert p.rules[Nonterminal("A")].alternatives == [[
Terminal("a"), Nonterminal("A_option")
]]
assert p.rules[Nonterminal("A_option")].alternatives == [[
Terminal("b"), Terminal("g")
], [Terminal("g")]]
def test_more_complex_grammar():
p = Parser("""
name ::= "ID"
| "&" "ID"
| splice
| insert
""")
p.parse()
assert p.rules[Nonterminal("name")].alternatives == [
[Terminal("ID")], [Terminal("&"), Terminal("ID")],
[Nonterminal("splice")], [Nonterminal("insert")]
]
def test_loop_rule():
p = Parser("""
A ::= "a" { "b" } "g"
""")
p.parse()
print(p.rules)
assert p.rules[Nonterminal("A")].alternatives == [[
Terminal("a"), Nonterminal("A_loop")
]]
assert p.rules[Nonterminal("A_loop")].alternatives == [[
Terminal("b"), Nonterminal("A_loop")
], [Terminal("g")]]
def test_group_rule():
p = Parser("""
A ::= "a" ( "b" | "c" ) "g"
""")
p.parse()
print(p.rules)
assert p.rules[Nonterminal("A")].alternatives == [[
Terminal("a"), Nonterminal("A_group1")
]]
assert p.rules[Nonterminal("A_group1")].alternatives == [[
Terminal("b"), Nonterminal("A_group2")
], [Terminal("c"), Nonterminal("A_group2")]]
assert p.rules[Nonterminal("A_group2")].alternatives == [[Terminal("g")]]
def __init__(self, grammar=None, lr_type=LR0, whitespaces=False, startsymbol=None):
if grammar:
logging.debug("Parsing Grammar")
parser = Parser(grammar, whitespaces)
parser.parse()
filename = "".join([os.path.dirname(__file__), "/../pickle/", str(hash(grammar) ^ hash(whitespaces)), ".pcl"])
try:
logging.debug("Try to unpickle former stategraph")
f = open(filename, "r")
start = time.time()
self.graph = pickle.load(f)
end = time.time()
logging.debug("unpickling done in %s", end-start)
except IOError:
logging.debug("could not unpickle old graph")
logging.debug("Creating Stategraph")
self.graph = StateGraph(parser.start_symbol, parser.rules, lr_type)
logging.debug("Building Stategraph")
self.graph.build()
logging.debug("Pickling")
pickle.dump(self.graph, open(filename, "w"))
if lr_type == LALR:
self.graph.convert_lalr()
logging.debug("Creating Syntaxtable")
self.syntaxtable = SyntaxTable(lr_type)
self.syntaxtable.build(self.graph)
self.stack = []
self.ast_stack = []
self.all_changes = []
self.undo = []
self.last_shift_state = 0
self.validating = False
self.last_status = False
self.error_node = None
self.whitespaces = whitespaces
self.anycount = set()
self.status_by_version = {}
self.errornode_by_version = {}
self.comment_tokens = []
self.indent_stack = None
self.indentation_based = False
self.previous_version = None
logging.debug("Incemental parser done")
def test_more_complex_grammar():
p = Parser("""
name ::= "ID"
| "&" "ID"
| splice
| insert
""")
p.parse()
assert p.rules[Nonterminal("name")].alternatives == [
[Terminal("ID")],
[Terminal("&"), Terminal("ID")],
[Nonterminal("splice")],
[Nonterminal("insert")]
]
def __init__(self, grammar, lr_type=LR0):
parser = Parser(grammar)
parser.parse()
self.graph = StateGraph(parser.start_symbol, parser.rules, lr_type)
self.graph.build()
if lr_type == LALR:
self.graph.convert_lalr()
self.syntaxtable = SyntaxTable(lr_type)
self.syntaxtable.build(self.graph)
self.stack = []
self.ast_stack = []
def __init__(self, grammar, lr_type=LR0):
parser = Parser(grammar)
parser.parse()
self.graph = StateGraph(parser.start_symbol, parser.rules, lr_type)
self.graph.build()
if lr_type == LALR:
self.graph.convert_lalr()
self.syntaxtable = SyntaxTable(lr_type)
self.syntaxtable.build(self.graph)
self.stack = []
self.ast_stack = []
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
from incparser.syntaxtable import SyntaxTable, Goto, Shift, Reduce, Accept, FinishSymbol
from incparser.stategraph import StateGraph
from grammar_parser.gparser import Parser, Terminal, Nonterminal, Epsilon
from incparser.production import Production
grammar = """
S ::= "b" A "d"
A ::= "c"
|
"""
p = Parser(grammar)
p.parse()
r = p.rules
b = Terminal("b")
c = Terminal("c")
d = Terminal("d")
S = Nonterminal("S")
A = Nonterminal("A")
S_bAd = Production(S, [b, A, d])
A_c = Production(A, [c])
A_None = Production(A, [Epsilon()])
syntaxtable = {
(0, b): Shift(2),
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
from incparser.syntaxtable import SyntaxTable, Goto, Shift, Reduce, Accept, FinishSymbol
from incparser.stategraph import StateGraph
from grammar_parser.gparser import Parser, Terminal, Nonterminal, Epsilon
from incparser.production import Production
grammar = """
S ::= "b" A "d"
A ::= "c"
|
"""
p = Parser(grammar)
p.parse()
r = p.rules
b = Terminal("b")
c = Terminal("c")
d = Terminal("d")
S = Nonterminal("S")
A = Nonterminal("A")
S_bAd = Production(S, [b, A, d])
A_c = Production(A, [c])
A_None = Production(A, [Epsilon()])
syntaxtable = {
(0, b): Shift(2),
| "a"
A ::= "a" S "c"
| "a"
| "a" S "b"
B ::= A S
C ::= D A
D ::= "d"
|
F ::= C D "f"
"""
p = Parser(grammar)
p.parse()
r = p.rules
grammar2 = """
E ::= P
| E "+" P
P ::= "a"
"""
p = Parser(grammar2)
p.parse()
r2 = p.rules
a = Terminal("a")
def test_simple():
p = Parser("E ::= \"a\"")
p.parse()
assert p.rules[Nonterminal("E")].symbol == Nonterminal("E")
assert p.rules[Nonterminal("E")].alternatives == [[Terminal("a")]]
def test_multiple_symbols():
p = Parser("E ::= A \"a\"")
p.parse()
assert p.rules[Nonterminal("E")].alternatives == [[Nonterminal("A"), Terminal("a")]]
def test_alternatives():
p = Parser("E ::= A | \"a\"")
p.parse()
assert p.rules[Nonterminal("E")].alternatives == [[Nonterminal("A")],
[Terminal("a")]]
def test_multiple_symbols():
p = Parser("E ::= A \"a\"")
p.parse()
assert p.rules[Nonterminal("E")].alternatives == [[
Nonterminal("A"), Terminal("a")
]]
def test_simple():
p = Parser("E ::= \"a\"")
p.parse()
assert p.rules[Nonterminal("E")].symbol == Nonterminal("E")
assert p.rules[Nonterminal("E")].alternatives == [[Terminal("a")]]
def test_alternatives():
p = Parser("E ::= A | \"a\"")
p.parse()
assert p.rules[Nonterminal("E")].alternatives == [[Nonterminal("A")], [Terminal("a")]]
