//#define IS_ONCALC //#define SHOW_COMPILATION_STEPS #include //#include #include #include #include //#include "keys.h" #define LEXER_PARSER_SIZE 30000 //#define LEXER_PARSER_SIZE 8000 #define USER_VAR_NB_MAX 250 #define NB_USER_ICE_FUNC 50 #define DIRECT_STRING_MAX_CHARS 4000 #define VARS_FUNCS_MAX_CHARS 20 #define NUMS_MAX_CHARS 20 #define EXTRACT_OUTPUT_BUF_SIZE 5000 #define STACK_NBELEM 1000 #define MINUS_CHAR 173 #define NB_LBL_MAX 80 #define NB_IF_WHILE_FOR_MAX 254 #define NB_FOR_MAX 50 #define NB_IMBRICATED_IF_WHILE_FOR_MAX 70 #define NB_IF_THEN_MAX 60 #define NB_IF_THEN_IMBRICATED_MAX 30 #define STO_ARROW_CHAR 0x04 #define NB_USER_NEO_FUNC 70 #define NB_IF_SHORT_MAX 50 #define DET 0xB3 #define SUM 0xB6 #ifdef IS_ONCALC //#define INPUT_PRGM "src.txt" unsigned char *INPUT_PRGM="./npcxfiles.tns"; unsigned char src_str_input[200]; unsigned char npprgm_str_input[200]; #include #include "n2DLib.h" typedef struct { t_key k; signed short matching_num; unsigned char matching_description_str[10]; unsigned char char_value; } newprogcx_key_data; newprogcx_key_data newprogcx_key_data_list[]= { {KEY_NSPIRE_CTRL,7,"CTRL",0}, {KEY_NSPIRE_RET,64,"return",0}, {KEY_NSPIRE_ENTER,37,"enter",'\n'}, {KEY_NSPIRE_SPACE,70,"space",' '}, {KEY_NSPIRE_NEGATIVE,36,"minus",'-'}, {KEY_NSPIRE_Z,69,"z",'z'}, {KEY_NSPIRE_PERIOD,35,".",'.'}, //?? {KEY_NSPIRE_Y,68,"y",'y'}, {KEY_NSPIRE_0,34,"0",'0'}, {KEY_NSPIRE_X,67,"x",'x'}, {KEY_NSPIRE_THETA,12,"theta",0}, //? {KEY_NSPIRE_COMMA,56,",",','}, {KEY_NSPIRE_PLUS,30,"+",'+'}, {KEY_NSPIRE_W,66,"w",'w'}, {KEY_NSPIRE_3,29,"3",'3'}, {KEY_NSPIRE_V,65,"v",'v'}, {KEY_NSPIRE_2,28,"2",'2'}, {KEY_NSPIRE_U,63,"u",'u'}, {KEY_NSPIRE_1,27,"1",'1'}, {KEY_NSPIRE_T,62,"t",'t'}, {KEY_NSPIRE_eEXP,25,"e",'e'}, {KEY_NSPIRE_PI,47,"pi",0}, {KEY_NSPIRE_QUES,46,"?",'!'}, {KEY_NSPIRE_QUESEXCL,46,"!",'!'}, {KEY_NSPIRE_MINUS,31,"-",'-'}, {KEY_NSPIRE_S,61,"s",'s'}, {KEY_NSPIRE_6,22,"6",'6'}, {KEY_NSPIRE_R,60,"r",'r'}, {KEY_NSPIRE_5,21,"5",'5'}, {KEY_NSPIRE_Q,59,"q",'q'}, {KEY_NSPIRE_4,20,"4",'4'}, {KEY_NSPIRE_P,58,"p",'p'}, {KEY_NSPIRE_TENX,26,"10^x",0}, {KEY_NSPIRE_EE,38,"EE",0}, {KEY_NSPIRE_COLON,35,".",'.'}, {KEY_NSPIRE_MULTIPLY,23,"*",'*'}, {KEY_NSPIRE_O,57,"o",'o'}, {KEY_NSPIRE_9,15,"9",'9'}, {KEY_NSPIRE_N,54,"n",'n'}, {KEY_NSPIRE_8,14,"8",'8'}, {KEY_NSPIRE_M,53,"m",'m'}, {KEY_NSPIRE_7,13,"7",'7'}, {KEY_NSPIRE_L,52,"l",'l'}, {KEY_NSPIRE_SQU,19,"²",'²'}, {KEY_NSPIRE_II,100,"II",0}, //??? {KEY_NSPIRE_QUOTE,30,"+",'+'}, {KEY_NSPIRE_DIVIDE,24,"/",'/'}, {KEY_NSPIRE_K,51,"k",'k'}, {KEY_NSPIRE_TAN,101,"TAN",0}, //??? {KEY_NSPIRE_J,50,"j",'j'}, {KEY_NSPIRE_COS,102,"COS",0}, //??? {KEY_NSPIRE_I,49,"i",'i'}, {KEY_NSPIRE_SIN,103,"SIN",0}, {KEY_NSPIRE_H,48,"h",'h'}, {KEY_NSPIRE_EXP,18,"^",'^'}, {KEY_NSPIRE_GTHAN,104,"GTHAN",0}, //??? {KEY_NSPIRE_APOSTROPHE,105,"'",0}, {KEY_NSPIRE_CAT,17,"CATALOG",0}, {KEY_NSPIRE_FRAC,24,"/",'/'}, {KEY_NSPIRE_G,45,"g",'g'}, {KEY_NSPIRE_RP,33,")",')'}, {KEY_NSPIRE_F,44,"f",'f'}, {KEY_NSPIRE_LP,32,"(",'('}, {KEY_NSPIRE_E,43,"e",'e'}, {KEY_NSPIRE_VAR,9,"VAR",0}, {KEY_NSPIRE_D,42,"d",'d'}, {KEY_NSPIRE_DEL,10,"DEL",0}, {KEY_NSPIRE_LTHAN,110,"LTHAN",0}, {KEY_NSPIRE_FLAG,55,"FLAG",0}, {KEY_NSPIRE_CLICK,1000,"CLICK",0}, {KEY_NSPIRE_C,41,"c",'c'}, {KEY_NSPIRE_HOME,2,"HOME",0}, {KEY_NSPIRE_B,40,"b",'b'}, {KEY_NSPIRE_MENU,6,"MENU",0}, {KEY_NSPIRE_A,39,"a",'a'}, {KEY_NSPIRE_ESC,1,"ESC",0}, {KEY_NSPIRE_BAR,3,"BAR",0}, {KEY_NSPIRE_TAB,5,"TAB",0}, {KEY_NSPIRE_EQU,11,"=",'='}, {KEY_NSPIRE_UP,1008,"UP",0}, {KEY_NSPIRE_UPRIGHT,10086,"UPRIGHT",0}, {KEY_NSPIRE_RIGHT,1006,"RIGHT",0}, {KEY_NSPIRE_RIGHTDOWN,10062,"RIGHTDOWN",0}, {KEY_NSPIRE_DOWN,1002,"DOWN",0}, {KEY_NSPIRE_DOWNLEFT,10024,"DOWNLEFT",0}, {KEY_NSPIRE_LEFT,1004,"LEFT",0}, {KEY_NSPIRE_LEFTUP,10048,"LEFTUP",0}, {KEY_NSPIRE_SHIFT,8,"SHIFT",0}, {KEY_NSPIRE_DOC,4,"DOC",0}, {KEY_NSPIRE_TRIG,12,"TRIG",0}, {KEY_NSPIRE_SCRATCHPAD,3,"SCRATCH",0}, {0,0,0,0} }; unsigned int getkey(void) { unsigned short i; t_key report; if(isKeyPressed(KEY_NSPIRE_UP)) return 1008; if(isKeyPressed(KEY_NSPIRE_DOWN)) return 1002; if(isKeyPressed(KEY_NSPIRE_LEFT)) return 1004; if(isKeyPressed(KEY_NSPIRE_RIGHT)) return 1006; if(isKeyPressed(KEY_NSPIRE_UPRIGHT)) return 10086; if(isKeyPressed(KEY_NSPIRE_RIGHTDOWN)) return 10062; if(isKeyPressed(KEY_NSPIRE_DOWNLEFT)) return 10024; if(isKeyPressed(KEY_NSPIRE_LEFTUP)) return 10048; if(isKeyPressed(KEY_NSPIRE_CLICK)) return 1000; if(get_key_pressed(&report)) { i=0; //printf("\nkey pressed"); while(newprogcx_key_data_list[i].matching_num!=0) { if(isKey(report, newprogcx_key_data_list[i].k)) { //printf(" k=%d",newprogcx_key_data_list[i].matching_num); return newprogcx_key_data_list[i].matching_num; } i++; } } return 0; } unsigned short keywait2(void) { unsigned short k; wait_no_key_pressed(); while((k=getkey())==0) ; return k; } #else //#define INPUT_PRGM "npcxfiles.tns" unsigned char *INPUT_PRGM="./npcxfiles.tns"; unsigned char src_str_input[50]; unsigned char npprgm_str_input[50]; #endif void finish(void); //for nb args verifications (operators ans c_funcs. Not user_funcs) : unsigned char *skip_ptr,*max_skip_ptr; void er_fc(void); void _mat_list(void); void _0arg(void); void _1arg(void); void _2arg(void); void _3arg(void); void _4arg(void); void _5arg(void); void _6arg(void); void _7arg(void); void _8arg(void); void _9arg(void); void value(void); void strng(void); void X_arg(void); //user funcs, blocks void uword(void); //user word void f1arg(void); //C functions with 1 argument (if while) void f2arg(void); //lelem [] void f3arg(void); //for_c_tag void f4arg(void); //C functions with 4 arguments (for) void nwdata_skip(void); //function newdata() void fXarg(void); //local() #ifndef IS_ONCALC //unsigned char src_prgm_buf[60000]; #else //unsigned char src_prgm_buf[40000]; #endif // IS_ONCALC void (*all_fc_skip_list[])(void)= { //0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 _0arg,_1arg,_2arg,_3arg,_4arg,_5arg,_6arg,_7arg,_8arg,_9arg,value , strng ,X_arg,uword , f1arg , f2arg , f3arg , f4arg , _mat_list, fXarg ,nwdata_skip , er_fc }; //end enum {_0 , _1 , _2 , _3 , _4 , _5 , _6 , _7 , _8 , _9 ,_value,_string, _X ,_uword, _cf1 , _cf2 , _cf3 , _cf4 , _data , _cfX , nwdata , _er }; // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 enum {null_tag,uint8_tag,int8_tag,uint16_tag,int16_tag,uint32_tag,int32_tag,c_func_tag,lbl_tag,goto_tag,continue_tag,break_tag,return_tag,user_func_tag,string_tag,if_tag,while_tag,for_tag,add_tag, // 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 sub_tag,mul_tag,div_tag,isz_tag,dsz_tag,parenthesis_open_tag,parenthesis_close_tag,user_word_tag,sup_tag,inf_tag,sto_equal_tag,sup_equ_tag,inf_equ_tag,equ_tag,hook_open_tag,hook_close_tag,lelem_tag, //36 37 38 39 40 41 42 43 44 45 46 47 end_cmd_tag,end_line_tag,end_prgm_tag,comma_tag,block_tag,start_block_tag,end_block_tag,endif_tag,endwhile_tag,endfor_tag,then_tag,if_then_tag, // 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 rollr_tag,rolll_tag,nequ_tag,orl_tag,andl_tag,mod_tag,notl_tag,end_tag,andb_tag,else_tag,uint24_tag,int24_tag,sto_arrow_tag,EXTRA1_PREFIX,EXTRA2_PREFIX, // 63 64 65 66 67 68 69 70 71 72 73 sto_global_var_tag,sto_local_var_tag,load_global_var_tag,load_local_var_tag,ice_func_tag,end_ice_func_tag,imaginaire_i_tag,address_tag,xorl_tag,xorb_tag,orb_tag // 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 ,call_tag,stoucad, stousad ,stouiad ,stoscad, stossad ,stosiad ,func_tag,endfunc_tag, return_no_tag, uc_data_tag , sc_data_tag, us_data_tag, ss_data_tag, ui_data_tag , si_data_tag //90 //91 //92 //93 //94 //95 , void_tag,set_rect_n_tag,for_c_tag,local_tag,when_tag,newdata_tag,enddd}; /* enum {_0 , _1 , _2 , _3 , _4 , _5 , _6 , _7 , _8 , _9 ,_value,_string, _X ,_uword, _cf1 , _cf4 , _er }; */ unsigned char fc_nbargs[]= // 0 1 2 3 4 5 6 7 8 9 { _er , _value , _value , _value , _value , _value , _value , _1 , _1 , _1 , //0 _0 , _0 , _1 , _X , _string , _cf1 , _cf1 , /*_X*/_cf4, _2 , _2 , //1 _2 , _2 , _1 , _1 , _er , _er , _uword , _2 , _2 , _2 , //2 _2 , _2 , _2 , _er , _er , _X , _0 , _0 , _0 , _er , //3 _X , _er , _er , _0 , _0 , _0 , _er , _cf1 , _2 , _2 , //4 _2 , _2 , _2 , _2 , _1 , _0 , _2 , _0 , _value , _value, //5 _2 , _er , _er , _er , _er , _er , _er , _1 , _0 , _1 , //6 _1 , _2 , _2 , _2 , _1 , _1 , _1 , _1 , _1 , _1 , //7 _1 , _1 , _0 , _0 , _data , _data, _1 , _1 , _1 , _1 , //8 _1 , _cf2 , _cf3 , _cfX , _cf3 , nwdata , _er , _er , _er , _er , //9 _X , _X , _X , _X , _X , _X , _X , _X , _X , _X , //10 _X , _X , _X , _X , _X , _X , _X , _X , _X , _X , //11 _X , _X , _X , _X , _X , _X , _X , _X , _X , _X , //12 _X , _X , _X , _X , _X , _X , _X , _X , _X , _X , //13 _X , _X , _X , _X , _X , _X , _X , _X , _X , _X , //14 _X , _X , _X , _X , _X , _X , _X , _X , _X , _X , //15 _X , _X , _X , _X , _X , _X , _X , _X , _X , _X , //16 _X , _X , _X , _X , _X , _X , _X , _X , _X , _X , //17 _X , _X , _X , _X , _X , _X , _X , _X , _X , _X , //18 _X , _X , _X , _X , _X , _X , _X , _X , _X , _X , //19 _X , _X , _X , _X , _X , _X , _X , _X , _X , _X , //20 _X , _X , _X , _X , _X , _X , _X , _X , _X , _X , //21 _X , _X , _X , _X , _X , _X , _X , _X , _X , _X , //22 _X , _X , _X , _X , _X , _X , _X , _X , _X , _X , //23 _X , _X , _X , _X , _X , _X , _X , _X , _X , _X //24 }; /* _er , _er , _er , _er , _er , _er , _er , _er , _er , _er , //11 _er , _er , _er , _er , _er , _er , _er , _er , _er , _er , //12 _er , _er , _er , _er , _er , _er , _er , _er , _er , _er , //13 _er , _er , _er , _er , _er , _er , _er , _er , _er , _er , //14 _er , _er , _er , _er , _er , _er , _er , _er , _er , _er , //15 _er , _er , _er , _er , _er , _er , _er , _er , _er , _er , //16 _er , _er , _er , _er , _er , _er , _er , _er , _er , _er , //17 _er , _er , _er , _er , _er , _er , _er , _er , _er , _er , //18 _er , _er , _er , _er , _er , _er , _er , _er , _er , _er , //19 _er , _er , _er , _er , _er , _er , _er , _er , _er , _er , //20 _er , _er , _er , _er , _er , _er , _er , _er , _er , _er , //21 _er , _er , _er , _er , _er , _er , _er , _er , _er , _er , //22 _er , _er , _er , _er , _er , _er , _er , _er , _er , _er , //23 _er , _er , _er , _er , _er , _er , _er , _er , _er , _er , //24 _er , _er , _er , _er , _er , _er //25 */ // 0 1 2 3 4 5 6 7 8 9 void (*fc_skip_list[256])(void);//= //NEWPROGCX BYTE CODE unsigned char //0 //1 //2 //3 //4 //5 //6 //7 //8 //9 *neo_funcs_list_str[]={"GETUCHAR" ,"GETUSHORT", "GETUINT" ,"GETSCHAR" ,"GETSSHORT", "GETSINT" , "NPVAR", "STOVAR" , "ADDD" , "ISEQU", //0 "keywait" , "LBL" , "GOTO" , "IFS" , "FORR" ,"BREAKK" , "GETADRES", "" , "SUBB" , "ISNEQU" , //1 "repeat" , "ISZ" , "" , "IFTHEN" ,"ENDFORR" ,"CONTINUE" , "" , "" , "MULL" , "ISINF", //2 "printd" , "DSZ" , "" , "ELSE" ,"WHILEE" , "" , "" , "" , "DIVV" , "ISSUP", //3 "printf" , "DEFDATA", "" , "ENDIF" ,"ENDWHILE" , "" , "" , "" , "" , "ISEQUINF", //4 "" ,"LELEMDATA", "" , "" , "" ,"ENDBLOCK" , "" , "" , "" , "ISEQUSUP", //5 "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , //6 "" , "" , "" , "" , "" ,"CONTUCPTR","CONTUSPTR","CONTUIPTR","CONTSCPTR","CONTSSPTR", //7 "CONTSIPTR", "DEFFUNC" ,"ENDDEFFUN","EXECFC" ,"RETURNN" , "RETURN" , "" , "" , "" , "" , //8 "" , "UCHAR" , "SCHAR" , "USHORT" , "SSHORT" , "UINT" , "UINT" , "" , "" , "" , //9 "" ,"STOUCELEM", "" , "" , "" , "" , "" , "" , "" , "" , //10 "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , //11 "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , //12 "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , //13 "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , //14 "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , //15 "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , //16 "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , //17 "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , //18 "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , //19 "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , //20 "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , //21 "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , //22 "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , //23 "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , //24 "" , "" , "" , "" , "" , "END" }; //25 //0 1 2 3 4 5 6 7 8 9 unsigned char funcs_nbarg[] ={ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 2 , 2 , 2 , //0 0 , 0 , 0 , 0 , 3 , 0 , 0 , 0 , 2 , 2 , //1 2 , 1 , 0 , 1 , 0 , 0 , 0 , 0 , 2 , 2 , //2 1 , 1 , 0 , 0 , 1 , 0 , 0 , 0 , 2 , 2 , //3 1 , 1 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 2 , //4 99 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 2 , //5 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , //6 0 , 0 , 0 , 0 , 0 , 1 , 1 , 1 , 1 , 1 , //7 1 , 1 , 0 , 1 , 1 , 0 , 0 , 0 , 0 , 0 , //8 1 , 1 , 0 , 1 , 1 , 0 , 0 , 0 , 0 , 0 , //8 0 , 1 , 1 , 1 , 1 , 1 , 1 , 0 , 0 , 0 , //9 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , //10 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , //11 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , //12 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , //13 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , //14 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , //15 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , //16 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , //17 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , //18 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , //19 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , //20 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , //21 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , //22 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , //23 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , //24 0 , 0 , 0 , 0 , 0 , 0 }; //25 //END OF NEWPROGCX BYTE CODE enum {LtoR,RtoL}; unsigned char src_prgm[45000],*ptr/*,*src="text \"Hello\"\n;keywait()\0"*/,*next_ptr,c_func_iden,c_word_iden,op_iden,is_minus,was_the_last_line; unsigned char output_lexer_tokens[LEXER_PARSER_SIZE],output_str[EXTRACT_OUTPUT_BUF_SIZE]; unsigned char output_parser_tokens[LEXER_PARSER_SIZE]; #ifndef IS_ONCALC unsigned char output_byte_code_prgm[35000],*out_ptr; //the tokenized output prgm and the moving output moving ptr #else unsigned char *output_byte_code_prgm,*out_ptr; //the tokenized output prgm and the moving output moving ptr #endif unsigned char *ptr_lexer_tokens; //ptr in output_lexer_tokens unsigned int lexer_size,parser_size; unsigned short line,nb_line_to_add; unsigned char is_too_long; unsigned char depth_iden=0; unsigned char *prgm_moving_ptr; unsigned char buf[EXTRACT_OUTPUT_BUF_SIZE]; unsigned char sto_arrow_str[2]; unsigned char imaginaire_i_str[2]; unsigned char ASM_dest_name_str[20]; //Les strings d'opérateurs les plus longs doivent être placés en premiers. Exemple : andb devant and unsigned char *op_str[]={ "XXXIII" ,/*imaginaire_i_str ,*/ "(ad*)" , "output" , "void" , "func" , "return" , "endfunc" , "modulo" , "datauc" , "datasc" , "dataus" , "datass" , "dataui" , "datasi" , "*(si*)" , "*(ss*)" ,"*(sc*)" ,"*(ui*)" , "*(us*)" ,"*(uc*)" , "==" , "%" ,"andb" , "orb" , "not" , "or" , "||" , "and" , "&&" , ">>" , "<<", ">=" , "<=" , "!=" , "!" , "++" , "--" , "+" , "-" , "*" , "/" , ">" , "<" , "=" , "&" , "|" ,0}; //Attention, place first longest strings unsigned char op_tag[]={ void_tag ,/* imaginaire_i_tag ,*/ address_tag, imaginaire_i_tag , void_tag , func_tag ,return_tag , endfunc_tag ,mod_tag ,uc_data_tag ,sc_data_tag,us_data_tag, ss_data_tag , ui_data_tag , si_data_tag , stosiad , stossad , stoscad , stouiad , stousad , stoucad ,equ_tag , mod_tag ,andb_tag,orb_tag , notl_tag , orl_tag , orl_tag ,andl_tag, andl_tag ,rollr_tag,rolll_tag,sup_equ_tag,inf_equ_tag, nequ_tag ,notl_tag ,isz_tag,dsz_tag,add_tag,sub_tag,mul_tag,div_tag,sup_tag,inf_tag,sto_equal_tag,andb_tag ,orb_tag ,0}; unsigned char op_priority[]={ 10 ,/* 5 ,*/ 14 , 5 , 10 , 10 , 10 , 10 , 13 , 14 , 14 , 14 , 14 , 14 , 14 , 14 , 14 , 14 , 14 , 14 , 14 , 9 , 13 , 8 , 8 , 14 , 5 , 5 , 5 , 5 , 11 , 11 , 10 , 10 , 9 , 14 , 15 , 15 , 12 , 12 , 13 , 13 , 10 , 10 , 1 , 8 , 6 ,0}; unsigned char op_associa[]={ LtoR ,/* LtoR ,*/ RtoL , LtoR , LtoR , LtoR , LtoR , LtoR , RtoL , RtoL , RtoL , RtoL , RtoL , RtoL , RtoL , RtoL , RtoL , RtoL , RtoL , RtoL , RtoL , LtoR , RtoL , RtoL , RtoL , RtoL , LtoR , LtoR , LtoR , LtoR , LtoR , LtoR , LtoR , LtoR , LtoR , RtoL , LtoR , LtoR , LtoR , LtoR , LtoR , LtoR , LtoR , LtoR , RtoL , LtoR , LtoR ,0}; //unsigned char op_nbargs[]={ 1 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 1 , 1 , 2 , 2 , 2 , 2 , 2 , 2 , 2 }; /* Precedence Operator Description Associativity 1 ++ -- Suffix/postfix increment and decrement Left-to-right 15 () Function call [] Array subscripting . Structure and union member access -> Structure and union member access through pointer (type){list} Compound literal(C99) 2 ++ -- Prefix increment and decrement[note 1] Right-to-left 14 + - Unary plus and minus ! ~ Logical NOT and bitwise NOT (type) Cast * Indirection (dereference) & Address-of sizeof Size-of[note 2] _Alignof Alignment requirement(C11) 3 * / % Multiplication, division, and remainder Left-to-right 13 4 + - Addition and subtraction 12 5 << >> Bitwise left shift and right shift 11 6 < <= For relational operators < and = respectively 10 > >= For relational operators > and = respectively 7 == != For relational = and ? respectively 9 8 & Bitwise AND 8 9 ^ Bitwise XOR (exclusive or) 7 10 | Bitwise OR (inclusive or) 6 11 && Logical AND 5 12 || Logical OR 4 13 ?: Ternary conditional[note 3] Right-to-left 3 14[note 4] = Simple assignment 2 += -= Assignment by sum and difference *= /= %= Assignment by product, quotient, and remainder <<= >>= Assignment by bitwise left shift and right shift &= ^= |= Assignment by bitwise AND, XOR, and OR 15 , Comma 1 */ unsigned char *c_words_str[]={"lbl" ,"goto" ,"continue" ,"break" , "then" , "endif" , "endfor" , "endwhile" , "else" , "call" , 0}; unsigned char c_words_tag[] ={lbl_tag,goto_tag,continue_tag,break_tag,then_tag,endif_tag ,endfor_tag,endwhile_tag, else_tag , call_tag , 0}; unsigned char *c_funcs_str[]={"if" , "while" , "for", "setrectn" , "local" , "when" , "newdata" ,0}; unsigned char c_funcs_tag[] ={if_tag,while_tag,for_tag,set_rect_n_tag, local_tag , when_tag , newdata_tag ,0}; unsigned char sub_l_elem_lvl,sub_l_elem_iden; typedef struct { unsigned char lexer_sub_tokens_list[DIRECT_STRING_MAX_CHARS],*ptr_fin; unsigned short size_in_bytes; } sub_l_elem; sub_l_elem sub_l_elem_list[20]; //for list and matrix sub lexer compile in transforms_...() typedef struct { unsigned char *token_ptr[STACK_NBELEM]; unsigned short nb_elem; } Stack; //For ifthen while for lbl goto . Globals vars unsigned short ifthen_lvl,while_lvl,for_lvl,block_lvl,blocks_list[100],block_i,ifthen_blocks_list[NB_IMBRICATED_IF_WHILE_FOR_MAX],while_blocks_list[NB_IMBRICATED_IF_WHILE_FOR_MAX],for_blocks_list[NB_IMBRICATED_IF_WHILE_FOR_MAX]; unsigned short func_lvl,func_block_list[100]; unsigned char lbl_names[NB_LBL_MAX][VARS_FUNCS_MAX_CHARS],goto_names[NB_LBL_MAX][VARS_FUNCS_MAX_CHARS],nb_lbl,nb_goto,lbl_iden,goto_iden; //signed short blocks_newprogcx_list[500],blocks_newprogcx_level,blocks_newprogcx_i,lbl_block_newprogcx_list[NB_LBL_MAX]; //unsigned char *goto_ptr_block_newprogcx_list[3*NB_LBL_MAX]; unsigned char when_iden; unsigned char is_in_while_cond; unsigned char while_cond_list[7][50]; signed char args_var_iden_list[100][16]; unsigned char fc_id,fc_nba,argsn_var_iden_list[100]; unsigned char is_void_data; //if not null, so values to store in each data** //short lbl_block_iden[NB_LBL_MAX],goto_block_iden[NB_LBL_MAX],blocks_iden_list[255],block_level,block_iden; //signed char putc_ice_prgm(unsigned char c); //signed int putw_ice_prgm(signed int c); //unsigned char *putstr_ice_prgm(unsigned char *str); //void create_init_ice_prgm(unsigned char *ice_prgm_name_str); unsigned char if_short_level=0,previous_token=0; unsigned short previous_line=0; unsigned char lexer_process_result; //after lexer_process(), if result==1 so end of line, 2==end of prgm unsigned char if_then_i_list_newprogcx[NB_IMBRICATED_IF_WHILE_FOR_MAX],if_then_iden_newprogcx,if_then_level_newprogcx; enum {WORD_FC,CLASSIC_FC,EXTRA1_FC,EXTRA2_FC}; //match with prefix_num in ice_function struct typedef struct { unsigned char func_str[30]; unsigned char prefix_num; unsigned char func_num; unsigned char func_nbargs; unsigned char func_nbargs_min; unsigned char ice_code1; unsigned char ice_code2; } simple_ice_function; simple_ice_function simple_ice_function_list[]= { {"keywait",CLASSIC_FC,10,0,0,0,0}, {"printd",CLASSIC_FC,220,1,0,0,0}, {"repeat",CLASSIC_FC,20,2,0,0,0}, {"printf",CLASSIC_FC,50,99,1,DET,0}, //99= nombre variable d'arguments 1=arg count min {"settxtpos",CLASSIC_FC,70,2,0,0,0}, {"gettxtposx",CLASSIC_FC,61,0,0,0,0}, {"gettxtposy",CLASSIC_FC,71,0,0,0,0}, {"settxtcolor",CLASSIC_FC,46,1,0,0,0}, {"sprintf",CLASSIC_FC,60,99,2,DET,0}, //99= nombre variable d'arguments 1=arg count min {"getlcdad",CLASSIC_FC,26,0,0,0,0}, {"setlcdad",CLASSIC_FC,56,1,0,0,0}, {"keytest",CLASSIC_FC,22,1,0,0,0}, {"msgbox",CLASSIC_FC,42,2,0,0,0}, //{"request1num",CLASSIC_FC,52,6,0,0,0}, //how_1numeric_input(const char * title, const char * subtitle, const char * msg, int * value_ref, int min_value, int max_value) //{"request2num",CLASSIC_FC,62,10,0,0,0}, {"request1str",CLASSIC_FC,72,4,0,0,0}, {"free",CLASSIC_FC,100,1,0,0,0}, {"malloc",CLASSIC_FC,110,1,0,0,0}, {"realloc",CLASSIC_FC,121,2,0,0,0}, {"bufon",CLASSIC_FC,93,0,0,0,0}, {"bufoff",CLASSIC_FC,94,0,0,0,0}, {"loadbmp",CLASSIC_FC,95,2,0,0,0}, {"bufflip",CLASSIC_FC,96,0,0,0,0}, {"sprite",CLASSIC_FC,97,3,0,0,0}, //sprite surface,x,y {"timeron",CLASSIC_FC,53,0,0,0,0}, {"timeroff",CLASSIC_FC,103,0,0,0,0}, {"timerset",CLASSIC_FC,113,1,0,0,0}, {"timerread",CLASSIC_FC,123,0,0,0,0}, {"delay",CLASSIC_FC,63,1,0,0,0}, //SDL_UpdateRect(SDL_Surface *screen, Sint32 x, Sint32 y, Sint32 w, Sint32 h); {"updaterect",CLASSIC_FC,64,4,0,0,0}, {"setpix",CLASSIC_FC,35,3,0,0,0}, {"getpix",CLASSIC_FC,45,2,0,0,0}, {"fillrect",CLASSIC_FC,36,5,0,0,0}, {"spritescaled",CLASSIC_FC,107,5,0,0,0}, {"spriterotated",CLASSIC_FC,108,4,0,0,0}, {"getspritew",CLASSIC_FC,27,1,0,0,0}, {"getspriteh",CLASSIC_FC,37,1,0,0,0}, {"getspritemask",CLASSIC_FC,137,1,0,0,0}, {"setspritemask",CLASSIC_FC,147,2,0,0,0}, {"drawline",CLASSIC_FC,120,5,0,0,0}, {"scrollleft",CLASSIC_FC,140,5,0,0,0}, {"scrollright",CLASSIC_FC,141,5,0,0,0}, {"scrolldown",CLASSIC_FC,142,5,0,0,0}, {"scrollup",CLASSIC_FC,143,5,5,0,0}, {"scrollup2",CLASSIC_FC,153,0,0,0,0}, {"charord",CLASSIC_FC,73,1,0,0,0}, {"setfont",CLASSIC_FC,90,1,0,0,0}, {"getkey",CLASSIC_FC,91,0,0,0,0}, {"keyascii",CLASSIC_FC,92,1,0,0,0}, {"spritepart",CLASSIC_FC,87,4,0,0,0}, {"newsprite",CLASSIC_FC,47,3,0,0,0}, {"getspritefirstpixadress",CLASSIC_FC,57,1,0,0,0}, {"getfirstpix",CLASSIC_FC,57,1,0,0,0}, {"getspritesize",CLASSIC_FC,67,1,0,0,0}, {"finish",CLASSIC_FC,130,0,0,0,0}, {"memcpy",CLASSIC_FC,150,3,0,0,0}, //memmove and memcpy are the same {"memmove",CLASSIC_FC,150,3,0,0,0}, {"memmovess",CLASSIC_FC,160,3,0,0,0}, {"memset",CLASSIC_FC,170,3,0,0,0}, {"memsetss",CLASSIC_FC,180,3,0,0,0}, {"strlen",CLASSIC_FC,66,1,0,0,0}, {"fillscreen",CLASSIC_FC,117,1,0,0,0}, {"colorrgb",CLASSIC_FC,127,3,0,0,0}, {"blit",CLASSIC_FC,210,4,0,0,0}, {"strcat",CLASSIC_FC,106,2,0,0,0}, {"rand",CLASSIC_FC,114,1,0,0xAB,0}, {"strcpy",CLASSIC_FC,111,2,0,0xAB,0}, {"menu",CLASSIC_FC,161,4,0,0xAB,0}, //arg1=list_str arg2=return_elem_str {"drawstrxy",CLASSIC_FC,171,3,0,0xAB,0}, {"strcmp",CLASSIC_FC,112,2,0,0xAB,0}, {"strcasecmp",CLASSIC_FC,122,2,0,0xAB,0}, {"atoi",CLASSIC_FC,105,1,0,0xAB,0}, {"atol",CLASSIC_FC,105,1,0,0xAB,0}, {"isnumstr",CLASSIC_FC,30,1,0,0xAB,0}, {"gets",CLASSIC_FC,40,1,0,0xAB,0}, {"fopen",CLASSIC_FC,155,2,0,0xAB,0}, {"fclose",CLASSIC_FC,165,1,0,0xAB,0}, {"fputc",CLASSIC_FC,175,2,0,0xAB,0}, {"fseek",CLASSIC_FC,185,3,0,0xAB,0}, {"ftell",CLASSIC_FC,195,1,0,0xAB,0}, {"fillcircle",CLASSIC_FC,156,4,0,0xAB,0}, {"drawcircle",CLASSIC_FC,166,4,0,0xAB,0}, {"abs",CLASSIC_FC,65,1,0,0xAB,0}, //{"newdata",CLASSIC_FC,190,3,0,0xAB,0}, {"END_FUNC",0,0,0,0,0,0} }; unsigned char newprogcx_var_list_str[256][21]; unsigned short newprogcx_var_list_nb_rows_nb_cols[256][2]; // unsigned char newprogcx_var_type_of_data_list[256]; //1=uc 11=sc 2=us 22=ss 3=ui 4=si int nb_newprogcx_var; typedef struct { unsigned char constant_str[30]; int value; } newprogcx_constant; /*keys : 1=ESC (top-left) 2=on-home 3=calculator 4=DOC 5=TAB etc*/ newprogcx_constant newprog_constant_list[]={ {"kctrl",7}, {"kreturn",64}, {"kenter",37}, {"kspace",70}, {"kminus",36}, {"kz",69}, {"kdot",35}, {"ky",68}, {"K0",34}, {"kx",67}, {"ktrig",12}, {"kcomma",56}, {"kplus",30}, {"kw",66}, {"k3",29}, {"kv",65}, {"k2",28}, {"ku",63}, {"k1",27}, {"kt",62}, {"kexp",25}, {"kpi",47}, {"kquestion",46}, {"kquesex",46}, {"ksub",31}, {"ks",61}, {"k6",22}, {"kr",60}, {"k5",21}, {"kq",59}, {"k4",20}, {"kp",58}, {"ktenx",26}, {"kee",38}, {"kmul",23}, {"ko",57}, {"k9",15}, {"kn",54}, {"k8",14}, {"km",53}, {"k7",13}, {"kl",52}, {"ksquare",19}, {"kii",100}, //??? {"kplus",30}, {"kdiv",24}, {"kk",51}, {"ktan",101}, //??? {"kj",50}, {"kcos",102}, //??? {"ki",49}, {"ksin",103}, {"kh",48}, {"kexp",18}, {"kgthan",104}, //??? {"kapostrophe",105}, {"kcataolog",17}, {"kfrac",24}, {"kg",45}, {"krp",33}, {"kf",44}, {"klp",32}, {"ke",43}, {"kvar",9}, {"kd",42}, {"kdel",10}, {"klthan",110}, {"kflag",55}, {"kclic",1000}, {"kc",41}, {"khome",2}, {"kb",40}, {"kmenu",6}, {"ka",39}, {"kesc",1}, {"kbar",3}, {"ktab",5}, {"kequ",11}, {"kup",1008}, {"kupright",10086}, {"kright",1006}, {"krightdown",10062}, {"kdown",1002}, {"kdownleft",10024}, {"kleft",1004}, {"kleftup",10048}, {"kshift",8}, {"kdoc",4}, {"ktrig",12}, {"kscratch",3}, {"font6x8",0}, {"font8x8",1}, {"font8x12",2}, {"font16x16",3}, {"onesec",32768}, {"lcdnbpix",76800}, {"lcdnbbytes",153600}, {"lcdsize",153600}, {"lcdwidth",320}, {"lcdheight",240}, {"uctype",1}, {"sctype",11}, {"ustype",2}, {"sstype",22}, {"uitype",4}, {"sitype",44}, {"white",-1}, {"black",0}, {"red",0b1111100000000000}, {"blue",0b0000000000011111}, {"green",0b0000011111100000}, {"yellow",0b1111111111100000}, {"purple",0b1111100000011111}, {"eof",EOF}, {"seekset",SEEK_SET}, {"seekcur",SEEK_CUR}, {"seekend",SEEK_END}, {"newline",'\n'}, //{"lcdrealad",0xC0000010}, //don't works {"END",0} }; /* typedef struct { unsigned char user_ice_func_str[20]; unsigned char func_num; unsigned char func_nbargs; } func_newprogcx; func_newprogcx func_newprogcx_list[100]; unsigned char nb_newprogcx_function=0; signed char is_in_newprogcx_func=0; */ //DEPRECATED BELOW------------------ typedef struct { unsigned char user_ice_func_str[20]; unsigned char func_num; unsigned char func_nbargs; } user_ice_function; user_ice_function user_ice_function_list[NB_USER_ICE_FUNC]; unsigned char nb_user_ice_function=0; signed char is_in_ice_func=0; //END DEPRECATED ----------------------- unsigned short nb_bytes_ice_prgm_instructions; unsigned short nb_if_short=0; typedef struct { unsigned char ice_var_str[VARS_FUNCS_MAX_CHARS+1]; unsigned char ice_func_iden; unsigned char ice_var_pointer_type; //1=s8 2=s16 3=s24 11=u8 12=u16 13=u24 unsigned char ice_local_var_index; //if is a local var, rank of the local var } ice_var; ice_var ice_var_list[USER_VAR_NB_MAX]; unsigned short nb_ice_var=0; unsigned char nb_for=0,for_index=0,for_queue[NB_IMBRICATED_IF_WHILE_FOR_MAX]; unsigned char nb_while=0,while_index=0,while_queue[NB_IMBRICATED_IF_WHILE_FOR_MAX]; unsigned char nb_if_then=0,if_then_index=0,if_then_queue[NB_IF_THEN_IMBRICATED_MAX]; typedef struct { unsigned char ice_func_str[VARS_FUNCS_MAX_CHARS+1]; unsigned char ice_func_nb_local_vars; } ice_func; ice_func ice_func_list[NB_USER_NEO_FUNC]; unsigned char nb_ice_func=0; unsigned char current_ice_func=0; unsigned char is_yet_located_lbl_list[NB_LBL_MAX]; unsigned char is_archived_src_prgm; unsigned char big_buf[1000]; unsigned char is_debug=0; unsigned char maj_str_buf[30]; unsigned char my_toupper(unsigned char c) { if(c>='a' && c<='z') return c+'A'-'a'; return c; } unsigned char *strtoupper( unsigned char *dest, const unsigned char *src) { unsigned char * result = dest; /*if(is_debug) { printf("\nstrtoupper:src=%s dest=%s",src,dest); }*/ while( *dest++ = my_toupper( *src++ ) ); /* if(is_debug) { printf("\nstrtoupper:result=%s ",result); } */ return result; } unsigned char* strtoupper_specified_max_len( unsigned char *dest, const unsigned char *src ,unsigned short max_len) { unsigned short i; for(i=0;i29) { sprintf(buf,"Error line %d:Func name too long %s",line,fc_str); my_exit(buf); } strcpy(func_newprogcx_list[nb_func_newprogcx].user_func_newprogcx_str,fc_str); func_newprogcx_list[nb_func_newprogcx].user_func_newprogcx_nbargs=nb_args_expected; func_newprogcx_list[nb_func_newprogcx].user_func_newprogcx_func_num=nb_func_newprogcx; if(nb_func_newprogcx>99) my_exit("Error:too much func endfunc"); //printf("\nin create func, rtn=%d",nb_func_newprogcx); return nb_func_newprogcx++; } //signed char putc_ice_prgm(unsigned char); int my_abs(int n) { if(n>=0) return n; else return -n; } void init_ice_var_list(void) { unsigned short i; for(i=0;i=0) { if(is_debug) printf("\nTry to put >=0 number=%d",num); if(num>65535) { *out_ptr=0x2; //neo tag for pos long #ifdef IS_ONCALC ui=num; uiptr=&ui; *(out_ptr+1)=*uiptr; *(out_ptr+2)=*(uiptr+1); *(out_ptr+3)=*(uiptr+2); *(out_ptr+4)=*(uiptr+3); #else *(unsigned int *)(out_ptr+1)=num; #endif // IS_ONCALC out_ptr+=5; return ; } else { if(num>255) { *out_ptr=0x1; //neo tag for pos short #ifdef IS_ONCALC us=num; usptr=&us; *(out_ptr+1)=*usptr; *(out_ptr+2)=*(usptr+1); #else *(unsigned short *)(out_ptr+1)=num; #endif // IS_ONCALC out_ptr+=3; return ; } else { *out_ptr=0x0; //neo tag for pos char *(unsigned char *)(out_ptr+1)=num; out_ptr+=2; if(is_debug) printf("\nnum=%d pushed",num); return ; } my_exit("Weird error\n"); } } else //neg number { if(my_abs(num)>65535) { *out_ptr=0x5; //neo tag for pos long #ifdef IS_ONCALC si=num; siptr=&si; *(out_ptr+1)=*siptr; *(out_ptr+2)=*(siptr+1); *(out_ptr+3)=*(siptr+2); *(out_ptr+4)=*(siptr+3); #else *(unsigned int *)(out_ptr+1)=num; #endif // IS_ONCALC out_ptr+=5; return ; } else { if(my_abs(num)>255) { *out_ptr=0x4; //neo tag for pos long #ifdef IS_ONCALC ss=num; ssptr=&ss; *(out_ptr+1)=*ssptr; *(out_ptr+2)=*(ssptr+1); #else *(unsigned short *)(out_ptr+1)=num; #endif // IS_ONCALC out_ptr+=3; return ; } else { *out_ptr=0x3; //neo tag for pos long *(unsigned char *)(out_ptr+1)=num; out_ptr+=2; return ; } my_exit("Weird error neg num\n"); } } } void push_num_output_no_isz_with_specified_ptr_68k(int num, unsigned char *ptr) { unsigned char *temp_out_ptr; temp_out_ptr=out_ptr; out_ptr=ptr; push_num_output_with_isz_68k(num); out_ptr=temp_out_ptr; } unsigned char is_alpha_num(unsigned char *ptr) { if(*ptr=='_' || *ptr>='a' && *ptr<='z' || *ptr>='A' && *ptr<='Z' || *ptr>='0' && *ptr<='9') return 1; else return 0; } unsigned char is_alpha_num_or_dot_or_div(unsigned char *ptr) { if(*ptr=='_' || *ptr>='a' && *ptr<='z' || *ptr>='A' && *ptr<='Z' || *ptr>='0' && *ptr<='9' || *ptr=='.' || *ptr=='/') return 1; else return 0; } void init_newprogcx_var_list_str(void) { int i; nb_newprogcx_var=0; for(i=0;i<255;i++) { newprogcx_var_list_str[i][0]=0; newprogcx_var_list_nb_rows_nb_cols[i][0]=0; //nb rows newprogcx_var_list_nb_rows_nb_cols[i][1]=0; //nb col newprogcx_var_type_of_data_list[i]=0; } } //blocks_newprogcx_list[500],blocks_newprogcx_level,blocks_newprogcx_i int get_newprogcx_var_iden(unsigned char *var_str_ptr) { int i; for(i=0;i<255;i++) { if(strcasecmp(var_str_ptr,&newprogcx_var_list_str[i][0])==0) return i; } return -1; } char is_existing_newprogcx_var_str(unsigned char *var_str) { if(get_newprogcx_var_iden(var_str)==-1) return 0; else return 1; } int create_newprogcx_var_and_return_iden(unsigned char *var_str) { if(strlen(var_str)>20) my_exit("Error:var name too long"); strcpy(&newprogcx_var_list_str[nb_newprogcx_var][0],var_str); nb_newprogcx_var++; if(nb_newprogcx_var>250) my_exit("Error:Too much vars"); return nb_newprogcx_var-1; } void init_ice_func_list(void) { unsigned short i; for(i=0;i=USER_VAR_NB_MAX) my_exit("Error:Too much NEO VAR definition"); strcpy(ice_var_list[nb_ice_var].ice_var_str,var_str); ice_var_list[nb_ice_var].ice_func_iden=ice_func_iden; ice_var_list[nb_ice_var].ice_var_pointer_type=wanted_type; //a finaliser: ice_var_list[nb_ice_var].ice_local_var_index=0; printf("\nNew ice var : str=%s func_iden=%d overall_index=%d type=%d local_index=%d",ice_var_list[nb_ice_var].ice_var_str,ice_var_list[nb_ice_var].ice_func_iden,nb_ice_var,ice_var_list[nb_ice_var].ice_var_pointer_type,ice_var_list[nb_ice_var].ice_local_var_index); nb_ice_var++; return nb_ice_var-1; } signed short get_ice_var_iden_with_ice_func_specified(unsigned char *var_str,unsigned char ice_func_iden) //ne sert pas { unsigned short i; for(i=0;i0) { //if(!is_alpha_num(src_str_input[strlen(src_str_input)-1])) src_str_input[strlen(src_str_input)-1]=0; for(v=0;v<50;v++) { if(!is_alpha_num_or_dot_or_div(&src_str_input[v])) { src_str_input[v]=0; goto end_src; } } } break; } } end_src : strcat(src_str_input,".tns"); if(src_str_input[0]==0) { sprintf(buf,"\nError:Unable to load in line 1 'INPUTSRC=' in %s",ti_prgm_src_str); my_exit(buf); } //printf("\nsrc_str=%s",src_str_input); //retrieve Byte code prgm name for(i=0;i<100;i++) buf2[i]=0; if(fgets(buf2,99,f)==0) { sprintf(buf,"\nError:Unable to load in line 2 'EXEC=' in %s",ti_prgm_src_str); my_exit(buf); } //printf("\nLine loaded 2= %s",buf2); keywait(); npprgm_str_input[0]=0; for(i=0;i0) { //if(!is_alpha_num(src_str_input[strlen(src_str_input)-1])) src_str_input[strlen(src_str_input)-1]=0; for(v=0;v<50;v++) { if(!is_alpha_num_or_dot_or_div(&npprgm_str_input[v])) { npprgm_str_input[v]=0; goto end_npprgm; } } } break; } } end_npprgm : strcat(npprgm_str_input,".tns"); if(npprgm_str_input[0]==0) { sprintf(buf,"\nError:Unable to load in line 2 'EXEC=' in %s",ti_prgm_src_str); my_exit(buf); } //printf("\noutput_str=%s",npprgm_str_input); printf("\nSRC=%s",src_str_input); printf("\nOUTPUT=%s",npprgm_str_input); strcpy(buf,src_str_input); //sprintf(buf,"%s.tns",ti_prgm_src_str); //strcpy(buf,ti_prgm_src_str); //#endif // IS_ONCALC printf("\nWant to open %s",buf); f=fopen(buf,"r"); if(f==0) my_exit("\nError:Unable open input program file"); else printf("\nLoad success"); //if(is_debug) keywait();} i=0; //src_prgm=(unsigned char*)malloc(60000); //src_prgm=src_prgm_buf; //if(src_prgm==0) my_exit("Error:Memory"); while(!feof(f)) { c=fgetc(f); if(c==9) src_prgm[i]=' '; //if tabulation else src_prgm[i]=c; //printf("%c-%d",c,c); i++; if(i>=30000) my_exit("Error:input prgm too big"); } src_prgm[i]='\0'; //src_prgm[++i]='\0'; //moi 15/04/2023 //src_prgm[i]=EOF; fclose(f); if(is_debug) printf("\nInput prgm size=%d",i+1); return src_prgm; } #ifndef IS_ONCALC //#define INPUT_PRGM "src.txt" //FILE *ice_prgm=NULL; //moi 14/02/2022 //long data_area_offset; //décalage après le tout début des fgetc de la structure de données /* unsigned short data_area_offset; //décalage après le tout début des fgetc de la structure de données long data_area_offset_position; //position où est enregistré l'offset de la structure de données long _1300_offset,_0200_offset_1,_0200_offset_2,_0100_offset; unsigned short _1300_nb_bytes,_0200_nb_bytes,_e900_nb_bytes,_0100_nb_bytes; unsigned short _e900_checksum; unsigned short all_ice_prgm_datas_nb_bytes; */ /* FILE *ice_prgm=NULL; long _1400_offset; unsigned short _1400_nb_bytes; long _0300_offset_1,_0300_offset_2; unsigned short _0300_nb_bytes; long _0100_offset; unsigned short _0100_nb_bytes; unsigned short checksum; void close_ice_prgm(void) { long check_sum_offset; unsigned char *ptr,*ptr2,*ptr3,*ptr_data_area_offset; long final_data_area_offset; ptr=(unsigned char*)(&_0100_nb_bytes); ptr2=(unsigned char*)(&_0300_nb_bytes); checksum+=(2*(*ptr2+*(ptr2+1))+(*ptr+*(ptr+1))); //car le checksum doit etre actualisé car on réécrit les _0200 check_sum_offset=ftell(ice_prgm); fputc(0,ice_prgm); fputc(0,ice_prgm); fseek(ice_prgm,check_sum_offset,SEEK_SET); //from beginning ptr=(unsigned char*)(&checksum); fputc(*(ptr+0),ice_prgm); fputc(*(ptr+1),ice_prgm); fseek(ice_prgm,_1400_offset,SEEK_SET); //from beginning ptr=(unsigned char*)(&_1400_nb_bytes); fputc(*(ptr+0),ice_prgm); fputc(*(ptr+1),ice_prgm); fseek(ice_prgm,_0300_offset_1,SEEK_SET); //from beginning ptr=(unsigned char*)(&_0300_nb_bytes); fputc(*(ptr+0),ice_prgm); fputc(*(ptr+1),ice_prgm); fseek(ice_prgm,_0300_offset_2,SEEK_SET); //from beginning ptr=(unsigned char*)(&_0300_nb_bytes); fputc(*(ptr+0),ice_prgm); fputc(*(ptr+1),ice_prgm); fseek(ice_prgm,_0100_offset,SEEK_SET); //from beginning ptr=(unsigned char*)(&_0100_nb_bytes); fputc(*(ptr+0),ice_prgm); fputc(*(ptr+1),ice_prgm); fclose(ice_prgm); } */ ////void (*fc_switch_list[256])(void); //void (*all_fc_switch_list[])(void)= //all_fc_skip_list //fc_nbargs //void (*fc_skip_list[256])(void)= /* signed char putc_ice_prgm(unsigned char c) { if(fputc(c,ice_prgm)==-1) my_exit("Error:Not enough memory"); data_area_offset++; //the initialisation is made in create_init_ice_prgm() at the appropriate moment _1300_nb_bytes++; //the initialisation is made in create_init_ice_prgm() at the appropriate moment _0200_nb_bytes++; //the initialisation is made in create_init_ice_prgm() at the appropriate moment _e900_nb_bytes++; //" _e900_checksum+=c; _0100_nb_bytes++; all_ice_prgm_datas_nb_bytes++; //informations utiles commencant aux 2 bytes de data_area_offset (compris) return c; }*/ /* signed char putc_ice_prgm(unsigned char c) { if(fputc(c,ice_prgm)==-1) { printf("\nMem error"); exit(0); } _1400_nb_bytes++; //the initialisation is made in create_init_ice_prgm() at the appropriate moment _0300_nb_bytes++; //the initialisation is made in create_init_ice_prgm() at the appropriate moment checksum+=c; _0100_nb_bytes++; return c; } signed int putw_ice_prgm(signed int c) { unsigned short temp; unsigned char *ptr; ptr=(unsigned char *)(&temp); temp=c; putc_ice_prgm(*ptr); putc_ice_prgm(*(ptr+1)); return c; } unsigned char *putstr_ice_prgm(unsigned char *str) { unsigned short i; i=0; while(str[i]!=0) { putc_ice_prgm(str[i]); i++; } putc_ice_prgm(str[i]); // the '\0' } void make_new_void_hxp(unsigned char *hxp_name) { unsigned char hxp_header[]={0x2A,0x2A,0x54,0x49,0x38,0x33,0x46,0x2a,0x1a,0x0a,0x0a,0x43,0x72,0x65,0x61,0x74, 0x65,0x64,0x20,0x62,0x79,0x20,0x54,0x49,0x20,0x43,0x6f,0x6e,0x6e,0x65,0x63,0x74, 0x20,0x43,0x45,0x20,0x35,0x2e,0x36,0x2e,0x33,0x2e,0x32,0x32,0x37,0x38,0,0, 0,0,0,0,0}; unsigned char full_name_buf[20],i,buf2[20]; checksum=0; sprintf(full_name_buf,"%s.8xp",hxp_name); ice_prgm=fopen(full_name_buf,"w"); if(ice_prgm==0) { printf("\nCreating ice prgm error"); exit(0); } //Beginning of header file bytes for(i=0;i<53;i++) { putc_ice_prgm(hxp_header[i]); } _1400_offset=ftell(ice_prgm); putc_ice_prgm(0); putc_ice_prgm(0); _1400_nb_bytes=0; checksum=0; putc_ice_prgm(0x0d); putc_ice_prgm(0x00); _0300_offset_1=ftell(ice_prgm); putc_ice_prgm(0); putc_ice_prgm(0); putc_ice_prgm(0x05); memset(buf2,0,11); strcpy(buf2,hxp_name); for(i=0;i<10;i++) { putc_ice_prgm(buf2[i]); } _0300_offset_2=ftell(ice_prgm); putc_ice_prgm(0); putc_ice_prgm(0); _0300_nb_bytes=0; _0100_offset=ftell(ice_prgm); putc_ice_prgm(0); putc_ice_prgm(0); _0100_nb_bytes=0; } */ #endif void init_fcs_skip_lists(void) { unsigned short i; for(i=0;i<=255;i++) { fc_skip_list[i]=all_fc_skip_list[fc_nbargs[i]]; //fc_switch_list[i]=all_fc_switch_list(fc_nbargs[i]); } } unsigned char *skip_end_line(unsigned char *ptr) //must points on 0xd or 0x0a { if(*ptr==0x0d && *(ptr+1)==0x0a) return ptr+2; return ptr+1; } unsigned char is_end_line(unsigned char *ptr) { if(*ptr==0x0d && *(ptr+1)==0x0a) return 1; if(*ptr==0x0d) return 1; if(*ptr==0x0a) return 1; return 0; } unsigned char must_be_at_beginning_token(unsigned char *tag_ptr) { switch(*tag_ptr) { case local_tag: case lbl_tag: case goto_tag: case continue_tag: case break_tag: case return_tag: case return_no_tag: case endif_tag: case endfor_tag: case endwhile_tag: case if_tag: case while_tag: case for_tag: case func_tag: case endfunc_tag: case void_tag: //case imaginaire_i_tag: return 1; break; } return 0; } unsigned char is_number_token(unsigned char *ptr); unsigned char get_operator_pos(unsigned char token) { unsigned short i; i=0; //printf(">>>>In get_operator_pos, token=%d",token); while(op_tag[i]!=0) { if(op_tag[i]==token) return i; i++; } my_exit("Error:Unknown operator"); } unsigned char *skip_spaces(unsigned char *ptr) { while(*ptr==' ' || *ptr==' ') //remplacer la deuxième ' ' pour la tabulation { ptr++; } return ptr; } unsigned char is_pure_num(unsigned char *ptr) { if(*ptr>='0' && *ptr<='9') return 1; else return 0; } unsigned char is_pure_alpha(unsigned char *ptr) { if(*ptr=='_' || *ptr>='a' && *ptr<='z' || *ptr>='A' && *ptr<='Z') return 1; else return 0; } unsigned char extract_var_func_str(unsigned char *ptr,unsigned char *buff) { } unsigned char is_line_comment(unsigned char *ptr) { ptr=skip_spaces(ptr); if(*ptr=='/' && *(ptr+1)=='/') return 1; return 0; } unsigned char is_interspace_comment(unsigned char *ptr) { ptr=skip_spaces(ptr); if(*ptr=='/' && *(ptr+1)=='*') return 1; return 0; } unsigned char is_beginning_of_block(unsigned char *ptr) { ptr=skip_spaces(ptr); if(*ptr=='{') {next_ptr=ptr+1; return 1;} return 0; } unsigned char is_end_of_block(unsigned char *ptr) { ptr=skip_spaces(ptr); if(*ptr=='}') {next_ptr=ptr+1; return 1;} return 0; } unsigned char is_op_str(unsigned char *ptr) { unsigned char i,i2,len,*ptr2,temp,buf1[100],buf2[100]; ptr=skip_spaces(ptr); strtoupper_specified_max_len(buf1,ptr,50); /*if(is_debug) { printf("\nIn is op str,ptr=%s, strtoupper_specified=%s",ptr,buf1); keywait(); }*/ for(i=0;i<255;i++) { //if(op_str[i]==0) printf("\n Is null"); if(op_str[i]==0) return 0; //end of operators strs, not found ptr2=op_str[i]; //if(ptr2[i]==0) printf("\n ptr2 Is null"); //printf("\nop_str[i=%d]=%s ptr2[0]=%d ",i,ptr2,ptr2[0]); len=strlen(ptr2); //printf("\nstrlen[%d]=%d",i,len); keywait(); strtoupper_specified_max_len(buf2,ptr2,50); //printf("\nstrlen=%d",len); temp=1; for(i2=0;i2=VARS_FUNCS_MAX_CHARS) my_exit("Error overflow"); output_str[i]=0; strcpy(buf,output_str); temp_ptr=skip_spaces(ptr+i); if(*temp_ptr=='"' || *temp_ptr=='{' || *temp_ptr=='}' || *temp_ptr==',' || is_alpha_num(temp_ptr) || is_op_str(temp_ptr) || *(temp_ptr)==')' || is_hook_str(temp_ptr) || is_end_of_cmd(temp_ptr)) {strcpy(output_str,buf); output_str[i]=0; next_ptr=ptr+i; return 1;} return 0; } } my_exit("Error:Word name too long"); is_too_long=1; return 9; //too long } else return 0; //not a var str } unsigned char is_a_c_word_str(unsigned char *ptr) //continue break goto lbl without '()' { unsigned char i; ptr=skip_spaces(ptr); if(!is_word_str(ptr)) return 0; //printf("\n>>>>>output_str=%s",output_str); i=0; while(c_words_str[i]) { //printf("\nin is a c word,\n%s %s",c_words_str[i],output_str); if(strcasecmp(c_words_str[i],output_str)==0) { //printf(">>>est un c word, iden=%d",i); c_word_iden=i; return 1; } i++; } return 0; } unsigned char *skip_arg(unsigned char *ptr); unsigned char is_func_str(unsigned char *ptr); unsigned char is_restricted_word(unsigned char *ptr) { unsigned short i; i=0; while(c_funcs_str[i]!=0) { if(strcasecmp(c_funcs_str[i],ptr)==0) return 1; i++; } return 0; } unsigned char is_a_user_word_str(unsigned char *ptr) { unsigned char i,buf[100];//,buf[VARS_FUNCS_MAX_CHARS]; ptr=skip_spaces(ptr); //if(is_word_str("maman[]")) printf("\nx>x>Is a word str=%s",output_str); //printf("\n>>>>>input str=%s",ptr); if(is_word_str(ptr)) { //printf("\n>>>In is_a_user_word, est bien un mot"); //strcpy(buf,output_str); //printf("\n>>>%s",output_str); if(!is_a_c_word_str(ptr) && !is_func_str(ptr)) { if(is_restricted_word(output_str)) { sprintf(buf,"Error line %d:Restricted word '%s', '%s()' expected",line,output_str,output_str); my_exit(buf); } return 1; } } return 0; } unsigned char is_comma(unsigned char *ptr) //',' { unsigned char i;//,buf[VARS_FUNCS_MAX_CHARS]; ptr=skip_spaces(ptr); if(*ptr==',') return 1; return 0; } unsigned char is_func_str(unsigned char *ptr) { unsigned char i,*temp_ptr; ptr=skip_spaces(ptr); //printf(" is in is_func_str"); if(is_pure_alpha(ptr)) { for(i=0;i='0' && *ptr<='9') || (*ptr>='A' && *ptr<='F') || (*ptr>='a' && *ptr<='f')) return 1; else return 0; } unsigned char is_pure_bin(unsigned char *ptr) { if(*ptr=='0' || *ptr=='1') return 1; else return 0; } unsigned char is_hex_num(unsigned char *ptr) { unsigned char i,*temp_ptr,*temp_ptr2,output_str_cpy[81],buf[50]; signed int num; ptr=skip_spaces(ptr); //printf("\nin num str, ptr=%s",ptr); if(*ptr==173) {is_minus=1; ptr++; ptr=skip_spaces(ptr); temp_ptr=output_str;/*+1; *output_str=173;*/} else {is_minus=0; temp_ptr=output_str;} if(!(*ptr=='0' && (*(ptr+1)=='x' || *(ptr+1)=='X'))) return 0; ptr+=2; //skip 0x //printf("\nin is_num_str, ptr=%s",ptr); if(is_pure_hex(ptr)) //173==minus tag for negative { for(i=0;i<=8;i++) { if(is_pure_hex(ptr+i)) { temp_ptr[i]=*(ptr+i); temp_ptr[i+1]=0; continue;} else { if(strlen(output_str)>8) { sprintf(buf,"Error line %d:Hxa num too long",line); my_exit(buf); } strcpy(output_str_cpy,output_str); num=(signed int)strtol(output_str_cpy, NULL, 16); //printf("\n num hex str=%s num=%d",output_str_cpy,num); sprintf(output_str_cpy,"%d",num); //printf("\n num hex str=%s",output_str_cpy); temp_ptr2=skip_spaces(ptr+i); //printf("><>><>>is_end_of_cmd=%d, *temp_ptr2=%d",is_end_of_cmd(temp_ptr2),*temp_ptr2); if(*temp_ptr2=='"' || *temp_ptr2=='{' || *temp_ptr2=='}' || is_op_str(temp_ptr2) || is_hook_str(temp_ptr2) || is_end_of_cmd(temp_ptr2) || *(temp_ptr2)==')' || *(temp_ptr2)==',') { strcpy(output_str,output_str_cpy); /*temp_ptr[i]=0;*/ next_ptr=temp_ptr2; /*printf("\noutput str=%s, is_minus=%d",output_str,is_minus);*/ return 1;} return 0; } } sprintf(buf,"Error line %d:Hexa num too long [2]",line); my_exit(buf); return 9; //too long } else return 0; //not a num str } unsigned char is_bin_num(unsigned char *ptr) { unsigned char i,*temp_ptr,*temp_ptr2,output_str_cpy[81],buf[50]; signed int num; ptr=skip_spaces(ptr); //printf("\nin num str, ptr=%s",ptr); if(*ptr==173) {is_minus=1; ptr++; ptr=skip_spaces(ptr); temp_ptr=output_str;/*+1; *output_str=173;*/} else {is_minus=0; temp_ptr=output_str;} if(!(*ptr=='0' && (*(ptr+1)=='b' || *(ptr+1)=='B'))) return 0; ptr+=2; //skip 0b //printf("\nin is_num_str, ptr=%s",ptr); if(is_pure_bin(ptr)) //173==minus tag for negative { for(i=0;i<=32;i++) { if(is_pure_bin(ptr+i)) { temp_ptr[i]=*(ptr+i); temp_ptr[i+1]=0; continue;} else { if(*(ptr+i)>='2' && *(ptr+i)<='9') { sprintf(buf,"Error line %d:invalid binary number",line); my_exit(buf); } if(strlen(output_str)>32) { sprintf(buf,"Error line %d:Binary number too long",line); my_exit(buf); } strcpy(output_str_cpy,output_str); num=(signed int)strtol(output_str_cpy, NULL, 2); sprintf(output_str_cpy,"%d",num); temp_ptr2=skip_spaces(ptr+i); //printf("><>><>>is_end_of_cmd=%d, *temp_ptr2=%d",is_end_of_cmd(temp_ptr2),*temp_ptr2); if(*temp_ptr2=='"' || *temp_ptr2=='{' || *temp_ptr2=='}' || is_op_str(temp_ptr2) || is_hook_str(temp_ptr2) || is_end_of_cmd(temp_ptr2) || *(temp_ptr2)==')' || *(temp_ptr2)==',') { strcpy(output_str,output_str_cpy);/* temp_ptr[i]=0;*/ next_ptr=temp_ptr2; /*printf("\noutput str=%s, is_minus=%d",output_str,is_minus);*/ return 1;} return 0; } } sprintf(buf,"Error line %d:invalid binary number",line); my_exit(buf); return 9; //too long } else return 0; //not a num str } unsigned char is_num_str(unsigned char *ptr) //base 10 { unsigned char i,*temp_ptr,*temp_ptr2,output_str_cpy[81]; ptr=skip_spaces(ptr); if(is_hex_num(ptr)) return 1; if(is_bin_num(ptr)) return 1; //printf("\nin num str, ptr=%s",ptr); if(*ptr==173) {is_minus=1; ptr++; ptr=skip_spaces(ptr); temp_ptr=output_str;/*+1; *output_str=173;*/} else {is_minus=0; temp_ptr=output_str;} //printf("\nin is_num_str, ptr=%s",ptr); if(is_pure_num(ptr)) //173==minus tag for negative { for(i=0;i<=NUMS_MAX_CHARS;i++) { if(is_pure_num(ptr+i)) { temp_ptr[i]=*(ptr+i); temp_ptr[i+1]=0; continue;} else { if(strlen(output_str)>80) my_exit("Error overflow 2"); strcpy(output_str_cpy,output_str); temp_ptr2=skip_spaces(ptr+i); //printf("><>><>>is_end_of_cmd=%d, *temp_ptr2=%d",is_end_of_cmd(temp_ptr2),*temp_ptr2); if(*temp_ptr2=='"' || *temp_ptr2=='{' || *temp_ptr2=='}' || is_op_str(temp_ptr2) || is_hook_str(temp_ptr2) || is_end_of_cmd(temp_ptr2) || *(temp_ptr2)==')' || *(temp_ptr2)==',') { strcpy(output_str,output_str_cpy); temp_ptr[i]=0; next_ptr=temp_ptr2; /*printf("\noutput str=%s, is_minus=%d",output_str,is_minus);*/ return 1;} return 0; } } my_exit("Error:NUM too long"); return 9; //too long } else return 0; //not a num str } unsigned char is_direct_string_str(unsigned char *ptr) { unsigned char i,*temp_ptr; unsigned int size; size=0; ptr=skip_spaces(ptr); if(ptr[0]!='"') return 0; ptr++; temp_ptr=output_str; temp_ptr[0]=0; while(!is_end_of_file(ptr) && !is_end_line(ptr)) { if(*ptr=='"' && *(ptr+1)!='"') { *temp_ptr=0; size++; if(size>=DIRECT_STRING_MAX_CHARS) my_exit("Error:Direct String to long"); next_ptr=ptr+1; return 1; } if(*ptr!='"') { *temp_ptr=*ptr; temp_ptr++; size++; if(size>=DIRECT_STRING_MAX_CHARS) my_exit("Error:String to long"); ptr++; } if(*ptr=='"' && *(ptr+1)=='"') { *temp_ptr='"'; temp_ptr++; size++; if(size>=DIRECT_STRING_MAX_CHARS) my_exit("Error:String to long"); ptr+=2; continue; } } } /* unsigned char get_next_token(unsigned char *ptr) { unsigned char temp,buff[VARS_FUNCS_MAX_CHARS]; ptr=skip_spaces(ptr); if(is_pure_alpha(ptr,buff)) { } }*/ //output_lexer_token is the lexer buffer unsigned char *push_uint8(unsigned char value, unsigned char *ptr, unsigned int *size) { *ptr=uint8_tag; if(*size+2>=LEXER_PARSER_SIZE) my_exit("Error:LEXER-PARSER memory reached [1]"); *(ptr+1)=value; (*size)+=2; //printf(" NEW_SIZE=%d",*size); return ptr+2; } /* void push_uint8_ice_prgm(unsigned char v) { putc_ice_prgm(uint8_tag); putc_ice_prgm(v); } */ unsigned char *push_int8(signed char value, signed char *ptr, unsigned int *size) { *ptr=int8_tag; if(*size+2>=LEXER_PARSER_SIZE) my_exit("Error:LEXER-PARSER memory reached [2]"); *(ptr+1)=value; *size+=2; return ptr+2; } /* void push_int8_ice_prgm(signed char v) { putc_ice_prgm(int8_tag); putc_ice_prgm(v); } */ unsigned char *push_uint16(unsigned short value, unsigned char *ptr, unsigned int *size) { unsigned char *ucptr; ucptr=(unsigned char*)&value; *ptr=uint16_tag; if(*size+3>=LEXER_PARSER_SIZE) my_exit("Error:LEXER-PARSER memory reached [3]"); *(ptr+1)=*ucptr; *(ptr+2)=*(ucptr+1); //*(unsigned short*)(((unsigned char*)ptr+1))=value; *size+=3; return ptr+3; } /* void push_uint16_ice_prgm(unsigned short v) { (uint16_tag); putw_ice_prgm(v); }*/ unsigned char *push_int16(signed short value, unsigned char *ptr, unsigned int *size) { unsigned char *ucptr; ucptr=(unsigned char*)&value; *ptr=int16_tag; if(*size+3>=LEXER_PARSER_SIZE) my_exit("Error:LEXER-PARSER memory reached [4]"); *(ptr+1)=*ucptr; *(ptr+2)=*(ucptr+1); //*(unsigned short*)(((unsigned char*)ptr+1))=value; *size+=3; return ptr+3; /* *ptr=int16_tag; if(*size+3>=LEXER_PARSER_SIZE) my_exit("Error:LEXER-PARSER memory reached [4]"); *(signed short*)(((unsigned char*)ptr+1))=value; *size+=3; return ptr+3; */ } /* void push_int16_ice_prgm(signed short v) { putc_ice_prgm(int16_tag); putw_ice_prgm(v); } */ #ifndef IS_ONCALC //pc unsigned char *push_uint24(unsigned int value, unsigned char *ptr, unsigned int *size) //compatible with pc and ti83 { *ptr=uint24_tag; if(*size+5>=LEXER_PARSER_SIZE) my_exit("Error:LEXER-PARSER memory reached [5]"); *(unsigned int*)(((unsigned char*)ptr+1))=(value&0b00000000111111111111111111111111) | ((*(unsigned int*)(((unsigned char*)ptr+1)))&0b11111111000000000000000000000000); *size+=4; return ptr+4;//the 4th byte will be overwritten next (ptr+4<>ptr+5) } /* void push_uint24_ice_prgm(unsigned int value) { putc_ice_prgm(uint24_tag); putc_ice_prgm(*(((unsigned char*)(&value))+0)); putc_ice_prgm(*(((unsigned char*)(&value))+1)); putc_ice_prgm(*(((unsigned char*)(&value))+2)); } */ unsigned char *push_int24(signed int value, unsigned char *ptr, unsigned int *size) { *ptr=int24_tag; if(*size+5>=LEXER_PARSER_SIZE) my_exit("Error:LEXER-PARSER memory reached [6]"); *(signed int*)(((unsigned char*)ptr+1))=(value&0b00000000111111111111111111111111) | ((*(signed int*)(((unsigned char*)ptr+1)))&0b11111111000000000000000000000000); *size+=4; return ptr+4; } /* void push_int24_ice_prgm(signed int value) { putc_ice_prgm(int24_tag); putc_ice_prgm(*(((unsigned char*)(&value))+0)); putc_ice_prgm(*(((unsigned char*)(&value))+1)); putc_ice_prgm(*(((unsigned char*)(&value))+2)); }*/ #else #endif unsigned char *push_uint32(unsigned int value, unsigned char *ptr, unsigned int *size) { unsigned char *ucptr; ucptr=(unsigned char*)&value; *ptr=uint32_tag; if(*size+5>=LEXER_PARSER_SIZE) my_exit("Error:LEXER-PARSER memory reached [4]"); *(ptr+1)=*ucptr; *(ptr+2)=*(ucptr+1); *(ptr+3)=*(ucptr+2); *(ptr+4)=*(ucptr+3); //*(unsigned short*)(((unsigned char*)ptr+1))=value; *size+=5; return ptr+5; /* *ptr=uint32_tag; if(*size+5>=LEXER_PARSER_SIZE) my_exit("Error:LEXER-PARSER memory reached [7]"); *(unsigned int*)(((unsigned char*)ptr+1))=value; *size+=5; return ptr+5; */ } /* void push_uint32_ice_prgm(unsigned int value) { putc_ice_prgm(uint32_tag); putc_ice_prgm(*(((unsigned char*)(&value))+0)); putc_ice_prgm(*(((unsigned char*)(&value))+1)); putc_ice_prgm(*(((unsigned char*)(&value))+2)); putc_ice_prgm(*(((unsigned char*)(&value))+3)); } */ unsigned char *push_int32(signed int value, unsigned char *ptr, unsigned int *size) { unsigned char *ucptr; ucptr=(unsigned char*)&value; *ptr=int32_tag; if(*size+5>=LEXER_PARSER_SIZE) my_exit("Error:LEXER-PARSER memory reached [4]"); *(ptr+1)=*ucptr; *(ptr+2)=*(ucptr+1); *(ptr+3)=*(ucptr+2); *(ptr+4)=*(ucptr+3); //*(unsigned short*)(((unsigned char*)ptr+1))=value; *size+=5; return ptr+5; /* *ptr=int32_tag; if(*size+5>=LEXER_PARSER_SIZE) my_exit("Error:LEXER-PARSER memory reached [8]"); *(signed int*)(((unsigned char*)ptr+1))=value; *size+=5; return ptr+5; */ } /* void push_int32_ice_prgm(signed int value) { putc_ice_prgm(int32_tag); putc_ice_prgm(*(((unsigned char*)(&value))+0)); putc_ice_prgm(*(((unsigned char*)(&value))+1)); putc_ice_prgm(*(((unsigned char*)(&value))+2)); putc_ice_prgm(*(((unsigned char*)(&value))+3)); } */ /* signed int my_abs(signed int value) { if(value<0) return -value; return value; } */ unsigned char *push_value(signed int value, unsigned char *ptr, unsigned int *size) { //printf("\nin push_value, value=%d",value); unsigned char buf[50]; if(value>0) { if(value<=255) { return push_uint8(value,ptr,size); } if(value<=65535) { return push_uint16(value,ptr,size); } /* if(value<=16777215) { return push_uint24(value,ptr,size); } */ if(value<=4294967295) { return push_uint32(value,ptr,size); } sprintf(buf,"Error line %d:Number too big",line); my_exit(buf); } else //if <0 { if(value>=-128) { return push_int8(value,ptr,size); } if(value>=-32768) { return push_int16(value,ptr,size); } /* if(value>=-8388608) { return push_int24(value,ptr,size); } */ if(value>=-2147483648) { return push_int32(value,ptr,size); } sprintf(buf,"Error line %d:Number too big",line); my_exit(buf); } } signed int get_uint8(unsigned char **lexer_ptr) { unsigned char *ptr; ptr=*lexer_ptr + 1; *lexer_ptr+=2; return *(unsigned char*)ptr; } signed int get_int8(unsigned char **lexer_ptr) { unsigned char *ptr; ptr=*lexer_ptr + 1; *lexer_ptr+=2; return *(signed char*)ptr; } signed int get_uint16(unsigned char **lexer_ptr) { unsigned char *ptr; unsigned short v; ptr=*lexer_ptr + 1; //printf("\ninguint16 ptr=%d",ptr); *lexer_ptr+=3; memcpy(&v,ptr,2); return v; /* #ifdef IS_ONCALC return (unsigned short)(*ptr+256*(*(ptr+1))); #else return *(unsigned short*)ptr; #endif // IS_ONCALC */ } signed int get_int16(unsigned char **lexer_ptr) { unsigned char *ptr; signed short v; ptr=*lexer_ptr + 1; *lexer_ptr+=3; memcpy(&v,ptr,2); return v; //return *(signed short*)ptr; } signed int get_uint24(unsigned char **lexer_ptr) { unsigned char *ptr; ptr=*lexer_ptr + 1; *lexer_ptr+=4; //return (*(unsigned int*)ptr)&0b00000000111111111111111111111111; return (*(unsigned int*)ptr)&0b00000000111111111111111111111111; } signed int get_int24(unsigned char **lexer_ptr) { unsigned char *ptr; signed int temp_value; ptr=*lexer_ptr + 1; *lexer_ptr+=4; temp_value=(*(signed int*)ptr); temp_value=temp_value|0b11111111000000000000000000000000; return temp_value; //return (*(signed int*)ptr)&0b00000000111111111111111111111111; } signed int get_uint32(unsigned char **lexer_ptr) { unsigned char *ptr; unsigned int v; ptr=*lexer_ptr + 1; *lexer_ptr+=5; memcpy(&v,ptr,4); return v; //return *(unsigned int*)ptr; } signed int get_int32(unsigned char **lexer_ptr) { unsigned char *ptr; signed int v; ptr=*lexer_ptr + 1; *lexer_ptr+=5; memcpy(&v,ptr,4); return v; //return *(signed int*)ptr; } signed int get_value(unsigned char **lexer_ptr) { switch(**lexer_ptr) { case int8_tag: return get_int8(lexer_ptr); break; case uint8_tag: return get_uint8(lexer_ptr); break; case int16_tag: return get_int16(lexer_ptr); break; case uint16_tag: return get_uint16(lexer_ptr); break; case int24_tag: return get_int24(lexer_ptr); break; case uint24_tag: return get_uint24(lexer_ptr); break; case int32_tag: return get_int32(lexer_ptr); break; case uint32_tag: return get_uint32(lexer_ptr); break; } my_exit("Internal error:get_value"); } signed int get_value_no_isz(unsigned char *lexer_ptr) { return get_value(&lexer_ptr); } unsigned char *skip_token(unsigned char *ptr) { unsigned int i; signed int temp; if(lexer_size==0) { return ptr; } switch(*ptr) { case uint8_tag: case int8_tag: case uint16_tag: case int16_tag: case uint24_tag: case int24_tag: case uint32_tag: case int32_tag: get_value(&ptr); return ptr; break; case string_tag: ptr++; temp=get_uint16(&ptr); ptr+=temp; return ptr; break; case user_word_tag: ptr++; //skip user_word_tag ptr++; //skip string tag temp=get_uint16(&ptr); ptr+=temp; return ptr; break; case ice_func_tag: case end_ice_func_tag: ptr++; return ptr; break; case user_func_tag: ptr++; ptr++; temp=get_uint16(&ptr); ptr+=temp; //printf("\n in skip arg, next token=%d",*ptr); return ptr; break; } return ptr+1; } unsigned char *push_quantum(unsigned char value, unsigned char *ptr, unsigned int *size) { *ptr=value; if(*size+1>=LEXER_PARSER_SIZE) my_exit("Error:LEXER-PARSER memory reached [7]"); *size+=1; return ptr+1; } unsigned char *push_string(unsigned char *str, unsigned char *ptr, unsigned int *size) //size=taille de la pile { unsigned int str_len; unsigned char *ptr_real_ori,*ptr_ori,size_len; ptr_real_ori=ptr; //*ptr=string_tag; ptr=push_quantum(string_tag,ptr,size); //ptr++; str_len=strlen(str); ptr=push_uint16(str_len+1,ptr,size); if(*size+str_len+1>=LEXER_PARSER_SIZE) my_exit("Error:LEXER-PARSER memory reached (string)"); strcpy(ptr,str); //ptr+=str_len+1; *size+=str_len+1; return ptr+str_len+1; } unsigned char *push_token_from(unsigned char *src_token_ptr, unsigned char *dest_ptr, unsigned int *size) { unsigned int token_dim,i; unsigned char *ptr; ptr=dest_ptr; token_dim=skip_token(src_token_ptr)-src_token_ptr; for(i=0;i",*ptr); printf("STRING_TAG[%d]",temp-1); printf("-%s ",ptr); //2 lines for ti83 ptr+=temp; //continue; break; case if_tag: ptr++; printf("IF_TAG "); //continue; break; case while_tag: ptr++; printf("WHILE_TAG "); //continue; break; case for_tag: ptr++; printf("FOR_TAG "); //continue; break; case add_tag: ptr++; printf("ADD_TAG "); //continue; break; case sub_tag: ptr++; printf("SUB_TAG "); //continue; break; case mul_tag: ptr++; printf("MUL_TAG "); //continue; break; case div_tag: ptr++; printf("DIV_TAG "); // continue; break; case isz_tag: ptr++; printf("ISZ_TAG "); //continue; break; case dsz_tag: ptr++; printf("DSZ_TAG "); //continue; break; case parenthesis_open_tag: ptr++; printf("(_TAG "); //continue; break; case parenthesis_close_tag: ptr++; printf(")_TAG "); //continue; break; case user_word_tag: ptr++; printf("USER_WORD_TAG "); //continue; break; case sup_tag: ptr++; printf("SUP_TAG "); //continue; break; case inf_tag: ptr++; printf("INF_TAG "); //continue; break; case sto_equal_tag: ptr++; printf("STO_EQU_TAG "); //continue; break; case hook_open_tag: ptr++; printf("[_TAG "); //continue; break; case hook_close_tag: ptr++; printf("]_TAG "); //continue; break; case lelem_tag: ptr++; printf("LOAD_ELEM_TAG "); //continue; break; case end_cmd_tag: ptr++; printf("END_CMD_TAG "); //continue; break; case end_line_tag: //ptr=skip_end_line(ptr); ptr++; printf("END_LINE_TAG "); //continue; break; case comma_tag: ptr++; printf(",-TAG "); //continue; break; case block_tag: ptr++; printf("BLOCK_TAG "); //continue; break; case start_block_tag: ptr++; printf("START_BLOCK_TAG "); //continue; break; case end_block_tag: ptr++; printf("END_BLOCK_TAG "); //continue; break; //,endif_tag,endwhile_tag,endfor_tag case endif_tag: ptr++; printf("ENDIF_TAG "); //continue; break; case endwhile_tag: ptr++; printf("ENDWHILE_TAG "); //continue; break; case endfor_tag: ptr++; printf("ENDFOR_TAG "); //continue; break; case if_then_tag: ptr++; printf("IFTHEN_TAG "); // continue; break; case then_tag: ptr++; printf("THEN_TAG "); //continue; break; // orl_tag ,andl_tag ,rollr_tag,rolll_tag,sup_equ_tag,inf_equ_tag,nequ_tag ,equ_tag case orl_tag: ptr++; printf("||_TAG "); //continue; break; case andl_tag: ptr++; printf("&&_TAG "); //continue; break; case rollr_tag: ptr++; printf(">>_TAG "); //continue; break; case rolll_tag: ptr++; printf(",<<_TAG "); //continue; break; case sup_equ_tag: ptr++; printf(">=_TAG "); //continue; break; case inf_equ_tag: ptr++; printf("<=_TAG "); //continue; break; case nequ_tag: ptr++; printf("!=_TAG "); //continue; break; case equ_tag: ptr++; printf("==_TAG "); //continue; break; case mod_tag: //post isz ptr++; printf("MODULO_TAG "); //continue; break; case notl_tag: ptr++; printf("!_TAG "); //continue; break; case end_tag: ptr++; printf("END_TAG "); break; case andb_tag: ptr++; printf("&_TAG "); break; case else_tag: ptr++; printf("ELSE_TAG "); break; case sto_arrow_tag: ptr++; printf("STO_ARROW_TAG "); break; case func_tag: ptr++; printf("FUNC_TAG "); break; case endfunc_tag: ptr++; printf("ENDFUNC_TAG "); break; case imaginaire_i_tag: ptr++; printf("Imaginaire_TAG "); //continue; break; case address_tag: ptr++; printf("Ad*_tag "); break; case xorl_tag: ptr++; printf("XORL_tag "); break; case xorb_tag: ptr++; printf("XORB_tag "); break; case call_tag: ptr++; printf("Call_tag "); break; } //printf("\nin disp_token fin, *ptr=%d",*ptr); return ptr; } void disp_tokens_list(unsigned char *output_lexer_tokens,unsigned int lexer_size) { unsigned int i; unsigned char *ptr,*temp_ptr; if(is_debug!=1) return; if(lexer_size==0) { if(is_debug) { printf("\nNo DATA"); if(is_debug) keywait(); } return; } ptr=output_lexer_tokens; printf("\nDATA:\n{ "); while(ptrVARS_FUNCS_MAX_CHARS*/) { sprintf(buf_temp,"Error line %d:User C FUNC name too long (maxi:%d)",line,VARS_FUNCS_MAX_CHARS); my_exit(buf_temp); } c_func_token=c_funcs_tag[c_func_iden]; ptr_lexer_tokens=push_quantum(c_func_token,ptr_lexer_tokens,&lexer_size); ptr=next_ptr; ptr_lexer_tokens=push_quantum(parenthesis_open_tag,ptr_lexer_tokens,&lexer_size); previous_token=parenthesis_open_tag; ptr++; continue; } if(is_op_str(ptr)) //doit être placé après les commentaires et avant user words et c words { //unsigned char *op_str[]={"++","--","+","-","*","/",0}; //add_tag,sub_tag,mul_tag,div_tag,isz_tag,dsz_tag if(is_debug) {printf("\nIs an operator =%s, strlen=%d",output_str,strlen(output_str)); keywait();} op_token=op_tag[op_iden]; if(op_token==stoucad) { printf("In lexer, stoucad, after ptr=%c %s",*ptr,next_ptr); } if(op_token==sub_tag) //for minus or substraction purpose { //The condition tags just below is for which one who not make a minus so they are real soustractions if(!(previous_token==int8_tag || previous_token==hook_close_tag || previous_token==parenthesis_close_tag || previous_token==user_word_tag || previous_token==user_func_tag || previous_token==user_word_tag)) //int8_tag représente tous les types de nombres (8 16 32) pour previous_token { ptr_lexer_tokens=push_value(-1,ptr_lexer_tokens,&lexer_size); ptr_lexer_tokens=push_quantum(mul_tag,ptr_lexer_tokens,&lexer_size); previous_token=mul_tag; ptr=next_ptr; //printf("\n*ptr=%d",*ptr); continue; } } if(op_token==add_tag) // + suppress the token when no use at the beginning, example var=+2 become var=2 { if(!(previous_token==int8_tag || previous_token==string_tag || previous_token==hook_close_tag || previous_token==parenthesis_close_tag || previous_token==user_word_tag || previous_token==user_func_tag || previous_token==user_word_tag)) //int8_tag représente tous les types de nombres (8 16 32) pour previous_token { ptr=next_ptr; continue; } } ptr_lexer_tokens=push_quantum(op_token,ptr_lexer_tokens,&lexer_size); previous_token=op_token; ptr=next_ptr; //printf("\n at end of operator token, ptr=%s, is_end_of_file=%d",ptr,is_end_of_file(ptr)); continue; } if(is_a_user_word_str(ptr)) { //printf("\nuser word, next_ptr=%c ",*next_ptr); disp_token(ptr); keywait(); if(is_too_long/*strlen(output_str)>VARS_FUNCS_MAX_CHARS*/) //redondant { sprintf(buf_temp,"Error line %d:User word name too long (maxi:%d)",line,VARS_FUNCS_MAX_CHARS); my_exit(buf_temp); } if((constant_i=get_constant_word_str(output_str))!=666) //if constant exist { //newprog_constant_list if(is_minus==0) ptr_lexer_tokens=push_value(newprog_constant_list[constant_i].value,ptr_lexer_tokens,&lexer_size); else ptr_lexer_tokens=push_value(-newprog_constant_list[constant_i].value,ptr_lexer_tokens,&lexer_size); previous_token=int8_tag; ptr=next_ptr; continue; } else //so a user_word { ptr_lexer_tokens=push_quantum(user_word_tag,ptr_lexer_tokens,&lexer_size); previous_token=user_word_tag; ptr=next_ptr; ptr_lexer_tokens=push_string(output_str,ptr_lexer_tokens,&lexer_size); continue; } } if(is_a_c_word_str(ptr)) { //printf("\nis c_word"); if(is_too_long/*strlen(output_str)>VARS_FUNCS_MAX_CHARS*/) //redondant { sprintf(buf_temp,"Error line %d:Language word name too long (maxi:%d)",line,VARS_FUNCS_MAX_CHARS); my_exit(buf_temp); } c_word_token=c_words_tag[c_word_iden]; ptr_lexer_tokens=push_quantum(c_word_token,ptr_lexer_tokens,&lexer_size); previous_token=c_word_token; //previous_token=*ptr; ptr=next_ptr; //ptr_lexer_tokens=push_string(output_str,ptr_lexer_tokens,&lexer_size); continue; } if(is_user_func_str(ptr)) { //user_func_tag //printf("\nuser func, "); if(is_too_long/*strlen(output_str)>VARS_FUNCS_MAX_CHARS*/) { sprintf(buf_temp,"Error line %d:User func name too long (maxi:%d)",line,VARS_FUNCS_MAX_CHARS); my_exit(buf_temp); } ptr_lexer_tokens=push_quantum(user_func_tag,ptr_lexer_tokens,&lexer_size); ptr=next_ptr; //printf("\nnext ptr=%s",ptr); ptr_lexer_tokens=push_string(output_str,ptr_lexer_tokens,&lexer_size); //ptr=next_ptr; ptr_lexer_tokens=push_quantum(parenthesis_open_tag,ptr_lexer_tokens,&lexer_size); previous_token=parenthesis_open_tag; ptr++; //printf("\nprochain char=%c",*ptr); continue; } if(is_beginning_of_block(ptr)) { ptr=next_ptr; ptr_lexer_tokens=push_quantum(block_tag,ptr_lexer_tokens,&lexer_size); ptr_lexer_tokens=push_quantum(start_block_tag,ptr_lexer_tokens,&lexer_size); previous_token=start_block_tag; continue; } if(is_end_of_block(ptr)) { ptr=next_ptr; ptr_lexer_tokens=push_quantum(end_block_tag,ptr_lexer_tokens,&lexer_size); previous_token=end_block_tag; continue; } if(is_direct_string_str(ptr)) { //printf("\ndirect string, "); //The size verification is made in is_direct_string_str() ptr_lexer_tokens=push_string(output_str,ptr_lexer_tokens,&lexer_size); previous_token=string_tag; ptr=next_ptr; continue; } if(is_num_str(ptr)) { //printf("num_str=%s, atol=%d, is_minus=%d",output_str,atol(output_str),is_minus); if(strlen(output_str)>NUMS_MAX_CHARS) { sprintf(buf_temp,"Error line %d:NUM too long (maxi:%d)",line,NUMS_MAX_CHARS); my_exit(buf_temp); } if(is_minus==0) {ptr_lexer_tokens=push_value(atol(output_str),ptr_lexer_tokens,&lexer_size);} else {ptr_lexer_tokens=push_value(-atol(output_str),ptr_lexer_tokens,&lexer_size);} previous_token=int8_tag; ptr=next_ptr; continue; } if(is_comma(ptr)) { ptr_lexer_tokens=push_quantum(comma_tag,ptr_lexer_tokens,&lexer_size); previous_token=comma_tag; ptr++; continue; } if(*ptr=='(') { //printf("open parenth, "); ptr_lexer_tokens=push_quantum(parenthesis_open_tag,ptr_lexer_tokens,&lexer_size); previous_token=parenthesis_open_tag; ptr++; continue; } if(*ptr==')') { //printf("close parenth, "); ptr_lexer_tokens=push_quantum(parenthesis_close_tag,ptr_lexer_tokens,&lexer_size); previous_token=parenthesis_close_tag; ptr++; continue; } if(*ptr=='[') { //printf("begin hook, "); keywait(); ptr_lexer_tokens=push_quantum(hook_open_tag,ptr_lexer_tokens,&lexer_size); previous_token=hook_open_tag; ptr++; continue; } if(*ptr==']') { //printf("end hook, "); ptr_lexer_tokens=push_quantum(hook_close_tag,ptr_lexer_tokens,&lexer_size); previous_token=hook_close_tag; ptr++; continue; } if(is_end_of_cmd(ptr) && !is_end_line(ptr)) // i1;i2 { //printf("\nis end of cmd"); ptr_lexer_tokens=push_quantum(end_cmd_tag,ptr_lexer_tokens,&lexer_size); previous_token=end_cmd_tag; ptr++; prgm_moving_ptr=ptr; return 1; //continue; } if(is_end_line(ptr)) //retour chariot { //printf("is end of line"); /*if(previous_token==end_line_tag) //if void line, so goto next { ptr=skip_end_line(ptr); nb_line_to_add++; previous_token=end_line_tag; continue; } */ ptr_lexer_tokens=push_quantum(end_line_tag,ptr_lexer_tokens,&lexer_size); previous_token=end_line_tag; ptr=skip_end_line(ptr); prgm_moving_ptr=ptr; nb_line_to_add++; //printf("\nis end of line, next *ptr=%d",*ptr); if(is_end_of_file(ptr)) { //was_the_last_line=1; return 2; //end of file } else return 1; //end of line //continue; } ptr++; } ptr_lexer_tokens=push_quantum(end_cmd_tag,ptr_lexer_tokens,&lexer_size); prgm_moving_ptr=ptr; nb_line_to_add++; //was_the_last_line=1; return 2; //this is the last line } unsigned char *check_if_for_while_single_duo_parenthesis(unsigned char *ptr_open_parenthesis_token_ptr) //Will print an error if 'if()*;' 'while()*;' . The error is the '*' { unsigned char level,*ptr,buf_temp[150]; level=0; ptr=ptr_open_parenthesis_token_ptr; while(*ptr!=end_cmd_tag && *ptr!=end_line_tag && *ptr!=end_prgm_tag) { if(*ptr==parenthesis_open_tag) level++; if(*ptr==parenthesis_close_tag) level--; ptr=skip_token(ptr); } if(level==0 && *(ptr-1)!=parenthesis_close_tag) //la vérification du bon parenthesage est fait ailleur { sprintf(buf_temp,"Error line %d:Syntax 'if();...;' 'while();...;endwhile' 'for();...;endfor'",line); my_exit(buf_temp); } } unsigned char Verifications_and_transformations_lexer(void) { unsigned char *ptr,previous_token_tag,buf_temp[100],is_in_block,*then_ptr,parenthesis_level; unsigned short if_then_level,while_level,for_level; ptr=output_lexer_tokens; previous_token_tag=end_cmd_tag; is_in_block=0; if_then_level=0; while_level=0; for_level=0; parenthesis_level=0; //line=1; //disp_tokens_list(output_lexer_tokens,lexer_size); while(ptr=250) { sprintf(buf_temp,"Error line %d:Too much '('",line); my_exit(buf_temp); } previous_token_tag=parenthesis_open_tag; ptr++; continue; } if(*ptr==parenthesis_close_tag) { if(parenthesis_level==0) { sprintf(buf_temp,"Error line %d:Too much ')'",line); my_exit(buf_temp); } parenthesis_level--; previous_token_tag=parenthesis_close_tag; ptr++; continue; } if(*ptr==start_block_tag) { if(is_in_block) //error, imbricated block { sprintf(buf_temp,"Error line %d:Unexpected lists {{}} (imbricated)",line); my_exit(buf_temp); } is_in_block=1; *ptr=parenthesis_open_tag; //Transforms [ to ( for shunting yard previous_token_tag=*ptr; ptr++; continue; } if(*ptr==end_block_tag) { if(!is_in_block) { sprintf(buf_temp,"Error line %d:Start of list {} missing",line); my_exit(buf_temp); } is_in_block=0; *ptr=parenthesis_close_tag; previous_token_tag=*ptr; ptr++; continue; } if(is_in_block && (*ptr==if_tag || *ptr==for_tag || *ptr==while_tag || *ptr==goto_tag || *ptr==lbl_tag || *ptr==ice_func_tag)) { sprintf(buf_temp,"Error line %d:Forbiden IF-FOR-WHILE-LBL-GOTO in list {}",line); my_exit(buf_temp); } if(is_in_block && (*ptr==endif_tag || *ptr==endfor_tag || *ptr==endwhile_tag)) { sprintf(buf_temp,"Error line %d:Forbiden ENDIF-ENDFOR-ENDWHILE in list {}",line); my_exit(buf_temp); } /* { if(is_in_block) //error, imbricated block { sprintf(buf_temp,"Error line %d:Unexpected lists (imbricated)",line); my_exit(buf_temp); } is_in_block=1; ptr++; continue; } */ if(*ptr==end_line_tag) { if(parenthesis_level>0) { sprintf(buf_temp,"Error line %d:Missing ')' [x%d]",line,parenthesis_level); my_exit(buf_temp); } if(is_in_block) { sprintf(buf_temp,"Error line %d:Missing '}'",line); my_exit(buf_temp); } //line++; previous_token_tag=end_line_tag; ptr++; continue; } if(*ptr==end_cmd_tag) { previous_token_tag=end_cmd_tag; ptr++; if(parenthesis_level>0) { sprintf(buf_temp,"Error line %d:Missing ')' [x%d]",line,parenthesis_level); my_exit(buf_temp); } if(is_in_block) { sprintf(buf_temp,"Error line %d:Missing '}'",line); my_exit(buf_temp); } continue; } if(must_be_at_beginning_token(ptr)) //lbl if while return break endif func... { //printf("\nMust be at beginning"); /* if(previous_token_tag!=end_line_tag) { //disp_token(ptr); sprintf(buf_temp,"Error line %d:'lbl' 'if' and all specials words must be at the beginning of a command",line); my_exit(buf_temp); } */ if(*ptr==lbl_tag || *ptr==goto_tag) { if(*(ptr+1)!=user_word_tag) { sprintf(buf_temp,"Error line %d:Expected syntax : 'lbl name' or 'goto name'",line); my_exit(buf_temp); } } if(*ptr==if_tag) { if(*(ptr+1)==then_tag) { sprintf(buf_temp,"Error line %d:Condition expected in IF IFTHEN",line); my_exit(buf_temp); } if(is_an_ifthen(ptr,&then_ptr)) { //printf("\nis an if then"); *ptr=if_then_tag; //Transform the if in ifthen *then_ptr=end_cmd_tag; //replace the then_tag by end_cmd_tag. This new tag will be shunt at shunting yard process if_then_level++; } else check_if_for_while_single_duo_parenthesis(ptr+1); //else printf("\nn'est pas un if then"); } if(*ptr==endif_tag) { if(previous_token_tag!=end_cmd_tag && previous_token_tag!=end_line_tag) { sprintf(buf_temp,"Error line %d:ENDIF must be at the beginning of a command",line); my_exit(buf_temp); } /* if(if_then_level==0) { sprintf(buf_temp,"Error line %d:ENDIF unexpected",line); my_exit(buf_temp); } if_then_level--; */ } if(*ptr==while_tag) { if(previous_token_tag!=end_cmd_tag && previous_token_tag!=end_line_tag) { sprintf(buf_temp,"Error line %d:WHILE must be at the beginning of a command",line); my_exit(buf_temp); } check_if_for_while_single_duo_parenthesis(ptr+1); //else printf("\nn'est pas un if then"); //while_level++; } if(*ptr==endwhile_tag) { if(previous_token_tag!=end_cmd_tag && previous_token_tag!=end_line_tag) { sprintf(buf_temp,"Error line %d:ENDWHILE must be at the beginning of a command",line); my_exit(buf_temp); } /* if(while_level==0) { sprintf(buf_temp,"Error line %d:ENDWHILE unexpected",line); my_exit(buf_temp); } while_level--; */ } if(*ptr==for_tag) { if(previous_token_tag!=end_cmd_tag && previous_token_tag!=end_line_tag) { sprintf(buf_temp,"Error line %d:FOR must be at the beginning of a command",line); my_exit(buf_temp); } check_if_for_while_single_duo_parenthesis(ptr+1); //else printf("\nn'est pas un if then"); //for_level++; } if(*ptr==endfor_tag) { if(previous_token_tag!=end_cmd_tag && previous_token_tag!=end_line_tag) { sprintf(buf_temp,"Error line %d:ENDFOR must be at the beginning of a command",line); my_exit(buf_temp); } /* if(for_level==0) { sprintf(buf_temp,"Error line %d:ENDFOR unexpected",line); my_exit(buf_temp); } for_level--; */ } if(*ptr==func_tag) //fonctions codées en newprogcx { if(previous_token_tag!=end_cmd_tag && previous_token_tag!=end_line_tag) { sprintf(buf_temp,"Error line %d:'Func' must be at the beginning of a command",line); my_exit(buf_temp); } if(*(ptr+1)!=user_func_tag) { sprintf(buf_temp,"Error line %d:'Func funcname(...)' expected",line); my_exit(buf_temp); } } if(*ptr==endfunc_tag) //beginning of a ice func { if(previous_token_tag!=end_cmd_tag && previous_token_tag!=end_line_tag) { sprintf(buf_temp,"Error line %d:'Endfunc' must be at the beginning of a command",line); my_exit(buf_temp); } } /* if(*ptr==ice_func_tag) //beginning of a ice func { if(previous_token_tag!=end_cmd_tag && previous_token_tag!=end_line_tag) { sprintf(buf_temp,"Error line %d:'Func' must be at the beginning of a command",line); my_exit(buf_temp); } if(*(ptr+1)!=user_func_tag) { sprintf(buf_temp,"Error line %d:'Func funcname(...)' expected",line); my_exit(buf_temp); } } */ if(*ptr==end_ice_func_tag) //beginning of a ice func { if(previous_token_tag!=end_cmd_tag && previous_token_tag!=end_line_tag) { sprintf(buf_temp,"Error line %d:'Endfunc' must be at the beginning of a command",line); my_exit(buf_temp); } } previous_token_tag=*ptr; ptr++; continue; } previous_token_tag=*ptr; //ptr++; ptr=skip_token(ptr); } if(parenthesis_level>0) { sprintf(buf_temp,"Error line %d:Missing ')' [x%d]",line,parenthesis_level); my_exit(buf_temp); } //if(if_then_level>0) my_exit("Error:ENDIF expected"); //if(while_level>0) my_exit("Error:ENDWHILE expected"); //if(for_level>0) my_exit("Error:ENDFOR expected"); } /* unsigned char transform_hooks_to_lelem_in_output_lexer_tokens(void) { unsigned char *ptr,*ptr2,*ptr3,*ptr4,hooks_level,buf_temp[200]; unsigned int i; ptr=output_lexer_tokens; hooks_level=0; i=0; while(ptr0) hooks_level--; if(*ptr3==hook_close_tag && hooks_level==0) { *ptr3=parenthesis_close_tag; //transform ] to ) break; } ptr3=skip_token(ptr3); } if((ptr3==output_lexer_tokens+lexer_size && *ptr3!=hook_close_tag)) // not found >>error { sprintf(buf_temp,"Error line %d:Missing ]",line); my_exit(buf_temp); } ptr=ptr2+2; continue; } } ptr=skip_token(ptr); } } */ char get_degree_user_word(unsigned char *user_word_tag_ptr) //return how many [] degree. 0=not array so a classical var ; 1=list 2=mat { signed char degree,level; unsigned char *ptr,buf[50]; degree=0; //0=classic var 1=list 2=mat level=0; //level of imbrications ptr=user_word_tag_ptr; //printf("\nin get degree\n"); //disp_token(ptr); ptr=skip_token(ptr); //skip user_word_tag //if(*ptr!=hook_open_tag) return 0; //ptr=skip_token(ptr); //skip hook open tag degree=0; level=0; while(ptrfirst arg { unsigned char *ptr,i,i_degree,level,buf[50]; ptr=user_word_tag_ptr; ptr=skip_token(ptr); //skip user_word_tag //if(*ptr!=hook_open_tag) return 0; //ptr=skip_token(ptr); //skip hook open tag i_degree=0; level=0; while(ptrtotal_degree) my_exit("Error:list or matrix degree"); if(i_degree==argn) { if(*(ptr+1)==hook_close_tag) return 0; //void argn else return ptr+1; } level++; //degree++; //printf("\nIn open, degree=%d level=%d",degree,level); } if(*ptr==hook_close_tag) { //ptr++;//skip hook_close_tag level--; if(level==0 && *(ptr+1)!=hook_open_tag) { sprintf(buf,"Error line %d:over range in list or matrix",line); my_exit(buf); } //printf("\nIn close, degree=%d level=%d",degree,level); } ptr=skip_token(ptr); } } unsigned char *get_end_token_ptr_of_list_or_matrix(unsigned char *user_word_tag_ptr) //returns the ptr of token after the last ']' { signed char degree,level; unsigned char *ptr,buf[50]; degree=0; //0=classic var 1=list 2=mat level=0; //level of imbrications ptr=user_word_tag_ptr; //printf("\nin get degree\n"); //disp_token(ptr); ptr=skip_token(ptr); //skip user_word_tag //if(*ptr!=hook_open_tag) return 0; //ptr=skip_token(ptr); //skip hook open tag degree=0; level=0; while(ptr=19) my_exit("Error:Too much imbricated '[]'"); //end_ptr=output_lexer_tokens+lexer_size; temp_lexer_size=0; while(ptrDIRECT_STRING_MAX_CHARS-2) { sprintf(buf_temp,"Error line %d:Instruction too long (maxi lenght %d bytes)",line,DIRECT_STRING_MAX_CHARS-2); my_exit(buf_temp); } memcpy(output_lexer_tokens,sub_l_elem_list[i].lexer_sub_tokens_list,sub_l_elem_list[i].size_in_bytes); lexer_size=sub_l_elem_list[i].size_in_bytes; //printf("\ncopy:"); //disp_tokens_list(output_lexer_tokens,lexer_size); // } //} //printf("\nEnd transforms... list :"); //disp_tokens_list(temp_output_lexer_tokens,temp_lexer_size); //29/04/2023 begin /* while(ptr0) hooks_level--; if(*ptr3==hook_close_tag && hooks_level==0) { *ptr3=parenthesis_close_tag; //transform ] to ) break; } ptr3=skip_token(ptr3); } if((ptr3==output_lexer_tokens+lexer_size && *ptr3!=hook_close_tag)) // not found >>error { sprintf(buf_temp,"Error line %d:Missing ]",line); my_exit(buf_temp); } ptr=ptr2+2; continue; } } ptr=skip_token(ptr); }*/ //29/04/2023 end } unsigned char get_next_line_lexer_and_verifs_and_transforms(void) { unsigned char temp; if(was_the_last_line) return 0; //printf("\nbeginning * : %c",*src_prgm); keywait(); temp=lexer_process(); if(is_debug) printf("\nOriginal Lexer line %d :",line); if(is_debug) disp_tokens_list(output_lexer_tokens,lexer_size); if(temp==2) was_the_last_line=1; lexer_process_result=temp; //1=end of line, 2=end of prgm Verifications_and_transformations_lexer(); if(is_debug) printf("\nLexer line %d before hooks trasforms :",line); if(is_debug) disp_tokens_list(output_lexer_tokens,lexer_size); transform_hooks_to_lelem_in_output_lexer_tokens(); //transform_bin_or_hex_to_num_in_output_lexer_tokens(); return temp; } unsigned char is_number_token(unsigned char *ptr) { switch(*ptr) { case uint8_tag: case int8_tag: case uint16_tag: case int16_tag: case uint32_tag: case int32_tag: return 1; break; } return 0; } unsigned char is_number_token_with_opposite(unsigned char *ptr) //if mul_tag for opposite { unsigned char *ptr1,*ptr2; int v1,v2; switch(*ptr) { case uint8_tag: case int8_tag: case uint16_tag: case int16_tag: case uint32_tag: case int32_tag: return 1; break; } if(*ptr==mul_tag) { ptr++; ptr1=ptr; ptr2=skip_arg(ptr1); if(is_number_token(ptr1) && is_number_token(ptr2)) { return 1; } else 0; } return 0; } int get_value_of_opposite(unsigned char *mul_tag_ptr_or_value_ptr) { unsigned char *ptr,*ptr1,*ptr2; int v1,v2; ptr=mul_tag_ptr_or_value_ptr; if(*ptr==mul_tag) { ptr++; ptr1=ptr; ptr2=skip_arg(ptr1); v1=get_value_no_isz(ptr1); v2=get_value_no_isz(ptr2); return v1*v2; } else return get_value(&ptr); my_exit("Error in get_value_of_opposite"); } unsigned char is_word_token(unsigned char *ptr) { unsigned short i; i=0; if(ptr==0) return 0; while(c_words_tag[i]!=0) { if(*ptr==c_words_tag[i]) return 1; i++; } switch(*ptr) { case user_word_tag: return 1; break; } return 0; } unsigned char is_c_func_token(unsigned char *ptr) { unsigned short i; i=0; if(ptr==0) return 0; while(c_funcs_tag[i]!=0) { if(*ptr==c_funcs_tag[i]) return 1; i++; } if(*ptr==if_then_tag) return 1; return 0; } unsigned char is_func_token(unsigned char *ptr) { unsigned short i; i=0; if(ptr==0) return 0; if(is_c_func_token(ptr)) return 1; /* while(c_funcs_tag[i]!=0) { if(*ptr==c_funcs_tag[i]) return 1; i++; } */ switch(*ptr) { case user_func_tag: case block_tag: case lelem_tag: case for_c_tag: //moi return 1; break; } return 0; } unsigned char is_operator_token(unsigned char *ptr) { unsigned char i; //printf(" - token=%d",*ptr); i=0; if(ptr==0) return 0; while(op_tag[i]!=0) { if(*ptr==op_tag[i]) { //printf("\noperator match iden=%d, op_tag[i]=%d *ptr=%d",i,op_tag[i],*ptr); return 1; } i++; } return 0; } void disp_stack(unsigned char *stack,unsigned int stack_size) { unsigned int i; printf("\nStack : "); disp_tokens_list(stack,stack_size); } unsigned char is_LtoR_operator(unsigned char op_tag) { if(op_associa[op_tag]==LtoR) return 1; else return 0; } unsigned char is_RtoL_operator(unsigned char op_tag) { return !is_LtoR_operator(op_tag); } void init_Stack (Stack *s){ unsigned short i; for(i=0;itoken_ptr[i]=null_tag; } s->nb_elem=0; } signed char push_Stack(Stack *s,unsigned char *token_ptr) { if(s->nb_elem>=STACK_NBELEM) my_exit("Error:Stack overflow"); s->nb_elem++; s->token_ptr[s->nb_elem-1]=token_ptr; return 1; } unsigned char *pop_Stack(Stack *s) { if(s->nb_elem==0) return 0; s->nb_elem--; return s->token_ptr[s->nb_elem]; } unsigned char *get_top_stack_without_poping(Stack *s) { if(s->nb_elem==0) my_exit("Error:Try to load an empty Stack"); return s->token_ptr[s->nb_elem-1]; } void disp_Stack(Stack *s) { unsigned short i; printf("\nstack:"); for(i=0;inb_elem;i++) { printf("\n%d ",i+1); disp_token(s->token_ptr[i]); } } //for nb args verifications : void er_fc(void) { unsigned char buff[100]; sprintf(buf,"Error line %d:wrong argument(s) number",line); my_exit(buf); } void _mat_list(void) { skip_ptr++; X_arg(); } void _0arg(void) { skip_ptr++; } void _1arg(void) { skip_ptr++; (*((fc_skip_list[*skip_ptr])))(); } void _2arg(void) { skip_ptr++; (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); } void _3arg(void) { skip_ptr++; (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); } void _4arg(void) { skip_ptr++; (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); } void _5arg(void) { skip_ptr++; (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); } void _6arg(void) { skip_ptr++; (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); } void _7arg(void) { skip_ptr++; (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); } void _8arg(void) { skip_ptr++; (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); } void _9arg(void) { skip_ptr++; (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); } void value(void) { get_value(&skip_ptr); } void strng(void) { unsigned short temp; skip_ptr++; temp=get_uint16(&skip_ptr); skip_ptr+=temp; } void X_arg(void) { unsigned char buf[100],i; //printf("\nin X_arg,skip_ptr=%d. token :",skip_ptr); disp_token(skip_ptr); skip_ptr++; i=0; while(*skip_ptr!=end_tag) { //printf(" in i=%d, skip_ptr=%d",i,skip_ptr); disp_token(skip_ptr); (*((fc_skip_list[*skip_ptr])))(); /* if(skip_ptr>max_skip_ptr) { sprintf(buf,"Error line %d: Argument(s) count [0]",line); my_exit(buf); } */ } skip_ptr++; } void uword(void) //user word { skip_ptr++; strng(); } void f1arg(void) { unsigned char buf[100]; skip_ptr++; (*((fc_skip_list[*skip_ptr])))(); if(*skip_ptr!=end_tag) { sprintf(buf,"Error line %d:Arguments count",line); my_exit(buf); } skip_ptr++; } void f2arg(void) { unsigned char buf[100]; skip_ptr++; (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); if(*skip_ptr!=end_tag) { sprintf(buf,"Error line %d:Arguments count",line); my_exit(buf); } skip_ptr++; } void f3arg(void) { unsigned char buf[100]; skip_ptr++; (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); if(*skip_ptr!=end_tag) { sprintf(buf,"Error line %d:Arguments count",line); my_exit(buf); } skip_ptr++; } void f4arg(void) { unsigned char buf[100]; skip_ptr++; (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); if(*skip_ptr!=end_tag) { sprintf(buf,"Error line %d:Arguments count",line); my_exit(buf); } skip_ptr++; } void nwdata_skip(void) { unsigned char buf[100]; skip_ptr++; (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); (*((fc_skip_list[*skip_ptr])))(); if(*skip_ptr!=end_tag) { sprintf(buf,"Error line %d:Arguments count [A]",line); my_exit(buf); } skip_ptr++; } void fXarg(void) //local() : locals vars { unsigned char buf[100]; skip_ptr++; while(*skip_ptr!=end_tag) { (*((fc_skip_list[*skip_ptr])))(); if(skip_ptr>max_skip_ptr) { sprintf(buf,"Error line %d: Argument(s) count [X]",line); my_exit(buf); } } skip_ptr++; } void invert_parser_line(/*unsigned char *dest,unsigned int *dest_size*/ void) { unsigned char *tokens_ptr_list[3000],*ptr_parser,*moving_dest_ptr,*dest; unsigned short i; signed int i2; unsigned char parser_line_inverted[LEXER_PARSER_SIZE]; unsigned int parser_line_inverted_size,*dest_size; dest=parser_line_inverted; dest_size=&parser_line_inverted_size; parser_line_inverted_size=0; ptr_parser=output_parser_tokens; moving_dest_ptr=dest; *dest_size=0; i=0; while(ptr_parser=3000) my_exit("Error : overflow during parser line invertion"); ptr_parser=skip_token(ptr_parser); } for(i2=i-1;i2>=0;i2--) { //printf(">>temp token :"); //disp_token(tokens_ptr_list[i2]); moving_dest_ptr=push_token_from(tokens_ptr_list[i2],moving_dest_ptr,dest_size); } moving_dest_ptr=push_quantum(end_cmd_tag,moving_dest_ptr,dest_size); //for end_cmd nbargs verifications purpose memcpy(output_parser_tokens,parser_line_inverted,parser_line_inverted_size); if(is_debug) printf("\nInverted parser line :"); parser_size++; if(is_debug) disp_tokens_list(output_parser_tokens,parser_size); } void operators_cfuncs_nbargs_verif(unsigned char *ptr, unsigned char *max_ptr) //verif for all excepting user funcs { //disp_tokens_list(output_parser_tokens,parser_size); //if(is_debug) printf("\nIn operators_cfuncs_nbargs_verif"); if(*ptr==end_cmd_tag) //void line { printf("\nNbargs verif process : >Void line"); printf(" >>>>Returns"); return; } skip_ptr=ptr; //printf("\nverif token:"); //disp_token(skip_ptr); max_skip_ptr=max_ptr-1; //printf("\n1-max_skip_ptr=%d",max_skip_ptr); (*((fc_skip_list[*skip_ptr])))(); //printf("\n2-skip_ptr=%d *skip_ptr=%d",skip_ptr,*skip_ptr); if(skip_ptr>max_skip_ptr || *skip_ptr!=end_cmd_tag) { printf("\nError:Token after skipping process :"); disp_token(skip_ptr); sprintf(buf,"Error line %d:error",line); my_exit(buf); } } unsigned char *skip_arg(unsigned char *ptr) { unsigned char *temp_ptr,*next_arg_ptr;; temp_ptr=skip_ptr; skip_ptr=ptr; (*((fc_skip_list[*skip_ptr])))(); next_arg_ptr=skip_ptr; skip_ptr=temp_ptr; return next_arg_ptr; } unsigned short get_arg_size(unsigned char *ptr) { return skip_arg(ptr)-ptr; } unsigned short get_nb_args(unsigned char *ptr) //true before and after arguments switching { unsigned char buf[100],is_user_func=0; unsigned short n; if(*ptr==user_func_tag) is_user_func=1; else is_user_func=0; switch(fc_nbargs[*ptr]) { case _er: sprintf(buf,"Internal Error line %d, *ptr=%d",line,*ptr); //disp_token(ptr); my_exit(buf); break; case _data: return 1; break; case _0: case _1: case _2: case _3: case _4: case _5: case _6: case _7: case _8: case _9: return fc_nbargs[*ptr]; break; case _value: case _string: case _uword: return 0; break; case _X: case _cfX: //local() n=0; ptr++; while(*ptr!=end_tag) { ptr=skip_arg(ptr); n++; } if(is_user_func) return n-1; //retire the string token in count else return n; break; case _cf1: return 1; break; case _cf2: return 2; break; case _cf3: return 3; break; case _cf4: return 4; break; case nwdata: return 4; break; } sprintf(buf,"Internal Error line %d [2]",line); my_exit(buf); } unsigned char *get_arg_n_ptr_before_switching(unsigned char *ptr,unsigned short arg_n,unsigned short nb_args) { unsigned short i; char buf[100]; ptr++; //skip op func block tag //printf("\ntokk="); //disp_token(ptr); if(arg_n>nb_args) { sprintf(buf,"Internal Error:trying to retrieve a wrong argument"); my_exit(buf); } for(i=arg_n;i=_cf2 && fc_nbargs[*ptr]<=_cf4) || *ptr==newdata_tag || *ptr==block_tag || *ptr==lelem_tag || *ptr==sto_equal_tag) { //if(*ptr==lelem_tag) printf("\nIs in switch lelem"); keywait(); size=get_arg_size(ptr); nb_args=get_nb_args(ptr); memcpy(buf,ptr,size); moving_buf_ptr=buf; moving_buf_ptr++; //skip op tag //if(*ptr==lelem_tag) printf("\nin switch, lelem"); for(i=1;iNB_LBL_MAX) my_exit("Error:Too much lbl"); } } if(*ptr==goto_tag || *ptr==call_tag) { /*if(*(ptr+1)!=user_word_tag) { sprintf(buf,"Error line %d:Label (with goto) name must be a word",line); my_exit(buf); }*/ str=get_string_no_isz(ptr+2); if(is_already_exist_lbl_name(str)) { goto_iden=lbl_iden; if(!is_already_exist_goto_name(str)) { strcpy(&goto_names[nb_goto][0],str); //goto_iden=nb_goto; //printf("\nGoto '%s' added-lbl name matching",str); nb_goto++; } } else { strcpy(&lbl_names[nb_lbl][0],str); lbl_iden=nb_lbl; if(is_debug) printf("\nGoto:Expected Label '%s' added, iden=%d",str,goto_iden); nb_lbl++; if(nb_lbl>NB_LBL_MAX) my_exit("Error:Too much goto"); goto_iden=lbl_iden; if(!is_already_exist_goto_name(str)) { strcpy(&goto_names[nb_goto][0],str); //goto_iden=nb_goto; if(is_debug) printf("\nGoto '%s' added-No lbl name matching",str); nb_goto++; } } } if(*ptr==if_then_tag) { //printf("\nin ifthen, lvl=%d",ifthen_lvl); if(ifthen_lvl>=NB_IMBRICATED_IF_WHILE_FOR_MAX) { sprintf(buf,"Error line %d:Too much imbricated if() then",line); my_exit(buf); } ifthen_blocks_list[ifthen_lvl]=block_i; blocks_list[block_lvl]=block_i; ifthen_lvl++; block_lvl++; block_i++; //printf(" ifthen_lvl=%d",ifthen_lvl); } if(*ptr==endif_tag) { //printf("\nendif, lvl=%d",ifthen_lvl); if(ifthen_lvl==0) { sprintf(buf,"Error line %d:Unexpected endif",line); my_exit(buf); } ifthen_lvl--; block_lvl--; if(blocks_list[block_lvl]!=ifthen_blocks_list[ifthen_lvl]) my_exit("Error:Missing start or end of block syntax"); } if(*ptr==while_tag) { //printf("\nin ifthen, lvl=%d",ifthen_lvl); if(while_lvl>=NB_IMBRICATED_IF_WHILE_FOR_MAX) { sprintf(buf,"Error line %d:Too much imbricated while()",line); my_exit(buf); } while_blocks_list[while_lvl]=block_i; blocks_list[block_lvl]=block_i; while_lvl++; block_lvl++; block_i++; //printf(" ifthen_lvl=%d",ifthen_lvl); } if(*ptr==endwhile_tag) { //printf("\nendif, lvl=%d",ifthen_lvl); if(while_lvl==0) { sprintf(buf,"Error line %d:Unexpected endwhile",line); my_exit(buf); } while_lvl--; block_lvl--; if(blocks_list[block_lvl]!=while_blocks_list[while_lvl]) my_exit("Error:Missing start or end of block syntax"); } if(*ptr==for_tag || *ptr==for_c_tag) { //printf("\nin ifthen, lvl=%d",ifthen_lvl); if(*ptr==for_tag && *(ptr+1)!=user_word_tag) //devra vérifier dans le futur qu'il sagit bien d'une ice var { sprintf(buf,"Error line %d:Syntax expected :for(var,start,end,step)",line); my_exit(buf); } if(for_lvl>=NB_FOR_MAX) { sprintf(buf,"Error line %d:Too much imbricated for()",line); my_exit(buf); } for_blocks_list[for_lvl]=block_i; blocks_list[block_lvl]=block_i; for_lvl++; block_lvl++; block_i++; //printf(" ifthen_lvl=%d",ifthen_lvl); } if(*ptr==endfor_tag) { //printf("\nendif, lvl=%d",ifthen_lvl); if(for_lvl==0) { sprintf(buf,"Error line %d:Unexpected endfor",line); my_exit(buf); } for_lvl--; block_lvl--; if(blocks_list[block_lvl]!=for_blocks_list[for_lvl]) my_exit("Error:Missing start or end of block syntax"); } if(*ptr==break_tag) { if(for_lvl==0 && while_lvl==0) { sprintf(buf,"Error line %d:Unexpected 'break' (outside loop)",line); my_exit(buf); } } ptr=skip_token(ptr); } if(is_last_line) { /*lbl_iden_save=lbl_iden; if(!is_already_exist_lbl_name("MAIN")) { my_exit("Error:Unfounded label MAIN"); } lbl_iden=lbl_iden_save;*/ if(ifthen_lvl>0) { my_exit("Error:Expected endif"); } if(while_lvl>0) { my_exit("Error:Expected endwhile"); } if(for_lvl>0) { my_exit("Error:Expected endfor"); } //print_all_lbl_goto_names(); for(i=0;i0) { for(i=0;i0) { for(i=0;i0) { strcat(buf,temp_buf); for(i=0;i0) { //strcat(buf,temp_buf); for(i=0;i19) my_exit("Error:user func name too long"); strcpy(user_ice_function_list[nb_user_ice_function].user_ice_func_str,fc_str); user_ice_function_list[nb_user_ice_function].func_nbargs=nbargs; nb_user_ice_function++; return nb_user_ice_function-1; } //doit pointer sur user_func_str. Attention argn=1 pour le premier argument (pas 0) unsigned char *get_newprogcx_func_argn_ptr(unsigned char *user_func_tag_ptr,unsigned char nb_arg_total,unsigned char argn) //get argn tag ptr { unsigned char i,v,*ptr; ptr=skip_token(user_func_tag_ptr); //skip user func tag and his str for(i=0;i<(nb_arg_total-argn);i++) { ptr=skip_arg(ptr); } return ptr; } unsigned char *get_user_word_str(unsigned char *user_word_ptr) { user_word_ptr++; //skip user word tag user_word_ptr++; //skip string tag get_uint16(&user_word_ptr); return user_word_ptr; } void set_existing_var_as_list(unsigned char var_iden,unsigned short nb_rows) { newprogcx_var_list_nb_rows_nb_cols[var_iden][0]=nb_rows; //nb rows newprogcx_var_list_nb_rows_nb_cols[var_iden][1]=0; //nb col==0 } void set_existing_var_as_matrix(unsigned char var_iden,unsigned short nb_rows,unsigned short nb_cols) { newprogcx_var_list_nb_rows_nb_cols[var_iden][0]=nb_rows; //nb rows newprogcx_var_list_nb_rows_nb_cols[var_iden][1]=nb_cols; //nb cols } unsigned char *fill_datauc_with_block(unsigned char *src_block_ptr, unsigned int nb_elem) { int i; unsigned char *ptr,*ptr1,buf[100],has_reached_end_of_block; ptr=src_block_ptr; ptr1=skip_arg(ptr); //end of block ptr++; //skip block_tag has_reached_end_of_block=0; printf("\nIn fill datauc, 1er token"); disp_token(ptr); printf("\n nbelem data uc=%d",nb_elem); for(i=0;i=ptr1) has_reached_end_of_block=1; if(!has_reached_end_of_block) { if(!is_number_token_with_opposite(ptr)) { sprintf(buf,"Error line %d:Element of block { } must be a direct number",line); my_exit(buf); } *(unsigned char *)out_ptr=get_value_of_opposite(ptr); // get_value(&ptr); ptr=skip_arg(ptr); //skip value out_ptr++; //ptr=skip_arg(ptr); } else { *(unsigned char *)out_ptr=0; out_ptr++; //ptr=skip_arg(ptr); } } return ptr1+1; } unsigned char *fill_datauc_with_string(unsigned char *src_block_ptr, unsigned int nb_elem) { int i; unsigned char *ptr,*ptr1,buf[100],has_reached_end_of_block; unsigned char *end_str_ptr; ptr=src_block_ptr; //point on string_tag end_str_ptr=skip_token(ptr); ptr++; get_uint16(&ptr); //after this instruction, ptr point on first char has_reached_end_of_block=0; for(i=0;i=end_str_ptr) has_reached_end_of_block=1; if(!has_reached_end_of_block) { *(unsigned char *)out_ptr=*ptr; //get_value_of_opposite(ptr); // get_value(&ptr); ptr++; //ptr=skip_arg(ptr); //skip value out_ptr++; } else { *(unsigned char *)out_ptr=0; out_ptr++; } } return end_str_ptr; } unsigned char *fill_datasc_with_block(unsigned char *src_block_ptr, unsigned int nb_elem) { int i; unsigned char *ptr,*ptr1,buf[100],has_reached_end_of_block; ptr=src_block_ptr; ptr1=skip_arg(ptr); //end of block ptr++; //skip block_tag has_reached_end_of_block=0; //if(is_debug) {printf("\nIn fill datasc, 1er token"); disp_token(ptr);} //if(is_debug) printf("\n nbelem data sc=%d",nb_elem); for(i=0;i=ptr1) has_reached_end_of_block=1; if(!has_reached_end_of_block) { if(!is_number_token_with_opposite(ptr)) { sprintf(buf,"Error line %d:Element of block { } must be a direct number",line); my_exit(buf); } *(signed char *)out_ptr=get_value_of_opposite(ptr); // get_value(&ptr); ptr=skip_arg(ptr); //skip value out_ptr++; //ptr=skip_arg(ptr); } else { *(signed char *)out_ptr=0; out_ptr++; //ptr=skip_arg(ptr); } } return ptr1+1; } /* unsigned char *fill_datasc_with_block(unsigned char *src_block_ptr, unsigned int nb_elem) { int i; unsigned char *ptr,*ptr1,buf[100],has_reached_end_of_block; ptr=src_block_ptr; ptr1=skip_arg(ptr); //end of block ptr++; //skip block_tag has_reached_end_of_block=0; //printf("\nIn fill datauc, 1er token"); disp_token(ptr); for(i=0;i=ptr1) has_reached_end_of_block=1; if(!has_reached_end_of_block) { if(!is_number_token_with_opposite(ptr)) { sprintf(buf,"Error line %d:Element of block { } must be a direct number",line); my_exit(buf); } *(signed char *)out_ptr=get_value_of_opposite(ptr); // get_value(&ptr); ptr=skip_arg(ptr); //skip value out_ptr++; //ptr=skip_arg(ptr); } else { *(signed char *)out_ptr=0; out_ptr++; ptr=skip_arg(ptr); } } return ptr1+1; } */ unsigned char *fill_datasc_with_string(unsigned char *src_block_ptr, unsigned int nb_elem) { int i; unsigned char *ptr,*ptr1,buf[100],has_reached_end_of_block; unsigned char *end_str_ptr; ptr=src_block_ptr; //point on string_tag end_str_ptr=skip_token(ptr); ptr++; get_uint16(&ptr); //after this instruction, ptr point on first char has_reached_end_of_block=0; for(i=0;i=end_str_ptr) has_reached_end_of_block=1; if(!has_reached_end_of_block) { *(signed char *)out_ptr=*ptr; //get_value_of_opposite(ptr); // get_value(&ptr); ptr++; //ptr=skip_arg(ptr); //skip value out_ptr++; } else { *(signed char *)out_ptr=0; out_ptr++; } } return end_str_ptr; } unsigned char *fill_dataus_with_block(unsigned char *src_block_ptr, unsigned int nb_elem) { int i; unsigned char *ptr,*ptr1,buf[100],has_reached_end_of_block; ptr=src_block_ptr; ptr1=skip_arg(ptr); //end of block ptr++; //skip block_tag has_reached_end_of_block=0; //printf("\nIn fill datauc, 1er token"); disp_token(ptr); for(i=0;i=ptr1) has_reached_end_of_block=1; if(!has_reached_end_of_block) { if(!is_number_token_with_opposite(ptr)) { sprintf(buf,"Error line %d:Element of block { } must be a direct number",line); my_exit(buf); } *(unsigned short *)out_ptr=get_value_of_opposite(ptr); // get_value(&ptr); ptr=skip_arg(ptr); //skip value out_ptr+=2; //ptr=skip_arg(ptr); } else { *(unsigned short *)out_ptr=0; out_ptr+=2; ptr=skip_arg(ptr); } } return ptr1+1; } /* unsigned char *fill_data_us_ss_ui_si_with_string(unsigned char *src_block_ptr, unsigned int nb_elem,unsigned char elem_size) //elem_size=2 for short =4 for int { int i,i2; unsigned char *ptr,*ptr1,buf[100],has_reached_end_of_block; unsigned char *end_str_ptr; ptr=src_block_ptr; //point on string_tag end_str_ptr=skip_token(ptr); ptr++; get_uint16(&ptr); //after this instruction, ptr point on first char has_reached_end_of_block=0; for(i=0;i=end_str_ptr) has_reached_end_of_block=1; for(i2=0;i2=end_str_ptr) has_reached_end_of_block=1; if(!has_reached_end_of_block) { *(unsigned char *)out_ptr=*ptr; //get_value_of_opposite(ptr); // get_value(&ptr); ptr++; //ptr=skip_arg(ptr); //skip value out_ptr++; } else { *(unsigned char *)out_ptr=0; out_ptr++; } } } return end_str_ptr; } */ unsigned char *fill_datass_with_block(unsigned char *src_block_ptr, unsigned int nb_elem) { int i; unsigned char *ptr,*ptr1,buf[100],has_reached_end_of_block; ptr=src_block_ptr; ptr1=skip_arg(ptr); //end of block ptr++; //skip block_tag has_reached_end_of_block=0; //printf("\nIn fill datauc, 1er token"); disp_token(ptr); for(i=0;i=ptr1) has_reached_end_of_block=1; if(!has_reached_end_of_block) { if(!is_number_token_with_opposite(ptr)) { sprintf(buf,"Error line %d:Element of block { } must be a direct number",line); my_exit(buf); } *(signed short *)out_ptr=get_value_of_opposite(ptr); // get_value(&ptr); ptr=skip_arg(ptr); //skip value out_ptr+=2; //ptr=skip_arg(ptr); } else { *(signed short *)out_ptr=0; out_ptr+=2; ptr=skip_arg(ptr); } } return ptr1+1; } unsigned char *fill_datasi_with_block(unsigned char *src_block_ptr, unsigned int nb_elem) { int i; unsigned char *ptr,*ptr1,buf[100],has_reached_end_of_block; ptr=src_block_ptr; ptr1=skip_arg(ptr); //end of block ptr++; //skip block_tag has_reached_end_of_block=0; //printf("\nIn fill datauc, 1er token"); disp_token(ptr); for(i=0;i=ptr1) has_reached_end_of_block=1; if(!has_reached_end_of_block) { if(!is_number_token_with_opposite(ptr)) { sprintf(buf,"Error line %d:Element of block { } must be a direct number",line); my_exit(buf); } *(signed int *)out_ptr=get_value_of_opposite(ptr); // get_value(&ptr); ptr=skip_arg(ptr); //skip value out_ptr+=4; //ptr=skip_arg(ptr); } else { *(signed int *)out_ptr=0; out_ptr+=4; ptr=skip_arg(ptr); } } return ptr1+1; } unsigned char *fill_dataui_with_block(unsigned char *src_block_ptr, unsigned int nb_elem) { int i; unsigned char *ptr,*ptr1,buf[100],has_reached_end_of_block; ptr=src_block_ptr; ptr1=skip_arg(ptr); //end of block ptr++; //skip block_tag has_reached_end_of_block=0; //printf("\nIn fill datauc, 1er token"); disp_token(ptr); for(i=0;i=ptr1) has_reached_end_of_block=1; if(!has_reached_end_of_block) { if(!is_number_token_with_opposite(ptr)) { sprintf(buf,"Error line %d:Element of block { } must be a direct number",line); my_exit(buf); } *(unsigned int *)out_ptr=get_value_of_opposite(ptr); // get_value(&ptr); ptr=skip_arg(ptr); //skip value out_ptr+=4; //ptr=skip_arg(ptr); } else { *(unsigned int *)out_ptr=0; out_ptr+=4; ptr=skip_arg(ptr); } } return ptr1+1; } unsigned char *compile_uc_data_tag(unsigned char *ptr) { unsigned char *str,fc_nbargs,nbargs_found,*ptr1,*ptr2,*word_ptr,is_local_temp,temp; char buf[100],buf1[500],buf2[500],buf3[500],buf4[500],buf5[500],buf6[500]; unsigned short i,v1,i2,i3; int i_var,va,vb,vc,vd; signed short var_iden; ptr++; //printf("\nin compile uc 1"); if(*ptr!=lelem_tag) my_exit("Error:Syntax expected data** list_mat_name[R]'[C]'"); ptr++; //printf("\nin compile uc 2"); word_ptr=get_user_word_str(ptr); ptr=skip_arg(ptr); //pass the name of the list or matrix, so point on the degree i=get_value_no_isz(ptr); //degree 1=list 2=mat //printf("\nin compile uc 3"); ptr=skip_arg(ptr); //skip degree, now point on row value if(!is_number_token(ptr)) { sprintf(buf,"Error line %d:With '%s[rows]' rows must be a direct number",line,word_ptr); my_exit(buf); } va=get_value_no_isz(ptr); //nb rows //printf("\nin compile uc 4"); ptr=skip_arg(ptr); if(i==2) { if(!is_number_token(ptr)) { sprintf(buf,"Error line %d:With '%s[rows][cols]' rows and cols must be a direct numbers",line,word_ptr); my_exit(buf); } vb=get_value_no_isz(ptr); //nb columns ptr=skip_arg(ptr); //skip nb columns } else vb=1; //printf("\nfirst [] va=%d, vb=%d",va,vb); keywait(); //printf("\nin compile uc 5"); if(is_existing_newprogcx_var_str(word_ptr)) //classical var or list or matrix var { sprintf(buf,"Error line %d:can't create list or matrix. '%s' name already exist",line,word_ptr); my_exit(buf); } else //not exist, so create { i_var=create_newprogcx_var_and_return_iden(word_ptr); newprogcx_var_type_of_data_list[i_var]=1; //uc if(i==1) set_existing_var_as_list(i_var,va); else set_existing_var_as_matrix(i_var,va,vb); } //printf("\nin compile uc 6"); ptr1=out_ptr; *out_ptr=41; out_ptr++; //deffdata //printf("\nin compile uc 6-1"); //push_num_output_with_isz_68k(65000); //temporary, for total length - 2 bytes long *out_ptr=255; out_ptr++; //byte 1, temp *out_ptr=255; out_ptr++; //byte 2, temp *out_ptr=6; out_ptr++; //var tag //printf("\nin compile uc 6-2"); *out_ptr=i_var; out_ptr++; push_num_output_with_isz_68k(i); //degree newprogcx_var_type_of_data_list[i_var]=1; //printf("\nin compile uc 6-3"); if(va>0xffff || vb>0xffff) { sprintf(buf1,"Error line %d:With list and matrix, number of rows or columns are limited to 65536",line); my_exit(buf1); } //printf("\nin compile uc 6-4, va=%d vb=%d",va,vb); push_num_output_with_isz_68k(va); //nb rows push_num_output_with_isz_68k(vb); //nb cols, so null if list //printf("\nin compile uc 7"); if(!is_void_data) //add datas { //printf("\nin compile uc 7-1"); if(is_debug) printf("\nNot void datauc"); //printf("\nis add data=%d",( (4-(int)out_ptr%4)%4 )); keywait(); //printf("\nin compile uc 7-2"); out_ptr+=( (4-(int)out_ptr%4)%4 ); //printf("\nin compile uc 7-3"); ptr++; //skip end_tag if(*ptr==block_tag) { //printf("\nin compile uc 7-4"); ptr=fill_datauc_with_block(ptr,va*vb); //printf("\nin compile uc 7-5"); } else { //printf("\nin compile uc 7-6"); if(*ptr==string_tag) { if(is_debug) printf("\nis a string of data"); ptr=fill_datauc_with_string(ptr,va*vb); } else { sprintf(buf,"Error line %d:datauc must be filled with { }",line); my_exit(buf); } } //printf("\nin compile uc 7-7"); *(unsigned short *)(ptr1+1)=out_ptr-ptr1; } else *(unsigned short *)(ptr1+1)=out_ptr-ptr1; //printf("\nin compile uc 8"); is_void_data=0; return ptr; } unsigned char *compile_sc_data_tag(unsigned char *ptr) { unsigned char *str,fc_nbargs,nbargs_found,*ptr1,*ptr2,*word_ptr,is_local_temp,temp; char buf[100],buf1[500],buf2[500],buf3[500],buf4[500],buf5[500],buf6[500]; unsigned short i,v1,i2,i3; int i_var,va,vb,vc,vd; signed short var_iden; ptr++; if(*ptr!=lelem_tag) my_exit("Error:Syntax expected data** list_mat_name[R]'[C]'"); ptr++; word_ptr=get_user_word_str(ptr); ptr=skip_arg(ptr); //pass the name of the list or matrix, so point on the degree i=get_value_no_isz(ptr); //degree 1=list 2=mat ptr=skip_arg(ptr); //skip degree, now point on row value if(!is_number_token(ptr)) { sprintf(buf,"Error line %d:With '%s[rows]' rows must be a direct number",line,word_ptr); my_exit(buf); } va=get_value_no_isz(ptr); //nb rows ptr=skip_arg(ptr); if(i==2) { if(!is_number_token(ptr)) { sprintf(buf,"Error line %d:With '%s[rows][cols]' rows and cols must be a direct numbers",line,word_ptr); my_exit(buf); } vb=get_value_no_isz(ptr); //nb columns ptr=skip_arg(ptr); //skip nb columns } else vb=1; //printf("\nfirst [] va=%d, vb=%d",va,vb); keywait(); if(is_existing_newprogcx_var_str(word_ptr)) //classical var or list or matrix var { sprintf(buf,"Error line %d:can't create list or matrix. '%s' name already exist",line,word_ptr); my_exit(buf); } else //not exist, so create { i_var=create_newprogcx_var_and_return_iden(word_ptr); newprogcx_var_type_of_data_list[i_var]=11; //sc if(i==1) set_existing_var_as_list(i_var,va); else set_existing_var_as_matrix(i_var,va,vb); } ptr1=out_ptr; *out_ptr=131; out_ptr++; //deffdata //push_num_output_with_isz_68k(65000); //temporary, for total length - 2 bytes long *out_ptr=255; out_ptr++; //byte 1, temp *out_ptr=255; out_ptr++; //byte 2, temp *out_ptr=6; out_ptr++; //var tag *out_ptr=i_var; out_ptr++; push_num_output_with_isz_68k(i); //degree newprogcx_var_type_of_data_list[i_var]=11; if(va>0xffff || vb>0xffff) { sprintf(buf1,"Error line %d:With list and matrix, number of rows or columns are limited to 65536",line); my_exit(buf1); } push_num_output_with_isz_68k(va); //nb rows push_num_output_with_isz_68k(vb); //nb cols, so null if list if(!is_void_data) //add datas { if(is_debug) printf("\nNot void datasc"); //printf("\nis add data=%d",( (4-(int)out_ptr%4)%4 )); keywait(); out_ptr+=( (4-(int)out_ptr%4)%4 ); ptr++; //skip end_tag if(*ptr==block_tag) ptr=fill_datasc_with_block(ptr,va*vb); else { if(*ptr==string_tag) { if(is_debug) printf("\nis a string of data"); ptr=fill_datasc_with_string(ptr,va*vb); } else { sprintf(buf,"Error line %d:datauc must be filled with { }",line); my_exit(buf); } } *(unsigned short *)(ptr1+1)=out_ptr-ptr1; } else *(unsigned short *)(ptr1+1)=out_ptr-ptr1; is_void_data=0; return ptr; } /* unsigned char *compile_sc_data_tag(unsigned char *ptr) { unsigned char *str,fc_nbargs,nbargs_found,*ptr1,*ptr2,*word_ptr,is_local_temp,temp; char buf[100],buf1[500],buf2[500],buf3[500],buf4[500],buf5[500],buf6[500]; unsigned short i,v1,i2,i3; int i_var,va,vb,vc,vd; signed short var_iden; ptr++; if(*ptr!=lelem_tag) my_exit("Error:Syntax expected data** list_mat_name[R]'[C]'"); ptr++; word_ptr=get_user_word_str(ptr); ptr=skip_arg(ptr); //pass the name of the list or matrix, so point on the degree i=get_value_no_isz(ptr); //degree 1=list 2=mat ptr=skip_arg(ptr); //skip degree, now point on row value if(!is_number_token(ptr)) { sprintf(buf,"Error line %d:With '%s[rows]' rows must be a direct number",line,word_ptr); my_exit(buf); } va=get_value_no_isz(ptr); //nb rows ptr=skip_arg(ptr); if(i==2) { if(!is_number_token(ptr)) { sprintf(buf,"Error line %d:With '%s[rows][cols]' rows and cols must be a direct numbers",line,word_ptr); my_exit(buf); } vb=get_value_no_isz(ptr); //nb columns ptr=skip_arg(ptr); //skip nb columns } else vb=1; if(is_existing_newprogcx_var_str(word_ptr)) //classical var or list or matrix var { sprintf(buf,"Error line %d:can't create list or matrix. '%s' name already exist",line,word_ptr); my_exit(buf); } else //not exist, so create { i_var=create_newprogcx_var_and_return_iden(word_ptr); newprogcx_var_type_of_data_list[i_var]=11; //sc if(i==1) set_existing_var_as_list(i_var,va); else set_existing_var_as_matrix(i_var,va,vb); } ptr1=out_ptr; *out_ptr=131; out_ptr++; //deffdatasc //push_num_output_with_isz_68k(65000); //temporary, for total length - 2 bytes long *out_ptr=255; out_ptr++; //byte 1, temp *out_ptr=255; out_ptr++; //byte 2, temp *out_ptr=6; out_ptr++; //var tag *out_ptr=i_var; out_ptr++; push_num_output_with_isz_68k(i); //degree newprogcx_var_type_of_data_list[i_var]=11; if(va>0xffff || vb>0xffff) { sprintf(buf1,"Error line %d:With list and matrix, number of rows or columns are limited to 65536",line); my_exit(buf1); } push_num_output_with_isz_68k(va); //nb rows push_num_output_with_isz_68k(vb); //nb cols, so null if list if(!is_void_data) //add datas { //printf("\nNot void datasc"); out_ptr+=( (4-(int)out_ptr%4)%4 ); ptr++; //skip end_tag if(*ptr==block_tag) ptr=fill_datasc_with_block(ptr,va*vb); else { //from here if(*ptr==string_tag) { if(is_debug) printf("\nis a string of data"); ptr=fill_datasc_with_string(ptr,va*vb); } else { sprintf(buf,"Error line %d:datasc must be filled with { }",line); my_exit(buf); } } *(unsigned short *)(ptr1+1)=out_ptr-ptr1; } else *(unsigned short *)(ptr1+1)=out_ptr-ptr1; is_void_data=0; return ptr; } */ unsigned char *compile_us_data_tag(unsigned char *ptr) { unsigned char *str,fc_nbargs,nbargs_found,*ptr1,*ptr2,*word_ptr,is_local_temp,temp; char buf[100],buf1[500],buf2[500],buf3[500],buf4[500],buf5[500],buf6[500]; unsigned short i,v1,i2,i3; int i_var,va,vb,vc,vd; signed short var_iden; ptr++; if(*ptr!=lelem_tag) my_exit("Error:Syntax expected data** list_mat_name[R]'[C]'"); ptr++; word_ptr=get_user_word_str(ptr); ptr=skip_arg(ptr); //pass the name of the list or matrix, so point on the degree i=get_value_no_isz(ptr); //degree 1=list 2=mat ptr=skip_arg(ptr); //skip degree, now point on row value if(!is_number_token(ptr)) { sprintf(buf,"Error line %d:With '%s[rows]' rows must be a direct number",line,word_ptr); my_exit(buf); } va=get_value_no_isz(ptr); //nb rows ptr=skip_arg(ptr); if(i==2) { if(!is_number_token(ptr)) { sprintf(buf,"Error line %d:With '%s[rows][cols]' rows and cols must be a direct numbers",line,word_ptr); my_exit(buf); } vb=get_value_no_isz(ptr); //nb columns ptr=skip_arg(ptr); //skip nb columns } else vb=1; if(is_existing_newprogcx_var_str(word_ptr)) //classical var or list or matrix var { sprintf(buf,"Error line %d:can't create list or matrix. '%s' name already exist",line,word_ptr); my_exit(buf); } else //not exist, so create { i_var=create_newprogcx_var_and_return_iden(word_ptr); newprogcx_var_type_of_data_list[i_var]=2; //ss if(i==1) set_existing_var_as_list(i_var,va); else set_existing_var_as_matrix(i_var,va,vb); } ptr1=out_ptr; *out_ptr=132; out_ptr++; //deffdataus //push_num_output_with_isz_68k(65000); //temporary, for total length - 2 bytes long *out_ptr=255; out_ptr++; //byte 1, temp *out_ptr=255; out_ptr++; //byte 2, temp *out_ptr=6; out_ptr++; //var tag *out_ptr=i_var; out_ptr++; push_num_output_with_isz_68k(i); //degree newprogcx_var_type_of_data_list[i_var]=2; if(va>0xffff || vb>0xffff) { sprintf(buf1,"Error line %d:With list and matrix, number of rows or columns are limited to 65536",line); my_exit(buf1); } push_num_output_with_isz_68k(va); //nb rows push_num_output_with_isz_68k(vb); //nb cols, so null if list if(!is_void_data) //add datas { //printf("\nNot void datasc"); out_ptr+=( (4-(int)out_ptr%4)%4 ); ptr++; //skip end_tag if(*ptr==block_tag) ptr=fill_dataus_with_block(ptr,va*vb); else { sprintf(buf,"Error line %d:dataus must be filled with { }",line); my_exit(buf); } *(unsigned short *)(ptr1+1)=out_ptr-ptr1; } else *(unsigned short *)(ptr1+1)=out_ptr-ptr1; is_void_data=0; return ptr; } unsigned char *compile_ss_data_tag(unsigned char *ptr) { unsigned char *str,fc_nbargs,nbargs_found,*ptr1,*ptr2,*word_ptr,is_local_temp,temp; char buf[100],buf1[500],buf2[500],buf3[500],buf4[500],buf5[500],buf6[500]; unsigned short i,v1,i2,i3; int i_var,va,vb,vc,vd; signed short var_iden; ptr++; if(*ptr!=lelem_tag) my_exit("Error:Syntax expected data** list_mat_name[R]'[C]'"); ptr++; word_ptr=get_user_word_str(ptr); ptr=skip_arg(ptr); //pass the name of the list or matrix, so point on the degree i=get_value_no_isz(ptr); //degree 1=list 2=mat ptr=skip_arg(ptr); //skip degree, now point on row value if(!is_number_token(ptr)) { sprintf(buf,"Error line %d:With '%s[rows]' rows must be a direct number",line,word_ptr); my_exit(buf); } va=get_value_no_isz(ptr); //nb rows ptr=skip_arg(ptr); if(i==2) { if(!is_number_token(ptr)) { sprintf(buf,"Error line %d:With '%s[rows][cols]' rows and cols must be a direct numbers",line,word_ptr); my_exit(buf); } vb=get_value_no_isz(ptr); //nb columns ptr=skip_arg(ptr); //skip nb columns } else vb=1; if(is_existing_newprogcx_var_str(word_ptr)) //classical var or list or matrix var { sprintf(buf,"Error line %d:can't create list or matrix. '%s' name already exist",line,word_ptr); my_exit(buf); } else //not exist, so create { i_var=create_newprogcx_var_and_return_iden(word_ptr); newprogcx_var_type_of_data_list[i_var]=22; //sc if(i==1) set_existing_var_as_list(i_var,va); else set_existing_var_as_matrix(i_var,va,vb); } ptr1=out_ptr; *out_ptr=133; out_ptr++; //push_num_output_with_isz_68k(65000); //temporary, for total length - 2 bytes long *out_ptr=255; out_ptr++; //byte 1, temp *out_ptr=255; out_ptr++; //byte 2, temp *out_ptr=6; out_ptr++; //var tag *out_ptr=i_var; out_ptr++; push_num_output_with_isz_68k(i); //degree newprogcx_var_type_of_data_list[i_var]=22; if(va>0xffff || vb>0xffff) { sprintf(buf1,"Error line %d:With list and matrix, number of rows or columns are limited to 65536",line); my_exit(buf1); } push_num_output_with_isz_68k(va); //nb rows push_num_output_with_isz_68k(vb); //nb cols, so null if list if(!is_void_data) //add datas { //printf("\nNot void datasc"); out_ptr+=( (4-(int)out_ptr%4)%4 ); ptr++; //skip end_tag if(*ptr==block_tag) ptr=fill_datass_with_block(ptr,va*vb); else { sprintf(buf,"Error line %d:datass must be filled with { }",line); my_exit(buf); } *(unsigned short *)(ptr1+1)=out_ptr-ptr1; } else *(unsigned short *)(ptr1+1)=out_ptr-ptr1; is_void_data=0; return ptr; } unsigned char *compile_ui_data_tag(unsigned char *ptr) { unsigned char *str,fc_nbargs,nbargs_found,*ptr1,*ptr2,*word_ptr,is_local_temp,temp; char buf[100],buf1[500],buf2[500],buf3[500],buf4[500],buf5[500],buf6[500]; unsigned short i,v1,i2,i3; int i_var,va,vb,vc,vd; signed short var_iden; ptr++; if(*ptr!=lelem_tag) my_exit("Error:Syntax expected data** list_mat_name[R]'[C]'"); ptr++; word_ptr=get_user_word_str(ptr); ptr=skip_arg(ptr); //pass the name of the list or matrix, so point on the degree i=get_value_no_isz(ptr); //degree 1=list 2=mat ptr=skip_arg(ptr); //skip degree, now point on row value if(!is_number_token(ptr)) { sprintf(buf,"Error line %d:With '%s[rows]' rows must be a direct number",line,word_ptr); my_exit(buf); } va=get_value_no_isz(ptr); //nb rows ptr=skip_arg(ptr); if(i==2) { if(!is_number_token(ptr)) { sprintf(buf,"Error line %d:With '%s[rows][cols]' rows and cols must be a direct numbers",line,word_ptr); my_exit(buf); } vb=get_value_no_isz(ptr); //nb columns ptr=skip_arg(ptr); //skip nb columns } else vb=1; if(is_existing_newprogcx_var_str(word_ptr)) //classical var or list or matrix var { sprintf(buf,"Error line %d:can't create list or matrix. '%s' name already exist",line,word_ptr); my_exit(buf); } else //not exist, so create { i_var=create_newprogcx_var_and_return_iden(word_ptr); newprogcx_var_type_of_data_list[i_var]=4; //ss if(i==1) set_existing_var_as_list(i_var,va); else set_existing_var_as_matrix(i_var,va,vb); } ptr1=out_ptr; *out_ptr=134; out_ptr++; //deffdataus //push_num_output_with_isz_68k(65000); //temporary, for total length - 2 bytes long *out_ptr=255; out_ptr++; //byte 1, temp *out_ptr=255; out_ptr++; //byte 2, temp *out_ptr=6; out_ptr++; //var tag *out_ptr=i_var; out_ptr++; push_num_output_with_isz_68k(i); //degree newprogcx_var_type_of_data_list[i_var]=4; if(va>0xffff || vb>0xffff) { sprintf(buf1,"Error line %d:With list and matrix, number of rows or columns are limited to 65536",line); my_exit(buf1); } push_num_output_with_isz_68k(va); //nb rows push_num_output_with_isz_68k(vb); //nb cols, so null if list if(!is_void_data) //add datas { //printf("\nNot void datasc"); out_ptr+=( (4-(int)out_ptr%4)%4 ); ptr++; //skip end_tag if(*ptr==block_tag) ptr=fill_dataui_with_block(ptr,va*vb); else { sprintf(buf,"Error line %d:dataui must be filled with { }",line); my_exit(buf); } *(unsigned short *)(ptr1+1)=out_ptr-ptr1; } else *(unsigned short *)(ptr1+1)=out_ptr-ptr1; is_void_data=0; return ptr; } unsigned char *compile_si_data_tag(unsigned char *ptr) { unsigned char *str,fc_nbargs,nbargs_found,*ptr1,*ptr2,*word_ptr,is_local_temp,temp; char buf[100],buf1[500],buf2[500],buf3[500],buf4[500],buf5[500],buf6[500]; unsigned short i,v1,i2,i3; int i_var,va,vb,vc,vd; signed short var_iden; ptr++; if(*ptr!=lelem_tag) my_exit("Error:Syntax expected data** list_mat_name[R]'[C]'"); ptr++; word_ptr=get_user_word_str(ptr); ptr=skip_arg(ptr); //pass the name of the list or matrix, so point on the degree i=get_value_no_isz(ptr); //degree 1=list 2=mat ptr=skip_arg(ptr); //skip degree, now point on row value if(!is_number_token(ptr)) { sprintf(buf,"Error line %d:With '%s[rows]' rows must be a direct number",line,word_ptr); my_exit(buf); } va=get_value_no_isz(ptr); //nb rows ptr=skip_arg(ptr); if(i==2) { if(!is_number_token(ptr)) { sprintf(buf,"Error line %d:With '%s[rows][cols]' rows and cols must be a direct numbers",line,word_ptr); my_exit(buf); } vb=get_value_no_isz(ptr); //nb columns ptr=skip_arg(ptr); //skip nb columns } else vb=1; if(is_existing_newprogcx_var_str(word_ptr)) //classical var or list or matrix var { sprintf(buf,"Error line %d:can't create list or matrix. '%s' name already exist",line,word_ptr); my_exit(buf); } else //not exist, so create { i_var=create_newprogcx_var_and_return_iden(word_ptr); newprogcx_var_type_of_data_list[i_var]=44; //sc if(i==1) set_existing_var_as_list(i_var,va); else set_existing_var_as_matrix(i_var,va,vb); } ptr1=out_ptr; *out_ptr=135; out_ptr++; //push_num_output_with_isz_68k(65000); //temporary, for total length - 2 bytes long *out_ptr=255; out_ptr++; //byte 1, temp *out_ptr=255; out_ptr++; //byte 2, temp *out_ptr=6; out_ptr++; //var tag *out_ptr=i_var; out_ptr++; push_num_output_with_isz_68k(i); //degree newprogcx_var_type_of_data_list[i_var]=44; if(va>0xffff || vb>0xffff) { sprintf(buf1,"Error line %d:With list and matrix, number of rows or columns are limited to 65536",line); my_exit(buf1); } push_num_output_with_isz_68k(va); //nb rows push_num_output_with_isz_68k(vb); //nb cols, so null if list if(!is_void_data) //add datas { //printf("\nNot void datasc"); out_ptr+=( (4-(int)out_ptr%4)%4 ); ptr++; //skip end_tag if(*ptr==block_tag) ptr=fill_datasi_with_block(ptr,va*vb); else { sprintf(buf,"Error line %d:datasi must be filled with { }",line); my_exit(buf); } *(unsigned short *)(ptr1+1)=out_ptr-ptr1; } else *(unsigned short *)(ptr1+1)=out_ptr-ptr1; is_void_data=0; return ptr; } unsigned char *compile_arg(unsigned char *ptr) { unsigned char *str,fc_nbargs,nbargs_found,*ptr1,*ptr2,*ptr3,*word_ptr,is_local_temp,temp; char buf[100],buf1[500],buf2[500],buf3[500],buf4[500],buf5[500],buf6[500]; unsigned short i,v1,i2,i3; int i_var,va,vb,vc,vd; signed short var_iden; if(ptr==output_parser_tokens) depth_iden=0; //si début de ligne fc_nbargs=get_nb_args(ptr); temp=*ptr; if(is_debug) {printf("\n\nIn compile arg, token="); disp_token(ptr);/* printf(" Lbl_iden=%d",lbl_iden);*/} switch(*ptr) { case set_rect_n_tag: ptr++; *out_ptr=91; out_ptr++; ptr=compile_arg(ptr); //skip rect iden //ptr1=ptr; v1=get_nb_args(ptr); //nb elem in block if(*ptr!=block_tag || v1!=4) { sprintf(buf,"Error line %d:Syntax expected setrectn(iden,{x,y,w,h})",line); my_exit(buf); } ptr=compile_arg(ptr); //compile block if(*ptr==end_tag) ptr++; //skip end_tag break; case local_tag: //fc_id=i; fc_nba=nbargs_found; args_var_iden_list[iden][n] if(!is_in_func_newprogcx) { sprintf(buf,"Error line %d:'local(...)' must be in a function body",line); my_exit(buf); } *out_ptr=74; out_ptr++; v1=get_nb_args(ptr); //nb elem in local() ptr++; if(v1>10) { sprintf(buf,"Error line %d:Too many locals vars",line); my_exit(buf); } push_num_output_with_isz_68k(v1); ptr1=out_ptr; //point to the first arg for(i=0;i=1) { sprintf(buf1,"Error line %d:Can't define a function in a function",line); my_exit(buf1); } if(*ptr!=user_func_tag) { sprintf(buf1,"Error line %d:func fcname(...) syntax expected",line); my_exit(buf1); } //printf("\nIn func_tag compile str=%s",ptr+4); if(get_simple_ice_function_iden(ptr+5)!=9999) //so is a reserved func str { sprintf(buf1,"Error line %d:func fcname(...), reserved fcname '%s'",line,ptr+5); my_exit(buf1); } str=ptr+5; //fc name str ptr++; //skip user_func_tag . point now on fc_str_token ptr=skip_token(ptr); //point on arg now nbargs_found=get_nb_args(ptr1+1); //printf("\nin compile func fc, argn=%i",nbargs_found); //if(is_debug) printf("\nNewprogcx func %s nbargs %d",str,nbargs_found); if(is_existing_func_newprogcx(str)) { sprintf(buf,"Error line %d:Already existing func %s",line,str); my_exit(buf); } else { i=create_func_newprogcx_and_get_iden(str,nbargs_found);; if(is_debug) printf("\nafter create func, fc iden i=%d",i); } *out_ptr=81; out_ptr++; push_num_output_with_isz_68k( i ); //fc iden //sert dans local (s il y a) pour voir si il n'y a pas des doublons fc_id=i; fc_nba=nbargs_found; //for eventual 'local()' ; fc_id=i; fc_nba=nbargs_found; args_var_iden_list[iden][n] argsn_var_iden_list argsn_var_iden_list[fc_id]=nbargs_found; //printf("\nin func, nb=%d",nb_func_newprogcx-1); push_num_output_with_isz_68k(nbargs_found); //moi ptr2=out_ptr; //if(is_debug) printf("\n in compilearg, finc_tag 1"); for(i2=1;i2<=nbargs_found;i2++) { if(*ptr!=user_word_tag) { sprintf(buf,"Error line %d:With func fcname(arg1,...), arg* must be a var",line); my_exit(buf); } compile_arg(get_newprogcx_func_argn_ptr(ptr-1,nbargs_found,/*nbargs_found+1-i2*/i2)); //,i2) //compile all arsg } ptr=ptr3; //point to the end of func fc(arg1,....) 13/07/2023 //out_ptr=ptr2; //coté le 13/07/2023 //if(is_debug) printf("\n in compilearg, finc_tag 2"); //signed char args_var_iden_list[100][16]; //unsigned char fc_id,fc_nba,argsn_var_iden_list[100]; //nbargs list //For verify if all args name are differents for(i2=0;i28) my_exit("Error:ASM output name too long"); strtoupper_specified_max_len(ASM_dest_name_str,word_ptr,19); //sprintf(buf1,"%c%s",0xD7,strtoupper(buf,"MAIN")); //goto main //sprintf(big_buf,"%c%s%c%s%c",imaginaire_i_str[0],ASM_dest_name_str,0x3F,buf1,0x3F); /* sprintf(buf1,"%c%s",0xD7,strtoupper(buf,"MAIN")); //goto main put_str_no_0_to_ice(buf1); putc_ice_prgm(0x3F); //end of line return */ break; case int8_tag: //push_int8_ice_prgm(get_value(&ptr)); //break; case uint8_tag: //push_uint8_ice_prgm(get_value(&ptr)); //break; case int16_tag: //push_int16_ice_prgm(get_value(&ptr)); //break; case uint16_tag: //push_uint16_ice_prgm(get_value(&ptr)); //break; case int24_tag: //push_int24_ice_prgm(get_value(&ptr)); //break; case uint24_tag: //push_uint24_ice_prgm(get_value(&ptr)); //break; case int32_tag: // push_int32_ice_prgm(get_value(&ptr)); // break; case uint32_tag: //push_uint32_ice_prgm(get_value(&ptr)); push_num_output_with_isz_68k(get_value(&ptr)); //sprintf(big_buf,"%ld",get_value(&ptr)); //put_str_no_0_to_ice(buf); break; /*case ice_func_tag: //ice programmer usr func ptr=skip_arg(ptr); break;*/ case lbl_tag: //printf("\n lbl name=%s",ptr+6); *out_ptr=11; out_ptr++; *out_ptr=0; out_ptr++; *out_ptr=lbl_iden; out_ptr++; //Below : for lbl and goto in same block //lbl_block_newprogcx_list[lbl_iden]=blocks_newprogcx_list[blocks_newprogcx_level]; //sprintf(big_buf,"%c%s",0xD6,strtoupper(buf,ptr+6)); //printf("\nin lbl_tag compile - 1"); ptr=skip_arg(ptr); //printf("\ntoken after="); disp_token(ptr); //printf("\nin lbl_tag compile - 2"); keywait(); break; case goto_tag: *out_ptr=12; out_ptr++; *out_ptr=0; out_ptr++; *out_ptr=lbl_iden; out_ptr++; ptr=skip_arg(ptr); //ptr=skip_token(ptr+2); break; case call_tag: sprintf(big_buf,"%c%c%s",0x62,0x0B,strtoupper_specified_max_len(buf,ptr+6,30)); ptr=skip_arg(ptr); //ptr=skip_token(ptr+2); break; /* case string_tag: ptr++; temp=get_uint16(&ptr); //printf("%c<>",*ptr); printf("STRING_TAG[%d]",temp-1); printf("-%s ",ptr); //2 lines for ti83 ptr+=temp; //continue; break; */ case notl_tag: ptr++; *out_ptr=200; out_ptr++; ptr=compile_arg(ptr); break; case mod_tag: ptr++; *out_ptr=149; out_ptr++; ptr=compile_arg(ptr); ptr=compile_arg(ptr); break; case andb_tag: ptr++; *out_ptr=201; out_ptr++; ptr=compile_arg(ptr); ptr=compile_arg(ptr); break; break; case orb_tag: ptr++; *out_ptr=202; out_ptr++; ptr=compile_arg(ptr); ptr=compile_arg(ptr); break; case xorb_tag: ptr=compile_inverted_middle_op_size1(ptr,0x7F); break; case andl_tag: ptr++; *out_ptr=109; out_ptr++; ptr=compile_arg(ptr); ptr=compile_arg(ptr); break; case orl_tag: ptr++; *out_ptr=119; out_ptr++; ptr=compile_arg(ptr); ptr=compile_arg(ptr); break; case xorl_tag: ptr=compile_inverted_middle_op_size1(ptr,0x3D); break; case inf_equ_tag: ptr++; *out_ptr=49; out_ptr++; ptr=compile_arg(ptr); ptr=compile_arg(ptr); break; case inf_tag: ptr++; *out_ptr=29; out_ptr++; ptr=compile_arg(ptr); ptr=compile_arg(ptr); break; case sup_equ_tag: ptr++; *out_ptr=59; out_ptr++; ptr=compile_arg(ptr); ptr=compile_arg(ptr); break; case sup_tag: ptr++; *out_ptr=39; out_ptr++; ptr=compile_arg(ptr); ptr=compile_arg(ptr); //ptr=compile_inverted_middle_op_size1(ptr,0x6C); break; case nequ_tag: ptr++; *out_ptr=19; out_ptr++; ptr=compile_arg(ptr); ptr=compile_arg(ptr); break; case equ_tag: ptr++; *out_ptr=9; out_ptr++; ptr=compile_arg(ptr); ptr=compile_arg(ptr); //ptr=compile_inverted_middle_op_size1(ptr,0x6A); break; case rollr_tag: ptr++; *out_ptr=129; out_ptr++; ptr=compile_arg(ptr); ptr=compile_arg(ptr); break; case rolll_tag: ptr++; *out_ptr=139; out_ptr++; ptr=compile_arg(ptr); ptr=compile_arg(ptr); break; case add_tag: ptr++; *out_ptr=8; out_ptr++; ptr=compile_arg(ptr); ptr=compile_arg(ptr); break; case sub_tag: ptr++; *out_ptr=18; out_ptr++; ptr=compile_arg(ptr); ptr=compile_arg(ptr); break; case mul_tag: ptr++; va=0; vb=0; ptr1=ptr; if(*ptr==uint8_tag || *ptr==uint16_tag || *ptr==uint32_tag ||*ptr==int8_tag || *ptr==int16_tag || *ptr==int32_tag) //if opposé { va=get_value(&ptr); if(*ptr==int8_tag) { vb=get_value(&ptr); if(vb==-1) { if(is_debug) printf("An opposite num=%d",va*vb); push_num_output_with_isz_68k(vb*va); } } } if(vb!=-1) //so not an opposate { ptr=ptr1; *out_ptr=28; out_ptr++; ptr=compile_arg(ptr); ptr=compile_arg(ptr); } break; case div_tag: ptr++; *out_ptr=38; out_ptr++; ptr=compile_arg(ptr); ptr=compile_arg(ptr); break; case continue_tag: if(for_index==0 && while_index==0) { sprintf(buf,"Error line %d:Continue is not in a loop",line); my_exit(buf); } ptr++; *out_ptr=25; out_ptr++; break; case break_tag: ptr++; *out_ptr=15; out_ptr++; break; //putc_ice_prgm(break_tag); break; case if_then_tag: //printf("\nla1"); //printf("\nla2"); //ptr++; //skip _( ptr++; //unsigned char if_then_i_list_newprogcx[100],if_then_iden_newprogcx,if_then_level_newprogcx; if(if_then_level_newprogcx>NB_IMBRICATED_IF_WHILE_FOR_MAX) my_exit("Error:Too much imbricated if() then:endif"); if(if_then_iden_newprogcx>=255) my_exit("Error:Too much if() then:endif"); if_then_i_list_newprogcx[if_then_level_newprogcx]=if_then_iden_newprogcx; if_then_iden_newprogcx++; *out_ptr=23; //if then tag out_ptr++; //if_then_queue[if_then_index]=if_then_index; if_then_index++; *out_ptr=if_then_iden_newprogcx-1; if_then_level_newprogcx++; out_ptr++; ptr=compile_arg(ptr); //compile condition if(*ptr==end_tag) ptr++; //ptr=compile_front_op_size1(ptr,0xCE); //ptr++; //skip endcmd_tag //put_str_no_0_to_ice(big_buf); //putc_ice_prgm(0x3F); //end of line return //sprintf(big_buf,"%c",0xCF); //then break; case else_tag: ptr++; *out_ptr=33; out_ptr++; *out_ptr=if_then_i_list_newprogcx[if_then_level_newprogcx-1]; out_ptr++; //sprintf(big_buf,"%c",0xD0); //push_uint8_ice_prgm(if_then_queue[if_then_index]); break; case endif_tag: ptr++; *out_ptr=43; out_ptr++; //*out_ptr=if_then_queue[if_then_index]; out_ptr++; if(is_debug) if(if_then_level_newprogcx==0) my_exit("Internal error endif;"); *out_ptr=if_then_i_list_newprogcx[if_then_level_newprogcx-1]; out_ptr++; if_then_level_newprogcx--; //sprintf(big_buf,"%c",0xD4); /* ptr++; putc_ice_prgm(endif_tag); push_uint8_ice_prgm(if_then_queue[if_then_index]); */ //if_then_index--; break; case while_tag: ptr++; //putc_ice_prgm(while_tag); //push_uint8_ice_prgm(nb_while); //is_in_while_cond=1; while_index++; //enter_new_block_newprogcx(); if(while_index>7) my_exit("Error:Too much imbricated while()"); while_queue[while_index]=nb_while; nb_while++; if(nb_while>=NB_FOR_MAX) { sprintf(buf,"Error line %d:Too much 'while'",line); my_exit(buf); } *out_ptr=34; out_ptr++; *out_ptr=nb_while-1; out_ptr++; ptr=compile_arg(ptr); //strcpy(buf2,big_buf); //sprintf(big_buf,"%c%s",0xD1,buf2); //if(strlen(big_buf)>49) my_exit("Error:while(cond) with cond too long"); //sprintf(buf2,"%s%sWC%c",big_buf,sto_arrow_str,'A'+while_index-1); //strcpy(&while_cond_list[while_index-1][0],buf2); //strcpy(buf1,big_buf); //put_str_no_0_to_ice(&while_cond_list[while_index-1][0]); //putc_ice_prgm(0x3F); //end of line return //sprintf(big_buf,"%cWC%c",0xD1,'A'+while_index-1); if(*ptr==end_tag) ptr++; //skip end_tag //is_in_while_cond=0; break; case endwhile_tag: ptr++; //quit_block_newprogcx(); //putc_ice_prgm(endwhile_tag); //push_uint8_ice_prgm(while_queue[while_index]); //put_str_no_0_to_ice(&while_cond_list[while_index-1][0]); //putc_ice_prgm(0x3F); //end of line return *out_ptr=44; out_ptr++; *out_ptr=while_queue[while_index]; out_ptr++; while_index--; //sprintf(big_buf,"%c",0xD4); break; case for_c_tag: ptr++; for_index++; for_queue[for_index]=nb_for; nb_for++; //Below : for lbl and goto in same block process //blocks_newprogcx_list[blocks_newprogcx_level]=blocks_newprogcx_i; //blocks_newprogcx_level++; blocks_newprogcx_i++; //printf("\nin compile for, *ptr=%d",*ptr); disp_token(ptr); *out_ptr=54; out_ptr++; *out_ptr=nb_for-1; out_ptr++; //printf("\nin compile for, *ptr=%d",*ptr); disp_token(ptr); if(nb_for>=255) { sprintf(buf1,"Error line %d:Too much 'for'",line); my_exit(buf1); } /* if(*ptr!=user_word_tag) { sprintf(buf1,"Error line %d:syntax expected for(var,,,)",line); my_exit(buf1); } */ //printf("\nin compile for, *ptr=%d",*ptr); disp_token(ptr); //printf("\n*ptr-1=%d",*ptr); disp_token(ptr); ptr=compile_arg(ptr); //strcpy(buf1,big_buf); //printf("\n*ptr-2=%d",*ptr); ptr=compile_arg(ptr); //strcpy(buf2,big_buf); //printf("\n*ptr-3=%d",*ptr); ptr=compile_arg(ptr); //strcpy(buf3,big_buf); //printf("\n*ptr-4=%d",*ptr); //ptr=compile_arg(ptr); //strcpy(buf4,big_buf); //sprintf(big_buf,"%c%s%c%s%c%s%c%s",0xD3,buf1,0x2B,buf2,0x2B,buf3,0x2B,buf4); // 0xD3=For 0x2B=',' 0x10=( 0x11=) if(*ptr==end_tag) ptr++; //skip end_tag //*out_ptr=0; *(out_ptr+1)=0; out_ptr+=2; //for bug break; case for_tag: ptr++; for_index++; for_queue[for_index]=nb_for; nb_for++; //Below : for lbl and goto in same block process //blocks_newprogcx_list[blocks_newprogcx_level]=blocks_newprogcx_i; //blocks_newprogcx_level++; blocks_newprogcx_i++; //printf("\nin compile for, *ptr=%d",*ptr); disp_token(ptr); *out_ptr=14; out_ptr++; *out_ptr=nb_for-1; out_ptr++; //printf("\nin compile for, *ptr=%d",*ptr); disp_token(ptr); if(nb_for>=255) { sprintf(buf1,"Error line %d:Too much 'for'",line); my_exit(buf1); } if(*ptr!=user_word_tag) { sprintf(buf1,"Error line %d:syntax expected for(var,,,)",line); my_exit(buf1); } //printf("\nin compile for, *ptr=%d",*ptr); disp_token(ptr); //printf("\n*ptr-1=%d",*ptr); disp_token(ptr); ptr=compile_arg(ptr); //strcpy(buf1,big_buf); //printf("\n*ptr-2=%d",*ptr); ptr=compile_arg(ptr); //strcpy(buf2,big_buf); //printf("\n*ptr-3=%d",*ptr); ptr=compile_arg(ptr); //strcpy(buf3,big_buf); //printf("\n*ptr-4=%d",*ptr); ptr=compile_arg(ptr); //strcpy(buf4,big_buf); //sprintf(big_buf,"%c%s%c%s%c%s%c%s",0xD3,buf1,0x2B,buf2,0x2B,buf3,0x2B,buf4); // 0xD3=For 0x2B=',' 0x10=( 0x11=) if(*ptr==end_tag) ptr++; //skip end_tag //*out_ptr=0; *(out_ptr+1)=0; out_ptr+=2; //for bug break; case endfor_tag: ptr++; //quit_block_newprogcx(); //sprintf(big_buf,"%c",0xD4); //0xD4=End //putc_ice_prgm(endfor_tag); //push_uint8_ice_prgm(for_queue[for_index]); *out_ptr=24; out_ptr++; *out_ptr=for_queue[for_index]; out_ptr++; for_index--; break; case user_word_tag: //considère que les variables pour le moment //if(is_debug) printf("\nIn user_word tag"); ptr++; //skip user_word tag ptr++; //skip string tag v1=get_uint16(&ptr); word_ptr=ptr; //printf("\n %s",ptr); ptr+=v1; //go to the end of string token (so user word token too) if(!is_existing_newprogcx_var_str(word_ptr)) { i_var=create_newprogcx_var_and_return_iden(word_ptr); //printf("Newprog var %s no exist, iden=%d",word_ptr,i_var); } else {i_var=get_newprogcx_var_iden(word_ptr); /*printf("Newprog var %s already exist, iden=%d",word_ptr,i_var);*/} //Below : for lbl and goto in same block process //if(blocks_newprogcx_level>0) blocks_newprogcx_level--; //else my_exit("Internal error with blocks [1]"); //blocks_newprogcx_list[blocks_newprogcx_level]; *out_ptr=6; //newprog var tag out_ptr++; *out_ptr=i_var; out_ptr++; if(is_debug) printf("\nNewprogcx var str=%s, iden=%d",word_ptr,i_var); //strtoupper(maj_str_buf,word_ptr); //strcpy(big_buf,maj_str_buf); /* var_iden=get_ice_var_iden(word_ptr); //find first in local if(var_iden==-1) //create a new ice var { var_iden=create_ice_var_and_get_iden(word_ptr,3,0); is_local_temp=0; //var_type=3; } else //ice var already exist. Get if local { if(ice_var_list[var_iden].ice_func_iden!=0) is_local_temp=1; else is_local_temp=0; } if(is_local_temp) { putc_ice_prgm(load_local_var_tag); putc_ice_prgm(ice_var_list[var_iden].ice_local_var_index); printf("\nLoad local_tag iden=%d",ice_var_list[var_iden].ice_local_var_index); } else { putc_ice_prgm(load_global_var_tag); putc_ice_prgm(var_iden); //l'iden des variables globales peut sauter d'une var à la suivante si cas de variables locales printf("\nLoad global_tag iden=%d",var_iden); } */ //ptr+=v1; //go to the end of string token (so user word token too) break; case sto_equal_tag: ptr++; //printf("\ninsto_equal, *ptr=%d",*ptr); //disp_token(ptr); va=0; switch(*ptr) { case uc_data_tag: case sc_data_tag: case us_data_tag: case ss_data_tag: case ui_data_tag: case si_data_tag: is_void_data=0; va=1; break; case void_tag: ptr++; if(*ptr==uc_data_tag) { sprintf(buf,"Error line %d:Can't affect a void data**",line); my_exit(buf); } break; case stoucad: case stousad: case stouiad: case stoscad: case stossad: case stosiad: case user_word_tag: *out_ptr=7; out_ptr++; ptr=compile_arg(ptr); //dest //strcpy(buf1,big_buf); ptr=compile_arg(ptr); //src va=1; break; case lelem_tag: //list or matrix elem *out_ptr=101; out_ptr++; ptr=compile_arg(ptr); //dest ptr=compile_arg(ptr); //src va=1; break; } if(va==0) //incompatible sto equ destination { sprintf(buf,"Error line %d, invalid sto destination",line); my_exit(buf); } break; case string_tag: *out_ptr=17; out_ptr++; ptr1=get_string_no_isz(ptr); v1=strlen(ptr1); //printf("\nin disp token string, ptr1=%d",ptr1); if(v1>1000) { sprintf(buf,"Error line %d:String too long",line); my_exit(buf); } push_num_output_with_isz_68k(v1); strcpy(out_ptr,ptr1); out_ptr+=v1+1; //sprintf(big_buf,"%c%s%c",0x2A,get_string_no_isz(ptr),0x2A); ptr=skip_token(ptr); break; case if_tag: /* ptr=compile_front_op_size1(ptr,0xCE); if(previous_line!=line) if_short_level=0; if_short_level++; */ //ptr=compile_front_op_size1(ptr,0xCE); ptr++; //skip if_tag *out_ptr=13; out_ptr++; //if(previous_line!=line) if_short_level=0; if_short_level++; if(if_short_level>NB_IF_SHORT_MAX-1) my_exit("\nToo much if(cond):instruc"); *out_ptr=0; out_ptr++; *out_ptr=if_short_level; out_ptr++; //printf("\nif short level=%d",if_short_level); ptr=compile_arg(ptr); //skip condition ptr++; //skip end_tag break; case ice_func_tag: //user ice function definition ptr+=2; v1=is_existing_user_ice_func(ptr+4); //return func iden if(v1==9999) //not already exist { nbargs_found=get_nb_args(ptr-1); if(nbargs_found>6 && nbargs_found!=99) { sprintf(big_buf,"Error line %ld:%s too much args",line,ptr+4); my_exit(big_buf); } add_user_ice_func(ptr+4,nbargs_found); if(is_debug) printf("\nNew user ice func=%s() nb args=%d",ptr+4,nbargs_found); sprintf(big_buf,"%c%s",0xD6,strtoupper_specified_max_len(buf,ptr+4,30)); //put label ptr=skip_arg(ptr-2); //skip string token } else //already exist { sprintf(buf,"Error line %d:Already existing user ice func %s",line,ptr+4); my_exit(buf); } //is_ice_func_tag_just_trigered=2; break; case end_ice_func_tag: //ice programmer usr func sprintf(big_buf,"%c",0xD5); //put Return ptr=skip_arg(ptr); break; case user_func_tag: if(is_debug)printf("nn\n"); if(is_debug) printf("Is user function, %d %c",100,100);//*(ptr+5),*(ptr+5),ptr+5); //sprintf(buf,"\nuserfunc_str:%s",ptr+5); //printf(buf); i=get_simple_ice_function_iden(ptr+5); if(is_debug) printf("\n func iden=%d",i); //keywait(); nbargs_found=get_nb_args(ptr); //printf("\n nbargs found=%d",nbargs_found); if(is_debug) printf("\n bargs found=%d",nbargs_found); if(i==9999) //not a native ice function ==> so a user ice function define with func endfunc { //sprintf(buf,"Error:Unknown ice function %s()",ptr+5); //my_exit(buf); if(nbargs_found>6) { sprintf(big_buf,"Error line : too much args with your personnal function, 6 args maxi expected"); my_exit(big_buf); } if(!is_existing_func_newprogcx(ptr+5)) { sprintf(buf,"Error line %d:unknown func %s",line,ptr+5); my_exit(buf); } i=get_func_newprogcx_iden(ptr+5); //full newprogcx func if(nbargs_found!=func_newprogcx_list[i].user_func_newprogcx_nbargs) { sprintf(buf,"Error line %d:wrong number of args with %s",line,ptr+5); my_exit(buf); } *out_ptr=83; out_ptr++; push_num_output_with_isz_68k(i); //newprog func iden push_num_output_with_isz_68k(nbargs_found); //nbargs for(i3=1;i3<=nbargs_found;i3++) { compile_arg(get_newprogcx_func_argn_ptr(ptr,nbargs_found,i3)); } ptr=skip_arg(ptr); break; } else //native func first { //only funcnum=52 & =62 are allowed to have more than 6 args /*if(simple_ice_function_list[i].func_num!=52 && simple_ice_function_list[i].func_num!=62) //request1num or request2num. Nb args>6 { if(nbargs_found>6 && nbargs_found!=99) { sprintf(big_buf,"Error line%ld : %s too much args",line,simple_ice_function_list[i].func_str); my_exit(big_buf); } }*/ if(simple_ice_function_list[i].func_nbargs!=99 && simple_ice_function_list[i].func_nbargs!=nbargs_found) { sprintf(buf,"\nError: For %s(), %d args found, %d args expected",ptr+5,nbargs_found,simple_ice_function_list[i].func_nbargs); my_exit(buf); } if(simple_ice_function_list[i].func_num==210) //210=blit(), verify the args type { *out_ptr=simple_ice_function_list[i].func_num; //=210 out_ptr++; if(nbargs_found!=simple_ice_function_list[i].func_nbargs) { sprintf(buf,"Error line %d:With %s(), nb args expected=%d",line,simple_ice_function_list[i].func_str,simple_ice_function_list[i].func_nbargs); my_exit(buf); } if(*get_newprogcx_func_argn_ptr(ptr,nbargs_found,1)!=block_tag || *get_newprogcx_func_argn_ptr(ptr,nbargs_found,2)!=block_tag || *get_newprogcx_func_argn_ptr(ptr,nbargs_found,3)!=block_tag || *get_newprogcx_func_argn_ptr(ptr,nbargs_found,4)!=block_tag || get_nb_args(get_newprogcx_func_argn_ptr(ptr,nbargs_found,1))!=3 || get_nb_args(get_newprogcx_func_argn_ptr(ptr,nbargs_found,2))!=4 || get_nb_args(get_newprogcx_func_argn_ptr(ptr,nbargs_found,3))!=3 || get_nb_args(get_newprogcx_func_argn_ptr(ptr,nbargs_found,4))!=2) //true before and after arguments switching { sprintf(buf,"Error line %d:Expected %s({srcpixptr,srcw,srch},{x1,y1,w1,h1},{destpixptr,destw,desth},{x2,y2})",line,simple_ice_function_list[i].func_str); my_exit(buf); } for(i3=1;i3<=nbargs_found;i3++) { compile_arg(get_newprogcx_func_argn_ptr(ptr,nbargs_found,i3)); } ptr=skip_arg(ptr); } else { //ci dessous, toutes les fonctions simples //ptr=skip_token(ptr); //printf("\nUser func str=%s, iden=%d",simple_ice_function_list[i].func_str,i); *out_ptr=simple_ice_function_list[i].func_num; out_ptr++; if(simple_ice_function_list[i].func_nbargs==99) //nombre variables de paramètres { if(nbargs_found>6 || nbargs_found0 && *ptr!=if_tag) //ifshort process) { end_of_shortif=1; } else end_of_shortif=0; /* if(line==1) { sprintf(big_buf,"%c%s",0xD7,strtoupper(buf,"MAIN")); //goto main put_str_no_0_to_ice(big_buf); putc_ice_prgm(0x3F); //end of line return } */ //printf("\nis in compile cuurent line"); keywait(); while(ptr0) //ifshort process { ptr_temp=compile_arg(ptr); put_str_no_0_to_ice(big_buf); putc_ice_prgm(0x3F); //end of line return sprintf(big_buf,"%c",0xD4); //endif put_str_no_0_to_ice(big_buf); is_shortif_instruc--; ptr=ptr_temp; return ; } else */ //if(is_debug) {printf("\nIn compile current line, token="); disp_token(ptr); printf(" Lbl_iden=%d",lbl_iden);} ptr_temp=compile_arg(ptr); //printf("\nLa1"); if(ptr_temp==ptr) { if(*ptr_temp!=end_cmd_tag && *ptr_temp!=end_tag) { sprintf(buf,"Unimplemented root ice func:%d",*ptr); my_exit(buf); } //printf("\ndans le == -1"); ptr=skip_token(ptr); //printf("\ndans le == -2"); disp_token(ptr); //printf("\ncond=%d",ptr0 && is_operator_token(get_top_stack_without_poping(&operator_stack)) && (op_associa[get_operator_pos(*get_top_stack_without_poping(&operator_stack))]==LtoR && is_operator_token(get_top_stack_without_poping(&operator_stack)) && op_priority[get_operator_pos(*get_top_stack_without_poping(&operator_stack))]>=op_priority[get_operator_pos(o1)] || op_associa[get_operator_pos(*get_top_stack_without_poping(&operator_stack))]==RtoL && is_operator_token(get_top_stack_without_poping(&operator_stack)) && op_priority[get_operator_pos(*get_top_stack_without_poping(&operator_stack))]>op_priority[get_operator_pos(o1)])) { temp_token_ptr=pop_Stack(&operator_stack); if(temp_token_ptr==0) my_exit("\noperator token ptr is null"); //ptr_parser=push_quantum(*temp_token_ptr,ptr_parser,&parser_size); ptr_parser=push_token_from(temp_token_ptr,ptr_parser,&parser_size); } //printf("\n poped token="); //disp_token(temp_token_ptr); push_Stack(&operator_stack,ptr_lexer); } if(*ptr_lexer==comma_tag) { //printf("\nis comma"); while(operator_stack.nb_elem>0 && *get_top_stack_without_poping(&operator_stack)!=parenthesis_open_tag && *get_top_stack_without_poping(&operator_stack)!=comma_tag) { temp_token_ptr=pop_Stack(&operator_stack); //ptr_parser=push_quantum(*temp_token_ptr,ptr_parser,&parser_size); ptr_parser=push_token_from(temp_token_ptr,ptr_parser,&parser_size); } //if(operator_stack.nb_elem==0) // my_exit("Error: '(' or ')' missing"); } if(*ptr_lexer==parenthesis_open_tag) { //printf("\nparenthesis open"); if(is_func_token(previous_ptr_lexer)) ptr_parser=push_quantum(end_tag,ptr_parser,&parser_size); push_Stack(&operator_stack,ptr_lexer); } if(*ptr_lexer==parenthesis_close_tag) { //printf("\nparenthesis close"); while(operator_stack.nb_elem>0 && *get_top_stack_without_poping(&operator_stack)!=parenthesis_open_tag) { temp_token_ptr=pop_Stack(&operator_stack); ptr_parser=push_token_from(temp_token_ptr,ptr_parser,&parser_size); } pop_Stack(&operator_stack); //pop the left bracket if(operator_stack.nb_elem>0 && is_func_token(get_top_stack_without_poping(&operator_stack))) { temp_token_ptr=pop_Stack(&operator_stack); ptr_parser=push_token_from(temp_token_ptr,ptr_parser,&parser_size); } //if(operator_stack.nb_elem==0) // my_exit("Error:Expected '('"); } //printf("\noperators stack"); //disp_Stack(&operator_stack); previous_ptr_lexer=ptr_lexer; ptr_lexer=skip_token(ptr_lexer); } while(operator_stack.nb_elem>0) { if(is_operator_token(temp_token_ptr=pop_Stack(&operator_stack))) ptr_parser=push_quantum(*temp_token_ptr,ptr_parser,&parser_size); } if(*ptr_lexer==end_line_tag) { ptr_lexer=skip_token(ptr_lexer); } if(*ptr_lexer==end_cmd_tag) { ptr_lexer=skip_token(ptr_lexer); } if(*ptr_lexer==end_prgm_tag) //cette condition n'est jamais vraie (pour l'instant) { break; } if(temp==2) final_parser_line_compilation(1); //compilation and more the current command line. Last line else final_parser_line_compilation(0); //Not the last line } verify_matching_gotos_with_lbls(); } void copy_byte_code_to_file(void) { unsigned char *ptr; FILE *f; //f=fopen("./out.tns","wb"); f=fopen(npprgm_str_input,"wb"); if(!f) my_exit("Error creating output file:Memory-1"); for(ptr=output_byte_code_prgm;ptr