[数值计算] 【已解决】批处理的整数变量是如何解析存储的？

set /a n=2147483647+1
复制代码

32位有符号正整数2147483647原码为：01111111 11111111 11111111 11111111
加1后
结果为：10000000  00000000  00000000  00000000 （没有溢出，还是32位，只是计算后最高位变了）
因为最高位为1，输出时被解析为负数

而32位有符号整数中
-2147483648的原码就是：10000000  00000000  00000000  00000000  (表示负0)
正0是：00000000  00000000  00000000  00000000 （32个0）
复制代码

jae 00000067
je 00000024
das
popad
and [esi+3D],ch
xor dh,[ecx]
xor al,37
xor al,38
xor esi,[esi]
xor al,37
复制代码

jae 00000067
je 00000024
das
popad
and [esi+3D],ch
sub eax,37343132
xor al,38
xor esi,[esi]
xor al,37
复制代码

int SetWork(n)
struct cmdnode *n ;
{
        TCHAR *tas ;    /* Tokenized argument string    */
        TCHAR *wptr ;   /* Work pointer                 */
        int i ;                 /* Work variable                */

        //
        // If extensions are enabled, things are different
        //
        if (fEnableExtensions) {
            tas = n->argptr;
            //
            // Find first non-blank argument.
            //
            if (tas != NULL)
            while (*tas && *tas <= SPACE)
                tas += 1;

            //
            // No arguments, same as old behavior.  Display current
            // set of environment variables.
            //
            if (!tas || !*tas)
                return(DisplayEnv()) ;

            //
            // See if /A switch given.  If so, let arithmetic
            // expression evaluator do the work.
            //
            if (!_tcsnicmp(tas, SetArithStr, 2))
                return SetArithWork(tas+2);

            //
            // See if first argument is quoted.  If so, strip off
            // leading quote, spaces and trailing quote.
            //
            if (*tas == QUOTE) {
                tas += 1;
                while (*tas && *tas <= SPACE)
                    tas += 1;
                wptr = _tcsrchr(tas, QUOTE);
                if (wptr)
                    *wptr = NULLC;
            }

            //
            // Find the equal sign in the argument.
            //
            wptr = _tcschr(tas, EQ);

            //
            // If no equal sign, then assume argument is variable name
            // and user wants to see its value.  Display it.
            //
            if (!wptr)
                return DisplayEnvVariable(tas);

            //
            // Found the equal sign, so left of equal sign is variable name
            // and right of equal sign is value.  Dont allow user to set
            // a variable name that begins with an equal sign, since those
            // are reserved for drive current directories.
            //
            *wptr++ = NULLC;
            if (*wptr == EQ) {
                PutStdErr(MSG_BAD_SYNTAX, NOARGS);
                return(FAILURE) ;
            }

            return(SetEnvVar(tas, wptr, &CmdEnv)) ;
        }

        tas = TokStr(n->argptr, ONEQSTR, TS_WSPACE|TS_SDTOKENS) ;
        if (!*tas)
                return(DisplayEnv()) ;

        else {
                for (wptr = tas, i = 0 ; *wptr ; wptr += mystrlen(wptr)+1, i++)
                        ;
                /* If too many parameters were given, the second parameter */
                /* wasn't an equal sign, or they didn't specify a string   */
                /* return an error message.                                */
                if ( i > 3 || *(wptr = tas+mystrlen(tas)+1) != EQ ||
                    !mystrlen(mystrcpy(tas, stripit(tas))) ) {
/* M013 */              PutStdErr(MSG_BAD_SYNTAX, NOARGS);
                        return(FAILURE) ;

                } else {
                        return(SetEnvVar(tas, wptr+2, &CmdEnv)) ;
                }
        } ;
}
复制代码

/***    SetArithWork - set environment variable to value of arithmetic expression
 *
 *  Purpose:
 *      Set environment variable to value of arithmetic expression
 *
 *  int SetArithWork(TCHAR *tas)
 *
 *  Args:
 *      tas - pointer to null terminated string of the form:
 *
 *          VARNAME=expression
 *
 *  Returns:
 *      If valid expression, return SUCCESS otherwise FAILURE.
 *
 */

