Types

Semantics

type Value
  = oneof {
           undefinedValue;
           nullValue;
           booleanValue: Boolean;
           doubleValue: Double;
           stringValue: String;
           objectValue: Object}

type ObjectOrNull = oneof {nullObjectOrNull; objectObjectOrNull: Object}

type Object
  = tuple {
           properties: Property[];
           typeofName: String;
           prototype: ObjectOrNull;
           get: PropName  ValueOrException;
           put: PropName  Value  VoidOrException;
           delete: PropName  BooleanOrException;
           call: ObjectOrNull  Value[]  ReferenceOrException;
           construct: Value[]  ObjectOrException;
           defaultValue: DefaultValueHint  ValueOrException}

type DefaultValueHint = oneof {noHint; numberHint; stringHint}

type Property
  = tuple {
           name: String;
           readOnly: Boolean;
           enumerable: Boolean;
           permanent: Boolean;
           value: Value}

type PropName = String

type Place = tuple {base: Object; property: PropName}

type Reference
  = oneof {valueReference: Value; placeReference: Place; virtualReference: PropName}

type IntegerOrException = oneof {normal: Integer; abrupt: Exception}

type VoidOrException = oneof {normal; abrupt: Exception}

type BooleanOrException = oneof {normal: Boolean; abrupt: Exception}

type DoubleOrException = oneof {normal: Double; abrupt: Exception}

type StringOrException = oneof {normal: String; abrupt: Exception}

type ObjectOrException = oneof {normal: Object; abrupt: Exception}

type ValueOrException = oneof {normal: Value; abrupt: Exception}

type ReferenceOrException = oneof {normal: Reference; abrupt: Exception}

type ValueListOrException = oneof {normal: Value[]; abrupt: Exception}

Helper Functions

Semantics

objectOrNullToValue(o: ObjectOrNull) : Value
  = case o of
        nullObjectOrNull: nullValue;
        objectObjectOrNull(obj: Object): objectValue obj
        end

undefinedResult : ValueOrException = normal undefinedValue

nullResult : ValueOrException = normal nullValue

booleanResult(b: Boolean) : ValueOrException = normal booleanValue b

doubleResult(d: Double) : ValueOrException = normal doubleValue d

integerResult(i: Integer) : ValueOrException = doubleResult(rationalToDouble(i))

stringResult(s: String) : ValueOrException = normal stringValue s

objectResult(o: Object) : ValueOrException = normal objectValue o

Exceptions

Semantics

type Exception = oneof {exception: Value; error: Error}

type Error
  = oneof {
           coerceToPrimitiveError;
           coerceToObjectError;
           getValueError;
           putValueError;
           deleteError}

makeError(err: Error) : Exception = error err

Objects

Conversions

Semantics

referenceGetValue(rv: Reference) : ValueOrException
  = case rv of
        valueReference(v: Value): normal v;
        placeReference(r: Place): r.base.get(r.property);
        virtualReference: abrupt_{ValueOrException} makeError(getValueError)
        end

referencePutValue(rv: Reference, v: Value) : VoidOrException
  = case rv of
        valueReference: abrupt_{VoidOrException} makeError(putValueError);
        placeReference(r: Place): r.base.put(r.property, v);
        virtualReference: 
        end

Coercions

Semantics

coerceToBoolean(v: Value) : Boolean
  = case v of
        undefinedValue, nullValue: false;
        booleanValue(b: Boolean): b;
        doubleValue(d: Double): not (doubleIsZero(d) or doubleIsNan(d));
        stringValue(s: String): length(s)  0;
        objectValue: true
        end

coerceBooleanToDouble(b: Boolean) : Double
  = if b
     then 1.0
     else 0.0

coerceToDouble(v: Value) : DoubleOrException
  = case v of
        undefinedValue: normal NaN;
        nullValue: normal 0.0;
        booleanValue(b: Boolean): normal coerceBooleanToDouble(b);
        doubleValue(d: Double): normal d;
        stringValue: ;
        objectValue: 
        end

coerceToUint32(v: Value) : IntegerOrException
  = letexc d: Double = coerceToDouble(v)
     in normal doubleToUint32(d)

coerceToInt32(v: Value) : IntegerOrException
  = letexc d: Double = coerceToDouble(v)
     in normal uint32ToInt32(doubleToUint32(d))

uint32ToInt32(ui: Integer) : Integer
  = if ui < 2147483648
     then ui
     else ui - 4294967296

coerceToString(v: Value) : StringOrException
  = case v of
        undefinedValue: normal “undefined”;
        nullValue: normal “null”;
        booleanValue(b: Boolean):
              if b
              then normal “true”
              else normal “false”;
        doubleValue: ;
        stringValue(s: String): normal s;
        objectValue: 
        end

