?resize FALSE
?include "XOS.H--"
int A, B;
byte Q;
main()
{
PRINTF("Press 'F' for Fahrenheit to Celsius or 'C' for Celsius to Fahrenheit? ");
GETKEY(Q);
Q = AL;
if (Q == 'C')
{
PRINTF("\nTemperature in Celsius? ");
getnum(A);
A = AX;
B = A;
B = B/5*4;
A = A + B+32;
PRINTF("Temperature in Fahrenheit = ");
PRINTNUM(A);
TERMINATE();
}
if (Q == 'F')
{
PRINTF("\nTemperature in Fahrenheit? ");
getnum(A);
A = AX;
A = A-32;
A = A/9*5;
PRINTF("Temperature in Celsius = ");
PRINTNUM(A);
TERMINATE();
}
else
{
TERMINATE();
}
}
    

: void TERMINATE ()
{
$INT 0x20
}

: void PRINTF ()
{
SI = AX;
AH = 0x03;
$ INT 0x21
}

: void PRINTNUM ()
{
SI = AX;
CX = 0;
DOWN1:
BX = 0x0a;
DX = 0;
$ DIV BX
$ PUSH DX
$ INC CX
$ CMP AX, 0
$ JNZ DOWN1
DOWN2:
$ POP DX
$ ADD DL, 0x30
AL = DL;
AH = 0x0e;
$ INT 0x10
$ DEC CX
$ JNZ DOWN2
}

: void MSGBOX ()
{
 SI = AX;
 AH = 01;
$ INT 0x21
}

: word getstring (word buffer; byte num)
{
CL = num;
DI = buffer;
AH = 0x0C;
$ INT 0x21
}

: word getnum (int varnum)
{
AH = 0X0D;
$ INT 0X21
}

: void GETKEY ()
{
$ XOR AX, AX
$ INT 0x16
$ CMP AL, 0x61
$ JB OK
$ SUB AL, 0x20
OK:
}
    

so what language is this ?

I really don't see the point.

If you want really low-level programming, go for C and/or assembly - probably C with external assembly modules written using a proper assembler, instead of half-arsed inline assembly.

For high(er) level languages, I expect type safety and a decent optimizing compiler...

C-- looks like a bastard child that doesn't exactly encourage good programming practices.

me239: 80386 code "unlike most compilers these days"?

What do you need 8086 and 80286 code for?

There are some of us who use 8086 (80186) as microcontrollers. Some of us run DOS on embedded systems using 8086/80186 architectures. The world isn't just the PC...

It's almost the same as using a Macro in FASM and also I see it more fit for those who want to have a higher level for their own OS, but have little knowledge on creating C libraries.

Also another reason I started using it is because it can generate 8086, 80286, and 80386 code unlike most compilers these days.

I know of no compilers targetting those CPUs that produce decent code

f0dder wrote:

I know of no compilers targetting those CPUs that produce decent code

Borland C++

I know of no compilers targetting those CPUs that produce decent code

/***************************************
*             Sphinx C--               *  
*                                      *
*     strlen demo  By Emil Halim       *
*           23 / 9 / 2011              *
***************************************/

#pragma option w32         //create Windows GUI EXE.
#pragma option OBJ         //create OBJ file
#pragma option OS          //speed optimization 
#pragma option J0          //no startup code.

#include <Windows.h> 

#pragma option ia          // allow inline asm
#pragma option LST

extern cdecl _printf();   
#define printf  _printf

extern cdecl _strlen();
#define strlen _strlen 

int strlen1(char* pStr)
{
    EAX=0;
    while(byte *pStr !=0 )
     {
        pStr++;
        EAX++;
     }
} 

int fastcall strlen2(EAX)
{   
    EBX=EAX;
    while(DSBYTE[EAX] !=0 )
     {
        EAX++;
     }
    EAX -= EBX; 
} 

int fastcall strlen3(EAX)      // pure ASM code
{
   MOV EBX,EAX
@lop:
   CMP DSBYTE[EAX],0
   JE  fin
   INC EAX
   JMP lop
@fin:   
   SUB EAX,EBX
}