int SetArithWork(TCHAR *tas)
{
    TCHAR c, szResult[ MAX_PATH ];
    TCHAR *szOperator;
    TCHAR *wptr;
    DWORD i;
    BOOLEAN bUnaryOpPossible;
    int rc;


    //
    // If no input, declare an error
    //
    if (!tas || !tas) {
        PutStdErr(MSG_BAD_SYNTAX, NOARGS);
        return(FAILURE) ;
    }

    //
    // Now evaluate the expression.  Syntax accepted:
    //
    //  <expr>:     '(' <expr> ')'
    //            | <unary-op> <expr>
    //            | <expr> <binary-op> <expr>
    //            | <variable>
    //            | <number>
    //
    //  <unary-op>:  '+' | '-' |
    //               '~' | '!'
    //
    //  <binary-op>: '+' | '-' | '*' | '/' | '%'
    //               '|' | '&' | '^' | '=' | ','
    //
    //  <number>:   C-syntax (e.g. 16 or 0x10)
    //  <variable>: Any environment variable.  Dont need surround with % to get value
    //
    //  Operators have same meaning and precedence as ANSI C.  All arithmetic is
    //  fixed, 32 bit arithmetic.  No floating point.
    //

    //
    // Poor man's parser/evaluator with operand and operator stack.
    //
    iOperand = 0;
    iOperator = 0;
    bUnaryOpPossible = TRUE;
    rc = SUCCESS;
    do {
        //
        // Look at next non blank character
        //
        c = *tas;
        if (c <= SPACE || c == QUOTE) {
            if (*tas)
                tas += 1;
        }
        else
        if (_istdigit(c)) {
            //
            // Digit, must be numeric operand.  Push it on operand stack
            //
            lOperands[ iOperand ].Value = _tcstol(tas, &tas, 0);
            lOperands[ iOperand ].Name = NULL;
            iOperand += 1;

            if (_istdigit(*tas) || _istalpha(*tas)) {
                rc = MSG_SET_A_INVALID_NUMBER;
                break;
            }

            //
            // Unary op not possible after a operand.
            //
            bUnaryOpPossible = FALSE;
        }
        else
        if (bUnaryOpPossible && (szOperator = _tcschr(szUnaryOps, c))) {
            //
            // If unary op possible and we have one, then push it
            // on the operator stack
            tas += 1;
            if (rc = DoArithOps( wUnaryOpCodes[szOperator - szUnaryOps] ))
                break;
        }
        else
        if (!bUnaryOpPossible && (szOperator = _tcschr(szOps, c))) {
            //
            // If we have a binary op, push it on the operator stack
            //
            tas += 1;

            if (c == L'<' || c == L'>') {
                if (*tas != c) {
                    rc = MSG_SYNERR_GENL;
                    break;
                }
                tas += 1;
            }

            if (*tas == EQ) {
                tas += 1;
                if (rc = DoArithOps( A_EQOP ))
                    break;

                if (iOperand == 0) {
                    rc = MSG_SET_A_MISSING_OPERAND;
                    break;
                }
                lOperands[ iOperand ] = lOperands[ iOperand-1 ];
                iOperand += 1;
            }

            if (rc = DoArithOps( wOpCodes[szOperator - szOps] ))
                break;

            //
            // Unary op now possible.
            //

            if (c == RPOP) {
                bUnaryOpPossible = FALSE;
            }
            else {
                bUnaryOpPossible = TRUE;
            }
        }
        else
        if (!bUnaryOpPossible) {
            rc = MSG_SET_A_MISSING_OPERATOR;
            break;
        }
        else {
            //
            // Not a number or operator, must be a variable name.  The
            // name must be terminated by a space or an operator.
            //
            wptr = tas;
            while (*tas &&
                   *tas > SPACE &&
                   !_tcschr(szUnaryOps, *tas) &&
                   !_tcschr(szOps, *tas)
                  )
                tas += 1;

            //
            // If no variable or variable too long, bail
            //
            if (wptr == tas) {
                rc = MSG_SET_A_MISSING_OPERAND;
                break;
            }

            lOperands[ iOperand ].Value = 0;
            lOperands[ iOperand ].Name = gmkstr((tas-wptr+1)*sizeof(TCHAR));
            if (lOperands[ iOperand ].Name == NULL) {
                rc = MSG_NO_MEMORY;
                break;
            }

            //
            // Have variable name.  Push name on operand stack with a zero
            // value.  Value will be fetch when this operand is popped from
            // operand stack.
            //
            _tcsncpy(lOperands[ iOperand ].Name, wptr, tas-wptr);
            lOperands[ iOperand ].Name[tas-wptr] = NULLC;
            iOperand += 1;

            //
            // Unary op not possible after a operand.
            //
            bUnaryOpPossible = FALSE;
        }

    } while (*tas);

    if (rc == SUCCESS) {
        //
        // Do any pending operators.
        //
        rc = DoArithOps( 0 );

        //
        // If operator stack non-empty or more than one value
        // on operand stack, then invalid expression
        //
        if (rc == SUCCESS && (iOperator || iOperand != 1)) {
            if (iOperator)
                rc = MSG_SET_A_MISMATCHED_PARENS;
            else
                rc = MSG_SET_A_MISSING_OPERAND;
        }
    }

    if (rc != SUCCESS)
        PutStdErr(rc, ONEARG, tas);
    else {
        //
        // Valid result, display if not in a batch script.
        //
        if (!CurBat)
            cmd_printf( TEXT("%d"), lOperands[ 0 ].Value ) ;
    }

    return rc;
}
复制代码

