/**
* 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.
*/
// This was originally based on examples/pp-c.re from re2c: http://re2c.org/
// re2c is public domain code.
//
// You build mojoshader_lexer.c from the .re file with re2c...
// re2c -is -o mojoshader_lexer.c mojoshader_lexer.re
//
// Changes to the lexer are done to the .re file, not the C code!
//
// Please note that this isn't a perfect C lexer, since it is used for both
// HLSL and shader assembly language, and follows the quirks of Microsoft's
// tools.
#define __MOJOSHADER_INTERNAL__ 1
#include "mojoshader_internal.h"
typedef unsigned char uchar;
/*!max:re2c */
#define RET(t) return update_state(s, eoi, cursor, token, (Token) t)
#define YYCTYPE uchar
#define YYCURSOR cursor
#define YYLIMIT limit
#define YYMARKER s->lexer_marker
#define YYFILL(n) { if ((n) == 1) { cursor = sentinel; limit = cursor + YYMAXFILL; eoi = 1; } }
static uchar sentinel[YYMAXFILL];
static Token update_state(IncludeState *s, int eoi, const uchar *cur,
const uchar *tok, const Token val)
{
if (eoi)
{
s->bytes_left = 0;
s->source = (const char *) s->source_base + s->orig_length;
if ( (tok >= sentinel) && (tok < (sentinel+YYMAXFILL)) )
s->token = s->source;
else
s->token = (const char *) tok;
} // if
else
{
s->bytes_left -= (unsigned int) (cur - ((const uchar *) s->source));
s->source = (const char *) cur;
s->token = (const char *) tok;
} // else
s->tokenlen = (unsigned int) (s->source - s->token);
s->tokenval = val;
return val;
} // update_state
Token preprocessor_lexer(IncludeState *s)
{
const uchar *cursor = (const uchar *) s->source;
const uchar *token = cursor;
const uchar *matchptr;
const uchar *limit = cursor + s->bytes_left;
int eoi = 0;
/*!re2c
ANY = [\000-\377];
ANYLEGAL = [a-zA-Z0-9_/'*=+%^&|!#<>()[{}.,~^:;? \t\v\f\r\n\-\]\\];
O = [0-7];
D = [0-9];
L = [a-zA-Z_];
H = [a-fA-F0-9];
E = [Ee] [+-]? D+;
FS = [fFhH];
IS = [uUlL]*;
ESC = [\\] ([abfnrtv?'"\\] | "x" H+ | O+);
PP = "#" [ \t]*;
NEWLINE = ("\r\n" | "\r" | "\n");
WHITESPACE = [ \t\v\f]+;
*/
// preprocessor directives are only valid at start of line.
if (s->tokenval == ((Token) '\n'))
goto ppdirective; // may jump back to scanner_loop.
scanner_loop:
if (YYLIMIT == YYCURSOR) YYFILL(1);
token = cursor;
/*!re2c
"\\" [ \t\v\f]* NEWLINE { s->line++; goto scanner_loop; }
"/*" { goto multilinecomment; }
"//" { goto singlelinecomment; }
L (L|D)* { RET(TOKEN_IDENTIFIER); }
("0" [xX] H+ IS?) | ("0" D+ IS?) | (D+ IS?) |
(['] (ESC|ANY\[\r\n\\'])* ['])
{ RET(TOKEN_INT_LITERAL); }
(D+ E FS?) | (D* "." D+ E? FS?) | (D+ "." D* E? FS?)
{ RET(TOKEN_FLOAT_LITERAL); }
(["] (ESC|ANY\[\r\n\\"])* ["])
{ RET(TOKEN_STRING_LITERAL); }
">>=" { RET(TOKEN_RSHIFTASSIGN); }
"<<=" { RET(TOKEN_LSHIFTASSIGN); }
"+=" { RET(TOKEN_ADDASSIGN); }
"-=" { RET(TOKEN_SUBASSIGN); }
"*=" { RET(TOKEN_MULTASSIGN); }
"/=" { RET(TOKEN_DIVASSIGN); }
"%=" { RET(TOKEN_MODASSIGN); }
"^=" { RET(TOKEN_XORASSIGN); }
"&=" { RET(TOKEN_ANDASSIGN); }
"|=" { RET(TOKEN_ORASSIGN); }
"++" { RET(TOKEN_INCREMENT); }
"--" { RET(TOKEN_DECREMENT); }
">>" { RET(TOKEN_RSHIFT); }
"<<" { RET(TOKEN_LSHIFT); }
"&&" { RET(TOKEN_ANDAND); }
"||" { RET(TOKEN_OROR); }
"<=" { RET(TOKEN_LEQ); }
">=" { RET(TOKEN_GEQ); }
"==" { RET(TOKEN_EQL); }
"!=" { RET(TOKEN_NEQ); }
"#" { RET(TOKEN_HASH); }
"##" { RET(TOKEN_HASHHASH); }
"(" { RET('('); }
")" { RET(')'); }
"[" { RET('['); }
"]" { RET(']'); }
"." { RET('.'); }
"," { RET(','); }
"&" { RET('&'); }
"!" { RET('!'); }
"~" { RET('~'); }
"-" { RET('-'); }
"+" { RET('+'); }
"*" { RET('*'); }
"/" { RET('/'); }
"%" { RET('%'); }
"<" { RET('<'); }
">" { RET('>'); }
"^" { RET('^'); }
"|" { RET('|'); }
":" { RET(':'); }
"{" { RET('{'); }
"}" { RET('}'); }
"=" { RET('='); }
"?" { RET('?'); }
";" { if (s->asm_comments) goto singlelinecomment; RET(';'); }
"\000" { if (eoi) { RET(TOKEN_EOI); } goto bad_chars; }
WHITESPACE { if (s->report_whitespace) RET(' '); goto scanner_loop; }
NEWLINE { s->line++; RET('\n'); }
ANY { goto bad_chars; }
*/
multilinecomment:
if (YYLIMIT == YYCURSOR) YYFILL(1);
matchptr = cursor;
// The "*\/" is just to avoid screwing up text editor syntax highlighting.
/*!re2c
"*\/" {
if (s->report_comments)
RET(TOKEN_MULTI_COMMENT);
else if (s->report_whitespace)
RET(' ');
// Microsoft's preprocessor allows multiline comments
// before a preprocessor directive, even though C/C++
// doesn't. See if we've hit this case.
#if MATCH_MICROSOFT_PREPROCESSOR
if (s->tokenval == ((Token) '\n')) // was start of line?
{
update_state(s, eoi, cursor, token, (Token) '\n');
goto ppdirective; // may jump back to scanner_loop.
}
#endif
goto scanner_loop;
}
NEWLINE {
s->line++;
goto multilinecomment;
}
"\000" {
if (eoi)
RET(TOKEN_INCOMPLETE_COMMENT);
goto multilinecomment;
}
ANY { goto multilinecomment; }
*/
singlelinecomment:
if (YYLIMIT == YYCURSOR) YYFILL(1);
matchptr = cursor;
/*!re2c
NEWLINE {
s->line++;
if (s->report_comments)
{
cursor = matchptr; // so we RET('\n') next.
RET(TOKEN_SINGLE_COMMENT);
}
token = matchptr;
RET('\n');
}
"\000" {
if (eoi)
{
if (s->report_comments)
RET(TOKEN_SINGLE_COMMENT);
else
RET(TOKEN_EOI);
}
goto singlelinecomment;
}
ANY { goto singlelinecomment; }
*/
ppdirective:
if (YYLIMIT == YYCURSOR) YYFILL(1);
/*!re2c
PP "include" { RET(TOKEN_PP_INCLUDE); }
PP "line" { RET(TOKEN_PP_LINE); }
PP "define" { RET(TOKEN_PP_DEFINE); }
PP "undef" { RET(TOKEN_PP_UNDEF); }
PP "if" { RET(TOKEN_PP_IF); }
PP "ifdef" { RET(TOKEN_PP_IFDEF); }
PP "ifndef" { RET(TOKEN_PP_IFNDEF); }
PP "else" { RET(TOKEN_PP_ELSE); }
PP "elif" { RET(TOKEN_PP_ELIF); }
PP "endif" { RET(TOKEN_PP_ENDIF); }
PP "error" { RET(TOKEN_PP_ERROR); }
PP "pragma" { RET(TOKEN_PP_PRAGMA); }
WHITESPACE { goto ppdirective; }
ANY {
token = cursor = (const uchar *) s->source;
limit = cursor + s->bytes_left;
goto scanner_loop;
}
*/
bad_chars:
if (YYLIMIT == YYCURSOR) YYFILL(1);
/*!re2c
ANYLEGAL { cursor--; RET(TOKEN_BAD_CHARS); }
"\000" {
if (eoi)
{
assert( !((token >= sentinel) &&
(token < sentinel+YYMAXFILL)) );
eoi = 0;
cursor = (uchar *) s->source_base + s->orig_length;
RET(TOKEN_BAD_CHARS); // next call will be EOI.
}
goto bad_chars;
}
ANY { goto bad_chars; }
*/
assert(0 && "Shouldn't hit this code");
RET(TOKEN_UNKNOWN);
} // preprocessor_lexer
// end of mojoshader_lexer.re (or .c) ...