compilerlab5 0.1.1__py3-none-any.whl

compilerlab5-0.1.1.dist-info/METADATA

@@ -0,0 +1,374 @@
+Metadata-Version: 2.4
+Name: compilerlab5
+Version: 0.1.1
+Summary: Five Compiler Design laboratory programs from Experiments 6-10
+Author: Compiler Lab Package
+License: MIT
+Keywords: compiler-design,lalr,slr,three-address-code,shift-reduce,lexical-analyzer
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+\# compilerlab5
+
+
+
+A pip-installable package containing five Compiler Design laboratory programs based on \*\*Experiment 6-10.pdf\*\*:
+
+
+
+1\. LALR bottom-up parser demo
+
+2\. SLR(1) parsing demo
+
+3\. Three-address code generator
+
+4\. Lexical analyzer for operators
+
+5\. Shift-reduce parser
+
+
+
+\## Installation
+
+
+
+Install the package from PyPI:
+
+
+
+```bash
+
+python -m pip install compilerlab5
+
+```
+
+
+
+After installation, the package can be used from any supported Python environment.
+
+
+
+\## Usage
+
+
+
+\### 1. LALR Bottom-Up Parser
+
+
+
+```bash
+
+compilerlab5 lalr
+
+```
+
+
+
+Example input:
+
+
+
+```text
+
+i+i\*i
+
+```
+
+
+
+\### 2. SLR(1) Parser
+
+
+
+```bash
+
+compilerlab5 slr
+
+```
+
+
+
+Example input:
+
+
+
+```text
+
+dd
+
+```
+
+
+
+\### 3. Three-Address Code Generator
+
+
+
+```bash
+
+compilerlab5 tac
+
+```
+
+
+
+Example input:
+
+
+
+```text
+
+a+b\*c
+
+```
+
+
+
+\### 4. Lexical Analyzer for Operators
+
+
+
+```bash
+
+compilerlab5 operator
+
+```
+
+
+
+Example input:
+
+
+
+```text
+
+\+
+
+```
+
+
+
+\### 5. Shift-Reduce Parser
+
+
+
+```bash
+
+compilerlab5 shift-reduce
+
+```
+
+
+
+Example input:
+
+
+
+```text
+
+id+id\*id
+
+```
+
+
+
+\## Individual Commands
+
+
+
+The individual console commands are also available:
+
+
+
+```bash
+
+lalr-parser
+
+slr-parser
+
+tac-generator
+
+operator-validator
+
+shift-reduce-parser
+
+```
+
+
+
+\## Python Module Usage
+
+
+
+The package can also be executed through Python:
+
+
+
+```bash
+
+python -m cpp lalr
+
+python -m cpp slr
+
+python -m cpp tac
+
+python -m cpp operator
+
+python -m cpp shift-reduce
+
+```
+
+
+
+Here, `cpp` is the internal Python package name, while `compilerlab5` is the public PyPI distribution name.
+
+
+
+\## Local Testing
+
+
+
+From the project directory:
+
+
+
+```bash
+
+python -m pip install --upgrade build
+
+python -m build
+
+```
+
+
+
+Install the generated wheel:
+
+
+
+```bash
+
+python -m pip install dist/compilerlab5-0.1.1-py3-none-any.whl
+
+```
+
+
+
+\## PyPI Publishing
+
+
+
+Build the package:
+
+
+
+```bash
+
+python -m build
+
+```
+
+
+
+Check the generated distributions:
+
+
+
+```bash
+
+dir dist
+
+```
+
+
+
+Upload the distributions using Twine:
+
+
+
+```bash
+
+python -m twine upload dist/\*
+
+```
+
+
+
+For PyPI authentication, use the username:
+
+
+
+```text
+
+\_\_token\_\_
+
+```
+
+
+
+and a valid PyPI API token as the password.
+
+
+
+\## Portability
+
+
+
+The Python package does \*\*not\*\* require GCC or Clang to run the Python implementations.
+
+
+
+Python is required on the target system.
+
+
+
+The original C source files from the supplied \*\*Experiment 6-10.pdf\*\* are also included under:
+
+
+
+```text
+
+src/cpp/c\_sources/
+
+```
+
+
+
+These source files are included for laboratory/reference purposes.
+
+
+
+\## Package Information
+
+
+
+\*\*Distribution name:\*\* `compilerlab5`
+
+
+
+\*\*Python package/module:\*\* `cpp`
+
+
+
+\*\*Current version:\*\* `0.1.1`
+
+
+
+\*\*License:\*\* MIT
+
+
+
+\## Educational Purpose
+
+
+
+This is a teaching/laboratory package containing examples for Compiler Design experiments 6-10.
+
+
+
+The parser examples intentionally follow the structure and terminology of the supplied laboratory material and are intended for educational use rather than as a production compiler toolkit.
+
+
+