/***    DoArithOps - push operator on operator stack      arithmetic expression
 *
 *  Purpose:
 *      Push an operator on the operator stack.  Operator precedence handed here
 *
 *  int DoArithOps(USHORT OpCode)
 *
 *  Args:
 *      OpCode - operator value.  Precendence encoded in value, such that operators
 *          with higher precedence are numerically larger
 *
 *  Returns:
 *      If valid expression, return SUCCESS otherwise FAILURE.
 *
 */
int
DoArithOps(
    USHORT OpCode
    )
{
    USHORT op;
    LONG op1, op2, result;
    TCHAR szResult[ 32 ];

    //
    // Loop until we can push this operator onto the operator stack.
    // These means we have to pop off and any operators on the stack
    // that have a higher precedence than the new operator.
    //
    while (TRUE) {
        if (OpCode == A_ENDOP) {
            //
            // If new opcode is a right parenthesis, then all done if
            // the left parenthesis is on the top of the operator stack
            //
            if (iOperator != 0 && wOperators[iOperator-1] == A_BEGOP) {
                iOperator -= 1;
                OpCode = 0;
                break;
            }

            //
            // No left paren left, keep popping until we see it. Error
            // if nothing left to pop.
            //
            if (iOperator == 0)
                return MSG_SET_A_MISMATCHED_PARENS;
        }
        else
        if (OpCode == 0) {
            //
            // OpCode zero is end of expression.  Pop everything off.
            //
            if (iOperator == 0)
                break;
            }
        else
        if (iOperator == 0 || OpCode > wOperators[iOperator-1] || OpCode == A_BEGOP) {
            //
            // Done if no more operators to process or
            // New operator has higher precedence than operator on top of stack
            // or new operator is a left parenthesis
            //
            break;
        }

        //
        // We need to pop and process (i.e. evaluate) the operator stack
        // If it is a two operand stack, then get the second argument from
        // the top of the operand stack.  Done if not two operands on the
        // operand stack.
        //
        op = wOperators[--iOperator];
        if (op < A_NEGOP) {
            if (iOperand < 2)
                break;
            op2 = PopOperand();
        }

        //
        // Get the first operand from the top of the operand stack.  Error
        // if not one there.
        //
        if (iOperand < 1)
            break;
        op1 = PopOperand();


        //
        // Evaluate the operator and push the result back on the operand stack
        //
        result = 0;
        switch( op ) {
            case A_LSHOP: result = op1 << op2;  break;
            case A_RSHOP: result = op1 >> op2;  break;
            case A_ADDOP: result = op1 + op2;   break;
            case A_SUBOP: result = op1 - op2;   break;
            case A_MULOP: result = op1 * op2;   break;
            case A_DIVOP: if (op2 == 0) return MSG_SET_A_MISSING_OPERAND;
                          result = op1 / op2;   break;
            case A_MODOP: result = op1 % op2;   break;
            case A_ANDOP: result = op1 & op2;   break;
            case A_OROP:  result = op1 | op2;   break;
            case A_XOROP: result = op1 ^ op2;   break;
            case A_NEGOP: result = - op1;       break;
            case A_POSOP: result = + op1;       break;
            case A_NOTOP: result = ~ op1;       break;
            case A_SEPOP: result = op2;         break;
            case A_EQOP:  if (lOperands[iOperand].Name == NULL) return MSG_SET_A_BAD_ASSIGN;
                          result = op2;
                          //
                          // Left handside has variable name, convert result
                          // to text and store as value of variable.
                          //
                          _sntprintf( szResult, 32, TEXT("%d"), result ) ;
                          if (SetEnvVar(lOperands[iOperand].Name, szResult, &CmdEnv) != SUCCESS)
                              return GetLastError();
                          break;

            default:    break;
        }

        lOperands[iOperand].Value = result;
        lOperands[iOperand].Name = NULL;
        iOperand += 1;
    }

    //
    // If new operator code is not the end of the expression, push it onto the
    // operator stack.
    //
    if (OpCode != 0)
        wOperators[ iOperator++ ] = OpCode;
    return SUCCESS;
}
复制代码