ScriptBasic Belső Modulok

1. ScriptBasic Belső Modulok Peter Verhás Február 2002

2. Tartalom • Modulok általános felépítése • Beolvasó, ... , építő modulok részletesen

3. Ismétlés • ScriptBasic belső modulok • READER • LEXER • SYNTAXER • BULDER • EXECUTOR

4. Mi egy modul • Egy forrás fájlban implementált • Függvények gyűjteménye • typedef struct {} objektum adat definíció • Jól definiált hívási felület és eredmény

5. Objektum adat, függvények • Működési paraméterek • Pillanatnyi objektum státusz MODUL input reader.c lines read

6. Modul függvények • Inicializáló és operációs függvények • Belső függvények • Eredmény lekérdező függvények ScriptBasic main() Reader Lexer Syntax Build

7. Technikai megjegyzés • A ScriptBasic C-ben van írva, nem C++ • A fejléc fájlok mind a C kód megjegyzéseiben vannak • A headerer.pl generál *.c  *.h fájlokat • A fejléc fájlokban a függvény prototípus karbantartás automatizált • A // megjegyzéseket a headerer.pl szedi ki (nem teszi bele a *.h-ba) • (Létezik headerer.bas is  )

8. Beolvasó • Fájlból, vagy valamilyen más forrásból a memóriába olvassa be a programsorokat • A beolvasott sorokat tárolja

