compilerdesign

code = """
int main() {
    int x = 10;
    float y = 3.14;
    return x + y;
}
"""

result = cd.lexical_analyzer(code)

print(result['summary'])
# {
#   'total_tokens': 24,
#   'total_characters': 52,
#   'total_lines': 7,
#   'keywords': 5,
#   'identifiers': 3,
#   'integer_constants': 1,
#   'float_constants': 1,
#   'operators': 3,
#   'punctuation': 8,
# }

print(result['tokens'])         # [('KEYWORD','int'), ('KEYWORD','main'), ...]
print(result['unique_identifiers']) # ['x', 'y']
print(result['keywords_used'])      # ['int', 'float', 'return', 'main']

code = """
int globalVar;
int add(int a, int b) {
    int sum = a + b;
    return sum;
}
"""

table = cd.build_symbol_table(code)
cd.show_symbol_table(table)   # pretty table

print(table['total'])      # 5
print(table['entries'][0])
# {'name': 'globalVar', 'type': 'int', 'kind': 'variable', 'scope': 'global', 'line': 2}

grammar = {
    'E': ['E + T', 'T'],
    'T': ['T * F', 'F'],
    'F': ['( E )', 'id']
}

new_g = cd.eliminate_left_recursion(grammar)
# {
#   'E':  ["T E'"],
#   "E'": ["+ T E'", 'ε'],
#   'T':  ["F T'"],
#   "T'": ["* F T'", 'ε'],
#   'F':  ['( E )', 'id']
# }

grammar = {'A': ['a b', 'a c', 'd']}

factored = cd.left_factoring(grammar)
# {'A': ["a A'", 'd'],  "A'": ['b', 'c']}

dup_grammar = {'A': ['a', 'a']}
result = cd.check_ambiguity(dup_grammar)
# {'ambiguous': True, 'issues': ["A has duplicate productions."]}

clean_grammar = {'A': ['a b', 'c']}
result = cd.check_ambiguity(clean_grammar)
# {'ambiguous': False, 'issues': []}

grammar = {
    'E': ['T R'],    'R': ['+ T R', 'ε'],
    'T': ['F Y'],    'Y': ['* F Y', 'ε'],
    'F': ['( E )', 'i']
}

result = cd.compute_first_follow(grammar, start='E')

print(result['FIRST'])
# {'E': ['(', 'i'], 'R': ['+', 'ε'], 'T': ['(', 'i'],
#  'Y': ['*', 'ε'], 'F': ['(', 'i']}

print(result['FOLLOW'])
# {'E': ['$', ')'], 'R': ['$', ')'], 'T': ['$', ')', '+'],
#  'Y': ['$', ')', '+'], 'F': ['$', ')', '*', '+']}

grammar = {
    'E': ['T R'], 'R': ['+ T R', 'ε'],
    'T': ['F Y'], 'Y': ['* F Y', 'ε'],
    'F': ['( E )', 'i']
}
first = cd.compute_first(grammar)
follow = cd.compute_follow(grammar, start='E')

grammar = {
    'E': ['T R'], 'R': ['+ T R', 'ε'],
    'T': ['F Y'], 'Y': ['* F Y', 'ε'],
    'F': ['( E )', 'i']
}
r = cd.build_ll1_table(grammar, start='E')

print(r['is_ll1'])      # True
print(r['conflicts'])  # [] (empty if LL(1))
print(r['table'])      # {('E','('): 'T R', ('E','i'): 'T R', ...}

grammar = {
    'E': ['T R'], 'R': ['+ T R', 'ε'],
    'T': ['F Y'], 'Y': ['* F Y', 'ε'],
    'F': ['( E )', 'i']
}
result = cd.ll1_parse(
    grammar,
    tokens=['i', '+', 'i'],
    start='E'
)

print(result['accepted'])  # True

for step in result['steps']:
    print(step['stack'], '|', step['input'], '|', step['action'])