coerceToPrimitive(v: Value, hint: DefaultValueHint) : ValueOrException
  = case v of
        undefinedValue, nullValue, booleanValue, doubleValue, stringValue: normal v;
        objectValue(o: Object):
              letexc pv: Value = o.defaultValue(hint)
              in case pv of
                     undefinedValue, nullValue, booleanValue, doubleValue, stringValue:
                           normal pv;
                     objectValue: abrupt_{ValueOrException} makeError(coerceToPrimitiveError)
                     end
        end

coerceToObject(v: Value) : ObjectOrException
  = case v of
        undefinedValue, nullValue: abrupt_{ObjectOrException} makeError(coerceToObjectError);
        booleanValue: ;
        doubleValue: ;
        stringValue: ;
        objectValue(o: Object): normal o
        end

Environments

Semantics

type Env = tuple {this: ObjectOrNull}

lookupIdentifier(e: Env, id: String) : ReferenceOrException = 

Terminal Actions

Semantics

action EvalIdentifier[Identifier] : String

action EvalNumber[Number] : Double

action EvalString[String] : String

Primary Expressions

Syntax

Semantics

action Eval[PrimaryRvalue] : Env  ValueOrException

Eval[PrimaryRvalue  this](e: Env) = normal objectOrNullToValue(e.this)

Eval[PrimaryRvalue  null](e: Env) = nullResult

Eval[PrimaryRvalue  true](e: Env) = booleanResult(true)

Eval[PrimaryRvalue  false](e: Env) = booleanResult(false)

Eval[PrimaryRvalue  Number](e: Env) = doubleResult(EvalNumber[Number])

Eval[PrimaryRvalue  String](e: Env) = stringResult(EvalString[String])

Eval[PrimaryRvalue  ( CommaExpression^noLValue )] = Eval[CommaExpression^noLValue]

action Eval[PrimaryLvalue] : Env  ReferenceOrException

Eval[PrimaryLvalue  Identifier](e: Env)
  = lookupIdentifier(e, EvalIdentifier[Identifier])

Eval[PrimaryLvalue  ( Lvalue )] = Eval[Lvalue]

Left-Side Expressions

Syntax

Semantics

action Eval[MemberLvalue^{MemberExprKind}] : Env  ReferenceOrException

Eval[MemberLvalue^noCall  PrimaryLvalue] = Eval[PrimaryLvalue]

Eval[MemberLvalue^call  Lvalue Arguments](e: Env)
  = letexc functionReference: Reference = Eval[Lvalue](e)
     in letexc function: Value = referenceGetValue(functionReference)
     in letexc arguments: Value[] = Eval[Arguments](e)
     in let this: ObjectOrNull
             = case functionReference of
                   valueReference, virtualReference: nullObjectOrNull;
                   placeReference(p: Place): objectObjectOrNull p.base
                   end
     in callObject(function, this, arguments)

Eval[MemberLvalue^call  MemberExpression^{noCall,noLValue} Arguments](e: Env)
  = letexc function: Value = Eval[MemberExpression^{noCall,noLValue}](e)
     in letexc arguments: Value[] = Eval[Arguments](e)
     in callObject(function, nullObjectOrNull, arguments)

Eval[MemberLvalue^{MemberExprKind}  MemberExpression^{MemberExprKind,anyValue} [ Expression ]]
            (e: Env)
  = letexc container: Value = Eval[MemberExpression^{MemberExprKind,anyValue}](e)
     in letexc property: Value = Eval[Expression](e)
     in readProperty(container, property)

Eval[MemberLvalue^{MemberExprKind}  MemberExpression^{MemberExprKind,anyValue} . Identifier]
            (e: Env)
  = letexc container: Value = Eval[MemberExpression^{MemberExprKind,anyValue}](e)
     in readProperty(container, stringValue EvalIdentifier[Identifier])

action Eval[MemberExpression^{MemberExprKind,ExprKind}] : Env  ValueOrException

Eval[MemberExpression^{noCall,ExprKind}  PrimaryRvalue] = Eval[PrimaryRvalue]

Eval[MemberExpression^{MemberExprKind,anyValue}  MemberLvalue^{MemberExprKind}](e: Env)
  = letexc ref: Reference = Eval[MemberLvalue^{MemberExprKind}](e)
     in referenceGetValue(ref)

