158 lines
4 KiB
Python
Executable file
158 lines
4 KiB
Python
Executable file
rules_dict = {}
|
|
terminals_set = set()
|
|
|
|
def parse(lines):
|
|
lines = [line.strip() for line in lines]
|
|
lines = [line.split(":") for line in lines]
|
|
rules = [(line[0].strip(), line[1].strip().split(" ")) for line in lines]
|
|
for r in rules:
|
|
for right_element in r[1]:
|
|
if len(right_element) > 0 and not right_element[0].isupper():
|
|
terminals_set.add(right_element)
|
|
|
|
for i in range(0, len(rules)):
|
|
left = rules[i][0]
|
|
if left not in rules_dict:
|
|
rules_dict[left] = 0
|
|
|
|
print_includes()
|
|
print_util()
|
|
print_declarations()
|
|
print("// ---- Functions to parse terminals ----")
|
|
print_terminal_rules()
|
|
print_rules(rules)
|
|
print_main(rules)
|
|
# print(rules)
|
|
# print(rules_dict)
|
|
# print(terminals_set)
|
|
|
|
|
|
def print_declarations():
|
|
for key in rules_dict:
|
|
print(f"int parse_{key}(char* word, int pos);")
|
|
print()
|
|
|
|
def print_includes():
|
|
print("""\
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
""")
|
|
|
|
|
|
def print_util():
|
|
print("""\
|
|
void print_with_indent(int indent, char * string) {
|
|
printf("%*s%s", indent, "", string);
|
|
}
|
|
""")
|
|
|
|
|
|
def print_main(rules):
|
|
axiom = get_code(rules[0][0])
|
|
print(f"""\
|
|
int main(int argc, char* argv[]) {{
|
|
char* word;
|
|
if (argc >= 2)
|
|
word = argv[1];
|
|
else
|
|
word = "";
|
|
int value = parse_{axiom}(word, 0);
|
|
printf("%d\\n", value);
|
|
if (value == strlen(word) + 1) {{
|
|
printf("OK\\n");
|
|
}} else {{
|
|
printf("KO\\n");
|
|
}}
|
|
}}
|
|
""")
|
|
|
|
|
|
def print_rules(rules):
|
|
print("// ---- Functions to parse a non-terminal according to a rule ----")
|
|
print_unit_rules(rules)
|
|
print("// ---- Functions to parse a non-terminal by testing all rules ----")
|
|
print_global_rules()
|
|
|
|
|
|
def print_unit_rules(rules):
|
|
for i in range(0, len(rules)):
|
|
rule = rules[i]
|
|
left = rule[0]
|
|
rules_dict[left] += 1
|
|
code = get_code(left)
|
|
print(f"""\
|
|
int parse_{code}{rules_dict[left]}(char* word, int pos) {{
|
|
int totalCharParsed = 0;
|
|
int nbCharParsed;
|
|
printf("Entering {code}{rules_dict[left]}\\n");""")
|
|
for element in rule[1]:
|
|
elem_code = get_code(element)
|
|
if elem_code != "":
|
|
print(f"""
|
|
nbCharParsed = parse_{elem_code}(word, pos + totalCharParsed);
|
|
if (nbCharParsed == -1) {{
|
|
printf("Fail {elem_code} in {code}{rules_dict[left]}\\n");
|
|
return -1;
|
|
}}
|
|
totalCharParsed += nbCharParsed;""")
|
|
else:
|
|
print(f"\n printf(\"Epsilon! -> Success\\n\");")
|
|
print(f"""
|
|
printf("Success {code}{rules_dict[left]}\\n");
|
|
return totalCharParsed;
|
|
}}
|
|
""")
|
|
|
|
|
|
def print_global_rules():
|
|
for (key, value) in rules_dict.items():
|
|
code = get_code(key)
|
|
print(f"""\
|
|
int parse_{code}(char* word, int pos) {{
|
|
int nbCharParsed;
|
|
printf("Entering {key}\\n");""")
|
|
for i in range(1, value + 1):
|
|
print(f"""
|
|
nbCharParsed = parse_{code}{i}(word, pos);
|
|
if (nbCharParsed != -1) {{
|
|
return nbCharParsed;
|
|
}}""")
|
|
print("""
|
|
return -1;
|
|
}
|
|
""")
|
|
|
|
|
|
def get_code(s):
|
|
return ord(s) if len(s) == 1 and ((s < "A" or s > "Z") and (s < "a" or s > "z")) else s
|
|
|
|
|
|
def print_terminal_rules():
|
|
for t in terminals_set:
|
|
# escape \ and " in the terminal
|
|
safeT = "\\" + t if (t == '"' or t == '\\') else t
|
|
|
|
code = get_code(t)
|
|
l = len(t)
|
|
print(f"""\
|
|
int parse_{code}(char* word, int pos) {{
|
|
// Extract the next {l} chars of the word
|
|
char substr[{l+1}];
|
|
substr[0] = '\\0';
|
|
strncat(substr, &word[pos], {l});
|
|
|
|
// Compare this extracted string to the terminal,
|
|
// and check if the next char is a space or the end of the string
|
|
if (strcmp(substr, "{safeT}") == 0 && (word[pos+{l}] == ' ' || word[pos+{l}] == '\\0')) {{
|
|
print_with_indent(pos, "{safeT}\\n");
|
|
return {l+1};
|
|
}} else {{
|
|
return -1;
|
|
}}
|
|
}}
|
|
""")
|
|
|
|
|
|
if __name__ == '__main__':
|
|
with open("grammar.txt", "r") as f:
|
|
parse(f.readlines())
|