A Guide to the Sierra Programming Language 



Sierra is a new high-level programming language that is user-friendly and compiles into C code 
on the web using cloud computing. By January 2011 we can compile the generated C code on the web
using cloud computing also. Sierra has readable code designed to make sense to humans. 
Sierra has automatic memory management. Sierra is designed to be used both by professional software 
engineers and students since it's fast and easy to use. The objective is to increase productivity
and reduce bugs and make reusing code much easier and writing code more efficiently. The most 
striking difference is that Sierra has an underlying knowledgebase of implied meanings.


Note: We will soon be adding OOP and functional features and operator overloading.

1. Disclaimer
2. Introduction
3. Syntax
4. Sierra Core Data Types
   1. Atomic Variables
     1. Numbers
     2. Strings
   2. Arrays
   3. Records
5. Sierra Operators
   1. Mathematical Operators
   2. Comparison and Equality Operators
6. Sierra Global Block Commands
  1.Includes
  2.Macros
  3.Functions
7.Function and Main Block Commands
  1.Embedded C code
  2. Flow Control Structures
     1. If-Else
     2. Switch
     3. Miniswitch
     4. Loops 
     5. When
  3. File Operations
  4. swap
  5. search
8. Appendix
  1. C Translation Scheme
  2. Operator Precedence Table
  3. Upcoming Features
     1. Under Immediate Development
     2. Future Development


Disclaimer

This is the first-draft manual for the prototype Sierra RDC ("Readable C",) programming language.
This document is not intended to be definitive, and the basic elements of the Sierra RDC programming
language may change in further drafts of this manual. 
This manual is not intended to be an introduction to computer programming concepts, and presumes
some familiarity with basic concepts. It is recommended for readers who have prior experience 
in at least one other programming language. 
All text in this document is written in Verdana typeface, Sample Sierra RDC code will be
written in Courier New font.

Introduction 

Sierra  is a cloud-oriented, high-level, imperative programming language designed for translation
and compilation by a distributed  supercomputer.  For unsubscribed users, Sierra programs can also 
be translated into C99 by the  cloud, and can then be compiled to a binary by the local machine
using any C99-compliant compiler. 
 
    Sierra is intended to fulfill the following goals:

   *make programming easy for beginners 
   *dramatically speed up C99 development without sacrificing granularity of control or execution speed
   *automatic memory management
   *eventually be the basis for the Sierra Language Stack,  a larger initiative to realize 
    intentional and literate programming concepts augmented by cloud computing
 



Syntax 

    One line of Sierra is equivalent to approximately 2-8 lines of C99, but with a simplified 
    readable syntax that draws inspiration from a variety of sources including: Javascript, Groovy,
    Cobol, Pascal, Lisp, Lingo, Turing, Ada, Ruby, Python, and SQL. By using Sierra a C progrmamer
    will be at least 10X more productive than developing in C99 and reduce bugs by 50%.
    
     Sierra keywords are case-insensitive.  Thus the following Sierra statements are all equivalent:


    write "hello world"
    WRITE "hello world"
    wRiTe "hello world"


    Sierra variables on the other hand are case-sensitive. The following statements are not 
    equivalent:

    variable1 = variable2 + variable3
    variable1 = VARIABLE2 + variable3
    variable1 = Variable2 + Variable3    


       Sierra programs consist of blocks, containing zero or more statements.  At the highest level
       a Sierra program consists of two blocks, the global block and the main block.  The main block
       is opened by a begin main tag and ends with an end main tag.  The global block consists of 
       everything outside of the main block, either above begin main or below end main.  As in 
       C/C++, the double-slashes ("//")can be used to indicate a single-line comment anywhere in a
       Sierra program.  Likewise, multi-line comment blocks can be indicated beginning with the 
       character pair "/*" and ending with "*/". 



    // this is a comment
    function foo()
        write "this is function foo"
    end function  // this is the end of the function definition
    /*
      This is a comment
      spanning lines. 
    */

    //The main function is at the top of a file
    begin main
        foo()
        CALL_MY_FUNCTION
    end main

    function fooToo()
        write "this is function fooToo"
    end function   

    macro CALL_MY_FUNCTION  fooToo()
    
    /*
    Note: functions in Sierra don't need to be redeclared with extern as in C 
          when they are used in a different file from which they are created 
          and there is no need to create a prototype of a function.
   */
    
    
    You can pass records and arrays to functions as arguments.
    
    //recursive function
    
    function espressoMachine()
     when (coffee not done)
       //keep making coffee
     call self
    
    end function
    






