spp.h File Reference

Go to the source code of this file.

Functions
static char *	spp_var_get (char *var)
static int	spp_var_set (const char *var, const char *val)
static	TAG_CALLBACK (spp_set)
static	TAG_CALLBACK (spp_get)
static	TAG_CALLBACK (spp_getrandom)
static	TAG_CALLBACK (spp_add)
static	TAG_CALLBACK (spp_sub)
static	TAG_CALLBACK (spp_trace)
static	TAG_CALLBACK (spp_echo)
static	TAG_CALLBACK (spp_error)
static	TAG_CALLBACK (spp_warning)
static	TAG_CALLBACK (spp_system)
static	TAG_CALLBACK (spp_include)
static	TAG_CALLBACK (spp_if)
static	TAG_CALLBACK (spp_ifeq)
static	TAG_CALLBACK (spp_hex)
static	TAG_CALLBACK (spp_grepline)
static	TAG_CALLBACK (spp_else)
static	TAG_CALLBACK (spp_ifnot)
static	TAG_CALLBACK (spp_ifin)
static	TAG_CALLBACK (spp_endif)
static	TAG_CALLBACK (spp_default)
static	TAG_CALLBACK (spp_pipe)
static	TAG_CALLBACK (spp_switch)
static	TAG_CALLBACK (spp_case)
static	TAG_CALLBACK (spp_endswitch)
static	TAG_CALLBACK (spp_endpipe)
static	PUT_CALLBACK (spp_fputs)
static	ARG_CALLBACK (spp_arg_i)
static	ARG_CALLBACK (spp_arg_d)

Variables
static char *	spp_switch_str = NULL
static struct Tag	spp_tags []
static struct Arg	spp_args []
DLL_LOCAL struct Proc	spp_proc

Function Documentation

ARG_CALLBACK() [1/2]

static ARG_CALLBACK ( spp_arg_d  )

static

Definition at line 433 of file spp.h.

                               {
    /* TODO: Handle error */
    char *eq = strchr (arg, '=');
    if (eq) {
        *eq = '\0';
        spp_var_set (arg, eq+1);
    } else {
        spp_var_set (arg, "");
    }
    return 0;
}

References eq, and spp_var_set().

ARG_CALLBACK() [2/2]

static ARG_CALLBACK ( spp_arg_i  )

static

Definition at line 428 of file spp.h.

                               {
    rz_sys_setenv ("SPP_INCDIR", arg);
    return 0;
}

References rz_sys_setenv().

PUT_CALLBACK()

static PUT_CALLBACK ( spp_fputs  )

static

Definition at line 387 of file spp.h.

                               {
#if HAVE_SYSTEM
    if (spp_pipe_fd) {
        fprintf (spp_pipe_fd, "%s", buf);
    } else
#endif
    {
        out_printf (out, "%s", buf);
    }
    return 0;
}

References out, and out_printf().

spp_var_get()

static char* spp_var_get ( char *  var )

static

Definition at line 10 of file spp.h.

                                    {
    return rz_sys_getenv (var);
}

References rz_sys_getenv().

Referenced by TAG_CALLBACK().

spp_var_set()

static int spp_var_set ( const char *  var, const char *  val  )

static

Definition at line 14 of file spp.h.

                                                         {
    return rz_sys_setenv (var, val);
}

References rz_sys_setenv(), and val.

Referenced by ARG_CALLBACK(), and TAG_CALLBACK().

TAG_CALLBACK() [1/25]

static TAG_CALLBACK ( spp_add  )

static

Definition at line 102 of file spp.h.

                             {
    char res[32];
    char *var, *eq = strchr (buf, ' ');
    int ret = 0;
    if (!state->echo[state->ifl]) {
        return 0;
    }
    if (eq) {
        *eq = '\0';
        var = spp_var_get (buf);
        if (var) {
            ret = atoi (var);
        }
        ret += atoi (eq + 1);
        snprintf (res, sizeof (res), "%d", ret);
        rz_sys_setenv (buf, res);
    } else {
        /* syntax error */
    }
    return 0;
}

References eq, rz_sys_setenv(), snprintf, and spp_var_get().

TAG_CALLBACK() [2/25]

static TAG_CALLBACK ( spp_case  )

static

Definition at line 345 of file spp.h.

                              {
    state->echo[state->ifl] = strcmp (buf, spp_switch_str)?0:1;
    return 0;
}

