by2.txt

一个上课很好用的课件

44      SyntaxTreeNode* getChild3();
45
46      friend class SyntaxTree;
47  };
48
49
50

Copyright?2006 idea's web. All rights reserved. | www.ideawu.net 







index 
 1  /************************************************************
 2  * file: SyntaxTreeNode.cpp
 3  * date: 2006-04-12
 4  * author: ideawu
 5  * describe: none; SyntaxTreeNode
 6  *************************************************************/
 7
 8  #include "SyntaxTreeNode.h"
 9
10
11  SyntaxTreeNode::SyntaxTreeNode(){
12      type = ERROR;
13      value = 0;
14      left = right = child3 = NULL;
15  }
16  SyntaxTreeNode::SyntaxTreeNode(TokenType t, int val){
17      type = t;
18      value = val;
19      left = right = child3 = NULL;
20  }
21
22  SyntaxTreeNode::~SyntaxTreeNode(){
23      if(left != NULL){
24          delete left;
25      }
26      if(right != NULL){
27          delete right;
28      }
29      if(child3 != NULL){
30          delete child3;
31      }
32  }
33
34  /*===================================================================*/
35
36  void SyntaxTreeNode::setType(TokenType t){
37      type = t;
38  }
39
40  TokenType SyntaxTreeNode::getType(){
41      return type;
42  }
43
44  void SyntaxTreeNode::setValue(int val){
45      value = val;
46  }
47
48  int SyntaxTreeNode::getValue(){
49      return value;
50  }
51
52
53  void SyntaxTreeNode::addLeft(TokenType t, int val){
54      left = new SyntaxTreeNode(t, val);
55  }
56  void SyntaxTreeNode::addLeft(SyntaxTreeNode *n){
57      left = n;
58  }
59
60
61  void SyntaxTreeNode::addRight(TokenType t, int val){
62      right = new SyntaxTreeNode(t, val);
63  }
64  void SyntaxTreeNode::addRight(SyntaxTreeNode *n){
65      right = n;
66  }
67
68
69  void SyntaxTreeNode::addChild3(TokenType t, int val){
70      child3 = new SyntaxTreeNode(t, val);
71  }
72  void SyntaxTreeNode::addChild3(SyntaxTreeNode *n){
73      child3 = n;
74  }
75
76
77  SyntaxTreeNode* SyntaxTreeNode::getLeft(){
78      return left;
79  }
80
81  SyntaxTreeNode* SyntaxTreeNode::getRight(){
82      return right;
83  }
84
85  SyntaxTreeNode* SyntaxTreeNode::getChild3(){
86      return child3;
87  }
88
89
90

Copyright?2006 idea's web. All rights reserved. | www.ideawu.net 










index 
 1  /************************************************************
 2  * file: SyntaxTree.h
 3  * date: 2006-04-12
 4  * author: ideawu
 5  * describe: none; SyntaxTree
 6  *************************************************************/
 7
 8  #include "common.h"
 9  #include "SyntaxTreeNode.h"
10
11  class SyntaxTree{
12  private:
13      SyntaxTreeNode *root;
14      void display(SyntaxTreeNode *n, int tabcount, FILE *fo=stdout);
15
16  public:
17      SyntaxTree(TokenType t, int val=0);
18      // set root node with n.
19      SyntaxTree(SyntaxTreeNode *n);
20      SyntaxTree(SyntaxTree *tree);
21      SyntaxTree();   // with root.type = ERROR
22      ~SyntaxTree();
23
24      void display(FILE *fo=stdout);
25
26      void setRootNode();
27      void setRootNode(TokenType t, int val=0);
28      // set root node with n.
29      void setRootNode(SyntaxTreeNode *n);
30
31      void addLeft(TokenType t, int val=0);
32      // add the subtree n to this tree's left
33      void addLeft(SyntaxTree *n);
34
35      void addRight(TokenType t, int val=0);
36      // add the subtree n to this tree's right
37      void addRight(SyntaxTree *n);
38
39      void addChild3(TokenType t, int val=0);
40      // add the subtree n to this tree's child3
41      void addChild3(SyntaxTree *n);
42
43      SyntaxTreeNode* getRootNode();
44
45      SyntaxTree* getLeft();
46      SyntaxTree* getRight();
47      SyntaxTree* getChild3();
48
49  };
50
51
52

