def extension(self, node):
ret = {}
seen = set()
def _ensure_unique(field):
if field in seen:
raise ValueError(
"Field %r for extension %r is specified more than once !" %
(field, ret["name"]))
else:
seen.add(field)
def update(extension_dict, c):
if type(c) == list:
for i in c:
update(extension_dict, i)
elif c.type == "name":
ret["name"] = c.value
elif c.type == "sources":
_ensure_unique("sources")
ret["sources"] = c.value
elif c.type == "include_dirs":
_ensure_unique("include_dirs")
ret["include_dirs"] = c.value
else:
raise ValueError("Gne ?")
for c in [node.children[0]] + node.children[1]:
update(ret, c)
return Node("extension", value=ret)
def path(self, node):
path = {}
def update(c):
if type(c) == list:
for i in c:
update(i)
elif c.type == "path_declaration":
path["name"] = c.value
elif c.type == "path_description":
path["description"] = c.value
elif c.type == "default":
path["default"] = c.value
else:
raise SyntaxError("GNe ?")
if len(node.children) > 1:
nodes = [node.children[0]] + node.children[1]
else:
nodes = [node.children[0]]
for node in nodes:
update(node)
if not "description" in path:
raise ValueError("missing description in path section %r" %
(path["name"], ))
if not "default" in path:
raise ValueError("missing default in path section %r" %
(path["name"], ))
return Node("path", value=path)
def compiled_library(self, node):
ret = {"sources": [], "include_dirs": []}
seen = set()
def _ensure_unique(field):
if field in seen:
raise ValueError(
"Field %r for compiled library %r is specified more than once !"
% (field, ret["name"]))
else:
seen.add(field)
def update(compiled_library_dict, c):
if c.type == "name":
ret["name"] = c.value
elif c.type == "sources":
_ensure_unique("sources")
ret["sources"] = c.value
elif c.type == "include_dirs":
_ensure_unique("include_dirs")
ret["include_dirs"] = c.value
else:
raise ValueError("Unknown node %s" % c)
for c in [node.children[0]] + node.children[1]:
update(ret, c)
return Node("compiled_library", value=ret)
def p_library_name(p):
"""library_name : word
|"""
if len(p) == 1:
name = "default"
else:
name = p[1]
p[0] = Node("library_name", value=name)
def description(self, node):
tokens = []
for i in node.value:
if i.type in [
"literal", "multi_literal", "newline", "indent", "dedent",
"single_line"
]:
tokens.append(i)
# FIXME: fix grammar to get ind_shift
ind_shift = 4
inds = [0]
line_str = []
for line in split_newlines(tokens):
# FIXME: this is horrible
if line[0].type == "dedent":
if set([node.type for node in line
]) == set(["dedent"
]): # if the line only contains dedent
inds.pop(0)
remain = [Node("literal", value="\n")]
else:
while line[0].type == "dedent":
inds.pop(0)
line = line[1:]
remain = line
elif line[0].type == "indent":
inds.insert(0, line[0].value - ind_shift)
remain = line[1:]
else:
remain = line
if len(remain) > 0:
if remain[-1].type == "dedent":
remain = remain[:-1]
cur_line = [" " * inds[0]]
cur_line.extend([t.value for t in remain])
line_str.append("".join(cur_line))
return Node("description", value="".join(line_str))
def p_anytoken_no_comma(p):
"""anytoken_no_comma : WORD
| COLON
| DOUBLE_COLON
| LPAR
| RPAR
| LESS
| SLASH
| SHARP
| EQUAL
| GREATER
"""
p[0] = Node("anytoken", value=p[1])
def flag(self, node):
flag = {}
for i in [node.children[0]] + node.children[1]:
if i.type == "flag_declaration":
flag["name"] = i.value
elif i.type == "flag_description":
flag["description"] = i.value
elif i.type == "default":
flag["default"] = i.value
else:
raise SyntaxError("GNe ?")
if not flag["default"] in ["true", "false"]:
raise SyntaxError("invalid default value %s for flag %s" \
% (flag["default"], flag["name"]))
if not flag["name"] in self._vars:
self._vars[flag["name"]] = flag["default"]
return Node("flag", value=flag)
def executable(self, node):
d = {}
def update(exec_d, c):
if type(c) == list:
for i in c:
update(exec_d, i)
elif c.type == "name":
exec_d["name"] = c.value
elif c.type == "module":
exec_d["module"] = c.value
elif c.type == "function":
exec_d["function"] = c.value
else:
raise ValueError("Unhandled node type: %s" % c)
for c in node.children:
update(d, c)
return Node("executable", value=d)
def library(self, node):
library = {
"py_modules": [],
"install_requires": [],
"build_requires": [],
"packages": [],
"extensions": {},
"compiled_libraries": {},
"sub_directory": None,
}
def update(library_dict, c):
if type(c) == list:
for i in c:
update(library_dict, i)
elif c.type == "name":
library_dict["name"] = c.value
elif c.type == "modules":
library_dict["py_modules"].extend(c.value)
elif c.type == "packages":
library_dict["packages"].extend(c.value)
elif c.type in ("build_requires", "install_requires"):
library_dict[c.type].extend(c.value)
elif c.type == "extension":
name = c.value["name"]
library_dict["extensions"][name] = c.value
elif c.type == "compiled_library":
name = c.value["name"]
library_dict["compiled_libraries"][name] = c.value
elif c.type == "sub_directory":
library_dict["sub_directory"] = c.value
else:
raise ValueError("Unhandled node type: %s" % c)
if len(node.children) > 1:
nodes = [node.children[0]] + node.children[1]
else:
nodes = [node.children[0]]
for c in nodes:
update(library, c)
return Node("library", value=library)
def data_files(self, node):
d = {}
def update(data_d, c):
if type(c) == list:
for i in c:
update(data_d, i)
elif c.type == "data_files_declaration":
d["name"] = c.value
elif c.type == "source_dir":
d["source_dir"] = c.value
elif c.type == "target_dir":
d["target_dir"] = c.value
elif c.type == "files":
d["files"] = c.value
else:
raise ValueError("Unhandled node type: %s" % c)
for c in node.children:
update(d, c)
return Node("data_files", value=d)
def p_literal_no_space(p):
"""literal_no_space : anytoken_no_comma
"""
p[0] = Node("literal", value=p[1].value)
def path_default(self, node):
return Node("default", value=node.value)
def p_literal_no_space_term(p):
"""literal_no_space : COMMA
"""
p[0] = Node("literal", value=p[1])
def use_backends(self, node):
return Node("use_backends", value=node.value)
def sub_directory(self, node):
return Node("sub_directory", value=node.value)
def p_dedent(p):
"""dedent : DEDENT
"""
p[0] = Node("dedent", value=p[1])
def parse(self, data):
res = self.parser.parse(data, lexer=self.lexer)
# FIXME: this is stupid, deal correctly with empty ast in the grammar proper
if res is None:
res = Node("empty")
return res
def extension_declaration(self, node):
return Node("name", value=node.value)
def p_literal_term(p):
"""literal : WS
"""
p[0] = Node("literal", value=p[1])
def p_multi_literal(p):
"""multi_literal : literal
"""
p[0] = Node("multi_literal", value=p[1].value)
def function(self, node):
return Node("function", value=node.value)
def summary(self, node):
ret = Node(node.type)
ret.value = "".join([i.value for i in node.value])
return ret
def p_version(p):
"""version : WORD"""
p[0] = Node("version", value=p[1])
def p_word(p):
"""word : WORD"""
p[0] = Node("word", value=p[1])
def flag_default(self, node):
return Node("default", value=node.value)
def p_literal(p):
"""literal : literal_no_space
"""
p[0] = Node("literal", value=p[1].value)
def compiled_library_declaration(self, node):
return Node("name", value=node.value)
def exec_name(self, node):
return Node("name", value=node.value)
def p_indent(p):
"""indent : INDENT
"""
p[0] = Node("indent", value=p[1])
def module(self, node):
return Node("module", value=node.value)
def library_name(self, node):
return Node("name", value=node.value)
