/
mojoshader-compiler.c
1102 lines (958 loc) · 35 KB
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
#ifdef _WIN32
#define snprintf _snprintf // !!! FIXME: not a safe replacement!
19
20
#endif
21
22
23
static const char **include_paths = NULL;
static unsigned int include_path_count = 0;
24
#define MOJOSHADER_DEBUG_MALLOC 0
25
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
49
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
// -1 means "unroll at compiler's discretion",
// -2 means user didn't specify the attribute.
switch (unroll)
{
case 0:
fprintf(io, "[loop] ");
break;
case -1:
fprintf(io, "[unroll] ");
break;
case -2:
/* no-op. */
break;
default:
assert(unroll > 0);
fprintf(io, "[unroll(%d)] ", unroll);
break;
} // case
77
78
} // print_unroll_attr
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
static void print_ast_datatype(FILE *io, const MOJOSHADER_astDataType *dt)
{
int i;
if (dt == NULL)
return;
switch (dt->type)
{
case MOJOSHADER_AST_DATATYPE_BOOL:
fprintf(io, "bool");
return;
case MOJOSHADER_AST_DATATYPE_INT:
fprintf(io, "int");
return;
case MOJOSHADER_AST_DATATYPE_UINT:
fprintf(io, "uint");
return;
case MOJOSHADER_AST_DATATYPE_FLOAT:
fprintf(io, "float");
return;
case MOJOSHADER_AST_DATATYPE_FLOAT_SNORM:
fprintf(io, "snorm float");
return;
case MOJOSHADER_AST_DATATYPE_FLOAT_UNORM:
fprintf(io, "unorm float");
return;
case MOJOSHADER_AST_DATATYPE_HALF:
fprintf(io, "half");
return;
case MOJOSHADER_AST_DATATYPE_DOUBLE:
fprintf(io, "double");
return;
case MOJOSHADER_AST_DATATYPE_STRING:
fprintf(io, "string");
return;
case MOJOSHADER_AST_DATATYPE_SAMPLER_1D:
fprintf(io, "sampler1D");
return;
case MOJOSHADER_AST_DATATYPE_SAMPLER_2D:
fprintf(io, "sampler2D");
return;
case MOJOSHADER_AST_DATATYPE_SAMPLER_3D:
fprintf(io, "sampler3D");
return;
case MOJOSHADER_AST_DATATYPE_SAMPLER_CUBE:
fprintf(io, "samplerCUBE");
return;
case MOJOSHADER_AST_DATATYPE_SAMPLER_STATE:
fprintf(io, "sampler_state");
return;
case MOJOSHADER_AST_DATATYPE_SAMPLER_COMPARISON_STATE:
fprintf(io, "SamplerComparisonState");
return;
case MOJOSHADER_AST_DATATYPE_STRUCT:
fprintf(io, "struct { ");
for (i = 0; i < dt->structure.member_count; i++)
{
print_ast_datatype(io, dt->structure.members[i].datatype);
fprintf(io, " %s; ", dt->structure.members[i].identifier);
} // for
fprintf(io, "}");
return;
case MOJOSHADER_AST_DATATYPE_ARRAY:
print_ast_datatype(io, dt->array.base);
if (dt->array.elements < 0)
fprintf(io, "[]");
else
fprintf(io, "[%d]", dt->array.elements);
return;
case MOJOSHADER_AST_DATATYPE_VECTOR:
fprintf(io, "vector<");
print_ast_datatype(io, dt->vector.base);
fprintf(io, ",%d>", dt->vector.elements);
return;
case MOJOSHADER_AST_DATATYPE_MATRIX:
fprintf(io, "matrix<");
print_ast_datatype(io, dt->matrix.base);
fprintf(io, ",%d,%d>", dt->matrix.rows, dt->matrix.columns);
return;
case MOJOSHADER_AST_DATATYPE_BUFFER:
fprintf(io, "buffer<");
print_ast_datatype(io, dt->buffer.base);
fprintf(io, ">");
return;
case MOJOSHADER_AST_DATATYPE_USER:
fprintf(io, "%s", dt->user.name);
return;
174
175
176
177
178
179
180
181
182
// this should only appear if we did semantic analysis on the AST,
// so we only print the return value here.
case MOJOSHADER_AST_DATATYPE_FUNCTION:
if (!dt->function.retval)
fprintf(io, "void");
else
print_ast_datatype(io, dt->function.retval);
return;
183
184
185
186
187
188
189
//case MOJOSHADER_AST_DATATYPE_NONE:
default:
assert(0 && "Unexpected datatype.");
return;
} // switch
} // print_ast_datatype
190
// !!! FIXME: this screws up on order of operations.
191
static void print_ast(FILE *io, const int substmt, const void *_ast)
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
{
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 { \
224
if (!substmt) { for (i = 0; i < indent; i++) fprintf(io, " "); } \
225
226
227
228
229
230
231
232
233
} 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:
234
235
fprintf(io, "%s", pre_unary[(typeint-MOJOSHADER_AST_OP_START_RANGE_UNARY)-1]);
print_ast(io, 0, ast->unary.operand);
236
237
238
239
break;
case MOJOSHADER_AST_OP_POSTINCREMENT:
case MOJOSHADER_AST_OP_POSTDECREMENT:
240
241
print_ast(io, 0, ast->unary.operand);
fprintf(io, "%s", post_unary[typeint-MOJOSHADER_AST_OP_POSTINCREMENT]);
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
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:
case MOJOSHADER_AST_OP_COMMA:
274
print_ast(io, 0, ast->binary.left);
275
276
if (ast->ast.type != MOJOSHADER_AST_OP_COMMA)
fprintf(io, " "); // no space before the comma.
277
fprintf(io, "%s ", binary[
278
(typeint - MOJOSHADER_AST_OP_START_RANGE_BINARY) - 1]);
279
print_ast(io, 0, ast->binary.right);
280
281
282
break;
case MOJOSHADER_AST_OP_DEREF_ARRAY:
283
284
285
286
print_ast(io, 0, ast->binary.left);
fprintf(io, "[");
print_ast(io, 0, ast->binary.right);
fprintf(io, "]");
287
288
289
break;
case MOJOSHADER_AST_OP_DEREF_STRUCT:
290
291
292
print_ast(io, 0, ast->derefstruct.identifier);
fprintf(io, ".");
fprintf(io, "%s", ast->derefstruct.member);
293
294
295
break;
case MOJOSHADER_AST_OP_CONDITIONAL:
296
297
298
299
300
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);
301
302
303
break;
case MOJOSHADER_AST_OP_IDENTIFIER:
304
fprintf(io, "%s", ast->identifier.identifier);
305
306
307
break;
case MOJOSHADER_AST_OP_INT_LITERAL:
308
fprintf(io, "%d", ast->intliteral.value);
309
310
311
312
313
314
315
break;
case MOJOSHADER_AST_OP_FLOAT_LITERAL:
{
const float f = ast->floatliteral.value;
const long long flr = (long long) f;
if (((float) flr) == f)
316
fprintf(io, "%lld.0", flr);
317
else
318
fprintf(io, "%.16g", f);
319
320
321
322
break;
} // case
case MOJOSHADER_AST_OP_STRING_LITERAL:
323
fprintf(io, "\"%s\"", ast->stringliteral.string);
324
325
326
break;
case MOJOSHADER_AST_OP_BOOLEAN_LITERAL:
327
fprintf(io, "%s", ast->boolliteral.value ? "true" : "false");
328
329
330
break;
case MOJOSHADER_AST_ARGUMENTS:
331
print_ast(io, 0, ast->arguments.argument);
332
333
if (ast->arguments.next != NULL)
{
334
335
fprintf(io, ", ");
print_ast(io, 0, ast->arguments.next);
336
337
338
339
} // if
break;
case MOJOSHADER_AST_OP_CALLFUNC:
340
341
342
343
print_ast(io, 0, ast->callfunc.identifier);
fprintf(io, "(");
print_ast(io, 0, ast->callfunc.args);
fprintf(io, ")");
344
345
346
break;
case MOJOSHADER_AST_OP_CONSTRUCTOR:
347
348
print_ast_datatype(io, ast->constructor.datatype);
fprintf(io, "(");
349
350
print_ast(io, 0, ast->constructor.args);
fprintf(io, ")");
351
352
353
break;
case MOJOSHADER_AST_OP_CAST:
354
355
356
fprintf(io, "(");
print_ast_datatype(io, ast->cast.datatype);
fprintf(io, ") (");
357
358
print_ast(io, 0, ast->cast.operand);
fprintf(io, ")");
359
360
361
362
break;
case MOJOSHADER_AST_STATEMENT_EXPRESSION:
DO_INDENT;
363
364
365
print_ast(io, 0, ast->exprstmt.expr); // !!! FIXME: This is named badly...
fprintf(io, ";%s", nl);
print_ast(io, 0, ast->exprstmt.next);
366
367
368
369
break;
case MOJOSHADER_AST_STATEMENT_IF:
DO_INDENT;
370
371
372
fprintf(io, "if (");
print_ast(io, 0, ast->ifstmt.expr);
fprintf(io, ")\n");
373
374
isblock = ast->ifstmt.statement->ast.type == MOJOSHADER_AST_STATEMENT_BLOCK;
if (!isblock) indent++;
375
print_ast(io, 0, ast->ifstmt.statement);
376
if (!isblock) indent--;
377
print_ast(io, 0, ast->ifstmt.next);
378
379
380
381
break;
case MOJOSHADER_AST_STATEMENT_TYPEDEF:
DO_INDENT;
382
383
384
print_ast(io, 1, ast->typedefstmt.type_info);
fprintf(io, "%s", nl);
print_ast(io, 0, ast->typedefstmt.next);
385
386
387
388
389
390
391
break;
case MOJOSHADER_AST_STATEMENT_SWITCH:
DO_INDENT;
switch ( ast->switchstmt.attributes )
{
case MOJOSHADER_AST_SWITCHATTR_NONE: break;
392
393
394
395
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;
396
397
} // switch
398
399
400
fprintf(io, "switch (");
print_ast(io, 0, ast->switchstmt.expr);
fprintf(io, ")\n");
401
DO_INDENT;
402
fprintf(io, "{\n");
403
indent++;
404
print_ast(io, 0, ast->switchstmt.cases);
405
indent--;
406
fprintf(io, "\n");
407
DO_INDENT;
408
409
fprintf(io, "}\n");
print_ast(io, 0, ast->switchstmt.next);
410
411
412
413
break;
case MOJOSHADER_AST_SWITCH_CASE:
DO_INDENT;
414
415
416
fprintf(io, "case ");
print_ast(io, 0, ast->cases.expr);
fprintf(io, ":\n");
417
418
isblock = ast->cases.statement->ast.type == MOJOSHADER_AST_STATEMENT_BLOCK;
if (!isblock) indent++;
419
print_ast(io, 0, ast->cases.statement);
420
if (!isblock) indent--;
421
print_ast(io, 0, ast->cases.next);
422
423
424
425
break;
case MOJOSHADER_AST_STATEMENT_STRUCT:
DO_INDENT;
426
427
428
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);
429
430
431
432
break;
case MOJOSHADER_AST_STATEMENT_VARDECL:
DO_INDENT;
433
434
435
print_ast(io, 1, ast->vardeclstmt.declaration);
fprintf(io, ";%s", nl);
print_ast(io, 0, ast->vardeclstmt.next);
436
437
438
439
break;
case MOJOSHADER_AST_STATEMENT_BLOCK:
DO_INDENT;
440
fprintf(io, "{\n");
441
indent++;
442
print_ast(io, 0, ast->blockstmt.statements);
443
444
indent--;
DO_INDENT;
445
446
fprintf(io, "}\n");
print_ast(io, 0, ast->blockstmt.next);
447
448
449
450
break;
case MOJOSHADER_AST_STATEMENT_FOR:
DO_INDENT;
451
452
453
print_unroll_attr(io, ast->forstmt.unroll);
fprintf(io, "for (");
print_ast(io, 1, ast->forstmt.var_decl);
454
print_ast(io, 1, ast->forstmt.initializer);
455
456
457
458
fprintf(io, "; ");
print_ast(io, 1, ast->forstmt.looptest);
fprintf(io, "; ");
print_ast(io, 1, ast->forstmt.counter);
459
460
fprintf(io, ")\n");
461
462
isblock = ast->forstmt.statement->ast.type == MOJOSHADER_AST_STATEMENT_BLOCK;
if (!isblock) indent++;
463
print_ast(io, 0, ast->forstmt.statement);
464
465
if (!isblock) indent--;
466
print_ast(io, 0, ast->forstmt.next);
467
468
469
470
break;
case MOJOSHADER_AST_STATEMENT_DO:
DO_INDENT;
471
472
print_unroll_attr(io, ast->dostmt.unroll);
fprintf(io, "do\n");
473
474
475
isblock = ast->dostmt.statement->ast.type == MOJOSHADER_AST_STATEMENT_BLOCK;
if (!isblock) indent++;
476
print_ast(io, 0, ast->dostmt.statement);
477
478
479
if (!isblock) indent--;
DO_INDENT;
480
481
482
fprintf(io, "while (");
print_ast(io, 0, ast->dostmt.expr);
fprintf(io, ");\n");
483
484
print_ast(io, 0, ast->dostmt.next);
485
486
487
488
break;
case MOJOSHADER_AST_STATEMENT_WHILE:
DO_INDENT;
489
490
491
492
print_unroll_attr(io, ast->whilestmt.unroll);
fprintf(io, "while (");
print_ast(io, 0, ast->whilestmt.expr);
fprintf(io, ")\n");
493
494
495
isblock = ast->whilestmt.statement->ast.type == MOJOSHADER_AST_STATEMENT_BLOCK;
if (!isblock) indent++;
496
print_ast(io, 0, ast->whilestmt.statement);
497
498
if (!isblock) indent--;
499
print_ast(io, 0, ast->whilestmt.next);
500
501
502
503
break;
case MOJOSHADER_AST_STATEMENT_RETURN:
DO_INDENT;
504
fprintf(io, "return");
505
506
if (ast->returnstmt.expr)
{
507
508
fprintf(io, " ");
print_ast(io, 0, ast->returnstmt.expr);
509
} // if
510
511
fprintf(io, ";%s", nl);
print_ast(io, 0, ast->returnstmt.next);
512
513
514
515
516
517
518
break;
case MOJOSHADER_AST_STATEMENT_EMPTY:
case MOJOSHADER_AST_STATEMENT_BREAK:
case MOJOSHADER_AST_STATEMENT_CONTINUE:
case MOJOSHADER_AST_STATEMENT_DISCARD:
DO_INDENT;
519
fprintf(io, "%s;%s",
520
521
simple_stmt[(typeint-MOJOSHADER_AST_STATEMENT_START_RANGE)-1],
nl);
522
print_ast(io, 0, ast->stmt.next);
523
524
525
526
break;
case MOJOSHADER_AST_COMPUNIT_FUNCTION:
DO_INDENT;
527
print_ast(io, 0, ast->funcunit.declaration);
528
if (ast->funcunit.definition == NULL)
529
fprintf(io, ";%s", nl);
530
531
else
{
532
533
534
fprintf(io, "%s", nl);
print_ast(io, 0, ast->funcunit.definition);
fprintf(io, "%s", nl);
535
} // else
536
print_ast(io, 0, ast->funcunit.next);
537
538
539
540
break;
case MOJOSHADER_AST_COMPUNIT_TYPEDEF:
DO_INDENT;
541
542
543
print_ast(io, 0, ast->typedefunit.type_info);
fprintf(io, "%s", nl);
print_ast(io, 0, ast->typedefunit.next);
544
545
546
547
break;
case MOJOSHADER_AST_COMPUNIT_STRUCT:
DO_INDENT;
548
549
550
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);
551
552
553
554
break;
case MOJOSHADER_AST_COMPUNIT_VARIABLE:
DO_INDENT;
555
556
print_ast(io, 1, ast->varunit.declaration);
fprintf(io, ";%s", nl);
557
558
559
if (ast->varunit.next &&
ast->varunit.next->ast.type!=MOJOSHADER_AST_COMPUNIT_VARIABLE)
{
560
fprintf(io, "%s", nl); // group vars together, and space out other things.
561
} // if
562
print_ast(io, 0, ast->varunit.next);
563
564
565
break;
case MOJOSHADER_AST_SCALAR_OR_ARRAY:
566
fprintf(io, "%s", ast->soa.identifier);
567
568
if (ast->soa.isarray)
{
569
570
571
fprintf(io, "[");
print_ast(io, 0, ast->soa.dimension);
fprintf(io, "]");
572
573
574
575
576
} // if
break;
case MOJOSHADER_AST_TYPEDEF:
DO_INDENT;
577
578
579
fprintf(io, "typedef %s", ast->typdef.isconst ? "const " : "");
print_ast_datatype(io, ast->typdef.datatype);
fprintf(io, " ");
580
581
print_ast(io, 0, ast->typdef.details);
fprintf(io, ";%s", nl);
582
583
584
break;
case MOJOSHADER_AST_FUNCTION_PARAMS:
585
fprintf(io, "%s", inpmod[(int) ast->params.input_modifier]);
586
587
print_ast_datatype(io, ast->params.datatype);
fprintf(io, " %s", ast->params.identifier);
588
if (ast->params.semantic)
589
590
fprintf(io, " : %s", ast->params.semantic);
fprintf(io, "%s", interpmod[(int) ast->params.interpolation_modifier]);
591
592
593
if (ast->params.initializer)
{
594
595
fprintf(io, " = ");
print_ast(io, 0, ast->params.initializer);
596
597
598
599
} // if
if (ast->params.next)
{
600
601
fprintf(io, ", ");
print_ast(io, 0, ast->params.next);
602
603
604
605
} // if
break;
case MOJOSHADER_AST_FUNCTION_SIGNATURE:
606
fprintf(io, "%s", fnstorage[(int) ast->funcsig.storage_class]);
607
608
609
610
611
if (ast->funcsig.datatype)
print_ast_datatype(io, ast->funcsig.datatype);
else
fprintf(io, "void");
fprintf(io, " %s(", ast->funcsig.identifier);
612
613
print_ast(io, 0, ast->funcsig.params);
fprintf(io, ")");
614
if (ast->funcsig.semantic)
615
fprintf(io, " : %s", ast->funcsig.semantic);
616
617
618
break;
case MOJOSHADER_AST_STRUCT_DECLARATION:
619
fprintf(io, "struct %s\n", ast->structdecl.name);
620
DO_INDENT;
621
fprintf(io, "{\n");
622
indent++;
623
print_ast(io, 0, ast->structdecl.members);
624
625
indent--;
DO_INDENT;
626
fprintf(io, "}");
627
628
629
630
break;
case MOJOSHADER_AST_STRUCT_MEMBER:
DO_INDENT;
631
fprintf(io, "%s", interpmod[(int)ast->structmembers.interpolation_mod]);
632
633
print_ast_datatype(io, ast->structmembers.datatype);
fprintf(io, " ");
634
print_ast(io, 0, ast->structmembers.details);
635
if (ast->structmembers.semantic)
636
637
638
fprintf(io, " : %s", ast->structmembers.semantic);
fprintf(io, ";%s", nl);
print_ast(io, 0, ast->structmembers.next);
639
640
641
642
643
break;
case MOJOSHADER_AST_VARIABLE_DECLARATION:
DO_INDENT;
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_EXTERN)
644
fprintf(io, "extern ");
645
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_NOINTERPOLATION)
646
fprintf(io, "nointerpolation ");
647
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_SHARED)
648
fprintf(io, "shared");
649
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_STATIC)
650
fprintf(io, "static ");
651
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_UNIFORM)
652
fprintf(io, "uniform ");
653
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_VOLATILE)
654
fprintf(io, "nointerpolation ");
655
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_CONST)
656
fprintf(io, "const ");
657
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_ROWMAJOR)
658
fprintf(io, "rowmajor ");
659
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_COLUMNMAJOR)
660
fprintf(io, "columnmajor ");
661
662
if (ast->vardecl.datatype)
663
print_ast_datatype(io, ast->vardecl.datatype);
664
else
665
666
667
print_ast(io, 0, ast->vardecl.anonymous_datatype);
fprintf(io, " ");
print_ast(io, 0, ast->vardecl.details);
668
if (ast->vardecl.semantic)
669
fprintf(io, " : %s", ast->vardecl.semantic);
670
671
if (ast->vardecl.annotations)
{
672
673
fprintf(io, " ");
print_ast(io, 0, ast->vardecl.annotations);
674
675
676
} // if
if (ast->vardecl.initializer != NULL)
{
677
678
fprintf(io, " = ");
print_ast(io, 0, ast->vardecl.initializer);
679
} // if
680
print_ast(io, 0, ast->vardecl.lowlevel);
681
682
if (ast->vardecl.next == NULL)
683
fprintf(io, "%s", nl);
684
685
686
else
{
const int attr = ast->vardecl.next->attributes;
687
fprintf(io, ", ");
688
ast->vardecl.next->attributes = 0;
689
print_ast(io, 1, ast->vardecl.next);
690
691
692
693
694
ast->vardecl.next->attributes = attr;
} // if
break;
case MOJOSHADER_AST_PACK_OFFSET:
695
fprintf(io, " : packoffset(%s%s%s)", ast->packoffset.ident1,
696
697
698
699
700
ast->packoffset.ident2 ? "." : "",
ast->packoffset.ident2 ? ast->packoffset.ident2 : "");
break;
case MOJOSHADER_AST_VARIABLE_LOWLEVEL:
701
print_ast(io, 0, ast->varlowlevel.packoffset);
702
if (ast->varlowlevel.register_name)
703
fprintf(io, " : register(%s)", ast->varlowlevel.register_name);
704
705
706
707
708
break;
case MOJOSHADER_AST_ANNOTATION:
{
const MOJOSHADER_astAnnotations *a = &ast->annotations;
709
fprintf(io, "<");
710
711
while (a)
{
712
713
fprintf(io, " ");
print_ast_datatype(io, a->datatype);
714
715
if (a->initializer != NULL)
{
716
717
fprintf(io, " = ");
print_ast(io, 0, a->initializer);
718
719
} // if
if (a->next)
720
fprintf(io, ",");
721
722
a = a->next;
} // while
723
fprintf(io, " >");
724
725
726
727
728
729
730
731
732
733
734
break;
} // case
default:
assert(0 && "unexpected type");
break;
} // switch
#undef DO_INDENT
} // print_ast
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
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
790
791
static void close_include(const char *data, MOJOSHADER_malloc m,
MOJOSHADER_free f, void *d)
792
793
794
795
796
{
f((void *) data, d);
} // close_include
797
static int preprocess(const char *fname, const char *buf, int len,
798
799
const char *outfile,
const MOJOSHADER_preprocessorDefine *defs,
800
unsigned int defcount, FILE *io)
801
802
803
804
{
const MOJOSHADER_preprocessData *pd;
int retval = 0;
805
806
pd = MOJOSHADER_preprocess(fname, buf, len, defs, defcount, open_include,
close_include, Malloc, Free, NULL);
807
808
809
810
811
812
if (pd->error_count > 0)
{
int i;
for (i = 0; i < pd->error_count; i++)
{
813
fprintf(stderr, "%s:%d: ERROR: %s\n",
814
pd->errors[i].filename ? pd->errors[i].filename : "???",
815
816
817
818
819
820
821
822
pd->errors[i].error_position,
pd->errors[i].error);
} // for
} // if
else
{
if (pd->output != NULL)
{
823
824
const int len = pd->output_len;
if ((len) && (fwrite(pd->output, len, 1, io) != 1))
825
printf(" ... fwrite('%s') failed.\n", outfile);
826
else if ((outfile != NULL) && (fclose(io) == EOF))
827
828
829
830
831
832
833
834
printf(" ... fclose('%s') failed.\n", outfile);
else
retval = 1;
} // if
} // else
MOJOSHADER_freePreprocessData(pd);
return retval;
835
} // preprocess
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
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++)
{
855
fprintf(stderr, "%s:%d: ERROR: %s\n",
856
857
858
859
860
861
862
863
864
pd->errors[i].filename ? pd->errors[i].filename : "???",
pd->errors[i].error_position,
pd->errors[i].error);
} // for
} // if
else
{
if (pd->output != NULL)
{
865
866
const int len = pd->output_len;
if ((len) && (fwrite(pd->output, len, 1, io) != 1))
867
868
869
870
871
872
873
874
875
876
877
878
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
879
880
881
882
static int ast(const char *fname, const char *buf, int len,
const char *outfile, const MOJOSHADER_preprocessorDefine *defs,
unsigned int defcount, FILE *io)
{
883
884
const MOJOSHADER_astData *ad;
int retval = 0;
885
886
ad = MOJOSHADER_parseAst(MOJOSHADER_SRC_PROFILE_HLSL_PS_1_1, // !!! FIXME
887
888
fname, buf, len, defs, defcount,
open_include, close_include, Malloc, Free, NULL);
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
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
909
MOJOSHADER_freeAstData(ad);
910
911
return retval;
912
} // ast
913
914
915
916
917
918
static int compile(const char *fname, const char *buf, int len,
const char *outfile,
const MOJOSHADER_preprocessorDefine *defs,
unsigned int defcount, FILE *io)
{
919
920
921
// !!! FIXME: write me.
//const MOJOSHADER_parseData *pd;
//int retval = 0;
922
923
924
MOJOSHADER_compile(MOJOSHADER_SRC_PROFILE_HLSL_PS_1_1, // !!! FIXME
fname, buf, len, defs, defcount,
925
926
927
928
open_include, close_include,
Malloc, Free, NULL);
return 1;
} // compile
929
930
931
932
typedef enum
{
ACTION_UNKNOWN,
933
ACTION_VERSION,
934
935
ACTION_PREPROCESS,
ACTION_ASSEMBLE,
936
ACTION_AST,
937
ACTION_COMPILE,
938
939
940
} Action;
941
942
int main(int argc, char **argv)
{
943
Action action = ACTION_UNKNOWN;
944
int retval = 1;
945
946
947
const char *infile = NULL;
const char *outfile = NULL;
int i;
948
949
950
951
MOJOSHADER_preprocessorDefine *defs = NULL;
unsigned int defcount = 0;
952
953
954
955
include_paths = (const char **) malloc(sizeof (char *));
include_paths[0] = ".";
include_path_count = 1;
956
// !!! FIXME: clean this up.
957
958
959
960
for (i = 1; i < argc; i++)
{
const char *arg = argv[i];
961
962
if (strcmp(arg, "-P") == 0)
{
963
if ((action != ACTION_UNKNOWN) && (action != ACTION_PREPROCESS))
964
965
966
967
968
969
fail("Multiple actions specified");
action = ACTION_PREPROCESS;
} // if
else if (strcmp(arg, "-A") == 0)
{
970
if ((action != ACTION_UNKNOWN) && (action != ACTION_ASSEMBLE))
971
972
973
974
fail("Multiple actions specified");
action = ACTION_ASSEMBLE;
} // else if
975
976
977
978
979
980
981
else if (strcmp(arg, "-T") == 0)
{
if ((action != ACTION_UNKNOWN) && (action != ACTION_AST))
fail("Multiple actions specified");
action = ACTION_AST;
} // else if
982
983
984
985
986
987
988
else if (strcmp(arg, "-C") == 0)
{
if ((action != ACTION_UNKNOWN) && (action != ACTION_COMPILE))
fail("Multiple actions specified");
action = ACTION_COMPILE;
} // else if
989
990
991
992
993
994
995
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
996
else if (strcmp(arg, "-o") == 0)
997
998
{
if (outfile != NULL)
999
fail("multiple output files specified");
1000