Eval[MemberExpression^{noCall,ExprKind}  new MemberExpression^{noCall,anyValue}₁ Arguments]
            (e: Env)
  = letexc constructor: Value = Eval[MemberExpression^{noCall,anyValue}₁](e)
     in letexc arguments: Value[] = Eval[Arguments](e)
     in constructObject(constructor, arguments)

action Eval[NewExpression^ExprKind] : Env  ValueOrException

Eval[NewExpression^ExprKind  MemberExpression^{noCall,ExprKind}]
  = Eval[MemberExpression^{noCall,ExprKind}]

Eval[NewExpression^ExprKind  new NewExpression^anyValue₁](e: Env)
  = letexc constructor: Value = Eval[NewExpression^anyValue₁](e)
     in constructObject(constructor, []_Value)

action Eval[Arguments] : Env  ValueListOrException

Eval[Arguments  ( )](e: Env) = normal []_Value

Eval[Arguments  ( ArgumentList )] = Eval[ArgumentList]

action Eval[ArgumentList] : Env  ValueListOrException

Eval[ArgumentList  AssignmentExpression^anyValue](e: Env)
  = letexc arg: Value = Eval[AssignmentExpression^anyValue](e)
     in normal [arg]

Eval[ArgumentList  ArgumentList₁ , AssignmentExpression^anyValue](e: Env)
  = letexc args: Value[] = Eval[ArgumentList₁](e)
     in letexc arg: Value = Eval[AssignmentExpression^anyValue](e)
     in normal (args  [arg])

action Eval[Lvalue] : Env  ReferenceOrException

Eval[Lvalue  MemberLvalue^call] = Eval[MemberLvalue^call]

Eval[Lvalue  MemberLvalue^noCall] = Eval[MemberLvalue^noCall]

readProperty(container: Value, property: Value) : ReferenceOrException
  = letexc obj: Object = coerceToObject(container)
     in letexc name: PropName = coerceToString(property)
     in normal placeReference obj, name_Place

callObject(function: Value, this: ObjectOrNull, arguments: Value[]) : ReferenceOrException
  = case function of
        undefinedValue, nullValue, booleanValue, doubleValue, stringValue:
              abrupt_{ReferenceOrException} makeError(coerceToObjectError);
        objectValue(o: Object): o.call(this, arguments)
        end

constructObject(constructor: Value, arguments: Value[]) : ValueOrException
  = case constructor of
        undefinedValue, nullValue, booleanValue, doubleValue, stringValue:
              abrupt_{ValueOrException} makeError(coerceToObjectError);
        objectValue(o: Object):
              letexc res: Object = o.construct(arguments)
              in objectResult(res)
        end

Postfix Expressions

Syntax

Semantics

action Eval[PostfixExpression^ExprKind] : Env  ValueOrException

Eval[PostfixExpression^ExprKind  NewExpression^ExprKind] = Eval[NewExpression^ExprKind]

Eval[PostfixExpression^anyValue  MemberExpression^{call,anyValue}]
  = Eval[MemberExpression^{call,anyValue}]

Eval[PostfixExpression^ExprKind  Lvalue ++](e: Env)
  = letexc operandReference: Reference = Eval[Lvalue](e)
     in letexc operandValue: Value = referenceGetValue(operandReference)
     in letexc operand: Double = coerceToDouble(operandValue)
     in letexc u: Void
                  = referencePutValue(operandReference, doubleValue doubleAdd(operand, 1.0))
     in doubleResult(operand)

Eval[PostfixExpression^ExprKind  Lvalue --](e: Env)
  = letexc operandReference: Reference = Eval[Lvalue](e)
     in letexc operandValue: Value = referenceGetValue(operandReference)
     in letexc operand: Double = coerceToDouble(operandValue)
     in letexc u: Void
                  = referencePutValue(operandReference, doubleValue doubleSubtract(operand, 1.0))
     in doubleResult(operand)

Unary Operators

Syntax

Semantics

action Eval[UnaryExpression^ExprKind] : Env  ValueOrException

Eval[UnaryExpression^ExprKind  PostfixExpression^ExprKind]
  = Eval[PostfixExpression^ExprKind]

Eval[UnaryExpression^ExprKind  delete Lvalue](e: Env)
  = letexc rv: Reference = Eval[Lvalue](e)
     in case rv of
            valueReference: abrupt_{ValueOrException} makeError(deleteError);
            placeReference(r: Place):
                  letexc b: Boolean = r.base.delete(r.property)
                  in booleanResult(b);
            virtualReference: booleanResult(true)
            end

Eval[UnaryExpression^ExprKind  void UnaryExpression^anyValue₁](e: Env)
  = letexc operand: Value = Eval[UnaryExpression^anyValue₁](e)
     in undefinedResult

