Change NodeExpression to NodeRValue, NodeExpression.evaluate() to .get()

diff --git a/applesoft_basic.t b/applesoft_basic.t
index a8e5262..21dacb8 100644 (file)
--- a/applesoft_basic.t
+++ b/applesoft_basic.t
@@ -71,30 +71,30 @@ class NodeStatementHTab: NodeStatement;
 class NodeStatementVTab: NodeStatement;
 class NodeStatementGet: NodeStatement;
 class NodeStatementInput: NodeStatement;
-class NodeExpression: Node;
-class NodeExpressionOr: NodeExpression;
-class NodeExpressionAnd: NodeExpression;
-class NodeExpressionLT: NodeExpression;
-class NodeExpressionEqual: NodeExpression;
-class NodeExpressionGT: NodeExpression;
-class NodeExpressionGE: NodeExpression;
-class NodeExpressionLE: NodeExpression;
-class NodeExpressionNE: NodeExpression;
-class NodeExpressionAdd: NodeExpression;
-class NodeExpressionSubtract: NodeExpression;
-class NodeExpressionMultiply: NodeExpression;
-class NodeExpressionDivide: NodeExpression;
-class NodeExpressionPower: NodeExpression;
-class NodeExpressionSign: NodeExpression {
+class NodeRValue: Node;
+class NodeRValueOr: NodeRValue;
+class NodeRValueAnd: NodeRValue;
+class NodeRValueLT: NodeRValue;
+class NodeRValueEqual: NodeRValue;
+class NodeRValueGT: NodeRValue;
+class NodeRValueGE: NodeRValue;
+class NodeRValueLE: NodeRValue;
+class NodeRValueNE: NodeRValue;
+class NodeRValueAdd: NodeRValue;
+class NodeRValueSubtract: NodeRValue;
+class NodeRValueMultiply: NodeRValue;
+class NodeRValueDivide: NodeRValue;
+class NodeRValuePower: NodeRValue;
+class NodeRValueSign: NodeRValue {
   int sign;
 };
-class NodeExpressionNot: NodeExpression;
-class NodeExpressionIntLiteral: NodeExpression;
-class NodeExpressionFloatLiteral: NodeExpression;
-class NodeExpressionStrLiteral: NodeExpression;
-class NodeExpressionVariable: NodeExpression;
-class NodeExpressionStrDollar: NodeExpression;
-class NodeExpressionVal: NodeExpression;
+class NodeRValueNot: NodeRValue;
+class NodeRValueIntLiteral: NodeRValue;
+class NodeRValueFloatLiteral: NodeRValue;
+class NodeRValueStrLiteral: NodeRValue;
+class NodeRValueVariable: NodeRValue;
+class NodeRValueStrDollar: NodeRValue;
+class NodeRValueVal: NodeRValue;
 
 %%
 
@@ -237,16 +237,16 @@ def execute(self, context):
 def execute(self, context):
   name = self.children[0].str_value
   if name[-1] == '$':
-    value = self.children[1].evaluate_str(context)
+    value = self.children[1].get_str(context)
   else:
-    value = self.children[1].evaluate_float(context)
+    value = self.children[1].get_float(context)
     if name[-1] == '$':
       value = data_types.cint(value)
   context.find_variable(name).value = value
 @method(NodeStatementPrint)
 def execute(self, context):
   for i in self.children:
-    value = i.evaluate(context)
+    value = i.get(context)
     if isinstance(value, float):
       value = data_types.str_dollar(value)
     apple_io._print(value)
@@ -258,7 +258,7 @@ def execute(self, context):
   context.j = 1
 @method(NodeStatementIf)
 def execute(self, context):
-  value = self.children[0].evaluate(context)
+  value = self.children[0].get(context)
   if value == '' or value == 0.:
     context.i += 1
     context.j = 1
@@ -297,10 +297,10 @@ def execute(self, context):
     )
   variable = context.find_variable(name)
 
-  variable.value = self.children[1].evaluate_float(context)
-  end = self.children[2].evaluate_float(context)
+  variable.value = self.children[1].get_float(context)
+  end = self.children[2].get_float(context)
   step = (
-    self.children[3].evaluate_float(context)
+    self.children[3].get_float(context)
   if len(self.children) >= 4 else
     1.
   )
@@ -406,11 +406,11 @@ def execute(self, context):
   apple_io.flash()
 @method(NodeStatementHTab)
 def execute(self, context):
