spp.h File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <stdbool.h>
#include <errno.h>

Go to the source code of this file.

Classes
struct	s_strbuf_t
struct	Output
struct	SppState
struct	SppBuf
struct	Tag
struct	Arg
struct	Proc
struct	spp_t

Macros
#define	VERSION   "1.2.0"
#define	S_API
#define	MAXIFL   128
#define	DLL_LOCAL   __attribute__ ((visibility ("hidden")))
#define	GET_ARG(x, y, i)   if (y[i][2]) x = y[i] + 2; else x = y[++i]
#define	DEFAULT_PROC(x)
#define	ARG_CALLBACK(x)   int x (char *arg)
#define	TAG_CALLBACK(x)   int x (SppState *state, Output *out, char *buf)
#define	PUT_CALLBACK(x)   int x (Output *out, char *buf)
#define	IS_SPACE(x)   ((x==' ')||(x=='\t')||(x=='\r')||(x=='\n'))
#define	D   if (0)
#define	HAVE_FORK   1

Typedefs
typedef struct s_strbuf_t	SStrBuf
typedef struct SppState	SppState
typedef struct SppBuf	SppBuf
typedef struct Tag	SppTag
typedef struct Arg	SppArg
typedef struct Proc	SppProc
typedef struct spp_t	Spp

Functions
S_API int	spp_file (const char *file, Output *out)
S_API int	spp_run (char *buf, Output *out)
S_API void	spp_eval (char *buf, Output *out)
S_API void	spp_proc_eval (SppProc *p, char *buf, Output *out)
S_API void	spp_io (FILE *in, Output *out)
S_API void	spp_proc_list (void)
S_API void	spp_proc_list_kw (void)
S_API void	spp_proc_set (SppProc *p, const char *arg, int fail)
S_API Spp *	spp_new (SppProc *proc)
S_API char *	spp_parse (Spp *s, const char *input)
S_API void	spp_free (Spp *s)

Macro Definition Documentation

ARG_CALLBACK

#define ARG_CALLBACK

(

x

)

int x (char *arg)

Definition at line 110 of file spp.h.

D

#define D   if (0)

Definition at line 166 of file spp.h.

DEFAULT_PROC

#define DEFAULT_PROC

(

x

)

Value:

struct Tag *tags = (struct Tag *)&x##_tags; \
struct Arg *args = (struct Arg *)&x##_args; \
struct Proc *proc = &x##_proc;

Definition at line 75 of file spp.h.

DLL_LOCAL

#define DLL_LOCAL   __attribute__ ((visibility ("hidden")))

Definition at line 69 of file spp.h.

GET_ARG

#define GET_ARG	(		x,
			y,
			i
	)		if (y[i][2]) x = y[i] + 2; else x = y[++i]

Definition at line 73 of file spp.h.

HAVE_FORK

#define HAVE_FORK   1

Definition at line 170 of file spp.h.

IS_SPACE

#define IS_SPACE

(

x

)

((x==' ')||(x=='\t')||(x=='\r')||(x=='\n'))

Definition at line 114 of file spp.h.

MAXIFL

#define MAXIFL   128

Definition at line 63 of file spp.h.

PUT_CALLBACK

#define PUT_CALLBACK

(

x

)

int x (Output *out, char *buf)

Definition at line 113 of file spp.h.

S_API

#define S_API

Definition at line 28 of file spp.h.

TAG_CALLBACK

#define TAG_CALLBACK

(

x

)

int x (SppState *state, Output *out, char *buf)

Definition at line 112 of file spp.h.

VERSION

#define VERSION   "1.2.0"

Definition at line 12 of file spp.h.

Typedef Documentation

Spp

typedef struct spp_t Spp

SppArg

typedef struct Arg SppArg

SppBuf

typedef struct SppBuf SppBuf

SppProc

typedef struct Proc SppProc

SppState

typedef struct SppState SppState

SppTag

typedef struct Tag SppTag

SStrBuf

typedef struct s_strbuf_t SStrBuf

Function Documentation

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_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_free()

S_API void spp_free

(

Spp *

s

)

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_new()

S_API Spp* spp_new

(

SppProc *

proc

)

spp_parse()

S_API char* spp_parse	(	Spp *	s,
		const char *	input
	)

spp_proc_eval()

S_API void spp_proc_eval	(	SppProc *	p,
		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_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().