Autoconf

configure.ac --autoconf/autoheader--> configure + config.h.in
Makefile.in  --./configure----------> Makefile
config.h.in  --./configure----------> config.h
source files --make-----------------> program

tar -xf hello-1.0.tar.gz
cd hello-1.0
./configure
make
make check          # If the project provides tests
sudo make install   # Optional; consider a user-writable --prefix instead

./configure --help
./configure --prefix="$HOME/.local"
./configure CC=clang CFLAGS="-O2 -g"
make -j4
make install

autoreconf --install
./configure
make

autoreconf --force --install
mkdir -p build
cd build
../configure CFLAGS="-Wall -Wextra -g"
make

hello-autoconf/
|-- configure.ac
|-- Makefile.in
`-- src/
    `-- main.c

AC_PREREQ([2.69])
AC_INIT([hello-autoconf], [1.0.0], [bugs@example.org])
AC_CONFIG_SRCDIR([src/main.c])
AC_CONFIG_HEADERS([config.h])

AC_PROG_CC
AC_CHECK_HEADERS([stdlib.h string.h])
AC_CHECK_FUNCS([strdup])

AC_CONFIG_FILES([Makefile])
AC_OUTPUT

#include <config.h>

#include <stdio.h>

int main(void) {
    printf("Hello from %s!\n", PACKAGE_STRING);
    return 0;
}

srcdir = @srcdir@

CC = @CC@
CPPFLAGS = @CPPFLAGS@ -I.
CFLAGS = @CFLAGS@
LDFLAGS = @LDFLAGS@
LIBS = @LIBS@

PROGRAM = hello
SOURCES = $(srcdir)/src/main.c

.PHONY: all clean distclean

all: $(PROGRAM)

$(PROGRAM): $(SOURCES) config.h
	$(CC) $(CPPFLAGS) $(CFLAGS) -o $@ $(SOURCES) $(LDFLAGS) $(LIBS)

clean:
	rm -f $(PROGRAM)

distclean: clean
	rm -f Makefile config.h config.log config.status

autoreconf --install
./configure CFLAGS="-Wall -Wextra -g"
make
./hello

configure       # Distribute this so builders do not need Autoconf
config.h.in     # Distribute this if config.h is generated
config.log      # Local diagnostics from running configure
config.status   # Local regeneration helper
config.h        # Local configured header
Makefile        # Local configured build rules

AC_PREREQ([2.69])
AC_INIT([package-name], [version], [bugs@example.org], [tar-name], [homepage])
AC_CONFIG_SRCDIR([src/main.c])
AC_CONFIG_HEADERS([config.h])

# Tool discovery
AC_PROG_CC
AC_PROG_INSTALL

# Options selected by the builder
AC_ARG_ENABLE(...)
AC_ARG_WITH(...)

# System feature checks
AC_CHECK_HEADERS(...)
AC_CHECK_FUNCS(...)
AC_SEARCH_LIBS(...)

# Generated outputs
AC_CONFIG_FILES([Makefile src/Makefile])
AC_OUTPUT

AC_INIT([calculator], [2.1.0], [bugs@example.org])
AC_CHECK_HEADERS([stdint.h unistd.h])
AC_CHECK_FUNCS([getline snprintf])

# Good: portable shell used inside generated configure
if test "x$enable_debug" = xyes; then
  AC_DEFINE([ENABLE_DEBUG], [1], [Define to enable debug logging.])
fi

AC_ARG_WITH([greeting],
  [AS_HELP_STRING([--with-greeting=TEXT], [message printed by the program])],
  [GREETING=$withval],
  [GREETING=Hello])
AC_SUBST([GREETING])

GREETING = @GREETING@

AC_DEFINE([ENABLE_LOGGING], [1], [Define to compile logging support.])

#define ENABLE_LOGGING 1

AC_DEFINE_UNQUOTED([APP_DEFAULT_PORT], [$default_port],
  [Default TCP port used by the application.])

#include <config.h>

#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif

#ifdef ENABLE_LOGGING
# include <stdio.h>
# define LOG(message) fprintf(stderr, "%s\n", (message))
#else
# define LOG(message) ((void) 0)
#endif

AC_PROG_CC
AC_PROG_CXX

