Changes in / [bf4fe05:ec20ab9]


Ignore:
Files:
125 added
123 deleted
90 edited

Legend:

Unmodified
Added
Removed

  • driver/cfa.cc

    rbf4fe05 rec20ab9  
    2626#include <sys/stat.h>
    2727
    28 #include "Common/SemanticError.hpp"
     28#include "Common/SemanticError.h"
    2929#include "config.h"                                                                             // configure info
    3030

  • libcfa/src/enum.cfa

    rbf4fe05 rec20ab9  
    1 #include "enum.hfa"
    2 
    3 #pragma GCC visibility push(default)
    4 
    5 forall(T, E| TypedEnum(T, E)) {
    6     // constructors
    7 
    8     // comparison
    9     int ?==?(E l, E r) { return posE(l) == posE(r); }
    10     int ?!=?(E l, E r) { return posE(l) != posE(r); }
    11     int ?!=?(E l, zero_t) { return !( posE(l) == 0 ); }
    12     int ?<?(E l, E r) { return posE(l) < posE(r); }
    13     int ?<=?(E l, E r) { return posE(l) <= posE(r); }
    14     int ?>?(E l, E r) { return posE(l) > posE(r); }
    15     int ?>=?(E l, E r) {  return posE(l) >= posE(r); }
    16 }

  • libcfa/src/enum.hfa

    rbf4fe05 rec20ab9  
    11#pragma once
    22
    3 forall(T) { // T is the based type of enum(T)
    4     forall(E) trait Bounded {
    5         E lowerBound();
    6         E upperBound();
    7     };
     3forall( E ) trait Bounded {
     4        E lowerBound();
     5        E upperBound();
     6};
    87
    9     forall(E| Bounded(T, E)) trait Serial {
    10         unsigned fromInstance(E e);
    11         E fromInt(unsigned i);
    12         E succ(E e);
    13         E pred(E e);
    14     };
     8forall( E | Bounded( E ) ) trait Serial {
     9        unsigned fromInstance( E e );
     10        E fromInt( unsigned int posn );
     11        E succ( E e );
     12        E pred( E e );
     13};
    1514
    16     // Opague Enum + TypedEnum
    17     forall(E | Serial(T, E)) trait CfaEnum {
    18         char * labelE(E e);
    19         unsigned int posE(E e);
    20     };
     15forall( E, T ) trait TypedEnum {
     16        T valueE( E e );
     17        char * labelE( E e );
     18        unsigned int posE( E e );
     19};
    2120
    22     forall(E| CfaEnum(T, E)) trait TypedEnum {
    23         T valueE(E e);
    24     };
    25 
    26         forall(E | TypedEnum(T, E)) {
    27                 // comparison
    28                 int ?==?(E l, E r);                                                             // true if l and r are same enumerators
    29                 int ?!=?(E l, E r);                                                             // true if l and r are different enumerators
    30                 int ?!=?(E l, zero_t);                                                  // true if l is not the first enumerator
    31                 int ?<?(E l, E r);                                                              // true if l is an enuemerator before r
    32                 int ?<=?(E l, E r);                                                             // true if l before or the same as r
    33                 int ?>?(E l, E r);                                                              // true if l is an enuemrator after r
    34                 int ?>=?(E l, E r);                                                             // true if l after or the same as r
    35         }
     21forall( E, T | TypedEnum( E, T ) ) {
     22        // comparison
     23        int ?==?( E l, E r );                                                           // true if l and r are same enumerators   
     24        int ?!=?( E l, E r );                                                           // true if l and r are different enumerators
     25        int ?!=?( E l, zero_t );                                                        // true if l is not the first enumerator           
     26        int ?<?( E l, E r );                                                            // true if l is an enuemerator before r   
     27        int ?<=?( E l, E r );                                                           // true if l before or the same as r               
     28        int ?>?( E l, E r );                                                            // true if l is an enuemrator after r     
     29        int ?>=?( E l, E r );                                                           // true if l after or the same as r         
    3630}

  • src/AST/Decl.cpp

    rbf4fe05 rec20ab9  
    2020#include <unordered_map>
    2121
    22 #include "Common/Eval.hpp"     // for eval
    23 #include "Common/SemanticError.hpp"
     22#include "Common/Eval.h"       // for eval
     23#include "Common/SemanticError.h"
    2424
    2525#include "Fwd.hpp"             // for UniqueId

  • src/AST/Expr.cpp

    rbf4fe05 rec20ab9  
    2727#include "Type.hpp"
    2828#include "TypeSubstitution.hpp"
    29 #include "Common/Utility.hpp"
    30 #include "Common/SemanticError.hpp"
    31 #include "GenPoly/Lvalue.hpp"      // for referencesPermissable
    32 #include "ResolvExpr/Unify.hpp"    // for extractResultType
    33 #include "Tuples/Tuples.hpp"       // for makeTupleType
     29#include "Common/utility.h"
     30#include "Common/SemanticError.h"
     31#include "GenPoly/Lvalue.h"        // for referencesPermissable
     32#include "ResolvExpr/Unify.h"      // for extractResultType
     33#include "Tuples/Tuples.h"         // for makeTupleType
    3434
    3535namespace ast {

  • src/AST/Inspect.cpp

    rbf4fe05 rec20ab9  
    2424#include "AST/Stmt.hpp"
    2525#include "AST/Type.hpp"
    26 #include "CodeGen/OperatorTable.hpp"
     26#include "CodeGen/OperatorTable.h"
    2727
    2828namespace ast {

  • src/AST/Label.hpp

    rbf4fe05 rec20ab9  
    2121
    2222#include "Node.hpp"
    23 #include "Common/CodeLocation.hpp"
     23#include "Common/CodeLocation.h"
    2424
    2525namespace ast {

  • src/AST/LinkageSpec.cpp

    rbf4fe05 rec20ab9  
    2020#include <string>
    2121
    22 #include "Common/CodeLocation.hpp"
    23 #include "Common/SemanticError.hpp"
     22#include "Common/CodeLocation.h"
     23#include "Common/SemanticError.h"
    2424
    2525namespace ast {

  • src/AST/LinkageSpec.hpp

    rbf4fe05 rec20ab9  
    1919
    2020#include "Bitfield.hpp"
    21 #include "Common/CodeLocation.hpp"
     21#include "Common/CodeLocation.h"
    2222
    2323namespace ast {

  • src/AST/Node.hpp

    rbf4fe05 rec20ab9  
    2020#include <iosfwd>
    2121
    22 #include "Common/ErrorObjects.hpp"  // for SemanticErrorException
     22#include "Common/ErrorObjects.h"  // for SemanticErrorException
    2323
    2424namespace ast {

  • src/AST/ParseNode.hpp

    rbf4fe05 rec20ab9  
    1818#include "Node.hpp"
    1919
    20 #include "Common/CodeLocation.hpp"
     20#include "Common/CodeLocation.h"
    2121
    2222namespace ast {

  • src/AST/Pass.hpp

    rbf4fe05 rec20ab9  
    424424}
    425425
    426 #include "Common/Stats.hpp"
     426#include "Common/Stats.h"
    427427
    428428namespace ast {

  • src/AST/Pass.proto.hpp

    rbf4fe05 rec20ab9  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Pass.proto.hpp --
     7// Pass.impl.hpp --
    88//
    99// Author           : Thierry Delisle
    … …  
    1818
    1919#include "Common/Iterate.hpp"
    20 #include "Common/Stats/Heap.hpp"
    21 #include "Common/Utility.hpp"
     20#include "Common/Stats/Heap.h"
     21#include "Common/utility.h"
    2222namespace ast {
    2323        template<typename core_t> class Pass;

  • src/AST/Print.hpp

    rbf4fe05 rec20ab9  
    1919
    2020#include "AST/Fwd.hpp"
    21 #include "Common/Indenter.hpp"
     21#include "Common/Indenter.h"
    2222
    2323namespace ast {

  • src/AST/Stmt.hpp

    rbf4fe05 rec20ab9  
    2424#include "ParseNode.hpp"
    2525#include "Visitor.hpp"
    26 #include "Common/CodeLocation.hpp"
     26#include "Common/CodeLocation.h"
    2727
    2828// Must be included in *all* AST classes; should be #undef'd at the end of the file

  • src/AST/SymbolTable.cpp

    rbf4fe05 rec20ab9  
    2323#include "Inspect.hpp"
    2424#include "Type.hpp"
    25 #include "CodeGen/OperatorTable.hpp"       // for isCtorDtorAssign
    26 #include "Common/SemanticError.hpp"
    27 #include "Common/Stats/Counter.hpp"
    28 #include "GenPoly/GenPoly.hpp"
    29 #include "InitTweak/InitTweak.hpp"
    30 #include "ResolvExpr/Cost.hpp"
     25#include "CodeGen/OperatorTable.h"         // for isCtorDtorAssign
     26#include "Common/SemanticError.h"
     27#include "Common/Stats/Counter.h"
     28#include "GenPoly/GenPoly.h"
     29#include "InitTweak/InitTweak.h"
     30#include "ResolvExpr/Cost.h"
    3131#include "ResolvExpr/CandidateFinder.hpp"  // for referenceToRvalueConversion
    32 #include "ResolvExpr/Unify.hpp"
    33 #include "SymTab/Mangler.hpp"
     32#include "ResolvExpr/Unify.h"
     33#include "SymTab/Mangler.h"
    3434
    3535namespace ast {

  • src/AST/SymbolTable.hpp

    rbf4fe05 rec20ab9  
    2121#include "Fwd.hpp"
    2222#include "Node.hpp"                // for ptr, readonly
    23 #include "Common/CodeLocation.hpp"
    24 #include "Common/PersistentMap.hpp"
     23#include "Common/CodeLocation.h"
     24#include "Common/PersistentMap.h"
    2525
    2626namespace ResolvExpr {

  • src/AST/Type.cpp

    rbf4fe05 rec20ab9  
    2323#include "Init.hpp"
    2424#include "Inspect.hpp"
    25 #include "Common/Utility.hpp"    // for copy, move
    26 #include "Tuples/Tuples.hpp"     // for isTtype
     25#include "Common/utility.h"      // for copy, move
     26#include "Tuples/Tuples.h"       // for isTtype
    2727
    2828namespace ast {

  • src/AST/TypeEnvironment.cpp

    rbf4fe05 rec20ab9  
    2929#include "Print.hpp"
    3030#include "Type.hpp"
    31 #include "Common/Indenter.hpp"
    32 #include "ResolvExpr/Typeops.hpp"    // for occurs
    33 #include "ResolvExpr/WidenMode.hpp"
    34 #include "ResolvExpr/Unify.hpp"      // for unifyInexact
    35 #include "Tuples/Tuples.hpp"         // for isTtype
     31#include "Common/Indenter.h"
     32#include "ResolvExpr/typeops.h"    // for occurs
     33#include "ResolvExpr/WidenMode.h"
     34#include "ResolvExpr/Unify.h"      // for unifyInexact
     35#include "Tuples/Tuples.h"         // for isTtype
    3636#include "CompilationState.hpp"
    3737

  • src/AST/TypeEnvironment.hpp

    rbf4fe05 rec20ab9  
    2828#include "Type.hpp"
    2929#include "TypeSubstitution.hpp"
    30 #include "Common/Indenter.hpp"
    31 #include "ResolvExpr/WidenMode.hpp"
     30#include "Common/Indenter.h"
     31#include "ResolvExpr/WidenMode.h"
    3232
    3333namespace ast {

  • src/AST/TypeSubstitution.cpp

    rbf4fe05 rec20ab9  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // TypeSubstitution.cpp --
     7// TypeSubstitution.cc --
    88//
    99// Author           : Richard C. Bilson

  • src/AST/TypeSubstitution.hpp

    rbf4fe05 rec20ab9  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // TypeSubstitution.hpp --
     7// TypeSubstitution.h --
    88//
    99// Author           : Richard C. Bilson
    … …  
    1616#pragma once
    1717
    18 #include <cassert>                   // for assert
    19 #include <list>                      // for list<>::iterator, _List_iterator
     18#include <cassert>                 // for assert
     19#include <list>                    // for list<>::iterator, _List_iterator
    2020#include <unordered_map>
    2121#include <unordered_set>
    22 #include <string>                    // for string, operator!=
    23 #include <utility>                   // for pair
     22#include <string>                  // for string, operator!=
     23#include <utility>                 // for pair
    2424
    25 #include "Fwd.hpp"                   // for UniqueId
     25#include "Fwd.hpp"        // for UniqueId
    2626#include "ParseNode.hpp"
    2727#include "Type.hpp"
    28 #include "Common/SemanticError.hpp"  // for SemanticError
     28#include "Common/SemanticError.h"  // for SemanticError
    2929#include "Visitor.hpp"
    3030#include "Decl.hpp"

  • src/AST/Util.cpp

    rbf4fe05 rec20ab9  
    2020#include "Pass.hpp"
    2121#include "TranslationUnit.hpp"
    22 #include "Common/Utility.hpp"
    23 #include "GenPoly/ScopedSet.hpp"
     22#include "Common/utility.h"
     23#include "GenPoly/ScopedSet.h"
    2424
    2525#include <vector>

  • src/BasicTypes-gen.cpp

    rbf4fe05 rec20ab9  
    326326
    327327
    328         #define ConversionCost TOP_SRCDIR "src/ResolvExpr/ConversionCost.cpp"
     328        #define ConversionCost TOP_SRCDIR "src/ResolvExpr/ConversionCost.cc"
    329329        resetInput( file, ConversionCost, buffer, code, str );
    330330
    … …  
    405405
    406406
    407         #define CommonType TOP_SRCDIR "src/ResolvExpr/CommonType.cpp"
     407        #define CommonType TOP_SRCDIR "src/ResolvExpr/CommonType.cc"
    408408        resetInput( file, CommonType, buffer, code, str );
    409409
    … …  
    446446
    447447
    448         #define ManglerCommon TOP_SRCDIR "src/SymTab/ManglerCommon.cpp"
     448        #define ManglerCommon TOP_SRCDIR "src/SymTab/ManglerCommon.cc"
    449449        resetInput( file, ManglerCommon, buffer, code, str );
    450450

  • src/CodeGen/CodeGenerator.cpp

    rbf4fe05 rec20ab9  
    1717
    1818#include "AST/Print.hpp"
    19 #include "OperatorTable.hpp"         // for OperatorInfo, operatorLookup
    20 #include "CodeGen/GenType.hpp"       // for genType
     19#include "OperatorTable.h"           // for OperatorInfo, operatorLookup
     20#include "CodeGen/GenType.h"         // for genType
    2121#include "Common/ToString.hpp"       // for toString
    22 #include "Common/UniqueName.hpp"     // for UniqueName
     22#include "Common/UniqueName.h"       // for UniqueName
    2323
    2424namespace CodeGen {

  • src/CodeGen/CodeGenerator.hpp

    rbf4fe05 rec20ab9  
    2020#include "AST/Fwd.hpp"
    2121#include "AST/Pass.hpp"          // for WithGuards, WithShortCircuiting, ...
    22 #include "CodeGen/Options.hpp"   // for Options
    23 #include "Common/Indenter.hpp"   // for Indenter
     22#include "CodeGen/Options.h"     // for Options
     23#include "Common/Indenter.h"     // for Indenter
    2424
    2525

  • src/CodeGen/module.mk

    rbf4fe05 rec20ab9  
    1818        CodeGen/CodeGenerator.cpp \
    1919        CodeGen/CodeGenerator.hpp \
    20         CodeGen/GenType.cpp \
    21         CodeGen/GenType.hpp \
    22         CodeGen/OperatorTable.cpp \
    23         CodeGen/OperatorTable.hpp
     20        CodeGen/GenType.cc \
     21        CodeGen/GenType.h \
     22        CodeGen/OperatorTable.cc \
     23        CodeGen/OperatorTable.h
    2424
    2525SRC += $(SRC_CODEGEN) \
    26         CodeGen/FixMain.cpp \
    27         CodeGen/FixMain.hpp \
    28         CodeGen/FixNames.cpp \
    29         CodeGen/FixNames.hpp \
    30         CodeGen/Generate.cpp \
    31         CodeGen/Generate.hpp \
    32         CodeGen/LinkOnce.cpp \
    33         CodeGen/LinkOnce.hpp \
    34         CodeGen/Options.hpp
     26        CodeGen/Generate.cc \
     27        CodeGen/Generate.h \
     28        CodeGen/FixMain.cc \
     29        CodeGen/FixMain.h \
     30        CodeGen/FixNames.cc \
     31        CodeGen/FixNames.h \
     32        CodeGen/LinkOnce.cc \
     33        CodeGen/LinkOnce.h \
     34        CodeGen/Options.h
    3535
    3636SRCDEMANGLE += $(SRC_CODEGEN)

  • src/Common/CodeLocationTools.cpp

    rbf4fe05 rec20ab9  
    2020#include "AST/Pass.hpp"
    2121#include "AST/TranslationUnit.hpp"
    22 #include "Common/CodeLocation.hpp"
     22#include "Common/CodeLocation.h"
    2323
    2424namespace {

  • src/Common/DeclStats.cpp

    rbf4fe05 rec20ab9  
    1919#include "AST/Pass.hpp"
    2020#include "AST/Print.hpp"
    21 #include "Common/VectorMap.hpp"
     21#include "Common/VectorMap.h"
    2222
    2323#include <iostream>

  • src/Common/ResolvProtoDump.cpp

    rbf4fe05 rec20ab9  
    2626#include "AST/TranslationUnit.hpp"
    2727#include "AST/Type.hpp"
    28 #include "CodeGen/OperatorTable.hpp"
     28#include "CodeGen/OperatorTable.h"
    2929
    3030namespace {

  • src/Common/module.mk

    rbf4fe05 rec20ab9  
    1616
    1717SRC_COMMON = \
    18         Common/Assert.cpp \
    19         Common/CodeLocation.hpp \
     18        Common/Assert.cc \
     19        Common/CodeLocation.h \
    2020        Common/CodeLocationTools.hpp \
    2121        Common/CodeLocationTools.cpp \
    2222        Common/DeclStats.hpp \
    2323        Common/DeclStats.cpp \
    24         Common/ErrorObjects.hpp \
    25         Common/Eval.cpp \
    26         Common/Eval.hpp \
    27         Common/Examine.cpp \
    28         Common/Examine.hpp \
    29         Common/FilterCombos.hpp \
    30         Common/Indenter.hpp \
    31         Common/Indenter.cpp \
     24        Common/ErrorObjects.h \
     25        Common/Eval.cc \
     26        Common/Eval.h \
     27        Common/Examine.cc \
     28        Common/Examine.h \
     29        Common/FilterCombos.h \
     30        Common/Indenter.h \
     31        Common/Indenter.cc \
    3232        Common/Iterate.hpp \
    33         Common/PersistentMap.hpp \
     33        Common/PersistentMap.h \
    3434        Common/ResolvProtoDump.hpp \
    3535        Common/ResolvProtoDump.cpp \
    36         Common/ScopedMap.hpp \
    37         Common/SemanticError.cpp \
    38         Common/SemanticError.hpp \
    39         Common/Stats.hpp \
    40         Common/Stats/Base.hpp \
    41         Common/Stats/Counter.cpp \
    42         Common/Stats/Counter.hpp \
    43         Common/Stats/Heap.cpp \
    44         Common/Stats/Heap.hpp \
    45         Common/Stats/ResolveTime.cpp \
    46         Common/Stats/ResolveTime.hpp \
    47         Common/Stats/Stats.cpp \
    48         Common/Stats/Time.cpp \
    49         Common/Stats/Time.hpp \
     36        Common/ScopedMap.h \
     37        Common/SemanticError.cc \
     38        Common/SemanticError.h \
     39        Common/Stats.h \
     40        Common/Stats/Base.h \
     41        Common/Stats/Counter.cc \
     42        Common/Stats/Counter.h \
     43        Common/Stats/Heap.cc \
     44        Common/Stats/Heap.h \
     45        Common/Stats/ResolveTime.cc \
     46        Common/Stats/ResolveTime.h \
     47        Common/Stats/Stats.cc \
     48        Common/Stats/Time.cc \
     49        Common/Stats/Time.h \
    5050        Common/ToString.hpp \
    51         Common/UniqueName.cpp \
    52         Common/UniqueName.hpp \
    53         Common/Utility.hpp \
    54         Common/VectorMap.hpp
     51        Common/UniqueName.cc \
     52        Common/UniqueName.h \
     53        Common/utility.h \
     54        Common/VectorMap.h
    5555
    5656SRC += $(SRC_COMMON) \
    57         Common/DebugMalloc.cpp
     57        Common/DebugMalloc.cc
    5858
    5959SRCDEMANGLE += $(SRC_COMMON)

  • src/CompilationState.cpp

    rbf4fe05 rec20ab9  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // CompilationState.cpp --
     7// CompilationState.cc --
    88//
    99// Author           : Rob Schluntz

  • src/Concurrency/Corun.cpp

    rbf4fe05 rec20ab9  
    1919#include "AST/Stmt.hpp"
    2020#include "AST/TranslationUnit.hpp"
    21 #include "Common/UniqueName.hpp"
     21#include "Common/UniqueName.h"
    2222using namespace ast;
    2323using namespace std;

  • src/Concurrency/Keywords.cpp

    rbf4fe05 rec20ab9  
    1414//
    1515
    16 #include "Concurrency/Keywords.hpp"
     16#include "Concurrency/Keywords.h"
    1717
    1818#include <iostream>
    … …  
    2626#include "AST/DeclReplacer.hpp"
    2727#include "AST/TranslationUnit.hpp"
    28 #include "CodeGen/OperatorTable.hpp"
    29 #include "Common/Examine.hpp"
    30 #include "Common/Utility.hpp"
    31 #include "Common/UniqueName.hpp"
     28#include "CodeGen/OperatorTable.h"
     29#include "Common/Examine.h"
     30#include "Common/utility.h"
     31#include "Common/UniqueName.h"
    3232#include "ControlStruct/LabelGenerator.hpp"
    33 #include "InitTweak/InitTweak.hpp"
    34 #include "Virtual/Tables.hpp"
     33#include "InitTweak/InitTweak.h"
     34#include "Virtual/Tables.h"
    3535
    3636namespace Concurrency {

  • src/Concurrency/Waitfor.cpp

    rbf4fe05 rec20ab9  
    1414//
    1515
    16 #include "Waitfor.hpp"
     16#include "Waitfor.h"
    1717
    1818#include <string>
    1919
    2020#include "AST/Pass.hpp"
    21 #include "Common/UniqueName.hpp"
    22 #include "InitTweak/InitTweak.hpp"
    23 #include "ResolvExpr/Resolver.hpp"
     21#include "Common/UniqueName.h"
     22#include "InitTweak/InitTweak.h"
     23#include "ResolvExpr/Resolver.h"
    2424
    2525#include "AST/Print.hpp"

  • src/Concurrency/Waituntil.cpp

    rbf4fe05 rec20ab9  
    2424#include "AST/Stmt.hpp"
    2525#include "AST/Type.hpp"
    26 #include "Common/UniqueName.hpp"
     26#include "Common/UniqueName.h"
    2727
    2828using namespace ast;

  • src/Concurrency/Waituntil.hpp

    rbf4fe05 rec20ab9  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Waituntil.hpp --
     7// Waitfor.h --
    88//
    99// Author           : Thierry Delisle

  • src/Concurrency/module.mk

    rbf4fe05 rec20ab9  
    2121        Concurrency/Corun.hpp \
    2222        Concurrency/Keywords.cpp \
    23         Concurrency/Keywords.hpp \
     23        Concurrency/Keywords.h \
    2424        Concurrency/Waitfor.cpp \
    25         Concurrency/Waitfor.hpp \
     25        Concurrency/Waitfor.h \
    2626        Concurrency/Waituntil.cpp \
    2727        Concurrency/Waituntil.hpp

  • src/ControlStruct/ExceptDecl.cpp

    rbf4fe05 rec20ab9  
    1414//
    1515
    16 #include "ExceptDecl.hpp"
     16#include "ExceptDecl.h"
    1717
    1818#include <sstream>
    … …  
    2323#include "AST/Print.hpp"
    2424#include "AST/Type.hpp"
    25 #include "Virtual/Tables.hpp"
     25#include "Virtual/Tables.h"
    2626
    2727namespace ControlStruct {

  • src/ControlStruct/ExceptTranslate.cpp

    rbf4fe05 rec20ab9  
    1414//
    1515
    16 #include "ExceptTranslate.hpp"
     16#include "ExceptTranslate.h"
    1717
    1818#include "AST/Expr.hpp"

  • src/ControlStruct/module.mk

    rbf4fe05 rec20ab9  
    1717SRC += \
    1818        ControlStruct/ExceptDecl.cpp \
    19         ControlStruct/ExceptDecl.hpp \
     19        ControlStruct/ExceptDecl.h \
    2020        ControlStruct/ExceptTranslate.cpp \
    21         ControlStruct/ExceptTranslate.hpp \
     21        ControlStruct/ExceptTranslate.h \
    2222        ControlStruct/FixLabels.cpp \
    2323        ControlStruct/FixLabels.hpp \

  • src/GenPoly/Box.cpp

    rbf4fe05 rec20ab9  
    1414//
    1515
    16 #include "Box.hpp"
     16#include "Box.h"
    1717
    1818#include "AST/Decl.hpp"                // for Decl, FunctionDecl, ...
    … …  
    2424#include "AST/Vector.hpp"              // for vector
    2525#include "AST/GenericSubstitution.hpp" // for genericSubstitution
    26 #include "CodeGen/OperatorTable.hpp"   // for isAssignment
     26#include "CodeGen/OperatorTable.h"     // for isAssignment
    2727#include "Common/Iterate.hpp"          // for group_iterate
    28 #include "Common/ScopedMap.hpp"        // for ScopedMap
     28#include "Common/ScopedMap.h"          // for ScopedMap
    2929#include "Common/ToString.hpp"         // for toCString
    30 #include "Common/UniqueName.hpp"       // for UniqueName
    31 #include "GenPoly/FindFunction.hpp"    // for findFunction
    32 #include "GenPoly/GenPoly.hpp"         // for getFunctionType, ...
    33 #include "GenPoly/Lvalue.hpp"          // for generalizedLvalue
    34 #include "GenPoly/ScopedSet.hpp"       // for ScopedSet
     30#include "Common/UniqueName.h"         // for UniqueName
     31#include "GenPoly/FindFunction.h"      // for findFunction
     32#include "GenPoly/GenPoly.h"           // for getFunctionType, ...
     33#include "GenPoly/Lvalue.h"            // for generalizedLvalue
     34#include "GenPoly/ScopedSet.h"         // for ScopedSet
    3535#include "GenPoly/ScrubTypeVars.hpp"   // for scrubTypeVars, scrubAllTypeVars
    36 #include "ResolvExpr/Unify.hpp"        // for typesCompatible
    37 #include "SymTab/Mangler.hpp"          // for mangle, mangleType
     36#include "ResolvExpr/Unify.h"          // for typesCompatible
     37#include "SymTab/Mangler.h"            // for mangle, mangleType
    3838
    3939namespace GenPoly {

  • src/GenPoly/InstantiateGeneric.cpp

    rbf4fe05 rec20ab9  
    1414//
    1515
    16 #include "InstantiateGeneric.hpp"
     16#include "InstantiateGeneric.h"
    1717
    1818#include <cassert>                     // for assertf, assert
    … …  
    2727#include "AST/TranslationUnit.hpp"     // for TranslationUnit
    2828#include "AST/Vector.hpp"              // for vector
    29 #include "CodeGen/OperatorTable.hpp"   // for isAssignment
    30 #include "Common/ScopedMap.hpp"        // for ScopedMap
    31 #include "Common/UniqueName.hpp"       // for UniqueName
    32 #include "GenPoly/GenPoly.hpp"         // for isPolyType, typesPolyCompatible
     29#include "CodeGen/OperatorTable.h"     // for isAssignment
     30#include "Common/ScopedMap.h"          // for ScopedMap
     31#include "Common/UniqueName.h"         // for UniqueName
     32#include "GenPoly/GenPoly.h"           // for isPolyType, typesPolyCompatible
    3333#include "GenPoly/ScrubTypeVars.hpp"   // for scrubAllTypeVars
    3434#include "ResolvExpr/AdjustExprType.hpp"  // for adjustExprType
    35 #include "ResolvExpr/Unify.hpp"        // for typesCompatible
     35#include "ResolvExpr/Unify.h"          // for typesCompatible
    3636
    3737namespace GenPoly {

  • src/GenPoly/Lvalue.cpp

    rbf4fe05 rec20ab9  
    1414//
    1515
    16 #include "Lvalue.hpp"
     16#include "Lvalue.h"
    1717
    1818#include <set>
    … …  
    2424#include "AST/LinkageSpec.hpp"         // for Linkage
    2525#include "AST/Pass.hpp"
    26 #include "Common/SemanticError.hpp"    // for SemanticWarning
     26#include "Common/SemanticError.h"      // for SemanticWarning
    2727#include "Common/ToString.hpp"         // for toCString
    28 #include "Common/UniqueName.hpp"       // for UniqueName
    29 #include "GenPoly/GenPoly.hpp"         // for genFunctionType
    30 #include "ResolvExpr/Typeops.hpp"      // for typesCompatible
    31 #include "ResolvExpr/Unify.hpp"        // for unify
     28#include "Common/UniqueName.h"         // for UniqueName
     29#include "GenPoly/GenPoly.h"           // for genFunctionType
     30#include "ResolvExpr/typeops.h"        // for typesCompatible
     31#include "ResolvExpr/Unify.h"          // for unify
    3232
    3333#if 0

  • src/GenPoly/ScrubTypeVars.cpp

    rbf4fe05 rec20ab9  
    1616#include "ScrubTypeVars.hpp"
    1717
    18 #include <utility>                        // for pair
     18#include <utility>                      // for pair
    1919
    2020#include "AST/Pass.hpp"
    21 #include "GenPoly.hpp"                    // for mangleType, TyVarMap, align...
    22 #include "GenPoly/ErasableScopedMap.hpp"  // for ErasableScopedMap<>::const_...
    23 #include "SymTab/Mangler.hpp"             // for mangleType
     21#include "GenPoly.h"                    // for mangleType, TyVarMap, alignof...
     22#include "GenPoly/ErasableScopedMap.h"  // for ErasableScopedMap<>::const_it...
     23#include "SymTab/Mangler.h"             // for mangleType
    2424
    2525namespace GenPoly {

  • src/GenPoly/ScrubTypeVars.hpp

    rbf4fe05 rec20ab9  
    1919
    2020#include "AST/Fwd.hpp"        // for Node
    21 #include "GenPoly.hpp"        // for TypeVarMap
     21#include "GenPoly.h"          // for TypeVarMap
    2222
    2323namespace GenPoly {

  • src/GenPoly/Specialize.cpp

    rbf4fe05 rec20ab9  
    1414//
    1515
    16 #include "Specialize.hpp"
     16#include "Specialize.h"
    1717
    1818#include "AST/Copy.hpp"                  // for deepCopy
    … …  
    2020#include "AST/Pass.hpp"                  // for Pass
    2121#include "AST/TypeEnvironment.hpp"       // for OpenVarSet, AssertionSet
    22 #include "Common/UniqueName.hpp"         // for UniqueName
    23 #include "GenPoly/GenPoly.hpp"           // for getFunctionType
    24 #include "ResolvExpr/FindOpenVars.hpp"   // for findOpenVars
     22#include "Common/UniqueName.h"           // for UniqueName
     23#include "GenPoly/GenPoly.h"             // for getFunctionType
     24#include "ResolvExpr/FindOpenVars.h"     // for findOpenVars
    2525
    2626namespace GenPoly {

  • src/GenPoly/module.mk

    rbf4fe05 rec20ab9  
    1616
    1717SRC_GENPOLY = \
    18         GenPoly/GenPoly.cpp \
    19         GenPoly/GenPoly.hpp \
    20         GenPoly/Lvalue2.cpp \
    21         GenPoly/Lvalue.hpp
     18        GenPoly/GenPoly.cc \
     19        GenPoly/GenPoly.h \
     20        GenPoly/Lvalue2.cc \
     21        GenPoly/Lvalue.h
    2222
    2323SRC += $(SRC_GENPOLY) \
    2424        GenPoly/Box.cpp \
    25         GenPoly/Box.hpp \
    26         GenPoly/ErasableScopedMap.hpp \
    27         GenPoly/FindFunction.cpp \
    28         GenPoly/FindFunction.hpp \
     25        GenPoly/Box.h \
     26        GenPoly/ErasableScopedMap.h \
     27        GenPoly/FindFunction.cc \
     28        GenPoly/FindFunction.h \
    2929        GenPoly/InstantiateGeneric.cpp \
    30         GenPoly/InstantiateGeneric.hpp \
     30        GenPoly/InstantiateGeneric.h \
    3131        GenPoly/Lvalue.cpp \
    32         GenPoly/ScopedSet.hpp \
     32        GenPoly/ScopedSet.h \
    3333        GenPoly/ScrubTypeVars.cpp \
    3434        GenPoly/ScrubTypeVars.hpp \
    3535        GenPoly/Specialize.cpp \
    36         GenPoly/Specialize.hpp
     36        GenPoly/Specialize.h
    3737
    3838SRCDEMANGLE += $(SRC_GENPOLY)

  • src/InitTweak/FixInit.cpp

    rbf4fe05 rec20ab9  
    1 #include "FixInit.hpp"
     1#include "FixInit.h"
    22
    33#include <stddef.h>                    // for NULL
    … …  
    2222#include "AST/SymbolTable.hpp"
    2323#include "AST/Type.hpp"
    24 #include "CodeGen/OperatorTable.hpp"   // for isConstructor, isCtorDtor, isD...
    25 #include "Common/SemanticError.hpp"    // for SemanticError
     24#include "CodeGen/OperatorTable.h"     // for isConstructor, isCtorDtor, isD...
     25#include "Common/SemanticError.h"      // for SemanticError
    2626#include "Common/ToString.hpp"         // for toCString
    27 #include "Common/UniqueName.hpp"       // for UniqueName
    28 #include "FixGlobalInit.hpp"           // for fixGlobalInit
    29 #include "GenInit.hpp"                 // for genCtorDtor
    30 #include "GenPoly/GenPoly.hpp"         // for getFunctionType
    31 #include "ResolvExpr/Resolver.hpp"     // for findVoidExpression
    32 #include "ResolvExpr/Unify.hpp"        // for typesCompatible
     27#include "Common/UniqueName.h"         // for UniqueName
     28#include "FixGlobalInit.h"             // for fixGlobalInit
     29#include "GenInit.h"                   // for genCtorDtor
     30#include "GenPoly/GenPoly.h"           // for getFunctionType
     31#include "ResolvExpr/Resolver.h"       // for findVoidExpression
     32#include "ResolvExpr/Unify.h"          // for typesCompatible
    3333#include "SymTab/GenImplicitCall.hpp"  // for genImplicitCall
    3434

  • src/InitTweak/module.mk

    rbf4fe05 rec20ab9  
    1616
    1717SRC_INITTWEAK = \
    18         InitTweak/GenInit.cpp \
    19         InitTweak/GenInit.hpp \
    20         InitTweak/InitTweak.cpp \
    21         InitTweak/InitTweak.hpp
     18        InitTweak/GenInit.cc \
     19        InitTweak/GenInit.h \
     20        InitTweak/InitTweak.cc \
     21        InitTweak/InitTweak.h
    2222
    2323SRC += $(SRC_INITTWEAK) \
    24         InitTweak/FixGlobalInit.cpp \
    25         InitTweak/FixGlobalInit.hpp \
     24        InitTweak/FixGlobalInit.cc \
     25        InitTweak/FixGlobalInit.h \
    2626        InitTweak/FixInit.cpp \
    27         InitTweak/FixInit.hpp
     27        InitTweak/FixInit.h
    2828
    2929SRCDEMANGLE += $(SRC_INITTWEAK)

  • src/MakeLibCfa.cpp

    rbf4fe05 rec20ab9  
    1919#include "AST/Fwd.hpp"
    2020#include "AST/Pass.hpp"
    21 #include "CodeGen/OperatorTable.hpp"
    22 #include "Common/UniqueName.hpp"
     21#include "CodeGen/OperatorTable.h"
     22#include "Common/UniqueName.h"
    2323
    2424namespace LibCfa {

  • src/Makefile.am

    rbf4fe05 rec20ab9  
    5353include Virtual/module.mk
    5454
    55 $(addprefix $(srcdir)/, ResolvExpr/ConversionCost.cpp ResolvExpr/CommonType.cpp SymTab/ManglerCommon.cpp) : $(srcdir)/AST/BasicKind.hpp
     55$(addprefix $(srcdir)/, ResolvExpr/ConversionCost.cc ResolvExpr/CommonType.cc SymTab/ManglerCommon.cc) : $(srcdir)/AST/BasicKind.hpp
    5656
    5757$(srcdir)/AST/BasicKind.hpp : BasicTypes-gen.cpp
    … …  
    6565___driver_cfa_cpp_SOURCES = $(SRC)
    6666___driver_cfa_cpp_LDADD = -ldl $(LIBPROFILER) $(LIBTCMALLOC)
    67 EXTRA_DIST = include/cassert include/optional BasicTypes-gen.cpp
     67EXTRA_DIST = include/cassert include/optional BasicTypes-gen.cc
    6868
    6969AM_CXXFLAGS = @HOST_FLAGS@ -Wno-deprecated -Wall -Wextra -Werror=return-type -DDEBUG_ALL -I./Parser -I$(srcdir)/Parser -I$(srcdir)/include -DYY_NO_INPUT -O3 -g -std=c++17 $(TCMALLOCFLAG)
    … …  
    7373cfa_cpplib_PROGRAMS += $(DEMANGLER)
    7474EXTRA_PROGRAMS = ../driver/demangler
    75 ___driver_demangler_SOURCES = SymTab/demangler.cpp # test driver for the demangler, also useful as a sanity check that libdemangle.a is complete
     75___driver_demangler_SOURCES = SymTab/demangler.cc # test driver for the demangler, also useful as a sanity check that libdemangle.a is complete
    7676___driver_demangler_LDADD = libdemangle.a -ldl                  # yywrap
    7777noinst_LIBRARIES = $(LIBDEMANGLE)

  • src/Parser/RunParser.cpp

    rbf4fe05 rec20ab9  
    1818#include "AST/TranslationUnit.hpp"          // for TranslationUnit
    1919#include "Common/CodeLocationTools.hpp"     // for forceFillCodeLocations
    20 #include "Parser/DeclarationNode.hpp"       // for DeclarationNode, buildList
    21 #include "Parser/TypedefTable.hpp"          // for TypedefTable
     20#include "Parser/DeclarationNode.h"         // for DeclarationNode, buildList
     21#include "Parser/TypedefTable.h"            // for TypedefTable
    2222
    2323// Variables global to the parsing code.

  • src/Parser/lex.ll

    rbf4fe05 rec20ab9  
    4444
    4545#include "config.h"                                                                             // configure info
    46 #include "DeclarationNode.hpp"                          // for DeclarationNode
    47 #include "ExpressionNode.hpp"                           // for LabelNode
    48 #include "InitializerNode.hpp"                          // for InitializerNode
    49 #include "ParseNode.hpp"
    50 #include "ParserTypes.hpp"                              // for Token
    51 #include "StatementNode.hpp"                            // for CondCtl, ForCtrl
    52 #include "TypedefTable.hpp"
     46#include "DeclarationNode.h"                            // for DeclarationNode
     47#include "ExpressionNode.h"                             // for LabelNode
     48#include "InitializerNode.h"                            // for InitializerNode
     49#include "ParseNode.h"
     50#include "ParserTypes.h"                                // for Token
     51#include "StatementNode.h"                              // for CondCtl, ForCtrl
     52#include "TypedefTable.h"
    5353// This (generated) header must come late as it is missing includes.
    5454#include "parser.hh"                                    // generated info

  • src/Parser/module.mk

    rbf4fe05 rec20ab9  
    2020
    2121SRC += \
    22        Parser/DeclarationNode.cpp \
    23        Parser/DeclarationNode.hpp \
    24        Parser/ExpressionNode.cpp \
    25        Parser/ExpressionNode.hpp \
    26        Parser/InitializerNode.cpp \
    27        Parser/InitializerNode.hpp \
     22       Parser/DeclarationNode.cc \
     23       Parser/DeclarationNode.h \
     24       Parser/ExpressionNode.cc \
     25       Parser/ExpressionNode.h \
     26       Parser/InitializerNode.cc \
     27       Parser/InitializerNode.h \
    2828       Parser/lex.ll \
    29        Parser/ParseNode.cpp \
    30        Parser/ParseNode.hpp \
     29       Parser/ParseNode.cc \
     30       Parser/ParseNode.h \
    3131       Parser/parser.yy \
    32        Parser/ParserTypes.hpp \
    33        Parser/ParserUtility.hpp \
     32       Parser/ParserTypes.h \
     33       Parser/parserutility.h \
    3434       Parser/RunParser.cpp \
    3535       Parser/RunParser.hpp \
    36        Parser/StatementNode.cpp \
    37        Parser/StatementNode.hpp \
    38        Parser/TypeData.cpp \
    39        Parser/TypeData.hpp \
    40        Parser/TypedefTable.cpp \
    41        Parser/TypedefTable.hpp
     36       Parser/StatementNode.cc \
     37       Parser/StatementNode.h \
     38       Parser/TypeData.cc \
     39       Parser/TypeData.h \
     40       Parser/TypedefTable.cc \
     41       Parser/TypedefTable.h
    4242
    43 MOSTLYCLEANFILES += \
    44        Parser/lex.cc \
    45        Parser/parser.cc \
    46        Parser/parser.hh \
    47        Parser/parser.output
     43MOSTLYCLEANFILES += Parser/lex.cc Parser/parser.cc Parser/parser.hh Parser/parser.output

  • src/Parser/parser.yy

    rbf4fe05 rec20ab9  
    4848using namespace std;
    4949
    50 #include "DeclarationNode.hpp"                          // for DeclarationNode, ...
    51 #include "ExpressionNode.hpp"                           // for ExpressionNode, ...
    52 #include "InitializerNode.hpp"                          // for InitializerNode, ...
    53 #include "ParserTypes.hpp"
    54 #include "StatementNode.hpp"                            // for build_...
    55 #include "TypedefTable.hpp"
    56 #include "TypeData.hpp"
     50#include "DeclarationNode.h"                            // for DeclarationNode, ...
     51#include "ExpressionNode.h"                             // for ExpressionNode, ...
     52#include "InitializerNode.h"                            // for InitializerNode, ...
     53#include "ParserTypes.h"
     54#include "StatementNode.h"                              // for build_...
     55#include "TypedefTable.h"
     56#include "TypeData.h"
    5757#include "AST/Type.hpp"                                 // for BasicType, BasicKind
    58 #include "Common/SemanticError.hpp"                     // error_str
    59 #include "Common/Utility.hpp"                           // for maybeMoveBuild, maybeBuild, CodeLo...
     58#include "Common/SemanticError.h"                                               // error_str
     59#include "Common/utility.h"                                                             // for maybeMoveBuild, maybeBuild, CodeLo...
    6060
    6161// lex uses __null in a boolean context, it's fine.

  • src/ResolvExpr/Candidate.hpp

    rbf4fe05 rec20ab9  
    2020#include <vector>
    2121
    22 #include "Cost.hpp"
     22#include "Cost.h"
    2323#include "AST/Node.hpp"
    2424#include "AST/TypeEnvironment.hpp"
    25 #include "Common/Indenter.hpp"
     25#include "Common/Indenter.h"
    2626
    2727namespace ast {

  • src/ResolvExpr/CandidateFinder.cpp

    rbf4fe05 rec20ab9  
    1717
    1818#include <deque>
    19 #include <iterator>                 // for back_inserter
     19#include <iterator>               // for back_inserter
    2020#include <sstream>
    2121#include <string>
    … …  
    2525#include "AdjustExprType.hpp"
    2626#include "Candidate.hpp"
    27 #include "CastCost.hpp"             // for castCost
     27#include "CastCost.hpp"           // for castCost
    2828#include "CompilationState.hpp"
    29 #include "ConversionCost.hpp"       // for conversionCast
    30 #include "Cost.hpp"
     29#include "ConversionCost.h"       // for conversionCast
     30#include "Cost.h"
    3131#include "ExplodedArg.hpp"
    3232#include "PolyCost.hpp"
    33 #include "RenameVars.hpp"           // for renameTyVars
    34 #include "Resolver.hpp"
    35 #include "ResolveTypeof.hpp"
     33#include "RenameVars.h"           // for renameTyVars
     34#include "Resolver.h"
     35#include "ResolveTypeof.h"
    3636#include "SatisfyAssertions.hpp"
    3737#include "SpecCost.hpp"
    38 #include "Typeops.hpp"              // for combos
    39 #include "Unify.hpp"
    40 #include "WidenMode.hpp"
     38#include "typeops.h"              // for combos
     39#include "Unify.h"
     40#include "WidenMode.h"
    4141#include "AST/Expr.hpp"
    4242#include "AST/Node.hpp"
    … …  
    4545#include "AST/SymbolTable.hpp"
    4646#include "AST/Type.hpp"
    47 #include "Common/Utility.hpp"       // for move, copy
    48 #include "SymTab/Mangler.hpp"
    49 #include "Tuples/Tuples.hpp"        // for handleTupleAssignment
    50 #include "InitTweak/InitTweak.hpp"  // for getPointerBase
    51 
    52 #include "Common/Stats/Counter.hpp"
     47#include "Common/utility.h"       // for move, copy
     48#include "SymTab/Mangler.h"
     49#include "Tuples/Tuples.h"        // for handleTupleAssignment
     50#include "InitTweak/InitTweak.h"  // for getPointerBase
     51
     52#include "Common/Stats/Counter.h"
    5353
    5454#include "AST/Inspect.hpp"             // for getFunctionName
    … …  
    21382138}
    21392139
     2140// get the valueE(...) ApplicationExpr that returns the enum value
     2141const ast::Expr * getValueEnumCall(
     2142        const ast::Expr * expr,
     2143        const ResolvExpr::ResolveContext & context, const ast::TypeEnvironment & env ) {
     2144                auto callExpr = new ast::UntypedExpr(
     2145                        expr->location, new ast::NameExpr( expr->location, "valueE"), {expr} );
     2146                CandidateFinder finder( context, env );
     2147                finder.find( callExpr );
     2148                CandidateList winners = findMinCost( finder.candidates );
     2149                if (winners.size() != 1) {
     2150                        SemanticError( callExpr, "Ambiguous expression in valueE..." );
     2151                }
     2152                CandidateRef & choice = winners.front();
     2153                return choice->expr;
     2154}
     2155
    21402156const ast::Expr * createCondExpr( const ast::Expr * expr ) {
    21412157        assert( expr );

  • src/ResolvExpr/CandidateFinder.hpp

    rbf4fe05 rec20ab9  
    7070        const ast::Expr * expr, Cost & cost );
    7171
     72/// Get the valueE application that returns the enum's value.
     73const ast::Expr * getValueEnumCall( const ast::Expr * expr,
     74        const ResolveContext & context, const ast::TypeEnvironment & env );
     75
    7276/// Wrap an expression to convert the result to a conditional result.
    7377const ast::Expr * createCondExpr( const ast::Expr * expr );

  • src/ResolvExpr/CandidatePrinter.cpp

    rbf4fe05 rec20ab9  
    2424#include "AST/TranslationUnit.hpp"
    2525#include "ResolvExpr/CandidateFinder.hpp"
    26 #include "ResolvExpr/Resolver.hpp"
     26#include "ResolvExpr/Resolver.h"
    2727
    2828namespace ResolvExpr {

  • src/ResolvExpr/CastCost.hpp

    rbf4fe05 rec20ab9  
    1616#pragma once
    1717
     18#include "ResolvExpr/Cost.h"     // for Cost
     19
    1820namespace ast {
    1921        class SymbolTable;
    … …  
    2325
    2426namespace ResolvExpr {
    25 
    26 class Cost;
    2727
    2828Cost castCost(

  • src/ResolvExpr/CommonType.hpp

    rbf4fe05 rec20ab9  
    1818#include "AST/Fwd.hpp"
    1919#include "AST/TypeEnvironment.hpp"  // for AssertionSet, OpenVarSet
    20 #include "WidenMode.hpp"            // for WidenMode
     20#include "WidenMode.h"              // for WidenMode
    2121
    2222namespace ResolvExpr {

  • src/ResolvExpr/ExplodedArg.cpp

    rbf4fe05 rec20ab9  
    1616#include "ExplodedArg.hpp"
    1717
    18 #include "Tuples/Explode.hpp"   // for Tuples::explode
     18#include "Tuples/Explode.h"   // for Tuples::explode
    1919
    2020namespace ResolvExpr {

  • src/ResolvExpr/ExplodedArg.hpp

    rbf4fe05 rec20ab9  
    1919
    2020#include "Candidate.hpp"            // for Candidate, CandidateList
    21 #include "Cost.hpp"                 // for Cost
     21#include "Cost.h"                   // for Cost
    2222#include "AST/Expr.hpp"
    2323#include "AST/Node.hpp"             // for ptr

  • src/ResolvExpr/SatisfyAssertions.cpp

    rbf4fe05 rec20ab9  
    2828#include "CandidateFinder.hpp"
    2929#include "CommonType.hpp"
    30 #include "Cost.hpp"
    31 #include "RenameVars.hpp"
     30#include "Cost.h"
     31#include "RenameVars.h"
    3232#include "SpecCost.hpp"
    33 #include "Typeops.hpp"
    34 #include "Unify.hpp"
     33#include "typeops.h"
     34#include "Unify.h"
    3535#include "AST/Decl.hpp"
    3636#include "AST/Expr.hpp"
    … …  
    4040#include "AST/SymbolTable.hpp"
    4141#include "AST/TypeEnvironment.hpp"
    42 #include "FindOpenVars.hpp"
    43 #include "Common/FilterCombos.hpp"
    44 #include "Common/Indenter.hpp"
    45 #include "GenPoly/GenPoly.hpp"
    46 #include "SymTab/Mangler.hpp"
     42#include "FindOpenVars.h"
     43#include "Common/FilterCombos.h"
     44#include "Common/Indenter.h"
     45#include "GenPoly/GenPoly.h"
     46#include "SymTab/Mangler.h"
    4747
    4848namespace ResolvExpr {

  • src/ResolvExpr/module.mk

    rbf4fe05 rec20ab9  
    1616
    1717SRC_RESOLVEXPR = \
    18       ResolvExpr/AdjustExprType.cpp \
     18      ResolvExpr/AdjustExprType.cc \
    1919      ResolvExpr/AdjustExprType.hpp \
    2020      ResolvExpr/Candidate.cpp \
    … …  
    2222      ResolvExpr/CandidateFinder.hpp \
    2323      ResolvExpr/Candidate.hpp \
    24       ResolvExpr/CastCost.cpp \
     24      ResolvExpr/CastCost.cc \
    2525      ResolvExpr/CastCost.hpp \
    26       ResolvExpr/CommonType.cpp \
     26      ResolvExpr/CommonType.cc \
    2727      ResolvExpr/CommonType.hpp \
    28       ResolvExpr/ConversionCost.cpp \
    29       ResolvExpr/ConversionCost.hpp \
    30       ResolvExpr/Cost.hpp \
    31       ResolvExpr/CurrentObject.cpp \
    32       ResolvExpr/CurrentObject.hpp \
     28      ResolvExpr/ConversionCost.cc \
     29      ResolvExpr/ConversionCost.h \
     30      ResolvExpr/Cost.h \
     31      ResolvExpr/CurrentObject.cc \
     32      ResolvExpr/CurrentObject.h \
    3333      ResolvExpr/ExplodedArg.cpp \
    3434      ResolvExpr/ExplodedArg.hpp \
    35       ResolvExpr/FindOpenVars.cpp \
    36       ResolvExpr/FindOpenVars.hpp \
    37       ResolvExpr/PolyCost.cpp \
     35      ResolvExpr/FindOpenVars.cc \
     36      ResolvExpr/FindOpenVars.h \
     37      ResolvExpr/PolyCost.cc \
    3838      ResolvExpr/PolyCost.hpp \
    39       ResolvExpr/PtrsAssignable.cpp \
     39      ResolvExpr/PtrsAssignable.cc \
    4040      ResolvExpr/PtrsAssignable.hpp \
    41       ResolvExpr/PtrsCastable.cpp \
     41      ResolvExpr/PtrsCastable.cc \
    4242      ResolvExpr/PtrsCastable.hpp \
    43       ResolvExpr/RenameVars.cpp \
    44       ResolvExpr/RenameVars.hpp \
    45       ResolvExpr/Resolver.cpp \
    46       ResolvExpr/Resolver.hpp \
    47       ResolvExpr/ResolveTypeof.cpp \
    48       ResolvExpr/ResolveTypeof.hpp \
     43      ResolvExpr/RenameVars.cc \
     44      ResolvExpr/RenameVars.h \
     45      ResolvExpr/Resolver.cc \
     46      ResolvExpr/Resolver.h \
     47      ResolvExpr/ResolveTypeof.cc \
     48      ResolvExpr/ResolveTypeof.h \
    4949      ResolvExpr/ResolveMode.hpp \
    5050      ResolvExpr/SatisfyAssertions.cpp \
    5151      ResolvExpr/SatisfyAssertions.hpp \
    52       ResolvExpr/SpecCost.cpp \
     52      ResolvExpr/SpecCost.cc \
    5353      ResolvExpr/SpecCost.hpp \
    54       ResolvExpr/Typeops.hpp \
    55       ResolvExpr/Unify.cpp \
    56       ResolvExpr/Unify.hpp \
    57       ResolvExpr/WidenMode.hpp
     54      ResolvExpr/typeops.h \
     55      ResolvExpr/Unify.cc \
     56      ResolvExpr/Unify.h \
     57      ResolvExpr/WidenMode.h
    5858
    5959SRC += $(SRC_RESOLVEXPR) \

  • src/SymTab/GenImplicitCall.cpp

    rbf4fe05 rec20ab9  
    2323#include "AST/Stmt.hpp"                  // for ExprStmt
    2424#include "AST/Type.hpp"                  // for ArrayType, BasicType, ...
    25 #include "CodeGen/OperatorTable.hpp"     // for isCtorDtor
    26 #include "Common/UniqueName.hpp"         // for UniqueName
    27 #include "Common/Utility.hpp"            // for splice
     25#include "CodeGen/OperatorTable.h"       // for isCtorDtor
     26#include "Common/UniqueName.h"           // for UniqueName
     27#include "Common/utility.h"              // for splice
    2828
    2929namespace SymTab {

  • src/SymTab/GenImplicitCall.hpp

    rbf4fe05 rec20ab9  
    1616#pragma once
    1717
    18 #include "InitTweak/InitTweak.hpp"  // for InitExpander
     18#include "InitTweak/InitTweak.h"  // for InitExpander
    1919
    2020namespace SymTab {

  • src/SymTab/module.mk

    rbf4fe05 rec20ab9  
    1616
    1717SRC_SYMTAB = \
    18         SymTab/FixFunction.cpp \
    19         SymTab/FixFunction.hpp \
     18        SymTab/FixFunction.cc \
     19        SymTab/FixFunction.h \
    2020        SymTab/GenImplicitCall.cpp \
    2121        SymTab/GenImplicitCall.hpp \
    22         SymTab/Mangler.cpp \
    23         SymTab/ManglerCommon.cpp \
    24         SymTab/Mangler.hpp
     22        SymTab/Mangler.cc \
     23        SymTab/ManglerCommon.cc \
     24        SymTab/Mangler.h
    2525
    2626SRC += $(SRC_SYMTAB)
    2727
    2828SRCDEMANGLE += $(SRC_SYMTAB) \
    29         SymTab/Demangle.cpp \
    30         SymTab/Demangle.hpp
     29        SymTab/Demangle.cc \
     30        SymTab/Demangle.h

  • src/Tuples/TupleExpansion.cpp

    rbf4fe05 rec20ab9  
    1414//
    1515
    16 #include "Tuples.hpp"
     16#include "Tuples.h"
    1717
    1818#include "AST/Pass.hpp"
    19 #include "Common/ScopedMap.hpp"
     19#include "Common/ScopedMap.h"
    2020
    2121namespace Tuples {

  • src/Tuples/module.mk

    rbf4fe05 rec20ab9  
    1616
    1717SRC_TUPLES = \
    18         Tuples/Explode.cpp \
    19         Tuples/Explode.hpp \
    20         Tuples/TupleAssignment.cpp \
     18        Tuples/Explode.cc \
     19        Tuples/Explode.h \
     20        Tuples/TupleAssignment.cc \
    2121        Tuples/TupleExpansion.cpp \
    22         Tuples/Tuples.cpp \
    23         Tuples/Tuples.hpp
     22        Tuples/Tuples.cc \
     23        Tuples/Tuples.h
    2424
    2525SRC += $(SRC_TUPLES)

  • src/Validate/Autogen.cpp

    rbf4fe05 rec20ab9  
    1616#include "Autogen.hpp"
    1717
    18 #include <algorithm>                   // for count_if
    19 #include <cassert>                     // for strict_dynamic_cast, assert, a...
    20 #include <iterator>                    // for back_insert_iterator, back_ins...
    21 #include <list>                        // for list, _List_iterator, list<>::...
    22 #include <set>                         // for set, _Rb_tree_const_iterator
    23 #include <utility>                     // for pair
    24 #include <vector>                      // for vector
     18#include <algorithm>               // for count_if
     19#include <cassert>                 // for strict_dynamic_cast, assert, assertf
     20#include <iterator>                // for back_insert_iterator, back_inserter
     21#include <list>                    // for list, _List_iterator, list<>::iter...
     22#include <set>                     // for set, _Rb_tree_const_iterator
     23#include <utility>                 // for pair
     24#include <vector>                  // for vector
    2525
    2626#include "AST/Attribute.hpp"
    … …  
    3434#include "AST/Stmt.hpp"
    3535#include "AST/SymbolTable.hpp"
    36 #include "CodeGen/OperatorTable.hpp"  // for isCtorDtor, isCtorDtorAssign
    37 #include "Common/ScopedMap.hpp"        // for ScopedMap<>::const_iterator, S...
    38 #include "Common/Utility.hpp"          // for cloneAll, operator+
    39 #include "GenPoly/ScopedSet.hpp"       // for ScopedSet, ScopedSet<>::iterator
    40 #include "InitTweak/GenInit.hpp"       // for fixReturnStatements
    41 #include "InitTweak/InitTweak.hpp"     // for isAssignment, isCopyConstructor
     36#include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign
     37#include "Common/ScopedMap.h"      // for ScopedMap<>::const_iterator, Scope...
     38#include "Common/utility.h"        // for cloneAll, operator+
     39#include "GenPoly/ScopedSet.h"     // for ScopedSet, ScopedSet<>::iterator
     40#include "InitTweak/GenInit.h"     // for fixReturnStatements
     41#include "InitTweak/InitTweak.h"   // for isAssignment, isCopyConstructor
    4242#include "SymTab/GenImplicitCall.hpp"  // for genImplicitCall
    43 #include "SymTab/Mangler.hpp"          // for Mangler
     43#include "SymTab/Mangler.h"        // for Mangler
    4444#include "CompilationState.hpp"
    4545

  • src/Validate/CompoundLiteral.cpp

    rbf4fe05 rec20ab9  
    2020#include "AST/Pass.hpp"
    2121#include "AST/TranslationUnit.hpp"
    22 #include "Common/UniqueName.hpp"
     22#include "Common/UniqueName.h"
    2323
    2424namespace Validate {

  • src/Validate/EliminateTypedef.cpp

    rbf4fe05 rec20ab9  
    2121#include "AST/Pass.hpp"
    2222#include "AST/Stmt.hpp"
    23 #include "Common/Utility.hpp"
     23#include "Common/utility.h"
    2424
    2525namespace Validate {

  • src/Validate/EnumAndPointerDecay.cpp

    rbf4fe05 rec20ab9  
    2020#include "AST/Pass.hpp"
    2121#include "AST/Type.hpp"
    22 #include "SymTab/FixFunction.hpp"
     22#include "SymTab/FixFunction.h"
    2323#include "Validate/NoIdSymbolTable.hpp"
    2424

  • src/Validate/FindSpecialDecls.cpp

    rbf4fe05 rec20ab9  
    1414//
    1515
    16 #include "Validate/FindSpecialDecls.hpp"
     16#include "Validate/FindSpecialDecls.h"
    1717
    1818#include "AST/Decl.hpp"

  • src/Validate/FixQualifiedTypes.cpp

    rbf4fe05 rec20ab9  
    2121#include "AST/TranslationUnit.hpp"
    2222#include "Common/ToString.hpp"             // for toString
    23 #include "SymTab/Mangler.hpp"              // for Mangler
     23#include "SymTab/Mangler.h"                // for Mangler
    2424#include "Validate/NoIdSymbolTable.hpp"
    2525

  • src/Validate/FixReturnTypes.cpp

    rbf4fe05 rec20ab9  
    2020#include "AST/Type.hpp"
    2121#include "CodeGen/CodeGenerator.hpp"
    22 #include "ResolvExpr/Unify.hpp"
     22#include "ResolvExpr/Unify.h"
    2323
    2424namespace Validate {

  • src/Validate/ForallPointerDecay.cpp

    rbf4fe05 rec20ab9  
    2020#include "AST/DeclReplacer.hpp"
    2121#include "AST/Pass.hpp"
    22 #include "CodeGen/OperatorTable.hpp"
    23 #include "Common/CodeLocation.hpp"
     22#include "CodeGen/OperatorTable.h"
     23#include "Common/CodeLocation.h"
    2424#include "Common/ToString.hpp"
    25 #include "Common/Utility.hpp"
    26 #include "SymTab/FixFunction.hpp"
     25#include "Common/utility.h"
     26#include "SymTab/FixFunction.h"
    2727
    2828namespace Validate {

  • src/Validate/ImplementEnumFunc.cpp

    rbf4fe05 rec20ab9  
    22#include "AST/Pass.hpp"
    33#include "AST/TranslationUnit.hpp"
    4 #include "CodeGen/OperatorTable.hpp"  // for isCtorDtor, isCtorDtorAssign
    5 #include "InitTweak/InitTweak.hpp"    // for isAssignment, isCopyConstructor
     4#include "CodeGen/OperatorTable.h"  // for isCtorDtor, isCtorDtorAssign
     5#include "InitTweak/InitTweak.h"    // for isAssignment, isCopyConstructor
    66namespace Validate {
    77
    … …  
    2828                  proto_linkage{ast::Linkage::Cforall} {}
    2929
     30        void genAttrFunctions();
     31        void genSuccPredPosn();
     32        // void genSuccPredDecl();
     33
     34        void appendReturnThis(ast::FunctionDecl* decl) {
     35                assert(1 <= decl->params.size());
     36                assert(1 == decl->returns.size());
     37                assert(decl->stmts);
     38
     39                const CodeLocation& location = (decl->stmts->kids.empty())
     40                                                   ? decl->stmts->location
     41                                                   : decl->stmts->kids.back()->location;
     42                const ast::DeclWithType* thisParam = decl->params.front();
     43                decl->stmts.get_and_mutate()->push_back(new ast::ReturnStmt(
     44                        location, new ast::VariableExpr(location, thisParam)));
     45        }
     46        void genAttrStandardFuncs() {
     47                ast::FunctionDecl* (EnumAttrFuncGenerator::*standardProtos[4])()
     48                        const = {&EnumAttrFuncGenerator::genCtorProto,
     49                                         &EnumAttrFuncGenerator::genCopyProto,
     50                                         &EnumAttrFuncGenerator::genDtorProto,
     51                                         &EnumAttrFuncGenerator::genAssignProto};
     52                for (auto& generator : standardProtos) {
     53                        ast::FunctionDecl* decl = (this->*generator)();
     54                        produceForwardDecl(decl);
     55                        genFuncBody(decl);
     56                        if (CodeGen::isAssignment(decl->name)) {
     57                                appendReturnThis(decl);
     58                        }
     59                        produceDecl(decl);
     60                }
     61        }
     62
    3063private:
    3164        const CodeLocation& getLocation() const { return decl->location; }
    … …  
    4073        const ast::Decl* getDecl() const { return decl; }
    4174
    42         // Implement Bounded trait
    43         void genBoundedFunctions();
    44         ast::FunctionDecl* genBoundedProto(const char *) const;
    45         void genBoundedBody(ast::FunctionDecl* func) const;
    46 
    47         // Implement Serial trait
     75        // Implement Bounded trait for enum
     76    void genBoundedFunctions();
     77        // Implement Serial trait for enum
    4878        void genSerialTraitFuncs();
    49         ast::FunctionDecl* genFromIntProto() const;
    50         ast::FunctionDecl* genFromInstanceProto() const;
    51         ast::FunctionDecl* genInstToInstFuncProto(const char* func) const;
    52         void genFromIntBody(ast::FunctionDecl *) const;
    53         void genFromInstanceBody(ast::FunctionDecl *) const;
    54         void genSuccPredBody(ast::FunctionDecl *, const char *) const;
    55 
    56         // Implement TypedEnum trait
    57         void genTypedEnumFuncs();
    58         void genTypedEnumFunction(const ast::EnumAttribute attr);
     79
     80        // Bounded trait
     81        ast::FunctionDecl* genLowerBoundProto() const;
     82        ast::FunctionDecl* genUpperBoundProto() const;
     83        void genLowerBoundBody(ast::FunctionDecl* func) const;
     84        void genUpperBoundBody(ast::FunctionDecl* func) const;
     85
    5986        ast::FunctionDecl* genPosnProto() const;
    6087        ast::FunctionDecl* genLabelProto() const;
    6188        ast::FunctionDecl* genValueProto() const;
    62         void genValueOrLabelBody(
    63                 ast::FunctionDecl* func, ast::ObjectDecl* arrDecl) const;
    64         void genPosnBody(ast::FunctionDecl* func) const;
    65 
     89
     90        // Serial trait
     91        ast::FunctionDecl* genFromIntProto() const;
     92        ast::FunctionDecl* genFromInstanceProto() const;
     93        ast::FunctionDecl* genSuccProto() const;
     94        ast::FunctionDecl* genPredProto() const;
     95
     96        void genFromIntBody(ast::FunctionDecl *) const;
     97        void genFromInstanceBody(ast::FunctionDecl *) const;
    6698        ////////////////
     99
     100        ast::FunctionDecl* genSuccPosProto() const;
     101        ast::FunctionDecl* genPredPosProto() const;
    67102
    68103        // ---------------------------------------------------
    … …  
    86121        }
    87122
     123        /// E = EnumAttrType<T>`
     124        /// `void ?{}(E & _dst)`.
     125        ast::FunctionDecl* genCtorProto() const {
     126                return genProto("?{}", {dstParam()}, {});
     127        }
     128
     129        /// void ?{}(E & _dst, E _src)`.
     130        ast::FunctionDecl* genCopyProto() const {
     131                return genProto("?{}", {dstParam(), srcParam()}, {});
     132        }
     133
     134        ///`void ^?{}(E & _dst)`.
     135        ast::FunctionDecl* genDtorProto() const {
     136                // The destructor must be mutex on a concurrent type.
     137                return genProto("^?{}", {dstParam()}, {});
     138        }
     139
     140        /// `E ?{}(E & _dst, E _src)`.
     141        ast::FunctionDecl* genAssignProto() const {
     142                // Only the name is different, so just reuse the generation function.
     143                auto retval = srcParam();
     144                retval->name = "_ret";
     145                return genProto("?=?", {dstParam(), srcParam()}, {retval});
     146        }
     147
     148        void genFuncBody(ast::FunctionDecl* func) {
     149                const CodeLocation& location = func->location;
     150                auto& params = func->params;
     151                if (InitTweak::isCopyConstructor(func) ||
     152                        InitTweak::isAssignment(func)) {
     153                        assert(2 == params.size());
     154                        auto dstParam = params.front().strict_as<ast::ObjectDecl>();
     155                        auto srcParam = params.back().strict_as<ast::ObjectDecl>();
     156                        func->stmts = genCopyBody(location, dstParam, srcParam);
     157                } else {
     158                        assert(1 == params.size());
     159                        // Default constructor and destructor is empty.
     160                        func->stmts = new ast::CompoundStmt(location);
     161                        // Add unused attribute to parameter to silence warnings.
     162                        addUnusedAttribute(params.front());
     163
     164                        // Just an extra step to make the forward and declaration match.
     165                        if (forwards.empty()) return;
     166                        ast::FunctionDecl* fwd = strict_dynamic_cast<ast::FunctionDecl*>(
     167                                forwards.back().get_and_mutate());
     168                        addUnusedAttribute(fwd->params.front());
     169                }
     170        }
     171
     172        const ast::CompoundStmt* genCopyBody( const CodeLocation& location,
     173                        const ast::ObjectDecl* dstParam, const ast::ObjectDecl* srcParam) {
     174                return new ast::CompoundStmt(
     175                        location,
     176                        {new ast::ExprStmt(
     177                                location,
     178                                new ast::UntypedExpr(
     179                                        location, new ast::NameExpr(location, "__builtin_memcpy"),
     180                                        {
     181                                                new ast::AddressExpr( location,
     182                                                        new ast::VariableExpr( location, dstParam ) ),
     183                                                new ast::AddressExpr( location,
     184                                                        new ast::VariableExpr( location, srcParam ) ),
     185                                                new ast::SizeofExpr( location, srcParam->type ),
     186                                        }))});
     187        }
     188
     189        void genDtorBody(ast::FunctionDecl* func) {
     190                const CodeLocation& location = func->location;
     191                auto& params = func->params;
     192                assert(1 == params.size());
     193                func->stmts = new ast::CompoundStmt(location);
     194                addUnusedAttribute(params.front());
     195
     196                // Just an extra step to make the forward and declaration match.
     197                if (forwards.empty()) return;
     198                ast::FunctionDecl* fwd = strict_dynamic_cast<ast::FunctionDecl*>(
     199                        forwards.back().get_and_mutate());
     200                addUnusedAttribute(fwd->params.front());
     201        }
     202
     203        // ast::FunctionDecl*
    88204        // ----------------------------------------------------
     205
     206        ast::FunctionDecl* genSuccPredFunc(bool succ);
    89207
    90208        const ast::Init* getAutoInit(const ast::Init* prev) const;
    … …  
    96214                const ast::EnumAttribute attr, const CodeLocation& location,
    97215                std::vector<ast::ptr<ast::Init>>& inits) const;
     216        void genValueOrLabelBody(
     217                ast::FunctionDecl* func, ast::ObjectDecl* arrDecl) const;
     218        void genPosnBody(ast::FunctionDecl* func) const;
     219        void genAttributesDecls(const ast::EnumAttribute attr);
    98220};
    99221
    … …  
    252374}
    253375
    254 void EnumAttrFuncGenerator::genSuccPredBody(ast::FunctionDecl * func, const char* opt) const {
    255         auto params = func->params;
    256         assert( params.size() == 1 );
    257         auto param = params.front();
    258         auto enumToInt = new ast::CastExpr(
    259                 func->location,
    260                 new ast::VariableExpr(func->location, param),
    261                 new ast::BasicType(ast::BasicKind::UnsignedInt),
    262                 ast::GeneratedFlag::ExplicitCast
    263         );
    264         ast::UntypedExpr* addOneExpr = ast::UntypedExpr::createCall( func->location,
    265                 opt,
    266                 {enumToInt,
    267                 ast::ConstantExpr::from_int(func->location, 1)}
    268         );
    269         auto intToEnum = new ast::CastExpr(
    270                 func->location,
    271                 addOneExpr,
    272                 new ast::EnumInstType( decl ),
    273                 ast::GeneratedFlag::ExplicitCast
    274         );
    275         func->stmts = new ast::CompoundStmt(
    276                 func->location, {
    277                         new ast::ReturnStmt(
    278                                 func->location,
    279                                 intToEnum
    280                         )
    281                 }
    282         );
    283 }
    284 
    285 
    286376void EnumAttrFuncGenerator::genSerialTraitFuncs() {
    287         ast::FunctionDecl * protos[4] = {
    288                 genFromIntProto(),
    289                 genFromInstanceProto(),
    290                 genInstToInstFuncProto("succ"),
    291                 genInstToInstFuncProto("pred")
    292         };
    293         for (auto& proto: protos) produceForwardDecl(proto);
    294         genFromIntBody(protos[0]);
    295         genFromInstanceBody(protos[1]);
    296         genSuccPredBody(protos[2], "?+?");
    297         genSuccPredBody(protos[3], "?-?");
    298         for (auto& proto: protos) produceDecl(proto);
    299 }
    300 
    301 ast::FunctionDecl* EnumAttrFuncGenerator::genInstToInstFuncProto(const char * func) const {
    302         return genProto(
    303                 func,
     377        auto fromIntProto = genFromIntProto();
     378        produceForwardDecl(fromIntProto);
     379        genFromIntBody(fromIntProto);
     380        produceDecl(fromIntProto);
     381
     382        auto fromInstanceProto = genFromInstanceProto();
     383        produceForwardDecl(fromInstanceProto);
     384        genFromInstanceBody(fromInstanceProto);
     385        produceDecl(fromInstanceProto);
     386
     387        auto succProto = genSuccProto();
     388        auto predProto = genPredProto();
     389        produceForwardDecl(succProto);
     390        produceForwardDecl(predProto);
     391}
     392
     393ast::FunctionDecl* EnumAttrFuncGenerator::genSuccProto() const {
     394        return genProto(
     395                "succ",
    304396                {new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))},
    305397                {new ast::ObjectDecl(getLocation(), "_ret",
    … …  
    307399}
    308400
    309 ast::FunctionDecl* EnumAttrFuncGenerator::genBoundedProto(const char * func) const {
    310     return genProto(func, {}, {
     401ast::FunctionDecl* EnumAttrFuncGenerator::genPredProto() const {
     402        return genProto(
     403                "pred",
     404                {new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))},
     405                {new ast::ObjectDecl(getLocation(), "_ret",
     406                                     new ast::EnumInstType(decl))});
     407}
     408
     409ast::FunctionDecl* EnumAttrFuncGenerator::genLowerBoundProto() const {
     410    return genProto("lowerBound", {}, {
    311411        new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))
    312412    });
    313413}
    314414
    315 void EnumAttrFuncGenerator::genBoundedBody(ast::FunctionDecl* func) const {
     415ast::FunctionDecl* EnumAttrFuncGenerator::genUpperBoundProto() const {
     416    return genProto("upperBound", {}, {
     417        new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))
     418    });
     419}
     420
     421void EnumAttrFuncGenerator::genLowerBoundBody(ast::FunctionDecl* func) const {
    316422        const CodeLocation & loc = func->location;
    317         auto mem = func->name=="lowerBound"?  decl->members.front() : decl->members.back();
     423        auto mem = decl->members.front();
     424        // auto expr = new ast::QualifiedNameExpr( loc, decl, mem->name );
     425        // expr->result = new ast::EnumInstType( decl );
    318426        auto expr = new ast::NameExpr( loc, mem->name );
    319427        func->stmts = new ast::CompoundStmt( loc, {new ast::ReturnStmt(loc, expr)});
    320428}
    321429
     430void EnumAttrFuncGenerator::genUpperBoundBody(ast::FunctionDecl* func) const {
     431        const CodeLocation & loc = func->location;
     432        auto mem = decl->members.back();
     433        auto expr = new ast::NameExpr( loc, mem->name );
     434        // expr->result = new ast::EnumInstType( decl );
     435        func->stmts = new ast::CompoundStmt( loc, {new ast::ReturnStmt(loc, expr)});   
     436}
     437
    322438void EnumAttrFuncGenerator::genBoundedFunctions() {
    323         ast::FunctionDecl * boundedProtos[2] = {genBoundedProto("upperBound"), genBoundedProto("lowerBound")};
    324         for (auto & protos: boundedProtos) {
    325                 produceForwardDecl(protos);
    326                 genBoundedBody(protos);
    327                 produceDecl(protos);
    328         }
     439        ast::FunctionDecl * upperDecl = genUpperBoundProto();
     440        produceForwardDecl(upperDecl);
     441        genUpperBoundBody(upperDecl);
     442        produceDecl(upperDecl);
     443
     444        ast::FunctionDecl * lowerDecl = genLowerBoundProto();
     445        produceForwardDecl(lowerDecl);
     446        genLowerBoundBody(lowerDecl);
     447        produceDecl(lowerDecl);
    329448}
    330449
    331450inline ast::EnumAttrType * getPosnType( const ast::EnumDecl * decl ) {
    332451        return new ast::EnumAttrType(new ast::EnumInstType(decl), ast::EnumAttribute::Posn);
     452}
     453
     454ast::FunctionDecl* EnumAttrFuncGenerator::genSuccPosProto() const {
     455        return genProto(
     456                "_successor_",
     457                {new ast::ObjectDecl(getLocation(), "_i", getPosnType(decl))},
     458                {new ast::ObjectDecl(getLocation(), "_ret", getPosnType(decl))}
     459        );
     460}
     461
     462ast::FunctionDecl* EnumAttrFuncGenerator::genPredPosProto() const {
     463        return genProto(
     464                "_predessor_",
     465                {new ast::ObjectDecl(getLocation(), "_i", getPosnType(decl))},
     466                {new ast::ObjectDecl(getLocation(), "_ret", getPosnType(decl))}
     467        );
    333468}
    334469
    … …  
    376511}
    377512
    378 void EnumAttrFuncGenerator::genTypedEnumFunction(const ast::EnumAttribute attr) {
     513void EnumAttrFuncGenerator::genAttributesDecls(const ast::EnumAttribute attr) {
    379514        if (attr == ast::EnumAttribute::Value ||
    380515                attr == ast::EnumAttribute::Label) {
    381                 // TypedEnum's backing arrays
    382516                std::vector<ast::ptr<ast::Init>> inits =
    383517                        attr == ast::EnumAttribute::Value ? genValueInit() : genLabelInit();
    … …  
    400534}
    401535
    402 void EnumAttrFuncGenerator::genTypedEnumFuncs() {
    403         if (decl->base) genTypedEnumFunction(ast::EnumAttribute::Value);
    404         genTypedEnumFunction(ast::EnumAttribute::Label);
    405         genTypedEnumFunction(ast::EnumAttribute::Posn);
     536ast::FunctionDecl* EnumAttrFuncGenerator::genSuccPredFunc(bool succ) {
     537        ast::FunctionDecl* funcDecl = succ ? genSuccPosProto() : genPredPosProto();
     538        produceForwardDecl(funcDecl);
     539
     540        const CodeLocation& location = getLocation();
     541
     542        auto& params = funcDecl->params;
     543        assert(params.size() == 1);
     544        auto param = params.front().strict_as<ast::ObjectDecl>();
     545
     546
     547        auto rets = funcDecl->returns;
     548        assert(params.size() == 1);
     549        auto ret = rets.front().strict_as<ast::ObjectDecl>();
     550        auto retType = ret->type.strict_as<ast::EnumAttrType>();
     551
     552        auto addOneExpr = ast::UntypedExpr::createCall( location,
     553                succ? "?+?": "?-?",
     554                {new ast::VariableExpr(location, param),
     555                ast::ConstantExpr::from_int(location, 1)}
     556        );
     557
     558        funcDecl->stmts = new ast::CompoundStmt(
     559                location, {
     560                        new ast::ReturnStmt(
     561                                location,
     562                                new ast::CastExpr(location, addOneExpr, retType)
     563                        )
     564                }
     565        );
     566
     567        return funcDecl;
     568}
     569
     570void EnumAttrFuncGenerator::genAttrFunctions() {
     571        genAttributesDecls(ast::EnumAttribute::Value);
     572        genAttributesDecls(ast::EnumAttribute::Label);
     573        genAttributesDecls(ast::EnumAttribute::Posn);   
     574}
     575
     576// void EnumAttrFuncGenerator::genSuccPredDecl() {
     577//      auto succProto = genSuccProto();
     578//      auto predProto = genPredProto();
     579
     580//      produceForwardDecl(succProto);
     581//      produceForwardDecl(predProto);
     582// }
     583
     584void EnumAttrFuncGenerator::genSuccPredPosn() {
     585        ast::FunctionDecl* succ = genSuccPredFunc(true);
     586        ast::FunctionDecl* pred = genSuccPredFunc(false);
     587
     588        produceDecl(succ);
     589        produceDecl(pred);
    406590}
    407591
    … …  
    409593        std::list<ast::ptr<ast::Decl>>& decls) {
    410594        // Generate the functions (they go into forwards and definitions).
    411         genTypedEnumFuncs();
     595        genAttrStandardFuncs();
     596        genAttrFunctions();
    412597        genSerialTraitFuncs();
     598        genSuccPredPosn();
     599        // problematic
    413600        genBoundedFunctions();
    414601        // Now export the lists contents.
    … …  
    431618
    432619void ImplementEnumFunc::previsit(const ast::EnumDecl* enumDecl) {
    433         if (!enumDecl->body || !enumDecl->isTyped) return;
     620        if (!enumDecl->body) return;
     621        if (!enumDecl->base) return;
     622
    434623        ast::EnumInstType enumInst(enumDecl->name);
    435624        enumInst.base = enumDecl;
     625
    436626        EnumAttrFuncGenerator gen(enumDecl, &enumInst, functionNesting);
    437627        gen.generateAndAppendFunctions(declsToAddAfter);

  • src/Validate/ReplaceTypedef.cpp

    rbf4fe05 rec20ab9  
    1818#include "AST/Copy.hpp"
    1919#include "AST/Pass.hpp"
    20 #include "Common/ScopedMap.hpp"
    21 #include "Common/UniqueName.hpp"
    22 #include "ResolvExpr/Unify.hpp"
     20#include "Common/ScopedMap.h"
     21#include "Common/UniqueName.h"
     22#include "ResolvExpr/Unify.h"
    2323
    2424namespace Validate {

  • src/Validate/VerifyCtorDtorAssign.cpp

    rbf4fe05 rec20ab9  
    1717
    1818#include "AST/Pass.hpp"
    19 #include "CodeGen/OperatorTable.hpp"
     19#include "CodeGen/OperatorTable.h"
    2020
    2121namespace Validate {

  • src/Validate/module.mk

    rbf4fe05 rec20ab9  
    1616
    1717SRC_VALIDATE = \
    18         Validate/FindSpecialDecls.hpp
     18        Validate/FindSpecialDecls.h
    1919
    2020SRC += $(SRC_VALIDATE) \
    … …  
    4040        Validate/HoistTypeDecls.cpp \
    4141        Validate/HoistTypeDecls.hpp \
    42         Validate/ImplementEnumFunc.cpp \
    43         Validate/ImplementEnumFunc.hpp \
    4442        Validate/InitializerLength.cpp \
    4543        Validate/InitializerLength.hpp \
    … …  
    5452        Validate/ReturnCheck.hpp \
    5553        Validate/VerifyCtorDtorAssign.cpp \
    56         Validate/VerifyCtorDtorAssign.hpp
     54        Validate/VerifyCtorDtorAssign.hpp \
     55        Validate/ReplacePseudoFunc.cpp \
     56        Validate/ReplacePseudoFunc.hpp \
     57        Validate/ImplementEnumFunc.cpp \
     58        Validate/ImplementEnumFunc.hpp
    5759
    5860SRCDEMANGLE += $(SRC_VALIDATE)

  • src/Virtual/module.mk

    rbf4fe05 rec20ab9  
    1616
    1717SRC += \
    18         Virtual/ExpandCasts.cpp \
    19         Virtual/ExpandCasts.hpp \
    20         Virtual/Tables.cpp \
    21         Virtual/Tables.hpp \
     18        Virtual/ExpandCasts.cc \
     19        Virtual/ExpandCasts.h \
     20        Virtual/Tables.cc \
     21        Virtual/Tables.h \
    2222        Virtual/VirtualDtor.cpp \
    2323        Virtual/VirtualDtor.hpp

  • src/include/cassert

    rbf4fe05 rec20ab9  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // cassert --
     7// assert.h --
    88//
    99// Author           : Peter A. Buhr

  • src/include/optional

    rbf4fe05 rec20ab9  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // optional --
     7// optional.h --
    88//
    99// Author           : Michael L. Brooks

  • src/main.cpp

    rbf4fe05 rec20ab9  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // main.cpp --
     7// main.cc --
    88//
    99// Author           : Peter Buhr and Rob Schluntz
    … …  
    3535#include "CompilationState.hpp"
    3636#include "../config.h"                      // for CFA_LIBDIR
    37 #include "CodeGen/FixMain.hpp"              // for FixMain
    38 #include "CodeGen/FixNames.hpp"             // for fixNames
    39 #include "CodeGen/Generate.hpp"             // for generate
    40 #include "CodeGen/LinkOnce.hpp"             // for translateLinkOnce
     37#include "CodeGen/FixMain.h"                // for FixMain
     38#include "CodeGen/FixNames.h"               // for fixNames
     39#include "CodeGen/Generate.h"               // for generate
     40#include "CodeGen/LinkOnce.h"               // for translateLinkOnce
    4141#include "Common/CodeLocationTools.hpp"     // for forceFillCodeLocations
    4242#include "Common/DeclStats.hpp"             // for printDeclStats
    4343#include "Common/ResolvProtoDump.hpp"       // for dumpAsResolverProto
    44 #include "Common/Stats.hpp"                 // for Stats
    45 #include "Common/Utility.hpp"               // for deleteAll, filter, printAll
     44#include "Common/Stats.h"                   // for Stats
     45#include "Common/utility.h"                 // for deleteAll, filter, printAll
    4646#include "Concurrency/Actors.hpp"           // for implementActors
    4747#include "Concurrency/Corun.hpp"            // for implementCorun
    48 #include "Concurrency/Keywords.hpp"         // for implementMutex, implement...
    49 #include "Concurrency/Waitfor.hpp"          // for generateWaitfor
     48#include "Concurrency/Keywords.h"           // for implementMutex, implement...
     49#include "Concurrency/Waitfor.h"            // for generateWaitfor
    5050#include "Concurrency/Waituntil.hpp"        // for generateWaitUntil
    51 #include "ControlStruct/ExceptDecl.hpp"     // for translateExcept
    52 #include "ControlStruct/ExceptTranslate.hpp"// for translateThrows, translat...
     51#include "ControlStruct/ExceptDecl.h"       // for translateExcept
     52#include "ControlStruct/ExceptTranslate.h"  // for translateThrows, translat...
    5353#include "ControlStruct/FixLabels.hpp"      // for fixLabels
    5454#include "ControlStruct/HoistControlDecls.hpp" //  hoistControlDecls
    55 #include "GenPoly/Box.hpp"                  // for box
    56 #include "GenPoly/InstantiateGeneric.hpp"   // for instantiateGeneric
    57 #include "GenPoly/Lvalue.hpp"               // for convertLvalue
    58 #include "GenPoly/Specialize.hpp"           // for convertSpecializations
    59 #include "InitTweak/FixInit.hpp"            // for fix
    60 #include "InitTweak/GenInit.hpp"            // for genInit
     55#include "GenPoly/Box.h"                    // for box
     56#include "GenPoly/InstantiateGeneric.h"     // for instantiateGeneric
     57#include "GenPoly/Lvalue.h"                 // for convertLvalue
     58#include "GenPoly/Specialize.h"             // for convertSpecializations
     59#include "InitTweak/FixInit.h"              // for fix
     60#include "InitTweak/GenInit.h"              // for genInit
    6161#include "MakeLibCfa.hpp"                   // for makeLibCfa
    6262#include "Parser/RunParser.hpp"             // for buildList, dumpParseTree,...
    6363#include "ResolvExpr/CandidatePrinter.hpp"  // for printCandidates
    6464#include "ResolvExpr/EraseWith.hpp"         // for eraseWith
    65 #include "ResolvExpr/Resolver.hpp"          // for resolve
    66 #include "Tuples/Tuples.hpp"                // for expandMemberTuples, expan...
     65#include "ResolvExpr/Resolver.h"            // for resolve
     66#include "Tuples/Tuples.h"                  // for expandMemberTuples, expan...
    6767#include "Validate/Autogen.hpp"             // for autogenerateRoutines
     68#include "Validate/ImplementEnumFunc.hpp"   // for implementEnumFunc
    6869#include "Validate/CompoundLiteral.hpp"     // for handleCompoundLiterals
    6970#include "Validate/EliminateTypedef.hpp"    // for eliminateTypedef
    7071#include "Validate/EnumAndPointerDecay.hpp" // for decayEnumsAndPointers
    71 #include "Validate/FindSpecialDecls.hpp"    // for findGlobalDecls
     72#include "Validate/FindSpecialDecls.h"      // for findGlobalDecls
    7273#include "Validate/FixQualifiedTypes.hpp"   // for fixQualifiedTypes
    7374#include "Validate/FixReturnTypes.hpp"      // for fixReturnTypes
    … …  
    7677#include "Validate/HoistStruct.hpp"         // for hoistStruct
    7778#include "Validate/HoistTypeDecls.hpp"      // for hoistTypeDecls
    78 #include "Validate/ImplementEnumFunc.hpp"   // for implementEnumFunc
    7979#include "Validate/InitializerLength.hpp"   // for setLengthFromInitializer
    8080#include "Validate/LabelAddressFixer.hpp"   // for fixLabelAddresses
    … …  
    8383#include "Validate/ReturnCheck.hpp"         // for checkReturnStatements
    8484#include "Validate/VerifyCtorDtorAssign.hpp" // for verifyCtorDtorAssign
    85 #include "Virtual/ExpandCasts.hpp"          // for expandCasts
     85#include "Validate/ReplacePseudoFunc.hpp"   // for replacePseudoFunc
     86#include "Virtual/ExpandCasts.h"            // for expandCasts
    8687#include "Virtual/VirtualDtor.hpp"          // for implementVirtDtors
    8788
    … …  
    382383                PASS( "Resolve", ResolvExpr::resolve, transUnit );
    383384                DUMP( exprp, std::move( transUnit ) );
     385                PASS( "Replace Pseudo Func", Validate::replacePseudoFunc, transUnit );
    384386                PASS( "Fix Init", InitTweak::fix, transUnit, buildingLibrary() ); // Here
    385387                PASS( "Erase With", ResolvExpr::eraseWith, transUnit );

  • tests/enum_tests/.expect/voidEnum.txt

    rbf4fe05 rec20ab9  
    1 Two different Opague Enum Should not be the same:
    2 a and b are Not Equal
    3 Default Output:
     1Not Equal
    420
    531
    6 a
    7 b

  • tests/enum_tests/structEnum.cfa

    rbf4fe05 rec20ab9  
    1717};
    1818
    19 PointEnum identity(PointEnum in) {
    20      return in;
    21 }
     19// PointEnum foo(PointEnum in) {
     20//      return in;
     21// }
    2222
    2323// The only valid usage

  • tests/enum_tests/voidEnum.cfa

    rbf4fe05 rec20ab9  
    11#include <fstream.hfa>
    2 #include <enum.hfa>
     2
    33enum() voidEnum {
    44    a, b, c
    … …  
    99};
    1010
    11 char* a[voidEnum] = {
    12     "A",
    13     "B",
    14     "C"
    15 };
     11// void foo (const enum voidEnum & t){}
    1612
    1713int main() {
    1814    enum voidEnum v_1 = a;
    1915    enum voidEnum v_2 = b;
    20     sout | "Two different Opague Enum Should not be the same:";
     16    // foo(b);
     17    // enum voidEnum v_3 = 10;
     18    // Error as int cannot convert to void enum
    2119    if ( v_1 == v_2 ) {
    22         sout | "a and b are Equal" | nl;
     20        sout | "Equal" | nl;
    2321    } else {
    24         sout | "a and b are Not Equal" | nl;
     22        sout | "Not Equal" | nl;
    2523    }
    26     sout | "Default Output:";
    27     sout | a;
    28     sout | b;
    29    
    30     sout | labelE(v_1);
    31     sout | labelE(v_2);
    32 
     24    sout | a | nl;
     25    sout | b | nl;
    3326}
Note: See TracChangeset for help on using the changeset viewer.