/*******************************************************************************
*
* Driver for CPLD Display written as CFunctions
*
* (c) Peter Mather 2015 with acknowledgements to Peter Carnegie & Geoff Graham
* was SSD1963_44 modified by Trevor Henshaw 21/May/2018
*
* This CFunction MUST be compiled with Optimization Level 1, -O1
* -O2,-O3,-Os will compile successfully, but generate exceptions at runtime.
*
* When Generating the CFunction, use MERGE CFunction mode, and name the CFunction
* CPLDinit
*
* Entry point is function long long main(long long *MyAddress,
* long long *RST,
* long long *orientation
* long long *size)
*
* V1.0 2015-07-21 Peter Mather
* 1.01 Change orientation codes to 1:landscape, 2:portrait, 3:rlandscape, 4:rportrait
* 1.02 Use fixed PortC pinout for maximum performance
* 1.03 Stripped routines for use as loadable LIBRARY
* 1.04 Conditional compilation for 44 and 64-pin parts
* 1.1 Convert to Nathan approach
* 1.11 Minor change for compatibility with touch and restricting page usage
* 1.2 Implement RGB565, add-in triangle drawing read/write
******************************************************************************/
#define Version 111 //Version 1.11
#include <stdarg.h>
#include <xc.h> // Required for SFR defs
#include <sys/attribs.h> // Required to use __longramfunc__
#include "CFunctions.h"
#define MX470 //Comment out for compilation for 44-pin part
#define pin100
#define RGB565
#define aport *(volatile unsigned int *)(0xbf886030) //latch registers
#define aclrport *(volatile unsigned int *)(0xbf886034) //latch registers
#define asetport *(volatile unsigned int *)(0xbf886038) //latch registers
#define aread *(volatile unsigned int *)(0xbf886020) //latch registers
#define atrisinv *(volatile unsigned int *)(0xbf88601C) //latch registers
#define bclrport *(volatile unsigned int *)(0xbf886134) //latch registers
#define bsetport *(volatile unsigned int *)(0xbf886138) //latch registers
#define cport *(volatile unsigned int *)(0xbf886230) //latch registers
#define cread *(volatile unsigned int *)(0xbf886220) //latch registers
#define ctrisinv *(volatile unsigned int *)(0xbf88621C) //latch registers
#define cclrport *(volatile unsigned int *)(0xbf886234) //latch registers
#define csetport *(volatile unsigned int *)(0xbf886238) //latch registers
#define eport *(volatile unsigned int *)(0xbf886430) //latch registers
#define eread *(volatile unsigned int *)(0xbf886420) //latch registers
#define etrisinv *(volatile unsigned int *)(0xbf88641C) //latch registers
#define eclrport *(volatile unsigned int *)(0xbf886434) //latch registers
#define esetport *(volatile unsigned int *)(0xbf886438) //latch registers
#define DEVID (*(volatile unsigned int *)0xBF80F220)
#define swap(a, b) {int t; t = a; a = b; b = t; }

//Offsets into the persistent RAM of variables
#ifdef MX470
#ifndef pin100
#define RS_Pin_No 27
#define WR_Pin_No 24
#define RS_Pin 0x1000
#define WR_Pin 0x0800
#define clrport bclrport
#define setport bsetport
#else
#define RS_Pin_No 18
#define WR_Pin_No 19
#define RS_Pin 0x100
#define WR_Pin 0x200
#define RD_Pin_No 6
#define clrport eclrport
#define setport esetport
#endif
#define port eport // Data port Db0-Db7
#define portH aport // Data port Db8-Db15
#define read eread
#define trisinv etrisinv
#define RSLo PinSetBit(RS_Pin_No,LATCLR);
#define RSHi PinSetBit(RS_Pin_No,LATSET);
#define WRLo {PinSetBit(WR_Pin_No,LATCLR);asm("NOP");}
#define WRHi {PinSetBit(WR_Pin_No,LATSET);asm("NOP");}
#else
#define RS_Pin_No 4
#define WR_Pin_No 5
#define RS_Pin 0x100
#define WR_Pin 0x200
#define clrport cclrport
#define setport csetport
#define port cport
#define read cread
#define trisinv ctrisinv
#define RSLo clrport=RS_Pin
#define RSHi setport=RS_Pin
#define WRLo clrport=WR_Pin
#define WRHi setport=WR_Pin
#endif
#define Both WR_Pin | RS_Pin
#define RDLo (*(volatile unsigned int *)RDclrport)=RDpin
#define RDHi (*(volatile unsigned int *)RDsetport)=RDpin
#define LANDSCAPE 1
#define PORTRAIT 2
#define RLANDSCAPE 3
#define RPORTRAIT 4

