Changes in / [31f4837:acb33f15]


Ignore:
Files:
124 added
123 deleted
90 edited

Legend:

Unmodified
Added
Removed

  • doc/theses/jiada_liang_MMath/CFAenum.tex

    r31f4837 racb33f15  
    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 @int@.
     13Given the existence of this form, it is straightforward to extend it with types other than integers.
    1414\begin{cfa}
    1515enum E { Size = 20u, PI = 3.14159L, Jack = L"John" };
    … …  
    2121
    2222
    23 \section{Enumerator Visibility}
    24 \label{s:EnumeratorVisibility}
    25 
    26 In C, unscoped enumerators present a \newterm{naming problem} when multiple enumeration types appear in the same scope with duplicate enumerator names.
     23\section{Enumerator Unscoping}
     24\label{s:EnumeratorUnscoping}
     25
     26In C, unscoped enumerators presents 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{// return}$
     35E1 p() { return Third; }                                $\C{// correctly resolved duplicate names}$
    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 type.
     56Now the enumerators \emph{must} be qualified with the associated enumeration.
    5757\begin{cfa}
    5858Week week = @Week.@Mon;
    … …  
    6868}
    6969\end{cfa}
    70 As 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.
     70As 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.
    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 depending on the language context.
     346To better match with programmer intuition, \CFA toggles between value and position semantics depneding 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

    r31f4837 racb33f15  
    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 Indirect initialization (without initialization, @Max10Plus1@) is \newterm{auto-initialized}: from left to right, starting at zero or the next explicitly initialized constant, incrementing by @1@.
     80An enumerator without initialization 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@,@                  $\C{// terminating comma}$
    110 };
     109        Mon@ = 0@, Tue, Wed@,@ }; // terminating comma
    111110\end{clang}
    112111Note, 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

    r31f4837 racb33f15  
    135135
    136136\subsection{Algebraic Data Type}
    137 \label{s:AlgebraicDataType}
    138137
    139138An 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

    r31f4837 racb33f15  
    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}, 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}, Modula-3~\cite{Modula-3}, 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 introduced the \lstinline[language=Pascal]{const} aliasing declaration binding a name to a constant literal/expression.
     26Classic Pascal has 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 a type-resolution algorithm including the left-hand side of assignmente to disambiguate among overloaded identifiers.
     64Like \CFA, Ada uses an advanced type-resolution algorithm, including the left-hand side of assignment, 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;
     99OtherRed : 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})\footnote{
    282 The use of keyword \lstinline[language=c++]{class} is resonable because default visibility is \lstinline[language=c++]{private} (scoped).
    283 However, default visibility for \lstinline[language=c++]{struct} is \lstinline[language=c++]{public} (unscoped) making it an odd choice.},
    284 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}), where the enumerators are accessed using type qualification.
    285282\begin{c++}
    286283enum class E { A, B, C };
    … …  
    294291E e = A;    e = B;                                              $\C{// direct access}$
    295292\end{c++}
    296 \CC{11} added the ability to explicitly declare only an underlying \emph{integral} type for \lstinline[language=c++]{enum class}.
     293\CC{11} added the ability to explicitly declare the underlying \emph{integral} type for \lstinline[language=c++]{enum class}.
    297294\begin{c++}
    298295enum class RGB @: long@ { Red, Green, Blue };
    … …  
    305302char ch = rgb::Red;   ch = crgb;                $\C{// error}$
    306303\end{c++}
    307 An enumeration can be used in the @if@ and @switch@ statements.
    308 \begin{cquote}
    309 \setlength{\tabcolsep}{15pt}
    310 \begin{tabular}{@{}ll@{}}
    311 \begin{c++}
    312 if ( @day@ <= Fri )
    313         cout << "weekday" << endl;
    314 
    315 
    316 
    317 
    318 \end{c++}
    319 &
    320 \begin{c++}
    321 switch ( @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}
    330 However, there is no mechanism to iterate through an enumeration without an unsafe cast and it does not understand the enumerator values.
    331 \begin{c++}
    332 enum Week { Mon, Tue, Wed, Thu = 10, Fri, Sat, Sun };
    333 for ( Week d = Mon; d <= Sun; d = @(Week)(d + 1)@ ) cout << d << ' ';
    334 0 1 2 @3 4 5 6 7 8 9@ 10 11 12 13
    335 \end{c++}
    336 An enumeration type cannot declare an array dimension but an enumerator can be used as a subscript.
    337 There is no mechanism to subtype or inherit from an enumeration.
     304Finally, enumerations can be used in the @switch@ statement but there is no mechanism to iterate through an enumeration.
     305An enumeration type cannot declare an array dimension but can be used as a subscript.
     306There is no mechanism to subtype or inherit from enumerations.
    338307
    339308
    … …  
    342311
    343312% 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.
     315\begin{csharp}
     316enum Weekday : byte { Mon, Tue, Wed, Thu@ = 10@, Fri, Sat, Sun@,@ };
     317\end{csharp}
     318The default underlying type is @int@, with auto-incrementing, implicit/explicit initialization, terminator comma, and optional integral typing (default @int@).
     319A method cannot be defined in an enumeration type.
     320As 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.
     321\begin{csharp}
     322int day = (int)Weekday.Fri;             $\C{// day == 10}$
     323Weekday weekday = (Weekdays)42;         $\C{// weekday == 42, logically invalid}$
     324Console.WriteLine( Weekday.Fri ); $\C{// print Fri}$
     325string mon = Weekday.Mon.ToString(); $\C{// mon == "Mon"}$
     326\end{csharp}
     327
     328The @Enum.GetValues@ pseudo-method retrieves an array of the enumeration constants for looping over an enumeration type or variable (expensive operation).
     329\begin{csharp}
     330foreach ( Weekday constant in @Enum.GetValues@( typeof(Weekday) ) ) {
     331        Console.WriteLine( constant + " " + (int)constant ); // label, position
     332}
     333\end{csharp}
     334
     335The @Flags@ attribute creates a bit-flags enumeration, allowing bitwise operators @&@, @|@, @~@ (complement), @^@ (xor).
     336\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}
     343Weekday 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.
     347The key observation is that an enumeration class is just a structuring mechanism without any additional semantics.
     348
    344349% 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}.
     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
    348356\begin{csharp}
    349 enum Week : @long@ { Mon, Tue, Wed, Thu@ = 10@, Fri, Sat, Sun@,@ } // terminating comma
    350 enum RGB { Red, Green, Blue }
    351 \end{csharp}
    352 The default underlying integral type is @int@ (no @char@), with auto-incrementing, implicit/explicit initialization, and terminating comma.
    353 A method cannot be defined in an enumeration type (extension methods are possible).
    354 There is an explicit bidirectional conversion between an enumeration and its integral type, and an implicit conversion to the enumerator label in display contexts.
    355 \begin{csharp}
    356 int iday = (int)Week.Fri;                       $\C{// day == 11}$
    357 Week day = @(Week)@42;                          $\C{// day == 42, unsafe}$
    358 string mon = Week.Mon.ToString();       $\C{// mon == "Mon"}$
    359 RGB rgb = RGB.Red;                                      $\C{// rgb == "Red"}$
    360 day = @(Week)@rgb;                                      $\C{// day == "Mon", unsafe}$
    361 Console.WriteLine( Week.Fri );          $\C{// print label Fri}$
    362 \end{csharp}
    363 The majority of the integral operators (relational and arithmetic) work with enumerations, except @*@ and @/@.
    364 \begin{csharp}
    365 day = day++ - 5;                                        $\C{// unsafe}$
    366 day = day & day;
    367 \end{csharp}
    368 
    369 An enumeration can be used in the @if@ and @switch@ statements.
    370 \begin{cquote}
    371 \setlength{\tabcolsep}{15pt}
    372 \begin{tabular}{@{}ll@{}}
    373 \begin{csharp}
    374 if ( @day@ <= Week.Fri )
    375         Console.WriteLine( "weekday" );
    376 
    377 
    378 
    379 
    380 
     357public 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}
    381377\end{csharp}
    382378&
    383379\begin{csharp}
    384 switch ( @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;
     380public 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        }
    390401}
    391402\end{csharp}
    392403\end{tabular}
    393 \end{cquote}
    394 However, 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}
    396 for ( Week d = Mon; d <= Sun; @d += 1@ ) {
    397         Console.Write( d + " " );
    398 }
    399 Mon Tue Wed @3 4 5 6 7 8 9@ Thu Fri Sat Sun
    400 \end{csharp}
    401 The @Enum.GetValues@ pseudo-method retrieves an array of the enumeration constants for looping over an enumeration type or variable (expensive operation).
    402 \begin{csharp}
    403 foreach ( Week d in @Enum.GetValues@( typeof(Week) ) ) {
    404         Console.WriteLine( d + " " + (int)d + " " ); // label, position
    405 }
    406 Mon 0, Tue 1, Wed 2, Thu 10, Fri 11, Sat 12, Sun 13,
    407 \end{csharp}
    408 
    409 An enumeration type cannot declare an array dimension but an enumerator can be used as a subscript.
    410 There is no mechanism to subtype or inherit from an enumeration.
    411 
    412 The @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 }
    420 Week meetings = @Week.Mon | Week.Wed@; $\C{// 0x5}$
    421 \end{csharp}
     404\caption{\Csharp: Free Routine Versus Class Enumeration}
     405\label{CsharpFreeVersusClass}
     406\end{figure}
    422407
    423408
    424409\section{Golang}
    425410
    426 Golang has a no enumeration.
    427 It has @const@ aliasing declarations, similar to \CC \see{\VRef{s:C++RelatedWork}}, for basic types with type inferencing and static initialization (constant expression).
     411Golang provides pseudo-enumeration similar to classic Pascal \lstinline[language=pascal]{const}, binding a name to a constant literal/expression.
    428412\begin{Go}
    429 const R @int@ = 0;  const G @uint@ = 1;  const B = 2; $\C{// explicit typing and type inferencing}$
    430 const Fred = "Fred";  const Mary = "Mary";  const Jane = "Jane";
    431 const S = 0;  const T = 0;
    432 const USA = "USA";  const U = "USA";
    433 const V = 3.1;  const W = 3.1;
    434 \end{Go}
    435 Since these declarations are unmutable variables, they are unscoped and Golang has no overloading.
    436 
    437 Golang provides an enumeration-like feature to group together @const@ declaration into a block and introduces a form of auto-initialization.
    438 \begin{Go}
    439 const ( R = 0; G; B )                                   $\C{// implicit initialization: 0 0 0}$
    440 const ( Fred = "Fred"; Mary = "Mary"; Jane = "Jane" ) $\C{// explicit initialization: Fred Mary Jane}$
     413const ( R = 0; G; B )                                   $\C{// implicit: 0 0 0}$
     414const ( Fred = "Fred"; Mary = "Mary"; Jane = "Jane" ) $\C{// explicit: Fred Mary Jane}$
    441415const ( S = 0; T; USA = "USA"; U; V = 3.1; W ) $\C{// type change, implicit/explicit: 0 0 USA USA 3.1 3.1}$
    442416\end{Go}
    443 The first identifier \emph{must} be explicitly initialized;
    444 subsequent identifiers can be implicitly or explicitly initialized.
    445 Implicit initialization is the \emph{previous} (predecessor) identifier value.
    446 
    447 Each @const@ declaration provides an implicit integer counter starting at zero, called \lstinline[language=Go]{iota}.
    448 Using \lstinline[language=Go]{iota} outside of a @const@ block always sets the identifier to zero.
    449 \begin{Go}
    450 const R = iota;                                                 $\C{// 0}$
    451 \end{Go}
    452 Inside 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.
     417Constant identifiers are unscoped and must be unique (no overloading).
     418The first enumerator \emph{must} be explicitly initialized;
     419subsequent enumerators can be implicitly or explicitly initialized.
     420Implicit initialization is the previous (predecessor) enumerator value.
     421
     422Auto-incrementing is supported by the keyword \lstinline[language=Go]{iota}, available only in the \lstinline[language=Go]{const} declaration.
     423The \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).
    453424\begin{Go}
    454425const ( R = @iota@; G; B )                              $\C{// implicit: 0 1 2}$
    … …  
    459430const ( O1 = iota + 1; @_@; O3; @_@; O5 ) // 1, 3, 5
    460431\end{Go}
    461 Auto-initialization reverts from \lstinline[language=Go]{iota} to the previous value after an explicit initialization, but auto-incrementing of \lstinline[language=Go]{iota} continues.
     432Auto-incrementing stops after an explicit initialization.
    462433\begin{Go}
    463434const ( Mon = iota; Tue; Wed; // 0, 1, 2
    464                 @Thu = 10@; Fri; Sat; Sun = itoa ) // 10, 10, 10, 6
     435        @Thu = 10@; Fri; Sat; Sun ) // 10, 10, 10, 10
    465436\end{Go}
    466 Auto-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}.
     437Auto-incrementing can be restarted with an expression containing \emph{one} \lstinline[language=Go]{iota}.
    467438\begin{Go}
    468 const ( V1 = iota; V2; @V3 = 7;@ V4 = @iota@ + 1; V5 ) // 0 1 7 4 5
     439const ( V1 = iota; V2; @V3 = 7;@ V4 = @iota@; V5 ) // 0 1 7 3 4
    469440const ( Mon = iota; Tue; Wed; // 0, 1, 2
    470                 @Thu = 10;@ Fri = @iota - Wed + Thu - 1@; Sat; Sun ) // 10, 11, 12, 13
     441        @Thu = 10;@ Fri = @iota - Wed + Thu - 1@; Sat; Sun ) // 10, 11, 12, 13
    471442\end{Go}
    472 Here, @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}.
    473 Note, because \lstinline[language=Go]{iota} is incremented for an explicitly initialized identifier or @_@,
    474 at @Fri@ \lstinline[language=Go]{iota} is 4 requiring the minus one to compute the value for @Fri@.
     443Note, \lstinline[language=Go]{iota} is advanced for an explicitly initialized enumerator, like the underscore @_@ identifier.
    475444
    476445Basic switch and looping are possible.
    477446\begin{cquote}
    478 \setlength{\tabcolsep}{20pt}
     447\setlength{\tabcolsep}{15pt}
    479448\begin{tabular}{@{}ll@{}}
    480449\begin{Go}
    481 day := Mon;     // := $\(\Rightarrow\)$ type inferencing
    482 switch @day@ {
     450day := Mon;
     451switch day {
    483452  case Mon, Tue, Wed, Thu, Fri:
    484453        fmt.Println( "weekday" );
    … …  
    490459\begin{Go}
    491460
    492 for i := @Mon@; i <= @Sun@; i += 1 {
     461for i := Mon; i <= Sun; i += 1 {
    493462        fmt.Println( i )
    494463}
    … …  
    501470However, the loop prints the values from 0 to 13 because there is no actual enumeration.
    502471
    503 A constant variable can be used as an array dimension or a subscript.
    504 \begin{Go}
    505 var ar[@Sun@] int
    506 ar[@Mon@] = 3
    507 \end{Go}
    508 
    509472
    510473\section{Java}
    511474
    512 Java provides an enumeration using a specialized class.
    513 A basic Java enumeration is an opaque enumeration, where the enumerators are constants.
     475Every enumeration in Java is an enumeration class.
     476For a basic enumeration
    514477\begin{Java}
    515 enum Week {
    516         Mon, Tue, Wed, Thu, Fri, Sat, Sun;
    517 }
    518 Week day = Week.Sat;
     478enum Weekday { Mon, Tue, Wed, Thu, Fri, Sat, Sun };
     479Weekday day = Weekday.Sat;
    519480\end{Java}
    520 The enumerators members are scoped and cannot be made \lstinline[language=java]{public}, hence require qualification.
    521 The value of an enumeration instance is restricted to its enumerators.
    522 
    523 The position (ordinal) and label are accessible but there is no value.
     481the scoped enumerators are an ordered list of @final@ methods of type integer, ordered left to right starting at 0, increasing by 1.
     482The value of an enumeration instance is restricted to the enumeration's enumerators.
     483There is an implicit @int@ variable in the enumeration used to store the value of an enumeration instance.
     484The position (ordinal) and label are accessible, where the value is the same as the position.
    524485\begin{Java}
    525 System.out.println( day.!ordinal()! + " " + !day! + " " + day.!name()! );
    526 5 Sat Sat
     486System.out.println( day.!ordinal()! + " " + day.!name()! ); // 5 Sat
    527487\end{Java}
    528 Since @day@ has no value, it prints its label (name).
    529 The member @valueOf@ is the inverse of @name@ converting a string to enumerator.
     488There is an inverse function @valueOf@ from string to enumerator.
    530489\begin{Java}
    531 day = Week.valueOf( "Wed" );
     490day = Weekday.valueOf( "Wed" );
    532491\end{Java}
    533 Extra members can be added to provide specialized operations.
     492There are no implicit conversions to/from an enumerator and its underlying type.
     493Like \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
    534500\begin{Java}
    535 public boolean isWeekday() { return !ordinal()! <= Fri.ordinal(); }
    536 public boolean isWeekend() { return Fri.ordinal() < !ordinal()!; }
    537 \end{Java}
    538 Notice the unqualified calls to @ordinal@ in the members implying a \lstinline[language=Java]{this} to some implicit implementation variable, likely an @int@.
    539 
    540 Enumerator values require an enumeration type (any Java type may be used) and implementation member.
    541 \begin{Java}
    542 enum 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 };
    547 Week day = Week.Sat;
    548 \end{Java}
    549 The position, value, and label are accessible.
    550 \begin{Java}
    551 System.out.println( !day.ordinal()! + " " + !day.day! + " " + !day.name()! );
    552 5 6 Sat
    553 \end{Java}
    554 If 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@.
    555 The implementation constructor must be private since it is only used internally to initialize the enumerators.
    556 Initialization occurs at the enumeration-type declaration for each enumerator in the first line.
    557 
    558 Enumerations 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}
    563 if ( !day! == Week.Fri )
    564         System.out.println( "Fri" );
    565 
    566 
    567 
    568 
     501enum Weekday !{!
     502        Mon, Tue, Wed, Thu, Fri, Sat, Sun !}!;
     503
     504static boolean isWeekday( Weekday wd ) {
     505        return wd.ordinal() <= Weekday.Fri.ordinal();
     506}
     507static boolean isWeekend( Weekday wd ) {
     508        return Weekday.Fri.ordinal() < wd.ordinal();
     509}
     510
     511public static void main( String[] args ) {
     512        Weekday day = Weekday.Sat;
     513        System.out.println( isWeekday( day ) );
     514        System.out.println( isWeekend( day ) );
     515}
    569516\end{Java}
    570517&
    571518\begin{Java}
    572 switch ( !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;
     519enum 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!}!
     529public static void main( String[] args ) {
     530        WeekDay day = WeekDay.Sat;
     531        System.out.println( day.isWeekday() );
     532        System.out.println( day.isWeekend() );
    577533}
    578534\end{Java}
    579535\end{tabular}
    580 \end{cquote}
    581 Notice enumerators in the @switch@ statement do not require qualification.
    582 
    583 There 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}.
    584 Like \Csharp, looping over an enumeration is done using method @values@, which returns an array of enumerator values (expensive operation).
     536\caption{Java: Free Routine Versus Class Enumeration}
     537\label{f:JavaFreeVersusClass}
     538\end{figure}
     539
     540To 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.
    585541\begin{Java}
    586 for ( Week d : Week.values() ) {
    587         System.out.print( d.ordinal() + d.day + " " +  d.name() + ",  " );
     542enum 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};
     547Weekday day = Weekday.Sat;
     548\end{Java}
     549If an enumerator initialization is a runtime expression, the expression is executed once at the point the enumeration is declaraed.
     550
     551The position, value, and label are accessible.
     552\begin{Java}
     553System.out.println( !day.ordinal()! + " " + !day.day! + " " + !day.name()! );  // 5 6 Sat
     554\end{Java}
     555The constructor is private so only initialization or assignment can be used to set an enumeration, which ensures only corresponding enumerator values are allowed.
     556
     557An enumeration can appear in a @switch@ statement, but no ranges.
     558\begin{Java}
     559switch ( 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}
     568Like \Csharp, looping over an enumeration is done using method @values@, which returns the array of enumerator values (expensive operation).
     569\begin{Java}
     570for ( Weekday iday : Weekday.values() ) {
     571        System.out.print( iday.ordinal() + iday.day + " " +  iday.name() + ",  " );
    588572}
    5895730 1 Mon,  1 2 Tue,  2 3 Wed,  3 4 Thu,  4 5 Fri,  5 6 Sat,  6 7 Sun, 
    590574\end{Java}
    591575
    592 An enumeration type cannot declare an array dimension nor can an enumerator be used as a subscript.
    593 Enumeration inheritence is disallowed because an enumeration is \lstinline[language=Java]{final}.
    594 
    595 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.
     576As 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.
    596577There is also a specialized version of @HashMap@ with enumerator keys, which has performance benefits.
    597578
     579Enumeration inheritence is disallowed because an enumeration is @final@.
     580
     581
     582
     583\section{Modula-3}
     584
     585
    598586
    599587\section{Rust}
    600 
    601588% https://doc.rust-lang.org/reference/items/enumerations.html
    602589
    603 Rust @enum@ provides two largely independent mechanisms: an ADT and an enumeration.
    604 When @enum@ is an ADT, pattern matching is used to discriminate among the variant types.
     590Rust 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.
     592An enumeration without constructors is called field-less.
     593\begin{rust}
     594enum Week { Mon, Tues, Wed, Thu, Fri, Sat, Sun@,@ }
     595let mut week: Week = Week::Mon;
     596week = Week::Fri;
     597\end{rust}
     598A field-less enumeration with only unit variants is called unit-only.
     599\begin{rust}
     600enum Week { Mon = 0, Tues = 1, Wed = 2, Thu = 3, Fri = 4, Sat = 5, Sun = 6 }
     601\end{rust}
     602Enum constructors can have either named or unnamed fields:
     603\begin{rust}
     604enum Animal {
     605        Dog( String, f64 ),
     606        Cat{ name: String, weight: f64 },
     607}
     608let mut a: Animal = Animal::Dog("Cocoa".to_string(), 37.2);
     609a = Animal::Cat { name: "Spotty".to_string(), weight: 2.7 };
     610\end{rust}
     611Here, @Dog@ is an @enum@ variant, whereas @Cat@ is a struct-like variant.
     612
     613Each @enum@ type has an implicit integer tag (discriminant), with a unique value for each variant type.
     614Like a C enumeration, the tag values for the variant types start at 0 with auto incrementing.
     615The tag is re-purposed for enumeration by allowing it to be explicitly set, and auto incrmenting continues from that value.
    605616\begin{cquote}
    606 \sf\setlength{\tabcolsep}{20pt}
    607 \begin{tabular}{@{}ll@{}}
    608 \begin{rust}
    609 struct S {
    610         i : isize,  j : isize
    611 }
    612 enum @ADT@ {
    613         I(isize),   // int
    614         F(f64),   // float
    615         S(S),     // struct
    616 }
    617 \end{rust}
    618 &
    619 \begin{rust}
    620 let mut s = S{ i : 3, j : 4 };
    621 let mut adt : ADT;
    622 adt = 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 }
    628 \end{rust}
     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             &               \\
    629621\end{tabular}
    630622\end{cquote}
    631 When the variant types are the unit type, the ADT is still not an enumeration because there is no enumerating \see{\VRef{s:AlgebraicDataType}}.
     623In general, the tag can only be read as an opaque reference for comparison.
    632624\begin{rust}
    633 enum Week { Mon, Tues, Wed, Thu, Fri, Sat, Sun@,@ } // terminating comma
    634 let mut week : Week = Week::Mon;
    635 match week {
    636         Week::Mon => println!( "Mon" ),
    637         ...
    638         Week::Sun => println!( "Sun" ),
    639 }
     625if mem::discriminant(&week) == mem::discriminant(&Week::Mon) ...
    640626\end{rust}
    641 
    642 However, 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@{}}
     627If 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.
    646628\begin{rust}
    647 enum Week {
    648         Mon, Tues, Wed, // start 0
    649         Thu @= 10@, Fri,
    650         Sat, Sun,
    651 }
    652 
     629if week as isize == Week::Mon as isize ...
    653630\end{rust}
    654 &
    655 \begin{rust}
    656 #[repr(u8)]
    657 enum ADT {
    658         I(isize) @= 5@,  // ???
    659         F(f64) @= 10@,
    660         S(S) @= 0@,
    661 }
    662 \end{rust}
    663 \end{tabular}
    664 \end{cquote}
    665 Through 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}.
    666 When tags represent non-unit types, Rust largely precludes accessing the tag because the semantics become meaningless.
    667 Hence, the two mechanisms are largely disjoint, and ony the enumeration component is discussed.
    668 
    669 In detail, the @enum@ type has an implicit integer tag (discriminant), with a unique value for each variant type.
    670 Direct initialization is by a compile-time expression generating a constant value.
    671 Indirect initialization (without initialization, @Fri@/@Sun@) is auto-initialized: from left to right, starting at zero or the next explicitly initialized constant, incrementing by @1@.
    672 There is an explicit cast from the tag to integer.
    673 \begin{rust}
    674 let mut mon : isize = Week::Mon as isize;
    675 \end{rust}
    676 An 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++}
    681 if @week as isize@ == Week::Mon as isize {
    682         println!( "{:?}", week );
    683 }
    684 
    685 
    686 \end{c++}
    687 &
    688 \begin{c++}
    689 match @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}
    697 However, there is no mechanism to iterate through an enumeration without an casting to integral and positions versus values is not handled.
    698 \begin{c++}
    699 for d in Week::Mon as isize ..= Week::Sun as isize {
    700         print!( "{:?} ", d );
    701 }
    702 0 1 2 @3 4 5 6 7 8 9@ 10 11 12 13
    703 \end{c++}
    704 An enumeration type cannot declare an array dimension nor as a subscript.
    705 There is no mechanism to subtype or inherit from an enumeration.
    706631
    707632
    … …  
    22372162A basic variant is a list of nullary datatype constructors, which is like an unscoped, opaque enumeration.
    22382163\begin{ocaml}
    2239 type week = Mon | Tue | Wed | Thu | Fri | Sat | Sun
    2240 let day : week @= Mon@                          $\C{(* bind *)}$
    2241 let take_class( d : week ) =
     2164type weekday = Mon | Tue | Wed | Thu | Fri | Sat | Sun
     2165let day : weekday @= Mon@                               $\C{(* bind *)}$
     2166let take_class( d : weekday ) =
    22422167        @match@ d with                                          $\C{(* matching *)}$
    22432168                Mon | Wed -> Printf.printf "CS442\n" |
    … …  
    22502175The 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.
    22512176After compilation, variant names are mapped to an opague ascending intergral type discriminants, starting from 0.
    2252 Here, 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@.
    2253 The ``@_@'' 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.
     2177Here, 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@.
     2178The ``@_@'' 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.
    22542179Since the variant has no type, it has a \newterm{0-arity constructor}, \ie no parameters.
    2255 Because @week@ is a union of values @Mon@ to @Sun@, it is a \newterm{union type} in turns of the functional-programming paradigm.
     2180Because @weekday@ is a union of values @Mon@ to @Sun@, it is a \newterm{union type} in turns of the functional-programming paradigm.
    22562181
    22572182Each variant can have an associated heterogeneous type, with an n-ary constructor for creating a corresponding value.
    … …  
    23172242term "tag" further.
    23182243
    2319 <<Because week is a summation of values Mon to Sun, it is a sum type in
     2244<<Because weekday is a summation of values Mon to Sun, it is a sum type in
    23202245turns of the functional-programming paradigm>>
    23212246
    … …  
    23342259> I've marked 3 places with your name to shows places with enum ordering.
    23352260>
    2336 > type week = Mon | Tue | Wed | Thu | Fri | Sat | Sun
    2337 > let day : week = Mon
    2338 > let take_class( d : week ) =
     2261> type weekday = Mon | Tue | Wed | Thu | Fri | Sat | Sun
     2262> let day : weekday = Mon
     2263> let take_class( d : weekday ) =
    23392264>       if d <= Fri then                                (* Gregor *)
    2340 >               Printf.printf "week\n"
     2265>               Printf.printf "weekday\n"
    23412266>       else if d >= Sat then                   (* Gregor *)
    23422267>               Printf.printf "weekend\n";
    … …  
    25492474loop                    &               &               &               &               &               &               &               &               &               &               &               &               & \CM   \\
    25502475\hline
    2551 array/subscript &               &               &               &               &               &               &               &               &               &               & \CM   &               & \CM   \\
     2476array                   &               &               &               &               &               &               &               &               &               &               & \CM   &               & \CM   \\
    25522477\hline
    25532478subtype                 &               &               &               &               &               &               &               &               &               &               &               &               & \CM   \\

  • doc/theses/mike_brooks_MMath/background.tex

    r31f4837 racb33f15  
    437437class seqnode : public uSeqable { ... }
    438438%]
    439 A node inheriting from @uSeqable@ can appear in a sequence/collection but a node inheriting from @uColable@ can only appear in a collection.
     439A node inheriting from @uSeqable@ can appear in a sequence/collection but a node inherting 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 separate data allows some control;
     606Wrapped reference has no control over the link fields, but the seperate 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 managing multiple lists.
     692The downside is the dynamic allocation of the link nodes and manging 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 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.
     778A 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.
    779779A string can be read left-to-right, right-to-left, top-to-bottom, and have stacked elements (Arabic).
    780780
    781 A C character constant is an ASCII/Latin-1 character enclosed in single-quotes, \eg @'x'@, @'@\textsterling@'@.
    782 A 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.
    783 A character can be formed from an escape sequence, which expresses a non-typable character (@'\n'@), a delimiter character @'\''@, or a raw character @'\x2f'@.
    784 
    785 A character sequence is zero or more regular, wide, or escape characters enclosed in double-quotes @"xyz\n"@.
    786 The 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 
    788 For 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).
    789 For 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@.
    790 The value of a wide-character is implementation-defined, usually a UTF-16 character.
    791 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 wide characters corresponding to the multibyte character sequence, \eg @u"abc@$\mu$@"@, @U"abc@$\mu$@"@.
    792 The value of a @"u"@ character is an UTF-16 character;
    793 the value of a @"U"@ character is an UTF-32 character.
     781An integer character constant is a sequence of one or more multibyte characters enclosed in single-quotes, as in @'x'@.
     782A wide character constant is the same, except prefixed by the letter @L@, @u@, or @U@.
     783Except for escape sequences, the elements of the sequence are any members of the source character set;
     784they are mapped in an implementation-defined manner to members of the execution character set.
     785
     786A C character-string literal is a sequence of zero or more multibyte characters enclosed in double-quotes, as in @"xyz"@.
     787A UTF-8 string literal is the same, except prefixed by @u8@.
     788A wide string literal is the same, except prefixed by the letter @L@, @u@, or @U@.
     789
     790For 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.
     791For 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.
     792For 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.
    794793The value of a string literal containing a multibyte character or escape sequence not represented in the execution character set is implementation-defined.
    795794
    796 C strings are null-terminated rather than maintaining a separate string length.
     795
     796Another bad C design decision is to have null-terminated strings 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}
    802 Unfortunately, this design decision is both unsafe and inefficient.
    803 It 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.
    804 The 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 
    806 C strings are fixed size because arrays are used for the implementation.
    807 However, string manipulation commonly results in dynamically-sized temporary and final string values.
    808 As a result, storage management for C strings is a nightmare, quickly resulting in array overruns and incorrect results.
    809 
    810 Collectively, these design decisions make working with strings in C, awkward, time consuming, and very unsafe.
    811 While 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.
    812 Suffice it to say, C is not a go-to language for string applications, which is why \CC introduced the @string@ type.

  • driver/cfa.cc

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

  • libcfa/src/enum.hfa

    r31f4837 racb33f15  
    2626        forall(E | TypedEnum(T, E)) {
    2727                // comparison
    28                 int ?==?(E l, E r);                                                             // true if l and r are same enumerators
    29                 int ?!=?(E l, E r);                                                             // true if l and r are different enumerators
    30                 int ?!=?(E l, zero_t);                                                  // true if l is not the first enumerator
    31                 int ?<?(E l, E r);                                                              // true if l is an enuemerator before r
    32                 int ?<=?(E l, E r);                                                             // true if l before or the same as r
    33                 int ?>?(E l, E r);                                                              // true if l is an enuemrator after r
    34                 int ?>=?(E l, E r);                                                             // true if l after or the same as r
     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);
    3535        }
    3636}

  • src/AST/Decl.cpp

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

  • src/AST/Expr.cpp

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

  • src/AST/Inspect.cpp

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

  • src/AST/Label.hpp

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

  • src/AST/LinkageSpec.cpp

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

  • src/AST/LinkageSpec.hpp

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

  • src/AST/Node.hpp

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

  • src/AST/ParseNode.hpp

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

  • src/AST/Pass.hpp

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

  • src/AST/Pass.proto.hpp

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

  • src/AST/Print.hpp

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

  • src/AST/Stmt.hpp

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

  • src/AST/SymbolTable.cpp

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

  • src/AST/SymbolTable.hpp

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

  • src/AST/Type.cpp

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

  • src/AST/TypeEnvironment.cpp

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

  • src/AST/TypeEnvironment.hpp

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

  • src/AST/TypeSubstitution.cpp

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

  • src/AST/TypeSubstitution.hpp

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

  • src/AST/Util.cpp

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

  • src/BasicTypes-gen.cpp

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

  • src/CodeGen/CodeGenerator.cpp

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

  • src/CodeGen/CodeGenerator.hpp

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

  • src/CodeGen/module.mk

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

  • src/Common/CodeLocationTools.cpp

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

  • src/Common/DeclStats.cpp

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

  • src/Common/ResolvProtoDump.cpp

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

  • src/Common/module.mk

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

  • src/CompilationState.cpp

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

  • src/Concurrency/Corun.cpp

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

  • src/Concurrency/Keywords.cpp

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

  • src/Concurrency/Waitfor.cpp

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

  • src/Concurrency/Waituntil.cpp

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

  • src/Concurrency/Waituntil.hpp

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

  • src/Concurrency/module.mk

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

  • src/ControlStruct/ExceptDecl.cpp

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

  • src/ControlStruct/ExceptTranslate.cpp

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

  • src/ControlStruct/module.mk

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

  • src/GenPoly/Box.cpp

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

  • src/GenPoly/InstantiateGeneric.cpp

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

  • src/GenPoly/Lvalue.cpp

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

  • src/GenPoly/ScrubTypeVars.cpp

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

  • src/GenPoly/ScrubTypeVars.hpp

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

  • src/GenPoly/Specialize.cpp

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

  • src/GenPoly/module.mk

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

  • src/InitTweak/FixInit.cpp

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

  • src/InitTweak/module.mk

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

  • src/MakeLibCfa.cpp

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

  • src/Makefile.am

    r31f4837 racb33f15  
    5353include Virtual/module.mk
    5454
    55 $(addprefix $(srcdir)/, ResolvExpr/ConversionCost.cpp ResolvExpr/CommonType.cpp SymTab/ManglerCommon.cpp) : $(srcdir)/AST/BasicKind.hpp
     55$(addprefix $(srcdir)/, ResolvExpr/ConversionCost.cc ResolvExpr/CommonType.cc SymTab/ManglerCommon.cc) : $(srcdir)/AST/BasicKind.hpp
    5656
    5757$(srcdir)/AST/BasicKind.hpp : BasicTypes-gen.cpp
    … …  
    7373cfa_cpplib_PROGRAMS += $(DEMANGLER)
    7474EXTRA_PROGRAMS = ../driver/demangler
    75 ___driver_demangler_SOURCES = SymTab/demangler.cpp # test driver for the demangler, also useful as a sanity check that libdemangle.a is complete
     75___driver_demangler_SOURCES = SymTab/demangler.cc # test driver for the demangler, also useful as a sanity check that libdemangle.a is complete
    7676___driver_demangler_LDADD = libdemangle.a -ldl                  # yywrap
    7777noinst_LIBRARIES = $(LIBDEMANGLE)

  • src/Parser/RunParser.cpp

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

  • src/Parser/lex.ll

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

  • src/Parser/module.mk

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

  • src/Parser/parser.yy

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

  • src/ResolvExpr/Candidate.hpp

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

  • src/ResolvExpr/CandidateFinder.cpp

    r31f4837 racb33f15  
    1717
    1818#include <deque>
    19 #include <iterator>                 // for back_inserter
     19#include <iterator>               // for back_inserter
    2020#include <sstream>
    2121#include <string>
    … …  
    2525#include "AdjustExprType.hpp"
    2626#include "Candidate.hpp"
    27 #include "CastCost.hpp"             // for castCost
     27#include "CastCost.hpp"           // for castCost
    2828#include "CompilationState.hpp"
    29 #include "ConversionCost.hpp"       // for conversionCast
    30 #include "Cost.hpp"
     29#include "ConversionCost.h"       // for conversionCast
     30#include "Cost.h"
    3131#include "ExplodedArg.hpp"
    3232#include "PolyCost.hpp"
    33 #include "RenameVars.hpp"           // for renameTyVars
    34 #include "Resolver.hpp"
    35 #include "ResolveTypeof.hpp"
     33#include "RenameVars.h"           // for renameTyVars
     34#include "Resolver.h"
     35#include "ResolveTypeof.h"
    3636#include "SatisfyAssertions.hpp"
    3737#include "SpecCost.hpp"
    38 #include "Typeops.hpp"              // for combos
    39 #include "Unify.hpp"
    40 #include "WidenMode.hpp"
     38#include "typeops.h"              // for combos
     39#include "Unify.h"
     40#include "WidenMode.h"
    4141#include "AST/Expr.hpp"
    4242#include "AST/Node.hpp"
    … …  
    4545#include "AST/SymbolTable.hpp"
    4646#include "AST/Type.hpp"
    47 #include "Common/Utility.hpp"       // for move, copy
    48 #include "SymTab/Mangler.hpp"
    49 #include "Tuples/Tuples.hpp"        // for handleTupleAssignment
    50 #include "InitTweak/InitTweak.hpp"  // for getPointerBase
    51 
    52 #include "Common/Stats/Counter.hpp"
     47#include "Common/utility.h"       // for move, copy
     48#include "SymTab/Mangler.h"
     49#include "Tuples/Tuples.h"        // for handleTupleAssignment
     50#include "InitTweak/InitTweak.h"  // for getPointerBase
     51
     52#include "Common/Stats/Counter.h"
    5353
    5454#include "AST/Inspect.hpp"             // for getFunctionName

  • src/ResolvExpr/CandidatePrinter.cpp

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

  • src/ResolvExpr/CastCost.hpp

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

  • src/ResolvExpr/CommonType.hpp

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

  • src/ResolvExpr/ExplodedArg.cpp

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

  • src/ResolvExpr/ExplodedArg.hpp

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

  • src/ResolvExpr/SatisfyAssertions.cpp

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

  • src/ResolvExpr/module.mk

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

  • src/SymTab/GenImplicitCall.cpp

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

  • src/SymTab/GenImplicitCall.hpp

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

  • src/SymTab/module.mk

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

  • src/Tuples/TupleExpansion.cpp

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

  • src/Tuples/module.mk

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

  • src/Validate/Autogen.cpp

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

  • src/Validate/CompoundLiteral.cpp

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

  • src/Validate/EliminateTypedef.cpp

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

  • src/Validate/EnumAndPointerDecay.cpp

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

  • src/Validate/FindSpecialDecls.cpp

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

  • src/Validate/FixQualifiedTypes.cpp

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

  • src/Validate/FixReturnTypes.cpp

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

  • src/Validate/ForallPointerDecay.cpp

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

  • src/Validate/ImplementEnumFunc.cpp

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

  • src/Validate/ReplaceTypedef.cpp

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

  • src/Validate/VerifyCtorDtorAssign.cpp

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

  • src/Validate/module.mk

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

  • src/Virtual/module.mk

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

  • src/include/cassert

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

  • src/include/optional

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

  • src/main.cpp

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