cpvparser1.c - test code for ksh93 compound variable parsing
Posted by Anonymous on Sat 18th Nov 2023 12:27
raw | new post
modification of post by Anonymous (view diff)

/*
 * cpvparser1.c - test code for ksh93 compound variable parsing
 *
 *
 * It basically reads the output of $ print -v ... # like this:
 * ---- snip ----
 * $ ksh93 -c 'compound c=( va=1 vb=hello ) ; print -v c'
 * (
 *        va=1
 *        vb=hello
 * )
 * ---- snip ----
 *
 * ToDo:
 * - arrays (indexed, sparse indexed and associative)
 * - multibyte characters
 *
 * Written by Roland Mainz <roland.mainz@nrubsig.org>
 */

#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <stdio.h>
#include <ctype.h>

#define MAX_NAME_VAL_SIZE 1024

typedef struct cpv_name_val
{
        const char *cpv_name;
        const char *cpv_value;
} cpv_name_val;

/* prototypes */
static int cpv_read_cpv_header(const char **instr_ptr, size_t maxsize);
static void cpv_free_name_val_data(cpv_name_val *cnv);
static int cpv_parse_name_val(const char **instr_ptr, size_t maxsize, cpv_name_val *cpv_nv);

static
int cpv_read_cpv_header(const char **instr_ptr, size_t maxsize)
{
        const char *s = *instr_ptr;

skipspaces:
        while((*s != '\0') && isspace(*s))
                s++;

        /*
         * skip POSIX-style '#' comments
         * (allowed since this is based on POSIX sh(1) syntax)
         */
        if (*s == '#') {
                s++;
                /* ignore everything until the end-of-line */
                while((*s != '\0') && (*s != '\n'))
                        s++;
                goto skipspaces;
        }

        if (*s == '(') {
                *instr_ptr=++s;
                (void)fprintf(stderr, "cpv_read_cpv_header: begin-of-cpv\n");
                return 0;
        }

        (void)fprintf(stderr, "cpv_read_cpv_header: end-of-string, should not happen\n");
        return 1;
}

