Scripting Dynamics
/* * Copyright (c) 2013 Miguel Pando * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ #include
#include
#include
#include
#include
#include
#include
//--------- LIMITS ---------------- #define SB_NUM_LAB 100 //127 maximum #define SB_NUM_IF 100 //127 maximum #define SB_NUM_CMDS 25 #define SB_NUM_ERRS 25 #define SB_LAB_LEN 25 #define SB_FOR_NEST 5 #define SB_SUB_NEST 25 #define SB_IF_NEST 25 #define SB_NUM_INCS 10 #define SB_NUM_VAR 40 #define SB_NUM_CONSTS 100 //127 maximum //---------Token TYPES------------- #define SB_UNDEFTOK 0 #define SB_DELIMITER 1 #define SB_NUMBER 2 #define SB_INTEGER 3 #define SB_COMMAND 4 #define SB_STRING 5 #define SB_QUOTE 6 #define SB_VARISTR 7 #define SB_LABEL 8 #define SB_EXPRESSION 9 #define SB_NUMEXPR 10 #define SB_BITWISE 11 #define SB_FLOAT 12 #define SB_INUMEXPR 13 //------Tokens------------- #define SB_UNKNCOM 0 #define SB_RESERVED 1 #define SB_INPUT 2 #define SB_IF 3 #define SB_THEN 4 #define SB_FOR 5 #define SB_NEXT 6 #define SB_TO 7 #define SB_GOTO 8 #define SB_GOSUB 9 #define SB_RETURN 10 #define SB_EOL 11 #define SB_FORMAT 12 #define SB_ELSE 13 #define SB_ENDIF 14 #define SB_VAL 15 #define SB_CALL 16 #define SB_IMPORT 17 #define SB_PARSE 18 #define SB_PARSECOUNT 19 #define SB_XCALL 20 #define SB_OR 21 #define SB_AND 22 #define SB_CHR 23 #define SB_INSTR 24 #define SB_MID 25 #define SB_LEN 26 #define SB_REP 27 #define SB_TRIM 28 #define SB_LTRIM 29 #define SB_RTRIM 30 #define SB_ASC 31 #define SB_RE 32 #define SB_DATE 33 #define SB_TIME 34 #define SB_LCASE 35 #define SB_UCASE 36 #define SB_INCLUDE 37 #define SB_RAISE 38 #define SB_STEP 39 #define SB_GETFILE 40 #define SB_RUN 41 #define SB_XOR 42 #define SB_FINISHED 43 #define SB_END 44 #define SB_ANY 45 #define SB_PLUS 46 #define SB_MINUS 47 #define SB_ASTER 48 #define SB_DIV 49 #define SB_IDIV 50 #define SB_OPAREN 51 #define SB_GE 52 #define SB_NE 53 #define SB_LE 54 #define SB_G 55 #define SB_L 56 #define SB_EQ 57 #define SB_AMPER 58 #define SB_ASSIGN 59 #define SB_MOD 60 #define SB_EXP 61 #define SB_xGOTO 62 #define SB_INSTR1 63 #define SB_PARSECOUNT1 64 #define SB_PARSECOUNT2 65 #define SB_RE1 66 #define SB_PARSE1 67 #define SB_PARSE2 68 #define SB_REP1 69 #define SB_CPAREN 70 #define SB_COMMA 71 #define SB_SEMI 72 #define SB_MID1 73 #define SB_OSQR 74 #define SB_CSQR 75 #define SB_DIM 76 #define SB_ARRAY2 90 #define SB_ARRAY0 77 #define SB_ARRAY1 78 #define SB_ASSIGNARRAY 79 #define SB_ARG 80 #define SB_PRINT 81 #define SB_REREP 82 #define SB_STRNG 83 #define SB_STRNG1 84 #define SB_CONST1 85 #define SB_CONST2 86 #define SB_ERR 87 #define SB_ERRORMSG 88 #define SB_SLEEP 89 //-------------ERROR TYPES-------------- #define SB_ERRMSG -1 #define SB_SERROR 0 #define SB_PARENS 1 #define SB_NOEXP 2 #define SB_DIV_ZERO 3 #define SB_EQUAL_EXP 4 #define SB_NOT_VAR 5 #define SB_LAB_TAB_FULL 6 #define SB_DUP_LAB 7 #define SB_UNDEF_LAB 8 #define SB_THEN_EXP 9 #define SB_TO_EXP 10 #define SB_TOO_MNY_FOR 11 #define SB_NEXT_WO_FOR 12 #define SB_TOO_MNY_GOSUB 13 #define SB_RET_WO_GOSUB 14 #define SB_MISS_QUOTE 15 #define SB_BAD_FILE 16 #define SB_STR_EXP 17 #define SB_TOO_MNY_IF 18 #define SB_LIB_NOT_FOUND 19 #define SB_TOO_MNY_LIB 20 #define SB_MISS_ENDIF 21 #define SB_IF_TAB_FULL 22 #define SB_VAR_TABLE_FULL 23 #define SB_UNKNOWN_KEYWORD 24 //----------------TYPES--------- struct TAB_TYPE { char *Command; int Tok; }; struct TAB_TYPE Table[SB_NUM_CMDS]; struct LAB_TYPE { char Lname[SB_LAB_LEN]; int p; }; struct LAB_TYPE Label_Table[SB_NUM_LAB]; struct IF_TYPE { int p1; int p2; }; struct IF_TYPE IF_Table[SB_NUM_IF]; int iStack[SB_IF_NEST]; int Errorflag, Eflag, Aflag, iflag; int ProgPtr, pConsts, Const_ix, pp, ix; char *Consts[SB_NUM_CONSTS]; char Var_Table[SB_NUM_VAR * 3][30]; int Token_Type, Tok, itos; char Token[82], xToken[82], ErrorMsg[64]; char ErrorBuffer[512], pcode[4096]; char *MyProg; char ifcount; char *Delimiters; int nDelims; int Relops[] = {SB_GE, SB_NE, SB_LE, '<', '>', '=', '\0', '\0'}; int nRelops; int e; char *SErrorS[SB_NUM_ERRS] = { "Syntax Error", "Unbalanced Parentheses", "No Expression Present", "Division by Zero", "Equal Sign Expected", "Not a Variable", "Label Table Full", "Duplicate Label", "Undefined Label", "THEN Expected", "TO Expected", "Too Many Nested GOSUBs", "NEXT Without FOR", "Too Many GOSUBs", "Return Without GOSUB", "Missing Quote", "Bad File Name", "String Expected", "Too Many Nested IFs", "Library Not Found", "Too Many LIBs", "Unbalanced IF", "IF Table Full", "Variable Table Full", "Unknown Keyword" }; void DO_Error(int); void Check_END(); void Check_RAISE(); void Check_RUN(); void Check_DIM(); void Check_IF(); void Check_ENDIF(); void Check_ELSE(); void Check_PRINT(); void Check_GOTO(); void Check_GOSUB(); void Check_IMPORT(); void Check_RETURN(); void Check_FOR(); void Check_NEXT(); void Check_FORMAT(); void Check_SLEEP(); void PutBack(); void FindEOL(); void Init(); void ScanSource(); int ScanFlag; char *GetToken(); int Eval_StrExp(); int Eval_StrExp1(); int Eval_Exp(); int Eval_Exp1(); int Eval_Exp1a(); int Eval_Exp2(); int Eval_Exp3(); int Eval_Exp4(); int Eval_Exp5(); int Eval_Exp6(); int Atom(); int Eval_Test(); int Eval_Test_OR(); int Eval_Test_AND(); int Eval_Test_Parens(); int Eval_Test_End(); int Check_ASC(); int Check_CHR(); int Check_CASE(); int Check_LEN(); int Check_STRING(); int Check_REPLACE(); int Check_CALL(); int Check_MID(); int Check_VAL(); int Check_TRIM(int); int Check_INSTR(); int Check_PARSE(); int Check_PARSECOUNT(); int Check_ARG(); int Check_ARRAY(int); char *EXEC_INCLUDE(int *); char *getfile(char *, int *); int IsAlpha(char); int IsDigit(char); //int FindLabel(char *); int FindLabel(char *, int x); //??? x=start int GetSlot(char *, int); //***************************************************************** char *strupr(char *s) { //***************************************************************** char *ret; int i, ln; ln=strlen(s); ret=s; for (i=0; i
96 && ret[i] < 123) ret[i]&=0x0df; } return ret; } //***************************************************************** void getv(char *s, int i) { //***************************************************************** char n; n=GetSlot(s, i); n=128 + n; pcode[pp++]=n; } //***************************************************************** int savequote(char *s) { //***************************************************************** char c; int n; if (Const_ix > SB_NUM_CONSTS) { strcpy(ErrorMsg, "Number Of Constants Exceed Limit"); DO_Error(SB_ERRMSG); return 1; } pConsts+=strlen(s); pConsts++; if (pConsts > 16000) { strcpy(ErrorMsg, "Max Constant Space Exceeded"); DO_Error(SB_ERRMSG); return 1; } for (n=1; n<=Const_ix; n++) { if (Consts[n]==NULL) break; if (strcmp(Consts[n], s)==0) { c=n; pcode[pp++]=SB_CONST2; pcode[pp++]=c; return 0; } } Consts[Const_ix] = (char *) malloc(strlen(s) + 1); if(strlen(s)==0) { strcpy(Consts[Const_ix], "\2"); } else { strcpy(Consts[Const_ix], s); } c=n; pcode[pp++]=SB_CONST2; pcode[pp++]=c; Const_ix++; return 0; } //***************************************************************** int parsenumber() { //***************************************************************** char *T; int e; T=GetToken(); if (T[0]==',') T=GetToken(); if (T[0]==')') { DO_Error(SB_SERROR); return 1; } if (T[0]!=',') PutBack(); e=Eval_Exp(); return e; } //***************************************************************** int parsestring() { //***************************************************************** char *T; int e; T=GetToken(); if (T[0]==',' && Token_Type==SB_DELIMITER) T=GetToken(); if (T[0]==')') { DO_Error(SB_SERROR); return 1; } if (T[0]!=',' || Token_Type==SB_QUOTE) PutBack(); e=Eval_StrExp(); return e; } //***************************************************************** void DO_Error(int Gerror) { //***************************************************************** int TempPtr, MyLine, i; char *TempStr, ch, *s, *z, ebuf[4]; if (Errorflag) return; Errorflag=1; z=" in line "; TempPtr=0; TempStr=""; ch='\0'; MyLine=1; while (1) { if (ProgPtr <= TempPtr) break; ch=MyProg[TempPtr++]; if (ch=='\n') MyLine++; } if (Gerror >= 0 ) s=SErrorS[Gerror]; else s=ErrorMsg; if ( (ix + strlen(s) + strlen(z) + 4) >= 512) { printf("%s", ErrorBuffer); printf("Too Many Errors\n"); return; } for (i=0; i
='0' && T[1]<='9')) { if (T[0]=='I') c='0'; if (T[0]=='N') c='1'; if (T[0]=='S') c='2'; } else { DO_Error(SB_SERROR); return; } pcode[pp++]=c; c=T[1]; //0-9 pcode[pp++]=c; z=GetToken(); if (z[0] != '(' ) { DO_Error(SB_PARENS); return; } e=parsenumber(); //Array element if (e) return; z=GetToken(); if (z[0] != ')' ) { DO_Error(SB_PARENS); return; } z=GetToken(); if (z[0] != '=' ) { DO_Error(SB_EQUAL_EXP); return; } Aflag=1; if (T[0]=='S') { e=Eval_StrExp(); } else { e=Eval_Exp(); } Aflag=0; } //***************************************************************** void Assignment() { //***************************************************************** int e, ln; char b[30], *x, *T; char s; T=GetToken(); if (IsAlpha(T[0])==0) { DO_Error(SB_NOT_VAR); return; } strcpy(b, T); T=strupr(b); if (MyProg[ProgPtr]=='(') { Assign_Array(T); return; } //Peek pcode[pp++]=SB_ASSIGN; x=GetToken(); if (x[0] != '=') { DO_Error(SB_EQUAL_EXP); return; } ln=strlen(T); s=T[ln-1]; Aflag=1; if (s == '$') { // vname$ getv(T, 81); e=Eval_StrExp(); Aflag=0; return; } if (s == '#') { // vname# Float getv(T, 41); e=Eval_Exp(); Aflag=0; return; } getv(T, 1); // vname Integer e=Eval_Exp(); Aflag=0; } //***************************************************************** int Find_Expression(int *l) { //***************************************************************** char *expr; int t; strcpy(xToken, Token); expr=strupr(xToken); t=0; *l=SB_EXPRESSION; /* CASE "RE" 't=SB_RE : *l=SB_NUMEXPR 'CASE "REREP" 't=SB_REREP : *l=SB_NUMEXPR */ if (strcmp(expr, "ASC")==0) { t=SB_ASC; *l=SB_NUMEXPR; return t; } if (strcmp(expr, "CHR")==0) return SB_CHR; if (strcmp(expr, "CALL")==0) return SB_CALL; if (strcmp(expr, "DATE")==0) return SB_DATE; //if (strcmp(expr, "GETFILE")==0) return SB_GETFILE; if (strcmp(expr, "INSTR")==0) { t=SB_INSTR; *l=SB_NUMEXPR; return t; } if (strcmp(expr, "ERR")==0) { t=SB_ERR; *l=SB_NUMEXPR; return t; } if (strcmp(expr, "PARSECOUNT")==0) { t=SB_PARSECOUNT; *l=SB_NUMEXPR; return t; } if (strcmp(expr, "LEN")==0) { t=SB_LEN; *l=SB_NUMEXPR; return t; } if (strcmp(expr, "LCASE")==0) return SB_LCASE; if (strcmp(expr, "LTRIM")==0) return SB_LTRIM; if (strcmp(expr, "MID")==0) return SB_MID; if (strcmp(expr, "PARSE")==0) return SB_PARSE; if (strcmp(expr, "REPLACE")==0) return SB_REP; if (strcmp(expr, "RTRIM")==0) return SB_RTRIM; if (strcmp(expr, "TIME")==0) return SB_TIME; if (strcmp(expr, "INPUT")==0) return SB_INPUT; if (strcmp(expr, "ERRMSG")==0) return SB_ERRORMSG; if (strcmp(expr, "TRIM")==0) return SB_TRIM; if (strcmp(expr, "UCASE")==0) return SB_UCASE; if (strcmp(expr, "VAL")==0) { t=SB_VAL; *l=SB_NUMEXPR; return t; } if (strcmp(expr, "STRING")==0) return SB_STRNG; if (strcmp(expr, "ARG")==0) return SB_ARG; if (strcmp(expr, "AND")==0) { t=SB_AND; *l=SB_BITWISE; return t; } if (strcmp(expr, "OR")==0) { t=SB_OR; *l=SB_BITWISE; return t; } if (strcmp(expr, "XOR")==0) { t=SB_XOR; *l=SB_BITWISE; return t; } if (expr[0]=='N' || expr[0]=='S' || expr[0]=='I') { if (MyProg[ProgPtr]=='(') { //Peek if (expr[0]=='I') {*l=SB_INUMEXPR; t=SB_ARRAY0;} if (expr[0]=='N') {*l=SB_NUMEXPR; t=SB_ARRAY1;} if (expr[0]=='S') t=SB_ARRAY2; } return t; } return 0; } //***************************************************************** int LookUp() { //***************************************************************** char *s; int Counter; strcpy(xToken, Token); s=strupr(xToken); Counter=1; while (Counter < SB_NUM_CMDS) { if (Table[Counter].Command==NULL) break; if (strcmp(Table[Counter].Command, s)==0) { return Table[Counter].Tok; } Counter++; } return SB_UNKNCOM; //DEFAULT VALUE } //***************************************************************** int IsDelim(char c) { //***************************************************************** int i; if (c=='\0' || c=='\t' || c=='\r' || c=='\n') return 1; for (i=0; i
9) return -1; return n; } //***************************************************************** int IsAlpha(char c) { //***************************************************************** if ( (c>64 && c<91) || (c>96 && c<123) ) return 1; return 0; } //***************************************************************** void PutBack() { //***************************************************************** int Mylen, i, n; char *T; T=Token; Mylen=strlen(T); ProgPtr -= Mylen; if (Token_Type==SB_QUOTE) { n=0; for (i=0; i
': c=SB_G; break; case SB_GE: c=SB_GE; break; case '=': c=SB_EQ; break; case SB_NE: c=SB_NE; break; } pcode[pp++]=c; e=Eval_StrExp(); if (e) return e; PutBack(); } else { //Syntax Error DO_Error(SB_SERROR); return 1; } return 0; } // Entrance to Parser //***************************************************************** int Eval_Exp() { //***************************************************************** char *T; int e; T=GetToken(); if (strcmp(T, "EOF")==0) { DO_Error(SB_NOEXP); return 1; } e=Eval_Exp1(); if (e) return e; PutBack(); pcode[pp++]=SB_EOL; return 0; } //***************************************************************** int Eval_Exp1() { //BITWISE //***************************************************************** char op, *T, c; int e; e=Eval_Exp1a(); if (e) return e; if (Token_Type==SB_BITWISE && Aflag) { op=Tok; T=GetToken(); switch (op) { case SB_AND: c=SB_AND; break; case SB_OR: c=SB_OR; break; case SB_XOR: c=SB_XOR; break; } pcode[pp++]=c; e=Eval_Exp1(); if (e) return e; } return 0; } //***************************************************************** int Eval_Exp1a() { //RELATIONAL //***************************************************************** char op, *T, c; int e, n; e=Eval_Exp2(); if (e) return e; op=Token[0]; for (n=0; n
': c=SB_G; break; case SB_GE: c=SB_GE; break; case '=': c=SB_EQ; break; case SB_NE: c=SB_NE; break; } pcode[pp++]=c; e=Eval_Exp1a(); if (e) return e; } return 0; } //***************************************************************** int Eval_Exp2() { //ADD OR SUBTRACT //***************************************************************** char op, *T, c; int e; e=Eval_Exp3(); if (e) return e; op=Token[0]; while (op=='+' || op=='-') { switch (op) { case '-': c=SB_MINUS; break; case '+': c=SB_PLUS; break; } pcode[pp++]=c; T=GetToken(); e=Eval_Exp3(); if (e) return e; op=Token[0]; } return 0; } //***************************************************************** int Eval_Exp3() { //DIVIDE OR MULTIPLY OR MOD //***************************************************************** char op, *T, c; int e; e=Eval_Exp4(); if (e) return e; op=Token[0]; while (op=='*' || op=='/' || op=='\\' || op=='%') { switch (op) { case '*': c=SB_ASTER; break; case '/': c=SB_DIV; break; case '\\': c=SB_IDIV; break; case '%': c=SB_MOD; break; } pcode[pp++]=c; T=GetToken(); e=Eval_Exp4(); if (e) return e; op=Token[0]; } return 0; } //***************************************************************** int Eval_Exp4() { //PROCESS EXPONENT //***************************************************************** char *T; int e; e=Eval_Exp5(); if (e) return e; T=Token; if (T[0]=='^') { pcode[pp++]=SB_EXP; T=GetToken(); e=Eval_Exp4(); if (e) return e; } return 0; } //***************************************************************** int Eval_Exp5() { //UNARY + OR - //***************************************************************** char *T; T=Token; if (Token_Type==SB_DELIMITER && (T[0]=='+' || T[0]=='-') ) { pcode[pp++]=SB_MINUS; T=GetToken(); } e=Eval_Exp6(); if (e) return e; return 0; } //***************************************************************** int Eval_Exp6() { //SQUARE BRACKETS //***************************************************************** char *T; int e; T=Token; if (T[0]=='[') { pcode[pp++]=SB_OSQR; T=GetToken(); e=Eval_Exp2(); if (e) return e; T=Token; if (T[0] != ']') { DO_Error(SB_PARENS); return 1; } pcode[pp++]=SB_CSQR; T=GetToken(); return 0; } e=Atom(); return e; } //***************************************************************** int Atom() { //***************************************************************** char *T; int e, i, p; e=0; T=Token; switch(Token_Type) { case SB_INTEGER: case SB_FLOAT: e=Find_Var(T); break; case SB_NUMBER: p=atoi(T); for (i=0; i
= strlen(T) && p<127) { pcode[pp++]=SB_CONST1; pcode[pp++]=p+1; e=0; } else { e=savequote(T); if (e) return e; } break; case SB_INUMEXPR: switch(Tok) { case SB_ARRAY0: e=Check_ARRAY(0); //Integer Array break; default: DO_Error(SB_SERROR); return 1; } break; case SB_NUMEXPR: switch(Tok) { case SB_ASC: e=Check_ASC(); break; case SB_LEN: e=Check_LEN(); break; case SB_ERR: pcode[pp++]=SB_ERR; break; case SB_INSTR: e=Check_INSTR(); break; case SB_VAL: e=Check_VAL(); break; case SB_PARSECOUNT: e=Check_PARSECOUNT(); break; case SB_ARRAY1: e=Check_ARRAY(1); //Double Float Array break; default: DO_Error(SB_SERROR); return 1; } break; case SB_EXPRESSION: if (Tok==SB_CALL) { e=Check_CALL(); } else { DO_Error(SB_SERROR); return 1; } break; default: DO_Error(SB_SERROR); return 1; } T=GetToken(); return e; } //-----------------END OF PARSER--------------------------- //***************************************************************** int Eval_Test() { //***************************************************************** char *T; int e; T=GetToken(); e=Eval_Test_OR(); if (e) return e; pcode[pp++]=SB_EOL; return 0; } //***************************************************************** int Eval_Test_OR() { //***************************************************************** char *T, *op, c; int e; c=SB_OR; e=Eval_Test_AND(); if (e) return e; T=Token; op=strupr(T); if (strcmp(op, "OR")==0) { pcode[pp++]=c; T=GetToken(); e=Eval_Test_OR(); if (e) return e; return 0; } return 0; } //***************************************************************** int Eval_Test_AND() { //***************************************************************** char *T, *op, c; int e; c=SB_AND; e=Eval_Test_Parens(); if (e) return e; T=Token; op=strupr(T); if (strcmp(op, "AND")==0) { pcode[pp++]=c; T=GetToken(); e=Eval_Test_OR(); if (e) return e; } return 0; } //***************************************************************** int Eval_Test_Parens() { //***************************************************************** char *T, c1, c2; int e; c1=SB_OPAREN; c2=SB_CPAREN; T=Token; if (T[0]=='(') { pcode[pp++]=c1; T=GetToken(); e=Eval_Test_OR(); if (e) return e; pcode[pp++]=c2; T=Token; if (T[0] != ')') { DO_Error(SB_PARENS); return 1; } T=GetToken(); } else { e=Eval_Test_End(); if (e) return e; } return 0; } //***************************************************************** int Eval_Test_End() { //***************************************************************** char *T, c; int e; if (Token_Type==SB_VARISTR || Token_Type==SB_QUOTE || Token_Type==SB_EXPRESSION) { PutBack(); pcode[pp++]=2; e=Eval_StrExp1(); } else { PutBack(); pcode[pp++]=1; e=Eval_Exp(); } if (e) return e; T=GetToken(); c=Tok; if (c==SB_OR || c==SB_AND || c==SB_THEN || c==')') { } else { DO_Error(SB_UNKNOWN_KEYWORD); return 1; } return 0; } //***************************************************************** char *GetToken() { //***************************************************************** char ch, ch1; int l, n; l=0; Token_Type=SB_UNDEFTOK; Tok=SB_UNDEFTOK; Token[0]='\0'; ch=MyProg[ProgPtr]; if (ch=='\0') { //END OF PROG? Tok=SB_FINISHED; Token_Type=SB_DELIMITER; strcpy(Token, "EOF"); //CHR$(0) return Token; } while (ch==' ' || ch=='\t') { //GO PAST WHITE SPACES ch=MyProg[++ProgPtr]; } if (ch == '/') { if (MyProg[ProgPtr+1]=='*') { //We have a Block comment ++ProgPtr; while (1) { if (ch=='*') { if (MyProg[ProgPtr+1]=='/') break; } ch=MyProg[++ProgPtr]; } ++ProgPtr; ++ProgPtr; ch=MyProg[++ProgPtr]; } } if (ch == '\'') { // "'" We have a comment while (1) { if (ch=='\n') break; ch=MyProg[++ProgPtr]; } } if (ch=='\r' || ch=='\n' || ch==':') { //END OF LINE? if (ch=='\r') ProgPtr++; ProgPtr++; Tok=SB_EOL; Token_Type=SB_DELIMITER; Token[0]='E'; Token[1]='L'; Token[2]='\0'; if (ch==':') Token[0]='X'; return Token; } if (ch=='<' || ch=='>') { //DOUBLE OPS ch1=MyProg[ProgPtr + 1]; if (ch=='<') { Token[0]='<'; ProgPtr++; if (ch1=='>') { Token[0]=SB_NE; Token[1]='\0'; ProgPtr++; } if (ch1=='=') { Token[0]=SB_LE; Token[1]='\0'; ProgPtr++; } } if (ch=='>') { Token[0]='>'; ProgPtr++; if (ch1=='=') { Token[0]=SB_GE; Token[1]='\0'; ProgPtr++; } } Token_Type=SB_DELIMITER; return Token; } if (ch=='"') { //QUOTED STRING n=0; while (1) { ch=MyProg[++ProgPtr]; if (ch=='\n') break; if (ch=='"') { ch=MyProg[ProgPtr + 1]; if (ch=='"') { Token[n]=ch; ProgPtr++; } else { ch=' '; break; } } else { Token[n]=ch; } n++; } Token[n]='\0'; if (ch=='\n') { DO_Error(SB_MISS_QUOTE); ProgPtr++; } ProgPtr++; Token_Type=SB_QUOTE; return Token; } if (IsDelim(ch)) { Token[0]=ch; Token[1]='\0'; ProgPtr++; Token_Type=SB_DELIMITER; return Token; } if ( (IsDigit(ch) >= 0) || ch=='.') { n=0; while (1) { if (IsDelim(ch)==0 && IsAlpha(ch)==0) { Token[n]=ch; n++; ch=MyProg[++ProgPtr]; } else break; } if (IsAlpha(ch)) { Tok=SB_UNDEFTOK; return Token; } Token_Type=SB_NUMBER; Token[n]='\0'; return Token; } if (IsAlpha(ch)) { n=0; while (1) { if (IsDelim(ch) || ch=='.') break; Token[n]=ch; n++; ch=MyProg[++ProgPtr]; } Token_Type=SB_STRING; Token[n]='\0'; if (ch=='.' && ScanFlag==1) ++ProgPtr; //r = Lib.proc(params) same as r = Call Lib.proc(params) ??? if (ch=='.' && ScanFlag==0) { ScanFlag=2; Tok=SB_CALL; Token_Type=SB_EXPRESSION; PutBack(); return Token; } } if (Token_Type==SB_STRING) { //IS COMMAND OR VARIABLE if (ScanFlag==2) ScanFlag=0; Tok=LookUp(); if (Tok==SB_UNDEFTOK) { ch1=Token[n-1]; switch(ch1){ case '$': Token_Type=SB_VARISTR; break; case '#': Token_Type=SB_FLOAT; break; case ':': Token_Type=SB_LABEL; break; default: if (!(IsDigit(ch1) >=0 || IsAlpha(ch1))) return Token; if (ScanFlag==0) ScanFlag=2; Tok=Find_Expression(&l); if (Tok) { Token_Type=l; } else { if (ScanFlag==2) ScanFlag=0; Token_Type=SB_INTEGER; } } } else { Token_Type=SB_COMMAND; } } return Token; } //******************************************************************* void Init() { //******************************************************************* Table[1].Command="PRINT"; Table[1].Tok=SB_PRINT; Table[2].Command="IMPORT"; Table[2].Tok=SB_IMPORT; Table[3].Command="IF"; Table[3].Tok=SB_IF; Table[4].Command="THEN"; Table[4].Tok=SB_THEN; Table[5].Command="GOTO"; Table[5].Tok=SB_GOTO; Table[6].Command="FOR"; Table[6].Tok=SB_FOR; Table[7].Command="NEXT"; Table[7].Tok=SB_NEXT; Table[8].Command="TO"; Table[8].Tok=SB_TO; Table[9].Command="GOSUB"; Table[9].Tok=SB_GOSUB; Table[10].Command="RETURN"; Table[10].Tok=SB_RETURN; Table[11].Command="FORMAT"; Table[11].Tok=SB_FORMAT; Table[12].Command="ELSE"; Table[12].Tok=SB_ELSE; Table[13].Command="ENDIF"; Table[13].Tok=SB_ENDIF; Table[14].Command="INCLUDE"; Table[14].Tok=SB_INCLUDE; Table[15].Command="RAISE"; Table[15].Tok=SB_RAISE; Table[16].Command="STEP"; Table[16].Tok=SB_STEP; Table[17].Command="RUN"; Table[17].Tok=SB_RUN; Table[18].Command="END"; Table[18].Tok=SB_END; Table[19].Command="DIM"; Table[19].Tok=SB_DIM; Table[20].Command="SLEEP"; Table[20].Tok=SB_SLEEP; Delimiters = " ;,+-<>^=(*)/\\&%[]@"; nDelims=strlen(Delimiters); nRelops=8; } int xlen; //***************************************************************** char *Exec_xRUN(char *prg, int *e) { //***************************************************************** int count, i, n; char *T, *buf; union u { int n; char c[4]; }; union u u1; *e=0; Init(); MyProg=prg; //for (count=1; count < SB_NUM_LAB; count++) { for (count=0; count < SB_NUM_LAB; count++) { //??? Label_Table[count].Lname[0]='\0'; Label_Table[count].p=0; } for (count=0; count < SB_NUM_VAR * 3; count++) { Var_Table[count][0]='\0'; } ScanFlag=1; ScanSource(); if (Eflag) { *e=Eflag; return NULL; } ScanFlag=0; pp=0; Const_ix=1; pConsts=1; ProgPtr=0; ifcount=0; Tok=0; while (Tok != SB_FINISHED && Errorflag==0) { T=GetToken(); if (Token_Type==SB_INTEGER || Token_Type==SB_VARISTR || \ Token_Type==SB_FLOAT || Tok==SB_ARRAY0 || Tok==SB_ARRAY1 || Tok==SB_ARRAY2) { //a variable PutBack(); Assignment(); } else { if (Token_Type==SB_LABEL) { //n=FindLabel(Token); n=FindLabel(Token, 0); //??? Label_Table[n].p=pp + 1; } else { //a command switch (Tok) { case SB_PRINT: Check_PRINT(); break; case SB_GOTO: Check_GOTO(); break; case SB_GOSUB: Check_GOSUB(); break; case SB_RETURN: Check_RETURN(); break; case SB_FOR: Check_FOR(); break; case SB_NEXT: Check_NEXT(); break; case SB_IF: Check_IF(); break; case SB_ELSE: Check_ELSE(); break; case SB_ENDIF: Check_ENDIF(); break; case SB_IMPORT: Check_IMPORT(); break; case SB_FORMAT: Check_FORMAT(); break; case SB_RAISE: Check_RAISE(); break; case SB_RUN: Check_RUN(); break; case SB_DIM: Check_DIM(); break; case SB_SLEEP: Check_SLEEP(); break; case SB_END: Check_END(); break; case SB_FINISHED: pcode[pp]=SB_FINISHED; break; case SB_EOL: break; //do nothing default: DO_Error(SB_UNKNOWN_KEYWORD); } } } if (Errorflag==0) { if (iflag==2) { if (Token[0]=='E' && Token[1]=='L') { iflag=0; IF_Table[ifcount].p2=pp + 1; } } if (iflag==1) { iflag=2; pcode[pp++]=SB_xGOTO; pcode[pp++]=ifcount; } } Errorflag=0; } if (itos) { DO_Error(SB_MISS_ENDIF); Eflag=1; } if (ix) Eflag=1; if (Eflag==0) { //Output pcode /* u1.n=1; x1=3; x2=2; if (u1.c[0]==1) { x1=0; x2=1; } // Big Endian */ i=0; buf=(char *) malloc( (SB_NUM_LAB * 2) + (SB_NUM_IF * 4) + pConsts + 100); //for (count=1; count
0) { i=GetSlot(T, n); if (i==0) { DO_Error(SB_VAR_TABLE_FULL); return; } if (i<0) { i=-i; strcpy(Var_Table[i], T); } } if (Token_Type == SB_LABEL) { n=GetNextLabel(); if (n==-1) { DO_Error(SB_LAB_TAB_FULL); return; } if (n==-2) { DO_Error(SB_DUP_LAB); return; } //??? if (strlen(T) >= 6) { for (i=0; i<5; i++) TT[i] = T[i] | 0x20; //To Lower Case TT[i]='\0'; if (strcmp(TT, "cback")==0) { if (Label_Table[0].Lname[0] == '\0') { n=0; } else { DO_Error(SB_DUP_LAB); return; } } } strcpy(Label_Table[n].Lname, T); Label_Table[n].p=0; } if (Token_Type == SB_COMMAND) { if (Tok==SB_IF) { ifcount++; if (ifcount > SB_NUM_IF) { DO_Error(SB_IF_TAB_FULL); return; } } } if (Tok==SB_GOTO || Tok==SB_GOSUB) FindEOL(); } } //***************************************************************** //int FindLabel(char *s) { int FindLabel(char *s, int x) { //x=1 or 0 ??? //***************************************************************** int count; //for (count=1; count
'9') { DO_Error(SB_SERROR); return; } T=GetToken(); if (T[0] != '(') { DO_Error(SB_PARENS); return; } pcode[pp++]=SB_DIM; pcode[pp++]=ch0; pcode[pp++]=ch; e=parsenumber(); if (e) return; T=GetToken(); if (T[0] != ')') { DO_Error(SB_PARENS); return; } } //***************************************************************** void Check_RUN() { //***************************************************************** char *T; int e; //RUN xyz$ //RUN "xyz", p1$, p2$, x pcode[pp++]=SB_RUN; e=Eval_StrExp(); //pname while(1) { if (Tok==SB_EOL || Tok==SB_FINISHED) break; if (Token[0]==',') { Eval_StrExp(); } else { T=GetToken(); //DO_Error ??? } } pcode[pp++]=SB_XCALL; } //***************************************************************** void Check_END() { //***************************************************************** char *T; int e; T=GetToken(); if (Tok==SB_EOL) { pcode[pp++]=SB_END; pcode[pp++]=SB_EOL; } else { pcode[pp++]=SB_END; PutBack(); e=Eval_Exp(); } } //***************************************************************** void Check_RAISE() { //***************************************************************** int e; //RAISE "ERROR DESCRIPTION" pcode[pp++]=SB_RAISE; e=Eval_StrExp(); } //***************************************************************** char *EXEC_INCLUDE(int *e) { //***************************************************************** char *T, *z; int x; //INCLUDE "xyz.txt" *e=0; T=Token; z=getfile(T, &x); *e=x; return z; } //***************************************************************** int iPop() { //***************************************************************** int n; if (itos==0) { DO_Error(SB_SERROR); return -1; } n=iStack[itos]; iStack[itos]=0; itos--; return n; } //***************************************************************** void iPush() { //***************************************************************** itos++; if (itos > SB_IF_NEST) { DO_Error(SB_TOO_MNY_IF); return; } iStack[itos]=ifcount; } //***************************************************************** void Check_IF() { //***************************************************************** char *T; int e, l; //if (x>y or x=z+len(s$ & q$)) and z$="abc" then //t ( 1 var > var eol or 1 var = var + t var & var eol eol ) and 0 var = const eol eol //1 1 1 2 1 2 1 1 1 2 1 2 1 1 2 1 2 1 1 1 1 1 2 1 2 1 1 ifcount++; pcode[pp++]=SB_IF; e=Eval_Test(); if (e) return; //if (Errorflag) { FindEOL(); return; } if (Tok != SB_THEN) { DO_Error(SB_THEN); return; } l=0; T=GetToken(); if (Tok != SB_EOL) l=1; PutBack(); if (l) { iflag=1; } else { pcode[pp++]=SB_xGOTO; pcode[pp++]=ifcount; iPush(); } } //***************************************************************** void Check_ELSE() { //***************************************************************** char ch; int x; x=iStack[itos]; ch = (char) x; pcode[pp++]=SB_xGOTO; pcode[pp++]=(ch | 0x40); IF_Table[x].p1=pp + 1; } //***************************************************************** void Check_ENDIF() { //***************************************************************** int x; x=iPop(); IF_Table[x].p2=pp + 1; } //***************************************************************** void Check_PRINT() { //***************************************************************** char *T; int e; pcode[pp++]=SB_PRINT; e=Eval_StrExp(); if (e) return; T=Token; if (Tok != SB_EOL) { DO_Error(SB_SERROR); return; } pcode[pp++]=SB_EOL; } //***************************************************************** void Check_SLEEP() { //***************************************************************** char *T; int e; pcode[pp++]=SB_SLEEP; e=Eval_Exp(); if (e) return; T=Token; if (Tok != SB_EOL) { DO_Error(SB_SERROR); return; } pcode[pp++]=SB_EOL; } //***************************************************************** void Check_GOTO() { //***************************************************************** char *T; int n; T=GetToken(); //n=FindLabel(T); n=FindLabel(T, 1); //??? if (n==0) { DO_Error(SB_UNDEF_LAB); return; } pcode[pp++]=SB_GOTO; pcode[pp++]=(char) n; } //***************************************************************** void Check_GOSUB() { //***************************************************************** char *T; int n; T=GetToken(); //n=FindLabel(T); n=FindLabel(T, 1); //??? if (n==0) { DO_Error(SB_UNDEF_LAB); return; } pcode[pp++]=SB_GOSUB; pcode[pp++]=(char) n; } //***************************************************************** void Check_RETURN() { //***************************************************************** pcode[pp++]=SB_RETURN; } //***************************************************************** void Check_FOR() { //***************************************************************** char *T, *x; int e; T=GetToken(); if (Token_Type != SB_INTEGER) { DO_Error(SB_SERROR); return; } T=strupr(T); pcode[pp++]=SB_FOR; getv(T, 1); x=GetToken(); if (x[0] !='=') { DO_Error(SB_EQUAL_EXP); return; } e=Eval_Exp(); if (e) return; x=strupr(GetToken()); if (strcmp(x, "TO") !=0) { DO_Error(SB_TO_EXP); return; } e=Eval_Exp(); if (e) return; if (Tok==SB_STEP || Tok==SB_EOL) { } else { DO_Error(SB_SERROR); return; } if (Tok==SB_STEP) { T=GetToken(); e=Eval_Exp(); if (e) return; } else { //Step 2 - 1 pcode[pp++]=SB_CONST1; pcode[pp++]=2; pcode[pp++]=SB_EOL; } } //***************************************************************** void Check_NEXT() { //***************************************************************** char *T; T=GetToken(); if (Tok != SB_EOL) { DO_Error(SB_SERROR); return; } pcode[pp++]=SB_NEXT; } //***************************************************************** void Check_IMPORT() { //***************************************************************** char *lib; int e, i; pcode[pp++]=SB_IMPORT; lib=GetToken(); i=strlen(lib)-1; if (lib[i]!='$') { e=savequote(lib); } else { PutBack(); e=Eval_StrExp(); if (e) return; if (Tok != SB_EOL) { DO_Error(SB_SERROR); return; } } } //***************************************************************** void Check_FORMAT() { //***************************************************************** int e; pcode[pp++]=SB_FORMAT; e=Eval_StrExp(); } char getpbuf[30]; //***************************************************************** void getp(char *pw) { //***************************************************************** int ln, n; char ch; ln=strlen(pw); for (n=0; n < ln; n++) { ch = pw[n]; getpbuf[n] = ch; } getpbuf[n]='\0'; } //***************************************************************** int Check_CALL() { //***************************************************************** char *T, *lib, *proc; int e, i, ln; pcode[pp++]=SB_CALL; lib=GetToken(); ln=strlen(lib); i=ln-1; if (lib[i]!='$') { e=savequote(lib); if (e) return e; } else { pcode[pp++]=SB_VARISTR; getv(lib, 81); pcode[pp++]=SB_EOL; //Eval_StrExp(); } if (MyProg[ProgPtr]=='.') { //Peek //CALL MyLib.Proc(param1, param2, ...., paramn) ++ProgPtr; T=GetToken(); //Get Procedure getp(T); proc=&getpbuf[0]; T=GetToken(); if (T[0] !='(') { DO_Error(SB_SERROR); return 1; } if (MyProg[ProgPtr] != ')') T[0]=','; //Peek } else { //CALL MyLib(Proc, param1, param2, ...., paramn) T=GetToken(); if (T[0] !='(') { DO_Error(SB_SERROR); return 1; } T=GetToken(); //Get Procedure getp(T); proc=&getpbuf[0]; } e=savequote(proc); if (e) return e; while(1) { if (T[0]==')' || Tok==SB_EOL || Tok==SB_FINISHED) break; if (T[0]==',') { Eval_StrExp(); T=Token; } else { T=GetToken(); } } if (T[0] !=')') { DO_Error(SB_SERROR); return 1; } pcode[pp++]=SB_XCALL; return 0; } //***************************************************************** int Check_REPLACE() { //***************************************************************** char *T; int e, xi; //x$=REPLACE(z$, s$, c$) //x$=REPLACE(z$, ANY s$, c$) xi=pp; pp++; T=GetToken(); if (T[0] !='(') { DO_Error(SB_SERROR); return 1; } e=parsestring(); if (e) return e; T=GetToken(); T=strupr(T); pcode[xi]=SB_REP; if (strcmp(T, "ANY")==0) { pcode[xi]=SB_REP1; } else { PutBack(); } e=parsestring(); if (e) return e; e=parsestring(); if (e) return e; T=Token; if (T[0] !=')') { DO_Error(SB_SERROR); return 1; } return 0; } //***************************************************************** int Check_MID() { //***************************************************************** char *T; int e, xi; //x$=MID(z$, n) //x$=MID(z$, n, l) xi=pp; pp++; T=GetToken(); if (T[0] != '(') { DO_Error(SB_PARENS); return 1; } e=parsestring(); if (e) return e; e=parsenumber(); if (e) return e; pcode[xi]=SB_MID1; T=GetToken(); if (T[0] != ')') { pcode[xi]=SB_MID; PutBack(); e=parsenumber(); if (e) return e; T=GetToken(); } if (T[0] != ')') { DO_Error(SB_PARENS); return 1; } return 0; } //***************************************************************** int Check_LEN() { //***************************************************************** char *T; int e; //n=LEN(z$) T=GetToken(); if (T[0] != '(') { DO_Error(SB_PARENS); return 1; } pcode[pp++]=SB_LEN; e=parsestring(); if (e) return e; T=Token; if (T[0] != ')') { DO_Error(SB_PARENS); return 1; } return 0; } //***************************************************************** int Check_INSTR() { //***************************************************************** char *T; int e, a, xi; //n=INSTR(z$, "?") //n=INSTR(5, z$, "?") //n=INSTR(z$, ANY "?!") //n=INSTR(n, z$, ANY "?!") T=GetToken(); if (T[0] != '(') { DO_Error(SB_PARENS); return 1; } xi=pp; pp++; T=GetToken(); if (Token_Type==SB_INTEGER || Token_Type==SB_NUMBER || T[0]=='-') { PutBack(); e=parsenumber(); if (e) return e; } else { //instr(1, ... pcode[pp++]=SB_CONST1; pcode[pp++]=2; pcode[pp++]=SB_EOL; PutBack(); } e=parsestring(); if (e) return e; a=0; if (Token[0]==',') { T=GetToken(); if (T[0] != ')') { T=strupr(T); if (strcmp(T, "ANY")==0) { a=1; } else { PutBack(); } e=parsestring(); if (e) return e; } } else { DO_Error(SB_SERROR); return 1; } if (a) { pcode[xi]=SB_INSTR1; } else { pcode[xi]=SB_INSTR; } T=Token; if (T[0] != ')' ) { DO_Error(SB_PARENS); return 1; } return 0; } //***************************************************************** int Check_PARSE() { //***************************************************************** char *T; int a, e, xi; //x$=PARSE(z$, "?", n) SB_PARSE1 //x$=PARSE(z$, "?!", n) SB_PARSE1 //x$=PARSE(z$, ANY "?!", n) SB_PARSE2 //pcode[pp++]=SB_PARSE2; xi=pp; pp++; T=GetToken(); if (T[0] != '(') { DO_Error(SB_PARENS); return 1; } e=parsestring(); if (e) return e; a=0; T=Token; if (T[0]==',') { T=GetToken(); if (strcmp(strupr(T), "ANY") == 0) { a=1; T=GetToken(); } PutBack(); if (Token_Type==SB_VARISTR || Token_Type==SB_QUOTE || Token_Type==SB_EXPRESSION) { e=parsestring(); if (e) return e; } else { DO_Error(SB_SERROR); return 1; } } else { DO_Error(SB_SERROR); return 1; } e=parsenumber(); if (e) return e; T=GetToken(); if (T[0] != ')') { DO_Error(SB_PARENS); return 1; } pcode[xi]=SB_PARSE1; if (a) pcode[xi]=SB_PARSE2; return 0; } //***************************************************************** int Check_PARSECOUNT() { //***************************************************************** char *T; int e, a, xi; //x=PARSECOUNT(z$, "?") SB_PARSECOUNT1 //x=PARSECOUNT(z$, "?!") SB_PARSECOUNT1 //x=PARSE(z$, ANY "?!") SB_PARSECOUNT2 xi=pp; pp++; T=GetToken(); if (T[0] != '(') { DO_Error(SB_PARENS); return 1; } e=parsestring(); if (e) return e; T=Token; a=0; if (T[0]==',') { T=GetToken(); T=strupr(T); if (strcmp(T, "ANY")==0) { a=1; T=GetToken(); } PutBack(); if (Token_Type==SB_VARISTR || Token_Type==SB_QUOTE || Token_Type==SB_EXPRESSION) { e=parsestring(); if (e) return e; } else { DO_Error(SB_SERROR); return 1; } } else { DO_Error(SB_SERROR); return 1; } T=Token; if (T[0] != ')') { DO_Error(SB_PARENS); return 1; } switch (a) { case 0: pcode[xi]=SB_PARSECOUNT1; break; case 1: pcode[xi]=SB_PARSECOUNT2; break; } return 0; } //***************************************************************** int Check_ARRAY(int x ) { //***************************************************************** char *T, c; int e; T=Token; if (T[1]>='0' && T[1]<='9') { c=T[1]; } else { DO_Error(SB_SERROR); return 1; } if (x==0) pcode[pp++]=SB_ARRAY0; //i2(i) if (x==1) pcode[pp++]=SB_ARRAY1; //n2(i) if (x==2) pcode[pp++]=SB_ARRAY2; //s2(i) pcode[pp++]=c; T=GetToken(); if (T[0] != '(') { DO_Error(SB_PARENS); return 1; } e=parsenumber(); if (e) return e; T=GetToken(); if (T[0] != ')') { DO_Error(SB_PARENS); return 1; } return 0; } //***************************************************************** int Check_VAL() { //***************************************************************** char *T; int e; T=GetToken(); if (T[0] != '(') { DO_Error(SB_PARENS); return 1; } pcode[pp++]=SB_VAL; e=parsestring(); if (e) return e; T=Token; if (T[0] != ')') { DO_Error(SB_PARENS); return 1; } return 0; } //***************************************************************** int Check_CASE(int n) { //***************************************************************** char *T; int e; T=GetToken(); if (T[0] != '(') { DO_Error(SB_PARENS); return 1; } pcode[pp++]=(char) n; e=parsestring(); if (e) return e; T=Token; if (T[0] != ')') { DO_Error(SB_PARENS); return 1; } return 0; } //***************************************************************** int Check_ASC() { //***************************************************************** char *T; int e; T=GetToken(); if (T[0] != '(') { DO_Error(SB_PARENS); return 1; } pcode[pp++]=SB_ASC; e=parsestring(); if (e) return e; T=Token; if (T[0] != ')') { DO_Error(SB_PARENS); return 1; } return 0; } //***************************************************************** int Check_CHR() { //***************************************************************** char *T; int e; T=GetToken(); if (T[0] != '(') { DO_Error(SB_PARENS); return 1; } pcode[pp++]=SB_CHR; e=parsenumber(); if (e) return e; T=GetToken(); if (T[0] != ')') { DO_Error(SB_PARENS); return 1; } return 0; } //***************************************************************** int Check_ARG() { //***************************************************************** char *T; int e; //s$=ARG(3) //s$=ARG(x) T=GetToken(); if (T[0] != '(') { DO_Error(SB_PARENS); return 1; } pcode[pp++]=SB_ARG; e=parsenumber(); if (e) return e; T=GetToken(); if (T[0] != ')') { DO_Error(SB_PARENS); return 1; } return 0; } //***************************************************************** int Check_STRING() { //***************************************************************** char *T; int e, xi; //s$=String(10, 32) //s$=String(x, " ") //s$=String(x, z$) xi=pp; pp++; T=GetToken(); if (T[0] != '(') { DO_Error(SB_PARENS); return 1; } e=parsenumber(); if (e) return e; T=GetToken(); if (T[0] !=',') { DO_Error(SB_SERROR); return 1; } T=GetToken(); if (Token_Type==SB_INTEGER || Token_Type==SB_NUMBER) { pcode[xi]=SB_STRNG; PutBack(); e=parsenumber(); if (e) return e; T=GetToken(); } else { pcode[xi]=SB_STRNG1; PutBack(); e=parsestring(); if (e) return e; T=Token; } if (T[0] != ')') { DO_Error(SB_PARENS); return 1; } return 0; } //***************************************************************** int Check_TRIM(int n) { //***************************************************************** char *T; int e; T=GetToken(); if (T[0] != '(') { DO_Error(SB_PARENS); return 1; } pcode[pp++]=(char) n; e=parsestring(); if (e) return e; T=Token; if (T[0] != ')') { DO_Error(SB_PARENS); return 1; } return 0; } //********************************************************** void write_pcode(char *fname, char *z) { //********************************************************** FILE *fp; if((fp = fopen(fname, "wb"))==NULL) return; fwrite(z, xlen, 1, fp); fwrite(pcode, strlen(pcode), 1, fp); fclose(fp); } //********************************************************** char *getfile(char *fname, int *e) { //********************************************************** FILE *fp; int fsize; char *fbuffer; *e=0; if((fp = fopen(fname, "rb"))==NULL) { *e=1; return NULL; } fseek(fp, 0, SEEK_END); fsize = ftell(fp); rewind(fp); fbuffer = (char *) malloc(fsize + 1); fread(fbuffer, fsize, 1, fp); fbuffer[fsize] = '\0'; fclose(fp); return fbuffer; } //********************************************************** int main(int argc, char *argv[]) { //********************************************************** char *s, *z, fname[30]; int t1, t2, x; int fp, rc; struct stat f; if (argc < 2) {printf("Missing Parameters\n"); exit(EXIT_FAILURE);} x=0; strcpy(fname, argv[1]); strcat(fname, ".sdx"); fp = open(fname, O_RDONLY); if (fp==-1) { x=1; //Compile } else { rc=fstat(fp, &f); if (rc == -1) { printf("rc error\n"); return 1; } t1=f.st_mtime; close(fp); strcpy(fname, argv[1]); strcat(fname, ".sd"); fp = open(fname, O_RDONLY); if (fp==-1) { x=-1; } else { rc=fstat(fp, &f); if (rc == -1) {printf("rc error\n"); return 1; } t2=f.st_mtime; close(fp); if (t2 > t1) x=1; } } if (x<0) { printf("File %s Not Found\n", fname); exit(0); } //Run .sdx ? if (x==0) { printf("Not Changed\n"); exit(0); } strcpy(fname, argv[1]); strcat(fname, ".sd"); e=0; s=getfile(fname, &e); if (e) {printf("Unable To Open File %s\n", fname); exit(EXIT_FAILURE);} z=Exec_xRUN(s, &e); //Compile if (e) { printf("%s\n", ErrorBuffer); } else { strcpy(fname, argv[1]); strcat(fname, ".sdx"); write_pcode(fname, z); } return e; }