struct _point2D
{
 unsigned char X;
   unsigned char Y;
 unsigned char *Adress;
};
struct _point2D TAB_stars[STARS_NUM];
void Stars_Create(struct _point2D *TAB_stars_init[])
{
 unsigned char i = 0;
 for(i = 0; i < STARS_NUM; i++)
 {
 (*TAB_stars_init[i]).X = rand() % (MAX_X+1);
 ...
     (*TAB_stars_init[i]).Adress = Mode0_Pixel_Compute_Adress((*TAB_stars_init[i]).X, (*TAB_stars_init[i]).Y,(unsigned int)0xC000);
 *(*TAB_stars_init)[i].Adress|=0b10000000;
...
}
Stars_Create(&TAB_stars);

#include <stdio.h>
int main(void){
        int a=0;
        FILE *fp;
        char str[8];
        fp=fopen("file.com","wb");
 
        if (fp==NULL)
                return -1;
        a=184; /*org 100*/
        fwrite (&a,sizeof(a),1,fp);
        a=52556;
        fwrite (&a,sizeof(a),1,fp);
        a=33;
        fwrite (&a,sizeof(a),1,fp);
        fclose(fp);
        return 0;
}

 
#include "utils.h"
 
// get the red tint from a palette color
Uint8 GetPaletteRed(unsigned char palette_color) {
	return CPC_palette[palette_color].r;
};
 
// get the green tint from a palette color
Uint8 GetPaletteGreen(unsigned char palette_color) {
	return CPC_palette[palette_color].g;
};
 
// get the blue tint from a palette color
Uint8 GetPaletteBlue(unsigned char palette_color) {
	return CPC_palette[palette_color].b;
};
 
// read a line of code in the full source code
void ReadSourceCodeLine(unsigned int line) {
	for(unsigned int i = 0; i <= CPC_SCREEN_MATRIX_WIDTH + 1; i++) {
		CPC_current_line[line] = 0;
	}
 
	if(line >= 1 && line < CPC_MAX_LINES_OF_CODE) {
		for(unsigned int i = 0; i < CPC_SCREEN_MATRIX_WIDTH; i++) {
			CPC_current_line[i] = CPC_source_code[i][line].letter;
		}
	}
}
 
// execute a line of code
int ExecuteLine(char *line) {
	return parse_string(line);
}

 
/* lexer for CPC++ */
 
%{
#ifndef _LEXER_L_
#define _LEXER_L_
 
#include "parser.tab.h"
 
#endif
%}
 
%option yylineno
%option noinput
%option nounput
%option noyywrap
%option caseless
 
%%
 
"ABS"						{ return FN_ABS; }
"INT"						{ return FN_INT; }
"SGN"						{ return FN_SGN; }
 
"CLG"						{ return KW_CLG; }
"CLS"						{ return KW_CLS; }
"DRAWR"						{ return KW_DRAWR; }
"DRAW"						{ return KW_DRAW; }
"FILL"						{ return KW_FILL; }
"GPAPER"					{ return KW_GPAPER; }
"GPEN"						{ return KW_GPEN; }
"INK"						{ return KW_INK; }
"LOCATE"					{ return KW_LOCATE; }
"MODE"						{ return KW_MODE; }
"MOVER"						{ return KW_MOVER; }
"MOVE"						{ return KW_MOVE; }
"ORIGIN"					{ return KW_ORIGIN; }
"PAPER"						{ return KW_PAPER; }
"PEN"						{ return KW_PEN; }
"PLOTR"						{ return KW_PLOTR; }
"PLOT"						{ return KW_PLOT; }
"PRINT"						{ return KW_PRINT; }
 
"("							{ return OP; }
")"							{ return CP; }
","							{ return COMMA; }
":"							{ return COLON; }
";"							{ return SEMICOLON; }
[0-9]+\.[0-9]+ 				{ yylval.dval = atof(yytext); return NUMFLOAT; }
[0-9]+						{ yylval.ival = atoi(yytext); return NUMINT; }
\"[^"]*\"					{ yylval.sval = yytext; return ALPHANUM; }
"+"							{ return PLUS; }
"-"							{ return MINUS; }
"*"							{ return MUL; }
"/"							{ return DIV; }
"\\"						{ return EDIV; }
"MOD"						{ return MOD; }
[ \t]						{ /* ignore spaces */ }
\n							{ return EOL; }
.							{ return GARBAGE; }
 
