Changes in / [e0a653d:33218c6]


Ignore:
Files:
8 added
29 deleted
180 edited

Legend:

Unmodified
Added
Removed
  • configure

    re0a653d r33218c6  
    34713471        case $host_cpu in
    34723472                i386)
    3473                         CFLAGS+="-m32"
    3474                         CXXFLAGS+="-m32"
    3475                         CFAFLAGS+="-m32"
    3476                         LDFLAGS+="-m32"
     3473                        CFLAGS+=" -m32 "
     3474                        CXXFLAGS+=" -m32 "
     3475                        CFAFLAGS+=" -m32 "
     3476                        LDFLAGS+=" -m32 "
    34773477                        ;;
    34783478                i686)
    3479                         CFLAGS+="-m32"
    3480                         CXXFLAGS+="-m32"
    3481                         CFAFLAGS+="-m32"
    3482                         LDFLAGS+="-m32"
     3479                        CFLAGS+=" -m32 "
     3480                  CXXFLAGS+=" -m32 "
     3481                  CFAFLAGS+=" -m32 "
     3482                  LDFLAGS+=" -m32 "
    34833483                        ;;
    34843484                x86_64)
    3485                         CFLAGS+="-m64"
    3486                         CXXFLAGS+="-m64"
    3487                         CFAFLAGS+="-m64"
    3488                         LDFLAGS+="-m64"
     3485                        CFLAGS+=" -m64 "
     3486                        CXXFLAGS+=" -m64 "
     3487                        CFAFLAGS+=" -m64 "
     3488                        LDFLAGS+=" -m64 "
    34893489                        ;;
    34903490        esac
  • configure.ac

    re0a653d r33218c6  
    167167AC_SUBST([MACHINE_TYPE],[$host_cpu])
    168168
    169 if ! test "$host_cpu" = "$build_cpu"; then 
     169if ! test "$host_cpu" = "$build_cpu"; then
    170170        case $host_cpu in
    171171                i386)
    172                         CFLAGS+="-m32"
    173                         CXXFLAGS+="-m32"
    174                         CFAFLAGS+="-m32"
    175                         LDFLAGS+="-m32"
     172                        CFLAGS+=" -m32 "
     173                        CXXFLAGS+=" -m32 "
     174                        CFAFLAGS+=" -m32 "
     175                        LDFLAGS+=" -m32 "
    176176                        ;;
    177177                i686)
    178                         CFLAGS+="-m32"
    179                         CXXFLAGS+="-m32"
    180                         CFAFLAGS+="-m32"
    181                         LDFLAGS+="-m32"
     178                        CFLAGS+=" -m32 "
     179                  CXXFLAGS+=" -m32 "
     180                  CFAFLAGS+=" -m32 "
     181                  LDFLAGS+=" -m32 "
    182182                        ;;
    183183                x86_64)
    184                         CFLAGS+="-m64"
    185                         CXXFLAGS+="-m64"
    186                         CFAFLAGS+="-m64"
    187                         LDFLAGS+="-m64"
     184                        CFLAGS+=" -m64 "
     185                        CXXFLAGS+=" -m64 "
     186                        CFAFLAGS+=" -m64 "
     187                        LDFLAGS+=" -m64 "
    188188                        ;;
    189189        esac
  • doc/LaTeXmacros/common.tex

    re0a653d r33218c6  
    1111%% Created On       : Sat Apr  9 10:06:17 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Sun Jun 18 20:32:32 2017
    14 %% Update Count     : 319
     13%% Last Modified On : Mon Jul 17 10:21:17 2017
     14%% Update Count     : 348
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
     
    3636% Names used in the document.
    3737
    38 \newcommand{\CFAIcon}{\textrm{C}\raisebox{\depth}{\rotatebox{180}{\textsf{A}}}\xspace} % Cforall symbolic name
     38\newcommand{\CFAIcon}{\textsf{C}\raisebox{\depth}{\rotatebox{180}{\textsf{A}}}\xspace} % Cforall symbolic name
    3939\newcommand{\CFA}{\protect\CFAIcon} % safe for section/caption
    4040\newcommand{\CFL}{\textrm{Cforall}\xspace} % Cforall symbolic name
     
    5555\setlength{\parindentlnth}{\parindent}
    5656
     57\newcommand{\LstKeywordStyle}[1]{{\lst@basicstyle{\lst@keywordstyle{#1}}}}
     58\newcommand{\LstCommentStyle}[1]{{\lst@basicstyle{\lst@commentstyle{#1}}}}
     59
    5760\newlength{\gcolumnposn}                                % temporary hack because lstlisting does not handle tabs correctly
    5861\newlength{\columnposn}
    5962\setlength{\gcolumnposn}{2.5in}
    6063\setlength{\columnposn}{\gcolumnposn}
    61 \newcommand{\C}[2][\@empty]{\ifx#1\@empty\else\global\setlength{\columnposn}{#1}\global\columnposn=\columnposn\fi\hfill\makebox[\textwidth-\columnposn][l]{\lst@commentstyle{#2}}}
     64\newcommand{\C}[2][\@empty]{\ifx#1\@empty\else\global\setlength{\columnposn}{#1}\global\columnposn=\columnposn\fi\hfill\makebox[\textwidth-\columnposn][l]{\lst@basicstyle{\LstCommentStyle{#2}}}}
    6265\newcommand{\CRT}{\global\columnposn=\gcolumnposn}
    6366
     
    131134
    132135% inline text and code index (cannot use ©)
    133 \newcommand{\Indexc}[1]{\lstinline$#1$\index{#1@\lstinline$#1$}}
     136\newcommand{\Indexc}[2][\@empty]{\lstinline[#1]$#2$\index{#2@\lstinline[#1]$#2$}}
    134137% code index (cannot use ©)
    135 \newcommand{\indexc}[1]{\index{#1@\lstinline$#1$}}
     138\newcommand{\indexc}[2][\@empty]{\index{#2@\lstinline[#1]$#2$}}
    136139
    137140% Denote newterms in particular font and index them without particular font and in lowercase, e.g., \newterm{abc}.
     
    231234basicstyle=\linespread{0.9}\sf,                                                 % reduce line spacing and use sanserif font
    232235stringstyle=\tt,                                                                                % use typewriter font
    233 tabsize=4,                                                                                              % 4 space tabbing
     236tabsize=6,                                                                                              % N space tabbing
    234237xleftmargin=\parindentlnth,                                                             % indent code to paragraph indentation
    235238extendedchars=true,                                                                             % allow ASCII characters in the range 128-255
  • doc/LaTeXmacros/lstlang.sty

    re0a653d r33218c6  
    88%% Created On       : Sat May 13 16:34:42 2017
    99%% Last Modified By : Peter A. Buhr
    10 %% Last Modified On : Thu Jun 22 07:40:31 2017
    11 %% Update Count     : 10
     10%% Last Modified On : Wed Jul 12 22:42:09 2017
     11%% Update Count     : 12
    1212%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1313
     
    112112                finally, forall, ftype, _Generic, _Imaginary, inline, __label__, lvalue, _Noreturn, one_t,
    113113                otype, restrict, _Static_assert, throw, throwResume, trait, try, ttype, typeof, __typeof,
    114                 __typeof__, zero_t},
     114                __typeof__, with, zero_t},
    115115        morekeywords=[2]{
    116116                _Atomic, coroutine, is_coroutine, is_monitor, is_thread, monitor, mutex, nomutex,
     
    118118        moredirectives={defined,include_next}%
    119119}
     120
     121% C++ programming language
     122\lstdefinelanguage{C++}[ANSI]{C++}{}
    120123
    121124% uC++ programming language, based on ANSI C++
  • doc/bibliography/cfa.bib

    re0a653d r33218c6  
    22732273@manual{JavaScript,
    22742274    keywords    = {JavaScript},
    2275     contributer = {pabuhr},
     2275    contributer = {pabuhr@plg},
    22762276    title       = {ECMAScript 2015 Language Specification {JavaScript}},
    22772277    organization= {ECAM International},
     
    24462446@manual{Erlang,
    24472447    keywords    = {Erlang},
    2448     contributer = {pabuhr},
     2448    contributer = {pabuhr@plg},
    24492449    title       = {Erlang Reference Manual User's Guide, Vertion 7.0},
    24502450    organization= {Erlang/OTP System Documentation},
     
    27712771    publisher   = {ACM},
    27722772    address     = {New York, NY, USA},
     2773}
     2774
     2775@article{Yang95,
     2776    keywords    = {software solutions, N-thread, mutual exclusions},
     2777    contributer = {pabuhr@plg},
     2778    author      = {Jae-Heon Yang and James H. Anderson},
     2779    title       = {A Fast, Scalable Mutual Exclusion Algorithm},
     2780    journal     = {Distributed Computing},
     2781    publisher   = {Springer-Verlag},
     2782    volume      = {9},
     2783    number      = {1},
     2784    year        = {1995},
     2785    pages       = {51-60},
    27732786}
    27742787
     
    50525065    contributer = {pabuhr@plg},
    50535066    author      = {Kathleen Jensen and Niklaus Wirth},
    5054     title       = {{P}ascal User Manual and Report},
     5067    title       = {{P}ascal User Manual and Report, ISO Pascal Standard},
    50555068    publisher   = {Springer--Verlag},
    5056     year        = 1985,
    5057     edition     = {3rd},
    5058     note        = {Revised by Andrew B. Mickel and James F. Miner, ISO Pascal Standard}
     5069    year        = 1991,
     5070    edition     = {4th},
     5071    note        = {Revised by Andrew B. Mickel and James F. Miner}
    50595072}
    50605073
  • doc/proposals/virtual.txt

    re0a653d r33218c6  
    11Proposal for virtual functionality
     2
     3There are two types of virtual inheritance in this proposal, relaxed
     4(implicit) and strict (explicit). Relaxed is the simpler case that uses the
     5existing trait system with the addition of trait references and vtables.
     6Strict adds some constraints and requires some additional notation but allows
     7for down-casting.
     8
     9Relaxed Virtual Inheritance:
    210
    311Imagine the following code :
     
    2028void draw(line*);
    2129
    22 While all the members of this simple UI support drawing creating a UI that easily
    23 supports both these UI requires some tedious boiler-plate code :
     30While all the members of this simple UI support drawing, creating a UI that
     31easily supports both these UI requires some tedious boiler-plate code:
    2432
    2533enum type_t { text, line };
     
    4149}
    4250
    43 While this code will work as indented, adding any new widgets or any new widget behaviors
    44 requires changing existing code to add the desired functionality. To ease this maintenance
    45 effort required CFA introduces the concept of dynamic types, in a manner similar to C++.
    46 
    47 A simple usage of dynamic type with the previous example would look like :
    48 
    49 drawable* objects[10];
     51While this code will work as implemented, adding any new widgets or any new
     52widget behaviors requires changing existing code to add the desired
     53functionality. To ease this maintenance effort required CFA introduces the
     54concept of trait references.
     55
     56Using trait references to implement the above gives the following :
     57
     58trait drawable objects[10];
    5059fill_objects(objects);
    5160
    5261while(running) {
    53       for(drawable* object : objects) {
     62      for(drawable object : objects) {
    5463            draw(object);
    5564      }
    5665}
    5766
    58 However, this is not currently do-able in the current CFA and furthermore is not
    59 possible to implement statically. Therefore we need to add a new feature to handle
    60 having dynamic types like this (That is types that are found dynamically not types
    61 that change dynamically).
    62 
    63 C++ uses inheritance and virtual functions to find the
    64 desired type dynamically. CFA takes inspiration from this solution.
    65 
    66 What we really want to do is express the fact that calling draw() on a object
    67 should find the dynamic type of the parameter before calling the routine, much like the
    68 hand written example given above. We can express this by adding the virtual keyword on
    69 the parameter of the constraints on our trait:
     67The keyword trait is optional (by the same rules as the struct keyword). This
     68is not currently supported in CFA and the lookup is not possible to implement
     69statically. Therefore we need to add a new feature to handle having dynamic
     70lookups like this.
     71
     72What we really want to do is express the fact that calling draw() on a trait
     73reference should find the underlying type of the given parameter and find how
     74it implements the routine, as in the example with the enumeration and union.
     75
     76For instance specifying that the drawable trait reference looks up the type
     77of the first argument to find the implementation would be :
    7078
    7179trait drawable(otype T) {
     
    7381};
    7482
    75 This expresses the idea that drawable is similar to an abstract base class in C++ and
    76 also gives meaning to trying to take a pointer of drawable. That is anything that can
    77 be cast to a drawable pointer has the necessary information to call the draw routine on
    78 that type. Before that drawable was only a abstract type while now it also points to a
    79 piece of storage which specify which behavior the object will have at run time.
    80 
    81 This storage needs to be allocate somewhere. C++ just adds an invisible pointer at
    82 the beginning of the struct but we can do something more explicit for users, actually
    83 have a visible special field :
    84 
    85 struct text {
    86       char* text;
    87       vtable drawable;
    88 };
    89 
    90 struct line{
    91       vtable drawable;
    92       vec2 start;
    93       vec2 end;
    94 };
    95 
    96 With these semantics, adding a "vtable drawable" means that text pointers and line pointers are now
    97 convertible to drawable pointers. This conversion will not necessarily be a type only change however, indeed,
    98 the drawable pointer will point to the field "vtable drawable" not the head of the struct. However, since all
    99 the types are known at compile time, converting pointers becomes a simple offset operations.
    100 
    101 The vtable field contains a pointer to a vtable which contains all the information needed for the caller
    102 to find the function pointer of the desired behavior.
    103 
    104 One of the limitations of this design is that it does not support double dispatching, which
    105 concretely means traits cannot have routines with more than one virtual parameter. This design
    106 would have many ambiguities if it did support multiple virtual parameter. A futher limitation is
    107 that traits over more than one type cannot have vtables meaningfully defined for them, as the
    108 particular vtable to use would be a function of the other type(s) the trait is defined over.
    109 
    110 It is worth noting that the function pointers in these vtables are bound at object construction, rather than
    111 function call-site, as in Cforall's existing polymorphic functions. As such, it is possible that two objects
    112 with the same static type would have a different vtable (consider what happens if draw(line*) is overridden
    113 between the definitions of two line objects). Given that the virtual drawable* erases static types though,
    114 this should not be confusing in practice. A more distressing possibility is that of creating an object that
    115 outlives the scope of one of the functions in its vtable. This is certainly a possible bug, but it is of a
    116 type that C programmers are familiar with, and should be able to avoid by the usual methods.
    117 
    118 Extensibility.
    119 
    120 One of the obvious critics of this implementation is that it lacks extensibility for classes
    121 that cannot be modified (ex: Linux C headers). However this solution can be extended to
    122 allow more extensibility by adding "Fat pointers".
    123 
    124 Indeed, users could already "solve" this issue by writing their own fat pointers as such:
    125 
    126 trait MyContext(otype T) {
    127       void* get_stack(virtual T*)
    128 };
    129 
    130 void* get_stack(ucontext_t *context);
    131 
    132 struct fat_ucontext_t {
    133       vtable MyContext;
    134       ucontext_t *context;
    135 }
    136 
    137 //Tedious forwarding routine
    138 void* get_stack(fat_ucontext_t *ptr) {
    139       return get_stack(ptr->context);
    140 }
    141 
    142 However, users would have to write all the virtual methods they want to override and make
    143 them all simply forward to the existing method that takes the corresponding POCO(Plain Old C Object).
    144 
    145 The alternative we propose is to use language level fat pointers :
    146 
    147 trait MyContext(otype T) {
    148       void* get_stack(virtual T*)
    149 };
    150 
    151 void* get_stack(ucontext_t *context);
    152 
    153 //The type vptr(ucontext_t) all
    154 vptr(ucontext_t) context;
    155 
    156 These behave exactly as the previous example but all the forwarding routines are automatically generated.
    157 
    158 Bikeshedding.
    159 
    160 It may be desirable to add fewer new keywords than discussed in this proposal; it is possible that "virtual"
    161 could replace both "vtable" and "vptr" above with unambiguous contextual meaning. However, for purposes of
    162 clarity in the design discussion it is beneficial to keep the keywords for separate concepts distinct.
    163 
     83This could be implied in simple cases like this one (single parameter on the
     84trait and single generic parameter on the function). In more complex cases it
     85would have to be explicitly given, or a strong convention would have to be
     86enforced (e.g. implementation of trait functions is always drawn from the
     87first polymorphic parameter).
     88
     89Once a function in a trait has been marked as virtual it defines a new
     90function that takes in that trait's reference and then dynamically calls the
     91underlying type implementation. Hence a trait reference becomes a kind of
     92abstract type, cannot be directly instantiated but can still be used.
     93
     94One of the limitations of this design is that it does not support double
     95dispatching, which concretely means traits cannot have routines with more than
     96one virtual parameter. The program must have a single table to look up the
     97function on. Using trait references with traits with more than one parameter
     98is also restricted, initially forbidden, see extension.
     99
     100Extension: Multi-parameter Virtual Traits:
     101
     102This implementation can be extended to traits with multiple parameters if
     103one is called out as being the virtual trait. For example :
     104
     105trait iterator(otype T, dtype Item) {
     106        Maybe(Item) next(virtual T *);
     107}
     108
     109iterator(int) generators[10];
     110
     111Which creates a collection of iterators that produce integers, regardless of
     112how those iterators are implemented. This may require a note that this trait
     113is virtual on T and not Item, but noting it on the functions may be enough.
     114
     115
     116Strict Virtual Inheritance:
     117
     118One powerful feature relaxed virtual does not support is the idea of down
     119casting. Once something has been converted into a trait reference there is
     120very little we can do to recover and of the type information, only the trait's
     121required function implementations are kept.
     122
     123To allow down casting strict virtual requires that all traits and structures
     124involved be organized into a tree. Each trait or struct must have a unique
     125position on this tree (no multiple inheritance).
     126
     127This is declared as follows :
     128
     129trait error(otype T) virtual {
     130        const char * msg(T *);
     131}
     132
     133trait io_error(otype T) virtual error {
     134        FILE * src(T *);
     135}
     136
     137struct eof_error virtual io_error {
     138        FILE * fd;
     139};
     140
     141So the trait error is the head of a new tree and io_error is a child of it.
     142
     143Also the parent trait is implicitly part of the assertions of the children,
     144so all children implement the same operations as the parent. By the unique
     145path down the tree, we can also uniquely order them so that a prefix of a
     146child's vtable has the same format as its parent's.
     147
     148This gives us an important extra feature, runtime checking of the parent-child
     149relationship with a C++ dynamic_cast like operation. Allowing checked
     150conversions from trait references to more particular references, which works
     151if the underlying type is, or is a child of, the new trait type.
     152
     153Extension: Multiple Parents
     154
     155Although each trait/struct must have a unique position on each tree, it could
     156have positions on multiple trees. All this requires is the ability to give
     157multiple parents, as here :
     158
     159trait region(otype T) virtual drawable, collider;
     160
     161The restriction being, the parents must come from different trees. This
     162object (and all of its children) can be cast to either tree. This is handled
     163by generating a separate vtable for each tree the structure is in.
     164
     165Extension: Multi-parameter Strict Virtual
     166
     167If a trait has multiple parameters then one must be called out to be the one
     168we generate separate vtables for, as in :
     169
     170trait example(otype T, otype U) virtual(T) ...
     171
     172This can generate a separate vtable for each U for which all the T+U
     173implementations are provided. These are then separate nodes in the tree (or
     174the root of different trees) as if each was created individually. Providing a
     175single unique instance of these nodes would be the most difficult aspect of
     176this extension, possibly intractable, though with sufficient hoisting and
     177link-once duplication it may be possible.
     178
     179Example:
     180
     181trait argument(otype T) virtual {
     182        char short_name(virtual T *);
     183        bool is_set(virtual T *);
     184};
     185
     186trait value_argument(otype T, otype U) virtual(T) argument {
     187        U get_value(virtual T *);
     188};
     189
     190Extension: Structural Inheritance
     191
     192Currently traits must be the internal nodes and structs the leaf nodes.
     193Structs could be made internal nodes as well, in which case the child structs
     194would likely structurally inherit the fields of their parents.
     195
     196
     197Storing the Virtual Lookup Table (vtable):
     198
     199We have so far been silent on how the vtable is created, stored and accessed.
     200
     201Creation happens at compile time. Function pointers are found by using the
     202same best match rules as elsewhere (additional rules for defaults from the
     203parent may or may not be required). For strict virtual this must happen at the
     204global scope and forbidding static functions, to ensure that a single unique
     205vtable is created. Similarly, there may have to be stricter matching rules
     206for the functions that go into the vtable, possibly requiring an exact match.
     207Relaxed virtual could relax both restrictions, if we allow different vtable
     208at different conversion (struct to trait reference) sites. If it is allowed
     209local functions being bound to a vtable could cause issues when they go out
     210of scope, however this should follow the lifetime rules most C programs
     211already follow implicitly.
     212
     213Most vtables should be stored statically, the only exception being some of
     214the relaxed vtables that could have local function pointers. These may be able
     215to be stack allocated. All vtables should be immutable and require no manual
     216cleanup.
     217
     218Access has two main options:
     219
     220The first is through the use of fat pointers, or a tuple of pointers. When the
     221object is converted to a trait reference, the pointers to its vtables are
     222stored along side it.
     223
     224This allows for compatibility with existing structures (such as those imported
     225from C) and is the default storage method unless a different one is given.
     226
     227The other is by inlining the vtable pointer as "intrusive vtables". This adds
     228a field to the structure to the vtable. The trait reference then has a single
     229pointer to this field, the vtable includes an offset to find the beginning of
     230the structure again.
     231
     232This is used if you specify a vtable field in the structure. If given in the
     233trait the vtable pointer in the trait reference can then become a single
     234pointer to the vtable field and use that to recover the original object
     235pointer as well as retrieve all operations.
     236
     237trait drawable(otype T) {
     238        vtable drawable;
     239};
     240
     241struct line {
     242        vtable drawable;
     243        vec2 start;
     244        vec2 end;
     245};
     246
     247This inline code allows trait references to be converted to plain pointers
     248(although they still must be called specially). The vtable field may just be
     249an opaque block of memory or it may allow user access to the vtable. If so
     250then there should be some way to retrieve the type of the vtable, which will be
     251autogenerated and often unique.
     252
     253
     254Keyword Usage:
     255
     256It may be desirable to add fewer new keywords than discussed in this proposal.
     257It is possible that "virtual" could replace both "vtable" above with
     258unambiguous contextual meaning. However, for purposes of clarity in the design
     259discussion it is beneficial to keep the keywords for separate concepts distinct.
     260
     261
     262Trait References and Operations:
     263
     264sizeof(drawable) will return the size of the trait object itself. However :
     265
     266line a_line;
     267drawable widget = a_line;
     268sizeof(widget);
     269
     270Will instead return the sizeof the underlying object, although the trait must
     271require that its implementation is sized for there to be a meaningful value
     272to return. You may also get the size of the trait reference with
     273
     274sizeof(&widget);
     275
     276Calling free on a trait reference will free the memory for the object. It will
     277leave the vtables alone, as those are (always?) statically allocated.
  • doc/user/EHMHierarchy.fig

    re0a653d r33218c6  
    1 #FIG 3.2  Produced by xfig version 3.2.5b
     1#FIG 3.2  Produced by xfig version 3.2.5c
    22Landscape
    33Center
     
    19192 1 0 1 0 7 100 0 -1 0.000 0 0 -1 1 0 2
    2020        1 1 1.00 60.00 90.00
    21          1950 1425 3000 1200
     21         1950 1425 2925 1200
    22222 1 0 1 0 7 100 0 -1 0.000 0 0 -1 1 0 2
    2323        1 1 1.00 60.00 90.00
     
    2929        1 1 1.00 60.00 90.00
    3030         4950 1950 4950 1725
    31 4 1 0 100 0 0 12 0.0000 0 135 195 1950 1650 IO\001
    32 4 1 0 100 0 0 12 0.0000 0 135 870 4950 1650 Arithmetic\001
    33 4 1 0 100 0 0 12 0.0000 0 135 315 1350 2100 File\001
    34 4 1 0 100 0 0 12 0.0000 0 135 690 2550 2100 Network\001
    35 4 1 0 100 0 0 12 0.0000 0 180 1170 3750 2100 DivideByZero\001
    36 4 1 0 100 0 0 12 0.0000 0 135 750 4950 2100 Overflow\001
    37 4 1 0 100 0 0 12 0.0000 0 135 855 6000 2100 Underflow\001
    38 4 1 0 100 0 0 12 0.0000 0 180 840 3450 1200 Exception\001
     314 1 0 50 -1 0 13 0.0000 2 135 225 1950 1650 IO\001
     324 1 0 50 -1 0 13 0.0000 2 135 915 4950 1650 Arithmetic\001
     334 1 0 50 -1 0 13 0.0000 2 150 330 1350 2100 File\001
     344 1 0 50 -1 0 13 0.0000 2 135 735 2550 2100 Network\001
     354 1 0 50 -1 0 13 0.0000 2 180 1215 3750 2100 DivideByZero\001
     364 1 0 50 -1 0 13 0.0000 2 150 810 4950 2100 Overflow\001
     374 1 0 50 -1 0 13 0.0000 2 150 915 6000 2100 Underflow\001
     384 1 0 50 -1 0 13 0.0000 2 180 855 3450 1200 Exception\001
  • doc/user/Makefile

    re0a653d r33218c6  
    11## Define the appropriate configuration variables.
    22
    3 TeXLIB = .:../LaTeXmacros:../LaTeXmacros/listings:../LaTeXmacros/enumitem:../bibliography/:
     3TeXLIB = .:../LaTeXmacros:../bibliography/:
    44LaTeX  = TEXINPUTS=${TeXLIB} && export TEXINPUTS && latex -halt-on-error
    55BibTeX = BIBINPUTS=${TeXLIB} && export BIBINPUTS && bibtex
  • doc/user/user.tex

    re0a653d r33218c6  
    1111%% Created On       : Wed Apr  6 14:53:29 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Fri Jul  7 10:36:39 2017
    14 %% Update Count     : 2547
     13%% Last Modified On : Sat Jul 22 11:01:19 2017
     14%% Update Count     : 2878
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
     
    5757\CFAStyle                                                                                               % use default CFA format-style
    5858
     59\lstnewenvironment{C++}[1][]
     60{\lstset{language=C++,moredelim=**[is][\protect\color{red}]{®}{®}#1}}
     61{}
     62
    5963% inline code ©...© (copyright symbol) emacs: C-q M-)
    6064% red highlighting ®...® (registered trademark symbol) emacs: C-q M-.
     
    137141
    138142\CFA{}\index{cforall@\CFA}\footnote{Pronounced ``\Index*{C-for-all}'', and written \CFA, CFA, or \CFL.} is a modern general-purpose programming-language, designed as an evolutionary step forward for the C programming language.
    139 The syntax of the \CFA language builds from C, and should look immediately familiar to C/\Index*[C++]{\CC{}} programmers.
     143The syntax of \CFA builds from C and should look immediately familiar to C/\Index*[C++]{\CC{}} programmers.
    140144% Any language feature that is not described here can be assumed to be using the standard \Celeven syntax.
    141 \CFA adds many modern programming-language features that directly lead to increased \emph{\Index{safety}} and \emph{\Index{productivity}}, while maintaining interoperability with existing C programs and achieving C performance.
    142 Like C, \CFA is a statically typed, procedural language with a low-overhead runtime, meaning there is no global \Index{garbage-collection}, but \Index{regional garbage-collection}\index{garbage-collection!regional} is possible.
     145\CFA adds many modern programming-language features that directly lead to increased \emph{\Index{safety}} and \emph{\Index{productivity}}, while maintaining interoperability with existing C programs and achieving similar performance.
     146Like C, \CFA is a statically typed, procedural (non-\Index{object-oriented}) language with a low-overhead runtime, meaning there is no global \Index{garbage-collection}, but \Index{regional garbage-collection}\index{garbage-collection!regional} is possible.
    143147The primary new features include parametric-polymorphic routines and types, exceptions, concurrency, and modules.
    144148
    145 One of the main design philosophies of \CFA is to ``describe not prescribe'', which means \CFA tries to provide a pathway from low-level C programming to high-level \CFA programming, but it does not force programmers to ``do the right thing''.
    146 Programmers can cautiously add \CFA extensions to their C programs in any order and at any time to incrementally move towards safer, higher-level programming features.
    147 A programmer is always free to reach back to C from \CFA for any reason, and in many cases, new \CFA features have a fallback to a C mechanism.
    148 There is no notion or requirement for rewriting a legacy C program in \CFA;
    149 instead, a programmer evolves an existing C program into \CFA by incrementally incorporating \CFA features.
    150 New programs can be written in \CFA using a combination of C and \CFA features.
    151 \Index*[C++]{\CC{}} had a similar goal 30 years ago, but currently has the disadvantages of multiple legacy design-choices that cannot be updated and active divergence of the language model from C, requiring significant effort and training to incrementally add \CC to a C-based project.
     149One of the main design philosophies of \CFA is to ``\Index{describe not prescribe}'', which means \CFA tries to provide a pathway from low-level C programming to high-level \CFA programming, but it does not force programmers to ``do the right thing''.
     150Programmers can cautiously add \CFA extensions to their C programs in any order and at any time to incrementally move towards safer, higher-level programming.
     151A programmer is always free to reach back to C from \CFA, for any reason, and in many cases, new \CFA features can be locally switched back to there C counterpart.
     152There is no notion or requirement for \emph{rewriting} a legacy C program in \CFA;
     153instead, a programmer evolves a legacy program into \CFA by incrementally incorporating \CFA features.
     154As well, new programs can be written in \CFA using a combination of C and \CFA features.
     155
     156\Index*[C++]{\CC{}} had a similar goal 30 years ago, allowing object-oriented programming to be incrementally added to C.
     157However, \CC currently has the disadvantages of a strong object-oriented bias, multiple legacy design-choices that cannot be updated, and active divergence of the language model from C, all of which requires significant effort and training to incrementally add \CC to a C-based project.
    152158In contrast, \CFA has 30 years of hindsight and a clean starting point.
    153159
     
    156162\begin{quote2}
    157163\begin{tabular}{@{}l@{\hspace{1.5em}}l@{\hspace{1.5em}}l@{}}
    158 \multicolumn{1}{c@{\hspace{1.5em}}}{\textbf{\CFA}}      & \multicolumn{1}{c}{\textbf{C}}        & \multicolumn{1}{c}{\textbf{\CC}}      \\
    159 \begin{cfa}
    160 #include <fstream>§\indexc{fstream}§
    161 
    162 int main( void ) {
    163         int x = 0, y = 1, z = 2;
    164         ®sout | x | y | z | endl;®
    165 }
    166 \end{cfa}
    167 &
    168 \begin{lstlisting}
     164\multicolumn{1}{c@{\hspace{1.5em}}}{\textbf{C}} & \multicolumn{1}{c}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{\CC}}      \\
     165\begin{cfa}
    169166#include <stdio.h>§\indexc{stdio.h}§
    170167
     
    173170        ®printf( "%d %d %d\n", x, y, z );®
    174171}
    175 \end{lstlisting}
     172\end{cfa}
    176173&
    177 \begin{lstlisting}
     174\begin{cfa}
     175#include <fstream>§\indexc{fstream}§
     176
     177int main( void ) {
     178        int x = 0, y = 1, z = 2;
     179        ®sout | x | y | z | endl;®§\indexc{sout}§
     180}
     181\end{cfa}
     182&
     183\begin{cfa}
    178184#include <iostream>§\indexc{iostream}§
    179185using namespace std;
     
    182188        ®cout<<x<<" "<<y<<" "<<z<<endl;®
    183189}
    184 \end{lstlisting}
     190\end{cfa}
    185191\end{tabular}
    186192\end{quote2}
    187193While the \CFA I/O looks similar to the \Index*[C++]{\CC{}} output style, there are important differences, such as automatic spacing between variables as in \Index*{Python} (see~\VRef{s:IOLibrary}).
    188194
     195\subsection{Background}
     196
    189197This document is a programmer reference-manual for the \CFA programming language.
    190198The manual covers the core features of the language and runtime-system, with simple examples illustrating syntax and semantics of each feature.
    191199The manual does not teach programming, i.e., how to combine the new constructs to build complex programs.
    192 A reader should already have an intermediate knowledge of control flow, data structures, and concurrency issues to understand the ideas presented as well as some experience programming in C/\CC.
    193 Implementers may refer to the \CFA Programming Language Specification for details about the language syntax and semantics.
     200A reader should already have an intermediate knowledge of control flow, data structures, and concurrency issues to understand the ideas presented, as well as some experience programming in C/\CC.
     201Implementers should refer to the \CFA Programming Language Specification for details about the language syntax and semantics.
    194202Changes to the syntax and additional features are expected to be included in later revisions.
    195203
     
    200208This installation base and the programmers producing it represent a massive software-engineering investment spanning decades and likely to continue for decades more.
    201209Even with all its problems, C continues to be popular because it allows writing software at virtually any level in a computer system without restriction.
    202 For system programming, where direct access to hardware and dealing with real-time issues is a requirement, C is usually the language of choice.
     210For system programming, where direct access to hardware, storage management, and real-time issues are a requirement, C is usually the only language of choice.
    203211The TIOBE index~\cite{TIOBE} for March 2016 showed the following programming-language popularity: \Index*{Java} 20.5\%, C 14.5\%, \Index*[C++]{\CC{}} 6.7\%, \Csharp 4.3\%, \Index*{Python} 4.3\%, where the next 50 languages are less than 3\% each with a long tail.
    204212As well, for 30 years, C has been the number 1 and 2 most popular programming language:
     
    216224\end{center}
    217225Hence, C is still an extremely important programming language, with double the usage of \Index*[C++]{\CC{}}; in many cases, \CC is often used solely as a better C.
    218 Love it or hate it, C has been an important and influential part of computer science for 40 years and sit appeal is not diminishing.
    219 Unfortunately, C has too many problems and omissions to make it an acceptable programming language for modern needs.
    220 
    221 As stated, the goal of the \CFA project is to engineer modern language features into C in an evolutionary rather than revolutionary way.
     226Love it or hate it, C has been an important and influential part of computer science for 40 years and its appeal is not diminishing.
     227Unfortunately, C has many problems and omissions that make it an unacceptable programming language for modern needs.
     228
     229As stated, the goal of the \CFA project is to engineer modern language-features into C in an evolutionary rather than revolutionary way.
    222230\CC~\cite{C++14,C++} is an example of a similar project;
    223 however, it largely extended the language, and did not address many existing problems.\footnote{%
     231however, it largely extended the C language, and did not address most of C's existing problems.\footnote{%
    224232Two important existing problems addressed were changing the type of character literals from ©int© to ©char© and enumerator from ©int© to the type of its enumerators.}
    225 \Index*{Fortran}~\cite{Fortran08}, \Index*{Ada}~\cite{Ada12}, and \Index*{Cobol}~\cite{Cobol14} are examples of programming languages that took an evolutionary approach, where modern language features (\eg objects, concurrency) are added and problems fixed within the framework of the existing language.
     233\Index*{Fortran}~\cite{Fortran08}, \Index*{Ada}~\cite{Ada12}, and \Index*{Cobol}~\cite{Cobol14} are examples of programming languages that took an evolutionary approach, where modern language-features (\eg objects, concurrency) are added and problems fixed within the framework of the existing language.
    226234\Index*{Java}~\cite{Java8}, \Index*{Go}~\cite{Go}, \Index*{Rust}~\cite{Rust} and \Index*{D}~\cite{D} are examples of the revolutionary approach for modernizing C/\CC, resulting in a new language rather than an extension of the descendent.
    227 These languages have different syntax and semantics from C, and do not interoperate directly with C, largely because of garbage collection.
     235These languages have different syntax and semantics from C, do not interoperate directly with C, and are not systems languages because of restrictive memory-management or garbage collection.
    228236As a result, there is a significant learning curve to move to these languages, and C legacy-code must be rewritten.
    229 These costs can be prohibitive for many companies with a large software base in C/\CC, and a significant number of programmers requiring retraining to a new programming language.
    230 
    231 The result of this project is a language that is largely backwards compatible with \Index*[C11]{\Celeven{}}~\cite{C11}, but fixing some of the well known C problems and containing many modern language features.
     237These costs can be prohibitive for many companies with a large software-base in C/\CC, and a significant number of programmers require retraining to the new programming language.
     238
     239The result of this project is a language that is largely backwards compatible with \Index*[C11]{\Celeven{}}~\cite{C11}, but fixes many of the well known C problems while containing modern language-features.
    232240Without significant extension to the C programming language, it is becoming unable to cope with the needs of modern programming problems and programmers;
    233241as a result, it will fade into disuse.
    234242Considering the large body of existing C code and programmers, there is significant impetus to ensure C is transformed into a modern programming language.
    235 While \Index*[C11]{\Celeven{}} made a few simple extensions to the language, nothing was added to address existing problems in the language or to augment the language with modern language features.
    236 While some may argue that modern language features may make C complex and inefficient, it is clear a language without modern capabilities is insufficient for the advanced programming problems existing today.
     243While \Index*[C11]{\Celeven{}} made a few simple extensions to the language, nothing was added to address existing problems in the language or to augment the language with modern language-features.
     244While some may argue that modern language-features may make C complex and inefficient, it is clear a language without modern capabilities is insufficient for the advanced programming problems existing today.
    237245
    238246
    239247\section{History}
    240248
    241 The \CFA project started with \Index*{K-W C}~\cite{Buhr94a,Till89}, which extended C with new declaration syntax, multiple return values from routines, and extended assignment capabilities using the notion of tuples.
     249The \CFA project started with \Index*{K-W C}~\cite{Buhr94a,Till89}, which extended C with new declaration syntax, multiple return values from routines, and advanced assignment capabilities using the notion of tuples.
    242250(See~\cite{Werther96} for similar work in \Index*[C++]{\CC{}}.)
    243 A first \CFA implementation of these extensions was by Esteves~\cite{Esteves04}.
    244 The signature feature of \CFA is parametric-polymorphic functions~\cite{forceone:impl,Cormack90,Duggan96} with functions generalized using a ©forall© clause (giving the language its name):
     251The first \CFA implementation of these extensions was by Esteves~\cite{Esteves04}.
     252
     253The signature feature of \CFA is \emph{\Index{overload}able} \Index{parametric-polymorphic} functions~\cite{forceone:impl,Cormack90,Duggan96} with functions generalized using a ©forall© clause (giving the language its name):
    245254\begin{lstlisting}
    246255®forall( otype T )® T identity( T val ) { return val; }
     
    248257\end{lstlisting}
    249258% extending the C type system with parametric polymorphism and overloading, as opposed to the \Index*[C++]{\CC{}} approach of object-oriented extensions.
    250 \CFA{}\hspace{1pt}'s polymorphism was originally formalized by Ditchfiled~\cite{Ditchfield92}, and first implemented by Bilson~\cite{Bilson03}.
     259\CFA{}\hspace{1pt}'s polymorphism was originally formalized by Ditchfield~\cite{Ditchfield92}, and first implemented by Bilson~\cite{Bilson03}.
    251260However, at that time, there was little interesting in extending C, so work did not continue.
    252 As the saying goes, ``What goes around, comes around.'', and there is now renewed interest in the C programming language because of legacy code-bases, so the \CFA project has been restarted.
     261As the saying goes, ``\Index*{What goes around, comes around.}'', and there is now renewed interest in the C programming language because of legacy code-bases, so the \CFA project has been restarted.
    253262
    254263
     
    257266
    258267\CFA is designed to integrate directly with existing C programs and libraries.
    259 The most important feature of \Index{interoperability} is using the same \Index{calling convention}s, so there is no overhead to call existing C routines.
     268The most important feature of \Index{interoperability} is using the same \Index{calling convention}s, so there is no complex interface or overhead to call existing C routines.
    260269This feature allows \CFA programmers to take advantage of the existing panoply of C libraries to access thousands of external software features.
    261270Language developers often state that adequate \Index{library support} takes more work than designing and implementing the language itself.
    262271Fortunately, \CFA, like \Index*[C++]{\CC{}}, starts with immediate access to all exiting C libraries, and in many cases, can easily wrap library routines with simpler and safer interfaces, at very low cost.
    263 Hence, \CFA begins by leveraging the large repository of C libraries with little cost.
     272Hence, \CFA begins by leveraging the large repository of C libraries, and than allows programmers to incrementally augment their C programs with modern \Index{backward-compatible} features.
    264273
    265274\begin{comment}
     
    304313\end{comment}
    305314
    306 However, it is necessary to differentiate between C and \CFA code because of name overloading, as for \CC.
     315However, it is necessary to differentiate between C and \CFA code because of name \Index{overload}ing, as for \CC.
    307316For example, the C math-library provides the following routines for computing the absolute value of the basic types: ©abs©, ©labs©, ©llabs©, ©fabs©, ©fabsf©, ©fabsl©, ©cabsf©, ©cabs©, and ©cabsl©.
    308 Whereas, \CFA wraps each of these routines into ones with the common name ©abs©:
     317Whereas, \CFA wraps each of these routines into ones with the overloaded name ©abs©:
    309318\begin{cfa}
    310319char abs( char );
    311 ®extern "C" {®
    312 int abs( int );                                                 §\C{// use default C routine for int}§
    313 ®}® // extern "C"
     320®extern "C" {® int abs( int ); ®}®              §\C{// use default C routine for int}§
    314321long int abs( long int );
    315322long long int abs( long long int );
     
    326333Hence, there is the same need as in \CC, to know if a name is a C or \CFA name, so it can be correctly formed.
    327334There is no way around this problem, other than C's approach of creating unique names for each pairing of operation and type.
    328 This example strongly illustrates a core idea in \CFA: \emph{the power of a name}.
     335
     336This example strongly illustrates a core idea in \CFA: \emph{the \Index{power of a name}}.
    329337The name ``©abs©'' evokes the notion of absolute value, and many mathematical types provide the notion of absolute value.
    330 Hence, knowing the name ©abs© should be sufficient to apply it to any type where it is applicable.
    331 The time savings and safety of using one name uniformly versus $N$ unique names should not be underestimated.
    332 
    333 
    334 \section[Compiling CFA Program]{Compiling \CFA Program}
    335 
    336 The command ©cfa© is used to compile \CFA program(s), and is based on the GNU \Indexc{gcc} command, \eg:
    337 \begin{cfa}
    338 cfa§\indexc{cfa}\index{compilation!cfa@©cfa©}§ [ gcc-options ] C/§\CFA§-files [ assembler/loader-files ]
     338Hence, knowing the name ©abs© is sufficient to apply it to any type where it is applicable.
     339The time savings and safety of using one name uniformly versus $N$ unique names cannot be underestimated.
     340
     341
     342\section[Compiling a CFA Program]{Compiling a \CFA Program}
     343
     344The command ©cfa© is used to compile a \CFA program and is based on the \Index{GNU} \Indexc{gcc} command, \eg:
     345\begin{cfa}
     346cfa§\indexc{cfa}\index{compilation!cfa@©cfa©}§ [ gcc-options ] C/§\CFA{}§-files [ assembler/loader-files ]
    339347\end{cfa}
    340348\CFA programs having the following ©gcc© flags turned on:
     
    344352The 1999 C standard plus GNU extensions.
    345353\item
    346 {\lstset{deletekeywords={inline}}
    347 \Indexc{-fgnu89-inline}\index{compilation option!-fgnu89-inline@{©-fgnu89-inline©}}
     354\Indexc[deletekeywords=inline]{-fgnu89-inline}\index{compilation option!-fgnu89-inline@{\lstinline[deletekeywords=inline]$-fgnu89-inline$}}
    348355Use the traditional GNU semantics for inline routines in C99 mode, which allows inline routines in header files.
    349 }%
    350356\end{description}
    351357The following new \CFA options are available:
     
    354360\Indexc{-CFA}\index{compilation option!-CFA@©-CFA©}
    355361Only the C preprocessor and the \CFA translator steps are performed and the transformed program is written to standard output, which makes it possible to examine the code generated by the \CFA translator.
    356 The generated code started with the standard \CFA prelude.
     362The generated code starts with the standard \CFA \Index{prelude}.
    357363
    358364\item
    359365\Indexc{-debug}\index{compilation option!-debug@©-debug©}
    360366The program is linked with the debugging version of the runtime system.
    361 The debug version performs runtime checks to help during the debugging phase of a \CFA program, but substantially slows the execution of the program.
     367The debug version performs runtime checks to help during the debugging phase of a \CFA program, but can substantially slow program execution.
    362368The runtime checks should only be removed after the program is completely debugged.
    363369\textbf{This option is the default.}
     
    366372\Indexc{-nodebug}\index{compilation option!-nodebug@©-nodebug©}
    367373The program is linked with the non-debugging version of the runtime system, so the execution of the program is faster.
    368 \Emph{However, no runtime checks or ©assert©s are performed so errors usually result in abnormal program termination.}
     374\Emph{However, no runtime checks or ©assert©s are performed so errors usually result in abnormal program behaviour or termination.}
    369375
    370376\item
     
    386392\textbf{This option is the default.}
    387393
     394\begin{comment}
    388395\item
    389396\Indexc{-no-include-stdhdr}\index{compilation option!-no-include-stdhdr@©-no-include-stdhdr©}
    390397Do not supply ©extern "C"© wrappers for \Celeven standard include files (see~\VRef{s:StandardHeaders}).
    391398\textbf{This option is \emph{not} the default.}
     399\end{comment}
    392400\end{description}
    393401
     
    410418\item
    411419\Indexc{__CFA__}\index{preprocessor variables!__CFA__@©__CFA__©},
    412 \Indexc{__CFORALL__}\index{preprocessor variables!__CFORALL__@©__CFORALL__©} and
     420\Indexc{__CFORALL__}\index{preprocessor variables!__CFORALL__@©__CFORALL__©}, and
    413421\Indexc{__cforall}\index{preprocessor variables!__cforall@©__cforall©}
    414422are always available during preprocessing and have no value.
    415423\end{description}
    416424These preprocessor variables allow conditional compilation of programs that must work differently in these situations.
    417 For example, to toggle between C and \CFA extensions, using the following:
     425For example, to toggle between C and \CFA extensions, use the following:
    418426\begin{cfa}
    419427#ifndef __CFORALL__
     
    426434
    427435
    428 \section{Constants Underscores}
    429 
    430 Numeric constants are extended to allow \Index{underscore}s within constants\index{constant!underscore}, \eg:
     436\section{Constant Underscores}
     437
     438Numeric constants are extended to allow \Index{underscore}s\index{constant!underscore}, \eg:
    431439\begin{cfa}
    4324402®_®147®_®483®_®648;                                    §\C{// decimal constant}§
     
    441449L®_®§"\texttt{\textbackslash{x}}§®_®§\texttt{ff}§®_®§\texttt{ee}"§;     §\C{// wide character constant}§
    442450\end{cfa}
    443 The rules for placement of underscores is as follows:
    444 \begin{enumerate}
     451The rules for placement of underscores are:
     452\begin{enumerate}[topsep=5pt,itemsep=5pt,parsep=0pt]
    445453\item
    446454A sequence of underscores is disallowed, \eg ©12__34© is invalid.
     
    463471\label{s:BackquoteIdentifiers}
    464472
    465 \CFA accommodates keyword clashes with existing C variable-names by syntactic transformations using the \CFA backquote escape-mechanism:
     473\CFA introduces several new keywords (see \VRef{s:CFAKeywords}) that can clash with existing C variable-names in legacy code.
     474Keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism:
    466475\begin{cfa}
    467476int ®`®otype®`® = 3;                    §\C{// make keyword an identifier}§
    468477double ®`®forall®`® = 3.5;
    469478\end{cfa}
     479
    470480Existing C programs with keyword clashes can be converted by enclosing keyword identifiers in backquotes, and eventually the identifier name can be changed to a non-keyword name.
    471 \VRef[Figure]{f:InterpositionHeaderFile} shows how clashes in C header files (see~\VRef{s:StandardHeaders}) can be handled using preprocessor \newterm{interposition}: ©#include_next© and ©-I filename©:
     481\VRef[Figure]{f:HeaderFileInterposition} shows how clashes in existing C header-files (see~\VRef{s:StandardHeaders}) can be handled using preprocessor \newterm{interposition}: ©#include_next© and ©-I filename©.
     482Several common C header-files with keyword clashes are fixed in the standard \CFA header-library, so there is a seamless programming-experience.
    472483
    473484\begin{figure}
    474485\begin{cfa}
    475 // include file uses the CFA keyword "otype".
    476 #if ! defined( otype )                  §\C{// nesting ?}§
    477 #define otype ®`®otype®`®               §\C{// make keyword an identifier}§
     486// include file uses the CFA keyword "with".
     487#if ! defined( with )                   §\C{// nesting ?}§
     488#define with ®`®with®`®                 §\C{// make keyword an identifier}§
    478489#define __CFA_BFD_H__
    479 #endif // ! otype
    480 
    481 #®include_next® <bfd.h>                 §\C{// must have internal check for multiple expansion}§
    482 
    483 #if defined( otype ) && defined( __CFA_BFD_H__ )        §\C{// reset only if set}§
    484 #undef otype
     490#endif
     491
     492®#include_next <bfdlink.h>              §\C{// must have internal check for multiple expansion}§
     493®
     494#if defined( with ) && defined( __CFA_BFD_H__ ) §\C{// reset only if set}§
     495#undef with
    485496#undef __CFA_BFD_H__
    486 #endif // otype && __CFA_BFD_H__
    487 \end{cfa}
    488 \caption{Interposition of Header File}
    489 \label{f:InterpositionHeaderFile}
     497#endif
     498\end{cfa}
     499\caption{Header-File Interposition}
     500\label{f:HeaderFileInterposition}
    490501\end{figure}
    491502
    492503
    493 \section{Labelled Continue/Break}
     504\section{\texorpdfstring{Labelled \LstKeywordStyle{continue} / \LstKeywordStyle{break}}{Labelled continue / break}}
    494505
    495506While C provides ©continue© and ©break© statements for altering control flow, both are restricted to one level of nesting for a particular control structure.
    496507Unfortunately, this restriction forces programmers to use \Indexc{goto} to achieve the equivalent control-flow for more than one level of nesting.
    497 To prevent having to switch to the ©goto©, \CFA extends the \Indexc{continue}\index{continue@\lstinline $continue$!labelled}\index{labelled!continue@©continue©} and \Indexc{break}\index{break@\lstinline $break$!labelled}\index{labelled!break@©break©} with a target label to support static multi-level exit\index{multi-level exit}\index{static multi-level exit}~\cite{Buhr85,Java}.
     508To prevent having to switch to the ©goto©, \CFA extends the \Indexc{continue}\index{continue@\lstinline $continue$!labelled}\index{labelled!continue@©continue©} and \Indexc{break}\index{break@\lstinline $break$!labelled}\index{labelled!break@©break©} with a target label to support static multi-level exit\index{multi-level exit}\index{static multi-level exit}~\cite{Buhr85}, as in Java.
    498509For both ©continue© and ©break©, the target label must be directly associated with a ©for©, ©while© or ©do© statement;
    499510for ©break©, the target label can also be associated with a ©switch©, ©if© or compound (©{}©) statement.
     
    512523                        ®LF:® for ( ... ) {
    513524                                ®LW:® while ( ... ) {
    514                                         ... break ®LC®; ...                     // terminate compound
    515                                         ... break ®LS®; ...                     // terminate switch
    516                                         ... break ®LIF®; ...                    // terminate if
    517                                         ... continue ®LF;® ...   // resume loop
    518                                         ... break ®LF®; ...                     // terminate loop
    519                                         ... continue ®LW®; ...   // resume loop
    520                                         ... break ®LW®; ...               // terminate loop
     525                                        ... break ®LC®; ...             // terminate compound
     526                                        ... break ®LS®; ...             // terminate switch
     527                                        ... break ®LIF®; ...    // terminate if
     528                                        ... continue ®LF;® ...  // resume loop
     529                                        ... break ®LF®; ...             // terminate loop
     530                                        ... continue ®LW®; ...  // resume loop
     531                                        ... break ®LW®; ...             // terminate loop
    521532                                } // while
    522533                        } // for
    523534                } else {
    524                         ... break ®LIF®; ...                                     // terminate if
     535                        ... break ®LIF®; ...                    // terminate if
    525536                } // if
    526537        } // switch
     
    564575                          LF: for ( ;; ) {
    565576                                  LW: while ( 1 ) {
    566                                                 break LC;                       // terminate compound
    567                                                 break LS;                       // terminate switch
    568                                                 break LIF;                      // terminate if
    569                                                 continue LF;     // resume loop
    570                                                 break LF;                       // terminate loop
    571                                                 continue LW;     // resume loop
    572                                                 break LW;                 // terminate loop
     577                                                break LC;               // terminate compound
     578                                                break LS;               // terminate switch
     579                                                break LIF;              // terminate if
     580                                                continue LF;    // resume loop
     581                                                break LF;               // terminate loop
     582                                                continue LW;    // resume loop
     583                                                break LW;               // terminate loop
    573584                                        } // while
    574585                                } // for
    575586                        } else {
    576                                 break LIF;                                      // terminate if
     587                                break LIF;                              // terminate if
    577588                        } // if
    578589                } // switch
     
    613624\item
    614625They cannot branch into a control structure.
    615 This restriction prevents missing initialization at the start of a control structure resulting in undefined behaviour.
     626This restriction prevents missing declarations and/or initializations at the start of a control structure resulting in undefined behaviour.
    616627\end{itemize}
    617628The advantage of the labelled ©continue©/©break© is allowing static multi-level exits without having to use the ©goto© statement, and tying control flow to the target control structure rather than an arbitrary point in a program.
    618 Furthermore, the location of the label at the \emph{beginning} of the target control structure informs the reader that complex control-flow is occurring in the body of the control structure.
     629Furthermore, the location of the label at the \emph{beginning} of the target control structure informs the reader (\Index{eye candy}) that complex control-flow is occurring in the body of the control structure.
    619630With ©goto©, the label is at the end of the control structure, which fails to convey this important clue early enough to the reader.
    620631Finally, using an explicit target for the transfer instead of an implicit target allows new constructs to be added or removed without affecting existing constructs.
     
    622633
    623634
    624 \section{Switch Statement}
     635\section{\texorpdfstring{\LstKeywordStyle{switch} Statement}{switch Statement}}
    625636
    626637C allows a number of questionable forms for the ©switch© statement:
     
    663674        ®// open input file
    664675®} else if ( argc == 2 ) {
    665         ®// open input file
     676        ®// open input file (duplicate)
    666677
    667678®} else {
     
    676687\begin{cfa}
    677688switch ( i ) {
    678   case 1: case 3: case 5:       // odd values
    679         // same action
     689  ®case 1: case 3: case 5:®     // odd values
     690        // odd action
    680691        break;
    681   case 2: case 4: case 6:       // even values
    682         // same action
     692  ®case 2: case 4: case 6:®     // even values
     693        // even action
    683694        break;
    684695}
     
    686697However, this situation is handled in other languages without fall-through by allowing a list of case values.
    687698While fall-through itself is not a problem, the problem occurs when fall-through is the default, as this semantics is unintuitive to many programmers and is different from virtually all other programming languages with a ©switch© statement.
    688 Hence, default fall-through semantics results in a large number of programming errors as programmers often forget the ©break© statement at the end of a ©case© clause, resulting in inadvertent fall-through.
     699Hence, default fall-through semantics results in a large number of programming errors as programmers often \emph{forget} the ©break© statement at the end of a ©case© clause, resulting in inadvertent fall-through.
    689700
    690701\item
     
    708719The problem with this usage is branching into control structures, which is known to cause both comprehension and technical difficulties.
    709720The comprehension problem occurs from the inability to determine how control reaches a particular point due to the number of branches leading to it.
    710 The technical problem results from the inability to ensure allocation and initialization of variables when blocks are not entered at the beginning.
    711 Often transferring into a block can bypass variable declaration and/or its initialization, which results in subsequent errors.
    712 There are virtually no positive arguments for this kind of control flow, and therefore, there is a strong impetus to eliminate it.
     721The technical problem results from the inability to ensure declaration and initialization of variables when blocks are not entered at the beginning.
     722There are no positive arguments for this kind of control flow, and therefore, there is a strong impetus to eliminate it.
    713723Nevertheless, C does have an idiom where this capability is used, known as ``\Index*{Duff's device}''~\cite{Duff83}:
    714724\begin{cfa}
     
    770780and there is only a medium amount of fall-through from one ©case© clause to the next, and most of these result from a list of case values executing common code, rather than a sequence of case actions that compound.
    771781\end{itemize}
    772 These observations help to put the \CFA changes to the ©switch© into perspective.
     782These observations put into perspective the \CFA changes to the ©switch©.
    773783\begin{enumerate}
    774784\item
     
    791801  case 7:
    792802        ...
    793         ®break®                                         §\C{// explicit end of switch}§
     803        ®break®                                         §\C{// redundant explicit end of switch}§
    794804  default:
    795805        j = 3;
     
    797807\end{cfa}
    798808Like the ©switch© statement, the ©choose© statement retains the fall-through semantics for a list of ©case© clauses;
    799 the implicit ©break© is applied only at the end of the \emph{statements} following a ©case© clause.
    800 The explicit ©fallthru© is retained because it is a C-idiom most C programmers expect, and its absence might discourage programmers from using the ©choose© statement.
     809An implicit ©break© is applied only at the end of the \emph{statements} following a ©case© clause.
     810An explicit ©fallthru© is retained because it is a C-idiom most C programmers expect, and its absence might discourage programmers from using the ©choose© statement.
    801811As well, allowing an explicit ©break© from the ©choose© is a carry over from the ©switch© statement, and expected by C programmers.
    802812\item
     
    827837
    828838
    829 \section{Case Clause}
     839\section{\texorpdfstring{\LstKeywordStyle{case} Clause}{case Clause}}
    830840
    831841C restricts the ©case© clause of a ©switch© statement to a single value.
     
    903913
    904914
     915\section{\texorpdfstring{\LstKeywordStyle{with} Clause / Statement}{with Clause / Statement}}
     916\label{s:WithClauseStatement}
     917
     918In \Index{object-oriented} programming, there is an implicit first parameter, often names \textbf{©self©} or \textbf{©this©}, which is elided.
     919\begin{C++}
     920class C {
     921        int i, j;
     922        int mem() {              ®// implicit "this" parameter
     923®               i = 1;          ®// this->i
     924®               j = 3;          ®// this->j
     925®       }
     926}
     927\end{C++}
     928Since CFA is non-object-oriented, the equivalent object-oriented program looks like:
     929\begin{cfa}
     930struct S { int i, j; };
     931int mem( S &this ) {    // explicit "this" parameter
     932        ®this.®i = 1;                     // "this" is not elided
     933        ®this.®j = 2;
     934}
     935\end{cfa}
     936but it is cumbersome having to write "©this.©" many times in a member.
     937
     938\CFA provides a ©with© clause/statement (see Pascal~\cite[\S~4.F]{Pascal}) to elided the "©this.©" by opening a scope containing field identifiers, changing the qualified fields into variables and giving an opportunity for optimizing qualified references.
     939\begin{cfa}
     940int mem( S &this ) ®with this® {        // with clause
     941        i = 1;                  ®// this.i
     942®       j = 2;                  ®// this.j
     943®}
     944\end{cfa}
     945which extends to multiple routine parameters:
     946\begin{cfa}
     947struct T { double m, n; };
     948int mem2( S &this1, T &this2 ) ®with this1, this2® {
     949        i = 1; j = 2;
     950        m = 1.0; n = 2.0;
     951}
     952\end{cfa}
     953
     954The statement form is used within a block:
     955\begin{cfa}
     956int foo() {
     957        struct S1 { ... } s1;
     958        struct S2 { ... } s2;
     959        ®with s1® {                     // with statement
     960                // access fields of s1 without qualification
     961                ®with s2® {  // nesting
     962                        // access fields of s1 and s2 without qualification
     963                }
     964        }
     965        ®with s1, s2® {
     966                // access unambiguous fields of s1 and s2 without qualification
     967        }
     968}
     969\end{cfa}
     970
     971When opening multiple structures, fields with the same name and type are ambiguous and must be fully qualified.
     972For fields with the same name but different type, context/cast can be used to disambiguate.
     973\begin{cfa}
     974struct S { int i; int j; double m; } a, c;
     975struct T { int i; int k; int m } b, c;
     976®with a, b® {
     977        j + k;                                          §\C{// unambiguous, unique names define unique types}§
     978        i;                                                      §\C{// ambiguous, same name and type}§
     979        a.i + b.i;                                      §\C{// unambiguous, qualification defines unique names}§
     980        m;                                                      §\C{// ambiguous, same name and no context to define unique type}§
     981        m = 5.0;                                        §\C{// unambiguous, same name and context defines unique type}§
     982        m = 1;                                          §\C{// unambiguous, same name and context defines unique type}§
     983}
     984®with c® { ... }                                §\C{// ambiguous, same name and no context}§
     985®with (S)c® { ... }                             §\C{// unambiguous, same name and cast defines unique type}§
     986\end{cfa}
     987
     988
    905989\section{Exception Handling}
     990\label{s:ExceptionHandling}
    906991
    907992Exception handling provides two mechanism: change of control flow from a raise to a handler, and communication from the raise to the handler.
    908 \begin{cfa}
    909 exception void h( int i );
    910 exception int h( int i, double d );
    911 
     993Transfer of control can be local, within a routine, or non-local, among routines.
     994Non-local transfer can cause stack unwinding, i.e., non-local routine termination, depending on the kind of raise.
     995\begin{cfa}
     996exception_t E {};                               §\C{// exception type}§
    912997void f(...) {
    913         ... throw h( 3 );
    914         ... i = resume h( 3, 5.1 );
    915 }
    916 
     998        ... throw E{}; ...                      §\C{// termination}§
     999        ... throwResume E{}; ...        §\C{// resumption}§
     1000}
    9171001try {
    9181002        f(...);
    919 } catch h( int w ) {
    920         // reset
    921 } resume h( int p, double x ) {
    922         return 17;  // recover
     1003} catch( E e : §boolean-predicate§ ) {                  §\C{// termination handler}§
     1004        // recover and continue
     1005} catchResume( E e : §boolean-predicate§ ) {    §\C{// resumption handler}§
     1006        // repair and return
    9231007} finally {
    924 }
    925 \end{cfa}
    926 So the type raised would be the mangled name of the exception prototype and that name would be matched at the handler clauses by comparing the strings.
    927 The arguments for the call would have to be packed in a message and unpacked at handler clause and then a call made to the handler.
     1008        // always executed
     1009}
     1010\end{cfa}
     1011The kind of raise and handler match: ©throw© with ©catch© and ©throwResume© with ©catchResume©.
     1012Then the exception type must match along with any additonal predicate must be true.
     1013The ©catch© and ©catchResume© handlers may appear in any oder.
     1014However, the ©finally© clause must appear at the end of the ©try© statement.
    9281015
    9291016
     
    11361223
    11371224
    1138 \section{Pointer/Reference}
     1225\section{Exponentiation Operator}
     1226
     1227C, \CC, and Java (and many other programming languages) have no exponentiation operator\index{exponentiation!operator}\index{operator!exponentiation}, \ie $x^y$, and instead use a routine, like \Indexc{pow}, to perform the exponentiation operation.
     1228\CFA extends the basic operators with the exponentiation operator ©?\?©\index{?\\?@\lstinline$?\?$} and ©?\=?©\index{?\\=?@\lstinline$?\=?$}, as in, ©x \ y© and ©x \= y©, which means $x^y$ and $x \leftarrow x^y$.
     1229The priority of the exponentiation operator is between the cast and multiplicative operators, so that ©w * (int)x \ (int)y * z© is parenthesized as ©((w * (((int)x) \ ((int)y))) * z)©.
     1230
     1231As for \Index{division}, there are exponentiation operators for integral and floating-point types, including the builtin \Index{complex} types.
     1232Unsigned integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication (or shifting if the base is 2).
     1233Signed integral exponentiation\index{exponentiation!signed integral} is performed with repeated multiplication (or shifting if the base is 2), but yields a floating-point result because $b^{-e}=1/b^e$.
     1234Hence, it is important to designate exponent integral-constants as unsigned or signed: ©3 \ 3u© return an integral result, while ©3 \ 3© returns a floating-point result.
     1235Floating-point exponentiation\index{exponentiation!floating point} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the base cannot be negative.
     1236\begin{cfa}
     1237sout | 2 ®\® 8u | 4 ®\® 3u | -4 ®\® 3u | 4 ®\® -3 | -4 ®\® -3 | 4.0 ®\® 2.1 | (1.0f+2.0fi) ®\® (3.0f+2.0fi) | endl;
     1238256 64 -64 0.015625 -0.015625 18.3791736799526 0.264715-1.1922i
     1239\end{cfa}
     1240Parenthesis are necessary for the complex constants or the expresion is parsed as ©1.0f+(2.0fi \ 3.0f)+2.0fi©.
     1241The exponentiation operator is available for all the basic types, but for user-defined types, only the integral-computation versions are available.
     1242For returning an integral value, the user type ©T© must define multiplication, ©*©, and one, ©1©;
     1243for returning a floating-point value, an additional divide of type ©T© into a ©double© returning a ©double© (©double ?/?( double, T )©) is necessary for negative exponents.
     1244
     1245
     1246\section{Pointer / Reference}
    11391247
    11401248C provides a \newterm{pointer type};
     
    11441252An integer constant expression with the value 0, or such an expression cast to type ©void *©, is called a \newterm{null-pointer constant}.\footnote{
    11451253One way to conceptualize the null pointer is that no variable is placed at this address, so the null-pointer address can be used to denote an uninitialized pointer/reference object;
    1146 \ie the null pointer is guaranteed to compare unequal to a pointer to any object or routine.}
     1254\ie the null pointer is guaranteed to compare unequal to a pointer to any object or routine.
     1255In general, a value with special meaning among a set of values is called a \emph{\Index{sentinel value}}, \eg ©-1© as a return code value.}
    11471256An address is \newterm{sound}, if it points to a valid memory location in scope, \ie within the program's execution-environment and has not been freed.
    11481257Dereferencing an \newterm{unsound} address, including the null pointer, is \Index{undefined}, often resulting in a \Index{memory fault}.
     
    11791288\hline
    11801289\begin{cfa}
    1181 lda             r1,100                  // load address of x
    1182 ld               r2,(r1)                  // load value of x
    1183 lda             r3,104                  // load address of y
    1184 st               r2,(r3)                  // store x into y
     1290lda             r1,100  // load address of x
     1291ld               r2,(r1)          // load value of x
     1292lda             r3,104  // load address of y
     1293st               r2,(r3)          // store x into y
    11851294\end{cfa}
    11861295&
    11871296\begin{cfa}
    11881297
    1189 ld              r2,(100)                // load value of x
    1190 
    1191 st              r2,(104)                // store x into y
     1298ld              r2,(100)        // load value of x
     1299
     1300st              r2,(104)        // store x into y
    11921301\end{cfa}
    11931302\end{tabular}
     
    14851594
    14861595\item
    1487 lvalue to reference conversion: \lstinline[deletekeywords={lvalue}]@lvalue-type cv1 T@ converts to ©cv2 T &©, which allows implicitly converting variables to references.
     1596lvalue to reference conversion: \lstinline[deletekeywords=lvalue]$lvalue-type cv1 T$ converts to ©cv2 T &©, which allows implicitly converting variables to references.
    14881597\begin{cfa}
    14891598int x, &r = ®x®, f( int & p ); // lvalue variable (int) convert to reference (int &)
     
    25942703\begin{cfa}[belowskip=0pt]
    25952704char store[®sepSize®];                                          §\C{// sepSize is the maximum separator size}§
    2596 strcpy( store, sepGet( sout ) );
    2597 sepSet( sout, "_" );
     2705strcpy( store, sepGet( sout ) );                          §\C{// copy current separator}§
     2706sepSet( sout, "_" );                                            §\C{// change separator to underscore}§
    25982707sout | 1 | 2 | 3 | endl;
    25992708\end{cfa}
     
    26022711\end{cfa}
    26032712\begin{cfa}[belowskip=0pt]
    2604 sepSet( sout, store );
     2713sepSet( sout, store );                                          §\C{// change separator back to original}§
    26052714sout | 1 | 2 | 3 | endl;
    26062715\end{cfa}
     
    31593268\Indexc{gcc} provides ©typeof© to declare a secondary variable from a primary variable.
    31603269\CFA also relies heavily on the specification of the left-hand side of assignment for type inferencing, so in many cases it is crucial to specify the type of the left-hand side to select the correct type of the right-hand expression.
    3161 Only for overloaded routines with the same return type is variable type-inferencing possible.
     3270Only for overloaded routines \emph{with the same return type} is variable type-inferencing possible.
    31623271Finally, ©auto© presents the programming problem of tracking down a type when the type is actually needed.
    31633272For example, given
     
    52585367
    52595368
    5260 \section{\CFA Keywords}
     5369\section{\texorpdfstring{\CFA Keywords}{Cforall Keywords}}
    52615370\label{s:CFAKeywords}
    52625371
     5372\CFA introduces the following new keywords.
     5373
    52635374\begin{quote2}
    5264 \begin{tabular}{llll}
     5375\begin{tabular}{lllll}
    52655376\begin{tabular}{@{}l@{}}
    5266 ©_AT©                   \\
     5377©_At©                   \\
    52675378©catch©                 \\
    52685379©catchResume©   \\
    52695380©choose©                \\
    52705381©coroutine©             \\
    5271 ©disable©               \\
    52725382\end{tabular}
    52735383&
    52745384\begin{tabular}{@{}l@{}}
     5385©disable©               \\
    52755386©dtype©                 \\
    52765387©enable©                \\
    52775388©fallthrough©   \\
    52785389©fallthru©              \\
    5279 ©finally©               \\
    5280 ©forall©                \\
    52815390\end{tabular}
    52825391&
    52835392\begin{tabular}{@{}l@{}}
     5393©finally©               \\
     5394©forall©                \\
    52845395©ftype©                 \\
    52855396©lvalue©                \\
    52865397©monitor©               \\
     5398\end{tabular}
     5399&
     5400\begin{tabular}{@{}l@{}}
    52875401©mutex©                 \\
    52885402©one_t©                 \\
    52895403©otype©                 \\
     5404©throw©                 \\
     5405©throwResume©   \\
    52905406\end{tabular}
    52915407&
    52925408\begin{tabular}{@{}l@{}}
    5293 ©throw©                 \\
    5294 ©throwResume©   \\
    52955409©trait©                 \\
    52965410©try©                   \\
    52975411©ttype©                 \\
     5412©with©                  \\
    52985413©zero_t©                \\
    52995414\end{tabular}
     
    53305445g( p1, p2 ) int p1, p2;                 §\C{// int g( int p1, int p2 );}§
    53315446\end{cfa}
    5332 \CFA supports K\&R routine definitions:
     5447\CFA continues to support K\&R routine definitions:
    53335448\begin{cfa}
    53345449f( a, b, c )                                    §\C{// default int return}§
     
    54715586\Celeven prescribes the following standard header-files~\cite[\S~7.1.2]{C11} and \CFA adds to this list:
    54725587\begin{quote2}
    5473 \lstset{deletekeywords={float}}
    5474 \begin{tabular}{@{}llll|l@{}}
    5475 \multicolumn{4}{c|}{C11} & \multicolumn{1}{c}{\CFA}             \\
     5588\begin{tabular}{@{}lllll|l@{}}
     5589\multicolumn{5}{c|}{C11} & \multicolumn{1}{c}{\CFA}             \\
    54765590\hline
    54775591\begin{tabular}{@{}l@{}}
     
    54815595\Indexc{errno.h}                \\
    54825596\Indexc{fenv.h}                 \\
    5483 \Indexc{float.h}                \\
    5484 \Indexc{inttypes.h}             \\
    5485 \Indexc{iso646.h}               \\
     5597\Indexc[deletekeywords=float]{float.h} \\
    54865598\end{tabular}
    54875599&
    54885600\begin{tabular}{@{}l@{}}
     5601\Indexc{inttypes.h}             \\
     5602\Indexc{iso646.h}               \\
    54895603\Indexc{limits.h}               \\
    54905604\Indexc{locale.h}               \\
    54915605\Indexc{math.h}                 \\
    54925606\Indexc{setjmp.h}               \\
     5607\end{tabular}
     5608&
     5609\begin{tabular}{@{}l@{}}
    54935610\Indexc{signal.h}               \\
    54945611\Indexc{stdalign.h}             \\
    54955612\Indexc{stdarg.h}               \\
    54965613\Indexc{stdatomic.h}    \\
     5614\Indexc{stdbool.h}              \\
     5615\Indexc{stddef.h}               \\
    54975616\end{tabular}
    54985617&
    54995618\begin{tabular}{@{}l@{}}
    5500 \Indexc{stdbool.h}              \\
    5501 \Indexc{stddef.h}               \\
    55025619\Indexc{stdint.h}               \\
    55035620\Indexc{stdio.h}                \\
     
    55155632\Indexc{wctype.h}               \\
    55165633                                                \\
    5517                                                 \\
    5518                                                 \\
    55195634\end{tabular}
    55205635&
     
    55225637\Indexc{unistd.h}               \\
    55235638\Indexc{gmp.h}                  \\
    5524                                                 \\
    5525                                                 \\
    55265639                                                \\
    55275640                                                \\
     
    55635676The table shows allocation routines supporting different combinations of storage-management capabilities:
    55645677\begin{center}
    5565 \begin{tabular}{@{}lr|l|l|l|l@{}}
    5566                 &                                       & \multicolumn{1}{c|}{fill}     & resize        & alignment     & array \\
     5678\begin{tabular}{@{}r|r|l|l|l|l@{}}
     5679\multicolumn{1}{c}{}&           & \multicolumn{1}{c|}{fill}     & resize        & alignment     & array \\
    55675680\hline
    55685681C               & ©malloc©                      & no                    & no            & no            & no    \\
     
    55715684                & ©memalign©            & no                    & no            & yes           & no    \\
    55725685                & ©posix_memalign©      & no                    & no            & yes           & no    \\
     5686\hline
    55735687C11             & ©aligned_alloc©       & no                    & no            & yes           & no    \\
     5688\hline
    55745689\CFA    & ©alloc©                       & no/copy/yes   & no/yes        & no            & yes   \\
    55755690                & ©align_alloc©         & no/yes                & no            & yes           & yes   \\
  • src/CodeGen/CodeGenerator.h

    re0a653d r33218c6  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Thu Jun  8 15:48:00 2017
    13 // Update Count     : 52
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Fri Jul 21 22:16:21 2017
     13// Update Count     : 53
    1414//
    1515
    16 #ifndef CODEGENV_H
    17 #define CODEGENV_H
     16#pragma once
    1817
    1918#include <list>                   // for list
     
    166165} // namespace CodeGen
    167166
    168 #endif // CODEGENV_H
    169 
    170167// Local Variables: //
    171168// tab-width: 4 //
  • src/CodeGen/FixMain.h

    re0a653d r33218c6  
    99// Author           : Thierry Delisle
    1010// Created On       : Thr Jan 12 14:11:09 2017
    11 // Last Modified By :
    12 // Last Modified On :
    13 // Update Count     : 0
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Fri Jul 21 22:16:59 2017
     13// Update Count     : 1
    1414//
    1515
    16 #ifndef FIXMAIN_H
    17 #define FIXMAIN_H
     16#pragma once
    1817
    1918#include <iosfwd>
     
    4443        };
    4544};
    46 
    47 #endif //FIXMAIN_H
  • src/CodeGen/FixNames.h

    re0a653d r33218c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon May 18 23:37:32 2015
    13 // Update Count     : 2
     12// Last Modified On : Fri Jul 21 22:17:33 2017
     13// Update Count     : 3
    1414//
    1515
    16 #ifndef FIXNAMES_H
    17 #define FIXNAMES_H
     16#pragma once
    1817
    1918#include <list>  // for list
     
    2625} // namespace CodeGen
    2726
    28 #endif // FIXNAMES_H
    29 
    3027// Local Variables: //
    3128// tab-width: 4 //
  • src/CodeGen/GenType.h

    re0a653d r33218c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon May 18 23:38:53 2015
    13 // Update Count     : 1
     12// Last Modified On : Fri Jul 21 22:17:23 2017
     13// Update Count     : 2
    1414//
    1515
    16 #ifndef _GENTYPE_H
    17 #define _GENTYPE_H
     16#pragma once
    1817
    1918#include <string>  // for string
     
    2625} // namespace CodeGen
    2726
    28 #endif // _GENTYPE_H
    29 
    3027// Local Variables: //
    3128// tab-width: 4 //
  • src/CodeGen/Generate.h

    re0a653d r33218c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon May 18 23:39:51 2015
    13 // Update Count     : 1
     12// Last Modified On : Fri Jul 21 22:16:35 2017
     13// Update Count     : 2
    1414//
    1515
    16 #ifndef GENERATE_H
    17 #define GENERATE_H
     16#pragma once
    1817
    1918#include <iostream>  // for ostream
     
    3130} // namespace CodeGen
    3231
    33 #endif // GENERATE_H
    34 
    3532// Local Variables: //
    3633// tab-width: 4 //
  • src/CodeGen/OperatorTable.cc

    re0a653d r33218c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Dec 13 14:33:05 2016
    13 // Update Count     : 10
     12// Last Modified On : Sat Jul 15 17:12:22 2017
     13// Update Count     : 15
    1414//
    1515
     
    3535                        {       "++?",          "++",   "_operator_preincr",                    OT_PREFIXASSIGN         },
    3636                        {       "--?",          "--",   "_operator_predecr",                    OT_PREFIXASSIGN         },
     37                        {       "?\\?",         "\\",   "_operator_exponential",                OT_INFIX                        },
    3738                        {       "?*?",          "*",    "_operator_multiply",                   OT_INFIX                        },
    3839                        {       "?/?",          "/",    "_operator_divide",                             OT_INFIX                        },
     
    5253                        {       "?|?",          "|",    "_operator_bitor",                              OT_INFIX                        },
    5354                        {       "?=?",          "=",    "_operator_assign",                             OT_INFIXASSIGN          },
     55                        {       "?\\=?",        "\\=",  "_operator_expassign",                  OT_INFIXASSIGN          },
    5456                        {       "?*=?",         "*=",   "_operator_multassign",                 OT_INFIXASSIGN          },
    5557                        {       "?/=?",         "/=",   "_operator_divassign",                  OT_INFIXASSIGN          },
  • src/CodeGen/OperatorTable.h

    re0a653d r33218c6  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Wed Jun 24 16:17:57 2015
    13 // Update Count     : 5
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Fri Jul 21 22:17:11 2017
     13// Update Count     : 6
    1414//
    1515
    16 #ifndef _OPERATORTABLE_H
    17 #define _OPERATORTABLE_H
     16#pragma once
    1817
    1918#include <string>
     
    4544} // namespace CodeGen
    4645
    47 #endif // _OPERATORTABLE_H
    48 
    4946// Local Variables: //
    5047// tab-width: 4 //
  • src/CodeTools/DeclStats.h

    re0a653d r33218c6  
    99// Author           : Aaron Moss
    1010// Created On       : Wed Jan 31 16:40:00 2016
    11 // Last Modified By : Aaron Moss
    12 // Last Modified On : Wed Jan 31 16:40:00 2016
    13 // Update Count     : 1
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Fri Jul 21 22:17:56 2017
     13// Update Count     : 2
    1414//
    1515
    16 #ifndef DECLSTATS_H
    17 #define DECLSTATS_H
     16#pragma once
    1817
    1918#include <list>  // for list
     
    2827}  // namespace CodeTools
    2928
    30 #endif // DECLSTATS_H
    31 
    3229// Local Variables: //
    3330// tab-width: 4 //
  • src/CodeTools/TrackLoc.h

    re0a653d r33218c6  
    99// Author           : Andrew Beach
    1010// Created On       : Tues May 2 15:40:00 2017
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Wed May 3 14:42:00 2017
    13 // Update Count     : 0
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Fri Jul 21 22:17:44 2017
     13// Update Count     : 1
    1414//
    1515
    16 #ifndef TRACKLOC_H
    17 #define TRACKLOC_H
     16#pragma once
    1817
    1918#include <cstddef>   // for size_t
     
    3130}  // namespace CodeTools
    3231
    33 #endif // TRACKLOC_H
    34 
    3532// Local Variables: //
    3633// tab-width: 4 //
  • src/Common/CompilerError.h

    re0a653d r33218c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 18 23:41:30 2016
    13 // Update Count     : 3
     12// Last Modified On : Fri Jul 21 22:18:07 2017
     13// Update Count     : 4
    1414//
    1515
    16 #ifndef COMPILER_ERROR_H
    17 #define COMPILER_ERROR_H
     16#pragma once
    1817
    1918#include <string>
     
    3130};
    3231
    33 #endif // COMPILER_ERROR_H
    34 
    3532// Local Variables: //
    3633// tab-width: 4 //
  • src/Common/ScopedMap.h

    re0a653d r33218c6  
    99// Author           : Aaron B. Moss
    1010// Created On       : Wed Dec 2 11:37:00 2015
    11 // Last Modified By : Aaron B. Moss
    12 // Last Modified On : Wed Dec 2 11:37:00 2015
    13 // Update Count     : 1
    14 //
    15 
    16 #ifndef _SCOPEDMAP_H
    17 #define _SCOPEDMAP_H
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Fri Jul 21 22:18:24 2017
     13// Update Count     : 2
     14//
     15
     16#pragma once
    1817
    1918#include <cassert>
     
    305304};
    306305
    307 #endif // _SCOPEDMAP_H
    308 
    309306// Local Variables: //
    310307// tab-width: 4 //
  • src/Common/SemanticError.h

    re0a653d r33218c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Sep 24 15:13:42 2016
    13 // Update Count     : 5
     12// Last Modified On : Fri Jul 21 22:18:59 2017
     13// Update Count     : 6
    1414//
    1515
    16 #ifndef SEMANTICERROR_H
    17 #define SEMANTICERROR_H
     16#pragma once
    1817
    1918#include <exception>  // for exception
     
    6261}
    6362
    64 #endif // SEMANTICERROR_H
    65 
    6663// Local Variables: //
    6764// tab-width: 4 //
  • src/Common/UnimplementedError.h

    re0a653d r33218c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue May 19 07:23:08 2015
    13 // Update Count     : 1
     12// Last Modified On : Fri Jul 21 22:18:35 2017
     13// Update Count     : 2
    1414//
    1515
    16 #ifndef _UNIMPLEMENTEDERROR_H
    17 #define _UNIMPLEMENTEDERROR_H
     16#pragma once
    1817
    1918#include <string>
     
    3130};
    3231
    33 #endif // _UNIMPLEMENTEDERROR_H
    34 
    3532// Local Variables: //
    3633// tab-width: 4 //
  • src/Common/UniqueName.h

    re0a653d r33218c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue May 19 07:24:20 2015
    13 // Update Count     : 1
     12// Last Modified On : Fri Jul 21 22:18:45 2017
     13// Update Count     : 2
    1414//
    1515
    16 #ifndef UNIQUENAME_H
    17 #define UNIQUENAME_H
     16#pragma once
    1817
    1918#include <string>
     
    2827};
    2928
    30 #endif // UNIQUENAME_H
    31 
    3229// Local Variables: //
    3330// tab-width: 4 //
  • src/Common/VectorMap.h

    re0a653d r33218c6  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // ScopedMap.h --
     7// VectorMap.h --
    88//
    99// Author           : Aaron B. Moss
    1010// Created On       : Wed Feb  1 16:55:00 2017
    11 // Last Modified By : Aaron B. Moss
    12 // Last Modified On : Wed Feb  1 16:55:00 2017
    13 // Update Count     : 1
    14 //
    15 
    16 #ifndef _VECTORMAP_H
    17 #define _VECTORMAP_H
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Fri Jul 21 22:19:29 2017
     13// Update Count     : 2
     14//
     15
     16#pragma once
    1817
    1918#include <iterator>
     
    245244}
    246245
    247 #endif // _VECTORMAP_H
    248 
    249246// Local Variables: //
    250247// tab-width: 4 //
  • src/Common/utility.h

    re0a653d r33218c6  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Fri May 5 11:03:00 2017
    13 // Update Count     : 32
    14 //
    15 
    16 #ifndef _UTILITY_H
    17 #define _UTILITY_H
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Fri Jul 21 22:19:13 2017
     13// Update Count     : 33
     14//
     15
     16#pragma once
    1817
    1918#include <cctype>
     
    376375}
    377376
    378 #endif // _UTILITY_H
    379 
    380377// Local Variables: //
    381378// tab-width: 4 //
  • src/Concurrency/Keywords.cc

    re0a653d r33218c6  
    1 //                              -*- Mode: CPP -*-
    21//
    32// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
     
    1211// Last Modified By :
    1312// Last Modified On :
    14 // Update Count     : 3
     13// Update Count     : 5
    1514//
    1615
     
    549548        }
    550549};
     550
     551// Local Variables: //
     552// mode: c //
     553// tab-width: 4 //
     554// End: //
  • src/Concurrency/Keywords.h

    re0a653d r33218c6  
    1 //                              -*- Mode: CPP -*-
    21//
    32// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
     
    1211// Last Modified By :
    1312// Last Modified On :
    14 // Update Count     : 0
     13// Update Count     : 1
    1514//
    1615
    17 #ifndef KEYWORDS_H
    18 #define KEYWORDS_H
     16#pragma once
    1917
    2018#include <list>  // for list
     
    2826};
    2927
    30 #endif //KEYWORDS_H
     28// Local Variables: //
     29// tab-width: 4 //
     30// mode: c++ //
     31// compile-command: "make install" //
     32// End: //
  • src/ControlStruct/ExceptTranslate.cc

    re0a653d r33218c6  
    1010// Created On       : Wed Jun 14 16:49:00 2017
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Wed Jul 12 15:07:00 2017
    13 // Update Count     : 3
     12// Last Modified On : Tus Jul 18 10:09:00 2017
     13// Update Count     : 4
    1414//
    1515
     
    5050                        LinkageSpec::Cforall,
    5151                        /*bitfieldWidth*/ NULL,
    52                         new BasicType( emptyQualifiers, BasicType::SignedInt ),
     52                        new BasicType( noQualifiers, BasicType::SignedInt ),
    5353                        /*init*/ NULL
    5454                        );
     
    5959                        /*bitfieldWidth*/ NULL,
    6060                        new PointerType(
    61                                 emptyQualifiers,
    62                                 new BasicType( emptyQualifiers, BasicType::SignedInt )
     61                                noQualifiers,
     62                                new BasicType( noQualifiers, BasicType::SignedInt )
    6363                                ),
    6464                        /*init*/ NULL
     
    6969                        LinkageSpec::Cforall,
    7070                        /*bitfieldWidth*/ NULL,
    71                         new BasicType(emptyQualifiers, BasicType::Bool),
     71                        new BasicType(noQualifiers, BasicType::Bool),
    7272                        /*init*/ NULL
    7373                        );
     
    7878                        NULL,
    7979                        new PointerType(
    80                                 emptyQualifiers,
     80                                noQualifiers,
    8181                                new VoidType(
    82                                         emptyQualifiers
     82                                        noQualifiers
    8383                                        ),
    8484                                std::list<Attribute *>{new Attribute("unused")}
     
    143143                        LinkageSpec::Cforall,
    144144                        NULL,
    145                         new BasicType( emptyQualifiers, BasicType::SignedInt ),
     145                        new BasicType( noQualifiers, BasicType::SignedInt ),
    146146                        new SingleInit( throwStmt->get_expr() )
    147147                        );
     
    444444                        nullptr,
    445445                        new StructInstType(
    446                                 emptyQualifiers,
     446                                noQualifiers,
    447447                                hook_decl
    448448                                ),
  • src/ControlStruct/ExceptTranslate.h

    re0a653d r33218c6  
    99// Author           : Andrew Beach
    1010// Created On       : Tus Jun 06 10:13:00 2017
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Fri Jun 30 10:20:00 2017
    13 // Update Count     : 2
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:19:23 2017
     13// Update Count     : 4
    1414//
    1515
    16 #ifndef EXCEPT_TRANSLATE_H
    17 #define EXCEPT_TRANSLATE_H
     16#pragma once
    1817
    1918#include <list>
     
    2221namespace ControlStruct {
    2322        void translateEHM( std::list< Declaration *> & translationUnit );
    24         /* Converts exception handling structures into their underlying C code.
    25          * Translation does use the exception handling header, make sure it is
    26          * visible wherever translation occurs.
    27          */
     23        // Converts exception handling structures into their underlying C code.  Translation does use the exception
     24        // handling header, make sure it is visible wherever translation occurs.
    2825}
    2926
    30 #endif // EXCEPT_TRANSLATE_H
     27// Local Variables: //
     28// tab-width: 4 //
     29// mode: c++ //
     30// compile-command: "make install" //
     31// End: //
  • src/ControlStruct/ForExprMutator.h

    re0a653d r33218c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jan 25 21:22:13 2016
    13 // Update Count     : 3
     12// Last Modified On : Sat Jul 22 09:17:08 2017
     13// Update Count     : 4
    1414//
    1515
    16 #ifndef FOR_MUTATOR_H
    17 #define FOR_MUTATOR_H
     16#pragma once
    1817
    1918#include "SynTree/Mutator.h"
     
    2726} // namespace ControlStruct
    2827
    29 #endif // CHOOSE_MUTATOR_H
    30 
    3128// Local Variables: //
    3229// tab-width: 4 //
  • src/ControlStruct/LabelFixer.h

    re0a653d r33218c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul 12 17:36:16 2016
    13 // Update Count     : 33
     12// Last Modified On : Sat Jul 22 09:17:24 2017
     13// Update Count     : 34
    1414//
    1515
    16 #ifndef LABEL_FIXER_H
    17 #define LABEL_FIXER_H
     16#pragma once
    1817
    1918#include "Common/utility.h"
     
    8382} // namespace ControlStruct
    8483
    85 #endif // LABEL_FIXER_H
    86 
    8784// Local Variables: //
    8885// tab-width: 4 //
  • src/ControlStruct/LabelGenerator.h

    re0a653d r33218c6  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Wed Jun 03 14:16:26 2015
    13 // Update Count     : 5
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:20:14 2017
     13// Update Count     : 6
    1414//
    1515
    16 #ifndef LABEL_GENERATOR_H
    17 #define LABEL_GENERATOR_H
     16#pragma once
    1817
    1918#include "SynTree/SynTree.h"
     
    3534} // namespace ControlStruct
    3635
    37 #endif // LABEL_GENERATOR_H
    38 
    3936// Local Variables: //
    4037// tab-width: 4 //
  • src/ControlStruct/MLEMutator.h

    re0a653d r33218c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul 12 17:37:01 2016
    13 // Update Count     : 34
     12// Last Modified On : Sat Jul 22 09:19:59 2017
     13// Update Count     : 35
    1414//
    1515
    16 #ifndef MLE_MUTATOR_H
    17 #define MLE_MUTATOR_H
     16#pragma once
    1817
    1918#include <map>
     
    8988} // namespace ControlStruct
    9089
    91 #endif // MLE_MUTATOR_H
    92 
    9390// Local Variables: //
    9491// tab-width: 4 //
  • src/ControlStruct/Mutate.h

    re0a653d r33218c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue May 19 15:31:20 2015
    13 // Update Count     : 2
     12// Last Modified On : Sat Jul 22 09:17:59 2017
     13// Update Count     : 3
    1414//
    1515
    16 #ifndef CTRLS_MUTATE_H
    17 #define CTRLS_MUTATE_H
     16#pragma once
    1817
    1918#include <list>
     
    2726} // namespace ControlStruct
    2827
    29 #endif // CTRLS_MUTATE_H
    30 
    3128// Local Variables: //
    3229// tab-width: 4 //
  • src/GenPoly/Box.cc

    re0a653d r33218c6  
    202202                };
    203203
    204                 /// Replaces initialization of polymorphic values with alloca, declaration of dtype/ftype with appropriate void expression, and sizeof expressions of polymorphic types with the proper variable
     204                /// Replaces initialization of polymorphic values with alloca, declaration of dtype/ftype with appropriate void expression, sizeof expressions of polymorphic types with the proper variable, and strips fields from generic struct declarations.
    205205                class Pass3 final : public PolyMutator {
    206206                  public:
     
    210210                        using PolyMutator::mutate;
    211211                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
     212                        virtual Declaration *mutate( StructDecl *structDecl ) override;
     213                        virtual Declaration *mutate( UnionDecl *unionDecl ) override;
    212214                        virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
    213215                        virtual TypedefDecl *mutate( TypedefDecl *objectDecl ) override;
     
    18681870                }
    18691871
     1872                /// Strips the members from a generic aggregate
     1873                void stripGenericMembers(AggregateDecl* decl) {
     1874                        if ( ! decl->get_parameters().empty() ) decl->get_members().clear();
     1875                }
     1876
     1877                Declaration *Pass3::mutate( StructDecl *structDecl ) {
     1878                        stripGenericMembers( structDecl );
     1879                        return structDecl;
     1880                }
     1881               
     1882                Declaration *Pass3::mutate( UnionDecl *unionDecl ) {
     1883                        stripGenericMembers( unionDecl );
     1884                        return unionDecl;
     1885                }
     1886
    18701887                TypeDecl * Pass3::mutate( TypeDecl *typeDecl ) {
    18711888//   Initializer *init = 0;
  • src/GenPoly/Box.h

    re0a653d r33218c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Nov 19 17:24:01 2015
    13 // Update Count     : 5
     12// Last Modified On : Sat Jul 22 09:23:52 2017
     13// Update Count     : 6
    1414//
    1515
    16 #ifndef _BOX_H
    17 #define _BOX_H
     16#pragma once
    1817
    1918#include <list>
     
    2524} // namespace GenPoly
    2625
    27 #endif // _BOX_H
    28 
    2926// Local Variables: //
    3027// tab-width: 4 //
  • src/GenPoly/CopyParams.h

    re0a653d r33218c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue May 19 07:34:25 2015
    13 // Update Count     : 1
     12// Last Modified On : Sat Jul 22 09:23:09 2017
     13// Update Count     : 2
    1414//
    1515
    16 #ifndef _COPYPARAMS_H
    17 #define _COPYPARAMS_H
     16#pragma once
    1817
    1918#include "SynTree/SynTree.h"
     
    2423} // namespace GenPoly
    2524
    26 #endif // _COPYPARAMS_H
    27 
    2825// Local Variables: //
    2926// tab-width: 4 //
  • src/GenPoly/DeclMutator.h

    re0a653d r33218c6  
    1010// Created On       : Fri Nov 27 14:44:00 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul 12 17:39:01 2016
    13 // Update Count     : 2
     12// Last Modified On : Sat Jul 22 09:21:12 2017
     13// Update Count     : 4
    1414//
    1515
    16 #ifndef _DECLMUTATOR_H
    17 #define _DECLMUTATOR_H
     16#pragma once
    1817
    1918#include <list>
     
    2726        /// Mutates a list of declarations, providing a means of adding new declarations into the list
    2827        class DeclMutator : public Mutator {
    29         public:
     28          public:
    3029                typedef Mutator Parent;
    3130
     
    5049                /// Called on exit from a scope; overriders should call this as a super-class call
    5150                virtual void doEndScope();
    52         protected:
     51          protected:
    5352                /// Mutate a statement that forms its own scope
    5453                Statement* mutateStatement( Statement *stmt );
     
    5958                /// Add a declaration to the list to be added after the current position
    6059                void addDeclarationAfter( Declaration* decl );
    61         private:
     60          private:
    6261                /// A stack of declarations to add before the current declaration or statement
    6362                std::vector< std::list< Declaration* > > declsToAdd;
     
    6766} // namespace
    6867
    69 #endif // _DECLMUTATOR_H
    70 
    7168// Local Variables: //
    7269// tab-width: 4 //
  • src/GenPoly/ErasableScopedMap.h

    re0a653d r33218c6  
    99// Author           : Aaron B. Moss
    1010// Created On       : Wed Dec 2 11:37:00 2015
    11 // Last Modified By : Aaron B. Moss
    12 // Last Modified On : Wed Dec 2 11:37:00 2015
    13 // Update Count     : 1
    14 //
    15 
    16 #ifndef _ERASABLESCOPEDMAP_H
    17 #define _ERASABLESCOPEDMAP_H
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:23:24 2017
     13// Update Count     : 2
     14//
     15
     16#pragma once
    1817
    1918#include <cassert>
     
    278277} // namespace GenPoly
    279278
    280 #endif // _ERASABLESCOPEDMAP_H
    281 
    282279// Local Variables: //
    283280// tab-width: 4 //
  • src/GenPoly/FindFunction.h

    re0a653d r33218c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue May 19 07:36:35 2015
    13 // Update Count     : 1
     12// Last Modified On : Sat Jul 22 09:23:36 2017
     13// Update Count     : 2
    1414//
    1515
    16 #ifndef FINDFUNCTION_H
    17 #define FINDFUNCTION_H
     16#pragma once
    1817
    1918#include "SynTree/SynTree.h"
     
    2928} // namespace GenPoly
    3029
    31 #endif // FINDFUNCTION_H
    32 
    3330// Local Variables: //
    3431// tab-width: 4 //
  • src/GenPoly/GenPoly.h

    re0a653d r33218c6  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Tue Nov 24 15:24:38 2015
    13 // Update Count     : 6
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:22:57 2017
     13// Update Count     : 7
    1414//
    1515
    16 #ifndef GENPOLY_H
    17 #define GENPOLY_H
     16#pragma once
    1817
    1918#include <string>
     
    111110} // namespace GenPoly
    112111
    113 #endif // GENPOLY_H
    114 
    115112// Local Variables: //
    116113// tab-width: 4 //
  • src/GenPoly/InstantiateGeneric.h

    re0a653d r33218c6  
    99// Author           : Aaron B. Moss
    1010// Created On       : Thu Aug 04 18:33:00 2016
    11 // Last Modified By : Aaron B. Moss
    12 // Last Modified On : Thu Aug 04 18:33:00 2016
    13 // Update Count     : 1
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:22:42 2017
     13// Update Count     : 2
    1414//
    1515
    16 #ifndef _INSTANTIATEGENERIC_H
    17 #define _INSTANTIATEGENERIC_H
     16#pragma once
    1817
    1918#include "SynTree/SynTree.h"
     
    2625} // namespace GenPoly
    2726
    28 #endif // _INSTANTIATEGENERIC_H
    29 
    3027// Local Variables: //
    3128// tab-width: 4 //
  • src/GenPoly/Lvalue.h

    re0a653d r33218c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue May 19 07:42:09 2015
    13 // Update Count     : 1
     12// Last Modified On : Sat Jul 22 09:21:59 2017
     13// Update Count     : 2
    1414//
    1515
    16 #ifndef _LVALUE_H
    17 #define _LVALUE_H
     16#pragma once
    1817
    1918#include <list>
     
    2625} // namespace GenPoly
    2726
    28 #endif // _LVALUE_H
    29 
    3027// Local Variables: //
    3128// tab-width: 4 //
  • src/GenPoly/PolyMutator.h

    re0a653d r33218c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul 12 17:39:41 2016
    13 // Update Count     : 6
     12// Last Modified On : Sat Jul 22 09:20:31 2017
     13// Update Count     : 7
    1414//
    1515
    16 #ifndef _POLYMUTATOR_H
    17 #define _POLYMUTATOR_H
     16#pragma once
    1817
    1918#include <map>
     
    6665} // namespace
    6766
    68 #endif // _POLYMUTATOR_H
    69 
    7067// Local Variables: //
    7168// tab-width: 4 //
  • src/GenPoly/ScopedSet.h

    re0a653d r33218c6  
    99// Author           : Aaron B. Moss
    1010// Created On       : Thu Dec 3 11:51:00 2015
    11 // Last Modified By : Aaron B. Moss
    12 // Last Modified On : Thu Dec 3 11:51:00 2015
    13 // Update Count     : 1
    14 //
    15 
    16 #ifndef _SCOPEDSET_H
    17 #define _SCOPEDSET_H
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:22:17 2017
     13// Update Count     : 2
     14//
     15
     16#pragma once
    1817
    1918#include <iterator>
     
    247246} // namespace GenPoly
    248247
    249 #endif // _SCOPEDSET_H
    250 
    251248// Local Variables: //
    252249// tab-width: 4 //
  • src/GenPoly/ScrubTyVars.h

    re0a653d r33218c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue May 19 07:48:14 2015
    13 // Update Count     : 1
     12// Last Modified On : Sat Jul 22 09:21:47 2017
     13// Update Count     : 2
    1414//
    1515
    16 #ifndef _SCRUBTYVARS_H
    17 #define _SCRUBTYVARS_H
     16#pragma once
    1817
    1918#include <string>
     
    9594} // namespace GenPoly
    9695
    97 #endif // _SCRUBTYVARS_H
    98 
    9996// Local Variables: //
    10097// tab-width: 4 //
  • src/GenPoly/Specialize.h

    re0a653d r33218c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue May 19 07:53:58 2015
    13 // Update Count     : 1
     12// Last Modified On : Sat Jul 22 09:22:31 2017
     13// Update Count     : 2
    1414//
    1515
    16 #ifndef _SPECIALIZE_H
    17 #define _SPECIALIZE_H
     16#pragma once
    1817
    1918#include <list>
     
    2625} // namespace GenPoly
    2726
    28 #endif // _SPECIALIZE_H
    29 
    3027// Local Variables: //
    3128// tab-width: 4 //
  • src/InitTweak/FixGlobalInit.h

    re0a653d r33218c6  
    99// Author           : Rob Schluntz
    1010// Created On       : Mon May 04 15:14:56 2016
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Fri May 06 16:07:47 2016
    13 // Update Count     : 2
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:30:54 2017
     13// Update Count     : 3
    1414//
    1515
    16 #ifndef FIX_GLOBAL_INIT_H
    17 #define FIX_GLOBAL_INIT_H
     16#pragma once
    1817
    1918#include <string>
     
    3433} // namespace
    3534
    36 #endif // GENPOLY_POLYMUTATOR_H
    37 
    3835// Local Variables: //
    3936// tab-width: 4 //
  • src/InitTweak/FixInit.h

    re0a653d r33218c6  
    99// Author           : Rob Schluntz
    1010// Created On       : Wed Jan 13 16:29:30 2016
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Fri May 13 11:27:52 2016
    13 // Update Count     : 5
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:31:06 2017
     13// Update Count     : 6
    1414//
    1515
    16 #ifndef FIX_INIT_H
    17 #define FIX_INIT_H
     16#pragma once
    1817
    1918#include <string>
     
    3029} // namespace
    3130
    32 #endif // GENPOLY_POLYMUTATOR_H
    33 
    3431// Local Variables: //
    3532// tab-width: 4 //
  • src/InitTweak/GenInit.h

    re0a653d r33218c6  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Fri May 13 11:27:19 2016
    13 // Update Count     : 3
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:31:19 2017
     13// Update Count     : 4
    1414//
    1515
    16 #ifndef GEN_INIT_H
    17 #define GEN_INIT_H
     16#pragma once
    1817
    1918#include <string>
     
    3534} // namespace
    3635
    37 #endif // INITTWEAK_GENINIT_H
    38 
    3936// Local Variables: //
    4037// tab-width: 4 //
  • src/InitTweak/InitTweak.h

    re0a653d r33218c6  
    99// Author           : Rob Schluntz
    1010// Created On       : Fri May 13 11:26:36 2016
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Fri May 13 11:35:36 2016
    13 // Update Count     : 3
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:30:33 2017
     13// Update Count     : 4
    1414//
    1515
    16 #ifndef INIT_TWEAK_H
    17 #define INIT_TWEAK_H
     16#pragma once
    1817
    1918#include <string>
     
    116115} // namespace
    117116
    118 #endif // INITTWEAK_GENINIT_H
    119 
    120117// Local Variables: //
    121118// tab-width: 4 //
  • src/MakeLibCfa.h

    re0a653d r33218c6  
    1010// Created On       : Sat May 16 10:42:14 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat May 16 10:43:29 2015
    13 // Update Count     : 1
     12// Last Modified On : Sat Jul 22 09:31:35 2017
     13// Update Count     : 2
    1414//
    1515
    16 #ifndef LIBCFA_MAKELIBCFA_H
    17 #define LIBCFA_MAKELIBCFA_H
     16#pragma once
    1817
    1918#include <list>  // for list
     
    2524} // namespace LibCfa
    2625
    27 #endif // LIBCFA_MAKELIBCFA_H
    28 
    2926// Local Variables: //
    3027// tab-width: 4 //
  • src/Makefile.in

    re0a653d r33218c6  
    216216        SymTab/driver_cfa_cpp-TypeEquality.$(OBJEXT) \
    217217        SymTab/driver_cfa_cpp-Autogen.$(OBJEXT) \
     218        SymTab/driver_cfa_cpp-TreeStruct.$(OBJEXT) \
    218219        SynTree/driver_cfa_cpp-Type.$(OBJEXT) \
    219220        SynTree/driver_cfa_cpp-VoidType.$(OBJEXT) \
     
    514515        SymTab/Indexer.cc SymTab/Mangler.cc SymTab/Validate.cc \
    515516        SymTab/FixFunction.cc SymTab/ImplementationType.cc \
    516         SymTab/TypeEquality.cc SymTab/Autogen.cc SynTree/Type.cc \
    517         SynTree/VoidType.cc SynTree/BasicType.cc \
     517        SymTab/TypeEquality.cc SymTab/Autogen.cc SymTab/TreeStruct.cc \
     518        SynTree/Type.cc SynTree/VoidType.cc SynTree/BasicType.cc \
    518519        SynTree/PointerType.cc SynTree/ArrayType.cc \
    519520        SynTree/FunctionType.cc SynTree/ReferenceToType.cc \
     
    848849SymTab/driver_cfa_cpp-Autogen.$(OBJEXT): SymTab/$(am__dirstamp) \
    849850        SymTab/$(DEPDIR)/$(am__dirstamp)
     851SymTab/driver_cfa_cpp-TreeStruct.$(OBJEXT): SymTab/$(am__dirstamp) \
     852        SymTab/$(DEPDIR)/$(am__dirstamp)
    850853SynTree/$(am__dirstamp):
    851854        @$(MKDIR_P) SynTree
     
    10331036@AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-Indexer.Po@am__quote@
    10341037@AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-Mangler.Po@am__quote@
     1038@AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-TreeStruct.Po@am__quote@
    10351039@AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-TypeEquality.Po@am__quote@
    10361040@AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-Validate.Po@am__quote@
     
    20842088@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    20852089@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SymTab/driver_cfa_cpp-Autogen.obj `if test -f 'SymTab/Autogen.cc'; then $(CYGPATH_W) 'SymTab/Autogen.cc'; else $(CYGPATH_W) '$(srcdir)/SymTab/Autogen.cc'; fi`
     2090
     2091SymTab/driver_cfa_cpp-TreeStruct.o: SymTab/TreeStruct.cc
     2092@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SymTab/driver_cfa_cpp-TreeStruct.o -MD -MP -MF SymTab/$(DEPDIR)/driver_cfa_cpp-TreeStruct.Tpo -c -o SymTab/driver_cfa_cpp-TreeStruct.o `test -f 'SymTab/TreeStruct.cc' || echo '$(srcdir)/'`SymTab/TreeStruct.cc
     2093@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SymTab/$(DEPDIR)/driver_cfa_cpp-TreeStruct.Tpo SymTab/$(DEPDIR)/driver_cfa_cpp-TreeStruct.Po
     2094@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SymTab/TreeStruct.cc' object='SymTab/driver_cfa_cpp-TreeStruct.o' libtool=no @AMDEPBACKSLASH@
     2095@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     2096@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SymTab/driver_cfa_cpp-TreeStruct.o `test -f 'SymTab/TreeStruct.cc' || echo '$(srcdir)/'`SymTab/TreeStruct.cc
     2097
     2098SymTab/driver_cfa_cpp-TreeStruct.obj: SymTab/TreeStruct.cc
     2099@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SymTab/driver_cfa_cpp-TreeStruct.obj -MD -MP -MF SymTab/$(DEPDIR)/driver_cfa_cpp-TreeStruct.Tpo -c -o SymTab/driver_cfa_cpp-TreeStruct.obj `if test -f 'SymTab/TreeStruct.cc'; then $(CYGPATH_W) 'SymTab/TreeStruct.cc'; else $(CYGPATH_W) '$(srcdir)/SymTab/TreeStruct.cc'; fi`
     2100@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SymTab/$(DEPDIR)/driver_cfa_cpp-TreeStruct.Tpo SymTab/$(DEPDIR)/driver_cfa_cpp-TreeStruct.Po
     2101@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SymTab/TreeStruct.cc' object='SymTab/driver_cfa_cpp-TreeStruct.obj' libtool=no @AMDEPBACKSLASH@
     2102@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     2103@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SymTab/driver_cfa_cpp-TreeStruct.obj `if test -f 'SymTab/TreeStruct.cc'; then $(CYGPATH_W) 'SymTab/TreeStruct.cc'; else $(CYGPATH_W) '$(srcdir)/SymTab/TreeStruct.cc'; fi`
    20862104
    20872105SynTree/driver_cfa_cpp-Type.o: SynTree/Type.cc
  • src/Parser/DeclarationNode.cc

    re0a653d r33218c6  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Wed Jun 28 15:27:00 2017
    13 // Update Count     : 1019
     12// Last Modified On : Fri Jul 14 16:55:00 2017
     13// Update Count     : 1020
    1414//
    1515
     
    253253        newnode->type->aggregate.fields = fields;
    254254        newnode->type->aggregate.body = body;
     255        newnode->type->aggregate.tagged = false;
     256        newnode->type->aggregate.parent = nullptr;
    255257        return newnode;
    256258} // DeclarationNode::newAggregate
     
    273275        return newnode;
    274276} // DeclarationNode::newEnumConstant
     277
     278DeclarationNode * DeclarationNode::newTreeStruct( Aggregate kind, const string * name, const string * parent, ExpressionNode * actuals, DeclarationNode * fields, bool body ) {
     279        assert( name );
     280        DeclarationNode * newnode = new DeclarationNode;
     281        newnode->type = new TypeData( TypeData::Aggregate );
     282        newnode->type->aggregate.kind = kind;
     283        newnode->type->aggregate.name = name;
     284        newnode->type->aggregate.actuals = actuals;
     285        newnode->type->aggregate.fields = fields;
     286        newnode->type->aggregate.body = body;
     287        newnode->type->aggregate.tagged = true;
     288        newnode->type->aggregate.parent = parent;
     289        return newnode;
     290} // DeclarationNode::newTreeStruct
    275291
    276292DeclarationNode * DeclarationNode::newName( string * name ) {
  • src/Parser/ExpressionNode.cc

    re0a653d r33218c6  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Sat May 16 13:17:07 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jun 28 21:08:15 2017
    13 // Update Count     : 542
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Tus Jul 18 10:08:00 2017
     13// Update Count     : 550
    1414//
    1515
     
    4646// type.
    4747
    48 Type::Qualifiers emptyQualifiers;                               // no qualifiers on constants
     48Type::Qualifiers noQualifiers;                          // no qualifiers on constants
    4949
    5050static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
     
    118118        } // if
    119119
    120         Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[Unsigned][size] ), str, v ) );
     120        Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][size] ), str, v ) );
    121121        delete &str;                                                                            // created by lex
    122122        return ret;
     
    153153        } // if
    154154
    155         Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[complx][size] ), str, v ) );
     155        Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[complx][size] ), str, v ) );
    156156        delete &str;                                                                            // created by lex
    157157        return ret;
     
    159159
    160160Expression *build_constantChar( const std::string & str ) {
    161         Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::Char ), str, (unsigned long long int)(unsigned char)str[1] ) );
     161        Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, BasicType::Char ), str, (unsigned long long int)(unsigned char)str[1] ) );
    162162        delete &str;                                                                            // created by lex
    163163        return ret;
     
    166166ConstantExpr *build_constantStr( const std::string & str ) {
    167167        // string should probably be a primitive type
    168         ArrayType *at = new ArrayType( emptyQualifiers, new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ),
     168        ArrayType *at = new ArrayType( noQualifiers, new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ),
    169169                                                                   new ConstantExpr( Constant::from_ulong( str.size() + 1 - 2 ) ),  // +1 for '\0' and -2 for '"'
    170170                                                                   false, false );
     
    176176
    177177Expression *build_constantZeroOne( const std::string & str ) {
    178         Expression * ret = new ConstantExpr( Constant( str == "0" ? (Type *)new ZeroType( emptyQualifiers ) : (Type*)new OneType( emptyQualifiers ), str,
     178        Expression * ret = new ConstantExpr( Constant( str == "0" ? (Type *)new ZeroType( noQualifiers ) : (Type*)new OneType( noQualifiers ), str,
    179179                                                                                                   str == "0" ? (unsigned long long int)0 : (unsigned long long int)1 ) );
    180180        delete &str;                                                                            // created by lex
     
    231231}
    232232
     233// Must harmonize with OperKinds.
    233234static const char *OperName[] = {
    234235        // diadic
    235         "SizeOf", "AlignOf", "OffsetOf", "?+?", "?-?", "?*?", "?/?", "?%?", "||", "&&",
     236        "SizeOf", "AlignOf", "OffsetOf", "?+?", "?-?", "?\\?", "?*?", "?/?", "?%?", "||", "&&",
    236237        "?|?", "?&?", "?^?", "Cast", "?<<?", "?>>?", "?<?", "?>?", "?<=?", "?>=?", "?==?", "?!=?",
    237         "?=?", "?@=?", "?*=?", "?/=?", "?%=?", "?+=?", "?-=?", "?<<=?", "?>>=?", "?&=?", "?^=?", "?|=?",
     238        "?=?", "?@=?", "?\\=?", "?*=?", "?/=?", "?%=?", "?+=?", "?-=?", "?<<=?", "?>>=?", "?&=?", "?^=?", "?|=?",
    238239        "?[?]", "...",
    239240        // monadic
  • src/Parser/LinkageSpec.h

    re0a653d r33218c6  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Sat May 16 13:24:28 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Fri Jul  7 11:03:00 2017
    13 // Update Count     : 13
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:32:16 2017
     13// Update Count     : 14
    1414//
    1515
    16 #ifndef LINKAGESPEC_H
    17 #define LINKAGESPEC_H
     16#pragma once
    1817
    1918#include <string>
     
    7877};
    7978
    80 #endif // LINKAGESPEC_H
    81 
    8279// Local Variables: //
    8380// tab-width: 4 //
  • src/Parser/ParseNode.h

    re0a653d r33218c6  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Sat May 16 13:28:16 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Jun 12 13:00:00 2017
    13 // Update Count     : 779
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:32:30 2017
     13// Update Count     : 786
    1414//
    1515
    16 #ifndef PARSENODE_H
    17 #define PARSENODE_H
     16#pragma once
    1817
    1918#include <string>
     
    141140};
    142141
     142// Must harmonize with OperName.
    143143enum class OperKinds {
    144144        // diadic
    145         SizeOf, AlignOf, OffsetOf, Plus, Minus, Mul, Div, Mod, Or, And,
     145        SizeOf, AlignOf, OffsetOf, Plus, Minus, Exp, Mul, Div, Mod, Or, And,
    146146        BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
    147         Assign, AtAssn, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
     147        Assign, AtAssn, ExpAssn, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
    148148        Index, Range,
    149149        // monadic
     
    248248        static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
    249249
     250        // Perhaps this would best fold into newAggragate.
     251        static DeclarationNode * newTreeStruct( Aggregate kind, const std::string * name, const std::string * parent, ExpressionNode * actuals, DeclarationNode * fields, bool body );
     252
    250253        DeclarationNode();
    251254        ~DeclarationNode();
     
    332335
    333336        static UniqueName anonymous;
     337
     338        // Temp to test TreeStruct
     339        const std::string * parent_name;
    334340}; // DeclarationNode
    335341
     
    443449std::ostream & operator<<( std::ostream & out, const ParseNode * node );
    444450
    445 #endif // PARSENODE_H
    446 
    447451// Local Variables: //
    448452// tab-width: 4 //
  • src/Parser/ParserTypes.h

    re0a653d r33218c6  
    1010// Created On       : Sat Sep 22 08:58:10 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jun 28 22:10:17 2017
    13 // Update Count     : 349
     12// Last Modified On : Sat Jul 22 09:33:28 2017
     13// Update Count     : 350
    1414//
    1515
    16 #ifndef PARSER_HH
    17 #define PARSER_HH
     16#pragma once
    1817
    1918int yylex();
     
    4241}; // Token
    4342
    44 #endif // PARSER_HH
    45 
    4643// Local Variables: //
    4744// tab-width: 4 //
  • src/Parser/TypeData.cc

    re0a653d r33218c6  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Wed Jun 28 15:28:00 2017
    13 // Update Count     : 564
     12// Last Modified On : Tus Jul 18 10:10:00 2017
     13// Update Count     : 566
    1414//
    1515
     
    6363                aggregate.fields = nullptr;
    6464                aggregate.body = false;
     65                aggregate.tagged = false;
     66                aggregate.parent = nullptr;
    6567                break;
    6668          case AggregateInst:
     
    121123                delete aggregate.actuals;
    122124                delete aggregate.fields;
     125                delete aggregate.parent;
    123126                // delete aggregate;
    124127                break;
     
    192195                newtype->aggregate.kind = aggregate.kind;
    193196                newtype->aggregate.body = aggregate.body;
     197                newtype->aggregate.tagged = aggregate.tagged;
     198                newtype->aggregate.parent = aggregate.parent ? new string( *aggregate.parent ) : nullptr;
    194199                break;
    195200          case AggregateInst:
     
    449454          case TypeData::Builtin:
    450455                if(td->builtintype == DeclarationNode::Zero) {
    451                         return new ZeroType( emptyQualifiers );
     456                        return new ZeroType( noQualifiers );
    452457                }
    453458                else if(td->builtintype == DeclarationNode::One) {
    454                         return new OneType( emptyQualifiers );
     459                        return new OneType( noQualifiers );
    455460                }
    456461                else {
     
    619624        switch ( td->aggregate.kind ) {
    620625          case DeclarationNode::Struct:
     626                if ( td->aggregate.tagged ) {
     627                        at = new StructDecl( *td->aggregate.name, td->aggregate.parent, attributes, linkage );
     628                        buildForall( td->aggregate.params, at->get_parameters() );
     629                        break;
     630                }
    621631          case DeclarationNode::Coroutine:
    622632          case DeclarationNode::Monitor:
  • src/Parser/TypeData.h

    re0a653d r33218c6  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Sat May 16 15:18:36 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Wed Jun 28 15:29:00 2017
    13 // Update Count     : 186
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:32:47 2017
     13// Update Count     : 188
    1414//
    1515
    16 #ifndef TYPEDATA_H
    17 #define TYPEDATA_H
     16#pragma once
    1817
    1918#include "ParseNode.h"
     
    3130                DeclarationNode * fields;
    3231                bool body;
     32
     33                bool tagged;
     34                const std::string * parent;
    3335        };
    3436
     
    113115void buildKRFunction( const TypeData::Function_t & function );
    114116
    115 #endif // TYPEDATA_H
    116 
    117117// Local Variables: //
    118118// tab-width: 4 //
  • src/Parser/TypedefTable.h

    re0a653d r33218c6  
    1010// Created On       : Sat May 16 15:24:36 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jun 28 21:56:34 2017
    13 // Update Count     : 33
     12// Last Modified On : Sat Jul 22 09:33:14 2017
     13// Update Count     : 34
    1414//
    1515
    16 #ifndef TYPEDEFTABLE_H
    17 #define TYPEDEFTABLE_H
     16#pragma once
    1817
    1918#include <map>
     
    9190};
    9291
    93 #endif // TYPEDEFTABLE_H
    94 
    9592// Local Variables: //
    9693// tab-width: 4 //
  • src/Parser/lex.ll

    re0a653d r33218c6  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Tue Jul 11 21:30:51 2017
    13  * Update Count     : 534
     12 * Last Modified On : Mon Jul 24 08:27:23 2017
     13 * Update Count     : 545
    1414 */
    1515
     
    125125op_unary {op_unary_only}|{op_unary_binary}|{op_unary_pre_post}
    126126
    127 op_binary_only "/"|"%"|"^"|"&"|"|"|"<"|">"|"="|"=="|"!="|"<<"|">>"|"<="|">="|"+="|"-="|"*="|"/="|"%="|"&="|"|="|"^="|"<<="|">>="
     127op_binary_only "/"|"%"|"\\"|"^"|"&"|"|"|"<"|">"|"="|"=="|"!="|"<<"|">>"|"<="|">="|"+="|"-="|"*="|"/="|"%="|"\\="|"&="|"|="|"^="|"<<="|">>="
    128128op_binary_over {op_unary_binary}|{op_binary_only}
    129129                                // op_binary_not_over "?"|"->"|"."|"&&"|"||"|"@="
     
    136136
    137137%%
    138                                    /* line directives */
     138                                /* line directives */
    139139^{h_white}*"#"{h_white}*[0-9]+{h_white}*["][^"\n]+["].*"\n" {
    140140        /* " stop highlighting */
     
    232232int                             { KEYWORD_RETURN(INT); }
    233233__int128                { KEYWORD_RETURN(INT); }                                // GCC
     234__int128_t              { KEYWORD_RETURN(INT); }                                // GCC
    234235__label__               { KEYWORD_RETURN(LABEL); }                              // GCC
    235236long                    { KEYWORD_RETURN(LONG); }
     
    266267__typeof                { KEYWORD_RETURN(TYPEOF); }                             // GCC
    267268__typeof__              { KEYWORD_RETURN(TYPEOF); }                             // GCC
     269__uint128_t             { KEYWORD_RETURN(INT); }                                // GCC
    268270union                   { KEYWORD_RETURN(UNION); }
    269271unsigned                { KEYWORD_RETURN(UNSIGNED); }
    270272__builtin_va_list { KEYWORD_RETURN(VALIST); }                   // GCC
     273virtual                 { KEYWORD_RETURN(VIRTUAL); }                    // CFA
    271274void                    { KEYWORD_RETURN(VOID); }
    272275volatile                { KEYWORD_RETURN(VOLATILE); }
     
    274277__volatile__    { KEYWORD_RETURN(VOLATILE); }                   // GCC
    275278while                   { KEYWORD_RETURN(WHILE); }
     279with                    { KEYWORD_RETURN(WITH); }                               // CFA
    276280zero_t                  { NUMERIC_RETURN(ZERO_T); }                             // CFA
    277281
     
    336340"-"                             { ASCIIOP_RETURN(); }
    337341"*"                             { ASCIIOP_RETURN(); }
     342"\\"                    { ASCIIOP_RETURN(); }                                   // CFA, exponentiation
    338343"/"                             { ASCIIOP_RETURN(); }
    339344"%"                             { ASCIIOP_RETURN(); }
     
    360365"+="                    { NAMEDOP_RETURN(PLUSassign); }
    361366"-="                    { NAMEDOP_RETURN(MINUSassign); }
     367"\\="                   { NAMEDOP_RETURN(EXPassign); }                  // CFA, exponentiation
    362368"*="                    { NAMEDOP_RETURN(MULTassign); }
    363369"/="                    { NAMEDOP_RETURN(DIVassign); }
  • src/Parser/parser.yy

    re0a653d r33218c6  
    99// Author           : Peter A. Buhr
    1010// Created On       : Sat Sep  1 20:22:55 2001
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Tus Jul 11 13:39:00 2017
    13 // Update Count     : 2416
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon Jul 24 09:01:14 2017
     13// Update Count     : 2463
    1414//
    1515
     
    118118%token RESTRICT                                                                                 // C99
    119119%token ATOMIC                                                                                   // C11
    120 %token FORALL LVALUE MUTEX                                                              // CFA
    121 %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED ZERO_T ONE_T
     120%token FORALL LVALUE MUTEX VIRTUAL                                              // CFA
     121%token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED
     122%token BOOL COMPLEX IMAGINARY                                                   // C99
     123%token ZERO_T ONE_T                                                                             // CFA
    122124%token VALIST                                                                                   // GCC
    123 %token BOOL COMPLEX IMAGINARY                                                   // C99
    124125%token TYPEOF LABEL                                                                             // GCC
    125126%token ENUM STRUCT UNION
     
    129130%token ATTRIBUTE EXTENSION                                                              // GCC
    130131%token IF ELSE SWITCH CASE DEFAULT DO WHILE FOR BREAK CONTINUE GOTO RETURN
    131 %token CHOOSE DISABLE ENABLE FALLTHRU TRY CATCH CATCHRESUME FINALLY THROW THROWRESUME AT        // CFA
     132%token CHOOSE DISABLE ENABLE FALLTHRU TRY CATCH CATCHRESUME FINALLY THROW THROWRESUME AT WITH   // CFA
    132133%token ASM                                                                                              // C99, extension ISO/IEC 9899:1999 Section J.5.10(1)
    133134%token ALIGNAS ALIGNOF GENERIC STATICASSERT                             // C11
     
    151152%token ELLIPSIS                                                                                 // ...
    152153
    153 %token MULTassign       DIVassign       MODassign                               // *=   /=      %=/
     154%token EXPassign        MULTassign      DIVassign       MODassign       // \=   *=      /=      %=
    154155%token PLUSassign       MINUSassign                                                     // +=   -=
    155156%token LSassign         RSassign                                                        // <<=  >>=
     
    168169%type<op> ptrref_operator                               unary_operator                          assignment_operator
    169170%type<en> primary_expression                    postfix_expression                      unary_expression
    170 %type<en> cast_expression                               multiplicative_expression       additive_expression                     shift_expression
    171 %type<en> relational_expression                 equality_expression                     AND_expression                          exclusive_OR_expression
    172 %type<en> inclusive_OR_expression               logical_AND_expression          logical_OR_expression           conditional_expression
    173 %type<en> constant_expression                   assignment_expression           assignment_expression_opt
     171%type<en> cast_expression                               exponential_expression          multiplicative_expression       additive_expression
     172%type<en> shift_expression                              relational_expression           equality_expression
     173%type<en> AND_expression                                exclusive_OR_expression         inclusive_OR_expression
     174%type<en> logical_AND_expression                logical_OR_expression
     175%type<en> conditional_expression                constant_expression                     assignment_expression           assignment_expression_opt
    174176%type<en> comma_expression                              comma_expression_opt
    175 %type<en> argument_expression_list              argument_expression                     assignment_opt
     177%type<en> argument_expression_list              argument_expression                     default_initialize_opt
    176178%type<fctl> for_control_expression
    177179%type<en> subrange
     
    184186// statements
    185187%type<sn> labeled_statement                             compound_statement                      expression_statement            selection_statement
    186 %type<sn> iteration_statement                   jump_statement                          exception_statement                     asm_statement
     188%type<sn> iteration_statement                   jump_statement
     189%type<sn> with_statement                                exception_statement                     asm_statement
    187190%type<sn> fall_through_opt                              fall_through
    188191%type<sn> statement                                             statement_list
    189192%type<sn> block_item_list                               block_item
    190 %type<sn> case_clause
     193%type<sn> with_clause_opt
    191194%type<en> case_value
    192 %type<sn> case_value_list                               case_label                                      case_label_list
     195%type<sn> case_clause                                   case_value_list                         case_label                                      case_label_list
    193196%type<sn> switch_clause_list_opt                switch_clause_list                      choose_clause_list_opt          choose_clause_list
    194197%type<sn> /* handler_list */                    handler_clause                          finally_clause
     
    568571        | '(' type_no_function ')' cast_expression
    569572                { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
     573                // VIRTUAL cannot be opt because of look ahead issues
     574        | '(' VIRTUAL ')' cast_expression
     575                { $$ = new ExpressionNode( build_cast( nullptr, $4 ) ); }
     576        | '(' VIRTUAL type_no_function ')' cast_expression
     577                { $$ = new ExpressionNode( build_cast( $3, $5 ) ); }
    570578//      | '(' type_no_function ')' tuple
    571579//              { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
    572580        ;
    573581
     582exponential_expression:
     583        cast_expression
     584        | exponential_expression '\\' cast_expression
     585                { $$ = new ExpressionNode( build_binary_val( OperKinds::Exp, $1, $3 ) ); }
     586        ;
     587
    574588multiplicative_expression:
    575         cast_expression
    576         | multiplicative_expression '*' cast_expression
     589        exponential_expression
     590        | multiplicative_expression '*' exponential_expression
    577591                { $$ = new ExpressionNode( build_binary_val( OperKinds::Mul, $1, $3 ) ); }
    578         | multiplicative_expression '/' cast_expression
     592        | multiplicative_expression '/' exponential_expression
    579593                { $$ = new ExpressionNode( build_binary_val( OperKinds::Div, $1, $3 ) ); }
    580         | multiplicative_expression '%' cast_expression
     594        | multiplicative_expression '%' exponential_expression
    581595                { $$ = new ExpressionNode( build_binary_val( OperKinds::Mod, $1, $3 ) ); }
    582596        ;
     
    677691        '='                                                                                     { $$ = OperKinds::Assign; }
    678692        | ATassign                                                                      { $$ = OperKinds::AtAssn; }
     693        | EXPassign                                                                     { $$ = OperKinds::ExpAssn; }
    679694        | MULTassign                                                            { $$ = OperKinds::MulAssn; }
    680695        | DIVassign                                                                     { $$ = OperKinds::DivAssn; }
     
    729744        | iteration_statement
    730745        | jump_statement
     746        | with_statement
    731747        | exception_statement
    732748        | asm_statement
     
    936952        ;
    937953
     954with_statement:
     955        WITH '(' tuple_expression_list ')' compound_statement
     956                { $$ = (StatementNode *)0; }                                    // FIX ME
     957        ;
     958
    938959exception_statement:
    939960        TRY compound_statement handler_clause
     
    965986                { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, nullptr, new ExpressionNode( build_constantInteger( *$6 ) ), $9 ) ) ); }
    966987
    967         | handler_key '(' push push exception_declaration pop ')' compound_statement pop
    968                 { $$ = new StatementNode( build_catch( $1, $5, nullptr, $8 ) ); }
    969         | handler_clause handler_key '(' push push exception_declaration pop ')' compound_statement pop
    970                 { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, $6, nullptr, $9 ) ) ); }
     988        | handler_key '(' push push exception_declaration pop handler_predicate_opt ')' compound_statement pop
     989                { $$ = new StatementNode( build_catch( $1, $5, nullptr, $9 ) ); }
     990        | handler_clause handler_key '(' push push exception_declaration pop handler_predicate_opt ')' compound_statement pop
     991                { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, $6, nullptr, $10 ) ) ); }
     992        ;
     993
     994handler_predicate_opt:
     995        //empty
     996        | ';' conditional_expression
    971997        ;
    972998
     
    14951521        | IMAGINARY                                                                                     // C99
    14961522                { $$ = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); }
    1497         | VALIST                                                                                        // GCC, __builtin_va_list
    1498                 { $$ = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
    14991523        | ZERO_T
    15001524                { $$ = DeclarationNode::newBuiltinType( DeclarationNode::Zero ); }
    15011525        | ONE_T
    15021526                { $$ = DeclarationNode::newBuiltinType( DeclarationNode::One ); }
     1527        | VALIST                                                                                        // GCC, __builtin_va_list
     1528                { $$ = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
    15031529        ;
    15041530
     
    16601686        | aggregate_key attribute_list_opt typegen_name         // CFA
    16611687                { $$ = $3->addQualifiers( $2 ); }
     1688
     1689// Temp, testing TreeStruct
     1690    | STRUCT TRY attribute_list_opt no_attr_identifier_or_type_name
     1691        {
     1692            typedefTable.makeTypedef( *$4 );            // create typedef
     1693            if ( forall ) typedefTable.changeKind( *$4, TypedefTable::TG ); // $
     1694            forall = false;                             // reset
     1695        }
     1696      '{' field_declaration_list '}'
     1697        {
     1698            $$ = DeclarationNode::newTreeStruct( DeclarationNode::Struct,
     1699                $4, nullptr, nullptr, $7, true )->addQualifiers( $3 );
     1700        }
     1701    | STRUCT TRY attribute_list_opt no_attr_identifier_or_type_name TYPEDEFname
     1702        {
     1703            typedefTable.makeTypedef( *$4 );            // create typedef
     1704            if ( forall ) typedefTable.changeKind( *$4, TypedefTable::TG ); // $
     1705            forall = false;                             // reset
     1706        }
     1707      '{' field_declaration_list '}'
     1708        {
     1709            $$ = DeclarationNode::newTreeStruct( DeclarationNode::Struct,
     1710                $4, $5, nullptr, $8, true )->addQualifiers( $3 );
     1711        }
    16621712        ;
    16631713
     
    18381888cfa_parameter_declaration:                                                              // CFA, new & old style parameter declaration
    18391889        parameter_declaration
    1840         | cfa_identifier_parameter_declarator_no_tuple identifier_or_type_name assignment_opt
     1890        | cfa_identifier_parameter_declarator_no_tuple identifier_or_type_name default_initialize_opt
    18411891                { $$ = $1->addName( $2 ); }
    1842         | cfa_abstract_tuple identifier_or_type_name assignment_opt
     1892        | cfa_abstract_tuple identifier_or_type_name default_initialize_opt
    18431893                // To obtain LR(1), these rules must be duplicated here (see cfa_abstract_declarator).
    18441894                { $$ = $1->addName( $2 ); }
    1845         | type_qualifier_list cfa_abstract_tuple identifier_or_type_name assignment_opt
     1895        | type_qualifier_list cfa_abstract_tuple identifier_or_type_name default_initialize_opt
    18461896                { $$ = $2->addName( $3 )->addQualifiers( $1 ); }
    18471897        | cfa_function_specifier
     
    18601910parameter_declaration:
    18611911                // No SUE declaration in parameter list.
    1862         declaration_specifier_nobody identifier_parameter_declarator assignment_opt
     1912        declaration_specifier_nobody identifier_parameter_declarator default_initialize_opt
    18631913                {
    18641914                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    18651915                        $$ = $2->addType( $1 )->addInitializer( $3 ? new InitializerNode( $3 ) : nullptr );
    18661916                }
    1867         | declaration_specifier_nobody type_parameter_redeclarator assignment_opt
     1917        | declaration_specifier_nobody type_parameter_redeclarator default_initialize_opt
    18681918                {
    18691919                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    18731923
    18741924abstract_parameter_declaration:
    1875         declaration_specifier_nobody assignment_opt
     1925        declaration_specifier_nobody default_initialize_opt
    18761926                { $$ = $1->addInitializer( $2 ? new InitializerNode( $2 ) : nullptr ); }
    1877         | declaration_specifier_nobody abstract_parameter_declarator assignment_opt
     1927        | declaration_specifier_nobody abstract_parameter_declarator default_initialize_opt
    18781928                { $$ = $2->addType( $1 )->addInitializer( $3 ? new InitializerNode( $3 ) : nullptr ); }
    18791929        ;
     
    22122262        ;
    22132263
     2264with_clause_opt:
     2265        // empty
     2266                { $$ = (StatementNode *)0; }                                    // FIX ME
     2267        | WITH '(' tuple_expression_list ')'
     2268                { $$ = (StatementNode *)0; }                                    // FIX ME
     2269        ;
     2270
    22142271function_definition:
    2215         cfa_function_declaration compound_statement                     // CFA
     2272        cfa_function_declaration with_clause_opt compound_statement     // CFA
    22162273                {
    22172274                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    22182275                        typedefTable.leaveScope();
    2219                         $$ = $1->addFunctionBody( $2 );
    2220                 }
    2221         | declaration_specifier function_declarator compound_statement
     2276                        $$ = $1->addFunctionBody( $3 );
     2277                }
     2278        | declaration_specifier function_declarator with_clause_opt compound_statement
    22222279                {
    22232280                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    22242281                        typedefTable.leaveScope();
    2225                         $$ = $2->addFunctionBody( $3 )->addType( $1 );
    2226                 }
    2227         | type_qualifier_list function_declarator compound_statement
     2282                        $$ = $2->addFunctionBody( $4 )->addType( $1 );
     2283                }
     2284        | type_qualifier_list function_declarator with_clause_opt compound_statement
    22282285                {
    22292286                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    22302287                        typedefTable.leaveScope();
    2231                         $$ = $2->addFunctionBody( $3 )->addQualifiers( $1 );
    2232                 }
    2233         | declaration_qualifier_list function_declarator compound_statement
     2288                        $$ = $2->addFunctionBody( $4 )->addQualifiers( $1 );
     2289                }
     2290        | declaration_qualifier_list function_declarator with_clause_opt compound_statement
    22342291                {
    22352292                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    22362293                        typedefTable.leaveScope();
    2237                         $$ = $2->addFunctionBody( $3 )->addQualifiers( $1 );
    2238                 }
    2239         | declaration_qualifier_list type_qualifier_list function_declarator compound_statement
     2294                        $$ = $2->addFunctionBody( $4 )->addQualifiers( $1 );
     2295                }
     2296        | declaration_qualifier_list type_qualifier_list function_declarator with_clause_opt compound_statement
    22402297                {
    22412298                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    22422299                        typedefTable.leaveScope();
    2243                         $$ = $3->addFunctionBody( $4 )->addQualifiers( $2 )->addQualifiers( $1 );
     2300                        $$ = $3->addFunctionBody( $5 )->addQualifiers( $2 )->addQualifiers( $1 );
    22442301                }
    22452302
    22462303                // Old-style K&R function definition, OBSOLESCENT (see 4)
    2247         | declaration_specifier KR_function_declarator push KR_declaration_list_opt compound_statement
     2304        | declaration_specifier KR_function_declarator push KR_declaration_list_opt with_clause_opt compound_statement
    22482305                {
    22492306                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    22502307                        typedefTable.leaveScope();
    2251                         $$ = $2->addOldDeclList( $4 )->addFunctionBody( $5 )->addType( $1 );
    2252                 }
    2253         | type_qualifier_list KR_function_declarator push KR_declaration_list_opt compound_statement
     2308                        $$ = $2->addOldDeclList( $4 )->addFunctionBody( $6 )->addType( $1 );
     2309                }
     2310        | type_qualifier_list KR_function_declarator push KR_declaration_list_opt with_clause_opt compound_statement
    22542311                {
    22552312                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    22562313                        typedefTable.leaveScope();
    2257                         $$ = $2->addOldDeclList( $4 )->addFunctionBody( $5 )->addQualifiers( $1 );
     2314                        $$ = $2->addOldDeclList( $4 )->addFunctionBody( $6 )->addQualifiers( $1 );
    22582315                }
    22592316
    22602317                // Old-style K&R function definition with "implicit int" type_specifier, OBSOLESCENT (see 4)
    2261         | declaration_qualifier_list KR_function_declarator push KR_declaration_list_opt compound_statement
     2318        | declaration_qualifier_list KR_function_declarator push KR_declaration_list_opt with_clause_opt compound_statement
    22622319                {
    22632320                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    22642321                        typedefTable.leaveScope();
    2265                         $$ = $2->addOldDeclList( $4 )->addFunctionBody( $5 )->addQualifiers( $1 );
    2266                 }
    2267         | declaration_qualifier_list type_qualifier_list KR_function_declarator push KR_declaration_list_opt compound_statement
     2322                        $$ = $2->addOldDeclList( $4 )->addFunctionBody( $6 )->addQualifiers( $1 );
     2323                }
     2324        | declaration_qualifier_list type_qualifier_list KR_function_declarator push KR_declaration_list_opt with_clause_opt compound_statement
    22682325                {
    22692326                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    22702327                        typedefTable.leaveScope();
    2271                         $$ = $3->addOldDeclList( $5 )->addFunctionBody( $6 )->addQualifiers( $2 )->addQualifiers( $1 );
     2328                        $$ = $3->addOldDeclList( $5 )->addFunctionBody( $7 )->addQualifiers( $2 )->addQualifiers( $1 );
    22722329                }
    22732330        ;
     
    30313088        ;
    30323089
    3033 assignment_opt:
     3090default_initialize_opt:
    30343091        // empty
    30353092                { $$ = nullptr; }
  • src/Parser/parserutility.cc

    re0a653d r33218c6  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Sat May 16 15:30:39 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jun 28 22:11:32 2017
    13 // Update Count     : 7
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Tus Jul 18 10:12:00 2017
     13// Update Count     : 8
    1414//
    1515
     
    2626        UntypedExpr *comparison = new UntypedExpr( new NameExpr( "?!=?" ) );
    2727        comparison->get_args().push_back( orig );
    28         comparison->get_args().push_back( new ConstantExpr( Constant( new ZeroType( emptyQualifiers ), "0", (unsigned long long int)0 ) ) );
     28        comparison->get_args().push_back( new ConstantExpr( Constant( new ZeroType( noQualifiers ), "0", (unsigned long long int)0 ) ) );
    2929        return new CastExpr( comparison, new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
    3030}
  • src/Parser/parserutility.h

    re0a653d r33218c6  
    1010// Created On       : Sat May 16 15:31:46 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jun 28 22:11:40 2017
    13 // Update Count     : 3
     12// Last Modified On : Sat Jul 22 09:32:58 2017
     13// Update Count     : 4
    1414//
    1515
    16 #ifndef PARSEUTILITY_H
    17 #define PARSEUTILITY_H
     16#pragma once
    1817
    1918#include "SynTree/SynTree.h"
    2019
    2120Expression *notZeroExpr( Expression *orig );
    22 
    23 #endif // PARSEUTILITY_H
    2421
    2522// Local Variables: //
  • src/ResolvExpr/Alternative.h

    re0a653d r33218c6  
    1010// Created On       : Sat May 16 23:45:43 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat May 16 23:54:39 2015
    13 // Update Count     : 2
     12// Last Modified On : Sat Jul 22 09:36:36 2017
     13// Update Count     : 3
    1414//
    1515
    16 #ifndef ALTERNATIVE_H
    17 #define ALTERNATIVE_H
     16#pragma once
    1817
    1918#include <list>
     
    4746} // namespace ResolvExpr
    4847
    49 #endif // ALTERNATIVE_H
    50 
    5148// Local Variables: //
    5249// tab-width: 4 //
  • src/ResolvExpr/AlternativeFinder.h

    re0a653d r33218c6  
    99// Author           : Richard C. Bilson
    1010// Created On       : Sat May 16 23:56:12 2015
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Tue Apr 19 11:44:53 2016
    13 // Update Count     : 2
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:35:32 2017
     13// Update Count     : 3
    1414//
    1515
    16 #ifndef ALTERNATIVEFINDER_H
    17 #define ALTERNATIVEFINDER_H
     16#pragma once
    1817
    1918#include <set>
     
    132131} // namespace ResolvExpr
    133132
    134 #endif // ALTERNATIVEFINDER_H
    135 
    136133// Local Variables: //
    137134// tab-width: 4 //
  • src/ResolvExpr/AlternativePrinter.h

    re0a653d r33218c6  
    1010// Created On       : Sun May 17 06:55:43 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun May 17 06:57:12 2015
    13 // Update Count     : 3
     12// Last Modified On : Sat Jul 22 09:37:09 2017
     13// Update Count     : 4
    1414//
    1515
    16 #ifndef ALTERNATIVEPRINTER_H
    17 #define ALTERNATIVEPRINTER_H
     16#pragma once
    1817
    1918#include <iostream>
     
    3433} // namespace ResolvExpr
    3534
    36 #endif // ALTERNATIVEPRINTER_H
    37 
    3835// Local Variables: //
    3936// tab-width: 4 //
  • src/ResolvExpr/ConversionCost.h

    re0a653d r33218c6  
    1010// Created On       : Sun May 17 09:37:28 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Mar  2 17:35:56 2016
    13 // Update Count     : 3
     12// Last Modified On : Sat Jul 22 09:38:24 2017
     13// Update Count     : 4
    1414//
    1515
    16 #ifndef CONVERSIONCOST_H
    17 #define CONVERSIONCOST_H
     16#pragma once
    1817
    1918#include "SynTree/Visitor.h"
     
    5150} // namespace ResolvExpr
    5251
    53 #endif // CONVERSIONCOST_H */
    54 
    5552// Local Variables: //
    5653// tab-width: 4 //
  • src/ResolvExpr/Cost.h

    re0a653d r33218c6  
    99// Author           : Richard C. Bilson
    1010// Created On       : Sun May 17 09:39:50 2015
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Wed Jul 22 16:43:10 2015
    13 // Update Count     : 4
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:35:55 2017
     13// Update Count     : 5
    1414//
    1515
    16 #ifndef COST_H
    17 #define COST_H
     16#pragma once
    1817
    1918#include <iostream>
     
    114113} // namespace ResolvExpr
    115114
    116 #endif // COST_H
    117 
    118115// Local Variables: //
    119116// tab-width: 4 //
  • src/ResolvExpr/CurrentObject.h

    re0a653d r33218c6  
    99// Author           : Rob Schluntz
    1010// Created On       : Thu Jun  8 11:07:25 2017
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Thu Jun  8 11:07:41 2017
    13 // Update Count     : 2
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:36:48 2017
     13// Update Count     : 3
    1414//
    1515
    16 #ifndef CURRENT_OBJECT_H
    17 #define CURRENT_OBJECT_H
     16#pragma once
    1817
    1918#include <stack>
     
    5049} // namespace ResolvExpr
    5150
    52 #endif // CURRENT_OBJECT_H
    53 
    5451// Local Variables: //
    5552// tab-width: 4 //
  • src/ResolvExpr/FindOpenVars.h

    re0a653d r33218c6  
    1010// Created On       : Sun May 17 09:46:04 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun May 17 09:47:20 2015
    13 // Update Count     : 2
     12// Last Modified On : Sat Jul 22 09:35:18 2017
     13// Update Count     : 3
    1414//
    1515
    16 #ifndef FINDOPENVARS_H
    17 #define FINDOPENVARS_H
     16#pragma once
    1817
    1918#include "Unify.h"
     
    2524} // namespace ResolvExpr
    2625
    27 #endif // FINDOPENVARS_H
    28 
    2926// Local Variables: //
    3027// tab-width: 4 //
  • src/ResolvExpr/RenameVars.h

    re0a653d r33218c6  
    1010// Created On       : Sun May 17 12:10:28 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Mar  2 17:36:39 2016
    13 // Update Count     : 3
     12// Last Modified On : Sat Jul 22 09:33:54 2017
     13// Update Count     : 4
    1414//
    1515
    16 #ifndef RESOLVEXPR_RENAMEVARS_H
    17 #define RESOLVEXPR_RENAMEVARS_H
     16#pragma once
    1817
    1918#include <list>
     
    5655} // namespace ResolvExpr
    5756
    58 #endif // RENAMEVARS_H
    59 
    6057// Local Variables: //
    6158// tab-width: 4 //
  • src/ResolvExpr/ResolveTypeof.h

    re0a653d r33218c6  
    1010// Created On       : Sun May 17 12:14:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun May 17 12:16:29 2015
    13 // Update Count     : 2
     12// Last Modified On : Sat Jul 22 09:38:35 2017
     13// Update Count     : 3
    1414//
    1515
    16 #ifndef RESOLVETYPEOF_H
    17 #define RESOLVETYPEOF_H
     16#pragma once
    1817
    1918#include "SynTree/SynTree.h"
     
    2423} // namespace ResolvExpr
    2524
    26 #endif // RESOLVETYPEOF_H
    27 
    2825// Local Variables: //
    2926// tab-width: 4 //
  • src/ResolvExpr/Resolver.h

    re0a653d r33218c6  
    99// Author           : Richard C. Bilson
    1010// Created On       : Sun May 17 12:18:34 2015
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Thu Apr 14 15:06:53 2016
    13 // Update Count     : 2
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:36:57 2017
     13// Update Count     : 3
    1414//
    1515
    16 #ifndef RESOLVER_H
    17 #define RESOLVER_H
     16#pragma once
    1817
    1918#include "SynTree/SynTree.h"
     
    2928} // namespace ResolvExpr
    3029
    31 #endif // RESOLVER_H
    32 
    3330// Local Variables: //
    3431// tab-width: 4 //
  • src/ResolvExpr/TypeEnvironment.h

    re0a653d r33218c6  
    1010// Created On       : Sun May 17 12:24:58 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun May 17 12:26:52 2015
    13 // Update Count     : 2
     12// Last Modified On : Sat Jul 22 09:35:45 2017
     13// Update Count     : 3
    1414//
    1515
    16 #ifndef TYPEENVIRONMENT_H
    17 #define TYPEENVIRONMENT_H
     16#pragma once
    1817
    1918#include <string>
     
    9998} // namespace ResolvExpr
    10099
    101 #endif // TYPEENVIRONMENT_H */
    102 
    103100// Local Variables: //
    104101// tab-width: 4 //
  • src/ResolvExpr/TypeMap.h

    re0a653d r33218c6  
    99// Author           : Aaron B. Moss
    1010// Created On       : Fri Feb 19 13:55:00 2016
    11 // Last Modified By : Aaron B. Moss
    12 // Last Modified On : Fri Feb 19 13:55:00 2016
    13 // Update Count     : 1
    14 //
    15 
    16 #ifndef _TYPEMAP_H
    17 #define _TYPEMAP_H
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:37:19 2017
     13// Update Count     : 2
     14//
     15
     16#pragma once
    1817
    1918#include <map>
     
    204203}  // namespace ResolvExpr
    205204
    206 #endif // _TYPEMAP_H
    207 
    208205// Local Variables: //
    209206// tab-width: 4 //
  • src/ResolvExpr/Unify.h

    re0a653d r33218c6  
    1010// Created On       : Sun May 17 13:09:04 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun May 17 13:10:34 2015
    13 // Update Count     : 2
     12// Last Modified On : Fri Jul 21 23:09:34 2017
     13// Update Count     : 3
    1414//
    1515
    16 #ifndef UNIFY_H
    17 #define UNIFY_H
     16#pragma once
    1817
    1918#include <map>
     
    7271} // namespace ResolvExpr
    7372
    74 #endif // UNIFY_H
    75 
    7673// Local Variables: //
    7774// tab-width: 4 //
  • src/ResolvExpr/typeops.h

    re0a653d r33218c6  
    1010// Created On       : Sun May 17 07:28:22 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun May 17 07:33:11 2015
    13 // Update Count     : 2
     12// Last Modified On : Sat Jul 22 09:36:18 2017
     13// Update Count     : 3
    1414//
    1515
    16 #ifndef TYPEOPS_H
    17 #define TYPEOPS_H
     16#pragma once
    1817
    1918#include "SynTree/SynTree.h"
     
    157156} // namespace ResolvExpr
    158157
    159 #endif // TYPEOPS_H
    160 
    161158// Local Variables: //
    162159// tab-width: 4 //
  • src/SymTab/Autogen.cc

    re0a653d r33218c6  
    1010// Created On       : Thu Mar 03 15:45:56 2016
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Wed Jun 28 15:30:00 2017
    13 // Update Count     : 61
     12// Last Modified On : Fri Jul 14 16:41:00 2017
     13// Update Count     : 62
    1414//
    1515#include "Autogen.h"
     
    407407        void makeStructFunctions( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting, std::list< Declaration * > & declsToAdd, const std::vector< FuncData > & data ) {
    408408                // Builtins do not use autogeneration.
    409                 if ( aggregateDecl->get_linkage() == LinkageSpec::Builtin ||
     409                if ( aggregateDecl->get_linkage() == LinkageSpec::BuiltinCFA ||
    410410                         aggregateDecl->get_linkage() == LinkageSpec::BuiltinC ) {
    411411                        return;
  • src/SymTab/Autogen.h

    re0a653d r33218c6  
    1010// Created On       : Sun May 17 21:53:34 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jun 21 17:25:26 2017
    13 // Update Count     : 14
     12// Last Modified On : Sat Jul 22 09:50:25 2017
     13// Update Count     : 15
    1414//
    1515
    16 #ifndef AUTOGEN_H
    17 #define AUTOGEN_H
     16#pragma once
    1817
    1918#include <cassert>                // for assert
     
    183182        }
    184183} // namespace SymTab
    185 #endif // AUTOGEN_H
     184
     185// Local Variables: //
     186// tab-width: 4 //
     187// mode: c++ //
     188// compile-command: "make install" //
     189// End: //
     190
  • src/SymTab/FixFunction.h

    re0a653d r33218c6  
    1010// Created On       : Sun May 17 17:02:08 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Mar  2 17:34:06 2016
    13 // Update Count     : 3
     12// Last Modified On : Sat Jul 22 09:45:55 2017
     13// Update Count     : 4
    1414//
    1515
    16 #ifndef FIXFUNCTION_H
    17 #define FIXFUNCTION_H
     16#pragma once
    1817
    1918#include "SynTree/Mutator.h"  // for Mutator
     
    5049} // namespace SymTab
    5150
    52 #endif // FIXFUNCTION_H
    53 
    5451// Local Variables: //
    5552// tab-width: 4 //
  • src/SymTab/ImplementationType.h

    re0a653d r33218c6  
    1010// Created On       : Sun May 17 21:35:41 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun May 17 21:37:15 2015
    13 // Update Count     : 2
     12// Last Modified On : Sat Jul 22 09:46:19 2017
     13// Update Count     : 3
    1414//
    1515
    16 #ifndef IMPLEMENTATIONTYPE_H
    17 #define IMPLEMENTATIONTYPE_H
     16#pragma once
    1817
    1918class Type;
     
    3231} // namespace SymTab
    3332
    34 #endif // IMPLEMENTATIONTYPE_H
    35 
    3633// Local Variables: //
    3734// tab-width: 4 //
  • src/SymTab/Indexer.h

    re0a653d r33218c6  
    1010// Created On       : Sun May 17 21:38:55 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Mar  2 17:34:14 2016
    13 // Update Count     : 6
     12// Last Modified On : Sat Jul 22 09:46:34 2017
     13// Update Count     : 7
    1414//
    1515
    16 #ifndef INDEXER_H
    17 #define INDEXER_H
     16#pragma once
    1817
    1918#include <iosfwd>             // for ostream
     
    148147} // namespace SymTab
    149148
    150 #endif // INDEXER_H
    151 
    152149// Local Variables: //
    153150// tab-width: 4 //
  • src/SymTab/Mangler.h

    re0a653d r33218c6  
    99// Author           : Richard C. Bilson
    1010// Created On       : Sun May 17 21:44:03 2015
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Wed Aug 19 15:48:46 2015
    13 // Update Count     : 14
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:45:30 2017
     13// Update Count     : 15
    1414//
    1515
    16 #ifndef MANGLER_H
    17 #define MANGLER_H
     16#pragma once
    1817
    1918#include <map>                // for map, map<>::value_compare
     
    8180} // SymTab
    8281
    83 #endif // MANGLER_H
    84 
    8582// Local Variables: //
    8683// tab-width: 4 //
  • src/SymTab/Validate.h

    re0a653d r33218c6  
    1111// Created On       : Sun May 17 21:53:34 2015
    1212// Last Modified By : Peter A. Buhr
    13 // Last Modified On : Tue May 19 16:49:43 2015
    14 // Update Count     : 3
     13// Last Modified On : Sat Jul 22 09:46:07 2017
     14// Update Count     : 4
    1515//
    1616
    17 #ifndef VALIDATE_H
    18 #define VALIDATE_H
     17#pragma once
    1918
    2019#include <list>  // for list
     
    3130} // namespace SymTab
    3231
    33 #endif // VALIDATE_H
    34 
    3532// Local Variables: //
    3633// tab-width: 4 //
  • src/SymTab/module.mk

    re0a653d r33218c6  
    1010## Author           : Richard C. Bilson
    1111## Created On       : Mon Jun  1 17:49:17 2015
    12 ## Last Modified By : Rob Schluntz
    13 ## Last Modified On : Tue Jul 07 16:22:23 2015
    14 ## Update Count     : 2
     12## Last Modified By : Andrew Beach
     13## Last Modified On : Wed Jul 12 13:06:00 2017
     14## Update Count     : 3
    1515###############################################################################
    1616
     
    2121       SymTab/ImplementationType.cc \
    2222       SymTab/TypeEquality.cc \
    23        SymTab/Autogen.cc
     23       SymTab/Autogen.cc \
     24       SymTab/TreeStruct.cc
  • src/SynTree/AddStmtVisitor.h

    re0a653d r33218c6  
    1010// Created On       : Wed Jun 22 12:05:48 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul 12 17:50:32 2016
    13 // Update Count     : 8
     12// Last Modified On : Sat Jul 22 09:51:08 2017
     13// Update Count     : 9
    1414//
    1515
    16 #ifndef ADD_STATEMENT_VISITOR_H
    17 #define ADD_STATEMENT_VISITOR_H
     16#pragma once
    1817
    1918#include <list>
     
    4241};
    4342
    44 #endif // ADD_STATEMENT_VISITOR_H
     43// Local Variables: //
     44// tab-width: 4 //
     45// mode: c++ //
     46// compile-command: "make install" //
     47// End: //
  • src/SynTree/Attribute.h

    re0a653d r33218c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jan 18 16:27:11 2017
    13 // Update Count     : 38
     12// Last Modified On : Sat Jul 22 09:54:14 2017
     13// Update Count     : 39
    1414//
    1515
    16 #ifndef GCC_ATTRIBUTE_H
    17 #define GCC_ATTRIBUTE_H
     16#pragma once
    1817
    1918#include "SynTree.h"
     
    4241const std::list< Attribute * > noAttributes;
    4342
    44 #endif
    45 
    4643// Local Variables: //
    4744// tab-width: 4 //
  • src/SynTree/BaseSyntaxNode.h

    re0a653d r33218c6  
    1414//
    1515
    16 #ifndef BASE_SYNTAX_NODE_H
    17 #define BASE_SYNTAX_NODE_H
     16#pragma once
    1817
    1918#include "Common/utility.h"
     
    2928};
    3029
    31 #endif // BASE_SYNTAX_NODE_H
    32 
    3330// Local Variables: //
    3431// tab-width: 4 //
  • src/SynTree/Constant.cc

    re0a653d r33218c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Thr Jun 22 10:11:00 2017
    13 // Update Count     : 28
     12// Last Modified On : Fri Jul 14 14:50:00 2017
     13// Update Count     : 29
    1414//
    1515
     
    4646}
    4747
     48Constant Constant::null( Type * ptrtype ) {
     49        if ( nullptr == ptrtype ) {
     50                ptrtype = new PointerType(
     51                        Type::Qualifiers(),
     52                        new VoidType( Type::Qualifiers() )
     53                        );
     54        }
     55
     56        return Constant( ptrtype, "0", (unsigned long long int)0 );
     57}
     58
    4859unsigned long long Constant::get_ival() const {
    4960        assertf( safe_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve ival from non-integer constant." );
  • src/SynTree/Constant.h

    re0a653d r33218c6  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Thr Jun 22 10:13:00 2017
    13 // Update Count     : 15
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:54:46 2017
     13// Update Count     : 17
    1414//
    1515
    16 #ifndef CONSTANT_H
    17 #define CONSTANT_H
     16#pragma once
    1817
    1918#include "SynTree.h"
     
    4443        static Constant from_double( double d );
    4544
     45        /// generates a null pointer value for the given type. void * if omitted.
     46        static Constant null( Type * ptrtype = nullptr );
     47
    4648        virtual void accept( Visitor & v ) { v.visit( this ); }
    4749        virtual Constant * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     
    5860};
    5961
    60 #endif // CONSTANT_H
    61 
    6262// Local Variables: //
    6363// tab-width: 4 //
  • src/SynTree/Declaration.h

    re0a653d r33218c6  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Tus Jun 27 15:31:00 2017
    13 // Update Count     : 122
    14 //
    15 
    16 #ifndef DECLARATION_H
    17 #define DECLARATION_H
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:52:59 2017
     13// Update Count     : 124
     14//
     15
     16#pragma once
    1817
    1918#include <string>
     
    266265        typedef AggregateDecl Parent;
    267266  public:
    268         StructDecl( const std::string &name, DeclarationNode::Aggregate kind = DeclarationNode::Struct, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ), kind( kind ) {}
     267        StructDecl( const std::string &name, DeclarationNode::Aggregate kind = DeclarationNode::Struct, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ), kind( kind ), tagged( false ), parent_name( "" ) {}
     268        StructDecl( const std::string &name, const std::string *parent, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ), kind( DeclarationNode::Struct ), tagged( true ), parent_name( parent ? *parent : "" ) {}
    269269        StructDecl( const StructDecl &other ) : Parent( other ) {}
    270270
     
    273273        bool is_thread() { return kind == DeclarationNode::Thread; }
    274274
     275        // Tagged/Tree Structure Excetion
     276        bool get_tagged() { return tagged; }
     277        void set_tagged( bool newValue ) { tagged = newValue; }
     278        bool has_parent() { return parent_name != ""; }
     279        std::string get_parentName() { return parent_name; }
     280
    275281        virtual StructDecl *clone() const { return new StructDecl( *this ); }
    276282        virtual void accept( Visitor &v ) { v.visit( this ); }
     
    279285        DeclarationNode::Aggregate kind;
    280286        virtual std::string typeString() const;
     287
     288        bool tagged;
     289        std::string parent_name;
    281290};
    282291
     
    342351std::ostream & operator<<( std::ostream & out, const Declaration * decl );
    343352std::ostream & operator<<( std::ostream & os, const TypeDecl::Data & data );
    344 
    345 #endif // DECLARATION_H
    346353
    347354// Local Variables: //
  • src/SynTree/Expression.h

    re0a653d r33218c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Mar 30 16:44:00 2017
    13 // Update Count     : 41
     12// Last Modified On : Sat Jul 22 09:53:16 2017
     13// Update Count     : 42
    1414//
    1515
    16 #ifndef EXPRESSION_H
    17 #define EXPRESSION_H
     16#pragma once
    1817
    1918#include <map>
     
    798797std::ostream & operator<<( std::ostream & out, const Expression * expr );
    799798
    800 #endif // EXPRESSION_H
    801 
    802799// Local Variables: //
    803800// tab-width: 4 //
  • src/SynTree/Initializer.h

    re0a653d r33218c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Mar 23 16:12:42 2017
    13 // Update Count     : 20
     12// Last Modified On : Sat Jul 22 09:52:02 2017
     13// Update Count     : 21
    1414//
    1515
    16 #ifndef INITIALIZER_H
    17 #define INITIALIZER_H
     16#pragma once
    1817
    1918#include <cassert>
     
    141140std::ostream & operator<<( std::ostream & out, const Designation * des );
    142141
    143 #endif // INITIALIZER_H
    144 
    145142// Local Variables: //
    146143// tab-width: 4 //
  • src/SynTree/Label.h

    re0a653d r33218c6  
    1010// Created On       : Wed Jun 8 12:53:12 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Aug  7 14:44:29 2016
    13 // Update Count     : 2
     12// Last Modified On : Sat Jul 22 09:52:44 2017
     13// Update Count     : 3
    1414//
    1515
    16 #ifndef LABEL_H
    17 #define LABEL_H
     16#pragma once
    1817
    1918#include <string>
     
    5150static const std::list< Label > noLabels;
    5251
    53 #endif // LABEL_H
    54 
    5552// Local Variables: //
    5653// tab-width: 4 //
  • src/SynTree/Mutator.h

    re0a653d r33218c6  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Thu Jun  8 15:45:00 2017
    13 // Update Count     : 14
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:51:30 2017
     13// Update Count     : 15
    1414//
    1515#include <cassert>
     
    1818#include "Common/SemanticError.h"
    1919
    20 #ifndef MUTATOR_H
    21 #define MUTATOR_H
     20#pragma once
    2221
    2322class Mutator {
     
    150149}
    151150
    152 #endif // MUTATOR_H
    153 
    154151// Local Variables: //
    155152// tab-width: 4 //
  • src/SynTree/Statement.h

    re0a653d r33218c6  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Jun 12 13:35:00 2017
    13 // Update Count     : 67
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:54:32 2017
     13// Update Count     : 68
    1414//
    1515
    16 #ifndef STATEMENT_H
    17 #define STATEMENT_H
     16#pragma once
    1817
    1918#include "BaseSyntaxNode.h"
     
    428427std::ostream & operator<<( std::ostream & out, const Statement * statement );
    429428
    430 #endif // STATEMENT_H
    431 
    432429// Local Variables: //
    433430// tab-width: 4 //
  • src/SynTree/SynTree.h

    re0a653d r33218c6  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Thu Jun  8 17:00:00 2017
    13 // Update Count     : 9
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:51:46 2017
     13// Update Count     : 10
    1414//
    1515
    16 #ifndef SYNTREE_H
    17 #define SYNTREE_H
     16#pragma once
    1817
    1918#include <string>
     
    135134class Attribute;
    136135
    137 #endif // SYNTREE_H
    138 
    139136// Local Variables: //
    140137// tab-width: 4 //
  • src/SynTree/Type.h

    re0a653d r33218c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Mar 23 16:16:36 2017
    13 // Update Count     : 149
     12// Last Modified On : Sat Jul 22 09:53:29 2017
     13// Update Count     : 151
    1414//
    1515
    16 #ifndef TYPE_H
    17 #define TYPE_H
     16#pragma once
    1817
    1918#include "BaseSyntaxNode.h"
     
    172171};
    173172
    174 extern Type::Qualifiers emptyQualifiers;                                // no qualifiers on constants
     173extern Type::Qualifiers noQualifiers;                           // no qualifiers on constants
    175174
    176175class VoidType : public Type {
     
    602601std::ostream & operator<<( std::ostream & out, const Type * type );
    603602
    604 #endif // TYPE_H
    605 
    606603// Local Variables: //
    607604// tab-width: 4 //
  • src/SynTree/TypeSubstitution.h

    re0a653d r33218c6  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Fri Apr 29 15:00:20 2016
    13 // Update Count     : 2
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:52:24 2017
     13// Update Count     : 3
    1414//
    1515
    16 #ifndef TYPESUBSTITUTION_H
    17 #define TYPESUBSTITUTION_H
     16#pragma once
    1817
    1918#include <map>
     
    180179std::ostream & operator<<( std::ostream & out, const TypeSubstitution & sub );
    181180
    182 #endif // TYPESUBSTITUTION_H
    183 
    184181// Local Variables: //
    185182// tab-width: 4 //
  • src/SynTree/VarExprReplacer.h

    re0a653d r33218c6  
    99// Author           : Rob Schluntz
    1010// Created On       : Wed Jan 13 16:29:30 2016
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Fri May 13 11:27:52 2016
    13 // Update Count     : 5
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:53:41 2017
     13// Update Count     : 6
    1414//
    1515
    16 #ifndef VAR_EXPR_REPLACER_H
    17 #define VAR_EXPR_REPLACER_H
     16#pragma once
    1817
    1918#include <map>
     
    3534};
    3635
    37 #endif // VAR_EXPR_REPLACER_H
    38 
    3936// Local Variables: //
    4037// tab-width: 4 //
  • src/SynTree/Visitor.h

    re0a653d r33218c6  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Thr Jun 08 15:45:00 2017
    13 // Update Count     : 11
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Jul 22 09:54:04 2017
     13// Update Count     : 12
    1414//
    1515