# Bitwise Operators

### Bitwise Operators

Bitwise operators include and (‘&‘), or (‘|‘), exclusive or (‘^‘), left shift (‘<<‘), right shift (‘>>‘), and right shift, zero fill (‘>>>‘). These are all binary operators and are valid on any scalar type. When they are applied the scalar value is converted to an SFInt32 before the operation, and back to the original expression type after. Therefore roundoff error can occur when applying them to SFFloat or SFTime values. The shift operators shift the operand on the left side the number of bits specified by the operator on the right side. The difference between right shift and right shift, zero fill is that the former preserves the sign of the left operator and the latter always puts a zero in the most significant bits.

Examples:

```a & 0x0FF       // clears upper 24 bits of 'a'
a >> 5          // shift 'a' 5 bits to the right, sign extend
```

### 1.4.4 Logical and Comparison Operators

Logical expressions include logical and (‘&&‘), logical or (‘||‘), logical not (‘!‘), and the comparison operators (‘<‘, ‘<=‘, ‘==‘, ‘!=‘, ‘>=‘, ‘>‘). Logical not is prefix unary, the rest are binary. Each evaluates to either 0 (false) or 1 (true). The constants true, false, TRUE, and FALSE can also be used.

Examples:

```a < 5
b > 0 && c > 1
!((a > 4) || (b < 6))
```

### 1.4.5 String Operators

All the comparison operators can be used to compare Strings for lexicographic order. Additionally the operators ‘+’ and ‘+=’ can be used to concatenate 2 strings. Any expression involving a String and any scalar type will first convert the scalar to a string and then perform the concatentation. Conversion of a String to a scalar type can be done with the functions parseInt() and parseFloat().

Examples:

```'A one and ' + 'a two'         // result is "A one and a two"
'The magic number is ' + 7     // result is 'The magic number is 7'
a = 5;                         // 'a' contains an SFTime
a += 'is correct';             // 'a' is now the String '5 is correct'
```

### 1.4.6 Operator Precedence

Precedence rules are used to order evaluation. In the above compound expression example multiplication (‘*’) is evaluated before addition (‘+’). For operations of equal precedence evaluation order is shown in the table below. The default rules can be overridden with the use of the ‘(‘ and ‘)’ characters to bracket operations to be performed first.

Example:

```a = b + c * d;    // c * d is evaluated first
a = (b + c) * d;  // b + c is evaluated first
a = b * c / d;    // b * c is evaluated first
// ('*' and '/' have equal precedence, evaluation
// order is left-to-right)
```

Order of precedence is (unless otherwise stated evaluation order is left-to-right):

 Operator Type Operator Comments comma , assignment = += -= *= /= %= <<= >>= >>>= &= ^= |= right-to-left conditional ?: tertiary operator logical-or || logical-and && bitwise-or | bitwise-xor ^ bitwise-and & equality == != relational < <= > >= bitwise shift << >> >>> add/subtract + – multiply/divide * / % negate/increment ! ~ – ++ — unary operators call, member () [] . ## 2 Supported Protocol in the Script Node’s url Field

The url field of the Script node may contain a URL that references VRMLScript code:

``` Script {  url "http://foo.com/myScript.vs"  }
```

The vrmlscript: protocol allows the script to be placed inline as follows:

```    Script {  url "vrmlscript: function foo() { ... }"   }
```

The url field may contain multiple URLs and thus reference a remote file or in-line code:

```    Script {
url [ "http://foo.com/myScript.vs",
"vrmlscript: function foo() { ... }" ]
}
```

### 2.1 File Extension

The file extension for VRMLScript source code is .vs.

### 2.2 MIME Type

The MIME type for VRMLScript source code is defined as follows:

```        application/x-vrmlscript
```