Remove old version.
This commit is contained in:
parent
7c98e6e895
commit
9b2f9b706c
|
|
@ -1,20 +0,0 @@
|
||||||
"""
|
|
||||||
Exceptions for HECKfile processing.
|
|
||||||
"""
|
|
||||||
|
|
||||||
class HeckException (BaseException):
|
|
||||||
"""
|
|
||||||
Base exception for HECKfile processing.
|
|
||||||
"""
|
|
||||||
|
|
||||||
|
|
||||||
class HeckParseException(HeckException):
|
|
||||||
"""
|
|
||||||
Raised for parse errors specifically.
|
|
||||||
"""
|
|
||||||
|
|
||||||
|
|
||||||
class HeckLexException(HeckException):
|
|
||||||
"""
|
|
||||||
Raised for lex errors specifically.
|
|
||||||
"""
|
|
||||||
|
|
@ -1,119 +0,0 @@
|
||||||
import ply.lex as lex
|
|
||||||
|
|
||||||
"""
|
|
||||||
Lexical analyzer for HECKformat lines using PLY Lex.
|
|
||||||
"""
|
|
||||||
|
|
||||||
from .exceptions import HeckLexException
|
|
||||||
|
|
||||||
from typing import List, Optional
|
|
||||||
|
|
||||||
import string
|
|
||||||
|
|
||||||
tokens = ('ATOM', 'BASE10', 'BASE16', 'COMMENT', 'STRING', 'SECTION', 'ATTRIB', 'DEEP', 'ELEMENT')
|
|
||||||
|
|
||||||
# COMMENT ::= # .*$
|
|
||||||
# ATOM ::= [A-Za-z_][A-Za-z0-9_-]?
|
|
||||||
# BASE10NUMBER ::= (-)?[0-9]+(\.)?[0-9]+([FLUIDCfluidc])?
|
|
||||||
# BASE16NUMBER ::= 0x[0-9A-Fa-f]+
|
|
||||||
# NUMBER ::= (<BASE10NUMBER|BASE16NUMBER>)
|
|
||||||
# STRING ::= "([^\"]*|(\\)|(\"))"
|
|
||||||
# VALUE ::= (<ATOM>|<STRING>|<NUMBER>)
|
|
||||||
# VALUES ::= <VALUE>(\s+<VALUES>)?
|
|
||||||
# ATTRIBUTENAME ::= <ATOM>
|
|
||||||
# ATTRIBUTE ::= <ATTRIBUTENAME>=<VALUE>
|
|
||||||
# ATTRIBUTES ::= <ATTRIBUTE>(\s+<ATTRIBUTES>)?
|
|
||||||
# SECTIONLABEL ::= <ATOM>
|
|
||||||
# SECTION ::= %%%\s+<SECTIONLABEL>\s+<ATTRIBUTES>
|
|
||||||
# ELEMENTLABEL ::= [A-Za-z_][A-Za-z0-9!@#$%^&*()_+/\\-]?
|
|
||||||
# ELEMENT ::= <ELEMENTLABEL>\s+(<VALUES>|<ATTRIBUTES>)
|
|
||||||
# LINE ::= ^(((>)*<ELEMENT>) | <SECTION> | <COMMENT>) (<COMMENT>|$)
|
|
||||||
|
|
||||||
|
|
||||||
t_ignore = string.whitespace
|
|
||||||
|
|
||||||
t_DEEP = r'^(>)+'
|
|
||||||
|
|
||||||
t_BASE16 = r'0x[0-9A-Fa-f]+'
|
|
||||||
t_SECTION = r'^%%%\s'
|
|
||||||
t_ATTRIB = '='
|
|
||||||
t_ELEMENT = r'[A-Za-z_.][A-Za-z0-9.!@\$%^&*()_+/\\-]*'
|
|
||||||
|
|
||||||
def t_ATOM(token: lex.LexToken):
|
|
||||||
r'[A-Za-z_$][A-Za-z0-9_.-]*'
|
|
||||||
if token.value in ('true', 'True'):
|
|
||||||
token.value = True
|
|
||||||
elif token.value in ('false', 'False'):
|
|
||||||
token.value = False
|
|
||||||
return token
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
def t_BASE10(token: lex.LexToken):
|
|
||||||
r'(-)?[0-9]+(\.?[0-9]+)?([FLUIDCfluidc])?(\b|$)'
|
|
||||||
# python numbers are Very Flexible so we ignore typespec
|
|
||||||
vstr = token.value
|
|
||||||
if vstr[-1] in 'FLUIDCfluidc':
|
|
||||||
vstr = vstr[:-1]
|
|
||||||
if '.' in vstr:
|
|
||||||
token.value = float(vstr)
|
|
||||||
else:
|
|
||||||
token.value = int(vstr)
|
|
||||||
return token
|
|
||||||
|
|
||||||
def t_COMMENT(token: lex.LexToken):
|
|
||||||
r'\#\s?.*$'
|
|
||||||
...
|
|
||||||
|
|
||||||
def t_STRING(token: lex.LexToken):
|
|
||||||
r'"[^"]*"'
|
|
||||||
token.value = token.value[1:-1] # substring to strip double quotes
|
|
||||||
return token
|
|
||||||
|
|
||||||
def t_error(token: lex.LexToken):
|
|
||||||
print(f"{token.lineno} Unexpected character '{token.value[0]}' at position {token.lexpos}.")
|
|
||||||
print('... ' + token.value)
|
|
||||||
print(' ^')
|
|
||||||
# token.lexer.skip(1)
|
|
||||||
|
|
||||||
lexer = lex.lex()
|
|
||||||
|
|
||||||
def lex_line(line: str, lineno: int=0) -> List[lex.LexToken]:
|
|
||||||
"""
|
|
||||||
Return a list of tokens for a particular HECKformat file line.
|
|
||||||
|
|
||||||
"""
|
|
||||||
lexer.lineno = lineno
|
|
||||||
try:
|
|
||||||
lexer.input(line)
|
|
||||||
tokens = []
|
|
||||||
while True:
|
|
||||||
tok = lexer.token()
|
|
||||||
if tok:
|
|
||||||
tokens.append(tok)
|
|
||||||
else:
|
|
||||||
break
|
|
||||||
return tokens
|
|
||||||
except lex.LexError as inst:
|
|
||||||
# fixme raise a HeckFormat exception
|
|
||||||
raise HeckLexException from inst
|
|
||||||
|
|
||||||
TEST_STRINGS = [
|
|
||||||
'"hi yo123 123xyz #foo" 123xyz 123.223 1f abcd123 123abc $foo "hello world" #foo',
|
|
||||||
'1.23f',
|
|
||||||
'"hello world!" atom utehuteu tnhoeun_etuhenuoh',
|
|
||||||
'"hi yo123 123xyz #foo" xyz 123.223 1f abcd123 abc $foo "hello world" #foo',
|
|
||||||
'%%% heck',
|
|
||||||
'%%% markdown foo=bar',
|
|
||||||
'element 1.2 1.3 1.4 attrib="string value for attribute"',
|
|
||||||
'> element 5 4 3 2.5',
|
|
||||||
]
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
for idx, test in enumerate(TEST_STRINGS):
|
|
||||||
print(f"Line {idx}: '{test}'")
|
|
||||||
try:
|
|
||||||
for token in lex_line(test, idx):
|
|
||||||
print(' ' + str(token))
|
|
||||||
except Exception as inst:
|
|
||||||
print(f'Error in line.')
|
|
||||||
|
|
@ -1,226 +0,0 @@
|
||||||
from typing import Iterable, Union, Mapping, TypeVar, List, TextIO
|
|
||||||
|
|
||||||
import re
|
|
||||||
|
|
||||||
from .parser import parser
|
|
||||||
from .exceptions import HeckParseException
|
|
||||||
|
|
||||||
HeckValue = TypeVar("HeckElement") | str | int | float
|
|
||||||
|
|
||||||
class HeckElement:
|
|
||||||
"""
|
|
||||||
Container for a tree of HECKformat elements.
|
|
||||||
"""
|
|
||||||
name: str
|
|
||||||
"""The name of the element, either __ROOT__ for top level or whatever is specified in file."""
|
|
||||||
children: Iterable[TypeVar]
|
|
||||||
"""The children of the element."""
|
|
||||||
values: Iterable[HeckValue]
|
|
||||||
"""One or more values associated with the element."""
|
|
||||||
attributes: Mapping[str, HeckValue]
|
|
||||||
"""Zero or more attributes associated with the element as a key-value pair."""
|
|
||||||
|
|
||||||
def __init__(self):
|
|
||||||
self.children = []
|
|
||||||
self.values = []
|
|
||||||
self.attributes = dict()
|
|
||||||
self.name = ""
|
|
||||||
self.unparsed = False
|
|
||||||
|
|
||||||
def __str__(self):
|
|
||||||
k=''
|
|
||||||
if self.unparsed:
|
|
||||||
k='Unparsed '
|
|
||||||
return f"<HeckElement {k}{self.name} c={self.children} v={self.values} a={self.attributes}>"
|
|
||||||
|
|
||||||
def __repr__(self):
|
|
||||||
return self.__str__()
|
|
||||||
|
|
||||||
|
|
||||||
def to_struct(self) -> Mapping[str, Union[int, float, str, Mapping, List]]:
|
|
||||||
"""
|
|
||||||
Convert this HeckElement tree to a Python structure. The structure is a dictionary keyed by element name, where
|
|
||||||
the values are a list of each tree under that name, in order of their declaration in the tree, and futher, a
|
|
||||||
list of values.
|
|
||||||
|
|
||||||
For example:
|
|
||||||
|
|
||||||
```
|
|
||||||
%%% heck
|
|
||||||
a b c
|
|
||||||
a c d
|
|
||||||
```
|
|
||||||
|
|
||||||
turns into:
|
|
||||||
|
|
||||||
{'a': [['b', 'c'], ['c', 'd']]}
|
|
||||||
|
|
||||||
Subelements are treated as a dictionary object added to the end of each value.
|
|
||||||
|
|
||||||
For example:
|
|
||||||
|
|
||||||
```
|
|
||||||
%%% heck
|
|
||||||
a b
|
|
||||||
> c d
|
|
||||||
a e
|
|
||||||
> f g
|
|
||||||
```
|
|
||||||
|
|
||||||
turns into:
|
|
||||||
|
|
||||||
{'a': [['b'], {'c': [['d']]}, ['e', {'f': [['g']]}]]}
|
|
||||||
"""
|
|
||||||
|
|
||||||
|
|
||||||
def to_dict(self, merge=False) -> Mapping[str, Union[int, float, str, Mapping, List]]:
|
|
||||||
"""
|
|
||||||
As with `to_struct`, but attempts to merge all keys together at each level.
|
|
||||||
|
|
||||||
For example:
|
|
||||||
|
|
||||||
```
|
|
||||||
%%% heck
|
|
||||||
a b c
|
|
||||||
a c d
|
|
||||||
```
|
|
||||||
|
|
||||||
turns into (with merge set to True):
|
|
||||||
|
|
||||||
{'a': ['b', 'c', 'c', 'd']}
|
|
||||||
|
|
||||||
or (with merge set to False):
|
|
||||||
|
|
||||||
{'a': ['c', 'd']}
|
|
||||||
|
|
||||||
For child elements, the list is replaced by a dictionary, and the values are stored in a special key '%%% values'
|
|
||||||
|
|
||||||
Thus:
|
|
||||||
|
|
||||||
```
|
|
||||||
%%% heck
|
|
||||||
a b
|
|
||||||
> c d
|
|
||||||
```
|
|
||||||
|
|
||||||
becomes:
|
|
||||||
|
|
||||||
{'a':{'%%%values': ['b'], 'c': ['d']}}
|
|
||||||
|
|
||||||
This cannot represent exactly the contents of the input tree, however it may be more convenient in many use
|
|
||||||
cases where repeated elements of the same key are not allowed, or if keys are being treated as unique.
|
|
||||||
"""
|
|
||||||
|
|
||||||
|
|
||||||
def _get_element(ast: List) -> HeckElement:
|
|
||||||
"""
|
|
||||||
Get an element from an element AST from the parser.
|
|
||||||
"""
|
|
||||||
if not (ast[0] == 'element'):
|
|
||||||
raise HeckParseException(f"Found a non-element where an element was expected. {ast}")
|
|
||||||
elm = HeckElement()
|
|
||||||
elm.name = ast[1];
|
|
||||||
for item in ast[2:]:
|
|
||||||
if item[0] == 'values':
|
|
||||||
elm.values = [x[1] for x in item[1:]]
|
|
||||||
elif item[0] == 'attributes':
|
|
||||||
elm.attributes.update({x[1]: x[2][1] for x in item[1:]})
|
|
||||||
return elm
|
|
||||||
|
|
||||||
def load_heck(inp: Iterable[str]) -> HeckElement:
|
|
||||||
"""
|
|
||||||
Load a HECKformat into a tree of HeckElements from a list of lines from the file.
|
|
||||||
"""
|
|
||||||
MODE_INIT = 0
|
|
||||||
MODE_ELM = 1
|
|
||||||
MODE_UNPARSE = 2
|
|
||||||
|
|
||||||
rootelm = HeckElement()
|
|
||||||
pelm = [rootelm] # parent for subelement
|
|
||||||
pdepth = 0
|
|
||||||
depth = 0
|
|
||||||
rootelm.name = "__ROOT__"
|
|
||||||
mode = MODE_INIT
|
|
||||||
for idx, line in enumerate(inp):
|
|
||||||
if mode == MODE_UNPARSE:
|
|
||||||
if (line.startswith('%%%')):
|
|
||||||
mode = MODE_INIT
|
|
||||||
else:
|
|
||||||
pelm[-1].values.append(line)
|
|
||||||
continue
|
|
||||||
else:
|
|
||||||
ast = parser.parse(line)
|
|
||||||
if ast:
|
|
||||||
if ast[0] == 'section':
|
|
||||||
if ast[1] == 'heck':
|
|
||||||
mode = MODE_ELM
|
|
||||||
pelm = [rootelm]
|
|
||||||
else:
|
|
||||||
mode = MODE_UNPARSE
|
|
||||||
pelm = [HeckElement()]
|
|
||||||
rootelm.children.append(pelm[-1])
|
|
||||||
pelm[-1].name = ast[1]
|
|
||||||
pelm[-1].unparsed = True
|
|
||||||
else:
|
|
||||||
if not mode == MODE_ELM:
|
|
||||||
raise HeckParseException("Didn't find heck preamble, line {idx}")
|
|
||||||
else:
|
|
||||||
if ast[0] == 'deep':
|
|
||||||
# we're in a subitem
|
|
||||||
depth = ast[1]
|
|
||||||
if (depth > pdepth):
|
|
||||||
# are we deeper than last time?
|
|
||||||
try:
|
|
||||||
pelm.append(pelm[-1].children[-1])
|
|
||||||
except:
|
|
||||||
raise HeckParseException("Tried to go deeper without a previous element, line {idx}")
|
|
||||||
elif (depth < pdepth):
|
|
||||||
# are we shallower than last time?
|
|
||||||
pelm.pop()
|
|
||||||
if (not len(pelm)):
|
|
||||||
raise HeckParseException("Tried to go shallower while already shallow, line {idx}")
|
|
||||||
ast = ast[2]
|
|
||||||
pdepth = depth
|
|
||||||
elif (pdepth > 0):
|
|
||||||
# we're no longer deep, just pop up to the top
|
|
||||||
pdepth = 0
|
|
||||||
pelm = [rootelm]
|
|
||||||
pelm[-1].children.append(_get_element(ast))
|
|
||||||
|
|
||||||
return rootelm
|
|
||||||
|
|
||||||
def load(infile: TextIO) -> HeckElement:
|
|
||||||
return load_heck(infile.readlines())
|
|
||||||
|
|
||||||
def loads(ins: str) -> HeckElement:
|
|
||||||
return load_heck(re.split(r'\n|\r|\r\n', ins))
|
|
||||||
|
|
||||||
|
|
||||||
TEST_HECK = """
|
|
||||||
%%% heck
|
|
||||||
# Website!
|
|
||||||
title "My Website" bold=True
|
|
||||||
subtitle "Yep it's a website"
|
|
||||||
scale 3.72
|
|
||||||
matrix 0 0 0 0 1 2 3 1 2 3 4 29394.2
|
|
||||||
tags hey man what are you doin
|
|
||||||
> more tag tag tag 1 2 3
|
|
||||||
>> we can go deeper
|
|
||||||
>>> we can go even deeper
|
|
||||||
test
|
|
||||||
> _val 1
|
|
||||||
> _val 2
|
|
||||||
> _val 3
|
|
||||||
valueless
|
|
||||||
_more.orless complexelement
|
|
||||||
.yooooo
|
|
||||||
boolean True
|
|
||||||
%%% markdown
|
|
||||||
# Some cheeky markdown to confuse our processing.
|
|
||||||
|
|
||||||
All my page content goes here.
|
|
||||||
"""
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
result = load_heck(TEST_HECK.split('\n'))
|
|
||||||
print(result)
|
|
||||||
|
|
@ -1,118 +0,0 @@
|
||||||
import ply.yacc as yacc
|
|
||||||
|
|
||||||
"""
|
|
||||||
Parser for HECKformat lines using PLY Parser.
|
|
||||||
"""
|
|
||||||
|
|
||||||
from .lexer import tokens
|
|
||||||
|
|
||||||
def p_value(p):
|
|
||||||
"""
|
|
||||||
value : BASE16
|
|
||||||
| BASE10
|
|
||||||
| STRING
|
|
||||||
| ATOM
|
|
||||||
"""
|
|
||||||
#print(p[0], p[1])
|
|
||||||
p[0] = ("value", p[1])
|
|
||||||
|
|
||||||
|
|
||||||
def p_elm(p):
|
|
||||||
"""
|
|
||||||
elm : ATOM
|
|
||||||
| ELEMENT
|
|
||||||
"""
|
|
||||||
p[0] = p[1]
|
|
||||||
|
|
||||||
def p_attribute(p):
|
|
||||||
"""attribute : ATOM ATTRIB value"""
|
|
||||||
# print(p[0], p[1])
|
|
||||||
p[0] = ("attribute", p[1], p[3])
|
|
||||||
|
|
||||||
|
|
||||||
def p_attributes(p):
|
|
||||||
"""
|
|
||||||
attributes : attributes attribute
|
|
||||||
attributes : attribute
|
|
||||||
"""
|
|
||||||
if len(p) == 2:
|
|
||||||
p[0] = ["attributes", p[1]]
|
|
||||||
else:
|
|
||||||
p[0] = p[1]
|
|
||||||
p[0].append(p[2])
|
|
||||||
|
|
||||||
|
|
||||||
def p_section(p):
|
|
||||||
"""
|
|
||||||
section : SECTION elm
|
|
||||||
| SECTION elm attributes
|
|
||||||
"""
|
|
||||||
if (len(p) == 3):
|
|
||||||
p[0] = ("section", p[2])
|
|
||||||
else:
|
|
||||||
p[0] = ("section", p[2], p[3])
|
|
||||||
|
|
||||||
def p_values(p):
|
|
||||||
"""
|
|
||||||
values : values value
|
|
||||||
values : value
|
|
||||||
"""
|
|
||||||
if len(p) == 2:
|
|
||||||
p[0] = ["values", p[1]]
|
|
||||||
else:
|
|
||||||
p[0] = p[1]
|
|
||||||
p[0].append(p[2])
|
|
||||||
|
|
||||||
|
|
||||||
def p_element(p):
|
|
||||||
"""
|
|
||||||
element : elm values
|
|
||||||
| elm values attributes
|
|
||||||
| elm attributes
|
|
||||||
| elm
|
|
||||||
"""
|
|
||||||
# print(len(p))
|
|
||||||
if len(p) <= 2:
|
|
||||||
p[0] = ["element", p[1]]
|
|
||||||
else:
|
|
||||||
p[0] = ["element", p[1], p[2]]
|
|
||||||
if (len(p) == 4):
|
|
||||||
p[0].append(p[3])
|
|
||||||
|
|
||||||
|
|
||||||
def p_statement(p):
|
|
||||||
"""
|
|
||||||
statement : element
|
|
||||||
| DEEP element
|
|
||||||
| section
|
|
||||||
"""
|
|
||||||
if (len(p) > 2):
|
|
||||||
p[0] = ('deep', len(p[1]), p[2])
|
|
||||||
else:
|
|
||||||
p[0] = p[1]
|
|
||||||
|
|
||||||
|
|
||||||
def p_error(p):
|
|
||||||
if not p:
|
|
||||||
return
|
|
||||||
else:
|
|
||||||
print(f"Syntax error {p}")
|
|
||||||
|
|
||||||
parser = yacc.yacc(start="statement")
|
|
||||||
|
|
||||||
|
|
||||||
TEST_STRING = [
|
|
||||||
'%%% heck',
|
|
||||||
'%%% heck foo=bar',
|
|
||||||
'%%% heck bar=-5l quux="hello! how are you today?" fred=69 barney=nice',
|
|
||||||
'title "My website!"',
|
|
||||||
'zoom 5.73',
|
|
||||||
'tags yo fresh',
|
|
||||||
'dumper 1 2 3 4 5 6 7 8 9 dumpped=True',
|
|
||||||
'> big_dumper 32 23 384848',
|
|
||||||
'>> deep_dumper 1 2 3 a=false'
|
|
||||||
]
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
for test in TEST_STRING:
|
|
||||||
print(parser.parse(test))
|
|
||||||
|
|
@ -1,50 +0,0 @@
|
||||||
|
|
||||||
# parsetab.py
|
|
||||||
# This file is automatically generated. Do not edit.
|
|
||||||
# pylint: disable=W,C,R
|
|
||||||
_tabversion = '3.10'
|
|
||||||
|
|
||||||
_lr_method = 'LALR'
|
|
||||||
|
|
||||||
_lr_signature = 'statementATOM ATTRIB BASE10 BASE16 COMMENT DEEP ELEMENT SECTION STRING\n value : BASE16\n | BASE10\n | STRING\n | ATOM\n \n elm : ATOM\n | ELEMENT\n attribute : ATOM ATTRIB value\n attributes : attributes attribute\n attributes : attribute\n \n section : SECTION elm\n | SECTION elm attributes\n \n values : values value\n values : value\n \n element : elm values\n | elm values attributes\n | elm attributes\n | elm\n \n statement : element\n | DEEP element\n | section\n '
|
|
||||||
|
|
||||||
_lr_action_items = {'DEEP':([0,],[3,]),'SECTION':([0,],[6,]),'ATOM':([0,3,5,6,7,8,10,11,12,13,14,15,16,17,18,19,20,21,23,24,25,26,],[7,7,17,7,-5,-6,17,22,-13,-9,-1,-2,-3,-4,22,22,-12,-8,25,22,-4,-7,]),'ELEMENT':([0,3,6,],[8,8,8,]),'$end':([1,2,4,5,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,24,25,26,],[0,-18,-20,-17,-5,-6,-19,-14,-16,-13,-9,-1,-2,-3,-4,-10,-15,-12,-8,-11,-4,-7,]),'BASE16':([5,7,8,10,12,14,15,16,17,20,23,],[14,-5,-6,14,-13,-1,-2,-3,-4,-12,14,]),'BASE10':([5,7,8,10,12,14,15,16,17,20,23,],[15,-5,-6,15,-13,-1,-2,-3,-4,-12,15,]),'STRING':([5,7,8,10,12,14,15,16,17,20,23,],[16,-5,-6,16,-13,-1,-2,-3,-4,-12,16,]),'ATTRIB':([17,22,],[23,23,]),}
|
|
||||||
|
|
||||||
_lr_action = {}
|
|
||||||
for _k, _v in _lr_action_items.items():
|
|
||||||
for _x,_y in zip(_v[0],_v[1]):
|
|
||||||
if not _x in _lr_action: _lr_action[_x] = {}
|
|
||||||
_lr_action[_x][_k] = _y
|
|
||||||
del _lr_action_items
|
|
||||||
|
|
||||||
_lr_goto_items = {'statement':([0,],[1,]),'element':([0,3,],[2,9,]),'section':([0,],[4,]),'elm':([0,3,6,],[5,5,18,]),'values':([5,],[10,]),'attributes':([5,10,18,],[11,19,24,]),'value':([5,10,23,],[12,20,26,]),'attribute':([5,10,11,18,19,24,],[13,13,21,13,21,21,]),}
|
|
||||||
|
|
||||||
_lr_goto = {}
|
|
||||||
for _k, _v in _lr_goto_items.items():
|
|
||||||
for _x, _y in zip(_v[0], _v[1]):
|
|
||||||
if not _x in _lr_goto: _lr_goto[_x] = {}
|
|
||||||
_lr_goto[_x][_k] = _y
|
|
||||||
del _lr_goto_items
|
|
||||||
_lr_productions = [
|
|
||||||
("S' -> statement","S'",1,None,None,None),
|
|
||||||
('value -> BASE16','value',1,'p_value','parser.py',11),
|
|
||||||
('value -> BASE10','value',1,'p_value','parser.py',12),
|
|
||||||
('value -> STRING','value',1,'p_value','parser.py',13),
|
|
||||||
('value -> ATOM','value',1,'p_value','parser.py',14),
|
|
||||||
('elm -> ATOM','elm',1,'p_elm','parser.py',22),
|
|
||||||
('elm -> ELEMENT','elm',1,'p_elm','parser.py',23),
|
|
||||||
('attribute -> ATOM ATTRIB value','attribute',3,'p_attribute','parser.py',27),
|
|
||||||
('attributes -> attributes attribute','attributes',2,'p_attributes','parser.py',34),
|
|
||||||
('attributes -> attribute','attributes',1,'p_attributes','parser.py',35),
|
|
||||||
('section -> SECTION elm','section',2,'p_section','parser.py',46),
|
|
||||||
('section -> SECTION elm attributes','section',3,'p_section','parser.py',47),
|
|
||||||
('values -> values value','values',2,'p_values','parser.py',56),
|
|
||||||
('values -> value','values',1,'p_values','parser.py',57),
|
|
||||||
('element -> elm values','element',2,'p_element','parser.py',68),
|
|
||||||
('element -> elm values attributes','element',3,'p_element','parser.py',69),
|
|
||||||
('element -> elm attributes','element',2,'p_element','parser.py',70),
|
|
||||||
('element -> elm','element',1,'p_element','parser.py',71),
|
|
||||||
('statement -> element','statement',1,'p_statement','parser.py',84),
|
|
||||||
('statement -> DEEP element','statement',2,'p_statement','parser.py',85),
|
|
||||||
('statement -> section','statement',1,'p_statement','parser.py',86),
|
|
||||||
]
|
|
||||||
Loading…
Reference in New Issue
