]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Switch to new small-project Makefile.
authorwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Thu, 3 Feb 2000 14:03:24 +0000 (14:03 +0000)
committerwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Thu, 3 Feb 2000 14:03:24 +0000 (14:03 +0000)
git-svn-id: https://svn.dealii.org/trunk@2336 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/deal.II/Attic/examples/convergence/Makefile
deal.II/deal.II/Attic/examples/dof/Makefile
deal.II/deal.II/Attic/examples/error-estimation/Makefile
deal.II/deal.II/Attic/examples/grid/Makefile
deal.II/deal.II/Attic/examples/multigrid/Makefile
tests/big-tests/convergence/Makefile
tests/big-tests/dof/Makefile
tests/big-tests/error-estimation/Makefile
tests/big-tests/grid/Makefile
tests/big-tests/multigrid/Makefile

index c0815b3799ebf1a006040bdc5fe401ac983850ae..3b00259d3fc89c9ff27ca9a9b9fcbf2aab87248a 100644 (file)
@@ -1,73 +1,83 @@
 # $Id$
-# Copyright W. Bangerth, University of Heidelberg, 1998
+# Copyright W. Bangerth, University of Heidelberg, 1998, 1999, 2000
 
-# Template for makefiles for the examples subdirectory. In principle,
-# everything should be done automatically if you set the target file
-# here correctly:
+
+# For the small projects Makefile, you basically need to fill in only
+# four fields.
+#
+# The first is the name of the application. It is assumed that the
+# application name is the same as the base file name of the single C++
+# file from which the application is generated.
 target   = convergence
 
-# All dependencies between files should be updated by the included
-# file Makefile.dep if necessary. Object files are compiled into
-# the archives ./Obj.a and ./Obj.g.a. By default, the debug version
-# is used to link. It you don't like that, change the following
-# variable to "off"
+# The second field determines whether you want to run your program in
+# debug or optimized mode. The latter is significantly faster, but no
+# run-time checking of parameters and internal states is performed, so
+# you should set this value to `on' while you develop your program,
+# and to `off' when running production computations.
 debug-mode = on
 
-# If you want your program to be linked with extra object or library
-# files, specify them here:
-user-libs =
-
-# To run the program, use "make run"; to give parameters to the program,
-# give the parameters to the following variable:
-run-parameters  = 
-
-# To execute additional action apart from running the program, fill
-# in this list:
-additional-run-action = gnuplot make_ps
 
-# To specify which files are to be deleted by "make clean" (apart from
-# the usual ones: object files, executables, backups, etc), fill in the
-# following list
-delete-files = *gnuplot *.eps *ucd *history
+# As third field, we need to give the path to the top-level deal.II
+# directory. You need to adjust this to your needs. Since this path is
+# probably the most often needed one in the Makefile internals, it is
+# designated by a single-character variable, since that can be
+# reference using $D only, i.e. without the parentheses that are
+# required for most other parameters, as e.g. in $(target).
+D = ../../..
 
 
+# The last field specifies the names of data and other files that
+# shall be deleted when calling `make clean'. Object and backup files,
+# executables and the like are removed anyway. Here, we give a list of
+# files in the various output formats that deal.II supports.
+clean-up-files = *gmv *gnuplot *gpl *eps *pov
 
 
-###############################################################################
-# Internals
 
-#deal include base path
-D = ../../..
 
+#
+#
+# Usually, you will not need to change something beyond this point.
+#
+#
+# The next statement tell the `make' program where to find the
+# deal.II top level directory and to include the file with the global
+# settings
 include $D/common/Make.global_options
 