compilerlab5-0.1.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+compilerlab5-0.1.1.dist-info/licenses/LICENSE,sha256=FZMl_KxZ3I8Ajtguk5x4g3NhIXqG-L49BIUpHP5GpX0,659
+cpp/__init__.py,sha256=8EOxaXdnube-I32_fswktrTi6m7XzRy7b33uoC3i1xc,88
+cpp/__main__.py,sha256=EClCwCzb6h6YBpt0hrnG4h0mlNhNePyg_xBNNSVm1os,65
+cpp/cli.py,sha256=sA0xHsvyf8jqxQiDbaH7k8h3VT44p6rJVrh13ruprXI,513
+cpp/lalr.py,sha256=eHsbHIT8AfJxwaL6081iSxwrKHHmQWF_NdvjPT4JZqg,1049
+cpp/operator.py,sha256=BFrpeZt9f3RxNks7OgdqDglF5Oi63enMgB4utyMsymU,1361
+cpp/shift_reduce.py,sha256=DJ6Ab8qflBLtKGFEksOK14sryUoz-yVB10wgujQK-nw,1998
+cpp/slr.py,sha256=nGNTleNHCO70oES3sGHRkZjD8ykGO_IOG2LERC6R17M,724
+cpp/tac.py,sha256=MCs-aYek40GbZgwoehOIjvnKHW2g1-WGoIXh0xlZH4k,1303
+cpp/c_sources/01_lalr_bottom_up.c,sha256=c4NhvcdjpIk48izCpqaZrH-k1ViN2ZWTy_gDD_4WgWw,813
+cpp/c_sources/02_slr1_parser.c,sha256=7KAvuaWvUHYQISWDYwh9Ia3QTs7Ynn1Ybg2WW33Zuf0,1497
+cpp/c_sources/03_three_address_code.c,sha256=ytSSUdpDwtLkAOo9wGSiSazQYjAp7TNTpKHF2mMnFOc,1462
+cpp/c_sources/04_operator_lexical_analyzer.c,sha256=sBkSLiLLkvoSJokqYnGrKIe3qOsLq3shrGCw2Oq7P68,1805
+cpp/c_sources/05_shift_reduce_parser.c,sha256=oORINMK1GUXpLUWnAZr_G_MQEw-lIHAkDV5h2f8KDpQ,1406
+compilerlab5-0.1.1.dist-info/METADATA,sha256=IXf682qJRfKF-zsOdiXcLfDJ03VkSgnfvacViyiltVc,3738
+compilerlab5-0.1.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+compilerlab5-0.1.1.dist-info/entry_points.txt,sha256=UETMSrtoZk72OdIBMaD-RT2t7n4YzH7nQ93T52Jrm2Y,212
+compilerlab5-0.1.1.dist-info/top_level.txt,sha256=st3_n7dR9Y75QOgD4nJcJed-luRnmOMrSoGkUl0VO1I,4
+compilerlab5-0.1.1.dist-info/RECORD,,

compilerlab5-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

compilerlab5-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,7 @@
+[console_scripts]
+compilerlab5 = cpp.cli:main
+lalr-parser = cpp.lalr:main
+operator-validator = cpp.operator:main
+shift-reduce-parser = cpp.shift_reduce:main
+slr-parser = cpp.slr:main
+tac-generator = cpp.tac:main

compilerlab5-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,15 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.

compilerlab5-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+cpp

cpp/__init__.py

@@ -0,0 +1,2 @@
+"""Five Compiler Design laboratory programs, packaged for pip."""
+__version__ = "0.1.0"

cpp/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

cpp/c_sources/01_lalr_bottom_up.c

