Changeset 31f4837


Ignore:
Timestamp:
May 13, 2024, 10:26:59 AM (17 months ago)
Author:
JiadaL <j82liang@…>
Branches:
master
Children:
e6f1a4b
Parents:
acb33f15 (diff), ca4f2b2 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

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

Files:
1 deleted
90 edited
123 moved

Legend:

Unmodified
Added
Removed

  • doc/theses/jiada_liang_MMath/CFAenum.tex

    racb33f15 r31f4837  
    1111
    1212C already provides @const@-style aliasing using the unnamed enumerator \see{\VRef{s:TypeName}}, even if the name @enum@ is misleading (@const@ would be better).
    13 Given the existence of this form, it is straightforward to extend it with types other than integers.
     13Given the existence of this form, it is straightforward to extend it with types other than @int@.
    1414\begin{cfa}
    1515enum E { Size = 20u, PI = 3.14159L, Jack = L"John" };
    … …  
    2121
    2222
    23 \section{Enumerator Unscoping}
    24 \label{s:EnumeratorUnscoping}
    25 
    26 In C, unscoped enumerators presents a \newterm{naming problem} when multiple enumeration types appear in the same scope with duplicate enumerator names.
     23\section{Enumerator Visibility}
     24\label{s:EnumeratorVisibility}
     25
     26In C, unscoped enumerators present a \newterm{naming problem} when multiple enumeration types appear in the same scope with duplicate enumerator names.
    2727There is no mechanism in C to resolve these naming conflicts other than renaming one of the duplicates, which may be impossible.
    2828
    … …  
    3333enum E1 { First, Second, Third, Fourth };
    3434enum E2 { @Fourth@, @Third@, @Second@, @First@ }; $\C{// same enumerator names}$
    35 E1 p() { return Third; }                                $\C{// correctly resolved duplicate names}$
     35E1 p() { return Third; }                                $\C{// return}$
    3636E2 p() { return Fourth; }
    3737void foo() {
    … …  
    5454enum RGB @!@ { Red, Green, Blue };
    5555\end{cfa}
    56 Now the enumerators \emph{must} be qualified with the associated enumeration.
     56Now the enumerators \emph{must} be qualified with the associated enumeration type.
    5757\begin{cfa}
    5858Week week = @Week.@Mon;
    … …  
    6868}
    6969\end{cfa}
    70 As in Section~\ref{s:EnumeratorUnscoping}, opening multiple scoped enumerations in a @with@ can result in duplicate enumeration names, but \CFA implicit type resolution and explicit qualification/casting handles ambiguities.
     70As in Section~\ref{s:EnumeratorVisibility}, opening multiple scoped enumerations in a @with@ can result in duplicate enumeration names, but \CFA implicit type resolution and explicit qualification/casting handle ambiguities.
    7171
    7272\section{Enumeration Trait}
    … …  
    344344\end{cfa}
    345345which make @Third == First@ and @Fourth == Second@, causing a compilation error because of duplicase @case@ clauses.
    346 To better match with programmer intuition, \CFA toggles between value and position semantics depneding on the language context.
     346To better match with programmer intuition, \CFA toggles between value and position semantics depending on the language context.
    347347For conditional clauses and switch statments, \CFA uses the robust position implementation.
    348348\begin{cfa}

  • doc/theses/jiada_liang_MMath/background.tex

    racb33f15 r31f4837  
    7474However, it is restricted to integral values.
    7575\begin{clang}
    76 enum { Size = 20, Max = 10, MaxPlus10 = Max + 10, Max10Plus1, Fred = -7 };
     76enum { Size = 20, Max = 10, MaxPlus10 = Max + 10, @Max10Plus1@, Fred = -7 };
    7777\end{clang}
    7878Here, the aliased constants are: 20, 10, 20, 21, and -7.
    7979Direct initialization is by a compile-time expression generating a constant value.
    80 An enumerator without initialization is \newterm{auto-initialized}: from left to right, starting at zero or the next explicitly initialized constant, incrementing by @1@.
     80Indirect initialization (without initialization, @Max10Plus1@) is \newterm{auto-initialized}: from left to right, starting at zero or the next explicitly initialized constant, incrementing by @1@.
    8181Because multiple independent enumerators can be combined, enumerators with the same values can occur.
    8282The enumerators are rvalues, so assignment is disallowed.
    … …  
    8888\begin{cfa}
    8989typedef struct /* unnamed */  { ... } S;
    90 struct /* unnamed */  { ... } x, y, z;                  $\C{// questionable}$
     90struct /* unnamed */  { ... } x, y, z;  $\C{// questionable}$
    9191struct S {
    92         union /* unnamed */ {                                           $\C{// unscoped fields}$
     92        union /* unnamed */ {                           $\C{// unscoped fields}$
    9393                int i;  double d ;  char ch;
    9494        };
    … …  
    107107enum Week {
    108108        Thu@ = 10@, Fri, Sat, Sun,
    109         Mon@ = 0@, Tue, Wed@,@ }; // terminating comma
     109        Mon@ = 0@, Tue, Wed@,@                  $\C{// terminating comma}$
     110};
    110111\end{clang}
    111112Note, the comma in the enumerator list can be a terminator or a separator, allowing the list to end with a dangling comma.\footnote{

  • doc/theses/jiada_liang_MMath/intro.tex

    racb33f15 r31f4837  
    135135
    136136\subsection{Algebraic Data Type}
     137\label{s:AlgebraicDataType}
    137138
    138139An algebraic data type (ADT)\footnote{ADT is overloaded with abstract data type.} is another language feature often linked with enumeration, where an ADT conjoins an arbitrary type, possibly a \lstinline[language=C++]{class} or @union@, and a named constructor.

  • doc/theses/jiada_liang_MMath/relatedwork.tex

    racb33f15 r31f4837  
    1818\end{comment}
    1919
    20 Enumeration-like features exist in many popular programming languages, both past and present, \eg Pascal~\cite{Pascal}, Ada~\cite{Ada}, \Csharp~\cite{Csharp}, OCaml~\cite{OCaml} \CC, Go~\cite{Go}, Haskell~\cite{Haskell}, Java~\cite{Java}, Modula-3~\cite{Modula-3}, Rust~\cite{Rust}, Swift~\cite{Swift}, Python~\cite{Python}.
     20Enumeration-like features exist in many popular programming languages, both past and present, \eg Pascal~\cite{Pascal}, Ada~\cite{Ada}, \Csharp~\cite{Csharp}, OCaml~\cite{OCaml} \CC, Go~\cite{Go}, Haskell~\cite{Haskell}, Java~\cite{Java}, Rust~\cite{Rust}, Swift~\cite{Swift}, Python~\cite{Python}.
    2121Among theses languages, there are a large set of overlapping features, but each language has its own unique extensions and restrictions.
    2222
    … …  
    2424\label{s:Pascal}
    2525
    26 Classic Pascal has the \lstinline[language=Pascal]{const} aliasing declaration binding a name to a constant literal/expression.
     26Classic Pascal introduced the \lstinline[language=Pascal]{const} aliasing declaration binding a name to a constant literal/expression.
    2727\begin{pascal}
    2828const one = 0 + 1;   Vowels = set of (A,E,I,O,U);   NULL = NIL;
    … …  
    6262type Traffic_Light is ( @Red@, Yellow, @Green@ );
    6363\end{ada}
    64 Like \CFA, Ada uses an advanced type-resolution algorithm, including the left-hand side of assignment, to disambiguate among overloaded identifiers.
     64Like \CFA, Ada uses a type-resolution algorithm including the left-hand side of assignmente to disambiguate among overloaded identifiers.
    6565\VRef[Figure]{f:AdaEnumeration} shows how ambiguity is handled using a cast, \ie \lstinline[language=ada]{RGB'(Red)}.
    6666
    … …  
    9797Ada provides an alias mechanism, \lstinline[language=ada]{renames}, for aliasing types, which is useful to shorten package identifiers.
    9898\begin{ada}
    99 OtherRed : RGB renames Red;
     99@OtherRed@ : RGB renames Red;
    100100\end{ada}
    101101which suggests a possible \CFA extension to @typedef@.
    … …  
    160160Hence, the ordering of the enumerators is crucial to provide the necessary ranges.
    161161
    162 An enumeration type can be used in the Ada \lstinline[language=ada]{case} (all enumerators must appear or a default) or iterating constructs.
     162An enumeration type can be used in the Ada \lstinline[language=ada]{case} (all enumerators must appear or a @default@) or iterating constructs.
    163163\begin{cquote}
    164164\setlength{\tabcolsep}{15pt}
    … …  
    241241whereas C @const@ declarations without @static@ are marked @R@.
    242242
    243 The following \CC non-backwards compatible changes are made \see{\cite[\S~7.2]{ANSI98:C++}}.
     243The following \CC non-backwards compatible changes are made \see{\cite[\S~7.2]{ANSI98:c++}}.
    244244\begin{cquote}
    245245Change: \CC objects of enumeration type can only be assigned values of the same enumeration type.
    … …  
    248248\begin{c++}
    249249enum color { red, blue, green };
    250 color c = 1;                                                    $\C{// valid C, invalid C++}$
     250color c = 1;                                                    $\C{// valid C, invalid c++}$
    251251\end{c++}
    252252\textbf{Rationale}: The type-safe nature of \CC. \\
    … …  
    263263enum e { A };
    264264sizeof(A) == sizeof(int)                                $\C{// in C}$
    265 sizeof(A) == sizeof(e)                                  $\C{// in C++}$
     265sizeof(A) == sizeof(e)                                  $\C{// in c++}$
    266266/* and sizeof(int) is not necessary equal to sizeof(e) */
    267267\end{c++}
    … …  
    279279int i = A;    i = e;                                    $\C{// implicit casts to int}$
    280280\end{c++}
    281 \CC{11} added a scoped enumeration, \lstinline[language=c++]{enum class} (or \lstinline[language=c++]{enum struct}), where the enumerators are accessed using type qualification.
     281\CC{11} added a scoped enumeration, \lstinline[language=c++]{enum class} (or \lstinline[language=c++]{enum struct})\footnote{
     282The use of keyword \lstinline[language=c++]{class} is resonable because default visibility is \lstinline[language=c++]{private} (scoped).
     283However, default visibility for \lstinline[language=c++]{struct} is \lstinline[language=c++]{public} (unscoped) making it an odd choice.},
     284where the enumerators are accessed using type qualification.
    282285\begin{c++}
    283286enum class E { A, B, C };
    … …  
    291294E e = A;    e = B;                                              $\C{// direct access}$
    292295\end{c++}
    293 \CC{11} added the ability to explicitly declare the underlying \emph{integral} type for \lstinline[language=c++]{enum class}.
     296\CC{11} added the ability to explicitly declare only an underlying \emph{integral} type for \lstinline[language=c++]{enum class}.
    294297\begin{c++}
    295298enum class RGB @: long@ { Red, Green, Blue };
    … …  
    302305char ch = rgb::Red;   ch = crgb;                $\C{// error}$
    303306\end{c++}
    304 Finally, enumerations can be used in the @switch@ statement but there is no mechanism to iterate through an enumeration.
    305 An enumeration type cannot declare an array dimension but can be used as a subscript.
    306 There is no mechanism to subtype or inherit from enumerations.
     307An enumeration can be used in the @if@ and @switch@ statements.
     308\begin{cquote}
     309\setlength{\tabcolsep}{15pt}
     310\begin{tabular}{@{}ll@{}}
     311\begin{c++}
     312if ( @day@ <= Fri )
     313        cout << "weekday" << endl;
     314
     315
     316
     317
     318\end{c++}
     319&
     320\begin{c++}
     321switch ( @day@ ) {
     322  case Mon: case Tue: case Wed: case Thu: case Fri:
     323        cout << "weekday" << endl; break;
     324  case Sat: case Sun:
     325        cout << "weekend" << endl; break;
     326}
     327\end{c++}
     328\end{tabular}
     329\end{cquote}
     330However, there is no mechanism to iterate through an enumeration without an unsafe cast and it does not understand the enumerator values.
     331\begin{c++}
     332enum Week { Mon, Tue, Wed, Thu = 10, Fri, Sat, Sun };
     333for ( Week d = Mon; d <= Sun; d = @(Week)(d + 1)@ ) cout << d << ' ';
     3340 1 2 @3 4 5 6 7 8 9@ 10 11 12 13
     335\end{c++}
     336An enumeration type cannot declare an array dimension but an enumerator can be used as a subscript.
     337There is no mechanism to subtype or inherit from an enumeration.
    307338
    308339
    … …  
    311342
    312343% https://www.tutorialsteacher.com/codeeditor?cid=cs-mk8Ojx
    313 
    314 \Csharp is a dynamically-typed programming-language with a scoped, integral enumeration-type similar to the C/\CC enumeration.
     344% https://learn.microsoft.com/en-us/dotnet/api/system.enum?view=net-8.0
     345% https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/enums
     346
     347\Csharp is a dynamically-typed programming-language with a scoped, integral enumeration similar to \CC \lstinline[language=C++]{enum class}.
    315348\begin{csharp}
    316 enum Weekday : byte { Mon, Tue, Wed, Thu@ = 10@, Fri, Sat, Sun@,@ };
     349enum Week : @long@ { Mon, Tue, Wed, Thu@ = 10@, Fri, Sat, Sun@,@ } // terminating comma
     350enum RGB { Red, Green, Blue }
    317351\end{csharp}
    318 The default underlying type is @int@, with auto-incrementing, implicit/explicit initialization, terminator comma, and optional integral typing (default @int@).
    319 A method cannot be defined in an enumeration type.
    320 As well, there is an explicit bidirectional conversion between an enumeration and its integral type, and an implicit conversion to the enumerator label in display contexts.
     352The default underlying integral type is @int@ (no @char@), with auto-incrementing, implicit/explicit initialization, and terminating comma.
     353A method cannot be defined in an enumeration type (extension methods are possible).
     354There is an explicit bidirectional conversion between an enumeration and its integral type, and an implicit conversion to the enumerator label in display contexts.
    321355\begin{csharp}
    322 int day = (int)Weekday.Fri;             $\C{// day == 10}$
    323 Weekday weekday = (Weekdays)42;         $\C{// weekday == 42, logically invalid}$
    324 Console.WriteLine( Weekday.Fri ); $\C{// print Fri}$
    325 string mon = Weekday.Mon.ToString(); $\C{// mon == "Mon"}$
     356int iday = (int)Week.Fri;                       $\C{// day == 11}$
     357Week day = @(Week)@42;                          $\C{// day == 42, unsafe}$
     358string mon = Week.Mon.ToString();       $\C{// mon == "Mon"}$
     359RGB rgb = RGB.Red;                                      $\C{// rgb == "Red"}$
     360day = @(Week)@rgb;                                      $\C{// day == "Mon", unsafe}$
     361Console.WriteLine( Week.Fri );          $\C{// print label Fri}$
    326362\end{csharp}
    327 
    328 The @Enum.GetValues@ pseudo-method retrieves an array of the enumeration constants for looping over an enumeration type or variable (expensive operation).
     363The majority of the integral operators (relational and arithmetic) work with enumerations, except @*@ and @/@.
    329364\begin{csharp}
    330 foreach ( Weekday constant in @Enum.GetValues@( typeof(Weekday) ) ) {
    331         Console.WriteLine( constant + " " + (int)constant ); // label, position
    332 }
     365day = day++ - 5;                                        $\C{// unsafe}$
     366day = day & day;
    333367\end{csharp}
    334368
    335 The @Flags@ attribute creates a bit-flags enumeration, allowing bitwise operators @&@, @|@, @~@ (complement), @^@ (xor).
     369An enumeration can be used in the @if@ and @switch@ statements.
     370\begin{cquote}
     371\setlength{\tabcolsep}{15pt}
     372\begin{tabular}{@{}ll@{}}
    336373\begin{csharp}
    337 @[Flags]@ public enum Weekday {
    338         None = 0x0, Mon = 0x1, Tue = 0x2, Wed = 0x4,
    339         Thu = 0x8, Fri = 0x10, Sat = 0x20, Sun = 0x40,
    340         Weekend = @Sat | Sun@,
    341         Weekdays = @Mon | Tue | Wed | Thu | Fri@
    342 }
    343 Weekday meetings = @Weekday.Mon | Weekday.Wed@; // 0x5
    344 \end{csharp}
    345 
    346 \VRef[Figure]{CsharpFreeVersusClass} shows an enumeration with free routines for manipulation, and embedding the enumeration and operations into an enumeration class.
    347 The key observation is that an enumeration class is just a structuring mechanism without any additional semantics.
    348 
    349 % https://learn.microsoft.com/en-us/dotnet/api/system.enum?view=net-8.0
    350 
    351 \begin{figure}
    352 \centering
    353 \begin{tabular}{@{}l|l@{}}
    354 \multicolumn{1}{@{}c|}{non-object oriented} & \multicolumn{1}{c@{}}{object oriented} \\
    355 \hline
    356 \begin{csharp}
    357 public class Program {
    358 
    359         enum Weekday {
    360                 Mon, Tue, Wed, Thu, Fri, Sat, Sun };
    361 
    362         static bool isWeekday( Weekday wd ) {
    363                 return wd <= Weekday.Fri;
    364         }
    365         static bool isWeekend( Weekday wd ) {
    366                 return Weekday.Sat <= wd;
    367         }
    368 
    369 
    370         public static void Main() {
    371                 Weekday day = Weekday.Sat;
    372 
    373                 Console.WriteLine( isWeekday( day ) );
    374                 Console.WriteLine( isWeekend( day ) );
    375         }
    376 }
     374if ( @day@ <= Week.Fri )
     375        Console.WriteLine( "weekday" );
     376
     377
     378
     379
     380
    377381\end{csharp}
    378382&
    379383\begin{csharp}
    380 public class Program {
    381         public @class@ WeekDay : Enumeration {
    382                 public enum Day {
    383                                 Mon, Tue, Wed, Thu, Fri, Sat, Sun };
    384                 public enum Day2 : Day {
    385                                 XXX, YYY };
    386                 Day day;
    387                 public bool isWeekday() {
    388                         return day <= Day.Fri;
    389                 }
    390                 public bool isWeekend() {
    391                         return day > Day.Fri;
    392                 }
    393                 public WeekDay( Day d ) { day = d; }
    394         }
    395         public static void Main() {
    396                 WeekDay cday = new
    397                                 WeekDay( WeekDay.Day.Sat );
    398                 Console.WriteLine( cday.isWeekday() );
    399                 Console.WriteLine( cday.isWeekend() );
    400         }
     384switch ( @day@ ) {
     385  case Week.Mon: case Week.Tue: case Week.Wed:
     386  case Week.Thu: case Week.Fri:
     387        Console.WriteLine( "weekday" ); break;
     388  case Week.Sat: case Week.Sun:
     389        Console.WriteLine( "weekend" ); break;
    401390}
    402391\end{csharp}
    403392\end{tabular}
    404 \caption{\Csharp: Free Routine Versus Class Enumeration}
    405 \label{CsharpFreeVersusClass}
    406 \end{figure}
     393\end{cquote}
     394However, there is no mechanism to iterate through an enumeration without an unsafe cast to increment and positions versus values is not handled.
     395\begin{csharp}
     396for ( Week d = Mon; d <= Sun; @d += 1@ ) {
     397        Console.Write( d + " " );
     398}
     399Mon Tue Wed @3 4 5 6 7 8 9@ Thu Fri Sat Sun
     400\end{csharp}
     401The @Enum.GetValues@ pseudo-method retrieves an array of the enumeration constants for looping over an enumeration type or variable (expensive operation).
     402\begin{csharp}
     403foreach ( Week d in @Enum.GetValues@( typeof(Week) ) ) {
     404        Console.WriteLine( d + " " + (int)d + " " ); // label, position
     405}
     406Mon 0, Tue 1, Wed 2, Thu 10, Fri 11, Sat 12, Sun 13,
     407\end{csharp}
     408
     409An enumeration type cannot declare an array dimension but an enumerator can be used as a subscript.
     410There is no mechanism to subtype or inherit from an enumeration.
     411
     412The @Flags@ attribute creates a bit-flags enumeration, making bitwise operators @&@, @|@, @~@ (complement), @^@ (xor) sensible.
     413\begin{csharp}
     414@[Flags]@ public enum Week {
     415        None = 0x0, Mon = 0x1, Tue = 0x2, Wed = 0x4,
     416        Thu = 0x8, Fri = 0x10, Sat = 0x20, Sun = 0x40,
     417        Weekdays = @Mon | Tue | Wed | Thu | Fri@ $\C{// Weekdays == 0x1f}$
     418        Weekend = @Sat | Sun@,                  $\C{// Weekend == 0x60}$
     419}
     420Week meetings = @Week.Mon | Week.Wed@; $\C{// 0x5}$
     421\end{csharp}
    407422
    408423
    409424\section{Golang}
    410425
    411 Golang provides pseudo-enumeration similar to classic Pascal \lstinline[language=pascal]{const}, binding a name to a constant literal/expression.
     426Golang has a no enumeration.
     427It has @const@ aliasing declarations, similar to \CC \see{\VRef{s:C++RelatedWork}}, for basic types with type inferencing and static initialization (constant expression).
    412428\begin{Go}
    413 const ( R = 0; G; B )                                   $\C{// implicit: 0 0 0}$
    414 const ( Fred = "Fred"; Mary = "Mary"; Jane = "Jane" ) $\C{// explicit: Fred Mary Jane}$
     429const R @int@ = 0;  const G @uint@ = 1;  const B = 2; $\C{// explicit typing and type inferencing}$
     430const Fred = "Fred";  const Mary = "Mary";  const Jane = "Jane";
     431const S = 0;  const T = 0;
     432const USA = "USA";  const U = "USA";
     433const V = 3.1;  const W = 3.1;
     434\end{Go}
     435Since these declarations are unmutable variables, they are unscoped and Golang has no overloading.
     436
     437Golang provides an enumeration-like feature to group together @const@ declaration into a block and introduces a form of auto-initialization.
     438\begin{Go}
     439const ( R = 0; G; B )                                   $\C{// implicit initialization: 0 0 0}$
     440const ( Fred = "Fred"; Mary = "Mary"; Jane = "Jane" ) $\C{// explicit initialization: Fred Mary Jane}$
    415441const ( S = 0; T; USA = "USA"; U; V = 3.1; W ) $\C{// type change, implicit/explicit: 0 0 USA USA 3.1 3.1}$
    416442\end{Go}
    417 Constant identifiers are unscoped and must be unique (no overloading).
    418 The first enumerator \emph{must} be explicitly initialized;
    419 subsequent enumerators can be implicitly or explicitly initialized.
    420 Implicit initialization is the previous (predecessor) enumerator value.
    421 
    422 Auto-incrementing is supported by the keyword \lstinline[language=Go]{iota}, available only in the \lstinline[language=Go]{const} declaration.
    423 The \lstinline[language=Go]{iota} is a \emph{per \lstinline[language=golang]{const} declaration} integer counter, starting at zero and implicitly incremented by one for each \lstinline[language=golang]{const} identifier (enumerator).
     443The first identifier \emph{must} be explicitly initialized;
     444subsequent identifiers can be implicitly or explicitly initialized.
     445Implicit initialization is the \emph{previous} (predecessor) identifier value.
     446
     447Each @const@ declaration provides an implicit integer counter starting at zero, called \lstinline[language=Go]{iota}.
     448Using \lstinline[language=Go]{iota} outside of a @const@ block always sets the identifier to zero.
     449\begin{Go}
     450const R = iota;                                                 $\C{// 0}$
     451\end{Go}
     452Inside a @const@ block, \lstinline[language=Go]{iota} is implicitly incremented for each \lstinline[language=golang]{const} identifier and used to initialize the next uninitialized identifier.
    424453\begin{Go}
    425454const ( R = @iota@; G; B )                              $\C{// implicit: 0 1 2}$
    … …  
    430459const ( O1 = iota + 1; @_@; O3; @_@; O5 ) // 1, 3, 5
    431460\end{Go}
    432 Auto-incrementing stops after an explicit initialization.
     461Auto-initialization reverts from \lstinline[language=Go]{iota} to the previous value after an explicit initialization, but auto-incrementing of \lstinline[language=Go]{iota} continues.
    433462\begin{Go}
    434463const ( Mon = iota; Tue; Wed; // 0, 1, 2
    435         @Thu = 10@; Fri; Sat; Sun ) // 10, 10, 10, 10
     464                @Thu = 10@; Fri; Sat; Sun = itoa ) // 10, 10, 10, 6
    436465\end{Go}
    437 Auto-incrementing can be restarted with an expression containing \emph{one} \lstinline[language=Go]{iota}.
     466Auto-initialization from \lstinline[language=Go]{iota} is restarted and \lstinline[language=Go]{iota} reinitialized with an expression containing as most \emph{one} \lstinline[language=Go]{iota}.
    438467\begin{Go}
    439 const ( V1 = iota; V2; @V3 = 7;@ V4 = @iota@; V5 ) // 0 1 7 3 4
     468const ( V1 = iota; V2; @V3 = 7;@ V4 = @iota@ + 1; V5 ) // 0 1 7 4 5
    440469const ( Mon = iota; Tue; Wed; // 0, 1, 2
    441         @Thu = 10;@ Fri = @iota - Wed + Thu - 1@; Sat; Sun ) // 10, 11, 12, 13
     470                @Thu = 10;@ Fri = @iota - Wed + Thu - 1@; Sat; Sun ) // 10, 11, 12, 13
    442471\end{Go}
    443 Note, \lstinline[language=Go]{iota} is advanced for an explicitly initialized enumerator, like the underscore @_@ identifier.
     472Here, @V4@ and @Fri@ restart auto-incrementing from \lstinline[language=Go]{iota} and reset \lstinline[language=Go]{iota} to 4 and 11, respectively, because of the intialization expressions containing \lstinline[language=Go]{iota}.
     473Note, because \lstinline[language=Go]{iota} is incremented for an explicitly initialized identifier or @_@,
     474at @Fri@ \lstinline[language=Go]{iota} is 4 requiring the minus one to compute the value for @Fri@.
    444475
    445476Basic switch and looping are possible.
    446477\begin{cquote}
    447 \setlength{\tabcolsep}{15pt}
     478\setlength{\tabcolsep}{20pt}
    448479\begin{tabular}{@{}ll@{}}
    449480\begin{Go}
    450 day := Mon;
    451 switch day {
     481day := Mon;     // := $\(\Rightarrow\)$ type inferencing
     482switch @day@ {
    452483  case Mon, Tue, Wed, Thu, Fri:
    453484        fmt.Println( "weekday" );
    … …  
    459490\begin{Go}
    460491
    461 for i := Mon; i <= Sun; i += 1 {
     492for i := @Mon@; i <= @Sun@; i += 1 {
    462493        fmt.Println( i )
    463494}
    … …  
    470501However, the loop prints the values from 0 to 13 because there is no actual enumeration.
    471502
     503A constant variable can be used as an array dimension or a subscript.
     504\begin{Go}
     505var ar[@Sun@] int
     506ar[@Mon@] = 3
     507\end{Go}
     508
    472509
    473510\section{Java}
    474511
    475 Every enumeration in Java is an enumeration class.
    476 For a basic enumeration
     512Java provides an enumeration using a specialized class.
     513A basic Java enumeration is an opaque enumeration, where the enumerators are constants.
    477514\begin{Java}
    478 enum Weekday { Mon, Tue, Wed, Thu, Fri, Sat, Sun };
    479 Weekday day = Weekday.Sat;
     515enum Week {
     516        Mon, Tue, Wed, Thu, Fri, Sat, Sun;
     517}
     518Week day = Week.Sat;
    480519\end{Java}
    481 the scoped enumerators are an ordered list of @final@ methods of type integer, ordered left to right starting at 0, increasing by 1.
    482 The value of an enumeration instance is restricted to the enumeration's enumerators.
    483 There is an implicit @int@ variable in the enumeration used to store the value of an enumeration instance.
    484 The position (ordinal) and label are accessible, where the value is the same as the position.
     520The enumerators members are scoped and cannot be made \lstinline[language=java]{public}, hence require qualification.
     521The value of an enumeration instance is restricted to its enumerators.
     522
     523The position (ordinal) and label are accessible but there is no value.
    485524\begin{Java}
    486 System.out.println( day.!ordinal()! + " " + day.!name()! ); // 5 Sat
     525System.out.println( day.!ordinal()! + " " + !day! + " " + day.!name()! );
     5265 Sat Sat
    487527\end{Java}
    488 There is an inverse function @valueOf@ from string to enumerator.
     528Since @day@ has no value, it prints its label (name).
     529The member @valueOf@ is the inverse of @name@ converting a string to enumerator.
    489530\begin{Java}
    490 day = Weekday.valueOf( "Wed" );
     531day = Week.valueOf( "Wed" );
    491532\end{Java}
    492 There are no implicit conversions to/from an enumerator and its underlying type.
    493 Like \Csharp, \VRef[Figure]{f:JavaFreeVersusClass} shows the same example for an enumeration with free routines for manipulation, and embedding the enumeration and operations into an enumeration class.
    494 
    495 \begin{figure}
    496 \centering
    497 \begin{tabular}{@{}l|l@{}}
    498 \multicolumn{1}{@{}c|}{non-object oriented} & \multicolumn{1}{c@{}}{object oriented} \\
    499 \hline
     533Extra members can be added to provide specialized operations.
    500534\begin{Java}
    501 enum Weekday !{!
    502         Mon, Tue, Wed, Thu, Fri, Sat, Sun !}!;
    503 
    504 static boolean isWeekday( Weekday wd ) {
    505         return wd.ordinal() <= Weekday.Fri.ordinal();
    506 }
    507 static boolean isWeekend( Weekday wd ) {
    508         return Weekday.Fri.ordinal() < wd.ordinal();
    509 }
    510 
    511 public static void main( String[] args ) {
    512         Weekday day = Weekday.Sat;
    513         System.out.println( isWeekday( day ) );
    514         System.out.println( isWeekend( day ) );
    515 }
     535public boolean isWeekday() { return !ordinal()! <= Fri.ordinal(); }
     536public boolean isWeekend() { return Fri.ordinal() < !ordinal()!; }
     537\end{Java}
     538Notice the unqualified calls to @ordinal@ in the members implying a \lstinline[language=Java]{this} to some implicit implementation variable, likely an @int@.
     539
     540Enumerator values require an enumeration type (any Java type may be used) and implementation member.
     541\begin{Java}
     542enum Week {
     543        Mon!(1)!, Tue!(2)!, Wed!(3)!, Thu!(4)!, Fri!(5)!, Sat!(6)!, Sun!(7)!; // must appear first
     544        private !long! day;                                     $\C{// enumeration type and implementation member}$
     545        private Week( !long! d ) { day = d; } $\C{// enumerator initialization}$
     546};
     547Week day = Week.Sat;
     548\end{Java}
     549The position, value, and label are accessible.
     550\begin{Java}
     551System.out.println( !day.ordinal()! + " " + !day.day! + " " + !day.name()! );
     5525 6 Sat
     553\end{Java}
     554If the implementation member is \lstinline[language=Java]{public}, the enumeration is unsafe, as any value of the underlying type can be assigned to it, \eg @day = 42@.
     555The implementation constructor must be private since it is only used internally to initialize the enumerators.
     556Initialization occurs at the enumeration-type declaration for each enumerator in the first line.
     557
     558Enumerations can be used in the @if@ and @switch@ statements but only for equality tests.
     559\begin{cquote}
     560\setlength{\tabcolsep}{15pt}
     561\begin{tabular}{@{}ll@{}}
     562\begin{Java}
     563if ( !day! == Week.Fri )
     564        System.out.println( "Fri" );
     565
     566
     567
     568
    516569\end{Java}
    517570&
    518571\begin{Java}
    519 enum Weekday !{!
    520         Mon, Tue, Wed, Thu, Fri, Sat, Sun;
    521 
    522         public boolean isWeekday() {
    523                 return ordinal() <= Weekday.Fri.ordinal();
    524         }
    525         public boolean isWeekend() {
    526                 return Weekday.Fri.ordinal() < ordinal();
    527         }
    528 !}!
    529 public static void main( String[] args ) {
    530         WeekDay day = WeekDay.Sat;
    531         System.out.println( day.isWeekday() );
    532         System.out.println( day.isWeekend() );
     572switch ( !day! ) {
     573  case Mon: case Tue: case Wed: case Thu: case Fri:
     574        System.out.println( "weekday" );  break;
     575  case Sat: case Sun:
     576        System.out.println( "weekend" );  break;
    533577}
    534578\end{Java}
    535579\end{tabular}
    536 \caption{Java: Free Routine Versus Class Enumeration}
    537 \label{f:JavaFreeVersusClass}
    538 \end{figure}
    539 
    540 To explicitly assign enumerator values and/or use a non-@int@ enumeration type (any Java type may be used), the enumeration must specify an explicit type in the enumeration class and a constructor.
     580\end{cquote}
     581Notice enumerators in the @switch@ statement do not require qualification.
     582
     583There are no arithemtic operations on enumerations, so there is no arithmetic way to iterate through an enumeration without making the implementation type \lstinline[language=Java]{public}.
     584Like \Csharp, looping over an enumeration is done using method @values@, which returns an array of enumerator values (expensive operation).
    541585\begin{Java}
    542 enum Weekday {
    543         Mon!(1)!, Tue!(2)!, Wed!(3)!, Thu!(4)!, Fri!(5)!, Sat!(6)!, Sun!(7)!; // must appear first
    544         private !long! day;                                     $\C{// underlying enumeration type}$
    545         private Weekday( !long! d ) { day = d; } $\C{// used to initialize enumerators}$
    546 };
    547 Weekday day = Weekday.Sat;
    548 \end{Java}
    549 If an enumerator initialization is a runtime expression, the expression is executed once at the point the enumeration is declaraed.
    550 
    551 The position, value, and label are accessible.
    552 \begin{Java}
    553 System.out.println( !day.ordinal()! + " " + !day.day! + " " + !day.name()! );  // 5 6 Sat
    554 \end{Java}
    555 The constructor is private so only initialization or assignment can be used to set an enumeration, which ensures only corresponding enumerator values are allowed.
    556 
    557 An enumeration can appear in a @switch@ statement, but no ranges.
    558 \begin{Java}
    559 switch ( day ) {
    560   case Mon: case Tue: case Wed: case Thu: case Fri:
    561         System.out.println( "weekday" );
    562         break;
    563   case Sat: case Sun:
    564         System.out.println( "weekend" );
    565         break;
    566 }
    567 \end{Java}
    568 Like \Csharp, looping over an enumeration is done using method @values@, which returns the array of enumerator values (expensive operation).
    569 \begin{Java}
    570 for ( Weekday iday : Weekday.values() ) {
    571         System.out.print( iday.ordinal() + iday.day + " " +  iday.name() + ",  " );
     586for ( Week d : Week.values() ) {
     587        System.out.print( d.ordinal() + d.day + " " +  d.name() + ",  " );
    572588}
    5735890 1 Mon,  1 2 Tue,  2 3 Wed,  3 4 Thu,  4 5 Fri,  5 6 Sat,  6 7 Sun, 
    574590\end{Java}
    575591
    576 As well, Java provides an @EnumSet@ where the underlying type is an efficient set of bits, one per enumeration \see{\Csharp \lstinline{Flags}, \VRef{s:Csharp}}, providing (logical) operations on groups of enumerators.
     592An enumeration type cannot declare an array dimension nor can an enumerator be used as a subscript.
     593Enumeration inheritence is disallowed because an enumeration is \lstinline[language=Java]{final}.
     594
     595Java provides an @EnumSet@ where the underlying type is an efficient set of bits, one per enumeration \see{\Csharp \lstinline{Flags}, \VRef{s:Csharp}}, providing (logical) operations on groups of enumerators.
    577596There is also a specialized version of @HashMap@ with enumerator keys, which has performance benefits.
    578597
    579 Enumeration inheritence is disallowed because an enumeration is @final@.
    580 
    581 
    582 
    583 \section{Modula-3}
    584 
    585 
    586598
    587599\section{Rust}
     600
    588601% https://doc.rust-lang.org/reference/items/enumerations.html
    589602
    590 Rust provides a scoped enumeration based on variant types.
    591 % An enumeration, also referred to as an enum, is a simultaneous definition of a nominal enumerated type as well as a set of constructors, that can be used to create or pattern-match values of the corresponding enumerated type.
    592 An enumeration without constructors is called field-less.
     603Rust @enum@ provides two largely independent mechanisms: an ADT and an enumeration.
     604When @enum@ is an ADT, pattern matching is used to discriminate among the variant types.
     605\begin{cquote}
     606\sf\setlength{\tabcolsep}{20pt}
     607\begin{tabular}{@{}ll@{}}
    593608\begin{rust}
    594 enum Week { Mon, Tues, Wed, Thu, Fri, Sat, Sun@,@ }
    595 let mut week: Week = Week::Mon;
    596 week = Week::Fri;
     609struct S {
     610        i : isize,  j : isize
     611}
     612enum @ADT@ {
     613        I(isize),   // int
     614        F(f64),   // float
     615        S(S),     // struct
     616}
    597617\end{rust}
    598 A field-less enumeration with only unit variants is called unit-only.
     618&
    599619\begin{rust}
    600 enum Week { Mon = 0, Tues = 1, Wed = 2, Thu = 3, Fri = 4, Sat = 5, Sun = 6 }
     620let mut s = S{ i : 3, j : 4 };
     621let mut adt : ADT;
     622adt = ADT::I(3);  adt = ADT::F(3.5);  adt = ADT::S(s); // init examples
     623@match@ adt {
     624        ADT::I(i) => println!( "{:?}", i ),
     625        ADT::F(f) => println!( "{:?}", f ),
     626        ADT::S(s) => println!( "{:?} {:?}", s.i, s.j ),
     627}
    601628\end{rust}
    602 Enum constructors can have either named or unnamed fields:
    603 \begin{rust}
    604 enum Animal {
    605         Dog( String, f64 ),
    606         Cat{ name: String, weight: f64 },
    607 }
    608 let mut a: Animal = Animal::Dog("Cocoa".to_string(), 37.2);
    609 a = Animal::Cat { name: "Spotty".to_string(), weight: 2.7 };
    610 \end{rust}
    611 Here, @Dog@ is an @enum@ variant, whereas @Cat@ is a struct-like variant.
    612 
    613 Each @enum@ type has an implicit integer tag (discriminant), with a unique value for each variant type.
    614 Like a C enumeration, the tag values for the variant types start at 0 with auto incrementing.
    615 The tag is re-purposed for enumeration by allowing it to be explicitly set, and auto incrmenting continues from that value.
    616 \begin{cquote}
    617 \sf\setlength{\tabcolsep}{3pt}
    618 \begin{tabular}{rcccccccr}
    619 @enum@ Week \{  & Mon,  & Tue,  & Wed = 2,      & Thu = 10,     & Fri,  & Sat = 5,      & Sun   & \};   \\
    620 \rm tags                & 0             & 1             & 2                     & 10            & 11    & 5                     & 6             &               \\
    621629\end{tabular}
    622630\end{cquote}
    623 In general, the tag can only be read as an opaque reference for comparison.
     631When the variant types are the unit type, the ADT is still not an enumeration because there is no enumerating \see{\VRef{s:AlgebraicDataType}}.
    624632\begin{rust}
    625 if mem::discriminant(&week) == mem::discriminant(&Week::Mon) ...
     633enum Week { Mon, Tues, Wed, Thu, Fri, Sat, Sun@,@ } // terminating comma
     634let mut week : Week = Week::Mon;
     635match week {
     636        Week::Mon => println!( "Mon" ),
     637        ...
     638        Week::Sun => println!( "Sun" ),
     639}
    626640\end{rust}
    627 If the enumeration is unit-only, or field-less with no explicit discriminants and where only unit variants are explicit, then the discriminant is accessible with a numeric cast.
     641
     642However, Rust allows direct setting of the ADT constructor, which means it is actually a tag.
     643\begin{cquote}
     644\sf\setlength{\tabcolsep}{15pt}
     645\begin{tabular}{@{}ll@{}}
    628646\begin{rust}
    629 if week as isize == Week::Mon as isize ...
     647enum Week {
     648        Mon, Tues, Wed, // start 0
     649        Thu @= 10@, Fri,
     650        Sat, Sun,
     651}
     652
    630653\end{rust}
     654&
     655\begin{rust}
     656#[repr(u8)]
     657enum ADT {
     658        I(isize) @= 5@,  // ???
     659        F(f64) @= 10@,
     660        S(S) @= 0@,
     661}
     662\end{rust}
     663\end{tabular}
     664\end{cquote}
     665Through this integral tag, it is possible to enumerate, and when all tags represent the unit type, it behaves like \CC \lstinline[language=C++]{enum class}.
     666When tags represent non-unit types, Rust largely precludes accessing the tag because the semantics become meaningless.
     667Hence, the two mechanisms are largely disjoint, and ony the enumeration component is discussed.
     668
     669In detail, the @enum@ type has an implicit integer tag (discriminant), with a unique value for each variant type.
     670Direct initialization is by a compile-time expression generating a constant value.
     671Indirect initialization (without initialization, @Fri@/@Sun@) is auto-initialized: from left to right, starting at zero or the next explicitly initialized constant, incrementing by @1@.
     672There is an explicit cast from the tag to integer.
     673\begin{rust}
     674let mut mon : isize = Week::Mon as isize;
     675\end{rust}
     676An enumeration can be used in the @if@ and \lstinline[language=rust]{match} (@switch@) statements.
     677\begin{cquote}
     678\setlength{\tabcolsep}{8pt}
     679\begin{tabular}{@{}ll@{}}
     680\begin{c++}
     681if @week as isize@ == Week::Mon as isize {
     682        println!( "{:?}", week );
     683}
     684
     685
     686\end{c++}
     687&
     688\begin{c++}
     689match @week@ {
     690        Week::Mon | Week:: Tue | Week::Wed | Week::Thu
     691                | Week::Fri => println!( "weekday" ),
     692        Week::Sat | Week:: Sun => println!( "weekend" ),
     693}
     694\end{c++}
     695\end{tabular}
     696\end{cquote}
     697However, there is no mechanism to iterate through an enumeration without an casting to integral and positions versus values is not handled.
     698\begin{c++}
     699for d in Week::Mon as isize ..= Week::Sun as isize {
     700        print!( "{:?} ", d );
     701}
     7020 1 2 @3 4 5 6 7 8 9@ 10 11 12 13
     703\end{c++}
     704An enumeration type cannot declare an array dimension nor as a subscript.
     705There is no mechanism to subtype or inherit from an enumeration.
    631706
    632707
    … …  
    21622237A basic variant is a list of nullary datatype constructors, which is like an unscoped, opaque enumeration.
    21632238\begin{ocaml}
    2164 type weekday = Mon | Tue | Wed | Thu | Fri | Sat | Sun
    2165 let day : weekday @= Mon@                               $\C{(* bind *)}$
    2166 let take_class( d : weekday ) =
     2239type week = Mon | Tue | Wed | Thu | Fri | Sat | Sun
     2240let day : week @= Mon@                          $\C{(* bind *)}$
     2241let take_class( d : week ) =
    21672242        @match@ d with                                          $\C{(* matching *)}$
    21682243                Mon | Wed -> Printf.printf "CS442\n" |
    … …  
    21752250The only operations are binding and pattern matching (equality), where the variant name is logically the implementation tag stored in the union for discriminating the value in the object storage.
    21762251After compilation, variant names are mapped to an opague ascending intergral type discriminants, starting from 0.
    2177 Here, function @take_class@ has a @weekday@ parameter, and returns @"CS442"@, if the weekday value is @Mon@ or @Wed@, @"CS343"@, if the value is @Tue@ or @Thu@, and @"Tutorial"@ for @Fri@.
    2178 The ``@_@'' is a wildcard matching any @weekday@ value, so the function returns @"Take a break"@ for values @Sat@ or @Sun@, which are not matched by the previous cases.
     2252Here, function @take_class@ has a @week@ parameter, and returns @"CS442"@, if the week value is @Mon@ or @Wed@, @"CS343"@, if the value is @Tue@ or @Thu@, and @"Tutorial"@ for @Fri@.
     2253The ``@_@'' is a wildcard matching any @week@ value, so the function returns @"Take a break"@ for values @Sat@ or @Sun@, which are not matched by the previous cases.
    21792254Since the variant has no type, it has a \newterm{0-arity constructor}, \ie no parameters.
    2180 Because @weekday@ is a union of values @Mon@ to @Sun@, it is a \newterm{union type} in turns of the functional-programming paradigm.
     2255Because @week@ is a union of values @Mon@ to @Sun@, it is a \newterm{union type} in turns of the functional-programming paradigm.
    21812256
    21822257Each variant can have an associated heterogeneous type, with an n-ary constructor for creating a corresponding value.
    … …  
    22422317term "tag" further.
    22432318
    2244 <<Because weekday is a summation of values Mon to Sun, it is a sum type in
     2319<<Because week is a summation of values Mon to Sun, it is a sum type in
    22452320turns of the functional-programming paradigm>>
    22462321
    … …  
    22592334> I've marked 3 places with your name to shows places with enum ordering.
    22602335>
    2261 > type weekday = Mon | Tue | Wed | Thu | Fri | Sat | Sun
    2262 > let day : weekday = Mon
    2263 > let take_class( d : weekday ) =
     2336> type week = Mon | Tue | Wed | Thu | Fri | Sat | Sun
     2337> let day : week = Mon
     2338> let take_class( d : week ) =
    22642339>       if d <= Fri then                                (* Gregor *)
    2265 >               Printf.printf "weekday\n"
     2340>               Printf.printf "week\n"
    22662341>       else if d >= Sat then                   (* Gregor *)
    22672342>               Printf.printf "weekend\n";
    … …  
    24742549loop                    &               &               &               &               &               &               &               &               &               &               &               &               & \CM   \\
    24752550\hline
    2476 array                   &               &               &               &               &               &               &               &               &               &               & \CM   &               & \CM   \\
     2551array/subscript &               &               &               &               &               &               &               &               &               &               & \CM   &               & \CM   \\
    24772552\hline
    24782553subtype                 &               &               &               &               &               &               &               &               &               &               &               &               & \CM   \\

  • doc/theses/mike_brooks_MMath/background.tex

    racb33f15 r31f4837  
    437437class seqnode : public uSeqable { ... }
    438438%]
    439 A node inheriting from @uSeqable@ can appear in a sequence/collection but a node inherting from @uColable@ can only appear in a collection.
     439A node inheriting from @uSeqable@ can appear in a sequence/collection but a node inheriting from @uColable@ can only appear in a collection.
    440440Along with providing the appropriate link fields, the types @uColable@ and @uSeqable@ also provide one member routine:
    441441%[
    … …  
    604604supplying the link fields by inheritance makes them implicit and relies on compiler placement, such as the start or end of @req@.
    605605An example of an explicit attribute is cache alignment of the link fields in conjunction with other @req@ fields, improving locality and/or avoiding false sharing.
    606 Wrapped reference has no control over the link fields, but the seperate data allows some control;
     606Wrapped reference has no control over the link fields, but the separate data allows some control;
    607607wrapped value has no control over data or links.
    608608
    … …  
    690690Each group of intrusive links become the links for each separate STL list.
    691691The upside is the unlimited number of a lists a node can be associated with simultaneously, any number of STL lists can be created dynamically.
    692 The downside is the dynamic allocation of the link nodes and manging multiple lists.
     692The downside is the dynamic allocation of the link nodes and managing multiple lists.
    693693Note, it might be possible to wrap the multiple lists in another type to hide this implementation issue.
    694694
    … …  
    776776\section{String}
    777777
    778 A string is a logical sequence of symbols, where the form of the symbols can vary significantly: 7/8-bit characters (ASCII/Latin-1), or 2/4/8-byte (UNICODE) characters/symbols or variable length (UTF-8/16/32) characters.
     778A string is a sequence of symbols, where the form of a symbol can vary significantly: 7/8-bit characters (ASCII/Latin-1), or 2/4/8-byte (UNICODE) characters/symbols or variable length (UTF-8/16/32) characters.
    779779A string can be read left-to-right, right-to-left, top-to-bottom, and have stacked elements (Arabic).
    780780
    781 An integer character constant is a sequence of one or more multibyte characters enclosed in single-quotes, as in @'x'@.
    782 A wide character constant is the same, except prefixed by the letter @L@, @u@, or @U@.
    783 Except for escape sequences, the elements of the sequence are any members of the source character set;
    784 they are mapped in an implementation-defined manner to members of the execution character set.
    785 
    786 A C character-string literal is a sequence of zero or more multibyte characters enclosed in double-quotes, as in @"xyz"@.
    787 A UTF-8 string literal is the same, except prefixed by @u8@.
    788 A wide string literal is the same, except prefixed by the letter @L@, @u@, or @U@.
    789 
    790 For UTF-8 string literals, the array elements have type @char@, and are initialized with the characters of the multibyte character sequence, as encoded in UTF-8.
    791 For wide string literals prefixed by the letter @L@, the array elements have type @wchar_t@ and are initialized with the sequence of wide characters corresponding to the multibyte character sequence, as defined by the @mbstowcs@ function with an implementation-defined current locale.
    792 For wide string literals prefixed by the letter @u@ or @U@, the array elements have type @char16_t@ or @char32_t@, respectively, and are initialized with the sequence of wide characters corresponding to the multibyte character sequence, as defined by successive calls to the @mbrtoc16@, or @mbrtoc32@ function as appropriate for its type, with an implementation-defined current locale.
     781A C character constant is an ASCII/Latin-1 character enclosed in single-quotes, \eg @'x'@, @'@\textsterling@'@.
     782A wide C character constant is the same, except prefixed by the letter @L@, @u@, or @U@, \eg @u'\u25A0'@ (black square), where the @\u@ identifies a universal character name.
     783A character can be formed from an escape sequence, which expresses a non-typable character (@'\n'@), a delimiter character @'\''@, or a raw character @'\x2f'@.
     784
     785A character sequence is zero or more regular, wide, or escape characters enclosed in double-quotes @"xyz\n"@.
     786The kind of characters in the string is denoted by a prefix: UTF-8 characters are prefixed by @u8@, wide characters are prefixed by @L@, @u@, or @U@.
     787
     788For UTF-8 string literals, the array elements have type @char@ and are initialized with the characters of the multibyte character sequences, \eg @u8"\xe1\x90\x87"@ (Canadian syllabics Y-Cree OO).
     789For wide string literals prefixed by the letter @L@, the array elements have type @wchar_t@ and are initialized with the wide characters corresponding of the multibyte character sequence, \eg @L"abc@$\mu$@"@ and read/print using @wsanf@/@wprintf@.
     790The value of a wide-character is implementation-defined, usually a UTF-16 character.
     791For wide string literals prefixed by the letter @u@ or @U@, the array elements have type @char16_t@ or @char32_t@, respectively, and are initialized with wide characters corresponding to the multibyte character sequence, \eg @u"abc@$\mu$@"@, @U"abc@$\mu$@"@.
     792The value of a @"u"@ character is an UTF-16 character;
     793the value of a @"U"@ character is an UTF-32 character.
    793794The value of a string literal containing a multibyte character or escape sequence not represented in the execution character set is implementation-defined.
    794795
    795 
    796 Another bad C design decision is to have null-terminated strings rather than maintaining a separate string length.
     796C strings are null-terminated rather than maintaining a separate string length.
    797797\begin{quote}
    798798Technically, a string is an array whose elements are single characters.
    … …  
    800800This representation means that there is no real limit to how long a string can be, but programs have to scan one completely to determine its length.
    801801\end{quote}
     802Unfortunately, this design decision is both unsafe and inefficient.
     803It is common error in C to forget the space in a character array for the terminator or overwrite the terminator, resulting in array overruns in string operations.
     804The need to repeatedly scan an entire string to determine its length can result in significant cost, as it is not possible to cache the length in many cases.
     805
     806C strings are fixed size because arrays are used for the implementation.
     807However, string manipulation commonly results in dynamically-sized temporary and final string values.
     808As a result, storage management for C strings is a nightmare, quickly resulting in array overruns and incorrect results.
     809
     810Collectively, these design decisions make working with strings in C, awkward, time consuming, and very unsafe.
     811While there are companion string routines that take the maximum lengths of strings to prevent array overruns, that means the semantics of the operation can fail because strings are truncated.
     812Suffice it to say, C is not a go-to language for string applications, which is why \CC introduced the @string@ type.

  • driver/cfa.cc

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

  • libcfa/src/enum.hfa

    racb33f15 r31f4837  
    2626        forall(E | TypedEnum(T, E)) {
    2727                // comparison
    28                 int ?==?(E l, E r);
    29                 int ?!=?(E l, E r);
    30                 int ?!=?(E l, zero_t);
    31                 int ?<?(E l, E r);
    32                 int ?<=?(E l, E r);
    33                 int ?>?(E l, E r);
    34                 int ?>=?(E l, E r);
     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
    3535        }
    3636}

  • src/AST/Decl.cpp

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

  • src/AST/Expr.cpp

    racb33f15 r31f4837  
    2727#include "Type.hpp"
    2828#include "TypeSubstitution.hpp"
    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
     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
    3434
    3535namespace ast {

  • src/AST/Inspect.cpp

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

  • src/AST/Label.hpp

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

  • src/AST/LinkageSpec.cpp

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

  • src/AST/LinkageSpec.hpp

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

  • src/AST/Node.hpp

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

  • src/AST/ParseNode.hpp

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

  • src/AST/Pass.hpp

    racb33f15 r31f4837  
    423423}
    424424
    425 #include "Common/Stats.h"
     425#include "Common/Stats.hpp"
    426426
    427427namespace ast {

  • src/AST/Pass.proto.hpp

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

  • src/AST/Print.hpp

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

  • src/AST/Stmt.hpp

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

  • src/AST/SymbolTable.cpp

    racb33f15 r31f4837  
    2323#include "Inspect.hpp"
    2424#include "Type.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"
     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"
    3131#include "ResolvExpr/CandidateFinder.hpp"  // for referenceToRvalueConversion
    32 #include "ResolvExpr/Unify.h"
    33 #include "SymTab/Mangler.h"
     32#include "ResolvExpr/Unify.hpp"
     33#include "SymTab/Mangler.hpp"
    3434
    3535namespace ast {

  • src/AST/SymbolTable.hpp

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

  • src/AST/Type.cpp

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

  • src/AST/TypeEnvironment.cpp

    racb33f15 r31f4837  
    2929#include "Print.hpp"
    3030#include "Type.hpp"
    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
     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
    3636#include "CompilationState.hpp"
    3737

  • src/AST/TypeEnvironment.hpp

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

  • src/AST/TypeSubstitution.cpp

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

  • src/AST/TypeSubstitution.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // TypeSubstitution.h --
     7// TypeSubstitution.hpp --
    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.h"  // for SemanticError
     28#include "Common/SemanticError.hpp"  // for SemanticError
    2929#include "Visitor.hpp"
    3030#include "Decl.hpp"

  • src/AST/Util.cpp

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

  • src/BasicTypes-gen.cpp

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

  • src/CodeGen/CodeGenerator.cpp

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

  • src/CodeGen/CodeGenerator.hpp

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

  • src/CodeGen/FixMain.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // FixMain.cc -- Tools to change a Cforall main into a C main.
     7// FixMain.cpp -- Tools to change a Cforall main into a C main.
    88//
    99// Author           : Thierry Delisle
    … …  
    1414//
    1515
    16 #include "FixMain.h"
     16#include "FixMain.hpp"
    1717
    18 #include <cassert>                 // for assert, assertf
    19 #include <fstream>                 // for operator<<, basic_ostream::operator<<
    20 #include <list>                    // for list
    21 #include <string>                  // for operator<<
     18#include <cassert>                   // for assert, assertf
     19#include <fstream>                   // for operator<<, basic_ostream::oper...
     20#include <list>                      // for list
     21#include <string>                    // for operator<<
    2222
    2323#include "AST/Decl.hpp"
    … …  
    2525#include "AST/Type.hpp"
    2626#include "AST/Vector.hpp"
    27 #include "Common/SemanticError.h"  // for SemanticError
    28 #include "CodeGen/GenType.h"       // for GenType
    29 #include "SymTab/Mangler.h"
     27#include "Common/SemanticError.hpp"  // for SemanticError
     28#include "CodeGen/GenType.hpp"       // for GenType
     29#include "SymTab/Mangler.hpp"
    3030
    3131namespace CodeGen {

  • src/CodeGen/FixMain.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // FixMain.h -- Tools to change a Cforall main into a C main.
     7// FixMain.hpp -- Tools to change a Cforall main into a C main.
    88//
    99// Author           : Thierry Delisle

  • src/CodeGen/FixNames.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // FixNames.cc -- Adjustments to typed declarations.
     7// FixNames.cpp -- Adjustments to typed declarations.
    88//
    99// Author           : Richard C. Bilson
    … …  
    1414//
    1515
    16 #include "FixNames.h"
     16#include "FixNames.hpp"
    1717
    18 #include <memory>                  // for unique_ptr
    19 #include <string>                  // for string, operator!=, operator==
     18#include <memory>                    // for unique_ptr
     19#include <string>                    // for string, operator!=, operator==
    2020
    2121#include "AST/Chain.hpp"
    2222#include "AST/Expr.hpp"
    2323#include "AST/Pass.hpp"
    24 #include "Common/SemanticError.h"  // for SemanticError
    25 #include "FixMain.h"               // for FixMain
    26 #include "SymTab/Mangler.h"        // for Mangler
     24#include "Common/SemanticError.hpp"  // for SemanticError
     25#include "FixMain.hpp"               // for FixMain
     26#include "SymTab/Mangler.hpp"        // for Mangler
    2727#include "CompilationState.hpp"
    2828

  • src/CodeGen/FixNames.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // FixNames.h -- Adjustments to typed declarations.
     7// FixNames.hpp -- Adjustments to typed declarations.
    88//
    99// Author           : Richard C. Bilson

  • src/CodeGen/GenType.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // GenType.cc --
     7// GenType.cpp --
    88//
    99// Author           : Richard C. Bilson
    … …  
    1313// Update Count     : 24
    1414//
    15 #include "GenType.h"
     15
     16#include "GenType.hpp"
    1617
    1718#include <cassert>                // for assert, assertf
    … …  
    2223#include "AST/Vector.hpp"         // for vector
    2324#include "CodeGenerator.hpp"      // for CodeGenerator
    24 #include "Common/UniqueName.h"    // for UniqueName
     25#include "Common/UniqueName.hpp"  // for UniqueName
    2526
    2627namespace CodeGen {

  • src/CodeGen/GenType.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // GenType.h --
     7// GenType.hpp --
    88//
    99// Author           : Richard C. Bilson
    … …  
    1818#include <string>  // for string
    1919
    20 #include "CodeGen/Options.h" // for Options
     20#include "CodeGen/Options.hpp" // for Options
    2121
    2222namespace ast {

  • src/CodeGen/Generate.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Generate.cc --
     7// Generate.cpp --
    88//
    99// Author           : Richard C. Bilson
    … …  
    1313// Update Count     : 9
    1414//
    15 #include "Generate.h"
     15#include "Generate.hpp"
    1616
    1717#include <iostream>                  // for ostream, endl, operator<<
    … …  
    2020
    2121#include "CodeGenerator.hpp"         // for CodeGenerator, doSemicolon, ...
    22 #include "GenType.h"                 // for genPrettyType
     22#include "GenType.hpp"               // for genPrettyType
    2323
    2424using namespace std;

  • src/CodeGen/Generate.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Generate.h --
     7// Generate.hpp --
    88//
    99// Author           : Richard C. Bilson

  • src/CodeGen/LinkOnce.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // LinkOnce.cc -- Translate the cfa_linkonce attribute.
     7// LinkOnce.cpp -- Translate the cfa_linkonce attribute.
    88//
    99// Author           : Andrew Beach
    … …  
    1414//
    1515
    16 #include "LinkOnce.h"
     16#include "LinkOnce.hpp"
    1717
    1818#include <algorithm>

  • src/CodeGen/LinkOnce.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // LinkOnce.h -- Translate the cfa_linkonce attribute.
     7// LinkOnce.hpp -- Translate the cfa_linkonce attribute.
    88//
    99// Author           : Andrew Beach

  • src/CodeGen/OperatorTable.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // OperatorTable.cc --
     7// OperatorTable.cpp --
    88//
    99// Author           : Richard C. Bilson
    … …  
    1414//
    1515
    16 #include "OperatorTable.h"
     16#include "OperatorTable.hpp"
    1717
    1818#include <cassert>         // for assert

  • src/CodeGen/OperatorTable.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // OperatorTable.h --
     7// OperatorTable.hpp --
    88//
    99// Author           : Richard C. Bilson

  • src/CodeGen/module.mk

    racb33f15 r31f4837  
    1818        CodeGen/CodeGenerator.cpp \
    1919        CodeGen/CodeGenerator.hpp \
    20         CodeGen/GenType.cc \
    21         CodeGen/GenType.h \
    22         CodeGen/OperatorTable.cc \
    23         CodeGen/OperatorTable.h
     20        CodeGen/GenType.cpp \
     21        CodeGen/GenType.hpp \
     22        CodeGen/OperatorTable.cpp \
     23        CodeGen/OperatorTable.hpp
    2424
    2525SRC += $(SRC_CODEGEN) \
    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
     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
    3535
    3636SRCDEMANGLE += $(SRC_CODEGEN)

  • src/Common/Assert.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Assert.cc --
     7// Assert.cpp --
    88//
    99// Author           : Peter A. Buhr
    … …  
    2222#define CFA_ASSERT_FMT "*CFA assertion error* \"%s\" from program \"%s\" in \"%s\" at line %d in file \"%s\""
    2323
    24 // called by macro assert in assert.h
     24// called by macro assert in cassert
    2525void __assert_fail( const char *assertion, const char *file, unsigned int line, const char *function ) {
    2626        fprintf( stderr, CFA_ASSERT_FMT ".\n", assertion, __progname, function, line, file );

  • src/Common/CodeLocation.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // CodeLocation.h --
     7// CodeLocation.hpp --
    88//
    99// Author           : Andrew Beach

  • src/Common/CodeLocationTools.cpp

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

  • src/Common/DeclStats.cpp

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

  • src/Common/ErrorObjects.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // ErrorObjects.h --
     7// ErrorObjects.hpp --
    88//
    99// Author           : Thierry Delisle
    … …  
    2323#include <unistd.h>     // for isatty
    2424
    25 #include "CodeLocation.h"                                                               // for CodeLocation, toString
     25#include "CodeLocation.hpp"                                                             // for CodeLocation, toString
    2626
    2727struct error {

  • src/Common/Eval.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Eval.cc -- Evaluate parts of the ast at compile time.
     7// Eval.cpp -- Evaluate parts of the ast at compile time.
    88//
    99// Author           : Richard C. Bilson
    … …  
    1414//
    1515
    16 #include "Eval.h"
     16#include "Eval.hpp"
    1717
    1818#include <utility> // for pair
    1919
    2020#include "AST/Inspect.hpp"
    21 #include "CodeGen/OperatorTable.h"                                              // access: OperatorInfo
     21#include "CodeGen/OperatorTable.hpp"                                            // access: OperatorInfo
    2222#include "AST/Pass.hpp"
    23 #include "InitTweak/InitTweak.h"
     23#include "InitTweak/InitTweak.hpp"
    2424
    2525struct EvalNew : public ast::WithShortCircuiting {

  • src/Common/Eval.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Eval.h -- Evaluate parts of the ast at compile time.
     7// Eval.hpp -- Evaluate parts of the ast at compile time.
    88//
    99// Author           : Andrew Beach

  • src/Common/Examine.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Examine.cc -- Helpers for examining AST code.
     7// Examine.cpp -- Helpers for examining AST code.
    88//
    99// Author           : Andrew Beach
    … …  
    1414//
    1515
    16 #include "Common/Examine.h"
     16#include "Common/Examine.hpp"
    1717
    1818#include "AST/Type.hpp"
    19 #include "CodeGen/OperatorTable.h"
    20 #include "InitTweak/InitTweak.h"
     19#include "CodeGen/OperatorTable.hpp"
     20#include "InitTweak/InitTweak.hpp"
    2121
    2222namespace {
    … …  
    5555const ast::Type * getDestructorParam( const ast::FunctionDecl * func ) {
    5656        if ( !CodeGen::isDestructor( func->name ) ) return nullptr;
    57         //return InitTweak::getParamThis( func )->type;
    5857        return getTypeofThisSolo( func );
    5958}

  • src/Common/Examine.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Examine.h -- Helpers for examining AST code.
     7// Examine.hpp -- Helpers for examining AST code.
    88//
    99// Author           : Andrew Beach

  • src/Common/FilterCombos.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // FilterCombos.h --
     7// FilterCombos.hpp --
    88//
    99// Author           : Aaron B. Moss
    … …  
    2222
    2323/// Combo iterator that simply collects values into a vector, marking all values as valid.
    24 /// Prefer combos in typeops.h to use of IntoVectorComboIter with filterCombos
     24/// Prefer combos in Typeops.hpp to use of IntoVectorComboIter with filterCombos
    2525/// @param T    The element type of the vector.
    2626template<typename T>

  • src/Common/Indenter.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Indenter.cc --
     7// Indenter.cpp --
    88//
    99// Author           : Andrew Beach
    … …  
    1414//
    1515
    16 #include "Indenter.h"
     16#include "Indenter.hpp"
    1717
    1818unsigned Indenter::tabsize = 2;

  • src/Common/Indenter.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Indenter.h --
     7// Indenter.hpp --
    88//
    99// Author           : Rob Schluntz

  • src/Common/PersistentMap.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // PersistentMap.h --
     7// PersistentMap.hpp --
    88//
    99// Author           : Aaron B. Moss

  • src/Common/ResolvProtoDump.cpp

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

  • src/Common/ScopedMap.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // ScopedMap.h --
     7// ScopedMap.hpp --
    88//
    99// Author           : Aaron B. Moss

  • src/Common/SemanticError.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // SemanticError.cc --
     7// SemanticError.cpp --
    88//
    99// Author           : Thierry Delisle
    … …  
    1313// Update Count     : 34
    1414//
     15
     16#include "SemanticError.hpp"
    1517
    1618#include <cstdarg>
    … …  
    2325#include <vector>
    2426
     27#include "Common/Utility.hpp"                                                   // for to_string, CodeLocation (ptr only)
     28
    2529using namespace std;
    26 
    27 #include "Common/utility.h"                                                             // for to_string, CodeLocation (ptr only)
    28 #include "SemanticError.h"
    2930
    3031//-----------------------------------------------------------------------------

  • src/Common/SemanticError.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // SemanticError.h --
     7// SemanticError.hpp --
    88//
    99// Author           : Thierry Delisle
    … …  
    1616#pragma once
    1717
    18 #include "ErrorObjects.h"
     18#include "ErrorObjects.hpp"
    1919#include "AST/Node.hpp"
    2020#include "AST/ParseNode.hpp"

  • src/Common/Stats.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Stats.h --
     7// Stats.hpp --
    88//
    99// Author           : Thierry Delisle
    … …  
    2424
    2525These can be enabled using the --stats option, to which a comma seperated list of options can be passed.
    26 For more details see Stats.cc
     26For more information, see Stats/Stats.cpp
    2727
    2828Counters:
    … …  
    4040
    4141
    42 #include "Common/Stats/Counter.h"
    43 #include "Common/Stats/Heap.h"
    44 #include "Common/Stats/Time.h"
     42#include "Common/Stats/Counter.hpp"
     43#include "Common/Stats/Heap.hpp"
     44#include "Common/Stats/Time.hpp"
    4545
    4646namespace Stats {

  • src/Common/Stats/Base.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Heap.h --
     7// Heap.hpp --
    88//
    99// Author           : Thierry Delisle

  • src/Common/Stats/Counter.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Counter.cc --
     7// Counter.cpp --
    88//
    99// Author           : Thierry Delisle
    … …  
    1414//
    1515
    16 #include "Counter.h"
     16#include "Counter.hpp"
    1717
    1818#include <algorithm>

  • src/Common/Stats/Counter.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Counter.h --
     7// Counter.hpp --
    88//
    99// Author           : Thierry Delisle
    … …  
    1919#include <iostream>
    2020
    21 #include "Common/Stats/Base.h"
     21#include "Common/Stats/Base.hpp"
    2222
    2323#if defined( NO_STATISTICS )

  • src/Common/Stats/Heap.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Heap.cc --
     7// Heap.cpp --
    88//
    99// Author           : Thierry Delisle
    … …  
    6969                void stacktrace_push(size_t id) {
    7070                        ++stacktrace_depth;
    71                         assertf(stacktrace_depth < stacktrace_max_depth, "Stack trace too deep: increase size of array in Heap.cc");
     71                        assertf(stacktrace_depth < stacktrace_max_depth, "Stack trace too deep: increase size of array in Heap.cpp");
    7272                        trace[stacktrace_depth] = id;
    7373                }
    … …  
    8787                        passes_cnt++;
    8888
    89                         assertf(passes_cnt < passes_size, "Too many passes for Stats::Heap, increase the size of the array in Heap.cc");
     89                        assertf(passes_cnt < passes_size, "Too many passes for Stats::Heap, increase the size of the array in Heap.cpp");
    9090                }
    9191

  • src/Common/Stats/Heap.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Heap.h --
     7// Heap.hpp --
    88//
    99// Author           : Thierry Delisle

  • src/Common/Stats/ResolveTime.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // ResolveTime.cc --
     7// ResolveTime.cpp --
    88//
    99// Author           : Thierry Delisle
    … …  
    1414//
    1515
    16 #include "ResolveTime.h"
     16#include "ResolveTime.hpp"
    1717
    1818#include <fstream>

  • src/Common/Stats/ResolveTime.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // ResolveTime.h --
     7// ResolveTime.hpp --
    88//
    99// Author           : Thierry Delisle
    … …  
    1616#pragma once
    1717
    18 #include "Common/Stats/Base.h"
     18#include "Common/Stats/Base.hpp"
    1919
    2020#if defined( NO_STATISTICS )

  • src/Common/Stats/Stats.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Stats.cc --
     7// Stats.cpp --
    88//
    99// Author           : Thierry Delisle

  • src/Common/Stats/Time.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Time.cc --
     7// Time.cpp --
    88//
    99// Author           : Thierry Delisle
    … …  
    1414//
    1515
    16 #include "Time.h"
     16#include "Time.hpp"
    1717
    1818#include <cassert>

  • src/Common/Stats/Time.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Time.h --
     7// Time.hpp --
    88//
    99// Author           : Thierry Delisle
    … …  
    1616#pragma once
    1717
    18 #include "Common/Stats/Base.h"
     18#include "Common/Stats/Base.hpp"
    1919
    2020#if defined( NO_STATISTICS )

  • src/Common/UniqueName.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // UniqueName.cc -- Create a unique variants of a base name with a counter.
     7// UniqueName.cpp -- Create a unique variants of a base name with a counter.
    88//
    99// Author           : Richard C. Bilson
    … …  
    1414//
    1515
    16 #include "UniqueName.h"
     16#include "UniqueName.hpp"
    1717
    1818#include "Common/ToString.hpp"

  • src/Common/UniqueName.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // UniqueName.h -- Create a unique variants of a base name with a counter.
     7// UniqueName.hpp -- Create a unique variants of a base name with a counter.
    88//
    99// Author           : Richard C. Bilson

  • src/Common/Utility.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // utility.h -- General utilities used across the compiler.
     7// Utility.hpp -- General utilities used across the compiler.
    88//
    99// Author           : Richard C. Bilson

  • src/Common/VectorMap.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // VectorMap.h --
     7// VectorMap.hpp --
    88//
    99// Author           : Aaron B. Moss

  • src/Common/module.mk

    racb33f15 r31f4837  
    1616
    1717SRC_COMMON = \
    18         Common/Assert.cc \
    19         Common/CodeLocation.h \
     18        Common/Assert.cpp \
     19        Common/CodeLocation.hpp \
    2020        Common/CodeLocationTools.hpp \
    2121        Common/CodeLocationTools.cpp \
    2222        Common/DeclStats.hpp \
    2323        Common/DeclStats.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 \
     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 \
    3232        Common/Iterate.hpp \
    33         Common/PersistentMap.h \
     33        Common/PersistentMap.hpp \
    3434        Common/ResolvProtoDump.hpp \
    3535        Common/ResolvProtoDump.cpp \
    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 \
     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 \
    5050        Common/ToString.hpp \
    51         Common/UniqueName.cc \
    52         Common/UniqueName.h \
    53         Common/utility.h \
    54         Common/VectorMap.h
     51        Common/UniqueName.cpp \
     52        Common/UniqueName.hpp \
     53        Common/Utility.hpp \
     54        Common/VectorMap.hpp
    5555
    5656SRC += $(SRC_COMMON) \
    57         Common/DebugMalloc.cc
     57        Common/DebugMalloc.cpp
    5858
    5959SRCDEMANGLE += $(SRC_COMMON)

  • src/CompilationState.cpp

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

  • src/Concurrency/Corun.cpp

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

  • src/Concurrency/Keywords.cpp

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

  • src/Concurrency/Keywords.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Keywords.h -- Implement concurrency constructs from their keywords.
     7// Keywords.hpp -- Implement concurrency constructs from their keywords.
    88//
    99// Author           : Thierry Delisle

  • src/Concurrency/Waitfor.cpp

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

  • src/Concurrency/Waitfor.hpp

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

  • src/Concurrency/Waituntil.cpp

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

  • src/Concurrency/Waituntil.hpp

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

  • src/Concurrency/module.mk

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

  • src/ControlStruct/ExceptDecl.cpp

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

  • src/ControlStruct/ExceptDecl.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // ExceptDecl.h -- Handles declarations of exception types.
     7// ExceptDecl.hpp -- Handles declarations of exception types.
    88//
    99// Author           : Henry Xue

  • src/ControlStruct/ExceptTranslate.cpp

    racb33f15 r31f4837  
    1414//
    1515
    16 #include "ExceptTranslate.h"
     16#include "ExceptTranslate.hpp"
    1717
    1818#include "AST/Expr.hpp"

  • src/ControlStruct/module.mk

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

  • src/GenPoly/Box.cpp

    racb33f15 r31f4837  
    1414//
    1515
    16 #include "Box.h"
     16#include "Box.hpp"
    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.h"     // for isAssignment
     26#include "CodeGen/OperatorTable.hpp"   // for isAssignment
    2727#include "Common/Iterate.hpp"          // for group_iterate
    28 #include "Common/ScopedMap.h"          // for ScopedMap
     28#include "Common/ScopedMap.hpp"        // for ScopedMap
    2929#include "Common/ToString.hpp"         // for toCString
    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
     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
    3535#include "GenPoly/ScrubTypeVars.hpp"   // for scrubTypeVars, scrubAllTypeVars
    36 #include "ResolvExpr/Unify.h"          // for typesCompatible
    37 #include "SymTab/Mangler.h"            // for mangle, mangleType
     36#include "ResolvExpr/Unify.hpp"        // for typesCompatible
     37#include "SymTab/Mangler.hpp"          // for mangle, mangleType
    3838
    3939namespace GenPoly {

  • src/GenPoly/Box.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Box.h -- Implement polymorphic function calls and types.
     7// Box.hpp -- Implement polymorphic function calls and types.
    88//
    99// Author           : Richard C. Bilson

  • src/GenPoly/ErasableScopedMap.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // ErasableScopedMap.h -- A map that supports scoping and erasing elements.
     7// ErasableScopedMap.hpp -- A map that supports scoping and erasing elements.
    88//
    99// Author           : Aaron B. Moss

  • src/GenPoly/FindFunction.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // FindFunction.cc -- Find function types in a larger type.
     7// FindFunction.cpp -- Find function types in a larger type.
    88//
    99// Author           : Richard C. Bilson
    … …  
    1414//
    1515
    16 #include "FindFunction.h"
     16#include "FindFunction.hpp"
    1717
    18 #include <utility>                      // for pair
     18#include <utility>                        // for pair
    1919
    20 #include "AST/Pass.hpp"                 // for Pass
     20#include "AST/Pass.hpp"                   // for Pass
    2121#include "AST/Type.hpp"
    22 #include "GenPoly/ErasableScopedMap.h"  // for ErasableScopedMap<>::iterator
    23 #include "GenPoly/GenPoly.h"            // for TyVarMap
    24 #include "ScrubTypeVars.hpp"            // for scrubTypeVars
     22#include "GenPoly/ErasableScopedMap.hpp"  // for ErasableScopedMap<>::iterator
     23#include "GenPoly/GenPoly.hpp"            // for TyVarMap
     24#include "ScrubTypeVars.hpp"              // for scrubTypeVars
    2525
    2626namespace GenPoly {

  • src/GenPoly/FindFunction.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // FindFunction.h -- Find function types in a larger type.
     7// FindFunction.hpp -- Find function types in a larger type.
    88//
    99// Author           : Richard C. Bilson
    … …  
    1616#pragma once
    1717
    18 #include "GenPoly.h"            // for TypeVarMap
     18#include "GenPoly.hpp"            // for TypeVarMap
    1919
    2020namespace GenPoly {

  • src/GenPoly/GenPoly.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // GenPoly.cc -- General GenPoly utilities.
     7// GenPoly.cpp -- General GenPoly utilities.
    88//
    99// Author           : Richard C. Bilson
    … …  
    1414//
    1515
    16 #include "GenPoly.h"
    17 
    18 #include <cassert>                      // for assertf, assert
    19 #include <iostream>                     // for operator<<, ostream, basic_os...
    20 #include <iterator>                     // for back_insert_iterator, back_in...
    21 #include <list>                         // for list, _List_iterator, list<>:...
    22 #include <typeindex>                    // for type_index
    23 #include <utility>                      // for pair
    24 #include <vector>                       // for vector
     16#include "GenPoly.hpp"
     17
     18#include <cassert>                        // for assertf, assert
     19#include <iostream>                       // for operator<<, ostream, basic_...
     20#include <iterator>                       // for back_insert_iterator, back_...
     21#include <list>                           // for list, _List_iterator, list<...
     22#include <typeindex>                      // for type_index
     23#include <utility>                        // for pair
     24#include <vector>                         // for vector
    2525
    2626#include "AST/Expr.hpp"
    2727#include "AST/Type.hpp"
    2828#include "AST/TypeSubstitution.hpp"
    29 #include "GenPoly/ErasableScopedMap.h"  // for ErasableScopedMap<>::const_it...
    30 #include "ResolvExpr/typeops.h"         // for flatten
     29#include "GenPoly/ErasableScopedMap.hpp"  // for ErasableScopedMap<>::const_...
     30#include "ResolvExpr/Typeops.hpp"         // for flatten
    3131
    3232using namespace std;
    … …  
    256256
    257257        // So remaining types can be examined case by case.
    258         // Recurse through type structure (conditions borrowed from Unify.cc).
     258        // Recurse through type structure (conditions borrowed from Unify.cpp).
    259259
    260260        if ( type_index(typeid(ast::BasicType)) == lid ) {

  • src/GenPoly/GenPoly.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // GenPoly.h -- General GenPoly utilities.
     7// GenPoly.hpp -- General GenPoly utilities.
    88//
    99// Author           : Richard C. Bilson
    … …  
    1919#include <string>                 // for string, allocator, operator+, basic...
    2020
    21 #include "ErasableScopedMap.h"    // for ErasableScopedMap
     21#include "ErasableScopedMap.hpp"  // for ErasableScopedMap
    2222#include "AST/Decl.hpp"           // for AggregateDecl
    2323#include "AST/Fwd.hpp"            // for ApplicationExpr, BaseInstType, Func...
    24 #include "SymTab/Mangler.h"       // for Mangler
     24#include "SymTab/Mangler.hpp"     // for Mangler
    2525
    2626namespace ast {

  • src/GenPoly/InstantiateGeneric.cpp

    racb33f15 r31f4837  
    1414//
    1515
    16 #include "InstantiateGeneric.h"
     16#include "InstantiateGeneric.hpp"
    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.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
     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
    3333#include "GenPoly/ScrubTypeVars.hpp"   // for scrubAllTypeVars
    3434#include "ResolvExpr/AdjustExprType.hpp"  // for adjustExprType
    35 #include "ResolvExpr/Unify.h"          // for typesCompatible
     35#include "ResolvExpr/Unify.hpp"        // for typesCompatible
    3636
    3737namespace GenPoly {

  • src/GenPoly/InstantiateGeneric.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // InstantiateGeneric.h -- Create concrete instances of generic types.
     7// InstantiateGeneric.hpp -- Create concrete instances of generic types.
    88//
    99// Author           : Aaron B. Moss

  • src/GenPoly/Lvalue.cpp

    racb33f15 r31f4837  
    1414//
    1515
    16 #include "Lvalue.h"
     16#include "Lvalue.hpp"
    1717
    1818#include <set>
    … …  
    2424#include "AST/LinkageSpec.hpp"         // for Linkage
    2525#include "AST/Pass.hpp"
    26 #include "Common/SemanticError.h"      // for SemanticWarning
     26#include "Common/SemanticError.hpp"    // for SemanticWarning
    2727#include "Common/ToString.hpp"         // for toCString
    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
     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
    3232
    3333#if 0

  • src/GenPoly/Lvalue.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Lvalue.h -- Clean up lvalues and remove references.
     7// Lvalue.hpp -- Clean up lvalues and remove references.
    88//
    99// Author           : Richard C. Bilson

  • src/GenPoly/Lvalue2.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Lvalue2.cc -- Seperate Lvalue module for linking.
     7// Lvalue2.cpp -- Seperate Lvalue module for linking.
    88//
    99// Author           : Andrew Beach

  • src/GenPoly/ScopedSet.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // ScopedSet.h -- A set that supports save/restore scoping.
     7// ScopedSet.hpp -- A set that supports save/restore scoping.
    88//
    99// Author           : Aaron B. Moss

  • src/GenPoly/ScrubTypeVars.cpp

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

  • src/GenPoly/ScrubTypeVars.hpp

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

  • src/GenPoly/Specialize.cpp

    racb33f15 r31f4837  
    1414//
    1515
    16 #include "Specialize.h"
     16#include "Specialize.hpp"
    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.h"           // for UniqueName
    23 #include "GenPoly/GenPoly.h"             // for getFunctionType
    24 #include "ResolvExpr/FindOpenVars.h"     // for findOpenVars
     22#include "Common/UniqueName.hpp"         // for UniqueName
     23#include "GenPoly/GenPoly.hpp"           // for getFunctionType
     24#include "ResolvExpr/FindOpenVars.hpp"   // for findOpenVars
    2525
    2626namespace GenPoly {

  • src/GenPoly/Specialize.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Specialize.h -- Generate thunks to specialize polymorphic functions.
     7// Specialize.hpp -- Generate thunks to specialize polymorphic functions.
    88//
    99// Author           : Richard C. Bilson

  • src/GenPoly/module.mk

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

  • src/InitTweak/FixGlobalInit.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // FixGlobalInit.cc --
     7// FixGlobalInit.cpp --
    88//
    99// Author           : Rob Schluntz
    … …  
    1414//
    1515
    16 #include "FixGlobalInit.h"
     16#include "FixGlobalInit.hpp"
    1717
    1818#include <cassert>                 // for assert
    … …  
    2323#include "AST/Node.hpp"
    2424#include "AST/Pass.hpp"
    25 #include "Common/UniqueName.h"     // for UniqueName
    26 #include "InitTweak.h"             // for isIntrinsicSingleArgCallStmt
     25#include "Common/UniqueName.hpp"   // for UniqueName
     26#include "InitTweak.hpp"           // for isIntrinsicSingleArgCallStmt
    2727
    2828namespace InitTweak {

  • src/InitTweak/FixGlobalInit.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // FixGlobalInit.h --
     7// FixGlobalInit.hpp --
    88//
    99// Author           : Rob Schluntz

  • src/InitTweak/FixInit.cpp

    racb33f15 r31f4837  
    1 #include "FixInit.h"
     1#include "FixInit.hpp"
    22
    33#include <stddef.h>                    // for NULL
    … …  
    2222#include "AST/SymbolTable.hpp"
    2323#include "AST/Type.hpp"
    24 #include "CodeGen/OperatorTable.h"     // for isConstructor, isCtorDtor, isD...
    25 #include "Common/SemanticError.h"      // for SemanticError
     24#include "CodeGen/OperatorTable.hpp"   // for isConstructor, isCtorDtor, isD...
     25#include "Common/SemanticError.hpp"    // for SemanticError
    2626#include "Common/ToString.hpp"         // for toCString
    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
     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
    3333#include "SymTab/GenImplicitCall.hpp"  // for genImplicitCall
    3434

  • src/InitTweak/FixInit.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // FixInit.h --
     7// FixInit.hpp --
    88//
    99// Author           : Rob Schluntz

  • src/InitTweak/GenInit.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // GenInit.cc -- Generate initializers, and other stuff.
     7// GenInit.cpp -- Generate initializers, and other stuff.
    88//
    99// Author           : Rob Schluntz
    … …  
    1313// Update Count     : 186
    1414//
    15 #include "GenInit.h"
     15#include "GenInit.hpp"
    1616
    1717#include <stddef.h>                    // for NULL
    … …  
    2828#include "AST/Stmt.hpp"
    2929#include "CompilationState.hpp"
    30 #include "CodeGen/OperatorTable.h"
    31 #include "Common/SemanticError.h"      // for SemanticError
     30#include "CodeGen/OperatorTable.hpp"
     31#include "Common/SemanticError.hpp"    // for SemanticError
    3232#include "Common/ToString.hpp"         // for toCString
    33 #include "Common/UniqueName.h"         // for UniqueName
    34 #include "Common/utility.h"            // for ValueGuard, maybeClone
    35 #include "GenPoly/GenPoly.h"           // for getFunctionType, isPolyType
    36 #include "GenPoly/ScopedSet.h"         // for ScopedSet, ScopedSet<>::const_iter...
    37 #include "InitTweak.h"                 // for isConstExpr, InitExpander, checkIn...
    38 #include "ResolvExpr/Resolver.h"
     33#include "Common/UniqueName.hpp"       // for UniqueName
     34#include "Common/Utility.hpp"          // for ValueGuard, maybeClone
     35#include "GenPoly/GenPoly.hpp"         // for getFunctionType, isPolyType
     36#include "GenPoly/ScopedSet.hpp"       // for ScopedSet, ScopedSet<>::const_iter...
     37#include "InitTweak.hpp"               // for isConstExpr, InitExpander, checkIn...
     38#include "ResolvExpr/Resolver.hpp"
    3939#include "SymTab/GenImplicitCall.hpp"  // for genImplicitCall
    40 #include "SymTab/Mangler.h"            // for Mangler
    41 #include "Tuples/Tuples.h"             // for maybeImpure
    42 #include "Validate/FindSpecialDecls.h" // for SizeType
     40#include "SymTab/Mangler.hpp"          // for Mangler
     41#include "Tuples/Tuples.hpp"           // for maybeImpure
    4342
    4443namespace InitTweak {
    … …  
    334333
    335334ast::ConstructorInit * genCtorInit( const CodeLocation & loc, const ast::ObjectDecl * objDecl ) {
    336         // call into genImplicitCall from Autogen.h to generate calls to ctor/dtor for each
    337         // constructable object
     335        // Call genImplicitCall to generate calls to ctor/dtor for each constructable object.
    338336        InitExpander srcParam{ objDecl->init }, nullParam{ (const ast::Init *)nullptr };
    339337        ast::ptr< ast::Expr > dstParam = new ast::VariableExpr(loc, objDecl);

  • src/InitTweak/GenInit.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // GenInit.h -- Generate initializers, and other stuff.
     7// GenInit.hpp -- Generate initializers, and other stuff.
    88//
    99// Author           : Rodolfo G. Esteves
    … …  
    2020
    2121#include "AST/Fwd.hpp"
    22 #include "Common/CodeLocation.h"
    23 #include "GenPoly/ScopedSet.h" // for ScopedSet
     22#include "Common/CodeLocation.hpp"
     23#include "GenPoly/ScopedSet.hpp"  // for ScopedSet
    2424
    2525namespace InitTweak {

  • src/InitTweak/InitTweak.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // InitTweak.cc --
     7// InitTweak.cpp --
    88//
    99// Author           : Rob Schluntz
    … …  
    1414//
    1515
    16 #include "InitTweak.h"
    17 
    18 #include <algorithm>               // for find, all_of
    19 #include <cassert>                 // for assertf, assert, strict_dynamic_cast
    20 #include <iostream>                // for ostream, cerr, endl
    21 #include <iterator>                // for back_insert_iterator, back_inserter
    22 #include <memory>                  // for __shared_ptr
     16#include "InitTweak.hpp"
     17
     18#include <algorithm>                  // for find, all_of
     19#include <cassert>                    // for assertf, assert, strict_dynamic_...
     20#include <iostream>                   // for ostream, cerr, endl
     21#include <iterator>                   // for back_insert_iterator, back_inser...
     22#include <memory>                     // for __shared_ptr
    2323#include <vector>
    2424
    … …  
    3030#include "AST/Stmt.hpp"
    3131#include "AST/Type.hpp"
    32 #include "CodeGen/OperatorTable.h" // for isConstructor, isDestructor, isCto...
    33 #include "Common/SemanticError.h"  // for SemanticError
    34 #include "Common/ToString.hpp"     // for toCString
    35 #include "Common/UniqueName.h"     // for UniqueName
    36 #include "GenPoly/GenPoly.h"       // for getFunctionType
    37 #include "ResolvExpr/Unify.h"      // for typesCompatibleIgnoreQualifiers
    38 #include "Tuples/Tuples.h"         // for Tuples::isTtype
     32#include "CodeGen/OperatorTable.hpp"  // for isConstructor, isDestructor, isC...
     33#include "Common/SemanticError.hpp"   // for SemanticError
     34#include "Common/ToString.hpp"        // for toCString
     35#include "Common/UniqueName.hpp"      // for UniqueName
     36#include "GenPoly/GenPoly.hpp"        // for getFunctionType
     37#include "ResolvExpr/Unify.hpp"       // for typesCompatibleIgnoreQualifiers
     38#include "Tuples/Tuples.hpp"          // for Tuples::isTtype
    3939
    4040namespace InitTweak {

  • src/InitTweak/InitTweak.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // InitTweak.h --
     7// InitTweak.hpp --
    88//
    99// Author           : Rob Schluntz

  • src/InitTweak/module.mk

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

  • src/MakeLibCfa.cpp

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

  • src/Makefile.am

    racb33f15 r31f4837  
    5353include Virtual/module.mk
    5454
    55 $(addprefix $(srcdir)/, ResolvExpr/ConversionCost.cc ResolvExpr/CommonType.cc SymTab/ManglerCommon.cc) : $(srcdir)/AST/BasicKind.hpp
     55$(addprefix $(srcdir)/, ResolvExpr/ConversionCost.cpp ResolvExpr/CommonType.cpp SymTab/ManglerCommon.cpp) : $(srcdir)/AST/BasicKind.hpp
    5656
    5757$(srcdir)/AST/BasicKind.hpp : BasicTypes-gen.cpp
    … …  
    7373cfa_cpplib_PROGRAMS += $(DEMANGLER)
    7474EXTRA_PROGRAMS = ../driver/demangler
    75 ___driver_demangler_SOURCES = SymTab/demangler.cc # test driver for the demangler, also useful as a sanity check that libdemangle.a is complete
     75___driver_demangler_SOURCES = SymTab/demangler.cpp # 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/DeclarationNode.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // DeclarationNode.cc --
     7// DeclarationNode.cpp --
    88//
    99// Author           : Rodolfo G. Esteves
    … …  
    1414//
    1515
    16 #include "DeclarationNode.h"
    17 
    18 #include <cassert>                 // for assert, assertf, strict_dynamic_cast
    19 #include <iterator>                // for back_insert_iterator
    20 #include <list>                    // for list
    21 #include <memory>                  // for unique_ptr
    22 #include <ostream>                 // for operator<<, ostream, basic_ostream
    23 #include <string>                  // for string, operator+, allocator, char...
    24 
    25 #include "AST/Attribute.hpp"       // for Attribute
    26 #include "AST/Copy.hpp"            // for shallowCopy
    27 #include "AST/Decl.hpp"            // for Decl
    28 #include "AST/Expr.hpp"            // for Expr
    29 #include "AST/Print.hpp"           // for print
    30 #include "AST/Stmt.hpp"            // for AsmStmt, DirectiveStmt
    31 #include "AST/StorageClasses.hpp"  // for Storage::Class
    32 #include "AST/Type.hpp"            // for Type
    33 #include "Common/CodeLocation.h"   // for CodeLocation
    34 #include "Common/Iterate.hpp"      // for reverseIterate
    35 #include "Common/SemanticError.h"  // for SemanticError
    36 #include "Common/UniqueName.h"     // for UniqueName
    37 #include "Common/utility.h"        // for copy, spliceBegin
    38 #include "Parser/ExpressionNode.h" // for ExpressionNode
    39 #include "Parser/InitializerNode.h"// for InitializerNode
    40 #include "Parser/StatementNode.h"  // for StatementNode
    41 #include "TypeData.h"              // for TypeData, TypeData::Aggregate_t
    42 #include "TypedefTable.h"          // for TypedefTable
     16#include "DeclarationNode.hpp"
     17
     18#include <cassert>                     // for assert, assertf, strict_dynami...
     19#include <iterator>                    // for back_insert_iterator
     20#include <list>                        // for list
     21#include <memory>                      // for unique_ptr
     22#include <ostream>                     // for operator<<, ostream, basic_ost...
     23#include <string>                      // for string, operator+, allocator, ...
     24
     25#include "AST/Attribute.hpp"           // for Attribute
     26#include "AST/Copy.hpp"                // for shallowCopy
     27#include "AST/Decl.hpp"                // for Decl
     28#include "AST/Expr.hpp"                // for Expr
     29#include "AST/Print.hpp"               // for print
     30#include "AST/Stmt.hpp"                // for AsmStmt, DirectiveStmt
     31#include "AST/StorageClasses.hpp"      // for Storage::Class
     32#include "AST/Type.hpp"                // for Type
     33#include "Common/CodeLocation.hpp"     // for CodeLocation
     34#include "Common/Iterate.hpp"          // for reverseIterate
     35#include "Common/SemanticError.hpp"    // for SemanticError
     36#include "Common/UniqueName.hpp"       // for UniqueName
     37#include "Common/Utility.hpp"          // for copy, spliceBegin
     38#include "Parser/ExpressionNode.hpp"  // for ExpressionNode
     39#include "Parser/InitializerNode.hpp"  // for InitializerNode
     40#include "Parser/StatementNode.hpp"    // for StatementNode
     41#include "TypeData.hpp"                // for TypeData, TypeData::Aggregate_t
     42#include "TypedefTable.hpp"            // for TypedefTable
    4343
    4444extern TypedefTable typedefTable;

  • src/Parser/DeclarationNode.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // DeclarationNode.h --
     7// DeclarationNode.hpp --
    88//
    99// Author           : Andrew Beach
    … …  
    1616#pragma once
    1717
    18 #include "ParseNode.h"
     18#include "ParseNode.hpp"
    1919
    2020struct TypeData;

  • src/Parser/ExpressionNode.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // ExpressionNode.cc --
     7// ExpressionNode.cpp --
    88//
    99// Author           : Peter A. Buhr
    … …  
    1414//
    1515
    16 #include "ExpressionNode.h"
     16#include "ExpressionNode.hpp"
    1717
    1818#include <cassert>                 // for assert
    … …  
    2626#include "AST/Expr.hpp"            // for NameExpr
    2727#include "AST/Type.hpp"            // for Type, LengthFlag, DimentionFlag
    28 #include "Common/SemanticError.h"  // for SemanticError
    29 #include "Common/utility.h"        // for maybeMoveBuild, maybeBuild, CodeLo...
    30 #include "DeclarationNode.h"       // for DeclarationNode
    31 #include "InitializerNode.h"       // for InitializerNode
    32 #include "TypeData.h"              // for addType, build_basic_type, build_c...
    33 #include "parserutility.h"         // for notZeroExpr
     28#include "Common/SemanticError.hpp"// for SemanticError
     29#include "Common/Utility.hpp"      // for maybeMoveBuild, maybeBuild, CodeLo...
     30#include "DeclarationNode.hpp"     // for DeclarationNode
     31#include "InitializerNode.hpp"     // for InitializerNode
     32#include "TypeData.hpp"            // for addType, build_basic_type, build_c...
     33#include "ParserUtility.hpp"       // for notZeroExpr
    3434
    3535using namespace std;

  • src/Parser/ExpressionNode.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // ExpressionNode.h --
     7// ExpressionNode.hpp --
    88//
    99// Author           : Andrew Beach
    … …  
    1616#pragma once
    1717
    18 #include "ParseNode.h"
     18#include "ParseNode.hpp"
    1919
    2020struct InitializerNode;

  • src/Parser/InitializerNode.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // InitializerNode.cc --
     7// InitializerNode.cpp --
    88//
    99// Author           : Rodolfo G. Esteves
    … …  
    1414//
    1515
    16 #include "InitializerNode.h"
     16#include "InitializerNode.hpp"
    1717
    18 #include <iostream>                // for operator<<, ostream, basic_ostream
    19 #include <list>                    // for list
    20 #include <string>                  // for operator<<, string
     18#include <iostream>                  // for operator<<, ostream, basic_ostream
     19#include <list>                      // for list
     20#include <string>                    // for operator<<, string
    2121
    22 #include "AST/Expr.hpp"            // for Expr
    23 #include "AST/Init.hpp"            // for Designator, Init, ListInit, Sing...
    24 #include "Common/SemanticError.h"  // for SemanticError
    25 #include "Common/utility.h"        // for maybeBuild
    26 #include "ExpressionNode.h"        // for ExpressionNode
    27 #include "DeclarationNode.h"       // for buildList
     22#include "AST/Expr.hpp"              // for Expr
     23#include "AST/Init.hpp"              // for Designator, Init, ListInit, Sing...
     24#include "Common/SemanticError.hpp"  // for SemanticError
     25#include "Common/Utility.hpp"        // for maybeBuild
     26#include "ExpressionNode.hpp"        // for ExpressionNode
     27#include "DeclarationNode.hpp"       // for buildList
    2828
    2929using namespace std;

  • src/Parser/InitializerNode.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // InitializerNode.h --
     7// InitializerNode.hpp --
    88//
    99// Author           : Andrew Beach
    … …  
    1616#pragma once
    1717
    18 #include "ParseNode.h"
     18#include "ParseNode.hpp"
    1919
    2020struct InitializerNode final : public ParseList<InitializerNode> {

  • src/Parser/ParseNode.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // ParseNode.cc --
     7// ParseNode.cpp --
    88//
    99// Author           : Rodolfo G. Esteves
    … …  
    1414//
    1515
    16 #include "ParseNode.h"
     16#include "ParseNode.hpp"
    1717using namespace std;
    1818

  • src/Parser/ParseNode.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // ParseNode.h --
     7// ParseNode.hpp --
    88//
    99// Author           : Rodolfo G. Esteves
    … …  
    1616#pragma once
    1717
    18 #include <algorithm>               // for move
    19 #include <cassert>                 // for assert, assertf
    20 #include <iosfwd>                  // for ostream
    21 #include <iterator>                // for back_insert_iterator
    22 #include <list>                    // for list
    23 #include <memory>                  // for unique_ptr, pointer_traits
    24 #include <string>                  // for string
     18#include <algorithm>                 // for move
     19#include <cassert>                   // for assert, assertf
     20#include <iosfwd>                    // for ostream
     21#include <iterator>                  // for back_insert_iterator
     22#include <list>                      // for list
     23#include <memory>                    // for unique_ptr, pointer_traits
     24#include <string>                    // for string
    2525
    26 #include "AST/Expr.hpp"            // for Expr, NameExpr LogicalFlag
    27 #include "AST/Fwd.hpp"             // for ptr, Decl, DeclWithType,
    28 #include "AST/Stmt.hpp"            // for Stmt
    29 #include "Common/CodeLocation.h"   // for CodeLocation
    30 #include "Common/SemanticError.h"  // for SemanticError
    31 #include "Common/UniqueName.h"     // for UniqueName
    32 #include "Parser/parserutility.h"  // for maybeBuild, maybeCopy
     26#include "AST/Expr.hpp"              // for Expr, NameExpr, LogicalFlag
     27#include "AST/Fwd.hpp"               // for ptr, Decl, DeclWithType,
     28#include "AST/Stmt.hpp"              // for Stmt
     29#include "Common/CodeLocation.hpp"   // for CodeLocation
     30#include "Common/SemanticError.hpp"  // for SemanticError
     31#include "Common/UniqueName.hpp"     // for UniqueName
     32#include "Parser/ParserUtility.hpp"  // for maybeBuild, maybeCopy
    3333
    3434struct DeclarationNode;

  • src/Parser/ParserTypes.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // parser.hh --
     7// ParserTypes.hpp --
    88//
    99// Author           : Peter A. Buhr
    … …  
    2020
    2121#include <string>
    22 #include "ParseNode.h"
     22#include "ParseNode.hpp"
    2323// External declarations for information sharing between lexer and scanner
    2424class TypedefTable;

  • src/Parser/ParserUtility.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // parserutility.h -- Collected utilities for the parser.
     7// ParserUtility.hpp -- Collected utilities for the parser.
    88//
    99// Author           : Rodolfo G. Esteves

  • src/Parser/RunParser.cpp

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

  • src/Parser/StatementNode.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // StatementNode.cc -- Transform from parse data-structures to AST data-structures, usually deleting the parse
     7// StatementNode.cpp -- Transform from parse data-structures to AST data-structures, usually deleting the parse
    88//     data-structure after the transformation.
    99//
    … …  
    1515//
    1616
    17 #include "StatementNode.h"
     17#include "StatementNode.hpp"
    1818
    1919#include <cassert>                 // for assert, strict_dynamic_cast, assertf
    … …  
    2323#include "AST/Label.hpp"           // for Label
    2424#include "AST/Stmt.hpp"            // for Stmt, AsmStmt, BranchStmt, CaseCla...
    25 #include "Common/SemanticError.h"  // for SemanticError
    26 #include "Common/utility.h"        // for maybeMoveBuild, maybeBuild
    27 #include "DeclarationNode.h"       // for DeclarationNode
    28 #include "ExpressionNode.h"        // for ExpressionNode
    29 #include "parserutility.h"         // for notZeroExpr
     25#include "Common/SemanticError.hpp"// for SemanticError
     26#include "Common/Utility.hpp"      // for maybeMoveBuild, maybeBuild
     27#include "DeclarationNode.hpp"     // for DeclarationNode
     28#include "ExpressionNode.hpp"      // for ExpressionNode
     29#include "ParserUtility.hpp"       // for notZeroExpr
    3030
    3131class Declaration;

  • src/Parser/StatementNode.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // StatementNode.h --
     7// StatementNode.hpp --
    88//
    99// Author           : Andrew Beach
    … …  
    1616#pragma once
    1717
    18 #include "ParseNode.h"
     18#include "ParseNode.hpp"
    1919
    2020struct StatementNode final : public ParseList<StatementNode> {

  • src/Parser/TypeData.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // TypeData.cc --
     7// TypeData.cpp --
    88//
    99// Author           : Rodolfo G. Esteves
    … …  
    1414//
    1515
    16 #include "TypeData.h"
    17 
    18 #include <cassert>                 // for assert
    19 #include <ostream>                 // for operator<<, ostream, basic_ostream
    20 
    21 #include "AST/Attribute.hpp"       // for Attribute
    22 #include "AST/Decl.hpp"            // for AggregateDecl, ObjectDecl, TypeDe...
    23 #include "AST/Init.hpp"            // for SingleInit, ListInit
    24 #include "AST/Print.hpp"           // for print
    25 #include "AST/Type.hpp"            // for Type
    26 #include "Common/SemanticError.h"  // for SemanticError
    27 #include "Common/utility.h"        // for splice, spliceBegin
    28 #include "Common/Iterate.hpp"      // for reverseIterate
    29 #include "Parser/ExpressionNode.h" // for ExpressionNode
    30 #include "Parser/StatementNode.h"  // for StatementNode
     16#include "TypeData.hpp"
     17
     18#include <cassert>                   // for assert
     19#include <ostream>                   // for operator<<, ostream, basic_ostream
     20
     21#include "AST/Attribute.hpp"         // for Attribute
     22#include "AST/Decl.hpp"              // for AggregateDecl, ObjectDecl, Type...
     23#include "AST/Init.hpp"              // for SingleInit, ListInit
     24#include "AST/Print.hpp"             // for print
     25#include "AST/Type.hpp"              // for Type
     26#include "Common/SemanticError.hpp"  // for SemanticError
     27#include "Common/Utility.hpp"        // for splice, spliceBegin
     28#include "Common/Iterate.hpp"        // for reverseIterate
     29#include "Parser/ExpressionNode.hpp" // for ExpressionNode
     30#include "Parser/StatementNode.hpp"  // for StatementNode
    3131
    3232class Attribute;

  • src/Parser/TypeData.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // TypeData.h --
     7// TypeData.hpp --
    88//
    99// Author           : Peter A. Buhr
    … …  
    2222#include "AST/CVQualifiers.hpp"                     // for CV
    2323#include "AST/Fwd.hpp"                              // for Type
    24 #include "DeclarationNode.h"                        // for DeclarationNode
     24#include "DeclarationNode.hpp"                      // for DeclarationNode
    2525
    2626struct TypeData {

  • src/Parser/TypedefTable.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // TypedefTable.cc --
     7// TypedefTable.cpp --
    88//
    99// Author           : Peter A. Buhr
    … …  
    1515
    1616
    17 #include "TypedefTable.h"
     17#include "TypedefTable.hpp"
    1818
    1919#include <cassert>                                                                              // for assert
    … …  
    2323struct TypeData;
    2424
    25 #include "ExpressionNode.h"                                                             // for LabelNode
    26 #include "ParserTypes.h"                                                                // for Token
    27 #include "StatementNode.h"                                                              // for CondCtl, ForCtrl
     25#include "ExpressionNode.hpp"                                                   // for LabelNode
     26#include "ParserTypes.hpp"                                                              // for Token
     27#include "StatementNode.hpp"                                                    // for CondCtl, ForCtrl
    2828// This (generated) header must come late as it is missing includes.
    2929#include "parser.hh"                                                                    // for IDENTIFIER, TYPEDEFname, TYPEGENname

  • src/Parser/TypedefTable.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // TypedefTable.h --
     7// TypedefTable.hpp --
    88//
    99// Author           : Peter A. Buhr
    … …  
    1818#include <string>                                                                               // for string
    1919
    20 #include "Common/ScopedMap.h"                                                   // for ScopedMap
     20#include "Common/ScopedMap.hpp"                                                 // for ScopedMap
    2121
    2222class TypedefTable {

  • src/Parser/lex.ll

    racb33f15 r31f4837  
    4444
    4545#include "config.h"                                                                             // configure info
    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"
     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"
    5353// This (generated) header must come late as it is missing includes.
    5454#include "parser.hh"                                    // generated info

  • src/Parser/module.mk

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

  • src/Parser/parser.yy

    racb33f15 r31f4837  
    4848using namespace std;
    4949
    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"
     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"
    5757#include "AST/Type.hpp"                                 // for BasicType, BasicKind
    58 #include "Common/SemanticError.h"                                               // error_str
    59 #include "Common/utility.h"                                                             // for maybeMoveBuild, maybeBuild, CodeLo...
     58#include "Common/SemanticError.hpp"                     // error_str
     59#include "Common/Utility.hpp"                           // for maybeMoveBuild, maybeBuild, CodeLo...
    6060
    6161// lex uses __null in a boolean context, it's fine.

  • src/ResolvExpr/AdjustExprType.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // AdjustExprType_old.cc --
     7// AdjustExprType.cpp --
    88//
    99// Author           : Richard C. Bilson

  • src/ResolvExpr/Candidate.hpp

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

  • src/ResolvExpr/CandidateFinder.cpp

    racb33f15 r31f4837  
    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.h"       // for conversionCast
    30 #include "Cost.h"
     29#include "ConversionCost.hpp"       // for conversionCast
     30#include "Cost.hpp"
    3131#include "ExplodedArg.hpp"
    3232#include "PolyCost.hpp"
    33 #include "RenameVars.h"           // for renameTyVars
    34 #include "Resolver.h"
    35 #include "ResolveTypeof.h"
     33#include "RenameVars.hpp"           // for renameTyVars
     34#include "Resolver.hpp"
     35#include "ResolveTypeof.hpp"
    3636#include "SatisfyAssertions.hpp"
    3737#include "SpecCost.hpp"
    38 #include "typeops.h"              // for combos
    39 #include "Unify.h"
    40 #include "WidenMode.h"
     38#include "Typeops.hpp"              // for combos
     39#include "Unify.hpp"
     40#include "WidenMode.hpp"
    4141#include "AST/Expr.hpp"
    4242#include "AST/Node.hpp"
    … …  
    4545#include "AST/SymbolTable.hpp"
    4646#include "AST/Type.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"
     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"
    5353
    5454#include "AST/Inspect.hpp"             // for getFunctionName

  • src/ResolvExpr/CandidatePrinter.cpp

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

  • src/ResolvExpr/CastCost.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // CastCost.cc --
     7// CastCost.cpp --
    88//
    99// Author           : Richard C. Bilson
    … …  
    2222#include "AST/Type.hpp"
    2323#include "AST/TypeEnvironment.hpp"
    24 #include "ConversionCost.h"              // for ConversionCost
    25 #include "Cost.h"                        // for Cost, Cost::infinity
    26 #include "ResolvExpr/ConversionCost.h"  // for conversionCost
     24#include "ConversionCost.hpp"            // for ConversionCost
     25#include "Cost.hpp"                      // for Cost, Cost::infinity
     26#include "ResolvExpr/ConversionCost.hpp" // for conversionCost
    2727#include "ResolvExpr/PtrsCastable.hpp"   // for ptrsCastable
    28 #include "ResolvExpr/Unify.h"            // for typesCompatibleIgnoreQualifiers
     28#include "ResolvExpr/Unify.hpp"          // for typesCompatibleIgnoreQualifiers
    2929
    3030#if 0

  • src/ResolvExpr/CastCost.hpp

    racb33f15 r31f4837  
    1616#pragma once
    1717
    18 #include "ResolvExpr/Cost.h"     // for Cost
    19 
    2018namespace ast {
    2119        class SymbolTable;
    … …  
    2523
    2624namespace ResolvExpr {
     25
     26class Cost;
    2727
    2828Cost castCost(

  • src/ResolvExpr/CommonType.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // CommonType.cc --
     7// CommonType.cpp --
    88//
    99// Author           : Richard C. Bilson
    … …  
    2323#include "AST/Pass.hpp"
    2424#include "AST/Type.hpp"
    25 #include "Unify.h"                       // for unifyExact, WidenMode
    26 #include "typeops.h"                     // for isFtype
    27 #include "Tuples/Tuples.h"
     25#include "Unify.hpp"                     // for unifyExact, WidenMode
     26#include "Typeops.hpp"                   // for isFtype
     27#include "Tuples/Tuples.hpp"
    2828
    2929// #define DEBUG

  • src/ResolvExpr/CommonType.hpp

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

  • src/ResolvExpr/ConversionCost.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // ConversionCost.cc --
     7// ConversionCost.cpp --
    88//
    99// Author           : Richard C. Bilson
    … …  
    1414//
    1515
    16 #include "ConversionCost.h"
     16#include "ConversionCost.hpp"
    1717
    1818#include <cassert>                       // for assert
    … …  
    2020#include <string>                        // for operator==, string
    2121
    22 #include "ResolvExpr/Cost.h"             // for Cost
    23 #include "ResolvExpr/Unify.h"            // for typesCompatibleIgnoreQualifiers
     22#include "ResolvExpr/Cost.hpp"           // for Cost
     23#include "ResolvExpr/Unify.hpp"          // for typesCompatibleIgnoreQualifiers
    2424#include "ResolvExpr/PtrsAssignable.hpp" // for ptrsAssignable
    2525

  • src/ResolvExpr/ConversionCost.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // ConversionCost.h --
     7// ConversionCost.hpp --
    88//
    99// Author           : Richard C. Bilson
    … …  
    1818#include <functional>         // for function
    1919
    20 #include "Cost.h"             // for Cost
     20#include "Cost.hpp"           // for Cost
    2121
    2222#include "AST/Fwd.hpp"

  • src/ResolvExpr/CurrentObject.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // CurrentObject.h --
     7// CurrentObject.cpp --
    88//
    99// Author           : Rob Schluntz
    … …  
    1414//
    1515
     16#include "CurrentObject.hpp"
     17
    1618#include <stddef.h>                    // for size_t
    1719#include <cassert>                     // for assertf, assert, safe_dynamic_...
    … …  
    2830#include "AST/Print.hpp"               // for readonly
    2931#include "AST/Type.hpp"
    30 #include "Common/Eval.h"               // for eval
    31 #include "Common/Indenter.h"           // for Indenter, operator<<
    32 #include "Common/SemanticError.h"      // for SemanticError
    33 #include "Common/utility.h"            // for toString
    34 #include "CurrentObject.h"
     32#include "Common/Eval.hpp"             // for eval
     33#include "Common/Indenter.hpp"         // for Indenter, operator<<
     34#include "Common/SemanticError.hpp"    // for SemanticError
     35#include "Common/Utility.hpp"          // for toString
    3536
    3637#if 0

  • src/ResolvExpr/CurrentObject.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // CurrentObject.h --
     7// CurrentObject.hpp --
    88//
    99// Author           : Rob Schluntz
    … …  
    2121
    2222#include "AST/Node.hpp"  // for ptr
    23 #include "Common/CodeLocation.h"
     23#include "Common/CodeLocation.hpp"
    2424
    2525namespace ast {

  • src/ResolvExpr/ExplodedArg.cpp

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

  • src/ResolvExpr/ExplodedArg.hpp

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

  • src/ResolvExpr/FindOpenVars.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // FindOpenVars.cc --
     7// FindOpenVars.cpp --
    88//
    99// Author           : Richard C. Bilson
    … …  
    1414//
    1515
    16 #include "FindOpenVars.h"
     16#include "FindOpenVars.hpp"
    1717
    1818#include "AST/Pass.hpp"

  • src/ResolvExpr/PolyCost.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // PolyCost.cc --
     7// PolyCost.cpp --
    88//
    99// Author           : Richard C. Bilson

  • src/ResolvExpr/PtrsAssignable.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // PtrsAssignable.cc --
     7// PtrsAssignable.cpp --
    88//
    99// Author           : Richard C. Bilson

  • src/ResolvExpr/PtrsCastable.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // PtrsCastable.cc --
     7// PtrsCastable.cpp --
    88//
    99// Author           : Richard C. Bilson

  • src/ResolvExpr/RenameVars.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // RenameVars.cc --
     7// RenameVars.cpp --
    88//
    99// Author           : Richard C. Bilson
    … …  
    1414//
    1515
    16 #include <ext/alloc_traits.h>      // for __alloc_traits<>::value_type
    17 #include <memory>                  // for allocator_traits<>::value_type
    18 #include <sstream>                 // for operator<<, basic_ostream, ostring...
    19 #include <utility>                 // for pair
     16#include <ext/alloc_traits.h>         // for __alloc_traits<>::value_type
     17#include <memory>                     // for allocator_traits<>::value_type
     18#include <sstream>                    // for operator<<, basic_ostream, ostr...
     19#include <utility>                    // for pair
    2020
    2121#include "AST/Pass.hpp"
    2222#include "AST/Type.hpp"
    23 #include "Common/ScopedMap.h"
    24 #include "Common/SemanticError.h"  // for SemanticError
    25 #include "RenameVars.h"
     23#include "Common/ScopedMap.hpp"
     24#include "Common/SemanticError.hpp"   // for SemanticError
     25#include "RenameVars.hpp"
    2626
    2727#include "AST/Copy.hpp"

  • src/ResolvExpr/RenameVars.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // RenameVars.h --
     7// RenameVars.hpp --
    88//
    99// Author           : Richard C. Bilson

  • src/ResolvExpr/ResolveTypeof.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // ResolveTypeof.cc --
     7// ResolveTypeof.cpp --
    88//
    99// Author           : Richard C. Bilson
    … …  
    1414//
    1515
    16 #include "ResolveTypeof.h"
     16#include "ResolveTypeof.hpp"
    1717
    18 #include <cassert>  // for assert
     18#include <cassert>                  // for assert
    1919
    2020#include "AST/CVQualifiers.hpp"
    … …  
    2424#include "AST/Type.hpp"
    2525#include "AST/TypeEnvironment.hpp"
    26 #include "Common/utility.h"       // for copy
    27 #include "InitTweak/InitTweak.h"  // for isConstExpr
    28 #include "RenameVars.h"
    29 #include "Resolver.h"  // for resolveInVoidContext
    30 #include "SymTab/Mangler.h"
     26#include "Common/Utility.hpp"       // for copy
     27#include "InitTweak/InitTweak.hpp"  // for isConstExpr
     28#include "RenameVars.hpp"
     29#include "Resolver.hpp"             // for resolveInVoidContext
     30#include "SymTab/Mangler.hpp"
    3131
    3232namespace ResolvExpr {

  • src/ResolvExpr/ResolveTypeof.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // ResolveTypeof.h --
     7// ResolveTypeof.hpp --
    88//
    99// Author           : Richard C. Bilson

  • src/ResolvExpr/Resolver.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Resolver.cc --
     7// Resolver.cpp --
    88//
    99// Author           : Aaron B. Moss
    … …  
    2121#include "Candidate.hpp"
    2222#include "CandidateFinder.hpp"
    23 #include "CurrentObject.h"               // for CurrentObject
    24 #include "RenameVars.h"                  // for RenameVars, global_renamer
    25 #include "Resolver.h"
    26 #include "ResolveTypeof.h"
     23#include "CurrentObject.hpp"             // for CurrentObject
     24#include "RenameVars.hpp"                // for RenameVars, global_renamer
     25#include "Resolver.hpp"
     26#include "ResolveTypeof.hpp"
    2727#include "ResolveMode.hpp"               // for ResolveMode
    28 #include "typeops.h"                     // for extractResultType
    29 #include "Unify.h"                       // for unify
     28#include "Typeops.hpp"                   // for extractResultType
     29#include "Unify.hpp"                     // for unify
    3030#include "CompilationState.hpp"
    3131#include "AST/Decl.hpp"
    … …  
    3535#include "AST/SymbolTable.hpp"
    3636#include "AST/Type.hpp"
    37 #include "Common/Eval.h"                 // for eval
     37#include "Common/Eval.hpp"               // for eval
    3838#include "Common/Iterate.hpp"            // for group_iterate
    39 #include "Common/SemanticError.h"        // for SemanticError
    40 #include "Common/Stats/ResolveTime.h"    // for ResolveTime::start(), ResolveTime::stop()
     39#include "Common/SemanticError.hpp"      // for SemanticError
     40#include "Common/Stats/ResolveTime.hpp"  // for ResolveTime::start(), ResolveTime::stop()
    4141#include "Common/ToString.hpp"           // for toCString
    42 #include "Common/UniqueName.h"           // for UniqueName
    43 #include "InitTweak/GenInit.h"
    44 #include "InitTweak/InitTweak.h"         // for isIntrinsicSingleArgCallStmt
    45 #include "SymTab/Mangler.h"              // for Mangler
    46 #include "Tuples/Tuples.h"
    47 #include "Validate/FindSpecialDecls.h"  // for SizeType
     42#include "Common/UniqueName.hpp"         // for UniqueName
     43#include "InitTweak/GenInit.hpp"
     44#include "InitTweak/InitTweak.hpp"       // for isIntrinsicSingleArgCallStmt
     45#include "SymTab/Mangler.hpp"            // for Mangler
     46#include "Tuples/Tuples.hpp"
     47#include "Validate/FindSpecialDecls.hpp" // for SizeType
    4848
    4949using namespace std;

  • src/ResolvExpr/Resolver.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Resolver.h --
     7// Resolver.hpp --
    88//
    99// Author           : Richard C. Bilson

  • src/ResolvExpr/SatisfyAssertions.cpp

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

  • src/ResolvExpr/SpecCost.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // SpecCost.cc --
     7// SpecCost.cpp --
    88//
    99// Author           : Aaron B. Moss

  • src/ResolvExpr/Typeops.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // typeops.h --
     7// Typeops.hpp --
    88//
    99// Author           : Richard C. Bilson

  • src/ResolvExpr/Unify.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Unify.cc --
     7// Unify.cpp --
    88//
    99// Author           : Richard C. Bilson
    … …  
    1414//
    1515
    16 #include "Unify.h"
     16#include "Unify.hpp"
    1717
    1818#include <cassert>                  // for assertf, assert
    … …  
    3232#include "AST/Type.hpp"
    3333#include "AST/TypeEnvironment.hpp"
    34 #include "Common/Eval.h"            // for eval
     34#include "Common/Eval.hpp"          // for eval
    3535#include "CommonType.hpp"           // for commonType
    36 #include "FindOpenVars.h"           // for findOpenVars
     36#include "FindOpenVars.hpp"         // for findOpenVars
    3737#include "SpecCost.hpp"             // for SpecCost
    38 #include "Tuples/Tuples.h"          // for isTtype
    39 #include "typeops.h"                // for flatten, occurs
     38#include "Tuples/Tuples.hpp"        // for isTtype
     39#include "Typeops.hpp"              // for flatten, occurs
    4040
    4141namespace ast {

  • src/ResolvExpr/Unify.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Unify.h --
     7// Unify.hpp --
    88//
    99// Author           : Richard C. Bilson
    … …  
    1818#include "AST/Node.hpp"             // for ptr
    1919#include "AST/TypeEnvironment.hpp"  // for TypeEnvironment, AssertionSet, OpenVarSet
    20 #include "WidenMode.h"              // for WidenMode
     20#include "WidenMode.hpp"            // for WidenMode
    2121
    2222namespace ast {

  • src/ResolvExpr/module.mk

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

  • src/SymTab/Demangle.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Demangle.cc -- Convert a mangled name into a human readable name.
     7// Demangle.cpp -- Convert a mangled name into a human readable name.
    88//
    99// Author           : Rob Schluntz
    … …  
    1919#include "AST/Pass.hpp"
    2020#include "AST/Type.hpp"
    21 #include "CodeGen/GenType.h"
    22 #include "CodeGen/OperatorTable.h"
    23 #include "Common/utility.h"                                                             // isPrefix
    24 #include "Mangler.h"
     21#include "CodeGen/GenType.hpp"
     22#include "CodeGen/OperatorTable.hpp"
     23#include "Common/Utility.hpp"                                                           // isPrefix
     24#include "Mangler.hpp"
    2525
    2626#define DEBUG

  • src/SymTab/Demangle.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Demangle.h -- Convert a mangled name into a human readable name.
     7// Demangle.hpp -- Convert a mangled name into a human readable name.
    88//
    99// Author           : Andrew Beach

  • src/SymTab/FixFunction.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // FixFunction.cc --
     7// FixFunction.cpp --
    88//
    99// Author           : Richard C. Bilson
    … …  
    1414//
    1515
    16 #include "FixFunction.h"
     16#include "FixFunction.hpp"
    1717
    1818#include <list>                   // for list
    … …  
    2121#include "AST/Pass.hpp"
    2222#include "AST/Type.hpp"
    23 #include "Common/utility.h"       // for copy
     23#include "Common/Utility.hpp"     // for copy
    2424
    2525namespace SymTab {

  • src/SymTab/FixFunction.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // FixFunction.h --
     7// FixFunction.hpp --
    88//
    99// Author           : Richard C. Bilson

  • src/SymTab/GenImplicitCall.cpp

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

  • src/SymTab/GenImplicitCall.hpp

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

  • src/SymTab/Mangler.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Mangler.cc --
     7// Mangler.cpp --
    88//
    99// Author           : Richard C. Bilson
    … …  
    1313// Update Count     : 75
    1414//
    15 #include "Mangler.h"
     15#include "Mangler.hpp"
    1616
    1717#include <algorithm>                     // for copy, transform
    … …  
    2323
    2424#include "AST/Pass.hpp"
    25 #include "CodeGen/OperatorTable.h"       // for OperatorInfo, operatorLookup
     25#include "CodeGen/OperatorTable.hpp"     // for OperatorInfo, operatorLookup
    2626#include "Common/ToString.hpp"           // for toCString
    27 #include "Common/SemanticError.h"        // for SemanticError
     27#include "Common/SemanticError.hpp"      // for SemanticError
    2828
    2929namespace Mangle {

  • src/SymTab/Mangler.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Mangler.h --
     7// Mangler.hpp --
    88//
    99// Author           : Richard C. Bilson

  • src/SymTab/ManglerCommon.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Mangler.h --
     7// ManglerCommon.cpp --
    88//
    99// Author           : Richard C. Bilson
    … …  
    1414//
    1515
    16 #include "Mangler.h"
     16#include "Mangler.hpp"
    1717
    1818#include "AST/Decl.hpp"

  • src/SymTab/demangler.cpp

    racb33f15 r31f4837  
    1 #include "Demangle.h"
     1#include "Demangle.hpp"
    22#include <iostream>
    33#include <fstream>

  • src/SymTab/module.mk

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

  • src/Tuples/Explode.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Explode.cc --
     7// Explode.cpp --
    88//
    99// Author           : Rob Schluntz
    … …  
    1414//
    1515
    16 #include "Explode.h"
     16#include "Explode.hpp"
    1717
    1818#include "AST/Pass.hpp"          // for Pass

  • src/Tuples/Explode.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Explode.h --
     7// Explode.hpp --
    88//
    99// Author           : Rob Schluntz
    … …  
    2222#include "ResolvExpr/Candidate.hpp"     // for Candidate, CandidateList
    2323#include "ResolvExpr/ExplodedArg.hpp"   // for ExplodedArg
    24 #include "Tuples.h"                     // for maybeImpure
     24#include "Tuples.hpp"                   // for maybeImpure
    2525
    2626namespace ast {

  • src/Tuples/TupleAssignment.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // TupleAssignment.cc --
     7// TupleAssignment.cpp --
    88//
    99// Author           : Rodolfo G. Esteves
    … …  
    1414//
    1515
    16 #include "Tuples.h"
     16#include "Tuples.hpp"
    1717
    1818#include <algorithm>                       // for transform
    … …  
    2929#include "AST/Stmt.hpp"
    3030#include "AST/TypeEnvironment.hpp"
    31 #include "CodeGen/OperatorTable.h"
    32 #include "Common/UniqueName.h"             // for UniqueName
    33 #include "Common/utility.h"                // for splice, zipWith
    34 #include "Explode.h"                       // for explode
    35 #include "InitTweak/GenInit.h"             // for genCtorInit
    36 #include "InitTweak/InitTweak.h"           // for getPointerBase, isAssignment
     31#include "CodeGen/OperatorTable.hpp"
     32#include "Common/UniqueName.hpp"           // for UniqueName
     33#include "Common/Utility.hpp"              // for splice, zipWith
     34#include "Explode.hpp"                     // for explode
     35#include "InitTweak/GenInit.hpp"           // for genCtorInit
     36#include "InitTweak/InitTweak.hpp"         // for getPointerBase, isAssignment
    3737#include "ResolvExpr/CandidateFinder.hpp"  // for CandidateFinder
    38 #include "ResolvExpr/Cost.h"               // for Cost
    39 #include "ResolvExpr/Resolver.h"           // for resolveCtorInit
    40 #include "ResolvExpr/typeops.h"            // for combos
     38#include "ResolvExpr/Cost.hpp"             // for Cost
     39#include "ResolvExpr/Resolver.hpp"         // for resolveCtorInit
     40#include "ResolvExpr/Typeops.hpp"          // for combos
    4141
    4242#if 0

  • src/Tuples/TupleExpansion.cpp

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

  • src/Tuples/Tuples.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Tuples.cc -- A collection of tuple operations.
     7// Tuples.cpp -- A collection of tuple operations.
    88//
    99// Author           : Andrew Beach
    … …  
    1414//
    1515
    16 #include "Tuples.h"
     16#include "Tuples.hpp"
    1717
    1818#include "AST/Pass.hpp"
    1919#include "AST/Inspect.hpp"
    2020#include "AST/LinkageSpec.hpp"
    21 #include "InitTweak/InitTweak.h"
     21#include "InitTweak/InitTweak.hpp"
    2222
    2323namespace Tuples {

  • src/Tuples/Tuples.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Tuples.h -- A collection of tuple operations.
     7// Tuples.hpp -- A collection of tuple operations.
    88//
    99// Author           : Rodolfo G. Esteves
    … …  
    2727namespace Tuples {
    2828
    29 // TupleAssignment.cc
     29// TupleAssignment.cpp
    3030void handleTupleAssignment(
    3131        ResolvExpr::CandidateFinder & finder, const ast::UntypedExpr * assign,
    3232        std::vector< ResolvExpr::CandidateFinder > & args );
    3333
    34 // TupleExpansion.cc
     34// TupleExpansion.cpp
    3535/// Expands z.[a, b.[x, y], c] into [z.a, z.b.x, z.b.y, z.c], inserting UniqueExprs as appropriate.
    3636void expandMemberTuples( ast::TranslationUnit & translationUnit );

  • src/Tuples/module.mk

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

  • src/Validate/Autogen.cpp

    racb33f15 r31f4837  
    1616#include "Autogen.hpp"
    1717
    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
     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
    2525
    2626#include "AST/Attribute.hpp"
    … …  
    3434#include "AST/Stmt.hpp"
    3535#include "AST/SymbolTable.hpp"
    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
     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
    4242#include "SymTab/GenImplicitCall.hpp"  // for genImplicitCall
    43 #include "SymTab/Mangler.h"        // for Mangler
     43#include "SymTab/Mangler.hpp"          // for Mangler
    4444#include "CompilationState.hpp"
    4545

  • src/Validate/CompoundLiteral.cpp

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

  • src/Validate/EliminateTypedef.cpp

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

  • src/Validate/EnumAndPointerDecay.cpp

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

  • src/Validate/FindSpecialDecls.cpp

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

  • src/Validate/FindSpecialDecls.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // FindSpecialDeclarations.h -- Find special declarations used in the compiler.
     7// FindSpecialDeclarations.hpp -- Find special declarations used in the compiler.
    88//
    99// Author           : Rob Schluntz

  • src/Validate/FixQualifiedTypes.cpp

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

  • src/Validate/FixReturnTypes.cpp

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

  • src/Validate/ForallPointerDecay.cpp

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

  • src/Validate/ImplementEnumFunc.cpp

    racb33f15 r31f4837  
    22#include "AST/Pass.hpp"
    33#include "AST/TranslationUnit.hpp"
    4 #include "CodeGen/OperatorTable.h"  // for isCtorDtor, isCtorDtorAssign
    5 #include "InitTweak/InitTweak.h"    // for isAssignment, isCopyConstructor
     4#include "CodeGen/OperatorTable.hpp"  // for isCtorDtor, isCtorDtorAssign
     5#include "InitTweak/InitTweak.hpp"    // for isAssignment, isCopyConstructor
    66namespace Validate {
    77

  • src/Validate/ReplaceTypedef.cpp

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

  • src/Validate/VerifyCtorDtorAssign.cpp

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

  • src/Validate/module.mk

    racb33f15 r31f4837  
    1616
    1717SRC_VALIDATE = \
    18         Validate/FindSpecialDecls.h
     18        Validate/FindSpecialDecls.hpp
    1919
    2020SRC += $(SRC_VALIDATE) \
    … …  
    4040        Validate/HoistTypeDecls.cpp \
    4141        Validate/HoistTypeDecls.hpp \
     42        Validate/ImplementEnumFunc.cpp \
     43        Validate/ImplementEnumFunc.hpp \
    4244        Validate/InitializerLength.cpp \
    4345        Validate/InitializerLength.hpp \
    … …  
    5254        Validate/ReturnCheck.hpp \
    5355        Validate/VerifyCtorDtorAssign.cpp \
    54         Validate/VerifyCtorDtorAssign.hpp \
    55         Validate/ImplementEnumFunc.cpp \
    56         Validate/ImplementEnumFunc.hpp
     56        Validate/VerifyCtorDtorAssign.hpp
    5757
    5858SRCDEMANGLE += $(SRC_VALIDATE)

  • src/Virtual/ExpandCasts.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // ExpandCasts.cc --
     7// ExpandCasts.cpp --
    88//
    99// Author           : Andrew Beach
    … …  
    1414//
    1515
    16 #include "ExpandCasts.h"
    17 
    18 #include <cassert>                 // for assert, assertf
    19 #include <iterator>                // for back_inserter, inserter
    20 #include <string>                  // for string, allocator, operator==, ope...
     16#include "ExpandCasts.hpp"
     17
     18#include <cassert>                   // for assert, assertf
     19#include <iterator>                  // for back_inserter, inserter
     20#include <string>                    // for string, allocator, operator==, o...
    2121
    2222#include "AST/Copy.hpp"
    … …  
    2424#include "AST/Expr.hpp"
    2525#include "AST/Pass.hpp"
    26 #include "Common/ScopedMap.h"      // for ScopedMap
    27 #include "Common/SemanticError.h"  // for SemanticError
    28 #include "SymTab/Mangler.h"        // for mangleType
     26#include "Common/ScopedMap.hpp"      // for ScopedMap
     27#include "Common/SemanticError.hpp"  // for SemanticError
     28#include "SymTab/Mangler.hpp"        // for mangleType
    2929
    3030namespace Virtual {

  • src/Virtual/ExpandCasts.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // ExpandCasts.h --
     7// ExpandCasts.hpp --
    88//
    99// Author           : Andrew Beach

  • src/Virtual/Tables.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Tables.cc --
     7// Tables.cpp --
    88//
    99// Author           : Andrew Beach

  • src/Virtual/Tables.hpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Tables.h --
     7// Tables.hpp --
    88//
    99// Author           : Andrew Beach

  • src/Virtual/module.mk

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

  • src/include/cassert

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

  • src/include/optional

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

  • src/main.cpp

    racb33f15 r31f4837  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // main.cc --
     7// main.cpp --
    88//
    99// Author           : Peter Buhr and Rob Schluntz
    … …  
    3535#include "CompilationState.hpp"
    3636#include "../config.h"                      // for CFA_LIBDIR
    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
     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
    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.h"                   // for Stats
    45 #include "Common/utility.h"                 // for deleteAll, filter, printAll
     44#include "Common/Stats.hpp"                 // for Stats
     45#include "Common/Utility.hpp"               // for deleteAll, filter, printAll
    4646#include "Concurrency/Actors.hpp"           // for implementActors
    4747#include "Concurrency/Corun.hpp"            // for implementCorun
    48 #include "Concurrency/Keywords.h"           // for implementMutex, implement...
    49 #include "Concurrency/Waitfor.h"            // for generateWaitfor
     48#include "Concurrency/Keywords.hpp"         // for implementMutex, implement...
     49#include "Concurrency/Waitfor.hpp"          // for generateWaitfor
    5050#include "Concurrency/Waituntil.hpp"        // for generateWaitUntil
    51 #include "ControlStruct/ExceptDecl.h"       // for translateExcept
    52 #include "ControlStruct/ExceptTranslate.h"  // for translateThrows, translat...
     51#include "ControlStruct/ExceptDecl.hpp"     // for translateExcept
     52#include "ControlStruct/ExceptTranslate.hpp"// for translateThrows, translat...
    5353#include "ControlStruct/FixLabels.hpp"      // for fixLabels
    5454#include "ControlStruct/HoistControlDecls.hpp" //  hoistControlDecls
    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
     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
    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.h"            // for resolve
    66 #include "Tuples/Tuples.h"                  // for expandMemberTuples, expan...
     65#include "ResolvExpr/Resolver.hpp"          // for resolve
     66#include "Tuples/Tuples.hpp"                // for expandMemberTuples, expan...
    6767#include "Validate/Autogen.hpp"             // for autogenerateRoutines
    68 #include "Validate/ImplementEnumFunc.hpp"   // for implementEnumFunc
    6968#include "Validate/CompoundLiteral.hpp"     // for handleCompoundLiterals
    7069#include "Validate/EliminateTypedef.hpp"    // for eliminateTypedef
    7170#include "Validate/EnumAndPointerDecay.hpp" // for decayEnumsAndPointers
    72 #include "Validate/FindSpecialDecls.h"      // for findGlobalDecls
     71#include "Validate/FindSpecialDecls.hpp"    // for findGlobalDecls
    7372#include "Validate/FixQualifiedTypes.hpp"   // for fixQualifiedTypes
    7473#include "Validate/FixReturnTypes.hpp"      // for fixReturnTypes
    … …  
    7776#include "Validate/HoistStruct.hpp"         // for hoistStruct
    7877#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.h"            // for expandCasts
     85#include "Virtual/ExpandCasts.hpp"          // for expandCasts
    8686#include "Virtual/VirtualDtor.hpp"          // for implementVirtDtors
    8787
Note: See TracChangeset for help on using the changeset viewer.