/*************************************************************************
*
* defines start/end coordinates for memory access from host to SSD1963
* also maps the start and end points to suit the orientation
*
* This function is a modified version of the function inside the MMBasic
* Interpreter for MM+ on 'MX470 chips
*
*
**************************************************************************/
void defineregion(long x, long y, long width,long height){ //Address Set
long x1=x,x2=x+width-1,y1=y,y2=y+height-1;
unsigned long xstart,xend,ystart,yend,Vertical,Horizontal;
RSLo;
if(HRes>VRes){
Vertical=VRes;
Horizontal=HRes;
}
else {
Vertical=HRes;
Horizontal=VRes;
}
if(Option->DISPLAY_ORIENTATION!=LANDSCAPE)goto isP;
xstart = x1;
xend = x2;
ystart = y1;
yend = y2 ; //Must be Landscape
goto setreg;
isP:
if(Option->DISPLAY_ORIENTATION!=PORTRAIT)goto isRL;
xstart = y1;
xend = y2;
ystart = (Vertical - 1) - x2;
yend = (Vertical - 1) - x1;
goto setreg;
isRL:
if(Option->DISPLAY_ORIENTATION!=RLANDSCAPE)goto isRP;
xstart = (Horizontal - 1) - x2;
xend = (Horizontal - 1) - x1;
ystart = (Vertical - 1) - y2;
yend = (Vertical - 1) - y1;
goto setreg;
isRP:
xstart = (Horizontal - 1) - y2;
xend = (Horizontal - 1) - y1;
ystart = x1;
yend = x2;
setreg:
// Address Set these are the registers used for setting screen work area
port=0x02; RSLo; WRLo; WRHi; // RS low
portH=(ystart>>8 ); RSHi;
port=(ystart & 0x00FF) | Both; WRLo; WRHi; // RS HIGH
port=0x03; RSLo; WRLo; WRHi; // RS low
portH=(xstart>>8 ); RSHi;
port=(xstart & 0x00FF) | Both; WRLo; WRHi; // RS HIGH
port=0x06; RSLo; WRLo; WRHi; // RS low
portH=(yend>>8 ); RSHi;
port=(yend & 0x00FF) | Both; WRLo; WRHi; // RS HIGH RSHi;
port=0x07; RSLo; WRLo; WRHi; // RS low
portH=(xend>>8 ); RSHi;
port=(xend & 0x00FF) | Both; WRLo; WRHi; // RS HIGH*/
port=0x0F; RSLo; WRLo; WRHi; // RS low
}

void DisplayPage(int pg){ // NOT implemented
if(pg > 7) {pg = 0;}
port=0x04; RSLo; WRLo; WRHi; // RS low
port=(pg & 0x00FF) | Both; RSHi; WRLo; WRHi; // RS HIGH*/
}

void WritePage(int pg){ // Not implemented
if(pg > 7) {pg = 0;}
port=0x05; RSLo; WRLo; WRHi; // RS low
port=(pg & 0x00FF) | Both; RSHi; WRLo; WRHi; // RS HIGH*/
}