@@ -0,0 +1,23 @@
+#include <stdio.h>
+#include <string.h>
+char stack[50]; int top = -1;
+void push(char c) { stack[++top] = c; }
+void pop(int n) { top -= n; }
+int main() {
+    char input[50]; int i = 0;
+    printf("Enter string (e.g., i+i*i): "); scanf("%49s", input);
+    push('$');
+    while (input[i] != '\0') {
+        if (input[i] == 'i') {
+            push('F'); printf("Shift i, Reduce F->i\n");
+            stack[top] = 'T'; printf("Reduce T->F\n");
+            stack[top] = 'E'; printf("Reduce E->T\n");
+        } else if (input[i] == '+' || input[i] == '*') {
+            push(input[i]); printf("Shift %c\n", input[i]);
+        } else { printf("Rejected\n"); return 0; }
+        i++;
+    }
+    if (top >= 2 && stack[top] == 'E') printf("Accepted by LALR Bottom-Up Parser\n");
+    else printf("Rejected\n");
+    return 0;
+}

cpp/c_sources/02_slr1_parser.c

@@ -0,0 +1,37 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+char input[20]; int ip = 0;
+int main() {
+    int stateStack[20], top = 0; stateStack[top] = 0;
+    printf("Enter input string: "); scanf("%19s", input); strcat(input, "$");
+    while (1) {
+        int state = stateStack[top]; char symbol = input[ip];
+        switch (state) {
+            case 0:
+                if (symbol == 'c') { stateStack[++top] = 3; ip++; }
+                else if (symbol == 'd') { stateStack[++top] = 4; ip++; }
+                else { printf("Rejected\n"); return 0; }
+                break;
+            case 1:
+                if (symbol == '$') { printf("Accepted\n"); return 0; }
+                printf("Rejected\n"); return 0;
+            case 2:
+                if (symbol == 'c') { stateStack[++top] = 3; ip++; }
+                else if (symbol == 'd') { stateStack[++top] = 4; ip++; }
+                else { printf("Rejected\n"); return 0; }
+                break;
+            case 3:
+                /* The supplied experiment omits the full state-3 transition table. */
+                printf("Rejected\n"); return 0;
+            case 4:
+                top--; state = stateStack[top];
+                if (state == 0) stateStack[++top] = 2;
+                else if (state == 2) stateStack[++top] = 5;
+                else { printf("Rejected\n"); return 0; }
+                break;
+            case 5: printf("Accepted\n"); return 0;
+            default: printf("Rejected\n"); return 0;
+        }
+    }
+}

cpp/c_sources/03_three_address_code.c

@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+char input[50]; int tempCount = 1;
+void printTAC(char op, char a, char b) { printf("t%d = %c %c %c\n", tempCount, a, op, b); tempCount++; }
+int precedence(char c) { if (c=='+'||c=='-') return 1; if(c=='*'||c=='/') return 2; return 0; }
+int main() {
+    char opStack[50], valStack[50]; int topOp=-1, topVal=-1;
+    printf("Enter expression: "); scanf("%49s", input);
+    for (int i=0; input[i]!='\0'; i++) {
+        char ch=input[i];
+        if (isalnum((unsigned char)ch)) valStack[++topVal]=ch;
+        else if (ch=='(') opStack[++topOp]=ch;
+        else if (ch==')') {
+            while(topOp!=-1 && opStack[topOp]!='(') {
+                char op=opStack[topOp--], b=valStack[topVal--], a=valStack[topVal--];
+                printTAC(op,a,b); valStack[++topVal]='t'+tempCount-1;
+            }
+            if(topOp!=-1) topOp--;
+        } else {
+            while(topOp!=-1 && opStack[topOp]!='(' && precedence(opStack[topOp])>=precedence(ch)) {
+                char op=opStack[topOp--], b=valStack[topVal--], a=valStack[topVal--];
+                printTAC(op,a,b); valStack[++topVal]='t'+tempCount-1;
+            }
+            opStack[++topOp]=ch;
+        }
+    }
+    while(topOp!=-1) {
+        char op=opStack[topOp--], b=valStack[topVal--], a=valStack[topVal--];
+        printTAC(op,a,b); valStack[++topVal]='t'+tempCount-1;
+    }
+    printf("Final result stored in t%d\n", tempCount-1); return 0;
+}

cpp/c_sources/04_operator_lexical_analyzer.c

