The C-- Language Reference Manual

Simon Peyton Jones   Thomas Nordin   Dino Oliva   Pablo Nogueira Iglesias

May 23,1999

1   Introduction

2   Syntax definition

2.1   General

2.2   Comments

2.3   Names

        x
        foo
        _912
        aname12
        _foo.name_abit_12.long
        Sys.Indicators

        .9Aname
        3illegal

2.4   Name scope

2.5   Reserved words

abs% absf% align C data default else eexponentf% xport float32
float64 foreign fractionf% fractpartf% global goto if intpartf% import
jump neg% negf% predf% register return roundf% scalef% sign% signf%
stack succf% switch truncf% ulpf% bits8 bits16 bits32 bits64

2.6   The import and export declarations

  import printf, sqrt; /* C procedures used in this C-- program */
  export foo, bar;     /* To be used outside   this C-- program */

2.7   Constants

2.7.1   Integer and floating point numbers

2.7.2   Characters and strings

unicode(constant)

3   Fundamental concepts in C--

3.1   Memory

3.2   Data segment

3.3   Code segment

3.4   Types

• The size of a bits can be 8, 16, 32 or 64 bits.
• The size of a float can be 32 or 64 bits.

1. Local variable declarations (Section 5.2.1), to declare the type of local variables.
   
   
2. Memory write statements and memory read expressions (Section  5.3.3 and Section  6.2, respectively) to indicate the type of the value written/read.
   
   
3. Data layout directives (Section 4) to indicate the type of the allocated datum.

3.5   Local variables (or registers)

3.6   Global variables

  global {
    bits64 hp;
  }

  global {
    bits64 hplim "%ebx";
  }

3.7   Addresses

3.8   Names

3.9   Foreign language interface

4   Data layout directives

  data {
    foo:  bits32[4]{1,2,3,ff};  /* ff is a forward reference */
          bits16[4]{1,2};
    ff:   float64[2]{2.8,3.1}; bits32[2]{ff,foo};
    str:  bits8[]"Hello world\0";
    ustr: bits16[]unicode("Hello world\0");
          bits8;
    xs:   bits64[]{"This is an", "array of", "bits64's"};
  }

4.1   Labels

  data { foo: label1: label2: bar: bits32} /* just allocates */

  data { foo: align8;
         bar: bits32{0}; 
       }

4.2   Initialisation

type[n]{constant- list};

1. If [n] is not provided, only one element is allocated. The {constant-list} may or may not be provided. If provided, it should contain only one constant or constant expression to which the element is initialised. If not provided, no initial value is given. For example:
   
   

     data { lb1: bits8; }
      /* Allocates one byte (contains garbage) */
     data { lb2: bits8{17}; }
      /* Allocates one byte and initialises it to (ASCII code) 17 */
     data { lb3: bits32{17}; }
      /* Allocates one 4-byte word and initialises it to integer 17   */
   

2. If [n] is provided, then n elements are allocated. The {constant-list} may or may not be provided. If not provided, no initial value is given. If provided, it should contain c constants or constant expressions, such that c £ n. Element i (i:0 ... (n-1)) is initialised to the value of the constant or constant expression j (j:0 ... (c-1)) in {constant-list}, such that j = i mod c. For example:
   
   

     data { lb1: bits8[17]; }
      /* Allocates 17 bytes (that contain garbage) */
     data { lb2: bits8[17]{0}; }
      /* Allocates 17 bytes and initialises all of them to 0 */
     data { lb3: bits32[6]{1,2,3}; }
      /* Allocates six 4-byte words and initialises them 
       * to 1,2,3,1,2,3 respectively. 
       */
     data { lb4: bits32[6]{1,2,3,1,2,3}; }
      /* Allocates six 4-byte words and initialises them 
       * to 1,2,3,1,2,3 respectively.
       */
     data { lb5: bits32[4]{1,2,3}; }
      /* Allocates four 4-byte words and initialises them
       * to 1,2,3,1 respectively.
       */
   

3. There is also the possibility to have abbreviations when n = c.

   type [] {constant-list} ;	is an abbreviation for	type [c] {constant-list} ;
   bits8[]"char1 ... charn";	is an abbreviation for	bits8[n]{' char1 ', ... ,' charn '};
   bits16[]unicode(" char1 ... charn ");	is an abbreviation for

   
                       bits16[n]{unicode('char₁'),...,unicode('char_n')};
   
   For example:
   
   

     data { s1: bits8[6]{'h','e','l','l','o','\0'}; }
     data { s2: bits8[]"hello\0"; }  
      /* Both directives  allocate 7 bytes and initialise
       * them to the same ASCII code integers.
       */ 
     data { f1: float64[3]{3.5, 4.4, 6.98}; }
     data { f1: float64[] {3.5, 4.4, 6.98}; }
      /* Both directives allocate three 8-byte floats and initialise
       * them to the same floating point numbers.
       */
   

