VirtualBox

儲存庫 kBuild 的更動 1724


忽略:
時間撮記:
2008-9-5 上午12:34:53 (16 年 以前)
作者:
bird
訊息:

kmk: ifcond.c -> expreval.c

位置:
trunk/src/kmk
檔案:
修改 4 筆資料
移動 1 筆資料

圖例:

未更動
新增
刪除

  • trunk/src/kmk/Makefile.am

    r1722 r1724  
    4747                strcache.c variable.c version.c vpath.c hash.c \
    4848                \
     49                expreval.c \
    4950                kbuild.c \
    5051                electric.c \

  • trunk/src/kmk/Makefile.kmk

    r1722 r1724  
    178178        main.c \
    179179        read.c \
    180         ifcond.c \
     180        expreval.c \
    181181        hash.c \
    182182        strcache.c \

  • trunk/src/kmk/expreval.c

    r1723 r1724  
    22/* $Id$ */
    33/** @file
    4  * ifcond - C like if expressions.
     4 * expreval - Expressions evaluator, C / BSD make / nmake style.
    55 */
    66
    … …  
    5353*******************************************************************************/
    5454/** The max length of a string representation of a number. */
    55 #define IFCOND_NUM_LEN  ((sizeof("-9223372036854775802") + 4) & ~3)
     55#define EXPR_NUM_LEN  ((sizeof("-9223372036854775802") + 4) & ~3)
    5656
    5757/** The max operator stack depth. */
    58 #define IFCOND_MAX_OPERATORS  72
     58#define EXPR_MAX_OPERATORS  72
    5959/** The max operand depth. */
    60 #define IFCOND_MAX_OPERANDS   128
     60#define EXPR_MAX_OPERANDS   128
    6161
    6262
    … …  
    6666/** The 64-bit signed integer type we're using. */
    6767#ifdef _MSC_VER
    68 typedef __int64 IFCONDINT64;
     68typedef __int64 EXPRINT64;
    6969#else
    7070# include <stdint.h>
    71 typedef int64_t IFCONDINT64;
     71typedef int64_t EXPRINT64;
    7272#endif
    7373
    7474/** Pointer to a evaluator instance. */
    75 typedef struct IFCOND *PIFCOND;
     75typedef struct EXPR *PEXPR;
    7676
    7777
    … …  
    8282{
    8383    /** Invalid zero entry. */
    84     kIfCondVar_Invalid = 0,
     84    kExprVar_Invalid = 0,
    8585    /** A number. */
    86     kIfCondVar_Num,
     86    kExprVar_Num,
    8787    /** A string in need of expanding (perhaps). */
    88     kIfCondVar_String,
     88    kExprVar_String,
    8989    /** A simple string that doesn't need expanding. */
    90     kIfCondVar_SimpleString,
     90    kExprVar_SimpleString,
    9191    /** A quoted string in need of expanding (perhaps). */
    92     kIfCondVar_QuotedString,
     92    kExprVar_QuotedString,
    9393    /** A simple quoted string that doesn't need expanding. */
    94     kIfCondVar_QuotedSimpleString,
     94    kExprVar_QuotedSimpleString,
    9595    /** The end of the valid variable types. */
    96     kIfCondVar_End
    97 } IFCONDVARTYPE;
     96    kExprVar_End
     97} EXPRVARTYPE;
    9898
    9999/**
    … …  
    103103{
    104104    /** The variable type. */
    105     IFCONDVARTYPE enmType;
     105    EXPRVARTYPE enmType;
    106106    /** The variable. */
    107107    union
    … …  
    110110        char *psz;
    111111        /** The variable. */
    112         IFCONDINT64 i;
     112        EXPRINT64 i;
    113113    } uVal;
    114 } IFCONDVAR;
     114} EXPRVAR;
    115115/** Pointer to a operand variable. */
    116 typedef IFCONDVAR *PIFCONDVAR;
     116typedef EXPRVAR *PEXPRVAR;
    117117/** Pointer to a const operand variable. */
    118 typedef IFCONDVAR const *PCIFCONDVAR;
     118typedef EXPRVAR const *PCEXPRVAR;
    119119
    120120/**
    … …  
    123123typedef enum
    124124{
    125     kIfCondRet_Error = -1,
    126     kIfCondRet_Ok = 0,
    127     kIfCondRet_Operator,
    128     kIfCondRet_Operand,
    129     kIfCondRet_EndOfExpr,
    130     kIfCondRet_End
    131 } IFCONDRET;
     125    kExprRet_Error = -1,
     126    kExprRet_Ok = 0,
     127    kExprRet_Operator,
     128    kExprRet_Operand,
     129    kExprRet_EndOfExpr,
     130    kExprRet_End
     131} EXPRRET;
    132132
    133133/**
    … …  
    148148    signed char cArgs;
    149149    /** Pointer to the method implementing the operator. */
    150     IFCONDRET (*pfn)(PIFCOND pThis);
    151 } IFCONDOP;
     150    EXPRRET (*pfn)(PEXPR pThis);
     151} EXPROP;
    152152/** Pointer to a const operator. */
    153 typedef IFCONDOP const *PCIFCONDOP;
     153typedef EXPROP const *PCEXPROP;
    154154
    155155/**
    156156 * Expression evaluator instance.
    157157 */
    158 typedef struct IFCOND
     158typedef struct EXPR
    159159{
    160160    /** The full expression. */
    … …  
    165165    const struct floc *pFileLoc;
    166166    /** Pending binary operator. */
    167     PCIFCONDOP pPending;
     167    PCEXPROP pPending;
    168168    /** Top of the operator stack. */
    169169    int iOp;
    … …  
    171171    int iVar;
    172172    /** The operator stack. */
    173     PCIFCONDOP apOps[IFCOND_MAX_OPERATORS];
     173    PCEXPROP apOps[EXPR_MAX_OPERATORS];
    174174    /** The operand stack. */
    175     IFCONDVAR aVars[IFCOND_MAX_OPERANDS];
    176 } IFCOND;
     175    EXPRVAR aVars[EXPR_MAX_OPERANDS];
     176} EXPR;
    177177
    178178
    … …  
    184184static char g_auchOpStartCharMap[256];
    185185/** Whether we've initialized the map. */
    186 static int g_fIfCondInitializedMap = 0;
     186static int g_fExprInitializedMap = 0;
    187187
    188188
    … …  
    190190*   Internal Functions                                                         *
    191191*******************************************************************************/
    192 static void ifcond_unget_op(PIFCOND pThis);
    193 static IFCONDRET ifcond_get_binary_or_eoe_or_rparen(PIFCOND pThis);
     192static void expr_unget_op(PEXPR pThis);
     193static EXPRRET expr_get_binary_or_eoe_or_rparen(PEXPR pThis);
    194194
    195195
    … …  
    205205 * @param   ...         The message format args.
    206206 */
    207 static void ifcond_error(PIFCOND pThis, const char *pszError, ...)
     207static void expr_error(PEXPR pThis, const char *pszError, ...)
    208208{
    209209    char szTmp[256];
    … …  
    222222 *
    223223 * @returns pszDst.
    224  * @param   pszDst  The string buffer to write into. Assumes length of IFCOND_NUM_LEN.
     224 * @param   pszDst  The string buffer to write into. Assumes length of EXPR_NUM_LEN.
    225225 * @param   iSrc    The number to convert.
    226226 */
    227 static char *ifcond_num_to_string(char *pszDst, IFCONDINT64 iSrc)
     227static char *expr_num_to_string(char *pszDst, EXPRINT64 iSrc)
    228228{
    229229    static const char s_szDigits[17] = "0123456789abcdef";
    230     char szTmp[IFCOND_NUM_LEN];
    231     char *psz = &szTmp[IFCOND_NUM_LEN - 1];
     230    char szTmp[EXPR_NUM_LEN];
     231    char *psz = &szTmp[EXPR_NUM_LEN - 1];
    232232    int fNegative;
    233233
    … …  
    261261    /* copy it into the output buffer. */
    262262    psz++;
    263     return (char *)memcpy(pszDst, psz, &szTmp[IFCOND_NUM_LEN] - psz);
     263    return (char *)memcpy(pszDst, psz, &szTmp[EXPR_NUM_LEN] - psz);
    264264}
    265265
    … …  
    274274 * @param   fQuiet  Whether we should be quiet or grumpy on failure.
    275275 */
    276 static IFCONDRET ifcond_string_to_num(PIFCOND pThis, IFCONDINT64 *piDst, const char *pszSrc, int fQuiet)
    277 {
    278     IFCONDRET rc = kIfCondRet_Ok;
     276static EXPRRET expr_string_to_num(PEXPR pThis, EXPRINT64 *piDst, const char *pszSrc, int fQuiet)
     277{
     278    EXPRRET rc = kExprRet_Ok;
    279279    char const *psz = pszSrc;
    280     IFCONDINT64 i;
     280    EXPRINT64 i;
    281281    unsigned uBase;
    282282    int fNegative;
    … …  
    393393            *piDst = i;
    394394            if (!fQuiet)
    395                 ifcond_error(pThis, "Invalid a number \"%.80s\"", pszSrc);
    396             return kIfCondRet_Error;
     395                expr_error(pThis, "Invalid a number \"%.80s\"", pszSrc);
     396            return kExprRet_Error;
    397397        }
    398398
    … …  
    412412 * @param   pVar    The variable.
    413413 */
    414 static int ifcond_var_is_string(PCIFCONDVAR pVar)
    415 {
    416     return pVar->enmType >= kIfCondVar_String;
     414static int expr_var_is_string(PCEXPRVAR pVar)
     415{
     416    return pVar->enmType >= kExprVar_String;
    417417}
    418418
    … …  
    425425 * @param   pVar    The variable.
    426426 */
    427 static int ifcond_var_was_quoted(PCIFCONDVAR pVar)
    428 {
    429     return pVar->enmType >= kIfCondVar_QuotedString;
     427static int expr_var_was_quoted(PCEXPRVAR pVar)
     428{
     429    return pVar->enmType >= kExprVar_QuotedString;
    430430}
    431431
    … …  
    436436 * @param   pVar    The variable.
    437437 */
    438 static void ifcond_var_delete(PIFCONDVAR pVar)
    439 {
    440     if (ifcond_var_is_string(pVar))
     438static void expr_var_delete(PEXPRVAR pVar)
     439{
     440    if (expr_var_is_string(pVar))
    441441    {
    442442        free(pVar->uVal.psz);
    443443        pVar->uVal.psz = NULL;
    444444    }
    445     pVar->enmType = kIfCondVar_Invalid;
     445    pVar->enmType = kExprVar_Invalid;
    446446}
    447447
    … …  
    455455 * @param   enmType The string type.
    456456 */
    457 static void ifcond_var_init_substring(PIFCONDVAR pVar, const char *psz, size_t cch, IFCONDVARTYPE enmType)
     457static void expr_var_init_substring(PEXPRVAR pVar, const char *psz, size_t cch, EXPRVARTYPE enmType)
    458458{
    459459    /* convert string needing expanding into simple ones if possible.  */
    460     if (    enmType == kIfCondVar_String
     460    if (    enmType == kExprVar_String
    461461        &&  !memchr(psz, '$', cch))
    462         enmType = kIfCondVar_SimpleString;
    463     else if (   enmType == kIfCondVar_QuotedString
     462        enmType = kExprVar_SimpleString;
     463    else if (   enmType == kExprVar_QuotedString
    464464             && !memchr(psz, '$', cch))
    465         enmType = kIfCondVar_QuotedSimpleString;
     465        enmType = kExprVar_QuotedSimpleString;
    466466
    467467    pVar->enmType = enmType;
    … …  
    480480 * @param   enmType The string type.
    481481 */
    482 static void ifcond_var_init_string(PIFCONDVAR pVar, const char *psz, IFCONDVARTYPE enmType)
    483 {
    484     ifcond_var_init_substring(pVar, psz, strlen(psz), enmType);
     482static void expr_var_init_string(PEXPRVAR pVar, const char *psz, EXPRVARTYPE enmType)
     483{
     484    expr_var_init_substring(pVar, psz, strlen(psz), enmType);
    485485}
    486486
    … …  
    494494 * @param   enmType The string type.
    495495 */
    496 static void ifcond_var_assign_substring(PIFCONDVAR pVar, const char *psz, size_t cch, IFCONDVARTYPE enmType)
    497 {
    498     ifcond_var_delete(pVar);
    499     ifcond_var_init_substring(pVar, psz, cch, enmType);
     496static void expr_var_assign_substring(PEXPRVAR pVar, const char *psz, size_t cch, EXPRVARTYPE enmType)
     497{
     498    expr_var_delete(pVar);
     499    expr_var_init_substring(pVar, psz, cch, enmType);
    500500}
    501501
    … …  
    508508 * @param   enmType The string type.
    509509 */
    510 static void ifcond_var_assign_string(PIFCONDVAR pVar, const char *psz, IFCONDVARTYPE enmType)
    511 {
    512     ifcond_var_delete(pVar);
    513     ifcond_var_init_string(pVar, psz, enmType);
     510static void expr_var_assign_string(PEXPRVAR pVar, const char *psz, EXPRVARTYPE enmType)
     511{
     512    expr_var_delete(pVar);
     513    expr_var_init_string(pVar, psz, enmType);
    514514}
    515515#endif /* unused */
    … …  
    521521 * @param   pVar    The variable.
    522522 */
    523 static void ifcond_var_make_simple_string(PIFCONDVAR pVar)
     523static void expr_var_make_simple_string(PEXPRVAR pVar)
    524524{
    525525    switch (pVar->enmType)
    526526    {
    527         case kIfCondVar_Num:
     527        case kExprVar_Num:
    528528        {
    529             char *psz = (char *)xmalloc(IFCOND_NUM_LEN);
    530             ifcond_num_to_string(psz, pVar->uVal.i);
     529            char *psz = (char *)xmalloc(EXPR_NUM_LEN);
     530            expr_num_to_string(psz, pVar->uVal.i);
    531531            pVar->uVal.psz = psz;
    532             pVar->enmType = kIfCondVar_SimpleString;
     532            pVar->enmType = kExprVar_SimpleString;
    533533            break;
    534534        }
    535535
    536         case kIfCondVar_String:
    537         case kIfCondVar_QuotedString:
     536        case kExprVar_String:
     537        case kExprVar_QuotedString:
    538538        {
    539539            char *psz;
    … …  
    544544            pVar->uVal.psz = psz;
    545545
    546             pVar->enmType = pVar->enmType == kIfCondVar_String
    547                           ? kIfCondVar_SimpleString
    548                           : kIfCondVar_QuotedSimpleString;
     546            pVar->enmType = pVar->enmType == kExprVar_String
     547                          ? kExprVar_SimpleString
     548                          : kExprVar_QuotedSimpleString;
    549549            break;
    550550        }
    551551
    552         case kIfCondVar_SimpleString:
    553         case kIfCondVar_QuotedSimpleString:
     552        case kExprVar_SimpleString:
     553        case kExprVar_QuotedSimpleString:
    554554            /* nothing to do. */
    555555            break;
    … …  
    567567 * @param   pVar    The variable.
    568568 */
    569 static void ifcond_var_make_string(PIFCONDVAR pVar)
     569static void expr_var_make_string(PEXPRVAR pVar)
    570570{
    571571    switch (pVar->enmType)
    572572    {
    573         case kIfCondVar_Num:
    574             ifcond_var_make_simple_string(pVar);
     573        case kExprVar_Num:
     574            expr_var_make_simple_string(pVar);
    575575            break;
    576576
    577         case kIfCondVar_String:
    578         case kIfCondVar_SimpleString:
    579         case kIfCondVar_QuotedString:
    580         case kIfCondVar_QuotedSimpleString:
     577        case kExprVar_String:
     578        case kExprVar_SimpleString:
     579        case kExprVar_QuotedString:
     580        case kExprVar_QuotedSimpleString:
    581581            /* nothing to do. */
    582582            break;
    … …  
    595595 * @param   i       The integer value.
    596596 */
    597 static void ifcond_var_init_num(PIFCONDVAR pVar, IFCONDINT64 i)
    598 {
    599     pVar->enmType = kIfCondVar_Num;
     597static void expr_var_init_num(PEXPRVAR pVar, EXPRINT64 i)
     598{
     599    pVar->enmType = kExprVar_Num;
    600600    pVar->uVal.i = i;
    601601}
    … …  
    608608 * @param   i       The integer value.
    609609 */
    610 static void ifcond_var_assign_num(PIFCONDVAR pVar, IFCONDINT64 i)
    611 {
    612     ifcond_var_delete(pVar);
    613     ifcond_var_init_num(pVar, i);
     610static void expr_var_assign_num(PEXPRVAR pVar, EXPRINT64 i)
     611{
     612    expr_var_delete(pVar);
     613    expr_var_init_num(pVar, i);
    614614}
    615615
    … …  
    622622 * @param   pVar    The variable.
    623623 */
    624 static IFCONDRET ifcond_var_make_num(PIFCOND pThis, PIFCONDVAR pVar)
     624static EXPRRET expr_var_make_num(PEXPR pThis, PEXPRVAR pVar)
    625625{
    626626    switch (pVar->enmType)
    627627    {
    628         case kIfCondVar_Num:
     628        case kExprVar_Num:
    629629            /* nothing to do. */
    630630            break;
    631631
    632         case kIfCondVar_String:
    633             ifcond_var_make_simple_string(pVar);
     632        case kExprVar_String:
     633            expr_var_make_simple_string(pVar);
    634634            /* fall thru */
    635         case kIfCondVar_SimpleString:
     635        case kExprVar_SimpleString:
    636636        {
    637             IFCONDINT64 i;
    638             IFCONDRET rc = ifcond_string_to_num(pThis, &i, pVar->uVal.psz, 0 /* fQuiet */);
    639             if (rc < kIfCondRet_Ok)
     637            EXPRINT64 i;
     638            EXPRRET rc = expr_string_to_num(pThis, &i, pVar->uVal.psz, 0 /* fQuiet */);
     639            if (rc < kExprRet_Ok)
    640640                return rc;
    641             ifcond_var_assign_num(pVar, i);
     641            expr_var_assign_num(pVar, i);
    642642            break;
    643643        }
    644644
    645         case kIfCondVar_QuotedString:
    646         case kIfCondVar_QuotedSimpleString:
    647             ifcond_error(pThis, "Cannot convert a quoted string to a number");
    648             return kIfCondRet_Error;
     645        case kExprVar_QuotedString:
     646        case kExprVar_QuotedSimpleString:
     647            expr_error(pThis, "Cannot convert a quoted string to a number");
     648            return kExprRet_Error;
    649649
    650650        default:
    651651            assert(0);
    652             return kIfCondRet_Error;
    653     }
    654 
    655     return kIfCondRet_Ok;
     652            return kExprRet_Error;
     653    }
     654
     655    return kExprRet_Ok;
    656656}
    657657
    … …  
    663663 * @param   pVar    The variable.
    664664 */
    665 static IFCONDRET ifcond_var_try_make_num(PIFCONDVAR pVar)
     665static EXPRRET expr_var_try_make_num(PEXPRVAR pVar)
    666666{
    667667    switch (pVar->enmType)
    668668    {
    669         case kIfCondVar_Num:
     669        case kExprVar_Num:
    670670            /* nothing to do. */
    671671            break;
    672672
    673         case kIfCondVar_String:
    674             ifcond_var_make_simple_string(pVar);
     673        case kExprVar_String:
     674            expr_var_make_simple_string(pVar);
    675675            /* fall thru */
    676         case kIfCondVar_SimpleString:
     676        case kExprVar_SimpleString:
    677677        {
    678             IFCONDINT64 i;
    679             IFCONDRET rc = ifcond_string_to_num(NULL, &i, pVar->uVal.psz, 1 /* fQuiet */);
    680             if (rc < kIfCondRet_Ok)
     678            EXPRINT64 i;
     679            EXPRRET rc = expr_string_to_num(NULL, &i, pVar->uVal.psz, 1 /* fQuiet */);
     680            if (rc < kExprRet_Ok)
    681681                return rc;
    682             ifcond_var_assign_num(pVar, i);
     682            expr_var_assign_num(pVar, i);
    683683            break;
    684684        }
    … …  
    686686        default:
    687687            assert(0);
    688         case kIfCondVar_QuotedString:
    689         case kIfCondVar_QuotedSimpleString:
     688        case kExprVar_QuotedString:
     689        case kExprVar_QuotedSimpleString:
    690690            /* can't do this */
    691             return kIfCondRet_Error;
    692     }
    693 
    694     return kIfCondRet_Ok;
     691            return kExprRet_Error;
     692    }
     693
     694    return kExprRet_Ok;
    695695}
    696696
    … …  
    702702 * @param   f       The boolean value.
    703703 */
    704 static void ifcond_var_init_bool(PIFCONDVAR pVar, int f)
    705 {
    706     pVar->enmType = kIfCondVar_Num;
     704static void expr_var_init_bool(PEXPRVAR pVar, int f)
     705{
     706    pVar->enmType = kExprVar_Num;
    707707    pVar->uVal.i = !!f;
    708708}
    … …  
    715715 * @param   f       The boolean value.
    716716 */
    717 static void ifcond_var_assign_bool(PIFCONDVAR pVar, int f)
    718 {
    719     ifcond_var_delete(pVar);
    720     ifcond_var_init_bool(pVar, f);
     717static void expr_var_assign_bool(PEXPRVAR pVar, int f)
     718{
     719    expr_var_delete(pVar);
     720    expr_var_init_bool(pVar, f);
    721721}
    722722
    … …  
    728728 * @param   pVar    The variable.
    729729 */
    730 static int ifcond_var_make_bool(PIFCONDVAR pVar)
     730static int expr_var_make_bool(PEXPRVAR pVar)
    731731{
    732732    switch (pVar->enmType)
    733733    {
    734         case kIfCondVar_Num:
     734        case kExprVar_Num:
    735735            pVar->uVal.i = !!pVar->uVal.i;
    736736            break;
    737737
    738         case kIfCondVar_String:
    739             ifcond_var_make_simple_string(pVar);
     738        case kExprVar_String:
     739            expr_var_make_simple_string(pVar);
    740740            /* fall thru */
    741         case kIfCondVar_SimpleString:
     741        case kExprVar_SimpleString:
    742742        {
    743743            /*
    … …  
    745745             * GNU make boolean logic - not empty string means true.
    746746             */
    747             IFCONDINT64 iVal;
     747            EXPRINT64 iVal;
    748748            char const *psz = pVar->uVal.psz;
    749749            while (isblank((unsigned char)*psz))
    750750                psz++;
    751751            if (    *psz
    752                 &&  ifcond_string_to_num(NULL, &iVal, psz, 1 /* fQuiet */) >= kIfCondRet_Ok)
    753                 ifcond_var_assign_bool(pVar, iVal != 0);
     752                &&  expr_string_to_num(NULL, &iVal, psz, 1 /* fQuiet */) >= kExprRet_Ok)
     753                expr_var_assign_bool(pVar, iVal != 0);
    754754            else
    755                 ifcond_var_assign_bool(pVar, *psz != '\0');
     755                expr_var_assign_bool(pVar, *psz != '\0');
    756756            break;
    757757        }
    758758
    759         case kIfCondVar_QuotedString:
    760             ifcond_var_make_simple_string(pVar);
     759        case kExprVar_QuotedString:
     760            expr_var_make_simple_string(pVar);
    761761            /* fall thru */
    762         case kIfCondVar_QuotedSimpleString:
     762        case kExprVar_QuotedSimpleString:
    763763            /*
    764764             * Use GNU make boolean logic (not empty string means true).
    765765             * No stripping here, the string is quoted.
    766766             */
    767             ifcond_var_assign_bool(pVar, *pVar->uVal.psz != '\0');
     767            expr_var_assign_bool(pVar, *pVar->uVal.psz != '\0');
    768768            break;
    769769
    … …  
    781781 * @param   pThis   The evaluator instance.
    782782 */
    783 static void ifcond_pop_and_delete_var(PIFCOND pThis)
    784 {
    785     ifcond_var_delete(&pThis->aVars[pThis->iVar]);
     783static void expr_pop_and_delete_var(PEXPR pThis)
     784{
     785    expr_var_delete(&pThis->aVars[pThis->iVar]);
    786786    pThis->iVar--;
    787787}
    … …  
    806806 * @param   pVar2   The second variable.
    807807 */
    808 static IFCONDRET ifcond_var_unify_types(PIFCOND pThis, PIFCONDVAR pVar1, PIFCONDVAR pVar2, const char *pszOp)
     808static EXPRRET expr_var_unify_types(PEXPR pThis, PEXPRVAR pVar1, PEXPRVAR pVar2, const char *pszOp)
    809809{
    810810    /*
    811811     * Try make the variables the same type before comparing.
    812812     */
    813     if (    !ifcond_var_was_quoted(pVar1)
    814         &&  !ifcond_var_was_quoted(pVar2))
    815     {
    816         if (    ifcond_var_is_string(pVar1)
    817             ||  ifcond_var_is_string(pVar2))
     813    if (    !expr_var_was_quoted(pVar1)
     814        &&  !expr_var_was_quoted(pVar2))
     815    {
     816        if (    expr_var_is_string(pVar1)
     817            ||  expr_var_is_string(pVar2))
    818818        {
    819             if (!ifcond_var_is_string(pVar1))
    820                 ifcond_var_try_make_num(pVar2);
    821             else if (!ifcond_var_is_string(pVar2))
    822                 ifcond_var_try_make_num(pVar1);
     819            if (!expr_var_is_string(pVar1))
     820                expr_var_try_make_num(pVar2);
     821            else if (!expr_var_is_string(pVar2))
     822                expr_var_try_make_num(pVar1);
    823823            else
    824824            {
    … …  
    826826                 * Both are strings, simplify them then see if both can be made into numbers.
    827827                 */
    828                 IFCONDINT64 iVar1;
    829                 IFCONDINT64 iVar2;
    830 
    831                 ifcond_var_make_simple_string(pVar1);
    832                 ifcond_var_make_simple_string(pVar2);
    833 
    834                 if (    ifcond_string_to_num(NULL, &iVar1, pVar1->uVal.psz, 1 /* fQuiet */) >= kIfCondRet_Ok
    835                     &&  ifcond_string_to_num(NULL, &iVar2, pVar2->uVal.psz, 1 /* fQuiet */) >= kIfCondRet_Ok)
     828                EXPRINT64 iVar1;
     829                EXPRINT64 iVar2;
     830
     831                expr_var_make_simple_string(pVar1);
     832                expr_var_make_simple_string(pVar2);
     833
     834                if (    expr_string_to_num(NULL, &iVar1, pVar1->uVal.psz, 1 /* fQuiet */) >= kExprRet_Ok
     835                    &&  expr_string_to_num(NULL, &iVar2, pVar2->uVal.psz, 1 /* fQuiet */) >= kExprRet_Ok)
    836836                {
    837                     ifcond_var_assign_num(pVar1, iVar1);
    838                     ifcond_var_assign_num(pVar2, iVar2);
     837                    expr_var_assign_num(pVar1, iVar1);
     838                    expr_var_assign_num(pVar2, iVar2);
    839839                }
    840840            }
    … …  
    843843    else
    844844    {
    845         ifcond_var_make_simple_string(pVar1);
    846         ifcond_var_make_simple_string(pVar2);
     845        expr_var_make_simple_string(pVar1);
     846        expr_var_make_simple_string(pVar2);
    847847    }
    848848
    … …  
    850850     * Complain if they aren't the same type now.
    851851     */
    852     if (ifcond_var_is_string(pVar1) != ifcond_var_is_string(pVar2))
    853     {
    854         ifcond_error(pThis, "Unable to unify types for \"%s\"", pszOp);
    855         return kIfCondRet_Error;
    856     }
    857     return kIfCondRet_Ok;
     852    if (expr_var_is_string(pVar1) != expr_var_is_string(pVar2))
     853    {
     854        expr_error(pThis, "Unable to unify types for \"%s\"", pszOp);
     855        return kExprRet_Error;
     856    }
     857    return kExprRet_Ok;
    858858}
    859859
    … …  
    865865 * @param   pThis       The instance.
    866866 */
    867 static IFCONDRET ifcond_op_defined(PIFCOND pThis)
    868 {
    869     PIFCONDVAR          pVar = &pThis->aVars[pThis->iVar];
     867static EXPRRET expr_op_defined(PEXPR pThis)
     868{
     869    PEXPRVAR          pVar = &pThis->aVars[pThis->iVar];
    870870    struct variable    *pMakeVar;
    871871    assert(pThis->iVar >= 0);
    872872
    873     ifcond_var_make_simple_string(pVar);
     873    expr_var_make_simple_string(pVar);
    874874    pMakeVar = lookup_variable(pVar->uVal.psz, strlen(pVar->uVal.psz));
    875     ifcond_var_assign_bool(pVar, pMakeVar && *pMakeVar->value != '\0');
    876 
    877     return kIfCondRet_Ok;
     875    expr_var_assign_bool(pVar, pMakeVar && *pMakeVar->value != '\0');
     876
     877    return kExprRet_Ok;
    878878}
    879879
    … …  
    885885 * @param   pThis       The instance.
    886886 */
    887 static IFCONDRET ifcond_op_target(PIFCOND pThis)
    888 {
    889     PIFCONDVAR          pVar = &pThis->aVars[pThis->iVar];
     887static EXPRRET expr_op_target(PEXPR pThis)
     888{
     889    PEXPRVAR          pVar = &pThis->aVars[pThis->iVar];
    890890    struct file        *pFile = NULL;
    891891    assert(pThis->iVar >= 0);
    … …  
    896896     */
    897897#ifdef CONFIG_WITH_2ND_TARGET_EXPANSION
    898     if (    pVar->enmType == kIfCondVar_String
    899         ||  pVar->enmType == kIfCondVar_QuotedString)
     898    if (    pVar->enmType == kExprVar_String
     899        ||  pVar->enmType == kExprVar_QuotedString)
    900900    {
    901901        pFile = lookup_file(pVar->uVal.psz);
    … …  
    907907#endif
    908908    {
    909         ifcond_var_make_simple_string(pVar);
     909        expr_var_make_simple_string(pVar);
    910910        pFile = lookup_file(pVar->uVal.psz);
    911911    }
    … …  
    923923        pFile = pFile->prev;
    924924
    925     ifcond_var_assign_bool(pVar, pFile != NULL && pFile->is_target);
    926 
    927     return kIfCondRet_Ok;
     925    expr_var_assign_bool(pVar, pFile != NULL && pFile->is_target);
     926
     927    return kExprRet_Ok;
    928928}
    929929
    … …  
    935935 * @param   pThis       The instance.
    936936 */
    937 static IFCONDRET ifcond_op_pluss(PIFCOND pThis)
    938 {
    939     PIFCONDVAR pVar = &pThis->aVars[pThis->iVar];
     937static EXPRRET expr_op_pluss(PEXPR pThis)
     938{
     939    PEXPRVAR pVar = &pThis->aVars[pThis->iVar];
    940940    assert(pThis->iVar >= 0);
    941941
    942     return ifcond_var_make_num(pThis, pVar);
     942    return expr_var_make_num(pThis, pVar);
    943943}
    944944
    … …  
    951951 * @param   pThis       The instance.
    952952 */
    953 static IFCONDRET ifcond_op_minus(PIFCOND pThis)
    954 {
    955     IFCONDRET  rc;
    956     PIFCONDVAR pVar = &pThis->aVars[pThis->iVar];
     953static EXPRRET expr_op_minus(PEXPR pThis)
     954{
     955    EXPRRET  rc;
     956    PEXPRVAR pVar = &pThis->aVars[pThis->iVar];
    957957    assert(pThis->iVar >= 0);
    958958
    959     rc = ifcond_var_make_num(pThis, pVar);
    960     if (rc >= kIfCondRet_Ok)
     959    rc = expr_var_make_num(pThis, pVar);
     960    if (rc >= kExprRet_Ok)
    961961        pVar->uVal.i = -pVar->uVal.i;
    962962
    … …  
    972972 * @param   pThis       The instance.
    973973 */
    974 static IFCONDRET ifcond_op_bitwise_not(PIFCOND pThis)
    975 {
    976     IFCONDRET  rc;
    977     PIFCONDVAR pVar = &pThis->aVars[pThis->iVar];
     974static EXPRRET expr_op_bitwise_not(PEXPR pThis)
     975{
     976    EXPRRET  rc;
     977    PEXPRVAR pVar = &pThis->aVars[pThis->iVar];
    978978    assert(pThis->iVar >= 0);
    979979
    980     rc = ifcond_var_make_num(pThis, pVar);
    981     if (rc >= kIfCondRet_Ok)
     980    rc = expr_var_make_num(pThis, pVar);
     981    if (rc >= kExprRet_Ok)
    982982        pVar->uVal.i = ~pVar->uVal.i;
    983983
    … …  
    992992 * @param   pThis       The instance.
    993993 */
    994 static IFCONDRET ifcond_op_logical_not(PIFCOND pThis)
    995 {
    996     PIFCONDVAR pVar = &pThis->aVars[pThis->iVar];
     994static EXPRRET expr_op_logical_not(PEXPR pThis)
     995{
     996    PEXPRVAR pVar = &pThis->aVars[pThis->iVar];
    997997    assert(pThis->iVar >= 0);
    998998
    999     ifcond_var_assign_bool(pVar, !ifcond_var_make_bool(pVar));
    1000 
    1001     return kIfCondRet_Ok;
     999    expr_var_assign_bool(pVar, !expr_var_make_bool(pVar));
     1000
     1001    return kExprRet_Ok;
    10021002}
    10031003
    … …  
    10091009 * @param   pThis       The instance.
    10101010 */
    1011 static IFCONDRET ifcond_op_multiply(PIFCOND pThis)
    1012 {
    1013     IFCONDRET   rc = kIfCondRet_Ok;
    1014     PIFCONDVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
    1015     PIFCONDVAR  pVar2 = &pThis->aVars[pThis->iVar];
     1011static EXPRRET expr_op_multiply(PEXPR pThis)
     1012{
     1013    EXPRRET   rc = kExprRet_Ok;
     1014    PEXPRVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
     1015    PEXPRVAR  pVar2 = &pThis->aVars[pThis->iVar];
    10161016    assert(pThis->iVar >= 1);
    10171017
    1018     rc = ifcond_var_make_num(pThis, pVar1);
    1019     if (rc >= kIfCondRet_Ok)
    1020     {
    1021         rc = ifcond_var_make_num(pThis, pVar2);
    1022         if (rc >= kIfCondRet_Ok)
     1018    rc = expr_var_make_num(pThis, pVar1);
     1019    if (rc >= kExprRet_Ok)
     1020    {
     1021        rc = expr_var_make_num(pThis, pVar2);
     1022        if (rc >= kExprRet_Ok)
    10231023            pVar1->uVal.i %= pVar2->uVal.i;
    10241024    }
    10251025
    1026     ifcond_pop_and_delete_var(pThis);
     1026    expr_pop_and_delete_var(pThis);
    10271027    return rc;
    10281028}
    … …  
    10361036 * @param   pThis       The instance.
    10371037 */
    1038 static IFCONDRET ifcond_op_divide(PIFCOND pThis)
    1039 {
    1040     IFCONDRET   rc = kIfCondRet_Ok;
    1041     PIFCONDVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
    1042     PIFCONDVAR  pVar2 = &pThis->aVars[pThis->iVar];
     1038static EXPRRET expr_op_divide(PEXPR pThis)
     1039{
     1040    EXPRRET   rc = kExprRet_Ok;
     1041    PEXPRVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
     1042    PEXPRVAR  pVar2 = &pThis->aVars[pThis->iVar];
    10431043    assert(pThis->iVar >= 1);
    10441044
    1045     rc = ifcond_var_make_num(pThis, pVar1);
    1046     if (rc >= kIfCondRet_Ok)
    1047     {
    1048         rc = ifcond_var_make_num(pThis, pVar2);
    1049         if (rc >= kIfCondRet_Ok)
     1045    rc = expr_var_make_num(pThis, pVar1);
     1046    if (rc >= kExprRet_Ok)
     1047    {
     1048        rc = expr_var_make_num(pThis, pVar2);
     1049        if (rc >= kExprRet_Ok)
    10501050            pVar1->uVal.i /= pVar2->uVal.i;
    10511051    }
    10521052
    1053     ifcond_pop_and_delete_var(pThis);
     1053    expr_pop_and_delete_var(pThis);
    10541054    return rc;
    10551055}
    … …  
    10631063 * @param   pThis       The instance.
    10641064 */
    1065 static IFCONDRET ifcond_op_modulus(PIFCOND pThis)
    1066 {
    1067     IFCONDRET   rc = kIfCondRet_Ok;
    1068     PIFCONDVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
    1069     PIFCONDVAR  pVar2 = &pThis->aVars[pThis->iVar];
     1065static EXPRRET expr_op_modulus(PEXPR pThis)
     1066{
     1067    EXPRRET   rc = kExprRet_Ok;
     1068    PEXPRVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
     1069    PEXPRVAR  pVar2 = &pThis->aVars[pThis->iVar];
    10701070    assert(pThis->iVar >= 1);
    10711071
    1072     rc = ifcond_var_make_num(pThis, pVar1);
    1073     if (rc >= kIfCondRet_Ok)
    1074     {
    1075         rc = ifcond_var_make_num(pThis, pVar2);
    1076         if (rc >= kIfCondRet_Ok)
     1072    rc = expr_var_make_num(pThis, pVar1);
     1073    if (rc >= kExprRet_Ok)
     1074    {
     1075        rc = expr_var_make_num(pThis, pVar2);
     1076        if (rc >= kExprRet_Ok)
    10771077            pVar1->uVal.i %= pVar2->uVal.i;
    10781078    }
    10791079
    1080     ifcond_pop_and_delete_var(pThis);
     1080    expr_pop_and_delete_var(pThis);
    10811081    return rc;
    10821082}
    … …  
    10901090 * @param   pThis       The instance.
    10911091 */
    1092 static IFCONDRET ifcond_op_add(PIFCOND pThis)
    1093 {
    1094     IFCONDRET   rc = kIfCondRet_Ok;
    1095     PIFCONDVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
    1096     PIFCONDVAR  pVar2 = &pThis->aVars[pThis->iVar];
     1092static EXPRRET expr_op_add(PEXPR pThis)
     1093{
     1094    EXPRRET   rc = kExprRet_Ok;
     1095    PEXPRVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
     1096    PEXPRVAR  pVar2 = &pThis->aVars[pThis->iVar];
    10971097    assert(pThis->iVar >= 1);
    10981098
    1099     rc = ifcond_var_make_num(pThis, pVar1);
    1100     if (rc >= kIfCondRet_Ok)
    1101     {
    1102         rc = ifcond_var_make_num(pThis, pVar2);
    1103         if (rc >= kIfCondRet_Ok)
     1099    rc = expr_var_make_num(pThis, pVar1);
     1100    if (rc >= kExprRet_Ok)
     1101    {
     1102        rc = expr_var_make_num(pThis, pVar2);
     1103        if (rc >= kExprRet_Ok)
    11041104            pVar1->uVal.i += pVar2->uVal.i;
    11051105    }
    11061106
    1107     ifcond_pop_and_delete_var(pThis);
     1107    expr_pop_and_delete_var(pThis);
    11081108    return rc;
    11091109}
    … …  
    11161116 * @param   pThis       The instance.
    11171117 */
    1118 static IFCONDRET ifcond_op_sub(PIFCOND pThis)
    1119 {
    1120     IFCONDRET   rc = kIfCondRet_Ok;
    1121     PIFCONDVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
    1122     PIFCONDVAR  pVar2 = &pThis->aVars[pThis->iVar];
     1118static EXPRRET expr_op_sub(PEXPR pThis)
     1119{
     1120    EXPRRET   rc = kExprRet_Ok;
     1121    PEXPRVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
     1122    PEXPRVAR  pVar2 = &pThis->aVars[pThis->iVar];
    11231123    assert(pThis->iVar >= 1);
    11241124
    1125     rc = ifcond_var_make_num(pThis, pVar1);
    1126     if (rc >= kIfCondRet_Ok)
    1127     {
    1128         rc = ifcond_var_make_num(pThis, pVar2);
    1129         if (rc >= kIfCondRet_Ok)
     1125    rc = expr_var_make_num(pThis, pVar1);
     1126    if (rc >= kExprRet_Ok)
     1127    {
     1128        rc = expr_var_make_num(pThis, pVar2);
     1129        if (rc >= kExprRet_Ok)
    11301130            pVar1->uVal.i -= pVar2->uVal.i;
    11311131    }
    11321132
    1133     ifcond_pop_and_delete_var(pThis);
     1133    expr_pop_and_delete_var(pThis);
    11341134    return rc;
    11351135}
    … …  
    11411141 * @param   pThis       The instance.
    11421142 */
    1143 static IFCONDRET ifcond_op_shift_left(PIFCOND pThis)
    1144 {
    1145     IFCONDRET   rc = kIfCondRet_Ok;
    1146     PIFCONDVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
    1147     PIFCONDVAR  pVar2 = &pThis->aVars[pThis->iVar];
     1143static EXPRRET expr_op_shift_left(PEXPR pThis)
     1144{
     1145    EXPRRET   rc = kExprRet_Ok;
     1146    PEXPRVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
     1147    PEXPRVAR  pVar2 = &pThis->aVars[pThis->iVar];
    11481148    assert(pThis->iVar >= 1);
    11491149
    1150     rc = ifcond_var_make_num(pThis, pVar1);
    1151     if (rc >= kIfCondRet_Ok)
    1152     {
    1153         rc = ifcond_var_make_num(pThis, pVar2);
    1154         if (rc >= kIfCondRet_Ok)
     1150    rc = expr_var_make_num(pThis, pVar1);
     1151    if (rc >= kExprRet_Ok)
     1152    {
     1153        rc = expr_var_make_num(pThis, pVar2);
     1154        if (rc >= kExprRet_Ok)
    11551155            pVar1->uVal.i <<= pVar2->uVal.i;
    11561156    }
    11571157
    1158     ifcond_pop_and_delete_var(pThis);
     1158    expr_pop_and_delete_var(pThis);
    11591159    return rc;
    11601160}
    … …  
    11671167 * @param   pThis       The instance.
    11681168 */
    1169 static IFCONDRET ifcond_op_shift_right(PIFCOND pThis)
    1170 {
    1171     IFCONDRET   rc = kIfCondRet_Ok;
    1172     PIFCONDVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
    1173     PIFCONDVAR  pVar2 = &pThis->aVars[pThis->iVar];
     1169static EXPRRET expr_op_shift_right(PEXPR pThis)
     1170{
     1171    EXPRRET   rc = kExprRet_Ok;
     1172    PEXPRVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
     1173    PEXPRVAR  pVar2 = &pThis->aVars[pThis->iVar];
    11741174    assert(pThis->iVar >= 1);
    11751175
    1176     rc = ifcond_var_make_num(pThis, pVar1);
    1177     if (rc >= kIfCondRet_Ok)
    1178     {
    1179         rc = ifcond_var_make_num(pThis, pVar2);
    1180         if (rc >= kIfCondRet_Ok)
     1176    rc = expr_var_make_num(pThis, pVar1);
     1177    if (rc >= kExprRet_Ok)
     1178    {
     1179        rc = expr_var_make_num(pThis, pVar2);
     1180        if (rc >= kExprRet_Ok)
    11811181            pVar1->uVal.i >>= pVar2->uVal.i;
    11821182    }
    11831183
    1184     ifcond_pop_and_delete_var(pThis);
     1184    expr_pop_and_delete_var(pThis);
    11851185    return rc;
    11861186}
    … …  
    11931193 * @param   pThis       The instance.
    11941194 */
    1195 static IFCONDRET ifcond_op_less_or_equal_than(PIFCOND pThis)
    1196 {
    1197     IFCONDRET   rc = kIfCondRet_Ok;
    1198     PIFCONDVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
    1199     PIFCONDVAR  pVar2 = &pThis->aVars[pThis->iVar];
     1195static EXPRRET expr_op_less_or_equal_than(PEXPR pThis)
     1196{
     1197    EXPRRET   rc = kExprRet_Ok;
     1198    PEXPRVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
     1199    PEXPRVAR  pVar2 = &pThis->aVars[pThis->iVar];
    12001200    assert(pThis->iVar >= 1);
    12011201
    1202     rc = ifcond_var_unify_types(pThis, pVar1, pVar2, "<=");
    1203     if (rc >= kIfCondRet_Ok)
    1204     {
    1205         if (!ifcond_var_is_string(pVar1))
    1206             ifcond_var_assign_bool(pVar1, pVar1->uVal.i <= pVar2->uVal.i);
     1202    rc = expr_var_unify_types(pThis, pVar1, pVar2, "<=");
     1203    if (rc >= kExprRet_Ok)
     1204    {
     1205        if (!expr_var_is_string(pVar1))
     1206            expr_var_assign_bool(pVar1, pVar1->uVal.i <= pVar2->uVal.i);
    12071207        else
    1208             ifcond_var_assign_bool(pVar1, strcmp(pVar1->uVal.psz, pVar2->uVal.psz) <= 0);
    1209     }
    1210 
    1211     ifcond_pop_and_delete_var(pThis);
     1208            expr_var_assign_bool(pVar1, strcmp(pVar1->uVal.psz, pVar2->uVal.psz) <= 0);
     1209    }
     1210
     1211    expr_pop_and_delete_var(pThis);
    12121212    return rc;
    12131213}
    … …  
    12201220 * @param   pThis       The instance.
    12211221 */
    1222 static IFCONDRET ifcond_op_less_than(PIFCOND pThis)
    1223 {
    1224     IFCONDRET   rc = kIfCondRet_Ok;
    1225     PIFCONDVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
    1226     PIFCONDVAR  pVar2 = &pThis->aVars[pThis->iVar];
     1222static EXPRRET expr_op_less_than(PEXPR pThis)
     1223{
     1224    EXPRRET   rc = kExprRet_Ok;
     1225    PEXPRVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
     1226    PEXPRVAR  pVar2 = &pThis->aVars[pThis->iVar];
    12271227    assert(pThis->iVar >= 1);
    12281228
    1229     rc = ifcond_var_unify_types(pThis, pVar1, pVar2, "<");
    1230     if (rc >= kIfCondRet_Ok)
    1231     {
    1232         if (!ifcond_var_is_string(pVar1))
    1233             ifcond_var_assign_bool(pVar1, pVar1->uVal.i < pVar2->uVal.i);
     1229    rc = expr_var_unify_types(pThis, pVar1, pVar2, "<");
     1230    if (rc >= kExprRet_Ok)
     1231    {
     1232        if (!expr_var_is_string(pVar1))
     1233            expr_var_assign_bool(pVar1, pVar1->uVal.i < pVar2->uVal.i);
    12341234        else
    1235             ifcond_var_assign_bool(pVar1, strcmp(pVar1->uVal.psz, pVar2->uVal.psz) < 0);
    1236     }
    1237 
    1238     ifcond_pop_and_delete_var(pThis);
     1235            expr_var_assign_bool(pVar1, strcmp(pVar1->uVal.psz, pVar2->uVal.psz) < 0);
     1236    }
     1237
     1238    expr_pop_and_delete_var(pThis);
    12391239    return rc;
    12401240}
    … …  
    12471247 * @param   pThis       The instance.
    12481248 */
    1249 static IFCONDRET ifcond_op_greater_or_equal_than(PIFCOND pThis)
    1250 {
    1251     IFCONDRET   rc = kIfCondRet_Ok;
    1252     PIFCONDVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
    1253     PIFCONDVAR  pVar2 = &pThis->aVars[pThis->iVar];
     1249static EXPRRET expr_op_greater_or_equal_than(PEXPR pThis)
     1250{
     1251    EXPRRET   rc = kExprRet_Ok;
     1252    PEXPRVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
     1253    PEXPRVAR  pVar2 = &pThis->aVars[pThis->iVar];
    12541254    assert(pThis->iVar >= 1);
    12551255
    1256     rc = ifcond_var_unify_types(pThis, pVar1, pVar2, ">=");
    1257     if (rc >= kIfCondRet_Ok)
    1258     {
    1259         if (!ifcond_var_is_string(pVar1))
    1260             ifcond_var_assign_bool(pVar1, pVar1->uVal.i >= pVar2->uVal.i);
     1256    rc = expr_var_unify_types(pThis, pVar1, pVar2, ">=");
     1257    if (rc >= kExprRet_Ok)
     1258    {
     1259        if (!expr_var_is_string(pVar1))
     1260            expr_var_assign_bool(pVar1, pVar1->uVal.i >= pVar2->uVal.i);
    12611261        else
    1262             ifcond_var_assign_bool(pVar1, strcmp(pVar1->uVal.psz, pVar2->uVal.psz) >= 0);
    1263     }
    1264 
    1265     ifcond_pop_and_delete_var(pThis);
     1262            expr_var_assign_bool(pVar1, strcmp(pVar1->uVal.psz, pVar2->uVal.psz) >= 0);
     1263    }
     1264
     1265    expr_pop_and_delete_var(pThis);
    12661266    return rc;
    12671267}
    … …  
    12741274 * @param   pThis       The instance.
    12751275 */
    1276 static IFCONDRET ifcond_op_greater_than(PIFCOND pThis)
    1277 {
    1278     IFCONDRET   rc = kIfCondRet_Ok;
    1279     PIFCONDVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
    1280     PIFCONDVAR  pVar2 = &pThis->aVars[pThis->iVar];
     1276static EXPRRET expr_op_greater_than(PEXPR pThis)
     1277{
     1278    EXPRRET   rc = kExprRet_Ok;
     1279    PEXPRVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
     1280    PEXPRVAR  pVar2 = &pThis->aVars[pThis->iVar];
    12811281    assert(pThis->iVar >= 1);
    12821282
    1283     rc = ifcond_var_unify_types(pThis, pVar1, pVar2, ">");
    1284     if (rc >= kIfCondRet_Ok)
    1285     {
    1286         if (!ifcond_var_is_string(pVar1))
    1287             ifcond_var_assign_bool(pVar1, pVar1->uVal.i > pVar2->uVal.i);
     1283    rc = expr_var_unify_types(pThis, pVar1, pVar2, ">");
     1284    if (rc >= kExprRet_Ok)
     1285    {
     1286        if (!expr_var_is_string(pVar1))
     1287            expr_var_assign_bool(pVar1, pVar1->uVal.i > pVar2->uVal.i);
    12881288        else
    1289             ifcond_var_assign_bool(pVar1, strcmp(pVar1->uVal.psz, pVar2->uVal.psz) > 0);
    1290     }
    1291 
    1292     ifcond_pop_and_delete_var(pThis);
     1289            expr_var_assign_bool(pVar1, strcmp(pVar1->uVal.psz, pVar2->uVal.psz) > 0);
     1290    }
     1291
     1292    expr_pop_and_delete_var(pThis);
    12931293    return rc;
    12941294}
    … …  
    13011301 * @param   pThis       The instance.
    13021302 */
    1303 static IFCONDRET ifcond_op_equal(PIFCOND pThis)
    1304 {
    1305     IFCONDRET   rc = kIfCondRet_Ok;
    1306     PIFCONDVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
    1307     PIFCONDVAR  pVar2 = &pThis->aVars[pThis->iVar];
     1303static EXPRRET expr_op_equal(PEXPR pThis)
     1304{
     1305    EXPRRET   rc = kExprRet_Ok;
     1306    PEXPRVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
     1307    PEXPRVAR  pVar2 = &pThis->aVars[pThis->iVar];
    13081308    assert(pThis->iVar >= 1);
    13091309
    … …  
    13111311     * The same type?
    13121312     */
    1313     if (ifcond_var_is_string(pVar1) == ifcond_var_is_string(pVar2))
    1314     {
    1315         if (!ifcond_var_is_string(pVar1))
     1313    if (expr_var_is_string(pVar1) == expr_var_is_string(pVar2))
     1314    {
     1315        if (!expr_var_is_string(pVar1))
    13161316            /* numbers are simple */
    1317             ifcond_var_assign_bool(pVar1, pVar1->uVal.i == pVar2->uVal.i);
     1317            expr_var_assign_bool(pVar1, pVar1->uVal.i == pVar2->uVal.i);
    13181318        else
    13191319        {
    13201320            /* try a normal string compare. */
    1321             ifcond_var_make_simple_string(pVar1);
    1322             ifcond_var_make_simple_string(pVar2);
     1321            expr_var_make_simple_string(pVar1);
     1322            expr_var_make_simple_string(pVar2);
    13231323            if (!strcmp(pVar1->uVal.psz, pVar2->uVal.psz))
    1324                 ifcond_var_assign_bool(pVar1, 1);
     1324                expr_var_assign_bool(pVar1, 1);
    13251325            /* try convert and compare as number instead. */
    1326             else if (   ifcond_var_try_make_num(pVar1) >= kIfCondRet_Ok
    1327                      && ifcond_var_try_make_num(pVar2) >= kIfCondRet_Ok)
    1328                 ifcond_var_assign_bool(pVar1, pVar1->uVal.i == pVar2->uVal.i);
     1326            else if (   expr_var_try_make_num(pVar1) >= kExprRet_Ok
     1327                     && expr_var_try_make_num(pVar2) >= kExprRet_Ok)
     1328                expr_var_assign_bool(pVar1, pVar1->uVal.i == pVar2->uVal.i);
    13291329            /* ok, they really aren't equal. */
    13301330            else
    1331                 ifcond_var_assign_bool(pVar1, 0);
     1331                expr_var_assign_bool(pVar1, 0);
    13321332        }
    13331333    }
    … …  
    13401340         *     numerically. This one is a bit questionable, so we don't try this.
    13411341         */
    1342         if (   ifcond_var_try_make_num(pVar1) >= kIfCondRet_Ok
    1343             && ifcond_var_try_make_num(pVar2) >= kIfCondRet_Ok)
    1344             ifcond_var_assign_bool(pVar1, pVar1->uVal.i == pVar2->uVal.i);
     1342        if (   expr_var_try_make_num(pVar1) >= kExprRet_Ok
     1343            && expr_var_try_make_num(pVar2) >= kExprRet_Ok)
     1344            expr_var_assign_bool(pVar1, pVar1->uVal.i == pVar2->uVal.i);
    13451345        else
    13461346        {
    1347             ifcond_error(pThis, "Cannot compare strings and numbers");
    1348             rc = kIfCondRet_Error;
     1347            expr_error(pThis, "Cannot compare strings and numbers");
     1348            rc = kExprRet_Error;
    13491349        }
    13501350    }
    13511351
    1352     ifcond_pop_and_delete_var(pThis);
    1353     return kIfCondRet_Ok;
     1352    expr_pop_and_delete_var(pThis);
     1353    return kExprRet_Ok;
    13541354}
    13551355
    … …  
    13611361 * @param   pThis       The instance.
    13621362 */
    1363 static IFCONDRET ifcond_op_not_equal(PIFCOND pThis)
    1364 {
    1365     IFCONDRET rc = ifcond_op_equal(pThis);
    1366     if (rc >= kIfCondRet_Ok)
    1367         rc = ifcond_op_logical_not(pThis);
     1363static EXPRRET expr_op_not_equal(PEXPR pThis)
     1364{
     1365    EXPRRET rc = expr_op_equal(pThis);
     1366    if (rc >= kExprRet_Ok)
     1367        rc = expr_op_logical_not(pThis);
    13681368    return rc;
    13691369}
    … …  
    13761376 * @param   pThis       The instance.
    13771377 */
    1378 static IFCONDRET ifcond_op_bitwise_and(PIFCOND pThis)
    1379 {
    1380     PIFCONDVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
    1381     PIFCONDVAR  pVar2 = &pThis->aVars[pThis->iVar];
    1382     IFCONDRET   rc;
     1378static EXPRRET expr_op_bitwise_and(PEXPR pThis)
     1379{
     1380    PEXPRVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
     1381    PEXPRVAR  pVar2 = &pThis->aVars[pThis->iVar];
     1382    EXPRRET   rc;
    13831383    assert(pThis->iVar >= 1);
    13841384
    1385     rc = ifcond_var_make_num(pThis, pVar1);
    1386     if (rc >= kIfCondRet_Ok)
    1387     {
    1388         rc = ifcond_var_make_num(pThis, pVar2);
    1389         if (rc >= kIfCondRet_Ok)
     1385    rc = expr_var_make_num(pThis, pVar1);
     1386    if (rc >= kExprRet_Ok)
     1387    {
     1388        rc = expr_var_make_num(pThis, pVar2);
     1389        if (rc >= kExprRet_Ok)
    13901390            pVar1->uVal.i &= pVar2->uVal.i;
    13911391    }
    13921392
    1393     ifcond_pop_and_delete_var(pThis);
    1394     return kIfCondRet_Ok;
     1393    expr_pop_and_delete_var(pThis);
     1394    return kExprRet_Ok;
    13951395}
    13961396
    … …  
    14021402 * @param   pThis       The instance.
    14031403 */
    1404 static IFCONDRET ifcond_op_bitwise_xor(PIFCOND pThis)
    1405 {
    1406     PIFCONDVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
    1407     PIFCONDVAR  pVar2 = &pThis->aVars[pThis->iVar];
    1408     IFCONDRET   rc;
     1404static EXPRRET expr_op_bitwise_xor(PEXPR pThis)
     1405{
     1406    PEXPRVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
     1407    PEXPRVAR  pVar2 = &pThis->aVars[pThis->iVar];
     1408    EXPRRET   rc;
    14091409    assert(pThis->iVar >= 1);
    14101410
    1411     rc = ifcond_var_make_num(pThis, pVar1);
    1412     if (rc >= kIfCondRet_Ok)
    1413     {
    1414         rc = ifcond_var_make_num(pThis, pVar2);
    1415         if (rc >= kIfCondRet_Ok)
     1411    rc = expr_var_make_num(pThis, pVar1);
     1412    if (rc >= kExprRet_Ok)
     1413    {
     1414        rc = expr_var_make_num(pThis, pVar2);
     1415        if (rc >= kExprRet_Ok)
    14161416            pVar1->uVal.i ^= pVar2->uVal.i;
    14171417    }
    14181418
    1419     ifcond_pop_and_delete_var(pThis);
    1420     return kIfCondRet_Ok;
     1419    expr_pop_and_delete_var(pThis);
     1420    return kExprRet_Ok;
    14211421}
    14221422
    … …  
    14281428 * @param   pThis       The instance.
    14291429 */
    1430 static IFCONDRET ifcond_op_bitwise_or(PIFCOND pThis)
    1431 {
    1432     PIFCONDVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
    1433     PIFCONDVAR  pVar2 = &pThis->aVars[pThis->iVar];
    1434     IFCONDRET   rc;
     1430static EXPRRET expr_op_bitwise_or(PEXPR pThis)
     1431{
     1432    PEXPRVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
     1433    PEXPRVAR  pVar2 = &pThis->aVars[pThis->iVar];
     1434    EXPRRET   rc;
    14351435    assert(pThis->iVar >= 1);
    14361436
    1437     rc = ifcond_var_make_num(pThis, pVar1);
    1438     if (rc >= kIfCondRet_Ok)
    1439     {
    1440         rc = ifcond_var_make_num(pThis, pVar2);
    1441         if (rc >= kIfCondRet_Ok)
     1437    rc = expr_var_make_num(pThis, pVar1);
     1438    if (rc >= kExprRet_Ok)
     1439    {
     1440        rc = expr_var_make_num(pThis, pVar2);
     1441        if (rc >= kExprRet_Ok)
    14421442            pVar1->uVal.i |= pVar2->uVal.i;
    14431443    }
    14441444
    1445     ifcond_pop_and_delete_var(pThis);
    1446     return kIfCondRet_Ok;
     1445    expr_pop_and_delete_var(pThis);
     1446    return kExprRet_Ok;
    14471447}
    14481448
    … …  
    14541454 * @param   pThis       The instance.
    14551455 */
    1456 static IFCONDRET ifcond_op_logical_and(PIFCOND pThis)
    1457 {
    1458     PIFCONDVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
    1459     PIFCONDVAR  pVar2 = &pThis->aVars[pThis->iVar];
     1456static EXPRRET expr_op_logical_and(PEXPR pThis)
     1457{
     1458    PEXPRVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
     1459    PEXPRVAR  pVar2 = &pThis->aVars[pThis->iVar];
    14601460    assert(pThis->iVar >= 1);
    14611461
    1462     if (   ifcond_var_make_bool(pVar1)
    1463         && ifcond_var_make_bool(pVar2))
    1464         ifcond_var_assign_bool(pVar1, 1);
     1462    if (   expr_var_make_bool(pVar1)
     1463        && expr_var_make_bool(pVar2))
     1464        expr_var_assign_bool(pVar1, 1);
    14651465    else
    1466         ifcond_var_assign_bool(pVar1, 0);
    1467 
    1468     ifcond_pop_and_delete_var(pThis);
    1469     return kIfCondRet_Ok;
     1466        expr_var_assign_bool(pVar1, 0);
     1467
     1468    expr_pop_and_delete_var(pThis);
     1469    return kExprRet_Ok;
    14701470}
    14711471
    … …  
    14771477 * @param   pThis       The instance.
    14781478 */
    1479 static IFCONDRET ifcond_op_logical_or(PIFCOND pThis)
    1480 {
    1481     PIFCONDVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
    1482     PIFCONDVAR  pVar2 = &pThis->aVars[pThis->iVar];
     1479static EXPRRET expr_op_logical_or(PEXPR pThis)
     1480{
     1481    PEXPRVAR  pVar1 = &pThis->aVars[pThis->iVar - 1];
     1482    PEXPRVAR  pVar2 = &pThis->aVars[pThis->iVar];
    14831483    assert(pThis->iVar >= 1);
    14841484
    1485     if (   ifcond_var_make_bool(pVar1)
    1486         || ifcond_var_make_bool(pVar2))
    1487         ifcond_var_assign_bool(pVar1, 1);
     1485    if (   expr_var_make_bool(pVar1)
     1486        || expr_var_make_bool(pVar2))
     1487        expr_var_assign_bool(pVar1, 1);
    14881488    else
    1489         ifcond_var_assign_bool(pVar1, 0);
    1490 
    1491     ifcond_pop_and_delete_var(pThis);
    1492     return kIfCondRet_Ok;
     1489        expr_var_assign_bool(pVar1, 0);
     1490
     1491    expr_pop_and_delete_var(pThis);
     1492    return kExprRet_Ok;
    14931493}
    14941494
    … …  
    15001500 * @param   pThis       The instance.
    15011501 */
    1502 static IFCONDRET ifcond_op_left_parenthesis(PIFCOND pThis)
     1502static EXPRRET expr_op_left_parenthesis(PEXPR pThis)
    15031503{
    15041504    /*
    … …  
    15061506     * eat it. If not found there is an inbalance.
    15071507     */
    1508     IFCONDRET rc = ifcond_get_binary_or_eoe_or_rparen(pThis);
    1509     if (    rc == kIfCondRet_Operator
     1508    EXPRRET rc = expr_get_binary_or_eoe_or_rparen(pThis);
     1509    if (    rc == kExprRet_Operator
    15101510        &&  pThis->apOps[pThis->iOp]->szOp[0] == ')')
    15111511    {
    15121512        /* pop it and get another one which we can leave pending. */
    15131513        pThis->iOp--;
    1514         rc = ifcond_get_binary_or_eoe_or_rparen(pThis);
    1515         if (rc >= kIfCondRet_Ok)
    1516             ifcond_unget_op(pThis);
     1514        rc = expr_get_binary_or_eoe_or_rparen(pThis);
     1515        if (rc >= kExprRet_Ok)
     1516            expr_unget_op(pThis);
    15171517    }
    15181518    else
    15191519    {
    1520         ifcond_error(pThis, "Missing ')'");
    1521         rc = kIfCondRet_Error;
     1520        expr_error(pThis, "Missing ')'");
     1521        rc = kExprRet_Error;
    15221522    }
    15231523
    … …  
    15321532 * @param   pThis       The instance.
    15331533 */
    1534 static IFCONDRET ifcond_op_right_parenthesis(PIFCOND pThis)
    1535 {
    1536     return kIfCondRet_Ok;
     1534static EXPRRET expr_op_right_parenthesis(PEXPR pThis)
     1535{
     1536    return kExprRet_Ok;
    15371537}
    15381538
    … …  
    15481548 * means that || must come before |, or else | will match all.
    15491549 */
    1550 static const IFCONDOP g_aIfCondOps[] =
    1551 {
    1552 #define IFCOND_OP(szOp, iPrecedence, cArgs, pfn)  {  szOp, sizeof(szOp) - 1, '\0', iPrecedence, cArgs, pfn }
     1550static const EXPROP g_aExprOps[] =
     1551{
     1552#define EXPR_OP(szOp, iPrecedence, cArgs, pfn)  {  szOp, sizeof(szOp) - 1, '\0', iPrecedence, cArgs, pfn }
    15531553    /*        Name, iPrecedence,  cArgs,    pfn    */
    1554     IFCOND_OP("defined",     90,      1,    ifcond_op_defined),
    1555     IFCOND_OP("target",      90,      1,    ifcond_op_target),
    1556     IFCOND_OP("+",           80,      1,    ifcond_op_pluss),
    1557     IFCOND_OP("-",           80,      1,    ifcond_op_minus),
    1558     IFCOND_OP("~",           80,      1,    ifcond_op_bitwise_not),
    1559     IFCOND_OP("*",           75,      2,    ifcond_op_multiply),
    1560     IFCOND_OP("/",           75,      2,    ifcond_op_divide),
    1561     IFCOND_OP("%",           75,      2,    ifcond_op_modulus),
    1562     IFCOND_OP("+",           70,      2,    ifcond_op_add),
    1563     IFCOND_OP("-",           70,      2,    ifcond_op_sub),
    1564     IFCOND_OP("<<",          65,      2,    ifcond_op_shift_left),
    1565     IFCOND_OP(">>",          65,      2,    ifcond_op_shift_right),
    1566     IFCOND_OP("<=",          60,      2,    ifcond_op_less_or_equal_than),
    1567     IFCOND_OP("<",           60,      2,    ifcond_op_less_than),
    1568     IFCOND_OP(">=",          60,      2,    ifcond_op_greater_or_equal_than),
    1569     IFCOND_OP(">",           60,      2,    ifcond_op_greater_than),
    1570     IFCOND_OP("==",          55,      2,    ifcond_op_equal),
    1571     IFCOND_OP("!=",          55,      2,    ifcond_op_not_equal),
    1572     IFCOND_OP("!",           80,      1,    ifcond_op_logical_not),
    1573     IFCOND_OP("^",           45,      2,    ifcond_op_bitwise_xor),
    1574     IFCOND_OP("&&",          35,      2,    ifcond_op_logical_and),
    1575     IFCOND_OP("&",           50,      2,    ifcond_op_bitwise_and),
    1576     IFCOND_OP("||",          30,      2,    ifcond_op_logical_or),
    1577     IFCOND_OP("|",           40,      2,    ifcond_op_bitwise_or),
    1578             { "(", 1, ')',   10,      1,    ifcond_op_left_parenthesis },
    1579             { ")", 1, '(',   10,      0,    ifcond_op_right_parenthesis },
    1580  /*         { "?", 1, ':',    5,      2,    ifcond_op_question },
    1581             { ":", 1, '?',    5,      2,    ifcond_op_colon }, -- too weird for now. */
    1582 #undef IFCOND_OP
     1554    EXPR_OP("defined",     90,      1,    expr_op_defined),
     1555    EXPR_OP("target",      90,      1,    expr_op_target),
     1556    EXPR_OP("+",           80,      1,    expr_op_pluss),
     1557    EXPR_OP("-",           80,      1,    expr_op_minus),
     1558    EXPR_OP("~",           80,      1,    expr_op_bitwise_not),
     1559    EXPR_OP("*",           75,      2,    expr_op_multiply),
     1560    EXPR_OP("/",           75,      2,    expr_op_divide),
     1561    EXPR_OP("%",           75,      2,    expr_op_modulus),
     1562    EXPR_OP("+",           70,      2,    expr_op_add),
     1563    EXPR_OP("-",           70,      2,    expr_op_sub),
     1564    EXPR_OP("<<",          65,      2,    expr_op_shift_left),
     1565    EXPR_OP(">>",          65,      2,    expr_op_shift_right),
     1566    EXPR_OP("<=",          60,      2,    expr_op_less_or_equal_than),
     1567    EXPR_OP("<",           60,      2,    expr_op_less_than),
     1568    EXPR_OP(">=",          60,      2,    expr_op_greater_or_equal_than),
     1569    EXPR_OP(">",           60,      2,    expr_op_greater_than),
     1570    EXPR_OP("==",          55,      2,    expr_op_equal),
     1571    EXPR_OP("!=",          55,      2,    expr_op_not_equal),
     1572    EXPR_OP("!",           80,      1,    expr_op_logical_not),
     1573    EXPR_OP("^",           45,      2,    expr_op_bitwise_xor),
     1574    EXPR_OP("&&",          35,      2,    expr_op_logical_and),
     1575    EXPR_OP("&",           50,      2,    expr_op_bitwise_and),
     1576    EXPR_OP("||",          30,      2,    expr_op_logical_or),
     1577    EXPR_OP("|",           40,      2,    expr_op_bitwise_or),
     1578            { "(", 1, ')',   10,      1,    expr_op_left_parenthesis },
     1579            { ")", 1, '(',   10,      0,    expr_op_right_parenthesis },
     1580 /*         { "?", 1, ':',    5,      2,    expr_op_question },
     1581            { ":", 1, '?',    5,      2,    expr_op_colon }, -- too weird for now. */
     1582#undef EXPR_OP
    15831583};
    15841584
    15851585/** Dummy end of expression fake. */
    1586 static const IFCONDOP g_IfCondEndOfExpOp =
     1586static const EXPROP g_ExprEndOfExpOp =
    15871587{
    15881588              "", 0, '\0',    0,      0,    NULL
    … …  
    15931593 * Initializes the opcode character map if necessary.
    15941594 */
    1595 static void ifcond_map_init(void)
     1595static void expr_map_init(void)
    15961596{
    15971597    int i;
    1598     if (g_fIfCondInitializedMap)
     1598    if (g_fExprInitializedMap)
    15991599        return;
    16001600
    … …  
    16031603     */
    16041604    memset(&g_auchOpStartCharMap, 0, sizeof(g_auchOpStartCharMap));
    1605     for (i = 0; i < sizeof(g_aIfCondOps) / sizeof(g_aIfCondOps[0]); i++)
    1606     {
    1607         unsigned int ch = (unsigned int)g_aIfCondOps[i].szOp[0];
     1605    for (i = 0; i < sizeof(g_aExprOps) / sizeof(g_aExprOps[0]); i++)
     1606    {
     1607        unsigned int ch = (unsigned int)g_aExprOps[i].szOp[0];
    16081608        if (!g_auchOpStartCharMap[ch])
    16091609            g_auchOpStartCharMap[ch] = (i << 1) | 1;
    16101610    }
    16111611
    1612     g_fIfCondInitializedMap = 1;
     1612    g_fExprInitializedMap = 1;
    16131613}
    16141614
    … …  
    16251625 * @param   ch      The character.
    16261626 */
    1627 static unsigned char ifcond_map_get(char ch)
     1627static unsigned char expr_map_get(char ch)
    16281628{
    16291629    return g_auchOpStartCharMap[(unsigned int)ch];
    … …  
    16361636 * @returns Pointer to the matching operator. NULL if not found.
    16371637 * @param   psz     Pointer to what can be an operator.
    1638  * @param   uchVal  The ifcond_map_get value.
     1638 * @param   uchVal  The expr_map_get value.
    16391639 * @param   fUnary  Whether it must be an unary operator or not.
    16401640 */
    1641 static PCIFCONDOP ifcond_lookup_op(char const *psz, unsigned char uchVal, int fUnary)
     1641static PCEXPROP expr_lookup_op(char const *psz, unsigned char uchVal, int fUnary)
    16421642{
    16431643    char ch = *psz;
    16441644    int i;
    16451645
    1646     for (i = uchVal >> 1; i < sizeof(g_aIfCondOps) / sizeof(g_aIfCondOps[0]); i++)
     1646    for (i = uchVal >> 1; i < sizeof(g_aExprOps) / sizeof(g_aExprOps[0]); i++)
    16471647    {
    16481648        /* compare the string... */
    1649         switch (g_aIfCondOps[i].cchOp)
     1649        switch (g_aExprOps[i].cchOp)
    16501650        {
    16511651            case 1:
    1652                 if (g_aIfCondOps[i].szOp[0] != ch)
     1652                if (g_aExprOps[i].szOp[0] != ch)
    16531653                    continue;
    16541654                break;
    16551655            case 2:
    1656                 if (    g_aIfCondOps[i].szOp[0] != ch
    1657                     ||  g_aIfCondOps[i].szOp[1] != psz[1])
     1656                if (    g_aExprOps[i].szOp[0] != ch
     1657                    ||  g_aExprOps[i].szOp[1] != psz[1])
    16581658                    continue;
    16591659                break;
    16601660            default:
    1661                 if (    g_aIfCondOps[i].szOp[0] != ch
    1662                     ||  strncmp(&g_aIfCondOps[i].szOp[1], psz + 1, g_aIfCondOps[i].cchOp - 1))
     1661                if (    g_aExprOps[i].szOp[0] != ch
     1662                    ||  strncmp(&g_aExprOps[i].szOp[1], psz + 1, g_aExprOps[i].cchOp - 1))
    16631663                    continue;
    16641664                break;
    … …  
    16661666
    16671667        /* ... and the operator type. */
    1668         if (fUnary == (g_aIfCondOps[i].cArgs == 1))
     1668        if (fUnary == (g_aExprOps[i].cArgs == 1))
    16691669        {
    16701670            /* got a match! */
    1671             return &g_aIfCondOps[i];
     1671            return &g_aExprOps[i];
    16721672        }
    16731673    }
    … …  
    16841684 * @param   pThis       The evaluator instance.
    16851685 */
    1686 static void ifcond_unget_op(PIFCOND pThis)
     1686static void expr_unget_op(PEXPR pThis)
    16871687{
    16881688    assert(pThis->pPending == NULL);
    … …  
    17041704 *
    17051705 * @returns status code. Will grumble on failure.
    1706  * @retval  kIfCondRet_EndOfExpr if we encountered the end of the expression.
    1707  * @retval  kIfCondRet_Operator if we encountered a binary operator or right
     1706 * @retval  kExprRet_EndOfExpr if we encountered the end of the expression.
     1707 * @retval  kExprRet_Operator if we encountered a binary operator or right
    17081708 *          parenthesis. It's on the operator stack.
    17091709 *
    17101710 * @param   pThis       The evaluator instance.
    17111711 */
    1712 static IFCONDRET ifcond_get_binary_or_eoe_or_rparen(PIFCOND pThis)
     1712static EXPRRET expr_get_binary_or_eoe_or_rparen(PEXPR pThis)
    17131713{
    17141714    /*
    17151715     * See if there is anything pending first.
    17161716     */
    1717     PCIFCONDOP pOp = pThis->pPending;
     1717    PCEXPROP pOp = pThis->pPending;
    17181718    if (pOp)
    17191719        pThis->pPending = NULL;
    … …  
    17311731        if (*psz)
    17321732        {
    1733             unsigned char uchVal = ifcond_map_get(*psz);
     1733            unsigned char uchVal = expr_map_get(*psz);
    17341734            if (uchVal)
    1735                 pOp = ifcond_lookup_op(psz, uchVal, 0 /* fUnary */);
     1735                pOp = expr_lookup_op(psz, uchVal, 0 /* fUnary */);
    17361736            if (!pOp)
    17371737            {
    1738                 ifcond_error(pThis, "Expected binary operator, found \"%.42s\"...", psz);
    1739                 return kIfCondRet_Error;
     1738                expr_error(pThis, "Expected binary operator, found \"%.42s\"...", psz);
     1739                return kExprRet_Error;
    17401740            }
    17411741            psz += pOp->cchOp;
    17421742        }
    17431743        else
    1744             pOp = &g_IfCondEndOfExpOp;
     1744            pOp = &g_ExprEndOfExpOp;
    17451745        pThis->psz = psz;
    17461746    }
    … …  
    17491749     * Push it.
    17501750     */
    1751     if (pThis->iOp >= IFCOND_MAX_OPERATORS - 1)
    1752     {
    1753         ifcond_error(pThis, "Operator stack overflow");
    1754         return kIfCondRet_Error;
     1751    if (pThis->iOp >= EXPR_MAX_OPERATORS - 1)
     1752    {
     1753        expr_error(pThis, "Operator stack overflow");
     1754        return kExprRet_Error;
    17551755    }
    17561756    pThis->apOps[++pThis->iOp] = pOp;
    17571757
    17581758    return pOp->iPrecedence
    1759          ? kIfCondRet_Operator
    1760          : kIfCondRet_EndOfExpr;
     1759         ? kExprRet_Operator
     1760         : kExprRet_EndOfExpr;
    17611761}
    17621762
    … …  
    17731773 *
    17741774 * @returns status code. On failure we'll be done bitching already.
    1775  * @retval  kIfCondRet_Operator if we encountered an unary operator.
     1775 * @retval  kExprRet_Operator if we encountered an unary operator.
    17761776 *          It's on the operator stack.
    1777  * @retval  kIfCondRet_Operand if we encountered an operand operator.
     1777 * @retval  kExprRet_Operand if we encountered an operand operator.
    17781778 *          It's on the operand stack.
    17791779 *
    17801780 * @param   This        The evaluator instance.
    17811781 */
    1782 static IFCONDRET ifcond_get_unary_or_operand(PIFCOND pThis)
    1783 {
    1784     IFCONDRET       rc;
     1782static EXPRRET expr_get_unary_or_operand(PEXPR pThis)
     1783{
     1784    EXPRRET       rc;
    17851785    unsigned char   uchVal;
    1786     PCIFCONDOP      pOp;
     1786    PCEXPROP      pOp;
    17871787    char const     *psz = pThis->psz;
    17881788
    … …  
    17941794    if (!*psz)
    17951795    {
    1796         ifcond_error(pThis, "Unexpected end of expression");
    1797         return kIfCondRet_Error;
     1796        expr_error(pThis, "Unexpected end of expression");
     1797        return kExprRet_Error;
    17981798    }
    17991799
    … …  
    18021802     */
    18031803    pOp = NULL;
    1804     uchVal = ifcond_map_get(*psz);
     1804    uchVal = expr_map_get(*psz);
    18051805    if (uchVal)
    1806         pOp = ifcond_lookup_op(psz, uchVal, 1 /* fUnary */);
     1806        pOp = expr_lookup_op(psz, uchVal, 1 /* fUnary */);
    18071807    if (pOp)
    18081808    {
    … …  
    18101810         * Push the operator onto the stack.
    18111811         */
    1812         if (pThis->iVar < IFCOND_MAX_OPERANDS - 1)
     1812        if (pThis->iVar < EXPR_MAX_OPERANDS - 1)
    18131813        {
    18141814            pThis->apOps[++pThis->iOp] = pOp;
    1815             rc = kIfCondRet_Operator;
     1815            rc = kExprRet_Operator;
    18161816        }
    18171817        else
    18181818        {
    1819             ifcond_error(pThis, "Operator stack overflow");
    1820             rc = kIfCondRet_Error;
     1819            expr_error(pThis, "Operator stack overflow");
     1820            rc = kExprRet_Error;
    18211821        }
    18221822        psz += pOp->cchOp;
    18231823    }
    1824     else if (pThis->iVar < IFCOND_MAX_OPERANDS - 1)
     1824    else if (pThis->iVar < EXPR_MAX_OPERANDS - 1)
    18251825    {
    18261826        /*
    … …  
    18301830        const char *pszStart = psz;
    18311831
    1832         rc = kIfCondRet_Ok;
     1832        rc = kExprRet_Ok;
    18331833        if (*psz == '"')
    18341834        {
    … …  
    18361836            while (*psz && *psz != '"')
    18371837                psz++;
    1838             ifcond_var_init_substring(&pThis->aVars[++pThis->iVar], pszStart, psz - pszStart, kIfCondVar_QuotedString);
     1838            expr_var_init_substring(&pThis->aVars[++pThis->iVar], pszStart, psz - pszStart, kExprVar_QuotedString);
    18391839        }
    18401840        else if (*psz == '\'')
    … …  
    18431843            while (*psz && *psz != '\'')
    18441844                psz++;
    1845             ifcond_var_init_substring(&pThis->aVars[++pThis->iVar], pszStart, psz - pszStart, kIfCondVar_QuotedSimpleString);
     1845            expr_var_init_substring(&pThis->aVars[++pThis->iVar], pszStart, psz - pszStart, kExprVar_QuotedSimpleString);
    18461846        }
    18471847        else
    … …  
    18621862                    if (iPar > sizeof(achPars) / sizeof(achPars[0]))
    18631863                    {
    1864                         ifcond_error(pThis, "Too deep nesting of variable expansions");
    1865                         rc = kIfCondRet_Error;
     1864                        expr_error(pThis, "Too deep nesting of variable expansions");
     1865                        rc = kExprRet_Error;
    18661866                        break;
    18671867                    }
    … …  
    18751875                else if (!chEndPar)
    18761876                {
    1877                     /** @todo combine isspace and ifcond_map_get! */
    1878                     unsigned chVal = ifcond_map_get(ch);
     1877                    /** @todo combine isspace and expr_map_get! */
     1878                    unsigned chVal = expr_map_get(ch);
    18791879                    if (chVal)
    18801880                    {
    1881                         PCIFCONDOP pOp = ifcond_lookup_op(psz, uchVal, 0 /* fUnary */);
     1881                        PCEXPROP pOp = expr_lookup_op(psz, uchVal, 0 /* fUnary */);
    18821882                        if (pOp)
    18831883                            break;
    … …  
    18911891            }
    18921892
    1893             if (rc == kIfCondRet_Ok)
    1894                 ifcond_var_init_substring(&pThis->aVars[++pThis->iVar], pszStart, psz - pszStart, kIfCondVar_String);
     1893            if (rc == kExprRet_Ok)
     1894                expr_var_init_substring(&pThis->aVars[++pThis->iVar], pszStart, psz - pszStart, kExprVar_String);
    18951895        }
    18961896    }
    18971897    else
    18981898    {
    1899         ifcond_error(pThis, "Operand stack overflow");
    1900         rc = kIfCondRet_Error;
     1899        expr_error(pThis, "Operand stack overflow");
     1900        rc = kExprRet_Error;
    19011901    }
    19021902    pThis->psz = psz;
    … …  
    19131913 * @param   pThis       The instance.
    19141914 */
    1915 static IFCONDRET ifcond_eval(PIFCOND pThis)
    1916 {
    1917     IFCONDRET  rc;
    1918     PCIFCONDOP pOp;
     1915static EXPRRET expr_eval(PEXPR pThis)
     1916{
     1917    EXPRRET  rc;
     1918    PCEXPROP pOp;
    19191919
    19201920    /*
    … …  
    19261926         * Eat unary operators until we hit an operand.
    19271927         */
    1928         do  rc = ifcond_get_unary_or_operand(pThis);
    1929         while (rc == kIfCondRet_Operator);
    1930         if (rc < kIfCondRet_Error)
     1928        do  rc = expr_get_unary_or_operand(pThis);
     1929        while (rc == kExprRet_Operator);
     1930        if (rc < kExprRet_Error)
    19311931            break;
    19321932
    … …  
    19341934         * Look for a binary operator, right parenthesis or end of expression.
    19351935         */
    1936         rc = ifcond_get_binary_or_eoe_or_rparen(pThis);
    1937         if (rc < kIfCondRet_Error)
     1936        rc = expr_get_binary_or_eoe_or_rparen(pThis);
     1937        if (rc < kExprRet_Error)
    19381938            break;
    1939         ifcond_unget_op(pThis);
     1939        expr_unget_op(pThis);
    19401940
    19411941        /*
    … …  
    19501950            pOp = pThis->apOps[pThis->iOp--];
    19511951            rc = pOp->pfn(pThis);
    1952             if (rc < kIfCondRet_Error)
     1952            if (rc < kExprRet_Error)
    19531953                break;
    19541954        }
    1955         if (rc < kIfCondRet_Error)
     1955        if (rc < kExprRet_Error)
    19561956            break;
    19571957
    … …  
    19601960         * There should be no right parenthesis here.
    19611961         */
    1962         rc = ifcond_get_binary_or_eoe_or_rparen(pThis);
    1963         if (rc < kIfCondRet_Error)
     1962        rc = expr_get_binary_or_eoe_or_rparen(pThis);
     1963        if (rc < kExprRet_Error)
    19641964            break;
    19651965        pOp = pThis->apOps[pThis->iOp];
    … …  
    19681968        if (!pOp->cArgs)
    19691969        {
    1970             ifcond_error(pThis, "Unexpected \"%s\"", pOp->szOp);
    1971             rc = kIfCondRet_Error;
     1970            expr_error(pThis, "Unexpected \"%s\"", pOp->szOp);
     1971            rc = kExprRet_Error;
    19721972            break;
    19731973        }
    … …  
    19831983 * @param   pThis       The instance to destroy.
    19841984 */
    1985 static void ifcond_destroy(PIFCOND pThis)
     1985static void expr_destroy(PEXPR pThis)
    19861986{
    19871987    while (pThis->iVar >= 0)
    19881988    {
    1989         ifcond_var_delete(pThis->aVars);
     1989        expr_var_delete(pThis->aVars);
    19901990        pThis->iVar--;
    19911991    }
    … …  
    20002000 *
    20012001 * @param   pszExpr     What to parse.
    2002  *                      This must stick around until ifcond_destroy.
    2003  */
    2004 static PIFCOND ifcond_create(char const *pszExpr)
    2005 {
    2006     PIFCOND pThis = (PIFCOND)xmalloc(sizeof(*pThis));
     2002 *                      This must stick around until expr_destroy.
     2003 */
     2004static PEXPR expr_create(char const *pszExpr)
     2005{
     2006    PEXPR pThis = (PEXPR)xmalloc(sizeof(*pThis));
    20072007    pThis->pszExpr = pszExpr;
    20082008    pThis->psz = pszExpr;
    … …  
    20122012    pThis->iOp = -1;
    20132013
    2014     ifcond_map_init();
     2014    expr_map_init();
    20152015    return pThis;
    20162016}
    … …  
    20282028 * @param   flocp   The file location, used for errors.
    20292029 */
    2030 int ifcond(char *line, const struct floc *flocp)
     2030int expr_eval_if_conditionals(char *line, const struct floc *flocp)
    20312031{
    20322032    /*
    … …  
    20352035     */
    20362036    int rc = -1;
    2037     PIFCOND pIfCond = ifcond_create(line);
    2038     pIfCond->pFileLoc = flocp;
    2039     if (ifcond_eval(pIfCond) >= kIfCondRet_Ok)
     2037    PEXPR pExpr = expr_create(line);
     2038    pExpr->pFileLoc = flocp;
     2039    if (expr_eval(pExpr) >= kExprRet_Ok)
    20402040    {
    20412041        /*
    … …  
    20432043         * set our return value accordingly.
    20442044         */
    2045         if (ifcond_var_make_bool(&pIfCond->aVars[0]))
     2045        if (expr_var_make_bool(&pExpr->aVars[0]))
    20462046            rc = 0;
    20472047        else
    20482048            rc = 1;
    20492049    }
    2050     ifcond_destroy(pIfCond);
     2050    expr_destroy(pExpr);
    20512051
    20522052    return rc;
    … …  
    20542054
    20552055
     2056/**
     2057 * Evaluates the given expression and returns the result as a string.
     2058 *
     2059 * @returns variable buffer position.
     2060 *
     2061 * @param   o       The current variable buffer position.
     2062 * @param   expr    The expression.
     2063 */
     2064char *expr_eval_to_string(char *o, char *expr)
     2065{
     2066    /*
     2067     * Instantiate the expression evaluator and let
     2068     * it have a go at it.
     2069     */
     2070    PEXPR pExpr = expr_create(expr);
     2071    if (expr_eval(pExpr) >= kExprRet_Ok)
     2072    {
     2073        /*
     2074         * Convert the result (on top of the stack) to a string
     2075         * and copy it out the variable buffer.
     2076         */
     2077        PEXPRVAR pVar = &pExpr->aVars[0];
     2078        expr_var_make_simple_string(pVar);
     2079        o = variable_buffer_output(o, pVar->uVal.psz, strlen(pVar->uVal.psz));
     2080    }
     2081    expr_destroy(pExpr);
     2082
     2083    return o;
     2084}
     2085
     2086
    20562087#endif /* CONFIG_WITH_IF_CONDITIONALS */
    20572088

  • trunk/src/kmk/make.h

    r1719 r1724  
    729729
    730730#ifdef CONFIG_WITH_IF_CONDITIONALS
    731 extern int ifcond(char *line, const struct floc *flocp);
    732 #endif
    733 
     731extern int expr_eval_if_conditionals(char *line, const struct floc *flocp);
     732extern char *expr_eval_to_string(char *o, char *expr);
     733#endif
     734

  • trunk/src/kmk/read.c

    r1719 r1724  
    452452     free (stream_buf);
    453453  }
    454 #endif 
     454#endif
    455455  free (ebuf.bufstart);
    456456  alloca (0);
    … …  
    20042004{
    20052005  char *cmdname;
    2006   enum { c_ifdef, c_ifndef, c_ifeq, c_ifneq, 
     2006  enum { c_ifdef, c_ifndef, c_ifeq, c_ifneq,
    20072007#ifdef CONFIG_WITH_SET_CONDITIONALS
    2008     c_if1of, c_ifn1of, 
     2008    c_if1of, c_ifn1of,
    20092009#endif
    20102010#ifdef CONFIG_WITH_IF_CONDITIONALS
    20112011    c_ifcond,
    20122012#endif
    2013     c_else, c_endif 
     2013    c_else, c_endif
    20142014  } cmdtype;
    20152015  unsigned int i;
    … …  
    20312031#ifdef CONFIG_WITH_IF_CONDITIONALS
    20322032  else chkword ("if", c_ifcond)
    2033 #endif 
     2033#endif
    20342034  else chkword ("else", c_else)
    20352035  else chkword ("endif", c_endif)
    … …  
    21732173  else if (cmdtype == c_ifcond)
    21742174    {
    2175       int rval = ifcond (line, flocp);
     2175      int rval = expr_eval_if_conditionals (line, flocp);
    21762176      if (rval == -1)
    21772177          return rval;
注意: 瀏覽 TracChangeset 來幫助您使用更動檢視器

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette