Sweden-Number/dlls/d3dcompiler_43/hlsl.l

295 lines
13 KiB
Plaintext

/*
* HLSL parser
*
* Copyright 2008 Stefan Dösinger
* Copyright 2012 Matteo Bruni for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
%{
#include "config.h"
#include "wine/port.h"
#include "wine/debug.h"
#define YY_NO_UNISTD_H
#include "d3dcompiler_private.h"
#include "hlsl.tab.h"
WINE_DEFAULT_DEBUG_CHANNEL(hlsl_parser);
#define YY_USER_ACTION \
do { \
hlsl_lloc.first_column = hlsl_ctx.column; \
hlsl_lloc.first_line = hlsl_ctx.line_no; \
hlsl_ctx.column += yyleng; \
} while(0);
%}
%option noyywrap nounput noinput never-interactive
%option prefix="hlsl_"
%x pp pp_line pp_pragma pp_ignore
RESERVED1 auto|case|catch|char|class|const_cast|default|delete|dynamic_cast|enum
RESERVED2 explicit|friend|goto|long|mutable|new|operator|private|protected|public
RESERVED3 reinterpret_cast|short|signed|sizeof|static_cast|template|this|throw|try
RESERVED4 typename|union|unsigned|using|virtual
WS [ \t]
NEWLINE (\n)|(\r\n)
DOUBLESLASHCOMMENT "//"[^\n]*
STRING \"[^\"]*\"
IDENTIFIER [A-Za-z_][A-Za-z0-9_]*
ANY (.)
%%
{RESERVED1} {
hlsl_message("Line %u: Reserved keyword \"%s\" used.\n", hlsl_ctx.line_no, yytext);
set_parse_status(&hlsl_ctx.status, PARSE_ERR);
}
{RESERVED2} {
hlsl_message("Line %u: Reserved keyword \"%s\" used.\n", hlsl_ctx.line_no, yytext);
set_parse_status(&hlsl_ctx.status, PARSE_ERR);
}
{RESERVED3} {
hlsl_message("Line %u: Reserved keyword \"%s\" used.\n", hlsl_ctx.line_no, yytext);
set_parse_status(&hlsl_ctx.status, PARSE_ERR);
}
{RESERVED4} {
hlsl_message("Line %u: Reserved keyword \"%s\" used.\n", hlsl_ctx.line_no, yytext);
set_parse_status(&hlsl_ctx.status, PARSE_ERR);
}
BlendState {return KW_BLENDSTATE; }
break {return KW_BREAK; }
Buffer {return KW_BUFFER; }
cbuffer {return KW_CBUFFER; }
compile {return KW_COMPILE; }
const {return KW_CONST; }
continue {return KW_CONTINUE; }
DepthStencilState {return KW_DEPTHSTENCILSTATE; }
DepthStencilView {return KW_DEPTHSTENCILVIEW; }
discard {return KW_DISCARD; }
do {return KW_DO; }
double {return KW_DOUBLE; }
else {return KW_ELSE; }
extern {return KW_EXTERN; }
false {return KW_FALSE; }
for {return KW_FOR; }
GeometryShader {return KW_GEOMETRYSHADER; }
groupshared {return KW_GROUPSHARED; }
if {return KW_IF; }
in {return KW_IN; }
inline {return KW_INLINE; }
inout {return KW_INOUT; }
matrix {return KW_MATRIX; }
namespace {return KW_NAMESPACE; }
nointerpolation {return KW_NOINTERPOLATION; }
out {return KW_OUT; }
pass {return KW_PASS; }
PixelShader {return KW_PIXELSHADER; }
precise {return KW_PRECISE; }
RasterizerState {return KW_RASTERIZERSTATE; }
RenderTargetView {return KW_RENDERTARGETVIEW; }
return {return KW_RETURN; }
register {return KW_REGISTER; }
sampler {return KW_SAMPLER; }
sampler1D {return KW_SAMPLER1D; }
sampler2D {return KW_SAMPLER2D; }
sampler3D {return KW_SAMPLER3D; }
samplerCUBE {return KW_SAMPLERCUBE; }
sampler_state {return KW_SAMPLER_STATE; }
SamplerComparisonState {return KW_SAMPLERCOMPARISONSTATE;}
shared {return KW_SHARED; }
stateblock {return KW_STATEBLOCK; }
stateblock_state {return KW_STATEBLOCK_STATE; }
static {return KW_STATIC; }
string {return KW_STRING; }
struct {return KW_STRUCT; }
switch {return KW_SWITCH; }
tbuffer {return KW_TBUFFER; }
technique {return KW_TECHNIQUE; }
technique10 {return KW_TECHNIQUE10; }
texture {return KW_TEXTURE; }
texture1D {return KW_TEXTURE1D; }
Texture1DArray {return KW_TEXTURE1DARRAY; }
texture2D {return KW_TEXTURE2D; }
Texture2DArray {return KW_TEXTURE2DARRAY; }
Texture2DMS {return KW_TEXTURE2DMS; }
Texture2DMSArray {return KW_TEXTURE2DMSARRAY; }
texture3D {return KW_TEXTURE3D; }
Texture3DArray {return KW_TEXTURE3DARRAY; }
textureCUBE {return KW_TEXTURECUBE; }
true {return KW_TRUE; }
typedef {return KW_TYPEDEF; }
uniform {return KW_UNIFORM; }
vector {return KW_VECTOR; }
VertexShader {return KW_VERTEXSHADER; }
void {return KW_VOID; }
volatile {return KW_VOLATILE; }
while {return KW_WHILE; }
\+\+ {return OP_INC; }
\-\- {return OP_DEC; }
&& {return OP_AND; }
\|\| {return OP_OR; }
== {return OP_EQ; }
\<\< {return OP_LEFTSHIFT; }
\<\<= {return OP_LEFTSHIFTASSIGN; }
\>\> {return OP_RIGHTSHIFT; }
\>\>= {return OP_RIGHTSHIFTASSIGN; }
\.\.\. {return OP_ELLIPSIS; }
\<= {return OP_LE; }
\>= {return OP_GE; }
!= {return OP_NE; }
\+= {return OP_ADDASSIGN; }
\-= {return OP_SUBASSIGN; }
\*= {return OP_MULASSIGN; }
\/= {return OP_DIVASSIGN; }
%= {return OP_MODASSIGN; }
&= {return OP_ANDASSIGN; }
\|= {return OP_ORASSIGN; }
^= {return OP_XORASSIGN; }
## {return OP_UNKNOWN1; }
#@ {return OP_UNKNOWN2; }
:: {return OP_UNKNOWN3; }
\-\> {return OP_UNKNOWN4; }
column_major {return KW_COLUMN_MAJOR; }
row_major {return KW_ROW_MAJOR; }
{IDENTIFIER} {
hlsl_lval.name = d3dcompiler_strdup(yytext);
if (get_variable(hlsl_ctx.cur_scope, yytext)
|| find_function(yytext))
return VAR_IDENTIFIER;
else if (get_type(hlsl_ctx.cur_scope, yytext, TRUE))
return TYPE_IDENTIFIER;
else
return NEW_IDENTIFIER;
}
[0-9]*\.[0-9]+([eE][+-]?[0-9]+)?[h|H|f|F]? {
hlsl_lval.floatval = atof(yytext);
return C_FLOAT;
}
[0-9]+\.([eE][+-]?[0-9]+)?[h|H|f|F]? {
hlsl_lval.floatval = atof(yytext);
return C_FLOAT;
}
[0-9]+([eE][+-]?[0-9]+)?[h|H|f|F] {
hlsl_lval.floatval = atof(yytext);
return C_FLOAT;
}
0x[0-9a-fA-F]+ {
sscanf(yytext, "0x%x", &hlsl_lval.intval);
return C_INTEGER;
}
0[0-7]+ {
sscanf(yytext, "0%o", &hlsl_lval.intval);
return C_INTEGER;
}
[0-9]+ {
hlsl_lval.intval = (atoi(yytext));
return C_INTEGER;
}
{DOUBLESLASHCOMMENT} {}
{WS}+ {}
{NEWLINE} {
hlsl_ctx.line_no++;
hlsl_ctx.column = 1;
}
^# {
BEGIN pp;
}
<pp>pragma{WS}+ {
TRACE("Got a #pragma.\n");
BEGIN pp_pragma;
}
<pp_pragma>pack_matrix{WS}*\({WS}*row_major{WS}*\) {
TRACE("#pragma setting row_major mode.\n");
hlsl_ctx.matrix_majority = HLSL_ROW_MAJOR;
BEGIN pp_ignore;
}
<pp_pragma>pack_matrix{WS}*\({WS}*column_major{WS}*\) {
TRACE("#pragma setting column_major mode.\n");
hlsl_ctx.matrix_majority = HLSL_COLUMN_MAJOR;
BEGIN pp_ignore;
}
<pp_pragma>{NEWLINE} {
FIXME("Unsupported preprocessor #pragma directive at line %u.\n", hlsl_ctx.line_no);
BEGIN INITIAL;
}
<pp_pragma>{ANY} {}
<pp>[0-9]+ {
TRACE("Preprocessor line info.\n");
BEGIN pp_line;
hlsl_lval.intval = (atoi(yytext));
return PRE_LINE;
}
<pp_line>{STRING} {
char *string = d3dcompiler_strdup(yytext + 1);
BEGIN pp_ignore;
string[strlen(string) - 1] = 0;
hlsl_lval.name = string;
return STRING;
}
<pp_line>{WS}+ {}
<pp_line>{NEWLINE} {
FIXME("Malformed preprocessor line directive?\n");
BEGIN INITIAL;
}
<pp_ignore>{NEWLINE} {
BEGIN INITIAL;
}
<pp_ignore>{ANY} {}
<pp>{NEWLINE} {
FIXME("Unexpected preprocessor directive.\n");
BEGIN INITIAL;
}
<pp>{ANY} {}
{ANY} {
return yytext[0];
}
%%
struct bwriter_shader *parse_hlsl(enum shader_type type, DWORD major, DWORD minor,
const char *entrypoint, char **messages);
struct bwriter_shader *parse_hlsl_shader(const char *text, enum shader_type type, DWORD major, DWORD minor,
const char *entrypoint, char **messages)
{
struct bwriter_shader *ret = NULL;
YY_BUFFER_STATE buffer;
buffer = hlsl__scan_string(text);
hlsl__switch_to_buffer(buffer);
ret = parse_hlsl(type, major, minor, entrypoint, messages);
hlsl__delete_buffer(buffer);
return ret;
}