-  value = self.children[0].evaluate_float(context)
+  value = self.children[0].get_float(context)
   apple_io.htab(data_types.cint(value))
 @method(NodeStatementVTab)
 def execute(self, context):
-  value = self.children[0].evaluate_float(context)
+  value = self.children[0].get_float(context)
   apple_io.vtab(data_types.cint(value))
 @method(NodeStatementGet)
 def execute(self, context):
@@ -437,149 +437,149 @@ def execute(self, context):
   context.find_variable(name).value = value
 del execute
 
-@method(NodeExpression)
-def evaluate(self, context):
+@method(NodeRValue)
+def get(self, context):
   raise NotImplementedError()
-@method(NodeExpressionOr)
-def evaluate(self, context):
-  value0 = self.children[0].evaluate_float(context)
-  value1 = self.children[1].evaluate_float(context)
+@method(NodeRValueOr)
+def get(self, context):
+  value0 = self.children[0].get_float(context)
+  value1 = self.children[1].get_float(context)
   return float(value0 != 0. or value1 != 0.)
-@method(NodeExpressionAnd)
-def evaluate(self, context):
-  value0 = self.children[0].evaluate_float(context)
-  value1 = self.children[1].evaluate_float(context)
+@method(NodeRValueAnd)
+def get(self, context):
+  value0 = self.children[0].get_float(context)
+  value1 = self.children[1].get_float(context)
   return float(value0 != 0. and value1 != 0.)
-@method(NodeExpressionLT)
-def evaluate(self, context):
-  value0 = self.children[0].evaluate(context)
+@method(NodeRValueLT)
+def get(self, context):
+  value0 = self.children[0].get(context)
   value1 = (
-    self.children[1].evaluate_float(context)
+    self.children[1].get_float(context)
   if isinstance(value0, float) else
-    self.children[1].evaluate_str(context)
+    self.children[1].get_str(context)
   )
   return float(value0 < value1)
-@method(NodeExpressionEqual)
-def evaluate(self, context):
-  value0 = self.children[0].evaluate(context)
+@method(NodeRValueEqual)
+def get(self, context):
+  value0 = self.children[0].get(context)
   value1 = (
-    self.children[1].evaluate_float(context)
+    self.children[1].get_float(context)
   if isinstance(value0, float) else
-    self.children[1].evaluate_str(context)
+    self.children[1].get_str(context)
   )
   return float(value0 == value1)
-@method(NodeExpressionGT)
-def evaluate(self, context):
-  value0 = self.children[0].evaluate(context)
+@method(NodeRValueGT)
+def get(self, context):
+  value0 = self.children[0].get(context)
   value1 = (
-    self.children[1].evaluate_float(context)
+    self.children[1].get_float(context)
   if isinstance(value0, float) else
-    self.children[1].evaluate_str(context)
+    self.children[1].get_str(context)
   )
   return float(value0 > value1)
-@method(NodeExpressionGE)
-def evaluate(self, context):
-  value0 = self.children[0].evaluate(context)
+@method(NodeRValueGE)
+def get(self, context):
+  value0 = self.children[0].get(context)
   value1 = (
-    self.children[1].evaluate_float(context)
+    self.children[1].get_float(context)
   if isinstance(value0, float) else
-    self.children[1].evaluate_str(context)
+    self.children[1].get_str(context)
   )
   return float(value0 >= value1)
-@method(NodeExpressionLE)
-def evaluate(self, context):
-  value0 = self.children[0].evaluate(context)
+@method(NodeRValueLE)
+def get(self, context):
+  value0 = self.children[0].get(context)
   value1 = (
-    self.children[1].evaluate_float(context)
+    self.children[1].get_float(context)
   if isinstance(value0, float) else
-    self.children[1].evaluate_str(context)
+    self.children[1].get_str(context)
   )
   return float(value0 <= value1)
-@method(NodeExpressionNE)
-def evaluate(self, context):
-  value0 = self.children[0].evaluate(context)
+@method(NodeRValueNE)
+def get(self, context):
+  value0 = self.children[0].get(context)
   value1 = (
-    self.children[1].evaluate_float(context)
+    self.children[1].get_float(context)
   if isinstance(value0, float) else
-    self.children[1].evaluate_str(context)
+    self.children[1].get_str(context)
   )
   return float(value0 != value1)
