path: root/perftool/delsvec.c

/* 
 *------------------------------------------------------------------
 * Copyright (c) 2006-2016 Cisco and/or its affiliates.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* Break up a delimited string into a vector of substrings */

#include <stdio.h>
#include <vppinfra/clib.h>
#include <vppinfra/vec.h>
#include <vppinfra/hash.h>
#include <stdarg.h>

/*
 * #define UNIT_TESTS 1
 * #define MATCH_TRACE 1 
 */

/*
 * delsvec
 * break up an input string into a vector of [null-terminated] u8 *'s
 * 
 * Each supplied delimiter character results in a string in the output
 * vector, unless the delimiters occur back-to-back.  When matched,
 * a whitespace character in the delimiter consumes an arbitrary
 * run of whitespace. See the unit tests at the end of this file
 * for a set of examples.
 *
 * Returns a u8 **, or NULL if the input fails to match.  It is assumed
 * that both input and fmt are C strings, not necessarily vectors.
 *
 * Output strings are both vectors and proper C strings.
 */

static u8 **string_cache;
static u8 **svec_cache;

void delsvec_recycle_this_string (u8 *s)
{
    if (s) {
        _vec_len (s) = 0;
        vec_add1(string_cache, s);
    }
}

void delsvec_recycle_this_svec (u8 **svec)
{
    if (svec) {
        if (svec_cache) {
            vec_free (svec_cache);
        }
        _vec_len (svec) = 0;
        svec_cache = svec;
    }
}

int pvl (char *a)
{
    return vec_len(a);
}

u8 **delsvec(void *input_arg, char *fmt)
{
    u8 **rv = 0;
    int input_index=0;
    u8 *this;
    int dirflag=0;
    int i;
    u8 *input = input_arg;

    if (svec_cache) {
        rv = svec_cache;
        svec_cache = 0;
    }

    while (fmt) {
        dirflag=0;
        if (vec_len (string_cache) > 0) {
            this = string_cache [vec_len(string_cache)-1];
            _vec_len (string_cache) = vec_len (string_cache) - 1;
        } else 
            this = 0;
        /*
         * '*' means one of two things: match the rest of the input, 
         * or match as many characters as possible 
         */
        if (fmt[0] == '*') {
            fmt++;
            dirflag=1;
            /*
             * no more format: eat rest of string... 
             */
            if (!fmt[0]) {
                for (;input[input_index]; input_index++)
                    vec_add1(this, input[input_index]);
                if (vec_len(this)) {
                    vec_add1(this, 0);
#ifdef MATCH_TRACE
                    printf("final star-match adds: '%s'\n", this);
#endif
                    vec_add1(rv, this);
                } else {
                    vec_add1(string_cache, this);
                }

                return(rv);
            }
        }
        /*
         * Left-to-right scan, adding chars until next delimiter char 
         * appears.
         */
        if (!dirflag) {
            while (input[input_index]) {
                if (input[input_index] == fmt[0]) {
                    /* If we just (exact) matched a whitespace delimiter */
                    if (fmt[0] == ' '){
                        /* scan forward eating whitespace */
                        while (input[input_index] == ' ' ||
                               input[input_index] == '\t' ||
                               input[input_index] == '\n')
                            input_index++;
                        input_index--;
                    }
                    goto found;
                }
                /* If we're looking for whitespace */
                if (fmt[0] == ' ') {
                    /* and we have whitespace */
                    if (input[input_index] == ' ' ||
                        input[input_index] == '\t' ||
                        input[input_index] == '\n') {
                        /* scan forward eating whitespace */
                        while (input[input_index] == ' ' ||
                               input[input_index] == '\t' ||
                               input[input_index] == '\n') {
                            input_index++;
                        }
                        input_index--;
                        goto found;
                    }
                }
                /* Not a delimiter, save it */
                vec_add1(this, input[input_index]);
                input_index++;
            }
            /*
             * Fell off the wagon, clean up and bail out 
             */
        bail:

#ifdef MATCH_TRACE
            printf("failed, fmt[0] = '%c', input[%d]='%s'\n",
                   fmt[0], input_index, &input[input_index]);
#endif
            delsvec_recycle_this_string(this);
            for (i = 0; i < vec_len(rv); i++)
                delsvec_recycle_this_string(rv[i]);
            delsvec_recycle_this_svec(rv);
            return(0);
            
        found:
            /*
             * Delimiter matched
             */
            input_index++;
            fmt++;
            /*
             * If we actually accumulated non-delimiter characters,
             * add them to the result vector
             */
            if (vec_len(this)) {
                vec_add1(this, 0);
#ifdef MATCH_TRACE
                printf("match: add '%s'\n", this);
#endif
                vec_add1(rv, this);
            } else {
                vec_add1(string_cache, this);
            }
        } else { 
            /*
             * right-to-left scan, '*' not at 
             * the end of the delimiter string 
             */
            i = input_index;
            while (input[++i])
                ; /* scan forward */
            i--;
            while (i > input_index) {
                if (input[i] == fmt[0])
                    goto found2;
                
                if (fmt[0] == ' ' || fmt[0] == '\t' ||
                    fmt[0] == '\n') {
                    if (input[i] == ' ' ||
                        input[i] == '\t' ||
                        input[i] == '\n')
                        goto found2;
                }
                i--;
            }
            goto bail;

        found2:
            for (; input_index < i; input_index++) {
                vec_add1(this, input[input_index]);
            }
            input_index++;
            fmt++;
            vec_add1(this, 0);
#ifdef MATCH_TRACE
                printf("inner '*' match: add '%s'\n", this);
#endif
            vec_add1(rv, this);
        }
    }
    return (rv);
}