Eval[UnaryExpression^ExprKind  typeof Lvalue](e: Env)
  = letexc rv: Reference = Eval[Lvalue](e)
     in case rv of
            valueReference(v: Value): stringResult(valueTypeof(v));
            placeReference(r: Place):
                  letexc v: Value = r.base.get(r.property)
                  in stringResult(valueTypeof(v));
            virtualReference: stringResult(“undefined”)
            end

Eval[UnaryExpression^ExprKind  typeof UnaryExpression^noLValue₁](e: Env)
  = letexc v: Value = Eval[UnaryExpression^noLValue₁](e)
     in stringResult(valueTypeof(v))

Eval[UnaryExpression^ExprKind  ++ Lvalue](e: Env)
  = letexc operandReference: Reference = Eval[Lvalue](e)
     in letexc operandValue: Value = referenceGetValue(operandReference)
     in letexc operand: Double = coerceToDouble(operandValue)
     in let res: Double = doubleAdd(operand, 1.0)
     in letexc u: Void = referencePutValue(operandReference, doubleValue res)
     in doubleResult(res)

Eval[UnaryExpression^ExprKind  -- Lvalue](e: Env)
  = letexc operandReference: Reference = Eval[Lvalue](e)
     in letexc operandValue: Value = referenceGetValue(operandReference)
     in letexc operand: Double = coerceToDouble(operandValue)
     in let res: Double = doubleSubtract(operand, 1.0)
     in letexc u: Void = referencePutValue(operandReference, doubleValue res)
     in doubleResult(res)

Eval[UnaryExpression^ExprKind  + UnaryExpression^anyValue₁](e: Env)
  = letexc operandValue: Value = Eval[UnaryExpression^anyValue₁](e)
     in letexc operand: Double = coerceToDouble(operandValue)
     in doubleResult(operand)

Eval[UnaryExpression^ExprKind  - UnaryExpression^anyValue₁](e: Env)
  = letexc operandValue: Value = Eval[UnaryExpression^anyValue₁](e)
     in letexc operand: Double = coerceToDouble(operandValue)
     in doubleResult(doubleNegate(operand))

Eval[UnaryExpression^ExprKind  ~ UnaryExpression^anyValue₁](e: Env)
  = letexc operandValue: Value = Eval[UnaryExpression^anyValue₁](e)
     in letexc operand: Integer = coerceToInt32(operandValue)
     in integerResult(bitwiseXor(operand, -1))

Eval[UnaryExpression^ExprKind  ! UnaryExpression^anyValue₁](e: Env)
  = letexc operandValue: Value = Eval[UnaryExpression^anyValue₁](e)
     in booleanResult(not coerceToBoolean(operandValue))

valueTypeof(v: Value) : String
  = case v of
        undefinedValue: “undefined”;
        nullValue: “object”;
        booleanValue: “boolean”;
        doubleValue: “number”;
        stringValue: “string”;
        objectValue(o: Object): o.typeofName
        end

Multiplicative Operators

Syntax

Semantics

action Eval[MultiplicativeExpression^ExprKind] : Env  ValueOrException

Eval[MultiplicativeExpression^ExprKind  UnaryExpression^ExprKind]
  = Eval[UnaryExpression^ExprKind]

Eval[MultiplicativeExpression^ExprKind  MultiplicativeExpression^anyValue₁ * UnaryExpression^anyValue]
            (e: Env)
  = letexc leftValue: Value = Eval[MultiplicativeExpression^anyValue₁](e)
     in letexc rightValue: Value = Eval[UnaryExpression^anyValue](e)
     in applyBinaryDoubleOperator(doubleMultiply, leftValue, rightValue)

Eval[MultiplicativeExpression^ExprKind  MultiplicativeExpression^anyValue₁ / UnaryExpression^anyValue]
            (e: Env)
  = letexc leftValue: Value = Eval[MultiplicativeExpression^anyValue₁](e)
     in letexc rightValue: Value = Eval[UnaryExpression^anyValue](e)
     in applyBinaryDoubleOperator(doubleDivide, leftValue, rightValue)

Eval[MultiplicativeExpression^ExprKind  MultiplicativeExpression^anyValue₁ % UnaryExpression^anyValue]
            (e: Env)
  = letexc leftValue: Value = Eval[MultiplicativeExpression^anyValue₁](e)
     in letexc rightValue: Value = Eval[UnaryExpression^anyValue](e)
     in applyBinaryDoubleOperator(doubleRemainder, leftValue, rightValue)