Copyright?2006 idea's web. All rights reserved. | www.ideawu.net 








index 
  1  /************************************************************
  2  * file: SyntaxTree.cpp
  3  * date: 2006-04-12
  4  * author: ideawu
  5  * describe: none; SyntaxTree
  6  *************************************************************/
  7
  8  #include <stdio.h>
  9  #include <string.h>
 10  #include "SyntaxTree.h"
 11
 12
 13  char* tokenToString(TokenType type);
 14
 15  /*======================================================================*/
 16
 17  SyntaxTree::SyntaxTree(TokenType t, int val){
 18      root = new SyntaxTreeNode(t, val);
 19  }
 20  SyntaxTree::SyntaxTree(SyntaxTreeNode *n){
 21      setRootNode(n);
 22  }
 23  SyntaxTree::SyntaxTree(SyntaxTree *tree){
 24      setRootNode(tree->getRootNode());
 25  }
 26  SyntaxTree::SyntaxTree(){
 27      setRootNode();
 28  }
 29
 30  SyntaxTree::~SyntaxTree(){
 31      if(root != NULL){
 32          delete root;
 33      }
 34  }
 35
 36  /*====================================================================*/
 37
 38  void SyntaxTree::display(SyntaxTreeNode *n, int tabcount, FILE *fo){
 39      static int tab[200];    // is it enough?
 40
 41      SyntaxTreeNode * node = n;
 42      if(node == NULL) return;
 43
 44      if(node->type == NUM){
 45          fprintf(fo, "%-3d", node->value);
 46      }else{
 47          fprintf(fo, "%-3s", tokenToString(node->type));
 48      }
 49
 50      if(node->left != NULL){
 51          tab[tabcount] = 1;
 52      }
 53
 54      if(node->right != NULL){
 55          fprintf(fo, "---");
 56          this->display(node->right, tabcount + 1, fo);
 57      }
 58
 59      if(node->left != NULL){
 60          fprintf(fo, "\n");
 61          for(int i=0;i<tabcount;i++){
 62              if(tab[i] == 1){
 63                  fprintf(fo, "|%5s", "");
 64              }else{
 65                  fprintf(fo, "%6s", "");
 66              }
 67          }
 68          fprintf(fo, "+-----");
 69          tab[tabcount] = 0;
 70          this->display(node->left, tabcount + 1, fo);
 71      }
 72
 73  }
 74
 75  void SyntaxTree::display(FILE *fo){
 76      if(fo == NULL){
 77          fo = stdout;
 78          printf("\nFILE* NULL, will write to STDOUT.\n\n");
 79      }
 80
 81      fprintf(fo, "\n");
 82      this->display(root, 0, fo);
 83      fprintf(fo, "\n");
 84  }
 85
 86
 87  void SyntaxTree::setRootNode(TokenType t, int val){
 88      root = new SyntaxTreeNode(t, val);
 89  }
 90  void SyntaxTree::setRootNode(SyntaxTreeNode *n){
 91      if(n == NULL){
 92          root = new SyntaxTreeNode();
 93      }else{
 94          root = n;
 95      }
 96  }
 97  void SyntaxTree::setRootNode(){
 98      root = new SyntaxTreeNode();
 99  }