-@method(NodeExpressionAdd)
-def evaluate(self, context):
-  value0 = self.children[0].evaluate(context)
+@method(NodeRValueAdd)
+def get(self, context):
+  value0 = self.children[0].get(context)
   value1 = (
-    self.children[1].evaluate_float(context)
+    self.children[1].get_float(context)
   if isinstance(value0, float) else
-    self.children[1].evaluate_str(context)
+    self.children[1].get_str(context)
   )
   return value0 + value1
-@method(NodeExpressionSubtract)
-def evaluate(self, context):
-  value0 = self.children[0].evaluate_float(context)
-  value1 = self.children[1].evaluate_float(context)
+@method(NodeRValueSubtract)
+def get(self, context):
+  value0 = self.children[0].get_float(context)
+  value1 = self.children[1].get_float(context)
   return value0 - value1
-@method(NodeExpressionMultiply)
-def evaluate(self, context):
-  value0 = self.children[0].evaluate_float(context)
-  value1 = self.children[1].evaluate_float(context)
+@method(NodeRValueMultiply)
+def get(self, context):
+  value0 = self.children[0].get_float(context)
+  value1 = self.children[1].get_float(context)
   return value0 * value1
-@method(NodeExpressionDivide)
-def evaluate(self, context):
-  value0 = self.children[0].evaluate_float(context)
-  value1 = self.children[1].evaluate_float(context)
+@method(NodeRValueDivide)
+def get(self, context):
+  value0 = self.children[0].get_float(context)
+  value1 = self.children[1].get_float(context)
   return value0 / value1
-@method(NodeExpressionPower)
-def evaluate(self, context):
-  value0 = self.children[0].evaluate_float(context)
-  value1 = self.children[1].evaluate_float(context)
+@method(NodeRValuePower)
+def get(self, context):
+  value0 = self.children[0].get_float(context)
+  value1 = self.children[1].get_float(context)
   return value0 ** value1
-@method(NodeExpressionSign)
-def evaluate(self, context):
-  value = self.children[0].evaluate_float(context)
+@method(NodeRValueSign)
+def get(self, context):
+  value = self.children[0].get_float(context)
   return self.sign * value
-@method(NodeExpressionNot)
-def evaluate(self, context):
-  value = self.children[0].evaluate_float(context)
+@method(NodeRValueNot)
+def get(self, context):
+  value = self.children[0].get_float(context)
   return float(value == 0.)
-@method(NodeExpressionIntLiteral)
-def evaluate(self, context):
+@method(NodeRValueIntLiteral)
+def get(self, context):
   return float(self.children[0].int_value)
-@method(NodeExpressionFloatLiteral)
-def evaluate(self, context):
+@method(NodeRValueFloatLiteral)
+def get(self, context):
   return self.children[0].float_value
-@method(NodeExpressionStrLiteral)
-def evaluate(self, context):
+@method(NodeRValueStrLiteral)
+def get(self, context):
   return self.children[0].text[0]
-@method(NodeExpressionVariable)
-def evaluate(self, context):
+@method(NodeRValueVariable)
+def get(self, context):
   name = self.children[0].str_value
   return context.find_variable(name).value
-@method(NodeExpressionStrDollar)
-def evaluate(self, context):
-  value = self.children[0].evaluate_float(context)
+@method(NodeRValueStrDollar)
+def get(self, context):
+  value = self.children[0].get_float(context)
   return data_types.str_dollar(value)
-@method(NodeExpressionVal)
-def evaluate(self, context):
-  value = self.children[0].evaluate_str(context)
+@method(NodeRValueVal)
+def get(self, context):
+  value = self.children[0].get_str(context)
   return data_types.val(value)
-del evaluate
+del get
 
-@method(NodeExpression)
-def evaluate_float(self, context):
-  value = self.evaluate(context)
+@method(NodeRValue)
+def get_float(self, context):
+  value = self.get(context)
   if not isinstance(value, float):
     raise Exception(
       f'?TYPE MISMATCH ERROR IN {context.line_number():d}'
     )
   return value
-del evaluate_float
+del get_float
 
-@method(NodeExpression)
-def evaluate_str(self, context):
-  value = self.evaluate(context)
+@method(NodeRValue)
+def get_str(self, context):
+  value = self.get(context)
   if not isinstance(value, str):
     raise Exception(
       f'?TYPE MISMATCH ERROR IN {context.line_number():d}'
     )
   return value
-del evaluate_str
+del get_str

