mysql又加回来了

extern-libs/mysql/include/big_endian.h

@@ -0,0 +1,114 @@
+/* Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; version 2 of the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
+
+#include <string.h>
+
+/*
+  Data in big-endian format.
+*/
+static inline void float4store(uchar  *T, float  A)
+{ *(T)= ((uchar *) &A)[3];
+  *((T)+1)=(char) ((uchar *) &A)[2];
+  *((T)+2)=(char) ((uchar *) &A)[1];
+  *((T)+3)=(char) ((uchar *) &A)[0]; }
+
+static inline void float4get  (float  *V, const uchar *M)
+{ float def_temp;
+  ((uchar*) &def_temp)[0]=(M)[3];
+  ((uchar*) &def_temp)[1]=(M)[2];
+  ((uchar*) &def_temp)[2]=(M)[1];
+  ((uchar*) &def_temp)[3]=(M)[0];
+  (*V)=def_temp; }
+
+static inline void float8store(uchar  *T, double V)
+{ *(T)= ((uchar *) &V)[7];
+  *((T)+1)=(char) ((uchar *) &V)[6];
+  *((T)+2)=(char) ((uchar *) &V)[5];
+  *((T)+3)=(char) ((uchar *) &V)[4];
+  *((T)+4)=(char) ((uchar *) &V)[3];
+  *((T)+5)=(char) ((uchar *) &V)[2];
+  *((T)+6)=(char) ((uchar *) &V)[1];
+  *((T)+7)=(char) ((uchar *) &V)[0]; }
+
+static inline void float8get  (double *V, const uchar *M)
+{ double def_temp;
+  ((uchar*) &def_temp)[0]=(M)[7];                                 
+  ((uchar*) &def_temp)[1]=(M)[6];
+  ((uchar*) &def_temp)[2]=(M)[5];
+  ((uchar*) &def_temp)[3]=(M)[4];
+  ((uchar*) &def_temp)[4]=(M)[3];
+  ((uchar*) &def_temp)[5]=(M)[2];
+  ((uchar*) &def_temp)[6]=(M)[1];
+  ((uchar*) &def_temp)[7]=(M)[0];
+  (*V) = def_temp; }
+
+static inline void ushortget(uint16 *V, const uchar *pM)
+{ *V = (uint16) (((uint16) ((uchar) (pM)[1]))+
+                 ((uint16) ((uint16) (pM)[0]) << 8)); }
+static inline void shortget (int16  *V, const uchar *pM)
+{ *V = (short) (((short) ((uchar) (pM)[1]))+
+                ((short) ((short) (pM)[0]) << 8)); }
+static inline void longget  (int32  *V, const uchar *pM)
+{ int32 def_temp;
+  ((uchar*) &def_temp)[0]=(pM)[0];
+  ((uchar*) &def_temp)[1]=(pM)[1];
+  ((uchar*) &def_temp)[2]=(pM)[2];
+  ((uchar*) &def_temp)[3]=(pM)[3];
+  (*V)=def_temp; }
+static inline void ulongget (uint32 *V, const uchar *pM)
+{ uint32 def_temp;
+  ((uchar*) &def_temp)[0]=(pM)[0];
+  ((uchar*) &def_temp)[1]=(pM)[1];
+  ((uchar*) &def_temp)[2]=(pM)[2];
+  ((uchar*) &def_temp)[3]=(pM)[3];
+  (*V)=def_temp; }
+static inline void shortstore(uchar *T, int16 A)
+{ uint def_temp=(uint) (A) ;
+  *(((char*)T)+1)=(char)(def_temp);
+  *(((char*)T)+0)=(char)(def_temp >> 8); }
+static inline void longstore (uchar *T, int32 A)
+{ *(((char*)T)+3)=((A));
+  *(((char*)T)+2)=(((A) >> 8));
+  *(((char*)T)+1)=(((A) >> 16));
+  *(((char*)T)+0)=(((A) >> 24)); }
+
+static inline void floatget(float *V, const uchar *M)
+{
+  memcpy(V, (M), sizeof(float));
+}
+
+static inline void floatstore(uchar *T, float V)
+{
+  memcpy((T), (&V), sizeof(float));
+}
+
+static inline void doubleget(double *V, const uchar *M)
+{
+  memcpy(V, (M), sizeof(double));
+}
+
+static inline void doublestore(uchar *T, double V)
+{
+  memcpy((T), &V, sizeof(double));
+}
+
+static inline void longlongget(longlong *V, const uchar *M)
+{
+  memcpy(V, (M), sizeof(ulonglong));
+}
+static inline void longlongstore(uchar *T, longlong V)
+{
+  memcpy((T), &V, sizeof(ulonglong));
+}

