Changes in / [3f12158:f32e53e]


Ignore:
Location:
src
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • src/Parser/LinkageSpec.cc

    r3f12158 rf32e53e  
    1010// Created On       : Sat May 16 13:22:09 2015
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Fri Jul  7 11:11:00 2017
    13 // Update Count     : 25
     12// Last Modified On : Wed Jun 28 11:51:00 2017
     13// Update Count     : 24
    1414//
    1515
    … …  
    2222#include "Common/SemanticError.h"
    2323
    24 namespace LinkageSpec {
    25 
    26 Spec linkageCheck( const string * spec ) {
    27         assert( spec );
     24LinkageSpec::Spec LinkageSpec::linkageCheck( const string * spec ) {
    2825        unique_ptr<const string> guard( spec ); // allocated by lexer
    2926        if ( *spec == "\"Cforall\"" ) {
    … …  
    3835}
    3936
    40 Spec linkageUpdate( Spec old_spec, const string * cmd ) {
    41         assert( cmd );
    42         unique_ptr<const string> guard( cmd ); // allocated by lexer
    43         if ( *cmd == "\"Cforall\"" ) {
    44                 old_spec.is_mangled = true;
    45                 return old_spec;
    46         } else if ( *cmd == "\"C\"" ) {
    47                 old_spec.is_mangled = false;
    48                 return old_spec;
    49         } else {
    50                 throw SemanticError( "Invalid linkage specifier " + *cmd );
    51         } // if
     37string LinkageSpec::linkageName( LinkageSpec::Spec linkage ) {
     38        assert( 0 <= linkage && linkage < LinkageSpec::NoOfSpecs );
     39        static const char *linkageKinds[LinkageSpec::NoOfSpecs] = {
     40                "intrinsic", "Cforall", "C", "automatically generated", "compiler built-in", "cfa built-in", "c built-in",
     41        };
     42        return linkageKinds[linkage];
    5243}
    5344
    54 std::string linkageName( Spec linkage ) {
    55     switch ( linkage ) {
    56     case Intrinsic:
    57         return "intrinsic";
    58     case C:
    59         return "C";
    60     case Cforall:
    61         return "Cforall";
    62     case AutoGen:
    63         return "autogenerated cfa";
    64     case Compiler:
    65         return "compiler built-in";
    66     case BuiltinCFA:
    67         return "cfa built-in";
    68     case BuiltinC:
    69         return "c built-in";
    70     default:
    71         return "<unnamed linkage spec>";
    72     }
     45bool LinkageSpec::isMangled( Spec spec ) {
     46        assert( 0 <= spec && spec < LinkageSpec::NoOfSpecs );
     47        static bool decoratable[LinkageSpec::NoOfSpecs] = {
     48                //      Intrinsic,      Cforall,        C,              AutoGen,        Compiler,
     49                        true,           true,           false,  true,           false,
     50                //      Builtin,        BuiltinC,
     51                        true,           false,
     52        };
     53        return decoratable[spec];
    7354}
    7455
    75 } // LinkageSpec
     56bool LinkageSpec::isGeneratable( Spec spec ) {
     57        assert( 0 <= spec && spec < LinkageSpec::NoOfSpecs );
     58        static bool generatable[LinkageSpec::NoOfSpecs] = {
     59                //      Intrinsic,      Cforall,        C,              AutoGen,        Compiler,
     60                        true,           true,           true,   true,           false,
     61                //      Builtin,        BuiltinC,
     62                        true,           true,
     63        };
     64        return generatable[spec];
     65}
     66
     67bool LinkageSpec::isOverridable( Spec spec ) {
     68        assert( spec >= 0 && spec < LinkageSpec::NoOfSpecs );
     69        static bool overridable[LinkageSpec::NoOfSpecs] = {
     70                //      Intrinsic,      Cforall,        C,              AutoGen,        Compiler,
     71                        true,           false,          false,  true,           false,
     72                //      Builtin,        BuiltinC,
     73                        false,          false,
     74        };
     75        return overridable[spec];
     76}
     77
     78bool LinkageSpec::isBuiltin( Spec spec ) {
     79        assert( spec >= 0 && spec < LinkageSpec::NoOfSpecs );
     80        static bool builtin[LinkageSpec::NoOfSpecs] = {
     81                //      Intrinsic,      Cforall,        C,              AutoGen,        Compiler,
     82                        true,           false,          false,  false,          true,
     83                //      Builtin,        BuiltinC,
     84                        true,           true,
     85        };
     86        return builtin[spec];
     87}
    7688
    7789// Local Variables: //

  • src/Parser/LinkageSpec.h

    r3f12158 rf32e53e  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // LinkageSpec.h --
     7// LinkageSpec.h -- 
    88//
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Sat May 16 13:24:28 2015
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Fri Jul  7 11:03:00 2017
    13 // Update Count     : 13
     12// Last Modified On : Wed Jun 28 11:50:00 2017
     13// Update Count     : 12
    1414//
    1515
    … …  
    1919#include <string>
    2020
    21 namespace LinkageSpec {
    22         // All linkage specs are some combination of these flags:
    23         enum {
    24                 Mangle = 1 << 0,
    25                 Generate = 1 << 1,
    26                 Overrideable = 1 << 2,
    27                 Builtin = 1 << 3,
    28 
    29                 NoOfSpecs = 1 << 4,
     21struct LinkageSpec {
     22        enum Spec {
     23                Intrinsic,                                                                              // C built-in defined in prelude
     24                Cforall,                                                                                // ordinary
     25                C,                                                                                              // not overloadable, not mangled
     26                AutoGen,                                                                                // built by translator (struct assignment)
     27                Compiler,                                                                               // gcc internal
     28                Builtin,                                                                                // mangled builtins
     29                BuiltinC,                                                                               // non-mangled builtins
     30                NoOfSpecs
    3031        };
    31 
    32         union Spec {
    33                 unsigned int val;
    34                 struct {
    35                         bool is_mangled : 1;
    36                         bool is_generatable : 1;
    37                         bool is_overridable : 1;
    38                         bool is_builtin : 1;
    39                 };
    40                 constexpr Spec( unsigned int val ) : val( val ) {}
    41                 constexpr Spec( Spec const &other ) : val( other.val ) {}
    42                 // Operators may go here.
    43                 // Supports == and !=
    44                 constexpr operator unsigned int () const { return val; }
    45         };
    46 
    47 
    48         Spec linkageCheck( const std::string * );
    49         // Returns the Spec with the given name (limited to C, Cforall & BuiltinC)
    50         Spec linkageUpdate( Spec old_spec, const std::string * cmd );
    51         /* If cmd = "C" returns a Spec that is old_spec with is_mangled = false
    52          * If cmd = "Cforall" returns old_spec Spec with is_mangled = true
    53          */
    54 
    55         std::string linkageName( Spec );
    56 
    57         // To Update: LinkageSpec::isXyz( cur_spec ) -> cur_spec.is_xyz
    58         inline bool isMangled( Spec spec ) { return spec.is_mangled; }
    59         inline bool isGeneratable( Spec spec ) { return spec.is_generatable; }
    60         inline bool isOverridable( Spec spec ) { return spec.is_overridable; }
    61         inline bool isBuiltin( Spec spec ) { return spec.is_builtin; }
    62 
    63         // Pre-defined flag combinations:
    64         // C built-in defined in prelude
    65         constexpr Spec const Intrinsic = { Mangle | Generate | Overrideable | Builtin };
    66         // ordinary
    67         constexpr Spec const Cforall = { Mangle | Generate };
    68         // not overloadable, not mangled
    69         constexpr Spec const C = { Generate };
    70         // built by translator (struct assignment)
    71         constexpr Spec const AutoGen = { Mangle | Generate | Overrideable };
    72         // gcc internal
    73         constexpr Spec const Compiler = { Builtin };
    74         // mangled builtins
    75         constexpr Spec const BuiltinCFA = { Mangle | Generate | Builtin };
    76         // non-mangled builtins
    77         constexpr Spec const BuiltinC = { Generate | Builtin };
     32 
     33        static Spec linkageCheck( const std::string * );
     34        static std::string linkageName( Spec );
     35 
     36        static bool isMangled( Spec );
     37        static bool isGeneratable( Spec );
     38        static bool isOverridable( Spec );
     39        static bool isBuiltin( Spec );
    7840};
    7941

  • src/main.cc

    r3f12158 rf32e53e  
    1010// Author           : Richard C. Bilson
    1111// Created On       : Fri May 15 23:12:02 2015
    12 // Last Modified By : Andrew Beach
    13 // Last Modified On : Fri Jul  7 11:13:00 2017
    14 // Update Count     : 442
     12// Last Modified By : Peter A. Buhr
     13// Last Modified On : Thu Jun 29 12:46:50 2017
     14// Update Count     : 441
    1515//
    1616
    … …  
    206206                                FILE * builtins = fopen( libcfap | treep ? "../prelude/builtins.cf" : CFA_LIBDIR "/builtins.cf", "r" );
    207207                                assertf( builtins, "cannot open builtins.cf\n" );
    208                                 parse( builtins, LinkageSpec::BuiltinCFA );
     208                                parse( builtins, LinkageSpec::Builtin );
    209209                        } // if
    210210                } // if
Note: See TracChangeset for help on using the changeset viewer.