/***********************************************************************************************
* Display the bitmap of a char on the TFT panel
*
* This function is NEVER called by MMBasic programs
*
* This is optimised for the
* x, y - the top left of the char
* width, height - size of the char's bitmap
* scale - how much to scale the bitmap
* fg, bg - foreground and background colour
* bitmap - pointer to the butmap
*
* This function is a modified version of the function inside the MMBasic Interpreter
* for MM+ on 'MX470 chips
***********************************************************************************************/
void DrawBitmap_CPLD(int x1, int y1, int width, int height, int scale, int fc, int bc, unsigned char *bitmap ){
long i, j, k, m, n;
unsigned int fhb, flb, bhb, blb, xtest, ytest;
unsigned char *p;
xtest=HRes;
ytest=VRes;
fhb = ((fc >> 16) & 0b11111000) | ((fc >> 13) & 0b00000111);
flb = ((fc >> 5) & 0b11100000) | ((fc >> 3) & 0b00011111);
bhb = ((bc >> 16) & 0b11111000) | ((bc >> 13) & 0b00000111);
blb = ((bc >> 5) & 0b11100000) | ((bc >> 3) & 0b00011111);
n=0;
defineregion(x1,y1,width*scale,height*scale);
RSHi;
for(i = 0; i < height; i++) { // step thru the font scan line by line
for(j = 0; j < scale; j++) { // repeat lines to scale the font
for(k = 0; k < width; k++) { // step through each bit in a scan line
for(m = 0; m < scale; m++) { // repeat pixels to scale in the x axis
if(x1 + k * scale + m >= 0 && x1 + k * scale + m < xtest && y1 + i * scale + j >= 0 && y1 + i * scale + j < ytest) { // if the coordinates are valid
if((bitmap[((i * width) + k)/8] >> (((height * width) - ((i * width) + k) - 1) %8)) & 1) {
portH = fhb;
port = (flb & 0xFF) | Both;
WRLo; WRHi;
} else {
// if(bc==1 && Option->LCD_CS!=0){
portH = bhb;
port = (blb & 0xFF) | Both;
WRLo; WRHi;
n+=2;
// }
}
}
}
}
}
}
// }
if(bc==1 && Option->LCD_CS!=0) FreeMemory(p);
}

/******************************************************************
*
* Called by MMBasic Interpreter to draw a rectangle
* on the CPLD panel
*
* This function is NEVER called by MMBasic programs
*
*
*****************************************************************/

