Sphinx C-- documentation

Updated September 14, 2002. Under construction.

Partially based on a document by Peter Cellik, May 1995.
I used Peter's document as a starting point, but ended up totally rewriting it. There are several paragraphs remaining that can be traced back to Peter's document, and due acknowledgement is given here.

I am using C-- to develop applications for the MenuetOS operating system, so the main thrust of this page is 32-bit FLAT memory coding. However, the compiler itself runs at the DOS commandline, and can produce output for DOS 16- or 32-bit or for Windows 32-bit apps or DLLs. The official Sphinx C-- project page has example code, libraries, etc: http://www.sheker.chat.ru/index_e.htm. My own C-- introductory page is: http://www.goosee.com/cmm/. My MenuetOS page is: http://www.goosee.com/menuetos/.

Note that Michael Sheker's C-- "readme" file has been translated to English, and is included with the full package downloadable from his site. It is in places difficult to read, due to the fact that it is a translation, and also it is basically a historical record of changes introduced with each version. It is useful as a reference in conjunction with this document. I am sifting through it and have extracted the most important information to this page.

Michael has provided me with assistance. He has supplied some more translated files, and I have incorporated most of them  into this document, by rewriting them in a format that seems to me like readable English. Due acknowledgement is also given here of that source.

This document is based on my very limited experience with C--, and input is welcome.
Please use Mozilla Composer if you would like to contribute to updating this page! (see www.goosee.com/best/).
You might like to add text in some other color, such as red, prior to me vetting it and making it black.
-- email any updates to me. Find my email address at: http://www.goosee.com/bkauler/.

Contents

Introduction
Identifiers and symbols
Constants
Data types
Expressions
Declaring functions and macros
Conditional statements
Arrays
Structures
Pointers
Other syntax
Internal macros
Inline assembly
Directives and commandline options
Appendices
    How to install C--
    Further documentation

Introduction

Identifiers and symbols

Identifier naming

Some examples of valid C-- indentifiers are:

_DOG
CoW
loony12
HowdYBoys_AND_Girls
WOW___
x

12bogus              /* cannot start an identifier with a numerical digit */
y_es sir             /* spaces not allowed */
the-end              /* hyphens not allowed */

Symbols

SYMBOL | FUNCTION               | EXAMPLE
------------------------------------------------------------------------
  /*   | start comment block    | /* comment */
  */   | end comment block      | /* comment */
       |                        |
  //   | comment to end of line | // comment
       |                        |
   =   | assignment             | AX = 12;
   +   | addition               | AX = BX + 12;
   -   | subtraction            | house = dog - church;
   *   | multiplication         | x = y * z;
   /   | division               | x1 = dog / legs;
   &   | bitwise AND            | polution = stupid & pointless;
   |   | bitwise inclusive OR   | yes = i | mabe;
   ^   | bitwise exclusive OR   | snap = got ^ power;
  <<   | bit shift left         | x = y << z;
  >>   | bit shift right        | x = y >> z;
       |                        |
  +=   | addition               | fox += 12;   // fox = fox +12; 
  -=   | subtraction            | cow -= BX;   // cow = cow - BX;
  *=   | multiplication         | cow *= dog;  // cow = cow * dog;
  /=   | division               | cow /= dog;  // cow = cow / dog;
  &=   | bitwise AND            | p &= q;      // p = p & q; 
  |=   | bitwise inclusive OR   | p |= z;      // p = p | z; 
  ^=   | bitwise exclusive OR   | u ^= s;      // u = u ^ s; 
  <<=  | bit shift left         | x <<= z;     // x = x << z 
  >>=  | bit shift right        | x >>= z;     // x = x >> z
       |                        |
  ><   | swap                   | x >< y;  /* exchange values of x and y */
       |                        |
  ==   | equal to               | IF(AX == 12)
   >   | greater than           | IF(junk > BOGUS)
   <   | less than              | if( x < y )
  >=   | greater or equal to    | if(AX >= 12)
  <=   | less than or equal to  | IF(BL <= CH)
  !=   | not equal to           | IF(girl != boy)
  <>   | different than         | IF(cat <> dog)  /* same function as != */
       |                        |
   @   | insert code            | @ COLDBOOT();  /* insert COLDBOOT code */
   :   | dynamic procedure      | : functionname () // declare functionname
   $   | assembly operation     | $ PUSH AX      /* push AX onto stack */
   #   | offset address of      | loc = #cow;    /* loc = address of cow */
   #   | compiler directive     | #define cow dog;
   !   | NOT operator           | !x_var; if(!xflag)
  ...  |any number of parameters| void proc(...);
  ::   |allowing of visibility  | ::var=0;
       |                        |
   ~   |                        | This symbol is currently unused.

Reserved words

BREAK        CARRYFLAG     CASE       CONTINUE      ELSE
EXTRACT      FALSE         FOR        FROM          GOTO
IF           LOOPNZ        MINUSFLAG  NOTCARRYFLAG  NOTOVERFLOW
NOTZEROFLAG  OVERFLOW      PLUSFLAG   RETURN        SWITCH
TRUE         WHILE         ZEROFLAG   
__CODEPTR__  __COMPILER__  __DATAPTR__  __DATESTR__  __DATE__
__DAY__      __FILE__      __HOUR__     __LINE__     __MINUTE__
__MONTH__    __POSTPTR__   __SECOND__   __TIME__     __VER1__
__VER2__     __WEEKDAY__   __YEAR__     
_export      asm           break        byte         case
cdecl        char          continue     default      do
dword        else          enum         extern       far
fastcall     float         for          goto         if
inline       int           interrupt    long         loop
loopnz       pascal        return       short        signed
sizeof       static        stdcall      struct       switch
union        unsigned      void         while        word
ESCHAR       ESBYTE        ESINT        ESWORD       ESLONG
ESDWORD      ESFLOAT       
CSCHAR       CSBYTE        CSINT        CSWORD       CSLONG
CSDWORD      CSFLOAT
SSCHAR       SSBYTE        SSINT        SSWORD       SSLONG
SSDWORD      SSFLOAT
DSCHAR       DSBYTE        DSINT        DSWORD       DSLONG
DSDWORD      DSFLOAT
FSCHAR       FSBYTE        FSINT        FSWORD       FSLONG
FSDWORD      FSFLOAT
GSCHAR       GSBYTE        GSINT        GSWORD       GSLONG
GSDWORD      GSFLOAT
AX CX DX BX SP BP SI DI 
EAX ECX EDX EBX ESP EBP ESI EDI 
AL CL DL BL AH CH DH BH 
ES CS SS DS FS GS ST(0) ST(1) ST(2) ST(3) ST(4) ST(5) ST(6) ST(7) 
ST
st(0) st(1) st(2) st(3) st(4) st(5) st(6) st(7) 
st

