continued const correcting

Author: Joshua Goller

ch-4/rpc/include/rpc.h

@@ -67,11 +67,11 @@ void ungets(const char* const s, const int len);
 int parse(char* const s, const int s_size);
 
 // lexer.c
-operand_type lex(char symbol[], int len);
-operand_type handle_alpha(char oper[], int len);
-operand_type handle_numeric(char oper[], int len);
-int is_operator(char oper);
-operand_type handle_operator(char oper);
+operand_type lex(char* const symbol, const int len);
+operand_type handle_alpha(const char* const oper, const int len);
+operand_type handle_numeric(const char* const oper, const int len);
+int is_operator(const char oper);
+operand_type handle_operator(const char oper);
 
 // rpn_math.c
 bool double_eq(const double x, const double y);
@@ -92,14 +92,14 @@ void rpn_sqrt(operand val1);
 void rpn_floor(operand val1);
 
 // stack.c
-int push(operand op);
+int push(const operand op);
 operand pop(void);
 operand peek(void);
 void duplicate_top(void);
 void swap_top(void);
 int get_stack_top(void);
 
 // vars.c
-void assign(operand val1, operand val2);
-operand dereference(operand op);
-int validate_var(operand op);
+void assign(const operand val1, const operand val2);
+operand dereference(const operand op);
+int validate_var(const operand op);

ch-4/rpc/src/lexer.c

@@ -9,11 +9,10 @@ this file do.
 */
 
 // lex: get next operator or numeric operand
-operand_type lex(char symbol[], int token_len) {
+operand_type lex(char* const symbol, const int token_len) {
   int len;
 
   while ((len = parse(symbol, token_len))) {
-    // printf("lex() | parsed symbol: %s (%d)\n", symbol, len);
     if (len == -1) {
       return EXIT;
     }
@@ -41,7 +40,7 @@ operand_type lex(char symbol[], int token_len) {
   return CONTINUE;
 }
 
-operand_type handle_alpha(char operator[], int len) {
+operand_type handle_alpha(const char* const operator, const int len) {
   /*
   If we hit an alpha char, there are only two valid expressions:
   1) it's one character long, and therefore a variable
@@ -90,12 +89,12 @@ operand_type handle_alpha(char operator[], int len) {
   return GARBAGE;
 }
 
-int is_operator(char op) {
+int is_operator(const char op) {
   return ((op == '+') || (op == '-') || (op == '/') || (op == '*') ||
           (op == '%') || (op == '='));
 }
 
-operand_type handle_operator(char operator) {
+operand_type handle_operator(const char operator) {
   // printf("handle_operator() | handling %c\n", operator);
   switch (operator) {
     case '+':

ch-4/rpc/src/vars.c

@@ -5,46 +5,45 @@
 // A-Z at offsets 26-51
 static double vars_table[MAX_STACK_SIZE];
 
-void assign(operand val1, operand val2) {
+void assign(const operand val1, const operand val2) {
   if (!validate_var(val1)) {
     return;
   }
 
-  if (val2.type == VAR) {
-    val2 = dereference(val2);
-  }
+  const operand val2_ready = (val2.type == VAR) ? dereference(val2) : val2;
 
   if (val1.cvalue >= 'a' && val1.cvalue <= 'z') {
-    vars_table[val1.cvalue - 'a'] = val2.dvalue;
+    vars_table[val1.cvalue - 'a'] = val2_ready.dvalue;
   } else if (val1.cvalue >= 'A' && val1.cvalue <= 'Z') {
     // upper case var storage starts at vars_table[26]
-    vars_table[val1.cvalue - 'A' + 26] = val2.dvalue;
+    vars_table[val1.cvalue - 'A' + 26] = val2_ready.dvalue;
   }
 
   // C style assignment returns the value assigned
-  push(val2);
+  push(val2_ready);
 }
 
-operand dereference(operand op) {
+operand dereference(const operand op) {
   if (!validate_var(op)) {
     return (operand){GARBAGE, 0, 0.0};
   }
 
+  operand new;
   if (op.cvalue >= 'a' && op.cvalue <= 'z') {
-    op.dvalue = vars_table[op.cvalue - 'a'];
+    new.dvalue = vars_table[op.cvalue - 'a'];
   } else if (op.cvalue >= 'A' && op.cvalue <= 'Z') {
-    op.dvalue = vars_table[op.cvalue - 'A' + 26];
+    new.dvalue = vars_table[op.cvalue - 'A' + 26];
   } else {
     printf("Error: Invalid lvalue for variable assignment.\n");
     return (operand){GARBAGE, 0, 0.0};
   }
 
-  op.type = VAL;
-  op.cvalue = 0;
-  return op;
+  new.type = VAL;
+  new.cvalue = 0;
+  return new;
 }
 
-int validate_var(operand var) {
+int validate_var(const operand var) {
   if (var.type != VAR) {
     printf("validate_var() | Error: operand is not a VAR.\n");
     return 0;