// *** SSE2 version  from MASM forum***
? aligncode 16
int  fastcall strlen4(EAX) 
{     
    EBX = EAX ;                 // get the string pointer
       LEA ECX, DSDWORD[EAX+16]        // save pointer to string, on par with eax after first loop
 EAX &= 0xFFFFFFF0;          // align for use with SSE2
@shiftOK:     
    XORPS XMM0, XMM0                // zero xmm0 for finding zero bytes
@a1: 
    PCMPEQB XMM0, DSQWORD[EAX]      // ---- inner loop -----
    PMOVMSKB EDX, XMM0              // set byte mask in edx
     EAX += 16;                      // len counter (best position here)
 TEST EDX,EDX
        JE a1
       if(ECX<=EAX) goto a2;
    ECX -= EAX;                 // get difference, and cancel "misalign flag"
 SHR EDX, CL                 // shift invalid
        SHL EDX, CL                     // bits out
 JE shiftOK
@a2:  
    BSF EDX, EDX                // bit scan for the index
       SUB EAX, EBX                    // subtract original src pointer
    LEA EAX, DSDWORD[EAX+EDX-16]    // add scan index
}
? aligncode 4

char* testStr = "SPHINX C-- is so easy (an intermediate position between Assembler and C)";

main()
{
_start:  
     printf("string length is %d\n",strlen( testStr )); 
     printf("string length is %d\n",strlen1( testStr ));   
     printf("string length is %d\n",strlen2( testStr ));   
     printf("string length is %d\n",strlen3( testStr ));  
     printf("string length is %d\n",strlen4( testStr ));  
     MessageBox(0,"","",0); 
}
    

/***************************************
*             Sphinx C--               *  
*                                      *
*     strcmp demo  By Emil Halim       *
*           23 / 9 / 2011              *
***************************************/

#pragma option w32         //create Windows GUI EXE.
#pragma option OBJ         //create OBJ file
#pragma option OS          //speed optimization 
#pragma option J0          //no startup code.

#include <Windows.h> 

#pragma option ia          // allow inline asm
#pragma option LST

extern cdecl _printf();   
#define printf  _printf


/***************
s > t >>>  > 0
s = t >>>  = 0
s < t >>>  < 0
***************/
int strcmp1(char *s, char *t)           // pure C code
{
   for( ;byte *s == byte *t; s++, t++)
   if (byte *s == '\0') return 0;
   return  DSBYTE[s] - DSBYTE[t];
}

int fastcall strcmp2(ESI,EDI)          // mixed asm & C 
{
   AL = DSBYTE[ESI];
   while(AL==DSBYTE[EDI])
     {
       if(AL==0) return 0;
       ESI++;  EDI++;
       AL = DSBYTE[ESI];
     }
   return  DSBYTE[ESI] - DSBYTE[EDI];
}

char* testStr1 = "SPHINX C-- is so easy (an intermediate position between Assembler and C)";
char* testStr2 = "SPHINX C-- is so easy (an intermediate position between Assembler and C)";

main()
{
_start:  
     printf("string length is %d\n",strcmp1( testStr1 , testStr2 )); 
     printf("string length is %d\n",strcmp2( testStr1 , testStr2 )); 
     MessageBox(0,"","",0); 
}
    

/***************************************
*             Sphinx C--               *  
*                                      *
*     strcpy demo  By Emil Halim       *
*           23 / 9 / 2011              *
***************************************/

#pragma option w32         //create Windows GUI EXE.
#pragma option OBJ         //create OBJ file
#pragma option OS          //speed optimization 
#pragma option J0          //no startup code.

#include <Windows.h> 

#pragma option ia          // allow inline asm
#pragma option LST

extern cdecl _printf();   
#define printf  _printf

// C version
dword strcpy1(char* dst, char* src)  // use dword instead of char* in return value for correct calling
{
  char* rt = dst;
  while (byte *src != 0) 
   {
      *dst = *src;
      dst++; src++;
   }
  return rt;
}