diff --git a/applesoft_basic.y b/applesoft_basic.y
index 5e04f93..73c1052 100644 (file)
--- a/applesoft_basic.y
+++ b/applesoft_basic.y
@@ -204,29 +204,29 @@ data_item
   ;
 
 expression
-  : %space (?E{t_def.NodeExpressionOr}expression KEYWORD_OR expression)
-  | %space (?E{t_def.NodeExpressionAnd}expression KEYWORD_AND expression)
-  | %space (?E{t_def.NodeExpressionLT}expression '<' expression)
-  | %space (?E{t_def.NodeExpressionEqual}expression '=' expression)
-  | %space (?E{t_def.NodeExpressionGT}expression '>' expression)
-  | %space (?E{t_def.NodeExpressionGE}expression OPERATOR_GE expression)
-  | %space (?E{t_def.NodeExpressionLE}expression OPERATOR_LE expression)
-  | %space (?E{t_def.NodeExpressionNE}expression OPERATOR_NE expression)
-  | %space (?E{t_def.NodeExpressionAdd}expression '+' expression)
-  | %space (?E{t_def.NodeExpressionSubtract}expression '-' expression)
-  | %space (?E{t_def.NodeExpressionMultiply}expression '*' expression)
-  | %space (?E{t_def.NodeExpressionDivide}expression '/' expression)
-  | %space (?E{t_def.NodeExpressionPower}expression '^' expression)
-  | %space (?E{t_def.NodeExpressionSign, sign = -1}'-' expression) %prec UNARY
-  | %space (?E{t_def.NodeExpressionSign, sign = 1}'+' expression) %prec UNARY
-  | %space (?E{t_def.NodeExpressionNot}KEYWORD_NOT expression)
+  : %space (?E{t_def.NodeRValueOr}expression KEYWORD_OR expression)
+  | %space (?E{t_def.NodeRValueAnd}expression KEYWORD_AND expression)
+  | %space (?E{t_def.NodeRValueLT}expression '<' expression)
+  | %space (?E{t_def.NodeRValueEqual}expression '=' expression)
+  | %space (?E{t_def.NodeRValueGT}expression '>' expression)
+  | %space (?E{t_def.NodeRValueGE}expression OPERATOR_GE expression)
+  | %space (?E{t_def.NodeRValueLE}expression OPERATOR_LE expression)
+  | %space (?E{t_def.NodeRValueNE}expression OPERATOR_NE expression)
+  | %space (?E{t_def.NodeRValueAdd}expression '+' expression)
+  | %space (?E{t_def.NodeRValueSubtract}expression '-' expression)
+  | %space (?E{t_def.NodeRValueMultiply}expression '*' expression)
+  | %space (?E{t_def.NodeRValueDivide}expression '/' expression)
+  | %space (?E{t_def.NodeRValuePower}expression '^' expression)
+  | %space (?E{t_def.NodeRValueSign, sign = -1}'-' expression) %prec UNARY
+  | %space (?E{t_def.NodeRValueSign, sign = 1}'+' expression) %prec UNARY
+  | %space (?E{t_def.NodeRValueNot}KEYWORD_NOT expression)
   | '(' expression ')'
-  | %space (?E{t_def.NodeExpressionIntLiteral}INT_LITERAL)
-  | %space (?E{t_def.NodeExpressionFloatLiteral}FLOAT_LITERAL)
-  | %space (?E{t_def.NodeExpressionStrLiteral}STR_LITERAL)
-  | %space (?E{t_def.NodeExpressionVariable}VARIABLE)
-  | %space (?E{t_def.NodeExpressionStrDollar}KEYWORD_STR_DOLLAR '(' expression ')')
-  | %space (?E{t_def.NodeExpressionVal}KEYWORD_VAL '(' expression ')')
+  | %space (?E{t_def.NodeRValueIntLiteral}INT_LITERAL)
+  | %space (?E{t_def.NodeRValueFloatLiteral}FLOAT_LITERAL)
+  | %space (?E{t_def.NodeRValueStrLiteral}STR_LITERAL)
+  | %space (?E{t_def.NodeRValueVariable}VARIABLE)
+  | %space (?E{t_def.NodeRValueStrDollar}KEYWORD_STR_DOLLAR '(' expression ')')
+  | %space (?E{t_def.NodeRValueVal}KEYWORD_VAL '(' expression ')')
   ;
 %%