pass2.c

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

  ReturnCode Pass2PutString(struct Data *scr, char *arg, long len)
{
  ReturnCode ret;
  short num=0;
  if (pass2_current_data.flags&P2D_FLAG_STRING) {
    num=1;
    pass2_current_data.flags|=P2D_FLAG_STRING2;
  }
  pass2_current_data.string[num]=arg;
  pass2_current_data.strlen[num]=len;
  pass2_current_data.flags|=P2D_FLAG_STRING;
  return FPL_OK;
}

BOOL GetOper(void *user, struct Oper *oper, char index)
{
  return TRUE;
}
void PutOper(void *user, struct Oper *oper, char step)
{
}

  static ReturnCode ParseExpression(struct Data *scr, struct Pass1Data **p1datapek,
                                    struct Pass2Data **pass2_list)
{
  ReturnCode ret;
  struct Pass1Data *p1data=*p1datapek;
  char stop=FALSE;
  char loop;
  long logic_or_label=labelcount++, logic_and_label=0;
  if (p1data->code==COMP_END_OF_EXPR) {
    stop=TRUE;
    p1data=p1data->next;				/* eat me */
  }
  while (!stop) {
    do {
      loop=FALSE;
      switch(p1data->code) {
      case COMP_REF_LOCAL_SYMBOL: /* refers to a local symbol, number follows! */
      case COMP_REF_GLOBAL_SYMBOL: /* refers to a local symbol, number follows! */
      case COMP_REF_EXPORT_SYMBOL: /* refers to a export symbol, hash and name */
        CALL(HandleReference(scr, &p1data, pass2_list));
        break;
      case COMP_CALL_FUNCTION:
      case COMP_CALL_INTERNAL_FUNCTION:
        CALL(HandleFunctionCall(scr, &p1data, pass2_list));
        break;
      case COMP_OPEN_BRACE:	/* Only for assigns of arrays */
        p1data=p1data->next;				/* eat open brace */
        CALL(Pass2Put(scr, PASS2_OPEN_BRACE, p1data, pass2_list, 1));
        CALL(ParseExpression(scr, &p1data, pass2_list));
        p1data=p1data->next;				/* eat close brace */
        CALL(Pass2Put(scr, PASS2_CLOSE_BRACE, p1data, pass2_list, 1));
        break;
      case COMP_START_OF_EXPR:	/* Only for assigns of arrays */
        p1data=p1data->next;				/* eat start of expr */
        CALL(ParseExpression(scr, &p1data, pass2_list));
        CALL(Pass2Put(scr, PASS2_END_OF_EXPR, p1data, pass2_list, 1));
        break;
      case COMP_OPEN_PAREN:
        CALL(Pass2Put(scr, PASS2_OPEN_PAREN, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat open paren */
        CALL(ParseExpression(scr, &p1data, pass2_list));
/*        CALL(Pass2Put(scr, PASS2_END_OF_EXPR, p1data, pass2_list, 1)); 960306 */
        break;
      case COMP_NUM_CONSTANT:
        CALL(Pass2PutArg(scr, p1data->num[0]));
        CALL(Pass2Put(scr, PASS2_NUM_CONSTANT, p1data, pass2_list, 3));
        p1data=p1data->next;				/* eat me */
        break;
      case COMP_STRING_CONSTANT:
        CALL(Pass2PutString(scr, p1data->string, p1data->strlen));
        CALL(Pass2Put(scr, PASS2_STRING_CONSTANT, p1data, pass2_list, 3));
        p1data=p1data->next;				/* eat me */
        break;
      case COMP_CLOSE_BRACKET: /* ] */
        stop=TRUE;
        p1data=p1data->next;				/* eat me */
        break;
      case COMP_VARIABLE_REFERENCE:
        CALL(Pass2Put(scr, PASS2_VARIABLE_REFERENCE, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat me */
        loop=TRUE;
        break;
      case COMP_PREINC:
        CALL(Pass2Put(scr, PASS2_PREINC, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat me */
        loop=TRUE;
        break;
      case COMP_PREDEC:
        CALL(Pass2Put(scr, PASS2_PREDEC, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat me */
        loop=TRUE;
        break;
      case COMP_CONTENTSOF:
        CALL(Pass2Put(scr, PASS2_CONTENTSOF, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat me */
        loop=TRUE;
        break;
      case COMP_ONCECOMPLEMENT:
        CALL(Pass2Put(scr, PASS2_ONCECOMPLEMENT, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat me */
        loop=TRUE;
        break;
      case COMP_NOTOPERATOR:
        CALL(Pass2Put(scr, PASS2_NOTOPERATOR, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat me */
        loop=TRUE;
        break;
      case COMP_NEGATE:
        CALL(Pass2Put(scr, PASS2_NEGATE, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat me */
        loop=TRUE;
        break;
      }
    } while(loop);
    if (!stop) {
      switch(p1data->code) {
      case COMP_END_OF_EXPR:
        stop=TRUE;
        p1data=p1data->next;				/* eat me */
        break;
      case COMP_COMMA:
        CALL(Pass2Put(scr, PASS2_COMMA, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat me */
        break;
  
      case COMP_NOTEQUAL:
        CALL(Pass2Put(scr, PASS2_NOTEQUAL, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat me */
        break;
      case COMP_GREATER:
        CALL(Pass2Put(scr, PASS2_GREATER, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat me */
        break;
      case COMP_SHIFTRIGHT:
        CALL(Pass2Put(scr, PASS2_SHIFTRIGHT, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat me */
        break;
      case COMP_GREATEQ:
        CALL(Pass2Put(scr, PASS2_GREATEQ, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat me */
        break;
      case COMP_LESS:
        CALL(Pass2Put(scr, PASS2_LESS, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat me */
        break;
      case COMP_SHIFTLEFT:
        CALL(Pass2Put(scr, PASS2_SHIFTLEFT, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat me */
        break;
      case COMP_LESSEQ:
        CALL(Pass2Put(scr, PASS2_LESSEQ, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat me */
        break;
      case COMP_XOR:
        CALL(Pass2Put(scr, PASS2_XOR, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat me */
        break;
      case COMP_REMAIN:
        CALL(Pass2Put(scr, PASS2_REMAIN, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat me */
        break;
      case COMP_DIVISION:
        CALL(Pass2Put(scr, PASS2_DIVISION, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat me */
        break;
      case COMP_MULTIPLY:
        CALL(Pass2Put(scr, PASS2_MULTIPLY, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat me */
        break;
      case COMP_MINUS:
        CALL(Pass2Put(scr, PASS2_MINUS, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat me */
        break;
      case COMP_PLUS:
        CALL(Pass2Put(scr, PASS2_PLUS, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat me */
        break;
      case COMP_BINARYOR:
        CALL(Pass2Put(scr, PASS2_BINARYOR, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat me */
        break;
      case COMP_BINARYAND:
        CALL(Pass2Put(scr, PASS2_BINARYAND, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat me */
        break;
      case COMP_EQUAL:
        CALL(Pass2Put(scr, PASS2_EQUAL, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat me */
        break;
      case COMP_LOGICOR:
        CALL(Pass2PutArg(scr, logic_or_label));
        CALL(Pass2Put(scr, PASS2_LOGICOR, p1data, pass2_list, 3));
        if (logic_and_label) {
          CALL(Pass2PutArg(scr, logic_and_label));
          CALL(Pass2Put(scr, PASS2_LABEL, p1data, pass2_list, 0));
          logic_and_label=0;
        }
        p1data=p1data->next;				/* eat me */
        break;
      case COMP_LOGICAND:
        if (!logic_and_label) {
          logic_and_label=labelcount;
          labelcount++;
        }
        CALL(Pass2PutArg(scr, logic_and_label));
        CALL(Pass2Put(scr, PASS2_LOGICAND, p1data, pass2_list, 3));
        p1data=p1data->next;				/* eat me */
        break;
  
      case COMP_APPEND_STRING:
        CALL(Pass2Put(scr, PASS2_STRING_APPEND, p1data, pass2_list, 1));
        p1data=p1data->next;				/* eat me */
        break;
  
      case COMP_CONDOPSTART:
        {
          long label=labelcount;
          long label2;
          labelcount++;
          CALL(Pass2PutArg(scr, label));
          CALL(Pass2Put(scr, PASS2_CONDOPSTART, p1data, pass2_list, 3));
          p1data=p1data->next;				/* eat me */
          p1data=p1data->next;				/* eat start of expr */
          CALL(ParseExpression(scr, &p1data, pass2_list));
          label2=labelcount;
          labelcount++;
          CALL(Pass2PutArg(scr, label2));
          CALL(Pass2Put(scr, PASS2_LABEL_GOTO, p1data, pass2_list, 3));
          CALL(Pass2PutArg(scr, label));
          CALL(Pass2Put(scr, PASS2_LABEL, p1data, pass2_list, 0));
          p1data=p1data->next;				/* eat condopend */
          p1data=p1data->next;				/* eat start of expr */
          CALL(ParseExpression(scr, &p1data, pass2_list));
          CALL(Pass2PutArg(scr, label2));
          CALL(Pass2Put(scr, PASS2_LABEL, p1data, pass2_list, 0));
        }
        break;

      case COMP_CLOSE_PAREN:
        CALL(Pass2Put(scr, PASS2_CLOSE_PAREN, p1data, pass2_list, 1));
        stop=TRUE;
        p1data=p1data->next;				/* eat me */
        break;

      case COMP_CLOSE_BRACKET: /* ] */
        stop=TRUE;
        p1data=p1data->next;				/* eat me */
        break;

      default:
#ifdef DEBUG_OUTPUT
        if (scr->cmdline[LINE_VERBOSE]&VERBOSE_PASS2)
          printf("UNKNOWN EXPRESSION CODE (%d)(no %d)\n", p1data->code, p1data->counter);
#endif
        stop=TRUE;
        break;
      }
    }
  }
  if (logic_and_label) {
    CALL(Pass2PutArg(scr, logic_and_label));
    CALL(Pass2Put(scr, PASS2_LABEL, p1data, pass2_list, 0));
  }
  if (logic_or_label) {
    CALL(Pass2PutArg(scr, logic_or_label));
    CALL(Pass2Put(scr, PASS2_LABEL, p1data, pass2_list, 0));
  }
  *p1datapek=p1data;
  return FPL_OK;
}

static ReturnCode HandleFunctionCall(struct Data *scr, struct Pass1Data **p1datapek,
                                     struct Pass2Data **pass2_list)
{
  ReturnCode ret;
  struct Pass1Data *p1data=*p1datapek;
  struct Pass2Data *p2_stack;

  switch (p1data->code) {
  case COMP_CALL_INTERNAL_FUNCTION:
    CALL(Pass2PutArg(scr, p1data->num[0]));
    CALL(Pass2Put(scr, PASS2_CALL_INTERNAL_FUNCTION, p1data, pass2_list, 3));
    break;
  case COMP_CALL_FUNCTION:
    CALL(Pass2PutString(scr, p1data->string, p1data->strlen));
    CALL(Pass2PutArg(scr, p1data->num[0]));
    CALL(Pass2Put(scr, PASS2_CALL_EXPORT_FUNCTION, p1data, pass2_list, 3));
    break;
  }
  p2_stack=*pass2_list;

  p1data=p1data->next;					/* eat call */
  p1data=p1data->next;					/* eat open paren */
  CALL(ParseExpression(scr, &p1data, pass2_list));

  if (p1data->code==COMP_TYPE_OF_ARGUMENTS) {
    CALL(Pass2PutString(scr, p1data->string, p1data->strlen));
    CALL(Pass2Put(scr, PASS2_TYPE_OF_ARGUMENTS, p1data, &p2_stack, 3));
    p1data=p1data->next;  /* eat type of argument */
  }

  *p1datapek=p1data;
  return FPL_OK;
}

static ReturnCode HandleReference(struct Data *scr, struct Pass1Data **p1datapek,
                                  struct Pass2Data **pass2_list)
{
  ReturnCode ret;
  struct Pass1Data *p1data=*p1datapek;
  struct Pass2Data bracket_link_first;
  struct Pass2Data *bracket_link=&bracket_link_first;
  struct Pass1Data *datain=p1data;
  char stop;

  bracket_link_first.next=NULL;
  p1data=p1data->next;			/* eat reference */

  do {
    stop=TRUE;
    switch(p1data->code) {
    case COMP_ASSIGN:
      {
        CALL(Pass2PutArg(scr, datain->num[0]));	/* number */