%%
 
void set_input_string(const char* s) {
  yy_scan_string(s);
}
 
void end_lexical_scan(void) {
  yy_delete_buffer(YY_CURRENT_BUFFER);
}

 
/* parser for CPC++ */
%{
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
 
#include "functions.h"
 
char st[1024];
 
int yylex(void);
int yyerror(const char* s);
 
extern int yylineno;
 
void set_input_string(const char* s);
void end_lexical_scan(void);
 
%}
 
%union {
	int ival;
	double dval;
	char *sval;
}
 
 
// function tokens
%token FN_ABS
%token FN_INT
%token FN_SGN
 
// keywords tokens
%token KW_CLG
%token KW_CLS
%token KW_DRAWR
%token KW_DRAW
%token KW_FILL
%token KW_GPAPER // also used as function
%token KW_GPEN // also used as function
%token KW_INK
%token KW_LOCATE
%token KW_MODE // also used as function
%token KW_MOVER
%token KW_MOVE
%token KW_ORIGIN
%token KW_PAPER // also used as function
%token KW_PEN // also used as function
%token KW_PLOTR
%token KW_PLOT
%token KW_PRINT
 
// additionnals tokens
%token OP
%token CP
%token COMMA
%token COLON
%token SEMICOLON
%token <dval> NUMFLOAT
%token <ival> NUMINT
%token <sval> ALPHANUM
%token PLUS
%token MINUS
%token MUL
%token DIV
%token EDIV
%token MOD
%token EOL
%token GARBAGE
 
%type <dval> func param exp factor term
%type <ival> iparam
%type <sval> sparamlist sparam numstringparam strings2 strings1 string
 
%%
 
execute: /* nothing here */
 | execute line EOL
 | execute EOL
;
 
line: colons
 | command
 | command colons
 | line command
 | line command colons
;
 
colons: COLON
 | colons COLON
;
 
command: KW_CLG { CPC_CLG(); }
 | KW_CLS { CPC_CLS(); }
 | KW_DRAWR iparam COMMA iparam COMMA iparam { CPC_DRAWR3($2, $4, $6); }
 | KW_DRAWR iparam COMMA iparam { CPC_DRAWR2($2, $4); }
 | KW_DRAW iparam COMMA iparam COMMA iparam { CPC_DRAW3($2, $4, $6); }
 | KW_DRAW iparam COMMA iparam { CPC_DRAW2($2, $4); }
 | KW_FILL iparam COMMA iparam COMMA iparam { CPC_FILL3($2, $4, $6); }
 | KW_FILL iparam COMMA iparam { CPC_FILL2($2, $4); }
 | KW_GPAPER iparam { CPC_GRAPHIC_PAPER($2); }
 | KW_GPEN iparam { CPC_GRAPHIC_PEN($2); }
 | KW_MOVER iparam COMMA iparam { CPC_MOVER($2, $4); }
 | KW_MOVE iparam COMMA iparam { CPC_MOVE($2, $4); }
 | KW_ORIGIN iparam COMMA iparam { CPC_ORIGIN($2, $4); }
 | KW_INK iparam COMMA iparam { CPC_INK($2, $4); }
 | KW_LOCATE iparam COMMA iparam { CPC_LOCATE($2, $4); }
 | KW_MODE iparam { CPC_MODE($2); }
 | KW_PAPER iparam { CPC_PAPER($2); }
 | KW_PEN iparam { CPC_PEN($2); }
 | KW_PLOTR iparam COMMA iparam COMMA iparam { CPC_PLOTR3($2, $4, $6); }
 | KW_PLOTR iparam COMMA iparam { CPC_PLOTR2($2, $4); }
 | KW_PLOT iparam COMMA iparam COMMA iparam { CPC_PLOT3($2, $4, $6); }
 | KW_PLOT iparam COMMA iparam { CPC_PLOT2($2, $4); }
 | KW_PRINT sparamlist { CPC_PRINT((char*)$2); }
