SCI Programming Language/Introduction
The SCI language is an object-oriented language with a Lisp-like syntax. It is compiled by the sc compiler into p-machine code which is used by the interpreter, sci.exe. We will begin our discussion of the language with its basic Lisp-like characteristics, then go on to the object-oriented parts of the language. Like Lisp, SCI is based on parenthesized expressions which return values. An expression is of the form:
(procedure [parameter parameter...])
The parameters to a procedure may themselves be expressions to be evaluated, and may be nested until you lose track of the parentheses. Unlike Lisp, a procedure itself may not be the result of an evaluation. An example of an expression is:
(+ (-y 2) (/ x 3))
which would be written in infix notation as:
(y -2) + (x / 3)
All expressions are guaranteed to be evaluated from left to right. Thus,
(= x 4) (= y (/ (+= x 4) ( / = x 2)))
will result in y = 2 and x = 4.
Comments in SCI begin with a semicolon and continue to the end of the line.
Primitive Procedures
Arithmetic primitives
In the following examples, e1, e2, etc. are arbitrary expressions. Brackets [...] indicate optional entries. Procedures evaluate their parameters from left to right.
Addition
(+ e1 e2 [e3...])
evaluates to: e1 + e2 [+ e3...]
example: (+ 7 12 4) evaluates to 23.
Multiplication
(* e1 e2 [e3...])
evaluates to: e1 (*e2[*e3...]
example: (* 2 10 3) evaluates to 60.
Subtraction
(- e1 e2)
evaluates to : e1 - e2
example: (- 20 11) evaluates to 9.
Division
(/ e1 e2)
evaluates to: e1 / e2
example: (/ 24 6) evaluates to 4. <---- Note: does this round when necessary (up, down)?
Remainder
(mod e1 e2)
evaluates to: the remainder of e1 when divided by e2.
example: (mod 17 5) evaluates to 2.
Operation Shift Left
(<< e1 e2)
evaluates to : e1<< e2 where the << operation shifts its left hand side left by the number of bits specified by its right hand side.
example: (<< 7 2 ) evaluates to 28.
In binary: 111 << 2 = 11100
Operation Shift Right
(>> e1 e2)
evaluates to: e1 >> e2 (as in << except with a right shift)
example: (>> 7 2) evaluates to 1.
In binary: 111 >> 2 = 001
Bitwise Exclusive OR Operator
(^ e1 e2 [e3...])
evaluates to: e1^ e2 [^ e3...]
example: (^ 11 26) evaluates to 17.
In binary: 01011" 11010 = 10001
Bitwise AND Operator
(& e1 e2 [e3...])evaluates to: e1 &e2 [& e3...] example: (& 11 26)evaluates to 10.In binary: 01011 & 11010 = 01010
Bitwise OR Operator
(| e1 e2 [e3...])evaluates to: e2 [| e3...] example: (| 11 26)evaluates to 27.In binary: 01011 111010 = 11011
Bitwise NOT
(~ e1)evaluates to: the bitwise not of e1 (all 1 bits are changed to 0 and all 0 bits are changed to 1). example: (~ 11)evaluates to -12.In binary: ~01011 = 1111111111110100 (all the leading 0s in the 16 bit number change to 1s).
Boolean primitives
These procedures evaluate their parameters from left to right and terminate the moment the truth value of the expression is determined. If the truth value of the Boolean expression is determined before an expression is reached, that expression is never evaluated. Brackets [...] indicate optional entries. The compiler predefines FALSE to be 0 and TRUE to be 1.
Greater Than
| (> e1 e2 [e3...]) | |
| evaluates to: | TRUE if e1 > e2 [> e3...], else FALSE. |
| example: | (> 7 4 6) evaluates to FALSE. |
Greater Than or Equals
| (>= e1 e2 [e3...]) | |
| evaluates to: | TRUE if e1 >= e2 [>= e3...], else FALSE. |
| example: | (>= 7 4 4) evaluates to TRUE.
|
| evaluates to: | TRUE if e1 < e2 [< e3...], else FALSE. |
| example: | (< 2 4 5) evaluates to TRUE. |
Less Than or Equals
| (<= e1 e2 [e3...]) | |
| evaluates to: | TRUE if e1 <= e2 [<= e3...], else FALSE. |
| example: | (<= 7 8 7) evaluates to FALSE. |
====
Is Equal To
| (== e1 e2 [e3...]) | |
| evaluates to: | TRUE if e1 == e2 [== e3...], else FALSE. |
| example: | (== 1 TRUE 1) evaluates to TRUE. |
Page 7
Is Not Equal To
| - | evaluates to: | - | example: | ( ! = 7 4 6) evaluates to TRUE. |
AND
| (and e1 e2 [e3...]) | |||
| evaluates to: | - | example: | (and 7 4 6) evaluates to TRUE. |
OR
| (or e1 e2 [e3...]) | |||
| evaluates to: | - | example: | (or 3 0 2) evaluates to TRUE. |
NOT
(not el)|- |evaluates to: ||TRUE if the expression is zero, else FALSE.|- |example: ||(not 6) evaluates to FALSE. |}
Page 8
Assignment primitives
All assignment procedures store a value in a variable and return that value as the result of the assignment. In the following, v is a variable and e is an expression.
(= v e) evaluates to v = e
(+= v e) evaluates to v = v + e
(-= v e) evaluates to v = v - e
(*= v e) evaluates to v = v * e
(/= v e) evaluates to v = v / e
(|= v e) evaluates to v = v | e
(&= v e) evaluates to v = v & e
(^= v e) evaluates to v = v ^ e
(>>= v e) evaluates to v = v >> e
(<<= v e) evaluates to v = v << e
(++ v) evaluates to v = v + 1
(--v) evaluates to v = v - 1
- Notes
< Previous: Table of ContentsNext: Files >
