expr.c

a very popular packet of cryptography tools,it encloses the most common used algorithm and protocols

  case TOKEN_FUNCTION:
    CONTROL_PUSH (p->token_op, 1);

    if (p->token_op->type & MPEXPR_TYPE_CONSTANT)
      goto apply_control_lookahead;

    LOOKAHEAD (MPEXPR_TYPE_PREFIX);
    if (! (p->token == TOKEN_OPERATOR
           && p->token_op->type == MPEXPR_TYPE_OPENPAREN))
      ERROR ("expected open paren for function", MPEXPR_RESULT_PARSE_ERROR);

    TRACE (printf ("open paren for function \"%s\"\n", CP->op->name));

    if ((CP->op->type & MPEXPR_TYPE_MASK_ARGCOUNT) == MPEXPR_TYPE_NARY(0))
      {
        LOOKAHEAD (0);
        if (! (p->token == TOKEN_OPERATOR
               && p->token_op->type == MPEXPR_TYPE_CLOSEPAREN))
          ERROR ("expected close paren for 0ary function",
                 MPEXPR_RESULT_PARSE_ERROR);
        goto apply_control_lookahead;
      }

    goto another_expr_lookahead;
  }
  ERROR ("unrecognised start of expression", MPEXPR_RESULT_PARSE_ERROR);


 another_operator_lookahead:
  LOOKAHEAD (0);
 another_operator:
  TRACE (printf ("another operator maybe: %s\n", TOKEN_NAME(p->token)));

  switch (p->token) {
  case TOKEN_EOF:
    goto apply_control;

  case TOKEN_OPERATOR:
    /* The next operator is compared to the one on top of the control stack.
       If the next is lower precedence, or the same precedence and not
       right-associative, then reduce using the control stack and look at
       the next operator again later.  */

#define PRECEDENCE_TEST_REDUCE(tprec,cprec,ttype,ctype)                 \
  ((tprec) < (cprec)                                                    \
   || ((tprec) == (cprec) && ! ((ttype) & MPEXPR_TYPE_RIGHTASSOC)))
    
    if (PRECEDENCE_TEST_REDUCE (p->token_op->precedence, CP->op->precedence,
                                p->token_op->type,       CP->op->type))
      {
        TRACE (printf ("defer operator: %s (prec %d vs %d, type 0x%X)\n",
                       p->token_op->name,
                       p->token_op->precedence, CP->op->precedence,
                       p->token_op->type));
        goto apply_control;
      }

    /* An argsep is a binary operator, but is never pushed on the control
       stack, it just accumulates an extra argument for a function. */
    if (p->token_op->type == MPEXPR_TYPE_ARGSEP)
      {
        if (CP->op->precedence != 0)
          ERROR ("ARGSEP not in a function call", MPEXPR_RESULT_PARSE_ERROR);

        TRACE (printf ("argsep for function \"%s\"(%d)\n",
                       CP->op->name, CP->argcount));

#define IS_PAIRWISE(type)                                               \
  (((type) & (MPEXPR_TYPE_MASK_ARGCOUNT | MPEXPR_TYPE_PAIRWISE))        \
   == (MPEXPR_TYPE_BINARY | MPEXPR_TYPE_PAIRWISE))

        if (IS_PAIRWISE (CP->op->type) && CP->argcount >= 2)
          {
            TRACE (printf ("    will reduce pairwise now\n"));
            CP->argcount--;
            CONTROL_PUSH (CP->op, 2);
            goto apply_control;
          }

        CP->argcount++;
        goto another_expr_lookahead;
      }

    switch (p->token_op->type & MPEXPR_TYPE_MASK_ARGCOUNT) {
    case MPEXPR_TYPE_NARY(1):
      /* Postfix unary operators can always be applied immediately.  The
         easiest way to do this is just push it on the control stack and go
         to the normal control stack reduction code. */

      TRACE (printf ("postfix unary operator: %s\n", p->token_op->name));
      if (p->token_op->type & MPEXPR_TYPE_PREFIX)
        ERROR ("prefix unary operator used postfix",
               MPEXPR_RESULT_PARSE_ERROR);
      CONTROL_PUSH (p->token_op, 1);
      goto apply_control_lookahead;

    case MPEXPR_TYPE_NARY(2):
      CONTROL_PUSH (p->token_op, 2);
      goto another_expr_lookahead;

    case MPEXPR_TYPE_NARY(3):
      CONTROL_PUSH (p->token_op, 1);
      goto another_expr_lookahead;
    }
    
    TRACE (printf ("unrecognised operator \"%s\" type: 0x%X",
                   CP->op->name, CP->op->type));
    ERROR ("", MPEXPR_RESULT_PARSE_ERROR);
    break;

  default:
    TRACE (printf ("expecting an operator, got token %d", p->token));
    ERROR ("", MPEXPR_RESULT_PARSE_ERROR);
  }


 apply_control_lookahead:
  LOOKAHEAD (0);
 apply_control:
  /* Apply the top element CP of the control stack.  Data values are SP,
     SP-1, etc.  Result is left as stack top SP after popping consumed
     values.
 
     The use of sp as a duplicate of SP will help compilers that can't
     otherwise recognise the various uses of SP as common subexpressions.  */

  TRACE (printf ("apply control: nested %d, \"%s\" 0x%X, %d args\n",
                 p->control_top, CP->op->name, CP->op->type, CP->argcount));
  
  TRACE (printf ("apply 0x%X-ary\n",
                 CP->op->type & MPEXPR_TYPE_MASK_ARGCOUNT));
  switch (CP->op->type & MPEXPR_TYPE_MASK_ARGCOUNT) {
  case MPEXPR_TYPE_NARY(0):
    {
      mpX_ptr  sp;
      DATA_SPACE ();
      DATA_PUSH ();
      sp = SP;
      switch (CP->op->type & MPEXPR_TYPE_MASK_ARGSTYLE) {
      case 0:
        (* (mpexpr_fun_0ary_t) CP->op->fun) (sp);
        break;
      case MPEXPR_TYPE_RESULT_INT:
        (*p->mpX_set_si) (sp, (long) (* (mpexpr_fun_i_0ary_t) CP->op->fun) ());
        break;
      default:
        ERROR ("unrecognised 0ary argument calling style",
               MPEXPR_RESULT_BAD_TABLE);
      }
    }
    break;

  case MPEXPR_TYPE_NARY(1):
    {
      mpX_ptr  sp = SP;
      CHECK_ARGCOUNT ("unary", 1);
      TRACE (MPX_TRACE ("before", sp));
      
      switch (CP->op->type & MPEXPR_TYPE_MASK_SPECIAL) {
      case 0:
        /* not a special */
        break;

      case MPEXPR_TYPE_DONE & MPEXPR_TYPE_MASK_SPECIAL:
        TRACE (printf ("special done\n"));
        goto done;

      case MPEXPR_TYPE_LOGICAL_NOT & MPEXPR_TYPE_MASK_SPECIAL:
        TRACE (printf ("special logical not\n"));
        (*p->mpX_set_si)
          (sp, (long) ((* (mpexpr_fun_i_unary_t) CP->op->fun) (sp) == 0));
        goto apply_control_done;

      case MPEXPR_TYPE_CLOSEPAREN & MPEXPR_TYPE_MASK_SPECIAL:
        CONTROL_POP ();
        if (CP->op->type == MPEXPR_TYPE_OPENPAREN)
          {
            TRACE (printf ("close paren matching open paren\n"));
            CONTROL_POP ();
            goto another_operator;
          }
        if (CP->op->precedence == 0)
          {
            TRACE (printf ("close paren for function\n"));
            goto apply_control;
          }
        ERROR ("unexpected close paren", MPEXPR_RESULT_PARSE_ERROR);

      default:
        TRACE (printf ("unrecognised special unary operator 0x%X",
                       CP->op->type & MPEXPR_TYPE_MASK_SPECIAL));
        ERROR ("", MPEXPR_RESULT_BAD_TABLE);
      }

      switch (CP->op->type & MPEXPR_TYPE_MASK_ARGSTYLE) {
      case 0:
        (* (mpexpr_fun_unary_t) CP->op->fun) (sp, sp);
        break;
      case MPEXPR_TYPE_LAST_UI:
        CHECK_UI (sp);
        (* (mpexpr_fun_unary_ui_t) CP->op->fun)
          (sp, (*p->mpX_get_ui) (sp));
        break;
      case MPEXPR_TYPE_RESULT_INT:
        (*p->mpX_set_si)
          (sp, (long) (* (mpexpr_fun_i_unary_t) CP->op->fun) (sp));
        break;
      case MPEXPR_TYPE_RESULT_INT | MPEXPR_TYPE_LAST_UI:
        CHECK_UI (sp);
        (*p->mpX_set_si)
          (sp,
           (long) (* (mpexpr_fun_i_unary_ui_t) CP->op->fun)
           ((*p->mpX_get_ui) (sp)));
        break;
      default:
        ERROR ("unrecognised unary argument calling style",
               MPEXPR_RESULT_BAD_TABLE);
      }
    }
    break;

  case MPEXPR_TYPE_NARY(2):
    {
      mpX_ptr  sp;

      /* pairwise functions are allowed to have just one argument */
      if ((CP->op->type & MPEXPR_TYPE_PAIRWISE)
          && CP->op->precedence == 0
          && CP->argcount == 1)
        goto apply_control_done;          

      CHECK_ARGCOUNT ("binary", 2);
      DATA_POP (1);
      sp = SP;
      TRACE (MPX_TRACE ("lhs", sp);
             MPX_TRACE ("rhs", sp+1));
      
      if (CP->op->type & MPEXPR_TYPE_MASK_CMP)
        {
          int  type = CP->op->type;
          int  cmp = (* (mpexpr_fun_i_binary_t) CP->op->fun)
            (sp, sp+1);
          (*p->mpX_set_si)
            (sp,
             (long)
             ((  (cmp  < 0) & ((type & MPEXPR_TYPE_MASK_CMP_LT) != 0))
              | ((cmp == 0) & ((type & MPEXPR_TYPE_MASK_CMP_EQ) != 0))
              | ((cmp  > 0) & ((type & MPEXPR_TYPE_MASK_CMP_GT) != 0))));
          goto apply_control_done;
        }

      switch (CP->op->type & MPEXPR_TYPE_MASK_SPECIAL) {
      case 0:
        /* not a special */
        break;

      case MPEXPR_TYPE_QUESTION & MPEXPR_TYPE_MASK_SPECIAL:
        ERROR ("'?' without ':'", MPEXPR_RESULT_PARSE_ERROR);
          
      case MPEXPR_TYPE_COLON & MPEXPR_TYPE_MASK_SPECIAL:
        TRACE (printf ("special colon\n"));
        CONTROL_POP ();
        if (CP->op->type != MPEXPR_TYPE_QUESTION)
          ERROR ("':' without '?'", MPEXPR_RESULT_PARSE_ERROR);

        CP->argcount--;
        DATA_POP (1);
        sp--;
        TRACE (MPX_TRACE ("query", sp);
               MPX_TRACE ("true",  sp+1);
               MPX_TRACE ("false", sp+2));
        (*p->mpX_set)
          (sp, (* (mpexpr_fun_i_unary_t) CP->op->fun) (sp)
           ? sp+1 : sp+2);
        goto apply_control_done;

      case MPEXPR_TYPE_LOGICAL_AND & MPEXPR_TYPE_MASK_SPECIAL:
        TRACE (printf ("special logical and\n"));
        (*p->mpX_set_si)
          (sp,
           (long) 
           ((* (mpexpr_fun_i_unary_t) CP->op->fun) (sp)
            && (* (mpexpr_fun_i_unary_t) CP->op->fun) (sp+1)));
        goto apply_control_done;

      case MPEXPR_TYPE_LOGICAL_OR & MPEXPR_TYPE_MASK_SPECIAL:
        TRACE (printf ("special logical and\n"));
        (*p->mpX_set_si)
          (sp,
           (long) 
           ((* (mpexpr_fun_i_unary_t) CP->op->fun) (sp)
            || (* (mpexpr_fun_i_unary_t) CP->op->fun) (sp+1)));
        goto apply_control_done;

      case MPEXPR_TYPE_MAX & MPEXPR_TYPE_MASK_SPECIAL:
        TRACE (printf ("special max\n"));
        if ((* (mpexpr_fun_i_binary_t) CP->op->fun) (sp, sp+1) < 0)
          (*p->mpX_swap) (sp, sp+1);
        goto apply_control_done;
      case MPEXPR_TYPE_MIN & MPEXPR_TYPE_MASK_SPECIAL:
        TRACE (printf ("special min\n"));
        if ((* (mpexpr_fun_i_binary_t) CP->op->fun) (sp, sp+1) > 0)
          (*p->mpX_swap) (sp, sp+1);
        goto apply_control_done;

      default:
        ERROR ("unrecognised special binary operator",
               MPEXPR_RESULT_BAD_TABLE);
      }

      switch (CP->op->type & MPEXPR_TYPE_MASK_ARGSTYLE) {
      case 0:
        (* (mpexpr_fun_binary_t) CP->op->fun) (sp, sp, sp+1);
        break;
      case MPEXPR_TYPE_LAST_UI:
        CHECK_UI (sp+1);
        (* (mpexpr_fun_binary_ui_t) CP->op->fun)
          (sp, sp, (*p->mpX_get_ui) (sp+1));
        break;
      case MPEXPR_TYPE_RESULT_INT:
        (*p->mpX_set_si)
          (sp,
           (long) (* (mpexpr_fun_i_binary_t) CP->op->fun) (sp, sp+1));
        break;
      case MPEXPR_TYPE_LAST_UI | MPEXPR_TYPE_RESULT_INT:
        CHECK_UI (sp+1);
        (*p->mpX_set_si)
          (sp,
           (long) (* (mpexpr_fun_i_binary_ui_t) CP->op->fun)
           (sp, (*p->mpX_get_ui) (sp+1)));
        break;
      default:
        ERROR ("unrecognised binary argument calling style",
               MPEXPR_RESULT_BAD_TABLE);
      }
    }
    break;

  case MPEXPR_TYPE_NARY(3):
    {
      mpX_ptr  sp;

      CHECK_ARGCOUNT ("ternary", 3);
      DATA_POP (2);
      sp = SP;
      TRACE (MPX_TRACE ("arg1", sp);
             MPX_TRACE ("arg2", sp+1);
             MPX_TRACE ("arg3", sp+1));

      switch (CP->op->type & MPEXPR_TYPE_MASK_ARGSTYLE) {
      case 0:
        (* (mpexpr_fun_ternary_t) CP->op->fun) (sp, sp, sp+1, sp+2);
        break;
      case MPEXPR_TYPE_LAST_UI:
        CHECK_UI (sp+2);
        (* (mpexpr_fun_ternary_ui_t) CP->op->fun)
          (sp, sp, sp+1, (*p->mpX_get_ui) (sp+2));
        break;
      case MPEXPR_TYPE_RESULT_INT:
        (*p->mpX_set_si)
          (sp,
           (long) (* (mpexpr_fun_i_ternary_t) CP->op->fun)
           (sp, sp+1, sp+2));
        break;
      case MPEXPR_TYPE_LAST_UI | MPEXPR_TYPE_RESULT_INT:
        CHECK_UI (sp+2);
        (*p->mpX_set_si)
          (sp,
           (long) (* (mpexpr_fun_i_ternary_ui_t) CP->op->fun)
           (sp, sp+1, (*p->mpX_get_ui) (sp+2)));
        break;
      default:
        ERROR ("unrecognised binary argument calling style",
               MPEXPR_RESULT_BAD_TABLE);
      }
    }
    break;

  default:
    TRACE (printf ("unrecognised operator type: 0x%X\n", CP->op->type));
    ERROR ("", MPEXPR_RESULT_PARSE_ERROR);
  }

 apply_control_done:
  TRACE (MPX_TRACE ("result", SP));
  CONTROL_POP ();
  goto another_operator;

 done:
  if (p->error_code == MPEXPR_RESULT_OK)
    {
      if (p->data_top != 0)
        {
          TRACE (printf ("data stack want top at 0, got %d\n", p->data_top));
          p->error_code = MPEXPR_RESULT_PARSE_ERROR;
        }
      else
        (*p->mpX_set_or_swap) (p->res, SP);
    }

  {
    int  i;
    for (i = 0; i < p->data_inited; i++)
      {
        TRACE (printf ("clear %d\n", i));
        (*p->mpX_clear) (p->data_stack+i);
      }
  }

  __GMP_FREE_FUNC_TYPE (p->data_stack, p->data_alloc, union mpX_t);
  __GMP_FREE_FUNC_TYPE (p->control_stack, p->control_alloc,
                        struct mpexpr_control_t);

  return p->error_code;
}