Add a bunch more operation

Makefile

@@ -1,21 +1,33 @@
-OBJS=abCalc.o abCalcExpr.o abCalcExprReal.o abCalcExprInt.o abCalcStack.o \
-    abCalcMode.o abCalcMain.o abCalcOp.o abCalcOpAdd.o abCalcError.o
+OBJS=abCalc.o abCalcExpr.o abCalcExpReal.o abCalcExprInt.o abCalcStack.o \
+    abCalcMode.o abCalcMain.o abCalcOp.o abCalcError.o abCalcOpAdd.o \
+    abCalcOpSubtr.o abCalcOpMult.o abCalcOpDiv.o abCalcOpPower.o \
+    abCalcOpAnd.o abCalcOpOr.o abCalcOpXor.o abCalcOpNot.o
 
 NAME=abCalc
 
 all: $(NAME)
 
 abCalcExpr.o: abCalcExpr.h
-abCalcExprReal.o: abCalcExpr.h abCalcExprReal.h
+abCalcExpReal.o: abCalcExpr.h abCalcExpReal.h
+abCalcExprInt.o: abCalcExpr.h abCalcMode.h abCalcExprInt.h
 abCalcStack.o: abCalcExpr.h abCalcStack.h abCalcError.h
 abCalcMode.o: abCalcMode.h abCalcExpr.h
-abCalcExprInt.o: abCalcExpr.h abCalcMode.h abCalcExprInt.h
-abCalc.o: abCalc.h abCalcExpr.h abCalcMode.h abCalcExprReal.h abCalcExprInt.h \
-         abCalcStack.h abCalcOp.h abCalcError.h
-abCalcMain.o: abCalc.h abCalcStack.h abCalcExpr.h abCalcOp.h abCalcError.h
-abCalcOp.o: abCalcOp.h abCalcError.h abCalcExpr.h abCalcStack.h abCalcOpAdd.h
-abCalcOpAdd.o: abCalcOp.h abCalcError.h abCalcOpAdd.h
 abCalcError.o: abCalcError.h
+abCalc.o: abCalc.h abCalcExpr.h abCalcMode.h abCalcExpReal.h abCalcExprInt.h \
+    abCalcStack.h abCalcOp.h abCalcError.h
+abCalcMain.o: abCalc.h abCalcStack.h abCalcExpr.h abCalcOp.h abCalcError.h
+abCalcOp.o: abCalcOp.h abCalcError.h abCalcExpr.h abCalcStack.h abCalcOpAdd.h \
+    abCalcOpSubtr.h abCalcOpMult.h abCalcOpDiv.h abCalcOpPower.h \
+    abCalcOpAnd.h abCalcOpOr.h abCalcOpXor.h abCalcOpNot.h
+abCalcOpAdd.o: abCalcOp.h abCalcError.h abCalcOpAdd.h
+abCalcOpSubtr.o: abCalcOp.h abCalcError.h abCalcOpSubtr.h
+abCalcOpMult.o: abCalcOp.h abCalcError.h abCalcOpMult.h
+abCalcOpDiv.o: abCalcOp.h abCalcError.h abCalcOpDiv.h
+abCalcOpPower.o: abCalcOp.h abCalcError.h abCalcOpPower.h
+abCalcOpAnd.o: abCalcOp.h abCalcError.h abCalcOpAnd.h
+abCalcOpOr.o: abCalcOp.h abCalcError.h abCalcOpOr.h
+abCalcOpXor.o: abCalcOp.h abCalcError.h abCalcOpXor.h
+abCalcOpNot.o: abCalcOp.h abCalcError.h abCalcOpNot.h
 
 
 $(NAME): $(OBJS)

abCalc.c

@@ -6,7 +6,7 @@
 
 #include "abCalcExpr.h"
 #include "abCalcExprInt.h"
-#include "abCalcExprReal.h"
+#include "abCalcExpReal.h"
 #include "abCalcMode.h"
 #include "abCalcStack.h"
 #include "abCalcOp.h"

abCalcError.c

