kernel32/tests: Make test_define_dos_deviceA() static.
[wine] / dlls / d3dcompiler_43 / compiler.c
1 /*
2  * Copyright 2009 Matteo Bruni
3  * Copyright 2010 Matteo Bruni for CodeWeavers
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2.1 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18  */
19
20 #define COBJMACROS
21 #include "config.h"
22 #include "wine/port.h"
23 #include "wine/debug.h"
24 #include "wine/unicode.h"
25
26 #include "d3dcompiler_private.h"
27 #include "wine/wpp.h"
28
29 WINE_DEFAULT_DEBUG_CHANNEL(d3dcompiler);
30
31 #define D3DXERR_INVALIDDATA                      0x88760b59
32
33 #define BUFFER_INITIAL_CAPACITY 256
34
35 struct mem_file_desc
36 {
37     const char *buffer;
38     unsigned int size;
39     unsigned int pos;
40 };
41
42 static struct mem_file_desc current_shader;
43 static ID3DInclude *current_include;
44
45 #define INCLUDES_INITIAL_CAPACITY 4
46
47 struct loaded_include
48 {
49     const char *name;
50     const char *data;
51 };
52
53 static struct loaded_include *includes;
54 static int includes_capacity, includes_size;
55 static const char *parent_include;
56
57 static char *wpp_output;
58 static int wpp_output_capacity, wpp_output_size;
59
60 static char *wpp_messages;
61 static int wpp_messages_capacity, wpp_messages_size;
62
63 /* Mutex used to guarantee a single invocation
64    of the D3DXAssembleShader function (or its variants) at a time.
65    This is needed as wpp isn't thread-safe */
66 static CRITICAL_SECTION wpp_mutex;
67 static CRITICAL_SECTION_DEBUG wpp_mutex_debug =
68 {
69     0, 0, &wpp_mutex,
70     { &wpp_mutex_debug.ProcessLocksList,
71       &wpp_mutex_debug.ProcessLocksList },
72       0, 0, { (DWORD_PTR)(__FILE__ ": wpp_mutex") }
73 };
74 static CRITICAL_SECTION wpp_mutex = { &wpp_mutex_debug, -1, 0, 0, 0, 0 };
75
76 /* Preprocessor error reporting functions */
77 static void wpp_write_message(const char *fmt, va_list args)
78 {
79     char* newbuffer;
80     int rc, newsize;
81
82     if(wpp_messages_capacity == 0)
83     {
84         wpp_messages = HeapAlloc(GetProcessHeap(), 0, MESSAGEBUFFER_INITIAL_SIZE);
85         if(wpp_messages == NULL)
86         {
87             ERR("Error allocating memory for parser messages\n");
88             return;
89         }
90         wpp_messages_capacity = MESSAGEBUFFER_INITIAL_SIZE;
91     }
92
93     while(1)
94     {
95         rc = vsnprintf(wpp_messages + wpp_messages_size,
96                        wpp_messages_capacity - wpp_messages_size, fmt, args);
97
98         if (rc < 0 ||                                           /* C89 */
99             rc >= wpp_messages_capacity - wpp_messages_size) {  /* C99 */
100             /* Resize the buffer */
101             newsize = wpp_messages_capacity * 2;
102             newbuffer = HeapReAlloc(GetProcessHeap(), 0, wpp_messages, newsize);
103             if(newbuffer == NULL)
104             {
105                 ERR("Error reallocating memory for parser messages\n");
106                 return;
107             }
108             wpp_messages = newbuffer;
109             wpp_messages_capacity = newsize;
110         }
111         else
112         {
113             wpp_messages_size += rc;
114             return;
115         }
116     }
117 }
118
119 static void PRINTF_ATTR(1,2) wpp_write_message_var(const char *fmt, ...)
120 {
121     va_list args;
122
123     va_start(args, fmt);
124     wpp_write_message(fmt, args);
125     va_end(args);
126 }
127
128 static void wpp_error(const char *file, int line, int col, const char *near,
129                       const char *msg, va_list ap)
130 {
131     wpp_write_message_var("%s:%d:%d: %s: ", file ? file : "'main file'",
132                           line, col, "Error");
133     wpp_write_message(msg, ap);
134     wpp_write_message_var("\n");
135 }
136
137 static void wpp_warning(const char *file, int line, int col, const char *near,
138                         const char *msg, va_list ap)
139 {
140     wpp_write_message_var("%s:%d:%d: %s: ", file ? file : "'main file'",
141                           line, col, "Warning");
142     wpp_write_message(msg, ap);
143     wpp_write_message_var("\n");
144 }
145
146 static char *wpp_lookup_mem(const char *filename, const char *parent_name,
147                             char **include_path, int include_path_count)
148 {
149     /* Here we return always ok. We will maybe fail on the next wpp_open_mem */
150     char *path;
151     int i;
152
153     parent_include = NULL;
154     if(parent_name[0] != '\0')
155     {
156         for(i = 0; i < includes_size; i++)
157         {
158             if(!strcmp(parent_name, includes[i].name))
159             {
160                 parent_include = includes[i].data;
161                 break;
162             }
163         }
164         if(parent_include == NULL)
165         {
166             ERR("Parent include file missing\n");
167             return NULL;
168         }
169     }
170
171     path = malloc(strlen(filename) + 1);
172     if(path)
173         memcpy(path, filename, strlen(filename) + 1);
174     return path;
175 }
176
177 static void *wpp_open_mem(const char *filename, int type)
178 {
179     struct mem_file_desc *desc;
180     HRESULT hr;
181
182     if(filename[0] == '\0') /* "" means to load the initial shader */
183     {
184         current_shader.pos = 0;
185         return &current_shader;
186     }
187
188     if(current_include == NULL) return NULL;
189     desc = HeapAlloc(GetProcessHeap(), 0, sizeof(*desc));
190     if(!desc)
191     {
192         ERR("Error allocating memory\n");
193         return NULL;
194     }
195     hr = ID3DInclude_Open(current_include,
196                           type ? D3D_INCLUDE_SYSTEM : D3D_INCLUDE_LOCAL,
197                           filename, parent_include, (LPCVOID *)&desc->buffer,
198                           &desc->size);
199     if(FAILED(hr))
200     {
201         HeapFree(GetProcessHeap(), 0, desc);
202         return NULL;
203     }
204
205     if(includes_capacity == includes_size)
206     {
207         if(includes_capacity == 0)
208         {
209             includes = HeapAlloc(GetProcessHeap(), 0, INCLUDES_INITIAL_CAPACITY * sizeof(*includes));
210             if(includes == NULL)
211             {
212                 ERR("Error allocating memory for the loaded includes structure\n");
213                 goto error;
214             }
215             includes_capacity = INCLUDES_INITIAL_CAPACITY * sizeof(*includes);
216         }
217         else
218         {
219             int newcapacity = includes_capacity * 2;
220             struct loaded_include *newincludes =
221                 HeapReAlloc(GetProcessHeap(), 0, includes, newcapacity);
222             if(newincludes == NULL)
223             {
224                 ERR("Error reallocating memory for the loaded includes structure\n");
225                 goto error;
226             }
227             includes = newincludes;
228             includes_capacity = newcapacity;
229         }
230     }
231     includes[includes_size].name = filename;
232     includes[includes_size++].data = desc->buffer;
233
234     desc->pos = 0;
235     return desc;
236
237 error:
238     ID3DInclude_Close(current_include, desc->buffer);
239     HeapFree(GetProcessHeap(), 0, desc);
240     return NULL;
241 }
242
243 static void wpp_close_mem(void *file)
244 {
245     struct mem_file_desc *desc = file;
246
247     if(desc != &current_shader)
248     {
249         if(current_include)
250             ID3DInclude_Close(current_include, desc->buffer);
251         else
252             ERR("current_include == NULL, desc == %p, buffer = %s\n",
253                 desc, desc->buffer);
254
255         HeapFree(GetProcessHeap(), 0, desc);
256     }
257 }
258
259 static int wpp_read_mem(void *file, char *buffer, unsigned int len)
260 {
261     struct mem_file_desc *desc = file;
262
263     len = min(len, desc->size - desc->pos);
264     memcpy(buffer, desc->buffer + desc->pos, len);
265     desc->pos += len;
266     return len;
267 }
268
269 static void wpp_write_mem(const char *buffer, unsigned int len)
270 {
271     char *new_wpp_output;
272
273     if(wpp_output_capacity == 0)
274     {
275         wpp_output = HeapAlloc(GetProcessHeap(), 0, BUFFER_INITIAL_CAPACITY);
276         if(!wpp_output)
277         {
278             ERR("Error allocating memory\n");
279             return;
280         }
281         wpp_output_capacity = BUFFER_INITIAL_CAPACITY;
282     }
283     if(len > wpp_output_capacity - wpp_output_size)
284     {
285         while(len > wpp_output_capacity - wpp_output_size)
286         {
287             wpp_output_capacity *= 2;
288         }
289         new_wpp_output = HeapReAlloc(GetProcessHeap(), 0, wpp_output,
290                                      wpp_output_capacity);
291         if(!new_wpp_output)
292         {
293             ERR("Error allocating memory\n");
294             return;
295         }
296         wpp_output = new_wpp_output;
297     }
298     memcpy(wpp_output + wpp_output_size, buffer, len);
299     wpp_output_size += len;
300 }
301
302 static int wpp_close_output(void)
303 {
304     char *new_wpp_output = HeapReAlloc(GetProcessHeap(), 0, wpp_output,
305                                        wpp_output_size + 1);
306     if(!new_wpp_output) return 0;
307     wpp_output = new_wpp_output;
308     wpp_output[wpp_output_size]='\0';
309     wpp_output_size++;
310     return 1;
311 }
312
313 static HRESULT preprocess_shader(const void *data, SIZE_T data_size,
314         const D3D_SHADER_MACRO *defines, ID3DInclude *include, ID3DBlob **error_messages)
315 {
316     int ret;
317     HRESULT hr = S_OK;
318     const D3D_SHADER_MACRO *def = defines;
319
320     static const struct wpp_callbacks wpp_callbacks =
321     {
322         wpp_lookup_mem,
323         wpp_open_mem,
324         wpp_close_mem,
325         wpp_read_mem,
326         wpp_write_mem,
327         wpp_error,
328         wpp_warning,
329     };
330
331     if (def != NULL)
332     {
333         while (def->Name != NULL)
334         {
335             wpp_add_define(def->Name, def->Definition);
336             def++;
337         }
338     }
339     current_include = include;
340     includes_size = 0;
341
342     wpp_output_size = wpp_output_capacity = 0;
343     wpp_output = NULL;
344
345     wpp_set_callbacks(&wpp_callbacks);
346     wpp_messages_size = wpp_messages_capacity = 0;
347     wpp_messages = NULL;
348     current_shader.buffer = data;
349     current_shader.size = data_size;
350
351     ret = wpp_parse("", NULL);
352     if (!wpp_close_output())
353         ret = 1;
354     if (ret)
355     {
356         TRACE("Error during shader preprocessing\n");
357         if (wpp_messages)
358         {
359             int size;
360             ID3DBlob *buffer;
361
362             TRACE("Preprocessor messages:\n%s", debugstr_a(wpp_messages));
363
364             if (error_messages)
365             {
366                 size = strlen(wpp_messages) + 1;
367                 hr = D3DCreateBlob(size, &buffer);
368                 if (FAILED(hr))
369                     goto cleanup;
370                 CopyMemory(ID3D10Blob_GetBufferPointer(buffer), wpp_messages, size);
371                 *error_messages = buffer;
372             }
373         }
374         if (data)
375             TRACE("Shader source:\n%s\n", debugstr_an(data, data_size));
376         hr = E_FAIL;
377     }
378
379 cleanup:
380     /* Remove the previously added defines */
381     if (defines != NULL)
382     {
383         while (defines->Name != NULL)
384         {
385             wpp_del_define(defines->Name);
386             defines++;
387         }
388     }
389     HeapFree(GetProcessHeap(), 0, wpp_messages);
390     return hr;
391 }
392
393 static HRESULT assemble_shader(const char *preproc_shader,
394         ID3DBlob **shader_blob, ID3DBlob **error_messages)
395 {
396     struct bwriter_shader *shader;
397     char *messages = NULL;
398     HRESULT hr;
399     DWORD *res;
400     LPD3DBLOB buffer;
401     int size;
402     char *pos;
403
404     shader = SlAssembleShader(preproc_shader, &messages);
405
406     if (messages)
407     {
408         TRACE("Assembler messages:\n");
409         TRACE("%s", messages);
410
411         TRACE("Shader source:\n");
412         TRACE("%s\n", debugstr_a(preproc_shader));
413
414         if (error_messages)
415         {
416             const char *preproc_messages = *error_messages ? ID3D10Blob_GetBufferPointer(*error_messages) : NULL;
417
418             size = strlen(messages) + (preproc_messages ? strlen(preproc_messages) : 0) + 1;
419             hr = D3DCreateBlob(size, &buffer);
420             if (FAILED(hr))
421             {
422                 HeapFree(GetProcessHeap(), 0, messages);
423                 if (shader) SlDeleteShader(shader);
424                 return hr;
425             }
426             pos = ID3D10Blob_GetBufferPointer(buffer);
427             if (preproc_messages)
428             {
429                 CopyMemory(pos, preproc_messages, strlen(preproc_messages) + 1);
430                 pos += strlen(preproc_messages);
431             }
432             CopyMemory(pos, messages, strlen(messages) + 1);
433
434             if (*error_messages) ID3D10Blob_Release(*error_messages);
435             *error_messages = buffer;
436         }
437         HeapFree(GetProcessHeap(), 0, messages);
438     }
439
440     if (shader == NULL)
441     {
442         ERR("Asm reading failed\n");
443         return D3DXERR_INVALIDDATA;
444     }
445
446     hr = SlWriteBytecode(shader, 9, &res);
447     SlDeleteShader(shader);
448     if (FAILED(hr))
449     {
450         ERR("SlWriteBytecode failed with 0x%08x\n", hr);
451         return D3DXERR_INVALIDDATA;
452     }
453
454     if (shader_blob)
455     {
456         size = HeapSize(GetProcessHeap(), 0, res);
457         hr = D3DCreateBlob(size, &buffer);
458         if (FAILED(hr))
459         {
460             HeapFree(GetProcessHeap(), 0, res);
461             return hr;
462         }
463         CopyMemory(ID3D10Blob_GetBufferPointer(buffer), res, size);
464         *shader_blob = buffer;
465     }
466
467     HeapFree(GetProcessHeap(), 0, res);
468
469     return S_OK;
470 }
471
472 HRESULT WINAPI D3DAssemble(const void *data, SIZE_T datasize, const char *filename,
473         const D3D_SHADER_MACRO *defines, ID3DInclude *include, UINT flags,
474         ID3DBlob **shader, ID3DBlob **error_messages)
475 {
476     HRESULT hr;
477
478     EnterCriticalSection(&wpp_mutex);
479
480     /* TODO: flags */
481     if (flags) FIXME("flags %x\n", flags);
482
483     if (shader) *shader = NULL;
484     if (error_messages) *error_messages = NULL;
485
486     hr = preprocess_shader(data, datasize, defines, include, error_messages);
487     if (SUCCEEDED(hr))
488         hr = assemble_shader(wpp_output, shader, error_messages);
489
490     HeapFree(GetProcessHeap(), 0, wpp_output);
491     LeaveCriticalSection(&wpp_mutex);
492     return hr;
493 }
494
495 HRESULT WINAPI D3DCompile(const void *data, SIZE_T data_size, const char *filename,
496         const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint,
497         const char *target, UINT sflags, UINT eflags, ID3DBlob **shader, ID3DBlob **error_messages)
498 {
499     FIXME("data %p, data_size %lu, filename %s, defines %p, include %p, entrypoint %s,\n"
500             "target %s, sflags %#x, eflags %#x, shader %p, error_messages %p stub!\n",
501             data, data_size, debugstr_a(filename), defines, include, debugstr_a(entrypoint),
502             debugstr_a(target), sflags, eflags, shader, error_messages);
503
504     TRACE("Shader source:\n%s\n", debugstr_an(data, data_size));
505
506     if (error_messages)
507         D3DCreateBlob(1, error_messages); /* zero fill used as string end */
508
509     return D3DERR_INVALIDCALL;
510 }
511
512 HRESULT WINAPI D3DPreprocess(const void *data, SIZE_T size, const char *filename,
513         const D3D_SHADER_MACRO *defines, ID3DInclude *include,
514         ID3DBlob **shader, ID3DBlob **error_messages)
515 {
516     HRESULT hr;
517     ID3DBlob *buffer;
518
519     if (!data)
520         return E_INVALIDARG;
521
522     EnterCriticalSection(&wpp_mutex);
523
524     if (shader) *shader = NULL;
525     if (error_messages) *error_messages = NULL;
526
527     hr = preprocess_shader(data, size, defines, include, error_messages);
528
529     if (SUCCEEDED(hr))
530     {
531         if (shader)
532         {
533             hr = D3DCreateBlob(wpp_output_size, &buffer);
534             if (FAILED(hr))
535                 goto cleanup;
536             CopyMemory(ID3D10Blob_GetBufferPointer(buffer), wpp_output, wpp_output_size);
537             *shader = buffer;
538         }
539         else
540             hr = E_INVALIDARG;
541     }
542
543 cleanup:
544     HeapFree(GetProcessHeap(), 0, wpp_output);
545     LeaveCriticalSection(&wpp_mutex);
546     return hr;
547 }