@@ -0,0 +1,24 @@
+#include <stdio.h>
+#include <string.h>
+void validateOperator(const char *op) {
+    if(strlen(op)==1) {
+        switch(op[0]) {
+            case '+': case '-': case '*': case '/': case '%': printf("'%s' is a Valid Arithmetic Operator.\n",op); return;
+            case '<': case '>': printf("'%s' is a Valid Relational Operator.\n",op); return;
+            case '=': printf("'%s' is a Valid Assignment Operator.\n",op); return;
+            case '!': printf("'%s' is a Valid Logical NOT Operator.\n",op); return;
+            case '&': case '|': case '^': case '~': printf("'%s' is a Valid Bitwise Operator.\n",op); return;
+            case '?': case ':': printf("'%s' is a Valid Conditional/Ternary Operator.\n",op); return;
+        }
+    }
+    if(strlen(op)==2) {
+        if(!strcmp(op,"++")||!strcmp(op,"--")) { printf("'%s' is a Valid Increment/Decrement Operator.\n",op); return; }
+        if(!strcmp(op,"==")||!strcmp(op,"!=")||!strcmp(op,"<=")||!strcmp(op,">=")) { printf("'%s' is a Valid Relational Operator.\n",op); return; }
+        if(!strcmp(op,"&&")||!strcmp(op,"||")) { printf("'%s' is a Valid Logical Operator.\n",op); return; }
+        if(!strcmp(op,"+=")||!strcmp(op,"-=")||!strcmp(op,"*=")||!strcmp(op,"/=")||!strcmp(op,"%=")) { printf("'%s' is a Valid Compound Assignment Operator.\n",op); return; }
+        if(!strcmp(op,"<<")||!strcmp(op,">>")) { printf("'%s' is a Valid Bitwise Shift Operator.\n",op); return; }
+    }
+    if(strlen(op)==3 && (!strcmp(op,"<<=")||!strcmp(op,">>="))) { printf("'%s' is a Valid Compound Bitwise Shift Operator.\n",op); return; }
+    printf("'%s' is an INVALID Operator.\n",op);
+}
+int main(){ char input[10]; printf("--- Lexical Analyzer: Operator Validator ---\nEnter a symbol to validate: "); if(scanf("%9s",input)==1) validateOperator(input); return 0; }

cpp/c_sources/05_shift_reduce_parser.c

@@ -0,0 +1,21 @@
+#include <stdio.h>
+#include <string.h>
+char stack[100], input[100]; int top=-1, ip=0;
+void displayStack(){ for(int i=0;i<=top;i++) printf("%c",stack[i]); }
+void reduce() {
+    if(top>=1 && stack[top-1]=='i' && stack[top]=='d'){ stack[top-1]='E'; top--; printf("Reduce: E -> id\n"); return; }
+    if(top>=2 && stack[top-2]=='(' && stack[top-1]=='E' && stack[top]==')'){ top-=2; stack[top]='E'; printf("Reduce: E -> (E)\n"); return; }
+    if(top>=2 && stack[top-2]=='E' && stack[top-1]=='+' && stack[top]=='E'){ top-=2; stack[top]='E'; printf("Reduce: E -> E+E\n"); return; }
+    if(top>=2 && stack[top-2]=='E' && stack[top-1]=='*' && stack[top]=='E'){ top-=2; stack[top]='E'; printf("Reduce: E -> E*E\n"); return; }
+}
+int main(){
+    printf("SHIFT-REDUCE PARSER\n--------------------\nGrammar:\nE -> E+E\nE -> E*E\nE -> (E)\nE -> id\n\nEnter input string (use id for identifier): ");
+    scanf("%99s",input);
+    printf("\n%-15s %-15s %-20s\n","Stack","Input","Action");
+    printf("-----------------------------------------------\n");
+    while(input[ip]!='\0'){ stack[++top]=input[ip++]; printf("%-15s %-15s Shift %c\n",stack,input+ip,stack[top]); reduce(); }
+    while(1){ int oldTop=top; reduce(); if(oldTop==top) break; }
+    printf("\nFinal Stack: "); displayStack();
+    if(top==0 && stack[0]=='E') printf("\n\nInput string ACCEPTED.\n"); else printf("\n\nInput string REJECTED.\n");
+    return 0;
+}

cpp/cli.py

