pass2.c

类PASCAL语言的编译器,LINUX环境的,我没试过是否正确.

        CALL(ExamineLevel(scr, &p1data, pass2_list));	/* repeat command */
        if (p1data->code==COMP_ELSE) {
          CALL(Pass2PutArg(scr, label+1));
          CALL(Pass2Put(scr, PASS2_JUMP_OVER_ELSE, p1data, pass2_list, 3));/* Store jump over else */
          CALL(Pass2PutArg(scr, label));
          CALL(Pass2Put(scr, PASS2_LABEL_ELSE, p1data, pass2_list, 0));/* Store else label */
          p1data=p1data->next;				/* eat else */
          p1data=p1data->next;				/* eat open brace */
          CALL(ExamineLevel(scr, &p1data, pass2_list));	/* else */
          CALL(Pass2PutArg(scr, label+1));
          CALL(Pass2Put(scr, PASS2_END_OF_ELSE, p1data, pass2_list, 0));/* Store else label */
        } else {
          CALL(Pass2PutArg(scr, label));
          CALL(Pass2Put(scr, PASS2_LABEL_ELSE, p1data, pass2_list, 0));/* Store else label */
        }
      }
      break;
    case COMP_FOR:
      {
        long label=labelcount;
        struct Pass2Data *stack1, *stack2;
        labelcount++;
        p1data=p1data->next;				/* Eat and forget FOR */
        p1data=p1data->next;				/* eat begin of expression */
        CALL(ParseExpression(scr, &p1data, pass2_list));/* initial expression */
        CALL(Pass2PutArg(scr, label));
        CALL(Pass2Put(scr, PASS2_LABEL_BEGIN, p1data, pass2_list, 0));	/* Store label */
        CALL(Pass2PutArg(scr, level));
        CALL(Pass2Put(scr, PASS2_IFNOT_BRANCH_BREAK, p1data, pass2_list, 3));
        p1data=p1data->next;				/* eat begin of expression */
        CALL(ParseExpression(scr, &p1data, pass2_list));/* condition */
        CALL(Pass2Put(scr, PASS2_END_OF_EXPR, p1data, pass2_list, 1));	/* together with IFNOT */

        stack1=*pass2_list;
        p1data=p1data->next;				/* eat begin of expression */
        CALL(ParseExpression(scr, &p1data, pass2_list));/* repeat command */
        stack2=*pass2_list;
        *pass2_list=stack1;
        level++;
        p1data=p1data->next;				/* eat open brace */
        CALL(ExamineLevel(scr, &p1data, pass2_list));	/* repeat command */
        level--;
        CALL(Pass2PutArg(scr, level));
        CALL(Pass2Put(scr, PASS2_LABEL_CONTINUE, p1data, pass2_list, 0));/* A continue goes here */
        if (stack1!=stack2)
          *pass2_list=stack2;

        CALL(Pass2PutArg(scr, label));
        CALL(Pass2Put(scr, PASS2_GOTO_BEGIN, p1data, pass2_list, 3));	/* Repeat for */
        CALL(Pass2PutArg(scr, level));
        CALL(Pass2Put(scr, PASS2_LABEL_BREAK, p1data, pass2_list, 0));	/* A break goes here */
      }
      break;
    case COMP_CONTINUE:
      p1data=p1data->next;				/* Eat and forget CONTINUE */
      CALL(Pass2PutArg(scr, level));
      CALL(Pass2Put(scr, PASS2_CONTINUE, p1data, pass2_list, 3));
      break;
    case COMP_WHILE:
      {
        long label, label2, label_else;
        struct Pass1Data *stack1;
        label=labelcount;
        labelcount++;
        label2=labelcount;
        labelcount++;
        label_else=labelcount;
        labelcount++;
        p1data=p1data->next;				/* Eat and forget WHILE */
        p1data=p1data->next;				/* eat begin of expression */
        stack1=p1data;
        CALL(Pass2PutArg(scr, label));
        CALL(Pass2Put(scr, PASS2_LABEL_BEGIN, p1data, pass2_list, 0));	/* Store label */
        CALL(Pass2PutArg(scr, label_else));
        CALL(Pass2Put(scr, PASS2_IFNOT_BRANCH_ELSE, p1data, pass2_list, 3));
        CALL(ParseExpression(scr, &p1data, pass2_list));/* condition */
        CALL(Pass2Put(scr, PASS2_END_OF_EXPR, p1data, pass2_list, 1));	/* together with IFNOT */
        CALL(Pass2PutArg(scr, label2));
        CALL(Pass2Put(scr, PASS2_LABEL_BEGIN, p1data, pass2_list, 0));	/* Store label */

        level++;
        p1data=p1data->next;				/* eat open brace */
        CALL(ExamineLevel(scr, &p1data, pass2_list));	/* repeat command */
        CALL(Pass2PutArg(scr, level));
        CALL(Pass2Put(scr, PASS2_LABEL_CONTINUE, p1data, pass2_list, 0));/* A continue goes here */
        level--;

        if (p1data->code==COMP_ELSE) {
          CALL(Pass2PutArg(scr, level));
          CALL(Pass2Put(scr, PASS2_IFNOT_BRANCH_BREAK, stack1, pass2_list, 3));
          CALL(ParseExpression(scr, &stack1, pass2_list));/* condition */
          CALL(Pass2Put(scr, PASS2_END_OF_EXPR, stack1, pass2_list, 1));	/* together with IFNOT */
          CALL(Pass2PutArg(scr, label2));
          CALL(Pass2Put(scr, PASS2_GOTO_BEGIN, stack1, pass2_list, 3));
          p1data=p1data->next;				/* eat else */
          CALL(Pass2PutArg(scr, label_else));
          CALL(Pass2Put(scr, PASS2_LABEL_ELSE, p1data, pass2_list, 0));/* Store else label */
          p1data=p1data->next;				/* eat open brace */
          CALL(ExamineLevel(scr, &p1data, pass2_list));	/* else */
        } else {
          CALL(Pass2PutArg(scr, label));
          CALL(Pass2Put(scr, PASS2_GOTO_BEGIN, p1data, pass2_list, 3));	/* Repeat for */
          CALL(Pass2PutArg(scr, label_else));
          CALL(Pass2Put(scr, PASS2_LABEL_ELSE, p1data, pass2_list, 0));/* Store else label */
        }
        CALL(Pass2PutArg(scr, level));
        CALL(Pass2Put(scr, PASS2_LABEL_BREAK, p1data, pass2_list, 0));	/* A break goes here */
      }
      break;
    case COMP_SWITCH:
      {
        p1data=p1data->next;				/* Eat and forget SWITCH */
        CALL(Pass2Put(scr, PASS2_SWITCH, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat begin of expression */
        CALL(ParseExpression(scr, &p1data, pass2_list));/* initial expression */
        CALL(Pass2Put(scr, PASS2_END_OF_EXPR, p1data, pass2_list, 1));	/* together with SWITCH */
        level++;
        p1data=p1data->next;				/* eat open brace */
        CALL(ExamineLevel(scr, &p1data, pass2_list));	/* repeat command */
        level--;
        CALL(Pass2PutArg(scr, level));
        CALL(Pass2Put(scr, PASS2_LABEL_BREAK, p1data, pass2_list, 0));	/* A break goes here */
      }
      break;
    case COMP_CASE:
      {
        long label=labelcount;
        labelcount++;
        p1data=p1data->next;				/* Eat and forget CASE */
        CALL(Pass2PutArg(scr, label));
        CALL(Pass2Put(scr, PASS2_CASE, p1data, &case_link, 3));
        p1data=p1data->next;				/* eat begin of expression */
        CALL(ParseExpression(scr, &p1data, &case_link));/* initial expression */
        CALL(Pass2Put(scr, PASS2_END_OF_EXPR, p1data, &case_link, 1));	/* together with CASE */
        CALL(Pass2PutArg(scr, label));
        CALL(Pass2Put(scr, PASS2_LABEL, p1data, pass2_list, 0));
      }
      break;
    case COMP_DEFAULT:
      {
        long label=labelcount;
        labelcount++;
        p1data=p1data->next;				/* Eat and forget DEFAULT */
        CALL(Pass2PutArg(scr, label));
        CALL(Pass2Put(scr, PASS2_LABEL_GOTO, p1data, &default_link, 3));
        CALL(Pass2PutArg(scr, label));
        CALL(Pass2Put(scr, PASS2_LABEL, p1data, pass2_list, 0));
      }
      break;
    case COMP_EXIT:
      CALL(Pass2Put(scr, PASS2_EXIT, p1data, pass2_list, 1));
      p1data=p1data->next;				/* Eat and forget EXIT */
      p1data=p1data->next;				/* eat begin of expression */
      CALL(ParseExpression(scr, &p1data, pass2_list));/* initial expression */
      CALL(Pass2Put(scr, PASS2_END_OF_EXPR, p1data, pass2_list, 1));	/* together with EXIT */
      break;
    case COMP_BREAK:
      {
        long count=p1data->num[0];
        p1data=p1data->next;				/* Eat and forget BREAK */
        if (p1data->next->code!=COMP_END_OF_EXPR) {
          CALL(Pass2Put(scr, PASS2_BREAK_EXPR, p1data, pass2_list, 1));
          p1data=p1data->next;				/* eat begin of expression */
          CALL(ParseExpression(scr, &p1data, pass2_list));/* initial expression */
          CALL(Pass2Put(scr, PASS2_END_OF_EXPR, p1data, pass2_list, 1));	/* together with BREAK */
          {
            long downcount=level;
            while (--count>=0) {
              downcount--;
              CALL(Pass2PutArg(scr, downcount));
              CALL(Pass2Put(scr, PASS2_GOTO_BREAK, p1data, pass2_list, 3));
            }
          }
          CALL(Pass2Put(scr, PASS2_END_OF_EXPR, p1data, pass2_list, 1));	/* together with BREAK */
        } else {
          p1data=p1data->next;				/* eat begin of expression */
          p1data=p1data->next;				/* eat end of expression */
          CALL(Pass2PutArg(scr, level-1));
          CALL(Pass2Put(scr, PASS2_GOTO_BREAK, p1data, pass2_list, 3));
        }
      }
      break;
    case COMP_DO:
      {
        long label=labelcount;
        labelcount++;
        p1data=p1data->next;				/* Eat and forget DO */
        p1data=p1data->next;				/* eat begin of expression */
        CALL(Pass2PutArg(scr, label));
        CALL(Pass2Put(scr, PASS2_LABEL_BEGIN, p1data, pass2_list, 0));	/* Store label */
        level++;
        CALL(ExamineLevel(scr, &p1data, pass2_list));	/* repeat command */
        CALL(Pass2PutArg(scr, level));
        CALL(Pass2Put(scr, PASS2_LABEL_CONTINUE, p1data, pass2_list, 0));/* A continue goes here */
        level--;

        CALL(Pass2PutArg(scr, label));
        CALL(Pass2Put(scr, PASS2_IF_BRANCH, p1data, pass2_list, 3));
        p1data=p1data->next;				/* eat while */
        p1data=p1data->next;				/* eat begin of expression */
        CALL(ParseExpression(scr, &p1data, pass2_list));/* repeat command */
        CALL(Pass2Put(scr, PASS2_END_OF_EXPR, p1data, pass2_list, 1));	/* together with IF_BRANCH */

        CALL(Pass2PutArg(scr, level));
        CALL(Pass2Put(scr, PASS2_LABEL_BREAK, p1data, pass2_list, 0));	/* A break goes here */
      }
      break;
    case COMP_RETURN:
      p1data=p1data->next;				/* Eat and forget RETURN */
      CALL(Pass2Put(scr, PASS2_RETURN, p1data, pass2_list, 1));	/* A break goes here */
      p1data=p1data->next;				/* eat begin of expression */
      CALL(ParseExpression(scr, &p1data, pass2_list));/* repeat command */
      CALL(Pass2Put(scr, PASS2_END_OF_EXPR, p1data, pass2_list, 1));	/* together with RETURN */
      break;
    case COMP_RESIZE:
      p1data=p1data->next;				/* Eat and forget RESIZE */
      CALL(HandleReference(scr, &p1data, pass2_list));
      CALL(Pass2Put(scr, PASS2_RESIZE, p1data, pass2_list, 1));
      do {
        p1data=p1data->next; 				/* eat start of expr */
        CALL(Pass2Put(scr, PASS2_OPEN_BRACKET, p1data, pass2_list, 1));
        CALL(ParseExpression(scr, &p1data, pass2_list));
        CALL(Pass2Put(scr, PASS2_CLOSE_BRACKET, p1data, pass2_list, 1));
      } while (p1data->code==COMP_START_OF_EXPR);
      break;
    default:
      {
        register struct Pass1Data *oldp1=p1data;
        CALL(ParseExpression(scr, &p1data, pass2_list));/* parse expression */
        if (p1data==oldp1) {
          printf("UNKNOWN CODE (%d)(no %d)\n", p1data->code, p1data->counter);
          exit(0);
        }
      }
      break;
    }
  } while (p1data && !stop);
