Changeset 3f12158

Timestamp:

Jul 7, 2017, 11:55:37 AM (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:

7c03d6d

Parents:

f32e53e (diff), 54d714e (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src

Files:

• Parser/LinkageSpec.cc (modified) (3 diffs)
• Parser/LinkageSpec.h (modified) (2 diffs)
• main.cc (modified) (2 diffs)

src/Parser/LinkageSpec.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 13:22:09 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Jun 28 11:51:00 2017
-// Update Count     : 24
+// Last Modified On : Fri Jul  7 11:11:00 2017
+// Update Count     : 25
 //
 
@@ -22 +22 @@
 #include "Common/SemanticError.h"
 
-LinkageSpec::Spec LinkageSpec::linkageCheck( const string * spec ) {
+namespace LinkageSpec {
+
+Spec linkageCheck( const string * spec ) {
+        assert( spec );
         unique_ptr<const string> guard( spec ); // allocated by lexer
         if ( *spec == "\"Cforall\"" ) {
@@ -35 +38 @@
 }
 
-string LinkageSpec::linkageName( LinkageSpec::Spec linkage ) {
-        assert( 0 <= linkage && linkage < LinkageSpec::NoOfSpecs );
-        static const char *linkageKinds[LinkageSpec::NoOfSpecs] = {
-                "intrinsic", "Cforall", "C", "automatically generated", "compiler built-in", "cfa built-in", "c built-in",
-        };
-        return linkageKinds[linkage];
+Spec linkageUpdate( Spec old_spec, const string * cmd ) {
+        assert( cmd );
+        unique_ptr<const string> guard( cmd ); // allocated by lexer
+        if ( *cmd == "\"Cforall\"" ) {
+                old_spec.is_mangled = true;
+                return old_spec;
+        } else if ( *cmd == "\"C\"" ) {
+                old_spec.is_mangled = false;
+                return old_spec;
+        } else {
+                throw SemanticError( "Invalid linkage specifier " + *cmd );
+        } // if
 }
 
-bool LinkageSpec::isMangled( Spec spec ) {
-        assert( 0 <= spec && spec < LinkageSpec::NoOfSpecs );
-        static bool decoratable[LinkageSpec::NoOfSpecs] = {
-                //      Intrinsic,      Cforall,        C,              AutoGen,        Compiler,
-                        true,           true,           false,  true,           false,
-                //      Builtin,        BuiltinC,
-                        true,           false,
-        };
-        return decoratable[spec];
+std::string linkageName( Spec linkage ) {
+    switch ( linkage ) {
+    case Intrinsic:
+        return "intrinsic";
+    case C:
+        return "C";
+    case Cforall:
+        return "Cforall";
+    case AutoGen:
+        return "autogenerated cfa";
+    case Compiler:
+        return "compiler built-in";
+    case BuiltinCFA:
+        return "cfa built-in";
+    case BuiltinC:
+        return "c built-in";
+    default:
+        return "<unnamed linkage spec>";
+    }
 }
 
-bool LinkageSpec::isGeneratable( Spec spec ) {
-        assert( 0 <= spec && spec < LinkageSpec::NoOfSpecs );
-        static bool generatable[LinkageSpec::NoOfSpecs] = {
-                //      Intrinsic,      Cforall,        C,              AutoGen,        Compiler,
-                        true,           true,           true,   true,           false,
-                //      Builtin,        BuiltinC,
-                        true,           true,
-        };
-        return generatable[spec];
-}
-
-bool LinkageSpec::isOverridable( Spec spec ) {
-        assert( spec >= 0 && spec < LinkageSpec::NoOfSpecs );
-        static bool overridable[LinkageSpec::NoOfSpecs] = {
-                //      Intrinsic,      Cforall,        C,              AutoGen,        Compiler,
-                        true,           false,          false,  true,           false,
-                //      Builtin,        BuiltinC,
-                        false,          false,
-        };
-        return overridable[spec];
-}
-
-bool LinkageSpec::isBuiltin( Spec spec ) {
-        assert( spec >= 0 && spec < LinkageSpec::NoOfSpecs );
-        static bool builtin[LinkageSpec::NoOfSpecs] = {
-                //      Intrinsic,      Cforall,        C,              AutoGen,        Compiler,
-                        true,           false,          false,  false,          true,
-                //      Builtin,        BuiltinC,
-                        true,           true,
-        };
-        return builtin[spec];
-}
+} // LinkageSpec
 
 // Local Variables: //

src/Parser/LinkageSpec.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// LinkageSpec.h -- 
+// LinkageSpec.h --
 //
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:24:28 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Jun 28 11:50:00 2017
-// Update Count     : 12
+// Last Modified On : Fri Jul  7 11:03:00 2017
+// Update Count     : 13
 //
 
@@ -19 +19 @@
 #include <string>
 
-struct LinkageSpec {
-        enum Spec {
-                Intrinsic,                                                                              // C built-in defined in prelude
-                Cforall,                                                                                // ordinary
-                C,                                                                                              // not overloadable, not mangled
-                AutoGen,                                                                                // built by translator (struct assignment)
-                Compiler,                                                                               // gcc internal
-                Builtin,                                                                                // mangled builtins
-                BuiltinC,                                                                               // non-mangled builtins
-                NoOfSpecs
+namespace LinkageSpec {
+        // All linkage specs are some combination of these flags:
+        enum {
+                Mangle = 1 << 0,
+                Generate = 1 << 1,
+                Overrideable = 1 << 2,
+                Builtin = 1 << 3,
+
+                NoOfSpecs = 1 << 4,
         };
-  
-        static Spec linkageCheck( const std::string * );
-        static std::string linkageName( Spec );
-  
-        static bool isMangled( Spec );
-        static bool isGeneratable( Spec );
-        static bool isOverridable( Spec );
-        static bool isBuiltin( Spec );
+
+        union Spec {
+                unsigned int val;
+                struct {
+                        bool is_mangled : 1;
+                        bool is_generatable : 1;
+                        bool is_overridable : 1;
+                        bool is_builtin : 1;
+                };
+                constexpr Spec( unsigned int val ) : val( val ) {}
+                constexpr Spec( Spec const &other ) : val( other.val ) {}
+                // Operators may go here.
+                // Supports == and !=
+                constexpr operator unsigned int () const { return val; }
+        };
+
+
+        Spec linkageCheck( const std::string * );
+        // Returns the Spec with the given name (limited to C, Cforall & BuiltinC)
+        Spec linkageUpdate( Spec old_spec, const std::string * cmd );
+        /* If cmd = "C" returns a Spec that is old_spec with is_mangled = false
+         * If cmd = "Cforall" returns old_spec Spec with is_mangled = true
+         */
+
+        std::string linkageName( Spec );
+
+        // To Update: LinkageSpec::isXyz( cur_spec ) -> cur_spec.is_xyz
+        inline bool isMangled( Spec spec ) { return spec.is_mangled; }
+        inline bool isGeneratable( Spec spec ) { return spec.is_generatable; }
+        inline bool isOverridable( Spec spec ) { return spec.is_overridable; }
+        inline bool isBuiltin( Spec spec ) { return spec.is_builtin; }
+
+        // Pre-defined flag combinations:
+        // C built-in defined in prelude
+        constexpr Spec const Intrinsic = { Mangle | Generate | Overrideable | Builtin };
+        // ordinary
+        constexpr Spec const Cforall = { Mangle | Generate };
+        // not overloadable, not mangled
+        constexpr Spec const C = { Generate };
+        // built by translator (struct assignment)
+        constexpr Spec const AutoGen = { Mangle | Generate | Overrideable };
+        // gcc internal
+        constexpr Spec const Compiler = { Builtin };
+        // mangled builtins
+        constexpr Spec const BuiltinCFA = { Mangle | Generate | Builtin };
+        // non-mangled builtins
+        constexpr Spec const BuiltinC = { Generate | Builtin };
 };
 

src/main.cc

@@ -10 +10 @@
 // Author           : Richard C. Bilson
 // Created On       : Fri May 15 23:12:02 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jun 29 12:46:50 2017
-// Update Count     : 441
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Jul  7 11:13:00 2017
+// Update Count     : 442
 //
 
@@ -206 +206 @@
                                 FILE * builtins = fopen( libcfap | treep ? "../prelude/builtins.cf" : CFA_LIBDIR "/builtins.cf", "r" );
                                 assertf( builtins, "cannot open builtins.cf\n" );
-                                parse( builtins, LinkageSpec::Builtin );
+                                parse( builtins, LinkageSpec::BuiltinCFA );
                         } // if
                 } // if