Sierra Core Data Types

Atomic Variables in Sierra

The basic components of any programming language are variables and literals. Sierra variables 
are untyped and do not have to be declared before use.  Variable names can contain any alphanumeric
character including the "_" (underscore) symbol, but the first character cannot be a number.  
Variables can have the 'var' keyword in front of them when they are declared, but it is not 
necessary.  Variables are assigned to by using the '=' operator.  
    
We will soon add support for multiple variable assignments per line: 

var x = 5, y = 7, z = 10



    Numbers             

    x = 5      // assigns the integer value 5 to the symbolic variable x. 
    var y = 7  // assigns the integer value 7 to the symbolic variable y.
    z = x + y  // assigns the integer value 12 to the symbolic variable z.
   


    Strings

  x = "hello "     // assigns the character string "hello" to the variable x
    
  var y = "world"  // assigns the character string "world" to the variable y
    
  z = x + y        // assigns the character string "hello world" to the variable z

  var info = " this is a long string      //multiline string
      that spans many lines and we don't
      have to have slashes on the end
      and then we end it this way "
      
  r = y + "be free"
    // appends "be free'" to the end of y  creating  r = "world be free"  
    // with string combining a space is added automatically inbetween

  if (string1 = string2) then    //notice only one = sign is used

  x = string1.length             //uses dot syntax and the length of a string is true length
  
  if (string3 not= string4) then //can use not=, not equal, not eq 
  
  read new string
  write string
  
  copy string2 to string3
  
  string1 + string2              //joins strings so string1 now contains both strings
  
  search for  "money" in stringexample 
  
  string.lowercase
   
  string7 = "can't this work"   //no escape character necessary can\'t
  
  string.uppercase
  
  string.capitalize
  
  string.notnumber
  
  convert string to number //converts to integer
  
  space //" " 
  


 Note: strings end with an automatic newline \n and so it's unnecessary to put an \n at the end of string
 

   Booleans

    x = true          // assigns the boolean value 'true' to x
    
    y = TRUE          // assigns the boolean value 'true' to y  ( keywords are case-insensitive)
    
    var z = False     // assigns the boolean value 'false' to z 
    
    z = TruE          // assigns the boolean value 'true' to z 
   
    if (x = true) then//not if (x) then
   
    if (x not true) then
   
    if (y = false) then
   
    set x to true or set x = true  
   
   
   

Arrays 

    Arrays in Sierra can be declared explicitly using the 'create array' directive: 

    create array myListArray = [5, 6, true, "a string"]
    /* creates an array called myListArray containing 4 elements: 2 numbers, 
        a boolean, and a string   */
     

    Sierra arrays are indexed starting at 1 (and not 0 as in other languages).  The elements in
    a Sierra array can be accessed using the bracket ("[]") operator like so:
    

    create array myListArray = [5,6]     // creates an array called myListArray with 2 numerical elements
    x = myListArray[1] + myListArray[2]  // assigns the integer value 11 to the variable x 
    z = myListArray[1]                   // z = 5
  
    The number of elements in an array can be accessed using the '.length' operations, like so:

    x = myListArray.length               // assigns the integer value 2 (the number of elements in myListArray)
       
   A variety of shorthand mechanisms exist for instantiating arrays in Sierra:    

    create array arrayB = [5 thru 10]    // creates an array called 'arrayB' containing the integer values 5,6,7,8,9 and 10.
    create array arrayC = [5 until 10]   // creates an array called 'arrayC' containing the integer values 5,6,7,8 and 9.
    write arrayC[2]                      // prints the 2nd array element in arrayC, which contains the integer value 6, to the console             
    create array arrayA = [5 random]     // creates an array called 'arrayA' containing 5 random integers
    sort array months[]                  //alphabetically for strings by default