#if 0
  if (!p1data && !level) {
    struct Pass2Data *declare_link=&main_declare_link_first;
    while (declare_link->next)
      declare_link=declare_link->next;
    CALL(Pass2PutArg(scr, main_label_number));
    CALL(Pass2Put(scr, PASS2_MAIN_START, p1data, &declare_link, 3));
    if (main_declare_link_first.next) {
      struct Pass2Data *temp=&pass2_first_data;
      CALL(Pass2Link(scr, &temp, main_declare_link_first.next));
      main_declare_link_first.next=NULL;
    }
    CALL(Pass2Put(scr, PASS2_MAIN_END, p1data, pass2_list, 0));
    if (function_contain_link_first.next) {
      CALL(Pass2Link(scr, pass2_list, function_contain_link_first.next));
      function_contain_link_first.next=NULL;
    }
    CALL(Pass2Put(scr, PASS2_MAIN_END, p1data, pass2_list, 0));
    CALL(Pass2Put(scr, PASS2_MAIN_END, p1data, pass2_list, 0));
    CALL(Pass2Put(scr, PASS2_MAIN_END, p1data, pass2_list, 0));
  }
#endif
  if (case_link_first.next || default_link_first.next) {
    CALL(Pass2PutArg(scr, level));
    CALL(Pass2Put(scr, PASS2_LABEL_BREAK, p1data, pass2_list, 0));
    if (default_link_first.next) {
      CALL(Pass2Link(scr, &case_link, default_link_first.next));
      default_link_first.next=NULL;
    } else {
      CALL(Pass2PutArg(scr, level));
      CALL(Pass2Put(scr, PASS2_GOTO_BREAK, p1data, &case_link, 3));
    }
    if (case_link_first.next) {
      CALL(Pass2Link(scr, &initial_link, case_link_first.next));
      case_link_first.next=NULL;
    }
  }
  if (!p1data) {
    if (main_declare_link_first.next) {
      struct Pass2Data *temp=&pass2_first_data;
      CALL(Pass2Link(scr, &temp, main_declare_link_first.next));
      main_declare_link_first.next=NULL;
    }
    if (function_declare_link_first.next) {
      CALL(Pass2Link(scr, &function_start, function_declare_link_first.next));
    }
    function_declare_link=&function_declare_link_first;
    function_declare_link_first.next=NULL;
    if (function_contain_link_first.next) {
      CALL(Pass2Link(scr, pass2_list, function_contain_link_first.next));
      function_contain_link_first.next=NULL;
    }
  }
  *p1datapek=p1data;
  return FPL_OK;
}

ReturnCode Pass2Start(struct Data *scr)
{
  ReturnCode ret;
  struct Pass1Data *p1data=first_data.next;
  struct Pass2Data *pass2_list=&pass2_first_data;

  memset(&pass2_first_data, 0, sizeof(struct Pass2Data));
  memset(&pass2_current_data, 0, sizeof(struct Pass2Data));
  
  memset(&main_declare_link_first,0, sizeof(struct Pass2Data));
  memset(&function_declare_link_first, 0, sizeof(struct Pass2Data));
  memset(&function_contain_link_first, 0, sizeof(struct Pass2Data));
  main_declare_link=&main_declare_link_first;
  function_declare_link=&function_declare_link_first;
  function_contain_link=&function_contain_link_first;
  function_start=NULL;
  
  mainlevel=0;
  level=0;
  labelcount=0;
  total_number_of_variables=0;
  total_number_of_functions=0;
  max_level=0;
  
  CALL(ExamineLevel(scr, &p1data, &pass2_list));
  CALL(Pass2PushPut(scr, &pass2_list));		/* flush list */
  return FPL_OK;
}