OpenAL-1.4.0.2/0000755000000000000000000000000012114505146007657 5ustar OpenAL-1.4.0.2/LICENSE0000644000000000000000000000272211733255111010667 0ustar Copyright (c) 2003-2009, Sven Panne All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of the author nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OpenAL-1.4.0.2/README0000644000000000000000000000044311733255111010540 0ustar To build this package using Cabal directly from darcs, you must run "autoreconf" before the usual Cabal build steps (configure/build/install). autoreconf is included in the GNU autoconf tools. There is no need to run the "configure" script: the "setup configure" step will do this for you. OpenAL-1.4.0.2/aclocal.m40000644000000000000000000002227611733255111011530 0ustar # FPTOOLS_CHECK_HTYPE(TYPE [, DEFAULT_VALUE, [, VALUE-FOR-CROSS-COMPILATION]) # # This test should *really* be rewritten!!! AC_DEFUN([FPTOOLS_CHECK_HTYPE], [changequote(<<, >>)dnl dnl The name to #define. define(<>, translit(htype_$1, [a-z *], [A-Z_P]))dnl dnl The cache variable name. define(<>, translit(fptools_cv_htype_$1, [ *], [_p]))dnl define(<>, translit(fptools_cv_htype_sup_$1, [ *], [_p]))dnl changequote([, ])dnl AC_MSG_CHECKING(Haskell type for $1) AC_CACHE_VAL(AC_CV_NAME, [AC_CV_NAME_supported=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" AC_RUN_IFELSE([AC_LANG_SOURCE([[#include #include #if HAVE_SYS_TYPES_H # include #endif #if HAVE_UNISTD_H # include #endif #if HAVE_SYS_STAT_H # include #endif #if HAVE_FCNTL_H # include #endif #if HAVE_SIGNAL_H # include #endif #if HAVE_TIME_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_STRING_H # include #endif #if HAVE_CTYPE_H # include #endif #if defined(HAVE_GL_GL_H) # include #elif defined(HAVE_OPENGL_GL_H) # include #endif #if defined(HAVE_AL_AL_H) # include #elif defined(HAVE_OPENAL_AL_H) # include #endif #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) # include #endif #if HAVE_SYS_RESOURCE_H # include #endif typedef $1 testing; main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { fprintf(f, "%s%d\n", ((testing)(-1) < (testing)0) ? "Int" : "Word", sizeof(testing)*8); } else { fprintf(f,"%s\n", (sizeof(testing) > sizeof(double)) ? "LDouble" : (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); } fclose(f); exit(0); }]])],[AC_CV_NAME=`cat conftestval`], [ifelse([$2], , [AC_CV_NAME=NotReallyAType; AC_CV_NAME_supported=no], [AC_CV_NAME=$2])], [ifelse([$3], , [AC_CV_NAME=NotReallyATypeCross; AC_CV_NAME_supported=no], [AC_CV_NAME=$3])]) CPPFLAGS="$fp_check_htype_save_cppflags"]) dnl if test "$AC_CV_NAME_supported" = yes; then AC_MSG_RESULT($AC_CV_NAME) AC_DEFINE_UNQUOTED(AC_TYPE_NAME, $AC_CV_NAME, [Define to Haskell type for $1]) else AC_MSG_RESULT([not supported]) fi undefine([AC_TYPE_NAME])dnl undefine([AC_CV_NAME])dnl undefine([AC_CV_NAME_supported])dnl ]) # FP_COMPUTE_INT(EXPRESSION, VARIABLE, INCLUDES, IF-FAILS) # --------------------------------------------------------- # Assign VARIABLE the value of the compile-time EXPRESSION using INCLUDES for # compilation. Execute IF-FAILS when unable to determine the value. Works for # cross-compilation, too. # # Implementation note: We are lazy and use an internal autoconf macro, but it # is supported in autoconf versions 2.50 up to the actual 2.57, so there is # little risk. AC_DEFUN([FP_COMPUTE_INT], [_AC_COMPUTE_INT([$1], [$2], [$3], [$4])[]dnl ])# FP_COMPUTE_INT # FP_CHECK_CONST(EXPRESSION, [INCLUDES = DEFAULT-INCLUDES], [VALUE-IF-FAIL = -1]) # ------------------------------------------------------------------------------- # Defines CONST_EXPRESSION to the value of the compile-time EXPRESSION, using # INCLUDES. If the value cannot be determined, use VALUE-IF-FAIL. AC_DEFUN([FP_CHECK_CONST], [AS_VAR_PUSHDEF([fp_Cache], [fp_cv_const_$1])[]dnl AC_CACHE_CHECK([value of $1], fp_Cache, [FP_COMPUTE_INT([$1], fp_check_const_result, [AC_INCLUDES_DEFAULT([$2])], [fp_check_const_result=m4_default([$3], ['-1'])]) AS_VAR_SET(fp_Cache, [$fp_check_const_result])])[]dnl AC_DEFINE_UNQUOTED(AS_TR_CPP([CONST_$1]), AS_VAR_GET(fp_Cache), [The value of $1.])[]dnl AS_VAR_POPDEF([fp_Cache])[]dnl ])# FP_CHECK_CONST # FP_CHECK_CONSTS_TEMPLATE(EXPRESSION...) # --------------------------------------- # autoheader helper for FP_CHECK_CONSTS m4_define([FP_CHECK_CONSTS_TEMPLATE], [AC_FOREACH([fp_Const], [$1], [AH_TEMPLATE(AS_TR_CPP(CONST_[]fp_Const), [The value of ]fp_Const[.])])[]dnl ])# FP_CHECK_CONSTS_TEMPLATE # FP_CHECK_CONSTS(EXPRESSION..., [INCLUDES = DEFAULT-INCLUDES], [VALUE-IF-FAIL = -1]) # ----------------------------------------------------------------------------------- # List version of FP_CHECK_CONST AC_DEFUN([FP_CHECK_CONSTS], [FP_CHECK_CONSTS_TEMPLATE([$1])dnl for fp_const_name in $1 do FP_CHECK_CONST([$fp_const_name], [$2], [$3]) done ])# FP_CHECK_CONSTS # FP_ARG_OPENAL # ------------- AC_DEFUN([FP_ARG_OPENAL], [AC_ARG_ENABLE([openal], [AC_HELP_STRING([--enable-openal], [build a Haskell binding for OpenAL (default=autodetect)])], [enable_openal=$enableval], [enable_openal=yes]) ])# FP_ARG_OPENAL # FP_CHECK_OPENAL # ------------- AC_DEFUN([FP_CHECK_OPENAL], [AC_REQUIRE([AC_CANONICAL_TARGET]) AL_CFLAGS= case $target_os in darwin*) AL_LIBS= AL_FRAMEWORKS=OpenAL ;; *) AC_SEARCH_LIBS([alGenSources], [openal openal32], [AL_LIBS="$ac_cv_search_alGenSources"]) test x"$AL_LIBS" = x"none required" && AL_LIBS= AC_SUBST([AL_LIBS]) AL_FRAMEWORKS= ;; esac AC_SUBST([AL_CFLAGS]) AC_SUBST([AL_FRAMEWORKS]) ])# FP_CHECK_OPENAL # FP_HEADER_AL # ------------ # Check for an AL header, setting the variable fp_found_al_header to no/yes, # depending on the outcome. AC_DEFUN([FP_HEADER_AL], [if test -z "$fp_found_al_header"; then fp_found_al_header=no AC_CHECK_HEADERS([AL/al.h OpenAL/al.h], [fp_found_al_header=yes; break]) fi ]) # FP_HEADER_AL # FP_HEADER_ALC # ------------- # Check for an ALC header, setting the variable fp_found_alc_header to no/yes, # depending on the outcome. AC_DEFUN([FP_HEADER_ALC], [if test -z "$fp_found_alc_header"; then fp_found_alc_header=no AC_CHECK_HEADERS([AL/alc.h OpenAL/alc.h], [fp_found_alc_header=yes; break]) fi ]) # FP_HEADER_ALC # FP_FUNC_ALCCLOSEDEVICE_VOID # --------------------------- # Defines ALCCLOSEDEVICE_VOID to 1 if `alcCloseDevice' returns void. AC_DEFUN([FP_FUNC_ALCCLOSEDEVICE_VOID], [AC_REQUIRE([FP_HEADER_ALC]) AC_CACHE_CHECK([whether alcCloseDevice returns void], [fp_cv_func_alcclosedevice_void], [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT #if defined(HAVE_AL_ALC_H) #include #elif defined(HAVE_OPENAL_ALC_H) #include #endif ], [[int x = (int)alcCloseDevice(NULL);]])], [fp_cv_func_alcclosedevice_void=no], [fp_cv_func_alcclosedevice_void=yes])]) if test x"$fp_cv_func_alcclosedevice_void" = xyes; then AC_DEFINE([ALCCLOSEDEVICE_VOID], [1], [Define to 1 if `alcCloseDevice' returns void.]) fi ]) # FP_FUNC_ALCCLOSEDEVICE_VOID # FP_FUNC_ALCMAKECONTEXTCURRENT_VOID # ---------------------------------- # Defines ALCMAKECONTEXTCURRENT_VOID to 1 if `alcMakeContextCurrent' returns void. AC_DEFUN([FP_FUNC_ALCMAKECONTEXTCURRENT_VOID], [AC_REQUIRE([FP_HEADER_ALC]) AC_CACHE_CHECK([whether alcMakeContextCurrent returns void], [fp_cv_func_alcmakecontextcurrent_void], [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT #if defined(HAVE_AL_ALC_H) #include #elif defined(HAVE_OPENAL_ALC_H) #include #endif ], [[int x = (int)alcMakeContextCurrent(NULL);]])], [fp_cv_func_alcmakecontextcurrent_void=no], [fp_cv_func_alcmakecontextcurrent_void=yes])]) if test x"$fp_cv_func_alcmakecontextcurrent_void)" = xyes; then AC_DEFINE([ALCMAKECONTEXTCURRENT_VOID], [1], [Define to 1 if `alcMakeContextCurrent' returns void.]) fi ]) # FP_FUNC_ALCMAKECONTEXTCURRENT_VOID # FP_FUNC_ALCPROCESSCONTEXT_VOID # ------------------------------ # Defines ALCPROCESSCONTEXT_VOID to 1 if `alcProcessContext' returns void. AC_DEFUN([FP_FUNC_ALCPROCESSCONTEXT_VOID], [AC_REQUIRE([FP_HEADER_ALC]) AC_CACHE_CHECK([whether alcProcessContext returns void], [fp_cv_func_alcprocesscontext_void], [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT #if defined(HAVE_AL_ALC_H) #include #elif defined(HAVE_OPENAL_ALC_H) #include #endif ], [[int x = (int)alcProcessContext(NULL);]])], [fp_cv_func_alcprocesscontext_void=no], [fp_cv_func_alcprocesscontext_void=yes])]) if test x"$fp_cv_func_alcprocesscontext_void" = xyes; then AC_DEFINE([ALCPROCESSCONTEXT_VOID], [1], [Define to 1 if `alcProcessContext' returns void.]) fi ]) # FP_FUNC_ALCPROCESSCONTEXT_VOID # FP_FUNC_ALCDESTROYCONTEXT_VOID # ------------------------------ # Defines ALCDESTROYCONTEXT_VOID to 1 if `alcDestroyContext' returns void. AC_DEFUN([FP_FUNC_ALCDESTROYCONTEXT_VOID], [AC_REQUIRE([FP_HEADER_ALC]) AC_CACHE_CHECK([whether alcDestroyContext returns void], [fp_cv_func_alcdestroycontext_void], [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT #if defined(HAVE_AL_ALC_H) #include #elif defined(HAVE_OPENAL_ALC_H) #include #endif ], [[int x = (int)alcDestroyContext(NULL);]])], [fp_cv_func_alcdestroycontext_void=no], [fp_cv_func_alcdestroycontext_void=yes])]) if test x"$fp_cv_func_alcdestroycontext_void" = xyes; then AC_DEFINE([ALCDESTROYCONTEXT_VOID], [1], [Define to 1 if `alcDestroyContext' returns void.]) fi ]) # FP_FUNC_ALCDESTROYCONTEXT_VOID # FP_ARG_COMPILER # ------------- AC_DEFUN([FP_ARG_COMPILER], [AC_ARG_WITH([compiler], [AC_HELP_STRING([--with-compiler@<:@=HC@:>@], [use the given Haskell compiler (default=ghc)])], [with_compiler=$withval], [with_compiler=ghc]) ])# FP_ARG_COMPILER OpenAL-1.4.0.2/OpenAL.buildinfo.in0000644000000000000000000000040211733255111013273 0ustar -- @configure_input@ -- System-dependent values used by Distribution.Simple.defaultUserHooks -- buildable: @BUILD_PACKAGE_BOOL@ ghc-options: -DCALLCONV=@CALLCONV@ cc-options: -DCALLCONV=@CALLCONV@ extra-libraries: @AL_LIBS_PLAIN@ frameworks: @AL_FRAMEWORKS@ OpenAL-1.4.0.2/OpenAL.cabal0000644000000000000000000000345312114504672011771 0ustar name: OpenAL version: 1.4.0.2 license: BSD3 license-file: LICENSE maintainer: None homepage: http://connect.creativelabs.com/openal/ category: Sound synopsis: A binding to the OpenAL cross-platform 3D audio API description: A Haskell binding for the OpenAL cross-platform 3D audio API, appropriate for use with gaming applications and many other types of audio applications. For more information about OpenAL, please see: . build-type: Configure extra-source-files: OpenAL.buildinfo.in README aclocal.m4 config.guess config.sub configure configure.ac examples/test/TestDevice.hs include/HsOpenAL.h.in include/HsOpenALConfig.h.in install-sh extra-tmp-files: config.log config.status autom4te.cache OpenAL.buildinfo include/HsOpenALConfig.h include/HsOpenAL.h exposed-modules: Sound.OpenAL, Sound.OpenAL.AL, Sound.OpenAL.AL.ALboolean, Sound.OpenAL.AL.Attenuation, Sound.OpenAL.AL.BasicTypes, Sound.OpenAL.AL.Buffer, Sound.OpenAL.AL.BufferInternal, Sound.OpenAL.AL.Doppler, Sound.OpenAL.AL.Errors, Sound.OpenAL.AL.Extensions, Sound.OpenAL.AL.Format, Sound.OpenAL.AL.Listener, Sound.OpenAL.AL.Source, Sound.OpenAL.AL.StringQueries, Sound.OpenAL.ALC, Sound.OpenAL.ALC.BasicTypes, Sound.OpenAL.ALC.Capture, Sound.OpenAL.ALC.Context, Sound.OpenAL.ALC.Device, Sound.OpenAL.ALC.Errors, Sound.OpenAL.ALC.Extensions other-modules: Sound.OpenAL.AL.PeekPoke, Sound.OpenAL.AL.QueryUtils, Sound.OpenAL.AL.SourceState, Sound.OpenAL.AL.String, Sound.OpenAL.ALC.ALCboolean, Sound.OpenAL.ALC.QueryUtils, Sound.OpenAL.ALC.String, Sound.OpenAL.Config, Sound.OpenAL.Constants include-dirs: include includes: HsOpenAL.h install-includes: HsOpenAL.h ghc-options: -Wall build-depends: base >= 3 && < 5, StateVar, ObjectName, Tensor extensions: CPP, ForeignFunctionInterface OpenAL-1.4.0.2/examples/0000755000000000000000000000000011733255111011475 5ustar OpenAL-1.4.0.2/examples/test/0000755000000000000000000000000011733255111012454 5ustar OpenAL-1.4.0.2/examples/test/TestDevice.hs0000644000000000000000000000070012107326776015060 0ustar import Control.Monad ( unless ) import System.IO ( hPutStrLn, stderr ) import System.Posix.Unistd ( sleep ) import Sound.OpenAL main :: IO () main = do maybeDevice <- openDevice (Just "'( ( devices '( native null ) ) )") case maybeDevice of Nothing -> hPutStrLn stderr "openDevice failed" Just device -> do sleep 1 ok <- closeDevice device unless ok $ hPutStrLn stderr "closeDevice failed" OpenAL-1.4.0.2/Sound/0000755000000000000000000000000011733255111010747 5ustar OpenAL-1.4.0.2/Sound/OpenAL/0000755000000000000000000000000011733255111012065 5ustar OpenAL-1.4.0.2/Sound/OpenAL/AL.hs0000644000000000000000000001373312107326776012740 0ustar -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- This module corresponds to chapters 2 (OpenAL Operation), 3 (State and State -- Requests), 4 (Listener and Sources) and 5 (Buffers) of the OpenAL -- Specification and Reference (version 1.1). -- -------------------------------------------------------------------------------- module Sound.OpenAL.AL ( -- * OpenAL Fundamentals -- $OpenALFundamentals -- * Basic AL Operation -- $BasicALOperation -- * Time and Frequency -- $TimeAndFrequency -- * Space and Distance -- $SpaceAndDistance -- * Coordinate System -- $CoordinateSystem module Sound.OpenAL.AL.BasicTypes, module Sound.OpenAL.AL.Errors, module Sound.OpenAL.AL.StringQueries, module Sound.OpenAL.AL.Attenuation, module Sound.OpenAL.AL.Doppler, module Sound.OpenAL.AL.Listener, module Sound.OpenAL.AL.Source, module Sound.OpenAL.AL.Buffer, module Sound.OpenAL.AL.Extensions ) where import Sound.OpenAL.AL.BasicTypes import Sound.OpenAL.AL.Errors import Sound.OpenAL.AL.StringQueries import Sound.OpenAL.AL.Attenuation import Sound.OpenAL.AL.Doppler import Sound.OpenAL.AL.Listener import Sound.OpenAL.AL.Source import Sound.OpenAL.AL.Buffer import Sound.OpenAL.AL.Extensions -------------------------------------------------------------------------------- -- $OpenALFundamentals -- OpenAL is concerned with rendering audio into an output buffer and collecting -- audio data from an input buffer. OpenAL\'s primary use is assumed to be for -- spatialized audio. There is no support for MIDI. -- -- OpenAL has three fundamental primitives or objects: 'Buffer's, 'Source's, and -- a single listener (see "Sound.OpenAL.AL.Listener"). Each object can be -- changed independently; the setting of one object does not affect the setting -- of others. The application can also set modes that affect processing. Modes -- are set, objects specified, and other OpenAL operations performed by sending -- commands in the form of function or procedure calls. -- -- Sources store locations, directions, and other attributes of an object in 3D -- space and have a buffer associated with them for playback. When the program -- wants to play a sound, it controls execution through a source object. Sources -- are processed independently from each other. -- -- Buffers store compressed or uncompressed audio data. It is common to -- initialize a large set of buffers when the program first starts (or at -- non-critical times during execution, between levels in a game, for -- instance). Buffers are referred to by sources. Data (audio sample data) is -- associated with buffers. -- -- There is only one listener (per audio context). The listener attributes are -- similar to source attributes, but are used to represent where the user is -- hearing the audio from. The influence of all the sources from the perspective -- of the listener is mixed and played for the user. -------------------------------------------------------------------------------- -- $BasicALOperation -- OpenAL can be used for a variety of audio playback tasks, and is an excellent -- complement to OpenGL for real-time rendering, see -- "Graphics.Rendering.OpenGL". A programmer who is familiar with OpenGL will -- immediately notice the similarities between the two APIs in that they -- describe their 3D environments using similar methods. -- -- For an OpenGL\/OpenAL program, most of the audio programming will be in two -- places in the code: initialization of the program, and the rendering loop. An -- OpenGL\/OpenAL program will typically contain a section where the graphics -- and audio systems are initialized, although it may be spread into multiple -- functions. For OpenAL, initialization normally consists of creating a -- context, creating the initial set of buffers, loading the buffers with sample -- data, creating sources, attaching buffers to sources, setting locations and -- directions for the listener and sources, and setting the initial values for -- state global to OpenAL. -------------------------------------------------------------------------------- -- $TimeAndFrequency -- By default, OpenAL uses seconds and Hertz as units for time and frequency, -- respectively. A float or integral value of one for a variable that specifies -- quantities like duration, latency, delay, or any other parameter measured as -- time, specifies 1 second. For frequency, the basic unit is 1\/second, or -- Hertz. In other words, sample frequencies and frequency cut-offs or filter -- parameters specifying frequencies are expressed in units of Hertz. -------------------------------------------------------------------------------- -- $SpaceAndDistance -- OpenAL does not define the units of measurement for distances. The -- application is free to use meters, inches, or parsecs. OpenAL provides means -- for simulating the natural attenuation of sound according to distance, and to -- exaggerate or reduce this effect. However, the resulting effects do not -- depend on the distance unit used by the application to express source and -- listener coordinates. OpenAL calculations are scale invariant. The -- specification assumes Euclidean calculation of distances, and mandates that -- if two sources are sorted with respect to the Euclidean metric, the distance -- calculation used by the implementation has to preserve that order. -------------------------------------------------------------------------------- -- $CoordinateSystem -- OpenAL - like OpenGL - uses a right-handed Cartesian coordinate system (RHS), -- where in a frontal default view X (thumb) points right, Y (index finger) -- points up, and Z (middle finger) points towards the viewer\/camera. To switch -- from a left handed coordinate system (LHS) to a right handed coordinate -- systems, flip the sign on the Z coordinate. OpenAL-1.4.0.2/Sound/OpenAL/ALC.hs0000644000000000000000000000236712107326776013044 0ustar -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.ALC -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- This module corresponds to chapter 6 (AL Contexts and the ALC API) of the -- OpenAL Specification and Reference (version 1.1). -- -- ALC is a portable API for managing OpenAL contexts, including resource -- sharing, locking, and unlocking. Within the core AL API the existence of a -- context is implied, but the context is not exposed. The context encapsulates -- the state of a given instance of the AL state machine. -- -------------------------------------------------------------------------------- module Sound.OpenAL.ALC ( module Sound.OpenAL.ALC.BasicTypes, module Sound.OpenAL.ALC.Device, module Sound.OpenAL.ALC.Context, module Sound.OpenAL.ALC.Extensions, module Sound.OpenAL.ALC.Errors, module Sound.OpenAL.ALC.Capture ) where import Sound.OpenAL.ALC.BasicTypes import Sound.OpenAL.ALC.Device import Sound.OpenAL.ALC.Context import Sound.OpenAL.ALC.Extensions import Sound.OpenAL.ALC.Errors import Sound.OpenAL.ALC.Capture OpenAL-1.4.0.2/Sound/OpenAL/Config.hs0000644000000000000000000001435512107326776013652 0ustar -- #hide -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.Config -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- This purely internal module defines the platform-specific stuff which has -- been figured out by configure. -- -------------------------------------------------------------------------------- module Sound.OpenAL.Config ( -- AL types ALboolean, ALchar, ALbyte, ALubyte, ALshort, ALushort, ALint, ALuint, ALsizei, ALenum, ALfloat, ALdouble, -- ALC types ALCboolean, ALCchar, ALCbyte, ALCubyte, ALCshort, ALCushort, ALCint, ALCuint, ALCsizei, ALCenum, ALCfloat, ALCdouble, -- Device stuff ALCdevice(ALCdevice), Device, nullDevice, marshalDevice, unmarshalDevice, closeDevice, -- Context stuff ALCcontext(..), Context, nullContext, marshalContext, unmarshalContext, alcProcessContext, alcMakeContextCurrent, alcDestroyContext ) where import Data.Int import Data.Word import Foreign.Ptr ( Ptr, nullPtr ) -------------------------------------------------------------------------------- #include "HsOpenALConfig.h" -------------------------------------------------------------------------------- -- AL types -- | 8-bit boolean type ALboolean = HTYPE_ALBOOLEAN -- | Character type ALchar = HTYPE_ALCHAR -- | Signed 8-bit 2\'s complement integer type ALbyte = HTYPE_ALBYTE -- | Unsigned 8-bit integer type ALubyte = HTYPE_ALUBYTE -- | Signed 16-bit 2\'s complement integer type ALshort = HTYPE_ALSHORT -- | Unsigned 16-bit integer type ALushort = HTYPE_ALUSHORT -- | Signed 32-bit 2\'s complement integer type ALint = HTYPE_ALINT -- | Unsigned 32-bit integer type ALuint = HTYPE_ALUINT -- | Non-negatitve 32-bit binary integer size type ALsizei = HTYPE_ALSIZEI -- | Enumerated 32-bit value type ALenum = HTYPE_ALENUM -- | 32-bit IEEE754 floating-point type ALfloat = HTYPE_ALFLOAT -- | 64-bit IEEE754 floating-point type ALdouble = HTYPE_ALDOUBLE -------------------------------------------------------------------------------- -- ALC types -- | 8-bit boolean type ALCboolean = HTYPE_ALCBOOLEAN -- | Character type ALCchar = HTYPE_ALCCHAR -- | Signed 8-bit 2\'s complement integer type ALCbyte = HTYPE_ALCBYTE -- | Unsigned 8-bit integer type ALCubyte = HTYPE_ALCUBYTE -- | Signed 16-bit 2\'s complement integer type ALCshort = HTYPE_ALCSHORT -- | Unsigned 16-bit integer type ALCushort = HTYPE_ALCUSHORT -- | Signed 32-bit 2\'s complement integer type ALCint = HTYPE_ALCINT -- | Unsigned 32-bit integer type ALCuint = HTYPE_ALCUINT -- | Non-negatitve 32-bit binary integer size type ALCsizei = HTYPE_ALCSIZEI -- | Enumerated 32-bit value type ALCenum = HTYPE_ALCENUM -- | 32-bit IEEE754 floating-point type ALCfloat = HTYPE_ALCFLOAT -- | 64-bit IEEE754 floating-point type ALCdouble = HTYPE_ALCDOUBLE -------------------------------------------------------------------------------- -- In OpenAL 1.1, alcCloseDevice() returns an ALCboolean, before it was void. -- To break a dependency cycle, we have to define the Device type here, too. -- | The abstract device type. newtype Device = Device ALCdevice deriving ( Eq, Ord, Show ) newtype ALCdevice = ALCdevice (Ptr ALCdevice) deriving ( Eq, Ord, Show ) nullDevice :: Device nullDevice = Device (ALCdevice nullPtr) marshalDevice :: Device -> ALCdevice marshalDevice (Device device) = device unmarshalDevice :: ALCdevice -> Maybe Device unmarshalDevice device = if device == marshalDevice nullDevice then Nothing else Just (Device device) -- | 'closeDevice' allows the application (i.e. the client program) to -- disconnect from a device (i.e. the server). It returns 'True' for success and -- 'False' for failure. Once closed, the 'Device' is invalid. -- -- /Note:/ Older OpenAL implementations will always report a success! closeDevice :: Device -> IO Bool #if ALCCLOSEDEVICE_VOID closeDevice = fmap (const True) . alcCloseDevice . marshalDevice foreign import CALLCONV unsafe "alcCloseDevice" alcCloseDevice :: ALCdevice -> IO () #else -- inlined unmarshalALCboolean here to break dependency cycle closeDevice = fmap (/= CONST_ALC_FALSE) . alcCloseDevice . marshalDevice foreign import CALLCONV unsafe "alcCloseDevice" alcCloseDevice :: ALCdevice -> IO ALCboolean #endif -------------------------------------------------------------------------------- -- In OpenAL 1.1, alcProcessContext() returns void for all platforms, before it -- returned ALCcontext* on Linux. To break a dependency cycle, we have to define -- the Context type here, too. -- | The abstract context type. data Context = Context ALCcontext deriving ( Eq, Ord, Show ) newtype ALCcontext = ALCcontext (Ptr ALCcontext) deriving ( Eq, Ord, Show ) nullContext :: Context nullContext = Context (ALCcontext nullPtr) marshalContext :: Context -> ALCcontext marshalContext (Context context) = context unmarshalContext :: ALCcontext -> Maybe Context unmarshalContext context = if context == marshalContext nullContext then Nothing else Just (Context context) #if ALCPROCESSCONTEXT_VOID foreign import CALLCONV unsafe "alcProcessContext" alcProcessContext :: ALCcontext -> IO () #else foreign import CALLCONV unsafe "alcProcessContext" alcProcessContext :: ALCcontext -> IO ALCcontext #endif -------------------------------------------------------------------------------- -- In OpenAL 1.1, alcMakeContextCurrent() returns void, before it was ALCenum on -- Linux and ALCboolean on other platforms. Currently we default to ALCenum in -- the latter case. #if ALCMAKECONTEXTCURRENT_VOID foreign import CALLCONV unsafe "alcMakeContextCurrent" alcMakeContextCurrent :: ALCcontext -> IO () #else foreign import CALLCONV unsafe "alcMakeContextCurrent" alcMakeContextCurrent :: ALCcontext -> IO ALCenum #endif -------------------------------------------------------------------------------- -- In OpenAL 1.1, alcDestroyContext() returns void, before it returned ALCenum -- on Linux. #if ALCDESTROYCONTEXT_VOID foreign import CALLCONV unsafe "alcDestroyContext" alcDestroyContext :: ALCcontext -> IO () #else foreign import CALLCONV unsafe "alcDestroyContext" alcDestroyContext :: ALCcontext -> IO ALCenum #endif OpenAL-1.4.0.2/Sound/OpenAL/Constants.hs0000644000000000000000000001760212107326776014417 0ustar -- #hide -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.Constants -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- This purely internal module defines all AL\/ALC constants, which have been -- figured out by configure. In contrast to OpenGL and GLUT, these constants -- varied on different platforms in the past and have evolved quite a bit. -- -------------------------------------------------------------------------------- module Sound.OpenAL.Constants where import Sound.OpenAL.Config ( ALboolean, ALint, ALenum, ALCboolean, ALCint, ALCenum ) -------------------------------------------------------------------------------- #include "HsOpenALConfig.h" -------------------------------------------------------------------------------- al_FALSE, al_TRUE :: ALboolean al_FALSE = CONST_AL_FALSE al_TRUE = CONST_AL_TRUE al_NO_ERROR, al_INVALID_NAME, al_INVALID_ENUM, al_INVALID_VALUE, al_INVALID_OPERATION, al_OUT_OF_MEMORY :: ALenum al_NO_ERROR = CONST_AL_NO_ERROR al_INVALID_NAME = CONST_AL_INVALID_NAME al_INVALID_ENUM = CONST_AL_INVALID_ENUM al_INVALID_VALUE = CONST_AL_INVALID_VALUE al_INVALID_OPERATION = CONST_AL_INVALID_OPERATION al_OUT_OF_MEMORY = CONST_AL_OUT_OF_MEMORY -------------------------------------------------------------------------------- al_DISTANCE_MODEL, al_DOPPLER_FACTOR, al_SPEED_OF_SOUND :: ALenum al_DISTANCE_MODEL = CONST_AL_DISTANCE_MODEL al_DOPPLER_FACTOR = CONST_AL_DOPPLER_FACTOR al_SPEED_OF_SOUND = CONST_AL_SPEED_OF_SOUND al_VERSION, al_RENDERER, al_VENDOR, al_EXTENSIONS :: ALenum al_VERSION = CONST_AL_VERSION al_RENDERER = CONST_AL_RENDERER al_VENDOR = CONST_AL_VENDOR al_EXTENSIONS = CONST_AL_EXTENSIONS al_NONE, al_INVERSE_DISTANCE, al_INVERSE_DISTANCE_CLAMPED, al_LINEAR_DISTANCE, al_LINEAR_DISTANCE_CLAMPED, al_EXPONENT_DISTANCE, al_EXPONENT_DISTANCE_CLAMPED :: ALenum al_NONE = CONST_AL_NONE al_INVERSE_DISTANCE = CONST_AL_INVERSE_DISTANCE al_INVERSE_DISTANCE_CLAMPED = CONST_AL_INVERSE_DISTANCE_CLAMPED al_LINEAR_DISTANCE = CONST_AL_LINEAR_DISTANCE al_LINEAR_DISTANCE_CLAMPED = CONST_AL_LINEAR_DISTANCE_CLAMPED al_EXPONENT_DISTANCE = CONST_AL_EXPONENT_DISTANCE al_EXPONENT_DISTANCE_CLAMPED = CONST_AL_EXPONENT_DISTANCE_CLAMPED -------------------------------------------------------------------------------- al_POSITION, al_VELOCITY, al_GAIN :: ALenum al_POSITION = CONST_AL_POSITION al_VELOCITY = CONST_AL_VELOCITY al_GAIN = CONST_AL_GAIN al_ORIENTATION :: ALenum al_ORIENTATION = CONST_AL_ORIENTATION al_SOURCE_RELATIVE, al_SOURCE_TYPE, al_LOOPING, al_BUFFER, al_BUFFERS_QUEUED, al_BUFFERS_PROCESSED, al_MIN_GAIN, al_MAX_GAIN, al_REFERENCE_DISTANCE, al_ROLLOFF_FACTOR, al_MAX_DISTANCE, al_PITCH, al_DIRECTION, al_CONE_INNER_ANGLE, al_CONE_OUTER_ANGLE, al_CONE_OUTER_GAIN, al_SEC_OFFSET, al_SAMPLE_OFFSET, al_BYTE_OFFSET, al_SOURCE_STATE :: ALenum al_SOURCE_RELATIVE = CONST_AL_SOURCE_RELATIVE al_SOURCE_TYPE = CONST_AL_SOURCE_TYPE al_LOOPING = CONST_AL_LOOPING al_BUFFER = CONST_AL_BUFFER al_BUFFERS_QUEUED = CONST_AL_BUFFERS_QUEUED al_BUFFERS_PROCESSED = CONST_AL_BUFFERS_PROCESSED al_MIN_GAIN = CONST_AL_MIN_GAIN al_MAX_GAIN = CONST_AL_MAX_GAIN al_REFERENCE_DISTANCE = CONST_AL_REFERENCE_DISTANCE al_ROLLOFF_FACTOR = CONST_AL_ROLLOFF_FACTOR al_MAX_DISTANCE = CONST_AL_MAX_DISTANCE al_PITCH = CONST_AL_PITCH al_DIRECTION = CONST_AL_DIRECTION al_CONE_INNER_ANGLE = CONST_AL_CONE_INNER_ANGLE al_CONE_OUTER_ANGLE = CONST_AL_CONE_OUTER_ANGLE al_CONE_OUTER_GAIN = CONST_AL_CONE_OUTER_GAIN al_SEC_OFFSET = CONST_AL_SEC_OFFSET al_SAMPLE_OFFSET = CONST_AL_SAMPLE_OFFSET al_BYTE_OFFSET = CONST_AL_BYTE_OFFSET al_SOURCE_STATE = CONST_AL_SOURCE_STATE al_UNDETERMINED, al_STATIC, al_STREAMING :: ALint al_UNDETERMINED = CONST_AL_UNDETERMINED al_STATIC = CONST_AL_STATIC al_STREAMING = CONST_AL_STREAMING al_INITIAL, al_PLAYING, al_PAUSED, al_STOPPED :: ALint al_INITIAL = CONST_AL_INITIAL al_PLAYING = CONST_AL_PLAYING al_PAUSED = CONST_AL_PAUSED al_STOPPED = CONST_AL_STOPPED -------------------------------------------------------------------------------- al_FREQUENCY, al_SIZE, al_BITS, al_CHANNELS :: ALenum al_FREQUENCY = CONST_AL_FREQUENCY al_SIZE = CONST_AL_SIZE al_BITS = CONST_AL_BITS al_CHANNELS = CONST_AL_CHANNELS al_FORMAT_MONO8, al_FORMAT_MONO16, al_FORMAT_STEREO8, al_FORMAT_STEREO16 :: ALenum al_FORMAT_MONO8 = CONST_AL_FORMAT_MONO8 al_FORMAT_MONO16 = CONST_AL_FORMAT_MONO16 al_FORMAT_STEREO8 = CONST_AL_FORMAT_STEREO8 al_FORMAT_STEREO16 = CONST_AL_FORMAT_STEREO16 -------------------------------------------------------------------------------- alc_FALSE, alc_TRUE :: ALCboolean alc_FALSE = CONST_ALC_FALSE alc_TRUE = CONST_ALC_TRUE alc_FREQUENCY, alc_REFRESH, alc_SYNC, alc_MONO_SOURCES, alc_STEREO_SOURCES :: ALCint alc_FREQUENCY = CONST_ALC_FREQUENCY alc_REFRESH = CONST_ALC_REFRESH alc_SYNC = CONST_ALC_SYNC alc_MONO_SOURCES = CONST_ALC_MONO_SOURCES alc_STEREO_SOURCES = CONST_ALC_STEREO_SOURCES alc_NO_ERROR, alc_INVALID_DEVICE, alc_INVALID_CONTEXT, alc_INVALID_ENUM, alc_INVALID_VALUE, alc_INVALID_OPERATION, alc_OUT_OF_MEMORY :: ALCenum alc_NO_ERROR = CONST_ALC_NO_ERROR alc_INVALID_DEVICE = CONST_ALC_INVALID_DEVICE alc_INVALID_CONTEXT = CONST_ALC_INVALID_CONTEXT alc_INVALID_ENUM = CONST_ALC_INVALID_ENUM alc_INVALID_VALUE = CONST_ALC_INVALID_VALUE alc_INVALID_OPERATION = CONST_ALC_INVALID_OPERATION alc_OUT_OF_MEMORY = CONST_ALC_OUT_OF_MEMORY alc_DEFAULT_DEVICE_SPECIFIER, alc_DEVICE_SPECIFIER, alc_EXTENSIONS, alc_CAPTURE_DEFAULT_DEVICE_SPECIFIER, alc_CAPTURE_DEVICE_SPECIFIER :: ALCenum alc_DEFAULT_DEVICE_SPECIFIER = CONST_ALC_DEFAULT_DEVICE_SPECIFIER alc_DEVICE_SPECIFIER = CONST_ALC_DEVICE_SPECIFIER alc_EXTENSIONS = CONST_ALC_EXTENSIONS alc_CAPTURE_DEFAULT_DEVICE_SPECIFIER= CONST_ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER alc_CAPTURE_DEVICE_SPECIFIER = CONST_ALC_CAPTURE_DEVICE_SPECIFIER alc_ATTRIBUTES_SIZE, alc_ALL_ATTRIBUTES, alc_MAJOR_VERSION, alc_MINOR_VERSION, alc_CAPTURE_SAMPLES :: ALCenum alc_ATTRIBUTES_SIZE = CONST_ALC_ATTRIBUTES_SIZE alc_ALL_ATTRIBUTES = CONST_ALC_ALL_ATTRIBUTES alc_MAJOR_VERSION = CONST_ALC_MAJOR_VERSION alc_MINOR_VERSION = CONST_ALC_MINOR_VERSION alc_CAPTURE_SAMPLES = CONST_ALC_CAPTURE_SAMPLES OpenAL-1.4.0.2/Sound/OpenAL/AL/0000755000000000000000000000000011733255111012361 5ustar OpenAL-1.4.0.2/Sound/OpenAL/AL/BufferInternal.hs0000644000000000000000000000450512107326776015643 0ustar -- #hide -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL.BufferInternal -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- This is a purely internal module for (un-)marshaling Buffer. -- -------------------------------------------------------------------------------- module Sound.OpenAL.AL.BufferInternal ( Buffer(..), marshalBuffer, unmarshalBuffer ) where import Data.ObjectName import Foreign.Marshal.Array ( withArrayLen, peekArray, allocaArray ) import Foreign.Ptr ( Ptr, castPtr ) import Foreign.Storable ( Storable(..) ) import Sound.OpenAL.AL.ALboolean ( unmarshalALboolean ) import Sound.OpenAL.AL.BasicTypes ( ALboolean, ALuint, ALsizei ) import Sound.OpenAL.AL.PeekPoke ( peek1, poke1 ) -------------------------------------------------------------------------------- -- | The abstract buffer type. newtype Buffer = Buffer { bufferID :: ALuint } deriving ( Eq, Ord, Show ) -- | A dummy buffer. nullBuffer :: Buffer nullBuffer = Buffer 0 marshalBuffer :: Maybe Buffer -> ALuint marshalBuffer = bufferID . maybe nullBuffer id unmarshalBuffer :: ALuint -> Maybe Buffer unmarshalBuffer b = if b == bufferID nullBuffer then Nothing else Just (Buffer b) instance Storable Buffer where sizeOf ~(Buffer b) = sizeOf b alignment ~(Buffer b) = alignment b peek = peek1 Buffer . castPtr poke ptr (Buffer b) = poke1 (castPtr ptr) b -------------------------------------------------------------------------------- -- This should really be in Sound.OpenAL.AL.Buffer, but we have it here to -- avoid an orphan module. instance ObjectName Buffer where genObjectNames n = allocaArray n $ \buf -> do alGenBuffers (fromIntegral n) buf peekArray n buf deleteObjectNames buffers = withArrayLen buffers $ alDeleteBuffers . fromIntegral isObjectName = fmap unmarshalALboolean . alIsBuffer foreign import CALLCONV unsafe "alGenBuffers" alGenBuffers :: ALsizei -> Ptr Buffer -> IO () foreign import CALLCONV unsafe "alDeleteBuffers" alDeleteBuffers :: ALsizei -> Ptr Buffer -> IO () foreign import CALLCONV unsafe "alIsBuffer" alIsBuffer :: Buffer -> IO ALboolean OpenAL-1.4.0.2/Sound/OpenAL/AL/Listener.hs0000644000000000000000000001456412107326776014530 0ustar -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL.Listener -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- This module corresponds to sections 4.1 (Basic Listener and Source -- Attributes) and 4.2 (Listener Object) of the OpenAL Specification and -- Reference (version 1.1). -- -- The listener object defines various properties that affect processing of the -- sound for the actual output. The listener is unique for an OpenAL Context, -- and has no name. By controlling the listener, the application controls the -- way the user experiences the virtual world, as the listener defines the -- sampling\/pickup point and orientation, and other parameters that affect the -- output stream. -- -- It is entirely up to the driver and hardware configuration, i.e. the -- installation of OpenAL as part of the operating system and hardware setup, -- whether the output stream is generated for headphones or 2 speakers, 4.1 -- speakers, or other arrangements, whether (and which) HRTFs are applied, -- etc... -- --------------------------------------------------------------------------------- module Sound.OpenAL.AL.Listener ( listenerPosition, listenerVelocity, Gain, listenerGain, orientation ) where import Data.StateVar import Data.Tensor import Foreign.Marshal.Array import Foreign.Marshal.Utils import Foreign.Ptr import Foreign.Storable import Sound.OpenAL.AL.BasicTypes import Sound.OpenAL.AL.PeekPoke import Sound.OpenAL.AL.QueryUtils -------------------------------------------------------------------------------- -- | 'listenerPosition' contains the current location of the listener in the -- world coordinate system. Any 3-tuple of valid float values is allowed. -- Implementation behavior on encountering NaN and infinity is not defined. The -- initial position is ('Vertex3' 0 0 0). listenerPosition :: StateVar (Vertex3 ALfloat) listenerPosition = makeListenerVar GetPosition 3 (peek3 Vertex3) listener3f -------------------------------------------------------------------------------- -- | 'listenerVelocity' contains current velocity (speed and direction) of the -- listener in the world coordinate system. Any 3-tuple of valid float -- values is allowed, and the initial velocity is ('Vector3' 0 0 0). -- 'listenerVelocity' does not affect 'listenerPosition'. OpenAL does not -- calculate the velocity from subsequent position updates, nor does it -- adjust the position over time based on the specified velocity. Any -- such calculation is left to the application. For the purposes of sound -- processing, position and velocity are independent parameters affecting -- different aspects of the sounds. -- -- 'listenerVelocity' is taken into account by the driver to synthesize the -- Doppler effect perceived by the listener for each source, based on the -- velocity of both source and listener, and the Doppler related parameters. listenerVelocity :: StateVar (Vector3 ALfloat) listenerVelocity = makeListenerVar GetVelocity 3 (peek3 Vector3) listener3f -------------------------------------------------------------------------------- -- | A scalar amplitude multiplier. type Gain = ALfloat -- | 'listenerGain' contains a scalar amplitude multiplier, which is effectively -- applied to all sources in the current context. The initial value 1 means -- that the sound is unattenuated. A 'listenerGain' value of 0.5 is equivalent -- to an attenuation of 6dB. The value zero equals silence (no output). Driver -- implementations are free to optimize this case and skip mixing and processing -- stages where applicable. The implementation is in charge of ensuring -- artifact-free (click-free) changes of gain values and is free to defer actual -- modification of the sound samples, within the limits of acceptable latencies. -- -- A 'listenerGain' larger than 1 (amplification) is permitted. However, the -- implementation is free to clamp the total gain (effective gain per source -- times listener gain) to 1 to prevent overflow. listenerGain :: StateVar Gain listenerGain = makeListenerVar GetGain 1 (peek1 id) listenerf -------------------------------------------------------------------------------- -- | 'orientation' contains an \"at\" vector and an \"up\" vector, where the -- \"at\" vector represents the \"forward\" direction of the listener and the -- orthogonal projection of the \"up\" vector into the subspace perpendicular to -- the \"at\" vector represents the \"up\" direction for the listener. OpenAL -- expects two vectors that are linearly independent. These vectors are not -- expected to be normalized. If the two vectors are linearly dependent, -- behavior is undefined. The initial orientation is ('Vector3' 0 0 (-1), -- 'Vector3' 0 1 0), i.e. looking down the Z axis with the Y axis pointing -- upwards. orientation :: StateVar (Vector3 ALfloat, Vector3 ALfloat) orientation = makeListenerVar GetOrientation 6 (peek6 Vector3) listenerVector6 -------------------------------------------------------------------------------- listenerf :: GetPName -> ALfloat -> IO () listenerf = alListenerf . marshalGetPName foreign import CALLCONV unsafe "alListenerf" alListenerf :: ALenum -> ALfloat -> IO () -------------------------------------------------------------------------------- listener3f :: Storable a => GetPName -> a -> IO () listener3f n x = with x $ listenerfv n listenerVector6 :: GetPName -> (Vector3 ALfloat, Vector3 ALfloat) -> IO () listenerVector6 n (x, y) = withArray [x, y] $ listenerfv n listenerfv :: GetPName -> Ptr a -> IO () listenerfv = alListenerfv . marshalGetPName foreign import CALLCONV unsafe "alListenerfv" alListenerfv :: ALenum -> Ptr a -> IO () -------------------------------------------------------------------------------- getListenerfv :: GetPName -> Ptr ALfloat -> IO () getListenerfv = alGetListenerfv . marshalGetPName foreign import CALLCONV unsafe "alGetListenerfv" alGetListenerfv :: ALenum -> Ptr ALfloat -> IO () -------------------------------------------------------------------------------- makeListenerVar :: GetPName -> Int -> (Ptr ALfloat -> IO a) -> (GetPName -> a -> IO ()) -> StateVar a makeListenerVar pname size reader writer = makeStateVar (allocaArray size $ \buf -> do getListenerfv pname buf reader buf) (writer pname) OpenAL-1.4.0.2/Sound/OpenAL/AL/StringQueries.hs0000644000000000000000000000203012107326776015530 0ustar -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL.StringQueries -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- This module corresponds to section 3.1.2 (String Queries) of the OpenAL -- Specification and Reference (version 1.1). -- -------------------------------------------------------------------------------- module Sound.OpenAL.AL.StringQueries ( alVendor, alRenderer ) where import Data.StateVar import Sound.OpenAL.AL.QueryUtils ( StringName(..), getString ) -------------------------------------------------------------------------------- -- | Contains the name of the vendor. alVendor :: GettableStateVar String alVendor = makeGettableStateVar (getString Vendor) -- | Contains information about the specific renderer. alRenderer :: GettableStateVar String alRenderer = makeGettableStateVar (getString Renderer) OpenAL-1.4.0.2/Sound/OpenAL/AL/PeekPoke.hs0000644000000000000000000000332212107326776014434 0ustar -- #hide -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL.PeekPoke -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file libraries/OpenGL/LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- This is a purely internal module with peek- and poke-related utilities. -- -------------------------------------------------------------------------------- module Sound.OpenAL.AL.PeekPoke ( poke1, peek1, peek3, peek6 ) where import Foreign.Ptr ( Ptr ) import Foreign.Storable ( Storable(peekElemOff,pokeElemOff) ) -------------------------------------------------------------------------------- -- The implementation is little bit verbose/redundant, but seems to generate -- better code than mapM/zipWithM_. -------------------------------------------------------------------------------- {-# INLINE poke1 #-} poke1 :: Storable a => Ptr a -> a -> IO () poke1 ptr x = pokeElemOff ptr 0 x -------------------------------------------------------------------------------- {-# INLINE peek1 #-} peek1 :: Storable a => (a -> b) -> Ptr a -> IO b peek1 f ptr = do x <- peekElemOff ptr 0 return $ f x {-# INLINE peek3 #-} peek3 :: Storable a => (a -> a -> a -> b) -> Ptr a -> IO b peek3 f ptr = do x <- peekElemOff ptr 0 y <- peekElemOff ptr 1 z <- peekElemOff ptr 2 return $ f x y z {-# INLINE peek6 #-} peek6 :: Storable a => (a -> a -> a -> b) -> Ptr a -> IO (b, b) peek6 f ptr = do x <- peekElemOff ptr 0 y <- peekElemOff ptr 1 z <- peekElemOff ptr 2 u <- peekElemOff ptr 3 v <- peekElemOff ptr 4 w <- peekElemOff ptr 5 return $ (f x y z, f u v w) OpenAL-1.4.0.2/Sound/OpenAL/AL/Attenuation.hs0000644000000000000000000002311712107326776015230 0ustar -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL.Attenuation -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- This module corresponds to section 3.4 (Attenuation By Distance) of the -- OpenAL Specification and Reference (version 1.1). -- -------------------------------------------------------------------------------- module Sound.OpenAL.AL.Attenuation ( -- * Introduction -- $Introduction -- * Handling the Distance Model DistanceModel(..), distanceModel -- * Evaluation of Gain\/Attenuation Related State -- $EvaluationOfGainAttenuationRelatedState -- * No Culling By Distance -- $NoCullingByDistance ) where import Data.StateVar import Foreign.Marshal.Alloc ( alloca ) import Foreign.Ptr ( Ptr ) import Sound.OpenAL.AL.BasicTypes ( ALint, ALenum ) import Sound.OpenAL.AL.PeekPoke ( peek1 ) import Sound.OpenAL.AL.QueryUtils ( GetPName(GetDistanceModel), marshalGetPName ) import Sound.OpenAL.Constants ( al_NONE, al_INVERSE_DISTANCE, al_INVERSE_DISTANCE_CLAMPED, al_LINEAR_DISTANCE, al_LINEAR_DISTANCE_CLAMPED, al_EXPONENT_DISTANCE, al_EXPONENT_DISTANCE_CLAMPED ) #ifdef __HADDOCK__ import Sound.OpenAL.AL.Source ( sourceGain, gainBounds, coneAngles, coneOuterGain, referenceDistance, rolloffFactor, maxDistance ) #endif -------------------------------------------------------------------------------- -- $Introduction -- Samples usually use the entire dynamic range of the chosen format\/encoding, -- independent of their real world intensity. In other words, a jet engine and a -- clockwork both will have samples with full amplitude. The application will -- then have to adjust source gain accordingly to account for relative -- differences. -- -- Source gain is then attenuated by distance. The effective attenuation of a -- source depends on many factors, among which distance attenuation and source -- and listener gain are only some of the contributing factors. Even if the -- source and listener gain exceed 1 (amplification beyond the guaranteed -- dynamic range), distance and other attenuation might ultimately limit the -- overall gain to a value below 1. -------------------------------------------------------------------------------- -- $EvaluationOfGainAttenuationRelatedState -- While amplification\/attenuation commute (multiplication of scaling factors), -- clamping operations do not. The order in which various gain related -- operations are applied is: -- -- 1. Distance attenuation is calculated first, including minimum -- ('referenceDistance') and maximum ('maxDistance') thresholds. -- -- 2. The result is then multiplied by source gain. -- -- 3. If the source is directional (the inner cone angle is less than the outer -- cone angle, see 'coneAngles'), an angle-dependent attenuation is calculated -- depending on 'coneOuterGain', and multiplied with the distance-dependent -- attenuation. The resulting attenuation factor for the given angle and -- distance between listener and source is multiplied with 'sourceGain'. -- -- 4. The effective gain computed this way is compared against 'gainBounds'. -- -- 5. The result is guaranteed to be clamped to 'gainBounds', and subsequently -- multiplied by listener gain which serves as an overall volume control. -- -- The implementation is free to clamp listener gain if necessary due to -- hardware or implementation constraints. -------------------------------------------------------------------------------- -- $NoCullingByDistance -- With the DS3D compatible inverse clamped distance model, OpenAL provides a -- per-source 'maxDistance' attribute that can be used to define a distance -- beyond which the source will not be further attenuated by distance. The DS3D -- distance attenuation model and its clamping of volume is also extended by a -- mechanism to cull (mute) sources from processing, based on distance. However, -- the OpenAL does not support culling a source from processing based on a -- distance threshold. -- -- At this time OpenAL is not meant to support culling at all. Culling based on -- distance, or bounding volumes, or other criteria, is best left to the -- application. For example, the application might employ sophisticated -- techniques to determine whether sources are audible that are beyond the scope -- of OpenAL. In particular, rule based culling inevitably introduces acoustic -- artifacts. E.g. if the listener-source distance is nearly equal to the culling -- threshold distance, but varies above and below, there will be popping -- artifacts in the absence of hysteresis. -------------------------------------------------------------------------------- -- | OpenAL currently supports six modes of operation with respect to distance -- attenuation, including one that is similar to the IASIG I3DL2 model. The -- application chooses one of these models (or chooses to disable -- distance-dependent attenuation) on a per-context basis. -- -- The distance used in the formulas for the \"clamped\" modes below is clamped -- to be in the range between 'referenceDistance' and 'maxDistance': -- -- /clamped distance/ = -- max('referenceDistance', min(/distance/, 'maxDistance')) -- -- The linear models are not physically realistic, but do allow full attenuation -- of a source beyond a specified distance. The OpenAL implementation is still -- free to apply any range clamping as necessary. -- -- With all the distance models, if the formula can not be evaluated then the -- source will not be attenuated. For example, if a linear model is being used -- with 'referenceDistance' equal to 'maxDistance', then the gain equation will -- have a divide-by-zero error in it. In this case, there is no attenuation for -- that source. data DistanceModel = NoAttenuation -- ^ Bypass all distance attenuation calculation for all sources. The -- implementation is expected to optimize this situation. | InverseDistance -- ^ Inverse distance rolloff model, which is equivalent to the IASIG I3DL2 -- model with the exception that 'referenceDistance' does not imply any -- clamping. -- -- /gain/ = 'referenceDistance' \/ ('referenceDistance' + -- 'rolloffFactor' \* (/distance/ - 'referenceDistance')) -- -- The 'referenceDistance' parameter used here is a per-source attribute -- which is the distance at which the listener will experience gain -- (unless the implementation had to clamp effective gain to the available -- dynamic range). 'rolloffFactor' is per-source parameter the application -- can use to increase or decrease the range of a source by decreasing or -- increasing the attenuation, respectively. The default value is 1. The -- implementation is free to optimize for a 'rolloffFactor' value of 0, -- which indicates that the application does not wish any distance -- attenuation on the respective source. | InverseDistanceClamped -- ^ Inverse Distance clamped model, which is essentially the inverse -- distance rolloff model, extended to guarantee that for distances below -- 'referenceDistance', gain is clamped. This mode is equivalent to the -- IASIG I3DL2 distance model. | LinearDistance -- ^ Linear distance rolloff model, modeling a linear dropoff in gain as -- distance increases between the source and listener. -- -- /gain/ = (1 - 'rolloffFactor' \* (/distance/ - 'referenceDistance') \/ -- ('maxDistance' - 'referenceDistance')) | LinearDistanceClamped -- ^ Linear Distance clamped model, which is the linear model, extended to -- guarantee that for distances below 'referenceDistance', gain is clamped. | ExponentDistance -- ^ Exponential distance rolloff model, modeling an exponential dropoff in -- gain as distance increases between the source and listener. -- -- /gain/ = (/distance/ \/ 'referenceDistance') \*\* (- 'rolloffFactor') | ExponentDistanceClamped -- ^ Exponential Distance clamped model, which is the exponential model, -- extended to guarantee that for distances below 'referenceDistance', -- gain is clamped. deriving ( Eq, Ord, Show ) marshalDistanceModel :: DistanceModel -> ALenum marshalDistanceModel x = case x of NoAttenuation -> al_NONE InverseDistance -> al_INVERSE_DISTANCE InverseDistanceClamped -> al_INVERSE_DISTANCE_CLAMPED LinearDistance -> al_LINEAR_DISTANCE LinearDistanceClamped -> al_LINEAR_DISTANCE_CLAMPED ExponentDistance -> al_EXPONENT_DISTANCE ExponentDistanceClamped -> al_EXPONENT_DISTANCE_CLAMPED unmarshalDistanceModel :: ALenum -> DistanceModel unmarshalDistanceModel x | x == al_NONE = NoAttenuation | x == al_INVERSE_DISTANCE = InverseDistance | x == al_INVERSE_DISTANCE_CLAMPED = InverseDistanceClamped | x == al_LINEAR_DISTANCE = LinearDistance | x == al_LINEAR_DISTANCE_CLAMPED = LinearDistanceClamped | x == al_EXPONENT_DISTANCE = ExponentDistance | x == al_EXPONENT_DISTANCE_CLAMPED = ExponentDistanceClamped | otherwise = error ("unmarshalDistanceModel: illegal value " ++ show x) -- | Contains the current per-context distance model. distanceModel :: StateVar DistanceModel distanceModel = makeStateVar (alloca $ \buf -> do alGetIntegerv (marshalGetPName GetDistanceModel) buf peek1 (unmarshalDistanceModel . fromIntegral) buf) (alDistanceModel . marshalDistanceModel) foreign import CALLCONV unsafe "alGetIntegerv" alGetIntegerv :: ALenum -> Ptr ALint -> IO () foreign import CALLCONV unsafe "alDistanceModel" alDistanceModel :: ALenum -> IO () OpenAL-1.4.0.2/Sound/OpenAL/AL/Doppler.hs0000644000000000000000000000750412107326776014344 0ustar -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL.Doppler -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- This module corresponds to section 3.5.2. (Velocity Dependent Doppler Effect) -- of the OpenAL Specification and Reference (version 1.1). -- -------------------------------------------------------------------------------- module Sound.OpenAL.AL.Doppler ( -- * Introduction -- $Introduction dopplerFactor, speedOfSound ) where import Data.StateVar import Foreign.Ptr ( FunPtr ) import Sound.OpenAL.AL.BasicTypes ( ALenum, ALfloat ) import Sound.OpenAL.AL.Extensions ( alProcAddress ) import Sound.OpenAL.AL.QueryUtils ( GetPName(GetDopplerFactor,GetSpeedOfSound), marshalGetPName ) #ifdef __HADDOCK__ import Sound.OpenAL.AL.Errors ( ALError(ALInvalidValue) ) #endif -------------------------------------------------------------------------------- -- | 'dopplerFactor' is a simple scaling of source and listener velocities to -- exaggerate or deemphasize the Doppler (pitch) shift resulting from the -- calculation. Setting 'dopplerFactor' to a negative value will result in an -- 'ALInvalidValue' error, the command is then ignored. The default value is 1. -- The implementation is free to optimize the case of 'dopplerFactor' containing -- zero, as this effectively disables the effect. dopplerFactor :: StateVar ALfloat dopplerFactor = makeDopplerVar GetDopplerFactor "alDopplerFactor" -------------------------------------------------------------------------------- -- | 'speedOfSound' allows the application to change the reference (propagation) -- speed used in the Doppler calculation. The source and listener velocities -- should be expressed in the same units as the speed of sound. Setting -- 'speedOfSound' to a negative or zero value will result in an 'ALInvalidValue' -- error, the command is ignored then. The default value is 343.3 (appropriate -- for velocity units of meters and air as the propagation medium). speedOfSound :: StateVar ALfloat speedOfSound = makeDopplerVar GetSpeedOfSound "alSpeedOfSound" -------------------------------------------------------------------------------- makeDopplerVar :: GetPName -> String -> StateVar ALfloat makeDopplerVar p apiEntryName = makeStateVar (alGetFloat (marshalGetPName p)) (\value -> do -- ToDo: Should we check alcVersion or alIsExtensionPresent here? funPtr <- get (alProcAddress apiEntryName) invokeWithFloat funPtr value) foreign import CALLCONV unsafe "alGetFloat" alGetFloat :: ALenum -> IO ALfloat type Invoker a = FunPtr a -> a foreign import CALLCONV unsafe "dynamic" invokeWithFloat :: Invoker (ALfloat -> IO ()) -------------------------------------------------------------------------------- -- $Introduction -- The Doppler Effect depends on the velocities of source and listener relative -- to the medium, and the propagation speed of sound in that medium. The -- application might want to emphasize or de-emphasize the Doppler Effect as -- physically accurate calculation might not give the desired results. -- The amount of frequency shift (pitch change) is proportional to the speed of -- listener and source along their line of sight. -- -- The Doppler Effect as implemented by OpenAL is described in detail in section -- 3.5.2 of the OpenAL 1.1 specification. Note that effects of the medium (air, -- water) moving with respect to listener and source are ignored. There are two -- API calls global to the current context that provide control of the Doppler -- factor and the speed of sound. Distance and velocity units are completely -- independent of one another (so you could use different units for each if -- desired). OpenAL-1.4.0.2/Sound/OpenAL/AL/Buffer.hs0000644000000000000000000001664112107326776014152 0ustar -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL.Buffer -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- This module corresponds to chapter 6 (Buffers) of the OpenAL Specification -- and Reference (version 1.1). -- -- A buffer encapsulates OpenAL state related to storing sample data. The -- application can request and release buffer objects, and fill them with -- data. Data can be supplied compressed and encoded as long as the format is -- supported. Buffers can, internally, contain waveform data as uncompressed or -- compressed samples. -- -- Unlike source (see "Sound.OpenAL.AL.Source") and listener (see -- "Sound.OpenAL.AL.Listener") objects, buffer objects can be shared among AL -- contexts. Buffers are referenced by sources. A single buffer can be referred -- to by multiple sources. This separation allows drivers and hardware to -- optimize storage and processing where applicable. -- -- The simplest supported format for buffer data is PCM. PCM data is assumed to -- use the processor\'s native byte order. Other formats use the byte order -- native to that format. -- -- At this time, buffer states are defined for purposes of discussion. The -- states described in this section are not exposed through the API (can not be -- queried, or be set directly), and the state description used in the -- implementation might differ from this. -- -- A buffer is considered to be in one of the following states, with respect to -- all sources: -- -- [/unused/] The buffer is not included in any queue for any source. In -- particular, the buffer is neither pending nor current for any source. The -- buffer name can be deleted at this time. -- -- [/processed/] The buffer is listed in the queue of at least one source, but -- is neither pending nor current for any source. The buffer can be deleted as -- soon as it has been unqueued for all sources it is queued with. -- -- [/pending/] There is at least one source for which the buffer has been queued, -- for which the buffer data has not yet been dereferenced. The buffer can only -- be unqueued for those sources that have dereferenced the data in the buffer -- in its entirety, and cannot be deleted or changed. -- -- The buffer state is dependent on the state of all sources that is has been -- queued for. A single queue occurrence of a buffer propagates the buffer state -- (over all sources) from /unused/ to /processed/ or higher. Sources that are -- in the 'Stopped' or 'Initial' states still have queue entries that cause -- buffers to be /processed/. -- -- A single queue entry with a single source for which the buffer is not yet -- /processed/ propagates the buffer\'s queuing state to /pending/. -- -- Buffers that are /processed/ for a given source can be unqueued from that -- source\'s queue. Buffers that have been unqueued from all sources are -- /unused/. Buffers that are /unused/ can be deleted, or changed by writing -- 'bufferData'. -- -------------------------------------------------------------------------------- module Sound.OpenAL.AL.Buffer ( Buffer, MemoryRegion(..), Format(..), BufferData(..), bufferData ) where import Data.StateVar import Foreign.Marshal.Alloc ( alloca ) import Foreign.Ptr ( Ptr, nullPtr ) import Sound.OpenAL.AL.BufferInternal ( Buffer(..) ) import Sound.OpenAL.AL.BasicTypes ( ALint, ALsizei, ALenum ) import Sound.OpenAL.AL.Format ( Format(..), marshalFormat ) import Sound.OpenAL.AL.PeekPoke ( peek1 ) import Sound.OpenAL.ALC.Context ( Frequency ) import Sound.OpenAL.Constants ( al_FREQUENCY, al_SIZE, al_BITS, al_CHANNELS ) #ifdef __HADDOCK__ import Sound.OpenAL.AL.SourceState ( SourceState(..) ) import Sound.OpenAL.AL.Errors ( ALErrorCategory(..) ) #endif -------------------------------------------------------------------------------- data MemoryRegion a = MemoryRegion (Ptr a) ALsizei #ifdef __HADDOCK__ -- Help Haddock a bit, because it doesn't do any instance inference. instance Eq (MemoryRegion a) instance Ord (MemoryRegion a) instance Show (MemoryRegion a) #else deriving ( Eq, Ord, Show ) #endif data BufferData a = BufferData (MemoryRegion a) Format Frequency #ifdef __HADDOCK__ -- Help Haddock a bit, because it doesn't do any instance inference. instance Eq (BufferData a) instance Ord (BufferData a) instance Show (BufferData a) #else deriving ( Eq, Ord, Show ) #endif -------------------------------------------------------------------------------- -- | A special case of buffer state is the actual sound sample data stored in -- association with the buffer. Applications can specify sample data using -- 'bufferData'. -- -- The data specified is copied to an internal software, or if possible, -- hardware buffer. The implementation is free to apply decompression, -- conversion, resampling, and filtering as needed. The internal format of the -- buffer is not exposed to the application, and not accessible. -- -- Buffers containing audio data with more than one channel will be played -- without 3D spatialization features, these formats are normally used for -- background music. Applications should always check for an error condition -- after attempting to specify buffer data in case an implementation has to -- generate an 'ALOutOfMemory' or a conversion related 'ALInvalidValue' error. -- The application is free to reuse the memory specified by the data pointer -- once 'bufferData' is set. The implementation has to dereference, e.g. copy, -- the data while accessing 'bufferData' execution. bufferData :: Buffer -> StateVar (BufferData a) bufferData buffer = makeStateVar (getBufferData buffer) (setBufferData buffer) getBufferData :: Buffer -> IO (BufferData a) getBufferData buffer = do channels <- getBufferi buffer Channels bits <- getBufferi buffer Bits raw <- return nullPtr -- ToDo: AL_DATA query missing!!! size <- getBufferi buffer Size frequency <- getBufferi buffer Frequency return $ BufferData (MemoryRegion raw size) (makeFormat channels bits) frequency setBufferData :: Buffer -> BufferData a -> IO () setBufferData buffer (BufferData (MemoryRegion raw size) format frequency) = alBufferData buffer (marshalFormat format) raw size (round frequency) foreign import CALLCONV unsafe "alBufferData" alBufferData :: Buffer -> ALenum -> Ptr a -> ALsizei -> ALsizei -> IO () -------------------------------------------------------------------------------- -- ToDo: What about IMAADPCMMono16, IMAADPCMStereo16, Vorbis...? makeFormat :: ALint -> ALint -> Format makeFormat 1 8 = Mono8 makeFormat 2 8 = Stereo8 makeFormat 1 16 = Mono16 makeFormat 2 16 = Stereo16 makeFormat channels bits = error ("makeFormat: illegal values " ++ show (channels, bits)) -------------------------------------------------------------------------------- data BufferQuery = Frequency | Size | Bits | Channels marshalBufferQuery :: BufferQuery -> ALenum marshalBufferQuery x = case x of Frequency -> al_FREQUENCY Size -> al_SIZE Bits -> al_BITS Channels -> al_CHANNELS -------------------------------------------------------------------------------- getBufferi :: Num a => Buffer -> BufferQuery -> IO a getBufferi buffer query = alloca $ \buf -> do alGetBufferi buffer (marshalBufferQuery query) buf peek1 fromIntegral buf foreign import CALLCONV unsafe "alGetBufferi" alGetBufferi :: Buffer -> ALenum -> Ptr ALint -> IO () OpenAL-1.4.0.2/Sound/OpenAL/AL/ALboolean.hs0000644000000000000000000000164312107326776014571 0ustar -- #hide -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL.ALboolean -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- This is a purely internal module for (un-)marshaling ALboolean. -- -------------------------------------------------------------------------------- module Sound.OpenAL.AL.ALboolean ( marshalALboolean, unmarshalALboolean ) where import Sound.OpenAL.AL.BasicTypes ( ALboolean ) import Sound.OpenAL.Constants ( al_FALSE, al_TRUE ) -------------------------------------------------------------------------------- marshalALboolean :: Bool -> ALboolean marshalALboolean False = al_FALSE marshalALboolean True = al_TRUE unmarshalALboolean :: ALboolean -> Bool unmarshalALboolean = (/= al_FALSE) OpenAL-1.4.0.2/Sound/OpenAL/AL/Format.hs0000644000000000000000000000277612107326776014175 0ustar -- #hide -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL.Format -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- This is a purely internal module for (un-)marshaling Format. -- -------------------------------------------------------------------------------- module Sound.OpenAL.AL.Format ( Format(..), marshalFormat, unmarshalFormat ) where import Sound.OpenAL.AL.BasicTypes ( ALenum ) import Sound.OpenAL.Constants ( al_FORMAT_MONO8, al_FORMAT_MONO16, al_FORMAT_STEREO8, al_FORMAT_STEREO16 ) -------------------------------------------------------------------------------- -- | Valid sound formats. An implementation may expose other formats, see -- "Sound.OpenAL.ALC.Extensions" for information on determining if additional -- formats are supported. data Format = Mono8 | Mono16 | Stereo8 | Stereo16 deriving ( Eq, Ord, Show ) marshalFormat :: Format -> ALenum marshalFormat x = case x of Mono8 -> al_FORMAT_MONO8 Mono16 -> al_FORMAT_MONO16 Stereo8 -> al_FORMAT_STEREO8 Stereo16 -> al_FORMAT_STEREO16 unmarshalFormat :: ALenum -> Format unmarshalFormat x | x == al_FORMAT_MONO8 = Mono8 | x == al_FORMAT_MONO16 = Mono16 | x == al_FORMAT_STEREO8 = Stereo8 | x == al_FORMAT_STEREO16 = Stereo16 | otherwise = error ("unmarshalFormat: illegal value " ++ show x) OpenAL-1.4.0.2/Sound/OpenAL/AL/Extensions.hs0000644000000000000000000001021612107326776015070 0ustar -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL.Extensions -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- This module corresponds to section 3.1.2 (String Queries) and chapter 7 -- (Appendix: Extensions) of the OpenAL Specification and Reference (version -- 1.1). -- -------------------------------------------------------------------------------- module Sound.OpenAL.AL.Extensions ( alExtensions, alIsExtensionPresent, alProcAddress, alEnumValue, alVersion ) where import Data.StateVar import Foreign.Ptr ( Ptr, FunPtr ) import Sound.OpenAL.AL.ALboolean ( unmarshalALboolean ) import Sound.OpenAL.AL.BasicTypes ( ALboolean, ALchar, ALenum ) import Sound.OpenAL.AL.QueryUtils ( StringName(..), getString ) import Sound.OpenAL.AL.String ( withALString ) #ifdef __HADDOCK__ import Foreign.Ptr ( nullFunPtr ) #endif -------------------------------------------------------------------------------- -- | Contains the list of available extensions. alExtensions :: GettableStateVar [String] alExtensions = makeGettableStateVar (fmap words $ getString Extensions) -------------------------------------------------------------------------------- -- | Contains a version string in the format @\"/\/./\/ /\/\"@. alVersion :: GettableStateVar String alVersion = makeGettableStateVar (getString Version) -------------------------------------------------------------------------------- -- | To verify that a given extension is available for the current context, use -- 'alIsExtensionPresent'. For invalid and unsupported string tokens it contains -- 'False'. The extension name is not case sensitive: The implementation will -- convert the name to all upper-case internally (and will express extension -- names in upper-case). alIsExtensionPresent :: String -> GettableStateVar Bool alIsExtensionPresent extensionName = makeGettableStateVar $ fmap unmarshalALboolean $ withALString extensionName alIsExtensionPresent_ foreign import CALLCONV unsafe "alIsExtensionPresent" alIsExtensionPresent_ :: Ptr ALchar -> IO ALboolean -------------------------------------------------------------------------------- -- | To retrieving function entry addresses, applications can use -- 'alProcAddress'. It contains 'nullFunPtr' if no entry point with the given -- name can be found. Implementations are free to use 'nullFunPtr' if an -- entry point is present, but not applicable for the current context. However -- the specification does not guarantee this behavior. Applications can use -- 'alProcAddress' to obtain core API entry points, not just extensions. This -- is the recommended way to dynamically load and unload OpenAL DLLs as sound -- drivers. alProcAddress :: String -> GettableStateVar (FunPtr a) alProcAddress funcName = makeGettableStateVar $ withALString funcName alGetProcAddress foreign import CALLCONV unsafe "alGetProcAddress" alGetProcAddress :: Ptr ALchar -> IO (FunPtr a) -------------------------------------------------------------------------------- -- | To obtain enumeration values for extensions, the application has to use -- 'alEnumValue' of an extension token. Enumeration values are defined within -- the OpenAL name space and allocated according to specification of the core -- API and the extensions, thus they are context-independent. -- -- 'alEnumValue' contains 0 if the enumeration can not be found. The presence of -- an enum value does not guarantee the applicability of an extension to the -- current context. A non-zero value indicates merely that the implementation is -- aware of the existence of this extension. Implementations should not attempt -- to use 0 to indicate that the extensions is not supported for the current -- context. alEnumValue :: String -> GettableStateVar ALenum alEnumValue enumName = makeGettableStateVar $ withALString enumName alGetEnumValue foreign import CALLCONV unsafe "alGetEnumValue" alGetEnumValue :: Ptr ALchar -> IO ALenum OpenAL-1.4.0.2/Sound/OpenAL/AL/String.hs0000644000000000000000000000173412107326776014204 0ustar -- #hide -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL.String -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -------------------------------------------------------------------------------- module Sound.OpenAL.AL.String ( withALString, peekALString ) where import Foreign.C.String ( withCString, peekCString ) import Foreign.Ptr ( Ptr, castPtr ) import Sound.OpenAL.AL.BasicTypes ( ALchar ) -------------------------------------------------------------------------------- -- AL uses "Ptr ALchar" instead of "CString" for strings, so some wrappers -- are quite handy. withALString :: String -> (Ptr ALchar -> IO a) -> IO a withALString str action = withCString str (action . castPtr) peekALString :: Ptr ALchar -> IO String peekALString = peekCString . castPtr OpenAL-1.4.0.2/Sound/OpenAL/AL/Errors.hs0000644000000000000000000000655712107326776014222 0ustar -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL.Errors -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- This module corresponds to section 2.7 (AL Errors) of the OpenAL -- Specification and Reference (version 1.1). -- -------------------------------------------------------------------------------- module Sound.OpenAL.AL.Errors ( ALError(..), ALErrorCategory(..), alErrors ) where import Data.StateVar import Sound.OpenAL.AL.BasicTypes ( ALenum ) import Sound.OpenAL.Constants ( al_NO_ERROR, al_INVALID_NAME, al_INVALID_ENUM, al_INVALID_VALUE, al_INVALID_OPERATION, al_OUT_OF_MEMORY ) import Sound.OpenAL.AL.QueryUtils ( StringName(..), getString ) -------------------------------------------------------------------------------- -- | AL errors consist of a general error category and a description of what -- went wrong. data ALError = ALError ALErrorCategory String deriving ( Eq, Ord, Show ) -------------------------------------------------------------------------------- -- | General AL error categories. data ALErrorCategory = ALInvalidEnum | ALInvalidValue | ALInvalidOperation | ALInvalidName | ALOutOfMemory deriving ( Eq, Ord, Show ) unmarshalALErrorCategory :: ALenum -> ALErrorCategory unmarshalALErrorCategory x | x == al_INVALID_ENUM = ALInvalidEnum | x == al_INVALID_VALUE = ALInvalidValue | x == al_INVALID_OPERATION = ALInvalidOperation | x == al_INVALID_NAME = ALInvalidName | x == al_OUT_OF_MEMORY = ALOutOfMemory | otherwise = error ("unmarshalALErrorCategory: illegal value " ++ show x) -------------------------------------------------------------------------------- -- | OpenAL detects only a subset of those conditions that could be considered -- errors. This is because in many cases error checking would adversely impact -- the performance of an error-free program. The state variable 'alErrors' is -- used to obtain error information. When an error is detected by AL, a flag is -- set and the error code is recorded. Further errors, if they occur, do not -- affect this recorded code. When 'alErrors' is read, the error is returned and -- the flag is cleared, so that a further error will again record its code. If -- reading 'alErrors' returns @\[\]@ then there has been no detectable error -- since the last time 'alErrors' (or since the AL was initialized). -- -- When an error flag is set, results of AL operations are undefined only if -- 'ALOutOfMemory' has occurred. In other cases, the command generating the -- error is ignored so that it has no effect on AL state or output buffer -- contents. If the error generating command returns a value, it returns zero. -- If the generating command modifies values through a pointer argument, no -- change is made to these values. These error semantics apply only to AL -- errors, not to system errors such as memory access errors. alErrors :: GettableStateVar [ALError] alErrors = makeGettableStateVar $ do c <- alGetError if c == al_NO_ERROR then return [] else do s <- getString (ALErrorCategory c) return [ ALError (unmarshalALErrorCategory c) s ] foreign import CALLCONV unsafe "alGetError" alGetError :: IO ALenum OpenAL-1.4.0.2/Sound/OpenAL/AL/SourceState.hs0000644000000000000000000000331112107326776015170 0ustar -- #hide -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL.SourceState -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -------------------------------------------------------------------------------- module Sound.OpenAL.AL.SourceState ( SourceState(..), unmarshalSourceState ) where import Sound.OpenAL.AL.BasicTypes ( ALint ) import Sound.OpenAL.Constants ( al_INITIAL, al_PLAYING, al_PAUSED, al_STOPPED ) -------------------------------------------------------------------------------- -- | Each source can be in one of four possible execution states: 'Initial', -- 'Playing', 'Paused', 'Stopped'. Sources that are either 'Playing' or 'Paused' -- are considered active. Sources that are 'Stopped' or 'Initial' are considered -- inactive. Only 'Playing' sources are included in the processing. The -- implementation is free to skip those processing stages for sources that have -- no effect on the output (e.g. mixing for a source muted by zero gain, but not -- sample offset increments). Depending on the current state of a source certain -- (e.g. repeated) state transition commands are legal NOPs: they will be -- ignored, no error is generated. data SourceState = Initial | Playing | Paused | Stopped deriving ( Eq, Ord, Show ) unmarshalSourceState :: ALint -> SourceState unmarshalSourceState x | x == al_INITIAL = Initial | x == al_PLAYING = Playing | x == al_PAUSED = Paused | x == al_STOPPED = Stopped | otherwise = error ("unmarshalSourceState: illegal value " ++ show x) OpenAL-1.4.0.2/Sound/OpenAL/AL/Source.hs0000644000000000000000000010127312107326776014175 0ustar -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL.Source -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- This module corresponds to sections 4.1 (Basic Listener and Source -- Attributes) and 4.3 (Source Objects) of the OpenAL Specification and -- Reference (version 1.1). -- -- Sources specify attributes like position, velocity, and a buffer with sample -- data. By controlling a source\'s attributes the application can modify and -- parameterize the static sample data provided by the buffer referenced by the -- source. Sources define a localized sound, and encapsulate a set of attributes -- applied to a sound at its origin, i.e. in the very first stage of the -- processing on the way to the listener. Source related effects have to be -- applied before listener related effects unless the output is invariant to any -- collapse or reversal of order. OpenAL also provides additional functions to -- manipulate and query the execution state of sources: the current playing -- status of a source, including access to the current sampling position within -- the associated buffer. -- -------------------------------------------------------------------------------- module Sound.OpenAL.AL.Source ( -- * The Source Type Source, -- * Source Attributes -- ** Basic Source Attributes sourcePosition, sourceVelocity, sourceGain, -- ** Source Positioning SourceRelative(..), sourceRelative, -- ** Source Type SourceType(..), sourceType, -- ** Buffer Looping LoopingMode(..), loopingMode, -- ** Current Buffer buffer, -- ** Queue State Queries buffersQueued, buffersProcessed, -- ** Bounds on Gain gainBounds, -- ** Distance Model Attributes referenceDistance, rolloffFactor, maxDistance, -- ** Frequency Shift by Pitch pitch, -- ** Direction and Cone -- $DirectionAndCone direction, coneAngles, coneOuterGain, -- ** Offset secOffset, sampleOffset, byteOffset, -- * Queuing Buffers with a Source -- $QueuingBuffersWithASource queueBuffers, unqueueBuffers, -- * Managing Source Execution -- $ManagingSourceExecution SourceState(..), sourceState, play, pause, stop, rewind ) where import Control.Monad import Data.ObjectName import Data.StateVar import Data.Tensor import Foreign.Marshal.Array import Foreign.Marshal.Utils import Foreign.Ptr import Foreign.Storable import Sound.OpenAL.AL.ALboolean import Sound.OpenAL.AL.BasicTypes import Sound.OpenAL.AL.BufferInternal import Sound.OpenAL.AL.Listener import Sound.OpenAL.AL.PeekPoke import Sound.OpenAL.AL.QueryUtils import Sound.OpenAL.AL.SourceState import Sound.OpenAL.Constants #ifdef __HADDOCK__ import Sound.OpenAL.AL.Listener ( listenerGain ) import Sound.OpenAL.AL.Errors ( ALErrorCategory(..) ) #endif -------------------------------------------------------------------------------- -- | The abstract buffer type. newtype Source = Source ALuint deriving ( Eq, Ord, Show ) instance Storable Source where sizeOf ~(Source b) = sizeOf b alignment ~(Source b) = alignment b peek = peek1 Source . castPtr poke ptr (Source b) = poke1 (castPtr ptr) b instance ObjectName Source where genObjectNames n = allocaArray n $ \buf -> do alGenSources (fromIntegral n) buf peekArray n buf deleteObjectNames = withArraySizei alDeleteSources isObjectName = fmap unmarshalALboolean . alIsSource foreign import CALLCONV unsafe "alGenSources" alGenSources :: ALsizei -> Ptr Source -> IO () foreign import CALLCONV unsafe "alDeleteSources" alDeleteSources :: ALsizei -> Ptr Source -> IO () foreign import CALLCONV unsafe "alIsSource" alIsSource :: Source -> IO ALboolean -------------------------------------------------------------------------------- -- | 'sourcePosition' contains the current location of the source in the world -- coordinate system. Any 3-tuple of valid float values is allowed. -- Implementation behavior on encountering NaN and infinity is not defined. The -- initial position is ('Vertex3' 0 0 0). sourcePosition :: Source -> StateVar (Vertex3 ALfloat) sourcePosition = makeSourceStateVar dictVertex3ALfloat GetPosition -- | 'sourceVelocity' contains current velocity (speed and direction) of the -- source in the world coordinate system. Any 3-tuple of valid float values is -- allowed, and the initial velocity is ('Vector3' 0 0 0). 'sourceVelocity' does -- not affect 'sourcePosition'. OpenAL does not calculate the velocity from -- subsequent position updates, nor does it adjust the position over time based -- on the specified velocity. Any such calculation is left to the application. -- For the purposes of sound processing, position and velocity are independent -- parameters affecting different aspects of the sounds. -- -- 'sourceVelocity' is taken into account by the driver to synthesize the -- Doppler effect perceived by the listener for each source, based on the -- velocity of both source and listener, and the Doppler related parameters. sourceVelocity :: Source -> StateVar (Vector3 ALfloat) sourceVelocity = makeSourceStateVar dictVector3ALfloat GetVelocity -- | 'sourceGain' contains a scalar amplitude multiplier for the given source. -- The initial value 1 means that the sound is unattenuated. A 'sourceGain' -- value of 0.5 is equivalent to an attenuation of 6dB. The value zero equals -- silence (no output). Driver implementations are free to optimize this case -- and skip mixing and processing stages where applicable. The implementation is -- in charge of ensuring artifact-free (click-free) changes of gain values and -- is free to defer actual modification of the sound samples, within the limits -- of acceptable latencies. -- -- A 'sourceGain' larger than 1 (amplification) is permitted. However, the -- implementation is free to clamp the total gain (effective gain per source -- times listener gain) to 1 to prevent overflow. sourceGain :: Source -> StateVar Gain sourceGain = makeSourceStateVar dictALfloat GetGain -------------------------------------------------------------------------------- -- | The entity to which the source attributes 'sourcePosition', -- 'sourceVelocity' and 'direction' are to be interpreted. data SourceRelative = World | Listener deriving ( Eq, Ord, Show ) marshalSourceRelative :: SourceRelative -> Bool marshalSourceRelative = (== Listener) unmarshalSourceRelative :: Bool -> SourceRelative unmarshalSourceRelative x = if x then Listener else World -- | If 'sourceRelative' contains 'Listener', it indicates indicates that the -- values specified by 'sourcePosition', 'sourceVelocity' and 'direction' are to -- be interpreted relative to the listener position. The initial value is -- 'World', indicating that those source attributes are to be interpreted -- relative to the world, i.e. they are considered absolute. sourceRelative :: Source -> StateVar SourceRelative sourceRelative = makeSourceStateVar dictSourceRelative GetSourceRelative -------------------------------------------------------------------------------- -- | When first created, a source will be in the 'Undetermined' state. If a -- buffer is then attached using 'buffer', then the source will enter the -- 'Static' state. If the first buffer attached to a source is attached using -- 'queueBuffers', then the source will enter the 'Streaming' state. A source of -- either state will be reset to state 'Undetermined' by setting its 'buffer' to -- 'Nothing', and attaching any buffer to a streaming source will change the -- state to 'Static'. Attempting to queue a buffer on a static source will -- result in an 'ALInvalidOperation' error. data SourceType = Undetermined | Static | Streaming deriving ( Eq, Ord, Show ) unmarshalSourceType :: ALint -> SourceType unmarshalSourceType x | x == al_UNDETERMINED = Undetermined | x == al_STATIC = Static | x == al_STREAMING = Streaming | otherwise = error ("unmarshalSourceType: illegal value " ++ show x) -- | 'sourceType' indicates whether a source is ready to queue buffers, ready to -- use a static buffer, or is in an undetermined state where it can be used for -- either streaming or static playback. sourceType :: Source -> GettableStateVar SourceType sourceType = makeSourceGettableStateVar dictSourceType GetSourceType -------------------------------------------------------------------------------- -- | Specifies what should happen when the end of a buffer queue is reached. data LoopingMode = OneShot | Looping deriving ( Eq, Ord, Show ) marshalLoopingMode :: LoopingMode -> Bool marshalLoopingMode = (== Looping) unmarshalLoopingMode :: Bool -> LoopingMode unmarshalLoopingMode x = if x then Looping else OneShot -- | If 'loopingMode' contains 'Looping', it indicates that the source will not -- be in the 'Stopped' state once it reaches the end of last buffer in the -- buffer queue. Instead, the source will immediately promote to 'Initial' and -- 'Playing'. The initial value is 'OneShot'. 'loopingMode' can be changed on a -- source in any execution state. In particular, it can be changed on a -- 'Playing' source. loopingMode :: Source -> StateVar LoopingMode loopingMode = makeSourceStateVar dictLoopingMode GetLooping -------------------------------------------------------------------------------- -- | 'buffer' contains the current buffer object. Setting 'buffer' to 'Just' a -- buffer object makes it the head entry in the source\'s queue. Setting -- 'buffer'for a source in the 'Stopped' or 'Initial' state empties the entire -- queue, then appends the one buffer specified (or none at all if 'Nothing' -- was specified). -- -- For a source in the 'Playing' or 'Paused' state, setting 'buffer' will result -- in the 'ALInvalidOperation' error state being set. 'buffer' can be applied only -- to sources in the 'Initial' and 'Stopped' states. Specifying an invalid -- buffer name (either because the buffer name doesn\'t exist or because that -- buffer can\'t be attached to the specified source) will result in an -- 'ALInvalidValue' error while specifying an invalid source name results in an -- 'ALInvalidName' error. Setting 'buffer' to 'Nothing' is a legal way to release -- the current buffer queue on a source in the 'Initial' or 'Stopped' state, -- whether the source has just one entry (current buffer) or more. Setting -- 'buffer' to 'Nothing' still causes an 'ALInvalidOperation' for any source in -- the 'Playing' or 'Paused' state, consequently it cannot be used to mute or -- stop a source. The initial value is 'Nothing'. buffer :: Source -> StateVar (Maybe Buffer) buffer = makeSourceStateVar dictMaybeBuffer GetBuffer -------------------------------------------------------------------------------- -- | 'buffersQueued' contains the number of buffers in the queue of a given -- source. This includes those not yet played, the one currently playing, and -- the ones that have been played already. It will contain 0 if 'buffer' has -- been set to 'Nothing'. buffersQueued :: Source -> GettableStateVar ALint buffersQueued = makeSourceGettableStateVar dictALint GetBuffersQueued -- | 'buffersProcessed' contains the number of buffers that have been played -- by a given source. Indirectly, this gives the index of the buffer currently -- playing. It can be used to determine how much slots are needed for unqueuing -- them. On a source in the 'Stopped' state, all buffers are processed. On a -- source in the 'Initial' state, no buffers are processed, all buffers are -- pending. It will contain 0 if 'buffer' has been set to 'Nothing'. buffersProcessed :: Source -> GettableStateVar ALint buffersProcessed = makeSourceGettableStateVar dictALint GetBuffersProcessed -------------------------------------------------------------------------------- -- | 'gainBounds' contains two scalar amplitude thresholds between 0 and 1 -- (included): The minimum guaranteed gain for this source and the maximum gain -- permitted, with initial values 0 and 1, respectively At the end of the -- processing of various attenuation factors such as distance based attenuation -- and 'sourceGain', the effective gain calculated is compared to these values: -- -- If the effective gain is lower than the minimum gain, the minimum gain is -- applied. This happens before the 'listenerGain' is applied. If a zero minimum -- gain is set, then the effective gain will not be corrected. -- -- If the effective gain is higher than the maximum gain, the maximum gain is -- applied. This happens before the 'listenerGain' is applied. If the -- 'listenerGain' times the maximum gain still exceeds the maximum gain the -- implementation can handle, the implementation is free to clamp. If a zero -- maximum gain is set, then the source is effectively muted. The implementation -- is free to optimize for this situation, but no optimization is required or -- recommended as setting 'sourceGain' to zero is the proper way to mute a -- source. gainBounds :: Source -> StateVar (Gain, Gain) gainBounds source = pairStateVars (makeSourceStateVar dictALfloat GetMinGain source) (makeSourceStateVar dictALfloat GetMaxGain source) -------------------------------------------------------------------------------- -- | 'referenceDistance' is used for distance attenuation calculations based on -- inverse distance with rolloff. Depending on the distance model it will also -- act as a distance threshold below which gain is clamped. See -- "Sound.OpenAL.AL.Attenuation" for details. The initial value is 1. referenceDistance :: Source -> StateVar ALfloat referenceDistance = makeSourceStateVar dictALfloat GetReferenceDistance -- | 'rolloffFactor' is used for distance attenuation calculations based on -- inverse distance with rolloff. For distances smaller than 'maxDistance' (and, -- depending on the distance model, larger than 'referenceDistance'), this will -- scale the distance attenuation over the applicable range. See -- "Sound.OpenAL.AL.Attenuation" for details how the attenuation is computed as -- a function of the distance. The initial value is 1. -- -- In particular, 'rolloffFactor' can be set to zero for those sources that are -- supposed to be exempt from distance attenuation. The implementation is -- encouraged to optimize this case, bypassing distance attenuation calculation -- entirely on a persource basis. rolloffFactor :: Source -> StateVar ALfloat rolloffFactor = makeSourceStateVar dictALfloat GetRolloffFactor -- | 'maxDistance' is used for distance attenuation calculations based on -- inverse distance with rolloff, if the inverse clamped distance model is -- used. In this case, distances greater than 'maxDistance' will be clamped to -- 'maxDistance'. 'maxDistance' based clamping is applied before minimum gain -- clamping (see 'gainBounds'), so if the effective gain at 'maxDistance' is -- larger than the minimum gain, the minimum gain will have no effect. No -- culling is supported. The initial value is the largest representable -- 'ALfloat'. maxDistance :: Source -> StateVar ALfloat maxDistance = makeSourceStateVar dictALfloat GetMaxDistance -------------------------------------------------------------------------------- -- | 'pitch' contains the desired pitch shift, where 1 (the initial value) -- equals identity. Each reduction by 50 percent equals a pitch shift of -12 -- semitones (one octave reduction). Each doubling equals a pitch shift of 12 -- semitones (one octave increase). Zero is not a legal value. Implementations -- may clamp the actual output pitch range to any values subject to the -- implementation's own limits. pitch :: Source -> StateVar ALfloat pitch = makeSourceStateVar dictALfloat GetPitch -------------------------------------------------------------------------------- -- $DirectionAndCone -- Each source can be directional, depending on the settings for 'coneAngles'. -- There are three zones defined: the inner cone, the outside zone, and the -- transitional zone in between. The angle-dependent gain for a directional -- source is constant inside the inner cone, and changes over the transitional -- zone to the value specified outside the outer cone. 'sourceGain' is applied -- for the inner cone, with an application selectable 'coneOuterGain' factor to -- define the gain in the outer zone. In the transitional zone -- implementation-dependent interpolation between 'sourceGain' and 'sourceGain' -- times 'coneOuterGain' is applied. -------------------------------------------------------------------------------- -- | If 'direction' does not contain the zero vector ('Vector3' 0 0 0), the -- source is directional. The sound emission is presumed to be symmetric around -- the direction vector (cylinder symmetry). Sources are not oriented in full 3 -- degrees of freedom, only two angles are effectively needed. -- -- The zero vector is the initial value, indicating that a source is not -- directional. Specifying a non-zero vector will make the source directional. -- Specifying a zero vector for a directional source will effectively mark it as -- nondirectional. direction :: Source -> StateVar (Vector3 ALfloat) direction = makeSourceStateVar dictVector3ALfloat GetDirection -- | 'coneAngles' contains the inner and outer angles of the sound cone, in -- degrees. The default of 360 for the inner cone angle means that it covers the -- entire world, which is equivalent to an omni-directional source. The default -- of 360 for the outer cone angle means that it covers the entire world. If the -- inner angle is also 360, then the zone for angle-dependent attenuation is -- zero. coneAngles :: Source -> StateVar (ALfloat, ALfloat) coneAngles source = pairStateVars (makeSourceStateVar dictALfloat GetConeInnerAngle source) (makeSourceStateVar dictALfloat GetConeOuterAngle source) -- | 'coneOuterGain' contains the factor with which 'sourceGain' is multiplied -- to determine the effective gain outside the cone defined by the outer angle. -- The effective gain applied outside the outer cone is 'sourceGain' times -- 'coneOuterGain'. Changing 'sourceGain' affects all directions, i.e. the -- source is attenuated in all directions, for any position of the listener. The -- application has to change 'coneOuterGain' as well if a different behavior is -- desired. coneOuterGain :: Source -> StateVar Gain coneOuterGain = makeSourceStateVar dictALfloat GetConeOuterGain -------------------------------------------------------------------------------- -- | 'secOffset' contains the playback position, expressed in seconds (the value -- will loop back to zero for looping sources). -- -- When setting 'secOffset' on a source which is already playing, the playback -- will jump to the new offset unless the new offset is out of range, in which -- case an 'ALInvalidValue' error is set. If the source is not playing, then the -- offset will be applied on the next 'play' call. -- -- The position is relative to the beginning of all the queued buffers for the -- source, and any queued buffers traversed by a set call will be marked as -- processed. -- -- This value is based on byte position, so a pitch-shifted source will have an -- exaggerated playback speed. For example, you can be 0.5 seconds into a buffer -- having taken only 0.25 seconds to get there if the pitch is set to 2. secOffset :: Source -> StateVar ALfloat secOffset = makeSourceStateVar dictALfloat GetSecOffset -- | 'sampleOffset' contains the playback position, expressed in samples (the -- value will loop back to zero for looping sources). For a compressed format, -- this value will represent an exact offset within the uncompressed data. -- -- When setting 'sampleOffset' on a source which is already playing, the -- playback will jump to the new offset unless the new offset is out of range, -- in which case an 'ALInvalidValue' error is set. If the source is not playing, -- then the offset will be applied on the next 'play' call. A 'stop', 'rewind', -- or a second 'play' call will reset the offset to the beginning of the buffer. -- -- The position is relative to the beginning of all the queued buffers for the -- source, and any queued buffers traversed by a set call will be marked as -- processed. sampleOffset :: Source -> StateVar ALint sampleOffset = makeSourceStateVar dictALint GetSampleOffset -- | 'byteOffset' contains the playback position, expressed in bytes (the value -- will loop back to zero for looping sources). For a compressed format, this -- value may represent an approximate offset within the compressed data buffer. -- -- When setting 'byteOffset' on a source which is already playing, the playback -- will jump to the new offset unless the new offset is out of range, in which -- case an 'ALInvalidValue' error is set. If the source is not playing, then the -- offset will be applied on the next 'play' call. A 'stop', 'rewind', or a -- second 'play' call will reset the offset to the beginning of the buffer. -- -- The position is relative to the beginning of all the queued buffers for the -- source, and any queued buffers traversed by a set call will be marked as -- processed. byteOffset :: Source -> StateVar ALint byteOffset = makeSourceStateVar dictALint GetByteOffset -------------------------------------------------------------------------------- pairStateVars :: StateVar a -> StateVar b -> StateVar (a,b) pairStateVars var1 var2 = makeStateVar (liftM2 (,) (get var1) (get var2)) (\(val1,val2) -> do var1 $= val1; var2 $= val2) data Dictionary a b c = Dictionary { alGetter :: Source -> ALenum -> Ptr b -> IO (), alSetter :: Source -> ALenum -> Ptr b -> IO (), size :: Int, peekSize :: Ptr b -> IO a, marshal :: a -> c } dictALint :: Dictionary ALint ALint ALint dictALint = Dictionary { alGetter = alGetSourceiv, alSetter = alSourceiv, size = 1, peekSize = peek1 id, marshal = id } dictALfloat :: Dictionary ALfloat ALfloat ALfloat dictALfloat = Dictionary { alGetter = alGetSourcefv, alSetter = alSourcefv, size = 1, peekSize = peek1 id, marshal = id } dictSourceRelative :: Dictionary SourceRelative ALint ALint dictSourceRelative = Dictionary { alGetter = alGetSourceiv, alSetter = alSourceiv, size = 1, peekSize = peek1 (unmarshalSourceRelative . unmarshalALboolean . fromIntegral), marshal = fromIntegral . marshalALboolean . marshalSourceRelative } dictSourceType :: Dictionary SourceType ALint ALint dictSourceType = Dictionary { alGetter = alGetSourceiv, alSetter = undefined, size = 1, peekSize = peek1 unmarshalSourceType, marshal = undefined } dictLoopingMode :: Dictionary LoopingMode ALint ALint dictLoopingMode = Dictionary { alGetter = alGetSourceiv, alSetter = alSourceiv, size = 1, peekSize = peek1 (unmarshalLoopingMode . unmarshalALboolean . fromIntegral), marshal = fromIntegral . marshalALboolean . marshalLoopingMode } dictSourceState :: Dictionary SourceState ALint ALint dictSourceState = Dictionary { alGetter = alGetSourceiv, alSetter = undefined, size = 1, peekSize = peek1 unmarshalSourceState, marshal = undefined } dictVertex3ALfloat :: Dictionary (Vertex3 ALfloat) ALfloat (Vertex3 ALfloat) dictVertex3ALfloat = Dictionary { alGetter = alGetSourcefv, alSetter = alSourcefv, size = 3, peekSize = peek3 Vertex3, marshal = id } dictVector3ALfloat :: Dictionary (Vector3 ALfloat) ALfloat (Vector3 ALfloat) dictVector3ALfloat = Dictionary { alGetter = alGetSourcefv, alSetter = alSourcefv, size = 3, peekSize = peek3 Vector3, marshal = id } dictMaybeBuffer :: Dictionary (Maybe Buffer) ALint ALint dictMaybeBuffer = Dictionary { alGetter = alGetSourceiv, alSetter = alSourceiv, size = 1, peekSize = peek1 (unmarshalBuffer . fromIntegral), marshal = fromIntegral . marshalBuffer } makeGetter :: Storable b => Dictionary a b c -> GetPName -> Source -> IO a makeGetter dict name source = allocaArray (size dict) $ \buf -> do alGetter dict source (marshalGetPName name) buf peekSize dict buf makeSetter :: Storable c => Dictionary a b c -> GetPName -> Source -> a -> IO () makeSetter dict name source value = with (marshal dict value) $ alSetter dict source (marshalGetPName name) . castPtr makeSourceStateVar :: (Storable b, Storable c) => Dictionary a b c -> GetPName -> Source -> StateVar a makeSourceStateVar dict name source = makeStateVar (makeGetter dict name source) (makeSetter dict name source) makeSourceGettableStateVar :: (Storable b, Storable c) => Dictionary a b c -> GetPName -> Source -> GettableStateVar a makeSourceGettableStateVar dict name source = makeGettableStateVar (makeGetter dict name source) -------------------------------------------------------------------------------- foreign import CALLCONV unsafe "alGetSourcefv" alGetSourcefv :: Source -> ALenum -> Ptr ALfloat -> IO () foreign import CALLCONV unsafe "alSourcefv" alSourcefv :: Source -> ALenum -> Ptr ALfloat -> IO () foreign import CALLCONV unsafe "alGetSourceiv" alGetSourceiv :: Source -> ALenum -> Ptr ALint -> IO () -- Note: Older OpenAL implementations have no alSourceiv, so we emulate it here. alSourceiv :: Source -> ALenum -> Ptr ALint -> IO () alSourceiv source n buf = peek buf >>= alSourcei source n foreign import CALLCONV unsafe "alSourcei" alSourcei :: Source -> ALenum -> ALint -> IO () -------------------------------------------------------------------------------- -- $QueuingBuffersWithASource -- OpenAL does not specify a built-in streaming mechanism. There is no mechanism -- to stream data into a buffer object. Instead, the API has a more flexible and -- versatile mechanism to queue buffers for sources. There are many ways to use -- this feature, with streaming being only one of them. -- -- Streaming is replaced by queuing static buffers. This effectively moves any -- multi-buffer caching into the application and allows the application to -- select how many buffers it wants to use, the size of the buffers, and whether -- these are re-used in cycle, pooled, or thrown away. -- -- Looping (over a finite number of repetitions) can be implemented by -- explicitly repeating buffers in the queue. Infinite loops can (theoretically) -- be accomplished by sufficiently large repetition counters. If only a single -- buffer is supposed to be repeated infinitely, using the respective source -- attribute 'loopingMode' is recommended. -- -- Loop Points for restricted looping inside a buffer can in many cases be -- replaced by splitting the sample into several buffers and queuing the sample -- fragments (including repetitions) accordingly. -- -- Buffers can be queued, unqueued after they have been used, and either be -- deleted, or refilled and queued again. Splitting large samples over several -- buffers maintained in a queue has distinct advantages over approaches that -- require explicit management of samples and sample indices. -------------------------------------------------------------------------------- -- | The application can queue up one or multiple buffer names using -- 'queueBuffers'. The buffers will be queued in the sequence in which they -- appear in the list. -- -- This command is legal on a source in any playback state (to allow for -- streaming, queuing has to be possible on a 'Playing' source). -- -- All buffers in a queue must have the same format and attributes. An attempt -- to mix formats or other buffer attributes will result in a failure and an -- 'ALInvalidValue' error will be thrown. If the queue operation fails, the source -- queue will remain unchanged (even if some of the buffers could have been -- queued). queueBuffers :: Source -> [Buffer] -> IO () queueBuffers = withArraySizei . alSourceQueueBuffers withArraySizei :: Storable a => (ALsizei -> Ptr a -> IO ()) -> [a] -> IO () withArraySizei f xs = withArrayLen xs $ f . fromIntegral foreign import CALLCONV unsafe "alSourceQueueBuffers" alSourceQueueBuffers :: Source -> ALsizei -> Ptr Buffer -> IO () -------------------------------------------------------------------------------- -- | Once a queue entry for a buffer has been appended to a queue and is pending -- processing, it should not be changed. Removal of a given queue entry is not -- possible unless either the source is stopped (in which case then entire queue -- is considered processed), or if the queue entry has already been processed -- ('Playing' or 'Paused' source). A playing source will enter the 'Stopped' -- state if it completes playback of the last buffer in its queue (the same -- behavior as when a single buffer has been attached to a source and has -- finished playback). -- -- The 'unqueueBuffers' command removes a number of buffers entries that have -- finished processing, in the order of appearance, from the queue. The -- operation will fail with an 'ALInvalidValue' error if more buffers are -- requested than available, leaving the destination arguments unchanged. unqueueBuffers :: Source -> [Buffer] -> IO () unqueueBuffers = withArraySizei . alSourceUnqueueBuffers foreign import CALLCONV unsafe "alSourceUnqueueBuffers" alSourceUnqueueBuffers :: Source -> ALsizei -> Ptr Buffer -> IO () -------------------------------------------------------------------------------- -- $ManagingSourceExecution -- The execution state of a source can be queried. OpenAL provides a set of -- functions that initiate state transitions causing sources to start and stop -- execution. -------------------------------------------------------------------------------- -- | Contains the current execution state of the given source. The initial state -- of any source is 'Initial'. -- -- Note that the 'Initial' state is not necessarily identical to the initial -- state in which a source is created, because the other source attributes are -- not automatically reset to their initial values. 'Initial' merely indicates -- that the source can be executed using the 'play' command. A 'Stopped' or -- 'Initial' source can be reset into the default configuration by using a -- sequence of source commands as necessary. As the application has to specify -- all relevant state anyway to create a useful source configuration, no reset -- command is provided. sourceState :: Source -> GettableStateVar SourceState sourceState source = makeGettableStateVar (makeGetter dictSourceState GetSourceState source) -------------------------------------------------------------------------------- -- | 'play' applied to an 'Initial' source will promote the source to 'Playing', -- thus the data found in the buffer will be fed into the processing, starting -- at the beginning. 'play' applied to a 'Playing' source will restart the -- source from the beginning. It will not affect the configuration, and will -- leave the source in 'Playing' state, but reset the sampling offset to the -- beginning. 'play' applied to a 'Paused' source will resume processing using -- the source state as preserved at the 'pause' operation. 'play' applied to a -- 'Stopped' source will propagate it to 'Initial' then to 'Playing' -- immediately. play :: [Source] -> IO () play = withArraySizei alSourcePlayv foreign import CALLCONV unsafe "alSourcePlayv" alSourcePlayv :: ALsizei -> Ptr Source -> IO () -- | 'pause' applied to an 'Initial' source is a legal NOP. 'pause' applied to a -- 'Playing' source will change its state to 'Paused'. The source is exempt from -- processing, its current state is preserved. 'pause' applied to a 'Paused' -- source is a legal NOP. 'pause' applied to a 'Stopped' source is a legal NOP. pause :: [Source] -> IO () pause = withArraySizei alSourcePausev foreign import CALLCONV unsafe "alSourcePausev" alSourcePausev :: ALsizei -> Ptr Source -> IO () -- | 'stop' applied to an 'Initial' source is a legal NOP. 'stop' applied to a -- 'Playing' source will change its state to 'Stopped'. The source is exempt -- from processing, its current state is preserved. 'stop' applied to a 'Paused' -- source will change its state to 'Stopped', with the same consequences as on a -- 'Playing' source. 'stop' applied to a 'Stopped' source is a legal NOP. stop :: [Source] -> IO () stop = withArraySizei alSourceStopv foreign import CALLCONV unsafe "alSourceStopv" alSourceStopv :: ALsizei -> Ptr Source -> IO () -- | 'rewind' applied to an 'Initial' source is a legal NOP. 'rewind' applied to -- a 'Playing' source will change its state to 'Stopped' then 'Initial'. The -- source is exempt from processing: its current state is preserved, with the -- exception of the sampling offset, which is reset to the beginning. 'rewind' -- applied to a 'Paused' source will change its state to 'Initial', with the -- same consequences as on a 'Playing' source. 'rewind' applied to an 'Stopped' -- source promotes the source to 'Initial', resetting the sampling offset to the -- beginning. rewind :: [Source] -> IO () rewind = withArraySizei alSourceRewindv foreign import CALLCONV unsafe "alSourceRewindv" alSourceRewindv :: ALsizei -> Ptr Source -> IO () OpenAL-1.4.0.2/Sound/OpenAL/AL/BasicTypes.hs0000644000000000000000000000420212107326776014775 0ustar -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL.BasicTypes -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- This module corresponds to section 2.2 (Primitive Types) of the OpenAL -- Specification and Reference (version 1.1). -- -------------------------------------------------------------------------------- module Sound.OpenAL.AL.BasicTypes ( -- * Primitive Types -- $PrimitiveTypes -- * Floating-Point Computation -- $FloatingPointComputation ALboolean, ALchar, ALbyte, ALubyte, ALshort, ALushort, ALint, ALuint, ALsizei, ALenum, ALfloat, ALdouble ) where import Sound.OpenAL.Config -------------------------------------------------------------------------------- -- $PrimitiveTypes -- As OpenAL is meant to allow for seamless integration with OpenGL code if -- needed, the OpenAL library primitive (scalar) data types mimic the OpenGL -- data types. Guaranteed minimum sizes are stated for OpenGL data types, but -- the actual choice of C data type is left to the implementation. All -- implementations on a given binary architecture, however, must use a common -- definition of these data types. -------------------------------------------------------------------------------- -- $FloatingPointComputation -- Any representable floating-point value is legal as input to an OpenAL command -- that requires floating point data. The result of providing a value that is -- not a floating point number to such a command is unspecified, but must not -- lead to OpenAL being interrupted or terminated. In IEEE arithmetic, for -- example, providing a negative zero or a denormalized number to an OpenAL -- command yields predictable results, while providing a NaN or infinity yields -- unspecified results. Some calculations require division. In such cases -- (including implied divisions required by vector normalizations), a division -- by zero produces an unspecified result but must not lead to OpenAL -- interruption or termination. OpenAL-1.4.0.2/Sound/OpenAL/AL/QueryUtils.hs0000644000000000000000000000674612107326776015074 0ustar -- #hide -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.AL.QueryUtils -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file libraries/OpenGL/LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- This is a purely internal module with utilities to query OpenAL state. -- -------------------------------------------------------------------------------- module Sound.OpenAL.AL.QueryUtils ( GetPName(..), marshalGetPName, StringName(..), getString ) where import Foreign.Ptr ( Ptr ) import Sound.OpenAL.AL.BasicTypes ( ALchar, ALenum ) import Sound.OpenAL.AL.String ( peekALString ) import Sound.OpenAL.Constants ( al_DISTANCE_MODEL, al_DOPPLER_FACTOR, al_SPEED_OF_SOUND, al_POSITION, al_VELOCITY, al_GAIN, al_ORIENTATION, al_SOURCE_RELATIVE, al_SOURCE_TYPE, al_LOOPING, al_BUFFER, al_BUFFERS_QUEUED, al_BUFFERS_PROCESSED, al_MIN_GAIN, al_MAX_GAIN, al_REFERENCE_DISTANCE, al_ROLLOFF_FACTOR, al_MAX_DISTANCE, al_PITCH, al_DIRECTION, al_CONE_INNER_ANGLE, al_CONE_OUTER_ANGLE, al_CONE_OUTER_GAIN, al_SEC_OFFSET, al_SAMPLE_OFFSET, al_BYTE_OFFSET, al_SOURCE_STATE, al_VENDOR, al_RENDERER, al_VERSION, al_EXTENSIONS ) -------------------------------------------------------------------------------- data GetPName = GetDistanceModel | GetDopplerFactor | GetSpeedOfSound | GetPosition | GetVelocity | GetGain | GetOrientation | GetSourceRelative | GetSourceType | GetLooping | GetBuffer | GetBuffersQueued | GetBuffersProcessed | GetMinGain | GetMaxGain | GetReferenceDistance | GetRolloffFactor | GetMaxDistance | GetPitch | GetDirection | GetConeInnerAngle | GetConeOuterAngle | GetConeOuterGain | GetSecOffset | GetSampleOffset | GetByteOffset | GetSourceState marshalGetPName :: GetPName -> ALenum marshalGetPName x = case x of GetDistanceModel -> al_DISTANCE_MODEL GetDopplerFactor -> al_DOPPLER_FACTOR GetSpeedOfSound -> al_SPEED_OF_SOUND GetPosition -> al_POSITION GetVelocity -> al_VELOCITY GetGain -> al_GAIN GetOrientation -> al_ORIENTATION GetSourceRelative -> al_SOURCE_RELATIVE GetSourceType -> al_SOURCE_TYPE GetLooping -> al_LOOPING GetBuffer -> al_BUFFER GetBuffersQueued -> al_BUFFERS_QUEUED GetBuffersProcessed -> al_BUFFERS_PROCESSED GetMinGain -> al_MIN_GAIN GetMaxGain -> al_MAX_GAIN GetReferenceDistance -> al_REFERENCE_DISTANCE GetRolloffFactor -> al_ROLLOFF_FACTOR GetMaxDistance -> al_MAX_DISTANCE GetPitch -> al_PITCH GetDirection -> al_DIRECTION GetConeInnerAngle -> al_CONE_INNER_ANGLE GetConeOuterAngle -> al_CONE_OUTER_ANGLE GetConeOuterGain -> al_CONE_OUTER_GAIN GetSecOffset -> al_SEC_OFFSET GetSampleOffset -> al_SAMPLE_OFFSET GetByteOffset -> al_BYTE_OFFSET GetSourceState -> al_SOURCE_STATE -------------------------------------------------------------------------------- data StringName = Vendor | Renderer | Version | Extensions | ALErrorCategory ALenum marshalStringName :: StringName -> ALenum marshalStringName x = case x of Vendor -> al_VENDOR Renderer -> al_RENDERER Version -> al_VERSION Extensions -> al_EXTENSIONS ALErrorCategory e -> e getString :: StringName -> IO String getString n = alGetString (marshalStringName n) >>= peekALString foreign import CALLCONV unsafe "alGetString" alGetString :: ALenum -> IO (Ptr ALchar) OpenAL-1.4.0.2/Sound/OpenAL/ALC/0000755000000000000000000000000012107327541012467 5ustar OpenAL-1.4.0.2/Sound/OpenAL/ALC/Capture.hs0000644000000000000000000001241112107326776014436 0ustar -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.ALC.Capture -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- This module corresponds to section 6.4.2. (Capture) of the OpenAL -- Specification and Reference (version 1.1). -- -------------------------------------------------------------------------------- module Sound.OpenAL.ALC.Capture ( NumSamples, captureOpenDevice, captureStart, captureNumSamples, captureSamples, captureStop, captureCloseDevice, captureDefaultDeviceSpecifier, captureDeviceSpecifier, allCaptureDeviceSpecifiers ) where import Data.StateVar import Foreign.Ptr ( Ptr, nullPtr, FunPtr ) import Sound.OpenAL.AL.Buffer ( Format ) import Sound.OpenAL.AL.Format ( marshalFormat ) import Sound.OpenAL.ALC.ALCboolean ( unmarshalALCboolean ) import Sound.OpenAL.ALC.BasicTypes ( ALCchar, ALCuint, ALCenum, ALCsizei, ALCboolean ) import Sound.OpenAL.ALC.Context ( Frequency ) import Sound.OpenAL.ALC.Device ( Device ) import Sound.OpenAL.ALC.Extensions ( alcProcAddress ) import Sound.OpenAL.ALC.QueryUtils ( IntQuery(..), getInteger ) import Sound.OpenAL.ALC.QueryUtils ( StringQuery(..), getString, getStringRaw, alcIsExtensionPresent ) import Sound.OpenAL.ALC.String ( withALCString, peekALCStrings ) import Sound.OpenAL.Config ( ALCdevice(..), marshalDevice, unmarshalDevice ) -------------------------------------------------------------------------------- type NumSamples = ALCsizei -------------------------------------------------------------------------------- type Invoker a = FunPtr a -> a getCaptureFunc :: String -> IO (FunPtr a) getCaptureFunc = get . alcProcAddress Nothing -------------------------------------------------------------------------------- captureOpenDevice :: Maybe String -> Frequency -> Format -> NumSamples -> IO (Maybe Device) captureOpenDevice maybeDeviceSpec frequency format size = do funPtr <- getCaptureFunc "alcCaptureOpenDevice" let open deviceSpec = invokeCaptureOpenDevice funPtr deviceSpec (round frequency) (fromIntegral (marshalFormat format)) size fmap unmarshalDevice $ (maybe (open nullPtr) -- use preferred device (flip withALCString open) maybeDeviceSpec) foreign import CALLCONV unsafe "dynamic" invokeCaptureOpenDevice :: Invoker (Ptr ALCchar -> ALCuint -> ALCenum -> ALCsizei -> IO ALCdevice) -------------------------------------------------------------------------------- captureStart :: Device -> IO () captureStart = captureStartStop "alcCaptureStart" captureStartStop :: String -> Device -> IO () captureStartStop funName device = do funPtr <- getCaptureFunc funName invokeCaptureStartStop funPtr (marshalDevice device) foreign import CALLCONV unsafe "dynamic" invokeCaptureStartStop :: Invoker (ALCdevice -> IO ()) -------------------------------------------------------------------------------- captureNumSamples :: Device -> GettableStateVar NumSamples captureNumSamples device = makeGettableStateVar $ fmap fromIntegral (getInteger (Just device) CaptureSamples) -------------------------------------------------------------------------------- captureSamples :: Device -> Ptr a -> NumSamples -> IO () captureSamples device buf n = do funPtr <- getCaptureFunc "alcCaptureSamples" invokeCaptureSamples funPtr (marshalDevice device) buf n foreign import CALLCONV unsafe "dynamic" invokeCaptureSamples :: Invoker (ALCdevice -> Ptr a -> NumSamples -> IO ()) -------------------------------------------------------------------------------- captureStop :: Device -> IO () captureStop = captureStartStop "alcCaptureStop" -------------------------------------------------------------------------------- captureCloseDevice :: Device -> IO Bool captureCloseDevice device = do funPtr <- getCaptureFunc "alcCaptureCloseDevice" fmap unmarshalALCboolean . invokeCaptureCloseDevice funPtr . marshalDevice $ device foreign import CALLCONV unsafe "dynamic" invokeCaptureCloseDevice :: Invoker (ALCdevice -> IO ALCboolean) -------------------------------------------------------------------------------- -- | Contains the name of the default capture device. captureDefaultDeviceSpecifier :: GettableStateVar String captureDefaultDeviceSpecifier = makeGettableStateVar $ getString Nothing CaptureDefaultDeviceSpecifier -------------------------------------------------------------------------------- -- | Contains the specifier string for the given capture device. captureDeviceSpecifier :: Device -> GettableStateVar String captureDeviceSpecifier device = makeGettableStateVar $ getString (Just device) CaptureDeviceSpecifier -------------------------------------------------------------------------------- -- | Contains a list of specifiers for all available capture devices. allCaptureDeviceSpecifiers :: GettableStateVar [String] allCaptureDeviceSpecifiers = makeGettableStateVar $ do enumExtPresent <- get (alcIsExtensionPresent Nothing "ALC_ENUMERATION_EXT") if enumExtPresent then peekALCStrings =<< getStringRaw Nothing CaptureDeviceSpecifier else fmap (\s -> [s]) $ get captureDefaultDeviceSpecifier OpenAL-1.4.0.2/Sound/OpenAL/ALC/ALCboolean.hs0000644000000000000000000000167012107326776014777 0ustar -- #hide -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.ALC.ALCboolean -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- This is a purely internal module for (un-)marshaling ALCboolean. -- -------------------------------------------------------------------------------- module Sound.OpenAL.ALC.ALCboolean ( marshalALCboolean, unmarshalALCboolean ) where import Sound.OpenAL.ALC.BasicTypes ( ALCboolean ) import Sound.OpenAL.Constants ( alc_FALSE, alc_TRUE ) -------------------------------------------------------------------------------- marshalALCboolean :: Bool -> ALCboolean marshalALCboolean False = alc_FALSE marshalALCboolean True = alc_TRUE unmarshalALCboolean :: ALCboolean -> Bool unmarshalALCboolean = (/= alc_FALSE) OpenAL-1.4.0.2/Sound/OpenAL/ALC/Device.hs0000644000000000000000000002331112107326776014233 0ustar -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.ALC.Device -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- This module corresponds to section 6.1 (Managing Devices) of the OpenAL -- Specification and Reference (version 1.1). -- -- ALC introduces the notion of a device. A device can be, depending on the -- implementation, a hardware device, or a daemon\/OS service\/actual -- server. This mechanism also permits different drivers (and hardware) to -- coexist within the same system, as well as allowing several applications to -- share system resources for audio, including a single hardware output -- device. The details are left to the implementation, which has to map the -- available backends to unique device specifiers. -- -------------------------------------------------------------------------------- module Sound.OpenAL.ALC.Device ( Device, openDevice, closeDevice, defaultDeviceSpecifier, deviceSpecifier, allDeviceSpecifiers ) where import Data.StateVar import Foreign.Ptr ( Ptr, nullPtr ) import Foreign.Marshal.Utils ( maybePeek ) import Sound.OpenAL.ALC.BasicTypes ( ALCchar ) import Sound.OpenAL.ALC.QueryUtils ( StringQuery(..), getString, getStringRaw, alcIsExtensionPresent ) import Sound.OpenAL.ALC.String ( withALCString, peekALCString, peekALCStrings ) import Sound.OpenAL.Config ( Device, ALCdevice(..), unmarshalDevice, closeDevice ) -------------------------------------------------------------------------------- -- | 'openDevice' allows the application (i.e. the client program) to connect to -- a device (i.e. the server). If the function returns 'Nothing', then no sound -- driver\/device has been found. The argument to 'openDevice' specifies a -- certain device or device configuration. If it is 'Nothing', the -- implementation will provide an implementation specific default, see -- 'defaultDeviceSpecifier'. Otherwise it is 'Just' an implementation-dependent -- string. You can use 'allDeviceSpecifiers' to get a list of the known OpenAL -- devices. -- -- /Notes for Windows:/ There are 3 possible device strings, each having a -- deprecated equivalent for legacy applications only: -- -- * @\"Generic Hardware\"@ (legacy string: @\"DirectSound3D\"@) -- -- * @\"Generic Software\"@ (legacy string: @\"DirectSound\"@) -- -- * @\"Generic Software Fallback\"@ (legacy string: @\"MMSYSTEM\"@) -- -- /Notes for Linux\/\*nix:/ If an @.openalrc@ file is present in the user\'s -- home directory, it is loaded first, otherwise @\/etc\/openalrc@ is tried. -- The bindings (if any) of @devices@, @direction@, @sampling-rate@, and -- @speaker-num@ (see below) after loading one of these files take precedence -- over any bindings done via the argument to 'openDevice'. -- -- The syntax of these files is lisp-based and a sequence of expressions, where -- an expression is one the following: -- -- * A boolean value of the form @\#f@ or @\#t@, which evaluate to /false/ and -- /true/, respectively. -- -- * An non-negative integer value, i.e. a sequence of decimal digits, -- evaluating to itself. -- -- * A (signed) floating point value, as recoginzed by C\'s @atof()@, evaluating -- to itself. -- -- * A pointer value of the form @\#p/num/@, where /num/ can be an octal, -- decimal or hexadecimal value, as recoginzed by C\`s @strtol()@, evaluating -- to itself. This kind of expression is currently unused. -- -- * A string, i.e. a sequence of printable\/whitespace characters between -- double quotes, evaluating to itself. -- -- * A symbol, i.e. a sequence of almost all characters which don\'t form a -- simple expression like the ones mentioned below, e.g. @foo@, @bar1@, @3baz@, -- ... The symbol evaluates to the value currently bound to it. -- -- * A function application of the form @(/symbol/ /expression/...)@. The -- function bound to the symbol is applied to the evaluated arguments. -- -- * A quotation of the form @(quote /expression/)@ or @\'/expression/@, -- evaluating to the unevaluated /expression/ itself. -- -- * A definition of the form @(define /symbol/ /expression/)@, binding /symbol/ -- to the value of /expression/. The whole expression evaluates to the value of -- /expression/, too. -- -- * A conjunction of boolean expressions of the form @(and /expression/...)@. -- Each /expression/ is evaluated in turn, and if one of them evaluates to -- /false/, the value of the whole expression is /false/. Otherwise the value is -- /true/. -- -- * An extension loading mechanism of the form @(load-extension -- /libraryName/)@, where /libraryName/ has to evaluate to a string. This tries -- to load the dynamic library with up to 3 special entry points: -- @alExtension_03282000@ (pointing to a mandatory NULL-terminated sequence of -- pairs of pointers to names and extension functions), @alExtInit_03282000@ (an -- optional initialization function), and @alExtFini_03282000@ (an optional -- cleanup function). If the extension could be loaded successfully, the whole -- expression evaluates to /true/, otherwise to /false/. -- -- Some symbols have a special meaning for OpenAL: -- -- [@devices@] Has the form @(/devspec/...)@, where /devspec/ is either a -- symbol\/string specifying a device or @(/device/ /device-param/...)@, -- specifying a device with additional parameters. These optional device -- parameters are stored in a variable @device-params@, but are currently -- unused. The first device which can successfully opened is used. -- -- [@direction@] Type string or symbol: @\"read\"@ specifies that the device -- should be an input device, everything else means output device (default). -- -- [@sampling-rate@] Type integer or float: Specifies the internal mixing -- frequency, default is 44.1kHz. -- -- [@speaker-num@] Type integer or float: Specifies the number of speakers, -- which can be 1, 2 (default), or 4. -- -- [@alsa-device@] Type string, @alsa@ backend only: Specifies both -- @alsa-out-device@ and @alsa-in-device@, default @\"plughw:0,0\"@. -- -- [@alsa-out-device@] Type string, @alsa@ backend only: Specifies the ALSA -- output device, defaults to the value of @alsa-device@. -- -- [@alsa-in-device@] Type string, @alsa@ backend only: Specifies the ALSA -- input device, defaults to the value of @alsa-device@. -- -- [@native-in-device@] Type string, @native@ backend on IRIX only. -- -- [@native-out-device@] Type string, @native@ backend on IRIX only. -- -- [@native-rear-out-device@] Type string, @native@ backend on IRIX only. -- -- [@native-use-select@] Type boolean, @native@ backend on Linux only: If @\#t@, -- wait up to 0.8sec for the device to become ready for writing. If @\#f@, just -- try to write and hope it won\'t hang forever. The latter might be necessary -- for some drivers which don\'t implement @select()@ , like some Aureal -- drivers. -- -- [@lin-dsp-path@] Type string, @native@ backend on Linux only: Path to DSP -- device for writing, tried before @\/dev\/sound\/dsp@ and @\/dev\/sound@ if -- set. -- -- [@lin-dsp-read-path@] Type string, @native@ backend on Linux only: Path to -- DSP device for reading, tried before @\/dev\/sound\/dsp@ and @\/dev\/sound@ -- if set. Defaults to the value of @lin-dsp-path@. -- -- [@native-backend-debug@] Type boolean, @native@ backend on Darwin only: If -- set to @\#f@, be a bit verbose on stderr about what\'s going on in the -- backend. -- -- [@source-rolloff-factor@] Type integer or float: Value of the initial rolloff -- factor for sources, default is @1.0@. -- -- [@listener-position@] List of 3 integers or floats: Value of the initial -- listener position, default is @(0 0 0)@. -- -- [@listener-velocity@] List of 3 integers or floats: Value of the initial -- listener velocity, default is @(0 0 0)@. -- -- [@listener-orientation@] List of 6 integers or floats: Value of the initial -- listener orientation (at\/up), default is @(0 0 -1 0 1 0)@. -- -- The string given to 'openDevice' has to be of the form @\'((/symbol/ -- /expression/) ...)@, which means basically a sequence of @define@ -- expressions. Example: -- -- @ -- \"\'((sampling-rate 8000) (native-backend-debug \#f))\" -- @ -- -- /Note:/ The information above has been reverse-engineered from the OpenAL SI -- and could be inaccurate. Any corrections and\/or additions are highly -- welcome. openDevice :: Maybe String -> IO (Maybe Device) openDevice maybeDeviceSpec = fmap unmarshalDevice $ maybe (alcOpenDevice nullPtr) -- use preferred device (flip withALCString alcOpenDevice) maybeDeviceSpec foreign import CALLCONV unsafe "alcOpenDevice" alcOpenDevice :: Ptr ALCchar -> IO ALCdevice -------------------------------------------------------------------------------- -- | Contains 'Just' the specifier string for the default device or 'Nothing' if -- there is no sound support at all. defaultDeviceSpecifier :: GettableStateVar (Maybe String) defaultDeviceSpecifier = makeGettableStateVar $ getStringRaw Nothing DefaultDeviceSpecifier >>= maybePeek peekALCString -------------------------------------------------------------------------------- -- | Contains the specifier string for the given device. deviceSpecifier :: Device -> GettableStateVar String deviceSpecifier device = makeGettableStateVar $ getString (Just device) DeviceSpecifier -------------------------------------------------------------------------------- -- | Contains a list of specifiers for all available devices. allDeviceSpecifiers :: GettableStateVar [String] allDeviceSpecifiers = makeGettableStateVar $ do enumExtPresent <- get (alcIsExtensionPresent Nothing "ALC_ENUMERATION_EXT") if enumExtPresent then getStringRaw Nothing DeviceSpecifier >>= peekALCStrings else get defaultDeviceSpecifier >>= (return . maybe [] (\s -> [s])) OpenAL-1.4.0.2/Sound/OpenAL/ALC/Extensions.hs0000644000000000000000000000670712107326776015205 0ustar -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.ALC.Extensions -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- This module corresponds to the extension handling parts of section 6.3 -- (ALC Queries) of the OpenAL Specification and Reference (version 1.1). -- -------------------------------------------------------------------------------- module Sound.OpenAL.ALC.Extensions ( alcExtensions, alcIsExtensionPresent, alcProcAddress, alcEnumValue, alcVersion ) where import Control.Monad ( liftM2 ) import Data.StateVar import Foreign.Ptr ( Ptr, FunPtr ) import Sound.OpenAL.ALC.BasicTypes ( ALCchar, ALCenum, ALCint ) import Sound.OpenAL.ALC.Device ( Device ) import Sound.OpenAL.ALC.QueryUtils ( StringQuery(..), getString, IntQuery(..), getInteger, alcIsExtensionPresent ) import Sound.OpenAL.ALC.String ( withALCString ) import Sound.OpenAL.Config ( ALCdevice(..), nullDevice, marshalDevice ) -------------------------------------------------------------------------------- -- | Contains a list of available context extensions. alcExtensions :: Device -> GettableStateVar [String] alcExtensions device = makeGettableStateVar $ fmap words $ getString (Just device) Extensions -------------------------------------------------------------------------------- -- | The application is expected to verify the applicability of an extension or -- core function entry point before requesting it by name, by use of -- 'alcIsExtensionPresent'. Extension entry points can be retrieved using -- 'alcProcAddress'. Entry points can be device specific, but are not context -- specific. Using 'Nothing' as the device does not guarantee that the entry -- point is returned, even if available for one of the available devices. alcProcAddress :: Maybe Device -> String -> GettableStateVar (FunPtr a) alcProcAddress maybeDevice funcName = makeGettableStateVar . withALCString funcName . alcGetProcAddress . marshalDevice . maybe nullDevice id $ maybeDevice foreign import CALLCONV unsafe "alcGetProcAddress" alcGetProcAddress :: ALCdevice -> Ptr ALCchar -> IO (FunPtr a) -------------------------------------------------------------------------------- -- | Enumeration\/token values are device independent, but tokens defined for -- extensions might not be present for a given device. Using 'Nothing' as the -- device is legal, but only the tokens defined by the AL core are -- guaranteed. Availability of extension tokens depends on the ALC extension. alcEnumValue :: Maybe Device -> String -> GettableStateVar ALCenum alcEnumValue maybeDevice enumName = makeGettableStateVar . withALCString enumName . alcGetEnumValue . marshalDevice . maybe nullDevice id $ maybeDevice foreign import CALLCONV unsafe "alcGetEnumValue" alcGetEnumValue :: ALCdevice -> Ptr ALCchar -> IO ALCenum -------------------------------------------------------------------------------- -- | Contains the \"/major/./minor/\" specification revision for this implementation. alcVersion :: GettableStateVar String alcVersion = makeGettableStateVar $ liftM2 makeVersionString (getInteger Nothing MajorVersion) (getInteger Nothing MinorVersion) makeVersionString :: ALCint -> ALCint -> String makeVersionString major minor = show major ++ "." ++ show minor OpenAL-1.4.0.2/Sound/OpenAL/ALC/String.hs0000644000000000000000000000257412107326776014312 0ustar -- #hide -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.ALC.String -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -------------------------------------------------------------------------------- module Sound.OpenAL.ALC.String ( withALCString, peekALCString, peekALCStrings ) where import Foreign.C.String ( withCString, peekCString ) import Foreign.Marshal.Array ( lengthArray0 ) import Foreign.Ptr ( Ptr, castPtr, plusPtr ) import Sound.OpenAL.ALC.BasicTypes ( ALCchar ) -------------------------------------------------------------------------------- -- AL uses "Ptr ALCchar" instead of "CString" for strings, so some wrappers -- are quite handy. withALCString :: String -> (Ptr ALCchar -> IO a) -> IO a withALCString str action = withCString str (action . castPtr) peekALCString :: Ptr ALCchar -> IO String peekALCString = peekCString . castPtr peekALCStrings :: Ptr ALCchar -> IO [String] peekALCStrings ptr = loop ptr [] where loop p strs = do str <- peekALCString p if str == "" then return (reverse strs) else do len <- lengthArray0 0 p loop (p `plusPtr` (len + 1)) (str : strs) OpenAL-1.4.0.2/Sound/OpenAL/ALC/Errors.hs0000644000000000000000000000734712107326776014323 0ustar -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.ALC.Errors -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- This module corresponds to section 6.3.6 (Query for Error Conditions) of the -- OpenAL Specification and Reference (version 1.1). -- -------------------------------------------------------------------------------- module Sound.OpenAL.ALC.Errors ( ALCError(..), ALCErrorCategory(..), alcErrors ) where import Data.StateVar import Sound.OpenAL.ALC.BasicTypes ( ALCenum ) import Sound.OpenAL.ALC.Device ( Device ) import Sound.OpenAL.ALC.QueryUtils ( StringQuery(..), getString ) import Sound.OpenAL.Constants ( alc_NO_ERROR, alc_INVALID_DEVICE, alc_INVALID_CONTEXT, alc_INVALID_ENUM, alc_INVALID_VALUE, alc_OUT_OF_MEMORY, alc_INVALID_OPERATION ) import Sound.OpenAL.Config ( ALCdevice(..), marshalDevice ) -------------------------------------------------------------------------------- -- | ALC errors consist of a general error category and a description of what -- went wrong. data ALCError = ALCError ALCErrorCategory String deriving ( Eq, Ord, Show ) -------------------------------------------------------------------------------- -- | General ALC error categories. data ALCErrorCategory = ALCInvalidEnum | ALCInvalidValue | ALCInvalidOperation | ALCInvalidDevice | ALCInvalidContext | ALCOutOfMemory deriving ( Eq, Ord, Show ) unmarshalALCErrorCategory :: ALCenum -> ALCErrorCategory unmarshalALCErrorCategory x | x == alc_INVALID_ENUM = ALCInvalidEnum | x == alc_INVALID_VALUE = ALCInvalidValue | x == alc_INVALID_OPERATION = ALCInvalidOperation | x == alc_INVALID_DEVICE = ALCInvalidDevice | x == alc_INVALID_CONTEXT = ALCInvalidContext | x == alc_OUT_OF_MEMORY = ALCOutOfMemory | otherwise = error ("unmarshalALCErrorCategory: illegal value " ++ show x) -------------------------------------------------------------------------------- -- | OpenAL detects only a subset of those conditions that could be considered -- errors. This is because in many cases error checking would adversely impact -- the performance of an error-free program. The state variable 'alcErrors' is -- used to obtain error information. When an error is detected by ALC, a flag is -- set and the error code is recorded. Further errors, if they occur, do not -- affect this recorded code. When 'alcErrors' is read, the error for the given -- device is returned and the flag is cleared, so that a further error will -- again record its code. If reading 'alcErrors' returns @\[\]@ then there has -- been no detectable error since the last time 'alcErrors' (or since the ALC -- was initialized). -- -- When an error flag is set, results of ALC operations are undefined only if -- 'ALCOutOfMemory' has occurred. In other cases, the command generating the -- error is ignored so that it has no effect on ALC state or output buffer -- contents. If the error generating command returns a value, it returns zero. -- If the generating command modifies values through a pointer argument, no -- change is made to these values. These error semantics apply only to ALC -- errors, not to system errors such as memory access errors. alcErrors :: Device -> GettableStateVar [ALCError] alcErrors device = makeGettableStateVar $ do c <- alcGetError (marshalDevice device) if c == alc_NO_ERROR then return [] else do s <- getString (Just device) (ALCErrorCategory c) return [ ALCError (unmarshalALCErrorCategory c) s ] foreign import CALLCONV unsafe "alcGetError" alcGetError :: ALCdevice -> IO ALCenum OpenAL-1.4.0.2/Sound/OpenAL/ALC/BasicTypes.hs0000644000000000000000000000160412107326776015103 0ustar -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.ALC.BasicTypes -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- This module corresponds to the introductory parts of chapter 6 (AL Contexts -- and the ALC API) of the OpenAL Specification and Reference (version 1.1). -- -- The context API makes use of ALC types which are defined separately from the -- AL types - there is an 'ALCboolean', 'ALCchar', etc. -- -------------------------------------------------------------------------------- module Sound.OpenAL.ALC.BasicTypes ( ALCboolean, ALCchar, ALCbyte, ALCubyte, ALCshort, ALCushort, ALCint, ALCuint, ALCsizei, ALCenum, ALCfloat, ALCdouble ) where import Sound.OpenAL.Config OpenAL-1.4.0.2/Sound/OpenAL/ALC/QueryUtils.hs0000644000000000000000000001115112107326776015161 0ustar -- #hide -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.ALC.QueryUtils -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -------------------------------------------------------------------------------- module Sound.OpenAL.ALC.QueryUtils ( StringQuery(..), getString, getStringRaw, IntQuery(..), marshalIntQuery, getInteger, getIntegerv, alcIsExtensionPresent ) where import Control.Monad ( when ) import Data.StateVar import Foreign.Marshal.Array ( withArray, peekArray ) import Foreign.Ptr ( Ptr ) import Sound.OpenAL.ALC.ALCboolean ( unmarshalALCboolean ) import Sound.OpenAL.ALC.BasicTypes ( ALCboolean, ALCchar, ALCint, ALCenum, ALCsizei ) import Sound.OpenAL.ALC.String ( withALCString, peekALCString ) import Sound.OpenAL.Config ( Device, ALCdevice(..), nullDevice, marshalDevice ) import Sound.OpenAL.Constants ( alc_DEFAULT_DEVICE_SPECIFIER, alc_DEVICE_SPECIFIER, alc_EXTENSIONS, alc_CAPTURE_DEFAULT_DEVICE_SPECIFIER, alc_CAPTURE_DEVICE_SPECIFIER, alc_ATTRIBUTES_SIZE, alc_ALL_ATTRIBUTES, alc_MAJOR_VERSION, alc_MINOR_VERSION, alc_CAPTURE_SAMPLES ) -------------------------------------------------------------------------------- data StringQuery = DefaultDeviceSpecifier | DeviceSpecifier | Extensions | CaptureDefaultDeviceSpecifier | CaptureDeviceSpecifier | ALCErrorCategory ALCenum marshalStringQuery :: StringQuery -> ALCenum marshalStringQuery x = case x of DefaultDeviceSpecifier -> alc_DEFAULT_DEVICE_SPECIFIER DeviceSpecifier -> alc_DEVICE_SPECIFIER Extensions -> alc_EXTENSIONS CaptureDefaultDeviceSpecifier -> alc_CAPTURE_DEFAULT_DEVICE_SPECIFIER CaptureDeviceSpecifier -> alc_CAPTURE_DEVICE_SPECIFIER ALCErrorCategory e -> e -------------------------------------------------------------------------------- getString :: Maybe Device -> StringQuery -> IO String getString device query = getStringRaw device query >>= peekALCString getStringRaw :: Maybe Device -> StringQuery -> IO (Ptr ALCchar) getStringRaw maybeDevice = alcGetString (marshalMaybeDevice maybeDevice) . marshalStringQuery marshalMaybeDevice :: Maybe Device -> ALCdevice marshalMaybeDevice = marshalDevice . maybe nullDevice id foreign import CALLCONV unsafe "alcGetString" alcGetString :: ALCdevice -> ALCenum -> IO (Ptr ALCchar) -------------------------------------------------------------------------------- data IntQuery = AttributesSize | AllAttributes | MajorVersion | MinorVersion | CaptureSamples marshalIntQuery :: IntQuery -> ALCenum marshalIntQuery x = case x of AttributesSize -> alc_ATTRIBUTES_SIZE AllAttributes -> alc_ALL_ATTRIBUTES MajorVersion -> alc_MAJOR_VERSION MinorVersion -> alc_MINOR_VERSION CaptureSamples -> alc_CAPTURE_SAMPLES -------------------------------------------------------------------------------- getInteger :: Maybe Device -> IntQuery -> IO ALCint getInteger maybeDevice query = fmap head $ getIntegerv maybeDevice query 1 -- We are extremely careful below to avoid segfaults in case that there is no -- current context, an invalid device, etc. getIntegerv :: Maybe Device -> IntQuery -> ALCsizei -> IO [ALCint] getIntegerv maybeDevice query numALCints = let n = fromIntegral numALCints in withArray (replicate n 0) $ \buf -> do when (numALCints > 0) $ alcGetIntegerv (marshalMaybeDevice maybeDevice) (marshalIntQuery query) numALCints buf peekArray n buf foreign import CALLCONV unsafe "alcGetIntegerv" alcGetIntegerv :: ALCdevice -> ALCenum -> ALCsizei -> Ptr ALCint -> IO () -------------------------------------------------------------------------------- -- | To verify that a given extension is available for the current context and -- the device it is associated with, use 'alcIsExtensionPresent'. For invalid -- and unsupported string tokens it contains 'False'. Using 'Nothing' as the -- device is acceptable. The extension name is not case sensitive: The -- implementation will convert the name to all upper-case internally (and will -- express extension names in upper-case). alcIsExtensionPresent :: Maybe Device -> String -> GettableStateVar Bool alcIsExtensionPresent maybeDevice extensionName = makeGettableStateVar $ fmap unmarshalALCboolean $ withALCString extensionName $ alcIsExtensionPresent_ (marshalMaybeDevice maybeDevice) foreign import CALLCONV unsafe "alcIsExtensionPresent" alcIsExtensionPresent_ :: ALCdevice -> Ptr ALCchar -> IO ALCboolean OpenAL-1.4.0.2/Sound/OpenAL/ALC/Context.hs0000644000000000000000000002211412107326776014460 0ustar -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL.ALC.Context -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- This module corresponds to section 6.2 (Managing Rendering Contexts) of the -- OpenAL Specification and Reference (version 1.1). -- -- All operations of the AL core API affect a current AL context. Within the -- scope of AL, the ALC is implied - it is not visible as a handle or function -- parameter. Only one AL Context per process can be current at a time. -- Applications maintaining multiple AL Contexts, whether threaded or not, -- have to set the current context accordingly. Applications can have multiple -- threads that share one more or contexts. In other words, AL and ALC are -- threadsafe. -- -------------------------------------------------------------------------------- module Sound.OpenAL.ALC.Context ( Frequency, ContextAttribute(..), Context, createContext, currentContext, processContext, suspendContext, destroyContext, contextsDevice, allAttributes ) where import Data.StateVar import Foreign.Marshal.Array ( withArray0 ) import Foreign.Ptr ( Ptr ) import Sound.OpenAL.ALC.BasicTypes ( ALCint ) import Sound.OpenAL.ALC.ALCboolean ( marshalALCboolean, unmarshalALCboolean ) import Sound.OpenAL.ALC.Device ( Device ) import Sound.OpenAL.ALC.QueryUtils ( IntQuery(..), getInteger, getIntegerv ) import Sound.OpenAL.Config ( ALCdevice(..), marshalDevice, unmarshalDevice, ALCcontext(..), Context, nullContext, marshalContext, unmarshalContext, alcProcessContext, alcDestroyContext, alcMakeContextCurrent ) import Sound.OpenAL.Constants ( alc_FREQUENCY, alc_REFRESH, alc_SYNC, alc_MONO_SOURCES, alc_STEREO_SOURCES ) #ifdef __HADDOCK__ import Sound.OpenAL.ALC.Errors ( ALCErrorCategory(..) ) #endif -------------------------------------------------------------------------------- -- | Frequency, specified in samples per second, i.e. units of Hertz \[Hz\]. -- Note that the underlying OpenAL API currently uses integral frequencies -- only, but we want to mirror physical reality here more closely. type Frequency = Float -------------------------------------------------------------------------------- -- | The application can choose to specify certain attributes for a context at -- context-creation time. Attributes not specified explicitly are set to -- implementation dependent defaults. data ContextAttribute = Frequency Frequency -- ^ Frequency for mixing output buffer, in units of -- Hz | Refresh Frequency -- ^ Refresh intervals, in units of Hz | Sync Bool -- ^ Flag, indicating a synchronous context | MonoSources Int -- ^ A hint indicating how many sources should be -- capable of supporting mono data | StereoSources Int -- ^ A hint indicating how many sources should be -- capable of supporting stereo data deriving ( Eq, Ord, Show ) marshalContextAttribute :: ContextAttribute -> (ALCint,ALCint) marshalContextAttribute a = case a of Frequency f -> (alc_FREQUENCY, round f) Refresh r -> (alc_REFRESH, round r) Sync s -> (alc_SYNC, fromIntegral (marshalALCboolean s)) MonoSources m -> (alc_MONO_SOURCES, fromIntegral m) StereoSources s -> (alc_STEREO_SOURCES, fromIntegral s) unmarshalContextAttribute :: (ALCint,ALCint) -> ContextAttribute unmarshalContextAttribute a@(x,y) | x == alc_FREQUENCY = Frequency (fromIntegral y) | x == alc_REFRESH = Refresh (fromIntegral y) | x == alc_SYNC = Sync (unmarshalALCboolean (fromIntegral y)) | x == alc_MONO_SOURCES = MonoSources (fromIntegral y) | x == alc_STEREO_SOURCES = StereoSources (fromIntegral y) | otherwise = error ("unmarshalContextAttribute: illegal value " ++ show a) -------------------------------------------------------------------------------- -- | Create a context for a given device and given attributes. Context creation -- will fail in the following cases: a) if the application requests attributes -- that, by themselves, can not be provided b) if the combination of specified -- attributes can not be provided c) if a specified attribute, or the -- combination of attributes, does not match the default values for unspecified -- attributes If context creation fails, 'Nothing' will be returned, otherwise -- 'Just' the new context. Note that 'createContext' does /not/ set the current -- context, this must be done separately via 'currentContext'. createContext :: Device -> [ContextAttribute] -> IO (Maybe Context) createContext device attributes = do let pairToList (key, value) = [key, value] attrs = concatMap (pairToList . marshalContextAttribute) attributes fmap unmarshalContext . withArray0 0 attrs . alcCreateContext . marshalDevice $ device foreign import CALLCONV unsafe "alcCreateContext" alcCreateContext :: ALCdevice -> Ptr ALCint -> IO ALCcontext -------------------------------------------------------------------------------- -- | Contains 'Just' the current context with respect to OpenAL operation, or -- 'Nothing' if there is no current context. Setting it to the latter is useful -- when shutting OpenAL down. The state variable applies to the device that the -- context was created for. For each OS process (usually this means for each -- application), only one context can be current at any given time. All AL -- commands apply to the current context. Commands that affect objects shared -- among contexts (e.g. buffers) have side effects on other contexts. currentContext :: StateVar (Maybe Context) currentContext = makeStateVar getCurrentContext makeContextCurrent getCurrentContext :: IO (Maybe Context) getCurrentContext = fmap unmarshalContext $ alcGetCurrentContext foreign import CALLCONV unsafe "alcGetCurrentContext" alcGetCurrentContext :: IO ALCcontext makeContextCurrent :: Maybe Context -> IO () makeContextCurrent = fmap (const ()) . alcMakeContextCurrent . marshalContext . maybe nullContext id -------------------------------------------------------------------------------- -- | The current context is the only context accessible to state changes by AL -- commands (aside from state changes affecting shared objects). However, -- multiple contexts can be processed at the same time. To indicate that a -- context should be processed (i.e. that internal execution state like offset -- increments are supposed to be performed), the application has to use -- 'processContext'. Repeated calls to 'processContext' are legal, and do not -- affect a context that is already marked as processing. The default state of a -- context created by 'createContext' is that it is processing. processContext :: Context -> IO () processContext = fmap (const ()) . alcProcessContext . marshalContext -- | The application can suspend any context from processing (including the -- current one). To indicate that a context should be suspended from processing -- (i.e. that internal execution state like offset increments is not supposed to -- be changed), the application has to use 'suspendContext'. Repeated calls to -- 'suspendContext' are legal, and do not affect a context that is already -- marked as suspended. suspendContext :: Context -> IO () suspendContext = alcSuspendContext . marshalContext foreign import CALLCONV unsafe "alcSuspendContext" alcSuspendContext :: ALCcontext -> IO () -------------------------------------------------------------------------------- -- | Destroy the given context. Note that the the correct way to destroy a -- context is to first release it by setting 'currentContext' to -- 'Nothing'. Applications should not attempt to destroy a current context, -- doing so will not work and will result in an 'ALCInvalidOperation' error. destroyContext :: Context -> IO () destroyContext = fmap (const ()) . alcDestroyContext . marshalContext -------------------------------------------------------------------------------- -- | Contains 'Just' the device of the given context or 'Nothing' if the context -- is invalid. contextsDevice :: Context -> GettableStateVar (Maybe Device) contextsDevice = makeGettableStateVar . fmap unmarshalDevice . alcGetContextsDevice . marshalContext foreign import CALLCONV unsafe "alcGetContextsDevice" alcGetContextsDevice :: ALCcontext -> IO ALCdevice -------------------------------------------------------------------------------- -- | Contains the attribute list for the current context of the specified -- device. allAttributes :: Device -> GettableStateVar [ContextAttribute] allAttributes device = makeGettableStateVar $ do numALCints <- fmap fromIntegral $ getInteger (Just device) AttributesSize fmap toContextAttributes $ getIntegerv (Just device) AllAttributes numALCints toContextAttributes :: [ALCint] -> [ContextAttribute] toContextAttributes xs = case xs of [] -> [] -- should only happen when device and/or current context is invalid (0:_) -> [] (x:y:rest) -> unmarshalContextAttribute (x,y) : toContextAttributes rest _ -> error ("toContextAttributes: illegal value " ++ show xs) OpenAL-1.4.0.2/Sound/OpenAL.hs0000644000000000000000000002205312107326776012437 0ustar -------------------------------------------------------------------------------- -- | -- Module : Sound.OpenAL -- Copyright : (c) Sven Panne 2003-2009 -- License : BSD-style (see the file LICENSE) -- -- Maintainer : sven.panne@aedion.de -- Stability : stable -- Portability : portable -- -- A convenience module, combining the Haskell bindings for AL and ALC. -- -------------------------------------------------------------------------------- module Sound.OpenAL ( -- * A Brief History of OpenAL -- $ABriefHistoryOfOpenAL -- * What is the OpenAL Audio System? -- $WhatIsTheOpenALAudioSystem -- * Different Views of OpenAL -- ** Programmer\'s View of OpenAL -- $ProgrammersViewOfOpenAL -- ** Implementor\'s View of OpenAL -- $ImplementorsViewOfOpenAL -- ** The Specification\'s View of OpenAL -- $TheSpecificationsViewOfOpenAL -- * Legal stuff -- $LegalStuff module Sound.OpenAL.AL , module Sound.OpenAL.ALC -- * Convenience Re-exports , module Data.ObjectName , module Data.StateVar , module Data.Tensor ) where import Sound.OpenAL.AL import Sound.OpenAL.ALC import Data.ObjectName import Data.StateVar import Data.Tensor ( Vector3(..), Vertex3(..) ) -------------------------------------------------------------------------------- -- $ABriefHistoryOfOpenAL -- The first discussions about implementing OpenAL as an audio API complimentary -- to OpenGL started around 1998. There were a few aborted attempts at creating -- the headers and a specification, but by late 1999 Loki Entertainment Software -- was in need for an API of exactly this type and pursued both a specification -- and a Linux implementation. At around that time, Loki started talking with -- Creative Labs about standardizing the API and expanding platform support. The -- OpenAL 1.0 specification was released in early 2000 and compliant OpenAL -- libraries were released in the same year for Linux, MacOS 8\/9, Windows, and -- BeOS. Loki Entertainment also shipped several games using OpenAL in 2000: -- Heavy Gear 2 and Heretic 2 (both under Linux). In 2001, Creative Labs -- released the first hardware-accelerated OpenAL libraries. The libraries -- supported the SoundBlaster Live on MacOS 8\/9 and Windows. -- -- Since 2001, there has been continuous improvement in OpenAL. Some platforms -- are less relevant than in 2000 (BeOS and MacOS 8\/9 for instance), but more -- platforms have been added as well (BSD, Solaris, IRIX, Mac OS X, and the -- popular console gaming platforms). Hardware support is enabled for many -- Creative and NVIDIA audio devices under Windows as well. -- -- In terms of product support, OpenAL has been used in a large number of titles -- over the years, on many platforms (for a list of many of the titles, see -- ). -------------------------------------------------------------------------------- -- $WhatIsTheOpenALAudioSystem -- OpenAL (for /Open Audio Library/) is a software interface to audio hardware. -- The interface consists of a number of functions that allow a programmer to -- specify the objects and operations in producing high-quality audio output, -- specifically multichannel output of 3D arrangements of sound sources around a -- listener. -- -- The OpenAL API is designed to be cross-platform and easy to use. It resembles -- the OpenGL API in coding style and conventions. OpenAL uses a syntax -- resembling that of OpenGL where applicable. For more information on OpenGL, -- see and the "Graphics.Rendering.OpenGL" module. -- -- OpenAL is foremost a means to generate audio in a simulated three-dimensional -- space. Consequently, legacy audio concepts such as panning and left\/right -- channels are not directly supported. OpenAL does include extensions -- compatible with the IA-SIG 3D Level 1 and Level 2 rendering guidelines to -- handle sound-source directivity and distancerelated attenuation and Doppler -- effects, as well as environmental effects such as reflection, obstruction, -- transmission, reverberation. For more information on IA-SIG 3D, see -- . -- -- Like OpenGL, the OpenAL core API has no notion of an explicit rendering -- context, and operates on an implied current OpenAL Context. Unlike the OpenGL -- specification, the OpenAL specification includes both the core API (the -- actual OpenAL API, see "Sound.OpenAL.AL") and the operating system bindings -- of the ALC API (the /Audio Library Context/, see "Sound.OpenAL.ALC"). Unlike -- OpenGL\'s GLX, WGL and other OS-specific bindings, the ALC API is portable -- across platforms as well. -------------------------------------------------------------------------------- -- $ProgrammersViewOfOpenAL -- To the programmer, OpenAL is a set of commands that allow the specification -- of sound sources and a listener in three dimensions, combined with commands -- that control how these sound sources are rendered into the output buffer. The -- effect of OpenAL commands is not guaranteed to be immediate, as there are -- latencies depending on the implementation, but ideally such latency should -- not be noticeable to the user. -- -- A typical program that uses OpenAL begins with calls to open a sound device -- which is used to process output and play it on attached hardware (speakers or -- headphones). Then, calls are made to allocate an AL context and associate it -- with the device. Once an AL context is allocated, the programmer is free to -- issue AL commands. Some calls are used to render sources (point and -- directional sources, looping or not), while others affect the rendering of -- these sources including how they are attenuated by distance and relative -- orientation. -------------------------------------------------------------------------------- -- $ImplementorsViewOfOpenAL -- To the implementor, OpenAL is a set of commands that affect the operation of -- CPU and sound hardware. If the hardware consists only of an addressable -- output buffer, then OpenAL must be implemented almost entirely on the host -- CPU. In some cases audio hardware provides DSP-based and other acceleration -- in various degrees. The OpenAL implementor\'s task is to provide the CPU -- software interface while dividing the work for each AL command between the -- CPU and the audio hardware. This division should be tailored to the available -- audio hardware to obtain optimum performance in carrying out AL calls. -- -- OpenAL maintains a considerable amount of state information. This state -- controls how the sources are rendered into the output buffer. Some of this -- state is directly available to the user: he or she can make calls to obtain -- its value. Some of it, however, is visible only by the effect it has on what -- is rendered. One of the main goals of the OpenAL specification is to make -- OpenAL state information explicit, to elucidate how it changes, and to -- indicate what its effects are. -------------------------------------------------------------------------------- -- $TheSpecificationsViewOfOpenAL -- The OpenAL specification (see ) -- views OpenAL as a state machine that controls a multichannel processing -- system to synthesize a digital stream, passing sample data through a chain of -- parametrized digital audio signal processing operations. This model should -- engender a specification that satisfies the needs of both programmers and -- implementors. It does not, however, necessarily provide a model for -- implementation. Any proper implementation must produce results conforming to -- those produced by the methods specified in the OpenAL specification, but -- there may be ways to carry out a particular computation that are more -- efficient than the one specified. -------------------------------------------------------------------------------- -- $LegalStuff -- The documentation is more or less based upon the OpenAL 1.1 Specification and -- Reference, which is in turn based upon the older OpenAL Specification and -- Reference (1.0), published in June 2000. Both copyright notices are presented -- below: -- -- Version 1.1: Published June 2005, Copyright (c) 2005 by authors -- -- Version 1.0 Draft Edition: Published June 2000, Copyright (c) 1999-2000 by -- Loki Software -- -- Permission is granted to make and distribute verbatim copies of this manual -- provided the copyright notice and this permission notice are preserved on all -- copies. Permission is granted to copy and distribute translations of this -- manual into another language, under the above conditions for modified -- versions, except that this permission notice may be stated in a translation -- approved by the copyright owners. -- -- BeOS is a trademark of PalmSource, Inc. Linux is a trademark of Linus -- Torvalds. Macintosh and Apple are trademarks of Apple Computer, Inc. OpenAL -- is a trademark of Creative Labs, Inc. OpenGL is a trademark of Silicon -- Graphics, Inc. UNIX is a trademark of X\/Open Group. Windows is a trademark -- of Microsoft Corp. X Window System is a trademark of X Consortium, Inc. All -- other trademarks are property of their respective owners. OpenAL-1.4.0.2/configure0000755000000000000000000064314411733255111011602 0ustar #! /bin/sh # Guess values for system-dependent variables and create Makefiles. # Generated by GNU Autoconf 2.68 for Haskell HOpenAL package 1.3.1.3. # # Report bugs to . # # # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, # 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software # Foundation, Inc. # # # This configure script is free software; the Free Software Foundation # gives unlimited permission to copy, distribute and modify it. ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi as_nl=' ' export as_nl # Printing a long string crashes Solaris 7 /usr/bin/printf. as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo # Prefer a ksh shell builtin over an external printf program on Solaris, # but without wasting forks for bash or zsh. if test -z "$BASH_VERSION$ZSH_VERSION" \ && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='print -r --' as_echo_n='print -rn --' elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='printf %s\n' as_echo_n='printf %s' else if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' as_echo_n='/usr/ucb/echo -n' else as_echo_body='eval expr "X$1" : "X\\(.*\\)"' as_echo_n_body='eval arg=$1; case $arg in #( *"$as_nl"*) expr "X$arg" : "X\\(.*\\)$as_nl"; arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; esac; expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" ' export as_echo_n_body as_echo_n='sh -c $as_echo_n_body as_echo' fi export as_echo_body as_echo='sh -c $as_echo_body as_echo' fi # The user is always right. if test "${PATH_SEPARATOR+set}" != set; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=';' } fi # IFS # We need space, tab and new line, in precisely that order. Quoting is # there to prevent editors from complaining about space-tab. # (If _AS_PATH_WALK were called with IFS unset, it would disable word # splitting by setting IFS to empty value.) IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break done IFS=$as_save_IFS ;; esac # We did not find ourselves, most probably we were run as `sh COMMAND' # in which case we are not to be found in the path. if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi # Unset variables that we do not need and which cause bugs (e.g. in # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" # suppresses any "Segmentation fault" message there. '((' could # trigger a bug in pdksh 5.2.14. for as_var in BASH_ENV ENV MAIL MAILPATH do eval test x\${$as_var+set} = xset \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done PS1='$ ' PS2='> ' PS4='+ ' # NLS nuisances. LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE # CDPATH. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH if test "x$CONFIG_SHELL" = x; then as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which # is contrary to our usage. Disable this feature. alias -g '\${1+\"\$@\"}'='\"\$@\"' setopt NO_GLOB_SUBST else case \`(set -o) 2>/dev/null\` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi " as_required="as_fn_return () { (exit \$1); } as_fn_success () { as_fn_return 0; } as_fn_failure () { as_fn_return 1; } as_fn_ret_success () { return 0; } as_fn_ret_failure () { return 1; } exitcode=0 as_fn_success || { exitcode=1; echo as_fn_success failed.; } as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : else exitcode=1; echo positional parameters were not saved. fi test x\$exitcode = x0 || exit 1" as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1 test \$(( 1 + 1 )) = 2 || exit 1" if (eval "$as_required") 2>/dev/null; then : as_have_required=yes else as_have_required=no fi if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then : else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR as_found=false for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. as_found=: case $as_dir in #( /*) for as_base in sh bash ksh sh5; do # Try only shells that exist, to save several forks. as_shell=$as_dir/$as_base if { test -f "$as_shell" || test -f "$as_shell.exe"; } && { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then : CONFIG_SHELL=$as_shell as_have_required=yes if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then : break 2 fi fi done;; esac as_found=false done $as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } && { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then : CONFIG_SHELL=$SHELL as_have_required=yes fi; } IFS=$as_save_IFS if test "x$CONFIG_SHELL" != x; then : # We cannot yet assume a decent shell, so we have to provide a # neutralization value for shells without unset; and this also # works around shells that cannot unset nonexistent variables. # Preserve -v and -x to the replacement shell. BASH_ENV=/dev/null ENV=/dev/null (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV export CONFIG_SHELL case $- in # (((( *v*x* | *x*v* ) as_opts=-vx ;; *v* ) as_opts=-v ;; *x* ) as_opts=-x ;; * ) as_opts= ;; esac exec "$CONFIG_SHELL" $as_opts "$as_myself" ${1+"$@"} fi if test x$as_have_required = xno; then : $as_echo "$0: This script requires a shell more modern than all" $as_echo "$0: the shells that I found on your system." if test x${ZSH_VERSION+set} = xset ; then $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should" $as_echo "$0: be upgraded to zsh 4.3.4 or later." else $as_echo "$0: Please tell bug-autoconf@gnu.org and $0: sven.panne@aedion.de about your system, including any $0: error possibly output before this message. Then install $0: a modern shell, or manually run the script under such a $0: shell if you do have one." fi exit 1 fi fi fi SHELL=${CONFIG_SHELL-/bin/sh} export SHELL # Unset more variables known to interfere with behavior of common tools. CLICOLOR_FORCE= GREP_OPTIONS= unset CLICOLOR_FORCE GREP_OPTIONS ## --------------------- ## ## M4sh Shell Functions. ## ## --------------------- ## # as_fn_unset VAR # --------------- # Portably unset VAR. as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. as_fn_set_status () { return $1 } # as_fn_set_status # as_fn_exit STATUS # ----------------- # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit # as_fn_mkdir_p # ------------- # Create "$as_dir" as a directory, including parents if necessary. as_fn_mkdir_p () { case $as_dir in #( -*) as_dir=./$as_dir;; esac test -d "$as_dir" || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" as_dir=`$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` test -d "$as_dir" && break done test -z "$as_dirs" || eval "mkdir $as_dirs" } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" } # as_fn_mkdir_p # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : eval 'as_fn_append () { eval $1+=\$2 }' else as_fn_append () { eval $1=\$$1\$2 } fi # as_fn_append # as_fn_arith ARG... # ------------------ # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : eval 'as_fn_arith () { as_val=$(( $* )) }' else as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } fi # as_fn_arith # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are # provided, also output the error to LOG_FD, referencing LINENO. Then exit the # script with STATUS, using 1 if that was 0. as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi $as_echo "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; then as_expr=expr else as_expr=false fi if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then as_basename=basename else as_basename=false fi if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || $as_echo X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` # Avoid depending upon Character Ranges. as_cr_letters='abcdefghijklmnopqrstuvwxyz' as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits as_lineno_1=$LINENO as_lineno_1a=$LINENO as_lineno_2=$LINENO as_lineno_2a=$LINENO eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" && test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || { # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-) sed -n ' p /[$]LINENO/= ' <$as_myself | sed ' s/[$]LINENO.*/&-/ t lineno b :lineno N :loop s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ t loop s/-\n.*// ' >$as_me.lineno && chmod +x "$as_me.lineno" || { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } # Don't try to exec as it changes $[0], causing all sort of problems # (the dirname of $[0] is not the place where we might find the # original and so on. Autoconf is especially sensitive to this). . "./$as_me.lineno" # Exit status is that of the last command. exit } ECHO_C= ECHO_N= ECHO_T= case `echo -n x` in #((((( -n*) case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. xy) ECHO_C='\c';; *) echo `echo ksh88 bug on AIX 6.1` > /dev/null ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. # In both cases, we have to default to `cp -p'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -p' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -p' fi else as_ln_s='cp -p' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null if mkdir -p . 2>/dev/null; then as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false fi if test -x / >/dev/null 2>&1; then as_test_x='test -x' else if ls -dL / >/dev/null 2>&1; then as_ls_L_option=L else as_ls_L_option= fi as_test_x=' eval sh -c '\'' if test -d "$1"; then test -d "$1/."; else case $1 in #( -*)set "./$1";; esac; case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #(( ???[sx]*):;;*)false;;esac;fi '\'' sh ' fi as_executable_p=$as_test_x # Sed expression to map a string onto a valid CPP name. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" # Sed expression to map a string onto a valid variable name. as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" test -n "$DJDIR" || exec 7<&0 &1 # Name of the host. # hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status, # so uname gets run too. ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` # # Initializations. # ac_default_prefix=/usr/local ac_clean_files= ac_config_libobj_dir=. LIBOBJS= cross_compiling=no subdirs= MFLAGS= MAKEFLAGS= # Identity of this package. PACKAGE_NAME='Haskell HOpenAL package' PACKAGE_TARNAME='OpenAL' PACKAGE_VERSION='1.3.1.3' PACKAGE_STRING='Haskell HOpenAL package 1.3.1.3' PACKAGE_BUGREPORT='sven.panne@aedion.de' PACKAGE_URL='' ac_unique_file="include/HsOpenAL.h.in" # Factoring default headers for most tests. ac_includes_default="\ #include #ifdef HAVE_SYS_TYPES_H # include #endif #ifdef HAVE_SYS_STAT_H # include #endif #ifdef STDC_HEADERS # include # include #else # ifdef HAVE_STDLIB_H # include # endif #endif #ifdef HAVE_STRING_H # if !defined STDC_HEADERS && defined HAVE_MEMORY_H # include # endif # include #endif #ifdef HAVE_STRINGS_H # include #endif #ifdef HAVE_INTTYPES_H # include #endif #ifdef HAVE_STDINT_H # include #endif #ifdef HAVE_UNISTD_H # include #endif" ac_subst_vars='LTLIBOBJS LIBOBJS CALLCONV BUILD_PACKAGE_BOOL EGREP GREP CPP AL_LIBS_PLAIN AL_FRAMEWORKS AL_CFLAGS AL_LIBS OBJEXT EXEEXT ac_ct_CC CPPFLAGS LDFLAGS CFLAGS CC target_os target_vendor target_cpu target host_os host_vendor host_cpu host build_os build_vendor build_cpu build target_alias host_alias build_alias LIBS ECHO_T ECHO_N ECHO_C DEFS mandir localedir libdir psdir pdfdir dvidir htmldir infodir docdir oldincludedir includedir localstatedir sharedstatedir sysconfdir datadir datarootdir libexecdir sbindir bindir program_transform_name prefix exec_prefix PACKAGE_URL PACKAGE_BUGREPORT PACKAGE_STRING PACKAGE_VERSION PACKAGE_TARNAME PACKAGE_NAME PATH_SEPARATOR SHELL' ac_subst_files='' ac_user_opts=' enable_option_checking with_compiler enable_openal ' ac_precious_vars='build_alias host_alias target_alias CC CFLAGS LDFLAGS LIBS CPPFLAGS CPP' # Initialize some variables set by options. ac_init_help= ac_init_version=false ac_unrecognized_opts= ac_unrecognized_sep= # The variables have the same names as the options, with # dashes changed to underlines. cache_file=/dev/null exec_prefix=NONE no_create= no_recursion= prefix=NONE program_prefix=NONE program_suffix=NONE program_transform_name=s,x,x, silent= site= srcdir= verbose= x_includes=NONE x_libraries=NONE # Installation directory options. # These are left unexpanded so users can "make install exec_prefix=/foo" # and all the variables that are supposed to be based on exec_prefix # by default will actually change. # Use braces instead of parens because sh, perl, etc. also accept them. # (The list follows the same order as the GNU Coding Standards.) bindir='${exec_prefix}/bin' sbindir='${exec_prefix}/sbin' libexecdir='${exec_prefix}/libexec' datarootdir='${prefix}/share' datadir='${datarootdir}' sysconfdir='${prefix}/etc' sharedstatedir='${prefix}/com' localstatedir='${prefix}/var' includedir='${prefix}/include' oldincludedir='/usr/include' docdir='${datarootdir}/doc/${PACKAGE_TARNAME}' infodir='${datarootdir}/info' htmldir='${docdir}' dvidir='${docdir}' pdfdir='${docdir}' psdir='${docdir}' libdir='${exec_prefix}/lib' localedir='${datarootdir}/locale' mandir='${datarootdir}/man' ac_prev= ac_dashdash= for ac_option do # If the previous option needs an argument, assign it. if test -n "$ac_prev"; then eval $ac_prev=\$ac_option ac_prev= continue fi case $ac_option in *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;; *=) ac_optarg= ;; *) ac_optarg=yes ;; esac # Accept the important Cygnus configure options, so we can diagnose typos. case $ac_dashdash$ac_option in --) ac_dashdash=yes ;; -bindir | --bindir | --bindi | --bind | --bin | --bi) ac_prev=bindir ;; -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) bindir=$ac_optarg ;; -build | --build | --buil | --bui | --bu) ac_prev=build_alias ;; -build=* | --build=* | --buil=* | --bui=* | --bu=*) build_alias=$ac_optarg ;; -cache-file | --cache-file | --cache-fil | --cache-fi \ | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) ac_prev=cache_file ;; -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) cache_file=$ac_optarg ;; --config-cache | -C) cache_file=config.cache ;; -datadir | --datadir | --datadi | --datad) ac_prev=datadir ;; -datadir=* | --datadir=* | --datadi=* | --datad=*) datadir=$ac_optarg ;; -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \ | --dataroo | --dataro | --datar) ac_prev=datarootdir ;; -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \ | --dataroot=* | --dataroo=* | --dataro=* | --datar=*) datarootdir=$ac_optarg ;; -disable-* | --disable-*) ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval enable_$ac_useropt=no ;; -docdir | --docdir | --docdi | --doc | --do) ac_prev=docdir ;; -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*) docdir=$ac_optarg ;; -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv) ac_prev=dvidir ;; -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*) dvidir=$ac_optarg ;; -enable-* | --enable-*) ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval enable_$ac_useropt=\$ac_optarg ;; -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ | --exec | --exe | --ex) ac_prev=exec_prefix ;; -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ | --exec=* | --exe=* | --ex=*) exec_prefix=$ac_optarg ;; -gas | --gas | --ga | --g) # Obsolete; use --with-gas. with_gas=yes ;; -help | --help | --hel | --he | -h) ac_init_help=long ;; -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) ac_init_help=recursive ;; -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) ac_init_help=short ;; -host | --host | --hos | --ho) ac_prev=host_alias ;; -host=* | --host=* | --hos=* | --ho=*) host_alias=$ac_optarg ;; -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht) ac_prev=htmldir ;; -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \ | --ht=*) htmldir=$ac_optarg ;; -includedir | --includedir | --includedi | --included | --include \ | --includ | --inclu | --incl | --inc) ac_prev=includedir ;; -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ | --includ=* | --inclu=* | --incl=* | --inc=*) includedir=$ac_optarg ;; -infodir | --infodir | --infodi | --infod | --info | --inf) ac_prev=infodir ;; -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) infodir=$ac_optarg ;; -libdir | --libdir | --libdi | --libd) ac_prev=libdir ;; -libdir=* | --libdir=* | --libdi=* | --libd=*) libdir=$ac_optarg ;; -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ | --libexe | --libex | --libe) ac_prev=libexecdir ;; -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ | --libexe=* | --libex=* | --libe=*) libexecdir=$ac_optarg ;; -localedir | --localedir | --localedi | --localed | --locale) ac_prev=localedir ;; -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*) localedir=$ac_optarg ;; -localstatedir | --localstatedir | --localstatedi | --localstated \ | --localstate | --localstat | --localsta | --localst | --locals) ac_prev=localstatedir ;; -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*) localstatedir=$ac_optarg ;; -mandir | --mandir | --mandi | --mand | --man | --ma | --m) ac_prev=mandir ;; -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) mandir=$ac_optarg ;; -nfp | --nfp | --nf) # Obsolete; use --without-fp. with_fp=no ;; -no-create | --no-create | --no-creat | --no-crea | --no-cre \ | --no-cr | --no-c | -n) no_create=yes ;; -no-recursion | --no-recursion | --no-recursio | --no-recursi \ | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) no_recursion=yes ;; -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ | --oldin | --oldi | --old | --ol | --o) ac_prev=oldincludedir ;; -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) oldincludedir=$ac_optarg ;; -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) ac_prev=prefix ;; -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) prefix=$ac_optarg ;; -program-prefix | --program-prefix | --program-prefi | --program-pref \ | --program-pre | --program-pr | --program-p) ac_prev=program_prefix ;; -program-prefix=* | --program-prefix=* | --program-prefi=* \ | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) program_prefix=$ac_optarg ;; -program-suffix | --program-suffix | --program-suffi | --program-suff \ | --program-suf | --program-su | --program-s) ac_prev=program_suffix ;; -program-suffix=* | --program-suffix=* | --program-suffi=* \ | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) program_suffix=$ac_optarg ;; -program-transform-name | --program-transform-name \ | --program-transform-nam | --program-transform-na \ | --program-transform-n | --program-transform- \ | --program-transform | --program-transfor \ | --program-transfo | --program-transf \ | --program-trans | --program-tran \ | --progr-tra | --program-tr | --program-t) ac_prev=program_transform_name ;; -program-transform-name=* | --program-transform-name=* \ | --program-transform-nam=* | --program-transform-na=* \ | --program-transform-n=* | --program-transform-=* \ | --program-transform=* | --program-transfor=* \ | --program-transfo=* | --program-transf=* \ | --program-trans=* | --program-tran=* \ | --progr-tra=* | --program-tr=* | --program-t=*) program_transform_name=$ac_optarg ;; -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd) ac_prev=pdfdir ;; -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*) pdfdir=$ac_optarg ;; -psdir | --psdir | --psdi | --psd | --ps) ac_prev=psdir ;; -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*) psdir=$ac_optarg ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil) silent=yes ;; -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) ac_prev=sbindir ;; -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ | --sbi=* | --sb=*) sbindir=$ac_optarg ;; -sharedstatedir | --sharedstatedir | --sharedstatedi \ | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ | --sharedst | --shareds | --shared | --share | --shar \ | --sha | --sh) ac_prev=sharedstatedir ;; -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ | --sha=* | --sh=*) sharedstatedir=$ac_optarg ;; -site | --site | --sit) ac_prev=site ;; -site=* | --site=* | --sit=*) site=$ac_optarg ;; -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) ac_prev=srcdir ;; -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) srcdir=$ac_optarg ;; -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ | --syscon | --sysco | --sysc | --sys | --sy) ac_prev=sysconfdir ;; -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) sysconfdir=$ac_optarg ;; -target | --target | --targe | --targ | --tar | --ta | --t) ac_prev=target_alias ;; -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) target_alias=$ac_optarg ;; -v | -verbose | --verbose | --verbos | --verbo | --verb) verbose=yes ;; -version | --version | --versio | --versi | --vers | -V) ac_init_version=: ;; -with-* | --with-*) ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval with_$ac_useropt=\$ac_optarg ;; -without-* | --without-*) ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval with_$ac_useropt=no ;; --x) # Obsolete; use --with-x. with_x=yes ;; -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ | --x-incl | --x-inc | --x-in | --x-i) ac_prev=x_includes ;; -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) x_includes=$ac_optarg ;; -x-libraries | --x-libraries | --x-librarie | --x-librari \ | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) ac_prev=x_libraries ;; -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) x_libraries=$ac_optarg ;; -*) as_fn_error $? "unrecognized option: \`$ac_option' Try \`$0 --help' for more information" ;; *=*) ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` # Reject names that are not valid shell variable names. case $ac_envvar in #( '' | [0-9]* | *[!_$as_cr_alnum]* ) as_fn_error $? "invalid variable name: \`$ac_envvar'" ;; esac eval $ac_envvar=\$ac_optarg export $ac_envvar ;; *) # FIXME: should be removed in autoconf 3.0. $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2 expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2 : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}" ;; esac done if test -n "$ac_prev"; then ac_option=--`echo $ac_prev | sed 's/_/-/g'` as_fn_error $? "missing argument to $ac_option" fi if test -n "$ac_unrecognized_opts"; then case $enable_option_checking in no) ;; fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;; *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; esac fi # Check all directory arguments for consistency. for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ datadir sysconfdir sharedstatedir localstatedir includedir \ oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ libdir localedir mandir do eval ac_val=\$$ac_var # Remove trailing slashes. case $ac_val in */ ) ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'` eval $ac_var=\$ac_val;; esac # Be sure to have absolute directory names. case $ac_val in [\\/$]* | ?:[\\/]* ) continue;; NONE | '' ) case $ac_var in *prefix ) continue;; esac;; esac as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val" done # There might be people who depend on the old broken behavior: `$host' # used to hold the argument of --host etc. # FIXME: To remove some day. build=$build_alias host=$host_alias target=$target_alias # FIXME: To remove some day. if test "x$host_alias" != x; then if test "x$build_alias" = x; then cross_compiling=maybe $as_echo "$as_me: WARNING: if you wanted to set the --build type, don't use --host. If a cross compiler is detected then cross compile mode will be used" >&2 elif test "x$build_alias" != "x$host_alias"; then cross_compiling=yes fi fi ac_tool_prefix= test -n "$host_alias" && ac_tool_prefix=$host_alias- test "$silent" = yes && exec 6>/dev/null ac_pwd=`pwd` && test -n "$ac_pwd" && ac_ls_di=`ls -di .` && ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` || as_fn_error $? "working directory cannot be determined" test "X$ac_ls_di" = "X$ac_pwd_ls_di" || as_fn_error $? "pwd does not report name of working directory" # Find the source files, if location was not specified. if test -z "$srcdir"; then ac_srcdir_defaulted=yes # Try the directory containing this script, then the parent directory. ac_confdir=`$as_dirname -- "$as_myself" || $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_myself" : 'X\(//\)[^/]' \| \ X"$as_myself" : 'X\(//\)$' \| \ X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_myself" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` srcdir=$ac_confdir if test ! -r "$srcdir/$ac_unique_file"; then srcdir=.. fi else ac_srcdir_defaulted=no fi if test ! -r "$srcdir/$ac_unique_file"; then test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .." as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir" fi ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work" ac_abs_confdir=`( cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg" pwd)` # When building in place, set srcdir=. if test "$ac_abs_confdir" = "$ac_pwd"; then srcdir=. fi # Remove unnecessary trailing slashes from srcdir. # Double slashes in file names in object file debugging info # mess up M-x gdb in Emacs. case $srcdir in */) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;; esac for ac_var in $ac_precious_vars; do eval ac_env_${ac_var}_set=\${${ac_var}+set} eval ac_env_${ac_var}_value=\$${ac_var} eval ac_cv_env_${ac_var}_set=\${${ac_var}+set} eval ac_cv_env_${ac_var}_value=\$${ac_var} done # # Report the --help message. # if test "$ac_init_help" = "long"; then # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF \`configure' configures Haskell HOpenAL package 1.3.1.3 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... To assign environment variables (e.g., CC, CFLAGS...), specify them as VAR=VALUE. See below for descriptions of some of the useful variables. Defaults for the options are specified in brackets. Configuration: -h, --help display this help and exit --help=short display options specific to this package --help=recursive display the short help of all the included packages -V, --version display version information and exit -q, --quiet, --silent do not print \`checking ...' messages --cache-file=FILE cache test results in FILE [disabled] -C, --config-cache alias for \`--cache-file=config.cache' -n, --no-create do not create output files --srcdir=DIR find the sources in DIR [configure dir or \`..'] Installation directories: --prefix=PREFIX install architecture-independent files in PREFIX [$ac_default_prefix] --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX [PREFIX] By default, \`make install' will install all the files in \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify an installation prefix other than \`$ac_default_prefix' using \`--prefix', for instance \`--prefix=\$HOME'. For better control, use the options below. Fine tuning of the installation directories: --bindir=DIR user executables [EPREFIX/bin] --sbindir=DIR system admin executables [EPREFIX/sbin] --libexecdir=DIR program executables [EPREFIX/libexec] --sysconfdir=DIR read-only single-machine data [PREFIX/etc] --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] --localstatedir=DIR modifiable single-machine data [PREFIX/var] --libdir=DIR object code libraries [EPREFIX/lib] --includedir=DIR C header files [PREFIX/include] --oldincludedir=DIR C header files for non-gcc [/usr/include] --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] --datadir=DIR read-only architecture-independent data [DATAROOTDIR] --infodir=DIR info documentation [DATAROOTDIR/info] --localedir=DIR locale-dependent data [DATAROOTDIR/locale] --mandir=DIR man documentation [DATAROOTDIR/man] --docdir=DIR documentation root [DATAROOTDIR/doc/OpenAL] --htmldir=DIR html documentation [DOCDIR] --dvidir=DIR dvi documentation [DOCDIR] --pdfdir=DIR pdf documentation [DOCDIR] --psdir=DIR ps documentation [DOCDIR] _ACEOF cat <<\_ACEOF System types: --build=BUILD configure for building on BUILD [guessed] --host=HOST cross-compile to build programs to run on HOST [BUILD] --target=TARGET configure for building compilers for TARGET [HOST] _ACEOF fi if test -n "$ac_init_help"; then case $ac_init_help in short | recursive ) echo "Configuration of Haskell HOpenAL package 1.3.1.3:";; esac cat <<\_ACEOF Optional Features: --disable-option-checking ignore unrecognized --enable/--with options --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) --enable-FEATURE[=ARG] include FEATURE [ARG=yes] --enable-openal build a Haskell binding for OpenAL (default=autodetect) Optional Packages: --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) --with-compiler[=HC] use the given Haskell compiler (default=ghc) Some influential environment variables: CC C compiler command CFLAGS C compiler flags LDFLAGS linker flags, e.g. -L if you have libraries in a nonstandard directory LIBS libraries to pass to the linker, e.g. -l CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I if you have headers in a nonstandard directory CPP C preprocessor Use these variables to override the choices made by `configure' or to help it to find libraries and programs with nonstandard names/locations. Report bugs to . _ACEOF ac_status=$? fi if test "$ac_init_help" = "recursive"; then # If there are subdirs, report their specific --help. for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue test -d "$ac_dir" || { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } || continue ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix # for backward compatibility: ac_top_builddir=$ac_top_build_prefix case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\\/]* | ?:[\\/]* ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix cd "$ac_dir" || { ac_status=$?; continue; } # Check for guested configure. if test -f "$ac_srcdir/configure.gnu"; then echo && $SHELL "$ac_srcdir/configure.gnu" --help=recursive elif test -f "$ac_srcdir/configure"; then echo && $SHELL "$ac_srcdir/configure" --help=recursive else $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 fi || ac_status=$? cd "$ac_pwd" || { ac_status=$?; break; } done fi test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF Haskell HOpenAL package configure 1.3.1.3 generated by GNU Autoconf 2.68 Copyright (C) 2010 Free Software Foundation, Inc. This configure script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it. _ACEOF exit fi ## ------------------------ ## ## Autoconf initialization. ## ## ------------------------ ## # ac_fn_c_try_compile LINENO # -------------------------- # Try to compile conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext if { { ac_try="$ac_compile" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_c_werror_flag" || test ! -s conftest.err } && test -s conftest.$ac_objext; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_compile # ac_fn_c_try_link LINENO # ----------------------- # Try to link conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_link () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext conftest$ac_exeext if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_c_werror_flag" || test ! -s conftest.err } && test -s conftest$ac_exeext && { test "$cross_compiling" = yes || $as_test_x conftest$ac_exeext }; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would # interfere with the next link command; also delete a directory that is # left behind by Apple's compiler. We do this before executing the actions. rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_link # ac_fn_c_try_cpp LINENO # ---------------------- # Try to preprocess conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_cpp () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if { { ac_try="$ac_cpp conftest.$ac_ext" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } > conftest.i && { test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || test ! -s conftest.err }; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_cpp # ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES # ------------------------------------------------------- # Tests whether HEADER exists, giving a warning if it cannot be compiled using # the include files in INCLUDES and setting the cache variable VAR # accordingly. ac_fn_c_check_header_mongrel () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if eval \${$3+:} false; then : { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } else # Is the header compilable? { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5 $as_echo_n "checking $2 usability... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 #include <$2> _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_header_compiler=yes else ac_header_compiler=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5 $as_echo "$ac_header_compiler" >&6; } # Is the header present? { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5 $as_echo_n "checking $2 presence... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include <$2> _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : ac_header_preproc=yes else ac_header_preproc=no fi rm -f conftest.err conftest.i conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5 $as_echo "$ac_header_preproc" >&6; } # So? What about this header? case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #(( yes:no: ) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} ;; no:yes:* ) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5 $as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5 $as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} ( $as_echo "## ----------------------------------- ## ## Report this to sven.panne@aedion.de ## ## ----------------------------------- ##" ) | sed "s/^/$as_me: WARNING: /" >&2 ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else eval "$3=\$ac_header_compiler" fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_header_mongrel # ac_fn_c_try_run LINENO # ---------------------- # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes # that executables *can* be run. ac_fn_c_try_run () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { ac_try='./conftest$ac_exeext' { { case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; }; then : ac_retval=0 else $as_echo "$as_me: program exited with status $ac_status" >&5 $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=$ac_status fi rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_run # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES # ------------------------------------------------------- # Tests whether HEADER exists and can be compiled using the include files in # INCLUDES, setting the cache variable VAR accordingly. ac_fn_c_check_header_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 #include <$2> _ACEOF if ac_fn_c_try_compile "$LINENO"; then : eval "$3=yes" else eval "$3=no" fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_header_compile # ac_fn_c_compute_int LINENO EXPR VAR INCLUDES # -------------------------------------------- # Tries to find the compile-time value of EXPR in a program that includes # INCLUDES, setting VAR accordingly. Returns whether the value could be # computed ac_fn_c_compute_int () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if test "$cross_compiling" = yes; then # Depending upon the size, compute the lo and hi bounds. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main () { static int test_array [1 - 2 * !(($2) >= 0)]; test_array [0] = 0 ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_lo=0 ac_mid=0 while :; do cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main () { static int test_array [1 - 2 * !(($2) <= $ac_mid)]; test_array [0] = 0 ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_hi=$ac_mid; break else as_fn_arith $ac_mid + 1 && ac_lo=$as_val if test $ac_lo -le $ac_mid; then ac_lo= ac_hi= break fi as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main () { static int test_array [1 - 2 * !(($2) < 0)]; test_array [0] = 0 ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_hi=-1 ac_mid=-1 while :; do cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main () { static int test_array [1 - 2 * !(($2) >= $ac_mid)]; test_array [0] = 0 ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_lo=$ac_mid; break else as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val if test $ac_mid -le $ac_hi; then ac_lo= ac_hi= break fi as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else ac_lo= ac_hi= fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext # Binary search between lo and hi bounds. while test "x$ac_lo" != "x$ac_hi"; do as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main () { static int test_array [1 - 2 * !(($2) <= $ac_mid)]; test_array [0] = 0 ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_hi=$ac_mid else as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done case $ac_lo in #(( ?*) eval "$3=\$ac_lo"; ac_retval=0 ;; '') ac_retval=1 ;; esac else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 static long int longval () { return $2; } static unsigned long int ulongval () { return $2; } #include #include int main () { FILE *f = fopen ("conftest.val", "w"); if (! f) return 1; if (($2) < 0) { long int i = longval (); if (i != ($2)) return 1; fprintf (f, "%ld", i); } else { unsigned long int i = ulongval (); if (i != ($2)) return 1; fprintf (f, "%lu", i); } /* Do not output a trailing newline, as this causes \r\n confusion on some platforms. */ return ferror (f) || fclose (f) != 0; ; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : echo >>conftest.val; read $3 config.log <<_ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. It was created by Haskell HOpenAL package $as_me 1.3.1.3, which was generated by GNU Autoconf 2.68. Invocation command line was $ $0 $@ _ACEOF exec 5>>config.log { cat <<_ASUNAME ## --------- ## ## Platform. ## ## --------- ## hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` uname -m = `(uname -m) 2>/dev/null || echo unknown` uname -r = `(uname -r) 2>/dev/null || echo unknown` uname -s = `(uname -s) 2>/dev/null || echo unknown` uname -v = `(uname -v) 2>/dev/null || echo unknown` /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` /bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` /bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` /usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown` /bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` /bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` _ASUNAME as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. $as_echo "PATH: $as_dir" done IFS=$as_save_IFS } >&5 cat >&5 <<_ACEOF ## ----------- ## ## Core tests. ## ## ----------- ## _ACEOF # Keep a trace of the command line. # Strip out --no-create and --no-recursion so they do not pile up. # Strip out --silent because we don't want to record it for future runs. # Also quote any args containing shell meta-characters. # Make two passes to allow for proper duplicate-argument suppression. ac_configure_args= ac_configure_args0= ac_configure_args1= ac_must_keep_next=false for ac_pass in 1 2 do for ac_arg do case $ac_arg in -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil) continue ;; *\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; esac case $ac_pass in 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;; 2) as_fn_append ac_configure_args1 " '$ac_arg'" if test $ac_must_keep_next = true; then ac_must_keep_next=false # Got value, back to normal. else case $ac_arg in *=* | --config-cache | -C | -disable-* | --disable-* \ | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ | -with-* | --with-* | -without-* | --without-* | --x) case "$ac_configure_args0 " in "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; esac ;; -* ) ac_must_keep_next=true ;; esac fi as_fn_append ac_configure_args " '$ac_arg'" ;; esac done done { ac_configure_args0=; unset ac_configure_args0;} { ac_configure_args1=; unset ac_configure_args1;} # When interrupted or exit'd, cleanup temporary files, and complete # config.log. We remove comments because anyway the quotes in there # would cause problems or look ugly. # WARNING: Use '\'' to represent an apostrophe within the trap. # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug. trap 'exit_status=$? # Save into config.log some information that might help in debugging. { echo $as_echo "## ---------------- ## ## Cache variables. ## ## ---------------- ##" echo # The following way of writing the cache mishandles newlines in values, ( for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do eval ac_val=\$$ac_var case $ac_val in #( *${as_nl}*) case $ac_var in #( *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; unset $ac_var;} ;; esac ;; esac done (set) 2>&1 | case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #( *${as_nl}ac_space=\ *) sed -n \ "s/'\''/'\''\\\\'\'''\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p" ;; #( *) sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | sort ) echo $as_echo "## ----------------- ## ## Output variables. ## ## ----------------- ##" echo for ac_var in $ac_subst_vars do eval ac_val=\$$ac_var case $ac_val in *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac $as_echo "$ac_var='\''$ac_val'\''" done | sort echo if test -n "$ac_subst_files"; then $as_echo "## ------------------- ## ## File substitutions. ## ## ------------------- ##" echo for ac_var in $ac_subst_files do eval ac_val=\$$ac_var case $ac_val in *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac $as_echo "$ac_var='\''$ac_val'\''" done | sort echo fi if test -s confdefs.h; then $as_echo "## ----------- ## ## confdefs.h. ## ## ----------- ##" echo cat confdefs.h echo fi test "$ac_signal" != 0 && $as_echo "$as_me: caught signal $ac_signal" $as_echo "$as_me: exit $exit_status" } >&5 rm -f core *.core core.conftest.* && rm -f -r conftest* confdefs* conf$$* $ac_clean_files && exit $exit_status ' 0 for ac_signal in 1 2 13 15; do trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal done ac_signal=0 # confdefs.h avoids OS command line length limits that DEFS can exceed. rm -f -r conftest* confdefs.h $as_echo "/* confdefs.h */" > confdefs.h # Predefined preprocessor variables. cat >>confdefs.h <<_ACEOF #define PACKAGE_NAME "$PACKAGE_NAME" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_TARNAME "$PACKAGE_TARNAME" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_VERSION "$PACKAGE_VERSION" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_STRING "$PACKAGE_STRING" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_URL "$PACKAGE_URL" _ACEOF # Let the site file select an alternate cache file if it wants to. # Prefer an explicitly selected file to automatically selected ones. ac_site_file1=NONE ac_site_file2=NONE if test -n "$CONFIG_SITE"; then # We do not want a PATH search for config.site. case $CONFIG_SITE in #(( -*) ac_site_file1=./$CONFIG_SITE;; */*) ac_site_file1=$CONFIG_SITE;; *) ac_site_file1=./$CONFIG_SITE;; esac elif test "x$prefix" != xNONE; then ac_site_file1=$prefix/share/config.site ac_site_file2=$prefix/etc/config.site else ac_site_file1=$ac_default_prefix/share/config.site ac_site_file2=$ac_default_prefix/etc/config.site fi for ac_site_file in "$ac_site_file1" "$ac_site_file2" do test "x$ac_site_file" = xNONE && continue if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 $as_echo "$as_me: loading site script $ac_site_file" >&6;} sed 's/^/| /' "$ac_site_file" >&5 . "$ac_site_file" \ || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "failed to load site script $ac_site_file See \`config.log' for more details" "$LINENO" 5; } fi done if test -r "$cache_file"; then # Some versions of bash will fail to source /dev/null (special files # actually), so we avoid doing that. DJGPP emulates it as a regular file. if test /dev/null != "$cache_file" && test -f "$cache_file"; then { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 $as_echo "$as_me: loading cache $cache_file" >&6;} case $cache_file in [\\/]* | ?:[\\/]* ) . "$cache_file";; *) . "./$cache_file";; esac fi else { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 $as_echo "$as_me: creating cache $cache_file" >&6;} >$cache_file fi # Check that the precious variables saved in the cache have kept the same # value. ac_cache_corrupted=false for ac_var in $ac_precious_vars; do eval ac_old_set=\$ac_cv_env_${ac_var}_set eval ac_new_set=\$ac_env_${ac_var}_set eval ac_old_val=\$ac_cv_env_${ac_var}_value eval ac_new_val=\$ac_env_${ac_var}_value case $ac_old_set,$ac_new_set in set,) { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} ac_cache_corrupted=: ;; ,set) { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5 $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} ac_cache_corrupted=: ;; ,);; *) if test "x$ac_old_val" != "x$ac_new_val"; then # differences in whitespace do not lead to failure. ac_old_val_w=`echo x $ac_old_val` ac_new_val_w=`echo x $ac_new_val` if test "$ac_old_val_w" != "$ac_new_val_w"; then { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5 $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} ac_cache_corrupted=: else { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5 $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;} eval $ac_var=\$ac_old_val fi { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5 $as_echo "$as_me: former value: \`$ac_old_val'" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5 $as_echo "$as_me: current value: \`$ac_new_val'" >&2;} fi;; esac # Pass precious variables to config.status. if test "$ac_new_set" = set; then case $ac_new_val in *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; *) ac_arg=$ac_var=$ac_new_val ;; esac case " $ac_configure_args " in *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. *) as_fn_append ac_configure_args " '$ac_arg'" ;; esac fi done if $ac_cache_corrupted; then { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;} as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5 fi ## -------------------- ## ## Main body of script. ## ## -------------------- ## ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu # Safety check: Ensure that we are in the correct source directory. # The first file mentioned below will be generated by autoheader and contains # defines which are needed during package build time only. The second header # contains all kinds of stuff which is needed for using this package. ac_config_headers="$ac_config_headers include/HsOpenALConfig.h include/HsOpenAL.h" # we do not really care about this here, but this avoids a warning about an # unknown option # Check whether --with-compiler was given. if test "${with_compiler+set}" = set; then : withval=$with_compiler; with_compiler=$withval else with_compiler=ghc fi # We set this to "yes" later when we have found OpenAL libs and headers. AL_BUILD_PACKAGE=no # Shall we build this package at all? # Check whether --enable-openal was given. if test "${enable_openal+set}" = set; then : enableval=$enable_openal; enable_openal=$enableval else enable_openal=yes fi if test x"$enable_openal" = xyes; then # Check for ALUT include paths and libraries ac_aux_dir= for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do if test -f "$ac_dir/install-sh"; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/install-sh -c" break elif test -f "$ac_dir/install.sh"; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/install.sh -c" break elif test -f "$ac_dir/shtool"; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/shtool install -c" break fi done if test -z "$ac_aux_dir"; then as_fn_error $? "cannot find install-sh, install.sh, or shtool in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" "$LINENO" 5 fi # These three variables are undocumented and unsupported, # and are intended to be withdrawn in a future Autoconf release. # They can cause serious problems if a builder's source tree is in a directory # whose full name contains unusual characters. ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var. ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var. ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var. # Make sure we can run config.sub. $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 || as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 $as_echo_n "checking build system type... " >&6; } if ${ac_cv_build+:} false; then : $as_echo_n "(cached) " >&6 else ac_build_alias=$build_alias test "x$ac_build_alias" = x && ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"` test "x$ac_build_alias" = x && as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` || as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5 fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5 $as_echo "$ac_cv_build" >&6; } case $ac_cv_build in *-*-*) ;; *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;; esac build=$ac_cv_build ac_save_IFS=$IFS; IFS='-' set x $ac_cv_build shift build_cpu=$1 build_vendor=$2 shift; shift # Remember, the first character of IFS is used to create $*, # except with old shells: build_os=$* IFS=$ac_save_IFS case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 $as_echo_n "checking host system type... " >&6; } if ${ac_cv_host+:} false; then : $as_echo_n "(cached) " >&6 else if test "x$host_alias" = x; then ac_cv_host=$ac_cv_build else ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` || as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5 fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5 $as_echo "$ac_cv_host" >&6; } case $ac_cv_host in *-*-*) ;; *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;; esac host=$ac_cv_host ac_save_IFS=$IFS; IFS='-' set x $ac_cv_host shift host_cpu=$1 host_vendor=$2 shift; shift # Remember, the first character of IFS is used to create $*, # except with old shells: host_os=$* IFS=$ac_save_IFS case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5 $as_echo_n "checking target system type... " >&6; } if ${ac_cv_target+:} false; then : $as_echo_n "(cached) " >&6 else if test "x$target_alias" = x; then ac_cv_target=$ac_cv_host else ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` || as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5 fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5 $as_echo "$ac_cv_target" >&6; } case $ac_cv_target in *-*-*) ;; *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;; esac target=$ac_cv_target ac_save_IFS=$IFS; IFS='-' set x $ac_cv_target shift target_cpu=$1 target_vendor=$2 shift; shift # Remember, the first character of IFS is used to create $*, # except with old shells: target_os=$* IFS=$ac_save_IFS case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac # The aliases save the names the user supplied, while $host etc. # will get canonicalized. test -n "$target_alias" && test "$program_prefix$program_suffix$program_transform_name" = \ NONENONEs,x,x, && program_prefix=${target_alias}- ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. set dummy ${ac_tool_prefix}gcc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_CC="${ac_tool_prefix}gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_prog_CC"; then ac_ct_CC=$CC # Extract the first word of "gcc", so it can be a program name with args. set dummy gcc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_ac_ct_CC="gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 $as_echo "$ac_ct_CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi else CC="$ac_cv_prog_CC" fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. set dummy ${ac_tool_prefix}cc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_CC="${ac_tool_prefix}cc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi fi if test -z "$CC"; then # Extract the first word of "cc", so it can be a program name with args. set dummy cc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else ac_prog_rejected=no as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then ac_prog_rejected=yes continue fi ac_cv_prog_CC="cc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS if test $ac_prog_rejected = yes; then # We found a bogon in the path, so make sure we never use it. set dummy $ac_cv_prog_CC shift if test $# != 0; then # We chose a different compiler from the bogus one. # However, it has the same basename, so the bogon will be chosen # first if we set CC to just the basename; use the full file name. shift ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@" fi fi fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then for ac_prog in cl.exe do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_CC="$ac_tool_prefix$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$CC" && break done fi if test -z "$CC"; then ac_ct_CC=$CC for ac_prog in cl.exe do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_ac_ct_CC="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 $as_echo "$ac_ct_CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$ac_ct_CC" && break done if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi fi fi test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "no acceptable C compiler found in \$PATH See \`config.log' for more details" "$LINENO" 5; } # Provide some information about the compiler. $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 set X $ac_compile ac_compiler=$2 for ac_option in --version -v -V -qversion; do { { ac_try="$ac_compiler $ac_option >&5" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compiler $ac_option >&5") 2>conftest.err ac_status=$? if test -s conftest.err; then sed '10a\ ... rest of stderr output deleted ... 10q' conftest.err >conftest.er1 cat conftest.er1 >&5 fi rm -f conftest.er1 conftest.err $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } done cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out" # Try to create an executable without -o first, disregard a.out. # It will help us diagnose broken compilers, and finding out an intuition # of exeext. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5 $as_echo_n "checking whether the C compiler works... " >&6; } ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'` # The possible output files: ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*" ac_rmfiles= for ac_file in $ac_files do case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; * ) ac_rmfiles="$ac_rmfiles $ac_file";; esac done rm -f $ac_rmfiles if { { ac_try="$ac_link_default" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link_default") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : # Autoconf-2.13 could set the ac_cv_exeext variable to `no'. # So ignore a value of `no', otherwise this would lead to `EXEEXT = no' # in a Makefile. We should not override ac_cv_exeext if it was cached, # so that the user can short-circuit this test for compilers unknown to # Autoconf. for ac_file in $ac_files '' do test -f "$ac_file" || continue case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; [ab].out ) # We found the default executable, but exeext='' is most # certainly right. break;; *.* ) if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no; then :; else ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` fi # We set ac_cv_exeext here because the later test for it is not # safe: cross compilers may not add the suffix if given an `-o' # argument, so we may need to know it at that point already. # Even if this section looks crufty: it has the advantage of # actually working. break;; * ) break;; esac done test "$ac_cv_exeext" = no && ac_cv_exeext= else ac_file='' fi if test -z "$ac_file"; then : { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error 77 "C compiler cannot create executables See \`config.log' for more details" "$LINENO" 5; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5 $as_echo_n "checking for C compiler default output file name... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 $as_echo "$ac_file" >&6; } ac_exeext=$ac_cv_exeext rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out ac_clean_files=$ac_clean_files_save { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 $as_echo_n "checking for suffix of executables... " >&6; } if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : # If both `conftest.exe' and `conftest' are `present' (well, observable) # catch `conftest.exe'. For instance with Cygwin, `ls conftest' will # work properly (i.e., refer to `conftest.exe'), while it won't with # `rm'. for ac_file in conftest.exe conftest conftest.*; do test -f "$ac_file" || continue case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` break;; * ) break;; esac done else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of executables: cannot compile and link See \`config.log' for more details" "$LINENO" 5; } fi rm -f conftest conftest$ac_cv_exeext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 $as_echo "$ac_cv_exeext" >&6; } rm -f conftest.$ac_ext EXEEXT=$ac_cv_exeext ac_exeext=$EXEEXT cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { FILE *f = fopen ("conftest.out", "w"); return ferror (f) || fclose (f) != 0; ; return 0; } _ACEOF ac_clean_files="$ac_clean_files conftest.out" # Check that the compiler produces executables we can run. If not, either # the compiler is broken, or we cross compile. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 $as_echo_n "checking whether we are cross compiling... " >&6; } if test "$cross_compiling" != yes; then { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } if { ac_try='./conftest$ac_cv_exeext' { { case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; }; then cross_compiling=no else if test "$cross_compiling" = maybe; then cross_compiling=yes else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot run C compiled programs. If you meant to cross compile, use \`--host'. See \`config.log' for more details" "$LINENO" 5; } fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 $as_echo "$cross_compiling" >&6; } rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out ac_clean_files=$ac_clean_files_save { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 $as_echo_n "checking for suffix of object files... " >&6; } if ${ac_cv_objext+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF rm -f conftest.o conftest.obj if { { ac_try="$ac_compile" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : for ac_file in conftest.o conftest.obj conftest.*; do test -f "$ac_file" || continue; case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;; *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` break;; esac done else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of object files: cannot compile See \`config.log' for more details" "$LINENO" 5; } fi rm -f conftest.$ac_cv_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 $as_echo "$ac_cv_objext" >&6; } OBJEXT=$ac_cv_objext ac_objext=$OBJEXT { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5 $as_echo_n "checking whether we are using the GNU C compiler... " >&6; } if ${ac_cv_c_compiler_gnu+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { #ifndef __GNUC__ choke me #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_compiler_gnu=yes else ac_compiler_gnu=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_cv_c_compiler_gnu=$ac_compiler_gnu fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 $as_echo "$ac_cv_c_compiler_gnu" >&6; } if test $ac_compiler_gnu = yes; then GCC=yes else GCC= fi ac_test_CFLAGS=${CFLAGS+set} ac_save_CFLAGS=$CFLAGS { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 $as_echo_n "checking whether $CC accepts -g... " >&6; } if ${ac_cv_prog_cc_g+:} false; then : $as_echo_n "(cached) " >&6 else ac_save_c_werror_flag=$ac_c_werror_flag ac_c_werror_flag=yes ac_cv_prog_cc_g=no CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_g=yes else CFLAGS="" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : else ac_c_werror_flag=$ac_save_c_werror_flag CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_g=yes fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_c_werror_flag=$ac_save_c_werror_flag fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 $as_echo "$ac_cv_prog_cc_g" >&6; } if test "$ac_test_CFLAGS" = set; then CFLAGS=$ac_save_CFLAGS elif test $ac_cv_prog_cc_g = yes; then if test "$GCC" = yes; then CFLAGS="-g -O2" else CFLAGS="-g" fi else if test "$GCC" = yes; then CFLAGS="-O2" else CFLAGS= fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 $as_echo_n "checking for $CC option to accept ISO C89... " >&6; } if ${ac_cv_prog_cc_c89+:} false; then : $as_echo_n "(cached) " >&6 else ac_cv_prog_cc_c89=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #include #include /* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ struct buf { int x; }; FILE * (*rcsopen) (struct buf *, struct stat *, int); static char *e (p, i) char **p; int i; { return p[i]; } static char *f (char * (*g) (char **, int), char **p, ...) { char *s; va_list v; va_start (v,p); s = g (p, va_arg (v,int)); va_end (v); return s; } /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has function prototypes and stuff, but not '\xHH' hex character constants. These don't provoke an error unfortunately, instead are silently treated as 'x'. The following induces an error, until -std is added to get proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an array size at least. It's necessary to write '\x00'==0 to get something that's true only with -std. */ int osf4_cc_array ['\x00' == 0 ? 1 : -1]; /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters inside strings and character constants. */ #define FOO(x) 'x' int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; int test (int i, double x); struct s1 {int (*f) (int a);}; struct s2 {int (*f) (double a);}; int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); int argc; char **argv; int main () { return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; ; return 0; } _ACEOF for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" do CC="$ac_save_CC $ac_arg" if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_c89=$ac_arg fi rm -f core conftest.err conftest.$ac_objext test "x$ac_cv_prog_cc_c89" != "xno" && break done rm -f conftest.$ac_ext CC=$ac_save_CC fi # AC_CACHE_VAL case "x$ac_cv_prog_cc_c89" in x) { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 $as_echo "none needed" >&6; } ;; xno) { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 $as_echo "unsupported" >&6; } ;; *) CC="$CC $ac_cv_prog_cc_c89" { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 $as_echo "$ac_cv_prog_cc_c89" >&6; } ;; esac if test "x$ac_cv_prog_cc_c89" != xno; then : fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu AL_CFLAGS= case $target_os in darwin*) AL_LIBS= AL_FRAMEWORKS=OpenAL ;; *) { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing alGenSources" >&5 $as_echo_n "checking for library containing alGenSources... " >&6; } if ${ac_cv_search_alGenSources+:} false; then : $as_echo_n "(cached) " >&6 else ac_func_search_save_LIBS=$LIBS cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char alGenSources (); int main () { return alGenSources (); ; return 0; } _ACEOF for ac_lib in '' openal openal32; do if test -z "$ac_lib"; then ac_res="none required" else ac_res=-l$ac_lib LIBS="-l$ac_lib $ac_func_search_save_LIBS" fi if ac_fn_c_try_link "$LINENO"; then : ac_cv_search_alGenSources=$ac_res fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext if ${ac_cv_search_alGenSources+:} false; then : break fi done if ${ac_cv_search_alGenSources+:} false; then : else ac_cv_search_alGenSources=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_alGenSources" >&5 $as_echo "$ac_cv_search_alGenSources" >&6; } ac_res=$ac_cv_search_alGenSources if test "$ac_res" != no; then : test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" AL_LIBS="$ac_cv_search_alGenSources" fi test x"$AL_LIBS" = x"none required" && AL_LIBS= AL_FRAMEWORKS= ;; esac if test "$AL_LIBS" = no; then { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "no OpenAL library found, so this package cannot be built See \`config.log' for more details" "$LINENO" 5; } fi AL_LIBS_PLAIN=`echo "$AL_LIBS" | sed -e s/-l//` # check for ALUT include files ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 $as_echo_n "checking how to run the C preprocessor... " >&6; } # On Suns, sometimes $CPP names a directory. if test -n "$CPP" && test -d "$CPP"; then CPP= fi if test -z "$CPP"; then if ${ac_cv_prog_CPP+:} false; then : $as_echo_n "(cached) " >&6 else # Double quotes because CPP needs to be expanded for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" do ac_preproc_ok=false for ac_c_preproc_warn_flag in '' yes do # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. # Prefer to if __STDC__ is defined, since # exists even on freestanding compilers. # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. "Syntax error" is here to catch this case. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifdef __STDC__ # include #else # include #endif Syntax error _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : else # Broken: fails on valid input. continue fi rm -f conftest.err conftest.i conftest.$ac_ext # OK, works on sane cases. Now check whether nonexistent headers # can be detected and how. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : # Broken: success on invalid input. continue else # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i conftest.err conftest.$ac_ext if $ac_preproc_ok; then : break fi done ac_cv_prog_CPP=$CPP fi CPP=$ac_cv_prog_CPP else ac_cv_prog_CPP=$CPP fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 $as_echo "$CPP" >&6; } ac_preproc_ok=false for ac_c_preproc_warn_flag in '' yes do # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. # Prefer to if __STDC__ is defined, since # exists even on freestanding compilers. # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. "Syntax error" is here to catch this case. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifdef __STDC__ # include #else # include #endif Syntax error _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : else # Broken: fails on valid input. continue fi rm -f conftest.err conftest.i conftest.$ac_ext # OK, works on sane cases. Now check whether nonexistent headers # can be detected and how. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : # Broken: success on invalid input. continue else # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i conftest.err conftest.$ac_ext if $ac_preproc_ok; then : else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "C preprocessor \"$CPP\" fails sanity check See \`config.log' for more details" "$LINENO" 5; } fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 $as_echo_n "checking for grep that handles long lines and -e... " >&6; } if ${ac_cv_path_GREP+:} false; then : $as_echo_n "(cached) " >&6 else if test -z "$GREP"; then ac_path_GREP_found=false # Loop through the user's path and test for each of PROGNAME-LIST as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_prog in grep ggrep; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext" { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue # Check for GNU ac_path_GREP and select it if it is found. # Check for GNU $ac_path_GREP case `"$ac_path_GREP" --version 2>&1` in *GNU*) ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; *) ac_count=0 $as_echo_n 0123456789 >"conftest.in" while : do cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" $as_echo 'GREP' >> "conftest.nl" "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val if test $ac_count -gt ${ac_path_GREP_max-0}; then # Best one so far, save it but keep looking for a better one ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_max=$ac_count fi # 10*(2^10) chars as input seems more than enough test $ac_count -gt 10 && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out;; esac $ac_path_GREP_found && break 3 done done done IFS=$as_save_IFS if test -z "$ac_cv_path_GREP"; then as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 fi else ac_cv_path_GREP=$GREP fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 $as_echo "$ac_cv_path_GREP" >&6; } GREP="$ac_cv_path_GREP" { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 $as_echo_n "checking for egrep... " >&6; } if ${ac_cv_path_EGREP+:} false; then : $as_echo_n "(cached) " >&6 else if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 then ac_cv_path_EGREP="$GREP -E" else if test -z "$EGREP"; then ac_path_EGREP_found=false # Loop through the user's path and test for each of PROGNAME-LIST as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_prog in egrep; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext" { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue # Check for GNU ac_path_EGREP and select it if it is found. # Check for GNU $ac_path_EGREP case `"$ac_path_EGREP" --version 2>&1` in *GNU*) ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; *) ac_count=0 $as_echo_n 0123456789 >"conftest.in" while : do cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" $as_echo 'EGREP' >> "conftest.nl" "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val if test $ac_count -gt ${ac_path_EGREP_max-0}; then # Best one so far, save it but keep looking for a better one ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_max=$ac_count fi # 10*(2^10) chars as input seems more than enough test $ac_count -gt 10 && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out;; esac $ac_path_EGREP_found && break 3 done done done IFS=$as_save_IFS if test -z "$ac_cv_path_EGREP"; then as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 fi else ac_cv_path_EGREP=$EGREP fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 $as_echo "$ac_cv_path_EGREP" >&6; } EGREP="$ac_cv_path_EGREP" { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 $as_echo_n "checking for ANSI C header files... " >&6; } if ${ac_cv_header_stdc+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #include #include int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_header_stdc=yes else ac_cv_header_stdc=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext if test $ac_cv_header_stdc = yes; then # SunOS 4.x string.h does not declare mem*, contrary to ANSI. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | $EGREP "memchr" >/dev/null 2>&1; then : else ac_cv_header_stdc=no fi rm -f conftest* fi if test $ac_cv_header_stdc = yes; then # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | $EGREP "free" >/dev/null 2>&1; then : else ac_cv_header_stdc=no fi rm -f conftest* fi if test $ac_cv_header_stdc = yes; then # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. if test "$cross_compiling" = yes; then : : else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #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)) return 2; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : else ac_cv_header_stdc=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5 $as_echo "$ac_cv_header_stdc" >&6; } if test $ac_cv_header_stdc = yes; then $as_echo "#define STDC_HEADERS 1" >>confdefs.h fi # On IRIX 5.3, sys/types and inttypes.h are conflicting. for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ inttypes.h stdint.h unistd.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default " if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF fi done if test -z "$fp_found_al_header"; then fp_found_al_header=no for ac_header in AL/al.h OpenAL/al.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default" if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF fp_found_al_header=yes; break fi done fi if test -z "$fp_found_alc_header"; then fp_found_alc_header=no for ac_header in AL/alc.h OpenAL/alc.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default" if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF fp_found_alc_header=yes; break fi done fi if test x"$fp_found_al_header" = xno || test x"$fp_found_alc_header" = xno; then { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "no OpenAL headers found, so this package cannot be built See \`config.log' for more details" "$LINENO" 5; } fi AL_BUILD_PACKAGE=yes for ac_header in AL/alext.h OpenAL/alext.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default" if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF break fi done { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether alcCloseDevice returns void" >&5 $as_echo_n "checking whether alcCloseDevice returns void... " >&6; } if ${fp_cv_func_alcclosedevice_void+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default #if defined(HAVE_AL_ALC_H) #include #elif defined(HAVE_OPENAL_ALC_H) #include #endif int main () { int x = (int)alcCloseDevice(NULL); ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : fp_cv_func_alcclosedevice_void=no else fp_cv_func_alcclosedevice_void=yes fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fp_cv_func_alcclosedevice_void" >&5 $as_echo "$fp_cv_func_alcclosedevice_void" >&6; } if test x"$fp_cv_func_alcclosedevice_void" = xyes; then $as_echo "#define ALCCLOSEDEVICE_VOID 1" >>confdefs.h fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether alcMakeContextCurrent returns void" >&5 $as_echo_n "checking whether alcMakeContextCurrent returns void... " >&6; } if ${fp_cv_func_alcmakecontextcurrent_void+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default #if defined(HAVE_AL_ALC_H) #include #elif defined(HAVE_OPENAL_ALC_H) #include #endif int main () { int x = (int)alcMakeContextCurrent(NULL); ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : fp_cv_func_alcmakecontextcurrent_void=no else fp_cv_func_alcmakecontextcurrent_void=yes fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fp_cv_func_alcmakecontextcurrent_void" >&5 $as_echo "$fp_cv_func_alcmakecontextcurrent_void" >&6; } if test x"$fp_cv_func_alcmakecontextcurrent_void)" = xyes; then $as_echo "#define ALCMAKECONTEXTCURRENT_VOID 1" >>confdefs.h fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether alcProcessContext returns void" >&5 $as_echo_n "checking whether alcProcessContext returns void... " >&6; } if ${fp_cv_func_alcprocesscontext_void+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default #if defined(HAVE_AL_ALC_H) #include #elif defined(HAVE_OPENAL_ALC_H) #include #endif int main () { int x = (int)alcProcessContext(NULL); ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : fp_cv_func_alcprocesscontext_void=no else fp_cv_func_alcprocesscontext_void=yes fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fp_cv_func_alcprocesscontext_void" >&5 $as_echo "$fp_cv_func_alcprocesscontext_void" >&6; } if test x"$fp_cv_func_alcprocesscontext_void" = xyes; then $as_echo "#define ALCPROCESSCONTEXT_VOID 1" >>confdefs.h fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether alcDestroyContext returns void" >&5 $as_echo_n "checking whether alcDestroyContext returns void... " >&6; } if ${fp_cv_func_alcdestroycontext_void+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default #if defined(HAVE_AL_ALC_H) #include #elif defined(HAVE_OPENAL_ALC_H) #include #endif int main () { int x = (int)alcDestroyContext(NULL); ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : fp_cv_func_alcdestroycontext_void=no else fp_cv_func_alcdestroycontext_void=yes fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fp_cv_func_alcdestroycontext_void" >&5 $as_echo "$fp_cv_func_alcdestroycontext_void" >&6; } if test x"$fp_cv_func_alcdestroycontext_void" = xyes; then $as_echo "#define ALCDESTROYCONTEXT_VOID 1" >>confdefs.h fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking Haskell type for ALboolean" >&5 $as_echo_n "checking Haskell type for ALboolean... " >&6; } if ${fptools_cv_htype_ALboolean+:} false; then : $as_echo_n "(cached) " >&6 else fptools_cv_htype_sup_ALboolean=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then : fptools_cv_htype_ALboolean=NotReallyATypeCross; fptools_cv_htype_sup_ALboolean=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if HAVE_SYS_TYPES_H # include #endif #if HAVE_UNISTD_H # include #endif #if HAVE_SYS_STAT_H # include #endif #if HAVE_FCNTL_H # include #endif #if HAVE_SIGNAL_H # include #endif #if HAVE_TIME_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_STRING_H # include #endif #if HAVE_CTYPE_H # include #endif #if defined(HAVE_GL_GL_H) # include #elif defined(HAVE_OPENGL_GL_H) # include #endif #if defined(HAVE_AL_AL_H) # include #elif defined(HAVE_OPENAL_AL_H) # include #endif #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) # include #endif #if HAVE_SYS_RESOURCE_H # include #endif typedef ALboolean testing; main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { fprintf(f, "%s%d\n", ((testing)(-1) < (testing)0) ? "Int" : "Word", sizeof(testing)*8); } else { fprintf(f,"%s\n", (sizeof(testing) > sizeof(double)) ? "LDouble" : (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); } fclose(f); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : fptools_cv_htype_ALboolean=`cat conftestval` else fptools_cv_htype_ALboolean=NotReallyAType; fptools_cv_htype_sup_ALboolean=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi CPPFLAGS="$fp_check_htype_save_cppflags" fi if test "$fptools_cv_htype_sup_ALboolean" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fptools_cv_htype_ALboolean" >&5 $as_echo "$fptools_cv_htype_ALboolean" >&6; } cat >>confdefs.h <<_ACEOF #define HTYPE_ALBOOLEAN $fptools_cv_htype_ALboolean _ACEOF else { $as_echo "$as_me:${as_lineno-$LINENO}: result: not supported" >&5 $as_echo "not supported" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking Haskell type for ALchar" >&5 $as_echo_n "checking Haskell type for ALchar... " >&6; } if ${fptools_cv_htype_ALchar+:} false; then : $as_echo_n "(cached) " >&6 else fptools_cv_htype_sup_ALchar=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then : fptools_cv_htype_ALchar=NotReallyATypeCross; fptools_cv_htype_sup_ALchar=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if HAVE_SYS_TYPES_H # include #endif #if HAVE_UNISTD_H # include #endif #if HAVE_SYS_STAT_H # include #endif #if HAVE_FCNTL_H # include #endif #if HAVE_SIGNAL_H # include #endif #if HAVE_TIME_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_STRING_H # include #endif #if HAVE_CTYPE_H # include #endif #if defined(HAVE_GL_GL_H) # include #elif defined(HAVE_OPENGL_GL_H) # include #endif #if defined(HAVE_AL_AL_H) # include #elif defined(HAVE_OPENAL_AL_H) # include #endif #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) # include #endif #if HAVE_SYS_RESOURCE_H # include #endif typedef ALchar testing; main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { fprintf(f, "%s%d\n", ((testing)(-1) < (testing)0) ? "Int" : "Word", sizeof(testing)*8); } else { fprintf(f,"%s\n", (sizeof(testing) > sizeof(double)) ? "LDouble" : (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); } fclose(f); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : fptools_cv_htype_ALchar=`cat conftestval` else fptools_cv_htype_ALchar=Int8 fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi CPPFLAGS="$fp_check_htype_save_cppflags" fi if test "$fptools_cv_htype_sup_ALchar" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fptools_cv_htype_ALchar" >&5 $as_echo "$fptools_cv_htype_ALchar" >&6; } cat >>confdefs.h <<_ACEOF #define HTYPE_ALCHAR $fptools_cv_htype_ALchar _ACEOF else { $as_echo "$as_me:${as_lineno-$LINENO}: result: not supported" >&5 $as_echo "not supported" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking Haskell type for ALbyte" >&5 $as_echo_n "checking Haskell type for ALbyte... " >&6; } if ${fptools_cv_htype_ALbyte+:} false; then : $as_echo_n "(cached) " >&6 else fptools_cv_htype_sup_ALbyte=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then : fptools_cv_htype_ALbyte=NotReallyATypeCross; fptools_cv_htype_sup_ALbyte=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if HAVE_SYS_TYPES_H # include #endif #if HAVE_UNISTD_H # include #endif #if HAVE_SYS_STAT_H # include #endif #if HAVE_FCNTL_H # include #endif #if HAVE_SIGNAL_H # include #endif #if HAVE_TIME_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_STRING_H # include #endif #if HAVE_CTYPE_H # include #endif #if defined(HAVE_GL_GL_H) # include #elif defined(HAVE_OPENGL_GL_H) # include #endif #if defined(HAVE_AL_AL_H) # include #elif defined(HAVE_OPENAL_AL_H) # include #endif #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) # include #endif #if HAVE_SYS_RESOURCE_H # include #endif typedef ALbyte testing; main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { fprintf(f, "%s%d\n", ((testing)(-1) < (testing)0) ? "Int" : "Word", sizeof(testing)*8); } else { fprintf(f,"%s\n", (sizeof(testing) > sizeof(double)) ? "LDouble" : (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); } fclose(f); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : fptools_cv_htype_ALbyte=`cat conftestval` else fptools_cv_htype_ALbyte=NotReallyAType; fptools_cv_htype_sup_ALbyte=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi CPPFLAGS="$fp_check_htype_save_cppflags" fi if test "$fptools_cv_htype_sup_ALbyte" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fptools_cv_htype_ALbyte" >&5 $as_echo "$fptools_cv_htype_ALbyte" >&6; } cat >>confdefs.h <<_ACEOF #define HTYPE_ALBYTE $fptools_cv_htype_ALbyte _ACEOF else { $as_echo "$as_me:${as_lineno-$LINENO}: result: not supported" >&5 $as_echo "not supported" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking Haskell type for ALubyte" >&5 $as_echo_n "checking Haskell type for ALubyte... " >&6; } if ${fptools_cv_htype_ALubyte+:} false; then : $as_echo_n "(cached) " >&6 else fptools_cv_htype_sup_ALubyte=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then : fptools_cv_htype_ALubyte=NotReallyATypeCross; fptools_cv_htype_sup_ALubyte=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if HAVE_SYS_TYPES_H # include #endif #if HAVE_UNISTD_H # include #endif #if HAVE_SYS_STAT_H # include #endif #if HAVE_FCNTL_H # include #endif #if HAVE_SIGNAL_H # include #endif #if HAVE_TIME_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_STRING_H # include #endif #if HAVE_CTYPE_H # include #endif #if defined(HAVE_GL_GL_H) # include #elif defined(HAVE_OPENGL_GL_H) # include #endif #if defined(HAVE_AL_AL_H) # include #elif defined(HAVE_OPENAL_AL_H) # include #endif #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) # include #endif #if HAVE_SYS_RESOURCE_H # include #endif typedef ALubyte testing; main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { fprintf(f, "%s%d\n", ((testing)(-1) < (testing)0) ? "Int" : "Word", sizeof(testing)*8); } else { fprintf(f,"%s\n", (sizeof(testing) > sizeof(double)) ? "LDouble" : (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); } fclose(f); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : fptools_cv_htype_ALubyte=`cat conftestval` else fptools_cv_htype_ALubyte=NotReallyAType; fptools_cv_htype_sup_ALubyte=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi CPPFLAGS="$fp_check_htype_save_cppflags" fi if test "$fptools_cv_htype_sup_ALubyte" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fptools_cv_htype_ALubyte" >&5 $as_echo "$fptools_cv_htype_ALubyte" >&6; } cat >>confdefs.h <<_ACEOF #define HTYPE_ALUBYTE $fptools_cv_htype_ALubyte _ACEOF else { $as_echo "$as_me:${as_lineno-$LINENO}: result: not supported" >&5 $as_echo "not supported" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking Haskell type for ALshort" >&5 $as_echo_n "checking Haskell type for ALshort... " >&6; } if ${fptools_cv_htype_ALshort+:} false; then : $as_echo_n "(cached) " >&6 else fptools_cv_htype_sup_ALshort=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then : fptools_cv_htype_ALshort=NotReallyATypeCross; fptools_cv_htype_sup_ALshort=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if HAVE_SYS_TYPES_H # include #endif #if HAVE_UNISTD_H # include #endif #if HAVE_SYS_STAT_H # include #endif #if HAVE_FCNTL_H # include #endif #if HAVE_SIGNAL_H # include #endif #if HAVE_TIME_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_STRING_H # include #endif #if HAVE_CTYPE_H # include #endif #if defined(HAVE_GL_GL_H) # include #elif defined(HAVE_OPENGL_GL_H) # include #endif #if defined(HAVE_AL_AL_H) # include #elif defined(HAVE_OPENAL_AL_H) # include #endif #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) # include #endif #if HAVE_SYS_RESOURCE_H # include #endif typedef ALshort testing; main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { fprintf(f, "%s%d\n", ((testing)(-1) < (testing)0) ? "Int" : "Word", sizeof(testing)*8); } else { fprintf(f,"%s\n", (sizeof(testing) > sizeof(double)) ? "LDouble" : (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); } fclose(f); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : fptools_cv_htype_ALshort=`cat conftestval` else fptools_cv_htype_ALshort=NotReallyAType; fptools_cv_htype_sup_ALshort=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi CPPFLAGS="$fp_check_htype_save_cppflags" fi if test "$fptools_cv_htype_sup_ALshort" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fptools_cv_htype_ALshort" >&5 $as_echo "$fptools_cv_htype_ALshort" >&6; } cat >>confdefs.h <<_ACEOF #define HTYPE_ALSHORT $fptools_cv_htype_ALshort _ACEOF else { $as_echo "$as_me:${as_lineno-$LINENO}: result: not supported" >&5 $as_echo "not supported" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking Haskell type for ALushort" >&5 $as_echo_n "checking Haskell type for ALushort... " >&6; } if ${fptools_cv_htype_ALushort+:} false; then : $as_echo_n "(cached) " >&6 else fptools_cv_htype_sup_ALushort=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then : fptools_cv_htype_ALushort=NotReallyATypeCross; fptools_cv_htype_sup_ALushort=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if HAVE_SYS_TYPES_H # include #endif #if HAVE_UNISTD_H # include #endif #if HAVE_SYS_STAT_H # include #endif #if HAVE_FCNTL_H # include #endif #if HAVE_SIGNAL_H # include #endif #if HAVE_TIME_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_STRING_H # include #endif #if HAVE_CTYPE_H # include #endif #if defined(HAVE_GL_GL_H) # include #elif defined(HAVE_OPENGL_GL_H) # include #endif #if defined(HAVE_AL_AL_H) # include #elif defined(HAVE_OPENAL_AL_H) # include #endif #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) # include #endif #if HAVE_SYS_RESOURCE_H # include #endif typedef ALushort testing; main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { fprintf(f, "%s%d\n", ((testing)(-1) < (testing)0) ? "Int" : "Word", sizeof(testing)*8); } else { fprintf(f,"%s\n", (sizeof(testing) > sizeof(double)) ? "LDouble" : (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); } fclose(f); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : fptools_cv_htype_ALushort=`cat conftestval` else fptools_cv_htype_ALushort=NotReallyAType; fptools_cv_htype_sup_ALushort=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi CPPFLAGS="$fp_check_htype_save_cppflags" fi if test "$fptools_cv_htype_sup_ALushort" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fptools_cv_htype_ALushort" >&5 $as_echo "$fptools_cv_htype_ALushort" >&6; } cat >>confdefs.h <<_ACEOF #define HTYPE_ALUSHORT $fptools_cv_htype_ALushort _ACEOF else { $as_echo "$as_me:${as_lineno-$LINENO}: result: not supported" >&5 $as_echo "not supported" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking Haskell type for ALint" >&5 $as_echo_n "checking Haskell type for ALint... " >&6; } if ${fptools_cv_htype_ALint+:} false; then : $as_echo_n "(cached) " >&6 else fptools_cv_htype_sup_ALint=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then : fptools_cv_htype_ALint=NotReallyATypeCross; fptools_cv_htype_sup_ALint=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if HAVE_SYS_TYPES_H # include #endif #if HAVE_UNISTD_H # include #endif #if HAVE_SYS_STAT_H # include #endif #if HAVE_FCNTL_H # include #endif #if HAVE_SIGNAL_H # include #endif #if HAVE_TIME_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_STRING_H # include #endif #if HAVE_CTYPE_H # include #endif #if defined(HAVE_GL_GL_H) # include #elif defined(HAVE_OPENGL_GL_H) # include #endif #if defined(HAVE_AL_AL_H) # include #elif defined(HAVE_OPENAL_AL_H) # include #endif #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) # include #endif #if HAVE_SYS_RESOURCE_H # include #endif typedef ALint testing; main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { fprintf(f, "%s%d\n", ((testing)(-1) < (testing)0) ? "Int" : "Word", sizeof(testing)*8); } else { fprintf(f,"%s\n", (sizeof(testing) > sizeof(double)) ? "LDouble" : (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); } fclose(f); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : fptools_cv_htype_ALint=`cat conftestval` else fptools_cv_htype_ALint=NotReallyAType; fptools_cv_htype_sup_ALint=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi CPPFLAGS="$fp_check_htype_save_cppflags" fi if test "$fptools_cv_htype_sup_ALint" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fptools_cv_htype_ALint" >&5 $as_echo "$fptools_cv_htype_ALint" >&6; } cat >>confdefs.h <<_ACEOF #define HTYPE_ALINT $fptools_cv_htype_ALint _ACEOF else { $as_echo "$as_me:${as_lineno-$LINENO}: result: not supported" >&5 $as_echo "not supported" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking Haskell type for ALuint" >&5 $as_echo_n "checking Haskell type for ALuint... " >&6; } if ${fptools_cv_htype_ALuint+:} false; then : $as_echo_n "(cached) " >&6 else fptools_cv_htype_sup_ALuint=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then : fptools_cv_htype_ALuint=NotReallyATypeCross; fptools_cv_htype_sup_ALuint=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if HAVE_SYS_TYPES_H # include #endif #if HAVE_UNISTD_H # include #endif #if HAVE_SYS_STAT_H # include #endif #if HAVE_FCNTL_H # include #endif #if HAVE_SIGNAL_H # include #endif #if HAVE_TIME_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_STRING_H # include #endif #if HAVE_CTYPE_H # include #endif #if defined(HAVE_GL_GL_H) # include #elif defined(HAVE_OPENGL_GL_H) # include #endif #if defined(HAVE_AL_AL_H) # include #elif defined(HAVE_OPENAL_AL_H) # include #endif #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) # include #endif #if HAVE_SYS_RESOURCE_H # include #endif typedef ALuint testing; main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { fprintf(f, "%s%d\n", ((testing)(-1) < (testing)0) ? "Int" : "Word", sizeof(testing)*8); } else { fprintf(f,"%s\n", (sizeof(testing) > sizeof(double)) ? "LDouble" : (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); } fclose(f); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : fptools_cv_htype_ALuint=`cat conftestval` else fptools_cv_htype_ALuint=NotReallyAType; fptools_cv_htype_sup_ALuint=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi CPPFLAGS="$fp_check_htype_save_cppflags" fi if test "$fptools_cv_htype_sup_ALuint" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fptools_cv_htype_ALuint" >&5 $as_echo "$fptools_cv_htype_ALuint" >&6; } cat >>confdefs.h <<_ACEOF #define HTYPE_ALUINT $fptools_cv_htype_ALuint _ACEOF else { $as_echo "$as_me:${as_lineno-$LINENO}: result: not supported" >&5 $as_echo "not supported" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking Haskell type for ALsizei" >&5 $as_echo_n "checking Haskell type for ALsizei... " >&6; } if ${fptools_cv_htype_ALsizei+:} false; then : $as_echo_n "(cached) " >&6 else fptools_cv_htype_sup_ALsizei=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then : fptools_cv_htype_ALsizei=NotReallyATypeCross; fptools_cv_htype_sup_ALsizei=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if HAVE_SYS_TYPES_H # include #endif #if HAVE_UNISTD_H # include #endif #if HAVE_SYS_STAT_H # include #endif #if HAVE_FCNTL_H # include #endif #if HAVE_SIGNAL_H # include #endif #if HAVE_TIME_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_STRING_H # include #endif #if HAVE_CTYPE_H # include #endif #if defined(HAVE_GL_GL_H) # include #elif defined(HAVE_OPENGL_GL_H) # include #endif #if defined(HAVE_AL_AL_H) # include #elif defined(HAVE_OPENAL_AL_H) # include #endif #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) # include #endif #if HAVE_SYS_RESOURCE_H # include #endif typedef ALsizei testing; main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { fprintf(f, "%s%d\n", ((testing)(-1) < (testing)0) ? "Int" : "Word", sizeof(testing)*8); } else { fprintf(f,"%s\n", (sizeof(testing) > sizeof(double)) ? "LDouble" : (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); } fclose(f); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : fptools_cv_htype_ALsizei=`cat conftestval` else fptools_cv_htype_ALsizei=NotReallyAType; fptools_cv_htype_sup_ALsizei=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi CPPFLAGS="$fp_check_htype_save_cppflags" fi if test "$fptools_cv_htype_sup_ALsizei" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fptools_cv_htype_ALsizei" >&5 $as_echo "$fptools_cv_htype_ALsizei" >&6; } cat >>confdefs.h <<_ACEOF #define HTYPE_ALSIZEI $fptools_cv_htype_ALsizei _ACEOF else { $as_echo "$as_me:${as_lineno-$LINENO}: result: not supported" >&5 $as_echo "not supported" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking Haskell type for ALenum" >&5 $as_echo_n "checking Haskell type for ALenum... " >&6; } if ${fptools_cv_htype_ALenum+:} false; then : $as_echo_n "(cached) " >&6 else fptools_cv_htype_sup_ALenum=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then : fptools_cv_htype_ALenum=NotReallyATypeCross; fptools_cv_htype_sup_ALenum=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if HAVE_SYS_TYPES_H # include #endif #if HAVE_UNISTD_H # include #endif #if HAVE_SYS_STAT_H # include #endif #if HAVE_FCNTL_H # include #endif #if HAVE_SIGNAL_H # include #endif #if HAVE_TIME_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_STRING_H # include #endif #if HAVE_CTYPE_H # include #endif #if defined(HAVE_GL_GL_H) # include #elif defined(HAVE_OPENGL_GL_H) # include #endif #if defined(HAVE_AL_AL_H) # include #elif defined(HAVE_OPENAL_AL_H) # include #endif #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) # include #endif #if HAVE_SYS_RESOURCE_H # include #endif typedef ALenum testing; main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { fprintf(f, "%s%d\n", ((testing)(-1) < (testing)0) ? "Int" : "Word", sizeof(testing)*8); } else { fprintf(f,"%s\n", (sizeof(testing) > sizeof(double)) ? "LDouble" : (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); } fclose(f); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : fptools_cv_htype_ALenum=`cat conftestval` else fptools_cv_htype_ALenum=NotReallyAType; fptools_cv_htype_sup_ALenum=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi CPPFLAGS="$fp_check_htype_save_cppflags" fi if test "$fptools_cv_htype_sup_ALenum" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fptools_cv_htype_ALenum" >&5 $as_echo "$fptools_cv_htype_ALenum" >&6; } cat >>confdefs.h <<_ACEOF #define HTYPE_ALENUM $fptools_cv_htype_ALenum _ACEOF else { $as_echo "$as_me:${as_lineno-$LINENO}: result: not supported" >&5 $as_echo "not supported" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking Haskell type for ALfloat" >&5 $as_echo_n "checking Haskell type for ALfloat... " >&6; } if ${fptools_cv_htype_ALfloat+:} false; then : $as_echo_n "(cached) " >&6 else fptools_cv_htype_sup_ALfloat=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then : fptools_cv_htype_ALfloat=NotReallyATypeCross; fptools_cv_htype_sup_ALfloat=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if HAVE_SYS_TYPES_H # include #endif #if HAVE_UNISTD_H # include #endif #if HAVE_SYS_STAT_H # include #endif #if HAVE_FCNTL_H # include #endif #if HAVE_SIGNAL_H # include #endif #if HAVE_TIME_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_STRING_H # include #endif #if HAVE_CTYPE_H # include #endif #if defined(HAVE_GL_GL_H) # include #elif defined(HAVE_OPENGL_GL_H) # include #endif #if defined(HAVE_AL_AL_H) # include #elif defined(HAVE_OPENAL_AL_H) # include #endif #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) # include #endif #if HAVE_SYS_RESOURCE_H # include #endif typedef ALfloat testing; main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { fprintf(f, "%s%d\n", ((testing)(-1) < (testing)0) ? "Int" : "Word", sizeof(testing)*8); } else { fprintf(f,"%s\n", (sizeof(testing) > sizeof(double)) ? "LDouble" : (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); } fclose(f); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : fptools_cv_htype_ALfloat=`cat conftestval` else fptools_cv_htype_ALfloat=NotReallyAType; fptools_cv_htype_sup_ALfloat=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi CPPFLAGS="$fp_check_htype_save_cppflags" fi if test "$fptools_cv_htype_sup_ALfloat" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fptools_cv_htype_ALfloat" >&5 $as_echo "$fptools_cv_htype_ALfloat" >&6; } cat >>confdefs.h <<_ACEOF #define HTYPE_ALFLOAT $fptools_cv_htype_ALfloat _ACEOF else { $as_echo "$as_me:${as_lineno-$LINENO}: result: not supported" >&5 $as_echo "not supported" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking Haskell type for ALdouble" >&5 $as_echo_n "checking Haskell type for ALdouble... " >&6; } if ${fptools_cv_htype_ALdouble+:} false; then : $as_echo_n "(cached) " >&6 else fptools_cv_htype_sup_ALdouble=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then : fptools_cv_htype_ALdouble=NotReallyATypeCross; fptools_cv_htype_sup_ALdouble=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if HAVE_SYS_TYPES_H # include #endif #if HAVE_UNISTD_H # include #endif #if HAVE_SYS_STAT_H # include #endif #if HAVE_FCNTL_H # include #endif #if HAVE_SIGNAL_H # include #endif #if HAVE_TIME_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_STRING_H # include #endif #if HAVE_CTYPE_H # include #endif #if defined(HAVE_GL_GL_H) # include #elif defined(HAVE_OPENGL_GL_H) # include #endif #if defined(HAVE_AL_AL_H) # include #elif defined(HAVE_OPENAL_AL_H) # include #endif #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) # include #endif #if HAVE_SYS_RESOURCE_H # include #endif typedef ALdouble testing; main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { fprintf(f, "%s%d\n", ((testing)(-1) < (testing)0) ? "Int" : "Word", sizeof(testing)*8); } else { fprintf(f,"%s\n", (sizeof(testing) > sizeof(double)) ? "LDouble" : (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); } fclose(f); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : fptools_cv_htype_ALdouble=`cat conftestval` else fptools_cv_htype_ALdouble=NotReallyAType; fptools_cv_htype_sup_ALdouble=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi CPPFLAGS="$fp_check_htype_save_cppflags" fi if test "$fptools_cv_htype_sup_ALdouble" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fptools_cv_htype_ALdouble" >&5 $as_echo "$fptools_cv_htype_ALdouble" >&6; } cat >>confdefs.h <<_ACEOF #define HTYPE_ALDOUBLE $fptools_cv_htype_ALdouble _ACEOF else { $as_echo "$as_me:${as_lineno-$LINENO}: result: not supported" >&5 $as_echo "not supported" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking Haskell type for ALCboolean" >&5 $as_echo_n "checking Haskell type for ALCboolean... " >&6; } if ${fptools_cv_htype_ALCboolean+:} false; then : $as_echo_n "(cached) " >&6 else fptools_cv_htype_sup_ALCboolean=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then : fptools_cv_htype_ALCboolean=NotReallyATypeCross; fptools_cv_htype_sup_ALCboolean=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if HAVE_SYS_TYPES_H # include #endif #if HAVE_UNISTD_H # include #endif #if HAVE_SYS_STAT_H # include #endif #if HAVE_FCNTL_H # include #endif #if HAVE_SIGNAL_H # include #endif #if HAVE_TIME_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_STRING_H # include #endif #if HAVE_CTYPE_H # include #endif #if defined(HAVE_GL_GL_H) # include #elif defined(HAVE_OPENGL_GL_H) # include #endif #if defined(HAVE_AL_AL_H) # include #elif defined(HAVE_OPENAL_AL_H) # include #endif #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) # include #endif #if HAVE_SYS_RESOURCE_H # include #endif typedef ALCboolean testing; main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { fprintf(f, "%s%d\n", ((testing)(-1) < (testing)0) ? "Int" : "Word", sizeof(testing)*8); } else { fprintf(f,"%s\n", (sizeof(testing) > sizeof(double)) ? "LDouble" : (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); } fclose(f); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : fptools_cv_htype_ALCboolean=`cat conftestval` else fptools_cv_htype_ALCboolean=Int8 fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi CPPFLAGS="$fp_check_htype_save_cppflags" fi if test "$fptools_cv_htype_sup_ALCboolean" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fptools_cv_htype_ALCboolean" >&5 $as_echo "$fptools_cv_htype_ALCboolean" >&6; } cat >>confdefs.h <<_ACEOF #define HTYPE_ALCBOOLEAN $fptools_cv_htype_ALCboolean _ACEOF else { $as_echo "$as_me:${as_lineno-$LINENO}: result: not supported" >&5 $as_echo "not supported" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking Haskell type for ALCchar" >&5 $as_echo_n "checking Haskell type for ALCchar... " >&6; } if ${fptools_cv_htype_ALCchar+:} false; then : $as_echo_n "(cached) " >&6 else fptools_cv_htype_sup_ALCchar=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then : fptools_cv_htype_ALCchar=NotReallyATypeCross; fptools_cv_htype_sup_ALCchar=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if HAVE_SYS_TYPES_H # include #endif #if HAVE_UNISTD_H # include #endif #if HAVE_SYS_STAT_H # include #endif #if HAVE_FCNTL_H # include #endif #if HAVE_SIGNAL_H # include #endif #if HAVE_TIME_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_STRING_H # include #endif #if HAVE_CTYPE_H # include #endif #if defined(HAVE_GL_GL_H) # include #elif defined(HAVE_OPENGL_GL_H) # include #endif #if defined(HAVE_AL_AL_H) # include #elif defined(HAVE_OPENAL_AL_H) # include #endif #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) # include #endif #if HAVE_SYS_RESOURCE_H # include #endif typedef ALCchar testing; main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { fprintf(f, "%s%d\n", ((testing)(-1) < (testing)0) ? "Int" : "Word", sizeof(testing)*8); } else { fprintf(f,"%s\n", (sizeof(testing) > sizeof(double)) ? "LDouble" : (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); } fclose(f); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : fptools_cv_htype_ALCchar=`cat conftestval` else fptools_cv_htype_ALCchar=Int8 fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi CPPFLAGS="$fp_check_htype_save_cppflags" fi if test "$fptools_cv_htype_sup_ALCchar" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fptools_cv_htype_ALCchar" >&5 $as_echo "$fptools_cv_htype_ALCchar" >&6; } cat >>confdefs.h <<_ACEOF #define HTYPE_ALCCHAR $fptools_cv_htype_ALCchar _ACEOF else { $as_echo "$as_me:${as_lineno-$LINENO}: result: not supported" >&5 $as_echo "not supported" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking Haskell type for ALCbyte" >&5 $as_echo_n "checking Haskell type for ALCbyte... " >&6; } if ${fptools_cv_htype_ALCbyte+:} false; then : $as_echo_n "(cached) " >&6 else fptools_cv_htype_sup_ALCbyte=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then : fptools_cv_htype_ALCbyte=NotReallyATypeCross; fptools_cv_htype_sup_ALCbyte=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if HAVE_SYS_TYPES_H # include #endif #if HAVE_UNISTD_H # include #endif #if HAVE_SYS_STAT_H # include #endif #if HAVE_FCNTL_H # include #endif #if HAVE_SIGNAL_H # include #endif #if HAVE_TIME_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_STRING_H # include #endif #if HAVE_CTYPE_H # include #endif #if defined(HAVE_GL_GL_H) # include #elif defined(HAVE_OPENGL_GL_H) # include #endif #if defined(HAVE_AL_AL_H) # include #elif defined(HAVE_OPENAL_AL_H) # include #endif #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) # include #endif #if HAVE_SYS_RESOURCE_H # include #endif typedef ALCbyte testing; main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { fprintf(f, "%s%d\n", ((testing)(-1) < (testing)0) ? "Int" : "Word", sizeof(testing)*8); } else { fprintf(f,"%s\n", (sizeof(testing) > sizeof(double)) ? "LDouble" : (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); } fclose(f); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : fptools_cv_htype_ALCbyte=`cat conftestval` else fptools_cv_htype_ALCbyte=Int8 fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi CPPFLAGS="$fp_check_htype_save_cppflags" fi if test "$fptools_cv_htype_sup_ALCbyte" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fptools_cv_htype_ALCbyte" >&5 $as_echo "$fptools_cv_htype_ALCbyte" >&6; } cat >>confdefs.h <<_ACEOF #define HTYPE_ALCBYTE $fptools_cv_htype_ALCbyte _ACEOF else { $as_echo "$as_me:${as_lineno-$LINENO}: result: not supported" >&5 $as_echo "not supported" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking Haskell type for ALCubyte" >&5 $as_echo_n "checking Haskell type for ALCubyte... " >&6; } if ${fptools_cv_htype_ALCubyte+:} false; then : $as_echo_n "(cached) " >&6 else fptools_cv_htype_sup_ALCubyte=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then : fptools_cv_htype_ALCubyte=NotReallyATypeCross; fptools_cv_htype_sup_ALCubyte=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if HAVE_SYS_TYPES_H # include #endif #if HAVE_UNISTD_H # include #endif #if HAVE_SYS_STAT_H # include #endif #if HAVE_FCNTL_H # include #endif #if HAVE_SIGNAL_H # include #endif #if HAVE_TIME_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_STRING_H # include #endif #if HAVE_CTYPE_H # include #endif #if defined(HAVE_GL_GL_H) # include #elif defined(HAVE_OPENGL_GL_H) # include #endif #if defined(HAVE_AL_AL_H) # include #elif defined(HAVE_OPENAL_AL_H) # include #endif #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) # include #endif #if HAVE_SYS_RESOURCE_H # include #endif typedef ALCubyte testing; main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { fprintf(f, "%s%d\n", ((testing)(-1) < (testing)0) ? "Int" : "Word", sizeof(testing)*8); } else { fprintf(f,"%s\n", (sizeof(testing) > sizeof(double)) ? "LDouble" : (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); } fclose(f); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : fptools_cv_htype_ALCubyte=`cat conftestval` else fptools_cv_htype_ALCubyte=Word8 fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi CPPFLAGS="$fp_check_htype_save_cppflags" fi if test "$fptools_cv_htype_sup_ALCubyte" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fptools_cv_htype_ALCubyte" >&5 $as_echo "$fptools_cv_htype_ALCubyte" >&6; } cat >>confdefs.h <<_ACEOF #define HTYPE_ALCUBYTE $fptools_cv_htype_ALCubyte _ACEOF else { $as_echo "$as_me:${as_lineno-$LINENO}: result: not supported" >&5 $as_echo "not supported" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking Haskell type for ALCshort" >&5 $as_echo_n "checking Haskell type for ALCshort... " >&6; } if ${fptools_cv_htype_ALCshort+:} false; then : $as_echo_n "(cached) " >&6 else fptools_cv_htype_sup_ALCshort=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then : fptools_cv_htype_ALCshort=NotReallyATypeCross; fptools_cv_htype_sup_ALCshort=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if HAVE_SYS_TYPES_H # include #endif #if HAVE_UNISTD_H # include #endif #if HAVE_SYS_STAT_H # include #endif #if HAVE_FCNTL_H # include #endif #if HAVE_SIGNAL_H # include #endif #if HAVE_TIME_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_STRING_H # include #endif #if HAVE_CTYPE_H # include #endif #if defined(HAVE_GL_GL_H) # include #elif defined(HAVE_OPENGL_GL_H) # include #endif #if defined(HAVE_AL_AL_H) # include #elif defined(HAVE_OPENAL_AL_H) # include #endif #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) # include #endif #if HAVE_SYS_RESOURCE_H # include #endif typedef ALCshort testing; main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { fprintf(f, "%s%d\n", ((testing)(-1) < (testing)0) ? "Int" : "Word", sizeof(testing)*8); } else { fprintf(f,"%s\n", (sizeof(testing) > sizeof(double)) ? "LDouble" : (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); } fclose(f); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : fptools_cv_htype_ALCshort=`cat conftestval` else fptools_cv_htype_ALCshort=Int16 fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi CPPFLAGS="$fp_check_htype_save_cppflags" fi if test "$fptools_cv_htype_sup_ALCshort" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fptools_cv_htype_ALCshort" >&5 $as_echo "$fptools_cv_htype_ALCshort" >&6; } cat >>confdefs.h <<_ACEOF #define HTYPE_ALCSHORT $fptools_cv_htype_ALCshort _ACEOF else { $as_echo "$as_me:${as_lineno-$LINENO}: result: not supported" >&5 $as_echo "not supported" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking Haskell type for ALCushort" >&5 $as_echo_n "checking Haskell type for ALCushort... " >&6; } if ${fptools_cv_htype_ALCushort+:} false; then : $as_echo_n "(cached) " >&6 else fptools_cv_htype_sup_ALCushort=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then : fptools_cv_htype_ALCushort=NotReallyATypeCross; fptools_cv_htype_sup_ALCushort=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if HAVE_SYS_TYPES_H # include #endif #if HAVE_UNISTD_H # include #endif #if HAVE_SYS_STAT_H # include #endif #if HAVE_FCNTL_H # include #endif #if HAVE_SIGNAL_H # include #endif #if HAVE_TIME_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_STRING_H # include #endif #if HAVE_CTYPE_H # include #endif #if defined(HAVE_GL_GL_H) # include #elif defined(HAVE_OPENGL_GL_H) # include #endif #if defined(HAVE_AL_AL_H) # include #elif defined(HAVE_OPENAL_AL_H) # include #endif #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) # include #endif #if HAVE_SYS_RESOURCE_H # include #endif typedef ALCushort testing; main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { fprintf(f, "%s%d\n", ((testing)(-1) < (testing)0) ? "Int" : "Word", sizeof(testing)*8); } else { fprintf(f,"%s\n", (sizeof(testing) > sizeof(double)) ? "LDouble" : (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); } fclose(f); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : fptools_cv_htype_ALCushort=`cat conftestval` else fptools_cv_htype_ALCushort=Word16 fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi CPPFLAGS="$fp_check_htype_save_cppflags" fi if test "$fptools_cv_htype_sup_ALCushort" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fptools_cv_htype_ALCushort" >&5 $as_echo "$fptools_cv_htype_ALCushort" >&6; } cat >>confdefs.h <<_ACEOF #define HTYPE_ALCUSHORT $fptools_cv_htype_ALCushort _ACEOF else { $as_echo "$as_me:${as_lineno-$LINENO}: result: not supported" >&5 $as_echo "not supported" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking Haskell type for ALCint" >&5 $as_echo_n "checking Haskell type for ALCint... " >&6; } if ${fptools_cv_htype_ALCint+:} false; then : $as_echo_n "(cached) " >&6 else fptools_cv_htype_sup_ALCint=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then : fptools_cv_htype_ALCint=NotReallyATypeCross; fptools_cv_htype_sup_ALCint=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if HAVE_SYS_TYPES_H # include #endif #if HAVE_UNISTD_H # include #endif #if HAVE_SYS_STAT_H # include #endif #if HAVE_FCNTL_H # include #endif #if HAVE_SIGNAL_H # include #endif #if HAVE_TIME_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_STRING_H # include #endif #if HAVE_CTYPE_H # include #endif #if defined(HAVE_GL_GL_H) # include #elif defined(HAVE_OPENGL_GL_H) # include #endif #if defined(HAVE_AL_AL_H) # include #elif defined(HAVE_OPENAL_AL_H) # include #endif #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) # include #endif #if HAVE_SYS_RESOURCE_H # include #endif typedef ALCint testing; main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { fprintf(f, "%s%d\n", ((testing)(-1) < (testing)0) ? "Int" : "Word", sizeof(testing)*8); } else { fprintf(f,"%s\n", (sizeof(testing) > sizeof(double)) ? "LDouble" : (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); } fclose(f); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : fptools_cv_htype_ALCint=`cat conftestval` else fptools_cv_htype_ALCint=Int32 fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi CPPFLAGS="$fp_check_htype_save_cppflags" fi if test "$fptools_cv_htype_sup_ALCint" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fptools_cv_htype_ALCint" >&5 $as_echo "$fptools_cv_htype_ALCint" >&6; } cat >>confdefs.h <<_ACEOF #define HTYPE_ALCINT $fptools_cv_htype_ALCint _ACEOF else { $as_echo "$as_me:${as_lineno-$LINENO}: result: not supported" >&5 $as_echo "not supported" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking Haskell type for ALCuint" >&5 $as_echo_n "checking Haskell type for ALCuint... " >&6; } if ${fptools_cv_htype_ALCuint+:} false; then : $as_echo_n "(cached) " >&6 else fptools_cv_htype_sup_ALCuint=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then : fptools_cv_htype_ALCuint=NotReallyATypeCross; fptools_cv_htype_sup_ALCuint=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if HAVE_SYS_TYPES_H # include #endif #if HAVE_UNISTD_H # include #endif #if HAVE_SYS_STAT_H # include #endif #if HAVE_FCNTL_H # include #endif #if HAVE_SIGNAL_H # include #endif #if HAVE_TIME_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_STRING_H # include #endif #if HAVE_CTYPE_H # include #endif #if defined(HAVE_GL_GL_H) # include #elif defined(HAVE_OPENGL_GL_H) # include #endif #if defined(HAVE_AL_AL_H) # include #elif defined(HAVE_OPENAL_AL_H) # include #endif #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) # include #endif #if HAVE_SYS_RESOURCE_H # include #endif typedef ALCuint testing; main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { fprintf(f, "%s%d\n", ((testing)(-1) < (testing)0) ? "Int" : "Word", sizeof(testing)*8); } else { fprintf(f,"%s\n", (sizeof(testing) > sizeof(double)) ? "LDouble" : (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); } fclose(f); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : fptools_cv_htype_ALCuint=`cat conftestval` else fptools_cv_htype_ALCuint=Word32 fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi CPPFLAGS="$fp_check_htype_save_cppflags" fi if test "$fptools_cv_htype_sup_ALCuint" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fptools_cv_htype_ALCuint" >&5 $as_echo "$fptools_cv_htype_ALCuint" >&6; } cat >>confdefs.h <<_ACEOF #define HTYPE_ALCUINT $fptools_cv_htype_ALCuint _ACEOF else { $as_echo "$as_me:${as_lineno-$LINENO}: result: not supported" >&5 $as_echo "not supported" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking Haskell type for ALCsizei" >&5 $as_echo_n "checking Haskell type for ALCsizei... " >&6; } if ${fptools_cv_htype_ALCsizei+:} false; then : $as_echo_n "(cached) " >&6 else fptools_cv_htype_sup_ALCsizei=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then : fptools_cv_htype_ALCsizei=NotReallyATypeCross; fptools_cv_htype_sup_ALCsizei=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if HAVE_SYS_TYPES_H # include #endif #if HAVE_UNISTD_H # include #endif #if HAVE_SYS_STAT_H # include #endif #if HAVE_FCNTL_H # include #endif #if HAVE_SIGNAL_H # include #endif #if HAVE_TIME_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_STRING_H # include #endif #if HAVE_CTYPE_H # include #endif #if defined(HAVE_GL_GL_H) # include #elif defined(HAVE_OPENGL_GL_H) # include #endif #if defined(HAVE_AL_AL_H) # include #elif defined(HAVE_OPENAL_AL_H) # include #endif #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) # include #endif #if HAVE_SYS_RESOURCE_H # include #endif typedef ALCsizei testing; main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { fprintf(f, "%s%d\n", ((testing)(-1) < (testing)0) ? "Int" : "Word", sizeof(testing)*8); } else { fprintf(f,"%s\n", (sizeof(testing) > sizeof(double)) ? "LDouble" : (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); } fclose(f); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : fptools_cv_htype_ALCsizei=`cat conftestval` else fptools_cv_htype_ALCsizei=Int32 fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi CPPFLAGS="$fp_check_htype_save_cppflags" fi if test "$fptools_cv_htype_sup_ALCsizei" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fptools_cv_htype_ALCsizei" >&5 $as_echo "$fptools_cv_htype_ALCsizei" >&6; } cat >>confdefs.h <<_ACEOF #define HTYPE_ALCSIZEI $fptools_cv_htype_ALCsizei _ACEOF else { $as_echo "$as_me:${as_lineno-$LINENO}: result: not supported" >&5 $as_echo "not supported" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking Haskell type for ALCenum" >&5 $as_echo_n "checking Haskell type for ALCenum... " >&6; } if ${fptools_cv_htype_ALCenum+:} false; then : $as_echo_n "(cached) " >&6 else fptools_cv_htype_sup_ALCenum=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then : fptools_cv_htype_ALCenum=NotReallyATypeCross; fptools_cv_htype_sup_ALCenum=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if HAVE_SYS_TYPES_H # include #endif #if HAVE_UNISTD_H # include #endif #if HAVE_SYS_STAT_H # include #endif #if HAVE_FCNTL_H # include #endif #if HAVE_SIGNAL_H # include #endif #if HAVE_TIME_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_STRING_H # include #endif #if HAVE_CTYPE_H # include #endif #if defined(HAVE_GL_GL_H) # include #elif defined(HAVE_OPENGL_GL_H) # include #endif #if defined(HAVE_AL_AL_H) # include #elif defined(HAVE_OPENAL_AL_H) # include #endif #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) # include #endif #if HAVE_SYS_RESOURCE_H # include #endif typedef ALCenum testing; main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { fprintf(f, "%s%d\n", ((testing)(-1) < (testing)0) ? "Int" : "Word", sizeof(testing)*8); } else { fprintf(f,"%s\n", (sizeof(testing) > sizeof(double)) ? "LDouble" : (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); } fclose(f); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : fptools_cv_htype_ALCenum=`cat conftestval` else fptools_cv_htype_ALCenum=Int32 fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi CPPFLAGS="$fp_check_htype_save_cppflags" fi if test "$fptools_cv_htype_sup_ALCenum" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fptools_cv_htype_ALCenum" >&5 $as_echo "$fptools_cv_htype_ALCenum" >&6; } cat >>confdefs.h <<_ACEOF #define HTYPE_ALCENUM $fptools_cv_htype_ALCenum _ACEOF else { $as_echo "$as_me:${as_lineno-$LINENO}: result: not supported" >&5 $as_echo "not supported" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking Haskell type for ALCfloat" >&5 $as_echo_n "checking Haskell type for ALCfloat... " >&6; } if ${fptools_cv_htype_ALCfloat+:} false; then : $as_echo_n "(cached) " >&6 else fptools_cv_htype_sup_ALCfloat=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then : fptools_cv_htype_ALCfloat=NotReallyATypeCross; fptools_cv_htype_sup_ALCfloat=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if HAVE_SYS_TYPES_H # include #endif #if HAVE_UNISTD_H # include #endif #if HAVE_SYS_STAT_H # include #endif #if HAVE_FCNTL_H # include #endif #if HAVE_SIGNAL_H # include #endif #if HAVE_TIME_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_STRING_H # include #endif #if HAVE_CTYPE_H # include #endif #if defined(HAVE_GL_GL_H) # include #elif defined(HAVE_OPENGL_GL_H) # include #endif #if defined(HAVE_AL_AL_H) # include #elif defined(HAVE_OPENAL_AL_H) # include #endif #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) # include #endif #if HAVE_SYS_RESOURCE_H # include #endif typedef ALCfloat testing; main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { fprintf(f, "%s%d\n", ((testing)(-1) < (testing)0) ? "Int" : "Word", sizeof(testing)*8); } else { fprintf(f,"%s\n", (sizeof(testing) > sizeof(double)) ? "LDouble" : (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); } fclose(f); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : fptools_cv_htype_ALCfloat=`cat conftestval` else fptools_cv_htype_ALCfloat=Float fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi CPPFLAGS="$fp_check_htype_save_cppflags" fi if test "$fptools_cv_htype_sup_ALCfloat" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fptools_cv_htype_ALCfloat" >&5 $as_echo "$fptools_cv_htype_ALCfloat" >&6; } cat >>confdefs.h <<_ACEOF #define HTYPE_ALCFLOAT $fptools_cv_htype_ALCfloat _ACEOF else { $as_echo "$as_me:${as_lineno-$LINENO}: result: not supported" >&5 $as_echo "not supported" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking Haskell type for ALCdouble" >&5 $as_echo_n "checking Haskell type for ALCdouble... " >&6; } if ${fptools_cv_htype_ALCdouble+:} false; then : $as_echo_n "(cached) " >&6 else fptools_cv_htype_sup_ALCdouble=yes fp_check_htype_save_cppflags="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $X_CFLAGS" if test "$cross_compiling" = yes; then : fptools_cv_htype_ALCdouble=NotReallyATypeCross; fptools_cv_htype_sup_ALCdouble=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if HAVE_SYS_TYPES_H # include #endif #if HAVE_UNISTD_H # include #endif #if HAVE_SYS_STAT_H # include #endif #if HAVE_FCNTL_H # include #endif #if HAVE_SIGNAL_H # include #endif #if HAVE_TIME_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_STRING_H # include #endif #if HAVE_CTYPE_H # include #endif #if defined(HAVE_GL_GL_H) # include #elif defined(HAVE_OPENGL_GL_H) # include #endif #if defined(HAVE_AL_AL_H) # include #elif defined(HAVE_OPENAL_AL_H) # include #endif #if defined(HAVE_AL_ALC_H) # include #elif defined(HAVE_OPENAL_ALC_H) # include #endif #if HAVE_SYS_RESOURCE_H # include #endif typedef ALCdouble testing; main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); if (((testing)((int)((testing)1.4))) == ((testing)1.4)) { fprintf(f, "%s%d\n", ((testing)(-1) < (testing)0) ? "Int" : "Word", sizeof(testing)*8); } else { fprintf(f,"%s\n", (sizeof(testing) > sizeof(double)) ? "LDouble" : (sizeof(testing) == sizeof(double)) ? "Double" : "Float"); } fclose(f); exit(0); } _ACEOF if ac_fn_c_try_run "$LINENO"; then : fptools_cv_htype_ALCdouble=`cat conftestval` else fptools_cv_htype_ALCdouble=Double fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi CPPFLAGS="$fp_check_htype_save_cppflags" fi if test "$fptools_cv_htype_sup_ALCdouble" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $fptools_cv_htype_ALCdouble" >&5 $as_echo "$fptools_cv_htype_ALCdouble" >&6; } cat >>confdefs.h <<_ACEOF #define HTYPE_ALCDOUBLE $fptools_cv_htype_ALCdouble _ACEOF else { $as_echo "$as_me:${as_lineno-$LINENO}: result: not supported" >&5 $as_echo "not supported" >&6; } fi for fp_const_name in AL_FALSE AL_TRUE AL_NO_ERROR AL_INVALID_NAME AL_INVALID_ENUM AL_INVALID_VALUE AL_INVALID_OPERATION AL_OUT_OF_MEMORY AL_DOPPLER_FACTOR AL_SPEED_OF_SOUND AL_DISTANCE_MODEL AL_VERSION AL_RENDERER AL_VENDOR AL_EXTENSIONS AL_NONE AL_INVERSE_DISTANCE AL_INVERSE_DISTANCE_CLAMPED AL_LINEAR_DISTANCE AL_LINEAR_DISTANCE_CLAMPED AL_EXPONENT_DISTANCE AL_EXPONENT_DISTANCE_CLAMPED AL_POSITION AL_VELOCITY AL_GAIN AL_ORIENTATION AL_SOURCE_RELATIVE AL_SOURCE_TYPE AL_LOOPING AL_BUFFER AL_BUFFERS_QUEUED AL_BUFFERS_PROCESSED AL_MIN_GAIN AL_MAX_GAIN AL_REFERENCE_DISTANCE AL_ROLLOFF_FACTOR AL_MAX_DISTANCE AL_PITCH AL_DIRECTION AL_CONE_INNER_ANGLE AL_CONE_OUTER_ANGLE AL_CONE_OUTER_GAIN AL_SEC_OFFSET AL_SAMPLE_OFFSET AL_BYTE_OFFSET AL_SOURCE_STATE AL_UNDETERMINED AL_STATIC AL_STREAMING AL_INITIAL AL_PLAYING AL_PAUSED AL_STOPPED AL_FREQUENCY AL_SIZE AL_BITS AL_CHANNELS AL_FORMAT_MONO8 AL_FORMAT_MONO16 AL_FORMAT_STEREO8 AL_FORMAT_STEREO16 ALC_FALSE ALC_TRUE ALC_FREQUENCY ALC_REFRESH ALC_SYNC ALC_MONO_SOURCES ALC_STEREO_SOURCES ALC_NO_ERROR ALC_INVALID_DEVICE ALC_INVALID_CONTEXT ALC_INVALID_ENUM ALC_INVALID_VALUE ALC_INVALID_OPERATION ALC_OUT_OF_MEMORY ALC_DEFAULT_DEVICE_SPECIFIER ALC_DEVICE_SPECIFIER ALC_EXTENSIONS ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER ALC_CAPTURE_DEVICE_SPECIFIER ALC_ATTRIBUTES_SIZE ALC_ALL_ATTRIBUTES ALC_MAJOR_VERSION ALC_MINOR_VERSION ALC_CAPTURE_SAMPLES do as_fp_Cache=`$as_echo "fp_cv_const_$fp_const_name" | $as_tr_sh` { $as_echo "$as_me:${as_lineno-$LINENO}: checking value of $fp_const_name" >&5 $as_echo_n "checking value of $fp_const_name... " >&6; } if eval \${$as_fp_Cache+:} false; then : $as_echo_n "(cached) " >&6 else if ac_fn_c_compute_int "$LINENO" "$fp_const_name" "fp_check_const_result" "#include #if defined(HAVE_AL_AL_H) #include #elif defined(HAVE_OPENAL_AL_H) #include #endif #if defined(HAVE_AL_ALC_H) #include #elif defined(HAVE_OPENAL_ALC_H) #include #endif #if defined(HAVE_AL_ALEXT_H) #include #elif defined(HAVE_OPENAL_ALEXT_H) #include #endif #ifndef AL_SPEED_OF_SOUND #define AL_SPEED_OF_SOUND 0xC003 #endif #ifndef AL_LINEAR_DISTANCE #define AL_LINEAR_DISTANCE 0xD003 #endif #ifndef AL_LINEAR_DISTANCE_CLAMPED #define AL_LINEAR_DISTANCE_CLAMPED 0xD004 #endif #ifndef AL_EXPONENT_DISTANCE #define AL_EXPONENT_DISTANCE 0xD005 #endif #ifndef AL_EXPONENT_DISTANCE_CLAMPED #define AL_EXPONENT_DISTANCE_CLAMPED 0xD006 #endif #ifndef AL_SEC_OFFSET #define AL_SEC_OFFSET 0x1024 #endif #ifndef AL_SAMPLE_OFFSET #define AL_SAMPLE_OFFSET 0x1025 #endif #ifndef AL_BYTE_OFFSET #define AL_BYTE_OFFSET 0x1026 #endif #ifndef AL_UNDETERMINED #define AL_UNDETERMINED 0x1030 #endif #ifndef AL_STATIC #define AL_STATIC 0x1028 #endif #ifndef ALC_MONO_SOURCES #define ALC_MONO_SOURCES 0x1010 #endif #ifndef ALC_STEREO_SOURCES #define ALC_STEREO_SOURCES 0x1011 #endif #ifndef AL_INVALID_ENUM #ifdef AL_ILLEGAL_ENUM #define AL_INVALID_ENUM AL_ILLEGAL_ENUM #else #define AL_INVALID_ENUM 0xA002 #endif #endif #ifndef AL_INVALID_OPERATION #ifdef AL_ILLEGAL_COMMAND #define AL_INVALID_OPERATION AL_ILLEGAL_COMMAND #else #define AL_INVALID_OPERATION 0xA004 #endif #endif /* NOTE: THIS IS NOT IN ANY HEADER */ #ifndef ALC_INVALID_OPERATION #define ALC_INVALID_OPERATION 0xA006 #endif #ifndef ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER #define ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER 0x311 #endif #ifndef ALC_CAPTURE_DEVICE_SPECIFIER #define ALC_CAPTURE_DEVICE_SPECIFIER 0x310 #endif #ifndef ALC_CAPTURE_SAMPLES #define ALC_CAPTURE_SAMPLES 0x312 #endif "; then : else fp_check_const_result='-1' fi eval "$as_fp_Cache=\$fp_check_const_result" fi eval ac_res=\$$as_fp_Cache { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } cat >>confdefs.h <<_ACEOF #define `$as_echo "CONST_$fp_const_name" | $as_tr_cpp` `eval 'as_val=${'$as_fp_Cache'};$as_echo "$as_val"'` _ACEOF done cat >>confdefs.h <<_ACEOF #define AL_LIBS `echo '' $AL_LIBS | sed -e 's/-[^ ]*/,"&"/g' -e 's/^ *,//'` _ACEOF cat >>confdefs.h <<_ACEOF #define AL_FRAMEWORKS `echo '' $AL_FRAMEWORKS | sed -e 's/-[^ ]*/,"&"/g' -e 's/^ *,//'` _ACEOF fi if test "$AL_BUILD_PACKAGE" = yes; then BUILD_PACKAGE_BOOL=True else BUILD_PACKAGE_BOOL=False fi case "$host" in # WinDoze DLL hell # NOTE: For some obscure/unknown reason, OpenAL uses ccall, even on WinDoze... # *-mingw32) CALLCONV=stdcall ;; *) CALLCONV=ccall ;; esac ac_config_files="$ac_config_files OpenAL.buildinfo" cat >confcache <<\_ACEOF # This file is a shell script that caches the results of configure # tests run on this system so they can be shared between configure # scripts and configure runs, see configure's option --config-cache. # It is not useful on other systems. If it contains results you don't # want to keep, you may remove or edit it. # # config.status only pays attention to the cache file if you give it # the --recheck option to rerun configure. # # `ac_cv_env_foo' variables (set or unset) will be overridden when # loading this file, other *unset* `ac_cv_foo' will be assigned the # following values. _ACEOF # The following way of writing the cache mishandles newlines in values, # but we know of no workaround that is simple, portable, and efficient. # So, we kill variables containing newlines. # Ultrix sh set writes to stderr and can't be redirected directly, # and sets the high bit in the cache file unless we assign to the vars. ( for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do eval ac_val=\$$ac_var case $ac_val in #( *${as_nl}*) case $ac_var in #( *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; unset $ac_var;} ;; esac ;; esac done (set) 2>&1 | case $as_nl`(ac_space=' '; set) 2>&1` in #( *${as_nl}ac_space=\ *) # `set' does not quote correctly, so add quotes: double-quote # substitution turns \\\\ into \\, and sed turns \\ into \. sed -n \ "s/'/'\\\\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" ;; #( *) # `set' quotes correctly as required by POSIX, so do not add quotes. sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | sort ) | sed ' /^ac_cv_env_/b end t clear :clear s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ t end s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ :end' >>confcache if diff "$cache_file" confcache >/dev/null 2>&1; then :; else if test -w "$cache_file"; then if test "x$cache_file" != "x/dev/null"; then { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 $as_echo "$as_me: updating cache $cache_file" >&6;} if test ! -f "$cache_file" || test -h "$cache_file"; then cat confcache >"$cache_file" else case $cache_file in #( */* | ?:*) mv -f confcache "$cache_file"$$ && mv -f "$cache_file"$$ "$cache_file" ;; #( *) mv -f confcache "$cache_file" ;; esac fi fi else { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;} fi fi rm -f confcache test "x$prefix" = xNONE && prefix=$ac_default_prefix # Let make expand exec_prefix. test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' DEFS=-DHAVE_CONFIG_H ac_libobjs= ac_ltlibobjs= U= for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue # 1. Remove the extension, and $U if already installed. ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' ac_i=`$as_echo "$ac_i" | sed "$ac_script"` # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR # will be set to the directory where LIBOBJS objects are built. as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext" as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo' done LIBOBJS=$ac_libobjs LTLIBOBJS=$ac_ltlibobjs : "${CONFIG_STATUS=./config.status}" ac_write_fail=0 ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files $CONFIG_STATUS" { $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 $as_echo "$as_me: creating $CONFIG_STATUS" >&6;} as_write_fail=0 cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1 #! $SHELL # Generated by $as_me. # Run this file to recreate the current configuration. # Compiler output produced by configure, useful for debugging # configure, is in config.log if it exists. debug=false ac_cs_recheck=false ac_cs_silent=false SHELL=\${CONFIG_SHELL-$SHELL} export SHELL _ASEOF cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi as_nl=' ' export as_nl # Printing a long string crashes Solaris 7 /usr/bin/printf. as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo # Prefer a ksh shell builtin over an external printf program on Solaris, # but without wasting forks for bash or zsh. if test -z "$BASH_VERSION$ZSH_VERSION" \ && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='print -r --' as_echo_n='print -rn --' elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='printf %s\n' as_echo_n='printf %s' else if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' as_echo_n='/usr/ucb/echo -n' else as_echo_body='eval expr "X$1" : "X\\(.*\\)"' as_echo_n_body='eval arg=$1; case $arg in #( *"$as_nl"*) expr "X$arg" : "X\\(.*\\)$as_nl"; arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; esac; expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" ' export as_echo_n_body as_echo_n='sh -c $as_echo_n_body as_echo' fi export as_echo_body as_echo='sh -c $as_echo_body as_echo' fi # The user is always right. if test "${PATH_SEPARATOR+set}" != set; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=';' } fi # IFS # We need space, tab and new line, in precisely that order. Quoting is # there to prevent editors from complaining about space-tab. # (If _AS_PATH_WALK were called with IFS unset, it would disable word # splitting by setting IFS to empty value.) IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break done IFS=$as_save_IFS ;; esac # We did not find ourselves, most probably we were run as `sh COMMAND' # in which case we are not to be found in the path. if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi # Unset variables that we do not need and which cause bugs (e.g. in # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" # suppresses any "Segmentation fault" message there. '((' could # trigger a bug in pdksh 5.2.14. for as_var in BASH_ENV ENV MAIL MAILPATH do eval test x\${$as_var+set} = xset \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done PS1='$ ' PS2='> ' PS4='+ ' # NLS nuisances. LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE # CDPATH. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are # provided, also output the error to LOG_FD, referencing LINENO. Then exit the # script with STATUS, using 1 if that was 0. as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi $as_echo "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. as_fn_set_status () { return $1 } # as_fn_set_status # as_fn_exit STATUS # ----------------- # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit # as_fn_unset VAR # --------------- # Portably unset VAR. as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : eval 'as_fn_append () { eval $1+=\$2 }' else as_fn_append () { eval $1=\$$1\$2 } fi # as_fn_append # as_fn_arith ARG... # ------------------ # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : eval 'as_fn_arith () { as_val=$(( $* )) }' else as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } fi # as_fn_arith if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; then as_expr=expr else as_expr=false fi if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then as_basename=basename else as_basename=false fi if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || $as_echo X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` # Avoid depending upon Character Ranges. as_cr_letters='abcdefghijklmnopqrstuvwxyz' as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits ECHO_C= ECHO_N= ECHO_T= case `echo -n x` in #((((( -n*) case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. xy) ECHO_C='\c';; *) echo `echo ksh88 bug on AIX 6.1` > /dev/null ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. # In both cases, we have to default to `cp -p'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -p' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -p' fi else as_ln_s='cp -p' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null # as_fn_mkdir_p # ------------- # Create "$as_dir" as a directory, including parents if necessary. as_fn_mkdir_p () { case $as_dir in #( -*) as_dir=./$as_dir;; esac test -d "$as_dir" || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" as_dir=`$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` test -d "$as_dir" && break done test -z "$as_dirs" || eval "mkdir $as_dirs" } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" } # as_fn_mkdir_p if mkdir -p . 2>/dev/null; then as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false fi if test -x / >/dev/null 2>&1; then as_test_x='test -x' else if ls -dL / >/dev/null 2>&1; then as_ls_L_option=L else as_ls_L_option= fi as_test_x=' eval sh -c '\'' if test -d "$1"; then test -d "$1/."; else case $1 in #( -*)set "./$1";; esac; case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #(( ???[sx]*):;;*)false;;esac;fi '\'' sh ' fi as_executable_p=$as_test_x # Sed expression to map a string onto a valid CPP name. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" # Sed expression to map a string onto a valid variable name. as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" exec 6>&1 ## ----------------------------------- ## ## Main body of $CONFIG_STATUS script. ## ## ----------------------------------- ## _ASEOF test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # Save the log message, to keep $0 and so on meaningful, and to # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" This file was extended by Haskell HOpenAL package $as_me 1.3.1.3, which was generated by GNU Autoconf 2.68. Invocation command line was CONFIG_FILES = $CONFIG_FILES CONFIG_HEADERS = $CONFIG_HEADERS CONFIG_LINKS = $CONFIG_LINKS CONFIG_COMMANDS = $CONFIG_COMMANDS $ $0 $@ on `(hostname || uname -n) 2>/dev/null | sed 1q` " _ACEOF case $ac_config_files in *" "*) set x $ac_config_files; shift; ac_config_files=$*;; esac case $ac_config_headers in *" "*) set x $ac_config_headers; shift; ac_config_headers=$*;; esac cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 # Files that config.status was made for. config_files="$ac_config_files" config_headers="$ac_config_headers" _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 ac_cs_usage="\ \`$as_me' instantiates files and other configuration actions from templates according to the current configuration. Unless the files and actions are specified as TAGs, all are instantiated by default. Usage: $0 [OPTION]... [TAG]... -h, --help print this help, then exit -V, --version print version number and configuration settings, then exit --config print configuration, then exit -q, --quiet, --silent do not print progress messages -d, --debug don't remove temporary files --recheck update $as_me by reconfiguring in the same conditions --file=FILE[:TEMPLATE] instantiate the configuration file FILE --header=FILE[:TEMPLATE] instantiate the configuration header FILE Configuration files: $config_files Configuration headers: $config_headers Report bugs to ." _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" ac_cs_version="\\ Haskell HOpenAL package config.status 1.3.1.3 configured by $0, generated by GNU Autoconf 2.68, with options \\"\$ac_cs_config\\" Copyright (C) 2010 Free Software Foundation, Inc. This config.status script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it." ac_pwd='$ac_pwd' srcdir='$srcdir' test -n "\$AWK" || AWK=awk _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # The default lists apply if the user does not specify any file. ac_need_defaults=: while test $# != 0 do case $1 in --*=?*) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'` ac_shift=: ;; --*=) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg= ac_shift=: ;; *) ac_option=$1 ac_optarg=$2 ac_shift=shift ;; esac case $ac_option in # Handling of the options. -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) ac_cs_recheck=: ;; --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) $as_echo "$ac_cs_version"; exit ;; --config | --confi | --conf | --con | --co | --c ) $as_echo "$ac_cs_config"; exit ;; --debug | --debu | --deb | --de | --d | -d ) debug=: ;; --file | --fil | --fi | --f ) $ac_shift case $ac_optarg in *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; '') as_fn_error $? "missing file argument" ;; esac as_fn_append CONFIG_FILES " '$ac_optarg'" ac_need_defaults=false;; --header | --heade | --head | --hea ) $ac_shift case $ac_optarg in *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; esac as_fn_append CONFIG_HEADERS " '$ac_optarg'" ac_need_defaults=false;; --he | --h) # Conflict between --help and --header as_fn_error $? "ambiguous option: \`$1' Try \`$0 --help' for more information.";; --help | --hel | -h ) $as_echo "$ac_cs_usage"; exit ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil | --si | --s) ac_cs_silent=: ;; # This is an error. -*) as_fn_error $? "unrecognized option: \`$1' Try \`$0 --help' for more information." ;; *) as_fn_append ac_config_targets " $1" ac_need_defaults=false ;; esac shift done ac_configure_extra_args= if $ac_cs_silent; then exec 6>/dev/null ac_configure_extra_args="$ac_configure_extra_args --silent" fi _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 if \$ac_cs_recheck; then set X '$SHELL' '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion shift \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6 CONFIG_SHELL='$SHELL' export CONFIG_SHELL exec "\$@" fi _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 exec 5>>config.log { echo sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX ## Running $as_me. ## _ASBOX $as_echo "$ac_log" } >&5 _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # Handling of arguments. for ac_config_target in $ac_config_targets do case $ac_config_target in "include/HsOpenALConfig.h") CONFIG_HEADERS="$CONFIG_HEADERS include/HsOpenALConfig.h" ;; "include/HsOpenAL.h") CONFIG_HEADERS="$CONFIG_HEADERS include/HsOpenAL.h" ;; "OpenAL.buildinfo") CONFIG_FILES="$CONFIG_FILES OpenAL.buildinfo" ;; *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;; esac done # If the user did not use the arguments to specify the items to instantiate, # then the envvar interface is used. Set only those that are not. # We use the long form for the default assignment because of an extremely # bizarre bug on SunOS 4.1.3. if $ac_need_defaults; then test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers fi # Have a temporary directory for convenience. Make it in the build tree # simply because there is no reason against having it here, and in addition, # creating and moving files from /tmp can sometimes cause problems. # Hook for its removal unless debugging. # Note that there is a small window in which the directory will not be cleaned: # after its creation but before its name has been assigned to `$tmp'. $debug || { tmp= ac_tmp= trap 'exit_status=$? : "${ac_tmp:=$tmp}" { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status ' 0 trap 'as_fn_exit 1' 1 2 13 15 } # Create a (secure) tmp directory for tmp files. { tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && test -d "$tmp" } || { tmp=./conf$$-$RANDOM (umask 077 && mkdir "$tmp") } || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5 ac_tmp=$tmp # Set up the scripts for CONFIG_FILES section. # No need to generate them if there are no CONFIG_FILES. # This happens for instance with `./config.status config.h'. if test -n "$CONFIG_FILES"; then ac_cr=`echo X | tr X '\015'` # On cygwin, bash can eat \r inside `` if the user requested igncr. # But we know of no other shell where ac_cr would be empty at this # point, so we can use a bashism as a fallback. if test "x$ac_cr" = x; then eval ac_cr=\$\'\\r\' fi ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' /dev/null` if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then ac_cs_awk_cr='\\r' else ac_cs_awk_cr=$ac_cr fi echo 'BEGIN {' >"$ac_tmp/subs1.awk" && _ACEOF { echo "cat >conf$$subs.awk <<_ACEOF" && echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' && echo "_ACEOF" } >conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'` ac_delim='%!_!# ' for ac_last_try in false false false false false :; do . ./conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` if test $ac_delim_n = $ac_delim_num; then break elif $ac_last_try; then as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 else ac_delim="$ac_delim!$ac_delim _$ac_delim!! " fi done rm -f conf$$subs.sh cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK && _ACEOF sed -n ' h s/^/S["/; s/!.*/"]=/ p g s/^[^!]*!// :repl t repl s/'"$ac_delim"'$// t delim :nl h s/\(.\{148\}\)..*/\1/ t more1 s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/ p n b repl :more1 s/["\\]/\\&/g; s/^/"/; s/$/"\\/ p g s/.\{148\}// t nl :delim h s/\(.\{148\}\)..*/\1/ t more2 s/["\\]/\\&/g; s/^/"/; s/$/"/ p b :more2 s/["\\]/\\&/g; s/^/"/; s/$/"\\/ p g s/.\{148\}// t delim ' >$CONFIG_STATUS || ac_write_fail=1 rm -f conf$$subs.awk cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 _ACAWK cat >>"\$ac_tmp/subs1.awk" <<_ACAWK && for (key in S) S_is_set[key] = 1 FS = "" } { line = $ 0 nfields = split(line, field, "@") substed = 0 len = length(field[1]) for (i = 2; i < nfields; i++) { key = field[i] keylen = length(key) if (S_is_set[key]) { value = S[key] line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3) len += length(value) + length(field[++i]) substed = 1 } else len += 1 + keylen } print line } _ACAWK _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" else cat fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \ || as_fn_error $? "could not setup config files machinery" "$LINENO" 5 _ACEOF # VPATH may cause trouble with some makes, so we remove sole $(srcdir), # ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and # trailing colons and then remove the whole line if VPATH becomes empty # (actually we leave an empty line to preserve line numbers). if test "x$srcdir" = x.; then ac_vpsub='/^[ ]*VPATH[ ]*=[ ]*/{ h s/// s/^/:/ s/[ ]*$/:/ s/:\$(srcdir):/:/g s/:\${srcdir}:/:/g s/:@srcdir@:/:/g s/^:*// s/:*$// x s/\(=[ ]*\).*/\1/ G s/\n// s/^[^=]*=[ ]*$// }' fi cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 fi # test -n "$CONFIG_FILES" # Set up the scripts for CONFIG_HEADERS section. # No need to generate them if there are no CONFIG_HEADERS. # This happens for instance with `./config.status Makefile'. if test -n "$CONFIG_HEADERS"; then cat >"$ac_tmp/defines.awk" <<\_ACAWK || BEGIN { _ACEOF # Transform confdefs.h into an awk script `defines.awk', embedded as # here-document in config.status, that substitutes the proper values into # config.h.in to produce config.h. # Create a delimiter string that does not exist in confdefs.h, to ease # handling of long lines. ac_delim='%!_!# ' for ac_last_try in false false :; do ac_tt=`sed -n "/$ac_delim/p" confdefs.h` if test -z "$ac_tt"; then break elif $ac_last_try; then as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5 else ac_delim="$ac_delim!$ac_delim _$ac_delim!! " fi done # For the awk script, D is an array of macro values keyed by name, # likewise P contains macro parameters if any. Preserve backslash # newline sequences. ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]* sed -n ' s/.\{148\}/&'"$ac_delim"'/g t rset :rset s/^[ ]*#[ ]*define[ ][ ]*/ / t def d :def s/\\$// t bsnl s/["\\]/\\&/g s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ D["\1"]=" \3"/p s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2"/p d :bsnl s/["\\]/\\&/g s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ D["\1"]=" \3\\\\\\n"\\/p t cont s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p t cont d :cont n s/.\{148\}/&'"$ac_delim"'/g t clear :clear s/\\$// t bsnlc s/["\\]/\\&/g; s/^/"/; s/$/"/p d :bsnlc s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p b cont ' >$CONFIG_STATUS || ac_write_fail=1 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 for (key in D) D_is_set[key] = 1 FS = "" } /^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ { line = \$ 0 split(line, arg, " ") if (arg[1] == "#") { defundef = arg[2] mac1 = arg[3] } else { defundef = substr(arg[1], 2) mac1 = arg[2] } split(mac1, mac2, "(") #) macro = mac2[1] prefix = substr(line, 1, index(line, defundef) - 1) if (D_is_set[macro]) { # Preserve the white space surrounding the "#". print prefix "define", macro P[macro] D[macro] next } else { # Replace #undef with comments. This is necessary, for example, # in the case of _POSIX_SOURCE, which is predefined and required # on some systems where configure will not decide to define it. if (defundef == "undef") { print "/*", prefix defundef, macro, "*/" next } } } { print } _ACAWK _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 as_fn_error $? "could not setup config headers machinery" "$LINENO" 5 fi # test -n "$CONFIG_HEADERS" eval set X " :F $CONFIG_FILES :H $CONFIG_HEADERS " shift for ac_tag do case $ac_tag in :[FHLC]) ac_mode=$ac_tag; continue;; esac case $ac_mode$ac_tag in :[FHL]*:*);; :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;; :[FH]-) ac_tag=-:-;; :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; esac ac_save_IFS=$IFS IFS=: set x $ac_tag IFS=$ac_save_IFS shift ac_file=$1 shift case $ac_mode in :L) ac_source=$1;; :[FH]) ac_file_inputs= for ac_f do case $ac_f in -) ac_f="$ac_tmp/stdin";; *) # Look for the file first in the build tree, then in the source tree # (if the path is not absolute). The absolute path cannot be DOS-style, # because $ac_f cannot contain `:'. test -f "$ac_f" || case $ac_f in [\\/$]*) false;; *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; esac || as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;; esac case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac as_fn_append ac_file_inputs " '$ac_f'" done # Let's still pretend it is `configure' which instantiates (i.e., don't # use $as_me), people would be surprised to read: # /* config.h. Generated by config.status. */ configure_input='Generated from '` $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' `' by configure.' if test x"$ac_file" != x-; then configure_input="$ac_file. $configure_input" { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 $as_echo "$as_me: creating $ac_file" >&6;} fi # Neutralize special characters interpreted by sed in replacement strings. case $configure_input in #( *\&* | *\|* | *\\* ) ac_sed_conf_input=`$as_echo "$configure_input" | sed 's/[\\\\&|]/\\\\&/g'`;; #( *) ac_sed_conf_input=$configure_input;; esac case $ac_tag in *:-:* | *:-) cat >"$ac_tmp/stdin" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; esac ;; esac ac_dir=`$as_dirname -- "$ac_file" || $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$ac_file" : 'X\(//\)[^/]' \| \ X"$ac_file" : 'X\(//\)$' \| \ X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$ac_file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` as_dir="$ac_dir"; as_fn_mkdir_p ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix # for backward compatibility: ac_top_builddir=$ac_top_build_prefix case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\\/]* | ?:[\\/]* ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix case $ac_mode in :F) # # CONFIG_FILE # _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # If the template does not know about datarootdir, expand it. # FIXME: This hack should be removed a few years after 2.60. ac_datarootdir_hack=; ac_datarootdir_seen= ac_sed_dataroot=' /datarootdir/ { p q } /@datadir@/p /@docdir@/p /@infodir@/p /@localedir@/p /@mandir@/p' case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in *datarootdir*) ac_datarootdir_seen=yes;; *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 $as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_datarootdir_hack=' s&@datadir@&$datadir&g s&@docdir@&$docdir&g s&@infodir@&$infodir&g s&@localedir@&$localedir&g s&@mandir@&$mandir&g s&\\\${datarootdir}&$datarootdir&g' ;; esac _ACEOF # Neutralize VPATH when `$srcdir' = `.'. # Shell code in configure.ac might set extrasub. # FIXME: do we really want to maintain this feature? cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_sed_extra="$ac_vpsub $extrasub _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 :t /@[a-zA-Z_][a-zA-Z_0-9]*@/!b s|@configure_input@|$ac_sed_conf_input|;t t s&@top_builddir@&$ac_top_builddir_sub&;t t s&@top_build_prefix@&$ac_top_build_prefix&;t t s&@srcdir@&$ac_srcdir&;t t s&@abs_srcdir@&$ac_abs_srcdir&;t t s&@top_srcdir@&$ac_top_srcdir&;t t s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t s&@builddir@&$ac_builddir&;t t s&@abs_builddir@&$ac_abs_builddir&;t t s&@abs_top_builddir@&$ac_abs_top_builddir&;t t $ac_datarootdir_hack " eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \ >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5 test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } && { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \ "$ac_tmp/out"`; test -z "$ac_out"; } && { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&5 $as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&2;} rm -f "$ac_tmp/stdin" case $ac_file in -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";; *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";; esac \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; :H) # # CONFIG_HEADER # if test x"$ac_file" != x-; then { $as_echo "/* $configure_input */" \ && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" } >"$ac_tmp/config.h" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 $as_echo "$as_me: $ac_file is unchanged" >&6;} else rm -f "$ac_file" mv "$ac_tmp/config.h" "$ac_file" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 fi else $as_echo "/* $configure_input */" \ && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \ || as_fn_error $? "could not create -" "$LINENO" 5 fi ;; esac done # for ac_tag as_fn_exit 0 _ACEOF ac_clean_files=$ac_clean_files_save test $ac_write_fail = 0 || as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5 # configure is writing to config.log, and then calls config.status. # config.status does its own redirection, appending to config.log. # Unfortunately, on DOS this fails, as config.log is still kept open # by configure, so config.status won't be able to write to it; its # output is simply discarded. So we exec the FD to /dev/null, # effectively closing config.log, so it can be properly (re)opened and # appended to by config.status. When coming back to configure, we # need to make the FD available again. if test "$no_create" != yes; then ac_cs_success=: ac_config_status_args= test "$silent" = yes && ac_config_status_args="$ac_config_status_args --quiet" exec 5>/dev/null $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false exec 5>>config.log # Use ||, not &&, to avoid exiting from the if with $? = 1, which # would make configure fail if this is the last instruction. $ac_cs_success || as_fn_exit 1 fi if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} fi OpenAL-1.4.0.2/configure.ac0000644000000000000000000001417711733255111012157 0ustar AC_INIT([Haskell HOpenAL package], [1.3.1.3], [sven.panne@aedion.de], [OpenAL]) # Safety check: Ensure that we are in the correct source directory. AC_CONFIG_SRCDIR([include/HsOpenAL.h.in]) # The first file mentioned below will be generated by autoheader and contains # defines which are needed during package build time only. The second header # contains all kinds of stuff which is needed for using this package. AC_CONFIG_HEADERS([include/HsOpenALConfig.h include/HsOpenAL.h]) # we do not really care about this here, but this avoids a warning about an # unknown option FP_ARG_COMPILER # We set this to "yes" later when we have found OpenAL libs and headers. AL_BUILD_PACKAGE=no # Shall we build this package at all? FP_ARG_OPENAL if test x"$enable_openal" = xyes; then # Check for ALUT include paths and libraries FP_CHECK_OPENAL if test "$AL_LIBS" = no; then AC_MSG_FAILURE([no OpenAL library found, so this package cannot be built]) fi AL_LIBS_PLAIN=`echo "$AL_LIBS" | sed -e s/-l//` AC_SUBST([AL_LIBS_PLAIN]) # check for ALUT include files FP_HEADER_AL FP_HEADER_ALC if test x"$fp_found_al_header" = xno || test x"$fp_found_alc_header" = xno; then AC_MSG_FAILURE([no OpenAL headers found, so this package cannot be built]) fi AL_BUILD_PACKAGE=yes AC_CHECK_HEADERS([AL/alext.h OpenAL/alext.h], [break]) FP_FUNC_ALCCLOSEDEVICE_VOID FP_FUNC_ALCMAKECONTEXTCURRENT_VOID FP_FUNC_ALCPROCESSCONTEXT_VOID FP_FUNC_ALCDESTROYCONTEXT_VOID FPTOOLS_CHECK_HTYPE([ALboolean]) FPTOOLS_CHECK_HTYPE([ALchar], [Int8]) FPTOOLS_CHECK_HTYPE([ALbyte]) FPTOOLS_CHECK_HTYPE([ALubyte]) FPTOOLS_CHECK_HTYPE([ALshort]) FPTOOLS_CHECK_HTYPE([ALushort]) FPTOOLS_CHECK_HTYPE([ALint]) FPTOOLS_CHECK_HTYPE([ALuint]) FPTOOLS_CHECK_HTYPE([ALsizei]) FPTOOLS_CHECK_HTYPE([ALenum]) FPTOOLS_CHECK_HTYPE([ALfloat]) FPTOOLS_CHECK_HTYPE([ALdouble]) FPTOOLS_CHECK_HTYPE([ALCboolean], [Int8]) FPTOOLS_CHECK_HTYPE([ALCchar], [Int8]) FPTOOLS_CHECK_HTYPE([ALCbyte], [Int8]) FPTOOLS_CHECK_HTYPE([ALCubyte], [Word8]) FPTOOLS_CHECK_HTYPE([ALCshort], [Int16]) FPTOOLS_CHECK_HTYPE([ALCushort], [Word16]) FPTOOLS_CHECK_HTYPE([ALCint], [Int32]) FPTOOLS_CHECK_HTYPE([ALCuint], [Word32]) FPTOOLS_CHECK_HTYPE([ALCsizei], [Int32]) FPTOOLS_CHECK_HTYPE([ALCenum], [Int32]) FPTOOLS_CHECK_HTYPE([ALCfloat], [Float]) FPTOOLS_CHECK_HTYPE([ALCdouble], [Double]) FP_CHECK_CONSTS([AL_FALSE AL_TRUE AL_NO_ERROR AL_INVALID_NAME AL_INVALID_ENUM AL_INVALID_VALUE AL_INVALID_OPERATION AL_OUT_OF_MEMORY AL_DOPPLER_FACTOR AL_SPEED_OF_SOUND AL_DISTANCE_MODEL AL_VERSION AL_RENDERER AL_VENDOR AL_EXTENSIONS AL_NONE AL_INVERSE_DISTANCE AL_INVERSE_DISTANCE_CLAMPED AL_LINEAR_DISTANCE AL_LINEAR_DISTANCE_CLAMPED AL_EXPONENT_DISTANCE AL_EXPONENT_DISTANCE_CLAMPED AL_POSITION AL_VELOCITY AL_GAIN AL_ORIENTATION AL_SOURCE_RELATIVE AL_SOURCE_TYPE AL_LOOPING AL_BUFFER AL_BUFFERS_QUEUED AL_BUFFERS_PROCESSED AL_MIN_GAIN AL_MAX_GAIN AL_REFERENCE_DISTANCE AL_ROLLOFF_FACTOR AL_MAX_DISTANCE AL_PITCH AL_DIRECTION AL_CONE_INNER_ANGLE AL_CONE_OUTER_ANGLE AL_CONE_OUTER_GAIN AL_SEC_OFFSET AL_SAMPLE_OFFSET AL_BYTE_OFFSET AL_SOURCE_STATE AL_UNDETERMINED AL_STATIC AL_STREAMING AL_INITIAL AL_PLAYING AL_PAUSED AL_STOPPED AL_FREQUENCY AL_SIZE AL_BITS AL_CHANNELS AL_FORMAT_MONO8 AL_FORMAT_MONO16 AL_FORMAT_STEREO8 AL_FORMAT_STEREO16 ALC_FALSE ALC_TRUE ALC_FREQUENCY ALC_REFRESH ALC_SYNC ALC_MONO_SOURCES ALC_STEREO_SOURCES ALC_NO_ERROR ALC_INVALID_DEVICE ALC_INVALID_CONTEXT ALC_INVALID_ENUM ALC_INVALID_VALUE ALC_INVALID_OPERATION ALC_OUT_OF_MEMORY ALC_DEFAULT_DEVICE_SPECIFIER ALC_DEVICE_SPECIFIER ALC_EXTENSIONS ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER ALC_CAPTURE_DEVICE_SPECIFIER ALC_ATTRIBUTES_SIZE ALC_ALL_ATTRIBUTES ALC_MAJOR_VERSION ALC_MINOR_VERSION ALC_CAPTURE_SAMPLES], [#include #if defined(HAVE_AL_AL_H) #include #elif defined(HAVE_OPENAL_AL_H) #include #endif #if defined(HAVE_AL_ALC_H) #include #elif defined(HAVE_OPENAL_ALC_H) #include #endif #if defined(HAVE_AL_ALEXT_H) #include #elif defined(HAVE_OPENAL_ALEXT_H) #include #endif #ifndef AL_SPEED_OF_SOUND #define AL_SPEED_OF_SOUND 0xC003 #endif #ifndef AL_LINEAR_DISTANCE #define AL_LINEAR_DISTANCE 0xD003 #endif #ifndef AL_LINEAR_DISTANCE_CLAMPED #define AL_LINEAR_DISTANCE_CLAMPED 0xD004 #endif #ifndef AL_EXPONENT_DISTANCE #define AL_EXPONENT_DISTANCE 0xD005 #endif #ifndef AL_EXPONENT_DISTANCE_CLAMPED #define AL_EXPONENT_DISTANCE_CLAMPED 0xD006 #endif #ifndef AL_SEC_OFFSET #define AL_SEC_OFFSET 0x1024 #endif #ifndef AL_SAMPLE_OFFSET #define AL_SAMPLE_OFFSET 0x1025 #endif #ifndef AL_BYTE_OFFSET #define AL_BYTE_OFFSET 0x1026 #endif #ifndef AL_UNDETERMINED #define AL_UNDETERMINED 0x1030 #endif #ifndef AL_STATIC #define AL_STATIC 0x1028 #endif #ifndef ALC_MONO_SOURCES #define ALC_MONO_SOURCES 0x1010 #endif #ifndef ALC_STEREO_SOURCES #define ALC_STEREO_SOURCES 0x1011 #endif #ifndef AL_INVALID_ENUM #ifdef AL_ILLEGAL_ENUM #define AL_INVALID_ENUM AL_ILLEGAL_ENUM #else #define AL_INVALID_ENUM 0xA002 #endif #endif #ifndef AL_INVALID_OPERATION #ifdef AL_ILLEGAL_COMMAND #define AL_INVALID_OPERATION AL_ILLEGAL_COMMAND #else #define AL_INVALID_OPERATION 0xA004 #endif #endif /* NOTE: THIS IS NOT IN ANY HEADER */ #ifndef ALC_INVALID_OPERATION #define ALC_INVALID_OPERATION 0xA006 #endif #ifndef ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER #define ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER 0x311 #endif #ifndef ALC_CAPTURE_DEVICE_SPECIFIER #define ALC_CAPTURE_DEVICE_SPECIFIER 0x310 #endif #ifndef ALC_CAPTURE_SAMPLES #define ALC_CAPTURE_SAMPLES 0x312 #endif ]) AC_DEFINE_UNQUOTED([AL_LIBS], [`echo '' $AL_LIBS | sed -e 's/-[[^ ]]*/,"&"/g' -e 's/^ *,//'`], [Library flags for AL, as a list of string literals.]) AC_DEFINE_UNQUOTED([AL_FRAMEWORKS], [`echo '' $AL_FRAMEWORKS | sed -e 's/-[[^ ]]*/,"&"/g' -e 's/^ *,//'`], [Framework flags for AL, as a list of string literals.]) fi if test "$AL_BUILD_PACKAGE" = yes; then BUILD_PACKAGE_BOOL=True else BUILD_PACKAGE_BOOL=False fi AC_SUBST([BUILD_PACKAGE_BOOL]) case "$host" in # WinDoze DLL hell # NOTE: For some obscure/unknown reason, OpenAL uses ccall, even on WinDoze... # *-mingw32) CALLCONV=stdcall ;; *) CALLCONV=ccall ;; esac AC_SUBST([CALLCONV]) AC_CONFIG_FILES([OpenAL.buildinfo]) AC_OUTPUT OpenAL-1.4.0.2/install-sh0000644000000000000000000002017411733255111011664 0ustar #!/bin/sh # install - install a program, script, or datafile scriptversion=2003-09-24.23 # This originates from X11R5 (mit/util/scripts/install.sh), which was # later released in X11R6 (xc/config/util/install.sh) with the # following copyright and license. # # Copyright (C) 1994 X Consortium # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to # deal in the Software without restriction, including without limitation the # rights to use, copy, modify, merge, publish, distribute, sublicense, and/or # sell copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN # AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC- # TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # # Except as contained in this notice, the name of the X Consortium shall not # be used in advertising or otherwise to promote the sale, use or other deal- # ings in this Software without prior written authorization from the X Consor- # tium. # # # FSF changes to this file are in the public domain. # # Calling this script install-sh is preferred over install.sh, to prevent # `make' implicit rules from creating a file called install from it # when there is no Makefile. # # This script is compatible with the BSD install script, but was written # from scratch. It can only install one file at a time, a restriction # shared with many OS's install programs. # set DOITPROG to echo to test this script # Don't use :- since 4.3BSD and earlier shells don't like it. doit="${DOITPROG-}" # put in absolute paths if you don't have them in your path; or use env. vars. mvprog="${MVPROG-mv}" cpprog="${CPPROG-cp}" chmodprog="${CHMODPROG-chmod}" chownprog="${CHOWNPROG-chown}" chgrpprog="${CHGRPPROG-chgrp}" stripprog="${STRIPPROG-strip}" rmprog="${RMPROG-rm}" mkdirprog="${MKDIRPROG-mkdir}" transformbasename= transform_arg= instcmd="$mvprog" chmodcmd="$chmodprog 0755" chowncmd= chgrpcmd= stripcmd= rmcmd="$rmprog -f" mvcmd="$mvprog" src= dst= dir_arg= usage="Usage: $0 [OPTION]... SRCFILE DSTFILE or: $0 -d DIR1 DIR2... In the first form, install SRCFILE to DSTFILE, removing SRCFILE by default. In the second, create the directory path DIR. Options: -b=TRANSFORMBASENAME -c copy source (using $cpprog) instead of moving (using $mvprog). -d create directories instead of installing files. -g GROUP $chgrp installed files to GROUP. -m MODE $chmod installed files to MODE. -o USER $chown installed files to USER. -s strip installed files (using $stripprog). -t=TRANSFORM --help display this help and exit. --version display version info and exit. Environment variables override the default commands: CHGRPPROG CHMODPROG CHOWNPROG CPPROG MKDIRPROG MVPROG RMPROG STRIPPROG " while test -n "$1"; do case $1 in -b=*) transformbasename=`echo $1 | sed 's/-b=//'` shift continue;; -c) instcmd=$cpprog shift continue;; -d) dir_arg=true shift continue;; -g) chgrpcmd="$chgrpprog $2" shift shift continue;; --help) echo "$usage"; exit 0;; -m) chmodcmd="$chmodprog $2" shift shift continue;; -o) chowncmd="$chownprog $2" shift shift continue;; -s) stripcmd=$stripprog shift continue;; -t=*) transformarg=`echo $1 | sed 's/-t=//'` shift continue;; --version) echo "$0 $scriptversion"; exit 0;; *) if test -z "$src"; then src=$1 else # this colon is to work around a 386BSD /bin/sh bug : dst=$1 fi shift continue;; esac done if test -z "$src"; then echo "$0: no input file specified." >&2 exit 1 fi # Protect names starting with `-'. case $src in -*) src=./$src ;; esac if test -n "$dir_arg"; then dst=$src src= if test -d "$dst"; then instcmd=: chmodcmd= else instcmd=$mkdirprog fi else # Waiting for this to be detected by the "$instcmd $src $dsttmp" command # might cause directories to be created, which would be especially bad # if $src (and thus $dsttmp) contains '*'. if test ! -f "$src" && test ! -d "$src"; then echo "$0: $src does not exist." >&2 exit 1 fi if test -z "$dst"; then echo "$0: no destination specified." >&2 exit 1 fi # Protect names starting with `-'. case $dst in -*) dst=./$dst ;; esac # If destination is a directory, append the input filename; won't work # if double slashes aren't ignored. if test -d "$dst"; then dst=$dst/`basename "$src"` fi fi # This sed command emulates the dirname command. dstdir=`echo "$dst" | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'` # Make sure that the destination directory exists. # Skip lots of stat calls in the usual case. if test ! -d "$dstdir"; then defaultIFS=' ' IFS="${IFS-$defaultIFS}" oIFS=$IFS # Some sh's can't handle IFS=/ for some reason. IFS='%' set - `echo "$dstdir" | sed -e 's@/@%@g' -e 's@^%@/@'` IFS=$oIFS pathcomp= while test $# -ne 0 ; do pathcomp=$pathcomp$1 shift test -d "$pathcomp" || $mkdirprog "$pathcomp" pathcomp=$pathcomp/ done fi if test -n "$dir_arg"; then $doit $instcmd "$dst" \ && { test -z "$chowncmd" || $doit $chowncmd "$dst"; } \ && { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } \ && { test -z "$stripcmd" || $doit $stripcmd "$dst"; } \ && { test -z "$chmodcmd" || $doit $chmodcmd "$dst"; } else # If we're going to rename the final executable, determine the name now. if test -z "$transformarg"; then dstfile=`basename "$dst"` else dstfile=`basename "$dst" $transformbasename \ | sed $transformarg`$transformbasename fi # don't allow the sed command to completely eliminate the filename. test -z "$dstfile" && dstfile=`basename "$dst"` # Make a couple of temp file names in the proper directory. dsttmp=$dstdir/_inst.$$_ rmtmp=$dstdir/_rm.$$_ # Trap to clean up those temp files at exit. trap 'status=$?; rm -f "$dsttmp" "$rmtmp" && exit $status' 0 trap '(exit $?); exit' 1 2 13 15 # Move or copy the file name to the temp name $doit $instcmd "$src" "$dsttmp" && # and set any options; do chmod last to preserve setuid bits. # # If any of these fail, we abort the whole thing. If we want to # ignore errors from any of these, just make sure not to ignore # errors from the above "$doit $instcmd $src $dsttmp" command. # { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } \ && { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } \ && { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } \ && { test -z "$chmodcmd" || $doit $chmodcmd "$dsttmp"; } && # Now remove or move aside any old file at destination location. We # try this two ways since rm can't unlink itself on some systems and # the destination file might be busy for other reasons. In this case, # the final cleanup might fail but the new file should still install # successfully. { if test -f "$dstdir/$dstfile"; then $doit $rmcmd -f "$dstdir/$dstfile" 2>/dev/null \ || $doit $mvcmd -f "$dstdir/$dstfile" "$rmtmp" 2>/dev/null \ || { echo "$0: cannot unlink or rename $dstdir/$dstfile" >&2 (exit 1); exit } else : fi } && # Now rename the file to the real destination. $doit $mvcmd "$dsttmp" "$dstdir/$dstfile" fi && # The final little trick to "correctly" pass the exit status to the exit trap. { (exit 0); exit } # Local variables: # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "scriptversion=" # time-stamp-format: "%:y-%02m-%02d.%02H" # time-stamp-end: "$" # End: OpenAL-1.4.0.2/config.guess0000644000000000000000000012605111733255111012201 0ustar #! /bin/sh # Attempt to guess a canonical system name. # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, # 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. timestamp='2006-02-23' # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA # 02110-1301, USA. # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. # Originally written by Per Bothner . # Please send patches to . Submit a context # diff and a properly formatted ChangeLog entry. # # This script attempts to guess a canonical system name similar to # config.sub. If it succeeds, it prints the system name on stdout, and # exits with 0. Otherwise, it exits with 1. # # The plan is that this can be called by configure scripts if you # don't specify an explicit build system type. me=`echo "$0" | sed -e 's,.*/,,'` usage="\ Usage: $0 [OPTION] Output the configuration name of the system \`$me' is run on. Operation modes: -h, --help print this help, then exit -t, --time-stamp print date of last modification, then exit -v, --version print version number, then exit Report bugs and patches to ." version="\ GNU config.guess ($timestamp) Originally written by Per Bothner. Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." help=" Try \`$me --help' for more information." # Parse command line while test $# -gt 0 ; do case $1 in --time-stamp | --time* | -t ) echo "$timestamp" ; exit ;; --version | -v ) echo "$version" ; exit ;; --help | --h* | -h ) echo "$usage"; exit ;; -- ) # Stop option processing shift; break ;; - ) # Use stdin as input. break ;; -* ) echo "$me: invalid option $1$help" >&2 exit 1 ;; * ) break ;; esac done if test $# != 0; then echo "$me: too many arguments$help" >&2 exit 1 fi trap 'exit 1' 1 2 15 # CC_FOR_BUILD -- compiler used by this script. Note that the use of a # compiler to aid in system detection is discouraged as it requires # temporary files to be created and, as you can see below, it is a # headache to deal with in a portable fashion. # Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still # use `HOST_CC' if defined, but it is deprecated. # Portable tmp directory creation inspired by the Autoconf team. set_cc_for_build=' trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ; trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ; : ${TMPDIR=/tmp} ; { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } || { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } || { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ; dummy=$tmp/dummy ; tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ; case $CC_FOR_BUILD,$HOST_CC,$CC in ,,) echo "int x;" > $dummy.c ; for c in cc gcc c89 c99 ; do if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then CC_FOR_BUILD="$c"; break ; fi ; done ; if test x"$CC_FOR_BUILD" = x ; then CC_FOR_BUILD=no_compiler_found ; fi ;; ,,*) CC_FOR_BUILD=$CC ;; ,*,*) CC_FOR_BUILD=$HOST_CC ;; esac ; set_cc_for_build= ;' # This is needed to find uname on a Pyramid OSx when run in the BSD universe. # (ghazi@noc.rutgers.edu 1994-08-24) if (test -f /.attbin/uname) >/dev/null 2>&1 ; then PATH=$PATH:/.attbin ; export PATH fi UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown # Note: order is significant - the case branches are not exclusive. case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in *:NetBSD:*:*) # NetBSD (nbsd) targets should (where applicable) match one or # more of the tupples: *-*-netbsdelf*, *-*-netbsdaout*, # *-*-netbsdecoff* and *-*-netbsd*. For targets that recently # switched to ELF, *-*-netbsd* would select the old # object file format. This provides both forward # compatibility and a consistent mechanism for selecting the # object file format. # # Note: NetBSD doesn't particularly care about the vendor # portion of the name. We always set it to "unknown". sysctl="sysctl -n hw.machine_arch" UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \ /usr/sbin/$sysctl 2>/dev/null || echo unknown)` case "${UNAME_MACHINE_ARCH}" in armeb) machine=armeb-unknown ;; arm*) machine=arm-unknown ;; sh3el) machine=shl-unknown ;; sh3eb) machine=sh-unknown ;; *) machine=${UNAME_MACHINE_ARCH}-unknown ;; esac # The Operating System including object format, if it has switched # to ELF recently, or will in the future. case "${UNAME_MACHINE_ARCH}" in arm*|i386|m68k|ns32k|sh3*|sparc|vax) eval $set_cc_for_build if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \ | grep __ELF__ >/dev/null then # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout). # Return netbsd for either. FIX? os=netbsd else os=netbsdelf fi ;; *) os=netbsd ;; esac # The OS release # Debian GNU/NetBSD machines have a different userland, and # thus, need a distinct triplet. However, they do not need # kernel version information, so it can be replaced with a # suitable tag, in the style of linux-gnu. case "${UNAME_VERSION}" in Debian*) release='-gnu' ;; *) release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'` ;; esac # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM: # contains redundant information, the shorter form: # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used. echo "${machine}-${os}${release}" exit ;; *:OpenBSD:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'` echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE} exit ;; *:ekkoBSD:*:*) echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE} exit ;; *:SolidBSD:*:*) echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE} exit ;; macppc:MirBSD:*:*) echo powerppc-unknown-mirbsd${UNAME_RELEASE} exit ;; *:MirBSD:*:*) echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE} exit ;; alpha:OSF1:*:*) case $UNAME_RELEASE in *4.0) UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'` ;; *5.*) UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'` ;; esac # According to Compaq, /usr/sbin/psrinfo has been available on # OSF/1 and Tru64 systems produced since 1995. I hope that # covers most systems running today. This code pipes the CPU # types through head -n 1, so we only detect the type of CPU 0. ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1` case "$ALPHA_CPU_TYPE" in "EV4 (21064)") UNAME_MACHINE="alpha" ;; "EV4.5 (21064)") UNAME_MACHINE="alpha" ;; "LCA4 (21066/21068)") UNAME_MACHINE="alpha" ;; "EV5 (21164)") UNAME_MACHINE="alphaev5" ;; "EV5.6 (21164A)") UNAME_MACHINE="alphaev56" ;; "EV5.6 (21164PC)") UNAME_MACHINE="alphapca56" ;; "EV5.7 (21164PC)") UNAME_MACHINE="alphapca57" ;; "EV6 (21264)") UNAME_MACHINE="alphaev6" ;; "EV6.7 (21264A)") UNAME_MACHINE="alphaev67" ;; "EV6.8CB (21264C)") UNAME_MACHINE="alphaev68" ;; "EV6.8AL (21264B)") UNAME_MACHINE="alphaev68" ;; "EV6.8CX (21264D)") UNAME_MACHINE="alphaev68" ;; "EV6.9A (21264/EV69A)") UNAME_MACHINE="alphaev69" ;; "EV7 (21364)") UNAME_MACHINE="alphaev7" ;; "EV7.9 (21364A)") UNAME_MACHINE="alphaev79" ;; esac # A Pn.n version is a patched version. # A Vn.n version is a released version. # A Tn.n version is a released field test version. # A Xn.n version is an unreleased experimental baselevel. # 1.2 uses "1.2" for uname -r. echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` exit ;; Alpha\ *:Windows_NT*:*) # How do we know it's Interix rather than the generic POSIX subsystem? # Should we change UNAME_MACHINE based on the output of uname instead # of the specific Alpha model? echo alpha-pc-interix exit ;; 21064:Windows_NT:50:3) echo alpha-dec-winnt3.5 exit ;; Amiga*:UNIX_System_V:4.0:*) echo m68k-unknown-sysv4 exit ;; *:[Aa]miga[Oo][Ss]:*:*) echo ${UNAME_MACHINE}-unknown-amigaos exit ;; *:[Mm]orph[Oo][Ss]:*:*) echo ${UNAME_MACHINE}-unknown-morphos exit ;; *:OS/390:*:*) echo i370-ibm-openedition exit ;; *:z/VM:*:*) echo s390-ibm-zvmoe exit ;; *:OS400:*:*) echo powerpc-ibm-os400 exit ;; arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) echo arm-acorn-riscix${UNAME_RELEASE} exit ;; arm:riscos:*:*|arm:RISCOS:*:*) echo arm-unknown-riscos exit ;; SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*) echo hppa1.1-hitachi-hiuxmpp exit ;; Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*) # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE. if test "`(/bin/universe) 2>/dev/null`" = att ; then echo pyramid-pyramid-sysv3 else echo pyramid-pyramid-bsd fi exit ;; NILE*:*:*:dcosx) echo pyramid-pyramid-svr4 exit ;; DRS?6000:unix:4.0:6*) echo sparc-icl-nx6 exit ;; DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*) case `/usr/bin/uname -p` in sparc) echo sparc-icl-nx7; exit ;; esac ;; sun4H:SunOS:5.*:*) echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; i86pc:SunOS:5.*:*) echo i386-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4*:SunOS:6*:*) # According to config.sub, this is the proper way to canonicalize # SunOS6. Hard to guess exactly what SunOS6 will be like, but # it's likely to be more like Solaris than SunOS4. echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4*:SunOS:*:*) case "`/usr/bin/arch -k`" in Series*|S4*) UNAME_RELEASE=`uname -v` ;; esac # Japanese Language versions have a version number like `4.1.3-JL'. echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'` exit ;; sun3*:SunOS:*:*) echo m68k-sun-sunos${UNAME_RELEASE} exit ;; sun*:*:4.2BSD:*) UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null` test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3 case "`/bin/arch`" in sun3) echo m68k-sun-sunos${UNAME_RELEASE} ;; sun4) echo sparc-sun-sunos${UNAME_RELEASE} ;; esac exit ;; aushp:SunOS:*:*) echo sparc-auspex-sunos${UNAME_RELEASE} exit ;; # The situation for MiNT is a little confusing. The machine name # can be virtually everything (everything which is not # "atarist" or "atariste" at least should have a processor # > m68000). The system name ranges from "MiNT" over "FreeMiNT" # to the lowercase version "mint" (or "freemint"). Finally # the system name "TOS" denotes a system which is actually not # MiNT. But MiNT is downward compatible to TOS, so this should # be no problem. atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*) echo m68k-atari-mint${UNAME_RELEASE} exit ;; atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*) echo m68k-atari-mint${UNAME_RELEASE} exit ;; *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*) echo m68k-atari-mint${UNAME_RELEASE} exit ;; milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*) echo m68k-milan-mint${UNAME_RELEASE} exit ;; hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*) echo m68k-hades-mint${UNAME_RELEASE} exit ;; *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*) echo m68k-unknown-mint${UNAME_RELEASE} exit ;; m68k:machten:*:*) echo m68k-apple-machten${UNAME_RELEASE} exit ;; powerpc:machten:*:*) echo powerpc-apple-machten${UNAME_RELEASE} exit ;; RISC*:Mach:*:*) echo mips-dec-mach_bsd4.3 exit ;; RISC*:ULTRIX:*:*) echo mips-dec-ultrix${UNAME_RELEASE} exit ;; VAX*:ULTRIX*:*:*) echo vax-dec-ultrix${UNAME_RELEASE} exit ;; 2020:CLIX:*:* | 2430:CLIX:*:*) echo clipper-intergraph-clix${UNAME_RELEASE} exit ;; mips:*:*:UMIPS | mips:*:*:RISCos) eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #ifdef __cplusplus #include /* for printf() prototype */ int main (int argc, char *argv[]) { #else int main (argc, argv) int argc; char *argv[]; { #endif #if defined (host_mips) && defined (MIPSEB) #if defined (SYSTYPE_SYSV) printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0); #endif #if defined (SYSTYPE_SVR4) printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0); #endif #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD) printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0); #endif #endif exit (-1); } EOF $CC_FOR_BUILD -o $dummy $dummy.c && dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` && SYSTEM_NAME=`$dummy $dummyarg` && { echo "$SYSTEM_NAME"; exit; } echo mips-mips-riscos${UNAME_RELEASE} exit ;; Motorola:PowerMAX_OS:*:*) echo powerpc-motorola-powermax exit ;; Motorola:*:4.3:PL8-*) echo powerpc-harris-powermax exit ;; Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*) echo powerpc-harris-powermax exit ;; Night_Hawk:Power_UNIX:*:*) echo powerpc-harris-powerunix exit ;; m88k:CX/UX:7*:*) echo m88k-harris-cxux7 exit ;; m88k:*:4*:R4*) echo m88k-motorola-sysv4 exit ;; m88k:*:3*:R3*) echo m88k-motorola-sysv3 exit ;; AViiON:dgux:*:*) # DG/UX returns AViiON for all architectures UNAME_PROCESSOR=`/usr/bin/uname -p` if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ] then if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \ [ ${TARGET_BINARY_INTERFACE}x = x ] then echo m88k-dg-dgux${UNAME_RELEASE} else echo m88k-dg-dguxbcs${UNAME_RELEASE} fi else echo i586-dg-dgux${UNAME_RELEASE} fi exit ;; M88*:DolphinOS:*:*) # DolphinOS (SVR3) echo m88k-dolphin-sysv3 exit ;; M88*:*:R3*:*) # Delta 88k system running SVR3 echo m88k-motorola-sysv3 exit ;; XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3) echo m88k-tektronix-sysv3 exit ;; Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD) echo m68k-tektronix-bsd exit ;; *:IRIX*:*:*) echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'` exit ;; ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX. echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id exit ;; # Note that: echo "'`uname -s`'" gives 'AIX ' i*86:AIX:*:*) echo i386-ibm-aix exit ;; ia64:AIX:*:*) if [ -x /usr/bin/oslevel ] ; then IBM_REV=`/usr/bin/oslevel` else IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} fi echo ${UNAME_MACHINE}-ibm-aix${IBM_REV} exit ;; *:AIX:2:3) if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #include main() { if (!__power_pc()) exit(1); puts("powerpc-ibm-aix3.2.5"); exit(0); } EOF if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` then echo "$SYSTEM_NAME" else echo rs6000-ibm-aix3.2.5 fi elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then echo rs6000-ibm-aix3.2.4 else echo rs6000-ibm-aix3.2 fi exit ;; *:AIX:*:[45]) IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'` if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then IBM_ARCH=rs6000 else IBM_ARCH=powerpc fi if [ -x /usr/bin/oslevel ] ; then IBM_REV=`/usr/bin/oslevel` else IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} fi echo ${IBM_ARCH}-ibm-aix${IBM_REV} exit ;; *:AIX:*:*) echo rs6000-ibm-aix exit ;; ibmrt:4.4BSD:*|romp-ibm:BSD:*) echo romp-ibm-bsd4.4 exit ;; ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and echo romp-ibm-bsd${UNAME_RELEASE} # 4.3 with uname added to exit ;; # report: romp-ibm BSD 4.3 *:BOSX:*:*) echo rs6000-bull-bosx exit ;; DPX/2?00:B.O.S.:*:*) echo m68k-bull-sysv3 exit ;; 9000/[34]??:4.3bsd:1.*:*) echo m68k-hp-bsd exit ;; hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*) echo m68k-hp-bsd4.4 exit ;; 9000/[34678]??:HP-UX:*:*) HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` case "${UNAME_MACHINE}" in 9000/31? ) HP_ARCH=m68000 ;; 9000/[34]?? ) HP_ARCH=m68k ;; 9000/[678][0-9][0-9]) if [ -x /usr/bin/getconf ]; then sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null` sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null` case "${sc_cpu_version}" in 523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0 528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1 532) # CPU_PA_RISC2_0 case "${sc_kernel_bits}" in 32) HP_ARCH="hppa2.0n" ;; 64) HP_ARCH="hppa2.0w" ;; '') HP_ARCH="hppa2.0" ;; # HP-UX 10.20 esac ;; esac fi if [ "${HP_ARCH}" = "" ]; then eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #define _HPUX_SOURCE #include #include int main () { #if defined(_SC_KERNEL_BITS) long bits = sysconf(_SC_KERNEL_BITS); #endif long cpu = sysconf (_SC_CPU_VERSION); switch (cpu) { case CPU_PA_RISC1_0: puts ("hppa1.0"); break; case CPU_PA_RISC1_1: puts ("hppa1.1"); break; case CPU_PA_RISC2_0: #if defined(_SC_KERNEL_BITS) switch (bits) { case 64: puts ("hppa2.0w"); break; case 32: puts ("hppa2.0n"); break; default: puts ("hppa2.0"); break; } break; #else /* !defined(_SC_KERNEL_BITS) */ puts ("hppa2.0"); break; #endif default: puts ("hppa1.0"); break; } exit (0); } EOF (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy` test -z "$HP_ARCH" && HP_ARCH=hppa fi ;; esac if [ ${HP_ARCH} = "hppa2.0w" ] then eval $set_cc_for_build # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating # 32-bit code. hppa64-hp-hpux* has the same kernel and a compiler # generating 64-bit code. GNU and HP use different nomenclature: # # $ CC_FOR_BUILD=cc ./config.guess # => hppa2.0w-hp-hpux11.23 # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess # => hppa64-hp-hpux11.23 if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | grep __LP64__ >/dev/null then HP_ARCH="hppa2.0w" else HP_ARCH="hppa64" fi fi echo ${HP_ARCH}-hp-hpux${HPUX_REV} exit ;; ia64:HP-UX:*:*) HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` echo ia64-hp-hpux${HPUX_REV} exit ;; 3050*:HI-UX:*:*) eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #include int main () { long cpu = sysconf (_SC_CPU_VERSION); /* The order matters, because CPU_IS_HP_MC68K erroneously returns true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct results, however. */ if (CPU_IS_PA_RISC (cpu)) { switch (cpu) { case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break; case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break; case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break; default: puts ("hppa-hitachi-hiuxwe2"); break; } } else if (CPU_IS_HP_MC68K (cpu)) puts ("m68k-hitachi-hiuxwe2"); else puts ("unknown-hitachi-hiuxwe2"); exit (0); } EOF $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` && { echo "$SYSTEM_NAME"; exit; } echo unknown-hitachi-hiuxwe2 exit ;; 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* ) echo hppa1.1-hp-bsd exit ;; 9000/8??:4.3bsd:*:*) echo hppa1.0-hp-bsd exit ;; *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*) echo hppa1.0-hp-mpeix exit ;; hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* ) echo hppa1.1-hp-osf exit ;; hp8??:OSF1:*:*) echo hppa1.0-hp-osf exit ;; i*86:OSF1:*:*) if [ -x /usr/sbin/sysversion ] ; then echo ${UNAME_MACHINE}-unknown-osf1mk else echo ${UNAME_MACHINE}-unknown-osf1 fi exit ;; parisc*:Lites*:*:*) echo hppa1.1-hp-lites exit ;; C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) echo c1-convex-bsd exit ;; C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) if getsysinfo -f scalar_acc then echo c32-convex-bsd else echo c2-convex-bsd fi exit ;; C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) echo c34-convex-bsd exit ;; C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) echo c38-convex-bsd exit ;; C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) echo c4-convex-bsd exit ;; CRAY*Y-MP:*:*:*) echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*[A-Z]90:*:*:*) echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \ | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \ -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \ -e 's/\.[^.]*$/.X/' exit ;; CRAY*TS:*:*:*) echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*T3E:*:*:*) echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*SV1:*:*:*) echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; *:UNICOS/mp:*:*) echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*) FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'` echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" exit ;; 5000:UNIX_System_V:4.*:*) FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'` echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" exit ;; i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*) echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE} exit ;; sparc*:BSD/OS:*:*) echo sparc-unknown-bsdi${UNAME_RELEASE} exit ;; *:BSD/OS:*:*) echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE} exit ;; *:FreeBSD:*:*) case ${UNAME_MACHINE} in pc98) echo i386-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; *) echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; esac exit ;; i*:CYGWIN*:*) echo ${UNAME_MACHINE}-pc-cygwin exit ;; i*:MINGW*:*) echo ${UNAME_MACHINE}-pc-mingw32 exit ;; i*:MSYS_NT-*:*:*) echo ${UNAME_MACHINE}-pc-mingw32 exit ;; i*:windows32*:*) # uname -m includes "-pc" on this system. echo ${UNAME_MACHINE}-mingw32 exit ;; i*:PW*:*) echo ${UNAME_MACHINE}-pc-pw32 exit ;; x86:Interix*:[345]*) echo i586-pc-interix${UNAME_RELEASE} exit ;; EM64T:Interix*:[345]*) echo x86_64-unknown-interix${UNAME_RELEASE} exit ;; [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*) echo i${UNAME_MACHINE}-pc-mks exit ;; i*:Windows_NT*:* | Pentium*:Windows_NT*:*) # How do we know it's Interix rather than the generic POSIX subsystem? # It also conflicts with pre-2.0 versions of AT&T UWIN. Should we # UNAME_MACHINE based on the output of uname instead of i386? echo i586-pc-interix exit ;; i*:UWIN*:*) echo ${UNAME_MACHINE}-pc-uwin exit ;; amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*) echo x86_64-unknown-cygwin exit ;; p*:CYGWIN*:*) echo powerpcle-unknown-cygwin exit ;; prep*:SunOS:5.*:*) echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; *:GNU:*:*) # the GNU system echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'` exit ;; *:GNU/*:*:*) # other systems with GNU libc and userland echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-gnu exit ;; i*86:Minix:*:*) echo ${UNAME_MACHINE}-pc-minix exit ;; arm*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; cris:Linux:*:*) echo cris-axis-linux-gnu exit ;; crisv32:Linux:*:*) echo crisv32-axis-linux-gnu exit ;; frv:Linux:*:*) echo frv-unknown-linux-gnu exit ;; ia64:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; m32r*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; m68*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; mips:Linux:*:*) eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #undef CPU #undef mips #undef mipsel #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) CPU=mipsel #else #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) CPU=mips #else CPU= #endif #endif EOF eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n ' /^CPU/{ s: ::g p }'`" test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; } ;; mips64:Linux:*:*) eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #undef CPU #undef mips64 #undef mips64el #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) CPU=mips64el #else #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) CPU=mips64 #else CPU= #endif #endif EOF eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n ' /^CPU/{ s: ::g p }'`" test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; } ;; or32:Linux:*:*) echo or32-unknown-linux-gnu exit ;; ppc:Linux:*:*) echo powerpc-unknown-linux-gnu exit ;; ppc64:Linux:*:*) echo powerpc64-unknown-linux-gnu exit ;; alpha:Linux:*:*) case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in EV5) UNAME_MACHINE=alphaev5 ;; EV56) UNAME_MACHINE=alphaev56 ;; PCA56) UNAME_MACHINE=alphapca56 ;; PCA57) UNAME_MACHINE=alphapca56 ;; EV6) UNAME_MACHINE=alphaev6 ;; EV67) UNAME_MACHINE=alphaev67 ;; EV68*) UNAME_MACHINE=alphaev68 ;; esac objdump --private-headers /bin/sh | grep ld.so.1 >/dev/null if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC} exit ;; parisc:Linux:*:* | hppa:Linux:*:*) # Look for CPU level case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in PA7*) echo hppa1.1-unknown-linux-gnu ;; PA8*) echo hppa2.0-unknown-linux-gnu ;; *) echo hppa-unknown-linux-gnu ;; esac exit ;; parisc64:Linux:*:* | hppa64:Linux:*:*) echo hppa64-unknown-linux-gnu exit ;; s390:Linux:*:* | s390x:Linux:*:*) echo ${UNAME_MACHINE}-ibm-linux exit ;; sh64*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; sh*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; sparc:Linux:*:* | sparc64:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; vax:Linux:*:*) echo ${UNAME_MACHINE}-dec-linux-gnu exit ;; x86_64:Linux:*:*) echo x86_64-unknown-linux-gnu exit ;; i*86:Linux:*:*) # The BFD linker knows what the default object file format is, so # first see if it will tell us. cd to the root directory to prevent # problems with other programs or directories called `ld' in the path. # Set LC_ALL=C to ensure ld outputs messages in English. ld_supported_targets=`cd /; LC_ALL=C ld --help 2>&1 \ | sed -ne '/supported targets:/!d s/[ ][ ]*/ /g s/.*supported targets: *// s/ .*// p'` case "$ld_supported_targets" in elf32-i386) TENTATIVE="${UNAME_MACHINE}-pc-linux-gnu" ;; a.out-i386-linux) echo "${UNAME_MACHINE}-pc-linux-gnuaout" exit ;; coff-i386) echo "${UNAME_MACHINE}-pc-linux-gnucoff" exit ;; "") # Either a pre-BFD a.out linker (linux-gnuoldld) or # one that does not give us useful --help. echo "${UNAME_MACHINE}-pc-linux-gnuoldld" exit ;; esac # Determine whether the default compiler is a.out or elf eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #include #ifdef __ELF__ # ifdef __GLIBC__ # if __GLIBC__ >= 2 LIBC=gnu # else LIBC=gnulibc1 # endif # else LIBC=gnulibc1 # endif #else #if defined(__INTEL_COMPILER) || defined(__PGI) || defined(__sun) LIBC=gnu #else LIBC=gnuaout #endif #endif #ifdef __dietlibc__ LIBC=dietlibc #endif EOF eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n ' /^LIBC/{ s: ::g p }'`" test x"${LIBC}" != x && { echo "${UNAME_MACHINE}-pc-linux-${LIBC}" exit } test x"${TENTATIVE}" != x && { echo "${TENTATIVE}"; exit; } ;; i*86:DYNIX/ptx:4*:*) # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. # earlier versions are messed up and put the nodename in both # sysname and nodename. echo i386-sequent-sysv4 exit ;; i*86:UNIX_SV:4.2MP:2.*) # Unixware is an offshoot of SVR4, but it has its own version # number series starting with 2... # I am not positive that other SVR4 systems won't match this, # I just have to hope. -- rms. # Use sysv4.2uw... so that sysv4* matches it. echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION} exit ;; i*86:OS/2:*:*) # If we were able to find `uname', then EMX Unix compatibility # is probably installed. echo ${UNAME_MACHINE}-pc-os2-emx exit ;; i*86:XTS-300:*:STOP) echo ${UNAME_MACHINE}-unknown-stop exit ;; i*86:atheos:*:*) echo ${UNAME_MACHINE}-unknown-atheos exit ;; i*86:syllable:*:*) echo ${UNAME_MACHINE}-pc-syllable exit ;; i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.0*:*) echo i386-unknown-lynxos${UNAME_RELEASE} exit ;; i*86:*DOS:*:*) echo ${UNAME_MACHINE}-pc-msdosdjgpp exit ;; i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*) UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'` if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL} else echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL} fi exit ;; i*86:*:5:[678]*) # UnixWare 7.x, OpenUNIX and OpenServer 6. case `/bin/uname -X | grep "^Machine"` in *486*) UNAME_MACHINE=i486 ;; *Pentium) UNAME_MACHINE=i586 ;; *Pent*|*Celeron) UNAME_MACHINE=i686 ;; esac echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION} exit ;; i*86:*:3.2:*) if test -f /usr/options/cb.name; then UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')` (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486 (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \ && UNAME_MACHINE=i586 (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \ && UNAME_MACHINE=i686 (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \ && UNAME_MACHINE=i686 echo ${UNAME_MACHINE}-pc-sco$UNAME_REL else echo ${UNAME_MACHINE}-pc-sysv32 fi exit ;; pc:*:*:*) # Left here for compatibility: # uname -m prints for DJGPP always 'pc', but it prints nothing about # the processor, so we play safe by assuming i386. echo i386-pc-msdosdjgpp exit ;; Intel:Mach:3*:*) echo i386-pc-mach3 exit ;; paragon:*:*:*) echo i860-intel-osf1 exit ;; i860:*:4.*:*) # i860-SVR4 if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4 else # Add other i860-SVR4 vendors below as they are discovered. echo i860-unknown-sysv${UNAME_RELEASE} # Unknown i860-SVR4 fi exit ;; mini*:CTIX:SYS*5:*) # "miniframe" echo m68010-convergent-sysv exit ;; mc68k:UNIX:SYSTEM5:3.51m) echo m68k-convergent-sysv exit ;; M680?0:D-NIX:5.3:*) echo m68k-diab-dnix exit ;; M68*:*:R3V[5678]*:*) test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;; 3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0) OS_REL='' test -r /etc/.relid \ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4.3${OS_REL}; exit; } /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*) /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4; exit; } ;; m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*) echo m68k-unknown-lynxos${UNAME_RELEASE} exit ;; mc68030:UNIX_System_V:4.*:*) echo m68k-atari-sysv4 exit ;; TSUNAMI:LynxOS:2.*:*) echo sparc-unknown-lynxos${UNAME_RELEASE} exit ;; rs6000:LynxOS:2.*:*) echo rs6000-unknown-lynxos${UNAME_RELEASE} exit ;; PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.0*:*) echo powerpc-unknown-lynxos${UNAME_RELEASE} exit ;; SM[BE]S:UNIX_SV:*:*) echo mips-dde-sysv${UNAME_RELEASE} exit ;; RM*:ReliantUNIX-*:*:*) echo mips-sni-sysv4 exit ;; RM*:SINIX-*:*:*) echo mips-sni-sysv4 exit ;; *:SINIX-*:*:*) if uname -p 2>/dev/null >/dev/null ; then UNAME_MACHINE=`(uname -p) 2>/dev/null` echo ${UNAME_MACHINE}-sni-sysv4 else echo ns32k-sni-sysv fi exit ;; PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort # says echo i586-unisys-sysv4 exit ;; *:UNIX_System_V:4*:FTX*) # From Gerald Hewes . # How about differentiating between stratus architectures? -djm echo hppa1.1-stratus-sysv4 exit ;; *:*:*:FTX*) # From seanf@swdc.stratus.com. echo i860-stratus-sysv4 exit ;; i*86:VOS:*:*) # From Paul.Green@stratus.com. echo ${UNAME_MACHINE}-stratus-vos exit ;; *:VOS:*:*) # From Paul.Green@stratus.com. echo hppa1.1-stratus-vos exit ;; mc68*:A/UX:*:*) echo m68k-apple-aux${UNAME_RELEASE} exit ;; news*:NEWS-OS:6*:*) echo mips-sony-newsos6 exit ;; R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*) if [ -d /usr/nec ]; then echo mips-nec-sysv${UNAME_RELEASE} else echo mips-unknown-sysv${UNAME_RELEASE} fi exit ;; BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only. echo powerpc-be-beos exit ;; BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only. echo powerpc-apple-beos exit ;; BePC:BeOS:*:*) # BeOS running on Intel PC compatible. echo i586-pc-beos exit ;; SX-4:SUPER-UX:*:*) echo sx4-nec-superux${UNAME_RELEASE} exit ;; SX-5:SUPER-UX:*:*) echo sx5-nec-superux${UNAME_RELEASE} exit ;; SX-6:SUPER-UX:*:*) echo sx6-nec-superux${UNAME_RELEASE} exit ;; Power*:Rhapsody:*:*) echo powerpc-apple-rhapsody${UNAME_RELEASE} exit ;; *:Rhapsody:*:*) echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE} exit ;; *:Darwin:*:*) UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown case $UNAME_PROCESSOR in unknown) UNAME_PROCESSOR=powerpc ;; esac echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE} exit ;; *:procnto*:*:* | *:QNX:[0123456789]*:*) UNAME_PROCESSOR=`uname -p` if test "$UNAME_PROCESSOR" = "x86"; then UNAME_PROCESSOR=i386 UNAME_MACHINE=pc fi echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE} exit ;; *:QNX:*:4*) echo i386-pc-qnx exit ;; NSE-?:NONSTOP_KERNEL:*:*) echo nse-tandem-nsk${UNAME_RELEASE} exit ;; NSR-?:NONSTOP_KERNEL:*:*) echo nsr-tandem-nsk${UNAME_RELEASE} exit ;; *:NonStop-UX:*:*) echo mips-compaq-nonstopux exit ;; BS2000:POSIX*:*:*) echo bs2000-siemens-sysv exit ;; DS/*:UNIX_System_V:*:*) echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE} exit ;; *:Plan9:*:*) # "uname -m" is not consistent, so use $cputype instead. 386 # is converted to i386 for consistency with other x86 # operating systems. if test "$cputype" = "386"; then UNAME_MACHINE=i386 else UNAME_MACHINE="$cputype" fi echo ${UNAME_MACHINE}-unknown-plan9 exit ;; *:TOPS-10:*:*) echo pdp10-unknown-tops10 exit ;; *:TENEX:*:*) echo pdp10-unknown-tenex exit ;; KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*) echo pdp10-dec-tops20 exit ;; XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*) echo pdp10-xkl-tops20 exit ;; *:TOPS-20:*:*) echo pdp10-unknown-tops20 exit ;; *:ITS:*:*) echo pdp10-unknown-its exit ;; SEI:*:*:SEIUX) echo mips-sei-seiux${UNAME_RELEASE} exit ;; *:DragonFly:*:*) echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` exit ;; *:*VMS:*:*) UNAME_MACHINE=`(uname -p) 2>/dev/null` case "${UNAME_MACHINE}" in A*) echo alpha-dec-vms ; exit ;; I*) echo ia64-dec-vms ; exit ;; V*) echo vax-dec-vms ; exit ;; esac ;; *:XENIX:*:SysV) echo i386-pc-xenix exit ;; i*86:skyos:*:*) echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//' exit ;; i*86:rdos:*:*) echo ${UNAME_MACHINE}-pc-rdos exit ;; esac #echo '(No uname command or uname output not recognized.)' 1>&2 #echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2 eval $set_cc_for_build cat >$dummy.c < # include #endif main () { #if defined (sony) #if defined (MIPSEB) /* BFD wants "bsd" instead of "newsos". Perhaps BFD should be changed, I don't know.... */ printf ("mips-sony-bsd\n"); exit (0); #else #include printf ("m68k-sony-newsos%s\n", #ifdef NEWSOS4 "4" #else "" #endif ); exit (0); #endif #endif #if defined (__arm) && defined (__acorn) && defined (__unix) printf ("arm-acorn-riscix\n"); exit (0); #endif #if defined (hp300) && !defined (hpux) printf ("m68k-hp-bsd\n"); exit (0); #endif #if defined (NeXT) #if !defined (__ARCHITECTURE__) #define __ARCHITECTURE__ "m68k" #endif int version; version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`; if (version < 4) printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version); else printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version); exit (0); #endif #if defined (MULTIMAX) || defined (n16) #if defined (UMAXV) printf ("ns32k-encore-sysv\n"); exit (0); #else #if defined (CMU) printf ("ns32k-encore-mach\n"); exit (0); #else printf ("ns32k-encore-bsd\n"); exit (0); #endif #endif #endif #if defined (__386BSD__) printf ("i386-pc-bsd\n"); exit (0); #endif #if defined (sequent) #if defined (i386) printf ("i386-sequent-dynix\n"); exit (0); #endif #if defined (ns32000) printf ("ns32k-sequent-dynix\n"); exit (0); #endif #endif #if defined (_SEQUENT_) struct utsname un; uname(&un); if (strncmp(un.version, "V2", 2) == 0) { printf ("i386-sequent-ptx2\n"); exit (0); } if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */ printf ("i386-sequent-ptx1\n"); exit (0); } printf ("i386-sequent-ptx\n"); exit (0); #endif #if defined (vax) # if !defined (ultrix) # include # if defined (BSD) # if BSD == 43 printf ("vax-dec-bsd4.3\n"); exit (0); # else # if BSD == 199006 printf ("vax-dec-bsd4.3reno\n"); exit (0); # else printf ("vax-dec-bsd\n"); exit (0); # endif # endif # else printf ("vax-dec-bsd\n"); exit (0); # endif # else printf ("vax-dec-ultrix\n"); exit (0); # endif #endif #if defined (alliant) && defined (i860) printf ("i860-alliant-bsd\n"); exit (0); #endif exit (1); } EOF $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && SYSTEM_NAME=`$dummy` && { echo "$SYSTEM_NAME"; exit; } # Apollos put the system type in the environment. test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit; } # Convex versions that predate uname can use getsysinfo(1) if [ -x /usr/convex/getsysinfo ] then case `getsysinfo -f cpu_type` in c1*) echo c1-convex-bsd exit ;; c2*) if getsysinfo -f scalar_acc then echo c32-convex-bsd else echo c2-convex-bsd fi exit ;; c34*) echo c34-convex-bsd exit ;; c38*) echo c38-convex-bsd exit ;; c4*) echo c4-convex-bsd exit ;; esac fi cat >&2 < in order to provide the needed information to handle your system. config.guess timestamp = $timestamp uname -m = `(uname -m) 2>/dev/null || echo unknown` uname -r = `(uname -r) 2>/dev/null || echo unknown` uname -s = `(uname -s) 2>/dev/null || echo unknown` uname -v = `(uname -v) 2>/dev/null || echo unknown` /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null` /bin/uname -X = `(/bin/uname -X) 2>/dev/null` hostinfo = `(hostinfo) 2>/dev/null` /bin/universe = `(/bin/universe) 2>/dev/null` /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null` /bin/arch = `(/bin/arch) 2>/dev/null` /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null` /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null` UNAME_MACHINE = ${UNAME_MACHINE} UNAME_RELEASE = ${UNAME_RELEASE} UNAME_SYSTEM = ${UNAME_SYSTEM} UNAME_VERSION = ${UNAME_VERSION} EOF exit 1 # Local variables: # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "timestamp='" # time-stamp-format: "%:y-%02m-%02d" # time-stamp-end: "'" # End: OpenAL-1.4.0.2/include/0000755000000000000000000000000012107331166011303 5ustar OpenAL-1.4.0.2/include/HsOpenALConfig.h0000644000000000000000000002426512107331166014224 0ustar /* include/HsOpenALConfig.h. Generated from HsOpenALConfig.h.in by configure. */ /* include/HsOpenALConfig.h.in. Generated from configure.ac by autoheader. */ /* Define to 1 if `alcCloseDevice' returns void. */ /* #undef ALCCLOSEDEVICE_VOID */ /* Define to 1 if `alcDestroyContext' returns void. */ #define ALCDESTROYCONTEXT_VOID 1 /* Define to 1 if `alcMakeContextCurrent' returns void. */ /* #undef ALCMAKECONTEXTCURRENT_VOID */ /* Define to 1 if `alcProcessContext' returns void. */ #define ALCPROCESSCONTEXT_VOID 1 /* Framework flags for AL, as a list of string literals. */ #define AL_FRAMEWORKS /* Library flags for AL, as a list of string literals. */ #define AL_LIBS "-lopenal" /* The value of ALC_ALL_ATTRIBUTES. */ #define CONST_ALC_ALL_ATTRIBUTES 4099 /* The value of ALC_ATTRIBUTES_SIZE. */ #define CONST_ALC_ATTRIBUTES_SIZE 4098 /* The value of ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER. */ #define CONST_ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER 785 /* The value of ALC_CAPTURE_DEVICE_SPECIFIER. */ #define CONST_ALC_CAPTURE_DEVICE_SPECIFIER 784 /* The value of ALC_CAPTURE_SAMPLES. */ #define CONST_ALC_CAPTURE_SAMPLES 786 /* The value of ALC_DEFAULT_DEVICE_SPECIFIER. */ #define CONST_ALC_DEFAULT_DEVICE_SPECIFIER 4100 /* The value of ALC_DEVICE_SPECIFIER. */ #define CONST_ALC_DEVICE_SPECIFIER 4101 /* The value of ALC_EXTENSIONS. */ #define CONST_ALC_EXTENSIONS 4102 /* The value of ALC_FALSE. */ #define CONST_ALC_FALSE 0 /* The value of ALC_FREQUENCY. */ #define CONST_ALC_FREQUENCY 4103 /* The value of ALC_INVALID_CONTEXT. */ #define CONST_ALC_INVALID_CONTEXT 40962 /* The value of ALC_INVALID_DEVICE. */ #define CONST_ALC_INVALID_DEVICE 40961 /* The value of ALC_INVALID_ENUM. */ #define CONST_ALC_INVALID_ENUM 40963 /* The value of ALC_INVALID_OPERATION. */ #define CONST_ALC_INVALID_OPERATION 40966 /* The value of ALC_INVALID_VALUE. */ #define CONST_ALC_INVALID_VALUE 40964 /* The value of ALC_MAJOR_VERSION. */ #define CONST_ALC_MAJOR_VERSION 4096 /* The value of ALC_MINOR_VERSION. */ #define CONST_ALC_MINOR_VERSION 4097 /* The value of ALC_MONO_SOURCES. */ #define CONST_ALC_MONO_SOURCES 4112 /* The value of ALC_NO_ERROR. */ #define CONST_ALC_NO_ERROR 0 /* The value of ALC_OUT_OF_MEMORY. */ #define CONST_ALC_OUT_OF_MEMORY 40965 /* The value of ALC_REFRESH. */ #define CONST_ALC_REFRESH 4104 /* The value of ALC_STEREO_SOURCES. */ #define CONST_ALC_STEREO_SOURCES 4113 /* The value of ALC_SYNC. */ #define CONST_ALC_SYNC 4105 /* The value of ALC_TRUE. */ #define CONST_ALC_TRUE 1 /* The value of AL_BITS. */ #define CONST_AL_BITS 8194 /* The value of AL_BUFFER. */ #define CONST_AL_BUFFER 4105 /* The value of AL_BUFFERS_PROCESSED. */ #define CONST_AL_BUFFERS_PROCESSED 4118 /* The value of AL_BUFFERS_QUEUED. */ #define CONST_AL_BUFFERS_QUEUED 4117 /* The value of AL_BYTE_OFFSET. */ #define CONST_AL_BYTE_OFFSET 4134 /* The value of AL_CHANNELS. */ #define CONST_AL_CHANNELS 8195 /* The value of AL_CONE_INNER_ANGLE. */ #define CONST_AL_CONE_INNER_ANGLE 4097 /* The value of AL_CONE_OUTER_ANGLE. */ #define CONST_AL_CONE_OUTER_ANGLE 4098 /* The value of AL_CONE_OUTER_GAIN. */ #define CONST_AL_CONE_OUTER_GAIN 4130 /* The value of AL_DIRECTION. */ #define CONST_AL_DIRECTION 4101 /* The value of AL_DISTANCE_MODEL. */ #define CONST_AL_DISTANCE_MODEL 53248 /* The value of AL_DOPPLER_FACTOR. */ #define CONST_AL_DOPPLER_FACTOR 49152 /* The value of AL_EXPONENT_DISTANCE. */ #define CONST_AL_EXPONENT_DISTANCE 53253 /* The value of AL_EXPONENT_DISTANCE_CLAMPED. */ #define CONST_AL_EXPONENT_DISTANCE_CLAMPED 53254 /* The value of AL_EXTENSIONS. */ #define CONST_AL_EXTENSIONS 45060 /* The value of AL_FALSE. */ #define CONST_AL_FALSE 0 /* The value of AL_FORMAT_MONO16. */ #define CONST_AL_FORMAT_MONO16 4353 /* The value of AL_FORMAT_MONO8. */ #define CONST_AL_FORMAT_MONO8 4352 /* The value of AL_FORMAT_STEREO16. */ #define CONST_AL_FORMAT_STEREO16 4355 /* The value of AL_FORMAT_STEREO8. */ #define CONST_AL_FORMAT_STEREO8 4354 /* The value of AL_FREQUENCY. */ #define CONST_AL_FREQUENCY 8193 /* The value of AL_GAIN. */ #define CONST_AL_GAIN 4106 /* The value of AL_INITIAL. */ #define CONST_AL_INITIAL 4113 /* The value of AL_INVALID_ENUM. */ #define CONST_AL_INVALID_ENUM 40962 /* The value of AL_INVALID_NAME. */ #define CONST_AL_INVALID_NAME 40961 /* The value of AL_INVALID_OPERATION. */ #define CONST_AL_INVALID_OPERATION 40964 /* The value of AL_INVALID_VALUE. */ #define CONST_AL_INVALID_VALUE 40963 /* The value of AL_INVERSE_DISTANCE. */ #define CONST_AL_INVERSE_DISTANCE 53249 /* The value of AL_INVERSE_DISTANCE_CLAMPED. */ #define CONST_AL_INVERSE_DISTANCE_CLAMPED 53250 /* The value of AL_LINEAR_DISTANCE. */ #define CONST_AL_LINEAR_DISTANCE 53251 /* The value of AL_LINEAR_DISTANCE_CLAMPED. */ #define CONST_AL_LINEAR_DISTANCE_CLAMPED 53252 /* The value of AL_LOOPING. */ #define CONST_AL_LOOPING 4103 /* The value of AL_MAX_DISTANCE. */ #define CONST_AL_MAX_DISTANCE 4131 /* The value of AL_MAX_GAIN. */ #define CONST_AL_MAX_GAIN 4110 /* The value of AL_MIN_GAIN. */ #define CONST_AL_MIN_GAIN 4109 /* The value of AL_NONE. */ #define CONST_AL_NONE 0 /* The value of AL_NO_ERROR. */ #define CONST_AL_NO_ERROR 0 /* The value of AL_ORIENTATION. */ #define CONST_AL_ORIENTATION 4111 /* The value of AL_OUT_OF_MEMORY. */ #define CONST_AL_OUT_OF_MEMORY 40965 /* The value of AL_PAUSED. */ #define CONST_AL_PAUSED 4115 /* The value of AL_PITCH. */ #define CONST_AL_PITCH 4099 /* The value of AL_PLAYING. */ #define CONST_AL_PLAYING 4114 /* The value of AL_POSITION. */ #define CONST_AL_POSITION 4100 /* The value of AL_REFERENCE_DISTANCE. */ #define CONST_AL_REFERENCE_DISTANCE 4128 /* The value of AL_RENDERER. */ #define CONST_AL_RENDERER 45059 /* The value of AL_ROLLOFF_FACTOR. */ #define CONST_AL_ROLLOFF_FACTOR 4129 /* The value of AL_SAMPLE_OFFSET. */ #define CONST_AL_SAMPLE_OFFSET 4133 /* The value of AL_SEC_OFFSET. */ #define CONST_AL_SEC_OFFSET 4132 /* The value of AL_SIZE. */ #define CONST_AL_SIZE 8196 /* The value of AL_SOURCE_RELATIVE. */ #define CONST_AL_SOURCE_RELATIVE 514 /* The value of AL_SOURCE_STATE. */ #define CONST_AL_SOURCE_STATE 4112 /* The value of AL_SOURCE_TYPE. */ #define CONST_AL_SOURCE_TYPE 4135 /* The value of AL_SPEED_OF_SOUND. */ #define CONST_AL_SPEED_OF_SOUND 49155 /* The value of AL_STATIC. */ #define CONST_AL_STATIC 4136 /* The value of AL_STOPPED. */ #define CONST_AL_STOPPED 4116 /* The value of AL_STREAMING. */ #define CONST_AL_STREAMING 4137 /* The value of AL_TRUE. */ #define CONST_AL_TRUE 1 /* The value of AL_UNDETERMINED. */ #define CONST_AL_UNDETERMINED 4144 /* The value of AL_VELOCITY. */ #define CONST_AL_VELOCITY 4102 /* The value of AL_VENDOR. */ #define CONST_AL_VENDOR 45057 /* The value of AL_VERSION. */ #define CONST_AL_VERSION 45058 /* Define to 1 if you have the header file. */ #define HAVE_AL_ALC_H 1 /* Define to 1 if you have the header file. */ #define HAVE_AL_ALEXT_H 1 /* Define to 1 if you have the header file. */ #define HAVE_AL_AL_H 1 /* Define to 1 if you have the header file. */ #define HAVE_INTTYPES_H 1 /* Define to 1 if you have the header file. */ #define HAVE_MEMORY_H 1 /* Define to 1 if you have the header file. */ /* #undef HAVE_OPENAL_ALC_H */ /* Define to 1 if you have the header file. */ /* #undef HAVE_OPENAL_ALEXT_H */ /* Define to 1 if you have the header file. */ /* #undef HAVE_OPENAL_AL_H */ /* Define to 1 if you have the header file. */ #define HAVE_STDINT_H 1 /* Define to 1 if you have the header file. */ #define HAVE_STDLIB_H 1 /* Define to 1 if you have the header file. */ #define HAVE_STRINGS_H 1 /* Define to 1 if you have the header file. */ #define HAVE_STRING_H 1 /* Define to 1 if you have the header file. */ #define HAVE_SYS_STAT_H 1 /* Define to 1 if you have the header file. */ #define HAVE_SYS_TYPES_H 1 /* Define to 1 if you have the header file. */ #define HAVE_UNISTD_H 1 /* Define to Haskell type for ALboolean */ #define HTYPE_ALBOOLEAN Int8 /* Define to Haskell type for ALbyte */ #define HTYPE_ALBYTE Int8 /* Define to Haskell type for ALCboolean */ #define HTYPE_ALCBOOLEAN Int8 /* Define to Haskell type for ALCbyte */ #define HTYPE_ALCBYTE Int8 /* Define to Haskell type for ALCchar */ #define HTYPE_ALCCHAR Int8 /* Define to Haskell type for ALCdouble */ #define HTYPE_ALCDOUBLE Double /* Define to Haskell type for ALCenum */ #define HTYPE_ALCENUM Int32 /* Define to Haskell type for ALCfloat */ #define HTYPE_ALCFLOAT Float /* Define to Haskell type for ALchar */ #define HTYPE_ALCHAR Int8 /* Define to Haskell type for ALCint */ #define HTYPE_ALCINT Int32 /* Define to Haskell type for ALCshort */ #define HTYPE_ALCSHORT Int16 /* Define to Haskell type for ALCsizei */ #define HTYPE_ALCSIZEI Int32 /* Define to Haskell type for ALCubyte */ #define HTYPE_ALCUBYTE Word8 /* Define to Haskell type for ALCuint */ #define HTYPE_ALCUINT Word32 /* Define to Haskell type for ALCushort */ #define HTYPE_ALCUSHORT Word16 /* Define to Haskell type for ALdouble */ #define HTYPE_ALDOUBLE Double /* Define to Haskell type for ALenum */ #define HTYPE_ALENUM Int32 /* Define to Haskell type for ALfloat */ #define HTYPE_ALFLOAT Float /* Define to Haskell type for ALint */ #define HTYPE_ALINT Int32 /* Define to Haskell type for ALshort */ #define HTYPE_ALSHORT Int16 /* Define to Haskell type for ALsizei */ #define HTYPE_ALSIZEI Int32 /* Define to Haskell type for ALubyte */ #define HTYPE_ALUBYTE Word8 /* Define to Haskell type for ALuint */ #define HTYPE_ALUINT Word32 /* Define to Haskell type for ALushort */ #define HTYPE_ALUSHORT Word16 /* Define to the address where bug reports for this package should be sent. */ #define PACKAGE_BUGREPORT "sven.panne@aedion.de" /* Define to the full name of this package. */ #define PACKAGE_NAME "Haskell HOpenAL package" /* Define to the full name and version of this package. */ #define PACKAGE_STRING "Haskell HOpenAL package 1.3.1.3" /* Define to the one symbol short name of this package. */ #define PACKAGE_TARNAME "OpenAL" /* Define to the version of this package. */ #define PACKAGE_VERSION "1.3.1.3" /* Define to 1 if you have the ANSI C header files. */ #define STDC_HEADERS 1 OpenAL-1.4.0.2/include/HsOpenAL.h0000644000000000000000000000155112107326776013102 0ustar /* include/HsOpenAL.h. Generated from HsOpenAL.h.in by configure. */ /* ----------------------------------------------------------------------------- * * Module : C support for Sound.OpenAL * Copyright : (c) Sven Panne 2003-2005 * License : BSD-style (see the file libraries/OpenAL/LICENSE) * * Maintainer : sven.panne@aedion.de * Stability : provisional * Portability : portable * * -------------------------------------------------------------------------- */ #ifndef HSOPENAL_H #define HSOPENAL_H /* Define to 1 if you have the header file. */ #define HAVE_AL_ALC_H 1 /* Define to 1 if you have the header file. */ /* #undef HAVE_OPENAL_ALC_H */ #if defined(HAVE_AL_ALC_H) #include #include #elif defined(HAVE_OPENAL_ALC_H) #include #include #endif #endif OpenAL-1.4.0.2/include/HsOpenALConfig.h.in0000644000000000000000000002237112107326777014641 0ustar /* include/HsOpenALConfig.h.in. Generated from configure.ac by autoheader. */ /* Define to 1 if `alcCloseDevice' returns void. */ #undef ALCCLOSEDEVICE_VOID /* Define to 1 if `alcDestroyContext' returns void. */ #undef ALCDESTROYCONTEXT_VOID /* Define to 1 if `alcMakeContextCurrent' returns void. */ #undef ALCMAKECONTEXTCURRENT_VOID /* Define to 1 if `alcProcessContext' returns void. */ #undef ALCPROCESSCONTEXT_VOID /* Framework flags for AL, as a list of string literals. */ #undef AL_FRAMEWORKS /* Library flags for AL, as a list of string literals. */ #undef AL_LIBS /* The value of ALC_ALL_ATTRIBUTES. */ #undef CONST_ALC_ALL_ATTRIBUTES /* The value of ALC_ATTRIBUTES_SIZE. */ #undef CONST_ALC_ATTRIBUTES_SIZE /* The value of ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER. */ #undef CONST_ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER /* The value of ALC_CAPTURE_DEVICE_SPECIFIER. */ #undef CONST_ALC_CAPTURE_DEVICE_SPECIFIER /* The value of ALC_CAPTURE_SAMPLES. */ #undef CONST_ALC_CAPTURE_SAMPLES /* The value of ALC_DEFAULT_DEVICE_SPECIFIER. */ #undef CONST_ALC_DEFAULT_DEVICE_SPECIFIER /* The value of ALC_DEVICE_SPECIFIER. */ #undef CONST_ALC_DEVICE_SPECIFIER /* The value of ALC_EXTENSIONS. */ #undef CONST_ALC_EXTENSIONS /* The value of ALC_FALSE. */ #undef CONST_ALC_FALSE /* The value of ALC_FREQUENCY. */ #undef CONST_ALC_FREQUENCY /* The value of ALC_INVALID_CONTEXT. */ #undef CONST_ALC_INVALID_CONTEXT /* The value of ALC_INVALID_DEVICE. */ #undef CONST_ALC_INVALID_DEVICE /* The value of ALC_INVALID_ENUM. */ #undef CONST_ALC_INVALID_ENUM /* The value of ALC_INVALID_OPERATION. */ #undef CONST_ALC_INVALID_OPERATION /* The value of ALC_INVALID_VALUE. */ #undef CONST_ALC_INVALID_VALUE /* The value of ALC_MAJOR_VERSION. */ #undef CONST_ALC_MAJOR_VERSION /* The value of ALC_MINOR_VERSION. */ #undef CONST_ALC_MINOR_VERSION /* The value of ALC_MONO_SOURCES. */ #undef CONST_ALC_MONO_SOURCES /* The value of ALC_NO_ERROR. */ #undef CONST_ALC_NO_ERROR /* The value of ALC_OUT_OF_MEMORY. */ #undef CONST_ALC_OUT_OF_MEMORY /* The value of ALC_REFRESH. */ #undef CONST_ALC_REFRESH /* The value of ALC_STEREO_SOURCES. */ #undef CONST_ALC_STEREO_SOURCES /* The value of ALC_SYNC. */ #undef CONST_ALC_SYNC /* The value of ALC_TRUE. */ #undef CONST_ALC_TRUE /* The value of AL_BITS. */ #undef CONST_AL_BITS /* The value of AL_BUFFER. */ #undef CONST_AL_BUFFER /* The value of AL_BUFFERS_PROCESSED. */ #undef CONST_AL_BUFFERS_PROCESSED /* The value of AL_BUFFERS_QUEUED. */ #undef CONST_AL_BUFFERS_QUEUED /* The value of AL_BYTE_OFFSET. */ #undef CONST_AL_BYTE_OFFSET /* The value of AL_CHANNELS. */ #undef CONST_AL_CHANNELS /* The value of AL_CONE_INNER_ANGLE. */ #undef CONST_AL_CONE_INNER_ANGLE /* The value of AL_CONE_OUTER_ANGLE. */ #undef CONST_AL_CONE_OUTER_ANGLE /* The value of AL_CONE_OUTER_GAIN. */ #undef CONST_AL_CONE_OUTER_GAIN /* The value of AL_DIRECTION. */ #undef CONST_AL_DIRECTION /* The value of AL_DISTANCE_MODEL. */ #undef CONST_AL_DISTANCE_MODEL /* The value of AL_DOPPLER_FACTOR. */ #undef CONST_AL_DOPPLER_FACTOR /* The value of AL_EXPONENT_DISTANCE. */ #undef CONST_AL_EXPONENT_DISTANCE /* The value of AL_EXPONENT_DISTANCE_CLAMPED. */ #undef CONST_AL_EXPONENT_DISTANCE_CLAMPED /* The value of AL_EXTENSIONS. */ #undef CONST_AL_EXTENSIONS /* The value of AL_FALSE. */ #undef CONST_AL_FALSE /* The value of AL_FORMAT_MONO16. */ #undef CONST_AL_FORMAT_MONO16 /* The value of AL_FORMAT_MONO8. */ #undef CONST_AL_FORMAT_MONO8 /* The value of AL_FORMAT_STEREO16. */ #undef CONST_AL_FORMAT_STEREO16 /* The value of AL_FORMAT_STEREO8. */ #undef CONST_AL_FORMAT_STEREO8 /* The value of AL_FREQUENCY. */ #undef CONST_AL_FREQUENCY /* The value of AL_GAIN. */ #undef CONST_AL_GAIN /* The value of AL_INITIAL. */ #undef CONST_AL_INITIAL /* The value of AL_INVALID_ENUM. */ #undef CONST_AL_INVALID_ENUM /* The value of AL_INVALID_NAME. */ #undef CONST_AL_INVALID_NAME /* The value of AL_INVALID_OPERATION. */ #undef CONST_AL_INVALID_OPERATION /* The value of AL_INVALID_VALUE. */ #undef CONST_AL_INVALID_VALUE /* The value of AL_INVERSE_DISTANCE. */ #undef CONST_AL_INVERSE_DISTANCE /* The value of AL_INVERSE_DISTANCE_CLAMPED. */ #undef CONST_AL_INVERSE_DISTANCE_CLAMPED /* The value of AL_LINEAR_DISTANCE. */ #undef CONST_AL_LINEAR_DISTANCE /* The value of AL_LINEAR_DISTANCE_CLAMPED. */ #undef CONST_AL_LINEAR_DISTANCE_CLAMPED /* The value of AL_LOOPING. */ #undef CONST_AL_LOOPING /* The value of AL_MAX_DISTANCE. */ #undef CONST_AL_MAX_DISTANCE /* The value of AL_MAX_GAIN. */ #undef CONST_AL_MAX_GAIN /* The value of AL_MIN_GAIN. */ #undef CONST_AL_MIN_GAIN /* The value of AL_NONE. */ #undef CONST_AL_NONE /* The value of AL_NO_ERROR. */ #undef CONST_AL_NO_ERROR /* The value of AL_ORIENTATION. */ #undef CONST_AL_ORIENTATION /* The value of AL_OUT_OF_MEMORY. */ #undef CONST_AL_OUT_OF_MEMORY /* The value of AL_PAUSED. */ #undef CONST_AL_PAUSED /* The value of AL_PITCH. */ #undef CONST_AL_PITCH /* The value of AL_PLAYING. */ #undef CONST_AL_PLAYING /* The value of AL_POSITION. */ #undef CONST_AL_POSITION /* The value of AL_REFERENCE_DISTANCE. */ #undef CONST_AL_REFERENCE_DISTANCE /* The value of AL_RENDERER. */ #undef CONST_AL_RENDERER /* The value of AL_ROLLOFF_FACTOR. */ #undef CONST_AL_ROLLOFF_FACTOR /* The value of AL_SAMPLE_OFFSET. */ #undef CONST_AL_SAMPLE_OFFSET /* The value of AL_SEC_OFFSET. */ #undef CONST_AL_SEC_OFFSET /* The value of AL_SIZE. */ #undef CONST_AL_SIZE /* The value of AL_SOURCE_RELATIVE. */ #undef CONST_AL_SOURCE_RELATIVE /* The value of AL_SOURCE_STATE. */ #undef CONST_AL_SOURCE_STATE /* The value of AL_SOURCE_TYPE. */ #undef CONST_AL_SOURCE_TYPE /* The value of AL_SPEED_OF_SOUND. */ #undef CONST_AL_SPEED_OF_SOUND /* The value of AL_STATIC. */ #undef CONST_AL_STATIC /* The value of AL_STOPPED. */ #undef CONST_AL_STOPPED /* The value of AL_STREAMING. */ #undef CONST_AL_STREAMING /* The value of AL_TRUE. */ #undef CONST_AL_TRUE /* The value of AL_UNDETERMINED. */ #undef CONST_AL_UNDETERMINED /* The value of AL_VELOCITY. */ #undef CONST_AL_VELOCITY /* The value of AL_VENDOR. */ #undef CONST_AL_VENDOR /* The value of AL_VERSION. */ #undef CONST_AL_VERSION /* Define to 1 if you have the header file. */ #undef HAVE_AL_ALC_H /* Define to 1 if you have the header file. */ #undef HAVE_AL_ALEXT_H /* Define to 1 if you have the header file. */ #undef HAVE_AL_AL_H /* Define to 1 if you have the header file. */ #undef HAVE_INTTYPES_H /* Define to 1 if you have the header file. */ #undef HAVE_MEMORY_H /* Define to 1 if you have the header file. */ #undef HAVE_OPENAL_ALC_H /* Define to 1 if you have the header file. */ #undef HAVE_OPENAL_ALEXT_H /* Define to 1 if you have the header file. */ #undef HAVE_OPENAL_AL_H /* Define to 1 if you have the header file. */ #undef HAVE_STDINT_H /* Define to 1 if you have the header file. */ #undef HAVE_STDLIB_H /* Define to 1 if you have the header file. */ #undef HAVE_STRINGS_H /* Define to 1 if you have the header file. */ #undef HAVE_STRING_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_STAT_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_TYPES_H /* Define to 1 if you have the header file. */ #undef HAVE_UNISTD_H /* Define to Haskell type for ALboolean */ #undef HTYPE_ALBOOLEAN /* Define to Haskell type for ALbyte */ #undef HTYPE_ALBYTE /* Define to Haskell type for ALCboolean */ #undef HTYPE_ALCBOOLEAN /* Define to Haskell type for ALCbyte */ #undef HTYPE_ALCBYTE /* Define to Haskell type for ALCchar */ #undef HTYPE_ALCCHAR /* Define to Haskell type for ALCdouble */ #undef HTYPE_ALCDOUBLE /* Define to Haskell type for ALCenum */ #undef HTYPE_ALCENUM /* Define to Haskell type for ALCfloat */ #undef HTYPE_ALCFLOAT /* Define to Haskell type for ALchar */ #undef HTYPE_ALCHAR /* Define to Haskell type for ALCint */ #undef HTYPE_ALCINT /* Define to Haskell type for ALCshort */ #undef HTYPE_ALCSHORT /* Define to Haskell type for ALCsizei */ #undef HTYPE_ALCSIZEI /* Define to Haskell type for ALCubyte */ #undef HTYPE_ALCUBYTE /* Define to Haskell type for ALCuint */ #undef HTYPE_ALCUINT /* Define to Haskell type for ALCushort */ #undef HTYPE_ALCUSHORT /* Define to Haskell type for ALdouble */ #undef HTYPE_ALDOUBLE /* Define to Haskell type for ALenum */ #undef HTYPE_ALENUM /* Define to Haskell type for ALfloat */ #undef HTYPE_ALFLOAT /* Define to Haskell type for ALint */ #undef HTYPE_ALINT /* Define to Haskell type for ALshort */ #undef HTYPE_ALSHORT /* Define to Haskell type for ALsizei */ #undef HTYPE_ALSIZEI /* Define to Haskell type for ALubyte */ #undef HTYPE_ALUBYTE /* Define to Haskell type for ALuint */ #undef HTYPE_ALUINT /* Define to Haskell type for ALushort */ #undef HTYPE_ALUSHORT /* Define to the address where bug reports for this package should be sent. */ #undef PACKAGE_BUGREPORT /* Define to the full name of this package. */ #undef PACKAGE_NAME /* Define to the full name and version of this package. */ #undef PACKAGE_STRING /* Define to the one symbol short name of this package. */ #undef PACKAGE_TARNAME /* Define to the version of this package. */ #undef PACKAGE_VERSION /* Define to 1 if you have the ANSI C header files. */ #undef STDC_HEADERS OpenAL-1.4.0.2/include/HsOpenAL.h.in0000644000000000000000000000143112107326777013505 0ustar /* ----------------------------------------------------------------------------- * * Module : C support for Sound.OpenAL * Copyright : (c) Sven Panne 2003-2005 * License : BSD-style (see the file libraries/OpenAL/LICENSE) * * Maintainer : sven.panne@aedion.de * Stability : provisional * Portability : portable * * -------------------------------------------------------------------------- */ #ifndef HSOPENAL_H #define HSOPENAL_H /* Define to 1 if you have the header file. */ #undef HAVE_AL_ALC_H /* Define to 1 if you have the header file. */ #undef HAVE_OPENAL_ALC_H #if defined(HAVE_AL_ALC_H) #include #include #elif defined(HAVE_OPENAL_ALC_H) #include #include #endif #endif OpenAL-1.4.0.2/Setup.hs0000644000000000000000000000016211733255111011312 0ustar module Main (main) where import Distribution.Simple main :: IO () main = defaultMainWithHooks autoconfUserHooks OpenAL-1.4.0.2/config.sub0000644000000000000000000007713011733255111011647 0ustar #! /bin/sh # Configuration validation subroutine script. # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, # 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. timestamp='2006-02-23' # This file is (in principle) common to ALL GNU software. # The presence of a machine in this file suggests that SOME GNU software # can handle that machine. It does not imply ALL GNU software can. # # This file is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA # 02110-1301, USA. # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. # Please send patches to . Submit a context # diff and a properly formatted ChangeLog entry. # # Configuration subroutine to validate and canonicalize a configuration type. # Supply the specified configuration type as an argument. # If it is invalid, we print an error message on stderr and exit with code 1. # Otherwise, we print the canonical config type on stdout and succeed. # This file is supposed to be the same for all GNU packages # and recognize all the CPU types, system types and aliases # that are meaningful with *any* GNU software. # Each package is responsible for reporting which valid configurations # it does not support. The user should be able to distinguish # a failure to support a valid configuration from a meaningless # configuration. # The goal of this file is to map all the various variations of a given # machine specification into a single specification in the form: # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM # or in some cases, the newer four-part form: # CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM # It is wrong to echo any other type of specification. me=`echo "$0" | sed -e 's,.*/,,'` usage="\ Usage: $0 [OPTION] CPU-MFR-OPSYS $0 [OPTION] ALIAS Canonicalize a configuration name. Operation modes: -h, --help print this help, then exit -t, --time-stamp print date of last modification, then exit -v, --version print version number, then exit Report bugs and patches to ." version="\ GNU config.sub ($timestamp) Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." help=" Try \`$me --help' for more information." # Parse command line while test $# -gt 0 ; do case $1 in --time-stamp | --time* | -t ) echo "$timestamp" ; exit ;; --version | -v ) echo "$version" ; exit ;; --help | --h* | -h ) echo "$usage"; exit ;; -- ) # Stop option processing shift; break ;; - ) # Use stdin as input. break ;; -* ) echo "$me: invalid option $1$help" exit 1 ;; *local*) # First pass through any local machine types. echo $1 exit ;; * ) break ;; esac done case $# in 0) echo "$me: missing argument$help" >&2 exit 1;; 1) ;; *) echo "$me: too many arguments$help" >&2 exit 1;; esac # Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any). # Here we must recognize all the valid KERNEL-OS combinations. maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'` case $maybe_os in nto-qnx* | linux-gnu* | linux-dietlibc | linux-newlib* | linux-uclibc* | \ uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | knetbsd*-gnu* | netbsd*-gnu* | \ storm-chaos* | os2-emx* | rtmk-nova*) os=-$maybe_os basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'` ;; *) basic_machine=`echo $1 | sed 's/-[^-]*$//'` if [ $basic_machine != $1 ] then os=`echo $1 | sed 's/.*-/-/'` else os=; fi ;; esac ### Let's recognize common machines as not being operating systems so ### that things like config.sub decstation-3100 work. We also ### recognize some manufacturers as not being operating systems, so we ### can provide default operating systems below. case $os in -sun*os*) # Prevent following clause from handling this invalid input. ;; -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \ -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \ -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \ -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\ -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \ -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \ -apple | -axis | -knuth | -cray) os= basic_machine=$1 ;; -sim | -cisco | -oki | -wec | -winbond) os= basic_machine=$1 ;; -scout) ;; -wrs) os=-vxworks basic_machine=$1 ;; -chorusos*) os=-chorusos basic_machine=$1 ;; -chorusrdb) os=-chorusrdb basic_machine=$1 ;; -hiux*) os=-hiuxwe2 ;; -sco6) os=-sco5v6 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco5) os=-sco3.2v5 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco4) os=-sco3.2v4 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco3.2.[4-9]*) os=`echo $os | sed -e 's/sco3.2./sco3.2v/'` basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco3.2v[4-9]*) # Don't forget version if it is 3.2v4 or newer. basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco5v6*) # Don't forget version if it is 3.2v4 or newer. basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco*) os=-sco3.2v2 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -udk*) basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -isc) os=-isc2.2 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -clix*) basic_machine=clipper-intergraph ;; -isc*) basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -lynx*) os=-lynxos ;; -ptx*) basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'` ;; -windowsnt*) os=`echo $os | sed -e 's/windowsnt/winnt/'` ;; -psos*) os=-psos ;; -mint | -mint[0-9]*) basic_machine=m68k-atari os=-mint ;; esac # Decode aliases for certain CPU-COMPANY combinations. case $basic_machine in # Recognize the basic CPU types without company name. # Some are omitted here because they have special meanings below. 1750a | 580 \ | a29k \ | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \ | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \ | am33_2.0 \ | arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr \ | bfin \ | c4x | clipper \ | d10v | d30v | dlx | dsp16xx \ | fr30 | frv \ | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \ | i370 | i860 | i960 | ia64 \ | ip2k | iq2000 \ | m32r | m32rle | m68000 | m68k | m88k | maxq | mb | microblaze | mcore \ | mips | mipsbe | mipseb | mipsel | mipsle \ | mips16 \ | mips64 | mips64el \ | mips64vr | mips64vrel \ | mips64orion | mips64orionel \ | mips64vr4100 | mips64vr4100el \ | mips64vr4300 | mips64vr4300el \ | mips64vr5000 | mips64vr5000el \ | mips64vr5900 | mips64vr5900el \ | mipsisa32 | mipsisa32el \ | mipsisa32r2 | mipsisa32r2el \ | mipsisa64 | mipsisa64el \ | mipsisa64r2 | mipsisa64r2el \ | mipsisa64sb1 | mipsisa64sb1el \ | mipsisa64sr71k | mipsisa64sr71kel \ | mipstx39 | mipstx39el \ | mn10200 | mn10300 \ | mt \ | msp430 \ | nios | nios2 \ | ns16k | ns32k \ | or32 \ | pdp10 | pdp11 | pj | pjl \ | powerpc | powerpc64 | powerpc64le | powerpcle | ppcbe \ | pyramid \ | sh | sh[1234] | sh[24]a | sh[23]e | sh[34]eb | shbe | shle | sh[1234]le | sh3ele \ | sh64 | sh64le \ | sparc | sparc64 | sparc64b | sparc86x | sparclet | sparclite \ | sparcv8 | sparcv9 | sparcv9b \ | strongarm \ | tahoe | thumb | tic4x | tic80 | tron \ | v850 | v850e \ | we32k \ | x86 | xscale | xscalee[bl] | xstormy16 | xtensa \ | z8k) basic_machine=$basic_machine-unknown ;; m32c) basic_machine=$basic_machine-unknown ;; m6811 | m68hc11 | m6812 | m68hc12) # Motorola 68HC11/12. basic_machine=$basic_machine-unknown os=-none ;; m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k) ;; ms1) basic_machine=mt-unknown ;; # We use `pc' rather than `unknown' # because (1) that's what they normally are, and # (2) the word "unknown" tends to confuse beginning users. i*86 | x86_64) basic_machine=$basic_machine-pc ;; # Object if more than one company name word. *-*-*) echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 exit 1 ;; # Recognize the basic CPU types with company name. 580-* \ | a29k-* \ | alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \ | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \ | alphapca5[67]-* | alpha64pca5[67]-* | arc-* \ | arm-* | armbe-* | armle-* | armeb-* | armv*-* \ | avr-* \ | bfin-* | bs2000-* \ | c[123]* | c30-* | [cjt]90-* | c4x-* | c54x-* | c55x-* | c6x-* \ | clipper-* | craynv-* | cydra-* \ | d10v-* | d30v-* | dlx-* \ | elxsi-* \ | f30[01]-* | f700-* | fr30-* | frv-* | fx80-* \ | h8300-* | h8500-* \ | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \ | i*86-* | i860-* | i960-* | ia64-* \ | ip2k-* | iq2000-* \ | m32r-* | m32rle-* \ | m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \ | m88110-* | m88k-* | maxq-* | mcore-* \ | mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \ | mips16-* \ | mips64-* | mips64el-* \ | mips64vr-* | mips64vrel-* \ | mips64orion-* | mips64orionel-* \ | mips64vr4100-* | mips64vr4100el-* \ | mips64vr4300-* | mips64vr4300el-* \ | mips64vr5000-* | mips64vr5000el-* \ | mips64vr5900-* | mips64vr5900el-* \ | mipsisa32-* | mipsisa32el-* \ | mipsisa32r2-* | mipsisa32r2el-* \ | mipsisa64-* | mipsisa64el-* \ | mipsisa64r2-* | mipsisa64r2el-* \ | mipsisa64sb1-* | mipsisa64sb1el-* \ | mipsisa64sr71k-* | mipsisa64sr71kel-* \ | mipstx39-* | mipstx39el-* \ | mmix-* \ | mt-* \ | msp430-* \ | nios-* | nios2-* \ | none-* | np1-* | ns16k-* | ns32k-* \ | orion-* \ | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \ | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* | ppcbe-* \ | pyramid-* \ | romp-* | rs6000-* \ | sh-* | sh[1234]-* | sh[24]a-* | sh[23]e-* | sh[34]eb-* | shbe-* \ | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \ | sparc-* | sparc64-* | sparc64b-* | sparc86x-* | sparclet-* \ | sparclite-* \ | sparcv8-* | sparcv9-* | sparcv9b-* | strongarm-* | sv1-* | sx?-* \ | tahoe-* | thumb-* \ | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \ | tron-* \ | v850-* | v850e-* | vax-* \ | we32k-* \ | x86-* | x86_64-* | xps100-* | xscale-* | xscalee[bl]-* \ | xstormy16-* | xtensa-* \ | ymp-* \ | z8k-*) ;; m32c-*) ;; # Recognize the various machine names and aliases which stand # for a CPU type and a company and sometimes even an OS. 386bsd) basic_machine=i386-unknown os=-bsd ;; 3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc) basic_machine=m68000-att ;; 3b*) basic_machine=we32k-att ;; a29khif) basic_machine=a29k-amd os=-udi ;; abacus) basic_machine=abacus-unknown ;; adobe68k) basic_machine=m68010-adobe os=-scout ;; alliant | fx80) basic_machine=fx80-alliant ;; altos | altos3068) basic_machine=m68k-altos ;; am29k) basic_machine=a29k-none os=-bsd ;; amd64) basic_machine=x86_64-pc ;; amd64-*) basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'` ;; amdahl) basic_machine=580-amdahl os=-sysv ;; amiga | amiga-*) basic_machine=m68k-unknown ;; amigaos | amigados) basic_machine=m68k-unknown os=-amigaos ;; amigaunix | amix) basic_machine=m68k-unknown os=-sysv4 ;; apollo68) basic_machine=m68k-apollo os=-sysv ;; apollo68bsd) basic_machine=m68k-apollo os=-bsd ;; aux) basic_machine=m68k-apple os=-aux ;; balance) basic_machine=ns32k-sequent os=-dynix ;; c90) basic_machine=c90-cray os=-unicos ;; convex-c1) basic_machine=c1-convex os=-bsd ;; convex-c2) basic_machine=c2-convex os=-bsd ;; convex-c32) basic_machine=c32-convex os=-bsd ;; convex-c34) basic_machine=c34-convex os=-bsd ;; convex-c38) basic_machine=c38-convex os=-bsd ;; cray | j90) basic_machine=j90-cray os=-unicos ;; craynv) basic_machine=craynv-cray os=-unicosmp ;; cr16c) basic_machine=cr16c-unknown os=-elf ;; crds | unos) basic_machine=m68k-crds ;; crisv32 | crisv32-* | etraxfs*) basic_machine=crisv32-axis ;; cris | cris-* | etrax*) basic_machine=cris-axis ;; crx) basic_machine=crx-unknown os=-elf ;; da30 | da30-*) basic_machine=m68k-da30 ;; decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn) basic_machine=mips-dec ;; decsystem10* | dec10*) basic_machine=pdp10-dec os=-tops10 ;; decsystem20* | dec20*) basic_machine=pdp10-dec os=-tops20 ;; delta | 3300 | motorola-3300 | motorola-delta \ | 3300-motorola | delta-motorola) basic_machine=m68k-motorola ;; delta88) basic_machine=m88k-motorola os=-sysv3 ;; djgpp) basic_machine=i586-pc os=-msdosdjgpp ;; dpx20 | dpx20-*) basic_machine=rs6000-bull os=-bosx ;; dpx2* | dpx2*-bull) basic_machine=m68k-bull os=-sysv3 ;; ebmon29k) basic_machine=a29k-amd os=-ebmon ;; elxsi) basic_machine=elxsi-elxsi os=-bsd ;; encore | umax | mmax) basic_machine=ns32k-encore ;; es1800 | OSE68k | ose68k | ose | OSE) basic_machine=m68k-ericsson os=-ose ;; fx2800) basic_machine=i860-alliant ;; genix) basic_machine=ns32k-ns ;; gmicro) basic_machine=tron-gmicro os=-sysv ;; go32) basic_machine=i386-pc os=-go32 ;; h3050r* | hiux*) basic_machine=hppa1.1-hitachi os=-hiuxwe2 ;; h8300hms) basic_machine=h8300-hitachi os=-hms ;; h8300xray) basic_machine=h8300-hitachi os=-xray ;; h8500hms) basic_machine=h8500-hitachi os=-hms ;; harris) basic_machine=m88k-harris os=-sysv3 ;; hp300-*) basic_machine=m68k-hp ;; hp300bsd) basic_machine=m68k-hp os=-bsd ;; hp300hpux) basic_machine=m68k-hp os=-hpux ;; hp3k9[0-9][0-9] | hp9[0-9][0-9]) basic_machine=hppa1.0-hp ;; hp9k2[0-9][0-9] | hp9k31[0-9]) basic_machine=m68000-hp ;; hp9k3[2-9][0-9]) basic_machine=m68k-hp ;; hp9k6[0-9][0-9] | hp6[0-9][0-9]) basic_machine=hppa1.0-hp ;; hp9k7[0-79][0-9] | hp7[0-79][0-9]) basic_machine=hppa1.1-hp ;; hp9k78[0-9] | hp78[0-9]) # FIXME: really hppa2.0-hp basic_machine=hppa1.1-hp ;; hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893) # FIXME: really hppa2.0-hp basic_machine=hppa1.1-hp ;; hp9k8[0-9][13679] | hp8[0-9][13679]) basic_machine=hppa1.1-hp ;; hp9k8[0-9][0-9] | hp8[0-9][0-9]) basic_machine=hppa1.0-hp ;; hppa-next) os=-nextstep3 ;; hppaosf) basic_machine=hppa1.1-hp os=-osf ;; hppro) basic_machine=hppa1.1-hp os=-proelf ;; i370-ibm* | ibm*) basic_machine=i370-ibm ;; # I'm not sure what "Sysv32" means. Should this be sysv3.2? i*86v32) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-sysv32 ;; i*86v4*) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-sysv4 ;; i*86v) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-sysv ;; i*86sol2) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-solaris2 ;; i386mach) basic_machine=i386-mach os=-mach ;; i386-vsta | vsta) basic_machine=i386-unknown os=-vsta ;; iris | iris4d) basic_machine=mips-sgi case $os in -irix*) ;; *) os=-irix4 ;; esac ;; isi68 | isi) basic_machine=m68k-isi os=-sysv ;; m88k-omron*) basic_machine=m88k-omron ;; magnum | m3230) basic_machine=mips-mips os=-sysv ;; merlin) basic_machine=ns32k-utek os=-sysv ;; mingw32) basic_machine=i386-pc os=-mingw32 ;; miniframe) basic_machine=m68000-convergent ;; *mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*) basic_machine=m68k-atari os=-mint ;; mips3*-*) basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'` ;; mips3*) basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown ;; monitor) basic_machine=m68k-rom68k os=-coff ;; morphos) basic_machine=powerpc-unknown os=-morphos ;; msdos) basic_machine=i386-pc os=-msdos ;; ms1-*) basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'` ;; mvs) basic_machine=i370-ibm os=-mvs ;; ncr3000) basic_machine=i486-ncr os=-sysv4 ;; netbsd386) basic_machine=i386-unknown os=-netbsd ;; netwinder) basic_machine=armv4l-rebel os=-linux ;; news | news700 | news800 | news900) basic_machine=m68k-sony os=-newsos ;; news1000) basic_machine=m68030-sony os=-newsos ;; news-3600 | risc-news) basic_machine=mips-sony os=-newsos ;; necv70) basic_machine=v70-nec os=-sysv ;; next | m*-next ) basic_machine=m68k-next case $os in -nextstep* ) ;; -ns2*) os=-nextstep2 ;; *) os=-nextstep3 ;; esac ;; nh3000) basic_machine=m68k-harris os=-cxux ;; nh[45]000) basic_machine=m88k-harris os=-cxux ;; nindy960) basic_machine=i960-intel os=-nindy ;; mon960) basic_machine=i960-intel os=-mon960 ;; nonstopux) basic_machine=mips-compaq os=-nonstopux ;; np1) basic_machine=np1-gould ;; nsr-tandem) basic_machine=nsr-tandem ;; op50n-* | op60c-*) basic_machine=hppa1.1-oki os=-proelf ;; openrisc | openrisc-*) basic_machine=or32-unknown ;; os400) basic_machine=powerpc-ibm os=-os400 ;; OSE68000 | ose68000) basic_machine=m68000-ericsson os=-ose ;; os68k) basic_machine=m68k-none os=-os68k ;; pa-hitachi) basic_machine=hppa1.1-hitachi os=-hiuxwe2 ;; paragon) basic_machine=i860-intel os=-osf ;; pbd) basic_machine=sparc-tti ;; pbb) basic_machine=m68k-tti ;; pc532 | pc532-*) basic_machine=ns32k-pc532 ;; pc98) basic_machine=i386-pc ;; pc98-*) basic_machine=i386-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentium | p5 | k5 | k6 | nexgen | viac3) basic_machine=i586-pc ;; pentiumpro | p6 | 6x86 | athlon | athlon_*) basic_machine=i686-pc ;; pentiumii | pentium2 | pentiumiii | pentium3) basic_machine=i686-pc ;; pentium4) basic_machine=i786-pc ;; pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*) basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentiumpro-* | p6-* | 6x86-* | athlon-*) basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*) basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentium4-*) basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pn) basic_machine=pn-gould ;; power) basic_machine=power-ibm ;; ppc) basic_machine=powerpc-unknown ;; ppc-*) basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ppcle | powerpclittle | ppc-le | powerpc-little) basic_machine=powerpcle-unknown ;; ppcle-* | powerpclittle-*) basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ppc64) basic_machine=powerpc64-unknown ;; ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ppc64le | powerpc64little | ppc64-le | powerpc64-little) basic_machine=powerpc64le-unknown ;; ppc64le-* | powerpc64little-*) basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ps2) basic_machine=i386-ibm ;; pw32) basic_machine=i586-unknown os=-pw32 ;; rdos) basic_machine=i386-pc os=-rdos ;; rom68k) basic_machine=m68k-rom68k os=-coff ;; rm[46]00) basic_machine=mips-siemens ;; rtpc | rtpc-*) basic_machine=romp-ibm ;; s390 | s390-*) basic_machine=s390-ibm ;; s390x | s390x-*) basic_machine=s390x-ibm ;; sa29200) basic_machine=a29k-amd os=-udi ;; sb1) basic_machine=mipsisa64sb1-unknown ;; sb1el) basic_machine=mipsisa64sb1el-unknown ;; sei) basic_machine=mips-sei os=-seiux ;; sequent) basic_machine=i386-sequent ;; sh) basic_machine=sh-hitachi os=-hms ;; sh64) basic_machine=sh64-unknown ;; sparclite-wrs | simso-wrs) basic_machine=sparclite-wrs os=-vxworks ;; sps7) basic_machine=m68k-bull os=-sysv2 ;; spur) basic_machine=spur-unknown ;; st2000) basic_machine=m68k-tandem ;; stratus) basic_machine=i860-stratus os=-sysv4 ;; sun2) basic_machine=m68000-sun ;; sun2os3) basic_machine=m68000-sun os=-sunos3 ;; sun2os4) basic_machine=m68000-sun os=-sunos4 ;; sun3os3) basic_machine=m68k-sun os=-sunos3 ;; sun3os4) basic_machine=m68k-sun os=-sunos4 ;; sun4os3) basic_machine=sparc-sun os=-sunos3 ;; sun4os4) basic_machine=sparc-sun os=-sunos4 ;; sun4sol2) basic_machine=sparc-sun os=-solaris2 ;; sun3 | sun3-*) basic_machine=m68k-sun ;; sun4) basic_machine=sparc-sun ;; sun386 | sun386i | roadrunner) basic_machine=i386-sun ;; sv1) basic_machine=sv1-cray os=-unicos ;; symmetry) basic_machine=i386-sequent os=-dynix ;; t3e) basic_machine=alphaev5-cray os=-unicos ;; t90) basic_machine=t90-cray os=-unicos ;; tic54x | c54x*) basic_machine=tic54x-unknown os=-coff ;; tic55x | c55x*) basic_machine=tic55x-unknown os=-coff ;; tic6x | c6x*) basic_machine=tic6x-unknown os=-coff ;; tx39) basic_machine=mipstx39-unknown ;; tx39el) basic_machine=mipstx39el-unknown ;; toad1) basic_machine=pdp10-xkl os=-tops20 ;; tower | tower-32) basic_machine=m68k-ncr ;; tpf) basic_machine=s390x-ibm os=-tpf ;; udi29k) basic_machine=a29k-amd os=-udi ;; ultra3) basic_machine=a29k-nyu os=-sym1 ;; v810 | necv810) basic_machine=v810-nec os=-none ;; vaxv) basic_machine=vax-dec os=-sysv ;; vms) basic_machine=vax-dec os=-vms ;; vpp*|vx|vx-*) basic_machine=f301-fujitsu ;; vxworks960) basic_machine=i960-wrs os=-vxworks ;; vxworks68) basic_machine=m68k-wrs os=-vxworks ;; vxworks29k) basic_machine=a29k-wrs os=-vxworks ;; w65*) basic_machine=w65-wdc os=-none ;; w89k-*) basic_machine=hppa1.1-winbond os=-proelf ;; xbox) basic_machine=i686-pc os=-mingw32 ;; xps | xps100) basic_machine=xps100-honeywell ;; ymp) basic_machine=ymp-cray os=-unicos ;; z8k-*-coff) basic_machine=z8k-unknown os=-sim ;; none) basic_machine=none-none os=-none ;; # Here we handle the default manufacturer of certain CPU types. It is in # some cases the only manufacturer, in others, it is the most popular. w89k) basic_machine=hppa1.1-winbond ;; op50n) basic_machine=hppa1.1-oki ;; op60c) basic_machine=hppa1.1-oki ;; romp) basic_machine=romp-ibm ;; mmix) basic_machine=mmix-knuth ;; rs6000) basic_machine=rs6000-ibm ;; vax) basic_machine=vax-dec ;; pdp10) # there are many clones, so DEC is not a safe bet basic_machine=pdp10-unknown ;; pdp11) basic_machine=pdp11-dec ;; we32k) basic_machine=we32k-att ;; sh[1234] | sh[24]a | sh[34]eb | sh[1234]le | sh[23]ele) basic_machine=sh-unknown ;; sparc | sparcv8 | sparcv9 | sparcv9b) basic_machine=sparc-sun ;; cydra) basic_machine=cydra-cydrome ;; orion) basic_machine=orion-highlevel ;; orion105) basic_machine=clipper-highlevel ;; mac | mpw | mac-mpw) basic_machine=m68k-apple ;; pmac | pmac-mpw) basic_machine=powerpc-apple ;; *-unknown) # Make sure to match an already-canonicalized machine name. ;; *) echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 exit 1 ;; esac # Here we canonicalize certain aliases for manufacturers. case $basic_machine in *-digital*) basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'` ;; *-commodore*) basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'` ;; *) ;; esac # Decode manufacturer-specific aliases for certain operating systems. if [ x"$os" != x"" ] then case $os in # First match some system type aliases # that might get confused with valid system types. # -solaris* is a basic system type, with this one exception. -solaris1 | -solaris1.*) os=`echo $os | sed -e 's|solaris1|sunos4|'` ;; -solaris) os=-solaris2 ;; -svr4*) os=-sysv4 ;; -unixware*) os=-sysv4.2uw ;; -gnu/linux*) os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'` ;; # First accept the basic system types. # The portable systems comes first. # Each alternative MUST END IN A *, to match a version number. # -sysv* is not here because it comes later, after sysvr4. -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \ | -*vms* | -sco* | -esix* | -isc* | -aix* | -sunos | -sunos[34]*\ | -hpux* | -unos* | -osf* | -luna* | -dgux* | -solaris* | -sym* \ | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \ | -aos* \ | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \ | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \ | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \ | -openbsd* | -solidbsd* \ | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \ | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \ | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \ | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \ | -chorusos* | -chorusrdb* \ | -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \ | -mingw32* | -linux-gnu* | -linux-newlib* | -linux-uclibc* \ | -uxpv* | -beos* | -mpeix* | -udk* \ | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \ | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \ | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \ | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \ | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \ | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \ | -skyos* | -haiku* | -rdos*) # Remember, each alternative MUST END IN *, to match a version number. ;; -qnx*) case $basic_machine in x86-* | i*86-*) ;; *) os=-nto$os ;; esac ;; -nto-qnx*) ;; -nto*) os=`echo $os | sed -e 's|nto|nto-qnx|'` ;; -sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \ | -windows* | -osx | -abug | -netware* | -os9* | -beos* | -haiku* \ | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*) ;; -mac*) os=`echo $os | sed -e 's|mac|macos|'` ;; -linux-dietlibc) os=-linux-dietlibc ;; -linux*) os=`echo $os | sed -e 's|linux|linux-gnu|'` ;; -sunos5*) os=`echo $os | sed -e 's|sunos5|solaris2|'` ;; -sunos6*) os=`echo $os | sed -e 's|sunos6|solaris3|'` ;; -opened*) os=-openedition ;; -os400*) os=-os400 ;; -wince*) os=-wince ;; -osfrose*) os=-osfrose ;; -osf*) os=-osf ;; -utek*) os=-bsd ;; -dynix*) os=-bsd ;; -acis*) os=-aos ;; -atheos*) os=-atheos ;; -syllable*) os=-syllable ;; -386bsd) os=-bsd ;; -ctix* | -uts*) os=-sysv ;; -nova*) os=-rtmk-nova ;; -ns2 ) os=-nextstep2 ;; -nsk*) os=-nsk ;; # Preserve the version number of sinix5. -sinix5.*) os=`echo $os | sed -e 's|sinix|sysv|'` ;; -sinix*) os=-sysv4 ;; -tpf*) os=-tpf ;; -triton*) os=-sysv3 ;; -oss*) os=-sysv3 ;; -svr4) os=-sysv4 ;; -svr3) os=-sysv3 ;; -sysvr4) os=-sysv4 ;; # This must come after -sysvr4. -sysv*) ;; -ose*) os=-ose ;; -es1800*) os=-ose ;; -xenix) os=-xenix ;; -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) os=-mint ;; -aros*) os=-aros ;; -kaos*) os=-kaos ;; -zvmoe) os=-zvmoe ;; -none) ;; *) # Get rid of the `-' at the beginning of $os. os=`echo $os | sed 's/[^-]*-//'` echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2 exit 1 ;; esac else # Here we handle the default operating systems that come with various machines. # The value should be what the vendor currently ships out the door with their # machine or put another way, the most popular os provided with the machine. # Note that if you're going to try to match "-MANUFACTURER" here (say, # "-sun"), then you have to tell the case statement up towards the top # that MANUFACTURER isn't an operating system. Otherwise, code above # will signal an error saying that MANUFACTURER isn't an operating # system, and we'll never get to this point. case $basic_machine in *-acorn) os=-riscix1.2 ;; arm*-rebel) os=-linux ;; arm*-semi) os=-aout ;; c4x-* | tic4x-*) os=-coff ;; # This must come before the *-dec entry. pdp10-*) os=-tops20 ;; pdp11-*) os=-none ;; *-dec | vax-*) os=-ultrix4.2 ;; m68*-apollo) os=-domain ;; i386-sun) os=-sunos4.0.2 ;; m68000-sun) os=-sunos3 # This also exists in the configure program, but was not the # default. # os=-sunos4 ;; m68*-cisco) os=-aout ;; mips*-cisco) os=-elf ;; mips*-*) os=-elf ;; or32-*) os=-coff ;; *-tti) # must be before sparc entry or we get the wrong os. os=-sysv3 ;; sparc-* | *-sun) os=-sunos4.1.1 ;; *-be) os=-beos ;; *-haiku) os=-haiku ;; *-ibm) os=-aix ;; *-knuth) os=-mmixware ;; *-wec) os=-proelf ;; *-winbond) os=-proelf ;; *-oki) os=-proelf ;; *-hp) os=-hpux ;; *-hitachi) os=-hiux ;; i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent) os=-sysv ;; *-cbm) os=-amigaos ;; *-dg) os=-dgux ;; *-dolphin) os=-sysv3 ;; m68k-ccur) os=-rtu ;; m88k-omron*) os=-luna ;; *-next ) os=-nextstep ;; *-sequent) os=-ptx ;; *-crds) os=-unos ;; *-ns) os=-genix ;; i370-*) os=-mvs ;; *-next) os=-nextstep3 ;; *-gould) os=-sysv ;; *-highlevel) os=-bsd ;; *-encore) os=-bsd ;; *-sgi) os=-irix ;; *-siemens) os=-sysv4 ;; *-masscomp) os=-rtu ;; f30[01]-fujitsu | f700-fujitsu) os=-uxpv ;; *-rom68k) os=-coff ;; *-*bug) os=-coff ;; *-apple) os=-macos ;; *-atari*) os=-mint ;; *) os=-none ;; esac fi # Here we handle the case where we know the os, and the CPU type, but not the # manufacturer. We pick the logical manufacturer. vendor=unknown case $basic_machine in *-unknown) case $os in -riscix*) vendor=acorn ;; -sunos*) vendor=sun ;; -aix*) vendor=ibm ;; -beos*) vendor=be ;; -hpux*) vendor=hp ;; -mpeix*) vendor=hp ;; -hiux*) vendor=hitachi ;; -unos*) vendor=crds ;; -dgux*) vendor=dg ;; -luna*) vendor=omron ;; -genix*) vendor=ns ;; -mvs* | -opened*) vendor=ibm ;; -os400*) vendor=ibm ;; -ptx*) vendor=sequent ;; -tpf*) vendor=ibm ;; -vxsim* | -vxworks* | -windiss*) vendor=wrs ;; -aux*) vendor=apple ;; -hms*) vendor=hitachi ;; -mpw* | -macos*) vendor=apple ;; -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) vendor=atari ;; -vos*) vendor=stratus ;; esac basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"` ;; esac echo $basic_machine$os exit # Local variables: # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "timestamp='" # time-stamp-format: "%:y-%02m-%02d" # time-stamp-end: "'" # End: