diff options
Diffstat (limited to 'Makefile')
| -rw-r--r-- | Makefile | 249 |
1 files changed, 249 insertions, 0 deletions
diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..2cd989c --- /dev/null +++ b/Makefile @@ -0,0 +1,249 @@ + +# A file to describe dependencies for compilations used by the POSIX +# "make" utility, see http://pubs.opengroup.org/onlinepubs/9699919799/ + +# Ensure that we use strict POSIX make rules. +.POSIX : + +# empty the list of suffixes +.SUFFIXES : +# C files, sources +.SUFFIXES : .c .h +# products, object files, make dependencies, assembler +.SUFFIXES : .o .d .s + +# The choice of the compiler. Commonly available on POSIX systems are +# compilers called clang, gcc, icc or c99. Try them in this order if +# the following does not work for you. +# +# Here we used a "wrapper" for gcc that comes with the "musl" C +# library. This has the advatage to provide full support for C11 +# threads that we need for the "experience" level. On some Linux +# distributions musl is available as packages 'musl', 'musl-dev', +# 'musl-tools'. Other Linux distributions such as Alpine directly ship +# with musl as their C library. +CC ?= /usr/local/musl/bin/musl-gcc +#CC = clang +#CC = gcc +#CC = icc +#CC = c99 + +# A collection of typical flags on a Linux box with gcc or clang + +# First a choice of a C standard to which your code is conforming. The +# following should be the default for a recent compiler (2023). Other +# options could be -std=c11 or -std=gnu11. +STD = -std=c2x + +# Warning options. It is important that the compiler gives you all +# that he knows. +WAR = -Wall + +# Optimization options. The ones here are my favorite, maximal +# optimization for the machine on which we are compiling and maximal +# separation of functions and data into different sections. +OPT ?= -O3 -march=native -fdata-sections -ffunction-sections + +# For the gcc and friends the addition of this flag produces a make +# dependency file with suffix .d +DEP = -MD + +CFLAGS = ${SILENT} ${OPT} ${WAR} ${STD} ${INC} ${DEP} + +# The linker flags. Here this corresponds to eliminate all of the +# collected sections that are finally not needed in the executable. +LDFLAGS = -Wl,--gc-sections +# in the link step we need our own library +LDLIBS = -L. -lmodernC +# sometime we will need the "math" library and also "real time" +LDLIBS += -lm -lrt + +ifdef CEDRO +export CEDRO_CC := ${CC} -D__CEDRO__ -std=c2x -x c - +export CCC := ${CEDRO}/bin/cedrocc +else +export CCC := ${CC} +endif + +# C sources that produce an executable +ROURCES = \ + basic_blocks.c \ + basic_blocks2.c \ + bitint.c \ + cat.c \ + crash.c \ + endianness.c \ + euclid.c \ + extern.c \ + embed.c \ + enum.c \ + fibonacci2.c \ + fibonacci3.c \ + fibonacci4.c \ + fibonacci5.c \ + fibonacci6.c \ + fibonacci.c \ + fibonacciCache.c \ + fibonacciRet.c \ + fp_except.c \ + generic.c \ + getting-started.c \ + heron.c \ + heron-expanded.c \ + heron_k.c \ + lifetime.c \ + locale.c \ + macro_trace.c \ + mbstrings-main.c \ + numberline.c \ + precision.c \ + rationals.c \ + shadow.c \ + sighandler_test.c \ + strcpy.c \ + strtoul.c \ + tendots.c \ + terran.c \ + test_circular.c \ + test-features.c \ + test-printf.c \ + timespec.c \ + va_arg.c \ + yday.c + + +# Comment this out if your platform does not support the C11 thread model +TOURCES = B9.c B9-detach.c + +SOURCES = ${ROURCES} ${TOURCES} + +# Translation units (TU) that provide functionality that can be used +# by others. These are collected into the library libmodernC.a +RSOURCES = \ + circular.c \ + literals.c \ + mbstrings.c \ + sighandler.c \ + stats.c + +# Comment this out if your platform does not support the C11 thread model +TSOURCES = esc.c life.c termin.c + +LSOURCES = ${RSOURCES} ${TSOURCES} + +# TU that just prove a point. +OSOURCES = \ + anonymous_function.c \ + atomic_or_struct.c \ + constexpr.c \ + volatile_atomic.c + +# Examples of bad TU that produce diagnostics when compiled +BSOURCES = \ + getting-started-badly.c \ + tgstring_test.c + +# The following lines use the above to create new lists of files where +# the .c suffixes are replaced. +OBJECTS = ${SOURCES:.c=.o} + +LOBJECTS = ${LSOURCES:.c=.o} + +BOBJECTS = ${BSOURCES:.c=.o} + +OOBJECTS = ${OSOURCES:.c=.o} + +BINARIES = ${SOURCES:.c=} + +DEPENDS = ${SOURCES:.c=.d} ${LSOURCES:.c=.d} + +# This implicit rule tells how make is supposed to produce an object +# file (.o suffix) from a C file (.c suffix). This is needed to +# produce an executable file from your program. +# +# Here the make-special variable $< expands and to the dependency (the +# .o object file). +.c.o : + ${CCC} ${CFLAGS} -o $@ -c $< + +# This implicit rule tells how make is supposed to produce an assembly +# file (.s suffix) from a C file (.c suffix). This is only needed if +# you want to inspect what your compiler produces from your code. +.c.s : + ${CC} ${CFLAGS} -o $@ -S $< + +# This implicit rule tells make that the dependency file (.d suffix) +# itself depends on the object file. This is a bit of a lie, because +# we will produce them along (see DEP above) when normally compiling. +.d.o : + +# This implicit rule tells make that the final executable file (no +# suffix) depends on the object file (.o suffix). If your platform has +# a suffix for executables, e.g .exe, you'd have to add it here. On +# POSIX systems it is common to use the same compiler command (here +# ${CC}) also for linking. +# +# The additional make-special variable $@ expands to the target name +# (the executable). +.o : + ${CC} -o $@ ${LDFLAGS} $< ${LDLIBS} + +# This is the first explicit target, so per default make will try to +# produce it. It is only here for the dependencies to all our +# executables, so all of these will be created, if possible. Since +# this target has no rule of its own, a file named "binaries" will +# never be produced. +binaries : ${BINARIES} + +# This rule tells make that all our executable files also depend on +# the archive 'libmodernC.a'. +${BINARIES} : libmodernC.a + +# That archive depends on all the "LOBJECTS" +libmodernC.a : ${LOBJECTS} + ${AR} crf $@ $^ + +# These target need some special command line arguments so they have +# their own production line. +tgstring.o : tgstring.h + ${CC} -D_TG_INLINE= -c -x c ${CFLAGS} -o tgstring.o tgstring.h + +embed : embed.o + ${CC} ${CFLAGS} -o $@ ${LDFLAGS} $< ${LDLIBS} + +# An alternative target that just has all sources compiled. +objects : ${OBJECTS} ${LOBJECTS} ${OOBJECTS} + + +# Compilation of the "bad" objects will produce a lot of +# diagnostics. These are for demonstrative purposes, only. +bad : ${BOBJECTS} + +# Linkage of the "bad" objects may produce executables that have +# unforseeable effects if they are run. +# +# ***** DO NOT USE THESE **** +# +# These are for demonstrative purposes, only. +verybad : ${BOBJECTS:.o=} + +# They also depend on the library. +${BOBJECTS:.o=} : libmodernC.a + +# Cleanup the directory from all files that we produce +clean : + rm -f libmodernC.a ${DEPENDS} ${OBJECTS} ${LOBJECTS} ${OOBJECTS} ${BOBJECTS} ${BINARIES} ${BOBJECTS:.o=} + +# Include all the produced dependency files. In POSIX, it is +# unspecified if "include" works with more than one file, but usually +# it does. +# +# The "-" in front tells make not to complain, if the dependency files +# to not exist, yet. If they are missing, make looks into its rules to +# see how to produce them, produces them and reads them. +# +# If the initial generation of make dependency files does not work for +# you, you could launch a compilation of all objects with +# +# make -i +-include ${DEPENDS} |