Reader
├── __init__(grammar_file, sentences_file)
├── read_bnf_grammar() → Dict[str, List[List[str]]]
│   └── Parses BNF format with multi-line support
└── read_sentences() → List[List[str]]
    └── Tokenizes sentences with epsilon handling

Parser
├── __init__(grammar_file, sentences_file)
│   └── Initializes grammar, sentences, and parsing state
├── detect_left_recursion() → List[List[str]]
│   └── DFS-based cycle detection
├── parsing_rules(symbol: str) → Union[Dict, str, None]
│   └── Recursive descent with backtracking
└── error_check(sentence, start_symbol) → None
    └── Diagnostic report generation

Functions:
├── generate_parse_tree(derivation) → str
│   └── Text-based tree with ASCII art
└── generate_graphical_tree(derivation, entry_num, output_format) → str
    └── Graphviz PDF/PNG rendering

run_test(grammar_file, sentences_file) → None
├── Left-recursion check
├── Iterative sentence parsing
├── Result accumulation
└── Parse tree visualization (text + graphical)

SyntaxEngine (customtkinter.CTk)
├── Sidebar controls (file loading, execution)
├── Tabbed output (parse tree, JSON, anomaly logs)
├── Kernel logging (timestamped event tracking)
├── Progress animation (visual feedback)
└── Topology preview (graphical tree display)

class Reader:
    def __init__(self, grammar_file: str, sentences_file: str) -> None:
        """
        Initialize reader with file paths (relative to script location).
        
        Args:
            grammar_file (str): Relative path to BNF grammar file
            sentences_file (str): Relative path to sentences file
        
        Raises:
            None (graceful fallback on FileNotFoundError)
        """

    def read_bnf_grammar() -> Dict[str, List[List[str]]]:
        """
        Parse BNF grammar file and return production rules.
        
        Returns:
            Dict[str, List[List[str]]]: Grammar dictionary
                {
                    'E': [['T'], ['E', '+', 'T'], ['E', '-', 'T']],
                    'T': [['F'], ['T', '*', 'F']],
                    'F': [['(', 'E', ')'], ['id']]
                }
        
        Raises:
            FileNotFoundError: Returns {} (empty dict) if file not found
        
        Examples:
            >>> reader = Reader('grammar.txt', 'sentences.txt')
            >>> grammar = reader.read_bnf_grammar()
            >>> grammar['E']
            [['T'], ['E', '+', 'T']]
        """

    def read_sentences() -> List[List[str]]:
        """
        Parse sentences file and return tokenized input.
        
        Returns:
            List[List[str]]: Tokenized sentences
                [
                    ['a', '+', 'b'],
                    ['(', 'a', ')'],
                    ['ε']
                ]
        
        Raises:
            FileNotFoundError: Returns [] (empty list) if file not found
        
        Notes:
            - Single-token inputs (no spaces) are split character by character
            - Multi-token inputs (with spaces) are split by whitespace
            - Empty lines are skipped
            - Epsilon token 'ε' is preserved
        
        Examples:
            >>> sentences = reader.read_sentences()
            >>> sentences[0]
            ['a', '+', 'b']
        """

class Parser:
    def __init__(self, grammar_file: str, sentences_file: str) -> None:
        """
        Initialize parser with grammar and sentences.
        
        Attributes:
            grammar (Dict[str, List[List[str]]]): Parsed BNF rules
            sentences (List[List[str]]): Tokenized input sentences
            tokens (List[str]): Current sentence token buffer
            current_index (int): Position in token buffer
            max_idx (int): Furthest successfully consumed position
            expected_at_max (List[str]): Expected tokens at failure point
        """

    def detect_left_recursion() -> List[List[str]]:
        """
        Detect left-recursive cycles in grammar using DFS.
        
        Returns:
            List[List[str]]: Cycles found (empty if no cycles)
            [
                ['E', 'T', 'E'],  # Cycle: E→T→E
                ['S', 'S']         # Direct recursion: S→S
            ]
        
        Complexity:
            Time: O(V + E) where V = non-terminals, E = edges
            Space: O(V) visited set + O(d) recursion depth
        
        Notes:
            - Runs before parsing to prevent stack overflow
            - Detects both direct and indirect left-recursion
            - Returns empty list if grammar is left-recursive-free
        
        Examples:
            >>> cycles = parser.detect_left_recursion()
            >>> if cycles:
            ...     print("Grammar has left-recursion! Aborting.")
        """

    def parsing_rules(symbol: str) -> Union[Dict, str, None]:
        """
        Recursive descent parser with backtracking.
        
        Args:
            symbol (str): Non-terminal or terminal to parse
        
        Returns:
            Union[Dict, str, None]:
                - Dict: Successful derivation tree
                - str: Terminal token or epsilon (ε)
                - None: Parse failure
        
        State modifications:
            - Updates current_index on successful terminal match
            - Updates max_idx and expected_at_max on mismatch
            - Backtracking via recursion stack (automatic)
        
        Complexity:
            Time: O(n × g × p) worst case backtracking
            Space: O(d) recursion stack depth
        
        Notes:
            - Productions sorted by length (longest first) for heuristic
            - Epsilon productions handled implicitly
            - Non-determinism resolved via production order
        
        Examples:
            >>> parser.tokens = ['a', '+', 'b']
            >>> parser.current_index = 0
            >>> result = parser.parsing_rules('E')
            >>> print(result)
            {'T': {'F': 'a'}, '+': '+', 'T': {'F': 'b'}}
        """

    def error_check(sentence: List[str], start_symbol: str) -> None:
        """
        Generate detailed error diagnostics for failed parse.
        
        Args:
            sentence (List[str]): Original input sentence
            start_symbol (str): Grammar start symbol
        
        Prints:
            - Token position and label at error location
            - Expected tokens at failure point
            - Contextual explanation (what preceded the error)
        
        Output format:
            Invalid
            
            Error:
            •Where the error occurs: at token 2 ("d")
            •What was expected: "b" or "c"
            •Why the sentence is invalid: after 'a', the grammar requires ...
        
        Examples:
            >>> parser.error_check(['a', 'd'], 'S')
            Invalid
            
            Error:
            •Where the error occurs: at token 2 ("d")
            ...
        """

