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];
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");
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(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();
while(is_qualifier(token))
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(")");
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();
RefPtr<Iteration> ProgramParser::parse_while()
{
expect("while");
- expect("(");
RefPtr<Iteration> loop = new Iteration;
+ loop->source = source_index;
+ loop->line = current_line;
+ expect("(");
loop->condition = parse_expression();
expect(")");
{
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(";");