/
mojoshader_preprocessor.c
2378 lines (1998 loc) · 66.9 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
TOKENCASE(TOKEN_EOI);
184
TOKENCASE(TOKEN_PREPROCESSING_ERROR);
185
186
187
188
189
190
#undef TOKENCASE
case ((Token) '\n'):
printf("'\\n'");
break;
191
192
193
194
case ((Token) '\\'):
printf("'\\\\'");
break;
195
196
197
198
199
200
201
202
203
204
default:
assert(((int)tokenval) < 256);
printf("'%c'", (char) tokenval);
break;
} // switch
printf(")\n");
} // MOJOSHADER_print_debug_token
#endif
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
#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
226
227
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
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;
268
269
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
#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
303
// !!! FIXME: maybe use these pool magic elsewhere?
304
// !!! FIXME: maybe just get rid of this? (maybe the fragmentation isn't a big deal?)
305
306
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
// 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; \
333
ctx->poolname##_pool = item; \
334
335
336
337
338
339
340
341
342
}
#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)
343
IMPLEMENT_POOL(Define, define)
344
345
346
347
// Preprocessor define hashtable stuff...
348
349
// !!! FIXME: why isn't this using mojoshader_common.c's code?
350
351
// this is djb's xor hashing function.
static inline uint32 hash_string_djbxor(const char *sym)
352
{
353
register uint32 hash = 5381;
354
while (*sym)
355
356
357
358
359
360
361
hash = ((hash << 5) + hash) ^ *(sym++);
return hash;
} // hash_string_djbxor
static inline uint8 hash_define(const char *sym)
{
return (uint8) hash_string_djbxor(sym);
362
363
364
} // hash_define
365
static int add_define(Context *ctx, const char *sym, const char *val,
366
char **parameters, int paramcount)
367
{
368
const uint8 hash = hash_define(sym);
369
Define *bucket = ctx->define_hashtable[hash];
370
371
while (bucket)
{
372
if (strcmp(bucket->identifier, sym) == 0)
373
{
374
375
failf(ctx, "'%s' already defined", sym); // !!! FIXME: warning?
// !!! FIXME: gcc reports the location of previous #define here.
376
377
378
379
380
return 0;
} // if
bucket = bucket->next;
} // while
381
bucket = get_define(ctx);
382
383
384
if (bucket == NULL)
return 0;
385
bucket->definition = val;
386
bucket->original = NULL;
387
388
389
bucket->identifier = sym;
bucket->parameters = (const char **) parameters;
bucket->paramcount = paramcount;
390
391
392
393
394
395
bucket->next = ctx->define_hashtable[hash];
ctx->define_hashtable[hash] = bucket;
return 1;
} // add_define
396
397
static void free_define(Context *ctx, Define *def)
{
398
399
400
401
402
403
404
405
406
407
408
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
409
410
411
} // free_define
412
413
static int remove_define(Context *ctx, const char *sym)
{
414
const uint8 hash = hash_define(sym);
415
416
Define *bucket = ctx->define_hashtable[hash];
Define *prev = NULL;
417
418
while (bucket)
{
419
if (strcmp(bucket->identifier, sym) == 0)
420
421
422
423
424
{
if (prev == NULL)
ctx->define_hashtable[hash] = bucket->next;
else
prev->next = bucket->next;
425
free_define(ctx, bucket);
426
427
428
429
430
431
432
433
434
435
return 1;
} // if
prev = bucket;
bucket = bucket->next;
} // while
return 0;
} // remove_define
436
static const Define *find_define(Context *ctx, const char *sym)
437
{
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
if ( (ctx->file_macro) && (strcmp(sym, "__FILE__") == 0) )
{
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
else if ( (ctx->line_macro) && (strcmp(sym, "__LINE__") == 0) )
{
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);
assert(len < bufsize);
ctx->line_macro->definition = str;
return ctx->line_macro;
} // else
469
const uint8 hash = hash_define(sym);
470
Define *bucket = ctx->define_hashtable[hash];
471
472
while (bucket)
{
473
if (strcmp(bucket->identifier, sym) == 0)
474
return bucket;
475
476
477
478
479
480
bucket = bucket->next;
} // while
return NULL;
} // find_define
481
482
483
484
485
486
487
488
489
490
491
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
492
493
static const Define *find_macro_arg(const IncludeState *state,
const Define *defines)
494
495
496
497
498
499
{
const Define *def = NULL;
char *sym = (char *) alloca(state->tokenlen + 1);
memcpy(sym, state->token, state->tokenlen);
sym[state->tokenlen] = '\0';
500
for (def = defines; def != NULL; def = def->next)
501
{
502
assert(def->parameters == NULL); // args can't have args!
503
504
505
506
507
508
509
510
511
assert(def->paramcount == 0); // args can't have args!
if (strcmp(def->identifier, sym) == 0)
break;
} // while
return def;
} // find_macro_arg
512
static void put_all_defines(Context *ctx)
513
{
514
size_t i;
515
516
for (i = 0; i < STATICARRAYLEN(ctx->define_hashtable); i++)
{
517
Define *bucket = ctx->define_hashtable[i];
518
519
520
ctx->define_hashtable[i] = NULL;
while (bucket)
{
521
Define *next = bucket->next;
522
free_define(ctx, bucket);
523
524
525
bucket = next;
} // while
} // for
526
} // put_all_defines
527
528
529
static int push_source(Context *ctx, const char *fname, const char *source,
530
unsigned int srclen, unsigned int linenum,
531
MOJOSHADER_includeClose close_callback)
532
{
533
IncludeState *state = get_include(ctx);
534
535
536
if (state == NULL)
return 0;
537
if (fname != NULL)
538
{
539
state->filename = stringcache(ctx->filename_cache, fname);
540
541
if (state->filename == NULL)
{
542
put_include(ctx, state);
543
544
return 0;
} // if
545
546
} // if
547
state->close_callback = close_callback;
548
549
550
state->source_base = source;
state->source = source;
state->token = source;
551
state->tokenval = ((Token) '\n');
552
state->orig_length = srclen;
553
state->bytes_left = srclen;
554
state->line = linenum;
555
state->next = ctx->include_stack;
556
state->asm_comments = ctx->asm_comments;
557
558
559
print_debug_lexing_position(state);
560
561
562
563
564
565
566
567
568
ctx->include_stack = state;
return 1;
} // push_source
static void pop_source(Context *ctx)
{
IncludeState *state = ctx->include_stack;
569
assert(state != NULL); // more pops than pushes!
570
571
572
if (state == NULL)
return;
573
if (state->close_callback)
574
{
575
576
state->close_callback(state->source_base, ctx->malloc,
ctx->free, ctx->malloc_data);
577
578
} // if
579
580
// state->filename is a pointer to the filename cache; don't free it here!
581
582
583
584
585
586
587
Conditional *cond = state->conditional_stack;
while (cond)
{
Conditional *next = cond->next;
put_conditional(ctx, cond);
cond = next;
} // while
588
589
ctx->include_stack = state->next;
590
591
592
print_debug_lexing_position(ctx->include_stack);
593
put_include(ctx, state);
594
595
596
} // pop_source
597
598
599
600
601
602
603
static void close_define_include(const char *data, MOJOSHADER_malloc m,
MOJOSHADER_free f, void *d)
{
f((void *) data, d);
} // close_define_include
604
605
606
607
Preprocessor *preprocessor_start(const char *fname, const char *source,
unsigned int sourcelen,
MOJOSHADER_includeOpen open_callback,
MOJOSHADER_includeClose close_callback,
608
const MOJOSHADER_preprocessorDefine *defines,
609
unsigned int define_count, int asm_comments,
610
611
612
MOJOSHADER_malloc m, MOJOSHADER_free f, void *d)
{
int okay = 1;
613
unsigned int i = 0;
614
615
616
617
618
619
620
// 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)
621
return NULL;
622
623
624
625
626
627
628
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;
629
ctx->asm_comments = asm_comments;
630
631
ctx->filename_cache = stringcache_create(MallocBridge, FreeBridge, ctx);
632
633
634
635
636
637
638
639
640
641
642
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);
643
644
645
646
// let the usual preprocessor parser sort these out.
char *define_include = NULL;
unsigned int define_include_len = 0;
647
if ((okay) && (define_count > 0))
648
{
649
650
651
Buffer *predefbuf = buffer_create(256, MallocBridge, FreeBridge, ctx);
okay = okay && (predefbuf != NULL);
for (i = 0; okay && (i < define_count); i++)
652
{
653
654
okay = okay && buffer_append_fmt(predefbuf, "#define %s %s\n",
defines[i].identifier, defines[i].definition);
655
656
} // for
657
658
define_include_len = buffer_size(predefbuf);
if (define_include_len > 0)
659
{
660
661
662
663
define_include = buffer_flatten(predefbuf);
okay = okay && (define_include != NULL);
} // if
buffer_destroy(predefbuf);
664
} // if
665
666
if ((okay) && (!push_source(ctx,fname,source,sourcelen,1,NULL)))
667
668
okay = 0;
669
if ((okay) && (define_include_len > 0))
670
{
671
assert(define_include != NULL);
672
okay = push_source(ctx, "<predefined macros>", define_include,
673
define_include_len, 1, close_define_include);
674
675
} // if
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
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);
695
696
put_all_defines(ctx);
697
698
699
if (ctx->filename_cache != NULL)
stringcache_destroy(ctx->filename_cache);
700
701
free_define(ctx, ctx->file_macro);
free_define(ctx, ctx->line_macro);
702
free_define_pool(ctx);
703
free_conditional_pool(ctx);
704
free_include_pool(ctx);
705
706
707
708
709
710
711
712
713
714
715
716
Free(ctx, ctx);
} // preprocessor_end
int preprocessor_outofmemory(Preprocessor *_ctx)
{
Context *ctx = (Context *) _ctx;
return ctx->out_of_memory;
} // preprocessor_outofmemory
717
718
719
720
721
722
723
724
725
726
727
728
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)
{
729
730
731
732
#if !MATCH_MICROSOFT_PREPROCESSOR
state->report_whitespace = 1;
#endif
733
734
735
736
737
738
739
if (!state->pushedback)
return preprocessor_lexer(state);
state->pushedback = 0;
return state->tokenval;
} // lexer
740
// !!! FIXME: parsing fails on preprocessor directives should skip rest of line.
741
742
static int require_newline(IncludeState *state)
{
743
744
const Token token = lexer(state);
pushback(state); // rewind no matter what.
745
return ( (token == TOKEN_INCOMPLETE_COMMENT) || // call it an eol.
746
(token == ((Token) '\n')) || (token == TOKEN_EOI) );
747
748
} // require_newline
749
// !!! FIXME: didn't we implement this by hand elsewhere?
750
751
752
753
754
755
756
757
758
759
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
760
761
762
static void handle_pp_include(Context *ctx)
{
IncludeState *state = ctx->include_stack;
763
Token token = lexer(state);
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
794
795
796
797
798
799
800
801
802
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';
803
bogus = !require_newline(state);
804
805
806
807
808
809
810
811
812
813
} // if
if (bogus)
{
fail(ctx, "Invalid #include directive");
return;
} // else
const char *newdata = NULL;
unsigned int newbytes = 0;
814
815
816
817
818
819
if ((ctx->open_callback == NULL) || (ctx->close_callback == NULL))
{
fail(ctx, "Saw #include, but no include callbacks defined");
return;
} // if
820
821
822
823
824
825
826
827
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
828
MOJOSHADER_includeClose callback = ctx->close_callback;
829
if (!push_source(ctx, filename, newdata, newbytes, 1, callback))
830
831
832
833
834
835
836
{
assert(ctx->out_of_memory);
ctx->close_callback(newdata, ctx->malloc, ctx->free, ctx->malloc_data);
} // if
} // handle_pp_include
837
838
839
840
841
842
843
static void handle_pp_line(Context *ctx)
{
IncludeState *state = ctx->include_stack;
char *filename = NULL;
int linenum = 0;
int bogus = 0;
844
if (lexer(state) != TOKEN_INT_LITERAL)
845
846
bogus = 1;
else
847
linenum = token_to_int(state);
848
849
if (!bogus)
850
851
852
853
854
855
856
857
858
{
Token t = lexer(state);
if (t == ((Token) '\n'))
{
state->line = linenum;
return;
}
bogus = (t != TOKEN_STRING_LITERAL);
}
859
860
861
862
if (!bogus)
{
state->token++; // skip '\"'...
863
864
865
filename = (char *) alloca(state->tokenlen);
memcpy(filename, state->token, state->tokenlen-1);
filename[state->tokenlen-1] = '\0';
866
867
868
869
870
871
872
873
874
bogus = !require_newline(state);
} // if
if (bogus)
{
fail(ctx, "Invalid #line directive");
return;
} // if
875
const char *cached = stringcache(ctx->filename_cache, filename);
876
state->filename = cached; // may be NULL if stringcache() failed.
877
878
879
880
state->line = linenum;
} // handle_pp_line
881
882
883
static void handle_pp_error(Context *ctx)
{
IncludeState *state = ctx->include_stack;
884
885
886
char *ptr = ctx->failstr;
int avail = sizeof (ctx->failstr) - 1;
int cpy = 0;
887
888
int done = 0;
889
890
891
892
893
894
895
const char *prefix = "#error";
const size_t prefixlen = strlen(prefix);
strcpy(ctx->failstr, prefix);
avail -= prefixlen;
ptr += prefixlen;
state->report_whitespace = 1;
896
897
while (!done)
{
898
const Token token = lexer(state);
899
900
901
switch (token)
{
case ((Token) '\n'):
902
903
904
state->line--; // make sure error is on the right line.
// fall through!
case TOKEN_INCOMPLETE_COMMENT:
905
case TOKEN_EOI:
906
pushback(state); // move back so we catch this later.
907
908
909
done = 1;
break;
910
case ((Token) ' '):
911
912
913
914
915
916
if (!avail)
break;
*(ptr++) = ' ';
avail--;
break;
917
default:
918
cpy = Min(avail, (int) state->tokenlen);
919
920
921
922
if (cpy)
memcpy(ptr, state->token, cpy);
ptr += cpy;
avail -= cpy;
923
924
925
926
break;
} // switch
} // while
927
928
*ptr = '\0';
state->report_whitespace = 0;
929
930
931
932
ctx->isfail = 1;
} // handle_pp_error
933
934
935
static void handle_pp_define(Context *ctx)
{
IncludeState *state = ctx->include_stack;
936
int done = 0;
937
938
if (lexer(state) != TOKEN_IDENTIFIER)
939
{
940
fail(ctx, "Macro names must be identifiers");
941
942
943
return;
} // if
944
945
946
947
char *definition = NULL;
char *sym = (char *) Malloc(ctx, state->tokenlen+1);
if (sym == NULL)
return;
948
949
memcpy(sym, state->token, state->tokenlen);
sym[state->tokenlen] = '\0';
950
951
952
953
954
955
956
957
if (strcmp(sym, "defined") == 0)
{
Free(ctx, sym);
fail(ctx, "'defined' cannot be used as a macro name");
return;
} // if
958
959
960
// Don't treat these symbols as special anymore if they get (re)#defined.
if (strcmp(sym, "__FILE__") == 0)
{
961
962
if (ctx->file_macro)
{
963
failf(ctx, "'%s' already defined", sym); // !!! FIXME: warning?
964
965
966
free_define(ctx, ctx->file_macro);
ctx->file_macro = NULL;
} // if
967
968
969
} // if
else if (strcmp(sym, "__LINE__") == 0)
{
970
971
if (ctx->line_macro)
{
972
failf(ctx, "'%s' already defined", sym); // !!! FIXME: warning?
973
974
975
free_define(ctx, ctx->line_macro);
ctx->line_macro = NULL;
} // if
976
977
} // else if
978
979
980
981
982
// #define a(b) is different than #define a (b) :(
state->report_whitespace = 1;
lexer(state);
state->report_whitespace = 0;
983
int params = 0;
984
char **idents = NULL;
985
static const char space = ' ';
986
987
988
989
990
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)
break;
params++;
if (lexer(state) != ((Token) ','))
break;
} // while