
PocketLilC and PocketViC version 1.09  Copyright (c) 2002 by Jim Steuert

questions to jsteuert@hotmail.com


NOTES: 
=====

 1) LONG AND SHORT ALIGNMENT: On the StrongARM chip, for all ram
   variables (global and malloc'd ram data), alignment is of
   critical importance. Longs must be aligned on 4-byte boundaries,
   shorts on 2-byte boundaries. (like the old IBM 360 Mainframe days).

 2) IMMEDIATES: ARM  immediate operands for most instructions
    require that they be of the 12-bit binary form  rrrr bbbb bbbb,
	where bbbb bbbb is an 8-bit unsigned value, and rrrr is a
	rotation, which is doubled. So, for example, 8b6 immediate
	value encoding becomes hex b6 rotated right (8*2) bits or 00b60000.

 3) DATA ARRAY VARIABLES:
    Of course, all elements of an array must be aligned based
	on that particular size: char, short, or long.
	
	Datavars for this compiler are given an offset
    off of r10. The first 128-byte area is for function pointers,
	so data vars start at 128 off of r10.

    THERE IS AN ADDITIONAL REQUIREMENT FOR ALIGNING THE START OF ARRAYS.

	This means for the first 512 bytes off of r10 (384 bytes of datavars),
	all arrays (even char arrays) must start at least 2-byte alignment.
	For up to 1024 bytes, all arrays must start at 4-byte alignment,
	up to 2048 bytes, all arrays must start at 8-byte alignment.

	This alignment is necessary so that the offset fits into
	an embedded immediate 12-bit value as in note 2.

    THIS ALIGNMENT IS NOT AUTOMATIC, YOU MUST CHECK ALIGNMENT
	YOURSELF. IF WRONG, YOUR PROGRAM WILL CRASH.



PocketVic C Compilation
=======================
>cc
>cc -S
>cc <progname>
>cc -S <progname>

Running Compiled Program
========================
>run

PocketViC   C  Syntax:
======================

start  <progname>
//
// this is a comment
//
  char/long/short  <datavar> ;
  char/long/short  *<datavar> ;
  char/long/short  <datavar>[dimension] ;
  char/long/short  <datavar> = constant ;
  char/long/short  <datavar>[dimension] = { constant, constant, ... } ;

main
{
  ...datavar definitions...
  reg char/long/short <regvar> ;
  reg char/long/short *<regvar> ;
  ...
  long *avp;
  avp = argv;  (must be done as first stmt if argv used)
  ...
}

subroutine  <subname1>
{
  ...datavar definitions...
  ...regvar  definitions...
  ...
}

subroutine  <subname2>
{
  ...datavar definitions...
  ...regvar  definitions...
  ...
}
...
end


PocketViC  C Statements (1 per line)
====================================

1. FOR/BREAK/CONTINUE STATEMENTS
================================
  for (  regvar  =  k1 ;  regvar <  regvar2/k2   ; regvar ++/+= k3 )
  {
  ...stmts...
  ...   break;
  ...   continue;
  ...stmts...
  }

2. IF STATEMENT
===============
  if (  regvar     ==  !=  >=  <=  >  <    regvar2/#imm )
  {
   ...
  }

3. GOTO/LABEL STATEMENT
=======================
  goto <label>;

<label>:

4. EXIT STATEMENT
=================
  exit exit(

5. RETURN STATEMENT
===================
  return
  return( regvar/constant )

6. SUBROUTINE STATEMENT
=======================
  subroutine  <subroutinename>
  {
    reg  char/short/long  <regvarname> ;
    reg  char/short/long  *<regvarname> ;
    -- arguments referenced as regvars: r0, r1, r2, r3 ---
      <regvar> = r0;  copy immediately if to be used repeatedly
      <regvar> = r1;
    ...
    ... other statements ...
  }

7. SUBROUTINE CALLS
===================
  set reg = function( dataref, dataref, ... )
  where function is:
    1. own subroutine
    2. one of:
        printf strtoul memcpy memcmp strcpy strcat strcmp sprintf
        open lseek read write close malloc free dialog message
        fopen fgets fclose

8.  UNARY OPERATION STATEMENTS
==============================
  regvar  unary-operator   regvar;
   unary-operator:
         =  +=  -=  &=  |=  ^=   >>  <<  <<<  >>>  =~

9. ASSIGNMENT STATEMENTS
========================
  dataref  =  dataref ;

10. ARITHMETIC STATEMENTS
========================
  dataref  =  dataref  operator  dataref ;

WHERE:
======
  operator is one of:
     ^  +  -  |  *  *<  &~  &
  dataref is one of:
    *regvar++
    *regvar
    regvar[constant]
    regvar[regvar]
    regvar
    datavar
    datavar[constant]
    datavar[regvar]
    constant
    &datavar  or datavar if datavar is an array
    "literal string"