References spp_switch_str.

TAG_CALLBACK() [3/25]

static TAG_CALLBACK ( spp_default  )

static

Definition at line 312 of file spp.h.

                                 {
    if (!state->echo[state->ifl]) {
        return 0;
    }
    if (buf[-1] != ';') { /* commented tag */
        fprintf (stderr, "WARNING: invalid command: '%s' at line %d\n", buf, state->lineno);
    }
    return 0;
}

TAG_CALLBACK() [4/25]

static TAG_CALLBACK ( spp_echo  )

static

Definition at line 151 of file spp.h.

                              {
    if (state->echo[state->ifl]) {
        out_printf (out, "%s", buf);
    }
    // TODO: add variable replacement here?? not necessary, done by {{get}}
    return 0;
}

References out, and out_printf().

TAG_CALLBACK() [5/25]

static TAG_CALLBACK ( spp_else  )

static

Definition at line 280 of file spp.h.

                              {
    state->echo[state->ifl] = state->echo[state->ifl] ? 0 : 1;
    return 0;
}

TAG_CALLBACK() [6/25]

static TAG_CALLBACK ( spp_endif  )

static

Definition at line 308 of file spp.h.

                               {
    return -1;
}

TAG_CALLBACK() [7/25]

static TAG_CALLBACK ( spp_endpipe  )

static

Definition at line 356 of file spp.h.

                                 {
#if HAVE_SYSTEM
    /* TODO: Get output here */
    int ret = 0, len = 0;
    int outlen = 4096;
    char *str = (char *)malloc (4096);
    char *tstr;
    do {
        len += ret;
        ret = fread (str + len, 1, 1023, spp_pipe_fd);
        if (ret + 1024 > outlen) {
            outlen += 4096;
            tstr = realloc (str, outlen);
            if (!tstr) {
                fprintf (stderr, "Out of memory.\n");
                break;
            }
            str = tstr;
        }
    } while (ret > 0);
    str[len] = '\0';
    out_printf (out, "%s", str);
    if (spp_pipe_fd) {
        pclose (spp_pipe_fd);
    }
    spp_pipe_fd = NULL;
    free (str);
#endif
    return 0;
}

References free(), len, malloc(), NULL, out, out_printf(), realloc(), and cmd_descs_generate::str.

TAG_CALLBACK() [8/25]

static TAG_CALLBACK ( spp_endswitch  )

static

Definition at line 350 of file spp.h.

                                   {
    free (spp_switch_str);
    spp_switch_str = NULL;
    return -1;
}

References free(), NULL, and spp_switch_str.

TAG_CALLBACK() [9/25]

static TAG_CALLBACK ( spp_error  )

static

Definition at line 159 of file spp.h.

                               {
    if (!state->echo[state->ifl]) {
        return 0;
    }
    fprintf (stderr, "ERROR: %s (line=%d)\n", buf, state->lineno);
    return -1;
}

TAG_CALLBACK() [10/25]

static TAG_CALLBACK ( spp_get  )

static

Definition at line 75 of file spp.h.

                             {
    char *var;
    if (!state->echo[state->ifl]) {
        return 0;
    }
    var = spp_var_get (buf);
    if (var) {
        out_printf (out, "%s", var);
    }
    return 0;
}

References out, out_printf(), and spp_var_get().

TAG_CALLBACK() [11/25]

static TAG_CALLBACK ( spp_getrandom  )

static

Definition at line 87 of file spp.h.

                                   {
    int max;
    if (!state->echo[state->ifl]) {
        return 0;
    }
    // XXX srsly? this is pretty bad random
    srandom (rz_sys_getpid ()); // TODO: change this to be portable
    max = atoi (buf);
    if (max > 0) {
        max = (int)(rand () % max);
    }
    out_printf (out, "%d", max);
    return 0;
}

References int, max, out, out_printf(), and rz_sys_getpid().

TAG_CALLBACK() [12/25]

static TAG_CALLBACK ( spp_grepline  )

static

Definition at line 253 of file spp.h.

                                  {
    FILE *fd;
    char b[1024];
    char *ptr;
    int line;
 
    if (!state->echo[state->ifl]) return 1;
    ptr = strchr(buf, ' ');
    if (ptr) {
        *ptr= '\0';
        fd = fopen (buf, "r");
        line = atoi (ptr+1);
        if (fd) {
            while (!feof (fd) && line--) {
                if (!fgets (b, 1023, fd)) {
                    break;
                }
            }
            fclose (fd);
            out_printf (out, "%s", b);
        } else {
            fprintf(stderr, "Unable to open '%s'\n", buf);
        }
    }
    return 0;
}