Array language not yet supported but will offer support soon:
   get first item of array2
   get last item of array2
   delete first item of array2
   delete last item of array2
   put "word" at beginning of array1
   put 'word" at end of array1
   search array2 for "word"
   array1 + array2 //joins arrays



Records

    Aggregate types in Sierra are called 'records', (replacing structs in C) they consist of a 
    list of one or more variables, referenced under one name.  Record types can be defined at 
    the global level (outside of the main block) like so:

    record Pixel 
        x, y, z 
    end record            // create a record type that has 3 variables named x,y and z 

    Once an aggregate has been defined, it can be instantiated in the main portion of the Sierra 
    program and its member variables accessed with either the '@' or '.' operators:

    new Pixel myPixel
        x=5, y=6, z=7 
    end new  
     /* creates a new symbolic variable of type Pixel called 'myPixel' 
      and sets its x,y and z field members to 5,6 and 7 respectively  */
    myPixel.x = 7          // change the field member x of record myPixel to the integer value 7
    
    y@myPixel = 10  // change the field member y of record myPixel to the integer value 10
    
    myValue = myPixel.z    // set the variable myValue equal to the value of the member z of record myPixel
    
    alias pixy for Pixel   //alias name  synonym for record name
   
   


Sierra Operators

   Sierra has the standard set of operators for acting on variables and literals, and order of 
   precedence can be indicated with parenthesis.
   
 Mathematical Operators

    a = 5 * 5     // multiplication, assigns the integer value of 25 to variable a
    
    b = 5 + 7     // addition, assigns the integer value of 12 to variable b
    
    c = 7 - 2     // subtraction, assigns the integer value of 5 to variable c
    
    d = 12 / 2    // division, assigns the integer value of 6 to variable d
    
    e = 5^2       // exponentiation, sets the integer value of 25 to variable e
    
    f = 12 mod 6  // modulo operator, sets the integer value of f to 2 
    
    g = "the number " + 42  
     /* sets the variable g to string value "the number 42". 
      Adding a number to a string always concatenates the number as a character */ 
   
    h = (5 + 6) + " is the number"     // sets the variable h to the value "11 is the number" 


 
Comparison and Equality Operators

    a = 5 > 4       // sets the variable a to the boolean value 'false'
    
    b = 5 < 10      // sets the variable b to the boolean value 'true'
    
    c = (5 >= 5)    // sets the variable c to the boolean value 'true'
    
    d = 5 <= 6      // sets the variable d to the boolean value 'true' 
   
    e = (5 = 5)
   /* Sets the variable e to the boolean value 'true'. 
      Note that the first '=' symbol is interpreted as an assignment operation, 
      while the second is a comparion  */
    e = (y = z)   // sets the variable e to the boolean value 'false' if y is not equal to z, and 'true' 
 
 if y is equal to z
 
 f = true and false   // sets the variable f to the boolean value 'false'
 
 f = true or false    // sets the variable f to the boolean value 'true'





Global Block Commands

    These are statements that can be issued outside of any control block in a Sierra program. Such 
    global-level statements are generally reserved for definitions, project management, and 
    translator directives.

Includes

    Since Sierra is built on top of C99, C standard library functions are available by default.
    And the entire C standard library is included by default. It is also possible to  instruct the 
    compiler to include a C library in your program with the include statement.  When the include
    statement is used, there is no need to place a '.h' file  extension at the end of the library name.
    Should there be multiple files in a Sierra source code, the Sierra translator will handle 
    declaring the include for all files in the program. 

    include time   // includes the C standard library header <time.h> 

