mojoshader-compiler.c
1
2
3
4
5
6
7
8
9
10
11
/**
* MojoShader; generate shader programs from bytecode of compiled
* Direct3D shaders.
*
* Please see the file LICENSE.txt in the source's root directory.
*
* This file written by Ryan C. Gordon.
*/
#include <stdio.h>
#include <stdlib.h>
12
#include <string.h>
13
14
#include <assert.h>
15
16
#include "mojoshader.h"
17
18
19
20
#ifndef _WIN32
#define stricmp(a,b) strcasecmp(a,b)
#endif
21
22
23
static const char **include_paths = NULL;
static unsigned int include_path_count = 0;
24
#define MOJOSHADER_DEBUG_MALLOC 0
26
#if MOJOSHADER_DEBUG_MALLOC
27
static void *Malloc(int len, void *d)
28
29
30
31
32
33
34
35
36
37
{
void *ptr = malloc(len + sizeof (int));
int *store = (int *) ptr;
printf("malloc() %d bytes (%p)\n", len, ptr);
if (ptr == NULL) return NULL;
*store = len;
return (void *) (store + 1);
} // Malloc
38
static void Free(void *_ptr, void *d)
39
40
41
42
43
44
45
46
47
48
{
int *ptr = (((int *) _ptr) - 1);
int len = *ptr;
printf("free() %d bytes (%p)\n", len, ptr);
free(ptr);
} // Free
#else
#define Malloc NULL
#define Free NULL
#endif
50
51
52
53
54
55
56
static void fail(const char *err)
{
printf("%s.\n", err);
exit(1);
} // fail
57
static void print_unroll_attr(FILE *io, const int unroll)
58
59
{
if (unroll == 0)
60
fprintf(io, "[loop] ");
61
else if (unroll < 0)
62
fprintf(io, "[unroll] ");
64
fprintf(io, "[unroll(%d)] ", unroll);
65
66
67
} // print_unroll_attr
// !!! FIXME: this screws up on order of operations.
68
static void print_ast(FILE *io, const int substmt, const void *_ast)
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
{
const MOJOSHADER_astNode *ast = (const MOJOSHADER_astNode *) _ast;
const char *nl = substmt ? "" : "\n";
int typeint = 0;
static int indent = 0;
int isblock = 0;
int i;
// These _HAVE_ to be in the same order as MOJOSHADER_astNodeType!
static const char *binary[] =
{
",", "*", "/", "%", "+", "-", "<<", ">>", "<", ">", "<=", ">=", "==",
"!=", "&", "^", "|", "&&", "||", "=", "*=", "/=", "%=", "+=", "-=",
"<<=", ">>=", "&=", "^=", "|="
};
static const char *pre_unary[] = { "++", "--", "-", "~", "!" };
static const char *post_unary[] = { "++", "--" };
static const char *simple_stmt[] = { "", "break", "continue", "discard" };
static const char *inpmod[] = { "", "in ", "out ", "in out ", "uniform " };
static const char *fnstorage[] = { "", "inline " };
static const char *interpmod[] = {
"", " linear", " centroid", " nointerpolation",
" noperspective", " sample"
};
if (!ast) return;
typeint = (int) ast->ast.type;
#define DO_INDENT do { \
101
if (!substmt) { for (i = 0; i < indent; i++) fprintf(io, " "); } \
102
103
104
105
106
107
108
109
110
} while (0)
switch (ast->ast.type)
{
case MOJOSHADER_AST_OP_PREINCREMENT:
case MOJOSHADER_AST_OP_PREDECREMENT:
case MOJOSHADER_AST_OP_NEGATE:
case MOJOSHADER_AST_OP_COMPLEMENT:
case MOJOSHADER_AST_OP_NOT:
111
112
fprintf(io, "%s", pre_unary[(typeint-MOJOSHADER_AST_OP_START_RANGE_UNARY)-1]);
print_ast(io, 0, ast->unary.operand);
113
114
115
116
break;
case MOJOSHADER_AST_OP_POSTINCREMENT:
case MOJOSHADER_AST_OP_POSTDECREMENT:
117
118
print_ast(io, 0, ast->unary.operand);
fprintf(io, "%s", post_unary[typeint-MOJOSHADER_AST_OP_POSTINCREMENT]);
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
break;
case MOJOSHADER_AST_OP_MULTIPLY:
case MOJOSHADER_AST_OP_DIVIDE:
case MOJOSHADER_AST_OP_MODULO:
case MOJOSHADER_AST_OP_ADD:
case MOJOSHADER_AST_OP_SUBTRACT:
case MOJOSHADER_AST_OP_LSHIFT:
case MOJOSHADER_AST_OP_RSHIFT:
case MOJOSHADER_AST_OP_LESSTHAN:
case MOJOSHADER_AST_OP_GREATERTHAN:
case MOJOSHADER_AST_OP_LESSTHANOREQUAL:
case MOJOSHADER_AST_OP_GREATERTHANOREQUAL:
case MOJOSHADER_AST_OP_EQUAL:
case MOJOSHADER_AST_OP_NOTEQUAL:
case MOJOSHADER_AST_OP_BINARYAND:
case MOJOSHADER_AST_OP_BINARYXOR:
case MOJOSHADER_AST_OP_BINARYOR:
case MOJOSHADER_AST_OP_LOGICALAND:
case MOJOSHADER_AST_OP_LOGICALOR:
case MOJOSHADER_AST_OP_ASSIGN:
case MOJOSHADER_AST_OP_MULASSIGN:
case MOJOSHADER_AST_OP_DIVASSIGN:
case MOJOSHADER_AST_OP_MODASSIGN:
case MOJOSHADER_AST_OP_ADDASSIGN:
case MOJOSHADER_AST_OP_SUBASSIGN:
case MOJOSHADER_AST_OP_LSHIFTASSIGN:
case MOJOSHADER_AST_OP_RSHIFTASSIGN:
case MOJOSHADER_AST_OP_ANDASSIGN:
case MOJOSHADER_AST_OP_XORASSIGN:
case MOJOSHADER_AST_OP_ORASSIGN:
150
fprintf(io, " "); // then fall through! (no space before the comma).
151
case MOJOSHADER_AST_OP_COMMA:
152
153
print_ast(io, 0, ast->binary.left);
fprintf(io, "%s ", binary[
154
(typeint - MOJOSHADER_AST_OP_START_RANGE_BINARY) - 1]);
155
print_ast(io, 0, ast->binary.right);
156
157
158
break;
case MOJOSHADER_AST_OP_DEREF_ARRAY:
159
160
161
162
print_ast(io, 0, ast->binary.left);
fprintf(io, "[");
print_ast(io, 0, ast->binary.right);
fprintf(io, "]");
163
164
165
break;
case MOJOSHADER_AST_OP_DEREF_STRUCT:
166
167
168
print_ast(io, 0, ast->derefstruct.identifier);
fprintf(io, ".");
fprintf(io, "%s", ast->derefstruct.member);
169
170
171
break;
case MOJOSHADER_AST_OP_CONDITIONAL:
172
173
174
175
176
print_ast(io, 0, ast->ternary.left);
fprintf(io, " ? ");
print_ast(io, 0, ast->ternary.center);
fprintf(io, " : ");
print_ast(io, 0, ast->ternary.right);
177
178
179
break;
case MOJOSHADER_AST_OP_IDENTIFIER:
180
fprintf(io, "%s", ast->identifier.identifier);
181
182
183
break;
case MOJOSHADER_AST_OP_INT_LITERAL:
184
fprintf(io, "%d", ast->intliteral.value);
185
186
187
188
189
190
191
break;
case MOJOSHADER_AST_OP_FLOAT_LITERAL:
{
const float f = ast->floatliteral.value;
const long long flr = (long long) f;
if (((float) flr) == f)
192
fprintf(io, "%lld.0", flr);
193
else
194
fprintf(io, "%.16g", f);
195
196
197
198
break;
} // case
case MOJOSHADER_AST_OP_STRING_LITERAL:
199
fprintf(io, "\"%s\"", ast->stringliteral.string);
200
201
202
break;
case MOJOSHADER_AST_OP_BOOLEAN_LITERAL:
203
fprintf(io, "%s", ast->boolliteral.value ? "true" : "false");
204
205
206
break;
case MOJOSHADER_AST_ARGUMENTS:
207
print_ast(io, 0, ast->arguments.argument);
208
209
if (ast->arguments.next != NULL)
{
210
211
fprintf(io, ", ");
print_ast(io, 0, ast->arguments.next);
212
213
214
215
} // if
break;
case MOJOSHADER_AST_OP_CALLFUNC:
216
217
218
219
print_ast(io, 0, ast->callfunc.identifier);
fprintf(io, "(");
print_ast(io, 0, ast->callfunc.args);
fprintf(io, ")");
220
221
222
break;
case MOJOSHADER_AST_OP_CONSTRUCTOR:
223
224
225
fprintf(io, "%s(", ast->constructor.datatype);
print_ast(io, 0, ast->constructor.args);
fprintf(io, ")");
226
227
228
break;
case MOJOSHADER_AST_OP_CAST:
229
230
231
fprintf(io, "(%s) (", ast->cast.datatype);
print_ast(io, 0, ast->cast.operand);
fprintf(io, ")");
232
233
234
235
break;
case MOJOSHADER_AST_STATEMENT_EXPRESSION:
DO_INDENT;
236
237
238
print_ast(io, 0, ast->exprstmt.expr); // !!! FIXME: This is named badly...
fprintf(io, ";%s", nl);
print_ast(io, 0, ast->exprstmt.next);
239
240
241
242
break;
case MOJOSHADER_AST_STATEMENT_IF:
DO_INDENT;
243
244
245
fprintf(io, "if (");
print_ast(io, 0, ast->ifstmt.expr);
fprintf(io, ")\n");
246
247
isblock = ast->ifstmt.statement->ast.type == MOJOSHADER_AST_STATEMENT_BLOCK;
if (!isblock) indent++;
248
print_ast(io, 0, ast->ifstmt.statement);
249
if (!isblock) indent--;
250
print_ast(io, 0, ast->ifstmt.next);
251
252
253
254
break;
case MOJOSHADER_AST_STATEMENT_TYPEDEF:
DO_INDENT;
255
256
257
print_ast(io, 1, ast->typedefstmt.type_info);
fprintf(io, "%s", nl);
print_ast(io, 0, ast->typedefstmt.next);
258
259
260
261
262
263
264
break;
case MOJOSHADER_AST_STATEMENT_SWITCH:
DO_INDENT;
switch ( ast->switchstmt.attributes )
{
case MOJOSHADER_AST_SWITCHATTR_NONE: break;
265
266
267
268
case MOJOSHADER_AST_SWITCHATTR_FLATTEN: fprintf(io, "[flatten] "); break;
case MOJOSHADER_AST_SWITCHATTR_BRANCH: fprintf(io, "[branch] "); break;
case MOJOSHADER_AST_SWITCHATTR_FORCECASE: fprintf(io, "[forcecase] "); break;
case MOJOSHADER_AST_SWITCHATTR_CALL: fprintf(io, "[call] "); break;
269
270
} // switch
271
272
273
fprintf(io, "switch (");
print_ast(io, 0, ast->switchstmt.expr);
fprintf(io, ")\n");
274
DO_INDENT;
275
fprintf(io, "{\n");
276
indent++;
277
print_ast(io, 0, ast->switchstmt.cases);
278
indent--;
279
fprintf(io, "\n");
280
DO_INDENT;
281
282
fprintf(io, "}\n");
print_ast(io, 0, ast->switchstmt.next);
283
284
285
286
break;
case MOJOSHADER_AST_SWITCH_CASE:
DO_INDENT;
287
288
289
fprintf(io, "case ");
print_ast(io, 0, ast->cases.expr);
fprintf(io, ":\n");
290
291
isblock = ast->cases.statement->ast.type == MOJOSHADER_AST_STATEMENT_BLOCK;
if (!isblock) indent++;
292
print_ast(io, 0, ast->cases.statement);
293
if (!isblock) indent--;
294
print_ast(io, 0, ast->cases.next);
295
296
297
298
break;
case MOJOSHADER_AST_STATEMENT_STRUCT:
DO_INDENT;
299
300
301
print_ast(io, 0, ast->structstmt.struct_info);
fprintf(io, ";%s%s", nl, nl); // always space these out.
print_ast(io, 0, ast->structstmt.next);
302
303
304
305
break;
case MOJOSHADER_AST_STATEMENT_VARDECL:
DO_INDENT;
306
307
308
print_ast(io, 1, ast->vardeclstmt.declaration);
fprintf(io, ";%s", nl);
print_ast(io, 0, ast->vardeclstmt.next);
309
310
311
312
break;
case MOJOSHADER_AST_STATEMENT_BLOCK:
DO_INDENT;
313
fprintf(io, "{\n");
314
indent++;
315
print_ast(io, 0, ast->blockstmt.statements);
316
317
indent--;
DO_INDENT;
318
319
fprintf(io, "}\n");
print_ast(io, 0, ast->blockstmt.next);
320
321
322
323
break;
case MOJOSHADER_AST_STATEMENT_FOR:
DO_INDENT;
324
325
326
print_unroll_attr(io, ast->forstmt.unroll);
fprintf(io, "for (");
print_ast(io, 1, ast->forstmt.var_decl);
327
328
if (ast->forstmt.initializer != NULL)
{
329
330
fprintf(io, " = ");
print_ast(io, 1, ast->forstmt.initializer);
331
} // if
332
333
334
335
fprintf(io, "; ");
print_ast(io, 1, ast->forstmt.looptest);
fprintf(io, "; ");
print_ast(io, 1, ast->forstmt.counter);
337
fprintf(io, ")\n");
338
339
isblock = ast->forstmt.statement->ast.type == MOJOSHADER_AST_STATEMENT_BLOCK;
if (!isblock) indent++;
340
print_ast(io, 0, ast->forstmt.statement);
341
342
if (!isblock) indent--;
343
print_ast(io, 0, ast->forstmt.next);
344
345
346
347
break;
case MOJOSHADER_AST_STATEMENT_DO:
DO_INDENT;
348
349
print_unroll_attr(io, ast->dostmt.unroll);
fprintf(io, "do\n");
350
351
352
isblock = ast->dostmt.statement->ast.type == MOJOSHADER_AST_STATEMENT_BLOCK;
if (!isblock) indent++;
353
print_ast(io, 0, ast->dostmt.statement);
354
355
356
if (!isblock) indent--;
DO_INDENT;
357
358
359
fprintf(io, "while (");
print_ast(io, 0, ast->dostmt.expr);
fprintf(io, ");\n");
361
print_ast(io, 0, ast->dostmt.next);
362
363
364
365
break;
case MOJOSHADER_AST_STATEMENT_WHILE:
DO_INDENT;
366
367
368
369
print_unroll_attr(io, ast->whilestmt.unroll);
fprintf(io, "while (");
print_ast(io, 0, ast->whilestmt.expr);
fprintf(io, ")\n");
370
371
372
isblock = ast->whilestmt.statement->ast.type == MOJOSHADER_AST_STATEMENT_BLOCK;
if (!isblock) indent++;
373
print_ast(io, 0, ast->whilestmt.statement);
374
375
if (!isblock) indent--;
376
print_ast(io, 0, ast->whilestmt.next);
377
378
379
380
break;
case MOJOSHADER_AST_STATEMENT_RETURN:
DO_INDENT;
381
fprintf(io, "return");
382
383
if (ast->returnstmt.expr)
{
384
385
fprintf(io, " ");
print_ast(io, 0, ast->returnstmt.expr);
386
} // if
387
388
fprintf(io, ";%s", nl);
print_ast(io, 0, ast->returnstmt.next);
389
390
391
392
393
394
395
break;
case MOJOSHADER_AST_STATEMENT_EMPTY:
case MOJOSHADER_AST_STATEMENT_BREAK:
case MOJOSHADER_AST_STATEMENT_CONTINUE:
case MOJOSHADER_AST_STATEMENT_DISCARD:
DO_INDENT;
396
fprintf(io, "%s;%s",
397
398
simple_stmt[(typeint-MOJOSHADER_AST_STATEMENT_START_RANGE)-1],
nl);
399
print_ast(io, 0, ast->stmt.next);
400
401
402
403
break;
case MOJOSHADER_AST_COMPUNIT_FUNCTION:
DO_INDENT;
404
print_ast(io, 0, ast->funcunit.declaration);
405
if (ast->funcunit.definition == NULL)
406
fprintf(io, ";%s", nl);
407
408
else
{
409
410
411
fprintf(io, "%s", nl);
print_ast(io, 0, ast->funcunit.definition);
fprintf(io, "%s", nl);
412
} // else
413
print_ast(io, 0, ast->funcunit.next);
414
415
416
417
break;
case MOJOSHADER_AST_COMPUNIT_TYPEDEF:
DO_INDENT;
418
419
420
print_ast(io, 0, ast->typedefunit.type_info);
fprintf(io, "%s", nl);
print_ast(io, 0, ast->typedefunit.next);
421
422
423
424
break;
case MOJOSHADER_AST_COMPUNIT_STRUCT:
DO_INDENT;
425
426
427
print_ast(io, 0, ast->structunit.struct_info);
fprintf(io, ";%s%s", nl, nl); // always space these out.
print_ast(io, 0, ast->structunit.next);
428
429
430
431
break;
case MOJOSHADER_AST_COMPUNIT_VARIABLE:
DO_INDENT;
432
433
print_ast(io, 1, ast->varunit.declaration);
fprintf(io, ";%s", nl);
434
435
436
if (ast->varunit.next &&
ast->varunit.next->ast.type!=MOJOSHADER_AST_COMPUNIT_VARIABLE)
{
437
fprintf(io, "%s", nl); // group vars together, and space out other things.
438
} // if
439
print_ast(io, 0, ast->varunit.next);
440
441
442
break;
case MOJOSHADER_AST_SCALAR_OR_ARRAY:
443
fprintf(io, "%s", ast->soa.identifier);
444
445
if (ast->soa.isarray)
{
446
447
448
fprintf(io, "[");
print_ast(io, 0, ast->soa.dimension);
fprintf(io, "]");
449
450
451
452
453
} // if
break;
case MOJOSHADER_AST_TYPEDEF:
DO_INDENT;
454
fprintf(io, "typedef %s%s ",
455
ast->typdef.isconst ? "const " : "", ast->typdef.datatype);
456
457
print_ast(io, 0, ast->typdef.details);
fprintf(io, ";%s", nl);
458
459
460
break;
case MOJOSHADER_AST_FUNCTION_PARAMS:
461
462
fprintf(io, "%s", inpmod[(int) ast->params.input_modifier]);
fprintf(io, "%s %s", ast->params.datatype, ast->params.identifier);
463
if (ast->params.semantic)
464
465
fprintf(io, " : %s", ast->params.semantic);
fprintf(io, "%s", interpmod[(int) ast->params.interpolation_modifier]);
466
467
468
if (ast->params.initializer)
{
469
470
fprintf(io, " = ");
print_ast(io, 0, ast->params.initializer);
471
472
473
474
} // if
if (ast->params.next)
{
475
476
fprintf(io, ", ");
print_ast(io, 0, ast->params.next);
477
478
479
480
} // if
break;
case MOJOSHADER_AST_FUNCTION_SIGNATURE:
481
482
fprintf(io, "%s", fnstorage[(int) ast->funcsig.storage_class]);
fprintf(io, "%s %s(",
483
484
ast->funcsig.datatype ? ast->funcsig.datatype : "void",
ast->funcsig.identifier);
485
486
print_ast(io, 0, ast->funcsig.params);
fprintf(io, ")");
487
if (ast->funcsig.semantic)
488
fprintf(io, " : %s", ast->funcsig.semantic);
489
490
491
break;
case MOJOSHADER_AST_STRUCT_DECLARATION:
492
fprintf(io, "struct %s\n", ast->structdecl.name);
493
DO_INDENT;
494
fprintf(io, "{\n");
495
indent++;
496
print_ast(io, 0, ast->structdecl.members);
497
498
indent--;
DO_INDENT;
499
fprintf(io, "}");
500
501
502
503
break;
case MOJOSHADER_AST_STRUCT_MEMBER:
DO_INDENT;
504
505
506
fprintf(io, "%s", interpmod[(int)ast->structmembers.interpolation_mod]);
fprintf(io, "%s ", ast->structmembers.datatype);
print_ast(io, 0, ast->structmembers.details);
507
if (ast->structmembers.semantic)
508
509
510
fprintf(io, " : %s", ast->structmembers.semantic);
fprintf(io, ";%s", nl);
print_ast(io, 0, ast->structmembers.next);
511
512
513
514
515
break;
case MOJOSHADER_AST_VARIABLE_DECLARATION:
DO_INDENT;
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_EXTERN)
516
fprintf(io, "extern ");
517
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_NOINTERPOLATION)
518
fprintf(io, "nointerpolation ");
519
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_SHARED)
520
fprintf(io, "shared");
521
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_STATIC)
522
fprintf(io, "static ");
523
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_UNIFORM)
524
fprintf(io, "uniform ");
525
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_VOLATILE)
526
fprintf(io, "nointerpolation ");
527
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_CONST)
528
fprintf(io, "const ");
529
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_ROWMAJOR)
530
fprintf(io, "rowmajor ");
531
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_COLUMNMAJOR)
532
fprintf(io, "columnmajor ");
533
534
if (ast->vardecl.datatype)
535
fprintf(io, "%s", ast->vardecl.datatype);
536
else
537
538
539
print_ast(io, 0, ast->vardecl.anonymous_datatype);
fprintf(io, " ");
print_ast(io, 0, ast->vardecl.details);
540
if (ast->vardecl.semantic)
541
fprintf(io, " : %s", ast->vardecl.semantic);
542
543
if (ast->vardecl.annotations)
{
544
545
fprintf(io, " ");
print_ast(io, 0, ast->vardecl.annotations);
546
547
548
} // if
if (ast->vardecl.initializer != NULL)
{
549
550
fprintf(io, " = ");
print_ast(io, 0, ast->vardecl.initializer);
551
} // if
552
print_ast(io, 0, ast->vardecl.lowlevel);
553
554
if (ast->vardecl.next == NULL)
555
fprintf(io, "%s", nl);
556
557
558
else
{
const int attr = ast->vardecl.next->attributes;
559
fprintf(io, ", ");
560
ast->vardecl.next->attributes = 0;
561
print_ast(io, 1, ast->vardecl.next);
562
563
564
565
566
ast->vardecl.next->attributes = attr;
} // if
break;
case MOJOSHADER_AST_PACK_OFFSET:
567
fprintf(io, " : packoffset(%s%s%s)", ast->packoffset.ident1,
568
569
570
571
572
ast->packoffset.ident2 ? "." : "",
ast->packoffset.ident2 ? ast->packoffset.ident2 : "");
break;
case MOJOSHADER_AST_VARIABLE_LOWLEVEL:
573
print_ast(io, 0, ast->varlowlevel.packoffset);
574
if (ast->varlowlevel.register_name)
575
fprintf(io, " : register(%s)", ast->varlowlevel.register_name);
576
577
578
579
580
break;
case MOJOSHADER_AST_ANNOTATION:
{
const MOJOSHADER_astAnnotations *a = &ast->annotations;
581
fprintf(io, "<");
582
583
while (a)
{
584
fprintf(io, " %s ", a->datatype);
585
586
if (a->initializer != NULL)
{
587
588
fprintf(io, " = ");
print_ast(io, 0, a->initializer);
589
590
} // if
if (a->next)
591
fprintf(io, ",");
592
593
a = a->next;
} // while
594
fprintf(io, " >");
595
596
597
598
599
600
601
602
603
604
605
break;
} // case
default:
assert(0 && "unexpected type");
break;
} // switch
#undef DO_INDENT
} // print_ast
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
static int open_include(MOJOSHADER_includeType inctype, const char *fname,
const char *parent, const char **outdata,
unsigned int *outbytes, MOJOSHADER_malloc m,
MOJOSHADER_free f, void *d)
{
int i;
for (i = 0; i < include_path_count; i++)
{
const char *path = include_paths[i];
const size_t len = strlen(path) + strlen(fname) + 2;
char *buf = (char *) m(len, d);
if (buf == NULL)
return 0;
snprintf(buf, len, "%s/%s", path, fname);
FILE *io = fopen(buf, "rb");
f(buf, d);
if (io == NULL)
continue;
if (fseek(io, 0, SEEK_END) != -1)
{
const long fsize = ftell(io);
if ((fsize == -1) || (fseek(io, 0, SEEK_SET) == -1))
{
fclose(io);
return 0;
} // if
char *data = (char *) m(fsize, d);
if (data == NULL)
{
fclose(io);
return 0;
} // if
if (fread(data, fsize, 1, io) != 1)
{
f(data, d);
fclose(io);
return 0;
} // if
fclose(io);
*outdata = data;
*outbytes = (unsigned int) fsize;
return 1;
} // if
} // for
return 0;
} // open_include
661
662
static void close_include(const char *data, MOJOSHADER_malloc m,
MOJOSHADER_free f, void *d)
663
664
665
666
667
{
f((void *) data, d);
} // close_include
668
static int preprocess(const char *fname, const char *buf, int len,
669
670
const char *outfile,
const MOJOSHADER_preprocessorDefine *defs,
671
unsigned int defcount, FILE *io)
672
673
674
675
{
const MOJOSHADER_preprocessData *pd;
int retval = 0;
676
677
pd = MOJOSHADER_preprocess(fname, buf, len, defs, defcount, open_include,
close_include, Malloc, Free, NULL);
678
679
680
681
682
683
if (pd->error_count > 0)
{
int i;
for (i = 0; i < pd->error_count; i++)
{
684
fprintf(stderr, "%s:%d: ERROR: %s\n",
685
pd->errors[i].filename ? pd->errors[i].filename : "???",
686
687
688
689
690
691
692
693
pd->errors[i].error_position,
pd->errors[i].error);
} // for
} // if
else
{
if (pd->output != NULL)
{
694
695
const int len = pd->output_len;
if ((len) && (fwrite(pd->output, len, 1, io) != 1))
696
printf(" ... fwrite('%s') failed.\n", outfile);
697
else if ((outfile != NULL) && (fclose(io) == EOF))
698
699
700
701
702
703
704
705
printf(" ... fclose('%s') failed.\n", outfile);
else
retval = 1;
} // if
} // else
MOJOSHADER_freePreprocessData(pd);
return retval;
706
} // preprocess
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
static int assemble(const char *fname, const char *buf, int len,
const char *outfile,
const MOJOSHADER_preprocessorDefine *defs,
unsigned int defcount, FILE *io)
{
const MOJOSHADER_parseData *pd;
int retval = 0;
pd = MOJOSHADER_assemble(fname, buf, len, NULL, 0, NULL, 0,
defs, defcount, open_include, close_include,
Malloc, Free, NULL);
if (pd->error_count > 0)
{
int i;
for (i = 0; i < pd->error_count; i++)
{
726
fprintf(stderr, "%s:%d: ERROR: %s\n",
727
728
729
730
731
732
733
734
735
pd->errors[i].filename ? pd->errors[i].filename : "???",
pd->errors[i].error_position,
pd->errors[i].error);
} // for
} // if
else
{
if (pd->output != NULL)
{
736
737
const int len = pd->output_len;
if ((len) && (fwrite(pd->output, len, 1, io) != 1))
738
739
740
741
742
743
744
745
746
747
748
749
printf(" ... fwrite('%s') failed.\n", outfile);
else if ((outfile != NULL) && (fclose(io) == EOF))
printf(" ... fclose('%s') failed.\n", outfile);
else
retval = 1;
} // if
} // else
MOJOSHADER_freeParseData(pd);
return retval;
} // assemble
750
751
752
753
static int ast(const char *fname, const char *buf, int len,
const char *outfile, const MOJOSHADER_preprocessorDefine *defs,
unsigned int defcount, FILE *io)
{
754
755
const MOJOSHADER_astData *ad;
int retval = 0;
757
ad = MOJOSHADER_parseAst(MOJOSHADER_SRC_PROFILE_HLSL_PS_1_1, // !!! FIXME
758
759
fname, buf, len, defs, defcount,
open_include, close_include, Malloc, Free, NULL);
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
if (ad->error_count > 0)
{
int i;
for (i = 0; i < ad->error_count; i++)
{
fprintf(stderr, "%s:%d: ERROR: %s\n",
ad->errors[i].filename ? ad->errors[i].filename : "???",
ad->errors[i].error_position,
ad->errors[i].error);
} // for
} // if
else
{
print_ast(io, 0, ad->ast);
if ((outfile != NULL) && (fclose(io) == EOF))
printf(" ... fclose('%s') failed.\n", outfile);
else
retval = 1;
} // else
return retval;
782
} // ast
783
784
785
786
787
788
static int compile(const char *fname, const char *buf, int len,
const char *outfile,
const MOJOSHADER_preprocessorDefine *defs,
unsigned int defcount, FILE *io)
{
789
790
791
// !!! FIXME: write me.
//const MOJOSHADER_parseData *pd;
//int retval = 0;
793
794
MOJOSHADER_compile(MOJOSHADER_SRC_PROFILE_HLSL_PS_1_1, // !!! FIXME
fname, buf, len, defs, defcount,
795
796
797
798
open_include, close_include,
Malloc, Free, NULL);
return 1;
} // compile
799
800
801
802
typedef enum
{
ACTION_UNKNOWN,
803
ACTION_VERSION,
804
805
ACTION_PREPROCESS,
ACTION_ASSEMBLE,
806
ACTION_AST,
807
ACTION_COMPILE,
808
809
810
} Action;
811
812
int main(int argc, char **argv)
{
813
Action action = ACTION_UNKNOWN;
814
int retval = 1;
815
816
817
const char *infile = NULL;
const char *outfile = NULL;
int i;
819
820
821
MOJOSHADER_preprocessorDefine *defs = NULL;
unsigned int defcount = 0;
822
823
824
825
include_paths = (const char **) malloc(sizeof (char *));
include_paths[0] = ".";
include_path_count = 1;
826
// !!! FIXME: clean this up.
827
828
829
830
for (i = 1; i < argc; i++)
{
const char *arg = argv[i];
831
832
if (strcmp(arg, "-P") == 0)
{
833
if ((action != ACTION_UNKNOWN) && (action != ACTION_PREPROCESS))
834
835
836
837
838
839
fail("Multiple actions specified");
action = ACTION_PREPROCESS;
} // if
else if (strcmp(arg, "-A") == 0)
{
840
if ((action != ACTION_UNKNOWN) && (action != ACTION_ASSEMBLE))
841
842
843
844
fail("Multiple actions specified");
action = ACTION_ASSEMBLE;
} // else if
845
846
847
848
849
850
851
else if (strcmp(arg, "-T") == 0)
{
if ((action != ACTION_UNKNOWN) && (action != ACTION_AST))
fail("Multiple actions specified");
action = ACTION_AST;
} // else if
852
853
854
855
856
857
858
else if (strcmp(arg, "-C") == 0)
{
if ((action != ACTION_UNKNOWN) && (action != ACTION_COMPILE))
fail("Multiple actions specified");
action = ACTION_COMPILE;
} // else if
859
860
861
862
863
864
865
else if ((strcmp(arg, "-V") == 0) || (strcmp(arg, "--version") == 0))
{
if ((action != ACTION_UNKNOWN) && (action != ACTION_VERSION))
fail("Multiple actions specified");
action = ACTION_VERSION;
} // else if
866
else if (strcmp(arg, "-o") == 0)
867
868
{
if (outfile != NULL)
869
fail("multiple output files specified");
870
871
872
arg = argv[++i];
if (arg == NULL)
873
fail("no filename after '-o'");
874
875
876
outfile = arg;
} // if
877
else if (strcmp(arg, "-I") == 0)
878
879
880
{
arg = argv[++i];
if (arg == NULL)
881
882
fail("no path after '-I'");
883
884
885
886
887
888
include_paths = (const char **) realloc(include_paths,
(include_path_count+1) * sizeof (char *));
include_paths[include_path_count] = arg;
include_path_count++;
} // if
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
else if (strncmp(arg, "-D", 2) == 0)
{
arg += 2;
char *ident = strdup(arg);
char *ptr = strchr(ident, '=');
const char *val = "";
if (ptr)
{
*ptr = '\0';
val = ptr+1;
} // if
defs = (MOJOSHADER_preprocessorDefine *) realloc(defs,
(defcount+1) * sizeof (MOJOSHADER_preprocessorDefine));
defs[defcount].identifier = ident;
defs[defcount].definition = val;
defcount++;
} // else if
else
{
if (infile != NULL)
911
fail("multiple input files specified");
912
913
914
915
infile = arg;
} // else
} // for
916
917
918
if (action == ACTION_UNKNOWN)
action = ACTION_ASSEMBLE;
919
920
921
922
923
924
if (action == ACTION_VERSION)
{
printf("mojoshader-compiler, changeset %s\n", MOJOSHADER_CHANGESET);
return 0;
} // if
925
if (infile == NULL)
926
fail("no input file specified");
927
928
929
FILE *io = fopen(infile, "rb");
if (io == NULL)
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
fail("failed to open input file");
fseek(io, 0, SEEK_END);
long fsize = ftell(io);
fseek(io, 0, SEEK_SET);
if (fsize == -1)
fsize = 1000000;
char *buf = (char *) malloc(fsize);
const int rc = fread(buf, 1, fsize, io);
fclose(io);
if (rc == EOF)
fail("failed to read input file");
FILE *outio = outfile ? fopen(outfile, "wb") : stdout;
if (outio == NULL)
fail("failed to open output file");
if (action == ACTION_PREPROCESS)
retval = (!preprocess(infile, buf, rc, outfile, defs, defcount, outio));
else if (action == ACTION_ASSEMBLE)
retval = (!assemble(infile, buf, rc, outfile, defs, defcount, outio));
952
953
else if (action == ACTION_AST)
retval = (!ast(infile, buf, rc, outfile, defs, defcount, outio));
954
955
else if (action == ACTION_COMPILE)
retval = (!compile(infile, buf, rc, outfile, defs, defcount, outio));
956
957
958
959
960
if ((retval != 0) && (outfile != NULL))
remove(outfile);
free(buf);
962
for (i = 0; i < defcount; i++)
963
free((void *) defs[i].identifier);
964
965
free(defs);
966
967
free(include_paths);
968
969
970
return retval;
} // main
971
// end of mojoshader-compiler.c ...