Changes in / [acb33f15:31f4837]


Ignore:
Files:
123 added
124 deleted
90 edited

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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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.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.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/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/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/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/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/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/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/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/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/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.