Class ArithmeticExpression

java.lang.Object
simula.compiler.syntaxClass.SyntaxClass
simula.compiler.syntaxClass.expression.Expression
simula.compiler.syntaxClass.expression.ArithmeticExpression
public final class ArithmeticExpression extends Expression

Arithmetic expressions

Simula Standard:  3.5 Arithmetic expressions.

   arithmetic-expression
       =  simple-arithmetic-expression
       |  if-clause  simple-arithmetic-expression
          else  arithmetic-expression

   simple-arithmetic-expression
       =  [ + | - ]  term  {  ( + | - )  term }

   term
       =  factor  {  ( * | / | // )  factor }

   factor
       =  primary  { **  primary }

   primary
       =  unsigned-number
       |  variable
       |  function-designator
       |  "("  arithmetic-expression  ")"

An arithmetic expression is a rule for computing a numerical value. In the case of simple arithmetic expressions this value is obtained by executing the indicated arithmetic operations on the actual numerical values of the primaries of the expression, as explained in detail in 3.5.1 below. The value of a primary is obvious in the case of numbers. For variables it is the current value (assigned last in the dynamic sense), and for function designators it is the value arising from the computing rules defining the procedure when applied to the current values of the procedure parameters given in the expression. Finally, for arithmetic expressions enclosed by parentheses the value must through a recursive analysis be expressed in terms of the values of primaries of the other three kinds.

In the more general arithmetic expressions, which include if-clauses, one out of several simple arithmetic expressions is selected on the basis of the actual values of the Boolean expressions (see 3.2). This selection is made as follows: The Boolean expressions of the if-clauses are evaluated one by one in sequence from left to right until one having the value true is found. The value of the arithmetic expression is then the value of the first arithmetic expression following this Boolean (the longest arithmetic expression found in this position is understood). If none of the Boolean expressions has the value true, then the value of the arithmetic expression is the value of the expression following the final else.

In evaluating an arithmetic expression, all primaries within that expression are evaluated with the following exceptions:

 - Primaries that occur within any expression governed by an if-clause but not selected by it.

 - Primaries that occur within a Boolean expression.
   1) after the operator or else when the evaluation of a preceding Boolean tertiary results in false, or
   2) after the operator and then when the evaluation of a preceding equivalence results in false.
 
 - Primaries that occur after a function designator, and the evaluation of
   the function terminates with a goto-statement. In this case the evaluation of
   the arithmetic expression is abandoned.

Primaries are always evaluated in strict lexical order.

NOTE: The implementation of EXP '**' deviates from the definition in Simula Standard. It is always evaluated in long real and the result is converted to the appropriate type.

Link to GitHub: Source File.

Author:
Simula Standard, Øystein Myhre Andersen

  • Field Details

    • lhs

      private Expression lhs
      The left hand side

    • opr

      private int opr
      The arithmetic operation

    • rhs

      private Expression rhs
      The right hand side

  • Constructor Details

    • ArithmeticExpression

      private ArithmeticExpression(Expression lhs, int opr, Expression rhs)
      Create a new ArithmeticExpression.
      Parameters:
      lhs - left hand side
      opr - arithmetic operation
      rhs - right hand side

    • ArithmeticExpression

      private ArithmeticExpression()
      Default constructor used by Attribute File I/O

  • Method Details

    • create

      static Expression create(Expression lhs, int opr, Expression rhs)
      Create a new ArithmeticExpression.
      Parameters:
      lhs - the left hand side
      opr - the arithmetic operation
      rhs - the right hand side
      Returns:
      the newly created ArithmeticExpression

    • evaluate

      public Expression evaluate()
      Description copied from class: Expression
      Try to Compile-time Evaluate this expression
      Overrides:
      evaluate in class Expression
      Returns:
      the resulting evaluated expression

    • doChecking

      public void doChecking()
      Description copied from class: SyntaxClass

      Perform semantic checking.

      This must be redefined in every subclass.

      Overrides:
      doChecking in class SyntaxClass

    • maybeStatement

      public boolean maybeStatement()
      Description copied from class: Expression
      Returns true if this expression may be used as a statement.
      Specified by:
      maybeStatement in class Expression
      Returns:
      true if this expression may be used as a statement

    • buildEvaluation

      public void buildEvaluation(Expression rightPart, CodeBuilder codeBuilder)
      Description copied from class: Expression
      ClassFile coding utility: Build Evaluation Code.
      Specified by:
      buildEvaluation in class Expression
      Parameters:
      rightPart - expression
      codeBuilder - the codeBuilder used.

    • toJavaCode

      public String toJavaCode()
      Description copied from class: SyntaxClass
      Generate Java code for this Syntax Class.
      Overrides:
      toJavaCode in class SyntaxClass
      Returns:
      Java code

    • toString

      public String toString()
      Overrides:
      toString in class Expression

    • writeObject

      public void writeObject(AttributeOutputStream oupt) throws IOException
      Description copied from class: SyntaxClass
      Write a SyntaxClass object to a AttributeOutputStream.
      Overrides:
      writeObject in class SyntaxClass
      Parameters:
      oupt - the AttributeOutputStream to write to.
      Throws:
      IOException - if something went wrong.

    • readObject

      public static ArithmeticExpression readObject(AttributeInputStream inpt) throws IOException
      Read and return an ArithmeticExpression.
      Parameters:
      inpt - the AttributeInputStream to read from
      Returns:
      the ArithmeticExpression read from the stream.
      Throws:
      IOException - if something went wrong.