bootimage: config cpv test parser cpvparser1.c - test code for ksh93 compound variable parsing
Posted by Anonymous on Tue 21st Nov 2023 12:19
raw | new post
modification of post by Anonymous (view diff)


/*
 * MIT License
 *
 * Copyright (c) 2023 Roland Mainz <roland.mainz@nrubsig.org>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

/*
 * cpvparser1.c - simple 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>

#include "cpvparser1.h"

/* private data! */
typedef struct cpv_parse_context {
        const char *start_string;
        const char *curr_string;
        size_t max_name_val_size;
        unsigned long flags;
} cpv_parse_context;


void *cpv_create_parser(const char *s, unsigned long flags, ...)
{
        cpv_parse_context *cpc;

        cpc = calloc(1, sizeof(cpv_parse_context));
        if (!cpc)
                goto fail;

        cpc->start_string = strdup(s);
        if (!cpc->start_string)
                goto fail;

        cpc->curr_string = cpc->start_string;
        cpc->max_name_val_size = strlen(cpc->start_string);
        cpc->flags = flags;

        return (cpc);

fail:
        if (cpc) {
                free((void *)cpc->start_string);
                free(cpc);
        }

        return NULL;
}

void cpv_free_parser(void *v_cpc)
{
        cpv_parse_context *cpc = (cpv_parse_context *)v_cpc;
        if (cpc) {
                free((void *)cpc->start_string);
                free(cpc);
        }
}

int cpv_read_cpv_header(void *v_cpc)
{
        cpv_parse_context *cpc = (cpv_parse_context *)v_cpc;
        const char *s = cpc->curr_string;

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 == '(') {
                cpc->curr_string=++s;
                if (cpc->flags & CPVFLAG_DEBUG_OUTPUT) {
                        (void)fprintf(stderr, "cpv_read_cpv_header: begin-of-cpv\n");
                }
                return 0;
        }

        if (cpc->flags & CPVFLAG_DEBUG_OUTPUT) {
                (void)fprintf(stderr, "cpv_read_cpv_header: end-of-string, should not happen\n");
        }
        return 1;
}

int cpv_parse_name_val(void *v_cpc, cpv_name_val *cpv_nv)
{
        cpv_parse_context *cpc = (cpv_parse_context *)v_cpc;
        char namebuff[cpc->max_name_val_size+1];
        char valbuff[cpc->max_name_val_size+1];

        const char *s = cpc->curr_string;

        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') {
                if (cpc->flags & CPVFLAG_DEBUG_OUTPUT) {
                        (void)fprintf(stderr, "cpv_parse_name_val: "
                                "error: end-of-string, should not happen\n");
                }
                return 1;
        }

        /* cpv == "( foo=bar blabla=text )"*/
        if (*s == ')') {
                if (cpc->flags & CPVFLAG_DEBUG_OUTPUT) {
                        (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)) {
                if (cpc->flags & CPVFLAG_DEBUG_OUTPUT) {
                        (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 != '=') {
                if (cpc->flags & CPVFLAG_DEBUG_OUTPUT) {
                        (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) {
                if (cpc->flags & CPVFLAG_DEBUG_OUTPUT) {
                        (void)fprintf(stderr, "cpv_parse_name_val: "
                                "parsererror, still in single quotes "
                                "at the end\n");
                }
                return 1;
        }
        if (in_doublequotes) {
                if (cpc->flags & CPVFLAG_DEBUG_OUTPUT) {
                        (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);
                if (cpc->flags & CPVFLAG_DEBUG_OUTPUT) {
                        (void)fprintf(stderr, "cpv_parse_name_val: "
                                "parser error, out of memory\n");
                }
                return 2;
        }

        cpc->curr_string = 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;
}
/*
 * MIT License
 *
 * Copyright (c) 2023 Roland Mainz <roland.mainz@nrubsig.org>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

/*
 * cpvparser1.c - simple 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>

#include "cpvparser1.h"

/*
 * Compile with:
 * $ gcc -Wall -g cpvparser1.c  main.c -o cpvparser1
 *
 * Example usage:
 * ./cpvparser1 "$(ksh -c 'compound c ; typeset c.s="hello" ; print -v c')"
 */
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)";
        int numcnv = 0;
        int i = 0;
        cpv_name_val cnv[256];
        void *c;

        if (ac == 2) {
                (void)fputs("# parsing av[1] ...\n", stderr);
                c = cpv_create_parser(av[1], 0);
        }
        else {
                (void)fputs("# parsing builtin test string ...\n", stderr);
                c = cpv_create_parser(str, 0);
        }

        if (!c) {
                (void)fprintf(stderr, "cpv_create_parser: no memory\n");
                return EXIT_FAILURE;
        }

        if (cpv_read_cpv_header(c)) {
                (void)fprintf(stderr, "cpv_read_cpv_header failed\n");
                return EXIT_FAILURE;
        }

        for (numcnv=0 ; cpv_parse_name_val(c, &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]);
        }

        cpv_free_parser(c);

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

        return EXIT_SUCCESS;
}

/*
 * MIT License
 *
 * Copyright (c) 2023 Roland Mainz <roland.mainz@nrubsig.org>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

/*
 * cpvparser1.h - simple 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>
 */

#ifndef CPV_PARSER_H
#define CPV_PARSER_H 1

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

/* Flags for |cpv_create_parser()| */
#define CPVFLAG_DEBUG_OUTPUT (0x00000008L)

/* prototypes */
void *cpv_create_parser(const char *s, unsigned long flags, ...);
void cpv_free_parser(void *);
int cpv_read_cpv_header(void *);
void cpv_free_name_val_data(cpv_name_val *);
int cpv_parse_name_val(void *, cpv_name_val *);

#endif /* !CPV_PARSER_H */