pcddd 1.0.1__tar.gz

pcddd-1.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 R Sam Gladson
+
+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, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pcddd-1.0.1/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: pcddd
+Version: 1.0.1
+Summary: PCD C programs stored as text and printable from the command line
+Author: R Sam Gladson
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# PCD Code Library
+
+A small Python package containing 10 C programs from the PCD experiments, stored as text and printed from the command line.
+
+## Install
+
+```bash
+pip install pcddd
+```
+
+## Usage
+
+```text
+pcd list
+pcd 1
+pcd 2
+...
+pcd 10
+```
+
+The package prints the stored C source code; it does not execute the C programs.
+
+You can save a program from CMD:
+
+```text
+pcd 1 > program1.c
+```

pcddd-1.0.1/README.md

@@ -0,0 +1,27 @@
+# PCD Code Library
+
+A small Python package containing 10 C programs from the PCD experiments, stored as text and printed from the command line.
+
+## Install
+
+```bash
+pip install pcddd
+```
+
+## Usage
+
+```text
+pcd list
+pcd 1
+pcd 2
+...
+pcd 10
+```
+
+The package prints the stored C source code; it does not execute the C programs.
+
+You can save a program from CMD:
+
+```text
+pcd 1 > program1.c
+```

pcddd-1.0.1/pcd_codes/__init__.py

@@ -0,0 +1,2 @@
+"""PCD C program source-code library."""
+__version__ = "1.0.1"

pcddd-1.0.1/pcd_codes/__main__.py

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

pcddd-1.0.1/pcd_codes/cli.py

@@ -0,0 +1,55 @@
+from importlib.resources import files
+
+PROGRAMS = {
+    "1": "01_string_patterns.c",
+    "2": "02_nfa_to_dfa.c",
+    "3": "03_regex_to_nfa.c",
+    "4": "04_lexical_analyser_spaces_comments.c",
+    "5": "05_predictive_parser.c",
+    "6": "06_operator_lexical_analyser.c",
+    "7": "07_shift_reduce_parser.c",
+    "8": "08_lalr_bottom_up_parser.c",
+    "9": "09_slr1_parser.c",
+    "10": "10_three_address_code.c",
+}
+
+TITLES = {
+    "1": "Recognize string under 'a', 'a*b+', 'abb'",
+    "2": "Convert NFA to DFA",
+    "3": "Convert regular expression into NFA",
+    "4": "Lexical analyser to ignore redundant spaces, tabs, newlines and comments",
+    "5": "Construct a predictive parser",
+    "6": "Lexical analyser for operators",
+    "7": "Shift-reduce parsing",
+    "8": "Construct LALR bottom-up parser",
+    "9": "Implement SLR(1) Parsing algorithm",
+    "10": "Generate three address code using C",
+}
+
+
+def print_program(number: str) -> None:
+    if number not in PROGRAMS:
+        raise SystemExit(f"Program {number} not found. Use 'pcd list' to see available programs.")
+    path = files("pcd_codes").joinpath("programs", PROGRAMS[number])
+    print(path.read_text(encoding="utf-8"), end="")
+
+
+def main() -> None:
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        prog="pcd",
+        description="Print PCD C programs stored as source text."
+    )
+    parser.add_argument("command", nargs="?", help="program number (1-10) or 'list'")
+    args = parser.parse_args()
+
+    if args.command is None or args.command.lower() == "list":
+        print("Available PCD programs:\n")
+        for number, title in TITLES.items():
+            print(f"{number:>2}. {title}")
+        print("\nUsage: pcd <number>")
+        print("Example: pcd 1")
+        return
+
+    print_program(args.command)

pcddd-1.0.1/pcd_codes/programs/01_string_patterns.c

@@ -0,0 +1,31 @@
+#include<stdio.h>
+#include<string.h>
+int main(){
+       char str[100];
+       int i=0;
+       printf("Enter a String:");
+       scanf("%s",str);
+
+       if(strcmp(str,"a")==0){
+               printf("String matches pattern'a'");
+               return 0;
+       }
+       if(strcmp(str,"abb")==0){
+               printf("String matches pattern 'abb'\n");
+               return 0;
+       }
+       i=0;
+       while(str[i]=='a'){
+               i++;
+       }
+       int bcount = 0;
+       while(str[i]=='b'){
+               bcount++;
+               i++;
+       }
+       if(bcount > 0 && str[i]=='\0')
+         printf("String matches pattern 'a*b+'\n");
+       else
+          printf("String does not match any pattern \n");
+       return 0;
+}

