Changes in / [b7d6a36:dca5802]


Ignore:
Files:
33 added
81 deleted
206 edited

Legend:

Unmodified
Added
Removed

  • Jenkinsfile

    rb7d6a36 rdca5802  
    215215
    216216                //Then publish the results
    217                 do_plot(Settings.RunBenchmark && Settings.Publish, 'compile'        , groupCompile    , false, 'Compilation')
    218                 do_plot(Settings.RunBenchmark && Settings.Publish, 'compile.diff'   , groupCompile    , true , 'Compilation (relative)')
    219                 do_plot(Settings.RunBenchmark && Settings.Publish, 'ctxswitch'      , groupConcurrency, false, 'Context Switching')
    220                 do_plot(Settings.RunBenchmark && Settings.Publish, 'ctxswitch.diff' , groupConcurrency, true , 'Context Switching (relative)')
    221                 do_plot(Settings.RunBenchmark && Settings.Publish, 'mutex'          , groupConcurrency, false, 'Mutual Exclusion')
    222                 do_plot(Settings.RunBenchmark && Settings.Publish, 'mutex.diff'     , groupConcurrency, true , 'Mutual Exclusion (relative)')
    223                 do_plot(Settings.RunBenchmark && Settings.Publish, 'scheduling'     , groupConcurrency, false, 'Internal and External Scheduling')
    224                 do_plot(Settings.RunBenchmark && Settings.Publish, 'scheduling.diff', groupConcurrency, true , 'Internal and External Scheduling (relative)')
     217                do_plot(Settings.RunBenchmark && Settings.Publish, 'compile'       , groupCompile    , false, 'Compilation')
     218                do_plot(Settings.RunBenchmark && Settings.Publish, 'compile.diff'  , groupCompile    , true , 'Compilation (relative)')
     219                do_plot(Settings.RunBenchmark && Settings.Publish, 'ctxswitch'     , groupConcurrency, false, 'Context Switching')
     220                do_plot(Settings.RunBenchmark && Settings.Publish, 'ctxswitch.diff', groupConcurrency, true , 'Context Switching (relative)')
     221                do_plot(Settings.RunBenchmark && Settings.Publish, 'mutex'         , groupConcurrency, false, 'Mutual Exclusion')
     222                do_plot(Settings.RunBenchmark && Settings.Publish, 'mutex.diff'    , groupConcurrency, true , 'Mutual Exclusion (relative)')
     223                do_plot(Settings.RunBenchmark && Settings.Publish, 'signal'        , groupConcurrency, false, 'Internal and External Scheduling')
     224                do_plot(Settings.RunBenchmark && Settings.Publish, 'signal.diff'   , groupConcurrency, true , 'Internal and External Scheduling (relative)')
    225225        }
    226226}

  • benchmark/Makefile.am

    rb7d6a36 rdca5802  
    1111## Created On       : Sun May 31 09:08:15 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Sat Jan 25 09:20:44 2020
    14 ## Update Count     : 255
     13## Last Modified On : Mon Jul 29 18:02:19 2019
     14## Update Count     : 54
    1515###############################################################################
    1616
    … …  
    2828BENCH_V_CFA = $(__bench_v_CFA_$(__quiet))
    2929BENCH_V_CXX = $(__bench_v_CXX_$(__quiet))
     30BENCH_V_GOC = $(__bench_v_GOC_$(__quiet))
     31BENCH_V_JAVAC = $(__bench_v_JAVAC_$(__quiet))
    3032BENCH_V_UPP = $(__bench_v_UPP_$(__quiet))
    31 BENCH_V_GOC = $(__bench_v_GOC_$(__quiet))
    32 BENCH_V_PY = $(__bench_v_PY_$(__quiet))
    33 BENCH_V_RUSTC = $(__bench_v_RUSTC_$(__quiet))
    34 BENCH_V_NODEJS = $(__bench_v_NODEJS_$(__quiet))
    35 BENCH_V_JAVAC = $(__bench_v_JAVAC_$(__quiet))
    3633
    3734__quiet = verbose
    … …  
    3936__bench_v_CFA_quiet = @
    4037__bench_v_CXX_quiet = @
     38__bench_v_GOC_quiet = @
     39__bench_v_JAVAC_quiet = @
    4140__bench_v_UPP_quiet = @
    42 __bench_v_GOC_quiet = @
    43 __bench_v_RUSTC_quiet = @
    44 __bench_v_JAVAC_quiet = @
    4541__bench_v_CC_verbose = $(AM_V_CC)
    4642__bench_v_CFA_verbose = $(AM_V_CFA)
    4743__bench_v_CXX_verbose = $(AM_V_CXX)
     44__bench_v_GOC_verbose = $(AM_V_GOC)
     45__bench_v_JAVAC_verbose = $(AM_V_JAVAC)
    4846__bench_v_UPP_verbose = $(AM_V_UPP)
    49 __bench_v_GOC_verbose = $(AM_V_GOC)
    50 __bench_v_PY_verbose = $(AM_V_PY)
    51 __bench_v_RUSTC_verbose = $(AM_V_RUST)
    52 __bench_v_NODEJS_verbose = $(AM_V_NODEJS)
    53 __bench_v_JAVAC_verbose = $(AM_V_JAVAC)
    5447
    5548
    … …  
    5851STATS    = ${abs_top_srcdir}/tools/stat.py
    5952# NEED AT LEAST 4 DATA VALUES FOR BENCHMARKS BECAUSE THE MAX AND MIN VALUES ARE REMOVED
    60 repeats  = 13 # 31 for benchmarks
     53repeats  = 5 # 31 for benchmarks
    6154arch     = x64
    6255skipcompile = no
    … …  
    6962
    7063dummyC.c:
    71         echo "int main() { return 0; }" > ${@}
     64        @echo "int main() { return 0; }" > ${@}
    7265
    7366dummyCXX.cpp:
    74         echo "int main() { return 0; }" > ${@}
    75 
    76 .SILENT:                # do not print recipe
     67        @echo "int main() { return 0; }" > ${@}
     68
    7769.NOTPARALLEL:
    78 .PHONY: jenkins cleancsv
    79 
    80 ## =========================================================================================================
    81 
    82 all : basic$(EXEEXT) ctxswitch$(EXEEXT) mutex$(EXEEXT) schedint$(EXEEXT) schedext$(EXEEXT) creation$(EXEEXT)
    83 
    84 basic_loop_DURATION = 15000000000
    85 basic_function_DURATION = 10000000000
    86 basic_tls_fetch_add_DURATION = 10000000000
    87 basic_DURATION = 250000000
    88 
    89 ctxswitch_pthread_DURATION = 25000000
    90 ctxswitch_rust_thread_DURATION = $(ctxswitch_pthread_DURATION)
    91 ctxswitch_cfa_generator_DURATION = 5000000000
    92 ctxswitch_nodejs_await_DURATION = 5000000
    93 ctxswitch_DURATION = 100000000
    94 
    95 #mutex_java_DURATION = 10000000
    96 mutex_DURATION = 50000000
    97 
    98 schedint_pthread_DURATION = 1000000
    99 schedint_java_DURATION = $(schedint_pthread_DURATION)
    100 schedint_rust_DURATION = $(schedint_pthread_DURATION)
    101 schedint_DURATION = 10000000
    102 
    103 schedext_DURATION = 10000000
    104 
    105 creation_pthread_DURATION = 250000
    106 creation_rust_thread_DURATION = ${creation_pthread_DURATION}
    107 creation_java_thread_DURATION = ${creation_pthread_DURATION}
    108 creation_cfa_coroutine_DURATION = 100000000
    109 creation_cfa_coroutine_eager_DURATION = 10000000
    110 creation_upp_coroutine_DURATION = ${creation_cfa_coroutine_eager_DURATION}
    111 creation_cfa_thread_DURATION = 10000000
    112 creation_upp_thread_DURATION = ${creation_cfa_thread_DURATION}
    113 creation_DURATION = 10000000
     70.PHONY: compile.csv ctxswitch.csv mutex.csv signal.csv
     71
     72## =========================================================================================================
     73all : ctxswitch$(EXEEXT) mutex$(EXEEXT) signal$(EXEEXT) waitfor$(EXEEXT) creation$(EXEEXT)
    11474
    11575%.run : %$(EXEEXT) ${REPEAT}
    116         rm -f .result.log
    117         echo "------------------------------------------------------"
    118         echo $<
    119         ${REPEAT} ${repeats} -- ./a.out\
    120                 $(if ${$(subst -,_,$(basename $@))_DURATION},\
    121                         ${$(subst -,_,$(basename $@))_DURATION},\
    122                         ${$(firstword $(subst -, ,$(basename $@)))_DURATION}) | tee -a .result.log
    123         ${STATS} .result.log
    124         echo "------------------------------------------------------"
    125         rm -f a.out .result.log *.class
    126 
    127 #       ${REPEAT} ${repeats} -- /usr/bin/time -f "%Uu %Ss %Er %Mkb" ./a.out
     76        @rm -f .result.log
     77        @echo "------------------------------------------------------"
     78        @echo $<
     79        @${REPEAT} ${repeats} ./a.out | tee -a .result.log
     80        @${STATS} .result.log
     81        @echo "------------------------------------------------------"
     82        @rm -f a.out .result.log *.class
    12883
    12984%.runquiet :
    130         +make $(basename $@) CFLAGS="-w" __quiet=quiet
    131         taskset -c 1 ./a.out
    132         rm -f a.out
     85        @+make $(basename $@) CFLAGS="-w" __quiet=quiet
     86        @taskset -c 1 ./a.out
     87        @rm -f a.out
    13388
    13489%.make :
    135         printf "${PRINT_FORMAT}" $(basename $(subst compile-,,$@))
    136         +/usr/bin/time -f ${TIME_FORMAT} make $(basename $@) 2>&1
     90        @printf "${PRINT_FORMAT}" $(basename $(subst compile-,,$@))
     91        @+/usr/bin/time -f ${TIME_FORMAT} make $(basename $@) 2>&1
    13792
    13893${REPEAT} :
    139         +make -C ${abs_top_builddir}/tools repeat
     94        @+make -C ${abs_top_builddir}/tools repeat
    14095
    14196## =========================================================================================================
    … …  
    14398FIX_NEW_LINES = cat $@ | tr "\n" "\t" | sed -r 's/\t,/,/' | tr "\t" "\n" > $@
    14499
    145 cleancsv:
    146         rm -f compile.csv basic.csv ctxswitch.csv mutex.csv scheduling.csv
    147 
    148 jenkins$(EXEEXT): cleancsv
     100jenkins$(EXEEXT):
    149101@DOifskipcompile@
    150         +make compile.csv
    151         -+make compile.diff.csv
     102        @+make compile.csv
     103        @-+make compile.diff.csv
    152104@DOendif@
    153         +make ctxswitch.csv
    154         -+make ctxswitch.diff.csv
    155         +make mutex.csv
    156         -+make mutex.diff.csv
    157         +make scheduling.csv
    158         -+make scheduling.diff.csv
     105        @+make ctxswitch.csv
     106        @-+make ctxswitch.diff.csv
     107        @+make mutex.csv
     108        @-+make mutex.diff.csv
     109        @+make signal.csv
     110        @-+make signal.diff.csv
    159111@DOifskipcompile@
    160112        cat compile.csv
    … …  
    165117        cat mutex.csv
    166118        -cat mutex.diff.csv
    167         cat scheduling.csv
    168         -cat scheduling.diff.csv
     119        cat signal.csv
     120        -cat signal.diff.csv
    169121
    170122compile.csv:
    171         echo "building $@"
    172         echo "array,attributes,empty,expression,io,monitor,operators,typeof" > $@
    173         +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-array.make >> $@
    174         +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-attributes.make >> $@
    175         +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-empty.make >> $@
    176         +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-expression.make >> $@
    177         +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-io.make >> $@
    178         +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-monitor.make >> $@
    179         +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-operators.make >> $@
    180         +make TIME_FORMAT='%e' PRINT_FORMAT='' compile-typeof.make >> $@
    181         $(srcdir)/fixcsv.sh $@
     123        @echo "array,attributes,empty,expression,io,monitor,operators,typeof" > $@
     124        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-array.make >> $@
     125        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-attributes.make >> $@
     126        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-empty.make >> $@
     127        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-expression.make >> $@
     128        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-io.make >> $@
     129        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-monitor.make >> $@
     130        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-operators.make >> $@
     131        @+make TIME_FORMAT='%e' PRINT_FORMAT='' compile-typeof.make >> $@
     132        @$(srcdir)/fixcsv.sh $@
    182133
    183134ctxswitch.csv:
    184         echo "building $@"
    185         echo "generator,coroutine,thread" > $@
    186         +make ctxswitch-cfa_generator.runquiet >> $@ && echo -n ',' >> $@
    187         +make ctxswitch-cfa_coroutine.runquiet >> $@ && echo -n ',' >> $@
    188         +make ctxswitch-cfa_thread.runquiet >> $@
    189         $(srcdir)/fixcsv.sh $@
     135        @echo "generator,coroutine,thread" > $@
     136        @+make ctxswitch-cfa_generator.runquiet >> $@ && echo -n ',' >> $@
     137        @+make ctxswitch-cfa_coroutine.runquiet >> $@ && echo -n ',' >> $@
     138        @+make ctxswitch-cfa_thread.runquiet >> $@
     139        @$(srcdir)/fixcsv.sh $@
    190140
    191141mutex.csv:
    192         echo "building $@"
    193         echo "1-monitor,2-monitor" > $@
    194         +make mutex-cfa1.runquiet >> $@ && echo -n ',' >> $@
    195         +make mutex-cfa2.runquiet >> $@
    196         $(srcdir)/fixcsv.sh $@
    197 
    198 scheduling.csv:
    199         echo "building $@"
    200         echo "schedint-1,schedint-2,schedext-1,schedext-2" > $@
    201         +make schedint-cfa1.runquiet >> $@ && echo -n ',' >> $@
    202         +make schedint-cfa2.runquiet >> $@ && echo -n ',' >> $@
    203         +make schedext-cfa1.runquiet >> $@ && echo -n ',' >> $@
    204         +make schedext-cfa2.runquiet >> $@
    205         $(srcdir)/fixcsv.sh $@
     142        @echo "1-monitor,2-monitor" > $@
     143        @+make mutex-cfa1.runquiet >> $@ && echo -n ',' >> $@
     144        @+make mutex-cfa2.runquiet >> $@
     145        @$(srcdir)/fixcsv.sh $@
     146
     147signal.csv:
     148        @echo "signal-1,signal-2,waitfor-1,waitfor-2" > $@
     149        @+make signal-cfa1.runquiet >> $@ && echo -n ',' >> $@
     150        @+make signal-cfa2.runquiet >> $@ && echo -n ',' >> $@
     151        @+make waitfor-cfa1.runquiet >> $@ && echo -n ',' >> $@
     152        @+make waitfor-cfa2.runquiet >> $@
     153        @$(srcdir)/fixcsv.sh $@
    206154
    207155%.diff.csv: %.csv
    208         test -e $(srcdir)/baselines/$(arch)/$< || (echo "Error : Missing baseline for ${<}" && false)
    209         $(srcdir)/baselines/calc.py $(srcdir)/baselines/$(arch)/$(<) $(<) > $@
    210 
    211 ## =========================================================================================================
    212 
    213 BASIC_DEPEND  =                                 \
    214         basic-loop.run                          \
    215         basic-function.run                      \
    216         basic-fetch_add.run                     \
    217         basic-ttst_lock.run                     \
    218         basic-tls-fetch_add.run
    219 
    220 basic-loop$(EXEEXT):
    221         $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/loop.c
    222 
    223 basic-function$(EXEEXT):
    224         $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/function.c
    225 
    226 basic-fetch_add$(EXEEXT):
    227         $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/fetch_add.c
    228 
    229 basic-ttst_lock$(EXEEXT):
    230         $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/ttst_lock.c
    231 
    232 basic-tls-fetch_add$(EXEEXT):
    233         $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/tls_fetch_add.c
    234 
    235 basic$(EXEEXT): $(BASIC_DEPEND)
    236 
    237 ## =========================================================================================================
    238 
    239 CTXSWITCH_DEPEND  =                     \
     156        @test -e $(srcdir)/baselines/$(arch)/$< || (echo "Error : Missing baseline for ${<}" && false)
     157        @$(srcdir)/baselines/calc.py $(srcdir)/baselines/$(arch)/$(<) $(<) > $@
     158
     159
     160## =========================================================================================================
     161loop$(EXEEXT):
     162        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=5000000000 $(srcdir)/loop.c
     163
     164function$(EXEEXT):
     165        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=5000000000 $(srcdir)/function.c
     166
     167fetch_add$(EXEEXT):
     168        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/fetch_add.c
     169
     170ttst_lock$(EXEEXT):
     171        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/ttst_lock.c
     172
     173tls-fetch_add$(EXEEXT):
     174        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/tls-fetch_add.c
     175
     176## =========================================================================================================
     177CTXSWITCH_DEPEND  =                 \
     178        loop.run                                \
     179        function.run                    \
     180        fetch_add.run                   \
     181        ttst_lock.run                   \
     182        tls-fetch_add.run                       \
     183        ctxswitch-pthread.run           \
    240184        ctxswitch-cfa_generator.run     \
    241185        ctxswitch-cfa_coroutine.run     \
    … …  
    244188        ctxswitch-upp_coroutine.run     \
    245189        ctxswitch-upp_thread.run        \
    246         ctxswitch-python_coroutine.run  \
    247         ctxswitch-nodejs_coroutine.run  \
    248         ctxswitch-nodejs_await.run      \
    249         ctxswitch-goroutine_thread.run  \
    250         ctxswitch-rust_thread.run       \
    251         ctxswitch-nodejs_coroutine.run  \
    252         ctxswitch-java_thread.run       \
    253         ctxswitch-pthread.run
     190        ctxswitch-goroutine.run         \
     191        ctxswitch-java_thread.run
     192
    254193
    255194if WITH_LIBFIBRE
    256 CTXSWITCH_DEPEND  +=                    \
    257         ctxswitch-kos_fibre.run         \
     195CTXSWITCH_DEPEND  +=           \
     196        ctxswitch-kos_fibre.run  \
    258197        ctxswitch-kos_fibre2.run
     198
    259199
    260200ctxswitch-kos_fibre$(EXEEXT):
    … …  
    267207ctxswitch$(EXEEXT): $(CTXSWITCH_DEPEND)
    268208
     209ctxswitch-pthread$(EXEEXT):
     210        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=50000000 $(srcdir)/ctxswitch/pthreads.c
     211
    269212ctxswitch-cfa_generator$(EXEEXT):
    270         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_gen.cfa
     213        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_gen.cfa
    271214
    272215ctxswitch-cfa_coroutine$(EXEEXT):
    273         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_cor.cfa
     216        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_cor.cfa
    274217
    275218ctxswitch-cfa_thread$(EXEEXT):
    276         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_thrd.cfa
     219        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd.cfa
    277220
    278221ctxswitch-cfa_thread2$(EXEEXT):
    279         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_thrd2.cfa
     222        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd2.cfa
    280223
    281224ctxswitch-upp_coroutine$(EXEEXT):
    282         $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/ctxswitch/upp_cor.cc
     225        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_cor.cc
    283226
    284227ctxswitch-upp_thread$(EXEEXT):
    285         $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/ctxswitch/upp_thrd.cc
    286 
    287 ctxswitch-python_coroutine$(EXEEXT):
    288         $(BENCH_V_PY)echo "#!/bin/sh" > a.out
    289         echo "python3.7 $(srcdir)/ctxswitch/python_cor.py" >> a.out
    290         chmod a+x a.out
    291 
    292 ctxswitch-nodejs_coroutine$(EXEEXT):
    293         $(BENCH_V_NODEJS)echo "#!/bin/sh" > a.out
    294         echo "nodejs $(srcdir)/ctxswitch/node_cor.js" >> a.out
    295         chmod a+x a.out
    296 
    297 ctxswitch-nodejs_await$(EXEEXT):
    298         $(BENCH_V_NODEJS)echo "#!/bin/sh" > a.out
    299         echo "nodejs $(srcdir)/ctxswitch/node_await.js" >> a.out
    300         chmod a+x a.out
    301 
    302 ctxswitch-goroutine_thread$(EXEEXT):
     228        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_thrd.cc
     229
     230ctxswitch-goroutine$(EXEEXT):
    303231        $(BENCH_V_GOC)go build -o a.out $(srcdir)/ctxswitch/goroutine.go
    304 
    305 ctxswitch-rust_thread$(EXEEXT):
    306         $(BENCH_V_RUSTC)rustc -C opt-level=3 -o a.out $(srcdir)/ctxswitch/rust_thrd.rs
    307232
    308233ctxswitch-java_thread$(EXEEXT):
    309234        $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/ctxswitch/JavaThread.java
    310         echo "#!/bin/sh" > a.out
    311         echo "java JavaThread" >> a.out
    312         chmod a+x a.out
    313 
    314 ctxswitch-pthread$(EXEEXT):
    315         $(BENCH_V_CC)$(COMPILE) $(srcdir)/ctxswitch/pthreads.c
    316 
    317 ## =========================================================================================================
    318 
    319 mutex$(EXEEXT) :                \
     235        @echo "#!/bin/sh" > a.out
     236        @echo "java JavaThread" >> a.out
     237        @chmod a+x a.out
     238
     239## =========================================================================================================
     240mutex$(EXEEXT) :\
     241        loop.run                        \
     242        function.run            \
     243        fetch_add.run           \
     244        mutex-pthread_lock.run  \
     245        mutex-upp.run           \
    320246        mutex-cfa1.run          \
    321247        mutex-cfa2.run          \
    322248        mutex-cfa4.run          \
    323         mutex-upp.run           \
    324         mutex-go.run            \
    325         mutex-rust.run          \
    326         mutex-java.run          \
    327         mutex-pthread.run
    328 
    329 mutex-pthread$(EXEEXT):
    330         $(BENCH_V_CC)$(COMPILE) $(srcdir)/mutex/pthreads.c
     249        mutex-java_thread.run
     250
     251mutex-pthread_lock$(EXEEXT):
     252        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=50000000 $(srcdir)/mutex/pthreads.c
     253
     254mutex-upp$(EXEEXT):
     255        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/mutex/upp.cc
    331256
    332257mutex-cfa1$(EXEEXT):
    333         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutex/cfa1.cfa
     258        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa1.cfa
    334259
    335260mutex-cfa2$(EXEEXT):
    336         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutex/cfa2.cfa
     261        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa2.cfa
    337262
    338263mutex-cfa4$(EXEEXT):
    339         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutex/cfa4.cfa
    340 
    341 mutex-upp$(EXEEXT):
    342         $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/mutex/upp.cc
    343 
    344 mutex-go$(EXEEXT):
    345         $(BENCH_V_GOC)go build -o a.out $(srcdir)/mutex/goroutine.go
    346 
    347 mutex-rust$(EXEEXT):
    348         $(BENCH_V_RUSTC)rustc -C opt-level=3 -o a.out $(srcdir)/mutex/rust.rs
    349 
    350 mutex-java$(EXEEXT):
     264        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa4.cfa
     265
     266mutex-java_thread$(EXEEXT):
    351267        $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/mutex/JavaThread.java
    352         echo "#!/bin/sh" > a.out
    353         echo "java JavaThread" >> a.out
    354         chmod a+x a.out
    355 
    356 ## =========================================================================================================
    357 
    358 schedint$(EXEEXT) :             \
    359         schedint-cfa1.run       \
    360         schedint-cfa2.run       \
    361         schedint-cfa4.run       \
    362         schedint-upp.run        \
    363         schedint-rust.run       \
    364         schedint-java.run       \
    365         schedint-pthread.run
    366 
    367 schedint-cfa1$(EXEEXT):
    368         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedint/cfa1.cfa
    369 
    370 schedint-cfa2$(EXEEXT):
    371         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedint/cfa2.cfa
    372 
    373 schedint-cfa4$(EXEEXT):
    374         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedint/cfa4.cfa
    375 
    376 schedint-upp$(EXEEXT):
    377         $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/schedint/upp.cc
    378 
    379 schedint-rust$(EXEEXT):
    380         $(BENCH_V_RUSTC)rustc -C opt-level=3 -o a.out $(srcdir)/schedint/rust.rs
    381 
    382 schedint-java$(EXEEXT):
     268        @echo "#!/bin/sh" > a.out
     269        @echo "java JavaThread" >> a.out
     270        @chmod a+x a.out
     271
     272## =========================================================================================================
     273signal$(EXEEXT) :\
     274        signal-pthread_cond.run \
     275        signal-upp.run          \
     276        signal-cfa1.run         \
     277        signal-cfa2.run         \
     278        signal-cfa4.run         \
     279        signal-java_thread.run
     280
     281signal-pthread_cond$(EXEEXT):
     282        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=500000  $(srcdir)/schedint/pthreads.c
     283
     284signal-upp$(EXEEXT):
     285        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=5000000 $(srcdir)/schedint/upp.cc
     286
     287signal-cfa1$(EXEEXT):
     288        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa1.cfa
     289
     290signal-cfa2$(EXEEXT):
     291        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa2.cfa
     292
     293signal-cfa4$(EXEEXT):
     294        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa4.cfa
     295
     296signal-java_thread$(EXEEXT):
    383297        $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/schedint/JavaThread.java
    384         echo "#!/bin/sh" > a.out
    385         echo "java JavaThread" >> a.out
    386         chmod a+x a.out
    387 
    388 schedint-pthread$(EXEEXT):
    389         $(BENCH_V_CC)$(COMPILE) $(srcdir)/schedint/pthreads.c
    390 
    391 ## =========================================================================================================
    392 
    393 schedext$(EXEEXT) :             \
    394         schedext-cfa1.run       \
    395         schedext-cfa2.run       \
    396         schedext-cfa4.run       \
    397         schedext-upp.run        \
    398         schedext-goroutine.run
    399 
    400 schedext-cfa1$(EXEEXT):
    401         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedext/cfa1.cfa
    402 
    403 schedext-cfa2$(EXEEXT):
    404         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedext/cfa2.cfa
    405 
    406 schedext-cfa4$(EXEEXT):
    407         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedext/cfa4.cfa
    408 
    409 schedext-upp$(EXEEXT):
    410         $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/schedext/upp.cc
    411 
    412 schedext-goroutine$(EXEEXT):
    413         $(BENCH_V_GOC)go build -o a.out $(srcdir)/schedext/goroutine.go
    414 
    415 
    416 ## =========================================================================================================
    417 
    418 creation$(EXEEXT) :                             \
    419         creation-cfa_generator.run              \
     298        @echo "#!/bin/sh" > a.out
     299        @echo "java JavaThread" >> a.out
     300        @chmod a+x a.out
     301
     302
     303## =========================================================================================================
     304waitfor$(EXEEXT) :\
     305        waitfor-upp.run         \
     306        waitfor-cfa1.run                \
     307        waitfor-cfa2.run                \
     308        waitfor-cfa4.run
     309
     310waitfor-upp$(EXEEXT):
     311        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=5000000 $(srcdir)/schedext/upp.cc
     312
     313waitfor-cfa1$(EXEEXT):
     314        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa1.cfa
     315
     316waitfor-cfa2$(EXEEXT):
     317        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa2.cfa
     318
     319waitfor-cfa4$(EXEEXT):
     320        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa4.cfa
     321
     322## =========================================================================================================
     323creation$(EXEEXT) :\
     324        creation-pthread.run                    \
    420325        creation-cfa_coroutine.run              \
    421326        creation-cfa_coroutine_eager.run        \
    … …  
    423328        creation-upp_coroutine.run              \
    424329        creation-upp_thread.run                 \
    425         creation-python_coroutine.run           \
    426         creation-nodejs_coroutine.run           \
    427         creation-goroutine_thread.run           \
    428         creation-rust_thread.run                \
    429         creation-java_thread.run                \
    430         creation-pthread.run
    431 
    432 creation-cfa_generator$(EXEEXT):
    433         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_gen.cfa
     330        creation-goroutine.run                  \
     331        creation-java_thread.run
    434332
    435333creation-cfa_coroutine$(EXEEXT):
    436         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_cor.cfa
     334        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_cor.cfa
    437335
    438336creation-cfa_coroutine_eager$(EXEEXT):
    439         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_cor.cfa  -DEAGER
     337        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_cor.cfa  -DEAGER
    440338
    441339creation-cfa_thread$(EXEEXT):
    442         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_thrd.cfa
     340        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_thrd.cfa
    443341
    444342creation-upp_coroutine$(EXEEXT):
    445         $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/creation/upp_cor.cc
     343        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/creation/upp_cor.cc
    446344
    447345creation-upp_thread$(EXEEXT):
    448         $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/creation/upp_thrd.cc
    449 
    450 creation-python_coroutine$(EXEEXT):
    451         $(BENCH_V_PY)echo "#!/bin/sh" > a.out
    452         echo "python3.7 $(srcdir)/creation/python_cor.py" >> a.out
    453         chmod a+x a.out
    454 
    455 creation-nodejs_coroutine$(EXEEXT):
    456         $(BENCH_V_NODEJS)echo "#!/bin/sh" > a.out
    457         echo "nodejs $(srcdir)/creation/node_cor.js" >> a.out
    458         chmod a+x a.out
    459 
    460 creation-goroutine_thread$(EXEEXT):
     346        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/creation/upp_thrd.cc
     347
     348creation-pthread$(EXEEXT):
     349        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=250000   $(srcdir)/creation/pthreads.c
     350
     351creation-goroutine$(EXEEXT):
    461352        $(BENCH_V_GOC)go build -o a.out $(srcdir)/creation/goroutine.go
    462 
    463 creation-rust_thread$(EXEEXT):
    464         $(BENCH_V_RUSTC)rustc -C opt-level=3 -o a.out $(srcdir)/creation/rust_thrd.rs
    465353
    466354creation-java_thread$(EXEEXT):
    467355        $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/creation/JavaThread.java
    468         echo "#!/bin/sh" > a.out
    469         echo "java JavaThread" >> a.out
    470         chmod a+x a.out
    471 
    472 creation-pthread$(EXEEXT):
    473         $(BENCH_V_CC)$(COMPILE) $(srcdir)/creation/pthreads.c
    474 
    475 ## =========================================================================================================
    476 
    477 compile$(EXEEXT) :              \
     356        @echo "#!/bin/sh" > a.out
     357        @echo "java JavaThread" >> a.out
     358        @chmod a+x a.out
     359
     360## =========================================================================================================
     361
     362compile$(EXEEXT) :\
    478363        compile-array.make      \
    479364        compile-attributes.make \
    … …  
    485370        compile-typeof.make
    486371
     372
    487373testdir = $(top_srcdir)/tests
    488374
    489375compile-array$(EXEEXT):
    490         $(CFACOMPILE) -fsyntax-only -w $(testdir)/array.cfa
     376        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/array.cfa
    491377
    492378compile-attributes$(EXEEXT):
    493         $(CFACOMPILE) -fsyntax-only -w $(testdir)/attributes.cfa
     379        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/attributes.cfa
    494380
    495381compile-empty$(EXEEXT):
    496         $(CFACOMPILE) -fsyntax-only -w $(srcdir)/compile/empty.cfa
     382        @$(CFACOMPILE) -fsyntax-only -w $(srcdir)/compile/empty.cfa
    497383
    498384compile-expression$(EXEEXT):
    499         $(CFACOMPILE) -fsyntax-only -w $(testdir)/expression.cfa
     385        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/expression.cfa
    500386
    501387compile-io$(EXEEXT):
    502         $(CFACOMPILE) -fsyntax-only -w $(testdir)/io1.cfa
     388        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/io1.cfa
    503389
    504390compile-monitor$(EXEEXT):
    505         $(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/monitor.cfa
     391        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/monitor.cfa
    506392
    507393compile-operators$(EXEEXT):
    508         $(CFACOMPILE) -fsyntax-only -w $(testdir)/operators.cfa
     394        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/operators.cfa
    509395
    510396compile-thread$(EXEEXT):
    511         $(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/thread.cfa
     397        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/thread.cfa
    512398
    513399compile-typeof$(EXEEXT):
    514         $(CFACOMPILE) -fsyntax-only -w $(testdir)/typeof.cfa
     400        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/typeof.cfa

  • benchmark/Makefile.in

    rb7d6a36 rdca5802  
    9393EXTRA_PROGRAMS = dummy$(EXEEXT)
    9494@WITH_LIBFIBRE_TRUE@am__append_1 = \
    95 @WITH_LIBFIBRE_TRUE@    ctxswitch-kos_fibre.run         \
     95@WITH_LIBFIBRE_TRUE@    ctxswitch-kos_fibre.run  \
    9696@WITH_LIBFIBRE_TRUE@    ctxswitch-kos_fibre2.run
    9797
    … …  
    358358am__v_CFA_0 = @echo "  CFA     " $@;
    359359am__v_CFA_1 =
     360AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
     361am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
     362am__v_JAVAC_0 = @echo "  JAVAC   " $@;
     363am__v_JAVAC_1 =
     364AM_V_GOC = $(am__v_GOC_@AM_V@)
     365am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
     366am__v_GOC_0 = @echo "  GOC     " $@;
     367am__v_GOC_1 =
    360368UPPCC = u++
    361369UPPCOMPILE = $(UPPCC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_UPPFLAGS) $(UPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_CFLAGS) $(CFLAGS)
    … …  
    364372am__v_UPP_0 = @echo "  UPP     " $@;
    365373am__v_UPP_1 =
    366 AM_V_GOC = $(am__v_GOC_@AM_V@)
    367 am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
    368 am__v_GOC_0 = @echo "  GOC     " $@;
    369 am__v_GOC_1 =
    370 AM_V_PY = $(am__v_PY_@AM_V@)
    371 am__v_PY_ = $(am__v_PY_@AM_DEFAULT_V@)
    372 am__v_PY_0 = @echo "  PYTHON  " $@;
    373 am__v_PY_1 =
    374 AM_V_RUST = $(am__v_RUST_@AM_V@)
    375 am__v_RUST_ = $(am__v_RUST_@AM_DEFAULT_V@)
    376 am__v_RUST_0 = @echo "  RUST    " $@;
    377 am__v_RUST_1 =
    378 AM_V_NODEJS = $(am__v_NODEJS_@AM_V@)
    379 am__v_NODEJS_ = $(am__v_NODEJS_@AM_DEFAULT_V@)
    380 am__v_NODEJS_0 = @echo "  NODEJS  " $@;
    381 am__v_NODEJS_1 =
    382 AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
    383 am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
    384 am__v_JAVAC_0 = @echo "  JAVAC   " $@;
    385 am__v_JAVAC_1 =
    386374
    387375# applies to both programs
    … …  
    392380BENCH_V_CFA = $(__bench_v_CFA_$(__quiet))
    393381BENCH_V_CXX = $(__bench_v_CXX_$(__quiet))
     382BENCH_V_GOC = $(__bench_v_GOC_$(__quiet))
     383BENCH_V_JAVAC = $(__bench_v_JAVAC_$(__quiet))
    394384BENCH_V_UPP = $(__bench_v_UPP_$(__quiet))
    395 BENCH_V_GOC = $(__bench_v_GOC_$(__quiet))
    396 BENCH_V_PY = $(__bench_v_PY_$(__quiet))
    397 BENCH_V_RUSTC = $(__bench_v_RUSTC_$(__quiet))
    398 BENCH_V_NODEJS = $(__bench_v_NODEJS_$(__quiet))
    399 BENCH_V_JAVAC = $(__bench_v_JAVAC_$(__quiet))
    400385__quiet = verbose
    401386__bench_v_CC_quiet = @
    402387__bench_v_CFA_quiet = @
    403388__bench_v_CXX_quiet = @
     389__bench_v_GOC_quiet = @
     390__bench_v_JAVAC_quiet = @
    404391__bench_v_UPP_quiet = @
    405 __bench_v_GOC_quiet = @
    406 __bench_v_RUSTC_quiet = @
    407 __bench_v_JAVAC_quiet = @
    408392__bench_v_CC_verbose = $(AM_V_CC)
    409393__bench_v_CFA_verbose = $(AM_V_CFA)
    410394__bench_v_CXX_verbose = $(AM_V_CXX)
     395__bench_v_GOC_verbose = $(AM_V_GOC)
     396__bench_v_JAVAC_verbose = $(AM_V_JAVAC)
    411397__bench_v_UPP_verbose = $(AM_V_UPP)
    412 __bench_v_GOC_verbose = $(AM_V_GOC)
    413 __bench_v_PY_verbose = $(AM_V_PY)
    414 __bench_v_RUSTC_verbose = $(AM_V_RUST)
    415 __bench_v_NODEJS_verbose = $(AM_V_NODEJS)
    416 __bench_v_JAVAC_verbose = $(AM_V_JAVAC)
    417398TOOLSDIR = ${abs_top_builddir}/tools/
    418399REPEAT = ${abs_top_builddir}/tools/repeat
    419400STATS = ${abs_top_srcdir}/tools/stat.py
    420401# NEED AT LEAST 4 DATA VALUES FOR BENCHMARKS BECAUSE THE MAX AND MIN VALUES ARE REMOVED
    421 repeats = 13 # 31 for benchmarks
     402repeats = 5 # 31 for benchmarks
    422403arch = x64
    423404skipcompile = no
    … …  
    425406PRINT_FORMAT = %20s: #Comments needed for spacing
    426407dummy_SOURCES = dummyC.c dummyCXX.cpp
    427 basic_loop_DURATION = 15000000000
    428 basic_function_DURATION = 10000000000
    429 basic_tls_fetch_add_DURATION = 10000000000
    430 basic_DURATION = 250000000
    431 ctxswitch_pthread_DURATION = 25000000
    432 ctxswitch_rust_thread_DURATION = $(ctxswitch_pthread_DURATION)
    433 ctxswitch_cfa_generator_DURATION = 5000000000
    434 ctxswitch_nodejs_await_DURATION = 5000000
    435 ctxswitch_DURATION = 100000000
    436 
    437 #mutex_java_DURATION = 10000000
    438 mutex_DURATION = 50000000
    439 schedint_pthread_DURATION = 1000000
    440 schedint_java_DURATION = $(schedint_pthread_DURATION)
    441 schedint_rust_DURATION = $(schedint_pthread_DURATION)
    442 schedint_DURATION = 10000000
    443 schedext_DURATION = 10000000
    444 creation_pthread_DURATION = 250000
    445 creation_rust_thread_DURATION = ${creation_pthread_DURATION}
    446 creation_java_thread_DURATION = ${creation_pthread_DURATION}
    447 creation_cfa_coroutine_DURATION = 100000000
    448 creation_cfa_coroutine_eager_DURATION = 10000000
    449 creation_upp_coroutine_DURATION = ${creation_cfa_coroutine_eager_DURATION}
    450 creation_cfa_thread_DURATION = 10000000
    451 creation_upp_thread_DURATION = ${creation_cfa_thread_DURATION}
    452 creation_DURATION = 10000000
    453408FIX_NEW_LINES = cat $@ | tr "\n" "\t" | sed -r 's/\t,/,/' | tr "\t" "\n" > $@
    454 BASIC_DEPEND = \
    455         basic-loop.run                          \
    456         basic-function.run                      \
    457         basic-fetch_add.run                     \
    458         basic-ttst_lock.run                     \
    459         basic-tls-fetch_add.run
    460 
    461 CTXSWITCH_DEPEND = ctxswitch-cfa_generator.run \
    462         ctxswitch-cfa_coroutine.run ctxswitch-cfa_thread.run \
    463         ctxswitch-cfa_thread2.run ctxswitch-upp_coroutine.run \
    464         ctxswitch-upp_thread.run ctxswitch-python_coroutine.run \
    465         ctxswitch-nodejs_coroutine.run ctxswitch-nodejs_await.run \
    466         ctxswitch-goroutine_thread.run ctxswitch-rust_thread.run \
    467         ctxswitch-nodejs_coroutine.run ctxswitch-java_thread.run \
    468         ctxswitch-pthread.run $(am__append_1)
     409CTXSWITCH_DEPEND = loop.run function.run fetch_add.run ttst_lock.run \
     410        tls-fetch_add.run ctxswitch-pthread.run \
     411        ctxswitch-cfa_generator.run ctxswitch-cfa_coroutine.run \
     412        ctxswitch-cfa_thread.run ctxswitch-cfa_thread2.run \
     413        ctxswitch-upp_coroutine.run ctxswitch-upp_thread.run \
     414        ctxswitch-goroutine.run ctxswitch-java_thread.run \
     415        $(am__append_1)
    469416testdir = $(top_srcdir)/tests
    470417all: all-am
    … …  
    785732
    786733dummyC.c:
    787         echo "int main() { return 0; }" > ${@}
     734        @echo "int main() { return 0; }" > ${@}
    788735
    789736dummyCXX.cpp:
    790         echo "int main() { return 0; }" > ${@}
    791 
    792 .SILENT:                # do not print recipe
     737        @echo "int main() { return 0; }" > ${@}
     738
    793739.NOTPARALLEL:
    794 .PHONY: jenkins cleancsv
    795 
    796 all : basic$(EXEEXT) ctxswitch$(EXEEXT) mutex$(EXEEXT) schedint$(EXEEXT) schedext$(EXEEXT) creation$(EXEEXT)
     740.PHONY: compile.csv ctxswitch.csv mutex.csv signal.csv
     741
     742all : ctxswitch$(EXEEXT) mutex$(EXEEXT) signal$(EXEEXT) waitfor$(EXEEXT) creation$(EXEEXT)
    797743
    798744%.run : %$(EXEEXT) ${REPEAT}
    799         rm -f .result.log
    800         echo "------------------------------------------------------"
    801         echo $<
    802         ${REPEAT} ${repeats} -- ./a.out\
    803                 $(if ${$(subst -,_,$(basename $@))_DURATION},\
    804                         ${$(subst -,_,$(basename $@))_DURATION},\
    805                         ${$(firstword $(subst -, ,$(basename $@)))_DURATION}) | tee -a .result.log
    806         ${STATS} .result.log
    807         echo "------------------------------------------------------"
    808         rm -f a.out .result.log *.class
    809 
    810 #       ${REPEAT} ${repeats} -- /usr/bin/time -f "%Uu %Ss %Er %Mkb" ./a.out
     745        @rm -f .result.log
     746        @echo "------------------------------------------------------"
     747        @echo $<
     748        @${REPEAT} ${repeats} ./a.out | tee -a .result.log
     749        @${STATS} .result.log
     750        @echo "------------------------------------------------------"
     751        @rm -f a.out .result.log *.class
    811752
    812753%.runquiet :
    813         +make $(basename $@) CFLAGS="-w" __quiet=quiet
    814         taskset -c 1 ./a.out
    815         rm -f a.out
     754        @+make $(basename $@) CFLAGS="-w" __quiet=quiet
     755        @taskset -c 1 ./a.out
     756        @rm -f a.out
    816757
    817758%.make :
    818         printf "${PRINT_FORMAT}" $(basename $(subst compile-,,$@))
    819         +/usr/bin/time -f ${TIME_FORMAT} make $(basename $@) 2>&1
     759        @printf "${PRINT_FORMAT}" $(basename $(subst compile-,,$@))
     760        @+/usr/bin/time -f ${TIME_FORMAT} make $(basename $@) 2>&1
    820761
    821762${REPEAT} :
    822         +make -C ${abs_top_builddir}/tools repeat
    823 
    824 cleancsv:
    825         rm -f compile.csv basic.csv ctxswitch.csv mutex.csv scheduling.csv
    826 
    827 jenkins$(EXEEXT): cleancsv
     763        @+make -C ${abs_top_builddir}/tools repeat
     764
     765jenkins$(EXEEXT):
    828766@DOifskipcompile@
    829         +make compile.csv
    830         -+make compile.diff.csv
     767        @+make compile.csv
     768        @-+make compile.diff.csv
    831769@DOendif@
    832         +make ctxswitch.csv
    833         -+make ctxswitch.diff.csv
    834         +make mutex.csv
    835         -+make mutex.diff.csv
    836         +make scheduling.csv
    837         -+make scheduling.diff.csv
     770        @+make ctxswitch.csv
     771        @-+make ctxswitch.diff.csv
     772        @+make mutex.csv
     773        @-+make mutex.diff.csv
     774        @+make signal.csv
     775        @-+make signal.diff.csv
    838776@DOifskipcompile@
    839777        cat compile.csv
    … …  
    844782        cat mutex.csv
    845783        -cat mutex.diff.csv
    846         cat scheduling.csv
    847         -cat scheduling.diff.csv
     784        cat signal.csv
     785        -cat signal.diff.csv
    848786
    849787compile.csv:
    850         echo "building $@"
    851         echo "array,attributes,empty,expression,io,monitor,operators,typeof" > $@
    852         +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-array.make >> $@
    853         +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-attributes.make >> $@
    854         +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-empty.make >> $@
    855         +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-expression.make >> $@
    856         +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-io.make >> $@
    857         +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-monitor.make >> $@
    858         +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-operators.make >> $@
    859         +make TIME_FORMAT='%e' PRINT_FORMAT='' compile-typeof.make >> $@
    860         $(srcdir)/fixcsv.sh $@
     788        @echo "array,attributes,empty,expression,io,monitor,operators,typeof" > $@
     789        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-array.make >> $@
     790        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-attributes.make >> $@
     791        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-empty.make >> $@
     792        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-expression.make >> $@
     793        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-io.make >> $@
     794        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-monitor.make >> $@
     795        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-operators.make >> $@
     796        @+make TIME_FORMAT='%e' PRINT_FORMAT='' compile-typeof.make >> $@
     797        @$(srcdir)/fixcsv.sh $@
    861798
    862799ctxswitch.csv:
    863         echo "building $@"
    864         echo "generator,coroutine,thread" > $@
    865         +make ctxswitch-cfa_generator.runquiet >> $@ && echo -n ',' >> $@
    866         +make ctxswitch-cfa_coroutine.runquiet >> $@ && echo -n ',' >> $@
    867         +make ctxswitch-cfa_thread.runquiet >> $@
    868         $(srcdir)/fixcsv.sh $@
     800        @echo "generator,coroutine,thread" > $@
     801        @+make ctxswitch-cfa_generator.runquiet >> $@ && echo -n ',' >> $@
     802        @+make ctxswitch-cfa_coroutine.runquiet >> $@ && echo -n ',' >> $@
     803        @+make ctxswitch-cfa_thread.runquiet >> $@
     804        @$(srcdir)/fixcsv.sh $@
    869805
    870806mutex.csv:
    871         echo "building $@"
    872         echo "1-monitor,2-monitor" > $@
    873         +make mutex-cfa1.runquiet >> $@ && echo -n ',' >> $@
    874         +make mutex-cfa2.runquiet >> $@
    875         $(srcdir)/fixcsv.sh $@
    876 
    877 scheduling.csv:
    878         echo "building $@"
    879         echo "schedint-1,schedint-2,schedext-1,schedext-2" > $@
    880         +make schedint-cfa1.runquiet >> $@ && echo -n ',' >> $@
    881         +make schedint-cfa2.runquiet >> $@ && echo -n ',' >> $@
    882         +make schedext-cfa1.runquiet >> $@ && echo -n ',' >> $@
    883         +make schedext-cfa2.runquiet >> $@
    884         $(srcdir)/fixcsv.sh $@
     807        @echo "1-monitor,2-monitor" > $@
     808        @+make mutex-cfa1.runquiet >> $@ && echo -n ',' >> $@
     809        @+make mutex-cfa2.runquiet >> $@
     810        @$(srcdir)/fixcsv.sh $@
     811
     812signal.csv:
     813        @echo "signal-1,signal-2,waitfor-1,waitfor-2" > $@
     814        @+make signal-cfa1.runquiet >> $@ && echo -n ',' >> $@
     815        @+make signal-cfa2.runquiet >> $@ && echo -n ',' >> $@
     816        @+make waitfor-cfa1.runquiet >> $@ && echo -n ',' >> $@
     817        @+make waitfor-cfa2.runquiet >> $@
     818        @$(srcdir)/fixcsv.sh $@
    885819
    886820%.diff.csv: %.csv
    887         test -e $(srcdir)/baselines/$(arch)/$< || (echo "Error : Missing baseline for ${<}" && false)
    888         $(srcdir)/baselines/calc.py $(srcdir)/baselines/$(arch)/$(<) $(<) > $@
    889 
    890 basic-loop$(EXEEXT):
    891         $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/loop.c
    892 
    893 basic-function$(EXEEXT):
    894         $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/function.c
    895 
    896 basic-fetch_add$(EXEEXT):
    897         $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/fetch_add.c
    898 
    899 basic-ttst_lock$(EXEEXT):
    900         $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/ttst_lock.c
    901 
    902 basic-tls-fetch_add$(EXEEXT):
    903         $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/tls_fetch_add.c
    904 
    905 basic$(EXEEXT): $(BASIC_DEPEND)
     821        @test -e $(srcdir)/baselines/$(arch)/$< || (echo "Error : Missing baseline for ${<}" && false)
     822        @$(srcdir)/baselines/calc.py $(srcdir)/baselines/$(arch)/$(<) $(<) > $@
     823
     824loop$(EXEEXT):
     825        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=5000000000 $(srcdir)/loop.c
     826
     827function$(EXEEXT):
     828        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=5000000000 $(srcdir)/function.c
     829
     830fetch_add$(EXEEXT):
     831        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/fetch_add.c
     832
     833ttst_lock$(EXEEXT):
     834        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/ttst_lock.c
     835
     836tls-fetch_add$(EXEEXT):
     837        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/tls-fetch_add.c
    906838
    907839@WITH_LIBFIBRE_TRUE@ctxswitch-kos_fibre$(EXEEXT):
    … …  
    913845ctxswitch$(EXEEXT): $(CTXSWITCH_DEPEND)
    914846
     847ctxswitch-pthread$(EXEEXT):
     848        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=50000000 $(srcdir)/ctxswitch/pthreads.c
     849
    915850ctxswitch-cfa_generator$(EXEEXT):
    916         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_gen.cfa
     851        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_gen.cfa
    917852
    918853ctxswitch-cfa_coroutine$(EXEEXT):
    919         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_cor.cfa
     854        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_cor.cfa
    920855
    921856ctxswitch-cfa_thread$(EXEEXT):
    922         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_thrd.cfa
     857        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd.cfa
    923858
    924859ctxswitch-cfa_thread2$(EXEEXT):
    925         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_thrd2.cfa
     860        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd2.cfa
    926861
    927862ctxswitch-upp_coroutine$(EXEEXT):
    928         $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/ctxswitch/upp_cor.cc
     863        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_cor.cc
    929864
    930865ctxswitch-upp_thread$(EXEEXT):
    931         $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/ctxswitch/upp_thrd.cc
    932 
    933 ctxswitch-python_coroutine$(EXEEXT):
    934         $(BENCH_V_PY)echo "#!/bin/sh" > a.out
    935         echo "python3.7 $(srcdir)/ctxswitch/python_cor.py" >> a.out
    936         chmod a+x a.out
    937 
    938 ctxswitch-nodejs_coroutine$(EXEEXT):
    939         $(BENCH_V_NODEJS)echo "#!/bin/sh" > a.out
    940         echo "nodejs $(srcdir)/ctxswitch/node_cor.js" >> a.out
    941         chmod a+x a.out
    942 
    943 ctxswitch-nodejs_await$(EXEEXT):
    944         $(BENCH_V_NODEJS)echo "#!/bin/sh" > a.out
    945         echo "nodejs $(srcdir)/ctxswitch/node_await.js" >> a.out
    946         chmod a+x a.out
    947 
    948 ctxswitch-goroutine_thread$(EXEEXT):
     866        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_thrd.cc
     867
     868ctxswitch-goroutine$(EXEEXT):
    949869        $(BENCH_V_GOC)go build -o a.out $(srcdir)/ctxswitch/goroutine.go
    950 
    951 ctxswitch-rust_thread$(EXEEXT):
    952         $(BENCH_V_RUSTC)rustc -C opt-level=3 -o a.out $(srcdir)/ctxswitch/rust_thrd.rs
    953870
    954871ctxswitch-java_thread$(EXEEXT):
    955872        $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/ctxswitch/JavaThread.java
    956         echo "#!/bin/sh" > a.out
    957         echo "java JavaThread" >> a.out
    958         chmod a+x a.out
    959 
    960 ctxswitch-pthread$(EXEEXT):
    961         $(BENCH_V_CC)$(COMPILE) $(srcdir)/ctxswitch/pthreads.c
    962 
    963 mutex$(EXEEXT) :                \
     873        @echo "#!/bin/sh" > a.out
     874        @echo "java JavaThread" >> a.out
     875        @chmod a+x a.out
     876
     877mutex$(EXEEXT) :\
     878        loop.run                        \
     879        function.run            \
     880        fetch_add.run           \
     881        mutex-pthread_lock.run  \
     882        mutex-upp.run           \
    964883        mutex-cfa1.run          \
    965884        mutex-cfa2.run          \
    966885        mutex-cfa4.run          \
    967         mutex-upp.run           \
    968         mutex-go.run            \
    969         mutex-rust.run          \
    970         mutex-java.run          \
    971         mutex-pthread.run
    972 
    973 mutex-pthread$(EXEEXT):
    974         $(BENCH_V_CC)$(COMPILE) $(srcdir)/mutex/pthreads.c
     886        mutex-java_thread.run
     887
     888mutex-pthread_lock$(EXEEXT):
     889        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=50000000 $(srcdir)/mutex/pthreads.c
     890
     891mutex-upp$(EXEEXT):
     892        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/mutex/upp.cc
    975893
    976894mutex-cfa1$(EXEEXT):
    977         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutex/cfa1.cfa
     895        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa1.cfa
    978896
    979897mutex-cfa2$(EXEEXT):
    980         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutex/cfa2.cfa
     898        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa2.cfa
    981899
    982900mutex-cfa4$(EXEEXT):
    983         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutex/cfa4.cfa
    984 
    985 mutex-upp$(EXEEXT):
    986         $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/mutex/upp.cc
    987 
    988 mutex-go$(EXEEXT):
    989         $(BENCH_V_GOC)go build -o a.out $(srcdir)/mutex/goroutine.go
    990 
    991 mutex-rust$(EXEEXT):
    992         $(BENCH_V_RUSTC)rustc -C opt-level=3 -o a.out $(srcdir)/mutex/rust.rs
    993 
    994 mutex-java$(EXEEXT):
     901        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa4.cfa
     902
     903mutex-java_thread$(EXEEXT):
    995904        $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/mutex/JavaThread.java
    996         echo "#!/bin/sh" > a.out
    997         echo "java JavaThread" >> a.out
    998         chmod a+x a.out
    999 
    1000 schedint$(EXEEXT) :             \
    1001         schedint-cfa1.run       \
    1002         schedint-cfa2.run       \
    1003         schedint-cfa4.run       \
    1004         schedint-upp.run        \
    1005         schedint-rust.run       \
    1006         schedint-java.run       \
    1007         schedint-pthread.run
    1008 
    1009 schedint-cfa1$(EXEEXT):
    1010         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedint/cfa1.cfa
    1011 
    1012 schedint-cfa2$(EXEEXT):
    1013         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedint/cfa2.cfa
    1014 
    1015 schedint-cfa4$(EXEEXT):
    1016         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedint/cfa4.cfa
    1017 
    1018 schedint-upp$(EXEEXT):
    1019         $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/schedint/upp.cc
    1020 
    1021 schedint-rust$(EXEEXT):
    1022         $(BENCH_V_RUSTC)rustc -C opt-level=3 -o a.out $(srcdir)/schedint/rust.rs
    1023 
    1024 schedint-java$(EXEEXT):
     905        @echo "#!/bin/sh" > a.out
     906        @echo "java JavaThread" >> a.out
     907        @chmod a+x a.out
     908
     909signal$(EXEEXT) :\
     910        signal-pthread_cond.run \
     911        signal-upp.run          \
     912        signal-cfa1.run         \
     913        signal-cfa2.run         \
     914        signal-cfa4.run         \
     915        signal-java_thread.run
     916
     917signal-pthread_cond$(EXEEXT):
     918        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=500000  $(srcdir)/schedint/pthreads.c
     919
     920signal-upp$(EXEEXT):
     921        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=5000000 $(srcdir)/schedint/upp.cc
     922
     923signal-cfa1$(EXEEXT):
     924        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa1.cfa
     925
     926signal-cfa2$(EXEEXT):
     927        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa2.cfa
     928
     929signal-cfa4$(EXEEXT):
     930        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa4.cfa
     931
     932signal-java_thread$(EXEEXT):
    1025933        $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/schedint/JavaThread.java
    1026         echo "#!/bin/sh" > a.out
    1027         echo "java JavaThread" >> a.out
    1028         chmod a+x a.out
    1029 
    1030 schedint-pthread$(EXEEXT):
    1031         $(BENCH_V_CC)$(COMPILE) $(srcdir)/schedint/pthreads.c
    1032 
    1033 schedext$(EXEEXT) :             \
    1034         schedext-cfa1.run       \
    1035         schedext-cfa2.run       \
    1036         schedext-cfa4.run       \
    1037         schedext-upp.run        \
    1038         schedext-goroutine.run
    1039 
    1040 schedext-cfa1$(EXEEXT):
    1041         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedext/cfa1.cfa
    1042 
    1043 schedext-cfa2$(EXEEXT):
    1044         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedext/cfa2.cfa
    1045 
    1046 schedext-cfa4$(EXEEXT):
    1047         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedext/cfa4.cfa
    1048 
    1049 schedext-upp$(EXEEXT):
    1050         $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/schedext/upp.cc
    1051 
    1052 schedext-goroutine$(EXEEXT):
    1053         $(BENCH_V_GOC)go build -o a.out $(srcdir)/schedext/goroutine.go
    1054 
    1055 creation$(EXEEXT) :                             \
    1056         creation-cfa_generator.run              \
     934        @echo "#!/bin/sh" > a.out
     935        @echo "java JavaThread" >> a.out
     936        @chmod a+x a.out
     937
     938waitfor$(EXEEXT) :\
     939        waitfor-upp.run         \
     940        waitfor-cfa1.run                \
     941        waitfor-cfa2.run                \
     942        waitfor-cfa4.run
     943
     944waitfor-upp$(EXEEXT):
     945        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=5000000 $(srcdir)/schedext/upp.cc
     946
     947waitfor-cfa1$(EXEEXT):
     948        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa1.cfa
     949
     950waitfor-cfa2$(EXEEXT):
     951        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa2.cfa
     952
     953waitfor-cfa4$(EXEEXT):
     954        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa4.cfa
     955
     956creation$(EXEEXT) :\
     957        creation-pthread.run                    \
    1057958        creation-cfa_coroutine.run              \
    1058959        creation-cfa_coroutine_eager.run        \
    … …  
    1060961        creation-upp_coroutine.run              \
    1061962        creation-upp_thread.run                 \
    1062         creation-python_coroutine.run           \
    1063         creation-nodejs_coroutine.run           \
    1064         creation-goroutine_thread.run           \
    1065         creation-rust_thread.run                \
    1066         creation-java_thread.run                \
    1067         creation-pthread.run
    1068 
    1069 creation-cfa_generator$(EXEEXT):
    1070         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_gen.cfa
     963        creation-goroutine.run                  \
     964        creation-java_thread.run
    1071965
    1072966creation-cfa_coroutine$(EXEEXT):
    1073         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_cor.cfa
     967        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_cor.cfa
    1074968
    1075969creation-cfa_coroutine_eager$(EXEEXT):
    1076         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_cor.cfa  -DEAGER
     970        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_cor.cfa  -DEAGER
    1077971
    1078972creation-cfa_thread$(EXEEXT):
    1079         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_thrd.cfa
     973        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_thrd.cfa
    1080974
    1081975creation-upp_coroutine$(EXEEXT):
    1082         $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/creation/upp_cor.cc
     976        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/creation/upp_cor.cc
    1083977
    1084978creation-upp_thread$(EXEEXT):
    1085         $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/creation/upp_thrd.cc
    1086 
    1087 creation-python_coroutine$(EXEEXT):
    1088         $(BENCH_V_PY)echo "#!/bin/sh" > a.out
    1089         echo "python3.7 $(srcdir)/creation/python_cor.py" >> a.out
    1090         chmod a+x a.out
    1091 
    1092 creation-nodejs_coroutine$(EXEEXT):
    1093         $(BENCH_V_NODEJS)echo "#!/bin/sh" > a.out
    1094         echo "nodejs $(srcdir)/creation/node_cor.js" >> a.out
    1095         chmod a+x a.out
    1096 
    1097 creation-goroutine_thread$(EXEEXT):
     979        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/creation/upp_thrd.cc
     980
     981creation-pthread$(EXEEXT):
     982        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=250000   $(srcdir)/creation/pthreads.c
     983
     984creation-goroutine$(EXEEXT):
    1098985        $(BENCH_V_GOC)go build -o a.out $(srcdir)/creation/goroutine.go
    1099 
    1100 creation-rust_thread$(EXEEXT):
    1101         $(BENCH_V_RUSTC)rustc -C opt-level=3 -o a.out $(srcdir)/creation/rust_thrd.rs
    1102986
    1103987creation-java_thread$(EXEEXT):
    1104988        $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/creation/JavaThread.java
    1105         echo "#!/bin/sh" > a.out
    1106         echo "java JavaThread" >> a.out
    1107         chmod a+x a.out
    1108 
    1109 creation-pthread$(EXEEXT):
    1110         $(BENCH_V_CC)$(COMPILE) $(srcdir)/creation/pthreads.c
    1111 
    1112 compile$(EXEEXT) :              \
     989        @echo "#!/bin/sh" > a.out
     990        @echo "java JavaThread" >> a.out
     991        @chmod a+x a.out
     992
     993compile$(EXEEXT) :\
    1113994        compile-array.make      \
    1114995        compile-attributes.make \
    … …  
    11211002
    11221003compile-array$(EXEEXT):
    1123         $(CFACOMPILE) -fsyntax-only -w $(testdir)/array.cfa
     1004        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/array.cfa
    11241005
    11251006compile-attributes$(EXEEXT):
    1126         $(CFACOMPILE) -fsyntax-only -w $(testdir)/attributes.cfa
     1007        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/attributes.cfa
    11271008
    11281009compile-empty$(EXEEXT):
    1129         $(CFACOMPILE) -fsyntax-only -w $(srcdir)/compile/empty.cfa
     1010        @$(CFACOMPILE) -fsyntax-only -w $(srcdir)/compile/empty.cfa
    11301011
    11311012compile-expression$(EXEEXT):
    1132         $(CFACOMPILE) -fsyntax-only -w $(testdir)/expression.cfa
     1013        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/expression.cfa
    11331014
    11341015compile-io$(EXEEXT):
    1135         $(CFACOMPILE) -fsyntax-only -w $(testdir)/io1.cfa
     1016        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/io1.cfa
    11361017
    11371018compile-monitor$(EXEEXT):
    1138         $(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/monitor.cfa
     1019        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/monitor.cfa
    11391020
    11401021compile-operators$(EXEEXT):
    1141         $(CFACOMPILE) -fsyntax-only -w $(testdir)/operators.cfa
     1022        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/operators.cfa
    11421023
    11431024compile-thread$(EXEEXT):
    1144         $(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/thread.cfa
     1025        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/thread.cfa
    11451026
    11461027compile-typeof$(EXEEXT):
    1147         $(CFACOMPILE) -fsyntax-only -w $(testdir)/typeof.cfa
     1028        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/typeof.cfa
    11481029
    11491030# Tell versions [3.59,3.63) of GNU make to not export all variables.

  • benchmark/bench.h

    rb7d6a36 rdca5802  
    55#endif
    66        #include <stdlib.h>
    7         #include <stdint.h>                             // uint64_t
    8         #include <unistd.h>                             // sysconf
     7        #include <unistd.h>                                     // sysconf
    98#if ! defined(__cforall)
    109        #include <time.h>
    … …  
    1615
    1716
    18 static inline uint64_t bench_time() {
    19         struct timespec ts;
    20         clock_gettime( CLOCK_THREAD_CPUTIME_ID, &ts );
    21         return 1000000000LL * ts.tv_sec + ts.tv_nsec;
    22 } // bench_time
     17static inline unsigned long long int bench_time() {
     18    struct timespec ts;
     19    clock_gettime(
     20#if defined( __linux__ )
     21         CLOCK_THREAD_CPUTIME_ID,
     22#elif defined( __freebsd__ )
     23         CLOCK_PROF,
     24#elif defined( __solaris__ )
     25         CLOCK_HIGHRES,
     26#else
     27    #error uC++ : internal error, unsupported architecture
     28#endif
     29         &ts );
     30    return 1000000000LL * ts.tv_sec + ts.tv_nsec;
     31} // Time
    2332
    2433#ifndef BENCH_N
    25 #define BENCH_N 10000000
     34#define BENCH_N 500 //10000000
    2635#endif
    2736
    28 size_t times = BENCH_N;
    29 
    30 #define BENCH_START()                           \
    31         if ( argc > 2 ) exit( EXIT_FAILURE );   \
    32         if ( argc == 2 ) {                      \
    33                 times = atoi( argv[1] );        \
    34         }
    35 
    3637#define BENCH(statement, output)                \
    37         uint64_t StartTime, EndTime;            \
     38        size_t n = BENCH_N;                     \
     39        if( argc > 2 ) return 1;                \
     40        if( argc == 2 ) {                               \
     41                n = atoi(argv[1]);              \
     42        }                                               \
     43        long long int StartTime, EndTime;       \
    3844        StartTime = bench_time();               \
    39         statement;                              \
     45        statement;                                      \
    4046        EndTime = bench_time();                 \
    41         double output = (double)( EndTime - StartTime ) / times;
    42 
     47        double output =         \
     48            (double)( EndTime - StartTime ) / n;
    4349
    4450#if defined(__cforall)
    … …  
    4753}
    4854#endif
    49 #if defined(__U_CPLUSPLUS__)
    50 unsigned int uDefaultPreemption() {
    51         return 0;
    52 }
    53 #endif

  • benchmark/creation/JavaThread.java

    rb7d6a36 rdca5802  
    2626        static int x = 2;
    2727
    28         static private int times = Integer.parseInt("10000") ;
     28        static private final int NoOfTimes = Integer.parseInt("10000") ;
    2929
    3030        public static class MyThread extends Thread {
    … …  
    3333        }
    3434        public static void helper() throws InterruptedException {
    35                 for(int i = 1; i <= times; i += 1) {
     35                for(int i = 1; i <= NoOfTimes; i += 1) {
    3636                        MyThread m = new MyThread();
    3737                        x = nextRandom( x );
    … …  
    4444                helper();
    4545                long end = System.nanoTime();
    46                 System.out.println( (end - start) / times );
     46                System.out.println( (end - start) / NoOfTimes );
    4747        }
    4848        public static void main(String[] args) throws InterruptedException {
    49                 if ( args.length > 2 ) System.exit( 1 );
    50                 if ( args.length == 2 ) { times = Integer.parseInt(args[1]); }
    51 
    52                 for (int i = Integer.parseInt("5"); --i >= 0 ; ) {
     49                for (int n = Integer.parseInt("5"); --n >= 0 ; ) {
    5350                        InnerMain();
    54                         Thread.sleep(2000);             // 2 seconds
     51                        Thread.sleep(2000);     // 2 seconds
    5552                        x = nextRandom(x);
    5653                }
    … …  
    5855        }
    5956}
    60 
    61 // Local Variables: //
    62 // tab-width: 4 //
    63 // End: //

  • benchmark/creation/cfa_cor.cfa

    rb7d6a36 rdca5802  
    55
    66coroutine MyCoroutine {};
    7 void ?{}( MyCoroutine & this ) {
     7void ?{} (MyCoroutine & this) {
    88#ifdef EAGER
    9         resume( this );
     9        resume(this);
    1010#endif
    1111}
    12 void main( MyCoroutine & ) {}
     12void main(MyCoroutine &) {}
    1313
    14 int main( int argc, char * argv[] ) {
    15         BENCH_START()
     14int main(int argc, char* argv[]) {
    1615        BENCH(
    17                 for ( times ) {
    18                         MyCoroutine c;
     16                for ( i; n ) {
     17                        MyCoroutine m;
    1918                },
    2019                result
    2120        )
    22         printf( "%g\n", result );
     21
     22        printf("%g\n", result);
    2323}
    24 
    25 // Local Variables: //
    26 // tab-width: 4 //
    27 // End: //

  • benchmark/creation/cfa_thrd.cfa

    rb7d6a36 rdca5802  
    77void main(MyThread &) {}
    88
    9 int main( int argc, char * argv[] ) {
    10         BENCH_START()
     9int main(int argc, char* argv[]) {
    1110        BENCH(
    12                 for ( times ) {
     11                for ( i; n ) {
    1312                        MyThread m;
    1413                },
    1514                result
    1615        )
    17         printf( "%g\n", result );
     16
     17        printf("%g\n", result);
    1818}
    19 
    20 // Local Variables: //
    21 // tab-width: 4 //
    22 // End: //

  • benchmark/creation/goroutine.go

    rb7d6a36 rdca5802  
    22
    33import (
    4         "fmt"
    5         "time"
    6         "os"
    7         "strconv"
     4    "fmt"
     5    "time"
    86)
    97
    … …  
    1917
    2018func main() {
    21         var times int = 10000000
    22         if len( os.Args ) > 2 { os.Exit( 1 ) }
    23         if len( os.Args ) == 2 { times, _ = strconv.Atoi(os.Args[1]) }
    24 
     19        const NoOfTimes = 500000
    2520        start := time.Now()
    26         for i := 1; i <= times; i += 1 {
     21        for i := 1; i <= NoOfTimes; i += 1 {
    2722                go noop()               // creation
    28                 <- shake                // wait for completion
    2923        }
    3024        end := time.Now()
    31         fmt.Printf( "%d\n", end.Sub(start) / time.Duration(times) )
     25        fmt.Printf("%d\n", end.Sub(start) / time.Duration(NoOfTimes))
     26        <- shake
    3227}
    33 
    34 // Local Variables: //
    35 // tab-width: 4 //
    36 // End: //

  • benchmark/creation/pthreads.c

    rb7d6a36 rdca5802  
    44#include "bench.h"
    55
    6 static void * foo(void *arg) {
     6static void *foo(void *arg) {
    77    return arg;
    88}
    99
    10 int main( int argc, char * argv[] ) {
    11         BENCH_START()
     10int main(int argc, char* argv[]) {
    1211        BENCH(
    13                 for (size_t i = 0; i < times; i++) {
     12                for (size_t i = 0; i < n; i++) {
    1413                        pthread_t thread;
    1514                        if (pthread_create(&thread, NULL, foo, NULL) < 0) {
    … …  
    1716                                return 1;
    1817                        }
     18
    1919                        if (pthread_join( thread, NULL) < 0) {
    2020                                perror( "failure" );
    … …  
    2424                result
    2525        )
    26         printf( "%g\n", result );
     26
     27        printf("%g\n", result);
    2728}
    28 
    29 // Local Variables: //
    30 // tab-width: 4 //
    31 // End: //

  • benchmark/creation/upp_cor.cc

    rb7d6a36 rdca5802  
    55_Coroutine MyCor {
    66        void main() {}
    7   public:
    8         MyCor() { resume(); }
    97};
    108
    11 int main( int argc, char * argv[] ) {
    12         BENCH_START()
     9int main(int argc, char* argv[]) {
    1310        BENCH(
    14                 for (size_t i = 0; i < times; i++) {
     11                for (size_t i = 0; i < n; i++) {
    1512                        MyCor m;
    1613                },
    1714                result
    1815        )
    19         printf( "%g\n", result );
     16
     17        printf("%g\n", result);
    2018}
    21 
    22 // Local Variables: //
    23 // tab-width: 4 //
    24 // End: //

  • benchmark/creation/upp_thrd.cc

    rb7d6a36 rdca5802  
    77};
    88
    9 int main( int argc, char * argv[] ) {
    10         BENCH_START()
     9int main(int argc, char* argv[]) {
    1110        BENCH(
    12                 for (size_t i = 0; i < times; i++) {
     11                for (size_t i = 0; i < n; i++) {
    1312                        MyThread m;
    1413                },
    1514                result
    1615        )
    17         printf( "%g\n", result );
     16
     17        printf("%g\n", result);
    1818}
    19 
    20 // Local Variables: //
    21 // tab-width: 4 //
    22 // End: //

  • benchmark/ctxswitch/JavaThread.java

    rb7d6a36 rdca5802  
    2626        static int x = 2;
    2727
    28         static private int times = Integer.parseInt("100000");
     28        static private final int NoOfTimes = Integer.parseInt("1000000") ;
    2929
    3030        public static void helper() {
    31                 for(int i = 1; i <= times; i += 1) {
     31                for(int i = 1; i <= NoOfTimes; i += 1) {
    3232                        Thread.yield();
    3333                }
    … …  
    3737                helper();
    3838                long end = System.nanoTime();
    39                 System.out.println( (end - start) / times );
     39                System.out.println( (end - start) / NoOfTimes );
    4040        }
    4141        public static void main(String[] args) throws InterruptedException {
    42                 if ( args.length > 2 ) System.exit( 1 );
    43                 if ( args.length == 2 ) { times = Integer.parseInt(args[1]); }
    44 
    45                 for (int i = Integer.parseInt("5"); --i >= 0 ; ) {
     42                for (int n = Integer.parseInt("5"); --n >= 0 ; ) {
    4643                        InnerMain();
    47                         Thread.sleep(2000);     // 2 seconds
     44                        Thread.sleep(2000);     // 2 seconds
    4845                        x = nextRandom(x);
    4946                }
    … …  
    5148        }
    5249}
    53 
    54 // Local Variables: //
    55 // tab-width: 4 //
    56 // End: //

  • benchmark/ctxswitch/cfa_cor.cfa

    rb7d6a36 rdca5802  
    44#include "bench.h"
    55
    6 coroutine C {} c;
    7 void main( __attribute__((unused)) C & ) {
    8         while () {
     6coroutine GreatSuspender {};
     7
     8void ?{}( GreatSuspender & this ) {
     9        prime(this);
     10}
     11
     12void main( __attribute__((unused)) GreatSuspender & this ) {
     13        while( true ) {
    914                suspend();
    1015        }
    1116}
    12 int main( int argc, char * argv[] ) {
    13         BENCH_START()
     17
     18int main(int argc, char* argv[]) {
     19        GreatSuspender s;
     20
    1421        BENCH(
    15                 for ( times ) {
    16                         resume( c );
     22                for ( i; n ) {
     23                        resume( s );
    1724                },
    1825                result
    1926        )
    20         printf( "%g\n", result );
     27
     28        printf("%g\n", result);
    2129}
    22 
    23 // Local Variables: //
    24 // tab-width: 4 //
    25 // End: //

  • benchmark/ctxswitch/cfa_cor_then.cfa

    rb7d6a36 rdca5802  
    66void noOp(void) {}
    77
    8 coroutine C {} c;
     8coroutine GreatSuspender {};
    99
    10 void ?{}( C & this ) {
     10void ?{}( GreatSuspender & this ) {
    1111        prime(this);
    1212}
    1313
    14 void main( __attribute__((unused)) C & this ) {
    15         while () {
     14void main( __attribute__((unused)) GreatSuspender & this ) {
     15        while( true ) {
    1616                suspend_then(noOp);
    1717        }
    1818}
    1919
    20 int main( int argc, char * argv[] ) {
    21         BENCH_START()
     20int main(int argc, char* argv[]) {
     21        GreatSuspender s;
     22
    2223        BENCH(
    23                 for ( times ) {
    24                         resume( c );
     24                for ( i; n ) {
     25                        resume( s );
    2526                },
    2627                result
    2728        )
    28         printf( "%g\n", result );
     29
     30        printf("%g\n", result);
    2931}
    30 
    31 // Local Variables: //
    32 // tab-width: 4 //
    33 // End: //

  • benchmark/ctxswitch/cfa_gen.cfa

    rb7d6a36 rdca5802  
    33typedef struct {
    44        void * next;
    5 } C;
     5} GreatSuspender;
    66
    7 void comain( C * c ) {
    8         if ( __builtin_expect(c->next != 0, 1) ) goto *(c->next);
    9         c->next = &&s1;
     7void comain( GreatSuspender * this ) {
     8    if ( __builtin_expect(this->next != 0, 1) ) goto *(this->next);
     9    this->next = &&s1;
    1010        for () {
    11                 return;
     11            return;
    1212          s1: ;
    1313        }
    1414}
    1515
    16 int main( int argc, char * argv[] ) {
    17         BENCH_START()
    18         C c = { 0 };
     16int main(int argc, char* argv[]) {
     17    GreatSuspender s = { 0 };
     18
    1919        BENCH(
    20                 for ( times ) {
    21                         comain( &c );
     20                for ( i; n ) {
     21                        comain( &s );
    2222                },
    2323                result
    2424        )
    25         printf( "%g\n", result );
     25
     26        printf("%g\n", result);
    2627}
    27 
    28 // Local Variables: //
    29 // tab-width: 4 //
    30 // End: //

  • benchmark/ctxswitch/cfa_thrd.cfa

    rb7d6a36 rdca5802  
    33#include "bench.h"
    44
    5 int main( int argc, char * argv[] ) {
    6         BENCH_START()
     5int main(int argc, char* argv[]) {
    76        BENCH(
    8                 for ( times ) {
     7                for ( i; n ) {
    98                        yield();
    109                },
    1110                result
    1211        )
    13         printf( "%g\n", result );
     12
     13        printf("%g\n", result);
    1414}
    15 
    16 // Local Variables: //
    17 // tab-width: 4 //
    18 // End: //

  • benchmark/ctxswitch/cfa_thrd2.cfa

    rb7d6a36 rdca5802  
    88
    99void main(__attribute__((unused)) Fibre & this) {
    10         while ( ! done ) {
     10        while(!done) {
    1111                yield();
    1212        }
    1313}
    1414
    15 int main( int argc, char * argv[] ) {
    16         BENCH_START()
     15int main(int argc, char* argv[]) {
    1716        Fibre f1;
    1817        BENCH(
    19                 for ( times ) {
     18                for ( i; n ) {
    2019                        yield();
    2120                },
    2221                result
    2322        )
    24         printf( "%g\n", result );
     23
     24        printf("%g\n", result);
    2525        done = true;
     26        return 0;
    2627}
    27 
    28 // Local Variables: //
    29 // tab-width: 4 //
    30 // End: //

  • benchmark/ctxswitch/goroutine.go

    rb7d6a36 rdca5802  
    22
    33import (
    4         "fmt"
    5         "time"
    6         "os"
    7         "strconv"
    8         "runtime"
     4    "fmt"
     5    "runtime"
     6    "time"
    97)
    108
    … …  
    3028
    3129func main() {
    32         var times int = 10000000
    33         if len( os.Args ) > 2 { os.Exit( 1 ) }
    34         if len( os.Args ) == 2 { times, _ = strconv.Atoi(os.Args[1]) }
    35         go ContextSwitch( times )               // context switch
     30        const NoOfTimes = 10000000
     31        go ContextSwitch( NoOfTimes )           // context switch
    3632        <- shake
    3733}
    38 
    39 // Local Variables: //
    40 // tab-width: 4 //
    41 // End: //

  • benchmark/ctxswitch/kos_fibre.cpp

    rb7d6a36 rdca5802  
    33#include "bench.h"
    44
    5 int main( int argc, char * argv[] ) {
    6         BENCH_START()
     5int main(int argc, char* argv[]) {
    76        BENCH(
    8                 for (size_t i = 0; i < times; i++) {
     7                for (size_t i = 0; i < n; i++) {
    98                        Fibre::yield();
    109                },
    1110                result
    1211        )
    13         printf( "%g\n", result );
     12        printf("%g\n", result);
     13        return 0;
    1414}
    15 
    16 // Local Variables: //
    17 // tab-width: 4 //
    18 // End: //

  • benchmark/ctxswitch/kos_fibre2.cpp

    rb7d6a36 rdca5802  
    1111}
    1212
    13 int main( int argc, char * argv[] ) {
    14         BENCH_START()
     13int main(int argc, char* argv[]) {
    1514        Fibre* f1 = (new Fibre)->run(f1main);
    1615        BENCH(
    17                 for (size_t i = 0; i < times; i++) {
     16                for (size_t i = 0; i < n; i++) {
    1817                        Fibre::yield();
    1918                },
    2019                result
    2120        )
    22         printf( "%g\n", result );
     21        printf("%g\n", result);
    2322        done = true;
    2423        Fibre::yield();
    2524        f1->join();
     25        return 0;
    2626}
    27 
    28 // Local Variables: //
    29 // tab-width: 4 //
    30 // End: //

  • benchmark/ctxswitch/pthreads.c

    rb7d6a36 rdca5802  
    66#include "bench.h"
    77
    8 int main( int argc, char * argv[] ) {
    9         BENCH_START()
     8int main(int argc, char* argv[]) {
    109        BENCH(
    11                 for (size_t i = 0; i < times; i++) {
     10                for (size_t i = 0; i < n; i++) {
    1211                        sched_yield();
    1312                },
    1413                result
    1514        )
    16         printf( "%g\n", result );
     15
     16        printf("%g\n", result);
    1717}

  • benchmark/ctxswitch/upp_cor.cc

    rb7d6a36 rdca5802  
    33#include "bench.h"
    44
    5 _Coroutine C {
     5_Coroutine GreatSuspender {
     6public:
     7        GreatSuspender() {
     8                resume();
     9        }
     10
     11        void do_resume() {
     12                resume();
     13        }
     14private:
    615        void main() {
    716                while( true ) {
    … …  
    918                }
    1019        }
    11   public:
    12         void do_resume() {
    13                 resume();
    14         }
    15 } c;
    16 int main( int argc, char * argv[] ) {
    17         BENCH_START()
     20};
     21
     22int main(int argc, char* argv[]) {
     23        GreatSuspender s;
     24
    1825        BENCH(
    19                 for (size_t i = 0; i < times; i++) {
    20                         c.do_resume();
     26                for (size_t i = 0; i < n; i++) {
     27                        s.do_resume();
    2128                },
    2229                result
    2330        )
    24         printf( "%g\n", result );
     31
     32        printf("%g\n", result);
    2533}
    26 
    27 // Local Variables: //
    28 // tab-width: 4 //
    29 // End: //

  • benchmark/ctxswitch/upp_thrd.cc

    rb7d6a36 rdca5802  
    33#include "bench.h"
    44
    5 int main( int argc, char * argv[] ) {
    6         BENCH_START()
     5int main(int argc, char* argv[]) {
    76        BENCH(
    8                 for (size_t i = 0; i < times; i++) {
     7                for (size_t i = 0; i < n; i++) {
    98                        uThisTask().yield();
    109                },
    1110                result
    1211        )
    13         printf( "%g\n", result );
     12
     13        printf("%g\n", result);
    1414}
    15 
    16 // Local Variables: //
    17 // tab-width: 4 //
    18 // End: //

  • benchmark/mutex/JavaThread.java

    rb7d6a36 rdca5802  
    2626        static int x = 2;
    2727
    28         static private int times = Integer.parseInt("100000000");
     28        static private final int NoOfTimes = Integer.parseInt("100000000") ;
    2929
    3030        public synchronized void noop() {
    … …  
    3535                // Inhibit biased locking ...
    3636                x = (j.hashCode() ^ System.identityHashCode(j)) | 1 ;     
    37                 for(int i = 1; i <= times; i += 1) {
     37                for(int i = 1; i <= NoOfTimes; i += 1) {
    3838                        x = nextRandom(x);
    3939                        j.noop();
    … …  
    4444                helper();
    4545                long end = System.nanoTime();
    46                 System.out.println( (end - start) / times );
     46                System.out.println( (end - start) / NoOfTimes );
    4747        }
    4848        public static void main(String[] args) throws InterruptedException {
    49                 if ( args.length > 2 ) System.exit( 1 );
    50                 if ( args.length == 2 ) { times = Integer.parseInt(args[1]); }
    51 
    5249                for (int n = Integer.parseInt("5"); --n >= 0 ; ) {
    5350                        InnerMain();
    … …  
    5855        }
    5956}
    60 
    61 // Local Variables: //
    62 // tab-width: 4 //
    63 // End: //

  • benchmark/mutex/cfa1.cfa

    rb7d6a36 rdca5802  
    44#include "bench.h"
    55
    6 monitor M {} m1;
    7 void __attribute__((noinline)) call( M & mutex p1 ) {}
     6monitor M {};
     7void __attribute__((noinline)) call( M & mutex m ) {}
    88
    9 int main( int argc, char * argv[] ) {
    10         BENCH_START()
     9int main(int argc, char* argv[]) {
     10        M m;
    1111        BENCH(
    12                 for ( times ) {
    13                         call( m1 );
     12                for ( i; n ) {
     13                        call(m);
    1414                },
    1515                result
    1616        )
    17         printf( "%g\n", result );
     17
     18        printf("%g\n", result);
    1819}
    19 
    20 // Local Variables: //
    21 // tab-width: 4 //
    22 // End: //

  • benchmark/mutex/cfa2.cfa

    rb7d6a36 rdca5802  
    44#include "bench.h"
    55
    6 monitor M {} m1, m2;
     6monitor M {};
     7void __attribute__((noinline)) call( M & mutex m1, M & mutex m2 ) {}
    78
    8 void __attribute__((noinline)) call( M & mutex p1, M & mutex p2 ) {}
    9 
    10 int main( int argc, char * argv[] ) {
    11         BENCH_START()
     9int main(int argc, char* argv[]) {
     10        M m1, m2;
    1211        BENCH(
    13                 for ( times ) {
    14                         call( m1, m2 );
     12                for ( i; n ) {
     13                        call(m1, m2);
    1514                },
    1615                result
    1716        )
    18         printf( "%g\n", result );
     17
     18        printf("%g\n", result);
    1919}
    20 
    21 // Local Variables: //
    22 // tab-width: 4 //
    23 // End: //

  • benchmark/mutex/cfa4.cfa

    rb7d6a36 rdca5802  
    55
    66
    7 monitor M {} m1, m2, m3, m4;
    8 void __attribute__((noinline)) call( M & mutex p1, M & mutex p2, M & mutex p3, M & mutex p4 ) {}
     7monitor M {};
     8void __attribute__((noinline)) call( M & mutex m1, M & mutex m2, M & mutex m3, M & mutex m4 ) {}
    99
    10 int main( int argc, char * argv[] ) {
    11         BENCH_START()
     10int main(int argc, char* argv[]) {
     11        M m1, m2, m3, m4;
    1212        BENCH(
    13                 for ( times ) {
    14                         call( m1, m2, m3, m4 );
     13                for ( i; n ) {
     14                        call(m1, m2, m3, m4);
    1515                },
    1616                result
    1717        )
    18         printf( "%g\n", result );
     18
     19        printf("%g\n", result);
    1920}
    20 
    21 // Local Variables: //
    22 // tab-width: 4 //
    23 // End: //

  • benchmark/mutex/pthreads.c

    rb7d6a36 rdca5802  
    77
    88void __attribute__((noinline)) call() {
    9          pthread_mutex_lock( &mutex );
    10          pthread_mutex_unlock( &mutex );
     9         pthread_mutex_lock  (&mutex);
     10         pthread_mutex_unlock(&mutex);
    1111}
    12 int main( int argc, char * argv[] ) {
    13         BENCH_START()
     12
     13int main(int argc, char* argv[]) {
    1414        BENCH(
    15                 for ( size_t i = 0; i < times; i++ ) {
     15                for (size_t i = 0; i < n; i++) {
    1616                        call();
    1717                },
    1818                result
    1919        )
    20         printf( "%g\n", result );
     20
     21        printf("%g\n", result);
    2122}
    22 
    23 // Local Variables: //
    24 // tab-width: 4 //
    25 // End: //

  • benchmark/mutex/upp.cc

    rb7d6a36 rdca5802  
    88};
    99
    10 int main( int argc, char * argv[] ) {
    11         BENCH_START()
     10int main(int argc, char* argv[]) {
    1211        MyMonitor m;
    1312        BENCH(
    14                 for ( size_t i = 0; i < times; i++ ) {
     13                for (size_t i = 0; i < n; i++) {
    1514                        m.call();
    1615                },
    1716                result
    1817        )
    19         printf( "%g\n", result );
     18
     19        printf("%g\n", result);
    2020}
    21 
    22 // Local Variables: //
    23 // tab-width: 4 //
    24 // End: //

  • benchmark/schedext/cfa1.cfa

    rb7d6a36 rdca5802  
    44#include <stdio.h>
    55
    6 #include "../bench.h"
     6#include "bench.h"
    77
    8 monitor M {} m1;
     8int argc;
     9char** argv;
     10volatile int go = 0;
    911
    10 void __attribute__((noinline)) call( M & mutex p1 ) {}
    11 void __attribute__((noinline)) wait( M & mutex p1 ) {
    12         for ( times ) {
    13                 waitfor( call : p1 );
    14         }
     12monitor M {};
     13M m1;
     14
     15void __attribute__((noinline)) call( M & mutex a1 ) {}
     16
     17int  __attribute__((noinline)) wait( M & mutex a1 ) {
     18        go = 1;
     19        BENCH(
     20                for ( i; n ) {
     21                        waitfor(call, a1);
     22                },
     23                result
     24        )
     25
     26        printf("%g\n", result);
     27        go = 0;
     28        return 0;
    1529}
    1630
    1731thread T {};
     32void ^?{}( T & mutex this ) {}
    1833void main( T & ) {
    19         BENCH(
    20                 for ( times ) { call( m1 ); },
    21                 result
    22         )
    23         printf( "%g\n", result );
     34        while(go == 0) { yield(); }
     35        while(go == 1) { call(m1); }
     36
    2437}
    2538
    26 int main( int argc, char * argv[] ) {
    27         BENCH_START()
     39int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
    2840        T t;
    29         wait( m1 );
     41        return wait(m1);
    3042}
    31 
    32 // Local Variables: //
    33 // tab-width: 4 //
    34 // End: //

  • benchmark/schedext/cfa2.cfa

    rb7d6a36 rdca5802  
    44#include <stdio.h>
    55
    6 #include "../bench.h"
     6#include "bench.h"
    77
    8 monitor M {} m1, m2;
     8int argc;
     9char** argv;
     10volatile int go = 0;
    911
    10 void __attribute__((noinline)) call( M & mutex p1, M & mutex p2 ) {}
    11 void __attribute__((noinline)) wait( M & mutex p1, M & mutex p2 ) {
    12         for ( times ) {
    13                 waitfor( call : p1, p2 );
    14         }
    15 }
    16 thread T {};
    17 void main( T & ) {
     12monitor M {};
     13M m1, m2;
     14
     15void __attribute__((noinline)) call( M & mutex a1, M & mutex a2 ) {}
     16
     17int  __attribute__((noinline)) wait( M & mutex a1, M & mutex a2 ) {
     18        go = 1;
    1819        BENCH(
    19                 for ( times ) {
    20                         call( m1, m2 );
     20                for ( i; n ) {
     21                        waitfor(call, a1, a2);
    2122                },
    2223                result
    2324        )
    24         printf( "%g\n", result );
     25
     26        printf("%g\n", result);
     27        go = 0;
     28        return 0;
    2529}
    2630
    27 int main( int argc, char * argv[] ) {
    28         BENCH_START()
    29         T t;
    30         wait( m1, m2 );
     31thread T {};
     32void ^?{}( T & mutex this ) {}
     33void main( T & ) {
     34        while(go == 0) { yield(); }
     35        while(go == 1) { call(m1, m2); }
     36
    3137}
    3238
    33 // Local Variables: //
    34 // tab-width: 4 //
    35 // End: //
     39int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
     40        T t;
     41        return wait(m1, m2);
     42}

  • benchmark/schedext/cfa4.cfa

    rb7d6a36 rdca5802  
    44#include <stdio.h>
    55
    6 #include "../bench.h"
     6#include "bench.h"
    77
    8 monitor M {} m1, m2, m3, m4;
     8int argc;
     9char** argv;
     10volatile int go = 0;
    911
    10 void __attribute__((noinline)) call( M & mutex p1, M & mutex p2, M & mutex p3, M & mutex p4 ) {}
    11 void __attribute__((noinline)) wait( M & mutex p1, M & mutex p2, M & mutex p3, M & mutex p4 ) {
    12         for ( times ) {
    13                 waitfor( call : p1, p2, p3, p4 );
    14         }
    15 }
    16 thread T {};
    17 void main( T & ) {
     12monitor M {};
     13M m1, m2, m3, m4;
     14
     15void __attribute__((noinline)) call( M & mutex a1, M & mutex a2, M & mutex a3, M & mutex a4 ) {}
     16
     17int  __attribute__((noinline)) wait( M & mutex a1, M & mutex a2, M & mutex a3, M & mutex a4 ) {
     18        go = 1;
    1819        BENCH(
    19                 for ( times ) {
    20                         call( m1, m2, m3, m4 );
     20                for ( i; n ) {
     21                        waitfor(call, a1, a2, a3, a4);
    2122                },
    2223                result
    2324        )
    24         printf( "%g\n", result );
     25
     26        printf("%g\n", result);
     27        go = 0;
     28        return 0;
    2529}
    2630
    27 int main( int argc, char * argv[] ) {
    28         BENCH_START()
    29         T t;
    30         wait( m1, m2, m3, m4 );
     31thread T {};
     32void ^?{}( T & mutex this ) {}
     33void main( T & ) {
     34        while(go == 0) { yield(); }
     35        while(go == 1) { call(m1, m2, m3, m4); }
     36
    3137}
    3238
    33 // Local Variables: //
    34 // tab-width: 4 //
    35 // End: //
     39int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
     40        T t;
     41        return wait(m1, m2, m3, m4);
     42}

  • benchmark/schedext/upp.cc

    rb7d6a36 rdca5802  
    33#include "bench.h"
    44
     5int argc;
     6char** argv;
     7volatile int go = 0;
     8
    59_Monitor M {
    610public:
    711        void __attribute__((noinline)) call() {}
    8         void __attribute__((noinline)) wait() {
    9                 for ( size_t i = 0; i < times; i++ ) {
    10                         _Accept(call);
    11                 }
     12
     13        int __attribute__((noinline)) wait() {
     14                go = 1;
     15                BENCH(
     16                        for (size_t i = 0; i < n; i++) {
     17                                _Accept(call);
     18                        },
     19                        result
     20                )
     21
     22                printf("%g\n", result);
     23                go = 0;
     24                return 0;
    1225        }
    13 } m;
     26};
     27
     28M m;
    1429
    1530_Task T {
    1631        void main() {
    17                 BENCH(
    18                         for ( size_t i = 0; i < times; i++ ) {
    19                                 m.call();
    20                         },
    21                         result
    22                 )
    23                 printf( "%g\n", result );
     32                while(go == 0) { yield(); }
     33                while(go == 1) { m.call(); }
     34
    2435        }
    2536};
    2637
    27 int main( int argc, char * argv[] ) {
    28         BENCH_START()
     38int main(int margc, char* margv[]) {
     39        argc = margc;
     40        argv = margv;
    2941        T t;
    30         m.wait();
     42        return m.wait();
    3143}
    32 
    33 // Local Variables: //
    34 // tab-width: 4 //
    35 // End: //

  • benchmark/schedint/JavaThread.java

    rb7d6a36 rdca5802  
    4949        static int x = 2;
    5050
    51         static private int times = Integer.parseInt("1000000");
     51        static private final int NoOfTimes = Integer.parseInt("1000000") ;
    5252
    5353        public static void helper( Monitor m ) throws InterruptedException {
    54                 for(int i = 1; i <= times; i += 1) {
     54                for(int i = 1; i <= NoOfTimes; i += 1) {
    5555                        m.wait();               // relase monitor lock
    5656                        m.next = true;
    … …  
    6363                synchronized(m) {
    6464                        s.start();
    65                         while( ! Monitor.go ) { // waiter must start first
     65                        while( !Monitor.go ) {
    6666                                Thread.yield();
    6767                        }
    … …  
    7272                Monitor.go = false;
    7373                s.join();
    74                 System.out.println( (end - start) / times);
     74                System.out.println( (end - start) / NoOfTimes);
    7575        }
    7676        public static void main(String[] args) throws InterruptedException {
    77                 if ( args.length > 2 ) System.exit( 1 );
    78                 if ( args.length == 2 ) { times = Integer.parseInt(args[1]); }
    79 
    8077                for (int n = Integer.parseInt("5"); --n >= 0 ; ) {
    8178                        InnerMain();
    … …  
    8683        }
    8784}
    88 
    89 // Local Variables: //
    90 // tab-width: 4 //
    91 // End: //

  • benchmark/schedint/cfa1.cfa

    rb7d6a36 rdca5802  
    44#include <stdio.h>
    55
    6 #include "../bench.h"
     6#include "bench.h"
    77
     8int argc;
     9char** argv;
    810volatile int go = 0;
    911
    1012condition c;
    11 monitor M {} m1;
     13monitor M {};
     14M m1;
    1215
    13 void __attribute__((noinline)) call( M & mutex p1 ) {
    14         signal( c );
     16void __attribute__((noinline)) call( M & mutex a1 ) {
     17        signal(c);
    1518}
    16 void __attribute__((noinline)) wait( M & mutex p1 ) {
     19
     20int  __attribute__((noinline)) wait( M & mutex a1 ) {
    1721        go = 1;
    18         for ( times ) {
    19                 wait( c );
    20         }
     22        BENCH(
     23                for ( i; n ) {
     24                        wait(c);
     25                },
     26                result
     27        )
     28
     29        printf("%g\n", result);
     30        go = 0;
     31        return 0;
    2132}
    2233
    2334thread T {};
     35void ^?{}( T & mutex ) {}
    2436void main( T & ) {
    25         while ( go == 0 ) { yield(); } // waiter must start first
    26         BENCH(
    27                 for ( times ) { call( m1 ); },
    28                 result
    29         )
    30         printf( "%g\n", result );
     37        while(go == 0) { yield(); }
     38        while(go == 1) { call(m1); }
     39
    3140}
    3241
    33 int main( int argc, char * argv[] ) {
    34         BENCH_START()
     42int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
    3543        T t;
    36         wait( m1 );
     44        return wait(m1);
    3745}
    38 
    39 // Local Variables: //
    40 // tab-width: 4 //
    41 // End: //

  • benchmark/schedint/cfa2.cfa

    rb7d6a36 rdca5802  
    44#include <stdio.h>
    55
    6 #include "../bench.h"
     6#include "bench.h"
    77
     8int argc;
     9char** argv;
    810volatile int go = 0;
    911
    1012condition c;
    11 monitor M {} m1, m2;
     13monitor M {};
     14M m1, m2;
    1215
    13 void __attribute__((noinline)) call( M & mutex p1, M & mutex p2 ) {
    14         signal( c );
     16void __attribute__((noinline)) call( M & mutex a1, M & mutex a2 ) {
     17        signal(c);
    1518}
    16 void __attribute__((noinline)) wait( M & mutex p1, M & mutex p2 ) {
     19
     20int  __attribute__((noinline)) wait( M & mutex a1, M & mutex a2 ) {
    1721        go = 1;
    18         for ( times ) {
    19                 wait( c );
    20         }
     22        BENCH(
     23                for ( i; n ) {
     24                        wait(c);
     25                },
     26                result
     27        )
     28
     29        printf("%g\n", result);
     30        go = 0;
     31        return 0;
    2132}
    2233
    2334thread T {};
     35void ^?{}( T & mutex this ) {}
    2436void main( T & ) {
    25         while ( go == 0 ) { yield(); } // waiter must start first
    26         BENCH(
    27                 for ( times ) { call( m1, m2 ); },
    28                 result
    29         )
    30         printf( "%g\n", result );
     37        while(go == 0) { yield(); }
     38        while(go == 1) { call(m1, m2); }
     39
    3140}
    3241
    33 int main( int argc, char * argv[] ) {
    34         BENCH_START()
     42int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
    3543        T t;
    36         wait( m1, m2 );
     44        return wait(m1, m2);
    3745}
    38 
    39 // Local Variables: //
    40 // tab-width: 4 //
    41 // End: //

  • benchmark/schedint/cfa4.cfa

    rb7d6a36 rdca5802  
    44#include <stdio.h>
    55
    6 #include "../bench.h"
     6#include "bench.h"
    77
     8int argc;
     9char** argv;
    810volatile int go = 0;
    911
    1012condition c;
    11 monitor M {} m1, m2, m3, m4;
     13monitor M {};
     14M m1, m2, m3, m4;
    1215
    13 void __attribute__((noinline)) call( M & mutex p1, M & mutex p2, M & mutex p3, M & mutex p4 ) {
    14         signal( c );
     16void __attribute__((noinline)) call( M & mutex a1, M & mutex a2, M & mutex a3, M & mutex a4 ) {
     17        signal(c);
    1518}
    16 void __attribute__((noinline)) wait( M & mutex p1, M & mutex p2, M & mutex p3, M & mutex p4 ) {
     19
     20int  __attribute__((noinline)) wait( M & mutex a1, M & mutex a2, M & mutex a3, M & mutex a4 ) {
    1721        go = 1;
    18         for ( times ) {
    19                 wait( c );
    20         }
     22        BENCH(
     23                for ( i; n ) {
     24                        wait(c);
     25                },
     26                result
     27        )
     28
     29        printf("%g\n", result);
     30        go = 0;
     31        return 0;
    2132}
    2233
    2334thread T {};
     35void ^?{}( T & mutex this ) {}
    2436void main( T & ) {
    25         while ( go == 0 ) { yield(); } // waiter must start first
    26         BENCH(
    27                 for ( times ) { call( m1, m2, m3, m4 ); },
    28                 result
    29         )
    30         printf( "%g\n", result );
     37        while(go == 0) { yield(); }
     38        while(go == 1) { call(m1, m2, m3, m4); }
     39
    3140}
    3241
    33 int main( int argc, char * argv[] ) {
    34         BENCH_START()
     42int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
    3543        T t;
    36         wait( m1, m2, m3, m4 );
     44        return wait(m1, m2, m3, m4);
    3745}
    38 
    39 // Local Variables: //
    40 // tab-width: 4 //
    41 // End: //

  • benchmark/schedint/pthreads.c

    rb7d6a36 rdca5802  
    44#include "bench.h"
    55
     6int argc;
     7char** argv;
    68volatile int go = 0;
    79
     10pthread_cond_t c;
    811pthread_mutex_t m;
    9 pthread_cond_t c;
    1012
    1113void __attribute__((noinline)) call() {
    12         pthread_mutex_lock( &m );
    13         pthread_cond_signal( &c );
    14         pthread_mutex_unlock( &m );
     14        pthread_mutex_lock(&m);
     15        pthread_cond_signal(&c);
     16        pthread_mutex_unlock(&m);
    1517}
    1618
    17 void __attribute__((noinline)) wait() {
     19int __attribute__((noinline)) wait() {
    1820        pthread_mutex_lock(&m);
    1921        go = 1;
    20         for ( size_t i = 0; i < times; i++ ) {
    21                 pthread_cond_wait( &c, &m );
    22         }
     22        BENCH(
     23                for (size_t i = 0; i < n; i++) {
     24                        pthread_cond_wait(&c, &m);
     25                },
     26                result
     27        )
     28
     29        printf("%g\n", result);
    2330        go = 0;
    24         pthread_mutex_unlock( &m );
     31        pthread_mutex_unlock(&m);
     32        return 0;
    2533}
    2634
    27 void * thread_main( __attribute__((unused)) void * arg ) {
    28         while ( go == 0 ) { sched_yield(); } // waiter must start first
    29         // barging for lock acquire => may not execute N times
    30         BENCH(
    31                 while ( go == 1 ) { call(); },
    32                 result
    33         )
    34         printf( "%g\n", result );
     35void* thread_main(__attribute__((unused)) void * arg ) {
     36        while(go == 0) { sched_yield(); }
     37        while(go == 1) { call(); }
    3538        return NULL;
    3639}
    3740
    38 int main( int argc, char * argv[] ) {
    39         BENCH_START()
     41int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
    4042        pthread_t thread;
    41         if ( pthread_create( &thread, NULL, thread_main, NULL ) < 0 ) {
     43        if (pthread_create(&thread, NULL, thread_main, NULL) < 0) {
    4244                perror( "failure" );
    4345                return 1;
    4446        }
    4547        wait();
    46         if ( pthread_join( thread, NULL ) < 0 ) {
     48        if (pthread_join( thread, NULL) < 0) {
    4749                perror( "failure" );
    4850                return 1;
    4951        }
     52        return 0;
    5053}
    51 
    52 // Local Variables: //
    53 // tab-width: 4 //
    54 // End: //

  • benchmark/schedint/upp.cc

    rb7d6a36 rdca5802  
    33#include "bench.h"
    44
     5int argc;
     6char** argv;
    57volatile int go = 0;
    68
    … …  
    1113                cond.signal();
    1214        }
    13         void __attribute__((noinline)) wait() {
     15
     16        int __attribute__((noinline)) wait() {
    1417                go = 1;
    15                 for ( size_t i = 0; i < times; i++ ) {
    16                         cond.wait();
    17                 }
     18                BENCH(
     19                        for (size_t i = 0; i < n; i++) {
     20                                cond.wait();
     21                        },
     22                        result
     23                )
     24
     25                printf("%g\n", result);
     26                go = 0;
     27                return 0;
    1828        }
    19 } m;
     29};
     30
     31M m;
    2032
    2133_Task T {
    2234        void main() {
    23                 while ( go == 0 ) { yield(); } // waiter must start first
    24                 BENCH(
    25                         for ( size_t i = 0; i < times; i++ ) {
    26                                 m.call();
    27                         },
    28                         result
    29                 )
    30                 printf( "%g\n", result );
     35                while(go == 0) { yield(); }
     36                while(go == 1) { m.call(); }
     37
    3138        }
    3239};
    3340
    34 int main( int argc, char * argv[] ) {
    35         BENCH_START()
     41int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
    3642        T t;
    37         m.wait();
     43        return m.wait();
    3844}
    39 
    40 // Local Variables: //
    41 // tab-width: 4 //
    42 // End: //

  • doc/theses/thierry_delisle_PhD/code/relaxed_list.cpp

    rb7d6a36 rdca5802  
    99#include <vector>
    1010
    11 #include <getopt.h>
    1211#include <unistd.h>
    1312#include <sys/sysinfo.h>
    … …  
    2221
    2322        int value;
    24         int id;
    25 
    26         Node() { creates++; }
    27         Node(int value): value(value) { creates++; }
    28         ~Node() { destroys++; }
     23        Node(int value): value(value) {
     24                creates++;
     25        }
     26
     27        ~Node() {
     28                destroys++;
     29        }
    2930};
    3031
    … …  
    3233std::atomic_size_t Node::destroys = { 0 };
    3334
     35static const constexpr int nodes_per_threads = 128;
     36struct NodeArray {
     37        __attribute__((aligned(64))) Node * array[nodes_per_threads];
     38        __attribute__((aligned(64))) char pad;
     39};
     40
    3441bool enable_stats = false;
    35 
    36 template<>
    37 thread_local relaxed_list<Node>::TLS relaxed_list<Node>::tls = {};
    38 
    39 template<>
    40 relaxed_list<Node> * relaxed_list<Node>::head = nullptr;
    41 
    42 #ifndef NO_STATS
    43 template<>
    44 relaxed_list<Node>::GlobalStats relaxed_list<Node>::global_stats = {};
    45 #endif
    46 
    47 // ================================================================================================
    48 //                        UTILS
    49 // ================================================================================================
    5042
    5143struct local_stat_t {
    … …  
    5547        size_t crc_in  = 0;
    5648        size_t crc_out = 0;
    57         size_t valmax = 0;
    58         size_t valmin = 100000000ul;
    5949};
    6050
    61 struct global_stat_t {
    62         std::atomic_size_t in  = { 0 };
    63         std::atomic_size_t out = { 0 };
    64         std::atomic_size_t empty = { 0 };
    65         std::atomic_size_t crc_in  = { 0 };
    66         std::atomic_size_t crc_out = { 0 };
    67         std::atomic_size_t valmax = { 0 };
    68         std::atomic_size_t valmin = { 100000000ul };
    69 };
    70 
    71 void atomic_max(std::atomic_size_t & target, size_t value) {
    72         for(;;) {
    73                 size_t expect = target.load(std::memory_order_relaxed);
    74                 if(value <= expect) return;
    75                 bool success = target.compare_exchange_strong(expect, value);
    76                 if(success) return;
    77         }
    78 }
    79 
    80 void atomic_min(std::atomic_size_t & target, size_t value) {
    81         for(;;) {
    82                 size_t expect = target.load(std::memory_order_relaxed);
    83                 if(value >= expect) return;
    84                 bool success = target.compare_exchange_strong(expect, value);
    85                 if(success) return;
    86         }
    87 }
    88 
    89 void tally_stats(global_stat_t & global, local_stat_t & local) {
    90 
    91         global.in    += local.in;
    92         global.out   += local.out;
    93         global.empty += local.empty;
    94 
    95         global.crc_in  += local.crc_in;
    96         global.crc_out += local.crc_out;
    97 
    98         atomic_max(global.valmax, local.valmax);
    99         atomic_min(global.valmin, local.valmin);
    100 
    101         relaxed_list<Node>::stats_tls_tally();
    102 }
    103 
    104 void waitfor(double & duration, barrier_t & barrier, std::atomic_bool & done) {
     51__attribute__((noinline)) void run_body(
     52        std::atomic<bool>& done,
     53        Random & rand,
     54        Node * (&my_nodes)[128],
     55        local_stat_t & local,
     56        relaxed_list<Node> & list
     57) {
     58        while(__builtin_expect(!done.load(std::memory_order_relaxed), true)) {
     59                int idx = rand.next() % nodes_per_threads;
     60                if (auto node = my_nodes[idx]) {
     61                        local.crc_in += node->value;
     62                        list.push(node);
     63                        my_nodes[idx] = nullptr;
     64                        local.in++;
     65                }
     66                else if(auto node = list.pop()) {
     67                        local.crc_out += node->value;
     68                        my_nodes[idx] = node;
     69                        local.out++;
     70                }
     71                else {
     72                        local.empty++;
     73                }
     74        }
     75}
     76
     77void run(unsigned nthread, unsigned nqueues, unsigned fill, double duration) {
     78        // List being tested
     79        relaxed_list<Node> list = { nthread * nqueues };
     80
     81        // Barrier for synchronization
     82        barrier_t barrier(nthread + 1);
     83
     84        // Data to check everything is OK
     85        struct {
     86                std::atomic_size_t in  = { 0 };
     87                std::atomic_size_t out = { 0 };
     88                std::atomic_size_t empty = { 0 };
     89                std::atomic_size_t crc_in  = { 0 };
     90                std::atomic_size_t crc_out = { 0 };
     91                struct {
     92                        struct {
     93                                std::atomic_size_t attempt = { 0 };
     94                                std::atomic_size_t success = { 0 };
     95                        } push;
     96                        struct {
     97                                std::atomic_size_t attempt = { 0 };
     98                                std::atomic_size_t success = { 0 };
     99                        } pop;
     100                } pick;
     101        } global;
     102
     103        // Flag to signal termination
     104        std::atomic_bool done  = { false };
     105
     106        // Prep nodes
     107        std::cout << "Initializing ";
     108        size_t nnodes  = 0;
     109        size_t npushed = 0;
     110        NodeArray all_nodes[nthread];
     111        for(auto & nodes : all_nodes) {
     112                Random rand(rdtscl());
     113                for(auto & node : nodes.array) {
     114                        auto r = rand.next() % 100;
     115                        if(r < fill) {
     116                                node = new Node(rand.next() % 100);
     117                                nnodes++;
     118                        } else {
     119                                node = nullptr;
     120                        }
     121                }
     122
     123                for(int i = 0; i < 10; i++) {
     124                        int idx = rand.next() % nodes_per_threads;
     125                        if (auto node = nodes.array[idx]) {
     126                                global.crc_in += node->value;
     127                                list.push(node);
     128                                npushed++;
     129                                nodes.array[idx] = nullptr;
     130                        }
     131                }
     132        }
     133
     134        std::cout << nnodes << " nodes " << fill << "% (" << npushed << " pushed)" << std::endl;
     135
     136        enable_stats = true;
     137
     138        std::thread * threads[nthread];
     139        unsigned i = 1;
     140        for(auto & t : threads) {
     141                auto & my_nodes = all_nodes[i - 1].array;
     142                t = new std::thread([&done, &list, &barrier, &global, &my_nodes](unsigned tid) {
     143                        Random rand(tid + rdtscl());
     144
     145                        local_stat_t local;
     146
     147                        // affinity(tid);
     148
     149                        barrier.wait(tid);
     150
     151                        // EXPERIMENT START
     152
     153                        run_body(done, rand, my_nodes, local, list);
     154
     155                        // EXPERIMENT END
     156
     157                        barrier.wait(tid);
     158
     159                        global.in    += local.in;
     160                        global.out   += local.out;
     161                        global.empty += local.empty;
     162
     163                        for(auto node : my_nodes) {
     164                                delete node;
     165                        }
     166
     167                        global.crc_in  += local.crc_in;
     168                        global.crc_out += local.crc_out;
     169
     170                        global.pick.push.attempt += relaxed_list<Node>::tls.pick.push.attempt;
     171                        global.pick.push.success += relaxed_list<Node>::tls.pick.push.success;
     172                        global.pick.pop .attempt += relaxed_list<Node>::tls.pick.pop.attempt;
     173                        global.pick.pop .success += relaxed_list<Node>::tls.pick.pop.success;
     174                }, i++);
     175        }
     176
    105177        std::cout << "Starting" << std::endl;
    106178        auto before = Clock::now();
    … …  
    124196        duration = durr.count();
    125197        std::cout << "\rClosing down" << std::endl;
    126 }
    127 
    128 void waitfor(double & duration, barrier_t & barrier, const std::atomic_size_t & count) {
    129         std::cout << "Starting" << std::endl;
    130         auto before = Clock::now();
    131         barrier.wait(0);
    132 
    133         while(true) {
    134                 usleep(100000);
    135                 size_t c = count.load();
    136                 if( c == 0 ) {
    137                         break;
    138                 }
    139                 std::cout << "\r" << c;
    140                 std::cout.flush();
    141         }
    142 
    143         barrier.wait(0);
    144         auto after = Clock::now();
    145         duration_t durr = after - before;
    146         duration = durr.count();
    147         std::cout << "\rClosing down" << std::endl;
    148 }
    149 
    150 void print_stats(double duration, unsigned nthread, global_stat_t & global) {
     198
     199        for(auto t : threads) {
     200                t->join();
     201                delete t;
     202        }
     203
     204        enable_stats = false;
     205
     206        while(auto node = list.pop()) {
     207                global.crc_out += node->value;
     208                delete node;
     209        }
     210
    151211        assert(Node::creates == Node::destroys);
    152212        assert(global.crc_in == global.crc_out);
    … …  
    164224        std::cout << "Ops/sec       : " << ops_sec << "\n";
    165225        std::cout << "Total ops     : " << ops << "(" << global.in << "i, " << global.out << "o, " << global.empty << "e)\n";
    166         if(global.valmax != 0) {
    167                 std::cout << "Max runs      : " << global.valmax << "\n";
    168                 std::cout << "Min runs      : " << global.valmin << "\n";
    169         }
    170226        #ifndef NO_STATS
    171                 relaxed_list<Node>::stats_print(std::cout);
     227                double push_sur = (100.0 * double(global.pick.push.success) / global.pick.push.attempt);
     228                double pop_sur  = (100.0 * double(global.pick.pop .success) / global.pick.pop .attempt);
     229                std::cout << "Push Pick %   : " << push_sur << "(" << global.pick.push.success << " / " << global.pick.push.attempt << ")\n";
     230                std::cout << "Pop  Pick %   : " << pop_sur  << "(" << global.pick.pop .success << " / " << global.pick.pop .attempt << ")\n";
    172231        #endif
    173232}
    174233
    175 void save_fairness(const int data[], int factor, unsigned nthreads, size_t columns, size_t rows, const std::string & output);
    176 
    177 // ================================================================================================
    178 //                        EXPERIMENTS
    179 // ================================================================================================
    180 
    181 // ================================================================================================
    182 __attribute__((noinline)) void runChurn_body(
    183         std::atomic<bool>& done,
    184         Random & rand,
    185         Node * my_nodes[],
    186         unsigned nslots,
    187         local_stat_t & local,
    188         relaxed_list<Node> & list
    189 ) {
    190         while(__builtin_expect(!done.load(std::memory_order_relaxed), true)) {
    191                 int idx = rand.next() % nslots;
    192                 if (auto node = my_nodes[idx]) {
    193                         local.crc_in += node->value;
    194                         list.push(node);
    195                         my_nodes[idx] = nullptr;
    196                         local.in++;
    197                 }
    198                 else if(auto node = list.pop()) {
    199                         local.crc_out += node->value;
    200                         my_nodes[idx] = node;
    201                         local.out++;
    202                 }
    203                 else {
    204                         local.empty++;
    205                 }
    206         }
    207 }
    208 
    209 void runChurn(unsigned nthread, unsigned nqueues, double duration, unsigned nnodes, const unsigned nslots) {
    210         std::cout << "Churn Benchmark" << std::endl;
    211         assert(nnodes <= nslots);
    212         // List being tested
    213 
    214         // Barrier for synchronization
    215         barrier_t barrier(nthread + 1);
    216 
    217         // Data to check everything is OK
    218         global_stat_t global;
    219 
    220         // Flag to signal termination
    221         std::atomic_bool done  = { false };
    222 
    223         // Prep nodes
    224         std::cout << "Initializing ";
    225         size_t npushed = 0;
    226         relaxed_list<Node> list = { nthread * nqueues };
    227         {
    228                 Node** all_nodes[nthread];
    229                 for(auto & nodes : all_nodes) {
    230                         nodes = new __attribute__((aligned(64))) Node*[nslots + 8];
    231                         Random rand(rdtscl());
    232                         for(unsigned i = 0; i < nnodes; i++) {
    233                                 nodes[i] = new Node(rand.next() % 100);
    234                         }
    235 
    236                         for(unsigned i = nnodes; i < nslots; i++) {
    237                                 nodes[i] = nullptr;
    238                         }
    239 
    240                         for(int i = 0; i < 10 && i < (int)nslots; i++) {
    241                                 int idx = rand.next() % nslots;
    242                                 if (auto node = nodes[idx]) {
    243                                         global.crc_in += node->value;
    244                                         list.push(node);
    245                                         npushed++;
    246                                         nodes[idx] = nullptr;
    247                                 }
    248                         }
    249                 }
    250 
    251                 std::cout << nnodes << " nodes (" << nslots << " slots)" << std::endl;
    252 
    253                 enable_stats = true;
    254 
    255                 std::thread * threads[nthread];
    256                 unsigned i = 1;
    257                 for(auto & t : threads) {
    258                         auto & my_nodes = all_nodes[i - 1];
    259                         t = new std::thread([&done, &list, &barrier, &global, &my_nodes, nslots](unsigned tid) {
    260                                 Random rand(tid + rdtscl());
    261 
    262                                 local_stat_t local;
    263 
    264                                 // affinity(tid);
    265 
    266                                 barrier.wait(tid);
    267 
    268                                 // EXPERIMENT START
    269 
    270                                 runChurn_body(done, rand, my_nodes, nslots, local, list);
    271 
    272                                 // EXPERIMENT END
    273 
    274                                 barrier.wait(tid);
    275 
    276                                 tally_stats(global, local);
    277 
    278                                 for(unsigned i = 0; i < nslots; i++) {
    279                                         delete my_nodes[i];
    280                                 }
    281                         }, i++);
    282                 }
    283 
    284                 waitfor(duration, barrier, done);
    285 
    286                 for(auto t : threads) {
    287                         t->join();
    288                         delete t;
    289                 }
    290 
    291                 enable_stats = false;
    292 
    293                 while(auto node = list.pop()) {
    294                         global.crc_out += node->value;
    295                         delete node;
    296                 }
    297 
    298                 for(auto nodes : all_nodes) {
    299                         delete[] nodes;
    300                 }
    301         }
    302 
    303         print_stats(duration, nthread, global);
    304 }
    305 
    306 // ================================================================================================
    307 __attribute__((noinline)) void runPingPong_body(
    308         std::atomic<bool>& done,
    309         Node initial_nodes[],
    310         unsigned nnodes,
    311         local_stat_t & local,
    312         relaxed_list<Node> & list
    313 ) {
    314         Node * nodes[nnodes];
    315         {
    316                 unsigned i = 0;
    317                 for(auto & n : nodes) {
    318                         n = &initial_nodes[i++];
    319                 }
    320         }
    321 
    322         while(__builtin_expect(!done.load(std::memory_order_relaxed), true)) {
    323 
    324                 for(Node * & node : nodes) {
    325                         local.crc_in += node->value;
    326                         list.push(node);
    327                         local.in++;
    328                 }
    329 
    330                 // -----
    331 
    332                 for(Node * & node : nodes) {
    333                         node = list.pop();
    334                         assert(node);
    335                         local.crc_out += node->value;
    336                         local.out++;
    337                 }
    338         }
    339 }
    340 
    341 void runPingPong(unsigned nthread, unsigned nqueues, double duration, unsigned nnodes) {
    342         std::cout << "PingPong Benchmark" << std::endl;
    343 
    344 
    345         // Barrier for synchronization
    346         barrier_t barrier(nthread + 1);
    347 
    348         // Data to check everything is OK
    349         global_stat_t global;
    350 
    351         // Flag to signal termination
    352         std::atomic_bool done  = { false };
    353 
    354         std::cout << "Initializing ";
    355         // List being tested
    356         relaxed_list<Node> list = { nthread * nqueues };
    357         {
    358                 enable_stats = true;
    359 
    360                 std::thread * threads[nthread];
    361                 unsigned i = 1;
    362                 for(auto & t : threads) {
    363                         t = new std::thread([&done, &list, &barrier, &global, nnodes](unsigned tid) {
    364                                 Random rand(tid + rdtscl());
    365 
    366                                 Node nodes[nnodes];
    367                                 for(auto & n : nodes) {
    368                                         n.value = (int)rand.next() % 100;
    369                                 }
    370 
    371                                 local_stat_t local;
    372 
    373                                 // affinity(tid);
    374 
    375                                 barrier.wait(tid);
    376 
    377                                 // EXPERIMENT START
    378 
    379                                 runPingPong_body(done, nodes, nnodes, local, list);
    380 
    381                                 // EXPERIMENT END
    382 
    383                                 barrier.wait(tid);
    384 
    385                                 tally_stats(global, local);
    386                         }, i++);
    387                 }
    388 
    389                 waitfor(duration, barrier, done);
    390 
    391                 for(auto t : threads) {
    392                         t->join();
    393                         delete t;
    394                 }
    395 
    396                 enable_stats = false;
    397         }
    398 
    399         print_stats(duration, nthread, global);
    400 }
    401 
    402 // ================================================================================================
    403 __attribute__((noinline)) void runFairness_body(
    404         unsigned tid,
    405         size_t width,
    406         size_t length,
    407         int output[],
    408         std::atomic_size_t & count,
    409         Node initial_nodes[],
    410         unsigned nnodes,
    411         local_stat_t & local,
    412         relaxed_list<Node> & list
    413 ) {
    414         Node * nodes[nnodes];
    415         {
    416                 unsigned i = 0;
    417                 for(auto & n : nodes) {
    418                         n = &initial_nodes[i++];
    419                 }
    420         }
    421 
    422         while(__builtin_expect(0 != count.load(std::memory_order_relaxed), true)) {
    423 
    424                 for(Node * & node : nodes) {
    425                         local.crc_in += node->id;
    426                         list.push(node);
    427                         local.in++;
    428                 }
    429 
    430                 // -----
    431 
    432                 for(Node * & node : nodes) {
    433                         node = list.pop();
    434                         assert(node);
    435 
    436                         if (unsigned(node->value) < length) {
    437                                 size_t idx = (node->value * width) + node->id;
    438                                 assert(idx < (width * length));
    439                                 output[idx] = tid;
    440                         }
    441 
    442                         node->value++;
    443                         if(unsigned(node->value) == length) count--;
    444 
    445                         local.crc_out += node->id;
    446                         local.out++;
    447                 }
    448         }
    449 }
    450 
    451 void runFairness(unsigned nthread, unsigned nqueues, double duration, unsigned nnodes, const std::string & output) {
    452         std::cout << "Fairness Benchmark, outputing to : " << output << std::endl;
    453 
    454         // Barrier for synchronization
    455         barrier_t barrier(nthread + 1);
    456 
    457         // Data to check everything is OK
    458         global_stat_t global;
    459 
    460         std::cout << "Initializing ";
    461 
    462         // Check fairness by creating a png of where the threads ran
    463         size_t width = nthread * nnodes;
    464         size_t length = 100000;
    465 
    466         std::unique_ptr<int[]> data_out { new int[width * length] };
    467 
    468         // Flag to signal termination
    469         std::atomic_size_t count = width;
    470 
    471         // List being tested
    472         relaxed_list<Node> list = { nthread * nqueues };
    473         {
    474                 enable_stats = true;
    475 
    476                 std::thread * threads[nthread];
    477                 unsigned i = 1;
    478                 for(auto & t : threads) {
    479                         t = new std::thread([&count, &list, &barrier, &global, nnodes, width, length, data_out = data_out.get()](unsigned tid) {
    480                                 unsigned int start = (tid - 1) * nnodes;
    481                                 Node nodes[nnodes];
    482                                 for(auto & n : nodes) {
    483                                         n.id = start;
    484                                         n.value = 0;
    485                                         start++;
    486                                 }
    487 
    488                                 local_stat_t local;
    489 
    490                                 // affinity(tid);
    491 
    492                                 barrier.wait(tid);
    493 
    494                                 // EXPERIMENT START
    495 
    496                                 runFairness_body(tid, width, length, data_out, count, nodes, nnodes, local, list);
    497 
    498                                 // EXPERIMENT END
    499 
    500                                 barrier.wait(tid);
    501 
    502                                 for(const auto & n : nodes) {
    503                                         local.valmax = max(local.valmax, size_t(n.value));
    504                                         local.valmin = min(local.valmin, size_t(n.value));
    505                                 }
    506 
    507                                 tally_stats(global, local);
    508                         }, i++);
    509                 }
    510 
    511                 waitfor(duration, barrier, count);
    512 
    513                 for(auto t : threads) {
    514                         t->join();
    515                         delete t;
    516                 }
    517 
    518                 enable_stats = false;
    519         }
    520 
    521         print_stats(duration, nthread, global);
    522 
    523         save_fairness(data_out.get(), 100, nthread, width, length, output);
    524 }
    525 
    526 // ================================================================================================
    527 
    528 bool iequals(const std::string& a, const std::string& b)
    529 {
    530     return std::equal(a.begin(), a.end(),
    531                       b.begin(), b.end(),
    532                       [](char a, char b) {
    533                           return std::tolower(a) == std::tolower(b);
    534                       });
     234void usage(char * argv[]) {
     235        std::cerr << argv[0] << ": [DURATION (FLOAT:SEC)] [NTHREADS] [NQUEUES] [FILL]" << std::endl;;
     236        std::exit(1);
    535237}
    536238
    … …  
    539241        double duration   = 5.0;
    540242        unsigned nthreads = 2;
    541         unsigned nqueues  = 4;
    542         unsigned nnodes   = 100;
    543         unsigned nslots   = 100;
    544         std::string out   = "fairness.png";
    545 
    546         enum {
    547                 Churn,
    548                 PingPong,
    549                 Fairness,
    550                 NONE
    551         } benchmark = NONE;
     243        unsigned nqueues  = 2;
     244        unsigned fill     = 100;
    552245
    553246        std::cout.imbue(std::locale(""));
    554247
    555         for(;;) {
    556                 static struct option options[] = {
    557                         {"duration",  required_argument, 0, 'd'},
    558                         {"nthreads",  required_argument, 0, 't'},
    559                         {"nqueues",   required_argument, 0, 'q'},
    560                         {"benchmark", required_argument, 0, 'b'},
    561                         {0, 0, 0, 0}
    562                 };
    563 
    564                 int idx = 0;
    565                 int opt = getopt_long(argc, argv, "d:t:q:b:", options, &idx);
    566 
    567                 std::string arg = optarg ? optarg : "";
    568                 size_t len = 0;
    569                 switch(opt) {
    570                         // Exit Case
    571                         case -1:
    572                                 /* paranoid */ assert(optind <= argc);
    573                                 switch(benchmark) {
    574                                 case NONE:
    575                                         std::cerr << "Must specify a benchmark" << std::endl;
    576                                         goto usage;
    577                                 case PingPong:
    578                                         nnodes = 1;
    579                                         nslots = 1;
    580                                         switch(argc - optind) {
    581                                         case 0: break;
    582                                         case 1:
    583                                                 try {
    584                                                         arg = optarg = argv[optind];
    585                                                         nnodes = stoul(optarg, &len);
    586                                                         if(len != arg.size()) { throw std::invalid_argument(""); }
    587                                                 } catch(std::invalid_argument &) {
    588                                                         std::cerr << "Number of nodes must be a positive integer, was " << arg << std::endl;
    589                                                         goto usage;
    590                                                 }
    591                                                 break;
    592                                         default:
    593                                                 std::cerr << "'PingPong' benchmark doesn't accept more than 2 extra arguments" << std::endl;
    594                                                 goto usage;
    595                                         }
    596                                         break;
    597                                 case Churn:
    598                                         nnodes = 100;
    599                                         nslots = 100;
    600                                         switch(argc - optind) {
    601                                         case 0: break;
    602                                         case 1:
    603                                                 try {
    604                                                         arg = optarg = argv[optind];
    605                                                         nnodes = stoul(optarg, &len);
    606                                                         if(len != arg.size()) { throw std::invalid_argument(""); }
    607                                                         nslots = nnodes;
    608                                                 } catch(std::invalid_argument &) {
    609                                                         std::cerr << "Number of nodes must be a positive integer, was " << arg << std::endl;
    610                                                         goto usage;
    611                                                 }
    612                                                 break;
    613                                         case 2:
    614                                                 try {
    615                                                         arg = optarg = argv[optind];
    616                                                         nnodes = stoul(optarg, &len);
    617                                                         if(len != arg.size()) { throw std::invalid_argument(""); }
    618                                                 } catch(std::invalid_argument &) {
    619                                                         std::cerr << "Number of nodes must be a positive integer, was " << arg << std::endl;
    620                                                         goto usage;
    621                                                 }
    622                                                 try {
    623                                                         arg = optarg = argv[optind + 1];
    624                                                         nslots = stoul(optarg, &len);
    625                                                         if(len != arg.size()) { throw std::invalid_argument(""); }
    626                                                 } catch(std::invalid_argument &) {
    627                                                         std::cerr << "Number of slots must be a positive integer, was " << arg << std::endl;
    628                                                         goto usage;
    629                                                 }
    630                                                 break;
    631                                         default:
    632                                                 std::cerr << "'Churn' benchmark doesn't accept more than 2 extra arguments" << std::endl;
    633                                                 goto usage;
    634                                         }
    635                                         break;
    636                                 case Fairness:
    637                                         nnodes = 1;
    638                                         switch(argc - optind) {
    639                                         case 0: break;
    640                                         case 1:
    641                                                 arg = optarg = argv[optind];
    642                                                 out = arg;
    643                                                 break;
    644                                         default:
    645                                                 std::cerr << "'Churn' benchmark doesn't accept more than 2 extra arguments" << std::endl;
    646                                                 goto usage;
    647                                         }
    648                                 }
    649                                 goto run;
    650                         // Benchmarks
    651                         case 'b':
    652                                 if(benchmark != NONE) {
    653                                         std::cerr << "Only when benchmark can be run" << std::endl;
    654                                         goto usage;
    655                                 }
    656                                 if(iequals(arg, "churn")) {
    657                                         benchmark = Churn;
    658                                         break;
    659                                 }
    660                                 if(iequals(arg, "pingpong")) {
    661                                         benchmark = PingPong;
    662                                         break;
    663                                 }
    664                                 if(iequals(arg, "fairness")) {
    665                                         benchmark = Fairness;
    666                                         break;
    667                                 }
    668                                 std::cerr << "Unkown benchmark " << arg << std::endl;
    669                                 goto usage;
    670                         // Numeric Arguments
    671                         case 'd':
    672                                 try {
    673                                         duration = stod(optarg, &len);
    674                                         if(len != arg.size()) { throw std::invalid_argument(""); }
    675                                 } catch(std::invalid_argument &) {
    676                                         std::cerr << "Duration must be a valid double, was " << arg << std::endl;
    677                                         goto usage;
    678                                 }
    679                                 break;
    680                         case 't':
    681                                 try {
    682                                         nthreads = stoul(optarg, &len);
    683                                         if(len != arg.size()) { throw std::invalid_argument(""); }
    684                                 } catch(std::invalid_argument &) {
    685                                         std::cerr << "Number of threads must be a positive integer, was " << arg << std::endl;
    686                                         goto usage;
    687                                 }
    688                                 break;
    689                         case 'q':
    690                                 try {
    691                                         nqueues = stoul(optarg, &len);
    692                                         if(len != arg.size()) { throw std::invalid_argument(""); }
    693                                 } catch(std::invalid_argument &) {
    694                                         std::cerr << "Number of queues must be a positive integer, was " << arg << std::endl;
    695                                         goto usage;
    696                                 }
    697                                 break;
    698                         // Other cases
    699                         default: /* ? */
    700                                 std::cerr << opt << std::endl;
    701                         usage:
    702                                 std::cerr << "Usage: " << argv[0] << ": [options] -b churn [NNODES] [NSLOTS = NNODES]" << std::endl;
    703                                 std::cerr << "  or:  " << argv[0] << ": [options] -b pingpong [NNODES]" << std::endl;
    704                                 std::cerr << std::endl;
    705                                 std::cerr << "  -d, --duration=DURATION  Duration of the experiment, in seconds" << std::endl;
    706                                 std::cerr << "  -t, --nthreads=NTHREADS  Number of kernel threads" << std::endl;
    707                                 std::cerr << "  -q, --nqueues=NQUEUES    Number of queues per threads" << std::endl;
    708                                 std::exit(1);
    709                 }
    710         }
    711         run:
     248        switch (argc)
     249        {
     250        case 5:
     251                fill = std::stoul(argv[4]);
     252                [[fallthrough]];
     253        case 4:
     254                nqueues = std::stoul(argv[3]);
     255                [[fallthrough]];
     256        case 3:
     257                nthreads = std::stoul(argv[2]);
     258                [[fallthrough]];
     259        case 2:
     260                duration = std::stod(argv[1]);
     261                if( duration <= 0.0 ) {
     262                        std::cerr << "Duration must be positive, was " << argv[1] << "(" << duration << ")" << std::endl;
     263                        usage(argv);
     264                }
     265                [[fallthrough]];
     266        case 1:
     267                break;
     268        default:
     269                usage(argv);
     270                break;
     271        }
    712272
    713273        check_cache_line_size();
    714274
    715275        std::cout << "Running " << nthreads << " threads (" << (nthreads * nqueues) << " queues) for " << duration << " seconds" << std::endl;
    716         switch(benchmark) {
    717                 case Churn:
    718                         runChurn(nthreads, nqueues, duration, nnodes, nslots);
    719                         break;
    720                 case PingPong:
    721                         runPingPong(nthreads, nqueues, duration, nnodes);
    722                         break;
    723                 case Fairness:
    724                         runFairness(nthreads, nqueues, duration, nnodes, out);
    725                         break;
    726                 default:
    727                         abort();
    728         }
     276        run(nthreads, nqueues, fill, duration);
     277
    729278        return 0;
    730279}
    731280
     281template<>
     282thread_local relaxed_list<Node>::TLS relaxed_list<Node>::tls = {};
     283
     284template<>
     285relaxed_list<Node>::intrusive_queue_t::stat::Dif relaxed_list<Node>::intrusive_queue_t::stat::dif = {};
     286
    732287const char * __my_progname = "Relaxed List";
    733 
    734 struct rgb_t {
    735     double r;       // a fraction between 0 and 1
    736     double g;       // a fraction between 0 and 1
    737     double b;       // a fraction between 0 and 1
    738 };
    739 
    740 struct hsv_t {
    741     double h;       // angle in degrees
    742     double s;       // a fraction between 0 and 1
    743     double v;       // a fraction between 0 and 1
    744 };
    745 
    746 rgb_t hsv2rgb(hsv_t in) {
    747         double hh, p, q, t, ff;
    748         long   i;
    749         rgb_t  out;
    750 
    751         if(in.s <= 0.0) {       // < is bogus, just shuts up warnings
    752                 out.r = in.v;
    753                 out.g = in.v;
    754                 out.b = in.v;
    755                 return out;
    756         }
    757         hh = in.h;
    758         if(hh >= 360.0) hh = 0.0;
    759         hh /= 60.0;
    760         i = (long)hh;
    761         ff = hh - i;
    762         p = in.v * (1.0 - in.s);
    763         q = in.v * (1.0 - (in.s * ff));
    764         t = in.v * (1.0 - (in.s * (1.0 - ff)));
    765 
    766         switch(i) {
    767         case 0:
    768                 out.r = in.v;
    769                 out.g = t;
    770                 out.b = p;
    771                 break;
    772         case 1:
    773                 out.r = q;
    774                 out.g = in.v;
    775                 out.b = p;
    776                 break;
    777         case 2:
    778                 out.r = p;
    779                 out.g = in.v;
    780                 out.b = t;
    781                 break;
    782 
    783         case 3:
    784                 out.r = p;
    785                 out.g = q;
    786                 out.b = in.v;
    787                 break;
    788         case 4:
    789                 out.r = t;
    790                 out.g = p;
    791                 out.b = in.v;
    792                 break;
    793         case 5:
    794         default:
    795                 out.r = in.v;
    796                 out.g = p;
    797                 out.b = q;
    798                 break;
    799         }
    800         return out;
    801 }
    802 
    803 void save_fairness(const int data[], int factor, unsigned nthreads, size_t columns, size_t rows, const std::string & output) {
    804         std::ofstream os(output);
    805         os << "<html>\n";
    806         os << "<head>\n";
    807         os << "<style>\n";
    808         os << "</style>\n";
    809         os << "</head>\n";
    810         os << "<body>\n";
    811         os << "<table style=\"width=100%\">\n";
    812 
    813         size_t idx = 0;
    814         for(size_t r = 0ul; r < rows; r++) {
    815                 os << "<tr>\n";
    816                 for(size_t c = 0ul; c < columns; c++) {
    817                         os << "<td class=\"custom custom" << data[idx] << "\"></td>\n";
    818                         idx++;
    819                 }
    820                 os << "</tr>\n";
    821         }
    822 
    823         os << "</table>\n";
    824         os << "</body>\n";
    825         os << "</html>\n";
    826         os << std::endl;
    827 }
    828 
    829 #include <png.h>
    830 #include <setjmp.h>
    831 
    832 /*
    833 void save_fairness(const int data[], int factor, unsigned nthreads, size_t columns, size_t rows, const std::string & output) {
    834         int width  = columns * factor;
    835         int height = rows / factor;
    836 
    837         int code = 0;
    838         int idx = 0;
    839         FILE *fp = NULL;
    840         png_structp png_ptr = NULL;
    841         png_infop info_ptr = NULL;
    842         png_bytep row = NULL;
    843 
    844         // Open file for writing (binary mode)
    845         fp = fopen(output.c_str(), "wb");
    846         if (fp == NULL) {
    847                 fprintf(stderr, "Could not open file %s for writing\n", output.c_str());
    848                 code = 1;
    849                 goto finalise;
    850         }
    851 
    852            // Initialize write structure
    853         png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
    854         if (png_ptr == NULL) {
    855                 fprintf(stderr, "Could not allocate write struct\n");
    856                 code = 1;
    857                 goto finalise;
    858         }
    859 
    860         // Initialize info structure
    861         info_ptr = png_create_info_struct(png_ptr);
    862         if (info_ptr == NULL) {
    863                 fprintf(stderr, "Could not allocate info struct\n");
    864                 code = 1;
    865                 goto finalise;
    866         }
    867 
    868         // Setup Exception handling
    869         if (setjmp(png_jmpbuf(png_ptr))) {
    870                 fprintf(stderr, "Error during png creation\n");
    871                 code = 1;
    872                 goto finalise;
    873         }
    874 
    875         png_init_io(png_ptr, fp);
    876 
    877         // Write header (8 bit colour depth)
    878         png_set_IHDR(png_ptr, info_ptr, width, height,
    879                 8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
    880                 PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
    881 
    882         png_write_info(png_ptr, info_ptr);
    883 
    884         // Allocate memory for one row (3 bytes per pixel - RGB)
    885         row = (png_bytep) malloc(3 * width * sizeof(png_byte));
    886 
    887         // Write image data
    888         int x, y;
    889         for (y=0 ; y<height ; y++) {
    890                 for (x=0 ; x<width ; x++) {
    891                         auto & r = row[(x * 3) + 0];
    892                         auto & g = row[(x * 3) + 1];
    893                         auto & b = row[(x * 3) + 2];
    894                         assert(idx < (rows * columns));
    895                         int color = data[idx] - 1;
    896                         assert(color < nthreads);
    897                         assert(color >= 0);
    898                         idx++;
    899 
    900                         double angle = double(color) / double(nthreads);
    901 
    902                         auto c = hsv2rgb({ 360.0 * angle, 0.8, 0.8 });
    903 
    904                         r = char(c.r * 255.0);
    905                         g = char(c.g * 255.0);
    906                         b = char(c.b * 255.0);
    907 
    908                 }
    909                 png_write_row(png_ptr, row);
    910         }
    911 
    912         assert(idx == (rows * columns));
    913 
    914         // End write
    915         png_write_end(png_ptr, NULL);
    916 
    917         finalise:
    918         if (fp != NULL) fclose(fp);
    919         if (info_ptr != NULL) png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
    920         if (png_ptr != NULL) png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
    921         if (row != NULL) free(row);
    922 }
    923 */

  • doc/theses/thierry_delisle_PhD/code/relaxed_list.hpp

    rb7d6a36 rdca5802  
    3737};
    3838
    39 static inline bool bts(std::atomic_size_t & target, size_t bit ) {
    40         //*
    41         int result = 0;
    42         asm volatile(
    43                 "LOCK btsq %[bit], %[target]\n\t"
    44                 :"=@ccc" (result)
    45                 : [target] "m" (target), [bit] "r" (bit)
    46         );
    47         return result != 0;
    48         /*/
    49         size_t mask = 1ul << bit;
    50         size_t ret = target.fetch_or(mask, std::memory_order_relaxed);
    51         return (ret & mask) != 0;
    52         //*/
    53 }
    54 
    55 static inline bool btr(std::atomic_size_t & target, size_t bit ) {
    56         //*
    57         int result = 0;
    58         asm volatile(
    59                 "LOCK btrq %[bit], %[target]\n\t"
    60                 :"=@ccc" (result)
    61                 : [target] "m" (target), [bit] "r" (bit)
    62         );
    63         return result != 0;
    64         /*/
    65         size_t mask = 1ul << bit;
    66         size_t ret = target.fetch_and(~mask, std::memory_order_relaxed);
    67         return (ret & mask) != 0;
    68         //*/
    69 }
    7039
    7140extern bool enable_stats;
    … …  
    7948                size_t attempt = 0;
    8049                size_t success = 0;
    81                 size_t mask_attempt = 0;
    82         } pop;
    83 };
    84 
    85 struct empty_stat {
    86         struct {
    87                 size_t value = 0;
    88                 size_t count = 0;
    89         } push;
    90         struct {
    91                 size_t value = 0;
    92                 size_t count = 0;
    9350        } pop;
    9451};
    … …  
    10562        static_assert(std::is_same<decltype(node_t::_links), _LinksFields_t<node_t>>::value, "Node must have a links field");
    10663
     64
    10765public:
    10866        relaxed_list(unsigned numLists)
    109                 : lists(new intrusive_queue_t[numLists])
     67                : numNonEmpty{0}
     68                , lists(new intrusive_queue_t[numLists])
    11069                , numLists(numLists)
    111         {
    112                 assertf(7 * 8 * 8 >= numLists, "List currently only supports 448 sublists");
    113                 // assert(sizeof(*this) == 128);
    114                 std::cout << "Constructing Relaxed List with " << numLists << std::endl;
    115 
     70        {}
     71
     72        ~relaxed_list() {
     73                lists.reset();
    11674                #ifndef NO_STATS
    117                         if(head) this->next = head;
    118                         head = this;
     75                        std::cout << "Difference   : "
     76                                << ssize_t(double(intrusive_queue_t::stat::dif.value) / intrusive_queue_t::stat::dif.num  ) << " avg\t"
     77                                << intrusive_queue_t::stat::dif.max << "max" << std::endl;
    11978                #endif
    120         }
    121 
    122         ~relaxed_list() {
    123                 std::cout << "Destroying Relaxed List" << std::endl;
    124                 lists.reset();
    12579        }
    12680
    … …  
    13084                while(true) {
    13185                        // Pick a random list
    132                         unsigned i = tls.rng.next() % numLists;
     86                        int i = tls.rng.next() % numLists;
    13387
    13488                        #ifndef NO_STATS
    … …  
    13993                        if( !lists[i].lock.try_lock() ) continue;
    14094
    141                         __attribute__((unused)) int num = numNonEmpty;
    142 
    14395                        // Actually push it
    144                         if(lists[i].push(node)) {
    145                                 numNonEmpty++;
    146                                 size_t qword = i >> 6ull;
    147                                 size_t bit   = i & 63ull;
    148                                 assertf((list_mask[qword] & (1ul << bit)) == 0, "Before set %zu:%zu (%u), %zx & %zx", qword, bit, i, list_mask[qword].load(), (1ul << bit));
    149                                 __attribute__((unused)) bool ret = bts(list_mask[qword], bit);
    150                                 assert(!ret);
    151                                 assertf((list_mask[qword] & (1ul << bit)) != 0, "After set %zu:%zu (%u), %zx & %zx", qword, bit, i, list_mask[qword].load(), (1ul << bit));
    152                         }
     96                        lists[i].push(node, numNonEmpty);
    15397                        assert(numNonEmpty <= (int)numLists);
    15498
    … …  
    158102                        #ifndef NO_STATS
    159103                                tls.pick.push.success++;
    160                                 tls.empty.push.value += num;
    161                                 tls.empty.push.count += 1;
    162104                        #endif
    163105                        return;
    … …  
    166108
    167109        __attribute__((noinline, hot)) node_t * pop() {
    168                 #if !defined(NO_BITMASK)
    169                         // for(int r = 0; r < 10 && numNonEmpty != 0; r++) {
    170                         //      // Pick two lists at random
    171                         //      unsigned i = tls.rng.next() % numLists;
    172                         //      unsigned j = tls.rng.next() % numLists;
    173 
    174                         //      if(auto node = try_pop(i, j)) return node;
    175                         // }
    176                         int nnempty;
    177                         while(0 != (nnempty = numNonEmpty)) {
    178                                 tls.pick.pop.mask_attempt++;
    179                                 unsigned i, j;
    180                                 // if( numLists < 4 || (numLists / nnempty) < 4 ) {
    181                                 //      // Pick two lists at random
    182                                 //      i = tls.rng.next() % numLists;
    183                                 //      j = tls.rng.next() % numLists;
    184                                 // } else
    185                                 {
    186                                         #ifndef NO_STATS
    187                                                 // tls.pick.push.mask_attempt++;
    188                                         #endif
    189 
    190                                         // Pick two lists at random
    191                                         unsigned num = ((numLists - 1) >> 6) + 1;
    192 
    193                                         unsigned ri = tls.rng.next();
    194                                         unsigned rj = tls.rng.next();
    195 
    196                                         unsigned wdxi = (ri >> 6u) % num;
    197                                         unsigned wdxj = (rj >> 6u) % num;
    198 
    199                                         size_t maski = list_mask[wdxi].load(std::memory_order_relaxed);
    200                                         size_t maskj = list_mask[wdxj].load(std::memory_order_relaxed);
    201 
    202                                         if(maski == 0 && maskj == 0) continue;
    203 
    204                                         unsigned bi = rand_bit(ri, maski);
    205                                         unsigned bj = rand_bit(rj, maskj);
    206 
    207                                         assertf(bi < 64, "%zu %u", maski, bi);
    208                                         assertf(bj < 64, "%zu %u", maskj, bj);
    209 
    210                                         i = bi | (wdxi << 6);
    211                                         j = bj | (wdxj << 6);
    212 
    213                                         assertf(i < numLists, "%u", wdxi << 6);
    214                                         assertf(j < numLists, "%u", wdxj << 6);
    215                                 }
    216 
    217                                 if(auto node = try_pop(i, j)) return node;
    218                         }
    219                 #else
    220                         while(numNonEmpty != 0) {
    221                                 // Pick two lists at random
    222                                 int i = tls.rng.next() % numLists;
    223                                 int j = tls.rng.next() % numLists;
    224 
    225                                 if(auto node = try_pop(i, j)) return node;
    226                         }
    227                 #endif
     110                while(numNonEmpty != 0) {
     111                        // Pick two lists at random
     112                        int i = tls.rng.next() % numLists;
     113                        int j = tls.rng.next() % numLists;
     114
     115                        #ifndef NO_STATS
     116                                tls.pick.pop.attempt++;
     117                        #endif
     118
     119                        // Pick the bet list
     120                        int w = i;
     121                        if( __builtin_expect(lists[j].ts() != 0, true) ) {
     122                                w = (lists[i].ts() < lists[j].ts()) ? i : j;
     123                        }
     124
     125                        auto & list = lists[w];
     126                        // If list looks empty retry
     127                        if( list.ts() == 0 ) continue;
     128
     129                        // If we can't get the lock retry
     130                        if( !list.lock.try_lock() ) continue;
     131
     132                        // If list is empty, unlock and retry
     133                        if( list.ts() == 0 ) {
     134                                list.lock.unlock();
     135                                continue;
     136                        }
     137
     138                        // Actually pop the list
     139                        auto node = list.pop(numNonEmpty);
     140                        assert(node);
     141
     142                        // Unlock and return
     143                        list.lock.unlock();
     144                        assert(numNonEmpty >= 0);
     145                        #ifndef NO_STATS
     146                                tls.pick.pop.success++;
     147                        #endif
     148                        return node;
     149                }
    228150
    229151                return nullptr;
    230152        }
    231 
    232 private:
    233         node_t * try_pop(unsigned i, unsigned j) {
    234                 #ifndef NO_STATS
    235                         tls.pick.pop.attempt++;
    236                 #endif
    237 
    238                 // Pick the bet list
    239                 int w = i;
    240                 if( __builtin_expect(lists[j].ts() != 0, true) ) {
    241                         w = (lists[i].ts() < lists[j].ts()) ? i : j;
    242                 }
    243 
    244                 auto & list = lists[w];
    245                 // If list looks empty retry
    246                 if( list.ts() == 0 ) return nullptr;
    247 
    248                 // If we can't get the lock retry
    249                 if( !list.lock.try_lock() ) return nullptr;
    250 
    251                 __attribute__((unused)) int num = numNonEmpty;
    252 
    253                 // If list is empty, unlock and retry
    254                 if( list.ts() == 0 ) {
    255                         list.lock.unlock();
    256                         return nullptr;
    257                 }
    258 
    259                 // Actually pop the list
    260                 node_t * node;
    261                 bool emptied;
    262                 std::tie(node, emptied) = list.pop();
    263                 assert(node);
    264 
    265                 if(emptied) {
    266                         numNonEmpty--;
    267                         size_t qword = w >> 6ull;
    268                         size_t bit   = w & 63ull;
    269                         assert((list_mask[qword] & (1ul << bit)) != 0);
    270                         __attribute__((unused)) bool ret = btr(list_mask[qword], bit);
    271                         assert(ret);
    272                         assert((list_mask[qword] & (1ul << bit)) == 0);
    273                 }
    274 
    275                 // Unlock and return
    276                 list.lock.unlock();
    277                 assert(numNonEmpty >= 0);
    278                 #ifndef NO_STATS
    279                         tls.pick.pop.success++;
    280                         tls.empty.pop.value += num;
    281                         tls.empty.pop.count += 1;
    282                 #endif
    283                 return node;
    284         }
    285153
    286154private:
    … …  
    294162                struct stat {
    295163                        ssize_t diff = 0;
    296                         size_t  push = 0;
    297                         size_t  pop  = 0;
    298                         // size_t value = 0;
    299                         // size_t count = 0;
     164
     165                        static struct Dif {
     166                                ssize_t value = 0;
     167                                size_t  num   = 0;
     168                                ssize_t max   = 0;
     169                        } dif;
    300170                };
    301171
    … …  
    308178                sentinel_t before;
    309179                sentinel_t after;
    310                 #ifndef NO_STATS
    311                         stat s;
    312                 #endif
    313 
    314 #pragma GCC diagnostic push
    315 #pragma GCC diagnostic ignored "-Winvalid-offsetof"
     180                stat s;
     181
    316182                static constexpr auto fields_offset = offsetof( node_t, _links );
    317 #pragma GCC diagnostic pop
    318183        public:
    319184                intrusive_queue_t()
    … …  
    321186                        , after {{ head(), nullptr }}
    322187                {
    323                         /* paranoid */ assert((reinterpret_cast<uintptr_t>( head() ) + fields_offset) == reinterpret_cast<uintptr_t>(&before));
    324                         /* paranoid */ assert((reinterpret_cast<uintptr_t>( tail() ) + fields_offset) == reinterpret_cast<uintptr_t>(&after ));
    325                         /* paranoid */ assert(head()->_links.prev == nullptr);
    326                         /* paranoid */ assert(head()->_links.next == tail() );
    327                         /* paranoid */ assert(tail()->_links.next == nullptr);
    328                         /* paranoid */ assert(tail()->_links.prev == head() );
    329                         /* paranoid */ assert(sizeof(*this) == 128);
    330                         /* paranoid */ assert((intptr_t(this) % 128) == 0);
    331                 }
    332 
    333                 ~intrusive_queue_t() = default;
     188                        assert((reinterpret_cast<uintptr_t>( head() ) + fields_offset) == reinterpret_cast<uintptr_t>(&before));
     189                        assert((reinterpret_cast<uintptr_t>( tail() ) + fields_offset) == reinterpret_cast<uintptr_t>(&after ));
     190                        assert(head()->_links.prev == nullptr);
     191                        assert(head()->_links.next == tail() );
     192                        assert(tail()->_links.next == nullptr);
     193                        assert(tail()->_links.prev == head() );
     194                        assert(sizeof(*this) == 128);
     195                        assert((intptr_t(this) % 128) == 0);
     196                }
     197
     198                ~intrusive_queue_t() {
     199                        #ifndef NO_STATS
     200                                stat::dif.value+= s.diff;
     201                                stat::dif.num  ++;
     202                                stat::dif.max  = std::abs(stat::dif.max) > std::abs(s.diff) ? stat::dif.max : s.diff;
     203                        #endif
     204                }
    334205
    335206                inline node_t * head() const {
    … …  
    349220                }
    350221
    351                 inline bool push(node_t * node) {
     222                inline void push(node_t * node, std::atomic_int & nonEmpty) {
    352223                        assert(lock);
    353224                        assert(node->_links.ts != 0);
    … …  
    361232                        prev->_links.next = node;
    362233                        tail->_links.prev = node;
    363                         #ifndef NO_STATS
    364                                 if(enable_stats) {
    365                                         s.diff++;
    366                                         s.push++;
    367                                 }
    368                         #endif
    369234                        if(before._links.ts == 0l) {
     235                                nonEmpty += 1;
    370236                                before._links.ts = node->_links.ts;
    371                                 assert(node->_links.prev == this->head());
    372                                 return true;
    373                         }
    374                         return false;
    375                 }
    376 
    377                 inline std::pair<node_t *, bool> pop() {
     237                        }
     238                        #ifndef NO_STATS
     239                                if(enable_stats) s.diff++;
     240                        #endif
     241                }
     242
     243                inline node_t * pop(std::atomic_int & nonEmpty) {
    378244                        assert(lock);
    379245                        node_t * head = this->head();
    … …  
    382248                        node_t * node = head->_links.next;
    383249                        node_t * next = node->_links.next;
    384                         if(node == tail) return {nullptr, false};
     250                        if(node == tail) return nullptr;
    385251
    386252                        head->_links.next = next;
    387253                        next->_links.prev = head;
    388254
    389                         #ifndef NO_STATS
    390                                 if(enable_stats) {
    391                                         s.diff--;
    392                                         s.pop ++;
    393                                 }
    394                         #endif
    395255                        if(next == tail) {
    396256                                before._links.ts = 0l;
    397                                 return {node, true};
     257                                nonEmpty -= 1;
    398258                        }
    399259                        else {
    … …  
    401261                                before._links.ts = next->_links.ts;
    402262                                assert(before._links.ts != 0);
    403                                 return {node, false};
    404                         }
     263                        }
     264                        #ifndef NO_STATS
     265                                if(enable_stats) s.diff--;
     266                        #endif
     267                        return node;
    405268                }
    406269
    … …  
    414277
    415278        static __attribute__((aligned(128))) thread_local struct TLS {
    416                 Random     rng = { int(rdtscl()) };
    417                 pick_stat  pick;
    418                 empty_stat empty;
     279                Random    rng = { int(rdtscl()) };
     280                pick_stat pick;
    419281        } tls;
    420282
    421 public:
    422         std::atomic_int numNonEmpty  = { 0 };  // number of non-empty lists
    423         std::atomic_size_t list_mask[7] = { {0}, {0}, {0}, {0}, {0}, {0}, {0} }; // which queues are empty
    424283private:
     284        std::atomic_int numNonEmpty; // number of non-empty lists
    425285        __attribute__((aligned(64))) std::unique_ptr<intrusive_queue_t []> lists;
    426286        const unsigned numLists;
    … …  
    428288public:
    429289        static const constexpr size_t sizeof_queue = sizeof(intrusive_queue_t);
    430 
    431 #ifndef NO_STATS
    432         static void stats_print(std::ostream & os) {
    433                 auto it = head;
    434                 while(it) {
    435                         it->stats_print_local(os);
    436                         it = it->next;
    437                 }
    438         }
    439 
    440         static void stats_tls_tally() {
    441                 global_stats.pick.push.attempt += tls.pick.push.attempt;
    442                 global_stats.pick.push.success += tls.pick.push.success;
    443                 global_stats.pick.pop .attempt += tls.pick.pop.attempt;
    444                 global_stats.pick.pop .success += tls.pick.pop.success;
    445                 global_stats.pick.pop .mask_attempt += tls.pick.pop.mask_attempt;
    446 
    447                 global_stats.qstat.push.value += tls.empty.push.value;
    448                 global_stats.qstat.push.count += tls.empty.push.count;
    449                 global_stats.qstat.pop .value += tls.empty.pop .value;
    450                 global_stats.qstat.pop .count += tls.empty.pop .count;
    451         }
    452 
    453 private:
    454         static struct GlobalStats {
    455                 struct {
    456                         struct {
    457                                 std::atomic_size_t attempt = { 0 };
    458                                 std::atomic_size_t success = { 0 };
    459                         } push;
    460                         struct {
    461                                 std::atomic_size_t attempt = { 0 };
    462                                 std::atomic_size_t success = { 0 };
    463                                 std::atomic_size_t mask_attempt = { 0 };
    464                         } pop;
    465                 } pick;
    466                 struct {
    467                         struct {
    468                                 std::atomic_size_t value = { 0 };
    469                                 std::atomic_size_t count = { 0 };
    470                         } push;
    471                         struct {
    472                                 std::atomic_size_t value = { 0 };
    473                                 std::atomic_size_t count = { 0 };
    474                         } pop;
    475                 } qstat;
    476         } global_stats;
    477 
    478         // Link list of all lists for stats
    479         __attribute__((aligned(64))) relaxed_list<node_t> * next = nullptr;
    480 
    481         static relaxed_list<node_t> * head;
    482 
    483         void stats_print_local(std::ostream & os ) {
    484                 std::cout << "----- Relaxed List Stats -----" << std::endl;
    485                 {
    486                         ssize_t diff = 0;
    487                         size_t  num  = 0;
    488                         ssize_t max  = 0;
    489 
    490                         for(size_t i = 0; i < numLists; i++) {
    491                                 const auto & list = lists[i];
    492                                 diff+= list.s.diff;
    493                                 num ++;
    494                                 max  = std::abs(max) > std::abs(list.s.diff) ? max : list.s.diff;
    495                                 os << "Local Q ops   : " << (list.s.push + list.s.pop) << "(" << list.s.push << "i, " << list.s.pop << "o)\n";
    496                         }
    497 
    498                         os << "Difference   : " << ssize_t(double(diff) / num  ) << " avg\t" << max << "max" << std::endl;
    499                 }
    500 
    501                 const auto & global = global_stats;
    502 
    503                 double push_sur = (100.0 * double(global.pick.push.success) / global.pick.push.attempt);
    504                 double pop_sur  = (100.0 * double(global.pick.pop .success) / global.pick.pop .attempt);
    505                 double mpop_sur = (100.0 * double(global.pick.pop .success) / global.pick.pop .mask_attempt);
    506 
    507                 os << "Push   Pick % : " << push_sur << "(" << global.pick.push.success << " / " << global.pick.push.attempt << ")\n";
    508                 os << "Pop    Pick % : " << pop_sur  << "(" << global.pick.pop .success << " / " << global.pick.pop .attempt << ")\n";
    509                 os << "TryPop Pick % : " << mpop_sur << "(" << global.pick.pop .success << " / " << global.pick.pop .mask_attempt << ")\n";
    510 
    511                 double avgQ_push = double(global.qstat.push.value) / global.qstat.push.count;
    512                 double avgQ_pop  = double(global.qstat.pop .value) / global.qstat.pop .count;
    513                 double avgQ      = double(global.qstat.push.value + global.qstat.pop .value) / (global.qstat.push.count + global.qstat.pop .count);
    514                 os << "Push   Avg Qs : " << avgQ_push << " (" << global.qstat.push.count << "ops)\n";
    515                 os << "Pop    Avg Qs : " << avgQ_pop  << " (" << global.qstat.pop .count << "ops)\n";
    516                 os << "Global Avg Qs : " << avgQ      << " (" << (global.qstat.push.count + global.qstat.pop .count) << "ops)\n";
    517         }
    518 #endif
    519 };
     290};

  • doc/theses/thierry_delisle_PhD/code/utils.hpp

    rb7d6a36 rdca5802  
    1010#include <unistd.h>
    1111#include <sys/sysinfo.h>
    12 
    13 #include <x86intrin.h>
    1412
    1513// Barrier from
    … …  
    5856}
    5957
    60 static inline void affinity(int tid) {
     58void affinity(int tid) {
    6159        static int cpus = get_nprocs();
    6260
    … …  
    7270
    7371static const constexpr std::size_t cache_line_size = 64;
    74 static inline void check_cache_line_size() {
     72void check_cache_line_size() {
    7573        std::cout << "Checking cache line size" << std::endl;
    7674        const std::string cache_file = "/sys/devices/system/cpu/cpu0/cache/index0/coherency_line_size";
    … …  
    105103        return std::chrono::duration_cast<std::chrono::duration<T, Ratio>>(std::chrono::duration<T>(seconds)).count();
    106104}
    107 
    108 static inline unsigned rand_bit(unsigned rnum, size_t mask) {
    109         unsigned bit = mask ? rnum % __builtin_popcountl(mask) : 0;
    110 #if !defined(__BMI2__)
    111         uint64_t v = mask;   // Input value to find position with rank r.
    112         unsigned int r = bit + 1;// Input: bit's desired rank [1-64].
    113         unsigned int s;      // Output: Resulting position of bit with rank r [1-64]
    114         uint64_t a, b, c, d; // Intermediate temporaries for bit count.
    115         unsigned int t;      // Bit count temporary.
    116 
    117         // Do a normal parallel bit count for a 64-bit integer,
    118         // but store all intermediate steps.
    119         a =  v - ((v >> 1) & ~0UL/3);
    120         b = (a & ~0UL/5) + ((a >> 2) & ~0UL/5);
    121         c = (b + (b >> 4)) & ~0UL/0x11;
    122         d = (c + (c >> 8)) & ~0UL/0x101;
    123 
    124 
    125         t = (d >> 32) + (d >> 48);
    126         // Now do branchless select!
    127         s  = 64;
    128         s -= ((t - r) & 256) >> 3; r -= (t & ((t - r) >> 8));
    129         t  = (d >> (s - 16)) & 0xff;
    130         s -= ((t - r) & 256) >> 4; r -= (t & ((t - r) >> 8));
    131         t  = (c >> (s - 8)) & 0xf;
    132         s -= ((t - r) & 256) >> 5; r -= (t & ((t - r) >> 8));
    133         t  = (b >> (s - 4)) & 0x7;
    134         s -= ((t - r) & 256) >> 6; r -= (t & ((t - r) >> 8));
    135         t  = (a >> (s - 2)) & 0x3;
    136         s -= ((t - r) & 256) >> 7; r -= (t & ((t - r) >> 8));
    137         t  = (v >> (s - 1)) & 0x1;
    138         s -= ((t - r) & 256) >> 8;
    139         return s - 1;
    140 #else
    141         uint64_t picked = _pdep_u64(1ul << bit, mask);
    142         return picked ? __builtin_ctzl(picked) : 0;
    143 #endif
    144 }

  • driver/cfa.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Tue Aug 20 13:44:49 2002
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jan 31 16:48:03 2020
    13 // Update Count     : 421
     12// Last Modified On : Tue Sep 10 17:00:15 2019
     13// Update Count     : 420
    1414//
    1515
    … …  
    187187                        } else if ( arg == "-XCFA" ) {                          // CFA pass through
    188188                                i += 1;
    189                                 if ( i == argc ) continue;                              // next argument available ?
    190189                                Putenv( argv, argv[i] );
    191190
    … …  
    411410                args[nargs++] = "-lcfathread";
    412411                args[nargs++] = "-Wl,--pop-state";
    413                 args[nargs++] = "-Wl,--push-state,--no-as-needed";
    414412                args[nargs++] = "-lcfa";
    415                 args[nargs++] = "-Wl,--pop-state";
    416413                args[nargs++] = "-pthread";
    417414                args[nargs++] = "-ldl";

  • libcfa/prelude/Makefile.am

    rb7d6a36 rdca5802  
    1111## Created On       : Sun May 31 08:54:01 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Mon Feb  3 21:27:18 2020
    14 ## Update Count     : 208
     13## Last Modified On : Wed Dec 14 15:00:35 2016
     14## Update Count     : 205
    1515###############################################################################
    1616
    … …  
    3636extras.cf : ${srcdir}/extras.regx ${srcdir}/extras.c
    3737        ${AM_V_GEN}gcc ${AM_CFLAGS} -E ${srcdir}/extras.c | grep -f ${srcdir}/extras.regx > extras.cf
    38         ${AM_V_GEN}gcc ${AM_CFLAGS} -E ${srcdir}/extras.c | grep -zo -f ${srcdir}/extras.regx2 | tr '\0' '\n' >> extras.cf
    3938
    4039# create forward declarations for gcc builtins

  • libcfa/prelude/Makefile.in

    rb7d6a36 rdca5802  
    1 # Makefile.in generated by automake 1.16.1 from Makefile.am.
     1# Makefile.in generated by automake 1.15 from Makefile.am.
    22# @configure_input@
    33
    4 # Copyright (C) 1994-2018 Free Software Foundation, Inc.
     4# Copyright (C) 1994-2014 Free Software Foundation, Inc.
    55
    66# This Makefile.in is free software; the Free Software Foundation
    … …  
    331331            cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
    332332          *) \
    333             echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
    334             cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
     333            echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
     334            cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
    335335        esac;
    336336
    … …  
    377377
    378378
    379 distdir: $(BUILT_SOURCES)
    380         $(MAKE) $(AM_MAKEFLAGS) distdir-am
    381 
    382 distdir-am: $(DISTFILES)
     379distdir: $(DISTFILES)
    383380        @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
    384381        topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
    … …  
    543540extras.cf : ${srcdir}/extras.regx ${srcdir}/extras.c
    544541        ${AM_V_GEN}gcc ${AM_CFLAGS} -E ${srcdir}/extras.c | grep -f ${srcdir}/extras.regx > extras.cf
    545         ${AM_V_GEN}gcc ${AM_CFLAGS} -E ${srcdir}/extras.c | grep -zo -f ${srcdir}/extras.regx2 | tr '\0' '\n' >> extras.cf
    546542
    547543# create forward declarations for gcc builtins

  • libcfa/prelude/extras.regx

    rb7d6a36 rdca5802  
    2424typedef.* char32_t;
    2525typedef.* wchar_t;
     26extern.*\*malloc\(.*\).*
     27extern.* free\(.*\).*
     28extern.* exit\(.*\).*
     29extern.* atexit\(.*\).*
     30extern.* abort\(.*\).*
     31extern.* printf\(.*\).*

  • libcfa/prelude/prototypes.awk

    rb7d6a36 rdca5802  
    1010# Created On       : Sat May 16 07:57:37 2015
    1111# Last Modified By : Peter A. Buhr
    12 # Last Modified On : Sat Feb  8 09:46:58 2020
    13 # Update Count     : 36
     12# Last Modified On : Thu Jun  6 20:46:28 2019
     13# Update Count     : 34
    1414#
    1515
    … …  
    1717
    1818BEGIN {
    19         FS = "[( )]"
     19  FS = "[( )]"
    2020        # order so string search is longest string
    2121        i=-1
    … …  
    8484
    8585/BT_FN/ {
    86         for (i = 1; i <= NF; i += 1 ) {
    87                 if ( match($i, "BT_FN") != 0 ) {
    88                         prototypes[$i] = $i
    89                 }
     86        for (i = 1; i <= NF; i++) {
     87          if( match($i, "BT_FN") != 0 ) {
     88                prototypes[$i] = $i
     89          }
    9090        }
    91 }
     91  }
    9292
    9393END {
    … …  
    103103
    104104        for ( prototype in prototypes ) {
    105                 # printf( "//\"%s\"\n", prototype )
    106                 if ( index( "BT_LAST", prototype ) == 1 ) {
    107                         continue
     105          # printf( "//\"%s\"\n", prototype )
     106          if ( index( "BT_LAST", prototype ) == 1 ) {
     107                continue
     108          } # if
     109
     110          printf( "#define %s(NAME) FUNC_SIMPLE(", prototype )
     111
     112          if ( sub( "BT_FN_", "", prototype ) == 0 ) {
     113                printf( "\n********** BAD MACRO NAME \"%s\" **********\n", prototype )
     114                exit 0
     115          } # if
     116
     117          # generate function return type as macro
     118          for ( t = 0; t < N; t += 1 ) {                                        # find longest match
     119                type = types[t];
     120                if ( index( prototype, type ) == 1 ) {          # found match
     121                  printf( "BT_%s, NAME", type )
     122                  sub( type, "", prototype )
     123                  break;
    108124                } # if
     125          } # for
    109126
    110                 printf( "#define %s(NAME) FUNC_SIMPLE(", prototype )
    111 
    112                 if ( sub( "BT_FN_", "", prototype ) == 0 ) {
    113                         printf( "\n********** BAD MACRO NAME \"%s\" **********\n", prototype )
     127          # generate function parameter types as macro
     128          if ( index( prototype, "VAR" ) != 2 ) {                       # C-style empty parameters ?
     129                for ( p = 0; length( prototype ) > 0; p += 1 ) { # until all parameters types are removed
     130                  sub( "_", "", prototype)                              # remove "_"
     131                  printf( ", ", type )
     132                  temp = prototype
     133                  for ( t = 0; t < N; t += 1 ) {                        # find longest match
     134                        type = types[t];
     135                        if ( index( prototype, type ) == 1 ) { # found match
     136                          printf( "BT_%s", type )
     137                          sub( type, "", prototype )
     138                          break;
     139                        } # if
     140                  } # for
     141                  if ( temp == prototype ) {                            # no match found for parameter in macro table
     142                        printf( "\n********** MISSING TYPE \"%s\" **********\n", prototype )
    114143                        exit 0
    115                 } # if
    116 
    117                 # generate function return type as macro
    118                 for ( t = 0; t < N; t += 1 ) {                                  # find longest match
    119                         type = types[t];
    120                         if ( index( prototype, type ) == 1 ) {          # found match
    121                                 printf( "BT_%s, NAME", type )
    122                                 sub( type, "", prototype )
    123                                 break;
    124                         } # if
     144                  } # if
    125145                } # for
    126 
    127                 # generate function parameter types as macro
    128                 if ( index( prototype, "VAR" ) != 2 ) {                 # C-style empty parameters ?
    129                         for ( p = 0; length( prototype ) > 0; p += 1 ) { # until all parameters types are removed
    130                                 sub( "_", "", prototype)                                # remove "_"
    131                                 printf( ", ", type )
    132                                 temp = prototype
    133                                 for ( t = 0; t < N; t += 1 ) {                  # find longest match
    134                                         type = types[t];
    135                                         if ( index( prototype, type ) == 1 ) { # found match
    136                                                 printf( "BT_%s", type )
    137                                                 sub( type, "", prototype )
    138                                                 break;
    139                                         } # if
    140                                 } # for
    141                                 if ( temp == prototype ) {                              # no match found for parameter in macro table
    142                                         printf( "\n********** MISSING TYPE \"%s\" **********\n", prototype )
    143                                         exit 0
    144                                 } # if
    145                         } # for
    146                 } # if
    147                 printf( ")\n" )
     146          } # if
     147          printf( ")\n" )
    148148        } # for
    149149

  • libcfa/src/Makefile.in

    rb7d6a36 rdca5802  
    423423am__v_CFA_0 = @echo "  CFA     " $@;
    424424am__v_CFA_1 =
     425AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
     426am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
     427am__v_JAVAC_0 = @echo "  JAVAC   " $@;
     428am__v_JAVAC_1 =
     429AM_V_GOC = $(am__v_GOC_@AM_V@)
     430am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
     431am__v_GOC_0 = @echo "  GOC     " $@;
     432am__v_GOC_1 =
    425433UPPCC = u++
    426434UPPCOMPILE = $(UPPCC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_UPPFLAGS) $(UPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_CFLAGS) $(CFLAGS)
    … …  
    429437am__v_UPP_0 = @echo "  UPP     " $@;
    430438am__v_UPP_1 =
    431 AM_V_GOC = $(am__v_GOC_@AM_V@)
    432 am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
    433 am__v_GOC_0 = @echo "  GOC     " $@;
    434 am__v_GOC_1 =
    435 AM_V_RUST = $(am__v_RUST_@AM_V@)
    436 am__v_RUST_ = $(am__v_RUST_@AM_DEFAULT_V@)
    437 am__v_RUST_0 = @echo "  RUST     " $@;
    438 am__v_RUST_1 =
    439 AM_V_NODEJS = $(am__v_NODEJS_@AM_V@)
    440 am__v_NODEJS_ = $(am__v_NODEJS_@AM_DEFAULT_V@)
    441 am__v_NODEJS_0 = @echo "  NODEJS     " $@;
    442 am__v_NODEJS_1 =
    443 AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
    444 am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
    445 am__v_JAVAC_0 = @echo "  JAVAC   " $@;
    446 am__v_JAVAC_1 =
    447439lib_LTLIBRARIES = libcfa.la libcfathread.la
    448440gdbwaittarget = ""

  • libcfa/src/assert.cfa

    rb7d6a36 rdca5802  
    1010// Created On       : Mon Nov 28 12:27:26 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb  4 13:00:18 2020
    13 // Update Count     : 6
     12// Last Modified On : Thu Nov 21 17:09:26 2019
     13// Update Count     : 5
    1414//
    1515
    … …  
    2626
    2727        // called by macro assert in assert.h
    28         void __assert_fail( const char assertion[], const char file[], unsigned int line, const char function[] ) {
     28        void __assert_fail( const char *assertion, const char *file, unsigned int line, const char *function ) {
    2929                __cfaabi_bits_print_safe( STDERR_FILENO, CFA_ASSERT_FMT ".\n", assertion, __progname, function, line, file );
    3030                abort();
    … …  
    3232
    3333        // called by macro assertf
    34         void __assert_fail_f( const char assertion[], const char file[], unsigned int line, const char function[], const char fmt[], ... ) {
     34        void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... ) {
    3535                __cfaabi_bits_acquire();
    3636                __cfaabi_bits_print_nolock( STDERR_FILENO, CFA_ASSERT_FMT ": ", assertion, __progname, function, line, file );

  • libcfa/src/bits/containers.hfa

    rb7d6a36 rdca5802  
    1010// Created On       : Tue Oct 31 16:38:50 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jan 15 07:42:35 2020
    13 // Update Count     : 28
     12// Last Modified On : Wed Jun 26 08:52:20 2019
     13// Update Count     : 4
    1414
    1515#pragma once
    … …  
    4444
    4545        forall(dtype T | sized(T))
    46         static inline T & ?[?]( __small_array(T) & this, __lock_size_t idx ) {
     46        static inline T& ?[?]( __small_array(T) & this, __lock_size_t idx) {
    4747                return ((typeof(this.data))this.data)[idx];
    4848        }
    4949
    5050        forall(dtype T | sized(T))
    51         static inline T & ?[?]( const __small_array(T) & this, __lock_size_t idx ) {
     51        static inline T& ?[?]( const __small_array(T) & this, __lock_size_t idx) {
    5252                return ((typeof(this.data))this.data)[idx];
    5353        }
    5454
    55         forall(dtype T)
    56         static inline T * begin( const __small_array(T) & this ) {
     55        forall(dtype T | sized(T))
     56        static inline T* begin( const __small_array(T) & this ) {
    5757                return ((typeof(this.data))this.data);
    5858        }
    5959
    6060        forall(dtype T | sized(T))
    61         static inline T * end( const __small_array(T) & this ) {
     61        static inline T* end( const __small_array(T) & this ) {
    6262                return ((typeof(this.data))this.data) + this.size;
    6363        }
    … …  
    7070#ifdef __cforall
    7171        trait is_node(dtype T) {
    72                 T *& get_next( T & );
     72                T*& get_next( T& );
    7373        };
    7474#endif
    … …  
    9797        forall(dtype T)
    9898        static inline void ?{}( __stack(T) & this ) {
    99                 (this.top){ 0p };
    100         }
    101 
    102         static inline forall( dtype T | is_node(T) ) {
    103                 void push( __stack(T) & this, T * val ) {
    104                         verify( !get_next( *val ) );
    105                         get_next( *val ) = this.top;
    106                         this.top = val;
    107                 }
    108 
    109                 T * pop( __stack(T) & this ) {
    110                         T * top = this.top;
    111                         if( top ) {
    112                                 this.top = get_next( *top );
    113                                 get_next( *top ) = 0p;
    114                         }
    115                         return top;
    116                 }
    117 
    118                 int ?!=?( const __stack(T) & this, __attribute__((unused)) zero_t zero ) {
    119                         return this.top != 0;
    120                 }
     99                (this.top){ NULL };
     100        }
     101
     102        forall(dtype T | is_node(T) | sized(T))
     103        static inline void push( __stack(T) & this, T * val ) {
     104                verify( !get_next( *val ) );
     105                get_next( *val ) = this.top;
     106                this.top = val;
     107        }
     108
     109        forall(dtype T | is_node(T) | sized(T))
     110        static inline T * pop( __stack(T) & this ) {
     111                T * top = this.top;
     112                if( top ) {
     113                        this.top = get_next( *top );
     114                        get_next( *top ) = NULL;
     115                }
     116                return top;
     117        }
     118
     119        forall(dtype T | is_node(T))
     120        static inline int ?!=?( const __stack(T) & this, __attribute__((unused)) zero_t zero ) {
     121                return this.top != 0;
    121122        }
    122123#endif
    … …  
    144145
    145146#ifdef __cforall
    146         static inline forall( dtype T | is_node(T) ) {
    147                 void ?{}( __queue(T) & this ) with( this ) {
    148                         head{ 0p };
    149                         tail{ &head };
    150                 }
    151 
    152                 void append( __queue(T) & this, T * val ) with( this ) {
    153                         verify(tail != 0p);
    154                         *tail = val;
    155                         tail = &get_next( *val );
    156                 }
    157 
    158                 T * pop_head( __queue(T) & this ) {
    159                         T * head = this.head;
    160                         if( head ) {
    161                                 this.head = get_next( *head );
    162                                 if( !get_next( *head ) ) {
    163                                         this.tail = &this.head;
    164                                 }
    165                                 get_next( *head ) = 0p;
     147
     148        forall(dtype T)
     149        static inline void ?{}( __queue(T) & this ) with( this ) {
     150                head{ NULL };
     151                tail{ &head };
     152        }
     153
     154        forall(dtype T | is_node(T) | sized(T))
     155        static inline void append( __queue(T) & this, T * val ) with( this ) {
     156                verify(tail != NULL);
     157                *tail = val;
     158                tail = &get_next( *val );
     159        }
     160
     161        forall(dtype T | is_node(T) | sized(T))
     162        static inline T * pop_head( __queue(T) & this ) {
     163                T * head = this.head;
     164                if( head ) {
     165                        this.head = get_next( *head );
     166                        if( !get_next( *head ) ) {
     167                                this.tail = &this.head;
    166168                        }
    167                         return head;
    168                 }
    169 
    170                 T * remove( __queue(T) & this, T ** it ) with( this ) {
    171                         T * val = *it;
    172                         verify( val );
    173 
    174                         (*it) = get_next( *val );
    175 
    176                         if( tail == &get_next( *val ) ) {
    177                                 tail = it;
    178                         }
    179 
    180                         get_next( *val ) = 0p;
    181 
    182                         verify( (head == 0p) == (&head == tail) );
    183                         verify( *tail == 0p );
    184                         return val;
    185                 }
    186 
    187                 int ?!=?( const __queue(T) & this, __attribute__((unused)) zero_t zero ) {
    188                         return this.head != 0;
    189                 }
     169                        get_next( *head ) = NULL;
     170                }
     171                return head;
     172        }
     173
     174        forall(dtype T | is_node(T) | sized(T))
     175        static inline T * remove( __queue(T) & this, T ** it ) with( this ) {
     176                T * val = *it;
     177                verify( val );
     178
     179                (*it) = get_next( *val );
     180
     181                if( tail == &get_next( *val ) ) {
     182                        tail = it;
     183                }
     184
     185                get_next( *val ) = NULL;
     186
     187                verify( (head == NULL) == (&head == tail) );
     188                verify( *tail == NULL );
     189                return val;
     190        }
     191
     192        forall(dtype T | is_node(T))
     193        static inline int ?!=?( const __queue(T) & this, __attribute__((unused)) zero_t zero ) {
     194                return this.head != 0;
    190195        }
    191196#endif
    … …  
    218223
    219224#ifdef __cforall
    220         forall(dtype T )
     225
     226        forall(dtype T | sized(T))
    221227        static inline [void] ?{}( __dllist(T) & this, * [T * & next, T * & prev] ( T & ) __get ) {
    222                 this.head{ 0p };
     228                this.head{ NULL };
    223229                this.__get = __get;
    224230        }
    … …  
    226232        #define next 0
    227233        #define prev 1
    228         static inline forall(dtype T) {
    229                 void push_front( __dllist(T) & this, T & node ) with( this ) {
    230                         verify(__get);
    231                         if ( head ) {
    232                                 __get( node ).next = head;
    233                                 __get( node ).prev = __get( *head ).prev;
    234                                 // inserted node must be consistent before it is seen
    235                                 // prevent code movement across barrier
    236                                 asm( "" : : : "memory" );
    237                                 __get( *head ).prev = &node;
    238                                 T & _prev = *__get( node ).prev;
    239                                 __get( _prev ).next = &node;
    240                         } else {
    241                                 __get( node ).next = &node;
    242                                 __get( node ).prev = &node;
    243                         }
    244 
     234        forall(dtype T | sized(T))
     235        static inline void push_front( __dllist(T) & this, T & node ) with( this ) {
     236                verify(__get);
     237                if ( head ) {
     238                        __get( node ).next = head;
     239                        __get( node ).prev = __get( *head ).prev;
     240                        // inserted node must be consistent before it is seen
    245241                        // prevent code movement across barrier
    246242                        asm( "" : : : "memory" );
    247                         head = &node;
    248                 }
    249 
    250                 void remove( __dllist(T) & this, T & node ) with( this ) {
    251                         verify(__get);
    252                         if ( &node == head ) {
    253                                 if ( __get( *head ).next == head ) {
    254                                         head = 0p;
    255                                 } else {
    256                                         head = __get( *head ).next;
    257                                 }
     243                        __get( *head ).prev = &node;
     244                        T & _prev = *__get( node ).prev;
     245                        __get( _prev ).next = &node;
     246                }
     247                else {
     248                        __get( node ).next = &node;
     249                        __get( node ).prev = &node;
     250                }
     251
     252                // prevent code movement across barrier
     253                asm( "" : : : "memory" );
     254                head = &node;
     255        }
     256
     257        forall(dtype T | sized(T))
     258        static inline void remove( __dllist(T) & this, T & node ) with( this ) {
     259                verify(__get);
     260                if ( &node == head ) {
     261                        if ( __get( *head ).next == head ) {
     262                                head = NULL;
    258263                        }
    259                         __get( *__get( node ).next ).prev = __get( node ).prev;
    260                         __get( *__get( node ).prev ).next = __get( node ).next;
    261                         __get( node ).next = 0p;
    262                         __get( node ).prev = 0p;
    263                 }
    264 
    265                 int ?!=?( const __dllist(T) & this, __attribute__((unused)) zero_t zero ) {
    266                         return this.head != 0;
    267                 }
     264                        else {
     265                                head = __get( *head ).next;
     266                        }
     267                }
     268                __get( *__get( node ).next ).prev = __get( node ).prev;
     269                __get( *__get( node ).prev ).next = __get( node ).next;
     270                __get( node ).next = NULL;
     271                __get( node ).prev = NULL;
     272        }
     273
     274        forall(dtype T | sized(T))
     275        static inline int ?!=?( const __dllist(T) & this, __attribute__((unused)) zero_t zero ) {
     276                return this.head != 0;
    268277        }
    269278        #undef next
    … …  
    277286
    278287#endif
    279 
    280 // Local Variables: //
    281 // tab-width: 4 //
    282 // End: //

  • libcfa/src/bits/debug.cfa

    rb7d6a36 rdca5802  
    1010// Created On       : Thu Mar 30 12:30:01 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb  4 13:03:16 2020
    13 // Update Count     : 11
     12// Last Modified On : Thu Nov 21 17:16:30 2019
     13// Update Count     : 10
    1414//
    1515
    … …  
    2727
    2828extern "C" {
    29         void __cfaabi_bits_write( int fd, const char in_buffer[], int len ) {
     29
     30        void __cfaabi_bits_write( int fd, const char *in_buffer, int len ) {
    3031                // ensure all data is written
    3132                for ( int count = 0, retcode; count < len; count += retcode ) {

  • libcfa/src/bits/debug.hfa

    rb7d6a36 rdca5802  
    1010// Created On       : Mon Nov 28 12:27:26 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb  4 12:29:21 2020
    13 // Update Count     : 9
     12// Last Modified On : Thu Nov 21 17:06:58 2019
     13// Update Count     : 8
    1414//
    1515
    … …  
    2121        #define __cfaabi_dbg_ctx __PRETTY_FUNCTION__
    2222        #define __cfaabi_dbg_ctx2 , __PRETTY_FUNCTION__
    23         #define __cfaabi_dbg_ctx_param const char caller[]
    24         #define __cfaabi_dbg_ctx_param2 , const char caller[]
     23        #define __cfaabi_dbg_ctx_param const char * caller
     24        #define __cfaabi_dbg_ctx_param2 , const char * caller
    2525#else
    2626        #define __cfaabi_dbg_debug_do(...)
    … …  
    3939        #include <unistd.h>
    4040
    41         extern void __cfaabi_bits_write( int fd, const char buffer[], int len );
     41        extern void __cfaabi_bits_write( int fd, const char *buffer, int len );
    4242        extern void __cfaabi_bits_acquire();
    4343        extern void __cfaabi_bits_release();

  • libcfa/src/bits/defs.hfa

    rb7d6a36 rdca5802  
    1010// Created On       : Thu Nov  9 13:24:10 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jan 28 22:38:27 2020
    13 // Update Count     : 9
     12// Last Modified On : Thu Feb  8 16:22:41 2018
     13// Update Count     : 8
    1414//
    1515
    … …  
    3434
    3535#ifdef __cforall
    36 void abort( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ ));
    37 void abort( bool signalAbort, const char fmt[], ... ) __attribute__ (( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ ));
     36void abort ( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ ));
    3837extern "C" {
    3938#endif

  • libcfa/src/bits/locks.hfa

    rb7d6a36 rdca5802  
    1010// Created On       : Tue Oct 31 15:14:38 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb  4 13:03:19 2020
    13 // Update Count     : 11
     12// Last Modified On : Sat Aug 11 15:42:24 2018
     13// Update Count     : 10
    1414//
    1515
    … …  
    5454
    5555                #ifdef __CFA_DEBUG__
    56                         void __cfaabi_dbg_record(__spinlock_t & this, const char prev_name[]);
     56                        void __cfaabi_dbg_record(__spinlock_t & this, const char * prev_name);
    5757                #else
    5858                        #define __cfaabi_dbg_record(x, y)

  • libcfa/src/bits/signal.hfa

    rb7d6a36 rdca5802  
    3737
    3838        act.sa_sigaction = (void (*)(int, siginfo_t *, void *))handler;
    39         sigemptyset( &act.sa_mask );
    40         sigaddset( &act.sa_mask, SIGALRM );             // disabled during signal handler
    41         sigaddset( &act.sa_mask, SIGUSR1 );
    42         sigaddset( &act.sa_mask, SIGSEGV );
    43         sigaddset( &act.sa_mask, SIGBUS );
    44         sigaddset( &act.sa_mask, SIGILL );
    45         sigaddset( &act.sa_mask, SIGFPE );
    46         sigaddset( &act.sa_mask, SIGHUP );              // revert to default on second delivery
    47         sigaddset( &act.sa_mask, SIGTERM );
    48         sigaddset( &act.sa_mask, SIGINT );
    4939        act.sa_flags = flags;
    5040
    51         if ( sigaction( sig, &act, 0p ) == -1 ) {
     41        if ( sigaction( sig, &act, NULL ) == -1 ) {
    5242                __cfaabi_dbg_print_buffer_decl(
    5343                        " __cfaabi_sigaction( sig:%d, handler:%p, flags:%d ), problem installing signal handler, error(%d) %s.\n",
    … …  
    5545                );
    5646                _exit( EXIT_FAILURE );
    57         } // if
     47        }
    5848}
     49
     50// Sigaction wrapper : restore default handler
     51static void __cfaabi_sigdefault( int sig ) {
     52        struct sigaction act;
     53
     54        act.sa_handler = SIG_DFL;
     55        act.sa_flags = 0;
     56        sigemptyset( &act.sa_mask );
     57
     58        if ( sigaction( sig, &act, NULL ) == -1 ) {
     59                __cfaabi_dbg_print_buffer_decl(
     60                        " __cfaabi_sigdefault( sig:%d ), problem reseting signal handler, error(%d) %s.\n",
     61                        sig, errno, strerror( errno )
     62                );
     63                _exit( EXIT_FAILURE );
     64        }
     65}

  • libcfa/src/clock.hfa

    rb7d6a36 rdca5802  
    1010// Created On       : Thu Apr 12 14:36:06 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jan  6 12:49:58 2020
    13 // Update Count     : 9
     12// Last Modified On : Thu Jun 13 21:21:13 2019
     13// Update Count     : 8
    1414//
    1515
    1616#include <time.hfa>
     17
    1718
    1819//######################### C time #########################
    … …  
    2526static inline tm * localtime_r( time_t tp, tm * result ) { return localtime_r( &tp, result ); }
    2627
     28
    2729//######################### Clock #########################
    2830
    2931struct Clock {                                                                                  // private
    3032        Duration offset;                                                                        // for virtual clock: contains offset from real-time
     33        int clocktype;                                                                          // implementation only -1 (virtual), CLOCK_REALTIME
    3134};
    3235
    3336static inline {
     37        void resetClock( Clock & clk ) with( clk ) {
     38                clocktype = CLOCK_REALTIME_COARSE;
     39        } // Clock::resetClock
     40
    3441        void resetClock( Clock & clk, Duration adj ) with( clk ) {
     42                clocktype = -1;
    3543                offset = adj + __timezone`s;                                    // timezone (global) is (UTC - local time) in seconds
    3644        } // resetClock
    3745
     46        void ?{}( Clock & clk ) { resetClock( clk ); }
    3847        void ?{}( Clock & clk, Duration adj ) { resetClock( clk, adj ); }
    3948
    … …  
    8089                return ret;
    8190        } // getTime
    82 
    83         Time getCPUTime() {
    84                 timespec ts;
    85                 clock_gettime( CLOCK_THREAD_CPUTIME_ID, &ts );
    86                 return (Time){ ts };
    87     } // getCPUTime
    8891} // distribution
    8992

  • libcfa/src/concurrency/CtxSwitch-x86_64.S

    rb7d6a36 rdca5802  
    8787CtxInvokeStub:
    8888        movq %rbx, %rdi
    89         movq %r12, %rsi
    90         jmp *%r13
     89        jmp *%r12
    9190        .size  CtxInvokeStub, .-CtxInvokeStub
    9291

  • libcfa/src/concurrency/alarm.cfa

    rb7d6a36 rdca5802  
    1010// Created On       : Fri Jun 2 11:31:25 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Jan  5 08:41:36 2020
    13 // Update Count     : 69
     12// Last Modified On : Tue Dec  3 22:47:24 2019
     13// Update Count     : 68
    1414//
    1515
    … …  
    3939
    4040void __kernel_set_timer( Duration alarm ) {
    41         verifyf(alarm >= 1`us || alarm == 0, "Setting timer to < 1us (%jins)", alarm`ns);
     41        verifyf(alarm >= 1`us || alarm == 0, "Setting timer to < 1us (%jins)", alarm.tv);
    4242        setitimer( ITIMER_REAL, &(itimerval){ alarm }, 0p );
    4343}

  • libcfa/src/concurrency/coroutine.cfa

    rb7d6a36 rdca5802  
    1010// Created On       : Mon Nov 28 12:27:26 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb  4 12:29:25 2020
    13 // Update Count     : 16
     12// Last Modified On : Thu Dec  5 14:37:29 2019
     13// Update Count     : 15
    1414//
    1515
    … …  
    8989}
    9090
    91 void ?{}( coroutine_desc & this, const char name[], void * storage, size_t storageSize ) with( this ) {
     91void ?{}( coroutine_desc & this, const char * name, void * storage, size_t storageSize ) with( this ) {
    9292        (this.context){0p, 0p};
    9393        (this.stack){storage, storageSize};
    … …  
    187187// is not inline (We can't inline Cforall in C)
    188188extern "C" {
    189         void __leave_coroutine( struct coroutine_desc * src ) {
     189        void __suspend_internal(void) {
     190                suspend();
     191        }
     192
     193        void __leave_coroutine( coroutine_desc * src ) {
    190194                coroutine_desc * starter = src->cancellation != 0 ? src->last : src->starter;
    191195
    … …  
    203207                CoroutineCtxSwitch( src, starter );
    204208        }
    205 
    206         struct coroutine_desc * __finish_coroutine(void) {
    207                 struct coroutine_desc * cor = kernelTLS.this_thread->curr_cor;
    208 
    209                 if(cor->state == Primed) {
    210                         suspend();
    211                 }
    212 
    213                 cor->state = Active;
    214 
    215                 return cor;
    216         }
    217209}
    218210

  • libcfa/src/concurrency/coroutine.hfa

    rb7d6a36 rdca5802  
    1010// Created On       : Mon Nov 28 12:27:26 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb  4 12:29:26 2020
    13 // Update Count     : 11
     12// Last Modified On : Tue Dec  3 22:47:58 2019
     13// Update Count     : 10
    1414//
    1515
    … …  
    3535// void ^?{}( coStack_t & this );
    3636
    37 void ?{}( coroutine_desc & this, const char name[], void * storage, size_t storageSize );
     37void ?{}( coroutine_desc & this, const char * name, void * storage, size_t storageSize );
    3838void ^?{}( coroutine_desc & this );
    3939
    … …  
    4141static inline void ?{}( coroutine_desc & this, size_t stackSize)                     { this{ "Anonymous Coroutine", 0p, stackSize }; }
    4242static inline void ?{}( coroutine_desc & this, void * storage, size_t storageSize )  { this{ "Anonymous Coroutine", storage, storageSize }; }
    43 static inline void ?{}( coroutine_desc & this, const char name[])                    { this{ name, 0p, 0 }; }
    44 static inline void ?{}( coroutine_desc & this, const char name[], size_t stackSize ) { this{ name, 0p, stackSize }; }
     43static inline void ?{}( coroutine_desc & this, const char * name)                    { this{ name, 0p, 0 }; }
     44static inline void ?{}( coroutine_desc & this, const char * name, size_t stackSize ) { this{ name, 0p, stackSize }; }
    4545
    4646//-----------------------------------------------------------------------------
    … …  
    6161// Start coroutine routines
    6262extern "C" {
    63         void CtxInvokeCoroutine(void (*main)(void *), void * this);
     63      forall(dtype T | is_coroutine(T))
     64      void CtxInvokeCoroutine(T * this);
    6465
    65         forall(dtype T)
    66         void CtxStart(void (*main)(T &), struct coroutine_desc * cor, T & this, void (*invoke)(void (*main)(void *), void *));
     66      forall(dtype T | is_coroutine(T))
     67      void CtxStart(T * this, void ( *invoke)(T *));
    6768
    6869        extern void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc *) __attribute__ ((__noreturn__));
    … …  
    128129
    129130        if( unlikely(dst->context.SP == 0p) ) {
    130                 TL_GET( this_thread )->curr_cor = dst;
    131131                __stack_prepare(&dst->stack, 65000);
    132                 CtxStart(main, dst, cor, CtxInvokeCoroutine);
    133                 TL_GET( this_thread )->curr_cor = src;
     132                CtxStart(&cor, CtxInvokeCoroutine);
    134133        }
    135134

  • libcfa/src/concurrency/invoke.c

    rb7d6a36 rdca5802  
    2929// Called from the kernel when starting a coroutine or task so must switch back to user mode.
    3030
    31 extern void __leave_coroutine ( struct coroutine_desc * );
    32 extern struct coroutine_desc * __finish_coroutine(void);
    33 extern void __leave_thread_monitor();
     31extern void __suspend_internal(void);
     32extern void __leave_coroutine( struct coroutine_desc * );
     33extern void __finish_creation( struct thread_desc * );
     34extern void __leave_thread_monitor( struct thread_desc * this );
    3435extern void disable_interrupts() OPTIONAL_THREAD;
    3536extern void enable_interrupts( __cfaabi_dbg_ctx_param );
    … …  
    3738void CtxInvokeCoroutine(
    3839        void (*main)(void *),
     40        struct coroutine_desc *(*get_coroutine)(void *),
    3941        void *this
    4042) {
    41         // Finish setting up the coroutine by setting its state
    42         struct coroutine_desc * cor = __finish_coroutine();
     43        struct coroutine_desc* cor = get_coroutine( this );
    4344
    44         // Call the main of the coroutine
     45        if(cor->state == Primed) {
     46                __suspend_internal();
     47        }
     48
     49        cor->state = Active;
     50
    4551        main( this );
    4652
    … …  
    7783
    7884void CtxInvokeThread(
     85        void (*dtor)(void *),
    7986        void (*main)(void *),
     87        struct thread_desc *(*get_thread)(void *),
    8088        void *this
    8189) {
     90        // Fetch the thread handle from the user defined thread structure
     91        struct thread_desc* thrd = get_thread( this );
     92
     93        // First suspend, once the thread arrives here,
     94        // the function pointer to main can be invalidated without risk
     95        __finish_creation( thrd );
     96
    8297        // Officially start the thread by enabling preemption
    8398        enable_interrupts( __cfaabi_dbg_ctx );
    … …  
    93108        // The order of these 4 operations is very important
    94109        //Final suspend, should never return
    95         __leave_thread_monitor();
     110        __leave_thread_monitor( thrd );
    96111        __cabi_abort( "Resumed dead thread" );
    97112}
    98113
     114
    99115void CtxStart(
    100116        void (*main)(void *),
    101         struct coroutine_desc * cor,
     117        struct coroutine_desc *(*get_coroutine)(void *),
    102118        void *this,
    103119        void (*invoke)(void *)
    104120) {
     121        struct coroutine_desc * cor = get_coroutine( this );
    105122        struct __stack_t * stack = cor->stack.storage;
    106123
    … …  
    121138
    122139        fs->dummyReturn = NULL;
    123         fs->argument[0] = main;     // argument to invoke
    124         fs->argument[1] = this;     // argument to invoke
     140        fs->argument[0] = this;     // argument to invoke
    125141        fs->rturn = invoke;
    126142
    … …  
    140156        fs->dummyReturn = NULL;
    141157        fs->rturn = CtxInvokeStub;
    142         fs->fixedRegisters[0] = main;
    143         fs->fixedRegisters[1] = this;
    144         fs->fixedRegisters[2] = invoke;
     158        fs->fixedRegisters[0] = this;
     159        fs->fixedRegisters[1] = invoke;
    145160
    146161#elif defined( __ARM_ARCH )
    147 #error ARM needs to be upgrade to use to parameters like X86/X64 (A.K.A. : I broke this and do not know how to fix it)
     162
    148163        struct FakeStack {
    149164                float fpRegs[16];                       // floating point registers

  • libcfa/src/concurrency/kernel.cfa

    rb7d6a36 rdca5802  
    1010// Created On       : Tue Jan 17 12:27:26 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb  4 13:03:15 2020
    13 // Update Count     : 58
     12// Last Modified On : Thu Dec  5 16:25:52 2019
     13// Update Count     : 52
    1414//
    1515
    … …  
    210210
    211211static void start(processor * this);
    212 void ?{}(processor & this, const char name[], cluster & cltr) with( this ) {
     212void ?{}(processor & this, const char * name, cluster & cltr) with( this ) {
    213213        this.name = name;
    214214        this.cltr = &cltr;
    … …  
    240240}
    241241
    242 void ?{}(cluster & this, const char name[], Duration preemption_rate) with( this ) {
     242void ?{}(cluster & this, const char * name, Duration preemption_rate) with( this ) {
    243243        this.name = name;
    244244        this.preemption_rate = preemption_rate;
    … …  
    454454}
    455455
    456 static void Abort( int ret, const char func[] ) {
     456static void Abort( int ret, const char * func ) {
    457457        if ( ret ) {                                                                            // pthread routines return errno values
    458458                abort( "%s : internal error, error(%d) %s.", func, ret, strerror( ret ) );
    … …  
    503503        verify( ! kernelTLS.preemption_state.enabled );
    504504
    505         kernelTLS.this_thread->curr_cor = dst;
    506505        __stack_prepare( &dst->stack, 65000 );
    507         CtxStart(main, dst, this->runner, CtxInvokeCoroutine);
     506        CtxStart(&this->runner, CtxInvokeCoroutine);
    508507
    509508        verify( ! kernelTLS.preemption_state.enabled );
    … …  
    519518        CtxSwitch( &src->context, &dst->context );
    520519        // when CtxSwitch returns we are back in the src coroutine
    521 
    522         mainThread->curr_cor = &mainThread->self_cor;
    523520
    524521        // set state of new coroutine to active
    … …  
    867864                sigemptyset( &mask );
    868865                sigaddset( &mask, SIGALRM );            // block SIGALRM signals
    869                 sigaddset( &mask, SIGUSR1 );            // block SIGALRM signals
    870                 sigsuspend( &mask );                            // block the processor to prevent further damage during abort
    871                 _exit( EXIT_FAILURE );                          // if processor unblocks before it is killed, terminate it
     866                sigsuspend( &mask );                    // block the processor to prevent further damage during abort
     867                _exit( EXIT_FAILURE );                  // if processor unblocks before it is killed, terminate it
    872868        }
    873869        else {
    … …  
    990986__cfaabi_dbg_debug_do(
    991987        extern "C" {
    992                 void __cfaabi_dbg_record(__spinlock_t & this, const char prev_name[]) {
     988                void __cfaabi_dbg_record(__spinlock_t & this, const char * prev_name) {
    993989                        this.prev_name = prev_name;
    994990                        this.prev_thrd = kernelTLS.this_thread;

  • libcfa/src/concurrency/kernel.hfa

    rb7d6a36 rdca5802  
    1010// Created On       : Tue Jan 17 12:27:26 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb  4 12:29:26 2020
    13 // Update Count     : 22
     12// Last Modified On : Wed Dec  4 07:54:51 2019
     13// Update Count     : 18
    1414//
    1515
    … …  
    151151};
    152152
    153 void  ?{}(processor & this, const char name[], struct cluster & cltr);
     153void  ?{}(processor & this, const char * name, struct cluster & cltr);
    154154void ^?{}(processor & this);
    155155
    156156static inline void  ?{}(processor & this)                    { this{ "Anonymous Processor", *mainCluster}; }
    157157static inline void  ?{}(processor & this, struct cluster & cltr)    { this{ "Anonymous Processor", cltr}; }
    158 static inline void  ?{}(processor & this, const char name[]) { this{name, *mainCluster }; }
     158static inline void  ?{}(processor & this, const char * name) { this{name, *mainCluster }; }
    159159
    160160static inline [processor *&, processor *& ] __get( processor & this ) {
    … …  
    344344extern Duration default_preemption();
    345345
    346 void ?{} (cluster & this, const char name[], Duration preemption_rate);
     346void ?{} (cluster & this, const char * name, Duration preemption_rate);
    347347void ^?{}(cluster & this);
    348348
    349349static inline void ?{} (cluster & this)                           { this{"Anonymous Cluster", default_preemption()}; }
    350350static inline void ?{} (cluster & this, Duration preemption_rate) { this{"Anonymous Cluster", preemption_rate}; }
    351 static inline void ?{} (cluster & this, const char name[])        { this{name, default_preemption()}; }
     351static inline void ?{} (cluster & this, const char * name)        { this{name, default_preemption()}; }
    352352
    353353static inline [cluster *&, cluster *& ] __get( cluster & this ) {

  • libcfa/src/concurrency/kernel_private.hfa

    rb7d6a36 rdca5802  
    8888// Threads
    8989extern "C" {
    90       void CtxInvokeThread(void (*main)(void *), void * this);
     90      forall(dtype T | is_thread(T))
     91      void CtxInvokeThread(T * this);
    9192}
    9293

  • libcfa/src/concurrency/monitor.cfa

    rb7d6a36 rdca5802  
    243243        // last routine called by a thread.
    244244        // Should never return
    245         void __leave_thread_monitor() {
    246                 thread_desc * thrd = TL_GET( this_thread );
     245        void __leave_thread_monitor( thread_desc * thrd ) {
    247246                monitor_desc * this = &thrd->self_mon;
    248247

  • libcfa/src/concurrency/thread.cfa

    rb7d6a36 rdca5802  
    5959void ?{}( scoped(T)& this ) with( this ) {
    6060        handle{};
    61         __thrd_start(handle, main);
     61        __thrd_start(handle);
    6262}
    6363
    … …  
    6565void ?{}( scoped(T)& this, P params ) with( this ) {
    6666        handle{ params };
    67         __thrd_start(handle, main);
     67        __thrd_start(handle);
    6868}
    6969
    … …  
    7676// Starting and stopping threads
    7777forall( dtype T | is_thread(T) )
    78 void __thrd_start( T & this, void (*main_p)(T &) ) {
     78void __thrd_start( T& this ) {
    7979        thread_desc * this_thrd = get_thread(this);
     80        thread_desc * curr_thrd = TL_GET( this_thread );
    8081
    8182        disable_interrupts();
    82         CtxStart(main_p, get_coroutine(this), this, CtxInvokeThread);
    83 
     83        CtxStart(&this, CtxInvokeThread);
    8484        this_thrd->context.[SP, FP] = this_thrd->self_cor.context.[SP, FP];
    8585        verify( this_thrd->context.SP );
     86        CtxSwitch( &curr_thrd->context, &this_thrd->context );
    8687
    8788        ScheduleThread(this_thrd);
    8889        enable_interrupts( __cfaabi_dbg_ctx );
     90}
     91
     92extern "C" {
     93        // KERNEL ONLY
     94        void __finish_creation(thread_desc * this) {
     95                // set new coroutine that the processor is executing
     96                // and context switch to it
     97                verify( kernelTLS.this_thread != this );
     98                verify( kernelTLS.this_thread->context.SP );
     99                CtxSwitch( &this->context, &kernelTLS.this_thread->context );
     100        }
    89101}
    90102

  • libcfa/src/concurrency/thread.hfa

    rb7d6a36 rdca5802  
    5454
    5555forall( dtype T | is_thread(T) )
    56 void __thrd_start( T & this, void (*)(T &) );
     56void __thrd_start( T & this );
    5757
    5858//-----------------------------------------------------------------------------

  • libcfa/src/exception.c

    rb7d6a36 rdca5802  
    6969
    7070
    71 // This macro should be the only thing that needs to change across machines.
    72 // Used in the personality function, way down in termination.
     71// This macro should be the only thing that needs to change across machines.  Used in the personality function, way down
     72// in termination.
    7373// struct _Unwind_Context * -> _Unwind_Reason_Code(*)(exception_t *)
    7474#define MATCHER_FROM_CONTEXT(ptr_to_context) \
    … …  
    102102}
    103103
    104 // Do we control where exceptions get thrown even with concurency?
    105 // If not these are not quite thread safe, the cleanup hook has to
    106 // be added after the node is built but before it is made the top node.
     104// Do we control where exceptions get thrown even with concurency?  If not these are not quite thread safe, the cleanup
     105// hook has to be added after the node is built but before it is made the top node.
    107106
    108107void __cfaabi_ehm__try_resume_setup(struct __cfaabi_ehm__try_resume_node * node,
    … …  
    213212        _Unwind_Reason_Code ret = _Unwind_RaiseException( &this_exception_storage );
    214213
    215         // If we reach here it means something happened. For resumption to work we need to find a way
    216         // to return back to here. Most of them will probably boil down to setting a global flag and
    217         // making the phase 1 either stop or fail. Causing an error on purpose may help avoiding
    218         // unnecessary work but it might have some weird side effects. If we just pretend no handler
    219         // was found that would work but may be expensive for no reason since we will always search
    220         // the whole stack.
     214        // If we reach here it means something happened.  For resumption to work we need to find a way to return back to
     215        // here.  Most of them will probably boil down to setting a global flag and making the phase 1 either stop or
     216        // fail.  Causing an error on purpose may help avoiding unnecessary work but it might have some weird side
     217        // effects.  If we just pretend no handler was found that would work but may be expensive for no reason since we
     218        // will always search the whole stack.
    221219
    222220        if( ret == _URC_END_OF_STACK ) {
    223                 // No proper handler was found. This can be handled in many ways, C++ calls std::terminate.
    224                 // Here we force unwind the stack, basically raising a cancellation.
     221                // No proper handler was found.  This can be handled in several way.  C++ calls std::terminate Here we
     222                // force unwind the stack, basically raising a cancellation.
    225223                printf("Uncaught exception %p\n", &this_exception_storage);
    226224
    … …  
    230228        }
    231229
    232         // We did not simply reach the end of the stack without finding a handler. This is an error.
     230        // We did not simply reach the end of the stack without finding a handler.  Something wen't wrong
    233231        printf("UNWIND ERROR %d after raise exception\n", ret);
    234232        abort();
    … …  
    248246}
    249247
    250 #pragma GCC push_options
    251 #pragma GCC optimize("O0")
    252 
    253 // This is our personality routine. For every stack frame annotated with
    254 // ".cfi_personality 0x3,__gcfa_personality_v0" this function will be called twice when unwinding.
    255 //  Once in the search phase and once in the cleanup phase.
     248#if defined(PIC)
     249#warning Exceptions not yet supported when using Position-Independent Code
     250__attribute__((noinline))
     251void __cfaabi_ehm__try_terminate(void (*try_block)(),
     252                void (*catch_block)(int index, exception_t * except),
     253                __attribute__((unused)) int (*match_block)(exception_t * except)) {
     254        abort();
     255}
     256#else
     257// This is our personality routine.  For every stack frame anotated with ".cfi_personality 0x3,__gcfa_personality_v0".
     258// This function will be called twice when unwinding.  Once in the search phased and once in the cleanup phase.
    256259_Unwind_Reason_Code __gcfa_personality_v0 (
    257260                int version, _Unwind_Action actions, unsigned long long exceptionClass,
    … …  
    261264
    262265        //__cfaabi_dbg_print_safe("CFA: 0x%lx\n", _Unwind_GetCFA(context));
    263         __cfaabi_dbg_print_safe("Personality function (%d, %x, %llu, %p, %p):",
    264                         version, actions, exceptionClass, unwind_exception, context);
     266        __cfaabi_dbg_print_safe("Personality function (%d, %x, %llu, %p, %p):", version, actions, exceptionClass, unwind_exception, context);
    265267
    266268        // If we've reached the end of the stack then there is nothing much we can do...
    … …  
    289291        // Get the instuction pointer and a reading pointer into the exception table
    290292        lsda_header_info lsd_info;
    291         const unsigned char * cur_ptr = parse_lsda_header(context, lsd, &lsd_info);
     293        const unsigned char * cur_ptr = parse_lsda_header( context, lsd, &lsd_info);
    292294        _Unwind_Ptr instruction_ptr = _Unwind_GetIP( context );
    293295
    … …  
    300302
    301303                // Decode the common stuff we have in here
    302                 cur_ptr = read_encoded_value(0, lsd_info.call_site_encoding, cur_ptr, &callsite_start);
    303                 cur_ptr = read_encoded_value(0, lsd_info.call_site_encoding, cur_ptr, &callsite_len);
    304                 cur_ptr = read_encoded_value(0, lsd_info.call_site_encoding, cur_ptr, &callsite_landing_pad);
    305                 cur_ptr = read_uleb128(cur_ptr, &callsite_action);
     304                cur_ptr = read_encoded_value (0, lsd_info.call_site_encoding, cur_ptr, &callsite_start);
     305                cur_ptr = read_encoded_value (0, lsd_info.call_site_encoding, cur_ptr, &callsite_len);
     306                cur_ptr = read_encoded_value (0, lsd_info.call_site_encoding, cur_ptr, &callsite_landing_pad);
     307                cur_ptr = read_uleb128 (cur_ptr, &callsite_action);
    306308
    307309                // Have we reach the correct frame info yet?
    … …  
    314316                        void * ep = (void*)lsd_info.Start + callsite_start + callsite_len;
    315317                        void * ip = (void*)instruction_ptr;
    316                         __cfaabi_dbg_print_safe("\nfound %p - %p (%p, %p, %p), looking for %p\n",
    317                                         bp, ep, ls, cs, cl, ip);
     318                        __cfaabi_dbg_print_safe("\nfound %p - %p (%p, %p, %p), looking for %p\n", bp, ep, ls, cs, cl, ip);
    318319#endif // __CFA_DEBUG_PRINT__
    319320                        continue;
    320321                }
    321322
    322                 // Have we gone too far?
     323                // Have we gone too far
    323324                if( lsd_info.Start + callsite_start > instruction_ptr ) {
    324325                        printf(" gone too far");
    … …  
    330331                        // Which phase are we in
    331332                        if (actions & _UA_SEARCH_PHASE) {
    332                                 // In search phase, these means we found a potential handler we must check.
    333 
    334                                 // We have arbitrarily decided that 0 means nothing to do and 1 means there is
    335                                 // a potential handler. This doesn't seem to conflict the gcc default behavior.
     333                                // Search phase, this means we probably found a potential handler and must check if it is a match
     334
     335                                // If we have arbitrarily decided that 0 means nothing to do and 1 means there is a potential handler
     336                                // This doesn't seem to conflict the gcc default behavior
    336337                                if (callsite_action != 0) {
    337338                                        // Now we want to run some code to see if the handler matches
    … …  
    350351                                        // The current apprach uses one exception table entry per try block
    351352                                        _uleb128_t imatcher;
    352                                         // Get the relative offset to the {...}?
    353                                         cur_ptr = read_uleb128(cur_ptr, &imatcher);
     353                                        // Get the relative offset to the
     354                                        cur_ptr = read_uleb128 (cur_ptr, &imatcher);
     355
     356                                        // Get a function pointer from the relative offset and call it
     357                                        // _Unwind_Reason_Code (*matcher)() = (_Unwind_Reason_Code (*)())lsd_info.LPStart + imatcher;
    354358
    355359                                        _Unwind_Reason_Code (*matcher)(exception_t *) =
    … …  
    410414}
    411415
    412 // Try statements are hoisted out see comments for details. While this could probably be unique
    413 // and simply linked from libcfa but there is one problem left, see the exception table for details
     416// Try statements are hoisted out see comments for details.  With this could probably be unique and simply linked from
     417// libcfa but there is one problem left, see the exception table for details
    414418__attribute__((noinline))
    415419void __cfaabi_ehm__try_terminate(void (*try_block)(),
    … …  
    424428        // assembly works.
    425429
    426         // Setup the personality routine and exception table.
    427 #ifdef __PIC__
    428         asm volatile (".cfi_personality 0x9b,CFA.ref.__gcfa_personality_v0");
    429         asm volatile (".cfi_lsda 0x1b, .LLSDACFA2");
    430 #else
     430        // Setup the personality routine
    431431        asm volatile (".cfi_personality 0x3,__gcfa_personality_v0");
     432        // Setup the exception table
    432433        asm volatile (".cfi_lsda 0x3, .LLSDACFA2");
    433 #endif
    434434
    435435        // Label which defines the start of the area for which the handler is setup.
    … …  
    442442        asm volatile goto ("" : : : : CATCH );
    443443
    444         // Normal return for when there is no throw.
     444        // Normal return
    445445        return;
    446446
    … …  
    459459}
    460460
    461 // Exception table data we need to generate. While this is almost generic, the custom data refers
    462 // to {*}try_terminate, which is no way generic. Some more works need to be done if we want to
    463 // have a single call to the try routine.
    464 
    465 #ifdef __PIC__
     461// Exception table data we need to generate.  While this is almost generic, the custom data refers to foo_try_match try
     462// match, which is no way generic.  Some more works need to be done if we want to have a single call to the try routine.
     463
    466464#if defined( __i386 ) || defined( __x86_64 )
    467465asm (
    468         // HEADER
     466        //HEADER
    469467        ".LFECFA1:\n"
    470468        "       .globl  __gcfa_personality_v0\n"
    471469        "       .section        .gcc_except_table,\"a\",@progbits\n"
    472         // TABLE HEADER (important field is the BODY length at the end)
    473         ".LLSDACFA2:\n"
     470        ".LLSDACFA2:\n"                                                 //TABLE header
    474471        "       .byte   0xff\n"
    475472        "       .byte   0xff\n"
    476473        "       .byte   0x1\n"
    477         "       .uleb128 .LLSDACSECFA2-.LLSDACSBCFA2\n"
    478         // BODY (language specific data)
    479         // This uses language specific data and can be modified arbitrarily
    480         // We use handled area offset, handled area length,
    481         // handler landing pad offset and 1 (action code, gcc seems to use 0).
    482         ".LLSDACSBCFA2:\n"
    483         "       .uleb128 .TRYSTART-__cfaabi_ehm__try_terminate\n"
    484         "       .uleb128 .TRYEND-.TRYSTART\n"
    485         "       .uleb128 .CATCH-__cfaabi_ehm__try_terminate\n"
    486         "       .uleb128 1\n"
    487         ".LLSDACSECFA2:\n"
    488         // TABLE FOOTER
    489         "       .text\n"
    490         "       .size   __cfaabi_ehm__try_terminate, .-__cfaabi_ehm__try_terminate\n"
    491 );
    492 
    493 // Somehow this piece of helps with the resolution of debug symbols.
    494 __attribute__((unused)) static const int dummy = 0;
    495 
    496 asm (
    497         // Add a hidden symbol which points at the function.
    498         "       .hidden CFA.ref.__gcfa_personality_v0\n"
    499         "       .weak   CFA.ref.__gcfa_personality_v0\n"
    500         // No clue what this does specifically
    501         "       .section        .data.rel.local.CFA.ref.__gcfa_personality_v0,\"awG\",@progbits,CFA.ref.__gcfa_personality_v0,comdat\n"
    502         "       .align 8\n"
    503         "       .type CFA.ref.__gcfa_personality_v0, @object\n"
    504         "       .size CFA.ref.__gcfa_personality_v0, 8\n"
    505         "CFA.ref.__gcfa_personality_v0:\n"
    506 #if defined( __x86_64 )
    507         "       .quad __gcfa_personality_v0\n"
    508 #else // then __i386
    509         "   .long __gcfa_personality_v0\n"
    510 #endif
    511 );
    512 #else
    513 #error Exception Handling: unknown architecture for position independent code.
    514 #endif // __i386 || __x86_64
    515 #else // __PIC__
    516 #if defined( __i386 ) || defined( __x86_64 )
    517 asm (
    518         // HEADER
    519         ".LFECFA1:\n"
    520         "       .globl  __gcfa_personality_v0\n"
    521         "       .section        .gcc_except_table,\"a\",@progbits\n"
    522         // TABLE HEADER (important field is the BODY length at the end)
    523         ".LLSDACFA2:\n"
    524         "       .byte   0xff\n"
    525         "       .byte   0xff\n"
    526         "       .byte   0x1\n"
    527         "       .uleb128 .LLSDACSECFA2-.LLSDACSBCFA2\n"
    528         // BODY (language specific data)
    529         ".LLSDACSBCFA2:\n"
    530         //      Handled area start (relative to start of function)
    531         "       .uleb128 .TRYSTART-__cfaabi_ehm__try_terminate\n"
    532         //      Handled area length
    533         "       .uleb128 .TRYEND-.TRYSTART\n"
    534         //      Handler landing pad address (relative to start of function)
    535         "       .uleb128 .CATCH-__cfaabi_ehm__try_terminate\n"
    536         //      Action code, gcc seems to always use 0.
    537         "       .uleb128 1\n"
    538         // TABLE FOOTER
    539         ".LLSDACSECFA2:\n"
    540         "       .text\n"
     474        "       .uleb128 .LLSDACSECFA2-.LLSDACSBCFA2\n"         // BODY length
     475        // Body uses language specific data and therefore could be modified arbitrarily
     476        ".LLSDACSBCFA2:\n"                                              // BODY start
     477        "       .uleb128 .TRYSTART-__cfaabi_ehm__try_terminate\n"               // Handled area start  (relative to start of function)
     478        "       .uleb128 .TRYEND-.TRYSTART\n"                           // Handled area length
     479        "       .uleb128 .CATCH-__cfaabi_ehm__try_terminate\n"                          // Hanlder landing pad adress  (relative to start of function)
     480        "       .uleb128 1\n"                                           // Action code, gcc seems to use always 0
     481        ".LLSDACSECFA2:\n"                                              // BODY end
     482        "       .text\n"                                                        // TABLE footer
    541483        "       .size   __cfaabi_ehm__try_terminate, .-__cfaabi_ehm__try_terminate\n"
    542484        "       .ident  \"GCC: (Ubuntu 6.2.0-3ubuntu11~16.04) 6.2.0 20160901\"\n"
    543         "       .section        .note.GNU-stack,\"x\",@progbits\n"
     485//      "       .section        .note.GNU-stack,\"x\",@progbits\n"
    544486);
    545 #else
    546 #error Exception Handling: unknown architecture for position dependent code.
    547487#endif // __i386 || __x86_64
    548 #endif // __PIC__
    549 
    550 #pragma GCC pop_options
     488#endif //PIC

  • libcfa/src/executor.cfa

    rb7d6a36 rdca5802  
    88#include <stdio.h>
    99
    10 forall( dtype T )
    11 monitor Buffer {                                        // unbounded buffer
    12     __queue_t( T ) queue;                               // unbounded list of work requests
    13     condition delay;
    14 }; // Buffer
    15 forall( dtype T | is_node(T) ) {
     10forall( otype T | is_node(T) | is_monitor(T) ) {
     11    monitor Buffer {                                    // unbounded buffer
     12        __queue_t( T ) queue;                           // unbounded list of work requests
     13        condition delay;
     14    }; // Buffer
     15
    1616    void insert( Buffer( T ) & mutex buf, T * elem ) with(buf) {
    1717        append( queue, elem );                          // insert element into buffer
    … …  
    2020
    2121    T * remove( Buffer( T ) & mutex buf ) with(buf) {
    22         if ( queue.head != 0 ) wait( delay );                   // no request to process ? => wait
    23 //      return pop_head( queue );
     22        if ( ! queue ) wait( delay );                   // no request to process ? => wait
     23        return pop_head( queue );
    2424    } // remove
    2525} // distribution

  • libcfa/src/fstream.cfa

    rb7d6a36 rdca5802  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Feb  7 19:01:01 2020
    13 // Update Count     : 363
     12// Last Modified On : Fri Nov 29 06:56:46 2019
     13// Update Count     : 355
    1414//
    1515
    … …  
    3232
    3333void ?{}( ofstream & os, void * file ) {
    34         os.$file = file;
    35         os.$sepDefault = true;
    36         os.$sepOnOff = false;
    37         os.$nlOnOff = true;
    38         os.$prt = false;
    39         os.$sawNL = false;
    40         $sepSetCur( os, sepGet( os ) );
     34        os.file = file;
     35        os.sepDefault = true;
     36        os.sepOnOff = false;
     37        os.nlOnOff = true;
     38        os.prt = false;
     39        os.sawNL = false;
    4140        sepSet( os, " " );
     41        sepSetCur( os, sepGet( os ) );
    4242        sepSetTuple( os, ", " );
    4343} // ?{}
    4444
    4545// private
    46 bool $sepPrt( ofstream & os ) { $setNL( os, false ); return os.$sepOnOff; }
    47 void $sepReset( ofstream & os ) { os.$sepOnOff = os.$sepDefault; }
    48 void $sepReset( ofstream & os, bool reset ) { os.$sepDefault = reset; os.$sepOnOff = os.$sepDefault; }
    49 const char * $sepGetCur( ofstream & os ) { return os.$sepCur; }
    50 void $sepSetCur( ofstream & os, const char sepCur[] ) { os.$sepCur = sepCur; }
    51 bool $getNL( ofstream & os ) { return os.$sawNL; }
    52 void $setNL( ofstream & os, bool state ) { os.$sawNL = state; }
    53 bool $getANL( ofstream & os ) { return os.$nlOnOff; }
    54 bool $getPrt( ofstream & os ) { return os.$prt; }
    55 void $setPrt( ofstream & os, bool state ) { os.$prt = state; }
     46bool sepPrt( ofstream & os ) { setNL( os, false ); return os.sepOnOff; }
     47void sepReset( ofstream & os ) { os.sepOnOff = os.sepDefault; }
     48void sepReset( ofstream & os, bool reset ) { os.sepDefault = reset; os.sepOnOff = os.sepDefault; }
     49const char * sepGetCur( ofstream & os ) { return os.sepCur; }
     50void sepSetCur( ofstream & os, const char * sepCur ) { os.sepCur = sepCur; }
     51bool getNL( ofstream & os ) { return os.sawNL; }
     52void setNL( ofstream & os, bool state ) { os.sawNL = state; }
     53bool getANL( ofstream & os ) { return os.nlOnOff; }
     54bool getPrt( ofstream & os ) { return os.prt; }
     55void setPrt( ofstream & os, bool state ) { os.prt = state; }
    5656
    5757// public
    58 void ?{}( ofstream & os ) { os.$file = 0p; }
    59 
    60 void ?{}( ofstream & os, const char name[], const char mode[] ) {
     58void ?{}( ofstream & os ) { os.file = 0; }
     59
     60void ?{}( ofstream & os, const char * name, const char * mode ) {
    6161        open( os, name, mode );
    6262} // ?{}
    6363
    64 void ?{}( ofstream & os, const char name[] ) {
     64void ?{}( ofstream & os, const char * name ) {
    6565        open( os, name, "w" );
    6666} // ?{}
    … …  
    7070} // ^?{}
    7171
    72 void sepOn( ofstream & os ) { os.$sepOnOff = ! $getNL( os ); }
    73 void sepOff( ofstream & os ) { os.$sepOnOff = false; }
     72void sepOn( ofstream & os ) { os.sepOnOff = ! getNL( os ); }
     73void sepOff( ofstream & os ) { os.sepOnOff = false; }
    7474
    7575bool sepDisable( ofstream & os ) {
    76         bool temp = os.$sepDefault;
    77         os.$sepDefault = false;
    78         $sepReset( os );
     76        bool temp = os.sepDefault;
     77        os.sepDefault = false;
     78        sepReset( os );
    7979        return temp;
    8080} // sepDisable
    8181
    8282bool sepEnable( ofstream & os ) {
    83         bool temp = os.$sepDefault;
    84         os.$sepDefault = true;
    85         if ( os.$sepOnOff ) $sepReset( os );                            // start of line ?
     83        bool temp = os.sepDefault;
     84        os.sepDefault = true;
     85        if ( os.sepOnOff ) sepReset( os );                                      // start of line ?
    8686        return temp;
    8787} // sepEnable
    8888
    89 void nlOn( ofstream & os ) { os.$nlOnOff = true; }
    90 void nlOff( ofstream & os ) { os.$nlOnOff = false; }
    91 
    92 const char * sepGet( ofstream & os ) { return os.$separator; }
    93 void sepSet( ofstream & os, const char s[] ) {
     89void nlOn( ofstream & os ) { os.nlOnOff = true; }
     90void nlOff( ofstream & os ) { os.nlOnOff = false; }
     91
     92const char * sepGet( ofstream & os ) { return os.separator; }
     93void sepSet( ofstream & os, const char * s ) {
    9494        assert( s );
    95         strncpy( os.$separator, s, sepSize - 1 );
    96         os.$separator[sepSize - 1] = '\0';
     95        strncpy( os.separator, s, sepSize - 1 );
     96        os.separator[sepSize - 1] = '\0';
    9797} // sepSet
    9898
    99 const char * sepGetTuple( ofstream & os ) { return os.$tupleSeparator; }
    100 void sepSetTuple( ofstream & os, const char s[] ) {
     99const char * sepGetTuple( ofstream & os ) { return os.tupleSeparator; }
     100void sepSetTuple( ofstream & os, const char * s ) {
    101101        assert( s );
    102         strncpy( os.$tupleSeparator, s, sepSize - 1 );
    103         os.$tupleSeparator[sepSize - 1] = '\0';
     102        strncpy( os.tupleSeparator, s, sepSize - 1 );
     103        os.tupleSeparator[sepSize - 1] = '\0';
    104104} // sepSet
    105105
    106106void ends( ofstream & os ) {
    107         if ( $getANL( os ) ) nl( os );
    108         else $setPrt( os, false );                                                      // turn off
     107        if ( getANL( os ) ) nl( os );
     108        else setPrt( os, false );                                                       // turn off
    109109        if ( &os == &exit ) exit( EXIT_FAILURE );
    110110        if ( &os == &abort ) abort();
    … …  
    112112
    113113int fail( ofstream & os ) {
    114         return os.$file == 0 || ferror( (FILE *)(os.$file) );
     114        return os.file == 0 || ferror( (FILE *)(os.file) );
    115115} // fail
    116116
    117117int flush( ofstream & os ) {
    118         return fflush( (FILE *)(os.$file) );
     118        return fflush( (FILE *)(os.file) );
    119119} // flush
    120120
    121 void open( ofstream & os, const char name[], const char mode[] ) {
     121void open( ofstream & os, const char * name, const char * mode ) {
    122122        FILE * file = fopen( name, mode );
    123123        #ifdef __CFA_DEBUG__
    124         if ( file == 0p ) {
     124        if ( file == 0 ) {
    125125                abort | IO_MSG "open output file \"" | name | "\"" | nl | strerror( errno );
    126126        } // if
    … …  
    129129} // open
    130130
    131 void open( ofstream & os, const char name[] ) {
     131void open( ofstream & os, const char * name ) {
    132132        open( os, name, "w" );
    133133} // open
    134134
    135135void close( ofstream & os ) {
    136         if ( (FILE *)(os.$file) == stdout || (FILE *)(os.$file) == stderr ) return;
    137 
    138         if ( fclose( (FILE *)(os.$file) ) == EOF ) {
     136        if ( (FILE *)(os.file) == stdout || (FILE *)(os.file) == stderr ) return;
     137
     138        if ( fclose( (FILE *)(os.file) ) == EOF ) {
    139139                abort | IO_MSG "close output" | nl | strerror( errno );
    140140        } // if
    141141} // close
    142142
    143 ofstream & write( ofstream & os, const char data[], size_t size ) {
     143ofstream & write( ofstream & os, const char * data, size_t size ) {
    144144        if ( fail( os ) ) {
    145145                abort | IO_MSG "attempt write I/O on failed stream";
    146146        } // if
    147147
    148         if ( fwrite( data, 1, size, (FILE *)(os.$file) ) != size ) {
     148        if ( fwrite( data, 1, size, (FILE *)(os.file) ) != size ) {
    149149                abort | IO_MSG "write" | nl | strerror( errno );
    150150        } // if
    … …  
    155155        va_list args;
    156156        va_start( args, format );
    157         int len = vfprintf( (FILE *)(os.$file), format, args );
     157        int len = vfprintf( (FILE *)(os.file), format, args );
    158158        if ( len == EOF ) {
    159                 if ( ferror( (FILE *)(os.$file) ) ) {
     159                if ( ferror( (FILE *)(os.file) ) ) {
    160160                        abort | IO_MSG "invalid write";
    161161                } // if
    … …  
    163163        va_end( args );
    164164
    165         $setPrt( os, true );                                                            // called in output cascade
    166         $sepReset( os );                                                                        // reset separator
     165        setPrt( os, true );                                                                     // called in output cascade
     166        sepReset( os );                                                                         // reset separator
    167167        return len;
    168168} // fmt
    … …  
    184184// private
    185185void ?{}( ifstream & is, void * file ) {
    186         is.$file = file;
    187         is.$nlOnOff = false;
     186        is.file = file;
     187        is.nlOnOff = false;
    188188} // ?{}
    189189
    190190// public
    191 void ?{}( ifstream & is ) { is.$file = 0p; }
    192 
    193 void ?{}( ifstream & is, const char name[], const char mode[] ) {
     191void ?{}( ifstream & is ) {     is.file = 0; }
     192
     193void ?{}( ifstream & is, const char * name, const char * mode ) {
    194194        open( is, name, mode );
    195195} // ?{}
    196196
    197 void ?{}( ifstream & is, const char name[] ) {
     197void ?{}( ifstream & is, const char * name ) {
    198198        open( is, name, "r" );
    199199} // ?{}
    … …  
    203203} // ^?{}
    204204
    205 void nlOn( ifstream & os ) { os.$nlOnOff = true; }
    206 void nlOff( ifstream & os ) { os.$nlOnOff = false; }
    207 bool getANL( ifstream & os ) { return os.$nlOnOff; }
     205void nlOn( ifstream & os ) { os.nlOnOff = true; }
     206void nlOff( ifstream & os ) { os.nlOnOff = false; }
     207bool getANL( ifstream & os ) { return os.nlOnOff; }
    208208
    209209int fail( ifstream & is ) {
    210         return is.$file == 0p || ferror( (FILE *)(is.$file) );
     210        return is.file == 0 || ferror( (FILE *)(is.file) );
    211211} // fail
    212212
    213213int eof( ifstream & is ) {
    214         return feof( (FILE *)(is.$file) );
     214        return feof( (FILE *)(is.file) );
    215215} // eof
    216216
    217 void open( ifstream & is, const char name[], const char mode[] ) {
     217void open( ifstream & is, const char * name, const char * mode ) {
    218218        FILE * file = fopen( name, mode );
    219219        #ifdef __CFA_DEBUG__
    220         if ( file == 0p ) {
     220        if ( file == 0 ) {
    221221                abort | IO_MSG "open input file \"" | name | "\"" | nl | strerror( errno );
    222222        } // if
    223223        #endif // __CFA_DEBUG__
    224         is.$file = file;
    225 } // open
    226 
    227 void open( ifstream & is, const char name[] ) {
     224        is.file = file;
     225} // open
     226
     227void open( ifstream & is, const char * name ) {
    228228        open( is, name, "r" );
    229229} // open
    230230
    231231void close( ifstream & is ) {
    232         if ( (FILE *)(is.$file) == stdin ) return;
    233 
    234         if ( fclose( (FILE *)(is.$file) ) == EOF ) {
     232        if ( (FILE *)(is.file) == stdin ) return;
     233
     234        if ( fclose( (FILE *)(is.file) ) == EOF ) {
    235235                abort | IO_MSG "close input" | nl | strerror( errno );
    236236        } // if
    … …  
    242242        } // if
    243243
    244         if ( fread( data, size, 1, (FILE *)(is.$file) ) == 0 ) {
     244        if ( fread( data, size, 1, (FILE *)(is.file) ) == 0 ) {
    245245                abort | IO_MSG "read" | nl | strerror( errno );
    246246        } // if
    … …  
    253253        } // if
    254254
    255         if ( ungetc( c, (FILE *)(is.$file) ) == EOF ) {
     255        if ( ungetc( c, (FILE *)(is.file) ) == EOF ) {
    256256                abort | IO_MSG "ungetc" | nl | strerror( errno );
    257257        } // if
    … …  
    263263
    264264        va_start( args, format );
    265         int len = vfscanf( (FILE *)(is.$file), format, args );
     265        int len = vfscanf( (FILE *)(is.file), format, args );
    266266        if ( len == EOF ) {
    267                 if ( ferror( (FILE *)(is.$file) ) ) {
     267                if ( ferror( (FILE *)(is.file) ) ) {
    268268                        abort | IO_MSG "invalid read";
    269269                } // if

  • libcfa/src/fstream.hfa

    rb7d6a36 rdca5802  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Feb 17 08:29:23 2020
    13 // Update Count     : 175
     12// Last Modified On : Fri Nov 29 06:56:02 2019
     13// Update Count     : 168
    1414//
    1515
    … …  
    2424enum { sepSize = 16 };
    2525struct ofstream {
    26         void * $file;
    27         bool $sepDefault;
    28         bool $sepOnOff;
    29         bool $nlOnOff;
    30         bool $prt;                                                                                      // print text
    31         bool $sawNL;
    32         const char * $sepCur;
    33         char $separator[sepSize];
    34         char $tupleSeparator[sepSize];
     26        void * file;
     27        bool sepDefault;
     28        bool sepOnOff;
     29        bool nlOnOff;
     30        bool prt;                                                                                       // print text
     31        bool sawNL;
     32        const char * sepCur;
     33        char separator[sepSize];
     34        char tupleSeparator[sepSize];
    3535}; // ofstream
    3636
    3737// private
    38 bool $sepPrt( ofstream & );
    39 void $sepReset( ofstream & );
    40 void $sepReset( ofstream &, bool );
    41 const char * $sepGetCur( ofstream & );
    42 void $sepSetCur( ofstream &, const char [] );
    43 bool $getNL( ofstream & );
    44 void $setNL( ofstream &, bool );
    45 bool $getANL( ofstream & );
    46 bool $getPrt( ofstream & );
    47 void $setPrt( ofstream &, bool );
     38bool sepPrt( ofstream & );
     39void sepReset( ofstream & );
     40void sepReset( ofstream &, bool );
     41const char * sepGetCur( ofstream & );
     42void sepSetCur( ofstream &, const char * );
     43bool getNL( ofstream & );
     44void setNL( ofstream &, bool );
     45bool getANL( ofstream & );
     46bool getPrt( ofstream & );
     47void setPrt( ofstream &, bool );
    4848
    4949// public
    … …  
    5656
    5757const char * sepGet( ofstream & );
    58 void sepSet( ofstream &, const char [] );
     58void sepSet( ofstream &, const char * );
    5959const char * sepGetTuple( ofstream & );
    60 void sepSetTuple( ofstream &, const char [] );
     60void sepSetTuple( ofstream &, const char * );
    6161
    6262void ends( ofstream & os );
    6363int fail( ofstream & );
    6464int flush( ofstream & );
    65 void open( ofstream &, const char name[], const char mode[] );
    66 void open( ofstream &, const char name[] );
     65void open( ofstream &, const char * name, const char * mode );
     66void open( ofstream &, const char * name );
    6767void close( ofstream & );
    68 ofstream & write( ofstream &, const char data[], size_t size );
    69 int fmt( ofstream &, const char format[], ... ) __attribute__(( format(printf, 2, 3) ));
     68ofstream & write( ofstream &, const char * data, size_t size );
     69int fmt( ofstream &, const char format[], ... );
    7070
    7171void ?{}( ofstream & os );
    72 void ?{}( ofstream & os, const char name[], const char mode[] );
    73 void ?{}( ofstream & os, const char name[] );
     72void ?{}( ofstream & os, const char * name, const char * mode );
     73void ?{}( ofstream & os, const char * name );
    7474void ^?{}( ofstream & os );
    7575
    … …  
    8282
    8383struct ifstream {
    84         void * $file;
    85         bool $nlOnOff;
     84        void * file;
     85        bool nlOnOff;
    8686}; // ifstream
    8787
    … …  
    9292int fail( ifstream & is );
    9393int eof( ifstream & is );
    94 void open( ifstream & is, const char name[], const char mode[] );
    95 void open( ifstream & is, const char name[] );
     94void open( ifstream & is, const char * name, const char * mode );
     95void open( ifstream & is, const char * name );
    9696void close( ifstream & is );
    9797ifstream & read( ifstream & is, char * data, size_t size );
    9898ifstream & ungetc( ifstream & is, char c );
    99 int fmt( ifstream &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
     99int fmt( ifstream &, const char format[], ... );
    100100
    101101void ?{}( ifstream & is );
    102 void ?{}( ifstream & is, const char name[], const char mode[] );
    103 void ?{}( ifstream & is, const char name[] );
     102void ?{}( ifstream & is, const char * name, const char * mode );
     103void ?{}( ifstream & is, const char * name );
    104104void ^?{}( ifstream & is );
    105105

  • libcfa/src/gmp.hfa

    rb7d6a36 rdca5802  
    1010// Created On       : Tue Apr 19 08:43:43 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Feb  9 09:56:54 2020
    13 // Update Count     : 31
     12// Last Modified On : Sat Jul 13 15:25:05 2019
     13// Update Count     : 27
    1414//
    1515
    … …  
    2424
    2525static inline {
    26         // constructor, zero_t/one_t are unnecessary because of relationship with signed/unsigned int
     26        // constructor
    2727        void ?{}( Int & this ) { mpz_init( this.mpz ); }
    2828        void ?{}( Int & this, Int init ) { mpz_init_set( this.mpz, init.mpz ); }
     29        void ?{}( Int & this, zero_t ) { mpz_init_set_si( this.mpz, 0 ); }
     30        void ?{}( Int & this, one_t ) { mpz_init_set_si( this.mpz, 1 ); }
    2931        void ?{}( Int & this, signed long int init ) { mpz_init_set_si( this.mpz, init ); }
    3032        void ?{}( Int & this, unsigned long int init ) { mpz_init_set_ui( this.mpz, init ); }
    31         void ?{}( Int & this, const char val[] ) { if ( mpz_init_set_str( this.mpz, val, 0 ) ) abort(); }
     33        void ?{}( Int & this, const char * val ) { if ( mpz_init_set_str( this.mpz, val, 0 ) ) abort(); }
    3234        void ^?{}( Int & this ) { mpz_clear( this.mpz ); }
    3335
    … …  
    3537        Int ?`mp( signed long int init ) { return (Int){ init }; }
    3638        Int ?`mp( unsigned long int init ) { return (Int){ init }; }
    37         Int ?`mp( const char init[] ) { return (Int){ init }; }
     39        Int ?`mp( const char * init ) { return (Int){ init }; }
    3840
    3941        // assignment
    … …  
    4143        Int ?=?( Int & lhs, long int rhs ) { mpz_set_si( lhs.mpz, rhs ); return lhs; }
    4244        Int ?=?( Int & lhs, unsigned long int rhs ) { mpz_set_ui( lhs.mpz, rhs ); return lhs; }
    43         Int ?=?( Int & lhs, const char rhs[] ) { if ( mpz_set_str( lhs.mpz, rhs, 0 ) ) { abort | "invalid string conversion"; } return lhs; }
     45        Int ?=?( Int & lhs, const char * rhs ) { if ( mpz_set_str( lhs.mpz, rhs, 0 ) ) { abort | "invalid string conversion"; } return lhs; }
    4446
    4547        char ?=?( char & lhs, Int rhs ) { char val = mpz_get_si( rhs.mpz ); lhs = val; return lhs; }
    … …  
    263265        forall( dtype ostype | ostream( ostype ) ) {
    264266                ostype & ?|?( ostype & os, Int mp ) {
    265                         if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     267                        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    266268                        gmp_printf( "%Zd", mp.mpz );
    267269                        sepOn( os );

  • libcfa/src/heap.cfa

    rb7d6a36 rdca5802  
    1010// Created On       : Tue Dec 19 21:58:35 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb  4 10:04:51 2020
    13 // Update Count     : 648
     12// Last Modified On : Sun Dec  8 21:01:31 2019
     13// Update Count     : 647
    1414//
    1515
    … …  
    380380
    381381
    382 static inline void checkHeader( bool check, const char name[], void * addr ) {
     382static inline void checkHeader( bool check, const char * name, void * addr ) {
    383383        if ( unlikely( check ) ) {                                                      // bad address ?
    384384                abort( "Attempt to %s storage %p with address outside the heap.\n"
    … …  
    418418
    419419
    420 static inline bool headers( const char name[] __attribute__(( unused )), void * addr, HeapManager.Storage.Header *& header, HeapManager.FreeHeader *& freeElem, size_t & size, size_t & alignment ) with ( heapManager ) {
     420static inline bool headers( const char * name __attribute__(( unused )), void * addr, HeapManager.Storage.Header *& header, HeapManager.FreeHeader *& freeElem, size_t & size, size_t & alignment ) with ( heapManager ) {
    421421        header = headerAddr( addr );
    422422

  • libcfa/src/interpose.cfa

    rb7d6a36 rdca5802  
    1010// Created On       : Wed Mar 29 16:10:31 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Feb 17 10:18:53 2020
    13 // Update Count     : 166
     12// Last Modified On : Sat Nov 30 07:09:42 2019
     13// Update Count     : 119
    1414//
    1515
    … …  
    2929#include "bits/signal.hfa"                                                              // sigHandler_?
    3030#include "startup.hfa"                                                                  // STARTUP_PRIORITY_CORE
    31 #include <assert.h>
    3231
    3332//=============================================================================================
    … …  
    4140
    4241typedef void (* generic_fptr_t)(void);
    43 generic_fptr_t interpose_symbol( const char symbol[], const char version[] ) {
     42generic_fptr_t interpose_symbol( const char * symbol, const char * version ) {
    4443        const char * error;
    4544
    … …  
    9695        void __cfaabi_interpose_startup(void)  __attribute__(( constructor( STARTUP_PRIORITY_CORE ) ));
    9796        void __cfaabi_interpose_startup( void ) {
    98                 const char *version = 0p;
     97                const char *version = NULL;
    9998
    10099                preload_libgcc();
    … …  
    106105#pragma GCC diagnostic pop
    107106
    108                 // As a precaution (and necessity), errors that result in termination are delivered on a separate stack because
    109                 // task stacks might be very small (4K) and the signal delivery corrupts memory to the point that a clean
    110                 // shutdown is impossible. Also, when a stack overflow encounters the non-accessible sentinel page (debug only)
    111                 // and generates a segment fault, the signal cannot be delivered on the sentinel page. Finally, calls to abort
    112                 // print a stack trace that uses substantial stack space.
    113 
    114                 #define MINSTKSZ SIGSTKSZ * 8
    115                 static char stack[MINSTKSZ] __attribute__(( aligned (16) ));
    116                 static stack_t ss;
    117 
    118                 ss.ss_sp = stack;
    119                 ss.ss_size = MINSTKSZ;
    120                 ss.ss_flags = 0;
    121                 if ( sigaltstack( &ss, 0p ) == -1 ) {
    122                         abort( "__cfaabi_interpose_startup : internal error, sigaltstack error(%d) %s.", errno, strerror( errno ) );
    123                 } // if
    124 
    125107                // Failure handler
    126                 __cfaabi_sigaction( SIGSEGV, sigHandler_segv, SA_SIGINFO | SA_ONSTACK );
    127                 __cfaabi_sigaction( SIGBUS , sigHandler_segv, SA_SIGINFO | SA_ONSTACK );
    128                 __cfaabi_sigaction( SIGILL , sigHandler_ill , SA_SIGINFO | SA_ONSTACK );
    129                 __cfaabi_sigaction( SIGFPE , sigHandler_fpe , SA_SIGINFO | SA_ONSTACK );
    130                 __cfaabi_sigaction( SIGTERM, sigHandler_term, SA_SIGINFO | SA_ONSTACK | SA_RESETHAND ); // one shot handler, return to default
    131                 __cfaabi_sigaction( SIGINT , sigHandler_term, SA_SIGINFO | SA_ONSTACK | SA_RESETHAND );
    132                 __cfaabi_sigaction( SIGABRT, sigHandler_term, SA_SIGINFO | SA_ONSTACK | SA_RESETHAND );
    133                 __cfaabi_sigaction( SIGHUP , sigHandler_term, SA_SIGINFO | SA_ONSTACK | SA_RESETHAND ); // terminal hangup
     108                __cfaabi_sigaction( SIGSEGV, sigHandler_segv , SA_SIGINFO );
     109                __cfaabi_sigaction( SIGBUS , sigHandler_segv , SA_SIGINFO );
     110                __cfaabi_sigaction( SIGILL , sigHandler_ill  , SA_SIGINFO );
     111                __cfaabi_sigaction( SIGFPE , sigHandler_fpe  , SA_SIGINFO );
     112                __cfaabi_sigaction( SIGABRT, sigHandler_abrt, SA_SIGINFO | SA_RESETHAND);
     113                __cfaabi_sigaction( SIGTERM, sigHandler_term , SA_SIGINFO );
     114                __cfaabi_sigaction( SIGINT , sigHandler_term , SA_SIGINFO );
    134115        }
    135116}
    … …  
    142123void exit( int status, const char fmt[], ... ) __attribute__(( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ ));
    143124void abort( const char fmt[], ... ) __attribute__(( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ ));
    144 void abort( bool signalAbort, const char fmt[], ... ) __attribute__(( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ ));
    145125
    146126extern "C" {
    147127        void abort( void ) __attribute__(( __nothrow__, __leaf__, __noreturn__ )) {
    148                 abort( false, "%s", "" );
     128                abort( NULL );
    149129        }
    150130
    … …  
    152132                va_list argp;
    153133                va_start( argp, fmt );
    154                 abort( false, fmt, argp );
     134                abort( fmt, argp );
    155135                va_end( argp );
    156136        }
    … …  
    161141}
    162142
    163 void * kernel_abort( void ) __attribute__(( __nothrow__, __leaf__, __weak__ )) { return 0p; }
    164 void kernel_abort_msg( void * data, char buffer[], int size ) __attribute__(( __nothrow__, __leaf__, __weak__ )) {}
    165 // See concurrency/kernel.cfa for strong definition used in multi-processor mode.
     143void * kernel_abort    ( void ) __attribute__(( __nothrow__, __leaf__, __weak__ )) { return NULL; }
     144void   kernel_abort_msg( void * data, char * buffer, int size ) __attribute__(( __nothrow__, __leaf__, __weak__ )) {}
    166145int kernel_abort_lastframe( void ) __attribute__(( __nothrow__, __leaf__, __weak__ )) { return 4; }
    167146
    168147enum { abort_text_size = 1024 };
    169148static char abort_text[ abort_text_size ];
    170 
    171 static void __cfaabi_backtrace( int start ) {
    172         enum { Frames = 50, };                                                          // maximum number of stack frames
    173         int last = kernel_abort_lastframe();                            // skip last N stack frames
     149static int abort_lastframe;
     150
     151void exit( int status, const char fmt[], ... ) __attribute__(( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ )) {
     152    va_list args;
     153    va_start( args, fmt );
     154    vfprintf( stderr, fmt, args );
     155    va_end( args );
     156        __cabi_libc.exit( status );
     157}
     158
     159void abort( const char fmt[], ... ) __attribute__(( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ )) {
     160        void * kernel_data = kernel_abort();                    // must be done here to lock down kernel
     161        int len;
     162
     163        abort_lastframe = kernel_abort_lastframe();
     164        len = snprintf( abort_text, abort_text_size, "Cforall Runtime error (UNIX pid:%ld) ", (long int)getpid() ); // use UNIX pid (versus getPid)
     165        __cfaabi_dbg_write( abort_text, len );
     166
     167        if ( fmt ) {
     168                va_list args;
     169                va_start( args, fmt );
     170
     171                len = vsnprintf( abort_text, abort_text_size, fmt, args );
     172                va_end( args );
     173                __cfaabi_dbg_write( abort_text, len );
     174
     175                if ( fmt[strlen( fmt ) - 1] != '\n' ) {         // add optional newline if missing at the end of the format text
     176                        __cfaabi_dbg_write( "\n", 1 );
     177                }
     178        }
     179
     180        kernel_abort_msg( kernel_data, abort_text, abort_text_size );
     181        __cabi_libc.abort();
     182}
     183
     184static void __cfaabi_backtrace() {
     185        enum {
     186                Frames = 50,                                                                    // maximum number of stack frames
     187                Start = 8,                                                                              // skip first N stack frames
     188        };
    174189
    175190        void * array[Frames];
    176191        size_t size = backtrace( array, Frames );
    177         char ** messages = backtrace_symbols( array, size ); // does not demangle names
    178 
    179         *index( messages[0], '(' ) = '\0';                                      // find executable name
     192        char ** messages = backtrace_symbols( array, size );
     193
     194        // find executable name
     195        *index( messages[0], '(' ) = '\0';
    180196        __cfaabi_bits_print_nolock( STDERR_FILENO, "Stack back trace for: %s\n", messages[0]);
    181197
    182         for ( unsigned int i = start; i < size - last && messages != 0p; i += 1 ) {
     198        for ( int i = Start; i < size - abort_lastframe && messages != 0p; i += 1 ) {
    183199                char * name = 0p, * offset_begin = 0p, * offset_end = 0p;
    184200
    185                 for ( char * p = messages[i]; *p; p += 1 ) {    // find parantheses and +offset
     201                for ( char * p = messages[i]; *p; ++p ) {
    186202                        //__cfaabi_bits_print_nolock( "X %s\n", p);
     203                        // find parantheses and +offset
    187204                        if ( *p == '(' ) {
    188205                                name = p;
    … …  
    195212                }
    196213
    197                 // if line contains symbol, print it
    198                 int frameNo = i - start;
     214                // if line contains symbol print it
     215                int frameNo = i - Start;
    199216                if ( name && offset_begin && offset_end && name < offset_begin ) {
    200                         *name++ = '\0';                                                         // delimit strings
     217                        // delimit strings
     218                        *name++ = '\0';
    201219                        *offset_begin++ = '\0';
    202220                        *offset_end++ = '\0';
    … …  
    210228}
    211229
    212 void exit( int status, const char fmt[], ... ) {
    213         va_list args;
    214         va_start( args, fmt );
    215         vfprintf( stderr, fmt, args );
    216         va_end( args );
    217         __cabi_libc.exit( status );
    218 }
    219 
    220 void abort( bool signalAbort, const char fmt[], ... ) {
    221         void * kernel_data = kernel_abort();                            // must be done here to lock down kernel
    222         int len;
    223 
    224         signal( SIGABRT, SIG_DFL );                                                     // prevent final "real" abort from recursing to handler
    225 
    226         len = snprintf( abort_text, abort_text_size, "Cforall Runtime error (UNIX pid:%ld) ", (long int)getpid() ); // use UNIX pid (versus getPid)
    227         __cfaabi_bits_write( STDERR_FILENO, abort_text, len );
    228 
    229         assert( fmt );
    230         va_list args;
    231         va_start( args, fmt );
    232 
    233         len = vsnprintf( abort_text, abort_text_size, fmt, args );
    234         va_end( args );
    235         __cfaabi_bits_write( STDERR_FILENO, abort_text, len );
    236 
    237         if ( fmt[strlen( fmt ) - 1] != '\n' ) {                         // add optional newline if missing at the end of the format text
    238                 __cfaabi_dbg_write( "\n", 1 );
    239         } // if
    240         kernel_abort_msg( kernel_data, abort_text, abort_text_size );
    241 
    242         __cfaabi_backtrace( signalAbort ? 4 : 2 );
    243 
    244         __cabi_libc.abort();                                                            // print stack trace in handler
    245 }
    246 
    247 void abort( const char fmt[], ... ) {
    248         va_list args;
    249         va_start( args, fmt );
    250         abort( false, fmt, args );
    251         va_end( args );
    252 }
    253 
    254230void sigHandler_segv( __CFA_SIGPARMS__ ) {
    255                 if ( sfp->si_addr == 0p ) {
    256                         abort( true, "Null pointer (0p) dereference.\n" );
    257                 } else {
    258                         abort( true, "%s at memory location %p.\n"
    259                                    "Possible cause is reading outside the address space or writing to a protected area within the address space with an invalid pointer or subscript.\n",
    260                                    (sig == SIGSEGV ? "Segment fault" : "Bus error"), sfp->si_addr );
    261                 }
     231        abort( "Addressing invalid memory at location %p\n"
     232                        "Possible cause is reading outside the address space or writing to a protected area within the address space with an invalid pointer or subscript.\n",
     233                        sfp->si_addr );
    262234}
    263235
    264236void sigHandler_ill( __CFA_SIGPARMS__ ) {
    265         abort( true, "Executing illegal instruction at location %p.\n"
     237        abort( "Executing illegal instruction at location %p.\n"
    266238                        "Possible cause is stack corruption.\n",
    267239                        sfp->si_addr );
    … …  
    279251          default: msg = "unknown";
    280252        } // choose
    281         abort( true, "Computation error %s at location %p.\n", msg, sfp->si_addr );
     253        abort( "Computation error %s at location %p.\n", msg, sfp->si_addr );
     254}
     255
     256void sigHandler_abrt( __CFA_SIGPARMS__ ) {
     257        __cfaabi_backtrace();
     258
     259        // reset default signal handler
     260        __cfaabi_sigdefault( SIGABRT );
     261
     262        raise( SIGABRT );
    282263}
    283264
    284265void sigHandler_term( __CFA_SIGPARMS__ ) {
    285         abort( true, "Application interrupted by signal: %s.\n", strsignal( sig ) );
     266        abort( "Application stopped by %s signal.", sig == SIGINT ? "an interrupt (SIGINT)" : "a terminate (SIGTERM)" );
    286267}
    287268

  • libcfa/src/iostream.cfa

    rb7d6a36 rdca5802  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 20 15:53:23 2020
    13 // Update Count     : 829
     12// Last Modified On : Sat Jul 13 08:07:59 2019
     13// Update Count     : 821
    1414//
    1515
    … …  
    1919#include <stdio.h>
    2020#include <stdbool.h>                                                                    // true/false
    21 #include <stdint.h>                                                                             // UINT64_MAX
    2221//#include <string.h>                                                                   // strlen, strcmp
    2322extern size_t strlen (const char *__s) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
    … …  
    3635forall( dtype ostype | ostream( ostype ) ) {
    3736        ostype & ?|?( ostype & os, zero_t ) {
    38                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     37                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    3938                fmt( os, "%d", 0n );
    4039                return os;
    … …  
    4544
    4645        ostype & ?|?( ostype & os, one_t ) {
    47                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     46                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    4847                fmt( os, "%d", 1n );
    4948                return os;
    … …  
    5453
    5554        ostype & ?|?( ostype & os, bool b ) {
    56                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     55                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    5756                fmt( os, "%s", b ? "true" : "false" );
    5857                return os;
    … …  
    6463        ostype & ?|?( ostype & os, char c ) {
    6564                fmt( os, "%c", c );
    66                 if ( c == '\n' ) $setNL( os, true );
     65                if ( c == '\n' ) setNL( os, true );
    6766                return sepOff( os );
    6867        } // ?|?
    … …  
    7271
    7372        ostype & ?|?( ostype & os, signed char sc ) {
    74                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     73                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    7574                fmt( os, "%hhd", sc );
    7675                return os;
    … …  
    8180
    8281        ostype & ?|?( ostype & os, unsigned char usc ) {
    83                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     82                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    8483                fmt( os, "%hhu", usc );
    8584                return os;
    … …  
    9089
    9190        ostype & ?|?( ostype & os, short int si ) {
    92                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     91                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    9392                fmt( os, "%hd", si );
    9493                return os;
    … …  
    9998
    10099        ostype & ?|?( ostype & os, unsigned short int usi ) {
    101                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     100                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    102101                fmt( os, "%hu", usi );
    103102                return os;
    … …  
    108107
    109108        ostype & ?|?( ostype & os, int i ) {
    110                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     109                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    111110                fmt( os, "%d", i );
    112111                return os;
    … …  
    117116
    118117        ostype & ?|?( ostype & os, unsigned int ui ) {
    119                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     118                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    120119                fmt( os, "%u", ui );
    121120                return os;
    … …  
    126125
    127126        ostype & ?|?( ostype & os, long int li ) {
    128                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     127                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    129128                fmt( os, "%ld", li );
    130129                return os;
    … …  
    135134
    136135        ostype & ?|?( ostype & os, unsigned long int uli ) {
    137                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     136                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    138137                fmt( os, "%lu", uli );
    139138                return os;
    … …  
    144143
    145144        ostype & ?|?( ostype & os, long long int lli ) {
    146                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     145                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    147146                fmt( os, "%lld", lli );
    148147                return os;
    … …  
    153152
    154153        ostype & ?|?( ostype & os, unsigned long long int ulli ) {
    155                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     154                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    156155                fmt( os, "%llu", ulli );
    157156                return os;
    … …  
    160159                (ostype &)(os | ulli); ends( os );
    161160        } // ?|?
    162 
    163 #if defined( __SIZEOF_INT128__ )
    164         //      UINT64_MAX 18_446_744_073_709_551_615_ULL
    165         #define P10_UINT64 10_000_000_000_000_000_000_ULL       // 19 zeroes
    166 
    167         static void base10_128( ostype & os, unsigned int128 val ) {
    168                 if ( val > UINT64_MAX ) {
    169                         base10_128( os, val / P10_UINT64 );                     // recursive
    170                         fmt( os, "%.19lu", (uint64_t)(val % P10_UINT64) );
    171                 } else {
    172                         fmt( os, "%lu", (uint64_t)val );
    173                 } // if
    174         } // base10_128
    175 
    176         static void base10_128( ostype & os, int128 val ) {
    177                 if ( val < 0 ) {
    178                         fmt( os, "-" );                                                         // leading negative sign
    179                         val = -val;
    180                 } // if
    181                 base10_128( os, (unsigned int128)val );                 // print zero/positive value
    182         } // base10_128
    183 
    184         ostype & ?|?( ostype & os, int128 llli ) {
    185                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
    186                 base10_128( os, llli );
    187                 return os;
    188         } // ?|?
    189         void & ?|?( ostype & os, int128 llli ) {
    190                 (ostype &)(os | llli); ends( os );
    191         } // ?|?
    192 
    193         ostype & ?|?( ostype & os, unsigned int128 ullli ) {
    194                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
    195                 base10_128( os, ullli );
    196                 return os;
    197         } // ?|?
    198         void & ?|?( ostype & os, unsigned int128 ullli ) {
    199                 (ostype &)(os | ullli); ends( os );
    200         } // ?|?
    201 #endif // __SIZEOF_INT128__
    202161
    203162        #define PrintWithDP( os, format, val, ... ) \
    … …  
    216175
    217176        ostype & ?|?( ostype & os, float f ) {
    218                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     177                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    219178                PrintWithDP( os, "%g", f );
    220179                return os;
    … …  
    225184
    226185        ostype & ?|?( ostype & os, double d ) {
    227                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     186                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    228187                PrintWithDP( os, "%.*lg", d, DBL_DIG );
    229188                return os;
    … …  
    234193
    235194        ostype & ?|?( ostype & os, long double ld ) {
    236                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     195                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    237196                PrintWithDP( os, "%.*Lg", ld, LDBL_DIG );
    238197                return os;
    … …  
    243202
    244203        ostype & ?|?( ostype & os, float _Complex fc ) {
    245                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     204                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    246205//              os | crealf( fc ) | nonl;
    247206                PrintWithDP( os, "%g", crealf( fc ) );
    … …  
    255214
    256215        ostype & ?|?( ostype & os, double _Complex dc ) {
    257                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     216                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    258217//              os | creal( dc ) | nonl;
    259218                PrintWithDP( os, "%.*lg", creal( dc ), DBL_DIG );
    … …  
    267226
    268227        ostype & ?|?( ostype & os, long double _Complex ldc ) {
    269                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     228                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    270229//              os | creall( ldc ) || nonl;
    271230                PrintWithDP( os, "%.*Lg", creall( ldc ), LDBL_DIG );
    … …  
    278237        } // ?|?
    279238
    280         ostype & ?|?( ostype & os, const char str[] ) {
     239        ostype & ?|?( ostype & os, const char * str ) {
    281240                enum { Open = 1, Close, OpenClose };
    282241                static const unsigned char mask[256] @= {
    … …  
    298257                // first character IS NOT spacing or closing punctuation => add left separator
    299258                unsigned char ch = str[0];                                              // must make unsigned
    300                 if ( $sepPrt( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {
    301                         fmt( os, "%s", $sepGetCur( os ) );
     259                if ( sepPrt( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {
     260                        fmt( os, "%s", sepGetCur( os ) );
    302261                } // if
    303262
    304263                // if string starts line, must reset to determine open state because separator is off
    305                 $sepReset( os );                                                                // reset separator
     264                sepReset( os );                                                                 // reset separator
    306265
    307266                // last character IS spacing or opening punctuation => turn off separator for next item
    308267                size_t len = strlen( str );
    309268                ch = str[len - 1];                                                              // must make unsigned
    310                 if ( $sepPrt( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {
     269                if ( sepPrt( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {
    311270                        sepOn( os );
    312271                } else {
    313272                        sepOff( os );
    314273                } // if
    315                 if ( ch == '\n' ) $setNL( os, true );                   // check *AFTER* $sepPrt call above as it resets NL flag
     274                if ( ch == '\n' ) setNL( os, true );                    // check *AFTER* sepPrt call above as it resets NL flag
    316275                return write( os, str, len );
    317276        } // ?|?
    318 
    319         void ?|?( ostype & os, const char str[] ) {
     277        void ?|?( ostype & os, const char * str ) {
    320278                (ostype &)(os | str); ends( os );
    321279        } // ?|?
    322280
    323281//      ostype & ?|?( ostype & os, const char16_t * str ) {
    324 //              if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     282//              if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    325283//              fmt( os, "%ls", str );
    326284//              return os;
    … …  
    329287// #if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
    330288//      ostype & ?|?( ostype & os, const char32_t * str ) {
    331 //              if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     289//              if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    332290//              fmt( os, "%ls", str );
    333291//              return os;
    … …  
    336294
    337295//      ostype & ?|?( ostype & os, const wchar_t * str ) {
    338 //              if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     296//              if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    339297//              fmt( os, "%ls", str );
    340298//              return os;
    … …  
    342300
    343301        ostype & ?|?( ostype & os, const void * p ) {
    344                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     302                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    345303                fmt( os, "%p", p );
    346304                return os;
    … …  
    357315        void ?|?( ostype & os, ostype & (* manip)( ostype & ) ) {
    358316                (ostype &)(manip( os ));
    359                 if ( $getPrt( os ) ) ends( os );                                // something printed ?
    360                 $setPrt( os, false );                                                   // turn off
     317                if ( getPrt( os ) ) ends( os );                                 // something printed ?
     318                setPrt( os, false );                                                    // turn off
    361319        } // ?|?
    362320
    … …  
    371329        ostype & nl( ostype & os ) {
    372330                (ostype &)(os | '\n');
    373                 $setPrt( os, false );                                                   // turn off
    374                 $setNL( os, true );
     331                setPrt( os, false );                                                    // turn off
     332                setNL( os, true );
    375333                flush( os );
    376334                return sepOff( os );                                                    // prepare for next line
    … …  
    378336
    379337        ostype & nonl( ostype & os ) {
    380                 $setPrt( os, false );                                                   // turn off
     338                setPrt( os, false );                                                    // turn off
    381339                return os;
    382340        } // nonl
    … …  
    417375        ostype & ?|?( ostype & os, T arg, Params rest ) {
    418376                (ostype &)(os | arg);                                                   // print first argument
    419                 $sepSetCur( os, sepGetTuple( os ) );                    // switch to tuple separator
     377                sepSetCur( os, sepGetTuple( os ) );                             // switch to tuple separator
    420378                (ostype &)(os | rest);                                                  // print remaining arguments
    421                 $sepSetCur( os, sepGet( os ) );                                 // switch to regular separator
     379                sepSetCur( os, sepGet( os ) );                                  // switch to regular separator
    422380                return os;
    423381        } // ?|?
    … …  
    425383                // (ostype &)(?|?( os, arg, rest )); ends( os );
    426384                (ostype &)(os | arg);                                                   // print first argument
    427                 $sepSetCur( os, sepGetTuple( os ) );                    // switch to tuple separator
     385                sepSetCur( os, sepGetTuple( os ) );                             // switch to tuple separator
    428386                (ostype &)(os | rest);                                                  // print remaining arguments
    429                 $sepSetCur( os, sepGet( os ) );                                 // switch to regular separator
     387                sepSetCur( os, sepGet( os ) );                                  // switch to regular separator
    430388                ends( os );
    431389        } // ?|?
    … …  
    456414forall( dtype ostype | ostream( ostype ) ) { \
    457415        ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \
    458                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \
     416                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); \
    459417\
    460418                if ( f.base == 'b' || f.base == 'B' ) {                 /* bespoke binary format */ \
    … …  
    505463\
    506464                if ( ! f.flags.pc ) {                                                   /* no precision */ \
     465                        /* printf( "%s\n", &fmtstr[star] ); */ \
    507466                        fmtstr[sizeof(IFMTNP)-2] = f.base;                      /* sizeof includes '\0' */ \
    508                         /* printf( "%s %c %c\n", &fmtstr[star], f.base, CODE ); */ \
    509467                        fmt( os, &fmtstr[star], f.wd, f.val ); \
    510468                } else {                                                                                /* precision */ \
    511469                        fmtstr[sizeof(IFMTP)-2] = f.base;                       /* sizeof includes '\0' */ \
    512                         /* printf( "%s %c %c\n", &fmtstr[star], f.base, CODE ); */ \
     470                        /* printf( "%s\n", &fmtstr[star] ); */ \
    513471                        fmt( os, &fmtstr[star], f.wd, f.pc, f.val ); \
    514472                } /* if */ \
    … …  
    528486IntegralFMTImpl( signed long long int, 'd', "%    *ll ", "%    *.*ll " )
    529487IntegralFMTImpl( unsigned long long int, 'u', "%    *ll ", "%    *.*ll " )
    530 
    531 
    532 #if defined( __SIZEOF_INT128__ )
    533 // Default prefix for non-decimal prints is 0b, 0, 0x.
    534 #define IntegralFMTImpl128( T, SIGNED, CODE, IFMTNP, IFMTP ) \
    535 forall( dtype ostype | ostream( ostype ) ) \
    536 static void base10_128( ostype & os, _Ostream_Manip(T) fmt ) { \
    537         if ( fmt.val > UINT64_MAX ) { \
    538                 fmt.val /= P10_UINT64; \
    539                 base10_128( os, fmt ); /* recursive */ \
    540                 _Ostream_Manip(unsigned long long int) fmt2 @= { (uint64_t)(fmt.val % P10_UINT64), 0, 19, 'u', { .all : 0 } }; \
    541                 fmt2.flags.nobsdp = true; \
    542                 printf( "fmt2 %c %lld %d\n", fmt2.base, fmt2.val, fmt2.all );   \
    543                 sepOff( os ); \
    544                 (ostype &)(os | fmt2); \
    545         } else { \
    546                 printf( "fmt %c %lld %d\n", fmt.base, fmt.val, fmt.all ); \
    547                 (ostype &)(os | fmt); \
    548         } /* if */ \
    549 } /* base10_128 */                                                 \
    550 forall( dtype ostype | ostream( ostype ) ) { \
    551         ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \
    552                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \
    553 \
    554                 if ( f.base == 'b' | f.base == 'o' | f.base == 'x' | f.base == 'X' ) { \
    555                         unsigned long long int msig = (unsigned long long int)(f.val >> 64); \
    556                         unsigned long long int lsig = (unsigned long long int)(f.val); \
    557                         _Ostream_Manip(SIGNED long long int) fmt @= { msig, f.wd, f.pc, f.base, { .all : f.all } }; \
    558                         _Ostream_Manip(unsigned long long int) fmt2 @= { lsig, 0, 0, f.base, { .all : 0 } }; \
    559                         if ( msig == 0 ) { \
    560                                 fmt.val = lsig; \
    561                                 (ostype &)(os | fmt); \
    562                         } else { \
    563                                 fmt2.flags.pad0 = fmt2.flags.nobsdp = true;     \
    564                                 if ( f.base == 'b' ) { \
    565                                         if ( f.wd > 64 ) fmt.wd = f.wd - 64; \
    566                                         fmt2.wd = 64; \
    567                                         (ostype &)(os | fmt | "" | fmt2); \
    568                                 } else if ( f.base == 'o' ) { \
    569                                         fmt.val = (unsigned long long int)fmt.val >> 2; \
    570                                         if ( f.wd > 21 ) fmt.wd = f.wd - 21; \
    571                                         fmt2.wd = 1; \
    572                                         fmt2.val = ((msig & 0x3) << 1) + 1; \
    573                                         (ostype &)(os | fmt | "" | fmt2); \
    574                                         sepOff( os ); \
    575                                         fmt2.wd = 21; \
    576                                         fmt2.val = lsig & 0x7fffffffffffffff; \
    577                                         (ostype &)(os | fmt2); \
    578                                 } else { \
    579                                         if ( f.flags.left ) { \
    580                                                 if ( f.wd > 16 ) fmt2.wd = f.wd - 16;   \
    581                                                 fmt.wd = 16;                                                    \
    582                                         } else { \
    583                                                 if ( f.wd > 16 ) fmt.wd = f.wd - 16;    \
    584                                                 fmt2.wd = 16;                                                   \
    585                                         } /* if */ \
    586                                         (ostype &)(os | fmt | "" | fmt2); \
    587                                 } /* if */ \
    588                         } /* if */ \
    589                 } else { \
    590                         base10_128( os, f ); \
    591                 } /* if */ \
    592                 return os; \
    593         } /* ?|? */ \
    594         void ?|?( ostype & os, _Ostream_Manip(T) f ) { (ostype &)(os | f); ends( os ); } \
    595 } // distribution
    596 
    597 IntegralFMTImpl128( int128, signed, 'd', "%    *ll ", "%    *.*ll " )
    598 IntegralFMTImpl128( unsigned int128, unsigned, 'u', "%    *ll ", "%    *.*ll " )
    599 #endif // __SIZEOF_INT128__
    600488
    601489//*********************************** floating point ***********************************
    … …  
    625513forall( dtype ostype | ostream( ostype ) ) { \
    626514        ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \
    627                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \
     515                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); \
    628516                char fmtstr[sizeof(DFMTP)];                                             /* sizeof includes '\0' */ \
    629517                if ( ! f.flags.pc ) memcpy( &fmtstr, DFMTNP, sizeof(DFMTNP) ); \
    … …  
    648536                return os; \
    649537        } /* ?|? */ \
    650 \
    651538        void ?|?( ostype & os, _Ostream_Manip(T) f ) { (ostype &)(os | f); ends( os ); } \
    652539} // distribution
    … …  
    668555                } // if
    669556
    670                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     557                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    671558
    672559                #define CFMTNP "% * "
    … …  
    684571                return os;
    685572        } // ?|?
    686 
    687573        void ?|?( ostype & os, _Ostream_Manip(char) f ) { (ostype &)(os | f); ends( os ); }
    688574} // distribution
    … …  
    706592                } // if
    707593
    708                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     594                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    709595
    710596                #define SFMTNP "% * "
    … …  
    730616                return os;
    731617        } // ?|?
    732 
    733618        void ?|?( ostype & os, _Ostream_Manip(const char *) f ) { (ostype &)(os | f); ends( os ); }
    734619} // distribution
    … …  
    850735        } // ?|?
    851736
    852         // istype & ?|?( istype & is, const char fmt[] ) {
     737        // istype & ?|?( istype & is, const char * fmt ) {
    853738        //      fmt( is, fmt, "" );
    854739        //      return is;

  • libcfa/src/iostream.hfa

    rb7d6a36 rdca5802  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 20 15:30:56 2020
    13 // Update Count     : 337
     12// Last Modified On : Fri Jul 12 12:08:38 2019
     13// Update Count     : 334
    1414//
    1515
    … …  
    2424trait ostream( dtype ostype ) {
    2525        // private
    26         bool $sepPrt( ostype & );                                                       // get separator state (on/off)
    27         void $sepReset( ostype & );                                                     // set separator state to default state
    28         void $sepReset( ostype &, bool );                                       // set separator and default state
    29         const char * $sepGetCur( ostype & );                            // get current separator string
    30         void $sepSetCur( ostype &, const char [] );                     // set current separator string
    31         bool $getNL( ostype & );                                                        // check newline
    32         void $setNL( ostype &, bool );                                          // saw newline
    33         bool $getANL( ostype & );                                                       // get auto newline (on/off)
    34         bool $getPrt( ostype & );                                                       // get fmt called in output cascade
    35         void $setPrt( ostype &, bool );                                         // set fmt called in output cascade
     26        bool sepPrt( ostype & );                                                        // get separator state (on/off)
     27        void sepReset( ostype & );                                                      // set separator state to default state
     28        void sepReset( ostype &, bool );                                        // set separator and default state
     29        const char * sepGetCur( ostype & );                                     // get current separator string
     30        void sepSetCur( ostype &, const char * );                       // set current separator string
     31        bool getNL( ostype & );                                                         // check newline
     32        void setNL( ostype &, bool );                                           // saw newline
     33        bool getANL( ostype & );                                                        // get auto newline (on/off)
     34        bool getPrt( ostype & );                                                        // get fmt called in output cascade
     35        void setPrt( ostype &, bool );                                          // set fmt called in output cascade
    3636        // public
    3737        void sepOn( ostype & );                                                         // turn separator state on
    … …  
    4343
    4444        const char * sepGet( ostype & );                                        // get separator string
    45         void sepSet( ostype &, const char [] );                         // set separator to string (15 character maximum)
     45        void sepSet( ostype &, const char * );                          // set separator to string (15 character maximum)
    4646        const char * sepGetTuple( ostype & );                           // get tuple separator string
    47         void sepSetTuple( ostype &, const char [] );            // set tuple separator to string (15 character maximum)
     47        void sepSetTuple( ostype &, const char * );                     // set tuple separator to string (15 character maximum)
    4848
    4949        void ends( ostype & os );                                                       // end of output statement
    5050        int fail( ostype & );
    5151        int flush( ostype & );
    52         void open( ostype & os, const char name[], const char mode[] );
     52        void open( ostype & os, const char * name, const char * mode );
    5353        void close( ostype & os );
    54         ostype & write( ostype &, const char [], size_t );
     54        ostype & write( ostype &, const char *, size_t );
    5555        int fmt( ostype &, const char format[], ... ) __attribute__(( format(printf, 2, 3) ));
    5656}; // ostream
    … …  
    9898        ostype & ?|?( ostype &, unsigned long long int );
    9999        void ?|?( ostype &, unsigned long long int );
    100 #if defined( __SIZEOF_INT128__ )
    101         ostype & ?|?( ostype &, int128 );
    102         void ?|?( ostype &, int128 );
    103         ostype & ?|?( ostype &, unsigned int128 );
    104         void ?|?( ostype &, unsigned int128 );
    105 #endif // __SIZEOF_INT128__
    106100
    107101        ostype & ?|?( ostype &, float );
    … …  
    119113        void ?|?( ostype &, long double _Complex );
    120114
    121         ostype & ?|?( ostype &, const char [] );
    122         void ?|?( ostype &, const char [] );
     115        ostype & ?|?( ostype &, const char * );
     116        void ?|?( ostype &, const char * );
    123117        // ostype & ?|?( ostype &, const char16_t * );
    124118#if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
    … …  
    212206IntegralFMTDecl( signed long long int, 'd' )
    213207IntegralFMTDecl( unsigned long long int, 'u' )
    214 #if defined( __SIZEOF_INT128__ )
    215 IntegralFMTDecl( int128, 'd' )
    216 IntegralFMTDecl( unsigned int128, 'u' )
    217 #endif
    218208
    219209//*********************************** floating point ***********************************
    … …  
    266256
    267257static inline {
    268         _Ostream_Manip(const char *) bin( const char s[] ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'b', { .all : 0 } }; }
    269         _Ostream_Manip(const char *) oct( const char s[] ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'o', { .all : 0 } }; }
    270         _Ostream_Manip(const char *) hex( const char s[] ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'x', { .all : 0 } }; }
    271         _Ostream_Manip(const char *) wd( unsigned int w, const char s[] ) { return (_Ostream_Manip(const char *))@{ s, w, 0, 's', { .all : 0 } }; }
    272         _Ostream_Manip(const char *) wd( unsigned int w, unsigned char pc, const char s[] ) { return (_Ostream_Manip(const char *))@{ s, w, pc, 's', { .flags.pc : true } }; }
     258        _Ostream_Manip(const char *) bin( const char * s ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'b', { .all : 0 } }; }
     259        _Ostream_Manip(const char *) oct( const char * s ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'o', { .all : 0 } }; }
     260        _Ostream_Manip(const char *) hex( const char * s ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'x', { .all : 0 } }; }
     261        _Ostream_Manip(const char *) wd( unsigned int w, const char * s ) { return (_Ostream_Manip(const char *))@{ s, w, 0, 's', { .all : 0 } }; }
     262        _Ostream_Manip(const char *) wd( unsigned int w, unsigned char pc, const char * s ) { return (_Ostream_Manip(const char *))@{ s, w, pc, 's', { .flags.pc : true } }; }
    273263        _Ostream_Manip(const char *) & wd( unsigned int w, _Ostream_Manip(const char *) & fmt ) { fmt.wd = w; return fmt; }
    274264        _Ostream_Manip(const char *) & wd( unsigned int w, unsigned char pc, _Ostream_Manip(const char *) & fmt ) { fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; }
    … …  
    291281        int fail( istype & );
    292282        int eof( istype & );
    293         void open( istype & is, const char name[] );
     283        void open( istype & is, const char * name );
    294284        void close( istype & is );
    295285        istype & read( istype &, char *, size_t );
    … …  
    326316        istype & ?|?( istype &, long double _Complex & );
    327317
    328 //      istype & ?|?( istype &, const char [] );
     318//      istype & ?|?( istype &, const char * );
    329319        istype & ?|?( istype &, char * );
    330320
    … …  
    353343static inline {
    354344        _Istream_Cstr skip( unsigned int n ) { return (_Istream_Cstr){ 0p, 0p, n, { .all : 0 } }; }
    355         _Istream_Cstr skip( const char scanset[] ) { return (_Istream_Cstr){ 0p, scanset, -1, { .all : 0 } }; }
    356         _Istream_Cstr incl( const char scanset[], char * s ) { return (_Istream_Cstr){ s, scanset, -1, { .flags.inex : false } }; }
    357         _Istream_Cstr & incl( const char scanset[], _Istream_Cstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = false; return fmt; }
    358         _Istream_Cstr excl( const char scanset[], char * s ) { return (_Istream_Cstr){ s, scanset, -1, { .flags.inex : true } }; }
    359         _Istream_Cstr & excl( const char scanset[], _Istream_Cstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = true; return fmt; }
    360         _Istream_Cstr ignore( const char s[] ) { return (_Istream_Cstr)@{ s, 0p, -1, { .flags.ignore : true } }; }
     345        _Istream_Cstr skip( const char * scanset ) { return (_Istream_Cstr){ 0p, scanset, -1, { .all : 0 } }; }
     346        _Istream_Cstr incl( const char * scanset, char * s ) { return (_Istream_Cstr){ s, scanset, -1, { .flags.inex : false } }; }
     347        _Istream_Cstr & incl( const char * scanset, _Istream_Cstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = false; return fmt; }
     348        _Istream_Cstr excl( const char * scanset, char * s ) { return (_Istream_Cstr){ s, scanset, -1, { .flags.inex : true } }; }
     349        _Istream_Cstr & excl( const char * scanset, _Istream_Cstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = true; return fmt; }
     350        _Istream_Cstr ignore( const char * s ) { return (_Istream_Cstr)@{ s, 0p, -1, { .flags.ignore : true } }; }
    361351        _Istream_Cstr & ignore( _Istream_Cstr & fmt ) { fmt.flags.ignore = true; return fmt; }
    362         _Istream_Cstr wdi( unsigned int w, char s[] ) { return (_Istream_Cstr)@{ s, 0p, w, { .all : 0 } }; }
     352        _Istream_Cstr wdi( unsigned int w, char * s ) { return (_Istream_Cstr)@{ s, 0p, w, { .all : 0 } }; }
    363353        _Istream_Cstr & wdi( unsigned int w, _Istream_Cstr & fmt ) { fmt.wd = w; return fmt; }
    364354} // distribution

  • libcfa/src/math.hfa

    rb7d6a36 rdca5802  
    1010// Created On       : Mon Apr 18 23:37:04 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb  4 10:27:11 2020
    13 // Update Count     : 117
     12// Last Modified On : Fri Jul 13 11:02:15 2018
     13// Update Count     : 116
    1414//
    1515
    … …  
    5151static inline long double fdim( long double x, long double y ) { return fdiml( x, y ); }
    5252
    53 static inline float nan( const char tag[] ) { return nanf( tag ); }
    54 // extern "C" { double nan( const char [] ); }
    55 static inline long double nan( const char tag[] ) { return nanl( tag ); }
     53static inline float nan( const char * tag ) { return nanf( tag ); }
     54// extern "C" { double nan( const char * ); }
     55static inline long double nan( const char * tag ) { return nanl( tag ); }
    5656
    5757//---------------------- Exponential ----------------------

  • libcfa/src/rational.cfa

    rb7d6a36 rdca5802  
    1010// Created On       : Wed Apr  6 17:54:28 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Feb  8 17:56:36 2020
    13 // Update Count     : 187
     12// Last Modified On : Fri Jul 12 18:12:08 2019
     13// Update Count     : 184
    1414//
    1515
    … …  
    5656        } // rational
    5757
    58         void ?{}( Rational(RationalImpl) & r, zero_t ) {
    59                 r{ (RationalImpl){0}, (RationalImpl){1} };
    60         } // rational
    61 
    62         void ?{}( Rational(RationalImpl) & r, one_t ) {
    63                 r{ (RationalImpl){1}, (RationalImpl){1} };
    64         } // rational
    6558
    6659        // getter for numerator/denominator

  • libcfa/src/startup.cfa

    rb7d6a36 rdca5802  
    1010// Created On       : Tue Jul 24 16:21:57 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb  4 13:03:18 2020
    13 // Update Count     : 30
     12// Last Modified On : Sat Nov 30 07:07:56 2019
     13// Update Count     : 13
    1414//
    1515
     16#include "startup.hfa"
    1617#include <time.h>                                                                               // tzset
    17 #include "startup.hfa"
    1818
    1919extern "C" {
    20     void __cfaabi_appready_startup( void ) __attribute__(( constructor( STARTUP_PRIORITY_APPREADY ) ));
     20    static void __cfaabi_appready_startup( void ) __attribute__(( constructor( STARTUP_PRIORITY_APPREADY ) ));
    2121    void __cfaabi_appready_startup( void ) {
    2222                tzset();                                                                                // initialize time global variables
    … …  
    2727    } // __cfaabi_appready_startup
    2828
    29     void __cfaabi_appready_shutdown( void ) __attribute__(( destructor( STARTUP_PRIORITY_APPREADY ) ));
     29    static void __cfaabi_appready_shutdown( void ) __attribute__(( destructor( STARTUP_PRIORITY_APPREADY ) ));
    3030    void __cfaabi_appready_shutdown( void ) {
    3131                #ifdef __CFA_DEBUG__
    … …  
    4141struct __spinlock_t;
    4242extern "C" {
    43         void __cfaabi_dbg_record(struct __spinlock_t & this, const char prev_name[]) __attribute__(( weak )) {}
     43        void __cfaabi_dbg_record(struct __spinlock_t & this, const char * prev_name) __attribute__(( weak )) {}
    4444}
    4545

  • libcfa/src/stdhdr/assert.h

    rb7d6a36 rdca5802  
    1010// Created On       : Mon Jul  4 23:25:26 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb  4 12:58:49 2020
    13 // Update Count     : 15
     12// Last Modified On : Mon Jul 31 23:09:32 2017
     13// Update Count     : 13
    1414//
    1515
    … …  
    2727        #define assertf( expr, fmt, ... ) ((expr) ? ((void)0) : __assert_fail_f(__VSTRINGIFY__(expr), __FILE__, __LINE__, __PRETTY_FUNCTION__, fmt, ## __VA_ARGS__ ))
    2828
    29         void __assert_fail_f( const char assertion[], const char file[], unsigned int line, const char function[], const char fmt[], ... ) __attribute__((noreturn, format( printf, 5, 6) ));
     29        void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... ) __attribute__((noreturn, format( printf, 5, 6) ));
    3030#endif
    3131

  • libcfa/src/stdhdr/bfdlink.h

    rb7d6a36 rdca5802  
    1010// Created On       : Tue Jul 18 07:26:04 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Feb  7 19:05:08 2020
    13 // Update Count     : 6
     12// Last Modified On : Sun Jul 22 13:49:30 2018
     13// Update Count     : 4
    1414//
    1515
    1616// include file uses the CFA keyword "with".
    1717#if ! defined( with )                                                                   // nesting ?
    18 #define with ``with                                                                             // make keyword an identifier
     18#define with `with`                                                                             // make keyword an identifier
    1919#define __CFA_BFDLINK_H__
    2020#endif

  • libcfa/src/stdhdr/hwloc.h

    rb7d6a36 rdca5802  
    1010// Created On       : Tue Jul 18 07:45:00 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Feb  7 19:05:18 2020
    13 // Update Count     : 6
     12// Last Modified On : Sun Jul 22 13:49:58 2018
     13// Update Count     : 4
    1414//
    1515
    1616// include file uses the CFA keyword "thread".
    1717#if ! defined( thread )                                                                 // nesting ?
    18 #define thread ``thread                                                                 // make keyword an identifier
     18#define thread `thread`                                                                 // make keyword an identifier
    1919#define __CFA_HWLOC_H__
    2020#endif

  • libcfa/src/stdhdr/krb5.h

    rb7d6a36 rdca5802  
    1010// Created On       : Tue Jul 18 07:55:44 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Feb  7 19:05:35 2020
    13 // Update Count     : 6
     12// Last Modified On : Sun Jul 22 13:50:24 2018
     13// Update Count     : 4
    1414//
    1515
    1616// include file uses the CFA keyword "enable".
    1717#if ! defined( enable )                                                                 // nesting ?
    18 #define enable ``enable                                                                 // make keyword an identifier
     18#define enable `enable`                                                                 // make keyword an identifier
    1919#define __CFA_KRB5_H__
    2020#endif

  • libcfa/src/stdhdr/math.h

    rb7d6a36 rdca5802  
    1010// Created On       : Mon Jul  4 23:25:26 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Feb  7 19:05:27 2020
    13 // Update Count     : 15
     12// Last Modified On : Thu Feb 22 18:16:07 2018
     13// Update Count     : 13
    1414//
    1515
    1616extern "C" {
    1717#if ! defined( exception )                                                              // nesting ?
    18 #define exception ``exception                                                   // make keyword an identifier
     18#define exception `exception`                                                   // make keyword an identifier
    1919#define __CFA_MATH_H__
    2020#endif

  • libcfa/src/stdhdr/sys/ucontext.h

    rb7d6a36 rdca5802  
    1010// Created On       : Thu Feb  8 23:48:16 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Feb  7 19:05:41 2020
    13 // Update Count     : 6
     12// Last Modified On : Thu Feb  8 23:50:44 2018
     13// Update Count     : 4
    1414//
    1515
    1616#if ! defined( ftype )                                                                  // nesting ?
    17 #define ftype ``ftype                                                                   // make keyword an identifier
     17#define ftype `ftype`                                                                   // make keyword an identifier
    1818#define __CFA_UCONTEXT_H__
    1919#endif

  • libcfa/src/stdlib.cfa

    rb7d6a36 rdca5802  
    1010// Created On       : Thu Jan 28 17:10:29 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb  4 08:27:08 2020
    13 // Update Count     : 486
     12// Last Modified On : Wed Nov 20 17:22:47 2019
     13// Update Count     : 485
    1414//
    1515
    … …  
    107107//---------------------------------------
    108108
    109 float _Complex strto( const char sptr[], char ** eptr ) {
     109float _Complex strto( const char * sptr, char ** eptr ) {
    110110        float re, im;
    111111        char * eeptr;
    … …  
    118118} // strto
    119119
    120 double _Complex strto( const char sptr[], char ** eptr ) {
     120double _Complex strto( const char * sptr, char ** eptr ) {
    121121        double re, im;
    122122        char * eeptr;
    … …  
    129129} // strto
    130130
    131 long double _Complex strto( const char sptr[], char ** eptr ) {
     131long double _Complex strto( const char * sptr, char ** eptr ) {
    132132        long double re, im;
    133133        char * eeptr;

  • libcfa/src/stdlib.hfa

    rb7d6a36 rdca5802  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb  4 08:27:01 2020
    13 // Update Count     : 401
     12// Last Modified On : Fri Nov 29 23:08:02 2019
     13// Update Count     : 400
    1414//
    1515
    … …  
    193193
    194194static inline {
    195         int strto( const char sptr[], char ** eptr, int base ) { return (int)strtol( sptr, eptr, base ); }
    196         unsigned int strto( const char sptr[], char ** eptr, int base ) { return (unsigned int)strtoul( sptr, eptr, base ); }
    197         long int strto( const char sptr[], char ** eptr, int base ) { return strtol( sptr, eptr, base ); }
    198         unsigned long int strto( const char sptr[], char ** eptr, int base ) { return strtoul( sptr, eptr, base ); }
    199         long long int strto( const char sptr[], char ** eptr, int base ) { return strtoll( sptr, eptr, base ); }
    200         unsigned long long int strto( const char sptr[], char ** eptr, int base ) { return strtoull( sptr, eptr, base ); }
    201 
    202         float strto( const char sptr[], char ** eptr ) { return strtof( sptr, eptr ); }
    203         double strto( const char sptr[], char ** eptr ) { return strtod( sptr, eptr ); }
    204         long double strto( const char sptr[], char ** eptr ) { return strtold( sptr, eptr ); }
    205 } // distribution
    206 
    207 float _Complex strto( const char sptr[], char ** eptr );
    208 double _Complex strto( const char sptr[], char ** eptr );
    209 long double _Complex strto( const char sptr[], char ** eptr );
     195        int strto( const char * sptr, char ** eptr, int base ) { return (int)strtol( sptr, eptr, base ); }
     196        unsigned int strto( const char * sptr, char ** eptr, int base ) { return (unsigned int)strtoul( sptr, eptr, base ); }
     197        long int strto( const char * sptr, char ** eptr, int base ) { return strtol( sptr, eptr, base ); }
     198        unsigned long int strto( const char * sptr, char ** eptr, int base ) { return strtoul( sptr, eptr, base ); }
     199        long long int strto( const char * sptr, char ** eptr, int base ) { return strtoll( sptr, eptr, base ); }
     200        unsigned long long int strto( const char * sptr, char ** eptr, int base ) { return strtoull( sptr, eptr, base ); }
     201
     202        float strto( const char * sptr, char ** eptr ) { return strtof( sptr, eptr ); }
     203        double strto( const char * sptr, char ** eptr ) { return strtod( sptr, eptr ); }
     204        long double strto( const char * sptr, char ** eptr ) { return strtold( sptr, eptr ); }
     205} // distribution
     206
     207float _Complex strto( const char * sptr, char ** eptr );
     208double _Complex strto( const char * sptr, char ** eptr );
     209long double _Complex strto( const char * sptr, char ** eptr );
    210210
    211211static inline {
    212         int ato( const char sptr[] ) { return (int)strtol( sptr, 0p, 10 ); }
    213         unsigned int ato( const char sptr[] ) { return (unsigned int)strtoul( sptr, 0p, 10 ); }
    214         long int ato( const char sptr[] ) { return strtol( sptr, 0p, 10 ); }
    215         unsigned long int ato( const char sptr[] ) { return strtoul( sptr, 0p, 10 ); }
    216         long long int ato( const char sptr[] ) { return strtoll( sptr, 0p, 10 ); }
    217         unsigned long long int ato( const char sptr[] ) { return strtoull( sptr, 0p, 10 ); }
    218 
    219         float ato( const char sptr[] ) { return strtof( sptr, 0p ); }
    220         double ato( const char sptr[] ) { return strtod( sptr, 0p ); }
    221         long double ato( const char sptr[] ) { return strtold( sptr, 0p ); }
    222 
    223         float _Complex ato( const char sptr[] ) { return strto( sptr, 0p ); }
    224         double _Complex ato( const char sptr[] ) { return strto( sptr, 0p ); }
    225         long double _Complex ato( const char sptr[] ) { return strto( sptr, 0p ); }
     212        int ato( const char * sptr ) { return (int)strtol( sptr, 0p, 10 ); }
     213        unsigned int ato( const char * sptr ) { return (unsigned int)strtoul( sptr, 0p, 10 ); }
     214        long int ato( const char * sptr ) { return strtol( sptr, 0p, 10 ); }
     215        unsigned long int ato( const char * sptr ) { return strtoul( sptr, 0p, 10 ); }
     216        long long int ato( const char * sptr ) { return strtoll( sptr, 0p, 10 ); }
     217        unsigned long long int ato( const char * sptr ) { return strtoull( sptr, 0p, 10 ); }
     218
     219        float ato( const char * sptr ) { return strtof( sptr, 0p ); }
     220        double ato( const char * sptr ) { return strtod( sptr, 0p ); }
     221        long double ato( const char * sptr ) { return strtold( sptr, 0p ); }
     222
     223        float _Complex ato( const char * sptr ) { return strto( sptr, 0p ); }
     224        double _Complex ato( const char * sptr ) { return strto( sptr, 0p ); }
     225        long double _Complex ato( const char * sptr ) { return strto( sptr, 0p ); }
    226226} // distribution
    227227

  • libcfa/src/time.cfa

    rb7d6a36 rdca5802  
    1010// Created On       : Tue Mar 27 13:33:14 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb  4 08:24:18 2020
    13 // Update Count     : 70
     12// Last Modified On : Sat Jul 13 08:41:55 2019
     13// Update Count     : 65
    1414//
    1515
    … …  
    3333forall( dtype ostype | ostream( ostype ) ) {
    3434        ostype & ?|?( ostype & os, Duration dur ) with( dur ) {
    35                 (ostype &)(os | tn / TIMEGRAN);                                 // print seconds
    36                 long int ns = (tn < 0 ? -tn : tn) % TIMEGRAN;   // compute nanoseconds
     35                (ostype &)(os | tv / TIMEGRAN);                                 // print seconds
     36                long int ns = (tv < 0 ? -tv : tv) % TIMEGRAN;   // compute nanoseconds
    3737                if ( ns != 0 ) {                                                                // some ?
    3838                        char buf[16];
    … …  
    5252
    5353#ifdef __CFA_DEBUG__
    54 static void tabort( int year, int month, int day, int hour, int min, int sec, int64_t nsec ) {
     54static void tabort( int year, int month, int day, int hour, int min, int sec, int nsec ) {
    5555        abort | "Attempt to create Time( year=" | year | "(>=1970), month=" | month | "(1-12), day=" | day | "(1-31), hour=" | hour | "(0-23), min=" | min | "(0-59), sec=" | sec
    56                   | "(0-60), nsec=" | nsec | "(0-999_999_999), which is not in the range 00:00:00 UTC, January 1, 1970 to 03:14:07 UTC, January 19, 2038, where month and day have 1 origin.";
     56                  | "(0-60), nsec=" | nsec | "(0-999_999_999), which exceeds range 00:00:00 UTC, January 1, 1970 to 03:14:07 UTC, January 19, 2038.";
    5757} // tabort
    5858#endif // __CFA_DEBUG__
    5959
    60 void ?{}( Time & time, int year, int month, int day, int hour, int min, int sec, int64_t nsec ) with( time ) {
     60void ?{}( Time & time, int year, int month, int day, int hour, int min, int sec, int nsec ) with( time ) {
    6161        tm tm;
    6262
    63         // Values can be in any range (+/-) but result must be in the epoch.
     63        tm.tm_isdst = -1;                                                                       // let mktime determine if alternate timezone is in effect
    6464        tm.tm_year = year - 1900;                                                       // mktime uses 1900 as its starting point
    65         // Make month in range 1-12 to match with day.
     65#ifdef __CFA_DEBUG__
     66        if ( month < 1 || 12 < month ) {
     67                tabort( year, month, day, hour, min, sec, nsec );
     68        } // if
     69#endif // __CFA_DEBUG__
    6670        tm.tm_mon = month - 1;                                                          // mktime uses range 0-11
     71#ifdef __CFA_DEBUG__
     72        if ( day < 1 || 31 < day ) {
     73                tabort( year, month, day, hour, min, sec, nsec );
     74        } // if
     75#endif // __CFA_DEBUG__
    6776        tm.tm_mday = day;                                                                       // mktime uses range 1-31
    6877        tm.tm_hour = hour;
    6978        tm.tm_min = min;
    7079        tm.tm_sec = sec;
    71         tm.tm_isdst = -1;                                                                       // let mktime determine if alternate timezone is in effect
    7280        time_t epochsec = mktime( &tm );
    7381#ifdef __CFA_DEBUG__
    74         if ( epochsec <= (time_t)-1 ) {                                         // MUST BE LESS THAN OR EQUAL!
     82        if ( epochsec == (time_t)-1 ) {
    7583                tabort( year, month, day, hour, min, sec, nsec );
    7684        } // if
    7785#endif // __CFA_DEBUG__
    78         tn = (int64_t)(epochsec) * TIMEGRAN + nsec;                     // convert to nanoseconds
     86        tv = (int64_t)(epochsec) * TIMEGRAN + nsec;                     // convert to nanoseconds
    7987#ifdef __CFA_DEBUG__
    80         if ( tn > 2147483647LL * TIMEGRAN ) {                           // between 00:00:00 UTC, January 1, 1970 and 03:14:07 UTC, January 19, 2038.
     88        if ( tv > 2147483647LL * TIMEGRAN ) {                           // between 00:00:00 UTC, January 1, 1970 and 03:14:07 UTC, January 19, 2038.
    8189                tabort( year, month, day, hour, min, sec, nsec );
    8290        } // if
    … …  
    8593
    8694char * yy_mm_dd( Time time, char * buf ) with( time ) {
    87         time_t s = tn / TIMEGRAN;
     95        time_t s = tv / TIMEGRAN;
    8896        tm tm;
    8997        gmtime_r( &s, &tm );                                                            // tm_mon <= 11, tm_mday <= 31
    … …  
    100108
    101109char * mm_dd_yy( Time time, char * buf ) with( time ) {
    102         time_t s = tn / TIMEGRAN;
     110        time_t s = tv / TIMEGRAN;
    103111        tm tm;
    104112        gmtime_r( &s, &tm );                                                            // tm_mon <= 11, tm_mday <= 31
    … …  
    115123
    116124char * dd_mm_yy( Time time, char * buf ) with( time ) {
    117         time_t s = tn / TIMEGRAN;
     125        time_t s = tv / TIMEGRAN;
    118126        tm tm;
    119127        gmtime_r( &s, &tm );                                                            // tm_mon <= 11, tm_mday <= 31
    … …  
    129137} // dd_mm_yy
    130138
    131 size_t strftime( char buf[], size_t size, const char fmt[], Time time ) with( time ) {
    132         time_t s = tn / TIMEGRAN;
     139size_t strftime( char * buf, size_t size, const char * fmt, Time time ) with( time ) {
     140        time_t s = tv / TIMEGRAN;
    133141        tm tm;
    134142        gmtime_r( &s, &tm );
    … …  
    139147        ostype & ?|?( ostype & os, Time time ) with( time ) {
    140148                char buf[32];                                                                   // at least 26
    141                 time_t s = tn / TIMEGRAN;
     149                time_t s = tv / TIMEGRAN;
    142150                ctime_r( &s, (char *)&buf );                                    // 26 characters: "Wed Jun 30 21:49:08 1993\n"
    143151                buf[24] = '\0';                                                                 // remove trailing '\n'
    144                 long int ns = (tn < 0 ? -tn : tn) % TIMEGRAN;   // compute nanoseconds
     152                long int ns = (tv < 0 ? -tv : tv) % TIMEGRAN;   // compute nanoseconds
    145153                if ( ns == 0 ) {                                                                // none ?
    146154                        (ostype &)(os | buf);                                           // print date/time/year

  • libcfa/src/time.hfa

    rb7d6a36 rdca5802  
    1010// Created On       : Wed Mar 14 23:18:57 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb  4 08:24:32 2020
    13 // Update Count     : 654
     12// Last Modified On : Sat Sep 22 12:25:34 2018
     13// Update Count     : 643
    1414//
    1515
    … …  
    3232        Duration ?=?( Duration & dur, __attribute__((unused)) zero_t ) { return dur{ 0 }; }
    3333
    34         Duration +?( Duration rhs ) with( rhs ) { return (Duration)@{ +tn }; }
    35         Duration ?+?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tn + rhs.tn }; }
     34        Duration +?( Duration rhs ) with( rhs ) {       return (Duration)@{ +tv }; }
     35        Duration ?+?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tv + rhs.tv }; }
    3636        Duration ?+=?( Duration & lhs, Duration rhs ) { lhs = lhs + rhs; return lhs; }
    3737
    38         Duration -?( Duration rhs ) with( rhs ) { return (Duration)@{ -tn }; }
    39         Duration ?-?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tn - rhs.tn }; }
     38        Duration -?( Duration rhs ) with( rhs ) { return (Duration)@{ -tv }; }
     39        Duration ?-?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tv - rhs.tv }; }
    4040        Duration ?-=?( Duration & lhs, Duration rhs ) { lhs = lhs - rhs; return lhs; }
    4141
    42         Duration ?*?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tn * rhs }; }
    43         Duration ?*?( int64_t lhs, Duration rhs ) { return (Duration)@{ lhs * rhs.tn }; }
     42        Duration ?*?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tv * rhs }; }
     43        Duration ?*?( int64_t lhs, Duration rhs ) { return (Duration)@{ lhs * rhs.tv }; }
    4444        Duration ?*=?( Duration & lhs, int64_t rhs ) { lhs = lhs * rhs; return lhs; }
    4545
    46         int64_t ?/?( Duration lhs, Duration rhs ) { return lhs.tn / rhs.tn; }
    47         Duration ?/?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tn / rhs }; }
     46        int64_t ?/?( Duration lhs, Duration rhs ) { return lhs.tv / rhs.tv; }
     47        Duration ?/?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tv / rhs }; }
    4848        Duration ?/=?( Duration & lhs, int64_t rhs ) { lhs = lhs / rhs; return lhs; }
    49         double div( Duration lhs, Duration rhs ) { return (double)lhs.tn / (double)rhs.tn; }
    50 
    51         Duration ?%?( Duration lhs, Duration rhs ) { return (Duration)@{ lhs.tn % rhs.tn }; }
     49        double div( Duration lhs, Duration rhs ) { return (double)lhs.tv / (double)rhs.tv; }
     50
     51        Duration ?%?( Duration lhs, Duration rhs ) { return (Duration)@{ lhs.tv % rhs.tv }; }
    5252        Duration ?%=?( Duration & lhs, Duration rhs ) { lhs = lhs % rhs; return lhs; }
    5353
    54         bool ?==?( Duration lhs, Duration rhs ) { return lhs.tn == rhs.tn; }
    55         bool ?!=?( Duration lhs, Duration rhs ) { return lhs.tn != rhs.tn; }
    56         bool ?<? ( Duration lhs, Duration rhs ) { return lhs.tn <  rhs.tn; }
    57         bool ?<=?( Duration lhs, Duration rhs ) { return lhs.tn <= rhs.tn; }
    58         bool ?>? ( Duration lhs, Duration rhs ) { return lhs.tn >  rhs.tn; }
    59         bool ?>=?( Duration lhs, Duration rhs ) { return lhs.tn >= rhs.tn; }
    60 
    61         bool ?==?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn == 0; }
    62         bool ?!=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn != 0; }
    63         bool ?<? ( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn <  0; }
    64         bool ?<=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn <= 0; }
    65         bool ?>? ( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn >  0; }
    66         bool ?>=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn >= 0; }
    67 
    68         Duration abs( Duration rhs ) { return rhs.tn >= 0 ? rhs : -rhs; }
     54        bool ?==?( Duration lhs, Duration rhs ) { return lhs.tv == rhs.tv; }
     55        bool ?!=?( Duration lhs, Duration rhs ) { return lhs.tv != rhs.tv; }
     56        bool ?<? ( Duration lhs, Duration rhs ) { return lhs.tv <  rhs.tv; }
     57        bool ?<=?( Duration lhs, Duration rhs ) { return lhs.tv <= rhs.tv; }
     58        bool ?>? ( Duration lhs, Duration rhs ) { return lhs.tv >  rhs.tv; }
     59        bool ?>=?( Duration lhs, Duration rhs ) { return lhs.tv >= rhs.tv; }
     60
     61        bool ?==?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tv == 0; }
     62        bool ?!=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tv != 0; }
     63        bool ?<? ( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tv <  0; }
     64        bool ?<=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tv <= 0; }
     65        bool ?>? ( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tv >  0; }
     66        bool ?>=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tv >= 0; }
     67
     68        Duration abs( Duration rhs ) { return rhs.tv >= 0 ? rhs : -rhs; }
    6969
    7070        Duration ?`ns( int64_t nsec ) { return (Duration)@{ nsec }; }
    … …  
    8282        Duration ?`w( double weeks ) { return (Duration)@{ weeks * (7LL * 24LL * 60LL * 60LL * TIMEGRAN) }; }
    8383
    84         int64_t ?`ns( Duration dur ) { return dur.tn; }
    85         int64_t ?`us( Duration dur ) { return dur.tn / (TIMEGRAN / 1_000_000LL); }
    86         int64_t ?`ms( Duration dur ) { return dur.tn / (TIMEGRAN / 1_000LL); }
    87         int64_t ?`s( Duration dur ) { return dur.tn / TIMEGRAN; }
    88         int64_t ?`m( Duration dur ) { return dur.tn / (60LL * TIMEGRAN); }
    89         int64_t ?`h( Duration dur ) { return dur.tn / (60LL * 60LL * TIMEGRAN); }
    90         int64_t ?`d( Duration dur ) { return dur.tn / (24LL * 60LL * 60LL * TIMEGRAN); }
    91         int64_t ?`w( Duration dur ) { return dur.tn / (7LL * 24LL * 60LL * 60LL * TIMEGRAN); }
    92 
    93         Duration max( Duration lhs, Duration rhs ) { return  (lhs.tn < rhs.tn) ? rhs : lhs;}
    94         Duration min( Duration lhs, Duration rhs ) { return !(rhs.tn < lhs.tn) ? lhs : rhs;}
     84        int64_t ?`ns( Duration dur ) { return dur.tv; }
     85        int64_t ?`us( Duration dur ) { return dur.tv / (TIMEGRAN / 1_000_000LL); }
     86        int64_t ?`ms( Duration dur ) { return dur.tv / (TIMEGRAN / 1_000LL); }
     87        int64_t ?`s( Duration dur ) { return dur.tv / TIMEGRAN; }
     88        int64_t ?`m( Duration dur ) { return dur.tv / (60LL * TIMEGRAN); }
     89        int64_t ?`h( Duration dur ) { return dur.tv / (60LL * 60LL * TIMEGRAN); }
     90        int64_t ?`d( Duration dur ) { return dur.tv / (24LL * 60LL * 60LL * TIMEGRAN); }
     91        int64_t ?`w( Duration dur ) { return dur.tv / (7LL * 24LL * 60LL * 60LL * TIMEGRAN); }
     92
     93        Duration max( Duration lhs, Duration rhs ) { return  (lhs.tv < rhs.tv) ? rhs : lhs;}
     94        Duration min( Duration lhs, Duration rhs ) { return !(rhs.tv < lhs.tv) ? lhs : rhs;}
    9595} // distribution
    9696
    … …  
    143143//######################### Time #########################
    144144
    145 void ?{}( Time & time, int year, int month = 1, int day = 1, int hour = 0, int min = 0, int sec = 0, int64_t nsec = 0 );
     145void ?{}( Time & time, int year, int month = 0, int day = 0, int hour = 0, int min = 0, int sec = 0, int nsec = 0 );
    146146static inline {
    147147        Time ?=?( Time & time, __attribute__((unused)) zero_t ) { return time{ 0 }; }
    148148
    149         void ?{}( Time & time, timeval t ) with( time ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000; }
     149        void ?{}( Time & time, timeval t ) with( time ) { tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000; }
    150150        Time ?=?( Time & time, timeval t ) with( time ) {
    151                 tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * (TIMEGRAN / 1_000_000LL);
     151                tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * (TIMEGRAN / 1_000_000LL);
    152152                return time;
    153153        } // ?=?
    154154
    155         void ?{}( Time & time, timespec t ) with( time ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec; }
     155        void ?{}( Time & time, timespec t ) with( time ) { tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec; }
    156156        Time ?=?( Time & time, timespec t ) with( time ) {
    157                 tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec;
     157                tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec;
    158158                return time;
    159159        } // ?=?
    160160
    161         Time ?+?( Time & lhs, Duration rhs ) { return (Time)@{ lhs.tn + rhs.tn }; }
     161        Time ?+?( Time & lhs, Duration rhs ) { return (Time)@{ lhs.tv + rhs.tv }; }
    162162        Time ?+?( Duration lhs, Time rhs ) { return rhs + lhs; }
    163163        Time ?+=?( Time & lhs, Duration rhs ) { lhs = lhs + rhs; return lhs; }
    164164
    165         Duration ?-?( Time lhs, Time rhs ) { return (Duration)@{ lhs.tn - rhs.tn }; }
    166         Time ?-?( Time lhs, Duration rhs ) { return (Time)@{ lhs.tn - rhs.tn }; }
     165        Duration ?-?( Time lhs, Time rhs ) { return (Duration)@{ lhs.tv - rhs.tv }; }
     166        Time ?-?( Time lhs, Duration rhs ) { return (Time)@{ lhs.tv - rhs.tv }; }
    167167        Time ?-=?( Time & lhs, Duration rhs ) { lhs = lhs - rhs; return lhs; }
    168         bool ?==?( Time lhs, Time rhs ) { return lhs.tn == rhs.tn; }
    169         bool ?!=?( Time lhs, Time rhs ) { return lhs.tn != rhs.tn; }
    170         bool ?<?( Time lhs, Time rhs ) { return lhs.tn < rhs.tn; }
    171         bool ?<=?( Time lhs, Time rhs ) { return lhs.tn <= rhs.tn; }
    172         bool ?>?( Time lhs, Time rhs ) { return lhs.tn > rhs.tn; }
    173         bool ?>=?( Time lhs, Time rhs ) { return lhs.tn >= rhs.tn; }
    174 
    175         int64_t ?`ns( Time t ) { return t.tn; }
     168        bool ?==?( Time lhs, Time rhs ) { return lhs.tv == rhs.tv; }
     169        bool ?!=?( Time lhs, Time rhs ) { return lhs.tv != rhs.tv; }
     170        bool ?<?( Time lhs, Time rhs ) { return lhs.tv < rhs.tv; }
     171        bool ?<=?( Time lhs, Time rhs ) { return lhs.tv <= rhs.tv; }
     172        bool ?>?( Time lhs, Time rhs ) { return lhs.tv > rhs.tv; }
     173        bool ?>=?( Time lhs, Time rhs ) { return lhs.tv >= rhs.tv; }
    176174} // distribution
    177175
    … …  
    191189} // dmy
    192190
    193 size_t strftime( char buf[], size_t size, const char fmt[], Time time );
     191size_t strftime( char * buf, size_t size, const char * fmt, Time time );
    194192
    195193//------------------------- timeval (cont) -------------------------
    196194
    197195static inline void ?{}( timeval & t, Time time ) with( t, time ) {
    198         tv_sec = tn / TIMEGRAN;                                                         // seconds
    199         tv_usec = tn % TIMEGRAN / (TIMEGRAN / 1_000_000LL);     // microseconds
     196        tv_sec = tv / TIMEGRAN;                                                         // seconds
     197        tv_usec = tv % TIMEGRAN / (TIMEGRAN / 1_000_000LL);     // microseconds
    200198} // ?{}
    201199
    … …  
    203201
    204202static inline void ?{}( timespec & t, Time time ) with( t, time ) {
    205         tv_sec = tn / TIMEGRAN;                                                         // seconds
    206         tv_nsec = tn % TIMEGRAN;                                                        // nanoseconds
     203        tv_sec = tv / TIMEGRAN;                                                         // seconds
     204        tv_nsec = tv % TIMEGRAN;                                                        // nanoseconds
    207205} // ?{}
    208206

  • libcfa/src/time_t.hfa

    rb7d6a36 rdca5802  
    1010// Created On       : Tue Apr 10 14:42:03 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Jan  5 08:22:46 2020
    13 // Update Count     : 7
     12// Last Modified On : Fri Apr 13 07:51:47 2018
     13// Update Count     : 6
    1414//
    1515
    … …  
    2020
    2121struct Duration {                                                                               // private
    22         int64_t tn;                                                                                     // nanoseconds
     22        int64_t tv;                                                                                     // nanoseconds
    2323}; // Duration
    2424
    25 static inline void ?{}( Duration & dur ) with( dur ) { tn = 0; }
    26 static inline void ?{}( Duration & dur, __attribute__((unused)) zero_t ) with( dur ) { tn = 0; }
     25static inline void ?{}( Duration & dur ) with( dur ) { tv = 0; }
     26static inline void ?{}( Duration & dur, __attribute__((unused)) zero_t ) with( dur ) { tv = 0; }
    2727
    2828
    … …  
    3030
    3131struct Time {                                                                                   // private
    32         uint64_t tn;                                                                            // nanoseconds since UNIX epoch
     32        uint64_t tv;                                                                            // nanoseconds since UNIX epoch
    3333}; // Time
    3434
    35 static inline void ?{}( Time & time ) with( time ) { tn = 0; }
    36 static inline void ?{}( Time & time, __attribute__((unused)) zero_t ) with( time ) { tn = 0; }
     35static inline void ?{}( Time & time ) with( time ) { tv = 0; }
     36static inline void ?{}( Time & time, __attribute__((unused)) zero_t ) with( time ) { tv = 0; }
    3737
    3838// Local Variables: //

  • longrun_tests/Makefile.in

    rb7d6a36 rdca5802  
    492492am__v_CFA_0 = @echo "  CFA     " $@;
    493493am__v_CFA_1 =
     494AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
     495am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
     496am__v_JAVAC_0 = @echo "  JAVAC   " $@;
     497am__v_JAVAC_1 =
     498AM_V_GOC = $(am__v_GOC_@AM_V@)
     499am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
     500am__v_GOC_0 = @echo "  GOC     " $@;
     501am__v_GOC_1 =
    494502UPPCC = u++
    495503UPPCOMPILE = $(UPPCC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_UPPFLAGS) $(UPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_CFLAGS) $(CFLAGS)
    … …  
    498506am__v_UPP_0 = @echo "  UPP     " $@;
    499507am__v_UPP_1 =
    500 AM_V_GOC = $(am__v_GOC_@AM_V@)
    501 am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
    502 am__v_GOC_0 = @echo "  GOC     " $@;
    503 am__v_GOC_1 =
    504 AM_V_PY = $(am__v_PY_@AM_V@)
    505 am__v_PY_ = $(am__v_PY_@AM_DEFAULT_V@)
    506 am__v_PY_0 = @echo "  PYTHON  " $@;
    507 am__v_PY_1 =
    508 AM_V_RUST = $(am__v_RUST_@AM_V@)
    509 am__v_RUST_ = $(am__v_RUST_@AM_DEFAULT_V@)
    510 am__v_RUST_0 = @echo "  RUST    " $@;
    511 am__v_RUST_1 =
    512 AM_V_NODEJS = $(am__v_NODEJS_@AM_V@)
    513 am__v_NODEJS_ = $(am__v_NODEJS_@AM_DEFAULT_V@)
    514 am__v_NODEJS_0 = @echo "  NODEJS  " $@;
    515 am__v_NODEJS_1 =
    516 AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
    517 am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
    518 am__v_JAVAC_0 = @echo "  JAVAC   " $@;
    519 am__v_JAVAC_1 =
    520508repeats = 10
    521509max_time = 600

  • src/AST/Convert.cpp

    rb7d6a36 rdca5802  
    1010// Created On       : Thu May 09 15::37::05 2019
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Dec 11 21:39:32 2019
    13 // Update Count     : 33
     12// Last Modified On : Tue Dec 10 22:20:10 2019
     13// Update Count     : 32
    1414//
    1515
    … …  
    12231223                                cv( node ),
    12241224                                node->name,
    1225                                 node->kind == ast::TypeDecl::Ftype,
     1225                                node->kind == ast::TypeVar::Ftype,
    12261226                                get<Attribute>().acceptL( node->attributes )
    12271227                        };
    … …  
    15781578                        { old->storageClasses.val },
    15791579                        GET_ACCEPT_1(base, Type),
    1580                         (ast::TypeDecl::Kind)(unsigned)old->kind,
     1580                        (ast::TypeVar::Kind)(unsigned)old->kind,
    15811581                        old->sized,
    15821582                        GET_ACCEPT_1(init, Type)
    … …  
    25612561                        ty = new ast::TypeInstType{
    25622562                                old->name,
    2563                                 old->isFtype ? ast::TypeDecl::Ftype : ast::TypeDecl::Dtype,
     2563                                old->isFtype ? ast::TypeVar::Ftype : ast::TypeVar::Dtype,
    25642564                                cv( old ),
    25652565                                GET_ACCEPT_V( attributes, Attribute )

  • src/AST/Decl.cpp

    rb7d6a36 rdca5802  
    1010// Created On       : Thu May 9 10:00:00 2019
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec 13 16:23:15 2019
    13 // Update Count     : 20
     12// Last Modified On : Wed Dec 11 16:41:39 2019
     13// Update Count     : 18
    1414//
    1515
    … …  
    2626#include "Node.hpp"            // for readonly
    2727#include "Type.hpp"            // for readonly
     28#include "Parser/ParseNode.h"  // for DeclarationNode
    2829
    2930namespace ast {
    … …  
    5556
    5657const char * TypeDecl::typeString() const {
    57         static const char * kindNames[] = { "sized data type", "sized object type", "sized function type", "sized tuple type" };
    58         static_assert( sizeof(kindNames)/sizeof(kindNames[0]) == TypeDecl::NUMBER_OF_KINDS, "typeString: kindNames is out of sync." );
    59         assertf( kind < TypeDecl::NUMBER_OF_KINDS, "TypeDecl kind is out of bounds." );
     58        static const char * kindNames[] = { "sized object type", "sized function type", "sized tuple type" };
     59        assertf( sizeof(kindNames)/sizeof(kindNames[0]) == DeclarationNode::NoTypeClass-1,
     60                "typeString: kindNames is out of sync." );
     61        assertf( kind < sizeof(kindNames)/sizeof(kindNames[0]), "TypeDecl's kind is out of bounds." );
    6062        return sized ? kindNames[ kind ] : &kindNames[ kind ][ sizeof("sized") ]; // sizeof includes '\0'
    6163}
    6264
    6365const char * TypeDecl::genTypeString() const {
    64         static const char * kindNames[] = { "dtype", "otype", "ftype", "ttype" };
    65         static_assert( sizeof(kindNames)/sizeof(kindNames[0]) == TypeDecl::NUMBER_OF_KINDS, "genTypeString: kindNames is out of sync." );
    66         assertf( kind < TypeDecl::NUMBER_OF_KINDS, "TypeDecl kind is out of bounds." );
     66        static const char * kindNames[] = { "dtype", "ftype", "ttype" };
     67        assertf( sizeof(kindNames)/sizeof(kindNames[0]) == DeclarationNode::NoTypeClass-1, "genTypeString: kindNames is out of sync." );
     68        assertf( kind < sizeof(kindNames)/sizeof(kindNames[0]), "TypeDecl's kind is out of bounds." );
    6769        return kindNames[ kind ];
    6870}

  • src/AST/Decl.hpp

    rb7d6a36 rdca5802  
    1010// Created On       : Thu May 9 10:00:00 2019
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec 13 17:38:33 2019
    13 // Update Count     : 29
     12// Last Modified On : Wed Dec 11 08:20:20 2019
     13// Update Count     : 16
    1414//
    1515
    … …  
    2020#include <unordered_map>
    2121#include <vector>
    22 #include <algorithm>
    2322
    2423#include "FunctionSpec.hpp"
    … …  
    2827#include "ParseNode.hpp"
    2928#include "StorageClasses.hpp"
     29#include "TypeVar.hpp"
    3030#include "Visitor.hpp"
    31 #include "Common/utility.h"
    32 #include "Common/SemanticError.h"                                               // error_str
     31#include "Parser/ParseNode.h"  // for DeclarationNode::Aggregate
    3332
    3433// Must be included in *all* AST classes; should be #undef'd at the end of the file
    … …  
    126125        std::vector< ptr<Expr> > withExprs;
    127126
    128         FunctionDecl( const CodeLocation & loc, const std::string & name, FunctionType * type,
     127        FunctionDecl( const CodeLocation & loc, const std::string &name, FunctionType * type,
    129128                CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C,
    130129                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {})
    … …  
    137136        bool has_body() const { return stmts; }
    138137
    139         const DeclWithType * accept( Visitor & v ) const override { return v.visit( this ); }
     138        const DeclWithType * accept( Visitor &v ) const override { return v.visit( this ); }
    140139private:
    141140        FunctionDecl * clone() const override { return new FunctionDecl( *this ); }
    … …  
    164163/// Cforall type variable: `dtype T`
    165164class TypeDecl final : public NamedTypeDecl {
    166   public:
    167         enum Kind { Dtype, Otype, Ftype, Ttype, NUMBER_OF_KINDS };
    168 
    169         Kind kind;
     165public:
     166        TypeVar::Kind kind;
    170167        bool sized;
    171168        ptr<Type> init;
    … …  
    173170        /// Data extracted from a type decl
    174171        struct Data {
    175                 Kind kind;
     172                TypeVar::Kind kind;
    176173                bool isComplete;
    177174
    178                 Data() : kind( NUMBER_OF_KINDS ), isComplete( false ) {}
     175                Data() : kind( (TypeVar::Kind)-1 ), isComplete( false ) {}
    179176                Data( const TypeDecl * d ) : kind( d->kind ), isComplete( d->sized ) {}
    180                 Data( Kind k, bool c ) : kind( k ), isComplete( c ) {}
     177                Data( TypeVar::Kind k, bool c ) : kind( k ), isComplete( c ) {}
    181178                Data( const Data & d1, const Data & d2 )
    182                         : kind( d1.kind ), isComplete( d1.isComplete || d2.isComplete ) {}
    183 
    184                 bool operator==( const Data & o ) const { return kind == o.kind && isComplete == o.isComplete; }
    185                 bool operator!=( const Data & o ) const { return !(*this == o); }
     179                : kind( d1.kind ), isComplete( d1.isComplete || d2.isComplete ) {}
     180
     181                bool operator== ( const Data & o ) const {
     182                        return kind == o.kind && isComplete == o.isComplete;
     183                }
     184                bool operator!= ( const Data & o ) const { return !(*this == o); }
    186185        };
    187186
    188         TypeDecl( const CodeLocation & loc, const std::string & name, Storage::Classes storage, Type * b,
    189                           Kind k, bool s, Type * i = nullptr )
    190                 : NamedTypeDecl( loc, name, storage, b ), kind( k ), sized( k == Ttype || s ),
    191                 init( i ) {}
     187        TypeDecl( const CodeLocation& loc, const std::string& name, Storage::Classes storage, Type* b,
     188                TypeVar::Kind k, bool s, Type* i = nullptr )
     189        : NamedTypeDecl( loc, name, storage, b ), kind( k ), sized( k == TypeVar::Ttype || s ),
     190          init( i ) {}
    192191
    193192        const char * typeString() const override;
    … …  
    199198
    200199        const Decl * accept( Visitor & v ) const override { return v.visit( this ); }
    201   private:
     200private:
    202201        TypeDecl * clone() const override { return new TypeDecl{ *this }; }
    203202        MUTATE_FRIEND
    … …  
    344343        ptr<AsmStmt> stmt;
    345344
    346         AsmDecl( const CodeLocation & loc, AsmStmt * stmt )
     345        AsmDecl( const CodeLocation & loc, AsmStmt *stmt )
    347346        : Decl( loc, "", {}, {} ), stmt(stmt) {}
    348347
    349         const AsmDecl * accept( Visitor & v ) const override { return v.visit( this ); }
    350 private:
    351         AsmDecl * clone() const override { return new AsmDecl( *this ); }
     348        const AsmDecl * accept( Visitor &v ) const override { return v.visit( this ); }
     349private:
     350        AsmDecl *clone() const override { return new AsmDecl( *this ); }
    352351        MUTATE_FRIEND
    353352};
    … …  
    361360        : Decl( loc, "", {}, {} ), cond( condition ), msg( msg ) {}
    362361
    363         const StaticAssertDecl * accept( Visitor & v ) const override { return v.visit( this ); }
     362        const StaticAssertDecl * accept( Visitor &v ) const override { return v.visit( this ); }
    364363private:
    365364        StaticAssertDecl * clone() const override { return new StaticAssertDecl( *this ); }

  • src/AST/Print.cpp

    rb7d6a36 rdca5802  
    13591359                preprint( node );
    13601360                os << "instance of type " << node->name
    1361                    << " (" << (node->kind == ast::TypeDecl::Ftype ? "" : "not ") << "function type)";
     1361                   << " (" << (node->kind == ast::TypeVar::Ftype ? "" : "not ") << "function type)";
    13621362                print( node->params );
    13631363

  • src/AST/Type.cpp

    rb7d6a36 rdca5802  
    99// Author           : Aaron B. Moss
    1010// Created On       : Mon May 13 15:00:00 2019
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Dec 15 16:56:28 2019
    13 // Update Count     : 4
     11// Last Modified By : Aaron B. Moss
     12// Last Modified On : Mon May 13 15:00:00 2019
     13// Update Count     : 1
    1414//
    1515
    … …  
    4848// --- BasicType
    4949
    50 // GENERATED START, DO NOT EDIT
    51 // GENERATED BY BasicTypes-gen.cc
    52 const char * BasicType::typeNames[] = {
     50const char *BasicType::typeNames[] = {
    5351        "_Bool",
    5452        "char",
    … …  
    8886        "_Float128x _Complex",
    8987};
    90 // GENERATED END
     88static_assert(
     89        sizeof(BasicType::typeNames)/sizeof(BasicType::typeNames[0]) == BasicType::NUMBER_OF_BASIC_TYPES,
     90        "Each basic type name should have a corresponding kind enum value"
     91);
    9192
    9293// --- FunctionType

  • src/AST/Type.hpp

    rb7d6a36 rdca5802  
    99// Author           : Aaron B. Moss
    1010// Created On       : Thu May 9 10:00:00 2019
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Dec 11 21:56:46 2019
    13 // Update Count     : 5
     11// Last Modified By : Aaron B. Moss
     12// Last Modified On : Thu May 9 10:00:00 2019
     13// Update Count     : 1
    1414//
    1515
    … …  
    2626#include "Fwd.hpp"
    2727#include "Node.hpp"          // for Node, ptr, ptr_base
     28#include "TypeVar.hpp"
    2829#include "Visitor.hpp"
    2930
    … …  
    422423public:
    423424        readonly<TypeDecl> base;
    424         TypeDecl::Kind kind;
     425        TypeVar::Kind kind;
    425426
    426427        TypeInstType( const std::string& n, const TypeDecl * b, CV::Qualifiers q = {},
    427428                std::vector<ptr<Attribute>> && as = {} )
    428429        : ReferenceToType( n, q, std::move(as) ), base( b ), kind( b->kind ) {}
    429         TypeInstType( const std::string& n, TypeDecl::Kind k, CV::Qualifiers q = {},
     430        TypeInstType( const std::string& n, TypeVar::Kind k, CV::Qualifiers q = {},
    430431                std::vector<ptr<Attribute>> && as = {} )
    431432        : ReferenceToType( n, q, std::move(as) ), base(), kind( k ) {}

  • src/AST/TypeEnvironment.cpp

    rb7d6a36 rdca5802  
    99// Author           : Aaron B. Moss
    1010// Created On       : Wed May 29 11:00:00 2019
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Dec 11 21:49:13 2019
    13 // Update Count     : 4
     11// Last Modified By : Aaron B. Moss
     12// Last Modified On : Wed May 29 11:00:00 2019
     13// Update Count     : 1
    1414//
    1515
    … …  
    240240                return true;
    241241        } else if ( auto typeInst = dynamic_cast< const TypeInstType * >( type ) ) {
    242                 return typeInst->kind == TypeDecl::Ftype;
     242                return typeInst->kind == TypeVar::Ftype;
    243243        } else return false;
    244244}
    … …  
    248248        bool tyVarCompatible( const TypeDecl::Data & data, const Type * type ) {
    249249                switch ( data.kind ) {
    250                   case TypeDecl::Dtype:
     250                  case TypeVar::Dtype:
    251251                        // to bind to an object type variable, the type must not be a function type.
    252252                        // if the type variable is specified to be a complete type then the incoming
    … …  
    254254                        // xxx - should this also check that type is not a tuple type and that it's not a ttype?
    255255                        return ! isFtype( type ) && ( ! data.isComplete || type->isComplete() );
    256                   case TypeDecl::Ftype:
     256                  case TypeVar::Ftype:
    257257                        return isFtype( type );
    258                   case TypeDecl::Ttype:
     258                  case TypeVar::Ttype:
    259259                        // ttype unifies with any tuple type
    260260                        return dynamic_cast< const TupleType * >( type ) || Tuples::isTtype( type );

  • src/AST/TypeEnvironment.hpp

    rb7d6a36 rdca5802  
    99// Author           : Aaron B. Moss
    1010// Created On       : Wed May 29 11:00:00 2019
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Dec 11 21:55:54 2019
    13 // Update Count     : 3
     11// Last Modified By : Aaron B. Moss
     12// Last Modified On : Wed May 29 11:00:00 2019
     13// Update Count     : 1
    1414//
    1515
    … …  
    2828#include "Type.hpp"
    2929#include "TypeSubstitution.hpp"
     30#include "TypeVar.hpp"
    3031#include "Common/Indenter.h"
    3132#include "ResolvExpr/WidenMode.h"
    … …  
    106107        /// Singleton class constructor from substitution
    107108        EqvClass( const std::string & v, const Type * b )
    108         : vars{ v }, bound( b ), allowWidening( false ), data( TypeDecl::Dtype, false ) {}
     109        : vars{ v }, bound( b ), allowWidening( false ), data( TypeVar::Dtype, false ) {}
    109110
    110111        /// Single-var constructor (strips qualifiers from bound type)

  • src/AST/module.mk

    rb7d6a36 rdca5802  
    1010## Author           : Thierry Delisle
    1111## Created On       : Thu May 09 16:05:36 2019
    12 ## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Sat Dec 14 07:29:10 2019
    14 ## Update Count     : 3
     12## Last Modified By :
     13## Last Modified On :
     14## Update Count     :
    1515###############################################################################
    1616
    … …  
    3434        AST/TypeSubstitution.cpp
    3535
     36
     37
    3638SRC += $(SRC_AST)
    3739SRCDEMANGLE += $(SRC_AST)

  • src/BasicTypes-gen.cc

    rb7d6a36 rdca5802  
    273273
    274274
    275         #define TypeH TOP_SRCDIR "src/SynTree/Type.h"
    276         resetInput( file, TypeH, buffer, code, str );
    277 
    278         if ( (start = str.find( STARTMK )) == string::npos ) Abort( "start", TypeH );
     275        #define Type TOP_SRCDIR "src/SynTree/Type.h"
     276        resetInput( file, Type, buffer, code, str );
     277
     278        if ( (start = str.find( STARTMK )) == string::npos ) Abort( "start", Type );
    279279        start += sizeof( STARTMK );                                                     // includes newline
    280280        code << str.substr( 0, start );
    … …  
    289289        code << "\t";                                                                           // indentation for end marker
    290290
    291         if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", TypeH );
     291        if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", Type );
    292292        code << str.substr( start );
    293293
    294         output( file, TypeH, code );
     294        output( file, Type, code );
    295295        // cout << code.str();
    296296
    297297
    298         #define TypeC TOP_SRCDIR "src/SynTree/Type.cc"
    299         resetInput( file, TypeC, buffer, code, str );
    300 
    301         if ( (start = str.find( STARTMK )) == string::npos ) Abort( "start", TypeC );
    302         start += sizeof( STARTMK );                                                     // includes newline
    303         code << str.substr( 0, start );
    304 
    305         code << BYMK << endl;
    306         code << "const char * BasicType::typeNames[] = {" << endl;
    307         for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) {
    308                 code << "\t\"" << graph[r].type << "\"," << endl;
    309         } // for       
    310         code << "};" << endl;
    311 
    312         if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", TypeC );
    313         code << str.substr( start );
    314 
    315         output( file, TypeC, code );
    316         // cout << code.str();
    317 
    318 
    319298        // TEMPORARY DURING CHANGE OVER
    320         #define TypeH_AST TOP_SRCDIR "src/AST/Type.hpp"
    321         resetInput( file, TypeH_AST, buffer, code, str );
    322 
    323         if ( (start = str.find( STARTMK )) == string::npos ) Abort( "start", TypeH_AST );
     299        #define TypeAST TOP_SRCDIR "src/AST/Type.hpp"
     300        resetInput( file, TypeAST, buffer, code, str );
     301
     302        if ( (start = str.find( STARTMK )) == string::npos ) Abort( "start", TypeAST );
    324303        start += sizeof( STARTMK );                                                     // includes newline
    325304        code << str.substr( 0, start );
    … …  
    334313        code << "\t";                                                                           // indentation for end marker
    335314
    336         if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", TypeH_AST );
     315        if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", TypeAST );
    337316        code << str.substr( start );
    338317
    339         output( file, TypeH_AST, code );
    340         // cout << code.str();
    341 
    342 
    343         #define TypeC_AST TOP_SRCDIR "src/AST/Type.cpp"
    344         resetInput( file, TypeC_AST, buffer, code, str );
    345 
    346         if ( (start = str.find( STARTMK )) == string::npos ) Abort( "start", TypeC_AST );
    347         start += sizeof( STARTMK );                                                     // includes newline
    348         code << str.substr( 0, start );
    349 
    350         code << BYMK << endl;
    351         code << "const char * BasicType::typeNames[] = {" << endl;
    352         for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) {
    353                 code << "\t\"" << graph[r].type << "\"," << endl;
    354         } // for       
    355         code << "};" << endl;
    356 
    357         if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", TypeC_AST );
    358         code << str.substr( start );
    359 
    360         output( file, TypeC_AST, code );
     318        output( file, TypeAST, code );
    361319        // cout << code.str();
    362320

  • src/CodeGen/CodeGenerator.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Feb 16 08:32:48 2020
    13 // Update Count     : 532
     12// Last Modified On : Sat Oct 19 19:30:38 2019
     13// Update Count     : 506
    1414//
    1515#include "CodeGenerator.h"
    … …  
    2323#include "InitTweak/InitTweak.h"     // for getPointerBase
    2424#include "OperatorTable.h"           // for OperatorInfo, operatorLookup
    25 #include "SynTree/LinkageSpec.h"     // for Spec, Intrinsic
     25#include "Parser/LinkageSpec.h"      // for Spec, Intrinsic
    2626#include "SynTree/Attribute.h"       // for Attribute
    2727#include "SynTree/BaseSyntaxNode.h"  // for BaseSyntaxNode
    … …  
    3939        int CodeGenerator::tabsize = 4;
    4040
    41         // The kinds of statements that would ideally be followed by whitespace.
     41        // the kinds of statements that would ideally be followed by whitespace
    4242        bool wantSpacing( Statement * stmt) {
    4343                return dynamic_cast< IfStmt * >( stmt ) || dynamic_cast< CompoundStmt * >( stmt ) ||
    … …  
    7878        }
    7979
    80         // Using updateLocation at the beginning of a node and endl within a node should become the method of formating.
     80        /* Using updateLocation at the beginning of a node and endl
     81         * within a node should become the method of formating.
     82         */
    8183        void CodeGenerator::updateLocation( CodeLocation const & to ) {
    8284                // skip if linemarks shouldn't appear or if codelocation is unset
    … …  
    9395                } else {
    9496                        output << "\n# " << to.first_line << " \"" << to.filename
    95                                    << "\"\n" << indent;
     97                               << "\"\n" << indent;
    9698                        currentLocation = to;
    9799                }
    … …  
    129131
    130132        void CodeGenerator::genAttributes( list< Attribute * > & attributes ) {
    131                 if ( attributes.empty() ) return;
     133          if ( attributes.empty() ) return;
    132134                output << "__attribute__ ((";
    133135                for ( list< Attribute * >::iterator attr( attributes.begin() );; ) {
    … …  
    138140                                output << ")";
    139141                        } // if
    140                         if ( ++attr == attributes.end() ) break;
     142                  if ( ++attr == attributes.end() ) break;
    141143                        output << ",";                                                          // separator
    142144                } // for
    … …  
    163165                previsit( (BaseSyntaxNode *)node );
    164166                GuardAction( [this, node](){
    165                                 if ( options.printExprTypes && node->result ) {
    166                                         output << " /* " << genType( node->result, "", options ) << " */ ";
    167                                 }
    168                         } );
     167                        if ( options.printExprTypes && node->result ) {
     168                                output << " /* " << genType( node->result, "", options ) << " */ ";
     169                        }
     170                } );
    169171        }
    170172
    … …  
    397399                extension( applicationExpr );
    398400                if ( VariableExpr * varExpr = dynamic_cast< VariableExpr* >( applicationExpr->get_function() ) ) {
    399                         const OperatorInfo * opInfo;
    400                         if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic && ( opInfo = operatorLookup( varExpr->get_var()->get_name() ) ) ) {
     401                        OperatorInfo opInfo;
     402                        if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic && operatorLookup( varExpr->get_var()->get_name(), opInfo ) ) {
    401403                                std::list< Expression* >::iterator arg = applicationExpr->get_args().begin();
    402                                 switch ( opInfo->type ) {
     404                                switch ( opInfo.type ) {
    403405                                  case OT_INDEX:
    404406                                        assert( applicationExpr->get_args().size() == 2 );
    … …  
    421423                                                output << "(";
    422424                                                (*arg++)->accept( *visitor );
    423                                                 output << ") /* " << opInfo->inputName << " */";
     425                                                output << ") /* " << opInfo.inputName << " */";
    424426                                        } else if ( applicationExpr->get_args().size() == 2 ) {
    425427                                                // intrinsic two parameter constructors are essentially bitwise assignment
    426428                                                output << "(";
    427429                                                (*arg++)->accept( *visitor );
    428                                                 output << opInfo->symbol;
     430                                                output << opInfo.symbol;
    429431                                                (*arg)->accept( *visitor );
    430                                                 output << ") /* " << opInfo->inputName << " */";
     432                                                output << ") /* " << opInfo.inputName << " */";
    431433                                        } else {
    432434                                                // no constructors with 0 or more than 2 parameters
    … …  
    439441                                        assert( applicationExpr->get_args().size() == 1 );
    440442                                        output << "(";
    441                                         output << opInfo->symbol;
     443                                        output << opInfo.symbol;
    442444                                        (*arg)->accept( *visitor );
    443445                                        output << ")";
    … …  
    448450                                        assert( applicationExpr->get_args().size() == 1 );
    449451                                        (*arg)->accept( *visitor );
    450                                         output << opInfo->symbol;
     452                                        output << opInfo.symbol;
    451453                                        break;
    452454
    … …  
    457459                                        output << "(";
    458460                                        (*arg++)->accept( *visitor );
    459                                         output << opInfo->symbol;
     461                                        output << opInfo.symbol;
    460462                                        (*arg)->accept( *visitor );
    461463                                        output << ")";
    … …  
    484486                extension( untypedExpr );
    485487                if ( NameExpr * nameExpr = dynamic_cast< NameExpr* >( untypedExpr->function ) ) {
    486                         const OperatorInfo * opInfo = operatorLookup( nameExpr->name );
    487                         if ( opInfo ) {
     488                        OperatorInfo opInfo;
     489                        if ( operatorLookup( nameExpr->name, opInfo ) ) {
    488490                                std::list< Expression* >::iterator arg = untypedExpr->args.begin();
    489                                 switch ( opInfo->type ) {
     491                                switch ( opInfo.type ) {
    490492                                  case OT_INDEX:
    491493                                        assert( untypedExpr->args.size() == 2 );
    … …  
    506508                                                output << "(";
    507509                                                (*arg++)->accept( *visitor );
    508                                                 output << ") /* " << opInfo->inputName << " */";
     510                                                output << ") /* " << opInfo.inputName << " */";
    509511                                        } else if ( untypedExpr->get_args().size() == 2 ) {
    510512                                                // intrinsic two parameter constructors are essentially bitwise assignment
    511513                                                output << "(";
    512514                                                (*arg++)->accept( *visitor );
    513                                                 output << opInfo->symbol;
     515                                                output << opInfo.symbol;
    514516                                                (*arg)->accept( *visitor );
    515                                                 output << ") /* " << opInfo->inputName << " */";
     517                                                output << ") /* " << opInfo.inputName << " */";
    516518                                        } else {
    517519                                                // no constructors with 0 or more than 2 parameters
    … …  
    519521                                                output << "(";
    520522                                                (*arg++)->accept( *visitor );
    521                                                 output << opInfo->symbol << "{ ";
     523                                                output << opInfo.symbol << "{ ";
    522524                                                genCommaList( arg, untypedExpr->args.end() );
    523                                                 output << "}) /* " << opInfo->inputName << " */";
     525                                                output << "}) /* " << opInfo.inputName << " */";
    524526                                        } // if
    525527                                        break;
    … …  
    530532                                        assert( untypedExpr->args.size() == 1 );
    531533                                        output << "(";
    532                                         output << opInfo->symbol;
     534                                        output << opInfo.symbol;
    533535                                        (*arg)->accept( *visitor );
    534536                                        output << ")";
    … …  
    539541                                        assert( untypedExpr->args.size() == 1 );
    540542                                        (*arg)->accept( *visitor );
    541                                         output << opInfo->symbol;
     543                                        output << opInfo.symbol;
    542544                                        break;
    543545
    … …  
    547549                                        output << "(";
    548550                                        (*arg++)->accept( *visitor );
    549                                         output << opInfo->symbol;
     551                                        output << opInfo.symbol;
    550552                                        (*arg)->accept( *visitor );
    551553                                        output << ")";
    … …  
    579581        void CodeGenerator::postvisit( NameExpr * nameExpr ) {
    580582                extension( nameExpr );
    581                 const OperatorInfo * opInfo = operatorLookup( nameExpr->name );
    582                 if ( opInfo ) {
    583                         if ( opInfo->type == OT_CONSTANT ) {
    584                                 output << opInfo->symbol;
     583                OperatorInfo opInfo;
     584                if ( operatorLookup( nameExpr->name, opInfo ) ) {
     585                        if ( opInfo.type == OT_CONSTANT ) {
     586                                output << opInfo.symbol;
    585587                        } else {
    586                                 output << opInfo->outputName;
     588                                output << opInfo.outputName;
    587589                        }
    588590                } else {
    … …  
    652654        void CodeGenerator::postvisit( VariableExpr * variableExpr ) {
    653655                extension( variableExpr );
    654                 const OperatorInfo * opInfo;
    655                 if ( variableExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic && (opInfo = operatorLookup( variableExpr->get_var()->get_name() )) && opInfo->type == OT_CONSTANT ) {
    656                         output << opInfo->symbol;
     656                OperatorInfo opInfo;
     657                if ( variableExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic && operatorLookup( variableExpr->get_var()->get_name(), opInfo ) && opInfo.type == OT_CONSTANT ) {
     658                        output << opInfo.symbol;
    657659                } else {
    658660                        output << mangleName( variableExpr->get_var() );
    … …  
    10091011                  case BranchStmt::FallThroughDefault:
    10101012                        assertf( ! options.genC, "fallthru should not reach code generation." );
    1011                         output << "fallthru";
     1013                  output << "fallthru";
    10121014                        break;
    10131015                } // switch
    … …  
    10331035
    10341036                output << ((throwStmt->get_kind() == ThrowStmt::Terminate) ?
    1035                                    "throw" : "throwResume");
     1037                           "throw" : "throwResume");
    10361038                if (throwStmt->get_expr()) {
    10371039                        output << " ";
    … …  
    10481050
    10491051                output << ((stmt->get_kind() == CatchStmt::Terminate) ?
    1050                                    "catch" : "catchResume");
     1052                "catch" : "catchResume");
    10511053                output << "( ";
    10521054                stmt->decl->accept( *visitor );
    … …  
    11851187
    11861188        std::string genName( DeclarationWithType * decl ) {
    1187                 const OperatorInfo * opInfo = operatorLookup( decl->get_name() );
    1188                 if ( opInfo ) {
    1189                         return opInfo->outputName;
     1189                CodeGen::OperatorInfo opInfo;
     1190                if ( operatorLookup( decl->get_name(), opInfo ) ) {
     1191                        return opInfo.outputName;
    11901192                } else {
    11911193                        return decl->get_name();

  • src/CodeGen/CodeGenerator.h

    rb7d6a36 rdca5802  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Feb 16 03:58:31 2020
    13 // Update Count     : 62
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Tue Apr 30 12:01:00 2019
     13// Update Count     : 57
    1414//
    1515
    … …  
    2929namespace CodeGen {
    3030        struct CodeGenerator : public WithShortCircuiting, public WithGuards, public WithVisitorRef<CodeGenerator> {
    31                 static int tabsize;
     31          static int tabsize;
    3232
    3333                CodeGenerator( std::ostream &os, bool pretty = false, bool genC = false, bool lineMarks = false, bool printExprTypes = false );
    … …  
    104104                void postvisit( AsmStmt * );
    105105                void postvisit( DirectiveStmt * );
    106                 void postvisit( AsmDecl * );                                    // special: statement in declaration context
     106                void postvisit( AsmDecl * );                            // special: statement in declaration context
    107107                void postvisit( IfStmt * );
    108108                void postvisit( SwitchStmt * );
    … …  
    147147                LabelPrinter printLabels;
    148148                Options options;
    149           public:
     149        public:
    150150                LineEnder endl;
    151           private:
     151        private:
    152152
    153153                CodeLocation currentLocation;
    … …  
    162162        template< class Iterator >
    163163        void CodeGenerator::genCommaList( Iterator begin, Iterator end ) {
    164                 if ( begin == end ) return;
     164          if ( begin == end ) return;
    165165                for ( ;; ) {
    166166                        (*begin++)->accept( *visitor );
    167                         if ( begin == end ) break;
     167                  if ( begin == end ) break;
    168168                        output << ", ";                                                         // separator
    169169                } // for

  • src/CodeGen/FixMain.h

    rb7d6a36 rdca5802  
    1010// Created On       : Thr Jan 12 14:11:09 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Feb 16 03:24:32 2020
    13 // Update Count     : 5
     12// Last Modified On : Fri Jul 21 22:16:59 2017
     13// Update Count     : 1
    1414//
    1515
    … …  
    1919#include <memory>
    2020
    21 #include "SynTree/LinkageSpec.h"
     21#include "Parser/LinkageSpec.h"
    2222
    2323class FunctionDecl;
    … …  
    4242                static std::unique_ptr<FunctionDecl> main_signature;
    4343        };
    44 } // namespace CodeGen
     44};

  • src/CodeGen/FixNames.cc

    rb7d6a36 rdca5802  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec 13 23:39:14 2019
    13 // Update Count     : 21
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Wed Jun 28 15:26:00 2017
     13// Update Count     : 20
    1414//
    1515
    … …  
    2222#include "Common/SemanticError.h"  // for SemanticError
    2323#include "FixMain.h"               // for FixMain
     24#include "Parser/LinkageSpec.h"    // for Cforall, isMangled
    2425#include "SymTab/Mangler.h"        // for Mangler
    25 #include "SynTree/LinkageSpec.h"   // for Cforall, isMangled
    2626#include "SynTree/Constant.h"      // for Constant
    2727#include "SynTree/Declaration.h"   // for FunctionDecl, ObjectDecl, Declarat...

  • src/CodeGen/GenType.h

    rb7d6a36 rdca5802  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Feb 16 04:11:40 2020
    13 // Update Count     : 5
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Tue Apr 30 11:47:00 2019
     13// Update Count     : 3
    1414//
    1515
    … …  
    2525        std::string genType( Type *type, const std::string &baseString, const Options &options );
    2626        std::string genType( Type *type, const std::string &baseString, bool pretty = false, bool genC = false, bool lineMarks = false );
    27         std::string genPrettyType( Type * type, const std::string & baseString );
     27  std::string genPrettyType( Type * type, const std::string & baseString );
    2828} // namespace CodeGen
    2929

  • src/CodeGen/Generate.cc

    rb7d6a36 rdca5802  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Feb 16 03:01:51 2020
    13 // Update Count     : 9
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Fri Aug 18 15:39:00 2017
     13// Update Count     : 7
    1414//
    1515#include "Generate.h"
    … …  
    2222#include "GenType.h"                 // for genPrettyType
    2323#include "Common/PassVisitor.h"      // for PassVisitor
    24 #include "SynTree/LinkageSpec.h"     // for isBuiltin, isGeneratable
     24#include "Parser/LinkageSpec.h"      // for isBuiltin, isGeneratable
    2525#include "SynTree/BaseSyntaxNode.h"  // for BaseSyntaxNode
    2626#include "SynTree/Declaration.h"     // for Declaration
    … …  
    6464        void generate( BaseSyntaxNode * node, std::ostream & os ) {
    6565                if ( Type * type = dynamic_cast< Type * >( node ) ) {
    66                         os << genPrettyType( type, "" );
     66                        os << CodeGen::genPrettyType( type, "" );
    6767                } else {
    6868                        PassVisitor<CodeGenerator> cgv( os, true, false, false, false );

  • src/CodeGen/OperatorTable.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb 18 15:55:01 2020
    13 // Update Count     : 55
     12// Last Modified On : Sat Jul 15 17:12:22 2017
     13// Update Count     : 15
    1414//
    1515
    … …  
    1717#include <map>        // for map, _Rb_tree_const_iterator, map<>::const_iterator
    1818#include <utility>    // for pair
    19 using namespace std;
    2019
    2120#include "OperatorTable.h"
    … …  
    2322
    2423namespace CodeGen {
    25         const OperatorInfo CodeGen::tableValues[] = {
    26                 // inputName symbol   outputName                     friendlyName                  type
    27                 {       "?[?]",   "",     "_operator_index",             "Index",                      OT_INDEX          },
    28                 {       "?{}",    "=",    "_constructor",                "Constructor",                OT_CTOR           },
    29                 {       "^?{}",   "",     "_destructor",                 "Destructor",                 OT_DTOR           },
    30                 {       "?()",    "",     "_operator_call",              "Call Operator",              OT_CALL           },
    31                 {       "?++",    "++",   "_operator_postincr",          "Postfix Increment",          OT_POSTFIXASSIGN  },
    32                 {       "?--",    "--",   "_operator_postdecr",          "Postfix Decrement",          OT_POSTFIXASSIGN  },
    33                 {       "*?",     "*",    "_operator_deref",             "Dereference",                OT_PREFIX         },
    34                 {       "+?",     "+",    "_operator_unaryplus",         "Plus",                       OT_PREFIX         },
    35                 {       "-?",     "-",    "_operator_unaryminus",        "Minus",                      OT_PREFIX         },
    36                 {       "~?",     "~",    "_operator_bitnot",            "Bitwise Not",                OT_PREFIX         },
    37                 {       "!?",     "!",    "_operator_lognot",            "Logical Not",                OT_PREFIX         },
    38                 {       "++?",    "++",   "_operator_preincr",           "Prefix Increment",           OT_PREFIXASSIGN   },
    39                 {       "--?",    "--",   "_operator_predecr",           "Prefix Decrement",           OT_PREFIXASSIGN   },
    40                 {       "?\\?",   "\\",   "_operator_exponential",       "Exponentiation",             OT_INFIX          },
    41                 {       "?*?",    "*",    "_operator_multiply",          "Multiplication",             OT_INFIX          },
    42                 {       "?/?",    "/",    "_operator_divide",            "Division",                   OT_INFIX          },
    43                 {       "?%?",    "%",    "_operator_modulus",           "Modulo",                     OT_INFIX          },
    44                 {       "?+?",    "+",    "_operator_add",               "Addition",                   OT_INFIX          },
    45                 {       "?-?",    "-",    "_operator_subtract",          "Substraction",               OT_INFIX          },
    46                 {       "?<<?",   "<<",   "_operator_shiftleft",         "Shift Left",                 OT_INFIX          },
    47                 {       "?>>?",   ">>",   "_operator_shiftright",        "Shift Right",                OT_INFIX          },
    48                 {       "?<?",    "<",    "_operator_less",              "Less-than",                  OT_INFIX          },
    49                 {       "?>?",    ">",    "_operator_greater",           "Greater-than",               OT_INFIX          },
    50                 {       "?<=?",   "<=",   "_operator_lessequal",         "Less-than-or-Equal",         OT_INFIX          },
    51                 {       "?>=?",   ">=",   "_operator_greaterequal",      "Greater-than-or-Equal",      OT_INFIX          },
    52                 {       "?==?",   "==",   "_operator_equal",             "Equality",                   OT_INFIX          },
    53                 {       "?!=?",   "!=",   "_operator_notequal",          "Not-Equal",                  OT_INFIX          },
    54                 {       "?&?",    "&",    "_operator_bitand",            "Bitwise And",                OT_INFIX          },
    55                 {       "?^?",    "^",    "_operator_bitxor",            "Bitwise Xor",                OT_INFIX          },
    56                 {       "?|?",    "|",    "_operator_bitor",             "Bitwise Or",                 OT_INFIX          },
    57                 {       "?=?",    "=",    "_operator_assign",            "Assignment",                 OT_INFIXASSIGN    },
    58                 {       "?\\=?",  "\\=",  "_operator_expassign",         "Exponentiation Assignment",  OT_INFIXASSIGN    },
    59                 {       "?*=?",   "*=",   "_operator_multassign",        "Multiplication Assignment",  OT_INFIXASSIGN    },
    60                 {       "?/=?",   "/=",   "_operator_divassign",         "Division Assignment",        OT_INFIXASSIGN    },
    61                 {       "?%=?",   "%=",   "_operator_modassign",         "Modulo Assignment",          OT_INFIXASSIGN    },
    62                 {       "?+=?",   "+=",   "_operator_addassign",         "Addition Assignment",        OT_INFIXASSIGN    },
    63                 {       "?-=?",   "-=",   "_operator_subassign",         "Substrction Assignment",     OT_INFIXASSIGN    },
    64                 {       "?<<=?",  "<<=",  "_operator_shiftleftassign",   "Shift Left Assignment",      OT_INFIXASSIGN    },
    65                 {       "?>>=?",  ">>=",  "_operator_shiftrightassign",  "Shift Right Assignment",     OT_INFIXASSIGN    },
    66                 {       "?&=?",   "&=",   "_operator_bitandassign",      "Bitwise And Assignment",     OT_INFIXASSIGN    },
    67                 {       "?^=?",   "^=",   "_operator_bitxorassign",      "Bitwise Xor Assignment",     OT_INFIXASSIGN    },
    68                 {       "?|=?",   "|=",   "_operator_bitorassign",       "Bitwise Or Assignment",      OT_INFIXASSIGN    },
    69         }; // tableValues
     24        namespace {
     25                const OperatorInfo tableValues[] = {
     26                        {       "?[?]",         "",             "_operator_index",                              OT_INDEX                        },
     27                        {       "?{}",          "=",    "_constructor",                                 OT_CTOR                         },
     28                        {       "^?{}",         "",             "_destructor",                                  OT_DTOR                         },
     29                        {       "?()",          "",             "_operator_call",                               OT_CALL                         },
     30                        {       "?++",          "++",   "_operator_postincr",                   OT_POSTFIXASSIGN        },
     31                        {       "?--",          "--",   "_operator_postdecr",                   OT_POSTFIXASSIGN        },
     32                        {       "*?",           "*",    "_operator_deref",                              OT_PREFIX                       },
     33                        {       "+?",           "+",    "_operator_unaryplus",                  OT_PREFIX                       },
     34                        {       "-?",           "-",    "_operator_unaryminus",                 OT_PREFIX                       },
     35                        {       "~?",           "~",    "_operator_bitnot",                             OT_PREFIX                       },
     36                        {       "!?",           "!",    "_operator_lognot",                             OT_PREFIX                       },
     37                        {       "++?",          "++",   "_operator_preincr",                    OT_PREFIXASSIGN         },
     38                        {       "--?",          "--",   "_operator_predecr",                    OT_PREFIXASSIGN         },
     39                        {       "?\\?",         "\\",   "_operator_exponential",                OT_INFIX                        },
     40                        {       "?*?",          "*",    "_operator_multiply",                   OT_INFIX                        },
     41                        {       "?/?",          "/",    "_operator_divide",                             OT_INFIX                        },
     42                        {       "?%?",          "%",    "_operator_modulus",                    OT_INFIX                        },
     43                        {       "?+?",          "+",    "_operator_add",                                OT_INFIX                        },
     44                        {       "?-?",          "-",    "_operator_subtract",                   OT_INFIX                        },
     45                        {       "?<<?",         "<<",   "_operator_shiftleft",                  OT_INFIX                        },
     46                        {       "?>>?",         ">>",   "_operator_shiftright",                 OT_INFIX                        },
     47                        {       "?<?",          "<",    "_operator_less",                               OT_INFIX                        },
     48                        {       "?>?",          ">",    "_operator_greater",                    OT_INFIX                        },
     49                        {       "?<=?",         "<=",   "_operator_lessequal",                  OT_INFIX                        },
     50                        {       "?>=?",         ">=",   "_operator_greaterequal",               OT_INFIX                        },
     51                        {       "?==?",         "==",   "_operator_equal",                              OT_INFIX                        },
     52                        {       "?!=?",         "!=",   "_operator_notequal",                   OT_INFIX                        },
     53                        {       "?&?",          "&",    "_operator_bitand",                             OT_INFIX                        },
     54                        {       "?^?",          "^",    "_operator_bitxor",                             OT_INFIX                        },
     55                        {       "?|?",          "|",    "_operator_bitor",                              OT_INFIX                        },
     56                        {       "?=?",          "=",    "_operator_assign",                             OT_INFIXASSIGN          },
     57                        {       "?\\=?",        "\\=",  "_operator_expassign",                  OT_INFIXASSIGN          },
     58                        {       "?*=?",         "*=",   "_operator_multassign",                 OT_INFIXASSIGN          },
     59                        {       "?/=?",         "/=",   "_operator_divassign",                  OT_INFIXASSIGN          },
     60                        {       "?%=?",         "%=",   "_operator_modassign",                  OT_INFIXASSIGN          },
     61                        {       "?+=?",         "+=",   "_operator_addassign",                  OT_INFIXASSIGN          },
     62                        {       "?-=?",         "-=",   "_operator_subassign",                  OT_INFIXASSIGN          },
     63                        {       "?<<=?",        "<<=",  "_operator_shiftleftassign",    OT_INFIXASSIGN          },
     64                        {       "?>>=?",        ">>=",  "_operator_shiftrightassign",   OT_INFIXASSIGN          },
     65                        {       "?&=?",         "&=",   "_operator_bitandassign",               OT_INFIXASSIGN          },
     66                        {       "?^=?",         "^=",   "_operator_bitxorassign",               OT_INFIXASSIGN          },
     67                        {       "?|=?",         "|=",   "_operator_bitorassign",                OT_INFIXASSIGN          },
     68                };
    7069
    71         std::map< std::string, OperatorInfo > CodeGen::table;
     70                const int numOps = sizeof( tableValues ) / sizeof( OperatorInfo );
    7271
    73         CodeGen::CodeGen() {
    74                 enum { numOps = sizeof( tableValues ) / sizeof( OperatorInfo ) };
    75                 for ( int i = 0; i < numOps; i += 1 ) {
    76                         table[ tableValues[i].inputName ] = tableValues[i];
    77                 } // for
     72                std::map< std::string, OperatorInfo > table;
     73
     74                void initialize() {
     75                        for ( int i = 0; i < numOps; ++i ) {
     76                                table[ tableValues[i].inputName ] = tableValues[i];
     77                        } // for
     78                }
     79        } // namespace
     80
     81        bool operatorLookup( const std::string & funcName, OperatorInfo & info ) {
     82                static bool init = false;
     83                if ( ! init ) {
     84                        initialize();
     85                } // if
     86
     87                std::map< std::string, OperatorInfo >::const_iterator i = table.find( funcName );
     88                if ( i == table.end() ) {
     89                        if ( isPrefix( funcName, "?`" ) ) {
     90                                // handle literal suffixes, which are user-defined postfix operators
     91                                info.inputName = funcName;
     92                                info.symbol = funcName.substr(2);
     93                                info.outputName = toString( "__operator_literal_", info.symbol );
     94                                info.type = OT_POSTFIX;
     95                                return true;
     96                        }
     97                        return false;
     98                } else {
     99                        info = i->second;
     100                        return true;
     101                } // if
    78102        }
    79103
    80         const OperatorInfo * operatorLookup( const string & funcName ) {
    81                 if ( funcName.find_first_of( "?^*+-!", 0, 1 ) == string::npos ) return nullptr; // prefilter
    82                 const OperatorInfo * ret = &CodeGen::table.find( funcName )->second; // must be in the table
    83                 assert( ret );
    84                 return ret;
     104        bool isOperator( const std::string & funcName ) {
     105                OperatorInfo info;
     106                return operatorLookup( funcName, info );
    85107        }
    86108
    87         bool isOperator( const string & funcName ) {
    88                 return operatorLookup( funcName ) != nullptr;
    89         }
    90 
    91         string operatorFriendlyName( const string & funcName ) {
    92                 const OperatorInfo * info = operatorLookup( funcName );
    93                 if ( info ) return info->friendlyName;
    94                 return "";
    95         }
    96 
    97         bool isConstructor( const string & funcName ) {
    98                 const OperatorInfo * info = operatorLookup( funcName );
    99                 if ( info ) return info->type == OT_CTOR;
     109        /// determines if a given function name is one of the operator types between [begin, end)
     110        template<typename Iterator>
     111        bool isOperatorType( const std::string & funcName, Iterator begin, Iterator end ) {
     112                OperatorInfo info;
     113                if ( operatorLookup( funcName, info ) ) {
     114                        return std::find( begin, end, info.type ) != end;
     115                }
    100116                return false;
    101117        }
    102118
    103         bool isDestructor( const string & funcName ) {
    104                 const OperatorInfo * info = operatorLookup( funcName );
    105                 if ( info ) return info->type == OT_DTOR;
    106                 return false;
     119        bool isConstructor( const std::string & funcName ) {
     120                static OperatorType types[] = { OT_CTOR };
     121                return isOperatorType( funcName, std::begin(types), std::end(types) );
    107122        }
    108123
    109         bool isCtorDtor( const string & funcName ) {
    110                 const OperatorInfo * info = operatorLookup( funcName );
    111                 if ( info ) return info->type <= OT_CONSTRUCTOR;
    112                 return false;
     124        bool isDestructor( const std::string & funcName ) {
     125                static OperatorType types[] = { OT_DTOR };
     126                return isOperatorType( funcName, std::begin(types), std::end(types) );
    113127        }
    114128
    115         bool isAssignment( const string & funcName ) {
    116                 const OperatorInfo * info = operatorLookup( funcName );
    117                 if ( info ) return info->type > OT_CONSTRUCTOR && info->type <= OT_ASSIGNMENT;
    118                 return false;
     129        bool isAssignment( const std::string & funcName ) {
     130                static OperatorType types[] = { OT_PREFIXASSIGN, OT_POSTFIXASSIGN, OT_INFIXASSIGN };
     131                return isOperatorType( funcName, std::begin(types), std::end(types) );
    119132        }
    120133
    121         bool isCtorDtorAssign( const string & funcName ) {
    122                 const OperatorInfo * info = operatorLookup( funcName );
    123                 if ( info ) return info->type <= OT_ASSIGNMENT;
    124                 return false;
     134        bool isCtorDtor( const std::string & funcName ) {
     135                static OperatorType types[] = { OT_CTOR, OT_DTOR };
     136                return isOperatorType( funcName, std::begin(types), std::end(types) );
    125137        }
    126138
    127         CodeGen codegen;                                                                        // initialize singleton package
     139        bool isCtorDtorAssign( const std::string & funcName ) {
     140                static OperatorType types[] = { OT_CTOR, OT_DTOR, OT_PREFIXASSIGN, OT_POSTFIXASSIGN, OT_INFIXASSIGN };
     141                return isOperatorType( funcName, std::begin(types), std::end(types) );
     142        }
    128143} // namespace CodeGen
    129144
    130145// Local Variables: //
    131146// tab-width: 4 //
     147// mode: c++ //
     148// compile-command: "make install" //
    132149// End: //

  • src/CodeGen/OperatorTable.h

    rb7d6a36 rdca5802  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Feb 16 08:13:34 2020
    13 // Update Count     : 26
     12// Last Modified On : Fri Jul 21 22:17:11 2017
     13// Update Count     : 6
    1414//
    1515
    … …  
    1717
    1818#include <string>
    19 #include <map>
    2019
    2120namespace CodeGen {
    2221        enum OperatorType {
     22                OT_INDEX,
    2323                OT_CTOR,
    2424                OT_DTOR,
    25                 OT_CONSTRUCTOR = OT_DTOR,
     25                OT_CALL,
     26                OT_PREFIX,
     27                OT_POSTFIX,
     28                OT_INFIX,
    2629                OT_PREFIXASSIGN,
    2730                OT_POSTFIXASSIGN,
    2831                OT_INFIXASSIGN,
    29                 OT_ASSIGNMENT = OT_INFIXASSIGN,
    30                 OT_CALL,
    31                 OT_PREFIX,
    32                 OT_INFIX,
    33                 OT_POSTFIX,
    34                 OT_INDEX,
    3532                OT_LABELADDRESS,
    3633                OT_CONSTANT
    … …  
    4138                std::string symbol;
    4239                std::string outputName;
    43                 std::string friendlyName;
    4440                OperatorType type;
    4541        };
    4642
    47         class CodeGen {
    48                 friend const OperatorInfo * operatorLookup( const std::string & funcName );
    49 
    50                 static const OperatorInfo tableValues[];
    51                 static std::map< std::string, OperatorInfo > table;
    52           public:
    53                 CodeGen();
    54         }; // CodeGen
    55 
    5643        bool isOperator( const std::string & funcName );
    57         const OperatorInfo * operatorLookup( const std::string & funcName );
    58         std::string operatorFriendlyName( const std::string & funcName );
     44        bool operatorLookup( const std::string & funcName, OperatorInfo & info );
    5945
    6046        bool isConstructor( const std::string & );

  • src/CodeGen/Options.h

    rb7d6a36 rdca5802  
    99// Author           : Andrew Beach
    1010// Created On       : Tue Apr 30 11:36:00 2019
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Feb 15 18:37:06 2020
    13 // Update Count     : 3
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Thr May  2 10:45:00 2019
     13// Update Count     : 2
    1414//
    1515
    1616#pragma once
    1717
    18 struct Options {
    19         // External Options: Same thoughout a pass.
    20         bool pretty;
    21         bool genC;
    22         bool lineMarks;
    23         bool printExprTypes;
     18namespace CodeGen {
     19        struct Options {
     20                // External Options: Same thoughout a pass.
     21                bool pretty;
     22                bool genC;
     23                bool lineMarks;
     24                bool printExprTypes;
    2425
    25         // Internal Options: Changed on some recurisive calls.
    26         bool anonymousUnused = false;
     26                // Internal Options: Changed on some recurisive calls.
     27                bool anonymousUnused = false;
    2728
    28         Options(bool pretty, bool genC, bool lineMarks, bool printExprTypes) :
    29                 pretty(pretty), genC(genC), lineMarks(lineMarks), printExprTypes(printExprTypes)
     29                Options(bool pretty, bool genC, bool lineMarks, bool printExprTypes) :
     30                        pretty(pretty), genC(genC), lineMarks(lineMarks), printExprTypes(printExprTypes)
    3031                {}
    31 };
     32        };
     33} // namespace CodeGen
    3234
    3335// Local Variables: //

  • src/CodeGen/module.mk

    rb7d6a36 rdca5802  
    1111## Created On       : Mon Jun  1 17:49:17 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Sat Dec 14 07:29:42 2019
    14 ## Update Count     : 4
     13## Last Modified On : Tue Jun  2 11:17:02 2015
     14## Update Count     : 3
    1515###############################################################################
    1616
    … …  
    2424        CodeGen/OperatorTable.cc
    2525
     26
    2627SRC += $(SRC_CODEGEN) CodeGen/Generate.cc CodeGen/FixNames.cc
    2728SRCDEMANGLE += $(SRC_CODEGEN)

  • src/CodeTools/DeclStats.cc

    rb7d6a36 rdca5802  
    99// Author           : Aaron Moss
    1010// Created On       : Wed Jan 31 16:40:00 2016
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec 13 23:39:33 2019
    13 // Update Count     : 2
     11// Last Modified By : Aaron Moss
     12// Last Modified On : Wed Jan 31 16:40:00 2016
     13// Update Count     : 1
    1414//
    1515
    … …  
    2626#include "Common/VectorMap.h"      // for VectorMap
    2727#include "GenPoly/GenPoly.h"       // for hasPolyBase
    28 #include "SynTree/LinkageSpec.h"   // for ::NoOfSpecs, Spec
     28#include "Parser/LinkageSpec.h"    // for ::NoOfSpecs, Spec
    2929#include "SynTree/Declaration.h"   // for FunctionDecl, TypeDecl, Declaration
    3030#include "SynTree/Expression.h"    // for UntypedExpr, Expression

  • src/CodeTools/ResolvProtoDump.cc

    rb7d6a36 rdca5802  
    99// Author           : Aaron Moss
    1010// Created On       : Tue Sep 11 09:04:00 2018
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Feb 15 13:50:11 2020
    13 // Update Count     : 3
     11// Last Modified By : Aaron Moss
     12// Last Modified On : Tue Sep 11 09:04:00 2018
     13// Update Count     : 1
    1414//
    1515
    … …  
    182182
    183183                        // replace operator names
    184                         const CodeGen::OperatorInfo * opInfo = CodeGen::operatorLookup( name );
    185                         if ( opInfo ) {
     184                        CodeGen::OperatorInfo info;
     185                        if ( CodeGen::operatorLookup( name, info ) ) {
    186186                                ss << new_prefix(pre, "");
    187                                 op_name( opInfo->outputName, ss );
     187                                op_name( info.outputName, ss );
    188188                                return;
    189189                        }

  • src/Common/Debug.h

    rb7d6a36 rdca5802  
    99// Author           : Rob Schluntz
    1010// Created On       : Fri Sep 1 11:09:14 2017
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec 13 23:39:42 2019
    13 // Update Count     : 3
     11// Last Modified By : Rob Schluntz
     12// Last Modified On : Fri Sep 1 11:09:36 2017
     13// Update Count     : 2
    1414//
    1515
    … …  
    2121
    2222#include "CodeGen/Generate.h"
    23 #include "SynTree/LinkageSpec.h"
     23#include "Parser/LinkageSpec.h"
    2424#include "SynTree/Declaration.h"
    2525

  • src/Common/PassVisitor.impl.h

    rb7d6a36 rdca5802  
    33023302        VISIT_START( node );
    33033303
    3304         indexerAddUnion( node->name );
     3304        indexerAddStruct( node->name );
    33053305
    33063306        {
    … …  
    33173317        VISIT_START( node );
    33183318
    3319         indexerAddUnion( node->name );
     3319        indexerAddStruct( node->name );
    33203320
    33213321        {
    … …  
    33323332        MUTATE_START( node );
    33333333
    3334         indexerAddUnion( node->name );
     3334        indexerAddStruct( node->name );
    33353335
    33363336        {

  • src/Common/SemanticError.h

    rb7d6a36 rdca5802  
    4949struct WarningData {
    5050        const char * const name;
     51        const char * const message;
    5152        const Severity default_severity;
    52         const char * const message;
    5353};
    5454
    5555constexpr WarningData WarningFormats[] = {
    56         {"self-assign"            , Severity::Warn    , "self assignment of expression: %s"                          },
    57         {"reference-conversion"   , Severity::Warn    , "rvalue to reference conversion of rvalue: %s"               },
    58         {"qualifiers-zero_t-one_t", Severity::Warn    , "questionable use of type qualifier %s with %s"              },
    59         {"aggregate-forward-decl" , Severity::Warn    , "forward declaration of nested aggregate: %s"                },
    60         {"superfluous-decl"       , Severity::Warn    , "declaration does not allocate storage: %s"                  },
    61         {"gcc-attributes"         , Severity::Warn    , "invalid attribute: %s"                                      },
    62         {"c++-like-copy"          , Severity::Warn    , "Constructor from reference is not a valid copy constructor" },
     56        {"self-assign"            , "self assignment of expression: %s"            , Severity::Warn},
     57        {"reference-conversion"   , "rvalue to reference conversion of rvalue: %s" , Severity::Warn},
     58        {"qualifiers-zero_t-one_t", "questionable use of type qualifier %s with %s", Severity::Warn},
     59        {"aggregate-forward-decl" , "forward declaration of nested aggregate: %s"  , Severity::Warn},
     60        {"superfluous-decl"       , "declaration does not allocate storage: %s"    , Severity::Warn},
     61        {"gcc-attributes"         , "invalid attribute: %s"                        , Severity::Warn},
    6362};
    6463
    … …  
    7069        SuperfluousDecl,
    7170        GccAttributes,
    72         CppCopy,
    7371        NUMBER_OF_WARNINGS, // This MUST be the last warning
    7472};

  • src/Common/Stats/Time.h

    rb7d6a36 rdca5802  
    99// Author           : Thierry Delisle
    1010// Created On       : Fri Mar 01 15:14:11 2019
    11 // Last Modified By : Andrew Beach
     11// Last Modified By :
    1212// Last Modified On :
    1313// Update Count     :
    … …  
    4141                                f();
    4242                        }
    43 
    44                         template<typename ret_t = void, typename func_t, typename... arg_t>
    45                         inline ret_t TimeCall(
    46                                         const char *, func_t func, arg_t&&... arg) {
    47                                 return func(std::forward<arg_t>(arg)...);
    48                         }
    4943#               else
    5044                        void StartGlobal();
    … …  
    6559                                func();
    6660                        }
    67 
    68                         template<typename ret_t = void, typename func_t, typename... arg_t>
    69                         inline ret_t TimeCall(
    70                                         const char * name, func_t func, arg_t&&... arg) {
    71                                 BlockGuard guard(name);
    72                                 return func(std::forward<arg_t>(arg)...);
    73                         }
    7461#               endif
    7562        }

  • src/Common/utility.h

    rb7d6a36 rdca5802  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb 11 13:00:36 2020
    13 // Update Count     : 50
     12// Last Modified On : Wed Jul 24 14:28:19 2019
     13// Update Count     : 41
    1414//
    1515
    … …  
    2929#include <utility>
    3030#include <vector>
    31 #include <cstring>                                                                              // memcmp
    3231
    3332#include "Common/Indenter.h"
    … …  
    265264}
    266265
    267 // determines if pref is a prefix of str
    268 static inline bool isPrefix( const std::string & str, const std::string & pref, unsigned int start = 0 ) {
     266/// determines if `pref` is a prefix of `str`
     267static inline bool isPrefix( const std::string & str, const std::string & pref ) {
    269268        if ( pref.size() > str.size() ) return false;
    270     return 0 == memcmp( str.c_str() + start, pref.c_str(), pref.size() );
    271         // return prefix == full.substr(0, prefix.size()); // for future, requires c++17
     269        auto its = std::mismatch( pref.begin(), pref.end(), str.begin() );
     270        return its.first == pref.end();
    272271}
    273272

  • src/Concurrency/Keywords.cc

    rb7d6a36 rdca5802  
    1111// Last Modified By :
    1212// Last Modified On :
    13 // Update Count     : 10
     13// Update Count     : 9
    1414//
    1515
    … …  
    2424#include "CodeGen/OperatorTable.h" // for isConstructor
    2525#include "InitTweak/InitTweak.h"   // for getPointerBase
    26 #include "SynTree/LinkageSpec.h"   // for Cforall
     26#include "Parser/LinkageSpec.h"    // for Cforall
    2727#include "SynTree/Constant.h"      // for Constant
    2828#include "SynTree/Declaration.h"   // for StructDecl, FunctionDecl, ObjectDecl
    … …  
    716716                                new UntypedExpr(
    717717                                        new NameExpr( "__thrd_start" ),
    718                                         { new VariableExpr( param ), new NameExpr("main") }
     718                                        { new VariableExpr( param ) }
    719719                                )
    720720                        )

  • src/Concurrency/Waitfor.cc

    rb7d6a36 rdca5802  
    1111// Last Modified By :
    1212// Last Modified On :
    13 // Update Count     : 12
     13// Update Count     : 10
    1414//
    1515
    … …  
    2727#include "CodeGen/OperatorTable.h" // for isConstructor
    2828#include "InitTweak/InitTweak.h"   // for getPointerBase
     29#include "Parser/LinkageSpec.h"    // for Cforall
    2930#include "ResolvExpr/Resolver.h"   // for findVoidExpression
    30 #include "SynTree/LinkageSpec.h"   // for Cforall
    3131#include "SynTree/Constant.h"      // for Constant
    3232#include "SynTree/Declaration.h"   // for StructDecl, FunctionDecl, ObjectDecl
    … …  
    4242void foo() {
    4343        while( true ) {
    44                 when( a < 1 ) waitfor( f : a ) { bar(); }
     44                when( a < 1 ) waitfor( f, a ) { bar(); }
    4545                or timeout( swagl() );
    46                 or waitfor( g : a ) { baz(); }
    47                 or waitfor( ^?{} : a ) { break; }
     46                or waitfor( g, a ) { baz(); }
     47                or waitfor( ^?{}, a ) { break; }
    4848                or waitfor( ^?{} ) { break; }
    4949        }

  • src/ControlStruct/ExceptTranslate.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Wed Jun 14 16:49:00 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec 13 23:40:15 2019
    13 // Update Count     : 12
     12// Last Modified On : Wed Feb 13 18:15:29 2019
     13// Update Count     : 11
    1414//
    1515
    … …  
    2424#include "Common/SemanticError.h"     // for SemanticError
    2525#include "Common/utility.h"           // for CodeLocation
    26 #include "SynTree/LinkageSpec.h"      // for Cforall
     26#include "Parser/LinkageSpec.h"       // for Cforall
    2727#include "SynTree/Attribute.h"        // for Attribute
    2828#include "SynTree/Constant.h"         // for Constant

  • src/ControlStruct/LabelFixer.cc

    rb7d6a36 rdca5802  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Tue Jan 21 10:32:00 2020
    13 // Update Count     : 160
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon Mar 11 22:26:02 2019
     13// Update Count     : 159
    1414//
    1515
    … …  
    2121#include "ControlStruct/LabelGenerator.h"  // for LabelGenerator
    2222#include "LabelFixer.h"
    23 #include "MLEMutator.h"                    // for MultiLevelExitMutator
     23#include "MLEMutator.h"                    // for MLEMutator
    2424#include "SynTree/Declaration.h"           // for FunctionDecl
    2525#include "SynTree/Expression.h"            // for NameExpr, Expression, Unty...
    … …  
    4444
    4545        void LabelFixer::postvisit( FunctionDecl * functionDecl ) {
    46                 PassVisitor<MultiLevelExitMutator> mlem( resolveJumps(), generator );
    47                 // We start in the body so we can stop when we hit another FunctionDecl.
    48                 maybeMutate( functionDecl->statements, mlem );
     46                PassVisitor<MLEMutator> mlemut( resolveJumps(), generator );
     47                functionDecl->acceptMutator( mlemut );
    4948        }
    5049
    … …  
    7675
    7776
    78         // Sets the definition of the labelTable entry to be the provided statement for every label in
    79         // the list parameter. Happens for every kind of statement.
     77        // sets the definition of the labelTable entry to be the provided statement for every label in the list
     78        // parameter. Happens for every kind of statement
    8079        Label LabelFixer::setLabelsDef( std::list< Label > & llabel, Statement * definition ) {
    8180                assert( definition != 0 );
    8281                assert( llabel.size() > 0 );
     82
     83                Entry * e = new Entry( definition );
    8384
    8485                for ( std::list< Label >::iterator i = llabel.begin(); i != llabel.end(); i++ ) {
    … …  
    8687                        l.set_statement( definition ); // attach statement to the label to be used later
    8788                        if ( labelTable.find( l ) == labelTable.end() ) {
    88                                 // All labels on this statement need to use the same entry,
    89                                 // so this should only be created once.
     89                                // all labels on this statement need to use the same entry, so this should only be created once
    9090                                // undefined and unused until now, add an entry
    91                                 labelTable[ l ] = new Entry( definition );
     91                                labelTable[ l ] =  e;
    9292                        } else if ( labelTable[ l ]->defined() ) {
    9393                                // defined twice, error
    94                                 SemanticError( l.get_statement()->location,
    95                                         "Duplicate definition of label: " + l.get_name() );
    96                         } else {
     94                                SemanticError( l.get_statement()->location, "Duplicate definition of label: " + l.get_name() );
     95                        }       else {
    9796                                // used previously, but undefined until now -> link with this entry
    98                                 // Question: Is changing objects important?
    9997                                delete labelTable[ l ];
    100                                 labelTable[ l ] = new Entry( definition );
     98                                labelTable[ l ] = e;
    10199                        } // if
    102100                } // for
    103101
    104                 // Produce one of the labels attached to this statement to be temporarily used as the
    105                 // canonical label.
     102                // produce one of the labels attached to this statement to be temporarily used as the canonical label
    106103                return labelTable[ llabel.front() ]->get_label();
    107104        }

  • src/ControlStruct/MLEMutator.cc

    rb7d6a36 rdca5802  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Wed Jan 22 11:50:00 2020
    13 // Update Count     : 223
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Tue Oct 22 17:22:44 2019
     13// Update Count     : 220
    1414//
    1515
    … …  
    3333
    3434namespace ControlStruct {
    35         MultiLevelExitMutator::~MultiLevelExitMutator() {
     35        MLEMutator::~MLEMutator() {
    3636                delete targetTable;
    3737                targetTable = 0;
    3838        }
    3939        namespace {
    40                 bool isLoop( const MultiLevelExitMutator::Entry & e ) {
    41                         return dynamic_cast< WhileStmt * >( e.get_controlStructure() )
    42                                 || dynamic_cast< ForStmt * >( e.get_controlStructure() );
    43                 }
    44                 bool isSwitch( const MultiLevelExitMutator::Entry & e ) {
    45                         return dynamic_cast< SwitchStmt *>( e.get_controlStructure() );
    46                 }
    47 
    48                 bool isBreakTarget( const MultiLevelExitMutator::Entry & e ) {
    49                         return isLoop( e ) || isSwitch( e )
    50                                 || dynamic_cast< CompoundStmt *>( e.get_controlStructure() );
    51                 }
    52                 bool isContinueTarget( const MultiLevelExitMutator::Entry & e ) {
    53                         return isLoop( e );
    54                 }
    55                 bool isFallthroughTarget( const MultiLevelExitMutator::Entry & e ) {
    56                         return dynamic_cast< CaseStmt *>( e.get_controlStructure() );
    57                 }
    58                 bool isFallthroughDefaultTarget( const MultiLevelExitMutator::Entry & e ) {
    59                         return isSwitch( e );
    60                 }
     40                bool isLoop( const MLEMutator::Entry & e ) { return dynamic_cast< WhileStmt * >( e.get_controlStructure() ) || dynamic_cast< ForStmt * >( e.get_controlStructure() ); }
     41                bool isSwitch( const MLEMutator::Entry & e ) { return dynamic_cast< SwitchStmt *>( e.get_controlStructure() ); }
     42
     43                bool isBreakTarget( const MLEMutator::Entry & e ) { return isLoop( e ) || isSwitch( e ) || dynamic_cast< CompoundStmt *>( e.get_controlStructure() ); }
     44                bool isContinueTarget( const MLEMutator::Entry & e ) { return isLoop( e ); }
     45                bool isFallthroughTarget( const MLEMutator::Entry & e ) { return dynamic_cast< CaseStmt *>( e.get_controlStructure() );; }
     46                bool isFallthroughDefaultTarget( const MLEMutator::Entry & e ) { return isSwitch( e ); }
    6147        } // namespace
    62 
    63         void MultiLevelExitMutator::premutate( FunctionDecl * ) {
    64                 visit_children = false;
    65         }
    6648
    6749        // break labels have to come after the statement they break out of, so mutate a statement, then if they inform us
    6850        // through the breakLabel field tha they need a place to jump to on a break statement, add the break label to the
    6951        // body of statements
    70         void MultiLevelExitMutator::fixBlock( std::list< Statement * > &kids, bool caseClause ) {
     52        void MLEMutator::fixBlock( std::list< Statement * > &kids, bool caseClause ) {
    7153                SemanticErrorException errors;
    7254
    … …  
    9981        }
    10082
    101         void MultiLevelExitMutator::premutate( CompoundStmt *cmpndStmt ) {
     83        void MLEMutator::premutate( CompoundStmt *cmpndStmt ) {
    10284                visit_children = false;
    10385                bool labeledBlock = !(cmpndStmt->labels.empty());
    … …  
    136118                        }
    137119                }
    138                 assertf( false, "Could not find label '%s' on statement %s",
    139                         originalTarget.get_name().c_str(), toString( stmt ).c_str() );
    140         }
    141 
    142 
    143         Statement *MultiLevelExitMutator::postmutate( BranchStmt *branchStmt )
    144                         throw ( SemanticErrorException ) {
     120                assertf( false, "Could not find label '%s' on statement %s", originalTarget.get_name().c_str(), toString( stmt ).c_str() );
     121        }
     122
     123
     124        Statement *MLEMutator::postmutate( BranchStmt *branchStmt ) throw ( SemanticErrorException ) {
    145125                std::string originalTarget = branchStmt->originalTarget;
    146126
    … …  
    250230        }
    251231
    252         Statement *MultiLevelExitMutator::mutateLoop( Statement *bodyLoop, Entry &e ) {
     232        Statement *MLEMutator::mutateLoop( Statement *bodyLoop, Entry &e ) {
    253233                // only generate these when needed
    254234                if( !e.isContUsed() && !e.isBreakUsed() ) return bodyLoop;
    … …  
    273253
    274254        template< typename LoopClass >
    275         void MultiLevelExitMutator::prehandleLoopStmt( LoopClass * loopStmt ) {
     255        void MLEMutator::prehandleLoopStmt( LoopClass * loopStmt ) {
    276256                // remember this as the most recent enclosing loop, then mutate the body of the loop -- this will determine
    277257                // whether brkLabel and contLabel are used with branch statements and will recursively do the same to nested
    … …  
    284264
    285265        template< typename LoopClass >
    286         Statement * MultiLevelExitMutator::posthandleLoopStmt( LoopClass * loopStmt ) {
     266        Statement * MLEMutator::posthandleLoopStmt( LoopClass * loopStmt ) {
    287267                assert( ! enclosingControlStructures.empty() );
    288268                Entry &e = enclosingControlStructures.back();
    … …  
    295275        }
    296276
    297         void MultiLevelExitMutator::premutate( WhileStmt * whileStmt ) {
     277        void MLEMutator::premutate( WhileStmt * whileStmt ) {
    298278                return prehandleLoopStmt( whileStmt );
    299279        }
    300280
    301         void MultiLevelExitMutator::premutate( ForStmt * forStmt ) {
     281        void MLEMutator::premutate( ForStmt * forStmt ) {
    302282                return prehandleLoopStmt( forStmt );
    303283        }
    304284
    305         Statement * MultiLevelExitMutator::postmutate( WhileStmt * whileStmt ) {
     285        Statement * MLEMutator::postmutate( WhileStmt * whileStmt ) {
    306286                return posthandleLoopStmt( whileStmt );
    307287        }
    308288
    309         Statement * MultiLevelExitMutator::postmutate( ForStmt * forStmt ) {
     289        Statement * MLEMutator::postmutate( ForStmt * forStmt ) {
    310290                return posthandleLoopStmt( forStmt );
    311291        }
    312292
    313         void MultiLevelExitMutator::premutate( IfStmt * ifStmt ) {
     293        void MLEMutator::premutate( IfStmt * ifStmt ) {
    314294                // generate a label for breaking out of a labeled if
    315295                bool labeledBlock = !(ifStmt->get_labels().empty());
    … …  
    321301        }
    322302
    323         Statement * MultiLevelExitMutator::postmutate( IfStmt * ifStmt ) {
     303        Statement * MLEMutator::postmutate( IfStmt * ifStmt ) {
    324304                bool labeledBlock = !(ifStmt->get_labels().empty());
    325305                if ( labeledBlock ) {
    … …  
    331311        }
    332312
    333         void MultiLevelExitMutator::premutate( TryStmt * tryStmt ) {
     313        void MLEMutator::premutate( TryStmt * tryStmt ) {
    334314                // generate a label for breaking out of a labeled if
    335315                bool labeledBlock = !(tryStmt->get_labels().empty());
    … …  
    341321        }
    342322
    343         Statement * MultiLevelExitMutator::postmutate( TryStmt * tryStmt ) {
     323        Statement * MLEMutator::postmutate( TryStmt * tryStmt ) {
    344324                bool labeledBlock = !(tryStmt->get_labels().empty());
    345325                if ( labeledBlock ) {
    … …  
    351331        }
    352332
    353         void MultiLevelExitMutator::premutate( FinallyStmt * ) {
    354                 GuardAction([this, old = std::move(enclosingControlStructures)]() {
    355                         enclosingControlStructures = std::move(old);
    356                 });
    357                 enclosingControlStructures = std::list<Entry>();
    358                 GuardValue( inFinally );
    359                 inFinally = true;
    360         }
    361 
    362         void MultiLevelExitMutator::premutate( ReturnStmt *returnStmt ) {
    363                 if ( inFinally ) {
    364                         SemanticError( returnStmt->location, "'return' may not appear in a finally clause" );
    365                 }
    366         }
    367 
    368         void MultiLevelExitMutator::premutate( CaseStmt *caseStmt ) {
     333        void MLEMutator::premutate( CaseStmt *caseStmt ) {
    369334                visit_children = false;
    370335
    … …  
    405370        }
    406371
    407         void MultiLevelExitMutator::premutate( SwitchStmt *switchStmt ) {
     372        void MLEMutator::premutate( SwitchStmt *switchStmt ) {
    408373                // generate a label for breaking out of a labeled switch
    409374                Label brkLabel = generator->newLabel("switchBreak", switchStmt);
    … …  
    431396        }
    432397
    433         Statement * MultiLevelExitMutator::postmutate( SwitchStmt * switchStmt ) {
     398        Statement * MLEMutator::postmutate( SwitchStmt * switchStmt ) {
    434399                Entry &e = enclosingControlStructures.back();
    435400                assert ( e == switchStmt );

  • src/ControlStruct/MLEMutator.h

    rb7d6a36 rdca5802  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Wed Jan 22 11:50:00 2020
    13 // Update Count     : 48
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Tue Oct 22 17:22:47 2019
     13// Update Count     : 45
    1414//
    1515
    … …  
    3030        class LabelGenerator;
    3131
    32         class MultiLevelExitMutator : public WithVisitorRef<MultiLevelExitMutator>,
    33                         public WithShortCircuiting, public WithGuards {
     32        class MLEMutator : public WithVisitorRef<MLEMutator>, public WithShortCircuiting, public WithGuards {
    3433          public:
    3534                class Entry;
    36                 MultiLevelExitMutator( std::map<Label, Statement *> *t, LabelGenerator *gen = 0 ) :
    37                         targetTable( t ), breakLabel(std::string("")), generator( gen ) {}
    38                 ~MultiLevelExitMutator();
    39 
    40                 void premutate( FunctionDecl * );
     35                MLEMutator( std::map<Label, Statement *> *t, LabelGenerator *gen = 0 ) : targetTable( t ), breakLabel(std::string("")), generator( gen ) {}
     36                ~MLEMutator();
    4137
    4238                void premutate( CompoundStmt *cmpndStmt );
    … …  
    5147                void premutate( SwitchStmt *switchStmt );
    5248                Statement * postmutate( SwitchStmt *switchStmt );
    53                 void premutate( ReturnStmt *returnStmt );
    5449                void premutate( TryStmt *tryStmt );
    5550                Statement * postmutate( TryStmt *tryStmt );
    56                 void premutate( FinallyStmt *finallyStmt );
    5751
    5852                Statement *mutateLoop( Statement *bodyLoop, Entry &e );
    … …  
    116110                Label breakLabel;
    117111                LabelGenerator *generator;
    118                 bool inFinally = false;
    119112
    120113                template< typename LoopClass >

  • src/ControlStruct/Mutate.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Feb 16 03:22:07 2020
    13 // Update Count     : 10
     12// Last Modified On : Thu Aug  4 11:39:08 2016
     13// Update Count     : 9
    1414//
    1515
    … …  
    3737                mutateAll( translationUnit, formut );
    3838        }
    39 } // namespace ControlStruct
     39} // namespace CodeGen
    4040
    4141// Local Variables: //

  • src/GenPoly/Box.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec 13 23:40:34 2019
    13 // Update Count     : 347
     12// Last Modified On : Wed Jun 21 15:49:59 2017
     13// Update Count     : 346
    1414//
    1515
    … …  
    3737#include "InitTweak/InitTweak.h"         // for getFunctionName, isAssignment
    3838#include "Lvalue.h"                      // for generalizedLvalue
     39#include "Parser/LinkageSpec.h"          // for C, Spec, Cforall, Intrinsic
    3940#include "ResolvExpr/TypeEnvironment.h"  // for EqvClass
    4041#include "ResolvExpr/typeops.h"          // for typesCompatible
    … …  
    4344#include "SymTab/Indexer.h"              // for Indexer
    4445#include "SymTab/Mangler.h"              // for Mangler
    45 #include "SynTree/LinkageSpec.h"         // for C, Spec, Cforall, Intrinsic
    4646#include "SynTree/Attribute.h"           // for Attribute
    4747#include "SynTree/Constant.h"            // for Constant

  • src/GenPoly/Lvalue.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec 13 23:14:38 2019
    13 // Update Count     : 7
     12// Last Modified On : Fri Mar 17 09:11:18 2017
     13// Update Count     : 5
    1414//
    1515
    … …  
    1717#include <string>                        // for string
    1818
    19 #include "Common/UniqueName.h"
    2019#include "Common/PassVisitor.h"
    2120#include "GenPoly.h"                     // for isPolyType
    … …  
    2322
    2423#include "InitTweak/InitTweak.h"
     24#include "Parser/LinkageSpec.h"          // for Spec, isBuiltin, Intrinsic
    2525#include "ResolvExpr/TypeEnvironment.h"  // for AssertionSet, OpenVarSet
    2626#include "ResolvExpr/Unify.h"            // for unify
    2727#include "ResolvExpr/typeops.h"
    2828#include "SymTab/Indexer.h"              // for Indexer
    29 #include "SynTree/LinkageSpec.h"         // for Spec, isBuiltin, Intrinsic
    3029#include "SynTree/Declaration.h"         // for Declaration, FunctionDecl
    3130#include "SynTree/Expression.h"          // for Expression, ConditionalExpr

  • src/GenPoly/Specialize.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec 13 23:40:49 2019
    13 // Update Count     : 32
     12// Last Modified On : Thu Mar 16 07:53:59 2017
     13// Update Count     : 31
    1414//
    1515
    … …  
    2727#include "GenPoly.h"                     // for getFunctionType
    2828#include "InitTweak/InitTweak.h"         // for isIntrinsicCallExpr
     29#include "Parser/LinkageSpec.h"          // for C
    2930#include "ResolvExpr/FindOpenVars.h"     // for findOpenVars
    3031#include "ResolvExpr/TypeEnvironment.h"  // for OpenVarSet, AssertionSet
    3132#include "Specialize.h"
    32 #include "SynTree/LinkageSpec.h"         // for C
    3333#include "SynTree/Attribute.h"           // for Attribute
    3434#include "SynTree/Declaration.h"         // for FunctionDecl, DeclarationWit...

  • src/InitTweak/FixGlobalInit.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Mon May 04 15:14:56 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec 13 23:41:10 2019
    13 // Update Count     : 19
     12// Last Modified On : Thu Mar 16 07:53:11 2017
     13// Update Count     : 18
    1414//
    1515
    … …  
    2323#include "Common/UniqueName.h"     // for UniqueName
    2424#include "InitTweak.h"             // for isIntrinsicSingleArgCallStmt
    25 #include "SynTree/LinkageSpec.h"   // for C
     25#include "Parser/LinkageSpec.h"    // for C
    2626#include "SynTree/Attribute.h"     // for Attribute
    2727#include "SynTree/Constant.h"      // for Constant

  • src/InitTweak/FixInit.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Wed Jan 13 16:29:30 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Feb 16 04:17:07 2020
    13 // Update Count     : 82
     12// Last Modified On : Wed Feb 13 18:15:56 2019
     13// Update Count     : 76
    1414//
    1515#include "FixInit.h"
    … …  
    3838#include "GenPoly/GenPoly.h"           // for getFunctionType
    3939#include "InitTweak.h"                 // for getFunctionName, getCallArg
     40#include "Parser/LinkageSpec.h"        // for C, Spec, Cforall, isBuiltin
    4041#include "ResolvExpr/Resolver.h"       // for findVoidExpression
    4142#include "ResolvExpr/typeops.h"        // for typesCompatible
    … …  
    4344#include "SymTab/Indexer.h"            // for Indexer
    4445#include "SymTab/Mangler.h"            // for Mangler
    45 #include "SynTree/LinkageSpec.h"       // for C, Spec, Cforall, isBuiltin
    4646#include "SynTree/Attribute.h"         // for Attribute
    4747#include "SynTree/Constant.h"          // for Constant
    … …  
    745745                }
    746746
    747                 // to prevent warnings ('_unq0' may be used uninitialized in this function),
     747                // to prevent warnings (‘_unq0’ may be used uninitialized in this function),
    748748                // insert an appropriate zero initializer for UniqueExpr temporaries.
    749749                Initializer * makeInit( Type * t ) {

  • src/InitTweak/FixInit.h

    rb7d6a36 rdca5802  
    1010// Created On       : Wed Jan 13 16:29:30 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Feb 16 07:54:50 2020
    13 // Update Count     : 8
     12// Last Modified On : Sat Jul 22 09:31:06 2017
     13// Update Count     : 6
    1414//
    1515
    … …  
    2222
    2323namespace InitTweak {
    24         /// replace constructor initializers with expression statements and unwrap basic C-style initializers
     24  /// replace constructor initializers with expression statements
     25  /// and unwrap basic C-style initializers
    2526        void fix( std::list< Declaration * > & translationUnit, bool inLibrary );
    2627} // namespace

  • src/InitTweak/GenInit.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec 13 23:15:10 2019
    13 // Update Count     : 184
     12// Last Modified On : Fri Mar 17 09:12:36 2017
     13// Update Count     : 183
    1414//
    1515#include "GenInit.h"
    … …  
    3434#include "GenPoly/ScopedSet.h"         // for ScopedSet, ScopedSet<>::const_iter...
    3535#include "InitTweak.h"                 // for isConstExpr, InitExpander, checkIn...
     36#include "Parser/LinkageSpec.h"        // for isOverridable, C
    3637#include "ResolvExpr/Resolver.h"
    3738#include "SymTab/Autogen.h"            // for genImplicitCall
    3839#include "SymTab/Mangler.h"            // for Mangler
    39 #include "SynTree/LinkageSpec.h"       // for isOverridable, C
    4040#include "SynTree/Declaration.h"       // for ObjectDecl, DeclarationWithType
    4141#include "SynTree/Expression.h"        // for VariableExpr, UntypedExpr, Address...

  • src/InitTweak/InitTweak.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Fri May 13 11:26:36 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec 13 23:15:52 2019
    13 // Update Count     : 8
     12// Last Modified On : Thu Jul 25 22:21:48 2019
     13// Update Count     : 7
    1414//
    1515
    … …  
    3333#include "GenPoly/GenPoly.h"       // for getFunctionType
    3434#include "InitTweak.h"
     35#include "Parser/LinkageSpec.h"    // for Spec, isBuiltin, Intrinsic
    3536#include "ResolvExpr/typeops.h"    // for typesCompatibleIgnoreQualifiers
    3637#include "SymTab/Autogen.h"
    3738#include "SymTab/Indexer.h"        // for Indexer
    38 #include "SynTree/LinkageSpec.h"   // for Spec, isBuiltin, Intrinsic
    3939#include "SynTree/Attribute.h"     // for Attribute
    4040#include "SynTree/Constant.h"      // for Constant

  • src/MakeLibCfa.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Sat May 16 10:33:33 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Feb 16 03:49:49 2020
    13 // Update Count     : 45
     12// Last Modified On : Sun Feb 17 21:08:09 2019
     13// Update Count     : 41
    1414//
    1515
    … …  
    2323#include "Common/SemanticError.h"   // for SemanticError
    2424#include "Common/UniqueName.h"      // for UniqueName
    25 #include "SynTree/LinkageSpec.h"    // for Spec, Intrinsic, C
     25#include "Parser/LinkageSpec.h"     // for Spec, Intrinsic, C
    2626#include "SynTree/Declaration.h"    // for FunctionDecl, ObjectDecl, Declara...
    2727#include "SynTree/Expression.h"     // for NameExpr, UntypedExpr, VariableExpr
    … …  
    9696
    9797                        FunctionDecl *funcDecl = origFuncDecl->clone();
    98                         const CodeGen::OperatorInfo * opInfo;
    99                         opInfo = CodeGen::operatorLookup( funcDecl->get_name() );
    100                         assert( opInfo );
     98                        CodeGen::OperatorInfo opInfo;
     99                        bool lookResult = CodeGen::operatorLookup( funcDecl->get_name(), opInfo );
     100                        assert( lookResult );
    101101                        assert( ! funcDecl->get_statements() );
    102102                        // build a recursive call - this is okay, as the call will actually be codegen'd using operator syntax
    … …  
    120120
    121121                        Statement * stmt = nullptr;
    122                         switch ( opInfo->type ) {
     122                        switch ( opInfo.type ) {
    123123                          case CodeGen::OT_INDEX:
    124124                          case CodeGen::OT_CALL:

  • src/Makefile.in

    rb7d6a36 rdca5802  
    212212        SymTab/Indexer.$(OBJEXT) SymTab/Mangler.$(OBJEXT) \
    213213        SymTab/ManglerCommon.$(OBJEXT) SymTab/Validate.$(OBJEXT)
    214 am__objects_7 = SynTree/AddressExpr.$(OBJEXT) \
    215         SynTree/AggregateDecl.$(OBJEXT) \
    216         SynTree/ApplicationExpr.$(OBJEXT) SynTree/ArrayType.$(OBJEXT) \
    217         SynTree/AttrType.$(OBJEXT) SynTree/Attribute.$(OBJEXT) \
    218         SynTree/BasicType.$(OBJEXT) SynTree/CommaExpr.$(OBJEXT) \
    219         SynTree/CompoundStmt.$(OBJEXT) SynTree/Constant.$(OBJEXT) \
    220         SynTree/DeclReplacer.$(OBJEXT) SynTree/DeclStmt.$(OBJEXT) \
     214am__objects_7 = SynTree/Type.$(OBJEXT) SynTree/VoidType.$(OBJEXT) \
     215        SynTree/BasicType.$(OBJEXT) SynTree/PointerType.$(OBJEXT) \
     216        SynTree/ArrayType.$(OBJEXT) SynTree/ReferenceType.$(OBJEXT) \
     217        SynTree/FunctionType.$(OBJEXT) \
     218        SynTree/ReferenceToType.$(OBJEXT) SynTree/TupleType.$(OBJEXT) \
     219        SynTree/TypeofType.$(OBJEXT) SynTree/AttrType.$(OBJEXT) \
     220        SynTree/VarArgsType.$(OBJEXT) SynTree/ZeroOneType.$(OBJEXT) \
     221        SynTree/Constant.$(OBJEXT) SynTree/Expression.$(OBJEXT) \
     222        SynTree/TupleExpr.$(OBJEXT) SynTree/CommaExpr.$(OBJEXT) \
     223        SynTree/TypeExpr.$(OBJEXT) SynTree/ApplicationExpr.$(OBJEXT) \
     224        SynTree/AddressExpr.$(OBJEXT) SynTree/Statement.$(OBJEXT) \
     225        SynTree/CompoundStmt.$(OBJEXT) SynTree/DeclStmt.$(OBJEXT) \
    221226        SynTree/Declaration.$(OBJEXT) \
    222227        SynTree/DeclarationWithType.$(OBJEXT) \
    223         SynTree/Expression.$(OBJEXT) SynTree/FunctionDecl.$(OBJEXT) \
    224         SynTree/FunctionType.$(OBJEXT) SynTree/Initializer.$(OBJEXT) \
    225         SynTree/LinkageSpec.$(OBJEXT) SynTree/NamedTypeDecl.$(OBJEXT) \
    226         SynTree/ObjectDecl.$(OBJEXT) SynTree/PointerType.$(OBJEXT) \
    227         SynTree/ReferenceToType.$(OBJEXT) \
    228         SynTree/ReferenceType.$(OBJEXT) SynTree/Statement.$(OBJEXT) \
    229         SynTree/TupleExpr.$(OBJEXT) SynTree/TupleType.$(OBJEXT) \
    230         SynTree/Type.$(OBJEXT) SynTree/TypeDecl.$(OBJEXT) \
    231         SynTree/TypeExpr.$(OBJEXT) SynTree/TypeSubstitution.$(OBJEXT) \
    232         SynTree/TypeofType.$(OBJEXT) SynTree/VarArgsType.$(OBJEXT) \
    233         SynTree/VoidType.$(OBJEXT) SynTree/ZeroOneType.$(OBJEXT)
     228        SynTree/ObjectDecl.$(OBJEXT) SynTree/FunctionDecl.$(OBJEXT) \
     229        SynTree/AggregateDecl.$(OBJEXT) \
     230        SynTree/NamedTypeDecl.$(OBJEXT) SynTree/TypeDecl.$(OBJEXT) \
     231        SynTree/Initializer.$(OBJEXT) \
     232        SynTree/TypeSubstitution.$(OBJEXT) SynTree/Attribute.$(OBJEXT) \
     233        SynTree/DeclReplacer.$(OBJEXT)
    234234am__objects_8 = CompilationState.$(OBJEXT) $(am__objects_1) \
    235235        $(am__objects_2) Concurrency/Keywords.$(OBJEXT) \
    236236        $(am__objects_3) $(am__objects_4) GenPoly/GenPoly.$(OBJEXT) \
    237237        GenPoly/Lvalue.$(OBJEXT) InitTweak/GenInit.$(OBJEXT) \
    238         InitTweak/InitTweak.$(OBJEXT) $(am__objects_5) \
    239         $(am__objects_6) SymTab/Demangle.$(OBJEXT) $(am__objects_7) \
    240         Tuples/TupleAssignment.$(OBJEXT) \
     238        InitTweak/InitTweak.$(OBJEXT) Parser/LinkageSpec.$(OBJEXT) \
     239        $(am__objects_5) $(am__objects_6) SymTab/Demangle.$(OBJEXT) \
     240        $(am__objects_7) Tuples/TupleAssignment.$(OBJEXT) \
    241241        Tuples/TupleExpansion.$(OBJEXT) Tuples/Explode.$(OBJEXT) \
    242242        Tuples/Tuples.$(OBJEXT) Validate/HandleAttributes.$(OBJEXT) \
    … …  
    261261        InitTweak/GenInit.$(OBJEXT) InitTweak/FixInit.$(OBJEXT) \
    262262        InitTweak/FixGlobalInit.$(OBJEXT) \
    263         InitTweak/InitTweak.$(OBJEXT) Parser/DeclarationNode.$(OBJEXT) \
    264         Parser/ExpressionNode.$(OBJEXT) \
    265         Parser/InitializerNode.$(OBJEXT) Parser/ParseNode.$(OBJEXT) \
    266         Parser/StatementNode.$(OBJEXT) Parser/TypeData.$(OBJEXT) \
    267         Parser/TypedefTable.$(OBJEXT) Parser/lex.$(OBJEXT) \
    268         Parser/parser.$(OBJEXT) Parser/parserutility.$(OBJEXT) \
     263        InitTweak/InitTweak.$(OBJEXT) Parser/parser.$(OBJEXT) \
     264        Parser/lex.$(OBJEXT) Parser/TypedefTable.$(OBJEXT) \
     265        Parser/ParseNode.$(OBJEXT) Parser/DeclarationNode.$(OBJEXT) \
     266        Parser/ExpressionNode.$(OBJEXT) Parser/StatementNode.$(OBJEXT) \
     267        Parser/InitializerNode.$(OBJEXT) Parser/TypeData.$(OBJEXT) \
     268        Parser/LinkageSpec.$(OBJEXT) Parser/parserutility.$(OBJEXT) \
    269269        $(am__objects_5) ResolvExpr/AlternativePrinter.$(OBJEXT) \
    270270        $(am__objects_6) $(am__objects_7) \
    … …  
    559559        InitTweak/GenInit.cc InitTweak/FixInit.cc \
    560560        InitTweak/FixGlobalInit.cc InitTweak/InitTweak.cc \
    561         Parser/DeclarationNode.cc Parser/ExpressionNode.cc \
    562         Parser/InitializerNode.cc Parser/ParseNode.cc \
    563         Parser/StatementNode.cc Parser/TypeData.cc \
    564         Parser/TypedefTable.cc Parser/lex.ll Parser/parser.yy \
    565         Parser/parserutility.cc $(SRC_RESOLVEXPR) \
    566         ResolvExpr/AlternativePrinter.cc $(SRC_SYMTAB) $(SRC_SYNTREE) \
    567         Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc \
    568         Tuples/Explode.cc Tuples/Tuples.cc \
     561        Parser/parser.yy Parser/lex.ll Parser/TypedefTable.cc \
     562        Parser/ParseNode.cc Parser/DeclarationNode.cc \
     563        Parser/ExpressionNode.cc Parser/StatementNode.cc \
     564        Parser/InitializerNode.cc Parser/TypeData.cc \
     565        Parser/LinkageSpec.cc Parser/parserutility.cc \
     566        $(SRC_RESOLVEXPR) ResolvExpr/AlternativePrinter.cc \
     567        $(SRC_SYMTAB) $(SRC_SYNTREE) Tuples/TupleAssignment.cc \
     568        Tuples/TupleExpansion.cc Tuples/Explode.cc Tuples/Tuples.cc \
    569569        Validate/HandleAttributes.cc Validate/FindSpecialDecls.cc \
    570570        Virtual/ExpandCasts.cc
    … …  
    572572        Concurrency/Keywords.cc $(SRC_COMMON) $(SRC_CONTROLSTRUCT) \
    573573        GenPoly/GenPoly.cc GenPoly/Lvalue.cc InitTweak/GenInit.cc \
    574         InitTweak/InitTweak.cc $(SRC_RESOLVEXPR) $(SRC_SYMTAB) \
    575         SymTab/Demangle.cc $(SRC_SYNTREE) Tuples/TupleAssignment.cc \
    576         Tuples/TupleExpansion.cc Tuples/Explode.cc Tuples/Tuples.cc \
     574        InitTweak/InitTweak.cc Parser/LinkageSpec.cc $(SRC_RESOLVEXPR) \
     575        $(SRC_SYMTAB) SymTab/Demangle.cc $(SRC_SYNTREE) \
     576        Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc \
     577        Tuples/Explode.cc Tuples/Tuples.cc \
    577578        Validate/HandleAttributes.cc Validate/FindSpecialDecls.cc
    578579MAINTAINERCLEANFILES = ${libdir}/${notdir ${cfa_cpplib_PROGRAMS}}
    … …  
    662663
    663664SRC_SYNTREE = \
     665      SynTree/Type.cc \
     666      SynTree/VoidType.cc \
     667      SynTree/BasicType.cc \
     668      SynTree/PointerType.cc \
     669      SynTree/ArrayType.cc \
     670      SynTree/ReferenceType.cc \
     671      SynTree/FunctionType.cc \
     672      SynTree/ReferenceToType.cc \
     673      SynTree/TupleType.cc \
     674      SynTree/TypeofType.cc \
     675      SynTree/AttrType.cc \
     676      SynTree/VarArgsType.cc \
     677      SynTree/ZeroOneType.cc \
     678      SynTree/Constant.cc \
     679      SynTree/Expression.cc \
     680      SynTree/TupleExpr.cc \
     681      SynTree/CommaExpr.cc \
     682      SynTree/TypeExpr.cc \
     683      SynTree/ApplicationExpr.cc \
    664684      SynTree/AddressExpr.cc \
    665       SynTree/AggregateDecl.cc \
    666       SynTree/ApplicationExpr.cc \
    667       SynTree/ArrayType.cc \
    668       SynTree/AttrType.cc \
    669       SynTree/Attribute.cc \
    670       SynTree/BasicType.cc \
    671       SynTree/CommaExpr.cc \
     685      SynTree/Statement.cc \
    672686      SynTree/CompoundStmt.cc \
    673       SynTree/Constant.cc \
    674       SynTree/DeclReplacer.cc \
    675687      SynTree/DeclStmt.cc \
    676688      SynTree/Declaration.cc \
    677689      SynTree/DeclarationWithType.cc \
    678       SynTree/Expression.cc \
     690      SynTree/ObjectDecl.cc \
    679691      SynTree/FunctionDecl.cc \
    680       SynTree/FunctionType.cc \
     692      SynTree/AggregateDecl.cc \
     693      SynTree/NamedTypeDecl.cc \
     694      SynTree/TypeDecl.cc \
    681695      SynTree/Initializer.cc \
    682       SynTree/LinkageSpec.cc \
    683       SynTree/NamedTypeDecl.cc \
    684       SynTree/ObjectDecl.cc \
    685       SynTree/PointerType.cc \
    686       SynTree/ReferenceToType.cc \
    687       SynTree/ReferenceType.cc \
    688       SynTree/Statement.cc \
    689       SynTree/TupleExpr.cc \
    690       SynTree/TupleType.cc \
    691       SynTree/Type.cc \
    692       SynTree/TypeDecl.cc \
    693       SynTree/TypeExpr.cc \
    694696      SynTree/TypeSubstitution.cc \
    695       SynTree/TypeofType.cc \
    696       SynTree/VarArgsType.cc \
    697       SynTree/VoidType.cc \
    698       SynTree/ZeroOneType.cc
     697      SynTree/Attribute.cc \
     698      SynTree/DeclReplacer.cc
    699699
    700700
    … …  
    869869InitTweak/InitTweak.$(OBJEXT): InitTweak/$(am__dirstamp) \
    870870        InitTweak/$(DEPDIR)/$(am__dirstamp)
     871Parser/$(am__dirstamp):
     872        @$(MKDIR_P) Parser
     873        @: > Parser/$(am__dirstamp)
     874Parser/$(DEPDIR)/$(am__dirstamp):
     875        @$(MKDIR_P) Parser/$(DEPDIR)
     876        @: > Parser/$(DEPDIR)/$(am__dirstamp)
     877Parser/LinkageSpec.$(OBJEXT): Parser/$(am__dirstamp) \
     878        Parser/$(DEPDIR)/$(am__dirstamp)
    871879ResolvExpr/$(am__dirstamp):
    872880        @$(MKDIR_P) ResolvExpr
    … …  
    949957        @$(MKDIR_P) SynTree/$(DEPDIR)
    950958        @: > SynTree/$(DEPDIR)/$(am__dirstamp)
     959SynTree/Type.$(OBJEXT): SynTree/$(am__dirstamp) \
     960        SynTree/$(DEPDIR)/$(am__dirstamp)
     961SynTree/VoidType.$(OBJEXT): SynTree/$(am__dirstamp) \
     962        SynTree/$(DEPDIR)/$(am__dirstamp)
     963SynTree/BasicType.$(OBJEXT): SynTree/$(am__dirstamp) \
     964        SynTree/$(DEPDIR)/$(am__dirstamp)
     965SynTree/PointerType.$(OBJEXT): SynTree/$(am__dirstamp) \
     966        SynTree/$(DEPDIR)/$(am__dirstamp)
     967SynTree/ArrayType.$(OBJEXT): SynTree/$(am__dirstamp) \
     968        SynTree/$(DEPDIR)/$(am__dirstamp)
     969SynTree/ReferenceType.$(OBJEXT): SynTree/$(am__dirstamp) \
     970        SynTree/$(DEPDIR)/$(am__dirstamp)
     971SynTree/FunctionType.$(OBJEXT): SynTree/$(am__dirstamp) \
     972        SynTree/$(DEPDIR)/$(am__dirstamp)
     973SynTree/ReferenceToType.$(OBJEXT): SynTree/$(am__dirstamp) \
     974        SynTree/$(DEPDIR)/$(am__dirstamp)
     975SynTree/TupleType.$(OBJEXT): SynTree/$(am__dirstamp) \
     976        SynTree/$(DEPDIR)/$(am__dirstamp)
     977SynTree/TypeofType.$(OBJEXT): SynTree/$(am__dirstamp) \
     978        SynTree/$(DEPDIR)/$(am__dirstamp)
     979SynTree/AttrType.$(OBJEXT): SynTree/$(am__dirstamp) \
     980        SynTree/$(DEPDIR)/$(am__dirstamp)
     981SynTree/VarArgsType.$(OBJEXT): SynTree/$(am__dirstamp) \
     982        SynTree/$(DEPDIR)/$(am__dirstamp)
     983SynTree/ZeroOneType.$(OBJEXT): SynTree/$(am__dirstamp) \
     984        SynTree/$(DEPDIR)/$(am__dirstamp)
     985SynTree/Constant.$(OBJEXT): SynTree/$(am__dirstamp) \
     986        SynTree/$(DEPDIR)/$(am__dirstamp)
     987SynTree/Expression.$(OBJEXT): SynTree/$(am__dirstamp) \
     988        SynTree/$(DEPDIR)/$(am__dirstamp)
     989SynTree/TupleExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
     990        SynTree/$(DEPDIR)/$(am__dirstamp)
     991SynTree/CommaExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
     992        SynTree/$(DEPDIR)/$(am__dirstamp)
     993SynTree/TypeExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
     994        SynTree/$(DEPDIR)/$(am__dirstamp)
     995SynTree/ApplicationExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
     996        SynTree/$(DEPDIR)/$(am__dirstamp)
    951997SynTree/AddressExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
    952998        SynTree/$(DEPDIR)/$(am__dirstamp)
     999SynTree/Statement.$(OBJEXT): SynTree/$(am__dirstamp) \
     1000        SynTree/$(DEPDIR)/$(am__dirstamp)
     1001SynTree/CompoundStmt.$(OBJEXT): SynTree/$(am__dirstamp) \
     1002        SynTree/$(DEPDIR)/$(am__dirstamp)
     1003SynTree/DeclStmt.$(OBJEXT): SynTree/$(am__dirstamp) \
     1004        SynTree/$(DEPDIR)/$(am__dirstamp)
     1005SynTree/Declaration.$(OBJEXT): SynTree/$(am__dirstamp) \
     1006        SynTree/$(DEPDIR)/$(am__dirstamp)
     1007SynTree/DeclarationWithType.$(OBJEXT): SynTree/$(am__dirstamp) \
     1008        SynTree/$(DEPDIR)/$(am__dirstamp)
     1009SynTree/ObjectDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
     1010        SynTree/$(DEPDIR)/$(am__dirstamp)
     1011SynTree/FunctionDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
     1012        SynTree/$(DEPDIR)/$(am__dirstamp)
    9531013SynTree/AggregateDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
    9541014        SynTree/$(DEPDIR)/$(am__dirstamp)
    955 SynTree/ApplicationExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
    956         SynTree/$(DEPDIR)/$(am__dirstamp)
    957 SynTree/ArrayType.$(OBJEXT): SynTree/$(am__dirstamp) \
    958         SynTree/$(DEPDIR)/$(am__dirstamp)
    959 SynTree/AttrType.$(OBJEXT): SynTree/$(am__dirstamp) \
     1015SynTree/NamedTypeDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
     1016        SynTree/$(DEPDIR)/$(am__dirstamp)
     1017SynTree/TypeDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
     1018        SynTree/$(DEPDIR)/$(am__dirstamp)
     1019SynTree/Initializer.$(OBJEXT): SynTree/$(am__dirstamp) \
     1020        SynTree/$(DEPDIR)/$(am__dirstamp)
     1021SynTree/TypeSubstitution.$(OBJEXT): SynTree/$(am__dirstamp) \
    9601022        SynTree/$(DEPDIR)/$(am__dirstamp)
    9611023SynTree/Attribute.$(OBJEXT): SynTree/$(am__dirstamp) \
    9621024        SynTree/$(DEPDIR)/$(am__dirstamp)
    963 SynTree/BasicType.$(OBJEXT): SynTree/$(am__dirstamp) \
    964         SynTree/$(DEPDIR)/$(am__dirstamp)
    965 SynTree/CommaExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
    966         SynTree/$(DEPDIR)/$(am__dirstamp)
    967 SynTree/CompoundStmt.$(OBJEXT): SynTree/$(am__dirstamp) \
    968         SynTree/$(DEPDIR)/$(am__dirstamp)
    969 SynTree/Constant.$(OBJEXT): SynTree/$(am__dirstamp) \
    970         SynTree/$(DEPDIR)/$(am__dirstamp)
    9711025SynTree/DeclReplacer.$(OBJEXT): SynTree/$(am__dirstamp) \
    972         SynTree/$(DEPDIR)/$(am__dirstamp)
    973 SynTree/DeclStmt.$(OBJEXT): SynTree/$(am__dirstamp) \
    974         SynTree/$(DEPDIR)/$(am__dirstamp)
    975 SynTree/Declaration.$(OBJEXT): SynTree/$(am__dirstamp) \
    976         SynTree/$(DEPDIR)/$(am__dirstamp)
    977 SynTree/DeclarationWithType.$(OBJEXT): SynTree/$(am__dirstamp) \
    978         SynTree/$(DEPDIR)/$(am__dirstamp)
    979 SynTree/Expression.$(OBJEXT): SynTree/$(am__dirstamp) \
    980         SynTree/$(DEPDIR)/$(am__dirstamp)
    981 SynTree/FunctionDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
    982         SynTree/$(DEPDIR)/$(am__dirstamp)
    983 SynTree/FunctionType.$(OBJEXT): SynTree/$(am__dirstamp) \
    984         SynTree/$(DEPDIR)/$(am__dirstamp)
    985 SynTree/Initializer.$(OBJEXT): SynTree/$(am__dirstamp) \
    986         SynTree/$(DEPDIR)/$(am__dirstamp)
    987 SynTree/LinkageSpec.$(OBJEXT): SynTree/$(am__dirstamp) \
    988         SynTree/$(DEPDIR)/$(am__dirstamp)
    989 SynTree/NamedTypeDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
    990         SynTree/$(DEPDIR)/$(am__dirstamp)
    991 SynTree/ObjectDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
    992         SynTree/$(DEPDIR)/$(am__dirstamp)
    993 SynTree/PointerType.$(OBJEXT): SynTree/$(am__dirstamp) \
    994         SynTree/$(DEPDIR)/$(am__dirstamp)
    995 SynTree/ReferenceToType.$(OBJEXT): SynTree/$(am__dirstamp) \
    996         SynTree/$(DEPDIR)/$(am__dirstamp)
    997 SynTree/ReferenceType.$(OBJEXT): SynTree/$(am__dirstamp) \
    998         SynTree/$(DEPDIR)/$(am__dirstamp)
    999 SynTree/Statement.$(OBJEXT): SynTree/$(am__dirstamp) \
    1000         SynTree/$(DEPDIR)/$(am__dirstamp)
    1001 SynTree/TupleExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
    1002         SynTree/$(DEPDIR)/$(am__dirstamp)
    1003 SynTree/TupleType.$(OBJEXT): SynTree/$(am__dirstamp) \
    1004         SynTree/$(DEPDIR)/$(am__dirstamp)
    1005 SynTree/Type.$(OBJEXT): SynTree/$(am__dirstamp) \
    1006         SynTree/$(DEPDIR)/$(am__dirstamp)
    1007 SynTree/TypeDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
    1008         SynTree/$(DEPDIR)/$(am__dirstamp)
    1009 SynTree/TypeExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
    1010         SynTree/$(DEPDIR)/$(am__dirstamp)
    1011 SynTree/TypeSubstitution.$(OBJEXT): SynTree/$(am__dirstamp) \
    1012         SynTree/$(DEPDIR)/$(am__dirstamp)
    1013 SynTree/TypeofType.$(OBJEXT): SynTree/$(am__dirstamp) \
    1014         SynTree/$(DEPDIR)/$(am__dirstamp)
    1015 SynTree/VarArgsType.$(OBJEXT): SynTree/$(am__dirstamp) \
    1016         SynTree/$(DEPDIR)/$(am__dirstamp)
    1017 SynTree/VoidType.$(OBJEXT): SynTree/$(am__dirstamp) \
    1018         SynTree/$(DEPDIR)/$(am__dirstamp)
    1019 SynTree/ZeroOneType.$(OBJEXT): SynTree/$(am__dirstamp) \
    10201026        SynTree/$(DEPDIR)/$(am__dirstamp)
    10211027Tuples/$(am__dirstamp):
    … …  
    11341140InitTweak/FixGlobalInit.$(OBJEXT): InitTweak/$(am__dirstamp) \
    11351141        InitTweak/$(DEPDIR)/$(am__dirstamp)
    1136 Parser/$(am__dirstamp):
    1137         @$(MKDIR_P) Parser
    1138         @: > Parser/$(am__dirstamp)
    1139 Parser/$(DEPDIR)/$(am__dirstamp):
    1140         @$(MKDIR_P) Parser/$(DEPDIR)
    1141         @: > Parser/$(DEPDIR)/$(am__dirstamp)
     1142Parser/parser.hh: Parser/parser.cc
     1143        @if test ! -f $@; then rm -f Parser/parser.cc; else :; fi
     1144        @if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) Parser/parser.cc; else :; fi
     1145Parser/parser.$(OBJEXT): Parser/$(am__dirstamp) \
     1146        Parser/$(DEPDIR)/$(am__dirstamp)
     1147Parser/lex.$(OBJEXT): Parser/$(am__dirstamp) \
     1148        Parser/$(DEPDIR)/$(am__dirstamp)
     1149Parser/TypedefTable.$(OBJEXT): Parser/$(am__dirstamp) \
     1150        Parser/$(DEPDIR)/$(am__dirstamp)
     1151Parser/ParseNode.$(OBJEXT): Parser/$(am__dirstamp) \
     1152        Parser/$(DEPDIR)/$(am__dirstamp)
    11421153Parser/DeclarationNode.$(OBJEXT): Parser/$(am__dirstamp) \
    11431154        Parser/$(DEPDIR)/$(am__dirstamp)
    11441155Parser/ExpressionNode.$(OBJEXT): Parser/$(am__dirstamp) \
    11451156        Parser/$(DEPDIR)/$(am__dirstamp)
     1157Parser/StatementNode.$(OBJEXT): Parser/$(am__dirstamp) \
     1158        Parser/$(DEPDIR)/$(am__dirstamp)
    11461159Parser/InitializerNode.$(OBJEXT): Parser/$(am__dirstamp) \
    11471160        Parser/$(DEPDIR)/$(am__dirstamp)
    1148 Parser/ParseNode.$(OBJEXT): Parser/$(am__dirstamp) \
    1149         Parser/$(DEPDIR)/$(am__dirstamp)
    1150 Parser/StatementNode.$(OBJEXT): Parser/$(am__dirstamp) \
    1151         Parser/$(DEPDIR)/$(am__dirstamp)
    11521161Parser/TypeData.$(OBJEXT): Parser/$(am__dirstamp) \
    1153         Parser/$(DEPDIR)/$(am__dirstamp)
    1154 Parser/TypedefTable.$(OBJEXT): Parser/$(am__dirstamp) \
    1155         Parser/$(DEPDIR)/$(am__dirstamp)
    1156 Parser/lex.$(OBJEXT): Parser/$(am__dirstamp) \
    1157         Parser/$(DEPDIR)/$(am__dirstamp)
    1158 Parser/parser.hh: Parser/parser.cc
    1159         @if test ! -f $@; then rm -f Parser/parser.cc; else :; fi
    1160         @if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) Parser/parser.cc; else :; fi
    1161 Parser/parser.$(OBJEXT): Parser/$(am__dirstamp) \
    11621162        Parser/$(DEPDIR)/$(am__dirstamp)
    11631163Parser/parserutility.$(OBJEXT): Parser/$(am__dirstamp) \
    … …  
    12701270@AMDEP_TRUE@@am__include@ @am__quote@Parser/$(DEPDIR)/ExpressionNode.Po@am__quote@
    12711271@AMDEP_TRUE@@am__include@ @am__quote@Parser/$(DEPDIR)/InitializerNode.Po@am__quote@
     1272@AMDEP_TRUE@@am__include@ @am__quote@Parser/$(DEPDIR)/LinkageSpec.Po@am__quote@
    12721273@AMDEP_TRUE@@am__include@ @am__quote@Parser/$(DEPDIR)/ParseNode.Po@am__quote@
    12731274@AMDEP_TRUE@@am__include@ @am__quote@Parser/$(DEPDIR)/StatementNode.Po@am__quote@
    … …  
    13281329@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/FunctionType.Po@am__quote@
    13291330@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/Initializer.Po@am__quote@
    1330 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/LinkageSpec.Po@am__quote@
    13311331@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/NamedTypeDecl.Po@am__quote@
    13321332@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/ObjectDecl.Po@am__quote@

  • src/Parser/DeclarationNode.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Dec 16 15:32:22 2019
    13 // Update Count     : 1133
     12// Last Modified On : Wed Dec 11 07:40:14 2019
     13// Update Count     : 1123
    1414//
    1515
    … …  
    2424#include "Common/UniqueName.h"     // for UniqueName
    2525#include "Common/utility.h"        // for maybeClone, maybeBuild, CodeLocation
     26#include "Parser/LinkageSpec.h"    // for Spec, linkageName, Cforall
    2627#include "Parser/ParseNode.h"      // for DeclarationNode, ExpressionNode
    27 #include "SynTree/LinkageSpec.h"   // for Spec, linkageName, Cforall
    2828#include "SynTree/Attribute.h"     // for Attribute
    2929#include "SynTree/Declaration.h"   // for TypeDecl, ObjectDecl, Declaration
    … …  
    4747const char * DeclarationNode::signednessNames[] = { "signed", "unsigned", "NoSignednessNames" };
    4848const char * DeclarationNode::lengthNames[] = { "short", "long", "long long", "NoLengthNames" };
     49const char * DeclarationNode::typeClassNames[] = { "otype", "dtype", "ftype", "NoTypeClassNames" };
    4950const char * DeclarationNode::builtinTypeNames[] = { "__builtin_va_list", "__auto_type", "zero_t", "one_t", "NoBuiltinTypeNames" };
    5051
    … …  
    5758
    5859//      variable.name = nullptr;
    59         variable.tyClass = TypeDecl::NUMBER_OF_KINDS;
     60        variable.tyClass = NoTypeClass;
    6061        variable.assertions = nullptr;
    6162        variable.initializer = nullptr;
    … …  
    133134
    134135        if ( linkage != LinkageSpec::Cforall ) {
    135                 os << LinkageSpec::name( linkage ) << " ";
     136                os << LinkageSpec::linkageName( linkage ) << " ";
    136137        } // if
    137138
    … …  
    311312} // DeclarationNode::newFromTypeGen
    312313
    313 DeclarationNode * DeclarationNode::newTypeParam( TypeDecl::Kind tc, const string * name ) {
     314DeclarationNode * DeclarationNode::newTypeParam( TypeClass tc, const string * name ) {
    314315        DeclarationNode * newnode = new DeclarationNode;
    315316        newnode->type = nullptr;
    … …  
    669670
    670671DeclarationNode * DeclarationNode::addAssertions( DeclarationNode * assertions ) {
    671         if ( variable.tyClass != TypeDecl::NUMBER_OF_KINDS ) {
     672        if ( variable.tyClass != NoTypeClass ) {
    672673                if ( variable.assertions ) {
    673674                        variable.assertions->appendList( assertions );
    … …  
    874875
    875876DeclarationNode * DeclarationNode::addTypeInitializer( DeclarationNode * init ) {
    876         assertf( variable.tyClass != TypeDecl::NUMBER_OF_KINDS, "Called addTypeInitializer on something that isn't a type variable." );
     877        assertf( variable.tyClass != NoTypeClass, "Called addTypeInitializer on something that isn't a type variable." );
    877878        variable.initializer = init;
    878879        return this;
    … …  
    10731074        } // if
    10741075
    1075         if ( variable.tyClass != TypeDecl::NUMBER_OF_KINDS ) {
     1076        if ( variable.tyClass != NoTypeClass ) {
    10761077                // otype is internally converted to dtype + otype parameters
    10771078                static const TypeDecl::Kind kindMap[] = { TypeDecl::Dtype, TypeDecl::Dtype, TypeDecl::Ftype, TypeDecl::Ttype };
    1078                 static_assert( sizeof(kindMap)/sizeof(kindMap[0]) == TypeDecl::NUMBER_OF_KINDS, "DeclarationNode::build: kindMap is out of sync." );
     1079                assertf( sizeof(kindMap)/sizeof(kindMap[0]) == NoTypeClass, "DeclarationNode::build: kindMap is out of sync." );
    10791080                assertf( variable.tyClass < sizeof(kindMap)/sizeof(kindMap[0]), "Variable's tyClass is out of bounds." );
    1080                 TypeDecl * ret = new TypeDecl( *name, Type::StorageClasses(), nullptr, kindMap[ variable.tyClass ], variable.tyClass == TypeDecl::Otype, variable.initializer ? variable.initializer->buildType() : nullptr );
     1081                TypeDecl * ret = new TypeDecl( *name, Type::StorageClasses(), nullptr, kindMap[ variable.tyClass ], variable.tyClass == Otype, variable.initializer ? variable.initializer->buildType() : nullptr );
    10811082                buildList( variable.assertions, ret->get_assertions() );
    10821083                return ret;

  • src/Parser/ExpressionNode.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Dec 18 21:14:58 2019
    13 // Update Count     : 981
     12// Last Modified On : Tue Dec 10 23:01:47 2019
     13// Update Count     : 980
    1414//
    1515
    … …  
    265265        static const BasicType::Kind kind[2][12] = {
    266266                { BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::uuFloat80, BasicType::uuFloat128, BasicType::uFloat16, BasicType::uFloat32, BasicType::uFloat32x, BasicType::uFloat64, BasicType::uFloat64x, BasicType::uFloat128, BasicType::uFloat128x },
    267                 { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::NUMBER_OF_BASIC_TYPES, BasicType::NUMBER_OF_BASIC_TYPES, BasicType::uFloat16Complex, BasicType::uFloat32Complex, BasicType::uFloat32xComplex, BasicType::uFloat64Complex, BasicType::uFloat64xComplex, BasicType::uFloat128Complex, BasicType::uFloat128xComplex },
     267                { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, (BasicType::Kind)-1, (BasicType::Kind)-1, BasicType::uFloat16Complex, BasicType::uFloat32Complex, BasicType::uFloat32xComplex, BasicType::uFloat64Complex, BasicType::uFloat64xComplex, BasicType::uFloat128Complex, BasicType::uFloat128xComplex },
    268268        };
    269269
    … …  
    374374
    375375Expression * build_field_name_FLOATING_DECIMALconstant( const string & str ) {
    376         if ( str[str.size() - 1] != '.' ) SemanticError( yylloc, "invalid tuple index " + str );
     376        if ( str[str.size()-1] != '.' ) SemanticError( yylloc, "invalid tuple index " + str );
    377377        Expression * ret = build_constantInteger( *new string( str.substr( 0, str.size()-1 ) ) );
    378378        delete &str;

  • src/Parser/ParseNode.h

    rb7d6a36 rdca5802  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Feb  7 17:56:02 2020
    13 // Update Count     : 891
     12// Last Modified On : Wed Dec 11 07:40:07 2019
     13// Update Count     : 882
    1414//
    1515
    … …  
    2828#include "Common/UniqueName.h"     // for UniqueName
    2929#include "Common/utility.h"        // for maybeClone, maybeBuild
    30 #include "SynTree/LinkageSpec.h"   // for Spec
     30#include "Parser/LinkageSpec.h"    // for Spec
    3131#include "SynTree/Declaration.h"   // for Aggregate
    3232#include "SynTree/Expression.h"    // for Expression, ConstantExpr (ptr only)
    … …  
    218218        enum Length { Short, Long, LongLong, NoLength };
    219219        static const char * lengthNames[];
     220        enum TypeClass { Otype, Dtype, Ftype, Ttype, NoTypeClass };
     221        static const char * typeClassNames[];
    220222        enum BuiltinType { Valist, AutoType, Zero, One, NoBuiltinType };
    221223        static const char * builtinTypeNames[];
    … …  
    239241        static DeclarationNode * newName( const std::string * );
    240242        static DeclarationNode * newFromTypeGen( const std::string *, ExpressionNode * params );
    241         static DeclarationNode * newTypeParam( TypeDecl::Kind, const std::string * );
     243        static DeclarationNode * newTypeParam( TypeClass, const std::string * );
    242244        static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
    243245        static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
    … …  
    309311        struct Variable_t {
    310312//              const std::string * name;
    311                 TypeDecl::Kind tyClass;
     313                DeclarationNode::TypeClass tyClass;
    312314                DeclarationNode * assertions;
    313315                DeclarationNode * initializer;
    … …  
    449451                                * out++ = result;
    450452                        } else {
    451                                 SemanticError( cur->location, "type specifier declaration in forall clause is currently unimplemented." );
     453                                assertf(false, "buildList unknown type");
    452454                        } // if
    453455                } catch( SemanticErrorException & e ) {

  • src/Parser/ParserTypes.h

    rb7d6a36 rdca5802  
    1010// Created On       : Sat Sep 22 08:58:10 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Feb 15 11:04:40 2020
    13 // Update Count     : 351
     12// Last Modified On : Sat Jul 22 09:33:28 2017
     13// Update Count     : 350
    1414//
    1515
    … …  
    2727// current location in the input
    2828extern int yylineno;
    29 extern char * yyfilename;
     29extern char *yyfilename;
    3030
    3131struct Location {
    32     char * file;
     32    char *file;
    3333    int line;
    3434}; // Location
    3535
    3636struct Token {
    37     std::string * str;                                                                  // must be pointer as used in union
     37    std::string *str;                                                                   // must be pointer as used in union
    3838    Location loc;
    3939

  • src/Parser/TypeData.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Dec 16 07:56:46 2019
    13 // Update Count     : 662
     12// Last Modified On : Wed Dec 11 07:48:33 2019
     13// Update Count     : 659
    1414//
    1515
    … …  
    489489        for ( typename ForallList::iterator i = outputList.begin(); i != outputList.end(); ++i, n = (DeclarationNode*)n->get_next() ) {
    490490                TypeDecl * td = static_cast<TypeDecl *>(*i);
    491                 if ( n->variable.tyClass == TypeDecl::Otype ) {
     491                if ( n->variable.tyClass == DeclarationNode::Otype ) {
    492492                        // add assertion parameters to `type' tyvars in reverse order
    493493                        // add dtor:  void ^?{}(T *)
    … …  
    522522        switch ( td->kind ) {
    523523          case TypeData::Unknown:
    524                 // fill in implicit int
    525                 return new BasicType( buildQualifiers( td ), BasicType::SignedInt );
     524                        // fill in implicit int
     525                        return new BasicType( buildQualifiers( td ), BasicType::SignedInt );
    526526          case TypeData::Basic:
    527                 return buildBasicType( td );
     527                        return buildBasicType( td );
    528528          case TypeData::Pointer:
    529                 return buildPointer( td );
     529                        return buildPointer( td );
    530530          case TypeData::Array:
    531                 return buildArray( td );
     531                        return buildArray( td );
    532532          case TypeData::Reference:
    533                 return buildReference( td );
     533                        return buildReference( td );
    534534          case TypeData::Function:
    535                 return buildFunction( td );
     535                        return buildFunction( td );
    536536          case TypeData::AggregateInst:
    537                 return buildAggInst( td );
     537                        return buildAggInst( td );
    538538          case TypeData::EnumConstant:
    539                 // the name gets filled in later -- by SymTab::Validate
    540                 return new EnumInstType( buildQualifiers( td ), "" );
     539                        // the name gets filled in later -- by SymTab::Validate
     540                        return new EnumInstType( buildQualifiers( td ), "" );
    541541          case TypeData::SymbolicInst:
    542                 return buildSymbolicInst( td );
     542                        return buildSymbolicInst( td );
    543543          case TypeData::Tuple:
    544                 return buildTuple( td );
     544                        return buildTuple( td );
    545545          case TypeData::Typeof:
    546546          case TypeData::Basetypeof:
    547                 return buildTypeof( td );
     547                        return buildTypeof( td );
    548548          case TypeData::Builtin:
    549                 switch ( td->builtintype ) {
    550                   case DeclarationNode::Zero:
    551                         return new ZeroType( noQualifiers );
    552                   case DeclarationNode::One:
    553                         return new OneType( noQualifiers );
    554                   default:
    555                         return new VarArgsType( buildQualifiers( td ) );
    556                 } // switch
     549                        if (td->builtintype == DeclarationNode::Zero) {
     550                                return new ZeroType( noQualifiers );
     551                        }
     552                        else if (td->builtintype == DeclarationNode::One) {
     553                                return new OneType( noQualifiers );
     554                        }
     555                        else {
     556                                return new VarArgsType( buildQualifiers( td ) );
     557                        }
    557558          case TypeData::GlobalScope:
    558                 return new GlobalScopeType();
    559           case TypeData::Qualified:
    560                 return new QualifiedType( buildQualifiers( td ), typebuild( td->qualified.parent ), typebuild( td->qualified.child ) );
     559                        return new GlobalScopeType();
     560                case TypeData::Qualified:
     561                        return new QualifiedType( buildQualifiers( td ), typebuild( td->qualified.parent ), typebuild( td->qualified.child ) );
    561562          case TypeData::Symbolic:
    562563          case TypeData::Enum:
    563564          case TypeData::Aggregate:
    564                 assert( false );
     565                        assert( false );
    565566        } // switch
    566567

  • src/Parser/TypeData.h

    rb7d6a36 rdca5802  
    1010// Created On       : Sat May 16 15:18:36 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec 13 23:42:35 2019
    13 // Update Count     : 199
     12// Last Modified On : Tue Dec 10 23:01:07 2019
     13// Update Count     : 198
    1414//
    1515
    … …  
    2121
    2222#include "ParseNode.h"           // for DeclarationNode, DeclarationNode::Ag...
    23 #include "SynTree/LinkageSpec.h" // for Spec
     23#include "Parser/LinkageSpec.h" // for Spec
    2424#include "SynTree/Type.h"        // for Type, ReferenceToType (ptr only)
    2525#include "SynTree/SynTree.h"     // for Visitor Nodes

  • src/Parser/TypedefTable.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Sat May 16 15:20:13 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Feb 15 08:06:36 2020
    13 // Update Count     : 259
     12// Last Modified On : Wed Jul 25 15:32:35 2018
     13// Update Count     : 258
    1414//
    1515
    … …  
    4747} // TypedefTable::~TypedefTable
    4848
    49 bool TypedefTable::exists( const string & identifier ) const {
     49bool TypedefTable::exists( const string & identifier ) {
    5050        return kindTable.find( identifier ) != kindTable.end();
    5151} // TypedefTable::exists
    5252
    53 bool TypedefTable::existsCurr( const string & identifier ) const {
     53bool TypedefTable::existsCurr( const string & identifier ) {
    5454        return kindTable.findAt( kindTable.currentScope() - 1, identifier ) != kindTable.end();
    5555} // TypedefTable::exists

  • src/Parser/TypedefTable.h

    rb7d6a36 rdca5802  
    1010// Created On       : Sat May 16 15:24:36 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Feb 15 08:06:37 2020
    13 // Update Count     : 117
     12// Last Modified On : Wed Jul 25 15:33:55 2018
     13// Update Count     : 114
    1414//
    1515
    … …  
    3030        ~TypedefTable();
    3131
    32         bool exists( const std::string & identifier ) const;
    33         bool existsCurr( const std::string & identifier ) const;
     32        bool exists( const std::string & identifier );
     33        bool existsCurr( const std::string & identifier );
    3434        int isKind( const std::string & identifier ) const;
    3535        void makeTypedef( const std::string & name, int kind = TYPEDEFname );

  • src/Parser/lex.ll

    rb7d6a36 rdca5802  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Sat Feb 15 11:05:50 2020
    13  * Update Count     : 737
     12 * Last Modified On : Sun Aug  4 20:53:47 2019
     13 * Update Count     : 719
    1414 */
    1515
    … …  
    4242#include "ParseNode.h"
    4343#include "TypedefTable.h"
    44 
    45 string * build_postfix_name( string * name );
    4644
    4745char *yyfilename;
    … …  
    332330                                /* identifier */
    333331{identifier}    { IDENTIFIER_RETURN(); }
    334 "``"{identifier} {                                                                              // CFA
    335         yytext[yyleng] = '\0'; yytext += 2;                                     // SKULLDUGGERY: remove backquotes (ok to shorten?)
     332"`"{identifier}"`" {                                                                    // CFA
     333        yytext[yyleng - 1] = '\0'; yytext += 1;                         // SKULLDUGGERY: remove backquotes (ok to shorten?)
    336334        IDENTIFIER_RETURN();
    337335}
    … …  
    434432"?"({op_unary_pre_post}|"()"|"[?]"|"{}") { IDENTIFIER_RETURN(); }
    435433"^?{}"                  { IDENTIFIER_RETURN(); }
    436 "?`"{identifier} {                                                                              // postfix operator
    437         yylval.tok.str = new string( &yytext[2] );                      // remove ?`
    438         yylval.tok.str = build_postfix_name( yylval.tok.str ); // add prefix
    439         RETURN_LOCN( typedefTable.isKind( *yylval.tok.str ) );
    440 }
     434"?`"{identifier} { IDENTIFIER_RETURN(); }                               // postfix operator
    441435"?"{op_binary_over}"?"  { IDENTIFIER_RETURN(); }                // binary
    442436        /*

  • src/Parser/module.mk

    rb7d6a36 rdca5802  
    1111## Created On       : Sat May 16 15:29:09 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Sat Dec 14 07:34:47 2019
    14 ## Update Count     : 107
     13## Last Modified On : Wed Jun 28 21:58:29 2017
     14## Update Count     : 104
    1515###############################################################################
    1616
    … …  
    1919AM_YFLAGS = -d -t -v
    2020
    21 SRC += \
     21SRC += Parser/parser.yy \
     22       Parser/lex.ll \
     23       Parser/TypedefTable.cc \
     24       Parser/ParseNode.cc \
    2225       Parser/DeclarationNode.cc \
    2326       Parser/ExpressionNode.cc \
     27       Parser/StatementNode.cc \
    2428       Parser/InitializerNode.cc \
    25        Parser/ParseNode.cc \
    26        Parser/StatementNode.cc \
    2729       Parser/TypeData.cc \
    28        Parser/TypedefTable.cc \
    29        Parser/lex.ll \
    30        Parser/parser.yy \
     30       Parser/LinkageSpec.cc \
    3131       Parser/parserutility.cc
    3232
     33SRCDEMANGLE += \
     34        Parser/LinkageSpec.cc
     35
     36
    3337MOSTLYCLEANFILES += Parser/lex.cc Parser/parser.cc Parser/parser.hh Parser/parser.output

  • src/Parser/parser.yy

    rb7d6a36 rdca5802  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Feb 16 08:22:14 2020
    13 // Update Count     : 4461
     12// Last Modified On : Tue Dec 10 23:07:17 2019
     13// Update Count     : 4400
    1414//
    1515
    … …  
    5555#include "TypedefTable.h"
    5656#include "TypeData.h"
    57 #include "SynTree/LinkageSpec.h"
     57#include "LinkageSpec.h"
    5858#include "Common/SemanticError.h"                                               // error_str
    5959#include "Common/utility.h"                                                             // for maybeMoveBuild, maybeBuild, CodeLo...
    … …  
    166166} // rebindForall
    167167
    168 string * build_postfix_name( string * name ) {
    169         *name = string("__postfix_func_") + *name;
    170         return name;
     168NameExpr * build_postfix_name( const string * name ) {
     169        NameExpr * new_name = build_varref( new string( "?`" + *name ) );
     170        delete name;
     171        return new_name;
    171172} // build_postfix_name
    172173
    … …  
    237238        DeclarationNode * decl;
    238239        AggregateDecl::Aggregate aggKey;
    239         TypeDecl::Kind tclass;
     240        DeclarationNode::TypeClass tclass;
    240241        StatementNode * sn;
    241242        WaitForStmt * wfs;
    … …  
    322323%type<op> ptrref_operator                               unary_operator                          assignment_operator
    323324%type<en> primary_expression                    postfix_expression                      unary_expression
    324 %type<en> cast_expression_list                  cast_expression                         exponential_expression          multiplicative_expression       additive_expression
     325%type<en> cast_expression                               exponential_expression          multiplicative_expression       additive_expression
    325326%type<en> shift_expression                              relational_expression           equality_expression
    326327%type<en> AND_expression                                exclusive_OR_expression         inclusive_OR_expression
    … …  
    578579        | '(' compound_statement ')'                                            // GCC, lambda expression
    579580                { $$ = new ExpressionNode( new StmtExpr( dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >($2) ) ) ); }
     581        | constant '`' IDENTIFIER                                                       // CFA, postfix call
     582                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $3 ) ), $1 ) ); }
     583        | string_literal '`' IDENTIFIER                                         // CFA, postfix call
     584                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $3 ) ), new ExpressionNode( $1 ) ) ); }
     585        | IDENTIFIER '`' IDENTIFIER                                                     // CFA, postfix call
     586                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $3 ) ), new ExpressionNode( build_varref( $1 ) ) ) ); }
     587        | tuple '`' IDENTIFIER                                                          // CFA, postfix call
     588                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $3 ) ), $1 ) ); }
     589        | '(' comma_expression ')' '`' IDENTIFIER                       // CFA, postfix call
     590                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $5 ) ), $2 ) ); }
    580591        | type_name '.' identifier                                                      // CFA, nested type
    581592                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
    … …  
    631642        | postfix_expression '(' argument_expression_list ')'
    632643                { $$ = new ExpressionNode( build_func( $1, $3 ) ); }
    633         | postfix_expression '`' identifier                                     // CFA, postfix call
    634                 { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( build_postfix_name( $3 ) ) ), $1 ) ); }
    635         | constant '`' identifier                                                       // CFA, postfix call
    636                 { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( build_postfix_name( $3 ) ) ), $1 ) ); }
    637         | string_literal '`' identifier                                         // CFA, postfix call
    638                 { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( build_postfix_name( $3 ) ) ), new ExpressionNode( $1 ) ) ); }
    639644        | postfix_expression '.' identifier
    640645                { $$ = new ExpressionNode( build_fieldSel( $1, build_varref( $3 ) ) ); }
    … …  
    661666        | '(' type_no_function ')' '@' '{' initializer_list_opt comma_opt '}' // CFA, explicit C compound-literal
    662667                { $$ = new ExpressionNode( build_compoundLiteral( $2, (new InitializerNode( $6, true ))->set_maybeConstructed( false ) ) ); }
    663         | '^' primary_expression '{' argument_expression_list '}' // CFA, destructor call
     668        | '^' primary_expression '{' argument_expression_list '}' // CFA
    664669                {
    665670                        Token fn;
    … …  
    674679        | argument_expression
    675680        | argument_expression_list ',' argument_expression
    676                 { $$ = (ExpressionNode *)($1->set_last( $3 )); }
     681                { $$ = (ExpressionNode *)( $1->set_last( $3 )); }
    677682        ;
    678683
    … …  
    686691field_name_list:                                                                                // CFA, tuple field selector
    687692        field
    688         | field_name_list ',' field                                     { $$ = (ExpressionNode *)($1->set_last( $3 )); }
     693        | field_name_list ',' field                                     { $$ = (ExpressionNode *)$1->set_last( $3 ); }
    689694        ;
    690695
    … …  
    955960                { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $3 ) ) ); }
    956961        | '[' push assignment_expression pop ',' tuple_expression_list ']'
    957                 { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)($3->set_last( $6 ) ) )); }
     962                { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)$3->set_last( $6 ) ) ); }
    958963        ;
    959964
    … …  
    961966        assignment_expression_opt
    962967        | tuple_expression_list ',' assignment_expression_opt
    963                 { $$ = (ExpressionNode *)($1->set_last( $3 )); }
     968                { $$ = (ExpressionNode *)$1->set_last( $3 ); }
    964969        ;
    965970
    … …  
    11851190                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
    11861191                                                OperKinds::LThan, $1->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
    1187         | '=' comma_expression                                                                  // CFA
    1188                 { $$ = forCtrl( $2, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
    1189                                                 OperKinds::LEThan, $2->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
    11901192        | comma_expression inclexcl comma_expression            // CFA
    11911193                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
    … …  
    11951197                { $$ = forCtrl( $3, $1, new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
    11961198                                                OperKinds::LThan, $3->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
    1197         | comma_expression ';' '=' comma_expression                             // CFA
    1198                 { $$ = forCtrl( $4, $1, new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
    1199                                                 OperKinds::LEThan, $4->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
    12001199        | comma_expression ';' comma_expression inclexcl comma_expression // CFA
    12011200                { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
    … …  
    13021301        WAITFOR '(' cast_expression ')'
    13031302                { $$ = $3; }
    1304 //      | WAITFOR '(' cast_expression ',' argument_expression_list ')'
    1305 //              { $$ = (ExpressionNode *)$3->set_last( $5 ); }
    1306         | WAITFOR '(' cast_expression_list ':' argument_expression_list ')'
    1307                 { $$ = (ExpressionNode *)($3->set_last( $5 )); }
    1308         ;
    1309 
    1310 cast_expression_list:
    1311         cast_expression
    1312         | cast_expression_list ',' cast_expression
    1313                 { $$ = (ExpressionNode *)($1->set_last( $3 )); }
     1303        | WAITFOR '(' cast_expression ',' argument_expression_list ')'
     1304                { $$ = (ExpressionNode *)$3->set_last( $5 ); }
    13141305        ;
    13151306
    … …  
    14221413        asm_operand
    14231414        | asm_operands_list ',' asm_operand
    1424                 { $$ = (ExpressionNode *)($1->set_last( $3 )); }
     1415                { $$ = (ExpressionNode *)$1->set_last( $3 ); }
    14251416        ;
    14261417
    … …  
    14381429                { $$ = new ExpressionNode( $1 ); }
    14391430        | asm_clobbers_list_opt ',' string_literal
    1440                 { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( $3 ) )); }
     1431                // set_last returns ParseNode *
     1432                { $$ = (ExpressionNode *)$1->set_last( new ExpressionNode( $3 ) ); }
    14411433        ;
    14421434
    … …  
    23612353        | initializer_list_opt ',' initializer          { $$ = (InitializerNode *)( $1->set_last( $3 ) ); }
    23622354        | initializer_list_opt ',' designation initializer
    2363                 { $$ = (InitializerNode *)($1->set_last( $4->set_designators( $3 ) )); }
     2355                { $$ = (InitializerNode *)( $1->set_last( $4->set_designators( $3 ) ) ); }
    23642356        ;
    23652357
    … …  
    23832375        designator
    23842376        | designator_list designator
    2385                 { $$ = (ExpressionNode *)($1->set_last( $2 )); }
     2377                { $$ = (ExpressionNode *)( $1->set_last( $2 ) ); }
    23862378        //| designator_list designator                                          { $$ = new ExpressionNode( $1, $2 ); }
    23872379        ;
    … …  
    24392431        | type_specifier identifier_parameter_declarator
    24402432        | assertion_list
    2441                 { $$ = DeclarationNode::newTypeParam( TypeDecl::Dtype, new string( DeclarationNode::anonymous.newName() ) )->addAssertions( $1 ); }
     2433                { $$ = DeclarationNode::newTypeParam( DeclarationNode::Dtype, new string( DeclarationNode::anonymous.newName() ) )->addAssertions( $1 ); }
    24422434        ;
    24432435
    24442436type_class:                                                                                             // CFA
    24452437        OTYPE
    2446                 { $$ = TypeDecl::Otype; }
     2438                { $$ = DeclarationNode::Otype; }
    24472439        | DTYPE
    2448                 { $$ = TypeDecl::Dtype; }
     2440                { $$ = DeclarationNode::Dtype; }
    24492441        | FTYPE
    2450                 { $$ = TypeDecl::Ftype; }
     2442                { $$ = DeclarationNode::Ftype; }
    24512443        | TTYPE
    2452                 { $$ = TypeDecl::Ttype; }
     2444                { $$ = DeclarationNode::Ttype; }
    24532445        ;
    24542446
    … …  
    24802472                { SemanticError( yylloc, toString("Expression generic parameters are currently unimplemented: ", $1->build()) ); $$ = nullptr; }
    24812473        | type_list ',' type
    2482                 { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ) )); }
     2474                { $$ = (ExpressionNode *)( $1->set_last( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ) ) ); }
    24832475        | type_list ',' assignment_expression
    24842476                { SemanticError( yylloc, toString("Expression generic parameters are currently unimplemented: ", $3->build()) ); $$ = nullptr; }
    … …  
    25912583                {
    25922584                        linkageStack.push( linkage );                           // handle nested extern "C"/"Cforall"
    2593                         linkage = LinkageSpec::update( yylloc, linkage, $2 );
     2585                        linkage = LinkageSpec::linkageUpdate( yylloc, linkage, $2 );
    25942586                }
    25952587          '{' up external_definition_list_opt down '}'

  • src/ResolvExpr/AdjustExprType.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Sat May 16 23:41:42 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Dec 11 21:43:56 2019
    13 // Update Count     : 6
     12// Last Modified On : Wed Mar  2 17:34:53 2016
     13// Update Count     : 4
    1414//
    1515
    … …  
    133133                        // replace known function-type-variables with pointer-to-function
    134134                        if ( const ast::EqvClass * eqvClass = tenv.lookup( inst->name ) ) {
    135                                 if ( eqvClass->data.kind == ast::TypeDecl::Ftype ) {
     135                                if ( eqvClass->data.kind == ast::TypeVar::Ftype ) {
    136136                                        return new ast::PointerType{ inst };
    137137                                }
    138138                        } else if ( const ast::NamedTypeDecl * ntDecl = symtab.lookupType( inst->name ) ) {
    139139                                if ( auto tyDecl = dynamic_cast< const ast::TypeDecl * >( ntDecl ) ) {
    140                                         if ( tyDecl->kind == ast::TypeDecl::Ftype ) {
     140                                        if ( tyDecl->kind == ast::TypeVar::Ftype ) {
    141141                                                return new ast::PointerType{ inst };
    142142                                        }

  • src/ResolvExpr/PtrsCastable.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Sun May 17 11:48:00 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Dec 11 21:48:33 2019
    13 // Update Count     : 9
     12// Last Modified On : Wed Mar  2 17:36:18 2016
     13// Update Count     : 8
    1414//
    1515
    … …  
    176176                        if ( const ast::NamedTypeDecl * named = symtab.lookupType( inst->name ) ) {
    177177                                if ( auto tyDecl = dynamic_cast< const ast::TypeDecl * >( named ) ) {
    178                                         if ( tyDecl->kind == ast::TypeDecl::Ftype ) {
     178                                        if ( tyDecl->kind == ast::TypeVar::Ftype ) {
    179179                                                return -1;
    180180                                        }
    181181                                }
    182182                        } else if ( const ast::EqvClass * eqvClass = env.lookup( inst->name ) ) {
    183                                 if ( eqvClass->data.kind == ast::TypeDecl::Ftype ) {
     183                                if ( eqvClass->data.kind == ast::TypeVar::Ftype ) {
    184184                                        return -1;
    185185                                }

  • src/ResolvExpr/Resolver.cc

    rb7d6a36 rdca5802  
    8484                void previsit( ThrowStmt * throwStmt );
    8585                void previsit( CatchStmt * catchStmt );
    86                 void postvisit( CatchStmt * catchStmt );
    8786                void previsit( WaitForStmt * stmt );
    8887
    … …  
    568567
    569568        void Resolver_old::previsit( CatchStmt * catchStmt ) {
    570                 // Until we are very sure this invarent (ifs that move between passes have thenPart)
    571                 // holds, check it. This allows a check for when to decode the mangling.
    572                 if ( IfStmt * ifStmt = dynamic_cast<IfStmt *>( catchStmt->body ) ) {
    573                         assert( ifStmt->thenPart );
    574                 }
    575                 // Encode the catchStmt so the condition can see the declaration.
    576569                if ( catchStmt->cond ) {
    577                         IfStmt * ifStmt = new IfStmt( catchStmt->cond, nullptr, catchStmt->body );
    578                         catchStmt->cond = nullptr;
    579                         catchStmt->body = ifStmt;
    580                 }
    581         }
    582 
    583         void Resolver_old::postvisit( CatchStmt * catchStmt ) {
    584                 // Decode the catchStmt so everything is stored properly.
    585                 IfStmt * ifStmt = dynamic_cast<IfStmt *>( catchStmt->body );
    586                 if ( nullptr != ifStmt && nullptr == ifStmt->thenPart ) {
    587                         assert( ifStmt->condition );
    588                         assert( ifStmt->elsePart );
    589                         catchStmt->cond = ifStmt->condition;
    590                         catchStmt->body = ifStmt->elsePart;
    591                         ifStmt->condition = nullptr;
    592                         ifStmt->elsePart = nullptr;
    593                         delete ifStmt;
     570                        findSingleExpression( catchStmt->cond, new BasicType( noQualifiers, BasicType::Bool ), indexer );
    594571                }
    595572        }
    … …  
    14891466
    14901467        const ast::CatchStmt * Resolver_new::previsit( const ast::CatchStmt * catchStmt ) {
    1491                 // TODO: This will need a fix for the decl/cond scoping problem.
    14921468                if ( catchStmt->cond ) {
    14931469                        ast::ptr< ast::Type > boolType = new ast::BasicType{ ast::BasicType::Bool };

  • src/ResolvExpr/Unify.cc

    rb7d6a36 rdca5802  
    99// Author           : Richard C. Bilson
    1010// Created On       : Sun May 17 12:27:10 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec 13 23:43:05 2019
    13 // Update Count     : 46
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Wed Sep  4 10:00:00 2019
     13// Update Count     : 44
    1414//
    1515
    … …  
    3232#include "Common/PassVisitor.h"     // for PassVisitor
    3333#include "FindOpenVars.h"           // for findOpenVars
    34 #include "SynTree/LinkageSpec.h"    // for C
     34#include "Parser/LinkageSpec.h"     // for C
    3535#include "SynTree/Constant.h"       // for Constant
    3636#include "SynTree/Declaration.h"    // for TypeDecl, TypeDecl::Data, Declarati...
    … …  
    781781                                if ( const ast::EqvClass * clz = tenv.lookup( typeInst->name ) ) {
    782782                                        // expand ttype parameter into its actual type
    783                                         if ( clz->data.kind == ast::TypeDecl::Ttype && clz->bound ) {
     783                                        if ( clz->data.kind == ast::TypeVar::Ttype && clz->bound ) {
    784784                                                return clz->bound;
    785785                                        }

  • src/SymTab/Autogen.h

    rb7d6a36 rdca5802  
    1010// Created On       : Sun May 17 21:53:34 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec 13 16:38:06 2019
    13 // Update Count     : 16
     12// Last Modified On : Sat Jul 22 09:50:25 2017
     13// Update Count     : 15
    1414//
    1515
    … …  
    3434#include "SynTree/Expression.h"   // for NameExpr, ConstantExpr, UntypedExpr...
    3535#include "SynTree/Type.h"         // for Type, ArrayType, Type::Qualifiers
    36 #include "SynTree/Statement.h"    // for CompoundStmt, DeclStmt, ExprStmt
    3736
    3837class CompoundStmt;

  • src/SymTab/Demangle.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Thu Jul 19 12:52:41 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb 11 15:09:18 2020
    13 // Update Count     : 10
     12// Last Modified On : Tue Jul 30 13:46:33 2019
     13// Update Count     : 3
    1414//
    1515
    … …  
    1919#include "CodeGen/GenType.h"
    2020#include "Common/PassVisitor.h"
    21 #include "Common/utility.h"                                                             // isPrefix
    2221#include "Mangler.h"
    2322#include "SynTree/Type.h"
    … …  
    367366                                // type variable types
    368367                                for (size_t k = 0; k < TypeDecl::NUMBER_OF_KINDS; ++k) {
    369                                         static const std::string typeVariableNames[] = { "DT", "OT", "FT", "TT", };
     368                                        static const std::string typeVariableNames[] = { "DT", "FT", "TT", };
    370369                                        static_assert(
    371370                                                sizeof(typeVariableNames)/sizeof(typeVariableNames[0]) == TypeDecl::NUMBER_OF_KINDS,
    … …  
    417416
    418417                        bool StringView::isPrefix(const std::string & pref) {
    419                                 // if ( pref.size() > str.size()-idx ) return false;
    420                                 // auto its = std::mismatch( pref.begin(), pref.end(), std::next(str.begin(), idx) );
    421                                 // if (its.first == pref.end()) {
    422                                 //      idx += pref.size();
    423                                 //      return true;
    424                                 // }
    425 
    426                                 // This update is untested because there are no tests for this code.
    427                                 if ( ::isPrefix( str, pref, idx ) ) {
     418                                if ( pref.size() > str.size()-idx ) return false;
     419                                auto its = std::mismatch( pref.begin(), pref.end(), std::next(str.begin(), idx) );
     420                                if (its.first == pref.end()) {
    428421                                        idx += pref.size();
    429422                                        return true;
    … …  
    436429                                PRINT( std::cerr << "====== " << str.size() << " " << str << std::endl; )
    437430                                if (str.size() < 2+Encoding::manglePrefix.size()) return false; // +2 for at least _1 suffix
    438                                 if ( ! isPrefix(Encoding::manglePrefix) || ! isdigit(str.back() ) ) return false;
     431                                if (! isPrefix(Encoding::manglePrefix) || ! isdigit(str.back())) return false;
    439432
    440433                                // get name

  • src/SymTab/Indexer.cc

    rb7d6a36 rdca5802  
    99// Author           : Richard C. Bilson
    1010// Created On       : Sun May 17 21:37:33 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec 13 23:43:19 2019
    13 // Update Count     : 22
     11// Last Modified By : Aaron B. Moss
     12// Last Modified On : Fri Mar  8 13:55:00 2019
     13// Update Count     : 21
    1414//
    1515
    … …  
    3131#include "InitTweak/InitTweak.h"   // for isConstructor, isCopyFunction, isC...
    3232#include "Mangler.h"               // for Mangler
     33#include "Parser/LinkageSpec.h"    // for isMangled, isOverridable, Spec
    3334#include "ResolvExpr/typeops.h"    // for typesCompatible
    34 #include "SynTree/LinkageSpec.h"   // for isMangled, isOverridable, Spec
    3535#include "SynTree/Constant.h"      // for Constant
    3636#include "SynTree/Declaration.h"   // for DeclarationWithType, FunctionDecl

  • src/SymTab/Mangler.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Sun May 17 21:40:29 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Feb 15 13:55:12 2020
    13 // Update Count     : 33
     12// Last Modified On : Tue Jul 30 13:46:10 2019
     13// Update Count     : 26
    1414//
    1515#include "Mangler.h"
    … …  
    2626#include "Common/SemanticError.h"        // for SemanticError
    2727#include "Common/utility.h"              // for toString
     28#include "Parser/LinkageSpec.h"          // for Spec, isOverridable, AutoGen, Int...
    2829#include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment
    29 #include "SynTree/LinkageSpec.h"         // for Spec, isOverridable, AutoGen, Int...
    3030#include "SynTree/Declaration.h"         // for TypeDecl, DeclarationWithType
    3131#include "SynTree/Expression.h"          // for TypeExpr, Expression, operator<<
    … …  
    128128                                } // if
    129129                                mangleName << Encoding::manglePrefix;
    130                                 const CodeGen::OperatorInfo * opInfo = CodeGen::operatorLookup( declaration->get_name() );
    131                                 if ( opInfo ) {
    132                                         mangleName << opInfo->outputName.size() << opInfo->outputName;
     130                                CodeGen::OperatorInfo opInfo;
     131                                if ( operatorLookup( declaration->get_name(), opInfo ) ) {
     132                                        mangleName << opInfo.outputName.size() << opInfo.outputName;
    133133                                } else {
    134134                                        mangleName << declaration->name.size() << declaration->name;
    … …  
    471471                        } // if
    472472                        mangleName << Encoding::manglePrefix;
    473                         const CodeGen::OperatorInfo * opInfo = CodeGen::operatorLookup( decl->name );
    474                         if ( opInfo ) {
    475                                 mangleName << opInfo->outputName.size() << opInfo->outputName;
     473                        CodeGen::OperatorInfo opInfo;
     474                        if ( operatorLookup( decl->name, opInfo ) ) {
     475                                mangleName << opInfo.outputName.size() << opInfo.outputName;
    476476                        } else {
    477477                                mangleName << decl->name.size() << decl->name;
    … …  
    654654                        // aside from the assert false.
    655655                        assertf(false, "Mangler_new should not visit typedecl: %s", toCString(decl));
    656                         assertf( decl->kind < ast::TypeDecl::Kind::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->kind );
     656                        assertf( decl->kind < ast::TypeVar::Kind::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->kind );
    657657                        mangleName << Encoding::typeVariables[ decl->kind ] << ( decl->name.length() ) << decl->name;
    658658                }
    … …  
    674674                                        for ( const ast::TypeDecl * decl : ptype->forall ) {
    675675                                                switch ( decl->kind ) {
    676                                                 case ast::TypeDecl::Kind::Dtype:
     676                                                case ast::TypeVar::Kind::Dtype:
    677677                                                        dcount++;
    678678                                                        break;
    679                                                 case ast::TypeDecl::Kind::Ftype:
     679                                                case ast::TypeVar::Kind::Ftype:
    680680                                                        fcount++;
    681681                                                        break;
    682                                                 case ast::TypeDecl::Kind::Ttype:
     682                                                case ast::TypeVar::Kind::Ttype:
    683683                                                        vcount++;
    684684                                                        break;

  • src/SymTab/ManglerCommon.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Sun May 17 21:44:03 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec 13 14:54:38 2019
    13 // Update Count     : 28
     12// Last Modified On : Thu Feb 14 17:06:37 2019
     13// Update Count     : 26
    1414//
    1515
    … …  
    104104                        const std::string typeVariables[] = {
    105105                                "BD", // dtype
    106                                 "BO", // otype
    107106                                "BF", // ftype
    108107                                "BT", // ttype

  • src/SymTab/Validate.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Sun May 17 21:50:04 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec 13 23:43:34 2019
    13 // Update Count     : 363
     12// Last Modified On : Tue Dec 10 22:22:01 2019
     13// Update Count     : 362
    1414//
    1515
    … …  
    6969#include "InitTweak/GenInit.h"         // for fixReturnStatements
    7070#include "InitTweak/InitTweak.h"       // for isCtorDtorAssign
     71#include "Parser/LinkageSpec.h"        // for C
    7172#include "ResolvExpr/typeops.h"        // for typesCompatible
    7273#include "ResolvExpr/Resolver.h"       // for findSingleExpression
    7374#include "ResolvExpr/ResolveTypeof.h"  // for resolveTypeof
    7475#include "SymTab/Autogen.h"            // for SizeType
    75 #include "SynTree/LinkageSpec.h"       // for C
    7676#include "SynTree/Attribute.h"         // for noAttributes, Attribute
    7777#include "SynTree/Constant.h"          // for Constant
    … …  
    311311                        Stats::Heap::newPass("validate-A");
    312312                        Stats::Time::BlockGuard guard("validate-A");
    313                         VerifyCtorDtorAssign::verify( translationUnit );  // must happen before autogen, because autogen examines existing ctor/dtors
    314313                        acceptAll( translationUnit, hoistDecls );
    315314                        ReplaceTypedef::replaceTypedef( translationUnit );
    … …  
    337336                        Stats::Time::BlockGuard guard("validate-C");
    338337                        acceptAll( translationUnit, genericParams );  // check as early as possible - can't happen before LinkReferenceToTypes_old
     338                        VerifyCtorDtorAssign::verify( translationUnit );  // must happen before autogen, because autogen examines existing ctor/dtors
    339339                        ReturnChecker::checkFunctionReturns( translationUnit );
    340340                        InitTweak::fixReturnStatements( translationUnit ); // must happen before autogen
    … …  
    375375                        Stats::Heap::newPass("validate-F");
    376376                        Stats::Time::BlockGuard guard("validate-F");
    377                         Stats::Time::TimeCall("Fix Object Type",
    378                                 FixObjectType::fix, translationUnit);
    379                         Stats::Time::TimeCall("Array Length",
    380                                 ArrayLength::computeLength, translationUnit);
    381                         Stats::Time::TimeCall("Find Special Declarations",
    382                                 Validate::findSpecialDecls, translationUnit);
    383                         Stats::Time::TimeCall("Fix Label Address",
    384                                 mutateAll<LabelAddressFixer>, translationUnit, labelAddrFixer);
    385                         Stats::Time::TimeCall("Handle Attributes",
    386                                 Validate::handleAttributes, translationUnit);
     377                        Stats::Time::TimeBlock("Fix Object Type", [&]() {
     378                                FixObjectType::fix( translationUnit );
     379                        });
     380                        Stats::Time::TimeBlock("Array Length", [&]() {
     381                                ArrayLength::computeLength( translationUnit );
     382                        });
     383                        Stats::Time::TimeBlock("Find Special Declarations", [&]() {
     384                                Validate::findSpecialDecls( translationUnit );
     385                        });
     386                        Stats::Time::TimeBlock("Fix Label Address", [&]() {
     387                                mutateAll( translationUnit, labelAddrFixer );
     388                        });
     389                        Stats::Time::TimeBlock("Handle Attributes", [&]() {
     390                                Validate::handleAttributes( translationUnit );
     391                        });
    387392                }
    388393        }
    … …  
    11821187                if ( CodeGen::isCtorDtorAssign( funcDecl->get_name() ) ) { // TODO: also check /=, etc.
    11831188                        if ( params.size() == 0 ) {
    1184                                 SemanticError( funcDecl->location, "Constructors, destructors, and assignment functions require at least one parameter." );
     1189                                SemanticError( funcDecl, "Constructors, destructors, and assignment functions require at least one parameter " );
    11851190                        }
    11861191                        ReferenceType * refType = dynamic_cast< ReferenceType * >( params.front()->get_type() );
    11871192                        if ( ! refType ) {
    1188                                 SemanticError( funcDecl->location, "First parameter of a constructor, destructor, or assignment function must be a reference." );
     1193                                SemanticError( funcDecl, "First parameter of a constructor, destructor, or assignment function must be a reference " );
    11891194                        }
    11901195                        if ( CodeGen::isCtorDtor( funcDecl->get_name() ) && returnVals.size() != 0 ) {
    1191                                 if(!returnVals.front()->get_type()->isVoid()) {
    1192                                         SemanticError( funcDecl->location, "Constructors and destructors cannot have explicit return values." );
    1193                                 }
     1196                                SemanticError( funcDecl, "Constructors and destructors cannot have explicit return values " );
    11941197                        }
    11951198                }

  • src/SynTree/AggregateDecl.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Sun May 17 23:56:39 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Dec 16 15:07:20 2019
    13 // Update Count     : 31
     12// Last Modified On : Wed Dec 11 16:31:55 2019
     13// Update Count     : 29
    1414//
    1515
    … …  
    2222#include "Declaration.h"         // for AggregateDecl, TypeDecl, Declaration
    2323#include "Initializer.h"
    24 #include "LinkageSpec.h"         // for Spec, linkageName, Cforall
     24#include "Parser/LinkageSpec.h"  // for Spec, linkageName, Cforall
    2525#include "Type.h"                // for Type, Type::StorageClasses
    2626
    … …  
    5555        os << typeString() << " " << name << ":";
    5656        if ( get_linkage() != LinkageSpec::Cforall ) {
    57                 os << " " << LinkageSpec::name( linkage );
     57                os << " " << LinkageSpec::linkageName( linkage );
    5858        } // if
    5959        os << " with body " << has_body();

  • src/SynTree/Attribute.h

    rb7d6a36 rdca5802  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 13 21:34:08 2020
    13 // Update Count     : 40
     12// Last Modified On : Sat Jul 22 09:54:14 2017
     13// Update Count     : 39
    1414//
    1515
    … …  
    3838        virtual ~Attribute();
    3939
    40         const std::string & get_name() const { return name; }
     40        std::string get_name() const { return name; }
    4141        void set_name( const std::string & newValue ) { name = newValue; }
    4242        std::list< Expression * > & get_parameters() { return parameters; }

  • src/SynTree/Declaration.h

    rb7d6a36 rdca5802  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec 13 23:11:22 2019
    13 // Update Count     : 157
     12// Last Modified On : Wed Dec 11 16:48:20 2019
     13// Update Count     : 149
    1414//
    1515
    … …  
    2424#include "BaseSyntaxNode.h"      // for BaseSyntaxNode
    2525#include "Mutator.h"             // for Mutator
    26 #include "LinkageSpec.h"         // for Spec, Cforall
     26#include "Parser/LinkageSpec.h"  // for Spec, Cforall
    2727#include "SynTree.h"             // for UniqueId
    2828#include "SynTree/Type.h"        // for Type, Type::StorageClasses, Type::Fu...
    … …  
    4343        bool extension = false;
    4444
    45         Declaration( const std::string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage );
    46         Declaration( const Declaration & other );
     45        Declaration( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage );
     46        Declaration( const Declaration &other );
    4747        virtual ~Declaration();
    4848
    49         const std::string & get_name() const { return name; }
     49        const std::string &get_name() const { return name; }
    5050        void set_name( std::string newValue ) { name = newValue; }
    5151
    … …  
    5858
    5959        bool get_extension() const { return extension; }
    60         Declaration * set_extension( bool exten ) { extension = exten; return this; }
     60        Declaration *set_extension( bool exten ) { extension = exten; return this; }
    6161
    6262        void fixUniqueId( void );
    63         virtual Declaration * clone() const override = 0;
     63        virtual Declaration *clone() const override = 0;
    6464        virtual void accept( Visitor & v ) override = 0;
    6565        virtual void accept( Visitor & v ) const override = 0;
    66         virtual Declaration * acceptMutator( Mutator & m ) override = 0;
    67         virtual void print( std::ostream & os, Indenter indent = {} ) const override = 0;
    68         virtual void printShort( std::ostream & os, Indenter indent = {} ) const = 0;
     66        virtual Declaration *acceptMutator( Mutator &m ) override = 0;
     67        virtual void print( std::ostream &os, Indenter indent = {} ) const override = 0;
     68        virtual void printShort( std::ostream &os, Indenter indent = {} ) const = 0;
    6969
    7070        UniqueId uniqueId;
    … …  
    8080        int scopeLevel = 0;
    8181
    82         Expression * asmName;
     82        Expression *asmName;
    8383        std::list< Attribute * > attributes;
    8484        bool isDeleted = false;
    8585
    86         DeclarationWithType( const std::string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs );
    87         DeclarationWithType( const DeclarationWithType & other );
     86        DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs );
     87        DeclarationWithType( const DeclarationWithType &other );
    8888        virtual ~DeclarationWithType();
    8989
    … …  
    9696        DeclarationWithType * set_scopeLevel( int newValue ) { scopeLevel = newValue; return this; }
    9797
    98         Expression * get_asmName() const { return asmName; }
    99         DeclarationWithType * set_asmName( Expression * newValue ) { asmName = newValue; return this; }
     98        Expression *get_asmName() const { return asmName; }
     99        DeclarationWithType * set_asmName( Expression *newValue ) { asmName = newValue; return this; }
    100100
    101101        std::list< Attribute * >& get_attributes() { return attributes; }
    … …  
    105105        //void set_functionSpecifiers( Type::FuncSpecifiers newValue ) { fs = newValue; }
    106106
    107         virtual DeclarationWithType * clone() const override = 0;
    108         virtual DeclarationWithType * acceptMutator( Mutator & m )  override = 0;
     107        virtual DeclarationWithType *clone() const override = 0;
     108        virtual DeclarationWithType *acceptMutator( Mutator &m )  override = 0;
    109109
    110110        virtual Type * get_type() const = 0;
    … …  
    118118        typedef DeclarationWithType Parent;
    119119  public:
    120         Type * type;
    121         Initializer * init;
    122         Expression * bitfieldWidth;
    123 
    124         ObjectDecl( const std::string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Expression * bitfieldWidth, Type * type, Initializer * init,
     120        Type *type;
     121        Initializer *init;
     122        Expression *bitfieldWidth;
     123
     124        ObjectDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init,
    125125                                const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
    126         ObjectDecl( const ObjectDecl & other );
     126        ObjectDecl( const ObjectDecl &other );
    127127        virtual ~ObjectDecl();
    128128
    129129        virtual Type * get_type() const override { return type; }
    130         virtual void set_type(Type * newType) override { type = newType; }
    131 
    132         Initializer * get_init() const { return init; }
    133         void set_init( Initializer * newValue ) { init = newValue; }
    134 
    135         Expression * get_bitfieldWidth() const { return bitfieldWidth; }
    136         void set_bitfieldWidth( Expression * newValue ) { bitfieldWidth = newValue; }
     130        virtual void set_type(Type *newType) override { type = newType; }
     131
     132        Initializer *get_init() const { return init; }
     133        void set_init( Initializer *newValue ) { init = newValue; }
     134
     135        Expression *get_bitfieldWidth() const { return bitfieldWidth; }
     136        void set_bitfieldWidth( Expression *newValue ) { bitfieldWidth = newValue; }
    137137
    138138        static ObjectDecl * newObject( const std::string & name, Type * type, Initializer * init );
    139139
    140         virtual ObjectDecl * clone() const override { return new ObjectDecl( *this ); }
    141         virtual void accept( Visitor & v ) override { v.visit( this ); }
    142         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    143         virtual DeclarationWithType * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    144         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    145         virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
     140        virtual ObjectDecl *clone() const override { return new ObjectDecl( *this ); }
     141        virtual void accept( Visitor & v ) override { v.visit( this ); }
     142        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     143        virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     144        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     145        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
    146146};
    147147
    … …  
    149149        typedef DeclarationWithType Parent;
    150150  public:
    151         FunctionType * type;
    152         CompoundStmt * statements;
     151        FunctionType *type;
     152        CompoundStmt *statements;
    153153        std::list< Expression * > withExprs;
    154154
    155         FunctionDecl( const std::string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType * type, CompoundStmt * statements,
     155        FunctionDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements,
    156156                                  const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
    157         FunctionDecl( const FunctionDecl & other );
     157        FunctionDecl( const FunctionDecl &other );
    158158        virtual ~FunctionDecl();
    159159
    … …  
    162162
    163163        FunctionType * get_functionType() const { return type; }
    164         void set_functionType( FunctionType * newValue ) { type = newValue; }
    165         CompoundStmt * get_statements() const { return statements; }
    166         void set_statements( CompoundStmt * newValue ) { statements = newValue; }
     164        void set_functionType( FunctionType *newValue ) { type = newValue; }
     165        CompoundStmt *get_statements() const { return statements; }
     166        void set_statements( CompoundStmt *newValue ) { statements = newValue; }
    167167        bool has_body() const { return NULL != statements; }
    168168
    169169        static FunctionDecl * newFunction( const std::string & name, FunctionType * type, CompoundStmt * statements );
    170170
    171         virtual FunctionDecl * clone() const override { return new FunctionDecl( *this ); }
    172         virtual void accept( Visitor & v ) override { v.visit( this ); }
    173         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    174         virtual DeclarationWithType * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    175         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    176         virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
     171        virtual FunctionDecl *clone() const override { return new FunctionDecl( *this ); }
     172        virtual void accept( Visitor & v ) override { v.visit( this ); }
     173        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     174        virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     175        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     176        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
    177177};
    178178
    … …  
    180180        typedef Declaration Parent;
    181181  public:
    182         Type * base;
    183         std::list< TypeDecl * > parameters;
    184         std::list< DeclarationWithType * > assertions;
    185 
    186         NamedTypeDecl( const std::string & name, Type::StorageClasses scs, Type * type );
    187         NamedTypeDecl( const NamedTypeDecl & other );
     182        Type *base;
     183        std::list< TypeDecl* > parameters;
     184        std::list< DeclarationWithType* > assertions;
     185
     186        NamedTypeDecl( const std::string &name, Type::StorageClasses scs, Type *type );
     187        NamedTypeDecl( const NamedTypeDecl &other );
    188188        virtual ~NamedTypeDecl();
    189189
    190         Type * get_base() const { return base; }
    191         void set_base( Type * newValue ) { base = newValue; }
    192         std::list< TypeDecl* > & get_parameters() { return parameters; }
    193         std::list< DeclarationWithType * >& get_assertions() { return assertions; }
     190        Type *get_base() const { return base; }
     191        void set_base( Type *newValue ) { base = newValue; }
     192        std::list< TypeDecl* >& get_parameters() { return parameters; }
     193        std::list< DeclarationWithType* >& get_assertions() { return assertions; }
    194194
    195195        virtual const char * typeString() const = 0;
    196196
    197         virtual NamedTypeDecl * clone() const override = 0;
    198         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    199         virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
     197        virtual NamedTypeDecl *clone() const override = 0;
     198        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     199        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
    200200};
    201201
    … …  
    203203        typedef NamedTypeDecl Parent;
    204204  public:
    205         enum Kind { Dtype, Otype, Ftype, Ttype, NUMBER_OF_KINDS };
    206 
    207         Kind kind;
     205        enum Kind { Dtype, Ftype, Ttype, NUMBER_OF_KINDS };
     206
     207        Type * init;
    208208        bool sized;
    209         Type * init;
    210209
    211210        /// Data extracted from a type decl
    212211        struct Data {
    213                 Kind kind;
     212                TypeDecl::Kind kind;
    214213                bool isComplete;
    215214
    216                 Data() : kind( NUMBER_OF_KINDS ), isComplete( false ) {}
    217                 Data( const TypeDecl * typeDecl ) : Data( typeDecl->get_kind(), typeDecl->isComplete() ) {}
     215                Data() : kind( (TypeDecl::Kind)-1 ), isComplete( false ) {}
     216                Data( TypeDecl * typeDecl ) : Data( typeDecl->get_kind(), typeDecl->isComplete() ) {}
    218217                Data( Kind kind, bool isComplete ) : kind( kind ), isComplete( isComplete ) {}
    219                 Data( const Data & d1, const Data & d2 )
    220                         : kind( d1.kind ), isComplete( d1.isComplete || d2.isComplete ) {}
    221 
    222                 bool operator==( const Data & other ) const { return kind == other.kind && isComplete == other.isComplete; }
    223                 bool operator!=( const Data & other ) const { return !(*this == other);}
     218                Data( const Data& d1, const Data& d2 )
     219                : kind( d1.kind ), isComplete ( d1.isComplete || d2.isComplete ) {}
     220
     221                bool operator==(const Data & other) const { return kind == other.kind && isComplete == other.isComplete; }
     222                bool operator!=(const Data & other) const { return !(*this == other);}
    224223        };
    225224
    226         TypeDecl( const std::string & name, Type::StorageClasses scs, Type * type, Kind kind, bool sized, Type * init = nullptr );
    227         TypeDecl( const TypeDecl & other );
     225        TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind, bool sized, Type * init = nullptr );
     226        TypeDecl( const TypeDecl &other );
    228227        virtual ~TypeDecl();
    229228
    … …  
    240239        virtual const char * genTypeString() const;
    241240
    242         virtual TypeDecl * clone() const override { return new TypeDecl( *this ); }
    243         virtual void accept( Visitor & v ) override { v.visit( this ); }
    244         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    245         virtual Declaration * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    246         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     241        virtual TypeDecl *clone() const override { return new TypeDecl( *this ); }
     242        virtual void accept( Visitor & v ) override { v.visit( this ); }
     243        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     244        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     245        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     246
     247        Kind kind;
    247248};
    248249
    … …  
    250251        typedef NamedTypeDecl Parent;
    251252  public:
    252         TypedefDecl( const std::string & name, CodeLocation location, Type::StorageClasses scs, Type * type, LinkageSpec::Spec spec = LinkageSpec::Cforall )
     253        TypedefDecl( const std::string &name, CodeLocation location, Type::StorageClasses scs, Type *type, LinkageSpec::Spec spec = LinkageSpec::Cforall )
    253254                : Parent( name, scs, type ) { set_linkage( spec ); this->location = location; }
    254255
    255         TypedefDecl( const TypedefDecl & other ) : Parent( other ) {}
    256 
    257         virtual const char * typeString() const override;
    258 
    259         virtual TypedefDecl * clone() const override { return new TypedefDecl( *this ); }
    260         virtual void accept( Visitor & v ) override { v.visit( this ); }
    261         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    262         virtual Declaration * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
     256        TypedefDecl( const TypedefDecl &other ) : Parent( other ) {}
     257
     258        virtual const char * typeString() const override;
     259
     260        virtual TypedefDecl *clone() const override { return new TypedefDecl( *this ); }
     261        virtual void accept( Visitor & v ) override { v.visit( this ); }
     262        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     263        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    263264  private:
    264265};
    … …  
    276277        AggregateDecl * parent = nullptr;
    277278
    278         AggregateDecl( const std::string & name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall );
    279         AggregateDecl( const AggregateDecl & other );
     279        AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall );
     280        AggregateDecl( const AggregateDecl &other );
    280281        virtual ~AggregateDecl();
    281282
    … …  
    289290        AggregateDecl * set_body( bool body ) { AggregateDecl::body = body; return this; }
    290291
    291         virtual void print( std::ostream & os, Indenter indent = {} ) const override final;
    292         virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
     292        virtual void print( std::ostream &os, Indenter indent = {} ) const override final;
     293        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
    293294  protected:
    294295        virtual const char * typeString() const = 0;
    … …  
    298299        typedef AggregateDecl Parent;
    299300  public:
    300         StructDecl( const std::string & name, Aggregate kind = Struct, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ), kind( kind ) {}
    301         StructDecl( const StructDecl & other ) : Parent( other ), kind( other.kind ) {}
     301        StructDecl( const std::string &name, Aggregate kind = Struct, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ), kind( kind ) {}
     302        StructDecl( const StructDecl &other ) : Parent( other ), kind( other.kind ) {}
    302303
    303304        bool is_coroutine() { return kind == Coroutine; }
    … …  
    305306        bool is_thread() { return kind == Thread; }
    306307
    307         virtual StructDecl * clone() const override { return new StructDecl( *this ); }
    308         virtual void accept( Visitor & v ) override { v.visit( this ); }
    309         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    310         virtual Declaration * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
     308        virtual StructDecl *clone() const override { return new StructDecl( *this ); }
     309        virtual void accept( Visitor & v ) override { v.visit( this ); }
     310        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     311        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    311312        Aggregate kind;
    312313  private:
    … …  
    317318        typedef AggregateDecl Parent;
    318319  public:
    319         UnionDecl( const std::string & name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {}
    320         UnionDecl( const UnionDecl & other ) : Parent( other ) {}
    321 
    322         virtual UnionDecl * clone() const override { return new UnionDecl( *this ); }
    323         virtual void accept( Visitor & v ) override { v.visit( this ); }
    324         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    325         virtual Declaration * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
     320        UnionDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {}
     321        UnionDecl( const UnionDecl &other ) : Parent( other ) {}
     322
     323        virtual UnionDecl *clone() const override { return new UnionDecl( *this ); }
     324        virtual void accept( Visitor & v ) override { v.visit( this ); }
     325        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     326        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    326327  private:
    327328        virtual const char * typeString() const override;
    … …  
    331332        typedef AggregateDecl Parent;
    332333  public:
    333         EnumDecl( const std::string & name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {}
    334         EnumDecl( const EnumDecl & other ) : Parent( other ) {}
     334        EnumDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {}
     335        EnumDecl( const EnumDecl &other ) : Parent( other ) {}
    335336
    336337        bool valueOf( Declaration * enumerator, long long int & value );
    337338
    338         virtual EnumDecl * clone() const override { return new EnumDecl( *this ); }
    339         virtual void accept( Visitor & v ) override { v.visit( this ); }
    340         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    341         virtual Declaration * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
     339        virtual EnumDecl *clone() const override { return new EnumDecl( *this ); }
     340        virtual void accept( Visitor & v ) override { v.visit( this ); }
     341        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     342        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    342343  private:
    343344        std::unordered_map< std::string, long long int > enumValues;
    … …  
    348349        typedef AggregateDecl Parent;
    349350  public:
    350         TraitDecl( const std::string & name, const std::list< Attribute * > & attributes, LinkageSpec::Spec linkage ) : Parent( name, attributes, linkage ) {
     351        TraitDecl( const std::string &name, const std::list< Attribute * > & attributes, LinkageSpec::Spec linkage ) : Parent( name, attributes, linkage ) {
    351352                assertf( attributes.empty(), "attribute unsupported for traits" );
    352353        }
    353         TraitDecl( const TraitDecl & other ) : Parent( other ) {}
    354 
    355         virtual TraitDecl * clone() const override { return new TraitDecl( *this ); }
    356         virtual void accept( Visitor & v ) override { v.visit( this ); }
    357         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    358         virtual Declaration * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
     354        TraitDecl( const TraitDecl &other ) : Parent( other ) {}
     355
     356        virtual TraitDecl *clone() const override { return new TraitDecl( *this ); }
     357        virtual void accept( Visitor & v ) override { v.visit( this ); }
     358        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     359        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    359360  private:
    360361        virtual const char * typeString() const override;
    … …  
    380381class AsmDecl : public Declaration {
    381382  public:
    382         AsmStmt * stmt;
    383 
    384         AsmDecl( AsmStmt * stmt );
    385         AsmDecl( const AsmDecl & other );
     383        AsmStmt *stmt;
     384
     385        AsmDecl( AsmStmt *stmt );
     386        AsmDecl( const AsmDecl &other );
    386387        virtual ~AsmDecl();
    387388
    388         AsmStmt * get_stmt() { return stmt; }
    389         void set_stmt( AsmStmt * newValue ) { stmt = newValue; }
    390 
    391         virtual AsmDecl * clone() const override { return new AsmDecl( *this ); }
    392         virtual void accept( Visitor & v ) override { v.visit( this ); }
    393         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    394         virtual AsmDecl * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    395         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    396         virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
     389        AsmStmt *get_stmt() { return stmt; }
     390        void set_stmt( AsmStmt *newValue ) { stmt = newValue; }
     391
     392        virtual AsmDecl *clone() const override { return new AsmDecl( *this ); }
     393        virtual void accept( Visitor & v ) override { v.visit( this ); }
     394        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     395        virtual AsmDecl *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     396        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     397        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
    397398};
    398399
    … …  
    409410        virtual void accept( Visitor & v ) override { v.visit( this ); }
    410411        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    411         virtual StaticAssertDecl * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    412         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    413         virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
     412        virtual StaticAssertDecl * acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     413        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     414        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
    414415};
    415416

  • src/SynTree/DeclarationWithType.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec 13 23:45:16 2019
    13 // Update Count     : 26
     12// Last Modified On : Thu Mar 16 08:34:35 2017
     13// Update Count     : 25
    1414//
    1515
    … …  
    2020#include "Common/utility.h"      // for cloneAll, deleteAll, maybeClone
    2121#include "Declaration.h"         // for DeclarationWithType, Declaration
    22 #include "LinkageSpec.h"         // for Spec
    23 #include "Expression.h"          // for ConstantExpr
     22#include "Parser/LinkageSpec.h"  // for Spec
     23#include "SynTree/Expression.h"  // for ConstantExpr
    2424#include "Type.h"                // for Type, Type::FuncSpecifiers, Type::St...
    2525

  • src/SynTree/FunctionDecl.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Dec 16 15:11:20 2019
    13 // Update Count     : 77
     12// Last Modified On : Sat Dec  7 17:40:09 2019
     13// Update Count     : 75
    1414//
    1515
    … …  
    2424#include "Declaration.h"         // for FunctionDecl, FunctionDecl::Parent
    2525#include "Expression.h"
    26 #include "LinkageSpec.h"         // for Spec, linkageName, Cforall
     26#include "Parser/LinkageSpec.h"  // for Spec, linkageName, Cforall
    2727#include "Statement.h"           // for CompoundStmt
    2828#include "Type.h"                // for Type, FunctionType, Type::FuncSpecif...
    … …  
    7373        } // if
    7474        if ( linkage != LinkageSpec::Cforall ) {
    75                 os << LinkageSpec::name( linkage ) << " ";
     75                os << LinkageSpec::linkageName( linkage ) << " ";
    7676        } // if
    7777

  • src/SynTree/NamedTypeDecl.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Dec 16 15:11:40 2019
    13 // Update Count     : 17
     12// Last Modified On : Wed Dec 11 08:26:17 2019
     13// Update Count     : 15
    1414//
    1515
    … …  
    2020#include "Common/utility.h"      // for printAll, cloneAll, deleteAll, maybe...
    2121#include "Declaration.h"         // for NamedTypeDecl, DeclarationWithType
    22 #include "LinkageSpec.h"         // for Spec, Cforall, linkageName
     22#include "Parser/LinkageSpec.h"  // for Spec, Cforall, linkageName
    2323#include "Type.h"                // for Type, Type::StorageClasses
    2424
    … …  
    4444
    4545        if ( linkage != LinkageSpec::Cforall ) {
    46                 os << LinkageSpec::name( linkage ) << " ";
     46                os << LinkageSpec::linkageName( linkage ) << " ";
    4747        } // if
    4848        get_storageClasses().print( os );

  • src/SynTree/ObjectDecl.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Dec 16 15:12:03 2019
    13 // Update Count     : 61
     12// Last Modified On : Thu Mar 16 08:34:27 2017
     13// Update Count     : 59
    1414//
    1515
    … …  
    2323#include "Expression.h"          // for Expression
    2424#include "Initializer.h"         // for Initializer
    25 #include "LinkageSpec.h"         // for Spec, linkageName, Cforall
     25#include "Parser/LinkageSpec.h"  // for Spec, linkageName, Cforall
    2626#include "Type.h"                // for Type, Type::StorageClasses, Type::Fu...
    2727
    … …  
    4848
    4949        if ( linkage != LinkageSpec::Cforall ) {
    50                 os << LinkageSpec::name( linkage ) << " ";
     50                os << LinkageSpec::linkageName( linkage ) << " ";
    5151        } // if
    5252

  • src/SynTree/Statement.cc

    rb7d6a36 rdca5802  
    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 Jan 20 16:03:00 2020
    13 // Update Count     : 71
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sun Sep  3 20:46:44 2017
     13// Update Count     : 68
    1414//
    1515
    … …  
    4646Statement::~Statement() {}
    4747
    48 ExprStmt::ExprStmt( Expression * expr ) : Statement(), expr( expr ) {}
    49 
    50 ExprStmt::ExprStmt( const ExprStmt & other ) : Statement( other ), expr( maybeClone( other.expr ) ) {}
     48ExprStmt::ExprStmt( Expression *expr ) : Statement(), expr( expr ) {}
     49
     50ExprStmt::ExprStmt( const ExprStmt &other ) : Statement( other ), expr( maybeClone( other.expr ) ) {}
    5151
    5252ExprStmt::~ExprStmt() {
    … …  
    5454}
    5555
    56 void ExprStmt::print( std::ostream & os, Indenter indent ) const {
     56void ExprStmt::print( std::ostream &os, Indenter indent ) const {
    5757        os << "Expression Statement:" << endl << indent+1;
    5858        expr->print( os, indent+1 );
    … …  
    6060
    6161
    62 AsmStmt::AsmStmt( bool voltile, Expression * instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels ) : Statement(), voltile( voltile ), instruction( instruction ), output( output ), input( input ), clobber( clobber ), gotolabels( gotolabels ) {}
     62AsmStmt::AsmStmt( bool voltile, Expression *instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels ) : Statement(), voltile( voltile ), instruction( instruction ), output( output ), input( input ), clobber( clobber ), gotolabels( gotolabels ) {}
    6363
    6464AsmStmt::AsmStmt( const AsmStmt & other ) : Statement( other ), voltile( other.voltile ), instruction( maybeClone( other.instruction ) ), gotolabels( other.gotolabels ) {
    … …  
    7575}
    7676
    77 void AsmStmt::print( std::ostream & os, Indenter indent ) const {
     77void AsmStmt::print( std::ostream &os, Indenter indent ) const {
    7878        os << "Assembler Statement:" << endl;
    7979        os << indent+1 << "instruction: " << endl << indent;
    … …  
    9696DirectiveStmt::DirectiveStmt( const std::string & directive ) : Statement(), directive( directive ) {}
    9797
    98 void DirectiveStmt::print( std::ostream & os, Indenter ) const {
     98void DirectiveStmt::print( std::ostream &os, Indenter ) const {
    9999        os << "GCC Directive:" << directive << endl;
    100100}
    101101
    102102
    103 const char * BranchStmt::brType[] = {
    104         "Goto", "Break", "Continue", "Fall Through", "Fall Through Default",
    105 };
     103const char *BranchStmt::brType[] = { "Goto", "Break", "Continue" };
    106104
    107105BranchStmt::BranchStmt( Label target, Type type ) throw ( SemanticErrorException ) :
    … …  
    113111}
    114112
    115 BranchStmt::BranchStmt( Expression * computedTarget, Type type ) throw ( SemanticErrorException ) :
     113BranchStmt::BranchStmt( Expression *computedTarget, Type type ) throw ( SemanticErrorException ) :
    116114        Statement(), computedTarget( computedTarget ), type( type ) {
    117115        if ( type != BranchStmt::Goto || computedTarget == nullptr ) {
    … …  
    120118}
    121119
    122 void BranchStmt::print( std::ostream & os, Indenter indent ) const {
    123         assert(type < 5);
     120void BranchStmt::print( std::ostream &os, Indenter indent ) const {
    124121        os << "Branch (" << brType[type] << ")" << endl ;
    125122        if ( target != "" ) os << indent+1 << "with target: " << target << endl;
    … …  
    128125}
    129126
    130 ReturnStmt::ReturnStmt( Expression * expr ) : Statement(), expr( expr ) {}
     127ReturnStmt::ReturnStmt( Expression *expr ) : Statement(), expr( expr ) {}
    131128
    132129ReturnStmt::ReturnStmt( const ReturnStmt & other ) : Statement( other ), expr( maybeClone( other.expr ) ) {}
    … …  
    136133}
    137134
    138 void ReturnStmt::print( std::ostream & os, Indenter indent ) const {
     135void ReturnStmt::print( std::ostream &os, Indenter indent ) const {
    139136        os << "Return Statement, returning: ";
    140137        if ( expr != nullptr ) {
    … …  
    145142}
    146143
    147 IfStmt::IfStmt( Expression * condition, Statement * thenPart, Statement * elsePart, std::list<Statement *> initialization ):
     144IfStmt::IfStmt( Expression *condition, Statement *thenPart, Statement *elsePart, std::list<Statement *> initialization ):
    148145        Statement(), condition( condition ), thenPart( thenPart ), elsePart( elsePart ), initialization( initialization ) {}
    149146
    … …  
    160157}
    161158
    162 void IfStmt::print( std::ostream & os, Indenter indent ) const {
     159void IfStmt::print( std::ostream &os, Indenter indent ) const {
    163160        os << "If on condition: " << endl;
    164161        os << indent+1;
    … …  
    179176        thenPart->print( os, indent+1 );
    180177
    181         if ( elsePart != nullptr ) {
     178        if ( elsePart != 0 ) {
    182179                os << indent << "... else: " << endl;
    183180                os << indent+1;
    … …  
    186183}
    187184
    188 SwitchStmt::SwitchStmt( Expression * condition, const std::list<Statement *> & statements ):
     185SwitchStmt::SwitchStmt( Expression * condition, const std::list<Statement *> &statements ):
    189186        Statement(), condition( condition ), statements( statements ) {
    190187}
    … …  
    201198}
    202199
    203 void SwitchStmt::print( std::ostream & os, Indenter indent ) const {
     200void SwitchStmt::print( std::ostream &os, Indenter indent ) const {
    204201        os << "Switch on condition: ";
    205202        condition->print( os );
    … …  
    211208}
    212209
    213 CaseStmt::CaseStmt( Expression * condition, const std::list<Statement *> & statements, bool deflt ) throw ( SemanticErrorException ) :
     210CaseStmt::CaseStmt( Expression *condition, const std::list<Statement *> &statements, bool deflt ) throw ( SemanticErrorException ) :
    214211        Statement(), condition( condition ), stmts( statements ), _isDefault( deflt ) {
    215         if ( isDefault() && condition != nullptr ) SemanticError( condition, "default case with condition: " );
     212        if ( isDefault() && condition != 0 ) SemanticError( condition, "default case with condition: " );
    216213}
    217214
    … …  
    232229}
    233230
    234 void CaseStmt::print( std::ostream & os, Indenter indent ) const {
     231void CaseStmt::print( std::ostream &os, Indenter indent ) const {
    235232        if ( isDefault() ) os << indent << "Default ";
    236233        else {
    … …  
    246243}
    247244
    248 WhileStmt::WhileStmt( Expression * condition, Statement * body, std::list< Statement * > & initialization, bool isDoWhile ):
     245WhileStmt::WhileStmt( Expression *condition, Statement *body, std::list< Statement * > & initialization, bool isDoWhile ):
    249246        Statement(), condition( condition), body( body), initialization( initialization ), isDoWhile( isDoWhile) {
    250247}
    … …  
    259256}
    260257
    261 void WhileStmt::print( std::ostream & os, Indenter indent ) const {
     258void WhileStmt::print( std::ostream &os, Indenter indent ) const {
    262259        os << "While on condition: " << endl ;
    263260        condition->print( os, indent+1 );
    … …  
    265262        os << indent << "... with body: " << endl;
    266263
    267         if ( body != nullptr ) body->print( os, indent+1 );
    268 }
    269 
    270 ForStmt::ForStmt( std::list<Statement *> initialization, Expression * condition, Expression * increment, Statement * body ):
     264        if ( body != 0 ) body->print( os, indent+1 );
     265}
     266
     267ForStmt::ForStmt( std::list<Statement *> initialization, Expression *condition, Expression *increment, Statement *body ):
    271268        Statement(), initialization( initialization ), condition( condition ), increment( increment ), body( body ) {
    272269}
    … …  
    285282}
    286283
    287 void ForStmt::print( std::ostream & os, Indenter indent ) const {
     284void ForStmt::print( std::ostream &os, Indenter indent ) const {
    288285        Statement::print( os, indent ); // print labels
    289286
    … …  
    308305        }
    309306
    310         if ( body != nullptr ) {
     307        if ( body != 0 ) {
    311308                os << "\n" << indent << "... with body: \n" << indent+1;
    312309                body->print( os, indent+1 );
    … …  
    320317}
    321318
    322 ThrowStmt::ThrowStmt( const ThrowStmt & other ) :
     319ThrowStmt::ThrowStmt( const ThrowStmt &other ) :
    323320        Statement ( other ), kind( other.kind ), expr( maybeClone( other.expr ) ), target( maybeClone( other.target ) ) {
    324321}
    … …  
    329326}
    330327
    331 void ThrowStmt::print( std::ostream & os, Indenter indent) const {
     328void ThrowStmt::print( std::ostream &os, Indenter indent) const {
    332329        if ( target ) os << "Non-Local ";
    333330        os << "Throw Statement, raising: ";
    … …  
    339336}
    340337
    341 TryStmt::TryStmt( CompoundStmt * tryBlock, std::list<CatchStmt *> & handlers, FinallyStmt * finallyBlock ) :
     338TryStmt::TryStmt( CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock ) :
    342339        Statement(), block( tryBlock ),  handlers( handlers ), finallyBlock( finallyBlock ) {
    343340}
    344341
    345 TryStmt::TryStmt( const TryStmt & other ) : Statement( other ), block( maybeClone( other.block ) ), finallyBlock( maybeClone( other.finallyBlock ) ) {
     342TryStmt::TryStmt( const TryStmt &other ) : Statement( other ), block( maybeClone( other.block ) ), finallyBlock( maybeClone( other.finallyBlock ) ) {
    346343        cloneAll( other.handlers, handlers );
    347344}
    … …  
    353350}
    354351
    355 void TryStmt::print( std::ostream & os, Indenter indent ) const {
     352void TryStmt::print( std::ostream &os, Indenter indent ) const {
    356353        os << "Try Statement" << endl;
    357354        os << indent << "... with block:" << endl << indent+1;
    … …  
    366363
    367364        // finally block
    368         if ( finallyBlock != nullptr ) {
     365        if ( finallyBlock != 0 ) {
    369366                os << indent << "... and finally:" << endl << indent+1;
    370367                finallyBlock->print( os, indent+1 );
    … …  
    372369}
    373370
    374 CatchStmt::CatchStmt( Kind kind, Declaration * decl, Expression * cond, Statement * body ) :
     371CatchStmt::CatchStmt( Kind kind, Declaration *decl, Expression *cond, Statement *body ) :
    375372        Statement(), kind ( kind ), decl ( decl ), cond ( cond ), body( body ) {
    376373                assertf( decl, "Catch clause must have a declaration." );
    … …  
    386383}
    387384
    388 void CatchStmt::print( std::ostream & os, Indenter indent ) const {
     385void CatchStmt::print( std::ostream &os, Indenter indent ) const {
    389386        os << "Catch " << ((Terminate == kind) ? "Terminate" : "Resume") << " Statement" << endl;
    390387
    … …  
    404401
    405402
    406 FinallyStmt::FinallyStmt( CompoundStmt * block ) : Statement(), block( block ) {
     403FinallyStmt::FinallyStmt( CompoundStmt *block ) : Statement(), block( block ) {
    407404}
    408405
    … …  
    414411}
    415412
    416 void FinallyStmt::print( std::ostream & os, Indenter indent ) const {
     413void FinallyStmt::print( std::ostream &os, Indenter indent ) const {
    417414        os << "Finally Statement" << endl;
    418415        os << indent << "... with block:" << endl << indent+1;
    … …  
    461458}
    462459
    463 void WaitForStmt::print( std::ostream & os, Indenter indent ) const {
     460void WaitForStmt::print( std::ostream &os, Indenter indent ) const {
    464461        os << "Waitfor Statement" << endl;
    465462        indent += 1;
    … …  
    517514}
    518515
    519 void NullStmt::print( std::ostream & os, Indenter indent ) const {
     516void NullStmt::print( std::ostream &os, Indenter indent ) const {
    520517        os << "Null Statement" << endl;
    521518        Statement::print( os, indent );
    … …  
    533530}
    534531
    535 void ImplicitCtorDtorStmt::print( std::ostream & os, Indenter indent ) const {
     532void ImplicitCtorDtorStmt::print( std::ostream &os, Indenter indent ) const {
    536533        os << "Implicit Ctor Dtor Statement" << endl;
    537534        os << indent << "... with Ctor/Dtor: ";

  • src/SynTree/Statement.h

    rb7d6a36 rdca5802  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jan 10 14:13:24 2020
    13 // Update Count     : 85
     12// Last Modified On : Tue Mar 12 09:01:53 2019
     13// Update Count     : 83
    1414//
    1515
    … …  
    257257        Statement * body;
    258258
    259         ForStmt( std::list<Statement *> initialization, Expression * condition = nullptr, Expression * increment = nullptr, Statement * body = nullptr );
     259        ForStmt( std::list<Statement *> initialization, Expression * condition = 0, Expression * increment = 0, Statement * body = 0 );
    260260        ForStmt( const ForStmt & other );
    261261        virtual ~ForStmt();
    … …  
    357357        FinallyStmt * finallyBlock;
    358358
    359         TryStmt( CompoundStmt * tryBlock, std::list<CatchStmt *> & handlers, FinallyStmt * finallyBlock = nullptr );
     359        TryStmt( CompoundStmt * tryBlock, std::list<CatchStmt *> & handlers, FinallyStmt * finallyBlock = 0 );
    360360        TryStmt( const TryStmt & other );
    361361        virtual ~TryStmt();

  • src/SynTree/TupleType.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec 13 23:44:38 2019
    13 // Update Count     : 4
     12// Last Modified On : Wed Feb  1 17:10:58 2017
     13// Update Count     : 3
    1414//
    1515
    … …  
    2020#include "Declaration.h"         // for Declaration, ObjectDecl
    2121#include "Initializer.h"         // for ListInit
    22 #include "LinkageSpec.h"         // for Cforall
     22#include "Parser/LinkageSpec.h"  // for Cforall
    2323#include "Type.h"                // for TupleType, Type, Type::Qualifiers
    2424

  • src/SynTree/Type.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Dec 15 16:52:37 2019
    13 // Update Count     : 49
     12// Last Modified On : Sun Aug  4 21:05:07 2019
     13// Update Count     : 45
    1414//
    1515#include "Type.h"
    … …  
    2424using namespace std;
    2525
    26 // GENERATED START, DO NOT EDIT
    27 // GENERATED BY BasicTypes-gen.cc
    2826const char * BasicType::typeNames[] = {
    2927        "_Bool",
    … …  
    4745        "float",
    4846        "float _Complex",
     47        //"float _Imaginary",
    4948        "_Float32x",
    5049        "_Float32x _Complex",
    … …  
    5352        "double",
    5453        "double _Complex",
     54        //"double _Imaginary",
    5555        "_Float64x",
    5656        "_Float64x _Complex",
    … …  
    6161        "long double",
    6262        "long double _Complex",
     63        //"long double _Imaginary",
    6364        "_Float128x",
    6465        "_Float128x _Complex",
    6566};
    66 // GENERATED END
     67static_assert(
     68        sizeof(BasicType::typeNames) / sizeof(BasicType::typeNames[0]) == BasicType::NUMBER_OF_BASIC_TYPES,
     69        "Each basic type name should have a corresponding kind enum value"
     70);
    6771
    6872Type::Type( const Qualifiers &tq, const std::list< Attribute * > & attributes ) : tq( tq ), attributes( attributes ) {}

  • src/SynTree/TypeDecl.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec 13 15:26:14 2019
    13 // Update Count     : 21
     12// Last Modified On : Wed Dec 11 17:56:30 2019
     13// Update Count     : 10
    1414//
    1515
    … …  
    1818
    1919#include "Common/utility.h"  // for maybeClone
     20#include "Parser/ParseNode.h"
    2021#include "Declaration.h"     // for TypeDecl, TypeDecl::Data, TypeDecl::Kind...
    2122#include "Type.h"            // for Type, Type::StorageClasses
    2223
    23 TypeDecl::TypeDecl( const std::string & name, Type::StorageClasses scs, Type * type, Kind kind, bool sized, Type * init ) : Parent( name, scs, type ), kind( kind ), sized( kind == Ttype || sized ), init( init ) {
     24TypeDecl::TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind, bool sized, Type * init ) : Parent( name, scs, type ), init( init ), sized( kind == Ttype || sized ), kind( kind ) {
    2425}
    2526
    26 TypeDecl::TypeDecl( const TypeDecl & other ) : Parent( other ), kind( other.kind ), sized( other.sized ), init( maybeClone( other.init ) ) {
     27TypeDecl::TypeDecl( const TypeDecl &other ) : Parent( other ), init( maybeClone( other.init ) ), sized( other.sized ), kind( other.kind ) {
    2728}
    2829
    2930TypeDecl::~TypeDecl() {
    30         delete init;
     31  delete init;
    3132}
    3233
    3334const char * TypeDecl::typeString() const {
    34         static const char * kindNames[] = { "sized data type", "sized object type", "sized function type", "sized tuple type" };
    35         static_assert( sizeof(kindNames)/sizeof(kindNames[0]) == TypeDecl::NUMBER_OF_KINDS, "typeString: kindNames is out of sync." );
    36         assertf( kind < TypeDecl::NUMBER_OF_KINDS, "TypeDecl kind is out of bounds." );
     35        static const char * kindNames[] = { "sized object type", "sized function type", "sized tuple type" };
     36        assertf( sizeof(kindNames)/sizeof(kindNames[0]) == DeclarationNode::NoTypeClass-1, "typeString: kindNames is out of sync." );
     37        assertf( kind < sizeof(kindNames)/sizeof(kindNames[0]), "TypeDecl's kind is out of bounds." );
    3738        return isComplete() ? kindNames[ kind ] : &kindNames[ kind ][ sizeof("sized") ]; // sizeof includes '\0'
    3839}
    3940
    4041const char * TypeDecl::genTypeString() const {
    41         static const char * kindNames[] = { "dtype", "otype", "ftype", "ttype" };
    42         static_assert( sizeof(kindNames)/sizeof(kindNames[0]) == TypeDecl::NUMBER_OF_KINDS, "genTypeString: kindNames is out of sync." );
    43         assertf( kind < TypeDecl::NUMBER_OF_KINDS, "TypeDecl kind is out of bounds." );
     42        static const char * kindNames[] = { "dtype", "ftype", "ttype" };
     43        assertf( sizeof(kindNames)/sizeof(kindNames[0]) == DeclarationNode::NoTypeClass-1, "genTypeString: kindNames is out of sync." );
     44        assertf( kind < sizeof(kindNames)/sizeof(kindNames[0]), "TypeDecl's kind is out of bounds." );
    4445        return kindNames[ kind ];
    4546}
    4647
    4748void TypeDecl::print( std::ostream &os, Indenter indent ) const {
    48         NamedTypeDecl::print( os, indent );
    49         if ( init ) {
    50                 os << std::endl << indent << "with type initializer: ";
    51                 init->print( os, indent + 1 );
    52         } // if
     49  NamedTypeDecl::print( os, indent );
     50  if ( init ) {
     51    os << std::endl << indent << "with type initializer: ";
     52    init->print( os, indent + 1 );
     53  }
    5354}
    5455
     56
    5557std::ostream & operator<<( std::ostream & os, const TypeDecl::Data & data ) {
    56         return os << data.kind << ", " << data.isComplete;
     58  return os << data.kind << ", " << data.isComplete;
    5759}
    5860

  • src/SynTree/module.mk

    rb7d6a36 rdca5802  
    1111## Created On       : Mon Jun  1 17:49:17 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Sat Dec 14 07:26:43 2019
    14 ## Update Count     : 2
     13## Last Modified On : Mon Jun  1 17:54:09 2015
     14## Update Count     : 1
    1515###############################################################################
    1616
    1717SRC_SYNTREE = \
     18      SynTree/Type.cc \
     19      SynTree/VoidType.cc \
     20      SynTree/BasicType.cc \
     21      SynTree/PointerType.cc \
     22      SynTree/ArrayType.cc \
     23      SynTree/ReferenceType.cc \
     24      SynTree/FunctionType.cc \
     25      SynTree/ReferenceToType.cc \
     26      SynTree/TupleType.cc \
     27      SynTree/TypeofType.cc \
     28      SynTree/AttrType.cc \
     29      SynTree/VarArgsType.cc \
     30      SynTree/ZeroOneType.cc \
     31      SynTree/Constant.cc \
     32      SynTree/Expression.cc \
     33      SynTree/TupleExpr.cc \
     34      SynTree/CommaExpr.cc \
     35      SynTree/TypeExpr.cc \
     36      SynTree/ApplicationExpr.cc \
    1837      SynTree/AddressExpr.cc \
    19       SynTree/AggregateDecl.cc \
    20       SynTree/ApplicationExpr.cc \
    21       SynTree/ArrayType.cc \
    22       SynTree/AttrType.cc \
    23       SynTree/Attribute.cc \
    24       SynTree/BasicType.cc \
    25       SynTree/CommaExpr.cc \
     38      SynTree/Statement.cc \
    2639      SynTree/CompoundStmt.cc \
    27       SynTree/Constant.cc \
    28       SynTree/DeclReplacer.cc \
    2940      SynTree/DeclStmt.cc \
    3041      SynTree/Declaration.cc \
    3142      SynTree/DeclarationWithType.cc \
    32       SynTree/Expression.cc \
     43      SynTree/ObjectDecl.cc \
    3344      SynTree/FunctionDecl.cc \
    34       SynTree/FunctionType.cc \
     45      SynTree/AggregateDecl.cc \
     46      SynTree/NamedTypeDecl.cc \
     47      SynTree/TypeDecl.cc \
    3548      SynTree/Initializer.cc \
    36       SynTree/LinkageSpec.cc \
    37       SynTree/NamedTypeDecl.cc \
    38       SynTree/ObjectDecl.cc \
    39       SynTree/PointerType.cc \
    40       SynTree/ReferenceToType.cc \
    41       SynTree/ReferenceType.cc \
    42       SynTree/Statement.cc \
    43       SynTree/TupleExpr.cc \
    44       SynTree/TupleType.cc \
    45       SynTree/Type.cc \
    46       SynTree/TypeDecl.cc \
    47       SynTree/TypeExpr.cc \
    4849      SynTree/TypeSubstitution.cc \
    49       SynTree/TypeofType.cc \
    50       SynTree/VarArgsType.cc \
    51       SynTree/VoidType.cc \
    52       SynTree/ZeroOneType.cc
     50      SynTree/Attribute.cc \
     51      SynTree/DeclReplacer.cc
    5352
    5453SRC += $(SRC_SYNTREE)

  • src/Tuples/TupleAssignment.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec 13 23:45:33 2019
    13 // Update Count     : 9
     12// Last Modified On : Fri Mar 17 09:43:03 2017
     13// Update Count     : 8
    1414//
    1515
    … …  
    3434#include "InitTweak/GenInit.h"             // for genCtorInit
    3535#include "InitTweak/InitTweak.h"           // for getPointerBase, isAssignment
     36#include "Parser/LinkageSpec.h"            // for Cforall
    3637#include "ResolvExpr/Alternative.h"        // for AltList, Alternative
    3738#include "ResolvExpr/AlternativeFinder.h"  // for AlternativeFinder, simpleC...
    … …  
    4041#include "ResolvExpr/TypeEnvironment.h"    // for TypeEnvironment
    4142#include "ResolvExpr/typeops.h"            // for combos
    42 #include "SynTree/LinkageSpec.h"           // for Cforall
    4343#include "SynTree/Declaration.h"           // for ObjectDecl
    4444#include "SynTree/Expression.h"            // for Expression, CastExpr, Name...

  • src/Tuples/TupleExpansion.cc

    rb7d6a36 rdca5802  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec 13 23:45:51 2019
    13 // Update Count     : 24
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Fri Jul 19 14:39:00 2019
     13// Update Count     : 22
    1414//
    1515
    … …  
    2727#include "Common/utility.h"       // for CodeLocation
    2828#include "InitTweak/InitTweak.h"  // for getFunction
    29 #include "SynTree/LinkageSpec.h"  // for Spec, C, Intrinsic
     29#include "Parser/LinkageSpec.h"   // for Spec, C, Intrinsic
    3030#include "SynTree/Constant.h"     // for Constant
    3131#include "SynTree/Declaration.h"  // for StructDecl, DeclarationWithType
    … …  
    361361        const ast::TypeInstType * isTtype( const ast::Type * type ) {
    362362                if ( const ast::TypeInstType * inst = dynamic_cast< const ast::TypeInstType * >( type ) ) {
    363                         if ( inst->base && inst->base->kind == ast::TypeDecl::Ttype ) {
     363                        if ( inst->base && inst->base->kind == ast::TypeVar::Ttype ) {
    364364                                return inst;
    365365                        }

  • src/cfa.make

    rb7d6a36 rdca5802  
     1
     2
    13CFACOMPILE = $(CFACC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(CFAFLAGS) $(AM_CFLAGS) $(CFLAGS)
    24LTCFACOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
    … …  
    1921        $(am__mv) $$depbase.Tpo $$depbase.Plo
    2022
     23AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
     24am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
     25am__v_JAVAC_0 = @echo "  JAVAC   " $@;
     26am__v_JAVAC_1 =
     27
     28AM_V_GOC = $(am__v_GOC_@AM_V@)
     29am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
     30am__v_GOC_0 = @echo "  GOC     " $@;
     31am__v_GOC_1 =
     32
    2133UPPCC = u++
    2234UPPCOMPILE = $(UPPCC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_UPPFLAGS) $(UPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_CFLAGS) $(CFLAGS)
    … …  
    2638am__v_UPP_0 = @echo "  UPP     " $@;
    2739am__v_UPP_1 =
    28 
    29 AM_V_GOC = $(am__v_GOC_@AM_V@)
    30 am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
    31 am__v_GOC_0 = @echo "  GOC     " $@;
    32 am__v_GOC_1 =
    33 
    34 AM_V_PY = $(am__v_PY_@AM_V@)
    35 am__v_PY_ = $(am__v_PY_@AM_DEFAULT_V@)
    36 am__v_PY_0 = @echo "  PYTHON  " $@;
    37 am__v_PY_1 =
    38 
    39 AM_V_RUST = $(am__v_RUST_@AM_V@)
    40 am__v_RUST_ = $(am__v_RUST_@AM_DEFAULT_V@)
    41 am__v_RUST_0 = @echo "  RUST    " $@;
    42 am__v_RUST_1 =
    43 
    44 AM_V_NODEJS = $(am__v_NODEJS_@AM_V@)
    45 am__v_NODEJS_ = $(am__v_NODEJS_@AM_DEFAULT_V@)
    46 am__v_NODEJS_0 = @echo "  NODEJS  " $@;
    47 am__v_NODEJS_1 =
    48 
    49 AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
    50 am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
    51 am__v_JAVAC_0 = @echo "  JAVAC   " $@;
    52 am__v_JAVAC_1 =

  • src/main.cc

    rb7d6a36 rdca5802  
    1010// Created On       : Fri May 15 23:12:02 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Feb  8 08:33:50 2020
    13 // Update Count     : 633
     12// Last Modified On : Fri Aug 23 06:50:08 2019
     13// Update Count     : 607
    1414//
    1515
    … …  
    2020#include <cstdio>                           // for fopen, FILE, fclose, stdin
    2121#include <cstdlib>                          // for exit, free, abort, EXIT_F...
    22 #include <csignal>                          // for signal, SIGABRT, SIGSEGV
     22#include <csignal>                         // for signal, SIGABRT, SIGSEGV
    2323#include <cstring>                          // for index
    2424#include <fstream>                          // for ofstream
    … …  
    2828#include <list>                             // for list
    2929#include <string>                           // for char_traits, operator<<
    30 
    31 using namespace std;
    32 
    3330
    3431#include "CompilationState.h"
    … …  
    5653#include "InitTweak/GenInit.h"              // for genInit
    5754#include "MakeLibCfa.h"                     // for makeLibCfa
     55#include "Parser/LinkageSpec.h"             // for Spec, Cforall, Intrinsic
    5856#include "Parser/ParseNode.h"               // for DeclarationNode, buildList
    5957#include "Parser/TypedefTable.h"            // for TypedefTable
    … …  
    6159#include "ResolvExpr/Resolver.h"            // for resolve
    6260#include "SymTab/Validate.h"                // for validate
    63 #include "SynTree/LinkageSpec.h"            // for Spec, Cforall, Intrinsic
    6461#include "SynTree/Declaration.h"            // for Declaration
    6562#include "SynTree/Visitor.h"                // for acceptAll
    … …  
    6764#include "Virtual/ExpandCasts.h"            // for expandCasts
    6865
     66
     67using namespace std;
    6968
    7069static void NewPass( const char * const name ) {
    … …  
    9897static bool waiting_for_gdb = false;                                    // flag to set cfa-cpp to wait for gdb on start
    9998
    100 static string PreludeDirector = "";
     99static std::string PreludeDirector = "";
    101100
    102101static void parse_cmdline( int argc, char *argv[] );
    … …  
    105104
    106105static void backtrace( int start ) {                                    // skip first N stack frames
    107         enum { Frames = 50, };                                                          // maximum number of stack frames
     106        enum { Frames = 50 };
    108107        void * array[Frames];
    109         size_t size = ::backtrace( array, Frames );
     108        int size = ::backtrace( array, Frames );
    110109        char ** messages = ::backtrace_symbols( array, size ); // does not demangle names
    111110
    … …  
    114113
    115114        // skip last 2 stack frames after main
    116         for ( unsigned int i = start; i < size - 2 && messages != nullptr; i += 1 ) {
     115        for ( int i = start; i < size - 2 && messages != nullptr; i += 1 ) {
    117116                char * mangled_name = nullptr, * offset_begin = nullptr, * offset_end = nullptr;
    118 
    119                 for ( char * p = messages[i]; *p; p += 1 ) {    // find parantheses and +offset
     117                for ( char *p = messages[i]; *p; ++p ) {        // find parantheses and +offset
    120118                        if ( *p == '(' ) {
    121119                                mangled_name = p;
    … …  
    155153} // backtrace
    156154
    157 #define SIGPARMS int sig __attribute__(( unused )), siginfo_t * sfp __attribute__(( unused )), ucontext_t * cxt __attribute__(( unused ))
    158 
    159 static void Signal( int sig, void (*handler)(SIGPARMS), int flags ) {
    160         struct sigaction act;
    161 
    162         act.sa_sigaction = (void (*)(int, siginfo_t *, void *))handler;
    163         act.sa_flags = flags;
    164 
    165         if ( sigaction( sig, &act, nullptr ) == -1 ) {
    166             cerr << "*CFA runtime error* problem installing signal handler, error(" << errno << ") " << strerror( errno ) << endl;
    167             _exit( EXIT_FAILURE );
    168         } // if
    169 } // Signal
    170 
    171 static void sigSegvBusHandler( SIGPARMS ) {
    172         if ( sfp->si_addr == nullptr ) {
    173                 cerr << "Null pointer (nullptr) dereference." << endl;
    174         } else {
    175                 cerr << (sig == SIGSEGV ? "Segment fault" : "Bus error") << " at memory location " << sfp->si_addr << "." << endl
    176                          << "Possible cause is reading outside the address space or writing to a protected area within the address space with an invalid pointer or subscript." << endl;
    177         } // if
     155static void sigSegvBusHandler( int sig_num ) {
     156        cerr << "*CFA runtime error* program cfa-cpp terminated with "
     157                 <<     (sig_num == SIGSEGV ? "segment fault" : "bus error")
     158                 << "." << endl;
    178159        backtrace( 2 );                                                                         // skip first 2 stack frames
     160        //_exit( EXIT_FAILURE );
    179161        abort();                                                                                        // cause core dump for debugging
    180162} // sigSegvBusHandler
    181163
    182 static void sigFpeHandler( SIGPARMS ) {
    183         const char * msg;
    184 
    185         switch ( sfp->si_code ) {
    186           case FPE_INTDIV: case FPE_FLTDIV: msg = "divide by zero"; break;
    187           case FPE_FLTOVF: msg = "overflow"; break;
    188           case FPE_FLTUND: msg = "underflow"; break;
    189           case FPE_FLTRES: msg = "inexact result"; break;
    190           case FPE_FLTINV: msg = "invalid operation"; break;
    191           default: msg = "unknown";
    192         } // choose
    193         cerr << "Computation error " << msg << " at location " << sfp->si_addr << endl
    194                  << "Possible cause is constant-expression evaluation invalid." << endl;
    195         backtrace( 2 );                                                                         // skip first 2 stack frames
    196         abort();                                                                                        // cause core dump for debugging
    197 } // sigFpeHandler
    198 
    199 static void sigAbortHandler( SIGPARMS ) {
     164static void sigAbortHandler( __attribute__((unused)) int sig_num ) {
    200165        backtrace( 6 );                                                                         // skip first 6 stack frames
    201         Signal( SIGABRT, (void (*)(SIGPARMS))SIG_DFL, SA_SIGINFO );     // reset default signal handler
     166        signal( SIGABRT, SIG_DFL);                                                      // reset default signal handler
    202167        raise( SIGABRT );                                                                       // reraise SIGABRT
    203168} // sigAbortHandler
    … …  
    208173        list< Declaration * > translationUnit;
    209174
    210         Signal( SIGSEGV, sigSegvBusHandler, SA_SIGINFO );
    211         Signal( SIGBUS, sigSegvBusHandler, SA_SIGINFO );
    212         Signal( SIGFPE, sigFpeHandler, SA_SIGINFO );
    213         Signal( SIGABRT, sigAbortHandler, SA_SIGINFO );
    214 
    215         // cout << "main" << endl;
     175        signal( SIGSEGV, sigSegvBusHandler );
     176        signal( SIGBUS, sigSegvBusHandler );
     177        signal( SIGABRT, sigAbortHandler );
     178
     179        // std::cout << "main" << std::endl;
    216180        // for ( int i = 0; i < argc; i += 1 ) {
    217         //      cout << '\t' << argv[i] << endl;
     181        //      std::cout << '\t' << argv[i] << std::endl;
    218182        // } // for
    219183
    … …  
    222186
    223187        if ( waiting_for_gdb ) {
    224                 cerr << "Waiting for gdb" << endl;
    225                 cerr << "run :" << endl;
    226                 cerr << "  gdb attach " << getpid() << endl;
     188                std::cerr << "Waiting for gdb" << std::endl;
     189                std::cerr << "run :" << std::endl;
     190                std::cerr << "  gdb attach " << getpid() << std::endl;
    227191                raise(SIGSTOP);
    228192        } // if
    … …  
    424388                return EXIT_FAILURE;
    425389        } catch ( ... ) {
    426                 exception_ptr eptr = current_exception();
     390                std::exception_ptr eptr = std::current_exception();
    427391                try {
    428392                        if (eptr) {
    429                                 rethrow_exception(eptr);
     393                                std::rethrow_exception(eptr);
    430394                        } else {
    431                                 cerr << "Exception Uncaught and Unknown" << endl;
    432                         } // if
    433                 } catch(const exception& e) {
    434                         cerr << "Uncaught Exception \"" << e.what() << "\"\n";
     395                                std::cerr << "Exception Uncaught and Unknown" << std::endl;
     396                        } // if
     397                } catch(const std::exception& e) {
     398                        std::cerr << "Uncaught Exception \"" << e.what() << "\"\n";
    435399                } // try
    436400                return EXIT_FAILURE;

  • tests/.expect/alloc-ERROR.txt

    rb7d6a36 rdca5802  
    1 alloc.cfa:310:1 error: No reasonable alternatives for expression Applying untyped:
     1alloc.cfa:311:1 error: No reasonable alternatives for expression Applying untyped:
    22  Name: ?=?
    33...to:
    … …  
    1919
    2020
    21 alloc.cfa:311:1 error: No reasonable alternatives for expression Applying untyped:
     21alloc.cfa:312:1 error: No reasonable alternatives for expression Applying untyped:
    2222  Name: ?=?
    2323...to:
    … …  
    3939
    4040
    41 alloc.cfa:312:1 error: No reasonable alternatives for expression Applying untyped:
     41alloc.cfa:313:1 error: No reasonable alternatives for expression Applying untyped:
    4242  Name: ?=?
    4343...to:
    … …  
    5050
    5151
    52 alloc.cfa:313:1 error: No reasonable alternatives for expression Applying untyped:
     52alloc.cfa:314:1 error: No reasonable alternatives for expression Applying untyped:
    5353  Name: ?=?
    5454...to:

  • tests/.expect/alloc.txt

    rb7d6a36 rdca5802  
    22CFA malloc 0xdeadbeef
    33CFA alloc 0xdeadbeef
     4CFA array alloc, fill 0xde
    45CFA alloc, fill dededede
    56CFA alloc, fill 3

  • tests/.expect/loopctrl.txt

    rb7d6a36 rdca5802  
    66A
    77A A A A A A A A A A
    8 A A A A A A A A A A A
    98B B B B B
    109C C C C C
    … …  
    1312
    14130 1 2 3 4 5 6 7 8 9
    15 0 1 2 3 4 5 6 7 8 9 10
    16141 3 5 7 9
    171510 8 6 4 2
    … …  
    3028N N N N N N N N N N
    31290 1 2 3 4 5 6 7 8 9
    32 0 1 2 3 4 5 6 7 8 9 10
    333010 9 8 7 6 5 4 3 2 1
    3431

  • tests/.expect/nested-types-ERR1.txt

    rb7d6a36 rdca5802  
    1 nested-types.cfa:83:1 error: Use of undefined type T
     1nested-types.cfa:70:1 error: Use of undefined type T

  • tests/.expect/nested-types-ERR2.txt

    rb7d6a36 rdca5802  
    1 nested-types.cfa:86:1 error: Use of undefined global type Z
    2 nested-types.cfa:87:1 error: Qualified type requires an aggregate on the left, but has: signed int
    3 nested-types.cfa:88:1 error: Undefined type in qualified type: Qualified Type:
     1nested-types.cfa:73:1 error: Use of undefined global type Z
     2nested-types.cfa:74:1 error: Qualified type requires an aggregate on the left, but has: signed int
     3nested-types.cfa:75:1 error: Undefined type in qualified type: Qualified Type:
    44  instance of struct S with body 1
    55  instance of type Z (not function type)

  • tests/.expect/rational.txt

    rb7d6a36 rdca5802  
    11constructor
    2 3/1 4/1 0/1 0/1 1/1
     23/1 4/1 0/1
    331/2 5/7
    442/3 -3/2

  • tests/.expect/time.txt

    rb7d6a36 rdca5802  
    1818Dividing that by 2 gives 2403.5 seconds
    19194807 seconds is 1 hours, 20 minutes, 7 seconds
    20 2020 Jan  5 14:01:40 (GMT)
    21 1970 Jan  5 14:00:00 (GMT)
    22 1973 Jan  2 06:59:00 (GMT)

  • tests/Makefile.in

    rb7d6a36 rdca5802  
    364364am__v_CFA_0 = @echo "  CFA     " $@;
    365365am__v_CFA_1 =
     366AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
     367am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
     368am__v_JAVAC_0 = @echo "  JAVAC   " $@;
     369am__v_JAVAC_1 =
     370AM_V_GOC = $(am__v_GOC_@AM_V@)
     371am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
     372am__v_GOC_0 = @echo "  GOC     " $@;
     373am__v_GOC_1 =
    366374UPPCC = u++
    367375UPPCOMPILE = $(UPPCC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_UPPFLAGS) $(UPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_CFLAGS) $(CFLAGS)
    … …  
    370378am__v_UPP_0 = @echo "  UPP     " $@;
    371379am__v_UPP_1 =
    372 AM_V_GOC = $(am__v_GOC_@AM_V@)
    373 am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
    374 am__v_GOC_0 = @echo "  GOC     " $@;
    375 am__v_GOC_1 =
    376 AM_V_PY = $(am__v_PY_@AM_V@)
    377 am__v_PY_ = $(am__v_PY_@AM_DEFAULT_V@)
    378 am__v_PY_0 = @echo "  PYTHON  " $@;
    379 am__v_PY_1 =
    380 AM_V_RUST = $(am__v_RUST_@AM_V@)
    381 am__v_RUST_ = $(am__v_RUST_@AM_DEFAULT_V@)
    382 am__v_RUST_0 = @echo "  RUST    " $@;
    383 am__v_RUST_1 =
    384 AM_V_NODEJS = $(am__v_NODEJS_@AM_V@)
    385 am__v_NODEJS_ = $(am__v_NODEJS_@AM_DEFAULT_V@)
    386 am__v_NODEJS_0 = @echo "  NODEJS  " $@;
    387 am__v_NODEJS_1 =
    388 AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
    389 am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
    390 am__v_JAVAC_0 = @echo "  JAVAC   " $@;
    391 am__v_JAVAC_1 =
    392380debug = yes
    393381installed = no

  • tests/alloc.cfa

    rb7d6a36 rdca5802  
    1010// Created On       : Wed Feb  3 07:56:22 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Feb 16 09:21:13 2020
    13 // Update Count     : 405
     12// Last Modified On : Fri Nov 22 15:34:19 2019
     13// Update Count     : 404
    1414//
    1515
    … …  
    4848
    4949        p = alloc_set( fill );                                                          // CFA alloc, fill
     50        printf( "CFA array alloc, fill %#hhx\n", fill );
    5051        printf( "CFA alloc, fill %08x\n", *p );
    5152        free( p );

  • tests/concurrent/examples/boundedBufferEXT.cfa

    rb7d6a36 rdca5802  
    1010// Created On       : Wed Apr 18 22:52:12 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jan 16 22:36:34 2020
    13 // Update Count     : 15
     12// Last Modified On : Fri Jun 21 08:19:20 2019
     13// Update Count     : 14
    1414//
    1515
    … …  
    3737
    3838        void insert( Buffer(T) & mutex buffer, T elem ) with( buffer ) {
    39                 if ( count == BufferSize ) waitfor( remove : buffer );
     39                if ( count == BufferSize ) waitfor( remove, buffer );
    4040                elements[back] = elem;
    4141                back = ( back + 1 ) % BufferSize;
    … …  
    4444
    4545        T remove( Buffer(T) & mutex buffer ) with( buffer ) {
    46                 if ( count == 0 ) waitfor( insert : buffer );
     46                if ( count == 0 ) waitfor( insert, buffer );
    4747                T elem = elements[front];
    4848                front = ( front + 1 ) % BufferSize;

  • tests/concurrent/examples/boundedBufferTHREAD.cfa

    rb7d6a36 rdca5802  
    1010// Created On       : Wed Apr 18 22:52:12 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jan 16 23:09:43 2020
    13 // Update Count     : 25
     12// Last Modified On : Fri Jun 21 11:50:12 2019
     13// Update Count     : 24
    1414//
    1515
    … …  
    4444        void main( Buffer & buffer ) with( buffer ) {
    4545                for () {
    46                         waitfor( ^?{} : buffer ) {
     46                        waitfor( ^?{}, buffer ) {
    4747                                break;
    48                         } or when ( count != 20 ) waitfor( insert : buffer ) {
     48                        } or when ( count != 20 ) waitfor( insert, buffer ) {
    4949                                back = (back + 1) % 20;
    5050                                count += 1;
    51                         } or when ( count != 0 ) waitfor( remove : buffer ) {
     51                        } or when ( count != 0 ) waitfor( remove, buffer ) {
    5252                                front = (front + 1) % 20;
    5353                                count -= 1;

  • tests/concurrent/examples/gortn.cfa

    rb7d6a36 rdca5802  
    1010// Created On       : Wed Feb 20 08:02:37 2019
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jan 16 22:43:40 2020
    13 // Update Count     : 5
     12// Last Modified On : Fri Jun 21 08:25:03 2019
     13// Update Count     : 4
    1414//
    1515
    … …  
    2626void main( GoRtn & gortn ) with( gortn ) {
    2727        for () {
    28                 waitfor( mem1 : gortn ) sout | i;
    29                 or waitfor( mem2 : gortn ) sout | f;
    30                 or waitfor( mem3 : gortn ) sout | m.i | m.j;
    31                 or waitfor( ^?{} : gortn ) break;
     28                waitfor( mem1, gortn ) sout | i;
     29                or waitfor( mem2, gortn ) sout | f;
     30                or waitfor( mem3, gortn ) sout | m.i | m.j;
     31                or waitfor( ^?{}, gortn ) break;
    3232        }
    3333}

  • tests/concurrent/examples/quickSort.cfa

    rb7d6a36 rdca5802  
    1111// Created On       : Wed Dec  6 12:15:52 2017
    1212// Last Modified By : Peter A. Buhr
    13 // Last Modified On : Wed Feb 12 18:24:47 2020
    14 // Update Count     : 177
     13// Last Modified On : Thu Oct 10 13:58:18 2019
     14// Update Count     : 176
    1515//
    1616
    … …  
    2727
    2828void ?{}( Quicksort & qs, int values[], int size, int depth ) {
    29         qs.[values, low, high, depth] = [values, 0, size, depth];
     29        qs.values = values;  qs.low = 0;  qs.high = size;  qs.depth = depth;
    3030} // Quicksort
    3131
    … …  
    167167                        values[counter] = size - counter;                       // descending values
    168168                } // for
    169                 for ( i; 200 ) {                                                                // random shuffle a few values
     169                for ( int i = 0; i < 200; i +=1 ) {                             // random shuffle a few values
    170170                        swap( values[rand() % size], values[rand() % size] );
    171171                } // for

  • tests/concurrent/waitfor/barge.cfa

    rb7d6a36 rdca5802  
    6565                yield(random( 10 ));
    6666                this.state = WAITFOR;
    67                 waitfor(do_call : this) {
     67                waitfor(do_call, this) {
    6868                        sout | i;
    6969                }

  • tests/concurrent/waitfor/dtor.cfa

    rb7d6a36 rdca5802  
    4747        yield(random( 10 ));
    4848        set_state( this, MAIN );
    49         waitfor( ^?{} : this ) {
     49        waitfor( ^?{}, this ) {
    5050                set_state( this, AFTER );
    5151        }

  • tests/concurrent/waitfor/else.cfa

    rb7d6a36 rdca5802  
    1414        sout | "Starting";
    1515
    16         when( false ) waitfor( notcalled : m );
     16        when( false ) waitfor( notcalled, m );
    1717
    1818        sout | "Step" | i++;
    1919
    20         waitfor( notcalled : m ); or else {
     20        waitfor( notcalled, m ); or else {
    2121                sout | "else called";
    2222        }
    … …  
    2424        sout | "Step" | i++;
    2525
    26         when( true ) waitfor( notcalled : m ); or when( true ) else {
     26        when( true ) waitfor( notcalled, m ); or when( true ) else {
    2727                sout | "else called";
    2828        }
    … …  
    3030        sout | "Step" | i++;
    3131
    32         when( false ) waitfor( notcalled : m ); or when( true ) else {
     32        when( false ) waitfor( notcalled, m ); or when( true ) else {
    3333                sout | "else called";
    3434        }
    … …  
    3636        sout | "Step" | i++;
    3737
    38         when( false ) waitfor( notcalled : m ); or when( false ) else {
     38        when( false ) waitfor( notcalled, m ); or when( false ) else {
    3939                sout | "else called";
    4040        }

  • tests/concurrent/waitfor/parse.cfa

    rb7d6a36 rdca5802  
    2424
    2525        //---------------------------------------
    26         waitfor( f1 : a ) {
     26        waitfor( f1, a ) {
    2727                1;
    2828        }
    2929
    3030        //---------------------------------------
    31         waitfor( f1 : a ) {
     31        waitfor( f1, a ) {
    3232                2;
    3333        }
    34         waitfor( f2 : a ) {
     34        waitfor( f2, a ) {
    3535                3;
    3636        }
    3737
    3838        //---------------------------------------
    39         when( 1 < 3 ) waitfor( f2 : a, a ) {
     39        when( 1 < 3 ) waitfor( f2, a, a ) {
    4040                4;
    4141        }
    … …  
    4545
    4646        //---------------------------------------
    47         when( 2 < 3 ) waitfor( f3 : a ) {
     47        when( 2 < 3 ) waitfor( f3, a ) {
    4848                5;
    4949        }
    … …  
    5353
    5454        //---------------------------------------
    55         when( 3 < 3 ) waitfor( f3 : a, a ) {
     55        when( 3 < 3 ) waitfor( f3, a, a ) {
    5656                7;
    5757        }
    … …  
    6464
    6565        //---------------------------------------
    66         when( 6 < 3 ) waitfor( f3 : a, a, a ) {
     66        when( 6 < 3 ) waitfor( f3, a, a, a ) {
    6767                10;
    6868        }
    69         or when( 7 < 3 ) waitfor( f1 : a  ) {
     69        or when( 7 < 3 ) waitfor( f1, a  ) {
    7070                11;
    7171        }
    … …  
    7575
    7676        //---------------------------------------
    77         when( 8 < 3 ) waitfor( f3 : a, a ) {
     77        when( 8 < 3 ) waitfor( f3, a, a ) {
    7878                13;
    7979        }
    80         or waitfor( f1 : a  ) {
     80        or waitfor( f1, a  ) {
    8181                14;
    8282        }
    … …  
    8686
    8787        //---------------------------------------
    88         when( 10 < 3 ) waitfor( f1 : a ) {
     88        when( 10 < 3 ) waitfor( f1, a ) {
    8989                16;
    9090        }
    91         or waitfor( f2 : a, a ) {
     91        or waitfor( f2, a, a ) {
    9292                17;
    9393        }
    … …  
    100100}
    101101
    102 int main() {}
     102int main() {
     103
     104}

  • tests/concurrent/waitfor/parse2.cfa

    rb7d6a36 rdca5802  
    1010// Created On       : Wed Aug 30 17:53:29 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jan 16 23:13:37 2020
    13 // Update Count     : 6
     12// Last Modified On : Fri Mar 22 13:42:11 2019
     13// Update Count     : 3
    1414//
    1515
    … …  
    2626        }
    2727
    28         waitfor( x : z ) {
     28        waitfor( x, z ) {
    2929        }
    3030
    … …  
    3737        or waitfor( y );
    3838
    39         waitfor( x : z );
     39        waitfor( x, z );
    4040        or waitfor( y );
    4141
    … …  
    4343        or when( true ) waitfor( y );
    4444
    45         when( true ) waitfor( x : z );
     45        when( true ) waitfor( x, z );
    4646        or when( true ) waitfor( y );
    4747
    … …  
    5050        }
    5151
    52         waitfor( x : z ) {
     52        waitfor( x, z ) {
    5353        } or waitfor( y ) {
    5454        }
    … …  
    8080        or else;
    8181
    82         when( true ) waitfor( x : z );
     82        when( true ) waitfor( x, z );
    8383        or else;
    8484
    … …  
    9999        }
    100100
    101         when( true ) waitfor( x : z );
     101        when( true ) waitfor( x, z );
    102102        or else {
    103103        }
    … …  
    115115        or when( true ) else;
    116116
    117         when( true ) waitfor( x : z );
     117        when( true ) waitfor( x, z );
    118118        or when( true ) else;
    119119
    … …  
    134134        }
    135135
    136         when( true ) waitfor( x : z );
     136        when( true ) waitfor( x, z );
    137137        or when( true ) else {
    138138        }
    … …  
    149149        or timeout( 3 );
    150150
    151         waitfor( x : z );
     151        waitfor( x, z );
    152152        or timeout( 3 );
    153153
    … …  
    163163        }
    164164
    165         when( true ) waitfor( x : z ) {
     165        when( true ) waitfor( x, z ) {
    166166        } or timeout( 3 ) {
    167167        }
    … …  
    171171        }
    172172
    173         when( true ) waitfor( x : z ) {
     173        when( true ) waitfor( x, z ) {
    174174        } or when ( true ) timeout( 3 ) {
    175175        }
    … …  
    229229
    230230        int or, timeout;
    231         waitfor( timeout : 7 ) 3;
    232         waitfor( timeout : 7 ) 3; or waitfor( timeout : 7 ) 3;
    233         when( or ) waitfor( or : ) { 4; } or timeout( 1 ) 3;
    234         when( 3 ) waitfor( or : 2 ) 4; or else 4;
    235         when( 3 ) waitfor( or : 3 ) 4; or when( or ) timeout( or ) 4; or when( or ) else timeout;
    236         when( 3 ) waitfor( or : or ) 3; or when( or ) waitfor( or : timeout ) 4; or else 4;
    237         when( 3 ) waitfor( or : or ) 3; or waitfor( or : 9 ) 4; or when( or ) timeout( timeout ) 4;
    238         when( 3 ) waitfor( or : 3 ) 3; or waitfor( or : 7 ) or; or timeout( 1 ) or; or when( 3 ) else or;
     231        waitfor( timeout, 7 ) 3;
     232        waitfor( timeout, 7 ) 3; or waitfor( timeout, 7 ) 3;
     233        when( or ) waitfor( or, ) { 4; } or timeout( 1 ) 3;
     234        when( 3 ) waitfor( or, 2 ) 4; or else 4;
     235        when( 3 ) waitfor( or, 3 ) 4; or when( or ) timeout( or ) 4; or when( or ) else timeout;
     236        when( 3 ) waitfor( or, or ) 3; or when( or ) waitfor( or, timeout ) 4; or else 4;
     237        when( 3 ) waitfor( or, or ) 3; or waitfor( or, 9 ) 4; or when( or ) timeout( timeout ) 4;
     238        when( 3 ) waitfor( or, 3 ) 3; or waitfor( or, 7 ) or; or timeout( 1 ) or; or when( 3 ) else or;
    239239
    240240        // test else selection

  • tests/concurrent/waitfor/recurse.cfa

    rb7d6a36 rdca5802  
    6666
    6767        rand_yield();
    68         waitfor( call4 : this );
     68        waitfor( call4, this );
    6969        rand_yield();
    7070
    … …  
    7878
    7979        rand_yield();
    80         waitfor( call3 : this );
     80        waitfor( call3, this );
    8181        rand_yield();
    8282
    … …  
    9292
    9393        rand_yield();
    94         waitfor( call2 : this );
     94        waitfor( call2, this );
    9595        rand_yield();
    9696

  • tests/concurrent/waitfor/statment.cfa

    rb7d6a36 rdca5802  
    101101
    102102        while( !done ) {
    103                    waitfor( get_index : this );
    104                 or waitfor( call1 : this ) { sout | "Statement"; if( this.last_val != 1 ) { serr | "Incorrect index: expected" | 1 | "got" | this.last_val; } }
    105                 or waitfor( call2 : this ) { sout | "Statement"; if( this.last_val != 2 ) { serr | "Incorrect index: expected" | 2 | "got" | this.last_val; } }
    106                 or waitfor( call3 : this ) { sout | "Statement"; if( this.last_val != 3 ) { serr | "Incorrect index: expected" | 3 | "got" | this.last_val; } }
    107                 or waitfor( call4 : this ) { sout | "Statement"; if( this.last_val != 4 ) { serr | "Incorrect index: expected" | 4 | "got" | this.last_val; } }
    108                 or waitfor( call5 : this ) { sout | "Statement"; if( this.last_val != 5 ) { serr | "Incorrect index: expected" | 5 | "got" | this.last_val; } }
    109                 or waitfor( call6 : this ) { sout | "Statement"; if( this.last_val != 6 ) { serr | "Incorrect index: expected" | 6 | "got" | this.last_val; } }
    110                 or waitfor( call7 : this ) { sout | "Statement"; if( this.last_val != 7 ) { serr | "Incorrect index: expected" | 7 | "got" | this.last_val; } }
     103                   waitfor( get_index, this );
     104                or waitfor( call1, this ) { sout | "Statement"; if( this.last_val != 1 ) { serr | "Incorrect index: expected" | 1 | "got" | this.last_val; } }
     105                or waitfor( call2, this ) { sout | "Statement"; if( this.last_val != 2 ) { serr | "Incorrect index: expected" | 2 | "got" | this.last_val; } }
     106                or waitfor( call3, this ) { sout | "Statement"; if( this.last_val != 3 ) { serr | "Incorrect index: expected" | 3 | "got" | this.last_val; } }
     107                or waitfor( call4, this ) { sout | "Statement"; if( this.last_val != 4 ) { serr | "Incorrect index: expected" | 4 | "got" | this.last_val; } }
     108                or waitfor( call5, this ) { sout | "Statement"; if( this.last_val != 5 ) { serr | "Incorrect index: expected" | 5 | "got" | this.last_val; } }
     109                or waitfor( call6, this ) { sout | "Statement"; if( this.last_val != 6 ) { serr | "Incorrect index: expected" | 6 | "got" | this.last_val; } }
     110                or waitfor( call7, this ) { sout | "Statement"; if( this.last_val != 7 ) { serr | "Incorrect index: expected" | 7 | "got" | this.last_val; } }
    111111
    112112                done = true;

  • tests/concurrent/waitfor/when.cfa

    rb7d6a36 rdca5802  
    6262
    6363        for( int i = 0; i < N; i++ ) {
    64                    when( this.last_call == 6 ) waitfor( call1 : this ) { if( this.last_call != 1) { serr | "Expected last_call to be 1 got" | this.last_call; } }
    65                 or when( this.last_call == 1 ) waitfor( call2 : this ) { if( this.last_call != 2) { serr | "Expected last_call to be 2 got" | this.last_call; } }
    66                 or when( this.last_call == 2 ) waitfor( call3 : this ) { if( this.last_call != 3) { serr | "Expected last_call to be 3 got" | this.last_call; } }
    67                 or when( this.last_call == 3 ) waitfor( call4 : this ) { if( this.last_call != 4) { serr | "Expected last_call to be 4 got" | this.last_call; } }
    68                 or when( this.last_call == 4 ) waitfor( call5 : this ) { if( this.last_call != 5) { serr | "Expected last_call to be 5 got" | this.last_call; } }
    69                 or when( this.last_call == 5 ) waitfor( call6 : this ) { if( this.last_call != 6) { serr | "Expected last_call to be 6 got" | this.last_call; } }
     64                   when( this.last_call == 6 ) waitfor( call1, this ) { if( this.last_call != 1) { serr | "Expected last_call to be 1 got" | this.last_call; } }
     65                or when( this.last_call == 1 ) waitfor( call2, this ) { if( this.last_call != 2) { serr | "Expected last_call to be 2 got" | this.last_call; } }
     66                or when( this.last_call == 2 ) waitfor( call3, this ) { if( this.last_call != 3) { serr | "Expected last_call to be 3 got" | this.last_call; } }
     67                or when( this.last_call == 3 ) waitfor( call4, this ) { if( this.last_call != 4) { serr | "Expected last_call to be 4 got" | this.last_call; } }
     68                or when( this.last_call == 4 ) waitfor( call5, this ) { if( this.last_call != 5) { serr | "Expected last_call to be 5 got" | this.last_call; } }
     69                or when( this.last_call == 5 ) waitfor( call6, this ) { if( this.last_call != 6) { serr | "Expected last_call to be 6 got" | this.last_call; } }
    7070
    7171                sout | this.last_call;

  • tests/expression.cfa

    rb7d6a36 rdca5802  
    1 struct S { int i; };
    2 void ?{}( S & s, int i ) { s.i = i; }
    3 int ?`mary( int );
    4 int ?`mary( S );
    5 [int] ?`mary( [int, int] );
    6 int & ?`jane( int & );
    7 int jack( int );
    8 
    91int main() {
    10     int a[3] = { 0, 0, 0 };
    11     S s = { 3 }, * ps = &s;
    12     [int] t = { 3 };
    13     * [int] pt = &t;
    14     int i = 1, j = 2;
     2    struct s { int i; } x, *p = &x;
     3    int i = 3;
    154
    165    // operators
    176
    18     !i;
     7    ! i;
    198    ~i;
    209    +i;
    2110    -i;
    22     *ps;
    23     ++ps;
    24     --ps;
    25     ps++;
    26     ps--;
     11    *p;
     12    ++p;
     13    --p;
     14    p++;
     15    p--;
    2716
    28     i + j;
    29     i - j;
    30     i * j;
     17    i+i;
     18    i-i;
     19    i*i;
    3120
    32     i / j;
    33     i % j;
    34     i ^ j;
    35     i & j;
    36     i | j;
    37     i < j;
    38     i > j;
    39     i = j;
     21    i/i;
     22    i%i;
     23    i^i;
     24    i&i;
     25    i|i;
     26    i<i;
     27    i>i;
     28    i=i;
    4029
    41     i == j;
    42     i != j;
    43     i << j;
    44     i >> j;
    45     i <= j;
    46     i >= j;
    47     i && j;
    48     i || j;
    49     ps->i;
     30    i==i;
     31    i!=i;
     32    i<<i;
     33    i>>i;
     34    i<=i;
     35    i>=i;
     36    i&&i;
     37    i||i;
     38    p->i;
     39    i*=i;
     40    i/=i;
     41    i%=i;
     42    i+=i;
     43    i-=i;
     44    i&=i;
     45    i|=i;
     46    i^=i;
     47    i<<=i;
     48    i>>=i;
    5049
    51     i *= j;
    52     i /= j;
    53     i %= j;
    54     i += j;
    55     i -= j;
    56     i &= j;
    57     i |= j;
    58     i ^= j;
    59     i <<= j;
    60     i >>= j;
    61 
    62     i ? i : j;
    63 
    64     // postfix function call
    65 
    66     (3 + 4)`mary;
    67     ({3 + 4;})`mary;
    68     [3, 4]`mary;
    69     3`mary;
    70     a[0]`mary;
    71     a[0]`mary`mary;
    72     s{0}`mary;
    73     a[3]`jane++;
    74     jack(3)`mary;
    75     s.i`mary;
    76     t.0`mary;
    77     s.[i]`mary;
    78     ps->i`mary;
    79     pt->0`mary;
    80     ps->[i]`mary;
    81     i++`mary;
    82     i--`mary;
    83     (S){2}`mary;
    84     (S)@{2}`mary;
     50    i?i:i;
    8551} // main

  • tests/labelledExit.cfa

    rb7d6a36 rdca5802  
    1010// Created On       : Wed Aug 10 07:29:39 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb  5 16:49:48 2020
    13 // Update Count     : 9
     12// Last Modified On : Fri Oct 25 17:41:51 2019
     13// Update Count     : 7
    1414//
    1515
    … …  
    162162
    163163        // computed goto
    164         {
    165                 void *array[] = { &&foo, &&bar, &&hack };
    166           foo: bar: hack:
    167                 &&foo;
    168                 &&bar;
    169                 goto *array[i];
    170         }
     164        // {
     165        //      void *array[] = { &&foo, &&bar, &&hack };
     166        //   foo: bar: hack:
     167        //      &&foo;
     168        //      &&bar;
     169        //      goto *array[i];
     170        // }
    171171
    172172  Q: if ( i > 5 ) {

  • tests/loopctrl.cfa

    rb7d6a36 rdca5802  
    1010// Created On       : Wed Aug  8 18:32:59 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Dec 12 17:55:26 2019
    13 // Update Count     : 108
     12// Last Modified On : Fri Jul 12 12:05:05 2019
     13// Update Count     : 106
    1414//
    1515
    … …  
    4343        for ( 1 ) { sout | "A"; }                                                       sout | nl;
    4444        for ( 10 ) { sout | "A"; }                                                      sout | nl;
    45         for ( = 10 ) { sout | "A"; }                                            sout | nl;
    4645        for ( 1 ~= 10 ~ 2 ) { sout | "B"; }                                     sout | nl;
    4746        for ( 10 -~= 1 ~ 2 ) { sout | "C"; }                            sout | nl;
    … …  
    5049
    5150        for ( i; 10 ) { sout | i; }                                                     sout | nl;
    52         for ( i; = 10 ) { sout | i; }                                           sout | nl;
    5351        for ( i; 1 ~= 10 ~ 2 ) { sout | i; }                            sout | nl;
    5452        for ( i; 10 -~= 1 ~ 2 ) { sout | i; }                           sout | nl;
    … …  
    8987        for ( N ) { sout | "N"; }                                                       sout | nl;
    9088        for ( i; N ) { sout | i; }                                                      sout | nl;
    91         for ( i; = N ) { sout | i; }                                            sout | nl;
    9289        for ( i; N -~ 0 ) { sout | i; }                                         sout | nl | nl;
    9390

  • tests/nested-types.cfa

    rb7d6a36 rdca5802  
    1010// Created On       : Mon Jul 9 10:20:03 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb 12 18:21:15 2020
    13 // Update Count     : 3
     12// Last Modified On : Tue Nov  6 17:59:40 2018
     13// Update Count     : 2
    1414//
    1515
    … …  
    5050//   double d;
    5151// };
    52 
    53 // struct S {
    54 //     enum C { R, G, B };
    55 //     int i;
    56 //     struct T {
    57 //      int i;
    58 //     };
    59 //     T t;
    60 // };
    61 
    62 // S s;
    63 // S.C c;
    64 // S.T t;
    6552
    6653int main() {

  • tests/pybin/tools.py

    rb7d6a36 rdca5802  
    175175
    176176def which(program):
    177         fpath, fname = os.path.split(program)
    178         if fpath:
    179                 if is_exe(program):
    180                         return program
    181         else:
    182                 for path in os.environ["PATH"].split(os.pathsep):
    183                         exe_file = os.path.join(path, program)
    184                         if is_exe(exe_file):
    185                                 return exe_file
    186         return None
     177    fpath, fname = os.path.split(program)
     178    if fpath:
     179        if is_exe(program):
     180            return program
     181    else:
     182        for path in os.environ["PATH"].split(os.pathsep):
     183            exe_file = os.path.join(path, program)
     184            if is_exe(exe_file):
     185                return exe_file
     186
     187    return None
    187188
    188189@contextlib.contextmanager
    … …  
    364365
    365366class Timed:
    366         def __enter__(self):
    367                 self.start = time.time()
    368                 return self
    369 
    370         def __exit__(self, *args):
    371                 self.end = time.time()
    372                 self.duration = self.end - self.start
     367    def __enter__(self):
     368        self.start = time.time()
     369        return self
     370
     371    def __exit__(self, *args):
     372        self.end = time.time()
     373        self.duration = self.end - self.start
    373374
    374375def timed(src, timeout):
    375376        expire = time.time() + timeout
    376377        i = iter(src)
    377         with contextlib.suppress(StopIteration):
    378                 while True:
    379                         yield i.next(max(expire - time.time(), 0))
     378        while True:
     379                yield i.next(max(expire - time.time(), 0))

  • tests/quotedKeyword.cfa

    rb7d6a36 rdca5802  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Feb  7 19:07:07 2020
    13 // Update Count     : 25
     12// Last Modified On : Tue Dec  4 21:45:53 2018
     13// Update Count     : 23
    1414//
    1515
    … …  
    1717
    1818struct {
    19         int ``otype;
    20         int ``struct;
     19        int `otype`;
     20        int `struct`;
    2121} st = { 10, 10 };
    2222
    23 typedef int ``forall;
    24 ``forall xxx = 10;
     23typedef int `forall`;
     24`forall` xxx = 10;
    2525
    26 int ``_Alignas, ``_Alignof, ``__alignof, ``__alignof__, ``asm, ``__asm, ``__asm__, ``_At, ``_Atomic, ``__attribute,
    27         ``__attribute__, ``auto, ``_Bool, ``break, ``case, ``catch, ``catchResume, ``char, ``choose, ``_Complex, ``__complex,
    28         ``__complex__, ``const, ``__const, ``__const__, ``continue, ``default, ``disable, ``do, ``double, ``dtype, ``else,
    29         ``enable, ``enum, ``__extension__, ``extern, ``fallthru, ``finally, ``float, ``__float128, ``for, ``forall, ``fortran,
    30         ``ftype, ``_Generic, ``goto, ``if, ``_Imaginary, ``__imag, ``__imag__, ``inline, ``__inline, ``__inline__, ``int,
    31         ``__int128, ``__label__, ``long, ``lvalue, ``_Noreturn, ``__builtin_offsetof, ``otype, ``register, ``restrict,
    32         ``__restrict, ``__restrict__, ``return, ``short, ``signed, ``__signed, ``__signed__, ``sizeof, ``static,
    33         ``_Static_assert, ``struct, ``switch, ``_Thread_local, ``throw, ``throwResume, ``trait, ``try, ``typedef,
    34         ``typeof, ``__typeof, ``__typeof__, ``union, ``unsigned, ``__builtin_va_list, ``void, ``volatile, ``__volatile,
    35         ``__volatile__, ``while;
     26int `_Alignas`, `_Alignof`, `__alignof`, `__alignof__`, `asm`, `__asm`, `__asm__`, `_At`, `_Atomic`, `__attribute`,
     27        `__attribute__`, `auto`, `_Bool`, `break`, `case`, `catch`, `catchResume`, `char`, `choose`, `_Complex`, `__complex`,
     28        `__complex__`, `const`, `__const`, `__const__`, `continue`, `default`, `disable`, `do`, `double`, `dtype`, `else`,
     29        `enable`, `enum`, `__extension__`, `extern`, `fallthru`, `finally`, `float`, `__float128`, `for`, `forall`, `fortran`,
     30        `ftype`, `_Generic`, `goto`, `if`, `_Imaginary`, `__imag`, `__imag__`, `inline`, `__inline`, `__inline__`, `int`,
     31        `__int128`, `__label__`, `long`, `lvalue`, `_Noreturn`, `__builtin_offsetof`, `otype`, `register`, `restrict`,
     32        `__restrict`, `__restrict__`, `return`, `short`, `signed`, `__signed`, `__signed__`, `sizeof`, `static`,
     33        `_Static_assert`, `struct`, `switch`, `_Thread_local`, `throw`, `throwResume`, `trait`, `try`, `typedef`,
     34        `typeof`, `__typeof`, `__typeof__`, `union`, `unsigned`, `__builtin_va_list`, `void`, `volatile`, `__volatile`,
     35        `__volatile__`, `while`;
    3636
    3737int main() {
    38         int ``if = 0;
    39         ``catch = 1;
    40         st.``otype = 2;
    41         st.``struct = 3;
    42         ``throw = 4;
    43         sout | ``catch + st.``otype + st.``struct + ``throw;
     38        int `if` = 0;
     39        `catch` = 1;
     40        st.`otype` = 2;
     41        st.`struct` = 3;
     42        `throw` = 4;
     43        sout | `catch` + st.`otype` + st.`struct` + `throw`;
    4444}
    4545

  • tests/rational.cfa

    rb7d6a36 rdca5802  
    1010// Created On       : Mon Mar 28 08:43:12 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Feb  8 18:46:23 2020
    13 // Update Count     : 86
     12// Last Modified On : Wed Mar 27 07:37:17 2019
     13// Update Count     : 80
    1414//
    1515
    … …  
    1919#include <fstream.hfa>
    2020
    21 typedef Rational(int) RatInt;
    22 double convert( int i ) { return (double)i; }                   // used by narrow/widen
     21double convert( int i ) { return (double)i; }
    2322int convert( double d ) { return (int)d; }
    2423
    2524int main() {
    2625        sout | "constructor";
    27         RatInt a = { 3 }, b = { 4 }, c, d = 0, e = 1;
    28         sout | a | b | c | d | e;
     26        Rational(int) a = { 3 }, b = { 4 }, c;
     27        sout | a | b | c;
    2928
    30         a = (RatInt){ 4, 8 };
    31         b = (RatInt){ 5, 7 };
     29        a = (Rational(int)){ 4, 8 };
     30        b = (Rational(int)){ 5, 7 };
    3231        sout | a | b;
    33         a = (RatInt){ -2, -3 };
    34         b = (RatInt){ 3, -2 };
     32        a = (Rational(int)){ -2, -3 };
     33        b = (Rational(int)){ 3, -2 };
    3534        sout | a | b;
    36         a = (RatInt){ -2, 3 };
    37         b = (RatInt){ 3, 2 };
     35        a = (Rational(int)){ -2, 3 };
     36        b = (Rational(int)){ 3, 2 };
    3837        sout | a | b;
    3938
    4039        sout | "logical";
    41         a = (RatInt){ -2 };
    42         b = (RatInt){ -3, 2 };
     40        a = (Rational(int)){ -2 };
     41        b = (Rational(int)){ -3, 2 };
    4342        sout | a | b;
    4443//      sout | a == 1; // FIX ME
    … …  
    5958
    6059        sout | "conversion";
    61         a = (RatInt){ 3, 4 };
     60        a = (Rational(int)){ 3, 4 };
    6261        sout | widen( a );
    63         a = (RatInt){ 1, 7 };
     62        a = (Rational(int)){ 1, 7 };
    6463        sout | widen( a );
    65         a = (RatInt){ 355, 113 };
     64        a = (Rational(int)){ 355, 113 };
    6665        sout | widen( a );
    6766        sout | narrow( 0.75, 4 );
    … …  
    7574
    7675        sout | "more tests";
    77         RatInt x = { 1, 2 }, y = { 2 };
     76        Rational(int) x = { 1, 2 }, y = { 2 };
    7877        sout | x - y;
    7978        sout | x > y;
    … …  
    8180        sout | y | denominator( y, -2 ) | y;
    8281
    83         RatInt z = { 0, 5 };
     82        Rational(int) z = { 0, 5 };
    8483        sout | z;
    8584
    8685        sout | x | numerator( x, 0 ) | x;
    8786
    88         x = (RatInt){ 1, MAX } + (RatInt){ 1, MAX };
     87        x = (Rational(int)){ 1, MAX } + (Rational(int)){ 1, MAX };
    8988        sout | x;
    90         x = (RatInt){ 3, MAX } + (RatInt){ 2, MAX };
     89        x = (Rational(int)){ 3, MAX } + (Rational(int)){ 2, MAX };
    9190        sout | x;
    9291

  • tests/test.py

    rb7d6a36 rdca5802  
    152152        # run everything in a temp directory to make sure core file are handled properly
    153153        with tempdir():
    154                 # if the make command succeeds continue otherwise skip to diff
     154                # if the make command succeds continue otherwise skip to diff
    155155                if success(make_ret):
    156156                        with Timed() as run_dur:

  • tests/time.cfa

    rb7d6a36 rdca5802  
    1010// Created On       : Tue Mar 27 17:24:56 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Jan  5 18:27:37 2020
    13 // Update Count     : 34
     12// Last Modified On : Fri Nov 29 23:05:30 2019
     13// Update Count     : 24
    1414//
    1515
    … …  
    3434        sout | t;
    3535        t = t + d1;
    36         sout | t | t`ns;
     36        sout | t | t.tv;
    3737        Time t1 = (timespec){ 104_414, 10_000_000 };
    38         sout | t1 | t1`ns;
    39         sout | t - t  | t + d5 | t`ns;
    40         char buf[64];
     38        sout | t1 | t1.tv;
     39        sout | t - t  | t + d5 | t.tv;
     40        char buf[16];
    4141        sout | "yy/mm/dd" | [t, buf]`ymd | nonl;                        // shared buf => separate calls
    4242        sout | "mm/dd/yy" | mm_dd_yy( t, buf ) | nonl;
    … …  
    4545        sout | "dd/yy/mm" | [t, buf]`dmy;
    4646        Time t2 = { 2001, 7, 4, 0, 0, 1, 0 }, t3 = (timeval){ 994_219_201 };
    47         sout | t2 | t2`ns | nl | t3 | t3`ns;
     47        sout | t2 | t2.tv | nl | t3 | t3.tv;
    4848        sout | nl;
    4949
    … …  
    6262        sout | "Dividing that by 2 gives" | s / 2 | "seconds";
    6363        sout | s | "seconds is" | s`h | "hours," | (s % 1`h)`m | "minutes," | (s % 1`m)`s | "seconds";
    64 
    65     t1 = (Time){ 2020, 1, 5, 9, 0, 0, 100000000000LL };
    66     t2 = (Time){ 1969, 13, 5, 9 };
    67     t3 = (Time){ 1970, 25, 366, 48, 120, -120, 60000000000LL };
    68     strftime( buf, 128, "%Y %b %e %H:%M:%S (GMT)", t1 );
    69     sout | buf;
    70     strftime( buf, 128, "%Y %b %e %H:%M:%S (GMT)", t2 );
    71     sout | buf;
    72     strftime( buf, 128, "%Y %b %e %H:%M:%S (GMT)", t3 );
    73     sout | buf;
    7464} // main
    7565

  • tests/userLiterals.cfa

    rb7d6a36 rdca5802  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // userLiterals.cfa --
     7// user_literals.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Wed Sep  6 21:40:50 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb 19 07:48:45 2020
    13 // Update Count     : 74
     12// Last Modified On : Tue Dec  4 22:03:10 2018
     13// Update Count     : 56
    1414//
    1515
    … …  
    2424int ?`__thingy_( int x ) { sout | "_thingy_" | x; return x; }
    2525
    26 int ?`s( const char * s ) { sout | "s" | s; return 0; }
    27 int ?`m( const char16_t * m ) { sout | "m" | m; return 0;}
    28 int ?`h( const char32_t * h ) { sout | "h" | h; return 0; }
     26int ?`s( const char * s ) { sout | "secs" | s; return 0; }
     27int ?`m( const char16_t * m ) { sout | "mins" | m; return 0;}
     28int ?`h( const char32_t * h ) { sout | "hours" | h; return 0; }
    2929int ?`_A_( const wchar_t * str ) { sout | "_A_" | str; return 0; }
    3030int ?`__thingy_( const char * str ) { sout | "_thingy_" | str; return 0; }
    … …  
    3737        return (Weight){ l.stones + r.stones };
    3838}
    39 ofstream & ?|?( ofstream & os, Weight w ) { return os | wd(1,1, w.stones); }
    40 void ?|?( ofstream & os, Weight w ) { (ofstream)(os | w); ends( os ); }
     39ofstream & ?|?( ofstream & os, Weight w ) { return os | w.stones; }
    4140
    4241Weight ?`st( double w ) { return (Weight){ w }; }               // backquote for user literals
    … …  
    6160        sout | w;
    6261
    63         0`s;
     62//      0`secs;
    6463        1`s;
    6564        23`s;
    … …  
    8382
    8483        "abc"`s;
    85         // FIX ME: requires char16_t, char32_t, and wchar_t be unique types
    86         // u"abc"`m;
    87         // U_"abc"`h;
    88         // L"abc"`_A_;
     84//      u"abc"`m;
     85//      U_"abc"`h;
     86//      L"abc"`_A_;
    8987        u8_"abc"`__thingy_;
    9088} // main
    … …  
    9290// Local Variables: //
    9391// tab-width: 4 //
    94 // compile-command: "cfa userLiterals.cfa" //
     92// compile-command: "cfa user_literals.cfa" //
    9593// End: //

  • tools/catchsig.c

    rb7d6a36 rdca5802  
    2121        printf("Starting...\n");
    2222        sig(SIGHUP);
    23         sig(SIGINT);
    24         sig(SIGQUIT);
    25         sig(SIGILL);
    26         sig(SIGABRT);
    27         sig(SIGFPE);
    28         sig(SIGSEGV);
    29         sig(SIGPIPE);
    30         sig(SIGALRM);
    31         sig(SIGTERM);
    32         sig(SIGUSR1);
    33         sig(SIGUSR2);
    34         sig(SIGCHLD);
    35         sig(SIGCONT);
    36         sig(SIGTSTP);
    37         sig(SIGTTIN);
    38         sig(SIGTTOU);
     23      sig(SIGINT);
     24      sig(SIGQUIT);
     25      sig(SIGILL);
     26      sig(SIGABRT);
     27      sig(SIGFPE);
     28      sig(SIGSEGV);
     29      sig(SIGPIPE);
     30      sig(SIGALRM);
     31      sig(SIGTERM);
     32      sig(SIGUSR1);
     33      sig(SIGUSR2);
     34      sig(SIGCHLD);
     35      sig(SIGCONT);
     36      sig(SIGTSTP);
     37      sig(SIGTTIN);
     38      sig(SIGTTOU);
    3939        while(1);
    4040        return 0;

  • tools/stat.py

    rb7d6a36 rdca5802  
    1717                avg = numpy.mean  (content)
    1818                std = numpy.std   (content)
    19                 print "median {0:.1f} avg {1:.1f} stddev {2:.1f}".format( med, avg, std )
     19                print "median {0:.1f} avg {1:.1f} stddev {2:.2f}".format( med, avg, std )
    2020
    2121
Note: See TracChangeset for help on using the changeset viewer.