@@ -26,6 +26,8 @@ void abCalcErrorInit(void)
     gErrorStrings[abCalcBadArgValueError] = "Bad Argument Value";
     gErrorStrings[abCalcTooFewArgsError] = "Too Few Arguments";
     gErrorStrings[abCalcStackFullError] = "Stack Full";
+    gErrorStrings[abCalcInfiniteResultError] = "Infinite Result";
+    gErrorStrings[abCalcComplexResultError] = "Complex Result";
 }
 
 

abCalcError.h

@@ -16,6 +16,8 @@ typedef enum abCalcErrorType {
     abCalcBadArgValueError,
     abCalcTooFewArgsError,
     abCalcStackFullError,
+    abCalcInfiniteResultError,
+    abCalcComplexResultError,
 
     abCalcErrorTypeMax
 } abCalcErrorType;

abCalcExpReal.c

@@ -1,5 +1,5 @@
 /* 
-    abCalcExprReal.c
+    abCalcExpReal.c
         By: Jeremy Rand
  */
 

abCalcExpReal.h

@@ -1,11 +1,11 @@
 /* 
-    abCalcExprReal.h
+    abCalcExpReal.h
         By: Jeremy Rand
  */
 
 
-#ifndef ABCALCEXPRREAL_H
-#define ABCALCEXPRREAL_H
+#ifndef ABCALCEXPREAL_H
+#define ABCALCEXPREAL_H
 
 
 void abCalcExprRealInit(void);

abCalcOp.c

@@ -13,6 +13,14 @@
 #include "abCalcStack.h"
 
 #include "abCalcOpAdd.h"
+#include "abCalcOpSubtr.h"
+#include "abCalcOpMult.h"
+#include "abCalcOpDiv.h"
+#include "abCalcOpPower.h"
+#include "abCalcOpAnd.h"
+#include "abCalcOpOr.h"
+#include "abCalcOpXor.h"
+#include "abCalcOpNot.h"
 
 
 #define AB_CALC_MAX_OPS 128
@@ -27,6 +35,14 @@ void abCalcOpInit(void)
     memset(gOps, 0, sizeof(gOps));
 
     abCalcOpAddInit();
+    abCalcOpSubtrInit();
+    abCalcOpMultInit();
+    abCalcOpDivInit();
+    abCalcOpPowerInit();
+    abCalcOpAndInit();
+    abCalcOpOrInit();
+    abCalcOpXorInit();
+    abCalcOpNotInit();
 }
 
 

abCalcOpAdd.c

@@ -49,16 +49,16 @@ void addExecute(void)
 
     if ((expr1Real) && (expr2Real)) {
         result.type = abCalcExprTypeReal;
-        result.u.real = expr1->u.real + expr2->u.real;
+        result.u.real = expr2->u.real + expr1->u.real;
     } else {
         result.type = abCalcExprTypeInt;
 
         if (expr1Real) {
-            result.u.integer = (abCalcIntType)expr1->u.real + expr2->u.integer;
+            result.u.integer = expr2->u.integer + (abCalcIntType)expr1->u.real;
         } else if (expr2Real) {
-            result.u.integer = expr1->u.integer + (abCalcIntType)expr2->u.real;
+            result.u.integer = (abCalcIntType)expr2->u.real + expr1->u.integer;
         } else {
-            result.u.integer = expr1->u.integer + expr2->u.integer;
+            result.u.integer = expr2->u.integer + expr1->u.integer;
         }
     }
 

abCalcOpAnd.c

