; CC1B Ver 0.5A beta, Copyright (c) B Knudsen Data
; C compiler for the Ubicom SX family
; ************  24. Jun 2002  11:40  *************

        device SX28

PCL         EQU   $02
Carry       EQU   0
Zero_       EQU   2
i           EQU   $08
t           EQU   $09
p           EQU   $0B
si          EQU   $0C
strID       EQU   $08
ci          EQU   $0D

  ; FILE sx\demo-rom.c
                        ;// DATA STORED IN PROGRAM MEMORY
                        ;
                        ;#pragma chip SX28 // select device
                        ;
                        ;
                        ;// THE 'const' TYPE MODIFIER IS RECOMMENDED FOR ALL ROM DATA
                        ;const int16 tx[10] = { 1, 2, 1000, -34, -30000, 2, 100, 23, 0, 0};
                        ;
                        ;const char str[] = "String 1";
                        ;
                        ;const struct  {
                        ;  const char *str;
                        ;} txtp[] = {
                        ;  "A table of pointer to strings",
                        ;  "Monday", "Tuesday",
                        ;  "MyString",
                        ;  "MyString",  // equal strings and substrings are merged to save space
                        ;  "String",    // merged with substring
                        ;};
                        ;
                        ;
                        ;// NOTE: const data that are not read are NOT stored!
                        ;const char notAccessed[] = "This data is removed because it is not read";
                        ;
                        ;void sub(uns8 i)
                        ;{
_const1
        MOV   ci,W
        MOV   W,#101
        MOV   W,ci-W
        SNB   3.Carry
        RETW  0
        MOV   W,ci
        ADD   PCL,W
        RETW  1
        RETW  0
        RETW  2
        RETW  0
        RETW  232
        RETW  3
        RETW  222
        RETW  255
        RETW  208
        RETW  138
        RETW  2
        RETW  0
        RETW  100
        RETW  0
        RETW  23
        RETW  0
        RETW  0
        RETW  0
        RETW  0
        RETW  0
        RETW  83
        RETW  116
        RETW  114
        RETW  105
        RETW  110
        RETW  103
        RETW  32
        RETW  49
        RETW  0
        RETW  35
        RETW  65
        RETW  72
        RETW  80
        RETW  80
        RETW  82
        RETW  65
        RETW  32
        RETW  116
        RETW  97
        RETW  98
        RETW  108
        RETW  101
        RETW  32
        RETW  111
        RETW  102
        RETW  32
        RETW  112
        RETW  111
        RETW  105
        RETW  110
        RETW  116
        RETW  101
        RETW  114
        RETW  32
        RETW  116
        RETW  111
        RETW  32
        RETW  115
        RETW  116
        RETW  114
        RETW  105
        RETW  110
        RETW  103
        RETW  115
        RETW  0
        RETW  77
        RETW  111
        RETW  110
        RETW  100
        RETW  97
        RETW  121
        RETW  0
        RETW  84
        RETW  117
        RETW  101
        RETW  115
        RETW  100
        RETW  97
        RETW  121
        RETW  0
        RETW  77
        RETW  121
        RETW  83
        RETW  116
        RETW  114
        RETW  105
        RETW  110
        RETW  103
        RETW  0
        RETW  72
        RETW  101
        RETW  108
        RETW  108
        RETW  111
        RETW  32
        RETW  119
        RETW  111
        RETW  114
        RETW  108
        RETW  100
        RETW  0
sub
        MOV   i,W
                        ;    // reading the 'const' table
                        ;    int16 t = tx[i];
        CLRB  3.Carry
        MOV   W,<<i
        CALL  _const1
        MOV   t,W
        MOV   W,++ci
        CALL  _const1
        MOV   t+1,W
                        ;
                        ;    const char *p = str;
        MOV   W,#20
        MOV   p,W
                        ;    i = *p;
        CALL  _const1
        MOV   i,W
                        ;    p = "Hello world";
        MOV   W,#89
        MOV   p,W
                        ;    i = *p;
        CALL  _const1
        MOV   i,W
                        ;
                        ;    char si;
                        ;    p = txtp[si].str;
        MOV   W,#29
        ADD   W,si
        CALL  _const1
        MOV   p,W
                        ;    i = *p;
        CALL  _const1
        MOV   i,W
                        ;}
        RET  
                        ;
                        ;
                        ;
                        ;
                        ;// **********************************************************************
                        ;// **********************************************************************
                        ;// **********************************************************************
                        ;
                        ;// DATA CAN BE STORED DIRECTLY IN PROGRAM MEMORY
                        ;// NOTE: This is for special needs, when 'const' tables is not sufficient
                        ;
                        ;#define CDATA_START  0x600
                        ;#pragma cdata[CDATA_START]  // start of cdata block
                        ;
                        ;// STORE 12 bits data
                        ;#pragma cdata[] = 0xFFF, 0x200, 0x100
                        ;
                        ;// CONSTANT EXPRESSIONS ARE EVALUATED BEFORE STORING
                        ;#pragma cdata[] = 0x100, (10<<2) + 346,\
                        ;                  10, 456, 1000
                        ;
                        ;
                        ;#define D8(l,h)  l + h*128
                        ;#define D16(x)  x%0x100, x/0x100
                        ;
                        ;// STORE 8 AND 16 BITS DATA
                        ;#pragma cdata[] = D8(10,20), D16(23453)
                        ;
                        ;// AUTOMATIC ADDRESS CALCULATION
                        ;#pragma cdata.ID0 = 0x10, 200+300
                        ;#pragma cdata.ID1 = "Hello world\0"
                        ;#pragma cdata.ID2 = "Another string\r\n" "merged"
                        ;
                        ;// STORE A TABLE OF 16 BIT ADDRESSES TO ROM CODE
                        ;#pragma cdata.ID_TABLE = ID0, ID1, ID2  // store addresses
                        ;
                        ;#pragma cdata.CDATA_END    // end of cdata block
                        ;
                        ;
                        ;#pragma origin CDATA_END  // program code follow right after
        ORG $0632
                        ;
                        ;
                        ;void write(uns16 strID)
                        ;{
write
                        ;    while (1)  {
                        ;        MODE = strID.high8;
m001    MOV   W,strID+1
        MOV   M,W
                        ;        W = strID % 256;
        MOV   W,strID
                        ;        iread();
        IREAD
                        ;        if (W == '\0')
        XOR   W,#0
        SNB   3.Zero_
                        ;            return;
        RET  
                        ;        // write W to device
                        ;        strID ++;
        INC   strID
        SNB   3.Zero_
        INC   strID+1
                        ;    }
        JMP   m001
                        ;}
                        ;
                        ;
                        ;// **********************************************************************
                        ;// **********************************************************************
                        ;// **********************************************************************
                        ;
                        ;/* NOTE: functions using labels in the directly stored data must be
                        ;   defined after the data definitions */
                        ;
                        ;void pointers( void)
                        ;{
pointers
                        ;    write(ID1);
        MOV   W,#13
        MOV   strID,W
        MOV   W,#6
        MOV   strID+1,W
        CALL  write
                        ;    write(ID2);
        MOV   W,#25
        MOV   strID,W
        MOV   W,#6
        MOV   strID+1,W
        JMP   write
                        ;}
                        ;
                        ;
                        ;page0 void main(void)
                        ;{
        ORG $0083
main
                        ;    sub(3);
        MOV   W,#3
        CALL  sub
                        ;    pointers();
        PAGE  1536
        CALL  pointers
        PAGE  0
                        ;}
        SLEEP

        ORG $07FF
        GOTO main
        ORG $0600
        DW $FFF
        DW $200
        DW $100
        DW $100
        DW $182
        DW $00A
        DW $1C8
        DW $3E8
        DW $A0A
        DW $09D
        DW $05B
        DW $010
        DW $1F4
        DW $048
        DW $065
        DW $06C
        DW $06C
        DW $06F
        DW $020
        DW $077
        DW $06F
        DW $072
        DW $06C
        DW $064
        DW $000
        DW $041
        DW $06E
        DW $06F
        DW $074
        DW $068
        DW $065
        DW $072
        DW $020
        DW $073
        DW $074
        DW $072
        DW $069
        DW $06E
        DW $067
        DW $00D
        DW $00A
        DW $06D
        DW $065
        DW $072
        DW $067
        DW $065
        DW $064
        DW $60B
        DW $60D
        DW $619
        END