-# get lists of files we need
-cc-files    = $(filter-out *%, $(shell echo *.cc))
-o-files     = $(cc-files:.cc=.o)
-go-files    = $(cc-files:.cc=.go)
-h-files     = $(filter-out *%, $(shell echo *.h))
-lib-h-files = $(filter-out *%, $(shell echo ../../include/*/*.h))
 
-# list of libraries needed to link with
-libs.g   = ./Obj.g.a         \
-           $(lib-deal2-2d.g) \
+# Since the whole project consists of only one file, we need not
+# consider difficult dependencies. We only have to declare the
+# libraries which we want to link to the object file, and there need
+# to be two sets of libraries: one for the debug mode version of the
+# application and one for the optimized mode. Here we have selected
+# the versions for 2d. Note that the order in which the libraries are
+# given here is important and that your applications won't link
+# properly if they are given in another order.
+#
+# You may need to augment the lists of libraries when compiling your
+# program for other dimensions, or when using third party libraries
+libs.g   = $(lib-deal2-2d.g) \
           $(lib-lac.g)      \
            $(lib-base.g)
-libs     = ./Obj.a           \
-           $(lib-deal2-2d.o) \
+libs.o   = $(lib-deal2-2d.o) \
           $(lib-lac.o)      \
            $(lib-base.o)
 
 
-# check whether we use debug mode or not
+# We now use the variable defined above which switch between debug and
+# optimized mode to select the correct compiler flags and the set of
+# libraries to link with. Included in the list of libraries is the
+# name of the object file which we will produce from the single C++
+# file. Note that by default we use the extension .go for object files
+# compiled in debug mode and .o for object files in optimized mode.
 ifeq ($(debug-mode),on)
-libraries = $(libs.g)
-flags     = $(CXXFLAGS.g)
-endif
-
-ifeq ($(debug-mode),off)
-libraries = $(libs)
-flags     = $(CXXFLAGS.o)
+  libraries = $(target).go $(libs.g)
+  flags     = $(CXXFLAGS.g)
+else
+  libraries = $(target).go $(libs.o)
+  flags     = $(CXXFLAGS.o)
 endif
 
 
@@ -79,55 +89,81 @@ endif
 
 
 
-# make rule for the target
+# Now comes the first production rule: how to link the single object
+# file produced from the single C++ file into the executable. Since
+# this is the first rule in the Makefile, it is the one `make' selects
+# if you call it without arguments.
 $(target) : $(libraries)
        @echo ============================ Linking $@
-       @$(CXX) $(flags) -o $@ $^ $(user-libs)
+       @$(CXX) $(flags) -o $@ $^
 
-# rule how to run the program
+
+# To make running the application somewhat independent of the actual
+# program name, we usually declare a rule `run' which simply runs the
+# program. You can then run it by typing `make run'. This is also
+# useful if you want to call the executable with arguments which do
+# not change frequently. You may then want to add them to the
+# following rule:
 run: $(target)
-       $(target) $(run-parameters)
-       $(additional-run-action)
+       @echo ============================ Running $<
+       @./$(target)
+       gnuplot make_ps
+
+
+# As a last rule to the `make' program, we define what to do when
+# cleaning up a directory. This usually involves deleting object files
+# and other automatically created files such as the executable itself,
+# backup files, and data files. Since the latter are not usually quite
+# diverse, you needed to declare them at the top of this file.
+clean:
+       -rm -f *.o *.go *~ Makefile.dep $(target) $(clean-up-files)
 
 
-# rule to make object files
+# Since we have not yet stated how to make an object file from a C++
+# file, we should do so now. Since the many flags passed to the
+# compiler are usually not of much interest, we suppress the actual
+# command line using the `at' sign in the first column of the rules
+# and write the string indicating what we do instead.
 %.go : %.cc
-       @echo ============================ Compiling with debugging information:   $<
-       @echo $(CXX) ... -c $< -o $@
+       @echo ==============debug========= $(<F)
        @$(CXX) $(CXXFLAGS.g) -c $< -o $@
 %.o : %.cc
-       @echo ============================ Compiling with optimization:   $<
-       @echo $(CXX) ... -c $< -o $@
-       @$(CXX) $(CXXFLAGS.o) -c $< -o $@
-
-
-# rules which files the libraries depend upon
-Obj.a: ./Obj.a($(o-files))
-Obj.g.a: ./Obj.g.a($(go-files))
-
-
-clean:
-       -rm -f *.o *.go *~ Makefile.dep Obj.a Obj.g.a $(target) $(delete-files)
+       @echo ==============optimized===== $(<F)
+       @$(CXX) $(CXXFLAGS) -c $< -o $@
 
 
+# The following statement tells make that the rules `run' and `clean'
+# are not expected to produce files of the same name as Makefile rules
+# usually do.
+.PHONY: run clean
 
-.PHONY: clean
 
-
-#Rule to generate the dependency file. This file is
-#automagically remade whenever needed, i.e. whenever
-#one of the cc-/h-files changed. Make detects whether
-#to remake this file upon inclusion at the bottom
-#of this file.
+# Finally there is a rule which you normally need not care much about:
+# since the executable depends on some include files from the library,
+# besides the C++ application file of course, it is necessary to
+# re-generate the executable when one of the files it depends on has
+# changed. The following rule to created a dependency file
+# `Makefile.dep', which `make' uses to determine when to regenerate
+# the executable. This file is automagically remade whenever needed,
+# i.e. whenever one of the cc-/h-files changed. Make detects whether
+# to remake this file upon inclusion at the bottom of this file.
 #
-#use perl to generate rules for the .go files as well
-#as to make rules not for tria.o and the like, but
-#rather for libnumerics.a(tria.o)
-Makefile.dep: $(cc-files) $(h-files) $(lib-h-files)
+# The dependency file is created using a perl script.  Since the
+# script prefixes the output names by `lib/o' or `lib/go' (it was
+# written for the sublibraries' Makefile), we have to strip that again
+# since object files are placed in the present directory for this
+# application. All these things are made in the next rule:
+Makefile.dep: $(target).cc Makefile \
+              $(shell echo $(include-path-base)/base/*.h    \
+                           $(include-path-lac)/lac/*.h     \
+                           $(include-path-deal2)/*/*.h)
        @echo ============================ Remaking Makefile
-       @perl $D/common/scripts/Make_dep.pl ./Obj $(INCLUDE) $(cc-files) \
+       @perl $D/common/scripts/make_dependencies.pl  $(INCLUDE) $(target).cc \
+               | perl -pi -e 's!lib/g?o/!!g;' \
                > Makefile.dep
 
-
+# To make the dependencies known to `make', we finally have to include
+# them:
 include Makefile.dep
 
+
index 3f7be46d144fdea03db4ec7233f537e0ca545f89..ee93d64e403cd204c8e18e2ec45c3bfa3708a39f 100644 (file)
@@ -1,77 +1,87 @@
 # $Id$
-# Copyright W. Bangerth, University of Heidelberg, 1998
+# Copyright W. Bangerth, University of Heidelberg, 1998, 1999, 2000
 
-# Template for makefiles for the examples subdirectory. In principle,
-# everything should be done automatically if you set the target file
-# here correctly:
+
+# For the small projects Makefile, you basically need to fill in only
+# four fields.
+#
+# The first is the name of the application. It is assumed that the
+# application name is the same as the base file name of the single C++
+# file from which the application is generated.
 target   = dof_test
 
-# All dependencies between files should be updated by the included
-# file Makefile.dep if necessary. Object files are compiled into
-# the archives ./Obj.a and ./Obj.g.a. By default, the debug version
-# is used to link. It you don't like that, change the following
-# variable to "off"
+# The second field determines whether you want to run your program in
+# debug or optimized mode. The latter is significantly faster, but no
+# run-time checking of parameters and internal states is performed, so
+# you should set this value to `on' while you develop your program,
+# and to `off' when running production computations.
 debug-mode = on
 
-# If you want your program to be linked with extra object or library
-# files, specify them here:
-user-libs =
-
-# To run the program, use "make run"; to give parameters to the program,
-# give the parameters to the following variable:
-run-parameters  = 2 $(target).prm ; $(target) 3 $(target).prm
-
-# To execute additional action apart from running the program, fill
-# in this list:
-additional-run-action = gnuplot make_ps
 
-# To specify which files are to be deleted by "make clean" (apart from
-# the usual ones: object files, executables, backups, etc), fill in the
-# following list
-delete-files = results/?d.*
+# As third field, we need to give the path to the top-level deal.II
+# directory. You need to adjust this to your needs. Since this path is
+# probably the most often needed one in the Makefile internals, it is
+# designated by a single-character variable, since that can be
+# reference using $D only, i.e. without the parentheses that are
+# required for most other parameters, as e.g. in $(target).
+D = ../../..
 
 
+# The last field specifies the names of data and other files that
+# shall be deleted when calling `make clean'. Object and backup files,
+# executables and the like are removed anyway. Here, we give a list of
+# files in the various output formats that deal.II supports.
+clean-up-files = *gmv *gnuplot *gpl *eps *pov
 
 
-###############################################################################
-# Internals
 
-#deal include base path
-D = ../../..
 
+#
+#
+# Usually, you will not need to change something beyond this point.
+#
+#
+# The next statement tell the `make' program where to find the
+# deal.II top level directory and to include the file with the global
+# settings
 include $D/common/Make.global_options
 
 
-# get lists of files we need
-cc-files    = $(filter-out *%, $(shell echo *.cc))
-o-files     = $(cc-files:.cc=.o)
-go-files    = $(cc-files:.cc=.go)
-h-files     = $(filter-out *%, $(shell echo *.h))
-lib-h-files = $(filter-out *%, $(shell echo ../../include/*/*.h))
-
-# list of libraries needed to link with
-libs.g   = ./Obj.g.a         \
-           $(lib-deal2-2d.g) \
-           $(lib-deal2-3d.g) \
+# Since the whole project consists of only one file, we need not
+# consider difficult dependencies. We only have to declare the
+# libraries which we want to link to the object file, and there need
+# to be two sets of libraries: one for the debug mode version of the
+# application and one for the optimized mode. Here we have selected
+# the versions for 2d. Note that the order in which the libraries are
+# given here is important and that your applications won't link
+# properly if they are given in another order.
+#
+# You may need to augment the lists of libraries when compiling your
+# program for other dimensions, or when using third party libraries
+libs.g   = $(lib-deal2-2d.g) \
+          $(lib-deal2-3d.g) \
           $(lib-lac.g)      \
            $(lib-base.g)
-libs     = ./Obj.a           \
-           $(lib-deal2-2d.o) \
-           $(lib-deal2-3d.o) \
+libs.o   = $(lib-deal2-2d.o) \
+          $(lib-deal2-3d.o) \
           $(lib-lac.o)      \
            $(lib-base.o)
 
 
-# check whether we use debug mode or not
+# We now use the variable defined above which switch between debug and
+# optimized mode to select the correct compiler flags and the set of
+# libraries to link with. Included in the list of libraries is the
+# name of the object file which we will produce from the single C++
+# file. Note that by default we use the extension .go for object files
+# compiled in debug mode and .o for object files in optimized mode.
 ifeq ($(debug-mode),on)
-libraries = $(libs.g)
-flags     = $(CXXFLAGS.g)
+  libraries = $(target).go $(libs.g)
+  flags     = $(CXXFLAGS.g)
+else
+  libraries = $(target).go $(libs.o)
+  flags     = $(CXXFLAGS.o)
 endif
 
-ifeq ($(debug-mode),off)
-libraries = $(libs)
-flags     = $(CXXFLAGS)
-endif
 
 # If in multithread mode, add the ACE library to the libraries which
 # we need to link with:
@@ -80,55 +90,83 @@ ifneq ($(with-multithreading),no)
 endif
 
 
-# make rule for the target
+
+# Now comes the first production rule: how to link the single object
+# file produced from the single C++ file into the executable. Since
+# this is the first rule in the Makefile, it is the one `make' selects
+# if you call it without arguments.
 $(target) : $(libraries)
        @echo ============================ Linking $@
-       @$(CXX) $(flags) -o $@ $(libraries) $(user-libs)
+       @$(CXX) $(flags) -o $@ $^
+
 
-# rule how to run the program
+# To make running the application somewhat independent of the actual
+# program name, we usually declare a rule `run' which simply runs the
+# program. You can then run it by typing `make run'. This is also
+# useful if you want to call the executable with arguments which do
+# not change frequently. You may then want to add them to the
+# following rule:
 run: $(target)
-       $(target) $(run-parameters)
-       $(additional-run-action)
+       @echo ============================ Running $<
+       ./$(target) 2 $(target).prm 
+       ./$(target) 3 $(target).prm
+       gnuplot make_ps
 
 
-# rule to make object files
+# As a last rule to the `make' program, we define what to do when
+# cleaning up a directory. This usually involves deleting object files
+# and other automatically created files such as the executable itself,
+# backup files, and data files. Since the latter are not usually quite
+# diverse, you needed to declare them at the top of this file.
+clean:
+       -rm -f *.o *.go *~ Makefile.dep $(target) $(clean-up-files)
+
+
+# Since we have not yet stated how to make an object file from a C++
+# file, we should do so now. Since the many flags passed to the
+# compiler are usually not of much interest, we suppress the actual
+# command line using the `at' sign in the first column of the rules
+# and write the string indicating what we do instead.
 %.go : %.cc
-       @echo ============================ Compiling with debugging information:   $<
-       @echo $(CXX) ... -c $< -o $@
+       @echo ==============debug========= $(<F)
        @$(CXX) $(CXXFLAGS.g) -c $< -o $@
 %.o : %.cc
-       @echo ============================ Compiling with optimization:   $<
-       @echo $(CXX) ... -c $< -o $@
+       @echo ==============optimized===== $(<F)
        @$(CXX) $(CXXFLAGS) -c $< -o $@
 
 
-# rules which files the libraries depend upon
-Obj.a: ./Obj.a($(o-files))
-Obj.g.a: ./Obj.g.a($(go-files))
-
+# The following statement tells make that the rules `run' and `clean'
+# are not expected to produce files of the same name as Makefile rules
+# usually do.
+.PHONY: run clean
 
-clean:
-       -rm -f *.o *.go *~ Makefile.dep Obj.a Obj.g.a $(target) $(delete-files)
 
-
-
-.PHONY: clean
-
-
-#Rule to generate the dependency file. This file is
-#automagically remade whenever needed, i.e. whenever
-#one of the cc-/h-files changed. Make detects whether
-#to remake this file upon inclusion at the bottom
-#of this file.
+# Finally there is a rule which you normally need not care much about:
+# since the executable depends on some include files from the library,
+# besides the C++ application file of course, it is necessary to
+# re-generate the executable when one of the files it depends on has
+# changed. The following rule to created a dependency file
+# `Makefile.dep', which `make' uses to determine when to regenerate
+# the executable. This file is automagically remade whenever needed,
+# i.e. whenever one of the cc-/h-files changed. Make detects whether
+# to remake this file upon inclusion at the bottom of this file.
 #
-#use perl to generate rules for the .go files as well
-#as to make rules not for tria.o and the like, but
-#rather for libnumerics.a(tria.o)
-Makefile.dep: $(cc-files) $(h-files) $(lib-h-files)
+# The dependency file is created using a perl script.  Since the
+# script prefixes the output names by `lib/o' or `lib/go' (it was
+# written for the sublibraries' Makefile), we have to strip that again
+# since object files are placed in the present directory for this
+# application. All these things are made in the next rule:
+Makefile.dep: $(target).cc Makefile \
+              $(shell echo $(include-path-base)/base/*.h    \
+                           $(include-path-lac)/lac/*.h     \
+                           $(include-path-deal2)/*/*.h)
        @echo ============================ Remaking Makefile
-       @perl $D/common/scripts/Make_dep.pl ./Obj $(INCLUDE) $(cc-files) \
+       @perl $D/common/scripts/make_dependencies.pl  $(INCLUDE) $(target).cc \
+               | perl -pi -e 's!lib/g?o/!!g;' \
                > Makefile.dep
 
-
+# To make the dependencies known to `make', we finally have to include
+# them:
 include Makefile.dep
 
+
index 3744bd3dbd96fa39105b6ac89927c99c56f2a00b..96921c2ca16c1badb6511bbc6217df539da62f46 100644 (file)
@@ -1,79 +1,85 @@
 # $Id$
-# Copyright W. Bangerth, University of Heidelberg, 1998
+# Copyright W. Bangerth, University of Heidelberg, 1998, 1999, 2000
 
-# Template for makefiles for the examples subdirectory. In principle,
-# everything should be done automatically if you set the target file
-# here correctly:
+
+# For the small projects Makefile, you basically need to fill in only
+# four fields.
+#
+# The first is the name of the application. It is assumed that the
+# application name is the same as the base file name of the single C++
+# file from which the application is generated.
 target   = error-estimation
 
-# All dependencies between files should be updated by the included
-# file Makefile.dep if necessary. Object files are compiled into
-# the archives ./Obj.a and ./Obj.g.a. By default, the debug version
-# is used to link. It you don't like that, change the following
-# variable to "off"
+# The second field determines whether you want to run your program in
+# debug or optimized mode. The latter is significantly faster, but no
+# run-time checking of parameters and internal states is performed, so
+# you should set this value to `on' while you develop your program,
+# and to `off' when running production computations.
 debug-mode = on
 
-# If you want your program to be linked with extra object or library
-# files, specify them here:
-user-libs =
-
-# To run the program, use "make run"; to give parameters to the program,
-# give the parameters to the following variable:
-run-parameters  = ee.gauss.prm
-
-# To execute additional action apart from running the program, fill
-# in this list:
-run-action=\
-       $(target) ee.gauss.prm; \
-       $(target) ee.singular.prm; \
-       $(target) ee.kink.prm; \
-       gnuplot make_ps; \
-       perl -pi -e 's/^\#.*$$\\${}n//g' data-*/*.inp
 
-# To specify which files are to be deleted by "make clean" (apart from
-# the usual ones: object files, executables, backups, etc), fill in the
-# following list
-delete-files = data-*/*
+# As third field, we need to give the path to the top-level deal.II
+# directory. You need to adjust this to your needs. Since this path is
+# probably the most often needed one in the Makefile internals, it is
+# designated by a single-character variable, since that can be
+# reference using $D only, i.e. without the parentheses that are
+# required for most other parameters, as e.g. in $(target).
+D = ../../..
 
 
+# The last field specifies the names of data and other files that
+# shall be deleted when calling `make clean'. Object and backup files,
+# executables and the like are removed anyway. Here, we give a list of
+# files in the various output formats that deal.II supports.
+clean-up-files = *gmv *gnuplot *gpl *eps *pov
 
 
-###############################################################################
-# Internals
 
-#deal include base path
-D = ../../..
 
+#
+#
+# Usually, you will not need to change something beyond this point.
+#
+#
+# The next statement tell the `make' program where to find the
+# deal.II top level directory and to include the file with the global
+# settings
 include $D/common/Make.global_options
 
 
-# get lists of files we need
-cc-files    = $(filter-out *%, $(shell echo *.cc))
-o-files     = $(cc-files:.cc=.o)
-go-files    = $(cc-files:.cc=.go)
-h-files     = $(filter-out *%, $(shell echo *.h))
-lib-h-files = $(filter-out *%, $(shell echo ../../include/*/*.h))
-
-# list of libraries needed to link with
-libs.g   = ./Obj.g.a         \
-           $(lib-deal2-2d.g) \
+# Since the whole project consists of only one file, we need not
+# consider difficult dependencies. We only have to declare the
+# libraries which we want to link to the object file, and there need
+# to be two sets of libraries: one for the debug mode version of the
+# application and one for the optimized mode. Here we have selected
+# the versions for 2d. Note that the order in which the libraries are
+# given here is important and that your applications won't link
+# properly if they are given in another order.
+#
+# You may need to augment the lists of libraries when compiling your
+# program for other dimensions, or when using third party libraries
+libs.g   = $(lib-deal2-2d.g) \
           $(lib-lac.g)      \
            $(lib-base.g)
-libs     = ./Obj.a           \
-           $(lib-deal2-2d.o) \
+libs.o   = $(lib-deal2-2d.o) \
           $(lib-lac.o)      \
            $(lib-base.o)
 
-# check whether we use debug mode or not
+
+# We now use the variable defined above which switch between debug and
+# optimized mode to select the correct compiler flags and the set of
+# libraries to link with. Included in the list of libraries is the
+# name of the object file which we will produce from the single C++
+# file. Note that by default we use the extension .go for object files
+# compiled in debug mode and .o for object files in optimized mode.
 ifeq ($(debug-mode),on)
-libraries = $(libs.g)
-flags     = $(CXXFLAGS.g)
+  libraries = $(target).go $(libs.g)
+  flags     = $(CXXFLAGS.g)
+else
+  libraries = $(target).go $(libs.o)
+  flags     = $(CXXFLAGS.o)
 endif
 
-ifeq ($(debug-mode),off)
-libraries = $(libs)
-flags     = $(CXXFLAGS)
-endif
 
 # If in multithread mode, add the ACE library to the libraries which
 # we need to link with:
@@ -82,52 +88,85 @@ ifneq ($(with-multithreading),no)
 endif
 
 
-# make rule for the target
+
+# Now comes the first production rule: how to link the single object
+# file produced from the single C++ file into the executable. Since
+# this is the first rule in the Makefile, it is the one `make' selects
+# if you call it without arguments.
 $(target) : $(libraries)
        @echo ============================ Linking $@
-       @$(CXX) $(flags) -o $@ $^ $(user-libs)
+       @$(CXX) $(flags) -o $@ $^
 
-run: $(target)
-       $(run-action)
-
-# rule to make object files
-%.go : %.cc
-       @echo ============================ Compiling with debugging information:   $<
-       @echo $(CXX) ... -c $< -o $@
-       @$(CXX) $(CXXFLAGS.g) -c $< -o $@
-%.o : %.cc
-       @echo ============================ Compiling with optimization:   $<
-       @echo $(CXX) ... -c $< -o $@
-       @$(CXX) $(CXXFLAGS) -c $< -o $@
 
+# To make running the application somewhat independent of the actual
+# program name, we usually declare a rule `run' which simply runs the
+# program. You can then run it by typing `make run'. This is also
+# useful if you want to call the executable with arguments which do
+# not change frequently. You may then want to add them to the
+# following rule:
+run: $(target)
+       @echo ============================ Running $<
+       ./$(target) ee.gauss.prm
+       ./(target) ee.singular.prm; \
+       ./$(target) ee.kink.prm; \
+       gnuplot make_ps; \
 
-# rules which files the libraries depend upon
-Obj.a: ./Obj.a($(o-files))
-Obj.g.a: ./Obj.g.a($(go-files))
 
 
+# As a last rule to the `make' program, we define what to do when
+# cleaning up a directory. This usually involves deleting object files
+# and other automatically created files such as the executable itself,
+# backup files, and data files. Since the latter are not usually quite
+# diverse, you needed to declare them at the top of this file.
 clean:
-       -rm -f *.o *.go *~ Makefile.dep Obj.a Obj.g.a $(target) $(delete-files)
+       -rm -f *.o *.go *~ Makefile.dep $(target) $(clean-up-files)
 
 
+# Since we have not yet stated how to make an object file from a C++
+# file, we should do so now. Since the many flags passed to the
+# compiler are usually not of much interest, we suppress the actual
+# command line using the `at' sign in the first column of the rules
+# and write the string indicating what we do instead.
+%.go : %.cc
+       @echo ==============debug========= $(<F)
+       @$(CXX) $(CXXFLAGS.g) -c $< -o $@
+%.o : %.cc
+       @echo ==============optimized===== $(<F)
+       @$(CXX) $(CXXFLAGS) -c $< -o $@
 
-.PHONY: clean
 
+# The following statement tells make that the rules `run' and `clean'
+# are not expected to produce files of the same name as Makefile rules
+# usually do.
+.PHONY: run clean
 
-#Rule to generate the dependency file. This file is
-#automagically remade whenever needed, i.e. whenever
-#one of the cc-/h-files changed. Make detects whether
-#to remake this file upon inclusion at the bottom
-#of this file.
+
+# Finally there is a rule which you normally need not care much about:
+# since the executable depends on some include files from the library,
+# besides the C++ application file of course, it is necessary to
+# re-generate the executable when one of the files it depends on has
+# changed. The following rule to created a dependency file
+# `Makefile.dep', which `make' uses to determine when to regenerate
+# the executable. This file is automagically remade whenever needed,
+# i.e. whenever one of the cc-/h-files changed. Make detects whether
+# to remake this file upon inclusion at the bottom of this file.
 #
-#use perl to generate rules for the .go files as well
-#as to make rules not for tria.o and the like, but
-#rather for libnumerics.a(tria.o)
-Makefile.dep: $(cc-files) $(h-files) $(lib-h-files)
+# The dependency file is created using a perl script.  Since the
+# script prefixes the output names by `lib/o' or `lib/go' (it was
+# written for the sublibraries' Makefile), we have to strip that again
+# since object files are placed in the present directory for this
+# application. All these things are made in the next rule:
+Makefile.dep: $(target).cc Makefile \
+              $(shell echo $(include-path-base)/base/*.h    \
+                           $(include-path-lac)/lac/*.h     \
+                           $(include-path-deal2)/*/*.h)
        @echo ============================ Remaking Makefile
-       @perl $D/common/scripts/Make_dep.pl ./Obj $(INCLUDE) $(cc-files) \
+       @perl $D/common/scripts/make_dependencies.pl  $(INCLUDE) $(target).cc \
+               | perl -pi -e 's!lib/g?o/!!g;' \
                > Makefile.dep
 
-
+# To make the dependencies known to `make', we finally have to include
+# them:
 include Makefile.dep
 
+
index 9bd38ee827a2cbfe22f00e3d6b9ef8891aac775c..455e443c64c39c9af6bd087dc66e6d5b3038b974 100644 (file)
@@ -1,77 +1,87 @@
 # $Id$
-# Copyright W. Bangerth, University of Heidelberg, 1998
+# Copyright W. Bangerth, University of Heidelberg, 1998, 1999, 2000
 
-# Template for makefiles for the examples subdirectory. In principle,
-# everything should be done automatically if you set the target file
-# here correctly:
+
+# For the small projects Makefile, you basically need to fill in only
+# four fields.
+#
+# The first is the name of the application. It is assumed that the
+# application name is the same as the base file name of the single C++
+# file from which the application is generated.
 target   = grid_test
 
-# All dependencies between files should be updated by the included
-# file Makefile.dep if necessary. Object files are compiled into
-# the archives ./Obj.a and ./Obj.g.a. By default, the debug version
-# is used to link. It you don't like that, change the following
-# variable to "off"
+# The second field determines whether you want to run your program in
+# debug or optimized mode. The latter is significantly faster, but no
+# run-time checking of parameters and internal states is performed, so
+# you should set this value to `on' while you develop your program,
+# and to `off' when running production computations.
 debug-mode = on
 
-# If you want your program to be linked with extra object or library
-# files, specify them here:
-user-libs =
-
-# To run the program, use "make run"; to give parameters to the program,
-# give the parameters to the following variable:
-run-parameters  = 2 1
 
-# To execute additional action apart from running the program, fill
-# in this list:
-additional-run-action = grid_test 2 2 ; grid_test 2 3 ; grid_test 2 4 ; grid_test 3 1 ; grid_test 3 2 ; grid_test 3 3 ; grid_test 3 4
-
-# To specify which files are to be deleted by "make clean" (apart from
-# the usual ones: object files, executables, backups, etc), fill in the
-# following list
-delete-files = results/[123]d*
+# As third field, we need to give the path to the top-level deal.II
+# directory. You need to adjust this to your needs. Since this path is
+# probably the most often needed one in the Makefile internals, it is
+# designated by a single-character variable, since that can be
+# reference using $D only, i.e. without the parentheses that are
+# required for most other parameters, as e.g. in $(target).
+D = ../../..
 
 
+# The last field specifies the names of data and other files that
+# shall be deleted when calling `make clean'. Object and backup files,
+# executables and the like are removed anyway. Here, we give a list of
+# files in the various output formats that deal.II supports.
+clean-up-files = *gmv *gnuplot *gpl *eps *pov
 
 
-###############################################################################
-# Internals
 
-#deal include base path
-D = ../../..
 
+#
+#
+# Usually, you will not need to change something beyond this point.
+#
+#
+# The next statement tell the `make' program where to find the
+# deal.II top level directory and to include the file with the global
+# settings
 include $D/common/Make.global_options
 
 
-# get lists of files we need
-cc-files    = $(filter-out *%, $(shell echo *.cc))
-o-files     = $(cc-files:.cc=.o)
-go-files    = $(cc-files:.cc=.go)
-h-files     = $(filter-out *%, $(shell echo *.h))
-lib-h-files = $(filter-out *%, $(shell echo ../../include/*/*.h))
-
-# list of libraries needed to link with
-libs.g   = ./Obj.g.a         \
-           $(lib-deal2-2d.g) \
-           $(lib-deal2-3d.g) \
+# Since the whole project consists of only one file, we need not
+# consider difficult dependencies. We only have to declare the
+# libraries which we want to link to the object file, and there need
+# to be two sets of libraries: one for the debug mode version of the
+# application and one for the optimized mode. Here we have selected
+# the versions for 2d. Note that the order in which the libraries are
+# given here is important and that your applications won't link
+# properly if they are given in another order.
+#
+# You may need to augment the lists of libraries when compiling your
+# program for other dimensions, or when using third party libraries
+libs.g   = $(lib-deal2-2d.g) \
+          $(lib-deal2-3d.g) \
           $(lib-lac.g)      \
            $(lib-base.g)
-libs     = ./Obj.a           \
-           $(lib-deal2-2d.o) \
-           $(lib-deal2-3d.o) \
+libs.o   = $(lib-deal2-2d.o) \
+          $(lib-deal2-3d.o) \
           $(lib-lac.o)      \
            $(lib-base.o)
 
 
-# check whether we use debug mode or not
+# We now use the variable defined above which switch between debug and
+# optimized mode to select the correct compiler flags and the set of
+# libraries to link with. Included in the list of libraries is the
+# name of the object file which we will produce from the single C++
+# file. Note that by default we use the extension .go for object files
+# compiled in debug mode and .o for object files in optimized mode.
 ifeq ($(debug-mode),on)
-libraries = $(libs.g)
-flags     = $(CXXFLAGS.g)
+  libraries = $(target).go $(libs.g)
+  flags     = $(CXXFLAGS.g)
+else
+  libraries = $(target).go $(libs.o)
+  flags     = $(CXXFLAGS.o)
 endif
 
-ifeq ($(debug-mode),off)
-libraries = $(libs)
-flags     = $(CXXFLAGS)
-endif
 
 # If in multithread mode, add the ACE library to the libraries which
 # we need to link with:
@@ -80,55 +90,89 @@ ifneq ($(with-multithreading),no)
 endif
 
 
-# make rule for the target
+
+# Now comes the first production rule: how to link the single object
+# file produced from the single C++ file into the executable. Since
+# this is the first rule in the Makefile, it is the one `make' selects
+# if you call it without arguments.
 $(target) : $(libraries)
        @echo ============================ Linking $@
-       @$(CXX) $(flags) -o $@ $(libraries) $(user-libs)
+       @$(CXX) $(flags) -o $@ $^
+
 
-# rule how to run the program
+# To make running the application somewhat independent of the actual
+# program name, we usually declare a rule `run' which simply runs the
+# program. You can then run it by typing `make run'. This is also
+# useful if you want to call the executable with arguments which do
+# not change frequently. You may then want to add them to the
+# following rule:
 run: $(target)
-       $(target) $(run-parameters)
-       $(additional-run-action)
+       @echo ============================ Running $<
+       ./$(target) 2 1
+       ./$(target) 2 2
+       ./$(target) 2 3
+       ./$(target) 2 4
+       ./$(target) 3 1
+       ./$(target) 3 2
+       ./$(target) 3 3
+       ./$(target) 3 4
+
+
+
+# As a last rule to the `make' program, we define what to do when
+# cleaning up a directory. This usually involves deleting object files
+# and other automatically created files such as the executable itself,
+# backup files, and data files. Since the latter are not usually quite
+# diverse, you needed to declare them at the top of this file.
+clean:
+       -rm -f *.o *.go *~ Makefile.dep $(target) $(clean-up-files)
 
 
-# rule to make object files
+# Since we have not yet stated how to make an object file from a C++
+# file, we should do so now. Since the many flags passed to the
+# compiler are usually not of much interest, we suppress the actual
+# command line using the `at' sign in the first column of the rules
+# and write the string indicating what we do instead.
 %.go : %.cc
-       @echo ============================ Compiling with debugging information:   $<
-       @echo $(CXX) ... -c $< -o $@
+       @echo ==============debug========= $(<F)
        @$(CXX) $(CXXFLAGS.g) -c $< -o $@
 %.o : %.cc
-       @echo ============================ Compiling with optimization:   $<
-       @echo $(CXX) ... -c $< -o $@
+       @echo ==============optimized===== $(<F)
        @$(CXX) $(CXXFLAGS) -c $< -o $@
 
 
-# rules which files the libraries depend upon
-Obj.a: ./Obj.a($(o-files))
-Obj.g.a: ./Obj.g.a($(go-files))
-
-
-clean:
-       rm -f *.o *.go *~ Makefile.dep Obj.a Obj.g.a $(target) $(delete-files)
-
-
+# The following statement tells make that the rules `run' and `clean'
+# are not expected to produce files of the same name as Makefile rules
+# usually do.
+.PHONY: run clean
 
-.PHONY: clean
 
-
-#Rule to generate the dependency file. This file is
-#automagically remade whenever needed, i.e. whenever
-#one of the cc-/h-files changed. Make detects whether
-#to remake this file upon inclusion at the bottom
-#of this file.
+# Finally there is a rule which you normally need not care much about:
+# since the executable depends on some include files from the library,
+# besides the C++ application file of course, it is necessary to
+# re-generate the executable when one of the files it depends on has
+# changed. The following rule to created a dependency file
+# `Makefile.dep', which `make' uses to determine when to regenerate
+# the executable. This file is automagically remade whenever needed,
+# i.e. whenever one of the cc-/h-files changed. Make detects whether
+# to remake this file upon inclusion at the bottom of this file.
 #
-#use perl to generate rules for the .go files as well
-#as to make rules not for tria.o and the like, but
-#rather for libnumerics.a(tria.o)
-Makefile.dep: $(cc-files) $(h-files) $(lib-h-files)
+# The dependency file is created using a perl script.  Since the
+# script prefixes the output names by `lib/o' or `lib/go' (it was
+# written for the sublibraries' Makefile), we have to strip that again
+# since object files are placed in the present directory for this
+# application. All these things are made in the next rule:
+Makefile.dep: $(target).cc Makefile \
+              $(shell echo $(include-path-base)/base/*.h    \
+                           $(include-path-lac)/lac/*.h     \
+                           $(include-path-deal2)/*/*.h)
        @echo ============================ Remaking Makefile
-       @perl $D/common/scripts/Make_dep.pl ./Obj $(INCLUDE) $(cc-files) \
+       @perl $D/common/scripts/make_dependencies.pl  $(INCLUDE) $(target).cc \
+               | perl -pi -e 's!lib/g?o/!!g;' \
                > Makefile.dep
 
-
+# To make the dependencies known to `make', we finally have to include
+# them:
 include Makefile.dep
 
+
index 6ed598d4339d7865a598287c4c6c042b6fe2d99f..c0b78a5d493aeb19f0b8772b919c6b6b59e823d4 100644 (file)
@@ -1,74 +1,83 @@
 # $Id$
-# Copyright W. Bangerth, University of Heidelberg, 1998
+# Copyright W. Bangerth, University of Heidelberg, 1998, 1999, 2000
 
-# Template for makefiles for the examples subdirectory. In principle,
-# everything should be done automatically if you set the target file
-# here correctly:
+
+# For the small projects Makefile, you basically need to fill in only
+# four fields.
+#
+# The first is the name of the application. It is assumed that the
+# application name is the same as the base file name of the single C++
+# file from which the application is generated.
 target   = multigrid
 
-# All dependencies between files should be updated by the included
-# file Makefile.dep if necessary. Object files are compiled into
-# the archives ./Obj.a and ./Obj.g.a. By default, the debug version
-# is used to link. It you don't like that, change the following
-# variable to "off"
+# The second field determines whether you want to run your program in
+# debug or optimized mode. The latter is significantly faster, but no
+# run-time checking of parameters and internal states is performed, so
+# you should set this value to `on' while you develop your program,
+# and to `off' when running production computations.
 debug-mode = on
 
-# If you want your program to be linked with extra object or library
-# files, specify them here:
-user-libs =
-
-# To run the program, use "make run"; to give parameters to the program,
-# give the parameters to the following variable:
-run-parameters  = 
-
-# To execute additional action apart from running the program, fill
-# in this list:
-additional-run-action = gnuplot make_ps
 
-# To specify which files are to be deleted by "make clean" (apart from
-# the usual ones: object files, executables, backups, etc), fill in the
-# following list
-delete-files = *gnuplot *.eps *ucd *history
+# As third field, we need to give the path to the top-level deal.II
+# directory. You need to adjust this to your needs. Since this path is
+# probably the most often needed one in the Makefile internals, it is
+# designated by a single-character variable, since that can be
+# reference using $D only, i.e. without the parentheses that are
+# required for most other parameters, as e.g. in $(target).
+D = ../../..
 
 
+# The last field specifies the names of data and other files that
+# shall be deleted when calling `make clean'. Object and backup files,
+# executables and the like are removed anyway. Here, we give a list of
+# files in the various output formats that deal.II supports.
+clean-up-files = *gmv *gnuplot *gpl *eps *pov
 
 
-###############################################################################
-# Internals
 
-#deal include base path
-D = ../../..
 
+#
+#
+# Usually, you will not need to change something beyond this point.
+#
+#
+# The next statement tell the `make' program where to find the
+# deal.II top level directory and to include the file with the global
+# settings
 include $D/common/Make.global_options
 
 
-# get lists of files we need
-cc-files    = $(filter-out *%, $(shell echo *.cc))
-o-files     = $(cc-files:.cc=.o)
-go-files    = $(cc-files:.cc=.go)
-h-files     = $(filter-out *%, $(shell echo *.h))
-lib-h-files = $(filter-out *%, $(shell echo ../../include/*/*.h))
-
-# list of libraries needed to link with
-libs.g   = ./Obj.g.a         \
-           $(lib-deal2-2d.g) \
+# Since the whole project consists of only one file, we need not
+# consider difficult dependencies. We only have to declare the
+# libraries which we want to link to the object file, and there need
+# to be two sets of libraries: one for the debug mode version of the
+# application and one for the optimized mode. Here we have selected
+# the versions for 2d. Note that the order in which the libraries are
+# given here is important and that your applications won't link
+# properly if they are given in another order.
+#
+# You may need to augment the lists of libraries when compiling your
+# program for other dimensions, or when using third party libraries
+libs.g   = $(lib-deal2-2d.g) \
           $(lib-lac.g)      \
            $(lib-base.g)
-libs     = ./Obj.a           \
-           $(lib-deal2-2d.o) \
+libs.o   = $(lib-deal2-2d.o) \
           $(lib-lac.o)      \
            $(lib-base.o)
 
 
-# check whether we use debug mode or not
+# We now use the variable defined above which switch between debug and
+# optimized mode to select the correct compiler flags and the set of
+# libraries to link with. Included in the list of libraries is the
+# name of the object file which we will produce from the single C++
+# file. Note that by default we use the extension .go for object files
+# compiled in debug mode and .o for object files in optimized mode.
 ifeq ($(debug-mode),on)
-libraries = $(libs.g)
-flags     = $(CXXFLAGS.g)
-endif
-
-ifeq ($(debug-mode),off)
-libraries = $(libs)
-flags     = $(CXXFLAGS)
+  libraries = $(target).go $(libs.g)
+  flags     = $(CXXFLAGS.g)
+else
+  libraries = $(target).go $(libs.o)
+  flags     = $(CXXFLAGS.o)
 endif
 
 
@@ -78,55 +87,83 @@ ifneq ($(with-multithreading),no)
   libraries += $(lib-ACE)
 endif
 
-# make rule for the target
+
+
+# Now comes the first production rule: how to link the single object
+# file produced from the single C++ file into the executable. Since
+# this is the first rule in the Makefile, it is the one `make' selects
+# if you call it without arguments.
 $(target) : $(libraries)
        @echo ============================ Linking $@
-       @$(CXX) $(flags) -o $@ $^ $(user-libs)
+       @$(CXX) $(flags) -o $@ $^
 
-# rule how to run the program
+
+# To make running the application somewhat independent of the actual
+# program name, we usually declare a rule `run' which simply runs the
+# program. You can then run it by typing `make run'. This is also
+# useful if you want to call the executable with arguments which do
+# not change frequently. You may then want to add them to the
+# following rule:
 run: $(target)
-       $(target) $(run-parameters)
-       $(additional-run-action)
+       @echo ============================ Running $<
+       @./$(target)
+       gnuplot make_ps
 
 
-# rule to make object files
+# As a last rule to the `make' program, we define what to do when
+# cleaning up a directory. This usually involves deleting object files
+# and other automatically created files such as the executable itself,
+# backup files, and data files. Since the latter are not usually quite
+# diverse, you needed to declare them at the top of this file.
+clean:
+       -rm -f *.o *.go *~ Makefile.dep $(target) $(clean-up-files)
+
+
+# Since we have not yet stated how to make an object file from a C++
+# file, we should do so now. Since the many flags passed to the
+# compiler are usually not of much interest, we suppress the actual
+# command line using the `at' sign in the first column of the rules
+# and write the string indicating what we do instead.
 %.go : %.cc
-       @echo ============================ Compiling with debugging information:   $<
-       @echo $(CXX) ... -c $< -o $@
+       @echo ==============debug========= $(<F)
        @$(CXX) $(CXXFLAGS.g) -c $< -o $@
 %.o : %.cc
-       @echo ============================ Compiling with optimization:   $<
-       @echo $(CXX) ... -c $< -o $@
+       @echo ==============optimized===== $(<F)
        @$(CXX) $(CXXFLAGS) -c $< -o $@
 
 
-# rules which files the libraries depend upon
-Obj.a: ./Obj.a($(o-files))
-Obj.g.a: ./Obj.g.a($(go-files))
-
+# The following statement tells make that the rules `run' and `clean'
+# are not expected to produce files of the same name as Makefile rules
+# usually do.
+.PHONY: run clean
 
-clean:
-       -rm -f *.o *.go *~ Makefile.dep Obj.a Obj.g.a $(target) $(delete-files)
-
-
-
-.PHONY: clean
 
-
-#Rule to generate the dependency file. This file is
-#automagically remade whenever needed, i.e. whenever
-#one of the cc-/h-files changed. Make detects whether
-#to remake this file upon inclusion at the bottom
-#of this file.
+# Finally there is a rule which you normally need not care much about:
+# since the executable depends on some include files from the library,
+# besides the C++ application file of course, it is necessary to
+# re-generate the executable when one of the files it depends on has
+# changed. The following rule to created a dependency file
+# `Makefile.dep', which `make' uses to determine when to regenerate
+# the executable. This file is automagically remade whenever needed,
+# i.e. whenever one of the cc-/h-files changed. Make detects whether
+# to remake this file upon inclusion at the bottom of this file.
 #
-#use perl to generate rules for the .go files as well
-#as to make rules not for tria.o and the like, but
-#rather for libnumerics.a(tria.o)
-Makefile.dep: $(cc-files) $(h-files) $(lib-h-files)
+# The dependency file is created using a perl script.  Since the
+# script prefixes the output names by `lib/o' or `lib/go' (it was
+# written for the sublibraries' Makefile), we have to strip that again
+# since object files are placed in the present directory for this
+# application. All these things are made in the next rule:
+Makefile.dep: $(target).cc Makefile \
+              $(shell echo $(include-path-base)/base/*.h    \
+                           $(include-path-lac)/lac/*.h     \
+                           $(include-path-deal2)/*/*.h)
        @echo ============================ Remaking Makefile
-       @perl $D/common/scripts/Make_dep.pl ./Obj $(INCLUDE) $(cc-files) \
+       @perl $D/common/scripts/make_dependencies.pl  $(INCLUDE) $(target).cc \
+               | perl -pi -e 's!lib/g?o/!!g;' \
                > Makefile.dep
 
-
+# To make the dependencies known to `make', we finally have to include
+# them:
 include Makefile.dep
 
+
index c0815b3799ebf1a006040bdc5fe401ac983850ae..3b00259d3fc89c9ff27ca9a9b9fcbf2aab87248a 100644 (file)
@@ -1,73 +1,83 @@
 # $Id$
-# Copyright W. Bangerth, University of Heidelberg, 1998
+# Copyright W. Bangerth, University of Heidelberg, 1998, 1999, 2000
 
-# Template for makefiles for the examples subdirectory. In principle,
-# everything should be done automatically if you set the target file
-# here correctly:
+
+# For the small projects Makefile, you basically need to fill in only
+# four fields.
+#
+# The first is the name of the application. It is assumed that the
+# application name is the same as the base file name of the single C++
+# file from which the application is generated.
 target   = convergence
 
-# All dependencies between files should be updated by the included
-# file Makefile.dep if necessary. Object files are compiled into
-# the archives ./Obj.a and ./Obj.g.a. By default, the debug version
-# is used to link. It you don't like that, change the following
-# variable to "off"
+# The second field determines whether you want to run your program in
+# debug or optimized mode. The latter is significantly faster, but no
+# run-time checking of parameters and internal states is performed, so
+# you should set this value to `on' while you develop your program,
+# and to `off' when running production computations.
 debug-mode = on
 
-# If you want your program to be linked with extra object or library
-# files, specify them here:
-user-libs =
-
-# To run the program, use "make run"; to give parameters to the program,
-# give the parameters to the following variable:
-run-parameters  = 
-
-# To execute additional action apart from running the program, fill
-# in this list:
-additional-run-action = gnuplot make_ps
 
-# To specify which files are to be deleted by "make clean" (apart from
-# the usual ones: object files, executables, backups, etc), fill in the
-# following list
-delete-files = *gnuplot *.eps *ucd *history
+# As third field, we need to give the path to the top-level deal.II
+# directory. You need to adjust this to your needs. Since this path is
+# probably the most often needed one in the Makefile internals, it is
+# designated by a single-character variable, since that can be
+# reference using $D only, i.e. without the parentheses that are
+# required for most other parameters, as e.g. in $(target).
+D = ../../..
 
 
+# The last field specifies the names of data and other files that
+# shall be deleted when calling `make clean'. Object and backup files,
+# executables and the like are removed anyway. Here, we give a list of
+# files in the various output formats that deal.II supports.
+clean-up-files = *gmv *gnuplot *gpl *eps *pov
 
 
-###############################################################################
-# Internals
 
-#deal include base path
-D = ../../..
 
+#
+#
+# Usually, you will not need to change something beyond this point.
+#
+#
+# The next statement tell the `make' program where to find the
+# deal.II top level directory and to include the file with the global
+# settings
 include $D/common/Make.global_options
 
-# get lists of files we need
-cc-files    = $(filter-out *%, $(shell echo *.cc))
-o-files     = $(cc-files:.cc=.o)
-go-files    = $(cc-files:.cc=.go)
-h-files     = $(filter-out *%, $(shell echo *.h))
-lib-h-files = $(filter-out *%, $(shell echo ../../include/*/*.h))
 
-# list of libraries needed to link with
-libs.g   = ./Obj.g.a         \
-           $(lib-deal2-2d.g) \
+# Since the whole project consists of only one file, we need not
+# consider difficult dependencies. We only have to declare the
+# libraries which we want to link to the object file, and there need
+# to be two sets of libraries: one for the debug mode version of the
+# application and one for the optimized mode. Here we have selected
+# the versions for 2d. Note that the order in which the libraries are
+# given here is important and that your applications won't link
+# properly if they are given in another order.
+#
+# You may need to augment the lists of libraries when compiling your
+# program for other dimensions, or when using third party libraries
+libs.g   = $(lib-deal2-2d.g) \
           $(lib-lac.g)      \
            $(lib-base.g)
-libs     = ./Obj.a           \
-           $(lib-deal2-2d.o) \
+libs.o   = $(lib-deal2-2d.o) \
           $(lib-lac.o)      \
            $(lib-base.o)
 
 
-# check whether we use debug mode or not
+# We now use the variable defined above which switch between debug and
+# optimized mode to select the correct compiler flags and the set of
+# libraries to link with. Included in the list of libraries is the
+# name of the object file which we will produce from the single C++
+# file. Note that by default we use the extension .go for object files
+# compiled in debug mode and .o for object files in optimized mode.
 ifeq ($(debug-mode),on)
-libraries = $(libs.g)
-flags     = $(CXXFLAGS.g)
-endif
-
-ifeq ($(debug-mode),off)
-libraries = $(libs)
-flags     = $(CXXFLAGS.o)
+  libraries = $(target).go $(libs.g)
+  flags     = $(CXXFLAGS.g)
+else
+  libraries = $(target).go $(libs.o)
+  flags     = $(CXXFLAGS.o)
 endif
 
 
@@ -79,55 +89,81 @@ endif
 
 
 
-# make rule for the target
+# Now comes the first production rule: how to link the single object
+# file produced from the single C++ file into the executable. Since
+# this is the first rule in the Makefile, it is the one `make' selects
+# if you call it without arguments.
 $(target) : $(libraries)
        @echo ============================ Linking $@
-       @$(CXX) $(flags) -o $@ $^ $(user-libs)
+       @$(CXX) $(flags) -o $@ $^
 
-# rule how to run the program
+
+# To make running the application somewhat independent of the actual
+# program name, we usually declare a rule `run' which simply runs the
+# program. You can then run it by typing `make run'. This is also
+# useful if you want to call the executable with arguments which do
+# not change frequently. You may then want to add them to the
+# following rule:
 run: $(target)
-       $(target) $(run-parameters)
-       $(additional-run-action)
+       @echo ============================ Running $<
+       @./$(target)
+       gnuplot make_ps
+
+
+# As a last rule to the `make' program, we define what to do when
+# cleaning up a directory. This usually involves deleting object files
+# and other automatically created files such as the executable itself,
+# backup files, and data files. Since the latter are not usually quite
+# diverse, you needed to declare them at the top of this file.
+clean:
+       -rm -f *.o *.go *~ Makefile.dep $(target) $(clean-up-files)
 
 
-# rule to make object files
+# Since we have not yet stated how to make an object file from a C++
+# file, we should do so now. Since the many flags passed to the
+# compiler are usually not of much interest, we suppress the actual
+# command line using the `at' sign in the first column of the rules
+# and write the string indicating what we do instead.
 %.go : %.cc
-       @echo ============================ Compiling with debugging information:   $<
-       @echo $(CXX) ... -c $< -o $@
+       @echo ==============debug========= $(<F)
        @$(CXX) $(CXXFLAGS.g) -c $< -o $@
 %.o : %.cc
-       @echo ============================ Compiling with optimization:   $<
-       @echo $(CXX) ... -c $< -o $@
-       @$(CXX) $(CXXFLAGS.o) -c $< -o $@
-
-
-# rules which files the libraries depend upon
-Obj.a: ./Obj.a($(o-files))
-Obj.g.a: ./Obj.g.a($(go-files))
-
-
-clean:
-       -rm -f *.o *.go *~ Makefile.dep Obj.a Obj.g.a $(target) $(delete-files)
+       @echo ==============optimized===== $(<F)
+       @$(CXX) $(CXXFLAGS) -c $< -o $@
 
 
+# The following statement tells make that the rules `run' and `clean'
+# are not expected to produce files of the same name as Makefile rules
+# usually do.
+.PHONY: run clean
 
-.PHONY: clean
 
-
-#Rule to generate the dependency file. This file is
-#automagically remade whenever needed, i.e. whenever
-#one of the cc-/h-files changed. Make detects whether
-#to remake this file upon inclusion at the bottom
-#of this file.
+# Finally there is a rule which you normally need not care much about:
+# since the executable depends on some include files from the library,
+# besides the C++ application file of course, it is necessary to
+# re-generate the executable when one of the files it depends on has
+# changed. The following rule to created a dependency file
+# `Makefile.dep', which `make' uses to determine when to regenerate
+# the executable. This file is automagically remade whenever needed,
+# i.e. whenever one of the cc-/h-files changed. Make detects whether
+# to remake this file upon inclusion at the bottom of this file.
 #
-#use perl to generate rules for the .go files as well
-#as to make rules not for tria.o and the like, but
-#rather for libnumerics.a(tria.o)
-Makefile.dep: $(cc-files) $(h-files) $(lib-h-files)
+# The dependency file is created using a perl script.  Since the
+# script prefixes the output names by `lib/o' or `lib/go' (it was
+# written for the sublibraries' Makefile), we have to strip that again
+# since object files are placed in the present directory for this
+# application. All these things are made in the next rule:
+Makefile.dep: $(target).cc Makefile \
+              $(shell echo $(include-path-base)/base/*.h    \
+                           $(include-path-lac)/lac/*.h     \
+                           $(include-path-deal2)/*/*.h)
        @echo ============================ Remaking Makefile
-       @perl $D/common/scripts/Make_dep.pl ./Obj $(INCLUDE) $(cc-files) \
+       @perl $D/common/scripts/make_dependencies.pl  $(INCLUDE) $(target).cc \
+               | perl -pi -e 's!lib/g?o/!!g;' \
                > Makefile.dep
 
-
+# To make the dependencies known to `make', we finally have to include
+# them:
 include Makefile.dep
 
+
index 3f7be46d144fdea03db4ec7233f537e0ca545f89..ee93d64e403cd204c8e18e2ec45c3bfa3708a39f 100644 (file)
@@ -1,77 +1,87 @@
 # $Id$
-# Copyright W. Bangerth, University of Heidelberg, 1998
+# Copyright W. Bangerth, University of Heidelberg, 1998, 1999, 2000
 
-# Template for makefiles for the examples subdirectory. In principle,
-# everything should be done automatically if you set the target file
-# here correctly:
+
+# For the small projects Makefile, you basically need to fill in only
+# four fields.
+#
+# The first is the name of the application. It is assumed that the
+# application name is the same as the base file name of the single C++
+# file from which the application is generated.
 target   = dof_test
 
-# All dependencies between files should be updated by the included
-# file Makefile.dep if necessary. Object files are compiled into
-# the archives ./Obj.a and ./Obj.g.a. By default, the debug version
-# is used to link. It you don't like that, change the following
-# variable to "off"
+# The second field determines whether you want to run your program in
+# debug or optimized mode. The latter is significantly faster, but no
+# run-time checking of parameters and internal states is performed, so
+# you should set this value to `on' while you develop your program,
+# and to `off' when running production computations.
 debug-mode = on
 
-# If you want your program to be linked with extra object or library
-# files, specify them here:
-user-libs =
-
-# To run the program, use "make run"; to give parameters to the program,
-# give the parameters to the following variable:
-run-parameters  = 2 $(target).prm ; $(target) 3 $(target).prm
-
-# To execute additional action apart from running the program, fill
-# in this list:
-additional-run-action = gnuplot make_ps
 
-# To specify which files are to be deleted by "make clean" (apart from
-# the usual ones: object files, executables, backups, etc), fill in the
-# following list
-delete-files = results/?d.*
+# As third field, we need to give the path to the top-level deal.II
+# directory. You need to adjust this to your needs. Since this path is
+# probably the most often needed one in the Makefile internals, it is
+# designated by a single-character variable, since that can be
+# reference using $D only, i.e. without the parentheses that are
+# required for most other parameters, as e.g. in $(target).
+D = ../../..
 
 
+# The last field specifies the names of data and other files that
+# shall be deleted when calling `make clean'. Object and backup files,
+# executables and the like are removed anyway. Here, we give a list of
+# files in the various output formats that deal.II supports.
+clean-up-files = *gmv *gnuplot *gpl *eps *pov
 
 
-###############################################################################
-# Internals
 
-#deal include base path
-D = ../../..
 
+#
+#
+# Usually, you will not need to change something beyond this point.
+#
+#
+# The next statement tell the `make' program where to find the
+# deal.II top level directory and to include the file with the global
+# settings
 include $D/common/Make.global_options
 
 
-# get lists of files we need
-cc-files    = $(filter-out *%, $(shell echo *.cc))
-o-files     = $(cc-files:.cc=.o)
-go-files    = $(cc-files:.cc=.go)
-h-files     = $(filter-out *%, $(shell echo *.h))
-lib-h-files = $(filter-out *%, $(shell echo ../../include/*/*.h))
-
-# list of libraries needed to link with
-libs.g   = ./Obj.g.a         \
-           $(lib-deal2-2d.g) \
-           $(lib-deal2-3d.g) \
+# Since the whole project consists of only one file, we need not
+# consider difficult dependencies. We only have to declare the
+# libraries which we want to link to the object file, and there need
+# to be two sets of libraries: one for the debug mode version of the
+# application and one for the optimized mode. Here we have selected
+# the versions for 2d. Note that the order in which the libraries are
+# given here is important and that your applications won't link
+# properly if they are given in another order.
+#
+# You may need to augment the lists of libraries when compiling your
+# program for other dimensions, or when using third party libraries
+libs.g   = $(lib-deal2-2d.g) \
+          $(lib-deal2-3d.g) \
           $(lib-lac.g)      \
            $(lib-base.g)
-libs     = ./Obj.a           \
-           $(lib-deal2-2d.o) \
-           $(lib-deal2-3d.o) \
+libs.o   = $(lib-deal2-2d.o) \
+          $(lib-deal2-3d.o) \
           $(lib-lac.o)      \
            $(lib-base.o)
 
 
-# check whether we use debug mode or not
+# We now use the variable defined above which switch between debug and
+# optimized mode to select the correct compiler flags and the set of
+# libraries to link with. Included in the list of libraries is the
+# name of the object file which we will produce from the single C++
+# file. Note that by default we use the extension .go for object files
+# compiled in debug mode and .o for object files in optimized mode.
 ifeq ($(debug-mode),on)
-libraries = $(libs.g)
-flags     = $(CXXFLAGS.g)
+  libraries = $(target).go $(libs.g)
+  flags     = $(CXXFLAGS.g)
+else
+  libraries = $(target).go $(libs.o)
+  flags     = $(CXXFLAGS.o)
 endif
 
-ifeq ($(debug-mode),off)
-libraries = $(libs)
-flags     = $(CXXFLAGS)
-endif
 
 # If in multithread mode, add the ACE library to the libraries which
 # we need to link with:
@@ -80,55 +90,83 @@ ifneq ($(with-multithreading),no)
 endif
 
 
-# make rule for the target
+
+# Now comes the first production rule: how to link the single object
+# file produced from the single C++ file into the executable. Since
+# this is the first rule in the Makefile, it is the one `make' selects
+# if you call it without arguments.
 $(target) : $(libraries)
        @echo ============================ Linking $@
-       @$(CXX) $(flags) -o $@ $(libraries) $(user-libs)
+       @$(CXX) $(flags) -o $@ $^
+
 
-# rule how to run the program
+# To make running the application somewhat independent of the actual
+# program name, we usually declare a rule `run' which simply runs the
+# program. You can then run it by typing `make run'. This is also
+# useful if you want to call the executable with arguments which do
+# not change frequently. You may then want to add them to the
+# following rule:
 run: $(target)
-       $(target) $(run-parameters)
-       $(additional-run-action)
+       @echo ============================ Running $<
+       ./$(target) 2 $(target).prm 
+       ./$(target) 3 $(target).prm
+       gnuplot make_ps
 
 
-# rule to make object files
+# As a last rule to the `make' program, we define what to do when
+# cleaning up a directory. This usually involves deleting object files
+# and other automatically created files such as the executable itself,
+# backup files, and data files. Since the latter are not usually quite
+# diverse, you needed to declare them at the top of this file.
+clean:
+       -rm -f *.o *.go *~ Makefile.dep $(target) $(clean-up-files)
+
+
+# Since we have not yet stated how to make an object file from a C++
+# file, we should do so now. Since the many flags passed to the
+# compiler are usually not of much interest, we suppress the actual
+# command line using the `at' sign in the first column of the rules
+# and write the string indicating what we do instead.
 %.go : %.cc
-       @echo ============================ Compiling with debugging information:   $<
-       @echo $(CXX) ... -c $< -o $@
+       @echo ==============debug========= $(<F)
        @$(CXX) $(CXXFLAGS.g) -c $< -o $@
 %.o : %.cc
-       @echo ============================ Compiling with optimization:   $<
-       @echo $(CXX) ... -c $< -o $@
+       @echo ==============optimized===== $(<F)
        @$(CXX) $(CXXFLAGS) -c $< -o $@
 
 
-# rules which files the libraries depend upon
-Obj.a: ./Obj.a($(o-files))
-Obj.g.a: ./Obj.g.a($(go-files))
-
+# The following statement tells make that the rules `run' and `clean'
+# are not expected to produce files of the same name as Makefile rules
+# usually do.
+.PHONY: run clean
 
-clean:
-       -rm -f *.o *.go *~ Makefile.dep Obj.a Obj.g.a $(target) $(delete-files)
 
-
-
-.PHONY: clean
-
-
-#Rule to generate the dependency file. This file is
-#automagically remade whenever needed, i.e. whenever
-#one of the cc-/h-files changed. Make detects whether
-#to remake this file upon inclusion at the bottom
-#of this file.
+# Finally there is a rule which you normally need not care much about:
+# since the executable depends on some include files from the library,
+# besides the C++ application file of course, it is necessary to
+# re-generate the executable when one of the files it depends on has
+# changed. The following rule to created a dependency file
+# `Makefile.dep', which `make' uses to determine when to regenerate
+# the executable. This file is automagically remade whenever needed,
+# i.e. whenever one of the cc-/h-files changed. Make detects whether
+# to remake this file upon inclusion at the bottom of this file.
 #
-#use perl to generate rules for the .go files as well
-#as to make rules not for tria.o and the like, but
-#rather for libnumerics.a(tria.o)
-Makefile.dep: $(cc-files) $(h-files) $(lib-h-files)
+# The dependency file is created using a perl script.  Since the
+# script prefixes the output names by `lib/o' or `lib/go' (it was
+# written for the sublibraries' Makefile), we have to strip that again
+# since object files are placed in the present directory for this
+# application. All these things are made in the next rule:
+Makefile.dep: $(target).cc Makefile \
+              $(shell echo $(include-path-base)/base/*.h    \
+                           $(include-path-lac)/lac/*.h     \
+                           $(include-path-deal2)/*/*.h)
        @echo ============================ Remaking Makefile
-       @perl $D/common/scripts/Make_dep.pl ./Obj $(INCLUDE) $(cc-files) \
+       @perl $D/common/scripts/make_dependencies.pl  $(INCLUDE) $(target).cc \
+               | perl -pi -e 's!lib/g?o/!!g;' \
                > Makefile.dep
 
-
+# To make the dependencies known to `make', we finally have to include
+# them:
 include Makefile.dep
 
+
index 3744bd3dbd96fa39105b6ac89927c99c56f2a00b..96921c2ca16c1badb6511bbc6217df539da62f46 100644 (file)
@@ -1,79 +1,85 @@
 # $Id$
-# Copyright W. Bangerth, University of Heidelberg, 1998
+# Copyright W. Bangerth, University of Heidelberg, 1998, 1999, 2000
 
-# Template for makefiles for the examples subdirectory. In principle,
-# everything should be done automatically if you set the target file
-# here correctly:
+
+# For the small projects Makefile, you basically need to fill in only
+# four fields.
+#
+# The first is the name of the application. It is assumed that the
+# application name is the same as the base file name of the single C++
+# file from which the application is generated.
 target   = error-estimation
 
-# All dependencies between files should be updated by the included
-# file Makefile.dep if necessary. Object files are compiled into
-# the archives ./Obj.a and ./Obj.g.a. By default, the debug version
-# is used to link. It you don't like that, change the following
-# variable to "off"
+# The second field determines whether you want to run your program in
+# debug or optimized mode. The latter is significantly faster, but no
+# run-time checking of parameters and internal states is performed, so
+# you should set this value to `on' while you develop your program,
+# and to `off' when running production computations.
 debug-mode = on
 
-# If you want your program to be linked with extra object or library
-# files, specify them here:
-user-libs =
-
-# To run the program, use "make run"; to give parameters to the program,
-# give the parameters to the following variable:
-run-parameters  = ee.gauss.prm
-
-# To execute additional action apart from running the program, fill
-# in this list:
-run-action=\
-       $(target) ee.gauss.prm; \
-       $(target) ee.singular.prm; \
-       $(target) ee.kink.prm; \
-       gnuplot make_ps; \
-       perl -pi -e 's/^\#.*$$\\${}n//g' data-*/*.inp
 
-# To specify which files are to be deleted by "make clean" (apart from
-# the usual ones: object files, executables, backups, etc), fill in the
-# following list
-delete-files = data-*/*
+# As third field, we need to give the path to the top-level deal.II
+# directory. You need to adjust this to your needs. Since this path is
+# probably the most often needed one in the Makefile internals, it is
+# designated by a single-character variable, since that can be
+# reference using $D only, i.e. without the parentheses that are
+# required for most other parameters, as e.g. in $(target).
+D = ../../..
 
 
+# The last field specifies the names of data and other files that
+# shall be deleted when calling `make clean'. Object and backup files,
+# executables and the like are removed anyway. Here, we give a list of
+# files in the various output formats that deal.II supports.
+clean-up-files = *gmv *gnuplot *gpl *eps *pov
 
 
-###############################################################################
-# Internals
 
-#deal include base path
-D = ../../..
 
+#
+#
+# Usually, you will not need to change something beyond this point.
+#
+#
+# The next statement tell the `make' program where to find the
+# deal.II top level directory and to include the file with the global
+# settings
 include $D/common/Make.global_options
 
 
-# get lists of files we need
-cc-files    = $(filter-out *%, $(shell echo *.cc))
-o-files     = $(cc-files:.cc=.o)
-go-files    = $(cc-files:.cc=.go)
-h-files     = $(filter-out *%, $(shell echo *.h))
-lib-h-files = $(filter-out *%, $(shell echo ../../include/*/*.h))
-
-# list of libraries needed to link with
-libs.g   = ./Obj.g.a         \
-           $(lib-deal2-2d.g) \
+# Since the whole project consists of only one file, we need not
+# consider difficult dependencies. We only have to declare the
+# libraries which we want to link to the object file, and there need
+# to be two sets of libraries: one for the debug mode version of the
+# application and one for the optimized mode. Here we have selected
+# the versions for 2d. Note that the order in which the libraries are
+# given here is important and that your applications won't link
+# properly if they are given in another order.
+#
+# You may need to augment the lists of libraries when compiling your
+# program for other dimensions, or when using third party libraries
+libs.g   = $(lib-deal2-2d.g) \
           $(lib-lac.g)      \
            $(lib-base.g)
-libs     = ./Obj.a           \
-           $(lib-deal2-2d.o) \
+libs.o   = $(lib-deal2-2d.o) \
           $(lib-lac.o)      \
            $(lib-base.o)
 
-# check whether we use debug mode or not
+
+# We now use the variable defined above which switch between debug and
+# optimized mode to select the correct compiler flags and the set of
+# libraries to link with. Included in the list of libraries is the
+# name of the object file which we will produce from the single C++
+# file. Note that by default we use the extension .go for object files
+# compiled in debug mode and .o for object files in optimized mode.
 ifeq ($(debug-mode),on)
-libraries = $(libs.g)
-flags     = $(CXXFLAGS.g)
+  libraries = $(target).go $(libs.g)
+  flags     = $(CXXFLAGS.g)
+else
+  libraries = $(target).go $(libs.o)
+  flags     = $(CXXFLAGS.o)
 endif
 
-ifeq ($(debug-mode),off)
-libraries = $(libs)
-flags     = $(CXXFLAGS)
-endif
 
 # If in multithread mode, add the ACE library to the libraries which
 # we need to link with:
@@ -82,52 +88,85 @@ ifneq ($(with-multithreading),no)
 endif
 
 
-# make rule for the target
+
+# Now comes the first production rule: how to link the single object
+# file produced from the single C++ file into the executable. Since
+# this is the first rule in the Makefile, it is the one `make' selects
+# if you call it without arguments.
 $(target) : $(libraries)
        @echo ============================ Linking $@
-       @$(CXX) $(flags) -o $@ $^ $(user-libs)
+       @$(CXX) $(flags) -o $@ $^
 
-run: $(target)
-       $(run-action)
-
-# rule to make object files
-%.go : %.cc
-       @echo ============================ Compiling with debugging information:   $<
-       @echo $(CXX) ... -c $< -o $@
-       @$(CXX) $(CXXFLAGS.g) -c $< -o $@
-%.o : %.cc
-       @echo ============================ Compiling with optimization:   $<
-       @echo $(CXX) ... -c $< -o $@
-       @$(CXX) $(CXXFLAGS) -c $< -o $@
 
+# To make running the application somewhat independent of the actual
+# program name, we usually declare a rule `run' which simply runs the
+# program. You can then run it by typing `make run'. This is also
+# useful if you want to call the executable with arguments which do
+# not change frequently. You may then want to add them to the
+# following rule:
+run: $(target)
+       @echo ============================ Running $<
+       ./$(target) ee.gauss.prm
+       ./(target) ee.singular.prm; \
+       ./$(target) ee.kink.prm; \
+       gnuplot make_ps; \
 
-# rules which files the libraries depend upon
-Obj.a: ./Obj.a($(o-files))
-Obj.g.a: ./Obj.g.a($(go-files))
 
 
+# As a last rule to the `make' program, we define what to do when
+# cleaning up a directory. This usually involves deleting object files
+# and other automatically created files such as the executable itself,
+# backup files, and data files. Since the latter are not usually quite
+# diverse, you needed to declare them at the top of this file.
 clean:
-       -rm -f *.o *.go *~ Makefile.dep Obj.a Obj.g.a $(target) $(delete-files)
+       -rm -f *.o *.go *~ Makefile.dep $(target) $(clean-up-files)
 
 
+# Since we have not yet stated how to make an object file from a C++
+# file, we should do so now. Since the many flags passed to the
+# compiler are usually not of much interest, we suppress the actual
+# command line using the `at' sign in the first column of the rules
+# and write the string indicating what we do instead.
+%.go : %.cc
+       @echo ==============debug========= $(<F)
+       @$(CXX) $(CXXFLAGS.g) -c $< -o $@
+%.o : %.cc
+       @echo ==============optimized===== $(<F)
+       @$(CXX) $(CXXFLAGS) -c $< -o $@
 
-.PHONY: clean
 
+# The following statement tells make that the rules `run' and `clean'
+# are not expected to produce files of the same name as Makefile rules
+# usually do.
+.PHONY: run clean
 
-#Rule to generate the dependency file. This file is
-#automagically remade whenever needed, i.e. whenever
-#one of the cc-/h-files changed. Make detects whether
-#to remake this file upon inclusion at the bottom
-#of this file.
+
+# Finally there is a rule which you normally need not care much about:
+# since the executable depends on some include files from the library,
+# besides the C++ application file of course, it is necessary to
+# re-generate the executable when one of the files it depends on has
+# changed. The following rule to created a dependency file
+# `Makefile.dep', which `make' uses to determine when to regenerate
+# the executable. This file is automagically remade whenever needed,
+# i.e. whenever one of the cc-/h-files changed. Make detects whether
+# to remake this file upon inclusion at the bottom of this file.
 #
-#use perl to generate rules for the .go files as well
-#as to make rules not for tria.o and the like, but
-#rather for libnumerics.a(tria.o)
-Makefile.dep: $(cc-files) $(h-files) $(lib-h-files)
+# The dependency file is created using a perl script.  Since the
+# script prefixes the output names by `lib/o' or `lib/go' (it was
+# written for the sublibraries' Makefile), we have to strip that again
+# since object files are placed in the present directory for this
+# application. All these things are made in the next rule:
+Makefile.dep: $(target).cc Makefile \
+              $(shell echo $(include-path-base)/base/*.h    \
+                           $(include-path-lac)/lac/*.h     \
+                           $(include-path-deal2)/*/*.h)
        @echo ============================ Remaking Makefile
-       @perl $D/common/scripts/Make_dep.pl ./Obj $(INCLUDE) $(cc-files) \
+       @perl $D/common/scripts/make_dependencies.pl  $(INCLUDE) $(target).cc \
+               | perl -pi -e 's!lib/g?o/!!g;' \
                > Makefile.dep
 
-
+# To make the dependencies known to `make', we finally have to include
+# them:
 include Makefile.dep
 
+
index 9bd38ee827a2cbfe22f00e3d6b9ef8891aac775c..455e443c64c39c9af6bd087dc66e6d5b3038b974 100644 (file)
@@ -1,77 +1,87 @@
 # $Id$
-# Copyright W. Bangerth, University of Heidelberg, 1998
+# Copyright W. Bangerth, University of Heidelberg, 1998, 1999, 2000
 
-# Template for makefiles for the examples subdirectory. In principle,
-# everything should be done automatically if you set the target file
-# here correctly:
+
+# For the small projects Makefile, you basically need to fill in only
+# four fields.
+#
+# The first is the name of the application. It is assumed that the
+# application name is the same as the base file name of the single C++
+# file from which the application is generated.
 target   = grid_test
 
-# All dependencies between files should be updated by the included
-# file Makefile.dep if necessary. Object files are compiled into
-# the archives ./Obj.a and ./Obj.g.a. By default, the debug version
-# is used to link. It you don't like that, change the following
-# variable to "off"
+# The second field determines whether you want to run your program in
+# debug or optimized mode. The latter is significantly faster, but no
+# run-time checking of parameters and internal states is performed, so
+# you should set this value to `on' while you develop your program,
+# and to `off' when running production computations.
 debug-mode = on
 
-# If you want your program to be linked with extra object or library
-# files, specify them here:
-user-libs =
-
-# To run the program, use "make run"; to give parameters to the program,
-# give the parameters to the following variable:
-run-parameters  = 2 1
 
-# To execute additional action apart from running the program, fill
-# in this list:
-additional-run-action = grid_test 2 2 ; grid_test 2 3 ; grid_test 2 4 ; grid_test 3 1 ; grid_test 3 2 ; grid_test 3 3 ; grid_test 3 4
-
-# To specify which files are to be deleted by "make clean" (apart from
-# the usual ones: object files, executables, backups, etc), fill in the
-# following list
-delete-files = results/[123]d*
+# As third field, we need to give the path to the top-level deal.II
+# directory. You need to adjust this to your needs. Since this path is
+# probably the most often needed one in the Makefile internals, it is
+# designated by a single-character variable, since that can be
+# reference using $D only, i.e. without the parentheses that are
+# required for most other parameters, as e.g. in $(target).
+D = ../../..
 
 
+# The last field specifies the names of data and other files that
+# shall be deleted when calling `make clean'. Object and backup files,
+# executables and the like are removed anyway. Here, we give a list of
+# files in the various output formats that deal.II supports.
+clean-up-files = *gmv *gnuplot *gpl *eps *pov
 
 
-###############################################################################
-# Internals
 
-#deal include base path
-D = ../../..
 
+#
+#
+# Usually, you will not need to change something beyond this point.
+#
+#
+# The next statement tell the `make' program where to find the
+# deal.II top level directory and to include the file with the global
+# settings
 include $D/common/Make.global_options
 
 
-# get lists of files we need
-cc-files    = $(filter-out *%, $(shell echo *.cc))
-o-files     = $(cc-files:.cc=.o)
-go-files    = $(cc-files:.cc=.go)
-h-files     = $(filter-out *%, $(shell echo *.h))
-lib-h-files = $(filter-out *%, $(shell echo ../../include/*/*.h))
-
-# list of libraries needed to link with
-libs.g   = ./Obj.g.a         \
-           $(lib-deal2-2d.g) \
-           $(lib-deal2-3d.g) \
+# Since the whole project consists of only one file, we need not
+# consider difficult dependencies. We only have to declare the
+# libraries which we want to link to the object file, and there need
+# to be two sets of libraries: one for the debug mode version of the
+# application and one for the optimized mode. Here we have selected
+# the versions for 2d. Note that the order in which the libraries are
+# given here is important and that your applications won't link
+# properly if they are given in another order.
+#
+# You may need to augment the lists of libraries when compiling your
+# program for other dimensions, or when using third party libraries
+libs.g   = $(lib-deal2-2d.g) \
+          $(lib-deal2-3d.g) \
           $(lib-lac.g)      \
            $(lib-base.g)
-libs     = ./Obj.a           \
-           $(lib-deal2-2d.o) \
-           $(lib-deal2-3d.o) \
+libs.o   = $(lib-deal2-2d.o) \
+          $(lib-deal2-3d.o) \
           $(lib-lac.o)      \
            $(lib-base.o)
 
 
-# check whether we use debug mode or not
+# We now use the variable defined above which switch between debug and
+# optimized mode to select the correct compiler flags and the set of
+# libraries to link with. Included in the list of libraries is the
+# name of the object file which we will produce from the single C++
+# file. Note that by default we use the extension .go for object files
+# compiled in debug mode and .o for object files in optimized mode.
 ifeq ($(debug-mode),on)
-libraries = $(libs.g)
-flags     = $(CXXFLAGS.g)
+  libraries = $(target).go $(libs.g)
+  flags     = $(CXXFLAGS.g)
+else
+  libraries = $(target).go $(libs.o)
+  flags     = $(CXXFLAGS.o)
 endif
 
-ifeq ($(debug-mode),off)
-libraries = $(libs)
-flags     = $(CXXFLAGS)
-endif
 
 # If in multithread mode, add the ACE library to the libraries which
 # we need to link with:
@@ -80,55 +90,89 @@ ifneq ($(with-multithreading),no)
 endif
 
 
-# make rule for the target
+
+# Now comes the first production rule: how to link the single object
+# file produced from the single C++ file into the executable. Since
+# this is the first rule in the Makefile, it is the one `make' selects
+# if you call it without arguments.
 $(target) : $(libraries)
        @echo ============================ Linking $@
-       @$(CXX) $(flags) -o $@ $(libraries) $(user-libs)
+       @$(CXX) $(flags) -o $@ $^
+
 
-# rule how to run the program
+# To make running the application somewhat independent of the actual
+# program name, we usually declare a rule `run' which simply runs the
+# program. You can then run it by typing `make run'. This is also
+# useful if you want to call the executable with arguments which do
+# not change frequently. You may then want to add them to the
+# following rule:
 run: $(target)
-       $(target) $(run-parameters)
-       $(additional-run-action)
+       @echo ============================ Running $<
+       ./$(target) 2 1
+       ./$(target) 2 2
+       ./$(target) 2 3
+       ./$(target) 2 4
+       ./$(target) 3 1
+       ./$(target) 3 2
+       ./$(target) 3 3
+       ./$(target) 3 4
+
+
+
+# As a last rule to the `make' program, we define what to do when
+# cleaning up a directory. This usually involves deleting object files
+# and other automatically created files such as the executable itself,
+# backup files, and data files. Since the latter are not usually quite
+# diverse, you needed to declare them at the top of this file.
+clean:
+       -rm -f *.o *.go *~ Makefile.dep $(target) $(clean-up-files)
 
 
-# rule to make object files
+# Since we have not yet stated how to make an object file from a C++
+# file, we should do so now. Since the many flags passed to the
+# compiler are usually not of much interest, we suppress the actual
+# command line using the `at' sign in the first column of the rules
+# and write the string indicating what we do instead.
 %.go : %.cc
-       @echo ============================ Compiling with debugging information:   $<
-       @echo $(CXX) ... -c $< -o $@
+       @echo ==============debug========= $(<F)
        @$(CXX) $(CXXFLAGS.g) -c $< -o $@
 %.o : %.cc
-       @echo ============================ Compiling with optimization:   $<
-       @echo $(CXX) ... -c $< -o $@
+       @echo ==============optimized===== $(<F)
        @$(CXX) $(CXXFLAGS) -c $< -o $@
 
 
-# rules which files the libraries depend upon
-Obj.a: ./Obj.a($(o-files))
-Obj.g.a: ./Obj.g.a($(go-files))
-
-
-clean:
-       rm -f *.o *.go *~ Makefile.dep Obj.a Obj.g.a $(target) $(delete-files)
-
-
+# The following statement tells make that the rules `run' and `clean'
+# are not expected to produce files of the same name as Makefile rules
+# usually do.
+.PHONY: run clean
 
-.PHONY: clean
 
-
-#Rule to generate the dependency file. This file is
-#automagically remade whenever needed, i.e. whenever
-#one of the cc-/h-files changed. Make detects whether
-#to remake this file upon inclusion at the bottom
-#of this file.
+# Finally there is a rule which you normally need not care much about:
+# since the executable depends on some include files from the library,
+# besides the C++ application file of course, it is necessary to
+# re-generate the executable when one of the files it depends on has
+# changed. The following rule to created a dependency file
+# `Makefile.dep', which `make' uses to determine when to regenerate
+# the executable. This file is automagically remade whenever needed,
+# i.e. whenever one of the cc-/h-files changed. Make detects whether
+# to remake this file upon inclusion at the bottom of this file.
 #
-#use perl to generate rules for the .go files as well
-#as to make rules not for tria.o and the like, but
-#rather for libnumerics.a(tria.o)
-Makefile.dep: $(cc-files) $(h-files) $(lib-h-files)
+# The dependency file is created using a perl script.  Since the
+# script prefixes the output names by `lib/o' or `lib/go' (it was
+# written for the sublibraries' Makefile), we have to strip that again
+# since object files are placed in the present directory for this
+# application. All these things are made in the next rule:
+Makefile.dep: $(target).cc Makefile \
+              $(shell echo $(include-path-base)/base/*.h    \
+                           $(include-path-lac)/lac/*.h     \
+                           $(include-path-deal2)/*/*.h)
        @echo ============================ Remaking Makefile
-       @perl $D/common/scripts/Make_dep.pl ./Obj $(INCLUDE) $(cc-files) \
+       @perl $D/common/scripts/make_dependencies.pl  $(INCLUDE) $(target).cc \
+               | perl -pi -e 's!lib/g?o/!!g;' \
                > Makefile.dep
 
-
+# To make the dependencies known to `make', we finally have to include
+# them:
 include Makefile.dep
 
+
index 6ed598d4339d7865a598287c4c6c042b6fe2d99f..c0b78a5d493aeb19f0b8772b919c6b6b59e823d4 100644 (file)
@@ -1,74 +1,83 @@
 # $Id$
-# Copyright W. Bangerth, University of Heidelberg, 1998
+# Copyright W. Bangerth, University of Heidelberg, 1998, 1999, 2000
 
-# Template for makefiles for the examples subdirectory. In principle,
-# everything should be done automatically if you set the target file
-# here correctly:
+
+# For the small projects Makefile, you basically need to fill in only
+# four fields.
+#
+# The first is the name of the application. It is assumed that the
+# application name is the same as the base file name of the single C++
+# file from which the application is generated.
 target   = multigrid
 
-# All dependencies between files should be updated by the included
-# file Makefile.dep if necessary. Object files are compiled into
-# the archives ./Obj.a and ./Obj.g.a. By default, the debug version
-# is used to link. It you don't like that, change the following
-# variable to "off"
+# The second field determines whether you want to run your program in
+# debug or optimized mode. The latter is significantly faster, but no
+# run-time checking of parameters and internal states is performed, so
+# you should set this value to `on' while you develop your program,
+# and to `off' when running production computations.
 debug-mode = on
 
-# If you want your program to be linked with extra object or library
-# files, specify them here:
-user-libs =
-
-# To run the program, use "make run"; to give parameters to the program,
-# give the parameters to the following variable:
-run-parameters  = 
-
-# To execute additional action apart from running the program, fill
-# in this list:
-additional-run-action = gnuplot make_ps
 
-# To specify which files are to be deleted by "make clean" (apart from
-# the usual ones: object files, executables, backups, etc), fill in the
-# following list
-delete-files = *gnuplot *.eps *ucd *history
+# As third field, we need to give the path to the top-level deal.II
+# directory. You need to adjust this to your needs. Since this path is
+# probably the most often needed one in the Makefile internals, it is
+# designated by a single-character variable, since that can be
+# reference using $D only, i.e. without the parentheses that are
+# required for most other parameters, as e.g. in $(target).
+D = ../../..
 
 
+# The last field specifies the names of data and other files that
+# shall be deleted when calling `make clean'. Object and backup files,
+# executables and the like are removed anyway. Here, we give a list of
+# files in the various output formats that deal.II supports.
+clean-up-files = *gmv *gnuplot *gpl *eps *pov
 
 
-###############################################################################
-# Internals
 
-#deal include base path
-D = ../../..
 
+#
+#
+# Usually, you will not need to change something beyond this point.
+#
+#
+# The next statement tell the `make' program where to find the
+# deal.II top level directory and to include the file with the global
+# settings
 include $D/common/Make.global_options
 
 
-# get lists of files we need
-cc-files    = $(filter-out *%, $(shell echo *.cc))
-o-files     = $(cc-files:.cc=.o)
-go-files    = $(cc-files:.cc=.go)
-h-files     = $(filter-out *%, $(shell echo *.h))
-lib-h-files = $(filter-out *%, $(shell echo ../../include/*/*.h))
-
-# list of libraries needed to link with
-libs.g   = ./Obj.g.a         \
-           $(lib-deal2-2d.g) \
+# Since the whole project consists of only one file, we need not
+# consider difficult dependencies. We only have to declare the
+# libraries which we want to link to the object file, and there need
+# to be two sets of libraries: one for the debug mode version of the
+# application and one for the optimized mode. Here we have selected
+# the versions for 2d. Note that the order in which the libraries are
+# given here is important and that your applications won't link
+# properly if they are given in another order.
+#
+# You may need to augment the lists of libraries when compiling your
+# program for other dimensions, or when using third party libraries
+libs.g   = $(lib-deal2-2d.g) \
           $(lib-lac.g)      \
            $(lib-base.g)
-libs     = ./Obj.a           \
-           $(lib-deal2-2d.o) \
+libs.o   = $(lib-deal2-2d.o) \
           $(lib-lac.o)      \
            $(lib-base.o)
 
 
-# check whether we use debug mode or not
+# We now use the variable defined above which switch between debug and
+# optimized mode to select the correct compiler flags and the set of
+# libraries to link with. Included in the list of libraries is the
+# name of the object file which we will produce from the single C++
+# file. Note that by default we use the extension .go for object files
+# compiled in debug mode and .o for object files in optimized mode.
 ifeq ($(debug-mode),on)
-libraries = $(libs.g)
-flags     = $(CXXFLAGS.g)
-endif
-
-ifeq ($(debug-mode),off)
-libraries = $(libs)
-flags     = $(CXXFLAGS)
+  libraries = $(target).go $(libs.g)
+  flags     = $(CXXFLAGS.g)
+else
+  libraries = $(target).go $(libs.o)
+  flags     = $(CXXFLAGS.o)
 endif
 
 
@@ -78,55 +87,83 @@ ifneq ($(with-multithreading),no)
   libraries += $(lib-ACE)
 endif
 
-# make rule for the target
+
+
+# Now comes the first production rule: how to link the single object
+# file produced from the single C++ file into the executable. Since
+# this is the first rule in the Makefile, it is the one `make' selects
+# if you call it without arguments.
 $(target) : $(libraries)
        @echo ============================ Linking $@
-       @$(CXX) $(flags) -o $@ $^ $(user-libs)
+       @$(CXX) $(flags) -o $@ $^
 
-# rule how to run the program
+
+# To make running the application somewhat independent of the actual
+# program name, we usually declare a rule `run' which simply runs the
+# program. You can then run it by typing `make run'. This is also
+# useful if you want to call the executable with arguments which do
+# not change frequently. You may then want to add them to the
+# following rule:
 run: $(target)
-       $(target) $(run-parameters)
-       $(additional-run-action)
+       @echo ============================ Running $<
+       @./$(target)
+       gnuplot make_ps
 
 
-# rule to make object files
+# As a last rule to the `make' program, we define what to do when
+# cleaning up a directory. This usually involves deleting object files
+# and other automatically created files such as the executable itself,
+# backup files, and data files. Since the latter are not usually quite
+# diverse, you needed to declare them at the top of this file.
+clean:
+       -rm -f *.o *.go *~ Makefile.dep $(target) $(clean-up-files)
+
+
+# Since we have not yet stated how to make an object file from a C++
+# file, we should do so now. Since the many flags passed to the
+# compiler are usually not of much interest, we suppress the actual
+# command line using the `at' sign in the first column of the rules
+# and write the string indicating what we do instead.
 %.go : %.cc
-       @echo ============================ Compiling with debugging information:   $<
-       @echo $(CXX) ... -c $< -o $@
+       @echo ==============debug========= $(<F)
        @$(CXX) $(CXXFLAGS.g) -c $< -o $@
 %.o : %.cc
-       @echo ============================ Compiling with optimization:   $<
-       @echo $(CXX) ... -c $< -o $@
+       @echo ==============optimized===== $(<F)
        @$(CXX) $(CXXFLAGS) -c $< -o $@
 
 
-# rules which files the libraries depend upon
-Obj.a: ./Obj.a($(o-files))
-Obj.g.a: ./Obj.g.a($(go-files))
-
+# The following statement tells make that the rules `run' and `clean'
+# are not expected to produce files of the same name as Makefile rules
+# usually do.
+.PHONY: run clean
 
-clean:
-       -rm -f *.o *.go *~ Makefile.dep Obj.a Obj.g.a $(target) $(delete-files)
-
-
-
-.PHONY: clean
 
-
-#Rule to generate the dependency file. This file is
-#automagically remade whenever needed, i.e. whenever
-#one of the cc-/h-files changed. Make detects whether
-#to remake this file upon inclusion at the bottom
-#of this file.
+# Finally there is a rule which you normally need not care much about:
+# since the executable depends on some include files from the library,
+# besides the C++ application file of course, it is necessary to
+# re-generate the executable when one of the files it depends on has
+# changed. The following rule to created a dependency file
+# `Makefile.dep', which `make' uses to determine when to regenerate
+# the executable. This file is automagically remade whenever needed,
+# i.e. whenever one of the cc-/h-files changed. Make detects whether
+# to remake this file upon inclusion at the bottom of this file.
 #
-#use perl to generate rules for the .go files as well
-#as to make rules not for tria.o and the like, but
-#rather for libnumerics.a(tria.o)
-Makefile.dep: $(cc-files) $(h-files) $(lib-h-files)
+# The dependency file is created using a perl script.  Since the
+# script prefixes the output names by `lib/o' or `lib/go' (it was
+# written for the sublibraries' Makefile), we have to strip that again
+# since object files are placed in the present directory for this
+# application. All these things are made in the next rule:
+Makefile.dep: $(target).cc Makefile \
+              $(shell echo $(include-path-base)/base/*.h    \
+                           $(include-path-lac)/lac/*.h     \
+                           $(include-path-deal2)/*/*.h)
        @echo ============================ Remaking Makefile
-       @perl $D/common/scripts/Make_dep.pl ./Obj $(INCLUDE) $(cc-files) \
+       @perl $D/common/scripts/make_dependencies.pl  $(INCLUDE) $(target).cc \
+               | perl -pi -e 's!lib/g?o/!!g;' \
                > Makefile.dep
 
-
+# To make the dependencies known to `make', we finally have to include
+# them:
 include Makefile.dep
 
+

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.