Macros

    Sierra uses both parameterized and unparameterized macros to allow the programmer to do 
    simple text substitutions of Sierra code prior to translation.  These are Sierra-level 
    macros, so the text substituted in will be processed by Sierra.  Macros must be defined at 
    the global level and can then be used within function blocks:
    
     macro MyMacro  An unparameterized macro!
     macro MyParameterizedMacro(x,y)  A parameterized macro with parameters x and y
     begin main
            write "MyMacro"    // will write "An unparameterized macro!" to the console
            write "MyParameterizedMacro(foo, 5)"   // will write "A parameterized macro with 
                                                   // parameters foo and 5" to the console
     end main






Function 

    Functions in Sierra are used to encapsulate a series of Sierra instructions.  They can be 
    defined at the global level like so:
    

    function foo(left, right)
        write "function add called"
        result left + right
    end function


    This creates the definition for a function called foo. The function prints out the message
    "function add called" to the console, and then returns the result of adding the values of the
    left and right variables. Once defined this function can then be called, either from within 
    another function block or from within the main block. Unlike C, there are no function
    prototypes.There are no extern functions either; they all work globally. 

    funcValue = add(5, 2) 
    /* calls the user-defined function foo with the value 'left' equal to 5 
     and the value 'right' equal to 2, and returns the result 7.
     */
     
    funcValue = add("this statement is ", false)   // call the function foo, returning  


    fast function name()  //this is an inline function that runs faster

    //do something
    end function



Function and Main Block Commands
    These are commands and instructions that are primarily intended for embedding inside either 
    a begin main     end main block or inside a function block.
    The are intended to represent explicit instructions to the machine.

Embedded C code

  C99-compliant code can be placed inside of a <C code> block, indicating the the translator should 
  directly insert the text contained withing the C code into the output program: 

     Using simple tags C code can be embedded within Sierra code. 
     
       
          <C code>
           // C code 
           printf("Invalid input.\n");
           for (int k = 0; k < 5; k++){ j+=k; }
          </C code>





Flow Control Structures


If-Else

     Sierra has several constructs for controlling the logical flow of a program.  The first of 
     these is the 'if'  statement, which can also optionally have an 'else' clause:
      
    if (x = 1) then
        write "x is 1"
    else
         write "x is not 1"
    end if 
    // writes "x is 1" if the value of x is the number 1. 
    
    
     if(x = 10 and y = 3) then
        if (z = 100 or a = 5) then
          write var values
     end ifs  //notice we can end with one if with an s
     
     


Switch

    Sierra has a switch block, which is a multi-conditional branching statement used to act 
    according to a variable's value. Different variable types can be checked by the same switch
    block. Within a case defined inside a switch block the fall thru statement can be used to
    indicate that the instructions for the case beneath the current case should also be executed.
    No break statement is needed to indicate the end of a switch statement.  

    x = "D"
    switch (x)
    case 10
        write "case 1"      // this will print out if x is 10
    case "A" thru "E"
        write "case 2"
        fall thru
         /* this will print out if x is a letter between 'a' and 'e', and also 
          execute the instructions in the case below   */
    case "hello"
        write "case 3"
        exit switch
         // this will print out if x is the string "hello"
    default
        write "default!"
         // if none of the cases were satisfied, then the default block is executed
    end switch




Miniswitch

   There is also a miniswitch that chains together a series of conditional branches in a 
   convenient manner that replaces the messy and confusing C else if chain:

    miniswitch
        if (n not 2 or n = 22)
              write "this line will print if n isn't 2 or n is 22."
        if (n not 3 or n = 6)
              write "this statement will print if n isn't 3 or n is 6"
        if ((n = 1) and (n not 1))
              write "This line will never print"
        default
              write "default case, always executes if everything else fails."
    end miniswitch