AC_LANG_PUSH([C++])
AC_COMPILE_IFELSE(
  [AC_LANG_PROGRAM([[#include <vector>]], [[std::vector<int> v; v.push_back(1);]])],
  [AC_MSG_NOTICE([C++ vector support is available])],
  [AC_MSG_ERROR([a usable C++ standard library is required])])
AC_LANG_POP([C++])

AC_CHECK_HEADERS([stdint.h stdlib.h string.h unistd.h])
AC_CHECK_HEADERS([sys/socket.h netinet/in.h arpa/inet.h])

#define HAVE_STDINT_H 1
#define HAVE_SYS_SOCKET_H 1

AC_CHECK_HEADERS([sys/socket.h])
AC_CHECK_HEADERS([netinet/in.h], [], [],
[AC_INCLUDES_DEFAULT[
#ifdef HAVE_SYS_SOCKET_H
# include <sys/socket.h>
#endif
]])

AC_CHECK_FUNCS([getline memmove snprintf strdup strnlen])

AC_CHECK_FUNC([clock_gettime],
  [AC_DEFINE([HAVE_CLOCK_GETTIME], [1],
    [Define if clock_gettime is available.])],
  [AC_MSG_WARN([clock_gettime unavailable; using fallback timing])])

AC_CHECK_TYPES([ssize_t, uint32_t])
AC_CHECK_MEMBERS([struct stat.st_mtim])
AC_CHECK_SIZEOF([long])
AC_TYPE_SIZE_T
AC_TYPE_PID_T

AC_SEARCH_LIBS([clock_gettime], [rt],
  [],
  [AC_MSG_ERROR([clock_gettime is required])])

AC_SEARCH_LIBS([socket], [socket],
  [],
  [AC_MSG_ERROR([socket support is required])])

AC_CHECK_LIB([m], [sin],
  [],
  [AC_MSG_ERROR([the math library is required])])

$(CC) $(CPPFLAGS) $(CFLAGS) -o app $(OBJECTS) $(LDFLAGS) $(LIBS)

AC_CHECK_HEADERS([zlib.h], [],
  [AC_MSG_ERROR([zlib headers are required])])
AC_CHECK_LIB([z], [inflate], [],
  [AC_MSG_ERROR([zlib library is required])])

PKG_PROG_PKG_CONFIG
PKG_CHECK_MODULES([LIBXML], [libxml-2.0 >= 2.9])
AC_SUBST([LIBXML_CFLAGS])
AC_SUBST([LIBXML_LIBS])

CPPFLAGS = @CPPFLAGS@ @LIBXML_CFLAGS@
LIBS = @LIBXML_LIBS@ @LIBS@

AC_ARG_ENABLE([debug],
  [AS_HELP_STRING([--enable-debug], [compile debug logging support])],
  [],
  [enable_debug=no])

AS_CASE([$enable_debug],
  [yes], [AC_DEFINE([ENABLE_DEBUG], [1],
           [Define to compile debug logging support.])],
  [no],  [],
  [AC_MSG_ERROR([--enable-debug accepts only yes or no])])

./configure --enable-debug
./configure --disable-debug

AC_ARG_WITH([ssl],
  [AS_HELP_STRING([--with-ssl=PREFIX],
    [use TLS support installed below PREFIX])],
  [ssl_prefix=$withval],
  [ssl_prefix=no])

AS_IF([test "x$ssl_prefix" != xno], [
  AS_IF([test "x$ssl_prefix" != xyes], [
    CPPFLAGS="$CPPFLAGS -I$ssl_prefix/include"
    LDFLAGS="$LDFLAGS -L$ssl_prefix/lib"
  ])
  AC_CHECK_HEADERS([openssl/ssl.h], [],
    [AC_MSG_ERROR([OpenSSL headers not found])])
  AC_CHECK_LIB([ssl], [SSL_new], [],
    [AC_MSG_ERROR([OpenSSL library not found])])
  AC_DEFINE([WITH_SSL], [1], [Define to build TLS support.])
])

./configure --with-ssl
./configure --with-ssl=/opt/openssl

AC_MSG_NOTICE([checking optional networking support])
AC_MSG_WARN([documentation will not be generated])
AC_MSG_ERROR([libfoo >= 2.0 is required])
AC_MSG_CHECKING([whether experimental mode is enabled])
AC_MSG_RESULT([$enable_experimental])

AC_COMPILE_IFELSE(
  [AC_LANG_PROGRAM(
    [[#include <stdatomic.h>]],
    [[_Atomic int counter = 0; return (int) counter;]])],
  [AC_DEFINE([HAVE_C11_ATOMICS], [1],
    [Define if C11 atomics are available.])],
  [AC_MSG_WARN([C11 atomics unavailable; using mutex fallback])])

save_LIBS=$LIBS
LIBS="$LIBS -lpthread"
AC_LINK_IFELSE(
  [AC_LANG_PROGRAM(
    [[#include <pthread.h>]],
    [[pthread_t t; return pthread_create(&t, 0, 0, 0);]])],
  [AC_DEFINE([HAVE_PTHREAD_CREATE], [1],
    [Define if POSIX threads are linkable.])],
  [AC_MSG_ERROR([POSIX threads are required])])
LIBS=$save_LIBS

AC_RUN_IFELSE(
  [AC_LANG_PROGRAM([], [[return 0;]])],
  [AC_MSG_NOTICE([test program ran successfully])],
  [AC_MSG_ERROR([test program failed])],
  [AC_MSG_NOTICE([cross compiling: skipping run-time probe])])

mkdir build-debug
cd build-debug
../configure --prefix="$HOME/.local" CFLAGS="-O0 -g"
make
make install

./config.status             # Recreate configured files
./config.status Makefile    # Recreate one configured output
./config.status --recheck   # Rerun configure using its saved arguments

prefix = @prefix@
exec_prefix = @exec_prefix@
bindir = @bindir@
includedir = @includedir@
libdir = @libdir@

install:
	mkdir -p "$(DESTDIR)$(bindir)"
	cp hello "$(DESTDIR)$(bindir)/hello"

./configure --prefix=/usr/local
make
make DESTDIR="$PWD/stage" install

AC_CANONICAL_BUILD
AC_CANONICAL_HOST
AC_PROG_CC

./configure --build=x86_64-pc-linux-gnu \
  --host=aarch64-linux-gnu \
  CC=aarch64-linux-gnu-gcc
make

AC_CACHE_CHECK([whether the target has working frobnicate],
  [ac_cv_have_working_frobnicate], [
    AC_RUN_IFELSE(
      [AC_LANG_PROGRAM([[#include <frobnicate.h>]],
        [[return frobnicate() ? 0 : 1;]])],
      [ac_cv_have_working_frobnicate=yes],
      [ac_cv_have_working_frobnicate=no],
      [AC_MSG_ERROR([set ac_cv_have_working_frobnicate for cross compilation])])
  ])

AS_IF([test "x$ac_cv_have_working_frobnicate" = xyes], [
  AC_DEFINE([HAVE_WORKING_FROBNICATE], [1],
    [Define if frobnicate works on the host system.])
])

./configure --host=aarch64-linux-gnu \
  ac_cv_have_working_frobnicate=yes

./configure --cache-file=config.cache
rm -f config.cache            # Discard stale cached test answers

hello-automake/
|-- configure.ac
|-- Makefile.am
`-- src/
    |-- Makefile.am
    `-- main.c

AC_PREREQ([2.69])
AC_INIT([hello-automake], [1.0.0], [bugs@example.org])
AM_INIT_AUTOMAKE([foreign subdir-objects])
AC_CONFIG_SRCDIR([src/main.c])
AC_CONFIG_HEADERS([config.h])
AC_PROG_CC
AC_CONFIG_FILES([Makefile src/Makefile])
AC_OUTPUT

SUBDIRS = src

bin_PROGRAMS = hello
hello_SOURCES = main.c
hello_CPPFLAGS = -I$(top_builddir)

autoreconf --install
./configure
make
make check
make distcheck

AC_DEFUN([AX_CHECK_WIDGET], [
  AC_CHECK_HEADERS([widget.h], [],
    [AC_MSG_ERROR([widget.h is required])])
  AC_SEARCH_LIBS([widget_init], [widget], [],
    [AC_MSG_ERROR([libwidget is required])])
])

AC_CONFIG_MACRO_DIRS([m4])
AX_CHECK_WIDGET

ACLOCAL_AMFLAGS = -I m4

autoreconf --force --install

AC_DEFUN([MYPROJECT_CHECK_FAST_INT], [
  AC_REQUIRE([AC_PROG_CC])
  AC_CHECK_SIZEOF([long])
  AS_IF([test "$ac_cv_sizeof_long" -ge 8], [
    AC_DEFINE([HAVE_64BIT_LONG], [1],
      [Define if long is at least 64 bits wide.])
  ])
])

./configure CPPFLAGS="-I/opt/foo/include" LDFLAGS="-L/opt/foo/lib"
less config.log

autoreconf --force --install
rm -rf build-check
mkdir build-check
cd build-check
../configure --prefix="$PWD/install" CFLAGS="-Wall -Wextra -O2"
make
make check
make install

make distcheck

# User building a release
./configure --prefix="$HOME/.local"
make
make check
make install

# Maintainer after editing configure.ac or M4 macros
autoreconf --force --install

# Clean separate build directory
mkdir build && cd build
../configure CC=clang CFLAGS="-Wall -Wextra -g"
make

# Regenerate configured output files
./config.status
./config.status --recheck

# Cross compile example
./configure --host=aarch64-linux-gnu CC=aarch64-linux-gnu-gcc

# Diagnose a failure
less config.log