Difference between revisions of "SCI Programming Language/Primitive Procedures"

From SCI Wiki
Jump to navigationJump to search
Line 23: Line 23:
  
 
 
 
 
 +
 +
 +
==<br /> Primitive Procedures ==
 +
 +
===<br /> Arithmetic primitives ===
 +
 +
In the following examples, e1, e2, etc. are arbitrary expressions. Brackets [...] indicate optional entries. Procedures evaluate their parameters from left to right.
 +
 +
====<br /> Addition ====
 +
 +
<blockquote><code>(+ e1 e2 [e3...])</code></blockquote>
 +
 +
evaluates to: e1 + e2 [+ e3...]
 +
 +
example: (+ 7 12 4) evaluates to 23.
 +
 +
====<br /> Multiplication ====
 +
 +
<blockquote><code>(* e1 e2 [e3...])</code></blockquote>
 +
 +
evaluates to:  e1 (*e2[*e3...]
 +
 +
example: (* 2 10 3) evaluates to 60.
 +
 +
====<br /> Subtraction ====
 +
 +
<blockquote><code>(- e1 e2)</code></blockquote>
 +
 +
evaluates to : e1 - e2
 +
 +
example: (- 20 11) evaluates to 9.
 +
 +
====<br /> Division ====
 +
 +
<blockquote><code>(/ e1 e2)</code></blockquote>
 +
 +
evaluates to: e1 / e2
 +
 +
example: (/ 24 6) evaluates to 4. <----  Note: does this round when necessary (up, down)?
 +
 +
====<br /> Remainder ====
 +
 +
<blockquote><code>(mod e1 e2)</code></blockquote>
 +
 +
evaluates to: the remainder of e1 when divided by e2.
 +
 +
example: (mod 17 5) evaluates to 2.
 +
 +
====<br /> Operation Shift Left ====
 +
 +
<blockquote><code>(<< e1 e2)</code></blockquote>
 +
 +
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
 +
 +
====<br /> Operation Shift Right ====
 +
 +
<blockquote><code>(>> e1 e2)</code></blockquote>
 +
 +
evaluates to: e1 >> e2 (as in << except with a right shift)
 +
 +
example: (>> 7 2) evaluates to 1.
 +
 +
In binary: 111 >> 2 = 001
 +
 +
====<br /> Bitwise Exclusive OR Operator ====
 +
 +
<blockquote><code>(^ e1 e2 [e3...])</code></blockquote>
 +
 +
evaluates to: e1^ e2 [^ e3...]
 +
 +
example: (^ 11 26) evaluates to 17.
 +
 +
In binary: 01011" 11010 = 10001
 +
 +
====<br /> Bitwise AND Operator ====
 +
 +
<blockquote>
 +
{|
 +
|<code>(& e1 e2 [e3...])</code>
 +
|-
 +
|evaluates to: ||e1 &e2 [& e3...]
 +
|-
 +
|''example:'' ||<code>(& 11 26)</code> evaluates to 10.
 +
|-
 +
|&nbsp; ||In binary: 01011 & 11010 = 01010
 +
|}
 +
</blockquote>
 +
 +
====<br /> Bitwise OR Operator ====
 +
 +
<blockquote>
 +
{|
 +
| <code><nowiki>(| e1 e2 [e3...])</nowiki></code>
 +
|-
 +
|evaluates to: ||e1 | e2 [| e3...]
 +
|-
 +
|''example:'' ||<code><nowiki>(| 11 26)</nowiki></code> evaluates to 27.
 +
|-
 +
|&nbsp;||In binary: 01011 111010 = 11011
 +
|}
 +
</blockquote>
 +
 +
====<br /> Bitwise NOT ====
 +
 +
<blockquote>
 +
{|
 +
|<code>(~ e1)</code>
 +
|-
 +
|evaluates to: &nbsp; ||the bitwise not of e1 (all 1 bits are changed to 0 and all 0 bits are changed to 1).
 +
|-
 +
|''example:'' ||<code>(~ 11)</code> evaluates to -12.
 +
|-
 +
|&nbsp; ||In binary: ~01011 = 1111111111110100 (all the leading 0s in the 16 bit number change to 1s).
 +
|}
 +
</blockquote>
 +
 +
===<br /> 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.
 +
 +
====<br /> Greater Than ====
 +
 +
{|
 +
|(> e1 e2 [e3...])
 +
|-
 +
|evaluates to: ||TRUE if e1 > e2 [> e3...], else FALSE.
 +
|-
 +
|''example:'' ||(> 7 4 6) evaluates to FALSE.
 +
|}
 +
 +
====<br /> Greater Than or Equals ====
 +
 +
{|
 +
|(>= e1 e2 [e3...])
 +
|-
 +
|evaluates to: ||TRUE if e1 >= e2 [>= e3...], else FALSE.
 +
|-
 +
|''example:'' ||(>= 7 4 4) evaluates to TRUE.
 +
 +
====<br /> Less Than ====
 +
 +
(< e1 e2 [e3...])
 +
|-
 +
|evaluates to: ||TRUE if e1 < e2 [< e3...], else FALSE.
 +
|-
 +
|''example:'' ||(< 2 4 5) evaluates to TRUE.
 +
|}
 +
 +
====<br /> Less Than or Equals ====
 +
 +
{|
 +
|(<= e1 e2 [e3...])
 +
|-
 +
|evaluates to: ||TRUE if e1 <= e2 [<= e3...], else FALSE.
 +
|-
 +
|''example:'' ||(<= 7 8 7) evaluates to FALSE.
 +
|}
 +
 +
====<br /> Is Equal To
 +
 +
{|
 +
|(== e1 e2 [e3...])
 +
|-
 +
|evaluates to: ||TRUE if e1 == e2 [== e3...], else FALSE.
 +
|-
 +
|''example:'' ||(== 1 TRUE 1) evaluates to TRUE.
 +
|}
 +
 +
'''Page 7'''
 +
 +
====<br /> Is Not Equal To ====
 +
 +
{|
 +
|(!= e1 e2 [e3...])|-
 +
|evaluates to: ||TRUE if e1 != e2 [!= e3...], else FALSE.|-
 +
|''example:'' ||( ! = 7 4 6) evaluates to TRUE.
 +
|}
 +
 +
====<br /> AND ====
 +
 +
{|
 +
|(and e1 e2 [e3...])
 +
|-
 +
|evaluates to: ||TRUE if all the expressions are non-zero, else FALSE.|-
 +
|''example:'' ||(and 7 4 6) evaluates to TRUE.
 +
|}
 +
 +
====<br /> OR ====
 +
 +
{|
 +
|(or e1 e2 [e3...])
 +
|-
 +
|evaluates to: ||TRUE if any of the expressions are non-zero, else FALSE.|-
 +
|''example:'' ||(or 3 0 2) evaluates to TRUE.
 +
|}
 +
 +
====<br /> NOT ====
 +
 +
(not el)|-
 +
|evaluates to: ||TRUE if the expression is zero, else FALSE.|-
 +
|''example:'' ||(not 6) evaluates to FALSE.
 +
|}
 +
 +
'''Page 8'''
 +
===<br /> 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
 +
 +
 +
 +
 +
  
  

Revision as of 19:43, 24 May 2016

Official SCI Documentation

Chapter: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | Index


x
Author: Jeff Stephenson

 



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.


Less Than

(< e1 e2 [e3...])

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


 

Table of Contents

 

< Previous: IntroductionNext: Definitions >

Retrieved from "http://sciwiki.sierrahelp.com/index.php?title=SCI_Programming_Language/Primitive_Procedures&oldid=12574"