Changeset a7c4921 for src/Parser

Timestamp:

Feb 19, 2017, 10:20:13 AM (8 years ago)

Author:

Peter A. Buhr <pabuhr@…>

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:

e7cc8cb

Parents:

317450e

Message:

add documentation to routine buildKRFunction

File:

• src/Parser/TypeData.cc (modified) (3 diffs)

src/Parser/TypeData.cc ¶

@@ -10 +10 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 16 15:06:59 2017
-// Update Count     : 455
+// Last Modified On : Sun Feb 19 09:49:33 2017
+// Update Count     : 467
 //
 
@@ -776 +776 @@
 } // buildFunction
 
+// Transform KR routine declarations into C99 routine declarations:
+//
+//    rtn( a, b, c ) int a, c; double b {}  =>  int rtn( int a, double c, int b ) {}
+//
+// The type information for each post-declaration is moved to the corresponding pre-parameter and the post-declaration
+// is deleted. Note, the order of the parameter names may not be the same as the declaration names. Duplicate names and
+// extra names are disallowed.
+//
+// Note, there is no KR routine-prototype syntax:
+//
+//    rtn( a, b, c ) int a, c; double b; // invalid KR prototype
+//    rtn(); // valid KR prototype
+
 void buildKRFunction( const TypeData::Function_t & function ) {
         assert( ! function.params );
-        for ( DeclarationNode * decl = function.oldDeclList; decl != nullptr; decl = dynamic_cast< DeclarationNode* >( decl->get_next() ) ) {
+        // loop over declaration first as it is easier to spot errors
+        for ( DeclarationNode * decl = function.oldDeclList; decl != nullptr; decl = dynamic_cast< DeclarationNode * >( decl->get_next() ) ) {
+                // scan ALL parameter names for each declaration name to check for duplicates
                 for ( DeclarationNode * param = function.idList; param != nullptr; param = dynamic_cast< DeclarationNode* >( param->get_next() ) ) {
                         if ( *decl->name == *param->name ) {
+                                // type set => parameter name already transformed by a declaration names so there is a duplicate
+                                // declaration name attempting a second transformation
                                 if ( param->type ) throw SemanticError( string( "duplicate declaration name " ) + *param->name );
+                                // declaration type reset => declaration already transformed by a parameter name so there is a duplicate
+                                // parameter name attempting a second transformation
                                 if ( ! decl->type ) throw SemanticError( string( "duplicate parameter name " ) + *param->name );
-                                param->type = decl->type;
-                                decl->type = nullptr;
-                                param->attributes.splice( param->attributes.end(), decl->attributes );
+                                param->type = decl->type;                               // set copy declaration type to parameter type
+                                decl->type = nullptr;                                   // reset declaration type
+                                param->attributes.splice( param->attributes.end(), decl->attributes ); // copy and reset attributes from declaration to parameter
                         } // if
                 } // for
+                // declaration type still set => type not moved to a matching parameter so there is a missing parameter name
                 if ( decl->type ) throw SemanticError( string( "missing name in parameter list " ) + *decl->name );
         } // for
+
+        // Parameter names without a declaration default to type int:
+        //
+        //    rtb( a, b, c ) const char * b; {} => int rtn( int a, const char * b, int c ) {}
+
         for ( DeclarationNode * param = function.idList; param != nullptr; param = dynamic_cast< DeclarationNode* >( param->get_next() ) ) {
-                if ( ! param->type ) {
+                if ( ! param->type ) {                                                  // generate type int for empty parameters
                         param->type = new TypeData( TypeData::Basic );
                         param->type->basictype = DeclarationNode::Int;
@@ -797 +822 @@
         } // for
 
-        function.params = function.idList;
-        function.idList = nullptr;
-        delete function.oldDeclList;
-        function.oldDeclList = nullptr;
+        function.params = function.idList;                                      // newly modified idList becomes parameters
+        function.idList = nullptr;                                                      // idList now empty
+        delete function.oldDeclList;                                            // deletes entire list
+        function.oldDeclList = nullptr;                                         // reset
 } // buildKRFunction