util.c

小型编译器,可以用于测试使用

/****************************************************/
/* File: util.c                                     */
/* Utility function implementation                  */
/* for the TINY compiler                            */
/* Compiler Construction: Principles and Practice   */
/* Kenneth C. Louden                                */
/****************************************************/

#include "globals.h"
#include "util.h"

/* Procedure printToken prints a token 
 * and its lexeme to the listing file
 */
void printToken( TokenType token, const char* tokenString )
{ char *err;
	static i;
	switch (token)
	{ case IF:
    case THEN:
    case ELSE:
    case END:
    case REPEAT:
    case UNTIL:
    case READ:
    case WRITE:
	case BTRUE:
	case BFALSE:
	case OR:
	case AND:
	case NOT:
	case INT:
	case BOOL:
	case STRING:
	case WHILE:
	case DO:
      fprintf(listing,
         "(KEY,%s)\n",tokenString);
      break;
    case ASSIGN:
    case LT:
    case EQ:
	case GT:
	case LE:
	case GE:
	case COMMA:
    case LPAREN:
    case RPAREN:
    case SEMI:
    case PLUS:
    case MINUS:
    case TIMES:
    case OVER:
		fprintf(listing,
			"(SYM,%s)\n",tokenString);
		break;
    case NUM:
      fprintf(listing,
          "(NUM,%s)\n",tokenString);
      break;
    case ID:
      fprintf(listing,
          "(ID,%s)\n",tokenString);
      break;
	case STR:
		fprintf(listing,"(STR,%s)\n",tokenString);
		break;
	case ENDFILE:
		fprintf(listing,"(EOF)\n");
		break;
    case ERROR:
	  switch(errortype)
	  {
	  case 1:
		  err = "unknown character";
		  break;
	  case 2:
		  err = "comment missing \'}\'";
		  break;
	  case 3:
		  err = "string missing right quotation";
		  break;
	  default:
		  err = "unknown lexical error";
	  }
      fprintf(listing,
          "Lexical error: %s: \"%s\"\n",err,tokenString);
      break;
	}
}

/* Function newStmtNode creates a new statement
 * node for syntax tree construction
 */
TreeNode * newStmtNode(StmtKind kind)
{ TreeNode * t = (TreeNode *) malloc(sizeof(TreeNode));
  int i;
  if (t==NULL)
    fprintf(listing,"Out of memory error at line %d\n",lineno);
  else {
    for (i=0;i<MAXCHILDREN;i++) t->child[i] = NULL;
    t->sibling = NULL;
    t->nodekind = StmtK;
    t->kind.stmt = kind;
    t->lineno = lineno;
  }
  return t;
}

/* Function newExpNode creates a new expression 
 * node for syntax tree construction
 */
TreeNode * newExpNode(ExpKind kind)
{ TreeNode * t = (TreeNode *) malloc(sizeof(TreeNode));
  int i;
  if (t==NULL)
    fprintf(listing,"Out of memory error at line %d\n",lineno);
  else {
    for (i=0;i<MAXCHILDREN;i++) t->child[i] = NULL;
    t->sibling = NULL;
    t->nodekind = ExpK;
    t->kind.exp = kind;
    t->lineno = lineno;
    t->type = Void;
  }
  return t;
}

/* Function copyString allocates and makes a new
 * copy of an existing string
 */
char * copyString(char * s)
{ int n;
  char * t;
  if (s==NULL) return NULL;
  n = strlen(s)+1;
  t = malloc(n);
  if (t==NULL)
    fprintf(listing,"Out of memory error at line %d\n",lineno);
  else strcpy(t,s);
  return t;
}

/* Variable indentno is used by printTree to
 * store current number of spaces to indent
 */
static indentno = 0;

/* macros to increase/decrease indentation */
#define INDENT indentno+=2
#define UNINDENT indentno-=2

/* printSpaces indents by printing spaces */
static void printSpaces(void)
{ int i;
  for (i=0;i<indentno;i++)
    fprintf(listing," ");
}

/* procedure printTree prints a syntax tree to the 
 * listing file using indentation to indicate subtrees
 */
void printTree( TreeNode * tree )
{ int i;
  INDENT;
  while (tree != NULL) {
    printSpaces();
    if (tree->nodekind==StmtK)
    { switch (tree->kind.stmt) {
        case IfK:
          fprintf(listing,"If\n");
          break;
        case RepeatK:
          fprintf(listing,"Repeat\n");
          break;
        case AssignK:
          fprintf(listing,"Assign to: %s\n",tree->attr.name);
          break;
        case ReadK:
          fprintf(listing,"Read: %s\n",tree->attr.name);
          break;
        case WriteK:
          fprintf(listing,"Write\n");
          break;
		case WhileK:		//增加
			fprintf(listing,"While\n");
			break;
        default:
          fprintf(listing,"Unknown ExpNode kind\n");
          break;
      }
    }
    else if (tree->nodekind==ExpK)
    { 
		char *tokenString;
		switch (tree->kind.exp) {
        case OpK:
          fprintf(listing,"Op: ");
		  //修改
		  switch (tree->attr.op){
		  case PLUS:
			tokenString = "+";
			break;
		  case MINUS:
			tokenString = "-";
			break;
		  case TIMES:
			tokenString = "*";
			break;
		  case OVER:
			tokenString = "/";
			break;
		  case AND:
			tokenString = "and";
			break;
		  case OR:
			tokenString = "or";
			break;
		  case NOT:
			tokenString = "not";
			break;
		  case LT:
			tokenString = "<";
			break;
		  case LE:
			tokenString = "<=";
			break;
		  case EQ:
			tokenString = "=";
			break;
		  case GT:
			tokenString = ">";
			break;
		  case GE:
			tokenString = ">=";
			break;
		  }
		  printToken(tree->attr.op,tokenString);
          break;
        case ConstK:
          fprintf(listing,"Const: %d\n",tree->attr.val);
          break;
        case IdK:
          fprintf(listing,"Id: %s\n",tree->attr.name);
          break;
		case StrK:		//增加
			fprintf(listing,"String: %s\n",tree->attr.name);
			break;
		case BoolK:		//增加
			if(tree->attr.val == 1)
				fprintf(listing,"Boolean: %s\n","true");
			else
				fprintf(listing,"Boolean: %s\n","false");
			break;
        default:
          fprintf(listing,"Unknown ExpNode kind\n");
          break;
      }
    }
    else fprintf(listing,"Unknown node kind\n");
    for (i=0;i<MAXCHILDREN;i++)
         printTree(tree->child[i]);
    tree = tree->sibling;
  }
  UNINDENT;
}