packages feed

OpenAL 1.4.0.2 → 1.7.0.5

raw patch · 78 files changed

Files

+ CHANGELOG.md view
@@ -0,0 +1,20 @@+1.7.0.5+-------+* Relaxed upper version bound for `StateVar` package.++1.7.0.4+-------+* Removed redundant constraints.++1.7.0.3+-------+* Relaxed upper version bound for `OpenGL` package.++1.7.0.2+-------+* Relaxed upper version bound for `transformers` package.+* Added `CHANGELOG.md` to distribution.++1.7.0.1+-------+* Relaxed bounds for `OpenGL` package.
LICENSE view
@@ -1,4 +1,4 @@-Copyright (c) 2003-2009, Sven Panne+Copyright (c) 2003-2016, Sven Panne All rights reserved.  Redistribution and use in source and binary forms, with or without
− OpenAL.buildinfo.in 
@@ -1,8 +0,0 @@--- @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.cabal view
@@ -1,59 +1,116 @@-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+name: OpenAL+version: 1.7.0.5+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: <http://connect.creativelabs.com/openal/>.-build-type:     Configure+  A Haskell binding for the OpenAL cross-platform 3D audio API,+  appropriate for use with gaming applications and many other+  types of audio applications.+  .+  On Windows, this package works well with the \"OpenAL Soft\" binary+  distribution from <http://kcat.strangesoft.net/openal.html>.+  Type \'cabal install --extra-lib-dirs=\<DIR\>\' where \<DIR\> is the+  directory where libOpenAL32.dll.a is located (must be an absolute path).+  Then rename soft_oal.dll to OpenAL32.dll and put it somewhere in+  the PATH. I found that c:\\Windows\\ worked.+  .+  This package has also been tested on GNU/Linux and iOS.+homepage: https://github.com/haskell-openal/ALUT+bug-reports: https://github.com/haskell-openal/ALUT/issues+copyright: Copyright (C) 2003-2016 Sven Panne+license: BSD3+license-file: LICENSE+author: Sven Panne+maintainer: Sven Panne <svenpanne@gmail.com>, Stephen Blackheath <haskell.openal2.stephen@blacksapphire.com>+category: Sound+build-type: Simple+tested-with:+  GHC == 7.0.4+  GHC == 7.2.2+  GHC == 7.4.2+  GHC == 7.6.3+  GHC == 7.8.4+  GHC == 7.10.3+  GHC == 8.0.2+  GHC == 8.2.2+  GHC == 8.4.3+  GHC == 8.6.5+  GHC == 8.8.1+cabal-version: >= 1.10 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+  CHANGELOG.md+  README.md++flag UseNativeWindowsLibraries+  description:+    When compiling under Windows, use the native libraries instead of e.g. the+    ones coming with Cygwin.++flag BuildExamples+  description: Build various OpenAL examples.+  default: False++library+  exposed-modules:+    Sound.OpenAL+    Sound.OpenAL.AL+    Sound.OpenAL.AL.Attenuation+    Sound.OpenAL.AL.BasicTypes+    Sound.OpenAL.AL.Buffer+    Sound.OpenAL.AL.Doppler+    Sound.OpenAL.AL.Errors+    Sound.OpenAL.AL.Extensions+    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.ALboolean+    Sound.OpenAL.AL.BufferInternal+    Sound.OpenAL.AL.Format+    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+  hs-source-dirs: src+  build-depends:+    base         >= 3    && < 5,+    transformers >= 0.2  && < 0.6,+    ObjectName   >= 1.1  && < 1.2,+    StateVar     >= 1.1  && < 1.3,+    OpenGL       >= 2.12 && < 3.1+  default-language: Haskell2010+  ghc-options: -Wall+  if impl(ghc > 8)+    ghc-options: -Wcompat+  other-extensions: CPP+  if os(windows) && flag(UseNativeWindowsLibraries)+    extra-libraries: OpenAL32+  else+    if os(darwin) || os(ios)+      frameworks: OpenAL+    else+      extra-libraries: openal++executable TestDevice+  if !flag(BuildExamples)+    buildable: False+  main-is: TestDevice.hs+  build-depends: base >= 3 && < 5, OpenAL+  hs-source-dirs: examples/test+  default-language: Haskell2010+  ghc-options: -Wall++source-repository head+  type: git+  location: https://github.com/haskell-openal/OpenAL.git
− README 
@@ -1,4 +0,0 @@-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.
+ README.md view
@@ -0,0 +1,4 @@+[![Hackage](https://img.shields.io/hackage/v/OpenAL.svg)](https://hackage.haskell.org/package/OpenAL)+[![Stackage LTS](https://www.stackage.org/package/OpenAL/badge/lts)](https://www.stackage.org/lts/package/OpenAL)+[![Stackage nightly](https://www.stackage.org/package/OpenAL/badge/nightly)](https://www.stackage.org/nightly/package/OpenAL)+[![Build Status](https://img.shields.io/travis/haskell-openal/OpenAL/master.svg)](https://travis-ci.org/haskell-openal/OpenAL)
Setup.hs view
@@ -1,6 +1,2 @@-module Main (main) where- import Distribution.Simple--main :: IO ()-main = defaultMainWithHooks autoconfUserHooks+main = defaultMain
− Sound/OpenAL.hs 
@@ -1,181 +0,0 @@------------------------------------------------------------------------------------ |--- 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--- <http://www.openal.org/titles.html>).------------------------------------------------------------------------------------- $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 <http://www.opengl.org/> 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--- <http://www.iasig.org/wg/closed/3dwg/3dwg.shtml>.------ 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 <http://www.openal.org/documentation.html>)--- 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.
− Sound/OpenAL/AL.hs 
@@ -1,128 +0,0 @@------------------------------------------------------------------------------------ |--- 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.
− Sound/OpenAL/AL/ALboolean.hs 
@@ -1,30 +0,0 @@--- #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)
− Sound/OpenAL/AL/Attenuation.hs 
@@ -1,211 +0,0 @@------------------------------------------------------------------------------------ |--- 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 ()
− Sound/OpenAL/AL/BasicTypes.hs 
@@ -1,49 +0,0 @@------------------------------------------------------------------------------------ |--- 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.
− Sound/OpenAL/AL/Buffer.hs 
@@ -1,182 +0,0 @@------------------------------------------------------------------------------------ |--- 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 ()
− Sound/OpenAL/AL/BufferInternal.hs 
@@ -1,75 +0,0 @@--- #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
− Sound/OpenAL/AL/Doppler.hs 
@@ -1,91 +0,0 @@------------------------------------------------------------------------------------ |--- 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).
− Sound/OpenAL/AL/Errors.hs 
@@ -1,87 +0,0 @@------------------------------------------------------------------------------------ |--- 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
− Sound/OpenAL/AL/Extensions.hs 
@@ -1,101 +0,0 @@------------------------------------------------------------------------------------ |--- 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 @\"/\<spec major number\>/./\<spec--- minor number\>/ /\<optional vendor version information\>/\"@.--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
− Sound/OpenAL/AL/Format.hs 
@@ -1,50 +0,0 @@--- #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)
− Sound/OpenAL/AL/Listener.hs 
@@ -1,148 +0,0 @@------------------------------------------------------------------------------------ |--- 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)
− Sound/OpenAL/AL/PeekPoke.hs 
@@ -1,59 +0,0 @@--- #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)
− Sound/OpenAL/AL/QueryUtils.hs 
@@ -1,122 +0,0 @@--- #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)
− Sound/OpenAL/AL/Source.hs 
@@ -1,764 +0,0 @@------------------------------------------------------------------------------------ |--- 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 ()
− Sound/OpenAL/AL/SourceState.hs 
@@ -1,46 +0,0 @@--- #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)
− Sound/OpenAL/AL/String.hs 
@@ -1,31 +0,0 @@--- #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
− Sound/OpenAL/AL/StringQueries.hs 
@@ -1,33 +0,0 @@------------------------------------------------------------------------------------ |--- 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)
− Sound/OpenAL/ALC.hs 
@@ -1,35 +0,0 @@------------------------------------------------------------------------------------ |--- 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
− Sound/OpenAL/ALC/ALCboolean.hs 
@@ -1,30 +0,0 @@--- #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)
− Sound/OpenAL/ALC/BasicTypes.hs 
@@ -1,24 +0,0 @@------------------------------------------------------------------------------------ |--- 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
− Sound/OpenAL/ALC/Capture.hs 
@@ -1,137 +0,0 @@------------------------------------------------------------------------------------ |--- 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
− Sound/OpenAL/ALC/Context.hs 
@@ -1,199 +0,0 @@------------------------------------------------------------------------------------ |--- 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)
− Sound/OpenAL/ALC/Device.hs 
@@ -1,222 +0,0 @@------------------------------------------------------------------------------------ |--- 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]))
− Sound/OpenAL/ALC/Errors.hs 
@@ -1,92 +0,0 @@------------------------------------------------------------------------------------ |--- 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
− Sound/OpenAL/ALC/Extensions.hs 
@@ -1,85 +0,0 @@------------------------------------------------------------------------------------ |--- 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
− Sound/OpenAL/ALC/QueryUtils.hs 
@@ -1,121 +0,0 @@--- #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
− Sound/OpenAL/ALC/String.hs 
@@ -1,42 +0,0 @@--- #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)
− Sound/OpenAL/Config.hs 
@@ -1,233 +0,0 @@--- #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
− Sound/OpenAL/Constants.hs 
@@ -1,166 +0,0 @@--- #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
− aclocal.m4 
@@ -1,318 +0,0 @@-# 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(<<AC_TYPE_NAME>>, translit(htype_$1, [a-z *], [A-Z_P]))dnl-dnl The cache variable name.-define(<<AC_CV_NAME>>, translit(fptools_cv_htype_$1, [ *], [_p]))dnl-define(<<AC_CV_NAME_supported>>, 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 <stdio.h>-#include <stddef.h>--#if HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif--#if HAVE_UNISTD_H-# include <unistd.h>-#endif--#if HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif--#if HAVE_FCNTL_H-# include <fcntl.h>-#endif--#if HAVE_SIGNAL_H-# include <signal.h>-#endif--#if HAVE_TIME_H-# include <time.h>-#endif--#if HAVE_TERMIOS_H-# include <termios.h>-#endif--#if HAVE_STRING_H-# include <string.h>-#endif--#if HAVE_CTYPE_H-# include <ctype.h>-#endif--#if defined(HAVE_GL_GL_H)-# include <GL/gl.h>-#elif defined(HAVE_OPENGL_GL_H)-# include <OpenGL/gl.h>-#endif--#if defined(HAVE_AL_AL_H)-# include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-# include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-# include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-# include <OpenAL/alc.h>-#endif--#if HAVE_SYS_RESOURCE_H-# include <sys/resource.h>-#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 <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-#include <OpenAL/alc.h>-#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 <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-#include <OpenAL/alc.h>-#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 <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-#include <OpenAL/alc.h>-#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 <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-#include <OpenAL/alc.h>-#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
− config.guess 
@@ -1,1497 +0,0 @@-#! /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 <per@bothner.com>.-# Please send patches to <config-patches@gnu.org>.  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 <config-patches@gnu.org>."--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 <stdio.h>  /* 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 <sys/systemcfg.h>--		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 <stdlib.h>-              #include <unistd.h>--              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 <unistd.h>-	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 <features.h>-	#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' </usr/options/cb.name`-		echo ${UNAME_MACHINE}-pc-isc$UNAME_REL-	elif /bin/uname -X 2>/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 <Richard.M.Bartel@ccMail.Census.GOV>-        echo i586-unisys-sysv4-        exit ;;-    *:UNIX_System_V:4*:FTX*)-	# From Gerald Hewes <hewes@openmarket.com>.-	# 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 <<EOF-#ifdef _SEQUENT_-# include <sys/types.h>-# include <sys/utsname.h>-#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 <sys/param.h>-  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 <sys/param.h>-#  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 <<EOF-$0: unable to guess system type--This script, last modified $timestamp, has failed to recognize-the operating system you are using. It is advised that you-download the most up to date version of the config scripts from--  http://savannah.gnu.org/cgi-bin/viewcvs/*checkout*/config/config/config.guess-and-  http://savannah.gnu.org/cgi-bin/viewcvs/*checkout*/config/config/config.sub--If the version you run ($0) is already up to date, please-send the following data and any information you think might be-pertinent to <config-patches@gnu.org> 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:
− config.sub 
@@ -1,1608 +0,0 @@-#! /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 <config-patches@gnu.org>.  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 <config-patches@gnu.org>."--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:
− configure 
@@ -1,8104 +0,0 @@-#! /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 <sven.panne@aedion.de>.-#-#-# 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 </dev/null-exec 6>&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 <stdio.h>-#ifdef HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif-#ifdef HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif-#ifdef STDC_HEADERS-# include <stdlib.h>-# include <stddef.h>-#else-# ifdef HAVE_STDLIB_H-#  include <stdlib.h>-# endif-#endif-#ifdef HAVE_STRING_H-# if !defined STDC_HEADERS && defined HAVE_MEMORY_H-#  include <memory.h>-# endif-# include <string.h>-#endif-#ifdef HAVE_STRINGS_H-# include <strings.h>-#endif-#ifdef HAVE_INTTYPES_H-# include <inttypes.h>-#endif-#ifdef HAVE_STDINT_H-# include <stdint.h>-#endif-#ifdef HAVE_UNISTD_H-# include <unistd.h>-#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<lib dir> if you have libraries in a-              nonstandard directory <lib dir>-  LIBS        libraries to pass to the linker, e.g. -l<library>-  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if-              you have headers in a nonstandard directory <include dir>-  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 <sven.panne@aedion.de>.-_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 <stdio.h>-#include <stdlib.h>-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 <conftest.val; ac_retval=0-else-  ac_retval=1-fi-rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \-  conftest.$ac_objext conftest.beam conftest.$ac_ext-rm -f conftest.val--  fi-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno-  as_fn_set_status $ac_retval--} # ac_fn_c_compute_int-cat >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 <stdio.h>-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 <stdarg.h>-#include <stdio.h>-#include <sys/types.h>-#include <sys/stat.h>-/* 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 <limits.h> to <assert.h> if __STDC__ is defined, since-  # <limits.h> 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 <limits.h>-#else-# include <assert.h>-#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 <ac_nonexistent.h>-_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 <limits.h> to <assert.h> if __STDC__ is defined, since-  # <limits.h> 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 <limits.h>-#else-# include <assert.h>-#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 <ac_nonexistent.h>-_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 <stdlib.h>-#include <stdarg.h>-#include <string.h>-#include <float.h>--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 <string.h>--_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 <stdlib.h>--_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 <ctype.h>-#include <stdlib.h>-#if ((' ' & 0x0FF) == 0x020)-# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')-# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))-#else-# define ISLOWER(c) \-		   (('a' <= (c) && (c) <= 'i') \-		     || ('j' <= (c) && (c) <= 'r') \-		     || ('s' <= (c) && (c) <= 'z'))-# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))-#endif--#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))-int-main ()-{-  int i;-  for (i = 0; i < 256; i++)-    if (XOR (islower (i), ISLOWER (i))-	|| toupper (i) != TOUPPER (i))-      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 <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-#include <OpenAL/alc.h>-#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 <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-#include <OpenAL/alc.h>-#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 <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-#include <OpenAL/alc.h>-#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 <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-#include <OpenAL/alc.h>-#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 <stdio.h>-#include <stddef.h>--#if HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif--#if HAVE_UNISTD_H-# include <unistd.h>-#endif--#if HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif--#if HAVE_FCNTL_H-# include <fcntl.h>-#endif--#if HAVE_SIGNAL_H-# include <signal.h>-#endif--#if HAVE_TIME_H-# include <time.h>-#endif--#if HAVE_TERMIOS_H-# include <termios.h>-#endif--#if HAVE_STRING_H-# include <string.h>-#endif--#if HAVE_CTYPE_H-# include <ctype.h>-#endif--#if defined(HAVE_GL_GL_H)-# include <GL/gl.h>-#elif defined(HAVE_OPENGL_GL_H)-# include <OpenGL/gl.h>-#endif--#if defined(HAVE_AL_AL_H)-# include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-# include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-# include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-# include <OpenAL/alc.h>-#endif--#if HAVE_SYS_RESOURCE_H-# include <sys/resource.h>-#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 <stdio.h>-#include <stddef.h>--#if HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif--#if HAVE_UNISTD_H-# include <unistd.h>-#endif--#if HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif--#if HAVE_FCNTL_H-# include <fcntl.h>-#endif--#if HAVE_SIGNAL_H-# include <signal.h>-#endif--#if HAVE_TIME_H-# include <time.h>-#endif--#if HAVE_TERMIOS_H-# include <termios.h>-#endif--#if HAVE_STRING_H-# include <string.h>-#endif--#if HAVE_CTYPE_H-# include <ctype.h>-#endif--#if defined(HAVE_GL_GL_H)-# include <GL/gl.h>-#elif defined(HAVE_OPENGL_GL_H)-# include <OpenGL/gl.h>-#endif--#if defined(HAVE_AL_AL_H)-# include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-# include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-# include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-# include <OpenAL/alc.h>-#endif--#if HAVE_SYS_RESOURCE_H-# include <sys/resource.h>-#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 <stdio.h>-#include <stddef.h>--#if HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif--#if HAVE_UNISTD_H-# include <unistd.h>-#endif--#if HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif--#if HAVE_FCNTL_H-# include <fcntl.h>-#endif--#if HAVE_SIGNAL_H-# include <signal.h>-#endif--#if HAVE_TIME_H-# include <time.h>-#endif--#if HAVE_TERMIOS_H-# include <termios.h>-#endif--#if HAVE_STRING_H-# include <string.h>-#endif--#if HAVE_CTYPE_H-# include <ctype.h>-#endif--#if defined(HAVE_GL_GL_H)-# include <GL/gl.h>-#elif defined(HAVE_OPENGL_GL_H)-# include <OpenGL/gl.h>-#endif--#if defined(HAVE_AL_AL_H)-# include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-# include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-# include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-# include <OpenAL/alc.h>-#endif--#if HAVE_SYS_RESOURCE_H-# include <sys/resource.h>-#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 <stdio.h>-#include <stddef.h>--#if HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif--#if HAVE_UNISTD_H-# include <unistd.h>-#endif--#if HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif--#if HAVE_FCNTL_H-# include <fcntl.h>-#endif--#if HAVE_SIGNAL_H-# include <signal.h>-#endif--#if HAVE_TIME_H-# include <time.h>-#endif--#if HAVE_TERMIOS_H-# include <termios.h>-#endif--#if HAVE_STRING_H-# include <string.h>-#endif--#if HAVE_CTYPE_H-# include <ctype.h>-#endif--#if defined(HAVE_GL_GL_H)-# include <GL/gl.h>-#elif defined(HAVE_OPENGL_GL_H)-# include <OpenGL/gl.h>-#endif--#if defined(HAVE_AL_AL_H)-# include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-# include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-# include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-# include <OpenAL/alc.h>-#endif--#if HAVE_SYS_RESOURCE_H-# include <sys/resource.h>-#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 <stdio.h>-#include <stddef.h>--#if HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif--#if HAVE_UNISTD_H-# include <unistd.h>-#endif--#if HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif--#if HAVE_FCNTL_H-# include <fcntl.h>-#endif--#if HAVE_SIGNAL_H-# include <signal.h>-#endif--#if HAVE_TIME_H-# include <time.h>-#endif--#if HAVE_TERMIOS_H-# include <termios.h>-#endif--#if HAVE_STRING_H-# include <string.h>-#endif--#if HAVE_CTYPE_H-# include <ctype.h>-#endif--#if defined(HAVE_GL_GL_H)-# include <GL/gl.h>-#elif defined(HAVE_OPENGL_GL_H)-# include <OpenGL/gl.h>-#endif--#if defined(HAVE_AL_AL_H)-# include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-# include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-# include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-# include <OpenAL/alc.h>-#endif--#if HAVE_SYS_RESOURCE_H-# include <sys/resource.h>-#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 <stdio.h>-#include <stddef.h>--#if HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif--#if HAVE_UNISTD_H-# include <unistd.h>-#endif--#if HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif--#if HAVE_FCNTL_H-# include <fcntl.h>-#endif--#if HAVE_SIGNAL_H-# include <signal.h>-#endif--#if HAVE_TIME_H-# include <time.h>-#endif--#if HAVE_TERMIOS_H-# include <termios.h>-#endif--#if HAVE_STRING_H-# include <string.h>-#endif--#if HAVE_CTYPE_H-# include <ctype.h>-#endif--#if defined(HAVE_GL_GL_H)-# include <GL/gl.h>-#elif defined(HAVE_OPENGL_GL_H)-# include <OpenGL/gl.h>-#endif--#if defined(HAVE_AL_AL_H)-# include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-# include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-# include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-# include <OpenAL/alc.h>-#endif--#if HAVE_SYS_RESOURCE_H-# include <sys/resource.h>-#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 <stdio.h>-#include <stddef.h>--#if HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif--#if HAVE_UNISTD_H-# include <unistd.h>-#endif--#if HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif--#if HAVE_FCNTL_H-# include <fcntl.h>-#endif--#if HAVE_SIGNAL_H-# include <signal.h>-#endif--#if HAVE_TIME_H-# include <time.h>-#endif--#if HAVE_TERMIOS_H-# include <termios.h>-#endif--#if HAVE_STRING_H-# include <string.h>-#endif--#if HAVE_CTYPE_H-# include <ctype.h>-#endif--#if defined(HAVE_GL_GL_H)-# include <GL/gl.h>-#elif defined(HAVE_OPENGL_GL_H)-# include <OpenGL/gl.h>-#endif--#if defined(HAVE_AL_AL_H)-# include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-# include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-# include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-# include <OpenAL/alc.h>-#endif--#if HAVE_SYS_RESOURCE_H-# include <sys/resource.h>-#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 <stdio.h>-#include <stddef.h>--#if HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif--#if HAVE_UNISTD_H-# include <unistd.h>-#endif--#if HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif--#if HAVE_FCNTL_H-# include <fcntl.h>-#endif--#if HAVE_SIGNAL_H-# include <signal.h>-#endif--#if HAVE_TIME_H-# include <time.h>-#endif--#if HAVE_TERMIOS_H-# include <termios.h>-#endif--#if HAVE_STRING_H-# include <string.h>-#endif--#if HAVE_CTYPE_H-# include <ctype.h>-#endif--#if defined(HAVE_GL_GL_H)-# include <GL/gl.h>-#elif defined(HAVE_OPENGL_GL_H)-# include <OpenGL/gl.h>-#endif--#if defined(HAVE_AL_AL_H)-# include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-# include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-# include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-# include <OpenAL/alc.h>-#endif--#if HAVE_SYS_RESOURCE_H-# include <sys/resource.h>-#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 <stdio.h>-#include <stddef.h>--#if HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif--#if HAVE_UNISTD_H-# include <unistd.h>-#endif--#if HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif--#if HAVE_FCNTL_H-# include <fcntl.h>-#endif--#if HAVE_SIGNAL_H-# include <signal.h>-#endif--#if HAVE_TIME_H-# include <time.h>-#endif--#if HAVE_TERMIOS_H-# include <termios.h>-#endif--#if HAVE_STRING_H-# include <string.h>-#endif--#if HAVE_CTYPE_H-# include <ctype.h>-#endif--#if defined(HAVE_GL_GL_H)-# include <GL/gl.h>-#elif defined(HAVE_OPENGL_GL_H)-# include <OpenGL/gl.h>-#endif--#if defined(HAVE_AL_AL_H)-# include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-# include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-# include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-# include <OpenAL/alc.h>-#endif--#if HAVE_SYS_RESOURCE_H-# include <sys/resource.h>-#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 <stdio.h>-#include <stddef.h>--#if HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif--#if HAVE_UNISTD_H-# include <unistd.h>-#endif--#if HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif--#if HAVE_FCNTL_H-# include <fcntl.h>-#endif--#if HAVE_SIGNAL_H-# include <signal.h>-#endif--#if HAVE_TIME_H-# include <time.h>-#endif--#if HAVE_TERMIOS_H-# include <termios.h>-#endif--#if HAVE_STRING_H-# include <string.h>-#endif--#if HAVE_CTYPE_H-# include <ctype.h>-#endif--#if defined(HAVE_GL_GL_H)-# include <GL/gl.h>-#elif defined(HAVE_OPENGL_GL_H)-# include <OpenGL/gl.h>-#endif--#if defined(HAVE_AL_AL_H)-# include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-# include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-# include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-# include <OpenAL/alc.h>-#endif--#if HAVE_SYS_RESOURCE_H-# include <sys/resource.h>-#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 <stdio.h>-#include <stddef.h>--#if HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif--#if HAVE_UNISTD_H-# include <unistd.h>-#endif--#if HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif--#if HAVE_FCNTL_H-# include <fcntl.h>-#endif--#if HAVE_SIGNAL_H-# include <signal.h>-#endif--#if HAVE_TIME_H-# include <time.h>-#endif--#if HAVE_TERMIOS_H-# include <termios.h>-#endif--#if HAVE_STRING_H-# include <string.h>-#endif--#if HAVE_CTYPE_H-# include <ctype.h>-#endif--#if defined(HAVE_GL_GL_H)-# include <GL/gl.h>-#elif defined(HAVE_OPENGL_GL_H)-# include <OpenGL/gl.h>-#endif--#if defined(HAVE_AL_AL_H)-# include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-# include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-# include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-# include <OpenAL/alc.h>-#endif--#if HAVE_SYS_RESOURCE_H-# include <sys/resource.h>-#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 <stdio.h>-#include <stddef.h>--#if HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif--#if HAVE_UNISTD_H-# include <unistd.h>-#endif--#if HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif--#if HAVE_FCNTL_H-# include <fcntl.h>-#endif--#if HAVE_SIGNAL_H-# include <signal.h>-#endif--#if HAVE_TIME_H-# include <time.h>-#endif--#if HAVE_TERMIOS_H-# include <termios.h>-#endif--#if HAVE_STRING_H-# include <string.h>-#endif--#if HAVE_CTYPE_H-# include <ctype.h>-#endif--#if defined(HAVE_GL_GL_H)-# include <GL/gl.h>-#elif defined(HAVE_OPENGL_GL_H)-# include <OpenGL/gl.h>-#endif--#if defined(HAVE_AL_AL_H)-# include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-# include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-# include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-# include <OpenAL/alc.h>-#endif--#if HAVE_SYS_RESOURCE_H-# include <sys/resource.h>-#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 <stdio.h>-#include <stddef.h>--#if HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif--#if HAVE_UNISTD_H-# include <unistd.h>-#endif--#if HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif--#if HAVE_FCNTL_H-# include <fcntl.h>-#endif--#if HAVE_SIGNAL_H-# include <signal.h>-#endif--#if HAVE_TIME_H-# include <time.h>-#endif--#if HAVE_TERMIOS_H-# include <termios.h>-#endif--#if HAVE_STRING_H-# include <string.h>-#endif--#if HAVE_CTYPE_H-# include <ctype.h>-#endif--#if defined(HAVE_GL_GL_H)-# include <GL/gl.h>-#elif defined(HAVE_OPENGL_GL_H)-# include <OpenGL/gl.h>-#endif--#if defined(HAVE_AL_AL_H)-# include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-# include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-# include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-# include <OpenAL/alc.h>-#endif--#if HAVE_SYS_RESOURCE_H-# include <sys/resource.h>-#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 <stdio.h>-#include <stddef.h>--#if HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif--#if HAVE_UNISTD_H-# include <unistd.h>-#endif--#if HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif--#if HAVE_FCNTL_H-# include <fcntl.h>-#endif--#if HAVE_SIGNAL_H-# include <signal.h>-#endif--#if HAVE_TIME_H-# include <time.h>-#endif--#if HAVE_TERMIOS_H-# include <termios.h>-#endif--#if HAVE_STRING_H-# include <string.h>-#endif--#if HAVE_CTYPE_H-# include <ctype.h>-#endif--#if defined(HAVE_GL_GL_H)-# include <GL/gl.h>-#elif defined(HAVE_OPENGL_GL_H)-# include <OpenGL/gl.h>-#endif--#if defined(HAVE_AL_AL_H)-# include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-# include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-# include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-# include <OpenAL/alc.h>-#endif--#if HAVE_SYS_RESOURCE_H-# include <sys/resource.h>-#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 <stdio.h>-#include <stddef.h>--#if HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif--#if HAVE_UNISTD_H-# include <unistd.h>-#endif--#if HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif--#if HAVE_FCNTL_H-# include <fcntl.h>-#endif--#if HAVE_SIGNAL_H-# include <signal.h>-#endif--#if HAVE_TIME_H-# include <time.h>-#endif--#if HAVE_TERMIOS_H-# include <termios.h>-#endif--#if HAVE_STRING_H-# include <string.h>-#endif--#if HAVE_CTYPE_H-# include <ctype.h>-#endif--#if defined(HAVE_GL_GL_H)-# include <GL/gl.h>-#elif defined(HAVE_OPENGL_GL_H)-# include <OpenGL/gl.h>-#endif--#if defined(HAVE_AL_AL_H)-# include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-# include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-# include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-# include <OpenAL/alc.h>-#endif--#if HAVE_SYS_RESOURCE_H-# include <sys/resource.h>-#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 <stdio.h>-#include <stddef.h>--#if HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif--#if HAVE_UNISTD_H-# include <unistd.h>-#endif--#if HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif--#if HAVE_FCNTL_H-# include <fcntl.h>-#endif--#if HAVE_SIGNAL_H-# include <signal.h>-#endif--#if HAVE_TIME_H-# include <time.h>-#endif--#if HAVE_TERMIOS_H-# include <termios.h>-#endif--#if HAVE_STRING_H-# include <string.h>-#endif--#if HAVE_CTYPE_H-# include <ctype.h>-#endif--#if defined(HAVE_GL_GL_H)-# include <GL/gl.h>-#elif defined(HAVE_OPENGL_GL_H)-# include <OpenGL/gl.h>-#endif--#if defined(HAVE_AL_AL_H)-# include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-# include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-# include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-# include <OpenAL/alc.h>-#endif--#if HAVE_SYS_RESOURCE_H-# include <sys/resource.h>-#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 <stdio.h>-#include <stddef.h>--#if HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif--#if HAVE_UNISTD_H-# include <unistd.h>-#endif--#if HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif--#if HAVE_FCNTL_H-# include <fcntl.h>-#endif--#if HAVE_SIGNAL_H-# include <signal.h>-#endif--#if HAVE_TIME_H-# include <time.h>-#endif--#if HAVE_TERMIOS_H-# include <termios.h>-#endif--#if HAVE_STRING_H-# include <string.h>-#endif--#if HAVE_CTYPE_H-# include <ctype.h>-#endif--#if defined(HAVE_GL_GL_H)-# include <GL/gl.h>-#elif defined(HAVE_OPENGL_GL_H)-# include <OpenGL/gl.h>-#endif--#if defined(HAVE_AL_AL_H)-# include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-# include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-# include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-# include <OpenAL/alc.h>-#endif--#if HAVE_SYS_RESOURCE_H-# include <sys/resource.h>-#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 <stdio.h>-#include <stddef.h>--#if HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif--#if HAVE_UNISTD_H-# include <unistd.h>-#endif--#if HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif--#if HAVE_FCNTL_H-# include <fcntl.h>-#endif--#if HAVE_SIGNAL_H-# include <signal.h>-#endif--#if HAVE_TIME_H-# include <time.h>-#endif--#if HAVE_TERMIOS_H-# include <termios.h>-#endif--#if HAVE_STRING_H-# include <string.h>-#endif--#if HAVE_CTYPE_H-# include <ctype.h>-#endif--#if defined(HAVE_GL_GL_H)-# include <GL/gl.h>-#elif defined(HAVE_OPENGL_GL_H)-# include <OpenGL/gl.h>-#endif--#if defined(HAVE_AL_AL_H)-# include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-# include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-# include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-# include <OpenAL/alc.h>-#endif--#if HAVE_SYS_RESOURCE_H-# include <sys/resource.h>-#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 <stdio.h>-#include <stddef.h>--#if HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif--#if HAVE_UNISTD_H-# include <unistd.h>-#endif--#if HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif--#if HAVE_FCNTL_H-# include <fcntl.h>-#endif--#if HAVE_SIGNAL_H-# include <signal.h>-#endif--#if HAVE_TIME_H-# include <time.h>-#endif--#if HAVE_TERMIOS_H-# include <termios.h>-#endif--#if HAVE_STRING_H-# include <string.h>-#endif--#if HAVE_CTYPE_H-# include <ctype.h>-#endif--#if defined(HAVE_GL_GL_H)-# include <GL/gl.h>-#elif defined(HAVE_OPENGL_GL_H)-# include <OpenGL/gl.h>-#endif--#if defined(HAVE_AL_AL_H)-# include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-# include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-# include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-# include <OpenAL/alc.h>-#endif--#if HAVE_SYS_RESOURCE_H-# include <sys/resource.h>-#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 <stdio.h>-#include <stddef.h>--#if HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif--#if HAVE_UNISTD_H-# include <unistd.h>-#endif--#if HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif--#if HAVE_FCNTL_H-# include <fcntl.h>-#endif--#if HAVE_SIGNAL_H-# include <signal.h>-#endif--#if HAVE_TIME_H-# include <time.h>-#endif--#if HAVE_TERMIOS_H-# include <termios.h>-#endif--#if HAVE_STRING_H-# include <string.h>-#endif--#if HAVE_CTYPE_H-# include <ctype.h>-#endif--#if defined(HAVE_GL_GL_H)-# include <GL/gl.h>-#elif defined(HAVE_OPENGL_GL_H)-# include <OpenGL/gl.h>-#endif--#if defined(HAVE_AL_AL_H)-# include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-# include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-# include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-# include <OpenAL/alc.h>-#endif--#if HAVE_SYS_RESOURCE_H-# include <sys/resource.h>-#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 <stdio.h>-#include <stddef.h>--#if HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif--#if HAVE_UNISTD_H-# include <unistd.h>-#endif--#if HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif--#if HAVE_FCNTL_H-# include <fcntl.h>-#endif--#if HAVE_SIGNAL_H-# include <signal.h>-#endif--#if HAVE_TIME_H-# include <time.h>-#endif--#if HAVE_TERMIOS_H-# include <termios.h>-#endif--#if HAVE_STRING_H-# include <string.h>-#endif--#if HAVE_CTYPE_H-# include <ctype.h>-#endif--#if defined(HAVE_GL_GL_H)-# include <GL/gl.h>-#elif defined(HAVE_OPENGL_GL_H)-# include <OpenGL/gl.h>-#endif--#if defined(HAVE_AL_AL_H)-# include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-# include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-# include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-# include <OpenAL/alc.h>-#endif--#if HAVE_SYS_RESOURCE_H-# include <sys/resource.h>-#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 <stdio.h>-#include <stddef.h>--#if HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif--#if HAVE_UNISTD_H-# include <unistd.h>-#endif--#if HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif--#if HAVE_FCNTL_H-# include <fcntl.h>-#endif--#if HAVE_SIGNAL_H-# include <signal.h>-#endif--#if HAVE_TIME_H-# include <time.h>-#endif--#if HAVE_TERMIOS_H-# include <termios.h>-#endif--#if HAVE_STRING_H-# include <string.h>-#endif--#if HAVE_CTYPE_H-# include <ctype.h>-#endif--#if defined(HAVE_GL_GL_H)-# include <GL/gl.h>-#elif defined(HAVE_OPENGL_GL_H)-# include <OpenGL/gl.h>-#endif--#if defined(HAVE_AL_AL_H)-# include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-# include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-# include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-# include <OpenAL/alc.h>-#endif--#if HAVE_SYS_RESOURCE_H-# include <sys/resource.h>-#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 <stdio.h>-#include <stddef.h>--#if HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif--#if HAVE_UNISTD_H-# include <unistd.h>-#endif--#if HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif--#if HAVE_FCNTL_H-# include <fcntl.h>-#endif--#if HAVE_SIGNAL_H-# include <signal.h>-#endif--#if HAVE_TIME_H-# include <time.h>-#endif--#if HAVE_TERMIOS_H-# include <termios.h>-#endif--#if HAVE_STRING_H-# include <string.h>-#endif--#if HAVE_CTYPE_H-# include <ctype.h>-#endif--#if defined(HAVE_GL_GL_H)-# include <GL/gl.h>-#elif defined(HAVE_OPENGL_GL_H)-# include <OpenGL/gl.h>-#endif--#if defined(HAVE_AL_AL_H)-# include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-# include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-# include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-# include <OpenAL/alc.h>-#endif--#if HAVE_SYS_RESOURCE_H-# include <sys/resource.h>-#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 <stdio.h>-#include <stddef.h>--#if HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif--#if HAVE_UNISTD_H-# include <unistd.h>-#endif--#if HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif--#if HAVE_FCNTL_H-# include <fcntl.h>-#endif--#if HAVE_SIGNAL_H-# include <signal.h>-#endif--#if HAVE_TIME_H-# include <time.h>-#endif--#if HAVE_TERMIOS_H-# include <termios.h>-#endif--#if HAVE_STRING_H-# include <string.h>-#endif--#if HAVE_CTYPE_H-# include <ctype.h>-#endif--#if defined(HAVE_GL_GL_H)-# include <GL/gl.h>-#elif defined(HAVE_OPENGL_GL_H)-# include <OpenGL/gl.h>-#endif--#if defined(HAVE_AL_AL_H)-# include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-# include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-# include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-# include <OpenAL/alc.h>-#endif--#if HAVE_SYS_RESOURCE_H-# include <sys/resource.h>-#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 <stdio.h>-#if defined(HAVE_AL_AL_H)-#include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-#include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-#include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-#include <OpenAL/alc.h>-#endif--#if defined(HAVE_AL_ALEXT_H)-#include <AL/alext.h>-#elif defined(HAVE_OPENAL_ALEXT_H)-#include <OpenAL/alext.h>-#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 <sven.panne@aedion.de>."--_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 2>/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-' <conf$$subs.awk | sed '-/^[^""]/{-  N-  s/\n//-}-' >>$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-' <confdefs.h | sed '-s/'"$ac_delim"'/"\\\-"/g' >>$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-
− configure.ac 
@@ -1,203 +0,0 @@-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 <stdio.h>-#if defined(HAVE_AL_AL_H)-#include <AL/al.h>-#elif defined(HAVE_OPENAL_AL_H)-#include <OpenAL/al.h>-#endif--#if defined(HAVE_AL_ALC_H)-#include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-#include <OpenAL/alc.h>-#endif--#if defined(HAVE_AL_ALEXT_H)-#include <AL/alext.h>-#elif defined(HAVE_OPENAL_ALEXT_H)-#include <OpenAL/alext.h>-#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
examples/test/TestDevice.hs view
@@ -1,15 +1,37 @@+import Control.Concurrent ( threadDelay ) import Control.Monad ( unless )-import System.IO ( hPutStrLn, stderr )-import System.Posix.Unistd ( sleep )+import Data.Maybe ( listToMaybe )+import System.Environment ( getArgs ) import Sound.OpenAL +type DeviceSpecifier = Maybe String++showDevice :: DeviceSpecifier -> String+showDevice Nothing = "default"+showDevice (Just d) = "'" ++ d ++ "'"++orElse :: IO (Maybe a) -> IO (Maybe a) -> IO (Maybe a)+orElse f g = f >>= maybe g (return . Just)++check :: String -> IO (Maybe a) -> IO a+check what f = f >>= maybe (error $ what ++ " failed") return++boolToMaybe :: Bool -> Maybe ()+boolToMaybe x = if x then Just () else Nothing++getDeviceSpec :: String -> IO [String] -> IO DeviceSpecifier+getDeviceSpec what getter = do+   deviceSpecs <- getter+   unless (null deviceSpecs) $ do+      putStrLn $ "Found " ++ show (length deviceSpecs) ++ " " ++ what ++ ":"+      mapM_ (putStrLn . ("   " ++)) deviceSpecs+   return $ listToMaybe deviceSpecs+ 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"+   d <- getDeviceSpec "commandline arguments" getArgs `orElse`+        getDeviceSpec "enumerated devices" (get allDeviceSpecifiers)+   putStrLn $ "Using " ++ showDevice d ++ " device"+   device <- check "openDevice" $ openDevice d+   threadDelay 1000000+   check "closeDevice" $ fmap boolToMaybe $ closeDevice device
− include/HsOpenAL.h 
@@ -1,31 +0,0 @@-/* 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 <AL/alc.h> header file. */-#define HAVE_AL_ALC_H 1--/* Define to 1 if you have the <OpenAL/alc.h> header file. */-/* #undef HAVE_OPENAL_ALC_H */--#if defined(HAVE_AL_ALC_H)-#include <AL/al.h>-#include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-#include <OpenAL/al.h>-#include <OpenAL/alc.h>-#endif--#endif
− include/HsOpenAL.h.in 
@@ -1,30 +0,0 @@-/* ------------------------------------------------------------------------------ *- * 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 <AL/alc.h> header file. */-#undef HAVE_AL_ALC_H--/* Define to 1 if you have the <OpenAL/alc.h> header file. */-#undef HAVE_OPENAL_ALC_H--#if defined(HAVE_AL_ALC_H)-#include <AL/al.h>-#include <AL/alc.h>-#elif defined(HAVE_OPENAL_ALC_H)-#include <OpenAL/al.h>-#include <OpenAL/alc.h>-#endif--#endif
− include/HsOpenALConfig.h 
@@ -1,410 +0,0 @@-/* 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 <AL/alc.h> header file. */-#define HAVE_AL_ALC_H 1--/* Define to 1 if you have the <AL/alext.h> header file. */-#define HAVE_AL_ALEXT_H 1--/* Define to 1 if you have the <AL/al.h> header file. */-#define HAVE_AL_AL_H 1--/* Define to 1 if you have the <inttypes.h> header file. */-#define HAVE_INTTYPES_H 1--/* Define to 1 if you have the <memory.h> header file. */-#define HAVE_MEMORY_H 1--/* Define to 1 if you have the <OpenAL/alc.h> header file. */-/* #undef HAVE_OPENAL_ALC_H */--/* Define to 1 if you have the <OpenAL/alext.h> header file. */-/* #undef HAVE_OPENAL_ALEXT_H */--/* Define to 1 if you have the <OpenAL/al.h> header file. */-/* #undef HAVE_OPENAL_AL_H */--/* Define to 1 if you have the <stdint.h> header file. */-#define HAVE_STDINT_H 1--/* Define to 1 if you have the <stdlib.h> header file. */-#define HAVE_STDLIB_H 1--/* Define to 1 if you have the <strings.h> header file. */-#define HAVE_STRINGS_H 1--/* Define to 1 if you have the <string.h> header file. */-#define HAVE_STRING_H 1--/* Define to 1 if you have the <sys/stat.h> header file. */-#define HAVE_SYS_STAT_H 1--/* Define to 1 if you have the <sys/types.h> header file. */-#define HAVE_SYS_TYPES_H 1--/* Define to 1 if you have the <unistd.h> 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
− include/HsOpenALConfig.h.in 
@@ -1,409 +0,0 @@-/* 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 <AL/alc.h> header file. */-#undef HAVE_AL_ALC_H--/* Define to 1 if you have the <AL/alext.h> header file. */-#undef HAVE_AL_ALEXT_H--/* Define to 1 if you have the <AL/al.h> header file. */-#undef HAVE_AL_AL_H--/* Define to 1 if you have the <inttypes.h> header file. */-#undef HAVE_INTTYPES_H--/* Define to 1 if you have the <memory.h> header file. */-#undef HAVE_MEMORY_H--/* Define to 1 if you have the <OpenAL/alc.h> header file. */-#undef HAVE_OPENAL_ALC_H--/* Define to 1 if you have the <OpenAL/alext.h> header file. */-#undef HAVE_OPENAL_ALEXT_H--/* Define to 1 if you have the <OpenAL/al.h> header file. */-#undef HAVE_OPENAL_AL_H--/* Define to 1 if you have the <stdint.h> header file. */-#undef HAVE_STDINT_H--/* Define to 1 if you have the <stdlib.h> header file. */-#undef HAVE_STDLIB_H--/* Define to 1 if you have the <strings.h> header file. */-#undef HAVE_STRINGS_H--/* Define to 1 if you have the <string.h> header file. */-#undef HAVE_STRING_H--/* Define to 1 if you have the <sys/stat.h> header file. */-#undef HAVE_SYS_STAT_H--/* Define to 1 if you have the <sys/types.h> header file. */-#undef HAVE_SYS_TYPES_H--/* Define to 1 if you have the <unistd.h> 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
− install-sh 
@@ -1,295 +0,0 @@-#!/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:
+ src/Sound/OpenAL.hs view
@@ -0,0 +1,181 @@+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+--+-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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 Graphics.Rendering.OpenGL.GL.Tensor+) where++import Sound.OpenAL.AL+import Sound.OpenAL.ALC++import Data.ObjectName+import Data.StateVar+import Graphics.Rendering.OpenGL.GL.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+-- <http://www.openal.org/titles.html>).++--------------------------------------------------------------------------------+-- $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 <http://www.opengl.org/> 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+-- <http://www.iasig.org/wg/closed/3dwg/3dwg.shtml>.+--+-- 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 <http://www.openal.org/documentation.html>)+-- 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.
+ src/Sound/OpenAL/AL.hs view
@@ -0,0 +1,128 @@+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.AL+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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.
+ src/Sound/OpenAL/AL/ALboolean.hs view
@@ -0,0 +1,30 @@+{-# OPTIONS_HADDOCK hide #-}+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.AL.ALboolean+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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+import Sound.OpenAL.Constants++--------------------------------------------------------------------------------++marshalALboolean :: Bool -> ALboolean+marshalALboolean False = al_FALSE+marshalALboolean True  = al_TRUE++unmarshalALboolean :: ALboolean -> Bool+unmarshalALboolean = (/= al_FALSE)
+ src/Sound/OpenAL/AL/Attenuation.hs view
@@ -0,0 +1,212 @@+{-# LANGUAGE CPP #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.AL.Attenuation+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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++#if __GLASGOW_HASKELL__ >= 704+-- Make the foreign imports happy.+import Foreign.C.Types+#endif++import Data.StateVar ( StateVar, makeStateVar )+import Foreign.Marshal.Alloc ( alloca )+import Foreign.Ptr ( Ptr )++import Sound.OpenAL.AL.BasicTypes+import Sound.OpenAL.AL.PeekPoke+import Sound.OpenAL.AL.QueryUtils+import Sound.OpenAL.Constants++-- For Haddock only.+import Sound.OpenAL.AL.Source++--------------------------------------------------------------------------------+-- $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 ccall unsafe "alGetIntegerv"+   alGetIntegerv :: ALenum -> Ptr ALint -> IO ()++foreign import ccall unsafe "alDistanceModel"+   alDistanceModel :: ALenum -> IO ()
+ src/Sound/OpenAL/AL/BasicTypes.hs view
@@ -0,0 +1,49 @@+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.AL.BasicTypes+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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.
+ src/Sound/OpenAL/AL/Buffer.hs view
@@ -0,0 +1,175 @@+{-# LANGUAGE CPP #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.AL.Buffer+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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++#if __GLASGOW_HASKELL__ >= 704+-- Make the foreign imports happy.+import Foreign.C.Types+#endif++import Data.StateVar ( StateVar, makeStateVar )+import Foreign.Marshal.Alloc ( alloca )+import Foreign.Ptr ( Ptr, nullPtr )++import Sound.OpenAL.AL.BasicTypes+import Sound.OpenAL.AL.BufferInternal+import Sound.OpenAL.AL.Format+import Sound.OpenAL.AL.PeekPoke+import qualified Sound.OpenAL.ALC.Context as ALC+import Sound.OpenAL.Constants++-- For Haddock only.+import Sound.OpenAL.AL.Errors+import Sound.OpenAL.AL.SourceState++--------------------------------------------------------------------------------++data MemoryRegion a = MemoryRegion (Ptr a) ALsizei+   deriving ( Eq, Ord, Show )++data BufferData a = BufferData (MemoryRegion a) Format ALC.Frequency+   deriving ( Eq, Ord, Show )++--------------------------------------------------------------------------------++-- | 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 ccall 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 ccall unsafe "alGetBufferi"+   alGetBufferi :: Buffer -> ALenum -> Ptr ALint -> IO ()
+ src/Sound/OpenAL/AL/BufferInternal.hs view
@@ -0,0 +1,84 @@+{-# LANGUAGE CPP #-}+{-# OPTIONS_HADDOCK hide #-}+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.AL.BufferInternal+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- Stability   :  stable+-- Portability :  portable+--+-- This is a purely internal module for (un-)marshaling Buffer.+--+--------------------------------------------------------------------------------++module Sound.OpenAL.AL.BufferInternal (+   Buffer(..), marshalBuffer, unmarshalBuffer+) where++#if __GLASGOW_HASKELL__ >= 704+-- Make the foreign imports happy.+import Foreign.C.Types+#endif++import Control.Monad.IO.Class ( MonadIO(..) )+import Data.ObjectName ( ObjectName(..), GeneratableObjectName(..) )+import Foreign.Marshal.Array ( withArrayLen, peekArray, allocaArray )+import Foreign.Ptr ( Ptr, castPtr )+import Foreign.Storable ( Storable(..) )++import Sound.OpenAL.AL.ALboolean+import Sound.OpenAL.AL.BasicTypes+import Sound.OpenAL.AL.PeekPoke++--------------------------------------------------------------------------------++-- | 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+   deleteObjectNames buffers =+      liftIO $ withArrayLen buffers $ alDeleteBuffers . fromIntegral++   isObjectName = liftIO . fmap unmarshalALboolean . alIsBuffer++instance GeneratableObjectName Buffer where+   genObjectNames n = liftIO $+      allocaArray n $ \buf -> do+        alGenBuffers (fromIntegral n) buf+        peekArray n buf++foreign import ccall unsafe "alGenBuffers"+   alGenBuffers :: ALsizei -> Ptr Buffer -> IO ()++foreign import ccall unsafe "alDeleteBuffers"+   alDeleteBuffers :: ALsizei -> Ptr Buffer -> IO ()++foreign import ccall unsafe "alIsBuffer"+   alIsBuffer :: Buffer -> IO ALboolean
+ src/Sound/OpenAL/AL/Doppler.hs view
@@ -0,0 +1,97 @@+{-# LANGUAGE CPP #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.AL.Doppler+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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++#if __GLASGOW_HASKELL__ >= 704+-- Make the foreign imports happy.+import Foreign.C.Types+#endif++import Data.StateVar ( get, StateVar, makeStateVar )+import Foreign.Ptr ( FunPtr )++import Sound.OpenAL.AL.BasicTypes+import Sound.OpenAL.AL.Extensions+import Sound.OpenAL.AL.QueryUtils++-- For Haddock only.+import Sound.OpenAL.AL.Errors++--------------------------------------------------------------------------------++-- | '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 ccall unsafe "alGetFloat"+   alGetFloat :: ALenum -> IO ALfloat++type Invoker a = FunPtr a -> a++foreign import ccall 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).
+ src/Sound/OpenAL/AL/Errors.hs view
@@ -0,0 +1,92 @@+{-# LANGUAGE CPP #-}+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.AL.Errors+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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++#if __GLASGOW_HASKELL__ >= 704+-- Make the foreign imports happy.+import Foreign.C.Types+#endif++import Data.StateVar ( GettableStateVar, makeGettableStateVar )++import Sound.OpenAL.AL.BasicTypes+import Sound.OpenAL.Constants+import Sound.OpenAL.AL.QueryUtils++--------------------------------------------------------------------------------++-- | 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 ccall unsafe "alGetError"+   alGetError :: IO ALenum
+ src/Sound/OpenAL/AL/Extensions.hs view
@@ -0,0 +1,110 @@+{-# LANGUAGE CPP #-}+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.AL.Extensions+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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 (+   -- * General AL extension support+   alExtensions, alIsExtensionPresent, alProcAddress, alEnumValue, alVersion,++   -- * Internal re-exports, use at your own risk+   unmarshalALboolean, unmarshalFormat, unmarshalBuffer+) where++#if __GLASGOW_HASKELL__ >= 704+-- Make the foreign imports happy.+import Foreign.C.Types+#endif++import Data.StateVar ( GettableStateVar, makeGettableStateVar )+import Foreign.Ptr++import Sound.OpenAL.AL.ALboolean+import Sound.OpenAL.AL.BasicTypes+import Sound.OpenAL.AL.BufferInternal+import Sound.OpenAL.AL.Format+import Sound.OpenAL.AL.QueryUtils+import Sound.OpenAL.AL.String++--------------------------------------------------------------------------------++-- | Contains the list of available extensions.++alExtensions :: GettableStateVar [String]+alExtensions = makeGettableStateVar (fmap words $ getString Extensions)++--------------------------------------------------------------------------------++-- | Contains a version string in the format @\"/\<spec major number\>/./\<spec+-- minor number\>/ /\<optional vendor version information\>/\"@.++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 ccall 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 ccall 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 ccall unsafe "alGetEnumValue"+   alGetEnumValue :: Ptr ALchar -> IO ALenum
+ src/Sound/OpenAL/AL/Format.hs view
@@ -0,0 +1,49 @@+{-# OPTIONS_HADDOCK hide #-}+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.AL.Format+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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+import Sound.OpenAL.Constants++--------------------------------------------------------------------------------++-- | 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)
+ src/Sound/OpenAL/AL/Listener.hs view
@@ -0,0 +1,155 @@+{-# LANGUAGE CPP #-}+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.AL.Listener+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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++#if __GLASGOW_HASKELL__ >= 704+-- Make the foreign imports happy.+import Foreign.C.Types+#endif++import Data.StateVar ( StateVar, makeStateVar )+import Foreign.Marshal.Array ( allocaArray, withArray )+import Foreign.Marshal.Utils ( with )+import Foreign.Ptr ( Ptr )+import Foreign.Storable ( Storable )+import Graphics.Rendering.OpenGL.GL.Tensor ( Vector3(..), Vertex3 (..) )++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 ccall 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 ccall unsafe "alListenerfv"+   alListenerfv :: ALenum -> Ptr a -> IO ()++--------------------------------------------------------------------------------++getListenerfv :: GetPName -> Ptr ALfloat -> IO ()+getListenerfv = alGetListenerfv . marshalGetPName++foreign import ccall 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)
+ src/Sound/OpenAL/AL/PeekPoke.hs view
@@ -0,0 +1,59 @@+{-# OPTIONS_HADDOCK hide #-}+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.AL.PeekPoke+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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)
+ src/Sound/OpenAL/AL/QueryUtils.hs view
@@ -0,0 +1,122 @@+{-# LANGUAGE CPP #-}+{-# OPTIONS_HADDOCK hide #-}+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.AL.QueryUtils+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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++#if __GLASGOW_HASKELL__ >= 704+-- Make the foreign imports happy.+import Foreign.C.Types+#endif++import Foreign.Ptr ( Ptr )++import Sound.OpenAL.AL.BasicTypes+import Sound.OpenAL.AL.String+import Sound.OpenAL.Constants++--------------------------------------------------------------------------------++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 ccall unsafe "alGetString"+   alGetString :: ALenum -> IO (Ptr ALchar)
+ src/Sound/OpenAL/AL/Source.hs view
@@ -0,0 +1,775 @@+{-# LANGUAGE CPP #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.AL.Source+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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++#if __GLASGOW_HASKELL__ >= 704+-- Make the foreign imports happy.+import Foreign.C.Types+#endif++import Control.Monad ( liftM2 )+import Control.Monad.IO.Class ( MonadIO(..) )+import Data.ObjectName ( ObjectName(..), GeneratableObjectName(..) )+import Data.StateVar ( get, ($=)+                     , GettableStateVar, makeGettableStateVar+                     , StateVar, makeStateVar )+import Foreign.Marshal.Array ( allocaArray, peekArray, withArrayLen )+import Foreign.Marshal.Utils ( with )+import Foreign.Ptr ( Ptr, castPtr )+import Foreign.Storable ( Storable(..) )+import Graphics.Rendering.OpenGL.GL.Tensor ( Vector3(..), Vertex3(..) )++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++-- For Haddock only.+import Sound.OpenAL.AL.Errors++--------------------------------------------------------------------------------++-- | 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+   deleteObjectNames = liftIO . withArraySizei alDeleteSources++   isObjectName = liftIO . fmap unmarshalALboolean . alIsSource++instance GeneratableObjectName Source where+   genObjectNames n = liftIO $+      allocaArray n $ \buf -> do+         alGenSources (fromIntegral n) buf+         peekArray n buf++foreign import ccall unsafe "alGenSources"+   alGenSources :: ALsizei -> Ptr Source -> IO ()++foreign import ccall unsafe "alDeleteSources"+   alDeleteSources :: ALsizei -> Ptr Source -> IO ()++foreign import ccall 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) => Dictionary a b c -> GetPName -> Source -> GettableStateVar a+makeSourceGettableStateVar dict name source =+   makeGettableStateVar+      (makeGetter dict name source)++--------------------------------------------------------------------------------++foreign import ccall unsafe "alGetSourcefv"+   alGetSourcefv :: Source -> ALenum -> Ptr ALfloat -> IO ()++foreign import ccall unsafe "alSourcefv"+   alSourcefv :: Source -> ALenum -> Ptr ALfloat -> IO ()++foreign import ccall 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 ccall 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 :: MonadIO m => Source -> [Buffer] -> m ()+queueBuffers = withArraySizei . alSourceQueueBuffers++withArraySizei :: (MonadIO m, Storable a) => (ALsizei -> Ptr a -> IO ()) -> [a] -> m ()+withArraySizei f xs = liftIO $ withArrayLen xs $ f . fromIntegral++foreign import ccall 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 from the queue, returning the buffers that were unqueued.+-- The operation will fail with an 'ALInvalidValue' error if more buffers are+-- requested than available, leaving the destination arguments unchanged.++unqueueBuffers :: MonadIO m => Source -> ALsizei -> m [Buffer]+unqueueBuffers src n = liftIO $ allocaArray (fromIntegral n) $ \p -> do+    alSourceUnqueueBuffers src n p+    peekArray (fromIntegral n) p++foreign import ccall 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 :: MonadIO m => [Source] -> m ()+play = withArraySizei alSourcePlayv++foreign import ccall 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 :: MonadIO m => [Source] -> m ()+pause = withArraySizei alSourcePausev++foreign import ccall 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 :: MonadIO m => [Source] -> m ()+stop = withArraySizei alSourceStopv++foreign import ccall 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 :: MonadIO m => [Source] -> m ()+rewind = withArraySizei alSourceRewindv++foreign import ccall unsafe "alSourceRewindv"+   alSourceRewindv :: ALsizei -> Ptr Source -> IO ()
+ src/Sound/OpenAL/AL/SourceState.hs view
@@ -0,0 +1,46 @@+{-# OPTIONS_HADDOCK hide #-}+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.AL.SourceState+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- Stability   :  stable+-- Portability :  portable+--+--------------------------------------------------------------------------------++module Sound.OpenAL.AL.SourceState (+   SourceState(..), unmarshalSourceState+) where++import Sound.OpenAL.AL.BasicTypes+import Sound.OpenAL.Constants++--------------------------------------------------------------------------------++-- | 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)
+ src/Sound/OpenAL/AL/String.hs view
@@ -0,0 +1,32 @@+{-# OPTIONS_HADDOCK hide #-}+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.AL.String+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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++--------------------------------------------------------------------------------++-- 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
+ src/Sound/OpenAL/AL/StringQueries.hs view
@@ -0,0 +1,34 @@+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.AL.StringQueries+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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 ( GettableStateVar, makeGettableStateVar )++import Sound.OpenAL.AL.QueryUtils++--------------------------------------------------------------------------------++-- | 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)
+ src/Sound/OpenAL/ALC.hs view
@@ -0,0 +1,35 @@+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.ALC+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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
+ src/Sound/OpenAL/ALC/ALCboolean.hs view
@@ -0,0 +1,30 @@+{-# OPTIONS_HADDOCK hide #-}+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.ALC.ALCboolean+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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+import Sound.OpenAL.Constants++--------------------------------------------------------------------------------++marshalALCboolean :: Bool -> ALCboolean+marshalALCboolean False = alc_FALSE+marshalALCboolean True  = alc_TRUE++unmarshalALCboolean :: ALCboolean -> Bool+unmarshalALCboolean = (/= alc_FALSE)
+ src/Sound/OpenAL/ALC/BasicTypes.hs view
@@ -0,0 +1,24 @@+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.ALC.BasicTypes+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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
+ src/Sound/OpenAL/ALC/Capture.hs view
@@ -0,0 +1,142 @@+{-# LANGUAGE CPP #-}+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.ALC.Capture+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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++#if __GLASGOW_HASKELL__ >= 704+-- Make the foreign imports happy.+import Foreign.C.Types+#endif++import Control.Monad.IO.Class ( MonadIO(..) )+import Data.StateVar ( get, GettableStateVar, makeGettableStateVar )+import Foreign.Ptr ( Ptr, nullPtr, FunPtr )++import Sound.OpenAL.AL.Buffer+import Sound.OpenAL.AL.Format+import Sound.OpenAL.ALC.ALCboolean+import Sound.OpenAL.ALC.BasicTypes+import Sound.OpenAL.ALC.Context+import Sound.OpenAL.ALC.Device+import Sound.OpenAL.ALC.Extensions+import Sound.OpenAL.ALC.QueryUtils+import Sound.OpenAL.ALC.String+import Sound.OpenAL.Config++--------------------------------------------------------------------------------++type NumSamples = ALCsizei++--------------------------------------------------------------------------------++type Invoker a = FunPtr a -> a++getCaptureFunc :: String -> IO (FunPtr a)+getCaptureFunc = get . alcProcAddress Nothing++--------------------------------------------------------------------------------++captureOpenDevice :: MonadIO m =>+   Maybe String -> Frequency -> Format -> NumSamples -> m (Maybe Device)+captureOpenDevice maybeDeviceSpec frequency format size = liftIO $ 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 ccall unsafe "dynamic"+   invokeCaptureOpenDevice :: Invoker (Ptr ALCchar -> ALCuint -> ALCenum -> ALCsizei -> IO ALCdevice)++--------------------------------------------------------------------------------++captureStart :: MonadIO m => Device -> m ()+captureStart = captureStartStop "alcCaptureStart"++captureStartStop :: MonadIO m => String -> Device -> m ()+captureStartStop funName device = liftIO $ do+   funPtr <- getCaptureFunc funName+   invokeCaptureStartStop funPtr (marshalDevice device)++foreign import ccall unsafe "dynamic"+   invokeCaptureStartStop :: Invoker (ALCdevice -> IO ()) ++--------------------------------------------------------------------------------++captureNumSamples :: Device -> GettableStateVar NumSamples+captureNumSamples device = makeGettableStateVar $+   fmap fromIntegral (getInteger (Just device) CaptureSamples)++--------------------------------------------------------------------------------++captureSamples :: MonadIO m => Device -> Ptr a -> NumSamples -> m ()+captureSamples device buf n = liftIO $ do+   funPtr <- getCaptureFunc "alcCaptureSamples"+   invokeCaptureSamples funPtr (marshalDevice device) buf n++foreign import ccall unsafe "dynamic"+   invokeCaptureSamples :: Invoker (ALCdevice -> Ptr a -> NumSamples -> IO ())++--------------------------------------------------------------------------------++captureStop :: MonadIO m => Device -> m ()+captureStop = captureStartStop "alcCaptureStop"++--------------------------------------------------------------------------------++captureCloseDevice :: MonadIO m => Device -> m Bool+captureCloseDevice device = liftIO $ do+   funPtr <- getCaptureFunc "alcCaptureCloseDevice"+   fmap unmarshalALCboolean .+      invokeCaptureCloseDevice funPtr . marshalDevice $ device++foreign import ccall 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
+ src/Sound/OpenAL/ALC/Context.hs view
@@ -0,0 +1,197 @@+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.ALC.Context+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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 Control.Monad.IO.Class ( MonadIO(..) )+import Data.StateVar ( GettableStateVar, makeGettableStateVar+                     , StateVar, makeStateVar )+import Foreign.Marshal.Array ( withArray0 )+import Foreign.Ptr ( Ptr )++import Sound.OpenAL.ALC.ALCboolean+import Sound.OpenAL.ALC.BasicTypes+import Sound.OpenAL.ALC.Device+import Sound.OpenAL.ALC.QueryUtils+import Sound.OpenAL.Config+import Sound.OpenAL.Constants++-- For Haddock only.+import Sound.OpenAL.ALC.Errors++--------------------------------------------------------------------------------++-- | 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 :: MonadIO m => Device -> [ContextAttribute] -> m (Maybe Context)+createContext device attributes = liftIO $ do+   let pairToList (key, value) = [key, value]+       attrs = concatMap (pairToList . marshalContextAttribute) attributes+   fmap unmarshalContext .+      withArray0 0 attrs . alcCreateContext . marshalDevice $ device++foreign import ccall 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 ccall 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 :: MonadIO m => Context -> m ()+processContext = liftIO . 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 :: MonadIO m => Context -> m ()+suspendContext = liftIO . alcSuspendContext . marshalContext++foreign import ccall 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 :: MonadIO m => Context -> m ()+destroyContext = liftIO . 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 ccall 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)
+ src/Sound/OpenAL/ALC/Device.hs view
@@ -0,0 +1,222 @@+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.ALC.Device+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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 Control.Monad.IO.Class ( MonadIO(..) )+import Data.StateVar ( get, GettableStateVar, makeGettableStateVar )+import Foreign.Ptr ( Ptr, nullPtr )+import Foreign.Marshal.Utils ( maybePeek )++import Sound.OpenAL.ALC.BasicTypes+import Sound.OpenAL.ALC.QueryUtils+import Sound.OpenAL.ALC.String+import Sound.OpenAL.Config++--------------------------------------------------------------------------------++-- | '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 :: MonadIO m => Maybe String -> m (Maybe Device)+openDevice maybeDeviceSpec =+   liftIO $ fmap unmarshalDevice $+      maybe (alcOpenDevice nullPtr)   -- use preferred device+            (flip withALCString alcOpenDevice)+            maybeDeviceSpec++foreign import ccall 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]))
+ src/Sound/OpenAL/ALC/Errors.hs view
@@ -0,0 +1,97 @@+{-# LANGUAGE CPP #-}+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.ALC.Errors+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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++#if __GLASGOW_HASKELL__ >= 704+-- Make the foreign imports happy.+import Foreign.C.Types+#endif++import Data.StateVar ( GettableStateVar, makeGettableStateVar )++import Sound.OpenAL.ALC.BasicTypes+import Sound.OpenAL.ALC.Device+import Sound.OpenAL.ALC.QueryUtils+import Sound.OpenAL.Constants+import Sound.OpenAL.Config++--------------------------------------------------------------------------------++-- | 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 ccall unsafe "alcGetError"+   alcGetError :: ALCdevice -> IO ALCenum
+ src/Sound/OpenAL/ALC/Extensions.hs view
@@ -0,0 +1,91 @@+{-# LANGUAGE CPP #-}+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.ALC.Extensions+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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++#if __GLASGOW_HASKELL__ >= 704+-- Make the foreign imports happy.+import Foreign.C.Types+#endif++import Control.Monad ( liftM2 )+import Data.StateVar ( GettableStateVar, makeGettableStateVar )+import Foreign.Ptr ( Ptr, FunPtr )++import Sound.OpenAL.ALC.BasicTypes+import Sound.OpenAL.ALC.Device+import Sound.OpenAL.ALC.QueryUtils+import Sound.OpenAL.ALC.String+import Sound.OpenAL.Config++--------------------------------------------------------------------------------++-- | 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 ccall 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 ccall 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
+ src/Sound/OpenAL/ALC/QueryUtils.hs view
@@ -0,0 +1,123 @@+{-# LANGUAGE CPP #-}+{-# OPTIONS_HADDOCK hide #-}+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.ALC.QueryUtils+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- Stability   :  stable+-- Portability :  portable+--+--------------------------------------------------------------------------------++module Sound.OpenAL.ALC.QueryUtils (+   StringQuery(..), getString, getStringRaw,+   IntQuery(..), marshalIntQuery, getInteger, getIntegerv,+   alcIsExtensionPresent+) where++#if __GLASGOW_HASKELL__ >= 704+-- Make the foreign imports happy.+import Foreign.C.Types+#endif++import Control.Monad ( when )+import Data.StateVar ( GettableStateVar, makeGettableStateVar )+import Foreign.Marshal.Array ( withArray, peekArray )+import Foreign.Ptr ( Ptr )++import Sound.OpenAL.ALC.ALCboolean+import Sound.OpenAL.ALC.BasicTypes+import Sound.OpenAL.ALC.String+import Sound.OpenAL.Config+import Sound.OpenAL.Constants++--------------------------------------------------------------------------------++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 ccall 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 ccall 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 ccall unsafe "alcIsExtensionPresent"+   alcIsExtensionPresent_ :: ALCdevice -> Ptr ALCchar -> IO ALCboolean
+ src/Sound/OpenAL/ALC/String.hs view
@@ -0,0 +1,43 @@+{-# OPTIONS_HADDOCK hide #-}+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.ALC.String+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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++--------------------------------------------------------------------------------++-- 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)
+ src/Sound/OpenAL/Config.hs view
@@ -0,0 +1,192 @@+{-# OPTIONS_HADDOCK hide #-}+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.Config+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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 Control.Monad.IO.Class ( MonadIO(..) )+import Foreign.C.Types+import Foreign.Ptr ( Ptr, nullPtr )++--------------------------------------------------------------------------------+-- AL types++-- | 8-bit boolean+type ALboolean = CChar++-- | Character+type ALchar = CChar++-- | Signed 8-bit 2\'s complement integer+type ALbyte = CSChar++-- | Unsigned 8-bit integer+type ALubyte = CUChar++-- | Signed 16-bit 2\'s complement integer+type ALshort = CShort++-- | Unsigned 16-bit integer+type ALushort = CUShort++-- | Signed 32-bit 2\'s complement integer+type ALint = CInt++-- | Unsigned 32-bit integer+type ALuint = CUInt++-- | Non-negatitve 32-bit binary integer size+type ALsizei = CInt++-- | Enumerated 32-bit value+type ALenum = CInt++-- | 32-bit IEEE754 floating-point+type ALfloat = CFloat++-- | 64-bit IEEE754 floating-point+type ALdouble = CDouble++--------------------------------------------------------------------------------+-- ALC types++-- | 8-bit boolean+type ALCboolean = CChar++-- | Character+type ALCchar = CChar++-- | Signed 8-bit 2\'s complement integer+type ALCbyte = CSChar++-- | Unsigned 8-bit integer+type ALCubyte = CUChar++-- | Signed 16-bit 2\'s complement integer+type ALCshort = CShort++-- | Unsigned 16-bit integer+type ALCushort = CUShort++-- | Signed 32-bit 2\'s complement integer+type ALCint = CInt++-- | Unsigned 32-bit integer+type ALCuint = CUInt++-- | Non-negatitve 32-bit binary integer size+type ALCsizei = CInt++-- | Enumerated 32-bit value+type ALCenum = CInt++-- | 32-bit IEEE754 floating-point+type ALCfloat = CFloat++-- | 64-bit IEEE754 floating-point+type ALCdouble = CDouble++--------------------------------------------------------------------------------+-- 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 :: MonadIO m => Device -> m Bool+-- inlined unmarshalALCboolean here to break dependency cycle+closeDevice = liftIO . fmap (/= 0) . alcCloseDevice . marshalDevice++foreign import ccall unsafe "alcCloseDevice"+   alcCloseDevice :: ALCdevice -> IO ALCboolean++--------------------------------------------------------------------------------+-- 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)++--------------------------------------------------------------------------------+-- In ancient times, alcProcessContext returned ALCcontext.++foreign import ccall unsafe "alcProcessContext"+   alcProcessContext :: ALCcontext -> IO ()++--------------------------------------------------------------------------------+-- In OpenAL 1.1, alcMakeContextCurrent() returns void, before it was ALCenum on+-- Linux and ALCboolean on other platforms.++foreign import ccall unsafe "alcMakeContextCurrent"+   alcMakeContextCurrent :: ALCcontext -> IO ALCboolean++--------------------------------------------------------------------------------+-- In OpenAL 1.1, alcDestroyContext() returns void, before it returned ALCenum+-- on Linux.++foreign import ccall unsafe "alcDestroyContext"+   alcDestroyContext :: ALCcontext -> IO ()
+ src/Sound/OpenAL/Constants.hs view
@@ -0,0 +1,162 @@+{-# OPTIONS_HADDOCK hide #-}+--------------------------------------------------------------------------------+-- |+-- Module      :  Sound.OpenAL.Constants+-- Copyright   :  (c) Sven Panne 2003-2016+-- License     :  BSD3+-- +-- Maintainer  :  Sven Panne <svenpanne@gmail.com>+-- 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 )++--------------------------------------------------------------------------------++al_FALSE, al_TRUE :: ALboolean+al_FALSE                            = 0x0000+al_TRUE                             = 0x0001++al_NO_ERROR, al_INVALID_NAME, al_INVALID_ENUM, al_INVALID_VALUE,+   al_INVALID_OPERATION, al_OUT_OF_MEMORY :: ALenum+al_NO_ERROR                         = 0x0000+al_INVALID_NAME                     = 0xA001+al_INVALID_ENUM                     = 0xA002+al_INVALID_VALUE                    = 0xA003+al_INVALID_OPERATION                = 0xA004+al_OUT_OF_MEMORY                    = 0xA005++--------------------------------------------------------------------------------++al_DISTANCE_MODEL, al_DOPPLER_FACTOR, al_SPEED_OF_SOUND :: ALenum+al_DISTANCE_MODEL                   = 0xD000+al_DOPPLER_FACTOR                   = 0xC000+al_SPEED_OF_SOUND                   = 0xC003++al_VERSION, al_RENDERER, al_VENDOR, al_EXTENSIONS :: ALenum+al_VERSION                          = 0xB002+al_RENDERER                         = 0xB003+al_VENDOR                           = 0xB001+al_EXTENSIONS                       = 0xB004++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                             = 0x0000+al_INVERSE_DISTANCE                 = 0xD001+al_INVERSE_DISTANCE_CLAMPED         = 0xD002+al_LINEAR_DISTANCE                  = 0xD003+al_LINEAR_DISTANCE_CLAMPED          = 0xD004+al_EXPONENT_DISTANCE                = 0xD005+al_EXPONENT_DISTANCE_CLAMPED        = 0xD006++--------------------------------------------------------------------------------++al_POSITION, al_VELOCITY, al_GAIN :: ALenum+al_POSITION                         = 0x1004+al_VELOCITY                         = 0x1006+al_GAIN                             = 0x100A++al_ORIENTATION :: ALenum+al_ORIENTATION                      = 0x100F++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                  = 0x0202+al_SOURCE_TYPE                      = 0x1027+al_LOOPING                          = 0x1007+al_BUFFER                           = 0x1009+al_BUFFERS_QUEUED                   = 0x1015+al_BUFFERS_PROCESSED                = 0x1016+al_MIN_GAIN                         = 0x100D+al_MAX_GAIN                         = 0x100E+al_REFERENCE_DISTANCE               = 0x1020+al_ROLLOFF_FACTOR                   = 0x1021+al_MAX_DISTANCE                     = 0x1023+al_PITCH                            = 0x1003+al_DIRECTION                        = 0x1005+al_CONE_INNER_ANGLE                 = 0x1001+al_CONE_OUTER_ANGLE                 = 0x1002+al_CONE_OUTER_GAIN                  = 0x1022+al_SEC_OFFSET                       = 0x1024+al_SAMPLE_OFFSET                    = 0x1025+al_BYTE_OFFSET                      = 0x1026+al_SOURCE_STATE                     = 0x1010++al_UNDETERMINED, al_STATIC, al_STREAMING :: ALint+al_UNDETERMINED                     = 0x1030+al_STATIC                           = 0x1028+al_STREAMING                        = 0x1029++al_INITIAL, al_PLAYING, al_PAUSED, al_STOPPED :: ALint+al_INITIAL                          = 0x1011+al_PLAYING                          = 0x1012+al_PAUSED                           = 0x1013+al_STOPPED                          = 0x1014++--------------------------------------------------------------------------------++al_FREQUENCY, al_SIZE, al_BITS, al_CHANNELS :: ALenum+al_FREQUENCY                        = 0x2001+al_SIZE                             = 0x2004+al_BITS                             = 0x2002+al_CHANNELS                         = 0x2003++al_FORMAT_MONO8, al_FORMAT_MONO16, al_FORMAT_STEREO8,+   al_FORMAT_STEREO16 :: ALenum+al_FORMAT_MONO8                     = 0x1100+al_FORMAT_MONO16                    = 0x1101+al_FORMAT_STEREO8                   = 0x1102+al_FORMAT_STEREO16                  = 0x1103++--------------------------------------------------------------------------------++alc_FALSE, alc_TRUE :: ALCboolean+alc_FALSE                           = 0x0000+alc_TRUE                            = 0x0001++alc_FREQUENCY, alc_REFRESH, alc_SYNC, alc_MONO_SOURCES,+   alc_STEREO_SOURCES :: ALCint+alc_FREQUENCY                       = 0x1007+alc_REFRESH                         = 0x1008+alc_SYNC                            = 0x1009+alc_MONO_SOURCES                    = 0x1010+alc_STEREO_SOURCES                  = 0x1011++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                        = 0x0000+alc_INVALID_DEVICE                  = 0xA001+alc_INVALID_CONTEXT                 = 0xA002+alc_INVALID_ENUM                    = 0xA003+alc_INVALID_VALUE                   = 0xA004+alc_INVALID_OPERATION               = 0xA006+alc_OUT_OF_MEMORY                   = 0xA005++alc_DEFAULT_DEVICE_SPECIFIER, alc_DEVICE_SPECIFIER, alc_EXTENSIONS,+   alc_CAPTURE_DEFAULT_DEVICE_SPECIFIER, alc_CAPTURE_DEVICE_SPECIFIER :: ALCenum+alc_DEFAULT_DEVICE_SPECIFIER        = 0x1004+alc_DEVICE_SPECIFIER                = 0x1005+alc_EXTENSIONS                      = 0x1006+alc_CAPTURE_DEFAULT_DEVICE_SPECIFIER= 0x0311+alc_CAPTURE_DEVICE_SPECIFIER        = 0x0310++alc_ATTRIBUTES_SIZE, alc_ALL_ATTRIBUTES, alc_MAJOR_VERSION, alc_MINOR_VERSION,+   alc_CAPTURE_SAMPLES :: ALCenum+alc_ATTRIBUTES_SIZE                 = 0x1002+alc_ALL_ATTRIBUTES                  = 0x1003+alc_MAJOR_VERSION                   = 0x1000+alc_MINOR_VERSION                   = 0x1001+alc_CAPTURE_SAMPLES                 = 0x0312