1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/.hgignore	Mon Jan 28 18:19:26 2019 +0200
     1.3 @@ -0,0 +1,5 @@
     1.4 +\.o$
     1.5 +\.d$
     1.6 +\.swp$
     1.7 +\.a$
     1.8 +\.so\.

     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/Makefile	Mon Jan 28 18:19:26 2019 +0200
     2.3 @@ -0,0 +1,43 @@
     2.4 +src = $(wildcard src/*.cpp)
     2.5 +obj = $(src:.cpp=.o)
     2.6 +dep = $(obj:.o=.d)
     2.7 +
     2.8 +name = miniassimp
     2.9 +so_major = 0
    2.10 +so_minor = 1
    2.11 +
    2.12 +liba = lib$(name).a
    2.13 +libso = lib$(name).so
    2.14 +ldname = lib$(name).so.$(so_major)
    2.15 +soname = lib$(name).so.$(so_major).$(so_minor)
    2.16 +
    2.17 +warn = -pedantic -Wall
    2.18 +dbg = -g
    2.19 +opt = -O0
    2.20 +inc = -Iinclude
    2.21 +
    2.22 +CC=gcc
    2.23 +CXX=g++
    2.24 +CFLAGS = $(warn) $(dbg) $(opt) $(def) $(inc)
    2.25 +CXXFLAGS = $(warn) $(dbg) $(opt) $(def) $(inc)
    2.26 +
    2.27 +shared = -shared -Wl,-soname,$(soname)
    2.28 +
    2.29 +.PHONY: all
    2.30 +all: $(libso) $(liba)
    2.31 +
    2.32 +$(liba): $(obj)
    2.33 +	$(AR) rcs $@ $(obj)
    2.34 +
    2.35 +$(libso): $(obj)
    2.36 +	$(CC) -o $@ $(shared) $(obj) $(LDFLAGS)
    2.37 +
    2.38 +-include $(dep)
    2.39 +
    2.40 +%.d: %.cpp
    2.41 +	@echo depfile $@
    2.42 +	@$(CPP) $(CXXFLAGS) $< -MM -MT $(@:.d=.o) >$@
    2.43 +
    2.44 +.PHONY: clean
    2.45 +clean:
    2.46 +	rm -f $(obj) $(liba) $(libso)

     3.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.2 +++ b/include/miniassimp/BaseImporter.h	Mon Jan 28 18:19:26 2019 +0200
     3.3 @@ -0,0 +1,361 @@
     3.4 +/*
     3.5 +Open Asset Import Library (assimp)
     3.6 +----------------------------------------------------------------------
     3.7 +
     3.8 +Copyright (c) 2006-2018, assimp team
     3.9 +
    3.10 +
    3.11 +All rights reserved.
    3.12 +
    3.13 +Redistribution and use of this software in source and binary forms,
    3.14 +with or without modification, are permitted provided that the
    3.15 +following conditions are met:
    3.16 +
    3.17 +* Redistributions of source code must retain the above
    3.18 +  copyright notice, this list of conditions and the
    3.19 +  following disclaimer.
    3.20 +
    3.21 +* Redistributions in binary form must reproduce the above
    3.22 +  copyright notice, this list of conditions and the
    3.23 +  following disclaimer in the documentation and/or other
    3.24 +  materials provided with the distribution.
    3.25 +
    3.26 +* Neither the name of the assimp team, nor the names of its
    3.27 +  contributors may be used to endorse or promote products
    3.28 +  derived from this software without specific prior
    3.29 +  written permission of the assimp team.
    3.30 +
    3.31 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    3.32 +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    3.33 +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    3.34 +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
    3.35 +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    3.36 +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    3.37 +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    3.38 +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    3.39 +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    3.40 +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    3.41 +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    3.42 +
    3.43 +----------------------------------------------------------------------
    3.44 +*/
    3.45 +
    3.46 +/** @file Definition of the base class for all importer worker classes. */
    3.47 +#ifndef INCLUDED_AI_BASEIMPORTER_H
    3.48 +#define INCLUDED_AI_BASEIMPORTER_H
    3.49 +
    3.50 +#include "Exceptional.h"
    3.51 +
    3.52 +#include <vector>
    3.53 +#include <set>
    3.54 +#include <miniassimp/types.h>
    3.55 +#include <miniassimp/ProgressHandler.hpp>
    3.56 +
    3.57 +struct aiScene;
    3.58 +struct aiImporterDesc;
    3.59 +
    3.60 +namespace Assimp    {
    3.61 +
    3.62 +class Importer;
    3.63 +class IOSystem;
    3.64 +class BaseProcess;
    3.65 +class SharedPostProcessInfo;
    3.66 +class IOStream;
    3.67 +
    3.68 +// utility to do char4 to uint32 in a portable manner
    3.69 +#define AI_MAKE_MAGIC(string) ((uint32_t)((string[0] << 24) + \
    3.70 +    (string[1] << 16) + (string[2] << 8) + string[3]))
    3.71 +
    3.72 +
    3.73 +// ---------------------------------------------------------------------------
    3.74 +/** FOR IMPORTER PLUGINS ONLY: The BaseImporter defines a common interface
    3.75 + *  for all importer worker classes.
    3.76 + *
    3.77 + * The interface defines two functions: CanRead() is used to check if the
    3.78 + * importer can handle the format of the given file. If an implementation of
    3.79 + * this function returns true, the importer then calls ReadFile() which
    3.80 + * imports the given file. ReadFile is not overridable, it just calls
    3.81 + * InternReadFile() and catches any ImportErrorException that might occur.
    3.82 + */
    3.83 +class ASSIMP_API BaseImporter {
    3.84 +    friend class Importer;
    3.85 +
    3.86 +public:
    3.87 +
    3.88 +    /** Constructor to be privately used by #Importer */
    3.89 +    BaseImporter() AI_NO_EXCEPT;
    3.90 +
    3.91 +    /** Destructor, private as well */
    3.92 +    virtual ~BaseImporter();
    3.93 +
    3.94 +    // -------------------------------------------------------------------
    3.95 +    /** Returns whether the class can handle the format of the given file.
    3.96 +     *
    3.97 +     * The implementation should be as quick as possible. A check for
    3.98 +     * the file extension is enough. If no suitable loader is found with
    3.99 +     * this strategy, CanRead() is called again, the 'checkSig' parameter
   3.100 +     * set to true this time. Now the implementation is expected to
   3.101 +     * perform a full check of the file structure, possibly searching the
   3.102 +     * first bytes of the file for magic identifiers or keywords.
   3.103 +     *
   3.104 +     * @param pFile Path and file name of the file to be examined.
   3.105 +     * @param pIOHandler The IO handler to use for accessing any file.
   3.106 +     * @param checkSig Set to true if this method is called a second time.
   3.107 +     *   This time, the implementation may take more time to examine the
   3.108 +     *   contents of the file to be loaded for magic bytes, keywords, etc
   3.109 +     *   to be able to load files with unknown/not existent file extensions.
   3.110 +     * @return true if the class can read this file, false if not.
   3.111 +     */
   3.112 +    virtual bool CanRead(
   3.113 +        const std::string& pFile,
   3.114 +        IOSystem* pIOHandler,
   3.115 +        bool checkSig
   3.116 +        ) const = 0;
   3.117 +
   3.118 +    // -------------------------------------------------------------------
   3.119 +    /** Imports the given file and returns the imported data.
   3.120 +     * If the import succeeds, ownership of the data is transferred to
   3.121 +     * the caller. If the import fails, NULL is returned. The function
   3.122 +     * takes care that any partially constructed data is destroyed
   3.123 +     * beforehand.
   3.124 +     *
   3.125 +     * @param pImp #Importer object hosting this loader.
   3.126 +     * @param pFile Path of the file to be imported.
   3.127 +     * @param pIOHandler IO-Handler used to open this and possible other files.
   3.128 +     * @return The imported data or NULL if failed. If it failed a
   3.129 +     * human-readable error description can be retrieved by calling
   3.130 +     * GetErrorText()
   3.131 +     *
   3.132 +     * @note This function is not intended to be overridden. Implement
   3.133 +     * InternReadFile() to do the import. If an exception is thrown somewhere
   3.134 +     * in InternReadFile(), this function will catch it and transform it into
   3.135 +     *  a suitable response to the caller.
   3.136 +     */
   3.137 +    aiScene* ReadFile(
   3.138 +        const Importer* pImp,
   3.139 +        const std::string& pFile,
   3.140 +        IOSystem* pIOHandler
   3.141 +        );
   3.142 +
   3.143 +    // -------------------------------------------------------------------
   3.144 +    /** Returns the error description of the last error that occurred.
   3.145 +     * @return A description of the last error that occurred. An empty
   3.146 +     * string if there was no error.
   3.147 +     */
   3.148 +    const std::string& GetErrorText() const {
   3.149 +        return m_ErrorText;
   3.150 +    }
   3.151 +
   3.152 +    // -------------------------------------------------------------------
   3.153 +    /** Called prior to ReadFile().
   3.154 +     * The function is a request to the importer to update its configuration
   3.155 +     * basing on the Importer's configuration property list.
   3.156 +     * @param pImp Importer instance
   3.157 +     */
   3.158 +    virtual void SetupProperties(
   3.159 +        const Importer* pImp
   3.160 +        );
   3.161 +
   3.162 +    // -------------------------------------------------------------------
   3.163 +    /** Called by #Importer::GetImporterInfo to get a description of
   3.164 +     *  some loader features. Importers must provide this information. */
   3.165 +    virtual const aiImporterDesc* GetInfo() const = 0;
   3.166 +
   3.167 +    // -------------------------------------------------------------------
   3.168 +    /** Called by #Importer::GetExtensionList for each loaded importer.
   3.169 +     *  Take the extension list contained in the structure returned by
   3.170 +     *  #GetInfo and insert all file extensions into the given set.
   3.171 +     *  @param extension set to collect file extensions in*/
   3.172 +    void GetExtensionList(std::set<std::string>& extensions);
   3.173 +
   3.174 +protected:
   3.175 +
   3.176 +    // -------------------------------------------------------------------
   3.177 +    /** Imports the given file into the given scene structure. The
   3.178 +     * function is expected to throw an ImportErrorException if there is
   3.179 +     * an error. If it terminates normally, the data in aiScene is
   3.180 +     * expected to be correct. Override this function to implement the
   3.181 +     * actual importing.
   3.182 +     * <br>
   3.183 +     *  The output scene must meet the following requirements:<br>
   3.184 +     * <ul>
   3.185 +     * <li>At least a root node must be there, even if its only purpose
   3.186 +     *     is to reference one mesh.</li>
   3.187 +     * <li>aiMesh::mPrimitiveTypes may be 0. The types of primitives
   3.188 +     *   in the mesh are determined automatically in this case.</li>
   3.189 +     * <li>the vertex data is stored in a pseudo-indexed "verbose" format.
   3.190 +     *   In fact this means that every vertex that is referenced by
   3.191 +     *   a face is unique. Or the other way round: a vertex index may
   3.192 +     *   not occur twice in a single aiMesh.</li>
   3.193 +     * <li>aiAnimation::mDuration may be -1. Assimp determines the length
   3.194 +     *   of the animation automatically in this case as the length of
   3.195 +     *   the longest animation channel.</li>
   3.196 +     * <li>aiMesh::mBitangents may be NULL if tangents and normals are
   3.197 +     *   given. In this case bitangents are computed as the cross product
   3.198 +     *   between normal and tangent.</li>
   3.199 +     * <li>There needn't be a material. If none is there a default material
   3.200 +     *   is generated. However, it is recommended practice for loaders
   3.201 +     *   to generate a default material for yourself that matches the
   3.202 +     *   default material setting for the file format better than Assimp's
   3.203 +     *   generic default material. Note that default materials *should*
   3.204 +     *   be named AI_DEFAULT_MATERIAL_NAME if they're just color-shaded
   3.205 +     *   or AI_DEFAULT_TEXTURED_MATERIAL_NAME if they define a (dummy)
   3.206 +     *   texture. </li>
   3.207 +     * </ul>
   3.208 +     * If the AI_SCENE_FLAGS_INCOMPLETE-Flag is <b>not</b> set:<ul>
   3.209 +     * <li> at least one mesh must be there</li>
   3.210 +     * <li> there may be no meshes with 0 vertices or faces</li>
   3.211 +     * </ul>
   3.212 +     * This won't be checked (except by the validation step): Assimp will
   3.213 +     * crash if one of the conditions is not met!
   3.214 +     *
   3.215 +     * @param pFile Path of the file to be imported.
   3.216 +     * @param pScene The scene object to hold the imported data.
   3.217 +     * NULL is not a valid parameter.
   3.218 +     * @param pIOHandler The IO handler to use for any file access.
   3.219 +     * NULL is not a valid parameter. */
   3.220 +    virtual void InternReadFile(
   3.221 +        const std::string& pFile,
   3.222 +        aiScene* pScene,
   3.223 +        IOSystem* pIOHandler
   3.224 +        ) = 0;
   3.225 +
   3.226 +public: // static utilities
   3.227 +
   3.228 +    // -------------------------------------------------------------------
   3.229 +    /** A utility for CanRead().
   3.230 +     *
   3.231 +     *  The function searches the header of a file for a specific token
   3.232 +     *  and returns true if this token is found. This works for text
   3.233 +     *  files only. There is a rudimentary handling of UNICODE files.
   3.234 +     *  The comparison is case independent.
   3.235 +     *
   3.236 +     *  @param pIOSystem IO System to work with
   3.237 +     *  @param file File name of the file
   3.238 +     *  @param tokens List of tokens to search for
   3.239 +     *  @param numTokens Size of the token array
   3.240 +     *  @param searchBytes Number of bytes to be searched for the tokens.
   3.241 +     */
   3.242 +    static bool SearchFileHeaderForToken(
   3.243 +        IOSystem* pIOSystem,
   3.244 +        const std::string&  file,
   3.245 +        const char** tokens,
   3.246 +        unsigned int numTokens,
   3.247 +        unsigned int searchBytes = 200,
   3.248 +        bool tokensSol = false,
   3.249 +        bool noAlphaBeforeTokens = false);
   3.250 +
   3.251 +    // -------------------------------------------------------------------
   3.252 +    /** @brief Check whether a file has a specific file extension
   3.253 +     *  @param pFile Input file
   3.254 +     *  @param ext0 Extension to check for. Lowercase characters only, no dot!
   3.255 +     *  @param ext1 Optional second extension
   3.256 +     *  @param ext2 Optional third extension
   3.257 +     *  @note Case-insensitive
   3.258 +     */
   3.259 +    static bool SimpleExtensionCheck (
   3.260 +        const std::string& pFile,
   3.261 +        const char* ext0,
   3.262 +        const char* ext1 = NULL,
   3.263 +        const char* ext2 = NULL);
   3.264 +
   3.265 +    // -------------------------------------------------------------------
   3.266 +    /** @brief Extract file extension from a string
   3.267 +     *  @param pFile Input file
   3.268 +     *  @return Extension without trailing dot, all lowercase
   3.269 +     */
   3.270 +    static std::string GetExtension (
   3.271 +        const std::string& pFile);
   3.272 +
   3.273 +    // -------------------------------------------------------------------
   3.274 +    /** @brief Check whether a file starts with one or more magic tokens
   3.275 +     *  @param pFile Input file
   3.276 +     *  @param pIOHandler IO system to be used
   3.277 +     *  @param magic n magic tokens
   3.278 +     *  @params num Size of magic
   3.279 +     *  @param offset Offset from file start where tokens are located
   3.280 +     *  @param Size of one token, in bytes. Maximally 16 bytes.
   3.281 +     *  @return true if one of the given tokens was found
   3.282 +     *
   3.283 +     *  @note For convenience, the check is also performed for the
   3.284 +     *  byte-swapped variant of all tokens (big endian). Only for
   3.285 +     *  tokens of size 2,4.
   3.286 +     */
   3.287 +    static bool CheckMagicToken(
   3.288 +        IOSystem* pIOHandler,
   3.289 +        const std::string& pFile,
   3.290 +        const void* magic,
   3.291 +        unsigned int num,
   3.292 +        unsigned int offset = 0,
   3.293 +        unsigned int size   = 4);
   3.294 +
   3.295 +    // -------------------------------------------------------------------
   3.296 +    /** An utility for all text file loaders. It converts a file to our
   3.297 +     *   UTF8 character set. Errors are reported, but ignored.
   3.298 +     *
   3.299 +     *  @param data File buffer to be converted to UTF8 data. The buffer
   3.300 +     *  is resized as appropriate. */
   3.301 +    static void ConvertToUTF8(
   3.302 +        std::vector<char>& data);
   3.303 +
   3.304 +    // -------------------------------------------------------------------
   3.305 +    /** An utility for all text file loaders. It converts a file from our
   3.306 +     *   UTF8 character set back to ISO-8859-1. Errors are reported, but ignored.
   3.307 +     *
   3.308 +     *  @param data File buffer to be converted from UTF8 to ISO-8859-1. The buffer
   3.309 +     *  is resized as appropriate. */
   3.310 +    static void ConvertUTF8toISO8859_1(
   3.311 +        std::string& data);
   3.312 +
   3.313 +    // -------------------------------------------------------------------
   3.314 +    /// @brief  Enum to define, if empty files are ok or not.
   3.315 +    enum TextFileMode { 
   3.316 +        ALLOW_EMPTY,
   3.317 +        FORBID_EMPTY 
   3.318 +    };
   3.319 +
   3.320 +    // -------------------------------------------------------------------
   3.321 +    /** Utility for text file loaders which copies the contents of the
   3.322 +     *  file into a memory buffer and converts it to our UTF8
   3.323 +     *  representation.
   3.324 +     *  @param stream Stream to read from.
   3.325 +     *  @param data Output buffer to be resized and filled with the
   3.326 +     *   converted text file data. The buffer is terminated with
   3.327 +     *   a binary 0.
   3.328 +     *  @param mode Whether it is OK to load empty text files. */
   3.329 +    static void TextFileToBuffer(
   3.330 +        IOStream* stream,
   3.331 +        std::vector<char>& data,
   3.332 +        TextFileMode mode = FORBID_EMPTY);
   3.333 +
   3.334 +    // -------------------------------------------------------------------
   3.335 +    /** Utility function to move a std::vector into a aiScene array
   3.336 +    *  @param vec The vector to be moved
   3.337 +    *  @param out The output pointer to the allocated array.
   3.338 +    *  @param numOut The output count of elements copied. */
   3.339 +    template<typename T>
   3.340 +    AI_FORCE_INLINE
   3.341 +    static void CopyVector(
   3.342 +        std::vector<T>& vec,
   3.343 +        T*& out,
   3.344 +        unsigned int& outLength)
   3.345 +    {
   3.346 +        outLength = unsigned(vec.size());
   3.347 +        if (outLength) {
   3.348 +            out = new T[outLength];
   3.349 +            std::swap_ranges(vec.begin(), vec.end(), out);
   3.350 +        }
   3.351 +    }
   3.352 +
   3.353 +protected:
   3.354 +    /// Error description in case there was one.
   3.355 +    std::string m_ErrorText;
   3.356 +    /// Currently set progress handler.
   3.357 +    ProgressHandler* m_progress;
   3.358 +};
   3.359 +
   3.360 +
   3.361 +
   3.362 +} // end of namespace Assimp
   3.363 +
   3.364 +#endif // AI_BASEIMPORTER_H_INC

     4.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.2 +++ b/include/miniassimp/Compiler/poppack1.h	Mon Jan 28 18:19:26 2019 +0200
     4.3 @@ -0,0 +1,22 @@
     4.4 +
     4.5 +// ===============================================================================
     4.6 +// May be included multiple times - resets structure packing to the defaults 
     4.7 +// for all supported compilers. Reverts the changes made by #include <pushpack1.h> 
     4.8 +//
     4.9 +// Currently this works on the following compilers:
    4.10 +// MSVC 7,8,9
    4.11 +// GCC
    4.12 +// BORLAND (complains about 'pack state changed but not reverted', but works)
    4.13 +// ===============================================================================
    4.14 +
    4.15 +#ifndef AI_PUSHPACK_IS_DEFINED
    4.16 +#	error pushpack1.h must be included after poppack1.h
    4.17 +#endif
    4.18 +
    4.19 +// reset packing to the original value
    4.20 +#if defined(_MSC_VER) ||  defined(__BORLANDC__) || defined (__BCPLUSPLUS__)
    4.21 +#	pragma pack( pop )
    4.22 +#endif
    4.23 +#undef PACK_STRUCT
    4.24 +
    4.25 +#undef AI_PUSHPACK_IS_DEFINED

     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/include/miniassimp/Compiler/pstdint.h	Mon Jan 28 18:19:26 2019 +0200
     5.3 @@ -0,0 +1,912 @@
     5.4 +/*  A portable stdint.h
     5.5 + ****************************************************************************
     5.6 + *  BSD License:
     5.7 + ****************************************************************************
     5.8 + *
     5.9 + *  Copyright (c) 2005-2016 Paul Hsieh
    5.10 + *  All rights reserved.
    5.11 + *
    5.12 + *  Redistribution and use in source and binary forms, with or without
    5.13 + *  modification, are permitted provided that the following conditions
    5.14 + *  are met:
    5.15 + *
    5.16 + *  1. Redistributions of source code must retain the above copyright
    5.17 + *     notice, this list of conditions and the following disclaimer.
    5.18 + *  2. Redistributions in binary form must reproduce the above copyright
    5.19 + *     notice, this list of conditions and the following disclaimer in the
    5.20 + *     documentation and/or other materials provided with the distribution.
    5.21 + *  3. The name of the author may not be used to endorse or promote products
    5.22 + *     derived from this software without specific prior written permission.
    5.23 + *
    5.24 + *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
    5.25 + *  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
    5.26 + *  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
    5.27 + *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
    5.28 + *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
    5.29 + *  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    5.30 + *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    5.31 + *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    5.32 + *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
    5.33 + *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    5.34 + *
    5.35 + ****************************************************************************
    5.36 + *
    5.37 + *  Version 0.1.15.4
    5.38 + *
    5.39 + *  The ANSI C standard committee, for the C99 standard, specified the
    5.40 + *  inclusion of a new standard include file called stdint.h.  This is
    5.41 + *  a very useful and long desired include file which contains several
    5.42 + *  very precise definitions for integer scalar types that is
    5.43 + *  critically important for making portable several classes of
    5.44 + *  applications including cryptography, hashing, variable length
    5.45 + *  integer libraries and so on.  But for most developers its likely
    5.46 + *  useful just for programming sanity.
    5.47 + *
    5.48 + *  The problem is that some compiler vendors chose to ignore the C99
    5.49 + *  standard and some older compilers have no opportunity to be updated.
    5.50 + *  Because of this situation, simply including stdint.h in your code
    5.51 + *  makes it unportable.
    5.52 + *
    5.53 + *  So that's what this file is all about.  Its an attempt to build a
    5.54 + *  single universal include file that works on as many platforms as
    5.55 + *  possible to deliver what stdint.h is supposed to.  Even compilers
    5.56 + *  that already come with stdint.h can use this file instead without
    5.57 + *  any loss of functionality.  A few things that should be noted about
    5.58 + *  this file:
    5.59 + *
    5.60 + *    1) It is not guaranteed to be portable and/or present an identical
    5.61 + *       interface on all platforms.  The extreme variability of the
    5.62 + *       ANSI C standard makes this an impossibility right from the
    5.63 + *       very get go. Its really only meant to be useful for the vast
    5.64 + *       majority of platforms that possess the capability of
    5.65 + *       implementing usefully and precisely defined, standard sized
    5.66 + *       integer scalars.  Systems which are not intrinsically 2s
    5.67 + *       complement may produce invalid constants.
    5.68 + *
    5.69 + *    2) There is an unavoidable use of non-reserved symbols.
    5.70 + *
    5.71 + *    3) Other standard include files are invoked.
    5.72 + *
    5.73 + *    4) This file may come in conflict with future platforms that do
    5.74 + *       include stdint.h.  The hope is that one or the other can be
    5.75 + *       used with no real difference.
    5.76 + *
    5.77 + *    5) In the current version, if your platform can't represent
    5.78 + *       int32_t, int16_t and int8_t, it just dumps out with a compiler
    5.79 + *       error.
    5.80 + *
    5.81 + *    6) 64 bit integers may or may not be defined.  Test for their
    5.82 + *       presence with the test: #ifdef INT64_MAX or #ifdef UINT64_MAX.
    5.83 + *       Note that this is different from the C99 specification which
    5.84 + *       requires the existence of 64 bit support in the compiler.  If
    5.85 + *       this is not defined for your platform, yet it is capable of
    5.86 + *       dealing with 64 bits then it is because this file has not yet
    5.87 + *       been extended to cover all of your system's capabilities.
    5.88 + *
    5.89 + *    7) (u)intptr_t may or may not be defined.  Test for its presence
    5.90 + *       with the test: #ifdef PTRDIFF_MAX.  If this is not defined
    5.91 + *       for your platform, then it is because this file has not yet
    5.92 + *       been extended to cover all of your system's capabilities, not
    5.93 + *       because its optional.
    5.94 + *
    5.95 + *    8) The following might not been defined even if your platform is
    5.96 + *       capable of defining it:
    5.97 + *
    5.98 + *       WCHAR_MIN
    5.99 + *       WCHAR_MAX
   5.100 + *       (u)int64_t
   5.101 + *       PTRDIFF_MIN
   5.102 + *       PTRDIFF_MAX
   5.103 + *       (u)intptr_t
   5.104 + *
   5.105 + *    9) The following have not been defined:
   5.106 + *
   5.107 + *       WINT_MIN
   5.108 + *       WINT_MAX
   5.109 + *
   5.110 + *   10) The criteria for defining (u)int_least(*)_t isn't clear,
   5.111 + *       except for systems which don't have a type that precisely
   5.112 + *       defined 8, 16, or 32 bit types (which this include file does
   5.113 + *       not support anyways). Default definitions have been given.
   5.114 + *
   5.115 + *   11) The criteria for defining (u)int_fast(*)_t isn't something I
   5.116 + *       would trust to any particular compiler vendor or the ANSI C
   5.117 + *       committee.  It is well known that "compatible systems" are
   5.118 + *       commonly created that have very different performance
   5.119 + *       characteristics from the systems they are compatible with,
   5.120 + *       especially those whose vendors make both the compiler and the
   5.121 + *       system.  Default definitions have been given, but its strongly
   5.122 + *       recommended that users never use these definitions for any
   5.123 + *       reason (they do *NOT* deliver any serious guarantee of
   5.124 + *       improved performance -- not in this file, nor any vendor's
   5.125 + *       stdint.h).
   5.126 + *
   5.127 + *   12) The following macros:
   5.128 + *
   5.129 + *       PRINTF_INTMAX_MODIFIER
   5.130 + *       PRINTF_INT64_MODIFIER
   5.131 + *       PRINTF_INT32_MODIFIER
   5.132 + *       PRINTF_INT16_MODIFIER
   5.133 + *       PRINTF_LEAST64_MODIFIER
   5.134 + *       PRINTF_LEAST32_MODIFIER
   5.135 + *       PRINTF_LEAST16_MODIFIER
   5.136 + *       PRINTF_INTPTR_MODIFIER
   5.137 + *
   5.138 + *       are strings which have been defined as the modifiers required
   5.139 + *       for the "d", "u" and "x" printf formats to correctly output
   5.140 + *       (u)intmax_t, (u)int64_t, (u)int32_t, (u)int16_t, (u)least64_t,
   5.141 + *       (u)least32_t, (u)least16_t and (u)intptr_t types respectively.
   5.142 + *       PRINTF_INTPTR_MODIFIER is not defined for some systems which
   5.143 + *       provide their own stdint.h.  PRINTF_INT64_MODIFIER is not
   5.144 + *       defined if INT64_MAX is not defined.  These are an extension
   5.145 + *       beyond what C99 specifies must be in stdint.h.
   5.146 + *
   5.147 + *       In addition, the following macros are defined:
   5.148 + *
   5.149 + *       PRINTF_INTMAX_HEX_WIDTH
   5.150 + *       PRINTF_INT64_HEX_WIDTH
   5.151 + *       PRINTF_INT32_HEX_WIDTH
   5.152 + *       PRINTF_INT16_HEX_WIDTH
   5.153 + *       PRINTF_INT8_HEX_WIDTH
   5.154 + *       PRINTF_INTMAX_DEC_WIDTH
   5.155 + *       PRINTF_INT64_DEC_WIDTH
   5.156 + *       PRINTF_INT32_DEC_WIDTH
   5.157 + *       PRINTF_INT16_DEC_WIDTH
   5.158 + *       PRINTF_UINT8_DEC_WIDTH
   5.159 + *       PRINTF_UINTMAX_DEC_WIDTH
   5.160 + *       PRINTF_UINT64_DEC_WIDTH
   5.161 + *       PRINTF_UINT32_DEC_WIDTH
   5.162 + *       PRINTF_UINT16_DEC_WIDTH
   5.163 + *       PRINTF_UINT8_DEC_WIDTH
   5.164 + *
   5.165 + *       Which specifies the maximum number of characters required to
   5.166 + *       print the number of that type in either hexadecimal or decimal.
   5.167 + *       These are an extension beyond what C99 specifies must be in
   5.168 + *       stdint.h.
   5.169 + *
   5.170 + *  Compilers tested (all with 0 warnings at their highest respective
   5.171 + *  settings): Borland Turbo C 2.0, WATCOM C/C++ 11.0 (16 bits and 32
   5.172 + *  bits), Microsoft Visual C++ 6.0 (32 bit), Microsoft Visual Studio
   5.173 + *  .net (VC7), Intel C++ 4.0, GNU gcc v3.3.3
   5.174 + *
   5.175 + *  This file should be considered a work in progress.  Suggestions for
   5.176 + *  improvements, especially those which increase coverage are strongly
   5.177 + *  encouraged.
   5.178 + *
   5.179 + *  Acknowledgements
   5.180 + *
   5.181 + *  The following people have made significant contributions to the
   5.182 + *  development and testing of this file:
   5.183 + *
   5.184 + *  Chris Howie
   5.185 + *  John Steele Scott
   5.186 + *  Dave Thorup
   5.187 + *  John Dill
   5.188 + *  Florian Wobbe
   5.189 + *  Christopher Sean Morrison
   5.190 + *  Mikkel Fahnoe Jorgensen
   5.191 + *
   5.192 + */
   5.193 +
   5.194 +#include <stddef.h>
   5.195 +#include <limits.h>
   5.196 +#include <signal.h>
   5.197 +
   5.198 +/*
   5.199 + *  For gcc with _STDINT_H, fill in the PRINTF_INT*_MODIFIER macros, and
   5.200 + *  do nothing else.  On the Mac OS X version of gcc this is _STDINT_H_.
   5.201 + */
   5.202 +
   5.203 +#if ((defined(__SUNPRO_C) && __SUNPRO_C >= 0x570) || (defined(_MSC_VER) && _MSC_VER >= 1600) || (defined(__STDC__) && __STDC__ && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || (defined (__WATCOMC__) && (defined (_STDINT_H_INCLUDED) || __WATCOMC__ >= 1250)) || (defined(__GNUC__) && (__GNUC__ > 3 || defined(_STDINT_H) || defined(_STDINT_H_) || defined (__UINT_FAST64_TYPE__)) )) && !defined (_PSTDINT_H_INCLUDED)
   5.204 +#include <stdint.h>
   5.205 +#define _PSTDINT_H_INCLUDED
   5.206 +# if defined(__GNUC__) && (defined(__x86_64__) || defined(__ppc64__)) && !(defined(__APPLE__) && defined(__MACH__))
   5.207 +#  ifndef PRINTF_INT64_MODIFIER
   5.208 +#   define PRINTF_INT64_MODIFIER "l"
   5.209 +#  endif
   5.210 +#  ifndef PRINTF_INT32_MODIFIER
   5.211 +#   define PRINTF_INT32_MODIFIER ""
   5.212 +#  endif
   5.213 +# else
   5.214 +#  ifndef PRINTF_INT64_MODIFIER
   5.215 +#   define PRINTF_INT64_MODIFIER "ll"
   5.216 +#  endif
   5.217 +#  ifndef PRINTF_INT32_MODIFIER
   5.218 +#   if (UINT_MAX == UINT32_MAX)
   5.219 +#    define PRINTF_INT32_MODIFIER ""
   5.220 +#   else
   5.221 +#    define PRINTF_INT32_MODIFIER "l"
   5.222 +#   endif
   5.223 +#  endif
   5.224 +# endif
   5.225 +# ifndef PRINTF_INT16_MODIFIER
   5.226 +#  define PRINTF_INT16_MODIFIER "h"
   5.227 +# endif
   5.228 +# ifndef PRINTF_INTMAX_MODIFIER
   5.229 +#  define PRINTF_INTMAX_MODIFIER PRINTF_INT64_MODIFIER
   5.230 +# endif
   5.231 +# ifndef PRINTF_INT64_HEX_WIDTH
   5.232 +#  define PRINTF_INT64_HEX_WIDTH "16"
   5.233 +# endif
   5.234 +# ifndef PRINTF_UINT64_HEX_WIDTH
   5.235 +#  define PRINTF_UINT64_HEX_WIDTH "16"
   5.236 +# endif
   5.237 +# ifndef PRINTF_INT32_HEX_WIDTH
   5.238 +#  define PRINTF_INT32_HEX_WIDTH "8"
   5.239 +# endif
   5.240 +# ifndef PRINTF_UINT32_HEX_WIDTH
   5.241 +#  define PRINTF_UINT32_HEX_WIDTH "8"
   5.242 +# endif
   5.243 +# ifndef PRINTF_INT16_HEX_WIDTH
   5.244 +#  define PRINTF_INT16_HEX_WIDTH "4"
   5.245 +# endif
   5.246 +# ifndef PRINTF_UINT16_HEX_WIDTH
   5.247 +#  define PRINTF_UINT16_HEX_WIDTH "4"
   5.248 +# endif
   5.249 +# ifndef PRINTF_INT8_HEX_WIDTH
   5.250 +#  define PRINTF_INT8_HEX_WIDTH "2"
   5.251 +# endif
   5.252 +# ifndef PRINTF_UINT8_HEX_WIDTH
   5.253 +#  define PRINTF_UINT8_HEX_WIDTH "2"
   5.254 +# endif
   5.255 +# ifndef PRINTF_INT64_DEC_WIDTH
   5.256 +#  define PRINTF_INT64_DEC_WIDTH "19"
   5.257 +# endif
   5.258 +# ifndef PRINTF_UINT64_DEC_WIDTH
   5.259 +#  define PRINTF_UINT64_DEC_WIDTH "20"
   5.260 +# endif
   5.261 +# ifndef PRINTF_INT32_DEC_WIDTH
   5.262 +#  define PRINTF_INT32_DEC_WIDTH "10"
   5.263 +# endif
   5.264 +# ifndef PRINTF_UINT32_DEC_WIDTH
   5.265 +#  define PRINTF_UINT32_DEC_WIDTH "10"
   5.266 +# endif
   5.267 +# ifndef PRINTF_INT16_DEC_WIDTH
   5.268 +#  define PRINTF_INT16_DEC_WIDTH "5"
   5.269 +# endif
   5.270 +# ifndef PRINTF_UINT16_DEC_WIDTH
   5.271 +#  define PRINTF_UINT16_DEC_WIDTH "5"
   5.272 +# endif
   5.273 +# ifndef PRINTF_INT8_DEC_WIDTH
   5.274 +#  define PRINTF_INT8_DEC_WIDTH "3"
   5.275 +# endif
   5.276 +# ifndef PRINTF_UINT8_DEC_WIDTH
   5.277 +#  define PRINTF_UINT8_DEC_WIDTH "3"
   5.278 +# endif
   5.279 +# ifndef PRINTF_INTMAX_HEX_WIDTH
   5.280 +#  define PRINTF_INTMAX_HEX_WIDTH PRINTF_UINT64_HEX_WIDTH
   5.281 +# endif
   5.282 +# ifndef PRINTF_UINTMAX_HEX_WIDTH
   5.283 +#  define PRINTF_UINTMAX_HEX_WIDTH PRINTF_UINT64_HEX_WIDTH
   5.284 +# endif
   5.285 +# ifndef PRINTF_INTMAX_DEC_WIDTH
   5.286 +#  define PRINTF_INTMAX_DEC_WIDTH PRINTF_UINT64_DEC_WIDTH
   5.287 +# endif
   5.288 +# ifndef PRINTF_UINTMAX_DEC_WIDTH
   5.289 +#  define PRINTF_UINTMAX_DEC_WIDTH PRINTF_UINT64_DEC_WIDTH
   5.290 +# endif
   5.291 +
   5.292 +/*
   5.293 + *  Something really weird is going on with Open Watcom.  Just pull some of
   5.294 + *  these duplicated definitions from Open Watcom's stdint.h file for now.
   5.295 + */
   5.296 +
   5.297 +# if defined (__WATCOMC__) && __WATCOMC__ >= 1250
   5.298 +#  if !defined (INT64_C)
   5.299 +#   define INT64_C(x)   (x + (INT64_MAX - INT64_MAX))
   5.300 +#  endif
   5.301 +#  if !defined (UINT64_C)
   5.302 +#   define UINT64_C(x)  (x + (UINT64_MAX - UINT64_MAX))
   5.303 +#  endif
   5.304 +#  if !defined (INT32_C)
   5.305 +#   define INT32_C(x)   (x + (INT32_MAX - INT32_MAX))
   5.306 +#  endif
   5.307 +#  if !defined (UINT32_C)
   5.308 +#   define UINT32_C(x)  (x + (UINT32_MAX - UINT32_MAX))
   5.309 +#  endif
   5.310 +#  if !defined (INT16_C)
   5.311 +#   define INT16_C(x)   (x)
   5.312 +#  endif
   5.313 +#  if !defined (UINT16_C)
   5.314 +#   define UINT16_C(x)  (x)
   5.315 +#  endif
   5.316 +#  if !defined (INT8_C)
   5.317 +#   define INT8_C(x)   (x)
   5.318 +#  endif
   5.319 +#  if !defined (UINT8_C)
   5.320 +#   define UINT8_C(x)  (x)
   5.321 +#  endif
   5.322 +#  if !defined (UINT64_MAX)
   5.323 +#   define UINT64_MAX  18446744073709551615ULL
   5.324 +#  endif
   5.325 +#  if !defined (INT64_MAX)
   5.326 +#   define INT64_MAX  9223372036854775807LL
   5.327 +#  endif
   5.328 +#  if !defined (UINT32_MAX)
   5.329 +#   define UINT32_MAX  4294967295UL
   5.330 +#  endif
   5.331 +#  if !defined (INT32_MAX)
   5.332 +#   define INT32_MAX  2147483647L
   5.333 +#  endif
   5.334 +#  if !defined (INTMAX_MAX)
   5.335 +#   define INTMAX_MAX INT64_MAX
   5.336 +#  endif
   5.337 +#  if !defined (INTMAX_MIN)
   5.338 +#   define INTMAX_MIN INT64_MIN
   5.339 +#  endif
   5.340 +# endif
   5.341 +#endif
   5.342 +
   5.343 +/*
   5.344 + *  I have no idea what is the truly correct thing to do on older Solaris.
   5.345 + *  From some online discussions, this seems to be what is being
   5.346 + *  recommended.  For people who actually are developing on older Solaris,
   5.347 + *  what I would like to know is, does this define all of the relevant
   5.348 + *  macros of a complete stdint.h?  Remember, in pstdint.h 64 bit is
   5.349 + *  considered optional.
   5.350 + */
   5.351 +
   5.352 +#if (defined(__SUNPRO_C) && __SUNPRO_C >= 0x420) && !defined(_PSTDINT_H_INCLUDED)
   5.353 +#include <sys/inttypes.h>
   5.354 +#define _PSTDINT_H_INCLUDED
   5.355 +#endif
   5.356 +
   5.357 +#ifndef _PSTDINT_H_INCLUDED
   5.358 +#define _PSTDINT_H_INCLUDED
   5.359 +
   5.360 +#ifndef SIZE_MAX
   5.361 +# define SIZE_MAX (~(size_t)0)
   5.362 +#endif
   5.363 +
   5.364 +/*
   5.365 + *  Deduce the type assignments from limits.h under the assumption that
   5.366 + *  integer sizes in bits are powers of 2, and follow the ANSI
   5.367 + *  definitions.
   5.368 + */
   5.369 +
   5.370 +#ifndef UINT8_MAX
   5.371 +# define UINT8_MAX 0xff
   5.372 +#endif
   5.373 +#if !defined(uint8_t) && !defined(_UINT8_T) && !defined(vxWorks)
   5.374 +# if (UCHAR_MAX == UINT8_MAX) || defined (S_SPLINT_S)
   5.375 +    typedef unsigned char uint8_t;
   5.376 +#   define UINT8_C(v) ((uint8_t) v)
   5.377 +# else
   5.378 +#   error "Platform not supported"
   5.379 +# endif
   5.380 +#endif
   5.381 +
   5.382 +#ifndef INT8_MAX
   5.383 +# define INT8_MAX 0x7f
   5.384 +#endif
   5.385 +#ifndef INT8_MIN
   5.386 +# define INT8_MIN INT8_C(0x80)
   5.387 +#endif
   5.388 +#if !defined(int8_t) && !defined(_INT8_T) && !defined(vxWorks)
   5.389 +# if (SCHAR_MAX == INT8_MAX) || defined (S_SPLINT_S)
   5.390 +    typedef signed char int8_t;
   5.391 +#   define INT8_C(v) ((int8_t) v)
   5.392 +# else
   5.393 +#   error "Platform not supported"
   5.394 +# endif
   5.395 +#endif
   5.396 +
   5.397 +#ifndef UINT16_MAX
   5.398 +# define UINT16_MAX 0xffff
   5.399 +#endif
   5.400 +#if !defined(uint16_t) && !defined(_UINT16_T) && !defined(vxWorks)
   5.401 +#if (UINT_MAX == UINT16_MAX) || defined (S_SPLINT_S)
   5.402 +  typedef unsigned int uint16_t;
   5.403 +# ifndef PRINTF_INT16_MODIFIER
   5.404 +#  define PRINTF_INT16_MODIFIER ""
   5.405 +# endif
   5.406 +# define UINT16_C(v) ((uint16_t) (v))
   5.407 +#elif (USHRT_MAX == UINT16_MAX)
   5.408 +  typedef unsigned short uint16_t;
   5.409 +# define UINT16_C(v) ((uint16_t) (v))
   5.410 +# ifndef PRINTF_INT16_MODIFIER
   5.411 +#  define PRINTF_INT16_MODIFIER "h"
   5.412 +# endif
   5.413 +#else
   5.414 +#error "Platform not supported"
   5.415 +#endif
   5.416 +#endif
   5.417 +
   5.418 +#ifndef INT16_MAX
   5.419 +# define INT16_MAX 0x7fff
   5.420 +#endif
   5.421 +#ifndef INT16_MIN
   5.422 +# define INT16_MIN INT16_C(0x8000)
   5.423 +#endif
   5.424 +#if !defined(int16_t) && !defined(_INT16_T) && !defined(vxWorks)
   5.425 +#if (INT_MAX == INT16_MAX) || defined (S_SPLINT_S)
   5.426 +  typedef signed int int16_t;
   5.427 +# define INT16_C(v) ((int16_t) (v))
   5.428 +# ifndef PRINTF_INT16_MODIFIER
   5.429 +#  define PRINTF_INT16_MODIFIER ""
   5.430 +# endif
   5.431 +#elif (SHRT_MAX == INT16_MAX)
   5.432 +  typedef signed short int16_t;
   5.433 +# define INT16_C(v) ((int16_t) (v))
   5.434 +# ifndef PRINTF_INT16_MODIFIER
   5.435 +#  define PRINTF_INT16_MODIFIER "h"
   5.436 +# endif
   5.437 +#else
   5.438 +#error "Platform not supported"
   5.439 +#endif
   5.440 +#endif
   5.441 +
   5.442 +#ifndef UINT32_MAX
   5.443 +# define UINT32_MAX (0xffffffffUL)
   5.444 +#endif
   5.445 +#if !defined(uint32_t) && !defined(_UINT32_T) && !defined(vxWorks)
   5.446 +#if (ULONG_MAX == UINT32_MAX) || defined (S_SPLINT_S)
   5.447 +  typedef unsigned long uint32_t;
   5.448 +# define UINT32_C(v) v ## UL
   5.449 +# ifndef PRINTF_INT32_MODIFIER
   5.450 +#  define PRINTF_INT32_MODIFIER "l"
   5.451 +# endif
   5.452 +#elif (UINT_MAX == UINT32_MAX)
   5.453 +  typedef unsigned int uint32_t;
   5.454 +# ifndef PRINTF_INT32_MODIFIER
   5.455 +#  define PRINTF_INT32_MODIFIER ""
   5.456 +# endif
   5.457 +# define UINT32_C(v) v ## U
   5.458 +#elif (USHRT_MAX == UINT32_MAX)
   5.459 +  typedef unsigned short uint32_t;
   5.460 +# define UINT32_C(v) ((unsigned short) (v))
   5.461 +# ifndef PRINTF_INT32_MODIFIER
   5.462 +#  define PRINTF_INT32_MODIFIER ""
   5.463 +# endif
   5.464 +#else
   5.465 +#error "Platform not supported"
   5.466 +#endif
   5.467 +#endif
   5.468 +
   5.469 +#ifndef INT32_MAX
   5.470 +# define INT32_MAX (0x7fffffffL)
   5.471 +#endif
   5.472 +#ifndef INT32_MIN
   5.473 +# define INT32_MIN INT32_C(0x80000000)
   5.474 +#endif
   5.475 +#if !defined(int32_t) && !defined(_INT32_T) && !defined(vxWorks)
   5.476 +#if (LONG_MAX == INT32_MAX) || defined (S_SPLINT_S)
   5.477 +  typedef signed long int32_t;
   5.478 +# define INT32_C(v) v ## L
   5.479 +# ifndef PRINTF_INT32_MODIFIER
   5.480 +#  define PRINTF_INT32_MODIFIER "l"
   5.481 +# endif
   5.482 +#elif (INT_MAX == INT32_MAX)
   5.483 +  typedef signed int int32_t;
   5.484 +# define INT32_C(v) v
   5.485 +# ifndef PRINTF_INT32_MODIFIER
   5.486 +#  define PRINTF_INT32_MODIFIER ""
   5.487 +# endif
   5.488 +#elif (SHRT_MAX == INT32_MAX)
   5.489 +  typedef signed short int32_t;
   5.490 +# define INT32_C(v) ((short) (v))
   5.491 +# ifndef PRINTF_INT32_MODIFIER
   5.492 +#  define PRINTF_INT32_MODIFIER ""
   5.493 +# endif
   5.494 +#else
   5.495 +#error "Platform not supported"
   5.496 +#endif
   5.497 +#endif
   5.498 +
   5.499 +/*
   5.500 + *  The macro stdint_int64_defined is temporarily used to record
   5.501 + *  whether or not 64 integer support is available.  It must be
   5.502 + *  defined for any 64 integer extensions for new platforms that are
   5.503 + *  added.
   5.504 + */
   5.505 +
   5.506 +#undef stdint_int64_defined
   5.507 +#if (defined(__STDC__) && defined(__STDC_VERSION__)) || defined (S_SPLINT_S)
   5.508 +# if (__STDC__ && __STDC_VERSION__ >= 199901L) || defined (S_SPLINT_S)
   5.509 +#  define stdint_int64_defined
   5.510 +   typedef long long int64_t;
   5.511 +   typedef unsigned long long uint64_t;
   5.512 +#  define UINT64_C(v) v ## ULL
   5.513 +#  define  INT64_C(v) v ## LL
   5.514 +#  ifndef PRINTF_INT64_MODIFIER
   5.515 +#   define PRINTF_INT64_MODIFIER "ll"
   5.516 +#  endif
   5.517 +# endif
   5.518 +#endif
   5.519 +
   5.520 +#if !defined (stdint_int64_defined)
   5.521 +# if defined(__GNUC__) && !defined(vxWorks)
   5.522 +#  define stdint_int64_defined
   5.523 +   __extension__ typedef long long int64_t;
   5.524 +   __extension__ typedef unsigned long long uint64_t;
   5.525 +#  define UINT64_C(v) v ## ULL
   5.526 +#  define  INT64_C(v) v ## LL
   5.527 +#  ifndef PRINTF_INT64_MODIFIER
   5.528 +#   define PRINTF_INT64_MODIFIER "ll"
   5.529 +#  endif
   5.530 +# elif defined(__MWERKS__) || defined (__SUNPRO_C) || defined (__SUNPRO_CC) || defined (__APPLE_CC__) || defined (_LONG_LONG) || defined (_CRAYC) || defined (S_SPLINT_S)
   5.531 +#  define stdint_int64_defined
   5.532 +   typedef long long int64_t;
   5.533 +   typedef unsigned long long uint64_t;
   5.534 +#  define UINT64_C(v) v ## ULL
   5.535 +#  define  INT64_C(v) v ## LL
   5.536 +#  ifndef PRINTF_INT64_MODIFIER
   5.537 +#   define PRINTF_INT64_MODIFIER "ll"
   5.538 +#  endif
   5.539 +# elif (defined(__WATCOMC__) && defined(__WATCOM_INT64__)) || (defined(_MSC_VER) && _INTEGRAL_MAX_BITS >= 64) || (defined (__BORLANDC__) && __BORLANDC__ > 0x460) || defined (__alpha) || defined (__DECC)
   5.540 +#  define stdint_int64_defined
   5.541 +   typedef __int64 int64_t;
   5.542 +   typedef unsigned __int64 uint64_t;
   5.543 +#  define UINT64_C(v) v ## UI64
   5.544 +#  define  INT64_C(v) v ## I64
   5.545 +#  ifndef PRINTF_INT64_MODIFIER
   5.546 +#   define PRINTF_INT64_MODIFIER "I64"
   5.547 +#  endif
   5.548 +# endif
   5.549 +#endif
   5.550 +
   5.551 +#if !defined (LONG_LONG_MAX) && defined (INT64_C)
   5.552 +# define LONG_LONG_MAX INT64_C (9223372036854775807)
   5.553 +#endif
   5.554 +#ifndef ULONG_LONG_MAX
   5.555 +# define ULONG_LONG_MAX UINT64_C (18446744073709551615)
   5.556 +#endif
   5.557 +
   5.558 +#if !defined (INT64_MAX) && defined (INT64_C)
   5.559 +# define INT64_MAX INT64_C (9223372036854775807)
   5.560 +#endif
   5.561 +#if !defined (INT64_MIN) && defined (INT64_C)
   5.562 +# define INT64_MIN INT64_C (-9223372036854775808)
   5.563 +#endif
   5.564 +#if !defined (UINT64_MAX) && defined (INT64_C)
   5.565 +# define UINT64_MAX UINT64_C (18446744073709551615)
   5.566 +#endif
   5.567 +
   5.568 +/*
   5.569 + *  Width of hexadecimal for number field.
   5.570 + */
   5.571 +
   5.572 +#ifndef PRINTF_INT64_HEX_WIDTH
   5.573 +# define PRINTF_INT64_HEX_WIDTH "16"
   5.574 +#endif
   5.575 +#ifndef PRINTF_INT32_HEX_WIDTH
   5.576 +# define PRINTF_INT32_HEX_WIDTH "8"
   5.577 +#endif
   5.578 +#ifndef PRINTF_INT16_HEX_WIDTH
   5.579 +# define PRINTF_INT16_HEX_WIDTH "4"
   5.580 +#endif
   5.581 +#ifndef PRINTF_INT8_HEX_WIDTH
   5.582 +# define PRINTF_INT8_HEX_WIDTH "2"
   5.583 +#endif
   5.584 +#ifndef PRINTF_INT64_DEC_WIDTH
   5.585 +# define PRINTF_INT64_DEC_WIDTH "19"
   5.586 +#endif
   5.587 +#ifndef PRINTF_INT32_DEC_WIDTH
   5.588 +# define PRINTF_INT32_DEC_WIDTH "10"
   5.589 +#endif
   5.590 +#ifndef PRINTF_INT16_DEC_WIDTH
   5.591 +# define PRINTF_INT16_DEC_WIDTH "5"
   5.592 +#endif
   5.593 +#ifndef PRINTF_INT8_DEC_WIDTH
   5.594 +# define PRINTF_INT8_DEC_WIDTH "3"
   5.595 +#endif
   5.596 +#ifndef PRINTF_UINT64_DEC_WIDTH
   5.597 +# define PRINTF_UINT64_DEC_WIDTH "20"
   5.598 +#endif
   5.599 +#ifndef PRINTF_UINT32_DEC_WIDTH
   5.600 +# define PRINTF_UINT32_DEC_WIDTH "10"
   5.601 +#endif
   5.602 +#ifndef PRINTF_UINT16_DEC_WIDTH
   5.603 +# define PRINTF_UINT16_DEC_WIDTH "5"
   5.604 +#endif
   5.605 +#ifndef PRINTF_UINT8_DEC_WIDTH
   5.606 +# define PRINTF_UINT8_DEC_WIDTH "3"
   5.607 +#endif
   5.608 +
   5.609 +/*
   5.610 + *  Ok, lets not worry about 128 bit integers for now.  Moore's law says
   5.611 + *  we don't need to worry about that until about 2040 at which point
   5.612 + *  we'll have bigger things to worry about.
   5.613 + */
   5.614 +
   5.615 +#ifdef stdint_int64_defined
   5.616 +  typedef int64_t intmax_t;
   5.617 +  typedef uint64_t uintmax_t;
   5.618 +# define  INTMAX_MAX   INT64_MAX
   5.619 +# define  INTMAX_MIN   INT64_MIN
   5.620 +# define UINTMAX_MAX  UINT64_MAX
   5.621 +# define UINTMAX_C(v) UINT64_C(v)
   5.622 +# define  INTMAX_C(v)  INT64_C(v)
   5.623 +# ifndef PRINTF_INTMAX_MODIFIER
   5.624 +#   define PRINTF_INTMAX_MODIFIER PRINTF_INT64_MODIFIER
   5.625 +# endif
   5.626 +# ifndef PRINTF_INTMAX_HEX_WIDTH
   5.627 +#  define PRINTF_INTMAX_HEX_WIDTH PRINTF_INT64_HEX_WIDTH
   5.628 +# endif
   5.629 +# ifndef PRINTF_INTMAX_DEC_WIDTH
   5.630 +#  define PRINTF_INTMAX_DEC_WIDTH PRINTF_INT64_DEC_WIDTH
   5.631 +# endif
   5.632 +#else
   5.633 +  typedef int32_t intmax_t;
   5.634 +  typedef uint32_t uintmax_t;
   5.635 +# define  INTMAX_MAX   INT32_MAX
   5.636 +# define UINTMAX_MAX  UINT32_MAX
   5.637 +# define UINTMAX_C(v) UINT32_C(v)
   5.638 +# define  INTMAX_C(v)  INT32_C(v)
   5.639 +# ifndef PRINTF_INTMAX_MODIFIER
   5.640 +#   define PRINTF_INTMAX_MODIFIER PRINTF_INT32_MODIFIER
   5.641 +# endif
   5.642 +# ifndef PRINTF_INTMAX_HEX_WIDTH
   5.643 +#  define PRINTF_INTMAX_HEX_WIDTH PRINTF_INT32_HEX_WIDTH
   5.644 +# endif
   5.645 +# ifndef PRINTF_INTMAX_DEC_WIDTH
   5.646 +#  define PRINTF_INTMAX_DEC_WIDTH PRINTF_INT32_DEC_WIDTH
   5.647 +# endif
   5.648 +#endif
   5.649 +
   5.650 +/*
   5.651 + *  Because this file currently only supports platforms which have
   5.652 + *  precise powers of 2 as bit sizes for the default integers, the
   5.653 + *  least definitions are all trivial.  Its possible that a future
   5.654 + *  version of this file could have different definitions.
   5.655 + */
   5.656 +
   5.657 +#ifndef stdint_least_defined
   5.658 +  typedef   int8_t   int_least8_t;
   5.659 +  typedef  uint8_t  uint_least8_t;
   5.660 +  typedef  int16_t  int_least16_t;
   5.661 +  typedef uint16_t uint_least16_t;
   5.662 +  typedef  int32_t  int_least32_t;
   5.663 +  typedef uint32_t uint_least32_t;
   5.664 +# define PRINTF_LEAST32_MODIFIER PRINTF_INT32_MODIFIER
   5.665 +# define PRINTF_LEAST16_MODIFIER PRINTF_INT16_MODIFIER
   5.666 +# define  UINT_LEAST8_MAX  UINT8_MAX
   5.667 +# define   INT_LEAST8_MAX   INT8_MAX
   5.668 +# define UINT_LEAST16_MAX UINT16_MAX
   5.669 +# define  INT_LEAST16_MAX  INT16_MAX
   5.670 +# define UINT_LEAST32_MAX UINT32_MAX
   5.671 +# define  INT_LEAST32_MAX  INT32_MAX
   5.672 +# define   INT_LEAST8_MIN   INT8_MIN
   5.673 +# define  INT_LEAST16_MIN  INT16_MIN
   5.674 +# define  INT_LEAST32_MIN  INT32_MIN
   5.675 +# ifdef stdint_int64_defined
   5.676 +    typedef  int64_t  int_least64_t;
   5.677 +    typedef uint64_t uint_least64_t;
   5.678 +#   define PRINTF_LEAST64_MODIFIER PRINTF_INT64_MODIFIER
   5.679 +#   define UINT_LEAST64_MAX UINT64_MAX
   5.680 +#   define  INT_LEAST64_MAX  INT64_MAX
   5.681 +#   define  INT_LEAST64_MIN  INT64_MIN
   5.682 +# endif
   5.683 +#endif
   5.684 +#undef stdint_least_defined
   5.685 +
   5.686 +/*
   5.687 + *  The ANSI C committee pretending to know or specify anything about
   5.688 + *  performance is the epitome of misguided arrogance.  The mandate of
   5.689 + *  this file is to *ONLY* ever support that absolute minimum
   5.690 + *  definition of the fast integer types, for compatibility purposes.
   5.691 + *  No extensions, and no attempt to suggest what may or may not be a
   5.692 + *  faster integer type will ever be made in this file.  Developers are
   5.693 + *  warned to stay away from these types when using this or any other
   5.694 + *  stdint.h.
   5.695 + */
   5.696 +
   5.697 +typedef   int_least8_t   int_fast8_t;
   5.698 +typedef  uint_least8_t  uint_fast8_t;
   5.699 +typedef  int_least16_t  int_fast16_t;
   5.700 +typedef uint_least16_t uint_fast16_t;
   5.701 +typedef  int_least32_t  int_fast32_t;
   5.702 +typedef uint_least32_t uint_fast32_t;
   5.703 +#define  UINT_FAST8_MAX  UINT_LEAST8_MAX
   5.704 +#define   INT_FAST8_MAX   INT_LEAST8_MAX
   5.705 +#define UINT_FAST16_MAX UINT_LEAST16_MAX
   5.706 +#define  INT_FAST16_MAX  INT_LEAST16_MAX
   5.707 +#define UINT_FAST32_MAX UINT_LEAST32_MAX
   5.708 +#define  INT_FAST32_MAX  INT_LEAST32_MAX
   5.709 +#define   INT_FAST8_MIN   INT_LEAST8_MIN
   5.710 +#define  INT_FAST16_MIN  INT_LEAST16_MIN
   5.711 +#define  INT_FAST32_MIN  INT_LEAST32_MIN
   5.712 +#ifdef stdint_int64_defined
   5.713 +  typedef  int_least64_t  int_fast64_t;
   5.714 +  typedef uint_least64_t uint_fast64_t;
   5.715 +# define UINT_FAST64_MAX UINT_LEAST64_MAX
   5.716 +# define  INT_FAST64_MAX  INT_LEAST64_MAX
   5.717 +# define  INT_FAST64_MIN  INT_LEAST64_MIN
   5.718 +#endif
   5.719 +
   5.720 +#undef stdint_int64_defined
   5.721 +
   5.722 +/*
   5.723 + *  Whatever piecemeal, per compiler thing we can do about the wchar_t
   5.724 + *  type limits.
   5.725 + */
   5.726 +
   5.727 +#if defined(__WATCOMC__) || defined(_MSC_VER) || defined (__GNUC__) && !defined(vxWorks)
   5.728 +# include <wchar.h>
   5.729 +# ifndef WCHAR_MIN
   5.730 +#  define WCHAR_MIN 0
   5.731 +# endif
   5.732 +# ifndef WCHAR_MAX
   5.733 +#  define WCHAR_MAX ((wchar_t)-1)
   5.734 +# endif
   5.735 +#endif
   5.736 +
   5.737 +/*
   5.738 + *  Whatever piecemeal, per compiler/platform thing we can do about the
   5.739 + *  (u)intptr_t types and limits.
   5.740 + */
   5.741 +
   5.742 +#if (defined (_MSC_VER) && defined (_UINTPTR_T_DEFINED)) || defined (_UINTPTR_T)
   5.743 +# define STDINT_H_UINTPTR_T_DEFINED
   5.744 +#endif
   5.745 +
   5.746 +#ifndef STDINT_H_UINTPTR_T_DEFINED
   5.747 +# if defined (__alpha__) || defined (__ia64__) || defined (__x86_64__) || defined (_WIN64) || defined (__ppc64__)
   5.748 +#  define stdint_intptr_bits 64
   5.749 +# elif defined (__WATCOMC__) || defined (__TURBOC__)
   5.750 +#  if defined(__TINY__) || defined(__SMALL__) || defined(__MEDIUM__)
   5.751 +#    define stdint_intptr_bits 16
   5.752 +#  else
   5.753 +#    define stdint_intptr_bits 32
   5.754 +#  endif
   5.755 +# elif defined (__i386__) || defined (_WIN32) || defined (WIN32) || defined (__ppc64__)
   5.756 +#  define stdint_intptr_bits 32
   5.757 +# elif defined (__INTEL_COMPILER)
   5.758 +/* TODO -- what did Intel do about x86-64? */
   5.759 +# else
   5.760 +/* #error "This platform might not be supported yet" */
   5.761 +# endif
   5.762 +
   5.763 +# ifdef stdint_intptr_bits
   5.764 +#  define stdint_intptr_glue3_i(a,b,c)  a##b##c
   5.765 +#  define stdint_intptr_glue3(a,b,c)    stdint_intptr_glue3_i(a,b,c)
   5.766 +#  ifndef PRINTF_INTPTR_MODIFIER
   5.767 +#    define PRINTF_INTPTR_MODIFIER      stdint_intptr_glue3(PRINTF_INT,stdint_intptr_bits,_MODIFIER)
   5.768 +#  endif
   5.769 +#  ifndef PTRDIFF_MAX
   5.770 +#    define PTRDIFF_MAX                 stdint_intptr_glue3(INT,stdint_intptr_bits,_MAX)
   5.771 +#  endif
   5.772 +#  ifndef PTRDIFF_MIN
   5.773 +#    define PTRDIFF_MIN                 stdint_intptr_glue3(INT,stdint_intptr_bits,_MIN)
   5.774 +#  endif
   5.775 +#  ifndef UINTPTR_MAX
   5.776 +#    define UINTPTR_MAX                 stdint_intptr_glue3(UINT,stdint_intptr_bits,_MAX)
   5.777 +#  endif
   5.778 +#  ifndef INTPTR_MAX
   5.779 +#    define INTPTR_MAX                  stdint_intptr_glue3(INT,stdint_intptr_bits,_MAX)
   5.780 +#  endif
   5.781 +#  ifndef INTPTR_MIN
   5.782 +#    define INTPTR_MIN                  stdint_intptr_glue3(INT,stdint_intptr_bits,_MIN)
   5.783 +#  endif
   5.784 +#  ifndef INTPTR_C
   5.785 +#    define INTPTR_C(x)                 stdint_intptr_glue3(INT,stdint_intptr_bits,_C)(x)
   5.786 +#  endif
   5.787 +#  ifndef UINTPTR_C
   5.788 +#    define UINTPTR_C(x)                stdint_intptr_glue3(UINT,stdint_intptr_bits,_C)(x)
   5.789 +#  endif
   5.790 +  typedef stdint_intptr_glue3(uint,stdint_intptr_bits,_t) uintptr_t;
   5.791 +  typedef stdint_intptr_glue3( int,stdint_intptr_bits,_t)  intptr_t;
   5.792 +# else
   5.793 +/* TODO -- This following is likely wrong for some platforms, and does
   5.794 +   nothing for the definition of uintptr_t. */
   5.795 +  typedef ptrdiff_t intptr_t;
   5.796 +# endif
   5.797 +# define STDINT_H_UINTPTR_T_DEFINED
   5.798 +#endif
   5.799 +
   5.800 +/*
   5.801 + *  Assumes sig_atomic_t is signed and we have a 2s complement machine.
   5.802 + */
   5.803 +
   5.804 +#ifndef SIG_ATOMIC_MAX
   5.805 +# define SIG_ATOMIC_MAX ((((sig_atomic_t) 1) << (sizeof (sig_atomic_t)*CHAR_BIT-1)) - 1)
   5.806 +#endif
   5.807 +
   5.808 +#endif
   5.809 +
   5.810 +#if defined (__TEST_PSTDINT_FOR_CORRECTNESS)
   5.811 +
   5.812 +/*
   5.813 + *  Please compile with the maximum warning settings to make sure macros are
   5.814 + *  not defined more than once.
   5.815 + */
   5.816 +
   5.817 +#include <stdlib.h>
   5.818 +#include <stdio.h>
   5.819 +#include <string.h>
   5.820 +
   5.821 +#define glue3_aux(x,y,z) x ## y ## z
   5.822 +#define glue3(x,y,z) glue3_aux(x,y,z)
   5.823 +
   5.824 +#define DECLU(bits) glue3(uint,bits,_t) glue3(u,bits,) = glue3(UINT,bits,_C) (0);
   5.825 +#define DECLI(bits) glue3(int,bits,_t) glue3(i,bits,) = glue3(INT,bits,_C) (0);
   5.826 +
   5.827 +#define DECL(us,bits) glue3(DECL,us,) (bits)
   5.828 +
   5.829 +#define TESTUMAX(bits) glue3(u,bits,) = ~glue3(u,bits,); if (glue3(UINT,bits,_MAX) != glue3(u,bits,)) printf ("Something wrong with UINT%d_MAX\n", bits)
   5.830 +
   5.831 +#define REPORTERROR(msg) { err_n++; if (err_first <= 0) err_first = __LINE__; printf msg; }
   5.832 +
   5.833 +int main () {
   5.834 +	int err_n = 0;
   5.835 +	int err_first = 0;
   5.836 +	DECL(I,8)
   5.837 +	DECL(U,8)
   5.838 +	DECL(I,16)
   5.839 +	DECL(U,16)
   5.840 +	DECL(I,32)
   5.841 +	DECL(U,32)
   5.842 +#ifdef INT64_MAX
   5.843 +	DECL(I,64)
   5.844 +	DECL(U,64)
   5.845 +#endif
   5.846 +	intmax_t imax = INTMAX_C(0);
   5.847 +	uintmax_t umax = UINTMAX_C(0);
   5.848 +	char str0[256], str1[256];
   5.849 +
   5.850 +	sprintf (str0, "%" PRINTF_INT32_MODIFIER "d", INT32_C(2147483647));
   5.851 +	if (0 != strcmp (str0, "2147483647")) REPORTERROR (("Something wrong with PRINTF_INT32_MODIFIER : %s\n", str0));
   5.852 +	if (atoi(PRINTF_INT32_DEC_WIDTH) != (int) strlen(str0)) REPORTERROR (("Something wrong with PRINTF_INT32_DEC_WIDTH : %s\n", PRINTF_INT32_DEC_WIDTH));
   5.853 +	sprintf (str0, "%" PRINTF_INT32_MODIFIER "u", UINT32_C(4294967295));
   5.854 +	if (0 != strcmp (str0, "4294967295")) REPORTERROR (("Something wrong with PRINTF_INT32_MODIFIER : %s\n", str0));
   5.855 +	if (atoi(PRINTF_UINT32_DEC_WIDTH) != (int) strlen(str0)) REPORTERROR (("Something wrong with PRINTF_UINT32_DEC_WIDTH : %s\n", PRINTF_UINT32_DEC_WIDTH));
   5.856 +#ifdef INT64_MAX
   5.857 +	sprintf (str1, "%" PRINTF_INT64_MODIFIER "d", INT64_C(9223372036854775807));
   5.858 +	if (0 != strcmp (str1, "9223372036854775807")) REPORTERROR (("Something wrong with PRINTF_INT32_MODIFIER : %s\n", str1));
   5.859 +	if (atoi(PRINTF_INT64_DEC_WIDTH) != (int) strlen(str1)) REPORTERROR (("Something wrong with PRINTF_INT64_DEC_WIDTH : %s, %d\n", PRINTF_INT64_DEC_WIDTH, (int) strlen(str1)));
   5.860 +	sprintf (str1, "%" PRINTF_INT64_MODIFIER "u", UINT64_C(18446744073709550591));
   5.861 +	if (0 != strcmp (str1, "18446744073709550591")) REPORTERROR (("Something wrong with PRINTF_INT32_MODIFIER : %s\n", str1));
   5.862 +	if (atoi(PRINTF_UINT64_DEC_WIDTH) != (int) strlen(str1)) REPORTERROR (("Something wrong with PRINTF_UINT64_DEC_WIDTH : %s, %d\n", PRINTF_UINT64_DEC_WIDTH, (int) strlen(str1)));
   5.863 +#endif
   5.864 +
   5.865 +	sprintf (str0, "%d %x\n", 0, ~0);
   5.866 +
   5.867 +	sprintf (str1, "%d %x\n",  i8, ~0);
   5.868 +	if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with i8 : %s\n", str1));
   5.869 +	sprintf (str1, "%u %x\n",  u8, ~0);
   5.870 +	if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with u8 : %s\n", str1));
   5.871 +	sprintf (str1, "%d %x\n",  i16, ~0);
   5.872 +	if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with i16 : %s\n", str1));
   5.873 +	sprintf (str1, "%u %x\n",  u16, ~0);
   5.874 +	if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with u16 : %s\n", str1));
   5.875 +	sprintf (str1, "%" PRINTF_INT32_MODIFIER "d %x\n",  i32, ~0);
   5.876 +	if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with i32 : %s\n", str1));
   5.877 +	sprintf (str1, "%" PRINTF_INT32_MODIFIER "u %x\n",  u32, ~0);
   5.878 +	if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with u32 : %s\n", str1));
   5.879 +#ifdef INT64_MAX
   5.880 +	sprintf (str1, "%" PRINTF_INT64_MODIFIER "d %x\n",  i64, ~0);
   5.881 +	if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with i64 : %s\n", str1));
   5.882 +#endif
   5.883 +	sprintf (str1, "%" PRINTF_INTMAX_MODIFIER "d %x\n",  imax, ~0);
   5.884 +	if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with imax : %s\n", str1));
   5.885 +	sprintf (str1, "%" PRINTF_INTMAX_MODIFIER "u %x\n",  umax, ~0);
   5.886 +	if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with umax : %s\n", str1));
   5.887 +
   5.888 +	TESTUMAX(8);
   5.889 +	TESTUMAX(16);
   5.890 +	TESTUMAX(32);
   5.891 +#ifdef INT64_MAX
   5.892 +	TESTUMAX(64);
   5.893 +#endif
   5.894 +
   5.895 +#define STR(v) #v
   5.896 +#define Q(v) printf ("sizeof " STR(v) " = %u\n", (unsigned) sizeof (v));
   5.897 +	if (err_n) {
   5.898 +		printf ("pstdint.h is not correct.  Please use sizes below to correct it:\n");
   5.899 +	}
   5.900 +
   5.901 +	Q(int)
   5.902 +	Q(unsigned)
   5.903 +	Q(long int)
   5.904 +	Q(short int)
   5.905 +	Q(int8_t)
   5.906 +	Q(int16_t)
   5.907 +	Q(int32_t)
   5.908 +#ifdef INT64_MAX
   5.909 +	Q(int64_t)
   5.910 +#endif
   5.911 +
   5.912 +	return EXIT_SUCCESS;
   5.913 +}
   5.914 +
   5.915 +#endif

     6.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.2 +++ b/include/miniassimp/Compiler/pushpack1.h	Mon Jan 28 18:19:26 2019 +0200
     6.3 @@ -0,0 +1,43 @@
     6.4 +
     6.5 +
     6.6 +// ===============================================================================
     6.7 +// May be included multiple times - sets structure packing to 1 
     6.8 +// for all supported compilers. #include <poppack1.h> reverts the changes.
     6.9 +//
    6.10 +// Currently this works on the following compilers:
    6.11 +// MSVC 7,8,9
    6.12 +// GCC
    6.13 +// BORLAND (complains about 'pack state changed but not reverted', but works)
    6.14 +// Clang
    6.15 +//
    6.16 +//
    6.17 +// USAGE:
    6.18 +//
    6.19 +// struct StructToBePacked {
    6.20 +// } PACK_STRUCT;
    6.21 +//
    6.22 +// ===============================================================================
    6.23 +
    6.24 +#ifdef AI_PUSHPACK_IS_DEFINED
    6.25 +#	error poppack1.h must be included after pushpack1.h
    6.26 +#endif
    6.27 +
    6.28 +#if defined(_MSC_VER) ||  defined(__BORLANDC__) ||	defined (__BCPLUSPLUS__)
    6.29 +#	pragma pack(push,1)
    6.30 +#	define PACK_STRUCT
    6.31 +#elif defined( __GNUC__ ) || defined(__clang__)
    6.32 +#	if !defined(HOST_MINGW)
    6.33 +#		define PACK_STRUCT	__attribute__((__packed__))
    6.34 +#	else
    6.35 +#		define PACK_STRUCT	__attribute__((gcc_struct, __packed__))
    6.36 +#	endif
    6.37 +#else
    6.38 +#	error Compiler not supported
    6.39 +#endif
    6.40 +
    6.41 +#if defined(_MSC_VER)
    6.42 +// C4103: Packing was changed after the inclusion of the header, probably missing #pragma pop
    6.43 +#	pragma warning (disable : 4103) 
    6.44 +#endif
    6.45 +
    6.46 +#define AI_PUSHPACK_IS_DEFINED

     7.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.2 +++ b/include/miniassimp/DefaultIOStream.h	Mon Jan 28 18:19:26 2019 +0200
     7.3 @@ -0,0 +1,140 @@
     7.4 +/*
     7.5 +Open Asset Import Library (assimp)
     7.6 +----------------------------------------------------------------------
     7.7 +
     7.8 +Copyright (c) 2006-2018, assimp team
     7.9 +
    7.10 +
    7.11 +All rights reserved.
    7.12 +
    7.13 +Redistribution and use of this software in source and binary forms,
    7.14 +with or without modification, are permitted provided that the
    7.15 +following conditions are met:
    7.16 +
    7.17 +* Redistributions of source code must retain the above
    7.18 +  copyright notice, this list of conditions and the
    7.19 +  following disclaimer.
    7.20 +
    7.21 +* Redistributions in binary form must reproduce the above
    7.22 +  copyright notice, this list of conditions and the
    7.23 +  following disclaimer in the documentation and/or other
    7.24 +  materials provided with the distribution.
    7.25 +
    7.26 +* Neither the name of the assimp team, nor the names of its
    7.27 +  contributors may be used to endorse or promote products
    7.28 +  derived from this software without specific prior
    7.29 +  written permission of the assimp team.
    7.30 +
    7.31 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    7.32 +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    7.33 +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    7.34 +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
    7.35 +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    7.36 +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    7.37 +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    7.38 +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    7.39 +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    7.40 +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    7.41 +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    7.42 +
    7.43 +----------------------------------------------------------------------
    7.44 +*/
    7.45 +
    7.46 +/** @file Default file I/O using fXXX()-family of functions */
    7.47 +#ifndef AI_DEFAULTIOSTREAM_H_INC
    7.48 +#define AI_DEFAULTIOSTREAM_H_INC
    7.49 +
    7.50 +#include <stdio.h>
    7.51 +#include <miniassimp/IOStream.hpp>
    7.52 +#include <miniassimp/importerdesc.h>
    7.53 +#include <miniassimp/Defines.h>
    7.54 +
    7.55 +namespace Assimp    {
    7.56 +
    7.57 +// ----------------------------------------------------------------------------------
    7.58 +//! @class  DefaultIOStream
    7.59 +//! @brief  Default IO implementation, use standard IO operations
    7.60 +//! @note   An instance of this class can exist without a valid file handle
    7.61 +//!         attached to it. All calls fail, but the instance can nevertheless be
    7.62 +//!         used with no restrictions.
    7.63 +class ASSIMP_API DefaultIOStream : public IOStream
    7.64 +{
    7.65 +    friend class DefaultIOSystem;
    7.66 +#if __ANDROID__
    7.67 +# if __ANDROID_API__ > 9
    7.68 +#  if defined(AI_CONFIG_ANDROID_JNI_ASSIMP_MANAGER_SUPPORT)
    7.69 +    friend class AndroidJNIIOSystem;
    7.70 +#  endif // defined(AI_CONFIG_ANDROID_JNI_ASSIMP_MANAGER_SUPPORT)
    7.71 +# endif // __ANDROID_API__ > 9
    7.72 +#endif // __ANDROID__
    7.73 +
    7.74 +protected:
    7.75 +    DefaultIOStream() AI_NO_EXCEPT;
    7.76 +    DefaultIOStream(FILE* pFile, const std::string &strFilename);
    7.77 +
    7.78 +public:
    7.79 +    /** Destructor public to allow simple deletion to close the file. */
    7.80 +    ~DefaultIOStream ();
    7.81 +
    7.82 +    // -------------------------------------------------------------------
    7.83 +    /// Read from stream
    7.84 +    size_t Read(void* pvBuffer,
    7.85 +        size_t pSize,
    7.86 +        size_t pCount);
    7.87 +
    7.88 +
    7.89 +    // -------------------------------------------------------------------
    7.90 +    /// Write to stream
    7.91 +    size_t Write(const void* pvBuffer,
    7.92 +        size_t pSize,
    7.93 +        size_t pCount);
    7.94 +
    7.95 +    // -------------------------------------------------------------------
    7.96 +    /// Seek specific position
    7.97 +    aiReturn Seek(size_t pOffset,
    7.98 +        aiOrigin pOrigin);
    7.99 +
   7.100 +    // -------------------------------------------------------------------
   7.101 +    /// Get current seek position
   7.102 +    size_t Tell() const;
   7.103 +
   7.104 +    // -------------------------------------------------------------------
   7.105 +    /// Get size of file
   7.106 +    size_t FileSize() const;
   7.107 +
   7.108 +    // -------------------------------------------------------------------
   7.109 +    /// Flush file contents
   7.110 +    void Flush();
   7.111 +
   7.112 +private:
   7.113 +    //  File data-structure, using clib
   7.114 +    FILE* mFile;
   7.115 +    //  Filename
   7.116 +    std::string mFilename;
   7.117 +    // Cached file size
   7.118 +    mutable size_t mCachedSize;
   7.119 +};
   7.120 +
   7.121 +// ----------------------------------------------------------------------------------
   7.122 +inline
   7.123 +DefaultIOStream::DefaultIOStream() AI_NO_EXCEPT
   7.124 +: mFile(0)
   7.125 +, mFilename("")
   7.126 +, mCachedSize(SIZE_MAX) {
   7.127 +    // empty
   7.128 +}
   7.129 +
   7.130 +// ----------------------------------------------------------------------------------
   7.131 +inline
   7.132 +DefaultIOStream::DefaultIOStream (FILE* pFile, const std::string &strFilename)
   7.133 +: mFile(pFile)
   7.134 +, mFilename(strFilename)
   7.135 +, mCachedSize(SIZE_MAX) {
   7.136 +    // empty
   7.137 +}
   7.138 +// ----------------------------------------------------------------------------------
   7.139 +
   7.140 +} // ns assimp
   7.141 +
   7.142 +#endif //!!AI_DEFAULTIOSTREAM_H_INC
   7.143 +

     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/include/miniassimp/DefaultLogger.hpp	Mon Jan 28 18:19:26 2019 +0200
     8.3 @@ -0,0 +1,188 @@
     8.4 +/*
     8.5 +Open Asset Import Library (assimp)
     8.6 +----------------------------------------------------------------------
     8.7 +
     8.8 +Copyright (c) 2006-2018, assimp team
     8.9 +
    8.10 +
    8.11 +All rights reserved.
    8.12 +
    8.13 +Redistribution and use of this software in source and binary forms,
    8.14 +with or without modification, are permitted provided that the
    8.15 +following conditions are met:
    8.16 +
    8.17 +* Redistributions of source code must retain the above
    8.18 +  copyright notice, this list of conditions and the
    8.19 +  following disclaimer.
    8.20 +
    8.21 +* Redistributions in binary form must reproduce the above
    8.22 +  copyright notice, this list of conditions and the
    8.23 +  following disclaimer in the documentation and/or other
    8.24 +  materials provided with the distribution.
    8.25 +
    8.26 +* Neither the name of the assimp team, nor the names of its
    8.27 +  contributors may be used to endorse or promote products
    8.28 +  derived from this software without specific prior
    8.29 +  written permission of the assimp team.
    8.30 +
    8.31 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    8.32 +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    8.33 +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    8.34 +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
    8.35 +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    8.36 +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    8.37 +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    8.38 +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    8.39 +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    8.40 +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    8.41 +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    8.42 +
    8.43 +----------------------------------------------------------------------
    8.44 +*/
    8.45 +/** @file DefaultLogger.hpp
    8.46 +*/
    8.47 +
    8.48 +#ifndef INCLUDED_AI_DEFAULTLOGGER
    8.49 +#define INCLUDED_AI_DEFAULTLOGGER
    8.50 +
    8.51 +#include "Logger.hpp"
    8.52 +#include "LogStream.hpp"
    8.53 +#include "NullLogger.hpp"
    8.54 +#include <vector>
    8.55 +
    8.56 +namespace Assimp    {
    8.57 +// ------------------------------------------------------------------------------------
    8.58 +class IOStream;
    8.59 +struct LogStreamInfo;
    8.60 +
    8.61 +/** default name of logfile */
    8.62 +#define ASSIMP_DEFAULT_LOG_NAME "AssimpLog.txt"
    8.63 +
    8.64 +// ------------------------------------------------------------------------------------
    8.65 +/** @brief CPP-API: Primary logging facility of Assimp.
    8.66 + *
    8.67 + *  The library stores its primary #Logger as a static member of this class.
    8.68 + *  #get() returns this primary logger. By default the underlying implementation is
    8.69 + *  just a #NullLogger which rejects all log messages. By calling #create(), logging
    8.70 + *  is turned on. To capture the log output multiple log streams (#LogStream) can be
    8.71 + *  attach to the logger. Some default streams for common streaming locations (such as
    8.72 + *  a file, std::cout, OutputDebugString()) are also provided.
    8.73 + *
    8.74 + *  If you wish to customize the logging at an even deeper level supply your own
    8.75 + *  implementation of #Logger to #set().
    8.76 + *  @note The whole logging stuff causes a small extra overhead for all imports. */
    8.77 +class ASSIMP_API DefaultLogger :
    8.78 +    public Logger   {
    8.79 +
    8.80 +public:
    8.81 +
    8.82 +    // ----------------------------------------------------------------------
    8.83 +    /** @brief Creates a logging instance.
    8.84 +     *  @param name Name for log file. Only valid in combination
    8.85 +     *    with the aiDefaultLogStream_FILE flag.
    8.86 +     *  @param severity Log severity, VERBOSE turns on debug messages
    8.87 +     *  @param defStreams  Default log streams to be attached. Any bitwise
    8.88 +     *    combination of the aiDefaultLogStream enumerated values.
    8.89 +     *    If #aiDefaultLogStream_FILE is specified but an empty string is
    8.90 +     *    passed for 'name', no log file is created at all.
    8.91 +     *  @param  io IOSystem to be used to open external files (such as the
    8.92 +     *   log file). Pass NULL to rely on the default implementation.
    8.93 +     *  This replaces the default #NullLogger with a #DefaultLogger instance. */
    8.94 +    static Logger *create(const char* name = ASSIMP_DEFAULT_LOG_NAME,
    8.95 +        LogSeverity severity    = NORMAL,
    8.96 +        unsigned int defStreams = aiDefaultLogStream_DEBUGGER | aiDefaultLogStream_FILE,
    8.97 +        IOSystem* io            = NULL);
    8.98 +
    8.99 +    // ----------------------------------------------------------------------
   8.100 +    /** @brief Setup a custom #Logger implementation.
   8.101 +     *
   8.102 +     *  Use this if the provided #DefaultLogger class doesn't fit into
   8.103 +     *  your needs. If the provided message formatting is OK for you,
   8.104 +     *  it's much easier to use #create() and to attach your own custom
   8.105 +     *  output streams to it.
   8.106 +     *  @param logger Pass NULL to setup a default NullLogger*/
   8.107 +    static void set (Logger *logger);
   8.108 +
   8.109 +    // ----------------------------------------------------------------------
   8.110 +    /** @brief  Getter for singleton instance
   8.111 +     *   @return Only instance. This is never null, but it could be a
   8.112 +     *  NullLogger. Use isNullLogger to check this.*/
   8.113 +    static Logger *get();
   8.114 +
   8.115 +    // ----------------------------------------------------------------------
   8.116 +    /** @brief  Return whether a #NullLogger is currently active
   8.117 +     *  @return true if the current logger is a #NullLogger.
   8.118 +     *  Use create() or set() to setup a logger that does actually do
   8.119 +     *  something else than just rejecting all log messages. */
   8.120 +    static bool isNullLogger();
   8.121 +
   8.122 +    // ----------------------------------------------------------------------
   8.123 +    /** @brief  Kills the current singleton logger and replaces it with a
   8.124 +     *  #NullLogger instance. */
   8.125 +    static void kill();
   8.126 +
   8.127 +    // ----------------------------------------------------------------------
   8.128 +    /** @copydoc Logger::attachStream   */
   8.129 +    bool attachStream(LogStream *pStream,
   8.130 +        unsigned int severity);
   8.131 +
   8.132 +    // ----------------------------------------------------------------------
   8.133 +    /** @copydoc Logger::detatchStream */
   8.134 +    bool detatchStream(LogStream *pStream,
   8.135 +        unsigned int severity);
   8.136 +
   8.137 +private:
   8.138 +    // ----------------------------------------------------------------------
   8.139 +    /** @briefPrivate construction for internal use by create().
   8.140 +     *  @param severity Logging granularity  */
   8.141 +    explicit DefaultLogger(LogSeverity severity);
   8.142 +
   8.143 +    // ----------------------------------------------------------------------
   8.144 +    /** @briefDestructor    */
   8.145 +    ~DefaultLogger();
   8.146 +
   8.147 +    /** @brief  Logs debug infos, only been written when severity level VERBOSE is set */
   8.148 +    void OnDebug(const char* message);
   8.149 +
   8.150 +    /** @brief  Logs an info message */
   8.151 +    void OnInfo(const char*  message);
   8.152 +
   8.153 +    /** @brief  Logs a warning message */
   8.154 +    void OnWarn(const char*  message);
   8.155 +
   8.156 +    /** @brief  Logs an error message */
   8.157 +    void OnError(const char* message);
   8.158 +
   8.159 +    // ----------------------------------------------------------------------
   8.160 +    /** @brief Writes a message to all streams */
   8.161 +    void WriteToStreams(const char* message, ErrorSeverity ErrorSev );
   8.162 +
   8.163 +    // ----------------------------------------------------------------------
   8.164 +    /** @brief Returns the thread id.
   8.165 +     *  @note This is an OS specific feature, if not supported, a
   8.166 +     *    zero will be returned.
   8.167 +     */
   8.168 +    unsigned int GetThreadID();
   8.169 +
   8.170 +private:
   8.171 +    //  Aliases for stream container
   8.172 +    typedef std::vector<LogStreamInfo*> StreamArray;
   8.173 +    typedef std::vector<LogStreamInfo*>::iterator StreamIt;
   8.174 +    typedef std::vector<LogStreamInfo*>::const_iterator ConstStreamIt;
   8.175 +
   8.176 +    //! only logging instance
   8.177 +    static Logger *m_pLogger;
   8.178 +    static NullLogger s_pNullLogger;
   8.179 +
   8.180 +    //! Attached streams
   8.181 +    StreamArray m_StreamArray;
   8.182 +
   8.183 +    bool noRepeatMsg;
   8.184 +    char lastMsg[MAX_LOG_MESSAGE_LENGTH*2];
   8.185 +    size_t lastLen;
   8.186 +};
   8.187 +// ------------------------------------------------------------------------------------
   8.188 +
   8.189 +} // Namespace Assimp
   8.190 +
   8.191 +#endif // !! INCLUDED_AI_DEFAULTLOGGER

     9.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     9.2 +++ b/include/miniassimp/Defines.h	Mon Jan 28 18:19:26 2019 +0200
     9.3 @@ -0,0 +1,49 @@
     9.4 +/*
     9.5 +Open Asset Import Library (assimp)
     9.6 +----------------------------------------------------------------------
     9.7 +
     9.8 +Copyright (c) 2006-2012, assimp team
     9.9 +All rights reserved.
    9.10 +
    9.11 +Redistribution and use of this software in source and binary forms,
    9.12 +with or without modification, are permitted provided that the
    9.13 +following conditions are met:
    9.14 +
    9.15 +* Redistributions of source code must retain the above
    9.16 +  copyright notice, this list of conditions and the
    9.17 +  following disclaimer.
    9.18 +
    9.19 +* Redistributions in binary form must reproduce the above
    9.20 +  copyright notice, this list of conditions and the
    9.21 +  following disclaimer in the documentation and/or other
    9.22 +  materials provided with the distribution.
    9.23 +
    9.24 +* Neither the name of the assimp team, nor the names of its
    9.25 +  contributors may be used to endorse or promote products
    9.26 +  derived from this software without specific prior
    9.27 +  written permission of the assimp team.
    9.28 +
    9.29 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    9.30 +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    9.31 +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    9.32 +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
    9.33 +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    9.34 +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    9.35 +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    9.36 +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    9.37 +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    9.38 +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    9.39 +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    9.40 +
    9.41 +----------------------------------------------------------------------
    9.42 +*/
    9.43 +
    9.44 +// We need those constants, workaround for any platforms where nobody defined them yet
    9.45 +#if (!defined SIZE_MAX)
    9.46 +#   define SIZE_MAX (~((size_t)0))
    9.47 +#endif
    9.48 +
    9.49 +#if (!defined UINT_MAX)
    9.50 +#   define UINT_MAX (~((unsigned int)0))
    9.51 +#endif
    9.52 +

    10.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    10.2 +++ b/include/miniassimp/Exceptional.h	Mon Jan 28 18:19:26 2019 +0200
    10.3 @@ -0,0 +1,125 @@
    10.4 +/*
    10.5 +Open Asset Import Library (assimp)
    10.6 +----------------------------------------------------------------------
    10.7 +
    10.8 +Copyright (c) 2006-2008, assimp team
    10.9 +All rights reserved.
   10.10 +
   10.11 +Redistribution and use of this software in source and binary forms,
   10.12 +with or without modification, are permitted provided that the
   10.13 +following conditions are met:
   10.14 +
   10.15 +* Redistributions of source code must retain the above
   10.16 +  copyright notice, this list of conditions and the
   10.17 +  following disclaimer.
   10.18 +
   10.19 +* Redistributions in binary form must reproduce the above
   10.20 +  copyright notice, this list of conditions and the
   10.21 +  following disclaimer in the documentation and/or other
   10.22 +  materials provided with the distribution.
   10.23 +
   10.24 +* Neither the name of the assimp team, nor the names of its
   10.25 +  contributors may be used to endorse or promote products
   10.26 +  derived from this software without specific prior
   10.27 +  written permission of the assimp team.
   10.28 +
   10.29 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   10.30 +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   10.31 +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   10.32 +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   10.33 +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   10.34 +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   10.35 +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   10.36 +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   10.37 +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   10.38 +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   10.39 +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   10.40 +
   10.41 +----------------------------------------------------------------------
   10.42 +*/
   10.43 +
   10.44 +#ifndef INCLUDED_EXCEPTIONAL_H
   10.45 +#define INCLUDED_EXCEPTIONAL_H
   10.46 +
   10.47 +#include <stdexcept>
   10.48 +#include <miniassimp/DefaultIOStream.h>
   10.49 +using std::runtime_error;
   10.50 +
   10.51 +#ifdef _MSC_VER
   10.52 +#   pragma warning(disable : 4275)
   10.53 +#endif
   10.54 +
   10.55 +// ---------------------------------------------------------------------------
   10.56 +/** FOR IMPORTER PLUGINS ONLY: Simple exception class to be thrown if an
   10.57 + *  unrecoverable error occurs while importing. Loading APIs return
   10.58 + *  NULL instead of a valid aiScene then.  */
   10.59 +class DeadlyImportError
   10.60 +    : public runtime_error
   10.61 +{
   10.62 +public:
   10.63 +    /** Constructor with arguments */
   10.64 +    explicit DeadlyImportError( const std::string& errorText)
   10.65 +        : runtime_error(errorText)
   10.66 +    {
   10.67 +    }
   10.68 +
   10.69 +private:
   10.70 +};
   10.71 +
   10.72 +typedef DeadlyImportError DeadlyExportError;
   10.73 +
   10.74 +#ifdef _MSC_VER
   10.75 +#   pragma warning(default : 4275)
   10.76 +#endif
   10.77 +
   10.78 +// ---------------------------------------------------------------------------
   10.79 +template <typename T>
   10.80 +struct ExceptionSwallower   {
   10.81 +    T operator ()() const {
   10.82 +        return T();
   10.83 +    }
   10.84 +};
   10.85 +
   10.86 +// ---------------------------------------------------------------------------
   10.87 +template <typename T>
   10.88 +struct ExceptionSwallower<T*>   {
   10.89 +    T* operator ()() const {
   10.90 +        return NULL;
   10.91 +    }
   10.92 +};
   10.93 +
   10.94 +// ---------------------------------------------------------------------------
   10.95 +template <>
   10.96 +struct ExceptionSwallower<aiReturn> {
   10.97 +    aiReturn operator ()() const {
   10.98 +        try {
   10.99 +            throw;
  10.100 +        }
  10.101 +        catch (std::bad_alloc&) {
  10.102 +            return aiReturn_OUTOFMEMORY;
  10.103 +        }
  10.104 +        catch (...) {
  10.105 +            return aiReturn_FAILURE;
  10.106 +        }
  10.107 +    }
  10.108 +};
  10.109 +
  10.110 +// ---------------------------------------------------------------------------
  10.111 +template <>
  10.112 +struct ExceptionSwallower<void> {
  10.113 +    void operator ()() const {
  10.114 +        return;
  10.115 +    }
  10.116 +};
  10.117 +
  10.118 +#define ASSIMP_BEGIN_EXCEPTION_REGION()\
  10.119 +{\
  10.120 +    try {
  10.121 +
  10.122 +#define ASSIMP_END_EXCEPTION_REGION(type)\
  10.123 +    } catch(...) {\
  10.124 +        return ExceptionSwallower<type>()();\
  10.125 +    }\
  10.126 +}
  10.127 +
  10.128 +#endif // INCLUDED_EXCEPTIONAL_H

    11.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    11.2 +++ b/include/miniassimp/GenericProperty.h	Mon Jan 28 18:19:26 2019 +0200
    11.3 @@ -0,0 +1,133 @@
    11.4 +/*
    11.5 +Open Asset Import Library (assimp)
    11.6 +----------------------------------------------------------------------
    11.7 +
    11.8 +Copyright (c) 2006-2018, assimp team
    11.9 +
   11.10 +
   11.11 +All rights reserved.
   11.12 +
   11.13 +Redistribution and use of this software in source and binary forms,
   11.14 +with or without modification, are permitted provided that the
   11.15 +following conditions are met:
   11.16 +
   11.17 +* Redistributions of source code must retain the above
   11.18 +  copyright notice, this list of conditions and the
   11.19 +  following disclaimer.
   11.20 +
   11.21 +* Redistributions in binary form must reproduce the above
   11.22 +  copyright notice, this list of conditions and the
   11.23 +  following disclaimer in the documentation and/or other
   11.24 +  materials provided with the distribution.
   11.25 +
   11.26 +* Neither the name of the assimp team, nor the names of its
   11.27 +  contributors may be used to endorse or promote products
   11.28 +  derived from this software without specific prior
   11.29 +  written permission of the assimp team.
   11.30 +
   11.31 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   11.32 +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   11.33 +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   11.34 +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   11.35 +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   11.36 +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   11.37 +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   11.38 +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   11.39 +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   11.40 +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   11.41 +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   11.42 +
   11.43 +----------------------------------------------------------------------
   11.44 +*/
   11.45 +
   11.46 +#ifndef AI_GENERIC_PROPERTY_H_INCLUDED
   11.47 +#define AI_GENERIC_PROPERTY_H_INCLUDED
   11.48 +
   11.49 +#include <miniassimp/Importer.hpp>
   11.50 +#include <miniassimp/ai_assert.h>
   11.51 +#include "Hash.h"
   11.52 +
   11.53 +#include <map>
   11.54 +
   11.55 +// ------------------------------------------------------------------------------------------------
   11.56 +template <class T>
   11.57 +inline
   11.58 +bool SetGenericProperty(std::map< unsigned int, T >& list,
   11.59 +        const char* szName, const T& value) {
   11.60 +    ai_assert(0 != szName);
   11.61 +    const uint32_t hash = SuperFastHash(szName);
   11.62 +
   11.63 +    typename std::map<unsigned int, T>::iterator it = list.find(hash);
   11.64 +    if (it == list.end())   {
   11.65 +        list.insert(std::pair<unsigned int, T>( hash, value ));
   11.66 +        return false;
   11.67 +    }
   11.68 +    (*it).second = value;
   11.69 +
   11.70 +    return true;
   11.71 +}
   11.72 +
   11.73 +// ------------------------------------------------------------------------------------------------
   11.74 +template <class T>
   11.75 +inline
   11.76 +const T& GetGenericProperty(const std::map< unsigned int, T >& list,
   11.77 +        const char* szName, const T& errorReturn) {
   11.78 +    ai_assert(0 != szName);
   11.79 +    const uint32_t hash = SuperFastHash(szName);
   11.80 +
   11.81 +    typename std::map<unsigned int, T>::const_iterator it = list.find(hash);
   11.82 +    if (it == list.end()) {
   11.83 +        return errorReturn;
   11.84 +    }
   11.85 +
   11.86 +    return (*it).second;
   11.87 +}
   11.88 +
   11.89 +// ------------------------------------------------------------------------------------------------
   11.90 +// Special version for pointer types - they will be deleted when replaced with another value
   11.91 +// passing NULL removes the whole property
   11.92 +template <class T>
   11.93 +inline
   11.94 +void SetGenericPropertyPtr(std::map< unsigned int, T* >& list,
   11.95 +        const char* szName, T* value, bool* bWasExisting = 0 ) {
   11.96 +    ai_assert(0 != szName);
   11.97 +    const uint32_t hash = SuperFastHash(szName);
   11.98 +
   11.99 +    typename std::map<unsigned int, T*>::iterator it = list.find(hash);
  11.100 +    if (it == list.end())   {
  11.101 +        if (bWasExisting) {
  11.102 +            *bWasExisting = false;
  11.103 +        }
  11.104 +
  11.105 +        list.insert(std::pair<unsigned int,T*>( hash, value ));
  11.106 +        return;
  11.107 +    }
  11.108 +    if ((*it).second != value)  {
  11.109 +        delete (*it).second;
  11.110 +        (*it).second = value;
  11.111 +    }
  11.112 +    if (!value) {
  11.113 +        list.erase(it);
  11.114 +    }
  11.115 +    if (bWasExisting) {
  11.116 +        *bWasExisting = true;
  11.117 +    }
  11.118 +}
  11.119 +
  11.120 +// ------------------------------------------------------------------------------------------------
  11.121 +template <class T>
  11.122 +inline
  11.123 +bool HasGenericProperty(const std::map< unsigned int, T >& list,
  11.124 +        const char* szName) {
  11.125 +    ai_assert(0 != szName);
  11.126 +    const uint32_t hash = SuperFastHash(szName);
  11.127 +
  11.128 +    typename std::map<unsigned int, T>::const_iterator it = list.find(hash);
  11.129 +    if (it == list.end()) {
  11.130 +        return false;
  11.131 +    }
  11.132 +
  11.133 +    return true;
  11.134 +}
  11.135 +
  11.136 +#endif // !! AI_GENERIC_PROPERTY_H_INCLUDED

    12.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    12.2 +++ b/include/miniassimp/Hash.h	Mon Jan 28 18:19:26 2019 +0200
    12.3 @@ -0,0 +1,118 @@
    12.4 +/*
    12.5 +Open Asset Import Library (assimp)
    12.6 +----------------------------------------------------------------------
    12.7 +
    12.8 +Copyright (c) 2006-2018, assimp team
    12.9 +
   12.10 +
   12.11 +All rights reserved.
   12.12 +
   12.13 +Redistribution and use of this software in source and binary forms,
   12.14 +with or without modification, are permitted provided that the
   12.15 +following conditions are met:
   12.16 +
   12.17 +* Redistributions of source code must retain the above
   12.18 +  copyright notice, this list of conditions and the
   12.19 +  following disclaimer.
   12.20 +
   12.21 +* Redistributions in binary form must reproduce the above
   12.22 +  copyright notice, this list of conditions and the
   12.23 +  following disclaimer in the documentation and/or other
   12.24 +  materials provided with the distribution.
   12.25 +
   12.26 +* Neither the name of the assimp team, nor the names of its
   12.27 +  contributors may be used to endorse or promote products
   12.28 +  derived from this software without specific prior
   12.29 +  written permission of the assimp team.
   12.30 +
   12.31 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   12.32 +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   12.33 +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   12.34 +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   12.35 +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   12.36 +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   12.37 +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   12.38 +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   12.39 +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   12.40 +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   12.41 +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   12.42 +
   12.43 +----------------------------------------------------------------------
   12.44 +*/
   12.45 +
   12.46 +#ifndef AI_HASH_H_INCLUDED
   12.47 +#define AI_HASH_H_INCLUDED
   12.48 +
   12.49 +#include <inttypes.h>
   12.50 +#include <string.h>
   12.51 +
   12.52 +// ------------------------------------------------------------------------------------------------
   12.53 +// Hashing function taken from
   12.54 +// http://www.azillionmonkeys.com/qed/hash.html
   12.55 +// (incremental version)
   12.56 +//
   12.57 +// This code is Copyright 2004-2008 by Paul Hsieh. It is used here in the belief that
   12.58 +// Assimp's license is considered compatible with Pauls's derivative license as specified
   12.59 +// on his web page.
   12.60 +//
   12.61 +// (stdint.h should have been been included here)
   12.62 +// ------------------------------------------------------------------------------------------------
   12.63 +#undef get16bits
   12.64 +#if (defined(__GNUC__) && defined(__i386__)) || defined(__WATCOMC__) \
   12.65 +  || defined(_MSC_VER) || defined (__BORLANDC__) || defined (__TURBOC__)
   12.66 +#define get16bits(d) (*((const uint16_t *) (d)))
   12.67 +#endif
   12.68 +
   12.69 +#if !defined (get16bits)
   12.70 +#define get16bits(d) ((((uint32_t)(((const uint8_t *)(d))[1])) << 8)\
   12.71 +                       +(uint32_t)(((const uint8_t *)(d))[0]) )
   12.72 +#endif
   12.73 +
   12.74 +// ------------------------------------------------------------------------------------------------
   12.75 +inline uint32_t SuperFastHash (const char * data, uint32_t len = 0, uint32_t hash = 0) {
   12.76 +uint32_t tmp;
   12.77 +int rem;
   12.78 +
   12.79 +    if (!data) return 0;
   12.80 +    if (!len)len = (uint32_t)::strlen(data);
   12.81 +
   12.82 +    rem = len & 3;
   12.83 +    len >>= 2;
   12.84 +
   12.85 +    /* Main loop */
   12.86 +    for (;len > 0; len--) {
   12.87 +        hash  += get16bits (data);
   12.88 +        tmp    = (get16bits (data+2) << 11) ^ hash;
   12.89 +        hash   = (hash << 16) ^ tmp;
   12.90 +        data  += 2*sizeof (uint16_t);
   12.91 +        hash  += hash >> 11;
   12.92 +    }
   12.93 +
   12.94 +    /* Handle end cases */
   12.95 +    switch (rem) {
   12.96 +        case 3: hash += get16bits (data);
   12.97 +                hash ^= hash << 16;
   12.98 +                hash ^= data[sizeof (uint16_t)] << 18;
   12.99 +                hash += hash >> 11;
  12.100 +                break;
  12.101 +        case 2: hash += get16bits (data);
  12.102 +                hash ^= hash << 11;
  12.103 +                hash += hash >> 17;
  12.104 +                break;
  12.105 +        case 1: hash += *data;
  12.106 +                hash ^= hash << 10;
  12.107 +                hash += hash >> 1;
  12.108 +    }
  12.109 +
  12.110 +    /* Force "avalanching" of final 127 bits */
  12.111 +    hash ^= hash << 3;
  12.112 +    hash += hash >> 5;
  12.113 +    hash ^= hash << 4;
  12.114 +    hash += hash >> 17;
  12.115 +    hash ^= hash << 25;
  12.116 +    hash += hash >> 6;
  12.117 +
  12.118 +    return hash;
  12.119 +}
  12.120 +
  12.121 +#endif // !! AI_HASH_H_INCLUDED

    13.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    13.2 +++ b/include/miniassimp/IOStream.hpp	Mon Jan 28 18:19:26 2019 +0200
    13.3 @@ -0,0 +1,142 @@
    13.4 +/*
    13.5 +---------------------------------------------------------------------------
    13.6 +Open Asset Import Library (assimp)
    13.7 +---------------------------------------------------------------------------
    13.8 +
    13.9 +Copyright (c) 2006-2018, assimp team
   13.10 +
   13.11 +
   13.12 +
   13.13 +All rights reserved.
   13.14 +
   13.15 +Redistribution and use of this software in source and binary forms,
   13.16 +with or without modification, are permitted provided that the following
   13.17 +conditions are met:
   13.18 +
   13.19 +* Redistributions of source code must retain the above
   13.20 +  copyright notice, this list of conditions and the
   13.21 +  following disclaimer.
   13.22 +
   13.23 +* Redistributions in binary form must reproduce the above
   13.24 +  copyright notice, this list of conditions and the
   13.25 +  following disclaimer in the documentation and/or other
   13.26 +  materials provided with the distribution.
   13.27 +
   13.28 +* Neither the name of the assimp team, nor the names of its
   13.29 +  contributors may be used to endorse or promote products
   13.30 +  derived from this software without specific prior
   13.31 +  written permission of the assimp team.
   13.32 +
   13.33 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   13.34 +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   13.35 +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   13.36 +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   13.37 +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   13.38 +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   13.39 +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   13.40 +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   13.41 +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   13.42 +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   13.43 +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   13.44 +---------------------------------------------------------------------------
   13.45 +*/
   13.46 +/** @file IOStream.hpp
   13.47 + *  @brief File I/O wrappers for C++.
   13.48 + */
   13.49 +
   13.50 +#pragma once
   13.51 +#ifndef AI_IOSTREAM_H_INC
   13.52 +#define AI_IOSTREAM_H_INC
   13.53 +
   13.54 +#include "types.h"
   13.55 +
   13.56 +#ifndef __cplusplus
   13.57 +#   error This header requires C++ to be used. aiFileIO.h is the \
   13.58 +    corresponding C interface.
   13.59 +#endif
   13.60 +
   13.61 +namespace Assimp    {
   13.62 +
   13.63 +// ----------------------------------------------------------------------------------
   13.64 +/** @brief CPP-API: Class to handle file I/O for C++
   13.65 + *
   13.66 + *  Derive an own implementation from this interface to provide custom IO handling
   13.67 + *  to the Importer. If you implement this interface, be sure to also provide an
   13.68 + *  implementation for IOSystem that creates instances of your custom IO class.
   13.69 +*/
   13.70 +class ASSIMP_API IOStream
   13.71 +#ifndef SWIG
   13.72 +    : public Intern::AllocateFromAssimpHeap
   13.73 +#endif
   13.74 +{
   13.75 +protected:
   13.76 +    /** Constructor protected, use IOSystem::Open() to create an instance. */
   13.77 +    IOStream() AI_NO_EXCEPT;
   13.78 +
   13.79 +public:
   13.80 +    // -------------------------------------------------------------------
   13.81 +    /** @brief Destructor. Deleting the object closes the underlying file,
   13.82 +     * alternatively you may use IOSystem::Close() to release the file.
   13.83 +     */
   13.84 +    virtual ~IOStream();
   13.85 +
   13.86 +    // -------------------------------------------------------------------
   13.87 +    /** @brief Read from the file
   13.88 +     *
   13.89 +     * See fread() for more details
   13.90 +     * This fails for write-only files */
   13.91 +    virtual size_t Read(void* pvBuffer,
   13.92 +        size_t pSize,
   13.93 +        size_t pCount) = 0;
   13.94 +
   13.95 +    // -------------------------------------------------------------------
   13.96 +    /** @brief Write to the file
   13.97 +    *
   13.98 +    * See fwrite() for more details
   13.99 +    * This fails for read-only files */
  13.100 +    virtual size_t Write(const void* pvBuffer,
  13.101 +        size_t pSize,
  13.102 +        size_t pCount) = 0;
  13.103 +
  13.104 +    // -------------------------------------------------------------------
  13.105 +    /** @brief Set the read/write cursor of the file
  13.106 +     *
  13.107 +     * Note that the offset is _negative_ for aiOrigin_END.
  13.108 +     * See fseek() for more details */
  13.109 +    virtual aiReturn Seek(size_t pOffset,
  13.110 +        aiOrigin pOrigin) = 0;
  13.111 +
  13.112 +    // -------------------------------------------------------------------
  13.113 +    /** @brief Get the current position of the read/write cursor
  13.114 +     *
  13.115 +     * See ftell() for more details */
  13.116 +    virtual size_t Tell() const = 0;
  13.117 +
  13.118 +    // -------------------------------------------------------------------
  13.119 +    /** @brief Returns filesize
  13.120 +     *  Returns the filesize. */
  13.121 +    virtual size_t FileSize() const = 0;
  13.122 +
  13.123 +    // -------------------------------------------------------------------
  13.124 +    /** @brief Flush the contents of the file buffer (for writers)
  13.125 +     *  See fflush() for more details.
  13.126 +     */
  13.127 +    virtual void Flush() = 0;
  13.128 +}; //! class IOStream
  13.129 +
  13.130 +// ----------------------------------------------------------------------------------
  13.131 +inline
  13.132 +IOStream::IOStream() AI_NO_EXCEPT {
  13.133 +    // empty
  13.134 +}
  13.135 +
  13.136 +// ----------------------------------------------------------------------------------
  13.137 +inline
  13.138 +IOStream::~IOStream() {
  13.139 +    // empty
  13.140 +}
  13.141 +// ----------------------------------------------------------------------------------
  13.142 +
  13.143 +} //!namespace Assimp
  13.144 +
  13.145 +#endif //!!AI_IOSTREAM_H_INC

    14.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    14.2 +++ b/include/miniassimp/IOSystem.hpp	Mon Jan 28 18:19:26 2019 +0200
    14.3 @@ -0,0 +1,357 @@
    14.4 +/*
    14.5 +---------------------------------------------------------------------------
    14.6 +Open Asset Import Library (assimp)
    14.7 +---------------------------------------------------------------------------
    14.8 +
    14.9 +Copyright (c) 2006-2018, assimp team
   14.10 +
   14.11 +
   14.12 +
   14.13 +All rights reserved.
   14.14 +
   14.15 +Redistribution and use of this software in source and binary forms,
   14.16 +with or without modification, are permitted provided that the following
   14.17 +conditions are met:
   14.18 +
   14.19 +* Redistributions of source code must retain the above
   14.20 +  copyright notice, this list of conditions and the
   14.21 +  following disclaimer.
   14.22 +
   14.23 +* Redistributions in binary form must reproduce the above
   14.24 +  copyright notice, this list of conditions and the
   14.25 +  following disclaimer in the documentation and/or other
   14.26 +  materials provided with the distribution.
   14.27 +
   14.28 +* Neither the name of the assimp team, nor the names of its
   14.29 +  contributors may be used to endorse or promote products
   14.30 +  derived from this software without specific prior
   14.31 +  written permission of the assimp team.
   14.32 +
   14.33 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   14.34 +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   14.35 +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   14.36 +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   14.37 +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   14.38 +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   14.39 +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   14.40 +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   14.41 +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   14.42 +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   14.43 +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   14.44 +---------------------------------------------------------------------------
   14.45 +*/
   14.46 +
   14.47 +/** @file IOSystem.hpp
   14.48 + *  @brief File system wrapper for C++. Inherit this class to supply
   14.49 + *  custom file handling logic to the Import library.
   14.50 +*/
   14.51 +
   14.52 +#pragma once
   14.53 +#ifndef AI_IOSYSTEM_H_INC
   14.54 +#define AI_IOSYSTEM_H_INC
   14.55 +
   14.56 +#ifndef __cplusplus
   14.57 +#   error This header requires C++ to be used. aiFileIO.h is the \
   14.58 +    corresponding C interface.
   14.59 +#endif
   14.60 +
   14.61 +#include "types.h"
   14.62 +
   14.63 +#ifdef _WIN32
   14.64 +#   include <direct.h>  
   14.65 +#   include <stdlib.h>  
   14.66 +#   include <stdio.h>  
   14.67 +#else
   14.68 +#   include <sys/stat.h>
   14.69 +#   include <sys/types.h>
   14.70 +#   include <unistd.h>
   14.71 +#endif // _WIN32
   14.72 +
   14.73 +#include <vector>
   14.74 +
   14.75 +namespace Assimp    {
   14.76 +
   14.77 +    class IOStream;
   14.78 +
   14.79 +// ---------------------------------------------------------------------------
   14.80 +/** @brief CPP-API: Interface to the file system.
   14.81 + *
   14.82 + *  Derive an own implementation from this interface to supply custom file handling
   14.83 + *  to the importer library. If you implement this interface, you also want to
   14.84 + *  supply a custom implementation for IOStream.
   14.85 + *
   14.86 + *  @see Importer::SetIOHandler() 
   14.87 + */
   14.88 +class ASSIMP_API IOSystem
   14.89 +#ifndef SWIG
   14.90 +    : public Intern::AllocateFromAssimpHeap
   14.91 +#endif
   14.92 +{
   14.93 +public:
   14.94 +
   14.95 +    // -------------------------------------------------------------------
   14.96 +    /** @brief Default constructor.
   14.97 +     *
   14.98 +     *  Create an instance of your derived class and assign it to an
   14.99 +     *  #Assimp::Importer instance by calling Importer::SetIOHandler().
  14.100 +     */
  14.101 +    IOSystem() AI_NO_EXCEPT;
  14.102 +
  14.103 +    // -------------------------------------------------------------------
  14.104 +    /** @brief Virtual destructor.
  14.105 +     *
  14.106 +     *  It is safe to be called from within DLL Assimp, we're constructed
  14.107 +     *  on Assimp's heap.
  14.108 +     */
  14.109 +    virtual ~IOSystem();
  14.110 +
  14.111 +    // -------------------------------------------------------------------
  14.112 +    /** @brief For backward compatibility
  14.113 +     *  @see Exists(const char*)
  14.114 +     */
  14.115 +    AI_FORCE_INLINE bool Exists( const std::string& pFile) const;
  14.116 +
  14.117 +    // -------------------------------------------------------------------
  14.118 +    /** @brief Tests for the existence of a file at the given path.
  14.119 +     *
  14.120 +     * @param pFile Path to the file
  14.121 +     * @return true if there is a file with this path, else false.
  14.122 +     */
  14.123 +    virtual bool Exists( const char* pFile) const = 0;
  14.124 +
  14.125 +    // -------------------------------------------------------------------
  14.126 +    /** @brief Returns the system specific directory separator
  14.127 +     *  @return System specific directory separator
  14.128 +     */
  14.129 +    virtual char getOsSeparator() const = 0;
  14.130 +
  14.131 +    // -------------------------------------------------------------------
  14.132 +    /** @brief Open a new file with a given path.
  14.133 +     *
  14.134 +     *  When the access to the file is finished, call Close() to release
  14.135 +     *  all associated resources (or the virtual dtor of the IOStream).
  14.136 +     *
  14.137 +     *  @param pFile Path to the file
  14.138 +     *  @param pMode Desired file I/O mode. Required are: "wb", "w", "wt",
  14.139 +     *         "rb", "r", "rt".
  14.140 +     *
  14.141 +     *  @return New IOStream interface allowing the lib to access
  14.142 +     *         the underlying file.
  14.143 +     *  @note When implementing this class to provide custom IO handling,
  14.144 +     *  you probably have to supply an own implementation of IOStream as well.
  14.145 +     */
  14.146 +    virtual IOStream* Open(const char* pFile,
  14.147 +        const char* pMode = "rb") = 0;
  14.148 +
  14.149 +    // -------------------------------------------------------------------
  14.150 +    /** @brief For backward compatibility
  14.151 +     *  @see Open(const char*, const char*)
  14.152 +     */
  14.153 +    inline IOStream* Open(const std::string& pFile,
  14.154 +        const std::string& pMode = std::string("rb"));
  14.155 +
  14.156 +    // -------------------------------------------------------------------
  14.157 +    /** @brief Closes the given file and releases all resources
  14.158 +     *    associated with it.
  14.159 +     *  @param pFile The file instance previously created by Open().
  14.160 +     */
  14.161 +    virtual void Close( IOStream* pFile) = 0;
  14.162 +
  14.163 +    // -------------------------------------------------------------------
  14.164 +    /** @brief Compares two paths and check whether the point to
  14.165 +     *         identical files.
  14.166 +     *
  14.167 +     * The dummy implementation of this virtual member performs a
  14.168 +     * case-insensitive comparison of the given strings. The default IO
  14.169 +     * system implementation uses OS mechanisms to convert relative into
  14.170 +     * absolute paths, so the result can be trusted.
  14.171 +     * @param one First file
  14.172 +     * @param second Second file
  14.173 +     * @return true if the paths point to the same file. The file needn't
  14.174 +     *   be existing, however.
  14.175 +     */
  14.176 +    virtual bool ComparePaths (const char* one,
  14.177 +        const char* second) const;
  14.178 +
  14.179 +    // -------------------------------------------------------------------
  14.180 +    /** @brief For backward compatibility
  14.181 +     *  @see ComparePaths(const char*, const char*)
  14.182 +     */
  14.183 +    inline bool ComparePaths (const std::string& one,
  14.184 +        const std::string& second) const;
  14.185 +
  14.186 +    // -------------------------------------------------------------------
  14.187 +    /** @brief Pushes a new directory onto the directory stack.
  14.188 +     *  @param path Path to push onto the stack.
  14.189 +     *  @return True, when push was successful, false if path is empty.
  14.190 +     */
  14.191 +    virtual bool PushDirectory( const std::string &path );
  14.192 +
  14.193 +    // -------------------------------------------------------------------
  14.194 +    /** @brief Returns the top directory from the stack.
  14.195 +     *  @return The directory on the top of the stack.
  14.196 +     *          Returns empty when no directory was pushed to the stack.
  14.197 +     */
  14.198 +    virtual const std::string &CurrentDirectory() const;
  14.199 +
  14.200 +    // -------------------------------------------------------------------
  14.201 +    /** @brief Returns the number of directories stored on the stack.
  14.202 +     *  @return The number of directories of the stack.
  14.203 +     */
  14.204 +    virtual size_t StackSize() const;
  14.205 +
  14.206 +    // -------------------------------------------------------------------
  14.207 +    /** @brief Pops the top directory from the stack.
  14.208 +     *  @return True, when a directory was on the stack. False if no
  14.209 +     *          directory was on the stack.
  14.210 +     */
  14.211 +    virtual bool PopDirectory();
  14.212 +
  14.213 +    // -------------------------------------------------------------------
  14.214 +    /** @brief CReates an new directory at the given path.
  14.215 +     *  @param  path    [in] The path to create.
  14.216 +     *  @return True, when a directory was created. False if the directory
  14.217 +     *           cannot be created.
  14.218 +     */
  14.219 +    virtual bool CreateDirectory( const std::string &path );
  14.220 +
  14.221 +    // -------------------------------------------------------------------
  14.222 +    /** @brief Will change the current directory to the given path.
  14.223 +     *  @param path     [in] The path to change to.
  14.224 +     *  @return True, when the directory has changed successfully.
  14.225 +     */
  14.226 +    virtual bool ChangeDirectory( const std::string &path );
  14.227 +
  14.228 +    virtual bool DeleteFile( const std::string &file );
  14.229 +
  14.230 +private:
  14.231 +    std::vector<std::string> m_pathStack;
  14.232 +};
  14.233 +
  14.234 +// ----------------------------------------------------------------------------
  14.235 +AI_FORCE_INLINE
  14.236 +IOSystem::IOSystem() AI_NO_EXCEPT
  14.237 +: m_pathStack() {
  14.238 +    // empty
  14.239 +}
  14.240 +
  14.241 +// ----------------------------------------------------------------------------
  14.242 +AI_FORCE_INLINE
  14.243 +IOSystem::~IOSystem() {
  14.244 +    // empty
  14.245 +}
  14.246 +
  14.247 +// ----------------------------------------------------------------------------
  14.248 +// For compatibility, the interface of some functions taking a std::string was
  14.249 +// changed to const char* to avoid crashes between binary incompatible STL
  14.250 +// versions. This code her is inlined,  so it shouldn't cause any problems.
  14.251 +// ----------------------------------------------------------------------------
  14.252 +
  14.253 +// ----------------------------------------------------------------------------
  14.254 +AI_FORCE_INLINE
  14.255 +IOStream* IOSystem::Open(const std::string& pFile, const std::string& pMode) {
  14.256 +    // NOTE:
  14.257 +    // For compatibility, interface was changed to const char* to
  14.258 +    // avoid crashes between binary incompatible STL versions
  14.259 +    return Open(pFile.c_str(),pMode.c_str());
  14.260 +}
  14.261 +
  14.262 +// ----------------------------------------------------------------------------
  14.263 +AI_FORCE_INLINE
  14.264 +bool IOSystem::Exists( const std::string& pFile) const {
  14.265 +    // NOTE:
  14.266 +    // For compatibility, interface was changed to const char* to
  14.267 +    // avoid crashes between binary incompatible STL versions
  14.268 +    return Exists(pFile.c_str());
  14.269 +}
  14.270 +
  14.271 +// ----------------------------------------------------------------------------
  14.272 +AI_FORCE_INLINE
  14.273 +bool IOSystem::ComparePaths (const std::string& one, const std::string& second) const {
  14.274 +    // NOTE:
  14.275 +    // For compatibility, interface was changed to const char* to
  14.276 +    // avoid crashes between binary incompatible STL versions
  14.277 +    return ComparePaths(one.c_str(),second.c_str());
  14.278 +}
  14.279 +
  14.280 +// ----------------------------------------------------------------------------
  14.281 +AI_FORCE_INLINE
  14.282 +bool IOSystem::PushDirectory( const std::string &path ) {
  14.283 +    if ( path.empty() ) {
  14.284 +        return false;
  14.285 +    }
  14.286 +
  14.287 +    m_pathStack.push_back( path );
  14.288 +
  14.289 +    return true;
  14.290 +}
  14.291 +
  14.292 +// ----------------------------------------------------------------------------
  14.293 +AI_FORCE_INLINE
  14.294 +const std::string &IOSystem::CurrentDirectory() const {
  14.295 +    if ( m_pathStack.empty() ) {
  14.296 +        static const std::string Dummy("");
  14.297 +        return Dummy;
  14.298 +    }
  14.299 +    return m_pathStack[ m_pathStack.size()-1 ];
  14.300 +}
  14.301 +
  14.302 +// ----------------------------------------------------------------------------
  14.303 +AI_FORCE_INLINE
  14.304 +size_t IOSystem::StackSize() const {
  14.305 +    return m_pathStack.size();
  14.306 +}
  14.307 +
  14.308 +// ----------------------------------------------------------------------------
  14.309 +AI_FORCE_INLINE
  14.310 +bool IOSystem::PopDirectory() {
  14.311 +    if ( m_pathStack.empty() ) {
  14.312 +        return false;
  14.313 +    }
  14.314 +
  14.315 +    m_pathStack.pop_back();
  14.316 +
  14.317 +    return true;
  14.318 +}
  14.319 +
  14.320 +// ----------------------------------------------------------------------------
  14.321 +AI_FORCE_INLINE
  14.322 +bool IOSystem::CreateDirectory( const std::string &path ) {
  14.323 +    if ( path.empty() ) {
  14.324 +        return false;
  14.325 +    }
  14.326 +
  14.327 +#ifdef _WIN32
  14.328 +    return 0 != ::_mkdir( path.c_str() );
  14.329 +#else
  14.330 +    return 0 != ::mkdir( path.c_str(), 0777 );
  14.331 +#endif // _WIN32
  14.332 +}
  14.333 +
  14.334 +// ----------------------------------------------------------------------------
  14.335 +AI_FORCE_INLINE
  14.336 +bool IOSystem::ChangeDirectory( const std::string &path ) {
  14.337 +    if ( path.empty() ) {
  14.338 +        return false;
  14.339 +    }
  14.340 +
  14.341 +#ifdef _WIN32
  14.342 +    return 0 != ::_chdir( path.c_str() );
  14.343 +#else
  14.344 +    return 0 != ::chdir( path.c_str() );
  14.345 +#endif // _WIN32
  14.346 +}
  14.347 +
  14.348 +
  14.349 +// ----------------------------------------------------------------------------
  14.350 +AI_FORCE_INLINE
  14.351 +bool IOSystem::DeleteFile( const std::string &file ) {
  14.352 +    if ( file.empty() ) {
  14.353 +        return false;
  14.354 +    }
  14.355 +    const int retCode( ::remove( file.c_str() ) );
  14.356 +    return ( 0 == retCode );
  14.357 +}
  14.358 +} //!ns Assimp
  14.359 +
  14.360 +#endif //AI_IOSYSTEM_H_INC

    15.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    15.2 +++ b/include/miniassimp/Importer.hpp	Mon Jan 28 18:19:26 2019 +0200
    15.3 @@ -0,0 +1,649 @@
    15.4 +/*
    15.5 +---------------------------------------------------------------------------
    15.6 +Open Asset Import Library (assimp)
    15.7 +---------------------------------------------------------------------------
    15.8 +
    15.9 +Copyright (c) 2006-2018, assimp team
   15.10 +
   15.11 +
   15.12 +
   15.13 +All rights reserved.
   15.14 +
   15.15 +Redistribution and use of this software in source and binary forms,
   15.16 +with or without modification, are permitted provided that the following
   15.17 +conditions are met:
   15.18 +
   15.19 +* Redistributions of source code must retain the above
   15.20 +  copyright notice, this list of conditions and the
   15.21 +  following disclaimer.
   15.22 +
   15.23 +* Redistributions in binary form must reproduce the above
   15.24 +  copyright notice, this list of conditions and the
   15.25 +  following disclaimer in the documentation and/or other
   15.26 +  materials provided with the distribution.
   15.27 +
   15.28 +* Neither the name of the assimp team, nor the names of its
   15.29 +  contributors may be used to endorse or promote products
   15.30 +  derived from this software without specific prior
   15.31 +  written permission of the assimp team.
   15.32 +
   15.33 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   15.34 +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   15.35 +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   15.36 +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   15.37 +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   15.38 +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   15.39 +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   15.40 +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   15.41 +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   15.42 +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   15.43 +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   15.44 +---------------------------------------------------------------------------
   15.45 +*/
   15.46 +
   15.47 +/** @file  Importer.hpp
   15.48 + *  @brief Defines the C++-API to the Open Asset Import Library.
   15.49 + */
   15.50 +#pragma once
   15.51 +#ifndef AI_ASSIMP_HPP_INC
   15.52 +#define AI_ASSIMP_HPP_INC
   15.53 +
   15.54 +#ifndef __cplusplus
   15.55 +#   error This header requires C++ to be used. Use assimp.h for plain C.
   15.56 +#endif // __cplusplus
   15.57 +
   15.58 +// Public ASSIMP data structures
   15.59 +#include <miniassimp/types.h>
   15.60 +
   15.61 +namespace Assimp    {
   15.62 +    // =======================================================================
   15.63 +    // Public interface to Assimp
   15.64 +    class Importer;
   15.65 +    class IOStream;
   15.66 +    class IOSystem;
   15.67 +    class ProgressHandler;
   15.68 +
   15.69 +    // =======================================================================
   15.70 +    // Plugin development
   15.71 +    //
   15.72 +    // Include the following headers for the declarations:
   15.73 +    // BaseImporter.h
   15.74 +    // BaseProcess.h
   15.75 +    class BaseImporter;
   15.76 +    class BaseProcess;
   15.77 +    class SharedPostProcessInfo;
   15.78 +    class BatchLoader;
   15.79 +
   15.80 +    // =======================================================================
   15.81 +    // Holy stuff, only for members of the high council of the Jedi.
   15.82 +    class ImporterPimpl;
   15.83 +} //! namespace Assimp
   15.84 +
   15.85 +#define AI_PROPERTY_WAS_NOT_EXISTING 0xffffffff
   15.86 +
   15.87 +struct aiScene;
   15.88 +
   15.89 +// importerdesc.h
   15.90 +struct aiImporterDesc;
   15.91 +
   15.92 +/** @namespace Assimp Assimp's CPP-API and all internal APIs */
   15.93 +namespace Assimp    {
   15.94 +
   15.95 +// ----------------------------------------------------------------------------------
   15.96 +/** CPP-API: The Importer class forms an C++ interface to the functionality of the
   15.97 +*   Open Asset Import Library.
   15.98 +*
   15.99 +* Create an object of this class and call ReadFile() to import a file.
  15.100 +* If the import succeeds, the function returns a pointer to the imported data.
  15.101 +* The data remains property of the object, it is intended to be accessed
  15.102 +* read-only. The imported data will be destroyed along with the Importer
  15.103 +* object. If the import fails, ReadFile() returns a NULL pointer. In this
  15.104 +* case you can retrieve a human-readable error description be calling
  15.105 +* GetErrorString(). You can call ReadFile() multiple times with a single Importer
  15.106 +* instance. Actually, constructing Importer objects involves quite many
  15.107 +* allocations and may take some time, so it's better to reuse them as often as
  15.108 +* possible.
  15.109 +*
  15.110 +* If you need the Importer to do custom file handling to access the files,
  15.111 +* implement IOSystem and IOStream and supply an instance of your custom
  15.112 +* IOSystem implementation by calling SetIOHandler() before calling ReadFile().
  15.113 +* If you do not assign a custion IO handler, a default handler using the
  15.114 +* standard C++ IO logic will be used.
  15.115 +*
  15.116 +* @note One Importer instance is not thread-safe. If you use multiple
  15.117 +* threads for loading, each thread should maintain its own Importer instance.
  15.118 +*/
  15.119 +class ASSIMP_API Importer   {
  15.120 +private:
  15.121 +    Importer(const Importer& other);
  15.122 +    Importer &operator=(const Importer &);
  15.123 +
  15.124 +public:
  15.125 +    /**
  15.126 +     *  @brief The upper limit for hints.
  15.127 +     */
  15.128 +    static const unsigned int MaxLenHint = 200;
  15.129 +
  15.130 +public:
  15.131 +
  15.132 +    // -------------------------------------------------------------------
  15.133 +    /** Constructor. Creates an empty importer object.
  15.134 +     *
  15.135 +     * Call ReadFile() to start the import process. The configuration
  15.136 +     * property table is initially empty.
  15.137 +     */
  15.138 +    Importer();
  15.139 +
  15.140 +    // -------------------------------------------------------------------
  15.141 +    /** Destructor. The object kept ownership of the imported data,
  15.142 +     * which now will be destroyed along with the object.
  15.143 +     */
  15.144 +    ~Importer();
  15.145 +
  15.146 +
  15.147 +    // -------------------------------------------------------------------
  15.148 +    /** Registers a new loader.
  15.149 +     *
  15.150 +     * @param pImp Importer to be added. The Importer instance takes
  15.151 +     *   ownership of the pointer, so it will be automatically deleted
  15.152 +     *   with the Importer instance.
  15.153 +     * @return AI_SUCCESS if the loader has been added. The registration
  15.154 +     *   fails if there is already a loader for a specific file extension.
  15.155 +     */
  15.156 +    aiReturn RegisterLoader(BaseImporter* pImp);
  15.157 +
  15.158 +    // -------------------------------------------------------------------
  15.159 +    /** Unregisters a loader.
  15.160 +     *
  15.161 +     * @param pImp Importer to be unregistered.
  15.162 +     * @return AI_SUCCESS if the loader has been removed. The function
  15.163 +     *   fails if the loader is currently in use (this could happen
  15.164 +     *   if the #Importer instance is used by more than one thread) or
  15.165 +     *   if it has not yet been registered.
  15.166 +     */
  15.167 +    aiReturn UnregisterLoader(BaseImporter* pImp);
  15.168 +
  15.169 +    // -------------------------------------------------------------------
  15.170 +    /** Registers a new post-process step.
  15.171 +     *
  15.172 +     * At the moment, there's a small limitation: new post processing
  15.173 +     * steps are added to end of the list, or in other words, executed
  15.174 +     * last, after all built-in steps.
  15.175 +     * @param pImp Post-process step to be added. The Importer instance
  15.176 +     *   takes ownership of the pointer, so it will be automatically
  15.177 +     *   deleted with the Importer instance.
  15.178 +     * @return AI_SUCCESS if the step has been added correctly.
  15.179 +     */
  15.180 +    aiReturn RegisterPPStep(BaseProcess* pImp);
  15.181 +
  15.182 +    // -------------------------------------------------------------------
  15.183 +    /** Unregisters a post-process step.
  15.184 +     *
  15.185 +     * @param pImp Step to be unregistered.
  15.186 +     * @return AI_SUCCESS if the step has been removed. The function
  15.187 +     *   fails if the step is currently in use (this could happen
  15.188 +     *   if the #Importer instance is used by more than one thread) or
  15.189 +     *   if it has not yet been registered.
  15.190 +     */
  15.191 +    aiReturn UnregisterPPStep(BaseProcess* pImp);
  15.192 +
  15.193 +    // -------------------------------------------------------------------
  15.194 +    /** Set an integer configuration property.
  15.195 +     * @param szName Name of the property. All supported properties
  15.196 +     *   are defined in the aiConfig.g header (all constants share the
  15.197 +     *   prefix AI_CONFIG_XXX and are simple strings).
  15.198 +     * @param iValue New value of the property
  15.199 +     * @return true if the property was set before. The new value replaces
  15.200 +     *   the previous value in this case.
  15.201 +     * @note Property of different types (float, int, string ..) are kept
  15.202 +     *   on different stacks, so calling SetPropertyInteger() for a
  15.203 +     *   floating-point property has no effect - the loader will call
  15.204 +     *   GetPropertyFloat() to read the property, but it won't be there.
  15.205 +     */
  15.206 +    bool SetPropertyInteger(const char* szName, int iValue);
  15.207 +
  15.208 +    // -------------------------------------------------------------------
  15.209 +    /** Set a boolean configuration property. Boolean properties
  15.210 +     *  are stored on the integer stack internally so it's possible
  15.211 +     *  to set them via #SetPropertyBool and query them with
  15.212 +     *  #GetPropertyBool and vice versa.
  15.213 +     * @see SetPropertyInteger()
  15.214 +     */
  15.215 +    bool SetPropertyBool(const char* szName, bool value)    {
  15.216 +        return SetPropertyInteger(szName,value);
  15.217 +    }
  15.218 +
  15.219 +    // -------------------------------------------------------------------
  15.220 +    /** Set a floating-point configuration property.
  15.221 +     * @see SetPropertyInteger()
  15.222 +     */
  15.223 +    bool SetPropertyFloat(const char* szName, ai_real fValue);
  15.224 +
  15.225 +    // -------------------------------------------------------------------
  15.226 +    /** Set a string configuration property.
  15.227 +     * @see SetPropertyInteger()
  15.228 +     */
  15.229 +    bool SetPropertyString(const char* szName, const std::string& sValue);
  15.230 +
  15.231 +    // -------------------------------------------------------------------
  15.232 +    /** Set a matrix configuration property.
  15.233 +     * @see SetPropertyInteger()
  15.234 +     */
  15.235 +    bool SetPropertyMatrix(const char* szName, const aiMatrix4x4& sValue);
  15.236 +
  15.237 +    // -------------------------------------------------------------------
  15.238 +    /** Get a configuration property.
  15.239 +     * @param szName Name of the property. All supported properties
  15.240 +     *   are defined in the aiConfig.g header (all constants share the
  15.241 +     *   prefix AI_CONFIG_XXX).
  15.242 +     * @param iErrorReturn Value that is returned if the property
  15.243 +     *   is not found.
  15.244 +     * @return Current value of the property
  15.245 +     * @note Property of different types (float, int, string ..) are kept
  15.246 +     *   on different lists, so calling SetPropertyInteger() for a
  15.247 +     *   floating-point property has no effect - the loader will call
  15.248 +     *   GetPropertyFloat() to read the property, but it won't be there.
  15.249 +     */
  15.250 +    int GetPropertyInteger(const char* szName,
  15.251 +        int iErrorReturn = 0xffffffff) const;
  15.252 +
  15.253 +    // -------------------------------------------------------------------
  15.254 +    /** Get a boolean configuration property. Boolean properties
  15.255 +     *  are stored on the integer stack internally so it's possible
  15.256 +     *  to set them via #SetPropertyBool and query them with
  15.257 +     *  #GetPropertyBool and vice versa.
  15.258 +     * @see GetPropertyInteger()
  15.259 +     */
  15.260 +    bool GetPropertyBool(const char* szName, bool bErrorReturn = false) const {
  15.261 +        return GetPropertyInteger(szName,bErrorReturn)!=0;
  15.262 +    }
  15.263 +
  15.264 +    // -------------------------------------------------------------------
  15.265 +    /** Get a floating-point configuration property
  15.266 +     * @see GetPropertyInteger()
  15.267 +     */
  15.268 +    ai_real GetPropertyFloat(const char* szName,
  15.269 +        ai_real fErrorReturn = 10e10) const;
  15.270 +
  15.271 +    // -------------------------------------------------------------------
  15.272 +    /** Get a string configuration property
  15.273 +     *
  15.274 +     *  The return value remains valid until the property is modified.
  15.275 +     * @see GetPropertyInteger()
  15.276 +     */
  15.277 +    const std::string GetPropertyString(const char* szName,
  15.278 +        const std::string& sErrorReturn = "") const;
  15.279 +
  15.280 +    // -------------------------------------------------------------------
  15.281 +    /** Get a matrix configuration property
  15.282 +     *
  15.283 +     *  The return value remains valid until the property is modified.
  15.284 +     * @see GetPropertyInteger()
  15.285 +     */
  15.286 +    const aiMatrix4x4 GetPropertyMatrix(const char* szName,
  15.287 +        const aiMatrix4x4& sErrorReturn = aiMatrix4x4()) const;
  15.288 +
  15.289 +    // -------------------------------------------------------------------
  15.290 +    /** Supplies a custom IO handler to the importer to use to open and
  15.291 +     * access files. If you need the importer to use custom IO logic to
  15.292 +     * access the files, you need to provide a custom implementation of
  15.293 +     * IOSystem and IOFile to the importer. Then create an instance of
  15.294 +     * your custom IOSystem implementation and supply it by this function.
  15.295 +     *
  15.296 +     * The Importer takes ownership of the object and will destroy it
  15.297 +     * afterwards. The previously assigned handler will be deleted.
  15.298 +     * Pass NULL to take again ownership of your IOSystem and reset Assimp
  15.299 +     * to use its default implementation.
  15.300 +     *
  15.301 +     * @param pIOHandler The IO handler to be used in all file accesses
  15.302 +     *   of the Importer.
  15.303 +     */
  15.304 +    void SetIOHandler( IOSystem* pIOHandler);
  15.305 +
  15.306 +    // -------------------------------------------------------------------
  15.307 +    /** Retrieves the IO handler that is currently set.
  15.308 +     * You can use #IsDefaultIOHandler() to check whether the returned
  15.309 +     * interface is the default IO handler provided by ASSIMP. The default
  15.310 +     * handler is active as long the application doesn't supply its own
  15.311 +     * custom IO handler via #SetIOHandler().
  15.312 +     * @return A valid IOSystem interface, never NULL.
  15.313 +     */
  15.314 +    IOSystem* GetIOHandler() const;
  15.315 +
  15.316 +    // -------------------------------------------------------------------
  15.317 +    /** Checks whether a default IO handler is active
  15.318 +     * A default handler is active as long the application doesn't
  15.319 +     * supply its own custom IO handler via #SetIOHandler().
  15.320 +     * @return true by default
  15.321 +     */
  15.322 +    bool IsDefaultIOHandler() const;
  15.323 +
  15.324 +    // -------------------------------------------------------------------
  15.325 +    /** Supplies a custom progress handler to the importer. This
  15.326 +     *  interface exposes an #Update() callback, which is called
  15.327 +     *  more or less periodically (please don't sue us if it
  15.328 +     *  isn't as periodically as you'd like it to have ...).
  15.329 +     *  This can be used to implement progress bars and loading
  15.330 +     *  timeouts.
  15.331 +     *  @param pHandler Progress callback interface. Pass NULL to
  15.332 +     *    disable progress reporting.
  15.333 +     *  @note Progress handlers can be used to abort the loading
  15.334 +     *    at almost any time.*/
  15.335 +    void SetProgressHandler ( ProgressHandler* pHandler );
  15.336 +
  15.337 +    // -------------------------------------------------------------------
  15.338 +    /** Retrieves the progress handler that is currently set.
  15.339 +     * You can use #IsDefaultProgressHandler() to check whether the returned
  15.340 +     * interface is the default handler provided by ASSIMP. The default
  15.341 +     * handler is active as long the application doesn't supply its own
  15.342 +     * custom handler via #SetProgressHandler().
  15.343 +     * @return A valid ProgressHandler interface, never NULL.
  15.344 +     */
  15.345 +    ProgressHandler* GetProgressHandler() const;
  15.346 +
  15.347 +    // -------------------------------------------------------------------
  15.348 +    /** Checks whether a default progress handler is active
  15.349 +     * A default handler is active as long the application doesn't
  15.350 +     * supply its own custom progress handler via #SetProgressHandler().
  15.351 +     * @return true by default
  15.352 +     */
  15.353 +    bool IsDefaultProgressHandler() const;
  15.354 +
  15.355 +    // -------------------------------------------------------------------
  15.356 +    /** @brief Check whether a given set of post-processing flags
  15.357 +     *  is supported.
  15.358 +     *
  15.359 +     *  Some flags are mutually exclusive, others are probably
  15.360 +     *  not available because your excluded them from your
  15.361 +     *  Assimp builds. Calling this function is recommended if
  15.362 +     *  you're unsure.
  15.363 +     *
  15.364 +     *  @param pFlags Bitwise combination of the aiPostProcess flags.
  15.365 +     *  @return true if this flag combination is fine.
  15.366 +     */
  15.367 +    bool ValidateFlags(unsigned int pFlags) const;
  15.368 +
  15.369 +    // -------------------------------------------------------------------
  15.370 +    /** Reads the given file and returns its contents if successful.
  15.371 +     *
  15.372 +     * If the call succeeds, the contents of the file are returned as a
  15.373 +     * pointer to an aiScene object. The returned data is intended to be
  15.374 +     * read-only, the importer object keeps ownership of the data and will
  15.375 +     * destroy it upon destruction. If the import fails, NULL is returned.
  15.376 +     * A human-readable error description can be retrieved by calling
  15.377 +     * GetErrorString(). The previous scene will be deleted during this call.
  15.378 +     * @param pFile Path and filename to the file to be imported.
  15.379 +     * @param pFlags Optional post processing steps to be executed after
  15.380 +     *   a successful import. Provide a bitwise combination of the
  15.381 +     *   #aiPostProcessSteps flags. If you wish to inspect the imported
  15.382 +     *   scene first in order to fine-tune your post-processing setup,
  15.383 +     *   consider to use #ApplyPostProcessing().
  15.384 +     * @return A pointer to the imported data, NULL if the import failed.
  15.385 +     *   The pointer to the scene remains in possession of the Importer
  15.386 +     *   instance. Use GetOrphanedScene() to take ownership of it.
  15.387 +     *
  15.388 +     * @note Assimp is able to determine the file format of a file
  15.389 +     * automatically.
  15.390 +     */
  15.391 +    const aiScene* ReadFile(
  15.392 +        const char* pFile,
  15.393 +        unsigned int pFlags);
  15.394 +
  15.395 +    // -------------------------------------------------------------------
  15.396 +    /** Reads the given file from a memory buffer and returns its
  15.397 +     *  contents if successful.
  15.398 +     *
  15.399 +     * If the call succeeds, the contents of the file are returned as a
  15.400 +     * pointer to an aiScene object. The returned data is intended to be
  15.401 +     * read-only, the importer object keeps ownership of the data and will
  15.402 +     * destroy it upon destruction. If the import fails, NULL is returned.
  15.403 +     * A human-readable error description can be retrieved by calling
  15.404 +     * GetErrorString(). The previous scene will be deleted during this call.
  15.405 +     * Calling this method doesn't affect the active IOSystem.
  15.406 +     * @param pBuffer Pointer to the file data
  15.407 +     * @param pLength Length of pBuffer, in bytes
  15.408 +     * @param pFlags Optional post processing steps to be executed after
  15.409 +     *   a successful import. Provide a bitwise combination of the
  15.410 +     *   #aiPostProcessSteps flags. If you wish to inspect the imported
  15.411 +     *   scene first in order to fine-tune your post-processing setup,
  15.412 +     *   consider to use #ApplyPostProcessing().
  15.413 +     * @param pHint An additional hint to the library. If this is a non
  15.414 +     *   empty string, the library looks for a loader to support
  15.415 +     *   the file extension specified by pHint and passes the file to
  15.416 +     *   the first matching loader. If this loader is unable to completely
  15.417 +     *   the request, the library continues and tries to determine the
  15.418 +     *   file format on its own, a task that may or may not be successful.
  15.419 +     *   Check the return value, and you'll know ...
  15.420 +     * @return A pointer to the imported data, NULL if the import failed.
  15.421 +     *   The pointer to the scene remains in possession of the Importer
  15.422 +     *   instance. Use GetOrphanedScene() to take ownership of it.
  15.423 +     *
  15.424 +     * @note This is a straightforward way to decode models from memory
  15.425 +     * buffers, but it doesn't handle model formats that spread their
  15.426 +     * data across multiple files or even directories. Examples include
  15.427 +     * OBJ or MD3, which outsource parts of their material info into
  15.428 +     * external scripts. If you need full functionality, provide
  15.429 +     * a custom IOSystem to make Assimp find these files and use
  15.430 +     * the regular ReadFile() API.
  15.431 +     */
  15.432 +    const aiScene* ReadFileFromMemory(
  15.433 +        const void* pBuffer,
  15.434 +        size_t pLength,
  15.435 +        unsigned int pFlags,
  15.436 +        const char* pHint = "");
  15.437 +
  15.438 +    // -------------------------------------------------------------------
  15.439 +    /** Apply post-processing to an already-imported scene.
  15.440 +     *
  15.441 +     *  This is strictly equivalent to calling #ReadFile() with the same
  15.442 +     *  flags. However, you can use this separate function to inspect
  15.443 +     *  the imported scene first to fine-tune your post-processing setup.
  15.444 +     *  @param pFlags Provide a bitwise combination of the
  15.445 +     *   #aiPostProcessSteps flags.
  15.446 +     *  @return A pointer to the post-processed data. This is still the
  15.447 +     *   same as the pointer returned by #ReadFile(). However, if
  15.448 +     *   post-processing fails, the scene could now be NULL.
  15.449 +     *   That's quite a rare case, post processing steps are not really
  15.450 +     *   designed to 'fail'. To be exact, the #aiProcess_ValidateDS
  15.451 +     *   flag is currently the only post processing step which can actually
  15.452 +     *   cause the scene to be reset to NULL.
  15.453 +     *
  15.454 +     *  @note The method does nothing if no scene is currently bound
  15.455 +     *    to the #Importer instance.  */
  15.456 +    const aiScene* ApplyPostProcessing(unsigned int pFlags);
  15.457 +
  15.458 +    const aiScene* ApplyCustomizedPostProcessing( BaseProcess *rootProcess, bool requestValidation );
  15.459 +
  15.460 +    // -------------------------------------------------------------------
  15.461 +    /** @brief Reads the given file and returns its contents if successful.
  15.462 +     *
  15.463 +     * This function is provided for backward compatibility.
  15.464 +     * See the const char* version for detailed docs.
  15.465 +     * @see ReadFile(const char*, pFlags)  */
  15.466 +    const aiScene* ReadFile(
  15.467 +        const std::string& pFile,
  15.468 +        unsigned int pFlags);
  15.469 +
  15.470 +    // -------------------------------------------------------------------
  15.471 +    /** Frees the current scene.
  15.472 +     *
  15.473 +     *  The function does nothing if no scene has previously been
  15.474 +     *  read via ReadFile(). FreeScene() is called automatically by the
  15.475 +     *  destructor and ReadFile() itself.  */
  15.476 +    void FreeScene( );
  15.477 +
  15.478 +    // -------------------------------------------------------------------
  15.479 +    /** Returns an error description of an error that occurred in ReadFile().
  15.480 +     *
  15.481 +     * Returns an empty string if no error occurred.
  15.482 +     * @return A description of the last error, an empty string if no
  15.483 +     *   error occurred. The string is never NULL.
  15.484 +     *
  15.485 +     * @note The returned function remains valid until one of the
  15.486 +     * following methods is called: #ReadFile(), #FreeScene(). */
  15.487 +    const char* GetErrorString() const;
  15.488 +
  15.489 +    // -------------------------------------------------------------------
  15.490 +    /** Returns the scene loaded by the last successful call to ReadFile()
  15.491 +     *
  15.492 +     * @return Current scene or NULL if there is currently no scene loaded */
  15.493 +    const aiScene* GetScene() const;
  15.494 +
  15.495 +    // -------------------------------------------------------------------
  15.496 +    /** Returns the scene loaded by the last successful call to ReadFile()
  15.497 +     *  and releases the scene from the ownership of the Importer
  15.498 +     *  instance. The application is now responsible for deleting the
  15.499 +     *  scene. Any further calls to GetScene() or GetOrphanedScene()
  15.500 +     *  will return NULL - until a new scene has been loaded via ReadFile().
  15.501 +     *
  15.502 +     * @return Current scene or NULL if there is currently no scene loaded
  15.503 +     * @note Use this method with maximal caution, and only if you have to.
  15.504 +     *   By design, aiScene's are exclusively maintained, allocated and
  15.505 +     *   deallocated by Assimp and no one else. The reasoning behind this
  15.506 +     *   is the golden rule that deallocations should always be done
  15.507 +     *   by the module that did the original allocation because heaps
  15.508 +     *   are not necessarily shared. GetOrphanedScene() enforces you
  15.509 +     *   to delete the returned scene by yourself, but this will only
  15.510 +     *   be fine if and only if you're using the same heap as assimp.
  15.511 +     *   On Windows, it's typically fine provided everything is linked
  15.512 +     *   against the multithreaded-dll version of the runtime library.
  15.513 +     *   It will work as well for static linkage with Assimp.*/
  15.514 +    aiScene* GetOrphanedScene();
  15.515 +
  15.516 +    // -------------------------------------------------------------------
  15.517 +    /** Returns whether a given file extension is supported by ASSIMP.
  15.518 +     *
  15.519 +     * @param szExtension Extension to be checked.
  15.520 +     *   Must include a trailing dot '.'. Example: ".3ds", ".md3".
  15.521 +     *   Cases-insensitive.
  15.522 +     * @return true if the extension is supported, false otherwise */
  15.523 +    bool IsExtensionSupported(const char* szExtension) const;
  15.524 +
  15.525 +    // -------------------------------------------------------------------
  15.526 +    /** @brief Returns whether a given file extension is supported by ASSIMP.
  15.527 +     *
  15.528 +     * This function is provided for backward compatibility.
  15.529 +     * See the const char* version for detailed and up-to-date docs.
  15.530 +     * @see IsExtensionSupported(const char*) */
  15.531 +    inline bool IsExtensionSupported(const std::string& szExtension) const;
  15.532 +
  15.533 +    // -------------------------------------------------------------------
  15.534 +    /** Get a full list of all file extensions supported by ASSIMP.
  15.535 +     *
  15.536 +     * If a file extension is contained in the list this does of course not
  15.537 +     * mean that ASSIMP is able to load all files with this extension ---
  15.538 +     * it simply means there is an importer loaded which claims to handle
  15.539 +     * files with this file extension.
  15.540 +     * @param szOut String to receive the extension list.
  15.541 +     *   Format of the list: "*.3ds;*.obj;*.dae". This is useful for
  15.542 +     *   use with the WinAPI call GetOpenFileName(Ex). */
  15.543 +    void GetExtensionList(aiString& szOut) const;
  15.544 +
  15.545 +    // -------------------------------------------------------------------
  15.546 +    /** @brief Get a full list of all file extensions supported by ASSIMP.
  15.547 +     *
  15.548 +     * This function is provided for backward compatibility.
  15.549 +     * See the aiString version for detailed and up-to-date docs.
  15.550 +     * @see GetExtensionList(aiString&)*/
  15.551 +    inline void GetExtensionList(std::string& szOut) const;
  15.552 +
  15.553 +    // -------------------------------------------------------------------
  15.554 +    /** Get the number of importers currently registered with Assimp. */
  15.555 +    size_t GetImporterCount() const;
  15.556 +
  15.557 +    // -------------------------------------------------------------------
  15.558 +    /** Get meta data for the importer corresponding to a specific index..
  15.559 +    *
  15.560 +    *  For the declaration of #aiImporterDesc, include <assimp/importerdesc.h>.
  15.561 +    *  @param index Index to query, must be within [0,GetImporterCount())
  15.562 +    *  @return Importer meta data structure, NULL if the index does not
  15.563 +    *     exist or if the importer doesn't offer meta information (
  15.564 +    *     importers may do this at the cost of being hated by their peers).*/
  15.565 +    const aiImporterDesc* GetImporterInfo(size_t index) const;
  15.566 +
  15.567 +    // -------------------------------------------------------------------
  15.568 +    /** Find the importer corresponding to a specific index.
  15.569 +    *
  15.570 +    *  @param index Index to query, must be within [0,GetImporterCount())
  15.571 +    *  @return Importer instance. NULL if the index does not
  15.572 +    *     exist. */
  15.573 +    BaseImporter* GetImporter(size_t index) const;
  15.574 +
  15.575 +    // -------------------------------------------------------------------
  15.576 +    /** Find the importer corresponding to a specific file extension.
  15.577 +    *
  15.578 +    *  This is quite similar to #IsExtensionSupported except a
  15.579 +    *  BaseImporter instance is returned.
  15.580 +    *  @param szExtension Extension to check for. The following formats
  15.581 +    *    are recognized (BAH being the file extension): "BAH" (comparison
  15.582 +    *    is case-insensitive), ".bah", "*.bah" (wild card and dot
  15.583 +    *    characters at the beginning of the extension are skipped).
  15.584 +    *  @return NULL if no importer is found*/
  15.585 +    BaseImporter* GetImporter (const char* szExtension) const;
  15.586 +
  15.587 +    // -------------------------------------------------------------------
  15.588 +    /** Find the importer index corresponding to a specific file extension.
  15.589 +    *
  15.590 +    *  @param szExtension Extension to check for. The following formats
  15.591 +    *    are recognized (BAH being the file extension): "BAH" (comparison
  15.592 +    *    is case-insensitive), ".bah", "*.bah" (wild card and dot
  15.593 +    *    characters at the beginning of the extension are skipped).
  15.594 +    *  @return (size_t)-1 if no importer is found */
  15.595 +    size_t GetImporterIndex (const char* szExtension) const;
  15.596 +
  15.597 +    // -------------------------------------------------------------------
  15.598 +    /** Returns the storage allocated by ASSIMP to hold the scene data
  15.599 +     * in memory.
  15.600 +     *
  15.601 +     * This refers to the currently loaded file, see #ReadFile().
  15.602 +     * @param in Data structure to be filled.
  15.603 +     * @note The returned memory statistics refer to the actual
  15.604 +     *   size of the use data of the aiScene. Heap-related overhead
  15.605 +     *   is (naturally) not included.*/
  15.606 +    void GetMemoryRequirements(aiMemoryInfo& in) const;
  15.607 +
  15.608 +    // -------------------------------------------------------------------
  15.609 +    /** Enables "extra verbose" mode.
  15.610 +     *
  15.611 +     * 'Extra verbose' means the data structure is validated after *every*
  15.612 +     * single post processing step to make sure everyone modifies the data
  15.613 +     * structure in a well-defined manner. This is a debug feature and not
  15.614 +     * intended for use in production environments. */
  15.615 +    void SetExtraVerbose(bool bDo);
  15.616 +
  15.617 +    // -------------------------------------------------------------------
  15.618 +    /** Private, do not use. */
  15.619 +    ImporterPimpl* Pimpl() { return pimpl; }
  15.620 +    const ImporterPimpl* Pimpl() const { return pimpl; }
  15.621 +
  15.622 +protected:
  15.623 +
  15.624 +    // Just because we don't want you to know how we're hacking around.
  15.625 +    ImporterPimpl* pimpl;
  15.626 +}; //! class Importer
  15.627 +
  15.628 +
  15.629 +// ----------------------------------------------------------------------------
  15.630 +// For compatibility, the interface of some functions taking a std::string was
  15.631 +// changed to const char* to avoid crashes between binary incompatible STL
  15.632 +// versions. This code her is inlined,  so it shouldn't cause any problems.
  15.633 +// ----------------------------------------------------------------------------
  15.634 +
  15.635 +// ----------------------------------------------------------------------------
  15.636 +AI_FORCE_INLINE const aiScene* Importer::ReadFile( const std::string& pFile,unsigned int pFlags){
  15.637 +    return ReadFile(pFile.c_str(),pFlags);
  15.638 +}
  15.639 +// ----------------------------------------------------------------------------
  15.640 +AI_FORCE_INLINE void Importer::GetExtensionList(std::string& szOut) const   {
  15.641 +    aiString s;
  15.642 +    GetExtensionList(s);
  15.643 +    szOut = s.data;
  15.644 +}
  15.645 +// ----------------------------------------------------------------------------
  15.646 +AI_FORCE_INLINE bool Importer::IsExtensionSupported(const std::string& szExtension) const   {
  15.647 +    return IsExtensionSupported(szExtension.c_str());
  15.648 +}
  15.649 +
  15.650 +} // !namespace Assimp
  15.651 +
  15.652 +#endif // AI_ASSIMP_HPP_INC

    16.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    16.2 +++ b/include/miniassimp/LogStream.hpp	Mon Jan 28 18:19:26 2019 +0200
    16.3 @@ -0,0 +1,111 @@
    16.4 +/*
    16.5 +Open Asset Import Library (assimp)
    16.6 +----------------------------------------------------------------------
    16.7 +
    16.8 +Copyright (c) 2006-2018, assimp team
    16.9 +
   16.10 +
   16.11 +All rights reserved.
   16.12 +
   16.13 +Redistribution and use of this software in source and binary forms,
   16.14 +with or without modification, are permitted provided that the
   16.15 +following conditions are met:
   16.16 +
   16.17 +* Redistributions of source code must retain the above
   16.18 +  copyright notice, this list of conditions and the
   16.19 +  following disclaimer.
   16.20 +
   16.21 +* Redistributions in binary form must reproduce the above
   16.22 +  copyright notice, this list of conditions and the
   16.23 +  following disclaimer in the documentation and/or other
   16.24 +  materials provided with the distribution.
   16.25 +
   16.26 +* Neither the name of the assimp team, nor the names of its
   16.27 +  contributors may be used to endorse or promote products
   16.28 +  derived from this software without specific prior
   16.29 +  written permission of the assimp team.
   16.30 +
   16.31 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   16.32 +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   16.33 +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   16.34 +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   16.35 +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   16.36 +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   16.37 +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   16.38 +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   16.39 +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   16.40 +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   16.41 +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   16.42 +
   16.43 +----------------------------------------------------------------------
   16.44 +*/
   16.45 +
   16.46 +/** @file LogStream.hpp
   16.47 + *  @brief Abstract base class 'LogStream', representing an output log stream.
   16.48 + */
   16.49 +#ifndef INCLUDED_AI_LOGSTREAM_H
   16.50 +#define INCLUDED_AI_LOGSTREAM_H
   16.51 +
   16.52 +#include "types.h"
   16.53 +
   16.54 +namespace Assimp    {
   16.55 +
   16.56 +class IOSystem;
   16.57 +
   16.58 +// ------------------------------------------------------------------------------------
   16.59 +/** @brief CPP-API: Abstract interface for log stream implementations.
   16.60 + *
   16.61 + *  Several default implementations are provided, see #aiDefaultLogStream for more
   16.62 + *  details. Writing your own implementation of LogStream is just necessary if these
   16.63 + *  are not enough for your purpose. */
   16.64 +class ASSIMP_API LogStream
   16.65 +#ifndef SWIG
   16.66 +    : public Intern::AllocateFromAssimpHeap
   16.67 +#endif
   16.68 +{
   16.69 +protected:
   16.70 +    /** @brief  Default constructor */
   16.71 +    LogStream() AI_NO_EXCEPT;
   16.72 +
   16.73 +public:
   16.74 +    /** @brief  Virtual destructor  */
   16.75 +    virtual ~LogStream();
   16.76 +
   16.77 +    // -------------------------------------------------------------------
   16.78 +    /** @brief  Overwrite this for your own output methods
   16.79 +     *
   16.80 +     *  Log messages *may* consist of multiple lines and you shouldn't
   16.81 +     *  expect a consistent formatting. If you want custom formatting
   16.82 +     *  (e.g. generate HTML), supply a custom instance of Logger to
   16.83 +     *  #DefaultLogger:set(). Usually you can *expect* that a log message
   16.84 +     *  is exactly one line and terminated with a single \n character.
   16.85 +     *  @param message Message to be written */
   16.86 +    virtual void write(const char* message) = 0;
   16.87 +
   16.88 +    // -------------------------------------------------------------------
   16.89 +    /** @brief Creates a default log stream
   16.90 +     *  @param streams Type of the default stream
   16.91 +     *  @param name For aiDefaultLogStream_FILE: name of the output file
   16.92 +     *  @param io For aiDefaultLogStream_FILE: IOSystem to be used to open the output
   16.93 +     *   file. Pass NULL for the default implementation.
   16.94 +     *  @return New LogStream instance.  */
   16.95 +    static LogStream* createDefaultStream(aiDefaultLogStream stream,
   16.96 +        const char* name = "AssimpLog.txt",
   16.97 +        IOSystem* io = 0 );
   16.98 +
   16.99 +}; // !class LogStream
  16.100 +
  16.101 +inline
  16.102 +LogStream::LogStream() AI_NO_EXCEPT {
  16.103 +    // empty
  16.104 +}
  16.105 +
  16.106 +inline
  16.107 +LogStream::~LogStream() {
  16.108 +    // empty
  16.109 +}
  16.110 +
  16.111 +// ------------------------------------------------------------------------------------
  16.112 +} // Namespace Assimp
  16.113 +
  16.114 +#endif

    17.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    17.2 +++ b/include/miniassimp/Logger.hpp	Mon Jan 28 18:19:26 2019 +0200
    17.3 @@ -0,0 +1,305 @@
    17.4 +/*
    17.5 +Open Asset Import Library (assimp)
    17.6 +----------------------------------------------------------------------
    17.7 +
    17.8 +Copyright (c) 2006-2018, assimp team
    17.9 +
   17.10 +
   17.11 +All rights reserved.
   17.12 +
   17.13 +Redistribution and use of this software in source and binary forms,
   17.14 +with or without modification, are permitted provided that the
   17.15 +following conditions are met:
   17.16 +
   17.17 +* Redistributions of source code must retain the above
   17.18 +  copyright notice, this list of conditions and the
   17.19 +  following disclaimer.
   17.20 +
   17.21 +* Redistributions in binary form must reproduce the above
   17.22 +  copyright notice, this list of conditions and the
   17.23 +  following disclaimer in the documentation and/or other
   17.24 +  materials provided with the distribution.
   17.25 +
   17.26 +* Neither the name of the assimp team, nor the names of its
   17.27 +  contributors may be used to endorse or promote products
   17.28 +  derived from this software without specific prior
   17.29 +  written permission of the assimp team.
   17.30 +
   17.31 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   17.32 +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   17.33 +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   17.34 +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   17.35 +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   17.36 +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   17.37 +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   17.38 +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   17.39 +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   17.40 +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   17.41 +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   17.42 +
   17.43 +----------------------------------------------------------------------
   17.44 +*/
   17.45 +
   17.46 +/** @file Logger.hpp
   17.47 + *  @brief Abstract base class 'Logger', base of the logging system.
   17.48 + */
   17.49 +#ifndef INCLUDED_AI_LOGGER_H
   17.50 +#define INCLUDED_AI_LOGGER_H
   17.51 +
   17.52 +#include <miniassimp/types.h>
   17.53 +#include <miniassimp/TinyFormatter.h>
   17.54 +
   17.55 +namespace Assimp {
   17.56 +
   17.57 +class LogStream;
   17.58 +
   17.59 +// Maximum length of a log message. Longer messages are rejected.
   17.60 +#define MAX_LOG_MESSAGE_LENGTH 1024u
   17.61 +
   17.62 +// ----------------------------------------------------------------------------------
   17.63 +/** @brief CPP-API: Abstract interface for logger implementations.
   17.64 + *  Assimp provides a default implementation and uses it for almost all
   17.65 + *  logging stuff ('DefaultLogger'). This class defines just basic logging
   17.66 + *  behavior and is not of interest for you. Instead, take a look at #DefaultLogger. */
   17.67 +class ASSIMP_API Logger
   17.68 +#ifndef SWIG
   17.69 +    : public Intern::AllocateFromAssimpHeap
   17.70 +#endif
   17.71 +{
   17.72 +public:
   17.73 +
   17.74 +    // ----------------------------------------------------------------------
   17.75 +    /** @enum   LogSeverity
   17.76 +     *  @brief  Log severity to describe the granularity of logging.
   17.77 +     */
   17.78 +    enum LogSeverity {
   17.79 +        NORMAL,     //!< Normal granularity of logging
   17.80 +        VERBOSE     //!< Debug infos will be logged, too
   17.81 +    };
   17.82 +
   17.83 +    // ----------------------------------------------------------------------
   17.84 +    /** @enum   ErrorSeverity
   17.85 +     *  @brief  Description for severity of a log message.
   17.86 +     *
   17.87 +     *  Every LogStream has a bitwise combination of these flags.
   17.88 +     *  A LogStream doesn't receive any messages of a specific type
   17.89 +     *  if it doesn't specify the corresponding ErrorSeverity flag.
   17.90 +     */
   17.91 +    enum ErrorSeverity {
   17.92 +        Debugging   = 1,    //!< Debug log message
   17.93 +        Info        = 2,    //!< Info log message
   17.94 +        Warn        = 4,    //!< Warn log message
   17.95 +        Err         = 8     //!< Error log message
   17.96 +    };
   17.97 +
   17.98 +public:
   17.99 +
  17.100 +    /** @brief  Virtual destructor */
  17.101 +    virtual ~Logger();
  17.102 +
  17.103 +    // ----------------------------------------------------------------------
  17.104 +    /** @brief  Writes a debug message
  17.105 +     *   @param message Debug message*/
  17.106 +    void debug(const char* message);
  17.107 +    void debug(const std::string &message);
  17.108 +
  17.109 +    // ----------------------------------------------------------------------
  17.110 +    /** @brief  Writes a info message
  17.111 +     *  @param  message Info message*/
  17.112 +    void info(const char* message);
  17.113 +    void info(const std::string &message);
  17.114 +
  17.115 +    // ----------------------------------------------------------------------
  17.116 +    /** @brief  Writes a warning message
  17.117 +     *  @param  message Warn message*/
  17.118 +    void warn(const char* message);
  17.119 +    void warn(const std::string &message);
  17.120 +
  17.121 +    // ----------------------------------------------------------------------
  17.122 +    /** @brief  Writes an error message
  17.123 +     *  @param  message Error message*/
  17.124 +    void error(const char* message);
  17.125 +    void error(const std::string &message);
  17.126 +
  17.127 +    // ----------------------------------------------------------------------
  17.128 +    /** @brief  Set a new log severity.
  17.129 +     *  @param  log_severity New severity for logging*/
  17.130 +    void setLogSeverity(LogSeverity log_severity);
  17.131 +
  17.132 +    // ----------------------------------------------------------------------
  17.133 +    /** @brief Get the current log severity*/
  17.134 +    LogSeverity getLogSeverity() const;
  17.135 +
  17.136 +    // ----------------------------------------------------------------------
  17.137 +    /** @brief  Attach a new log-stream
  17.138 +     *
  17.139 +     *  The logger takes ownership of the stream and is responsible
  17.140 +     *  for its destruction (which is done using ::delete when the logger
  17.141 +     *  itself is destroyed). Call detachStream to detach a stream and to
  17.142 +     *  gain ownership of it again.
  17.143 +     *   @param pStream  Log-stream to attach
  17.144 +     *  @param severity  Message filter, specified which types of log
  17.145 +     *    messages are dispatched to the stream. Provide a bitwise
  17.146 +     *    combination of the ErrorSeverity flags.
  17.147 +     *  @return true if the stream has been attached, false otherwise.*/
  17.148 +    virtual bool attachStream(LogStream *pStream,
  17.149 +        unsigned int severity = Debugging | Err | Warn | Info) = 0;
  17.150 +
  17.151 +    // ----------------------------------------------------------------------
  17.152 +    /** @brief  Detach a still attached stream from the logger (or
  17.153 +     *          modify the filter flags bits)
  17.154 +     *   @param pStream Log-stream instance for detaching
  17.155 +     *  @param severity Provide a bitwise combination of the ErrorSeverity
  17.156 +     *    flags. This value is &~ed with the current flags of the stream,
  17.157 +     *    if the result is 0 the stream is detached from the Logger and
  17.158 +     *    the caller retakes the possession of the stream.
  17.159 +     *  @return true if the stream has been detached, false otherwise.*/
  17.160 +    virtual bool detatchStream(LogStream *pStream,
  17.161 +        unsigned int severity = Debugging | Err | Warn | Info) = 0;
  17.162 +
  17.163 +protected:
  17.164 +    /**
  17.165 +     *  Default constructor
  17.166 +     */
  17.167 +    Logger() AI_NO_EXCEPT;
  17.168 +
  17.169 +    /**
  17.170 +     *  Construction with a given log severity
  17.171 +     */
  17.172 +    explicit Logger(LogSeverity severity);
  17.173 +
  17.174 +    // ----------------------------------------------------------------------
  17.175 +    /**
  17.176 +     *  @brief Called as a request to write a specific debug message
  17.177 +     *  @param  message Debug message. Never longer than
  17.178 +     *    MAX_LOG_MESSAGE_LENGTH characters (excluding the '0').
  17.179 +     *  @note  The message string is only valid until the scope of
  17.180 +     *    the function is left.
  17.181 +     */
  17.182 +    virtual void OnDebug(const char* message)= 0;
  17.183 +
  17.184 +    // ----------------------------------------------------------------------
  17.185 +    /**
  17.186 +     *  @brief Called as a request to write a specific info message
  17.187 +     *  @param  message Info message. Never longer than
  17.188 +     *    MAX_LOG_MESSAGE_LENGTH characters (ecxluding the '0').
  17.189 +     *  @note  The message string is only valid until the scope of
  17.190 +     *    the function is left.
  17.191 +     */
  17.192 +    virtual void OnInfo(const char* message) = 0;
  17.193 +
  17.194 +    // ----------------------------------------------------------------------
  17.195 +    /**
  17.196 +     *  @brief Called as a request to write a specific warn message
  17.197 +     *  @param  message Warn message. Never longer than
  17.198 +     *    MAX_LOG_MESSAGE_LENGTH characters (exluding the '0').
  17.199 +     *  @note  The message string is only valid until the scope of
  17.200 +     *    the function is left.
  17.201 +     */
  17.202 +    virtual void OnWarn(const char* essage) = 0;
  17.203 +
  17.204 +    // ----------------------------------------------------------------------
  17.205 +    /**
  17.206 +     *  @brief Called as a request to write a specific error message
  17.207 +     *  @param  message Error message. Never longer than
  17.208 +     *    MAX_LOG_MESSAGE_LENGTH characters (exluding the '0').
  17.209 +     *  @note  The message string is only valid until the scope of
  17.210 +     *    the function is left.
  17.211 +     */
  17.212 +    virtual void OnError(const char* message) = 0;
  17.213 +
  17.214 +protected:
  17.215 +    LogSeverity m_Severity;
  17.216 +};
  17.217 +
  17.218 +// ----------------------------------------------------------------------------------
  17.219 +//  Default constructor
  17.220 +inline
  17.221 +Logger::Logger() AI_NO_EXCEPT
  17.222 +: m_Severity(NORMAL) {
  17.223 +    // empty
  17.224 +}
  17.225 +
  17.226 +// ----------------------------------------------------------------------------------
  17.227 +//  Virtual destructor
  17.228 +inline
  17.229 +Logger::~Logger() {
  17.230 +    // empty
  17.231 +}
  17.232 +
  17.233 +// ----------------------------------------------------------------------------------
  17.234 +// Construction with given logging severity
  17.235 +inline
  17.236 +Logger::Logger(LogSeverity severity)
  17.237 +: m_Severity(severity) {
  17.238 +    // empty
  17.239 +}
  17.240 +
  17.241 +// ----------------------------------------------------------------------------------
  17.242 +// Log severity setter
  17.243 +inline
  17.244 +void Logger::setLogSeverity(LogSeverity log_severity){
  17.245 +    m_Severity = log_severity;
  17.246 +}
  17.247 +
  17.248 +// ----------------------------------------------------------------------------------
  17.249 +// Log severity getter
  17.250 +inline
  17.251 +Logger::LogSeverity Logger::getLogSeverity() const {
  17.252 +    return m_Severity;
  17.253 +}
  17.254 +
  17.255 +// ----------------------------------------------------------------------------------
  17.256 +inline
  17.257 +void Logger::debug(const std::string &message) {
  17.258 +    return debug(message.c_str());
  17.259 +}
  17.260 +
  17.261 +// ----------------------------------------------------------------------------------
  17.262 +inline
  17.263 +void Logger::error(const std::string &message) {
  17.264 +    return error(message.c_str());
  17.265 +}
  17.266 +
  17.267 +// ----------------------------------------------------------------------------------
  17.268 +inline
  17.269 +void Logger::warn(const std::string &message) {
  17.270 +    return warn(message.c_str());
  17.271 +}
  17.272 +
  17.273 +// ----------------------------------------------------------------------------------
  17.274 +inline
  17.275 +void Logger::info(const std::string &message) {
  17.276 +    return info(message.c_str());
  17.277 +}
  17.278 +
  17.279 +// ------------------------------------------------------------------------------------------------
  17.280 +#define ASSIMP_LOG_WARN_F(string,...)\
  17.281 +    DefaultLogger::get()->warn((Formatter::format(string),__VA_ARGS__))
  17.282 +
  17.283 +#define ASSIMP_LOG_ERROR_F(string,...)\
  17.284 +    DefaultLogger::get()->error((Formatter::format(string),__VA_ARGS__))
  17.285 +
  17.286 +#define ASSIMP_LOG_DEBUG_F(string,...)\
  17.287 +    DefaultLogger::get()->debug((Formatter::format(string),__VA_ARGS__))
  17.288 +
  17.289 +#define ASSIMP_LOG_INFO_F(string,...)\
  17.290 +    DefaultLogger::get()->info((Formatter::format(string),__VA_ARGS__))
  17.291 +
  17.292 +
  17.293 +#define ASSIMP_LOG_WARN(string)\
  17.294 +    DefaultLogger::get()->warn(string)
  17.295 +
  17.296 +#define ASSIMP_LOG_ERROR(string)\
  17.297 +    DefaultLogger::get()->error(string)
  17.298 +
  17.299 +#define ASSIMP_LOG_DEBUG(string)\
  17.300 +    DefaultLogger::get()->debug(string)
  17.301 +
  17.302 +#define ASSIMP_LOG_INFO(string)\
  17.303 +    DefaultLogger::get()->info(string)
  17.304 +
  17.305 +
  17.306 +} // Namespace Assimp
  17.307 +
  17.308 +#endif // !! INCLUDED_AI_LOGGER_H