@@ -0,0 +1,50 @@
+/* 
+    abCalcOpAnd.c
+        By: Jeremy Rand
+ */
+
+
+#include <stdio.h>
+
+#include "abCalcOpAnd.h"
+
+#include "abCalcOp.h"
+#include "abCalcError.h"
+#include "abCalcExpr.h"
+#include "abCalcStack.h"
+
+
+#define OP_NAME "AND"
+
+
+static void andExecute(void);
+
+
+void abCalcOpAndInit(void)
+{
+    abCalcOpRegister(OP_NAME, andExecute);
+}
+
+
+void andExecute(void)
+{
+    abCalcExpr result;
+    AB_CALC_OP_TWO_ARGS(OP_NAME);
+
+    if (expr1->type != abCalcExprTypeInt) {
+        abCalcRaiseError(abCalcBadArgTypeError, OP_NAME);
+        return;
+    }
+
+    if (expr2->type != abCalcExprTypeInt) {
+        abCalcRaiseError(abCalcBadArgTypeError, OP_NAME);
+        return;
+    }
+
+    result.type = abCalcExprTypeInt;
+    result.u.integer = expr2->u.integer & expr1->u.integer;
+
+    abCalcStackExprPop(NULL);
+    abCalcStackExprPop(NULL);
+    abCalcStackExprPush(&result);
+}

abCalcOpAnd.h

@@ -0,0 +1,14 @@
+/* 
+    abCalcOpAnd.h
+        By: Jeremy Rand
+ */
+
+
+#ifndef ABCALCOPAND_H
+#define ABCALCOPAND_H
+
+
+void abCalcOpAndInit(void);
+
+
+#endif

abCalcOpDiv.c

@@ -0,0 +1,77 @@
+/* 
+    abCalcOpDiv.c
+        By: Jeremy Rand
+ */
+
+
+#include <stdio.h>
+
+#include "abCalcOpDiv.h"
+
+#include "abCalcOp.h"
+#include "abCalcError.h"
+#include "abCalcExpr.h"
+#include "abCalcStack.h"
+
+
+#define OP_NAME "/"
+
+
+static void divExecute(void);
+
+
+void abCalcOpDivInit(void)
+{
+    abCalcOpRegister(OP_NAME, divExecute);
+}
+
+
+void divExecute(void)
+{
+    abCalcExpr result;
+    char expr1Real = 0;
+    char expr2Real = 0;
+    AB_CALC_OP_TWO_ARGS(OP_NAME);
+
+    if (expr1->type == abCalcExprTypeReal) {
+        expr1Real = 1;
+        if (expr1->u.real == 0.0) {
+            abCalcRaiseError(abCalcInfiniteResultError, OP_NAME);
+            return;
+        }
+    } else if (expr1->type == abCalcExprTypeInt) {
+        if (expr1->u.integer == 0l) {
+            abCalcRaiseError(abCalcInfiniteResultError, OP_NAME);
+            return;
+        }
+    } else {
+        abCalcRaiseError(abCalcBadArgTypeError, OP_NAME);
+        return;
+    }
+
+    if (expr2->type == abCalcExprTypeReal) {
+        expr2Real = 1;
+    } else if (expr2->type != abCalcExprTypeInt) {
+        abCalcRaiseError(abCalcBadArgTypeError, OP_NAME);
+        return;
+    }
+
+    if ((expr1Real) && (expr2Real)) {
+        result.type = abCalcExprTypeReal;
+        result.u.real = expr2->u.real / expr1->u.real;
+    } else {
+        result.type = abCalcExprTypeInt;
+
+        if (expr1Real) {
+            result.u.integer = expr2->u.integer / (abCalcIntType)expr1->u.real;
+        } else if (expr2Real) {
+            result.u.integer = (abCalcIntType)expr2->u.real / expr1->u.integer;
+        } else {
+            result.u.integer = expr2->u.integer / expr1->u.integer;
+        }
+    }
+
+    abCalcStackExprPop(NULL);
+    abCalcStackExprPop(NULL);
+    abCalcStackExprPush(&result);
+}

abCalcOpDiv.h

@@ -0,0 +1,14 @@
+/* 
+    abCalcOpDiv.h
+        By: Jeremy Rand
+ */
+
+
+#ifndef ABCALCOPDIV_H
+#define ABCALCOPDIV_H
+
+
+void abCalcOpDivInit(void);
+
+
+#endif

abCalcOpMult.c

