Fix long-standing typo: mkuastunary

Should be mkastunary.
DoctorWkt · Jan 12, 2020 · 669bccf · 669bccf
1 parent 9c39a28
commit 669bccf
Show file tree

Hide file tree

Showing 269 changed files with 723 additions and 723 deletions.
diff --git a/02_Parser/Readme.md b/02_Parser/Readme.md
@@ -199,7 +199,7 @@ struct ASTnode *mkastleaf(int op, int intvalue) {
 }
 
 // Make a unary AST node: only one child
-struct ASTnode *mkuastunary(int op, struct ASTnode *left, int intvalue) {
+struct ASTnode *mkastunary(int op, struct ASTnode *left, int intvalue) {
   return (mkastnode(op, left, NULL, intvalue));
 ```
 

diff --git a/02_Parser/decl.h b/02_Parser/decl.h
@@ -5,6 +5,6 @@ int scan(struct token *t);
 struct ASTnode *mkastnode(int op, struct ASTnode *left,
 			  struct ASTnode *right, int intvalue);
 struct ASTnode *mkastleaf(int op, int intvalue);
-struct ASTnode *mkuastunary(int op, struct ASTnode *left, int intvalue);
+struct ASTnode *mkastunary(int op, struct ASTnode *left, int intvalue);
 struct ASTnode *binexpr(void);
 int interpretAST(struct ASTnode *n);
diff --git a/02_Parser/tree.c b/02_Parser/tree.c
@@ -31,6 +31,6 @@ struct ASTnode *mkastleaf(int op, int intvalue) {
 }
 
 // Make a unary AST node: only one child
-struct ASTnode *mkuastunary(int op, struct ASTnode *left, int intvalue) {
+struct ASTnode *mkastunary(int op, struct ASTnode *left, int intvalue) {
   return (mkastnode(op, left, NULL, intvalue));
 }
diff --git a/03_Precedence/decl.h b/03_Precedence/decl.h
@@ -5,6 +5,6 @@ int scan(struct token *t);
 struct ASTnode *mkastnode(int op, struct ASTnode *left,
 			  struct ASTnode *right, int intvalue);
 struct ASTnode *mkastleaf(int op, int intvalue);
-struct ASTnode *mkuastunary(int op, struct ASTnode *left, int intvalue);
+struct ASTnode *mkastunary(int op, struct ASTnode *left, int intvalue);
 struct ASTnode *binexpr(int rbp);
 int interpretAST(struct ASTnode *n);
diff --git a/03_Precedence/tree.c b/03_Precedence/tree.c
@@ -31,6 +31,6 @@ struct ASTnode *mkastleaf(int op, int intvalue) {
 }
 
 // Make a unary AST node: only one child
-struct ASTnode *mkuastunary(int op, struct ASTnode *left, int intvalue) {
+struct ASTnode *mkastunary(int op, struct ASTnode *left, int intvalue) {
   return (mkastnode(op, left, NULL, intvalue));
 }
diff --git a/04_Assembly/decl.h b/04_Assembly/decl.h
@@ -6,7 +6,7 @@ int scan(struct token *t);
 struct ASTnode *mkastnode(int op, struct ASTnode *left,
 			  struct ASTnode *right, int intvalue);
 struct ASTnode *mkastleaf(int op, int intvalue);
-struct ASTnode *mkuastunary(int op, struct ASTnode *left, int intvalue);
+struct ASTnode *mkastunary(int op, struct ASTnode *left, int intvalue);
 struct ASTnode *binexpr(int rbp);
 
 int interpretAST(struct ASTnode *n);

diff --git a/04_Assembly/tree.c b/04_Assembly/tree.c
@@ -31,6 +31,6 @@ struct ASTnode *mkastleaf(int op, int intvalue) {
 }
 
 // Make a unary AST node: only one child
-struct ASTnode *mkuastunary(int op, struct ASTnode *left, int intvalue) {
+struct ASTnode *mkastunary(int op, struct ASTnode *left, int intvalue) {
   return (mkastnode(op, left, NULL, intvalue));
 }
diff --git a/05_Statements/decl.h b/05_Statements/decl.h
@@ -8,7 +8,7 @@ int scan(struct token *t);
 struct ASTnode *mkastnode(int op, struct ASTnode *left,
 			  struct ASTnode *right, int intvalue);
 struct ASTnode *mkastleaf(int op, int intvalue);
-struct ASTnode *mkuastunary(int op, struct ASTnode *left, int intvalue);
+struct ASTnode *mkastunary(int op, struct ASTnode *left, int intvalue);
 
 // gen.c
 int genAST(struct ASTnode *n);

diff --git a/05_Statements/tree.c b/05_Statements/tree.c
@@ -32,6 +32,6 @@ struct ASTnode *mkastleaf(int op, int intvalue) {
 }
 
 // Make a unary AST node: only one child
-struct ASTnode *mkuastunary(int op, struct ASTnode *left, int intvalue) {
+struct ASTnode *mkastunary(int op, struct ASTnode *left, int intvalue) {
   return (mkastnode(op, left, NULL, intvalue));
 }
diff --git a/06_Variables/decl.h b/06_Variables/decl.h
@@ -8,7 +8,7 @@ int scan(struct token *t);
 struct ASTnode *mkastnode(int op, struct ASTnode *left,
 			  struct ASTnode *right, int intvalue);
 struct ASTnode *mkastleaf(int op, int intvalue);
-struct ASTnode *mkuastunary(int op, struct ASTnode *left, int intvalue);
+struct ASTnode *mkastunary(int op, struct ASTnode *left, int intvalue);
 
 // gen.c
 int genAST(struct ASTnode *n, int reg);

diff --git a/06_Variables/tree.c b/06_Variables/tree.c
@@ -30,6 +30,6 @@ struct ASTnode *mkastleaf(int op, int intvalue) {
 }
 
 // Make a unary AST node: only one child
-struct ASTnode *mkuastunary(int op, struct ASTnode *left, int intvalue) {
+struct ASTnode *mkastunary(int op, struct ASTnode *left, int intvalue) {
   return (mkastnode(op, left, NULL, intvalue));
 }
diff --git a/07_Comparisons/decl.h b/07_Comparisons/decl.h
@@ -8,7 +8,7 @@ int scan(struct token *t);
 struct ASTnode *mkastnode(int op, struct ASTnode *left,
 			  struct ASTnode *right, int intvalue);
 struct ASTnode *mkastleaf(int op, int intvalue);
-struct ASTnode *mkuastunary(int op, struct ASTnode *left, int intvalue);
+struct ASTnode *mkastunary(int op, struct ASTnode *left, int intvalue);
 
 // gen.c
 int genAST(struct ASTnode *n, int reg);

diff --git a/07_Comparisons/tree.c b/07_Comparisons/tree.c
@@ -30,6 +30,6 @@ struct ASTnode *mkastleaf(int op, int intvalue) {
 }
 
 // Make a unary AST node: only one child
-struct ASTnode *mkuastunary(int op, struct ASTnode *left, int intvalue) {
+struct ASTnode *mkastunary(int op, struct ASTnode *left, int intvalue) {
   return (mkastnode(op, left, NULL, intvalue));
 }
diff --git a/08_If_Statements/decl.h b/08_If_Statements/decl.h
@@ -9,7 +9,7 @@ struct ASTnode *mkastnode(int op, struct ASTnode *left,
 			  struct ASTnode *mid,
 			  struct ASTnode *right, int intvalue);
 struct ASTnode *mkastleaf(int op, int intvalue);
-struct ASTnode *mkuastunary(int op, struct ASTnode *left, int intvalue);
+struct ASTnode *mkastunary(int op, struct ASTnode *left, int intvalue);
 
 // gen.c
 int genAST(struct ASTnode *n, int reg, int parentASTop);

diff --git a/08_If_Statements/stmt.c b/08_If_Statements/stmt.c
@@ -41,7 +41,7 @@ static struct ASTnode *print_statement(void) {
   tree = binexpr(0);
 
   // Make an print AST tree
-  tree = mkuastunary(A_PRINT, tree, 0);
+  tree = mkastunary(A_PRINT, tree, 0);
 
   // Match the following semicolon
   // and return the AST

diff --git a/08_If_Statements/tree.c b/08_If_Statements/tree.c
@@ -32,6 +32,6 @@ struct ASTnode *mkastleaf(int op, int intvalue) {
 }
 
 // Make a unary AST node: only one child
-struct ASTnode *mkuastunary(int op, struct ASTnode *left, int intvalue) {
+struct ASTnode *mkastunary(int op, struct ASTnode *left, int intvalue) {
   return (mkastnode(op, left, NULL, NULL, intvalue));
 }
diff --git a/09_While_Loops/decl.h b/09_While_Loops/decl.h
@@ -9,7 +9,7 @@ struct ASTnode *mkastnode(int op, struct ASTnode *left,
 			  struct ASTnode *mid,
 			  struct ASTnode *right, int intvalue);
 struct ASTnode *mkastleaf(int op, int intvalue);
-struct ASTnode *mkuastunary(int op, struct ASTnode *left, int intvalue);
+struct ASTnode *mkastunary(int op, struct ASTnode *left, int intvalue);
 
 // gen.c
 int genAST(struct ASTnode *n, int reg, int parentASTop);

diff --git a/09_While_Loops/stmt.c b/09_While_Loops/stmt.c
@@ -30,7 +30,7 @@ static struct ASTnode *print_statement(void) {
   tree = binexpr(0);
 
   // Make an print AST tree
-  tree = mkuastunary(A_PRINT, tree, 0);
+  tree = mkastunary(A_PRINT, tree, 0);
 
   // Match the following semicolon
   // and return the AST

diff --git a/09_While_Loops/tree.c b/09_While_Loops/tree.c
@@ -32,6 +32,6 @@ struct ASTnode *mkastleaf(int op, int intvalue) {
 }
 
 // Make a unary AST node: only one child
-struct ASTnode *mkuastunary(int op, struct ASTnode *left, int intvalue) {
+struct ASTnode *mkastunary(int op, struct ASTnode *left, int intvalue) {
   return (mkastnode(op, left, NULL, NULL, intvalue));
 }
diff --git a/10_For_Loops/decl.h b/10_For_Loops/decl.h
@@ -9,7 +9,7 @@ struct ASTnode *mkastnode(int op, struct ASTnode *left,
 			  struct ASTnode *mid,
 			  struct ASTnode *right, int intvalue);
 struct ASTnode *mkastleaf(int op, int intvalue);
-struct ASTnode *mkuastunary(int op, struct ASTnode *left, int intvalue);
+struct ASTnode *mkastunary(int op, struct ASTnode *left, int intvalue);
 
 // gen.c
 int genAST(struct ASTnode *n, int reg, int parentASTop);

diff --git a/10_For_Loops/stmt.c b/10_For_Loops/stmt.c
@@ -33,7 +33,7 @@ static struct ASTnode *print_statement(void) {
   tree = binexpr(0);
 
   // Make an print AST tree
-  tree = mkuastunary(A_PRINT, tree, 0);
+  tree = mkastunary(A_PRINT, tree, 0);
 
   // Return the AST
   return (tree);

diff --git a/10_For_Loops/tree.c b/10_For_Loops/tree.c
@@ -32,6 +32,6 @@ struct ASTnode *mkastleaf(int op, int intvalue) {
 }
 
 // Make a unary AST node: only one child
-struct ASTnode *mkuastunary(int op, struct ASTnode *left, int intvalue) {
+struct ASTnode *mkastunary(int op, struct ASTnode *left, int intvalue) {
   return (mkastnode(op, left, NULL, NULL, intvalue));
 }
diff --git a/11_Functions_pt1/Readme.md b/11_Functions_pt1/Readme.md
@@ -61,7 +61,7 @@ struct ASTnode *function_declaration(void) {
 
   // Return an A_FUNCTION node which has the function's nameslot
   // and the compound statement sub-tree
-  return(mkuastunary(A_FUNCTION, tree, nameslot));
+  return(mkastunary(A_FUNCTION, tree, nameslot));
 }
 ```
 
@@ -99,7 +99,7 @@ this is a *unary* AST node with a single child:
 ```
   // Return an A_FUNCTION node which has the function's nameslot
   // and the compound statement sub-tree
-  return(mkuastunary(A_FUNCTION, tree, nameslot));
+  return(mkastunary(A_FUNCTION, tree, nameslot));
 ```
 
 The child has the sub-tree which holds the compound statement that

diff --git a/11_Functions_pt1/decl.c b/11_Functions_pt1/decl.c
@@ -43,5 +43,5 @@ struct ASTnode *function_declaration(void) {
 
   // Return an A_FUNCTION node which has the function's nameslot
   // and the compound statement sub-tree
-  return(mkuastunary(A_FUNCTION, tree, nameslot));
+  return(mkastunary(A_FUNCTION, tree, nameslot));
 }
diff --git a/11_Functions_pt1/decl.h b/11_Functions_pt1/decl.h
@@ -9,7 +9,7 @@ struct ASTnode *mkastnode(int op, struct ASTnode *left,
 			  struct ASTnode *mid,
 			  struct ASTnode *right, int intvalue);
 struct ASTnode *mkastleaf(int op, int intvalue);
-struct ASTnode *mkuastunary(int op, struct ASTnode *left, int intvalue);
+struct ASTnode *mkastunary(int op, struct ASTnode *left, int intvalue);
 
 // gen.c
 int genAST(struct ASTnode *n, int reg, int parentASTop);

diff --git a/11_Functions_pt1/stmt.c b/11_Functions_pt1/stmt.c
@@ -33,7 +33,7 @@ static struct ASTnode *print_statement(void) {
   tree = binexpr(0);
 
   // Make an print AST tree
-  tree = mkuastunary(A_PRINT, tree, 0);
+  tree = mkastunary(A_PRINT, tree, 0);
 
   // Return the AST
   return (tree);

diff --git a/11_Functions_pt1/tree.c b/11_Functions_pt1/tree.c
@@ -32,6 +32,6 @@ struct ASTnode *mkastleaf(int op, int intvalue) {
 }
 
 // Make a unary AST node: only one child
-struct ASTnode *mkuastunary(int op, struct ASTnode *left, int intvalue) {
+struct ASTnode *mkastunary(int op, struct ASTnode *left, int intvalue) {
   return (mkastnode(op, left, NULL, NULL, intvalue));
 }
diff --git a/12_Types_pt1/Readme.md b/12_Types_pt1/Readme.md
@@ -282,9 +282,9 @@ I've modified the code in `binexpr()` in `expr.c` to do this:
 
     // Widen either side if required. type vars are A_WIDEN now
     if (lefttype)
-      left = mkuastunary(lefttype, right->type, left, 0);
+      left = mkastunary(lefttype, right->type, left, 0);
     if (righttype)
-      right = mkuastunary(righttype, left->type, right, 0);
+      right = mkastunary(righttype, left->type, right, 0);
 
     // Join that sub-tree with ours. Convert the token
     // into an AST operation at the same time.
@@ -320,7 +320,7 @@ static struct ASTnode *print_statement(void) {
     fatal("Incompatible types");
 
   // Widen the tree if required. 
-  if (righttype) tree = mkuastunary(righttype, P_INT, tree, 0);
+  if (righttype) tree = mkastunary(righttype, P_INT, tree, 0);
 ```
 
 ## Using `type_compatible()` to Assign to a Variable
@@ -352,7 +352,7 @@ static struct ASTnode *assignment_statement(void) {
 
   // Widen the left if required.
   if (lefttype)
-    left = mkuastunary(lefttype, right->type, left, 0);
+    left = mkastunary(lefttype, right->type, left, 0);
 ```
 
 Note the 1 at the the end to this call to `type_compatible()`.

diff --git a/12_Types_pt1/decl.c b/12_Types_pt1/decl.c
@@ -59,5 +59,5 @@ struct ASTnode *function_declaration(void) {
 
   // Return an A_FUNCTION node which has the function's nameslot
   // and the compound statement sub-tree
-  return (mkuastunary(A_FUNCTION, P_VOID, tree, nameslot));
+  return (mkastunary(A_FUNCTION, P_VOID, tree, nameslot));
 }
diff --git a/12_Types_pt1/decl.h b/12_Types_pt1/decl.h
@@ -10,7 +10,7 @@ struct ASTnode *mkastnode(int op, int type,
 			  struct ASTnode *mid,
 			  struct ASTnode *right, int intvalue);
 struct ASTnode *mkastleaf(int op, int type, int intvalue);
-struct ASTnode *mkuastunary(int op, int type,
+struct ASTnode *mkastunary(int op, int type,
 			    struct ASTnode *left, int intvalue);
 
 // gen.c

diff --git a/12_Types_pt1/expr.c b/12_Types_pt1/expr.c
@@ -101,9 +101,9 @@ struct ASTnode *binexpr(int ptp) {
 
     // Widen either side if required. type vars are A_WIDEN now
     if (lefttype)
-      left = mkuastunary(lefttype, right->type, left, 0);
+      left = mkastunary(lefttype, right->type, left, 0);
     if (righttype)
-      right = mkuastunary(righttype, left->type, right, 0);
+      right = mkastunary(righttype, left->type, right, 0);
 
     // Join that sub-tree with ours. Convert the token
     // into an AST operation at the same time.

diff --git a/12_Types_pt1/stmt.c b/12_Types_pt1/stmt.c
@@ -41,10 +41,10 @@ static struct ASTnode *print_statement(void) {
 
   // Widen the tree if required. 
   if (righttype)
-    tree = mkuastunary(righttype, P_INT, tree, 0);
+    tree = mkastunary(righttype, P_INT, tree, 0);
 
   // Make an print AST tree
-  tree = mkuastunary(A_PRINT, P_NONE, tree, 0);
+  tree = mkastunary(A_PRINT, P_NONE, tree, 0);
 
   // Return the AST
   return (tree);
@@ -80,7 +80,7 @@ static struct ASTnode *assignment_statement(void) {
 
   // Widen the left if required.
   if (lefttype)
-    left = mkuastunary(lefttype, right->type, left, 0);
+    left = mkastunary(lefttype, right->type, left, 0);
 
   // Make an assignment AST tree
   tree = mkastnode(A_ASSIGN, P_INT, left, NULL, right, 0);

diff --git a/12_Types_pt1/tree.c b/12_Types_pt1/tree.c
@@ -34,7 +34,7 @@ struct ASTnode *mkastleaf(int op, int type, int intvalue) {
 }
 
 // Make a unary AST node: only one child
-struct ASTnode *mkuastunary(int op, int type, struct ASTnode *left,
+struct ASTnode *mkastunary(int op, int type, struct ASTnode *left,
 			    int intvalue) {
   return (mkastnode(op, type, left, NULL, NULL, intvalue));
 }
diff --git a/13_Functions_pt2/Readme.md b/13_Functions_pt2/Readme.md
@@ -64,7 +64,7 @@ struct ASTnode *funccall(void) {
   // Build the function call AST node. Store the
   // function's return type as this node's type.
   // Also record the function's symbol-id
-  tree = mkuastunary(A_FUNCCALL, Gsym[id].type, tree, id);
+  tree = mkastunary(A_FUNCCALL, Gsym[id].type, tree, id);
 
   // Get the ')'
   rparen();
@@ -253,10 +253,10 @@ static struct ASTnode *return_statement(void) {
 
   // Widen the left if required.
   if (returntype)
-    tree = mkuastunary(returntype, functype, tree, 0);
+    tree = mkastunary(returntype, functype, tree, 0);
 
   // Add on the A_RETURN node
-  tree = mkuastunary(A_RETURN, P_NONE, tree, 0);
+  tree = mkastunary(A_RETURN, P_NONE, tree, 0);
 
   // Get the ')'
   rparen();

diff --git a/13_Functions_pt2/decl.c b/13_Functions_pt2/decl.c
@@ -76,5 +76,5 @@ struct ASTnode *function_declaration(void) {
   }
   // Return an A_FUNCTION node which has the function's nameslot
   // and the compound statement sub-tree
-  return (mkuastunary(A_FUNCTION, type, tree, nameslot));
+  return (mkastunary(A_FUNCTION, type, tree, nameslot));
 }
diff --git a/13_Functions_pt2/decl.h b/13_Functions_pt2/decl.h
@@ -11,7 +11,7 @@ struct ASTnode *mkastnode(int op, int type,
 			  struct ASTnode *mid,
 			  struct ASTnode *right, int intvalue);
 struct ASTnode *mkastleaf(int op, int type, int intvalue);
-struct ASTnode *mkuastunary(int op, int type,
+struct ASTnode *mkastunary(int op, int type,
 			    struct ASTnode *left, int intvalue);
 
 // gen.c

diff --git a/13_Functions_pt2/expr.c b/13_Functions_pt2/expr.c
@@ -25,7 +25,7 @@ struct ASTnode *funccall(void) {
   // Build the function call AST node. Store the
   // function's return type as this node's type.
   // Also record the function's symbol-id
-  tree = mkuastunary(A_FUNCCALL, Gsym[id].type, tree, id);
+  tree = mkastunary(A_FUNCCALL, Gsym[id].type, tree, id);
 
   // Get the ')'
   rparen();
@@ -139,9 +139,9 @@ struct ASTnode *binexpr(int ptp) {
 
     // Widen either side if required. type vars are A_WIDEN now
     if (lefttype)
-      left = mkuastunary(lefttype, right->type, left, 0);
+      left = mkastunary(lefttype, right->type, left, 0);
     if (righttype)
-      right = mkuastunary(righttype, left->type, right, 0);
+      right = mkastunary(righttype, left->type, right, 0);
 
     // Join that sub-tree with ours. Convert the token
     // into an AST operation at the same time.