pcddd-1.0.1/pcd_codes/programs/02_nfa_to_dfa.c

@@ -0,0 +1,90 @@
+#include <stdio.h>
+#include<string.h>
+#define MAX 10
+int n;
+int i , j ,sym;
+int t[MAX][MAX][MAX];
+int dfastates[MAX][MAX];
+int dfacount=0;
+int visited[MAX];
+void adddfastate(int set[]){
+           for( i=0; i<dfacount;i++){
+                    int same=1;
+                    for(j=0;j<n;j++){
+                             if(dfastates[i][j]!=set[j]){
+                                      same=0;
+                                      break;
+                             }
+                    }
+                    if(same) return;
+           }
+           for (j=0;j<n;j++){
+                    dfastates[dfacount][j]=set[j];
+           }
+           dfacount++;
+}
+void printset(int set[]){
+           printf("{");
+           for(i=0;i<n;i++){
+                    if(set[i]) printf("q%d",i);
+           }
+           printf("}");
+}
+void nfatodfa(int start){
+           int q[MAX][MAX];
+           int front=0,rear=0;
+           int startset[MAX]={0};
+           startset[start]=1;
+           memcpy(q[rear++],startset,sizeof(startset));
+           adddfastate(startset);
+           printf("\nDFA states:\n");
+           while(front<rear){
+                    int current[MAX];
+                    memcpy(current,q[front++],sizeof(current));
+                    printf("\n State");
+                    printset(current);
+                    printf("->");
+                    for( sym=0;sym<2;sym++){
+                             int newset[MAX]={0};
+                             for( i=0;i<n;i++){
+                                      if(current[i]){
+                                              for( j=0; j<n;j++){
+                                                      if(t[i][sym][j]){
+                                                               newset[j]=1;
+                                                      }
+                                              }
+                                      }
+                             }
+                             printf("\n on input %c->", sym==0?'a':'b');
+                             printset(newset);
+                             adddfastate(newset);
+                             int exists=0;
+                             for( i=0;i<rear;i++){
+                                     if(memcmp(q[i],newset,sizeof(newset))==0){
+                                             exists=1;
+                                             break;
+                                     }
+                             }
+                             if(!exists){
+                                     memcpy(q[rear++],newset,sizeof(newset));
+                             }
+                     }
+           }
+}
+int main(){
+       int start;
+       printf("Enter number of nfa states:");
+       scanf("%d",&n);
+       printf("\nEnter nfa transition table(0/1) for a and b");
+       for( i=0; i<n; i++){
+                for( sym=0; sym<2;sym++){
+                        for(j=0;j<n;j++){
+                                scanf("%d",&t[i][sym][j]);
+                        }
+                }
+       }
+       printf("\nEnter start state:");
+       scanf("%d",&start);
+       nfatodfa(start);
+       return 0;
+}

pcddd-1.0.1/pcd_codes/programs/03_regex_to_nfa.c