@@ -0,0 +1,68 @@
+/* 
+    abCalcOpMult.c
+        By: Jeremy Rand
+ */
+
+
+#include <stdio.h>
+
+#include "abCalcOpMult.h"
+
+#include "abCalcOp.h"
+#include "abCalcError.h"
+#include "abCalcExpr.h"
+#include "abCalcStack.h"
+
+
+#define OP_NAME "*"
+
+
+static void multExecute(void);
+
+
+void abCalcOpMultInit(void)
+{
+    abCalcOpRegister(OP_NAME, multExecute);
+}
+
+
+void multExecute(void)
+{
+    abCalcExpr result;
+    char expr1Real = 0;
+    char expr2Real = 0;
+    AB_CALC_OP_TWO_ARGS(OP_NAME);
+
+    if (expr1->type == abCalcExprTypeReal) {
+        expr1Real = 1;
+    } else if (expr1->type != abCalcExprTypeInt) {
+        abCalcRaiseError(abCalcBadArgTypeError, OP_NAME);
+        return;
+    }
+
+    if (expr2->type == abCalcExprTypeReal) {
+        expr2Real = 1;
+    } else if (expr2->type != abCalcExprTypeInt) {
+        abCalcRaiseError(abCalcBadArgTypeError, OP_NAME);
+        return;
+    }
+
+    if ((expr1Real) && (expr2Real)) {
+        result.type = abCalcExprTypeReal;
+        result.u.real = expr2->u.real * expr1->u.real;
+    } else {
+        result.type = abCalcExprTypeInt;
+
+        if (expr1Real) {
+            result.u.integer = expr2->u.integer * (abCalcIntType)expr1->u.real;
+        } else if (expr2Real) {
+            result.u.integer = (abCalcIntType)expr2->u.real * expr1->u.integer;
+        } else {
+            result.u.integer = expr2->u.integer * expr1->u.integer;
+        }
+    }
+
+    abCalcStackExprPop(NULL);
+    abCalcStackExprPop(NULL);
+    abCalcStackExprPush(&result);
+}

abCalcOpMult.h

@@ -0,0 +1,14 @@
+/* 
+    abCalcOpMult.h
+        By: Jeremy Rand
+ */
+
+
+#ifndef ABCALCOPMULT_H
+#define ABCALCOPMULT_H
+
+
+void abCalcOpMultInit(void);
+
+
+#endif

abCalcOpNot.c

@@ -0,0 +1,45 @@
+/* 
+    abCalcOpNot.c
+        By: Jeremy Rand
+ */
+
+
+#include <stdio.h>
+
+#include "abCalcOpNot.h"
+
+#include "abCalcOp.h"
+#include "abCalcError.h"
+#include "abCalcExpr.h"
+#include "abCalcStack.h"
+
+
+#define OP_NAME "NOT"
+
+
+static void notExecute(void);
+
+
+void abCalcOpNotInit(void)
+{
+    abCalcOpRegister(OP_NAME, notExecute);
+}
+
+
+void notExecute(void)
+{
+    abCalcExpr result;
+    AB_CALC_OP_ONE_ARG(OP_NAME);
+
+    if (expr->type != abCalcExprTypeInt) {
+        abCalcRaiseError(abCalcBadArgTypeError, OP_NAME);
+        return;
+    }
+
+    result.type = abCalcExprTypeInt;
+    result.u.integer = ~(expr->u.integer);
+
+    abCalcStackExprPop(NULL);
+    abCalcStackExprPop(NULL);
+    abCalcStackExprPush(&result);
+}

abCalcOpNot.h

@@ -0,0 +1,14 @@
+/* 
+    abCalcOpNot.h
+        By: Jeremy Rand
+ */
+
+
+#ifndef ABCALCOPNOT_H
+#define ABCALCOPNOT_H
+
+
+void abCalcOpNotInit(void);
+
+
+#endif

abCalcOpOr.c