productions = [
    ('E', ['E', '+', 'T']),
    ('E', ['T']),
    ('T', ['T', '*', 'F']),
    ('T', ['F']),
    ('F', ['id'])
]

result = cd.shift_reduce_parse(productions, tokens=['id', '+', 'id'])

print(result['accepted'])  # True

for step in result['steps']:
    print(f"Stack: {step['stack']}  Input: {step['input']}  Action: {step['action']}")

grammar = {
    'E': ['T R'], 'R': ['+ T R', 'ε'],
    'T': ['F Y'], 'Y': ['* F Y', 'ε'],
    'F': ['( E )', 'i']
}
result = cd.compute_leading_trailing(grammar)

print(result['LEADING'])
# {'E': ['(', '+', '*', 'i'], 'R': ['+'], ...}

print(result['TRAILING'])
# {'E': [')', '+', '*', 'i'], ...}

# Individual functions:
leading  = cd.compute_leading(grammar)
trailing = cd.compute_trailing(grammar)

productions = [
    ('E', ['E', '+', 'T']),
    ('E', ['T']),
    ('T', ['id'])
]

result = cd.compute_lr0_items(productions, start='E')

print(f"Total states: {result['num_states']}")  # Total states: 6

for state in result['states']:
    print(f"\nState {state['id']}:")
    for item in state['items']:
        print(f"  {item}")  # e.g. "E' -> . E"

for (frm, sym, to) in result['transitions']:
    print(f"  State {frm} --{sym}--> State {to}")

# Infix → Postfix (Reverse Polish Notation)
cd.infix_to_postfix("a + b * c")     # "a b c * +"
cd.infix_to_postfix("(a + b) * c")   # "a b + c *"
cd.infix_to_postfix("a ^ b ^ c")     # "a b c ^ ^"  (right-assoc)

# Infix → Prefix (Polish Notation)
cd.infix_to_prefix("a + b * c")      # "+ a * b c"

# Postfix → Infix
cd.postfix_to_infix("a b c * +")      # "(a + (b * c))"

# Prefix → Infix
cd.prefix_to_infix("+ a * b c")      # "(a + (b * c))"

# Postfix → Prefix
cd.postfix_to_prefix("a b c * +")    # "+ a * b c"

# Prefix → Postfix
cd.prefix_to_postfix("+ a * b c")    # "a b c * +"

# Universal converter
cd.convert_expression(
    "a + b * c",
    from_notation="infix",
    to_notation="postfix"
)  # "a b c * +"

tac = cd.generate_three_address_code("a + b * c - d")
cd.show_three_address_code(tac)   # pretty table

for line in tac['pretty']:
    print(line)
# t1 = b * c
# t2 = a + t1
# t3 = t2 - d

print(tac['final'])   # 't3' (where the result lives)

dag = cd.build_dag("a + a * b")
cd.show_dag(dag)

# 'a' appears only once in the node list — shared leaf
print([n['label'] for n in dag['nodes']])
# ['a', 'b', '*', '+']

# End-to-end example — every step shows a clean table
import compilerdesign as cd

src = "int add(int a, int b) { int c = a + b * 2; return c; }"

cd.show_lexical(cd.lexical_analyzer(src))
cd.show_symbol_table(cd.build_symbol_table(src))
cd.show_three_address_code(cd.generate_three_address_code("a + b * 2"))
cd.show_dag(cd.build_dag("a + b * 2"))

g = {'E': ['E + T', 'T'], 'T': ['T * F', 'F'], 'F': ['( E )', 'id']}
g = cd.eliminate_left_recursion(g)
cd.show_grammar(g, "NO LEFT RECURSION")
cd.show_first_follow(cd.compute_first_follow(g, start='E'))
cd.show_ll1_table(cd.build_ll1_table(g, start='E'))
cd.show_parse_trace(cd.ll1_parse(g, ['id', '+', 'id'], start='E'))