Loops


       Sierra also contains a number of constructs for expressing loop statements.  What is unique 
       about the Sierra loops is that the counter is implied. Within the scope of a loop statement,
       there are special pre-defined variables available.  The currentloop variable is a numerical 
       value equal to the current iteration of the loop.  Likewise, inside a nested loop the 
       parentloop variable refers to the current iteration of the outer loop. Loops can have names.  
       

    infinite loop
        write "this is an infinite loop"
    end loop
    // prints out "this is an infinite loop" until the program is interrupted by the user
    // all infinite loops will have a default exit loop condition
   
    loop 5 times
        write "this is loop number " + currentloop
    end loop  
    // prints out the numbers 1 to 5

    loop from 5 until 10
        loop 5 times
            write "outer loop is " + parentloop + " and the inner loop is:" + currentloop
    end loops  // closes multiple loops
    // the outer loop will run from 5 thru 9 (but not 10), and the inner loop will run from 1 to 5

    loop from 5 thru 10
        write currentloop     
    end loop  
     // writes out the numbers from 5 thru 10. 
     // ('from... thru...' is a different mechanism than 'from...until...')

    loop until x = false
        if currentloop = 5 then 
            x = false
        end if
    end loop  
     // this loop will run five times and then terminate
   
     // while loop 
    loop while (x < 10) 
        write currentloop
    end loop

     // do while loop // does first loop before condition tested

    loop do while (x < 10)  // upside down do while loop
        write currentloop
    end loop

    exit loop   // instead of break
    next loop   // instead of continue  note: next loop is implied in all loops
    
    
    loop 100 times
      loop until (x = 50) 
        write x 
    end loops   //notice how we can end nested loops

     loop from 100 down to 1
       //do something
     end loop





When

   When statements are a special control block that checks a primary condition and runs in a loop 
   until a closing condition is met.  Optionally a when statement may have an unless clause which 
   causes the loop to break when its condition is true:

write "enter the input now:" 

when (userRequestsInput) then
   read string nextInput
   buffer + nextInput
until (bufferFull = true)
unless nextInput = "<newline>" then
   write "input terminated by user"
end when





File Operations


    Sierra provides a variety of file operations for opening, closing, and manipulating files via 
    file pointers.  Files can be opened in either binary or text mode by specifying the type, if 
    no type is given then text mode is assumed. It is also possible to open the file in read-only,
    write-only, and read-write (by default) modes.  

       // open a file pointer called fp
    open file fp "myFile.txt" for reading and writing

       // sets the current position in the file back to the beginning of the file
       // other possibilities are end and middle
    set filepointer fp to beginning 
    x = get filepointer fp position
       // read the data at the current file position as a string into a variable called s
    read from fp string s
       // closing file pointer
    close file fp