@@ -0,0 +1,80 @@
+include<stdio.h>
+#include<string.h>
+#define MAX 100
+int state=0;
+typedef struct{
+         int start;
+         int end;
+}
+NFA;
+void printTrans(int s,char c,int d){
+         if(c=='e')
+         printf("q%d--e-->q%d\n",s,d);
+         else
+         printf("q%d--%c-->q%d\n",s,c,d);
+}
+
+NFA createBasic(char c){
+       NFA n;
+       n.start=state++;
+       n.end=state++;
+       printTrans(n.start,c,n.end);
+       return n;
+}
+
+NFA concatenate(NFA a,NFA b){
+       printTrans(a.end,'e',b.start);
+       NFA n;
+       n.start=a.start;
+       n.end=b.end;
+       return n;
+}
+
+NFA unionNFA(NFA a,NFA b){
+        NFA n;
+        n.start=state++;
+        n.end=state++;
+        printTrans(n.start,'e',a.start);
+        printTrans(n.start,'e',b.start);
+        printTrans(a.end,'e',n.end);
+        printTrans(b.end,'e',n.end);
+        return n;
+}NFA kleene(NFA a){
+        NFA n;
+        n.start=state++;
+        n.end=state++;
+        printTrans(n.start,'e',a.start);
+        printTrans(n.start,'e',n.end);
+        printTrans(a.end,'e',a.start);
+        printTrans(a.end,'e',n.end);
+        return n;
+}
+
+int main(){
+        char regex[MAX];
+        NFA stack[MAX];
+        int top=-1;
+        printf("Enter simple regex(example:a/b*):");
+        scanf("%s",regex);
+        int i;
+        for(i=0;i<strlen(regex);i++){
+                 char c=regex[i];
+                 if(c=='a'||c=='b'){
+                          stack[++top]=createBasic(c);
+                 }
+
+                else if(c=='*'){
+                         stack[top]=kleene(stack[top]);
+                }
+                else if(c=='|'){
+                         NFA b=stack[top--];
+                         NFA a=stack[top--];
+                         stack[++top]=unionNFA(a,b);
+                }
+
+        }
+
+        printf("\n Start state:q%d\n",stack[top].start);
+        printf("Final state:q%d\n",stack[top].end);
+        return 0;
+}

pcddd-1.0.1/pcd_codes/programs/04_lexical_analyser_spaces_comments.c

@@ -0,0 +1,24 @@
+#include <stdio.h>
+int main()
+{
+  FILE *fp;
+  char ch, next;
+  fp = fopen("input.txt", "r");
+  if (fp == NULL){
+     printf("Cannot open file\n");
+     return 1;
+     }
+printf("Source code after removing spaces, tabs, newlines & comments:\n");
+while ((ch = fgetc(fp)) != EOF) {
+     if (ch == ' ' || ch == '\t' || ch == '\n')
+           continue;
+     if (ch == '\\'){
+         next = fgetc(fp);
+        if (next == '\n')
+           continue;
+     }
+     putchar(ch);
+}
+fclose(fp);
+return 0;
+}

pcddd-1.0.1/pcd_codes/programs/05_predictive_parser.c

@@ -0,0 +1,115 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+char stack[100];
+int top = -1;
+
+void push(char c) {
+  stack[++top] = c;
+}
+
+char pop() {
+  if (top == -1) return '\0';
+  return stack[top--];
+}
+
+char peek() {
+  if (top == -1) return '\0';
+  return stack[top];
+}
+
+void printStack() {
+  for (int i = 0; i <= top; i++) {
+     printf("%c", stack[i]);
+  }
+}
+
+int getRowIndex(char c) {
+   if (c == 'S') return 0;
+   if (c == 'B') return 1;
+   return -1;
+}
+
+int getColIndex(char c) {
+   if (c == 'a') return 0;
+   if (c == 'b') return 1;
+   if (c == '$') return 2;
+   return -1;
+}
+
+int main() {
+
+  char table[2][3][10] = {
+     { "aBa", "", "" },
+     { "", "bB", "#" }
+  };
+
+  char input[100];
+  printf("Enter the input string (end with $): ");
+  scanf("%s", input);
+
+  push('$');
+  push('S');
+
+  int ip = 0;
+  printf("\n%-20s %-20s %-20s\n", "Stack", "Input Buffer", "Action");
+  printf("------------------------------------------------------------\n");
+
+  while (peek() != '$') {
+
+    printStack();
+    printf("\t\t\t");
+    printf("%s", input + ip);
+    printf("\t\t\t");
+
+    char X = peek();
+    char a = input[ip];
+
+    if (X == a) {
+       printf("Match %c\n", a);
+       pop();
+       ip++;
+    }
+    else if (X >= 'a' && X <= 'z') {
+
+       printf("\nSyntax Error: Terminal mismatch! Expected %c but found %c\n", X, a);
+       return 1;
+    }
+    else {
+
+       int r = getRowIndex(X);
+       int c = getColIndex(a);
+
+       if (r == -1 || c == -1 || strlen(table[r][c]) == 0) {
+          printf("\nSyntax Error: No parsing table entry for [%c, %c]\n", X, a);
+          return 1;
+       }
+
+       char *prod = table[r][c];
+       printf("%c -> %s\n", X, prod);
+       pop();
+
+       if (strcmp(prod, "#") != 0) {
+          for (int i = strlen(prod) - 1; i >= 0; i--) {
+             push(prod[i]);
+          }
+       }
+    }
+  }
+
+  printStack();
+  printf("\t\t\t");
+  printf("%s", input + ip);
+  printf("\t\t\t");
+
+  if (peek() == '$' && input[ip] == '$') {
+     printf("Success\n");
+     printf("\nResult: String successfully Parsed & Accepted!\n");
+  } else {
+     printf("Error\n");
+     printf("\nResult: Syntax Error. Input rejected.\n");
+  }
+
+  return 0;
+}

