Apparently Windows does not handle 'long' the same as Unix.

src/Evaluator/EvalValues/EvalValue.cpp

@@ -37,7 +37,7 @@ namespace Porygon::Evaluation {
     }
 
 
-    EvalValue *CreateIntegerEvalValue(long l) {
+    EvalValue *CreateIntegerEvalValue(int64_t l) {
         return new IntegerEvalValue(l);
     }
 

src/Evaluator/EvalValues/EvalValue.hpp

@@ -37,7 +37,7 @@ namespace Porygon::Evaluation {
         virtual EvalValue* Clone() const = 0;
 
         [[nodiscard]]
-        virtual long EvaluateInteger() const {
+        virtual int64_t EvaluateInteger() const {
             throw EvaluationException("Can't evaluate this EvalValue as integer.");
         }
 

src/Evaluator/EvalValues/EvalValueHelper.hpp

@@ -9,10 +9,10 @@ namespace Porygon::Evaluation{
     class EvalValueHelper{
     public:
         inline static EvalValue* Create(unsigned char i){
-            return new IntegerEvalValue((long)i);
+            return new IntegerEvalValue((int64_t )i);
         }
         inline static EvalValue* Create(signed char i){
-            return new IntegerEvalValue((long)i);
+            return new IntegerEvalValue((int64_t )i);
         }
         inline static EvalValue* Create(short int i){
             return new IntegerEvalValue(i);
@@ -26,10 +26,10 @@ namespace Porygon::Evaluation{
         inline static EvalValue* Create(unsigned int i){
             return new IntegerEvalValue(i);
         }
-        inline static EvalValue* Create(signed long l){
+        inline static EvalValue* Create(int64_t l){
             return new IntegerEvalValue(l);
         }
-        inline static EvalValue* Create(unsigned long l){
+        inline static EvalValue* Create(uint64_t l){
             return new IntegerEvalValue(l);
         }
 

src/Evaluator/EvalValues/NumericEvalValue.hpp

@@ -10,7 +10,7 @@ namespace Porygon::Evaluation {
     class NumericEvalValue : public EvalValue {
 
         [[nodiscard]]
-        virtual long GetIntegerValue() const = 0;
+        virtual int64_t GetIntegerValue() const = 0;
 
         [[nodiscard]]
         virtual double GetFloatValue() const = 0;
@@ -44,10 +44,10 @@ namespace Porygon::Evaluation {
     };
 
     class IntegerEvalValue : public NumericEvalValue {
-        const long _value;
+        const int64_t _value;
 
         [[nodiscard]]
-        long GetIntegerValue() const final { return _value; }
+        int64_t GetIntegerValue() const final { return _value; }
 
         [[nodiscard]]
         double GetFloatValue() const final {
@@ -55,7 +55,7 @@ namespace Porygon::Evaluation {
         }
 
     public:
-        explicit IntegerEvalValue(long value) : _value(value) {
+        explicit IntegerEvalValue(int64_t  value) : _value(value) {
         }
 
         [[nodiscard]]
@@ -64,7 +64,7 @@ namespace Porygon::Evaluation {
         }
 
         [[nodiscard]]
-        inline long EvaluateInteger() const final {
+        inline int64_t EvaluateInteger() const final {
             return _value;
         }
 
@@ -85,7 +85,7 @@ namespace Porygon::Evaluation {
 
         [[nodiscard]]
         inline std::size_t GetHashCode() const final {
-            return std::hash<long>{}(_value);
+            return std::hash<int64_t >{}(_value);
         }
 
         [[nodiscard]]
@@ -104,8 +104,8 @@ namespace Porygon::Evaluation {
         const double _value;
 
         [[nodiscard]]
-        inline long GetIntegerValue() const final {
-            throw EvaluationException("Attempting to retrieve float from int eval value.");
+        inline int64_t GetIntegerValue() const final {
+            return _value;
         }
 
         [[nodiscard]]
@@ -128,8 +128,8 @@ namespace Porygon::Evaluation {
         }
 
         [[nodiscard]]
-        inline long EvaluateInteger() const final {
-            return static_cast<long>(_value);
+        inline int64_t EvaluateInteger() const final {
+            return static_cast<int64_t >(_value);
         }
 
         [[nodiscard]]
@@ -168,13 +168,13 @@ namespace Porygon::Evaluation {
                 auto rightVal = right->EvaluateInteger();
                 switch (operation) {
                     case Binder::BoundBinaryOperation::Addition:
-                        return new IntegerEvalValue((long) _value + rightVal);
+                        return new IntegerEvalValue((int64_t ) _value + rightVal);
                     case Binder::BoundBinaryOperation::Subtraction:
-                        return new IntegerEvalValue((long) _value - rightVal);
+                        return new IntegerEvalValue((int64_t ) _value - rightVal);
                     case Binder::BoundBinaryOperation::Multiplication:
-                        return new IntegerEvalValue((long) _value * rightVal);
+                        return new IntegerEvalValue((int64_t ) _value * rightVal);
                     case Binder::BoundBinaryOperation::Division:
-                        return new IntegerEvalValue((long) _value / rightVal);
+                        return new IntegerEvalValue((int64_t ) _value / rightVal);
                     case Binder::BoundBinaryOperation::LessThan:
                         return new BooleanEvalValue(_value < rightVal);
                     case Binder::BoundBinaryOperation::LessThanEquals: