mac_parse.c

[詳解]

/*++
/* NAME
/*  mac_parse 3
/* SUMMARY
/*  locate macro references in string
/* SYNOPSIS
/*  #include <mac_parse.h>
/*
/*  int mac_parse(string, action, context)
/*  const char *string;
/*  int (*action)(int type, VSTRING *buf, void *context);
/* DESCRIPTION
/*  This module recognizes macro expressions in null-terminated
/*  strings.  Macro expressions have the form $name, $(text) or
/*  ${text}. A macro name consists of alphanumerics and/or
/*  underscore. Text other than macro expressions is treated
/*  as literal text.
/*
/*  mac_parse() breaks up its string argument into macro references
/*  and other text, and invokes the \fIaction\fR routine for each item
/*  found.  With each action routine call, the \fItype\fR argument
/*  indicates what was found, \fIbuf\fR contains a copy of the text
/*  found, and \fIcontext\fR is passed on unmodified from the caller.
/*  The application is at liberty to clobber \fIbuf\fR.
/* .IP MAC_PARSE_LITERAL
/*  The content of \fIbuf\fR is literal text.
/* .IP MAC_PARSE_EXPR
/*  The content of \fIbuf\fR is a macro expression: either a
/*  bare macro name without the preceding "$", or all the text
/*  inside $() or ${}.
/* .PP
/*  The action routine result value is the bit-wise OR of zero or more
/*  of the following:
/* .IP  MAC_PARSE_ERROR
/*  A parsing error was detected.
/* .IP  MAC_PARSE_UNDEF
/*  A macro was expanded but not defined.
/* .PP
/*  Use the constant MAC_PARSE_OK when no error was detected.
/* SEE ALSO
/*  dict(3) dictionary interface.
/* DIAGNOSTICS
/*  Fatal errors: out of memory. malformed macro name.
/*
/*  The result value is the bit-wise OR of zero or more of the
/*  following:
/* .IP  MAC_PARSE_ERROR
/*  A parsing error was detected.
/* .IP  MAC_PARSE_UNDEF
/*  A macro was expanded but not defined.
/* LICENSE
/* .ad
/* .fi
/*  The Secure Mailer license must be distributed with this software.
/* AUTHOR(S)
/*  Wietse Venema
/*  IBM T.J. Watson Research
/*  P.O. Box 704
/*  Yorktown Heights, NY 10598, USA
/*--*/

/* System library. */

#include <sys_defs.h>
#include <ctype.h>

/* Utility library. */

#include <msg.h>
#include <mac_parse.h>

 /*
  * Helper macro for consistency. Null-terminate the temporary buffer,
  * execute the action, and reset the temporary buffer for re-use.
  */
#define MAC_PARSE_ACTION(status, type, buf, context) \
    do { \
        VSTRING_TERMINATE(buf); \
        status |= action((type), (buf), (context)); \
        VSTRING_RESET(buf); \
    } while(0)

/* mac_parse - split string into literal text and macro references */

int     mac_parse(const char *value, MAC_PARSE_FN action, void *context)
{
    const char *myname = "mac_parse";
    VSTRING *buf = vstring_alloc(1);    /* result buffer */
    const char *vp;         /* value pointer */
    const char *pp;         /* open_paren pointer */
    const char *ep;         /* string end pointer */
    static char open_paren[] = "({";
    static char close_paren[] = ")}";
    int     level;
    int     status = 0;

#define SKIP(start, var, cond) do { \
        for (var = start; *var && (cond); var++) \
        /* void */; \
    } while (0)

    if (msg_verbose > 1)
    msg_info("%s: %s", myname, value);

    for (vp = value; *vp;) {
    if (*vp != '$') {           /* ordinary character */
        VSTRING_ADDCH(buf, *vp);
        vp += 1;
    } else if (vp[1] == '$') {      /* $$ becomes $ */
        VSTRING_ADDCH(buf, *vp);
        vp += 2;
    } else {                /* found bare $ */
        if (VSTRING_LEN(buf) > 0)
        MAC_PARSE_ACTION(status, MAC_PARSE_LITERAL, buf, context);
        vp += 1;
        pp = open_paren;
        if (*vp == *pp || *vp == *++pp) {   /* ${x} or $(x) */
        level = 1;
        vp += 1;
        for (ep = vp; level > 0; ep++) {
            if (*ep == 0) {
            msg_warn("truncated macro reference: \"%s\"", value);
            status |= MAC_PARSE_ERROR;
            break;
            }
            if (*ep == *pp)
            level++;
            if (*ep == close_paren[pp - open_paren])
            level--;
        }
        if (status & MAC_PARSE_ERROR)
            break;
        vstring_strncat(buf, vp, level > 0 ? ep - vp : ep - vp - 1);
        vp = ep;
        } else {                /* plain $x */
        SKIP(vp, ep, ISALNUM(*ep) || *ep == '_');
        vstring_strncat(buf, vp, ep - vp);
        vp = ep;
        }
        if (VSTRING_LEN(buf) == 0) {
        status |= MAC_PARSE_ERROR;
        msg_warn("empty macro name: \"%s\"", value);
        break;
        }
        MAC_PARSE_ACTION(status, MAC_PARSE_EXPR, buf, context);
    }
    }
    if (VSTRING_LEN(buf) > 0 && (status & MAC_PARSE_ERROR) == 0)
    MAC_PARSE_ACTION(status, MAC_PARSE_LITERAL, buf, context);

    /*
     * Cleanup.
     */
    vstring_free(buf);

    return (status);
}

#ifdef TEST

 /*
  * Proof-of-concept test program. Read strings from stdin, print parsed
  * result to stdout.
  */
#include <vstring_vstream.h>

/* mac_parse_print - print parse tree */

static int mac_parse_print(int type, VSTRING *buf, void *unused_context)
{
    char   *type_name;

    switch (type) {
    case MAC_PARSE_EXPR:
    type_name = "MAC_PARSE_EXPR";
    break;
    case MAC_PARSE_LITERAL:
    type_name = "MAC_PARSE_LITERAL";
    break;
    default:
    msg_panic("unknown token type %d", type);
    }
    vstream_printf("%s \"%s\"\n", type_name, vstring_str(buf));
    return (0);
}

int     main(int unused_argc, char **unused_argv)
{
    VSTRING *buf = vstring_alloc(1);

    while (vstring_fgets_nonl(buf, VSTREAM_IN)) {
    mac_parse(vstring_str(buf), mac_parse_print, (void *) 0);
    vstream_fflush(VSTREAM_OUT);
    }
    vstring_free(buf);
    return (0);
}

#endif