spp.c File Reference

#include "spp.h"
#include "rz_api.h"
#include "config.h"
#include "rz_api.c"

Go to the source code of this file.

Functions
S_API int	spp_run (char *buf, Output *out)
static char *	spp_run_str (char *buf, int *rv)
void	lbuf_strcat (SppBuf *dst, char *src)
int	do_fputs (Output *out, char *str)
S_API void	spp_eval (char *buf, Output *out)
S_API void	spp_proc_eval (SppProc *proc, char *buf, Output *out)
S_API void	spp_io (FILE *in, Output *out)
S_API int	spp_file (const char *file, Output *out)
S_API void	spp_proc_list_kw ()
S_API void	spp_proc_list ()
S_API void	spp_proc_set (SppProc *p, const char *arg, int fail)
void	out_printf (Output *out, char *str,...)
static void	spp_proc_init (SppProc *p)
S_API char *	spp_eval_str (SppProc *p, const char *code)

Function Documentation

do_fputs()

int do_fputs	(	Output *	out,
		char *	str
	)

Definition at line 88 of file spp.c.

                                     {
    int i;
    int printed = 0;
    for (i = 0; i <= proc->state.ifl; i++) {
        if (!proc->state.echo[i]) {
            return printed;
        }
    }
    if (str[0]) {
        printed = 1;
    }
    if (proc->fputs) {
        proc->fputs (out, str);
    } else {
        if (out->fout) {
            fprintf (out->fout, "%s", str);
        }
    }
    return printed;
}

References SppState::echo, i, SppState::ifl, out, proc, Proc::state, and cmd_descs_generate::str.

Referenced by spp_io(), and spp_proc_eval().

lbuf_strcat()

void lbuf_strcat	(	SppBuf *	dst,
		char *	src
	)

Definition at line 73 of file spp.c.

                                         {
    int len = strlen (src);
    char *nbuf;
    if (!dst->lbuf || (len + dst->lbuf_n) > dst->lbuf_s) {
        nbuf = realloc (dst->lbuf, dst->lbuf_s << 1);
        if (!nbuf) {
            fprintf (stderr, "Out of memory.\n");
            return;
        }
        dst->lbuf = nbuf;
    }
    memcpy (dst->lbuf + dst->lbuf_n, src, len + 1);
    dst->lbuf_n += len;
}

References dst, len, memcpy(), realloc(), and src.

Referenced by spp_proc_eval().

out_printf()

void out_printf	(	Output *	out,
		char *	str,
			...
	)

Definition at line 329 of file spp.c.

                                             {
    va_list ap;
    va_start (ap, str);
    if (out->fout) {
        vfprintf (out->fout, str, ap);
    } else {
        char tmp[4096];
        vsnprintf (tmp, sizeof (tmp), str, ap);
        tmp[sizeof (tmp) - 1] = 0;
        rz_strbuf_append (out->cout, tmp);
    }
    va_end (ap);
}

References out, rz_strbuf_append(), cmd_descs_generate::str, autogen_x86imm::tmp, and vsnprintf.

spp_eval()

S_API void spp_eval	(	char *	buf,
		Output *	out
	)

Definition at line 109 of file spp.c.

                                            {
    spp_proc_eval (proc, buf, out);
}

References out, proc, and spp_proc_eval().

Referenced by main(), rz_asm_rasm_assemble(), and spp_io().

spp_eval_str()

S_API char* spp_eval_str	(	SppProc *	p,
		const char *	code
	)

Definition at line 352 of file spp.c.

                                                       {
    if (p) {
        spp_proc_init (p);
    }
    Output out;
    out.fout = NULL;
    out.cout = rz_strbuf_new (NULL);
    rz_strbuf_init (out.cout);
    char *c = strdup (code);
    if (c) {
        spp_proc_eval (p, c, &out);
        free (c);
    }
    return rz_strbuf_drain (out.cout);
}

References c, free(), NULL, out, p, rz_strbuf_drain(), rz_strbuf_init(), rz_strbuf_new(), spp_proc_eval(), spp_proc_init(), and strdup().

spp_file()

S_API int spp_file	(	const char *	file,
		Output *	out
	)

Definition at line 272 of file spp.c.

                                                  {
    FILE *in = fopen (file, "r");
    D fprintf (stderr, "SPP-FILE(%s)\n", file);
    if (in) {
        spp_io (in, out);
        fclose (in);
        return 1;
    }
    fprintf (stderr, "Cannot find '%s'\n", file);
    return 0;
}

References D, benchmark::FILE, in, out, and spp_io().

Referenced by main(), and TAG_CALLBACK().

spp_io()

S_API void spp_io	(	FILE *	in,
		Output *	out
	)

