mirror of
https://repo.dactyloidae.xyz/Dactyloidae/UXP.git
synced 2026-09-30 20:37:31 +09:00
import FIREFOX_52_6_0esr_RELEASE from mozilla-esr52 hg repo
This commit is contained in:
Roy Tam
commit
dcd9973243
150858 changed files with 23884658 additions and 0 deletions
17
modules/brotli/README.mozilla
Normal file
17
modules/brotli/README.mozilla
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
This is the Brotli data compression library from
|
||||
https://github.com/google/brotli.
|
||||
|
||||
Currently, we import only the Brotli decoder (the /dec/ subdirectory), not the
|
||||
encoder (/enc/ subdirectory).
|
||||
|
||||
Upstream code can be viewed at
|
||||
https://github.com/google/brotli/tree/master/dec
|
||||
|
||||
and cloned by
|
||||
git clone https://github.com/google/brotli
|
||||
|
||||
The in-tree copy is updated by running
|
||||
sh update.sh
|
||||
from within the modules/brotli directory.
|
||||
|
||||
Current version: [commit 29d31d5921b0a2b323ac24e7f7d0cdc9a3c0dd08].
|
||||
12
modules/brotli/dec/Makefile
Normal file
12
modules/brotli/dec/Makefile
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
#brotli/dec
|
||||
|
||||
include ../shared.mk
|
||||
|
||||
CFLAGS += -Wall
|
||||
|
||||
OBJS = bit_reader.o decode.o dictionary.o huffman.o state.o
|
||||
|
||||
all : $(OBJS)
|
||||
|
||||
clean :
|
||||
rm -f $(OBJS)
|
||||
48
modules/brotli/dec/bit_reader.c
Normal file
48
modules/brotli/dec/bit_reader.c
Normal file
|
|
@ -0,0 +1,48 @@
|
|||
/* Copyright 2013 Google Inc. All Rights Reserved.
|
||||
|
||||
Distributed under MIT license.
|
||||
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
/* Bit reading helpers */
|
||||
|
||||
#include "./bit_reader.h"
|
||||
|
||||
#include "./port.h"
|
||||
#include "./types.h"
|
||||
|
||||
#if defined(__cplusplus) || defined(c_plusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void BrotliInitBitReader(BrotliBitReader* const br) {
|
||||
br->val_ = 0;
|
||||
br->bit_pos_ = sizeof(br->val_) << 3;
|
||||
}
|
||||
|
||||
int BrotliWarmupBitReader(BrotliBitReader* const br) {
|
||||
size_t aligned_read_mask = (sizeof(br->val_) >> 1) - 1;
|
||||
/* Fixing alignment after unaligned BrotliFillWindow would result accumulator
|
||||
overflow. If unalignment is caused by BrotliSafeReadBits, then there is
|
||||
enough space in accumulator to fix aligment. */
|
||||
if (!BROTLI_ALIGNED_READ) {
|
||||
aligned_read_mask = 0;
|
||||
}
|
||||
if (BrotliGetAvailableBits(br) == 0) {
|
||||
if (!BrotliPullByte(br)) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
while ((((size_t)br->next_in) & aligned_read_mask) != 0) {
|
||||
if (!BrotliPullByte(br)) {
|
||||
/* If we consumed all the input, we don't care about the alignment. */
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
#if defined(__cplusplus) || defined(c_plusplus)
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
383
modules/brotli/dec/bit_reader.h
Normal file
383
modules/brotli/dec/bit_reader.h
Normal file
|
|
@ -0,0 +1,383 @@
|
|||
/* Copyright 2013 Google Inc. All Rights Reserved.
|
||||
|
||||
Distributed under MIT license.
|
||||
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
/* Bit reading helpers */
|
||||
|
||||
#ifndef BROTLI_DEC_BIT_READER_H_
|
||||
#define BROTLI_DEC_BIT_READER_H_
|
||||
|
||||
#include <string.h> /* memcpy */
|
||||
|
||||
#include "./port.h"
|
||||
#include "./types.h"
|
||||
|
||||
#if defined(__cplusplus) || defined(c_plusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#if (BROTLI_64_BITS)
|
||||
#define BROTLI_SHORT_FILL_BIT_WINDOW_READ 4
|
||||
typedef uint64_t reg_t;
|
||||
#else
|
||||
#define BROTLI_SHORT_FILL_BIT_WINDOW_READ 2
|
||||
typedef uint32_t reg_t;
|
||||
#endif
|
||||
|
||||
static const uint32_t kBitMask[33] = { 0x0000,
|
||||
0x00000001, 0x00000003, 0x00000007, 0x0000000F,
|
||||
0x0000001F, 0x0000003F, 0x0000007F, 0x000000FF,
|
||||
0x000001FF, 0x000003FF, 0x000007FF, 0x00000FFF,
|
||||
0x00001FFF, 0x00003FFF, 0x00007FFF, 0x0000FFFF,
|
||||
0x0001FFFF, 0x0003FFFF, 0x0007FFFF, 0x000FFFFF,
|
||||
0x001FFFFF, 0x003FFFFF, 0x007FFFFF, 0x00FFFFFF,
|
||||
0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF, 0x0FFFFFFF,
|
||||
0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF, 0xFFFFFFFF
|
||||
};
|
||||
|
||||
static BROTLI_INLINE uint32_t BitMask(uint32_t n) {
|
||||
if (IS_CONSTANT(n) || BROTLI_HAS_UBFX) {
|
||||
/* Masking with this expression turns to a single
|
||||
"Unsigned Bit Field Extract" UBFX instruction on ARM. */
|
||||
return ~((0xffffffffU) << n);
|
||||
} else {
|
||||
return kBitMask[n];
|
||||
}
|
||||
}
|
||||
|
||||
typedef struct {
|
||||
reg_t val_; /* pre-fetched bits */
|
||||
uint32_t bit_pos_; /* current bit-reading position in val_ */
|
||||
const uint8_t* next_in; /* the byte we're reading from */
|
||||
size_t avail_in;
|
||||
} BrotliBitReader;
|
||||
|
||||
typedef struct {
|
||||
reg_t val_;
|
||||
uint32_t bit_pos_;
|
||||
const uint8_t* next_in;
|
||||
size_t avail_in;
|
||||
} BrotliBitReaderState;
|
||||
|
||||
/* Initializes the bitreader fields. */
|
||||
BROTLI_INTERNAL void BrotliInitBitReader(BrotliBitReader* const br);
|
||||
|
||||
/* Ensures that accumulator is not empty. May consume one byte of input.
|
||||
Returns 0 if data is required but there is no input available.
|
||||
For BROTLI_ALIGNED_READ this function also prepares bit reader for aligned
|
||||
reading. */
|
||||
BROTLI_INTERNAL int BrotliWarmupBitReader(BrotliBitReader* const br);
|
||||
|
||||
static BROTLI_INLINE void BrotliBitReaderSaveState(
|
||||
BrotliBitReader* const from, BrotliBitReaderState* to) {
|
||||
to->val_ = from->val_;
|
||||
to->bit_pos_ = from->bit_pos_;
|
||||
to->next_in = from->next_in;
|
||||
to->avail_in = from->avail_in;
|
||||
}
|
||||
|
||||
static BROTLI_INLINE void BrotliBitReaderRestoreState(
|
||||
BrotliBitReader* const to, BrotliBitReaderState* from) {
|
||||
to->val_ = from->val_;
|
||||
to->bit_pos_ = from->bit_pos_;
|
||||
to->next_in = from->next_in;
|
||||
to->avail_in = from->avail_in;
|
||||
}
|
||||
|
||||
static BROTLI_INLINE uint32_t BrotliGetAvailableBits(
|
||||
const BrotliBitReader* br) {
|
||||
return (BROTLI_64_BITS ? 64 : 32) - br->bit_pos_;
|
||||
}
|
||||
|
||||
/* Returns amount of unread bytes the bit reader still has buffered from the
|
||||
BrotliInput, including whole bytes in br->val_. */
|
||||
static BROTLI_INLINE size_t BrotliGetRemainingBytes(BrotliBitReader* br) {
|
||||
return br->avail_in + (BrotliGetAvailableBits(br) >> 3);
|
||||
}
|
||||
|
||||
/* Checks if there is at least num bytes left in the input ringbuffer (excluding
|
||||
the bits remaining in br->val_). */
|
||||
static BROTLI_INLINE int BrotliCheckInputAmount(
|
||||
BrotliBitReader* const br, size_t num) {
|
||||
return br->avail_in >= num;
|
||||
}
|
||||
|
||||
static BROTLI_INLINE uint16_t BrotliLoad16LE(const uint8_t* in) {
|
||||
if (BROTLI_LITTLE_ENDIAN) {
|
||||
return *((const uint16_t*)in);
|
||||
} else if (BROTLI_BIG_ENDIAN) {
|
||||
uint16_t value = *((const uint16_t*)in);
|
||||
return (uint16_t)(((value & 0xFFU) << 8) | ((value & 0xFF00U) >> 8));
|
||||
} else {
|
||||
return (uint16_t)(in[0] | (in[1] << 8));
|
||||
}
|
||||
}
|
||||
|
||||
static BROTLI_INLINE uint32_t BrotliLoad32LE(const uint8_t* in) {
|
||||
if (BROTLI_LITTLE_ENDIAN) {
|
||||
return *((const uint32_t*)in);
|
||||
} else if (BROTLI_BIG_ENDIAN) {
|
||||
uint32_t value = *((const uint32_t*)in);
|
||||
return ((value & 0xFFU) << 24) | ((value & 0xFF00U) << 8) |
|
||||
((value & 0xFF0000U) >> 8) | ((value & 0xFF000000U) >> 24);
|
||||
} else {
|
||||
uint32_t value = (uint32_t)(*(in++));
|
||||
value |= (uint32_t)(*(in++)) << 8;
|
||||
value |= (uint32_t)(*(in++)) << 16;
|
||||
value |= (uint32_t)(*(in++)) << 24;
|
||||
return value;
|
||||
}
|
||||
}
|
||||
|
||||
#if (BROTLI_64_BITS)
|
||||
static BROTLI_INLINE uint64_t BrotliLoad64LE(const uint8_t* in) {
|
||||
if (BROTLI_LITTLE_ENDIAN) {
|
||||
return *((const uint64_t*)in);
|
||||
} else if (BROTLI_BIG_ENDIAN) {
|
||||
uint64_t value = *((const uint64_t*)in);
|
||||
return
|
||||
((value & 0xFFU) << 56) |
|
||||
((value & 0xFF00U) << 40) |
|
||||
((value & 0xFF0000U) << 24) |
|
||||
((value & 0xFF000000U) << 8) |
|
||||
((value & 0xFF00000000U) >> 8) |
|
||||
((value & 0xFF0000000000U) >> 24) |
|
||||
((value & 0xFF000000000000U) >> 40) |
|
||||
((value & 0xFF00000000000000U) >> 56);
|
||||
} else {
|
||||
uint64_t value = (uint64_t)(*(in++));
|
||||
value |= (uint64_t)(*(in++)) << 8;
|
||||
value |= (uint64_t)(*(in++)) << 16;
|
||||
value |= (uint64_t)(*(in++)) << 24;
|
||||
value |= (uint64_t)(*(in++)) << 32;
|
||||
value |= (uint64_t)(*(in++)) << 40;
|
||||
value |= (uint64_t)(*(in++)) << 48;
|
||||
value |= (uint64_t)(*(in++)) << 56;
|
||||
return value;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Guarantees that there are at least n_bits + 1 bits in accumulator.
|
||||
Precondition: accumulator contains at least 1 bit.
|
||||
n_bits should be in the range [1..24] for regular build. For portable
|
||||
non-64-bit little endian build only 16 bits are safe to request. */
|
||||
static BROTLI_INLINE void BrotliFillBitWindow(
|
||||
BrotliBitReader* const br, uint32_t n_bits) {
|
||||
#if (BROTLI_64_BITS)
|
||||
if (!BROTLI_ALIGNED_READ && IS_CONSTANT(n_bits) && (n_bits <= 8)) {
|
||||
if (br->bit_pos_ >= 56) {
|
||||
br->val_ >>= 56;
|
||||
br->bit_pos_ ^= 56; /* here same as -= 56 because of the if condition */
|
||||
br->val_ |= BrotliLoad64LE(br->next_in) << 8;
|
||||
br->avail_in -= 7;
|
||||
br->next_in += 7;
|
||||
}
|
||||
} else if (!BROTLI_ALIGNED_READ && IS_CONSTANT(n_bits) && (n_bits <= 16)) {
|
||||
if (br->bit_pos_ >= 48) {
|
||||
br->val_ >>= 48;
|
||||
br->bit_pos_ ^= 48; /* here same as -= 48 because of the if condition */
|
||||
br->val_ |= BrotliLoad64LE(br->next_in) << 16;
|
||||
br->avail_in -= 6;
|
||||
br->next_in += 6;
|
||||
}
|
||||
} else {
|
||||
if (br->bit_pos_ >= 32) {
|
||||
br->val_ >>= 32;
|
||||
br->bit_pos_ ^= 32; /* here same as -= 32 because of the if condition */
|
||||
br->val_ |= ((uint64_t)BrotliLoad32LE(br->next_in)) << 32;
|
||||
br->avail_in -= BROTLI_SHORT_FILL_BIT_WINDOW_READ;
|
||||
br->next_in += BROTLI_SHORT_FILL_BIT_WINDOW_READ;
|
||||
}
|
||||
}
|
||||
#else
|
||||
if (!BROTLI_ALIGNED_READ && IS_CONSTANT(n_bits) && (n_bits <= 8)) {
|
||||
if (br->bit_pos_ >= 24) {
|
||||
br->val_ >>= 24;
|
||||
br->bit_pos_ ^= 24; /* here same as -= 24 because of the if condition */
|
||||
br->val_ |= BrotliLoad32LE(br->next_in) << 8;
|
||||
br->avail_in -= 3;
|
||||
br->next_in += 3;
|
||||
}
|
||||
} else {
|
||||
if (br->bit_pos_ >= 16) {
|
||||
br->val_ >>= 16;
|
||||
br->bit_pos_ ^= 16; /* here same as -= 16 because of the if condition */
|
||||
br->val_ |= ((uint32_t)BrotliLoad16LE(br->next_in)) << 16;
|
||||
br->avail_in -= BROTLI_SHORT_FILL_BIT_WINDOW_READ;
|
||||
br->next_in += BROTLI_SHORT_FILL_BIT_WINDOW_READ;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
/* Mosltly like BrotliFillBitWindow, but guarantees only 16 bits and reads no
|
||||
more than BROTLI_SHORT_FILL_BIT_WINDOW_READ bytes of input. */
|
||||
static BROTLI_INLINE void BrotliFillBitWindow16(BrotliBitReader* const br) {
|
||||
BrotliFillBitWindow(br, 17);
|
||||
}
|
||||
|
||||
/* Pulls one byte of input to accumulator. */
|
||||
static BROTLI_INLINE int BrotliPullByte(BrotliBitReader* const br) {
|
||||
if (br->avail_in == 0) {
|
||||
return 0;
|
||||
}
|
||||
br->val_ >>= 8;
|
||||
#if (BROTLI_64_BITS)
|
||||
br->val_ |= ((uint64_t)*br->next_in) << 56;
|
||||
#else
|
||||
br->val_ |= ((uint32_t)*br->next_in) << 24;
|
||||
#endif
|
||||
br->bit_pos_ -= 8;
|
||||
--br->avail_in;
|
||||
++br->next_in;
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Returns currently available bits.
|
||||
The number of valid bits could be calclulated by BrotliGetAvailableBits. */
|
||||
static BROTLI_INLINE reg_t BrotliGetBitsUnmasked(BrotliBitReader* const br) {
|
||||
return br->val_ >> br->bit_pos_;
|
||||
}
|
||||
|
||||
/* Like BrotliGetBits, but does not mask the result.
|
||||
The result contains at least 16 valid bits. */
|
||||
static BROTLI_INLINE uint32_t BrotliGet16BitsUnmasked(
|
||||
BrotliBitReader* const br) {
|
||||
BrotliFillBitWindow(br, 16);
|
||||
return (uint32_t)BrotliGetBitsUnmasked(br);
|
||||
}
|
||||
|
||||
/* Returns the specified number of bits from br without advancing bit pos. */
|
||||
static BROTLI_INLINE uint32_t BrotliGetBits(
|
||||
BrotliBitReader* const br, uint32_t n_bits) {
|
||||
BrotliFillBitWindow(br, n_bits);
|
||||
return (uint32_t)BrotliGetBitsUnmasked(br) & BitMask(n_bits);
|
||||
}
|
||||
|
||||
/* Tries to peek the specified amount of bits. Returns 0, if there is not
|
||||
enough input. */
|
||||
static BROTLI_INLINE int BrotliSafeGetBits(
|
||||
BrotliBitReader* const br, uint32_t n_bits, uint32_t* val) {
|
||||
while (BrotliGetAvailableBits(br) < n_bits) {
|
||||
if (!BrotliPullByte(br)) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
*val = (uint32_t)BrotliGetBitsUnmasked(br) & BitMask(n_bits);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Advances the bit pos by n_bits. */
|
||||
static BROTLI_INLINE void BrotliDropBits(
|
||||
BrotliBitReader* const br, uint32_t n_bits) {
|
||||
br->bit_pos_ += n_bits;
|
||||
}
|
||||
|
||||
static BROTLI_INLINE void BrotliBitReaderUnload(BrotliBitReader* br) {
|
||||
uint32_t unused_bytes = BrotliGetAvailableBits(br) >> 3;
|
||||
uint32_t unused_bits = unused_bytes << 3;
|
||||
br->avail_in += unused_bytes;
|
||||
br->next_in -= unused_bytes;
|
||||
if (unused_bits == sizeof(br->val_) << 3) {
|
||||
br->val_ = 0;
|
||||
} else {
|
||||
br->val_ <<= unused_bits;
|
||||
}
|
||||
br->bit_pos_ += unused_bits;
|
||||
}
|
||||
|
||||
/* Reads the specified number of bits from br and advances the bit pos.
|
||||
Precondition: accumulator MUST contain at least n_bits. */
|
||||
static BROTLI_INLINE void BrotliTakeBits(
|
||||
BrotliBitReader* const br, uint32_t n_bits, uint32_t* val) {
|
||||
*val = (uint32_t)BrotliGetBitsUnmasked(br) & BitMask(n_bits);
|
||||
BROTLI_LOG(("[BrotliReadBits] %d %d %d val: %6x\n",
|
||||
(int)br->avail_in, (int)br->bit_pos_, n_bits, (int)*val));
|
||||
BrotliDropBits(br, n_bits);
|
||||
}
|
||||
|
||||
/* Reads the specified number of bits from br and advances the bit pos.
|
||||
Assumes that there is enough input to perform BrotliFillBitWindow. */
|
||||
static BROTLI_INLINE uint32_t BrotliReadBits(
|
||||
BrotliBitReader* const br, uint32_t n_bits) {
|
||||
if (BROTLI_64_BITS || (n_bits <= 16)) {
|
||||
uint32_t val;
|
||||
BrotliFillBitWindow(br, n_bits);
|
||||
BrotliTakeBits(br, n_bits, &val);
|
||||
return val;
|
||||
} else {
|
||||
uint32_t low_val;
|
||||
uint32_t high_val;
|
||||
BrotliFillBitWindow(br, 16);
|
||||
BrotliTakeBits(br, 16, &low_val);
|
||||
BrotliFillBitWindow(br, 8);
|
||||
BrotliTakeBits(br, n_bits - 16, &high_val);
|
||||
return low_val | (high_val << 16);
|
||||
}
|
||||
}
|
||||
|
||||
/* Tries to read the specified amount of bits. Returns 0, if there is not
|
||||
enough input. n_bits MUST be positive. */
|
||||
static BROTLI_INLINE int BrotliSafeReadBits(
|
||||
BrotliBitReader* const br, uint32_t n_bits, uint32_t* val) {
|
||||
while (BrotliGetAvailableBits(br) < n_bits) {
|
||||
if (!BrotliPullByte(br)) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
BrotliTakeBits(br, n_bits, val);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Advances the bit reader position to the next byte boundary and verifies
|
||||
that any skipped bits are set to zero. */
|
||||
static BROTLI_INLINE int BrotliJumpToByteBoundary(BrotliBitReader* br) {
|
||||
uint32_t pad_bits_count = BrotliGetAvailableBits(br) & 0x7;
|
||||
uint32_t pad_bits = 0;
|
||||
if (pad_bits_count != 0) {
|
||||
BrotliTakeBits(br, pad_bits_count, &pad_bits);
|
||||
}
|
||||
return pad_bits == 0;
|
||||
}
|
||||
|
||||
/* Peeks a byte at specified offset.
|
||||
Precondition: bit reader is parked to a byte boundary.
|
||||
Returns -1 if operation is not feasible. */
|
||||
static BROTLI_INLINE int BrotliPeekByte(BrotliBitReader* br, size_t offset) {
|
||||
uint32_t available_bits = BrotliGetAvailableBits(br);
|
||||
size_t bytes_left = available_bits >> 3;
|
||||
BROTLI_DCHECK((available_bits & 7) == 0);
|
||||
if (offset < bytes_left) {
|
||||
return (BrotliGetBitsUnmasked(br) >> (unsigned)(offset << 3)) & 0xFF;
|
||||
}
|
||||
offset -= bytes_left;
|
||||
if (offset < br->avail_in) {
|
||||
return br->next_in[offset];
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Copies remaining input bytes stored in the bit reader to the output. Value
|
||||
num may not be larger than BrotliGetRemainingBytes. The bit reader must be
|
||||
warmed up again after this. */
|
||||
static BROTLI_INLINE void BrotliCopyBytes(uint8_t* dest,
|
||||
BrotliBitReader* br, size_t num) {
|
||||
while (BrotliGetAvailableBits(br) >= 8 && num > 0) {
|
||||
*dest = (uint8_t)BrotliGetBitsUnmasked(br);
|
||||
BrotliDropBits(br, 8);
|
||||
++dest;
|
||||
--num;
|
||||
}
|
||||
memcpy(dest, br->next_in, num);
|
||||
br->avail_in -= num;
|
||||
br->next_in += num;
|
||||
}
|
||||
|
||||
#if defined(__cplusplus) || defined(c_plusplus)
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* BROTLI_DEC_BIT_READER_H_ */
|
||||
251
modules/brotli/dec/context.h
Normal file
251
modules/brotli/dec/context.h
Normal file
|
|
@ -0,0 +1,251 @@
|
|||
/* Copyright 2013 Google Inc. All Rights Reserved.
|
||||
|
||||
Distributed under MIT license.
|
||||
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
/* Lookup table to map the previous two bytes to a context id.
|
||||
|
||||
There are four different context modeling modes defined here:
|
||||
CONTEXT_LSB6: context id is the least significant 6 bits of the last byte,
|
||||
CONTEXT_MSB6: context id is the most significant 6 bits of the last byte,
|
||||
CONTEXT_UTF8: second-order context model tuned for UTF8-encoded text,
|
||||
CONTEXT_SIGNED: second-order context model tuned for signed integers.
|
||||
|
||||
The context id for the UTF8 context model is calculated as follows. If p1
|
||||
and p2 are the previous two bytes, we calculate the context as
|
||||
|
||||
context = kContextLookup[p1] | kContextLookup[p2 + 256].
|
||||
|
||||
If the previous two bytes are ASCII characters (i.e. < 128), this will be
|
||||
equivalent to
|
||||
|
||||
context = 4 * context1(p1) + context2(p2),
|
||||
|
||||
where context1 is based on the previous byte in the following way:
|
||||
|
||||
0 : non-ASCII control
|
||||
1 : \t, \n, \r
|
||||
2 : space
|
||||
3 : other punctuation
|
||||
4 : " '
|
||||
5 : %
|
||||
6 : ( < [ {
|
||||
7 : ) > ] }
|
||||
8 : , ; :
|
||||
9 : .
|
||||
10 : =
|
||||
11 : number
|
||||
12 : upper-case vowel
|
||||
13 : upper-case consonant
|
||||
14 : lower-case vowel
|
||||
15 : lower-case consonant
|
||||
|
||||
and context2 is based on the second last byte:
|
||||
|
||||
0 : control, space
|
||||
1 : punctuation
|
||||
2 : upper-case letter, number
|
||||
3 : lower-case letter
|
||||
|
||||
If the last byte is ASCII, and the second last byte is not (in a valid UTF8
|
||||
stream it will be a continuation byte, value between 128 and 191), the
|
||||
context is the same as if the second last byte was an ASCII control or space.
|
||||
|
||||
If the last byte is a UTF8 lead byte (value >= 192), then the next byte will
|
||||
be a continuation byte and the context id is 2 or 3 depending on the LSB of
|
||||
the last byte and to a lesser extent on the second last byte if it is ASCII.
|
||||
|
||||
If the last byte is a UTF8 continuation byte, the second last byte can be:
|
||||
- continuation byte: the next byte is probably ASCII or lead byte (assuming
|
||||
4-byte UTF8 characters are rare) and the context id is 0 or 1.
|
||||
- lead byte (192 - 207): next byte is ASCII or lead byte, context is 0 or 1
|
||||
- lead byte (208 - 255): next byte is continuation byte, context is 2 or 3
|
||||
|
||||
The possible value combinations of the previous two bytes, the range of
|
||||
context ids and the type of the next byte is summarized in the table below:
|
||||
|
||||
|--------\-----------------------------------------------------------------|
|
||||
| \ Last byte |
|
||||
| Second \---------------------------------------------------------------|
|
||||
| last byte \ ASCII | cont. byte | lead byte |
|
||||
| \ (0-127) | (128-191) | (192-) |
|
||||
|=============|===================|=====================|==================|
|
||||
| ASCII | next: ASCII/lead | not valid | next: cont. |
|
||||
| (0-127) | context: 4 - 63 | | context: 2 - 3 |
|
||||
|-------------|-------------------|---------------------|------------------|
|
||||
| cont. byte | next: ASCII/lead | next: ASCII/lead | next: cont. |
|
||||
| (128-191) | context: 4 - 63 | context: 0 - 1 | context: 2 - 3 |
|
||||
|-------------|-------------------|---------------------|------------------|
|
||||
| lead byte | not valid | next: ASCII/lead | not valid |
|
||||
| (192-207) | | context: 0 - 1 | |
|
||||
|-------------|-------------------|---------------------|------------------|
|
||||
| lead byte | not valid | next: cont. | not valid |
|
||||
| (208-) | | context: 2 - 3 | |
|
||||
|-------------|-------------------|---------------------|------------------|
|
||||
|
||||
The context id for the signed context mode is calculated as:
|
||||
|
||||
context = (kContextLookup[512 + p1] << 3) | kContextLookup[512 + p2].
|
||||
|
||||
For any context modeling modes, the context ids can be calculated by |-ing
|
||||
together two lookups from one table using context model dependent offsets:
|
||||
|
||||
context = kContextLookup[offset1 + p1] | kContextLookup[offset2 + p2].
|
||||
|
||||
where offset1 and offset2 are dependent on the context mode.
|
||||
*/
|
||||
|
||||
#ifndef BROTLI_DEC_CONTEXT_H_
|
||||
#define BROTLI_DEC_CONTEXT_H_
|
||||
|
||||
#include "./types.h"
|
||||
|
||||
enum ContextType {
|
||||
CONTEXT_LSB6 = 0,
|
||||
CONTEXT_MSB6 = 1,
|
||||
CONTEXT_UTF8 = 2,
|
||||
CONTEXT_SIGNED = 3
|
||||
};
|
||||
|
||||
/* Common context lookup table for all context modes. */
|
||||
static const uint8_t kContextLookup[1792] = {
|
||||
/* CONTEXT_UTF8, last byte. */
|
||||
/* ASCII range. */
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 0, 4, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
8, 12, 16, 12, 12, 20, 12, 16, 24, 28, 12, 12, 32, 12, 36, 12,
|
||||
44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 32, 32, 24, 40, 28, 12,
|
||||
12, 48, 52, 52, 52, 48, 52, 52, 52, 48, 52, 52, 52, 52, 52, 48,
|
||||
52, 52, 52, 52, 52, 48, 52, 52, 52, 52, 52, 24, 12, 28, 12, 12,
|
||||
12, 56, 60, 60, 60, 56, 60, 60, 60, 56, 60, 60, 60, 60, 60, 56,
|
||||
60, 60, 60, 60, 60, 56, 60, 60, 60, 60, 60, 24, 12, 28, 12, 0,
|
||||
/* UTF8 continuation byte range. */
|
||||
0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
|
||||
0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
|
||||
0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
|
||||
0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
|
||||
/* UTF8 lead byte range. */
|
||||
2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3,
|
||||
2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3,
|
||||
2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3,
|
||||
2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3,
|
||||
/* CONTEXT_UTF8 second last byte. */
|
||||
/* ASCII range. */
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1,
|
||||
1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1,
|
||||
1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1, 1, 1, 1, 0,
|
||||
/* UTF8 continuation byte range. */
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/* UTF8 lead byte range. */
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
/* CONTEXT_SIGNED, second last byte. */
|
||||
0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7,
|
||||
/* CONTEXT_SIGNED, last byte, same as the above values shifted by 3 bits. */
|
||||
0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
|
||||
16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
|
||||
16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
|
||||
16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
|
||||
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
|
||||
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
|
||||
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
|
||||
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
|
||||
32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
|
||||
32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
|
||||
32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
|
||||
32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
|
||||
40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
|
||||
40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
|
||||
40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
|
||||
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 56,
|
||||
/* CONTEXT_LSB6, last byte. */
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
|
||||
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
|
||||
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
|
||||
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
|
||||
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
|
||||
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
|
||||
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
|
||||
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
|
||||
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
|
||||
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
|
||||
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
|
||||
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
|
||||
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
|
||||
/* CONTEXT_MSB6, last byte. */
|
||||
0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3,
|
||||
4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7,
|
||||
8, 8, 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11,
|
||||
12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15,
|
||||
16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19,
|
||||
20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23,
|
||||
24, 24, 24, 24, 25, 25, 25, 25, 26, 26, 26, 26, 27, 27, 27, 27,
|
||||
28, 28, 28, 28, 29, 29, 29, 29, 30, 30, 30, 30, 31, 31, 31, 31,
|
||||
32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 34, 35, 35, 35, 35,
|
||||
36, 36, 36, 36, 37, 37, 37, 37, 38, 38, 38, 38, 39, 39, 39, 39,
|
||||
40, 40, 40, 40, 41, 41, 41, 41, 42, 42, 42, 42, 43, 43, 43, 43,
|
||||
44, 44, 44, 44, 45, 45, 45, 45, 46, 46, 46, 46, 47, 47, 47, 47,
|
||||
48, 48, 48, 48, 49, 49, 49, 49, 50, 50, 50, 50, 51, 51, 51, 51,
|
||||
52, 52, 52, 52, 53, 53, 53, 53, 54, 54, 54, 54, 55, 55, 55, 55,
|
||||
56, 56, 56, 56, 57, 57, 57, 57, 58, 58, 58, 58, 59, 59, 59, 59,
|
||||
60, 60, 60, 60, 61, 61, 61, 61, 62, 62, 62, 62, 63, 63, 63, 63,
|
||||
/* CONTEXT_{M,L}SB6, second last byte, */
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
};
|
||||
|
||||
static const int kContextLookupOffsets[8] = {
|
||||
/* CONTEXT_LSB6 */
|
||||
1024, 1536,
|
||||
/* CONTEXT_MSB6 */
|
||||
1280, 1536,
|
||||
/* CONTEXT_UTF8 */
|
||||
0, 256,
|
||||
/* CONTEXT_SIGNED */
|
||||
768, 512,
|
||||
};
|
||||
|
||||
#endif /* BROTLI_DEC_CONTEXT_H_ */
|
||||
2262
modules/brotli/dec/decode.c
Normal file
2262
modules/brotli/dec/decode.c
Normal file
File diff suppressed because it is too large
Load diff
162
modules/brotli/dec/decode.h
Normal file
162
modules/brotli/dec/decode.h
Normal file
|
|
@ -0,0 +1,162 @@
|
|||
/* Copyright 2013 Google Inc. All Rights Reserved.
|
||||
|
||||
Distributed under MIT license.
|
||||
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
/* API for Brotli decompression */
|
||||
|
||||
#ifndef BROTLI_DEC_DECODE_H_
|
||||
#define BROTLI_DEC_DECODE_H_
|
||||
|
||||
#include "./types.h"
|
||||
|
||||
#if defined(__cplusplus) || defined(c_plusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef struct BrotliStateStruct BrotliState;
|
||||
|
||||
typedef enum {
|
||||
/* Decoding error, e.g. corrupt input or memory allocation problem */
|
||||
BROTLI_RESULT_ERROR = 0,
|
||||
/* Decoding successfully completed */
|
||||
BROTLI_RESULT_SUCCESS = 1,
|
||||
/* Partially done; should be called again with more input */
|
||||
BROTLI_RESULT_NEEDS_MORE_INPUT = 2,
|
||||
/* Partially done; should be called again with more output */
|
||||
BROTLI_RESULT_NEEDS_MORE_OUTPUT = 3
|
||||
} BrotliResult;
|
||||
|
||||
#define BROTLI_ERROR_CODES_LIST(BROTLI_ERROR_CODE, SEPARATOR) \
|
||||
BROTLI_ERROR_CODE(_, NO_ERROR, 0) SEPARATOR \
|
||||
/* Same as BrotliResult values */ \
|
||||
BROTLI_ERROR_CODE(_, SUCCESS, 1) SEPARATOR \
|
||||
BROTLI_ERROR_CODE(_, NEEDS_MORE_INPUT, 2) SEPARATOR \
|
||||
BROTLI_ERROR_CODE(_, NEEDS_MORE_OUTPUT, 3) SEPARATOR \
|
||||
\
|
||||
/* Errors caused by invalid input */ \
|
||||
BROTLI_ERROR_CODE(_ERROR_FORMAT_, EXUBERANT_NIBBLE, -1) SEPARATOR \
|
||||
BROTLI_ERROR_CODE(_ERROR_FORMAT_, RESERVED, -2) SEPARATOR \
|
||||
BROTLI_ERROR_CODE(_ERROR_FORMAT_, EXUBERANT_META_NIBBLE, -3) SEPARATOR \
|
||||
BROTLI_ERROR_CODE(_ERROR_FORMAT_, SIMPLE_HUFFMAN_ALPHABET, -4) SEPARATOR \
|
||||
BROTLI_ERROR_CODE(_ERROR_FORMAT_, SIMPLE_HUFFMAN_SAME, -5) SEPARATOR \
|
||||
BROTLI_ERROR_CODE(_ERROR_FORMAT_, CL_SPACE, -6) SEPARATOR \
|
||||
BROTLI_ERROR_CODE(_ERROR_FORMAT_, HUFFMAN_SPACE, -7) SEPARATOR \
|
||||
BROTLI_ERROR_CODE(_ERROR_FORMAT_, CONTEXT_MAP_REPEAT, -8) SEPARATOR \
|
||||
BROTLI_ERROR_CODE(_ERROR_FORMAT_, BLOCK_LENGTH_1, -9) SEPARATOR \
|
||||
BROTLI_ERROR_CODE(_ERROR_FORMAT_, BLOCK_LENGTH_2, -10) SEPARATOR \
|
||||
BROTLI_ERROR_CODE(_ERROR_FORMAT_, TRANSFORM, -11) SEPARATOR \
|
||||
BROTLI_ERROR_CODE(_ERROR_FORMAT_, DICTIONARY, -12) SEPARATOR \
|
||||
BROTLI_ERROR_CODE(_ERROR_FORMAT_, WINDOW_BITS, -13) SEPARATOR \
|
||||
BROTLI_ERROR_CODE(_ERROR_FORMAT_, PADDING_1, -14) SEPARATOR \
|
||||
BROTLI_ERROR_CODE(_ERROR_FORMAT_, PADDING_2, -15) SEPARATOR \
|
||||
\
|
||||
/* -16..-20 codes are reserved */ \
|
||||
\
|
||||
/* Memory allocation problems */ \
|
||||
BROTLI_ERROR_CODE(_ERROR_ALLOC_, CONTEXT_MODES, -21) SEPARATOR \
|
||||
/* Literal, insert and distance trees together */ \
|
||||
BROTLI_ERROR_CODE(_ERROR_ALLOC_, TREE_GROUPS, -22) SEPARATOR \
|
||||
/* -23..-24 codes are reserved for distinct tree groups */ \
|
||||
BROTLI_ERROR_CODE(_ERROR_ALLOC_, CONTEXT_MAP, -25) SEPARATOR \
|
||||
BROTLI_ERROR_CODE(_ERROR_ALLOC_, RING_BUFFER_1, -26) SEPARATOR \
|
||||
BROTLI_ERROR_CODE(_ERROR_ALLOC_, RING_BUFFER_2, -27) SEPARATOR \
|
||||
/* -28..-29 codes are reserved for dynamic ringbuffer allocation */ \
|
||||
BROTLI_ERROR_CODE(_ERROR_ALLOC_, BLOCK_TYPE_TREES, -30) SEPARATOR \
|
||||
\
|
||||
/* "Impossible" states */ \
|
||||
BROTLI_ERROR_CODE(_ERROR_, UNREACHABLE, -31)
|
||||
|
||||
typedef enum {
|
||||
#define _BROTLI_COMMA ,
|
||||
#define _BROTLI_ERROR_CODE_ENUM_ITEM(PREFIX, NAME, CODE) \
|
||||
BROTLI ## PREFIX ## NAME = CODE
|
||||
BROTLI_ERROR_CODES_LIST(_BROTLI_ERROR_CODE_ENUM_ITEM, _BROTLI_COMMA)
|
||||
#undef _BROTLI_ERROR_CODE_ENUM_ITEM
|
||||
#undef _BROTLI_COMMA
|
||||
} BrotliErrorCode;
|
||||
|
||||
#define BROTLI_LAST_ERROR_CODE BROTLI_ERROR_UNREACHABLE
|
||||
|
||||
/* Creates the instance of BrotliState and initializes it. |alloc_func| and
|
||||
|free_func| MUST be both zero or both non-zero. In the case they are both
|
||||
zero, default memory allocators are used. |opaque| is passed to |alloc_func|
|
||||
and |free_func| when they are called. */
|
||||
BrotliState* BrotliCreateState(
|
||||
brotli_alloc_func alloc_func, brotli_free_func free_func, void* opaque);
|
||||
|
||||
/* Deinitializes and frees BrotliState instance. */
|
||||
void BrotliDestroyState(BrotliState* state);
|
||||
|
||||
/* Sets |*decoded_size| to the decompressed size of the given encoded stream.
|
||||
This function only works if the encoded buffer has a single meta block,
|
||||
or if it has two meta-blocks, where the first is uncompressed and the
|
||||
second is empty.
|
||||
Returns 1 on success, 0 on failure. */
|
||||
int BrotliDecompressedSize(size_t encoded_size,
|
||||
const uint8_t* encoded_buffer,
|
||||
size_t* decoded_size);
|
||||
|
||||
/* Decompresses the data in |encoded_buffer| into |decoded_buffer|, and sets
|
||||
|*decoded_size| to the decompressed length. */
|
||||
BrotliResult BrotliDecompressBuffer(size_t encoded_size,
|
||||
const uint8_t* encoded_buffer,
|
||||
size_t* decoded_size,
|
||||
uint8_t* decoded_buffer);
|
||||
|
||||
/* Decompresses the data. Supports partial input and output.
|
||||
|
||||
Must be called with an allocated input buffer in |*next_in| and an allocated
|
||||
output buffer in |*next_out|. The values |*available_in| and |*available_out|
|
||||
must specify the allocated size in |*next_in| and |*next_out| respectively.
|
||||
|
||||
After each call, |*available_in| will be decremented by the amount of input
|
||||
bytes consumed, and the |*next_in| pointer will be incremented by that
|
||||
amount. Similarly, |*available_out| will be decremented by the amount of
|
||||
output bytes written, and the |*next_out| pointer will be incremented by that
|
||||
amount. |total_out|, if it is not a null-pointer, will be set to the number
|
||||
of bytes decompressed since the last state initialization.
|
||||
|
||||
Input is never overconsumed, so |next_in| and |available_in| could be passed
|
||||
to the next consumer after decoding is complete. */
|
||||
BrotliResult BrotliDecompressStream(size_t* available_in,
|
||||
const uint8_t** next_in,
|
||||
size_t* available_out,
|
||||
uint8_t** next_out,
|
||||
size_t* total_out,
|
||||
BrotliState* s);
|
||||
|
||||
/* Fills the new state with a dictionary for LZ77, warming up the ringbuffer,
|
||||
e.g. for custom static dictionaries for data formats.
|
||||
Not to be confused with the built-in transformable dictionary of Brotli.
|
||||
|size| should be less or equal to 2^24 (16MiB), otherwise the dictionary will
|
||||
be ignored. The dictionary must exist in memory until decoding is done and
|
||||
is owned by the caller. To use:
|
||||
1) Allocate and initialize state with BrotliCreateState
|
||||
2) Use BrotliSetCustomDictionary
|
||||
3) Use BrotliDecompressStream
|
||||
4) Clean up and free state with BrotliDestroyState
|
||||
*/
|
||||
void BrotliSetCustomDictionary(
|
||||
size_t size, const uint8_t* dict, BrotliState* s);
|
||||
|
||||
/* Returns 1, if s is in a state where we have not read any input bytes yet,
|
||||
and 0 otherwise */
|
||||
int BrotliStateIsStreamStart(const BrotliState* s);
|
||||
|
||||
/* Returns 1, if s is in a state where we reached the end of the input and
|
||||
produced all of the output, and 0 otherwise. */
|
||||
int BrotliStateIsStreamEnd(const BrotliState* s);
|
||||
|
||||
/* Returns detailed error code after BrotliDecompressStream returns
|
||||
BROTLI_RESULT_ERROR. */
|
||||
BrotliErrorCode BrotliGetErrorCode(const BrotliState* s);
|
||||
|
||||
const char* BrotliErrorString(BrotliErrorCode c);
|
||||
|
||||
#if defined(__cplusplus) || defined(c_plusplus)
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* BROTLI_DEC_DECODE_H_ */
|
||||
9466
modules/brotli/dec/dictionary.c
Normal file
9466
modules/brotli/dec/dictionary.c
Normal file
File diff suppressed because it is too large
Load diff
38
modules/brotli/dec/dictionary.h
Normal file
38
modules/brotli/dec/dictionary.h
Normal file
|
|
@ -0,0 +1,38 @@
|
|||
/* Copyright 2013 Google Inc. All Rights Reserved.
|
||||
|
||||
Distributed under MIT license.
|
||||
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
/* Collection of static dictionary words. */
|
||||
|
||||
#ifndef BROTLI_DEC_DICTIONARY_H_
|
||||
#define BROTLI_DEC_DICTIONARY_H_
|
||||
|
||||
#include "./types.h"
|
||||
|
||||
#if defined(__cplusplus) || defined(c_plusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern const uint8_t kBrotliDictionary[122784];
|
||||
|
||||
static const uint32_t kBrotliDictionaryOffsetsByLength[] = {
|
||||
0, 0, 0, 0, 0, 4096, 9216, 21504, 35840, 44032, 53248, 63488, 74752, 87040,
|
||||
93696, 100864, 104704, 106752, 108928, 113536, 115968, 118528, 119872, 121280,
|
||||
122016
|
||||
};
|
||||
|
||||
static const uint8_t kBrotliDictionarySizeBitsByLength[] = {
|
||||
0, 0, 0, 0, 10, 10, 11, 11, 10, 10, 10, 10, 10,
|
||||
9, 9, 8, 7, 7, 8, 7, 7, 6, 6, 5, 5,
|
||||
};
|
||||
|
||||
static const int kBrotliMinDictionaryWordLength = 4;
|
||||
static const int kBrotliMaxDictionaryWordLength = 24;
|
||||
|
||||
#if defined(__cplusplus) || defined(c_plusplus)
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* BROTLI_DEC_DICTIONARY_H_ */
|
||||
356
modules/brotli/dec/huffman.c
Normal file
356
modules/brotli/dec/huffman.c
Normal file
|
|
@ -0,0 +1,356 @@
|
|||
/* Copyright 2013 Google Inc. All Rights Reserved.
|
||||
|
||||
Distributed under MIT license.
|
||||
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
/* Utilities for building Huffman decoding tables. */
|
||||
|
||||
#include "./huffman.h"
|
||||
|
||||
#include <string.h> /* memcpy, memset */
|
||||
|
||||
#include "./port.h"
|
||||
#include "./types.h"
|
||||
|
||||
#if defined(__cplusplus) || defined(c_plusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define BROTLI_REVERSE_BITS_MAX 8
|
||||
|
||||
#ifdef BROTLI_RBIT
|
||||
#define BROTLI_REVERSE_BITS_BASE (32 - BROTLI_REVERSE_BITS_MAX)
|
||||
#else
|
||||
#define BROTLI_REVERSE_BITS_BASE 0
|
||||
static uint8_t kReverseBits[1 << BROTLI_REVERSE_BITS_MAX] = {
|
||||
0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
|
||||
0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
|
||||
0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
|
||||
0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
|
||||
0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
|
||||
0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
|
||||
0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
|
||||
0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
|
||||
0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,
|
||||
0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
|
||||
0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
|
||||
0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
|
||||
0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
|
||||
0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
|
||||
0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,
|
||||
0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
|
||||
0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
|
||||
0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
|
||||
0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,
|
||||
0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
|
||||
0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
|
||||
0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
|
||||
0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
|
||||
0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
|
||||
0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,
|
||||
0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
|
||||
0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,
|
||||
0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
|
||||
0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
|
||||
0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
|
||||
0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
|
||||
0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
|
||||
};
|
||||
#endif /* BROTLI_RBIT */
|
||||
|
||||
#define BROTLI_REVERSE_BITS_LOWEST \
|
||||
(1U << (BROTLI_REVERSE_BITS_MAX - 1 + BROTLI_REVERSE_BITS_BASE))
|
||||
|
||||
/* Returns reverse(num >> BROTLI_REVERSE_BITS_BASE, BROTLI_REVERSE_BITS_MAX),
|
||||
where reverse(value, len) is the bit-wise reversal of the len least
|
||||
significant bits of value. */
|
||||
static BROTLI_INLINE uint32_t BrotliReverseBits(uint32_t num) {
|
||||
#ifdef BROTLI_RBIT
|
||||
return BROTLI_RBIT(num);
|
||||
#else
|
||||
return kReverseBits[num];
|
||||
#endif
|
||||
}
|
||||
|
||||
/* Stores code in table[0], table[step], table[2*step], ..., table[end] */
|
||||
/* Assumes that end is an integer multiple of step */
|
||||
static BROTLI_INLINE void ReplicateValue(HuffmanCode* table,
|
||||
int step, int end,
|
||||
HuffmanCode code) {
|
||||
do {
|
||||
end -= step;
|
||||
table[end] = code;
|
||||
} while (end > 0);
|
||||
}
|
||||
|
||||
/* Returns the table width of the next 2nd level table. count is the histogram
|
||||
of bit lengths for the remaining symbols, len is the code length of the next
|
||||
processed symbol */
|
||||
static BROTLI_INLINE int NextTableBitSize(const uint16_t* const count,
|
||||
int len, int root_bits) {
|
||||
int left = 1 << (len - root_bits);
|
||||
while (len < BROTLI_HUFFMAN_MAX_CODE_LENGTH) {
|
||||
left -= count[len];
|
||||
if (left <= 0) break;
|
||||
++len;
|
||||
left <<= 1;
|
||||
}
|
||||
return len - root_bits;
|
||||
}
|
||||
|
||||
void BrotliBuildCodeLengthsHuffmanTable(HuffmanCode* table,
|
||||
const uint8_t* const code_lengths,
|
||||
uint16_t* count) {
|
||||
HuffmanCode code; /* current table entry */
|
||||
int symbol; /* symbol index in original or sorted table */
|
||||
uint32_t key; /* prefix code */
|
||||
uint32_t key_step; /* prefix code addend */
|
||||
int step; /* step size to replicate values in current table */
|
||||
int table_size; /* size of current table */
|
||||
int sorted[18]; /* symbols sorted by code length */
|
||||
/* offsets in sorted table for each length */
|
||||
int offset[BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH + 1];
|
||||
int bits;
|
||||
int bits_count;
|
||||
BROTLI_DCHECK(BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH <=
|
||||
BROTLI_REVERSE_BITS_MAX);
|
||||
|
||||
/* generate offsets into sorted symbol table by code length */
|
||||
symbol = -1;
|
||||
bits = 1;
|
||||
BROTLI_REPEAT(BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH, {
|
||||
symbol += count[bits];
|
||||
offset[bits] = symbol;
|
||||
bits++;
|
||||
});
|
||||
/* Symbols with code length 0 are placed after all other symbols. */
|
||||
offset[0] = 17;
|
||||
|
||||
/* sort symbols by length, by symbol order within each length */
|
||||
symbol = 18;
|
||||
do {
|
||||
BROTLI_REPEAT(6, {
|
||||
symbol--;
|
||||
sorted[offset[code_lengths[symbol]]--] = symbol;
|
||||
});
|
||||
} while (symbol != 0);
|
||||
|
||||
table_size = 1 << BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH;
|
||||
|
||||
/* Special case: all symbols but one have 0 code length. */
|
||||
if (offset[0] == 0) {
|
||||
code.bits = 0;
|
||||
code.value = (uint16_t)sorted[0];
|
||||
for (key = 0; key < (uint32_t)table_size; ++key) {
|
||||
table[key] = code;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/* fill in table */
|
||||
key = 0;
|
||||
key_step = BROTLI_REVERSE_BITS_LOWEST;
|
||||
symbol = 0;
|
||||
bits = 1;
|
||||
step = 2;
|
||||
do {
|
||||
code.bits = (uint8_t)bits;
|
||||
for (bits_count = count[bits]; bits_count != 0; --bits_count) {
|
||||
code.value = (uint16_t)sorted[symbol++];
|
||||
ReplicateValue(&table[BrotliReverseBits(key)], step, table_size, code);
|
||||
key += key_step;
|
||||
}
|
||||
step <<= 1;
|
||||
key_step >>= 1;
|
||||
} while (++bits <= BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH);
|
||||
}
|
||||
|
||||
uint32_t BrotliBuildHuffmanTable(HuffmanCode* root_table,
|
||||
int root_bits,
|
||||
const uint16_t* const symbol_lists,
|
||||
uint16_t* count) {
|
||||
HuffmanCode code; /* current table entry */
|
||||
HuffmanCode* table; /* next available space in table */
|
||||
int len; /* current code length */
|
||||
int symbol; /* symbol index in original or sorted table */
|
||||
uint32_t key; /* prefix code */
|
||||
uint32_t key_step; /* prefix code addend */
|
||||
uint32_t sub_key; /* 2nd level table prefix code */
|
||||
uint32_t sub_key_step; /* 2nd level table prefix code addend */
|
||||
int step; /* step size to replicate values in current table */
|
||||
int table_bits; /* key length of current table */
|
||||
int table_size; /* size of current table */
|
||||
int total_size; /* sum of root table size and 2nd level table sizes */
|
||||
int max_length = -1;
|
||||
int bits;
|
||||
int bits_count;
|
||||
|
||||
BROTLI_DCHECK(root_bits <= BROTLI_REVERSE_BITS_MAX);
|
||||
BROTLI_DCHECK(BROTLI_HUFFMAN_MAX_CODE_LENGTH - root_bits <=
|
||||
BROTLI_REVERSE_BITS_MAX);
|
||||
|
||||
while (symbol_lists[max_length] == 0xFFFF) max_length--;
|
||||
max_length += BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1;
|
||||
|
||||
table = root_table;
|
||||
table_bits = root_bits;
|
||||
table_size = 1 << table_bits;
|
||||
total_size = table_size;
|
||||
|
||||
/* fill in root table */
|
||||
/* let's reduce the table size to a smaller size if possible, and */
|
||||
/* create the repetitions by memcpy if possible in the coming loop */
|
||||
if (table_bits > max_length) {
|
||||
table_bits = max_length;
|
||||
table_size = 1 << table_bits;
|
||||
}
|
||||
key = 0;
|
||||
key_step = BROTLI_REVERSE_BITS_LOWEST;
|
||||
bits = 1;
|
||||
step = 2;
|
||||
do {
|
||||
code.bits = (uint8_t)bits;
|
||||
symbol = bits - (BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1);
|
||||
for (bits_count = count[bits]; bits_count != 0; --bits_count) {
|
||||
symbol = symbol_lists[symbol];
|
||||
code.value = (uint16_t)symbol;
|
||||
ReplicateValue(&table[BrotliReverseBits(key)], step, table_size, code);
|
||||
key += key_step;
|
||||
}
|
||||
step <<= 1;
|
||||
key_step >>= 1;
|
||||
} while (++bits <= table_bits);
|
||||
|
||||
/* if root_bits != table_bits we only created one fraction of the */
|
||||
/* table, and we need to replicate it now. */
|
||||
while (total_size != table_size) {
|
||||
memcpy(&table[table_size], &table[0],
|
||||
(size_t)table_size * sizeof(table[0]));
|
||||
table_size <<= 1;
|
||||
}
|
||||
|
||||
/* fill in 2nd level tables and add pointers to root table */
|
||||
key_step = BROTLI_REVERSE_BITS_LOWEST >> (root_bits - 1);
|
||||
sub_key = (BROTLI_REVERSE_BITS_LOWEST << 1);
|
||||
sub_key_step = BROTLI_REVERSE_BITS_LOWEST;
|
||||
for (len = root_bits + 1, step = 2; len <= max_length; ++len) {
|
||||
symbol = len - (BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1);
|
||||
for (; count[len] != 0; --count[len]) {
|
||||
if (sub_key == (BROTLI_REVERSE_BITS_LOWEST << 1U)) {
|
||||
table += table_size;
|
||||
table_bits = NextTableBitSize(count, len, root_bits);
|
||||
table_size = 1 << table_bits;
|
||||
total_size += table_size;
|
||||
sub_key = BrotliReverseBits(key);
|
||||
key += key_step;
|
||||
root_table[sub_key].bits = (uint8_t)(table_bits + root_bits);
|
||||
root_table[sub_key].value =
|
||||
(uint16_t)(((size_t)(table - root_table)) - sub_key);
|
||||
sub_key = 0;
|
||||
}
|
||||
code.bits = (uint8_t)(len - root_bits);
|
||||
symbol = symbol_lists[symbol];
|
||||
code.value = (uint16_t)symbol;
|
||||
ReplicateValue(
|
||||
&table[BrotliReverseBits(sub_key)], step, table_size, code);
|
||||
sub_key += sub_key_step;
|
||||
}
|
||||
step <<= 1;
|
||||
sub_key_step >>= 1;
|
||||
}
|
||||
return (uint32_t)total_size;
|
||||
}
|
||||
|
||||
uint32_t BrotliBuildSimpleHuffmanTable(HuffmanCode* table,
|
||||
int root_bits,
|
||||
uint16_t* val,
|
||||
uint32_t num_symbols) {
|
||||
uint32_t table_size = 1;
|
||||
const uint32_t goal_size = 1U << root_bits;
|
||||
switch (num_symbols) {
|
||||
case 0:
|
||||
table[0].bits = 0;
|
||||
table[0].value = val[0];
|
||||
break;
|
||||
case 1:
|
||||
table[0].bits = 1;
|
||||
table[1].bits = 1;
|
||||
if (val[1] > val[0]) {
|
||||
table[0].value = val[0];
|
||||
table[1].value = val[1];
|
||||
} else {
|
||||
table[0].value = val[1];
|
||||
table[1].value = val[0];
|
||||
}
|
||||
table_size = 2;
|
||||
break;
|
||||
case 2:
|
||||
table[0].bits = 1;
|
||||
table[0].value = val[0];
|
||||
table[2].bits = 1;
|
||||
table[2].value = val[0];
|
||||
if (val[2] > val[1]) {
|
||||
table[1].value = val[1];
|
||||
table[3].value = val[2];
|
||||
} else {
|
||||
table[1].value = val[2];
|
||||
table[3].value = val[1];
|
||||
}
|
||||
table[1].bits = 2;
|
||||
table[3].bits = 2;
|
||||
table_size = 4;
|
||||
break;
|
||||
case 3: {
|
||||
int i, k;
|
||||
for (i = 0; i < 3; ++i) {
|
||||
for (k = i + 1; k < 4; ++k) {
|
||||
if (val[k] < val[i]) {
|
||||
uint16_t t = val[k];
|
||||
val[k] = val[i];
|
||||
val[i] = t;
|
||||
}
|
||||
}
|
||||
}
|
||||
for (i = 0; i < 4; ++i) {
|
||||
table[i].bits = 2;
|
||||
}
|
||||
table[0].value = val[0];
|
||||
table[2].value = val[1];
|
||||
table[1].value = val[2];
|
||||
table[3].value = val[3];
|
||||
table_size = 4;
|
||||
break;
|
||||
}
|
||||
case 4: {
|
||||
int i;
|
||||
if (val[3] < val[2]) {
|
||||
uint16_t t = val[3];
|
||||
val[3] = val[2];
|
||||
val[2] = t;
|
||||
}
|
||||
for (i = 0; i < 7; ++i) {
|
||||
table[i].value = val[0];
|
||||
table[i].bits = (uint8_t)(1 + (i & 1));
|
||||
}
|
||||
table[1].value = val[1];
|
||||
table[3].value = val[2];
|
||||
table[5].value = val[1];
|
||||
table[7].value = val[3];
|
||||
table[3].bits = 3;
|
||||
table[7].bits = 3;
|
||||
table_size = 8;
|
||||
break;
|
||||
}
|
||||
}
|
||||
while (table_size != goal_size) {
|
||||
memcpy(&table[table_size], &table[0],
|
||||
(size_t)table_size * sizeof(table[0]));
|
||||
table_size <<= 1;
|
||||
}
|
||||
return goal_size;
|
||||
}
|
||||
|
||||
#if defined(__cplusplus) || defined(c_plusplus)
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
68
modules/brotli/dec/huffman.h
Normal file
68
modules/brotli/dec/huffman.h
Normal file
|
|
@ -0,0 +1,68 @@
|
|||
/* Copyright 2013 Google Inc. All Rights Reserved.
|
||||
|
||||
Distributed under MIT license.
|
||||
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
/* Utilities for building Huffman decoding tables. */
|
||||
|
||||
#ifndef BROTLI_DEC_HUFFMAN_H_
|
||||
#define BROTLI_DEC_HUFFMAN_H_
|
||||
|
||||
#include "./types.h"
|
||||
#include "./port.h"
|
||||
|
||||
#if defined(__cplusplus) || defined(c_plusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define BROTLI_HUFFMAN_MAX_CODE_LENGTH 15
|
||||
|
||||
/* For current format this constant equals to kNumInsertAndCopyCodes */
|
||||
#define BROTLI_HUFFMAN_MAX_CODE_LENGTHS_SIZE 704
|
||||
|
||||
/* Maximum possible Huffman table size for an alphabet size of (index * 32),
|
||||
* max code length 15 and root table bits 8. */
|
||||
static const uint16_t kMaxHuffmanTableSize[] = {
|
||||
256, 402, 436, 468, 500, 534, 566, 598, 630, 662, 694, 726, 758, 790, 822,
|
||||
854, 886, 920, 952, 984, 1016, 1048, 1080};
|
||||
#define BROTLI_HUFFMAN_MAX_SIZE_26 396
|
||||
#define BROTLI_HUFFMAN_MAX_SIZE_258 632
|
||||
#define BROTLI_HUFFMAN_MAX_SIZE_272 646
|
||||
|
||||
#define BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH 5
|
||||
|
||||
typedef struct {
|
||||
uint8_t bits; /* number of bits used for this symbol */
|
||||
uint16_t value; /* symbol value or table offset */
|
||||
} HuffmanCode;
|
||||
|
||||
/* Builds Huffman lookup table assuming code lengths are in symbol order. */
|
||||
BROTLI_INTERNAL void BrotliBuildCodeLengthsHuffmanTable(HuffmanCode* root_table,
|
||||
const uint8_t* const code_lengths, uint16_t* count);
|
||||
|
||||
/* Builds Huffman lookup table assuming code lengths are in symbol order. */
|
||||
/* Returns size of resulting table. */
|
||||
BROTLI_INTERNAL uint32_t BrotliBuildHuffmanTable(HuffmanCode* root_table,
|
||||
int root_bits, const uint16_t* const symbol_lists, uint16_t* count_arg);
|
||||
|
||||
/* Builds a simple Huffman table. The num_symbols parameter is to be */
|
||||
/* interpreted as follows: 0 means 1 symbol, 1 means 2 symbols, 2 means 3 */
|
||||
/* symbols, 3 means 4 symbols with lengths 2,2,2,2, 4 means 4 symbols with */
|
||||
/* lengths 1,2,3,3. */
|
||||
BROTLI_INTERNAL uint32_t BrotliBuildSimpleHuffmanTable(HuffmanCode* table,
|
||||
int root_bits, uint16_t* symbols, uint32_t num_symbols);
|
||||
|
||||
/* Contains a collection of Huffman trees with the same alphabet size. */
|
||||
typedef struct {
|
||||
HuffmanCode** htrees;
|
||||
HuffmanCode* codes;
|
||||
uint16_t alphabet_size;
|
||||
uint16_t num_htrees;
|
||||
} HuffmanTreeGroup;
|
||||
|
||||
#if defined(__cplusplus) || defined(c_plusplus)
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* BROTLI_DEC_HUFFMAN_H_ */
|
||||
252
modules/brotli/dec/port.h
Normal file
252
modules/brotli/dec/port.h
Normal file
|
|
@ -0,0 +1,252 @@
|
|||
/* Copyright 2015 Google Inc. All Rights Reserved.
|
||||
|
||||
Distributed under MIT license.
|
||||
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
/* Macros for compiler / platform specific features and build options.
|
||||
|
||||
Build options are:
|
||||
* BROTLI_BUILD_32_BIT disables 64-bit optimizations
|
||||
* BROTLI_BUILD_64_BIT forces to use 64-bit optimizations
|
||||
* BROTLI_BUILD_BIG_ENDIAN forces to use big-endian optimizations
|
||||
* BROTLI_BUILD_ENDIAN_NEUTRAL disables endian-aware optimizations
|
||||
* BROTLI_BUILD_LITTLE_ENDIAN forces to use little-endian optimizations
|
||||
* BROTLI_BUILD_MODERN_COMPILER forces to use modern compilers built-ins,
|
||||
features and attributes
|
||||
* BROTLI_BUILD_PORTABLE disables dangerous optimizations, like unaligned
|
||||
read and overlapping memcpy; this reduces decompression speed by 5%
|
||||
* BROTLI_DEBUG dumps file name and line number when decoder detects stream
|
||||
or memory error
|
||||
* BROTLI_ENABLE_LOG enables asserts and dumps various state information
|
||||
*/
|
||||
|
||||
#ifndef BROTLI_DEC_PORT_H_
|
||||
#define BROTLI_DEC_PORT_H_
|
||||
|
||||
#if defined(BROTLI_ENABLE_LOG) || defined(BROTLI_DEBUG)
|
||||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
#endif
|
||||
|
||||
/* Compatibility with non-clang compilers. */
|
||||
#ifndef __has_builtin
|
||||
#define __has_builtin(x) 0
|
||||
#endif
|
||||
|
||||
#ifndef __has_attribute
|
||||
#define __has_attribute(x) 0
|
||||
#endif
|
||||
|
||||
#ifndef __has_feature
|
||||
#define __has_feature(x) 0
|
||||
#endif
|
||||
|
||||
#if defined(__arm__) || defined(__thumb__) || \
|
||||
defined(_M_ARM) || defined(_M_ARMT)
|
||||
#define BROTLI_TARGET_ARM
|
||||
#if (defined(__ARM_ARCH) && (__ARM_ARCH >= 7)) || \
|
||||
(defined(M_ARM) && (M_ARM >= 7))
|
||||
#define BROTLI_TARGET_ARMV7
|
||||
#endif /* ARMv7 */
|
||||
#if defined(__aarch64__)
|
||||
#define BROTLI_TARGET_ARMV8
|
||||
#endif /* ARMv8 */
|
||||
#endif /* ARM */
|
||||
|
||||
#if defined(__i386) || defined(_M_IX86)
|
||||
#define BROTLI_TARGET_X86
|
||||
#endif
|
||||
|
||||
#if defined(__x86_64__) || defined(_M_X64)
|
||||
#define BROTLI_TARGET_X64
|
||||
#endif
|
||||
|
||||
#if defined(__PPC64__)
|
||||
#define BROTLI_TARGET_POWERPC64
|
||||
#endif
|
||||
|
||||
#if defined(__GNUC__) && defined(__GNUC_MINOR__)
|
||||
#define BROTLI_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
|
||||
#else
|
||||
#define BROTLI_GCC_VERSION 0
|
||||
#endif
|
||||
|
||||
#if defined(__ICC)
|
||||
#define BROTLI_ICC_VERSION __ICC
|
||||
#else
|
||||
#define BROTLI_ICC_VERSION 0
|
||||
#endif
|
||||
|
||||
#if defined(BROTLI_BUILD_MODERN_COMPILER)
|
||||
#define BROTLI_MODERN_COMPILER 1
|
||||
#elif (BROTLI_GCC_VERSION > 300) || (BROTLI_ICC_VERSION >= 1600)
|
||||
#define BROTLI_MODERN_COMPILER 1
|
||||
#else
|
||||
#define BROTLI_MODERN_COMPILER 0
|
||||
#endif
|
||||
|
||||
#ifdef BROTLI_BUILD_PORTABLE
|
||||
#define BROTLI_ALIGNED_READ (!!1)
|
||||
#elif defined(BROTLI_TARGET_X86) || defined(BROTLI_TARGET_X64) || \
|
||||
defined(BROTLI_TARGET_ARMV7) || defined(BROTLI_TARGET_ARMV8)
|
||||
/* Allow unaligned read only for whitelisted CPUs. */
|
||||
#define BROTLI_ALIGNED_READ (!!0)
|
||||
#else
|
||||
#define BROTLI_ALIGNED_READ (!!1)
|
||||
#endif
|
||||
|
||||
/* Define "PREDICT_TRUE" and "PREDICT_FALSE" macros for capable compilers.
|
||||
|
||||
To apply compiler hint, enclose the branching condition into macros, like this:
|
||||
|
||||
if (PREDICT_TRUE(zero == 0)) {
|
||||
// main execution path
|
||||
} else {
|
||||
// compiler should place this code outside of main execution path
|
||||
}
|
||||
|
||||
OR:
|
||||
|
||||
if (PREDICT_FALSE(something_rare_or_unexpected_happens)) {
|
||||
// compiler should place this code outside of main execution path
|
||||
}
|
||||
|
||||
*/
|
||||
#if BROTLI_MODERN_COMPILER || __has_builtin(__builtin_expect)
|
||||
#define PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
|
||||
#define PREDICT_FALSE(x) (__builtin_expect(x, 0))
|
||||
#else
|
||||
#define PREDICT_FALSE(x) (x)
|
||||
#define PREDICT_TRUE(x) (x)
|
||||
#endif
|
||||
|
||||
/* IS_CONSTANT macros returns true for compile-time constant expressions. */
|
||||
#if BROTLI_MODERN_COMPILER || __has_builtin(__builtin_constant_p)
|
||||
#define IS_CONSTANT(x) (!!__builtin_constant_p(x))
|
||||
#else
|
||||
#define IS_CONSTANT(x) (!!0)
|
||||
#endif
|
||||
|
||||
#if BROTLI_MODERN_COMPILER || __has_attribute(always_inline)
|
||||
#define ATTRIBUTE_ALWAYS_INLINE __attribute__ ((always_inline))
|
||||
#else
|
||||
#define ATTRIBUTE_ALWAYS_INLINE
|
||||
#endif
|
||||
|
||||
#if defined(_WIN32) || defined(__CYGWIN__)
|
||||
#define ATTRIBUTE_VISIBILITY_HIDDEN
|
||||
#elif BROTLI_MODERN_COMPILER || __has_attribute(visibility)
|
||||
#define ATTRIBUTE_VISIBILITY_HIDDEN __attribute__ ((visibility ("hidden")))
|
||||
#else
|
||||
#define ATTRIBUTE_VISIBILITY_HIDDEN
|
||||
#endif
|
||||
|
||||
#ifndef BROTLI_INTERNAL
|
||||
#define BROTLI_INTERNAL ATTRIBUTE_VISIBILITY_HIDDEN
|
||||
#endif
|
||||
|
||||
#ifndef _MSC_VER
|
||||
#if defined(__cplusplus) || !defined(__STRICT_ANSI__) || \
|
||||
__STDC_VERSION__ >= 199901L
|
||||
#define BROTLI_INLINE inline ATTRIBUTE_ALWAYS_INLINE
|
||||
#else
|
||||
#define BROTLI_INLINE
|
||||
#endif
|
||||
#else /* _MSC_VER */
|
||||
#define BROTLI_INLINE __forceinline
|
||||
#endif /* _MSC_VER */
|
||||
|
||||
#ifdef BROTLI_ENABLE_LOG
|
||||
#define BROTLI_DCHECK(x) assert(x)
|
||||
#define BROTLI_LOG(x) printf x
|
||||
#else
|
||||
#define BROTLI_DCHECK(x)
|
||||
#define BROTLI_LOG(x)
|
||||
#endif
|
||||
|
||||
#if defined(BROTLI_DEBUG) || defined(BROTLI_ENABLE_LOG)
|
||||
static inline void BrotliDump(const char* f, int l, const char* fn) {
|
||||
fprintf(stderr, "%s:%d (%s)\n", f, l, fn);
|
||||
fflush(stderr);
|
||||
}
|
||||
#define BROTLI_DUMP() BrotliDump(__FILE__, __LINE__, __FUNCTION__)
|
||||
#else
|
||||
#define BROTLI_DUMP() (void)(0)
|
||||
#endif
|
||||
|
||||
#if defined(BROTLI_BUILD_64_BIT)
|
||||
#define BROTLI_64_BITS 1
|
||||
#elif defined(BROTLI_BUILD_32_BIT)
|
||||
#define BROTLI_64_BITS 0
|
||||
#elif defined(BROTLI_TARGET_X64) || defined(BROTLI_TARGET_ARMV8) || \
|
||||
defined(BROTLI_TARGET_POWERPC64)
|
||||
#define BROTLI_64_BITS 1
|
||||
#else
|
||||
#define BROTLI_64_BITS 0
|
||||
#endif
|
||||
|
||||
#if defined(BROTLI_BUILD_BIG_ENDIAN)
|
||||
#define BROTLI_LITTLE_ENDIAN 0
|
||||
#define BROTLI_BIG_ENDIAN 1
|
||||
#elif defined(BROTLI_BUILD_LITTLE_ENDIAN)
|
||||
#define BROTLI_LITTLE_ENDIAN 1
|
||||
#define BROTLI_BIG_ENDIAN 0
|
||||
#elif defined(BROTLI_BUILD_ENDIAN_NEUTRAL)
|
||||
#define BROTLI_LITTLE_ENDIAN 0
|
||||
#define BROTLI_BIG_ENDIAN 0
|
||||
#elif defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
|
||||
#define BROTLI_LITTLE_ENDIAN 1
|
||||
#define BROTLI_BIG_ENDIAN 0
|
||||
#elif defined(_WIN32)
|
||||
/* Win32 can currently always be assumed to be little endian */
|
||||
#define BROTLI_LITTLE_ENDIAN 1
|
||||
#define BROTLI_BIG_ENDIAN 0
|
||||
#else
|
||||
#if (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
|
||||
#define BROTLI_BIG_ENDIAN 1
|
||||
#else
|
||||
#define BROTLI_BIG_ENDIAN 0
|
||||
#endif
|
||||
#define BROTLI_LITTLE_ENDIAN 0
|
||||
#endif
|
||||
|
||||
#if BROTLI_MODERN_COMPILER || __has_attribute(noinline)
|
||||
#define BROTLI_NOINLINE __attribute__((noinline))
|
||||
#else
|
||||
#define BROTLI_NOINLINE
|
||||
#endif
|
||||
|
||||
#define BROTLI_REPEAT(N, X) { \
|
||||
if ((N & 1) != 0) {X;} \
|
||||
if ((N & 2) != 0) {X; X;} \
|
||||
if ((N & 4) != 0) {X; X; X; X;} \
|
||||
}
|
||||
|
||||
#if BROTLI_MODERN_COMPILER || defined(__llvm__)
|
||||
#if defined(BROTLI_TARGET_ARMV7)
|
||||
static BROTLI_INLINE unsigned BrotliRBit(unsigned input) {
|
||||
unsigned output;
|
||||
__asm__("rbit %0, %1\n" : "=r"(output) : "r"(input));
|
||||
return output;
|
||||
}
|
||||
#define BROTLI_RBIT(x) BrotliRBit(x)
|
||||
#endif /* armv7 */
|
||||
#endif /* gcc || clang */
|
||||
|
||||
#if defined(BROTLI_TARGET_ARM)
|
||||
#define BROTLI_HAS_UBFX (!!1)
|
||||
#else
|
||||
#define BROTLI_HAS_UBFX (!!0)
|
||||
#endif
|
||||
|
||||
#define BROTLI_ALLOC(S, L) S->alloc_func(S->memory_manager_opaque, L)
|
||||
|
||||
#define BROTLI_FREE(S, X) { \
|
||||
S->free_func(S->memory_manager_opaque, X); \
|
||||
X = NULL; \
|
||||
}
|
||||
|
||||
#define BROTLI_UNUSED(X) (void)(X)
|
||||
|
||||
#endif /* BROTLI_DEC_PORT_H_ */
|
||||
749
modules/brotli/dec/prefix.h
Normal file
749
modules/brotli/dec/prefix.h
Normal file
|
|
@ -0,0 +1,749 @@
|
|||
/* Copyright 2013 Google Inc. All Rights Reserved.
|
||||
|
||||
Distributed under MIT license.
|
||||
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
/* Lookup tables to map prefix codes to value ranges. This is used during
|
||||
decoding of the block lengths, literal insertion lengths and copy lengths.
|
||||
*/
|
||||
|
||||
#ifndef BROTLI_DEC_PREFIX_H_
|
||||
#define BROTLI_DEC_PREFIX_H_
|
||||
|
||||
#include "./types.h"
|
||||
|
||||
/* Represents the range of values belonging to a prefix code: */
|
||||
/* [offset, offset + 2^nbits) */
|
||||
struct PrefixCodeRange {
|
||||
uint16_t offset;
|
||||
uint8_t nbits;
|
||||
};
|
||||
|
||||
static const struct PrefixCodeRange kBlockLengthPrefixCode[] = {
|
||||
{ 1, 2}, { 5, 2}, { 9, 2}, { 13, 2},
|
||||
{ 17, 3}, { 25, 3}, { 33, 3}, { 41, 3},
|
||||
{ 49, 4}, { 65, 4}, { 81, 4}, { 97, 4},
|
||||
{ 113, 5}, { 145, 5}, { 177, 5}, { 209, 5},
|
||||
{ 241, 6}, { 305, 6}, { 369, 7}, { 497, 8},
|
||||
{ 753, 9}, { 1265, 10}, {2289, 11}, {4337, 12},
|
||||
{8433, 13}, {16625, 24}
|
||||
};
|
||||
|
||||
typedef struct CmdLutElement {
|
||||
uint8_t insert_len_extra_bits;
|
||||
uint8_t copy_len_extra_bits;
|
||||
int8_t distance_code;
|
||||
uint8_t context;
|
||||
uint16_t insert_len_offset;
|
||||
uint16_t copy_len_offset;
|
||||
} CmdLutElement;
|
||||
|
||||
static const CmdLutElement kCmdLut[704] = {
|
||||
{ 0x00, 0x00, 0, 0x00, 0x0000, 0x0002 },
|
||||
{ 0x00, 0x00, 0, 0x01, 0x0000, 0x0003 },
|
||||
{ 0x00, 0x00, 0, 0x02, 0x0000, 0x0004 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0000, 0x0005 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0000, 0x0006 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0000, 0x0007 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0000, 0x0008 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0000, 0x0009 },
|
||||
{ 0x00, 0x00, 0, 0x00, 0x0001, 0x0002 },
|
||||
{ 0x00, 0x00, 0, 0x01, 0x0001, 0x0003 },
|
||||
{ 0x00, 0x00, 0, 0x02, 0x0001, 0x0004 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0001, 0x0005 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0001, 0x0006 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0001, 0x0007 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0001, 0x0008 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0001, 0x0009 },
|
||||
{ 0x00, 0x00, 0, 0x00, 0x0002, 0x0002 },
|
||||
{ 0x00, 0x00, 0, 0x01, 0x0002, 0x0003 },
|
||||
{ 0x00, 0x00, 0, 0x02, 0x0002, 0x0004 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0002, 0x0005 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0002, 0x0006 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0002, 0x0007 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0002, 0x0008 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0002, 0x0009 },
|
||||
{ 0x00, 0x00, 0, 0x00, 0x0003, 0x0002 },
|
||||
{ 0x00, 0x00, 0, 0x01, 0x0003, 0x0003 },
|
||||
{ 0x00, 0x00, 0, 0x02, 0x0003, 0x0004 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0003, 0x0005 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0003, 0x0006 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0003, 0x0007 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0003, 0x0008 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0003, 0x0009 },
|
||||
{ 0x00, 0x00, 0, 0x00, 0x0004, 0x0002 },
|
||||
{ 0x00, 0x00, 0, 0x01, 0x0004, 0x0003 },
|
||||
{ 0x00, 0x00, 0, 0x02, 0x0004, 0x0004 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0004, 0x0005 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0004, 0x0006 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0004, 0x0007 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0004, 0x0008 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0004, 0x0009 },
|
||||
{ 0x00, 0x00, 0, 0x00, 0x0005, 0x0002 },
|
||||
{ 0x00, 0x00, 0, 0x01, 0x0005, 0x0003 },
|
||||
{ 0x00, 0x00, 0, 0x02, 0x0005, 0x0004 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0005, 0x0005 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0005, 0x0006 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0005, 0x0007 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0005, 0x0008 },
|
||||
{ 0x00, 0x00, 0, 0x03, 0x0005, 0x0009 },
|
||||
{ 0x01, 0x00, 0, 0x00, 0x0006, 0x0002 },
|
||||
{ 0x01, 0x00, 0, 0x01, 0x0006, 0x0003 },
|
||||
{ 0x01, 0x00, 0, 0x02, 0x0006, 0x0004 },
|
||||
{ 0x01, 0x00, 0, 0x03, 0x0006, 0x0005 },
|
||||
{ 0x01, 0x00, 0, 0x03, 0x0006, 0x0006 },
|
||||
{ 0x01, 0x00, 0, 0x03, 0x0006, 0x0007 },
|
||||
{ 0x01, 0x00, 0, 0x03, 0x0006, 0x0008 },
|
||||
{ 0x01, 0x00, 0, 0x03, 0x0006, 0x0009 },
|
||||
{ 0x01, 0x00, 0, 0x00, 0x0008, 0x0002 },
|
||||
{ 0x01, 0x00, 0, 0x01, 0x0008, 0x0003 },
|
||||
{ 0x01, 0x00, 0, 0x02, 0x0008, 0x0004 },
|
||||
{ 0x01, 0x00, 0, 0x03, 0x0008, 0x0005 },
|
||||
{ 0x01, 0x00, 0, 0x03, 0x0008, 0x0006 },
|
||||
{ 0x01, 0x00, 0, 0x03, 0x0008, 0x0007 },
|
||||
{ 0x01, 0x00, 0, 0x03, 0x0008, 0x0008 },
|
||||
{ 0x01, 0x00, 0, 0x03, 0x0008, 0x0009 },
|
||||
{ 0x00, 0x01, 0, 0x03, 0x0000, 0x000a },
|
||||
{ 0x00, 0x01, 0, 0x03, 0x0000, 0x000c },
|
||||
{ 0x00, 0x02, 0, 0x03, 0x0000, 0x000e },
|
||||
{ 0x00, 0x02, 0, 0x03, 0x0000, 0x0012 },
|
||||
{ 0x00, 0x03, 0, 0x03, 0x0000, 0x0016 },
|
||||
{ 0x00, 0x03, 0, 0x03, 0x0000, 0x001e },
|
||||
{ 0x00, 0x04, 0, 0x03, 0x0000, 0x0026 },
|
||||
{ 0x00, 0x04, 0, 0x03, 0x0000, 0x0036 },
|
||||
{ 0x00, 0x01, 0, 0x03, 0x0001, 0x000a },
|
||||
{ 0x00, 0x01, 0, 0x03, 0x0001, 0x000c },
|
||||
{ 0x00, 0x02, 0, 0x03, 0x0001, 0x000e },
|
||||
{ 0x00, 0x02, 0, 0x03, 0x0001, 0x0012 },
|
||||
{ 0x00, 0x03, 0, 0x03, 0x0001, 0x0016 },
|
||||
{ 0x00, 0x03, 0, 0x03, 0x0001, 0x001e },
|
||||
{ 0x00, 0x04, 0, 0x03, 0x0001, 0x0026 },
|
||||
{ 0x00, 0x04, 0, 0x03, 0x0001, 0x0036 },
|
||||
{ 0x00, 0x01, 0, 0x03, 0x0002, 0x000a },
|
||||
{ 0x00, 0x01, 0, 0x03, 0x0002, 0x000c },
|
||||
{ 0x00, 0x02, 0, 0x03, 0x0002, 0x000e },
|
||||
{ 0x00, 0x02, 0, 0x03, 0x0002, 0x0012 },
|
||||
{ 0x00, 0x03, 0, 0x03, 0x0002, 0x0016 },
|
||||
{ 0x00, 0x03, 0, 0x03, 0x0002, 0x001e },
|
||||
{ 0x00, 0x04, 0, 0x03, 0x0002, 0x0026 },
|
||||
{ 0x00, 0x04, 0, 0x03, 0x0002, 0x0036 },
|
||||
{ 0x00, 0x01, 0, 0x03, 0x0003, 0x000a },
|
||||
{ 0x00, 0x01, 0, 0x03, 0x0003, 0x000c },
|
||||
{ 0x00, 0x02, 0, 0x03, 0x0003, 0x000e },
|
||||
{ 0x00, 0x02, 0, 0x03, 0x0003, 0x0012 },
|
||||
{ 0x00, 0x03, 0, 0x03, 0x0003, 0x0016 },
|
||||
{ 0x00, 0x03, 0, 0x03, 0x0003, 0x001e },
|
||||
{ 0x00, 0x04, 0, 0x03, 0x0003, 0x0026 },
|
||||
{ 0x00, 0x04, 0, 0x03, 0x0003, 0x0036 },
|
||||
{ 0x00, 0x01, 0, 0x03, 0x0004, 0x000a },
|
||||
{ 0x00, 0x01, 0, 0x03, 0x0004, 0x000c },
|
||||
{ 0x00, 0x02, 0, 0x03, 0x0004, 0x000e },
|
||||
{ 0x00, 0x02, 0, 0x03, 0x0004, 0x0012 },
|
||||
{ 0x00, 0x03, 0, 0x03, 0x0004, 0x0016 },
|
||||
{ 0x00, 0x03, 0, 0x03, 0x0004, 0x001e },
|
||||
{ 0x00, 0x04, 0, 0x03, 0x0004, 0x0026 },
|
||||
{ 0x00, 0x04, 0, 0x03, 0x0004, 0x0036 },
|
||||
{ 0x00, 0x01, 0, 0x03, 0x0005, 0x000a },
|
||||
{ 0x00, 0x01, 0, 0x03, 0x0005, 0x000c },
|
||||
{ 0x00, 0x02, 0, 0x03, 0x0005, 0x000e },
|
||||
{ 0x00, 0x02, 0, 0x03, 0x0005, 0x0012 },
|
||||
{ 0x00, 0x03, 0, 0x03, 0x0005, 0x0016 },
|
||||
{ 0x00, 0x03, 0, 0x03, 0x0005, 0x001e },
|
||||
{ 0x00, 0x04, 0, 0x03, 0x0005, 0x0026 },
|
||||
{ 0x00, 0x04, 0, 0x03, 0x0005, 0x0036 },
|
||||
{ 0x01, 0x01, 0, 0x03, 0x0006, 0x000a },
|
||||
{ 0x01, 0x01, 0, 0x03, 0x0006, 0x000c },
|
||||
{ 0x01, 0x02, 0, 0x03, 0x0006, 0x000e },
|
||||
{ 0x01, 0x02, 0, 0x03, 0x0006, 0x0012 },
|
||||
{ 0x01, 0x03, 0, 0x03, 0x0006, 0x0016 },
|
||||
{ 0x01, 0x03, 0, 0x03, 0x0006, 0x001e },
|
||||
{ 0x01, 0x04, 0, 0x03, 0x0006, 0x0026 },
|
||||
{ 0x01, 0x04, 0, 0x03, 0x0006, 0x0036 },
|
||||
{ 0x01, 0x01, 0, 0x03, 0x0008, 0x000a },
|
||||
{ 0x01, 0x01, 0, 0x03, 0x0008, 0x000c },
|
||||
{ 0x01, 0x02, 0, 0x03, 0x0008, 0x000e },
|
||||
{ 0x01, 0x02, 0, 0x03, 0x0008, 0x0012 },
|
||||
{ 0x01, 0x03, 0, 0x03, 0x0008, 0x0016 },
|
||||
{ 0x01, 0x03, 0, 0x03, 0x0008, 0x001e },
|
||||
{ 0x01, 0x04, 0, 0x03, 0x0008, 0x0026 },
|
||||
{ 0x01, 0x04, 0, 0x03, 0x0008, 0x0036 },
|
||||
{ 0x00, 0x00, -1, 0x00, 0x0000, 0x0002 },
|
||||
{ 0x00, 0x00, -1, 0x01, 0x0000, 0x0003 },
|
||||
{ 0x00, 0x00, -1, 0x02, 0x0000, 0x0004 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0000, 0x0005 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0000, 0x0006 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0000, 0x0007 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0000, 0x0008 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0000, 0x0009 },
|
||||
{ 0x00, 0x00, -1, 0x00, 0x0001, 0x0002 },
|
||||
{ 0x00, 0x00, -1, 0x01, 0x0001, 0x0003 },
|
||||
{ 0x00, 0x00, -1, 0x02, 0x0001, 0x0004 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0001, 0x0005 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0001, 0x0006 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0001, 0x0007 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0001, 0x0008 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0001, 0x0009 },
|
||||
{ 0x00, 0x00, -1, 0x00, 0x0002, 0x0002 },
|
||||
{ 0x00, 0x00, -1, 0x01, 0x0002, 0x0003 },
|
||||
{ 0x00, 0x00, -1, 0x02, 0x0002, 0x0004 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0002, 0x0005 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0002, 0x0006 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0002, 0x0007 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0002, 0x0008 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0002, 0x0009 },
|
||||
{ 0x00, 0x00, -1, 0x00, 0x0003, 0x0002 },
|
||||
{ 0x00, 0x00, -1, 0x01, 0x0003, 0x0003 },
|
||||
{ 0x00, 0x00, -1, 0x02, 0x0003, 0x0004 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0003, 0x0005 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0003, 0x0006 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0003, 0x0007 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0003, 0x0008 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0003, 0x0009 },
|
||||
{ 0x00, 0x00, -1, 0x00, 0x0004, 0x0002 },
|
||||
{ 0x00, 0x00, -1, 0x01, 0x0004, 0x0003 },
|
||||
{ 0x00, 0x00, -1, 0x02, 0x0004, 0x0004 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0004, 0x0005 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0004, 0x0006 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0004, 0x0007 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0004, 0x0008 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0004, 0x0009 },
|
||||
{ 0x00, 0x00, -1, 0x00, 0x0005, 0x0002 },
|
||||
{ 0x00, 0x00, -1, 0x01, 0x0005, 0x0003 },
|
||||
{ 0x00, 0x00, -1, 0x02, 0x0005, 0x0004 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0005, 0x0005 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0005, 0x0006 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0005, 0x0007 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0005, 0x0008 },
|
||||
{ 0x00, 0x00, -1, 0x03, 0x0005, 0x0009 },
|
||||
{ 0x01, 0x00, -1, 0x00, 0x0006, 0x0002 },
|
||||
{ 0x01, 0x00, -1, 0x01, 0x0006, 0x0003 },
|
||||
{ 0x01, 0x00, -1, 0x02, 0x0006, 0x0004 },
|
||||
{ 0x01, 0x00, -1, 0x03, 0x0006, 0x0005 },
|
||||
{ 0x01, 0x00, -1, 0x03, 0x0006, 0x0006 },
|
||||
{ 0x01, 0x00, -1, 0x03, 0x0006, 0x0007 },
|
||||
{ 0x01, 0x00, -1, 0x03, 0x0006, 0x0008 },
|
||||
{ 0x01, 0x00, -1, 0x03, 0x0006, 0x0009 },
|
||||
{ 0x01, 0x00, -1, 0x00, 0x0008, 0x0002 },
|
||||
{ 0x01, 0x00, -1, 0x01, 0x0008, 0x0003 },
|
||||
{ 0x01, 0x00, -1, 0x02, 0x0008, 0x0004 },
|
||||
{ 0x01, 0x00, -1, 0x03, 0x0008, 0x0005 },
|
||||
{ 0x01, 0x00, -1, 0x03, 0x0008, 0x0006 },
|
||||
{ 0x01, 0x00, -1, 0x03, 0x0008, 0x0007 },
|
||||
{ 0x01, 0x00, -1, 0x03, 0x0008, 0x0008 },
|
||||
{ 0x01, 0x00, -1, 0x03, 0x0008, 0x0009 },
|
||||
{ 0x00, 0x01, -1, 0x03, 0x0000, 0x000a },
|
||||
{ 0x00, 0x01, -1, 0x03, 0x0000, 0x000c },
|
||||
{ 0x00, 0x02, -1, 0x03, 0x0000, 0x000e },
|
||||
{ 0x00, 0x02, -1, 0x03, 0x0000, 0x0012 },
|
||||
{ 0x00, 0x03, -1, 0x03, 0x0000, 0x0016 },
|
||||
{ 0x00, 0x03, -1, 0x03, 0x0000, 0x001e },
|
||||
{ 0x00, 0x04, -1, 0x03, 0x0000, 0x0026 },
|
||||
{ 0x00, 0x04, -1, 0x03, 0x0000, 0x0036 },
|
||||
{ 0x00, 0x01, -1, 0x03, 0x0001, 0x000a },
|
||||
{ 0x00, 0x01, -1, 0x03, 0x0001, 0x000c },
|
||||
{ 0x00, 0x02, -1, 0x03, 0x0001, 0x000e },
|
||||
{ 0x00, 0x02, -1, 0x03, 0x0001, 0x0012 },
|
||||
{ 0x00, 0x03, -1, 0x03, 0x0001, 0x0016 },
|
||||
{ 0x00, 0x03, -1, 0x03, 0x0001, 0x001e },
|
||||
{ 0x00, 0x04, -1, 0x03, 0x0001, 0x0026 },
|
||||
{ 0x00, 0x04, -1, 0x03, 0x0001, 0x0036 },
|
||||
{ 0x00, 0x01, -1, 0x03, 0x0002, 0x000a },
|
||||
{ 0x00, 0x01, -1, 0x03, 0x0002, 0x000c },
|
||||
{ 0x00, 0x02, -1, 0x03, 0x0002, 0x000e },
|
||||
{ 0x00, 0x02, -1, 0x03, 0x0002, 0x0012 },
|
||||
{ 0x00, 0x03, -1, 0x03, 0x0002, 0x0016 },
|
||||
{ 0x00, 0x03, -1, 0x03, 0x0002, 0x001e },
|
||||
{ 0x00, 0x04, -1, 0x03, 0x0002, 0x0026 },
|
||||
{ 0x00, 0x04, -1, 0x03, 0x0002, 0x0036 },
|
||||
{ 0x00, 0x01, -1, 0x03, 0x0003, 0x000a },
|
||||
{ 0x00, 0x01, -1, 0x03, 0x0003, 0x000c },
|
||||
{ 0x00, 0x02, -1, 0x03, 0x0003, 0x000e },
|
||||
{ 0x00, 0x02, -1, 0x03, 0x0003, 0x0012 },
|
||||
{ 0x00, 0x03, -1, 0x03, 0x0003, 0x0016 },
|
||||
{ 0x00, 0x03, -1, 0x03, 0x0003, 0x001e },
|
||||
{ 0x00, 0x04, -1, 0x03, 0x0003, 0x0026 },
|
||||
{ 0x00, 0x04, -1, 0x03, 0x0003, 0x0036 },
|
||||
{ 0x00, 0x01, -1, 0x03, 0x0004, 0x000a },
|
||||
{ 0x00, 0x01, -1, 0x03, 0x0004, 0x000c },
|
||||
{ 0x00, 0x02, -1, 0x03, 0x0004, 0x000e },
|
||||
{ 0x00, 0x02, -1, 0x03, 0x0004, 0x0012 },
|
||||
{ 0x00, 0x03, -1, 0x03, 0x0004, 0x0016 },
|
||||
{ 0x00, 0x03, -1, 0x03, 0x0004, 0x001e },
|
||||
{ 0x00, 0x04, -1, 0x03, 0x0004, 0x0026 },
|
||||
{ 0x00, 0x04, -1, 0x03, 0x0004, 0x0036 },
|
||||
{ 0x00, 0x01, -1, 0x03, 0x0005, 0x000a },
|
||||
{ 0x00, 0x01, -1, 0x03, 0x0005, 0x000c },
|
||||
{ 0x00, 0x02, -1, 0x03, 0x0005, 0x000e },
|
||||
{ 0x00, 0x02, -1, 0x03, 0x0005, 0x0012 },
|
||||
{ 0x00, 0x03, -1, 0x03, 0x0005, 0x0016 },
|
||||
{ 0x00, 0x03, -1, 0x03, 0x0005, 0x001e },
|
||||
{ 0x00, 0x04, -1, 0x03, 0x0005, 0x0026 },
|
||||
{ 0x00, 0x04, -1, 0x03, 0x0005, 0x0036 },
|
||||
{ 0x01, 0x01, -1, 0x03, 0x0006, 0x000a },
|
||||
{ 0x01, 0x01, -1, 0x03, 0x0006, 0x000c },
|
||||
{ 0x01, 0x02, -1, 0x03, 0x0006, 0x000e },
|
||||
{ 0x01, 0x02, -1, 0x03, 0x0006, 0x0012 },
|
||||
{ 0x01, 0x03, -1, 0x03, 0x0006, 0x0016 },
|
||||
{ 0x01, 0x03, -1, 0x03, 0x0006, 0x001e },
|
||||
{ 0x01, 0x04, -1, 0x03, 0x0006, 0x0026 },
|
||||
{ 0x01, 0x04, -1, 0x03, 0x0006, 0x0036 },
|
||||
{ 0x01, 0x01, -1, 0x03, 0x0008, 0x000a },
|
||||
{ 0x01, 0x01, -1, 0x03, 0x0008, 0x000c },
|
||||
{ 0x01, 0x02, -1, 0x03, 0x0008, 0x000e },
|
||||
{ 0x01, 0x02, -1, 0x03, 0x0008, 0x0012 },
|
||||
{ 0x01, 0x03, -1, 0x03, 0x0008, 0x0016 },
|
||||
{ 0x01, 0x03, -1, 0x03, 0x0008, 0x001e },
|
||||
{ 0x01, 0x04, -1, 0x03, 0x0008, 0x0026 },
|
||||
{ 0x01, 0x04, -1, 0x03, 0x0008, 0x0036 },
|
||||
{ 0x02, 0x00, -1, 0x00, 0x000a, 0x0002 },
|
||||
{ 0x02, 0x00, -1, 0x01, 0x000a, 0x0003 },
|
||||
{ 0x02, 0x00, -1, 0x02, 0x000a, 0x0004 },
|
||||
{ 0x02, 0x00, -1, 0x03, 0x000a, 0x0005 },
|
||||
{ 0x02, 0x00, -1, 0x03, 0x000a, 0x0006 },
|
||||
{ 0x02, 0x00, -1, 0x03, 0x000a, 0x0007 },
|
||||
{ 0x02, 0x00, -1, 0x03, 0x000a, 0x0008 },
|
||||
{ 0x02, 0x00, -1, 0x03, 0x000a, 0x0009 },
|
||||
{ 0x02, 0x00, -1, 0x00, 0x000e, 0x0002 },
|
||||
{ 0x02, 0x00, -1, 0x01, 0x000e, 0x0003 },
|
||||
{ 0x02, 0x00, -1, 0x02, 0x000e, 0x0004 },
|
||||
{ 0x02, 0x00, -1, 0x03, 0x000e, 0x0005 },
|
||||
{ 0x02, 0x00, -1, 0x03, 0x000e, 0x0006 },
|
||||
{ 0x02, 0x00, -1, 0x03, 0x000e, 0x0007 },
|
||||
{ 0x02, 0x00, -1, 0x03, 0x000e, 0x0008 },
|
||||
{ 0x02, 0x00, -1, 0x03, 0x000e, 0x0009 },
|
||||
{ 0x03, 0x00, -1, 0x00, 0x0012, 0x0002 },
|
||||
{ 0x03, 0x00, -1, 0x01, 0x0012, 0x0003 },
|
||||
{ 0x03, 0x00, -1, 0x02, 0x0012, 0x0004 },
|
||||
{ 0x03, 0x00, -1, 0x03, 0x0012, 0x0005 },
|
||||
{ 0x03, 0x00, -1, 0x03, 0x0012, 0x0006 },
|
||||
{ 0x03, 0x00, -1, 0x03, 0x0012, 0x0007 },
|
||||
{ 0x03, 0x00, -1, 0x03, 0x0012, 0x0008 },
|
||||
{ 0x03, 0x00, -1, 0x03, 0x0012, 0x0009 },
|
||||
{ 0x03, 0x00, -1, 0x00, 0x001a, 0x0002 },
|
||||
{ 0x03, 0x00, -1, 0x01, 0x001a, 0x0003 },
|
||||
{ 0x03, 0x00, -1, 0x02, 0x001a, 0x0004 },
|
||||
{ 0x03, 0x00, -1, 0x03, 0x001a, 0x0005 },
|
||||
{ 0x03, 0x00, -1, 0x03, 0x001a, 0x0006 },
|
||||
{ 0x03, 0x00, -1, 0x03, 0x001a, 0x0007 },
|
||||
{ 0x03, 0x00, -1, 0x03, 0x001a, 0x0008 },
|
||||
{ 0x03, 0x00, -1, 0x03, 0x001a, 0x0009 },
|
||||
{ 0x04, 0x00, -1, 0x00, 0x0022, 0x0002 },
|
||||
{ 0x04, 0x00, -1, 0x01, 0x0022, 0x0003 },
|
||||
{ 0x04, 0x00, -1, 0x02, 0x0022, 0x0004 },
|
||||
{ 0x04, 0x00, -1, 0x03, 0x0022, 0x0005 },
|
||||
{ 0x04, 0x00, -1, 0x03, 0x0022, 0x0006 },
|
||||
{ 0x04, 0x00, -1, 0x03, 0x0022, 0x0007 },
|
||||
{ 0x04, 0x00, -1, 0x03, 0x0022, 0x0008 },
|
||||
{ 0x04, 0x00, -1, 0x03, 0x0022, 0x0009 },
|
||||
{ 0x04, 0x00, -1, 0x00, 0x0032, 0x0002 },
|
||||
{ 0x04, 0x00, -1, 0x01, 0x0032, 0x0003 },
|
||||
{ 0x04, 0x00, -1, 0x02, 0x0032, 0x0004 },
|
||||
{ 0x04, 0x00, -1, 0x03, 0x0032, 0x0005 },
|
||||
{ 0x04, 0x00, -1, 0x03, 0x0032, 0x0006 },
|
||||
{ 0x04, 0x00, -1, 0x03, 0x0032, 0x0007 },
|
||||
{ 0x04, 0x00, -1, 0x03, 0x0032, 0x0008 },
|
||||
{ 0x04, 0x00, -1, 0x03, 0x0032, 0x0009 },
|
||||
{ 0x05, 0x00, -1, 0x00, 0x0042, 0x0002 },
|
||||
{ 0x05, 0x00, -1, 0x01, 0x0042, 0x0003 },
|
||||
{ 0x05, 0x00, -1, 0x02, 0x0042, 0x0004 },
|
||||
{ 0x05, 0x00, -1, 0x03, 0x0042, 0x0005 },
|
||||
{ 0x05, 0x00, -1, 0x03, 0x0042, 0x0006 },
|
||||
{ 0x05, 0x00, -1, 0x03, 0x0042, 0x0007 },
|
||||
{ 0x05, 0x00, -1, 0x03, 0x0042, 0x0008 },
|
||||
{ 0x05, 0x00, -1, 0x03, 0x0042, 0x0009 },
|
||||
{ 0x05, 0x00, -1, 0x00, 0x0062, 0x0002 },
|
||||
{ 0x05, 0x00, -1, 0x01, 0x0062, 0x0003 },
|
||||
{ 0x05, 0x00, -1, 0x02, 0x0062, 0x0004 },
|
||||
{ 0x05, 0x00, -1, 0x03, 0x0062, 0x0005 },
|
||||
{ 0x05, 0x00, -1, 0x03, 0x0062, 0x0006 },
|
||||
{ 0x05, 0x00, -1, 0x03, 0x0062, 0x0007 },
|
||||
{ 0x05, 0x00, -1, 0x03, 0x0062, 0x0008 },
|
||||
{ 0x05, 0x00, -1, 0x03, 0x0062, 0x0009 },
|
||||
{ 0x02, 0x01, -1, 0x03, 0x000a, 0x000a },
|
||||
{ 0x02, 0x01, -1, 0x03, 0x000a, 0x000c },
|
||||
{ 0x02, 0x02, -1, 0x03, 0x000a, 0x000e },
|
||||
{ 0x02, 0x02, -1, 0x03, 0x000a, 0x0012 },
|
||||
{ 0x02, 0x03, -1, 0x03, 0x000a, 0x0016 },
|
||||
{ 0x02, 0x03, -1, 0x03, 0x000a, 0x001e },
|
||||
{ 0x02, 0x04, -1, 0x03, 0x000a, 0x0026 },
|
||||
{ 0x02, 0x04, -1, 0x03, 0x000a, 0x0036 },
|
||||
{ 0x02, 0x01, -1, 0x03, 0x000e, 0x000a },
|
||||
{ 0x02, 0x01, -1, 0x03, 0x000e, 0x000c },
|
||||
{ 0x02, 0x02, -1, 0x03, 0x000e, 0x000e },
|
||||
{ 0x02, 0x02, -1, 0x03, 0x000e, 0x0012 },
|
||||
{ 0x02, 0x03, -1, 0x03, 0x000e, 0x0016 },
|
||||
{ 0x02, 0x03, -1, 0x03, 0x000e, 0x001e },
|
||||
{ 0x02, 0x04, -1, 0x03, 0x000e, 0x0026 },
|
||||
{ 0x02, 0x04, -1, 0x03, 0x000e, 0x0036 },
|
||||
{ 0x03, 0x01, -1, 0x03, 0x0012, 0x000a },
|
||||
{ 0x03, 0x01, -1, 0x03, 0x0012, 0x000c },
|
||||
{ 0x03, 0x02, -1, 0x03, 0x0012, 0x000e },
|
||||
{ 0x03, 0x02, -1, 0x03, 0x0012, 0x0012 },
|
||||
{ 0x03, 0x03, -1, 0x03, 0x0012, 0x0016 },
|
||||
{ 0x03, 0x03, -1, 0x03, 0x0012, 0x001e },
|
||||
{ 0x03, 0x04, -1, 0x03, 0x0012, 0x0026 },
|
||||
{ 0x03, 0x04, -1, 0x03, 0x0012, 0x0036 },
|
||||
{ 0x03, 0x01, -1, 0x03, 0x001a, 0x000a },
|
||||
{ 0x03, 0x01, -1, 0x03, 0x001a, 0x000c },
|
||||
{ 0x03, 0x02, -1, 0x03, 0x001a, 0x000e },
|
||||
{ 0x03, 0x02, -1, 0x03, 0x001a, 0x0012 },
|
||||
{ 0x03, 0x03, -1, 0x03, 0x001a, 0x0016 },
|
||||
{ 0x03, 0x03, -1, 0x03, 0x001a, 0x001e },
|
||||
{ 0x03, 0x04, -1, 0x03, 0x001a, 0x0026 },
|
||||
{ 0x03, 0x04, -1, 0x03, 0x001a, 0x0036 },
|
||||
{ 0x04, 0x01, -1, 0x03, 0x0022, 0x000a },
|
||||
{ 0x04, 0x01, -1, 0x03, 0x0022, 0x000c },
|
||||
{ 0x04, 0x02, -1, 0x03, 0x0022, 0x000e },
|
||||
{ 0x04, 0x02, -1, 0x03, 0x0022, 0x0012 },
|
||||
{ 0x04, 0x03, -1, 0x03, 0x0022, 0x0016 },
|
||||
{ 0x04, 0x03, -1, 0x03, 0x0022, 0x001e },
|
||||
{ 0x04, 0x04, -1, 0x03, 0x0022, 0x0026 },
|
||||
{ 0x04, 0x04, -1, 0x03, 0x0022, 0x0036 },
|
||||
{ 0x04, 0x01, -1, 0x03, 0x0032, 0x000a },
|
||||
{ 0x04, 0x01, -1, 0x03, 0x0032, 0x000c },
|
||||
{ 0x04, 0x02, -1, 0x03, 0x0032, 0x000e },
|
||||
{ 0x04, 0x02, -1, 0x03, 0x0032, 0x0012 },
|
||||
{ 0x04, 0x03, -1, 0x03, 0x0032, 0x0016 },
|
||||
{ 0x04, 0x03, -1, 0x03, 0x0032, 0x001e },
|
||||
{ 0x04, 0x04, -1, 0x03, 0x0032, 0x0026 },
|
||||
{ 0x04, 0x04, -1, 0x03, 0x0032, 0x0036 },
|
||||
{ 0x05, 0x01, -1, 0x03, 0x0042, 0x000a },
|
||||
{ 0x05, 0x01, -1, 0x03, 0x0042, 0x000c },
|
||||
{ 0x05, 0x02, -1, 0x03, 0x0042, 0x000e },
|
||||
{ 0x05, 0x02, -1, 0x03, 0x0042, 0x0012 },
|
||||
{ 0x05, 0x03, -1, 0x03, 0x0042, 0x0016 },
|
||||
{ 0x05, 0x03, -1, 0x03, 0x0042, 0x001e },
|
||||
{ 0x05, 0x04, -1, 0x03, 0x0042, 0x0026 },
|
||||
{ 0x05, 0x04, -1, 0x03, 0x0042, 0x0036 },
|
||||
{ 0x05, 0x01, -1, 0x03, 0x0062, 0x000a },
|
||||
{ 0x05, 0x01, -1, 0x03, 0x0062, 0x000c },
|
||||
{ 0x05, 0x02, -1, 0x03, 0x0062, 0x000e },
|
||||
{ 0x05, 0x02, -1, 0x03, 0x0062, 0x0012 },
|
||||
{ 0x05, 0x03, -1, 0x03, 0x0062, 0x0016 },
|
||||
{ 0x05, 0x03, -1, 0x03, 0x0062, 0x001e },
|
||||
{ 0x05, 0x04, -1, 0x03, 0x0062, 0x0026 },
|
||||
{ 0x05, 0x04, -1, 0x03, 0x0062, 0x0036 },
|
||||
{ 0x00, 0x05, -1, 0x03, 0x0000, 0x0046 },
|
||||
{ 0x00, 0x05, -1, 0x03, 0x0000, 0x0066 },
|
||||
{ 0x00, 0x06, -1, 0x03, 0x0000, 0x0086 },
|
||||
{ 0x00, 0x07, -1, 0x03, 0x0000, 0x00c6 },
|
||||
{ 0x00, 0x08, -1, 0x03, 0x0000, 0x0146 },
|
||||
{ 0x00, 0x09, -1, 0x03, 0x0000, 0x0246 },
|
||||
{ 0x00, 0x0a, -1, 0x03, 0x0000, 0x0446 },
|
||||
{ 0x00, 0x18, -1, 0x03, 0x0000, 0x0846 },
|
||||
{ 0x00, 0x05, -1, 0x03, 0x0001, 0x0046 },
|
||||
{ 0x00, 0x05, -1, 0x03, 0x0001, 0x0066 },
|
||||
{ 0x00, 0x06, -1, 0x03, 0x0001, 0x0086 },
|
||||
{ 0x00, 0x07, -1, 0x03, 0x0001, 0x00c6 },
|
||||
{ 0x00, 0x08, -1, 0x03, 0x0001, 0x0146 },
|
||||
{ 0x00, 0x09, -1, 0x03, 0x0001, 0x0246 },
|
||||
{ 0x00, 0x0a, -1, 0x03, 0x0001, 0x0446 },
|
||||
{ 0x00, 0x18, -1, 0x03, 0x0001, 0x0846 },
|
||||
{ 0x00, 0x05, -1, 0x03, 0x0002, 0x0046 },
|
||||
{ 0x00, 0x05, -1, 0x03, 0x0002, 0x0066 },
|
||||
{ 0x00, 0x06, -1, 0x03, 0x0002, 0x0086 },
|
||||
{ 0x00, 0x07, -1, 0x03, 0x0002, 0x00c6 },
|
||||
{ 0x00, 0x08, -1, 0x03, 0x0002, 0x0146 },
|
||||
{ 0x00, 0x09, -1, 0x03, 0x0002, 0x0246 },
|
||||
{ 0x00, 0x0a, -1, 0x03, 0x0002, 0x0446 },
|
||||
{ 0x00, 0x18, -1, 0x03, 0x0002, 0x0846 },
|
||||
{ 0x00, 0x05, -1, 0x03, 0x0003, 0x0046 },
|
||||
{ 0x00, 0x05, -1, 0x03, 0x0003, 0x0066 },
|
||||
{ 0x00, 0x06, -1, 0x03, 0x0003, 0x0086 },
|
||||
{ 0x00, 0x07, -1, 0x03, 0x0003, 0x00c6 },
|
||||
{ 0x00, 0x08, -1, 0x03, 0x0003, 0x0146 },
|
||||
{ 0x00, 0x09, -1, 0x03, 0x0003, 0x0246 },
|
||||
{ 0x00, 0x0a, -1, 0x03, 0x0003, 0x0446 },
|
||||
{ 0x00, 0x18, -1, 0x03, 0x0003, 0x0846 },
|
||||
{ 0x00, 0x05, -1, 0x03, 0x0004, 0x0046 },
|
||||
{ 0x00, 0x05, -1, 0x03, 0x0004, 0x0066 },
|
||||
{ 0x00, 0x06, -1, 0x03, 0x0004, 0x0086 },
|
||||
{ 0x00, 0x07, -1, 0x03, 0x0004, 0x00c6 },
|
||||
{ 0x00, 0x08, -1, 0x03, 0x0004, 0x0146 },
|
||||
{ 0x00, 0x09, -1, 0x03, 0x0004, 0x0246 },
|
||||
{ 0x00, 0x0a, -1, 0x03, 0x0004, 0x0446 },
|
||||
{ 0x00, 0x18, -1, 0x03, 0x0004, 0x0846 },
|
||||
{ 0x00, 0x05, -1, 0x03, 0x0005, 0x0046 },
|
||||
{ 0x00, 0x05, -1, 0x03, 0x0005, 0x0066 },
|
||||
{ 0x00, 0x06, -1, 0x03, 0x0005, 0x0086 },
|
||||
{ 0x00, 0x07, -1, 0x03, 0x0005, 0x00c6 },
|
||||
{ 0x00, 0x08, -1, 0x03, 0x0005, 0x0146 },
|
||||
{ 0x00, 0x09, -1, 0x03, 0x0005, 0x0246 },
|
||||
{ 0x00, 0x0a, -1, 0x03, 0x0005, 0x0446 },
|
||||
{ 0x00, 0x18, -1, 0x03, 0x0005, 0x0846 },
|
||||
{ 0x01, 0x05, -1, 0x03, 0x0006, 0x0046 },
|
||||
{ 0x01, 0x05, -1, 0x03, 0x0006, 0x0066 },
|
||||
{ 0x01, 0x06, -1, 0x03, 0x0006, 0x0086 },
|
||||
{ 0x01, 0x07, -1, 0x03, 0x0006, 0x00c6 },
|
||||
{ 0x01, 0x08, -1, 0x03, 0x0006, 0x0146 },
|
||||
{ 0x01, 0x09, -1, 0x03, 0x0006, 0x0246 },
|
||||
{ 0x01, 0x0a, -1, 0x03, 0x0006, 0x0446 },
|
||||
{ 0x01, 0x18, -1, 0x03, 0x0006, 0x0846 },
|
||||
{ 0x01, 0x05, -1, 0x03, 0x0008, 0x0046 },
|
||||
{ 0x01, 0x05, -1, 0x03, 0x0008, 0x0066 },
|
||||
{ 0x01, 0x06, -1, 0x03, 0x0008, 0x0086 },
|
||||
{ 0x01, 0x07, -1, 0x03, 0x0008, 0x00c6 },
|
||||
{ 0x01, 0x08, -1, 0x03, 0x0008, 0x0146 },
|
||||
{ 0x01, 0x09, -1, 0x03, 0x0008, 0x0246 },
|
||||
{ 0x01, 0x0a, -1, 0x03, 0x0008, 0x0446 },
|
||||
{ 0x01, 0x18, -1, 0x03, 0x0008, 0x0846 },
|
||||
{ 0x06, 0x00, -1, 0x00, 0x0082, 0x0002 },
|
||||
{ 0x06, 0x00, -1, 0x01, 0x0082, 0x0003 },
|
||||
{ 0x06, 0x00, -1, 0x02, 0x0082, 0x0004 },
|
||||
{ 0x06, 0x00, -1, 0x03, 0x0082, 0x0005 },
|
||||
{ 0x06, 0x00, -1, 0x03, 0x0082, 0x0006 },
|
||||
{ 0x06, 0x00, -1, 0x03, 0x0082, 0x0007 },
|
||||
{ 0x06, 0x00, -1, 0x03, 0x0082, 0x0008 },
|
||||
{ 0x06, 0x00, -1, 0x03, 0x0082, 0x0009 },
|
||||
{ 0x07, 0x00, -1, 0x00, 0x00c2, 0x0002 },
|
||||
{ 0x07, 0x00, -1, 0x01, 0x00c2, 0x0003 },
|
||||
{ 0x07, 0x00, -1, 0x02, 0x00c2, 0x0004 },
|
||||
{ 0x07, 0x00, -1, 0x03, 0x00c2, 0x0005 },
|
||||
{ 0x07, 0x00, -1, 0x03, 0x00c2, 0x0006 },
|
||||
{ 0x07, 0x00, -1, 0x03, 0x00c2, 0x0007 },
|
||||
{ 0x07, 0x00, -1, 0x03, 0x00c2, 0x0008 },
|
||||
{ 0x07, 0x00, -1, 0x03, 0x00c2, 0x0009 },
|
||||
{ 0x08, 0x00, -1, 0x00, 0x0142, 0x0002 },
|
||||
{ 0x08, 0x00, -1, 0x01, 0x0142, 0x0003 },
|
||||
{ 0x08, 0x00, -1, 0x02, 0x0142, 0x0004 },
|
||||
{ 0x08, 0x00, -1, 0x03, 0x0142, 0x0005 },
|
||||
{ 0x08, 0x00, -1, 0x03, 0x0142, 0x0006 },
|
||||
{ 0x08, 0x00, -1, 0x03, 0x0142, 0x0007 },
|
||||
{ 0x08, 0x00, -1, 0x03, 0x0142, 0x0008 },
|
||||
{ 0x08, 0x00, -1, 0x03, 0x0142, 0x0009 },
|
||||
{ 0x09, 0x00, -1, 0x00, 0x0242, 0x0002 },
|
||||
{ 0x09, 0x00, -1, 0x01, 0x0242, 0x0003 },
|
||||
{ 0x09, 0x00, -1, 0x02, 0x0242, 0x0004 },
|
||||
{ 0x09, 0x00, -1, 0x03, 0x0242, 0x0005 },
|
||||
{ 0x09, 0x00, -1, 0x03, 0x0242, 0x0006 },
|
||||
{ 0x09, 0x00, -1, 0x03, 0x0242, 0x0007 },
|
||||
{ 0x09, 0x00, -1, 0x03, 0x0242, 0x0008 },
|
||||
{ 0x09, 0x00, -1, 0x03, 0x0242, 0x0009 },
|
||||
{ 0x0a, 0x00, -1, 0x00, 0x0442, 0x0002 },
|
||||
{ 0x0a, 0x00, -1, 0x01, 0x0442, 0x0003 },
|
||||
{ 0x0a, 0x00, -1, 0x02, 0x0442, 0x0004 },
|
||||
{ 0x0a, 0x00, -1, 0x03, 0x0442, 0x0005 },
|
||||
{ 0x0a, 0x00, -1, 0x03, 0x0442, 0x0006 },
|
||||
{ 0x0a, 0x00, -1, 0x03, 0x0442, 0x0007 },
|
||||
{ 0x0a, 0x00, -1, 0x03, 0x0442, 0x0008 },
|
||||
{ 0x0a, 0x00, -1, 0x03, 0x0442, 0x0009 },
|
||||
{ 0x0c, 0x00, -1, 0x00, 0x0842, 0x0002 },
|
||||
{ 0x0c, 0x00, -1, 0x01, 0x0842, 0x0003 },
|
||||
{ 0x0c, 0x00, -1, 0x02, 0x0842, 0x0004 },
|
||||
{ 0x0c, 0x00, -1, 0x03, 0x0842, 0x0005 },
|
||||
{ 0x0c, 0x00, -1, 0x03, 0x0842, 0x0006 },
|
||||
{ 0x0c, 0x00, -1, 0x03, 0x0842, 0x0007 },
|
||||
{ 0x0c, 0x00, -1, 0x03, 0x0842, 0x0008 },
|
||||
{ 0x0c, 0x00, -1, 0x03, 0x0842, 0x0009 },
|
||||
{ 0x0e, 0x00, -1, 0x00, 0x1842, 0x0002 },
|
||||
{ 0x0e, 0x00, -1, 0x01, 0x1842, 0x0003 },
|
||||
{ 0x0e, 0x00, -1, 0x02, 0x1842, 0x0004 },
|
||||
{ 0x0e, 0x00, -1, 0x03, 0x1842, 0x0005 },
|
||||
{ 0x0e, 0x00, -1, 0x03, 0x1842, 0x0006 },
|
||||
{ 0x0e, 0x00, -1, 0x03, 0x1842, 0x0007 },
|
||||
{ 0x0e, 0x00, -1, 0x03, 0x1842, 0x0008 },
|
||||
{ 0x0e, 0x00, -1, 0x03, 0x1842, 0x0009 },
|
||||
{ 0x18, 0x00, -1, 0x00, 0x5842, 0x0002 },
|
||||
{ 0x18, 0x00, -1, 0x01, 0x5842, 0x0003 },
|
||||
{ 0x18, 0x00, -1, 0x02, 0x5842, 0x0004 },
|
||||
{ 0x18, 0x00, -1, 0x03, 0x5842, 0x0005 },
|
||||
{ 0x18, 0x00, -1, 0x03, 0x5842, 0x0006 },
|
||||
{ 0x18, 0x00, -1, 0x03, 0x5842, 0x0007 },
|
||||
{ 0x18, 0x00, -1, 0x03, 0x5842, 0x0008 },
|
||||
{ 0x18, 0x00, -1, 0x03, 0x5842, 0x0009 },
|
||||
{ 0x02, 0x05, -1, 0x03, 0x000a, 0x0046 },
|
||||
{ 0x02, 0x05, -1, 0x03, 0x000a, 0x0066 },
|
||||
{ 0x02, 0x06, -1, 0x03, 0x000a, 0x0086 },
|
||||
{ 0x02, 0x07, -1, 0x03, 0x000a, 0x00c6 },
|
||||
{ 0x02, 0x08, -1, 0x03, 0x000a, 0x0146 },
|
||||
{ 0x02, 0x09, -1, 0x03, 0x000a, 0x0246 },
|
||||
{ 0x02, 0x0a, -1, 0x03, 0x000a, 0x0446 },
|
||||
{ 0x02, 0x18, -1, 0x03, 0x000a, 0x0846 },
|
||||
{ 0x02, 0x05, -1, 0x03, 0x000e, 0x0046 },
|
||||
{ 0x02, 0x05, -1, 0x03, 0x000e, 0x0066 },
|
||||
{ 0x02, 0x06, -1, 0x03, 0x000e, 0x0086 },
|
||||
{ 0x02, 0x07, -1, 0x03, 0x000e, 0x00c6 },
|
||||
{ 0x02, 0x08, -1, 0x03, 0x000e, 0x0146 },
|
||||
{ 0x02, 0x09, -1, 0x03, 0x000e, 0x0246 },
|
||||
{ 0x02, 0x0a, -1, 0x03, 0x000e, 0x0446 },
|
||||
{ 0x02, 0x18, -1, 0x03, 0x000e, 0x0846 },
|
||||
{ 0x03, 0x05, -1, 0x03, 0x0012, 0x0046 },
|
||||
{ 0x03, 0x05, -1, 0x03, 0x0012, 0x0066 },
|
||||
{ 0x03, 0x06, -1, 0x03, 0x0012, 0x0086 },
|
||||
{ 0x03, 0x07, -1, 0x03, 0x0012, 0x00c6 },
|
||||
{ 0x03, 0x08, -1, 0x03, 0x0012, 0x0146 },
|
||||
{ 0x03, 0x09, -1, 0x03, 0x0012, 0x0246 },
|
||||
{ 0x03, 0x0a, -1, 0x03, 0x0012, 0x0446 },
|
||||
{ 0x03, 0x18, -1, 0x03, 0x0012, 0x0846 },
|
||||
{ 0x03, 0x05, -1, 0x03, 0x001a, 0x0046 },
|
||||
{ 0x03, 0x05, -1, 0x03, 0x001a, 0x0066 },
|
||||
{ 0x03, 0x06, -1, 0x03, 0x001a, 0x0086 },
|
||||
{ 0x03, 0x07, -1, 0x03, 0x001a, 0x00c6 },
|
||||
{ 0x03, 0x08, -1, 0x03, 0x001a, 0x0146 },
|
||||
{ 0x03, 0x09, -1, 0x03, 0x001a, 0x0246 },
|
||||
{ 0x03, 0x0a, -1, 0x03, 0x001a, 0x0446 },
|
||||
{ 0x03, 0x18, -1, 0x03, 0x001a, 0x0846 },
|
||||
{ 0x04, 0x05, -1, 0x03, 0x0022, 0x0046 },
|
||||
{ 0x04, 0x05, -1, 0x03, 0x0022, 0x0066 },
|
||||
{ 0x04, 0x06, -1, 0x03, 0x0022, 0x0086 },
|
||||
{ 0x04, 0x07, -1, 0x03, 0x0022, 0x00c6 },
|
||||
{ 0x04, 0x08, -1, 0x03, 0x0022, 0x0146 },
|
||||
{ 0x04, 0x09, -1, 0x03, 0x0022, 0x0246 },
|
||||
{ 0x04, 0x0a, -1, 0x03, 0x0022, 0x0446 },
|
||||
{ 0x04, 0x18, -1, 0x03, 0x0022, 0x0846 },
|
||||
{ 0x04, 0x05, -1, 0x03, 0x0032, 0x0046 },
|
||||
{ 0x04, 0x05, -1, 0x03, 0x0032, 0x0066 },
|
||||
{ 0x04, 0x06, -1, 0x03, 0x0032, 0x0086 },
|
||||
{ 0x04, 0x07, -1, 0x03, 0x0032, 0x00c6 },
|
||||
{ 0x04, 0x08, -1, 0x03, 0x0032, 0x0146 },
|
||||
{ 0x04, 0x09, -1, 0x03, 0x0032, 0x0246 },
|
||||
{ 0x04, 0x0a, -1, 0x03, 0x0032, 0x0446 },
|
||||
{ 0x04, 0x18, -1, 0x03, 0x0032, 0x0846 },
|
||||
{ 0x05, 0x05, -1, 0x03, 0x0042, 0x0046 },
|
||||
{ 0x05, 0x05, -1, 0x03, 0x0042, 0x0066 },
|
||||
{ 0x05, 0x06, -1, 0x03, 0x0042, 0x0086 },
|
||||
{ 0x05, 0x07, -1, 0x03, 0x0042, 0x00c6 },
|
||||
{ 0x05, 0x08, -1, 0x03, 0x0042, 0x0146 },
|
||||
{ 0x05, 0x09, -1, 0x03, 0x0042, 0x0246 },
|
||||
{ 0x05, 0x0a, -1, 0x03, 0x0042, 0x0446 },
|
||||
{ 0x05, 0x18, -1, 0x03, 0x0042, 0x0846 },
|
||||
{ 0x05, 0x05, -1, 0x03, 0x0062, 0x0046 },
|
||||
{ 0x05, 0x05, -1, 0x03, 0x0062, 0x0066 },
|
||||
{ 0x05, 0x06, -1, 0x03, 0x0062, 0x0086 },
|
||||
{ 0x05, 0x07, -1, 0x03, 0x0062, 0x00c6 },
|
||||
{ 0x05, 0x08, -1, 0x03, 0x0062, 0x0146 },
|
||||
{ 0x05, 0x09, -1, 0x03, 0x0062, 0x0246 },
|
||||
{ 0x05, 0x0a, -1, 0x03, 0x0062, 0x0446 },
|
||||
{ 0x05, 0x18, -1, 0x03, 0x0062, 0x0846 },
|
||||
{ 0x06, 0x01, -1, 0x03, 0x0082, 0x000a },
|
||||
{ 0x06, 0x01, -1, 0x03, 0x0082, 0x000c },
|
||||
{ 0x06, 0x02, -1, 0x03, 0x0082, 0x000e },
|
||||
{ 0x06, 0x02, -1, 0x03, 0x0082, 0x0012 },
|
||||
{ 0x06, 0x03, -1, 0x03, 0x0082, 0x0016 },
|
||||
{ 0x06, 0x03, -1, 0x03, 0x0082, 0x001e },
|
||||
{ 0x06, 0x04, -1, 0x03, 0x0082, 0x0026 },
|
||||
{ 0x06, 0x04, -1, 0x03, 0x0082, 0x0036 },
|
||||
{ 0x07, 0x01, -1, 0x03, 0x00c2, 0x000a },
|
||||
{ 0x07, 0x01, -1, 0x03, 0x00c2, 0x000c },
|
||||
{ 0x07, 0x02, -1, 0x03, 0x00c2, 0x000e },
|
||||
{ 0x07, 0x02, -1, 0x03, 0x00c2, 0x0012 },
|
||||
{ 0x07, 0x03, -1, 0x03, 0x00c2, 0x0016 },
|
||||
{ 0x07, 0x03, -1, 0x03, 0x00c2, 0x001e },
|
||||
{ 0x07, 0x04, -1, 0x03, 0x00c2, 0x0026 },
|
||||
{ 0x07, 0x04, -1, 0x03, 0x00c2, 0x0036 },
|
||||
{ 0x08, 0x01, -1, 0x03, 0x0142, 0x000a },
|
||||
{ 0x08, 0x01, -1, 0x03, 0x0142, 0x000c },
|
||||
{ 0x08, 0x02, -1, 0x03, 0x0142, 0x000e },
|
||||
{ 0x08, 0x02, -1, 0x03, 0x0142, 0x0012 },
|
||||
{ 0x08, 0x03, -1, 0x03, 0x0142, 0x0016 },
|
||||
{ 0x08, 0x03, -1, 0x03, 0x0142, 0x001e },
|
||||
{ 0x08, 0x04, -1, 0x03, 0x0142, 0x0026 },
|
||||
{ 0x08, 0x04, -1, 0x03, 0x0142, 0x0036 },
|
||||
{ 0x09, 0x01, -1, 0x03, 0x0242, 0x000a },
|
||||
{ 0x09, 0x01, -1, 0x03, 0x0242, 0x000c },
|
||||
{ 0x09, 0x02, -1, 0x03, 0x0242, 0x000e },
|
||||
{ 0x09, 0x02, -1, 0x03, 0x0242, 0x0012 },
|
||||
{ 0x09, 0x03, -1, 0x03, 0x0242, 0x0016 },
|
||||
{ 0x09, 0x03, -1, 0x03, 0x0242, 0x001e },
|
||||
{ 0x09, 0x04, -1, 0x03, 0x0242, 0x0026 },
|
||||
{ 0x09, 0x04, -1, 0x03, 0x0242, 0x0036 },
|
||||
{ 0x0a, 0x01, -1, 0x03, 0x0442, 0x000a },
|
||||
{ 0x0a, 0x01, -1, 0x03, 0x0442, 0x000c },
|
||||
{ 0x0a, 0x02, -1, 0x03, 0x0442, 0x000e },
|
||||
{ 0x0a, 0x02, -1, 0x03, 0x0442, 0x0012 },
|
||||
{ 0x0a, 0x03, -1, 0x03, 0x0442, 0x0016 },
|
||||
{ 0x0a, 0x03, -1, 0x03, 0x0442, 0x001e },
|
||||
{ 0x0a, 0x04, -1, 0x03, 0x0442, 0x0026 },
|
||||
{ 0x0a, 0x04, -1, 0x03, 0x0442, 0x0036 },
|
||||
{ 0x0c, 0x01, -1, 0x03, 0x0842, 0x000a },
|
||||
{ 0x0c, 0x01, -1, 0x03, 0x0842, 0x000c },
|
||||
{ 0x0c, 0x02, -1, 0x03, 0x0842, 0x000e },
|
||||
{ 0x0c, 0x02, -1, 0x03, 0x0842, 0x0012 },
|
||||
{ 0x0c, 0x03, -1, 0x03, 0x0842, 0x0016 },
|
||||
{ 0x0c, 0x03, -1, 0x03, 0x0842, 0x001e },
|
||||
{ 0x0c, 0x04, -1, 0x03, 0x0842, 0x0026 },
|
||||
{ 0x0c, 0x04, -1, 0x03, 0x0842, 0x0036 },
|
||||
{ 0x0e, 0x01, -1, 0x03, 0x1842, 0x000a },
|
||||
{ 0x0e, 0x01, -1, 0x03, 0x1842, 0x000c },
|
||||
{ 0x0e, 0x02, -1, 0x03, 0x1842, 0x000e },
|
||||
{ 0x0e, 0x02, -1, 0x03, 0x1842, 0x0012 },
|
||||
{ 0x0e, 0x03, -1, 0x03, 0x1842, 0x0016 },
|
||||
{ 0x0e, 0x03, -1, 0x03, 0x1842, 0x001e },
|
||||
{ 0x0e, 0x04, -1, 0x03, 0x1842, 0x0026 },
|
||||
{ 0x0e, 0x04, -1, 0x03, 0x1842, 0x0036 },
|
||||
{ 0x18, 0x01, -1, 0x03, 0x5842, 0x000a },
|
||||
{ 0x18, 0x01, -1, 0x03, 0x5842, 0x000c },
|
||||
{ 0x18, 0x02, -1, 0x03, 0x5842, 0x000e },
|
||||
{ 0x18, 0x02, -1, 0x03, 0x5842, 0x0012 },
|
||||
{ 0x18, 0x03, -1, 0x03, 0x5842, 0x0016 },
|
||||
{ 0x18, 0x03, -1, 0x03, 0x5842, 0x001e },
|
||||
{ 0x18, 0x04, -1, 0x03, 0x5842, 0x0026 },
|
||||
{ 0x18, 0x04, -1, 0x03, 0x5842, 0x0036 },
|
||||
{ 0x06, 0x05, -1, 0x03, 0x0082, 0x0046 },
|
||||
{ 0x06, 0x05, -1, 0x03, 0x0082, 0x0066 },
|
||||
{ 0x06, 0x06, -1, 0x03, 0x0082, 0x0086 },
|
||||
{ 0x06, 0x07, -1, 0x03, 0x0082, 0x00c6 },
|
||||
{ 0x06, 0x08, -1, 0x03, 0x0082, 0x0146 },
|
||||
{ 0x06, 0x09, -1, 0x03, 0x0082, 0x0246 },
|
||||
{ 0x06, 0x0a, -1, 0x03, 0x0082, 0x0446 },
|
||||
{ 0x06, 0x18, -1, 0x03, 0x0082, 0x0846 },
|
||||
{ 0x07, 0x05, -1, 0x03, 0x00c2, 0x0046 },
|
||||
{ 0x07, 0x05, -1, 0x03, 0x00c2, 0x0066 },
|
||||
{ 0x07, 0x06, -1, 0x03, 0x00c2, 0x0086 },
|
||||
{ 0x07, 0x07, -1, 0x03, 0x00c2, 0x00c6 },
|
||||
{ 0x07, 0x08, -1, 0x03, 0x00c2, 0x0146 },
|
||||
{ 0x07, 0x09, -1, 0x03, 0x00c2, 0x0246 },
|
||||
{ 0x07, 0x0a, -1, 0x03, 0x00c2, 0x0446 },
|
||||
{ 0x07, 0x18, -1, 0x03, 0x00c2, 0x0846 },
|
||||
{ 0x08, 0x05, -1, 0x03, 0x0142, 0x0046 },
|
||||
{ 0x08, 0x05, -1, 0x03, 0x0142, 0x0066 },
|
||||
{ 0x08, 0x06, -1, 0x03, 0x0142, 0x0086 },
|
||||
{ 0x08, 0x07, -1, 0x03, 0x0142, 0x00c6 },
|
||||
{ 0x08, 0x08, -1, 0x03, 0x0142, 0x0146 },
|
||||
{ 0x08, 0x09, -1, 0x03, 0x0142, 0x0246 },
|
||||
{ 0x08, 0x0a, -1, 0x03, 0x0142, 0x0446 },
|
||||
{ 0x08, 0x18, -1, 0x03, 0x0142, 0x0846 },
|
||||
{ 0x09, 0x05, -1, 0x03, 0x0242, 0x0046 },
|
||||
{ 0x09, 0x05, -1, 0x03, 0x0242, 0x0066 },
|
||||
{ 0x09, 0x06, -1, 0x03, 0x0242, 0x0086 },
|
||||
{ 0x09, 0x07, -1, 0x03, 0x0242, 0x00c6 },
|
||||
{ 0x09, 0x08, -1, 0x03, 0x0242, 0x0146 },
|
||||
{ 0x09, 0x09, -1, 0x03, 0x0242, 0x0246 },
|
||||
{ 0x09, 0x0a, -1, 0x03, 0x0242, 0x0446 },
|
||||
{ 0x09, 0x18, -1, 0x03, 0x0242, 0x0846 },
|
||||
{ 0x0a, 0x05, -1, 0x03, 0x0442, 0x0046 },
|
||||
{ 0x0a, 0x05, -1, 0x03, 0x0442, 0x0066 },
|
||||
{ 0x0a, 0x06, -1, 0x03, 0x0442, 0x0086 },
|
||||
{ 0x0a, 0x07, -1, 0x03, 0x0442, 0x00c6 },
|
||||
{ 0x0a, 0x08, -1, 0x03, 0x0442, 0x0146 },
|
||||
{ 0x0a, 0x09, -1, 0x03, 0x0442, 0x0246 },
|
||||
{ 0x0a, 0x0a, -1, 0x03, 0x0442, 0x0446 },
|
||||
{ 0x0a, 0x18, -1, 0x03, 0x0442, 0x0846 },
|
||||
{ 0x0c, 0x05, -1, 0x03, 0x0842, 0x0046 },
|
||||
{ 0x0c, 0x05, -1, 0x03, 0x0842, 0x0066 },
|
||||
{ 0x0c, 0x06, -1, 0x03, 0x0842, 0x0086 },
|
||||
{ 0x0c, 0x07, -1, 0x03, 0x0842, 0x00c6 },
|
||||
{ 0x0c, 0x08, -1, 0x03, 0x0842, 0x0146 },
|
||||
{ 0x0c, 0x09, -1, 0x03, 0x0842, 0x0246 },
|
||||
{ 0x0c, 0x0a, -1, 0x03, 0x0842, 0x0446 },
|
||||
{ 0x0c, 0x18, -1, 0x03, 0x0842, 0x0846 },
|
||||
{ 0x0e, 0x05, -1, 0x03, 0x1842, 0x0046 },
|
||||
{ 0x0e, 0x05, -1, 0x03, 0x1842, 0x0066 },
|
||||
{ 0x0e, 0x06, -1, 0x03, 0x1842, 0x0086 },
|
||||
{ 0x0e, 0x07, -1, 0x03, 0x1842, 0x00c6 },
|
||||
{ 0x0e, 0x08, -1, 0x03, 0x1842, 0x0146 },
|
||||
{ 0x0e, 0x09, -1, 0x03, 0x1842, 0x0246 },
|
||||
{ 0x0e, 0x0a, -1, 0x03, 0x1842, 0x0446 },
|
||||
{ 0x0e, 0x18, -1, 0x03, 0x1842, 0x0846 },
|
||||
{ 0x18, 0x05, -1, 0x03, 0x5842, 0x0046 },
|
||||
{ 0x18, 0x05, -1, 0x03, 0x5842, 0x0066 },
|
||||
{ 0x18, 0x06, -1, 0x03, 0x5842, 0x0086 },
|
||||
{ 0x18, 0x07, -1, 0x03, 0x5842, 0x00c6 },
|
||||
{ 0x18, 0x08, -1, 0x03, 0x5842, 0x0146 },
|
||||
{ 0x18, 0x09, -1, 0x03, 0x5842, 0x0246 },
|
||||
{ 0x18, 0x0a, -1, 0x03, 0x5842, 0x0446 },
|
||||
{ 0x18, 0x18, -1, 0x03, 0x5842, 0x0846 },
|
||||
};
|
||||
|
||||
#endif /* BROTLI_DEC_PREFIX_H_ */
|
||||
180
modules/brotli/dec/state.c
Normal file
180
modules/brotli/dec/state.c
Normal file
|
|
@ -0,0 +1,180 @@
|
|||
/* Copyright 2015 Google Inc. All Rights Reserved.
|
||||
|
||||
Distributed under MIT license.
|
||||
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "./state.h"
|
||||
|
||||
#include <stdlib.h> /* free, malloc */
|
||||
|
||||
#include "./huffman.h"
|
||||
#include "./types.h"
|
||||
|
||||
#if defined(__cplusplus) || defined(c_plusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Declared in decode.h */
|
||||
int BrotliStateIsStreamStart(const BrotliState* s);
|
||||
int BrotliStateIsStreamEnd(const BrotliState* s);
|
||||
|
||||
static void* DefaultAllocFunc(void* opaque, size_t size) {
|
||||
BROTLI_UNUSED(opaque);
|
||||
return malloc(size);
|
||||
}
|
||||
|
||||
static void DefaultFreeFunc(void* opaque, void* address) {
|
||||
BROTLI_UNUSED(opaque);
|
||||
free(address);
|
||||
}
|
||||
|
||||
void BrotliStateInit(BrotliState* s) {
|
||||
BrotliStateInitWithCustomAllocators(s, 0, 0, 0);
|
||||
}
|
||||
|
||||
void BrotliStateInitWithCustomAllocators(BrotliState* s,
|
||||
brotli_alloc_func alloc_func, brotli_free_func free_func, void* opaque) {
|
||||
if (!alloc_func) {
|
||||
s->alloc_func = DefaultAllocFunc;
|
||||
s->free_func = DefaultFreeFunc;
|
||||
s->memory_manager_opaque = 0;
|
||||
} else {
|
||||
s->alloc_func = alloc_func;
|
||||
s->free_func = free_func;
|
||||
s->memory_manager_opaque = opaque;
|
||||
}
|
||||
|
||||
BrotliInitBitReader(&s->br);
|
||||
s->state = BROTLI_STATE_UNINITED;
|
||||
s->substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_NONE;
|
||||
s->substate_tree_group = BROTLI_STATE_TREE_GROUP_NONE;
|
||||
s->substate_context_map = BROTLI_STATE_CONTEXT_MAP_NONE;
|
||||
s->substate_uncompressed = BROTLI_STATE_UNCOMPRESSED_NONE;
|
||||
s->substate_huffman = BROTLI_STATE_HUFFMAN_NONE;
|
||||
s->substate_decode_uint8 = BROTLI_STATE_DECODE_UINT8_NONE;
|
||||
s->substate_read_block_length = BROTLI_STATE_READ_BLOCK_LENGTH_NONE;
|
||||
|
||||
s->buffer_length = 0;
|
||||
s->loop_counter = 0;
|
||||
s->pos = 0;
|
||||
s->rb_roundtrips = 0;
|
||||
s->partial_pos_out = 0;
|
||||
|
||||
s->block_type_trees = NULL;
|
||||
s->block_len_trees = NULL;
|
||||
s->ringbuffer = NULL;
|
||||
|
||||
s->context_map = NULL;
|
||||
s->context_modes = NULL;
|
||||
s->dist_context_map = NULL;
|
||||
s->context_map_slice = NULL;
|
||||
s->dist_context_map_slice = NULL;
|
||||
|
||||
s->sub_loop_counter = 0;
|
||||
|
||||
s->literal_hgroup.codes = NULL;
|
||||
s->literal_hgroup.htrees = NULL;
|
||||
s->insert_copy_hgroup.codes = NULL;
|
||||
s->insert_copy_hgroup.htrees = NULL;
|
||||
s->distance_hgroup.codes = NULL;
|
||||
s->distance_hgroup.htrees = NULL;
|
||||
|
||||
s->custom_dict = NULL;
|
||||
s->custom_dict_size = 0;
|
||||
|
||||
s->is_last_metablock = 0;
|
||||
s->window_bits = 0;
|
||||
s->max_distance = 0;
|
||||
s->dist_rb[0] = 16;
|
||||
s->dist_rb[1] = 15;
|
||||
s->dist_rb[2] = 11;
|
||||
s->dist_rb[3] = 4;
|
||||
s->dist_rb_idx = 0;
|
||||
s->block_type_trees = NULL;
|
||||
s->block_len_trees = NULL;
|
||||
|
||||
/* Make small negative indexes addressable. */
|
||||
s->symbol_lists = &s->symbols_lists_array[BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1];
|
||||
|
||||
s->mtf_upper_bound = 255;
|
||||
}
|
||||
|
||||
void BrotliStateMetablockBegin(BrotliState* s) {
|
||||
s->meta_block_remaining_len = 0;
|
||||
s->block_length[0] = 1U << 28;
|
||||
s->block_length[1] = 1U << 28;
|
||||
s->block_length[2] = 1U << 28;
|
||||
s->num_block_types[0] = 1;
|
||||
s->num_block_types[1] = 1;
|
||||
s->num_block_types[2] = 1;
|
||||
s->block_type_rb[0] = 1;
|
||||
s->block_type_rb[1] = 0;
|
||||
s->block_type_rb[2] = 1;
|
||||
s->block_type_rb[3] = 0;
|
||||
s->block_type_rb[4] = 1;
|
||||
s->block_type_rb[5] = 0;
|
||||
s->context_map = NULL;
|
||||
s->context_modes = NULL;
|
||||
s->dist_context_map = NULL;
|
||||
s->context_map_slice = NULL;
|
||||
s->literal_htree = NULL;
|
||||
s->dist_context_map_slice = NULL;
|
||||
s->dist_htree_index = 0;
|
||||
s->context_lookup1 = NULL;
|
||||
s->context_lookup2 = NULL;
|
||||
s->literal_hgroup.codes = NULL;
|
||||
s->literal_hgroup.htrees = NULL;
|
||||
s->insert_copy_hgroup.codes = NULL;
|
||||
s->insert_copy_hgroup.htrees = NULL;
|
||||
s->distance_hgroup.codes = NULL;
|
||||
s->distance_hgroup.htrees = NULL;
|
||||
}
|
||||
|
||||
void BrotliStateCleanupAfterMetablock(BrotliState* s) {
|
||||
BROTLI_FREE(s, s->context_modes);
|
||||
BROTLI_FREE(s, s->context_map);
|
||||
BROTLI_FREE(s, s->dist_context_map);
|
||||
|
||||
BrotliHuffmanTreeGroupRelease(s, &s->literal_hgroup);
|
||||
BrotliHuffmanTreeGroupRelease(s, &s->insert_copy_hgroup);
|
||||
BrotliHuffmanTreeGroupRelease(s, &s->distance_hgroup);
|
||||
}
|
||||
|
||||
void BrotliStateCleanup(BrotliState* s) {
|
||||
BrotliStateCleanupAfterMetablock(s);
|
||||
|
||||
BROTLI_FREE(s, s->ringbuffer);
|
||||
BROTLI_FREE(s, s->block_type_trees);
|
||||
}
|
||||
|
||||
int BrotliStateIsStreamStart(const BrotliState* s) {
|
||||
return (s->state == BROTLI_STATE_UNINITED &&
|
||||
BrotliGetAvailableBits(&s->br) == 0);
|
||||
}
|
||||
|
||||
int BrotliStateIsStreamEnd(const BrotliState* s) {
|
||||
return s->state == BROTLI_STATE_DONE;
|
||||
}
|
||||
|
||||
void BrotliHuffmanTreeGroupInit(BrotliState* s, HuffmanTreeGroup* group,
|
||||
uint32_t alphabet_size, uint32_t ntrees) {
|
||||
/* Pack two allocations into one */
|
||||
const size_t max_table_size = kMaxHuffmanTableSize[(alphabet_size + 31) >> 5];
|
||||
const size_t code_size = sizeof(HuffmanCode) * ntrees * max_table_size;
|
||||
const size_t htree_size = sizeof(HuffmanCode*) * ntrees;
|
||||
char* p = (char*)BROTLI_ALLOC(s, code_size + htree_size);
|
||||
group->alphabet_size = (uint16_t)alphabet_size;
|
||||
group->num_htrees = (uint16_t)ntrees;
|
||||
group->codes = (HuffmanCode*)p;
|
||||
group->htrees = (HuffmanCode**)(p + code_size);
|
||||
}
|
||||
|
||||
void BrotliHuffmanTreeGroupRelease(BrotliState* s, HuffmanTreeGroup* group) {
|
||||
BROTLI_FREE(s, group->codes);
|
||||
group->htrees = NULL;
|
||||
}
|
||||
|
||||
#if defined(__cplusplus) || defined(c_plusplus)
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
242
modules/brotli/dec/state.h
Normal file
242
modules/brotli/dec/state.h
Normal file
|
|
@ -0,0 +1,242 @@
|
|||
/* Copyright 2015 Google Inc. All Rights Reserved.
|
||||
|
||||
Distributed under MIT license.
|
||||
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
/* Brotli state for partial streaming decoding. */
|
||||
|
||||
#ifndef BROTLI_DEC_STATE_H_
|
||||
#define BROTLI_DEC_STATE_H_
|
||||
|
||||
#include "./bit_reader.h"
|
||||
#include "./huffman.h"
|
||||
#include "./types.h"
|
||||
#include "./port.h"
|
||||
|
||||
#if defined(__cplusplus) || defined(c_plusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef enum {
|
||||
BROTLI_STATE_UNINITED,
|
||||
BROTLI_STATE_METABLOCK_BEGIN,
|
||||
BROTLI_STATE_METABLOCK_HEADER,
|
||||
BROTLI_STATE_METABLOCK_HEADER_2,
|
||||
BROTLI_STATE_CONTEXT_MODES,
|
||||
BROTLI_STATE_COMMAND_BEGIN,
|
||||
BROTLI_STATE_COMMAND_INNER,
|
||||
BROTLI_STATE_COMMAND_POST_DECODE_LITERALS,
|
||||
BROTLI_STATE_COMMAND_POST_WRAP_COPY,
|
||||
BROTLI_STATE_UNCOMPRESSED,
|
||||
BROTLI_STATE_METADATA,
|
||||
BROTLI_STATE_COMMAND_INNER_WRITE,
|
||||
BROTLI_STATE_METABLOCK_DONE,
|
||||
BROTLI_STATE_COMMAND_POST_WRITE_1,
|
||||
BROTLI_STATE_COMMAND_POST_WRITE_2,
|
||||
BROTLI_STATE_HUFFMAN_CODE_0,
|
||||
BROTLI_STATE_HUFFMAN_CODE_1,
|
||||
BROTLI_STATE_HUFFMAN_CODE_2,
|
||||
BROTLI_STATE_HUFFMAN_CODE_3,
|
||||
BROTLI_STATE_CONTEXT_MAP_1,
|
||||
BROTLI_STATE_CONTEXT_MAP_2,
|
||||
BROTLI_STATE_TREE_GROUP,
|
||||
BROTLI_STATE_DONE
|
||||
} BrotliRunningState;
|
||||
|
||||
typedef enum {
|
||||
BROTLI_STATE_METABLOCK_HEADER_NONE,
|
||||
BROTLI_STATE_METABLOCK_HEADER_EMPTY,
|
||||
BROTLI_STATE_METABLOCK_HEADER_NIBBLES,
|
||||
BROTLI_STATE_METABLOCK_HEADER_SIZE,
|
||||
BROTLI_STATE_METABLOCK_HEADER_UNCOMPRESSED,
|
||||
BROTLI_STATE_METABLOCK_HEADER_RESERVED,
|
||||
BROTLI_STATE_METABLOCK_HEADER_BYTES,
|
||||
BROTLI_STATE_METABLOCK_HEADER_METADATA
|
||||
} BrotliRunningMetablockHeaderState;
|
||||
|
||||
typedef enum {
|
||||
BROTLI_STATE_UNCOMPRESSED_NONE,
|
||||
BROTLI_STATE_UNCOMPRESSED_WRITE
|
||||
} BrotliRunningUncompressedState;
|
||||
|
||||
typedef enum {
|
||||
BROTLI_STATE_TREE_GROUP_NONE,
|
||||
BROTLI_STATE_TREE_GROUP_LOOP
|
||||
} BrotliRunningTreeGroupState;
|
||||
|
||||
typedef enum {
|
||||
BROTLI_STATE_CONTEXT_MAP_NONE,
|
||||
BROTLI_STATE_CONTEXT_MAP_READ_PREFIX,
|
||||
BROTLI_STATE_CONTEXT_MAP_HUFFMAN,
|
||||
BROTLI_STATE_CONTEXT_MAP_DECODE,
|
||||
BROTLI_STATE_CONTEXT_MAP_TRANSFORM
|
||||
} BrotliRunningContextMapState;
|
||||
|
||||
typedef enum {
|
||||
BROTLI_STATE_HUFFMAN_NONE,
|
||||
BROTLI_STATE_HUFFMAN_SIMPLE_SIZE,
|
||||
BROTLI_STATE_HUFFMAN_SIMPLE_READ,
|
||||
BROTLI_STATE_HUFFMAN_SIMPLE_BUILD,
|
||||
BROTLI_STATE_HUFFMAN_COMPLEX,
|
||||
BROTLI_STATE_HUFFMAN_LENGTH_SYMBOLS
|
||||
} BrotliRunningHuffmanState;
|
||||
|
||||
typedef enum {
|
||||
BROTLI_STATE_DECODE_UINT8_NONE,
|
||||
BROTLI_STATE_DECODE_UINT8_SHORT,
|
||||
BROTLI_STATE_DECODE_UINT8_LONG
|
||||
} BrotliRunningDecodeUint8State;
|
||||
|
||||
typedef enum {
|
||||
BROTLI_STATE_READ_BLOCK_LENGTH_NONE,
|
||||
BROTLI_STATE_READ_BLOCK_LENGTH_SUFFIX
|
||||
} BrotliRunningReadBlockLengthState;
|
||||
|
||||
struct BrotliStateStruct {
|
||||
BrotliRunningState state;
|
||||
|
||||
/* This counter is reused for several disjoint loops. */
|
||||
int loop_counter;
|
||||
|
||||
BrotliBitReader br;
|
||||
|
||||
brotli_alloc_func alloc_func;
|
||||
brotli_free_func free_func;
|
||||
void* memory_manager_opaque;
|
||||
|
||||
/* Temporary storage for remaining input. */
|
||||
union {
|
||||
uint64_t u64;
|
||||
uint8_t u8[8];
|
||||
} buffer;
|
||||
uint32_t buffer_length;
|
||||
|
||||
int pos;
|
||||
int max_backward_distance;
|
||||
int max_backward_distance_minus_custom_dict_size;
|
||||
int max_distance;
|
||||
int ringbuffer_size;
|
||||
int ringbuffer_mask;
|
||||
int dist_rb_idx;
|
||||
int dist_rb[4];
|
||||
int error_code;
|
||||
uint32_t sub_loop_counter;
|
||||
uint8_t* ringbuffer;
|
||||
uint8_t* ringbuffer_end;
|
||||
HuffmanCode* htree_command;
|
||||
const uint8_t* context_lookup1;
|
||||
const uint8_t* context_lookup2;
|
||||
uint8_t* context_map_slice;
|
||||
uint8_t* dist_context_map_slice;
|
||||
|
||||
/* This ring buffer holds a few past copy distances that will be used by */
|
||||
/* some special distance codes. */
|
||||
HuffmanTreeGroup literal_hgroup;
|
||||
HuffmanTreeGroup insert_copy_hgroup;
|
||||
HuffmanTreeGroup distance_hgroup;
|
||||
HuffmanCode* block_type_trees;
|
||||
HuffmanCode* block_len_trees;
|
||||
/* This is true if the literal context map histogram type always matches the
|
||||
block type. It is then not needed to keep the context (faster decoding). */
|
||||
int trivial_literal_context;
|
||||
int distance_context;
|
||||
int meta_block_remaining_len;
|
||||
uint32_t block_length_index;
|
||||
uint32_t block_length[3];
|
||||
uint32_t num_block_types[3];
|
||||
uint32_t block_type_rb[6];
|
||||
uint32_t distance_postfix_bits;
|
||||
uint32_t num_direct_distance_codes;
|
||||
int distance_postfix_mask;
|
||||
uint32_t num_dist_htrees;
|
||||
uint8_t* dist_context_map;
|
||||
HuffmanCode* literal_htree;
|
||||
uint8_t dist_htree_index;
|
||||
uint32_t repeat_code_len;
|
||||
uint32_t prev_code_len;
|
||||
|
||||
int copy_length;
|
||||
int distance_code;
|
||||
|
||||
/* For partial write operations */
|
||||
size_t rb_roundtrips; /* How many times we went around the ringbuffer */
|
||||
size_t partial_pos_out; /* How much output to the user in total (<= rb) */
|
||||
|
||||
/* For ReadHuffmanCode */
|
||||
uint32_t symbol;
|
||||
uint32_t repeat;
|
||||
uint32_t space;
|
||||
|
||||
HuffmanCode table[32];
|
||||
/* List of of symbol chains. */
|
||||
uint16_t* symbol_lists;
|
||||
/* Storage from symbol_lists. */
|
||||
uint16_t symbols_lists_array[BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1 +
|
||||
BROTLI_HUFFMAN_MAX_CODE_LENGTHS_SIZE];
|
||||
/* Tails of symbol chains. */
|
||||
int next_symbol[32];
|
||||
uint8_t code_length_code_lengths[18];
|
||||
/* Population counts for the code lengths */
|
||||
uint16_t code_length_histo[16];
|
||||
|
||||
/* For HuffmanTreeGroupDecode */
|
||||
int htree_index;
|
||||
HuffmanCode* next;
|
||||
|
||||
/* For DecodeContextMap */
|
||||
uint32_t context_index;
|
||||
uint32_t max_run_length_prefix;
|
||||
uint32_t code;
|
||||
HuffmanCode context_map_table[BROTLI_HUFFMAN_MAX_SIZE_272];
|
||||
|
||||
/* For InverseMoveToFrontTransform */
|
||||
uint32_t mtf_upper_bound;
|
||||
uint8_t mtf[256 + 4];
|
||||
|
||||
/* For custom dictionaries */
|
||||
const uint8_t* custom_dict;
|
||||
int custom_dict_size;
|
||||
|
||||
/* less used attributes are in the end of this struct */
|
||||
/* States inside function calls */
|
||||
BrotliRunningMetablockHeaderState substate_metablock_header;
|
||||
BrotliRunningTreeGroupState substate_tree_group;
|
||||
BrotliRunningContextMapState substate_context_map;
|
||||
BrotliRunningUncompressedState substate_uncompressed;
|
||||
BrotliRunningHuffmanState substate_huffman;
|
||||
BrotliRunningDecodeUint8State substate_decode_uint8;
|
||||
BrotliRunningReadBlockLengthState substate_read_block_length;
|
||||
|
||||
uint8_t is_last_metablock;
|
||||
uint8_t is_uncompressed;
|
||||
uint8_t is_metadata;
|
||||
uint8_t size_nibbles;
|
||||
uint32_t window_bits;
|
||||
|
||||
uint32_t num_literal_htrees;
|
||||
uint8_t* context_map;
|
||||
uint8_t* context_modes;
|
||||
|
||||
uint32_t trivial_literal_contexts[8]; /* 256 bits */
|
||||
};
|
||||
|
||||
typedef struct BrotliStateStruct BrotliStateInternal;
|
||||
#define BrotliState BrotliStateInternal
|
||||
|
||||
BROTLI_INTERNAL void BrotliStateInit(BrotliState* s);
|
||||
BROTLI_INTERNAL void BrotliStateInitWithCustomAllocators(BrotliState* s,
|
||||
brotli_alloc_func alloc_func, brotli_free_func free_func, void* opaque);
|
||||
BROTLI_INTERNAL void BrotliStateCleanup(BrotliState* s);
|
||||
BROTLI_INTERNAL void BrotliStateMetablockBegin(BrotliState* s);
|
||||
BROTLI_INTERNAL void BrotliStateCleanupAfterMetablock(BrotliState* s);
|
||||
BROTLI_INTERNAL void BrotliHuffmanTreeGroupInit(BrotliState* s,
|
||||
HuffmanTreeGroup* group, uint32_t alphabet_size, uint32_t ntrees);
|
||||
BROTLI_INTERNAL void BrotliHuffmanTreeGroupRelease(BrotliState* s,
|
||||
HuffmanTreeGroup* group);
|
||||
|
||||
#if defined(__cplusplus) || defined(c_plusplus)
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* BROTLI_DEC_STATE_H_ */
|
||||
300
modules/brotli/dec/transform.h
Normal file
300
modules/brotli/dec/transform.h
Normal file
|
|
@ -0,0 +1,300 @@
|
|||
/* Copyright 2013 Google Inc. All Rights Reserved.
|
||||
|
||||
Distributed under MIT license.
|
||||
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
/* Transformations on dictionary words. */
|
||||
|
||||
#ifndef BROTLI_DEC_TRANSFORM_H_
|
||||
#define BROTLI_DEC_TRANSFORM_H_
|
||||
|
||||
#include "./port.h"
|
||||
#include "./types.h"
|
||||
|
||||
#if defined(__cplusplus) || defined(c_plusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
enum WordTransformType {
|
||||
kIdentity = 0,
|
||||
kOmitLast1 = 1,
|
||||
kOmitLast2 = 2,
|
||||
kOmitLast3 = 3,
|
||||
kOmitLast4 = 4,
|
||||
kOmitLast5 = 5,
|
||||
kOmitLast6 = 6,
|
||||
kOmitLast7 = 7,
|
||||
kOmitLast8 = 8,
|
||||
kOmitLast9 = 9,
|
||||
kUppercaseFirst = 10,
|
||||
kUppercaseAll = 11,
|
||||
kOmitFirst1 = 12,
|
||||
kOmitFirst2 = 13,
|
||||
kOmitFirst3 = 14,
|
||||
kOmitFirst4 = 15,
|
||||
kOmitFirst5 = 16,
|
||||
kOmitFirst6 = 17,
|
||||
kOmitFirst7 = 18,
|
||||
kOmitFirst8 = 19,
|
||||
kOmitFirst9 = 20
|
||||
};
|
||||
|
||||
typedef struct {
|
||||
const uint8_t prefix_id;
|
||||
const uint8_t transform;
|
||||
const uint8_t suffix_id;
|
||||
} Transform;
|
||||
|
||||
static const char kPrefixSuffix[208] =
|
||||
"\0 \0, \0 of the \0 of \0s \0.\0 and \0 in \0\"\0 to \0\">\0\n\0. \0]\0"
|
||||
" for \0 a \0 that \0\'\0 with \0 from \0 by \0(\0. The \0 on \0 as \0"
|
||||
" is \0ing \0\n\t\0:\0ed \0=\"\0 at \0ly \0,\0=\'\0.com/\0. This \0"
|
||||
" not \0er \0al \0ful \0ive \0less \0est \0ize \0\xc2\xa0\0ous ";
|
||||
|
||||
enum {
|
||||
/* EMPTY = ""
|
||||
SP = " "
|
||||
DQUOT = "\""
|
||||
SQUOT = "'"
|
||||
CLOSEBR = "]"
|
||||
OPEN = "("
|
||||
SLASH = "/"
|
||||
NBSP = non-breaking space "\0xc2\xa0"
|
||||
*/
|
||||
kPFix_EMPTY = 0,
|
||||
kPFix_SP = 1,
|
||||
kPFix_COMMASP = 3,
|
||||
kPFix_SPofSPtheSP = 6,
|
||||
kPFix_SPtheSP = 9,
|
||||
kPFix_eSP = 12,
|
||||
kPFix_SPofSP = 15,
|
||||
kPFix_sSP = 20,
|
||||
kPFix_DOT = 23,
|
||||
kPFix_SPandSP = 25,
|
||||
kPFix_SPinSP = 31,
|
||||
kPFix_DQUOT = 36,
|
||||
kPFix_SPtoSP = 38,
|
||||
kPFix_DQUOTGT = 43,
|
||||
kPFix_NEWLINE = 46,
|
||||
kPFix_DOTSP = 48,
|
||||
kPFix_CLOSEBR = 51,
|
||||
kPFix_SPforSP = 53,
|
||||
kPFix_SPaSP = 59,
|
||||
kPFix_SPthatSP = 63,
|
||||
kPFix_SQUOT = 70,
|
||||
kPFix_SPwithSP = 72,
|
||||
kPFix_SPfromSP = 79,
|
||||
kPFix_SPbySP = 86,
|
||||
kPFix_OPEN = 91,
|
||||
kPFix_DOTSPTheSP = 93,
|
||||
kPFix_SPonSP = 100,
|
||||
kPFix_SPasSP = 105,
|
||||
kPFix_SPisSP = 110,
|
||||
kPFix_ingSP = 115,
|
||||
kPFix_NEWLINETAB = 120,
|
||||
kPFix_COLON = 123,
|
||||
kPFix_edSP = 125,
|
||||
kPFix_EQDQUOT = 129,
|
||||
kPFix_SPatSP = 132,
|
||||
kPFix_lySP = 137,
|
||||
kPFix_COMMA = 141,
|
||||
kPFix_EQSQUOT = 143,
|
||||
kPFix_DOTcomSLASH = 146,
|
||||
kPFix_DOTSPThisSP = 152,
|
||||
kPFix_SPnotSP = 160,
|
||||
kPFix_erSP = 166,
|
||||
kPFix_alSP = 170,
|
||||
kPFix_fulSP = 174,
|
||||
kPFix_iveSP = 179,
|
||||
kPFix_lessSP = 184,
|
||||
kPFix_estSP = 190,
|
||||
kPFix_izeSP = 195,
|
||||
kPFix_NBSP = 200,
|
||||
kPFix_ousSP = 203
|
||||
};
|
||||
|
||||
static const Transform kTransforms[] = {
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_EMPTY },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_SP },
|
||||
{ kPFix_SP, kIdentity, kPFix_SP },
|
||||
{ kPFix_EMPTY, kOmitFirst1, kPFix_EMPTY },
|
||||
{ kPFix_EMPTY, kUppercaseFirst, kPFix_SP },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_SPtheSP },
|
||||
{ kPFix_SP, kIdentity, kPFix_EMPTY },
|
||||
{ kPFix_sSP, kIdentity, kPFix_SP },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_SPofSP },
|
||||
{ kPFix_EMPTY, kUppercaseFirst, kPFix_EMPTY },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_SPandSP },
|
||||
{ kPFix_EMPTY, kOmitFirst2, kPFix_EMPTY },
|
||||
{ kPFix_EMPTY, kOmitLast1, kPFix_EMPTY },
|
||||
{ kPFix_COMMASP, kIdentity, kPFix_SP },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_COMMASP },
|
||||
{ kPFix_SP, kUppercaseFirst, kPFix_SP },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_SPinSP },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_SPtoSP },
|
||||
{ kPFix_eSP, kIdentity, kPFix_SP },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_DQUOT },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_DOT },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_DQUOTGT },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_NEWLINE },
|
||||
{ kPFix_EMPTY, kOmitLast3, kPFix_EMPTY },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_CLOSEBR },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_SPforSP },
|
||||
{ kPFix_EMPTY, kOmitFirst3, kPFix_EMPTY },
|
||||
{ kPFix_EMPTY, kOmitLast2, kPFix_EMPTY },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_SPaSP },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_SPthatSP },
|
||||
{ kPFix_SP, kUppercaseFirst, kPFix_EMPTY },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_DOTSP },
|
||||
{ kPFix_DOT, kIdentity, kPFix_EMPTY },
|
||||
{ kPFix_SP, kIdentity, kPFix_COMMASP },
|
||||
{ kPFix_EMPTY, kOmitFirst4, kPFix_EMPTY },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_SPwithSP },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_SQUOT },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_SPfromSP },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_SPbySP },
|
||||
{ kPFix_EMPTY, kOmitFirst5, kPFix_EMPTY },
|
||||
{ kPFix_EMPTY, kOmitFirst6, kPFix_EMPTY },
|
||||
{ kPFix_SPtheSP, kIdentity, kPFix_EMPTY },
|
||||
{ kPFix_EMPTY, kOmitLast4, kPFix_EMPTY },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_DOTSPTheSP },
|
||||
{ kPFix_EMPTY, kUppercaseAll, kPFix_EMPTY },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_SPonSP },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_SPasSP },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_SPisSP },
|
||||
{ kPFix_EMPTY, kOmitLast7, kPFix_EMPTY },
|
||||
{ kPFix_EMPTY, kOmitLast1, kPFix_ingSP },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_NEWLINETAB },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_COLON },
|
||||
{ kPFix_SP, kIdentity, kPFix_DOTSP },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_edSP },
|
||||
{ kPFix_EMPTY, kOmitFirst9, kPFix_EMPTY },
|
||||
{ kPFix_EMPTY, kOmitFirst7, kPFix_EMPTY },
|
||||
{ kPFix_EMPTY, kOmitLast6, kPFix_EMPTY },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_OPEN },
|
||||
{ kPFix_EMPTY, kUppercaseFirst, kPFix_COMMASP },
|
||||
{ kPFix_EMPTY, kOmitLast8, kPFix_EMPTY },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_SPatSP },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_lySP },
|
||||
{ kPFix_SPtheSP, kIdentity, kPFix_SPofSP },
|
||||
{ kPFix_EMPTY, kOmitLast5, kPFix_EMPTY },
|
||||
{ kPFix_EMPTY, kOmitLast9, kPFix_EMPTY },
|
||||
{ kPFix_SP, kUppercaseFirst, kPFix_COMMASP },
|
||||
{ kPFix_EMPTY, kUppercaseFirst, kPFix_DQUOT },
|
||||
{ kPFix_DOT, kIdentity, kPFix_OPEN },
|
||||
{ kPFix_EMPTY, kUppercaseAll, kPFix_SP },
|
||||
{ kPFix_EMPTY, kUppercaseFirst, kPFix_DQUOTGT },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_EQDQUOT },
|
||||
{ kPFix_SP, kIdentity, kPFix_DOT },
|
||||
{ kPFix_DOTcomSLASH, kIdentity, kPFix_EMPTY },
|
||||
{ kPFix_SPtheSP, kIdentity, kPFix_SPofSPtheSP },
|
||||
{ kPFix_EMPTY, kUppercaseFirst, kPFix_SQUOT },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_DOTSPThisSP },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_COMMA },
|
||||
{ kPFix_DOT, kIdentity, kPFix_SP },
|
||||
{ kPFix_EMPTY, kUppercaseFirst, kPFix_OPEN },
|
||||
{ kPFix_EMPTY, kUppercaseFirst, kPFix_DOT },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_SPnotSP },
|
||||
{ kPFix_SP, kIdentity, kPFix_EQDQUOT },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_erSP },
|
||||
{ kPFix_SP, kUppercaseAll, kPFix_SP },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_alSP },
|
||||
{ kPFix_SP, kUppercaseAll, kPFix_EMPTY },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_EQSQUOT },
|
||||
{ kPFix_EMPTY, kUppercaseAll, kPFix_DQUOT },
|
||||
{ kPFix_EMPTY, kUppercaseFirst, kPFix_DOTSP },
|
||||
{ kPFix_SP, kIdentity, kPFix_OPEN },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_fulSP },
|
||||
{ kPFix_SP, kUppercaseFirst, kPFix_DOTSP },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_iveSP },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_lessSP },
|
||||
{ kPFix_EMPTY, kUppercaseAll, kPFix_SQUOT },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_estSP },
|
||||
{ kPFix_SP, kUppercaseFirst, kPFix_DOT },
|
||||
{ kPFix_EMPTY, kUppercaseAll, kPFix_DQUOTGT },
|
||||
{ kPFix_SP, kIdentity, kPFix_EQSQUOT },
|
||||
{ kPFix_EMPTY, kUppercaseFirst, kPFix_COMMA },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_izeSP },
|
||||
{ kPFix_EMPTY, kUppercaseAll, kPFix_DOT },
|
||||
{ kPFix_NBSP, kIdentity, kPFix_EMPTY },
|
||||
{ kPFix_SP, kIdentity, kPFix_COMMA },
|
||||
{ kPFix_EMPTY, kUppercaseFirst, kPFix_EQDQUOT },
|
||||
{ kPFix_EMPTY, kUppercaseAll, kPFix_EQDQUOT },
|
||||
{ kPFix_EMPTY, kIdentity, kPFix_ousSP },
|
||||
{ kPFix_EMPTY, kUppercaseAll, kPFix_COMMASP },
|
||||
{ kPFix_EMPTY, kUppercaseFirst, kPFix_EQSQUOT },
|
||||
{ kPFix_SP, kUppercaseFirst, kPFix_COMMA },
|
||||
{ kPFix_SP, kUppercaseAll, kPFix_EQDQUOT },
|
||||
{ kPFix_SP, kUppercaseAll, kPFix_COMMASP },
|
||||
{ kPFix_EMPTY, kUppercaseAll, kPFix_COMMA },
|
||||
{ kPFix_EMPTY, kUppercaseAll, kPFix_OPEN },
|
||||
{ kPFix_EMPTY, kUppercaseAll, kPFix_DOTSP },
|
||||
{ kPFix_SP, kUppercaseAll, kPFix_DOT },
|
||||
{ kPFix_EMPTY, kUppercaseAll, kPFix_EQSQUOT },
|
||||
{ kPFix_SP, kUppercaseAll, kPFix_DOTSP },
|
||||
{ kPFix_SP, kUppercaseFirst, kPFix_EQDQUOT },
|
||||
{ kPFix_SP, kUppercaseAll, kPFix_EQSQUOT },
|
||||
{ kPFix_SP, kUppercaseFirst, kPFix_EQSQUOT },
|
||||
};
|
||||
|
||||
static const int kNumTransforms = sizeof(kTransforms) / sizeof(kTransforms[0]);
|
||||
|
||||
static int ToUpperCase(uint8_t* p) {
|
||||
if (p[0] < 0xc0) {
|
||||
if (p[0] >= 'a' && p[0] <= 'z') {
|
||||
p[0] ^= 32;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
/* An overly simplified uppercasing model for utf-8. */
|
||||
if (p[0] < 0xe0) {
|
||||
p[1] ^= 32;
|
||||
return 2;
|
||||
}
|
||||
/* An arbitrary transform for three byte characters. */
|
||||
p[2] ^= 5;
|
||||
return 3;
|
||||
}
|
||||
|
||||
static BROTLI_NOINLINE int TransformDictionaryWord(
|
||||
uint8_t* dst, const uint8_t* word, int len, int transform) {
|
||||
int idx = 0;
|
||||
{
|
||||
const char* prefix = &kPrefixSuffix[kTransforms[transform].prefix_id];
|
||||
while (*prefix) { dst[idx++] = (uint8_t)*prefix++; }
|
||||
}
|
||||
{
|
||||
const int t = kTransforms[transform].transform;
|
||||
int i = 0;
|
||||
int skip = t - (kOmitFirst1 - 1);
|
||||
if (skip > 0) {
|
||||
word += skip;
|
||||
len -= skip;
|
||||
} else if (t <= kOmitLast9) {
|
||||
len -= t;
|
||||
}
|
||||
while (i < len) { dst[idx++] = word[i++]; }
|
||||
if (t == kUppercaseFirst) {
|
||||
ToUpperCase(&dst[idx - len]);
|
||||
} else if (t == kUppercaseAll) {
|
||||
uint8_t* uppercase = &dst[idx - len];
|
||||
while (len > 0) {
|
||||
int step = ToUpperCase(uppercase);
|
||||
uppercase += step;
|
||||
len -= step;
|
||||
}
|
||||
}
|
||||
}
|
||||
{
|
||||
const char* suffix = &kPrefixSuffix[kTransforms[transform].suffix_id];
|
||||
while (*suffix) { dst[idx++] = (uint8_t)*suffix++; }
|
||||
return idx;
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(__cplusplus) || defined(c_plusplus)
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* BROTLI_DEC_TRANSFORM_H_ */
|
||||
38
modules/brotli/dec/types.h
Normal file
38
modules/brotli/dec/types.h
Normal file
|
|
@ -0,0 +1,38 @@
|
|||
/* Copyright 2013 Google Inc. All Rights Reserved.
|
||||
|
||||
Distributed under MIT license.
|
||||
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
/* Common types */
|
||||
|
||||
#ifndef BROTLI_DEC_TYPES_H_
|
||||
#define BROTLI_DEC_TYPES_H_
|
||||
|
||||
#include <stddef.h> /* for size_t */
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER < 1600)
|
||||
typedef __int8 int8_t;
|
||||
typedef unsigned __int8 uint8_t;
|
||||
typedef __int16 int16_t;
|
||||
typedef unsigned __int16 uint16_t;
|
||||
typedef __int32 int32_t;
|
||||
typedef unsigned __int32 uint32_t;
|
||||
typedef unsigned __int64 uint64_t;
|
||||
typedef __int64 int64_t;
|
||||
#else
|
||||
#include <stdint.h>
|
||||
#endif /* defined(_MSC_VER) && (_MSC_VER < 1600) */
|
||||
|
||||
/* Allocating function pointer. Function MUST return 0 in the case of failure.
|
||||
Otherwise it MUST return a valid pointer to a memory region of at least
|
||||
size length. Neither items nor size are allowed to be 0.
|
||||
opaque argument is a pointer provided by client and could be used to bind
|
||||
function to specific object (memory pool). */
|
||||
typedef void* (*brotli_alloc_func)(void* opaque, size_t size);
|
||||
|
||||
/* Deallocating function pointer. Function SHOULD be no-op in the case the
|
||||
address is 0. */
|
||||
typedef void (*brotli_free_func)(void* opaque, void* address);
|
||||
|
||||
#endif /* BROTLI_DEC_TYPES_H_ */
|
||||
29
modules/brotli/moz.build
Normal file
29
modules/brotli/moz.build
Normal file
|
|
@ -0,0 +1,29 @@
|
|||
# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
|
||||
# vim: set filetype=python:
|
||||
# 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/.
|
||||
|
||||
EXPORTS += [
|
||||
'dec/bit_reader.h',
|
||||
'dec/decode.h',
|
||||
'dec/huffman.h',
|
||||
'dec/port.h',
|
||||
'dec/state.h',
|
||||
'dec/types.h',
|
||||
]
|
||||
|
||||
UNIFIED_SOURCES += [
|
||||
'dec/bit_reader.c',
|
||||
'dec/decode.c',
|
||||
'dec/dictionary.c',
|
||||
'dec/huffman.c',
|
||||
'dec/state.c',
|
||||
]
|
||||
|
||||
# We allow warnings for third-party code that can be updated from upstream.
|
||||
ALLOW_COMPILER_WARNINGS = True
|
||||
|
||||
CFLAGS += ['-DBROTLI_BUILD_PORTABLE']
|
||||
|
||||
Library('brotli')
|
||||
21
modules/brotli/update.sh
Normal file
21
modules/brotli/update.sh
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
#!/bin/sh
|
||||
|
||||
# Script to update the mozilla in-tree copy of the Brotli decompressor.
|
||||
# Run this within the /modules/brotli directory of the source tree.
|
||||
|
||||
MY_TEMP_DIR=`mktemp -d -t brotli_update.XXXXXX` || exit 1
|
||||
|
||||
git clone https://github.com/google/brotli ${MY_TEMP_DIR}/brotli
|
||||
|
||||
COMMIT=`(cd ${MY_TEMP_DIR}/brotli && git log | head -n 1)`
|
||||
perl -p -i -e "s/\[commit [0-9a-f]{40}\]/[${COMMIT}]/" README.mozilla;
|
||||
|
||||
rm -rf dec
|
||||
mv ${MY_TEMP_DIR}/brotli/dec dec
|
||||
rm -rf ${MY_TEMP_DIR}
|
||||
hg add dec
|
||||
|
||||
echo "###"
|
||||
echo "### Updated brotli/dec to $COMMIT."
|
||||
echo "### Remember to verify and commit the changes to source control!"
|
||||
echo "###"
|
||||
17
modules/fdlibm/README.mozilla
Normal file
17
modules/fdlibm/README.mozilla
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
This is the fdlibm library imported from
|
||||
https://github.com/freebsd/freebsd
|
||||
|
||||
Upstream code can be viewed at
|
||||
https://github.com/freebsd/freebsd/tree/master/lib/msun/src
|
||||
|
||||
Each file is downloaded separately, as cloning whole repository takes so much
|
||||
resources.
|
||||
|
||||
The in-tree copy is updated by running
|
||||
sh update.sh
|
||||
from within the modules/fdlibm directory.
|
||||
|
||||
Current version: [commit f2287da07ac7a26ac08745cac66eec82ab9ba384].
|
||||
|
||||
patches 01-14 fixes files to be usable within mozilla-central tree.
|
||||
See https://bugzilla.mozilla.org/show_bug.cgi?id=933257
|
||||
112
modules/fdlibm/import.sh
Normal file
112
modules/fdlibm/import.sh
Normal file
|
|
@ -0,0 +1,112 @@
|
|||
#!/bin/sh
|
||||
|
||||
set -e
|
||||
|
||||
BASE_URL=https://raw.githubusercontent.com/freebsd/freebsd/master/lib/msun/src
|
||||
|
||||
download_source() {
|
||||
REMOTE_FILENAME=$1
|
||||
LOCAL_FILENAME=$2
|
||||
while true; do
|
||||
curl -o "src/${LOCAL_FILENAME}" "${BASE_URL}/${REMOTE_FILENAME}" && break
|
||||
done
|
||||
}
|
||||
|
||||
mkdir -p src
|
||||
|
||||
# headers
|
||||
download_source math.h fdlibm.h
|
||||
download_source math_private.h math_private.h
|
||||
|
||||
# Math.acos
|
||||
download_source e_acos.c e_acos.cpp
|
||||
|
||||
# Math.acosh
|
||||
download_source e_acosh.c e_acosh.cpp
|
||||
|
||||
# Math.asin
|
||||
download_source e_asin.c e_asin.cpp
|
||||
|
||||
# Math.asinh
|
||||
download_source s_asinh.c s_asinh.cpp
|
||||
|
||||
# Math.atan
|
||||
download_source s_atan.c s_atan.cpp
|
||||
|
||||
# Math.atanh
|
||||
download_source e_atanh.c e_atanh.cpp
|
||||
|
||||
# Math.atan2
|
||||
download_source e_atan2.c e_atan2.cpp
|
||||
|
||||
# Math.cbrt
|
||||
download_source s_cbrt.c s_cbrt.cpp
|
||||
|
||||
# Math.ceil
|
||||
download_source s_ceil.c s_ceil.cpp
|
||||
download_source s_ceilf.c s_ceilf.cpp
|
||||
|
||||
# Math.cos (not used due to poor performance)
|
||||
|
||||
# Math.cosh
|
||||
download_source e_cosh.c e_cosh.cpp
|
||||
|
||||
# Math.exp
|
||||
download_source e_exp.c e_exp.cpp
|
||||
|
||||
# Math.expm1
|
||||
download_source s_expm1.c s_expm1.cpp
|
||||
|
||||
# Math.floor and Math.round
|
||||
download_source s_floor.c s_floor.cpp
|
||||
|
||||
# Math.fround
|
||||
download_source s_floorf.c s_floorf.cpp
|
||||
|
||||
# Math.hypot
|
||||
download_source e_hypot.c e_hypot.cpp
|
||||
|
||||
# Math.log
|
||||
download_source e_log.c e_log.cpp
|
||||
|
||||
# Math.log1p
|
||||
download_source s_log1p.c s_log1p.cpp
|
||||
|
||||
# Math.log10
|
||||
download_source e_log10.c e_log10.cpp
|
||||
download_source k_log.h k_log.h
|
||||
|
||||
# Math.log2
|
||||
download_source e_log2.c e_log2.cpp
|
||||
|
||||
# Math.pow (not used due to poor performance)
|
||||
|
||||
# Math.sin (not used due to poor performance)
|
||||
|
||||
# Math.sinh
|
||||
download_source e_sinh.c e_sinh.cpp
|
||||
|
||||
# Math.sqrt (not used due to poor performance)
|
||||
|
||||
# Math.tan (not used due to poor performance)
|
||||
|
||||
# Math.tanh
|
||||
download_source s_tanh.c s_tanh.cpp
|
||||
|
||||
# Math.trunc
|
||||
download_source s_trunc.c s_trunc.cpp
|
||||
download_source s_truncf.c s_truncf.cpp
|
||||
|
||||
# dependencies
|
||||
download_source k_exp.c k_exp.cpp
|
||||
download_source s_copysign.c s_copysign.cpp
|
||||
download_source s_fabs.c s_fabs.cpp
|
||||
download_source s_scalbn.c s_scalbn.cpp
|
||||
|
||||
# These are not not used in Math.* functions, but used internally.
|
||||
download_source e_pow.c e_pow.cpp
|
||||
download_source e_sqrt.c e_sqrt.cpp
|
||||
|
||||
download_source s_nearbyint.c s_nearbyint.cpp
|
||||
download_source s_rint.c s_rint.cpp
|
||||
download_source s_rintf.c s_rintf.cpp
|
||||
7
modules/fdlibm/moz.build
Normal file
7
modules/fdlibm/moz.build
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
|
||||
# vim: set filetype=python:
|
||||
# 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/.
|
||||
|
||||
DIRS += ['src']
|
||||
|
|
@ -0,0 +1,504 @@
|
|||
diff --git a/modules/fdlibm/src/fdlibm.h b/modules/fdlibm/src/fdlibm.h
|
||||
--- a/modules/fdlibm/src/fdlibm.h
|
||||
+++ b/modules/fdlibm/src/fdlibm.h
|
||||
@@ -12,496 +12,50 @@
|
||||
/*
|
||||
* from: @(#)fdlibm.h 5.1 93/09/24
|
||||
* $FreeBSD$
|
||||
*/
|
||||
|
||||
#ifndef _MATH_H_
|
||||
#define _MATH_H_
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-#include <sys/_types.h>
|
||||
-#include <machine/_limits.h>
|
||||
-
|
||||
-/*
|
||||
- * ANSI/POSIX
|
||||
- */
|
||||
-extern const union __infinity_un {
|
||||
- unsigned char __uc[8];
|
||||
- double __ud;
|
||||
-} __infinity;
|
||||
-
|
||||
-extern const union __nan_un {
|
||||
- unsigned char __uc[sizeof(float)];
|
||||
- float __uf;
|
||||
-} __nan;
|
||||
-
|
||||
-#if __GNUC_PREREQ__(3, 3) || (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 800)
|
||||
-#define __MATH_BUILTIN_CONSTANTS
|
||||
-#endif
|
||||
-
|
||||
-#if __GNUC_PREREQ__(3, 0) && !defined(__INTEL_COMPILER)
|
||||
-#define __MATH_BUILTIN_RELOPS
|
||||
-#endif
|
||||
-
|
||||
-#ifdef __MATH_BUILTIN_CONSTANTS
|
||||
-#define HUGE_VAL __builtin_huge_val()
|
||||
-#else
|
||||
-#define HUGE_VAL (__infinity.__ud)
|
||||
-#endif
|
||||
-
|
||||
-#if __ISO_C_VISIBLE >= 1999
|
||||
-#define FP_ILOGB0 (-__INT_MAX)
|
||||
-#define FP_ILOGBNAN __INT_MAX
|
||||
-
|
||||
-#ifdef __MATH_BUILTIN_CONSTANTS
|
||||
-#define HUGE_VALF __builtin_huge_valf()
|
||||
-#define HUGE_VALL __builtin_huge_vall()
|
||||
-#define INFINITY __builtin_inff()
|
||||
-#define NAN __builtin_nanf("")
|
||||
-#else
|
||||
-#define HUGE_VALF (float)HUGE_VAL
|
||||
-#define HUGE_VALL (long double)HUGE_VAL
|
||||
-#define INFINITY HUGE_VALF
|
||||
-#define NAN (__nan.__uf)
|
||||
-#endif /* __MATH_BUILTIN_CONSTANTS */
|
||||
-
|
||||
-#define MATH_ERRNO 1
|
||||
-#define MATH_ERREXCEPT 2
|
||||
-#define math_errhandling MATH_ERREXCEPT
|
||||
-
|
||||
-#define FP_FAST_FMAF 1
|
||||
-
|
||||
-/* Symbolic constants to classify floating point numbers. */
|
||||
-#define FP_INFINITE 0x01
|
||||
-#define FP_NAN 0x02
|
||||
-#define FP_NORMAL 0x04
|
||||
-#define FP_SUBNORMAL 0x08
|
||||
-#define FP_ZERO 0x10
|
||||
-
|
||||
-#if (__STDC_VERSION__ >= 201112L && defined(__clang__)) || \
|
||||
- __has_extension(c_generic_selections)
|
||||
-#define __fp_type_select(x, f, d, ld) _Generic((x), \
|
||||
- float: f(x), \
|
||||
- double: d(x), \
|
||||
- long double: ld(x), \
|
||||
- volatile float: f(x), \
|
||||
- volatile double: d(x), \
|
||||
- volatile long double: ld(x), \
|
||||
- volatile const float: f(x), \
|
||||
- volatile const double: d(x), \
|
||||
- volatile const long double: ld(x), \
|
||||
- const float: f(x), \
|
||||
- const double: d(x), \
|
||||
- const long double: ld(x))
|
||||
-#elif __GNUC_PREREQ__(3, 1) && !defined(__cplusplus)
|
||||
-#define __fp_type_select(x, f, d, ld) __builtin_choose_expr( \
|
||||
- __builtin_types_compatible_p(__typeof(x), long double), ld(x), \
|
||||
- __builtin_choose_expr( \
|
||||
- __builtin_types_compatible_p(__typeof(x), double), d(x), \
|
||||
- __builtin_choose_expr( \
|
||||
- __builtin_types_compatible_p(__typeof(x), float), f(x), (void)0)))
|
||||
-#else
|
||||
-#define __fp_type_select(x, f, d, ld) \
|
||||
- ((sizeof(x) == sizeof(float)) ? f(x) \
|
||||
- : (sizeof(x) == sizeof(double)) ? d(x) \
|
||||
- : ld(x))
|
||||
-#endif
|
||||
-
|
||||
-#define fpclassify(x) \
|
||||
- __fp_type_select(x, __fpclassifyf, __fpclassifyd, __fpclassifyl)
|
||||
-#define isfinite(x) __fp_type_select(x, __isfinitef, __isfinite, __isfinitel)
|
||||
-#define isinf(x) __fp_type_select(x, __isinff, __isinf, __isinfl)
|
||||
-#define isnan(x) \
|
||||
- __fp_type_select(x, __inline_isnanf, __inline_isnan, __inline_isnanl)
|
||||
-#define isnormal(x) __fp_type_select(x, __isnormalf, __isnormal, __isnormall)
|
||||
-
|
||||
-#ifdef __MATH_BUILTIN_RELOPS
|
||||
-#define isgreater(x, y) __builtin_isgreater((x), (y))
|
||||
-#define isgreaterequal(x, y) __builtin_isgreaterequal((x), (y))
|
||||
-#define isless(x, y) __builtin_isless((x), (y))
|
||||
-#define islessequal(x, y) __builtin_islessequal((x), (y))
|
||||
-#define islessgreater(x, y) __builtin_islessgreater((x), (y))
|
||||
-#define isunordered(x, y) __builtin_isunordered((x), (y))
|
||||
-#else
|
||||
-#define isgreater(x, y) (!isunordered((x), (y)) && (x) > (y))
|
||||
-#define isgreaterequal(x, y) (!isunordered((x), (y)) && (x) >= (y))
|
||||
-#define isless(x, y) (!isunordered((x), (y)) && (x) < (y))
|
||||
-#define islessequal(x, y) (!isunordered((x), (y)) && (x) <= (y))
|
||||
-#define islessgreater(x, y) (!isunordered((x), (y)) && \
|
||||
- ((x) > (y) || (y) > (x)))
|
||||
-#define isunordered(x, y) (isnan(x) || isnan(y))
|
||||
-#endif /* __MATH_BUILTIN_RELOPS */
|
||||
-
|
||||
-#define signbit(x) __fp_type_select(x, __signbitf, __signbit, __signbitl)
|
||||
-
|
||||
-typedef __double_t double_t;
|
||||
-typedef __float_t float_t;
|
||||
-#endif /* __ISO_C_VISIBLE >= 1999 */
|
||||
-
|
||||
-/*
|
||||
- * XOPEN/SVID
|
||||
- */
|
||||
-#if __BSD_VISIBLE || __XSI_VISIBLE
|
||||
-#define M_E 2.7182818284590452354 /* e */
|
||||
-#define M_LOG2E 1.4426950408889634074 /* log 2e */
|
||||
-#define M_LOG10E 0.43429448190325182765 /* log 10e */
|
||||
-#define M_LN2 0.69314718055994530942 /* log e2 */
|
||||
-#define M_LN10 2.30258509299404568402 /* log e10 */
|
||||
-#define M_PI 3.14159265358979323846 /* pi */
|
||||
-#define M_PI_2 1.57079632679489661923 /* pi/2 */
|
||||
-#define M_PI_4 0.78539816339744830962 /* pi/4 */
|
||||
-#define M_1_PI 0.31830988618379067154 /* 1/pi */
|
||||
-#define M_2_PI 0.63661977236758134308 /* 2/pi */
|
||||
-#define M_2_SQRTPI 1.12837916709551257390 /* 2/sqrt(pi) */
|
||||
-#define M_SQRT2 1.41421356237309504880 /* sqrt(2) */
|
||||
-#define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */
|
||||
-
|
||||
-#define MAXFLOAT ((float)3.40282346638528860e+38)
|
||||
-extern int signgam;
|
||||
-#endif /* __BSD_VISIBLE || __XSI_VISIBLE */
|
||||
-
|
||||
-#if __BSD_VISIBLE
|
||||
-#if 0
|
||||
-/* Old value from 4.4BSD-Lite math.h; this is probably better. */
|
||||
-#define HUGE HUGE_VAL
|
||||
-#else
|
||||
-#define HUGE MAXFLOAT
|
||||
-#endif
|
||||
-#endif /* __BSD_VISIBLE */
|
||||
-
|
||||
-/*
|
||||
- * Most of these functions depend on the rounding mode and have the side
|
||||
- * effect of raising floating-point exceptions, so they are not declared
|
||||
- * as __pure2. In C99, FENV_ACCESS affects the purity of these functions.
|
||||
- */
|
||||
-__BEGIN_DECLS
|
||||
-/*
|
||||
- * ANSI/POSIX
|
||||
- */
|
||||
-int __fpclassifyd(double) __pure2;
|
||||
-int __fpclassifyf(float) __pure2;
|
||||
-int __fpclassifyl(long double) __pure2;
|
||||
-int __isfinitef(float) __pure2;
|
||||
-int __isfinite(double) __pure2;
|
||||
-int __isfinitel(long double) __pure2;
|
||||
-int __isinff(float) __pure2;
|
||||
-int __isinf(double) __pure2;
|
||||
-int __isinfl(long double) __pure2;
|
||||
-int __isnormalf(float) __pure2;
|
||||
-int __isnormal(double) __pure2;
|
||||
-int __isnormall(long double) __pure2;
|
||||
-int __signbit(double) __pure2;
|
||||
-int __signbitf(float) __pure2;
|
||||
-int __signbitl(long double) __pure2;
|
||||
-
|
||||
-static __inline int
|
||||
-__inline_isnan(__const double __x)
|
||||
-{
|
||||
-
|
||||
- return (__x != __x);
|
||||
-}
|
||||
-
|
||||
-static __inline int
|
||||
-__inline_isnanf(__const float __x)
|
||||
-{
|
||||
-
|
||||
- return (__x != __x);
|
||||
-}
|
||||
-
|
||||
-static __inline int
|
||||
-__inline_isnanl(__const long double __x)
|
||||
-{
|
||||
-
|
||||
- return (__x != __x);
|
||||
-}
|
||||
-
|
||||
-/*
|
||||
- * Version 2 of the Single UNIX Specification (UNIX98) defined isnan() and
|
||||
- * isinf() as functions taking double. C99, and the subsequent POSIX revisions
|
||||
- * (SUSv3, POSIX.1-2001, define it as a macro that accepts any real floating
|
||||
- * point type. If we are targeting SUSv2 and C99 or C11 (or C++11) then we
|
||||
- * expose the newer definition, assuming that the language spec takes
|
||||
- * precedence over the operating system interface spec.
|
||||
- */
|
||||
-#if __XSI_VISIBLE > 0 && __XSI_VISIBLE < 600 && __ISO_C_VISIBLE < 1999
|
||||
-#undef isinf
|
||||
-#undef isnan
|
||||
-int isinf(double);
|
||||
-int isnan(double);
|
||||
-#endif
|
||||
-
|
||||
double acos(double);
|
||||
double asin(double);
|
||||
double atan(double);
|
||||
double atan2(double, double);
|
||||
-double cos(double);
|
||||
-double sin(double);
|
||||
-double tan(double);
|
||||
|
||||
double cosh(double);
|
||||
double sinh(double);
|
||||
double tanh(double);
|
||||
|
||||
double exp(double);
|
||||
-double frexp(double, int *); /* fundamentally !__pure2 */
|
||||
-double ldexp(double, int);
|
||||
double log(double);
|
||||
double log10(double);
|
||||
-double modf(double, double *); /* fundamentally !__pure2 */
|
||||
|
||||
double pow(double, double);
|
||||
double sqrt(double);
|
||||
+double fabs(double);
|
||||
|
||||
+double floor(double);
|
||||
+double trunc(double);
|
||||
double ceil(double);
|
||||
-double fabs(double) __pure2;
|
||||
-double floor(double);
|
||||
-double fmod(double, double);
|
||||
|
||||
-/*
|
||||
- * These functions are not in C90.
|
||||
- */
|
||||
-#if __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999 || __XSI_VISIBLE
|
||||
double acosh(double);
|
||||
double asinh(double);
|
||||
double atanh(double);
|
||||
double cbrt(double);
|
||||
-double erf(double);
|
||||
-double erfc(double);
|
||||
-double exp2(double);
|
||||
double expm1(double);
|
||||
-double fma(double, double, double);
|
||||
double hypot(double, double);
|
||||
-int ilogb(double) __pure2;
|
||||
-double lgamma(double);
|
||||
-long long llrint(double);
|
||||
-long long llround(double);
|
||||
double log1p(double);
|
||||
double log2(double);
|
||||
-double logb(double);
|
||||
-long lrint(double);
|
||||
-long lround(double);
|
||||
-double nan(const char *) __pure2;
|
||||
-double nextafter(double, double);
|
||||
-double remainder(double, double);
|
||||
-double remquo(double, double, int *);
|
||||
double rint(double);
|
||||
-#endif /* __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999 || __XSI_VISIBLE */
|
||||
-
|
||||
-#if __BSD_VISIBLE || __XSI_VISIBLE
|
||||
-double j0(double);
|
||||
-double j1(double);
|
||||
-double jn(int, double);
|
||||
-double y0(double);
|
||||
-double y1(double);
|
||||
-double yn(int, double);
|
||||
-
|
||||
-#if __XSI_VISIBLE <= 500 || __BSD_VISIBLE
|
||||
-double gamma(double);
|
||||
-#endif
|
||||
-
|
||||
-#if __XSI_VISIBLE <= 600 || __BSD_VISIBLE
|
||||
-double scalb(double, double);
|
||||
-#endif
|
||||
-#endif /* __BSD_VISIBLE || __XSI_VISIBLE */
|
||||
-
|
||||
-#if __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999
|
||||
-double copysign(double, double) __pure2;
|
||||
-double fdim(double, double);
|
||||
-double fmax(double, double) __pure2;
|
||||
-double fmin(double, double) __pure2;
|
||||
+double copysign(double, double);
|
||||
double nearbyint(double);
|
||||
-double round(double);
|
||||
-double scalbln(double, long);
|
||||
double scalbn(double, int);
|
||||
-double tgamma(double);
|
||||
-double trunc(double);
|
||||
-#endif
|
||||
-
|
||||
-/*
|
||||
- * BSD math library entry points
|
||||
- */
|
||||
-#if __BSD_VISIBLE
|
||||
-double drem(double, double);
|
||||
-int finite(double) __pure2;
|
||||
-int isnanf(float) __pure2;
|
||||
-
|
||||
-/*
|
||||
- * Reentrant version of gamma & lgamma; passes signgam back by reference
|
||||
- * as the second argument; user must allocate space for signgam.
|
||||
- */
|
||||
-double gamma_r(double, int *);
|
||||
-double lgamma_r(double, int *);
|
||||
-
|
||||
-/*
|
||||
- * IEEE Test Vector
|
||||
- */
|
||||
-double significand(double);
|
||||
-#endif /* __BSD_VISIBLE */
|
||||
-
|
||||
-/* float versions of ANSI/POSIX functions */
|
||||
-#if __ISO_C_VISIBLE >= 1999
|
||||
-float acosf(float);
|
||||
-float asinf(float);
|
||||
-float atanf(float);
|
||||
-float atan2f(float, float);
|
||||
-float cosf(float);
|
||||
-float sinf(float);
|
||||
-float tanf(float);
|
||||
-
|
||||
-float coshf(float);
|
||||
-float sinhf(float);
|
||||
-float tanhf(float);
|
||||
-
|
||||
-float exp2f(float);
|
||||
-float expf(float);
|
||||
-float expm1f(float);
|
||||
-float frexpf(float, int *); /* fundamentally !__pure2 */
|
||||
-int ilogbf(float) __pure2;
|
||||
-float ldexpf(float, int);
|
||||
-float log10f(float);
|
||||
-float log1pf(float);
|
||||
-float log2f(float);
|
||||
-float logf(float);
|
||||
-float modff(float, float *); /* fundamentally !__pure2 */
|
||||
-
|
||||
-float powf(float, float);
|
||||
-float sqrtf(float);
|
||||
|
||||
float ceilf(float);
|
||||
-float fabsf(float) __pure2;
|
||||
float floorf(float);
|
||||
-float fmodf(float, float);
|
||||
-float roundf(float);
|
||||
|
||||
-float erff(float);
|
||||
-float erfcf(float);
|
||||
-float hypotf(float, float);
|
||||
-float lgammaf(float);
|
||||
-float tgammaf(float);
|
||||
-
|
||||
-float acoshf(float);
|
||||
-float asinhf(float);
|
||||
-float atanhf(float);
|
||||
-float cbrtf(float);
|
||||
-float logbf(float);
|
||||
-float copysignf(float, float) __pure2;
|
||||
-long long llrintf(float);
|
||||
-long long llroundf(float);
|
||||
-long lrintf(float);
|
||||
-long lroundf(float);
|
||||
-float nanf(const char *) __pure2;
|
||||
float nearbyintf(float);
|
||||
-float nextafterf(float, float);
|
||||
-float remainderf(float, float);
|
||||
-float remquof(float, float, int *);
|
||||
float rintf(float);
|
||||
-float scalblnf(float, long);
|
||||
-float scalbnf(float, int);
|
||||
float truncf(float);
|
||||
|
||||
-float fdimf(float, float);
|
||||
-float fmaf(float, float, float);
|
||||
-float fmaxf(float, float) __pure2;
|
||||
-float fminf(float, float) __pure2;
|
||||
-#endif
|
||||
-
|
||||
-/*
|
||||
- * float versions of BSD math library entry points
|
||||
- */
|
||||
-#if __BSD_VISIBLE
|
||||
-float dremf(float, float);
|
||||
-int finitef(float) __pure2;
|
||||
-float gammaf(float);
|
||||
-float j0f(float);
|
||||
-float j1f(float);
|
||||
-float jnf(int, float);
|
||||
-float scalbf(float, float);
|
||||
-float y0f(float);
|
||||
-float y1f(float);
|
||||
-float ynf(int, float);
|
||||
-
|
||||
-/*
|
||||
- * Float versions of reentrant version of gamma & lgamma; passes
|
||||
- * signgam back by reference as the second argument; user must
|
||||
- * allocate space for signgam.
|
||||
- */
|
||||
-float gammaf_r(float, int *);
|
||||
-float lgammaf_r(float, int *);
|
||||
-
|
||||
-/*
|
||||
- * float version of IEEE Test Vector
|
||||
- */
|
||||
-float significandf(float);
|
||||
-#endif /* __BSD_VISIBLE */
|
||||
-
|
||||
-/*
|
||||
- * long double versions of ISO/POSIX math functions
|
||||
- */
|
||||
-#if __ISO_C_VISIBLE >= 1999
|
||||
-long double acoshl(long double);
|
||||
-long double acosl(long double);
|
||||
-long double asinhl(long double);
|
||||
-long double asinl(long double);
|
||||
-long double atan2l(long double, long double);
|
||||
-long double atanhl(long double);
|
||||
-long double atanl(long double);
|
||||
-long double cbrtl(long double);
|
||||
-long double ceill(long double);
|
||||
-long double copysignl(long double, long double) __pure2;
|
||||
-long double coshl(long double);
|
||||
-long double cosl(long double);
|
||||
-long double erfcl(long double);
|
||||
-long double erfl(long double);
|
||||
-long double exp2l(long double);
|
||||
-long double expl(long double);
|
||||
-long double expm1l(long double);
|
||||
-long double fabsl(long double) __pure2;
|
||||
-long double fdiml(long double, long double);
|
||||
-long double floorl(long double);
|
||||
-long double fmal(long double, long double, long double);
|
||||
-long double fmaxl(long double, long double) __pure2;
|
||||
-long double fminl(long double, long double) __pure2;
|
||||
-long double fmodl(long double, long double);
|
||||
-long double frexpl(long double, int *); /* fundamentally !__pure2 */
|
||||
-long double hypotl(long double, long double);
|
||||
-int ilogbl(long double) __pure2;
|
||||
-long double ldexpl(long double, int);
|
||||
-long double lgammal(long double);
|
||||
-long long llrintl(long double);
|
||||
-long long llroundl(long double);
|
||||
-long double log10l(long double);
|
||||
-long double log1pl(long double);
|
||||
-long double log2l(long double);
|
||||
-long double logbl(long double);
|
||||
-long double logl(long double);
|
||||
-long lrintl(long double);
|
||||
-long lroundl(long double);
|
||||
-long double modfl(long double, long double *); /* fundamentally !__pure2 */
|
||||
-long double nanl(const char *) __pure2;
|
||||
-long double nearbyintl(long double);
|
||||
-long double nextafterl(long double, long double);
|
||||
-double nexttoward(double, long double);
|
||||
-float nexttowardf(float, long double);
|
||||
-long double nexttowardl(long double, long double);
|
||||
-long double powl(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 scalblnl(long double, long);
|
||||
-long double scalbnl(long double, int);
|
||||
-long double sinhl(long double);
|
||||
-long double sinl(long double);
|
||||
-long double sqrtl(long double);
|
||||
-long double tanhl(long double);
|
||||
-long double tanl(long double);
|
||||
-long double tgammal(long double);
|
||||
-long double truncl(long double);
|
||||
-#endif /* __ISO_C_VISIBLE >= 1999 */
|
||||
-
|
||||
-#if __BSD_VISIBLE
|
||||
-long double lgammal_r(long double, int *);
|
||||
-#endif
|
||||
-
|
||||
-__END_DECLS
|
||||
-
|
||||
#endif /* !_MATH_H_ */
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
diff --git a/modules/fdlibm/src/fdlibm.h b/modules/fdlibm/src/fdlibm.h
|
||||
--- a/modules/fdlibm/src/fdlibm.h
|
||||
+++ b/modules/fdlibm/src/fdlibm.h
|
||||
@@ -9,18 +9,18 @@
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
/*
|
||||
* from: @(#)fdlibm.h 5.1 93/09/24
|
||||
* $FreeBSD$
|
||||
*/
|
||||
|
||||
-#ifndef _MATH_H_
|
||||
-#define _MATH_H_
|
||||
+#ifndef mozilla_imported_fdlibm_h
|
||||
+#define mozilla_imported_fdlibm_h
|
||||
|
||||
double acos(double);
|
||||
double asin(double);
|
||||
double atan(double);
|
||||
double atan2(double, double);
|
||||
|
||||
double cosh(double);
|
||||
double sinh(double);
|
||||
@@ -53,9 +53,9 @@ double scalbn(double, int);
|
||||
|
||||
float ceilf(float);
|
||||
float floorf(float);
|
||||
|
||||
float nearbyintf(float);
|
||||
float rintf(float);
|
||||
float truncf(float);
|
||||
|
||||
-#endif /* !_MATH_H_ */
|
||||
+#endif /* mozilla_imported_fdlibm_h */
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
diff --git a/modules/fdlibm/src/fdlibm.h b/modules/fdlibm/src/fdlibm.h
|
||||
--- a/modules/fdlibm/src/fdlibm.h
|
||||
+++ b/modules/fdlibm/src/fdlibm.h
|
||||
@@ -12,16 +12,18 @@
|
||||
/*
|
||||
* from: @(#)fdlibm.h 5.1 93/09/24
|
||||
* $FreeBSD$
|
||||
*/
|
||||
|
||||
#ifndef mozilla_imported_fdlibm_h
|
||||
#define mozilla_imported_fdlibm_h
|
||||
|
||||
+namespace fdlibm {
|
||||
+
|
||||
double acos(double);
|
||||
double asin(double);
|
||||
double atan(double);
|
||||
double atan2(double, double);
|
||||
|
||||
double cosh(double);
|
||||
double sinh(double);
|
||||
double tanh(double);
|
||||
@@ -53,9 +55,11 @@ double scalbn(double, int);
|
||||
|
||||
float ceilf(float);
|
||||
float floorf(float);
|
||||
|
||||
float nearbyintf(float);
|
||||
float rintf(float);
|
||||
float truncf(float);
|
||||
|
||||
+} /* namespace fdlibm */
|
||||
+
|
||||
#endif /* mozilla_imported_fdlibm_h */
|
||||
|
|
@ -0,0 +1,716 @@
|
|||
diff --git a/modules/fdlibm/src/e_acos.cpp b/modules/fdlibm/src/e_acos.cpp
|
||||
--- a/modules/fdlibm/src/e_acos.cpp
|
||||
+++ b/modules/fdlibm/src/e_acos.cpp
|
||||
@@ -35,17 +35,16 @@
|
||||
* if x is NaN, return x itself;
|
||||
* if |x|>1, return NaN with invalid signal.
|
||||
*
|
||||
* Function needed: sqrt
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static const double
|
||||
one= 1.00000000000000000000e+00, /* 0x3FF00000, 0x00000000 */
|
||||
pi = 3.14159265358979311600e+00, /* 0x400921FB, 0x54442D18 */
|
||||
pio2_hi = 1.57079632679489655800e+00; /* 0x3FF921FB, 0x54442D18 */
|
||||
static volatile double
|
||||
pio2_lo = 6.12323399573676603587e-17; /* 0x3C91A626, 0x33145C07 */
|
||||
diff --git a/modules/fdlibm/src/e_acosh.cpp b/modules/fdlibm/src/e_acosh.cpp
|
||||
--- a/modules/fdlibm/src/e_acosh.cpp
|
||||
+++ b/modules/fdlibm/src/e_acosh.cpp
|
||||
@@ -26,17 +26,16 @@
|
||||
*
|
||||
* Special cases:
|
||||
* acosh(x) is NaN with signal if x<1.
|
||||
* acosh(NaN) is NaN without signal.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static const double
|
||||
one = 1.0,
|
||||
ln2 = 6.93147180559945286227e-01; /* 0x3FE62E42, 0xFEFA39EF */
|
||||
|
||||
double
|
||||
__ieee754_acosh(double x)
|
||||
diff --git a/modules/fdlibm/src/e_asin.cpp b/modules/fdlibm/src/e_asin.cpp
|
||||
--- a/modules/fdlibm/src/e_asin.cpp
|
||||
+++ b/modules/fdlibm/src/e_asin.cpp
|
||||
@@ -41,17 +41,16 @@
|
||||
* Special cases:
|
||||
* if x is NaN, return x itself;
|
||||
* if |x|>1, return NaN with invalid signal.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static const double
|
||||
one = 1.00000000000000000000e+00, /* 0x3FF00000, 0x00000000 */
|
||||
huge = 1.000e+300,
|
||||
pio2_hi = 1.57079632679489655800e+00, /* 0x3FF921FB, 0x54442D18 */
|
||||
pio2_lo = 6.12323399573676603587e-17, /* 0x3C91A626, 0x33145C07 */
|
||||
pio4_hi = 7.85398163397448278999e-01, /* 0x3FE921FB, 0x54442D18 */
|
||||
diff --git a/modules/fdlibm/src/e_atan2.cpp b/modules/fdlibm/src/e_atan2.cpp
|
||||
--- a/modules/fdlibm/src/e_atan2.cpp
|
||||
+++ b/modules/fdlibm/src/e_atan2.cpp
|
||||
@@ -39,17 +39,16 @@
|
||||
* The hexadecimal values are the intended ones for the following
|
||||
* constants. The decimal values may be used, provided that the
|
||||
* compiler will convert from decimal to binary accurately enough
|
||||
* to produce the hexadecimal values shown.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static volatile double
|
||||
tiny = 1.0e-300;
|
||||
static const double
|
||||
zero = 0.0,
|
||||
pi_o_4 = 7.8539816339744827900E-01, /* 0x3FE921FB, 0x54442D18 */
|
||||
pi_o_2 = 1.5707963267948965580E+00, /* 0x3FF921FB, 0x54442D18 */
|
||||
diff --git a/modules/fdlibm/src/e_atanh.cpp b/modules/fdlibm/src/e_atanh.cpp
|
||||
--- a/modules/fdlibm/src/e_atanh.cpp
|
||||
+++ b/modules/fdlibm/src/e_atanh.cpp
|
||||
@@ -30,17 +30,16 @@
|
||||
* atanh(x) is NaN if |x| > 1 with signal;
|
||||
* atanh(NaN) is that NaN with no signal;
|
||||
* atanh(+-1) is +-INF with signal.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static const double one = 1.0, huge = 1e300;
|
||||
static const double zero = 0.0;
|
||||
|
||||
double
|
||||
__ieee754_atanh(double x)
|
||||
{
|
||||
diff --git a/modules/fdlibm/src/e_cosh.cpp b/modules/fdlibm/src/e_cosh.cpp
|
||||
--- a/modules/fdlibm/src/e_cosh.cpp
|
||||
+++ b/modules/fdlibm/src/e_cosh.cpp
|
||||
@@ -32,17 +32,16 @@
|
||||
*
|
||||
* Special cases:
|
||||
* cosh(x) is |x| if x is +INF, -INF, or NaN.
|
||||
* only cosh(0)=1 is exact for finite x.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static const double one = 1.0, half=0.5, huge = 1.0e300;
|
||||
|
||||
double
|
||||
__ieee754_cosh(double x)
|
||||
{
|
||||
double t,w;
|
||||
diff --git a/modules/fdlibm/src/e_exp.cpp b/modules/fdlibm/src/e_exp.cpp
|
||||
--- a/modules/fdlibm/src/e_exp.cpp
|
||||
+++ b/modules/fdlibm/src/e_exp.cpp
|
||||
@@ -73,17 +73,16 @@
|
||||
* The hexadecimal values are the intended ones for the following
|
||||
* constants. The decimal values may be used, provided that the
|
||||
* compiler will convert from decimal to binary accurately enough
|
||||
* to produce the hexadecimal values shown.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static const double
|
||||
one = 1.0,
|
||||
halF[2] = {0.5,-0.5,},
|
||||
o_threshold= 7.09782712893383973096e+02, /* 0x40862E42, 0xFEFA39EF */
|
||||
u_threshold= -7.45133219101941108420e+02, /* 0xc0874910, 0xD52D3051 */
|
||||
ln2HI[2] ={ 6.93147180369123816490e-01, /* 0x3fe62e42, 0xfee00000 */
|
||||
diff --git a/modules/fdlibm/src/e_hypot.cpp b/modules/fdlibm/src/e_hypot.cpp
|
||||
--- a/modules/fdlibm/src/e_hypot.cpp
|
||||
+++ b/modules/fdlibm/src/e_hypot.cpp
|
||||
@@ -43,17 +43,16 @@
|
||||
*
|
||||
* Accuracy:
|
||||
* hypot(x,y) returns sqrt(x^2+y^2) with error less
|
||||
* than 1 ulps (units in the last place)
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
double
|
||||
__ieee754_hypot(double x, double y)
|
||||
{
|
||||
double a,b,t1,t2,y1,y2,w;
|
||||
int32_t j,k,ha,hb;
|
||||
|
||||
diff --git a/modules/fdlibm/src/e_log.cpp b/modules/fdlibm/src/e_log.cpp
|
||||
--- a/modules/fdlibm/src/e_log.cpp
|
||||
+++ b/modules/fdlibm/src/e_log.cpp
|
||||
@@ -62,17 +62,16 @@
|
||||
* The hexadecimal values are the intended ones for the following
|
||||
* constants. The decimal values may be used, provided that the
|
||||
* compiler will convert from decimal to binary accurately enough
|
||||
* to produce the hexadecimal values shown.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static const double
|
||||
ln2_hi = 6.93147180369123816490e-01, /* 3fe62e42 fee00000 */
|
||||
ln2_lo = 1.90821492927058770002e-10, /* 3dea39ef 35793c76 */
|
||||
two54 = 1.80143985094819840000e+16, /* 43500000 00000000 */
|
||||
Lg1 = 6.666666666666735130e-01, /* 3FE55555 55555593 */
|
||||
Lg2 = 3.999999999940941908e-01, /* 3FD99999 9997FA04 */
|
||||
diff --git a/modules/fdlibm/src/e_log10.cpp b/modules/fdlibm/src/e_log10.cpp
|
||||
--- a/modules/fdlibm/src/e_log10.cpp
|
||||
+++ b/modules/fdlibm/src/e_log10.cpp
|
||||
@@ -19,17 +19,16 @@
|
||||
* comments.
|
||||
*
|
||||
* log10(x) = (f - 0.5*f*f + k_log1p(f)) / ln10 + k * log10(2)
|
||||
* in not-quite-routine extra precision.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
#include "k_log.h"
|
||||
|
||||
static const double
|
||||
two54 = 1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */
|
||||
ivln10hi = 4.34294481878168880939e-01, /* 0x3fdbcb7b, 0x15200000 */
|
||||
ivln10lo = 2.50829467116452752298e-11, /* 0x3dbb9438, 0xca9aadd5 */
|
||||
log10_2hi = 3.01029995663611771306e-01, /* 0x3FD34413, 0x509F6000 */
|
||||
diff --git a/modules/fdlibm/src/e_log2.cpp b/modules/fdlibm/src/e_log2.cpp
|
||||
--- a/modules/fdlibm/src/e_log2.cpp
|
||||
+++ b/modules/fdlibm/src/e_log2.cpp
|
||||
@@ -21,17 +21,16 @@
|
||||
* This reduces x to {k, 1+f} exactly as in e_log.c, then calls the kernel,
|
||||
* then does the combining and scaling steps
|
||||
* log2(x) = (f - 0.5*f*f + k_log1p(f)) / ln2 + k
|
||||
* in not-quite-routine extra precision.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
#include "k_log.h"
|
||||
|
||||
static const double
|
||||
two54 = 1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */
|
||||
ivln2hi = 1.44269504072144627571e+00, /* 0x3ff71547, 0x65200000 */
|
||||
ivln2lo = 1.67517131648865118353e-10; /* 0x3de705fc, 0x2eefa200 */
|
||||
|
||||
diff --git a/modules/fdlibm/src/e_pow.cpp b/modules/fdlibm/src/e_pow.cpp
|
||||
--- a/modules/fdlibm/src/e_pow.cpp
|
||||
+++ b/modules/fdlibm/src/e_pow.cpp
|
||||
@@ -52,17 +52,16 @@
|
||||
*
|
||||
* Constants :
|
||||
* The hexadecimal values are the intended ones for the following
|
||||
* constants. The decimal values may be used, provided that the
|
||||
* compiler will convert from decimal to binary accurately enough
|
||||
* to produce the hexadecimal values shown.
|
||||
*/
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static const double
|
||||
bp[] = {1.0, 1.5,},
|
||||
dp_h[] = { 0.0, 5.84962487220764160156e-01,}, /* 0x3FE2B803, 0x40000000 */
|
||||
dp_l[] = { 0.0, 1.35003920212974897128e-08,}, /* 0x3E4CFDEB, 0x43CFD006 */
|
||||
zero = 0.0,
|
||||
one = 1.0,
|
||||
diff --git a/modules/fdlibm/src/e_sinh.cpp b/modules/fdlibm/src/e_sinh.cpp
|
||||
--- a/modules/fdlibm/src/e_sinh.cpp
|
||||
+++ b/modules/fdlibm/src/e_sinh.cpp
|
||||
@@ -29,17 +29,16 @@
|
||||
*
|
||||
* Special cases:
|
||||
* sinh(x) is |x| if x is +INF, -INF, or NaN.
|
||||
* only sinh(0)=0 is exact for finite x.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static const double one = 1.0, shuge = 1.0e307;
|
||||
|
||||
double
|
||||
__ieee754_sinh(double x)
|
||||
{
|
||||
double t,h;
|
||||
diff --git a/modules/fdlibm/src/e_sqrt.cpp b/modules/fdlibm/src/e_sqrt.cpp
|
||||
--- a/modules/fdlibm/src/e_sqrt.cpp
|
||||
+++ b/modules/fdlibm/src/e_sqrt.cpp
|
||||
@@ -81,17 +81,16 @@
|
||||
* sqrt(NaN) = NaN ... with invalid signal for signaling NaN
|
||||
*
|
||||
* Other methods : see the appended file at the end of the program below.
|
||||
*---------------
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static const double one = 1.0, tiny=1.0e-300;
|
||||
|
||||
double
|
||||
__ieee754_sqrt(double x)
|
||||
{
|
||||
double z;
|
||||
diff --git a/modules/fdlibm/src/k_exp.cpp b/modules/fdlibm/src/k_exp.cpp
|
||||
--- a/modules/fdlibm/src/k_exp.cpp
|
||||
+++ b/modules/fdlibm/src/k_exp.cpp
|
||||
@@ -24,17 +24,16 @@
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <sys/cdefs.h>
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
#include <complex.h>
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static const uint32_t k = 1799; /* constant for reduction */
|
||||
static const double kln2 = 1246.97177782734161156; /* k * ln2 */
|
||||
|
||||
/*
|
||||
* Compute exp(x), scaled to avoid spurious overflow. An exponent is
|
||||
* returned separately in 'expt'.
|
||||
diff --git a/modules/fdlibm/src/math_private.h b/modules/fdlibm/src/math_private.h
|
||||
--- a/modules/fdlibm/src/math_private.h
|
||||
+++ b/modules/fdlibm/src/math_private.h
|
||||
@@ -15,16 +15,18 @@
|
||||
*/
|
||||
|
||||
#ifndef _MATH_PRIVATE_H_
|
||||
#define _MATH_PRIVATE_H_
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <machine/endian.h>
|
||||
|
||||
+#include "fdlibm.h"
|
||||
+
|
||||
/*
|
||||
* The original fdlibm code used statements like:
|
||||
* n0 = ((*(int*)&one)>>29)^1; * index of high word *
|
||||
* ix0 = *(n0+(int*)&x); * high word of x *
|
||||
* ix1 = *((1-n0)+(int*)&x); * low word of x *
|
||||
* to dig two 32 bit words out of the 64 bit IEEE floating point
|
||||
* value. That is non-ANSI, and, moreover, the gcc instruction
|
||||
* scheduler gets it wrong. We instead use the following macros.
|
||||
diff --git a/modules/fdlibm/src/s_asinh.cpp b/modules/fdlibm/src/s_asinh.cpp
|
||||
--- a/modules/fdlibm/src/s_asinh.cpp
|
||||
+++ b/modules/fdlibm/src/s_asinh.cpp
|
||||
@@ -21,17 +21,16 @@
|
||||
* asinh(x) := x if 1+x*x=1,
|
||||
* := sign(x)*(log(x)+ln2)) for large |x|, else
|
||||
* := sign(x)*log(2|x|+1/(|x|+sqrt(x*x+1))) if|x|>2, else
|
||||
* := sign(x)*log1p(|x| + x^2/(1 + sqrt(1+x^2)))
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static const double
|
||||
one = 1.00000000000000000000e+00, /* 0x3FF00000, 0x00000000 */
|
||||
ln2 = 6.93147180559945286227e-01, /* 0x3FE62E42, 0xFEFA39EF */
|
||||
huge= 1.00000000000000000000e+300;
|
||||
|
||||
double
|
||||
diff --git a/modules/fdlibm/src/s_atan.cpp b/modules/fdlibm/src/s_atan.cpp
|
||||
--- a/modules/fdlibm/src/s_atan.cpp
|
||||
+++ b/modules/fdlibm/src/s_atan.cpp
|
||||
@@ -30,17 +30,16 @@
|
||||
* The hexadecimal values are the intended ones for the following
|
||||
* constants. The decimal values may be used, provided that the
|
||||
* compiler will convert from decimal to binary accurately enough
|
||||
* to produce the hexadecimal values shown.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static const double atanhi[] = {
|
||||
4.63647609000806093515e-01, /* atan(0.5)hi 0x3FDDAC67, 0x0561BB4F */
|
||||
7.85398163397448278999e-01, /* atan(1.0)hi 0x3FE921FB, 0x54442D18 */
|
||||
9.82793723247329054082e-01, /* atan(1.5)hi 0x3FEF730B, 0xD281F69B */
|
||||
1.57079632679489655800e+00, /* atan(inf)hi 0x3FF921FB, 0x54442D18 */
|
||||
};
|
||||
diff --git a/modules/fdlibm/src/s_cbrt.cpp b/modules/fdlibm/src/s_cbrt.cpp
|
||||
--- a/modules/fdlibm/src/s_cbrt.cpp
|
||||
+++ b/modules/fdlibm/src/s_cbrt.cpp
|
||||
@@ -10,17 +10,16 @@
|
||||
* ====================================================
|
||||
*
|
||||
* Optimized by Bruce D. Evans.
|
||||
*/
|
||||
|
||||
#include <sys/cdefs.h>
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
/* cbrt(x)
|
||||
* Return cube root of x
|
||||
*/
|
||||
static const u_int32_t
|
||||
B1 = 715094163, /* B1 = (1023-1023/3-0.03306235651)*2**20 */
|
||||
B2 = 696219795; /* B2 = (1023-1023/3-54/3-0.03306235651)*2**20 */
|
||||
diff --git a/modules/fdlibm/src/s_ceil.cpp b/modules/fdlibm/src/s_ceil.cpp
|
||||
--- a/modules/fdlibm/src/s_ceil.cpp
|
||||
+++ b/modules/fdlibm/src/s_ceil.cpp
|
||||
@@ -19,17 +19,16 @@
|
||||
* Method:
|
||||
* Bit twiddling.
|
||||
* Exception:
|
||||
* Inexact flag raised if x not equal to ceil(x).
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static const double huge = 1.0e300;
|
||||
|
||||
double
|
||||
ceil(double x)
|
||||
{
|
||||
int32_t i0,i1,j0;
|
||||
diff --git a/modules/fdlibm/src/s_ceilf.cpp b/modules/fdlibm/src/s_ceilf.cpp
|
||||
--- a/modules/fdlibm/src/s_ceilf.cpp
|
||||
+++ b/modules/fdlibm/src/s_ceilf.cpp
|
||||
@@ -11,17 +11,16 @@
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
#include <sys/cdefs.h>
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static const float huge = 1.0e30;
|
||||
|
||||
float
|
||||
ceilf(float x)
|
||||
{
|
||||
int32_t i0,j0;
|
||||
diff --git a/modules/fdlibm/src/s_copysign.cpp b/modules/fdlibm/src/s_copysign.cpp
|
||||
--- a/modules/fdlibm/src/s_copysign.cpp
|
||||
+++ b/modules/fdlibm/src/s_copysign.cpp
|
||||
@@ -14,17 +14,16 @@
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
* copysign(double x, double y)
|
||||
* copysign(x,y) returns a value with the magnitude of x and
|
||||
* with the sign bit of y.
|
||||
*/
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
double
|
||||
copysign(double x, double y)
|
||||
{
|
||||
u_int32_t hx,hy;
|
||||
GET_HIGH_WORD(hx,x);
|
||||
GET_HIGH_WORD(hy,y);
|
||||
diff --git a/modules/fdlibm/src/s_expm1.cpp b/modules/fdlibm/src/s_expm1.cpp
|
||||
--- a/modules/fdlibm/src/s_expm1.cpp
|
||||
+++ b/modules/fdlibm/src/s_expm1.cpp
|
||||
@@ -105,17 +105,16 @@
|
||||
* The hexadecimal values are the intended ones for the following
|
||||
* constants. The decimal values may be used, provided that the
|
||||
* compiler will convert from decimal to binary accurately enough
|
||||
* to produce the hexadecimal values shown.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static const double
|
||||
one = 1.0,
|
||||
tiny = 1.0e-300,
|
||||
o_threshold = 7.09782712893383973096e+02,/* 0x40862E42, 0xFEFA39EF */
|
||||
ln2_hi = 6.93147180369123816490e-01,/* 0x3fe62e42, 0xfee00000 */
|
||||
ln2_lo = 1.90821492927058770002e-10,/* 0x3dea39ef, 0x35793c76 */
|
||||
diff --git a/modules/fdlibm/src/s_fabs.cpp b/modules/fdlibm/src/s_fabs.cpp
|
||||
--- a/modules/fdlibm/src/s_fabs.cpp
|
||||
+++ b/modules/fdlibm/src/s_fabs.cpp
|
||||
@@ -13,17 +13,16 @@
|
||||
#ifndef lint
|
||||
static char rcsid[] = "$FreeBSD$";
|
||||
#endif
|
||||
|
||||
/*
|
||||
* fabs(x) returns the absolute value of x.
|
||||
*/
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
double
|
||||
fabs(double x)
|
||||
{
|
||||
u_int32_t high;
|
||||
GET_HIGH_WORD(high,x);
|
||||
SET_HIGH_WORD(x,high&0x7fffffff);
|
||||
diff --git a/modules/fdlibm/src/s_floor.cpp b/modules/fdlibm/src/s_floor.cpp
|
||||
--- a/modules/fdlibm/src/s_floor.cpp
|
||||
+++ b/modules/fdlibm/src/s_floor.cpp
|
||||
@@ -19,17 +19,16 @@
|
||||
* Method:
|
||||
* Bit twiddling.
|
||||
* Exception:
|
||||
* Inexact flag raised if x not equal to floor(x).
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static const double huge = 1.0e300;
|
||||
|
||||
double
|
||||
floor(double x)
|
||||
{
|
||||
int32_t i0,i1,j0;
|
||||
diff --git a/modules/fdlibm/src/s_floorf.cpp b/modules/fdlibm/src/s_floorf.cpp
|
||||
--- a/modules/fdlibm/src/s_floorf.cpp
|
||||
+++ b/modules/fdlibm/src/s_floorf.cpp
|
||||
@@ -20,17 +20,16 @@
|
||||
* floorf(x)
|
||||
* Return x rounded toward -inf to integral value
|
||||
* Method:
|
||||
* Bit twiddling.
|
||||
* Exception:
|
||||
* Inexact flag raised if x not equal to floorf(x).
|
||||
*/
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static const float huge = 1.0e30;
|
||||
|
||||
float
|
||||
floorf(float x)
|
||||
{
|
||||
int32_t i0,j0;
|
||||
diff --git a/modules/fdlibm/src/s_log1p.cpp b/modules/fdlibm/src/s_log1p.cpp
|
||||
--- a/modules/fdlibm/src/s_log1p.cpp
|
||||
+++ b/modules/fdlibm/src/s_log1p.cpp
|
||||
@@ -75,17 +75,16 @@
|
||||
* if(u==1.0) return x ; else
|
||||
* return log(u)*(x/(u-1.0));
|
||||
*
|
||||
* See HP-15C Advanced Functions Handbook, p.193.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static const double
|
||||
ln2_hi = 6.93147180369123816490e-01, /* 3fe62e42 fee00000 */
|
||||
ln2_lo = 1.90821492927058770002e-10, /* 3dea39ef 35793c76 */
|
||||
two54 = 1.80143985094819840000e+16, /* 43500000 00000000 */
|
||||
Lp1 = 6.666666666666735130e-01, /* 3FE55555 55555593 */
|
||||
Lp2 = 3.999999999940941908e-01, /* 3FD99999 9997FA04 */
|
||||
diff --git a/modules/fdlibm/src/s_nearbyint.cpp b/modules/fdlibm/src/s_nearbyint.cpp
|
||||
--- a/modules/fdlibm/src/s_nearbyint.cpp
|
||||
+++ b/modules/fdlibm/src/s_nearbyint.cpp
|
||||
@@ -23,17 +23,17 @@
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <sys/cdefs.h>
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
#include <fenv.h>
|
||||
-#include <math.h>
|
||||
+#include "math_private.h"
|
||||
|
||||
/*
|
||||
* We save and restore the floating-point environment to avoid raising
|
||||
* an inexact exception. We can get away with using fesetenv()
|
||||
* instead of feclearexcept()/feupdateenv() to restore the environment
|
||||
* because the only exception defined for rint() is overflow, and
|
||||
* rounding can't overflow as long as emax >= p.
|
||||
*
|
||||
diff --git a/modules/fdlibm/src/s_rint.cpp b/modules/fdlibm/src/s_rint.cpp
|
||||
--- a/modules/fdlibm/src/s_rint.cpp
|
||||
+++ b/modules/fdlibm/src/s_rint.cpp
|
||||
@@ -20,17 +20,16 @@
|
||||
* Method:
|
||||
* Using floating addition.
|
||||
* Exception:
|
||||
* Inexact flag raised if x not equal to rint(x).
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static const double
|
||||
TWO52[2]={
|
||||
4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
|
||||
-4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
|
||||
};
|
||||
|
||||
diff --git a/modules/fdlibm/src/s_rintf.cpp b/modules/fdlibm/src/s_rintf.cpp
|
||||
--- a/modules/fdlibm/src/s_rintf.cpp
|
||||
+++ b/modules/fdlibm/src/s_rintf.cpp
|
||||
@@ -14,17 +14,16 @@
|
||||
*/
|
||||
|
||||
#include <sys/cdefs.h>
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
#include <float.h>
|
||||
#include <stdint.h>
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static const float
|
||||
TWO23[2]={
|
||||
8.3886080000e+06, /* 0x4b000000 */
|
||||
-8.3886080000e+06, /* 0xcb000000 */
|
||||
};
|
||||
|
||||
diff --git a/modules/fdlibm/src/s_scalbn.cpp b/modules/fdlibm/src/s_scalbn.cpp
|
||||
--- a/modules/fdlibm/src/s_scalbn.cpp
|
||||
+++ b/modules/fdlibm/src/s_scalbn.cpp
|
||||
@@ -19,17 +19,16 @@ static char rcsid[] = "$FreeBSD$";
|
||||
* scalbn(x,n) returns x* 2**n computed by exponent
|
||||
* manipulation rather than by actually performing an
|
||||
* exponentiation or a multiplication.
|
||||
*/
|
||||
|
||||
#include <sys/cdefs.h>
|
||||
#include <float.h>
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static const double
|
||||
two54 = 1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */
|
||||
twom54 = 5.55111512312578270212e-17, /* 0x3C900000, 0x00000000 */
|
||||
huge = 1.0e+300,
|
||||
tiny = 1.0e-300;
|
||||
|
||||
diff --git a/modules/fdlibm/src/s_tanh.cpp b/modules/fdlibm/src/s_tanh.cpp
|
||||
--- a/modules/fdlibm/src/s_tanh.cpp
|
||||
+++ b/modules/fdlibm/src/s_tanh.cpp
|
||||
@@ -34,17 +34,16 @@
|
||||
*
|
||||
* Special cases:
|
||||
* tanh(NaN) is NaN;
|
||||
* only tanh(0)=0 is exact for finite argument.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static const volatile double tiny = 1.0e-300;
|
||||
static const double one = 1.0, two = 2.0, huge = 1.0e300;
|
||||
|
||||
double
|
||||
tanh(double x)
|
||||
{
|
||||
diff --git a/modules/fdlibm/src/s_trunc.cpp b/modules/fdlibm/src/s_trunc.cpp
|
||||
--- a/modules/fdlibm/src/s_trunc.cpp
|
||||
+++ b/modules/fdlibm/src/s_trunc.cpp
|
||||
@@ -19,17 +19,16 @@
|
||||
* Method:
|
||||
* Bit twiddling.
|
||||
* Exception:
|
||||
* Inexact flag raised if x not equal to trunc(x).
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static const double huge = 1.0e300;
|
||||
|
||||
double
|
||||
trunc(double x)
|
||||
{
|
||||
int32_t i0,i1,j0;
|
||||
diff --git a/modules/fdlibm/src/s_truncf.cpp b/modules/fdlibm/src/s_truncf.cpp
|
||||
--- a/modules/fdlibm/src/s_truncf.cpp
|
||||
+++ b/modules/fdlibm/src/s_truncf.cpp
|
||||
@@ -17,17 +17,16 @@
|
||||
* truncf(x)
|
||||
* Return x rounded toward 0 to integral value
|
||||
* Method:
|
||||
* Bit twiddling.
|
||||
* Exception:
|
||||
* Inexact flag raised if x not equal to truncf(x).
|
||||
*/
|
||||
|
||||
-#include "math.h"
|
||||
#include "math_private.h"
|
||||
|
||||
static const float huge = 1.0e30F;
|
||||
|
||||
float
|
||||
truncf(float x)
|
||||
{
|
||||
int32_t i0,j0;
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
diff --git a/modules/fdlibm/src/math_private.h b/modules/fdlibm/src/math_private.h
|
||||
--- a/modules/fdlibm/src/math_private.h
|
||||
+++ b/modules/fdlibm/src/math_private.h
|
||||
@@ -12,16 +12,17 @@
|
||||
/*
|
||||
* from: @(#)fdlibm.h 5.1 93/09/24
|
||||
* $FreeBSD$
|
||||
*/
|
||||
|
||||
#ifndef _MATH_PRIVATE_H_
|
||||
#define _MATH_PRIVATE_H_
|
||||
|
||||
+#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
#include <machine/endian.h>
|
||||
|
||||
#include "fdlibm.h"
|
||||
|
||||
/*
|
||||
* The original fdlibm code used statements like:
|
||||
* n0 = ((*(int*)&one)>>29)^1; * index of high word *
|
||||
|
|
@ -0,0 +1,74 @@
|
|||
diff --git a/modules/fdlibm/src/math_private.h b/modules/fdlibm/src/math_private.h
|
||||
--- a/modules/fdlibm/src/math_private.h
|
||||
+++ b/modules/fdlibm/src/math_private.h
|
||||
@@ -14,20 +14,21 @@
|
||||
* $FreeBSD$
|
||||
*/
|
||||
|
||||
#ifndef _MATH_PRIVATE_H_
|
||||
#define _MATH_PRIVATE_H_
|
||||
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
-#include <machine/endian.h>
|
||||
|
||||
#include "fdlibm.h"
|
||||
|
||||
+#include "mozilla/EndianUtils.h"
|
||||
+
|
||||
/*
|
||||
* The original fdlibm code used statements like:
|
||||
* n0 = ((*(int*)&one)>>29)^1; * index of high word *
|
||||
* ix0 = *(n0+(int*)&x); * high word of x *
|
||||
* ix1 = *((1-n0)+(int*)&x); * low word of x *
|
||||
* to dig two 32 bit words out of the 64 bit IEEE floating point
|
||||
* value. That is non-ANSI, and, moreover, the gcc instruction
|
||||
* scheduler gets it wrong. We instead use the following macros.
|
||||
@@ -36,27 +37,17 @@
|
||||
* endianness at run time.
|
||||
*/
|
||||
|
||||
/*
|
||||
* A union which permits us to convert between a double and two 32 bit
|
||||
* ints.
|
||||
*/
|
||||
|
||||
-#ifdef __arm__
|
||||
-#if defined(__VFP_FP__) || defined(__ARM_EABI__)
|
||||
-#define IEEE_WORD_ORDER BYTE_ORDER
|
||||
-#else
|
||||
-#define IEEE_WORD_ORDER BIG_ENDIAN
|
||||
-#endif
|
||||
-#else /* __arm__ */
|
||||
-#define IEEE_WORD_ORDER BYTE_ORDER
|
||||
-#endif
|
||||
-
|
||||
-#if IEEE_WORD_ORDER == BIG_ENDIAN
|
||||
+#if MOZ_BIG_ENDIAN
|
||||
|
||||
typedef union
|
||||
{
|
||||
double value;
|
||||
struct
|
||||
{
|
||||
u_int32_t msw;
|
||||
u_int32_t lsw;
|
||||
@@ -64,17 +55,17 @@ typedef union
|
||||
struct
|
||||
{
|
||||
u_int64_t w;
|
||||
} xparts;
|
||||
} ieee_double_shape_type;
|
||||
|
||||
#endif
|
||||
|
||||
-#if IEEE_WORD_ORDER == LITTLE_ENDIAN
|
||||
+#if MOZ_LITTLE_ENDIAN
|
||||
|
||||
typedef union
|
||||
{
|
||||
double value;
|
||||
struct
|
||||
{
|
||||
u_int32_t lsw;
|
||||
u_int32_t msw;
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
diff --git a/modules/fdlibm/src/math_private.h b/modules/fdlibm/src/math_private.h
|
||||
--- a/modules/fdlibm/src/math_private.h
|
||||
+++ b/modules/fdlibm/src/math_private.h
|
||||
@@ -724,16 +724,51 @@ irintl(long double x)
|
||||
#define __ieee754_j1f j1f
|
||||
#define __ieee754_y0f y0f
|
||||
#define __ieee754_y1f y1f
|
||||
#define __ieee754_jnf jnf
|
||||
#define __ieee754_ynf ynf
|
||||
#define __ieee754_remainderf remainderf
|
||||
#define __ieee754_scalbf scalbf
|
||||
|
||||
+#define acos fdlibm::acos
|
||||
+#define asin fdlibm::asin
|
||||
+#define atan fdlibm::atan
|
||||
+#define atan2 fdlibm::atan2
|
||||
+#define cosh fdlibm::cosh
|
||||
+#define sinh fdlibm::sinh
|
||||
+#define tanh fdlibm::tanh
|
||||
+#define exp fdlibm::exp
|
||||
+#define log fdlibm::log
|
||||
+#define log10 fdlibm::log10
|
||||
+#define pow fdlibm::pow
|
||||
+#define sqrt fdlibm::sqrt
|
||||
+#define ceil fdlibm::ceil
|
||||
+#define ceilf fdlibm::ceilf
|
||||
+#define fabs fdlibm::fabs
|
||||
+#define floor fdlibm::floor
|
||||
+#define acosh fdlibm::acosh
|
||||
+#define asinh fdlibm::asinh
|
||||
+#define atanh fdlibm::atanh
|
||||
+#define cbrt fdlibm::cbrt
|
||||
+#define expm1 fdlibm::expm1
|
||||
+#define hypot fdlibm::hypot
|
||||
+#define log1p fdlibm::log1p
|
||||
+#define log2 fdlibm::log2
|
||||
+#define scalb fdlibm::scalb
|
||||
+#define copysign fdlibm::copysign
|
||||
+#define scalbn fdlibm::scalbn
|
||||
+#define trunc fdlibm::trunc
|
||||
+#define truncf fdlibm::truncf
|
||||
+#define floorf fdlibm::floorf
|
||||
+#define nearbyint fdlibm::nearbyint
|
||||
+#define nearbyintf fdlibm::nearbyintf
|
||||
+#define rint fdlibm::rint
|
||||
+#define rintf fdlibm::rintf
|
||||
+
|
||||
/* fdlibm kernel function */
|
||||
int __kernel_rem_pio2(double*,double*,int,int,int);
|
||||
|
||||
/* double precision kernel functions */
|
||||
#ifndef INLINE_REM_PIO2
|
||||
int __ieee754_rem_pio2(double,double*);
|
||||
#endif
|
||||
double __kernel_sin(double,double,int);
|
||||
393
modules/fdlibm/patches/08_remove_weak_reference_macro.patch
Normal file
393
modules/fdlibm/patches/08_remove_weak_reference_macro.patch
Normal file
|
|
@ -0,0 +1,393 @@
|
|||
diff --git a/modules/fdlibm/src/e_acos.cpp b/modules/fdlibm/src/e_acos.cpp
|
||||
--- a/modules/fdlibm/src/e_acos.cpp
|
||||
+++ b/modules/fdlibm/src/e_acos.cpp
|
||||
@@ -99,12 +99,8 @@ double
|
||||
c = (z-df*df)/(s+df);
|
||||
p = z*(pS0+z*(pS1+z*(pS2+z*(pS3+z*(pS4+z*pS5)))));
|
||||
q = one+z*(qS1+z*(qS2+z*(qS3+z*qS4)));
|
||||
r = p/q;
|
||||
w = r*s+c;
|
||||
return 2.0*(df+w);
|
||||
}
|
||||
}
|
||||
-
|
||||
-#if LDBL_MANT_DIG == 53
|
||||
-__weak_reference(acos, acosl);
|
||||
-#endif
|
||||
diff --git a/modules/fdlibm/src/e_acosh.cpp b/modules/fdlibm/src/e_acosh.cpp
|
||||
--- a/modules/fdlibm/src/e_acosh.cpp
|
||||
+++ b/modules/fdlibm/src/e_acosh.cpp
|
||||
@@ -56,12 +56,8 @@ double
|
||||
} else if (hx > 0x40000000) { /* 2**28 > x > 2 */
|
||||
t=x*x;
|
||||
return __ieee754_log(2.0*x-one/(x+sqrt(t-one)));
|
||||
} else { /* 1<x<2 */
|
||||
t = x-one;
|
||||
return log1p(t+sqrt(2.0*t+t*t));
|
||||
}
|
||||
}
|
||||
-
|
||||
-#if LDBL_MANT_DIG == 53
|
||||
-__weak_reference(acosh, acoshl);
|
||||
-#endif
|
||||
diff --git a/modules/fdlibm/src/e_asin.cpp b/modules/fdlibm/src/e_asin.cpp
|
||||
--- a/modules/fdlibm/src/e_asin.cpp
|
||||
+++ b/modules/fdlibm/src/e_asin.cpp
|
||||
@@ -105,12 +105,8 @@ double
|
||||
c = (t-w*w)/(s+w);
|
||||
r = p/q;
|
||||
p = 2.0*s*r-(pio2_lo-2.0*c);
|
||||
q = pio4_hi-2.0*w;
|
||||
t = pio4_hi-(p-q);
|
||||
}
|
||||
if(hx>0) return t; else return -t;
|
||||
}
|
||||
-
|
||||
-#if LDBL_MANT_DIG == 53
|
||||
-__weak_reference(asin, asinl);
|
||||
-#endif
|
||||
diff --git a/modules/fdlibm/src/e_atan2.cpp b/modules/fdlibm/src/e_atan2.cpp
|
||||
--- a/modules/fdlibm/src/e_atan2.cpp
|
||||
+++ b/modules/fdlibm/src/e_atan2.cpp
|
||||
@@ -117,12 +117,8 @@ double
|
||||
switch (m) {
|
||||
case 0: return z ; /* atan(+,+) */
|
||||
case 1: return -z ; /* atan(-,+) */
|
||||
case 2: return pi-(z-pi_lo);/* atan(+,-) */
|
||||
default: /* case 3 */
|
||||
return (z-pi_lo)-pi;/* atan(-,-) */
|
||||
}
|
||||
}
|
||||
-
|
||||
-#if LDBL_MANT_DIG == 53
|
||||
-__weak_reference(atan2, atan2l);
|
||||
-#endif
|
||||
diff --git a/modules/fdlibm/src/e_atanh.cpp b/modules/fdlibm/src/e_atanh.cpp
|
||||
--- a/modules/fdlibm/src/e_atanh.cpp
|
||||
+++ b/modules/fdlibm/src/e_atanh.cpp
|
||||
@@ -56,12 +56,8 @@ double
|
||||
SET_HIGH_WORD(x,ix);
|
||||
if(ix<0x3fe00000) { /* x < 0.5 */
|
||||
t = x+x;
|
||||
t = 0.5*log1p(t+t*x/(one-x));
|
||||
} else
|
||||
t = 0.5*log1p((x+x)/(one-x));
|
||||
if(hx>=0) return t; else return -t;
|
||||
}
|
||||
-
|
||||
-#if LDBL_MANT_DIG == 53
|
||||
-__weak_reference(atanh, atanhl);
|
||||
-#endif
|
||||
diff --git a/modules/fdlibm/src/e_cosh.cpp b/modules/fdlibm/src/e_cosh.cpp
|
||||
--- a/modules/fdlibm/src/e_cosh.cpp
|
||||
+++ b/modules/fdlibm/src/e_cosh.cpp
|
||||
@@ -73,12 +73,8 @@ double
|
||||
|
||||
/* |x| in [log(maxdouble), overflowthresold] */
|
||||
if (ix<=0x408633CE)
|
||||
return __ldexp_exp(fabs(x), -1);
|
||||
|
||||
/* |x| > overflowthresold, cosh(x) overflow */
|
||||
return huge*huge;
|
||||
}
|
||||
-
|
||||
-#if (LDBL_MANT_DIG == 53)
|
||||
-__weak_reference(cosh, coshl);
|
||||
-#endif
|
||||
diff --git a/modules/fdlibm/src/e_exp.cpp b/modules/fdlibm/src/e_exp.cpp
|
||||
--- a/modules/fdlibm/src/e_exp.cpp
|
||||
+++ b/modules/fdlibm/src/e_exp.cpp
|
||||
@@ -152,12 +152,8 @@ double
|
||||
else y = one-((lo-(x*c)/(2.0-c))-hi);
|
||||
if(k >= -1021) {
|
||||
if (k==1024) return y*2.0*0x1p1023;
|
||||
return y*twopk;
|
||||
} else {
|
||||
return y*twopk*twom1000;
|
||||
}
|
||||
}
|
||||
-
|
||||
-#if (LDBL_MANT_DIG == 53)
|
||||
-__weak_reference(exp, expl);
|
||||
-#endif
|
||||
diff --git a/modules/fdlibm/src/e_hypot.cpp b/modules/fdlibm/src/e_hypot.cpp
|
||||
--- a/modules/fdlibm/src/e_hypot.cpp
|
||||
+++ b/modules/fdlibm/src/e_hypot.cpp
|
||||
@@ -119,12 +119,8 @@ double
|
||||
if(k!=0) {
|
||||
u_int32_t high;
|
||||
t1 = 1.0;
|
||||
GET_HIGH_WORD(high,t1);
|
||||
SET_HIGH_WORD(t1,high+(k<<20));
|
||||
return t1*w;
|
||||
} else return w;
|
||||
}
|
||||
-
|
||||
-#if LDBL_MANT_DIG == 53
|
||||
-__weak_reference(hypot, hypotl);
|
||||
-#endif
|
||||
diff --git a/modules/fdlibm/src/e_log.cpp b/modules/fdlibm/src/e_log.cpp
|
||||
--- a/modules/fdlibm/src/e_log.cpp
|
||||
+++ b/modules/fdlibm/src/e_log.cpp
|
||||
@@ -135,12 +135,8 @@ double
|
||||
hfsq=0.5*f*f;
|
||||
if(k==0) return f-(hfsq-s*(hfsq+R)); else
|
||||
return dk*ln2_hi-((hfsq-(s*(hfsq+R)+dk*ln2_lo))-f);
|
||||
} else {
|
||||
if(k==0) return f-s*(f-R); else
|
||||
return dk*ln2_hi-((s*(f-R)-dk*ln2_lo)-f);
|
||||
}
|
||||
}
|
||||
-
|
||||
-#if (LDBL_MANT_DIG == 53)
|
||||
-__weak_reference(log, logl);
|
||||
-#endif
|
||||
diff --git a/modules/fdlibm/src/e_log10.cpp b/modules/fdlibm/src/e_log10.cpp
|
||||
--- a/modules/fdlibm/src/e_log10.cpp
|
||||
+++ b/modules/fdlibm/src/e_log10.cpp
|
||||
@@ -82,12 +82,8 @@ double
|
||||
* with some parallelism and it reduces the error for many args.
|
||||
*/
|
||||
w = y2 + val_hi;
|
||||
val_lo += (y2 - w) + val_hi;
|
||||
val_hi = w;
|
||||
|
||||
return val_lo + val_hi;
|
||||
}
|
||||
-
|
||||
-#if (LDBL_MANT_DIG == 53)
|
||||
-__weak_reference(log10, log10l);
|
||||
-#endif
|
||||
diff --git a/modules/fdlibm/src/e_log2.cpp b/modules/fdlibm/src/e_log2.cpp
|
||||
--- a/modules/fdlibm/src/e_log2.cpp
|
||||
+++ b/modules/fdlibm/src/e_log2.cpp
|
||||
@@ -105,12 +105,8 @@ double
|
||||
|
||||
/* spadd(val_hi, val_lo, y), except for not using double_t: */
|
||||
w = y + val_hi;
|
||||
val_lo += (y - w) + val_hi;
|
||||
val_hi = w;
|
||||
|
||||
return val_lo + val_hi;
|
||||
}
|
||||
-
|
||||
-#if (LDBL_MANT_DIG == 53)
|
||||
-__weak_reference(log2, log2l);
|
||||
-#endif
|
||||
diff --git a/modules/fdlibm/src/e_sinh.cpp b/modules/fdlibm/src/e_sinh.cpp
|
||||
--- a/modules/fdlibm/src/e_sinh.cpp
|
||||
+++ b/modules/fdlibm/src/e_sinh.cpp
|
||||
@@ -67,12 +67,8 @@ double
|
||||
|
||||
/* |x| in [log(maxdouble), overflowthresold] */
|
||||
if (ix<=0x408633CE)
|
||||
return h*2.0*__ldexp_exp(fabs(x), -1);
|
||||
|
||||
/* |x| > overflowthresold, sinh(x) overflow */
|
||||
return x*shuge;
|
||||
}
|
||||
-
|
||||
-#if (LDBL_MANT_DIG == 53)
|
||||
-__weak_reference(sinh, sinhl);
|
||||
-#endif
|
||||
diff --git a/modules/fdlibm/src/e_sqrt.cpp b/modules/fdlibm/src/e_sqrt.cpp
|
||||
--- a/modules/fdlibm/src/e_sqrt.cpp
|
||||
+++ b/modules/fdlibm/src/e_sqrt.cpp
|
||||
@@ -182,20 +182,16 @@ double
|
||||
ix0 = (q>>1)+0x3fe00000;
|
||||
ix1 = q1>>1;
|
||||
if ((q&1)==1) ix1 |= sign;
|
||||
ix0 += (m <<20);
|
||||
INSERT_WORDS(z,ix0,ix1);
|
||||
return z;
|
||||
}
|
||||
|
||||
-#if (LDBL_MANT_DIG == 53)
|
||||
-__weak_reference(sqrt, sqrtl);
|
||||
-#endif
|
||||
-
|
||||
/*
|
||||
Other methods (use floating-point arithmetic)
|
||||
-------------
|
||||
(This is a copy of a drafted paper by Prof W. Kahan
|
||||
and K.C. Ng, written in May, 1986)
|
||||
|
||||
Two algorithms are given here to implement sqrt(x)
|
||||
(IEEE double precision arithmetic) in software.
|
||||
diff --git a/modules/fdlibm/src/s_asinh.cpp b/modules/fdlibm/src/s_asinh.cpp
|
||||
--- a/modules/fdlibm/src/s_asinh.cpp
|
||||
+++ b/modules/fdlibm/src/s_asinh.cpp
|
||||
@@ -50,12 +50,8 @@ asinh(double x)
|
||||
t = fabs(x);
|
||||
w = __ieee754_log(2.0*t+one/(__ieee754_sqrt(x*x+one)+t));
|
||||
} else { /* 2.0 > |x| > 2**-28 */
|
||||
t = x*x;
|
||||
w =log1p(fabs(x)+t/(one+__ieee754_sqrt(one+t)));
|
||||
}
|
||||
if(hx>0) return w; else return -w;
|
||||
}
|
||||
-
|
||||
-#if LDBL_MANT_DIG == 53
|
||||
-__weak_reference(asinh, asinhl);
|
||||
-#endif
|
||||
diff --git a/modules/fdlibm/src/s_atan.cpp b/modules/fdlibm/src/s_atan.cpp
|
||||
--- a/modules/fdlibm/src/s_atan.cpp
|
||||
+++ b/modules/fdlibm/src/s_atan.cpp
|
||||
@@ -112,12 +112,8 @@ atan(double x)
|
||||
s1 = z*(aT[0]+w*(aT[2]+w*(aT[4]+w*(aT[6]+w*(aT[8]+w*aT[10])))));
|
||||
s2 = w*(aT[1]+w*(aT[3]+w*(aT[5]+w*(aT[7]+w*aT[9]))));
|
||||
if (id<0) return x - x*(s1+s2);
|
||||
else {
|
||||
z = atanhi[id] - ((x*(s1+s2) - atanlo[id]) - x);
|
||||
return (hx<0)? -z:z;
|
||||
}
|
||||
}
|
||||
-
|
||||
-#if LDBL_MANT_DIG == 53
|
||||
-__weak_reference(atan, atanl);
|
||||
-#endif
|
||||
diff --git a/modules/fdlibm/src/s_cbrt.cpp b/modules/fdlibm/src/s_cbrt.cpp
|
||||
--- a/modules/fdlibm/src/s_cbrt.cpp
|
||||
+++ b/modules/fdlibm/src/s_cbrt.cpp
|
||||
@@ -105,12 +105,8 @@ cbrt(double x)
|
||||
s=t*t; /* t*t is exact */
|
||||
r=x/s; /* error <= 0.5 ulps; |r| < |t| */
|
||||
w=t+t; /* t+t is exact */
|
||||
r=(r-t)/(w+r); /* r-t is exact; w+r ~= 3*t */
|
||||
t=t+t*r; /* error <= 0.5 + 0.5/3 + epsilon */
|
||||
|
||||
return(t);
|
||||
}
|
||||
-
|
||||
-#if (LDBL_MANT_DIG == 53)
|
||||
-__weak_reference(cbrt, cbrtl);
|
||||
-#endif
|
||||
diff --git a/modules/fdlibm/src/s_ceil.cpp b/modules/fdlibm/src/s_ceil.cpp
|
||||
--- a/modules/fdlibm/src/s_ceil.cpp
|
||||
+++ b/modules/fdlibm/src/s_ceil.cpp
|
||||
@@ -65,12 +65,8 @@ ceil(double x)
|
||||
}
|
||||
}
|
||||
i1 &= (~i);
|
||||
}
|
||||
}
|
||||
INSERT_WORDS(x,i0,i1);
|
||||
return x;
|
||||
}
|
||||
-
|
||||
-#if LDBL_MANT_DIG == 53
|
||||
-__weak_reference(ceil, ceill);
|
||||
-#endif
|
||||
diff --git a/modules/fdlibm/src/s_expm1.cpp b/modules/fdlibm/src/s_expm1.cpp
|
||||
--- a/modules/fdlibm/src/s_expm1.cpp
|
||||
+++ b/modules/fdlibm/src/s_expm1.cpp
|
||||
@@ -210,12 +210,8 @@ expm1(double x)
|
||||
SET_HIGH_WORD(t,((0x3ff-k)<<20)); /* 2^-k */
|
||||
y = x-(e+t);
|
||||
y += one;
|
||||
y = y*twopk;
|
||||
}
|
||||
}
|
||||
return y;
|
||||
}
|
||||
-
|
||||
-#if (LDBL_MANT_DIG == 53)
|
||||
-__weak_reference(expm1, expm1l);
|
||||
-#endif
|
||||
diff --git a/modules/fdlibm/src/s_floor.cpp b/modules/fdlibm/src/s_floor.cpp
|
||||
--- a/modules/fdlibm/src/s_floor.cpp
|
||||
+++ b/modules/fdlibm/src/s_floor.cpp
|
||||
@@ -66,12 +66,8 @@ floor(double x)
|
||||
}
|
||||
}
|
||||
i1 &= (~i);
|
||||
}
|
||||
}
|
||||
INSERT_WORDS(x,i0,i1);
|
||||
return x;
|
||||
}
|
||||
-
|
||||
-#if LDBL_MANT_DIG == 53
|
||||
-__weak_reference(floor, floorl);
|
||||
-#endif
|
||||
diff --git a/modules/fdlibm/src/s_log1p.cpp b/modules/fdlibm/src/s_log1p.cpp
|
||||
--- a/modules/fdlibm/src/s_log1p.cpp
|
||||
+++ b/modules/fdlibm/src/s_log1p.cpp
|
||||
@@ -168,12 +168,8 @@ log1p(double x)
|
||||
return k*ln2_hi-((R-(k*ln2_lo+c))-f);
|
||||
}
|
||||
s = f/(2.0+f);
|
||||
z = s*s;
|
||||
R = z*(Lp1+z*(Lp2+z*(Lp3+z*(Lp4+z*(Lp5+z*(Lp6+z*Lp7))))));
|
||||
if(k==0) return f-(hfsq-s*(hfsq+R)); else
|
||||
return k*ln2_hi-((hfsq-(s*(hfsq+R)+(k*ln2_lo+c)))-f);
|
||||
}
|
||||
-
|
||||
-#if (LDBL_MANT_DIG == 53)
|
||||
-__weak_reference(log1p, log1pl);
|
||||
-#endif
|
||||
diff --git a/modules/fdlibm/src/s_rint.cpp b/modules/fdlibm/src/s_rint.cpp
|
||||
--- a/modules/fdlibm/src/s_rint.cpp
|
||||
+++ b/modules/fdlibm/src/s_rint.cpp
|
||||
@@ -80,12 +80,8 @@ rint(double x)
|
||||
if((i1&i)==0) return x; /* x is integral */
|
||||
i>>=1;
|
||||
if((i1&i)!=0) i1 = (i1&(~i))|((0x40000000)>>(j0-20));
|
||||
}
|
||||
INSERT_WORDS(x,i0,i1);
|
||||
STRICT_ASSIGN(double,w,TWO52[sx]+x);
|
||||
return w-TWO52[sx];
|
||||
}
|
||||
-
|
||||
-#if (LDBL_MANT_DIG == 53)
|
||||
-__weak_reference(rint, rintl);
|
||||
-#endif
|
||||
diff --git a/modules/fdlibm/src/s_scalbn.cpp b/modules/fdlibm/src/s_scalbn.cpp
|
||||
--- a/modules/fdlibm/src/s_scalbn.cpp
|
||||
+++ b/modules/fdlibm/src/s_scalbn.cpp
|
||||
@@ -53,13 +53,8 @@ scalbn (double x, int n)
|
||||
if (k <= -54)
|
||||
if (n > 50000) /* in case integer overflow in n+k */
|
||||
return huge*copysign(huge,x); /*overflow*/
|
||||
else return tiny*copysign(tiny,x); /*underflow*/
|
||||
k += 54; /* subnormal result */
|
||||
SET_HIGH_WORD(x,(hx&0x800fffff)|(k<<20));
|
||||
return x*twom54;
|
||||
}
|
||||
-
|
||||
-#if (LDBL_MANT_DIG == 53)
|
||||
-__weak_reference(scalbn, ldexpl);
|
||||
-__weak_reference(scalbn, scalbnl);
|
||||
-#endif
|
||||
diff --git a/modules/fdlibm/src/s_tanh.cpp b/modules/fdlibm/src/s_tanh.cpp
|
||||
--- a/modules/fdlibm/src/s_tanh.cpp
|
||||
+++ b/modules/fdlibm/src/s_tanh.cpp
|
||||
@@ -72,12 +72,8 @@ tanh(double x)
|
||||
z= -t/(t+two);
|
||||
}
|
||||
/* |x| >= 22, return +-1 */
|
||||
} else {
|
||||
z = one - tiny; /* raise inexact flag */
|
||||
}
|
||||
return (jx>=0)? z: -z;
|
||||
}
|
||||
-
|
||||
-#if (LDBL_MANT_DIG == 53)
|
||||
-__weak_reference(tanh, tanhl);
|
||||
-#endif
|
||||
diff --git a/modules/fdlibm/src/s_trunc.cpp b/modules/fdlibm/src/s_trunc.cpp
|
||||
--- a/modules/fdlibm/src/s_trunc.cpp
|
||||
+++ b/modules/fdlibm/src/s_trunc.cpp
|
||||
@@ -55,12 +55,8 @@ trunc(double x)
|
||||
i = ((u_int32_t)(0xffffffff))>>(j0-20);
|
||||
if((i1&i)==0) return x; /* x is integral */
|
||||
if(huge+x>0.0) /* raise inexact flag */
|
||||
i1 &= (~i);
|
||||
}
|
||||
INSERT_WORDS(x,i0,i1);
|
||||
return x;
|
||||
}
|
||||
-
|
||||
-#if LDBL_MANT_DIG == 53
|
||||
-__weak_reference(trunc, truncl);
|
||||
-#endif
|
||||
849
modules/fdlibm/patches/09_comment_out_rcsid_variable.patch
Normal file
849
modules/fdlibm/patches/09_comment_out_rcsid_variable.patch
Normal file
|
|
@ -0,0 +1,849 @@
|
|||
diff --git a/modules/fdlibm/src/e_acos.cpp b/modules/fdlibm/src/e_acos.cpp
|
||||
--- a/modules/fdlibm/src/e_acos.cpp
|
||||
+++ b/modules/fdlibm/src/e_acos.cpp
|
||||
@@ -6,18 +6,18 @@
|
||||
*
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* __ieee754_acos(x)
|
||||
* Method :
|
||||
* acos(x) = pi/2 - asin(x)
|
||||
* acos(-x) = pi/2 + asin(x)
|
||||
* For |x|<=0.5
|
||||
* acos(x) = pi/2 - (x + x*x^2*R(x^2)) (see asin.c)
|
||||
* For x>0.5
|
||||
diff --git a/modules/fdlibm/src/e_acosh.cpp b/modules/fdlibm/src/e_acosh.cpp
|
||||
--- a/modules/fdlibm/src/e_acosh.cpp
|
||||
+++ b/modules/fdlibm/src/e_acosh.cpp
|
||||
@@ -7,18 +7,18 @@
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* __ieee754_acosh(x)
|
||||
* Method :
|
||||
* Based on
|
||||
* acosh(x) = log [ x + sqrt(x*x-1) ]
|
||||
* we have
|
||||
* acosh(x) := log(x)+ln2, if x is large; else
|
||||
* acosh(x) := log(2x-1/(sqrt(x*x-1)+x)) if x>2; else
|
||||
diff --git a/modules/fdlibm/src/e_asin.cpp b/modules/fdlibm/src/e_asin.cpp
|
||||
--- a/modules/fdlibm/src/e_asin.cpp
|
||||
+++ b/modules/fdlibm/src/e_asin.cpp
|
||||
@@ -6,18 +6,18 @@
|
||||
*
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* __ieee754_asin(x)
|
||||
* Method :
|
||||
* Since asin(x) = x + x^3/6 + x^5*3/40 + x^7*15/336 + ...
|
||||
* we approximate asin(x) on [0,0.5] by
|
||||
* asin(x) = x + x*x^2*R(x^2)
|
||||
* where
|
||||
* R(x^2) is a rational approximation of (asin(x)-x)/x^3
|
||||
diff --git a/modules/fdlibm/src/e_atan2.cpp b/modules/fdlibm/src/e_atan2.cpp
|
||||
--- a/modules/fdlibm/src/e_atan2.cpp
|
||||
+++ b/modules/fdlibm/src/e_atan2.cpp
|
||||
@@ -7,18 +7,18 @@
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* __ieee754_atan2(y,x)
|
||||
* Method :
|
||||
* 1. Reduce y to positive by atan2(y,x)=-atan2(-y,x).
|
||||
* 2. Reduce x to positive by (if x and y are unexceptional):
|
||||
* ARG (x+iy) = arctan(y/x) ... if x > 0,
|
||||
* ARG (x+iy) = pi - arctan[y/(-x)] ... if x < 0,
|
||||
*
|
||||
diff --git a/modules/fdlibm/src/e_atanh.cpp b/modules/fdlibm/src/e_atanh.cpp
|
||||
--- a/modules/fdlibm/src/e_atanh.cpp
|
||||
+++ b/modules/fdlibm/src/e_atanh.cpp
|
||||
@@ -7,18 +7,18 @@
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* __ieee754_atanh(x)
|
||||
* Method :
|
||||
* 1.Reduced x to positive by atanh(-x) = -atanh(x)
|
||||
* 2.For x>=0.5
|
||||
* 1 2x x
|
||||
* atanh(x) = --- * log(1 + -------) = 0.5 * log1p(2 * --------)
|
||||
* 2 1 - x 1 - x
|
||||
diff --git a/modules/fdlibm/src/e_cosh.cpp b/modules/fdlibm/src/e_cosh.cpp
|
||||
--- a/modules/fdlibm/src/e_cosh.cpp
|
||||
+++ b/modules/fdlibm/src/e_cosh.cpp
|
||||
@@ -6,18 +6,18 @@
|
||||
*
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* __ieee754_cosh(x)
|
||||
* Method :
|
||||
* mathematically cosh(x) if defined to be (exp(x)+exp(-x))/2
|
||||
* 1. Replace x by |x| (cosh(x) = cosh(-x)).
|
||||
* 2.
|
||||
* [ exp(x) - 1 ]^2
|
||||
* 0 <= x <= ln2/2 : cosh(x) := 1 + -------------------
|
||||
diff --git a/modules/fdlibm/src/e_exp.cpp b/modules/fdlibm/src/e_exp.cpp
|
||||
--- a/modules/fdlibm/src/e_exp.cpp
|
||||
+++ b/modules/fdlibm/src/e_exp.cpp
|
||||
@@ -5,18 +5,18 @@
|
||||
* Copyright (C) 2004 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* __ieee754_exp(x)
|
||||
* Returns the exponential of x.
|
||||
*
|
||||
* Method
|
||||
* 1. Argument reduction:
|
||||
* Reduce x to an r so that |r| <= 0.5*ln2 ~ 0.34658.
|
||||
* Given x, find r and integer k such that
|
||||
diff --git a/modules/fdlibm/src/e_hypot.cpp b/modules/fdlibm/src/e_hypot.cpp
|
||||
--- a/modules/fdlibm/src/e_hypot.cpp
|
||||
+++ b/modules/fdlibm/src/e_hypot.cpp
|
||||
@@ -6,18 +6,18 @@
|
||||
*
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* __ieee754_hypot(x,y)
|
||||
*
|
||||
* Method :
|
||||
* If (assume round-to-nearest) z=x*x+y*y
|
||||
* has error less than sqrt(2)/2 ulp, than
|
||||
* sqrt(z) has error less than 1 ulp (exercise).
|
||||
*
|
||||
diff --git a/modules/fdlibm/src/e_log.cpp b/modules/fdlibm/src/e_log.cpp
|
||||
--- a/modules/fdlibm/src/e_log.cpp
|
||||
+++ b/modules/fdlibm/src/e_log.cpp
|
||||
@@ -6,18 +6,18 @@
|
||||
*
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* __ieee754_log(x)
|
||||
* Return the logrithm of x
|
||||
*
|
||||
* Method :
|
||||
* 1. Argument Reduction: find k and f such that
|
||||
* x = 2^k * (1+f),
|
||||
* where sqrt(2)/2 < 1+f < sqrt(2) .
|
||||
diff --git a/modules/fdlibm/src/e_log10.cpp b/modules/fdlibm/src/e_log10.cpp
|
||||
--- a/modules/fdlibm/src/e_log10.cpp
|
||||
+++ b/modules/fdlibm/src/e_log10.cpp
|
||||
@@ -6,32 +6,32 @@
|
||||
*
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
* Return the base 10 logarithm of x. See e_log.c and k_log.h for most
|
||||
* comments.
|
||||
*
|
||||
* log10(x) = (f - 0.5*f*f + k_log1p(f)) / ln10 + k * log10(2)
|
||||
* in not-quite-routine extra precision.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
#include "math_private.h"
|
||||
#include "k_log.h"
|
||||
-
|
||||
+
|
||||
static const double
|
||||
two54 = 1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */
|
||||
ivln10hi = 4.34294481878168880939e-01, /* 0x3fdbcb7b, 0x15200000 */
|
||||
ivln10lo = 2.50829467116452752298e-11, /* 0x3dbb9438, 0xca9aadd5 */
|
||||
log10_2hi = 3.01029995663611771306e-01, /* 0x3FD34413, 0x509F6000 */
|
||||
log10_2lo = 3.69423907715893078616e-13; /* 0x3D59FEF3, 0x11F12B36 */
|
||||
|
||||
static const double zero = 0.0;
|
||||
diff --git a/modules/fdlibm/src/e_log2.cpp b/modules/fdlibm/src/e_log2.cpp
|
||||
--- a/modules/fdlibm/src/e_log2.cpp
|
||||
+++ b/modules/fdlibm/src/e_log2.cpp
|
||||
@@ -6,18 +6,18 @@
|
||||
*
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
* Return the base 2 logarithm of x. See e_log.c and k_log.h for most
|
||||
* comments.
|
||||
*
|
||||
* This reduces x to {k, 1+f} exactly as in e_log.c, then calls the kernel,
|
||||
* then does the combining and scaling steps
|
||||
* log2(x) = (f - 0.5*f*f + k_log1p(f)) / ln2 + k
|
||||
diff --git a/modules/fdlibm/src/e_pow.cpp b/modules/fdlibm/src/e_pow.cpp
|
||||
--- a/modules/fdlibm/src/e_pow.cpp
|
||||
+++ b/modules/fdlibm/src/e_pow.cpp
|
||||
@@ -4,18 +4,18 @@
|
||||
* Copyright (C) 2004 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* __ieee754_pow(x,y) return x**y
|
||||
*
|
||||
* n
|
||||
* Method: Let x = 2 * (1+f)
|
||||
* 1. Compute and return log2(x) in two pieces:
|
||||
* log2(x) = w1 + w2,
|
||||
* where w1 has 53-24 = 29 bit trailing zeros.
|
||||
diff --git a/modules/fdlibm/src/e_sinh.cpp b/modules/fdlibm/src/e_sinh.cpp
|
||||
--- a/modules/fdlibm/src/e_sinh.cpp
|
||||
+++ b/modules/fdlibm/src/e_sinh.cpp
|
||||
@@ -6,18 +6,18 @@
|
||||
*
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* __ieee754_sinh(x)
|
||||
* Method :
|
||||
* mathematically sinh(x) if defined to be (exp(x)-exp(-x))/2
|
||||
* 1. Replace x by |x| (sinh(-x) = -sinh(x)).
|
||||
* 2.
|
||||
* E + E/(E+1)
|
||||
* 0 <= x <= 22 : sinh(x) := --------------, E=expm1(x)
|
||||
diff --git a/modules/fdlibm/src/e_sqrt.cpp b/modules/fdlibm/src/e_sqrt.cpp
|
||||
--- a/modules/fdlibm/src/e_sqrt.cpp
|
||||
+++ b/modules/fdlibm/src/e_sqrt.cpp
|
||||
@@ -6,18 +6,18 @@
|
||||
*
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* __ieee754_sqrt(x)
|
||||
* Return correctly rounded sqrt.
|
||||
* ------------------------------------------
|
||||
* | Use the hardware sqrt if you have one |
|
||||
* ------------------------------------------
|
||||
* Method:
|
||||
* Bit by bit method using integer arithmetic. (Slow, but portable)
|
||||
diff --git a/modules/fdlibm/src/k_exp.cpp b/modules/fdlibm/src/k_exp.cpp
|
||||
--- a/modules/fdlibm/src/k_exp.cpp
|
||||
+++ b/modules/fdlibm/src/k_exp.cpp
|
||||
@@ -19,22 +19,22 @@
|
||||
* 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.
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
#include <complex.h>
|
||||
|
||||
-#include "math_private.h"
|
||||
+ #include "math_private.h"
|
||||
|
||||
static const uint32_t k = 1799; /* constant for reduction */
|
||||
static const double kln2 = 1246.97177782734161156; /* k * ln2 */
|
||||
|
||||
/*
|
||||
* Compute exp(x), scaled to avoid spurious overflow. An exponent is
|
||||
* returned separately in 'expt'.
|
||||
*
|
||||
diff --git a/modules/fdlibm/src/k_log.h b/modules/fdlibm/src/k_log.h
|
||||
--- a/modules/fdlibm/src/k_log.h
|
||||
+++ b/modules/fdlibm/src/k_log.h
|
||||
@@ -6,18 +6,18 @@
|
||||
*
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
* k_log1p(f):
|
||||
* Return log(1+f) - f for 1+f in ~[sqrt(2)/2, sqrt(2)].
|
||||
*
|
||||
* The following describes the overall strategy for computing
|
||||
* logarithms in base e. The argument reduction and adding the final
|
||||
* term of the polynomial are done by the caller for increased accuracy
|
||||
diff --git a/modules/fdlibm/src/s_asinh.cpp b/modules/fdlibm/src/s_asinh.cpp
|
||||
--- a/modules/fdlibm/src/s_asinh.cpp
|
||||
+++ b/modules/fdlibm/src/s_asinh.cpp
|
||||
@@ -5,18 +5,18 @@
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* asinh(x)
|
||||
* Method :
|
||||
* Based on
|
||||
* asinh(x) = sign(x) * log [ |x| + sqrt(x*x+1) ]
|
||||
* we have
|
||||
* asinh(x) := x if 1+x*x=1,
|
||||
* := sign(x)*(log(x)+ln2)) for large |x|, else
|
||||
diff --git a/modules/fdlibm/src/s_atan.cpp b/modules/fdlibm/src/s_atan.cpp
|
||||
--- a/modules/fdlibm/src/s_atan.cpp
|
||||
+++ b/modules/fdlibm/src/s_atan.cpp
|
||||
@@ -5,18 +5,18 @@
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* atan(x)
|
||||
* Method
|
||||
* 1. Reduce x to positive by atan(x) = -atan(-x).
|
||||
* 2. According to the integer k=4t+0.25 chopped, t=x, the argument
|
||||
* is further reduced to one of the following intervals and the
|
||||
* arctangent of t is evaluated by the corresponding formula:
|
||||
*
|
||||
diff --git a/modules/fdlibm/src/s_cbrt.cpp b/modules/fdlibm/src/s_cbrt.cpp
|
||||
--- a/modules/fdlibm/src/s_cbrt.cpp
|
||||
+++ b/modules/fdlibm/src/s_cbrt.cpp
|
||||
@@ -7,18 +7,18 @@
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*
|
||||
* Optimized by Bruce D. Evans.
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
/* cbrt(x)
|
||||
* Return cube root of x
|
||||
*/
|
||||
static const u_int32_t
|
||||
B1 = 715094163, /* B1 = (1023-1023/3-0.03306235651)*2**20 */
|
||||
diff --git a/modules/fdlibm/src/s_ceil.cpp b/modules/fdlibm/src/s_ceil.cpp
|
||||
--- a/modules/fdlibm/src/s_ceil.cpp
|
||||
+++ b/modules/fdlibm/src/s_ceil.cpp
|
||||
@@ -5,18 +5,18 @@
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
* ceil(x)
|
||||
* Return x rounded toward -inf to integral value
|
||||
* Method:
|
||||
* Bit twiddling.
|
||||
* Exception:
|
||||
* Inexact flag raised if x not equal to ceil(x).
|
||||
diff --git a/modules/fdlibm/src/s_ceilf.cpp b/modules/fdlibm/src/s_ceilf.cpp
|
||||
--- a/modules/fdlibm/src/s_ceilf.cpp
|
||||
+++ b/modules/fdlibm/src/s_ceilf.cpp
|
||||
@@ -8,18 +8,18 @@
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const float huge = 1.0e30;
|
||||
|
||||
float
|
||||
ceilf(float x)
|
||||
{
|
||||
diff --git a/modules/fdlibm/src/s_copysign.cpp b/modules/fdlibm/src/s_copysign.cpp
|
||||
--- a/modules/fdlibm/src/s_copysign.cpp
|
||||
+++ b/modules/fdlibm/src/s_copysign.cpp
|
||||
@@ -5,18 +5,18 @@
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
* copysign(double x, double y)
|
||||
* copysign(x,y) returns a value with the magnitude of x and
|
||||
* with the sign bit of y.
|
||||
*/
|
||||
|
||||
#include "math_private.h"
|
||||
diff --git a/modules/fdlibm/src/s_expm1.cpp b/modules/fdlibm/src/s_expm1.cpp
|
||||
--- a/modules/fdlibm/src/s_expm1.cpp
|
||||
+++ b/modules/fdlibm/src/s_expm1.cpp
|
||||
@@ -5,18 +5,18 @@
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* expm1(x)
|
||||
* Returns exp(x)-1, the exponential of x minus 1.
|
||||
*
|
||||
* Method
|
||||
* 1. Argument reduction:
|
||||
* Given x, find r and integer k such that
|
||||
*
|
||||
diff --git a/modules/fdlibm/src/s_fabs.cpp b/modules/fdlibm/src/s_fabs.cpp
|
||||
--- a/modules/fdlibm/src/s_fabs.cpp
|
||||
+++ b/modules/fdlibm/src/s_fabs.cpp
|
||||
@@ -1,22 +1,22 @@
|
||||
-/* @(#)s_fabs.c 5.1 93/09/24 */
|
||||
+ /* @(#)s_fabs.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
#ifndef lint
|
||||
-static char rcsid[] = "$FreeBSD$";
|
||||
+ //static char rcsid[] = "$FreeBSD$";
|
||||
#endif
|
||||
|
||||
/*
|
||||
* fabs(x) returns the absolute value of x.
|
||||
*/
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
diff --git a/modules/fdlibm/src/s_floor.cpp b/modules/fdlibm/src/s_floor.cpp
|
||||
--- a/modules/fdlibm/src/s_floor.cpp
|
||||
+++ b/modules/fdlibm/src/s_floor.cpp
|
||||
@@ -5,18 +5,18 @@
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
* floor(x)
|
||||
* Return x rounded toward -inf to integral value
|
||||
* Method:
|
||||
* Bit twiddling.
|
||||
* Exception:
|
||||
* Inexact flag raised if x not equal to floor(x).
|
||||
diff --git a/modules/fdlibm/src/s_floorf.cpp b/modules/fdlibm/src/s_floorf.cpp
|
||||
--- a/modules/fdlibm/src/s_floorf.cpp
|
||||
+++ b/modules/fdlibm/src/s_floorf.cpp
|
||||
@@ -8,18 +8,18 @@
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
* floorf(x)
|
||||
* Return x rounded toward -inf to integral value
|
||||
* Method:
|
||||
* Bit twiddling.
|
||||
* Exception:
|
||||
* Inexact flag raised if x not equal to floorf(x).
|
||||
diff --git a/modules/fdlibm/src/s_log1p.cpp b/modules/fdlibm/src/s_log1p.cpp
|
||||
--- a/modules/fdlibm/src/s_log1p.cpp
|
||||
+++ b/modules/fdlibm/src/s_log1p.cpp
|
||||
@@ -5,18 +5,18 @@
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* double log1p(double x)
|
||||
*
|
||||
* Method :
|
||||
* 1. Argument Reduction: find k and f such that
|
||||
* 1+x = 2^k * (1+f),
|
||||
* where sqrt(2)/2 < 1+f < sqrt(2) .
|
||||
*
|
||||
diff --git a/modules/fdlibm/src/s_nearbyint.cpp b/modules/fdlibm/src/s_nearbyint.cpp
|
||||
--- a/modules/fdlibm/src/s_nearbyint.cpp
|
||||
+++ b/modules/fdlibm/src/s_nearbyint.cpp
|
||||
@@ -19,18 +19,18 @@
|
||||
* 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.
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
#include <fenv.h>
|
||||
#include "math_private.h"
|
||||
|
||||
/*
|
||||
* We save and restore the floating-point environment to avoid raising
|
||||
* an inexact exception. We can get away with using fesetenv()
|
||||
* instead of feclearexcept()/feupdateenv() to restore the environment
|
||||
diff --git a/modules/fdlibm/src/s_rint.cpp b/modules/fdlibm/src/s_rint.cpp
|
||||
--- a/modules/fdlibm/src/s_rint.cpp
|
||||
+++ b/modules/fdlibm/src/s_rint.cpp
|
||||
@@ -5,18 +5,18 @@
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
* rint(x)
|
||||
* Return x rounded to integral value according to the prevailing
|
||||
* rounding mode.
|
||||
* Method:
|
||||
* Using floating addition.
|
||||
* Exception:
|
||||
diff --git a/modules/fdlibm/src/s_rintf.cpp b/modules/fdlibm/src/s_rintf.cpp
|
||||
--- a/modules/fdlibm/src/s_rintf.cpp
|
||||
+++ b/modules/fdlibm/src/s_rintf.cpp
|
||||
@@ -8,18 +8,18 @@
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
#include <float.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const float
|
||||
TWO23[2]={
|
||||
diff --git a/modules/fdlibm/src/s_scalbn.cpp b/modules/fdlibm/src/s_scalbn.cpp
|
||||
--- a/modules/fdlibm/src/s_scalbn.cpp
|
||||
+++ b/modules/fdlibm/src/s_scalbn.cpp
|
||||
@@ -6,27 +6,27 @@
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
#ifndef lint
|
||||
-static char rcsid[] = "$FreeBSD$";
|
||||
+//static char rcsid[] = "$FreeBSD$";
|
||||
#endif
|
||||
|
||||
/*
|
||||
* scalbn (double x, int n)
|
||||
* scalbn(x,n) returns x* 2**n computed by exponent
|
||||
* manipulation rather than by actually performing an
|
||||
* exponentiation or a multiplication.
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
+//#include <sys/cdefs.h>
|
||||
#include <float.h>
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const double
|
||||
two54 = 1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */
|
||||
twom54 = 5.55111512312578270212e-17, /* 0x3C900000, 0x00000000 */
|
||||
huge = 1.0e+300,
|
||||
diff --git a/modules/fdlibm/src/s_tanh.cpp b/modules/fdlibm/src/s_tanh.cpp
|
||||
--- a/modules/fdlibm/src/s_tanh.cpp
|
||||
+++ b/modules/fdlibm/src/s_tanh.cpp
|
||||
@@ -5,18 +5,18 @@
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* Tanh(x)
|
||||
* Return the Hyperbolic Tangent of x
|
||||
*
|
||||
* Method :
|
||||
* x -x
|
||||
* e - e
|
||||
* 0. tanh(x) is defined to be -----------
|
||||
diff --git a/modules/fdlibm/src/s_trunc.cpp b/modules/fdlibm/src/s_trunc.cpp
|
||||
--- a/modules/fdlibm/src/s_trunc.cpp
|
||||
+++ b/modules/fdlibm/src/s_trunc.cpp
|
||||
@@ -5,18 +5,18 @@
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
* trunc(x)
|
||||
* Return x rounded toward 0 to integral value
|
||||
* Method:
|
||||
* Bit twiddling.
|
||||
* Exception:
|
||||
* Inexact flag raised if x not equal to trunc(x).
|
||||
diff --git a/modules/fdlibm/src/s_truncf.cpp b/modules/fdlibm/src/s_truncf.cpp
|
||||
--- a/modules/fdlibm/src/s_truncf.cpp
|
||||
+++ b/modules/fdlibm/src/s_truncf.cpp
|
||||
@@ -5,18 +5,18 @@
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
-#include <sys/cdefs.h>
|
||||
-__FBSDID("$FreeBSD$");
|
||||
+//#include <sys/cdefs.h>
|
||||
+//__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
* truncf(x)
|
||||
* Return x rounded toward 0 to integral value
|
||||
* Method:
|
||||
* Bit twiddling.
|
||||
* Exception:
|
||||
* Inexact flag raised if x not equal to truncf(x).
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
diff --git a/modules/fdlibm/src/k_exp.cpp b/modules/fdlibm/src/k_exp.cpp
|
||||
--- a/modules/fdlibm/src/k_exp.cpp
|
||||
+++ b/modules/fdlibm/src/k_exp.cpp
|
||||
@@ -22,18 +22,16 @@
|
||||
* 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.
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
-#include <complex.h>
|
||||
-
|
||||
#include "math_private.h"
|
||||
|
||||
static const uint32_t k = 1799; /* constant for reduction */
|
||||
static const double kln2 = 1246.97177782734161156; /* k * ln2 */
|
||||
|
||||
/*
|
||||
* Compute exp(x), scaled to avoid spurious overflow. An exponent is
|
||||
* returned separately in 'expt'.
|
||||
@@ -76,32 +74,8 @@ double
|
||||
double exp_x, scale;
|
||||
int ex_expt;
|
||||
|
||||
exp_x = __frexp_exp(x, &ex_expt);
|
||||
expt += ex_expt;
|
||||
INSERT_WORDS(scale, (0x3ff + expt) << 20, 0);
|
||||
return (exp_x * scale);
|
||||
}
|
||||
-
|
||||
-double complex
|
||||
-__ldexp_cexp(double complex z, int expt)
|
||||
-{
|
||||
- double x, y, exp_x, scale1, scale2;
|
||||
- int ex_expt, half_expt;
|
||||
-
|
||||
- x = creal(z);
|
||||
- y = cimag(z);
|
||||
- exp_x = __frexp_exp(x, &ex_expt);
|
||||
- expt += ex_expt;
|
||||
-
|
||||
- /*
|
||||
- * Arrange so that scale1 * scale2 == 2**expt. We use this to
|
||||
- * compensate for scalbn being horrendously slow.
|
||||
- */
|
||||
- half_expt = expt / 2;
|
||||
- INSERT_WORDS(scale1, (0x3ff + half_expt) << 20, 0);
|
||||
- half_expt = expt - half_expt;
|
||||
- INSERT_WORDS(scale2, (0x3ff + half_expt) << 20, 0);
|
||||
-
|
||||
- return (CMPLX(cos(y) * exp_x * scale1 * scale2,
|
||||
- sin(y) * exp_x * scale1 * scale2));
|
||||
-}
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
diff --git a/modules/fdlibm/src/math_private.h b/modules/fdlibm/src/math_private.h
|
||||
--- a/modules/fdlibm/src/math_private.h
|
||||
+++ b/modules/fdlibm/src/math_private.h
|
||||
@@ -12,16 +12,17 @@
|
||||
/*
|
||||
* from: @(#)fdlibm.h 5.1 93/09/24
|
||||
* $FreeBSD$
|
||||
*/
|
||||
|
||||
#ifndef _MATH_PRIVATE_H_
|
||||
#define _MATH_PRIVATE_H_
|
||||
|
||||
+#include <cfloat>
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
#include "fdlibm.h"
|
||||
|
||||
#include "mozilla/EndianUtils.h"
|
||||
|
||||
/*
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
diff --git a/modules/fdlibm/src/math_private.h b/modules/fdlibm/src/math_private.h
|
||||
--- a/modules/fdlibm/src/math_private.h
|
||||
+++ b/modules/fdlibm/src/math_private.h
|
||||
@@ -33,16 +33,21 @@
|
||||
* to dig two 32 bit words out of the 64 bit IEEE floating point
|
||||
* value. That is non-ANSI, and, moreover, the gcc instruction
|
||||
* scheduler gets it wrong. We instead use the following macros.
|
||||
* Unlike the original code, we determine the endianness at compile
|
||||
* time, not at run time; I don't see much benefit to selecting
|
||||
* endianness at run time.
|
||||
*/
|
||||
|
||||
+#ifdef WIN32
|
||||
+#define u_int32_t uint32_t
|
||||
+#define u_int64_t uint64_t
|
||||
+#endif
|
||||
+
|
||||
/*
|
||||
* A union which permits us to convert between a double and two 32 bit
|
||||
* ints.
|
||||
*/
|
||||
|
||||
#if MOZ_BIG_ENDIAN
|
||||
|
||||
typedef union
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
diff --git a/modules/fdlibm/src/math_private.h b/modules/fdlibm/src/math_private.h
|
||||
--- a/modules/fdlibm/src/math_private.h
|
||||
+++ b/modules/fdlibm/src/math_private.h
|
||||
@@ -285,16 +285,27 @@ do { \
|
||||
if (sizeof(type) >= sizeof(long double)) \
|
||||
(lval) = (rval); \
|
||||
else { \
|
||||
__lval = (rval); \
|
||||
(lval) = __lval; \
|
||||
} \
|
||||
} while (0)
|
||||
#endif
|
||||
+#else
|
||||
+#define STRICT_ASSIGN(type, lval, rval) do { \
|
||||
+ volatile type __lval; \
|
||||
+ \
|
||||
+ if (sizeof(type) >= sizeof(long double)) \
|
||||
+ (lval) = (rval); \
|
||||
+ else { \
|
||||
+ __lval = (rval); \
|
||||
+ (lval) = __lval; \
|
||||
+ } \
|
||||
+} while (0)
|
||||
#endif /* FLT_EVAL_METHOD */
|
||||
|
||||
/* Support switching the mode to FP_PE if necessary. */
|
||||
#if defined(__i386__) && !defined(NO_FPSETPREC)
|
||||
#define ENTERI() \
|
||||
long double __retval; \
|
||||
fp_prec_t __oprec; \
|
||||
\
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
diff --git a/modules/fdlibm/src/e_exp.cpp b/modules/fdlibm/src/e_exp.cpp
|
||||
--- a/modules/fdlibm/src/e_exp.cpp
|
||||
+++ b/modules/fdlibm/src/e_exp.cpp
|
||||
@@ -146,14 +146,17 @@ double
|
||||
if(k >= -1021)
|
||||
INSERT_WORDS(twopk,0x3ff00000+(k<<20), 0);
|
||||
else
|
||||
INSERT_WORDS(twopk,0x3ff00000+((k+1000)<<20), 0);
|
||||
c = x - t*(P1+t*(P2+t*(P3+t*(P4+t*P5))));
|
||||
if(k==0) return one-((x*c)/(c-2.0)-x);
|
||||
else y = one-((lo-(x*c)/(2.0-c))-hi);
|
||||
if(k >= -1021) {
|
||||
- if (k==1024) return y*2.0*0x1p1023;
|
||||
+ if (k==1024) {
|
||||
+ double const_0x1p1023 = pow(2, 1023);
|
||||
+ return y*2.0*const_0x1p1023;
|
||||
+ }
|
||||
return y*twopk;
|
||||
} else {
|
||||
return y*twopk*twom1000;
|
||||
}
|
||||
}
|
||||
diff --git a/modules/fdlibm/src/s_expm1.cpp b/modules/fdlibm/src/s_expm1.cpp
|
||||
--- a/modules/fdlibm/src/s_expm1.cpp
|
||||
+++ b/modules/fdlibm/src/s_expm1.cpp
|
||||
@@ -192,17 +192,20 @@ expm1(double x)
|
||||
e -= hxs;
|
||||
if(k== -1) return 0.5*(x-e)-0.5;
|
||||
if(k==1) {
|
||||
if(x < -0.25) return -2.0*(e-(x+0.5));
|
||||
else return one+2.0*(x-e);
|
||||
}
|
||||
if (k <= -2 || k>56) { /* suffice to return exp(x)-1 */
|
||||
y = one-(e-x);
|
||||
- if (k == 1024) y = y*2.0*0x1p1023;
|
||||
+ if (k == 1024) {
|
||||
+ double const_0x1p1023 = pow(2, 1023);
|
||||
+ y = y*2.0*const_0x1p1023;
|
||||
+ }
|
||||
else y = y*twopk;
|
||||
return y-one;
|
||||
}
|
||||
t = one;
|
||||
if(k<20) {
|
||||
SET_HIGH_WORD(t,0x3ff00000 - (0x200000>>k)); /* t=1-2^-k */
|
||||
y = t-(e-x);
|
||||
y = y*twopk;
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
diff --git a/modules/fdlibm/src/s_nearbyint.cpp b/modules/fdlibm/src/s_nearbyint.cpp
|
||||
--- a/modules/fdlibm/src/s_nearbyint.cpp
|
||||
+++ b/modules/fdlibm/src/s_nearbyint.cpp
|
||||
@@ -51,9 +51,8 @@ fn(type x) \
|
||||
fegetenv(&env); \
|
||||
ret = rint(x); \
|
||||
fesetenv(&env); \
|
||||
return (ret); \
|
||||
}
|
||||
|
||||
DECL(double, nearbyint, rint)
|
||||
DECL(float, nearbyintf, rintf)
|
||||
-DECL(long double, nearbyintl, rintl)
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
diff --git a/modules/fdlibm/src/math_private.h b/modules/fdlibm/src/math_private.h
|
||||
--- a/modules/fdlibm/src/math_private.h
|
||||
+++ b/modules/fdlibm/src/math_private.h
|
||||
@@ -271,17 +271,17 @@ do { \
|
||||
/* The above works on non-i386 too, but we use this to check v. */
|
||||
#define LD80C(m, ex, v) { .e = (v), }
|
||||
#endif
|
||||
|
||||
#ifdef FLT_EVAL_METHOD
|
||||
/*
|
||||
* Attempt to get strict C99 semantics for assignment with non-C99 compilers.
|
||||
*/
|
||||
-#if FLT_EVAL_METHOD == 0 || __GNUC__ == 0
|
||||
+#if !defined(_MSC_VER) && (FLT_EVAL_METHOD == 0 || __GNUC__ == 0)
|
||||
#define STRICT_ASSIGN(type, lval, rval) ((lval) = (rval))
|
||||
#else
|
||||
#define STRICT_ASSIGN(type, lval, rval) do { \
|
||||
volatile type __lval; \
|
||||
\
|
||||
if (sizeof(type) >= sizeof(long double)) \
|
||||
(lval) = (rval); \
|
||||
else { \
|
||||
|
||||
106
modules/fdlibm/src/e_acos.cpp
Normal file
106
modules/fdlibm/src/e_acos.cpp
Normal file
|
|
@ -0,0 +1,106 @@
|
|||
|
||||
/* @(#)e_acos.c 1.3 95/01/18 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* __ieee754_acos(x)
|
||||
* Method :
|
||||
* acos(x) = pi/2 - asin(x)
|
||||
* acos(-x) = pi/2 + asin(x)
|
||||
* For |x|<=0.5
|
||||
* acos(x) = pi/2 - (x + x*x^2*R(x^2)) (see asin.c)
|
||||
* For x>0.5
|
||||
* acos(x) = pi/2 - (pi/2 - 2asin(sqrt((1-x)/2)))
|
||||
* = 2asin(sqrt((1-x)/2))
|
||||
* = 2s + 2s*z*R(z) ...z=(1-x)/2, s=sqrt(z)
|
||||
* = 2f + (2c + 2s*z*R(z))
|
||||
* where f=hi part of s, and c = (z-f*f)/(s+f) is the correction term
|
||||
* for f so that f+c ~ sqrt(z).
|
||||
* For x<-0.5
|
||||
* acos(x) = pi - 2asin(sqrt((1-|x|)/2))
|
||||
* = pi - 0.5*(s+s*z*R(z)), where z=(1-|x|)/2,s=sqrt(z)
|
||||
*
|
||||
* Special cases:
|
||||
* if x is NaN, return x itself;
|
||||
* if |x|>1, return NaN with invalid signal.
|
||||
*
|
||||
* Function needed: sqrt
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const double
|
||||
one= 1.00000000000000000000e+00, /* 0x3FF00000, 0x00000000 */
|
||||
pi = 3.14159265358979311600e+00, /* 0x400921FB, 0x54442D18 */
|
||||
pio2_hi = 1.57079632679489655800e+00; /* 0x3FF921FB, 0x54442D18 */
|
||||
static volatile double
|
||||
pio2_lo = 6.12323399573676603587e-17; /* 0x3C91A626, 0x33145C07 */
|
||||
static const double
|
||||
pS0 = 1.66666666666666657415e-01, /* 0x3FC55555, 0x55555555 */
|
||||
pS1 = -3.25565818622400915405e-01, /* 0xBFD4D612, 0x03EB6F7D */
|
||||
pS2 = 2.01212532134862925881e-01, /* 0x3FC9C155, 0x0E884455 */
|
||||
pS3 = -4.00555345006794114027e-02, /* 0xBFA48228, 0xB5688F3B */
|
||||
pS4 = 7.91534994289814532176e-04, /* 0x3F49EFE0, 0x7501B288 */
|
||||
pS5 = 3.47933107596021167570e-05, /* 0x3F023DE1, 0x0DFDF709 */
|
||||
qS1 = -2.40339491173441421878e+00, /* 0xC0033A27, 0x1C8A2D4B */
|
||||
qS2 = 2.02094576023350569471e+00, /* 0x40002AE5, 0x9C598AC8 */
|
||||
qS3 = -6.88283971605453293030e-01, /* 0xBFE6066C, 0x1B8D0159 */
|
||||
qS4 = 7.70381505559019352791e-02; /* 0x3FB3B8C5, 0xB12E9282 */
|
||||
|
||||
double
|
||||
__ieee754_acos(double x)
|
||||
{
|
||||
double z,p,q,r,w,s,c,df;
|
||||
int32_t hx,ix;
|
||||
GET_HIGH_WORD(hx,x);
|
||||
ix = hx&0x7fffffff;
|
||||
if(ix>=0x3ff00000) { /* |x| >= 1 */
|
||||
u_int32_t lx;
|
||||
GET_LOW_WORD(lx,x);
|
||||
if(((ix-0x3ff00000)|lx)==0) { /* |x|==1 */
|
||||
if(hx>0) return 0.0; /* acos(1) = 0 */
|
||||
else return pi+2.0*pio2_lo; /* acos(-1)= pi */
|
||||
}
|
||||
return (x-x)/(x-x); /* acos(|x|>1) is NaN */
|
||||
}
|
||||
if(ix<0x3fe00000) { /* |x| < 0.5 */
|
||||
if(ix<=0x3c600000) return pio2_hi+pio2_lo;/*if|x|<2**-57*/
|
||||
z = x*x;
|
||||
p = z*(pS0+z*(pS1+z*(pS2+z*(pS3+z*(pS4+z*pS5)))));
|
||||
q = one+z*(qS1+z*(qS2+z*(qS3+z*qS4)));
|
||||
r = p/q;
|
||||
return pio2_hi - (x - (pio2_lo-x*r));
|
||||
} else if (hx<0) { /* x < -0.5 */
|
||||
z = (one+x)*0.5;
|
||||
p = z*(pS0+z*(pS1+z*(pS2+z*(pS3+z*(pS4+z*pS5)))));
|
||||
q = one+z*(qS1+z*(qS2+z*(qS3+z*qS4)));
|
||||
s = sqrt(z);
|
||||
r = p/q;
|
||||
w = r*s-pio2_lo;
|
||||
return pi - 2.0*(s+w);
|
||||
} else { /* x > 0.5 */
|
||||
z = (one-x)*0.5;
|
||||
s = sqrt(z);
|
||||
df = s;
|
||||
SET_LOW_WORD(df,0);
|
||||
c = (z-df*df)/(s+df);
|
||||
p = z*(pS0+z*(pS1+z*(pS2+z*(pS3+z*(pS4+z*pS5)))));
|
||||
q = one+z*(qS1+z*(qS2+z*(qS3+z*qS4)));
|
||||
r = p/q;
|
||||
w = r*s+c;
|
||||
return 2.0*(df+w);
|
||||
}
|
||||
}
|
||||
63
modules/fdlibm/src/e_acosh.cpp
Normal file
63
modules/fdlibm/src/e_acosh.cpp
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
|
||||
/* @(#)e_acosh.c 1.3 95/01/18 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* __ieee754_acosh(x)
|
||||
* Method :
|
||||
* Based on
|
||||
* acosh(x) = log [ x + sqrt(x*x-1) ]
|
||||
* we have
|
||||
* acosh(x) := log(x)+ln2, if x is large; else
|
||||
* acosh(x) := log(2x-1/(sqrt(x*x-1)+x)) if x>2; else
|
||||
* acosh(x) := log1p(t+sqrt(2.0*t+t*t)); where t=x-1.
|
||||
*
|
||||
* Special cases:
|
||||
* acosh(x) is NaN with signal if x<1.
|
||||
* acosh(NaN) is NaN without signal.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const double
|
||||
one = 1.0,
|
||||
ln2 = 6.93147180559945286227e-01; /* 0x3FE62E42, 0xFEFA39EF */
|
||||
|
||||
double
|
||||
__ieee754_acosh(double x)
|
||||
{
|
||||
double t;
|
||||
int32_t hx;
|
||||
u_int32_t lx;
|
||||
EXTRACT_WORDS(hx,lx,x);
|
||||
if(hx<0x3ff00000) { /* x < 1 */
|
||||
return (x-x)/(x-x);
|
||||
} else if(hx >=0x41b00000) { /* x > 2**28 */
|
||||
if(hx >=0x7ff00000) { /* x is inf of NaN */
|
||||
return x+x;
|
||||
} else
|
||||
return __ieee754_log(x)+ln2; /* acosh(huge)=log(2x) */
|
||||
} else if(((hx-0x3ff00000)|lx)==0) {
|
||||
return 0.0; /* acosh(1) = 0 */
|
||||
} else if (hx > 0x40000000) { /* 2**28 > x > 2 */
|
||||
t=x*x;
|
||||
return __ieee754_log(2.0*x-one/(x+sqrt(t-one)));
|
||||
} else { /* 1<x<2 */
|
||||
t = x-one;
|
||||
return log1p(t+sqrt(2.0*t+t*t));
|
||||
}
|
||||
}
|
||||
112
modules/fdlibm/src/e_asin.cpp
Normal file
112
modules/fdlibm/src/e_asin.cpp
Normal file
|
|
@ -0,0 +1,112 @@
|
|||
|
||||
/* @(#)e_asin.c 1.3 95/01/18 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* __ieee754_asin(x)
|
||||
* Method :
|
||||
* Since asin(x) = x + x^3/6 + x^5*3/40 + x^7*15/336 + ...
|
||||
* we approximate asin(x) on [0,0.5] by
|
||||
* asin(x) = x + x*x^2*R(x^2)
|
||||
* where
|
||||
* R(x^2) is a rational approximation of (asin(x)-x)/x^3
|
||||
* and its remez error is bounded by
|
||||
* |(asin(x)-x)/x^3 - R(x^2)| < 2^(-58.75)
|
||||
*
|
||||
* For x in [0.5,1]
|
||||
* asin(x) = pi/2-2*asin(sqrt((1-x)/2))
|
||||
* Let y = (1-x), z = y/2, s := sqrt(z), and pio2_hi+pio2_lo=pi/2;
|
||||
* then for x>0.98
|
||||
* asin(x) = pi/2 - 2*(s+s*z*R(z))
|
||||
* = pio2_hi - (2*(s+s*z*R(z)) - pio2_lo)
|
||||
* For x<=0.98, let pio4_hi = pio2_hi/2, then
|
||||
* f = hi part of s;
|
||||
* c = sqrt(z) - f = (z-f*f)/(s+f) ...f+c=sqrt(z)
|
||||
* and
|
||||
* asin(x) = pi/2 - 2*(s+s*z*R(z))
|
||||
* = pio4_hi+(pio4-2s)-(2s*z*R(z)-pio2_lo)
|
||||
* = pio4_hi+(pio4-2f)-(2s*z*R(z)-(pio2_lo+2c))
|
||||
*
|
||||
* Special cases:
|
||||
* if x is NaN, return x itself;
|
||||
* if |x|>1, return NaN with invalid signal.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const double
|
||||
one = 1.00000000000000000000e+00, /* 0x3FF00000, 0x00000000 */
|
||||
huge = 1.000e+300,
|
||||
pio2_hi = 1.57079632679489655800e+00, /* 0x3FF921FB, 0x54442D18 */
|
||||
pio2_lo = 6.12323399573676603587e-17, /* 0x3C91A626, 0x33145C07 */
|
||||
pio4_hi = 7.85398163397448278999e-01, /* 0x3FE921FB, 0x54442D18 */
|
||||
/* coefficient for R(x^2) */
|
||||
pS0 = 1.66666666666666657415e-01, /* 0x3FC55555, 0x55555555 */
|
||||
pS1 = -3.25565818622400915405e-01, /* 0xBFD4D612, 0x03EB6F7D */
|
||||
pS2 = 2.01212532134862925881e-01, /* 0x3FC9C155, 0x0E884455 */
|
||||
pS3 = -4.00555345006794114027e-02, /* 0xBFA48228, 0xB5688F3B */
|
||||
pS4 = 7.91534994289814532176e-04, /* 0x3F49EFE0, 0x7501B288 */
|
||||
pS5 = 3.47933107596021167570e-05, /* 0x3F023DE1, 0x0DFDF709 */
|
||||
qS1 = -2.40339491173441421878e+00, /* 0xC0033A27, 0x1C8A2D4B */
|
||||
qS2 = 2.02094576023350569471e+00, /* 0x40002AE5, 0x9C598AC8 */
|
||||
qS3 = -6.88283971605453293030e-01, /* 0xBFE6066C, 0x1B8D0159 */
|
||||
qS4 = 7.70381505559019352791e-02; /* 0x3FB3B8C5, 0xB12E9282 */
|
||||
|
||||
double
|
||||
__ieee754_asin(double x)
|
||||
{
|
||||
double t=0.0,w,p,q,c,r,s;
|
||||
int32_t hx,ix;
|
||||
GET_HIGH_WORD(hx,x);
|
||||
ix = hx&0x7fffffff;
|
||||
if(ix>= 0x3ff00000) { /* |x|>= 1 */
|
||||
u_int32_t lx;
|
||||
GET_LOW_WORD(lx,x);
|
||||
if(((ix-0x3ff00000)|lx)==0)
|
||||
/* asin(1)=+-pi/2 with inexact */
|
||||
return x*pio2_hi+x*pio2_lo;
|
||||
return (x-x)/(x-x); /* asin(|x|>1) is NaN */
|
||||
} else if (ix<0x3fe00000) { /* |x|<0.5 */
|
||||
if(ix<0x3e500000) { /* if |x| < 2**-26 */
|
||||
if(huge+x>one) return x;/* return x with inexact if x!=0*/
|
||||
}
|
||||
t = x*x;
|
||||
p = t*(pS0+t*(pS1+t*(pS2+t*(pS3+t*(pS4+t*pS5)))));
|
||||
q = one+t*(qS1+t*(qS2+t*(qS3+t*qS4)));
|
||||
w = p/q;
|
||||
return x+x*w;
|
||||
}
|
||||
/* 1> |x|>= 0.5 */
|
||||
w = one-fabs(x);
|
||||
t = w*0.5;
|
||||
p = t*(pS0+t*(pS1+t*(pS2+t*(pS3+t*(pS4+t*pS5)))));
|
||||
q = one+t*(qS1+t*(qS2+t*(qS3+t*qS4)));
|
||||
s = sqrt(t);
|
||||
if(ix>=0x3FEF3333) { /* if |x| > 0.975 */
|
||||
w = p/q;
|
||||
t = pio2_hi-(2.0*(s+s*w)-pio2_lo);
|
||||
} else {
|
||||
w = s;
|
||||
SET_LOW_WORD(w,0);
|
||||
c = (t-w*w)/(s+w);
|
||||
r = p/q;
|
||||
p = 2.0*s*r-(pio2_lo-2.0*c);
|
||||
q = pio4_hi-2.0*w;
|
||||
t = pio4_hi-(p-q);
|
||||
}
|
||||
if(hx>0) return t; else return -t;
|
||||
}
|
||||
124
modules/fdlibm/src/e_atan2.cpp
Normal file
124
modules/fdlibm/src/e_atan2.cpp
Normal file
|
|
@ -0,0 +1,124 @@
|
|||
|
||||
/* @(#)e_atan2.c 1.3 95/01/18 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* __ieee754_atan2(y,x)
|
||||
* Method :
|
||||
* 1. Reduce y to positive by atan2(y,x)=-atan2(-y,x).
|
||||
* 2. Reduce x to positive by (if x and y are unexceptional):
|
||||
* ARG (x+iy) = arctan(y/x) ... if x > 0,
|
||||
* ARG (x+iy) = pi - arctan[y/(-x)] ... if x < 0,
|
||||
*
|
||||
* Special cases:
|
||||
*
|
||||
* ATAN2((anything), NaN ) is NaN;
|
||||
* ATAN2(NAN , (anything) ) is NaN;
|
||||
* ATAN2(+-0, +(anything but NaN)) is +-0 ;
|
||||
* ATAN2(+-0, -(anything but NaN)) is +-pi ;
|
||||
* ATAN2(+-(anything but 0 and NaN), 0) is +-pi/2;
|
||||
* ATAN2(+-(anything but INF and NaN), +INF) is +-0 ;
|
||||
* ATAN2(+-(anything but INF and NaN), -INF) is +-pi;
|
||||
* ATAN2(+-INF,+INF ) is +-pi/4 ;
|
||||
* ATAN2(+-INF,-INF ) is +-3pi/4;
|
||||
* ATAN2(+-INF, (anything but,0,NaN, and INF)) is +-pi/2;
|
||||
*
|
||||
* Constants:
|
||||
* The hexadecimal values are the intended ones for the following
|
||||
* constants. The decimal values may be used, provided that the
|
||||
* compiler will convert from decimal to binary accurately enough
|
||||
* to produce the hexadecimal values shown.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static volatile double
|
||||
tiny = 1.0e-300;
|
||||
static const double
|
||||
zero = 0.0,
|
||||
pi_o_4 = 7.8539816339744827900E-01, /* 0x3FE921FB, 0x54442D18 */
|
||||
pi_o_2 = 1.5707963267948965580E+00, /* 0x3FF921FB, 0x54442D18 */
|
||||
pi = 3.1415926535897931160E+00; /* 0x400921FB, 0x54442D18 */
|
||||
static volatile double
|
||||
pi_lo = 1.2246467991473531772E-16; /* 0x3CA1A626, 0x33145C07 */
|
||||
|
||||
double
|
||||
__ieee754_atan2(double y, double x)
|
||||
{
|
||||
double z;
|
||||
int32_t k,m,hx,hy,ix,iy;
|
||||
u_int32_t lx,ly;
|
||||
|
||||
EXTRACT_WORDS(hx,lx,x);
|
||||
ix = hx&0x7fffffff;
|
||||
EXTRACT_WORDS(hy,ly,y);
|
||||
iy = hy&0x7fffffff;
|
||||
if(((ix|((lx|-lx)>>31))>0x7ff00000)||
|
||||
((iy|((ly|-ly)>>31))>0x7ff00000)) /* x or y is NaN */
|
||||
return x+y;
|
||||
if((hx-0x3ff00000|lx)==0) return atan(y); /* x=1.0 */
|
||||
m = ((hy>>31)&1)|((hx>>30)&2); /* 2*sign(x)+sign(y) */
|
||||
|
||||
/* when y = 0 */
|
||||
if((iy|ly)==0) {
|
||||
switch(m) {
|
||||
case 0:
|
||||
case 1: return y; /* atan(+-0,+anything)=+-0 */
|
||||
case 2: return pi+tiny;/* atan(+0,-anything) = pi */
|
||||
case 3: return -pi-tiny;/* atan(-0,-anything) =-pi */
|
||||
}
|
||||
}
|
||||
/* when x = 0 */
|
||||
if((ix|lx)==0) return (hy<0)? -pi_o_2-tiny: pi_o_2+tiny;
|
||||
|
||||
/* when x is INF */
|
||||
if(ix==0x7ff00000) {
|
||||
if(iy==0x7ff00000) {
|
||||
switch(m) {
|
||||
case 0: return pi_o_4+tiny;/* atan(+INF,+INF) */
|
||||
case 1: return -pi_o_4-tiny;/* atan(-INF,+INF) */
|
||||
case 2: return 3.0*pi_o_4+tiny;/*atan(+INF,-INF)*/
|
||||
case 3: return -3.0*pi_o_4-tiny;/*atan(-INF,-INF)*/
|
||||
}
|
||||
} else {
|
||||
switch(m) {
|
||||
case 0: return zero ; /* atan(+...,+INF) */
|
||||
case 1: return -zero ; /* atan(-...,+INF) */
|
||||
case 2: return pi+tiny ; /* atan(+...,-INF) */
|
||||
case 3: return -pi-tiny ; /* atan(-...,-INF) */
|
||||
}
|
||||
}
|
||||
}
|
||||
/* when y is INF */
|
||||
if(iy==0x7ff00000) return (hy<0)? -pi_o_2-tiny: pi_o_2+tiny;
|
||||
|
||||
/* compute y/x */
|
||||
k = (iy-ix)>>20;
|
||||
if(k > 60) { /* |y/x| > 2**60 */
|
||||
z=pi_o_2+0.5*pi_lo;
|
||||
m&=1;
|
||||
}
|
||||
else if(hx<0&&k<-60) z=0.0; /* 0 > |y|/x > -2**-60 */
|
||||
else z=atan(fabs(y/x)); /* safe to do y/x */
|
||||
switch (m) {
|
||||
case 0: return z ; /* atan(+,+) */
|
||||
case 1: return -z ; /* atan(-,+) */
|
||||
case 2: return pi-(z-pi_lo);/* atan(+,-) */
|
||||
default: /* case 3 */
|
||||
return (z-pi_lo)-pi;/* atan(-,-) */
|
||||
}
|
||||
}
|
||||
63
modules/fdlibm/src/e_atanh.cpp
Normal file
63
modules/fdlibm/src/e_atanh.cpp
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
|
||||
/* @(#)e_atanh.c 1.3 95/01/18 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* __ieee754_atanh(x)
|
||||
* Method :
|
||||
* 1.Reduced x to positive by atanh(-x) = -atanh(x)
|
||||
* 2.For x>=0.5
|
||||
* 1 2x x
|
||||
* atanh(x) = --- * log(1 + -------) = 0.5 * log1p(2 * --------)
|
||||
* 2 1 - x 1 - x
|
||||
*
|
||||
* For x<0.5
|
||||
* atanh(x) = 0.5*log1p(2x+2x*x/(1-x))
|
||||
*
|
||||
* Special cases:
|
||||
* atanh(x) is NaN if |x| > 1 with signal;
|
||||
* atanh(NaN) is that NaN with no signal;
|
||||
* atanh(+-1) is +-INF with signal.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const double one = 1.0, huge = 1e300;
|
||||
static const double zero = 0.0;
|
||||
|
||||
double
|
||||
__ieee754_atanh(double x)
|
||||
{
|
||||
double t;
|
||||
int32_t hx,ix;
|
||||
u_int32_t lx;
|
||||
EXTRACT_WORDS(hx,lx,x);
|
||||
ix = hx&0x7fffffff;
|
||||
if ((ix|((lx|(-lx))>>31))>0x3ff00000) /* |x|>1 */
|
||||
return (x-x)/(x-x);
|
||||
if(ix==0x3ff00000)
|
||||
return x/zero;
|
||||
if(ix<0x3e300000&&(huge+x)>zero) return x; /* x<2**-28 */
|
||||
SET_HIGH_WORD(x,ix);
|
||||
if(ix<0x3fe00000) { /* x < 0.5 */
|
||||
t = x+x;
|
||||
t = 0.5*log1p(t+t*x/(one-x));
|
||||
} else
|
||||
t = 0.5*log1p((x+x)/(one-x));
|
||||
if(hx>=0) return t; else return -t;
|
||||
}
|
||||
80
modules/fdlibm/src/e_cosh.cpp
Normal file
80
modules/fdlibm/src/e_cosh.cpp
Normal file
|
|
@ -0,0 +1,80 @@
|
|||
|
||||
/* @(#)e_cosh.c 1.3 95/01/18 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* __ieee754_cosh(x)
|
||||
* Method :
|
||||
* mathematically cosh(x) if defined to be (exp(x)+exp(-x))/2
|
||||
* 1. Replace x by |x| (cosh(x) = cosh(-x)).
|
||||
* 2.
|
||||
* [ exp(x) - 1 ]^2
|
||||
* 0 <= x <= ln2/2 : cosh(x) := 1 + -------------------
|
||||
* 2*exp(x)
|
||||
*
|
||||
* exp(x) + 1/exp(x)
|
||||
* ln2/2 <= x <= 22 : cosh(x) := -------------------
|
||||
* 2
|
||||
* 22 <= x <= lnovft : cosh(x) := exp(x)/2
|
||||
* lnovft <= x <= ln2ovft: cosh(x) := exp(x/2)/2 * exp(x/2)
|
||||
* ln2ovft < x : cosh(x) := huge*huge (overflow)
|
||||
*
|
||||
* Special cases:
|
||||
* cosh(x) is |x| if x is +INF, -INF, or NaN.
|
||||
* only cosh(0)=1 is exact for finite x.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const double one = 1.0, half=0.5, huge = 1.0e300;
|
||||
|
||||
double
|
||||
__ieee754_cosh(double x)
|
||||
{
|
||||
double t,w;
|
||||
int32_t ix;
|
||||
|
||||
/* High word of |x|. */
|
||||
GET_HIGH_WORD(ix,x);
|
||||
ix &= 0x7fffffff;
|
||||
|
||||
/* x is INF or NaN */
|
||||
if(ix>=0x7ff00000) return x*x;
|
||||
|
||||
/* |x| in [0,0.5*ln2], return 1+expm1(|x|)^2/(2*exp(|x|)) */
|
||||
if(ix<0x3fd62e43) {
|
||||
t = expm1(fabs(x));
|
||||
w = one+t;
|
||||
if (ix<0x3c800000) return w; /* cosh(tiny) = 1 */
|
||||
return one+(t*t)/(w+w);
|
||||
}
|
||||
|
||||
/* |x| in [0.5*ln2,22], return (exp(|x|)+1/exp(|x|)/2; */
|
||||
if (ix < 0x40360000) {
|
||||
t = __ieee754_exp(fabs(x));
|
||||
return half*t+half/t;
|
||||
}
|
||||
|
||||
/* |x| in [22, log(maxdouble)] return half*exp(|x|) */
|
||||
if (ix < 0x40862E42) return half*__ieee754_exp(fabs(x));
|
||||
|
||||
/* |x| in [log(maxdouble), overflowthresold] */
|
||||
if (ix<=0x408633CE)
|
||||
return __ldexp_exp(fabs(x), -1);
|
||||
|
||||
/* |x| > overflowthresold, cosh(x) overflow */
|
||||
return huge*huge;
|
||||
}
|
||||
162
modules/fdlibm/src/e_exp.cpp
Normal file
162
modules/fdlibm/src/e_exp.cpp
Normal file
|
|
@ -0,0 +1,162 @@
|
|||
|
||||
/* @(#)e_exp.c 1.6 04/04/22 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 2004 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* __ieee754_exp(x)
|
||||
* Returns the exponential of x.
|
||||
*
|
||||
* Method
|
||||
* 1. Argument reduction:
|
||||
* Reduce x to an r so that |r| <= 0.5*ln2 ~ 0.34658.
|
||||
* Given x, find r and integer k such that
|
||||
*
|
||||
* x = k*ln2 + r, |r| <= 0.5*ln2.
|
||||
*
|
||||
* Here r will be represented as r = hi-lo for better
|
||||
* accuracy.
|
||||
*
|
||||
* 2. Approximation of exp(r) by a special rational function on
|
||||
* the interval [0,0.34658]:
|
||||
* Write
|
||||
* R(r**2) = r*(exp(r)+1)/(exp(r)-1) = 2 + r*r/6 - r**4/360 + ...
|
||||
* We use a special Remes algorithm on [0,0.34658] to generate
|
||||
* a polynomial of degree 5 to approximate R. The maximum error
|
||||
* of this polynomial approximation is bounded by 2**-59. In
|
||||
* other words,
|
||||
* R(z) ~ 2.0 + P1*z + P2*z**2 + P3*z**3 + P4*z**4 + P5*z**5
|
||||
* (where z=r*r, and the values of P1 to P5 are listed below)
|
||||
* and
|
||||
* | 5 | -59
|
||||
* | 2.0+P1*z+...+P5*z - R(z) | <= 2
|
||||
* | |
|
||||
* The computation of exp(r) thus becomes
|
||||
* 2*r
|
||||
* exp(r) = 1 + -------
|
||||
* R - r
|
||||
* r*R1(r)
|
||||
* = 1 + r + ----------- (for better accuracy)
|
||||
* 2 - R1(r)
|
||||
* where
|
||||
* 2 4 10
|
||||
* R1(r) = r - (P1*r + P2*r + ... + P5*r ).
|
||||
*
|
||||
* 3. Scale back to obtain exp(x):
|
||||
* From step 1, we have
|
||||
* exp(x) = 2^k * exp(r)
|
||||
*
|
||||
* Special cases:
|
||||
* exp(INF) is INF, exp(NaN) is NaN;
|
||||
* exp(-INF) is 0, and
|
||||
* for finite argument, only exp(0)=1 is exact.
|
||||
*
|
||||
* Accuracy:
|
||||
* according to an error analysis, the error is always less than
|
||||
* 1 ulp (unit in the last place).
|
||||
*
|
||||
* Misc. info.
|
||||
* For IEEE double
|
||||
* if x > 7.09782712893383973096e+02 then exp(x) overflow
|
||||
* if x < -7.45133219101941108420e+02 then exp(x) underflow
|
||||
*
|
||||
* Constants:
|
||||
* The hexadecimal values are the intended ones for the following
|
||||
* constants. The decimal values may be used, provided that the
|
||||
* compiler will convert from decimal to binary accurately enough
|
||||
* to produce the hexadecimal values shown.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const double
|
||||
one = 1.0,
|
||||
halF[2] = {0.5,-0.5,},
|
||||
o_threshold= 7.09782712893383973096e+02, /* 0x40862E42, 0xFEFA39EF */
|
||||
u_threshold= -7.45133219101941108420e+02, /* 0xc0874910, 0xD52D3051 */
|
||||
ln2HI[2] ={ 6.93147180369123816490e-01, /* 0x3fe62e42, 0xfee00000 */
|
||||
-6.93147180369123816490e-01,},/* 0xbfe62e42, 0xfee00000 */
|
||||
ln2LO[2] ={ 1.90821492927058770002e-10, /* 0x3dea39ef, 0x35793c76 */
|
||||
-1.90821492927058770002e-10,},/* 0xbdea39ef, 0x35793c76 */
|
||||
invln2 = 1.44269504088896338700e+00, /* 0x3ff71547, 0x652b82fe */
|
||||
P1 = 1.66666666666666019037e-01, /* 0x3FC55555, 0x5555553E */
|
||||
P2 = -2.77777777770155933842e-03, /* 0xBF66C16C, 0x16BEBD93 */
|
||||
P3 = 6.61375632143793436117e-05, /* 0x3F11566A, 0xAF25DE2C */
|
||||
P4 = -1.65339022054652515390e-06, /* 0xBEBBBD41, 0xC5D26BF1 */
|
||||
P5 = 4.13813679705723846039e-08; /* 0x3E663769, 0x72BEA4D0 */
|
||||
|
||||
static volatile double
|
||||
huge = 1.0e+300,
|
||||
twom1000= 9.33263618503218878990e-302; /* 2**-1000=0x01700000,0*/
|
||||
|
||||
double
|
||||
__ieee754_exp(double x) /* default IEEE double exp */
|
||||
{
|
||||
double y,hi=0.0,lo=0.0,c,t,twopk;
|
||||
int32_t k=0,xsb;
|
||||
u_int32_t hx;
|
||||
|
||||
GET_HIGH_WORD(hx,x);
|
||||
xsb = (hx>>31)&1; /* sign bit of x */
|
||||
hx &= 0x7fffffff; /* high word of |x| */
|
||||
|
||||
/* filter out non-finite argument */
|
||||
if(hx >= 0x40862E42) { /* if |x|>=709.78... */
|
||||
if(hx>=0x7ff00000) {
|
||||
u_int32_t lx;
|
||||
GET_LOW_WORD(lx,x);
|
||||
if(((hx&0xfffff)|lx)!=0)
|
||||
return x+x; /* NaN */
|
||||
else return (xsb==0)? x:0.0; /* exp(+-inf)={inf,0} */
|
||||
}
|
||||
if(x > o_threshold) return huge*huge; /* overflow */
|
||||
if(x < u_threshold) return twom1000*twom1000; /* underflow */
|
||||
}
|
||||
|
||||
/* argument reduction */
|
||||
if(hx > 0x3fd62e42) { /* if |x| > 0.5 ln2 */
|
||||
if(hx < 0x3FF0A2B2) { /* and |x| < 1.5 ln2 */
|
||||
hi = x-ln2HI[xsb]; lo=ln2LO[xsb]; k = 1-xsb-xsb;
|
||||
} else {
|
||||
k = (int)(invln2*x+halF[xsb]);
|
||||
t = k;
|
||||
hi = x - t*ln2HI[0]; /* t*ln2HI is exact here */
|
||||
lo = t*ln2LO[0];
|
||||
}
|
||||
STRICT_ASSIGN(double, x, hi - lo);
|
||||
}
|
||||
else if(hx < 0x3e300000) { /* when |x|<2**-28 */
|
||||
if(huge+x>one) return one+x;/* trigger inexact */
|
||||
}
|
||||
else k = 0;
|
||||
|
||||
/* x is now in primary range */
|
||||
t = x*x;
|
||||
if(k >= -1021)
|
||||
INSERT_WORDS(twopk,0x3ff00000+(k<<20), 0);
|
||||
else
|
||||
INSERT_WORDS(twopk,0x3ff00000+((k+1000)<<20), 0);
|
||||
c = x - t*(P1+t*(P2+t*(P3+t*(P4+t*P5))));
|
||||
if(k==0) return one-((x*c)/(c-2.0)-x);
|
||||
else y = one-((lo-(x*c)/(2.0-c))-hi);
|
||||
if(k >= -1021) {
|
||||
if (k==1024) {
|
||||
double const_0x1p1023 = pow(2, 1023);
|
||||
return y*2.0*const_0x1p1023;
|
||||
}
|
||||
return y*twopk;
|
||||
} else {
|
||||
return y*twopk*twom1000;
|
||||
}
|
||||
}
|
||||
126
modules/fdlibm/src/e_hypot.cpp
Normal file
126
modules/fdlibm/src/e_hypot.cpp
Normal file
|
|
@ -0,0 +1,126 @@
|
|||
|
||||
/* @(#)e_hypot.c 1.3 95/01/18 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* __ieee754_hypot(x,y)
|
||||
*
|
||||
* Method :
|
||||
* If (assume round-to-nearest) z=x*x+y*y
|
||||
* has error less than sqrt(2)/2 ulp, than
|
||||
* sqrt(z) has error less than 1 ulp (exercise).
|
||||
*
|
||||
* So, compute sqrt(x*x+y*y) with some care as
|
||||
* follows to get the error below 1 ulp:
|
||||
*
|
||||
* Assume x>y>0;
|
||||
* (if possible, set rounding to round-to-nearest)
|
||||
* 1. if x > 2y use
|
||||
* x1*x1+(y*y+(x2*(x+x1))) for x*x+y*y
|
||||
* where x1 = x with lower 32 bits cleared, x2 = x-x1; else
|
||||
* 2. if x <= 2y use
|
||||
* t1*y1+((x-y)*(x-y)+(t1*y2+t2*y))
|
||||
* where t1 = 2x with lower 32 bits cleared, t2 = 2x-t1,
|
||||
* y1= y with lower 32 bits chopped, y2 = y-y1.
|
||||
*
|
||||
* NOTE: scaling may be necessary if some argument is too
|
||||
* large or too tiny
|
||||
*
|
||||
* Special cases:
|
||||
* hypot(x,y) is INF if x or y is +INF or -INF; else
|
||||
* hypot(x,y) is NAN if x or y is NAN.
|
||||
*
|
||||
* Accuracy:
|
||||
* hypot(x,y) returns sqrt(x^2+y^2) with error less
|
||||
* than 1 ulps (units in the last place)
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
double
|
||||
__ieee754_hypot(double x, double y)
|
||||
{
|
||||
double a,b,t1,t2,y1,y2,w;
|
||||
int32_t j,k,ha,hb;
|
||||
|
||||
GET_HIGH_WORD(ha,x);
|
||||
ha &= 0x7fffffff;
|
||||
GET_HIGH_WORD(hb,y);
|
||||
hb &= 0x7fffffff;
|
||||
if(hb > ha) {a=y;b=x;j=ha; ha=hb;hb=j;} else {a=x;b=y;}
|
||||
a = fabs(a);
|
||||
b = fabs(b);
|
||||
if((ha-hb)>0x3c00000) {return a+b;} /* x/y > 2**60 */
|
||||
k=0;
|
||||
if(ha > 0x5f300000) { /* a>2**500 */
|
||||
if(ha >= 0x7ff00000) { /* Inf or NaN */
|
||||
u_int32_t low;
|
||||
/* Use original arg order iff result is NaN; quieten sNaNs. */
|
||||
w = fabs(x+0.0)-fabs(y+0.0);
|
||||
GET_LOW_WORD(low,a);
|
||||
if(((ha&0xfffff)|low)==0) w = a;
|
||||
GET_LOW_WORD(low,b);
|
||||
if(((hb^0x7ff00000)|low)==0) w = b;
|
||||
return w;
|
||||
}
|
||||
/* scale a and b by 2**-600 */
|
||||
ha -= 0x25800000; hb -= 0x25800000; k += 600;
|
||||
SET_HIGH_WORD(a,ha);
|
||||
SET_HIGH_WORD(b,hb);
|
||||
}
|
||||
if(hb < 0x20b00000) { /* b < 2**-500 */
|
||||
if(hb <= 0x000fffff) { /* subnormal b or 0 */
|
||||
u_int32_t low;
|
||||
GET_LOW_WORD(low,b);
|
||||
if((hb|low)==0) return a;
|
||||
t1=0;
|
||||
SET_HIGH_WORD(t1,0x7fd00000); /* t1=2^1022 */
|
||||
b *= t1;
|
||||
a *= t1;
|
||||
k -= 1022;
|
||||
} else { /* scale a and b by 2^600 */
|
||||
ha += 0x25800000; /* a *= 2^600 */
|
||||
hb += 0x25800000; /* b *= 2^600 */
|
||||
k -= 600;
|
||||
SET_HIGH_WORD(a,ha);
|
||||
SET_HIGH_WORD(b,hb);
|
||||
}
|
||||
}
|
||||
/* medium size a and b */
|
||||
w = a-b;
|
||||
if (w>b) {
|
||||
t1 = 0;
|
||||
SET_HIGH_WORD(t1,ha);
|
||||
t2 = a-t1;
|
||||
w = sqrt(t1*t1-(b*(-b)-t2*(a+t1)));
|
||||
} else {
|
||||
a = a+a;
|
||||
y1 = 0;
|
||||
SET_HIGH_WORD(y1,hb);
|
||||
y2 = b - y1;
|
||||
t1 = 0;
|
||||
SET_HIGH_WORD(t1,ha+0x00100000);
|
||||
t2 = a - t1;
|
||||
w = sqrt(t1*y1-(w*(-w)-(t1*y2+t2*b)));
|
||||
}
|
||||
if(k!=0) {
|
||||
u_int32_t high;
|
||||
t1 = 1.0;
|
||||
GET_HIGH_WORD(high,t1);
|
||||
SET_HIGH_WORD(t1,high+(k<<20));
|
||||
return t1*w;
|
||||
} else return w;
|
||||
}
|
||||
142
modules/fdlibm/src/e_log.cpp
Normal file
142
modules/fdlibm/src/e_log.cpp
Normal file
|
|
@ -0,0 +1,142 @@
|
|||
|
||||
/* @(#)e_log.c 1.3 95/01/18 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* __ieee754_log(x)
|
||||
* Return the logrithm of x
|
||||
*
|
||||
* Method :
|
||||
* 1. Argument Reduction: find k and f such that
|
||||
* x = 2^k * (1+f),
|
||||
* where sqrt(2)/2 < 1+f < sqrt(2) .
|
||||
*
|
||||
* 2. Approximation of log(1+f).
|
||||
* Let s = f/(2+f) ; based on log(1+f) = log(1+s) - log(1-s)
|
||||
* = 2s + 2/3 s**3 + 2/5 s**5 + .....,
|
||||
* = 2s + s*R
|
||||
* We use a special Reme algorithm on [0,0.1716] to generate
|
||||
* a polynomial of degree 14 to approximate R The maximum error
|
||||
* of this polynomial approximation is bounded by 2**-58.45. In
|
||||
* other words,
|
||||
* 2 4 6 8 10 12 14
|
||||
* R(z) ~ Lg1*s +Lg2*s +Lg3*s +Lg4*s +Lg5*s +Lg6*s +Lg7*s
|
||||
* (the values of Lg1 to Lg7 are listed in the program)
|
||||
* and
|
||||
* | 2 14 | -58.45
|
||||
* | Lg1*s +...+Lg7*s - R(z) | <= 2
|
||||
* | |
|
||||
* Note that 2s = f - s*f = f - hfsq + s*hfsq, where hfsq = f*f/2.
|
||||
* In order to guarantee error in log below 1ulp, we compute log
|
||||
* by
|
||||
* log(1+f) = f - s*(f - R) (if f is not too large)
|
||||
* log(1+f) = f - (hfsq - s*(hfsq+R)). (better accuracy)
|
||||
*
|
||||
* 3. Finally, log(x) = k*ln2 + log(1+f).
|
||||
* = k*ln2_hi+(f-(hfsq-(s*(hfsq+R)+k*ln2_lo)))
|
||||
* Here ln2 is split into two floating point number:
|
||||
* ln2_hi + ln2_lo,
|
||||
* where n*ln2_hi is always exact for |n| < 2000.
|
||||
*
|
||||
* Special cases:
|
||||
* log(x) is NaN with signal if x < 0 (including -INF) ;
|
||||
* log(+INF) is +INF; log(0) is -INF with signal;
|
||||
* log(NaN) is that NaN with no signal.
|
||||
*
|
||||
* Accuracy:
|
||||
* according to an error analysis, the error is always less than
|
||||
* 1 ulp (unit in the last place).
|
||||
*
|
||||
* Constants:
|
||||
* The hexadecimal values are the intended ones for the following
|
||||
* constants. The decimal values may be used, provided that the
|
||||
* compiler will convert from decimal to binary accurately enough
|
||||
* to produce the hexadecimal values shown.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const double
|
||||
ln2_hi = 6.93147180369123816490e-01, /* 3fe62e42 fee00000 */
|
||||
ln2_lo = 1.90821492927058770002e-10, /* 3dea39ef 35793c76 */
|
||||
two54 = 1.80143985094819840000e+16, /* 43500000 00000000 */
|
||||
Lg1 = 6.666666666666735130e-01, /* 3FE55555 55555593 */
|
||||
Lg2 = 3.999999999940941908e-01, /* 3FD99999 9997FA04 */
|
||||
Lg3 = 2.857142874366239149e-01, /* 3FD24924 94229359 */
|
||||
Lg4 = 2.222219843214978396e-01, /* 3FCC71C5 1D8E78AF */
|
||||
Lg5 = 1.818357216161805012e-01, /* 3FC74664 96CB03DE */
|
||||
Lg6 = 1.531383769920937332e-01, /* 3FC39A09 D078C69F */
|
||||
Lg7 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */
|
||||
|
||||
static const double zero = 0.0;
|
||||
static volatile double vzero = 0.0;
|
||||
|
||||
double
|
||||
__ieee754_log(double x)
|
||||
{
|
||||
double hfsq,f,s,z,R,w,t1,t2,dk;
|
||||
int32_t k,hx,i,j;
|
||||
u_int32_t lx;
|
||||
|
||||
EXTRACT_WORDS(hx,lx,x);
|
||||
|
||||
k=0;
|
||||
if (hx < 0x00100000) { /* x < 2**-1022 */
|
||||
if (((hx&0x7fffffff)|lx)==0)
|
||||
return -two54/vzero; /* log(+-0)=-inf */
|
||||
if (hx<0) return (x-x)/zero; /* log(-#) = NaN */
|
||||
k -= 54; x *= two54; /* subnormal number, scale up x */
|
||||
GET_HIGH_WORD(hx,x);
|
||||
}
|
||||
if (hx >= 0x7ff00000) return x+x;
|
||||
k += (hx>>20)-1023;
|
||||
hx &= 0x000fffff;
|
||||
i = (hx+0x95f64)&0x100000;
|
||||
SET_HIGH_WORD(x,hx|(i^0x3ff00000)); /* normalize x or x/2 */
|
||||
k += (i>>20);
|
||||
f = x-1.0;
|
||||
if((0x000fffff&(2+hx))<3) { /* -2**-20 <= f < 2**-20 */
|
||||
if(f==zero) {
|
||||
if(k==0) {
|
||||
return zero;
|
||||
} else {
|
||||
dk=(double)k;
|
||||
return dk*ln2_hi+dk*ln2_lo;
|
||||
}
|
||||
}
|
||||
R = f*f*(0.5-0.33333333333333333*f);
|
||||
if(k==0) return f-R; else {dk=(double)k;
|
||||
return dk*ln2_hi-((R-dk*ln2_lo)-f);}
|
||||
}
|
||||
s = f/(2.0+f);
|
||||
dk = (double)k;
|
||||
z = s*s;
|
||||
i = hx-0x6147a;
|
||||
w = z*z;
|
||||
j = 0x6b851-hx;
|
||||
t1= w*(Lg2+w*(Lg4+w*Lg6));
|
||||
t2= z*(Lg1+w*(Lg3+w*(Lg5+w*Lg7)));
|
||||
i |= j;
|
||||
R = t2+t1;
|
||||
if(i>0) {
|
||||
hfsq=0.5*f*f;
|
||||
if(k==0) return f-(hfsq-s*(hfsq+R)); else
|
||||
return dk*ln2_hi-((hfsq-(s*(hfsq+R)+dk*ln2_lo))-f);
|
||||
} else {
|
||||
if(k==0) return f-s*(f-R); else
|
||||
return dk*ln2_hi-((s*(f-R)-dk*ln2_lo)-f);
|
||||
}
|
||||
}
|
||||
89
modules/fdlibm/src/e_log10.cpp
Normal file
89
modules/fdlibm/src/e_log10.cpp
Normal file
|
|
@ -0,0 +1,89 @@
|
|||
|
||||
/* @(#)e_log10.c 1.3 95/01/18 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
* Return the base 10 logarithm of x. See e_log.c and k_log.h for most
|
||||
* comments.
|
||||
*
|
||||
* log10(x) = (f - 0.5*f*f + k_log1p(f)) / ln10 + k * log10(2)
|
||||
* in not-quite-routine extra precision.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
#include "math_private.h"
|
||||
#include "k_log.h"
|
||||
|
||||
static const double
|
||||
two54 = 1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */
|
||||
ivln10hi = 4.34294481878168880939e-01, /* 0x3fdbcb7b, 0x15200000 */
|
||||
ivln10lo = 2.50829467116452752298e-11, /* 0x3dbb9438, 0xca9aadd5 */
|
||||
log10_2hi = 3.01029995663611771306e-01, /* 0x3FD34413, 0x509F6000 */
|
||||
log10_2lo = 3.69423907715893078616e-13; /* 0x3D59FEF3, 0x11F12B36 */
|
||||
|
||||
static const double zero = 0.0;
|
||||
static volatile double vzero = 0.0;
|
||||
|
||||
double
|
||||
__ieee754_log10(double x)
|
||||
{
|
||||
double f,hfsq,hi,lo,r,val_hi,val_lo,w,y,y2;
|
||||
int32_t i,k,hx;
|
||||
u_int32_t lx;
|
||||
|
||||
EXTRACT_WORDS(hx,lx,x);
|
||||
|
||||
k=0;
|
||||
if (hx < 0x00100000) { /* x < 2**-1022 */
|
||||
if (((hx&0x7fffffff)|lx)==0)
|
||||
return -two54/vzero; /* log(+-0)=-inf */
|
||||
if (hx<0) return (x-x)/zero; /* log(-#) = NaN */
|
||||
k -= 54; x *= two54; /* subnormal number, scale up x */
|
||||
GET_HIGH_WORD(hx,x);
|
||||
}
|
||||
if (hx >= 0x7ff00000) return x+x;
|
||||
if (hx == 0x3ff00000 && lx == 0)
|
||||
return zero; /* log(1) = +0 */
|
||||
k += (hx>>20)-1023;
|
||||
hx &= 0x000fffff;
|
||||
i = (hx+0x95f64)&0x100000;
|
||||
SET_HIGH_WORD(x,hx|(i^0x3ff00000)); /* normalize x or x/2 */
|
||||
k += (i>>20);
|
||||
y = (double)k;
|
||||
f = x - 1.0;
|
||||
hfsq = 0.5*f*f;
|
||||
r = k_log1p(f);
|
||||
|
||||
/* See e_log2.c for most details. */
|
||||
hi = f - hfsq;
|
||||
SET_LOW_WORD(hi,0);
|
||||
lo = (f - hi) - hfsq + r;
|
||||
val_hi = hi*ivln10hi;
|
||||
y2 = y*log10_2hi;
|
||||
val_lo = y*log10_2lo + (lo+hi)*ivln10lo + lo*ivln10hi;
|
||||
|
||||
/*
|
||||
* Extra precision in for adding y*log10_2hi is not strictly needed
|
||||
* since there is no very large cancellation near x = sqrt(2) or
|
||||
* x = 1/sqrt(2), but we do it anyway since it costs little on CPUs
|
||||
* with some parallelism and it reduces the error for many args.
|
||||
*/
|
||||
w = y2 + val_hi;
|
||||
val_lo += (y2 - w) + val_hi;
|
||||
val_hi = w;
|
||||
|
||||
return val_lo + val_hi;
|
||||
}
|
||||
112
modules/fdlibm/src/e_log2.cpp
Normal file
112
modules/fdlibm/src/e_log2.cpp
Normal file
|
|
@ -0,0 +1,112 @@
|
|||
|
||||
/* @(#)e_log10.c 1.3 95/01/18 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
* Return the base 2 logarithm of x. See e_log.c and k_log.h for most
|
||||
* comments.
|
||||
*
|
||||
* This reduces x to {k, 1+f} exactly as in e_log.c, then calls the kernel,
|
||||
* then does the combining and scaling steps
|
||||
* log2(x) = (f - 0.5*f*f + k_log1p(f)) / ln2 + k
|
||||
* in not-quite-routine extra precision.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
#include "math_private.h"
|
||||
#include "k_log.h"
|
||||
|
||||
static const double
|
||||
two54 = 1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */
|
||||
ivln2hi = 1.44269504072144627571e+00, /* 0x3ff71547, 0x65200000 */
|
||||
ivln2lo = 1.67517131648865118353e-10; /* 0x3de705fc, 0x2eefa200 */
|
||||
|
||||
static const double zero = 0.0;
|
||||
static volatile double vzero = 0.0;
|
||||
|
||||
double
|
||||
__ieee754_log2(double x)
|
||||
{
|
||||
double f,hfsq,hi,lo,r,val_hi,val_lo,w,y;
|
||||
int32_t i,k,hx;
|
||||
u_int32_t lx;
|
||||
|
||||
EXTRACT_WORDS(hx,lx,x);
|
||||
|
||||
k=0;
|
||||
if (hx < 0x00100000) { /* x < 2**-1022 */
|
||||
if (((hx&0x7fffffff)|lx)==0)
|
||||
return -two54/vzero; /* log(+-0)=-inf */
|
||||
if (hx<0) return (x-x)/zero; /* log(-#) = NaN */
|
||||
k -= 54; x *= two54; /* subnormal number, scale up x */
|
||||
GET_HIGH_WORD(hx,x);
|
||||
}
|
||||
if (hx >= 0x7ff00000) return x+x;
|
||||
if (hx == 0x3ff00000 && lx == 0)
|
||||
return zero; /* log(1) = +0 */
|
||||
k += (hx>>20)-1023;
|
||||
hx &= 0x000fffff;
|
||||
i = (hx+0x95f64)&0x100000;
|
||||
SET_HIGH_WORD(x,hx|(i^0x3ff00000)); /* normalize x or x/2 */
|
||||
k += (i>>20);
|
||||
y = (double)k;
|
||||
f = x - 1.0;
|
||||
hfsq = 0.5*f*f;
|
||||
r = k_log1p(f);
|
||||
|
||||
/*
|
||||
* f-hfsq must (for args near 1) be evaluated in extra precision
|
||||
* to avoid a large cancellation when x is near sqrt(2) or 1/sqrt(2).
|
||||
* This is fairly efficient since f-hfsq only depends on f, so can
|
||||
* be evaluated in parallel with R. Not combining hfsq with R also
|
||||
* keeps R small (though not as small as a true `lo' term would be),
|
||||
* so that extra precision is not needed for terms involving R.
|
||||
*
|
||||
* Compiler bugs involving extra precision used to break Dekker's
|
||||
* theorem for spitting f-hfsq as hi+lo, unless double_t was used
|
||||
* or the multi-precision calculations were avoided when double_t
|
||||
* has extra precision. These problems are now automatically
|
||||
* avoided as a side effect of the optimization of combining the
|
||||
* Dekker splitting step with the clear-low-bits step.
|
||||
*
|
||||
* y must (for args near sqrt(2) and 1/sqrt(2)) be added in extra
|
||||
* precision to avoid a very large cancellation when x is very near
|
||||
* these values. Unlike the above cancellations, this problem is
|
||||
* specific to base 2. It is strange that adding +-1 is so much
|
||||
* harder than adding +-ln2 or +-log10_2.
|
||||
*
|
||||
* This uses Dekker's theorem to normalize y+val_hi, so the
|
||||
* compiler bugs are back in some configurations, sigh. And I
|
||||
* don't want to used double_t to avoid them, since that gives a
|
||||
* pessimization and the support for avoiding the pessimization
|
||||
* is not yet available.
|
||||
*
|
||||
* The multi-precision calculations for the multiplications are
|
||||
* routine.
|
||||
*/
|
||||
hi = f - hfsq;
|
||||
SET_LOW_WORD(hi,0);
|
||||
lo = (f - hi) - hfsq + r;
|
||||
val_hi = hi*ivln2hi;
|
||||
val_lo = (lo+hi)*ivln2lo + lo*ivln2hi;
|
||||
|
||||
/* spadd(val_hi, val_lo, y), except for not using double_t: */
|
||||
w = y + val_hi;
|
||||
val_lo += (y - w) + val_hi;
|
||||
val_hi = w;
|
||||
|
||||
return val_lo + val_hi;
|
||||
}
|
||||
305
modules/fdlibm/src/e_pow.cpp
Normal file
305
modules/fdlibm/src/e_pow.cpp
Normal file
|
|
@ -0,0 +1,305 @@
|
|||
/* @(#)e_pow.c 1.5 04/04/22 SMI */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 2004 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* __ieee754_pow(x,y) return x**y
|
||||
*
|
||||
* n
|
||||
* Method: Let x = 2 * (1+f)
|
||||
* 1. Compute and return log2(x) in two pieces:
|
||||
* log2(x) = w1 + w2,
|
||||
* where w1 has 53-24 = 29 bit trailing zeros.
|
||||
* 2. Perform y*log2(x) = n+y' by simulating multi-precision
|
||||
* arithmetic, where |y'|<=0.5.
|
||||
* 3. Return x**y = 2**n*exp(y'*log2)
|
||||
*
|
||||
* Special cases:
|
||||
* 1. (anything) ** 0 is 1
|
||||
* 2. (anything) ** 1 is itself
|
||||
* 3. (anything) ** NAN is NAN except 1 ** NAN = 1
|
||||
* 4. NAN ** (anything except 0) is NAN
|
||||
* 5. +-(|x| > 1) ** +INF is +INF
|
||||
* 6. +-(|x| > 1) ** -INF is +0
|
||||
* 7. +-(|x| < 1) ** +INF is +0
|
||||
* 8. +-(|x| < 1) ** -INF is +INF
|
||||
* 9. +-1 ** +-INF is 1
|
||||
* 10. +0 ** (+anything except 0, NAN) is +0
|
||||
* 11. -0 ** (+anything except 0, NAN, odd integer) is +0
|
||||
* 12. +0 ** (-anything except 0, NAN) is +INF
|
||||
* 13. -0 ** (-anything except 0, NAN, odd integer) is +INF
|
||||
* 14. -0 ** (odd integer) = -( +0 ** (odd integer) )
|
||||
* 15. +INF ** (+anything except 0,NAN) is +INF
|
||||
* 16. +INF ** (-anything except 0,NAN) is +0
|
||||
* 17. -INF ** (anything) = -0 ** (-anything)
|
||||
* 18. (-anything) ** (integer) is (-1)**(integer)*(+anything**integer)
|
||||
* 19. (-anything except 0 and inf) ** (non-integer) is NAN
|
||||
*
|
||||
* Accuracy:
|
||||
* pow(x,y) returns x**y nearly rounded. In particular
|
||||
* pow(integer,integer)
|
||||
* always returns the correct integer provided it is
|
||||
* representable.
|
||||
*
|
||||
* Constants :
|
||||
* The hexadecimal values are the intended ones for the following
|
||||
* constants. The decimal values may be used, provided that the
|
||||
* compiler will convert from decimal to binary accurately enough
|
||||
* to produce the hexadecimal values shown.
|
||||
*/
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const double
|
||||
bp[] = {1.0, 1.5,},
|
||||
dp_h[] = { 0.0, 5.84962487220764160156e-01,}, /* 0x3FE2B803, 0x40000000 */
|
||||
dp_l[] = { 0.0, 1.35003920212974897128e-08,}, /* 0x3E4CFDEB, 0x43CFD006 */
|
||||
zero = 0.0,
|
||||
one = 1.0,
|
||||
two = 2.0,
|
||||
two53 = 9007199254740992.0, /* 0x43400000, 0x00000000 */
|
||||
huge = 1.0e300,
|
||||
tiny = 1.0e-300,
|
||||
/* poly coefs for (3/2)*(log(x)-2s-2/3*s**3 */
|
||||
L1 = 5.99999999999994648725e-01, /* 0x3FE33333, 0x33333303 */
|
||||
L2 = 4.28571428578550184252e-01, /* 0x3FDB6DB6, 0xDB6FABFF */
|
||||
L3 = 3.33333329818377432918e-01, /* 0x3FD55555, 0x518F264D */
|
||||
L4 = 2.72728123808534006489e-01, /* 0x3FD17460, 0xA91D4101 */
|
||||
L5 = 2.30660745775561754067e-01, /* 0x3FCD864A, 0x93C9DB65 */
|
||||
L6 = 2.06975017800338417784e-01, /* 0x3FCA7E28, 0x4A454EEF */
|
||||
P1 = 1.66666666666666019037e-01, /* 0x3FC55555, 0x5555553E */
|
||||
P2 = -2.77777777770155933842e-03, /* 0xBF66C16C, 0x16BEBD93 */
|
||||
P3 = 6.61375632143793436117e-05, /* 0x3F11566A, 0xAF25DE2C */
|
||||
P4 = -1.65339022054652515390e-06, /* 0xBEBBBD41, 0xC5D26BF1 */
|
||||
P5 = 4.13813679705723846039e-08, /* 0x3E663769, 0x72BEA4D0 */
|
||||
lg2 = 6.93147180559945286227e-01, /* 0x3FE62E42, 0xFEFA39EF */
|
||||
lg2_h = 6.93147182464599609375e-01, /* 0x3FE62E43, 0x00000000 */
|
||||
lg2_l = -1.90465429995776804525e-09, /* 0xBE205C61, 0x0CA86C39 */
|
||||
ovt = 8.0085662595372944372e-0017, /* -(1024-log2(ovfl+.5ulp)) */
|
||||
cp = 9.61796693925975554329e-01, /* 0x3FEEC709, 0xDC3A03FD =2/(3ln2) */
|
||||
cp_h = 9.61796700954437255859e-01, /* 0x3FEEC709, 0xE0000000 =(float)cp */
|
||||
cp_l = -7.02846165095275826516e-09, /* 0xBE3E2FE0, 0x145B01F5 =tail of cp_h*/
|
||||
ivln2 = 1.44269504088896338700e+00, /* 0x3FF71547, 0x652B82FE =1/ln2 */
|
||||
ivln2_h = 1.44269502162933349609e+00, /* 0x3FF71547, 0x60000000 =24b 1/ln2*/
|
||||
ivln2_l = 1.92596299112661746887e-08; /* 0x3E54AE0B, 0xF85DDF44 =1/ln2 tail*/
|
||||
|
||||
double
|
||||
__ieee754_pow(double x, double y)
|
||||
{
|
||||
double z,ax,z_h,z_l,p_h,p_l;
|
||||
double y1,t1,t2,r,s,t,u,v,w;
|
||||
int32_t i,j,k,yisint,n;
|
||||
int32_t hx,hy,ix,iy;
|
||||
u_int32_t lx,ly;
|
||||
|
||||
EXTRACT_WORDS(hx,lx,x);
|
||||
EXTRACT_WORDS(hy,ly,y);
|
||||
ix = hx&0x7fffffff; iy = hy&0x7fffffff;
|
||||
|
||||
/* y==zero: x**0 = 1 */
|
||||
if((iy|ly)==0) return one;
|
||||
|
||||
/* x==1: 1**y = 1, even if y is NaN */
|
||||
if (hx==0x3ff00000 && lx == 0) return one;
|
||||
|
||||
/* y!=zero: result is NaN if either arg is NaN */
|
||||
if(ix > 0x7ff00000 || ((ix==0x7ff00000)&&(lx!=0)) ||
|
||||
iy > 0x7ff00000 || ((iy==0x7ff00000)&&(ly!=0)))
|
||||
return (x+0.0)+(y+0.0);
|
||||
|
||||
/* determine if y is an odd int when x < 0
|
||||
* yisint = 0 ... y is not an integer
|
||||
* yisint = 1 ... y is an odd int
|
||||
* yisint = 2 ... y is an even int
|
||||
*/
|
||||
yisint = 0;
|
||||
if(hx<0) {
|
||||
if(iy>=0x43400000) yisint = 2; /* even integer y */
|
||||
else if(iy>=0x3ff00000) {
|
||||
k = (iy>>20)-0x3ff; /* exponent */
|
||||
if(k>20) {
|
||||
j = ly>>(52-k);
|
||||
if((j<<(52-k))==ly) yisint = 2-(j&1);
|
||||
} else if(ly==0) {
|
||||
j = iy>>(20-k);
|
||||
if((j<<(20-k))==iy) yisint = 2-(j&1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* special value of y */
|
||||
if(ly==0) {
|
||||
if (iy==0x7ff00000) { /* y is +-inf */
|
||||
if(((ix-0x3ff00000)|lx)==0)
|
||||
return one; /* (-1)**+-inf is 1 */
|
||||
else if (ix >= 0x3ff00000)/* (|x|>1)**+-inf = inf,0 */
|
||||
return (hy>=0)? y: zero;
|
||||
else /* (|x|<1)**-,+inf = inf,0 */
|
||||
return (hy<0)?-y: zero;
|
||||
}
|
||||
if(iy==0x3ff00000) { /* y is +-1 */
|
||||
if(hy<0) return one/x; else return x;
|
||||
}
|
||||
if(hy==0x40000000) return x*x; /* y is 2 */
|
||||
if(hy==0x3fe00000) { /* y is 0.5 */
|
||||
if(hx>=0) /* x >= +0 */
|
||||
return sqrt(x);
|
||||
}
|
||||
}
|
||||
|
||||
ax = fabs(x);
|
||||
/* special value of x */
|
||||
if(lx==0) {
|
||||
if(ix==0x7ff00000||ix==0||ix==0x3ff00000){
|
||||
z = ax; /*x is +-0,+-inf,+-1*/
|
||||
if(hy<0) z = one/z; /* z = (1/|x|) */
|
||||
if(hx<0) {
|
||||
if(((ix-0x3ff00000)|yisint)==0) {
|
||||
z = (z-z)/(z-z); /* (-1)**non-int is NaN */
|
||||
} else if(yisint==1)
|
||||
z = -z; /* (x<0)**odd = -(|x|**odd) */
|
||||
}
|
||||
return z;
|
||||
}
|
||||
}
|
||||
|
||||
/* CYGNUS LOCAL + fdlibm-5.3 fix: This used to be
|
||||
n = (hx>>31)+1;
|
||||
but ANSI C says a right shift of a signed negative quantity is
|
||||
implementation defined. */
|
||||
n = ((u_int32_t)hx>>31)-1;
|
||||
|
||||
/* (x<0)**(non-int) is NaN */
|
||||
if((n|yisint)==0) return (x-x)/(x-x);
|
||||
|
||||
s = one; /* s (sign of result -ve**odd) = -1 else = 1 */
|
||||
if((n|(yisint-1))==0) s = -one;/* (-ve)**(odd int) */
|
||||
|
||||
/* |y| is huge */
|
||||
if(iy>0x41e00000) { /* if |y| > 2**31 */
|
||||
if(iy>0x43f00000){ /* if |y| > 2**64, must o/uflow */
|
||||
if(ix<=0x3fefffff) return (hy<0)? huge*huge:tiny*tiny;
|
||||
if(ix>=0x3ff00000) return (hy>0)? huge*huge:tiny*tiny;
|
||||
}
|
||||
/* over/underflow if x is not close to one */
|
||||
if(ix<0x3fefffff) return (hy<0)? s*huge*huge:s*tiny*tiny;
|
||||
if(ix>0x3ff00000) return (hy>0)? s*huge*huge:s*tiny*tiny;
|
||||
/* now |1-x| is tiny <= 2**-20, suffice to compute
|
||||
log(x) by x-x^2/2+x^3/3-x^4/4 */
|
||||
t = ax-one; /* t has 20 trailing zeros */
|
||||
w = (t*t)*(0.5-t*(0.3333333333333333333333-t*0.25));
|
||||
u = ivln2_h*t; /* ivln2_h has 21 sig. bits */
|
||||
v = t*ivln2_l-w*ivln2;
|
||||
t1 = u+v;
|
||||
SET_LOW_WORD(t1,0);
|
||||
t2 = v-(t1-u);
|
||||
} else {
|
||||
double ss,s2,s_h,s_l,t_h,t_l;
|
||||
n = 0;
|
||||
/* take care subnormal number */
|
||||
if(ix<0x00100000)
|
||||
{ax *= two53; n -= 53; GET_HIGH_WORD(ix,ax); }
|
||||
n += ((ix)>>20)-0x3ff;
|
||||
j = ix&0x000fffff;
|
||||
/* determine interval */
|
||||
ix = j|0x3ff00000; /* normalize ix */
|
||||
if(j<=0x3988E) k=0; /* |x|<sqrt(3/2) */
|
||||
else if(j<0xBB67A) k=1; /* |x|<sqrt(3) */
|
||||
else {k=0;n+=1;ix -= 0x00100000;}
|
||||
SET_HIGH_WORD(ax,ix);
|
||||
|
||||
/* compute ss = s_h+s_l = (x-1)/(x+1) or (x-1.5)/(x+1.5) */
|
||||
u = ax-bp[k]; /* bp[0]=1.0, bp[1]=1.5 */
|
||||
v = one/(ax+bp[k]);
|
||||
ss = u*v;
|
||||
s_h = ss;
|
||||
SET_LOW_WORD(s_h,0);
|
||||
/* t_h=ax+bp[k] High */
|
||||
t_h = zero;
|
||||
SET_HIGH_WORD(t_h,((ix>>1)|0x20000000)+0x00080000+(k<<18));
|
||||
t_l = ax - (t_h-bp[k]);
|
||||
s_l = v*((u-s_h*t_h)-s_h*t_l);
|
||||
/* compute log(ax) */
|
||||
s2 = ss*ss;
|
||||
r = s2*s2*(L1+s2*(L2+s2*(L3+s2*(L4+s2*(L5+s2*L6)))));
|
||||
r += s_l*(s_h+ss);
|
||||
s2 = s_h*s_h;
|
||||
t_h = 3.0+s2+r;
|
||||
SET_LOW_WORD(t_h,0);
|
||||
t_l = r-((t_h-3.0)-s2);
|
||||
/* u+v = ss*(1+...) */
|
||||
u = s_h*t_h;
|
||||
v = s_l*t_h+t_l*ss;
|
||||
/* 2/(3log2)*(ss+...) */
|
||||
p_h = u+v;
|
||||
SET_LOW_WORD(p_h,0);
|
||||
p_l = v-(p_h-u);
|
||||
z_h = cp_h*p_h; /* cp_h+cp_l = 2/(3*log2) */
|
||||
z_l = cp_l*p_h+p_l*cp+dp_l[k];
|
||||
/* log2(ax) = (ss+..)*2/(3*log2) = n + dp_h + z_h + z_l */
|
||||
t = (double)n;
|
||||
t1 = (((z_h+z_l)+dp_h[k])+t);
|
||||
SET_LOW_WORD(t1,0);
|
||||
t2 = z_l-(((t1-t)-dp_h[k])-z_h);
|
||||
}
|
||||
|
||||
/* split up y into y1+y2 and compute (y1+y2)*(t1+t2) */
|
||||
y1 = y;
|
||||
SET_LOW_WORD(y1,0);
|
||||
p_l = (y-y1)*t1+y*t2;
|
||||
p_h = y1*t1;
|
||||
z = p_l+p_h;
|
||||
EXTRACT_WORDS(j,i,z);
|
||||
if (j>=0x40900000) { /* z >= 1024 */
|
||||
if(((j-0x40900000)|i)!=0) /* if z > 1024 */
|
||||
return s*huge*huge; /* overflow */
|
||||
else {
|
||||
if(p_l+ovt>z-p_h) return s*huge*huge; /* overflow */
|
||||
}
|
||||
} else if((j&0x7fffffff)>=0x4090cc00 ) { /* z <= -1075 */
|
||||
if(((j-0xc090cc00)|i)!=0) /* z < -1075 */
|
||||
return s*tiny*tiny; /* underflow */
|
||||
else {
|
||||
if(p_l<=z-p_h) return s*tiny*tiny; /* underflow */
|
||||
}
|
||||
}
|
||||
/*
|
||||
* compute 2**(p_h+p_l)
|
||||
*/
|
||||
i = j&0x7fffffff;
|
||||
k = (i>>20)-0x3ff;
|
||||
n = 0;
|
||||
if(i>0x3fe00000) { /* if |z| > 0.5, set n = [z+0.5] */
|
||||
n = j+(0x00100000>>(k+1));
|
||||
k = ((n&0x7fffffff)>>20)-0x3ff; /* new k for n */
|
||||
t = zero;
|
||||
SET_HIGH_WORD(t,n&~(0x000fffff>>k));
|
||||
n = ((n&0x000fffff)|0x00100000)>>(20-k);
|
||||
if(j<0) n = -n;
|
||||
p_h -= t;
|
||||
}
|
||||
t = p_l+p_h;
|
||||
SET_LOW_WORD(t,0);
|
||||
u = t*lg2_h;
|
||||
v = (p_l-(t-p_h))*lg2+t*lg2_l;
|
||||
z = u+v;
|
||||
w = v-(z-u);
|
||||
t = z*z;
|
||||
t1 = z - t*(P1+t*(P2+t*(P3+t*(P4+t*P5))));
|
||||
r = (z*t1)/(t1-two)-(w+z*w);
|
||||
z = one-(r-z);
|
||||
GET_HIGH_WORD(j,z);
|
||||
j += (n<<20);
|
||||
if((j>>20)<=0) z = scalbn(z,n); /* subnormal output */
|
||||
else SET_HIGH_WORD(z,j);
|
||||
return s*z;
|
||||
}
|
||||
74
modules/fdlibm/src/e_sinh.cpp
Normal file
74
modules/fdlibm/src/e_sinh.cpp
Normal file
|
|
@ -0,0 +1,74 @@
|
|||
|
||||
/* @(#)e_sinh.c 1.3 95/01/18 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* __ieee754_sinh(x)
|
||||
* Method :
|
||||
* mathematically sinh(x) if defined to be (exp(x)-exp(-x))/2
|
||||
* 1. Replace x by |x| (sinh(-x) = -sinh(x)).
|
||||
* 2.
|
||||
* E + E/(E+1)
|
||||
* 0 <= x <= 22 : sinh(x) := --------------, E=expm1(x)
|
||||
* 2
|
||||
*
|
||||
* 22 <= x <= lnovft : sinh(x) := exp(x)/2
|
||||
* lnovft <= x <= ln2ovft: sinh(x) := exp(x/2)/2 * exp(x/2)
|
||||
* ln2ovft < x : sinh(x) := x*shuge (overflow)
|
||||
*
|
||||
* Special cases:
|
||||
* sinh(x) is |x| if x is +INF, -INF, or NaN.
|
||||
* only sinh(0)=0 is exact for finite x.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const double one = 1.0, shuge = 1.0e307;
|
||||
|
||||
double
|
||||
__ieee754_sinh(double x)
|
||||
{
|
||||
double t,h;
|
||||
int32_t ix,jx;
|
||||
|
||||
/* High word of |x|. */
|
||||
GET_HIGH_WORD(jx,x);
|
||||
ix = jx&0x7fffffff;
|
||||
|
||||
/* x is INF or NaN */
|
||||
if(ix>=0x7ff00000) return x+x;
|
||||
|
||||
h = 0.5;
|
||||
if (jx<0) h = -h;
|
||||
/* |x| in [0,22], return sign(x)*0.5*(E+E/(E+1))) */
|
||||
if (ix < 0x40360000) { /* |x|<22 */
|
||||
if (ix<0x3e300000) /* |x|<2**-28 */
|
||||
if(shuge+x>one) return x;/* sinh(tiny) = tiny with inexact */
|
||||
t = expm1(fabs(x));
|
||||
if(ix<0x3ff00000) return h*(2.0*t-t*t/(t+one));
|
||||
return h*(t+t/(t+one));
|
||||
}
|
||||
|
||||
/* |x| in [22, log(maxdouble)] return 0.5*exp(|x|) */
|
||||
if (ix < 0x40862E42) return h*__ieee754_exp(fabs(x));
|
||||
|
||||
/* |x| in [log(maxdouble), overflowthresold] */
|
||||
if (ix<=0x408633CE)
|
||||
return h*2.0*__ldexp_exp(fabs(x), -1);
|
||||
|
||||
/* |x| > overflowthresold, sinh(x) overflow */
|
||||
return x*shuge;
|
||||
}
|
||||
446
modules/fdlibm/src/e_sqrt.cpp
Normal file
446
modules/fdlibm/src/e_sqrt.cpp
Normal file
|
|
@ -0,0 +1,446 @@
|
|||
|
||||
/* @(#)e_sqrt.c 1.3 95/01/18 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* __ieee754_sqrt(x)
|
||||
* Return correctly rounded sqrt.
|
||||
* ------------------------------------------
|
||||
* | Use the hardware sqrt if you have one |
|
||||
* ------------------------------------------
|
||||
* Method:
|
||||
* Bit by bit method using integer arithmetic. (Slow, but portable)
|
||||
* 1. Normalization
|
||||
* Scale x to y in [1,4) with even powers of 2:
|
||||
* find an integer k such that 1 <= (y=x*2^(2k)) < 4, then
|
||||
* sqrt(x) = 2^k * sqrt(y)
|
||||
* 2. Bit by bit computation
|
||||
* Let q = sqrt(y) truncated to i bit after binary point (q = 1),
|
||||
* i 0
|
||||
* i+1 2
|
||||
* s = 2*q , and y = 2 * ( y - q ). (1)
|
||||
* i i i i
|
||||
*
|
||||
* To compute q from q , one checks whether
|
||||
* i+1 i
|
||||
*
|
||||
* -(i+1) 2
|
||||
* (q + 2 ) <= y. (2)
|
||||
* i
|
||||
* -(i+1)
|
||||
* If (2) is false, then q = q ; otherwise q = q + 2 .
|
||||
* i+1 i i+1 i
|
||||
*
|
||||
* With some algebric manipulation, it is not difficult to see
|
||||
* that (2) is equivalent to
|
||||
* -(i+1)
|
||||
* s + 2 <= y (3)
|
||||
* i i
|
||||
*
|
||||
* The advantage of (3) is that s and y can be computed by
|
||||
* i i
|
||||
* the following recurrence formula:
|
||||
* if (3) is false
|
||||
*
|
||||
* s = s , y = y ; (4)
|
||||
* i+1 i i+1 i
|
||||
*
|
||||
* otherwise,
|
||||
* -i -(i+1)
|
||||
* s = s + 2 , y = y - s - 2 (5)
|
||||
* i+1 i i+1 i i
|
||||
*
|
||||
* One may easily use induction to prove (4) and (5).
|
||||
* Note. Since the left hand side of (3) contain only i+2 bits,
|
||||
* it does not necessary to do a full (53-bit) comparison
|
||||
* in (3).
|
||||
* 3. Final rounding
|
||||
* After generating the 53 bits result, we compute one more bit.
|
||||
* Together with the remainder, we can decide whether the
|
||||
* result is exact, bigger than 1/2ulp, or less than 1/2ulp
|
||||
* (it will never equal to 1/2ulp).
|
||||
* The rounding mode can be detected by checking whether
|
||||
* huge + tiny is equal to huge, and whether huge - tiny is
|
||||
* equal to huge for some floating point number "huge" and "tiny".
|
||||
*
|
||||
* Special cases:
|
||||
* sqrt(+-0) = +-0 ... exact
|
||||
* sqrt(inf) = inf
|
||||
* sqrt(-ve) = NaN ... with invalid signal
|
||||
* sqrt(NaN) = NaN ... with invalid signal for signaling NaN
|
||||
*
|
||||
* Other methods : see the appended file at the end of the program below.
|
||||
*---------------
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const double one = 1.0, tiny=1.0e-300;
|
||||
|
||||
double
|
||||
__ieee754_sqrt(double x)
|
||||
{
|
||||
double z;
|
||||
int32_t sign = (int)0x80000000;
|
||||
int32_t ix0,s0,q,m,t,i;
|
||||
u_int32_t r,t1,s1,ix1,q1;
|
||||
|
||||
EXTRACT_WORDS(ix0,ix1,x);
|
||||
|
||||
/* take care of Inf and NaN */
|
||||
if((ix0&0x7ff00000)==0x7ff00000) {
|
||||
return x*x+x; /* sqrt(NaN)=NaN, sqrt(+inf)=+inf
|
||||
sqrt(-inf)=sNaN */
|
||||
}
|
||||
/* take care of zero */
|
||||
if(ix0<=0) {
|
||||
if(((ix0&(~sign))|ix1)==0) return x;/* sqrt(+-0) = +-0 */
|
||||
else if(ix0<0)
|
||||
return (x-x)/(x-x); /* sqrt(-ve) = sNaN */
|
||||
}
|
||||
/* normalize x */
|
||||
m = (ix0>>20);
|
||||
if(m==0) { /* subnormal x */
|
||||
while(ix0==0) {
|
||||
m -= 21;
|
||||
ix0 |= (ix1>>11); ix1 <<= 21;
|
||||
}
|
||||
for(i=0;(ix0&0x00100000)==0;i++) ix0<<=1;
|
||||
m -= i-1;
|
||||
ix0 |= (ix1>>(32-i));
|
||||
ix1 <<= i;
|
||||
}
|
||||
m -= 1023; /* unbias exponent */
|
||||
ix0 = (ix0&0x000fffff)|0x00100000;
|
||||
if(m&1){ /* odd m, double x to make it even */
|
||||
ix0 += ix0 + ((ix1&sign)>>31);
|
||||
ix1 += ix1;
|
||||
}
|
||||
m >>= 1; /* m = [m/2] */
|
||||
|
||||
/* generate sqrt(x) bit by bit */
|
||||
ix0 += ix0 + ((ix1&sign)>>31);
|
||||
ix1 += ix1;
|
||||
q = q1 = s0 = s1 = 0; /* [q,q1] = sqrt(x) */
|
||||
r = 0x00200000; /* r = moving bit from right to left */
|
||||
|
||||
while(r!=0) {
|
||||
t = s0+r;
|
||||
if(t<=ix0) {
|
||||
s0 = t+r;
|
||||
ix0 -= t;
|
||||
q += r;
|
||||
}
|
||||
ix0 += ix0 + ((ix1&sign)>>31);
|
||||
ix1 += ix1;
|
||||
r>>=1;
|
||||
}
|
||||
|
||||
r = sign;
|
||||
while(r!=0) {
|
||||
t1 = s1+r;
|
||||
t = s0;
|
||||
if((t<ix0)||((t==ix0)&&(t1<=ix1))) {
|
||||
s1 = t1+r;
|
||||
if(((t1&sign)==sign)&&(s1&sign)==0) s0 += 1;
|
||||
ix0 -= t;
|
||||
if (ix1 < t1) ix0 -= 1;
|
||||
ix1 -= t1;
|
||||
q1 += r;
|
||||
}
|
||||
ix0 += ix0 + ((ix1&sign)>>31);
|
||||
ix1 += ix1;
|
||||
r>>=1;
|
||||
}
|
||||
|
||||
/* use floating add to find out rounding direction */
|
||||
if((ix0|ix1)!=0) {
|
||||
z = one-tiny; /* trigger inexact flag */
|
||||
if (z>=one) {
|
||||
z = one+tiny;
|
||||
if (q1==(u_int32_t)0xffffffff) { q1=0; q += 1;}
|
||||
else if (z>one) {
|
||||
if (q1==(u_int32_t)0xfffffffe) q+=1;
|
||||
q1+=2;
|
||||
} else
|
||||
q1 += (q1&1);
|
||||
}
|
||||
}
|
||||
ix0 = (q>>1)+0x3fe00000;
|
||||
ix1 = q1>>1;
|
||||
if ((q&1)==1) ix1 |= sign;
|
||||
ix0 += (m <<20);
|
||||
INSERT_WORDS(z,ix0,ix1);
|
||||
return z;
|
||||
}
|
||||
|
||||
/*
|
||||
Other methods (use floating-point arithmetic)
|
||||
-------------
|
||||
(This is a copy of a drafted paper by Prof W. Kahan
|
||||
and K.C. Ng, written in May, 1986)
|
||||
|
||||
Two algorithms are given here to implement sqrt(x)
|
||||
(IEEE double precision arithmetic) in software.
|
||||
Both supply sqrt(x) correctly rounded. The first algorithm (in
|
||||
Section A) uses newton iterations and involves four divisions.
|
||||
The second one uses reciproot iterations to avoid division, but
|
||||
requires more multiplications. Both algorithms need the ability
|
||||
to chop results of arithmetic operations instead of round them,
|
||||
and the INEXACT flag to indicate when an arithmetic operation
|
||||
is executed exactly with no roundoff error, all part of the
|
||||
standard (IEEE 754-1985). The ability to perform shift, add,
|
||||
subtract and logical AND operations upon 32-bit words is needed
|
||||
too, though not part of the standard.
|
||||
|
||||
A. sqrt(x) by Newton Iteration
|
||||
|
||||
(1) Initial approximation
|
||||
|
||||
Let x0 and x1 be the leading and the trailing 32-bit words of
|
||||
a floating point number x (in IEEE double format) respectively
|
||||
|
||||
1 11 52 ...widths
|
||||
------------------------------------------------------
|
||||
x: |s| e | f |
|
||||
------------------------------------------------------
|
||||
msb lsb msb lsb ...order
|
||||
|
||||
|
||||
------------------------ ------------------------
|
||||
x0: |s| e | f1 | x1: | f2 |
|
||||
------------------------ ------------------------
|
||||
|
||||
By performing shifts and subtracts on x0 and x1 (both regarded
|
||||
as integers), we obtain an 8-bit approximation of sqrt(x) as
|
||||
follows.
|
||||
|
||||
k := (x0>>1) + 0x1ff80000;
|
||||
y0 := k - T1[31&(k>>15)]. ... y ~ sqrt(x) to 8 bits
|
||||
Here k is a 32-bit integer and T1[] is an integer array containing
|
||||
correction terms. Now magically the floating value of y (y's
|
||||
leading 32-bit word is y0, the value of its trailing word is 0)
|
||||
approximates sqrt(x) to almost 8-bit.
|
||||
|
||||
Value of T1:
|
||||
static int T1[32]= {
|
||||
0, 1024, 3062, 5746, 9193, 13348, 18162, 23592,
|
||||
29598, 36145, 43202, 50740, 58733, 67158, 75992, 85215,
|
||||
83599, 71378, 60428, 50647, 41945, 34246, 27478, 21581,
|
||||
16499, 12183, 8588, 5674, 3403, 1742, 661, 130,};
|
||||
|
||||
(2) Iterative refinement
|
||||
|
||||
Apply Heron's rule three times to y, we have y approximates
|
||||
sqrt(x) to within 1 ulp (Unit in the Last Place):
|
||||
|
||||
y := (y+x/y)/2 ... almost 17 sig. bits
|
||||
y := (y+x/y)/2 ... almost 35 sig. bits
|
||||
y := y-(y-x/y)/2 ... within 1 ulp
|
||||
|
||||
|
||||
Remark 1.
|
||||
Another way to improve y to within 1 ulp is:
|
||||
|
||||
y := (y+x/y) ... almost 17 sig. bits to 2*sqrt(x)
|
||||
y := y - 0x00100006 ... almost 18 sig. bits to sqrt(x)
|
||||
|
||||
2
|
||||
(x-y )*y
|
||||
y := y + 2* ---------- ...within 1 ulp
|
||||
2
|
||||
3y + x
|
||||
|
||||
|
||||
This formula has one division fewer than the one above; however,
|
||||
it requires more multiplications and additions. Also x must be
|
||||
scaled in advance to avoid spurious overflow in evaluating the
|
||||
expression 3y*y+x. Hence it is not recommended uless division
|
||||
is slow. If division is very slow, then one should use the
|
||||
reciproot algorithm given in section B.
|
||||
|
||||
(3) Final adjustment
|
||||
|
||||
By twiddling y's last bit it is possible to force y to be
|
||||
correctly rounded according to the prevailing rounding mode
|
||||
as follows. Let r and i be copies of the rounding mode and
|
||||
inexact flag before entering the square root program. Also we
|
||||
use the expression y+-ulp for the next representable floating
|
||||
numbers (up and down) of y. Note that y+-ulp = either fixed
|
||||
point y+-1, or multiply y by nextafter(1,+-inf) in chopped
|
||||
mode.
|
||||
|
||||
I := FALSE; ... reset INEXACT flag I
|
||||
R := RZ; ... set rounding mode to round-toward-zero
|
||||
z := x/y; ... chopped quotient, possibly inexact
|
||||
If(not I) then { ... if the quotient is exact
|
||||
if(z=y) {
|
||||
I := i; ... restore inexact flag
|
||||
R := r; ... restore rounded mode
|
||||
return sqrt(x):=y.
|
||||
} else {
|
||||
z := z - ulp; ... special rounding
|
||||
}
|
||||
}
|
||||
i := TRUE; ... sqrt(x) is inexact
|
||||
If (r=RN) then z=z+ulp ... rounded-to-nearest
|
||||
If (r=RP) then { ... round-toward-+inf
|
||||
y = y+ulp; z=z+ulp;
|
||||
}
|
||||
y := y+z; ... chopped sum
|
||||
y0:=y0-0x00100000; ... y := y/2 is correctly rounded.
|
||||
I := i; ... restore inexact flag
|
||||
R := r; ... restore rounded mode
|
||||
return sqrt(x):=y.
|
||||
|
||||
(4) Special cases
|
||||
|
||||
Square root of +inf, +-0, or NaN is itself;
|
||||
Square root of a negative number is NaN with invalid signal.
|
||||
|
||||
|
||||
B. sqrt(x) by Reciproot Iteration
|
||||
|
||||
(1) Initial approximation
|
||||
|
||||
Let x0 and x1 be the leading and the trailing 32-bit words of
|
||||
a floating point number x (in IEEE double format) respectively
|
||||
(see section A). By performing shifs and subtracts on x0 and y0,
|
||||
we obtain a 7.8-bit approximation of 1/sqrt(x) as follows.
|
||||
|
||||
k := 0x5fe80000 - (x0>>1);
|
||||
y0:= k - T2[63&(k>>14)]. ... y ~ 1/sqrt(x) to 7.8 bits
|
||||
|
||||
Here k is a 32-bit integer and T2[] is an integer array
|
||||
containing correction terms. Now magically the floating
|
||||
value of y (y's leading 32-bit word is y0, the value of
|
||||
its trailing word y1 is set to zero) approximates 1/sqrt(x)
|
||||
to almost 7.8-bit.
|
||||
|
||||
Value of T2:
|
||||
static int T2[64]= {
|
||||
0x1500, 0x2ef8, 0x4d67, 0x6b02, 0x87be, 0xa395, 0xbe7a, 0xd866,
|
||||
0xf14a, 0x1091b,0x11fcd,0x13552,0x14999,0x15c98,0x16e34,0x17e5f,
|
||||
0x18d03,0x19a01,0x1a545,0x1ae8a,0x1b5c4,0x1bb01,0x1bfde,0x1c28d,
|
||||
0x1c2de,0x1c0db,0x1ba73,0x1b11c,0x1a4b5,0x1953d,0x18266,0x16be0,
|
||||
0x1683e,0x179d8,0x18a4d,0x19992,0x1a789,0x1b445,0x1bf61,0x1c989,
|
||||
0x1d16d,0x1d77b,0x1dddf,0x1e2ad,0x1e5bf,0x1e6e8,0x1e654,0x1e3cd,
|
||||
0x1df2a,0x1d635,0x1cb16,0x1be2c,0x1ae4e,0x19bde,0x1868e,0x16e2e,
|
||||
0x1527f,0x1334a,0x11051,0xe951, 0xbe01, 0x8e0d, 0x5924, 0x1edd,};
|
||||
|
||||
(2) Iterative refinement
|
||||
|
||||
Apply Reciproot iteration three times to y and multiply the
|
||||
result by x to get an approximation z that matches sqrt(x)
|
||||
to about 1 ulp. To be exact, we will have
|
||||
-1ulp < sqrt(x)-z<1.0625ulp.
|
||||
|
||||
... set rounding mode to Round-to-nearest
|
||||
y := y*(1.5-0.5*x*y*y) ... almost 15 sig. bits to 1/sqrt(x)
|
||||
y := y*((1.5-2^-30)+0.5*x*y*y)... about 29 sig. bits to 1/sqrt(x)
|
||||
... special arrangement for better accuracy
|
||||
z := x*y ... 29 bits to sqrt(x), with z*y<1
|
||||
z := z + 0.5*z*(1-z*y) ... about 1 ulp to sqrt(x)
|
||||
|
||||
Remark 2. The constant 1.5-2^-30 is chosen to bias the error so that
|
||||
(a) the term z*y in the final iteration is always less than 1;
|
||||
(b) the error in the final result is biased upward so that
|
||||
-1 ulp < sqrt(x) - z < 1.0625 ulp
|
||||
instead of |sqrt(x)-z|<1.03125ulp.
|
||||
|
||||
(3) Final adjustment
|
||||
|
||||
By twiddling y's last bit it is possible to force y to be
|
||||
correctly rounded according to the prevailing rounding mode
|
||||
as follows. Let r and i be copies of the rounding mode and
|
||||
inexact flag before entering the square root program. Also we
|
||||
use the expression y+-ulp for the next representable floating
|
||||
numbers (up and down) of y. Note that y+-ulp = either fixed
|
||||
point y+-1, or multiply y by nextafter(1,+-inf) in chopped
|
||||
mode.
|
||||
|
||||
R := RZ; ... set rounding mode to round-toward-zero
|
||||
switch(r) {
|
||||
case RN: ... round-to-nearest
|
||||
if(x<= z*(z-ulp)...chopped) z = z - ulp; else
|
||||
if(x<= z*(z+ulp)...chopped) z = z; else z = z+ulp;
|
||||
break;
|
||||
case RZ:case RM: ... round-to-zero or round-to--inf
|
||||
R:=RP; ... reset rounding mod to round-to-+inf
|
||||
if(x<z*z ... rounded up) z = z - ulp; else
|
||||
if(x>=(z+ulp)*(z+ulp) ...rounded up) z = z+ulp;
|
||||
break;
|
||||
case RP: ... round-to-+inf
|
||||
if(x>(z+ulp)*(z+ulp)...chopped) z = z+2*ulp; else
|
||||
if(x>z*z ...chopped) z = z+ulp;
|
||||
break;
|
||||
}
|
||||
|
||||
Remark 3. The above comparisons can be done in fixed point. For
|
||||
example, to compare x and w=z*z chopped, it suffices to compare
|
||||
x1 and w1 (the trailing parts of x and w), regarding them as
|
||||
two's complement integers.
|
||||
|
||||
...Is z an exact square root?
|
||||
To determine whether z is an exact square root of x, let z1 be the
|
||||
trailing part of z, and also let x0 and x1 be the leading and
|
||||
trailing parts of x.
|
||||
|
||||
If ((z1&0x03ffffff)!=0) ... not exact if trailing 26 bits of z!=0
|
||||
I := 1; ... Raise Inexact flag: z is not exact
|
||||
else {
|
||||
j := 1 - [(x0>>20)&1] ... j = logb(x) mod 2
|
||||
k := z1 >> 26; ... get z's 25-th and 26-th
|
||||
fraction bits
|
||||
I := i or (k&j) or ((k&(j+j+1))!=(x1&3));
|
||||
}
|
||||
R:= r ... restore rounded mode
|
||||
return sqrt(x):=z.
|
||||
|
||||
If multiplication is cheaper then the foregoing red tape, the
|
||||
Inexact flag can be evaluated by
|
||||
|
||||
I := i;
|
||||
I := (z*z!=x) or I.
|
||||
|
||||
Note that z*z can overwrite I; this value must be sensed if it is
|
||||
True.
|
||||
|
||||
Remark 4. If z*z = x exactly, then bit 25 to bit 0 of z1 must be
|
||||
zero.
|
||||
|
||||
--------------------
|
||||
z1: | f2 |
|
||||
--------------------
|
||||
bit 31 bit 0
|
||||
|
||||
Further more, bit 27 and 26 of z1, bit 0 and 1 of x1, and the odd
|
||||
or even of logb(x) have the following relations:
|
||||
|
||||
-------------------------------------------------
|
||||
bit 27,26 of z1 bit 1,0 of x1 logb(x)
|
||||
-------------------------------------------------
|
||||
00 00 odd and even
|
||||
01 01 even
|
||||
10 10 odd
|
||||
10 00 even
|
||||
11 01 even
|
||||
-------------------------------------------------
|
||||
|
||||
(4) Special cases (see (4) of Section A).
|
||||
|
||||
*/
|
||||
|
||||
65
modules/fdlibm/src/fdlibm.h
Normal file
65
modules/fdlibm/src/fdlibm.h
Normal file
|
|
@ -0,0 +1,65 @@
|
|||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
/*
|
||||
* from: @(#)fdlibm.h 5.1 93/09/24
|
||||
* $FreeBSD$
|
||||
*/
|
||||
|
||||
#ifndef mozilla_imported_fdlibm_h
|
||||
#define mozilla_imported_fdlibm_h
|
||||
|
||||
namespace fdlibm {
|
||||
|
||||
double acos(double);
|
||||
double asin(double);
|
||||
double atan(double);
|
||||
double atan2(double, double);
|
||||
|
||||
double cosh(double);
|
||||
double sinh(double);
|
||||
double tanh(double);
|
||||
|
||||
double exp(double);
|
||||
double log(double);
|
||||
double log10(double);
|
||||
|
||||
double pow(double, double);
|
||||
double sqrt(double);
|
||||
double fabs(double);
|
||||
|
||||
double floor(double);
|
||||
double trunc(double);
|
||||
double ceil(double);
|
||||
|
||||
double acosh(double);
|
||||
double asinh(double);
|
||||
double atanh(double);
|
||||
double cbrt(double);
|
||||
double expm1(double);
|
||||
double hypot(double, double);
|
||||
double log1p(double);
|
||||
double log2(double);
|
||||
double rint(double);
|
||||
double copysign(double, double);
|
||||
double nearbyint(double);
|
||||
double scalbn(double, int);
|
||||
|
||||
float ceilf(float);
|
||||
float floorf(float);
|
||||
|
||||
float nearbyintf(float);
|
||||
float rintf(float);
|
||||
float truncf(float);
|
||||
|
||||
} /* namespace fdlibm */
|
||||
|
||||
#endif /* mozilla_imported_fdlibm_h */
|
||||
81
modules/fdlibm/src/k_exp.cpp
Normal file
81
modules/fdlibm/src/k_exp.cpp
Normal file
|
|
@ -0,0 +1,81 @@
|
|||
/*-
|
||||
* Copyright (c) 2011 David Schultz <das@FreeBSD.ORG>
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const uint32_t k = 1799; /* constant for reduction */
|
||||
static const double kln2 = 1246.97177782734161156; /* k * ln2 */
|
||||
|
||||
/*
|
||||
* Compute exp(x), scaled to avoid spurious overflow. An exponent is
|
||||
* returned separately in 'expt'.
|
||||
*
|
||||
* Input: ln(DBL_MAX) <= x < ln(2 * DBL_MAX / DBL_MIN_DENORM) ~= 1454.91
|
||||
* Output: 2**1023 <= y < 2**1024
|
||||
*/
|
||||
static double
|
||||
__frexp_exp(double x, int *expt)
|
||||
{
|
||||
double exp_x;
|
||||
uint32_t hx;
|
||||
|
||||
/*
|
||||
* We use exp(x) = exp(x - kln2) * 2**k, carefully chosen to
|
||||
* minimize |exp(kln2) - 2**k|. We also scale the exponent of
|
||||
* exp_x to MAX_EXP so that the result can be multiplied by
|
||||
* a tiny number without losing accuracy due to denormalization.
|
||||
*/
|
||||
exp_x = exp(x - kln2);
|
||||
GET_HIGH_WORD(hx, exp_x);
|
||||
*expt = (hx >> 20) - (0x3ff + 1023) + k;
|
||||
SET_HIGH_WORD(exp_x, (hx & 0xfffff) | ((0x3ff + 1023) << 20));
|
||||
return (exp_x);
|
||||
}
|
||||
|
||||
/*
|
||||
* __ldexp_exp(x, expt) and __ldexp_cexp(x, expt) compute exp(x) * 2**expt.
|
||||
* They are intended for large arguments (real part >= ln(DBL_MAX))
|
||||
* where care is needed to avoid overflow.
|
||||
*
|
||||
* The present implementation is narrowly tailored for our hyperbolic and
|
||||
* exponential functions. We assume expt is small (0 or -1), and the caller
|
||||
* has filtered out very large x, for which overflow would be inevitable.
|
||||
*/
|
||||
|
||||
double
|
||||
__ldexp_exp(double x, int expt)
|
||||
{
|
||||
double exp_x, scale;
|
||||
int ex_expt;
|
||||
|
||||
exp_x = __frexp_exp(x, &ex_expt);
|
||||
expt += ex_expt;
|
||||
INSERT_WORDS(scale, (0x3ff + expt) << 20, 0);
|
||||
return (exp_x * scale);
|
||||
}
|
||||
100
modules/fdlibm/src/k_log.h
Normal file
100
modules/fdlibm/src/k_log.h
Normal file
|
|
@ -0,0 +1,100 @@
|
|||
|
||||
/* @(#)e_log.c 1.3 95/01/18 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
* k_log1p(f):
|
||||
* Return log(1+f) - f for 1+f in ~[sqrt(2)/2, sqrt(2)].
|
||||
*
|
||||
* The following describes the overall strategy for computing
|
||||
* logarithms in base e. The argument reduction and adding the final
|
||||
* term of the polynomial are done by the caller for increased accuracy
|
||||
* when different bases are used.
|
||||
*
|
||||
* Method :
|
||||
* 1. Argument Reduction: find k and f such that
|
||||
* x = 2^k * (1+f),
|
||||
* where sqrt(2)/2 < 1+f < sqrt(2) .
|
||||
*
|
||||
* 2. Approximation of log(1+f).
|
||||
* Let s = f/(2+f) ; based on log(1+f) = log(1+s) - log(1-s)
|
||||
* = 2s + 2/3 s**3 + 2/5 s**5 + .....,
|
||||
* = 2s + s*R
|
||||
* We use a special Reme algorithm on [0,0.1716] to generate
|
||||
* a polynomial of degree 14 to approximate R The maximum error
|
||||
* of this polynomial approximation is bounded by 2**-58.45. In
|
||||
* other words,
|
||||
* 2 4 6 8 10 12 14
|
||||
* R(z) ~ Lg1*s +Lg2*s +Lg3*s +Lg4*s +Lg5*s +Lg6*s +Lg7*s
|
||||
* (the values of Lg1 to Lg7 are listed in the program)
|
||||
* and
|
||||
* | 2 14 | -58.45
|
||||
* | Lg1*s +...+Lg7*s - R(z) | <= 2
|
||||
* | |
|
||||
* Note that 2s = f - s*f = f - hfsq + s*hfsq, where hfsq = f*f/2.
|
||||
* In order to guarantee error in log below 1ulp, we compute log
|
||||
* by
|
||||
* log(1+f) = f - s*(f - R) (if f is not too large)
|
||||
* log(1+f) = f - (hfsq - s*(hfsq+R)). (better accuracy)
|
||||
*
|
||||
* 3. Finally, log(x) = k*ln2 + log(1+f).
|
||||
* = k*ln2_hi+(f-(hfsq-(s*(hfsq+R)+k*ln2_lo)))
|
||||
* Here ln2 is split into two floating point number:
|
||||
* ln2_hi + ln2_lo,
|
||||
* where n*ln2_hi is always exact for |n| < 2000.
|
||||
*
|
||||
* Special cases:
|
||||
* log(x) is NaN with signal if x < 0 (including -INF) ;
|
||||
* log(+INF) is +INF; log(0) is -INF with signal;
|
||||
* log(NaN) is that NaN with no signal.
|
||||
*
|
||||
* Accuracy:
|
||||
* according to an error analysis, the error is always less than
|
||||
* 1 ulp (unit in the last place).
|
||||
*
|
||||
* Constants:
|
||||
* The hexadecimal values are the intended ones for the following
|
||||
* constants. The decimal values may be used, provided that the
|
||||
* compiler will convert from decimal to binary accurately enough
|
||||
* to produce the hexadecimal values shown.
|
||||
*/
|
||||
|
||||
static const double
|
||||
Lg1 = 6.666666666666735130e-01, /* 3FE55555 55555593 */
|
||||
Lg2 = 3.999999999940941908e-01, /* 3FD99999 9997FA04 */
|
||||
Lg3 = 2.857142874366239149e-01, /* 3FD24924 94229359 */
|
||||
Lg4 = 2.222219843214978396e-01, /* 3FCC71C5 1D8E78AF */
|
||||
Lg5 = 1.818357216161805012e-01, /* 3FC74664 96CB03DE */
|
||||
Lg6 = 1.531383769920937332e-01, /* 3FC39A09 D078C69F */
|
||||
Lg7 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */
|
||||
|
||||
/*
|
||||
* We always inline k_log1p(), since doing so produces a
|
||||
* substantial performance improvement (~40% on amd64).
|
||||
*/
|
||||
static inline double
|
||||
k_log1p(double f)
|
||||
{
|
||||
double hfsq,s,z,R,w,t1,t2;
|
||||
|
||||
s = f/(2.0+f);
|
||||
z = s*s;
|
||||
w = z*z;
|
||||
t1= w*(Lg2+w*(Lg4+w*Lg6));
|
||||
t2= z*(Lg1+w*(Lg3+w*(Lg5+w*Lg7)));
|
||||
R = t2+t1;
|
||||
hfsq=0.5*f*f;
|
||||
return s*(hfsq+R);
|
||||
}
|
||||
822
modules/fdlibm/src/math_private.h
Normal file
822
modules/fdlibm/src/math_private.h
Normal file
|
|
@ -0,0 +1,822 @@
|
|||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
/*
|
||||
* from: @(#)fdlibm.h 5.1 93/09/24
|
||||
* $FreeBSD$
|
||||
*/
|
||||
|
||||
#ifndef _MATH_PRIVATE_H_
|
||||
#define _MATH_PRIVATE_H_
|
||||
|
||||
#include <cfloat>
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
#include "fdlibm.h"
|
||||
|
||||
#include "mozilla/EndianUtils.h"
|
||||
|
||||
/*
|
||||
* The original fdlibm code used statements like:
|
||||
* n0 = ((*(int*)&one)>>29)^1; * index of high word *
|
||||
* ix0 = *(n0+(int*)&x); * high word of x *
|
||||
* ix1 = *((1-n0)+(int*)&x); * low word of x *
|
||||
* to dig two 32 bit words out of the 64 bit IEEE floating point
|
||||
* value. That is non-ANSI, and, moreover, the gcc instruction
|
||||
* scheduler gets it wrong. We instead use the following macros.
|
||||
* Unlike the original code, we determine the endianness at compile
|
||||
* time, not at run time; I don't see much benefit to selecting
|
||||
* endianness at run time.
|
||||
*/
|
||||
|
||||
#ifdef WIN32
|
||||
#define u_int32_t uint32_t
|
||||
#define u_int64_t uint64_t
|
||||
#endif
|
||||
|
||||
/*
|
||||
* A union which permits us to convert between a double and two 32 bit
|
||||
* ints.
|
||||
*/
|
||||
|
||||
#if MOZ_BIG_ENDIAN
|
||||
|
||||
typedef union
|
||||
{
|
||||
double value;
|
||||
struct
|
||||
{
|
||||
u_int32_t msw;
|
||||
u_int32_t lsw;
|
||||
} parts;
|
||||
struct
|
||||
{
|
||||
u_int64_t w;
|
||||
} xparts;
|
||||
} ieee_double_shape_type;
|
||||
|
||||
#endif
|
||||
|
||||
#if MOZ_LITTLE_ENDIAN
|
||||
|
||||
typedef union
|
||||
{
|
||||
double value;
|
||||
struct
|
||||
{
|
||||
u_int32_t lsw;
|
||||
u_int32_t msw;
|
||||
} parts;
|
||||
struct
|
||||
{
|
||||
u_int64_t w;
|
||||
} xparts;
|
||||
} ieee_double_shape_type;
|
||||
|
||||
#endif
|
||||
|
||||
/* Get two 32 bit ints from a double. */
|
||||
|
||||
#define EXTRACT_WORDS(ix0,ix1,d) \
|
||||
do { \
|
||||
ieee_double_shape_type ew_u; \
|
||||
ew_u.value = (d); \
|
||||
(ix0) = ew_u.parts.msw; \
|
||||
(ix1) = ew_u.parts.lsw; \
|
||||
} while (0)
|
||||
|
||||
/* Get a 64-bit int from a double. */
|
||||
#define EXTRACT_WORD64(ix,d) \
|
||||
do { \
|
||||
ieee_double_shape_type ew_u; \
|
||||
ew_u.value = (d); \
|
||||
(ix) = ew_u.xparts.w; \
|
||||
} while (0)
|
||||
|
||||
/* Get the more significant 32 bit int from a double. */
|
||||
|
||||
#define GET_HIGH_WORD(i,d) \
|
||||
do { \
|
||||
ieee_double_shape_type gh_u; \
|
||||
gh_u.value = (d); \
|
||||
(i) = gh_u.parts.msw; \
|
||||
} while (0)
|
||||
|
||||
/* Get the less significant 32 bit int from a double. */
|
||||
|
||||
#define GET_LOW_WORD(i,d) \
|
||||
do { \
|
||||
ieee_double_shape_type gl_u; \
|
||||
gl_u.value = (d); \
|
||||
(i) = gl_u.parts.lsw; \
|
||||
} while (0)
|
||||
|
||||
/* Set a double from two 32 bit ints. */
|
||||
|
||||
#define INSERT_WORDS(d,ix0,ix1) \
|
||||
do { \
|
||||
ieee_double_shape_type iw_u; \
|
||||
iw_u.parts.msw = (ix0); \
|
||||
iw_u.parts.lsw = (ix1); \
|
||||
(d) = iw_u.value; \
|
||||
} while (0)
|
||||
|
||||
/* Set a double from a 64-bit int. */
|
||||
#define INSERT_WORD64(d,ix) \
|
||||
do { \
|
||||
ieee_double_shape_type iw_u; \
|
||||
iw_u.xparts.w = (ix); \
|
||||
(d) = iw_u.value; \
|
||||
} while (0)
|
||||
|
||||
/* Set the more significant 32 bits of a double from an int. */
|
||||
|
||||
#define SET_HIGH_WORD(d,v) \
|
||||
do { \
|
||||
ieee_double_shape_type sh_u; \
|
||||
sh_u.value = (d); \
|
||||
sh_u.parts.msw = (v); \
|
||||
(d) = sh_u.value; \
|
||||
} while (0)
|
||||
|
||||
/* Set the less significant 32 bits of a double from an int. */
|
||||
|
||||
#define SET_LOW_WORD(d,v) \
|
||||
do { \
|
||||
ieee_double_shape_type sl_u; \
|
||||
sl_u.value = (d); \
|
||||
sl_u.parts.lsw = (v); \
|
||||
(d) = sl_u.value; \
|
||||
} while (0)
|
||||
|
||||
/*
|
||||
* A union which permits us to convert between a float and a 32 bit
|
||||
* int.
|
||||
*/
|
||||
|
||||
typedef union
|
||||
{
|
||||
float value;
|
||||
/* FIXME: Assumes 32 bit int. */
|
||||
unsigned int word;
|
||||
} ieee_float_shape_type;
|
||||
|
||||
/* Get a 32 bit int from a float. */
|
||||
|
||||
#define GET_FLOAT_WORD(i,d) \
|
||||
do { \
|
||||
ieee_float_shape_type gf_u; \
|
||||
gf_u.value = (d); \
|
||||
(i) = gf_u.word; \
|
||||
} while (0)
|
||||
|
||||
/* Set a float from a 32 bit int. */
|
||||
|
||||
#define SET_FLOAT_WORD(d,i) \
|
||||
do { \
|
||||
ieee_float_shape_type sf_u; \
|
||||
sf_u.word = (i); \
|
||||
(d) = sf_u.value; \
|
||||
} while (0)
|
||||
|
||||
/*
|
||||
* Get expsign and mantissa as 16 bit and 64 bit ints from an 80 bit long
|
||||
* double.
|
||||
*/
|
||||
|
||||
#define EXTRACT_LDBL80_WORDS(ix0,ix1,d) \
|
||||
do { \
|
||||
union IEEEl2bits ew_u; \
|
||||
ew_u.e = (d); \
|
||||
(ix0) = ew_u.xbits.expsign; \
|
||||
(ix1) = ew_u.xbits.man; \
|
||||
} while (0)
|
||||
|
||||
/*
|
||||
* Get expsign and mantissa as one 16 bit and two 64 bit ints from a 128 bit
|
||||
* long double.
|
||||
*/
|
||||
|
||||
#define EXTRACT_LDBL128_WORDS(ix0,ix1,ix2,d) \
|
||||
do { \
|
||||
union IEEEl2bits ew_u; \
|
||||
ew_u.e = (d); \
|
||||
(ix0) = ew_u.xbits.expsign; \
|
||||
(ix1) = ew_u.xbits.manh; \
|
||||
(ix2) = ew_u.xbits.manl; \
|
||||
} while (0)
|
||||
|
||||
/* Get expsign as a 16 bit int from a long double. */
|
||||
|
||||
#define GET_LDBL_EXPSIGN(i,d) \
|
||||
do { \
|
||||
union IEEEl2bits ge_u; \
|
||||
ge_u.e = (d); \
|
||||
(i) = ge_u.xbits.expsign; \
|
||||
} while (0)
|
||||
|
||||
/*
|
||||
* Set an 80 bit long double from a 16 bit int expsign and a 64 bit int
|
||||
* mantissa.
|
||||
*/
|
||||
|
||||
#define INSERT_LDBL80_WORDS(d,ix0,ix1) \
|
||||
do { \
|
||||
union IEEEl2bits iw_u; \
|
||||
iw_u.xbits.expsign = (ix0); \
|
||||
iw_u.xbits.man = (ix1); \
|
||||
(d) = iw_u.e; \
|
||||
} while (0)
|
||||
|
||||
/*
|
||||
* Set a 128 bit long double from a 16 bit int expsign and two 64 bit ints
|
||||
* comprising the mantissa.
|
||||
*/
|
||||
|
||||
#define INSERT_LDBL128_WORDS(d,ix0,ix1,ix2) \
|
||||
do { \
|
||||
union IEEEl2bits iw_u; \
|
||||
iw_u.xbits.expsign = (ix0); \
|
||||
iw_u.xbits.manh = (ix1); \
|
||||
iw_u.xbits.manl = (ix2); \
|
||||
(d) = iw_u.e; \
|
||||
} while (0)
|
||||
|
||||
/* Set expsign of a long double from a 16 bit int. */
|
||||
|
||||
#define SET_LDBL_EXPSIGN(d,v) \
|
||||
do { \
|
||||
union IEEEl2bits se_u; \
|
||||
se_u.e = (d); \
|
||||
se_u.xbits.expsign = (v); \
|
||||
(d) = se_u.e; \
|
||||
} while (0)
|
||||
|
||||
#ifdef __i386__
|
||||
/* Long double constants are broken on i386. */
|
||||
#define LD80C(m, ex, v) { \
|
||||
.xbits.man = __CONCAT(m, ULL), \
|
||||
.xbits.expsign = (0x3fff + (ex)) | ((v) < 0 ? 0x8000 : 0), \
|
||||
}
|
||||
#else
|
||||
/* The above works on non-i386 too, but we use this to check v. */
|
||||
#define LD80C(m, ex, v) { .e = (v), }
|
||||
#endif
|
||||
|
||||
#ifdef FLT_EVAL_METHOD
|
||||
/*
|
||||
* Attempt to get strict C99 semantics for assignment with non-C99 compilers.
|
||||
*/
|
||||
#if !defined(_MSC_VER) && (FLT_EVAL_METHOD == 0 || __GNUC__ == 0)
|
||||
#define STRICT_ASSIGN(type, lval, rval) ((lval) = (rval))
|
||||
#else
|
||||
#define STRICT_ASSIGN(type, lval, rval) do { \
|
||||
volatile type __lval; \
|
||||
\
|
||||
if (sizeof(type) >= sizeof(long double)) \
|
||||
(lval) = (rval); \
|
||||
else { \
|
||||
__lval = (rval); \
|
||||
(lval) = __lval; \
|
||||
} \
|
||||
} while (0)
|
||||
#endif
|
||||
#else
|
||||
#define STRICT_ASSIGN(type, lval, rval) do { \
|
||||
volatile type __lval; \
|
||||
\
|
||||
if (sizeof(type) >= sizeof(long double)) \
|
||||
(lval) = (rval); \
|
||||
else { \
|
||||
__lval = (rval); \
|
||||
(lval) = __lval; \
|
||||
} \
|
||||
} while (0)
|
||||
#endif /* FLT_EVAL_METHOD */
|
||||
|
||||
/* Support switching the mode to FP_PE if necessary. */
|
||||
#if defined(__i386__) && !defined(NO_FPSETPREC)
|
||||
#define ENTERI() \
|
||||
long double __retval; \
|
||||
fp_prec_t __oprec; \
|
||||
\
|
||||
if ((__oprec = fpgetprec()) != FP_PE) \
|
||||
fpsetprec(FP_PE)
|
||||
#define RETURNI(x) do { \
|
||||
__retval = (x); \
|
||||
if (__oprec != FP_PE) \
|
||||
fpsetprec(__oprec); \
|
||||
RETURNF(__retval); \
|
||||
} while (0)
|
||||
#else
|
||||
#define ENTERI(x)
|
||||
#define RETURNI(x) RETURNF(x)
|
||||
#endif
|
||||
|
||||
/* Default return statement if hack*_t() is not used. */
|
||||
#define RETURNF(v) return (v)
|
||||
|
||||
/*
|
||||
* 2sum gives the same result as 2sumF without requiring |a| >= |b| or
|
||||
* a == 0, but is slower.
|
||||
*/
|
||||
#define _2sum(a, b) do { \
|
||||
__typeof(a) __s, __w; \
|
||||
\
|
||||
__w = (a) + (b); \
|
||||
__s = __w - (a); \
|
||||
(b) = ((a) - (__w - __s)) + ((b) - __s); \
|
||||
(a) = __w; \
|
||||
} while (0)
|
||||
|
||||
/*
|
||||
* 2sumF algorithm.
|
||||
*
|
||||
* "Normalize" the terms in the infinite-precision expression a + b for
|
||||
* the sum of 2 floating point values so that b is as small as possible
|
||||
* relative to 'a'. (The resulting 'a' is the value of the expression in
|
||||
* the same precision as 'a' and the resulting b is the rounding error.)
|
||||
* |a| must be >= |b| or 0, b's type must be no larger than 'a's type, and
|
||||
* exponent overflow or underflow must not occur. This uses a Theorem of
|
||||
* Dekker (1971). See Knuth (1981) 4.2.2 Theorem C. The name "TwoSum"
|
||||
* is apparently due to Skewchuk (1997).
|
||||
*
|
||||
* For this to always work, assignment of a + b to 'a' must not retain any
|
||||
* extra precision in a + b. This is required by C standards but broken
|
||||
* in many compilers. The brokenness cannot be worked around using
|
||||
* STRICT_ASSIGN() like we do elsewhere, since the efficiency of this
|
||||
* algorithm would be destroyed by non-null strict assignments. (The
|
||||
* compilers are correct to be broken -- the efficiency of all floating
|
||||
* point code calculations would be destroyed similarly if they forced the
|
||||
* conversions.)
|
||||
*
|
||||
* Fortunately, a case that works well can usually be arranged by building
|
||||
* any extra precision into the type of 'a' -- 'a' should have type float_t,
|
||||
* double_t or long double. b's type should be no larger than 'a's type.
|
||||
* Callers should use these types with scopes as large as possible, to
|
||||
* reduce their own extra-precision and efficiciency problems. In
|
||||
* particular, they shouldn't convert back and forth just to call here.
|
||||
*/
|
||||
#ifdef DEBUG
|
||||
#define _2sumF(a, b) do { \
|
||||
__typeof(a) __w; \
|
||||
volatile __typeof(a) __ia, __ib, __r, __vw; \
|
||||
\
|
||||
__ia = (a); \
|
||||
__ib = (b); \
|
||||
assert(__ia == 0 || fabsl(__ia) >= fabsl(__ib)); \
|
||||
\
|
||||
__w = (a) + (b); \
|
||||
(b) = ((a) - __w) + (b); \
|
||||
(a) = __w; \
|
||||
\
|
||||
/* The next 2 assertions are weak if (a) is already long double. */ \
|
||||
assert((long double)__ia + __ib == (long double)(a) + (b)); \
|
||||
__vw = __ia + __ib; \
|
||||
__r = __ia - __vw; \
|
||||
__r += __ib; \
|
||||
assert(__vw == (a) && __r == (b)); \
|
||||
} while (0)
|
||||
#else /* !DEBUG */
|
||||
#define _2sumF(a, b) do { \
|
||||
__typeof(a) __w; \
|
||||
\
|
||||
__w = (a) + (b); \
|
||||
(b) = ((a) - __w) + (b); \
|
||||
(a) = __w; \
|
||||
} while (0)
|
||||
#endif /* DEBUG */
|
||||
|
||||
/*
|
||||
* Set x += c, where x is represented in extra precision as a + b.
|
||||
* x must be sufficiently normalized and sufficiently larger than c,
|
||||
* and the result is then sufficiently normalized.
|
||||
*
|
||||
* The details of ordering are that |a| must be >= |c| (so that (a, c)
|
||||
* can be normalized without extra work to swap 'a' with c). The details of
|
||||
* the normalization are that b must be small relative to the normalized 'a'.
|
||||
* Normalization of (a, c) makes the normalized c tiny relative to the
|
||||
* normalized a, so b remains small relative to 'a' in the result. However,
|
||||
* b need not ever be tiny relative to 'a'. For example, b might be about
|
||||
* 2**20 times smaller than 'a' to give about 20 extra bits of precision.
|
||||
* That is usually enough, and adding c (which by normalization is about
|
||||
* 2**53 times smaller than a) cannot change b significantly. However,
|
||||
* cancellation of 'a' with c in normalization of (a, c) may reduce 'a'
|
||||
* significantly relative to b. The caller must ensure that significant
|
||||
* cancellation doesn't occur, either by having c of the same sign as 'a',
|
||||
* or by having |c| a few percent smaller than |a|. Pre-normalization of
|
||||
* (a, b) may help.
|
||||
*
|
||||
* This is is a variant of an algorithm of Kahan (see Knuth (1981) 4.2.2
|
||||
* exercise 19). We gain considerable efficiency by requiring the terms to
|
||||
* be sufficiently normalized and sufficiently increasing.
|
||||
*/
|
||||
#define _3sumF(a, b, c) do { \
|
||||
__typeof(a) __tmp; \
|
||||
\
|
||||
__tmp = (c); \
|
||||
_2sumF(__tmp, (a)); \
|
||||
(b) += (a); \
|
||||
(a) = __tmp; \
|
||||
} while (0)
|
||||
|
||||
/*
|
||||
* Common routine to process the arguments to nan(), nanf(), and nanl().
|
||||
*/
|
||||
void _scan_nan(uint32_t *__words, int __num_words, const char *__s);
|
||||
|
||||
#ifdef _COMPLEX_H
|
||||
|
||||
/*
|
||||
* C99 specifies that complex numbers have the same representation as
|
||||
* an array of two elements, where the first element is the real part
|
||||
* and the second element is the imaginary part.
|
||||
*/
|
||||
typedef union {
|
||||
float complex f;
|
||||
float a[2];
|
||||
} float_complex;
|
||||
typedef union {
|
||||
double complex f;
|
||||
double a[2];
|
||||
} double_complex;
|
||||
typedef union {
|
||||
long double complex f;
|
||||
long double a[2];
|
||||
} long_double_complex;
|
||||
#define REALPART(z) ((z).a[0])
|
||||
#define IMAGPART(z) ((z).a[1])
|
||||
|
||||
/*
|
||||
* Inline functions that can be used to construct complex values.
|
||||
*
|
||||
* The C99 standard intends x+I*y to be used for this, but x+I*y is
|
||||
* currently unusable in general since gcc introduces many overflow,
|
||||
* underflow, sign and efficiency bugs by rewriting I*y as
|
||||
* (0.0+I)*(y+0.0*I) and laboriously computing the full complex product.
|
||||
* In particular, I*Inf is corrupted to NaN+I*Inf, and I*-0 is corrupted
|
||||
* to -0.0+I*0.0.
|
||||
*
|
||||
* The C11 standard introduced the macros CMPLX(), CMPLXF() and CMPLXL()
|
||||
* to construct complex values. Compilers that conform to the C99
|
||||
* standard require the following functions to avoid the above issues.
|
||||
*/
|
||||
|
||||
#ifndef CMPLXF
|
||||
static __inline float complex
|
||||
CMPLXF(float x, float y)
|
||||
{
|
||||
float_complex z;
|
||||
|
||||
REALPART(z) = x;
|
||||
IMAGPART(z) = y;
|
||||
return (z.f);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef CMPLX
|
||||
static __inline double complex
|
||||
CMPLX(double x, double y)
|
||||
{
|
||||
double_complex z;
|
||||
|
||||
REALPART(z) = x;
|
||||
IMAGPART(z) = y;
|
||||
return (z.f);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef CMPLXL
|
||||
static __inline long double complex
|
||||
CMPLXL(long double x, long double y)
|
||||
{
|
||||
long_double_complex z;
|
||||
|
||||
REALPART(z) = x;
|
||||
IMAGPART(z) = y;
|
||||
return (z.f);
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _COMPLEX_H */
|
||||
|
||||
#ifdef __GNUCLIKE_ASM
|
||||
|
||||
/* Asm versions of some functions. */
|
||||
|
||||
#ifdef __amd64__
|
||||
static __inline int
|
||||
irint(double x)
|
||||
{
|
||||
int n;
|
||||
|
||||
asm("cvtsd2si %1,%0" : "=r" (n) : "x" (x));
|
||||
return (n);
|
||||
}
|
||||
#define HAVE_EFFICIENT_IRINT
|
||||
#endif
|
||||
|
||||
#ifdef __i386__
|
||||
static __inline int
|
||||
irint(double x)
|
||||
{
|
||||
int n;
|
||||
|
||||
asm("fistl %0" : "=m" (n) : "t" (x));
|
||||
return (n);
|
||||
}
|
||||
#define HAVE_EFFICIENT_IRINT
|
||||
#endif
|
||||
|
||||
#if defined(__amd64__) || defined(__i386__)
|
||||
static __inline int
|
||||
irintl(long double x)
|
||||
{
|
||||
int n;
|
||||
|
||||
asm("fistl %0" : "=m" (n) : "t" (x));
|
||||
return (n);
|
||||
}
|
||||
#define HAVE_EFFICIENT_IRINTL
|
||||
#endif
|
||||
|
||||
#endif /* __GNUCLIKE_ASM */
|
||||
|
||||
#ifdef DEBUG
|
||||
#if defined(__amd64__) || defined(__i386__)
|
||||
#define breakpoint() asm("int $3")
|
||||
#else
|
||||
#include <signal.h>
|
||||
|
||||
#define breakpoint() raise(SIGTRAP)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* Write a pari script to test things externally. */
|
||||
#ifdef DOPRINT
|
||||
#include <stdio.h>
|
||||
|
||||
#ifndef DOPRINT_SWIZZLE
|
||||
#define DOPRINT_SWIZZLE 0
|
||||
#endif
|
||||
|
||||
#ifdef DOPRINT_LD80
|
||||
|
||||
#define DOPRINT_START(xp) do { \
|
||||
uint64_t __lx; \
|
||||
uint16_t __hx; \
|
||||
\
|
||||
/* Hack to give more-problematic args. */ \
|
||||
EXTRACT_LDBL80_WORDS(__hx, __lx, *xp); \
|
||||
__lx ^= DOPRINT_SWIZZLE; \
|
||||
INSERT_LDBL80_WORDS(*xp, __hx, __lx); \
|
||||
printf("x = %.21Lg; ", (long double)*xp); \
|
||||
} while (0)
|
||||
#define DOPRINT_END1(v) \
|
||||
printf("y = %.21Lg; z = 0; show(x, y, z);\n", (long double)(v))
|
||||
#define DOPRINT_END2(hi, lo) \
|
||||
printf("y = %.21Lg; z = %.21Lg; show(x, y, z);\n", \
|
||||
(long double)(hi), (long double)(lo))
|
||||
|
||||
#elif defined(DOPRINT_D64)
|
||||
|
||||
#define DOPRINT_START(xp) do { \
|
||||
uint32_t __hx, __lx; \
|
||||
\
|
||||
EXTRACT_WORDS(__hx, __lx, *xp); \
|
||||
__lx ^= DOPRINT_SWIZZLE; \
|
||||
INSERT_WORDS(*xp, __hx, __lx); \
|
||||
printf("x = %.21Lg; ", (long double)*xp); \
|
||||
} while (0)
|
||||
#define DOPRINT_END1(v) \
|
||||
printf("y = %.21Lg; z = 0; show(x, y, z);\n", (long double)(v))
|
||||
#define DOPRINT_END2(hi, lo) \
|
||||
printf("y = %.21Lg; z = %.21Lg; show(x, y, z);\n", \
|
||||
(long double)(hi), (long double)(lo))
|
||||
|
||||
#elif defined(DOPRINT_F32)
|
||||
|
||||
#define DOPRINT_START(xp) do { \
|
||||
uint32_t __hx; \
|
||||
\
|
||||
GET_FLOAT_WORD(__hx, *xp); \
|
||||
__hx ^= DOPRINT_SWIZZLE; \
|
||||
SET_FLOAT_WORD(*xp, __hx); \
|
||||
printf("x = %.21Lg; ", (long double)*xp); \
|
||||
} while (0)
|
||||
#define DOPRINT_END1(v) \
|
||||
printf("y = %.21Lg; z = 0; show(x, y, z);\n", (long double)(v))
|
||||
#define DOPRINT_END2(hi, lo) \
|
||||
printf("y = %.21Lg; z = %.21Lg; show(x, y, z);\n", \
|
||||
(long double)(hi), (long double)(lo))
|
||||
|
||||
#else /* !DOPRINT_LD80 && !DOPRINT_D64 (LD128 only) */
|
||||
|
||||
#ifndef DOPRINT_SWIZZLE_HIGH
|
||||
#define DOPRINT_SWIZZLE_HIGH 0
|
||||
#endif
|
||||
|
||||
#define DOPRINT_START(xp) do { \
|
||||
uint64_t __lx, __llx; \
|
||||
uint16_t __hx; \
|
||||
\
|
||||
EXTRACT_LDBL128_WORDS(__hx, __lx, __llx, *xp); \
|
||||
__llx ^= DOPRINT_SWIZZLE; \
|
||||
__lx ^= DOPRINT_SWIZZLE_HIGH; \
|
||||
INSERT_LDBL128_WORDS(*xp, __hx, __lx, __llx); \
|
||||
printf("x = %.36Lg; ", (long double)*xp); \
|
||||
} while (0)
|
||||
#define DOPRINT_END1(v) \
|
||||
printf("y = %.36Lg; z = 0; show(x, y, z);\n", (long double)(v))
|
||||
#define DOPRINT_END2(hi, lo) \
|
||||
printf("y = %.36Lg; z = %.36Lg; show(x, y, z);\n", \
|
||||
(long double)(hi), (long double)(lo))
|
||||
|
||||
#endif /* DOPRINT_LD80 */
|
||||
|
||||
#else /* !DOPRINT */
|
||||
#define DOPRINT_START(xp)
|
||||
#define DOPRINT_END1(v)
|
||||
#define DOPRINT_END2(hi, lo)
|
||||
#endif /* DOPRINT */
|
||||
|
||||
#define RETURNP(x) do { \
|
||||
DOPRINT_END1(x); \
|
||||
RETURNF(x); \
|
||||
} while (0)
|
||||
#define RETURNPI(x) do { \
|
||||
DOPRINT_END1(x); \
|
||||
RETURNI(x); \
|
||||
} while (0)
|
||||
#define RETURN2P(x, y) do { \
|
||||
DOPRINT_END2((x), (y)); \
|
||||
RETURNF((x) + (y)); \
|
||||
} while (0)
|
||||
#define RETURN2PI(x, y) do { \
|
||||
DOPRINT_END2((x), (y)); \
|
||||
RETURNI((x) + (y)); \
|
||||
} while (0)
|
||||
#ifdef STRUCT_RETURN
|
||||
#define RETURNSP(rp) do { \
|
||||
if (!(rp)->lo_set) \
|
||||
RETURNP((rp)->hi); \
|
||||
RETURN2P((rp)->hi, (rp)->lo); \
|
||||
} while (0)
|
||||
#define RETURNSPI(rp) do { \
|
||||
if (!(rp)->lo_set) \
|
||||
RETURNPI((rp)->hi); \
|
||||
RETURN2PI((rp)->hi, (rp)->lo); \
|
||||
} while (0)
|
||||
#endif
|
||||
#define SUM2P(x, y) ({ \
|
||||
const __typeof (x) __x = (x); \
|
||||
const __typeof (y) __y = (y); \
|
||||
\
|
||||
DOPRINT_END2(__x, __y); \
|
||||
__x + __y; \
|
||||
})
|
||||
|
||||
/*
|
||||
* ieee style elementary functions
|
||||
*
|
||||
* We rename functions here to improve other sources' diffability
|
||||
* against fdlibm.
|
||||
*/
|
||||
#define __ieee754_sqrt sqrt
|
||||
#define __ieee754_acos acos
|
||||
#define __ieee754_acosh acosh
|
||||
#define __ieee754_log log
|
||||
#define __ieee754_log2 log2
|
||||
#define __ieee754_atanh atanh
|
||||
#define __ieee754_asin asin
|
||||
#define __ieee754_atan2 atan2
|
||||
#define __ieee754_exp exp
|
||||
#define __ieee754_cosh cosh
|
||||
#define __ieee754_fmod fmod
|
||||
#define __ieee754_pow pow
|
||||
#define __ieee754_lgamma lgamma
|
||||
#define __ieee754_gamma gamma
|
||||
#define __ieee754_lgamma_r lgamma_r
|
||||
#define __ieee754_gamma_r gamma_r
|
||||
#define __ieee754_log10 log10
|
||||
#define __ieee754_sinh sinh
|
||||
#define __ieee754_hypot hypot
|
||||
#define __ieee754_j0 j0
|
||||
#define __ieee754_j1 j1
|
||||
#define __ieee754_y0 y0
|
||||
#define __ieee754_y1 y1
|
||||
#define __ieee754_jn jn
|
||||
#define __ieee754_yn yn
|
||||
#define __ieee754_remainder remainder
|
||||
#define __ieee754_scalb scalb
|
||||
#define __ieee754_sqrtf sqrtf
|
||||
#define __ieee754_acosf acosf
|
||||
#define __ieee754_acoshf acoshf
|
||||
#define __ieee754_logf logf
|
||||
#define __ieee754_atanhf atanhf
|
||||
#define __ieee754_asinf asinf
|
||||
#define __ieee754_atan2f atan2f
|
||||
#define __ieee754_expf expf
|
||||
#define __ieee754_coshf coshf
|
||||
#define __ieee754_fmodf fmodf
|
||||
#define __ieee754_powf powf
|
||||
#define __ieee754_lgammaf lgammaf
|
||||
#define __ieee754_gammaf gammaf
|
||||
#define __ieee754_lgammaf_r lgammaf_r
|
||||
#define __ieee754_gammaf_r gammaf_r
|
||||
#define __ieee754_log10f log10f
|
||||
#define __ieee754_log2f log2f
|
||||
#define __ieee754_sinhf sinhf
|
||||
#define __ieee754_hypotf hypotf
|
||||
#define __ieee754_j0f j0f
|
||||
#define __ieee754_j1f j1f
|
||||
#define __ieee754_y0f y0f
|
||||
#define __ieee754_y1f y1f
|
||||
#define __ieee754_jnf jnf
|
||||
#define __ieee754_ynf ynf
|
||||
#define __ieee754_remainderf remainderf
|
||||
#define __ieee754_scalbf scalbf
|
||||
|
||||
#define acos fdlibm::acos
|
||||
#define asin fdlibm::asin
|
||||
#define atan fdlibm::atan
|
||||
#define atan2 fdlibm::atan2
|
||||
#define cosh fdlibm::cosh
|
||||
#define sinh fdlibm::sinh
|
||||
#define tanh fdlibm::tanh
|
||||
#define exp fdlibm::exp
|
||||
#define log fdlibm::log
|
||||
#define log10 fdlibm::log10
|
||||
#define pow fdlibm::pow
|
||||
#define sqrt fdlibm::sqrt
|
||||
#define ceil fdlibm::ceil
|
||||
#define ceilf fdlibm::ceilf
|
||||
#define fabs fdlibm::fabs
|
||||
#define floor fdlibm::floor
|
||||
#define acosh fdlibm::acosh
|
||||
#define asinh fdlibm::asinh
|
||||
#define atanh fdlibm::atanh
|
||||
#define cbrt fdlibm::cbrt
|
||||
#define expm1 fdlibm::expm1
|
||||
#define hypot fdlibm::hypot
|
||||
#define log1p fdlibm::log1p
|
||||
#define log2 fdlibm::log2
|
||||
#define scalb fdlibm::scalb
|
||||
#define copysign fdlibm::copysign
|
||||
#define scalbn fdlibm::scalbn
|
||||
#define trunc fdlibm::trunc
|
||||
#define truncf fdlibm::truncf
|
||||
#define floorf fdlibm::floorf
|
||||
#define nearbyint fdlibm::nearbyint
|
||||
#define nearbyintf fdlibm::nearbyintf
|
||||
#define rint fdlibm::rint
|
||||
#define rintf fdlibm::rintf
|
||||
|
||||
/* fdlibm kernel function */
|
||||
int __kernel_rem_pio2(double*,double*,int,int,int);
|
||||
|
||||
/* double precision kernel functions */
|
||||
#ifndef INLINE_REM_PIO2
|
||||
int __ieee754_rem_pio2(double,double*);
|
||||
#endif
|
||||
double __kernel_sin(double,double,int);
|
||||
double __kernel_cos(double,double);
|
||||
double __kernel_tan(double,double,int);
|
||||
double __ldexp_exp(double,int);
|
||||
#ifdef _COMPLEX_H
|
||||
double complex __ldexp_cexp(double complex,int);
|
||||
#endif
|
||||
|
||||
/* float precision kernel functions */
|
||||
#ifndef INLINE_REM_PIO2F
|
||||
int __ieee754_rem_pio2f(float,double*);
|
||||
#endif
|
||||
#ifndef INLINE_KERNEL_SINDF
|
||||
float __kernel_sindf(double);
|
||||
#endif
|
||||
#ifndef INLINE_KERNEL_COSDF
|
||||
float __kernel_cosdf(double);
|
||||
#endif
|
||||
#ifndef INLINE_KERNEL_TANDF
|
||||
float __kernel_tandf(double,int);
|
||||
#endif
|
||||
float __ldexp_expf(float,int);
|
||||
#ifdef _COMPLEX_H
|
||||
float complex __ldexp_cexpf(float complex,int);
|
||||
#endif
|
||||
|
||||
/* long double precision kernel functions */
|
||||
long double __kernel_sinl(long double, long double, int);
|
||||
long double __kernel_cosl(long double, long double);
|
||||
long double __kernel_tanl(long double, long double, int);
|
||||
|
||||
#endif /* !_MATH_PRIVATE_H_ */
|
||||
67
modules/fdlibm/src/moz.build
Normal file
67
modules/fdlibm/src/moz.build
Normal file
|
|
@ -0,0 +1,67 @@
|
|||
# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
|
||||
# vim: set filetype=python:
|
||||
# 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/.
|
||||
|
||||
EXPORTS += [
|
||||
'fdlibm.h',
|
||||
]
|
||||
|
||||
FINAL_LIBRARY = 'js'
|
||||
|
||||
if CONFIG['GNU_CXX']:
|
||||
CXXFLAGS += [
|
||||
'-Wno-parentheses',
|
||||
'-Wno-sign-compare',
|
||||
]
|
||||
|
||||
if CONFIG['CLANG_CXX']:
|
||||
CXXFLAGS += [
|
||||
'-Wno-dangling-else',
|
||||
]
|
||||
|
||||
if CONFIG['_MSC_VER']:
|
||||
CXXFLAGS += [
|
||||
'-wd4018', # signed/unsigned mismatch
|
||||
'-wd4146', # unary minus operator applied to unsigned type
|
||||
'-wd4305', # truncation from 'double' to 'const float'
|
||||
'-wd4723', # potential divide by 0
|
||||
'-wd4756', # overflow in constant arithmetic
|
||||
]
|
||||
|
||||
SOURCES += [
|
||||
'e_acos.cpp',
|
||||
'e_acosh.cpp',
|
||||
'e_asin.cpp',
|
||||
'e_atan2.cpp',
|
||||
'e_atanh.cpp',
|
||||
'e_cosh.cpp',
|
||||
'e_exp.cpp',
|
||||
'e_hypot.cpp',
|
||||
'e_log.cpp',
|
||||
'e_log10.cpp',
|
||||
'e_log2.cpp',
|
||||
'e_pow.cpp',
|
||||
'e_sinh.cpp',
|
||||
'e_sqrt.cpp',
|
||||
'k_exp.cpp',
|
||||
's_asinh.cpp',
|
||||
's_atan.cpp',
|
||||
's_cbrt.cpp',
|
||||
's_ceil.cpp',
|
||||
's_ceilf.cpp',
|
||||
's_copysign.cpp',
|
||||
's_expm1.cpp',
|
||||
's_fabs.cpp',
|
||||
's_floor.cpp',
|
||||
's_floorf.cpp',
|
||||
's_log1p.cpp',
|
||||
's_nearbyint.cpp',
|
||||
's_rint.cpp',
|
||||
's_rintf.cpp',
|
||||
's_scalbn.cpp',
|
||||
's_tanh.cpp',
|
||||
's_trunc.cpp',
|
||||
's_truncf.cpp',
|
||||
]
|
||||
57
modules/fdlibm/src/s_asinh.cpp
Normal file
57
modules/fdlibm/src/s_asinh.cpp
Normal file
|
|
@ -0,0 +1,57 @@
|
|||
/* @(#)s_asinh.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* asinh(x)
|
||||
* Method :
|
||||
* Based on
|
||||
* asinh(x) = sign(x) * log [ |x| + sqrt(x*x+1) ]
|
||||
* we have
|
||||
* asinh(x) := x if 1+x*x=1,
|
||||
* := sign(x)*(log(x)+ln2)) for large |x|, else
|
||||
* := sign(x)*log(2|x|+1/(|x|+sqrt(x*x+1))) if|x|>2, else
|
||||
* := sign(x)*log1p(|x| + x^2/(1 + sqrt(1+x^2)))
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const double
|
||||
one = 1.00000000000000000000e+00, /* 0x3FF00000, 0x00000000 */
|
||||
ln2 = 6.93147180559945286227e-01, /* 0x3FE62E42, 0xFEFA39EF */
|
||||
huge= 1.00000000000000000000e+300;
|
||||
|
||||
double
|
||||
asinh(double x)
|
||||
{
|
||||
double t,w;
|
||||
int32_t hx,ix;
|
||||
GET_HIGH_WORD(hx,x);
|
||||
ix = hx&0x7fffffff;
|
||||
if(ix>=0x7ff00000) return x+x; /* x is inf or NaN */
|
||||
if(ix< 0x3e300000) { /* |x|<2**-28 */
|
||||
if(huge+x>one) return x; /* return x inexact except 0 */
|
||||
}
|
||||
if(ix>0x41b00000) { /* |x| > 2**28 */
|
||||
w = __ieee754_log(fabs(x))+ln2;
|
||||
} else if (ix>0x40000000) { /* 2**28 > |x| > 2.0 */
|
||||
t = fabs(x);
|
||||
w = __ieee754_log(2.0*t+one/(__ieee754_sqrt(x*x+one)+t));
|
||||
} else { /* 2.0 > |x| > 2**-28 */
|
||||
t = x*x;
|
||||
w =log1p(fabs(x)+t/(one+__ieee754_sqrt(one+t)));
|
||||
}
|
||||
if(hx>0) return w; else return -w;
|
||||
}
|
||||
119
modules/fdlibm/src/s_atan.cpp
Normal file
119
modules/fdlibm/src/s_atan.cpp
Normal file
|
|
@ -0,0 +1,119 @@
|
|||
/* @(#)s_atan.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* atan(x)
|
||||
* Method
|
||||
* 1. Reduce x to positive by atan(x) = -atan(-x).
|
||||
* 2. According to the integer k=4t+0.25 chopped, t=x, the argument
|
||||
* is further reduced to one of the following intervals and the
|
||||
* arctangent of t is evaluated by the corresponding formula:
|
||||
*
|
||||
* [0,7/16] atan(x) = t-t^3*(a1+t^2*(a2+...(a10+t^2*a11)...)
|
||||
* [7/16,11/16] atan(x) = atan(1/2) + atan( (t-0.5)/(1+t/2) )
|
||||
* [11/16.19/16] atan(x) = atan( 1 ) + atan( (t-1)/(1+t) )
|
||||
* [19/16,39/16] atan(x) = atan(3/2) + atan( (t-1.5)/(1+1.5t) )
|
||||
* [39/16,INF] atan(x) = atan(INF) + atan( -1/t )
|
||||
*
|
||||
* Constants:
|
||||
* The hexadecimal values are the intended ones for the following
|
||||
* constants. The decimal values may be used, provided that the
|
||||
* compiler will convert from decimal to binary accurately enough
|
||||
* to produce the hexadecimal values shown.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const double atanhi[] = {
|
||||
4.63647609000806093515e-01, /* atan(0.5)hi 0x3FDDAC67, 0x0561BB4F */
|
||||
7.85398163397448278999e-01, /* atan(1.0)hi 0x3FE921FB, 0x54442D18 */
|
||||
9.82793723247329054082e-01, /* atan(1.5)hi 0x3FEF730B, 0xD281F69B */
|
||||
1.57079632679489655800e+00, /* atan(inf)hi 0x3FF921FB, 0x54442D18 */
|
||||
};
|
||||
|
||||
static const double atanlo[] = {
|
||||
2.26987774529616870924e-17, /* atan(0.5)lo 0x3C7A2B7F, 0x222F65E2 */
|
||||
3.06161699786838301793e-17, /* atan(1.0)lo 0x3C81A626, 0x33145C07 */
|
||||
1.39033110312309984516e-17, /* atan(1.5)lo 0x3C700788, 0x7AF0CBBD */
|
||||
6.12323399573676603587e-17, /* atan(inf)lo 0x3C91A626, 0x33145C07 */
|
||||
};
|
||||
|
||||
static const double aT[] = {
|
||||
3.33333333333329318027e-01, /* 0x3FD55555, 0x5555550D */
|
||||
-1.99999999998764832476e-01, /* 0xBFC99999, 0x9998EBC4 */
|
||||
1.42857142725034663711e-01, /* 0x3FC24924, 0x920083FF */
|
||||
-1.11111104054623557880e-01, /* 0xBFBC71C6, 0xFE231671 */
|
||||
9.09088713343650656196e-02, /* 0x3FB745CD, 0xC54C206E */
|
||||
-7.69187620504482999495e-02, /* 0xBFB3B0F2, 0xAF749A6D */
|
||||
6.66107313738753120669e-02, /* 0x3FB10D66, 0xA0D03D51 */
|
||||
-5.83357013379057348645e-02, /* 0xBFADDE2D, 0x52DEFD9A */
|
||||
4.97687799461593236017e-02, /* 0x3FA97B4B, 0x24760DEB */
|
||||
-3.65315727442169155270e-02, /* 0xBFA2B444, 0x2C6A6C2F */
|
||||
1.62858201153657823623e-02, /* 0x3F90AD3A, 0xE322DA11 */
|
||||
};
|
||||
|
||||
static const double
|
||||
one = 1.0,
|
||||
huge = 1.0e300;
|
||||
|
||||
double
|
||||
atan(double x)
|
||||
{
|
||||
double w,s1,s2,z;
|
||||
int32_t ix,hx,id;
|
||||
|
||||
GET_HIGH_WORD(hx,x);
|
||||
ix = hx&0x7fffffff;
|
||||
if(ix>=0x44100000) { /* if |x| >= 2^66 */
|
||||
u_int32_t low;
|
||||
GET_LOW_WORD(low,x);
|
||||
if(ix>0x7ff00000||
|
||||
(ix==0x7ff00000&&(low!=0)))
|
||||
return x+x; /* NaN */
|
||||
if(hx>0) return atanhi[3]+*(volatile double *)&atanlo[3];
|
||||
else return -atanhi[3]-*(volatile double *)&atanlo[3];
|
||||
} if (ix < 0x3fdc0000) { /* |x| < 0.4375 */
|
||||
if (ix < 0x3e400000) { /* |x| < 2^-27 */
|
||||
if(huge+x>one) return x; /* raise inexact */
|
||||
}
|
||||
id = -1;
|
||||
} else {
|
||||
x = fabs(x);
|
||||
if (ix < 0x3ff30000) { /* |x| < 1.1875 */
|
||||
if (ix < 0x3fe60000) { /* 7/16 <=|x|<11/16 */
|
||||
id = 0; x = (2.0*x-one)/(2.0+x);
|
||||
} else { /* 11/16<=|x|< 19/16 */
|
||||
id = 1; x = (x-one)/(x+one);
|
||||
}
|
||||
} else {
|
||||
if (ix < 0x40038000) { /* |x| < 2.4375 */
|
||||
id = 2; x = (x-1.5)/(one+1.5*x);
|
||||
} else { /* 2.4375 <= |x| < 2^66 */
|
||||
id = 3; x = -1.0/x;
|
||||
}
|
||||
}}
|
||||
/* end of argument reduction */
|
||||
z = x*x;
|
||||
w = z*z;
|
||||
/* break sum from i=0 to 10 aT[i]z**(i+1) into odd and even poly */
|
||||
s1 = z*(aT[0]+w*(aT[2]+w*(aT[4]+w*(aT[6]+w*(aT[8]+w*aT[10])))));
|
||||
s2 = w*(aT[1]+w*(aT[3]+w*(aT[5]+w*(aT[7]+w*aT[9]))));
|
||||
if (id<0) return x - x*(s1+s2);
|
||||
else {
|
||||
z = atanhi[id] - ((x*(s1+s2) - atanlo[id]) - x);
|
||||
return (hx<0)? -z:z;
|
||||
}
|
||||
}
|
||||
112
modules/fdlibm/src/s_cbrt.cpp
Normal file
112
modules/fdlibm/src/s_cbrt.cpp
Normal file
|
|
@ -0,0 +1,112 @@
|
|||
/* @(#)s_cbrt.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*
|
||||
* Optimized by Bruce D. Evans.
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
/* cbrt(x)
|
||||
* Return cube root of x
|
||||
*/
|
||||
static const u_int32_t
|
||||
B1 = 715094163, /* B1 = (1023-1023/3-0.03306235651)*2**20 */
|
||||
B2 = 696219795; /* B2 = (1023-1023/3-54/3-0.03306235651)*2**20 */
|
||||
|
||||
/* |1/cbrt(x) - p(x)| < 2**-23.5 (~[-7.93e-8, 7.929e-8]). */
|
||||
static const double
|
||||
P0 = 1.87595182427177009643, /* 0x3ffe03e6, 0x0f61e692 */
|
||||
P1 = -1.88497979543377169875, /* 0xbffe28e0, 0x92f02420 */
|
||||
P2 = 1.621429720105354466140, /* 0x3ff9f160, 0x4a49d6c2 */
|
||||
P3 = -0.758397934778766047437, /* 0xbfe844cb, 0xbee751d9 */
|
||||
P4 = 0.145996192886612446982; /* 0x3fc2b000, 0xd4e4edd7 */
|
||||
|
||||
double
|
||||
cbrt(double x)
|
||||
{
|
||||
int32_t hx;
|
||||
union {
|
||||
double value;
|
||||
uint64_t bits;
|
||||
} u;
|
||||
double r,s,t=0.0,w;
|
||||
u_int32_t sign;
|
||||
u_int32_t high,low;
|
||||
|
||||
EXTRACT_WORDS(hx,low,x);
|
||||
sign=hx&0x80000000; /* sign= sign(x) */
|
||||
hx ^=sign;
|
||||
if(hx>=0x7ff00000) return(x+x); /* cbrt(NaN,INF) is itself */
|
||||
|
||||
/*
|
||||
* Rough cbrt to 5 bits:
|
||||
* cbrt(2**e*(1+m) ~= 2**(e/3)*(1+(e%3+m)/3)
|
||||
* where e is integral and >= 0, m is real and in [0, 1), and "/" and
|
||||
* "%" are integer division and modulus with rounding towards minus
|
||||
* infinity. The RHS is always >= the LHS and has a maximum relative
|
||||
* error of about 1 in 16. Adding a bias of -0.03306235651 to the
|
||||
* (e%3+m)/3 term reduces the error to about 1 in 32. With the IEEE
|
||||
* floating point representation, for finite positive normal values,
|
||||
* ordinary integer division of the value in bits magically gives
|
||||
* almost exactly the RHS of the above provided we first subtract the
|
||||
* exponent bias (1023 for doubles) and later add it back. We do the
|
||||
* subtraction virtually to keep e >= 0 so that ordinary integer
|
||||
* division rounds towards minus infinity; this is also efficient.
|
||||
*/
|
||||
if(hx<0x00100000) { /* zero or subnormal? */
|
||||
if((hx|low)==0)
|
||||
return(x); /* cbrt(0) is itself */
|
||||
SET_HIGH_WORD(t,0x43500000); /* set t= 2**54 */
|
||||
t*=x;
|
||||
GET_HIGH_WORD(high,t);
|
||||
INSERT_WORDS(t,sign|((high&0x7fffffff)/3+B2),0);
|
||||
} else
|
||||
INSERT_WORDS(t,sign|(hx/3+B1),0);
|
||||
|
||||
/*
|
||||
* New cbrt to 23 bits:
|
||||
* cbrt(x) = t*cbrt(x/t**3) ~= t*P(t**3/x)
|
||||
* where P(r) is a polynomial of degree 4 that approximates 1/cbrt(r)
|
||||
* to within 2**-23.5 when |r - 1| < 1/10. The rough approximation
|
||||
* has produced t such than |t/cbrt(x) - 1| ~< 1/32, and cubing this
|
||||
* gives us bounds for r = t**3/x.
|
||||
*
|
||||
* Try to optimize for parallel evaluation as in k_tanf.c.
|
||||
*/
|
||||
r=(t*t)*(t/x);
|
||||
t=t*((P0+r*(P1+r*P2))+((r*r)*r)*(P3+r*P4));
|
||||
|
||||
/*
|
||||
* Round t away from zero to 23 bits (sloppily except for ensuring that
|
||||
* the result is larger in magnitude than cbrt(x) but not much more than
|
||||
* 2 23-bit ulps larger). With rounding towards zero, the error bound
|
||||
* would be ~5/6 instead of ~4/6. With a maximum error of 2 23-bit ulps
|
||||
* in the rounded t, the infinite-precision error in the Newton
|
||||
* approximation barely affects third digit in the final error
|
||||
* 0.667; the error in the rounded t can be up to about 3 23-bit ulps
|
||||
* before the final error is larger than 0.667 ulps.
|
||||
*/
|
||||
u.value=t;
|
||||
u.bits=(u.bits+0x80000000)&0xffffffffc0000000ULL;
|
||||
t=u.value;
|
||||
|
||||
/* one step Newton iteration to 53 bits with error < 0.667 ulps */
|
||||
s=t*t; /* t*t is exact */
|
||||
r=x/s; /* error <= 0.5 ulps; |r| < |t| */
|
||||
w=t+t; /* t+t is exact */
|
||||
r=(r-t)/(w+r); /* r-t is exact; w+r ~= 3*t */
|
||||
t=t+t*r; /* error <= 0.5 + 0.5/3 + epsilon */
|
||||
|
||||
return(t);
|
||||
}
|
||||
72
modules/fdlibm/src/s_ceil.cpp
Normal file
72
modules/fdlibm/src/s_ceil.cpp
Normal file
|
|
@ -0,0 +1,72 @@
|
|||
/* @(#)s_ceil.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
* ceil(x)
|
||||
* Return x rounded toward -inf to integral value
|
||||
* Method:
|
||||
* Bit twiddling.
|
||||
* Exception:
|
||||
* Inexact flag raised if x not equal to ceil(x).
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const double huge = 1.0e300;
|
||||
|
||||
double
|
||||
ceil(double x)
|
||||
{
|
||||
int32_t i0,i1,j0;
|
||||
u_int32_t i,j;
|
||||
EXTRACT_WORDS(i0,i1,x);
|
||||
j0 = ((i0>>20)&0x7ff)-0x3ff;
|
||||
if(j0<20) {
|
||||
if(j0<0) { /* raise inexact if x != 0 */
|
||||
if(huge+x>0.0) {/* return 0*sign(x) if |x|<1 */
|
||||
if(i0<0) {i0=0x80000000;i1=0;}
|
||||
else if((i0|i1)!=0) { i0=0x3ff00000;i1=0;}
|
||||
}
|
||||
} else {
|
||||
i = (0x000fffff)>>j0;
|
||||
if(((i0&i)|i1)==0) return x; /* x is integral */
|
||||
if(huge+x>0.0) { /* raise inexact flag */
|
||||
if(i0>0) i0 += (0x00100000)>>j0;
|
||||
i0 &= (~i); i1=0;
|
||||
}
|
||||
}
|
||||
} else if (j0>51) {
|
||||
if(j0==0x400) return x+x; /* inf or NaN */
|
||||
else return x; /* x is integral */
|
||||
} else {
|
||||
i = ((u_int32_t)(0xffffffff))>>(j0-20);
|
||||
if((i1&i)==0) return x; /* x is integral */
|
||||
if(huge+x>0.0) { /* raise inexact flag */
|
||||
if(i0>0) {
|
||||
if(j0==20) i0+=1;
|
||||
else {
|
||||
j = i1 + (1<<(52-j0));
|
||||
if(j<i1) i0+=1; /* got a carry */
|
||||
i1 = j;
|
||||
}
|
||||
}
|
||||
i1 &= (~i);
|
||||
}
|
||||
}
|
||||
INSERT_WORDS(x,i0,i1);
|
||||
return x;
|
||||
}
|
||||
51
modules/fdlibm/src/s_ceilf.cpp
Normal file
51
modules/fdlibm/src/s_ceilf.cpp
Normal file
|
|
@ -0,0 +1,51 @@
|
|||
/* s_ceilf.c -- float version of s_ceil.c.
|
||||
* Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
|
||||
*/
|
||||
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const float huge = 1.0e30;
|
||||
|
||||
float
|
||||
ceilf(float x)
|
||||
{
|
||||
int32_t i0,j0;
|
||||
u_int32_t i;
|
||||
|
||||
GET_FLOAT_WORD(i0,x);
|
||||
j0 = ((i0>>23)&0xff)-0x7f;
|
||||
if(j0<23) {
|
||||
if(j0<0) { /* raise inexact if x != 0 */
|
||||
if(huge+x>(float)0.0) {/* return 0*sign(x) if |x|<1 */
|
||||
if(i0<0) {i0=0x80000000;}
|
||||
else if(i0!=0) { i0=0x3f800000;}
|
||||
}
|
||||
} else {
|
||||
i = (0x007fffff)>>j0;
|
||||
if((i0&i)==0) return x; /* x is integral */
|
||||
if(huge+x>(float)0.0) { /* raise inexact flag */
|
||||
if(i0>0) i0 += (0x00800000)>>j0;
|
||||
i0 &= (~i);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if(j0==0x80) return x+x; /* inf or NaN */
|
||||
else return x; /* x is integral */
|
||||
}
|
||||
SET_FLOAT_WORD(x,i0);
|
||||
return x;
|
||||
}
|
||||
32
modules/fdlibm/src/s_copysign.cpp
Normal file
32
modules/fdlibm/src/s_copysign.cpp
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
/* @(#)s_copysign.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
* copysign(double x, double y)
|
||||
* copysign(x,y) returns a value with the magnitude of x and
|
||||
* with the sign bit of y.
|
||||
*/
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
double
|
||||
copysign(double x, double y)
|
||||
{
|
||||
u_int32_t hx,hy;
|
||||
GET_HIGH_WORD(hx,x);
|
||||
GET_HIGH_WORD(hy,y);
|
||||
SET_HIGH_WORD(x,(hx&0x7fffffff)|(hy&0x80000000));
|
||||
return x;
|
||||
}
|
||||
220
modules/fdlibm/src/s_expm1.cpp
Normal file
220
modules/fdlibm/src/s_expm1.cpp
Normal file
|
|
@ -0,0 +1,220 @@
|
|||
/* @(#)s_expm1.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* expm1(x)
|
||||
* Returns exp(x)-1, the exponential of x minus 1.
|
||||
*
|
||||
* Method
|
||||
* 1. Argument reduction:
|
||||
* Given x, find r and integer k such that
|
||||
*
|
||||
* x = k*ln2 + r, |r| <= 0.5*ln2 ~ 0.34658
|
||||
*
|
||||
* Here a correction term c will be computed to compensate
|
||||
* the error in r when rounded to a floating-point number.
|
||||
*
|
||||
* 2. Approximating expm1(r) by a special rational function on
|
||||
* the interval [0,0.34658]:
|
||||
* Since
|
||||
* r*(exp(r)+1)/(exp(r)-1) = 2+ r^2/6 - r^4/360 + ...
|
||||
* we define R1(r*r) by
|
||||
* r*(exp(r)+1)/(exp(r)-1) = 2+ r^2/6 * R1(r*r)
|
||||
* That is,
|
||||
* R1(r**2) = 6/r *((exp(r)+1)/(exp(r)-1) - 2/r)
|
||||
* = 6/r * ( 1 + 2.0*(1/(exp(r)-1) - 1/r))
|
||||
* = 1 - r^2/60 + r^4/2520 - r^6/100800 + ...
|
||||
* We use a special Reme algorithm on [0,0.347] to generate
|
||||
* a polynomial of degree 5 in r*r to approximate R1. The
|
||||
* maximum error of this polynomial approximation is bounded
|
||||
* by 2**-61. In other words,
|
||||
* R1(z) ~ 1.0 + Q1*z + Q2*z**2 + Q3*z**3 + Q4*z**4 + Q5*z**5
|
||||
* where Q1 = -1.6666666666666567384E-2,
|
||||
* Q2 = 3.9682539681370365873E-4,
|
||||
* Q3 = -9.9206344733435987357E-6,
|
||||
* Q4 = 2.5051361420808517002E-7,
|
||||
* Q5 = -6.2843505682382617102E-9;
|
||||
* z = r*r,
|
||||
* with error bounded by
|
||||
* | 5 | -61
|
||||
* | 1.0+Q1*z+...+Q5*z - R1(z) | <= 2
|
||||
* | |
|
||||
*
|
||||
* expm1(r) = exp(r)-1 is then computed by the following
|
||||
* specific way which minimize the accumulation rounding error:
|
||||
* 2 3
|
||||
* r r [ 3 - (R1 + R1*r/2) ]
|
||||
* expm1(r) = r + --- + --- * [--------------------]
|
||||
* 2 2 [ 6 - r*(3 - R1*r/2) ]
|
||||
*
|
||||
* To compensate the error in the argument reduction, we use
|
||||
* expm1(r+c) = expm1(r) + c + expm1(r)*c
|
||||
* ~ expm1(r) + c + r*c
|
||||
* Thus c+r*c will be added in as the correction terms for
|
||||
* expm1(r+c). Now rearrange the term to avoid optimization
|
||||
* screw up:
|
||||
* ( 2 2 )
|
||||
* ({ ( r [ R1 - (3 - R1*r/2) ] ) } r )
|
||||
* expm1(r+c)~r - ({r*(--- * [--------------------]-c)-c} - --- )
|
||||
* ({ ( 2 [ 6 - r*(3 - R1*r/2) ] ) } 2 )
|
||||
* ( )
|
||||
*
|
||||
* = r - E
|
||||
* 3. Scale back to obtain expm1(x):
|
||||
* From step 1, we have
|
||||
* expm1(x) = either 2^k*[expm1(r)+1] - 1
|
||||
* = or 2^k*[expm1(r) + (1-2^-k)]
|
||||
* 4. Implementation notes:
|
||||
* (A). To save one multiplication, we scale the coefficient Qi
|
||||
* to Qi*2^i, and replace z by (x^2)/2.
|
||||
* (B). To achieve maximum accuracy, we compute expm1(x) by
|
||||
* (i) if x < -56*ln2, return -1.0, (raise inexact if x!=inf)
|
||||
* (ii) if k=0, return r-E
|
||||
* (iii) if k=-1, return 0.5*(r-E)-0.5
|
||||
* (iv) if k=1 if r < -0.25, return 2*((r+0.5)- E)
|
||||
* else return 1.0+2.0*(r-E);
|
||||
* (v) if (k<-2||k>56) return 2^k(1-(E-r)) - 1 (or exp(x)-1)
|
||||
* (vi) if k <= 20, return 2^k((1-2^-k)-(E-r)), else
|
||||
* (vii) return 2^k(1-((E+2^-k)-r))
|
||||
*
|
||||
* Special cases:
|
||||
* expm1(INF) is INF, expm1(NaN) is NaN;
|
||||
* expm1(-INF) is -1, and
|
||||
* for finite argument, only expm1(0)=0 is exact.
|
||||
*
|
||||
* Accuracy:
|
||||
* according to an error analysis, the error is always less than
|
||||
* 1 ulp (unit in the last place).
|
||||
*
|
||||
* Misc. info.
|
||||
* For IEEE double
|
||||
* if x > 7.09782712893383973096e+02 then expm1(x) overflow
|
||||
*
|
||||
* Constants:
|
||||
* The hexadecimal values are the intended ones for the following
|
||||
* constants. The decimal values may be used, provided that the
|
||||
* compiler will convert from decimal to binary accurately enough
|
||||
* to produce the hexadecimal values shown.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const double
|
||||
one = 1.0,
|
||||
tiny = 1.0e-300,
|
||||
o_threshold = 7.09782712893383973096e+02,/* 0x40862E42, 0xFEFA39EF */
|
||||
ln2_hi = 6.93147180369123816490e-01,/* 0x3fe62e42, 0xfee00000 */
|
||||
ln2_lo = 1.90821492927058770002e-10,/* 0x3dea39ef, 0x35793c76 */
|
||||
invln2 = 1.44269504088896338700e+00,/* 0x3ff71547, 0x652b82fe */
|
||||
/* Scaled Q's: Qn_here = 2**n * Qn_above, for R(2*z) where z = hxs = x*x/2: */
|
||||
Q1 = -3.33333333333331316428e-02, /* BFA11111 111110F4 */
|
||||
Q2 = 1.58730158725481460165e-03, /* 3F5A01A0 19FE5585 */
|
||||
Q3 = -7.93650757867487942473e-05, /* BF14CE19 9EAADBB7 */
|
||||
Q4 = 4.00821782732936239552e-06, /* 3ED0CFCA 86E65239 */
|
||||
Q5 = -2.01099218183624371326e-07; /* BE8AFDB7 6E09C32D */
|
||||
|
||||
static volatile double huge = 1.0e+300;
|
||||
|
||||
double
|
||||
expm1(double x)
|
||||
{
|
||||
double y,hi,lo,c,t,e,hxs,hfx,r1,twopk;
|
||||
int32_t k,xsb;
|
||||
u_int32_t hx;
|
||||
|
||||
GET_HIGH_WORD(hx,x);
|
||||
xsb = hx&0x80000000; /* sign bit of x */
|
||||
hx &= 0x7fffffff; /* high word of |x| */
|
||||
|
||||
/* filter out huge and non-finite argument */
|
||||
if(hx >= 0x4043687A) { /* if |x|>=56*ln2 */
|
||||
if(hx >= 0x40862E42) { /* if |x|>=709.78... */
|
||||
if(hx>=0x7ff00000) {
|
||||
u_int32_t low;
|
||||
GET_LOW_WORD(low,x);
|
||||
if(((hx&0xfffff)|low)!=0)
|
||||
return x+x; /* NaN */
|
||||
else return (xsb==0)? x:-1.0;/* exp(+-inf)={inf,-1} */
|
||||
}
|
||||
if(x > o_threshold) return huge*huge; /* overflow */
|
||||
}
|
||||
if(xsb!=0) { /* x < -56*ln2, return -1.0 with inexact */
|
||||
if(x+tiny<0.0) /* raise inexact */
|
||||
return tiny-one; /* return -1 */
|
||||
}
|
||||
}
|
||||
|
||||
/* argument reduction */
|
||||
if(hx > 0x3fd62e42) { /* if |x| > 0.5 ln2 */
|
||||
if(hx < 0x3FF0A2B2) { /* and |x| < 1.5 ln2 */
|
||||
if(xsb==0)
|
||||
{hi = x - ln2_hi; lo = ln2_lo; k = 1;}
|
||||
else
|
||||
{hi = x + ln2_hi; lo = -ln2_lo; k = -1;}
|
||||
} else {
|
||||
k = invln2*x+((xsb==0)?0.5:-0.5);
|
||||
t = k;
|
||||
hi = x - t*ln2_hi; /* t*ln2_hi is exact here */
|
||||
lo = t*ln2_lo;
|
||||
}
|
||||
STRICT_ASSIGN(double, x, hi - lo);
|
||||
c = (hi-x)-lo;
|
||||
}
|
||||
else if(hx < 0x3c900000) { /* when |x|<2**-54, return x */
|
||||
t = huge+x; /* return x with inexact flags when x!=0 */
|
||||
return x - (t-(huge+x));
|
||||
}
|
||||
else k = 0;
|
||||
|
||||
/* x is now in primary range */
|
||||
hfx = 0.5*x;
|
||||
hxs = x*hfx;
|
||||
r1 = one+hxs*(Q1+hxs*(Q2+hxs*(Q3+hxs*(Q4+hxs*Q5))));
|
||||
t = 3.0-r1*hfx;
|
||||
e = hxs*((r1-t)/(6.0 - x*t));
|
||||
if(k==0) return x - (x*e-hxs); /* c is 0 */
|
||||
else {
|
||||
INSERT_WORDS(twopk,0x3ff00000+(k<<20),0); /* 2^k */
|
||||
e = (x*(e-c)-c);
|
||||
e -= hxs;
|
||||
if(k== -1) return 0.5*(x-e)-0.5;
|
||||
if(k==1) {
|
||||
if(x < -0.25) return -2.0*(e-(x+0.5));
|
||||
else return one+2.0*(x-e);
|
||||
}
|
||||
if (k <= -2 || k>56) { /* suffice to return exp(x)-1 */
|
||||
y = one-(e-x);
|
||||
if (k == 1024) {
|
||||
double const_0x1p1023 = pow(2, 1023);
|
||||
y = y*2.0*const_0x1p1023;
|
||||
}
|
||||
else y = y*twopk;
|
||||
return y-one;
|
||||
}
|
||||
t = one;
|
||||
if(k<20) {
|
||||
SET_HIGH_WORD(t,0x3ff00000 - (0x200000>>k)); /* t=1-2^-k */
|
||||
y = t-(e-x);
|
||||
y = y*twopk;
|
||||
} else {
|
||||
SET_HIGH_WORD(t,((0x3ff-k)<<20)); /* 2^-k */
|
||||
y = x-(e+t);
|
||||
y += one;
|
||||
y = y*twopk;
|
||||
}
|
||||
}
|
||||
return y;
|
||||
}
|
||||
30
modules/fdlibm/src/s_fabs.cpp
Normal file
30
modules/fdlibm/src/s_fabs.cpp
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
/* @(#)s_fabs.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
#ifndef lint
|
||||
//static char rcsid[] = "$FreeBSD$";
|
||||
#endif
|
||||
|
||||
/*
|
||||
* fabs(x) returns the absolute value of x.
|
||||
*/
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
double
|
||||
fabs(double x)
|
||||
{
|
||||
u_int32_t high;
|
||||
GET_HIGH_WORD(high,x);
|
||||
SET_HIGH_WORD(x,high&0x7fffffff);
|
||||
return x;
|
||||
}
|
||||
73
modules/fdlibm/src/s_floor.cpp
Normal file
73
modules/fdlibm/src/s_floor.cpp
Normal file
|
|
@ -0,0 +1,73 @@
|
|||
/* @(#)s_floor.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
* floor(x)
|
||||
* Return x rounded toward -inf to integral value
|
||||
* Method:
|
||||
* Bit twiddling.
|
||||
* Exception:
|
||||
* Inexact flag raised if x not equal to floor(x).
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const double huge = 1.0e300;
|
||||
|
||||
double
|
||||
floor(double x)
|
||||
{
|
||||
int32_t i0,i1,j0;
|
||||
u_int32_t i,j;
|
||||
EXTRACT_WORDS(i0,i1,x);
|
||||
j0 = ((i0>>20)&0x7ff)-0x3ff;
|
||||
if(j0<20) {
|
||||
if(j0<0) { /* raise inexact if x != 0 */
|
||||
if(huge+x>0.0) {/* return 0*sign(x) if |x|<1 */
|
||||
if(i0>=0) {i0=i1=0;}
|
||||
else if(((i0&0x7fffffff)|i1)!=0)
|
||||
{ i0=0xbff00000;i1=0;}
|
||||
}
|
||||
} else {
|
||||
i = (0x000fffff)>>j0;
|
||||
if(((i0&i)|i1)==0) return x; /* x is integral */
|
||||
if(huge+x>0.0) { /* raise inexact flag */
|
||||
if(i0<0) i0 += (0x00100000)>>j0;
|
||||
i0 &= (~i); i1=0;
|
||||
}
|
||||
}
|
||||
} else if (j0>51) {
|
||||
if(j0==0x400) return x+x; /* inf or NaN */
|
||||
else return x; /* x is integral */
|
||||
} else {
|
||||
i = ((u_int32_t)(0xffffffff))>>(j0-20);
|
||||
if((i1&i)==0) return x; /* x is integral */
|
||||
if(huge+x>0.0) { /* raise inexact flag */
|
||||
if(i0<0) {
|
||||
if(j0==20) i0+=1;
|
||||
else {
|
||||
j = i1+(1<<(52-j0));
|
||||
if(j<i1) i0 +=1 ; /* got a carry */
|
||||
i1=j;
|
||||
}
|
||||
}
|
||||
i1 &= (~i);
|
||||
}
|
||||
}
|
||||
INSERT_WORDS(x,i0,i1);
|
||||
return x;
|
||||
}
|
||||
60
modules/fdlibm/src/s_floorf.cpp
Normal file
60
modules/fdlibm/src/s_floorf.cpp
Normal file
|
|
@ -0,0 +1,60 @@
|
|||
/* s_floorf.c -- float version of s_floor.c.
|
||||
* Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
|
||||
*/
|
||||
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
* floorf(x)
|
||||
* Return x rounded toward -inf to integral value
|
||||
* Method:
|
||||
* Bit twiddling.
|
||||
* Exception:
|
||||
* Inexact flag raised if x not equal to floorf(x).
|
||||
*/
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const float huge = 1.0e30;
|
||||
|
||||
float
|
||||
floorf(float x)
|
||||
{
|
||||
int32_t i0,j0;
|
||||
u_int32_t i;
|
||||
GET_FLOAT_WORD(i0,x);
|
||||
j0 = ((i0>>23)&0xff)-0x7f;
|
||||
if(j0<23) {
|
||||
if(j0<0) { /* raise inexact if x != 0 */
|
||||
if(huge+x>(float)0.0) {/* return 0*sign(x) if |x|<1 */
|
||||
if(i0>=0) {i0=0;}
|
||||
else if((i0&0x7fffffff)!=0)
|
||||
{ i0=0xbf800000;}
|
||||
}
|
||||
} else {
|
||||
i = (0x007fffff)>>j0;
|
||||
if((i0&i)==0) return x; /* x is integral */
|
||||
if(huge+x>(float)0.0) { /* raise inexact flag */
|
||||
if(i0<0) i0 += (0x00800000)>>j0;
|
||||
i0 &= (~i);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if(j0==0x80) return x+x; /* inf or NaN */
|
||||
else return x; /* x is integral */
|
||||
}
|
||||
SET_FLOAT_WORD(x,i0);
|
||||
return x;
|
||||
}
|
||||
175
modules/fdlibm/src/s_log1p.cpp
Normal file
175
modules/fdlibm/src/s_log1p.cpp
Normal file
|
|
@ -0,0 +1,175 @@
|
|||
/* @(#)s_log1p.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* double log1p(double x)
|
||||
*
|
||||
* Method :
|
||||
* 1. Argument Reduction: find k and f such that
|
||||
* 1+x = 2^k * (1+f),
|
||||
* where sqrt(2)/2 < 1+f < sqrt(2) .
|
||||
*
|
||||
* Note. If k=0, then f=x is exact. However, if k!=0, then f
|
||||
* may not be representable exactly. In that case, a correction
|
||||
* term is need. Let u=1+x rounded. Let c = (1+x)-u, then
|
||||
* log(1+x) - log(u) ~ c/u. Thus, we proceed to compute log(u),
|
||||
* and add back the correction term c/u.
|
||||
* (Note: when x > 2**53, one can simply return log(x))
|
||||
*
|
||||
* 2. Approximation of log1p(f).
|
||||
* Let s = f/(2+f) ; based on log(1+f) = log(1+s) - log(1-s)
|
||||
* = 2s + 2/3 s**3 + 2/5 s**5 + .....,
|
||||
* = 2s + s*R
|
||||
* We use a special Reme algorithm on [0,0.1716] to generate
|
||||
* a polynomial of degree 14 to approximate R The maximum error
|
||||
* of this polynomial approximation is bounded by 2**-58.45. In
|
||||
* other words,
|
||||
* 2 4 6 8 10 12 14
|
||||
* R(z) ~ Lp1*s +Lp2*s +Lp3*s +Lp4*s +Lp5*s +Lp6*s +Lp7*s
|
||||
* (the values of Lp1 to Lp7 are listed in the program)
|
||||
* and
|
||||
* | 2 14 | -58.45
|
||||
* | Lp1*s +...+Lp7*s - R(z) | <= 2
|
||||
* | |
|
||||
* Note that 2s = f - s*f = f - hfsq + s*hfsq, where hfsq = f*f/2.
|
||||
* In order to guarantee error in log below 1ulp, we compute log
|
||||
* by
|
||||
* log1p(f) = f - (hfsq - s*(hfsq+R)).
|
||||
*
|
||||
* 3. Finally, log1p(x) = k*ln2 + log1p(f).
|
||||
* = k*ln2_hi+(f-(hfsq-(s*(hfsq+R)+k*ln2_lo)))
|
||||
* Here ln2 is split into two floating point number:
|
||||
* ln2_hi + ln2_lo,
|
||||
* where n*ln2_hi is always exact for |n| < 2000.
|
||||
*
|
||||
* Special cases:
|
||||
* log1p(x) is NaN with signal if x < -1 (including -INF) ;
|
||||
* log1p(+INF) is +INF; log1p(-1) is -INF with signal;
|
||||
* log1p(NaN) is that NaN with no signal.
|
||||
*
|
||||
* Accuracy:
|
||||
* according to an error analysis, the error is always less than
|
||||
* 1 ulp (unit in the last place).
|
||||
*
|
||||
* Constants:
|
||||
* The hexadecimal values are the intended ones for the following
|
||||
* constants. The decimal values may be used, provided that the
|
||||
* compiler will convert from decimal to binary accurately enough
|
||||
* to produce the hexadecimal values shown.
|
||||
*
|
||||
* Note: Assuming log() return accurate answer, the following
|
||||
* algorithm can be used to compute log1p(x) to within a few ULP:
|
||||
*
|
||||
* u = 1+x;
|
||||
* if(u==1.0) return x ; else
|
||||
* return log(u)*(x/(u-1.0));
|
||||
*
|
||||
* See HP-15C Advanced Functions Handbook, p.193.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const double
|
||||
ln2_hi = 6.93147180369123816490e-01, /* 3fe62e42 fee00000 */
|
||||
ln2_lo = 1.90821492927058770002e-10, /* 3dea39ef 35793c76 */
|
||||
two54 = 1.80143985094819840000e+16, /* 43500000 00000000 */
|
||||
Lp1 = 6.666666666666735130e-01, /* 3FE55555 55555593 */
|
||||
Lp2 = 3.999999999940941908e-01, /* 3FD99999 9997FA04 */
|
||||
Lp3 = 2.857142874366239149e-01, /* 3FD24924 94229359 */
|
||||
Lp4 = 2.222219843214978396e-01, /* 3FCC71C5 1D8E78AF */
|
||||
Lp5 = 1.818357216161805012e-01, /* 3FC74664 96CB03DE */
|
||||
Lp6 = 1.531383769920937332e-01, /* 3FC39A09 D078C69F */
|
||||
Lp7 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */
|
||||
|
||||
static const double zero = 0.0;
|
||||
static volatile double vzero = 0.0;
|
||||
|
||||
double
|
||||
log1p(double x)
|
||||
{
|
||||
double hfsq,f,c,s,z,R,u;
|
||||
int32_t k,hx,hu,ax;
|
||||
|
||||
GET_HIGH_WORD(hx,x);
|
||||
ax = hx&0x7fffffff;
|
||||
|
||||
k = 1;
|
||||
if (hx < 0x3FDA827A) { /* 1+x < sqrt(2)+ */
|
||||
if(ax>=0x3ff00000) { /* x <= -1.0 */
|
||||
if(x==-1.0) return -two54/vzero; /* log1p(-1)=+inf */
|
||||
else return (x-x)/(x-x); /* log1p(x<-1)=NaN */
|
||||
}
|
||||
if(ax<0x3e200000) { /* |x| < 2**-29 */
|
||||
if(two54+x>zero /* raise inexact */
|
||||
&&ax<0x3c900000) /* |x| < 2**-54 */
|
||||
return x;
|
||||
else
|
||||
return x - x*x*0.5;
|
||||
}
|
||||
if(hx>0||hx<=((int32_t)0xbfd2bec4)) {
|
||||
k=0;f=x;hu=1;} /* sqrt(2)/2- <= 1+x < sqrt(2)+ */
|
||||
}
|
||||
if (hx >= 0x7ff00000) return x+x;
|
||||
if(k!=0) {
|
||||
if(hx<0x43400000) {
|
||||
STRICT_ASSIGN(double,u,1.0+x);
|
||||
GET_HIGH_WORD(hu,u);
|
||||
k = (hu>>20)-1023;
|
||||
c = (k>0)? 1.0-(u-x):x-(u-1.0);/* correction term */
|
||||
c /= u;
|
||||
} else {
|
||||
u = x;
|
||||
GET_HIGH_WORD(hu,u);
|
||||
k = (hu>>20)-1023;
|
||||
c = 0;
|
||||
}
|
||||
hu &= 0x000fffff;
|
||||
/*
|
||||
* The approximation to sqrt(2) used in thresholds is not
|
||||
* critical. However, the ones used above must give less
|
||||
* strict bounds than the one here so that the k==0 case is
|
||||
* never reached from here, since here we have committed to
|
||||
* using the correction term but don't use it if k==0.
|
||||
*/
|
||||
if(hu<0x6a09e) { /* u ~< sqrt(2) */
|
||||
SET_HIGH_WORD(u,hu|0x3ff00000); /* normalize u */
|
||||
} else {
|
||||
k += 1;
|
||||
SET_HIGH_WORD(u,hu|0x3fe00000); /* normalize u/2 */
|
||||
hu = (0x00100000-hu)>>2;
|
||||
}
|
||||
f = u-1.0;
|
||||
}
|
||||
hfsq=0.5*f*f;
|
||||
if(hu==0) { /* |f| < 2**-20 */
|
||||
if(f==zero) {
|
||||
if(k==0) {
|
||||
return zero;
|
||||
} else {
|
||||
c += k*ln2_lo;
|
||||
return k*ln2_hi+c;
|
||||
}
|
||||
}
|
||||
R = hfsq*(1.0-0.66666666666666666*f);
|
||||
if(k==0) return f-R; else
|
||||
return k*ln2_hi-((R-(k*ln2_lo+c))-f);
|
||||
}
|
||||
s = f/(2.0+f);
|
||||
z = s*s;
|
||||
R = z*(Lp1+z*(Lp2+z*(Lp3+z*(Lp4+z*(Lp5+z*(Lp6+z*Lp7))))));
|
||||
if(k==0) return f-(hfsq-s*(hfsq+R)); else
|
||||
return k*ln2_hi-((hfsq-(s*(hfsq+R)+(k*ln2_lo+c)))-f);
|
||||
}
|
||||
58
modules/fdlibm/src/s_nearbyint.cpp
Normal file
58
modules/fdlibm/src/s_nearbyint.cpp
Normal file
|
|
@ -0,0 +1,58 @@
|
|||
/*-
|
||||
* Copyright (c) 2004 David Schultz <das@FreeBSD.ORG>
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
#include <fenv.h>
|
||||
#include "math_private.h"
|
||||
|
||||
/*
|
||||
* We save and restore the floating-point environment to avoid raising
|
||||
* an inexact exception. We can get away with using fesetenv()
|
||||
* instead of feclearexcept()/feupdateenv() to restore the environment
|
||||
* because the only exception defined for rint() is overflow, and
|
||||
* rounding can't overflow as long as emax >= p.
|
||||
*
|
||||
* The volatile keyword is needed below because clang incorrectly assumes
|
||||
* that rint won't raise any floating-point exceptions. Declaring ret volatile
|
||||
* is sufficient to trick the compiler into doing the right thing.
|
||||
*/
|
||||
#define DECL(type, fn, rint) \
|
||||
type \
|
||||
fn(type x) \
|
||||
{ \
|
||||
volatile type ret; \
|
||||
fenv_t env; \
|
||||
\
|
||||
fegetenv(&env); \
|
||||
ret = rint(x); \
|
||||
fesetenv(&env); \
|
||||
return (ret); \
|
||||
}
|
||||
|
||||
DECL(double, nearbyint, rint)
|
||||
DECL(float, nearbyintf, rintf)
|
||||
87
modules/fdlibm/src/s_rint.cpp
Normal file
87
modules/fdlibm/src/s_rint.cpp
Normal file
|
|
@ -0,0 +1,87 @@
|
|||
/* @(#)s_rint.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
* rint(x)
|
||||
* Return x rounded to integral value according to the prevailing
|
||||
* rounding mode.
|
||||
* Method:
|
||||
* Using floating addition.
|
||||
* Exception:
|
||||
* Inexact flag raised if x not equal to rint(x).
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const double
|
||||
TWO52[2]={
|
||||
4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
|
||||
-4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
|
||||
};
|
||||
|
||||
double
|
||||
rint(double x)
|
||||
{
|
||||
int32_t i0,j0,sx;
|
||||
u_int32_t i,i1;
|
||||
double w,t;
|
||||
EXTRACT_WORDS(i0,i1,x);
|
||||
sx = (i0>>31)&1;
|
||||
j0 = ((i0>>20)&0x7ff)-0x3ff;
|
||||
if(j0<20) {
|
||||
if(j0<0) {
|
||||
if(((i0&0x7fffffff)|i1)==0) return x;
|
||||
i1 |= (i0&0x0fffff);
|
||||
i0 &= 0xfffe0000;
|
||||
i0 |= ((i1|-i1)>>12)&0x80000;
|
||||
SET_HIGH_WORD(x,i0);
|
||||
STRICT_ASSIGN(double,w,TWO52[sx]+x);
|
||||
t = w-TWO52[sx];
|
||||
GET_HIGH_WORD(i0,t);
|
||||
SET_HIGH_WORD(t,(i0&0x7fffffff)|(sx<<31));
|
||||
return t;
|
||||
} else {
|
||||
i = (0x000fffff)>>j0;
|
||||
if(((i0&i)|i1)==0) return x; /* x is integral */
|
||||
i>>=1;
|
||||
if(((i0&i)|i1)!=0) {
|
||||
/*
|
||||
* Some bit is set after the 0.5 bit. To avoid the
|
||||
* possibility of errors from double rounding in
|
||||
* w = TWO52[sx]+x, adjust the 0.25 bit to a lower
|
||||
* guard bit. We do this for all j0<=51. The
|
||||
* adjustment is trickiest for j0==18 and j0==19
|
||||
* since then it spans the word boundary.
|
||||
*/
|
||||
if(j0==19) i1 = 0x40000000; else
|
||||
if(j0==18) i1 = 0x80000000; else
|
||||
i0 = (i0&(~i))|((0x20000)>>j0);
|
||||
}
|
||||
}
|
||||
} else if (j0>51) {
|
||||
if(j0==0x400) return x+x; /* inf or NaN */
|
||||
else return x; /* x is integral */
|
||||
} else {
|
||||
i = ((u_int32_t)(0xffffffff))>>(j0-20);
|
||||
if((i1&i)==0) return x; /* x is integral */
|
||||
i>>=1;
|
||||
if((i1&i)!=0) i1 = (i1&(~i))|((0x40000000)>>(j0-20));
|
||||
}
|
||||
INSERT_WORDS(x,i0,i1);
|
||||
STRICT_ASSIGN(double,w,TWO52[sx]+x);
|
||||
return w-TWO52[sx];
|
||||
}
|
||||
52
modules/fdlibm/src/s_rintf.cpp
Normal file
52
modules/fdlibm/src/s_rintf.cpp
Normal file
|
|
@ -0,0 +1,52 @@
|
|||
/* s_rintf.c -- float version of s_rint.c.
|
||||
* Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
|
||||
*/
|
||||
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
#include <float.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const float
|
||||
TWO23[2]={
|
||||
8.3886080000e+06, /* 0x4b000000 */
|
||||
-8.3886080000e+06, /* 0xcb000000 */
|
||||
};
|
||||
|
||||
float
|
||||
rintf(float x)
|
||||
{
|
||||
int32_t i0,j0,sx;
|
||||
float w,t;
|
||||
GET_FLOAT_WORD(i0,x);
|
||||
sx = (i0>>31)&1;
|
||||
j0 = ((i0>>23)&0xff)-0x7f;
|
||||
if(j0<23) {
|
||||
if(j0<0) {
|
||||
if((i0&0x7fffffff)==0) return x;
|
||||
STRICT_ASSIGN(float,w,TWO23[sx]+x);
|
||||
t = w-TWO23[sx];
|
||||
GET_FLOAT_WORD(i0,t);
|
||||
SET_FLOAT_WORD(t,(i0&0x7fffffff)|(sx<<31));
|
||||
return t;
|
||||
}
|
||||
STRICT_ASSIGN(float,w,TWO23[sx]+x);
|
||||
return w-TWO23[sx];
|
||||
}
|
||||
if(j0==0x80) return x+x; /* inf or NaN */
|
||||
else return x; /* x is integral */
|
||||
}
|
||||
60
modules/fdlibm/src/s_scalbn.cpp
Normal file
60
modules/fdlibm/src/s_scalbn.cpp
Normal file
|
|
@ -0,0 +1,60 @@
|
|||
/* @(#)s_scalbn.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
#ifndef lint
|
||||
//static char rcsid[] = "$FreeBSD$";
|
||||
#endif
|
||||
|
||||
/*
|
||||
* scalbn (double x, int n)
|
||||
* scalbn(x,n) returns x* 2**n computed by exponent
|
||||
* manipulation rather than by actually performing an
|
||||
* exponentiation or a multiplication.
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
#include <float.h>
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const double
|
||||
two54 = 1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */
|
||||
twom54 = 5.55111512312578270212e-17, /* 0x3C900000, 0x00000000 */
|
||||
huge = 1.0e+300,
|
||||
tiny = 1.0e-300;
|
||||
|
||||
double
|
||||
scalbn (double x, int n)
|
||||
{
|
||||
int32_t k,hx,lx;
|
||||
EXTRACT_WORDS(hx,lx,x);
|
||||
k = (hx&0x7ff00000)>>20; /* extract exponent */
|
||||
if (k==0) { /* 0 or subnormal x */
|
||||
if ((lx|(hx&0x7fffffff))==0) return x; /* +-0 */
|
||||
x *= two54;
|
||||
GET_HIGH_WORD(hx,x);
|
||||
k = ((hx&0x7ff00000)>>20) - 54;
|
||||
if (n< -50000) return tiny*x; /*underflow*/
|
||||
}
|
||||
if (k==0x7ff) return x+x; /* NaN or Inf */
|
||||
k = k+n;
|
||||
if (k > 0x7fe) return huge*copysign(huge,x); /* overflow */
|
||||
if (k > 0) /* normal result */
|
||||
{SET_HIGH_WORD(x,(hx&0x800fffff)|(k<<20)); return x;}
|
||||
if (k <= -54)
|
||||
if (n > 50000) /* in case integer overflow in n+k */
|
||||
return huge*copysign(huge,x); /*overflow*/
|
||||
else return tiny*copysign(tiny,x); /*underflow*/
|
||||
k += 54; /* subnormal result */
|
||||
SET_HIGH_WORD(x,(hx&0x800fffff)|(k<<20));
|
||||
return x*twom54;
|
||||
}
|
||||
79
modules/fdlibm/src/s_tanh.cpp
Normal file
79
modules/fdlibm/src/s_tanh.cpp
Normal file
|
|
@ -0,0 +1,79 @@
|
|||
/* @(#)s_tanh.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/* Tanh(x)
|
||||
* Return the Hyperbolic Tangent of x
|
||||
*
|
||||
* Method :
|
||||
* x -x
|
||||
* e - e
|
||||
* 0. tanh(x) is defined to be -----------
|
||||
* x -x
|
||||
* e + e
|
||||
* 1. reduce x to non-negative by tanh(-x) = -tanh(x).
|
||||
* 2. 0 <= x < 2**-28 : tanh(x) := x with inexact if x != 0
|
||||
* -t
|
||||
* 2**-28 <= x < 1 : tanh(x) := -----; t = expm1(-2x)
|
||||
* t + 2
|
||||
* 2
|
||||
* 1 <= x < 22 : tanh(x) := 1 - -----; t = expm1(2x)
|
||||
* t + 2
|
||||
* 22 <= x <= INF : tanh(x) := 1.
|
||||
*
|
||||
* Special cases:
|
||||
* tanh(NaN) is NaN;
|
||||
* only tanh(0)=0 is exact for finite argument.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const volatile double tiny = 1.0e-300;
|
||||
static const double one = 1.0, two = 2.0, huge = 1.0e300;
|
||||
|
||||
double
|
||||
tanh(double x)
|
||||
{
|
||||
double t,z;
|
||||
int32_t jx,ix;
|
||||
|
||||
GET_HIGH_WORD(jx,x);
|
||||
ix = jx&0x7fffffff;
|
||||
|
||||
/* x is INF or NaN */
|
||||
if(ix>=0x7ff00000) {
|
||||
if (jx>=0) return one/x+one; /* tanh(+-inf)=+-1 */
|
||||
else return one/x-one; /* tanh(NaN) = NaN */
|
||||
}
|
||||
|
||||
/* |x| < 22 */
|
||||
if (ix < 0x40360000) { /* |x|<22 */
|
||||
if (ix<0x3e300000) { /* |x|<2**-28 */
|
||||
if(huge+x>one) return x; /* tanh(tiny) = tiny with inexact */
|
||||
}
|
||||
if (ix>=0x3ff00000) { /* |x|>=1 */
|
||||
t = expm1(two*fabs(x));
|
||||
z = one - two/(t+two);
|
||||
} else {
|
||||
t = expm1(-two*fabs(x));
|
||||
z= -t/(t+two);
|
||||
}
|
||||
/* |x| >= 22, return +-1 */
|
||||
} else {
|
||||
z = one - tiny; /* raise inexact flag */
|
||||
}
|
||||
return (jx>=0)? z: -z;
|
||||
}
|
||||
62
modules/fdlibm/src/s_trunc.cpp
Normal file
62
modules/fdlibm/src/s_trunc.cpp
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
/* @(#)s_floor.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
* trunc(x)
|
||||
* Return x rounded toward 0 to integral value
|
||||
* Method:
|
||||
* Bit twiddling.
|
||||
* Exception:
|
||||
* Inexact flag raised if x not equal to trunc(x).
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const double huge = 1.0e300;
|
||||
|
||||
double
|
||||
trunc(double x)
|
||||
{
|
||||
int32_t i0,i1,j0;
|
||||
u_int32_t i;
|
||||
EXTRACT_WORDS(i0,i1,x);
|
||||
j0 = ((i0>>20)&0x7ff)-0x3ff;
|
||||
if(j0<20) {
|
||||
if(j0<0) { /* raise inexact if x != 0 */
|
||||
if(huge+x>0.0) {/* |x|<1, so return 0*sign(x) */
|
||||
i0 &= 0x80000000U;
|
||||
i1 = 0;
|
||||
}
|
||||
} else {
|
||||
i = (0x000fffff)>>j0;
|
||||
if(((i0&i)|i1)==0) return x; /* x is integral */
|
||||
if(huge+x>0.0) { /* raise inexact flag */
|
||||
i0 &= (~i); i1=0;
|
||||
}
|
||||
}
|
||||
} else if (j0>51) {
|
||||
if(j0==0x400) return x+x; /* inf or NaN */
|
||||
else return x; /* x is integral */
|
||||
} else {
|
||||
i = ((u_int32_t)(0xffffffff))>>(j0-20);
|
||||
if((i1&i)==0) return x; /* x is integral */
|
||||
if(huge+x>0.0) /* raise inexact flag */
|
||||
i1 &= (~i);
|
||||
}
|
||||
INSERT_WORDS(x,i0,i1);
|
||||
return x;
|
||||
}
|
||||
52
modules/fdlibm/src/s_truncf.cpp
Normal file
52
modules/fdlibm/src/s_truncf.cpp
Normal file
|
|
@ -0,0 +1,52 @@
|
|||
/* @(#)s_floor.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
//__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
* truncf(x)
|
||||
* Return x rounded toward 0 to integral value
|
||||
* Method:
|
||||
* Bit twiddling.
|
||||
* Exception:
|
||||
* Inexact flag raised if x not equal to truncf(x).
|
||||
*/
|
||||
|
||||
#include "math_private.h"
|
||||
|
||||
static const float huge = 1.0e30F;
|
||||
|
||||
float
|
||||
truncf(float x)
|
||||
{
|
||||
int32_t i0,j0;
|
||||
u_int32_t i;
|
||||
GET_FLOAT_WORD(i0,x);
|
||||
j0 = ((i0>>23)&0xff)-0x7f;
|
||||
if(j0<23) {
|
||||
if(j0<0) { /* raise inexact if x != 0 */
|
||||
if(huge+x>0.0F) /* |x|<1, so return 0*sign(x) */
|
||||
i0 &= 0x80000000;
|
||||
} else {
|
||||
i = (0x007fffff)>>j0;
|
||||
if((i0&i)==0) return x; /* x is integral */
|
||||
if(huge+x>0.0F) /* raise inexact flag */
|
||||
i0 &= (~i);
|
||||
}
|
||||
} else {
|
||||
if(j0==0x80) return x+x; /* inf or NaN */
|
||||
else return x; /* x is integral */
|
||||
}
|
||||
SET_FLOAT_WORD(x,i0);
|
||||
return x;
|
||||
}
|
||||
35
modules/fdlibm/update.sh
Normal file
35
modules/fdlibm/update.sh
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
#!/bin/sh
|
||||
|
||||
# Script to update the mozilla in-tree copy of the fdlibm library.
|
||||
# Run this within the /modules/fdlibm directory of the source tree.
|
||||
|
||||
set -e
|
||||
|
||||
API_BASE_URL=https://api.github.com/repos/freebsd/freebsd
|
||||
|
||||
get_commit() {
|
||||
curl -s "${API_BASE_URL}/commits?path=lib/msun/src&per_page=1" \
|
||||
| python -c 'import json, sys; print(json.loads(sys.stdin.read())[0]["sha"])'
|
||||
}
|
||||
|
||||
mv ./src/moz.build ./src_moz.build
|
||||
rm -rf src
|
||||
BEFORE_COMMIT=$(get_commit)
|
||||
sh ./import.sh
|
||||
mv ./src_moz.build ./src/moz.build
|
||||
COMMIT=$(get_commit)
|
||||
if [ ${BEFORE_COMMIT} != ${COMMIT} ]; then
|
||||
echo "Latest commit is changed during import. Please run again."
|
||||
exit 1
|
||||
fi
|
||||
for FILE in $(ls patches/*.patch | sort); do
|
||||
patch -p3 < ${FILE}
|
||||
done
|
||||
hg add src
|
||||
|
||||
perl -p -i -e "s/\[commit [0-9a-f]{40}\]/[commit ${COMMIT}]/" README.mozilla
|
||||
|
||||
echo "###"
|
||||
echo "### Updated fdlibm/src to ${COMMIT}."
|
||||
echo "### Remember to verify and commit the changes to source control!"
|
||||
echo "###"
|
||||
452
modules/freetype2/CMakeLists.txt
Normal file
452
modules/freetype2/CMakeLists.txt
Normal file
|
|
@ -0,0 +1,452 @@
|
|||
# CMakeLists.txt
|
||||
#
|
||||
# Copyright 2013-2016 by
|
||||
# David Turner, Robert Wilhelm, and Werner Lemberg.
|
||||
#
|
||||
# Written originally by John Cary <cary@txcorp.com>
|
||||
#
|
||||
# This file is part of the FreeType project, and may only be used, modified,
|
||||
# and distributed under the terms of the FreeType project license,
|
||||
# LICENSE.TXT. By continuing to use, modify, or distribute this file you
|
||||
# indicate that you have read the license and understand and accept it
|
||||
# fully.
|
||||
#
|
||||
#
|
||||
# As a preliminary, create a compilation directory and change into it, for
|
||||
# example
|
||||
#
|
||||
# mkdir ~/freetype2.compiled
|
||||
# cd ~/freetype2.compiled
|
||||
#
|
||||
# Now you can say
|
||||
#
|
||||
# cmake <path-to-freetype2-src-dir>
|
||||
#
|
||||
# to create a Makefile that builds a static version of the library.
|
||||
#
|
||||
# For a dynamic library, use
|
||||
#
|
||||
# cmake <path-to-freetype2-src-dir> -D BUILD_SHARED_LIBS:BOOL=true
|
||||
#
|
||||
# For a framework on OS X, use
|
||||
#
|
||||
# cmake <path-to-freetype2-src-dir> -D BUILD_FRAMEWORK:BOOL=true -G Xcode
|
||||
#
|
||||
# instead.
|
||||
#
|
||||
# For an iOS static library, use
|
||||
#
|
||||
# cmake -D IOS_PLATFORM=OS -G Xcode <path-to-freetype2-src-dir>
|
||||
#
|
||||
# or
|
||||
#
|
||||
# cmake -D IOS_PLATFORM=SIMULATOR -G Xcode <path-to-freetype2-src-dir>
|
||||
#
|
||||
# Please refer to the cmake manual for further options, in particular, how
|
||||
# to modify compilation and linking parameters.
|
||||
#
|
||||
# Some notes.
|
||||
#
|
||||
# . `cmake' creates configuration files in
|
||||
#
|
||||
# <build-directory>/include/freetype/config
|
||||
#
|
||||
# which should be further modified if necessary.
|
||||
#
|
||||
# . You can use `cmake' directly on a freshly cloned FreeType git
|
||||
# repository.
|
||||
#
|
||||
# . `CMakeLists.txt' is provided as-is since it is normally not used by the
|
||||
# developer team.
|
||||
#
|
||||
# . If you want to disable the automatic generation of the distribution
|
||||
# targets, add the `-D FREETYPE_NO_DIST=true' command line argument.
|
||||
#
|
||||
# . Set the `WITH_ZLIB', `WITH_BZip2', `WITH_PNG', and `WITH_HarfBuzz'
|
||||
# CMake variables to `ON' or `OFF' to force or skip using a dependency.
|
||||
# Leave a variable undefined (which is the default) to use the dependency
|
||||
# only if it is available. Example:
|
||||
#
|
||||
# cmake ... -DWITH_ZLIB=ON -DWITH_HarfBuzz=OFF ...
|
||||
#
|
||||
# . Installation of FreeType can be controlled with the CMake variables
|
||||
# `SKIP_INSTALL_HEADERS', `SKIP_INSTALL_LIBRARIES', and `SKIP_INSTALL_ALL'
|
||||
# (this is compatible with the same CMake variables in zlib's CMake
|
||||
# support).
|
||||
|
||||
|
||||
cmake_minimum_required(VERSION 2.6)
|
||||
|
||||
|
||||
include(CheckIncludeFile)
|
||||
|
||||
|
||||
# CMAKE_TOOLCHAIN_FILE must be set before `project' is called, which
|
||||
# configures the base build environment and references the toolchain file
|
||||
if (APPLE)
|
||||
if (DEFINED IOS_PLATFORM)
|
||||
if (NOT "${IOS_PLATFORM}" STREQUAL "OS"
|
||||
AND NOT "${IOS_PLATFORM}" STREQUAL "SIMULATOR")
|
||||
message(FATAL_ERROR
|
||||
"IOS_PLATFORM must be set to either OS or SIMULATOR")
|
||||
endif ()
|
||||
if (NOT "${CMAKE_GENERATOR}" STREQUAL "Xcode")
|
||||
message(AUTHOR_WARNING
|
||||
"You should use Xcode generator with IOS_PLATFORM enabled to get Universal builds.")
|
||||
endif ()
|
||||
if (BUILD_SHARED_LIBS)
|
||||
message(FATAL_ERROR
|
||||
"BUILD_SHARED_LIBS can not be on with IOS_PLATFORM enabled")
|
||||
endif ()
|
||||
if (BUILD_FRAMEWORK)
|
||||
message(FATAL_ERROR
|
||||
"BUILD_FRAMEWORK can not be on with IOS_PLATFORM enabled")
|
||||
endif ()
|
||||
|
||||
# iOS only uses static libraries
|
||||
set(BUILD_SHARED_LIBS OFF)
|
||||
|
||||
set(CMAKE_TOOLCHAIN_FILE
|
||||
${CMAKE_SOURCE_DIR}/builds/cmake/iOS.cmake)
|
||||
endif ()
|
||||
else ()
|
||||
if (DEFINED IOS_PLATFORM)
|
||||
message(FATAL_ERROR "IOS_PLATFORM is not supported on this platform")
|
||||
endif ()
|
||||
endif ()
|
||||
|
||||
|
||||
project(freetype)
|
||||
|
||||
|
||||
if (WIN32 AND NOT MINGW AND BUILD_SHARED_LIBS)
|
||||
message(FATAL_ERROR "Building shared libraries on Windows needs MinGW")
|
||||
endif ()
|
||||
|
||||
# Disallow in-source builds
|
||||
if ("${PROJECT_BINARY_DIR}" STREQUAL "${PROJECT_SOURCE_DIR}")
|
||||
message(FATAL_ERROR
|
||||
"
|
||||
In-source builds are not permitted! Make a separate folder for"
|
||||
" building, e.g.,"
|
||||
"
|
||||
mkdir build; cd build; cmake .."
|
||||
"
|
||||
Before that, remove the files created by this failed run with"
|
||||
"
|
||||
rm -rf CMakeCache.txt CMakeFiles")
|
||||
endif ()
|
||||
|
||||
|
||||
# Add local cmake modules
|
||||
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/builds/cmake)
|
||||
|
||||
|
||||
if (BUILD_FRAMEWORK)
|
||||
if (NOT "${CMAKE_GENERATOR}" STREQUAL "Xcode")
|
||||
message(FATAL_ERROR
|
||||
"You should use Xcode generator with BUILD_FRAMEWORK enabled")
|
||||
endif ()
|
||||
set(CMAKE_OSX_ARCHITECTURES "$(ARCHS_STANDARD_32_64_BIT)")
|
||||
set(BUILD_SHARED_LIBS ON)
|
||||
endif ()
|
||||
|
||||
|
||||
set(VERSION_MAJOR "2")
|
||||
set(VERSION_MINOR "7")
|
||||
set(VERSION_PATCH "1")
|
||||
|
||||
set(PROJECT_VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH})
|
||||
set(SHARED_LIBRARY_VERSION ${VERSION_MAJOR}.${VERSION_MINOR})
|
||||
|
||||
|
||||
# Compiler definitions for building the library
|
||||
add_definitions(-DFT2_BUILD_LIBRARY)
|
||||
|
||||
|
||||
# Find dependencies
|
||||
foreach (d ZLIB BZip2 PNG HarfBuzz)
|
||||
string(TOUPPER "${d}" D)
|
||||
|
||||
if (DEFINED WITH_${d} OR DEFINED WITH_${D})
|
||||
if (WITH_${d} OR WITH_${D})
|
||||
find_package(${d} QUIET REQUIRED)
|
||||
endif ()
|
||||
else ()
|
||||
find_package(${d} QUIET)
|
||||
endif ()
|
||||
|
||||
if (${d}_FOUND OR ${D}_FOUND)
|
||||
message(STATUS "Building with ${d}")
|
||||
endif ()
|
||||
endforeach ()
|
||||
|
||||
|
||||
message(STATUS
|
||||
"Creating directory ${PROJECT_BINARY_DIR}/include/freetype/config")
|
||||
file(MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/include/freetype/config")
|
||||
|
||||
|
||||
# Create the configuration file
|
||||
message(STATUS
|
||||
"Creating file ${PROJECT_BINARY_DIR}/include/freetype/config/ftconfig.h")
|
||||
|
||||
if (UNIX)
|
||||
check_include_file("unistd.h" HAVE_UNISTD_H)
|
||||
check_include_file("fcntl.h" HAVE_FCNTL_H)
|
||||
check_include_file("stdint.h" HAVE_STDINT_H)
|
||||
|
||||
file(READ "${PROJECT_SOURCE_DIR}/builds/unix/ftconfig.in"
|
||||
FTCONFIG_H)
|
||||
if (HAVE_UNISTD_H)
|
||||
string(REGEX REPLACE
|
||||
"#undef +(HAVE_UNISTD_H)" "#define \\1"
|
||||
FTCONFIG_H "${FTCONFIG_H}")
|
||||
endif ()
|
||||
if (HAVE_FCNTL_H)
|
||||
string(REGEX REPLACE
|
||||
"#undef +(HAVE_FCNTL_H)" "#define \\1"
|
||||
FTCONFIG_H "${FTCONFIG_H}")
|
||||
endif ()
|
||||
if (HAVE_STDINT_H)
|
||||
string(REGEX REPLACE
|
||||
"#undef +(HAVE_STDINT_H)" "#define \\1"
|
||||
FTCONFIG_H "${FTCONFIG_H}")
|
||||
endif ()
|
||||
string(REPLACE "/undef " "#undef "
|
||||
FTCONFIG_H "${FTCONFIG_H}")
|
||||
file(WRITE "${PROJECT_BINARY_DIR}/include/freetype/config/ftconfig.h-new"
|
||||
"${FTCONFIG_H}")
|
||||
else ()
|
||||
file(READ "${PROJECT_SOURCE_DIR}/include/freetype/config/ftconfig.h"
|
||||
FTCONFIG_H)
|
||||
file(WRITE "${PROJECT_BINARY_DIR}/include/freetype/config/ftconfig.h-new"
|
||||
"${FTCONFIG_H}")
|
||||
endif ()
|
||||
execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different
|
||||
"${PROJECT_BINARY_DIR}/include/freetype/config/ftconfig.h-new"
|
||||
"${PROJECT_BINARY_DIR}/include/freetype/config/ftconfig.h")
|
||||
|
||||
|
||||
# Create the options file
|
||||
message(STATUS
|
||||
"Creating file ${PROJECT_BINARY_DIR}/include/freetype/config/ftoption.h")
|
||||
|
||||
file(READ "${PROJECT_SOURCE_DIR}/include/freetype/config/ftoption.h"
|
||||
FTOPTION_H)
|
||||
if (ZLIB_FOUND)
|
||||
string(REGEX REPLACE
|
||||
"/\\* +(#define +FT_CONFIG_OPTION_SYSTEM_ZLIB) +\\*/" "\\1"
|
||||
FTOPTION_H "${FTOPTION_H}")
|
||||
endif ()
|
||||
if (BZIP2_FOUND)
|
||||
string(REGEX REPLACE
|
||||
"/\\* +(#define +FT_CONFIG_OPTION_USE_BZIP2) +\\*/" "\\1"
|
||||
FTOPTION_H "${FTOPTION_H}")
|
||||
endif ()
|
||||
if (PNG_FOUND)
|
||||
string(REGEX REPLACE
|
||||
"/\\* +(#define +FT_CONFIG_OPTION_USE_PNG) +\\*/" "\\1"
|
||||
FTOPTION_H "${FTOPTION_H}")
|
||||
endif ()
|
||||
if (HARFBUZZ_FOUND)
|
||||
string(REGEX REPLACE
|
||||
"/\\* +(#define +FT_CONFIG_OPTION_USE_HARFBUZZ) +\\*/" "\\1"
|
||||
FTOPTION_H "${FTOPTION_H}")
|
||||
endif ()
|
||||
file(WRITE "${PROJECT_BINARY_DIR}/include/freetype/config/ftoption.h-new"
|
||||
"${FTOPTION_H}")
|
||||
execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different
|
||||
"${PROJECT_BINARY_DIR}/include/freetype/config/ftoption.h-new"
|
||||
"${PROJECT_BINARY_DIR}/include/freetype/config/ftoption.h")
|
||||
|
||||
|
||||
# Specify library include directories
|
||||
include_directories("${PROJECT_SOURCE_DIR}/include")
|
||||
include_directories(BEFORE "${PROJECT_BINARY_DIR}/include")
|
||||
|
||||
|
||||
file(GLOB PUBLIC_HEADERS "include/ft2build.h" "include/freetype/*.h")
|
||||
file(GLOB PUBLIC_CONFIG_HEADERS "include/freetype/config/*.h")
|
||||
file(GLOB PRIVATE_HEADERS "include/freetype/internal/*.h")
|
||||
|
||||
|
||||
set(BASE_SRCS
|
||||
src/autofit/autofit.c
|
||||
src/base/ftbase.c
|
||||
src/base/ftbbox.c
|
||||
src/base/ftbdf.c
|
||||
src/base/ftbitmap.c
|
||||
src/base/ftcid.c
|
||||
src/base/ftfntfmt.c
|
||||
src/base/ftfstype.c
|
||||
src/base/ftgasp.c
|
||||
src/base/ftglyph.c
|
||||
src/base/ftgxval.c
|
||||
src/base/ftinit.c
|
||||
src/base/ftlcdfil.c
|
||||
src/base/ftmm.c
|
||||
src/base/ftotval.c
|
||||
src/base/ftpatent.c
|
||||
src/base/ftpfr.c
|
||||
src/base/ftstroke.c
|
||||
src/base/ftsynth.c
|
||||
src/base/ftsystem.c
|
||||
src/base/fttype1.c
|
||||
src/base/ftwinfnt.c
|
||||
src/bdf/bdf.c
|
||||
src/bzip2/ftbzip2.c
|
||||
src/cache/ftcache.c
|
||||
src/cff/cff.c
|
||||
src/cid/type1cid.c
|
||||
src/gzip/ftgzip.c
|
||||
src/lzw/ftlzw.c
|
||||
src/pcf/pcf.c
|
||||
src/pfr/pfr.c
|
||||
src/psaux/psaux.c
|
||||
src/pshinter/pshinter.c
|
||||
src/psnames/psnames.c
|
||||
src/raster/raster.c
|
||||
src/sfnt/sfnt.c
|
||||
src/smooth/smooth.c
|
||||
src/truetype/truetype.c
|
||||
src/type1/type1.c
|
||||
src/type42/type42.c
|
||||
src/winfonts/winfnt.c
|
||||
)
|
||||
|
||||
if (WIN32)
|
||||
set(BASE_SRCS ${BASE_SRCS} builds/windows/ftdebug.c)
|
||||
elseif (WINCE)
|
||||
set(BASE_SRCS ${BASE_SRCS} builds/wince/ftdebug.c)
|
||||
else ()
|
||||
set(BASE_SRCS ${BASE_SRCS} src/base/ftdebug.c)
|
||||
endif ()
|
||||
|
||||
|
||||
if (BUILD_FRAMEWORK)
|
||||
set(BASE_SRCS
|
||||
${BASE_SRCS}
|
||||
builds/mac/freetype-Info.plist
|
||||
)
|
||||
endif ()
|
||||
|
||||
set(CMAKE_DEBUG_POSTFIX d)
|
||||
|
||||
add_library(freetype
|
||||
${PUBLIC_HEADERS}
|
||||
${PUBLIC_CONFIG_HEADERS}
|
||||
${PRIVATE_HEADERS}
|
||||
${BASE_SRCS}
|
||||
)
|
||||
|
||||
|
||||
if (BUILD_SHARED_LIBS)
|
||||
set_target_properties(freetype PROPERTIES
|
||||
VERSION ${PROJECT_VERSION}
|
||||
SOVERSION ${SHARED_LIBRARY_VERSION}
|
||||
COMPILE_DEFINITIONS freetype_EXPORTS
|
||||
)
|
||||
endif ()
|
||||
|
||||
|
||||
if (BUILD_FRAMEWORK)
|
||||
set_property(SOURCE ${PUBLIC_CONFIG_HEADERS}
|
||||
PROPERTY MACOSX_PACKAGE_LOCATION Headers/config
|
||||
)
|
||||
set_target_properties(freetype PROPERTIES
|
||||
FRAMEWORK TRUE
|
||||
MACOSX_FRAMEWORK_INFO_PLIST builds/mac/freetype-Info.plist
|
||||
PUBLIC_HEADER "${PUBLIC_HEADERS}"
|
||||
XCODE_ATTRIBUTE_INSTALL_PATH "@rpath"
|
||||
)
|
||||
endif ()
|
||||
|
||||
if (NOT CMAKE_VERSION VERSION_LESS 2.8.12)
|
||||
target_include_directories(freetype
|
||||
PUBLIC $<INSTALL_INTERFACE:include/freetype2>)
|
||||
endif ()
|
||||
|
||||
if (CMAKE_VERSION VERSION_LESS 2.8.12)
|
||||
set(MAYBE_PRIVATE "")
|
||||
else ()
|
||||
set(MAYBE_PRIVATE "PRIVATE")
|
||||
endif ()
|
||||
|
||||
if (ZLIB_FOUND)
|
||||
target_link_libraries(freetype ${MAYBE_PRIVATE} ${ZLIB_LIBRARIES})
|
||||
include_directories(${ZLIB_INCLUDE_DIRS})
|
||||
endif ()
|
||||
if (BZIP2_FOUND)
|
||||
target_link_libraries(freetype ${MAYBE_PRIVATE} ${BZIP2_LIBRARIES})
|
||||
include_directories(${BZIP2_INCLUDE_DIR}) # not BZIP2_INCLUDE_DIRS
|
||||
endif ()
|
||||
if (PNG_FOUND)
|
||||
add_definitions(${PNG_DEFINITIONS})
|
||||
target_link_libraries(freetype ${MAYBE_PRIVATE} ${PNG_LIBRARIES})
|
||||
include_directories(${PNG_INCLUDE_DIRS})
|
||||
endif ()
|
||||
if (HARFBUZZ_FOUND)
|
||||
target_link_libraries(freetype ${MAYBE_PRIVATE} ${HARFBUZZ_LIBRARIES})
|
||||
include_directories(${HARFBUZZ_INCLUDE_DIRS})
|
||||
endif ()
|
||||
|
||||
|
||||
# Installations
|
||||
# Note the trailing slash in the argument to the `DIRECTORY' directive
|
||||
if (NOT SKIP_INSTALL_HEADERS AND NOT SKIP_INSTALL_ALL)
|
||||
install(DIRECTORY ${PROJECT_SOURCE_DIR}/include/
|
||||
DESTINATION include/freetype2
|
||||
PATTERN "internal" EXCLUDE
|
||||
PATTERN "ftconfig.h" EXCLUDE
|
||||
PATTERN "ftoption.h" EXCLUDE
|
||||
)
|
||||
install(FILES
|
||||
${PROJECT_BINARY_DIR}/include/freetype/config/ftconfig.h
|
||||
${PROJECT_BINARY_DIR}/include/freetype/config/ftoption.h
|
||||
DESTINATION include/freetype2/freetype/config
|
||||
)
|
||||
endif ()
|
||||
|
||||
if (NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL)
|
||||
install(TARGETS freetype
|
||||
EXPORT freetype-targets
|
||||
RUNTIME DESTINATION bin
|
||||
LIBRARY DESTINATION lib
|
||||
ARCHIVE DESTINATION lib
|
||||
FRAMEWORK DESTINATION Library/Frameworks
|
||||
)
|
||||
install(EXPORT freetype-targets
|
||||
DESTINATION lib/cmake/freetype
|
||||
FILE freetype-config.cmake
|
||||
)
|
||||
endif ()
|
||||
|
||||
|
||||
# Packaging
|
||||
# CPack version numbers for release tarball name.
|
||||
set(CPACK_PACKAGE_VERSION_MAJOR ${VERSION_MAJOR})
|
||||
set(CPACK_PACKAGE_VERSION_MINOR ${VERSION_MINOR})
|
||||
set(CPACK_PACKAGE_VERSION_PATCH ${VERSION_PATCH}})
|
||||
if (NOT DEFINED CPACK_PACKAGE_DESCRIPTION_SUMMARY)
|
||||
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "${CMAKE_PROJECT_NAME}")
|
||||
endif ()
|
||||
if (NOT DEFINED CPACK_SOURCE_PACKAGE_FILE_NAME)
|
||||
set(CPACK_SOURCE_PACKAGE_FILE_NAME
|
||||
"${CMAKE_PROJECT_NAME}-${PROJECT_VERSION}-r${PROJECT_REV}"
|
||||
CACHE INTERNAL "tarball basename"
|
||||
)
|
||||
endif ()
|
||||
set(CPACK_SOURCE_GENERATOR TGZ)
|
||||
set(CPACK_SOURCE_IGNORE_FILES
|
||||
"/CVS/;/.svn/;.swp$;.#;/#;/build/;/serial/;/ser/;/parallel/;/par/;~;/preconfig.out;/autom4te.cache/;/.config")
|
||||
set(CPACK_GENERATOR TGZ)
|
||||
include(CPack)
|
||||
|
||||
|
||||
# Add `make dist' target if FREETYPE_DIST is set (which is the default)
|
||||
if (NOT DEFINED FREETYPE_NO_DIST)
|
||||
add_custom_target(dist COMMAND ${CMAKE_MAKE_PROGRAM} package_source)
|
||||
endif ()
|
||||
|
||||
# eof
|
||||
2106
modules/freetype2/ChangeLog
Normal file
2106
modules/freetype2/ChangeLog
Normal file
File diff suppressed because it is too large
Load diff
2613
modules/freetype2/ChangeLog.20
Normal file
2613
modules/freetype2/ChangeLog.20
Normal file
File diff suppressed because it is too large
Load diff
9439
modules/freetype2/ChangeLog.21
Normal file
9439
modules/freetype2/ChangeLog.21
Normal file
File diff suppressed because it is too large
Load diff
2837
modules/freetype2/ChangeLog.22
Normal file
2837
modules/freetype2/ChangeLog.22
Normal file
File diff suppressed because it is too large
Load diff
7948
modules/freetype2/ChangeLog.23
Normal file
7948
modules/freetype2/ChangeLog.23
Normal file
File diff suppressed because it is too large
Load diff
6360
modules/freetype2/ChangeLog.24
Normal file
6360
modules/freetype2/ChangeLog.24
Normal file
File diff suppressed because it is too large
Load diff
5161
modules/freetype2/ChangeLog.25
Normal file
5161
modules/freetype2/ChangeLog.25
Normal file
File diff suppressed because it is too large
Load diff
5711
modules/freetype2/ChangeLog.26
Normal file
5711
modules/freetype2/ChangeLog.26
Normal file
File diff suppressed because it is too large
Load diff
222
modules/freetype2/Jamfile
Normal file
222
modules/freetype2/Jamfile
Normal file
|
|
@ -0,0 +1,222 @@
|
|||
# FreeType 2 top Jamfile.
|
||||
#
|
||||
# Copyright 2001-2016 by
|
||||
# David Turner, Robert Wilhelm, and Werner Lemberg.
|
||||
#
|
||||
# This file is part of the FreeType project, and may only be used, modified,
|
||||
# and distributed under the terms of the FreeType project license,
|
||||
# LICENSE.TXT. By continuing to use, modify, or distribute this file you
|
||||
# indicate that you have read the license and understand and accept it
|
||||
# fully.
|
||||
|
||||
|
||||
# The HDRMACRO is already defined in FTJam and is used to add
|
||||
# the content of certain macros to the list of included header
|
||||
# files.
|
||||
#
|
||||
# We can compile FreeType 2 with classic Jam however thanks to
|
||||
# the following code
|
||||
#
|
||||
if ! $(JAM_TOOLSET)
|
||||
{
|
||||
rule HDRMACRO
|
||||
{
|
||||
# nothing
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
# We need to invoke a SubDir rule if the FT2 source directory top is not the
|
||||
# current directory. This allows us to build FreeType 2 as part of a larger
|
||||
# project easily.
|
||||
#
|
||||
if $(FT2_TOP) != $(DOT)
|
||||
{
|
||||
SubDir FT2_TOP ;
|
||||
}
|
||||
|
||||
|
||||
# The following macros define the include directory, the source directory,
|
||||
# and the final library name (without library extensions). They can be
|
||||
# replaced by other definitions when the library is compiled as part of
|
||||
# a larger project.
|
||||
#
|
||||
|
||||
# Name of FreeType include directory during compilation.
|
||||
# This is relative to FT2_TOP.
|
||||
#
|
||||
FT2_INCLUDE_DIR ?= include ;
|
||||
|
||||
# Name of FreeType source directory during compilation.
|
||||
# This is relative to FT2_TOP.
|
||||
#
|
||||
FT2_SRC_DIR ?= src ;
|
||||
|
||||
# Name of final library, without extension.
|
||||
#
|
||||
FT2_LIB ?= $(LIBPREFIX)freetype ;
|
||||
|
||||
|
||||
# Define FT2_BUILD_INCLUDE to point to your build-specific directory.
|
||||
# This is prepended to FT2_INCLUDE_DIR. It can be used to specify
|
||||
# the location of a custom <ft2build.h> which will point to custom
|
||||
# versions of `ftmodule.h' and `ftoption.h', for example.
|
||||
#
|
||||
FT2_BUILD_INCLUDE ?= ;
|
||||
|
||||
# The list of modules to compile on any given build of the library.
|
||||
# By default, this will contain _all_ modules defined in FT2_SRC_DIR.
|
||||
#
|
||||
# IMPORTANT: You'll need to change the content of `ftmodule.h' as well
|
||||
# if you modify this list or provide your own.
|
||||
#
|
||||
FT2_COMPONENTS ?= autofit # auto-fitter
|
||||
base # base component (public APIs)
|
||||
bdf # BDF font driver
|
||||
bzip2 # support for bzip2-compressed PCF font
|
||||
cache # cache sub-system
|
||||
cff # CFF/CEF font driver
|
||||
cid # PostScript CID-keyed font driver
|
||||
gzip # support for gzip-compressed PCF font
|
||||
lzw # support for LZW-compressed PCF font
|
||||
pcf # PCF font driver
|
||||
pfr # PFR/TrueDoc font driver
|
||||
psaux # common PostScript routines module
|
||||
pshinter # PostScript hinter module
|
||||
psnames # PostScript names handling
|
||||
raster # monochrome rasterizer
|
||||
sfnt # SFNT-based format support routines
|
||||
smooth # anti-aliased rasterizer
|
||||
truetype # TrueType font driver
|
||||
type1 # PostScript Type 1 font driver
|
||||
type42 # PostScript Type 42 (embedded TrueType) driver
|
||||
winfonts # Windows FON/FNT font driver
|
||||
;
|
||||
|
||||
|
||||
# Don't touch.
|
||||
#
|
||||
FT2_INCLUDE = $(FT2_BUILD_INCLUDE)
|
||||
[ FT2_SubDir $(FT2_INCLUDE_DIR) ] ;
|
||||
|
||||
FT2_SRC = [ FT2_SubDir $(FT2_SRC_DIR) ] ;
|
||||
|
||||
# Location of API Reference Documentation
|
||||
#
|
||||
if $(DOC_DIR)
|
||||
{
|
||||
DOC_DIR = $(DOCDIR:T) ;
|
||||
}
|
||||
else
|
||||
{
|
||||
DOC_DIR = docs/reference ;
|
||||
}
|
||||
|
||||
|
||||
# Only used by FreeType developers.
|
||||
#
|
||||
if $(DEBUG_HINTER)
|
||||
{
|
||||
CCFLAGS += -DDEBUG_HINTER ;
|
||||
}
|
||||
|
||||
|
||||
# We need `include' in the current include path in order to
|
||||
# compile any part of FreeType 2.
|
||||
#
|
||||
HDRS += $(FT2_INCLUDE) ;
|
||||
|
||||
|
||||
# We need to #define FT2_BUILD_LIBRARY so that our sources find the
|
||||
# internal headers
|
||||
#
|
||||
CCFLAGS += -DFT2_BUILD_LIBRARY ;
|
||||
|
||||
# Uncomment the following line if you want to build individual source files
|
||||
# for each FreeType 2 module. This is only useful during development, and
|
||||
# is better defined as an environment variable anyway!
|
||||
#
|
||||
# FT2_MULTI = true ;
|
||||
|
||||
|
||||
# The files `ftheader.h', `internal.h', and `ftserv.h' are used to define
|
||||
# macros that are later used in #include statements. They need to be parsed
|
||||
# in order to record these definitions.
|
||||
#
|
||||
HDRMACRO [ FT2_SubDir $(FT2_INCLUDE_DIR) freetype config ftheader.h ] ;
|
||||
HDRMACRO [ FT2_SubDir $(FT2_INCLUDE_DIR) freetype internal internal.h ] ;
|
||||
HDRMACRO [ FT2_SubDir $(FT2_INCLUDE_DIR) freetype internal ftserv.h ] ;
|
||||
|
||||
|
||||
# Now include the Jamfile in `freetype2/src', used to drive the compilation
|
||||
# of each FreeType 2 component and/or module.
|
||||
#
|
||||
SubInclude FT2_TOP $(FT2_SRC_DIR) ;
|
||||
|
||||
# Handle the generation of the `ftexport.sym' file, which contains the list
|
||||
# of exported symbols. This can be used on Unix by libtool.
|
||||
#
|
||||
SubInclude FT2_TOP $(FT2_SRC_DIR) tools ;
|
||||
|
||||
rule GenExportSymbols
|
||||
{
|
||||
local apinames = apinames$(SUFEXE) ;
|
||||
local aheader ;
|
||||
local headers ;
|
||||
|
||||
for aheader in [ Glob $(2) : *.h ]
|
||||
{
|
||||
switch $(aheader)
|
||||
{
|
||||
case */ftmac.h :
|
||||
if ( $(MAC) || $(OS) = MACOSX ) {
|
||||
headers += $(aheader) ;
|
||||
}
|
||||
case *.h : headers += $(aheader) ;
|
||||
}
|
||||
}
|
||||
|
||||
LOCATE on $(1) = $(ALL_LOCATE_TARGET) ;
|
||||
|
||||
APINAMES on $(1) = apinames$(SUFEXE) ;
|
||||
|
||||
Depends $(1) : $(apinames) $(headers) ;
|
||||
GenExportSymbols1 $(1) : $(headers) ;
|
||||
Clean clean : $(1) ;
|
||||
}
|
||||
|
||||
actions GenExportSymbols1 bind APINAMES
|
||||
{
|
||||
$(APINAMES) $(2) > $(1)
|
||||
}
|
||||
|
||||
GenExportSymbols ftexport.sym : include/freetype ;
|
||||
|
||||
# Test files (hinter debugging). Only used by FreeType developers.
|
||||
#
|
||||
if $(DEBUG_HINTER)
|
||||
{
|
||||
SubInclude FT2_TOP tests ;
|
||||
}
|
||||
|
||||
rule RefDoc
|
||||
{
|
||||
Depends $1 : all ;
|
||||
NotFile $1 ;
|
||||
Always $1 ;
|
||||
}
|
||||
|
||||
actions RefDoc
|
||||
{
|
||||
python $(FT2_SRC)/tools/docmaker/docmaker.py
|
||||
--prefix=ft2
|
||||
--title=FreeType-2.7.1
|
||||
--output=$(DOC_DIR)
|
||||
$(FT2_INCLUDE)/freetype/*.h
|
||||
$(FT2_INCLUDE)/freetype/config/*.h
|
||||
}
|
||||
|
||||
RefDoc refdoc ;
|
||||
|
||||
|
||||
# end of top Jamfile
|
||||
71
modules/freetype2/Jamrules
Normal file
71
modules/freetype2/Jamrules
Normal file
|
|
@ -0,0 +1,71 @@
|
|||
# FreeType 2 JamRules.
|
||||
#
|
||||
# Copyright 2001-2016 by
|
||||
# David Turner, Robert Wilhelm, and Werner Lemberg.
|
||||
#
|
||||
# This file is part of the FreeType project, and may only be used, modified,
|
||||
# and distributed under the terms of the FreeType project license,
|
||||
# LICENSE.TXT. By continuing to use, modify, or distribute this file you
|
||||
# indicate that you have read the license and understand and accept it
|
||||
# fully.
|
||||
|
||||
|
||||
# This file contains the Jam rules needed to build the FreeType 2 library.
|
||||
# It is shared by all Jamfiles and is included only once in the build
|
||||
# process.
|
||||
#
|
||||
|
||||
|
||||
# Call SubDirHdrs on a list of directories.
|
||||
#
|
||||
rule AddSubDirHdrs
|
||||
{
|
||||
local x ;
|
||||
|
||||
for x in $(<)
|
||||
{
|
||||
SubDirHdrs $(x) ;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
# Determine prefix of library file. We must use "libxxxxx" on Unix systems,
|
||||
# while all other simply use the real name.
|
||||
#
|
||||
if $(UNIX)
|
||||
{
|
||||
LIBPREFIX ?= lib ;
|
||||
}
|
||||
else
|
||||
{
|
||||
LIBPREFIX ?= "" ;
|
||||
}
|
||||
|
||||
# FT2_TOP contains the location of the FreeType source directory. You can
|
||||
# set it to a specific value if you want to compile the library as part of a
|
||||
# larger project.
|
||||
#
|
||||
FT2_TOP ?= $(DOT) ;
|
||||
|
||||
# Define a new rule used to declare a sub directory of the Nirvana source
|
||||
# tree.
|
||||
#
|
||||
rule FT2_SubDir
|
||||
{
|
||||
if $(FT2_TOP) = $(DOT)
|
||||
{
|
||||
return [ FDirName $(<) ] ;
|
||||
}
|
||||
else
|
||||
{
|
||||
return [ FDirName $(FT2_TOP) $(<) ] ;
|
||||
}
|
||||
}
|
||||
|
||||
# We also set ALL_LOCATE_TARGET in order to place all object and library
|
||||
# files in "objs".
|
||||
#
|
||||
ALL_LOCATE_TARGET ?= [ FT2_SubDir objs ] ;
|
||||
|
||||
|
||||
# end of Jamrules
|
||||
39
modules/freetype2/LICENSE.TXT
Normal file
39
modules/freetype2/LICENSE.TXT
Normal file
|
|
@ -0,0 +1,39 @@
|
|||
|
||||
The FreeType 2 font engine is copyrighted work and cannot be used
|
||||
legally without a software license. In order to make this project
|
||||
usable to a vast majority of developers, we distribute it under two
|
||||
mutually exclusive open-source licenses.
|
||||
|
||||
This means that *you* must choose *one* of the two licenses described
|
||||
below, then obey all its terms and conditions when using FreeType 2 in
|
||||
any of your projects or products.
|
||||
|
||||
- The FreeType License, found in the file `FTL.TXT', which is similar
|
||||
to the original BSD license *with* an advertising clause that forces
|
||||
you to explicitly cite the FreeType project in your product's
|
||||
documentation. All details are in the license file. This license
|
||||
is suited to products which don't use the GNU General Public
|
||||
License.
|
||||
|
||||
Note that this license is compatible to the GNU General Public
|
||||
License version 3, but not version 2.
|
||||
|
||||
- The GNU General Public License version 2, found in `GPLv2.TXT' (any
|
||||
later version can be used also), for programs which already use the
|
||||
GPL. Note that the FTL is incompatible with GPLv2 due to its
|
||||
advertisement clause.
|
||||
|
||||
The contributed BDF and PCF drivers come with a license similar to that
|
||||
of the X Window System. It is compatible to the above two licenses (see
|
||||
file src/bdf/README and src/pcf/README). The same holds for the files
|
||||
`fthash.c' and `fthash.h'; their code was part of the BDF driver in
|
||||
earlier FreeType versions.
|
||||
|
||||
The gzip module uses the zlib license (see src/gzip/zlib.h) which too is
|
||||
compatible to the above two licenses.
|
||||
|
||||
The MD5 checksum support (only used for debugging in development builds)
|
||||
is in the public domain.
|
||||
|
||||
|
||||
--- end of LICENSE.TXT ---
|
||||
34
modules/freetype2/Makefile
Normal file
34
modules/freetype2/Makefile
Normal file
|
|
@ -0,0 +1,34 @@
|
|||
#
|
||||
# FreeType 2 build system -- top-level Makefile
|
||||
#
|
||||
|
||||
|
||||
# Copyright 1996-2016 by
|
||||
# David Turner, Robert Wilhelm, and Werner Lemberg.
|
||||
#
|
||||
# This file is part of the FreeType project, and may only be used, modified,
|
||||
# and distributed under the terms of the FreeType project license,
|
||||
# LICENSE.TXT. By continuing to use, modify, or distribute this file you
|
||||
# indicate that you have read the license and understand and accept it
|
||||
# fully.
|
||||
|
||||
|
||||
# Project names
|
||||
#
|
||||
PROJECT := freetype
|
||||
PROJECT_TITLE := FreeType
|
||||
|
||||
# The variable TOP_DIR holds the path to the topmost directory in the project
|
||||
# engine source hierarchy. If it is not defined, default it to `.'.
|
||||
#
|
||||
TOP_DIR ?= .
|
||||
|
||||
# The variable OBJ_DIR gives the location where object files and the
|
||||
# FreeType library are built.
|
||||
#
|
||||
OBJ_DIR ?= $(TOP_DIR)/objs
|
||||
|
||||
|
||||
include $(TOP_DIR)/builds/toplevel.mk
|
||||
|
||||
# EOF
|
||||
84
modules/freetype2/README
Normal file
84
modules/freetype2/README
Normal file
|
|
@ -0,0 +1,84 @@
|
|||
FreeType 2.7.1
|
||||
==============
|
||||
|
||||
Homepage: http://www.freetype.org
|
||||
|
||||
FreeType is a freely available software library to render fonts.
|
||||
|
||||
It is written in C, designed to be small, efficient, highly
|
||||
customizable, and portable while capable of producing high-quality
|
||||
output (glyph images) of most vector and bitmap font formats.
|
||||
|
||||
Please read the docs/CHANGES file, it contains IMPORTANT
|
||||
INFORMATION.
|
||||
|
||||
Read the files `docs/INSTALL*' for installation instructions; see
|
||||
the file `docs/LICENSE.TXT' for the available licenses.
|
||||
|
||||
The FreeType 2 API reference is located in `docs/reference'; use the
|
||||
file `ft2-toc.html' as the top entry point. Additional
|
||||
documentation is available as a separate package from our sites. Go
|
||||
to
|
||||
|
||||
http://download.savannah.gnu.org/releases/freetype/
|
||||
|
||||
and download one of the following files.
|
||||
|
||||
freetype-doc-2.7.1.tar.bz2
|
||||
freetype-doc-2.7.1.tar.gz
|
||||
ftdoc271.zip
|
||||
|
||||
To view the documentation online, go to
|
||||
|
||||
http://www.freetype.org/freetype2/documentation.html
|
||||
|
||||
|
||||
Mailing Lists
|
||||
=============
|
||||
|
||||
The preferred way of communication with the FreeType team is using
|
||||
e-mail lists.
|
||||
|
||||
general use and discussion: freetype@nongnu.org
|
||||
engine internals, porting, etc.: freetype-devel@nongnu.org
|
||||
announcements: freetype-announce@nongnu.org
|
||||
git repository tracker: freetype-commit@nongnu.org
|
||||
|
||||
The lists are moderated; see
|
||||
|
||||
http://www.freetype.org/contact.html
|
||||
|
||||
how to subscribe.
|
||||
|
||||
|
||||
Bugs
|
||||
====
|
||||
|
||||
Please submit bug reports at
|
||||
|
||||
https://savannah.nongnu.org/bugs/?group=freetype
|
||||
|
||||
Alternatively, you might report bugs by e-mail to
|
||||
`freetype-devel@nongnu.org'. Don't forget to send a detailed
|
||||
explanation of the problem -- there is nothing worse than receiving
|
||||
a terse message that only says `it doesn't work'.
|
||||
|
||||
|
||||
Enjoy!
|
||||
|
||||
|
||||
The FreeType Team
|
||||
|
||||
----------------------------------------------------------------------
|
||||
|
||||
Copyright 2006-2016 by
|
||||
David Turner, Robert Wilhelm, and Werner Lemberg.
|
||||
|
||||
This file is part of the FreeType project, and may only be used,
|
||||
modified, and distributed under the terms of the FreeType project
|
||||
license, LICENSE.TXT. By continuing to use, modify, or distribute
|
||||
this file you indicate that you have read the license and understand
|
||||
and accept it fully.
|
||||
|
||||
|
||||
--- end of README ---
|
||||
50
modules/freetype2/README.git
Normal file
50
modules/freetype2/README.git
Normal file
|
|
@ -0,0 +1,50 @@
|
|||
The git archive doesn't contain pre-built configuration scripts for
|
||||
UNIXish platforms. To generate them say
|
||||
|
||||
sh autogen.sh
|
||||
|
||||
which in turn depends on the following packages:
|
||||
|
||||
automake (1.10.1)
|
||||
libtool (2.2.4)
|
||||
autoconf (2.62)
|
||||
|
||||
The versions given in parentheses are known to work. Newer versions
|
||||
should work too, of course. Note that autogen.sh also sets up proper
|
||||
file permissions for the `configure' and auxiliary scripts.
|
||||
|
||||
The autogen.sh script now checks the version of above three packages
|
||||
whether they match the numbers above. Otherwise it will complain and
|
||||
suggest either upgrading or using an environment variable to point to
|
||||
a more recent version of the required tool(s).
|
||||
|
||||
Note that `aclocal' is provided by the `automake' package on Linux,
|
||||
and that `libtoolize' is called `glibtoolize' on Darwin (OS X).
|
||||
|
||||
|
||||
For static builds which don't use platform specific optimizations, no
|
||||
configure script is necessary at all; saying
|
||||
|
||||
make setup ansi
|
||||
make
|
||||
|
||||
should work on all platforms which have GNU make (or makepp).
|
||||
|
||||
|
||||
Similarly, a build with `cmake' can be done directly from the git
|
||||
repository.
|
||||
|
||||
|
||||
----------------------------------------------------------------------
|
||||
|
||||
Copyright 2005-2016 by
|
||||
David Turner, Robert Wilhelm, and Werner Lemberg.
|
||||
|
||||
This file is part of the FreeType project, and may only be used,
|
||||
modified, and distributed under the terms of the FreeType project
|
||||
license, LICENSE.TXT. By continuing to use, modify, or distribute
|
||||
this file you indicate that you have read the license and understand
|
||||
and accept it fully.
|
||||
|
||||
|
||||
--- end of README.git ---
|
||||
6
modules/freetype2/README.moz-patches
Normal file
6
modules/freetype2/README.moz-patches
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
This directory contains freetype2 v2.7 downloaded from
|
||||
http://savannah.nongnu.org/download/freetype/
|
||||
|
||||
There are currently no local changes applied to the freetype tree,
|
||||
except that the file docs/LICENSE.TXT has been copied to the top-level
|
||||
directory of the FreeType tree as LICENSE.TXT.
|
||||
165
modules/freetype2/autogen.sh
Normal file
165
modules/freetype2/autogen.sh
Normal file
|
|
@ -0,0 +1,165 @@
|
|||
#!/bin/sh
|
||||
|
||||
# Copyright 2005-2016 by
|
||||
# David Turner, Robert Wilhelm, and Werner Lemberg.
|
||||
#
|
||||
# This file is part of the FreeType project, and may only be used, modified,
|
||||
# and distributed under the terms of the FreeType project license,
|
||||
# LICENSE.TXT. By continuing to use, modify, or distribute this file you
|
||||
# indicate that you have read the license and understand and accept it
|
||||
# fully.
|
||||
|
||||
run ()
|
||||
{
|
||||
echo "running \`$*'"
|
||||
eval $*
|
||||
|
||||
if test $? != 0 ; then
|
||||
echo "error while running \`$*'"
|
||||
exit 1
|
||||
fi
|
||||
}
|
||||
|
||||
get_major_version ()
|
||||
{
|
||||
echo $1 | sed -e 's/\([0-9][0-9]*\)\..*/\1/g'
|
||||
}
|
||||
|
||||
get_minor_version ()
|
||||
{
|
||||
echo $1 | sed -e 's/[0-9][0-9]*\.\([0-9][0-9]*\).*/\1/g'
|
||||
}
|
||||
|
||||
get_patch_version ()
|
||||
{
|
||||
# tricky: some version numbers don't include a patch
|
||||
# separated with a point, but something like 1.4-p6
|
||||
patch=`echo $1 | sed -e 's/[0-9][0-9]*\.[0-9][0-9]*\.\([0-9][0-9]*\).*/\1/g'`
|
||||
if test "$patch" = "$1"; then
|
||||
patch=`echo $1 | sed -e 's/[0-9][0-9]*\.[0-9][0-9]*\-p\([0-9][0-9]*\).*/\1/g'`
|
||||
# if there isn't any patch number, default to 0
|
||||
if test "$patch" = "$1"; then
|
||||
patch=0
|
||||
fi
|
||||
fi
|
||||
echo $patch
|
||||
}
|
||||
|
||||
# $1: version to check
|
||||
# $2: minimum version
|
||||
|
||||
compare_to_minimum_version ()
|
||||
{
|
||||
MAJOR1=`get_major_version $1`
|
||||
MAJOR2=`get_major_version $2`
|
||||
if test $MAJOR1 -lt $MAJOR2; then
|
||||
echo 0
|
||||
return
|
||||
else
|
||||
if test $MAJOR1 -gt $MAJOR2; then
|
||||
echo 1
|
||||
return
|
||||
fi
|
||||
fi
|
||||
|
||||
MINOR1=`get_minor_version $1`
|
||||
MINOR2=`get_minor_version $2`
|
||||
if test $MINOR1 -lt $MINOR2; then
|
||||
echo 0
|
||||
return
|
||||
else
|
||||
if test $MINOR1 -gt $MINOR2; then
|
||||
echo 1
|
||||
return
|
||||
fi
|
||||
fi
|
||||
|
||||
PATCH1=`get_patch_version $1`
|
||||
PATCH2=`get_patch_version $2`
|
||||
if test $PATCH1 -lt $PATCH2; then
|
||||
echo 0
|
||||
else
|
||||
echo 1
|
||||
fi
|
||||
}
|
||||
|
||||
# check the version of a given tool against a minimum version number
|
||||
#
|
||||
# $1: tool path
|
||||
# $2: tool usual name (e.g. `aclocal')
|
||||
# $3: tool variable (e.g. `ACLOCAL')
|
||||
# $4: minimum version to check against
|
||||
# $5: option field index used to extract the tool version from the
|
||||
# output of --version
|
||||
|
||||
check_tool_version ()
|
||||
{
|
||||
field=$5
|
||||
# assume the output of "[TOOL] --version" is "toolname (GNU toolname foo bar) version"
|
||||
if test "$field"x = x; then
|
||||
field=3 # default to 3 for all GNU autotools, after filtering enclosed string
|
||||
fi
|
||||
version=`$1 --version | head -1 | sed 's/([^)]*)/()/g' | cut -d ' ' -f $field`
|
||||
version_check=`compare_to_minimum_version $version $4`
|
||||
if test "$version_check"x = 0x; then
|
||||
echo "ERROR: Your version of the \`$2' tool is too old."
|
||||
echo " Minimum version $4 is required (yours is version $version)."
|
||||
echo " Please upgrade or use the $3 variable to point to a more recent one."
|
||||
echo ""
|
||||
exit 1
|
||||
fi
|
||||
}
|
||||
|
||||
if test ! -f ./builds/unix/configure.raw; then
|
||||
echo "You must be in the same directory as \`autogen.sh'."
|
||||
echo "Bootstrapping doesn't work if srcdir != builddir."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# On MacOS X, the GNU libtool is named `glibtool'.
|
||||
HOSTOS=`uname`
|
||||
if test "$LIBTOOLIZE"x != x; then
|
||||
:
|
||||
elif test "$HOSTOS"x = Darwinx; then
|
||||
LIBTOOLIZE=glibtoolize
|
||||
else
|
||||
LIBTOOLIZE=libtoolize
|
||||
fi
|
||||
|
||||
if test "$ACLOCAL"x = x; then
|
||||
ACLOCAL=aclocal
|
||||
fi
|
||||
|
||||
if test "$AUTOCONF"x = x; then
|
||||
AUTOCONF=autoconf
|
||||
fi
|
||||
|
||||
check_tool_version $ACLOCAL aclocal ACLOCAL 1.10.1
|
||||
check_tool_version $LIBTOOLIZE libtoolize LIBTOOLIZE 2.2.4
|
||||
check_tool_version $AUTOCONF autoconf AUTOCONF 2.62
|
||||
|
||||
# This sets freetype_major, freetype_minor, and freetype_patch.
|
||||
eval `sed -nf version.sed include/freetype/freetype.h`
|
||||
|
||||
# We set freetype-patch to an empty value if it is zero.
|
||||
if test "$freetype_patch" = ".0"; then
|
||||
freetype_patch=
|
||||
fi
|
||||
|
||||
cd builds/unix
|
||||
|
||||
echo "generating \`configure.ac'"
|
||||
sed -e "s;@VERSION@;$freetype_major$freetype_minor$freetype_patch;" \
|
||||
< configure.raw > configure.ac
|
||||
|
||||
run aclocal -I . --force
|
||||
run $LIBTOOLIZE --force --copy --install
|
||||
run autoconf --force
|
||||
|
||||
chmod +x install-sh
|
||||
|
||||
cd ../..
|
||||
|
||||
chmod +x ./configure
|
||||
|
||||
# EOF
|
||||
110
modules/freetype2/builds/amiga/README
Normal file
110
modules/freetype2/builds/amiga/README
Normal file
|
|
@ -0,0 +1,110 @@
|
|||
|
||||
README for the builds/amiga subdirectory.
|
||||
|
||||
Copyright 2005-2016 by
|
||||
Werner Lemberg and Detlef Würkner.
|
||||
|
||||
This file is part of the FreeType project, and may only be used, modified,
|
||||
and distributed under the terms of the FreeType project license,
|
||||
LICENSE.TXT. By continuing to use, modify, or distribute this file you
|
||||
indicate that you have read the license and understand and accept it
|
||||
fully.
|
||||
|
||||
|
||||
The makefile.os4 is for the AmigaOS4 SDK. To use it, type
|
||||
"make -f makefile.os4", it produces a link library libft2_ppc.a.
|
||||
|
||||
The makefile is for ppc-morphos-gcc-2.95.3-bin.tgz (gcc 2.95.3 hosted on
|
||||
68k-Amiga producing MorphOS-PPC-binaries from http://www.morphos.de).
|
||||
To use it, type "make assign", then "make"; it produces a link library
|
||||
libft2_ppc.a.
|
||||
|
||||
The smakefile is a makefile for Amiga SAS/C 6.58 (no longer available,
|
||||
latest sold version was 6.50, updates can be found in Aminet). It is
|
||||
based on the version found in the sourcecode of ttf.library 0.83b for
|
||||
FreeType 1.3.1 from Richard Griffith (ragriffi@sprynet.com,
|
||||
http://ragriffi.home.sprynet.com).
|
||||
|
||||
You will also need the latest include files and amiga.lib from the
|
||||
Amiga web site (http://www.amiga.com/3.9/download/NDK3.9.lha) for
|
||||
AmigaOS 3.9; the generated code should work under AmigaOS 2.04 and up.
|
||||
|
||||
To use it, call "smake assign" and then "smake" from the builds/amiga
|
||||
directory. The results are:
|
||||
|
||||
- A link library "ft2_680x0.lib" (where x depends on the setting of
|
||||
the CPU entry in the smakefile) containing all FreeType2 parts
|
||||
except of the init code, debugging code, and the system interface
|
||||
code.
|
||||
|
||||
- ftsystem.o, an object module containing the standard version of the
|
||||
system interface code which uses fopen() fclose() fread() fseek()
|
||||
ftell() malloc() realloc() and free() from lib:sc.lib (not pure).
|
||||
|
||||
- ftsystempure.o, an object module containing the pure version of the
|
||||
system interface code which uses Open() Close() Read() Seek()
|
||||
ExamineFH() AsmAllocPooled() AsmFreePooled() etc. This version can
|
||||
be used in both normal programs and in Amiga run-time shared system
|
||||
librarys (can be linked with lib:libinit.o, no copying of DATA and
|
||||
BSS hunks for each OpenLibrary() necessary). Source code is in
|
||||
src/base/ftsystem.c.
|
||||
|
||||
- ftdebug.o, an object module containing the standard version of the
|
||||
debugging code which uses vprintf() and exit() (not pure).
|
||||
Debugging can be turned on in FT:include/freetype/config/ftoption.h
|
||||
and with FT_SetTraceLevel().
|
||||
|
||||
- ftdebugpure.o, an object module containing the pure version of the
|
||||
debugging code which uses KVPrintf() from lib:debug.lib and no
|
||||
exit(). For debugging of Amiga run-time shared system libraries.
|
||||
Source code is in src/base/ftdebug.c.
|
||||
|
||||
- NO ftinit.o. Because linking with a link library should result in
|
||||
linking only the needed object modules in it, but standard
|
||||
ftsystem.o would force ALL FreeType2 modules to be linked to your
|
||||
program, I decided to use a different scheme: You must #include
|
||||
FT:src/base/ftinit.c in your sourcecode and specify with #define
|
||||
statements which modules you need. See
|
||||
include/freetype/config/ftmodule.h.
|
||||
|
||||
|
||||
To use in your own programs:
|
||||
|
||||
- Insert the #define and #include statements from top of
|
||||
include/freetype/config/ftmodule.h in your source code and
|
||||
uncomment the #define statements for the FreeType2 modules you need.
|
||||
|
||||
- You can use either PARAMETERS=REGISTER or PARAMETERS=STACK for
|
||||
calling the FreeType2 functions, because the link library and the
|
||||
object files are compiled with PARAMETERS=BOTH.
|
||||
|
||||
- "smake assign" (assign "FT:" to the FreeType2 main directory).
|
||||
|
||||
- Compile your program.
|
||||
|
||||
- Link with either ftsystem.o or ftsystempure.o, if debugging enabled
|
||||
with either ftdebug.o or (ftdebugpure.o and lib:debug.lib), and with
|
||||
ft2_680x0.lib as link library.
|
||||
|
||||
|
||||
To adapt to other compilers:
|
||||
|
||||
- The standard ANSI C maximum length of 31 significant characters in
|
||||
identifiers is not enough for FreeType2. Check if your compiler has
|
||||
a minimum length of 40 significant characters or can be switched to
|
||||
it. "idlen=40" is the option for SAS/C. Setting #define
|
||||
HAVE_LIMIT_ON_IDENTS in an include file may also work (not tested).
|
||||
|
||||
- Make sure that the include directory in builds/amiga is searched
|
||||
before the normal FreeType2 include directory, so you are able to
|
||||
replace problematic include files with your own version (same may be
|
||||
useful for the src directory).
|
||||
|
||||
- An example of how to replace/workaround a problematic include file
|
||||
is include/freetype/config/ftconfig.h; it changes a #define that
|
||||
would prevent SAS/C from generating XDEF's where it should do that and
|
||||
then includes the standard FreeType2 include file.
|
||||
|
||||
Local Variables:
|
||||
coding: latin-1
|
||||
End:
|
||||
55
modules/freetype2/builds/amiga/include/config/ftconfig.h
Normal file
55
modules/freetype2/builds/amiga/include/config/ftconfig.h
Normal file
|
|
@ -0,0 +1,55 @@
|
|||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftconfig.h */
|
||||
/* */
|
||||
/* Amiga-specific configuration file (specification only). */
|
||||
/* */
|
||||
/* Copyright 2005-2016 by */
|
||||
/* Werner Lemberg and Detlef Würkner. */
|
||||
/* */
|
||||
/* This file is part of the FreeType project, and may only be used, */
|
||||
/* modified, and distributed under the terms of the FreeType project */
|
||||
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
|
||||
/* this file you indicate that you have read the license and */
|
||||
/* understand and accept it fully. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
/*
|
||||
* This is an example how to override the default FreeType2 header files
|
||||
* with Amiga-specific changes. When the compiler searches this directory
|
||||
* before the default directory, we can do some modifications.
|
||||
*
|
||||
* Here we must change FT_EXPORT_DEF so that SAS/C does
|
||||
* generate the needed XDEFs.
|
||||
*/
|
||||
|
||||
#if 0
|
||||
#define FT_EXPORT_DEF( x ) extern x
|
||||
#endif
|
||||
|
||||
#undef FT_EXPORT_DEF
|
||||
#define FT_EXPORT_DEF( x ) x
|
||||
|
||||
/* Now include the original file */
|
||||
#ifndef __MORPHOS__
|
||||
#ifdef __SASC
|
||||
#include "FT:include/freetype/config/ftconfig.h"
|
||||
#else
|
||||
#include "/FT/include/freetype/config/ftconfig.h"
|
||||
#endif
|
||||
#else
|
||||
/* We must define that, it seems that
|
||||
* lib/gcc-lib/ppc-morphos/2.95.3/include/syslimits.h is missing in
|
||||
* ppc-morphos-gcc-2.95.3-bin.tgz (gcc for 68k producing MorphOS PPC elf
|
||||
* binaries from http://www.morphos.de)
|
||||
*/
|
||||
#define _LIBC_LIMITS_H_
|
||||
#include "/FT/include/freetype/config/ftconfig.h"
|
||||
#endif
|
||||
|
||||
/*
|
||||
Local Variables:
|
||||
coding: latin-1
|
||||
End:
|
||||
*/
|
||||
160
modules/freetype2/builds/amiga/include/config/ftmodule.h
Normal file
160
modules/freetype2/builds/amiga/include/config/ftmodule.h
Normal file
|
|
@ -0,0 +1,160 @@
|
|||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftmodule.h */
|
||||
/* */
|
||||
/* Amiga-specific FreeType module selection. */
|
||||
/* */
|
||||
/* Copyright 2005-2016 by */
|
||||
/* Werner Lemberg and Detlef Würkner. */
|
||||
/* */
|
||||
/* This file is part of the FreeType project, and may only be used, */
|
||||
/* modified, and distributed under the terms of the FreeType project */
|
||||
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
|
||||
/* this file you indicate that you have read the license and */
|
||||
/* understand and accept it fully. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
/*
|
||||
* To avoid that all your programs include all FreeType modules,
|
||||
* you copy the following piece of source code into your own
|
||||
* source file and specify which modules you really need in your
|
||||
* application by uncommenting the appropriate lines.
|
||||
*/
|
||||
/*
|
||||
//#define FT_USE_AUTOFIT // autofitter
|
||||
//#define FT_USE_RASTER // monochrome rasterizer
|
||||
//#define FT_USE_SMOOTH // anti-aliasing rasterizer
|
||||
//#define FT_USE_TT // truetype font driver
|
||||
//#define FT_USE_T1 // type1 font driver
|
||||
//#define FT_USE_T42 // type42 font driver
|
||||
//#define FT_USE_T1CID // cid-keyed type1 font driver // no cmap support
|
||||
//#define FT_USE_CFF // opentype font driver
|
||||
//#define FT_USE_BDF // bdf bitmap font driver
|
||||
//#define FT_USE_PCF // pcf bitmap font driver
|
||||
//#define FT_USE_PFR // pfr font driver
|
||||
//#define FT_USE_WINFNT // windows .fnt|.fon bitmap font driver
|
||||
//#define FT_USE_OTV // opentype validator
|
||||
//#define FT_USE_GXV // truetype gx validator
|
||||
#include "FT:src/base/ftinit.c"
|
||||
*/
|
||||
|
||||
/* Make sure that the needed support modules are built in.
|
||||
* Dependencies can be found by searching for FT_Get_Module.
|
||||
*/
|
||||
|
||||
#ifdef FT_USE_T42
|
||||
#define FT_USE_TT
|
||||
#endif
|
||||
|
||||
#ifdef FT_USE_TT
|
||||
#define FT_USE_SFNT
|
||||
#endif
|
||||
|
||||
#ifdef FT_USE_CFF
|
||||
#define FT_USE_SFNT
|
||||
#define FT_USE_PSHINT
|
||||
#define FT_USE_PSNAMES
|
||||
#endif
|
||||
|
||||
#ifdef FT_USE_T1
|
||||
#define FT_USE_PSAUX
|
||||
#define FT_USE_PSHINT
|
||||
#define FT_USE_PSNAMES
|
||||
#endif
|
||||
|
||||
#ifdef FT_USE_T1CID
|
||||
#define FT_USE_PSAUX
|
||||
#define FT_USE_PSHINT
|
||||
#define FT_USE_PSNAMES
|
||||
#endif
|
||||
|
||||
#ifdef FT_USE_PSAUX
|
||||
#define FT_USE_PSNAMES
|
||||
#endif
|
||||
|
||||
#ifdef FT_USE_SFNT
|
||||
#define FT_USE_PSNAMES
|
||||
#endif
|
||||
|
||||
/* Now include the modules */
|
||||
|
||||
#ifdef FT_USE_AUTOFIT
|
||||
FT_USE_MODULE( FT_Module_Class, autofit_module_class )
|
||||
#endif
|
||||
|
||||
#ifdef FT_USE_TT
|
||||
FT_USE_MODULE( FT_Driver_ClassRec, tt_driver_class )
|
||||
#endif
|
||||
|
||||
#ifdef FT_USE_T1
|
||||
FT_USE_MODULE( FT_Driver_ClassRec, t1_driver_class )
|
||||
#endif
|
||||
|
||||
#ifdef FT_USE_CFF
|
||||
FT_USE_MODULE( FT_Driver_ClassRec, cff_driver_class )
|
||||
#endif
|
||||
|
||||
#ifdef FT_USE_T1CID
|
||||
FT_USE_MODULE( FT_Driver_ClassRec, t1cid_driver_class )
|
||||
#endif
|
||||
|
||||
#ifdef FT_USE_PFR
|
||||
FT_USE_MODULE( FT_Driver_ClassRec, pfr_driver_class )
|
||||
#endif
|
||||
|
||||
#ifdef FT_USE_T42
|
||||
FT_USE_MODULE( FT_Driver_ClassRec, t42_driver_class )
|
||||
#endif
|
||||
|
||||
#ifdef FT_USE_WINFNT
|
||||
FT_USE_MODULE( FT_Driver_ClassRec, winfnt_driver_class )
|
||||
#endif
|
||||
|
||||
#ifdef FT_USE_PCF
|
||||
FT_USE_MODULE( FT_Driver_ClassRec, pcf_driver_class )
|
||||
#endif
|
||||
|
||||
#ifdef FT_USE_PSAUX
|
||||
FT_USE_MODULE( FT_Module_Class, psaux_module_class )
|
||||
#endif
|
||||
|
||||
#ifdef FT_USE_PSNAMES
|
||||
FT_USE_MODULE( FT_Module_Class, psnames_module_class )
|
||||
#endif
|
||||
|
||||
#ifdef FT_USE_PSHINT
|
||||
FT_USE_MODULE( FT_Module_Class, pshinter_module_class )
|
||||
#endif
|
||||
|
||||
#ifdef FT_USE_RASTER
|
||||
FT_USE_MODULE( FT_Renderer_Class, ft_raster1_renderer_class )
|
||||
#endif
|
||||
|
||||
#ifdef FT_USE_SFNT
|
||||
FT_USE_MODULE( FT_Module_Class, sfnt_module_class )
|
||||
#endif
|
||||
|
||||
#ifdef FT_USE_SMOOTH
|
||||
FT_USE_MODULE( FT_Renderer_Class, ft_smooth_renderer_class )
|
||||
FT_USE_MODULE( FT_Renderer_Class, ft_smooth_lcd_renderer_class )
|
||||
FT_USE_MODULE( FT_Renderer_Class, ft_smooth_lcdv_renderer_class )
|
||||
#endif
|
||||
|
||||
#ifdef FT_USE_OTV
|
||||
FT_USE_MODULE( FT_Module_Class, otv_module_class )
|
||||
#endif
|
||||
|
||||
#ifdef FT_USE_BDF
|
||||
FT_USE_MODULE( FT_Driver_ClassRec, bdf_driver_class )
|
||||
#endif
|
||||
|
||||
#ifdef FT_USE_GXV
|
||||
FT_USE_MODULE( FT_Module_Class, gxv_module_class )
|
||||
#endif
|
||||
|
||||
/*
|
||||
Local Variables:
|
||||
coding: latin-1
|
||||
End:
|
||||
*/
|
||||
299
modules/freetype2/builds/amiga/makefile
Normal file
299
modules/freetype2/builds/amiga/makefile
Normal file
|
|
@ -0,0 +1,299 @@
|
|||
#
|
||||
# Makefile for FreeType2 link library using ppc-morphos-gcc-2.95.3-bin.tgz
|
||||
# (gcc 2.95.3 hosted on 68k-Amiga producing MorphOS-PPC-binaries from
|
||||
# http://www.morphos.de)
|
||||
#
|
||||
|
||||
|
||||
# Copyright 2005-2016 by
|
||||
# Werner Lemberg and Detlef Würkner.
|
||||
#
|
||||
# This file is part of the FreeType project, and may only be used, modified,
|
||||
# and distributed under the terms of the FreeType project license,
|
||||
# LICENSE.TXT. By continuing to use, modify, or distribute this file you
|
||||
# indicate that you have read the license and understand and accept it
|
||||
# fully.
|
||||
|
||||
|
||||
#
|
||||
# to build from the builds/amiga directory call
|
||||
#
|
||||
# make assign
|
||||
# make
|
||||
#
|
||||
# Your programs source code should start with this
|
||||
# (uncomment the parts you do not need to keep the program small):
|
||||
# ---8<---
|
||||
#define FT_USE_AUTOFIT // autofitter
|
||||
#define FT_USE_RASTER // monochrome rasterizer
|
||||
#define FT_USE_SMOOTH // anti-aliasing rasterizer
|
||||
#define FT_USE_TT // truetype font driver
|
||||
#define FT_USE_T1 // type1 font driver
|
||||
#define FT_USE_T42 // type42 font driver
|
||||
#define FT_USE_T1CID // cid-keyed type1 font driver
|
||||
#define FT_USE_CFF // opentype font driver
|
||||
#define FT_USE_BDF // bdf bitmap font driver
|
||||
#define FT_USE_PCF // pcf bitmap font driver
|
||||
#define FT_USE_PFR // pfr font driver
|
||||
#define FT_USE_WINFNT // windows .fnt|.fon bitmap font driver
|
||||
#define FT_USE_OTV // opentype validator
|
||||
#define FT_USE_GXV // truetype gx validator
|
||||
#include "FT:src/base/ftinit.c"
|
||||
# ---8<---
|
||||
#
|
||||
# link your programs with libft2_ppc.a and either ftsystem.ppc.o or ftsystempure.ppc.o
|
||||
# (and either ftdebug.ppc.o or ftdebugpure.ppc.o if you enabled FT_DEBUG_LEVEL_ERROR or
|
||||
# FT_DEBUG_LEVEL_TRACE in include/freetype/config/ftoption.h).
|
||||
|
||||
all: libft2_ppc.a ftsystem.ppc.o ftsystempure.ppc.o
|
||||
|
||||
assign:
|
||||
assign FT: //
|
||||
|
||||
FTSRC = /FT/src
|
||||
|
||||
CC = ppc-morphos-gcc
|
||||
AR = ppc-morphos-ar rc
|
||||
RANLIB = ppc-morphos-ranlib
|
||||
LD = ppc-morphos-ld
|
||||
CFLAGS = -DFT2_BUILD_LIBRARY -O2 -I/emu/emulinclude/includegcc -I/emu/include -Iinclude -I$(FTSRC) -I/FT/include
|
||||
|
||||
#
|
||||
# FreeType2 library base
|
||||
#
|
||||
ftbase.ppc.o: $(FTSRC)/base/ftbase.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
ftinit.ppc.o: $(FTSRC)/base/ftinit.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
ftsystem.ppc.o: $(FTSRC)/base/ftsystem.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
# pure version for use in run-time library etc
|
||||
ftsystempure.ppc.o: src/base/ftsystem.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
ftdebug.ppc.o: $(FTSRC)/base/ftdebug.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
# pure version for use in run-time library etc
|
||||
ftdebugpure.ppc.o: src/base/ftdebug.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
#
|
||||
# FreeType2 library base extensions
|
||||
#
|
||||
ftbbox.ppc.o: $(FTSRC)/base/ftbbox.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
ftbdf.ppc.o: $(FTSRC)/base/ftbdf.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
ftbitmap.ppc.o: $(FTSRC)/base/ftbitmap.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
ftcid.ppc.o: $(FTSRC)/base/ftcid.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
ftfntfmt.ppc.o: $(FTSRC)/base/ftfntfmt.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
ftfstype.ppc.o: $(FTSRC)/base/ftfstype.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
ftgasp.ppc.o: $(FTSRC)/base/ftgasp.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
ftglyph.ppc.o: $(FTSRC)/base/ftglyph.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
ftgxval.ppc.o: $(FTSRC)/base/ftgxval.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
ftlcdfil.ppc.o: $(FTSRC)/base/ftlcdfil.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
ftmm.ppc.o: $(FTSRC)/base/ftmm.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
ftotval.ppc.o: $(FTSRC)/base/ftotval.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
ftpatent.ppc.o: $(FTSRC)/base/ftpatent.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
ftpfr.ppc.o: $(FTSRC)/base/ftpfr.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
ftstroke.ppc.o: $(FTSRC)/base/ftstroke.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
ftsynth.ppc.o: $(FTSRC)/base/ftsynth.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
fttype1.ppc.o: $(FTSRC)/base/fttype1.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
ftwinfnt.ppc.o: $(FTSRC)/base/ftwinfnt.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
#
|
||||
# FreeType2 library autofitting module
|
||||
#
|
||||
autofit.ppc.o: $(FTSRC)/autofit/autofit.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
#
|
||||
# FreeType2 library postscript hinting module
|
||||
#
|
||||
pshinter.ppc.o: $(FTSRC)/pshinter/pshinter.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
#
|
||||
# FreeType2 library PS support module
|
||||
#
|
||||
psaux.ppc.o: $(FTSRC)/psaux/psaux.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
#
|
||||
# FreeType2 library PS glyph names module
|
||||
#
|
||||
psnames.ppc.o: $(FTSRC)/psnames/psnames.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
#
|
||||
# FreeType2 library monochrome raster module
|
||||
#
|
||||
raster.ppc.o: $(FTSRC)/raster/raster.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
#
|
||||
# FreeType2 library anti-aliasing raster module
|
||||
#
|
||||
smooth.ppc.o: $(FTSRC)/smooth/smooth.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
#
|
||||
# FreeType2 library 'sfnt' module
|
||||
#
|
||||
sfnt.ppc.o: $(FTSRC)/sfnt/sfnt.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
#
|
||||
# FreeType2 library glyph and image caching system
|
||||
#
|
||||
ftcache.ppc.o: $(FTSRC)/cache/ftcache.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
#
|
||||
# FreeType2 library OpenType font driver
|
||||
#
|
||||
cff.ppc.o: $(FTSRC)/cff/cff.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
#
|
||||
# FreeType2 library TrueType font driver
|
||||
#
|
||||
truetype.ppc.o: $(FTSRC)/truetype/truetype.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
#
|
||||
# FreeType2 library Type1 font driver
|
||||
#
|
||||
type1.ppc.o: $(FTSRC)/type1/type1.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
#
|
||||
# FreeType2 library Type42 font driver
|
||||
#
|
||||
type42.ppc.o: $(FTSRC)/type42/type42.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
#
|
||||
# FreeType2 library CID-keyed Type1 font driver
|
||||
#
|
||||
type1cid.ppc.o: $(FTSRC)/cid/type1cid.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
#
|
||||
# FreeType2 library BDF bitmap font driver
|
||||
#
|
||||
bdf.ppc.o: $(FTSRC)/bdf/bdf.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
#
|
||||
# FreeType2 library PCF bitmap font driver
|
||||
#
|
||||
pcf.ppc.o: $(FTSRC)/pcf/pcf.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
#
|
||||
# FreeType2 library gzip support for compressed PCF bitmap fonts
|
||||
#
|
||||
gzip.ppc.o: $(FTSRC)/gzip/ftgzip.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
# FreeType2 library bzip2 support for compressed PCF bitmap fonts
|
||||
#
|
||||
bzip2.ppc.o: $(FTSRC)/bzip2/ftbzip2.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
#
|
||||
# FreeType2 library compress support for compressed PCF bitmap fonts
|
||||
#
|
||||
lzw.ppc.o: $(FTSRC)/lzw/ftlzw.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
#
|
||||
# FreeType2 library PFR font driver
|
||||
#
|
||||
pfr.ppc.o: $(FTSRC)/pfr/pfr.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
#
|
||||
# FreeType2 library Windows FNT/FON bitmap font driver
|
||||
#
|
||||
winfnt.ppc.o: $(FTSRC)/winfonts/winfnt.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
#
|
||||
# FreeType2 library TrueTypeGX Validator
|
||||
#
|
||||
gxvalid.ppc.o: $(FTSRC)/gxvalid/gxvalid.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
#
|
||||
# FreeType2 library OpenType validator
|
||||
#
|
||||
otvalid.ppc.o: $(FTSRC)/otvalid/otvalid.c
|
||||
$(CC) -c $(CFLAGS) -o $@ $<
|
||||
|
||||
BASEPPC = ftbase.ppc.o ftbbox.ppc.o ftbdf.ppc.o ftbitmap.ppc.o ftcid.ppc.o \
|
||||
ftfntfmt.ppc.oftfstype.ppc.o ftgasp.ppc.o ftglyph.ppc.o \
|
||||
ftgxval.ppc.o ftlcdfil.ppc.o ftmm.ppc.o ftotval.ppc.o \
|
||||
ftpatent.ppc.o ftpfr.ppc.o ftstroke.ppc.o ftsynth.ppc.o \
|
||||
fttype1.ppc.o ftwinfnt.ppc.o
|
||||
|
||||
DEBUGPPC = ftdebug.ppc.o ftdebugpure.ppc.o
|
||||
|
||||
AFITPPC = autofit.ppc.o
|
||||
|
||||
GXVPPC = gxvalid.ppc.o
|
||||
|
||||
OTVPPC = otvalid.ppc.o
|
||||
|
||||
PSPPC = psaux.ppc.o psnames.ppc.o pshinter.ppc.o
|
||||
|
||||
RASTERPPC = raster.ppc.o smooth.ppc.o
|
||||
|
||||
FONTDPPC = cff.ppc.o type1.ppc.o type42.ppc.o type1cid.ppc.o truetype.ppc.o\
|
||||
bdf.ppc.o pcf.ppc.o pfr.ppc.o winfnt.ppc.o
|
||||
|
||||
libft2_ppc.a: $(BASEPPC) $(AFITPPC) $(GXVPPC) $(OTVPPC) $(PSPPC) $(RASTERPPC) sfnt.ppc.o ftcache.ppc.o $(FONTDPPC) gzip.ppc.o bzip2.ppc.o lzw.ppc.o
|
||||
$(AR) $@ $(BASEPPC) $(AFITPPC) $(GXVPPC) $(OTVPPC) $(PSPPC) $(RASTERPPC) sfnt.ppc.o ftcache.ppc.o $(FONTDPPC) gzip.ppc.o bzip2.ppc.o lzw.ppc.o
|
||||
-@ ($(RANLIB) $@ || true) >/dev/null 2>&1
|
||||
|
||||
#Local Variables:
|
||||
#coding: latin-1
|
||||
#End:
|
||||
303
modules/freetype2/builds/amiga/makefile.os4
Normal file
303
modules/freetype2/builds/amiga/makefile.os4
Normal file
|
|
@ -0,0 +1,303 @@
|
|||
#
|
||||
# Makefile for FreeType2 link library using gcc 4.0.3 from the
|
||||
# AmigaOS4 SDK
|
||||
#
|
||||
|
||||
|
||||
# Copyright 2005-2016 by
|
||||
# Werner Lemberg and Detlef Würkner.
|
||||
#
|
||||
# This file is part of the FreeType project, and may only be used, modified,
|
||||
# and distributed under the terms of the FreeType project license,
|
||||
# LICENSE.TXT. By continuing to use, modify, or distribute this file you
|
||||
# indicate that you have read the license and understand and accept it
|
||||
# fully.
|
||||
|
||||
|
||||
# to build from the builds/amiga directory call
|
||||
#
|
||||
# make -f makefile.os4
|
||||
#
|
||||
# Your programs source code should start with this
|
||||
# (uncomment the parts you do not need to keep the program small):
|
||||
# ---8<---
|
||||
#define FT_USE_AUTOFIT // autofitter
|
||||
#define FT_USE_RASTER // monochrome rasterizer
|
||||
#define FT_USE_SMOOTH // anti-aliasing rasterizer
|
||||
#define FT_USE_TT // truetype font driver
|
||||
#define FT_USE_T1 // type1 font driver
|
||||
#define FT_USE_T42 // type42 font driver
|
||||
#define FT_USE_T1CID // cid-keyed type1 font driver
|
||||
#define FT_USE_CFF // opentype font driver
|
||||
#define FT_USE_BDF // bdf bitmap font driver
|
||||
#define FT_USE_PCF // pcf bitmap font driver
|
||||
#define FT_USE_PFR // pfr font driver
|
||||
#define FT_USE_WINFNT // windows .fnt|.fon bitmap font driver
|
||||
#define FT_USE_OTV // opentype validator
|
||||
#define FT_USE_GXV // truetype gx validator
|
||||
#include "FT:src/base/ftinit.c"
|
||||
# ---8<---
|
||||
#
|
||||
# link your programs with libft2_ppc.a and either ftsystem.ppc.o or ftsystempure.ppc.o
|
||||
# (and either ftdebug.ppc.o or ftdebugpure.ppc.o if you enabled FT_DEBUG_LEVEL_ERROR or
|
||||
# FT_DEBUG_LEVEL_TRACE in include/freetype/config/ftoption.h).
|
||||
|
||||
all: assign libft2_ppc.a ftsystem.ppc.o ftsystempure.ppc.o
|
||||
|
||||
assign:
|
||||
assign FT: //
|
||||
|
||||
CC = ppc-amigaos-gcc
|
||||
AR = ppc-amigaos-ar
|
||||
RANLIB = ppc-amigaos-ranlib
|
||||
|
||||
DIRFLAGS = -Iinclude -I/FT/src -I/FT/include -I/SDK/include
|
||||
|
||||
WARNINGS = -Wall -W -Wundef -Wpointer-arith -Wbad-function-cast \
|
||||
-Waggregate-return -Wwrite-strings -Wshadow
|
||||
|
||||
OPTIONS = -DFT2_BUILD_LIBRARY -DNDEBUG -fno-builtin
|
||||
OPTIMIZE = -O2 -fomit-frame-pointer -fstrength-reduce -finline-functions
|
||||
|
||||
CFLAGS = -mcrt=clib2 $(DIRFLAGS) $(WARNINGS) $(FT2FLAGS) $(OPTIONS) $(OPTIMIZE)
|
||||
|
||||
#
|
||||
# FreeType2 library base
|
||||
#
|
||||
ftbase.ppc.o: FT:src/base/ftbase.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/base/ftbase.c
|
||||
|
||||
ftinit.ppc.o: FT:src/base/ftinit.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/base/ftinit.c
|
||||
|
||||
ftsystem.ppc.o: FT:src/base/ftsystem.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/base/ftsystem.c
|
||||
|
||||
# pure version for use in run-time library etc
|
||||
ftsystempure.ppc.o: src/base/ftsystem.c
|
||||
$(CC) -c $(CFLAGS) -o $@ src/base/ftsystem.c
|
||||
|
||||
#
|
||||
# FreeType2 library base extensions
|
||||
#
|
||||
ftbbox.ppc.o: FT:src/base/ftbbox.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/base/ftbbox.c
|
||||
|
||||
ftbdf.ppc.o: FT:src/base/ftbdf.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/base/ftbdf.c
|
||||
|
||||
ftbitmap.ppc.o: FT:src/base/ftbitmap.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/base/ftbitmap.c
|
||||
|
||||
ftcid.ppc.o: FT:src/base/ftcid.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/base/ftcid.c
|
||||
|
||||
ftdebug.ppc.o: FT:src/base/ftdebug.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/base/ftdebug.c
|
||||
|
||||
# pure version for use in run-time library etc
|
||||
ftdebugpure.ppc.o: src/base/ftdebug.c
|
||||
$(CC) -c $(CFLAGS) -o $@ src/base/ftdebug.c
|
||||
|
||||
ftfntfmt.ppc.o: FT:src/base/ftfntfmt.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/base/ftfntfmt.c
|
||||
|
||||
ftfstype.ppc.o: FT:src/base/ftfstype.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/base/ftfstype.c
|
||||
|
||||
ftgasp.ppc.o: FT:src/base/ftgasp.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/base/ftgasp.c
|
||||
|
||||
ftglyph.ppc.o: FT:src/base/ftglyph.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/base/ftglyph.c
|
||||
|
||||
ftgxval.ppc.o: FT:src/base/ftgxval.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/base/ftgxval.c
|
||||
|
||||
ftlcdfil.ppc.o: FT:src/base/ftlcdfil.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/base/ftlcdfil.c
|
||||
|
||||
ftmm.ppc.o: FT:src/base/ftmm.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/base/ftmm.c
|
||||
|
||||
ftotval.ppc.o: FT:src/base/ftotval.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/base/ftotval.c
|
||||
|
||||
ftpatent.ppc.o: FT:src/base/ftpatent.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/base/ftpatent.c
|
||||
|
||||
ftpfr.ppc.o: FT:src/base/ftpfr.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/base/ftpfr.c
|
||||
|
||||
ftstroke.ppc.o: FT:src/base/ftstroke.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/base/ftstroke.c
|
||||
|
||||
ftsynth.ppc.o: FT:src/base/ftsynth.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/base/ftsynth.c
|
||||
|
||||
fttype1.ppc.o: FT:src/base/fttype1.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/base/fttype1.c
|
||||
|
||||
ftwinfnt.ppc.o: FT:src/base/ftwinfnt.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/base/ftwinfnt.c
|
||||
|
||||
#
|
||||
# FreeType2 library autofitting module
|
||||
#
|
||||
autofit.ppc.o: FT:src/autofit/autofit.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/autofit/autofit.c
|
||||
|
||||
#
|
||||
# FreeType2 library postscript hinting module
|
||||
#
|
||||
pshinter.ppc.o: FT:src/pshinter/pshinter.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/pshinter/pshinter.c
|
||||
|
||||
#
|
||||
# FreeType2 library PS support module
|
||||
#
|
||||
psaux.ppc.o: FT:src/psaux/psaux.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/psaux/psaux.c
|
||||
|
||||
#
|
||||
# FreeType2 library PS glyph names module
|
||||
#
|
||||
psnames.ppc.o: FT:src/psnames/psnames.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/psnames/psnames.c
|
||||
|
||||
#
|
||||
# FreeType2 library monochrome raster module
|
||||
#
|
||||
raster.ppc.o: FT:src/raster/raster.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/raster/raster.c
|
||||
|
||||
#
|
||||
# FreeType2 library anti-aliasing raster module
|
||||
#
|
||||
smooth.ppc.o: FT:src/smooth/smooth.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/smooth/smooth.c
|
||||
|
||||
#
|
||||
# FreeType2 library 'sfnt' module
|
||||
#
|
||||
sfnt.ppc.o: FT:src/sfnt/sfnt.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/sfnt/sfnt.c
|
||||
|
||||
#
|
||||
# FreeType2 library glyph and image caching system
|
||||
#
|
||||
ftcache.ppc.o: FT:src/cache/ftcache.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/cache/ftcache.c
|
||||
|
||||
#
|
||||
# FreeType2 library OpenType font driver
|
||||
#
|
||||
cff.ppc.o: FT:src/cff/cff.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/cff/cff.c
|
||||
|
||||
#
|
||||
# FreeType2 library TrueType font driver
|
||||
#
|
||||
truetype.ppc.o: FT:src/truetype/truetype.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/truetype/truetype.c
|
||||
|
||||
#
|
||||
# FreeType2 library Type1 font driver
|
||||
#
|
||||
type1.ppc.o: FT:src/type1/type1.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/type1/type1.c
|
||||
|
||||
#
|
||||
# FreeType2 library Type42 font driver
|
||||
#
|
||||
type42.ppc.o: FT:src/type42/type42.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/type42/type42.c
|
||||
|
||||
#
|
||||
# FreeType2 library CID-keyed Type1 font driver
|
||||
#
|
||||
type1cid.ppc.o: FT:src/cid/type1cid.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/cid/type1cid.c
|
||||
|
||||
#
|
||||
# FreeType2 library BDF bitmap font driver
|
||||
#
|
||||
bdf.ppc.o: FT:src/bdf/bdf.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/bdf/bdf.c
|
||||
|
||||
#
|
||||
# FreeType2 library PCF bitmap font driver
|
||||
#
|
||||
pcf.ppc.o: FT:src/pcf/pcf.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/pcf/pcf.c
|
||||
|
||||
#
|
||||
# FreeType2 library gzip support for compressed PCF bitmap fonts
|
||||
#
|
||||
gzip.ppc.o: FT:src/gzip/ftgzip.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/gzip/ftgzip.c
|
||||
|
||||
#
|
||||
# FreeType2 library bzip2 support for compressed PCF bitmap fonts
|
||||
#
|
||||
bzip2.ppc.o: FT:src/bzip2/ftbzip2.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/bzip2/ftbzip2.c
|
||||
|
||||
#
|
||||
# FreeType2 library compress support for compressed PCF bitmap fonts
|
||||
#
|
||||
lzw.ppc.o: FT:src/lzw/ftlzw.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/lzw/ftlzw.c
|
||||
|
||||
#
|
||||
# FreeType2 library PFR font driver
|
||||
#
|
||||
pfr.ppc.o: FT:src/pfr/pfr.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/pfr/pfr.c
|
||||
|
||||
#
|
||||
# FreeType2 library Windows FNT/FON bitmap font driver
|
||||
#
|
||||
winfnt.ppc.o: FT:src/winfonts/winfnt.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/winfonts/winfnt.c
|
||||
|
||||
#
|
||||
# FreeType2 library TrueTypeGX Validator
|
||||
#
|
||||
gxvalid.ppc.o: FT:src/gxvalid/gxvalid.c
|
||||
$(CC) -c $(CFLAGS) -Wno-aggregate-return -o $@ /FT/src/gxvalid/gxvalid.c
|
||||
|
||||
#
|
||||
# FreeType2 library OpenType validator
|
||||
#
|
||||
otvalid.ppc.o: FT:src/otvalid/otvalid.c
|
||||
$(CC) -c $(CFLAGS) -o $@ /FT/src/otvalid/otvalid.c
|
||||
|
||||
BASE = ftbase.ppc.o ftbbox.ppc.o ftbdf.ppc.o ftbitmap.ppc.o ftcid.ppc.o \
|
||||
ftfntfmt.ppc.o ftfstype.ppc.o ftgasp.ppc.o ftglyph.ppc.o \
|
||||
ftgxval.ppc.o ftlcdfil.ppc.o ftmm.ppc.o ftotval.ppc.o \
|
||||
ftpatent.ppc.o ftpfr.ppc.o ftstroke.ppc.o ftsynth.ppc.o \
|
||||
fttype1.ppc.o ftwinfnt.ppc.o
|
||||
|
||||
DEBUG = ftdebug.ppc.o ftdebugpure.ppc.o
|
||||
|
||||
AFIT = autofit.ppc.o
|
||||
|
||||
GXV = gxvalid.ppc.o
|
||||
|
||||
OTV = otvalid.ppc.o
|
||||
|
||||
PS = psaux.ppc.o psnames.ppc.o pshinter.ppc.o
|
||||
|
||||
RASTER = raster.ppc.o smooth.ppc.o
|
||||
|
||||
FONTD = cff.ppc.o type1.ppc.o type42.ppc.o type1cid.ppc.o truetype.ppc.o\
|
||||
bdf.ppc.o pcf.ppc.o pfr.ppc.o winfnt.ppc.o
|
||||
|
||||
libft2_ppc.a: $(BASE) $(AFIT) $(GXV) $(OTV) $(PS) $(RASTER) sfnt.ppc.o ftcache.ppc.o $(FONTD) gzip.ppc.o lzw.ppc.o
|
||||
$(AR) r $@ $(BASE) $(AFIT) $(GXV) $(OTV) $(PS) $(RASTER) sfnt.ppc.o ftcache.ppc.o $(FONTD) gzip.ppc.o lzw.ppc.o
|
||||
$(RANLIB) $@
|
||||
|
||||
#Local Variables:
|
||||
#coding: latin-1
|
||||
#End:
|
||||
303
modules/freetype2/builds/amiga/smakefile
Normal file
303
modules/freetype2/builds/amiga/smakefile
Normal file
|
|
@ -0,0 +1,303 @@
|
|||
#
|
||||
# Makefile for FreeType2 link library using Amiga SAS/C 6.58
|
||||
#
|
||||
|
||||
|
||||
# Copyright 2005-2016 by
|
||||
# Werner Lemberg and Detlef Würkner.
|
||||
#
|
||||
# This file is part of the FreeType project, and may only be used, modified,
|
||||
# and distributed under the terms of the FreeType project license,
|
||||
# LICENSE.TXT. By continuing to use, modify, or distribute this file you
|
||||
# indicate that you have read the license and understand and accept it
|
||||
# fully.
|
||||
|
||||
|
||||
# to build from the builds/amiga directory call
|
||||
#
|
||||
# smake assign
|
||||
# smake
|
||||
#
|
||||
# Your programs source code should start with this
|
||||
# (uncomment the parts you do not need to keep the program small):
|
||||
# ---8<---
|
||||
#define FT_USE_AUTOFIT // autofitter
|
||||
#define FT_USE_RASTER // monochrome rasterizer
|
||||
#define FT_USE_SMOOTH // anti-aliasing rasterizer
|
||||
#define FT_USE_TT // truetype font driver
|
||||
#define FT_USE_T1 // type1 font driver
|
||||
#define FT_USE_T42 // type42 font driver
|
||||
#define FT_USE_T1CID // cid-keyed type1 font driver
|
||||
#define FT_USE_CFF // opentype font driver
|
||||
#define FT_USE_BDF // bdf bitmap font driver
|
||||
#define FT_USE_PCF // pcf bitmap font driver
|
||||
#define FT_USE_PFR // pfr font driver
|
||||
#define FT_USE_WINFNT // windows .fnt|.fon bitmap font driver
|
||||
#define FT_USE_OTV // opentype validator
|
||||
#define FT_USE_GXV // truetype gx validator
|
||||
#include "FT:src/base/ftinit.c"
|
||||
# ---8<---
|
||||
#
|
||||
# link your programs with ft2_680x0.lib and either ftsystem.o or ftsystempure.o
|
||||
# (and either ftdebug.o or ftdebugpure.o if you enabled FT_DEBUG_LEVEL_ERROR or
|
||||
# FT_DEBUG_LEVEL_TRACE in include/freetype/config/ftoption.h).
|
||||
|
||||
OBJBASE = ftbase.o ftbbox.o ftbdf.o ftbitmap.o ftcid.o ftfntfmt.o ftfstype.o \
|
||||
ftgasp.o ftglyph.o ftgxval.o ftlcdfil.o ftmm.o ftotval.o \
|
||||
ftpatent.o ftpfr.o ftstroke.o ftsynth.o fttype1.o ftwinfnt.o
|
||||
|
||||
OBJSYSTEM = ftsystem.o ftsystempure.o
|
||||
|
||||
OBJDEBUG = ftdebug.o ftdebugpure.o
|
||||
|
||||
OBJAFIT = autofit.o
|
||||
|
||||
OBJGXV = gxvalid.o
|
||||
|
||||
OBJOTV = otvalid.o
|
||||
|
||||
OBJPS = psaux.o psnames.o pshinter.o
|
||||
|
||||
OBJRASTER = raster.o smooth.o
|
||||
|
||||
OBJSFNT = sfnt.o
|
||||
|
||||
OBJCACHE = ftcache.o
|
||||
|
||||
OBJFONTD = cff.o type1.o type42.o type1cid.o\
|
||||
truetype.o winfnt.o bdf.o pcf.o pfr.o
|
||||
|
||||
CORE = FT:src/
|
||||
|
||||
CPU = 68000
|
||||
#CPU = 68020
|
||||
#CPU = 68030
|
||||
#CPU = 68040
|
||||
#CPU = 68060
|
||||
|
||||
OPTIMIZER = optinlocal
|
||||
|
||||
SCFLAGS = optimize opttime optsched strmerge data=faronly idlen=50 cpu=$(CPU)\
|
||||
idir=include/ idir=$(CORE) idir=FT:include/ nostackcheck nochkabort\
|
||||
noicons ignore=79,85,110,306 parameters=both define=FT2_BUILD_LIBRARY
|
||||
|
||||
LIB = ft2_$(CPU).lib
|
||||
|
||||
# sample linker options
|
||||
OPTS = link lib=$(LIB),lib:sc.lib,lib:amiga.lib,lib:debug.lib\
|
||||
smallcode smalldata noicons utillib
|
||||
|
||||
# sample program entry
|
||||
#myprog: myprog.c ftsystem.o $(LIB)
|
||||
# sc $< programname=$@ ftsystem.o $(SCFLAGS) $(OPTS)
|
||||
|
||||
all: $(LIB) $(OBJSYSTEM) $(OBJDEBUG)
|
||||
|
||||
assign:
|
||||
assign FT: //
|
||||
|
||||
# uses separate object modules in lib to make for easier debugging
|
||||
# also, can make smaller programs if entire engine is not used
|
||||
ft2_$(CPU).lib: $(OBJBASE) $(OBJAFIT) $(OBJOTV) $(OBJPS) $(OBJRASTER) $(OBJSFNT) $(OBJCACHE) $(OBJFONTD) lzw.o gzip.o bzip2.o
|
||||
oml $@ r $(OBJBASE) $(OBJAFIT) $(OBJOTV) $(OBJPS) $(OBJRASTER) $(OBJSFNT) $(OBJCACHE) $(OBJFONTD) lzw.o gzip.o bzip2.o
|
||||
|
||||
clean:
|
||||
-delete \#?.o
|
||||
|
||||
realclean: clean
|
||||
-delete ft2$(CPU).lib
|
||||
|
||||
#
|
||||
# freetype library base
|
||||
#
|
||||
ftbase.o: $(CORE)base/ftbase.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
ftinit.o: $(CORE)base/ftinit.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
ftsystem.o: $(CORE)base/ftsystem.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
ftsystempure.o: src/base/ftsystem.c ## pure version for use in run-time library etc
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
ftdebug.o: $(CORE)base/ftdebug.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
ftdebugpure.o: src/base/ftdebug.c ## pure version for use in run-time library etc
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
#
|
||||
# freetype library base extensions
|
||||
#
|
||||
ftbbox.o: $(CORE)base/ftbbox.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
ftbdf.o: $(CORE)base/ftbdf.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
ftbitmap.o: $(CORE)base/ftbitmap.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
ftcid.o: $(CORE)base/ftcid.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
ftfntfmt.o: $(CORE)base/ftfntfmt.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
ftfstype.o: $(CORE)base/ftfstype.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
ftgasp.o: $(CORE)base/ftgasp.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
ftglyph.o: $(CORE)base/ftglyph.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
ftgxval.o: $(CORE)base/ftgxval.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
ftlcdfil.o: $(CORE)base/ftlcdfil.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
ftmm.o: $(CORE)base/ftmm.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
ftotval.o: $(CORE)base/ftotval.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
ftpatent.o: $(CORE)base/ftpatent.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
ftpfr.o: $(CORE)base/ftpfr.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
ftstroke.o: $(CORE)base/ftstroke.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
ftsynth.o: $(CORE)base/ftsynth.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
fttype1.o: $(CORE)base/fttype1.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
ftwinfnt.o: $(CORE)base/ftwinfnt.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
|
||||
#
|
||||
# freetype library autofitter module
|
||||
#
|
||||
autofit.o: $(CORE)autofit/autofit.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
|
||||
#
|
||||
# freetype library PS hinting module
|
||||
#
|
||||
pshinter.o: $(CORE)pshinter/pshinter.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
#
|
||||
# freetype library PS support module
|
||||
#
|
||||
psaux.o: $(CORE)psaux/psaux.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
|
||||
#
|
||||
# freetype library PS glyph names module
|
||||
#
|
||||
psnames.o: $(CORE)psnames/psnames.c
|
||||
sc $(SCFLAGS) code=far objname=$@ $<
|
||||
|
||||
#
|
||||
# freetype library monochrome raster module
|
||||
#
|
||||
raster.o: $(CORE)raster/raster.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
|
||||
#
|
||||
# freetype library anti-aliasing raster module
|
||||
#
|
||||
smooth.o: $(CORE)smooth/smooth.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
|
||||
#
|
||||
# freetype library 'sfnt' module
|
||||
#
|
||||
sfnt.o: $(CORE)sfnt/sfnt.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
|
||||
#
|
||||
# freetype library glyph and image caching system (still experimental)
|
||||
#
|
||||
ftcache.o: $(CORE)cache/ftcache.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
|
||||
#
|
||||
# freetype library OpenType font driver
|
||||
#
|
||||
cff.o: $(CORE)cff/cff.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
|
||||
#
|
||||
# freetype library TrueType font driver
|
||||
#
|
||||
truetype.o: $(CORE)truetype/truetype.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
|
||||
#
|
||||
# freetype library Type1 font driver
|
||||
#
|
||||
type1.o: $(CORE)type1/type1.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
|
||||
#
|
||||
# FreeType2 library Type42 font driver
|
||||
#
|
||||
type42.o: $(CORE)type42/type42.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
|
||||
#
|
||||
# freetype library CID-keyed Type1 font driver
|
||||
#
|
||||
type1cid.o: $(CORE)cid/type1cid.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
#
|
||||
# freetype library CID-keyed Type1 font driver extensions
|
||||
#
|
||||
#cidafm.o: $(CORE)cid/cidafm.c
|
||||
# sc $(SCFLAGS) objname=$@ $<
|
||||
|
||||
#
|
||||
# freetype library BDF bitmap font driver
|
||||
#
|
||||
bdf.o: $(CORE)bdf/bdf.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
|
||||
#
|
||||
# freetype library PCF bitmap font driver
|
||||
#
|
||||
pcf.o: $(CORE)pcf/pcf.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
|
||||
#
|
||||
# freetype library gzip support for compressed PCF bitmap fonts
|
||||
#
|
||||
gzip.o: $(CORE)gzip/ftgzip.c
|
||||
sc $(SCFLAGS) define FAR objname=$@ $<
|
||||
|
||||
#
|
||||
# freetype library bzip2 support for compressed PCF bitmap fonts
|
||||
#
|
||||
bzip2.o: $(CORE)bzip2/ftbzip2.c
|
||||
sc $(SCFLAGS) define FAR objname=$@ $<
|
||||
|
||||
#
|
||||
# freetype library compress support for compressed PCF bitmap fonts
|
||||
#
|
||||
lzw.o: $(CORE)lzw/ftlzw.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
|
||||
#
|
||||
# freetype library PFR font driver
|
||||
#
|
||||
pfr.o: $(CORE)pfr/pfr.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
|
||||
#
|
||||
# freetype library Windows FNT/FON bitmap font driver
|
||||
#
|
||||
winfnt.o: $(CORE)winfonts/winfnt.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
|
||||
#
|
||||
# freetype library TrueTypeGX validator
|
||||
#
|
||||
gxvalid.o: $(CORE)gxvalid/gxvalid.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
|
||||
#
|
||||
# freetype library OpenType validator
|
||||
#
|
||||
otvalid.o: $(CORE)otvalid/otvalid.c
|
||||
sc $(SCFLAGS) objname=$@ $<
|
||||
|
||||
#Local Variables:
|
||||
#coding: latin-1
|
||||
#End:
|
||||
297
modules/freetype2/builds/amiga/src/base/ftdebug.c
Normal file
297
modules/freetype2/builds/amiga/src/base/ftdebug.c
Normal file
|
|
@ -0,0 +1,297 @@
|
|||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftdebug.c */
|
||||
/* */
|
||||
/* Debugging and logging component for amiga (body). */
|
||||
/* */
|
||||
/* Copyright 1996-2016 by */
|
||||
/* David Turner, Robert Wilhelm, Werner Lemberg and Detlef Würkner. */
|
||||
/* */
|
||||
/* This file is part of the FreeType project, and may only be used, */
|
||||
/* modified, and distributed under the terms of the FreeType project */
|
||||
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
|
||||
/* this file you indicate that you have read the license and */
|
||||
/* understand and accept it fully. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* This component contains various macros and functions used to ease the */
|
||||
/* debugging of the FreeType engine. Its main purpose is in assertion */
|
||||
/* checking, tracing, and error detection. */
|
||||
/* */
|
||||
/* There are now three debugging modes: */
|
||||
/* */
|
||||
/* - trace mode */
|
||||
/* */
|
||||
/* Error and trace messages are sent to the log file (which can be the */
|
||||
/* standard error output). */
|
||||
/* */
|
||||
/* - error mode */
|
||||
/* */
|
||||
/* Only error messages are generated. */
|
||||
/* */
|
||||
/* - release mode: */
|
||||
/* */
|
||||
/* No error message is sent or generated. The code is free from any */
|
||||
/* debugging parts. */
|
||||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
/*
|
||||
* Based on the default ftdebug.c,
|
||||
* replaced vprintf() with KVPrintF(),
|
||||
* commented out exit(),
|
||||
* replaced getenv() with GetVar().
|
||||
*/
|
||||
|
||||
#include <exec/types.h>
|
||||
#include <utility/tagitem.h>
|
||||
#include <dos/exall.h>
|
||||
#include <dos/var.h>
|
||||
#define __NOLIBBASE__
|
||||
#define __NOLOBALIFACE__
|
||||
#define __USE_INLINE__
|
||||
#include <proto/dos.h>
|
||||
#include <clib/debug_protos.h>
|
||||
|
||||
#ifndef __amigaos4__
|
||||
extern struct Library *DOSBase;
|
||||
#else
|
||||
extern struct DOSIFace *IDOS;
|
||||
#endif
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_FREETYPE_H
|
||||
#include FT_INTERNAL_DEBUG_H
|
||||
|
||||
|
||||
#if defined( FT_DEBUG_LEVEL_ERROR )
|
||||
|
||||
/* documentation is in ftdebug.h */
|
||||
|
||||
FT_BASE_DEF( void )
|
||||
FT_Message( const char* fmt,
|
||||
... )
|
||||
{
|
||||
va_list ap;
|
||||
|
||||
|
||||
va_start( ap, fmt );
|
||||
KVPrintF( fmt, ap );
|
||||
va_end( ap );
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftdebug.h */
|
||||
|
||||
FT_BASE_DEF( void )
|
||||
FT_Panic( const char* fmt,
|
||||
... )
|
||||
{
|
||||
va_list ap;
|
||||
|
||||
|
||||
va_start( ap, fmt );
|
||||
KVPrintF( fmt, ap );
|
||||
va_end( ap );
|
||||
|
||||
/* exit( EXIT_FAILURE ); */
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftdebug.h */
|
||||
|
||||
FT_BASE_DEF( int )
|
||||
FT_Throw( FT_Error error,
|
||||
int line,
|
||||
const char* file )
|
||||
{
|
||||
FT_UNUSED( error );
|
||||
FT_UNUSED( line );
|
||||
FT_UNUSED( file );
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif /* FT_DEBUG_LEVEL_ERROR */
|
||||
|
||||
|
||||
|
||||
#ifdef FT_DEBUG_LEVEL_TRACE
|
||||
|
||||
/* array of trace levels, initialized to 0 */
|
||||
int ft_trace_levels[trace_count];
|
||||
|
||||
|
||||
/* define array of trace toggle names */
|
||||
#define FT_TRACE_DEF( x ) #x ,
|
||||
|
||||
static const char* ft_trace_toggles[trace_count + 1] =
|
||||
{
|
||||
#include FT_INTERNAL_TRACE_H
|
||||
NULL
|
||||
};
|
||||
|
||||
#undef FT_TRACE_DEF
|
||||
|
||||
|
||||
/* documentation is in ftdebug.h */
|
||||
|
||||
FT_BASE_DEF( FT_Int )
|
||||
FT_Trace_Get_Count( void )
|
||||
{
|
||||
return trace_count;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftdebug.h */
|
||||
|
||||
FT_BASE_DEF( const char * )
|
||||
FT_Trace_Get_Name( FT_Int idx )
|
||||
{
|
||||
int max = FT_Trace_Get_Count();
|
||||
|
||||
|
||||
if ( idx < max )
|
||||
return ft_trace_toggles[idx];
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* Initialize the tracing sub-system. This is done by retrieving the */
|
||||
/* value of the `FT2_DEBUG' environment variable. It must be a list of */
|
||||
/* toggles, separated by spaces, `;', or `,'. Example: */
|
||||
/* */
|
||||
/* export FT2_DEBUG="any:3 memory:7 stream:5" */
|
||||
/* */
|
||||
/* This requests that all levels be set to 3, except the trace level for */
|
||||
/* the memory and stream components which are set to 7 and 5, */
|
||||
/* respectively. */
|
||||
/* */
|
||||
/* See the file `include/freetype/internal/fttrace.h' for details of the */
|
||||
/* available toggle names. */
|
||||
/* */
|
||||
/* The level must be between 0 and 7; 0 means quiet (except for serious */
|
||||
/* runtime errors), and 7 means _very_ verbose. */
|
||||
/* */
|
||||
FT_BASE_DEF( void )
|
||||
ft_debug_init( void )
|
||||
{
|
||||
/* const char* ft2_debug = getenv( "FT2_DEBUG" ); */
|
||||
char buf[256];
|
||||
const char* ft2_debug = &buf[0];
|
||||
|
||||
|
||||
/* if ( ft2_debug ) */
|
||||
if ( GetVar( "FT2_DEBUG", (STRPTR)ft2_debug, 256, LV_VAR ) > 0 )
|
||||
{
|
||||
const char* p = ft2_debug;
|
||||
const char* q;
|
||||
|
||||
|
||||
for ( ; *p; p++ )
|
||||
{
|
||||
/* skip leading whitespace and separators */
|
||||
if ( *p == ' ' || *p == '\t' || *p == ',' || *p == ';' || *p == '=' )
|
||||
continue;
|
||||
|
||||
/* read toggle name, followed by ':' */
|
||||
q = p;
|
||||
while ( *p && *p != ':' )
|
||||
p++;
|
||||
|
||||
if ( !*p )
|
||||
break;
|
||||
|
||||
if ( *p == ':' && p > q )
|
||||
{
|
||||
FT_Int n, i, len = (FT_Int)( p - q );
|
||||
FT_Int level = -1, found = -1;
|
||||
|
||||
|
||||
for ( n = 0; n < trace_count; n++ )
|
||||
{
|
||||
const char* toggle = ft_trace_toggles[n];
|
||||
|
||||
|
||||
for ( i = 0; i < len; i++ )
|
||||
{
|
||||
if ( toggle[i] != q[i] )
|
||||
break;
|
||||
}
|
||||
|
||||
if ( i == len && toggle[i] == 0 )
|
||||
{
|
||||
found = n;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* read level */
|
||||
p++;
|
||||
if ( *p )
|
||||
{
|
||||
level = *p - '0';
|
||||
if ( level < 0 || level > 7 )
|
||||
level = -1;
|
||||
}
|
||||
|
||||
if ( found >= 0 && level >= 0 )
|
||||
{
|
||||
if ( found == trace_any )
|
||||
{
|
||||
/* special case for `any' */
|
||||
for ( n = 0; n < trace_count; n++ )
|
||||
ft_trace_levels[n] = level;
|
||||
}
|
||||
else
|
||||
ft_trace_levels[found] = level;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#else /* !FT_DEBUG_LEVEL_TRACE */
|
||||
|
||||
|
||||
FT_BASE_DEF( void )
|
||||
ft_debug_init( void )
|
||||
{
|
||||
/* nothing */
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Int )
|
||||
FT_Trace_Get_Count( void )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( const char * )
|
||||
FT_Trace_Get_Name( FT_Int idx )
|
||||
{
|
||||
FT_UNUSED( idx );
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
#endif /* !FT_DEBUG_LEVEL_TRACE */
|
||||
|
||||
/*
|
||||
Local Variables:
|
||||
coding: latin-1
|
||||
End:
|
||||
*/
|
||||
/* END */
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Add a link
Reference in a new issue