@@ -0,0 +1,19 @@
+import argparse
+from . import lalr, slr, tac, operator, shift_reduce
+
+COMMANDS = {
+    "lalr": lalr.main,
+    "slr": slr.main,
+    "tac": tac.main,
+    "operator": operator.main,
+    "shift-reduce": shift_reduce.main,
+}
+
+def main():
+    p=argparse.ArgumentParser(prog="cpp", description="Five Compiler Design lab programs")
+    p.add_argument("program", nargs="?", choices=COMMANDS, help="Program to run")
+    a=p.parse_args()
+    if not a.program:
+        p.print_help()
+        return
+    COMMANDS[a.program]()

cpp/lalr.py

@@ -0,0 +1,34 @@
+"""LALR-style bottom-up parser demo based on the supplied Experiment 6-10 PDF.
+
+Grammar demonstrated:
+E -> E+T | T
+T -> T*F | F
+F -> i
+
+This is a teaching/demo parser, matching the reduction trace style of the source.
+"""
+def parse(text: str) -> list[str]:
+    text = text.strip()
+    if not text:
+        return ["Rejected"]
+    if any(c not in "i+*" for c in text) or text[0] != "i" or text[-1] != "i":
+        return ["Rejected"]
+    if "++" in text or "**" in text or "+*" in text or "*+" in text:
+        return ["Rejected"]
+    out=[]
+    expect_operand=True
+    for c in text:
+        if expect_operand:
+            if c!="i": return ["Rejected"]
+            out += ["Shift i, Reduce F->i", "Reduce T->F", "Reduce E->T"]
+            expect_operand=False
+        else:
+            if c not in "+*": return ["Rejected"]
+            out.append(f"Shift {c}")
+            expect_operand=True
+    out.append("Accepted by LALR Bottom-Up Parser")
+    return out
+
+def main():
+    s=input("Enter string (e.g., i+i*i): ")
+    print("\n".join(parse(s)))

cpp/operator.py

@@ -0,0 +1,27 @@
+"""Lexical analyzer for operators, based on the supplied PDF."""
+def validate_operator(op: str) -> str:
+    arithmetic={"+","-","*","/","%"}
+    relational={"<",">","==","!=","<=",">="}
+    assignment={"="}
+    logical={"!","&&","||"}
+    bitwise={"&","|","^","~"}
+    conditional={"?",":"}
+    incdec={"++","--"}
+    compound={"+=","-=","*=","/=","%="}
+    shifts={"<<",">>"}
+    compound_shifts={"<<=",">>="}
+    if op in arithmetic: return f"'{op}' is a Valid Arithmetic Operator."
+    if op in relational: return f"'{op}' is a Valid Relational Operator."
+    if op in assignment: return f"'{op}' is a Valid Assignment Operator."
+    if op in logical: return f"'{op}' is a Valid Logical Operator."
+    if op in bitwise: return f"'{op}' is a Valid Bitwise Operator."
+    if op in conditional: return f"'{op}' is a Valid Conditional/Ternary Operator."
+    if op in incdec: return f"'{op}' is a Valid Increment/Decrement Operator."
+    if op in compound: return f"'{op}' is a Valid Compound Assignment Operator."
+    if op in shifts: return f"'{op}' is a Valid Bitwise Shift Operator."
+    if op in compound_shifts: return f"'{op}' is a Valid Compound Bitwise Shift Operator."
+    return f"'{op}' is an INVALID Operator."
+
+def main():
+    print("--- Lexical Analyzer: Operator Validator ---")
+    print(validate_operator(input("Enter a symbol to validate: ")))

cpp/shift_reduce.py