extern-libs/mysql/include/byte_order_generic.h

@@ -0,0 +1,97 @@
+/* Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; version 2 of the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
+
+/*
+  Endianness-independent definitions for architectures other
+  than the x86 architecture.
+*/
+static inline int16 sint2korr(const uchar *A)
+{
+  return
+    (int16) (((int16) (A[0])) +
+             ((int16) (A[1]) << 8))
+    ;
+}
+
+static inline int32 sint4korr(const uchar *A)
+{
+  return
+    (int32) (((int32) (A[0])) +
+             (((int32) (A[1]) << 8)) +
+             (((int32) (A[2]) << 16)) +
+             (((int32) (A[3]) << 24)))
+    ;
+}
+
+static inline uint16 uint2korr(const uchar *A)
+{
+  return
+    (uint16) (((uint16) (A[0])) +
+              ((uint16) (A[1]) << 8))
+    ;
+}
+
+static inline uint32 uint4korr(const uchar *A)
+{
+  return
+    (uint32) (((uint32) (A[0])) +
+              (((uint32) (A[1])) << 8) +
+              (((uint32) (A[2])) << 16) +
+              (((uint32) (A[3])) << 24))
+    ;
+}
+
+static inline ulonglong uint8korr(const uchar *A)
+{
+  return
+    ((ulonglong)(((uint32) (A[0])) +
+                 (((uint32) (A[1])) << 8) +
+                 (((uint32) (A[2])) << 16) +
+                 (((uint32) (A[3])) << 24)) +
+     (((ulonglong) (((uint32) (A[4])) +
+                    (((uint32) (A[5])) << 8) +
+                    (((uint32) (A[6])) << 16) +
+                    (((uint32) (A[7])) << 24))) <<
+      32))
+    ;
+}
+
+static inline longlong  sint8korr(const uchar *A)
+{
+  return (longlong) uint8korr(A);
+}
+
+static inline void int2store(uchar *T, uint16 A)
+{
+  uint def_temp= A ;
+  *(T)=   (uchar)(def_temp);
+  *(T+1)= (uchar)(def_temp >> 8);
+}
+
+static inline void int4store(uchar *T, uint32 A)
+{
+  *(T)=  (uchar) (A);
+  *(T+1)=(uchar) (A >> 8);
+  *(T+2)=(uchar) (A >> 16);
+  *(T+3)=(uchar) (A >> 24);
+}
+
+static inline void int8store(uchar *T, ulonglong A)
+{
+  uint def_temp= (uint) A,
+       def_temp2= (uint) (A >> 32);
+  int4store(T,  def_temp);
+  int4store(T+4,def_temp2);
+}

extern-libs/mysql/include/byte_order_generic_x86.h

@@ -0,0 +1,43 @@
+/* Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; version 2 of the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
+
+/*
+  Optimized functions for the x86 architecture (_WIN32 included).
+*/
+static inline int16  sint2korr(const uchar *A) { return *((int16*) A); }
+
+static inline int32 sint4korr(const uchar *A) { return *((int32*) A); }
+
+static inline uint16 uint2korr(const uchar *A) { return *((uint16*) A); }
+
+static inline uint32 uint4korr(const uchar *A) { return *((uint32*) A); }
+
+static inline ulonglong uint8korr(const uchar *A) { return *((ulonglong*) A);}
+static inline longlong  sint8korr(const uchar *A) { return *((longlong*) A); }
+
+static inline void int2store(uchar *T, uint16 A)
+{
+  *((uint16*) T)= A;
+}
+
+static inline void int4store(uchar *T, uint32 A)
+{
+  *((uint32*) T)= A;
+}
+
+static inline void int8store(uchar *T, ulonglong A)
+{
+  *((ulonglong*) T)= A;
+}

extern-libs/mysql/include/decimal.h