def generate_parse_tree(derivation: Dict) -> str:
    """
    Generate text-based parse tree with proper indentation.
    
    Args:
        derivation (Dict): Tree structure from parser
        {
            'E': {
                'T': {'F': 'a'},
                '+': '+',
                'T': {'F': 'b'}
            }
        }
    
    Returns:
        str: Formatted tree representation
        E
        ├── T
        │   └── F
        │       └── a
        ├── +
        └── T
            └── F
                └── b
    
    Notes:
        - Unicode box-drawing characters for visual hierarchy
        - Proper indentation at each nesting level
        - Terminal values right-aligned with parent
    """

def generate_graphical_tree(derivation: Dict, entry_num: str, 
                           output_format: str = 'pdf', 
                           view: bool = False) -> str:
    """
    Generate high-resolution parse tree visualization using Graphviz.
    
    Args:
        derivation (Dict): Tree structure from parser
        entry_num (str): Identifier for output file (e.g., 'entry_1')
        output_format (str): 'pdf' or 'png' (default: 'pdf')
        view (bool): Open file in default viewer (default: False)
    
    Returns:
        str: Path to generated output file
        'output/entry_1.pdf'
    
    Raises:
        graphviz.ExecutableNotFound: Graphviz not in system PATH
        subprocess.CalledProcessError: Rendering failed
    
    Notes:
        - Requires Graphviz system software installed
        - Creates 'output/' directory if not present
        - High-resolution rendering suitable for publication
        - Color-coded node types (non-terminal vs. terminal)
    
    Examples:
        >>> path = generate_graphical_tree(result, 'entry_1', 'pdf')
        >>> print(f"Tree saved to: {path}")
        Tree saved to: output/entry_1.pdf
    """

# Sort productions by length (longest first)
sorted_productions = sorted(grammar[symbol], key=len, reverse=True)

for production in sorted_productions:
    # Try longest productions first
    # Reduces backtracking for greedy matches

def detect_left_recursion():
    # Build dependency graph of non-terminals
    dependencies = {symbol: {first_symbols_of_productions}}
    
    # Run DFS from each non-terminal
    # If we revisit a node in current path → cycle detected
    # Abort parser before attempting problematic derivation

# Track maximum progress point
self.max_idx = 0
self.expected_at_max = []

# On each mismatch
if current_index >= max_idx:
    max_idx = current_index
    expected_at_max = expected_tokens

# Error report includes:
# 1. WHERE: Exact token position
# 2. WHAT: Expected tokens at that position
# 3. WHY: Context-aware explanation

# Save state before trying production
start_pos = current_index

# Recursively parse production
for part in production:
    result = parsing_rules(part)  # Updates current_index
    if result is None:
        break  # Failed
    
# Backtrack by restoring saved position
current_index = start_pos

# Convert derivation dictionary to DOT format
def derivation_to_dot(tree, parent_id=0):
    # Each node gets unique ID
    # Create DOT edge for each parent-child relationship
    # Render to PDF/PNG using Graphviz executable

# Ensure files are in same directory as script
# OR provide absolute paths:
Reader('/absolute/path/to/grammar.txt', '/absolute/path/to/sentences.txt')

# Increase recursion limit (temporary)
import sys
sys.setrecursionlimit(10000)

# Better: Fix the grammar
# Convert left-recursive rules to right-recursive form

# Check grammar parsing
parser = Parser('grammar.txt', 'sentences.txt')
print(parser.grammar)  # Verify structure
print(parser.sentences)  # Verify tokenization