// asm version
dword fastcall strcpy2( EDI, ESI)
{
    MOV EDX, EDI
    MOV EDI, ESI
    XOR ECX, ECX
    XOR EAX, EAX
    DEC ECX
    REPNE SCASB
    XOR ECX, 0FFFFFFFFH
    MOV EDI, EDX
    MOV EDX, ECX
    MOV EAX, EDI
    SHR ECX, 2
    REP MOVSD
    MOV ECX, EDX
    AND ECX, 3
    REP MOVSB
}

// asm & C
dword fastcall strcpy3(EDI, ESI)  // use dword instead of char* in return value for correct calling
{
  EAX = EDI;
  AL = DSBYTE[ESI];
  while ( AL != 0) 
   {
      DSBYTE[EDI] = AL;
      ESI++; EDI++;
      AL = DSBYTE[ESI];
   }
  return EAX;
}


char* testStr1 = "SPHINX C-- is so easy (an intermediate position between Assembler and C)";
char* testStr2 = "                                                                        ";

main()
{
_start:  
     strcpy1( testStr2 , testStr1 ); 
     printf("string2 is %s\n", testStr2 );
     strcpy2( testStr2 , testStr1 ); 
     printf("string2 is %s\n", testStr2 );
     strcpy3( testStr2 , testStr1 ); 
     printf("string2 is %s\n", testStr2 ); 
     MessageBox(0,"","",0); 
}
    

/***************************************
*             Sphinx C--               *  
*                                      *
*     strcat demo  By Emil Halim       *
*           23 / 9 / 2011              *
***************************************/

#pragma option w32         //create Windows GUI EXE.
#pragma option OBJ         //create OBJ file
#pragma option OS          //speed optimization 
#pragma option J0          //no startup code.

#include <Windows.h> 

#pragma option ia          // allow inline asm
#pragma option LST

extern cdecl _printf();   
#define printf  _printf

// C version
dword strcat1( char* dst, char* src )
{
  char* d = dst;
  while (byte *d != 0) d++;
  while (byte *src != '\0') 
   {
      *d = *src;
       d++; src++;
   }
  return dst;
}


char* testStr1 = "SPHINX C-- is so easy ";
char* testStr2 = "(an intermediate position between Assembler and C)";
testStr3: DB 255 dup 0   // space for strcat test must be greater than the sum of testStr1 & testStr2


main()
{
_start:  
     strcat1( testStr3 , testStr1 );
     strcat1( testStr3 , testStr2 ); 
     printf("%s\n", testStr3 );
     MessageBox(0,"","",0); 
}
    

/***************************************
*             Sphinx C--               *  
*                                      *
*     strstr demo  By Emil Halim       *
*           23 / 9 / 2011              *
***************************************/

#pragma option w32         //create Windows GUI EXE.
#pragma option OBJ         //create OBJ file
#pragma option OS          //speed optimization 
#pragma option J0          //no startup code.

#include <Windows.h> 

#pragma option ia          // allow inline asm
#pragma option LST

extern cdecl _printf();   
#define printf  _printf

// C version
dword  strstr1( char * str1, char * str2 )
{
        char* s1, *s2;
        char* cp =  str1;
        if ( !*str2 )
            return str1;

        while ( *cp != 0)
         {
                s1 = cp;
                s2 = str2;
                while ( *s1 ) && ( *s2  ) && (! *s1 - *s2) 
                  {
                     s1++; s2++;
                  } 
                if (!*s2)
                        return cp;
                cp++;
        }
        return 0;
}

char* testStr1 = "SPHINX C-- is so easy (an intermediate position between Assembler and C)";
char* testStr2 = "Assembler";

main()
{
_start:  
     printf("%s\n", strstr1( testStr1 , testStr2 ) );
     MessageBox(0,"","",0); 
}
    

here is a simple demo that will show you the point of using Sphinx C--