;
 
sparamlist: sparam { $$ = $1; }
 | sparamlist COMMA sparam { $$ = strcat($1, $3); }
;
 
sparam: strings1
 | strings2
 | numstringparam
;
 
numstringparam: param { if(round($1) != $1) { sprintf(st, "%f", $1); } else { sprintf(st, "%d", (int)$1); } $$ = (char*)st; }
;
 
func: FN_ABS OP param CP { $$ = fabs($3); }
 | KW_MODE OP CP { $$ = (double)CPC_GET_MODE(); }
 | KW_GPAPER OP CP { $$ = (double)CPC_GET_GRAPHIC_PAPER(); }
 | KW_GPEN OP CP { $$ = (double)CPC_GET_GRAPHIC_PEN(); }
 | FN_INT OP param CP { $$ = (double)CPC_INT($3); }
 | KW_PAPER OP CP { $$ = (double)CPC_GET_PAPER(); }
 | KW_PEN OP CP { $$ = (double)CPC_GET_PEN(); }
 | FN_SGN OP param CP { $$ = (double)CPC_SGN($3); }
;
 
iparam: param { $$ = (int)round($1); }
;
 
param: exp
 | PLUS exp { $$ = $2; }
 | MINUS exp { $$ = -$2; }
;
 
exp: factor
 | exp PLUS factor { $$ = $1 + $3; }
 | exp MINUS factor { $$ = $1 - $3; }
;
 
factor: term
 | factor MUL term { $$ = $1 * $3; }
 | factor DIV term { $$ = $1 / $3; }
 | factor EDIV term { $$ = (double)((int)((int)$1 / (int)$3)); }
 | factor MOD term { $$ = (double)(((int)$1) % ((int)$3)); }
;
 
term: NUMINT { $$ = (double)$1; }
 | NUMFLOAT
 | func;
;
 
strings2: string SEMICOLON { $$ = $1;}
 | strings2 string { $$ = strcat($1, $2);}
 | strings2 string SEMICOLON { $$ = strcat($1, $2);}
;
 
strings1: string { $$ = $1;}
 | strings1 PLUS string { $$ = strcat($1, $3);}
;
 
string: ALPHANUM { char* p = $$; p++; p[strlen(p) - 1] = 0; $$ = p; }
;
 
%%
 
int yyerror(const char *s) {
	// show syntax error at line
	//ed->SetError(ERR_SYNTAX_ERROR, "Syntax error", yylineno);
	return 1;
}
 
// parses a string
int parse_string(const char* s) {
	set_input_string(s);
	int ret = yyparse();
	end_lexical_scan();
	return ret;
}

void fonction1() 
{
	unsigned int x[200];
 
fonction 2(x);
 
...
}
 
void fonction2(unsigned int px[])
{
...
unsigned char toto=0;
...
px[y] = (unsigned char) toto;
...
}

void fonction1() 
{
	unsigned char x[200];
 
fonction 2(x);
 
...
}
 
void fonction2(unsigned char px[])
{
...
unsigned char toto=0;
...
px[y] = (unsigned char) toto;
...
}

void ili9341_Draw_Filled_Shape(uint8_t corners, const int16_t *xArray, const int16_t *yArray, int16_t x, int16_t y, colour_t colour)
{
--code
}

	uint16_t xArray_UP[3]={0,20,10};
	uint16_t yArray_UP[3]={10,10,0};
ili9341_Draw_Filled_Shape(3, xArray_UP, yArray_UP, 187, 40, ORANGE);