/
mojoshader_preprocessor.c
2403 lines (2018 loc) · 67.8 KB
1
2
3
4
5
6
7
8
9
10
11
12
/**
* 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.
*/
#define __MOJOSHADER_INTERNAL__ 1
#include "mojoshader_internal.h"
13
14
15
16
17
18
#if DEBUG_PREPROCESSOR
#define print_debug_token(token, len, val) \
MOJOSHADER_print_debug_token("PREPROCESSOR", token, len, val)
#else
#define print_debug_token(token, len, val)
#endif
19
20
#if DEBUG_LEXER
21
static Token debug_preprocessor_lexer(IncludeState *s)
22
{
23
const Token retval = preprocessor_lexer(s);
24
MOJOSHADER_print_debug_token("LEXER", s->token, s->tokenlen, retval);
25
return retval;
26
27
} // debug_preprocessor_lexer
#define preprocessor_lexer(s) debug_preprocessor_lexer(s)
28
29
#endif
30
31
32
#if DEBUG_TOKENIZER
static void print_debug_lexing_position(IncludeState *s)
{
33
34
if (s != NULL)
printf("NOW LEXING %s:%d ...\n", s->filename, s->line);
35
36
37
38
39
} // print_debug_lexing_position
#else
#define print_debug_lexing_position(s)
#endif
40
41
42
43
typedef struct Context
{
int isfail;
int out_of_memory;
44
char failstr[256];
45
int recursion_count;
46
int asm_comments;
47
int parsing_pragma;
48
Conditional *conditional_pool;
49
IncludeState *include_stack;
50
IncludeState *include_pool;
51
52
Define *define_hashtable[256];
Define *define_pool;
53
54
Define *file_macro;
Define *line_macro;
55
StringCache *filename_cache;
56
57
58
59
60
61
62
MOJOSHADER_includeOpen open_callback;
MOJOSHADER_includeClose close_callback;
MOJOSHADER_malloc malloc;
MOJOSHADER_free free;
void *malloc_data;
} Context;
63
64
65
66
67
68
// Microsoft's preprocessor has some quirks. In some ways, it doesn't work
// like you'd expect a C preprocessor to function.
#ifndef MATCH_MICROSOFT_PREPROCESSOR
#define MATCH_MICROSOFT_PREPROCESSOR 1
#endif
69
70
71
72
73
// Convenience functions for allocators...
static inline void out_of_memory(Context *ctx)
{
74
ctx->out_of_memory = 1;
75
76
77
78
79
80
81
82
83
84
85
86
} // out_of_memory
static inline void *Malloc(Context *ctx, const size_t len)
{
void *retval = ctx->malloc((int) len, ctx->malloc_data);
if (retval == NULL)
out_of_memory(ctx);
return retval;
} // Malloc
static inline void Free(Context *ctx, void *ptr)
{
87
ctx->free(ptr, ctx->malloc_data);
88
89
} // Free
90
91
92
93
94
95
96
97
98
99
static void *MallocBridge(int bytes, void *data)
{
return Malloc((Context *) data, (size_t) bytes);
} // MallocBridge
static void FreeBridge(void *ptr, void *data)
{
Free((Context *) data, ptr);
} // FreeBridge
100
101
102
103
104
105
106
107
108
109
110
111
112
113
static inline char *StrDup(Context *ctx, const char *str)
{
char *retval = (char *) Malloc(ctx, strlen(str) + 1);
if (retval != NULL)
strcpy(retval, str);
return retval;
} // StrDup
static void failf(Context *ctx, const char *fmt, ...) ISPRINTF(2,3);
static void failf(Context *ctx, const char *fmt, ...)
{
ctx->isfail = 1;
va_list ap;
va_start(ap, fmt);
114
vsnprintf(ctx->failstr, sizeof (ctx->failstr), fmt, ap);
115
116
117
118
119
120
121
122
123
va_end(ap);
} // failf
static inline void fail(Context *ctx, const char *reason)
{
failf(ctx, "%s", reason);
} // fail
124
125
126
127
128
129
130
131
132
133
134
#if DEBUG_TOKENIZER
void MOJOSHADER_print_debug_token(const char *subsystem, const char *token,
const unsigned int tokenlen,
const Token tokenval)
{
printf("%s TOKEN: \"", subsystem);
unsigned int i;
for (i = 0; i < tokenlen; i++)
{
if (token[i] == '\n')
printf("\\n");
135
136
else if (token[i] == '\\')
printf("\\\\");
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
else
printf("%c", token[i]);
} // for
printf("\" (");
switch (tokenval)
{
#define TOKENCASE(x) case x: printf("%s", #x); break
TOKENCASE(TOKEN_UNKNOWN);
TOKENCASE(TOKEN_IDENTIFIER);
TOKENCASE(TOKEN_INT_LITERAL);
TOKENCASE(TOKEN_FLOAT_LITERAL);
TOKENCASE(TOKEN_STRING_LITERAL);
TOKENCASE(TOKEN_ADDASSIGN);
TOKENCASE(TOKEN_SUBASSIGN);
TOKENCASE(TOKEN_MULTASSIGN);
TOKENCASE(TOKEN_DIVASSIGN);
TOKENCASE(TOKEN_MODASSIGN);
TOKENCASE(TOKEN_XORASSIGN);
TOKENCASE(TOKEN_ANDASSIGN);
TOKENCASE(TOKEN_ORASSIGN);
TOKENCASE(TOKEN_INCREMENT);
TOKENCASE(TOKEN_DECREMENT);
TOKENCASE(TOKEN_RSHIFT);
TOKENCASE(TOKEN_LSHIFT);
TOKENCASE(TOKEN_ANDAND);
TOKENCASE(TOKEN_OROR);
TOKENCASE(TOKEN_LEQ);
TOKENCASE(TOKEN_GEQ);
TOKENCASE(TOKEN_EQL);
TOKENCASE(TOKEN_NEQ);
167
TOKENCASE(TOKEN_HASH);
168
169
170
171
172
173
174
175
176
177
178
179
TOKENCASE(TOKEN_HASHHASH);
TOKENCASE(TOKEN_PP_INCLUDE);
TOKENCASE(TOKEN_PP_LINE);
TOKENCASE(TOKEN_PP_DEFINE);
TOKENCASE(TOKEN_PP_UNDEF);
TOKENCASE(TOKEN_PP_IF);
TOKENCASE(TOKEN_PP_IFDEF);
TOKENCASE(TOKEN_PP_IFNDEF);
TOKENCASE(TOKEN_PP_ELSE);
TOKENCASE(TOKEN_PP_ELIF);
TOKENCASE(TOKEN_PP_ENDIF);
TOKENCASE(TOKEN_PP_ERROR);
180
TOKENCASE(TOKEN_PP_PRAGMA);
181
182
TOKENCASE(TOKEN_INCOMPLETE_COMMENT);
TOKENCASE(TOKEN_BAD_CHARS);
183
184
TOKENCASE(TOKEN_SINGLE_COMMENT);
TOKENCASE(TOKEN_MULTI_COMMENT);
185
TOKENCASE(TOKEN_EOI);
186
TOKENCASE(TOKEN_PREPROCESSING_ERROR);
187
188
189
190
191
192
#undef TOKENCASE
case ((Token) '\n'):
printf("'\\n'");
break;
193
194
195
196
case ((Token) '\\'):
printf("'\\\\'");
break;
197
198
199
200
201
202
203
204
205
206
default:
assert(((int)tokenval) < 256);
printf("'%c'", (char) tokenval);
break;
} // switch
printf(")\n");
} // MOJOSHADER_print_debug_token
#endif
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
#if !MOJOSHADER_FORCE_INCLUDE_CALLBACKS
// !!! FIXME: most of these _MSC_VER should probably be _WINDOWS?
#ifdef _MSC_VER
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h> // GL headers need this for WINGDIAPI definition.
#else
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#endif
int MOJOSHADER_internal_include_open(MOJOSHADER_includeType inctype,
const char *fname, const char *parent,
const char **outdata,
unsigned int *outbytes,
MOJOSHADER_malloc m, MOJOSHADER_free f,
void *d)
{
#ifdef _MSC_VER
228
229
230
231
232
233
234
235
236
237
238
239
240
241
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
WCHAR wpath[MAX_PATH];
if (!MultiByteToWideChar(CP_UTF8, 0, fname, -1, wpath, MAX_PATH))
return 0;
const DWORD share = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
const HANDLE handle = CreateFileW(wpath, FILE_GENERIC_READ, share,
NULL, OPEN_EXISTING, NULL, NULL);
if (handle == INVALID_HANDLE_VALUE)
return 0;
const DWORD fileSize = GetFileSize(handle, NULL);
if (fileSize == INVALID_FILE_SIZE)
{
CloseHandle(handle);
return 0;
} // if
char *data = (char *) m(fileSize, d);
if (data == NULL)
{
CloseHandle(handle);
return 0;
} // if
DWORD readLength = 0;
if (!ReadFile(handle, data, fileSize, &readLength, NULL))
{
CloseHandle(handle);
f(data, d);
return 0;
} // if
CloseHandle(handle);
if (readLength != fileSize)
{
f(data, d);
return 0;
} // if
*outdata = data;
*outbytes = fileSize;
return 1;
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
#else
struct stat statbuf;
if (stat(fname, &statbuf) == -1)
return 0;
char *data = (char *) m(statbuf.st_size, d);
if (data == NULL)
return 0;
const int fd = open(fname, O_RDONLY);
if (fd == -1)
{
f(data, d);
return 0;
} // if
if (read(fd, data, statbuf.st_size) != statbuf.st_size)
{
f(data, d);
close(fd);
return 0;
} // if
close(fd);
*outdata = data;
*outbytes = (unsigned int) statbuf.st_size;
return 1;
#endif
} // MOJOSHADER_internal_include_open
void MOJOSHADER_internal_include_close(const char *data, MOJOSHADER_malloc m,
MOJOSHADER_free f, void *d)
{
f((void *) data, d);
} // MOJOSHADER_internal_include_close
#endif // !MOJOSHADER_FORCE_INCLUDE_CALLBACKS
305
// !!! FIXME: maybe use these pool magic elsewhere?
306
// !!! FIXME: maybe just get rid of this? (maybe the fragmentation isn't a big deal?)
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
// Pool stuff...
// ugh, I hate this macro salsa.
#define FREE_POOL(type, poolname) \
static void free_##poolname##_pool(Context *ctx) { \
type *item = ctx->poolname##_pool; \
while (item != NULL) { \
type *next = item->next; \
Free(ctx, item); \
item = next; \
} \
}
#define GET_POOL(type, poolname) \
static type *get_##poolname(Context *ctx) { \
type *retval = ctx->poolname##_pool; \
if (retval != NULL) \
ctx->poolname##_pool = retval->next; \
else \
retval = (type *) Malloc(ctx, sizeof (type)); \
if (retval != NULL) \
memset(retval, '\0', sizeof (type)); \
return retval; \
}
#define PUT_POOL(type, poolname) \
static void put_##poolname(Context *ctx, type *item) { \
item->next = ctx->poolname##_pool; \
335
ctx->poolname##_pool = item; \
336
337
338
339
340
341
342
343
344
}
#define IMPLEMENT_POOL(type, poolname) \
FREE_POOL(type, poolname) \
GET_POOL(type, poolname) \
PUT_POOL(type, poolname)
IMPLEMENT_POOL(Conditional, conditional)
IMPLEMENT_POOL(IncludeState, include)
345
IMPLEMENT_POOL(Define, define)
346
347
348
349
// Preprocessor define hashtable stuff...
350
351
// !!! FIXME: why isn't this using mojoshader_common.c's code?
352
353
// this is djb's xor hashing function.
static inline uint32 hash_string_djbxor(const char *sym)
354
{
355
register uint32 hash = 5381;
356
while (*sym)
357
358
359
360
361
362
363
hash = ((hash << 5) + hash) ^ *(sym++);
return hash;
} // hash_string_djbxor
static inline uint8 hash_define(const char *sym)
{
return (uint8) hash_string_djbxor(sym);
364
365
366
} // hash_define
367
static int add_define(Context *ctx, const char *sym, const char *val,
368
char **parameters, int paramcount)
369
{
370
const uint8 hash = hash_define(sym);
371
Define *bucket = ctx->define_hashtable[hash];
372
373
while (bucket)
{
374
if (strcmp(bucket->identifier, sym) == 0)
375
{
376
377
failf(ctx, "'%s' already defined", sym); // !!! FIXME: warning?
// !!! FIXME: gcc reports the location of previous #define here.
378
379
380
381
382
return 0;
} // if
bucket = bucket->next;
} // while
383
bucket = get_define(ctx);
384
385
386
if (bucket == NULL)
return 0;
387
bucket->definition = val;
388
bucket->original = NULL;
389
390
391
bucket->identifier = sym;
bucket->parameters = (const char **) parameters;
bucket->paramcount = paramcount;
392
393
394
395
396
397
bucket->next = ctx->define_hashtable[hash];
ctx->define_hashtable[hash] = bucket;
return 1;
} // add_define
398
399
static void free_define(Context *ctx, Define *def)
{
400
401
402
403
404
405
406
407
408
409
410
if (def != NULL)
{
int i;
for (i = 0; i < def->paramcount; i++)
Free(ctx, (void *) def->parameters[i]);
Free(ctx, (void *) def->parameters);
Free(ctx, (void *) def->identifier);
Free(ctx, (void *) def->definition);
Free(ctx, (void *) def->original);
put_define(ctx, def);
} // if
411
412
413
} // free_define
414
415
static int remove_define(Context *ctx, const char *sym)
{
416
const uint8 hash = hash_define(sym);
417
418
Define *bucket = ctx->define_hashtable[hash];
Define *prev = NULL;
419
420
while (bucket)
{
421
if (strcmp(bucket->identifier, sym) == 0)
422
423
424
425
426
{
if (prev == NULL)
ctx->define_hashtable[hash] = bucket->next;
else
prev->next = bucket->next;
427
free_define(ctx, bucket);
428
429
430
431
432
433
434
435
436
437
return 1;
} // if
prev = bucket;
bucket = bucket->next;
} // while
return 0;
} // remove_define
438
static const Define *find_define(Context *ctx, const char *sym)
439
{
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
const uint8 hash = hash_define(sym);
Define *bucket = ctx->define_hashtable[hash];
while (bucket)
{
if (strcmp(bucket->identifier, sym) == 0)
return bucket;
bucket = bucket->next;
} // while
const uint8 filestrhash = 67;
assert(hash_define("__FILE__") == filestrhash);
const uint8 linestrhash = 75;
assert(hash_define("__LINE__") == linestrhash);
if ( (hash == filestrhash) && (ctx->file_macro) && (strcmp(sym, "__FILE__") == 0) )
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
{
Free(ctx, (char *) ctx->file_macro->definition);
const IncludeState *state = ctx->include_stack;
const char *fname = state ? state->filename : "";
const size_t len = strlen(fname) + 2;
char *str = (char *) Malloc(ctx, len);
if (!str)
return NULL;
str[0] = '\"';
memcpy(str + 1, fname, len - 2);
str[len - 1] = '\"';
ctx->file_macro->definition = str;
return ctx->file_macro;
} // if
471
else if ( (hash == linestrhash) && (ctx->line_macro) && (strcmp(sym, "__LINE__") == 0) )
472
473
474
475
476
477
478
479
480
{
Free(ctx, (char *) ctx->line_macro->definition);
const IncludeState *state = ctx->include_stack;
const size_t bufsize = 32;
char *str = (char *) Malloc(ctx, bufsize);
if (!str)
return 0;
const size_t len = snprintf(str, bufsize, "%u", state->line);
481
assert(len < bufsize); (void) len;
482
483
484
485
ctx->line_macro->definition = str;
return ctx->line_macro;
} // else
486
487
488
489
return NULL;
} // find_define
490
491
492
493
494
495
496
497
498
499
500
static const Define *find_define_by_token(Context *ctx)
{
IncludeState *state = ctx->include_stack;
assert(state->tokenval == TOKEN_IDENTIFIER);
char *sym = (char *) alloca(state->tokenlen+1);
memcpy(sym, state->token, state->tokenlen);
sym[state->tokenlen] = '\0';
return find_define(ctx, sym);
} // find_define_by_token
501
502
static const Define *find_macro_arg(const IncludeState *state,
const Define *defines)
503
504
505
506
507
508
{
const Define *def = NULL;
char *sym = (char *) alloca(state->tokenlen + 1);
memcpy(sym, state->token, state->tokenlen);
sym[state->tokenlen] = '\0';
509
for (def = defines; def != NULL; def = def->next)
510
{
511
assert(def->parameters == NULL); // args can't have args!
512
513
514
515
516
517
518
519
520
assert(def->paramcount == 0); // args can't have args!
if (strcmp(def->identifier, sym) == 0)
break;
} // while
return def;
} // find_macro_arg
521
static void put_all_defines(Context *ctx)
522
{
523
size_t i;
524
525
for (i = 0; i < STATICARRAYLEN(ctx->define_hashtable); i++)
{
526
Define *bucket = ctx->define_hashtable[i];
527
528
529
ctx->define_hashtable[i] = NULL;
while (bucket)
{
530
Define *next = bucket->next;
531
free_define(ctx, bucket);
532
533
534
bucket = next;
} // while
} // for
535
} // put_all_defines
536
537
538
static int push_source(Context *ctx, const char *fname, const char *source,
539
unsigned int srclen, unsigned int linenum,
540
MOJOSHADER_includeClose close_callback)
541
{
542
IncludeState *state = get_include(ctx);
543
544
545
if (state == NULL)
return 0;
546
if (fname != NULL)
547
{
548
state->filename = stringcache(ctx->filename_cache, fname);
549
550
if (state->filename == NULL)
{
551
put_include(ctx, state);
552
553
return 0;
} // if
554
555
} // if
556
state->close_callback = close_callback;
557
558
559
state->source_base = source;
state->source = source;
state->token = source;
560
state->tokenval = ((Token) '\n');
561
state->orig_length = srclen;
562
state->bytes_left = srclen;
563
state->line = linenum;
564
state->next = ctx->include_stack;
565
state->asm_comments = ctx->asm_comments;
566
567
568
print_debug_lexing_position(state);
569
570
571
572
573
574
575
576
577
ctx->include_stack = state;
return 1;
} // push_source
static void pop_source(Context *ctx)
{
IncludeState *state = ctx->include_stack;
578
assert(state != NULL); // more pops than pushes!
579
580
581
if (state == NULL)
return;
582
if (state->close_callback)
583
{
584
585
state->close_callback(state->source_base, ctx->malloc,
ctx->free, ctx->malloc_data);
586
587
} // if
588
589
// state->filename is a pointer to the filename cache; don't free it here!
590
591
592
593
594
595
596
Conditional *cond = state->conditional_stack;
while (cond)
{
Conditional *next = cond->next;
put_conditional(ctx, cond);
cond = next;
} // while
597
598
ctx->include_stack = state->next;
599
600
601
print_debug_lexing_position(ctx->include_stack);
602
put_include(ctx, state);
603
604
605
} // pop_source
606
607
608
609
610
611
612
static void close_define_include(const char *data, MOJOSHADER_malloc m,
MOJOSHADER_free f, void *d)
{
f((void *) data, d);
} // close_define_include
613
614
615
616
Preprocessor *preprocessor_start(const char *fname, const char *source,
unsigned int sourcelen,
MOJOSHADER_includeOpen open_callback,
MOJOSHADER_includeClose close_callback,
617
const MOJOSHADER_preprocessorDefine *defines,
618
unsigned int define_count, int asm_comments,
619
620
621
MOJOSHADER_malloc m, MOJOSHADER_free f, void *d)
{
int okay = 1;
622
unsigned int i = 0;
623
624
625
626
627
628
629
// the preprocessor is internal-only, so we verify all these are != NULL.
assert(m != NULL);
assert(f != NULL);
Context *ctx = (Context *) m(sizeof (Context), d);
if (ctx == NULL)
630
return NULL;
631
632
633
634
635
636
637
memset(ctx, '\0', sizeof (Context));
ctx->malloc = m;
ctx->free = f;
ctx->malloc_data = d;
ctx->open_callback = open_callback;
ctx->close_callback = close_callback;
638
ctx->asm_comments = asm_comments;
639
640
ctx->filename_cache = stringcache_create(MallocBridge, FreeBridge, ctx);
641
642
643
644
645
646
647
648
649
650
651
okay = ((okay) && (ctx->filename_cache != NULL));
ctx->file_macro = get_define(ctx);
okay = ((okay) && (ctx->file_macro != NULL));
if ((okay) && (ctx->file_macro))
okay = ((ctx->file_macro->identifier = StrDup(ctx, "__FILE__")) != 0);
ctx->line_macro = get_define(ctx);
okay = ((okay) && (ctx->line_macro != NULL));
if ((okay) && (ctx->line_macro))
okay = ((ctx->line_macro->identifier = StrDup(ctx, "__LINE__")) != 0);
652
653
654
655
// let the usual preprocessor parser sort these out.
char *define_include = NULL;
unsigned int define_include_len = 0;
656
if ((okay) && (define_count > 0))
657
{
658
659
660
Buffer *predefbuf = buffer_create(256, MallocBridge, FreeBridge, ctx);
okay = okay && (predefbuf != NULL);
for (i = 0; okay && (i < define_count); i++)
661
{
662
663
okay = okay && buffer_append_fmt(predefbuf, "#define %s %s\n",
defines[i].identifier, defines[i].definition);
664
665
} // for
666
667
define_include_len = buffer_size(predefbuf);
if (define_include_len > 0)
668
{
669
670
671
672
define_include = buffer_flatten(predefbuf);
okay = okay && (define_include != NULL);
} // if
buffer_destroy(predefbuf);
673
} // if
674
675
if ((okay) && (!push_source(ctx,fname,source,sourcelen,1,NULL)))
676
677
okay = 0;
678
if ((okay) && (define_include_len > 0))
679
{
680
assert(define_include != NULL);
681
okay = push_source(ctx, "<predefined macros>", define_include,
682
define_include_len, 1, close_define_include);
683
684
} // if
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
if (!okay)
{
preprocessor_end((Preprocessor *) ctx);
return NULL;
} // if
return (Preprocessor *) ctx;
} // preprocessor_start
void preprocessor_end(Preprocessor *_ctx)
{
Context *ctx = (Context *) _ctx;
if (ctx == NULL)
return;
while (ctx->include_stack != NULL)
pop_source(ctx);
704
705
put_all_defines(ctx);
706
707
708
if (ctx->filename_cache != NULL)
stringcache_destroy(ctx->filename_cache);
709
710
free_define(ctx, ctx->file_macro);
free_define(ctx, ctx->line_macro);
711
free_define_pool(ctx);
712
free_conditional_pool(ctx);
713
free_include_pool(ctx);
714
715
716
717
718
719
720
721
722
723
724
725
Free(ctx, ctx);
} // preprocessor_end
int preprocessor_outofmemory(Preprocessor *_ctx)
{
Context *ctx = (Context *) _ctx;
return ctx->out_of_memory;
} // preprocessor_outofmemory
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
static inline void pushback(IncludeState *state)
{
#if DEBUG_PREPROCESSOR
printf("PREPROCESSOR PUSHBACK\n");
#endif
assert(!state->pushedback);
state->pushedback = 1;
} // pushback
static Token lexer(IncludeState *state)
{
if (!state->pushedback)
return preprocessor_lexer(state);
state->pushedback = 0;
return state->tokenval;
} // lexer
745
// !!! FIXME: parsing fails on preprocessor directives should skip rest of line.
746
747
static int require_newline(IncludeState *state)
{
748
749
const Token token = lexer(state);
pushback(state); // rewind no matter what.
750
return ( (token == TOKEN_INCOMPLETE_COMMENT) || // call it an eol.
751
(token == ((Token) '\n')) || (token == TOKEN_EOI) );
752
753
} // require_newline
754
// !!! FIXME: didn't we implement this by hand elsewhere?
755
756
757
758
759
760
761
762
763
764
static int token_to_int(IncludeState *state)
{
assert(state->tokenval == TOKEN_INT_LITERAL);
char *buf = (char *) alloca(state->tokenlen+1);
memcpy(buf, state->token, state->tokenlen);
buf[state->tokenlen] = '\0';
return atoi(buf);
} // token_to_int
765
766
767
static void handle_pp_include(Context *ctx)
{
IncludeState *state = ctx->include_stack;
768
Token token = lexer(state);
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
794
795
796
797
798
799
800
801
802
803
804
805
806
807
MOJOSHADER_includeType incltype;
char *filename = NULL;
int bogus = 0;
if (token == TOKEN_STRING_LITERAL)
incltype = MOJOSHADER_INCLUDETYPE_LOCAL;
else if (token == ((Token) '<'))
{
incltype = MOJOSHADER_INCLUDETYPE_SYSTEM;
// can't use lexer, since every byte between the < > pair is
// considered part of the filename. :/
while (!bogus)
{
if ( !(bogus = (state->bytes_left == 0)) )
{
const char ch = *state->source;
if ( !(bogus = ((ch == '\r') || (ch == '\n'))) )
{
state->source++;
state->bytes_left--;
if (ch == '>')
break;
} // if
} // if
} // while
} // else if
else
{
bogus = 1;
} // else
if (!bogus)
{
state->token++; // skip '<' or '\"'...
const unsigned int len = ((unsigned int) (state->source-state->token));
filename = (char *) alloca(len);
memcpy(filename, state->token, len-1);
filename[len-1] = '\0';
808
bogus = !require_newline(state);
809
810
811
812
813
814
815
816
817
818
} // if
if (bogus)
{
fail(ctx, "Invalid #include directive");
return;
} // else
const char *newdata = NULL;
unsigned int newbytes = 0;
819
820
821
822
823
824
if ((ctx->open_callback == NULL) || (ctx->close_callback == NULL))
{
fail(ctx, "Saw #include, but no include callbacks defined");
return;
} // if
825
826
827
828
829
830
831
832
if (!ctx->open_callback(incltype, filename, state->source_base,
&newdata, &newbytes, ctx->malloc,
ctx->free, ctx->malloc_data))
{
fail(ctx, "Include callback failed"); // !!! FIXME: better error
return;
} // if
833
MOJOSHADER_includeClose callback = ctx->close_callback;
834
if (!push_source(ctx, filename, newdata, newbytes, 1, callback))
835
836
837
838
839
840
841
{
assert(ctx->out_of_memory);
ctx->close_callback(newdata, ctx->malloc, ctx->free, ctx->malloc_data);
} // if
} // handle_pp_include
842
843
844
845
846
847
848
static void handle_pp_line(Context *ctx)
{
IncludeState *state = ctx->include_stack;
char *filename = NULL;
int linenum = 0;
int bogus = 0;
849
if (lexer(state) != TOKEN_INT_LITERAL)
850
851
bogus = 1;
else
852
linenum = token_to_int(state);
853
854
if (!bogus)
855
856
857
858
859
860
861
862
863
{
Token t = lexer(state);
if (t == ((Token) '\n'))
{
state->line = linenum;
return;
}
bogus = (t != TOKEN_STRING_LITERAL);
}
864
865
866
867
if (!bogus)
{
state->token++; // skip '\"'...
868
869
870
filename = (char *) alloca(state->tokenlen);
memcpy(filename, state->token, state->tokenlen-1);
filename[state->tokenlen-1] = '\0';
871
872
873
874
875
876
877
878
879
bogus = !require_newline(state);
} // if
if (bogus)
{
fail(ctx, "Invalid #line directive");
return;
} // if
880
const char *cached = stringcache(ctx->filename_cache, filename);
881
state->filename = cached; // may be NULL if stringcache() failed.
882
883
884
885
state->line = linenum;
} // handle_pp_line
886
887
888
static void handle_pp_error(Context *ctx)
{
IncludeState *state = ctx->include_stack;
889
890
891
char *ptr = ctx->failstr;
int avail = sizeof (ctx->failstr) - 1;
int cpy = 0;
892
893
int done = 0;
894
895
896
897
898
899
900
const char *prefix = "#error";
const size_t prefixlen = strlen(prefix);
strcpy(ctx->failstr, prefix);
avail -= prefixlen;
ptr += prefixlen;
state->report_whitespace = 1;
901
902
while (!done)
{
903
const Token token = lexer(state);
904
905
906
switch (token)
{
case ((Token) '\n'):
907
908
909
state->line--; // make sure error is on the right line.
// fall through!
case TOKEN_INCOMPLETE_COMMENT:
910
case TOKEN_EOI:
911
pushback(state); // move back so we catch this later.
912
913
914
done = 1;
break;
915
case ((Token) ' '):
916
917
918
919
920
921
if (!avail)
break;
*(ptr++) = ' ';
avail--;
break;
922
default:
923
cpy = Min(avail, (int) state->tokenlen);
924
925
926
927
if (cpy)
memcpy(ptr, state->token, cpy);
ptr += cpy;
avail -= cpy;
928
929
930
931
break;
} // switch
} // while
932
933
*ptr = '\0';
state->report_whitespace = 0;
934
935
936
937
ctx->isfail = 1;
} // handle_pp_error
938
939
940
static void handle_pp_define(Context *ctx)
{
IncludeState *state = ctx->include_stack;
941
int done = 0;
942
943
if (lexer(state) != TOKEN_IDENTIFIER)
944
{
945
fail(ctx, "Macro names must be identifiers");
946
947
948
return;
} // if
949
950
951
952
char *definition = NULL;
char *sym = (char *) Malloc(ctx, state->tokenlen+1);
if (sym == NULL)
return;
953
954
memcpy(sym, state->token, state->tokenlen);
sym[state->tokenlen] = '\0';
955
956
957
958
959
960
961
962
if (strcmp(sym, "defined") == 0)
{
Free(ctx, sym);
fail(ctx, "'defined' cannot be used as a macro name");
return;
} // if
963
964
965
// Don't treat these symbols as special anymore if they get (re)#defined.
if (strcmp(sym, "__FILE__") == 0)
{
966
967
if (ctx->file_macro)
{
968
failf(ctx, "'%s' already defined", sym); // !!! FIXME: warning?
969
970
971
free_define(ctx, ctx->file_macro);
ctx->file_macro = NULL;
} // if
972
973
974
} // if
else if (strcmp(sym, "__LINE__") == 0)
{
975
976
if (ctx->line_macro)
{
977
failf(ctx, "'%s' already defined", sym); // !!! FIXME: warning?
978
979
980
free_define(ctx, ctx->line_macro);
ctx->line_macro = NULL;
} // if
981
982
} // else if
983
984
985
986
987
// #define a(b) is different than #define a (b) :(
state->report_whitespace = 1;
lexer(state);
state->report_whitespace = 0;
988
int params = 0;
989
char **idents = NULL;
990
static const char space = ' ';
991
992
993
994
995
996
997
998
999
1000
if (state->tokenval == ((Token) ' '))
lexer(state); // skip it.
else if (state->tokenval == ((Token) '('))
{
IncludeState saved;
memcpy(&saved, state, sizeof (IncludeState));
while (1)
{
if (lexer(state) != TOKEN_IDENTIFIER)