@@ -0,0 +1,56 @@
+"""Shift-reduce parser based on the supplied PDF.
+
+Grammar:
+E -> E+E
+E -> E*E
+E -> (E)
+E -> id
+"""
+def parse(text: str) -> list[tuple[str,str,str]]:
+    s=text.strip()
+    if not s: return [("", "", "Rejected")]
+    tokens=[]
+    i=0
+    while i<len(s):
+        if s.startswith("id",i):
+            tokens.append("id"); i+=2
+        elif s[i] in "+*()":
+            tokens.append(s[i]); i+=1
+        else:
+            return [("", s[i:], "Rejected")]
+    stack=[]; rows=[]
+    def reduce_once():
+        if len(stack)>=1 and stack[-1]=="id":
+            stack[-1]="E"; return "Reduce: E -> id"
+        if len(stack)>=3 and stack[-3:] == ["(","E",")"]:
+            del stack[-3:]; stack.append("E"); return "Reduce: E -> (E)"
+        if len(stack)>=3 and stack[-3:] == ["E","*","E"]:
+            del stack[-3:]; stack.append("E"); return "Reduce: E -> E*E"
+        if len(stack)>=3 and stack[-3:] == ["E","+","E"]:
+            del stack[-3:]; stack.append("E"); return "Reduce: E -> E+E"
+        return None
+    for idx,tok in enumerate(tokens):
+        stack.append(tok)
+        rows.append((" ".join(stack)," ".join(tokens[idx+1:]),f"Shift {tok}"))
+        # Prefer id/parenthesis reductions immediately, then repeatedly reduce.
+        while True:
+            act=reduce_once()
+            if not act: break
+            rows.append((" ".join(stack)," ".join(tokens[idx+1:]),act))
+    while True:
+        act=reduce_once()
+        if not act: break
+        rows.append((" ".join(stack),"",act))
+    rows.append((" ".join(stack),"","Input string ACCEPTED." if stack==["E"] else "Input string REJECTED."))
+    return rows
+
+def main():
+    print("SHIFT-REDUCE PARSER")
+    print("--------------------")
+    print("Grammar:")
+    print("E -> E+E\nE -> E*E\nE -> (E)\nE -> id\n")
+    s=input("Enter input string (use id for identifier): ")
+    print("\n{:<15} {:<15} {:<30}".format("Stack","Input","Action"))
+    print("-"*65)
+    for a,b,c in parse(s):
+        print("{:<15} {:<15} {}".format(a,b,c))

cpp/slr.py

@@ -0,0 +1,29 @@
+"""SLR(1) parsing demo based on the supplied PDF.
+
+Grammar:
+S -> CC
+C -> cC | d
+
+The implementation mirrors the small state-machine example in the source.
+"""
+def parse(text: str) -> list[str]:
+    s=text.strip()
+    if not s:
+        return ["Rejected"]
+    # For S -> CC, C -> cC | d, valid strings are two C strings.
+    def consume_c(i):
+        while i < len(s) and s[i] == "c":
+            i += 1
+        if i < len(s) and s[i] == "d":
+            return i+1
+        return None
+    j=consume_c(0)
+    if j is not None and j < len(s):
+        k=consume_c(j)
+        if k == len(s):
+            return ["Accepted"]
+    return ["Rejected"]
+
+def main():
+    s=input("Enter input string: ")
+    print("\n".join(parse(s)))

cpp/tac.py

@@ -0,0 +1,38 @@
+"""Three-address code generator based on the supplied PDF."""
+import re
+
+def generate(expr: str) -> list[str]:
+    expr=expr.strip()
+    if not expr:
+        raise ValueError("Expression cannot be empty")
+    if not re.fullmatch(r"[A-Za-z0-9()+*/-]+", expr):
+        raise ValueError("Only identifiers/numbers, + - * / and parentheses are supported")
+    precedence={"+":1,"-":1,"*":2,"/":2}
+    ops=[]; vals=[]; out=[]; n=1
+    def emit():
+        nonlocal n
+        op=ops.pop()
+        b=vals.pop(); a=vals.pop()
+        t=f"t{n}"
+        out.append(f"{t} = {a} {op} {b}")
+        vals.append(t); n+=1
+    for ch in expr:
+        if ch.isalnum(): vals.append(ch)
+        elif ch=="(": ops.append(ch)
+        elif ch==")":
+            while ops and ops[-1]!="(": emit()
+            if not ops: raise ValueError("Mismatched parentheses")
+            ops.pop()
+        else:
+            while ops and ops[-1]!="(" and precedence[ops[-1]]>=precedence[ch]:
+                emit()
+            ops.append(ch)
+    while ops:
+        if ops[-1]=="(": raise ValueError("Mismatched parentheses")
+        emit()
+    if len(vals)!=1: raise ValueError("Invalid expression")
+    out.append(f"Final result stored in {vals[0]}")
+    return out
+
+def main():
+    print("\n".join(generate(input("Enter expression: "))))