1. SCons
  2. Core
  3. SCons

Wiki

Clone wiki

SCons / AutoconfRecipes

Autoconf recipes

Autoconf/automake macros provide a layer of portability that is currently not fully supported by scons. Here is a few autoconf-like functions that I use. I hope that others can fill more stuff in.

Examples

MKDIR_TAKES_ONE_ARG

def checkMkdirOneArg(conf):
  check_mkdir_one_arg_source = """
#include <sys/stat.h>
int main()
{
  mkdir("somedir");
}
"""
  conf.Message('Checking for the number of args for mkdir... ')
  ret = conf.TryLink(check_mkdir_one_arg_source, '.c') or \
    conf.TryLink('#include <unistd.h>' + check_mkdir_one_arg_source, '.c')
  if ret:
    conf.Result('one')
  else:
    conf.Result('two')
  return ret

SELECT_TYPE_ARG1 SELECT_TYPE_ARG234 SELECT_TYPE_ARG5

def checkSelectArgType(conf):
  ''' Adapted from autoconf '''
  conf.Message('Checking for arg types for select... ')
  for arg234 in ['fd_set *', 'int *', 'void *']:
    for arg1 in ['int', 'size_t', 'unsigned long', 'unsigned']:
      for arg5 in ['struct timeval *', 'const struct timeval *']:
        check_select_source = '''
#if HAVE_SYS_SELECT_H
# include <sys/select.h>
#endif
#if HAVE_SYS_SOCKET_H
# include <sys/socket.h>
#endif
extern int select (%s, %s, %s, %s, %s);
int main()
{
  return(0);
}
''' % (arg1, arg234, arg234, arg234, arg5)
        ret = conf.TryLink(check_select_source, '.c')
        if ret:
          conf.Result(ret)
          return (arg1, arg234, arg5)
  conf.Result('no (use default)')
  return ('int', 'int *', 'struct timeval *')

Check for boost libraries

def checkBoostLibraries(conf, lib, pathes):
  ''' look for boost libraries '''
  conf.Message('Checking for boost library %s... ' % lib)
  for path in pathes:
    # direct form: e.g. libboost_iostreams.a
    if os.path.isfile(os.path.join(path, 'lib%s.a' % lib)):
      conf.Result('yes')
      return (path, lib)
    # check things like libboost_iostreams-gcc.a
    files = glob.glob(os.path.join(path, 'lib%s-*.a' % lib))
    # if there are more than one, choose the first one
    # FIXME: choose the best one.
    if len(files) >= 1:
      # get xxx-gcc from /usr/local/lib/libboost_xxx-gcc.a
      conf.Result('yes')
      return (path, os.path.basename(files[0])[3:-2])
  conf.Result('n')
  return ('','')

To use them, do something like:

conf = Configure(env,
  custom_tests = {
    'CheckIstreambufIterator' : utils.checkIstreambufIterator,
    'CheckMkdirOneArg' : utils.checkMkdirOneArg,
    'CheckStdCount' : utils.checkStdCount,
    'CheckSelectArgType' : utils.checkSelectArgType,
    'CheckBoostLibraries' : utils.checkBoostLibraries,
    'CheckMsgFmt' : utils.checkMsgFmt,
  }
)

and then maybe

  # MKDIR_TAKES_ONE_ARG
  if conf.CheckMkdirOneArg():
    utils.addToConfig('#define MKDIR_TAKES_ONE_ARG 1')
  else:
    utils.addToConfig('/* #undef MKDIR_TAKES_ONE_ARG */')

Note that addToConfig is not part of scons.

Standard autoconf macros