applyBinaryDoubleOperator(operator: Double  Double  Double, leftValue: Value, rightValue: Value)
  : ValueOrException
  = letexc leftNumber: Double = coerceToDouble(leftValue)
     in letexc rightNumber: Double = coerceToDouble(rightValue)
     in doubleResult(operator(leftNumber, rightNumber))

Additive Operators

Syntax

Semantics

action Eval[AdditiveExpression^ExprKind] : Env  ValueOrException

Eval[AdditiveExpression^ExprKind  MultiplicativeExpression^ExprKind]
  = Eval[MultiplicativeExpression^ExprKind]

Eval[AdditiveExpression^ExprKind  AdditiveExpression^anyValue₁ + MultiplicativeExpression^anyValue]
            (e: Env)
  = letexc leftValue: Value = Eval[AdditiveExpression^anyValue₁](e)
     in letexc rightValue: Value = Eval[MultiplicativeExpression^anyValue](e)
     in letexc leftPrimitive: Value = coerceToPrimitive(leftValue, noHint)
     in letexc rightPrimitive: Value = coerceToPrimitive(rightValue, noHint)
     in if leftPrimitive is stringValue or rightPrimitive is stringValue
         then letexc leftString: String = coerceToString(leftPrimitive)
                in letexc rightString: String = coerceToString(rightPrimitive)
                in stringResult(leftString  rightString)
         else applyBinaryDoubleOperator(doubleAdd, leftPrimitive, rightPrimitive)

Eval[AdditiveExpression^ExprKind  AdditiveExpression^anyValue₁ - MultiplicativeExpression^anyValue]
            (e: Env)
  = letexc leftValue: Value = Eval[AdditiveExpression^anyValue₁](e)
     in letexc rightValue: Value = Eval[MultiplicativeExpression^anyValue](e)
     in applyBinaryDoubleOperator(doubleSubtract, leftValue, rightValue)

Bitwise Shift Operators

Syntax

Semantics

action Eval[ShiftExpression^ExprKind] : Env  ValueOrException

Eval[ShiftExpression^ExprKind  AdditiveExpression^ExprKind]
  = Eval[AdditiveExpression^ExprKind]

Eval[ShiftExpression^ExprKind  ShiftExpression^anyValue₁ << AdditiveExpression^anyValue]
            (e: Env)
  = letexc bitmapValue: Value = Eval[ShiftExpression^anyValue₁](e)
     in letexc countValue: Value = Eval[AdditiveExpression^anyValue](e)
     in letexc bitmap: Integer = coerceToUint32(bitmapValue)
     in letexc count: Integer = coerceToUint32(countValue)
     in integerResult(
             uint32ToInt32(bitwiseAnd(bitwiseShift(bitmap, bitwiseAnd(count, 31)), 4294967295)))

Eval[ShiftExpression^ExprKind  ShiftExpression^anyValue₁ >> AdditiveExpression^anyValue]
            (e: Env)
  = letexc bitmapValue: Value = Eval[ShiftExpression^anyValue₁](e)
     in letexc countValue: Value = Eval[AdditiveExpression^anyValue](e)
     in letexc bitmap: Integer = coerceToInt32(bitmapValue)
     in letexc count: Integer = coerceToUint32(countValue)
     in integerResult(bitwiseShift(bitmap, -bitwiseAnd(count, 31)))

Eval[ShiftExpression^ExprKind  ShiftExpression^anyValue₁ >>> AdditiveExpression^anyValue]
            (e: Env)
  = letexc bitmapValue: Value = Eval[ShiftExpression^anyValue₁](e)
     in letexc countValue: Value = Eval[AdditiveExpression^anyValue](e)
     in letexc bitmap: Integer = coerceToUint32(bitmapValue)
     in letexc count: Integer = coerceToUint32(countValue)
     in integerResult(bitwiseShift(bitmap, -bitwiseAnd(count, 31)))

Relational Operators

Syntax

Semantics

action Eval[RelationalExpression^ExprKind] : Env  ValueOrException

Eval[RelationalExpression^ExprKind  ShiftExpression^ExprKind]
  = Eval[ShiftExpression^ExprKind]

Eval[RelationalExpression^ExprKind  RelationalExpression^anyValue₁ < ShiftExpression^anyValue]
            (e: Env)
  = letexc leftValue: Value = Eval[RelationalExpression^anyValue₁](e)
     in letexc rightValue: Value = Eval[ShiftExpression^anyValue](e)
     in orderValues(leftValue, rightValue, true, false)

Eval[RelationalExpression^ExprKind  RelationalExpression^anyValue₁ > ShiftExpression^anyValue]
            (e: Env)
  = letexc leftValue: Value = Eval[RelationalExpression^anyValue₁](e)
     in letexc rightValue: Value = Eval[ShiftExpression^anyValue](e)
     in orderValues(rightValue, leftValue, true, false)