pcddd-1.0.1/pcd_codes/programs/06_operator_lexical_analyser.c

@@ -0,0 +1,78 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdbool.h>
+// Function to validate and classify the operator
+void validateOperator(const char *op) {
+  // 1-character operators
+  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;
+        default:
+           break;
+     }
+  }
+  // 2-character operators
+  if (strlen(op) == 2) {
+     if (strcmp(op, "++") == 0 || strcmp(op, "--") == 0) {
+        printf("'%s' is a Valid Increment/Decrement Operator.\n", op);
+        return;
+     }
+     if (strcmp(op, "==") == 0 || strcmp(op, "!=") == 0 ||
+        strcmp(op, "<=") == 0 || strcmp(op, ">=") == 0) {
+        printf("'%s' is a Valid Relational Operator.\n", op);
+        return;
+     }
+     if (strcmp(op, "&&") == 0 || strcmp(op, "||") == 0) {
+        printf("'%s' is a Valid Logical Operator.\n", op);
+        return;
+     }
+     if (strcmp(op, "+=") == 0 || strcmp(op, "-=") == 0 ||
+        strcmp(op, "*=") == 0 || strcmp(op, "/=") == 0 || strcmp(op, "%=") == 0) {
+        printf("'%s' is a Valid Compound Assignment Operator.\n", op);
+        return;
+     }
+     if (strcmp(op, "<<") == 0 || strcmp(op, ">>") == 0) {
+        printf("'%s' is a Valid Bitwise Shift Operator.\n", op);
+        return;
+     }
+  }
+  // 3-character operators
+  if (strlen(op) == 3) {
+      if (strcmp(op, "<<=") == 0 || strcmp(op, ">>=") == 0) {
+         printf("'%s' is a Valid Compound Bitwise Shift Operator.\n", op);
+         return;
+      }
+  }
+  // If no match is found
+  printf("'%s' is an INVALID Operator.\n", op);
+}
+
+int main() {
+   char input[10];
+
+    printf("--- Lexical Analyzer: Operator Validator ---\n");
+    printf("Enter a symbol to validate: ");
+
+    // Read string token, ignoring trailing newline characters
+    if (scanf("%9s", input) == 1) {
+       validateOperator(input);
+    }
+    return 0;
+}

pcddd-1.0.1/pcd_codes/programs/07_shift_reduce_parser.c

@@ -0,0 +1,106 @@
+#include <stdio.h>
+#include <string.h>
+char stack[100], input[100];
+int top = -1, ip = 0;
+void displayStack()
+{
+    int i;
+    for (i = 0; i <= top; i++)
+       printf("%c", stack[i]);
+}
+void reduce()
+{
+  /* E -> id */
+  if (top >= 1 &&
+     stack[top - 1] == 'i' &&
+     stack[top] == 'd')
+  {
+     stack[top - 1] = 'E';
+     top--;
+     printf("Reduce: E -> id\n");
+     return;
+  }
+
+    /* E -> (E) */
+    if (top >= 2 &&
+       stack[top - 2] == '(' &&
+       stack[top - 1] == 'E' &&
+       stack[top] == ')')
+    {
+       top -= 2;
+       stack[top] = 'E';
+       printf("Reduce: E -> (E)\n");
+       return;
+    }
+    /* E -> E+E */
+    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;
+    }
+    /* E -> E*E */
+    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");
+   printf("--------------------\n");
+
+  printf("Grammar:\n");
+  printf("E -> E+E\n");
+  printf("E -> E*E\n");
+  printf("E -> (E)\n");
+  printf("E -> id\n\n");
+
+  printf("Enter input string (use id for identifier): ");
+  scanf("%s", input);
+
+  printf("\n%-15s %-15s %-20s\n",
+       "Stack", "Input", "Action");
+  printf("-----------------------------------------------\n");
+
+  while (input[ip] != '\0')
+  {
+    /* Shift */
+    stack[++top] = input[ip++];
+
+      printf("%-15s %-15s ",
+           stack, input + ip);
+
+      printf("Shift %c\n", stack[top]);
+
+      /* Try reduction */
+      reduce();
+  }
+  /* Continue reducing until no reduction is possible */
+  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;
+}

