compiler.c File Reference

#include <stdarg.h>
#include <time.h>
#include "wine/debug.h"
#include "d3dcompiler_private.h"
#include "wpp_private.h"

Include dependency graph for compiler.c:

Go to the source code of this file.

Classes
struct	mem_file_desc
struct	loaded_include
struct	define
struct	target_info

Macros
#define	COBJMACROS
#define	D3DXERR_INVALIDDATA   0x88760b59
#define	BUFFER_INITIAL_CAPACITY   256
#define	INCLUDES_INITIAL_CAPACITY   4

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (d3dcompiler)
static void	wpp_write_message (const char *fmt, __ms_va_list args)
static void WINAPIV	PRINTF_ATTR (1, 2)
int WINAPIV	ppy_error (const char *msg,...)
int WINAPIV	ppy_warning (const char *msg,...)
char *	wpp_lookup (const char *filename, int type, const char *parent_name)
void *	wpp_open (const char *filename, int type)
void	wpp_close (void *file)
int	wpp_read (void *file, char *buffer, unsigned int len)
void	wpp_write (const char *buffer, unsigned int len)
static int	wpp_close_output (void)
static void	add_cmdline_defines (void)
static void	del_cmdline_defines (void)
static void	add_special_defines (void)
static void	del_special_defines (void)
int	wpp_add_define (const char *name, const char *value)
void	wpp_del_define (const char *name)
int	wpp_parse (const char *input, FILE *output)
static HRESULT	preprocess_shader (const void *data, SIZE_T data_size, const char *filename, const D3D_SHADER_MACRO *defines, ID3DInclude *include, ID3DBlob **error_messages)
static HRESULT	assemble_shader (const char *preproc_shader, ID3DBlob **shader_blob, ID3DBlob **error_messages)
HRESULT WINAPI	D3DAssemble (const void *data, SIZE_T datasize, const char *filename, const D3D_SHADER_MACRO *defines, ID3DInclude *include, UINT flags, ID3DBlob **shader, ID3DBlob **error_messages)
static const struct target_info *	get_target_info (const char *target)
static HRESULT	compile_shader (const char *preproc_shader, const char *target, const char *entrypoint, ID3DBlob **shader_blob, ID3DBlob **error_messages)
HRESULT WINAPI	D3DCompile2 (const void *data, SIZE_T data_size, const char *filename, const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint, const char *target, UINT sflags, UINT eflags, UINT secondary_flags, const void *secondary_data, SIZE_T secondary_data_size, ID3DBlob **shader, ID3DBlob **error_messages)
HRESULT WINAPI	D3DCompile (const void *data, SIZE_T data_size, const char *filename, const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint, const char *target, UINT sflags, UINT eflags, ID3DBlob **shader, ID3DBlob **error_messages)
HRESULT WINAPI	D3DPreprocess (const void *data, SIZE_T size, const char *filename, const D3D_SHADER_MACRO *defines, ID3DInclude *include, ID3DBlob **shader, ID3DBlob **error_messages)
HRESULT WINAPI	D3DDisassemble (const void *data, SIZE_T size, UINT flags, const char *comments, ID3DBlob **disassembly)
HRESULT WINAPI	D3DCompileFromFile (const WCHAR *filename, const D3D_SHADER_MACRO *defines, ID3DInclude *includes, const char *entrypoint, const char *target, UINT flags1, UINT flags2, ID3DBlob **code, ID3DBlob **errors)
HRESULT WINAPI	D3DLoadModule (const void *data, SIZE_T size, ID3D11Module **module)

