/************************************************************************************************** * Copyright (c) 2017 Epsilon Kran GmbH * Christophorusstraße 30, 5061 Elsbethen-Glasenbach, Austria. epsilon@palfinger.com *************************************************************************************************/ /**********************************************************************************************//** * \file base.h * * \latexonly \hypertarget{base}{} \endlatexonly * * * \brief base task class definition. * * * * \section base_sec Task Handling * * Each object of this type could be called cyclic by the object Handler. * The user doesn't need to handle the timing. Therefore are 4 * functions available which could be derived: * - \ref base.init * - \ref base.pre * - \ref base.work * - \ref base.post * - \ref base.idle * * *************************************************************************************************/ /************************************************************************************************** * * I N C L U D E S * *************************************************************************************************/ /* * global.h * * Created on: 02.05.2017 * Author: WallnerR */ /*#define EPS_DEBUG Activate Debug Variables */ /*#define X2C_INTERFACE This activates the X2C Interface for Debugging and Tracing */ /*#define SER_DEBUG 0 Activate Serial Interface for Debugging with printf */ /*#define SIMULATION This Activates the Hardware Simulation to compile the project on the pc */ /* * If Set Debug is enabled, the X2C Interface has to be disabled! */ /* * Global Defines */ /*****************************************************************************/ /* STDIO.H v5.1.6 */ /* */ /* Copyright (c) 1993-2014 Texas Instruments Incorporated */ /* http://www.ti.com/ */ /* */ /* Redistribution and use in source and binary forms, with or without */ /* modification, are permitted provided that the following conditions */ /* are met: */ /* */ /* Redistributions of source code must retain the above copyright */ /* notice, this list of conditions and the following disclaimer. */ /* */ /* Redistributions in binary form must reproduce the above copyright */ /* notice, this list of conditions and the following disclaimer in */ /* the documentation and/or other materials provided with the */ /* distribution. */ /* */ /* Neither the name of Texas Instruments Incorporated nor the names */ /* of its contributors may be used to endorse or promote products */ /* derived from this software without specific prior written */ /* permission. */ /* */ /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR */ /* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ /* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */ /* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */ /* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY */ /* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */ /* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */ /* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* */ /*****************************************************************************/ /*****************************************************************************/ /* linkage.h v5.1.6 */ /* */ /* Copyright (c) 1998-2014 Texas Instruments Incorporated */ /* http://www.ti.com/ */ /* */ /* Redistribution and use in source and binary forms, with or without */ /* modification, are permitted provided that the following conditions */ /* are met: */ /* */ /* Redistributions of source code must retain the above copyright */ /* notice, this list of conditions and the following disclaimer. */ /* */ /* Redistributions in binary form must reproduce the above copyright */ /* notice, this list of conditions and the following disclaimer in */ /* the documentation and/or other materials provided with the */ /* distribution. */ /* */ /* Neither the name of Texas Instruments Incorporated nor the names */ /* of its contributors may be used to endorse or promote products */ /* derived from this software without specific prior written */ /* permission. */ /* */ /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR */ /* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ /* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */ /* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */ /* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY */ /* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */ /* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */ /* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* */ /*****************************************************************************/ /* No modifiers are needed to access code or data */ /*--------------------------------------------------------------------------*/ /* Define _IDECL ==> how inline functions are declared */ /*--------------------------------------------------------------------------*/ /*****************************************************************************/ /* stdarg.h v5.1.6 */ /* */ /* Copyright (c) 1996-2014 Texas Instruments Incorporated */ /* http://www.ti.com/ */ /* */ /* Redistribution and use in source and binary forms, with or without */ /* modification, are permitted provided that the following conditions */ /* are met: */ /* */ /* Redistributions of source code must retain the above copyright */ /* notice, this list of conditions and the following disclaimer. */ /* */ /* Redistributions in binary form must reproduce the above copyright */ /* notice, this list of conditions and the following disclaimer in */ /* the documentation and/or other materials provided with the */ /* distribution. */ /* */ /* Neither the name of Texas Instruments Incorporated nor the names */ /* of its contributors may be used to endorse or promote products */ /* derived from this software without specific prior written */ /* permission. */ /* */ /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR */ /* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ /* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */ /* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */ /* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY */ /* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */ /* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */ /* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* */ /*****************************************************************************/ namespace std { typedef struct __va_list { void * __ap; } va_list; } /* namespace std */ using std::va_list; /*---------------------------------------------------------------------------*/ /* Attributes are only available in relaxed ANSI mode. */ /*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/ /* A header file conforming to ARM CLIB ABI (GENC-003539), should */ /* define _AEABI_PORTABLE when _AEABI_PORTABILITY_LEVEL is defined. */ /*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/ /* The macro definition that guards CLIB ABI (GENC-003539) requirements. */ /*---------------------------------------------------------------------------*/ //---------------------------------------------------------------------------- // IS RECOMMENDED OVER . IS PROVIDED FOR // COMPATIBILITY WITH C AND THIS USAGE IS DEPRECATED IN C++ //---------------------------------------------------------------------------- extern "C" namespace std { /****************************************************************************/ /* TYPES THAT ANSI REQUIRES TO BE DEFINED */ /****************************************************************************/ typedef unsigned size_t; typedef struct { int fd; /* File descriptor */ unsigned char* buf; /* Pointer to start of buffer */ unsigned char* pos; /* Position in buffer */ unsigned char* bufend; /* Pointer to end of buffer */ unsigned char* buff_stop; /* Pointer to last read char in buffer */ unsigned int flags; /* File status flags (see below) */ } FILE; typedef long fpos_t; /****************************************************************************/ /* DEVICE AND STREAM RELATED MACROS */ /****************************************************************************/ /****************************************************************************/ /* MACROS THAT DEFINE AND USE FILE STATUS FLAGS */ /****************************************************************************/ /****************************************************************************/ /* MACROS THAT ANSI REQUIRES TO BE DEFINED */ /****************************************************************************/ /******** END OF ANSI MACROS ************************************************/ /****************************************************************************/ /* DEVICE AND STREAM RELATED DATA STRUCTURES AND MACROS */ /****************************************************************************/ extern FILE _ftable[10]; extern char __TI_tmpnams[10][16]; /****************************************************************************/ /* FUNCTION DEFINITIONS - ANSI */ /****************************************************************************/ /****************************************************************************/ /* OPERATIONS ON FILES */ /****************************************************************************/ extern int remove(const char *_file); extern int rename(const char *_old, const char *_new); extern FILE *tmpfile(void); extern char *tmpnam(char *_s); /****************************************************************************/ /* FILE ACCESS FUNCTIONS */ /****************************************************************************/ extern int fclose(FILE *_fp); extern FILE *fopen(const char *_fname, const char *_mode); extern FILE *freopen(const char *_fname, const char *_mode, register FILE *_fp); extern void setbuf(register FILE *_fp, char *_buf); extern int setvbuf(register FILE *_fp, register char *_buf, register int _type, register size_t _size); extern int fflush(register FILE *_fp); /****************************************************************************/ /* FORMATTED INPUT/OUTPUT FUNCTIONS */ /****************************************************************************/ extern int fprintf(FILE *_fp, const char *_format, ...) ; extern int fscanf(FILE *_fp, const char *_fmt, ...) ; extern int printf(const char *_format, ...) ; extern int scanf(const char *_fmt, ...) ; extern int sprintf(char *_string, const char *_format, ...) ; extern int snprintf(char *_string, size_t _n, const char *_format, ...) ; extern int sscanf(const char *_str, const char *_fmt, ...) ; extern int vfprintf(FILE *_fp, const char *_format, va_list _ap) ; extern int vfscanf(FILE *_fp, const char *_fmt, va_list _ap) ; extern int vprintf(const char *_format, va_list _ap) ; extern int vscanf(const char *_format, va_list _ap) ; extern int vsprintf(char *_string, const char *_format, va_list _ap) ; extern int vsnprintf(char *_string, size_t _n, const char *_format, va_list _ap) ; extern int vsscanf(const char *_str, const char *_fmt, va_list _ap) ; /****************************************************************************/ /* CHARACTER INPUT/OUTPUT FUNCTIONS */ /****************************************************************************/ extern int fgetc(register FILE *_fp); extern char *fgets(char *_ptr, register int _size, register FILE *_fp); extern int fputc(int _c, register FILE *_fp); extern int fputs(const char *_ptr, register FILE *_fp); extern int getc(FILE *_p); extern int getchar(void); extern char *gets(char *_ptr); extern int putc(int _x, FILE *_fp); extern int putchar(int _x); extern int puts(const char *_ptr); extern int ungetc(int _c, register FILE *_fp); /****************************************************************************/ /* DIRECT INPUT/OUTPUT FUNCTIONS */ /****************************************************************************/ extern size_t fread(void *_ptr, size_t _size, size_t _count, FILE *_fp); extern size_t fwrite(const void *_ptr, size_t _size, size_t _count, register FILE *_fp); /****************************************************************************/ /* FILE POSITIONING FUNCTIONS */ /****************************************************************************/ extern int fgetpos(FILE *_fp, fpos_t *_pos); extern int fseek(register FILE *_fp, long _offset, int _ptrname); extern int fsetpos(FILE *_fp, const fpos_t *_pos); extern long ftell(FILE *_fp); extern void rewind(register FILE *_fp); /****************************************************************************/ /* ERROR-HANDLING FUNCTIONS */ /****************************************************************************/ extern void clearerr(FILE *_fp); extern int feof(FILE *_fp); extern int ferror(FILE *_fp); extern void perror(const char *_s); } /* extern "C" namespace std */ using std::size_t; using std::FILE; using std::fpos_t; using std::_ftable; using std::__TI_tmpnams; using std::remove; using std::rename; using std::tmpfile; using std::tmpnam; using std::fclose; using std::fopen; using std::freopen; using std::setbuf; using std::setvbuf; using std::fflush; using std::fprintf; using std::fscanf; using std::printf; using std::scanf; using std::sprintf; using std::snprintf; using std::sscanf; using std::vfprintf; using std::vprintf; using std::vsprintf; using std::vsnprintf; using std::fgetc; using std::fgets; using std::fputc; using std::fputs; using std::getc; using std::getchar; using std::gets; using std::putc; using std::putchar; using std::puts; using std::ungetc; using std::fread; using std::fwrite; using std::fgetpos; using std::fseek; using std::fsetpos; using std::ftell; using std::rewind; using std::clearerr; using std::feof; using std::ferror; using std::perror; /*****************************************************************************/ /* string.h v5.1.6 */ /* */ /* Copyright (c) 1993-2014 Texas Instruments Incorporated */ /* http://www.ti.com/ */ /* */ /* Redistribution and use in source and binary forms, with or without */ /* modification, are permitted provided that the following conditions */ /* are met: */ /* */ /* Redistributions of source code must retain the above copyright */ /* notice, this list of conditions and the following disclaimer. */ /* */ /* Redistributions in binary form must reproduce the above copyright */ /* notice, this list of conditions and the following disclaimer in */ /* the documentation and/or other materials provided with the */ /* distribution. */ /* */ /* Neither the name of Texas Instruments Incorporated nor the names */ /* of its contributors may be used to endorse or promote products */ /* derived from this software without specific prior written */ /* permission. */ /* */ /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR */ /* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ /* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */ /* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */ /* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY */ /* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */ /* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */ /* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* */ /*****************************************************************************/ //---------------------------------------------------------------------------- // IS RECOMMENDED OVER . IS PROVIDED FOR // COMPATIBILITY WITH C AND THIS USAGE IS DEPRECATED IN C++ //---------------------------------------------------------------------------- extern "C" namespace std { /*****************************************************************************/ /* linkage.h v5.1.6 */ /* */ /* Copyright (c) 1998-2014 Texas Instruments Incorporated */ /* http://www.ti.com/ */ /* */ /* Redistribution and use in source and binary forms, with or without */ /* modification, are permitted provided that the following conditions */ /* are met: */ /* */ /* Redistributions of source code must retain the above copyright */ /* notice, this list of conditions and the following disclaimer. */ /* */ /* Redistributions in binary form must reproduce the above copyright */ /* notice, this list of conditions and the following disclaimer in */ /* the documentation and/or other materials provided with the */ /* distribution. */ /* */ /* Neither the name of Texas Instruments Incorporated nor the names */ /* of its contributors may be used to endorse or promote products */ /* derived from this software without specific prior written */ /* permission. */ /* */ /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR */ /* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ /* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */ /* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */ /* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY */ /* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */ /* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */ /* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* */ /*****************************************************************************/ size_t strlen(const char *_string); char *strcpy(char *_dest, const char *_src); char *strncpy(char *_to, const char *_from, size_t _n); char *strcat(char *_string1, const char *_string2); char *strncat(char *_to, const char *_from, size_t _n); char *strchr(const char *_string, int _c); char *strrchr(const char *_string, int _c); int strcmp(const char *_string1, const char *_string2); int strncmp(const char *_string1, const char *_string2, size_t _n); int strcoll(const char *_string1, const char *_string2); size_t strxfrm(char *_to, const char *_from, size_t _n); char *strpbrk(const char *_string, const char *_chs); size_t strspn(const char *_string, const char *_chs); size_t strcspn(const char *_string, const char *_chs); char *strstr(const char *_string1, const char *_string2); char *strtok(char *_str1, const char *_str2); char *strerror(int _errno); char *strdup(const char *string); void *memmove(void *_s1, const void *_s2, size_t _n); void *memcpy(void *_s1, const void *_s2, size_t _n); int memcmp(const void *_cs, const void *_ct, size_t _n); void *memchr(const void *_cs, int _c, size_t _n); void *memset(void *_mem, int _ch, size_t _n); } /* extern "C" namespace std */ using std::size_t; using std::strlen; using std::strcpy; using std::strncpy; using std::strcat; using std::strncat; using std::strchr; using std::strrchr; using std::strcmp; using std::strncmp; using std::strcoll; using std::strxfrm; using std::strpbrk; using std::strspn; using std::strcspn; using std::strstr; using std::strtok; using std::strerror; using std::strdup; using std::memmove; using std::memcpy; using std::memcmp; using std::memchr; using std::memset; /************************************************************************************************** * * D E F I N I T I O N S * *************************************************************************************************/ /****************************************** Data Types *******************************************/ typedef unsigned char ubyte1; /**< @brief unsigned 8bit integer */ typedef unsigned short int ubyte2; /**< @brief unsigned 16bit integer */ typedef unsigned long ubyte4; /**< @brief unsigned 32bit integer */ typedef unsigned long long ubyte8; /**< @brief unsigned 64bit integer */ typedef signed char sbyte1; /**< @brief signed 8bit integer */ typedef signed short int sbyte2; /**< @brief signed 16bit integer */ typedef signed long sbyte4; /**< @brief signed 32bit integer */ typedef signed long long sbyte8; /**< @brief signed 64bit integer */ typedef float float4; /**< @brief 32bit float type */ typedef double float8; /**< @brief 64bit float type */ /************************************** Common Definitions ***************************************/ /** @def NULL * @brief NULL definition */ /** @def NULL_PTR * @brief NULL pointer definition */ /* we strongly recommend to use TT_FALSE and TT_TRUE */ /** @def TT_FALSE * @brief bool definition for FALSE */ /** @def TT_TRUE * @brief bool definition for TRUE */ /** @def UBYTE4_MAX_VALUE * @brief maximum value of the ubyte4 type */ /** @def UBYTE4_MIN_VALUE * @brief minimum value of the ubyte4 type */ /** @def UBYTE2_MAX_VALUE * @brief maximum value of the ubyte2 type */ /** @def UBYTE2_MIN_VALUE * @brief minimum value of the ubyte2 type */ /** @def UBYTE1_MAX_VALUE * @brief maximum value of the ubyte1 type */ /** @def UBYTE1_MIN_VALUE * @brief minimum value of the ubyte1 type */ /************************************************************************************************** * Copyright (c) 2017 Epsilon Kran GmbH * Christophorusstraße 30, 5061 Elsbethen-Glasenbach, Austria. epsilon@palfinger.com *************************************************************************************************/ /**********************************************************************************************//** * \file EPS_Error.h * * \latexonly \hypertarget{EPS Error}{} \endlatexonly * * \brief EPS Error Type description * * Contains the definition and documentation of all possible error types.\n * * \note * This is a Note.\n * * * Each object is allowed to return an error code. * * *************************************************************************************************/ /************************************************************************************************** * * I N C L U D E S * *************************************************************************************************/ /************************************************************************************************** * * D A T A S T R U C T U R E S * *************************************************************************************************/ /** \brief EPS error type * * Type definition for all the IO Driver errors and Epsilon errors. */ typedef ubyte2 EPS_ErrorType; /************************************************************************************************** * * D E F I N I T I O N S * *************************************************************************************************/ /* * E R R O R V A L U E S */ /* general codes */ /** Epsilon Error Code Offset * All generated errors have this offset from zero */ /** everything is fine, no error has occurred. */ /** Module or function is busy.\n * This error is reported if a function or module has not yet finished its task. For example the * init function will return this error code if a previous init command has not been * finished yet. */ /** General error. No further information can be provided. */ /** A NULL pointer has been passed to the function.\n * This error is reported if a non-optional pointer parameter of the function has been set to * \c #NULL. */ /** If a task method of an object is called even if the init process was not successful then * this error code is called. For example, the CAN bus init was not sucessfull and an * sync message in the pre method should be sent. * * Or a method of the class is called, which needs a init run before calling. */ /** There is not more space left to add an element to a buffer. * E.g. The message is given by the class todo if an message has to be sent. */ /** Before every division an check for zero is done. * If the divisor is zero, this error accours. */ /* can bus codes */ /** Not every can bus message could be send in very operation state of * the device. If the device is not in the right mode to perform the wanted * operation, this error is passed. */ /** Non optional can bus device is not connected to the bus * */ /** If the object, added to the can hardware class has the same * is a anouther already connected object, this error is returned */ /** * No more objects could be connected to the can hardware class * the internal buffer is full */ /** * The given handle of the object is not known by the hardware class */ /** * The called function is not allowed to do anything * because it is disabled. The enable() function has to be called * before. */ /************************************************************************************************** * * D E F I N I T I O N S * *************************************************************************************************/ /**********************************************************************************************//** * * \brief Constructor of the base object * * The constructor initializes the object memory *************************************************************************************************/ /* * TODO Fehlerbehandlung: Fehler nach oben durchreichen, Code normal weiter ausführen und auf Befehl von oben warten */ /************************************************************************************************** * * D A T A S T R U C T U R E S * *************************************************************************************************/ struct base_s; typedef EPS_ErrorType (*const fnc_base_objCall_t)(struct base_s* const self); /** * * \brief base object structure * * Every base object need the information, defined in this structure. \n * The basic object only has an init routine and a constructor to gernate \n * the object and to initialize the parameters. \n * * \warning * Every variable pointer and method pointer in the struct has to be set by the constructor! * */ typedef struct base_s{ /* * Methods of the Class */ /** * * \brief init prototype of the base object * * Functions of the type \ref base.init are called until the initialization process is finished. * The given counter value gets increased every initialization run. * If the initialization is not finished it is possible to returns #EPS_E_BUSY. * After a #EPS_E_BUSY return code the function gets recalled until #EPS_E_OK is returned. * * \param void* This pointer to a \ref base object * \param ubyte4 run counter of the initialization routine * * \return #EPS_ErrorType * * ************************************************************************************************** * * * \note * The initialization functions are so long called until all objects are initialized. * * \warning * It is possible, that the function is recalled even if the return value #EPS_E_OK has been returned! * */ fnc_base_objCall_t init; /** * \brief object prototype method * * The pre implementation of the class base is called before the base.work * is called. This interface allows cyclic manipulation of variables befor the * work task which holds the application. * * \param void* This pointer to the \ref base object memory * \return #EPS_ErrorType * * ************************************************************************************************** * * \remarks * This function is called before the work is called. Here usually the input variables * are readed an provided to the application. * * \note * The base.pre function is called cyclic ever specified period. * * \note * If the function is overwritten, additional error codes could be returned * */ fnc_base_objCall_t pre; /** * \brief object prototype method * * The work implementation of the class base is called after all base.pre * routines where called. * This interface allows cyclic manipulation of variables and performing an application. * * \param void* This pointer to the \ref base object memory * \return #EPS_ErrorType * * ************************************************************************************************** * * \note * This function is called after the base.pre method. * * \note * The base.work function is called cyclic ever specified period. * * \note * If the function is overwritten, additional error codes could be returned * */ fnc_base_objCall_t work; /** * \brief object prototype method * * The post implementation of the class base is called after all base.work * routines where called. * This interface allows cyclic manipulation of variables after the application is finished. * Here writing buffers, transmitting bus packages, ect. cloud be performed. * * \param void* This pointer to the \ref base object memory * \return #EPS_ErrorType * * ************************************************************************************************** * * \note * This function is called after the base.work method. * * \note * The base.post function is called cyclic ever specified period. * * \note * If the function is overwritten, additional error codes could be returned * */ fnc_base_objCall_t post; /** * \brief object prototype method * * The idle implementation of the class base is called after if there is * operation time left. * Within this implementation writing logs, comfort functions, ... could be performed. * * \param void* This pointer to the \ref base object memory * \return #EPS_ErrorType * * ************************************************************************************************** * * \remarks * This function is called if there is operation time left. * The call period is not specified and the operation could be interrupted. * * \note * Take care, the operation could be interrupted. Writing to real time variables * could be dangerous. * */ fnc_base_objCall_t idle; } base_t; /************************************************************************************************** * * F U N C T I O N S * *************************************************************************************************/ /**********************************************************************************************//** * * \brief implement of an base.init method * * This implementation initializes a base object. * To do so, nothin else than a pointer check is perforemd. * * \retval #EPS_E_OK everything fine, init is finished * \retval #EPS_E_NULLPTR null pointer exception, this is a fatal error, the operation has to be stooped * * *************************************************************************************************/ EPS_ErrorType base_init(base_t* const self); /**********************************************************************************************//** * * \brief implement of an base.pre method * * In the implementation of the base class only a null * pointer check is performed. * For more functionality a derivation has to be created * * \retval #EPS_E_OK * \retval #EPS_E_NULLPTR * * * \note * If the function is overwritten, additional error codes could be returned * *************************************************************************************************/ EPS_ErrorType base_pre(base_t* const self); /**********************************************************************************************//** * * \brief implement of an base.work method * * In the implementation of the base class only a null * pointer check is performed. * For more functionality a derivation has to be created * * \retval #EPS_E_OK * \retval #EPS_E_NULLPTR * * * \note * If the function is overwritten, additional error codes could be returned * *************************************************************************************************/ EPS_ErrorType base_work(base_t* const self); /**********************************************************************************************//** * * \brief implement of an base.post method * * In the implementation of the base class only a null * pointer check is performed. * For more functionality a derivation has to be created * * \retval #EPS_E_OK * \retval #EPS_E_NULLPTR * * * \note * If the function is overwritten, additional error codes could be returned * *************************************************************************************************/ EPS_ErrorType base_post(base_t* const self); /**********************************************************************************************//** * * \brief implement of an base.idle method * * In the implementation of the base class only a null * pointer check is performed. * For more functionality a derivation has to be created * * \retval #EPS_E_OK * \retval #EPS_E_NULLPTR * * * \note * If the function is overwritten, additional error codes could be returned * *************************************************************************************************/ EPS_ErrorType base_idle(base_t* const self); /**********************************************************************************************//** * * \brief Constructor of the base object * * The constructor initializes the object memory *************************************************************************************************/ /** * * \brief base object structure * * Every base object need the information, defined in this structure. \n * The basic object only has an init routine and a constructor to gernate \n * the object and to initialize the parameters. \n * */ typedef struct base_coordControl_s{ base_t base; } base_coordControl_t; extern "C" { EPS_ErrorType base_coordControl_init(base_coordControl_t* const self); EPS_ErrorType base_coordControl_work(base_coordControl_t* const self); } using namespace std; // This file is part of Eigen, a lightweight C++ template library // for linear algebra. // // Copyright (C) 2008 Gael Guennebaud // Copyright (C) 2007-2011 Benoit Jacob // // This Source Code Form is subject to the terms of the Mozilla // Public License v. 2.0. If a copy of the MPL was not distributed // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. // first thing Eigen does: stop the compiler from committing suicide // Handle NVCC/CUDA/SYCL // When compiling CUDA device code with NVCC, pull in math functions from the // global namespace. In host mode, and when device doee with clang, use the // std versions. // then include this file where all our macros are defined. It's really important to do it first because // it's where we do all the alignment settings (platform detection and honoring the user's will if he // defined e.g. EIGEN_DONT_ALIGN) so it needs to be done before we do anything with vectorization. // This file is part of Eigen, a lightweight C++ template library // for linear algebra. // // Copyright (C) 2008-2015 Gael Guennebaud // Copyright (C) 2006-2008 Benoit Jacob // // This Source Code Form is subject to the terms of the Mozilla // Public License v. 2.0. If a copy of the MPL was not distributed // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. // Compiler identification, EIGEN_COMP_* /// \internal EIGEN_COMP_GNUC set to 1 for all compilers compatible with GCC /// \internal EIGEN_COMP_CLANG set to major+minor version (e.g., 307 for clang 3.7) if the compiler is clang /// \internal EIGEN_COMP_LLVM set to 1 if the compiler backend is llvm /// \internal EIGEN_COMP_ICC set to __INTEL_COMPILER if the compiler is Intel compiler, 0 otherwise /// \internal EIGEN_COMP_MINGW set to 1 if the compiler is mingw /// \internal EIGEN_COMP_SUNCC set to 1 if the compiler is Solaris Studio /// \internal EIGEN_COMP_MSVC set to _MSC_VER if the compiler is Microsoft Visual C++, 0 otherwise. // For the record, here is a table summarizing the possible values for EIGEN_COMP_MSVC: // name ver MSC_VER // 2008 9 1500 // 2010 10 1600 // 2012 11 1700 // 2013 12 1800 // 2015 14 1900 // "15" 15 1900 /// \internal EIGEN_COMP_MSVC_STRICT set to 1 if the compiler is really Microsoft Visual C++ and not ,e.g., ICC or clang-cl /// \internal EIGEN_COMP_IBM set to 1 if the compiler is IBM XL C++ /// \internal EIGEN_COMP_PGI set to 1 if the compiler is Portland Group Compiler /// \internal EIGEN_COMP_ARM set to 1 if the compiler is ARM Compiler /// \internal EIGEN_COMP_ARM set to 1 if the compiler is ARM Compiler /// \internal EIGEN_GNUC_STRICT set to 1 if the compiler is really GCC and not a compatible compiler (e.g., ICC, clang, mingw, etc.) // FIXME: could probably be removed as we do not support gcc 3.x anymore // Architecture identification, EIGEN_ARCH_* /// \internal EIGEN_ARCH_ARM set to 1 if the architecture is ARM /// \internal EIGEN_ARCH_ARM64 set to 1 if the architecture is ARM64 /// \internal EIGEN_ARCH_MIPS set to 1 if the architecture is MIPS /// \internal EIGEN_ARCH_SPARC set to 1 if the architecture is SPARC /// \internal EIGEN_ARCH_IA64 set to 1 if the architecture is Intel Itanium /// \internal EIGEN_ARCH_PPC set to 1 if the architecture is PowerPC // Operating system identification, EIGEN_OS_* /// \internal EIGEN_OS_UNIX set to 1 if the OS is a unix variant /// \internal EIGEN_OS_LINUX set to 1 if the OS is based on Linux kernel /// \internal EIGEN_OS_ANDROID set to 1 if the OS is Android // note: ANDROID is defined when using ndk_build, __ANDROID__ is defined when using a standalone toolchain. /// \internal EIGEN_OS_GNULINUX set to 1 if the OS is GNU Linux and not Linux-based OS (e.g., not android) /// \internal EIGEN_OS_BSD set to 1 if the OS is a BSD variant /// \internal EIGEN_OS_MAC set to 1 if the OS is MacOS /// \internal EIGEN_OS_QNX set to 1 if the OS is QNX /// \internal EIGEN_OS_WIN set to 1 if the OS is Windows based /// \internal EIGEN_OS_WIN64 set to 1 if the OS is Windows 64bits /// \internal EIGEN_OS_WINCE set to 1 if the OS is Windows CE /// \internal EIGEN_OS_CYGWIN set to 1 if the OS is Windows/Cygwin /// \internal EIGEN_OS_WIN_STRICT set to 1 if the OS is really Windows and not some variants /// \internal EIGEN_OS_SUN set to 1 if the OS is SUN /// \internal EIGEN_OS_SOLARIS set to 1 if the OS is Solaris // This macro can be used to prevent from macro expansion, e.g.: // std::max EIGEN_NOT_A_MACRO(a,b) // Cross compiler wrapper around LLVM's __has_builtin // A Clang feature extension to determine compiler features. // We use it to determine 'cxx_rvalue_references' // Upperbound on the C++ version to use. // Expected values are 03, 11, 14, 17, etc. // By default, let's use an arbitrarily large C++ version. // Do we support r-value references? // Does the compiler support C99? // Does the compiler support result_of? // Does the compiler support variadic templates? // Does the compiler fully support const expressions? (as in c++14) // Does the compiler support C++11 math? // Let's be conservative and enable the default C++11 implementation only if we are sure it exists // Does the compiler support proper C++11 containers? // Does the compiler support C++11 noexcept? /** Allows to disable some optimizations which might affect the accuracy of the result. * Such optimization are enabled by default, and set EIGEN_FAST_MATH to 0 to disable them. * They currently include: * - single precision ArrayBase::sin() and ArrayBase::cos() for SSE and AVX vectorization. */ // concatenate two tokens // convert a token to a string // EIGEN_STRONG_INLINE is a stronger version of the inline, using __forceinline on MSVC, // but it still doesn't use GCC's always_inline. This is useful in (common) situations where MSVC needs forceinline // but GCC is still doing fine with just inline. // EIGEN_ALWAYS_INLINE is the stronget, it has the effect of making the function inline and adding every possible // attribute to maximize inlining. This should only be used when really necessary: in particular, // it uses __attribute__((always_inline)) on GCC, which most of the time is useless and can severely harm compile times. // FIXME with the always_inline attribute, // gcc 3.4.x and 4.1 reports the following compilation error: // Eval.h:91: sorry, unimplemented: inlining failed in call to 'const Eigen::Eval Eigen::MatrixBase::eval() const' // : function body not available // See also bug 1367 // this macro allows to get rid of linking errors about multiply defined functions. // - static is not very good because it prevents definitions from different object files to be merged. // So static causes the resulting linked executable to be bloated with multiple copies of the same function. // - inline is not perfect either as it unwantedly hints the compiler toward inlining the function. // eigen_plain_assert is where we implement the workaround for the assert() bug in GCC <= 4.3, see bug 89 // eigen_assert can be overridden // Suppresses 'unused variable' warnings. namespace Eigen { namespace internal { template void ignore_unused_variable(const T&) {} } } //------------------------------------------------------------------------------------------ // Static and dynamic alignment control // // The main purpose of this section is to define EIGEN_MAX_ALIGN_BYTES and EIGEN_MAX_STATIC_ALIGN_BYTES // as the maximal boundary in bytes on which dynamically and statically allocated data may be alignment respectively. // The values of EIGEN_MAX_ALIGN_BYTES and EIGEN_MAX_STATIC_ALIGN_BYTES can be specified by the user. If not, // a default value is automatically computed based on architecture, compiler, and OS. // // This section also defines macros EIGEN_ALIGN_TO_BOUNDARY(N) and the shortcuts EIGEN_ALIGN{8,16,32,_MAX} // to be used to declare statically aligned buffers. //------------------------------------------------------------------------------------------ /* EIGEN_ALIGN_TO_BOUNDARY(n) forces data to be n-byte aligned. This is used to satisfy SIMD requirements. * However, we do that EVEN if vectorization (EIGEN_VECTORIZE) is disabled, * so that vectorization doesn't affect binary compatibility. * * If we made alignment depend on whether or not EIGEN_VECTORIZE is defined, it would be impossible to link * vectorized and non-vectorized code. */ // If the user explicitly disable vectorization, then we also disable alignment // EIGEN_MIN_ALIGN_BYTES defines the minimal value for which the notion of explicit alignment makes sense // Defined the boundary (in bytes) on which the data needs to be aligned. Note // that unless EIGEN_ALIGN is defined and not equal to 0, the data may not be // aligned at all regardless of the value of this #define. // EIGEN_DONT_ALIGN_STATICALLY and EIGEN_DONT_ALIGN are deprectated // They imply EIGEN_MAX_STATIC_ALIGN_BYTES=0 // Try to automatically guess what is the best default value for EIGEN_MAX_STATIC_ALIGN_BYTES // 16 byte alignment is only useful for vectorization. Since it affects the ABI, we need to enable // 16 byte alignment on all platforms where vectorization might be enabled. In theory we could always // enable alignment, but it can be a cause of problems on some platforms, so we just disable it in // certain common platform (compiler+architecture combinations) to avoid these problems. // Only static alignment is really problematic (relies on nonstandard compiler extensions), // try to keep heap alignment even when we have to disable static alignment. // static alignment is completely disabled with GCC 3, Sun Studio, and QCC/QNX // If EIGEN_MAX_ALIGN_BYTES is defined, then it is considered as an upper bound for EIGEN_MAX_ALIGN_BYTES // At this stage, EIGEN_MAX_STATIC_ALIGN_BYTES>0 is the true test whether we want to align arrays on the stack or not. // It takes into account both the user choice to explicitly enable/disable alignment (by settting EIGEN_MAX_STATIC_ALIGN_BYTES) // and the architecture config (EIGEN_ARCH_WANTS_STACK_ALIGNMENT). // Henceforth, only EIGEN_MAX_STATIC_ALIGN_BYTES should be used. // Shortcuts to EIGEN_ALIGN_TO_BOUNDARY // Dynamic alignment control //---------------------------------------------------------------------- // 131072 == 128 KB // just an empty macro ! /** \internal * \brief Macro to manually inherit assignment operators. * This is necessary, because the implicitly defined assignment operator gets deleted when a custom operator= is defined. */ /** * Just a side note. Commenting within defines works only by documenting * behind the object (via '!<'). Comments cannot be multi-line and thus * we have these extra long lines. What is confusing doxygen over here is * that we use '\' and basically have a bunch of typedefs with their * documentation in a single line. **/ // FIXME Maybe the EIGEN_DENSE_PUBLIC_INTERFACE could be removed as importing PacketScalar is rarely needed // EIGEN_SIZE_MIN_PREFER_DYNAMIC gives the min between compile-time sizes. 0 has absolute priority, followed by 1, // followed by Dynamic, followed by other finite values. The reason for giving Dynamic the priority over // finite values is that min(3, Dynamic) should be Dynamic, since that could be anything between 0 and 3. // EIGEN_SIZE_MIN_PREFER_FIXED is a variant of EIGEN_SIZE_MIN_PREFER_DYNAMIC comparing MaxSizes. The difference is that finite values // now have priority over Dynamic, so that min(3, Dynamic) gives 3. Indeed, whatever the actual value is // (between 0 and 3), it is not more than 3. // see EIGEN_SIZE_MIN_PREFER_DYNAMIC. No need for a separate variant for MaxSizes here. // the expression type of a standard coefficient wise binary operation // Workaround for MSVC 2010 (see ML thread "patch with compile for for MSVC 2010") // Disable the ipa-cp-clone optimization flag with MinGW 6.x or newer (enabled by default with -O3) // See http://eigen.tuxfamily.org/bz/show_bug.cgi?id=556 for details. // complex standard header /* ymath.h internal header */ /* yvals.h values header for conforming compilers on various systems */ /*****************************************************************************/ /* stdarg.h v5.1.6 */ /* */ /* Copyright (c) 1996-2014 Texas Instruments Incorporated */ /* http://www.ti.com/ */ /* */ /* Redistribution and use in source and binary forms, with or without */ /* modification, are permitted provided that the following conditions */ /* are met: */ /* */ /* Redistributions of source code must retain the above copyright */ /* notice, this list of conditions and the following disclaimer. */ /* */ /* Redistributions in binary form must reproduce the above copyright */ /* notice, this list of conditions and the following disclaimer in */ /* the documentation and/or other materials provided with the */ /* distribution. */ /* */ /* Neither the name of Texas Instruments Incorporated nor the names */ /* of its contributors may be used to endorse or promote products */ /* derived from this software without specific prior written */ /* permission. */ /* */ /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR */ /* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ /* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */ /* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */ /* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY */ /* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */ /* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */ /* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* */ /*****************************************************************************/ using std::va_list; /*---------------------------------------------------------------------------*/ /* A header file conforming to ARM CLIB ABI (GENC-003539), should */ /* define _AEABI_PORTABLE when _AEABI_PORTABILITY_LEVEL is defined. */ /*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/ /* The macro definition that guards CLIB ABI (GENC-003539) requirements. */ /*---------------------------------------------------------------------------*/ /* You can predefine (on the compile command line, for example): _ALT_NS=1 -- to use namespace _Dinkum_std for C++ _ALT_NS=2 -- to use namespace _Dinkum_std for C++ and C _C_AS_CPP -- to compile C library as C++ _C_IN_NS -- to define C names in std/_Dinkum_std instead of global namespace _C99 -- to turn ON C99 library support _ABRCPP -- to turn ON Abridged C++ dialect (implies _ECPP) _ECPP -- to turn ON Embedded C++ dialect _NO_EX -- to turn OFF use of try/throw _NO_MT -- to turn OFF thread synchronization _NO_NS -- to turn OFF use of namespace declarations _STL_DB (or _STLP_DEBUG) -- to turn ON iterator/range debugging __NO_LONG_LONG -- to define _Longlong as long, not long long You can change (in this header): _ADDED_C_LIB -- from 1 to 0 to omit declarations for C extensions _COMPILER_TLS -- from 0 to 1 if _TLS_QUAL is not nil _EXFAIL -- from 1 to any nonzero value for EXIT_FAILURE _FILE_OP_LOCKS -- from 0 to 1 for file atomic locks _GLOBAL_LOCALE -- from 0 to 1 for shared locales instead of per-thread _HAS_IMMUTABLE_SETS -- from 1 to 0 to permit alterable set elements _HAS_STRICT_CONFORMANCE -- from 0 to 1 to disable nonconforming extensions _HAS_TRADITIONAL_IOSTREAMS -- from 1 to 0 to omit old iostreams functions _HAS_TRADITIONAL_ITERATORS -- from 0 to 1 for vector/string pointer iterators _HAS_TRADITIONAL_POS_TYPE -- from 0 to 1 for streampos same as streamoff _HAS_TRADITIONAL_STL -- from 1 to 0 to omit old STL functions _IOSTREAM_OP_LOCKS -- from 0 to 1 for iostream atomic locks _TLS_QUAL -- from nil to compiler TLS qualifier, such as __declspec(thread) _USE_EXISTING_SYSTEM_NAMES -- from 1 to 0 to disable mappings (_Open to open) Include directories needed to compile with Dinkum C: C -- include/c C99 -- include/c (define _C99) Embedded C++ -- include/c include/embedded (define _ECPP) Abridged C++ -- include/c include/embedded include (define _ABRCPP) Standard C++ -- include/c include Standard C++ with export -- include/c include/export include (--export --template_dir=lib/export) Include directories needed to compile with native C: C -- none C99 -- N/A Embedded C++ -- include/embedded (define _ECPP) Abridged C++ -- include/embedded include (define _ABRCPP) Standard C++ -- include Standard C++ with export -- include/export include (--export --template_dir=lib/export) */ /* targets with "native" mode libraries don't support C9X */ /* TI RTS supports the C9X snprintf() and vsnprintf() functions */ /* DETERMINE MACHINE TYPE */ /* _C99_MATH must be defined for using Dinkum Math */ /* DETERMINE _Ptrdifft AND _Sizet FROM MACHINE TYPE */ typedef long _Int32t; typedef unsigned long _Uint32t; typedef int _Ptrdifft; typedef unsigned _Sizet; /* EXCEPTION CONTROL */ /* NAMING PROPERTIES */ /* #define _STD_LINKAGE defines C names as extern "C++" */ /* #define _STD_USING defines C names in namespace std or _Dinkum_std */ /* THREAD AND LOCALE CONTROL */ /* THREAD-LOCAL STORAGE */ /* NAMESPACE CONTROL */ namespace std {} namespace std { typedef bool _Bool; } /* VC++ COMPILER PARAMETERS */ /* defined(__NO_LONG_LONG) && !defined (_MSC_VER) && ! TI 32 bit processor*/ /* MAKE MINGW LOOK LIKE WIN32 HEREAFTER */ namespace std { /* FLOATING-POINT PROPERTIES */ /* INTEGER PROPERTIES */ typedef long long _Longlong; typedef unsigned long long _ULonglong; /* wchar_t AND wint_t PROPERTIES */ typedef wchar_t _Wchart; typedef wchar_t _Wintt; /* POINTER PROPERTIES */ /* signal PROPERTIES */ /* stdarg PROPERTIES */ typedef ::std:: va_list _Va_list; /* stdlib PROPERTIES */ extern "C" { void _Atexit(void (*)(void)); } /* stdio PROPERTIES */ typedef char _Sysch_t; /* STORAGE ALIGNMENT PROPERTIES */ /* time PROPERTIES */ } /* MULTITHREAD PROPERTIES */ /* LOCK MACROS */ namespace std { extern "C++" { // in case of _C_AS_CPP // CLASS _Lockit class _Lockit { // lock while object in existence -- MUST NEST public: explicit _Lockit() { // do nothing } explicit _Lockit(int) { // do nothing } ~_Lockit() { // do nothing } public: _Lockit(const _Lockit&); // not defined _Lockit& operator=(const _Lockit&); // not defined }; class _Mutex { // lock under program control public: void _Lock() { // do nothing } void _Unlock() { // do nothing } }; } // extern "C++" } /* MISCELLANEOUS MACROS */ /*****************************************************************************/ /* linkage.h v5.1.6 */ /* */ /* Copyright (c) 1998-2014 Texas Instruments Incorporated */ /* http://www.ti.com/ */ /* */ /* Redistribution and use in source and binary forms, with or without */ /* modification, are permitted provided that the following conditions */ /* are met: */ /* */ /* Redistributions of source code must retain the above copyright */ /* notice, this list of conditions and the following disclaimer. */ /* */ /* Redistributions in binary form must reproduce the above copyright */ /* notice, this list of conditions and the following disclaimer in */ /* the documentation and/or other materials provided with the */ /* distribution. */ /* */ /* Neither the name of Texas Instruments Incorporated nor the names */ /* of its contributors may be used to endorse or promote products */ /* derived from this software without specific prior written */ /* permission. */ /* */ /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR */ /* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ /* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */ /* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */ /* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY */ /* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */ /* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */ /* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* */ /*****************************************************************************/ /*****************************************************************************/ /* _lock.h v5.1.6 */ /* */ /* Copyright (c) 2000-2014 Texas Instruments Incorporated */ /* http://www.ti.com/ */ /* */ /* Redistribution and use in source and binary forms, with or without */ /* modification, are permitted provided that the following conditions */ /* are met: */ /* */ /* Redistributions of source code must retain the above copyright */ /* notice, this list of conditions and the following disclaimer. */ /* */ /* Redistributions in binary form must reproduce the above copyright */ /* notice, this list of conditions and the following disclaimer in */ /* the documentation and/or other materials provided with the */ /* distribution. */ /* */ /* Neither the name of Texas Instruments Incorporated nor the names */ /* of its contributors may be used to endorse or promote products */ /* derived from this software without specific prior written */ /* permission. */ /* */ /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR */ /* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ /* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */ /* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */ /* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY */ /* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */ /* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */ /* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* */ /*****************************************************************************/ /*****************************************************************************/ /* linkage.h v5.1.6 */ /* */ /* Copyright (c) 1998-2014 Texas Instruments Incorporated */ /* http://www.ti.com/ */ /* */ /* Redistribution and use in source and binary forms, with or without */ /* modification, are permitted provided that the following conditions */ /* are met: */ /* */ /* Redistributions of source code must retain the above copyright */ /* notice, this list of conditions and the following disclaimer. */ /* */ /* Redistributions in binary form must reproduce the above copyright */ /* notice, this list of conditions and the following disclaimer in */ /* the documentation and/or other materials provided with the */ /* distribution. */ /* */ /* Neither the name of Texas Instruments Incorporated nor the names */ /* of its contributors may be used to endorse or promote products */ /* derived from this software without specific prior written */ /* permission. */ /* */ /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR */ /* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ /* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */ /* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */ /* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY */ /* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */ /* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */ /* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* */ /*****************************************************************************/ extern "C" { void _nop(); extern void ( *_lock)(); extern void (*_unlock)(); void _register_lock (void ( *lock)()); void _register_unlock(void (*unlock)()); } /* extern "C" */ /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ namespace std { extern "C" { /* MACROS FOR _FPP_TYPE */ /* MACROS FOR _Dtest RETURN (0 => ZERO) */ /* MACROS FOR _Feraise ARGUMENT */ /* TYPE DEFINITIONS */ typedef union { /* pun float types as integer array */ unsigned short _Word[8]; float _Float; double _Double; long double _Long_double; } _Dconst; /* ERROR REPORTING */ void _Feraise(int); /* double DECLARATIONS */ double _Cosh(double, double); short _Dtest(double *); short _Exp(double *, double, short); double _Log(double, int); double _Sin(double, unsigned int); double _Sinh(double, double); extern /* const */ _Dconst _Denorm, _Hugeval, _Inf, _Nan, _Snan; /* float DECLARATIONS */ float _FCosh(float, float); short _FDtest(float *); short _FExp(float *, float, short); float _FLog(float, int); float _FSin(float, unsigned int); float _FSinh(float, float); extern /* const */ _Dconst _FDenorm, _FInf, _FNan, _FSnan; /* long double DECLARATIONS */ long double _LCosh(long double, long double); short _LDtest(long double *); short _LExp(long double *, long double, short); long double _LLog(long double, int); long double _LSin(long double, unsigned int); long double _LSinh(long double, long double); extern /* const */ _Dconst _LDenorm, _LInf, _LNan, _LSnan; } } /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ // cmath standard header /* yvals.h values header for conforming compilers on various systems */ /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ /****************************************************************************/ /* math.h v5.1.6 */ /* */ /* Copyright (c) 2010-2014 Texas Instruments Incorporated */ /* http://www.ti.com/ */ /* */ /* Redistribution and use in source and binary forms, with or without */ /* modification, are permitted provided that the following conditions */ /* are met: */ /* */ /* Redistributions of source code must retain the above copyright */ /* notice, this list of conditions and the following disclaimer. */ /* */ /* Redistributions in binary form must reproduce the above copyright */ /* notice, this list of conditions and the following disclaimer in */ /* the documentation and/or other materials provided with the */ /* distribution. */ /* */ /* Neither the name of Texas Instruments Incorporated nor the names */ /* of its contributors may be used to endorse or promote products */ /* derived from this software without specific prior written */ /* permission. */ /* */ /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR */ /* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ /* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */ /* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */ /* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY */ /* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */ /* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */ /* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* */ /****************************************************************************/ /* math.h standard header */ /*---------------------------------------------------------------------------*/ /* A header file conforming to ARM CLIB ABI (GENC-003539), should */ /* define _AEABI_PORTABLE when _AEABI_PORTABILITY_LEVEL is defined. */ /*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/ /* The macro definition that guards CLIB ABI (GENC-003539) requirements. */ /*---------------------------------------------------------------------------*/ namespace std { /* CODES FOR is* FUNCTIONS */ /* CODES FOR ilogb FUNCTIONS */ /* TYPES */ typedef float float_t; typedef double double_t; /* MACROS */ extern "C" { int _FFpcomp(float, float); int _Fpcomp(double, double); int _LFpcomp(long double, long double); int _FDclass(float); int _Dclass(double); int _LDclass(long double); int _FDsign(float); int _Dsign(double); int _LDsign(long double); } extern "C" { /*---------------------------------------------------------------------------*/ /* If --fp_mode=relaxed is used and VFP is enabled, use the hardware square */ /* root directly instead of calling the sqrtx routine. This will not set */ /* errno if the argument is negative. */ /* */ /* This is done by defining sqrt to _relaxed_sqrt to allow other translation */ /* units to use the normal sqrt routine under strict mode. */ /*---------------------------------------------------------------------------*/ /* double declarations */ double acos(double); double asin(double); double atan(double); double atan2(double, double); double ceil(double); double exp(double); double fabs(double); double floor(double); double fmod(double, double); double frexp(double, int *); double ldexp(double, int); double modf(double, double *); double pow(double, double); double sqrt(double); double tan(double); double tanh(double); double acosh(double); double asinh(double); double atanh(double); double cbrt(double); double copysign(double, double); double erf(double); double erfc(double); double exp2(double); double expm1(double); double fdim(double, double); double fma(double, double, double); double fmax(double, double); double fmin(double, double); double hypot(double, double); int ilogb(double); double lgamma(double); _Longlong llrint(double); _Longlong llround(double); double log1p(double); double logb(double); long lrint(double); long lround(double); double nan(const char *); double nearbyint(double); double nextafter(double, double); double nexttoward(double, long double); double remainder(double, double); double remquo(double, double, int *); double rint(double); double round(double); double scalbn(double, int); double scalbln(double, long); double tgamma(double); double trunc(double); /* float declarations */ float acosf(float); float asinf(float); float atanf(float); float atan2f(float, float); float ceilf(float); float expf(float); float fabsf(float); float floorf(float); float fmodf(float, float); float frexpf(float, int *); float ldexpf(float, int); float modff(float, float *); float powf(float, float); float sqrtf(float); float tanf(float); float tanhf(float); float acoshf(float); float asinhf(float); float atanhf(float); float cbrtf(float); float copysignf(float, float); float erff(float); float erfcf(float); float expm1f(float); float exp2f(float); float fdimf(float, float); float fmaf(float, float, float); float fmaxf(float, float); float fminf(float, float); float hypotf(float, float); int ilogbf(float); float lgammaf(float); _Longlong llrintf(float); _Longlong llroundf(float); float log1pf(float); float logbf(float); long lrintf(float); long lroundf(float); float nanf(const char *); float nearbyintf(float); float nextafterf(float, float); float nexttowardf(float, long double); float remainderf(float, float); float remquof(float, float, int *); float rintf(float); float roundf(float); float scalbnf(float, int); float scalblnf(float, long); float tgammaf(float); float truncf(float); /* long double declarations */ long double acosl(long double); long double asinl(long double); long double atanl(long double); long double atan2l(long double, long double); long double ceill(long double); long double expl(long double); long double fabsl(long double); long double floorl(long double); long double fmodl(long double, long double); long double frexpl(long double, int *); long double ldexpl(long double, int); long double modfl(long double, long double *); long double powl(long double, long double); long double sqrtl(long double); long double tanl(long double); long double tanhl(long double); long double acoshl(long double); long double asinhl(long double); long double atanhl(long double); long double cbrtl(long double); long double copysignl(long double, long double); long double erfl(long double); long double erfcl(long double); long double exp2l(long double); long double expm1l(long double); long double fdiml(long double, long double); long double fmal(long double, long double, long double); long double fmaxl(long double, long double); long double fminl(long double, long double); long double hypotl(long double, long double); int ilogbl(long double); long double lgammal(long double); _Longlong llrintl(long double); _Longlong llroundl(long double); long double log1pl(long double); long double logbl(long double); long lrintl(long double); long lroundl(long double); long double nanl(const char *); long double nearbyintl(long double); long double nextafterl(long double, long double); long double nexttowardl(long double, long double); long double remainderl(long double, long double); long double remquol(long double, long double, int *); long double rintl(long double); long double roundl(long double); long double scalbnl(long double, int); long double scalblnl(long double, long); long double tgammal(long double); long double truncl(long double); } extern "C" { /* double MACRO OVERRIDES, FOR C */ double cos(double); double cosh(double); double log(double); double log10(double); double sin(double); double sinh(double); double log2(double); /* float MACRO OVERRIDES, FOR C */ float cosf(float); float coshf(float); float logf(float); float log10f(float); float sinf(float); float sinhf(float); float log2f(float); /* long double MACRO OVERRIDES, FOR C */ long double cosl(long double); long double coshl(long double); long double logl(long double); long double log10l(long double); long double sinl(long double); long double sinhl(long double); long double log2l(long double); } } /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ /****************************************************************************/ /* mathcpp.h v5.1.6 */ /* */ /* Copyright (c) 2010-2014 Texas Instruments Incorporated */ /* http://www.ti.com/ */ /* */ /* Redistribution and use in source and binary forms, with or without */ /* modification, are permitted provided that the following conditions */ /* are met: */ /* */ /* Redistributions of source code must retain the above copyright */ /* notice, this list of conditions and the following disclaimer. */ /* */ /* Redistributions in binary form must reproduce the above copyright */ /* notice, this list of conditions and the following disclaimer in */ /* the documentation and/or other materials provided with the */ /* distribution. */ /* */ /* Neither the name of Texas Instruments Incorporated nor the names */ /* of its contributors may be used to endorse or promote products */ /* derived from this software without specific prior written */ /* permission. */ /* */ /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR */ /* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ /* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */ /* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */ /* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY */ /* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */ /* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */ /* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* */ /****************************************************************************/ namespace std { /* _FPCOMP_template defined in math.h */ // TEMPLATE FUNCTION _Pow_int template inline _Ty _Pow_int(_Ty _Left, int _Right) { // raise to integer power unsigned int _Num = _Right; if (_Right < 0) _Num = 0 - _Num; for (_Ty _Ans = 1; ; _Left *= _Left) { // scale and fold in factors if ((_Num & 1) != 0) _Ans *= _Left; if ((_Num >>= 1) == 0) return (0 <= _Right ? _Ans : _Ans == _Ty(0) ? ::std:: _Inf . _Double : _Ty(1) / _Ans); } } // double INLINES, FOR C++ /* Non-overload inlines are in math.h */ // OVERLOADS inline double abs(double _Left) { // return absolute value return (fabs(_Left)); } inline double pow(double _Left, int _Right) { // raise to integer power return (_Pow_int(_Left, _Right)); } // float INLINES, FOR C++ /* Non-overload inlines are in math.h */ // OVERLOADS inline float abs(float _Left) { // return absolute value return (fabsf(_Left)); } inline float acos(float _Left) { // return arccosine return (acosf(_Left)); } inline float asin(float _Left) { // return arcsine return (asinf(_Left)); } inline float atan(float _Left) { // return arctangent return (atanf(_Left)); } inline float atan2(float _Left, float _Right) { // return arctangent return (atan2f(_Left, _Right)); } inline float ceil(float _Left) { // return ceiling return (ceilf(_Left)); } inline float cos(float _Left) { // return cosine return (_FSin(_Left, 1)); } inline float cosh(float _Left) { // return hyperbolic cosine return (_FCosh(_Left, 1)); } inline float exp(float _Left) { // return exponential return (expf(_Left)); } inline float fabs(float _Left) { // return absolute value return (fabsf(_Left)); } inline float floor(float _Left) { // return floor return (floorf(_Left)); } inline float fmod(float _Left, float _Right) { // return modulus return (fmodf(_Left, _Right)); } inline float frexp(float _Left, int *_Right) { // unpack exponent return (frexpf(_Left, _Right)); } inline float ldexp(float _Left, int _Right) { // pack exponent return (ldexpf(_Left, _Right)); } inline float log(float _Left) { // return natural logarithm return (_FLog(_Left, 0)); } inline float log10(float _Left) { // return base-10 logarithm return (_FLog(_Left, 1)); } inline float modf(float _Left, float *_Right) { // unpack fraction return (modff(_Left, _Right)); } inline float pow(float _Left, float _Right) { // raise to power return (powf(_Left, _Right)); } inline float pow(float _Left, int _Right) { // raise to integer power return (_Pow_int(_Left, _Right)); } inline float sin(float _Left) { // return sine return (_FSin(_Left, 0)); } inline float sinh(float _Left) { // return hyperbolic sine return (_FSinh(_Left, 1)); } inline float sqrt(float _Left) { // return square root return (sqrtf(_Left)); } inline float tan(float _Left) { // return tangent return (tanf(_Left)); } inline float tanh(float _Left) { // return hyperbolic tangent return (tanhf(_Left)); } inline float acosh(float _Left) { // return hyperbolic arccosine return (acoshf(_Left)); } inline float asinh(float _Left) { // return hyperbolic arcsine return (asinhf(_Left)); } inline float atanh(float _Left) { // return hyperbolic arctangent return (atanhf(_Left)); } inline float cbrt(float _Left) { // return cube root return (cbrtf(_Left)); } inline float copysign(float _Left, float _Right) { // return copysign return (copysignf(_Left, _Right)); } inline float erf(float _Left) { // return erf return (erff(_Left)); } inline float erfc(float _Left) { // return erfc return (erfcf(_Left)); } inline float exp2(float _Left) { // return exp2 return (exp2f(_Left)); } inline float expm1(float _Left) { // return expml return (expm1f(_Left)); } inline float fdim(float _Left, float _Right) { // return fdim return (fdimf(_Left, _Right)); } inline float fma(float _Left, float _Right, float _Addend) { // return fma return (fmaf(_Left, _Right, _Addend)); } inline float fmax(float _Left, float _Right) { // return fmax return (fmaxf(_Left, _Right)); } inline float fmin(float _Left, float _Right) { // return fmin return (fminf(_Left, _Right)); } inline float hypot(float _Left, float _Right) { // return hypot return (hypotf(_Left, _Right)); } inline int ilogb(float _Left) { // return ilogb return (ilogbf(_Left)); } inline float lgamma(float _Left) { // return lgamma return (lgammaf(_Left)); } inline _Longlong llrint(float _Left) { // return llrint return (llrintf(_Left)); } inline _Longlong llround(float _Left) { // return llround return (llroundf(_Left)); } inline float log1p(float _Left) { // return loglp return (log1pf(_Left)); } inline float log2(float _Left) { // return log2 return (_FLog(_Left, -1)); } inline float logb(float _Left) { // return logb return (logbf(_Left)); } inline long lrint(float _Left) { // return lrint return (lrintf(_Left)); } inline long lround(float _Left) { // return lround return (lroundf(_Left)); } inline float nearbyint(float _Left) { // return nearbyint return (nearbyintf(_Left)); } inline float nextafter(float _Left, float _Right) { // return nextafter return (nextafterf(_Left, _Right)); } inline float nexttoward(float _Left, long double _Right) { // return nexttoward return (nexttowardf(_Left, _Right)); } inline float remainder(float _Left, float _Right) { // return remainder return (remainderf(_Left, _Right)); } inline float remquo(float _Left, float _Right, int *_Pval) { // return remquo return (remquof(_Left, _Right, _Pval)); } inline float rint(float _Left) { // return rint return (rintf(_Left)); } inline float round(float _Left) { // return round return (roundf(_Left)); } inline float scalbn(float _Left, int _Right) { // return scalbn return (scalbnf(_Left, _Right)); } inline float scalbln(float _Left, long _Right) { // return scalbln return (scalblnf(_Left, _Right)); } inline float tgamma(float _Left) { // return tgamma return (tgammaf(_Left)); } inline float trunc(float _Left) { // return trunc return (truncf(_Left)); } // long double INLINES, FOR C++ /* Non-overload inlines are in math.h */ // OVERLOADS inline long double abs(long double _Left) { // return absolute value return (fabsl(_Left)); } inline long double acos(long double _Left) { // return arccosine return (acosl(_Left)); } inline long double asin(long double _Left) { // return arcsine return (asinl(_Left)); } inline long double atan(long double _Left) { // return arctangent return (atanl(_Left)); } inline long double atan2(long double _Left, long double _Right) { // return arctangent return (atan2l(_Left, _Right)); } inline long double ceil(long double _Left) { // return ceiling return (ceill(_Left)); } inline long double cos(long double _Left) { // return cosine return (_LSin(_Left, 1)); } inline long double cosh(long double _Left) { // return hyperbolic cosine return (_LCosh(_Left, 1)); } inline long double exp(long double _Left) { // return exponential return (expl(_Left)); } inline long double fabs(long double _Left) { // return absolute value return (fabsl(_Left)); } inline long double floor(long double _Left) { // return floor return (floorl(_Left)); } inline long double fmod(long double _Left, long double _Right) { // return modulus return (fmodl(_Left, _Right)); } inline long double frexp(long double _Left, int *_Right) { // unpack exponent return (frexpl(_Left, _Right)); } inline long double ldexp(long double _Left, int _Right) { // pack exponent return (ldexpl(_Left, _Right)); } inline long double log(long double _Left) { // return natural logarithm return (_LLog(_Left, 0)); } inline long double log10(long double _Left) { // return base-10 logarithm return (_LLog(_Left, 1)); } inline long double modf(long double _Left, long double *_Right) { // unpack fraction return (modfl(_Left, _Right)); } inline long double pow(long double _Left, long double _Right) { // raise to power return (powl(_Left, _Right)); } inline long double pow(long double _Left, int _Right) { // raise to integer power return (_Pow_int(_Left, _Right)); } inline long double sin(long double _Left) { // return sine return (_LSin(_Left, 0)); } inline long double sinh(long double _Left) { // return hyperbolic sine return (_LSinh(_Left, 1)); } inline long double sqrt(long double _Left) { // return square root return (sqrtl(_Left)); } inline long double tan(long double _Left) { // return tangent return (tanl(_Left)); } inline long double tanh(long double _Left) { // return hyperbolic tangent return (tanhl(_Left)); } inline long double acosh(long double _Left) { // return acosh return (acoshl(_Left)); } inline long double asinh(long double _Left) { // return asinh return (asinhl(_Left)); } inline long double atanh(long double _Left) { // return atanh return (atanhl(_Left)); } inline long double cbrt(long double _Left) { // return cbrt return (cbrtl(_Left)); } inline long double copysign(long double _Left, long double _Right) { // return copysign return (copysignl(_Left, _Right)); } inline long double erf(long double _Left) { // return erf return (erfl(_Left)); } inline long double erfc(long double _Left) { // return erfc return (erfcl(_Left)); } inline long double exp2(long double _Left) { // return exp2 return (exp2l(_Left)); } inline long double expm1(long double _Left) { // return expml return (expm1l(_Left)); } inline long double fdim(long double _Left, long double _Right) { // return fdim return (fdiml(_Left, _Right)); } inline long double fma(long double _Left, long double _Right, long double _Addend) { // return fma return (fmal(_Left, _Right, _Addend)); } inline long double fmax(long double _Left, long double _Right) { // return fmax return (fmaxl(_Left, _Right)); } inline long double fmin(long double _Left, long double _Right) { // return fmin return (fminl(_Left, _Right)); } inline long double hypot(long double _Left, long double _Right) { // return hypot return (hypotl(_Left, _Right)); } inline int ilogb(long double _Left) { // return ilogb return (ilogbl(_Left)); } inline long double lgamma(long double _Left) { // return lgamma return (lgammal(_Left)); } inline _Longlong llrint(long double _Left) { // return llrint return (llrintl(_Left)); } inline _Longlong llround(long double _Left) { // return llround return (llroundl(_Left)); } inline long double log1p(long double _Left) { // return loglp return (log1pl(_Left)); } inline long double log2(long double _Left) { // return log2 return (_LLog(_Left, -1)); } inline long double logb(long double _Left) { // return logb return (logbl(_Left)); } inline long lrint(long double _Left) { // return lrint return (lrintl(_Left)); } inline long lround(long double _Left) { // return lround return (lroundl(_Left)); } inline long double nearbyint(long double _Left) { // return nearbyint return (nearbyintl(_Left)); } inline long double nextafter(long double _Left, long double _Right) { // return nextafter return (nextafterl(_Left, _Right)); } inline long double nexttoward(long double _Left, long double _Right) { // return nexttoward return (nexttowardl(_Left, _Right)); } inline long double remainder(long double _Left, long double _Right) { // return remainder return (remainderl(_Left, _Right)); } inline long double remquo(long double _Left, long double _Right, int *_Pval) { // return remquo return (remquol(_Left, _Right, _Pval)); } inline long double rint(long double _Left) { // return rint return (rintl(_Left)); } inline long double round(long double _Left) { // return round return (roundl(_Left)); } inline long double scalbn(long double _Left, int _Right) { // return scalbn return (scalbnl(_Left, _Right)); } inline long double scalbln(long double _Left, long _Right) { // return scalbln return (scalblnl(_Left, _Right)); } inline long double tgamma(long double _Left) { // return tgamma return (tgammal(_Left)); } inline long double trunc(long double _Left) { // return trunc return (truncl(_Left)); } } /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ // sstream standard header // string standard header // istream standard header // ostream standard header // ios standard header // xlocnum internal header (from ) // climits standard header /* yvals.h values header for conforming compilers on various systems */ /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ /* limits.h standard header -- 8-bit version */ /*---------------------------------------------------------------------------*/ /* A header file conforming to ARM CLIB ABI (GENC-003539), should */ /* define _AEABI_PORTABLE when _AEABI_PORTABILITY_LEVEL is defined. */ /*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/ /* The macro definition that guards CLIB ABI (GENC-003539) requirements. */ /*---------------------------------------------------------------------------*/ /* CHAR PROPERTIES */ /* INT PROPERTIES */ /* MULTIBYTE PROPERTIES */ /* SIGNED CHAR PROPERTIES */ /* SHORT PROPERTIES */ /* LONG PROPERTIES */ /* UNSIGNED PROPERTIES */ /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ // cstdio standard header /* yvals.h values header for conforming compilers on various systems */ /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ /*****************************************************************************/ /* STDIO.H v5.1.6 */ /* */ /* Copyright (c) 1993-2014 Texas Instruments Incorporated */ /* http://www.ti.com/ */ /* */ /* Redistribution and use in source and binary forms, with or without */ /* modification, are permitted provided that the following conditions */ /* are met: */ /* */ /* Redistributions of source code must retain the above copyright */ /* notice, this list of conditions and the following disclaimer. */ /* */ /* Redistributions in binary form must reproduce the above copyright */ /* notice, this list of conditions and the following disclaimer in */ /* the documentation and/or other materials provided with the */ /* distribution. */ /* */ /* Neither the name of Texas Instruments Incorporated nor the names */ /* of its contributors may be used to endorse or promote products */ /* derived from this software without specific prior written */ /* permission. */ /* */ /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR */ /* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ /* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */ /* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */ /* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY */ /* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */ /* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */ /* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* */ /*****************************************************************************/ /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ // cstdlib standard header /* yvals.h values header for conforming compilers on various systems */ /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ /*****************************************************************************/ /* stdlib.h v5.1.6 */ /* */ /* Copyright (c) 1993-2014 Texas Instruments Incorporated */ /* http://www.ti.com/ */ /* */ /* Redistribution and use in source and binary forms, with or without */ /* modification, are permitted provided that the following conditions */ /* are met: */ /* */ /* Redistributions of source code must retain the above copyright */ /* notice, this list of conditions and the following disclaimer. */ /* */ /* Redistributions in binary form must reproduce the above copyright */ /* notice, this list of conditions and the following disclaimer in */ /* the documentation and/or other materials provided with the */ /* distribution. */ /* */ /* Neither the name of Texas Instruments Incorporated nor the names */ /* of its contributors may be used to endorse or promote products */ /* derived from this software without specific prior written */ /* permission. */ /* */ /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR */ /* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ /* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */ /* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */ /* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY */ /* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */ /* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */ /* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* */ /*****************************************************************************/ /*---------------------------------------------------------------------------*/ /* Attributes are only available in relaxed ANSI mode. */ /*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/ /* A header file conforming to ARM CLIB ABI (GENC-003539), should */ /* define _AEABI_PORTABLE when _AEABI_PORTABILITY_LEVEL is defined. */ /*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/ /* The macro definition that guards CLIB ABI (GENC-003539) requirements. */ /*---------------------------------------------------------------------------*/ //---------------------------------------------------------------------------- // IS RECOMMENDED OVER . IS PROVIDED FOR // COMPATIBILITY WITH C AND THIS USAGE IS DEPRECATED IN C++ //---------------------------------------------------------------------------- extern "C" namespace std { typedef struct { int quot, rem; } div_t; typedef struct { int quot, rem; } ldiv_t; typedef struct { long long quot, rem; } lldiv_t; /*****************************************************************************/ /* linkage.h v5.1.6 */ /* */ /* Copyright (c) 1998-2014 Texas Instruments Incorporated */ /* http://www.ti.com/ */ /* */ /* Redistribution and use in source and binary forms, with or without */ /* modification, are permitted provided that the following conditions */ /* are met: */ /* */ /* Redistributions of source code must retain the above copyright */ /* notice, this list of conditions and the following disclaimer. */ /* */ /* Redistributions in binary form must reproduce the above copyright */ /* notice, this list of conditions and the following disclaimer in */ /* the documentation and/or other materials provided with the */ /* distribution. */ /* */ /* Neither the name of Texas Instruments Incorporated nor the names */ /* of its contributors may be used to endorse or promote products */ /* derived from this software without specific prior written */ /* permission. */ /* */ /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR */ /* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ /* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */ /* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */ /* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY */ /* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */ /* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */ /* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* */ /*****************************************************************************/ /*---------------------------------------------------------------*/ /* NOTE - Normally, abs, labs, and fabs are expanded inline, so */ /* no formal definition is really required. However, ANSI */ /* requires that they exist as separate functions, so */ /* they are supplied in the library. The prototype is */ /* here mainly for documentation. */ /*---------------------------------------------------------------*/ int abs(int _val); long labs(long _val); long long llabs(long long _val); int atoi(const char *_st); long atol(const char *_st); long long atoll(const char *_st); int ltoa(long val, char *buffer); static __inline double atof(const char *_st); long strtol(const char *_st, char **_endptr, int _base); unsigned long strtoul(const char *_st, char **_endptr, int _base); long long strtoll(const char *_st, char **_endptr, int _base); unsigned long long strtoull(const char *_st, char **_endptr, int _base); double strtod(const char *_st, char **_endptr); long double strtold(const char *_st, char **_endptr); int rand(void); void srand(unsigned _seed); void *calloc(size_t _num, size_t _size) ; void *malloc(size_t _size) ; void *realloc(void *_ptr, size_t _size) ; void free(void *_ptr); void *memalign(size_t _aln, size_t _size) ; void abort(void); typedef void (*__TI_atexit_fn)(void); int atexit(__TI_atexit_fn _func); typedef int (*__TI_compar_fn)(const void *,const void *); void *bsearch(const void *_key, const void *_base, size_t _nmemb, size_t _size, __TI_compar_fn compar); void qsort(void *_base, size_t _nmemb, size_t _size, __TI_compar_fn compar); void exit(int _status); div_t div(int _numer, int _denom); ldiv_t ldiv(long _numer, long _denom); lldiv_t lldiv(long long _numer, long long _denom); char *getenv(const char *_string); int system(const char *_name); int mblen(const char *, size_t); size_t mbstowcs(wchar_t *, const char *, size_t); int mbtowc(wchar_t *, const char *, size_t); size_t wcstombs(char *, const wchar_t *, size_t); int wctomb(char *, wchar_t); } /* extern "C" namespace std */ namespace std { static __inline double atof(const char *_st) { return strtod(_st, (char **)0); } } /* namespace std */ namespace std { inline int atexit(void (*func)(void)) { return atexit((__TI_atexit_fn)func); } inline void *bsearch(const void *_key, const void *_base, size_t _nmemb, size_t _size, int (*compar)(const void *,const void *)) { return bsearch(_key, _base, _nmemb, _size, (__TI_compar_fn)compar); } inline void qsort(void *_base, size_t _nmemb, size_t _size, int (*_compar)(const void *, const void *)) { return qsort(_base, _nmemb, _size, (__TI_compar_fn)_compar); } } namespace std { /* long OVERLOADS */ inline long abs(long _Left) { // compute abs return (labs(_Left)); } inline ldiv_t div(long _Left, long _Right) { // compute quotient and remainder return (ldiv(_Left, _Right)); } } namespace std { /* long long OVERLOADS */ inline long long abs(long long _Left) { // compute abs return (llabs(_Left)); } inline lldiv_t div(long long _Left, long long _Right) { // compute quotient and remainder return (lldiv(_Left, _Right)); } } /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ // streambuf standard header // xiosbase internal header (from ) // xlocale internal header (from ) // climits standard header /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ // cstring standard header /* yvals.h values header for conforming compilers on various systems */ /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ /*****************************************************************************/ /* string.h v5.1.6 */ /* */ /* Copyright (c) 1993-2014 Texas Instruments Incorporated */ /* http://www.ti.com/ */ /* */ /* Redistribution and use in source and binary forms, with or without */ /* modification, are permitted provided that the following conditions */ /* are met: */ /* */ /* Redistributions of source code must retain the above copyright */ /* notice, this list of conditions and the following disclaimer. */ /* */ /* Redistributions in binary form must reproduce the above copyright */ /* notice, this list of conditions and the following disclaimer in */ /* the documentation and/or other materials provided with the */ /* distribution. */ /* */ /* Neither the name of Texas Instruments Incorporated nor the names */ /* of its contributors may be used to endorse or promote products */ /* derived from this software without specific prior written */ /* permission. */ /* */ /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR */ /* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ /* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */ /* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */ /* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY */ /* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */ /* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */ /* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* */ /*****************************************************************************/ /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ // stdexcept standard header // exception standard header // xstddef standard header // cstddef standard header /* yvals.h values header for conforming compilers on various systems */ /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ /*****************************************************************************/ /* stddef.h v5.1.6 */ /* */ /* Copyright (c) 1993-2014 Texas Instruments Incorporated */ /* http://www.ti.com/ */ /* */ /* Redistribution and use in source and binary forms, with or without */ /* modification, are permitted provided that the following conditions */ /* are met: */ /* */ /* Redistributions of source code must retain the above copyright */ /* notice, this list of conditions and the following disclaimer. */ /* */ /* Redistributions in binary form must reproduce the above copyright */ /* notice, this list of conditions and the following disclaimer in */ /* the documentation and/or other materials provided with the */ /* distribution. */ /* */ /* Neither the name of Texas Instruments Incorporated nor the names */ /* of its contributors may be used to endorse or promote products */ /* derived from this software without specific prior written */ /* permission. */ /* */ /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR */ /* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ /* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */ /* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */ /* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY */ /* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */ /* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */ /* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* */ /*****************************************************************************/ extern "C" namespace std { typedef int ptrdiff_t; } /* extern "C" namespace std */ /*-----------------------------------------------------------------------*/ /* Define _win_t, for compiling GCC libraries with the TI compiler. */ /* GCC's library (newlib) expects wint_t to be defined here, in stddef.h,*/ /* which is arguably incorrect, but we go along for compatibility. */ /* This is outside the _STDDEF guard in case this file has already */ /* been included without __need_wint_t. */ /*-----------------------------------------------------------------------*/ /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ namespace std { // EXCEPTION MACROS // typename KEYWORD /* #define _TEMPLATE template<> */ /* #define _TEMPLATE_MEMBER template */ // BITMASK MACROS // MISCELLANEOUS MACROS // TYPE DEFINITIONS enum _Uninitialized { // tag for suppressing initialization _Noinit}; } /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ namespace std { // FORWARD REFERENCES class exception; typedef void (*_Prhand)(const exception&); extern _Prhand _Raise_handler; void _Throw(const exception&); // CLASS exception class exception { // base of all library exceptions, EDG version public: static _Prhand _Set_raise_handler(_Prhand _Pnew) { // register a handler for _Raise calls const _Prhand _Pold = _Raise_handler; _Raise_handler = _Pnew; return (_Pold); } explicit exception(const char *_Message = "unknown") : _Ptr(_Message) { // construct from message string } exception(const exception& _Right) : _Ptr(_Right._Ptr) { // construct by copying _Right } exception& operator=(const exception& _Right) { // assign _Right _Ptr = _Right._Ptr; return (*this); } virtual ~exception() { // destroy the object } virtual const char *what() const { // return pointer to message string return (_Ptr); } void _Raise() const { // raise the exception if (_Raise_handler != 0) (*_Raise_handler)(*this); // call raise handler if present _Doraise(); // call the protected virtual ::std:: _Throw(*this); // raise this exception } protected: virtual void _Doraise() const { // perform class-specific exception handling } const char *_Ptr; // the message pointer }; // CLASS bad_exception class bad_exception : public exception { // base of all bad exceptions, EDG version public: bad_exception(const char *_Message = "bad exception") : exception(_Message) { // construct from message string } virtual ~bad_exception() { // destroy the object } protected: virtual void _Doraise() const { // raise this exception ::std:: _Throw(*this); } }; // TYPES typedef void (*terminate_handler)(); typedef void (*unexpected_handler)(); // FUNCTION DECLARATIONS terminate_handler set_terminate(terminate_handler) ; unexpected_handler set_unexpected(unexpected_handler) ; bool uncaught_exception() ; void terminate(); void unexpected(); } /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ // xstring internal header (from ) // xmemory internal header (from ) // cstdlib standard header /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ // new standard header // exception standard header /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ namespace std { // CLASS bad_alloc class bad_alloc : public ::std:: exception { // base of all bad allocation exceptions public: bad_alloc(const char *_Message = "bad allocation") : exception(_Message) { // construct from message string } // virtual ~bad_alloc() _THROW0() // {} // destroy the object protected: virtual void _Doraise() const { // perform class-specific exception handling ::std:: _Throw(*this); } }; } namespace std { // SUPPORT TYPES typedef void (*new_handler)(); // handler for operator new failures struct nothrow_t { // placement new tag type to suppress exceptions }; extern const nothrow_t nothrow; // constant for placement new tag // FUNCTION AND OBJECT DECLARATIONS new_handler set_new_handler(new_handler) ; // establish alternate new handler extern new_handler _New_hand; // pointer to current new handler } // new AND delete DECLARATIONS (NB: NOT IN std) void operator delete(void *) ; // delete allocated storage void *operator new(::std:: size_t) ; // allocate or throw exception void *operator new(::std:: size_t, const ::std:: nothrow_t&) ; // allocate or return null pointer void *operator new (std::size_t, void *ptr) ; void operator delete[](void *) ; // delete allocated array void *operator new[](::std:: size_t) ; // allocate array or throw exception void *operator new[](::std:: size_t, const ::std:: nothrow_t&) ; // allocate array or return null pointer void *operator new[](std::size_t, void *ptr) ; void operator delete(void *, const ::std:: nothrow_t&) ; // delete if nothrow new fails -- REPLACEABLE void operator delete[](void *, const ::std:: nothrow_t&) ; // delete if nothrow array new fails -- REPLACEABLE void operator delete(void *, void *) ; // {} // delete if placement new fails void operator delete[](void *, void *) ; // {} // delete if placement array new fails /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ // xutility internal header // climits standard header /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ // utility standard header // iosfwd standard header // cstdio standard header /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ // cstring standard header /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ // cwchar standard header /* yvals.h values header for conforming compilers on various systems */ /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ /*****************************************************************************/ /* wchar.h v5.1.6 */ /* */ /* Copyright (c) 1993-2014 Texas Instruments Incorporated */ /* http://www.ti.com/ */ /* */ /* Redistribution and use in source and binary forms, with or without */ /* modification, are permitted provided that the following conditions */ /* are met: */ /* */ /* Redistributions of source code must retain the above copyright */ /* notice, this list of conditions and the following disclaimer. */ /* */ /* Redistributions in binary form must reproduce the above copyright */ /* notice, this list of conditions and the following disclaimer in */ /* the documentation and/or other materials provided with the */ /* distribution. */ /* */ /* Neither the name of Texas Instruments Incorporated nor the names */ /* of its contributors may be used to endorse or promote products */ /* derived from this software without specific prior written */ /* permission. */ /* */ /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR */ /* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ /* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */ /* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */ /* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY */ /* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */ /* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */ /* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* */ /*****************************************************************************/ /*---------------------------------------------------------------------------*/ /* minimal support for C++ library implementation */ /* provided by Dinkumware */ /*---------------------------------------------------------------------------*/ /* wchar.h minimal header for C++ */ /*****************************************************************************/ /* stddef.h v5.1.6 */ /* */ /* Copyright (c) 1993-2014 Texas Instruments Incorporated */ /* http://www.ti.com/ */ /* */ /* Redistribution and use in source and binary forms, with or without */ /* modification, are permitted provided that the following conditions */ /* are met: */ /* */ /* Redistributions of source code must retain the above copyright */ /* notice, this list of conditions and the following disclaimer. */ /* */ /* Redistributions in binary form must reproduce the above copyright */ /* notice, this list of conditions and the following disclaimer in */ /* the documentation and/or other materials provided with the */ /* distribution. */ /* */ /* Neither the name of Texas Instruments Incorporated nor the names */ /* of its contributors may be used to endorse or promote products */ /* derived from this software without specific prior written */ /* permission. */ /* */ /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR */ /* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ /* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */ /* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */ /* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY */ /* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */ /* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */ /* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* */ /*****************************************************************************/ /*-----------------------------------------------------------------------*/ /* Define _win_t, for compiling GCC libraries with the TI compiler. */ /* GCC's library (newlib) expects wint_t to be defined here, in stddef.h,*/ /* which is arguably incorrect, but we go along for compatibility. */ /* This is outside the _STDDEF guard in case this file has already */ /* been included without __need_wint_t. */ /*-----------------------------------------------------------------------*/ /*****************************************************************************/ /* STDIO.H v5.1.6 */ /* */ /* Copyright (c) 1993-2014 Texas Instruments Incorporated */ /* http://www.ti.com/ */ /* */ /* Redistribution and use in source and binary forms, with or without */ /* modification, are permitted provided that the following conditions */ /* are met: */ /* */ /* Redistributions of source code must retain the above copyright */ /* notice, this list of conditions and the following disclaimer. */ /* */ /* Redistributions in binary form must reproduce the above copyright */ /* notice, this list of conditions and the following disclaimer in */ /* the documentation and/or other materials provided with the */ /* distribution. */ /* */ /* Neither the name of Texas Instruments Incorporated nor the names */ /* of its contributors may be used to endorse or promote products */ /* derived from this software without specific prior written */ /* permission. */ /* */ /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR */ /* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ /* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */ /* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */ /* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY */ /* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */ /* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */ /* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* */ /*****************************************************************************/ namespace std { /*---------------------------------------------------------------------------*/ /* A header file conforming to ARM CLIB ABI (GENC-003539), should */ /* define _AEABI_PORTABLE when _AEABI_PORTABILITY_LEVEL is defined. */ /*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/ /* The macro definition that guards CLIB ABI (GENC-003539) requirements. */ /*---------------------------------------------------------------------------*/ /* MACROS */ /* TYPE DEFINITIONS */ typedef int _Mbstatet; typedef _Mbstatet mbstate_t; struct tm; typedef int wint_t; extern "C" { /* FUNCTIONS */ wint_t btowc(int); wint_t fgetwc(FILE *); wint_t fputwc(wchar_t, FILE *); size_t mbrtowc(wchar_t *, const char *, size_t, mbstate_t *); wint_t ungetwc(wint_t, FILE *); size_t wcslen(const wchar_t *); size_t wcrtomb(char *, wchar_t, mbstate_t *); int wctob(wint_t); int wmemcmp(const wchar_t *, const wchar_t *, size_t); wchar_t *wmemcpy(wchar_t *, const wchar_t *, size_t); wchar_t *wmemmove(wchar_t *, const wchar_t *, size_t); wchar_t *wmemset(wchar_t *, wchar_t, size_t); int fwide(FILE *str, int mode); wchar_t *wmemchr(const wchar_t *, wchar_t, size_t); } /* inlines/macros */ } /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ typedef std::mbstate_t _Mbstatet; /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ // xstddef standard header /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ namespace std { // STREAM POSITIONING TYPES (from ) typedef long streamoff; typedef int streamsize; extern fpos_t _Fpz; extern const streamoff _BADOFF; // TEMPLATE CLASS fpos (from ) template class fpos { // store arbitrary file position typedef fpos<_Statetype> _Myt; public: fpos(streamoff _Off = 0) : _Myoff(_Off), _Fpos(_Fpz), _Mystate(_Stz) { // construct with stream offset } fpos(_Statetype _State, fpos_t _Fileposition) : _Myoff(0), _Fpos(_Fileposition), _Mystate(_State) { // construct with conversion state and C file position } _Statetype state() const { // return conversion state return (_Mystate); } void state(_Statetype _State) { // set conversion state _Mystate = _State; } fpos_t seekpos() const { // return C file position return (_Fpos); } operator streamoff() const { // return offset return (_Myoff + ((long)(_Fpos))); } streamoff operator-(const _Myt& _Right) const { // return difference of file positions as an offset return ((streamoff)*this - (streamoff)_Right); } _Myt& operator+=(streamoff _Off) { // add offset _Myoff += _Off; return (*this); } _Myt& operator-=(streamoff _Off) { // subtract offset _Myoff -= _Off; return (*this); } _Myt operator+(streamoff _Off) const { // return this + offset _Myt _Tmp = *this; return (_Tmp += _Off); } _Myt operator-(streamoff _Off) const { // return this - offset _Myt _Tmp = *this; return (_Tmp -= _Off); } bool operator==(const _Myt& _Right) const { // test for file position equality return ((streamoff)*this == (streamoff)_Right); } bool operator==(streamoff _Right) const { // test for file position equality with streamoff return ((streamoff)*this == _Right); } bool operator!=(const _Myt& _Right) const { // test for file position inequality return (!(*this == _Right)); } private: static _Statetype _Stz; // initial conversion state streamoff _Myoff; // stream offset fpos_t _Fpos; // C file position _Statetype _Mystate; // current conversion state }; // STATIC fpos::_Stz OBJECT template _Statetype fpos<_Statetype>::_Stz; typedef fpos<_Mbstatet> streampos; typedef streampos wstreampos; // TEMPLATE STRUCT char_traits (FROM ) template struct char_traits { // properties of a string or stream element typedef _Elem char_type; typedef long int_type; typedef streampos pos_type; typedef streamoff off_type; typedef _Mbstatet state_type; static void assign(_Elem& _Left, const _Elem& _Right) { // assign an element _Left = _Right; } static bool eq(const _Elem& _Left, const _Elem& _Right) { // test for element equality return (_Left == _Right); } static bool lt(const _Elem& _Left, const _Elem& _Right) { // test if _Left precedes _Right return (_Left < _Right); } static int compare(const _Elem *_First1, const _Elem *_First2, size_t _Count) { // compare [_First1, _First1 + _Count) with [_First2, ...) // _DEBUG_POINTER(_First1); // _DEBUG_POINTER(_First2); for (; 0 < _Count; --_Count, ++_First1, ++_First2) if (!eq(*_First1, *_First2)) return (lt(*_First1, *_First2) ? -1 : +1); return (0); } static size_t length(const _Elem *_First) { // find length of null-terminated sequence // _DEBUG_POINTER(_First); size_t _Count; for (_Count = 0; !eq(*_First, _Elem()); ++_First) ++_Count; return (_Count); } static _Elem *copy(_Elem *_First1, const _Elem *_First2, size_t _Count) { // copy [_First1, _First1 + _Count) to [_First2, ...) // _DEBUG_POINTER(_First1); // _DEBUG_POINTER(_First2); _Elem *_Next = _First1; for (; 0 < _Count; --_Count, ++_Next, ++_First2) assign(*_Next, *_First2); return (_First1); } static const _Elem *find(const _Elem *_First, size_t _Count, const _Elem& _Ch) { // look for _Ch in [_First, _First + _Count) // _DEBUG_POINTER(_First); for (; 0 < _Count; --_Count, ++_First) if (eq(*_First, _Ch)) return (_First); return (0); } static _Elem *move(_Elem *_First1, const _Elem *_First2, size_t _Count) { // copy [_First1, _First1 + _Count) to [_First2, ...) // _DEBUG_POINTER(_First1); // _DEBUG_POINTER(_First2); _Elem *_Next = _First1; if (_First2 < _Next && _Next < _First2 + _Count) for (_Next += _Count, _First2 += _Count; 0 < _Count; --_Count) assign(*--_Next, *--_First2); else for (; 0 < _Count; --_Count, ++_Next, ++_First2) assign(*_Next, *_First2); return (_First1); } static _Elem *assign(_Elem *_First, size_t _Count, _Elem _Ch) { // assign _Count * _Ch to [_First, ...) // _DEBUG_POINTER(_First); _Elem *_Next = _First; for (; 0 < _Count; --_Count, ++_Next) assign(*_Next, _Ch); return (_First); } static _Elem to_char_type(const int_type& _Meta) { // convert metacharacter to character return ((_Elem)_Meta); } static int_type to_int_type(const _Elem& _Ch) { // convert character to metacharacter return ((int_type)_Ch); } static bool eq_int_type(const int_type& _Left, const int_type& _Right) { // test for metacharacter equality return (_Left == _Right); } static int_type eof() { // return end-of-file metacharacter return ((int_type)(-1)); } static int_type not_eof(const int_type& _Meta) { // return anything but EOF return (_Meta != eof() ? (int_type)_Meta : (int_type)!eof()); } }; // STRUCT char_traits template<> struct char_traits { // properties of a string or stream wchar_t element typedef wchar_t _Elem; typedef _Elem char_type; // for overloads typedef wint_t int_type; typedef streampos pos_type; typedef streamoff off_type; typedef _Mbstatet state_type; static void assign(_Elem& _Left, const _Elem& _Right) { // assign an element _Left = _Right; } static bool eq(const _Elem& _Left, const _Elem& _Right) { // test for element equality return (_Left == _Right); } static bool lt(const _Elem& _Left, const _Elem& _Right) { // test if _Left precedes _Right return (_Left < _Right); } static int compare(const _Elem *_First1, const _Elem *_First2, size_t _Count) { // compare [_First1, _First1 + _Count) with [_First2, ...) // _DEBUG_POINTER(_First1); // _DEBUG_POINTER(_First2); return (::std:: wmemcmp(_First1, _First2, _Count)); } static size_t length(const _Elem *_First) { // find length of null-terminated sequence // _DEBUG_POINTER(_First); return (::std:: wcslen(_First)); } static _Elem *copy(_Elem *_First1, const _Elem *_First2, size_t _Count) { // copy [_First1, _First1 + _Count) to [_First2, ...) // _DEBUG_POINTER(_First1); // _DEBUG_POINTER(_First2); return ((_Elem *)::std:: wmemcpy(_First1, _First2, _Count)); } static const _Elem *find(const _Elem *_First, size_t _Count, const _Elem& _Ch) { // look for _Ch in [_First, _First + _Count) // _DEBUG_POINTER(_First); return ((const _Elem *)::std:: wmemchr(_First, _Ch, _Count)); } static _Elem *move(_Elem *_First1, const _Elem *_First2, size_t _Count) { // copy [_First1, _First1 + _Count) to [_First2, ...) // _DEBUG_POINTER(_First1); // _DEBUG_POINTER(_First2); return ((_Elem *)::std:: wmemmove(_First1, _First2, _Count)); } static _Elem *assign(_Elem *_First, size_t _Count, _Elem _Ch) { // assign _Count * _Ch to [_First, ...) // _DEBUG_POINTER(_First); return ((_Elem *)::std:: wmemset(_First, _Ch, _Count)); } static _Elem to_char_type(const int_type& _Meta) { // convert metacharacter to character return (_Meta); } static int_type to_int_type(const _Elem& _Ch) { // convert character to metacharacter return (_Ch); } static bool eq_int_type(const int_type& _Left, const int_type& _Right) { // test for metacharacter equality return (_Left == _Right); } static int_type eof() { // return end-of-file metacharacter return (((::std:: wint_t)(-1))); } static int_type not_eof(const int_type& _Meta) { // return anything but EOF return (_Meta != eof() ? _Meta : !eof()); } }; // STRUCT char_traits (FROM ) template<> struct char_traits { // properties of a string or stream char element typedef char _Elem; typedef _Elem char_type; typedef int int_type; typedef streampos pos_type; typedef streamoff off_type; typedef _Mbstatet state_type; static void assign(_Elem& _Left, const _Elem& _Right) { // assign an element _Left = _Right; } static bool eq(const _Elem& _Left, const _Elem& _Right) { // test for element equality return (_Left == _Right); } static bool lt(const _Elem& _Left, const _Elem& _Right) { // test if _Left precedes _Right return (_Left < _Right); } static int compare(const _Elem *_First1, const _Elem *_First2, size_t _Count) { // compare [_First1, _First1 + _Count) with [_First2, ...) // _DEBUG_POINTER(_First1); // _DEBUG_POINTER(_First2); return (::std:: memcmp(_First1, _First2, _Count)); } static size_t length(const _Elem *_First) { // find length of null-terminated string // _DEBUG_POINTER(_First); return (::std:: strlen(_First)); } static _Elem *copy(_Elem *_First1, const _Elem *_First2, size_t _Count) { // copy [_First1, _First1 + _Count) to [_First2, ...) // _DEBUG_POINTER(_First1); // _DEBUG_POINTER(_First2); return ((_Elem *)::std:: memcpy(_First1, _First2, _Count)); } static const _Elem *find(const _Elem *_First, size_t _Count, const _Elem& _Ch) { // look for _Ch in [_First, _First + _Count) // _DEBUG_POINTER(_First); return ((const _Elem *)::std:: memchr(_First, _Ch, _Count)); } static _Elem *move(_Elem *_First1, const _Elem *_First2, size_t _Count) { // copy [_First1, _First1 + _Count) to [_First2, ...) // _DEBUG_POINTER(_First1); // _DEBUG_POINTER(_First2); return ((_Elem *)::std:: memmove(_First1, _First2, _Count)); } static _Elem *assign(_Elem *_First, size_t _Count, _Elem _Ch) { // assign _Count * _Ch to [_First, ...) // _DEBUG_POINTER(_First); return ((_Elem *)::std:: memset(_First, _Ch, _Count)); } static _Elem to_char_type(const int_type& _Meta) { // convert metacharacter to character return ((_Elem)_Meta); } static int_type to_int_type(const _Elem& _Ch) { // convert character to metacharacter return ((unsigned char)_Ch); } static bool eq_int_type(const int_type& _Left, const int_type& _Right) { // test for metacharacter equality return (_Left == _Right); } static int_type eof() { // return end-of-file metacharacter return ((-1)); } static int_type not_eof(const int_type& _Meta) { // return anything but EOF return (_Meta != eof() ? _Meta : !eof()); } }; // FORWARD REFERENCES template class allocator; class ios_base; template > class basic_ios; template > class istreambuf_iterator; template > class ostreambuf_iterator; template > class basic_streambuf; template > class basic_istream; template > class basic_ostream; template > class basic_iostream; template, class _Alloc = allocator<_Elem> > class basic_stringbuf; template, class _Alloc = allocator<_Elem> > class basic_istringstream; template, class _Alloc = allocator<_Elem> > class basic_ostringstream; template, class _Alloc = allocator<_Elem> > class basic_stringstream; template > class basic_filebuf; template > class basic_ifstream; template > class basic_ofstream; template > class basic_fstream; // char TYPEDEFS typedef basic_ios > ios; typedef basic_streambuf > streambuf; typedef basic_istream > istream; typedef basic_ostream > ostream; typedef basic_iostream > iostream; typedef basic_stringbuf, allocator > stringbuf; typedef basic_istringstream, allocator > istringstream; typedef basic_ostringstream, allocator > ostringstream; typedef basic_stringstream, allocator > stringstream; typedef basic_filebuf > filebuf; typedef basic_ifstream > ifstream; typedef basic_ofstream > ofstream; typedef basic_fstream > fstream; // wchat_t TYPEDEFS typedef basic_ios > wios; typedef basic_streambuf > wstreambuf; typedef basic_istream > wistream; typedef basic_ostream > wostream; typedef basic_iostream > wiostream; typedef basic_stringbuf, allocator > wstringbuf; typedef basic_istringstream, allocator > wistringstream; typedef basic_ostringstream, allocator > wostringstream; typedef basic_stringstream, allocator > wstringstream; typedef basic_filebuf > wfilebuf; typedef basic_ifstream > wifstream; typedef basic_ofstream > wofstream; typedef basic_fstream > wfstream; } /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. V4.02:1476 */ namespace std { // TEMPLATE FUNCTION swap (from ) template inline void swap(_Ty& _Left, _Ty& _Right) { // exchange values stored at _Left and _Right _Ty _Tmp = _Left; _Left = _Right, _Right = _Tmp; } // TEMPLATE STRUCT pair template struct pair { // store a pair of values typedef pair<_Ty1, _Ty2> _Myt; typedef _Ty1 first_type; typedef _Ty2 second_type; pair() : first(_Ty1()), second(_Ty2()) { // construct from defaults } pair(const _Ty1& _Val1, const _Ty2& _Val2) : first(_Val1), second(_Val2) { // construct from specified values } template pair(const pair<_Other1, _Other2>& _Right) : first(_Right.first), second(_Right.second) { // construct from compatible pair } void swap(_Myt& _Right) { // exchange contents with _Right ::std:: swap(first, _Right.first); ::std:: swap(second, _Right.second); } _Ty1 first; // the first stored value _Ty2 second; // the second stored value }; // pair TEMPLATE OPERATORS template inline void swap(pair<_Ty1, _Ty2>& _Left, pair<_Ty1, _Ty2>& _Right) { // swap _Left and _Right pairs _Left.swap(_Right); } template inline bool operator==(const pair<_Ty1, _Ty2>& _Left, const pair<_Ty1, _Ty2>& _Right) { // test for pair equality return (_Left.first == _Right.first && _Left.second == _Right.second); } template inline bool operator!=(const pair<_Ty1, _Ty2>& _Left, const pair<_Ty1, _Ty2>& _Right) { // test for pair inequality return (!(_Left == _Right)); } template inline bool operator<(const pair<_Ty1, _Ty2>& _Left, const pair<_Ty1, _Ty2>& _Right) { // test if _Left < _Right for pairs return (_Left.first < _Right.first || !(_Right.first < _Left.first) && _Left.second < _Right.second); } template inline bool operator>(const pair<_Ty1, _Ty2>& _Left, const pair<_Ty1, _Ty2>& _Right) { // test if _Left > _Right for pairs return (_Right < _Left); } template inline bool operator<=(const pair<_Ty1, _Ty2>& _Left, const pair<_Ty1, _Ty2>& _Right) { // test if _Left <= _Right for pairs return (!(_Right < _Left)); } template inline bool operator>=(const pair<_Ty1, _Ty2>& _Left, const pair<_Ty1, _Ty2>& _Right) { // test if _Left >= _Right for pairs return (!(_Left < _Right)); } template inline pair<_Ty1, _Ty2> make_pair(_Ty1 _Val1, _Ty2 _Val2) { // return pair composed from arguments return (pair<_Ty1, _Ty2>(_Val1, _Val2)); } // TEMPLATE OPERATORS namespace rel_ops { // nested namespace to hide relational operators from std template inline bool operator!=(const _Ty& _Left, const _Ty& _Right) { // test for inequality, in terms of equality return (!(_Left == _Right)); } template inline bool operator>(const _Ty& _Left, const _Ty& _Right) { // test if _Left > _Right, in terms of operator< return (_Right < _Left); } template inline bool operator<=(const _Ty& _Left, const _Ty& _Right) { // test if _Left <= _Right, in terms of operator< return (!(_Right < _Left)); } template inline bool operator>=(const _Ty& _Left, const _Ty& _Right) { // test if _Left >= _Right, in terms of operator< return (!(_Left < _Right)); } } } /* * Copyright (c) 1992-2004 by P.J. Plauger. ALL RIGHTS RESERVED. * Consult your license regarding permissions and restrictions. */ /* * This file is derived from software bearing the following * restrictions: * * Copyright (c) 1994 * Hewlett-Packard Company * * Permission to use, copy, modify, distribute and sell this * software and its documentation for any purpose is hereby * granted without fee, provided that the above copyright notice * appear in all copies and that both that copyright notice and * this permission notice appear in supporting documentation. * Hewlett-Packard Company makes no representations about the * suitability of this software for any purpose. It is provided * "as is" without express or implied warranty. V4.02:1476 */ namespace std { // MACROS struct _Container_base { // base of all containers }; struct _Iterator_base { // base of all iterators }; // ITERATOR STUFF (from ) // ITERATOR TAGS struct input_iterator_tag { // identifying tag for input iterators }; struct output_iterator_tag { // identifying tag for output iterators }; struct forward_iterator_tag : public input_iterator_tag { // identifying tag for forward iterators }; struct bidirectional_iterator_tag : public forward_iterator_tag { // identifying tag for bidirectional iterators }; struct random_access_iterator_tag : public bidirectional_iterator_tag { // identifying tag for random-access iterators }; struct _Int_iterator_tag { // identifying tag for integer types, not an iterator }; // POINTER ITERATOR TAGS struct _Nonscalar_ptr_iterator_tag { // pointer to unknown type }; struct _Scalar_ptr_iterator_tag { // pointer to scalar type }; // TEMPLATE CLASS iterator template struct iterator : public _Iterator_base { // base type for all iterator classes typedef _Category iterator_category; typedef _Ty value_type; typedef _Diff difference_type; typedef _Diff distance_type; // retained typedef _Pointer pointer; typedef _Reference reference; }; template struct _Bidit : public iterator { // base for bidirectional iterators }; template struct _Ranit : public iterator { // base for random-access iterators }; struct _Outit : public iterator { // base for output iterators }; // TEMPLATE CLASS iterator_traits template struct iterator_traits { // get traits from iterator _Iter typedef typename _Iter::iterator_category iterator_category; typedef typename _Iter::value_type value_type; typedef typename _Iter::difference_type difference_type; typedef difference_type distance_type; // retained typedef typename _Iter::pointer pointer; typedef typename _Iter::reference reference; }; template struct iterator_traits<_Ty *> { // get traits from pointer typedef random_access_iterator_tag iterator_category; typedef _Ty value_type; typedef ptrdiff_t difference_type; typedef ptrdiff_t distance_type; // retained typedef _Ty *pointer; typedef _Ty& reference; }; template struct iterator_traits { // get traits from const pointer typedef random_access_iterator_tag iterator_category; typedef _Ty value_type; typedef ptrdiff_t difference_type; typedef ptrdiff_t distance_type; // retained typedef const _Ty *pointer; typedef const _Ty& reference; }; template<> struct iterator_traits<_Bool> { // get traits from integer type typedef _Int_iterator_tag iterator_category; }; template<> struct iterator_traits { // get traits from integer type typedef _Int_iterator_tag iterator_category; }; template<> struct iterator_traits { // get traits from integer type typedef _Int_iterator_tag iterator_category; }; template<> struct iterator_traits { // get traits from integer type typedef _Int_iterator_tag iterator_category; }; template<> struct iterator_traits { // get traits from integer type typedef _Int_iterator_tag iterator_category; }; template<> struct iterator_traits { // get traits from integer type typedef _Int_iterator_tag iterator_category; }; template<> struct iterator_traits { // get traits from integer type typedef _Int_iterator_tag iterator_category; }; template<> struct iterator_traits { // get traits from integer type typedef _Int_iterator_tag iterator_category; }; template<> struct iterator_traits { // get traits from integer type typedef _Int_iterator_tag iterator_category; }; template<> struct iterator_traits { // get traits from integer type typedef _Int_iterator_tag iterator_category; }; template<> struct iterator_traits { // get traits from integer type typedef _Int_iterator_tag iterator_category; }; template<> struct iterator_traits { // get traits from integer type typedef _Int_iterator_tag iterator_category; }; template<> struct iterator_traits { // get traits from integer type typedef _Int_iterator_tag iterator_category; }; // TEMPLATE FUNCTION _Iter_cat template inline typename iterator_traits<_Iter>::iterator_category _Iter_cat(const _Iter&) { // return category from iterator argument typename iterator_traits<_Iter>::iterator_category _Cat; return (_Cat); } // TEMPLATE FUNCTION _Ptr_cat template inline _Nonscalar_ptr_iterator_tag _Ptr_cat(_T1&, _T2&) { // return pointer category from arbitrary arguments _Nonscalar_ptr_iterator_tag _Cat; return (_Cat); } template inline _Scalar_ptr_iterator_tag _Ptr_cat(_Ty **, _Ty **) { // return pointer category from pointer to pointer arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } template inline _Scalar_ptr_iterator_tag _Ptr_cat(_Ty *const *, _Ty **) { // return pointer category from pointer to pointer arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } template inline _Scalar_ptr_iterator_tag _Ptr_cat(_Ty **, const _Ty **) { // return pointer category from pointer to pointer arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } template inline _Scalar_ptr_iterator_tag _Ptr_cat(_Ty *const *, const _Ty **) { // return pointer category from pointer to pointer arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } // INTEGER FUNCTION _Ptr_cat inline _Scalar_ptr_iterator_tag _Ptr_cat(_Bool *, _Bool *) { // return pointer category from pointer to bool arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(const _Bool *, _Bool *) { // return pointer category from pointer to bool arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(char *, char *) { // return pointer category from pointer to char arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(const char *, char *) { // return pointer category from pointer to char arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(signed char *, signed char *) { // return pointer category from pointer to signed char arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(const signed char *, signed char *) { // return pointer category from pointer to signed char arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(unsigned char *, unsigned char *) { // return pointer category from pointer to unsigned char arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(const unsigned char *, unsigned char *) { // return pointer category from pointer to unsigned char arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(wchar_t *, wchar_t *) { // return pointer category from pointer to wchar_t arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(const wchar_t *, wchar_t *) { // return pointer category from pointer to wchar_t arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(short *, short *) { // return pointer category from pointer to short arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(const short *, short *) { // return pointer category from pointer to short arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(unsigned short *, unsigned short *) { // return pointer category from pointer to unsigned short arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(const unsigned short *, unsigned short *) { // return pointer category from pointer to unsigned short arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(int *, int *) { // return pointer category from pointer to int arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(const int *, int *) { // return pointer category from pointer to int arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(unsigned int *, unsigned int *) { // return pointer category from pointer to unsigned int arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(const unsigned int *, unsigned int *) { // return pointer category from pointer to unsigned int arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(long *, long *) { // return pointer category from pointer to long arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(const long *, long *) { // return pointer category from pointer to long arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(unsigned long *, unsigned long *) { // return pointer category from pointer to unsigned long arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(const unsigned long *, unsigned long *) { // return pointer category from pointer to unsigned long arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(float *, float *) { // return pointer category from pointer to float arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(const float *, float *) { // return pointer category from pointer to float arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(double *, double *) { // return pointer category from pointer to double arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(const double *, double *) { // return pointer category from pointer to double arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(long double *, long double *) { // return pointer category from pointer to long double arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(const long double *, long double *) { // return pointer category from pointer to long double arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(long long *, long long *) { // return pointer category from pointer to long long arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(const long long *, long long *) { // return pointer category from pointer to long long arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(unsigned long long *, unsigned long long *) { // return pointer category from pointer to ulong long arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } inline _Scalar_ptr_iterator_tag _Ptr_cat(const unsigned long long *, unsigned long long *) { // return pointer category from pointer to ulong long arguments _Scalar_ptr_iterator_tag _Cat; return (_Cat); } // ITERATOR DEBUGGING MACROS // TEMPLATE FUNCTION _Val_type template inline typename iterator_traits<_Iter>::value_type *_Val_type(_Iter) { // return value type from arbitrary argument return (0); } // TEMPLATE FUNCTION advance template inline void advance(_InIt& _Where, _Diff _Off) { // increment iterator by offset, arbitrary iterators _Advance(_Where, _Off, _Iter_cat(_Where)); } template inline void _Advance(_InIt& _Where, _Diff _Off, input_iterator_tag) { // increment iterator by offset, input iterators for (; 0 < _Off; --_Off) ++_Where; } template inline void _Advance(_FI& _Where, _Diff _Off, forward_iterator_tag) { // increment iterator by offset, forward iterators for (; 0 < _Off; --_Off) ++_Where; } template inline void _Advance(_BI& _Where, _Diff _Off, bidirectional_iterator_tag) { // increment iterator by offset, bidirectional iterators for (; 0 < _Off; --_Off) ++_Where; for (; _Off < 0; ++_Off) --_Where; } template inline void _Advance(_RI& _Where, _Diff _Off, random_access_iterator_tag) { // increment iterator by offset, random-access iterators _Where += _Off; } // TEMPLATE FUNCTION _Dist_type template inline typename iterator_traits<_Iter>::difference_type *_Dist_type(_Iter) { // return distance type from arbitrary argument return (0); } // TEMPLATE FUNCTIONS distance and _Distance template inline void _Distance2(_InIt _First, _InIt _Last, _Diff& _Off, input_iterator_tag) { // add to _Off distance between input iterators for (; _First != _Last; ++_First) ++_Off; } template inline void _Distance2(_FwdIt _First, _FwdIt _Last, _Diff& _Off, forward_iterator_tag) { // add to _Off distance between forward iterators (redundant) for (; _First != _Last; ++_First) ++_Off; } template inline void _Distance2(_BidIt _First, _BidIt _Last, _Diff& _Off, bidirectional_iterator_tag) { // add to _Off distance between bidirectional iterators (redundant) for (; _First != _Last; ++_First) ++_Off; } template inline void _Distance2(_RanIt _First, _RanIt _Last, _Diff& _Off, random_access_iterator_tag) { // add to _Off distance between random-access iterators _Off += _Last - _First; } template inline typename iterator_traits<_InIt>::difference_type distance(_InIt _First, _InIt _Last) { // return distance between iterators typename iterator_traits<_InIt>::difference_type _Off = 0; _Distance2(_First, _Last, _Off, _Iter_cat(_First)); return (_Off); } template inline void _Distance(_InIt _First, _InIt _Last, _Diff& _Off) { // add to _Off distance between iterators _Distance2(_First, _Last, _Off, _Iter_cat(_First)); } // TEMPLATE CLASS reverse_iterator template class reverse_iterator : public iterator< typename iterator_traits<_RanIt>::iterator_category, typename iterator_traits<_RanIt>::value_type, typename iterator_traits<_RanIt>::difference_type, typename iterator_traits<_RanIt>::pointer, typename iterator_traits<_RanIt>::reference> { // wrap iterator to run it backwards public: typedef reverse_iterator<_RanIt> _Myt; typedef typename iterator_traits<_RanIt>::difference_type difference_type; typedef typename iterator_traits<_RanIt>::pointer pointer; typedef typename iterator_traits<_RanIt>::reference reference; typedef _RanIt iterator_type; reverse_iterator() { // construct with default wrapped iterator } explicit reverse_iterator(_RanIt _Right) : current(_Right) { // construct wrapped iterator from _Right } template reverse_iterator(const reverse_iterator<_Other>& _Right) : current(_Right.base()) { // initialize with compatible base } _RanIt base() const { // return wrapped iterator return (current); } reference operator*() const { // return designated value _RanIt _Tmp = current; return (*--_Tmp); } pointer operator->() const { // return pointer to class object return (&**this); } _Myt& operator++() { // preincrement --current; return (*this); } _Myt operator++(int) { // postincrement _Myt _Tmp = *this; --current; return (_Tmp); } _Myt& operator--() { // predecrement ++current; return (*this); } _Myt operator--(int) { // postdecrement _Myt _Tmp = *this; ++current; return (_Tmp); } bool _Equal(const _Myt& _Right) const { // test for iterator equality return (current == _Right.current); } // N.B. functions valid for random-access iterators only beyond this point _Myt& operator+=(difference_type _Off) { // increment by integer current -= _Off; return (*this); } _Myt operator+(difference_type _Off) const { // return this + integer return (_Myt(current - _Off)); } _Myt& operator-=(difference_type _Off) { // decrement by integer current += _Off; return (*this); } _Myt operator-(difference_type _Off) const { // return this - integer return (_Myt(current + _Off)); } reference operator[](difference_type _Off) const { // subscript return (*(*this + _Off)); } bool _Less(const _Myt& _Right) const { // test if this < _Right return (_Right.current < current); } difference_type _Minus(const _Myt& _Right) const { // return difference of iterators return (_Right.current - current); } protected: _RanIt current; // the wrapped iterator }; // reverse_iterator TEMPLATE OPERATORS template inline reverse_iterator<_RanIt> operator+(_Diff _Off, const reverse_iterator<_RanIt>& _Right) { // return reverse_iterator + integer return (_Right + _Off); } template inline typename reverse_iterator<_RanIt>::difference_type operator-(const reverse_iterator<_RanIt>& _Left, const reverse_iterator<_RanIt>& _Right) { // return difference of reverse_iterators return (_Left._Minus(_Right));