wpp.h File Reference

#include <stdio.h>
#include <stdarg.h>

Include dependency graph for wpp.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	wpp_callbacks

Functions
int	wpp_add_define (const char *name, const char *value)
void	wpp_del_define (const char *name)
int	wpp_add_cmdline_define (const char *value)
void	wpp_set_debug (int lex_debug, int parser_debug, int msg_debug)
void	wpp_set_pedantic (int on)
int	wpp_add_include_path (const char *path)
char *	wpp_find_include (const char *name, const char *parent_name)
int	wpp_parse (const char *input, FILE *output)
void	wpp_set_callbacks (const struct wpp_callbacks *callbacks)

Function Documentation

wpp_add_cmdline_define()

int wpp_add_cmdline_define

(

const char *

value

)

Definition at line 153 of file wpp.c.

{
    char *p;
    char *str = pp_xstrdup(value);
    if(!str)
        return 1;
    p = strchr( str, '=' );
    if (p) *p++ = 0;
    wpp_add_define( str, p );
    free( str );
    return 0;
}

Referenced by main().

wpp_add_define()

int wpp_add_define	(	const char *	name,
		const char *	value
	)

Definition at line 377 of file compiler.c.

{
    struct define *def;
 
    if (!value) value = "";
 
    for (def = cmdline_defines; def; def = def->next)
    {
        if (!strcmp( def->name, name ))
        {
            char *new_value = pp_xstrdup(value);
            if(!new_value)
                return 1;
            free( def->value );
            def->value = new_value;
 
            return 0;
        }
    }
 
    def = pp_xmalloc( sizeof(*def) );
    if(!def)
        return 1;
    def->next  = cmdline_defines;
    def->name  = pp_xstrdup(name);
    if(!def->name)
    {
        free(def);
        return 1;
    }
    def->value = pp_xstrdup(value);
    if(!def->value)
    {
        free(def->name);
        free(def);
        return 1;
    }
    cmdline_defines = def;
    return 0;
}

Referenced by add_widl_version_define(), main(), preprocess_shader(), and wpp_add_cmdline_define().

wpp_add_include_path()

int wpp_add_include_path

(

const char *

path

)

Definition at line 460 of file preproc.c.

{
    char *tok;
    char *cpy = pp_xstrdup(path);
    if(!cpy)
        return 1;
 
    tok = strtok(cpy, INCLUDESEPARATOR);
    while(tok)
    {
        if(*tok) {
            char *dir;
            char *cptr;
            char **new_path;
 
            dir = pp_xstrdup(tok);
            if(!dir)
            {
                free(cpy);
                return 1;
            }
            for(cptr = dir; *cptr; cptr++)
            {
                /* Convert to forward slash */
                if(*cptr == '\\')
                    *cptr = '/';
            }
            /* Kill eventual trailing '/' */
            if(*(cptr = dir + strlen(dir)-1) == '/')
                *cptr = '\0';
 
            /* Add to list */
            new_path = pp_xrealloc(includepath, (nincludepath+1) * sizeof(*includepath));
            if(!new_path)
            {
                free(dir);
                free(cpy);
                return 1;
            }
            includepath = new_path;
            includepath[nincludepath] = dir;
            nincludepath++;
        }
        tok = strtok(NULL, INCLUDESEPARATOR);
    }
    free(cpy);
    return 0;
}

Referenced by main().

wpp_del_define()

void wpp_del_define

(

const char *

name

)

Definition at line 420 of file compiler.c.

{
    struct define *def;
 
    for (def = cmdline_defines; def; def = def->next)
    {
        if (!strcmp( def->name, name ))
        {
            free( def->value );
            def->value = NULL;
            return;
        }
    }
}

Referenced by preprocess_shader().

wpp_find_include()

char * wpp_find_include	(	const char *	name,
		const char *	parent_name
	)

Definition at line 509 of file preproc.c.

{
    return wpp_default_lookup(name, !!parent_name, parent_name, includepath, nincludepath);
}

Referenced by open_typelib().

wpp_parse()

int wpp_parse	(	const char *	input,
		FILE *	output
	)

Definition at line 437 of file compiler.c.

{
    int ret;
 
    pp_status.input = NULL;
    pp_status.line_number = 1;
    pp_status.char_number = 1;
    pp_status.state = 0;
 
    ret = pp_push_define_state();
    if(ret)
        return ret;
    add_cmdline_defines();
    add_special_defines();
 
    if (!input) pp_status.file = stdin;
    else if (!(pp_status.file = wpp_open(input, 1)))
    {
        ppy_error("Could not open %s\n", input);
        del_special_defines();
        del_cmdline_defines();
        pp_pop_define_state();
        return 2;
    }
 
    pp_status.input = input ? pp_xstrdup(input) : NULL;
 
    ppy_out = output;
    pp_writestring("# 1 \"%s\" 1\n", input ? input : "");
 
    ret = ppy_parse();
    /* If there were errors during processing, return an error code */
    if (!ret && pp_status.state) ret = pp_status.state;
 
    if (input)
    {
    wpp_close(pp_status.file);
    free(pp_status.input);
    }
    /* Clean if_stack, it could remain dirty on errors */
    while (pp_get_if_depth()) pp_pop_if();
    del_special_defines();
    del_cmdline_defines();
    pp_pop_define_state();
    return ret;
}

Referenced by main(), and preprocess_shader().

wpp_set_callbacks()

void wpp_set_callbacks

(

const struct wpp_callbacks *

callbacks

)

Definition at line 232 of file wpp.c.

{
    wpp_callbacks = callbacks;
}

wpp_set_debug()

void wpp_set_debug	(	int	lex_debug,
		int	parser_debug,
		int	msg_debug
	)

Definition at line 168 of file wpp.c.

{
    pp_flex_debug   = lex_debug;
    ppy_debug       = parser_debug;
    pp_status.debug = msg_debug;
}

Referenced by main().

wpp_set_pedantic()

void wpp_set_pedantic

(

int

on

)

Definition at line 177 of file wpp.c.

{
    pp_status.pedantic = on;
}