Eval[RelationalExpression^ExprKind  RelationalExpression^anyValue₁ <= ShiftExpression^anyValue]
            (e: Env)
  = letexc leftValue: Value = Eval[RelationalExpression^anyValue₁](e)
     in letexc rightValue: Value = Eval[ShiftExpression^anyValue](e)
     in orderValues(rightValue, leftValue, false, true)

Eval[RelationalExpression^ExprKind  RelationalExpression^anyValue₁ >= ShiftExpression^anyValue]
            (e: Env)
  = letexc leftValue: Value = Eval[RelationalExpression^anyValue₁](e)
     in letexc rightValue: Value = Eval[ShiftExpression^anyValue](e)
     in orderValues(leftValue, rightValue, false, true)

orderValues(leftValue: Value, rightValue: Value, less: Boolean, greaterOrEqual: Boolean)
  : ValueOrException
  = letexc leftPrimitive: Value = coerceToPrimitive(leftValue, numberHint)
     in letexc rightPrimitive: Value = coerceToPrimitive(rightValue, numberHint)
     in if leftPrimitive is stringValue and rightPrimitive is stringValue
         then booleanResult(
                    compareStrings(
                        leftPrimitive.stringValue,
                        rightPrimitive.stringValue,
                        less,
                        greaterOrEqual,
                        greaterOrEqual))
         else letexc leftNumber: Double = coerceToDouble(leftPrimitive)
               in letexc rightNumber: Double = coerceToDouble(rightPrimitive)
               in booleanResult(
                       doubleCompare(
                           leftNumber,
                           rightNumber,
                           less,
                           greaterOrEqual,
                           greaterOrEqual,
                           false))

compareStrings(left: String, right: String, less: Boolean, equal: Boolean, greater: Boolean)
  : Boolean
  = if empty(left) and empty(right)
     then equal
     else if empty(left)
     then less
     else if empty(right)
     then greater
     else let leftCharCode: Integer = characterToCode(first(left));
               rightCharCode: Integer = characterToCode(first(right))
           in if leftCharCode < rightCharCode
               then less
               else if leftCharCode > rightCharCode
               then greater
               else compareStrings(rest(left), rest(right), less, equal, greater)

Equality Operators

Syntax

Semantics

action Eval[EqualityExpression^ExprKind] : Env  ValueOrException

Eval[EqualityExpression^ExprKind  RelationalExpression^ExprKind]
  = Eval[RelationalExpression^ExprKind]

Eval[EqualityExpression^ExprKind  EqualityExpression^anyValue₁ == RelationalExpression^anyValue]
            (e: Env)
  = letexc leftValue: Value = Eval[EqualityExpression^anyValue₁](e)
     in letexc rightValue: Value = Eval[RelationalExpression^anyValue](e)
     in letexc eq: Boolean = compareValues(leftValue, rightValue)
     in booleanResult(eq)

Eval[EqualityExpression^ExprKind  EqualityExpression^anyValue₁ != RelationalExpression^anyValue]
            (e: Env)
  = letexc leftValue: Value = Eval[EqualityExpression^anyValue₁](e)
     in letexc rightValue: Value = Eval[RelationalExpression^anyValue](e)
     in letexc eq: Boolean = compareValues(leftValue, rightValue)
     in booleanResult(not eq)

Eval[EqualityExpression^ExprKind  EqualityExpression^anyValue₁ === RelationalExpression^anyValue]
            (e: Env)
  = letexc leftValue: Value = Eval[EqualityExpression^anyValue₁](e)
     in letexc rightValue: Value = Eval[RelationalExpression^anyValue](e)
     in booleanResult(strictCompareValues(leftValue, rightValue))

Eval[EqualityExpression^ExprKind  EqualityExpression^anyValue₁ !== RelationalExpression^anyValue]
            (e: Env)
  = letexc leftValue: Value = Eval[EqualityExpression^anyValue₁](e)
     in letexc rightValue: Value = Eval[RelationalExpression^anyValue](e)
     in booleanResult(not strictCompareValues(leftValue, rightValue))

