自学教程：C++ AGFREE函数代码示例

static voidinit_scm(void){    last_scm_cmd = SCHEME_INIT_TEXT;    {        SCM ini_res = ag_scm_c_eval_string_from_file_line(            SCHEME_INIT_TEXT, AG_TEXT_STRTABLE_FILE, SCHEME_INIT_TEXT_LINENO);        AGDUPSTR(libguile_ver, scm2display(ini_res), "ini res");    }    {        unsigned int maj, min, mic;        switch (sscanf(libguile_ver, "%u.%u.%u", &maj, &min, &mic)) {        case 2:        case 3: break;        default:            AG_ABEND(aprf(GUILE_VERSION_BAD, libguile_ver));            /* NOT_REACHED */        }        maj = min + (100 * maj);        if ((GUILE_VERSION / 1000) != maj)            AG_ABEND(aprf(GUILE_VERSION_WRONG, libguile_ver,                          MK_STR(GUILE_VERSION)));    }    {#       if GUILE_VERSION >= 200000#         define SCHEME_INIT_DEBUG SCHEME_INIT_DEBUG_2_0#       else#         define SCHEME_INIT_DEBUG SCHEME_INIT_DEBUG_1_6#       endif        char * p = aprf(INIT_SCM_ERRS_FMT, SCHEME_INIT_DEBUG);#       undef  SCHEME_INIT_DEBUG        last_scm_cmd = p;        ag_scm_c_eval_string_from_file_line(p, __FILE__, __LINE__);        AGFREE(p);    }}

/*=export_func  optionTimeVal * private: * * what:  process an option with a time duration. * arg:   + tOptions * + opts + program options descriptor + * arg:   + tOptDesc * + od   + the descriptor for this arg + * * doc: *  Decipher a time duration value.=*/voidoptionTimeVal(tOptions * opts, tOptDesc * od){    time_t val;    if (INQUERY_CALL(opts, od))        return;    val = parse_duration(od->optArg.argString);    if (val == BAD_TIME) {        fprintf(stderr, zNotDuration, opts->pzProgName, od->optArg.argString);        if ((opts->fOptSet & OPTPROC_ERRSTOP) != 0)            (*(opts->pUsageProc))(opts, EXIT_FAILURE);    }    if (od->fOptState & OPTST_ALLOC_ARG) {        AGFREE(od->optArg.argString);        od->fOptState &= ~OPTST_ALLOC_ARG;    }    od->optArg.argInt = (long)val;}

/*=export_func  optionTimeVal * private: * * what:  process an option with a time duration. * arg:   + tOptions* + pOpts    + program options descriptor + * arg:   + tOptDesc* + pOptDesc + the descriptor for this arg + * * doc: *  Decipher a time duration value.=*/voidoptionTimeVal(tOptions * pOpts, tOptDesc * pOD){    time_t val;    if ((pOD->fOptState & OPTST_RESET) != 0)        return;    val = parse_duration(pOD->optArg.argString);    if (val == BAD_TIME) {        fprintf(stderr, zNotDuration, pOpts->pzProgName, pOD->optArg.argString);        if ((pOpts->fOptSet & OPTPROC_ERRSTOP) != 0)            (*(pOpts->pUsageProc))(pOpts, EXIT_FAILURE);    }    if (pOD->fOptState & OPTST_ALLOC_ARG) {        AGFREE(pOD->optArg.argString);        pOD->fOptState &= ~OPTST_ALLOC_ARG;    }    pOD->optArg.argInt = (unsigned long)val;}

/** *  handle AutoOpts mode flags */static char *aoflags_directive(tOptions * pOpts, char * pzText){    char * pz = pzText;    while (IS_WHITESPACE_CHAR(*++pz))  ;    pzText = strchr(pz, '>');    if (pzText != NULL) {        size_t len  = pzText - pz;        char * ftxt = AGALOC(len + 1, "aoflags");        memcpy(ftxt, pz, len);        ftxt[len] = NUL;        set_usage_flags(pOpts, ftxt);        AGFREE(ftxt);        pzText++;    }    return pzText;}

/** *  handle AutoOpts mode flags. * *  @param[in,out] opts  program option descriptor *  @param[in]     txt   scanning pointer *  @returns       the next character to look at */static char *aoflags_directive(tOptions * opts, char * txt){    char * pz;    pz = SPN_WHITESPACE_CHARS(txt+1);    txt = strchr(pz, '>');    if (txt != NULL) {        size_t len  = (unsigned)(txt - pz);        char * ftxt = AGALOC(len + 1, "aoflags");        memcpy(ftxt, pz, len);        ftxt[len] = NUL;        set_usage_flags(opts, ftxt);        AGFREE(ftxt);        txt++;    }    return txt;}

static voidprintSetMemberArg(FILE * fp, tOptDesc * pOD){    uintptr_t val = pOD->optArg.argEnum;    /*     *  This is a magic incantation that will convert the     *  bit flag values back into a string suitable for printing.     */    (*(pOD->pOptProc))(OPTPROC_RETURN_VALNAME, pOD);    printEntry( fp, pOD, (const void*)(pOD->optArg.argString));    if (pOD->optArg.argString != NULL) {        /*         *  set membership strings get allocated         */        AGFREE( pOD->optArg.argString );        pOD->fOptState &= ~OPTST_ALLOC_ARG;    }    pOD->optArg.argEnum = val;}

/** *  This gets called when all is well at the end. */LOCAL voidcleanup(tTemplate* pTF){    if (HAVE_OPT(USED_DEFINES))        print_used_defines();    if (pfDepends != NULL)        wrap_up_depends();    optionFree(&autogenOptions);    for (;;) {        tTemplate* pT = pNamedTplList;        if (pT == NULL)            break;        pNamedTplList = (tTemplate*)(void*)(pT->pNext);        unloadTemplate(pT);    }    AGFREE(forInfo.fi_data);    unloadTemplate(pTF);    unloadDefs();}

static voidprint_one_paragraph(char const * text, bool plain, FILE * fp){    if (plain) {#ifdef ENABLE_NLS#ifdef HAVE_LIBINTL_H#ifdef DEBUG_ENABLED#undef gettext#endif        char * buf = dgettext("libopts", text);        if (buf == text)            text = gettext(text);#endif /* HAVE_LIBINTL_H */#endif /* ENABLE_NLS */        fputs(text, fp);    }    else {        char const * t = optionQuoteString(text, LINE_SPLICE);        fprintf(fp, PUTS_FMT, t);        AGFREE((void *)t);    }}

static int delete_data_entry (SCROLLER_T * scrlr, void *delete_me){    NEXTED_PTR_T *data_ptr = delete_me;    register NEXTED_PTR_T *tmp;    if (data_ptr == scrlr->first_data_ptr)    {        scrlr->first_data_ptr = data_ptr->next;        if (data_ptr == scrlr->last_data_ptr)            scrlr->last_data_ptr = NULL;    }    else    {                            /* not first */        for (tmp = scrlr->first_data_ptr; tmp; tmp = tmp->next)        {            if (tmp->next == data_ptr)            {                if (data_ptr == scrlr->last_data_ptr)                    scrlr->last_data_ptr = tmp;                tmp->next = data_ptr->next;                break;            }        }                        /* for */    }                            /* not first */    if (data_ptr == scrlr->current_data_ptr)        scrlr->current_data_ptr = data_ptr->next;    if (scrlr->data_destructor)        scrlr->data_destructor (scrlr, data_ptr);    AGFREE (data_ptr);    scrlr->data_created--;    scrlr->data_stored--;    return 0;}

/* *  eval_true - should a string be interpreted as TRUE? * *  It is always true unless: * *  1.  it is the empty string *  2.  it starts with a digit and the number evaluates to zero *  3.  it starts with either "#f" or "#F" *  4.  For its length or its first five characters (whichever is less) *      it matches the string "false" */static ag_booleval_true(void){    ag_bool needFree;    ag_bool res = AG_TRUE;    char const * pz = evalExpression(&needFree);    if (IS_DEC_DIGIT_CHAR(*pz))        res = (atoi(pz) == 0) ? AG_FALSE : AG_TRUE;    else switch (*pz) {    case NUL:        res = AG_FALSE;        break;    case '#':        if ((pz[1] == 'f') || (pz[1] == 'F'))            res = AG_FALSE;        break;    case 'f':    case 'F':    {        int len = strlen(pz);        if (len > 5)            len = 5;        if (strneqvcmp(EVAL_TRUE_FALSE_STR, pz, len) == 0)            res = AG_FALSE;        break;    }    }    if (needFree)        AGFREE(pz);    return res;}

/** *  This directive @i{is} processed, but only if the expression begins with *  either a back quote (@code{`}) or an open parenthesis (@code{(}). *  Text within the back quotes are handed off to the shell for processing *  and parenthesized text is handed off to Guile.  Multiple line expressions *  must be joined with backslashes. * *  If the @code{shell-script} or @code{scheme-expr} do not yield @code{true} *  valued results, autogen will be aborted.  If @code{<anything else>} or *  nothing at all is provided, then this directive is ignored. * *  The result is @code{false} (and fails) if the result is empty, the *  number zero, or a string that starts with the letters 'n' or 'f' ("no" *  or "false"). */char *doDir_assert(directive_enum_t id, char const * dir, char * scan_next){    (void)id;    dir = SPN_WHITESPACE_CHARS(dir);    switch (*dir) {    case '`':    {        char * pzS = (char *)dir+1;        char * pzR = SPN_WHITESPACE_BACK(pzS, NULL);        if (*(--pzR) != '`')            break; /* not a valid script */        *pzR = NUL;        pzS = shell_cmd((char const *)pzS);        check_assert_str(pzS, dir);        AGFREE(pzS);        break;    }    case '(':    {        SCM res = ag_scm_c_eval_string_from_file_line(            dir, cctx->scx_fname, cctx->scx_line);        check_assert_str(scm2display(res), dir);        break;    }    default:        break;    }    return scan_next;}

/** * handle program segmentation of config file. * *  @param[in,out] opts  program option descriptor *  @param[in]     txt   scanning pointer *  @returns       the next character to look at */static char *program_directive(tOptions * opts, char * txt){    static char const ttlfmt[] = "<?";    size_t ttl_len  = sizeof(ttlfmt) + strlen(zCfgProg);    char * ttl      = AGALOC(ttl_len, "prog title");    size_t name_len = strlen(opts->pzProgName);    memcpy(ttl, ttlfmt, sizeof(ttlfmt) - 1);    memcpy(ttl + sizeof(ttlfmt) - 1, zCfgProg, ttl_len - (sizeof(ttlfmt) - 1));    do  {        txt = SPN_WHITESPACE_CHARS(txt+1);        if (  (strneqvcmp(txt, opts->pzProgName, (int)name_len) == 0)           && (IS_END_XML_TOKEN_CHAR(txt[name_len])) ) {            txt += name_len;            break;        }        txt = strstr(txt, ttl);    } while (txt != NULL);    AGFREE(ttl);    if (txt != NULL)        for (;;) {            if (*txt == NUL) {                txt = NULL;                break;            }            if (*(txt++) == '>')                break;        }    return txt;}

//.........这里部分代码省略.........        &Select_Compare,        &Select_Equivalent_Full,        &Select_Equivalent_End,        &Select_Equivalent_Start,        &Select_Equivalent,        &Select_Match_Full,        &Select_Match_End,        &Select_Match_Start,        &Select_Match,        &Select_Match_Always,        &Select_Match_Existence,        &Select_Match_NonExistence    };    static char const * const match_names[] = {        "COMPARE_FULL",        "COMPARE_END",        "COMPARE_START",        "CONTAINS",        "EQUIVALENT_FULL",        "EQUIVALENT_END",        "EQUIVALENT_START",        "EQUIV_CONTAINS",        "MATCH_FULL",        "MATCH_END",        "MATCH_START",        "MATCH_WITHIN",        "MATCH_ALWAYS",        "MATCH_EXISTENCE",        "MATCH_NONEXISTENCE"    };    tMacro*   pEnd = pT->aMacros + pMac->endIndex;    ag_bool needFree;    char const * pzSampleText = evalExpression(&needFree);    /*     *  Search through the selection clauses until we either     *  reach the end of the list for this CASE macro, or we match.     */    for (;;) {        tSuccess mRes;        pMac = pT->aMacros + pMac->sibIndex;        if (pMac >= pEnd) {            if (OPT_VALUE_TRACE >= TRACE_BLOCK_MACROS) {                fprintf(pfTrace, "CASE string `%s' did not match/n",                        pzSampleText);                if (OPT_VALUE_TRACE == TRACE_EVERYTHING)                    fprintf(pfTrace, zFileLine, pCurTemplate->pzTplFile,                            pMac->lineNo);            }            break;        }        /*         *  The current macro becomes the selected selection macro         */        pCurMacro = pMac;        mRes = (*(match_procs[pMac->funcCode & 0x0F])               )(pzSampleText, pT->pzTemplText + pMac->ozText);        /*         *  IF match, THEN generate and stop looking for a match.         */        if (SUCCEEDED(mRes)) {            if (OPT_VALUE_TRACE >= TRACE_BLOCK_MACROS) {                fprintf(pfTrace, "CASE string `%s' %s matched `%s'/n",                        pzSampleText,                        match_names[pMac->funcCode & 0x0F],                        pT->pzTemplText + pMac->ozText);                if (OPT_VALUE_TRACE == TRACE_EVERYTHING)                    fprintf(pfTrace, zFileLine, pCurTemplate->pzTplFile,                            pMac->lineNo);            }            generateBlock(pT, pMac + 1, pT->aMacros + pMac->sibIndex);            break;        }        else if (OPT_VALUE_TRACE == TRACE_EVERYTHING) {            fprintf(pfTrace, "CASE no match: `%s' %s vs. `%s'/n",                    pzSampleText,                    match_names[pMac->funcCode & 0x0F],                    pT->pzTemplText + pMac->ozText);        }    }    if (needFree)        AGFREE((void*)pzSampleText);    return pEnd;}

/** *  Invokes @code{$SHELL} or @file{/bin/sh} on a script that should *  generate AutoGen definitions.  It does this using the same server *  process that handles the back-quoted @code{`} text. *  The block of text handed to the shell is terminated with *  the #endshell directive. * *  @strong{CAUTION}@:  let not your @code{$SHELL} be @code{csh}. */char *doDir_shell(directive_enum_t id, char const * arg, char * scan_next){    static size_t const endshell_len = sizeof("/n#endshell") - 1;    scan_ctx_t * pCtx;    char *       pzText = scan_next;    (void)arg;    (void)id;    /*     *  The output time will always be the current time.     *  The dynamic content is always current :)     */    maxfile_time = outfile_time = time(NULL);    /*     *  IF there are no data after the '#shell' directive,     *  THEN we won't write any data     *  ELSE we have to find the end of the data.     */    if (strncmp(pzText, DIRECT_SHELL_END_SHELL+1, endshell_len-1) == 0)        return scan_next;    {        char * pz = strstr(scan_next, DIRECT_SHELL_END_SHELL);        if (pz == NULL)            AG_ABEND(aprf(DIRECT_SHELL_NOEND, cctx->scx_fname,                          cctx->scx_line));        while (scan_next < pz) {            if (*(scan_next++) == NL) cctx->scx_line++;        }        *scan_next = NUL;    }    /*     *  Advance the scan pointer to the next line after '#endshell'     *  IF there is no such line,     *  THEN the scan will resume on a zero-length string.     */    scan_next = strchr(scan_next + endshell_len, NL);    if (scan_next == NULL)        scan_next = VOIDP(zNil);    /*     *  Save the scan pointer into the current context     */    cctx->scx_scan  = scan_next;    /*     *  Run the shell command.  The output text becomes the     *  "file text" that is used for more definitions.     */    pzText = shell_cmd(pzText);    if (pzText == NULL)        return scan_next;    if (*pzText == NUL) {        AGFREE(pzText);        return scan_next;    }    /*     *  Get the space for the output data and for context overhead.     *  This is an extra allocation and copy, but easier than rewriting     *  'loadData()' for this special context.     */    pCtx = (scan_ctx_t *)AGALOC(sizeof(scan_ctx_t) + strlen(pzText) + 4,                             "shell output");    /*     *  Link the new scan data into the context stack     */    pCtx->scx_next = cctx;    cctx           = pCtx;    /*     *  Set up the rest of the context structure     */    AGDUPSTR(pCtx->scx_fname, DIRECT_SHELL_COMP_DEFS, DIRECT_SHELL_COMP_DEFS);    pCtx->scx_scan  =    pCtx->scx_data  = (char *)(pCtx + 1);    pCtx->scx_line  = 0;    strcpy(pCtx->scx_scan, pzText);    AGFREE(pzText);    return pCtx->scx_scan;}

static intwrite_eventControl(int action, u_char * var_val, u_char var_val_type,                   size_t var_val_len, u_char * statP,                   oid * name, size_t name_len){    long            long_temp;    char           *char_temp;    int             leaf_id, snmp_status;    static int      prev_action = COMMIT;    RMON_ENTRY_T   *hdr;    CRTL_ENTRY_T   *cloned_body;    switch (action) {    case RESERVE1:    case FREE:    case UNDO:    case ACTION:    case COMMIT:    default:        return ROWAPI_do_another_action(name, eventEntryFirstIndexBegin,                                        action, &prev_action,                                        table_ptr, sizeof(CRTL_ENTRY_T));    case RESERVE2:        /*         * get values from PDU, check them and save them in the cloned entry          */        long_temp = name[eventEntryFirstIndexBegin];        leaf_id = (int) name[eventEntryFirstIndexBegin - 1];        hdr = ROWAPI_find(table_ptr, long_temp);        /* it MUST be OK */        cloned_body = (CRTL_ENTRY_T *) hdr->tmp;        switch (leaf_id) {        case Leaf_event_index:            return SNMP_ERR_NOTWRITABLE;        case Leaf_event_description:            char_temp = AGMALLOC(1 + MAX_event_description);            if (!char_temp)                return SNMP_ERR_TOOBIG;            snmp_status = AGUTIL_get_string_value(var_val, var_val_type,                                                  var_val_len,                                                  MAX_event_description,                                                  1, NULL, char_temp);            if (SNMP_ERR_NOERROR != snmp_status) {                AGFREE(char_temp);                return snmp_status;            }            if (cloned_body->event_description)                AGFREE(cloned_body->event_description);            cloned_body->event_description = AGSTRDUP(char_temp);            /*             * ag_trace ("rx: event_description=<%s>", cloned_body->event_description);              */            AGFREE(char_temp);            break;        case Leaf_event_type:            snmp_status = AGUTIL_get_int_value(var_val, var_val_type,                                               var_val_len,                                               EVENT_NONE,                                               EVENT_LOG_AND_TRAP,                                               &long_temp);            if (SNMP_ERR_NOERROR != snmp_status) {                return snmp_status;            }            cloned_body->event_type = long_temp;            break;        case Leaf_event_last_time_sent:            return SNMP_ERR_NOTWRITABLE;        case Leaf_event_community:            char_temp = AGMALLOC(1 + MAX_event_community);            if (!char_temp)                return SNMP_ERR_TOOBIG;            snmp_status = AGUTIL_get_string_value(var_val, var_val_type,                                                  var_val_len,                                                  MAX_event_community,                                                  1, NULL, char_temp);            if (SNMP_ERR_NOERROR != snmp_status) {                AGFREE(char_temp);                return snmp_status;            }            if (cloned_body->event_community)                AGFREE(cloned_body->event_community);            cloned_body->event_community = AGSTRDUP(char_temp);            AGFREE(char_temp);            break;        case Leaf_eventOwner:            if (hdr->new_owner)                AGFREE(hdr->new_owner);            hdr->new_owner = AGMALLOC(MAX_OWNERSTRING);;            if (!hdr->new_owner)                return SNMP_ERR_TOOBIG;            snmp_status = AGUTIL_get_string_value(var_val, var_val_type,                                                  var_val_len,                                                  MAX_OWNERSTRING,                                                  1, NULL, hdr->new_owner);//.........这里部分代码省略.........

/*************************************************** * Function:write_etherStatsEntry  ***************************************************/static intwrite_etherStatsEntry(int action, u_char * var_val, u_char var_val_type,                      size_t var_val_len, u_char * statP,                      oid * name, size_t name_len){    long            long_temp;    int             leaf_id, snmp_status;    static int      prev_action = COMMIT;    RMON_ENTRY_T   *hdr;    CRTL_ENTRY_T   *cloned_body;    CRTL_ENTRY_T   *body;    switch (action) {    case RESERVE1:    case FREE:    case UNDO:    case ACTION:    case COMMIT:    default:        snmp_status =            ROWAPI_do_another_action(name, etherStatsEntryFirstIndexBegin,                                     action, &prev_action, table_ptr,                                     sizeof(CRTL_ENTRY_T));        if (SNMP_ERR_NOERROR != snmp_status) {            ag_trace("failed action %d with %d", action, snmp_status);        }        break;    case RESERVE2:        /*         * get values from PDU, check them and save them in the cloned entry          */        long_temp = name[etherStatsEntryFirstIndexBegin];        leaf_id = (int) name[etherStatsEntryFirstIndexBegin - 1];        hdr = ROWAPI_find(table_ptr, long_temp);        /* it MUST be OK */        cloned_body = (CRTL_ENTRY_T *) hdr->tmp;        body = (CRTL_ENTRY_T *) hdr->body;        switch (leaf_id) {        case Leaf_etherStatsDataSource:            snmp_status = AGUTIL_get_oid_value(var_val, var_val_type,                                               var_val_len,                                               &cloned_body->data_source);            if (SNMP_ERR_NOERROR != snmp_status) {                return snmp_status;            }            if (RMON1_ENTRY_UNDER_CREATION != hdr->status &&                snmp_oid_compare(cloned_body->data_source.objid,                                 cloned_body->data_source.length,                                 body->data_source.objid,                                 body->data_source.length))                return SNMP_ERR_BADVALUE;            break;            break;        case Leaf_etherStatsOwner:            if (hdr->new_owner)                AGFREE(hdr->new_owner);            hdr->new_owner = AGMALLOC(MAX_OWNERSTRING);;            if (!hdr->new_owner)                return SNMP_ERR_TOOBIG;            snmp_status = AGUTIL_get_string_value(var_val, var_val_type,                                                  var_val_len,                                                  MAX_OWNERSTRING,                                                  1, NULL, hdr->new_owner);            if (SNMP_ERR_NOERROR != snmp_status) {                return snmp_status;            }            break;        case Leaf_etherStatsStatus:            snmp_status = AGUTIL_get_int_value(var_val, var_val_type,                                               var_val_len,                                               RMON1_ENTRY_VALID,                                               RMON1_ENTRY_INVALID,                                               &long_temp);            if (SNMP_ERR_NOERROR != snmp_status) {                ag_trace("cannot browse etherStatsStatus");                return snmp_status;            }            hdr->new_status = long_temp;            break;            break;        default:            ag_trace("%s:unknown leaf_id=%d/n", table_ptr->name,                     (int) leaf_id);            return SNMP_ERR_NOSUCHNAME;        }                       /* of switch by 'leaf_id' */        break;    }                           /* of switch by 'action' */    prev_action = action;    return SNMP_ERR_NOERROR;}

intROWAPI_commit(TABLE_DEFINTION_T * table_ptr, u_long ctrl_index){    register RMON_ENTRY_T *eptr;    eptr = ROWAPI_find(table_ptr, ctrl_index);    if (!eptr) {        ag_trace("Smth wrong ?");        return SNMP_ERR_GENERR;    }    eptr->only_just_created = 0;    switch (eptr->new_status) { /* this status we want to set */    case RMON1_ENTRY_CREATE_REQUEST:   /* copy tmp => eprt */        if (eptr->new_owner) {            if (eptr->owner)                AGFREE(eptr->owner);            eptr->owner = AGSTRDUP(eptr->new_owner);        }        if (table_ptr->ClbkCopy && eptr->tmp)            table_ptr->ClbkCopy(eptr);        break;    case RMON1_ENTRY_INVALID:        ROWAPI_delete_clone(table_ptr, ctrl_index);        rowapi_delete(eptr);#if 0                           /* for debug */        dbg_f_AG_MEM_REPORT();#endif        break;    case RMON1_ENTRY_VALID:    /* copy tmp => eprt and activate */        /*         * Our MIB understanding extension: we permit to set         * VALID when entry doesn't exit, in this case PDU has to have         * the nessessary & valid set of non-default values         */        if (eptr->new_owner) {            if (eptr->owner)                AGFREE(eptr->owner);            eptr->owner = AGSTRDUP(eptr->new_owner);        }        if (table_ptr->ClbkCopy && eptr->tmp)            table_ptr->ClbkCopy(eptr);        if (RMON1_ENTRY_VALID != eptr->status) {            rowapi_activate(table_ptr, eptr);        }        break;    case RMON1_ENTRY_UNDER_CREATION:   /* deactivate (if need) and copy tmp => eprt */        /*         * Our MIB understanding extension: we permit to travel from         * VALID to 'UNDER_CREATION' state         */        rowapi_deactivate(table_ptr, eptr);        if (eptr->new_owner) {            if (eptr->owner)                AGFREE(eptr->owner);            eptr->owner = AGSTRDUP(eptr->new_owner);        }        if (table_ptr->ClbkCopy && eptr->tmp)            table_ptr->ClbkCopy(eptr);        break;    }    ROWAPI_delete_clone(table_ptr, ctrl_index);    return SNMP_ERR_NOERROR;}

/* * creates an entry, locats it in proper sorted order by index * Row is initialized to zero, * except: 'next', 'table_ptr', 'index', * 'timer_id' & 'status'=(RMON1_ENTRY_UNDER_CREATION) * Calls (if need) ClbkCreate. * Schedules for timeout under entry creation (id of this * scheduling is saved in 'timer_id'). * Returns 0: OK, -1:max. number exedes; -2:malloc failed; -3:ClbkCreate failed */intROWAPI_new(TABLE_DEFINTION_T * table_ptr, u_long ctrl_index){    register RMON_ENTRY_T *eptr;    register RMON_ENTRY_T *prev = NULL;    register RMON_ENTRY_T *enew;    /*     * check on 'max.number'     */    if (table_ptr->max_number_of_entries > 0 &&            table_ptr->current_number_of_entries >=            table_ptr->max_number_of_entries)        return -1;    /*     * allocate memory for the header     */    enew = (RMON_ENTRY_T *) AGMALLOC(sizeof(RMON_ENTRY_T));    if (!enew)        return -2;    /*     * init the header     */    memset(enew, 0, sizeof(RMON_ENTRY_T));    enew->ctrl_index = ctrl_index;    enew->table_ptr = (void *) table_ptr;    enew->status = RMON1_ENTRY_UNDER_CREATION;    enew->only_just_created = 1;    /*     * create the body: alloc it and set defaults     */    if (table_ptr->ClbkCreate) {        if (0 != table_ptr->ClbkCreate(enew)) {            AGFREE(enew);            return -3;        }    }    table_ptr->current_number_of_entries++;    /*     * find the place : before 'eptr' and after 'prev'     */    for (eptr = table_ptr->first; eptr; eptr = eptr->next) {        if (ctrl_index < eptr->ctrl_index)            break;        prev = eptr;    }    /*     * insert it     */    enew->next = eptr;    if (prev)        prev->next = enew;    else        table_ptr->first = enew;    enew->timer_id = snmp_alarm_register(MAX_CREATION_TIME, 0,                                         rowapi_too_long_creation_callback,                                         enew);    ag_trace("Entry %ld in %s has been created",             enew->ctrl_index, table_ptr->name);    return 0;}

//.........这里部分代码省略.........                    if (SNMP_ERR_NOERROR != snmp_status)                    {                        return snmp_status;                    }                    if (RMON1_ENTRY_UNDER_CREATION != hdr->status &&                        snmp_oid_compare (cloned_body->var_name.objid,                                          cloned_body->var_name.length, body->var_name.objid, body->var_name.length))                        return SNMP_ERR_BADVALUE;                    break;                    break;                case IDalarmSampleType:                    snmp_status = AGUTIL_get_int_value (var_val, var_val_type,                                                        var_val_len,                                                        SAMPLE_TYPE_ABSOLUTE, SAMPLE_TYPE_DELTE, &long_tmp);                    if (SNMP_ERR_NOERROR != snmp_status)                    {                        return snmp_status;                    }                    cloned_body->sample_type = long_tmp;                    break;                case IDalarmStartupAlarm:                    snmp_status = AGUTIL_get_int_value (var_val, var_val_type,                                                        var_val_len, ALARM_RISING, ALARM_BOTH, &long_tmp);                    if (SNMP_ERR_NOERROR != snmp_status)                    {                        return snmp_status;                    }                    cloned_body->startup_type = long_tmp;                    break;                case IDalarmRisingThreshold:                    snmp_status = AGUTIL_get_int_value (var_val, var_val_type, var_val_len, 0, MMM_MAX, &long_tmp);                    if (SNMP_ERR_NOERROR != snmp_status)                    {                        return snmp_status;                    }                    cloned_body->rising_threshold = long_tmp;                    break;                case IDalarmFallingThreshold:                    snmp_status = AGUTIL_get_int_value (var_val, var_val_type, var_val_len, 0, 0xFFFFFFFFl, &long_tmp);                    if (SNMP_ERR_NOERROR != snmp_status)                    {                        return snmp_status;                    }                    cloned_body->falling_threshold = long_tmp;                    break;                case IDalarmRisingEventIndex:                    snmp_status = AGUTIL_get_int_value (var_val, var_val_type, var_val_len, 0,    /* min. value */                                                        0,    /* max. value */                                                        &long_tmp);                    if (SNMP_ERR_NOERROR != snmp_status)                    {                        return snmp_status;                    }                    cloned_body->rising_event_index = long_tmp;                    break;                case IDalarmFallingEventIndex:                    snmp_status = AGUTIL_get_int_value (var_val, var_val_type, var_val_len, 0,    /* min. value */                                                        0,    /* max. value */                                                        &long_tmp);                    if (SNMP_ERR_NOERROR != snmp_status)                    {                        return snmp_status;                    }                    cloned_body->falling_event_index = long_tmp;                    break;                case IDalarmOwner:                    if (hdr->new_owner)                        AGFREE (hdr->new_owner);                    hdr->new_owner = AGMALLOC (MAX_OWNERSTRING);;                    if (!hdr->new_owner)                        return SNMP_ERR_TOOBIG;                    snmp_status = AGUTIL_get_string_value (var_val, var_val_type,                                                           var_val_len, MAX_OWNERSTRING, 1, NULL, hdr->new_owner);                    if (SNMP_ERR_NOERROR != snmp_status)                    {                        return snmp_status;                    }                    break;                case IDalarmStatus:                    snmp_status = AGUTIL_get_int_value (var_val, var_val_type,                                                        var_val_len, RMON1_ENTRY_VALID, RMON1_ENTRY_INVALID, &long_tmp);                    if (SNMP_ERR_NOERROR != snmp_status)                    {                        return snmp_status;                    }                    hdr->new_status = long_tmp;                    break;                default:                    ag_trace ("%s:unknown leaf_id=%d/n", table_ptr->name, (int) leaf_id);                    return SNMP_ERR_NOSUCHNAME;            }                    /* of switch by 'leaf_id' */            break;    }                            /* of switch by actions */    prev_action = action;    return SNMP_ERR_NOERROR;}

/*=export_func  optionNumericVal * private: * * what:  process an option with a numeric value. * arg:   + tOptions * + opts + program options descriptor + * arg:   + tOptDesc * + od   + the descriptor for this arg + * * doc: *  Decipher a numeric value.=*/voidoptionNumericVal(tOptions * opts, tOptDesc * od){    char * pz;    long   val;    /*     *  Guard against all the different ways this procedure might get invoked     *  when there is no string argument provided.     */    if (INQUERY_CALL(opts, od) || (od->optArg.argString == NULL))        return;    /*     *  Numeric options may have a range associated with it.     *  If it does, the usage procedure requests that it be     *  emitted by passing a NULL od pointer.  Also bail out     *  if there is no option argument or if we are being reset.     */    if (  (od == NULL)            || (od->optArg.argString == NULL)            || ((od->fOptState & OPTST_RESET) != 0)            || (opts <= OPTPROC_EMIT_LIMIT))        return;    errno = 0;    val = strtol(od->optArg.argString, &pz, 0);    if ((pz == od->optArg.argString) || (errno != 0))        goto bad_number;    if ((od->fOptState & OPTST_SCALED_NUM) != 0)        switch (*(pz++)) {        case NUL:            pz--;            break;        case 't':            val *= 1000;        case 'g':            val *= 1000;        case 'm':            val *= 1000;        case 'k':            val *= 1000;            break;        case 'T':            val *= 1024;        case 'G':            val *= 1024;        case 'M':            val *= 1024;        case 'K':            val *= 1024;            break;        default:            goto bad_number;        }    if (*pz != NUL)        goto bad_number;    if (od->fOptState & OPTST_ALLOC_ARG) {        AGFREE(od->optArg.argString);        od->fOptState &= ~OPTST_ALLOC_ARG;    }    od->optArg.argInt = val;    return;bad_number:    fprintf( stderr, zNotNumber, opts->pzProgName, od->optArg.argString );    if ((opts->fOptSet & OPTPROC_ERRSTOP) != 0)        (*(opts->pUsageProc))(opts, EXIT_FAILURE);    errno = EINVAL;    od->optArg.argInt = ~0;}

//.........这里部分代码省略.........    {        static char const curdir[]  = ".";        static char const zDirFmt[] = "%s/%s";        /*         *  Search each directory in our directory search list         *  for the file.  We always force one copy of this option.         */        int  ct = STACKCT_OPT(TEMPL_DIRS);        char const ** ppzDir = STACKLST_OPT(TEMPL_DIRS) + ct - 1;        char const *  pzDir  = curdir;        if (*pzFName == '/')            ct = 0;        do  {            char * pzEnd;            void * coerce;            /*             *  IF one of our template paths starts with '$', then expand it.             */            if (*pzDir == '$') {                if (! optionMakePath(pzFullName, (int)AG_PATH_MAX, pzDir,                                     autogenOptions.pzProgPath)) {                    coerce = (void *)pzDir;                    strcpy(coerce, curdir);                } else {                    AGDUPSTR(pzDir, pzFullName, "find directory name");                    coerce = (void *)ppzDir[1];                    free(coerce);                    ppzDir[1] = pzDir; /* save the computed name for later */                }            }            if ((*pzFName == '/') || (pzDir == curdir)) {                size_t nln = strlen(pzFName);                if (nln >= AG_PATH_MAX - MAX_SUFFIX_LEN)                    break;                memcpy(pzFullName, pzFName, nln);                pzEnd  = pzFullName + nln;                *pzEnd = NUL;            }            else {                pzEnd = pzFullName                    + snprintf(pzFullName, AG_PATH_MAX - MAX_SUFFIX_LEN,                               zDirFmt, pzDir, pzFName);            }            if (read_okay(pzFullName))                goto findFileReturn;            /*             *  IF the file does not already have a suffix,             *  THEN try the ones that are okay for this file.             */            if ((pzSfx == NULL) && (papSuffixList != NULL)) {                char const * const * papSL = papSuffixList;                *(pzEnd++) = '.';                do  {                    strcpy(pzEnd, *(papSL++)); /* must fit */                    if (read_okay(pzFullName))                        goto findFileReturn;                } while (*papSL != NULL);            }            if (*pzFName == '/')                break;            /*             *  IF there is a referrer, use it before the rest of the             *  TEMPL_DIRS We detect first time through by *both* pzDir value             *  and ct value.  "ct" will have this same value next time             *  through and occasionally "pzDir" will be set to "curdir", but             *  never again when ct is STACKCT_OPT(TEMPL_DIRS)             */            if (  (pzReferrer != NULL)               && (pzDir == curdir)               && (ct == STACKCT_OPT(TEMPL_DIRS))) {                pzDir = pzReferrer;                ct++;            } else {                pzDir = *(ppzDir--);            }        } while (--ct >= 0);    }    res = FAILURE; findFileReturn:    AGFREE(deallocAddr);    AGFREE(pzReferrer);    return res;}

/*=export_func  optionUnstackArg * private: * * what:  Remove option args from a stack * arg:   + tOptions* + opts + program options descriptor + * arg:   + tOptDesc* + od   + the descriptor for this arg + * * doc: *  Invoked for options that are equivalenced to stacked options.=*/voidoptionUnstackArg(tOptions * opts, tOptDesc * od){    tArgList * arg_list;    if (INQUERY_CALL(opts, od))        return;    arg_list = (tArgList*)od->optCookie;    /*     *  IF we don't have any stacked options,     *  THEN indicate that we don't have any of these options     */    if (arg_list == NULL) {        od->fOptState &= OPTST_PERSISTENT_MASK;        if ((od->fOptState & OPTST_INITENABLED) == 0)            od->fOptState |= OPTST_DISABLED;        return;    }#ifdef WITH_LIBREGEX    {        regex_t   re;        int       i, ct, dIdx;        if (regcomp(&re, od->optArg.argString, REG_NOSUB) != 0)            return;        /*         *  search the list for the entry(s) to remove.  Entries that         *  are removed are *not* copied into the result.  The source         *  index is incremented every time.  The destination only when         *  we are keeping a define.         */        for (i = 0, dIdx = 0, ct = arg_list->useCt; --ct >= 0; i++) {            char const * pzSrc = arg_list->apzArgs[ i ];            char *       pzEq  = strchr(pzSrc, '=');            int          res;            if (pzEq != NULL)                *pzEq = NUL;            res = regexec(&re, pzSrc, (size_t)0, NULL, 0);            switch (res) {            case 0:                /*                 *  Remove this entry by reducing the in-use count                 *  and *not* putting the string pointer back into                 *  the list.                 */                AGFREE(pzSrc);                arg_list->useCt--;                break;            default:            case REG_NOMATCH:                if (pzEq != NULL)                    *pzEq = '=';                /*                 *  IF we have dropped an entry                 *  THEN we have to move the current one.                 */                if (dIdx != i)                    arg_list->apzArgs[ dIdx ] = pzSrc;                dIdx++;            }        }        regfree(&re);    }#else  /* not WITH_LIBREGEX */    {        int i, ct, dIdx;        /*         *  search the list for the entry(s) to remove.  Entries that         *  are removed are *not* copied into the result.  The source         *  index is incremented every time.  The destination only when         *  we are keeping a define.         */        for (i = 0, dIdx = 0, ct = arg_list->useCt; --ct >= 0; i++) {            const char * pzSrc = arg_list->apzArgs[ i ];            char *       pzEq  = strchr(pzSrc, '=');            if (pzEq != NULL)                *pzEq = NUL;//.........这里部分代码省略.........

/*=export_func  optionPagedUsage * private: * * what:  emit help text and pass through a pager program. * arg:   + tOptions * + opts + program options descriptor + * arg:   + tOptDesc * + od   + the descriptor for this arg + * * doc: *  Run the usage output through a pager. *  This is very handy if it is very long. *  This is disabled on platforms without a working fork() function.=*/voidoptionPagedUsage(tOptions * opts, tOptDesc * od){#if ! defined(HAVE_WORKING_FORK)    if ((od->fOptState & OPTST_RESET) != 0)        return;    (*opts->pUsageProc)(opts, EXIT_SUCCESS);#else    static bool sv_print_exit = false;    static char * fil_name = NULL;    /*     *  IF we are being called after the usage proc is done     *     (and thus has called "exit(2)")     *  THEN invoke the pager to page through the usage file we created.     */    switch (pagerState) {    case PAGER_STATE_INITIAL:    {        if ((od->fOptState & OPTST_RESET) != 0)            return;        option_usage_fp = open_tmp_usage(&fil_name);        if (option_usage_fp == NULL)            (*opts->pUsageProc)(opts, EXIT_SUCCESS);        pagerState    = PAGER_STATE_READY;        sv_print_exit = print_exit;        /*         *  Set up so this routine gets called during the exit logic         */        atexit((void(*)(void))optionPagedUsage);        /*         *  The usage procedure will now put the usage information into         *  the temporary file we created above.  Keep any shell commands         *  out of the result.         */        print_exit = false;        (*opts->pUsageProc)(opts, EXIT_SUCCESS);        /* NOTREACHED */        _exit(EXIT_FAILURE);    }    case PAGER_STATE_READY:        fil_name = mk_pager_cmd(fil_name);        if (sv_print_exit) {            fputs("/nexit 0/n", stdout);            fclose(stdout);            dup2(STDERR_FILENO, STDOUT_FILENO);        } else {            fclose(stderr);            dup2(STDOUT_FILENO, STDERR_FILENO);        }        ignore_val( system( fil_name));        AGFREE(fil_name);    case PAGER_STATE_CHILD:        /*         *  This is a child process used in creating shell script usage.         */        break;    }#endif}

LOCAL voidprocessTemplate(tTemplate* pTF){    forInfo.fi_depth = 0;    /*     *  IF the template file does not specify any output suffixes,     *  THEN we will generate to standard out with the suffix set to zNoSfx.     *  With output going to stdout, we don't try to remove output on errors.     */    if (pOutSpecList == NULL) {        do_stdout_tpl(pTF);        return;    }    do  {        tOutSpec*  pOS    = pOutSpecList;        /*         * We cannot be in Scheme processing.  We've either just started         * or we've made a long jump from our own code.  If we've made a         * long jump, we've printed a message that is sufficient and we         * don't need to print any scheme expressions.         */        pzLastScheme = NULL;        /*         *  HOW was that we got here?         */        switch (setjmp(fileAbort)) {        case SUCCESS:            if (OPT_VALUE_TRACE >= TRACE_EVERYTHING) {                fprintf(pfTrace, PROC_TPL_START, pOS->zSuffix);                fflush(pfTrace);            }            /*             *  Set the output file name buffer.             *  It may get switched inside open_output.             */            open_output(pOS);            memcpy(&fpRoot, pCurFp, sizeof(fpRoot));            AGFREE(pCurFp);            pCurFp         = &fpRoot;            pzCurSfx       = pOS->zSuffix;            currDefCtx     = rootDefCtx;            pCurFp->flags &= ~FPF_FREE;            pCurFp->pPrev  = NULL;            generateBlock(pTF, pTF->aMacros, pTF->aMacros + pTF->macroCt);            do  {                out_close(AG_FALSE);  /* keep output */            } while (pCurFp->pPrev != NULL);            break;        case PROBLEM:            /*             *  We got here by a long jump.  Close/purge the open files.             */            do  {                out_close(AG_TRUE);  /* discard output */            } while (pCurFp->pPrev != NULL);            pzLastScheme = NULL; /* "problem" means "drop current output". */            break;        default:            fprintf(pfTrace, PROC_TPL_BOGUS_RET, pzOopsPrefix);            pzOopsPrefix = zNil;            /* FALLTHROUGH */        case FAILURE:            /*             *  We got here by a long jump.  Close/purge the open files.             */            do  {                out_close(AG_TRUE);  /* discard output */            } while (pCurFp->pPrev != NULL);            /*             *  On failure (or unknown jump type), we quit the program, too.             */            procState = PROC_STATE_ABORTING;            do pOS = nextOutSpec(pOS);            while (pOS != NULL);            exit(EXIT_FAILURE);        }        pOutSpecList = nextOutSpec(pOS);    } while (pOutSpecList != NULL);}

//.........这里部分代码省略.........optionParseShell(tOptions * opts){    /*     *  Check for our SHELL option now.     *  IF the output file contains the "#!" magic marker,     *  it will override anything we do here.     */    if (HAVE_GENSHELL_OPT(SHELL))        shell_prog = GENSHELL_OPT_ARG(SHELL);    else if (! ENABLED_GENSHELL_OPT(SHELL))        shell_prog = NULL;    else if ((shell_prog = getenv("SHELL")),             shell_prog == NULL)        shell_prog = POSIX_SHELL;    /*     *  Check for a specified output file     */    if (HAVE_GENSHELL_OPT(SCRIPT))        open_out(GENSHELL_OPT_ARG(SCRIPT), opts->pzProgName);        emit_usage(opts);    emit_setup(opts);    /*     *  There are four modes of option processing.     */    switch (opts->fOptSet & (OPTPROC_LONGOPT|OPTPROC_SHORTOPT)) {    case OPTPROC_LONGOPT:        fputs(LOOP_STR,         stdout);        fputs(LONG_OPT_MARK,    stdout);        fputs(INIT_LOPT_STR,    stdout);        emit_long(opts);        printf(LOPT_ARG_FMT,    opts->pzPROGNAME);        fputs(END_OPT_SEL_STR,  stdout);        fputs(NOT_FOUND_STR,    stdout);        break;    case 0:        fputs(ONLY_OPTS_LOOP,   stdout);        fputs(INIT_LOPT_STR,    stdout);        emit_long(opts);        printf(LOPT_ARG_FMT,    opts->pzPROGNAME);        break;    case OPTPROC_SHORTOPT:        fputs(LOOP_STR,         stdout);        fputs(FLAG_OPT_MARK,    stdout);        fputs(INIT_OPT_STR,     stdout);        emit_flag(opts);        printf(OPT_ARG_FMT,     opts->pzPROGNAME);        fputs(END_OPT_SEL_STR,  stdout);        fputs(NOT_FOUND_STR,    stdout);        break;    case OPTPROC_LONGOPT|OPTPROC_SHORTOPT:        fputs(LOOP_STR,         stdout);        fputs(LONG_OPT_MARK,    stdout);        fputs(INIT_LOPT_STR,    stdout);        emit_long(opts);        printf(LOPT_ARG_FMT,    opts->pzPROGNAME);        fputs(END_OPT_SEL_STR,  stdout);        fputs(FLAG_OPT_MARK,    stdout);        fputs(INIT_OPT_STR,     stdout);        emit_flag(opts);        printf(OPT_ARG_FMT,     opts->pzPROGNAME);        fputs(END_OPT_SEL_STR,  stdout);        fputs(NOT_FOUND_STR,    stdout);        break;    }    emit_wrapup(opts);    if ((script_trailer != NULL) && (*script_trailer != NUL))        fputs(script_trailer, stdout);    else if (ENABLED_GENSHELL_OPT(SHELL))        printf(SHOW_PROG_ENV, opts->pzPROGNAME);#ifdef HAVE_FCHMOD    fchmod(STDOUT_FILENO, 0755);#endif    fclose(stdout);    if (ferror(stdout))        fserr_exit(opts->pzProgName, zwriting, zstdout_name);    AGFREE(script_text);    script_leader    = NULL;    script_trailer   = NULL;    script_text      = NULL;}

/* *  process a single scheme expression, yielding text that gets processed *  into AutoGen definitions. */static voidalist_to_autogen_def(void){    static char const zSchemeText[] = "Scheme Computed Definitions";    static char const zWrap[] = "(alist->autogen-def %s)";    char*  pzText  = ++(pCurCtx->pzScan);    char*  pzEnd   = (char*)skipScheme(pzText, pzText + strlen(pzText));    SCM    res;    size_t res_len;    tScanCtx*  pCtx;    /*     *  Wrap the scheme expression with the `alist->autogen-def' function     */    {        char endCh = *pzEnd;        *pzEnd = NUL;        pzText = aprf(zWrap, pzText);        *pzEnd = endCh;    }    /*     *  Run the scheme expression.  The result is autogen definition text.     */    procState = PROC_STATE_GUILE_PRELOAD;    res = ag_scm_c_eval_string_from_file_line(        pzText, pCurCtx->pzCtxFname, pCurCtx->lineNo );    /*     *  The result *must* be a string, or we choke.     */    if (! AG_SCM_STRING_P(res)) {        static char const zEr[] =            "Scheme definition expression does not yield string:/n";        AG_ABEND(zEr);    }    res_len   = AG_SCM_STRLEN(res);    procState = PROC_STATE_LOAD_DEFS;    pCurCtx->pzScan = pzEnd;    AGFREE(pzText);    /*     *  Now, push the resulting string onto the input stack     *  and link the new scan data into the context stack     */    pCtx = (tScanCtx*)AGALOC(sizeof(tScanCtx) + 4 + res_len, "lex scan ctx");    pCtx->pCtx  = pCurCtx;    pCurCtx     = pCtx;    /*     *  Set up the rest of the context structure     */    AGDUPSTR(pCtx->pzCtxFname, zSchemeText, "scheme text");    pCtx->pzScan = /    pCtx->pzData = (char*)(pCtx+1);    pCtx->lineNo = 0;    memcpy((void*)(pCtx->pzScan), (void*)AG_SCM_CHARS(res), res_len);    pCtx->pzScan[ res_len ] = NUL;    /*     *  At this point, the next token will be obtained     *  from the newly allocated context structure.     *  When empty, input will resume from the '}' that we     *  left as the next input token in the old context.     */}

/* *  handle_opt * *  This routine handles equivalencing, sets the option state flags and *  invokes the handler procedure, if any. */LOCAL tSuccesshandle_opt(tOptions* pOpts, tOptState* pOptState){    /*     *  Save a copy of the option procedure pointer.     *  If this is an equivalence class option, we still want this proc.     */    tOptDesc* pOD = pOptState->pOD;    tOptProc* pOP = pOD->pOptProc;    if (pOD->fOptState & OPTST_ALLOC_ARG)        AGFREE(pOD->optArg.argString);    pOD->optArg.argString = pOptState->pzOptArg;    /*     *  IF we are presetting options, then we will ignore any un-presettable     *  options.  They are the ones either marked as such.     */    if (  ((pOpts->fOptSet & OPTPROC_PRESETTING) != 0)       && ((pOD->fOptState & OPTST_NO_INIT) != 0)       )        return PROBLEM;    /*     *  IF this is an equivalence class option,     *  THEN     *      Save the option value that got us to this option     *      entry.  (It may not be pOD->optChar[0], if this is an     *      equivalence entry.)     *      set the pointer to the equivalence class base     */    if (pOD->optEquivIndex != NO_EQUIVALENT) {        tOptDesc* p = pOpts->pOptDesc + pOD->optEquivIndex;        /*         * IF the current option state has not been defined (set on the         *    command line), THEN we will allow continued resetting of         *    the value.  Once "defined", then it must not change.         */        if ((pOD->fOptState & OPTST_DEFINED) != 0) {            /*             *  The equivalenced-to option has been found on the command             *  line before.  Make sure new occurrences are the same type.             *             *  IF this option has been previously equivalenced and             *     it was not the same equivalenced-to option,             *  THEN we have a usage problem.             */            if (p->optActualIndex != pOD->optIndex) {                fprintf(stderr, (char*)zMultiEquiv, p->pz_Name, pOD->pz_Name,                        (pOpts->pOptDesc + p->optActualIndex)->pz_Name);                return FAILURE;            }        } else {            /*             *  Set the equivalenced-to actual option index to no-equivalent             *  so that we set all the entries below.  This option may either             *  never have been selected before, or else it was selected by             *  some sort of "presetting" mechanism.             */            p->optActualIndex = NO_EQUIVALENT;        }        if (p->optActualIndex != pOD->optIndex) {            /*             *  First time through, copy over the state             *  and add in the equivalence flag             */            p->optActualValue = pOD->optValue;            p->optActualIndex = pOD->optIndex;            pOptState->flags |= OPTST_EQUIVALENCE;        }        /*         *  Copy the most recent option argument.  set membership state         *  is kept in ``p->optCookie''.  Do not overwrite.         */        p->optArg.argString = pOD->optArg.argString;        pOD = p;    } else {        pOD->optActualValue = pOD->optValue;        pOD->optActualIndex = pOD->optIndex;    }    pOD->fOptState &= OPTST_PERSISTENT_MASK;    pOD->fOptState |= (pOptState->flags & ~OPTST_PERSISTENT_MASK);    /*     *  Keep track of count only for DEFINED (command line) options.     *  IF we have too many, build up an error message and bail.     */    if (  (pOD->fOptState & OPTST_DEFINED)       && (++pOD->optOccCt > pOD->optMaxCt)  )  {//.........这里部分代码省略.........

/** *  The purpose of this function is to assign "long usage", short usage *  and version information to a shell variable.  Rather than wind our *  way through all the logic necessary to emit the text directly, we *  fork(), have our child process emit the text the normal way and *  capture the output in the parent process. * * @param[in] opts  the program options * @param[in] which what to print: long usage, usage or version * @param[in] od    for TT_VERSION, it is the version option */static voidtext_to_var(tOptions * opts, teTextTo which, tOptDesc * od){#   define _TT_(n) static char const z ## n [] = #n;    TEXTTO_TABLE#   undef _TT_#   define _TT_(n) z ## n ,      static char const * ttnames[] = { TEXTTO_TABLE };#   undef _TT_#if ! defined(HAVE_WORKING_FORK)    printf(SET_NO_TEXT_FMT, opts->pzPROGNAME, ttnames[which]);#else    int  fdpair[2];    fflush(stdout);    fflush(stderr);    if (pipe(fdpair) != 0)        fserr_exit(opts->pzProgName, "pipe", zinter_proc_pipe);    switch (fork()) {    case -1:        fserr_exit(opts->pzProgName, "fork", opts->pzProgName);        /* NOTREACHED */    case 0:        /*         * Send both stderr and stdout to the pipe.  No matter which         * descriptor is used, we capture the output on the read end.         */        dup2(fdpair[1], STDERR_FILENO);        dup2(fdpair[1], STDOUT_FILENO);        close(fdpair[0]);        switch (which) {        case TT_LONGUSAGE:            (*(opts->pUsageProc))(opts, EXIT_SUCCESS);            /* NOTREACHED */        case TT_USAGE:            (*(opts->pUsageProc))(opts, EXIT_FAILURE);            /* NOTREACHED */        case TT_VERSION:            if (od->fOptState & OPTST_ALLOC_ARG) {                AGFREE(od->optArg.argString);                od->fOptState &= ~OPTST_ALLOC_ARG;            }            od->optArg.argString = "c";            optionPrintVersion(opts, od);            /* NOTREACHED */        default:            option_exits(EXIT_FAILURE);            /* NOTREACHED */        }        /* NOTREACHED */    default:        close(fdpair[1]);    }    emit_var_text(opts->pzPROGNAME, ttnames[which], fdpair[0]);#endif}

//.........这里部分代码省略......... *  This procedure is called in two contexts: when a full or short usage text *  has been provided for display, and when autogen is assembling a list of *  translatable texts in the optmain.tlib template.  In the former case, /a *  plain is set to /a true, otherwise /a false. * *  Anything less than 256 characters in size is printed as a single unit. *  Otherwise, paragraphs are detected.  A paragraph break is defined as just *  before a non-empty line preceded by two newlines or a line that starts *  with at least one space character but fewer than 8 space characters. *  Lines indented with tabs or more than 7 spaces are considered continuation *  lines. * *  If 'plain' is true, we are emitting text for a user to see.  So, if it is *  true and NLS is not enabled, then just write the whole thing at once.=*/voidoptionPrintParagraphs(char const * text, bool plain, FILE * fp){    size_t len = strlen(text);    char * buf;#ifndef ENABLE_NLS    if (plain || (len < 256))#else    if (len < 256)#endif    {        print_one_paragraph(text, plain, fp);        return;    }    AGDUPSTR(buf, text, "ppara");    text = buf;    for (;;) {        char * scan;        if (len < 256) {        done:            print_one_paragraph(buf, plain, fp);            break;        }        scan = buf;    try_longer:        scan = strchr(scan, NL);        if (scan == NULL)            goto done;        if ((scan - buf) < 8) {            scan++;            goto try_longer;        }        scan++;        if ((! isspace((int)*scan)) || (*scan == HT))            /*             * line starts with tab or non-whitespace --> continuation             */            goto try_longer;        if (*scan == NL) {            /*             * Double newline -> paragraph break             * Include all newlines in current paragraph.             */            while (*++scan == NL)  /*continue*/;        } else {            char * p = scan;            int   sp_ct = 0;            while (*p == ' ') {                if (++sp_ct >= 8) {                    /*                     * Too many spaces --> continuation line                     */                    scan = p;                    goto try_longer;                }                p++;            }        }        /*         * "scan" points to the first character of a paragraph or the         * terminating NUL byte.         */        {            char svch = *scan;            *scan = NUL;            print_one_paragraph(buf, plain, fp);            len -= scan - buf;            if (len <= 0)                break;            *scan = svch;            buf = scan;        }    }    AGFREE((void *)text);}