Definition at line 224 of file spp.c.

                                         {
    char buf[4096];
    int lines;
    if (!proc->buf.lbuf) {
        proc->buf.lbuf = calloc (1, 4096);
    }
    if (!proc->buf.lbuf) {
        fprintf (stderr, "Out of memory.\n");
        return;
    }
    proc->buf.lbuf[0] = '\0';
    proc->buf.lbuf_s = 1024;
    while (!feof (in)) {
        buf[0] = '\0'; // ???
        if (!fgets (buf, sizeof (buf) - 1, in)) {
            break;
        }
        if (feof (in)) break;
        lines = 1;
        if (!memcmp (buf, "#!", 2)) {
            if (!fgets (buf, sizeof (buf) - 1, in) || feof (in)) {
                break;
            }
            lines++;
        }
        if (proc->multiline) {
            while (1) {
                char *eol = buf + strlen (buf) - strlen (proc->multiline);
                if (!strcmp (eol, proc->multiline)) {
                    D fprintf (stderr, "Multiline detected!\n");
                    if (!fgets (eol, 1023, in)) {
                        break;
                    }
                    if (feof (in)) {
                        break;
                    }
                    lines++;
                } else {
                    break;
                }
            }
        }
        spp_eval (buf, out);
        proc->state.lineno += lines;
    }
    (void)do_fputs (out, proc->buf.lbuf);
}

References Proc::buf, calloc(), D, do_fputs(), in, SppBuf::lbuf, SppBuf::lbuf_s, SppState::lineno, lines(), Proc::multiline, out, proc, spp_eval(), and Proc::state.

Referenced by main(), and spp_file().

spp_proc_eval()

S_API void spp_proc_eval	(	SppProc *	proc,
		char *	buf,
		Output *	out
	)

Definition at line 113 of file spp.c.

                                                                {
    char *ptr, *ptr2;
    char *ptrr = NULL;
    int delta;
    int printed = 0;
retry:
    /* per word */
    if (!proc->tag_pre && proc->token) {
        do {
            ptr = strstr (buf, proc->token);
            if (ptr) {
                *ptr = '\0';
            }
            delta = strlen (buf) - 1;
            if (buf[delta] == '\n') {
                buf[delta] = '\0';
            }
            if (*buf) {
                spp_run (buf, out);
            }
            buf = ptr + 1;
        } while (ptr);
        return;
    }
 
    if (!proc->tag_post) {
        /* handle per line here ? */
        return;
    }
 
    // TODO: do it in scope!
    delta = strlen (proc->tag_post);
 
    /* (pre) tag */
    ptr = proc->tag_pre? strstr (buf, proc->tag_pre): NULL;
    if (ptr) {
        D printf ("==> 0.0 (%s)\n", ptr);
        if (!proc->tag_begin || (proc->tag_begin && ptr == buf)) {
            *ptr = '\0';
            ptr = ptr + strlen (proc->tag_pre);
            if (do_fputs (out, buf)) {
                printed = 1;
            }
            D printf ("==> 0 (%s)\n", ptr);
        }
        ptrr = strstr (ptr + strlen (proc->tag_pre), proc->tag_pre);
    }
 
    /* (post) tag */
    if (!ptr) {
        do_fputs (out, buf);
        return;
    }
    ptr2 = strstr (ptr, proc->tag_post);
    if (ptr2) {
        *ptr2 = '\0';
        if (ptrr) {
            if (ptrr < ptr2) {
                char *p = strdup (ptr2 + 2);
                char *s = spp_run_str (ptrr + strlen (proc->tag_pre), NULL);
                D fprintf (stderr, "strcpy(%s)(%s)\n", ptrr, s);
                strcpy (ptrr, s);
                free (s);
                ptr[-2] = proc->tag_pre[0]; // XXX -2 check underflow?
 
                D fprintf (stderr, "strcat(%s)(%s)\n", ptrr, p);
                strcat (ptrr, p);
                buf = ptr - 2;
                D fprintf (stderr, "CONTINUE (%s)\n", buf);
                free (p);
                ptrr = NULL;
                goto retry;
            }
        }
        if (proc->buf.lbuf && proc->buf.lbuf[0]) {
            D printf("==> 1 (%s)\n", proc->buf.lbuf);
            if (ptr) {
                lbuf_strcat (&proc->buf, buf);
                do_fputs (out, buf);
                spp_run (ptr, out);
            } else {
                lbuf_strcat (&proc->buf, buf);
                D printf ("=(1)=> spp_run(%s)\n", proc->buf.lbuf);
                spp_run (proc->buf.lbuf + delta, out);
                D printf ("=(1)=> spp_run(%s)\n", proc->buf.lbuf);
            }
            proc->buf.lbuf[0]='\0';
            proc->buf.lbuf_n = 0;
        } else {
            D printf ("==> 2 (%s)\n", ptr);
            if (ptr) {
                D printf (" ==> 2.1: run(%s)\n", ptr);
                spp_run (ptr, out);
                buf = ptr2 + delta;
                if (buf[0] == '\n' && printed) {
                    buf++;
                }
                D printf (" ==> 2.1: continue(%s)\n", buf);
                goto retry;
            } else {
                do_fputs (out, buf);
            }
        }
        do_fputs (out, buf);
    } else {
        D printf ("==> 3\n");
        lbuf_strcat (&proc->buf, ptr);
    }
}