9. Beolvasó objektum struktúra 1/3 typedef struct _ReadObject { void * (*fpOpenFile)(char *, void *); int (*fpGetCharacter)(void *, void *); void (*fpCloseFile)(void *, void *); void *pFileHandleClass; void *(*memory_allocating_function)(size_t, void *); void (*memory_releasing_function)(void *, void *); void *pMemorySegment; ptConfigTree pConfig;

10. Beolvasó objektum struktúra 2/3 char *Buffer; // buffer to read a line long dwBuffer; // size of Buffer in bytes long cBuffer; // number of characters in buffer pSourceLine Result; // the lines of the file(s) read // iteration variables pSourceLine CurrentLine; // the current line in the iteration long NextCharacterPosition; // position of next character // to be returned during iteration char fForceFinalNL; // if TRUE then an extra new line is // added to the last line // if it was terminated by EOF

11. Beolvasó objektum struktúra 3/3 pReportFunction report; void * reportptr; // this pointer is passed // to the report function. The caller should set it. int iErrorCounter; unsigned long fErrorFlags; pImportedFileList pImportList; char *FirstUNIXline; struct _PreprocObject *pPREP; } ReadObject, *pReadObject;

12. Beolvasó függvények • reader_InitStructure • reader_ReadLines • reader_StartIteration • reader_NextCharacter/NextLine • reader_FileName/LineNumber

13. Lexikális elemző • A beolvasótól átveszi a karaktereket, és tokenizál • Token típusok enum LexemeType { LEX_T_DOUBLE = 1, LEX_T_LONG, LEX_T_STRING, LEX_T_ASYMBOL, LEX_T_NSYMBOL, LEX_T_CHARACTER, LEX_T_SKIP, LEX_T_SKIP_SYMBOL, LEX_T_DUMMY };

14. Token struktúra typedef struct _Lexeme { enum LexemeType type; // type of the lexeme union { double dValue; // double value long lValue; // long value char *sValue; // string or symbol value } value; long sLen; //length of string or symbol char *szFileName; // where the lexeme is long lLineNumber; // where the lexeme is struct _Lexeme *next; // link to the next lexeme } Lexeme, *pLexeme;

15. Lexikális elemző objektum struktúra 1/4 typedef struct _LexObject { // returns the next character from the input stream int (*pfGetCharacter)(void *); // returns a pointer to the file name that the last // character came from char * (*pfFileName)(void *); // returns the line number of the line that the last // character came from long (*pfLineNumber)(void *); void *pvInput; void *(*memory_allocating_function)(size_t, void *); void (*memory_releasing_function)(void *, void *); void *pMemorySegment;

16. Lexikális elemző objektum struktúra 2/4 char *SSC; // Start Symbol Character char *SCC; // Symbol Continuation Character char *SFC; // Symbol Final Character char *SStC; // Start String Character char *SKIP; // characters to be skipped // (though they are symbol // terminators and valid in strings) // this is usually space and tab // Escape replacements. The first character is // the escape character and // for each odd n the nth character is // the replacement for the (n-1)th character char *ESCS; long fFlag; // various options

17. Lexikális elemző objektum struktúra 3/4 pReportFunction report; // this pointer is passed to the report // function. The caller should set it. void *reportptr; int iErrorCounter; unsigned long fErrorFlags; // should point to a buffer of size char *buffer; long cbBuffer; //this number of bytes

18. Lexikális elemző objektum struktúra 4/4 pLexNASymbol pNASymbols; // Array of non alpha symbols // the longest Non Alpha Symbol // length including the final zchar int cbNASymbolLength; // Array of tokenizable alpha symbols pLexNASymbol pASymbols; // Array of command symbols for debug purposes // (used by ex_pprint via lex_SymbolicName) pLexNASymbol pCSymbols; pLexeme pLexResult; // list of tokens pLexeme pLexCurrentLexeme; // the actual lexeme struct _PreprocObject *pPREP; }LexObject, *pLexObject;

19. Lexikális elemző függvények • lex_InitStructure • lex_ReadInput • lex_StartIteration • lex_NextLexeme • lex_Save/RestorePosition • lex_EOF • lex_Type • lex_Double/String/Long/StrLen • Lex_Finish

20. Szintaxis elemző • A token listát olvassa és • Szintaxis fát generál • A szintaxis fa eNODE-okból áll • A szintaxis elemzőt nem tárgyaljuk • Nem érdemes, speciális, nem tipikus • De a generált BASIC belső kódot igen

21. eNODE struktúra typedef struct _eNODE { long OpCode; // the code of operation unsigned long NodeId; // the id of the node char *szFileName;// where the lexeme is long lLineNumber;// from which this syntax node is made union {...}Parameter; } eNODE,*peNODE;

22. eNODE Paraméter struktúra typedef struct _eNODE { ... union { // when the node is a command struct {...}CommandArgument; // when the node is an operation struct {...}Arguments; // when the node is a constant struct {...}Constant; // when the node is a variable struct {...}Variable; // when node is a user functions struct {...}UserFunction; }Parameter; } eNODE,*peNODE;

23. Parancs Argumentum // when the node is a command struct { union { struct _SymbolLABEL *pLabel; struct _eNODE *pNode; struct _eNODE_l *pNodeList; long lLongValue; double dDoubleValue; char *szStringValue; }Argument; long sLen; struct _eNODE *next; }CommandArgument;

24. További paraméterek // when the node is an operation struct { struct _eNODE_l *Argument;}Arguments; // when the node is a constant struct { union {double dValue;long lValue; char *sValue;}Value; long sLen; //the length of the string constant }Constant; // when the node is a variable struct { unsigned long Serial; }Variable; // when node is a user functions struct { pSymbolUF pFunction; // pointer to the function struct _eNODE_l *Argument; }UserFunction;

25. eNODE lista // node list typedef struct _eNODE_l{ unsigned long NodeId; // the id of the node char *szFileName;// where the lexeme is long lLineNumber;// from which this syntax node is made peNODE actualm; struct _eNODE_l *rest; } eNODE_l, *peNODE_l;

26. Címke és változó struktúra typedef struct _SymbolLABEL { // label for GOTO // and alikes long Serial; // serial value of the label unsigned long node; // where the label is placed (the node id) } SymbolLABEL, *pSymbolLABEL; typedef struct _SymbolVAR { //Variable long Serial; // serial number of the variable } SymbolVAR, *pSymbolVAR;

27. 13 actualm next rest rest rest 3 OpCode= EX_LEX_EXP OpCode=560 LET 1 Argument next Argument rest 9 10 OpCode= & 2 OpCode=eNTYPE_GVR Argument actualm Serial=1 5 OpCode=+ Argument 7 6 rest actualm actualm 8 4 OpCode=eNTYPE_STR OpCode=eNTYPE_LNG lValue=23 sValue=„5.5” Szintaxis elemzés példa a$ = 23 + "5.5" & "E1" 11 actualm 12 OpCode=eNTYPE_STR Argument sValue=„E1”

28. Szintaxis elemző függvények • ex_init • ex_Command_l

29. Építő (builder) • A szintaxis elemző pointer fáját alakítja át tömbbé • eNODE  cNODE

30. cNODE struktúra typedef struct _cNODE { long OpCode; // the code of operation union {...}Parameter; } cNODE,*pcNODE; typedef struct _eNODE { long OpCode; // the code of operation unsigned long NodeId; // the id of the node char *szFileName;// where the lexeme is long lLineNumber;// from which this syntax node is made union {...}Parameter; } eNODE,*peNODE;

31. cNODEParameter struktúra union { // when the node is a command struct {... }CommandArgument; // when the node is an operation struct {... }Arguments; // when the node is a constant union {... }Constant; // when the node is a variable struct { ... }Variable; // when node is a user functions struct { ... }UserFunction; // when the node is a node list head struct {... }NodeList; }Parameter; eNODE union { // when the node is a command struct {...}CommandArgument; // when the node is an operation struct {...}Arguments; // when the node is a constant struct {...}Constant; // when the node is a variable struct {...}Variable; // when node is a user functions struct {...}UserFunction; }Parameter;

32. cNODE Parancs Argumentum struktúra // when the node is a command struct { unsigned long next; union { unsigned long pNode; // node id of the node long lLongValue; double dDoubleValue; // serial value of the string from the string table unsigned long szStringValue; }Argument; }CommandArgument;

33. Építő modul függvények build_Build build_SaveCode build_LoadCode build_SaveCCode build_LookupFunctionByName build_LookupVariableByName

34. Köszönöm a figyelmet.