ax   cx   dx   bx   sp   bp   si   di
eax  ecx  edx  ebx  esp  ebp  esi  edi
al   cl   dl   bl   ah   ch   dh   bh
es   cs   ss   ds   fs   gs
DR0   DR1   DR2   DR3   DR4   DR5   DR6   DR7
CR0   CR1   CR2   CR3   CR4   CR5   CR6   CR7
TR0   TR1   TR2   TR3   TR4   TR5   TR6   TR7
MM0   MM1   MM2   MM3   MM4   MM5   MM6   MM7
XMM0  XMM1  XMM2  XMM3  XMM4  XMM5  XMM6  XMM7
dr0   dr1   dr2   dr3   dr4   dr5   dr6   dr7
cr0   cr1   cr2   cr3   cr4   cr5   cr6   cr7
tr0   tr1   tr2   tr3   tr4   tr5   tr6   tr7
mm0   mm1   mm2   mm3   mm4   mm5   mm6   mm7
xmm0  xmm1  xmm2  xmm3  xmm4  xmm5  xmm6  xmm7

Automatic registers

  (E)AX = 0;

Predetermined identifiers

__TLS__     there is a compilation under windows (w32, w32c, dll).
__DLL__     there is a compilation of a dll.
__CONSOLE__ there is a compilation of the console windows application.
__WIN32__   there is a compilation of a GUI application.
__FLAT__    the 32-bit code is compiled.
__MSDOS__   the 16-bit code is compiled.
__TINY__    the memory model tiny in 16-bit mode is used.
__SMALL__   the memory model small in 16-bit mode is used.
__DOS32__   the 32-bit code for DOS (d32) is compiled.
__COM__     the com-file is compiled.
__SYS__     the sys-file is compiled.
__ROM__     the rom-file is compiled.
__OBJ__     the obj-file is compiled
__TEXE__    the exe-file of a model tiny is compiled.
__EXE__     the exe-file of a model small is compiled.
codesize    compilation is carried on with optimization on the size of the code.
speed       compilation is carried on with optimization on speed of the code.
cpu         defines the type of the processor for which the compilation is carried on:
     0 - 8086
     1 - 80186
     2 - 80286
     3 - 80386
     4 - 80486
     5 - Pentium
     6 - Pentium MMX
     7 - Pentium II

#ifdef cpu > 3   //if the type of the processor is more 80386

Constants

Numerical Constants

Expressing numerical constants in decimal (base 10) or hexadecimal (base 16) are the same as in C. To express a numerical constant in binary (base 2) notation, the sequence of 1's and 0's are preceded by 0b, with no spaces in between. To express a numerical constant in octal (base 8) notation, the sequence of octal digits (0 to 7) are preceded by 0o with no spaces.

Some examples:

    0b11111111     // binary.      same as 255 decimal.
    0x00F          // hexadecimal. same as 15 decimal.
    0o10           // octal.       same as 8 decimal.

    000Fh
    127AH

#define DEF1 1023L    //"long" (signed 32-bit integer) value.
#define DEF2 2561Lu   //"unsigned long" (unsigned 32-bit integer).
#define DEF3 3.02F    //"float" (32-bit floating point).

Character Constants