@@ -0,0 +1,138 @@
+/* Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; version 2 of the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA */
+
+#ifndef _decimal_h
+#define _decimal_h
+
+typedef enum
+{TRUNCATE=0, HALF_EVEN, HALF_UP, CEILING, FLOOR}
+  decimal_round_mode;
+typedef int32 decimal_digit_t;
+
+/**
+    intg is the number of *decimal* digits (NOT number of decimal_digit_t's !)
+         before the point
+    frac is the number of decimal digits after the point
+    len  is the length of buf (length of allocated space) in decimal_digit_t's,
+         not in bytes
+    sign false means positive, true means negative
+    buf  is an array of decimal_digit_t's
+ */
+typedef struct st_decimal_t {
+  int    intg, frac, len;
+  my_bool sign;
+  decimal_digit_t *buf;
+} decimal_t;
+
+int internal_str2dec(const char *from, decimal_t *to, char **end,
+                     my_bool fixed);
+int decimal2string(const decimal_t *from, char *to, int *to_len,
+                   int fixed_precision, int fixed_decimals,
+                   char filler);
+int decimal2ulonglong(decimal_t *from, ulonglong *to);
+int ulonglong2decimal(ulonglong from, decimal_t *to);
+int decimal2longlong(decimal_t *from, longlong *to);
+int longlong2decimal(longlong from, decimal_t *to);
+int decimal2double(const decimal_t *from, double *to);
+int double2decimal(double from, decimal_t *to);
+int decimal_actual_fraction(decimal_t *from);
+int decimal2bin(decimal_t *from, uchar *to, int precision, int scale);
+int bin2decimal(const uchar *from, decimal_t *to, int precision, int scale);
+
+/**
+  Convert decimal to lldiv_t.
+  The integer part is stored in to->quot.
+  The fractional part is multiplied to 10^9 and stored to to->rem.
+  @param  from  Decimal value
+  @param  to    lldiv_t value
+  @retval 0     on success
+  @retval !0    in error
+*/
+int decimal2lldiv_t(const decimal_t *from, lldiv_t *to);
+
+/**
+  Convert doube to lldiv_t.
+  The integer part is stored in to->quot.
+  The fractional part is multiplied to 10^9 and stored to to->rem.
+  @param  from  Decimal value
+  @param  to    lldiv_t value
+  @retval 0     on success
+  @retval !0    in error
+*/
+
+int double2lldiv_t(double from, lldiv_t *to);
+int decimal_size(int precision, int scale);
+int decimal_bin_size(int precision, int scale);
+int decimal_result_size(decimal_t *from1, decimal_t *from2, char op,
+                        int param);
+
+int decimal_intg(const decimal_t *from);
+int decimal_add(const decimal_t *from1, const decimal_t *from2, decimal_t *to);
+int decimal_sub(const decimal_t *from1, const decimal_t *from2, decimal_t *to);
+int decimal_cmp(const decimal_t *from1, const decimal_t *from2);
+int decimal_mul(const decimal_t *from1, const decimal_t *from2, decimal_t *to);
+int decimal_div(const decimal_t *from1, const decimal_t *from2, decimal_t *to,
+                int scale_incr);
+int decimal_mod(const decimal_t *from1, const decimal_t *from2, decimal_t *to);
+int decimal_round(const decimal_t *from, decimal_t *to, int new_scale,
+                  decimal_round_mode mode);
+int decimal_is_zero(const decimal_t *from);
+void max_decimal(int precision, int frac, decimal_t *to);
+
+#define string2decimal(A,B,C) internal_str2dec((A), (B), (C), 0)
+#define string2decimal_fixed(A,B,C) internal_str2dec((A), (B), (C), 1)
+
+/* set a decimal_t to zero */
+
+#define decimal_make_zero(dec)        do {                \
+                                        (dec)->buf[0]=0;    \
+                                        (dec)->intg=1;      \
+                                        (dec)->frac=0;      \
+                                        (dec)->sign=0;      \
+                                      } while(0)
+
+/*
+  returns the length of the buffer to hold string representation
+  of the decimal (including decimal dot, possible sign and \0)
+*/
+
+#define decimal_string_size(dec) (((dec)->intg ? (dec)->intg : 1) + \
+				  (dec)->frac + ((dec)->frac > 0) + 2)
+
+/* negate a decimal */
+#define decimal_neg(dec) do { (dec)->sign^=1; } while(0)
+
+/*
+  conventions:
+
+    decimal_smth() == 0     -- everything's ok
+    decimal_smth() <= 1     -- result is usable, but precision loss is possible
+    decimal_smth() <= 2     -- result can be unusable, most significant digits
+                               could've been lost
+    decimal_smth() >  2     -- no result was generated
+*/
+
+#define E_DEC_OK                0
+#define E_DEC_TRUNCATED         1
+#define E_DEC_OVERFLOW          2
+#define E_DEC_DIV_ZERO          4
+#define E_DEC_BAD_NUM           8
+#define E_DEC_OOM              16
+
+#define E_DEC_ERROR            31
+#define E_DEC_FATAL_ERROR      30
+
+#endif
+