new language, new compiler

[l2e.git] / src / loader / Parser.cpp

diff --git a/src/loader/Parser.cpp b/src/loader/Parser.cpp
index 8ba370408206bc60f0cfa4d98574e56f6222d624..25a99b6d2314dbc7f7e6e591e80dee875a040b2e 100644 (file)
--- a/src/loader/Parser.cpp
+++ b/src/loader/Parser.cpp
@@ -1,18 +1,14 @@
-/*
- * Parser.cpp
- *
- *  Created on: Aug 26, 2012
- *      Author: holy
- */
-
 #include "Parser.h"
 
+#include "ParsedSource.h"
 #include "utility.h"
 
-#include <auto_ptr.h>
 #include <fstream>
+#include <memory>
+#include <string>
+#include <vector>
 
-using std::auto_ptr;
+using std::unique_ptr;
 using std::ifstream;
 using std::string;
 using std::vector;
@@ -91,14 +87,14 @@ Declaration *Parser::ProbeDefinition() {
                Token t(GetToken());
                tok.Putback(t);
                if (BeginOfPropertyList(t)) {
-                       auto_ptr<PropertyList> propertyList(ParsePropertyList());
-                       auto_ptr<Definition> dfn(new Definition(typeName, identifier));
+                       unique_ptr<PropertyList> propertyList(ParsePropertyList());
+                       unique_ptr<Definition> dfn(new Definition(typeName, identifier));
                        dfn->SetValue(propertyList.release());
                        product.AddDefinition(dfn.get());
                        return dfn.release();
                } else if (BeginningOfPrimitiveLiteral(t)) {
-                       auto_ptr<Literal> literal(ParseLiteral());
-                       auto_ptr<Definition> dfn(new Definition(typeName, identifier));
+                       unique_ptr<Literal> literal(ParseLiteral());
+                       unique_ptr<Definition> dfn(new Definition(typeName, identifier));
                        dfn->SetValue(literal.release());
                        product.AddDefinition(dfn.get());
                        return dfn.release();
@@ -186,7 +182,7 @@ PropertyList *Parser::ParsePropertyList() {
        Token t(GetToken());
        AssertTokenType(t.type, Token::ANGLE_BRACKET_OPEN);
 
-       auto_ptr<PropertyList> props(new PropertyList);
+       unique_ptr<PropertyList> props(new PropertyList);
 
        while (t.type != Token::ANGLE_BRACKET_CLOSE) {
                Token name(GetToken());
@@ -266,17 +262,33 @@ Literal *Parser::ParseArray() {
        Token probe(GetToken());
 
        if (probe.type == Token::TYPE_NAME) {
-               vector<PropertyList *> values;
-               while (t.type != Token::BRACKET_CLOSE) {
-                       PropertyList *value(ParsePropertyList());
-                       values.push_back(value);
+               t = GetToken();
+               tok.Putback(t);
+               if (t.type == Token::ANGLE_BRACKET_OPEN) {
+                       vector<PropertyList *> values;
+                       while (t.type != Token::BRACKET_CLOSE) {
+                               PropertyList *value(ParsePropertyList());
+                               values.push_back(value);
 
-                       t = GetToken();
-                       if (t.type != Token::BRACKET_CLOSE && t.type != Token::COMMA) {
-                               throw Error(file, tok.Line(), string("unexpected token ") + TokenTypeToString(t.type) + ", expected , or ]");
+                               t = GetToken();
+                               if (t.type != Token::BRACKET_CLOSE && t.type != Token::COMMA) {
+                                       throw Error(file, tok.Line(), string("unexpected token ") + TokenTypeToString(t.type) + ", expected , or ]");
+                               }
+                       }
+                       return new Literal(probe.str, values);
+               } else {
+                       vector<string> values;
+                       while (t.type != Token::BRACKET_CLOSE) {
+                               string value(ParseIdentifier());
+                               values.push_back(value);
+
+                               t = GetToken();
+                               if (t.type != Token::BRACKET_CLOSE && t.type != Token::COMMA) {
+                                       throw Error(file, tok.Line(), string("unexpected token ") + TokenTypeToString(t.type) + ", expected , or ]");
+                               }
                        }
+                       return new Literal(probe.str, values);
                }
-               return new Literal(probe.str, values);
        } else {
                tok.Putback(probe);
 
@@ -355,6 +367,7 @@ Literal *Parser::ParseScript() {
        Token t(GetToken());
        AssertTokenType(t.type, Token::SCRIPT_BEGIN, msg);
 
+       t = GetToken();
        vector<ScriptToken *> script;
        try {
                while (t.type != Token::SCRIPT_END) {
@@ -365,17 +378,23 @@ Literal *Parser::ParseScript() {
                                switch (t.type) {
                                        case Token::COMMAND: {
                                                Token t2(GetToken());
-                                               AssertTokenType(t.type, Token::IDENTIFIER, msg);
+                                               AssertTokenType(t2.type, Token::IDENTIFIER, msg);
                                                script.push_back(new ScriptToken(t2.str, ScriptToken::COMMAND));
                                                break;
                                        }
                                        case Token::IDENTIFIER: {
-                                               script.push_back(new ScriptToken(t.str, ScriptToken::IDENTIFIER));
+                                               Token t2(GetToken());
+                                               if (t2.type == Token::COLON) {
+                                                       script.push_back(new ScriptToken(t.str, ScriptToken::LABEL));
+                                               } else {
+                                                       tok.Putback(t2);
+                                                       script.push_back(new ScriptToken(t.str, ScriptToken::IDENTIFIER));
+                                               }
                                                break;
                                        }
                                        case Token::REGISTER: {
                                                Token t2(GetToken());
-                                               AssertTokenType(t.type, Token::IDENTIFIER, msg);
+                                               AssertTokenType(t2.type, Token::IDENTIFIER, msg);
                                                script.push_back(new ScriptToken(t2.str, ScriptToken::REGISTER));
                                                break;
                                        }