Please, if you have implemented one of the following, add your recipe here so that others can use it. (list copied from http://scons.org/wiki/GregNoel/StandardMacros#preview )

AC_INIT

Not needed

AC_CONFIG_SRCDIR


AM_INIT_AUTOMAKE

Not needed

AM_ENABLE_MULTILIB


AC_PREREQ


AC_COPYRIGHT


AC_REVISION

Not needed

AC_PREFIX_DEFAULT


AC_PREFIX_PROGRAM


AC_CONFIG_AUX_DIR


AC_CONFIG_COMMANDS


AC_CONFIG_COMMANDS_PRE


AC_CONFIG_COMMANDS_POST


AC_CONFIG_FILES


AC_CONFIG_HEADERS


AC_CONFIG_LINKS


AC_CONFIG_SUBDIRS


AC_OUTPUT


AC_DEFINE


AC_DEFINE_UNQUOTED


AC_SUBST

See SubstInFileBuilder, or try this code which uses @KEY_WORD@, just like Autoconf:

###############################################################################
#
# ACGenerateFile.py
#
# Taken from the SubstInFileBuilder on the SCons Wiki.  Slightly modified to
# use @ around keys so it behaves like GNU autotools.
#
###############################################################################


import re
from SCons.Script import *

def TOOL_SUBST(env):
    """Adds ACGenerateFile builder, which substitutes the keys->values of
    SUBST_DICT from the source to the target.

    The values of SUBST_DICT first have any construction variables expanded
    (its keys are not expanded).

    If a value of SUBST_DICT is a python callable function, it is called and
    the result is expanded as the value.

    If there's more than one source and more than one target, each target gets
    substituted from the corresponding source.
    """
    env.Append(TOOLS = 'SUBST')

    def do_subst_in_file(targetfile, sourcefile, dict):
        """Replace all instances of the keys of dict with their values.
        For example, if dict is {'VERSION': '1.2345', 'BASE': 'MyProg'},
        then all instances of @VERSION@ in the file will be replaced with
        1.2345 etc.
        """
        try:
            f = open(sourcefile, 'rb')
            contents = f.read()
            f.close()
        except:
            raise SCons.Errors.UserError, "Can't read source file %s"%sourcefile
        for (k,v) in dict.items():
            contents = re.sub("@" + k + "@", v, contents)
        try:
            f = open(targetfile, 'wb')
            f.write(contents)
            f.close()
        except:
            raise SCons.Errors.UserError, "Can't write target file %s"%targetfile
        return 0 # success

    def subst_in_file(target, source, env):
        if 'SUBST_DICT' not in env:
            raise SCons.Errors.UserError, "SubstInFile requires SUBST_DICT to be set."
        d = dict(env['SUBST_DICT']) # copy it
        for (k,v) in d.items():
            if callable(v):
                d[k] = env.subst(v())
            elif SCons.Util.is_String(v):
                d[k]=env.subst(v)
            else:
                raise SCons.Errors.UserError, "SubstInFile: key %s: %s must be a string or callable"%(k, repr(v))
        for (t,s) in zip(target, source):
            return do_subst_in_file(str(t), str(s), d)

    def subst_in_file_string(target, source, env):
        """This is what gets printed on the console."""
        return '\n'.join(['Substituting vars from %s into %s'%(s, t)
                          for t,s in zip(target, source)])

    def subst_emitter(target, source, env):
        """Add dependency from substituted SUBST_DICT to target.
        Returns original target, source tuple unchanged.
        """
        d = env['SUBST_DICT'].copy() # copy it
        for (k,v) in d.items():
            if callable(v):
                d[k] = env.subst(v())
            elif SCons.Util.is_String(v):
                d[k]=env.subst(v)
        Depends(target, SCons.Node.Python.Value(d))
        return target, source

    subst_action=SCons.Action.Action(subst_in_file, subst_in_file_string)
    env['BUILDERS']['SubstInFile'] = Builder(action=subst_action, emitter=subst_emitter)

To use do:

# Add the tool for use in the environment
from ACGenerateFile import *

# Setup some variables

PACKAGE_NAME = "nsound"

VERSION_A = "0"
VERSION_B = "5"
VERSION_C = "0"

PACKAGE_VERSION = VERSION_A + "." + VERSION_B + "." + VERSION_C

PACKAGE_RELEASE = PACKAGE_NAME + "-" + PACKAGE_VERSION

# create a new empty dictionary
dict = {}

# set the keys in the dictionary 
dict["PACKAGE_RELEASE"] = PACKAGE_RELEASE

endian = conf.checkEndian() # look at AC_C_BIGENDIAN on this wiki

if endian == "little":
        dict["PLATFORM_ENDIAN"] = "PLATFORM_LITTLE_ENDIAN"
elif endian == "big":
        dict["PLATFORM_ENDIAN"] = "PLATFORM_BIG_ENDIAN"

# Add the tool to the build environment
env = Environment(ENV = os.environ,
                  CXXFLAGS = env_CXXFLAGS + " " + custom_cxxflags,
                  CCFLAGS = env_CCFLAGS + " " + custom_ccflags,
                  LINKFLAGS = env_LDFLAGS + " ",
                  tools = ['default', TOOL_SUBST, "DistTar", "DistZip"],
                  toolpath = ".")

env.SubstInFile('src/Nsound/Nsound.h', 'src/Nsound/Nsound.h.in', SUBST_DICT=dict)
env.SubstInFile('src/Doxyfile', 'src/Doxyfile.in', SUBST_DICT=dict)

AC_SUBST_FILE


AC_ARG_VAR


AH_VERBATIM


AH_TEMPLATE


AH_TOP


AH_BOTTOM


AC_CHECK_PROG

# note that the full command path or none is returned, which can serve as True or False.
def CheckCommand(context, cmd):
       context.Message('Checking for %s command... ' % cmd)
       result = WhereIs(cmd)
       context.Result(result is not None)
       return result

AC_CHECK_PROGS

Not needed

AC_CHECK_TOOL


AC_CHECK_TOOLS


AC_PATH_PROG


AC_PATH_PROGS


AC_PATH_TOOL


AC_PROG_AWK


AC_PROG_EGREP


AC_PROG_FGREP


AC_PROG_INSTALL


AC_PROG_LEX


AC_PROG_YACC


AC_PROG_RANLIB


AC_PROG_LN_S


AM_GNU_GETTEXT


AM_PATH_PYTHON


AM_PATH_LISPDIR


AM_PROG_LISP


AM_PROG_AS


AM_PROG_LEX


AM_PROG_GCJ


AC_CHECK_FILE


AC_CHECK_FILES


AC_CHECK_LIB


AC_SEARCH_LIBS


AM_WITH_MALLOC


AM_WITH_REGEX


AC_CHECK_FUNCS

implemented as CheckFunc

AC_LIBOBJ


AC_LIBSOURCE


AC_LIBSOURCES


AC_CONFIG_LIBOBJ_DIR


AC_REPLACE_FUNCS


AC_REPLACE_FNMATCH


AC_FUNC_ALLOCA


AC_FUNC_CHOWN


AC_FUNC_CLOSEDIR_VOID


AC_FUNC_ERROR_AT_LINE


AC_FUNC_FNMATCH


AC_FUNC_FNMATCH_GNU


AC_FUNC_FORK


AC_FUNC_FSEEKO


AC_FUNC_GETGROUPS


AC_FUNC_GETLOADAVG


AC_FUNC_GETMNTENT


AC_FUNC_GETPGRP


AC_FUNC_LSTAT_FOLLOWS_SLASHED_SYMLINK


AC_FUNC_MALLOC


AC_FUNC_MEMCMP


AC_FUNC_MBRTOWC


AC_FUNC_MKTIME


AC_FUNC_MMAP


AC_FUNC_OBSTACK


AC_FUNC_REALLOC


AC_FUNC_SELECT_ARGTYPES


AC_FUNC_SETPGRP


AC_FUNC_SETVBUF_REVERSED


AC_FUNC_STAT


AC_FUNC_LSTAT


AC_FUNC_STRCOLL


AC_FUNC_STRERROR_R


AC_FUNC_STRFTIME


AC_FUNC_STRNLEN


AC_FUNC_STRTOD


AC_FUNC_UTIME_NULL


AC_FUNC_VPRINTF


AC_CHECK_FUNC


AC_CHECK_HEADERS


AC_HEADER_DIRENT


AC_HEADER_MAJOR


AC_HEADER_STAT


AC_HEADER_STDBOOL


AC_HEADER_STDC

##############################################################################
#
# By Samarjit Adhikari (adhikari_20022002_at_yahoo_com)
# Usage:
#    conf = Configure(env,custom_tests=\
#                 {'CheckStdCHeader': CheckStdCHeader
#                 },log_file="config.log",config_h="config.h")
#
#    if (not conf.CheckStdCHeader()):
#        ...
#    else:
#        ...
#
##############################################################################
def build_it(target = None, source = None, env = None):
    """
    This function is used to do Preprocessor operation
    on the source and verify the ANSI compliance of the system
    header files.
    """
    strsource = ""
    strtarget = ""
    for src in source:
        strsource += str(src)

    #Assuming only one target FIXME
    strtarget += str(target[0])

    cmd = str(env['CC']) + ' -E -o'+strtarget+' '+strsource

    p = os.popen (cmd)
    return p.close ()

def CheckStdCHeader(context):
    """
    This function is like a autoconf macro 'AC_PROG_CC_STDC'.
    """
    context.Message('Checking ANSI C compliant headers...')

    action_obj = Action (build_it)
    ret        = context.TryCompile(
    """
    #include <stdlib.h>
    #include <stdarg.h>
    #include <string.h>
    #include <float.h>

    int
    main ()
    {
      ;
      return 0;
    }
    """,\
    '.c')

    if ret: # Successful compilation
       retList = []
       ######### Try more specific . Test1 #########
       ret = context.TryAction (action_obj,\
       """
       #include <stdlib.h>
       """,'.c')
       #import pdb;pdb.set_trace()
       if ret[0]==1:
           if(re.search('free',ret[1])):
               retList.append(1)
           else:
               retList.append(0)
       ############### Test2 #####################
       ret = context.TryAction (action_obj,\
       """
       #include <string.h>
       """,'.c')
       if ret[0]==1:
           if(re.search('memchr',ret[1])):
               retList.append(1)
           else:
               retList.append(0)
       ################ Test3 #####################
       ret = context.TryLink(
       """
       #include <ctype.h>
       #if ((' ' & 0x0FF) == 0x020)
       # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
       # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
       #else
       # define ISLOWER(c) \
                  (('a' <= (c) && (c) <= 'i') \
                    || ('j' <= (c) && (c) <= 'r') \
                    || ('s' <= (c) && (c) <= 'z'))
       # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
       #endif

       #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
       int
       main ()
       {
         int i;
         for (i = 0; i < 256; i++)
           if (XOR (islower (i), ISLOWER (i))
           || toupper (i) != TOUPPER (i))
             exit(2);
         exit (0);
       }
       """,'.c')
       if ret==1:
           retList.append(1)
       else:
           retList.append(0)
       #Do the final testing.
       if 0 not in retList:
           ret = 1;
       else:
           ret = 0;

    context.Result(ret)
    return ret

AC_HEADER_SYS_WAIT


AC_HEADER_TIME


AC_HEADER_TIOCGWINSZ


AC_CHECK_DECL


AC_CHECK_DECLS


AC_CHECK_MEMBER


AC_CHECK_MEMBERS


AC_STRUCT_ST_BLKSIZE


AC_STRUCT_ST_BLOCKS


AC_STRUCT_ST_RDEV


AC_STRUCT_TM


AC_STRUCT_TIMEZONE


AC_CHECK_TYPES


AC_TYPE_GETGROUPS


AC_TYPE_MBSTATE_T


AC_TYPE_MODE_T


AC_TYPE_OFF_T


AC_TYPE_PID_T


AC_TYPE_SIGNAL


AC_TYPE_SIZE_T


AC_TYPE_UID_T


AC_PROG_CPP


AC_PROG_CXXCPP


AC_PROG_CC


AC_PROG_CC_C_O


AM_PROG_CC_C_O


AC_C_BACKSLASH_A


AC_C_BIGENDIAN

#############################
def Check_C_BIGENDIAN(context):
    context.Message("checking for Big Endianness ... ")
    src="""
#if defined(__MACH__)
#include <machine/endian.h>
#elif defined(OS_SOLARIS)
#include <sys/isa_defs.h>
#ifdef _LITTLE_ENDIAN
#define LITTLE_ENDIAN
#else
#define BIG_ENDIAN
#endif
#elif defined(OS_FREEBSD) || defined(OS_OPENBSD) || defined(OS_NETBSD) || defined(OS_DRAGONFLYBSD)
#include <sys/types.h>
#include <sys/endian.h>
#else
#include <endian.h>
#endif
#ifdef LITTLE_ENDIAN
#define IS_LITTLE_ENDIAN 1
#else
#define IS_LITTLE_ENDIAN (__BYTE_ORDER == __LITTLE_ENDIAN)
#endif
#ifdef IS_LITTLE_ENDIAN
    mychoke choke = IS_LITTLE_ENDIAN;
#endif
    int main() { return 0;}
"""
    ret=context.TryCompile(src,".cpp")
    context.Result(ret)
    if ret:
        context.Define("WORDS_BIGENDIAN") 
    return ret
###############################

AC_C_CONST


AC_C_VOLATILE


AC_C_INLINE


AC_C_CHAR_UNSIGNED


AC_C_LONG_DOUBLE


AC_C_STRINGIZE


AC_C_PROTOTYPES


AM_C_PROTOTYPES


AC_PROG_GCC_TRADITIONAL


AC_PROG_CXX


AC_PROG_F77


AC_PROG_F77_C_O


AC_F77_LIBRARY_LDFLAGS


AC_F77_DUMMY_MAIN


AC_F77_MAIN


AC_F77_WRAPPERS


AC_F77_FUNC


AC_LANG


AC_LANG_PUSH


AC_LANG_POP


AC_LANG_CONFTEST


AC_LANG_SOURCE


AC_LANG_PROGRAM


AC_LANG_CALL


AC_LANG_FUNC_LINK_TRY


AC_PREPROC_IFELSE


AC_EGREP_HEADERS


AC_EGREP_CPP

env=Environment()
conf=env.Configure()
import os,os.path,platform
# Only tested on OS X
if platform.system()=="Windows" and not env["CC"].count("gcc"):
   conf.env["CPPFLAG"]="/EP"
elif platform.system().count("VMS"):
   conf.env[optmarker]="/PREPROCESS_ONLY"
else:
   conf.env["CPPFLAG"]="-E -P"
match="main"
def cpp_egrep_gen(target, source, env, for_signature):
    return "%s %s %s | egrep %s"%(env["CC"],env["CPPFLAG"],source[0],match)
cpp_egrep = Builder(generator= cpp_egrep_gen, suffix = '.i', src_suffix = '.c')
conf.env["BUILDERS"].update({'CPP_EGREP' : cpp_egrep})
def Check_cpp_egrep(context,source_string):
    # assumes source and match are type str
    context.Message("Checking cpp | egrep %s :"%match)
    res=context.TryBuild(conf.env.CPP_EGREP,source_string,".c")
    context.Result(res)
conf.AddTests( {'Check_cpp_egrep': Check_cpp_egrep })
test_str="""
#include <iostream>
using namespace std;
int main(){
    cout<<"this is a test\n";
    return 0;
}"""
conf.Check_cpp_egrep(test_str)
env=conf.Finish()

AC_CHECK_SIZEOF

For example, the following function can be used:
def checkSizeOf(context, type):
    context.Message( 'getting size of ' + type + '... ' )
    #
    # We have to be careful with the program we wish to test here since
    # compilation will be attempted using the current environment's flags.
    # So make sure that the program will compile without any warning. For
    # example using: 'int main(int argc, char** argv)' will fail with the
    # '-Wall -Werror' flags since the variables argc and argv would not be
    # used in the program...
    #
    program = """
#include <stdlib.h>
#include <stdio.h>
int main() {
    printf("%d", (int)sizeof(""" + type + """));
    return 0;
}
"""
    ret = context.TryCompile(program, '.c')
    if ret == 0:
        print "test failed!\n"
        print "Error: cannot run the following test program:"
        print program
        print "Please check your compiler flags."
        Exit(1)
    ret = context.TryRun(program, '.c')
    context.Result(ret[0])
    return ret[1]
#
# This function should then be added to the configure context's
# custom tests
#
conf = Configure(env, custom_tests = {'checkSizeOf' : checkSizeOf})
#
# For example, print the result of sizeof(unsigned long int).
# Of course, in a real SCons file, this result would probably
# be stored in a environment variable or written to a config.h
# file
#
print "sizeof(unsigned long int) is: " + conf.checkSizeOf('unsigned long int')
This is another version, which uses a scheme similar to autoconf for testing the size (without requiring any run, thus being quite faster than methods using TryRun), and is a bit more flexible than the above (same API than the CheckType from SCons, with one more argument for expected size).

# Sensible default for common types on common platforms.
_DEFAULTS = {
    'short' : [2],
    'int' : [4, 2],
    'long' : [4, 8],
    'long long' : [8, 4],
    # Normally, there is no need to check unsigned types, because they are
    # guaranteed to be of the same size than their signed counterpart.
    'unsigned short' : [2],
    'unsigned int' : [4, 2],
    'unsigned long' : [4, 8],
    'unsigned long long' : [8, 4],
    'float' : [4],
    'double' : [8],
    'long double' : [12],
    'size_t' : [4],
}

def CheckTypeSize(context, type, includes = None, language = 'C', size = None):
    """This check can be used to get the size of a given type, or to check whether
    the type is of expected size.

    Arguments:
        - type : str
            the type to check
        - includes : sequence
            list of headers to include in the test code before testing the type
        - language : str
            'C' or 'C++'
        - size : int
            if given, will test wether the type has the given number of bytes.
            If not given, will test against a list of sizes (all sizes between
            0 and 16 bytes are tested).

        Returns:
                status : int
                        0 if the check failed, or the found size of the type if the check succeeded."""
    minsz = 0
    maxsz = 16

    if includes:
        src = "\n".join("#include <%s>\n" % i for i in includes)
    else:
        src = ""

    if language == 'C':
        ext = '.c'
    elif language == 'C++':
        ext = '.cpp'
    else:
        raise NotImplementedError("%s is not a recognized language" % language)

    # test code taken from autoconf: this is a pretty clever hack to find that
    # a type is of a given size using only compilation. This speeds things up
    # quite a bit compared to straightforward code using TryRun
    src += r"""
typedef %s scons_check_type;

int main()
{
    static int test_array[1 - 2 * ((long int) sizeof(scons_check_type) > %d)];
    test_array[0] = 0;

    return 0;
}
"""

    if size:
        # Only check if the given size is the right one
        context.Message('Checking %s is %d bytes... ' % (type, size))
        st = context.TryCompile(src % (type, size), ext)
        context.Result(st)

        if st:
            return size
        else:
            return 0
    else:
        # Only check if the given size is the right one
        context.Message('Checking size of %s ... ' % type)

        # Try sensible defaults first
        try:
            szrange = _DEFAULTS[type]
        except KeyError:
            szrange = []
        szrange.extend(xrange(minsz, maxsz))
        st = 0

        # Actual test
        for sz in szrange:
            st = context.TryCompile(src % (type, sz), ext)
            if st:
                break

        if st:
            context.Result('%d' % sz)
            return sz
        else:
            context.Result('Failed !')
            return 0

For example, to check wether long is 4 bytes on your platform, you can do:
config.CheckTypeSize('long', size = 4).

AC_PATH_X


AC_PATH_XTRA


AC_SYS_INTERPRETER


AC_SYS_LARGEFILE

################################
def Check_SYS_LARGEFILE(context):
    LARGEFILE=context.sconf.get_disable("LARGEFILE")
    # Taken from Fossies - Tries to enable 64-bit off_t 
    fseeko=context.sconf.CheckFunc('fseeko')
    if fseeko:
        context.env.Append(CPPDEFINES = ['HAVE_FSEEKO'],WXCONFIG_CPPDEFINES = ['HAVE_FSEEKO'])
        src="""
#include <stdio.h>
#include <sys/types.h>
"""
        offt=context.sconf.CheckTypeSize('off_t',src)
        if offt<8 and offt>0:
            flags=context.env.Dictionary()['CPPFLAGS']
            context.env.Append(CPPDEFINES=['_FILE_OFFSET_BITS=64'],WXCONFIG_CPPDEFINES=['_FILE_OFFSET_BITS=64'])
            offt=context.CheckTypeSize('off_t',src)
            if offt < 8:
                context.env.Replace(CPPFLAGS=flags)
        elif offt == 0:
            #set default value to 4
            offt=4
        sys.stdout.write( "sizeof(off_t)=%i\n"%offt)
        context.env.Append(CPPDEFINES = ['_FILE_OFFSET_BITS='+str(offt*8)],WXCONFIG_CPPDEFINES = ['_FILE_OFFSET_BITS='+str(offt*8)])
        context.Message("Checking for System LargeFile support")
        if fseeko and int(offt)>=8:
            context.env.Append(CPPDEFINES = ['_LARGE_FILES'],WXCONFIG_CPPDEFINES = ['_LARGE_FILES'])
            rc=True
        else:
            rc=False
        context.Result(rc)
        if rc:
            context.sconf.Define("HAVE_LARGEFILE_SUPPORT",1)
        #ignoring old gcc and hpux need for STDC_EXT - upgrade gcc
        return rc
    else:
        return fseek0
##############################

AC_SYS_LONG_FILE_NAMES


AC_SYS_POSIX_TERMIOS


AC_AIX


AC_GNU_SOURCE


AC_ISC_POSIX


AC_MINIX


AC_CANONICAL_BUILD


AC_CANONICAL_HOST


AC_CANONICAL_TARGET


AC_ARG_PROGRAM


AC_ARG_WITH/AC_WITH


AC_ARG_ENABLE/AC_ENABLE


AC_HELP_STRING


AC_CONFIG_TESTDIR


AT_INIT


AT_TESTED


AT_SETUP


AT_KEYWORDS


AT_CLEANUP


AT_DATA


AT_CHECK


AC_MSG_NOTICE


AC_MSG_ERROR


AC_MSG_FAILURE


AC_MSG_WARN


AC_DIAGNOSE


AC_WARNING


AC_FATAL


AC_CACHE_VAL


AC_CACHE_CHECK


AC_CACHE_LOAD


AC_CACHE_SAVE


AC_REQUIRE


AC_REQUIRE_CPP


AC_BEFORE


AM_CONDITIONAL


Updated