Grammar Semantics

Formal JavaScript Semantics

Grammar

Wednesday, February 28, 2001

Types

Semantics

type Value
  = oneof {
           undefinedValue;
           nullValue;
           booleanValue: Boolean;
           numberValue: Float64;
           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 Float64OrException = oneof {normal: Float64; 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

float64Result(d: Float64) : ValueOrException = normal numberValue d

integerResult(i: Integer) : ValueOrException = float64Result(rationalToFloat64(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;
        numberValue(d: Float64): not (float64IsZero(d) or float64IsNaN(d));
        stringValue(s: String): |s|  0;
        objectValue: true
        end

coerceBooleanToFloat64(b: Boolean) : Float64 = if b then 1.0 else +0.0

coerceToFloat64(v: Value) : Float64OrException
  = case v of
        undefinedValue: normal NaN;
        nullValue: normal +0.0;
        booleanValue(b: Boolean): normal coerceBooleanToFloat64(b);
        numberValue(d: Float64): normal d;
        stringValue: ;
        objectValue:
        end

float64ToUint32(x: Float64) : Integer
= if float64IsNaN(x) or float64IsInfinite(x) then 0 else truncateFloat64(x)mod4294967296

coerceToUint32(v: Value) : IntegerOrException
= letexc d: Float64 = coerceToFloat64(v)
in normal float64ToUint32(d)

coerceToInt32(v: Value) : IntegerOrException
= letexc d: Float64 = coerceToFloat64(v)
in normal uint32ToInt32(float64ToUint32(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”;
        numberValue: ;
        stringValue(s: String): normal s;
        objectValue:
        end

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

coerceToObject(v: Value) : ObjectOrException
  = case v of
        undefinedValue, nullValue: abrupt_{ObjectOrException} makeError(coerceToObjectError);
        booleanValue: ;
        numberValue: ;
        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] : Float64

action EvalString[String] : String

Primary Expressions

Syntax

PrimaryRvalue

this

| null

| true

| false

| Number

| String

| ( CommaExpression^noLValue )

PrimaryLvalue

Identifier

| ( Lvalue )

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) = float64Result(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

ExprKind {anyValue, noLValue}

MemberExprKind {call, noCall}

MemberLvalue^noCall

PrimaryLvalue

| MemberExpression^{noCall,anyValue} [ Expression ]

| MemberExpression^{noCall,anyValue} . Identifier

MemberLvalue^call

Lvalue Arguments

| MemberExpression^{noCall,noLValue} Arguments

| MemberExpression^{call,anyValue} [ Expression ]

| MemberExpression^{call,anyValue} . Identifier

MemberExpression^{noCall,noLValue}

PrimaryRvalue

| new MemberExpression^{noCall,anyValue} Arguments

MemberExpression^{noCall,anyValue}

PrimaryRvalue

| MemberLvalue^noCall

| new MemberExpression^{noCall,anyValue} Arguments

MemberExpression^{call,anyValue} MemberLvalue^call

NewExpression^ExprKind

MemberExpression^{noCall,ExprKind}

| new NewExpression^anyValue

Arguments

( )

| ( ArgumentList )

ArgumentList

AssignmentExpression^anyValue

| ArgumentList , AssignmentExpression^anyValue

Lvalue

MemberLvalue^call

| MemberLvalue^noCall

Semantics

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

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

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

Eval[MemberLvalue^call  MemberExpression^{noCall,noLValue} Arguments](e: Env)
  = letexc f: Value = Eval[MemberExpression^{noCall,noLValue}](e)
     in letexc arguments: Value[] = Eval[Arguments](e)
     in callObject(f, 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 base  obj, property  name

callObject(f: Value, this: ObjectOrNull, arguments: Value[]) : ReferenceOrException
  = case f of
        undefinedValue, nullValue, booleanValue, numberValue, 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, numberValue, stringValue:
              abrupt_{ValueOrException} makeError(coerceToObjectError);
        objectValue(o: Object):
              letexc res: Object = o.construct(arguments)
              in objectResult(res)
        end

Postfix Expressions

Syntax

PostfixExpression^anyValue

NewExpression^anyValue

| MemberExpression^{call,anyValue}

| Lvalue ++

| Lvalue --

PostfixExpression^noLValue

NewExpression^noLValue

| Lvalue ++

| Lvalue --

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: Float64 = coerceToFloat64(operandValue)
     in letexc u: Void
                  = referencePutValue(operandReference, numberValue float64Add(operand, 1.0))
     in float64Result(operand)

Eval[PostfixExpression^ExprKind  Lvalue --](e: Env)
  = letexc operandReference: Reference = Eval[Lvalue](e)
     in letexc operandValue: Value = referenceGetValue(operandReference)
     in letexc operand: Float64 = coerceToFloat64(operandValue)
     in letexc u: Void
                  = referencePutValue(
                         operandReference,
                         numberValue float64Subtract(operand, 1.0))
     in float64Result(operand)

Unary Operators

Syntax

UnaryExpression^ExprKind

PostfixExpression^ExprKind

| delete Lvalue

| void UnaryExpression^anyValue

| typeof Lvalue

| typeof UnaryExpression^noLValue

| ++ Lvalue

| -- Lvalue

| + UnaryExpression^anyValue

| - UnaryExpression^anyValue

| ~ UnaryExpression^anyValue

| ! UnaryExpression^anyValue

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: Float64 = coerceToFloat64(operandValue)
     in let res: Float64 = float64Add(operand, 1.0)
     in letexc u: Void = referencePutValue(operandReference, numberValue res)
     in float64Result(res)

Eval[UnaryExpression^ExprKind  -- Lvalue](e: Env)
  = letexc operandReference: Reference = Eval[Lvalue](e)
     in letexc operandValue: Value = referenceGetValue(operandReference)
     in letexc operand: Float64 = coerceToFloat64(operandValue)
     in let res: Float64 = float64Subtract(operand, 1.0)
     in letexc u: Void = referencePutValue(operandReference, numberValue res)
     in float64Result(res)

Eval[UnaryExpression^ExprKind  + UnaryExpression^anyValue₁](e: Env)
  = letexc operandValue: Value = Eval[UnaryExpression^anyValue₁](e)
     in letexc operand: Float64 = coerceToFloat64(operandValue)
     in float64Result(operand)

Eval[UnaryExpression^ExprKind  - UnaryExpression^anyValue₁](e: Env)
  = letexc operandValue: Value = Eval[UnaryExpression^anyValue₁](e)
     in letexc operand: Float64 = coerceToFloat64(operandValue)
     in float64Result(float64Negate(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”;
        numberValue: “number”;
        stringValue: “string”;
        objectValue(o: Object): o.typeofName
        end

Multiplicative Operators

Syntax

MultiplicativeExpression^ExprKind

UnaryExpression^ExprKind

| MultiplicativeExpression^anyValue * UnaryExpression^anyValue

| MultiplicativeExpression^anyValue / UnaryExpression^anyValue

| MultiplicativeExpression^anyValue % UnaryExpression^anyValue

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 applyBinaryFloat64Operator(float64Multiply, 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 applyBinaryFloat64Operator(float64Divide, 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 applyBinaryFloat64Operator(float64Remainder, leftValue, rightValue)

applyBinaryFloat64Operator(operator: Float64  Float64  Float64,
        leftValue: Value,
        rightValue: Value) : ValueOrException
  = letexc leftNumber: Float64 = coerceToFloat64(leftValue)
     in letexc rightNumber: Float64 = coerceToFloat64(rightValue)
     in float64Result(operator(leftNumber, rightNumber))

Additive Operators

Syntax

AdditiveExpression^ExprKind

MultiplicativeExpression^ExprKind

| AdditiveExpression^anyValue + MultiplicativeExpression^anyValue

| AdditiveExpression^anyValue - MultiplicativeExpression^anyValue

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 applyBinaryFloat64Operator(float64Add, 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 applyBinaryFloat64Operator(float64Subtract, leftValue, rightValue)

Bitwise Shift Operators

Syntax

ShiftExpression^ExprKind

AdditiveExpression^ExprKind

| ShiftExpression^anyValue << AdditiveExpression^anyValue

| ShiftExpression^anyValue >> AdditiveExpression^anyValue

| ShiftExpression^anyValue >>> AdditiveExpression^anyValue

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

RelationalExpression^ExprKind

ShiftExpression^ExprKind

| RelationalExpression^anyValue < ShiftExpression^anyValue

| RelationalExpression^anyValue > ShiftExpression^anyValue

| RelationalExpression^anyValue <= ShiftExpression^anyValue

| RelationalExpression^anyValue >= ShiftExpression^anyValue

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: Float64 = coerceToFloat64(leftPrimitive)
               in letexc rightNumber: Float64 = coerceToFloat64(rightPrimitive)
               in booleanResult(
                       float64Compare(
                           leftNumber,
                           rightNumber,
                           less,
                           greaterOrEqual,
                           greaterOrEqual,
                           false))

compareStrings(left: String,
        right: String,
        less: Boolean,
        equal: Boolean,
        greater: Boolean) : Boolean
  = if |left| = 0 and |right| = 0
     then equal
     else if |left| = 0
     then less
     else if |right| = 0
     then greater
     else let leftCharCode: Integer = characterToCode(left[0]);
               rightCharCode: Integer = characterToCode(right[0])
           in if leftCharCode < rightCharCode
               then less
               else if leftCharCode > rightCharCode
               then greater
               else compareStrings(left[1 ...], right[1 ...], less, equal, greater)

Equality Operators

Syntax

EqualityExpression^ExprKind

RelationalExpression^ExprKind

| EqualityExpression^anyValue == RelationalExpression^anyValue

| EqualityExpression^anyValue != RelationalExpression^anyValue

| EqualityExpression^anyValue === RelationalExpression^anyValue

| EqualityExpression^anyValue !== RelationalExpression^anyValue

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, numberValue, stringValue, objectValue: normal false
                 end;
        booleanValue(leftBool: Boolean):
              case rightValue of
                 undefinedValue, nullValue: normal false;
                 booleanValue(rightBool: Boolean): normal (not (leftBool xor rightBool));
                 numberValue, stringValue, objectValue:
                       compareFloat64ToValue(coerceBooleanToFloat64(leftBool), rightValue)
                 end;
        numberValue(leftNumber: Float64): compareFloat64ToValue(leftNumber, rightValue);
        stringValue(leftStr: String):
              case rightValue of
                 undefinedValue, nullValue: normal false;
                 booleanValue(rightBool: Boolean):
                       letexc leftNumber: Float64 = coerceToFloat64(leftValue)
                       in normal float64Equal(leftNumber, coerceBooleanToFloat64(rightBool));
                 numberValue(rightNumber: Float64):
                       letexc leftNumber: Float64 = coerceToFloat64(leftValue)
                       in normal float64Equal(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,
                               numberValue coerceBooleanToFloat64(rightBool));
                 numberValue, stringValue:
                       letexc leftPrimitive: Value = coerceToPrimitive(leftValue, noHint)
                       in compareValues(leftPrimitive, rightValue);
                 objectValue(rightObj: Object):
                       normal (leftObj.properties  rightObj.properties)
                 end
        end

compareFloat64ToValue(leftNumber: Float64, rightValue: Value) : BooleanOrException
  = case rightValue of
        undefinedValue, nullValue: normal false;
        booleanValue, numberValue, stringValue:
              letexc rightNumber: Float64 = coerceToFloat64(rightValue)
              in normal float64Equal(leftNumber, rightNumber);
        objectValue:
              letexc rightPrimitive: Value = coerceToPrimitive(rightValue, noHint)
              in compareFloat64ToValue(leftNumber, rightPrimitive)
        end

float64Equal(x: Float64, y: Float64) : Boolean
= float64Compare(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, numberValue, stringValue, objectValue: false
                 end;
        numberValue(leftNumber: Float64):
              case rightValue of
                 numberValue(rightNumber: Float64): float64Equal(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, numberValue, objectValue: false
                 end;
        objectValue(leftObj: Object):
              case rightValue of
                 objectValue(rightObj: Object): leftObj.properties  rightObj.properties;
                 undefinedValue, nullValue, booleanValue, numberValue, stringValue: false
                 end
        end

Binary Bitwise Operators

Syntax

BitwiseAndExpression^ExprKind

EqualityExpression^ExprKind

| BitwiseAndExpression^anyValue & EqualityExpression^anyValue

BitwiseXorExpression^ExprKind

BitwiseAndExpression^ExprKind

| BitwiseXorExpression^anyValue ^ BitwiseAndExpression^anyValue

BitwiseOrExpression^ExprKind

BitwiseXorExpression^ExprKind

| BitwiseOrExpression^anyValue | BitwiseXorExpression^anyValue

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

LogicalAndExpression^ExprKind

BitwiseOrExpression^ExprKind

| LogicalAndExpression^anyValue && BitwiseOrExpression^anyValue

LogicalOrExpression^ExprKind

LogicalAndExpression^ExprKind

| LogicalOrExpression^anyValue || LogicalAndExpression^anyValue

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

ConditionalExpression^ExprKind

LogicalOrExpression^ExprKind

| LogicalOrExpression^anyValue ? AssignmentExpression^anyValue : AssignmentExpression^anyValue

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

AssignmentExpression^ExprKind

ConditionalExpression^ExprKind

| Lvalue = AssignmentExpression^anyValue

Expressions

Syntax

CommaExpression^ExprKind AssignmentExpression^ExprKind

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

Expression CommaExpression^anyValue

Semantics

action Eval[Expression] : Env ValueOrException

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

Programs

Syntax

Program Expression End

Semantics

action Eval[Program] : ValueOrException

Eval[Program Expression End] = Eval[Expression](this nullObjectOrNull)

Waldemar Horwat
Last modified Wednesday, February 28, 2001