295 lines
13 KiB
Plaintext
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;
|
|
}
|