Single character constants are, like in C, enclosed in single quotes ('). Also as in C, special characters are expressed by a back slash (\) followed by the key letter or letters. Special characters supported are:

    '\a'    /* beep (same as in C) */
    '\b'    /* back space (same as C)*/
    '\f'    /* form feed (same as C)*/
    '\l'    /* line feed */
    '\n'    /* carriage return (in C called "newline")*/
    '\r'    /* carriage return (same as C)*/
    '\t'    /* horizontal tab */
    '\x??'  /* ASCII character formed from the ?? which would be two
	       hexadecimal digits for the character value */
    '\???'  /* ASCII character formed from the ??? which would be three
	       decimal digits for the character value */

	'ab'
	'the'
	'this is large'

String Constants

The current maximum length of string constants is 2048 characters including the 0 terminator (NULL), thus a maximum of 2047 characters.

Constant Expressions

Some examples of constant expressions are:

45 & 1 + 3         // equals 4
14 - 1 / 2         // equals 6
1 * 2 * 3 / 2 + 4  // equals 7

float y;      //define 32-bit floating-point variable.
  y=80+0.375;

   0.98
   -15.75
   3.14e2
   1.234567E-20

Data types

Types of variables

   NAME   | SIZE  |        VALUE RANGE          |        VALUE RANGE
	  |(bytes)|         (decimal)           |           (hex)
 ----------------------------------------------------------------------------
  byte    |   1   |           0 to 255          |        0x00 to 0xFF 
  word    |   2   |           0 to 65535        |      0x0000 to 0xFFFF
  dword   |   4   |           0 to 4294967295   |  0x00000000 to 0xFFFFFFFF
  char    |   1   |        -128 to 127          |        0x80 to 0x7F
  short   |   2   |      -32768 to 32767        |      0x8000 to 0x7FFF
  long    |   4   | -2147483648 to 2147483647   |  0x80000000 to 0x7FFFFFFF
  float   |   4   | +/-1.17E-38 to +/-3.37E38

  Equivalents:
  byte    |  unsigned char
  int     |  short or long <<<CAREFUL HERE!
  word    |  unsigned short
  dword   |  unsigned long

cpuspeed.c-- 22: char vchar=0;
00000036 0000                     db      0,0
cpuspeed.c-- 23: short vshort=0;
00000038 00000000                 dw      0,0
cpuspeed.c-- 24: int vint=0;
0000003C 00000000                 dd      0
cpuspeed.c-- 25: long vlong=0;
00000040 00000000                 dd      0
cpuspeed.c-- 26: word vword=0;
00000044 0000                     dw      0

Warning about 'int'

Declaring variables

variable-type identifier;

variable-type identifier1, identifier2, ... , identifierN;

variable-type identifier[elements];

variable-type identifier [] = {const1, const2};

char msg1[]="this is a string";
char msg1="this is a string";

Some examples of global declarations:

byte  i,j;       /* declare i and j to be of type byte */
word  ss[10];    /* declare ss to be an array of 10 word's */
short h,x[27];   /* declare h to be of type short and declare x to
                    be an array of 27 short's */
long zz = 0;     /* the variable zz of a type long
                    is declared and it is assigned value 0. */

Compilation and scope of variables

Global variables

char smsg1="CPU speed:";    //compiles right here. Note, square brackets not needed.
dword cpuspeed;             //compiles at end of file.

void draw_window(void)
{
  sys_window_redraw(1);
  sys_draw_window(100<<16+300,100<<16+200,0x001111CC,0x8099BBFF,0x00FFFFFF);
  sys_write_text(8<<16+8,0xFFFFFF,"C-- CPU speed example for MenuetOS",34);
  sys_draw_button(281<<16+12,5<<16+12,1,0x5599CC);
  sys_write_number(4<<16,cpuspeed,25<<16+40,0xFFFF80);
  sys_window_redraw(2);
}
//the function "sys_write_text()" passes address of a string. The string is
//compiled immediately after the function.

dword test1=0;             //compiles right here.
dword test2;               //compiles at end of file.

void main(void)
{
  dword test3=0;          //temporary, created on stack.
  cpuspeed=sys_service(5,0)/1000000; //get CPU speed.
  draw_window();
  while(1)
  {
   switch(sys_wait_event())
   {
    case 1:
     draw_window();
     continue;
    case 2:
     /*sys_get_key();*/
     continue;
    case 3:
     if(sys_get_button_id()==1) sys_exit_process();
     continue;
   }
  }
}

# initallvar TRUE

Local variables

static dword zz;
static long xx=0;

Dynamic variables

 : dword zz;       //the colon prefix makes it dynamic.
 : struct RECT xx;

Expressions

Constant expressions are introduced above. Now we look at expressions involving constants, variables, and registers.
In particular, there is the most important question about the mixing of explicit register names within a C-- expression -- isn't this risky?

Use of registers in C-- expressions

    EAX=y+100<<7;
    EBX=EAX<<2;
    offset1=EAX+EBX+x;

EAX, EDX

long y,x=5;
void main(void) {
  long time=1;
  y=100+90*cos(time*1.5+2.0)/x;

cpuspeed.c-- 52: y=100+90*cos(time*1.5+2.0)/x;
00000131 DB45FC                   fild    [ebp-4]
00000134 D80DB8010000             fmul    [1B8h]
0000013A D805BC010000             fadd    [1BCh]
00000140 D9FF                     fcos
00000142 50                       push    eax
00000143 DB1C24                   fistp   [esp]
00000146 58                       pop     eax
00000147 69C0BE000000             imul    eax,eax,0BEh
0000014D 99                       cwd
0000014E F73D04010000             idiv    dword ptr [104h]
00000154 A3D0010000               mov     [1D0h],eax

cpuspeed.c-- 52: y=100+90*EAX*cos(time*1.5+2.0)/x;
00000131 69C0BE000000             imul    eax,eax,0BEh
00000137 50                       push    eax
00000138 DB45FC                   fild    [ebp-4]
0000013B D80DBC010000             fmul    [1BCh]
00000141 D805C0010000             fadd    [1C0h]
00000147 D9FF                     fcos
00000149 50                       push    eax
0000014A DB1C24                   fistp   [esp]
0000014D 58                       pop     eax
0000014E 5A                       pop     edx
0000014F F7EA                     imul    edx
00000151 99                       cwd
00000152 F73D04010000             idiv    dword ptr [104h]
00000158 A3D4010000               mov     [1D4h],eax

cpuspeed.c-- 52: y=100+90*EAX*cos(time*1.5+2.0)*EDX/x;
00000131 69C0BE000000             imul    eax,eax,0BEh
00000137 50                       push    eax
00000138 DB45FC                   fild    [ebp-4]
0000013B D80DBC010000             fmul    [1BCh]
00000141 D805C0010000             fadd    [1C0h]
00000147 D9FF                     fcos
00000149 50                       push    eax
0000014A DB1C24                   fistp   [esp]
0000014D 58                       pop     eax
0000014E 5A                       pop     edx
0000014F F7EA                     imul    edx
00000151 F7EA                     imul    edx
00000153 99                       cwd
00000154 F73D04010000             idiv    dword ptr [104h]
0000015A A3D4010000               mov     [1D4h],eax

ECX

cpuspeed.c-- 52: loop(count) y=100+90*cos(time*1.5+2.0)/x;
00000138 DB45F8                   fild    [ebp-8]
0000013B D80DC4010000             fmul    [1C4h]
00000141 D805C8010000             fadd    [1C8h]
00000147 D9FF                     fcos
00000149 50                       push    eax
0000014A DB1C24                   fistp   [esp]
0000014D 58                       pop     eax
0000014E 69C0BE000000             imul    eax,eax,0BEh
00000154 99                       cwd
00000155 F73D04010000             idiv    dword ptr [104h]
0000015B A3DC010000               mov     [1DCh],eax
00000160 FF4DFC                   dec     dword ptr [ebp-4]
00000163 75D3                     jne     138h

  loop(ECX) y=100+90*cos(time*1.5+2.0)/x;

EBX, ESI, EDI

cpuspeed.c-- 55: EBX=*z+EAX<<2/x;
00000178 8B1D18020000             mov     ebx,[218h]
0000017E 8B1B                     mov     ebx,[ebx]
00000180 01C3                     add     ebx,eax
00000182 B102                     mov     cl,2
00000184 D3E3                     shl     ebx,cl
00000186 93                       xchg    ebx,eax
00000187 31D2                     xor     edx,edx
00000189 F73504010000             div     dword ptr [104h]
0000018F 93                       xchg    ebx,eax

cpuspeed.c-- 53: *z=100+90*cos(time*1.5+2.0)/x;
00000138 DB45F8                   fild    [ebp-8]
0000013B D80DC0010000             fmul    [1C0h]
00000141 D805C4010000             fadd    [1C4h]
00000147 D9FF                     fcos
00000149 50                       push    eax
0000014A DB1C24                   fistp   [esp]
0000014D 58                       pop     eax
0000014E 69C0BE000000             imul    eax,eax,0BEh
00000154 99                       cwd
00000155 F73D04010000             idiv    dword ptr [104h]
0000015B 8B1DDC010000             mov     ebx,[1DCh]
00000161 8903                     mov     [ebx],eax

cpuspeed.c-- 55: EBX=*z+EBX+EAX<<2/x; //stuffs up the value in EBX!

cpuspeed.c-- 57: EBX=*z+*zz;
00000138 8B1DB8010000             mov     ebx,[1B8h]
0000013E 8B1B                     mov     ebx,[ebx]
00000140 8B35BC010000             mov     esi,[1BCh]
00000146 031E                     add     ebx,[esi]

cpuspeed.c-- 58: EBX=*z+*zz+*zzz;
00000138 8B1DC0010000             mov     ebx,[1C0h]
0000013E 8B1B                     mov     ebx,[ebx]
00000140 8B35C4010000             mov     esi,[1C4h]
00000146 031E                     add     ebx,[esi]
00000148 8B35C8010000             mov     esi,[1C8h]
0000014E 031E                     add     ebx,[esi]

cpuspeed.c-- 58: y=*z+*zz+*zzz;
00000138 8B05C8010000             mov     eax,[1C8h]
0000013E 8B00                     mov     eax,[eax]
00000140 8B1DCC010000             mov     ebx,[1CCh]
00000146 0303                     add     eax,[ebx]
00000148 8B1DD0010000             mov     ebx,[1D0h]
0000014E 0303                     add     eax,[ebx]
00000150 A3C4010000               mov     [1C4h],eax

struct test {short a;char b[8];long c;} rr[5];
dword i,k;

cpuspeed.c-- 71: rr[i].b[k] >< rr[i+1].b[k+2];
00000127 8B352C020000             mov     esi,[22Ch]
0000012D 8B3D28020000             mov     edi,[228h]
00000133 6BFF0E                   imul    edi,edi,0Eh
00000136 8A843EE4010000           mov     al,[esi+edi+1E4h]
0000013D 8B3D2C020000             mov     edi,[22Ch]
00000143 83C702                   add     edi,2
00000146 8B1528020000             mov     edx,[228h]
0000014C 42                       inc     edx
0000014D 6BD20E                   imul    edx,edx,0Eh
00000150 868417E4010000           xchg    [edi+edx+1E4h],al
00000157 88843EE4010000           mov     [esi+edi+1E4h],al

    EAX=y+100<<7;       //do NOT insert another statement between...
    EBX=EAX<<2;         //do NOT always expect EAX to be preserved!
    offset1=EAX+EBX+x;  //AVOID using EBX in an expression!

#warning TRUE

wf=file_name

Conditional Expressions

Conditional expressions are expressions which are used for generating a 'yes' or 'no' for 'if' statements and 'do {} while' loops.

There are two types of conditional expressions, simple and complex.

Simple Conditional Expressions

Simple conditional expressions are a single token or expression that will be taken as a 'yes' if the calculated value is non-zero, or a 'no' if the calculated value is zero.

Complex Conditional Expressions

Complex conditional expressions are of the following form:

    ( leftside compare_op rightside )

    "leftside"   is any AL/AX/EAX or constant expression.  The expression
                 type will be determined by the first token (register or
                 variable): default is "word" for 16-bit code, "dword" for
                 32-bit code. If an other type is desired, the keyword 
                 "byte", "char", "int", "word", "long", "dword" or "float"
                 can preceed the expression to specify its type.
    "compare_op" is any one of "==", "!=", "<>", "<", ">", "<=", or ">=".
    "rightside"  is any single register, variable or constant expression.

    ( x+y > z )
    (int CX*DX <= 12*3 )
    (byte first*second+hold == cnumber )

    ( x+y >= x-y ) //rightside is not a single token or constant expression.
    ( z = y )      //"==", not "=" must be used.

Datatype override of registers

float f = 1.0;

void PROC ()
{
  IF (f < signed ECX) 	 // in the register ECX is sign number
  IF (unsigned EBX > f)  // in the register EBX is unsigned number
  IF (f == float EAX)    // in EAX is number of a format float. WARNING: EAX destroyed.
}

Datatype conversion

cpuspeed.c-- 59: i=a+j;
0000011F 50                       push    eax        //convert "a" to integer.
00000120 D905C0010000             fld     [1C0h]     //    /
00000126 DB1C24                   fistp   [esp]      //    /
00000129 58                       pop     eax        //    /
0000012A 660305BC010000           add     ax,[1BCh]  //evaluation done in short.
00000131 66A3B8010000             mov     [1B8h],ax

z = a+j;

cpuspeed.c-- 59: i= float a+j;
0000011F D905BC010000             fld     [1BCh]
00000125 DA05B8010000             fiadd   [1B8h]
0000012B DF1DB4010000             fistpw  [1B4h]
00000131 9B                       fwait

Assignment to a register

EAX = a*j;  //a is float, j is long.

EAX = long a*j;  //a is float, j is long.

Multiple assignment

  var1 = 0;
  var2 = 0;
  var3 = 0;

  var1 = var2 = var3 = 0;

Declaring functions and macros

General

Parameters for stack procedures, if any, may be of any type (specified by 'byte', 'char', 'word', 'int', 'dword' or 'long'). Parameters are passed using a Pascal-like calling convention, that is, the first parameter is pushed first and the second parameter is pushed second, and so on. The Pascal-calling convention does not support variable number of parameters, so you have to be sure to pass the proper number of parameters to a stack procedure.

The following example stack procedure returns the sum as a 'word' of all its parameters, which are of different types:

    word add_them_all (short a,b; long c,d)
    word x;
    dword y;
    {
      return( a+b+c+d );
    }

    EBP - 6    Local variable "y".
    EBP - 2    Local variable "x".
    EBP + 0    Saved EBP.
    EBP + 4    Return address.
    EBP + 8    Rightmost passed parameter, "d".
    EBP + 12   Parameter "c".
    EBP + 16   Parameter "b".
    EBP + 20   Parameter "a".

    push ebp       //save EBP.
    mov ebp,esp    //use EBP to access stack frame.
    sub esp,value  //value=number of bytes allocated for local variables.

    mov ebp,esp    //restore EBP.
    pop esp        //restore ESP.
    ret 12         //dump saved-EBP, local "x", local "y".

void afunc(word a, b, c; dword d, e; byte f);                 //shorthand format.
void afunc(word a, word b, word c, dword d, dword e, byte f); //full format.

A macro is an inline register procedure. The keyword "inline" is described below.

Return values from functions are returned via registers, below is a table showing what register is used for each return type:

	  return type  |  register returned in
	----------------------------------------
	     byte      |        AL
	     word      |        AX
	     dword     |        EAX
	     char      |        AL
	     short     |        AX
	     long      |        EAX

	dword proc_one ()
	{
	return( 42 );
	}

	dword proc_two ()
	{
	EAX = 42;
	}

long CARRYFLAG fopen(); 	  //the declaration of the procedure.

    if(fopen()) { code here }         //evaluates returned Carry flag TRUE/FALSE.
    if(handle=fopen()) { code here }  //still evaluates Carry flag.

    if(fopen() == 5) { code here }  //reverts to return value.

Calling convention

rettype modif procname ();

Default calling conventions

Variable number of parameters

void cdecl printf (word,...);

Inline stack functions

inline void sys_write_text(dword EBX, ECX, EDX, ESI){
 EAX = 4;
 $int 0x40;
}

cpuspeed.c-- 26: sys_write_text(8<<16+8,0xFFFFFF,"C-- CPU speed example for MenuetOS",34);
0000005F B808000800               mov     eax,80008h
00000064 50                       push    eax
00000065 68FFFFFF00               push    0FFFFFFh
0000006A B8E0000000               mov     eax,0E0h
0000006F 50                       push    eax
00000070 6A22                     push    22h
msys.h-- 99: EAX = 4;
00000072 B804000000               mov     eax,4
msys.h-- 100: $int 0x40;
00000077 CD40                     int     40h
00000079 83C410                   add     esp,10h

inline void sys_write_text(dword xystart, color, #message, length){
 EAX = 4;
 $int 0x40;
}

Inline register functions

inline fastcall void sys_write_text(dword EBX, ECX, EDX, ESI){
 EAX = 4;
 $int 0x40;
}

cpuspeed.c-- 26: sys_write_text(8<<16+8,0xFFFFFF,"C-- CPU speed example for MenuetOS",34);
0000005F BB08000800               mov     ebx,80008h
00000064 B9FFFFFF00               mov     ecx,0FFFFFFh
00000069 BAE0000000               mov     edx,0E0h
0000006E BE22000000               mov     esi,22h
msys.h-- 99: EAX = 4;
00000073 B804000000               mov     eax,4
msys.h-- 100: $int 0x40;
00000078 CD40                     int     40h

#define register fastcall

Non-inline register functions

fastcall void sys_write_text(dword EBX, ECX, EDX, ESI){
 EAX = 4;
 $int 0x40;
}

cpuspeed.c-- 26: sys_write_text(8<<16+8,0xFFFFFF,"C-- CPU speed example for MenuetOS",34);
00000067 BB08000800               mov     ebx,80008h
0000006C B9FFFFFF00               mov     ecx,0FFFFFFh
00000071 BAE4000000               mov     edx,0E4h
00000076 BE22000000               mov     esi,22h
0000007B E8A4FFFFFF               call    24h

msys.h-- 99: EAX = 4;
00000024 B804000000               mov     eax,4
msys.h-- 100: $int 0x40;
00000029 CD40                     int     40h
0000002B C3                       ret

Non-inline stack functions

void sys_write_text(dword xystart, color, #message, length){
 EAX = 4;
 $int 0x40;
}

Dynamic non-inline functions

 : sys_write_text(dword xystart, color, #message, length){
 EAX = 4;
 $int 0x40;
}

Interrupt Procedures

Interrupt procedures, procedures which are used as handles for interrupts, are defined in the following manner:

	interrupt procedure_name ()
	{
	// put code here
	}

	interrupt safe_handle ()
	{
	$PUSHAD                 //save all 32-bit registers.
	/* do your thing here */
	$POPAD   
	}

Conditional statements

'if' and 'else'

Selection statements, like in C can be followed by either a single command, or a block of many commands enclosed within '{' and '}'. C-- selection statements are restricted to C-- conditional expressions (as described in section 1.4 Expressions).

If more than 127 bytes of code follow an 'IF' statement, the compiler will issue the following error message:

	IF jump distance too far, use if.

'else' and 'ELSE' statements are used just like the 'else' command in C, except that 'ELSE' has the same 127 byte jump restriction as 'IF' of 127 bytes. 'else' generates 1 more byte of code than 'ELSE'.

'IF' and 'else', and 'if' and 'ELSE' may be mixed freely, such as the following example:

	if( x == 2 )
	    WRITESTR("Two");
	ELSE{WRITESTR("not two.");
	    printmorestuff();
	    }

	ELSE jump distance too far, use else.

'do {} while' loops

	count = 0;
	do {
	    count++;
	    WRITEWORD(count);
	    WRITELN();
	    } while (count < 5);

'loop' loops

	count = 5;
	loop( count )
	    {WRITEWORD(count);
	    WRITELN();
	    }

If the loop counter is zero before starting the 'loop' command, the loop will be executed the maximum number of times for the range of the variable. 256 times for a 8 bit (byte or char) counter, 65536 for a 16 bit (word or int) counter, and 4294967296 for a 32 bit (dword or long) loop counter. For example, the following loop will execute 256 times:

	BH = 0;
	loop( BH )
	    {
	    }

	loop()
	    WRITE('*');

	CX = 1000;
	loop( CX )
	    {
	    IF( CX > 3 )
		CX = 3;
	    }

'for' loop

    FOR(ECX=0;ECX<200;ECX++){
      EAX=ECX<<7;
      EBX=EAX<<2;
      EDI=EAX+EBX;
      FOR(EDX=0;EDX<320;EDX++,EDI++){
        ESI=EDI+offset1;
        c1=flowers[ESI];
        ESI=EDI+offset2;
        c2=flowers[ESI];
        ESI=EDI+offset3;
        c3=flowers[ESI];
        EAX=ECX<<6;
        EBX=EAX<<2;
        ESI=EAX+EBX+EDX;
        screen[ESI]=c1+c2+c3;
      }
    }

'switch' case

   switch(sys_wait_event())
   {
    case 1:
     draw_window();
     continue;                     //go back up and re-evaluate switch.
    case 2:
     /*sys_get_key();*/
     break;                        //exit from switch.
    case 3:
     if(sys_get_button_id()==1) sys_exit_process();
     continue;
   }

Arrays

Array indexing

dword array[10];
dword i;

  EBX=4;
  array[EBX]=0;     //*byte* offset.
  array[4]=0;       //*byte* offset.

  i=1;
  array[i]=0;       //index determined by datatype.

cpuspeed.c-- 66: EBX=4;
0000011F BB04000000               mov     ebx,4
cpuspeed.c-- 67: array[EBX]=0;
00000124 C783C401000000000000     mov     dword ptr [ebx+1C4h],0
cpuspeed.c-- 68: array[4]=0;
0000012E C705C801000000000000     mov     dword ptr [1C8h],0
cpuspeed.c-- 69: i=1;
00000138 C705EC01000001000000     mov     dword ptr [1ECh],1
cpuspeed.c-- 70: array[i]=0;
00000142 8B35EC010000             mov     esi,[1ECh]
00000148 C704B5C401000000000000   mov     dword ptr [1C4h+esi*4],0

	variable[index]
	variable[index+EBX+ESI]
	variable[index+EBX+EDI]
	variable[index+EBP+ESI]
	variable[index+EBP+EDI]
	variable[index+ESI]
	variable[index+EDI]
	variable[index+EBP]
	variable[index+EBX]

cpuspeed.c-- 69: buf[array[i]]=0;
0000013A 8B35C0010000             mov     esi,[1C0h]
00000140 8B34B514020000           mov     esi,[214h+esi*4]
00000147 C704B5C401000000000000   mov     dword ptr [1C4h+esi*4],0

  array[*i] = 0;   //here variable i will contain an absolute byte-displacement in
                   //array, instead of number of an element (index).

Structures

Structure syntax

  struct <tag> {<fields>};

  <tag> is the name of the structure definition (not an instantiation),
  <fields> are the definitions of the fields of the structure.

  struct [<tag>] {<fields>} <name>[,<name>...];
  [struct] <tag> <name> [, <name>...];

  [ ] square brackets denote optional,
  <name> is the name of an instantiation of the structure.

struct rect {long x; long y;} myrect;
struct {long x; long y;} myrect;
struct {long x; long y;} rect1, rect2;  //two structures instantiated.

struct rect {long x; long y;};         //definition of a structure.
struct rect myrect;                    //instantiation of rect.
struct FileInfo{dword read,firstBlock,qnBlockRead,retPtr,Work; byte filedir;};
struct FileInfo myfile;                //instantiation of FileInfo.

struct test {
  int a;
  char b [8];
  long c;
} rr, ff [4];

struct test dd;

  test dd;

Initialisation of structures at the declaration

       struct test dd = 2;

       struct test dd = {1,2,,6};

       struct test dd = FROM "file.dat";

       struct test dd = EXTRACT "file.dat",24,10;

Initialization of structures at execution of the program.

struct test {short a;char b[8];long c;};
void proc() {
struct test aa[5], rr;
short i;
   aa[0] = 0x78;            //1. all memory filled with 0x78.
   aa[0] = 0x12345678;      //2.  ditto
   aa[i] = int 0x12345678;  //3. all memory filled with 0x5678.
   aa = long 0x12345678;    //4. entire array filled with 0x12345678.
   rr = i;                  //5. 16-bit value fills the memory.

  rr = aa [2];

Structure access

Accessing arrays of structures and arrays in structures

struct test {short a;char b[8];long c;} rr[5];
    rr.a = 1;
    rr.b[i] = 2;
    rr[i].c = 3;
    rr[j].b[i] = 4;

Address of structure

struct bb        // tag of the structure.
{
  word b;        // the first field.
  dword c;       // the second field.
} ss;            // instantiation.

void proc ()
{
  EAX=#ss.b;     // get address of field "b" in structure "ss".
  EAX=#bb.b;     // get offset of the same field in a tag "bb".
}

Nested structures

struct RGB
{
  byte Red;
  byte Green;
  byte Blue;
  byte Reserved;
};

struct BMPINFO
{
  struct BMPHEADER header;  //the description of this structure is missed.
  struct RGB color [256];   //array of RGB structures.
} info;                     //instantiation.

  AL = info.color[10].Red;

struct ABC {
  int a;
  int b;
  int c;
};
struct {
  struct ABC first [4];    // 4 copies of structure ABC
  int d;
} second [4];

int i, k;
void proc ()
{
  AX=second[i].first[k].a; //an error as variables used in two places.
  AX=second[2].first[k].a; //this syntax is allowable.
  AX=second[i].first[3].a; //allowable.
}

Bit fields of structures

<type>[<identifier>]:< a constant >;

struct test {byte a:1;b:2;c:1;d:1;long vv;};
struct test rr=0;

cpuspeed.c-- 73: EAX=rr.a;
0000012D A104010000               mov     eax,[104h]
00000132 83E001                   and     eax,1

cpuspeed.c-- 74: EAX=rr.b;
00000135 A104010000               mov     eax,[104h]
0000013A 83E006                   and     eax,6
0000013D D1E8                     shr     eax,1

cpuspeed.c-- 75: EAX=rr.c;
0000013F A104010000               mov     eax,[104h]
00000144 83E008                   and     eax,8
00000147 C1E803                   shr     eax,3

cpuspeed.c-- 75: rr.c=1;
0000013F 800D0401000008           or      byte ptr [104h],8

The declaration of procedures in structures

struct Point           //the declaration of the class.
{
     int x;            //data items
     int y;            // of the class of a type Point.
     void SetX (int);  //the declaration of methods
     void SetY (int);  // of the Point class.
};

void Point::SetX (int _x) //definition of the procedure of the Point class.
{
    IF((_x>=0)&&(_x<=MAX_X)) x=_x;
//The variables x, y are the members of this class and consequently access
//to them from procedures of the same class is carried out directly.
}

void main ()
Point p;              //structure p instantiated in the stack.
{
  p.y = p.x = 0;
  p.SetX(1);
}

Inheriting

struct Derived: Base1, Base2... Basen
{
  long x0;
};

struct A
{
  long x, y;
  ...
};

struct B: A    //the structure 'B' inherits 'A'.
{
  ...
};

struct C: A    //the structure 'C' inherits 'A'.
{
  ...
};

struct D: B, C //the structure 'D' inherits 'B' and 'C'.
{
  ...
};

void main ()
D d;          //structure 'D' instantiated as 'd' on stack.
{
  d.x = 0;

  d.B::x=0;

  d.x=0;

  d.C::x=0;

Pointers

char *string [4] = {"string1", "string2", "string3", 0}; // a pointer array
char *str = "string4";

main ()
int i;
char *tstr;
{
    FOR (i = 0; string [i] != 0; i++) {
       WRITESTR (string [i]);
       WRITELN ();
    }
    FOR (tstr = str; byte *tstr != 0; tstr++) {
       WRITE (byte *tstr);
    }
}

void (*ptr)(); // the declaration of a pointer to a procedure

char *z;
  z = #main;

Pointers to structures

struct FileInfo *pmyfile;  //unacceptable format.

cpuspeed.c-- 73: ESI.FileInfo.read=0;
0000013E C70600000000             mov     dword ptr [esi],0

//this time I've initialised the elements when instantiating...
cpuspeed.c-- 56: struct FileInfo myfile={0,0,0,0,0,0};
00000104 000000000000000000000000 dd      0,0,0
00000110 0000000000000000         dd      0,0
00000118 00                       db      0

//now, pretend that "myfile" is in the ES (extra segment):
cpuspeed.c-- 74: ESDWORD[#myfile.read]=0;
0000015A 26C7050401000000000000   mov     dword ptr es:[104h],0

cpuspeed.c-- 75: ESDWORD[myfile.read]=0;
00000165 8B3504010000             mov     esi,[104h]
0000016B 26C70600000000           mov     dword ptr es:[esi],0

Other syntax

Jump labels

Labels are defined by a identifier followed by a colon. If the identifier used contains one or more lower case letters, it is a global jump label, otherwise it is a local jump label.

Global jump labels must not be used within inline procedures, only local labels may be used. This is important to remember, for inline procedures are inserted inline maybe in multiple places, at compile time.

Swap Operator

	AX >< BX;      // store the value of BX in AX and the value of AX in BX
	CH >< BL;      // swap the values of CH and BL
	dog >< cat;    // swap the values of the variable dog and the variable cat
	counter >< CX; // swap the values of counter and CX

Neg Operator

	-AX;     // same as 'AX = -AX;' but faster.
	-tree;   // same as 'tree = -tree;' but faster.
	-BH;     // toggle the sign of BH.

NOT Operator

C-- supports a quick syntax of doing a logical NOT toggling on a variable, the NOT operator. By placing a '!' in front of a memory variable or register followed by a ';', the value of the memory variable or register will be changed to the logical NOT of its current value. Some examples:

	!AX;     // same as 'AX ^= 0xFFFF;' but faster.
	!node;   // change the value of 'node' to its logical NOT.
	!CL;     // same as 'CL ^= 0xFF' but faster.

Special Conditional Expressions

C-- supports six special conditional expressions:

	CARRYFLAG
	NOTCARRYFLAG
	OVERFLOW
	NOTOVERFLOW
	ZEROFLAG
	NOTZEROFLAG

	IF( CARRYFLAG )
	    {
	    // do some stuff here
	    }

	do {
	    // do your thing in here
	    } while( NOTOVERFLOW );

'sizeof'

 sizeof (<a name of a type>)

  sizeof ("Test")    //result=5. includes terminating zero.
char a = "Test";
  sizeof (a)         //result=1. because "a" is char datatype.
  sizeof (file "filename.dat")  //result= size of the file.
  sizeof (func1)     //returns size of the procedure.
  sizeof (ss.bb)     //returns the size of "bb" member in structure "ss".
  sizeof (FileInfo)  //returns the size of structure "FileInfo".

  z = sizeof (FileInfo.read);

Unions

union
{
  dword regEAX;
  word regAX;
  byte regAL;
}; // have declared 3 variables located on same physical address.

void test ()
{
    regEAX = 0x2C;
    BL = regAL;  //in the register BL there will be a value 0x2C.
}

Internal macros

atan(x);     //calculate arctangent of number x.
atan2(x,y);  //calculate arctangent of the attitude x/y.
cos(x);      //return cosine of a corner x.
exp(x);      //return to an exhibitor of number x (erects the
                            basis the natural logarithms in a degree x).
fabs(x);     //calculate absolute value of number x.
log(x);      //calculate the natural logarithm of number x.
log10(x);    //calculate the decimal logarithm of number x.
sin(x);      //return a sine of a corner x.
sqrt(x);     //take a square root from among x.
tan(x);      //return tangent of a corner x.

    inp(port)      //read one byte from a port
    inportb(port)  //read one byte from a port
    inport(port)   //read a word from a port
    inportd(port)  //read a double word from a port
      /*port - the "port" parameter is not essential. If the value 
        is not given, the generated instruction will be "in al,dx".
        If the port value is less than 256, the generated 
        instruction will be "in al,port".*/

    outp(val,port)        //writes byte "val" to a port
    outportb(val,port)    //writes byte "val" to a port
    outport(val,port)     //writes word "val" to a port
    outportd(val,port)    //writes double word to a port
       /*val - written value
         port - the word with the address of a port is not essential.
         If the value is not given, the generated instruction will
         be "out dx,al". 
         If the port value is less than 256, the instruction
         will be "out port,al".*/

Inline assembly

C-- inline assembly supports all of the 8088/8086 assembly codes, plus the 80286, 80386, 80486 and Pentium to Pentium III enhanced instructions.

Here is some example inline assembly:

//at the C level, a variable declared:
dword cpuspeed;
 
    $mov  eax,cpuspeed   //loads contents of "cpuspeed" (square brackets not allowed).
    $mov  edi,#smsg1+16  //the "#" means immediate-mode (address-of "smsg1").
    $mov  ecx,5
  $newnum:               //labels are allowed.
    $xor  edx,edx
    $mov  ebx,10
    $div  ebx
    $add  dl,48
    $mov  DSBYTE[edi],dl //keyword "DSBYTE" is required.
    $sub  edi,1
    $loop newnum

Note that all instructions start with the "$" inline assembly specifier.

There is a problem for those familiar with NASM and FASM, as the instruction "mov eax,cpuspeed" loads the contents of variable "cpuspeed". You are not allowed to put square brackets to clarify this.
If you want to load the address of the variable, you put "mov eax,#cpuspeed".
Basically, the assembler syntax follows that of MASM (Microsoft assembler).

It is not allowed to have just "mov [edi],dl". You have got to specify which segment and the size, hence "DSBYTE" prefix.
Even though we are using the FLAT memory model with MenuetOS, in which CS=DS=SS (that is, point to the start of the virtual memory address space allocated for the program), the instruction still has encoded into it which segment it is accessing.

You are allowed to have a block of inline assembly. That is:

  asm {
  //asm code here.
  }

is allowed. For this you use the "asm" keyword. I found that "$ {   }" doesn't work.

Now for the ultimate integration of asm and C. If you put the commandline option as follows:

#pragma option ia     //"$" and "asm" keywords not required.

Then asm code does not have to be in asm blocks. That is, "$" and "asm { }" are not required. For example:

dword cpuspeed;
void main(void)
{
  cpuspeed=sys_service(5,0)/1000000; //a C statement.
   push eax                          //wow, no asm block.
   mov eax,cpuspeed
   pop eax; xor eax,eax
  draw_window();                     //back to normal C.

I have just put in some random code to illustrate. You throw in asm instructions just like C statements, and you can even use the standard ";" terminator if you wish, as I've done to place more than one instruction per line.

Some keywords may clash. For example, "int" is both an instruction and a datatype. However, C-- is in many cases able to distinguish between the different usage of "int" by the context in which it is placed.
To avoid a conflict between "int" used in header (include) files and the redefinition as an instruction mneumonic, it is prudent to place the "#pragma option ia" line after the "#include" lines.
Also, this example is a clash:

EAX = int 1 + a;

To clarify that inline asm is basically MASM-compatible, here are examples:

    $jmp  short place1   //"short" keyword, +/-127 locations.
    $mov eax,cpuspeed     //load contents of variable.
    $mov eax,#cpuspeed    //load address of variable.

Directives and command line options

Commandline arguments

SPHINX C-- Compiler   Version 0.238   Jun 03 2002
USAGE: C-- [options] [FILE_NAME.INI] [SOURCE_FILE_NAME]

                       C-- COMPILER OPTIONS

                           OPTIMIZATION
/OC  optimize for code size           /DE  enable temporary expansion variable
/OS  optimize for speed               /OST enable optimization string
/ON  enable optimization number       /AP[=n] align start procedure
/UST use startup code for variables   /AC[=n] align start cycles

                          CODE GENERATION
/2   80286 code optimizations         /SA=#### start code address
/3   80386 code optimizations         /AL=## set value insert byte
/4   80486 code optimizations         /WFA fast call API procedures
/5   pentium code optimizations       /IV  initial all variables
/A   enable address alignment         /SUV=#### start address variables

                           PREPROCESSOR
/IP=<path>  include file path         /IA   assembly instructions as identifier
/D=<idname> defined identifier        /CRI- not check include file on repeated
/MIF=<file> main input file           /IND=<name> import name from dll

                              LINKING
/AT    insert ATEXIT support block    /STM   startup code in main procedure
/ARGC  insert parse command line      /NS    disable stub
/P     insert parse command line      /S=#####  set stack size
/C     insert CTRL<C> ignoring code   /WIB=##### set image base address
/R     insert resize memory block     /WFU   add Fix Up table (for Windows32)
/ENV   insert variable with environ   /WMB   create windows mono block
/J0    disable initial jump to main() /WS=<name> set name stub file for win32
/J1    initial jump to main() short   /WBSS  set post data in bss section
/J2    initial jump to main() near    /WO    call API procedures on ordinals
/STUB= <name> set name stub file      /CPA   clear post area
/DOS4GW file running with DOS4GW

                           OUTPUT FILES
/TEXE DOS EXE file (model TINY)       /D32  EXE file (32bit code for DOS)
/EXE  DOS EXE file (model SMALL)      /W32  EXE for Windows32 GUI
/OBJ  OBJ output file                 /W32C EXE for Windows32 console
/SOBJ slave OBJ output file           /DLL  DLL for Windows32
/SYM  COM file symbiosis              /DBG  creation debug information
/SYS  device (SYS) file               /LST  creation assembly listing

                           MISCELLANEOUS
/HELP /H /? help, this info           /WORDS list of C-- reserved words
/W         enable warning             /LAI   list of assembler instructions
/WF=<file> direct warnings to a file  /ME    display my name and my address
/MER=##    set maximum number errors  /X     disable SPHINXC-- header in output
/NW=##     disable select warning

Compiler directives

#startaddress 0
#code32 TRUE
#pragma option X      //disable sphinx header in output file.
#pragma option LST    //generate asm listing file.
//#pragma option OC   //optimisation for code size.(BK:makes run file bigger!!!)
//#pragma option 4    //for i80486.
//#pragma option A    //align data from parity address.
#pragma option J0     //disable initial jump to main().
#resize 0             //disable mem. resizing code at start of output file.

#includepath C:\progra~2\c--\inc

#include "windows.h--"

#include <windows.h-->

'C--.INI' file

R-
X
3   ;comments are allowed, preceded by a ";".
os

Assembly language instructions

SPHINX C-- Compiler   Version 0.238   Jun 03 2002
LIST OF SUPPORTED ASSEMBLER INSTRUCTIONS:
AAA      AAD      AAM      AAS      ADC      ADD       ADDPS     ADDSS
ADRSIZE  AND      ANDNPS   ANDPS    ARPL    
BOUND    BSF      BSR      BSWAP    BT       BTC       BTR       BTS
CALL     CALLF    CBW      CDQ      CLC      CLD       CLI       CLTS
CMC      CMOVA    CMOVAE   CMOVB    CMOVBE   CMOVC     CMOVE     CMOVG
CMOVGE   CMOVL    CMOVLE   CMOVNA   CMOVNAE  CMOVNB    CMOVNBE   CMOVNC
CMOVNE   CMOVNG   CMOVNGE  CMOVNL   CMOVNLE  CMOVNO    CMOVNP    CMOVNS
CMOVNZ   CMOVO    CMOVP    CMOVPE   CMOVPO   CMOVS     CMOVZ     CMP
CMPPS    CMPSB    CMPSD    CMPSS    CMPSW    CMPXCHG   CMPXCHG8B COMISS
CPUID    CVTPI2PS CVTPS2PI CVTSI2SS CVTSS2SI CVTTPS2PI CVTTSS2SI CWD
CWDE  
DAA      DAS      DB       DD       DEC      DIV       DIVPS     DIVSS
DW   
EMMS     EMMX     ENTER
F2XM1    FABS     FADD     FADDP    FBLD     FBSTP     FCHS      FCLEX
FCMOVB   FCMOVBE  FCMOVE   FCMOVNB  FCMOVNBE FCMOVNE   FCMOVNU   FCMOVU
FCOM     FCOMI    FCOMIP   FCOMP    FCOMPP   FCOS      FDECSTP   FDISI
FDIV     FDIVP    FDIVR    FDIVRP   FENI     FFREE     FIADD     FICOM
FICOMP   FIDIV    FIDIVR   FILD     FILDQ    FIMUL     FINCSTP   FINIT
FIST     FISTP    FISUB    FISUBR   FLD      FLD1      FLDCW     FLDENV
FLDL2E   FLDL2T   FLDLG2   FLDLN2   FLDPI    FLDZ      FMUL      FMULP
FNCLEX   FNDISI   FNENI    FNINIT   FNOP     FNSAVE    FNSETPM   FNSTCW
FNSTENV  FNSTSW   FPATAN   FPREM    FPREM1   FPTAN     FRNDINT   FRSTOR
FSAVE    FSCALE   FSETPM   FSIN     FSINCOS  FSQRT     FST       FSTCW
FSTENV   FSTP     FSTSW    FSUB     FSUBP    FSUBR     FSUBRP    FTST
FUCOM    FUCOMI   FUCOMIP  FUCOMP   FUCOMPP  FWAIT     FXAM      FXCH
FXRSTOR  FXSAVE   FXTRACT  FYL2X    FYL2XP1
HALT     HLT
IDIV     IMUL     IN       INC      INSB     INSD      INSW      INT
INTO     INVD     INVLPD   INVLPG   IRET     IRETD    
JA       JAE      JB       JBE      JC       JCXZ      JE        JECXZ
JG       JGE      JL       JLE      JMP      JMPF      JMPN      JMPS
JNA      JNAE     JNB      JNBE     JNC      JNE       JNG       JNGE
JNL      JNLE     JNO      JNP      JNS      JNZ       JO        JP
JPE      JPO      JS       JZ       
LAHF     LAR      LDMXCSR  LDS      LEA      LEAVE     LES       LFS
LGDT     LGS      LIDT     LLDT     LMSW     LOADALL   LOCK      LODSB
LODSD    LODSW    LOOP     LOOPD    LOOPE    LOOPNE    LOOPNZ    LOOPW
LOOPZ    LSL      LSS      LTR     
MASKMOVQ MAXPS    MAXSS    MINPS    MINSS    MOV       MOVAPS    MOVD
MOVHLPS  MOVHPS   MOVLHPS  MOVLPS   MOVMSKPS MOVNTPS   MOVNTQ    MOVQ
MOVSB    MOVSD    MOVSS    MOVSW    MOVSX    MOVUPS    MOVZX     MUL
MULPS    MULSS    NEG      NOP      NOT      
OPSIZE   OR       ORPS     OUT      OUTSB    OUTSD     OUTSW
PACKSSDW PACKSSWB PACKUS   PACKUSWB PADDB    PADDD     PADDSB    PADDSW
PADDUSB  PADDUSW  PADDW    PAND     PANDN    PAVGB     PAVGW     PCMPEQB
PCMPEQD  PCMPEQW  PCMPGTB  PCMPGTD  PCMPGTW  PEXTRW    PINSRW    PMADD
PMADDWD  PMAXSW   PMAXUB   PMINSW   PMINUB   PMOVMSKB  PMULH     PMULHUW
PMULHW   PMULL    PMULLW   POP      POPA     POPAD     POPF      POPFD
POR      PREFETCHNTA PREFETCHT0  PREFETCHT1 PREFETCHT2 PSADBW    PSHUFW
PSLLD    PSLLQ    PSLLW    PSRAD    PSRAW    PSRLD     PSRLQ     PSRLW
PSUBB    PSUBD    PSUBSB   PSUBSW   PSUBUSB  PSUBUSW   PSUBW     PUNPCKHBW
PUNPCKHDQ PUNPCKHWD  PUNPCKLBW  PUNPCKLDQ  PUNPCKLWD   PUSH      PUSHA
PUSHAD   PUSHF    PUSHFD   PXOR
RCL      RCPPS    RCPSS    RCR      RDMSR    RDPMC     RDTSC     REP
REPE     REPNE    REPNZ    REPZ     RET      RETF      ROL       ROR
RSM      RSQRTPS  RSQRTSS  
SAHF     SAL      SAR      SBB      SBC      SCASB     SCASD     SCASW
SETA     SETAE    SETALC   SETB     SETBE    SETC      SETE      SETG
SETGE    SETL     SETLE    SETNA    SETNAE   SETNB     SETNBE    SETNC
SETNE    SETNG    SETNGE   SETNL    SETNLE   SETNO     SETNP     SETNS
SETNZ    SETO     SETP     SETPE    SETPO    SETS      SETZ      SFENCE
SGDT     SHL      SHLD     SHR      SHRD     SHUFPS    SIDT      SLDT
SMSW     SQRTPS   SQRTSS   STC      STD      STI       STMXCSR   STOSB
STOSD    STOSW    STR      SUB      SUBPS    SUBSS     SYSENTER  SYSEXIT
TEST   
UCOMISS  UD2      UNPCKHPS UNPCKLPS 
VERR     VERW
WAIT     WBINVD   WRMSR
XADD     XCHG     XLAT     XLATB    XOR      XORPS

Appendices

How to install C-- on your computer.

1. Create on the C drive the C-- folder ( for example by command: "MD C--").
2. Then copy into this folder library files (files with the *.H-- extension).
3. Copy into the same folder the files: C--.EXE; MAINLIB.LDP; STARTUP.H-- (the file C--.INI is not necessary.)
4. Then in the "autoexec.bat" file add an environment variable: "SET C--=C:\C--"
5. The files of libraries can be arranged in another folder, but then it will be necessary in the file "c--.ini" to add a line: "ip=c:\path_to_lib"
   

Further documentation

code32.txt    32-bit programming.
comstr.txt    Commandline parameters.
comstrd.txt   Optimisation of numerical expressions.
directin.txt  Conditional compilation.
ifloop.txt    Conditonal instructions.
import.txt    FROM and EXTRACT.
index.txt     Index addressing.
instr.txt     Compiler directives.
label.txt     Labels of transition.
output.txt    Output files.
sintc.txt     Special operators.
sys.txt       Compilation of device drivers.