References Proc::buf, D, delta, do_fputs(), free(), SppBuf::lbuf, SppBuf::lbuf_n, lbuf_strcat(), NULL, out, p, printf(), proc, s, spp_run(), spp_run_str(), strdup(), Proc::tag_begin, Proc::tag_post, Proc::tag_pre, and Proc::token.

Referenced by spp_eval(), and spp_eval_str().

spp_proc_init()

static void spp_proc_init ( SppProc *  p )

static

Definition at line 343 of file spp.c.

                                      {
    p->state.lineno = 1;
    p->state.ifl = 0;
    size_t i;
    for (i = 0; i < MAXIFL; i++) {
        p->state.echo[i] = p->default_echo;
    }
}

References i, MAXIFL, and p.

Referenced by spp_eval_str().

spp_proc_list()

S_API void spp_proc_list

(

void

)

Definition at line 291 of file spp.c.

                           {
    size_t i;
    for (i = 0; procs[i]; i++) {
        printf ("%s\n", procs[i]->name);
    }
}

References i, printf(), and procs.

Referenced by main().

spp_proc_list_kw()

S_API void spp_proc_list_kw

(

void

)

Definition at line 284 of file spp.c.

                              {
    int i;
    for (i = 0; tags[i].name; i++) {
        printf ("%s\n", tags[i].name);
    }
}

References i, printf(), and make_dist_html::tags.

Referenced by main().

spp_proc_set()

S_API void spp_proc_set	(	SppProc *	p,
		const char *	arg,
		int	fail
	)

Definition at line 298 of file spp.c.

                                                               {
    size_t i;
    bool found = false;
    if (arg) {
        for (i = 0; procs[i]; i++) {
            if (!strcmp (procs[i]->name, arg)) {
                proc = procs[i];
                found = true;
                D printf ("SET PROC:(%s)(%s)\n", arg, proc->name);
                break;
            }
        }
    }
    if (arg && *arg && !procs[i] && fail) {
        fprintf (stderr, "Invalid preprocessor name '%s'\n", arg);
        return;
    }
    if (!found || !proc) {
        proc = p;
    }
    if (proc) {
        proc->state.lineno = 1;
        proc->state.ifl = 0;
        for (i = 0; i < MAXIFL; i++) {
            proc->state.echo[i] = proc->default_echo;
        }
        //args = (struct Arg*)proc->args;
        tags = (SppTag*)proc->tags;
    }
}

References D, Proc::default_echo, SppState::echo, fail, found, i, SppState::ifl, SppState::lineno, MAXIFL, Proc::name, p, printf(), proc, procs, Proc::state, make_dist_html::tags, and Proc::tags.

Referenced by main(), and rz_asm_rasm_assemble().

spp_run()

S_API int spp_run	(	char *	buf,
		Output *	out
	)

Definition at line 11 of file spp.c.

                                          {
    size_t i;
    int ret = 0;
    char *tok;
 
    D fprintf (stderr, "SPP_RUN(%s)\n", buf);
    if (proc->chop) {
        for (; IS_SPACE (*buf); buf++);
        int buflen = strlen (buf);
        for (tok = buf + (buflen? buflen - 1: 0); IS_SPACE (*tok); tok--) {
            *tok = '\0';
        }
    }
 
    if (proc->token) {
        tok = strstr (buf, proc->token);
        if (tok) {
            *tok = '\0';
            tok = tok + 1;
        } else {
            tok = buf;
        }
    } else {
        tok = buf;
    }
    for (i = 0; tags[i].callback; i++) {
        D fprintf (stderr, "NAME=(%s)\n", tok);
        if ((!tags[i].name) || (!strcmp (buf, tags[i].name))) {
            if (out->fout) {
                fflush (out->fout);
            }
            ret = tags[i].callback (&proc->state, out, tok);
            proc->state.ifl += ret;
            if (ret == -1) {
                break;
            }
            if (ret) {
                if (proc->state.ifl < 0 || proc->state.ifl >= MAXIFL) {
                    fprintf (stderr, "Nested conditionals parsing error.\n");
                    break;
                }
            }
            break;
        }
    }
    return ret;
}

References buflen, Proc::chop, D, i, SppState::ifl, IS_SPACE, MAXIFL, out, proc, Proc::state, make_dist_html::tags, and Proc::token.

Referenced by spp_proc_eval(), and spp_run_str().

spp_run_str()

static char* spp_run_str ( char *  buf, int *  rv  )

static

Definition at line 59 of file spp.c.

                                             {
    char *b;
    Output tmp;
    tmp.fout = NULL;
    tmp.cout = rz_strbuf_new ("");
    int rc = spp_run (buf, &tmp);
    b = strdup (rz_strbuf_get (tmp.cout));
    rz_strbuf_free (tmp.cout);
    if (rv) {
        *rv = rc;
    }
    return b;
}

References b, NULL, rz_strbuf_free(), rz_strbuf_get(), rz_strbuf_new(), spp_run(), strdup(), and autogen_x86imm::tmp.

Referenced by spp_proc_eval().