References b, fd, benchmark::FILE, setup::line, out, and out_printf().

TAG_CALLBACK() [13/25]

static TAG_CALLBACK ( spp_hex  )

static

Definition at line 236 of file spp.h.

                             {
    int i;
    for(i = 0; buf[i]; i++) {
        if (buf[i] >= '0' && buf[i] <= '9') {
            int b;
            unsigned int ch;
            b = buf[i + 2];
            buf[i + 2] = '\0';
            sscanf(buf + i, "%02x", &ch);
            out_printf (out, "%c", ch);
            buf[i + 2] = b;
            buf = buf + 2;
        }
    }
    return 0;
}

References b, i, out, and out_printf().

TAG_CALLBACK() [14/25]

static TAG_CALLBACK ( spp_if  )

static

Definition at line 209 of file spp.h.

                            {
    char *var = spp_var_get(buf);
    state->echo[state->ifl + 1] = (var && *var != '0' && *var != '\0') ? 1 : 0;
    return 1;
}

References spp_var_get().

TAG_CALLBACK() [15/25]

static TAG_CALLBACK ( spp_ifeq  )

static

Definition at line 216 of file spp.h.

                              {
    char *value = buf;
    char *eq = strchr(buf, ' ');
    if (eq) {
        *eq = '\0';
        value = spp_var_get(value);
        if (value && !strcmp(value, eq+1)) {
            state->echo[state->ifl + 1] = 1;
        } else state->echo[state->ifl + 1] = 0;
//fprintf(stderr, "IFEQ(%s)(%s)=%d\n", buf, eq+1, echo[ifl]);
    } else {
        value = spp_var_get(buf);
        if (!value || *value=='\0')
            state->echo[state->ifl + 1] = 1;
        else state->echo[state->ifl + 1] = 0;
//fprintf(stderr, "IFEQ(%s)(%s)=%d\n", buf, value, echo[ifl]);
    }
    return 1;
}

References eq, spp_var_get(), and value.

TAG_CALLBACK() [16/25]

static TAG_CALLBACK ( spp_ifin  )

static

Definition at line 291 of file spp.h.

                              {
    char *var, *ptr;
    if (!state->echo[state->ifl]) {
        return 1;
    }
    ptr = strchr (buf, ' ');
    state->echo[state->ifl + 1] = 0;
    if (ptr) {
        *ptr='\0';
        var = getenv(buf);
        if (strstr (ptr + 1, var)) {
            state->echo[state->ifl + 1] = 1;
        }
    }
    return 1;
}

References getenv().

TAG_CALLBACK() [17/25]

static TAG_CALLBACK ( spp_ifnot  )

static

Definition at line 285 of file spp.h.

                               {
    spp_if (state, out, buf);
    spp_else (state, out, buf);
    return 1;
}

References out.

TAG_CALLBACK() [18/25]

static TAG_CALLBACK ( spp_include  )

static

Definition at line 187 of file spp.h.

                                 {
    char *incdir;
    if (!state->echo[state->ifl]) {
        return 0;
    }
    incdir = getenv("SPP_INCDIR");
    if (incdir) {
        char *b = strdup (incdir);
        char *p = realloc (b, strlen (b) + strlen (buf) + 3);
        if (p) {
            b = p;
            strcat (b, "/");
            strcat (b, buf);
            spp_file (b, out);
        }
        free (b);
    } else {
        spp_file(buf, out);
    }
    return 0;
}

References b, free(), getenv(), out, p, realloc(), spp_file(), and strdup().

TAG_CALLBACK() [19/25]

static TAG_CALLBACK ( spp_pipe  )

static

Definition at line 326 of file spp.h.

                              {
#if HAVE_SYSTEM
    spp_pipe_fd = popen (buf, "w");
#endif
    return 0;
}

TAG_CALLBACK() [20/25]

static TAG_CALLBACK ( spp_set  )

static