pcddd-1.0.1/pcd_codes/programs/08_lalr_bottom_up_parser.c

@@ -0,0 +1,43 @@
+#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("%s", 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;
+}

pcddd-1.0.1/pcd_codes/programs/09_slr1_parser.c

@@ -0,0 +1,67 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+char input[20];
+int ip = 0;
+int main() {
+   int stateStack[20];
+   int top = 0;
+   stateStack[top] = 0;
+   printf("Enter input string: ");
+   scanf("%s", 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;
+            }
+            break;
+         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 4: /* Reduce C → d */
+            top--;
+            state = stateStack[top];
+            if (state == 0)
+               stateStack[++top] = 2;
+            else if (state == 2)
+               stateStack[++top] = 5;
+            break;
+         case 5: /* Reduce S → CC */
+            printf("Accepted\n");
+            return 0;
+         default:
+            printf("Rejected\n");
+            return 0;
+      }
+   }
+}

pcddd-1.0.1/pcd_codes/programs/10_three_address_code.c

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

pcddd-1.0.1/pcddd.egg-info/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: pcddd
+Version: 1.0.1
+Summary: PCD C programs stored as text and printable from the command line
+Author: R Sam Gladson
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# PCD Code Library
+
+A small Python package containing 10 C programs from the PCD experiments, stored as text and printed from the command line.
+
+## Install
+
+```bash
+pip install pcddd
+```
+
+## Usage
+
+```text
+pcd list
+pcd 1
+pcd 2
+...
+pcd 10
+```
+
+The package prints the stored C source code; it does not execute the C programs.
+
+You can save a program from CMD:
+
+```text
+pcd 1 > program1.c
+```

pcddd-1.0.1/pcddd.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+LICENSE
+README.md
+pyproject.toml
+pcd_codes/__init__.py
+pcd_codes/__main__.py
+pcd_codes/cli.py
+pcd_codes/programs/01_string_patterns.c
+pcd_codes/programs/02_nfa_to_dfa.c
+pcd_codes/programs/03_regex_to_nfa.c
+pcd_codes/programs/04_lexical_analyser_spaces_comments.c
+pcd_codes/programs/05_predictive_parser.c
+pcd_codes/programs/06_operator_lexical_analyser.c
+pcd_codes/programs/07_shift_reduce_parser.c
+pcd_codes/programs/08_lalr_bottom_up_parser.c
+pcd_codes/programs/09_slr1_parser.c
+pcd_codes/programs/10_three_address_code.c
+pcddd.egg-info/PKG-INFO
+pcddd.egg-info/SOURCES.txt
+pcddd.egg-info/dependency_links.txt
+pcddd.egg-info/entry_points.txt
+pcddd.egg-info/top_level.txt

pcddd-1.0.1/pcddd.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pcddd-1.0.1/pcddd.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pcd = pcd_codes.cli:main

pcddd-1.0.1/pcddd.egg-info/top_level.txt

@@ -0,0 +1 @@
+pcd_codes

pcddd-1.0.1/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pcddd"
+version = "1.0.1"
+description = "PCD C programs stored as text and printable from the command line"
+readme = "README.md"
+requires-python = ">=3.9"
+authors = [
+    { name = "R Sam Gladson" }
+]
+license = "MIT"
+license-files = ["LICENSE"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Operating System :: OS Independent",
+]
+
+[project.scripts]
+pcd = "pcd_codes.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["pcd_codes*"]
+
+[tool.setuptools.package-data]
+pcd_codes = ["programs/*.c"]

pcddd-1.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+