EnglishFrenchSpanish

OnWorks favicon

makepp_builtin - Online in the Cloud

Run makepp_builtin in OnWorks free hosting provider over Ubuntu Online, Fedora Online, Windows online emulator or MAC OS online emulator

This is the command makepp_builtin that can be run in the OnWorks free hosting provider using one of our multiple free online workstations such as Ubuntu Online, Fedora Online, Windows online emulator or MAC OS online emulator

PROGRAM:

NAME


makepp_builtin -- Built in rules for makepp

DESCRIPTION


Makepp may be able to figure out how to compile and link your program even if you specify
no rules at all (or if you don't even have a Makeppfile). After every Makeppfile is
loaded, makepp also loads a set of default rules. (These rules are special in that they
do not override any other rules in the Makeppfile.) The default rule database is stored
in the file "makepp_builtin_rules.mk" in the makepp distribution or library directory, so
you can always look at that to see exactly what the default rules are.

Makepp's builtin rules are almost the same as the rules in GNU make, except that it has no
rules for some of the rare languages that GNU make has rules for. (This is deliberate; I
often ran into trouble with GNU make on several projects that accidentally reused some of
the suffixes that GNU make assigned to those rare languages.) The rules use the same
variables as GNU make, with some possibly useful additions. Makepp is smarter than GNU
make about inferring which compiler to use, and which other objects and libraries to link
in.

Default variable values
Makepp supplies default values for a number of variables. Most of these are typically
used in rules, and are indeed used in the default rules. Their values can be overridden
by assigning to these variables in your Makeppfile or on the command line.

These variables are documented in "Predefined Variables" in makepp_variables. If you have
any questions about what any variable evaluates to, you can always put a line like either
of these lines in your Makeppfile:

dummy := $(print $(CC))
&echo -- $(CC) # Must be indented less than previous rule.

which simply prints the value of the "$(CC)" variable when the Makeppfile is loaded.
(Incidentally, this is a useful way to debug any expression that you're not sure is
right.)

Compilation rules
In simplified form, here is approximately what the compilation rules look like. If you
change the values of any of the indicated variables, the compilation command is changed as
expected.

#
# For C programs:
#
%.o: %.c
$(CC) $(CFLAGS) $(CPPFLAGS) -c $(input) -o $(output)

#
# For C++ programs:
#
%.o: %.cxx # and also %.cc, %.cpp, %.c++, and %.C
$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $(input) -o $(output)

#
# For Fortran programs:
#
%.o: %.f
$(FC) $(FFLAGS) -c $(input) -o $(output)

#
# Yacc and lex:
#
%.c: %.y
$(YACC) $(YFLAGS) $(input)
&mv -f y.tab.c $(output)

%.c: %.l
$(LEX) $(LFLAGS) -t $(input) -o $(output)

If you're curious about the exact details, you can look in the file
makepp_builtin_rules.mk in the makepp distribution.

Link rules
Makepp also knows how to link programs, too. Makepp attempts to be more clever than the
standard Unix make when it comes to figuring out a link command. Suppose you are trying
to build the target program "xyz". Makepp will try to build this from "xyz.o", and
(unlike the standard Unix make) it will also attempt to infer whether any other objects or
libraries need to be linked in.

The link rule looks something like this:

xyz: $(infer_objects xyz.o, *.o)
$(infer_linker $(inputs)) $(inputs) $(LDFLAGS) $(LDLIBS) $(LIBS) -o $(output)

"$(infer_objects)" attempts to infer what other ".o" files need to be linked in based on
what ".h" files are included.

The "inferred linker" is a special bit of magic that turns into "$(CC)" if all the sources
are C code, "$(CXX)" if any of the sources are C++, or "$(F77)" if any of the sources are
Fortran.

Turning off the built-in rules
If you don't like the built-in rules, don't use them. If they don't work for you, your
built is probably sufficiently complicated that you need your own custom Makeppfile
anyway.

To turn off the builtin rules, you can add a line like this to your Makeppfile:

makepp_no_builtin = 1

If you do use them, but not the fairly expensive builtin linker rules, you can turn those
off with:

makepp_no_builtin_linker = 1

For backward compatibility, makepp also turns off its default rules if you include this
line somewhere in your Makeppfile:

.SUFFIXES:

You can turn off builtin rules for every Makeppfile in the entire build by specifying the
"--no-builtin-rules" option on the command line.

Use makepp_builtin online using onworks.net services


Free Servers & Workstations

Download Windows & Linux apps

Linux commands

  • 1
    abiword
    abiword
    abiword � flexible cross-platform word
    processor ...
    Run abiword
  • 2
    abl
    abl
    abl - Prefixed representation for
    boolean functions DESCRIPTION:
    libablmmm.a is a library that enables to
    represent a boolean function in a
    LISP-like form. An ...
    Run abl
  • 3
    cpan2debp
    cpan2debp
    dh-make-perl - Create debian source
    packages from Perl modules ...
    Run cpan2debp
  • 4
    cpan2distp
    cpan2distp
    cpan2dist - The CPANPLUS distribution
    creator DESCRIPTION: This script will
    create distributions of "CPAN" modules
    of the format you specify, including its
    pre...
    Run cpan2distp
  • 5
    gbp-buildpackage
    gbp-buildpackage
    gbp-buildpackage - Build Debian
    packages from a Git repository ...
    Run gbp-buildpackage
  • 6
    gbp-clone
    gbp-clone
    gbp-clone - Clone a repository from
    remote ...
    Run gbp-clone
  • More »

Ad