pass3.c

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

}

ReturnCode Pass3Examine(struct Data *scr, struct Pass2Data *pass2_data)
{
  ReturnCode ret;
  long local_varcount=0;
  long global_varcount=0;
  long declare_hit=0;
  long line_number=0;

  while (pass2_data) {
    if (scr->cmdline[LINE_DEBUG]&DEBUG_LINE) {
      if (line_number!=pass2_data->line) {
        line_number=pass2_data->line;
        CALL(Pass3PushLineNumber(scr, line_number));
      }
    }
    switch (pass2_data->code) {
    case PASS2_DECLARE:
      if (pass2_data->num[0]&FPL_EXPORT_SYMBOL) {
        pass2_data->flags&=~P2D_FLAG_NUM1; /* remove num */
        pass2_data->final_size=5;
        CALL(Pass3PushPut(scr, pass2_data));
        CALL(Pass3PutString(scr, pass3_last_data, pass2_data->num[1], TRUE, 0, STRING_IS_VARIABLE|STRING_IS_DECLARED));
        pass2_data=pass2_data->next;
      } else {
        long start_type=pass2_data->num[0];
        long start_num=local_varcount;
        if (start_type&FPL_GLOBAL_SYMBOL)
          start_num=global_varcount;
        while (pass2_data->code==PASS2_DECLARE &&
               pass2_data->num[0]==start_type) {
          if (start_type&FPL_GLOBAL_SYMBOL) {
            var_global_number[pass2_data->num[1]]=global_varcount;
            global_varcount++;
          } else {
            var_local_number[pass2_data->num[1]]=local_varcount;
            local_varcount++;
          }
          pass2_data=pass2_data->next;
        }
        CALL(Pass3PutArg(scr, start_type, &pass3_current_data)); /* Push type */
        CALL(Pass3PutArg(scr, start_num, &pass3_current_data)); /* Push start number */
        if (start_type&FPL_GLOBAL_SYMBOL) {
          CALL(Pass3PutArg(scr, global_varcount-start_num, &pass3_current_data)); /* Push number of variables*/
        } else {
          CALL(Pass3PutArg(scr, local_varcount-start_num, &pass3_current_data)); /* Push number of variables*/
        }
        CALL(Pass3Put(scr, PASS2_DECLARE, &pass3_current_data, 7));
        if (declare_hit) { /* if we have a former declare, lets swap them 
                              in order to get the declare with the higher
                              numbers first. */
          pass3_last_data->next=pass3_last_data->prev;
          pass3_last_data->prev->prev->next=pass3_last_data;
          pass3_last_data->prev->prev=pass3_last_data;
          pass3_last_data->prev->next=NULL;
          pass3_last_data->prev=pass3_last_data->next->prev;
          pass3_last_data=pass3_last_data->next;
        }
      }
      declare_hit=2; /* Remember we found a declare */
      break;
    case PASS2_END_OF_FUNCTION:
    case PASS2_MAIN_END:
      local_varcount=0;
      pass2_data=pass2_data->next;
      break;
    case PASS2_REF_LOCAL_SYMBOL:
    case PASS2_ASSIGN_LOCAL_SYMBOL:  /* [var num] [assign type] */
    case PASS2_ASSIGN_ARGUMENT: /* [var number], [arg number] */
    case PASS2_RESET_VARIABLE: /* [var number] */
      pass2_data->num[0]=var_local_number[pass2_data->num[0]];
      CALL(Pass3PushPut(scr, pass2_data));
      pass2_data=pass2_data->next;
      break;
    case PASS2_REF_GLOBAL_SYMBOL:
    case PASS2_ASSIGN_GLOBAL_SYMBOL:  /* [var num] [assign type] */
      pass2_data->num[0]=var_global_number[pass2_data->num[0]];
      CALL(Pass3PushPut(scr, pass2_data));
      pass2_data=pass2_data->next;
      break;
    case PASS2_REF_EXPORT_SYMBOL:
    case PASS2_ASSIGN_EXPORT_SYMBOL: /* [hash num] [assign type] [name] */
      {
        long num;
        num=Pass3FindLocalIdentifier(pass2_data->string[0]);
        if (num<0) {
          pass2_data->flags&=~P2D_FLAG_NUM0; /* remove num */
          CALL(Pass3PushPut(scr, pass2_data));
          CALL(Pass3PutString(scr, pass3_last_data, pass2_data->num[0], TRUE, 0, STRING_IS_VARIABLE));
        } else {
          if (pass2_data->code==PASS2_REF_EXPORT_SYMBOL)
            pass2_data->code=PASS2_REF_GLOBAL_SYMBOL; /* [function/var number] */
          else
            pass2_data->code=PASS2_ASSIGN_GLOBAL_SYMBOL; /* [function/var number] */
          pass2_data->flags&=~P2D_FLAG_STRING; /* remove num */
          pass2_data->num[0]=num;
          CALL(Pass3PushPut(scr, pass2_data));
        }
      }
      pass2_data=pass2_data->next;
      break;

    case PASS2_CALL_EXPORT_FUNCTION:
      {
        long num;
        num=Pass3FindLocalIdentifier(pass2_data->string[0]);
        if (num<0) {
          pass2_data->flags&=~P2D_FLAG_NUM0; /* remove num */
          CALL(Pass3PushPut(scr, pass2_data));
          CALL(Pass3PutString(scr, pass3_last_data, pass2_data->num[0], TRUE, 0, STRING_IS_FUNCTION));
        } else {
          pass2_data->code=PASS2_CALL_LOCAL_FUNCTION; /* [function/var number] */
          pass2_data->flags&=~P2D_FLAG_STRING; /* remove num */
          pass2_data->num[0]=num;
          CALL(Pass3PushPut(scr, pass2_data));
          CALL(Pass3PutLabelRef(scr, function_list,
                                pass2_data->num[0], &pass3_last_data->num[0]));
        }
      }
      pass2_data=pass2_data->next;
      break;

    case PASS2_LABEL_BEGIN:	/* [number] */
      CALL(Pass3PushPut(scr, pass2_data));
      label_list[pass2_data->num[0]].label_offset=pass3_last_data->final_offset;
      pass2_data=pass2_data->next;
      break;

    case PASS2_LABEL:
    case PASS2_LABEL_ELSE:		/* else [number]*/
    case PASS2_END_OF_ELSE:	/* else [number]*/
      CALL(Pass3PushPut(scr, pass2_data));
      label_list[pass2_data->num[0]].label_offset=pass3_last_data->final_offset;
      pass2_data=pass2_data->next;
      break;

    case PASS2_FUNCTION_START: /* [label/var number] */
      CALL(Pass3PushPut(scr, pass2_data));
      function_list[pass2_data->num[0]].label_offset=pass3_last_data->final_offset;
      pass2_data=pass2_data->next;
      break;

    case PASS2_LABEL_CONTINUE:	/* [level] */
      CALL(Pass3PushPut(scr, pass2_data));
      continue_list[pass2_data->num[0]].label_offset=pass3_last_data->final_offset;
      CALL(Pass3ExtractLabelRef(scr, continue_list, pass2_data->num[0]));
      pass2_data=pass2_data->next;
      break;

    case PASS2_LABEL_BREAK:	/* [level] */
      CALL(Pass3PushPut(scr, pass2_data));
      break_list[pass2_data->num[0]].label_offset=pass3_last_data->final_offset;
      CALL(Pass3ExtractLabelRef(scr, break_list, pass2_data->num[0]));
      pass2_data=pass2_data->next;
      break;

    case PASS2_CONTINUE: /* level */
      pass2_data->code=PASS2_LABEL_GOTO;
      CALL(Pass3PushPut(scr, pass2_data));
      CALL(Pass3PutLabelRef(scr, continue_list,
                            pass2_data->num[0], &pass3_last_data->num[0]));
      pass2_data=pass2_data->next;
      break;

    case PASS2_GOTO_BEGIN:	/* [number] */
      pass2_data->code=PASS2_LABEL_GOTO;
      /* falling down */
    case PASS2_MAIN_START:	/* [label number] */
    case PASS2_IF_BRANCH:	/* if branch [label] */
    case PASS2_CASE:	/* [label number] */
    case PASS2_LABEL_GOTO:	/* [number] */
    case PASS2_CONDOPSTART:
    case PASS2_LOGICOR:
    case PASS2_LOGICAND:
      CALL(Pass3PushPut(scr, pass2_data));
      CALL(Pass3PutLabelRef(scr, label_list,
                            pass2_data->num[0], &pass3_last_data->num[0]));
      pass2_data=pass2_data->next;
      break;
    case PASS2_JUMP_OVER_ELSE:	/* [number] jump over else */
      pass2_data->code=PASS2_LABEL_GOTO;
      CALL(Pass3PushPut(scr, pass2_data));
      CALL(Pass3PutLabelRef(scr, label_list,
                            pass2_data->num[0], &pass3_last_data->num[0]));
      pass2_data=pass2_data->next;
      break;
    case PASS2_IFNOT_BRANCH_ELSE:/* if not branch to else */
      pass2_data->code=PASS2_IFNOT_BRANCH;
      CALL(Pass3PushPut(scr, pass2_data));
      CALL(Pass3PutLabelRef(scr, label_list,
                            pass2_data->num[0], &pass3_last_data->num[0]));
      pass2_data=pass2_data->next;
      break;

    case PASS2_GOTO_BREAK:	/* [level] */
      pass2_data->code=PASS2_LABEL_GOTO;
      CALL(Pass3PushPut(scr, pass2_data));
      CALL(Pass3PutLabelRef(scr, break_list,
                            pass2_data->num[0], &pass3_last_data->num[0]));
      pass2_data=pass2_data->next;
      break;
    case PASS2_IFNOT_BRANCH_BREAK:/* [level] if not branch to break */
      pass2_data->code=PASS2_IFNOT_BRANCH;
      CALL(Pass3PushPut(scr, pass2_data));
      CALL(Pass3PutLabelRef(scr, break_list,
                            pass2_data->num[0], &pass3_last_data->num[0]));
      pass2_data=pass2_data->next;
      break;

    case PASS2_LOCAL_FUNCTION: /* [type], [number], [offset] */
      printf("No local symbol\n");
      exit(0);
    case PASS2_EXPORT_FUNCTION: /* [type], [num], [hash], [offset] */
      pass2_data->flags&=~P2D_FLAG_NUM2; /* remove hash */
      CALL(Pass3PushPut(scr, pass2_data));
      CALL(Pass3PutString(scr, pass3_last_data, pass2_data->num[2], TRUE, 0, STRING_IS_FUNCTION|STRING_IS_DECLARED));
      CALL(Pass3PutLabelRef(scr, label_list,
                            pass2_data->num[1], &pass3_last_data->num[1]));
      CALL(Pass3PutString(scr, pass3_last_data, pass2_data->num[2], FALSE, 1, STRING_IS_CONSTANT|STRING_IS_DECLARED));
      CALL(Pass3PutLabelRef(scr, label_list,
                            pass2_data->num[1], &pass3_last_data->num[1]));
      pass2_data=pass2_data->next;
      break;
    case PASS2_STRING_CONSTANT:
    case PASS2_TYPE_OF_ARGUMENTS:
      CALL(Pass3PushPut(scr, pass2_data));
      CALL(Pass3PutString(scr, pass3_last_data, 0, FALSE, 0, STRING_IS_CONSTANT|STRING_IS_DECLARED));
      pass2_data=pass2_data->next;
      break;
  

/* Don't change the syntax on these commands*/  
    case PASS2_POSTINC:
    case PASS2_POSTDEC:
    case PASS2_PREINC:
    case PASS2_PREDEC:
    case PASS2_CONTENTSOF:
    case PASS2_NUM_CONSTANT:
    case PASS2_OPEN_PAREN:
    case PASS2_CLOSE_PAREN:
    case PASS2_ONCECOMPLEMENT:
    case PASS2_NOTOPERATOR:
    case PASS2_NEGATE:
  
    case PASS2_COMMA:
    case PASS2_NOTEQUAL:
    case PASS2_GREATER:
    case PASS2_SHIFTRIGHT:
    case PASS2_GREATEQ:
    case PASS2_LESS:
    case PASS2_SHIFTLEFT:
    case PASS2_LESSEQ:
    case PASS2_XOR:
    case PASS2_REMAIN:
    case PASS2_DIVISION:
    case PASS2_MULTIPLY:
    case PASS2_MINUS:
    case PASS2_PLUS:
    case PASS2_BINARYOR:
    case PASS2_BINARYAND:
    case PASS2_EQUAL:
    case PASS2_STRING_APPEND:
  
    case PASS2_END_OF_EXPR:
  
    case PASS2_BREAK_EXPR: /* Followed by an expression and several GOTO_BREAK and END_OF_EXPR */
    case PASS2_RETURN:
    case PASS2_SWITCH:
  
    case PASS2_RESIZE:
    case PASS2_OPEN_BRACKET:
    case PASS2_CLOSE_BRACKET:

    case PASS2_CALL_INTERNAL_FUNCTION:
  
    case PASS2_OPEN_BRACE:
    case PASS2_CLOSE_BRACE:
  
    case PASS2_EXIT: /* expression */
    case PASS2_VARIABLE_REFERENCE:
    case PASS2_AMOUNT_VARIABLES:

    default:
      CALL(Pass3PushPut(scr, pass2_data));
      pass2_data=pass2_data->next;
      break;
    }
    if (declare_hit) /* Keep track of the declares */
      declare_hit--;
#if 0
    {
      static long count=0;
      count++;
      if (continue_list[2].next!=0) {
        printf("Potential %d\n", count);
      }
      if (count==6642 || count==6055) {
        printf("here %d\n", count);
        if (DBG_MemListCheck(__FILE__, __LINE__)) {
          printf("\nMEMORY ERROR %ld  \n", count);
          exit(0);
        }
      }
    }
#endif
  }
  {
    long count;
    for (count=0; count<=labelcount; count++) {
      CALL(Pass3ExtractLabelRef(scr, label_list, count));
    }
  }
  {
    long count;
    for (count=0; count<=max_level; count++) {
      CALL(Pass3ExtractLabelRef(scr, continue_list, count));
    }
  }
  {
    long count;
    for (count=0; count<=total_number_of_functions; count++) {
      CALL(Pass3ExtractLabelRef(scr, function_list, count));
    }
  }
  {
    struct Pass3String *count;
    count=pass3_first_string.next;
    while (count) {
      count->offset=final_offset_count;
      count->references.label_offset=count->offset;
      final_offset_count+=count->total_length+sizeof(long);
      CALL(Pass3ExtractLabelRef(scr, &count->references, 0));
      count=count->next;
    }
  }
  return FPL_OK;
}

ReturnCode Pass3Start(struct Data *scr, char *file, char *origfile)
{
  ReturnCode ret;

  Pass3CheckSystem();
  CALL(Pass3Open(scr, file));
  CALL(Pass3Examine(scr, pass2_first_data.next));
  CALL(Pass3Close(scr, file, origfile));

  return FPL_OK;
}