#include <msp/strings/regex.h>
#include "programparser.h"
+#undef interface
+
using namespace std;
namespace Msp {
delete module;
}
-Module &ProgramParser::parse(const string &s, const string &n)
+Module &ProgramParser::parse(const string &s, const string &n, unsigned i)
{
source = s;
source_name = n;
+ source_index = i;
parse_source();
return *module;
}
-Module &ProgramParser::parse(IO::Base &io, const string &n)
+Module &ProgramParser::parse(IO::Base &io, const string &n, unsigned i)
{
source = string();
source_name = n;
+ source_index = i;
while(!io.eof())
{
char buffer[4096];
source_end = source.end();
current_line = 1;
allow_preprocess = true;
- while(RefPtr<Node> statement = parse_global_declaration())
+ while(RefPtr<Statement> statement = parse_global_declaration())
cur_stage->content.body.push_back(statement);
}
{
if(*iter=='/')
comment = 0;
- else
+ else if(*iter!='*')
comment = 3;
}
bool ProgramParser::is_sampling_qualifier(const string &token)
{
- return token=="centroid";
+ return (token=="centroid" || token=="sample");
+}
+
+bool ProgramParser::is_interpolation_qualifier(const string &token)
+{
+ return (token=="smooth" || token=="flat" || token=="noperspective");
}
bool ProgramParser::is_precision_qualifier(const string &token)
bool ProgramParser::is_qualifier(const string &token)
{
- return (token=="const" || is_interface_qualifier(token) || is_sampling_qualifier(token) || is_precision_qualifier(token));
+ return (token=="const" ||
+ is_interface_qualifier(token) ||
+ is_sampling_qualifier(token) ||
+ is_interpolation_qualifier(token) ||
+ is_precision_qualifier(token));
}
bool ProgramParser::is_builtin_type(const string &token)
{
- static Regex re("^(void|float|int|bool|[ib]?vec[234]|mat[234](x[234])?|sampler((1D|2D)(Array)?(Shadow)?|Cube(Shadow)?|3D))$");
+ static Regex re("^(void|float|int|bool|[ib]?vec[234]|mat[234](x[234])?|sampler((1D|2D|Cube)(Array)?(Shadow)?|3D))$");
return re.match(token);
}
string token = peek_token();
if(token=="pragma")
preprocess_pragma();
+ else if(token=="version")
+ preprocess_version();
else if(token=="define" || token=="undef" || token=="if" || token=="ifdef" || token=="ifndef" || token=="else" ||
- token=="elif" || token=="endif" || token=="error" || token=="extension" || token=="version" || token=="line")
+ token=="elif" || token=="endif" || token=="error" || token=="extension" || token=="line")
throw runtime_error(format_error(format("Unsupported preprocessor directive '%s'", token)));
else if(!token.empty())
throw runtime_error(format_syntax_error("a preprocessor directive"));
iter = line_end;
}
+void ProgramParser::preprocess_version()
+{
+ expect("version");
+ string token = parse_token();
+ unsigned version = lexical_cast<unsigned>(token);
+ cur_stage->required_version = Version(version/100, version%100);
+
+ token = parse_token();
+ if(!token.empty())
+ throw runtime_error(format_syntax_error("end of line"));
+}
+
void ProgramParser::preprocess_pragma()
{
expect("pragma");
cur_stage = &module->stages.back();
}
-RefPtr<Node> ProgramParser::parse_global_declaration()
+RefPtr<Statement> ProgramParser::parse_global_declaration()
{
allow_stage_change = true;
string token = peek_token();
if(is_interface_qualifier(token) && peek_token(1)==";")
{
RefPtr<InterfaceLayout> iface_lo = new InterfaceLayout;
+ iface_lo->source = source_index;
+ iface_lo->line = current_line;
iface_lo->layout.qualifiers = layout->qualifiers;
iface_lo->interface = parse_token();
expect(";");
else if(is_interface_qualifier(token))
{
string next = peek_token(1);
- if(is_type(next) || is_precision_qualifier(next))
+ if(is_type(next) || is_qualifier(next))
return parse_variable_declaration();
else
return parse_interface_block();
throw runtime_error(format_syntax_error("a global declaration"));
}
-RefPtr<Node> ProgramParser::parse_statement()
+RefPtr<Statement> ProgramParser::parse_statement()
{
string token = peek_token();
if(token=="if")
return parse_conditional();
else if(token=="for")
- return parse_iteration();
+ return parse_for();
+ else if(token=="while")
+ return parse_while();
else if(token=="passthrough")
return parse_passthrough();
else if(token=="return")
else if(token=="break" || token=="continue" || token=="discard")
{
RefPtr<Jump> jump = new Jump;
+ jump->source = source_index;
+ jump->line = current_line;
jump->keyword = parse_token();
expect(";");
else if(!token.empty())
{
RefPtr<ExpressionStatement> expr = new ExpressionStatement;
+ expr->source = source_index;
+ expr->line = current_line;
expr->expression = parse_expression();
expect(";");
expect("import");
RefPtr<Import> import = new Import;
- import->module = parse_token();
+ import->source = source_index;
+ import->line = current_line;
+ import->module = expect_identifier();
expect(";");
return import;
}
{
expect("precision");
RefPtr<Precision> precision = new Precision;
+ precision->source = source_index;
+ precision->line = current_line;
precision->precision = parse_token();
if(!is_precision_qualifier(precision->precision))
{
expect("struct");
RefPtr<StructDeclaration> strct = new StructDeclaration;
+ strct->source = source_index;
+ strct->line = current_line;
strct->name = expect_identifier();
parse_block(strct->members, true);
RefPtr<VariableDeclaration> ProgramParser::parse_variable_declaration()
{
RefPtr<VariableDeclaration> var = new VariableDeclaration;
+ var->source = source_index;
+ var->line = current_line;
string token = peek_token();
- if(is_sampling_qualifier(token))
- {
- var->sampling = parse_token();
- token = peek_token();
- if(!is_interface_qualifier(token))
- throw runtime_error(format_syntax_error("an interface qualifier"));
- }
-
- if(is_interface_qualifier(token))
- var->interface = parse_token();
- else if(token=="const")
+ while(is_qualifier(token))
{
- var->constant = true;
parse_token();
+ if(is_interface_qualifier(token))
+ var->interface = token;
+ else if(is_sampling_qualifier(token))
+ var->sampling = token;
+ else if(is_interpolation_qualifier(token))
+ var->interpolation = token;
+ else if(is_precision_qualifier(token))
+ var->precision = token;
+ else if(token=="const")
+ var->constant = true;
+ token = peek_token();
}
- if(is_precision_qualifier(token))
- var->precision = parse_token();
-
var->type = expect_type();
var->name = expect_identifier();
RefPtr<FunctionDeclaration> ProgramParser::parse_function_declaration()
{
RefPtr<FunctionDeclaration> func = new FunctionDeclaration;
+ func->source = source_index;
+ func->line = current_line;
func->return_type = expect_type();
func->name = expect_identifier();
RefPtr<InterfaceBlock> ProgramParser::parse_interface_block()
{
RefPtr<InterfaceBlock> iface = new InterfaceBlock;
+ iface->source = source_index;
+ iface->line = current_line;
iface->interface = parse_token();
if(!is_interface_qualifier(iface->interface))
RefPtr<Conditional> ProgramParser::parse_conditional()
{
expect("if");
- expect("(");
RefPtr<Conditional> cond = new Conditional;
+ cond->source = source_index;
+ cond->line = current_line;
+ expect("(");
cond->condition = parse_expression();
expect(")");
return cond;
}
-RefPtr<Iteration> ProgramParser::parse_iteration()
+RefPtr<Iteration> ProgramParser::parse_for()
{
expect("for");
- expect("(");
RefPtr<Iteration> loop = new Iteration;
+ loop->source = source_index;
+ loop->line = current_line;
+ expect("(");
string token = peek_token();
if(is_type(token))
loop->init_statement = parse_statement();
else
{
- RefPtr<ExpressionStatement> expr = new ExpressionStatement;
- expr->expression = parse_expression();
+ if(token!=";")
+ {
+ RefPtr<ExpressionStatement> expr = new ExpressionStatement;
+ expr->expression = parse_expression();
+ loop->init_statement = expr;
+ }
expect(";");
- loop->init_statement = expr;
}
- loop->condition = parse_expression();
+ if(peek_token()!=";")
+ loop->condition = parse_expression();
expect(";");
- loop->loop_expression = parse_expression();
+ if(peek_token()!=")")
+ loop->loop_expression = parse_expression();
+ expect(")");
+
+ parse_block(loop->body, false);
+
+ return loop;
+}
+
+RefPtr<Iteration> ProgramParser::parse_while()
+{
+ expect("while");
+ RefPtr<Iteration> loop = new Iteration;
+ loop->source = source_index;
+ loop->line = current_line;
+ expect("(");
+ loop->condition = parse_expression();
expect(")");
parse_block(loop->body, false);
{
expect("passthrough");
RefPtr<Passthrough> pass = new Passthrough;
+ pass->source = source_index;
+ pass->line = current_line;
if(cur_stage->type==GEOMETRY)
{
expect("[");
{
expect("return");
RefPtr<Return> ret = new Return;
+ ret->source = source_index;
+ ret->line = current_line;
if(peek_token()!=";")
ret->expression = parse_expression();
expect(";");