Variables
static struct mem_file_desc	current_shader
static ID3DInclude *	current_include
static const char *	initial_filename
static struct loaded_include *	includes
static int	includes_capacity
static int	includes_size
static const char *	parent_include
static char *	wpp_output
static int	wpp_output_capacity
static int	wpp_output_size
static char *	wpp_messages
static int	wpp_messages_capacity
static int	wpp_messages_size
static struct define *	cmdline_defines
static CRITICAL_SECTION	wpp_mutex = { &wpp_mutex_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	wpp_mutex_debug
static const struct target_info	targets_info []

Macro Definition Documentation

BUFFER_INITIAL_CAPACITY

#define BUFFER_INITIAL_CAPACITY   256

Definition at line 32 of file compiler.c.

COBJMACROS

#define COBJMACROS

Definition at line 20 of file compiler.c.

D3DXERR_INVALIDDATA

#define D3DXERR_INVALIDDATA   0x88760b59

Definition at line 30 of file compiler.c.

INCLUDES_INITIAL_CAPACITY

#define INCLUDES_INITIAL_CAPACITY   4

Definition at line 45 of file compiler.c.

Function Documentation

add_cmdline_defines()

static void add_cmdline_defines ( void  )

static

Definition at line 326 of file compiler.c.

{
    struct define *def;
 
    for (def = cmdline_defines; def; def = def->next)
    {
        if (def->value) pp_add_define( def->name, def->value );
    }
}

Referenced by wpp_parse().

add_special_defines()

static void add_special_defines ( void  )

static

Definition at line 346 of file compiler.c.

{
    time_t now = time(NULL);
    pp_entry_t *ppp;
    char buf[32];
 
    strftime(buf, sizeof(buf), "\"%b %d %Y\"", localtime(&now));
    pp_add_define( "__DATE__", buf );
 
    strftime(buf, sizeof(buf), "\"%H:%M:%S\"", localtime(&now));
    pp_add_define( "__TIME__", buf );
 
    ppp = pp_add_define( "__FILE__", "" );
    if(ppp)
        ppp->type = def_special;
 
    ppp = pp_add_define( "__LINE__", "" );
    if(ppp)
        ppp->type = def_special;
}

Referenced by wpp_parse().

assemble_shader()

static HRESULT assemble_shader ( const char *  preproc_shader, ID3DBlob **  shader_blob, ID3DBlob **  error_messages  )

static

Definition at line 553 of file compiler.c.

{
    struct bwriter_shader *shader;
    char *messages = NULL;
    HRESULT hr;
    DWORD *res, size;
    ID3DBlob *buffer;
    char *pos;
 
    shader = SlAssembleShader(preproc_shader, &messages);
 
    if (messages)
    {
        TRACE("Assembler messages:\n");
        TRACE("%s\n", debugstr_a(messages));
 
        TRACE("Shader source:\n");
        TRACE("%s\n", debugstr_a(preproc_shader));
 
        if (error_messages)
        {
            const char *preproc_messages = *error_messages ? ID3D10Blob_GetBufferPointer(*error_messages) : NULL;
 
            size = strlen(messages) + (preproc_messages ? strlen(preproc_messages) : 0) + 1;
            hr = D3DCreateBlob(size, &buffer);
            if (FAILED(hr))
            {
                HeapFree(GetProcessHeap(), 0, messages);
                if (shader) SlDeleteShader(shader);
                return hr;
            }
            pos = ID3D10Blob_GetBufferPointer(buffer);
            if (preproc_messages)
            {
                CopyMemory(pos, preproc_messages, strlen(preproc_messages) + 1);
                pos += strlen(preproc_messages);
            }
            CopyMemory(pos, messages, strlen(messages) + 1);
 
            if (*error_messages) ID3D10Blob_Release(*error_messages);
            *error_messages = buffer;
        }
        HeapFree(GetProcessHeap(), 0, messages);
    }
 
    if (shader == NULL)
    {
        ERR("Asm reading failed\n");
        return D3DXERR_INVALIDDATA;
    }
 
    hr = SlWriteBytecode(shader, 9, &res, &size);
    SlDeleteShader(shader);
    if (FAILED(hr))
    {
        ERR("SlWriteBytecode failed with 0x%08x\n", hr);
        return D3DXERR_INVALIDDATA;
    }
 
    if (shader_blob)
    {
        hr = D3DCreateBlob(size, &buffer);
        if (FAILED(hr))
        {
            HeapFree(GetProcessHeap(), 0, res);
            return hr;
        }
        CopyMemory(ID3D10Blob_GetBufferPointer(buffer), res, size);
        *shader_blob = buffer;
    }
 
    HeapFree(GetProcessHeap(), 0, res);
 
    return S_OK;
}

Referenced by D3DAssemble().

compile_shader()

static HRESULT compile_shader ( const char *  preproc_shader, const char *  target, const char *  entrypoint, ID3DBlob **  shader_blob, ID3DBlob **  error_messages  )

static

Definition at line 754 of file compiler.c.

{
    struct bwriter_shader *shader;
    char *messages = NULL;
    HRESULT hr;
    DWORD *res, size, major, minor;
    ID3DBlob *buffer;
    char *pos;
    enum shader_type shader_type;
    const struct target_info *info;
 
    TRACE("Preprocessed shader source: %s\n", debugstr_a(preproc_shader));
 
    TRACE("Checking compilation target %s\n", debugstr_a(target));
    info = get_target_info(target);
    if (!info)
    {
        FIXME("Unknown compilation target %s\n", debugstr_a(target));
        return D3DERR_INVALIDCALL;
    }
    else
    {
        if (!info->support)
        {
            FIXME("Compilation target %s not yet supported\n", debugstr_a(target));
            return D3DERR_INVALIDCALL;
        }
        else
        {
            shader_type = info->type;
            major = info->sm_major;
            minor = info->sm_minor;
        }
    }
 
    shader = parse_hlsl_shader(preproc_shader, shader_type, major, minor, entrypoint, &messages);
 
    if (messages)
    {
        TRACE("Compiler messages:\n");
        TRACE("%s\n", debugstr_a(messages));
 
        TRACE("Shader source:\n");
        TRACE("%s\n", debugstr_a(preproc_shader));
 
        if (error_messages)
        {
            const char *preproc_messages = *error_messages ? ID3D10Blob_GetBufferPointer(*error_messages) : NULL;
 
            size = strlen(messages) + (preproc_messages ? strlen(preproc_messages) : 0) + 1;
            hr = D3DCreateBlob(size, &buffer);
            if (FAILED(hr))
            {
                HeapFree(GetProcessHeap(), 0, messages);
                if (shader) SlDeleteShader(shader);
                return hr;
            }
            pos = ID3D10Blob_GetBufferPointer(buffer);
            if (preproc_messages)
            {
                memcpy(pos, preproc_messages, strlen(preproc_messages) + 1);
                pos += strlen(preproc_messages);
            }
            memcpy(pos, messages, strlen(messages) + 1);
 
            if (*error_messages) ID3D10Blob_Release(*error_messages);
            *error_messages = buffer;
        }
        HeapFree(GetProcessHeap(), 0, messages);
    }
 
    if (!shader)
    {
        ERR("HLSL shader parsing failed.\n");
        return D3DXERR_INVALIDDATA;
    }
 
    hr = SlWriteBytecode(shader, 9, &res, &size);
    SlDeleteShader(shader);
    if (FAILED(hr))
    {
        ERR("SlWriteBytecode failed with error 0x%08x.\n", hr);
        return D3DXERR_INVALIDDATA;
    }
 
    if (shader_blob)
    {
        hr = D3DCreateBlob(size, &buffer);
        if (FAILED(hr))
        {
            HeapFree(GetProcessHeap(), 0, res);
            return hr;
        }
        memcpy(ID3D10Blob_GetBufferPointer(buffer), res, size);
        *shader_blob = buffer;
    }
 
    HeapFree(GetProcessHeap(), 0, res);
 
    return S_OK;
}

Referenced by D3DCompile2().

D3DAssemble()

HRESULT WINAPI D3DAssemble	(	const void *	data,
		SIZE_T	datasize,
		const char *	filename,
		const D3D_SHADER_MACRO *	defines,
		ID3DInclude *	include,
		UINT	flags,
		ID3DBlob **	shader,
		ID3DBlob **	error_messages
	)

Definition at line 630 of file compiler.c.

{
    HRESULT hr;
 
    TRACE("data %p, datasize %lu, filename %s, defines %p, include %p, sflags %#x, "
            "shader %p, error_messages %p.\n",
            data, datasize, debugstr_a(filename), defines, include, flags, shader, error_messages);
 
    EnterCriticalSection(&wpp_mutex);
 
    /* TODO: flags */
    if (flags) FIXME("flags %x\n", flags);
 
    if (shader) *shader = NULL;
    if (error_messages) *error_messages = NULL;
 
    hr = preprocess_shader(data, datasize, filename, defines, include, error_messages);
    if (SUCCEEDED(hr))
        hr = assemble_shader(wpp_output, shader, error_messages);
 
    HeapFree(GetProcessHeap(), 0, wpp_output);
    LeaveCriticalSection(&wpp_mutex);
    return hr;
}

Referenced by D3DXAssembleShader().

D3DCompile()

HRESULT WINAPI D3DCompile	(	const void *	data,
		SIZE_T	data_size,
		const char *	filename,
		const D3D_SHADER_MACRO *	defines,
		ID3DInclude *	include,
		const char *	entrypoint,
		const char *	target,
		UINT	sflags,
		UINT	eflags,
		ID3DBlob **	shader,
		ID3DBlob **	error_messages
	)

Definition at line 889 of file compiler.c.

{
    TRACE("data %p, data_size %lu, filename %s, defines %p, include %p, entrypoint %s, "
            "target %s, sflags %#x, eflags %#x, shader %p, error_messages %p.\n",
            data, data_size, debugstr_a(filename), defines, include, debugstr_a(entrypoint),
            debugstr_a(target), sflags, eflags, shader, error_messages);
 
    return D3DCompile2(data, data_size, filename, defines, include, entrypoint, target, sflags,
            eflags, 0, NULL, 0, shader, error_messages);
}

Referenced by d3dx9_effect_init(), D3DXCompileShader(), and D3DXCompileShaderFromFileW().

D3DCompile2()

HRESULT WINAPI D3DCompile2	(	const void *	data,
		SIZE_T	data_size,
		const char *	filename,
		const D3D_SHADER_MACRO *	defines,
		ID3DInclude *	include,
		const char *	entrypoint,
		const char *	target,
		UINT	sflags,
		UINT	eflags,
		UINT	secondary_flags,
		const void *	secondary_data,
		SIZE_T	secondary_data_size,
		ID3DBlob **	shader,
		ID3DBlob **	error_messages
	)

Definition at line 857 of file compiler.c.

{
    HRESULT hr;
 
    TRACE("data %p, data_size %lu, filename %s, defines %p, include %p, entrypoint %s, "
            "target %s, sflags %#x, eflags %#x, secondary_flags %#x, secondary_data %p, "
            "secondary_data_size %lu, shader %p, error_messages %p.\n",
            data, data_size, debugstr_a(filename), defines, include, debugstr_a(entrypoint),
            debugstr_a(target), sflags, eflags, secondary_flags, secondary_data,
            secondary_data_size, shader, error_messages);
 
    if (secondary_data)
        FIXME("secondary data not implemented yet\n");
 
    if (shader) *shader = NULL;
    if (error_messages) *error_messages = NULL;
 
    EnterCriticalSection(&wpp_mutex);
 
    hr = preprocess_shader(data, data_size, filename, defines, include, error_messages);
    if (SUCCEEDED(hr))
        hr = compile_shader(wpp_output, target, entrypoint, shader, error_messages);
 
    HeapFree(GetProcessHeap(), 0, wpp_output);
    LeaveCriticalSection(&wpp_mutex);
    return hr;
}

Referenced by D3DCompile().

D3DCompileFromFile()

HRESULT WINAPI D3DCompileFromFile	(	const WCHAR *	filename,
		const D3D_SHADER_MACRO *	defines,
		ID3DInclude *	includes,
		const char *	entrypoint,
		const char *	target,
		UINT	flags1,
		UINT	flags2,
		ID3DBlob **	code,
		ID3DBlob **	errors
	)

Definition at line 949 of file compiler.c.

{
    FIXME("filename %s, defines %p, includes %p, entrypoint %s, target %s, flags1 %x, flags2 %x, code %p, errors %p\n",
            debugstr_w(filename), defines, includes, debugstr_a(entrypoint), debugstr_a(target), flags1, flags2, code, errors);
 
    return E_NOTIMPL;
}

D3DDisassemble()

HRESULT WINAPI D3DDisassemble	(	const void *	data,
		SIZE_T	size,
		UINT	flags,
		const char *	comments,
		ID3DBlob **	disassembly
	)

Definition at line 942 of file compiler.c.

{
    FIXME("data %p, size %lu, flags %#x, comments %p, disassembly %p stub!\n",
            data, size, flags, comments, disassembly);
    return E_NOTIMPL;
}

D3DLoadModule()

HRESULT WINAPI D3DLoadModule	(	const void *	data,
		SIZE_T	size,
		ID3D11Module **	module
	)

Definition at line 959 of file compiler.c.

{
    FIXME("data %p, size %lu, module %p stub!\n", data, size, module);
    return E_NOTIMPL;
}

D3DPreprocess()

HRESULT WINAPI D3DPreprocess	(	const void *	data,
		SIZE_T	size,
		const char *	filename,
		const D3D_SHADER_MACRO *	defines,
		ID3DInclude *	include,
		ID3DBlob **	shader,
		ID3DBlob **	error_messages
	)

Definition at line 902 of file compiler.c.

{
    HRESULT hr;
    ID3DBlob *buffer;
 
    TRACE("data %p, size %lu, filename %s, defines %p, include %p, shader %p, error_messages %p\n",
          data, size, debugstr_a(filename), defines, include, shader, error_messages);
 
    if (!data)
        return E_INVALIDARG;
 
    EnterCriticalSection(&wpp_mutex);
 
    if (shader) *shader = NULL;
    if (error_messages) *error_messages = NULL;
 
    hr = preprocess_shader(data, size, filename, defines, include, error_messages);
 
    if (SUCCEEDED(hr))
    {
        if (shader)
        {
            hr = D3DCreateBlob(wpp_output_size, &buffer);
            if (FAILED(hr))
                goto cleanup;
            CopyMemory(ID3D10Blob_GetBufferPointer(buffer), wpp_output, wpp_output_size);
            *shader = buffer;
        }
        else
            hr = E_INVALIDARG;
    }
 
cleanup:
    HeapFree(GetProcessHeap(), 0, wpp_output);
    LeaveCriticalSection(&wpp_mutex);
    return hr;
}

Referenced by D3DXPreprocessShader(), and D3DXPreprocessShaderFromFileW().

del_cmdline_defines()

static void del_cmdline_defines ( void  )

static

Definition at line 336 of file compiler.c.

{
    struct define *def;
 
    for (def = cmdline_defines; def; def = def->next)
    {
        if (def->value) pp_del_define( def->name );
    }
}

Referenced by wpp_parse().

del_special_defines()

static void del_special_defines ( void  )

static

Definition at line 367 of file compiler.c.

{
    pp_del_define( "__DATE__" );
    pp_del_define( "__TIME__" );
    pp_del_define( "__FILE__" );
    pp_del_define( "__LINE__" );
}

Referenced by wpp_parse().

get_target_info()

static const struct target_info * get_target_info ( const char *  target )

static

Definition at line 732 of file compiler.c.

{
    LONG min = 0;
    LONG max = ARRAY_SIZE(targets_info) - 1;
    LONG cur;
    int res;
 
    while (min <= max)
    {
        cur = (min + max) / 2;
        res = strcmp(target, targets_info[cur].name);
        if (res < 0)
            max = cur - 1;
        else if (res > 0)
            min = cur + 1;
        else
            return &targets_info[cur];
    }
 
    return NULL;
}

Referenced by compile_shader().

ppy_error()

int WINAPIV ppy_error	(	const char *	msg,
			...
	)

Definition at line 135 of file compiler.c.

{
    __ms_va_list ap;
    __ms_va_start(ap, msg);
    wpp_write_message_var("%s:%d:%d: %s: ",
                          pp_status.input ? pp_status.input : "'main file'",
                          pp_status.line_number, pp_status.char_number, "Error");
    wpp_write_message(msg, ap);
    wpp_write_message_var("\n");
    __ms_va_end(ap);
    pp_status.state = 1;
    return 1;
}

Referenced by pp_pop_if(), and wpp_parse().

ppy_warning()

int WINAPIV ppy_warning	(	const char *	msg,
			...
	)

Definition at line 149 of file compiler.c.

{
    __ms_va_list ap;
    __ms_va_start(ap, msg);
    wpp_write_message_var("%s:%d:%d: %s: ",
                          pp_status.input ? pp_status.input : "'main file'",
                          pp_status.line_number, pp_status.char_number, "Warning");
    wpp_write_message(msg, ap);
    wpp_write_message_var("\n");
    __ms_va_end(ap);
    return 0;
}

Referenced by pp_add_define(), pp_add_macro(), and pp_del_define().

preprocess_shader()

static HRESULT preprocess_shader ( const void *  data, SIZE_T  data_size, const char *  filename, const D3D_SHADER_MACRO *  defines, ID3DInclude *  include, ID3DBlob **  error_messages  )

static

Definition at line 484 of file compiler.c.

{
    int ret;
    HRESULT hr = S_OK;
    const D3D_SHADER_MACRO *def = defines;
 
    if (def != NULL)
    {
        while (def->Name != NULL)
        {
            wpp_add_define(def->Name, def->Definition);
            def++;
        }
    }
    current_include = include;
    includes_size = 0;
 
    wpp_output_size = wpp_output_capacity = 0;
    wpp_output = NULL;
 
    wpp_messages_size = wpp_messages_capacity = 0;
    wpp_messages = NULL;
    current_shader.buffer = data;
    current_shader.size = data_size;
    initial_filename = filename ? filename : "";
 
    ret = wpp_parse(initial_filename, NULL);
    if (!wpp_close_output())
        ret = 1;
    if (ret)
    {
        TRACE("Error during shader preprocessing\n");
        if (wpp_messages)
        {
            int size;
            ID3DBlob *buffer;
 
            TRACE("Preprocessor messages:\n%s\n", debugstr_a(wpp_messages));
 
            if (error_messages)
            {
                size = strlen(wpp_messages) + 1;
                hr = D3DCreateBlob(size, &buffer);
                if (FAILED(hr))
                    goto cleanup;
                CopyMemory(ID3D10Blob_GetBufferPointer(buffer), wpp_messages, size);
                *error_messages = buffer;
            }
        }
        if (data)
            TRACE("Shader source:\n%s\n", debugstr_an(data, data_size));
        hr = E_FAIL;
    }
 
cleanup:
    /* Remove the previously added defines */
    if (defines != NULL)
    {
        while (defines->Name != NULL)
        {
            wpp_del_define(defines->Name);
            defines++;
        }
    }
    HeapFree(GetProcessHeap(), 0, wpp_messages);
    return hr;
}

Referenced by D3DAssemble(), D3DCompile2(), and D3DPreprocess().

PRINTF_ATTR()

static void WINAPIV PRINTF_ATTR ( 1  , 2    )

static

Definition at line 126 of file compiler.c.

{
    __ms_va_list args;
 
    __ms_va_start(args, fmt);
    wpp_write_message(fmt, args);
    __ms_va_end(args);
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

d3dcompiler

)

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(), and preprocess_shader().

wpp_close()

void wpp_close

(

void *

file

)

Definition at line 258 of file compiler.c.

{
    struct mem_file_desc *desc = file;
 
    if(desc != &current_shader)
    {
        if(current_include)
            ID3DInclude_Close(current_include, desc->buffer);
        else
            ERR("current_include == NULL, desc == %p, buffer = %s\n",
                desc, desc->buffer);
 
        HeapFree(GetProcessHeap(), 0, desc);
    }
}

Referenced by wpp_parse().

wpp_close_output()

static int wpp_close_output ( void  )

static

Definition at line 315 of file compiler.c.

{
    char *new_wpp_output = HeapReAlloc(GetProcessHeap(), 0, wpp_output,
                                       wpp_output_size + 1);
    if(!new_wpp_output) return 0;
    wpp_output = new_wpp_output;
    wpp_output[wpp_output_size]='\0';
    wpp_output_size++;
    return 1;
}

Referenced by preprocess_shader().

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

char * wpp_lookup	(	const char *	filename,
		int	type,
		const char *	parent_name
	)

Definition at line 162 of file compiler.c.

{
    /* We don't check for file existence here. We will potentially fail on
     * the following wpp_open_mem(). */
    char *path;
    int i;
 
    TRACE("Looking for include %s, parent %s.\n", debugstr_a(filename), debugstr_a(parent_name));
 
    parent_include = NULL;
    if (strcmp(parent_name, initial_filename))
    {
        for(i = 0; i < includes_size; i++)
        {
            if(!strcmp(parent_name, includes[i].name))
            {
                parent_include = includes[i].data;
                break;
            }
        }
        if(parent_include == NULL)
        {
            ERR("Parent include %s missing.\n", debugstr_a(parent_name));
            return NULL;
        }
    }
 
    path = malloc(strlen(filename) + 1);
    if(path)
        memcpy(path, filename, strlen(filename) + 1);
    return path;
}

Referenced by pp_open_include().

wpp_open()

void * wpp_open	(	const char *	filename,
		int	type
	)

Definition at line 195 of file compiler.c.

{
    struct mem_file_desc *desc;
    HRESULT hr;
 
    TRACE("Opening include %s.\n", debugstr_a(filename));
 
    if(!strcmp(filename, initial_filename))
    {
        current_shader.pos = 0;
        return &current_shader;
    }
 
    if(current_include == NULL) return NULL;
    desc = HeapAlloc(GetProcessHeap(), 0, sizeof(*desc));
    if(!desc)
        return NULL;
 
    if (FAILED(hr = ID3DInclude_Open(current_include, type ? D3D_INCLUDE_LOCAL : D3D_INCLUDE_SYSTEM,
            filename, parent_include, (const void **)&desc->buffer, &desc->size)))
    {
        HeapFree(GetProcessHeap(), 0, desc);
        return NULL;
    }
 
    if(includes_capacity == includes_size)
    {
        if(includes_capacity == 0)
        {
            includes = HeapAlloc(GetProcessHeap(), 0, INCLUDES_INITIAL_CAPACITY * sizeof(*includes));
            if(includes == NULL)
            {
                ERR("Error allocating memory for the loaded includes structure\n");
                goto error;
            }
            includes_capacity = INCLUDES_INITIAL_CAPACITY * sizeof(*includes);
        }
        else
        {
            int newcapacity = includes_capacity * 2;
            struct loaded_include *newincludes =
                HeapReAlloc(GetProcessHeap(), 0, includes, newcapacity);
            if(newincludes == NULL)
            {
                ERR("Error reallocating memory for the loaded includes structure\n");
                goto error;
            }
            includes = newincludes;
            includes_capacity = newcapacity;
        }
    }
    includes[includes_size].name = filename;
    includes[includes_size++].data = desc->buffer;
 
    desc->pos = 0;
    return desc;
 
error:
    ID3DInclude_Close(current_include, desc->buffer);
    HeapFree(GetProcessHeap(), 0, desc);
    return NULL;
}

Referenced by pp_open_include(), and wpp_parse().

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

int wpp_read	(	void *	file,
		char *	buffer,
		unsigned int	len
	)

Definition at line 274 of file compiler.c.

{
    struct mem_file_desc *desc = file;
 
    len = min(len, desc->size - desc->pos);
    memcpy(buffer, desc->buffer + desc->pos, len);
    desc->pos += len;
    return len;
}

wpp_write()

void wpp_write	(	const char *	buffer,
		unsigned int	len
	)

Definition at line 284 of file compiler.c.

{
    char *new_wpp_output;
 
    if(wpp_output_capacity == 0)
    {
        wpp_output = HeapAlloc(GetProcessHeap(), 0, BUFFER_INITIAL_CAPACITY);
        if(!wpp_output)
            return;
 
        wpp_output_capacity = BUFFER_INITIAL_CAPACITY;
    }
    if(len > wpp_output_capacity - wpp_output_size)
    {
        while(len > wpp_output_capacity - wpp_output_size)
        {
            wpp_output_capacity *= 2;
        }
        new_wpp_output = HeapReAlloc(GetProcessHeap(), 0, wpp_output,
                                     wpp_output_capacity);
        if(!new_wpp_output)
        {
            ERR("Error allocating memory\n");
            return;
        }
        wpp_output = new_wpp_output;
    }
    memcpy(wpp_output + wpp_output_size, buffer, len);
    wpp_output_size += len;
}

wpp_write_message()

static void wpp_write_message ( const char *  fmt, __ms_va_list  args  )

static

Definition at line 86 of file compiler.c.

{
    char* newbuffer;
    int rc, newsize;
 
    if(wpp_messages_capacity == 0)
    {
        wpp_messages = HeapAlloc(GetProcessHeap(), 0, MESSAGEBUFFER_INITIAL_SIZE);
        if(wpp_messages == NULL)
            return;
 
        wpp_messages_capacity = MESSAGEBUFFER_INITIAL_SIZE;
    }
 
    while(1)
    {
        rc = vsnprintf(wpp_messages + wpp_messages_size,
                       wpp_messages_capacity - wpp_messages_size, fmt, args);
 
        if (rc < 0 ||                                           /* C89 */
            rc >= wpp_messages_capacity - wpp_messages_size) {  /* C99 */
            /* Resize the buffer */
            newsize = wpp_messages_capacity * 2;
            newbuffer = HeapReAlloc(GetProcessHeap(), 0, wpp_messages, newsize);
            if(newbuffer == NULL)
            {
                ERR("Error reallocating memory for parser messages\n");
                return;
            }
            wpp_messages = newbuffer;
            wpp_messages_capacity = newsize;
        }
        else
        {
            wpp_messages_size += rc;
            return;
        }
    }
}

Referenced by ppy_error(), ppy_warning(), and PRINTF_ATTR().

Variable Documentation

cmdline_defines

struct define* cmdline_defines

static

Definition at line 70 of file compiler.c.

Referenced by add_cmdline_defines(), del_cmdline_defines(), wpp_add_define(), and wpp_del_define().

current_include

ID3DInclude* current_include

static

Definition at line 42 of file compiler.c.

Referenced by preprocess_shader(), wpp_close(), and wpp_open().

current_shader

struct mem_file_desc current_shader

static

Definition at line 41 of file compiler.c.

Referenced by preprocess_shader(), wpp_close(), and wpp_open().

includes

struct loaded_include* includes

static

Definition at line 53 of file compiler.c.

Referenced by D3DCompileFromFile(), IncludesTest::incl0(), IncludesTest::incl1(), IncludesTest::incl2(), wpp_lookup(), and wpp_open().

includes_capacity

int includes_capacity

static

Definition at line 54 of file compiler.c.

Referenced by wpp_open().

includes_size

int includes_size

static

Definition at line 54 of file compiler.c.

Referenced by preprocess_shader(), wpp_lookup(), and wpp_open().

initial_filename

const char* initial_filename

static

Definition at line 43 of file compiler.c.

Referenced by preprocess_shader(), wpp_lookup(), and wpp_open().

parent_include

const char* parent_include

static

Definition at line 55 of file compiler.c.

Referenced by wpp_lookup(), and wpp_open().

targets_info

const struct target_info targets_info[]

static

Definition at line 669 of file compiler.c.

Referenced by get_target_info().

wpp_messages

char* wpp_messages

static

Definition at line 60 of file compiler.c.

Referenced by preprocess_shader(), and wpp_write_message().

wpp_messages_capacity

int wpp_messages_capacity

static

Definition at line 61 of file compiler.c.

Referenced by preprocess_shader(), and wpp_write_message().

wpp_messages_size

int wpp_messages_size

static

Definition at line 61 of file compiler.c.

Referenced by preprocess_shader(), and wpp_write_message().

wpp_mutex

static CRITICAL_SECTION wpp_mutex = { &wpp_mutex_debug, -1, 0, 0, 0, 0 }

static

Definition at line 75 of file compiler.c.

Referenced by D3DAssemble(), D3DCompile2(), and D3DPreprocess().

wpp_mutex_debug

CRITICAL_SECTION_DEBUG wpp_mutex_debug

static

Initial value:

=
{
    0, 0, &wpp_mutex,
    { &wpp_mutex_debug.ProcessLocksList,
      &wpp_mutex_debug.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": wpp_mutex") }
}

Definition at line 76 of file compiler.c.

wpp_output

char* wpp_output

static

Definition at line 57 of file compiler.c.

Referenced by D3DAssemble(), D3DCompile2(), D3DPreprocess(), preprocess_shader(), wpp_close_output(), and wpp_write().

wpp_output_capacity

int wpp_output_capacity

static

Definition at line 58 of file compiler.c.

Referenced by preprocess_shader(), and wpp_write().

wpp_output_size

int wpp_output_size

static

Definition at line 58 of file compiler.c.

Referenced by D3DPreprocess(), preprocess_shader(), wpp_close_output(), and wpp_write().