Attempting to write to a file pointer that has not been explicitly opened will result in Sierra
automatically opening a new file with the same name as the variable in text mode. If the file 
pointer is not explicitly closed, then Sierra will automatically close the file once the file 
pointer goes out of scope.  Sierra checks whether a file pointer operation is successful, and 
bypasses commands that deal with the failed file pointer if so.

     // writes 'this is a line of text' to the file myFile
    write to myFile "this is a line of text" 
     // file pointer myFile will be closed if this is the last reference to it

      Currently there are three file operations that can be performed without explicitly 
      creating a file pointer. 

     // rename a file
    change file "myFile.txt" to "newFile"
     // copy file
    copy file "newFile" to "newCopyFile"
     // delete file
    delete file "newFile"    

   
   
   
   swap


    The swap statement switches the values of two variables:
      
    x = 5
    y = 273
    swap x with y  
    write x     // prints the value '273' to the console
    
    

  search


    The search statement can be used to search in files or arrays for the position of a value:
    
   create myArray = [17, 22, true, "a value", "another value", "the right value"] 
    write search myArray for "the right value"  
  // writes the number 6 (the position in myArray of the element being searched for) to the console   
   write search myArray for 17 
   // writes the number  1, the position in myArray of the first element equal to 17    






     Appendix

       C Translation Scheme  

       Each line of Sierra RDC generates between 2 to 8 lines of C99 code, giving the programmer a 
       reasonable degree of control over the machine-level instructions being generated. As a fall-back,
       Sierra also provides a C-embed mechanism that forces the translator to inline user-specified C 
       code.  This allows a programmer to "drill down" and take control of the C foundation when 
       necessary. 
    
       The Sierra translator uses a type inference algorithm to try to make conclusions 
       about which C99 data type a variable should be. When multiple incompatible data types are 
       combined for the same variable, Sierra uses a DynamicVariable struct to represent the variable
       and resolve its type during run-time. While from the programmer's perspective there is no 
       difference between a dynamic and native C type,  variables for which the native C data type 
       can be discerned by the translator at compile-time are obviously going to execute slightly 
       faster than types which cannot be resolved until run-time.  Therefore when it is absolutely 
       essential that a variable resolve to a native C data type, it is recommended to only assign 
       one data type to that variable within a given scope.
    
       For example, the following code will result in the declaration "int x;" appearing somewhere
       in the C99 output:
 
       x = 5             // x is an int in C
       y = 10            // y is an int in C
       x = y             // x is still an int
       x = x + 1         // x is still an int

       By contrast the following code will result in Sierra declaring a dynamic-type variable in 
       your C99 output:
 
       x = 5             // x is an int in C
       y = 10            // y is an int in C
       x = y             // x is still an int
       x = x + 1         // x is still an int
       x = "hello"       // NOTICE: x is now a char*


       Since the variable x cannot change its type in C99, a dynamic variable structure must be used 
       that can determine at run-time whether to treat x as an integer or a string.   Sierra uses the
       following structure to do this:
 
       typedef struct __SierraDynamicVar {
          int type; 
          void* ptr;
       } DynamicVariable;


       The integer field is used to indicate the current C99 type of the data, and the void pointer 
       contains the address to the data.  The table Sierra uses for data type codes is called the 
       Sierra Type Table and is as follows:
    
 


Data Type
Code

Integer
0
String
1
Float
2
Boolean
3
(reserved)
4
(reserved)
5
Dynamic
6
Number Pointer
7
String Pointer
8
Float Pointer
9
Boolean Pointer
10
(reserved)
11
(reserved)
12
Dynamic Pointer
13
File Pointer
14

 
      When a user defines a new record type, this triggers the generation of a corresponding
  struct definition in C99 and the codes for both static and pointer instances of that record 
  type are added to the Sierra Type Table.  For example if the user defines a record type called
 Node then static instances of type  Node will be referred to as type 15 and Node pointers to the 
 record are type 16.  If the user then defines another record type called Edge , then 17 refers to
 the static instances of Edge and 18 refers to a pointer to an Edge , and so on for further
 user-defined structs, with the odd code referring to a static and the even code to a pointer.
  
     Types for function parameters are determined based on how the function is used in the program.
  Parameters that need to be multi-typed are converted to dynamic, while parameters that are 
  always called with the same type are rendered as an appropriate native C type.  Likewise for
  function return types, all of the result statements in the function block are collected and
  examined to see which data types are returned.   
  
     Sierra loops correspond to "for" loops in C.  For each loop  statement in Sierra, a unique
  integer variable is generated to act as the loop counter using the naming 
  convention "__sierra_loop_var<number>"  where "<number>" is a unique number assigned to the
  current loop.  The current loop counter can be accessed with the 'currentloop' keyword, and 
  the parent loop counter is accessed with 'parentloop'.     
     
 

Operator Precedence Table

 