#ifdef UNIT_TESTS

typedef struct utest_ {
    char *string;
    char *fmt;
} utest_t;

utest_t tests[] = {
#ifdef NOTDEF
    {"Dec  7 08:56",
     "  :*"},
    {"Dec 17 08:56",
     "  :*"},
    {"Dec  7 08:56:41.239 install/inst_repl 0/9/CPU0 t1  [40989] File List:Successfully blobbified file list. Took 1 milliseconds",
     "  ::. / //  [] *"},
    {"RP/0/9/CPU0:Dec  7 08:55:28.550 : sam_server[291]: SAM backs up digest list to memory file",
     "///:  ::. : []: *"},
    /* Expected to fail */
    {"Dec  7 08:56:41.239 install/inst_repl 0/9/CPU0 t1  [40989] File List:Successfully blobbified file list. Took 1 milliseconds",
     "///:  ::. : : *"},
    /* Expected to fail */
    {"RP/0/9/CPU0:Dec  7 08:55:28.550 : sam_server[291]: SAM backs up digest list to memory file",
     "  ::. / //  [] *"},
    {"THIS that and + theother", "*+ *"}, 
    {"Dec 12 15:33:07.103 ifmgr/errors 0/RP0/CPU0 3# t2  Failed to open IM connection: No such file or directory", "  ::. / //   *"}, 
    {"Dec 16 21:43:47.328 ifmgr/bulk 0/3/CPU0 t8  Bulk DPC async download complete. Partitions 1, node_count 1, total_out 0, out_offset 0, out_expected 0: No error","  ::. / //  *"},
    {"t:0x53034bd6 CPU:00 PROCESS :PROCCREATE_NAME",
     ": :  :*"},
    {"                       pid:1", " *"},
    {"t:0x53034cbb CPU:00 THREAD  :THCREATE      pid:1 tid:1",
     ": :  : pid: tid:*"},
    {"t:0x5303f950 CPU:00 COMM    :REC_PULSE     scoid:0x40000003 pid:364659",
     ": :  : *"},
    {"/hfr-base-3.3.85/lib/libttyconnection.dll 0xfc000000 0x0000306c 0xfc027000 0x000001c8    1", 
     "     *"},
    {"Feb 28 02:38:26.123 seqtrace 0/1/CPU0 t8  :msg_receive:ifmgr/t8:IMC_MSG_MTU_UPDATE:ppp_ma/t1", 
     "  ::.  //  ::::*"},

    {"Feb 28 02:38:26.123 seqtrace 0/1/CPU0 t8  :msg_send_event:call:ifmgr/t8:124/0:cdp/t1", 
     "  ::.  //  :msg_send_event::::*"},

    {"Feb 28 02:38:26.125 seqtrace 0/1/CPU0 t1  :msg_receive_event:cdp/t1:124/0", 
     "  ::.  //  :msg_receive_event::*"}
    {"t:0x645dd86d CPU:00 USREVENT:EVENT:100, d0:0x00000002 d1:0x00000000",
     ": : USREVENT:EVENT:, d0: *"}
    {"t:0x5303f950 CPU:00 COMM    :REC_PULSE     scoid:0x40000003 pid:364659",
     ": :  : *"},
    {"t:0x2ccf9f5a CPU:00 INT_ENTR:0x80000000 (-2147483648)       IP:0x002d8b18", 
     ": : INT_ENTR:  IP:*"}
    {"t:0xd473951c CPU:00 KER_EXIT:SCHED_GET/88 ret_val:2 sched_priority:10",
     ": : KER_EXIT:SCHED_GET : sched_priority:*"}
    {"t:0x00000123 CPU:01 SYSTEM  :FUNC_ENTER thisfn:0x40e62048 call_site:0x00000000",
    ": : SYSTEM :FUNC_ thisfn: *"},
    {"t:0x5af8de95 CPU:00 INT_HANDLER_ENTR:0x0000004d (77)       PID:8200 IP:0x00000000 AREA:0x0bf9b290", ": : INT_HANDLER_*"},
#endif
    {"t:0x6d1ff92f CPU:00 CONTROL: BUFFER sequence = 1053, num_events = 714",
     ": : CONTROL*"},
    {"t:0x6d1ff92f CPU:00 CONTROL :TIME msb:0x0000003c lsb(offset):0x6d1ff921",
     ": : CONTROL*"},
};

int main (int argc, char **argv)
{
    int i, j;
    u8 **svec;

    for (j = 0; j < ARRAY_LEN(tests); j++) {
        printf ("input string: '%s'\n", tests[j].string);
        printf ("delimiter arg: '%s'\n", tests[j].fmt);
        printf ("parse trace:\n");
        svec = delsvec(tests[j].string, tests[j].fmt);
        if (!svec) {
            printf("index %d failed\n", j);
            continue;
        }
        printf("%d substring vectors\n", vec_len(svec));
        for (i = 0; i < vec_len(svec); i++) {
            printf("[%d]: '%s'\n", i, svec[i]);
        }
        printf ("-------------------\n");
    }
    exit(0);
}
#endif