Changeset 294647b for src

Timestamp:

Feb 14, 2017, 2:54:51 PM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

138e29e

Parents:

eafb094

Message:

Filename and linenumber handling for parsing errors

Location:

src

Files:

• Common/SemanticError.cc (modified) (2 diffs)
• Common/SemanticError.h (modified) (2 diffs)
• Common/utility.h (modified) (2 diffs)
• Parser/DeclarationNode.cc (modified) (3 diffs)
• Parser/ParseNode.h (modified) (3 diffs)
• SynTree/BaseSyntaxNode.h (added)
• SynTree/Declaration.h (modified) (1 diff)
• SynTree/Expression.h (modified) (1 diff)
• SynTree/Initializer.h (modified) (1 diff)
• SynTree/Statement.h (modified) (1 diff)

src/Common/SemanticError.cc

@@ -34 +34 @@
 
 void SemanticError::append( const std::string & msg ) {
-  errors.push_back( std::string( "Error: ") + msg );
+  using std::to_string;
+  const std::string loc = location.linenumber >= 0 ? "At \"" + to_string(location) + "\" " : "";
+  errors.push_back( loc + "Error: " + msg );
 }
 
@@ -45 +47 @@
 }
 
+void SemanticError::set_location( const CodeLocation& location ) {
+  this->location = location;
+  using std::to_string;
+  const std::string loc = location.linenumber >= 0 ? "At \"" + to_string(location) + "\" " : "";
+  auto& error = *errors.begin();
+  error.insert( 0, loc.c_str());
+}
+
 // Local Variables: //
 // tab-width: 4 //

src/Common/SemanticError.h

@@ -23 +23 @@
 #include <iostream>
 
+#include "utility.h"
+
 class SemanticError : public std::exception {
   public:
@@ -35 +37 @@
         void print( std::ostream &os );
 
+        void set_location( const CodeLocation& location );
         // constructs an exception using the given message and the printed
         // representation of the obj (T must have a print method)
   private:
         std::list< std::string > errors;
+        CodeLocation location;
 };
 

src/Common/utility.h

@@ -25 +25 @@
 #include <sstream>
 #include <string>
+
 #include <cassert>
-
 template< typename T >
 static inline T * maybeClone( const T *orig ) {
@@ -303 +303 @@
         return group_iterate_t<Args...>(args...);
 }
+
+struct CodeLocation {
+        int linenumber;
+        std::string filename;
+
+        CodeLocation() 
+                : linenumber( -1 )
+                , filename("")
+        {}
+
+        CodeLocation( const char* filename, int lineno )
+                : linenumber( lineno )
+                , filename(filename ? filename : "")
+        {}
+};
+
+inline std::string to_string( const CodeLocation& location ) {
+        return location.filename + ":" + std::to_string(location.linenumber);
+}
 #endif // _UTILITY_H
 

src/Parser/DeclarationNode.cc

@@ -921 +921 @@
                                 Declaration * decl = extr->build();
                                 if ( decl ) {
+                                        decl->location = cur->location;
                                         * out++ = decl;
                                 } // if
@@ -928 +929 @@
                         Declaration * decl = cur->build();
                         if ( decl ) {
+                                decl->location = cur->location;
                                 * out++ = decl;
                         } // if
                 } catch( SemanticError &e ) {
+                        e.set_location( cur->location );
                         errors.append( e );
                 } // try
@@ -950 +953 @@
                         if ( decl ) {
                                 if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
+                                        dwt->location = cur->location;
                                         * out++ = dwt;
                                 } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {
                                         StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->get_name() );
-                                        * out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr );
+                                        auto obj = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr );
+                                        obj->location = cur->location;
+                                        * out++ = obj; 
                                         delete agg;
                                 } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
                                         UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
-                                        * out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr );
+                                        auto obj = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr );
+                                        obj->location = cur->location;
+                                        * out++ = obj;
                                 } // if
                         } // if
                 } catch( SemanticError &e ) {
+                        e.set_location( cur->location );
                         errors.append( e );
                 } // try

src/Parser/ParseNode.h

@@ -39 +39 @@
 //##############################################################################
 
+extern char* yyfilename;
+extern int yylineno;
+
 class ParseNode {
   public:
@@ -65 +68 @@
         ParseNode * next = nullptr;
         std::string * name = nullptr;
+        CodeLocation location = { yyfilename, yylineno };
 }; // ParseNode
 
@@ -410 +414 @@
         while ( cur ) {
                 try {
-//                      SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::result_of< decltype(&NodeType::build)(NodeType)>::type >( cur ) );
                         SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
                         if ( result ) {
+                                result->location = cur->location;
                                 * out++ = result;
                         } // if
                 } catch( SemanticError &e ) {
+                        e.set_location( cur->location );
                         errors.append( e );
                 } // try

src/SynTree/Declaration.h

@@ -17 +17 @@
 #define DECLARATION_H
 
+#include <string>
+
+#include "BaseSyntaxNode.h"
+#include "Mutator.h"
+#include "Visitor.h"
 #include "SynTree.h"
-#include "Visitor.h"
-#include "Mutator.h"
 #include "Parser/LinkageSpec.h"
 #include "Parser/ParseNode.h"
-#include <string>
-
-class Declaration {
+
+class Declaration : public BaseSyntaxNode {
   public:
         Declaration( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage );

src/SynTree/Expression.h

@@ -19 +19 @@
 #include <map>
 #include <memory>
+
+#include "BaseSyntaxNode.h"
+#include "Constant.h"
+#include "Mutator.h"
 #include "SynTree.h"
 #include "Visitor.h"
-#include "Mutator.h"
-#include "Constant.h"
 #include "Common/UniqueName.h"
 
 /// Expression is the root type for all expressions
-class Expression {
+class Expression : public BaseSyntaxNode{
   public:
         Expression( Expression * _aname = nullptr );

src/SynTree/Initializer.h

@@ -17 +17 @@
 #define INITIALIZER_H
 
+#include <cassert>
+
+#include "BaseSyntaxNode.h"
+#include "Mutator.h"
 #include "SynTree.h"
+#include "Type.h"
 #include "Visitor.h"
-#include "Mutator.h"
-#include "Type.h"
-
-#include <cassert>
 
 const std::list<Expression*> noDesignators;
 
 // Initializer: base class for object initializers (provide default values)
-class Initializer {
+class Initializer : public BaseSyntaxNode {
   public:
         //      Initializer( std::string _name = std::string(""), int _pos = 0 );

src/SynTree/Statement.h

@@ -17 +17 @@
 #define STATEMENT_H
 
+#include "BaseSyntaxNode.h"
+#include "Label.h"
+#include "Mutator.h"
 #include "SynTree.h"
+#include "Type.h"
 #include "Visitor.h"
-#include "Mutator.h"
 #include "Common/SemanticError.h"
-#include "Type.h"
-#include "Label.h"
-
-class Statement {
+
+class Statement : public BaseSyntaxNode {
   public:
         Statement( std::list<Label> labels );