Definition at line 51 of file spp.h.

                             {
    char *eq, *val = "";
    if (!state->echo[state->ifl]) {
        return 0;
    }
    for (eq=buf; eq[0]; eq++) {
        switch (eq[0]) {
        case '-':
        case '.':
            eq[0] = '_';
            break;
        }
    }
    eq = strchr (buf, ' ');
    if (eq) {
        *eq = '\0';
        val = eq + 1;
    }
    if (spp_var_set (buf, val) == -1) {
        fprintf (stderr, "Invalid variable name '%s' at line %d\n", buf, state->lineno);
    }
    return 0;
}

References eq, spp_var_set(), and val.

TAG_CALLBACK() [21/25]

static TAG_CALLBACK ( spp_sub  )

static

Definition at line 124 of file spp.h.

                             {
    char *eq = strchr(buf, ' ');
    char *var;
    int ret = 0;
    if (!state->echo[state->ifl]) {
        return 0;
    }
    if (eq) {
        *eq = '\0';
        var = spp_var_get (buf);
        ret = var? atoi (var): 0;
        ret -= atoi (eq + 1);
        rz_sys_setenv (buf, eq + 1);
    } else {
        /* syntax error */
    }
    return ret;
}

References eq, rz_sys_setenv(), and spp_var_get().

TAG_CALLBACK() [22/25]

static TAG_CALLBACK ( spp_switch  )

static

Definition at line 335 of file spp.h.

                                {
    char *var = spp_var_get (buf);
    if (var) {
        spp_switch_str = strdup (var);
    } else {
        spp_switch_str = strdup ("");
    }
    return 1;
}

References spp_switch_str, spp_var_get(), and strdup().

TAG_CALLBACK() [23/25]

static TAG_CALLBACK ( spp_system  )

static

Definition at line 175 of file spp.h.

                                {
    if (!state->echo[state->ifl]) {
        return 0;
    }
#if HAVE_SYSTEM
    char *str = cmd_to_str (buf);
    out_printf (out, "%s", str);
    free(str);
#endif
    return 0;
}

References free(), out, out_printf(), and cmd_descs_generate::str.

TAG_CALLBACK() [24/25]

static TAG_CALLBACK ( spp_trace  )

static

Definition at line 143 of file spp.h.

                               {
    if (state->echo[state->ifl]) {
        fprintf (stderr, "%.1000s\n", buf);
    }
    return 0;
}

TAG_CALLBACK() [25/25]

static TAG_CALLBACK ( spp_warning  )

static

Definition at line 167 of file spp.h.

                                 {
    if (!state->echo[state->ifl]) {
        return 0;
    }
    fprintf (stderr, "WARNING: %s (line=%d)\n", buf, state->lineno);
    return 0;
}

Variable Documentation

spp_args

struct Arg spp_args[]

static

Initial value:

= {
    { "-I", "add include directory", 1, spp_arg_i },
    { "-D", "define value of variable", 1, spp_arg_d },
    { NULL }
}

Definition at line 433 of file spp.h.

spp_proc

DLL_LOCAL struct Proc spp_proc

Initial value:

= {
    .name = "spp",
    .tags = (struct Tag **)spp_tags,
    .args = (struct Arg **)spp_args,
    .token = " ",
    .eof = NULL,
    .tag_pre = "<{",
    .tag_post = "}>",
    .chop = 1,
    .fputs = spp_fputs,
    .multiline = NULL,
    .default_echo = 1,
    .tag_begin = 0,
}

Definition at line 451 of file spp.h.

spp_switch_str

char* spp_switch_str = NULL

static

Definition at line 333 of file spp.h.

Referenced by TAG_CALLBACK().

spp_tags

struct Tag spp_tags[]

static

Initial value:

= {
    { "get", spp_get },
    { "hex", spp_hex },
    { "getrandom", spp_getrandom },
    { "grepline", spp_grepline },
    { "set", spp_set },
    { "add", spp_add },
    { "sub", spp_sub },
    { "switch", spp_switch },
    { "case", spp_case },
    { "endswitch", spp_endswitch },
    { "echo", spp_echo },
    { "error", spp_error },
    { "warning", spp_warning },
    { "trace", spp_trace },
    { "ifin", spp_ifin },
    { "ifnot", spp_ifnot },
    { "ifeq", spp_ifeq },
    { "if", spp_if },
    { "else", spp_else },
    { "endif", spp_endif },
    { "pipe", spp_pipe },
    { "endpipe", spp_endpipe },
    { "include", spp_include },
    { "system", spp_system },
    { NULL, spp_default },
    { NULL }
}

Definition at line 387 of file spp.h.