100
101
102  void SyntaxTree::addLeft(TokenType t, int val){
103      root->left = new SyntaxTreeNode(t, val);
104  }
105  void SyntaxTree::addLeft(SyntaxTree *n){
106      if(n == NULL) return;
107      root->left = n->getRootNode();
108  }
109
110
111  void SyntaxTree::addRight(TokenType t, int val){
112      root->right = new SyntaxTreeNode(t, val);
113  }
114  void SyntaxTree::addRight(SyntaxTree *n){
115      if(n == NULL) return;
116      root->right = n->getRootNode();
117  }
118
119
120  void SyntaxTree::addChild3(TokenType t, int val){
121      root->child3 = new SyntaxTreeNode(t, val);
122  }
123  void SyntaxTree::addChild3(SyntaxTree *n){
124      if(n == NULL) return;
125      root->child3 = n->getRootNode();
126  }
127
128
129  SyntaxTreeNode* SyntaxTree::getRootNode(){
130      return root;
131  }
132
133
134  SyntaxTree* SyntaxTree::getLeft(){
135      if(root->left == NULL)
136          return NULL;
137      else
138          return new SyntaxTree(root->left);
139  }
140
141  SyntaxTree* SyntaxTree::getRight(){
142      if(root->right == NULL)
143          return NULL;
144      else
145          return new SyntaxTree(root->right);
146  }
147
148
149  SyntaxTree* SyntaxTree::getChild3(){
150      if(root->child3 == NULL)
151          return NULL;
152      else
153          return new SyntaxTree(root->child3);
154  }
155
156  /*==================================================================*/
157
158  char* tokenToString(TokenType type){
159      char *s = NULL;
160      switch(type){
161          case ID:
162              s = "ID";
163              break;
164          case NUM:
165              s = "NUM";
166              break;
167          case IF:
168              s = "if";
169              break;
170          case THEN:
171              s = "thn";
172              break;
173          case ELSE:
174              s = "els";
175              break;
176          case WHILE:
177              s = "whl";
178              break;
179          case DO:
180              s = "do";
181              break;
182          case BEGIN:
183              s = "blk";
184              break;
185          case END:
186              s = "end";  // "end"
187              break;
188          case ASSIGN:
189              s = "'='";
190              break;
191          case EQ:
192              s = "==";
193              break;
194          case LT:
195              s = "'<'";
196              break;
197          case GT:
198              s = "'>'";
199              break;
200          case PLUS:
201              s = "'+'";
202              break;
203          case MUL:
204              s = "'*'";
205              break;
206          case MINUS:
207              s = "'-'";
208              break;
209          case DIV:
210              s = "'/'";
211              break;
212          case OR:
213              s = "'|'";
214              break;
215          case AND:
216              s = "'&'";
217              break;
218          default:
219              s = "undef";
220      }
221      return s;
222  }
223
224
225

Copyright?2006 idea's web. All rights reserved. | www.ideawu.net 









index 
 1  /**************************************************
 2  * file: Parser.h
 3  * date: 2006-04-12
 4  * author: ideawu
 5  * describe: none; parser
 6  **************************************************/
 7
 8  #include "common.h"
 9  #include "Lexer.h"
10  #include "SyntaxTree.h"
11
12
13  class Parser{
14  private:
15      Lexer *lexer;
16      Token currentToken;
17
18      Token nextToken();
19
20      SyntaxTree* Statement();
21      SyntaxTree* Assign();
22      SyntaxTree* Expression();
23          SyntaxTree* T();
24          SyntaxTree* F();
25      SyntaxTree* Condition();
26      SyntaxTree* Boolean();
27          SyntaxTree* T2();
28          SyntaxTree* F2();
29      SyntaxTree* While();
30      SyntaxTree* Begin();
31      SyntaxTree* Block();
32
33      void printError(const char *error);
34
35  public:
36      Parser(char* sourcefile);
37
38      Parser();
39
40      ~Parser();
41
42      void reset();
43
44      void printError();
45
46      SyntaxTree* parse();
47
48      void setLexer(Lexer *srclexer);
49
50  };
51
52
53
54

Copyright?2006 idea's web. All rights reserved. | www.ideawu.net 











index 
  1  /**************************************************
  2  * file: Parser.cpp
  3  * date: 2006-04-12
  4  * author: ideawu
  5  * describe: parser
  6  **************************************************/
  7
  8  //#define TRACE_DEBUG
  9
 10  #ifdef TRACE_DEBUG
 11      #define TRACE(FUNCTION) printf("%-16s token = %s\n", FUNCTION, currentToken.name);