4.3   Alignment

  data { align4;
         foo: bits32{1};
         align8;
         bar: float64{1.7};
       }

  data { foo: bits8;
         align4;
         align8;
         align2;
         bits8;
         align4;         
       }

5   Procedures

5.1   Procedure definition

[conv] proc_name(type arg₁,...,type arg_n) [data] { body }

• conv is the (optional) calling convention declaration (Section  5.4) needed for inter-operation.
• proc_name is the procedure name, which stands for the procedure entry point address and, as a name, will be an expression (Section 3.8). It may be also used in call (Section 5.3.7) and jump (Section 5.3.8) statements.
• type arg₁,..., type arg_n is the formal argument list. Each formal argument consists of a name preceded by its type. If the procedure takes no arguments, the list should be empty. Unlike C, procedures with a variable number of arguments are not supported. The formal arguments are only in scope of the procedure body.
• data is the (optional) data declaration.
• body is the procedure body enclosed in curly braces. It consists of a (possibly empty) sequence of local declarations (variable declarations and stack directives), followed by a (non-empty) sequence of statements, such as assignments, memory writes, local control label declarations, gotos, etc. It is unspecified what happens if control flows off the edge of a procedure body, that is, every control path in a procedure body should finish in a jump (Section 5.3.8) or in a return (Section  5.3.9) statement. That is why a procedure body should have at least one (non null) statement.

  foo(bits32 y) {
    bits32 x;
    
    x = y + 1;
    jump bar(x);
  }

5.2   Local declarations

5.2.1   Local variables

type name₁,...,name_n ;

5.2.2   Stack directive

  f (bits32 x) {
    bits32 y;

    stack { p : bits32;
            q : bits32[40];
    }
    /* Here, p and q are the addresses of the relevant chunks of
       data. Their type is the native pointer type of the machine. */
  } 

5.2.3   Names usage

5.3   Statements

5.3.1   Null statement (;)

5.3.2   Assignment

name = expr ;

5.3.3   Memory write

bitsn[expr₁] = expr₂ ;

floatn[expr₁] = expr₂ ;

bits8[label+4] = 'A';

bitsn{aligna} [expr₁] = expr₂ ;
floatn{aligna} [expr₁] = expr₂ ;

• float64{align4}[label] = expr does a 8-byte write but assumes that label is aligned to a 4 byte boundary.
  
  
• bits32{align1}[label] = expr does a 4-byte write but assumes that label is aligned to a byte boundary (pointer to a byte).
  
  
• bits8{align4}[label] = expr does a 1-byte write but assumes that label is aligned to a 4 byte boundary.

5.3.4   if and relational operations

if expr₁ rel expr₂ { ...} [ else { ...} ]

if x == 0 { x = x + 1;}

  f(bits32 x)
  {
    bits32 y;

    y = 0;
    if y >= bits32[foo+8] {
      y = y + 1;
      return (y);
    } else {
      x = x -u 1;
      if x !=u 0 {
         y = y + 2;
      }
      return (y);
    }
  }           

5.3.5   switch

switch [sconst₁..sconst_n] expr {

sconst11 , ... , sconst1i	: { ... }
· · ·
sconstm1 , ... , sconstmj	: { ... }
default	: { ... }

}

• expr is an expression that yields a bitsn value.
  
  
• sconst_k1 , ... , sconst_kl : { ... } is branch k (k:1... m), in which multiple simple-constant² alternatives (l:1... i,j...) may be specified.
  
  When the value of expr is any of sconst_k1... sconst_kl, branch k is taken, executing its block of statements and resuming control at the first statement after the switch. There is no fall through between different branches: C-- assumes that earlier branches are more likely to be taken.
  
  
• default is the (optional) default branch that is taken when none of the others are taken. The effect is unspecified if none of the branches are taken---none of the sconst_ij match expr's value---and no default branch is provided.
  
  
• [sconst₁..sconst_n] is an (optional) range of simple constants in which the value of expr is guaranteed to be. This range is a hint to the compiler. No bounds checking is performed at run-time to see whether expr's value is in the range.
  
  

  switch [0..7] x + 23 {
    1,2,3   : { y = y + 1;} 
    5       : { y = x + 1; x = y;} 
    default : { y = f();
                if y == 0 { x = 1;}
              } 
  }

5.3.6   Local control labels and goto

  bar()
  {
  label:
    bits64[foo] = 18;
    bits64[foo+4*8] = bits64[bar];    
    goto label;
    return();
  }

5.3.7   Procedure call

[ conv ] [ name₁,...,name_n = ] expr( [ expr₁,...,expr_m ] );

• name₁,...,name_n = is the local variable name list. The results returned back by the procedure are stored in each variable in the order in which they are returned, from left to right, by the invoked procedure's return statement (Section  5.3.9). If the invoked procedure returns no values, the name list should be omitted, otherwise the values of the names are unspecified after the call.
  
  
• conv is the (optional) calling convention declaration needed for inter-operating with foreign code. (Section 5.4)
  
  
• expr is any expression that evaluates to a procedure address. It will typically be a (procedure) name.
  
  
• expr₁,...,expr_m is the (optional) actual argument list, where each actual argument expr_i is an expression. All the expressions are passed by value to the called procedure. If no arguments are passed, the list should be empty, as in, for example, x = f();.