void DrawRectangle_CPLD(int x1, int y1, int x2, int y2, int fc){
int t,j;
long width, height;
unsigned long i,ch,cl;
// make sure the coordinates are kept within the display area
if(x2 <= x1) { t = x1; x1 = x2; x2 = t; }
if(y2 <= y1) { t = y1; y1 = y2; y2 = t; }
if(x1 < 0) x1 = 0; if(x1 >= HRes) x1 = HRes - 1;
if(x2 < 0) x2 = 0; if(x2 >= HRes) x2 = HRes - 1;
if(y1 < 0) y1 = 0; if(y1 >= VRes) y1 = VRes - 1;
if(y2 < 0) y2 = 0; if(y2 >= VRes) y2 = VRes - 1;
width=x2-x1+1;
height=y2-y1+1;
i=width*height;
//Convert fc to RGB565
ch = ((fc >> 16) & 0b11111000) | ((fc >> 13) & 0b00000111);
cl = ((fc >> 5) & 0b11100000) | ((fc >> 3) & 0b00011111);
//ch = (((fc>>19)&0x1F)<<11)|(((fc>>10)&0x3F)<<6)|(((fc>>3)&0x1F));
defineregion(x1,y1,width,height);
RSHi;
for(i = 0; i < width; i++){
for(j = 0; j < height; j++){
portH = ch;
port = (cl & 0x00FF) | Both;
WRLo; WRHi;
}
}
}
int ReadRectangle(int x1, int y1, int width, int height, int pos, char *p ){
int j,RDpin, RDsetport, RDclrport;
RDpin=1<<GetPinBit(Option->LCD_CS);
RDsetport=(unsigned int)GetPortAddr(Option->LCD_CS,LATSET);
RDclrport=(unsigned int)GetPortAddr(Option->LCD_CS,LATCLR);

#ifdef RGB565
j=width*height*2+pos;
#else
j=width*height*3+pos;
#endif
defineregion(x1,y1,width,height);
#ifdef MX470
#ifndef pin100
RSLo;
#endif
#endif
port=0x22E ; WRLo; WRHi; // RS low
#ifdef MX470
#ifndef pin100
RSHi;
#endif
#endif
trisinv=0xFF; //set pins to read
#ifdef RGB565
atrisinv=0xFF;
#endif
do { //read in the screen area to be overlayed
#ifndef RGB565
RDLo;
asm("NOP");asm("NOP");asm("NOP");
RDHi;
p[pos++]=(read & 0xFF);
RDLo;
asm("NOP");asm("NOP");asm("NOP");
RDHi;
p[pos++]=(read & 0xFF);
RDLo;
asm("NOP");asm("NOP");asm("NOP");
RDHi;
p[pos++]=(read & 0xFF);
#else
RDLo;
asm("NOP");asm("NOP");asm("NOP");
RDHi;
p[pos++]=(read & 0xFF);
p[pos++]=(aread & 0xFF);
#endif
} while(pos<j);
trisinv=0xFF; //set pins to write
#ifdef RGB565
atrisinv=0xFF;
#endif


}
int RestoreRectangle(int x1, int y1, int width, int height, int pos, char p[]){
int i;
defineregion(x1,y1,width,height);
i=width*height;
#ifdef MX470
#ifndef pin100
RSLo;
#endif
#endif
#ifdef RGB565
aclrport=0xFF;
#endif
port=0x22C ; WRLo; WRHi; // RS low
#ifdef MX470
#ifndef pin100
RSHi;
#endif
#endif
#ifdef RGB565
while (i--) {
port=p[pos++] | Both; asetport=p[pos]; aclrport=(p[pos++]^0xFF);
WRLo; WRHi;
}
#else
while(i--){
port=p[pos++] | Both; WRLo; WRHi;
port=p[pos++] | Both; WRLo; WRHi;
port=p[pos++] | Both; WRLo; WRHi;
}
#endif
return pos;
}
long triangles(int mode, int buffpos, char *buff, long col, long x0, long y0, long x1, long y1,long x2, long y2) {//Cfunction
long a, b, y, last;
long dx01, dy01, dx02, dy02, dx12, dy12, sa, sb;

if (y0>y1) {
swap(y0, y1);
swap(x0, x1);
}
if (y1>y2) {
swap(y2, y1);
swap(x2, x1);
}
if (y0>y1) {
swap(y0, y1);
swap(x0, x1);
}
if(y0==y2) { // Handle awkward all-on-same-line case as its own thing
a=x0;
b=x0;
if(x1<a) {
a=x1;
} else {
if(x1>b) b=x1;
}
if(x2<a) {
a=x2;
} else {
if(x2>b) b=x2;
}
if(mode==0){
buffpos=ReadRectangle(a,y0,1,b-a+1,buffpos,buff);
} else if(mode==1) {
buffpos=RestoreRectangle(a,y0,1,b-a+1,buffpos,buff);
} else {
DrawRectangle_CPLD(a,y0,a,b-a+y0,col);
}
} else {
dx01=x1-x0; dy01=y1-y0; dx02=x2-x0; dy02=y2-y0; dx12=x2-x1; dy12=y2-y1; sa=0; sb=0;
if(y1==y2) {
last=y1; //Include y1 scanline
} else {
last=y1-1; // Skip it
}
for (y=y0;y<=last;y++){
a=x0+sa / dy01;
b=x0+sb / dy02;
sa=sa+dx01;
sb=sb+dx02;
a=x0+(x1-x0) * (y-y0) / (y1-y0);
b=x0+(x2-x0) * (y-y0) / (y2-y0);
if(a>b)swap(a,b);
if(mode==0){
buffpos=ReadRectangle(a,y,b-a+1,1,buffpos,buff);
} else if(mode==1) {
buffpos=RestoreRectangle(a,y,b-a+1,1,buffpos,buff);
} else {
DrawRectangle_CPLD(a,y,b,y,col);
}
}
sa=dx12 * (y-y1);
sb=dx02 * (y-y0);
while (y<=y2){
a=x1+sa / dy12;
b=x0+sb / dy02;
sa=sa+dx12;
sb=sb+dx02;
a=x1+(x2-x1) * (y-y1) / (y2-y1);
b=x0+(x2-x0) * (y-y0) / (y2-y0);
if(a>b) swap(a,b);
if(mode==0){
buffpos=ReadRectangle(a,y,b-a+1,1,buffpos,buff);
} else if(mode==1) {
buffpos=RestoreRectangle(a,y,b-a+1,1,buffpos,buff);
} else {
DrawRectangle_CPLD(a,y,b,y,col);
}
y=y+1;
}
}

return buffpos;
}

__attribute__((noinline)) void getFPC(void *a, void *b, volatile unsigned int *c)
{
*c = (unsigned int) (__builtin_return_address (0) - (b -a)) ;
}
void pstring(const char *s){
volatile unsigned int libAddr ;
getFPC(NULL,&&getFPCLab,&libAddr) ; // warning can be ignored, stupid editor
getFPCLab: { }
unsigned char * testData = (unsigned char *)((void *)s + libAddr );
MMPrintString(testData);
}

