/
mojoshader-compiler.c
1106 lines (962 loc) · 35.2 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
455
if (ast->forstmt.initializer != NULL)
{
456
457
fprintf(io, " = ");
print_ast(io, 1, ast->forstmt.initializer);
458
} // if
459
460
461
462
fprintf(io, "; ");
print_ast(io, 1, ast->forstmt.looptest);
fprintf(io, "; ");
print_ast(io, 1, ast->forstmt.counter);
463
464
fprintf(io, ")\n");
465
466
isblock = ast->forstmt.statement->ast.type == MOJOSHADER_AST_STATEMENT_BLOCK;
if (!isblock) indent++;
467
print_ast(io, 0, ast->forstmt.statement);
468
469
if (!isblock) indent--;
470
print_ast(io, 0, ast->forstmt.next);
471
472
473
474
break;
case MOJOSHADER_AST_STATEMENT_DO:
DO_INDENT;
475
476
print_unroll_attr(io, ast->dostmt.unroll);
fprintf(io, "do\n");
477
478
479
isblock = ast->dostmt.statement->ast.type == MOJOSHADER_AST_STATEMENT_BLOCK;
if (!isblock) indent++;
480
print_ast(io, 0, ast->dostmt.statement);
481
482
483
if (!isblock) indent--;
DO_INDENT;
484
485
486
fprintf(io, "while (");
print_ast(io, 0, ast->dostmt.expr);
fprintf(io, ");\n");
487
488
print_ast(io, 0, ast->dostmt.next);
489
490
491
492
break;
case MOJOSHADER_AST_STATEMENT_WHILE:
DO_INDENT;
493
494
495
496
print_unroll_attr(io, ast->whilestmt.unroll);
fprintf(io, "while (");
print_ast(io, 0, ast->whilestmt.expr);
fprintf(io, ")\n");
497
498
499
isblock = ast->whilestmt.statement->ast.type == MOJOSHADER_AST_STATEMENT_BLOCK;
if (!isblock) indent++;
500
print_ast(io, 0, ast->whilestmt.statement);
501
502
if (!isblock) indent--;
503
print_ast(io, 0, ast->whilestmt.next);
504
505
506
507
break;
case MOJOSHADER_AST_STATEMENT_RETURN:
DO_INDENT;
508
fprintf(io, "return");
509
510
if (ast->returnstmt.expr)
{
511
512
fprintf(io, " ");
print_ast(io, 0, ast->returnstmt.expr);
513
} // if
514
515
fprintf(io, ";%s", nl);
print_ast(io, 0, ast->returnstmt.next);
516
517
518
519
520
521
522
break;
case MOJOSHADER_AST_STATEMENT_EMPTY:
case MOJOSHADER_AST_STATEMENT_BREAK:
case MOJOSHADER_AST_STATEMENT_CONTINUE:
case MOJOSHADER_AST_STATEMENT_DISCARD:
DO_INDENT;
523
fprintf(io, "%s;%s",
524
525
simple_stmt[(typeint-MOJOSHADER_AST_STATEMENT_START_RANGE)-1],
nl);
526
print_ast(io, 0, ast->stmt.next);
527
528
529
530
break;
case MOJOSHADER_AST_COMPUNIT_FUNCTION:
DO_INDENT;
531
print_ast(io, 0, ast->funcunit.declaration);
532
if (ast->funcunit.definition == NULL)
533
fprintf(io, ";%s", nl);
534
535
else
{
536
537
538
fprintf(io, "%s", nl);
print_ast(io, 0, ast->funcunit.definition);
fprintf(io, "%s", nl);
539
} // else
540
print_ast(io, 0, ast->funcunit.next);
541
542
543
544
break;
case MOJOSHADER_AST_COMPUNIT_TYPEDEF:
DO_INDENT;
545
546
547
print_ast(io, 0, ast->typedefunit.type_info);
fprintf(io, "%s", nl);
print_ast(io, 0, ast->typedefunit.next);
548
549
550
551
break;
case MOJOSHADER_AST_COMPUNIT_STRUCT:
DO_INDENT;
552
553
554
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);
555
556
557
558
break;
case MOJOSHADER_AST_COMPUNIT_VARIABLE:
DO_INDENT;
559
560
print_ast(io, 1, ast->varunit.declaration);
fprintf(io, ";%s", nl);
561
562
563
if (ast->varunit.next &&
ast->varunit.next->ast.type!=MOJOSHADER_AST_COMPUNIT_VARIABLE)
{
564
fprintf(io, "%s", nl); // group vars together, and space out other things.
565
} // if
566
print_ast(io, 0, ast->varunit.next);
567
568
569
break;
case MOJOSHADER_AST_SCALAR_OR_ARRAY:
570
fprintf(io, "%s", ast->soa.identifier);
571
572
if (ast->soa.isarray)
{
573
574
575
fprintf(io, "[");
print_ast(io, 0, ast->soa.dimension);
fprintf(io, "]");
576
577
578
579
580
} // if
break;
case MOJOSHADER_AST_TYPEDEF:
DO_INDENT;
581
582
583
fprintf(io, "typedef %s", ast->typdef.isconst ? "const " : "");
print_ast_datatype(io, ast->typdef.datatype);
fprintf(io, " ");
584
585
print_ast(io, 0, ast->typdef.details);
fprintf(io, ";%s", nl);
586
587
588
break;
case MOJOSHADER_AST_FUNCTION_PARAMS:
589
fprintf(io, "%s", inpmod[(int) ast->params.input_modifier]);
590
591
print_ast_datatype(io, ast->params.datatype);
fprintf(io, " %s", ast->params.identifier);
592
if (ast->params.semantic)
593
594
fprintf(io, " : %s", ast->params.semantic);
fprintf(io, "%s", interpmod[(int) ast->params.interpolation_modifier]);
595
596
597
if (ast->params.initializer)
{
598
599
fprintf(io, " = ");
print_ast(io, 0, ast->params.initializer);
600
601
602
603
} // if
if (ast->params.next)
{
604
605
fprintf(io, ", ");
print_ast(io, 0, ast->params.next);
606
607
608
609
} // if
break;
case MOJOSHADER_AST_FUNCTION_SIGNATURE:
610
fprintf(io, "%s", fnstorage[(int) ast->funcsig.storage_class]);
611
612
613
614
615
if (ast->funcsig.datatype)
print_ast_datatype(io, ast->funcsig.datatype);
else
fprintf(io, "void");
fprintf(io, " %s(", ast->funcsig.identifier);
616
617
print_ast(io, 0, ast->funcsig.params);
fprintf(io, ")");
618
if (ast->funcsig.semantic)
619
fprintf(io, " : %s", ast->funcsig.semantic);
620
621
622
break;
case MOJOSHADER_AST_STRUCT_DECLARATION:
623
fprintf(io, "struct %s\n", ast->structdecl.name);
624
DO_INDENT;
625
fprintf(io, "{\n");
626
indent++;
627
print_ast(io, 0, ast->structdecl.members);
628
629
indent--;
DO_INDENT;
630
fprintf(io, "}");
631
632
633
634
break;
case MOJOSHADER_AST_STRUCT_MEMBER:
DO_INDENT;
635
fprintf(io, "%s", interpmod[(int)ast->structmembers.interpolation_mod]);
636
637
print_ast_datatype(io, ast->structmembers.datatype);
fprintf(io, " ");
638
print_ast(io, 0, ast->structmembers.details);
639
if (ast->structmembers.semantic)
640
641
642
fprintf(io, " : %s", ast->structmembers.semantic);
fprintf(io, ";%s", nl);
print_ast(io, 0, ast->structmembers.next);
643
644
645
646
647
break;
case MOJOSHADER_AST_VARIABLE_DECLARATION:
DO_INDENT;
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_EXTERN)
648
fprintf(io, "extern ");
649
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_NOINTERPOLATION)
650
fprintf(io, "nointerpolation ");
651
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_SHARED)
652
fprintf(io, "shared");
653
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_STATIC)
654
fprintf(io, "static ");
655
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_UNIFORM)
656
fprintf(io, "uniform ");
657
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_VOLATILE)
658
fprintf(io, "nointerpolation ");
659
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_CONST)
660
fprintf(io, "const ");
661
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_ROWMAJOR)
662
fprintf(io, "rowmajor ");
663
if (ast->vardecl.attributes & MOJOSHADER_AST_VARATTR_COLUMNMAJOR)
664
fprintf(io, "columnmajor ");
665
666
if (ast->vardecl.datatype)
667
print_ast_datatype(io, ast->vardecl.datatype);
668
else
669
670
671
print_ast(io, 0, ast->vardecl.anonymous_datatype);
fprintf(io, " ");
print_ast(io, 0, ast->vardecl.details);
672
if (ast->vardecl.semantic)
673
fprintf(io, " : %s", ast->vardecl.semantic);
674
675
if (ast->vardecl.annotations)
{
676
677
fprintf(io, " ");
print_ast(io, 0, ast->vardecl.annotations);
678
679
680
} // if
if (ast->vardecl.initializer != NULL)
{
681
682
fprintf(io, " = ");
print_ast(io, 0, ast->vardecl.initializer);
683
} // if
684
print_ast(io, 0, ast->vardecl.lowlevel);
685
686
if (ast->vardecl.next == NULL)
687
fprintf(io, "%s", nl);
688
689
690
else
{
const int attr = ast->vardecl.next->attributes;
691
fprintf(io, ", ");
692
ast->vardecl.next->attributes = 0;
693
print_ast(io, 1, ast->vardecl.next);
694
695
696
697
698
ast->vardecl.next->attributes = attr;
} // if
break;
case MOJOSHADER_AST_PACK_OFFSET:
699
fprintf(io, " : packoffset(%s%s%s)", ast->packoffset.ident1,
700
701
702
703
704
ast->packoffset.ident2 ? "." : "",
ast->packoffset.ident2 ? ast->packoffset.ident2 : "");
break;
case MOJOSHADER_AST_VARIABLE_LOWLEVEL:
705
print_ast(io, 0, ast->varlowlevel.packoffset);
706
if (ast->varlowlevel.register_name)
707
fprintf(io, " : register(%s)", ast->varlowlevel.register_name);
708
709
710
711
712
break;
case MOJOSHADER_AST_ANNOTATION:
{
const MOJOSHADER_astAnnotations *a = &ast->annotations;
713
fprintf(io, "<");
714
715
while (a)
{
716
717
fprintf(io, " ");
print_ast_datatype(io, a->datatype);
718
719
if (a->initializer != NULL)
{
720
721
fprintf(io, " = ");
print_ast(io, 0, a->initializer);
722
723
} // if
if (a->next)
724
fprintf(io, ",");
725
726
a = a->next;
} // while
727
fprintf(io, " >");
728
729
730
731
732
733
734
735
736
737
738
break;
} // case
default:
assert(0 && "unexpected type");
break;
} // switch
#undef DO_INDENT
} // print_ast
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
790
791
792
793
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
794
795
static void close_include(const char *data, MOJOSHADER_malloc m,
MOJOSHADER_free f, void *d)
796
797
798
799
800
{
f((void *) data, d);
} // close_include
801
static int preprocess(const char *fname, const char *buf, int len,
802
803
const char *outfile,
const MOJOSHADER_preprocessorDefine *defs,
804
unsigned int defcount, FILE *io)
805
806
807
808
{
const MOJOSHADER_preprocessData *pd;
int retval = 0;
809
810
pd = MOJOSHADER_preprocess(fname, buf, len, defs, defcount, open_include,
close_include, Malloc, Free, NULL);
811
812
813
814
815
816
if (pd->error_count > 0)
{
int i;
for (i = 0; i < pd->error_count; i++)
{
817
fprintf(stderr, "%s:%d: ERROR: %s\n",
818
pd->errors[i].filename ? pd->errors[i].filename : "???",
819
820
821
822
823
824
825
826
pd->errors[i].error_position,
pd->errors[i].error);
} // for
} // if
else
{
if (pd->output != NULL)
{
827
828
const int len = pd->output_len;
if ((len) && (fwrite(pd->output, len, 1, io) != 1))
829
printf(" ... fwrite('%s') failed.\n", outfile);
830
else if ((outfile != NULL) && (fclose(io) == EOF))
831
832
833
834
835
836
837
838
printf(" ... fclose('%s') failed.\n", outfile);
else
retval = 1;
} // if
} // else
MOJOSHADER_freePreprocessData(pd);
return retval;
839
} // preprocess
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
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++)
{
859
fprintf(stderr, "%s:%d: ERROR: %s\n",
860
861
862
863
864
865
866
867
868
pd->errors[i].filename ? pd->errors[i].filename : "???",
pd->errors[i].error_position,
pd->errors[i].error);
} // for
} // if
else
{
if (pd->output != NULL)
{
869
870
const int len = pd->output_len;
if ((len) && (fwrite(pd->output, len, 1, io) != 1))
871
872
873
874
875
876
877
878
879
880
881
882
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
883
884
885
886
static int ast(const char *fname, const char *buf, int len,
const char *outfile, const MOJOSHADER_preprocessorDefine *defs,
unsigned int defcount, FILE *io)
{
887
888
const MOJOSHADER_astData *ad;
int retval = 0;
889
890
ad = MOJOSHADER_parseAst(MOJOSHADER_SRC_PROFILE_HLSL_PS_1_1, // !!! FIXME
891
892
fname, buf, len, defs, defcount,
open_include, close_include, Malloc, Free, NULL);
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
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
913
MOJOSHADER_freeAstData(ad);
914
915
return retval;
916
} // ast
917
918
919
920
921
922
static int compile(const char *fname, const char *buf, int len,
const char *outfile,
const MOJOSHADER_preprocessorDefine *defs,
unsigned int defcount, FILE *io)
{
923
924
925
// !!! FIXME: write me.
//const MOJOSHADER_parseData *pd;
//int retval = 0;
926
927
928
MOJOSHADER_compile(MOJOSHADER_SRC_PROFILE_HLSL_PS_1_1, // !!! FIXME
fname, buf, len, defs, defcount,
929
930
931
932
open_include, close_include,
Malloc, Free, NULL);
return 1;
} // compile
933
934
935
936
typedef enum
{
ACTION_UNKNOWN,
937
ACTION_VERSION,
938
939
ACTION_PREPROCESS,
ACTION_ASSEMBLE,
940
ACTION_AST,
941
ACTION_COMPILE,
942
943
944
} Action;
945
946
int main(int argc, char **argv)
{
947
Action action = ACTION_UNKNOWN;
948
int retval = 1;
949
950
951
const char *infile = NULL;
const char *outfile = NULL;
int i;
952
953
954
955
MOJOSHADER_preprocessorDefine *defs = NULL;
unsigned int defcount = 0;
956
957
958
959
include_paths = (const char **) malloc(sizeof (char *));
include_paths[0] = ".";
include_path_count = 1;
960
// !!! FIXME: clean this up.
961
962
963
964
for (i = 1; i < argc; i++)
{
const char *arg = argv[i];
965
966
if (strcmp(arg, "-P") == 0)
{
967
if ((action != ACTION_UNKNOWN) && (action != ACTION_PREPROCESS))
968
969
970
971
972
973
fail("Multiple actions specified");
action = ACTION_PREPROCESS;
} // if
else if (strcmp(arg, "-A") == 0)
{
974
if ((action != ACTION_UNKNOWN) && (action != ACTION_ASSEMBLE))
975
976
977
978
fail("Multiple actions specified");
action = ACTION_ASSEMBLE;
} // else if
979
980
981
982
983
984
985
else if (strcmp(arg, "-T") == 0)
{
if ((action != ACTION_UNKNOWN) && (action != ACTION_AST))
fail("Multiple actions specified");
action = ACTION_AST;
} // else if
986
987
988
989
990
991
992
else if (strcmp(arg, "-C") == 0)
{
if ((action != ACTION_UNKNOWN) && (action != ACTION_COMPILE))
fail("Multiple actions specified");
action = ACTION_COMPILE;
} // else if
993
994
995
996
997
998
999
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
1000
else if (strcmp(arg, "-o") == 0)