static
int cpv_parse_name_val(const char **instr_ptr, size_t maxsize, cpv_name_val *cpv_nv)
{
        char namebuff[maxsize+1];
        char valbuff[maxsize+1];

        const char *s = *instr_ptr;

        char *n; /* pointer in |namebuff| */
        char *v; /* pointer in |valbuff| */

skipspaces:
        while((*s != '\0') && isspace(*s))
                s++;

        /*
         * skip POSIX-style '#' comments
         * (allowed since this is based on POSIX sh(1) syntax)
         */
        if (*s == '#') {
                s++;
                /* ignore everything until the end-of-line */
                while((*s != '\0') && (*s != '\n'))
                        s++;
                goto skipspaces;
        }

        if (*s == '\0') {
                (void)fprintf(stderr, "cpv_parse_name_val: "
                        "error: end-of-string, should not happen\n");
                return 1;
        }

        /* cpv == "( foo=bar blabla=text )"*/
        if (*s == ')') {
                (void)fprintf(stderr, "cpv_parse_name_val: end-of-cpv (OK)\n");
                return 1;
        }

parse_varname:
        /*
         * start parsing variable name
         */

        /* variable names MUST start with a letter! */
        if (!isalpha(*s)) {
                (void)fprintf(stderr,
                        "cpv_parse_name_val: parser error, first char "
                        "in variable name not isalpha(c=%c)\n",
                        *s);
                return 1;
        }

        n = namebuff;
        while((*s != '\0') && isalnum(*s))
                *n++ = *s++;
        *n = '\0';

        /*
         * skip typed member varables
         * (e.g. "typeset ", "typeset -i ", "typeset -l -i2" etc.)
         */
        if (isspace(*s)) {
                if ((!strcmp(namebuff, "typeset")) ||
                        (!strcmp(namebuff, "integer")) ||
                        (!strcmp(namebuff, "float")) ||
                        (!strcmp(namebuff, "compound"))) {
skip_typeset_options:
                        while(isspace(*s))
                                s++;
                        if (*s == '-') {
                                s++;
                                while(isalnum(*s))
                                        s++;
                                goto skip_typeset_options;
                        }

                        goto parse_varname;
                }
        }

        /* handle '=' */
        if (*s != '=') {

                (void)fprintf(stderr, "cpv_parse_name_val: "
                        "parser error, expected '=', got '%c'.\n",
                        *s);
                return 1;
        }

        s++; /* skip '=' */

        /*
         * start parsing variable value
         */
        bool in_doublequotes=false;
        bool in_singlequotes=false;
        v = valbuff;
val_quotes:
        if (in_singlequotes) {
                while(*s != '\0') {
                        if (*s == '\'') {
                                in_singlequotes = false;
                                s++;
                                goto val_quotes;
                        }

                        if ((*s == '\\') && (*(s+1) != '\0')) {
                                /*
                                 * fixme: should support \ooo octals,
                                 * \u[hex] unicode and \w[hex] wchar
                                 */
                                s++;
                        }
                        *v++ = *s++;
                }
        }
        else if (in_doublequotes) {
                while(*s != '\0') {
                        if (*s == '"') {
                                in_doublequotes = false;
                                s++;
                                goto val_quotes;
                        }

                        if ((*s == '\\') && (*(s+1) != '\0')) {
                                /*
                                 * fixme: should support \ooo octals,
                                 * \u[hex] unicode and \w[hex] wchar
                                 */
                                s++;
                        }

                        *v++ = *s++;
                }
        }
        else
        {
                while((*s != '\0') && (!isspace(*s))) {
                        if (*s == '"') {
                                in_doublequotes = true;
                                s++;
                                goto val_quotes;
                        }

                        if (*s == '\'') {
                                in_singlequotes = true;
                                s++;
                                goto val_quotes;
                        }

                        if ((*s == '\\') && (*(s+1) != '\0')) {
                                /*
                                 * fixme: should support \ooo octals,
                                 * \u[hex] unicode and \w[hex] wchar
                                 */
                                s++;
                        }
                        *v++ = *s++;
                }
        }

        if (in_singlequotes) {
                (void)fprintf(stderr, "cpv_parse_name_val: "
                        "parsererror, still in single quotes "
                        "at the end\n");
                return 1;
        }
        if (in_doublequotes) {
                (void)fprintf(stderr, "cpv_parse_name_val: "
                        "parser error, still in double quotes "
                        "at the end\n");
                return 1;
        }

        *v = '\0';

#if 0
        (void)printf("cpv_parse_name_val: name='%s', value='%s'\n",
                namebuff, valbuff);
#endif

        cpv_nv->cpv_name   = strdup(namebuff);
        cpv_nv->cpv_value  = strdup(valbuff);

        if ((cpv_nv->cpv_name == NULL) || (cpv_nv->cpv_value == NULL)) {
                cpv_free_name_val_data(cpv_nv);
                (void)fprintf(stderr, "cpv_parse_name_val: "
                        "parser error, out of memory\n");
                return 2;
        }

        *instr_ptr = s;

        return 0;
}

void cpv_free_name_val_data(cpv_name_val *cnv)
{
        if (!cnv)
                return;

        free((void *)cnv->cpv_name);
        free((void *)cnv->cpv_value);
        cnv->cpv_name = NULL;
        cnv->cpv_value = NULL;
}

int main(int ac, char *av[])
{
        const char *str =
                " ( \n"
                "x=y1 chicken=wing xchicken=w\\\"ing qcount=\"one two\" sq1='foo \" x \" bar'"
                "\n  # a comment x=y\n"
                "\n"
                " \n"
                "\t\n"
                "emptyval= \n"
                "emptyval2=\n"
                "emptyval3=''\n"
                " emptyval4="" \n"
                "aftercomment=yep\n"
                "typeset -i2 bintypedvar=1010\n"
                "typeset  -u  strtypedvar=UAUA\n"
                "integer lastvar=666 \n"
                "\n)";
        const char *s = str;
        int numcnv = 0;
        int i = 0;
        cpv_name_val cnv[256];

        (void)fputs("# parsing...\n", stderr);
        if (cpv_read_cpv_header(&s, MAX_NAME_VAL_SIZE)) {
                (void)fprintf(stderr, "cpv_read_cpv_header failed\n");
                return EXIT_FAILURE;
        }

        for (numcnv=0 ; cpv_parse_name_val(&s, MAX_NAME_VAL_SIZE, &cnv[numcnv]) == 0 ; numcnv++) {
        }

        (void)fputs("# data:\n", stderr);
        for (i=0 ; i < numcnv ; i++) {
                (void)printf("name='%s', value='%s'\n", cnv[i].cpv_name, cnv[i].cpv_value);
        }

        (void)fputs("# free memory ...\n", stderr);
        for (i=0 ; i < numcnv ; i++) {
                cpv_free_name_val_data(&cnv[i]);
        }

        (void)fputs("# done.\n", stderr);

        return EXIT_SUCCESS;
}