Operators
Description
@, ., []
Aggregate element resolution operators
exp, *, /, mod
Multiplication, division, modulo
+, -
Addition, subtraction
<,>,<=,>=, eq, is, not, not=, 
not equal
Comparison Operators

and, or, not
Logical Operators



 
     

Under Immediate Development

    * Multiple variable assignments per line:

      var x = 5, y = 7, z = 8 // assigns x,y, and z

  * Operators for conjoining words into sentences:
      use sentenceBuilder
     "Keep" + "moving" + "forward" // yields "Keep moving forward."
 
  * Resizable arrays, new array initializers and operations
  * Tree and Linked List Standard data structures
  * Label and Goto statements
  * Global variables accessible across multiple files in a project:
      global var Epsilon = 6.4

Future Development


  * Smart C embedding
  * Memory management model
  * Full Coverage of C Standard Library



 later implementation
      

except
between
empty
eval
null
between
before
after
any
some
none
location
sum
average
max
min
sigma
it
random number
range from x to n
positive
negative
even
odd



numbers can be used with commas like 20,000,000  
and numbers can be written in the human format like 20M or 15k


Bitwise Operators

bit.and
bit.or
bit.xor
bit.not
shiftleft
shiftright
flip
set
clear
invert

examples:
set bit 3 to 0
set bits 2 and 3 in a
clear bit 5 in a
invert bit 1 in a
flip bit 2 in a

Other comamnds

get cpu time used
get current calendar time

Sierra knows the value of pi and e  (3.141592653)  (2.71828183)



Algebra  Chalkboard Math

i * 3  //not i *= 3

i + 1  //not i++

result with 3 decimals



   Conditional terms
   
   
if (x ok) then //means x not= null and x not= empty


      


Other Features

change string1 to lowercase
change string2 to uppercase
end of file //instead of EOF
file's end //instead of EOF

character //instead of char

//conserving typing
if (pBST or pKey = null) then  //rather than if(pBST = null or pKey = null) then 

//no count++ 
//no  ++count
//no count = count + 1

count + 1

get memory byte size
bitwise operators

goto




Global Variables

     Sierra has some knowledge and intelligence to simplify what is expected by
the programmer. Therefore when a global variable is declared in any file it is
accessible to all other files in a project and there is no need to redeclare it in
any other file before using it.

      
          global var drink = "iced tea"
   

Include files

     Sierra has some knowledge and intelligence to simplify what is expected by
the programmer. Therefore when an include file is declared in any file it is
accessible to all other files in a project and there is no need to redeclare it in
any other file before using it.      
   
         include file California.s  //notice no need for quotes nor # sign



Other Sierra Commands




goto

if (i = 2 and j = 1) then

  goto end
  
end if

end:





    


words that will be added to the Sierra language

string, substring, array, list, has, table, get, put, set,  let, loop, it, from,
find,next,line,  word,words, search, swap, but,by, only, most, must, any, some, unless, 
until, when,while, except, where, with
and,or,not, but, next, before, after, of, in, into, read, write, location,
period, comma, all, every, end otherwise, and, is,in,  are, at , empty,each,
contains, copy, memory, stop,some, many, most, must, string, delete, error, every, 
exception, exit, file, first, from, into, invalid, just, first, last,fail,failed, succeed,
line, on, off, true, false, position, proceed, queue, random,split,
record, records, release, remainder, rename, replace, reverse, round, 
sentence, separate, sequence, set, size, sort, space, spaces, 
start, status, stop, sum, than through, thru, time, to, test, other, order
whenever, ok, between, at, append, by, continue, exists, also, every, same,
ascending, descending, reverse, array, goto, is, loop, range, mod, delay,
let, this, wait, times, reset, replace, head,tail
upto, downto, foreach, max, min, correlation, percent
declare, default, convert, empty, nothing, item, backwards, capitalize, alphabetical order,
remove, insert, pass thru, skip,