@@ -0,0 +1,50 @@
+/* 
+    abCalcOpOr.c
+        By: Jeremy Rand
+ */
+
+
+#include <stdio.h>
+
+#include "abCalcOpOr.h"
+
+#include "abCalcOp.h"
+#include "abCalcError.h"
+#include "abCalcExpr.h"
+#include "abCalcStack.h"
+
+
+#define OP_NAME "OR"
+
+
+static void orExecute(void);
+
+
+void abCalcOpOrInit(void)
+{
+    abCalcOpRegister(OP_NAME, orExecute);
+}
+
+
+void orExecute(void)
+{
+    abCalcExpr result;
+    AB_CALC_OP_TWO_ARGS(OP_NAME);
+
+    if (expr1->type != abCalcExprTypeInt) {
+        abCalcRaiseError(abCalcBadArgTypeError, OP_NAME);
+        return;
+    }
+
+    if (expr2->type != abCalcExprTypeInt) {
+        abCalcRaiseError(abCalcBadArgTypeError, OP_NAME);
+        return;
+    }
+
+    result.type = abCalcExprTypeInt;
+    result.u.integer = expr2->u.integer | expr1->u.integer;
+
+    abCalcStackExprPop(NULL);
+    abCalcStackExprPop(NULL);
+    abCalcStackExprPush(&result);
+}

abCalcOpOr.h

@@ -0,0 +1,14 @@
+/* 
+    abCalcOpOr.h
+        By: Jeremy Rand
+ */
+
+
+#ifndef ABCALCOPOR_H
+#define ABCALCOPOR_H
+
+
+void abCalcOpOrInit(void);
+
+
+#endif

abCalcOpPower.c

@@ -0,0 +1,72 @@
+/* 
+    abCalcOpPower.c
+        By: Jeremy Rand
+ */
+
+
+#include <math.h>
+#include <stdio.h>
+
+#include "abCalcOpPower.h"
+
+#include "abCalcOp.h"
+#include "abCalcError.h"
+#include "abCalcExpr.h"
+#include "abCalcStack.h"
+
+
+#define OP_NAME "^"
+
+
+static void powerExecute(void);
+
+
+void abCalcOpPowerInit(void)
+{
+    abCalcOpRegister(OP_NAME, powerExecute);
+}
+
+
+void powerExecute(void)
+{
+    abCalcExpr result;
+    double integral;
+    AB_CALC_OP_TWO_ARGS(OP_NAME);
+
+    if (expr1->type != abCalcExprTypeReal) {
+        abCalcRaiseError(abCalcBadArgTypeError, OP_NAME);
+        return;
+    }
+
+    if (expr2->type != abCalcExprTypeReal) {
+        abCalcRaiseError(abCalcBadArgTypeError, OP_NAME);
+        return;
+    }
+
+    result.type = abCalcExprTypeReal;
+
+	if (expr2->u.real == 0.0) {
+		if (expr1->u.real < 0.0) {
+            abCalcRaiseError(abCalcInfiniteResultError, OP_NAME);
+			return;
+		}
+		if (expr1->u.real == 0.0) {
+            result.u.real = 1.0;
+		} else {
+            result.u.real = 0.0;
+		}
+	} else {
+        if (expr2->u.real < 0.0) {
+            modf(expr1->u.real, &integral);
+            if (expr1->u.real != integral) {
+                abCalcRaiseError(abCalcComplexResultError, OP_NAME);
+                return;
+            }
+        }
+        result.u.real = pow(expr2->u.real, expr1->u.real);
+    }
+
+    abCalcStackExprPop(NULL);
+    abCalcStackExprPop(NULL);
+    abCalcStackExprPush(&result);
+}

abCalcOpPower.h

@@ -0,0 +1,14 @@
+/* 
+    abCalcOpPower.h
+        By: Jeremy Rand
+ */
+
+
+#ifndef ABCALCOPPOWER_H
+#define ABCALCOPPOWER_H
+
+
+void abCalcOpPowerInit(void);
+
+
+#endif

abCalcOpSubtr.c