compareValues(leftValue: Value, rightValue: Value) : BooleanOrException
  = case leftValue of
        undefinedValue, nullValue:
              case rightValue of
                 undefinedValue, nullValue: normal true;
                 booleanValue, doubleValue, stringValue, objectValue: normal false
                 end;
        booleanValue(leftBool: Boolean):
              case rightValue of
                 undefinedValue, nullValue: normal false;
                 booleanValue(rightBool: Boolean): normal (not (leftBool xor rightBool));
                 doubleValue, stringValue, objectValue:
                       compareDoubleToValue(coerceBooleanToDouble(leftBool), rightValue)
                 end;
        doubleValue(leftNumber: Double): compareDoubleToValue(leftNumber, rightValue);
        stringValue(leftStr: String):
              case rightValue of
                 undefinedValue, nullValue: normal false;
                 booleanValue(rightBool: Boolean):
                       letexc leftNumber: Double = coerceToDouble(leftValue)
                       in normal doubleEqual(leftNumber, coerceBooleanToDouble(rightBool));
                 doubleValue(rightNumber: Double):
                       letexc leftNumber: Double = coerceToDouble(leftValue)
                       in normal doubleEqual(leftNumber, rightNumber);
                 stringValue(rightStr: String):
                       normal compareStrings(leftStr, rightStr, false, true, false);
                 objectValue:
                       letexc rightPrimitive: Value = coerceToPrimitive(rightValue, noHint)
                       in compareValues(leftValue, rightPrimitive)
                 end;
        objectValue(leftObj: Object):
              case rightValue of
                 undefinedValue, nullValue: normal false;
                 booleanValue(rightBool: Boolean):
                       letexc leftPrimitive: Value = coerceToPrimitive(leftValue, noHint)
                       in compareValues(
                               leftPrimitive,
                               doubleValue coerceBooleanToDouble(rightBool));
                 doubleValue, stringValue:
                       letexc leftPrimitive: Value = coerceToPrimitive(leftValue, noHint)
                       in compareValues(leftPrimitive, rightValue);
                 objectValue(rightObj: Object):
                       normal (leftObj.properties  rightObj.properties)
                 end
        end

compareDoubleToValue(leftNumber: Double, rightValue: Value) : BooleanOrException
  = case rightValue of
        undefinedValue, nullValue: normal false;
        booleanValue, doubleValue, stringValue:
              letexc rightNumber: Double = coerceToDouble(rightValue)
              in normal doubleEqual(leftNumber, rightNumber);
        objectValue:
              letexc rightPrimitive: Value = coerceToPrimitive(rightValue, noHint)
              in compareDoubleToValue(leftNumber, rightPrimitive)
        end

doubleEqual(x: Double, y: Double) : Boolean
  = doubleCompare(x, y, false, true, false, false)

strictCompareValues(leftValue: Value, rightValue: Value) : Boolean
  = case leftValue of
        undefinedValue: rightValue is undefinedValue;
        nullValue: rightValue is nullValue;
        booleanValue(leftBool: Boolean):
              case rightValue of
                 booleanValue(rightBool: Boolean): not (leftBool xor rightBool);
                 undefinedValue, nullValue, doubleValue, stringValue, objectValue: false
                 end;
        doubleValue(leftNumber: Double):
              case rightValue of
                 doubleValue(rightNumber: Double): doubleEqual(leftNumber, rightNumber);
                 undefinedValue, nullValue, booleanValue, stringValue, objectValue: false
                 end;
        stringValue(leftStr: String):
              case rightValue of
                 stringValue(rightStr: String):
                       compareStrings(leftStr, rightStr, false, true, false);
                 undefinedValue, nullValue, booleanValue, doubleValue, objectValue: false
                 end;
        objectValue(leftObj: Object):
              case rightValue of
                 objectValue(rightObj: Object): leftObj.properties  rightObj.properties;
                 undefinedValue, nullValue, booleanValue, doubleValue, stringValue: false
                 end
        end

Binary Bitwise Operators

Syntax

Semantics

action Eval[BitwiseAndExpression^ExprKind] : Env  ValueOrException

Eval[BitwiseAndExpression^ExprKind  EqualityExpression^ExprKind]
  = Eval[EqualityExpression^ExprKind]

Eval[BitwiseAndExpression^ExprKind  BitwiseAndExpression^anyValue₁ & EqualityExpression^anyValue]
            (e: Env)
  = letexc leftValue: Value = Eval[BitwiseAndExpression^anyValue₁](e)
     in letexc rightValue: Value = Eval[EqualityExpression^anyValue](e)
     in applyBinaryBitwiseOperator(bitwiseAnd, leftValue, rightValue)

action Eval[BitwiseXorExpression^ExprKind] : Env  ValueOrException

Eval[BitwiseXorExpression^ExprKind  BitwiseAndExpression^ExprKind]
  = Eval[BitwiseAndExpression^ExprKind]

