Building Interpreters

Transcription

1 Building Interpreters Mool Sagiv html:// Chapter 4 1

2 Structure of a simple compiler/interpreter Leical analsis Snta analsis Runtime Sstem Design Intermediate code (AST) Code generation Machine dependent Contet analsis PL dependent Smbol Table PLpardigm dependent Interpretation 2

3 Tpes of Interpreters Recursive Recursivel traverse the tree Uniform data representation Conceptuall clean Ecellent error detection 1000 slower than compiler Iterative Closer to CPU One flat loop Eplicit stack Good error detection 30 slower than compiler Can invoke compiler on code fragments 3

4 Input language (Overview) Full parameterized epressions Arguments can be a single digit epression digit ( epression operator epression ) operator * digit

5 #include "parser.h" #include "backend.h" static int Interpret_epression(Epression *epr) { switch (epr->tpe) { case 'D': return epr->value; break; case 'P': { int e_left = Interpret_epression(epr->left); int e_right = Interpret_epression(epr->right); switch (epr->oper) { case '': return e_left e_right; case '*': return e_left * e_right; }} break; } } vo Process(AST_node *icode) { printf("%d\n", Interpret_epression(icode)); } 5

6 AST for (2 * ((3*4)9)) tpe left * P right D 2 oper P * P D 9 D 3 D 4 6

7 Uniform self-entifing data representation The tpes of the sizes of program data values are not known when the interpreter is written Uniform representation of data tpes Tpe Size The value is a pointer 7

8 Eample: Comple Number re: im:

9 9

10 Status Indicator Direct control flow of the interpreter Possible values Normal mode Errors Jumps Eceptions Return 10

11 Eample: Interpreting C Return PROCEDURE Elaborate return with epression statement (RWE node): SET Result To Evaluate epression (RWE node. epression); IF Status. mode /= Normal mode: Return mode; SET Status. mode To Return mode; SET Status. value TO Result; 11

12 Interpreting If-Statement 12

13 Smbol table Stores content of variables, named ants, For ever variable V of tpe T A pointer to the name of V The file name and the line it is declared Kind of declaration A pointer to T A pointer to newl allocated space Initialization bit Language dependent information (e.g. scope) 13

14 Summar Recursive Interpreters Can be implemented quickl Debug the programming language Not good for heav-dut interpreter Slow Can emplo general techniques to speed the recursive interpreter Memoization Tail call elimination Partial evaluation 14

15 Memoization int fib(int n) { if (n == 0) return 0 ; if (n==1) return 1; return fib(n-1) fib(n-2) ; } int sfib[100] = {-1, -1,, -1} int fib(int n) { if (sfib[n] > 0) return sfib[n]; if (n == 0) return 0 ; if (n==1) return 1; sfib[n] = fib(n-1) fib(n-2) ; return sfib[n]; } 15

16 Tail Call Elimination vo a( ) { b(); } vo b(){ code; } vo a( ) { code; } vo b(){ code; } 16

17 Tail Call Elimination vo a(int n) { code if (n > 0) a(n-1); } vo a(int n) { loop: code if (n > 0) { n = n -1 ; goto loop } 17

18 Partial Evaluation Partiall interpret static parts in a program Generates an equivalent program Program Partial Evaluator Program Input 1 Input 2 18

19 Eample int pow(int n, int e) { if (e==0) return 1; else return n * pow(n, e-1); } int pow4(int n) { return n * n * n *n; } e=4 19

20 Eample2 Bool match(string, regep) { switch(regep) {. } } regep=a b* 20

21 Partial Evaluation Generalizes Compilation Interpreter Partial Evaluator Program AST Program Input 21

22 But. 22

23 Iterative Interpretation Closed to CPU One flat loop with one big case statement Use eplicit stack Intermediate results Local variables Requires full annotated threaded AST Active-node-pointer (interpreted node) 23

24 Demo Compiler 24

25 Threaded AST Annotated AST Ever node is connected to the immediate successor in the eecution Control flow graph Nodes Basic eecution units epressions ignments Edges Transfer of control sequential while 25

26 Threaded AST for (2 * ((3*4)9)) Dumm_node tpe left * P right Start D 2 oper P * P D 9 D 3 D 4 26

27 Demo Compiler 27

28 C Eample while (( > 0) && ( < 10)) { } = ; = 1 ; > 0 and < 10 while T F seq eit 28 1

29 Threading the AST(3.2.1) One preorder AST p Ever tpe of AST has its threading routine Maintains Last node pointer Global variable Set successor of Last pointer when node is visited 29

30 Last node pointer main > 0 and < 10 while seq 30 1

31 Last node pointer main > 0 and < 10 while seq 31 1

32 Last node pointer main > 0 and < 10 while seq 32 1

33 Last node pointer main > 0 and < 10 while seq 33 1

34 Last node pointer main > 0 and < 10 while seq 34 1

35 Last node pointer main > 0 and < 10 while seq 35 1

36 Last node pointer main > 0 and < 10 while seq 36 1

37 Last node pointer main > 0 and < 10 while seq 37 1

38 Last node pointer main > 0 and < 10 while T seq 38 1

39 Last node pointer main > 0 and < 10 while T seq 39 1

40 Last node pointer main > 0 and < 10 while T seq 40 1

41 Last node pointer main > 0 and < 10 while T seq 41 1

42 main > 0 and < 10 while T seq Last node pointer 42 1

43 main > 0 and < 10 while T Last node pointer seq 43 1

44 main > First node pointer 0 and < 10 while T Last node pointer seq 44 1

45 Demo Compiler 45

46 Conditional Statement Last node pointer if cond then_part else_part 46

47 Conditional Statement if T F cond then_part else_part Last node pointer End_If 47

48 Iterative Interpretation Closed to CPU One flat loop with one big case statement Use eplicit stack Intermediate results Local variables Requires full annotated threaded AST Active-node-pointer (interpreted node) 48

49 Demo Compiler 49

50 Conditional Statements 50

51 Storing Threaded AST General Graph Arra Pseudo Instructions 51

52 Threaded AST as General Graph condition IF statement 1 statement 2 statement 3 statement 4 END If 52

53 Threaded AST as Arra condition IF statement 1 statement 2 statement 3 statement 4 53

54 Threaded AST as Pseudo Instructions condition IFFALSE statement 1 JUMP statement 2 statement 3 statement 4 54

55 Iterative Interpreters (Summar) Different AST representations Faster than recursive interpreters Some interpretative overhead is eliminated Portable Secure Similarities with the compiler 55