5.3.8   jump

jump expr(expr₁,...,expr_n);

• expr is any expression that evaluates to a procedure address. It will typically be a (procedure) name.
  
  
• expr₁,...,expr_n is the (optional) actual argument list, where each actual argument expr_i is an expression. All the expressions are passed by value to the target procedure. If no arguments are passed, the list should be empty, as in, for example, jump bar ();.

  bar(bits32 x, bits32 y)
  {
    jump bar(y, x);   /* Loop forever */
  }

5.3.9   return

[ conv ] return (expr₁,...,expr_n);

  bar(bits32 z)
  {
    return (1+z, z/3);
  {
  foo(bits32 z)
  {
    return ();
  {

5.4   Foreign language interface

  export foo;
  foreign C foo() 
  {
    bits32 x;
    jump bar(x);
  }

  import printf, fun;
  goo()
  {
    bits32 i;
    foreign C fun(5);  
        /* fun has type int -> void  */
    foreign C i = printf(str, arg); 
        /* printf() returns an int   */
    return ();
  }
  bar(bits32 a)
  {
    a = a + 1;
    foreign C return (a); /* uses C's convention to return 'a'   */
  }

1. C
2. Pascal

6   Expressions

6.1   Introduction

6.2   Memory read

bitsm[expr]
Type: bitsn ® bitsm

floatm[expr]
Type: bitsn ® floatm

bits32[p+1]

bitsm{aligna} [expr]
floatm{aligna} [expr]

• float64{align4}[label] reads a 8-byte float but assumes that label is aligned to a 4 byte boundary.
  
  
• bits32{align1}[label] reads a 4-byte bits but assumes that label is aligned to a byte boundary (pointer to a byte).
  
  
• bits8{align4}[label] reads 1-byte but assumes that label is aligned to a 4 byte boundary.

6.3   Operators, precedence, and evaluation order

6.4   Primitives

prim_name(expr₁,...expr_n)

6.5   Exception handling

  foo(bits32 y) {
    bits32 x;
    
    x = y +t y
    if Sys.Indicators & Sys.IntegerOverflow { 
        /* Write here code to handle exception */

        /* Clear handled exception */
        Sys.Indicators = Sys.Indicators & ~Sys.IntegerOverflow;
    } 
 }

6.6   Casting

6.6.1   bitsn

6.6.2   floatn

6.7   bits operators and primitives

6.7.1   + and -

6.7.2   *

6.7.3   /

6.7.4   %

6.7.5   neg% and abs%

6.7.6   sign%

6.7.7   &, |, and ^

6.7.8   ~

6.7.9   << and >>

6.8   float operators and primitives

6.8.1   +f, -f, and *f

6.8.2   /f

6.8.3   signf%

6.8.4   negf% and absf%

6.8.5   exponentf%

6.8.6   fractionf%

6.8.7   scalef%

6.8.8   succf% and pred%f

6.8.9   ulpf%

6.8.10   truncf%

6.8.11   roundf%

6.8.12   intpartf% and fractpartf%

7   Further Work

Expressions and constants

• Add w/ carry operator missing.
  
  
• Be more specific about number constants and their syntax. Saying that they're like C's is not enough.
  
  
• Regarding pointers.
  
  Pointer arithmetic, e.g.: float32[ptr + i] = float32[ptr];
  
  If natural pointer size is 8 then ptr has type word64; adding integer offset register i (say, of type word32), if numbers have word32 type then expression ptr+i needs a explicit casting: ptr + word64(i). More architecture-dependancy in the code. (See ``Preprocessing'')

Preprocessing

        word32[label+ word64(3)] = 43;

        #ifdef ... /* pointer size == integer size == 8*/
        #then 
          #define CAST(x) (x)
        #else      /* pointer size != integer size == 4 */
          #define CAST(x) word64((x))

        word32[label+CAST(3)] = 43;

Statements

• Explain better how the optional range improves compiler performance in the switch statement.

1

UTF-8 is an encoding of Unicode characters into 8-bit ASCII characters that does not use any of the ASCII control characters to perform the coding. Unicode is an abbreviation for Universal Multiple-Octet Coded Character Set (UCS), and it is defined in ISO/IEC 10646. It is an international standard for encoding computer character sets that differs from historical ASCII. UTF-8 stands for Universal Transformation Format, 8-Bit form. See http://www.unicode.org/unicode/standard/utf8.html for more information.

2

That is, bits integers or characters. See Figure 1.

3

Sys.Indicators may be viewed as a global variable, but indeed, it is the only possible global variable in a C-- program.

This document was translated from L^AT_EX by H^EV^EA.