/*******************************************************************************
*
* CPLDinit : Initialise the CFunction Driver Sub-System
*
* Function called to initialise the driver SubSystem
*
* CPLDinit is ALWAYS called from an MMBasic program
* On exit, vectors DrawRectangleVector, and DrawBitmapVector will
* be set to point to the CFunctions DrawRectangle_SSD1963 and
* DrawBitmap_SSD1963 respectively
*
* Input Arguments
* MyAddress: The Address of the CFunction, use PEEK(CFUNADDR CPLDinit)
* RST: The pin connected to the Reset input on the display
* orientation:
* is 0 for Portrait orientation, 1 for reverse portrait, 2 for landscape, 3 for reverse landscape
* size: The display size 4, 5, or 7"
*
* Exit Value Version
*
* Note, For added performance, it may be desirable to create a
* separate WriteData function which doen't asser/de-asser CS for each byte and
* instead use block CSLo/CSHi around data transfers. These "block" CSLo/CSHi
* statements have been left in the code as comments.
*
******************************************************************************/
//CFunction CPLDinit
long long main(char *orientation, unsigned char *p1, long long p2[], long long p3[], long long p4[], long long p5[], long long p6[],long long p7[], long long p8[]){
int t,HorizontalRes,VerticalRes;
unsigned int p[17];
int i,j,c;
if(Option->LCD_CS){
PinSetBit(Option->LCD_CS, LATSET);
}
volatile unsigned int libAddr ;
getFPC(NULL,&&getFPCLab,&libAddr) ; // warning can be ignored, stupid editor
getFPCLab: { }

if(*orientation>=0 && *orientation<=4){
Option->DISPLAY_ORIENTATION=*orientation;
Option->LCD_CS=0;
#ifndef MX470
if(p2[0])Option->LCD_CS=p2[0];
#else
if(*p1)Option->LCD_CS=*p1;
#endif
Option->DISPLAY_ORIENTATION=*orientation;
Option->LCD_CD=*p2; //save the display size as the display type for use in the driver routines

#ifdef MX470
#ifndef pin100
Option->LCD_Reset=28;
p[0]=60;
p[1]=61;
p[2]=62;
p[3]=63;
p[4]=64;
p[5]=1;
p[6]=2;
p[7]=3;
#else
Option->LCD_Reset=42;
p[0]=93;
p[1]=94;
p[2]=98;
p[3]=99;
p[4]=100;
p[5]=3;
p[6]=4;
p[7]=5;
p[8]=17;
p[9]=38;
p[10]=58;
p[11]=59;
p[12]=60;
p[13]=61;
p[14]=91;
p[15]=92;
p[16]=48;
#endif

#else
Option->LCD_Reset=*p1;
p[0]=25;
p[1]=26;
p[2]=27;
p[3]=36;
p[4]=37;
p[5]=38;
p[6]=2;
p[7]=3;
#endif
for(j=0;j<17;j++){
ExtCfg(p[j],EXT_DIG_OUT,0);ExtCfg(p[j],EXT_BOOT_RESERVED,0);
PinSetBit(p[j],LATCLR);
}
//Control Signals
ExtCfg(RS_Pin_No,EXT_DIG_OUT,0);ExtCfg(RS_Pin_No,EXT_BOOT_RESERVED,0);
RSHi;

ExtCfg(WR_Pin_No,EXT_DIG_OUT,0);ExtCfg(WR_Pin_No,EXT_BOOT_RESERVED,0);
WRHi;

ExtCfg(Option->LCD_Reset,EXT_DIG_OUT,0);ExtCfg(Option->LCD_Reset,EXT_BOOT_RESERVED,0);
PinSetBit(Option->LCD_Reset, LATSET);

if(Option->LCD_CS){
ExtCfg(Option->LCD_CS, EXT_DIG_OUT,0);
ExtCfg(Option->LCD_CS, EXT_BOOT_RESERVED,0);
PinSetBit(Option->LCD_CS, LATSET);
}

//Save DisplayMetrics
if(Option->LCD_CD<5){
HorizontalRes=480;
// if(Option->DISPLAY_ORIENTATION==1) VerticalRes=272*3; //3 frame buffers
/*else*/ VerticalRes=272;
} else {
HorizontalRes=800;
VerticalRes=480;
HRes = 800;
VRes = 480;
}

//Reset the CPLD
PinSetBit(Option->LCD_Reset,LATSET);
uSec(10000);
PinSetBit(Option->LCD_Reset,LATCLR);
uSec(10000);
PinSetBit(Option->LCD_Reset,LATSET);
uSec(10000);
port=0x0F; RSLo; WRLo; WRHi; // RS low
port=0x01; RSLo; WRLo; WRHi; // RS low
port=0x10; RSHi; // RS high
portH=0x00 | Both; WRLo; WRHi; // RS high
port=0x0F; RSLo; WRLo; WRHi;// RS low
PinSetBit(p[16],LATSET); //Turn on backlight

if(Option->DISPLAY_ORIENTATION&1){
HRes=HorizontalRes;
VRes=VerticalRes;
} else {
VRes=HorizontalRes;
HRes=VerticalRes;
}
//Save the current values of the Vectors

//Set the DrawRectangle vector to point to our function
DrawRectangleVector= (unsigned int)&DrawRectangle_CPLD + libAddr;

//Set the DrawBitmap vector to point to our function
DrawBitmapVector=(unsigned int)&DrawBitmap_CPLD + libAddr;
// DisplayPageVector=(unsigned int)&DisplayPage +libAddr;
// WritePageVector=(unsigned int)&WritePage +libAddr;

//Clear Screen to Black
if(Option->LCD_CD<5) {
DrawRectangle(0,0,HRes-1,VRes*3-1,0x000000);
} else {
DrawRectangle(0,0,HRes-1,VRes-1,0x000000);
}
#ifdef MX470
#ifndef pin100
static const char startup[]="SSD1963_64 driver loaded\r\n";
#else
static const char startup[]="CPLD_100 driver loaded\r\n";
#endif
#else
static const char startup[]="SSD1963_44 driver loaded\r\n";
#endif
pstring(startup);
}
} // . EVERYTHING BELOW COMMENTED OUT
/* else if(*orientation==5){
int num=p1[0],a=1;
unsigned char ch,cm;
if(p2!=NULL){
num=*p2-1;
a=0;
}
#ifdef RGB565
while (a<num) {
// port=p1[a++] | Both; asetport=p1[a]; aclrport=(p1[a++]^0xFF);
ch=p1[a++] & 0b11111000;
ch|=p1[a]>>5;
cm=(p1[a++]<<3) & 0b11100000;
cm|=(p1[a++]>>3);
port=cm | Both; asetport=ch; aclrport=(ch^0xFF);
WRLo; WRHi;
}
#else
while(a<num){
port=p1[a++] | Both; WRLo; WRHi;
port=p1[a++] | Both; WRLo; WRHi;
port=p1[a++] | Both; WRLo; WRHi;
}
#endif
} else if(*orientation==6){
return ReadRectangle(*p2, *p3, *p4, *p5, *p6, p1 );
} else if(*orientation==7){
return RestoreRectangle(p2[0], p3[0], p4[0], p5[0], p6[0], p1 );
} else if(*orientation==8){
defineregion(*p1, *p2, *p3, *p4);
#ifdef MX470
#ifndef pin100
RSLo;
#endif
#endif
#ifdef RGB565
aclrport=0xFF;
#endif
port=0x22C ; WRLo; WRHi; // RS low
#ifdef MX470
#ifndef pin100
RSHi;
#endif
#endif
return 8;
} else if(*orientation==9){
if(Option->DISPLAY_ORIENTATION==1){
VRes=272*3;
j=(*p1-1) * 272;
write_command_data(0x37,2,j>>8,j&0xFF);
}
}
#ifdef RGB565
else if(*orientation==10){
int num=p1[0],a=1,astore;
astore=aport & 0xFF00;
if(p2!=NULL){
num=*p2-1;
a=0;
}
while (a<num) {
aport=p1[a++]|astore;
port=p1[a++] | Both;
WRLo; WRHi;
}
#endif
} else { //must be triangles
int count=*orientation & 0x7F;
int i=0,j,buffpos=0;
while(i<count && p2<0){ //repeat for any restores
buffpos=triangles(1,buffpos,p1,p2,p3,p4,p5,p6,p7,p8);
i++;
}
buffpos=0;
j=i;
while(i<count && p2>=0){ //repeat for any store and write commands
buffpos=triangles(0,buffpos,p1,p2,p3,p4,p5,p6,p7,p8);
i++;
}
i=j;
while(i<count && p2>=0){ //repeat for any store and write commands
buffpos=triangles(2,buffpos,p1,p2,p3,p4,p5,p6,p7,p8);
i++;
}
return buffpos>>3;

}*/
//}

CFunction SGetStr(float, integer, integer) string

void myfunc(int *fred, int *bert){
if(bert==NULL)....
}