Eval[BitwiseXorExpression^ExprKind  BitwiseXorExpression^anyValue₁ ^ BitwiseAndExpression^anyValue]
            (e: Env)
  = letexc leftValue: Value = Eval[BitwiseXorExpression^anyValue₁](e)
     in letexc rightValue: Value = Eval[BitwiseAndExpression^anyValue](e)
     in applyBinaryBitwiseOperator(bitwiseXor, leftValue, rightValue)

action Eval[BitwiseOrExpression^ExprKind] : Env  ValueOrException

Eval[BitwiseOrExpression^ExprKind  BitwiseXorExpression^ExprKind]
  = Eval[BitwiseXorExpression^ExprKind]

Eval[BitwiseOrExpression^ExprKind  BitwiseOrExpression^anyValue₁ | BitwiseXorExpression^anyValue]
            (e: Env)
  = letexc leftValue: Value = Eval[BitwiseOrExpression^anyValue₁](e)
     in letexc rightValue: Value = Eval[BitwiseXorExpression^anyValue](e)
     in applyBinaryBitwiseOperator(bitwiseOr, leftValue, rightValue)

applyBinaryBitwiseOperator(operator: Integer  Integer  Integer, leftValue: Value, rightValue: Value)
  : ValueOrException
  = letexc leftInt: Integer = coerceToInt32(leftValue)
     in letexc rightInt: Integer = coerceToInt32(rightValue)
     in integerResult(operator(leftInt, rightInt))

Binary Logical Operators

Syntax

Semantics

action Eval[LogicalAndExpression^ExprKind] : Env  ValueOrException

Eval[LogicalAndExpression^ExprKind  BitwiseOrExpression^ExprKind]
  = Eval[BitwiseOrExpression^ExprKind]

Eval[LogicalAndExpression^ExprKind  LogicalAndExpression^anyValue₁ && BitwiseOrExpression^anyValue]
            (e: Env)
  = letexc leftValue: Value = Eval[LogicalAndExpression^anyValue₁](e)
     in if coerceToBoolean(leftValue)
         then Eval[BitwiseOrExpression^anyValue](e)
         else normal leftValue

action Eval[LogicalOrExpression^ExprKind] : Env  ValueOrException

Eval[LogicalOrExpression^ExprKind  LogicalAndExpression^ExprKind]
  = Eval[LogicalAndExpression^ExprKind]

Eval[LogicalOrExpression^ExprKind  LogicalOrExpression^anyValue₁ || LogicalAndExpression^anyValue]
            (e: Env)
  = letexc leftValue: Value = Eval[LogicalOrExpression^anyValue₁](e)
     in if coerceToBoolean(leftValue)
         then normal leftValue
         else Eval[LogicalAndExpression^anyValue](e)

Conditional Operator

Syntax

Semantics

action Eval[ConditionalExpression^ExprKind] : Env  ValueOrException

Eval[ConditionalExpression^ExprKind  LogicalOrExpression^ExprKind]
  = Eval[LogicalOrExpression^ExprKind]

Eval[ConditionalExpression^ExprKind  LogicalOrExpression^anyValue ? AssignmentExpression^anyValue₁ : AssignmentExpression^anyValue₂]
            (e: Env)
  = letexc condition: Value = Eval[LogicalOrExpression^anyValue](e)
     in if coerceToBoolean(condition)
         then Eval[AssignmentExpression^anyValue₁](e)
         else Eval[AssignmentExpression^anyValue₂](e)

Assignment Operators

Syntax

Expressions

Syntax

Semantics

action Eval[AssignmentExpression^ExprKind] : Env  ValueOrException

Eval[AssignmentExpression^ExprKind  ConditionalExpression^ExprKind]
  = Eval[ConditionalExpression^ExprKind]

Eval[AssignmentExpression^ExprKind  Lvalue = AssignmentExpression^anyValue₁](e: Env)
  = letexc leftReference: Reference = Eval[Lvalue](e)
     in letexc rightValue: Value = Eval[AssignmentExpression^anyValue₁](e)
     in letexc u: Void = referencePutValue(leftReference, rightValue)
     in normal rightValue

action Eval[CommaExpression^ExprKind] : Env  ValueOrException

Eval[CommaExpression^ExprKind  AssignmentExpression^ExprKind]
  = Eval[AssignmentExpression^ExprKind]

Syntax

Semantics

action Eval[Expression] : Env  ValueOrException

Eval[Expression  CommaExpression^anyValue] = Eval[CommaExpression^anyValue]

Programs

Syntax

Semantics

action Eval[Program] : ValueOrException

Eval[Program  Expression End] = Eval[Expression](nullObjectOrNull_Env)