@@ -0,0 +1,68 @@
+/* 
+    abCalcOpSubtr.c
+        By: Jeremy Rand
+ */
+
+
+#include <stdio.h>
+
+#include "abCalcOpSubtr.h"
+
+#include "abCalcOp.h"
+#include "abCalcError.h"
+#include "abCalcExpr.h"
+#include "abCalcStack.h"
+
+
+#define OP_NAME "-"
+
+
+static void subtrExecute(void);
+
+
+void abCalcOpSubtrInit(void)
+{
+    abCalcOpRegister(OP_NAME, subtrExecute);
+}
+
+
+void subtrExecute(void)
+{
+    abCalcExpr result;
+    char expr1Real = 0;
+    char expr2Real = 0;
+    AB_CALC_OP_TWO_ARGS(OP_NAME);
+
+    if (expr1->type == abCalcExprTypeReal) {
+        expr1Real = 1;
+    } else if (expr1->type != abCalcExprTypeInt) {
+        abCalcRaiseError(abCalcBadArgTypeError, OP_NAME);
+        return;
+    }
+
+    if (expr2->type == abCalcExprTypeReal) {
+        expr2Real = 1;
+    } else if (expr2->type != abCalcExprTypeInt) {
+        abCalcRaiseError(abCalcBadArgTypeError, OP_NAME);
+        return;
+    }
+
+    if ((expr1Real) && (expr2Real)) {
+        result.type = abCalcExprTypeReal;
+        result.u.real = expr2->u.real - expr1->u.real;
+    } else {
+        result.type = abCalcExprTypeInt;
+
+        if (expr1Real) {
+            result.u.integer = expr2->u.integer - (abCalcIntType)expr1->u.real;
+        } else if (expr2Real) {
+            result.u.integer = (abCalcIntType)expr2->u.real - expr1->u.integer;
+        } else {
+            result.u.integer = expr2->u.integer - expr2->u.integer;
+        }
+    }
+
+    abCalcStackExprPop(NULL);
+    abCalcStackExprPop(NULL);
+    abCalcStackExprPush(&result);
+}

abCalcOpSubtr.h

@@ -0,0 +1,14 @@
+/* 
+    abCalcOpSubtr.h
+        By: Jeremy Rand
+ */
+
+
+#ifndef ABCALCOPSUBTR_H
+#define ABCALCOPSUBTR_H
+
+
+void abCalcOpSubtrInit(void);
+
+
+#endif

abCalcOpXor.c

@@ -0,0 +1,50 @@
+/* 
+    abCalcOpXor.c
+        By: Jeremy Rand
+ */
+
+
+#include <stdio.h>
+
+#include "abCalcOpXor.h"
+
+#include "abCalcOp.h"
+#include "abCalcError.h"
+#include "abCalcExpr.h"
+#include "abCalcStack.h"
+
+
+#define OP_NAME "XOR"
+
+
+static void xorExecute(void);
+
+
+void abCalcOpXorInit(void)
+{
+    abCalcOpRegister(OP_NAME, xorExecute);
+}
+
+
+void xorExecute(void)
+{
+    abCalcExpr result;
+    AB_CALC_OP_TWO_ARGS(OP_NAME);
+
+    if (expr1->type != abCalcExprTypeInt) {
+        abCalcRaiseError(abCalcBadArgTypeError, OP_NAME);
+        return;
+    }
+
+    if (expr2->type != abCalcExprTypeInt) {
+        abCalcRaiseError(abCalcBadArgTypeError, OP_NAME);
+        return;
+    }
+
+    result.type = abCalcExprTypeInt;
+    result.u.integer = expr2->u.integer ^ expr1->u.integer;
+
+    abCalcStackExprPop(NULL);
+    abCalcStackExprPop(NULL);
+    abCalcStackExprPush(&result);
+}

abCalcOpXor.h

@@ -0,0 +1,14 @@
+/* 
+    abCalcOpXor.h
+        By: Jeremy Rand
+ */
+
+
+#ifndef ABCALCOPXOR_H
+#define ABCALCOPXOR_H
+
+
+void abCalcOpXorInit(void);
+
+
+#endif