lzo1x_1_compress: 340| 924|{ 341| 924| const lzo_bytep ip = in; 342| 924| lzo_bytep op = out; ------------------ | | 148| 924|#define lzo_bytep unsigned char __LZO_MMODEL * ------------------ 343| 924| lzo_uint l = in_len; 344| 924| lzo_uint t = 0; 345| | 346| 2.91k| while (l > 20) ------------------ | Branch (346:12): [True: 2.00k, False: 917] ------------------ 347| 2.00k| { 348| 2.00k| lzo_uint ll = l; 349| 2.00k| lzo_uintptr_t ll_end; ------------------ | | 3078| 2.00k|# define lzo_uintptr_t unsigned long ------------------ 350| 2.00k|#if 0 || (LZO_DETERMINISTIC) 351| 2.00k| ll = LZO_MIN(ll, 49152); ------------------ | | 263| 2.00k|#define LZO_MIN(a,b) ((a) <= (b) ? (a) : (b)) | | ------------------ | | | Branch (263:30): [True: 897, False: 1.10k] | | ------------------ ------------------ 352| 2.00k|#endif 353| 2.00k| ll_end = (lzo_uintptr_t)ip + ll; 354| 2.00k| if ((ll_end + ((t + ll) >> 5)) <= ll_end || (const lzo_bytep)(ll_end + ((t + ll) >> 5)) <= ip + ll) ------------------ | Branch (354:13): [True: 7, False: 1.99k] | Branch (354:53): [True: 0, False: 1.99k] ------------------ 355| 7| break; 356| 1.99k|#if (LZO_DETERMINISTIC) 357| 1.99k| lzo_memset(wrkmem, 0, ((lzo_uint)1 << D_BITS) * sizeof(lzo_dict_t)); ------------------ | | 205| 1.99k|# define lzo_memset(a,b,c) memset(a,b,c) ------------------ 358| 1.99k|#endif 359| 1.99k| t = do_compress(ip,ll,op,out_len,t,wrkmem); ------------------ | | 32| 1.99k|# define do_compress LZO_PP_ECONCAT2(DO_COMPRESS,_core) | | ------------------ | | | | 288| 1.99k|#define LZO_PP_ECONCAT2(a,b) LZO_PP_CONCAT2(a,b) | | | | ------------------ | | | | | | 280| 1.99k|#define LZO_PP_CONCAT2(a,b) a ## b | | | | ------------------ | | ------------------ ------------------ 360| 1.99k| ip += ll; 361| 1.99k| op += *out_len; 362| 1.99k| l -= ll; 363| 1.99k| } 364| 924| t += l; 365| | 366| 924| if (t > 0) ------------------ | Branch (366:9): [True: 924, False: 0] ------------------ 367| 924| { 368| 924| const lzo_bytep ii = in + in_len - t; 369| | 370| 924| if (op == out && t <= 238) ------------------ | Branch (370:13): [True: 155, False: 769] | Branch (370:26): [True: 44, False: 111] ------------------ 371| 44| *op++ = LZO_BYTE(17 + t); ------------------ | | 257| 44|# define LZO_BYTE(x) ((unsigned char) (x)) ------------------ 372| 880| else if (t <= 3) ------------------ | Branch (372:18): [True: 0, False: 880] ------------------ 373| 0| op[-2] = LZO_BYTE(op[-2] | t); ------------------ | | 257| 0|# define LZO_BYTE(x) ((unsigned char) (x)) ------------------ 374| 880| else if (t <= 18) ------------------ | Branch (374:18): [True: 553, False: 327] ------------------ 375| 553| *op++ = LZO_BYTE(t - 3); ------------------ | | 257| 553|# define LZO_BYTE(x) ((unsigned char) (x)) ------------------ 376| 327| else 377| 327| { 378| 327| lzo_uint tt = t - 18; 379| | 380| 327| *op++ = 0; 381| 112k| while (tt > 255) ------------------ | Branch (381:20): [True: 111k, False: 327] ------------------ 382| 111k| { 383| 111k| tt -= 255; 384| 111k| UA_SET1(op, 0); ------------------ | | 301| 111k|#define UA_SET1 LZO_MEMOPS_SET1 | | ------------------ | | | | 229| 111k| LZO_BLOCK_BEGIN \ | | | | ------------------ | | | | | | 1448| 111k|# define LZO_BLOCK_BEGIN do { | | | | ------------------ | | | | 230| 111k| lzo_memops_set_TU1p d__1 = (lzo_memops_set_TU1p) (lzo_memops_TU0p) (dd); \ | | | | ------------------ | | | | | | 223| 111k|#define lzo_memops_set_TU1p volatile lzo_memops_TU1p | | | | ------------------ | | | | 231| 111k| d__1[0] = LZO_BYTE(cc); \ | | | | ------------------ | | | | | | 257| 111k|# define LZO_BYTE(x) ((unsigned char) (x)) | | | | ------------------ | | | | 232| 111k| LZO_BLOCK_END | | | | ------------------ | | | | | | 1449| 111k|# define LZO_BLOCK_END } while __lzo_cte(0) | | | | | | ------------------ | | | | | | | | 1441| 111k|# define __lzo_cte(e) ((void)0,(e)) | | | | | | | | ------------------ | | | | | | | | | Branch (1441:38): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 385| 111k| op++; 386| 111k| } 387| 327| assert(tt > 0); 388| 327| *op++ = LZO_BYTE(tt); ------------------ | | 257| 327|# define LZO_BYTE(x) ((unsigned char) (x)) ------------------ 389| 327| } 390| 924| UA_COPYN(op, ii, t); ------------------ | | 343| 924|#define UA_COPYN LZO_MEMOPS_COPYN | | ------------------ | | | | 326| 924| LZO_BLOCK_BEGIN \ | | | | ------------------ | | | | | | 1448| 924|# define LZO_BLOCK_BEGIN do { | | | | ------------------ | | | | 327| 924| lzo_memops_TU1p d__n = (lzo_memops_TU1p) (lzo_memops_TU0p) (dd); \ | | | | ------------------ | | | | | | 175| 924|#define lzo_memops_TU1p unsigned char __LZO_MMODEL * | | | | ------------------ | | | | 328| 924| const lzo_memops_TU1p s__n = (const lzo_memops_TU1p) (const lzo_memops_TU0p) (ss); \ | | | | 329| 924| lzo_uint n__n = (nn); \ | | | | 330| 3.57M| while ((void)0, n__n >= 8) { LZO_MEMOPS_COPY8(d__n, s__n); d__n += 8; s__n += 8; n__n -= 8; } \ | | | | ------------------ | | | | | | 312| 3.57M| * (lzo_memops_TU8p) (lzo_memops_TU0p) (dd) = * (const lzo_memops_TU8p) (const lzo_memops_TU0p) (ss) | | | | ------------------ | | | | | Branch (330:12): [True: 3.57M, False: 924] | | | | ------------------ | | | | 331| 924| if ((void)0, n__n >= 4) { LZO_MEMOPS_COPY4(d__n, s__n); d__n += 4; s__n += 4; n__n -= 4; } \ | | | | ------------------ | | | | | | 296| 333| * (lzo_memops_TU4p) (lzo_memops_TU0p) (dd) = * (const lzo_memops_TU4p) (const lzo_memops_TU0p) (ss) | | | | ------------------ | | | | | Branch (331:9): [True: 333, False: 591] | | | | ------------------ | | | | 332| 1.15k| if ((void)0, n__n > 0) do { *d__n++ = *s__n++; } while (--n__n > 0); \ | | | | ------------------ | | | | | Branch (332:9): [True: 656, False: 268] | | | | | Branch (332:61): [True: 495, False: 656] | | | | ------------------ | | | | 333| 924| LZO_BLOCK_END | | | | ------------------ | | | | | | 1449| 924|# define LZO_BLOCK_END } while __lzo_cte(0) | | | | | | ------------------ | | | | | | | | 1441| 924|# define __lzo_cte(e) ((void)0,(e)) | | | | | | | | ------------------ | | | | | | | | | Branch (1441:38): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 391| 924| op += t; 392| 924| } 393| | 394| 924| *op++ = M4_MARKER | 1; ------------------ | | 80| 924|#define M4_MARKER 16 ------------------ 395| 924| *op++ = 0; 396| 924| *op++ = 0; 397| | 398| 924| *out_len = pd(op, out); ------------------ | | 70| 924|#define pd(a,b) ((lzo_uint) ((a)-(b))) ------------------ 399| 924| return LZO_E_OK; ------------------ | | 310| 924|#define LZO_E_OK 0 ------------------ 400| 924|} lzo1x_1.c:lzo1x_1_compress_core: 44| 1.99k|{ 45| 1.99k| const lzo_bytep ip; 46| 1.99k| lzo_bytep op; ------------------ | | 148| 1.99k|#define lzo_bytep unsigned char __LZO_MMODEL * ------------------ 47| 1.99k| const lzo_bytep const in_end = in + in_len; 48| 1.99k| const lzo_bytep const ip_end = in + in_len - 20; 49| 1.99k| const lzo_bytep ii; 50| 1.99k| lzo_dict_p const dict = (lzo_dict_p) wrkmem; ------------------ | | 426| 1.99k|# define lzo_dict_p lzo_dict_t * | | ------------------ | | | | 34| 1.99k|#define lzo_dict_t lzo_uint16_t | | | | ------------------ | | | | | | 3156| 1.99k|#define lzo_uint16_t lzo_uint16e_t | | | | | | ------------------ | | | | | | | | 2854| 1.99k|# define lzo_uint16e_t unsigned short int | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 51| | 52| 1.99k| op = out; 53| 1.99k| ip = in; 54| 1.99k| ii = ip; 55| | 56| 1.99k| ip += ti < 4 ? 4 - ti : 0; ------------------ | Branch (56:11): [True: 899, False: 1.09k] ------------------ 57| 1.99k| for (;;) 58| 1.99k| { 59| 1.99k| const lzo_bytep m_pos; 60| |#if !(LZO_DETERMINISTIC) 61| | LZO_DEFINE_UNINITIALIZED_VAR(lzo_uint, m_off, 0); 62| | lzo_uint m_len; 63| | lzo_uint dindex; 64| |next: 65| | if __lzo_unlikely(ip >= ip_end) 66| | break; 67| | DINDEX1(dindex,ip); 68| | GINDEX(m_pos,m_off,dict,dindex,in); 69| | if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M4_MAX_OFFSET)) 70| | goto literal; 71| |#if 1 72| | if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3]) 73| | goto try_match; 74| | DINDEX2(dindex,ip); 75| |#endif 76| | GINDEX(m_pos,m_off,dict,dindex,in); 77| | if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M4_MAX_OFFSET)) 78| | goto literal; 79| | if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3]) 80| | goto try_match; 81| | goto literal; 82| | 83| |try_match: 84| |#if (LZO_OPT_UNALIGNED32) 85| | if (UA_GET_NE32(m_pos) != UA_GET_NE32(ip)) 86| |#else 87| | if (m_pos[0] != ip[0] || m_pos[1] != ip[1] || m_pos[2] != ip[2] || m_pos[3] != ip[3]) 88| |#endif 89| | { 90| | /* a literal */ 91| |literal: 92| | UPDATE_I(dict,0,dindex,ip,in); 93| | ip += 1 + ((ip - ii) >> 5); 94| | continue; 95| | } 96| |/*match:*/ 97| | UPDATE_I(dict,0,dindex,ip,in); 98| |#else 99| 1.99k| lzo_uint m_off; 100| 1.99k| lzo_uint m_len; 101| 1.99k| { 102| 1.99k| lzo_uint32_t dv; ------------------ | | 3164| 1.99k|#define lzo_uint32_t lzo_uint32e_t | | ------------------ | | | | 2886| 1.99k|# define lzo_uint32e_t unsigned int | | ------------------ ------------------ 103| 1.99k| lzo_uint dindex; 104| 937k|literal: 105| 937k| ip += 1 + ((ip - ii) >> 5); 106| 1.02M|next: 107| 1.02M| if __lzo_unlikely(ip >= ip_end) ------------------ | | 1896| 1.02M|# define __lzo_unlikely(e) (__builtin_expect(!!(e),0)) | | ------------------ | | | Branch (1896:34): [True: 1.99k, False: 1.02M] | | ------------------ ------------------ 108| 1.99k| break; 109| 1.02M| dv = UA_GET_LE32(ip); ------------------ | | 352| 1.02M|#define UA_GET_LE32 LZO_MEMOPS_GET_LE32 | | ------------------ | | | | 374| 1.02M|#define LZO_MEMOPS_GET_LE32(ss) (* (const lzo_memops_TU4p) (const lzo_memops_TU0p) (ss)) | | ------------------ ------------------ 110| 1.02M| dindex = DINDEX(dv,ip); ------------------ | | 44| 1.02M|#define DINDEX(dv,p) DM(((DMUL(0x1824429d,dv)) >> (32-D_BITS))) | | ------------------ | | | | 151| 1.02M|#define DM(v) DMS(v,0) | | | | ------------------ | | | | | | 150| 1.02M|#define DMS(v,s) ((lzo_uint) (((v) & (D_MASK >> (s))) << (s))) | | | | | | ------------------ | | | | | | | | 57| 1.02M|# define D_MASK LZO_MASK(D_BITS) | | | | | | | | ------------------ | | | | | | | | | | 273| 1.02M|#define LZO_MASK(bits) (LZO_SIZE(bits) - 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 272| 1.02M|#define LZO_SIZE(bits) (1u << (bits)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 111| 1.02M| GINDEX(m_off,m_pos,in+dict,dindex,in); ------------------ | | 237| 1.02M|# define GINDEX(m_pos,m_off,dict,dindex,in) m_off = dict[dindex] ------------------ 112| 1.02M| UPDATE_I(dict,0,dindex,ip,in); ------------------ | | 244| 1.02M|# define UPDATE_I(dict,drun,index,p,in) dict[index] = DENTRY(p,in) | | ------------------ | | | | 236| 1.02M|# define DENTRY(p,in) ((lzo_dict_t) pd(p, in)) | | | | ------------------ | | | | | | 70| 1.02M|#define pd(a,b) ((lzo_uint) ((a)-(b))) | | | | ------------------ | | ------------------ ------------------ 113| 1.02M| if __lzo_unlikely(dv != UA_GET_LE32(m_pos)) ------------------ | | 1896| 1.02M|# define __lzo_unlikely(e) (__builtin_expect(!!(e),0)) | | ------------------ | | | Branch (1896:34): [True: 935k, False: 92.0k] | | ------------------ ------------------ 114| 935k| goto literal; 115| 1.02M| } 116| 92.0k|#endif 117| | 118| | /* a match */ 119| | 120| 92.0k| ii -= ti; ti = 0; 121| 92.0k| { 122| 92.0k| lzo_uint t = pd(ip,ii); ------------------ | | 70| 92.0k|#define pd(a,b) ((lzo_uint) ((a)-(b))) ------------------ 123| 92.0k| if (t != 0) ------------------ | Branch (123:13): [True: 52.3k, False: 39.6k] ------------------ 124| 52.3k| { 125| 52.3k| if (t <= 3) ------------------ | Branch (125:17): [True: 23.0k, False: 29.3k] ------------------ 126| 23.0k| { 127| 23.0k| op[-2] = LZO_BYTE(op[-2] | t); ------------------ | | 257| 23.0k|# define LZO_BYTE(x) ((unsigned char) (x)) ------------------ 128| 23.0k|#if (LZO_OPT_UNALIGNED32) 129| 23.0k| UA_COPY4(op, ii); ------------------ | | 337| 23.0k|#define UA_COPY4 LZO_MEMOPS_COPY4 | | ------------------ | | | | 296| 23.0k| * (lzo_memops_TU4p) (lzo_memops_TU0p) (dd) = * (const lzo_memops_TU4p) (const lzo_memops_TU0p) (ss) | | ------------------ ------------------ 130| 23.0k| op += t; 131| |#else 132| | { do *op++ = *ii++; while (--t > 0); } 133| |#endif 134| 23.0k| } 135| 29.3k|#if (LZO_OPT_UNALIGNED32) || (LZO_OPT_UNALIGNED64) 136| 29.3k| else if (t <= 16) ------------------ | Branch (136:22): [True: 19.6k, False: 9.75k] ------------------ 137| 19.6k| { 138| 19.6k| *op++ = LZO_BYTE(t - 3); ------------------ | | 257| 19.6k|# define LZO_BYTE(x) ((unsigned char) (x)) ------------------ 139| 19.6k| UA_COPY8(op, ii); ------------------ | | 340| 19.6k|#define UA_COPY8 LZO_MEMOPS_COPY8 | | ------------------ | | | | 312| 19.6k| * (lzo_memops_TU8p) (lzo_memops_TU0p) (dd) = * (const lzo_memops_TU8p) (const lzo_memops_TU0p) (ss) | | ------------------ ------------------ 140| 19.6k| UA_COPY8(op+8, ii+8); ------------------ | | 340| 19.6k|#define UA_COPY8 LZO_MEMOPS_COPY8 | | ------------------ | | | | 312| 19.6k| * (lzo_memops_TU8p) (lzo_memops_TU0p) (dd) = * (const lzo_memops_TU8p) (const lzo_memops_TU0p) (ss) | | ------------------ ------------------ 141| 19.6k| op += t; 142| 19.6k| } 143| 9.75k|#endif 144| 9.75k| else 145| 9.75k| { 146| 9.75k| if (t <= 18) ------------------ | Branch (146:21): [True: 861, False: 8.88k] ------------------ 147| 861| *op++ = LZO_BYTE(t - 3); ------------------ | | 257| 861|# define LZO_BYTE(x) ((unsigned char) (x)) ------------------ 148| 8.88k| else 149| 8.88k| { 150| 8.88k| lzo_uint tt = t - 18; 151| 8.88k| *op++ = 0; 152| 106k| while __lzo_unlikely(tt > 255) ------------------ | | 1896| 106k|# define __lzo_unlikely(e) (__builtin_expect(!!(e),0)) | | ------------------ | | | Branch (1896:34): [True: 97.3k, False: 8.88k] | | ------------------ ------------------ 153| 97.3k| { 154| 97.3k| tt -= 255; 155| 97.3k| UA_SET1(op, 0); ------------------ | | 301| 97.3k|#define UA_SET1 LZO_MEMOPS_SET1 | | ------------------ | | | | 229| 97.3k| LZO_BLOCK_BEGIN \ | | | | ------------------ | | | | | | 1448| 97.3k|# define LZO_BLOCK_BEGIN do { | | | | ------------------ | | | | 230| 97.3k| lzo_memops_set_TU1p d__1 = (lzo_memops_set_TU1p) (lzo_memops_TU0p) (dd); \ | | | | ------------------ | | | | | | 223| 97.3k|#define lzo_memops_set_TU1p volatile lzo_memops_TU1p | | | | ------------------ | | | | 231| 97.3k| d__1[0] = LZO_BYTE(cc); \ | | | | ------------------ | | | | | | 257| 97.3k|# define LZO_BYTE(x) ((unsigned char) (x)) | | | | ------------------ | | | | 232| 97.3k| LZO_BLOCK_END | | | | ------------------ | | | | | | 1449| 97.3k|# define LZO_BLOCK_END } while __lzo_cte(0) | | | | | | ------------------ | | | | | | | | 1441| 97.3k|# define __lzo_cte(e) ((void)0,(e)) | | | | | | | | ------------------ | | | | | | | | | Branch (1441:38): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 156| 97.3k| op++; 157| 97.3k| } 158| 8.88k| assert(tt > 0); 159| 8.88k| *op++ = LZO_BYTE(tt); ------------------ | | 257| 8.88k|# define LZO_BYTE(x) ((unsigned char) (x)) ------------------ 160| 8.88k| } 161| 9.75k|#if (LZO_OPT_UNALIGNED32) || (LZO_OPT_UNALIGNED64) 162| 1.58M| do { 163| 1.58M| UA_COPY8(op, ii); ------------------ | | 340| 1.58M|#define UA_COPY8 LZO_MEMOPS_COPY8 | | ------------------ | | | | 312| 1.58M| * (lzo_memops_TU8p) (lzo_memops_TU0p) (dd) = * (const lzo_memops_TU8p) (const lzo_memops_TU0p) (ss) | | ------------------ ------------------ 164| 1.58M| UA_COPY8(op+8, ii+8); ------------------ | | 340| 1.58M|#define UA_COPY8 LZO_MEMOPS_COPY8 | | ------------------ | | | | 312| 1.58M| * (lzo_memops_TU8p) (lzo_memops_TU0p) (dd) = * (const lzo_memops_TU8p) (const lzo_memops_TU0p) (ss) | | ------------------ ------------------ 165| 1.58M| op += 16; ii += 16; t -= 16; 166| 1.58M| } while (t >= 16); if (t > 0) ------------------ | Branch (166:26): [True: 1.57M, False: 9.75k] | Branch (166:40): [True: 9.00k, False: 749] ------------------ 167| 9.00k|#endif 168| 61.1k| { do *op++ = *ii++; while (--t > 0); } ------------------ | Branch (168:44): [True: 52.1k, False: 9.00k] ------------------ 169| 9.75k| } 170| 52.3k| } 171| 92.0k| } 172| 92.0k| m_len = 4; 173| 92.0k| { 174| 92.0k|#if (LZO_OPT_UNALIGNED64) 175| 92.0k| lzo_uint64_t v; ------------------ | | 3172| 92.0k|#define lzo_uint64_t lzo_uint64e_t | | ------------------ | | | | 2944| 92.0k|# define lzo_uint64e_t unsigned long int | | ------------------ ------------------ 176| 92.0k| v = UA_GET_NE64(ip + m_len) ^ UA_GET_NE64(m_pos + m_len); ------------------ | | 367| 92.0k|#define UA_GET_NE64 LZO_MEMOPS_GET_NE64 | | ------------------ | | | | 411| 92.0k|#define LZO_MEMOPS_GET_NE64(ss) (* (const lzo_memops_TU8p) (const lzo_memops_TU0p) (ss)) | | ------------------ ------------------ v = UA_GET_NE64(ip + m_len) ^ UA_GET_NE64(m_pos + m_len); ------------------ | | 367| 92.0k|#define UA_GET_NE64 LZO_MEMOPS_GET_NE64 | | ------------------ | | | | 411| 92.0k|#define LZO_MEMOPS_GET_NE64(ss) (* (const lzo_memops_TU8p) (const lzo_memops_TU0p) (ss)) | | ------------------ ------------------ 177| 92.0k| if __lzo_unlikely(v == 0) { ------------------ | | 1896| 92.0k|# define __lzo_unlikely(e) (__builtin_expect(!!(e),0)) | | ------------------ | | | Branch (1896:34): [True: 37.3k, False: 54.6k] | | ------------------ ------------------ 178| 727k| do { 179| 727k| m_len += 8; 180| 727k| v = UA_GET_NE64(ip + m_len) ^ UA_GET_NE64(m_pos + m_len); ------------------ | | 367| 727k|#define UA_GET_NE64 LZO_MEMOPS_GET_NE64 | | ------------------ | | | | 411| 727k|#define LZO_MEMOPS_GET_NE64(ss) (* (const lzo_memops_TU8p) (const lzo_memops_TU0p) (ss)) | | ------------------ ------------------ v = UA_GET_NE64(ip + m_len) ^ UA_GET_NE64(m_pos + m_len); ------------------ | | 367| 727k|#define UA_GET_NE64 LZO_MEMOPS_GET_NE64 | | ------------------ | | | | 411| 727k|#define LZO_MEMOPS_GET_NE64(ss) (* (const lzo_memops_TU8p) (const lzo_memops_TU0p) (ss)) | | ------------------ ------------------ 181| 727k| if __lzo_unlikely(ip + m_len >= ip_end) ------------------ | | 1896| 727k|# define __lzo_unlikely(e) (__builtin_expect(!!(e),0)) | | ------------------ | | | Branch (1896:34): [True: 192, False: 727k] | | ------------------ ------------------ 182| 192| goto m_len_done; 183| 727k| } while (v == 0); ------------------ | Branch (183:22): [True: 689k, False: 37.2k] ------------------ 184| 37.3k| } 185| |#if (LZO_ABI_BIG_ENDIAN) && defined(lzo_bitops_ctlz64) 186| | m_len += lzo_bitops_ctlz64(v) / CHAR_BIT; 187| |#elif (LZO_ABI_BIG_ENDIAN) 188| | if ((v >> (64 - CHAR_BIT)) == 0) do { 189| | v <<= CHAR_BIT; 190| | m_len += 1; 191| | } while ((v >> (64 - CHAR_BIT)) == 0); 192| |#elif (LZO_ABI_LITTLE_ENDIAN) && defined(lzo_bitops_cttz64) 193| 91.8k| m_len += lzo_bitops_cttz64(v) / CHAR_BIT; ------------------ | | 139| 91.8k|#define lzo_bitops_cttz64(v) ((unsigned) __builtin_ctzl(v)) ------------------ 194| |#elif (LZO_ABI_LITTLE_ENDIAN) 195| | if ((v & UCHAR_MAX) == 0) do { 196| | v >>= CHAR_BIT; 197| | m_len += 1; 198| | } while ((v & UCHAR_MAX) == 0); 199| |#else 200| | if (ip[m_len] == m_pos[m_len]) do { 201| | m_len += 1; 202| | } while (ip[m_len] == m_pos[m_len]); 203| |#endif 204| |#elif (LZO_OPT_UNALIGNED32) 205| | lzo_uint32_t v; 206| | v = UA_GET_NE32(ip + m_len) ^ UA_GET_NE32(m_pos + m_len); 207| | if __lzo_unlikely(v == 0) { 208| | do { 209| | m_len += 4; 210| | v = UA_GET_NE32(ip + m_len) ^ UA_GET_NE32(m_pos + m_len); 211| | if (v != 0) 212| | break; 213| | m_len += 4; 214| | v = UA_GET_NE32(ip + m_len) ^ UA_GET_NE32(m_pos + m_len); 215| | if __lzo_unlikely(ip + m_len >= ip_end) 216| | goto m_len_done; 217| | } while (v == 0); 218| | } 219| |#if (LZO_ABI_BIG_ENDIAN) && defined(lzo_bitops_ctlz32) 220| | m_len += lzo_bitops_ctlz32(v) / CHAR_BIT; 221| |#elif (LZO_ABI_BIG_ENDIAN) 222| | if ((v >> (32 - CHAR_BIT)) == 0) do { 223| | v <<= CHAR_BIT; 224| | m_len += 1; 225| | } while ((v >> (32 - CHAR_BIT)) == 0); 226| |#elif (LZO_ABI_LITTLE_ENDIAN) && defined(lzo_bitops_cttz32) 227| | m_len += lzo_bitops_cttz32(v) / CHAR_BIT; 228| |#elif (LZO_ABI_LITTLE_ENDIAN) 229| | if ((v & UCHAR_MAX) == 0) do { 230| | v >>= CHAR_BIT; 231| | m_len += 1; 232| | } while ((v & UCHAR_MAX) == 0); 233| |#else 234| | if (ip[m_len] == m_pos[m_len]) do { 235| | m_len += 1; 236| | } while (ip[m_len] == m_pos[m_len]); 237| |#endif 238| |#else 239| | if __lzo_unlikely(ip[m_len] == m_pos[m_len]) { 240| | do { 241| | m_len += 1; 242| | if (ip[m_len] != m_pos[m_len]) 243| | break; 244| | m_len += 1; 245| | if (ip[m_len] != m_pos[m_len]) 246| | break; 247| | m_len += 1; 248| | if (ip[m_len] != m_pos[m_len]) 249| | break; 250| | m_len += 1; 251| | if (ip[m_len] != m_pos[m_len]) 252| | break; 253| | m_len += 1; 254| | if (ip[m_len] != m_pos[m_len]) 255| | break; 256| | m_len += 1; 257| | if (ip[m_len] != m_pos[m_len]) 258| | break; 259| | m_len += 1; 260| | if (ip[m_len] != m_pos[m_len]) 261| | break; 262| | m_len += 1; 263| | if __lzo_unlikely(ip + m_len >= ip_end) 264| | goto m_len_done; 265| | } while (ip[m_len] == m_pos[m_len]); 266| | } 267| |#endif 268| 91.8k| } 269| 92.0k|m_len_done: 270| 92.0k| m_off = pd(ip,m_pos); ------------------ | | 70| 92.0k|#define pd(a,b) ((lzo_uint) ((a)-(b))) ------------------ 271| 92.0k| ip += m_len; 272| 92.0k| ii = ip; 273| 92.0k| if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) ------------------ | | 70| 184k|#define M2_MAX_LEN 8 ------------------ if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) ------------------ | | 59| 45.6k|#define M2_MAX_OFFSET 0x0800 ------------------ | Branch (273:13): [True: 45.6k, False: 46.4k] | Branch (273:36): [True: 34.6k, False: 11.0k] ------------------ 274| 34.6k| { 275| 34.6k| m_off -= 1; 276| 34.6k|#if defined(LZO1X) 277| 34.6k| *op++ = LZO_BYTE(((m_len - 1) << 5) | ((m_off & 7) << 2)); ------------------ | | 257| 34.6k|# define LZO_BYTE(x) ((unsigned char) (x)) ------------------ 278| 34.6k| *op++ = LZO_BYTE(m_off >> 3); ------------------ | | 257| 34.6k|# define LZO_BYTE(x) ((unsigned char) (x)) ------------------ 279| |#elif defined(LZO1Y) 280| | *op++ = LZO_BYTE(((m_len + 1) << 4) | ((m_off & 3) << 2)); 281| | *op++ = LZO_BYTE(m_off >> 2); 282| |#endif 283| 34.6k| } 284| 57.4k| else if (m_off <= M3_MAX_OFFSET) ------------------ | | 61| 57.4k|#define M3_MAX_OFFSET 0x4000 ------------------ | Branch (284:18): [True: 51.7k, False: 5.68k] ------------------ 285| 51.7k| { 286| 51.7k| m_off -= 1; 287| 51.7k| if (m_len <= M3_MAX_LEN) ------------------ | | 73| 51.7k|#define M3_MAX_LEN 33 ------------------ | Branch (287:17): [True: 36.0k, False: 15.6k] ------------------ 288| 36.0k| *op++ = LZO_BYTE(M3_MARKER | (m_len - 2)); ------------------ | | 257| 36.0k|# define LZO_BYTE(x) ((unsigned char) (x)) ------------------ 289| 15.6k| else 290| 15.6k| { 291| 15.6k| m_len -= M3_MAX_LEN; ------------------ | | 73| 15.6k|#define M3_MAX_LEN 33 ------------------ 292| 15.6k| *op++ = M3_MARKER | 0; ------------------ | | 79| 15.6k|#define M3_MARKER 32 ------------------ 293| 28.3k| while __lzo_unlikely(m_len > 255) ------------------ | | 1896| 28.3k|# define __lzo_unlikely(e) (__builtin_expect(!!(e),0)) | | ------------------ | | | Branch (1896:34): [True: 12.6k, False: 15.6k] | | ------------------ ------------------ 294| 12.6k| { 295| 12.6k| m_len -= 255; 296| 12.6k| UA_SET1(op, 0); ------------------ | | 301| 12.6k|#define UA_SET1 LZO_MEMOPS_SET1 | | ------------------ | | | | 229| 12.6k| LZO_BLOCK_BEGIN \ | | | | ------------------ | | | | | | 1448| 12.6k|# define LZO_BLOCK_BEGIN do { | | | | ------------------ | | | | 230| 12.6k| lzo_memops_set_TU1p d__1 = (lzo_memops_set_TU1p) (lzo_memops_TU0p) (dd); \ | | | | ------------------ | | | | | | 223| 12.6k|#define lzo_memops_set_TU1p volatile lzo_memops_TU1p | | | | ------------------ | | | | 231| 12.6k| d__1[0] = LZO_BYTE(cc); \ | | | | ------------------ | | | | | | 257| 12.6k|# define LZO_BYTE(x) ((unsigned char) (x)) | | | | ------------------ | | | | 232| 12.6k| LZO_BLOCK_END | | | | ------------------ | | | | | | 1449| 12.6k|# define LZO_BLOCK_END } while __lzo_cte(0) | | | | | | ------------------ | | | | | | | | 1441| 12.6k|# define __lzo_cte(e) ((void)0,(e)) | | | | | | | | ------------------ | | | | | | | | | Branch (1441:38): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 297| 12.6k| op++; 298| 12.6k| } 299| 15.6k| *op++ = LZO_BYTE(m_len); ------------------ | | 257| 15.6k|# define LZO_BYTE(x) ((unsigned char) (x)) ------------------ 300| 15.6k| } 301| 51.7k| *op++ = LZO_BYTE(m_off << 2); ------------------ | | 257| 51.7k|# define LZO_BYTE(x) ((unsigned char) (x)) ------------------ 302| 51.7k| *op++ = LZO_BYTE(m_off >> 6); ------------------ | | 257| 51.7k|# define LZO_BYTE(x) ((unsigned char) (x)) ------------------ 303| 51.7k| } 304| 5.68k| else 305| 5.68k| { 306| 5.68k| m_off -= 0x4000; 307| 5.68k| if (m_len <= M4_MAX_LEN) ------------------ | | 75| 5.68k|#define M4_MAX_LEN 9 ------------------ | Branch (307:17): [True: 2.16k, False: 3.51k] ------------------ 308| 2.16k| *op++ = LZO_BYTE(M4_MARKER | ((m_off >> 11) & 8) | (m_len - 2)); ------------------ | | 257| 2.16k|# define LZO_BYTE(x) ((unsigned char) (x)) ------------------ 309| 3.51k| else 310| 3.51k| { 311| 3.51k| m_len -= M4_MAX_LEN; ------------------ | | 75| 3.51k|#define M4_MAX_LEN 9 ------------------ 312| 3.51k| *op++ = LZO_BYTE(M4_MARKER | ((m_off >> 11) & 8)); ------------------ | | 257| 3.51k|# define LZO_BYTE(x) ((unsigned char) (x)) ------------------ 313| 6.96k| while __lzo_unlikely(m_len > 255) ------------------ | | 1896| 6.96k|# define __lzo_unlikely(e) (__builtin_expect(!!(e),0)) | | ------------------ | | | Branch (1896:34): [True: 3.44k, False: 3.51k] | | ------------------ ------------------ 314| 3.44k| { 315| 3.44k| m_len -= 255; 316| 3.44k| UA_SET1(op, 0); ------------------ | | 301| 3.44k|#define UA_SET1 LZO_MEMOPS_SET1 | | ------------------ | | | | 229| 3.44k| LZO_BLOCK_BEGIN \ | | | | ------------------ | | | | | | 1448| 3.44k|# define LZO_BLOCK_BEGIN do { | | | | ------------------ | | | | 230| 3.44k| lzo_memops_set_TU1p d__1 = (lzo_memops_set_TU1p) (lzo_memops_TU0p) (dd); \ | | | | ------------------ | | | | | | 223| 3.44k|#define lzo_memops_set_TU1p volatile lzo_memops_TU1p | | | | ------------------ | | | | 231| 3.44k| d__1[0] = LZO_BYTE(cc); \ | | | | ------------------ | | | | | | 257| 3.44k|# define LZO_BYTE(x) ((unsigned char) (x)) | | | | ------------------ | | | | 232| 3.44k| LZO_BLOCK_END | | | | ------------------ | | | | | | 1449| 3.44k|# define LZO_BLOCK_END } while __lzo_cte(0) | | | | | | ------------------ | | | | | | | | 1441| 3.44k|# define __lzo_cte(e) ((void)0,(e)) | | | | | | | | ------------------ | | | | | | | | | Branch (1441:38): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 317| 3.44k| op++; 318| 3.44k| } 319| 3.51k| *op++ = LZO_BYTE(m_len); ------------------ | | 257| 3.51k|# define LZO_BYTE(x) ((unsigned char) (x)) ------------------ 320| 3.51k| } 321| 5.68k| *op++ = LZO_BYTE(m_off << 2); ------------------ | | 257| 5.68k|# define LZO_BYTE(x) ((unsigned char) (x)) ------------------ 322| 5.68k| *op++ = LZO_BYTE(m_off >> 6); ------------------ | | 257| 5.68k|# define LZO_BYTE(x) ((unsigned char) (x)) ------------------ 323| 5.68k| } 324| 92.0k| goto next; 325| 91.8k| } 326| | 327| 1.99k| *out_len = pd(op, out); ------------------ | | 70| 1.99k|#define pd(a,b) ((lzo_uint) ((a)-(b))) ------------------ 328| 1.99k| return pd(in_end,ii-ti); ------------------ | | 70| 1.99k|#define pd(a,b) ((lzo_uint) ((a)-(b))) ------------------ 329| 1.99k|} lzo1x_decompress: 42| 540|{ 43| 540| lzo_bytep op; ------------------ | | 148| 540|#define lzo_bytep unsigned char __LZO_MMODEL * ------------------ 44| 540| const lzo_bytep ip; 45| 540| lzo_uint t; 46| |#if defined(COPY_DICT) 47| | lzo_uint m_off; 48| | const lzo_bytep dict_end; 49| |#else 50| 540| const lzo_bytep m_pos; 51| 540|#endif 52| | 53| 540| const lzo_bytep const ip_end = in + in_len; 54| |#if defined(HAVE_ANY_OP) 55| | lzo_bytep const op_end = out + *out_len; 56| |#endif 57| |#if defined(LZO1Z) 58| | lzo_uint last_m_off = 0; 59| |#endif 60| | 61| 540| LZO_UNUSED(wrkmem); ------------------ | | 1457| 540|# define LZO_UNUSED(var) ((void) &var) ------------------ 62| | 63| |#if defined(COPY_DICT) 64| | if (dict) 65| | { 66| | if (dict_len > M4_MAX_OFFSET) 67| | { 68| | dict += dict_len - M4_MAX_OFFSET; 69| | dict_len = M4_MAX_OFFSET; 70| | } 71| | dict_end = dict + dict_len; 72| | } 73| | else 74| | { 75| | dict_len = 0; 76| | dict_end = NULL; 77| | } 78| |#endif /* COPY_DICT */ 79| | 80| 540| *out_len = 0; 81| | 82| 540| op = out; 83| 540| ip = in; 84| | 85| 540| NEED_IP(1); ------------------ | | 137| 540|# define NEED_IP(x) ((void) 0) ------------------ 86| 540| if (*ip > 17) ------------------ | Branch (86:9): [True: 0, False: 540] ------------------ 87| 0| { 88| 0| t = *ip++ - 17; 89| 0| if (t < 4) ------------------ | Branch (89:13): [True: 0, False: 0] ------------------ 90| 0| goto match_next; 91| 0| assert(t > 0); NEED_OP(t); NEED_IP(t+3); ------------------ | | 143| 0|# define NEED_OP(x) ((void) 0) ------------------ assert(t > 0); NEED_OP(t); NEED_IP(t+3); ------------------ | | 137| 0|# define NEED_IP(x) ((void) 0) ------------------ 92| 0| do *op++ = *ip++; while (--t > 0); ------------------ | Branch (92:34): [True: 0, False: 0] ------------------ 93| 0| goto first_literal_run; 94| 0| } 95| | 96| 540| for (;;) 97| 68.1k| { 98| 68.1k| NEED_IP(3); ------------------ | | 137| 68.1k|# define NEED_IP(x) ((void) 0) ------------------ 99| 68.1k| t = *ip++; 100| 68.1k| if (t >= 16) ------------------ | Branch (100:13): [True: 39.6k, False: 28.5k] ------------------ 101| 39.6k| goto match; 102| | /* a literal run */ 103| 28.5k| if (t == 0) ------------------ | Branch (103:13): [True: 7.82k, False: 20.6k] ------------------ 104| 7.82k| { 105| 69.4k| while (*ip == 0) ------------------ | Branch (105:20): [True: 61.6k, False: 7.82k] ------------------ 106| 61.6k| { 107| 61.6k| t += 255; 108| 61.6k| ip++; 109| 61.6k| TEST_IV(t); ------------------ | | 138| 61.6k|# define TEST_IV(x) ((void) 0) ------------------ 110| 61.6k| NEED_IP(1); ------------------ | | 137| 61.6k|# define NEED_IP(x) ((void) 0) ------------------ 111| 61.6k| } 112| 7.82k| t += 15 + *ip++; 113| 7.82k| } 114| | /* copy literals */ 115| 28.5k| assert(t > 0); NEED_OP(t+3); NEED_IP(t+6); ------------------ | | 143| 28.5k|# define NEED_OP(x) ((void) 0) ------------------ assert(t > 0); NEED_OP(t+3); NEED_IP(t+6); ------------------ | | 137| 28.5k|# define NEED_IP(x) ((void) 0) ------------------ 116| 28.5k|#if (LZO_OPT_UNALIGNED64) && (LZO_OPT_UNALIGNED32) 117| 28.5k| t += 3; 118| 28.5k| if (t >= 8) do ------------------ | Branch (118:13): [True: 14.7k, False: 13.7k] ------------------ 119| 2.03M| { 120| 2.03M| UA_COPY8(op,ip); ------------------ | | 340| 2.03M|#define UA_COPY8 LZO_MEMOPS_COPY8 | | ------------------ | | | | 312| 2.03M| * (lzo_memops_TU8p) (lzo_memops_TU0p) (dd) = * (const lzo_memops_TU8p) (const lzo_memops_TU0p) (ss) | | ------------------ ------------------ 121| 2.03M| op += 8; ip += 8; t -= 8; 122| 2.03M| } while (t >= 8); ------------------ | Branch (122:18): [True: 2.02M, False: 14.7k] ------------------ 123| 28.5k| if (t >= 4) ------------------ | Branch (123:13): [True: 19.7k, False: 8.77k] ------------------ 124| 19.7k| { 125| 19.7k| UA_COPY4(op,ip); ------------------ | | 337| 19.7k|#define UA_COPY4 LZO_MEMOPS_COPY4 | | ------------------ | | | | 296| 19.7k| * (lzo_memops_TU4p) (lzo_memops_TU0p) (dd) = * (const lzo_memops_TU4p) (const lzo_memops_TU0p) (ss) | | ------------------ ------------------ 126| 19.7k| op += 4; ip += 4; t -= 4; 127| 19.7k| } 128| 28.5k| if (t > 0) ------------------ | Branch (128:13): [True: 17.0k, False: 11.4k] ------------------ 129| 17.0k| { 130| 17.0k| *op++ = *ip++; 131| 17.0k| if (t > 1) { *op++ = *ip++; if (t > 2) { *op++ = *ip++; } } ------------------ | Branch (131:17): [True: 10.9k, False: 6.10k] | Branch (131:45): [True: 5.31k, False: 5.66k] ------------------ 132| 17.0k| } 133| |#elif (LZO_OPT_UNALIGNED32) || (LZO_ALIGNED_OK_4) 134| |#if !(LZO_OPT_UNALIGNED32) 135| | if (PTR_ALIGNED2_4(op,ip)) 136| | { 137| |#endif 138| | UA_COPY4(op,ip); 139| | op += 4; ip += 4; 140| | if (--t > 0) 141| | { 142| | if (t >= 4) 143| | { 144| | do { 145| | UA_COPY4(op,ip); 146| | op += 4; ip += 4; t -= 4; 147| | } while (t >= 4); 148| | if (t > 0) do *op++ = *ip++; while (--t > 0); 149| | } 150| | else 151| | do *op++ = *ip++; while (--t > 0); 152| | } 153| |#if !(LZO_OPT_UNALIGNED32) 154| | } 155| | else 156| |#endif 157| |#endif 158| |#if !(LZO_OPT_UNALIGNED32) 159| | { 160| | *op++ = *ip++; *op++ = *ip++; *op++ = *ip++; 161| | do *op++ = *ip++; while (--t > 0); 162| | } 163| |#endif 164| | 165| | 166| 28.5k|first_literal_run: 167| | 168| | 169| 28.5k| t = *ip++; 170| 28.5k| if (t >= 16) ------------------ | Branch (170:13): [True: 28.5k, False: 0] ------------------ 171| 28.5k| goto match; 172| |#if defined(COPY_DICT) 173| |#if defined(LZO1Z) 174| | m_off = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2); 175| | last_m_off = m_off; 176| |#else 177| | m_off = (1 + M2_MAX_OFFSET) + (t >> 2) + (*ip++ << 2); 178| |#endif 179| | NEED_OP(3); 180| | t = 3; COPY_DICT(t,m_off) 181| |#else /* !COPY_DICT */ 182| |#if defined(LZO1Z) 183| | t = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2); 184| | m_pos = op - t; 185| | last_m_off = t; 186| |#else 187| 0| m_pos = op - (1 + M2_MAX_OFFSET); ------------------ | | 59| 0|#define M2_MAX_OFFSET 0x0800 ------------------ 188| 0| m_pos -= t >> 2; 189| 0| m_pos -= *ip++ << 2; 190| 0|#endif 191| 0| TEST_LB(m_pos); NEED_OP(3); ------------------ | | 102| 0|# define TEST_LB(m_pos) ((void) 0) ------------------ TEST_LB(m_pos); NEED_OP(3); ------------------ | | 143| 0|# define NEED_OP(x) ((void) 0) ------------------ 192| 0| *op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos; 193| 0|#endif /* COPY_DICT */ 194| 0| goto match_done; 195| | 196| | 197| | /* handle matches */ 198| 22.9k| for (;;) { 199| 91.1k|match: 200| 91.1k| if (t >= 64) /* a M2 match */ ------------------ | Branch (200:17): [True: 33.7k, False: 57.3k] ------------------ 201| 33.7k| { 202| |#if defined(COPY_DICT) 203| |#if defined(LZO1X) 204| | m_off = 1 + ((t >> 2) & 7) + (*ip++ << 3); 205| | t = (t >> 5) - 1; 206| |#elif defined(LZO1Y) 207| | m_off = 1 + ((t >> 2) & 3) + (*ip++ << 2); 208| | t = (t >> 4) - 3; 209| |#elif defined(LZO1Z) 210| | m_off = t & 0x1f; 211| | if (m_off >= 0x1c) 212| | m_off = last_m_off; 213| | else 214| | { 215| | m_off = 1 + (m_off << 6) + (*ip++ >> 2); 216| | last_m_off = m_off; 217| | } 218| | t = (t >> 5) - 1; 219| |#endif 220| |#else /* !COPY_DICT */ 221| 33.7k|#if defined(LZO1X) 222| 33.7k| m_pos = op - 1; 223| 33.7k| m_pos -= (t >> 2) & 7; 224| 33.7k| m_pos -= *ip++ << 3; 225| 33.7k| t = (t >> 5) - 1; 226| |#elif defined(LZO1Y) 227| | m_pos = op - 1; 228| | m_pos -= (t >> 2) & 3; 229| | m_pos -= *ip++ << 2; 230| | t = (t >> 4) - 3; 231| |#elif defined(LZO1Z) 232| | { 233| | lzo_uint off = t & 0x1f; 234| | m_pos = op; 235| | if (off >= 0x1c) 236| | { 237| | assert(last_m_off > 0); 238| | m_pos -= last_m_off; 239| | } 240| | else 241| | { 242| | off = 1 + (off << 6) + (*ip++ >> 2); 243| | m_pos -= off; 244| | last_m_off = off; 245| | } 246| | } 247| | t = (t >> 5) - 1; 248| |#endif 249| 33.7k| TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1); ------------------ | | 102| 33.7k|# define TEST_LB(m_pos) ((void) 0) ------------------ TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1); ------------------ | | 143| 33.7k|# define NEED_OP(x) ((void) 0) ------------------ 250| 33.7k| goto copy_match; 251| 33.7k|#endif /* COPY_DICT */ 252| 33.7k| } 253| 57.3k| else if (t >= 32) /* a M3 match */ ------------------ | Branch (253:22): [True: 51.2k, False: 6.18k] ------------------ 254| 51.2k| { 255| 51.2k| t &= 31; 256| 51.2k| if (t == 0) ------------------ | Branch (256:21): [True: 15.6k, False: 35.5k] ------------------ 257| 15.6k| { 258| 28.3k| while (*ip == 0) ------------------ | Branch (258:28): [True: 12.6k, False: 15.6k] ------------------ 259| 12.6k| { 260| 12.6k| t += 255; 261| 12.6k| ip++; 262| 12.6k| TEST_OV(t); ------------------ | | 144| 12.6k|# define TEST_OV(x) ((void) 0) ------------------ 263| 12.6k| NEED_IP(1); ------------------ | | 137| 12.6k|# define NEED_IP(x) ((void) 0) ------------------ 264| 12.6k| } 265| 15.6k| t += 31 + *ip++; 266| 15.6k| NEED_IP(2); ------------------ | | 137| 15.6k|# define NEED_IP(x) ((void) 0) ------------------ 267| 15.6k| } 268| |#if defined(COPY_DICT) 269| |#if defined(LZO1Z) 270| | m_off = 1 + (ip[0] << 6) + (ip[1] >> 2); 271| | last_m_off = m_off; 272| |#else 273| | m_off = 1 + (ip[0] >> 2) + (ip[1] << 6); 274| |#endif 275| |#else /* !COPY_DICT */ 276| |#if defined(LZO1Z) 277| | { 278| | lzo_uint off = 1 + (ip[0] << 6) + (ip[1] >> 2); 279| | m_pos = op - off; 280| | last_m_off = off; 281| | } 282| |#elif (LZO_OPT_UNALIGNED16) && (LZO_ABI_LITTLE_ENDIAN) 283| | m_pos = op - 1; 284| 51.2k| m_pos -= UA_GET_LE16(ip) >> 2; ------------------ | | 349| 51.2k|#define UA_GET_LE16 LZO_MEMOPS_GET_LE16 | | ------------------ | | | | 352| 51.2k|#define LZO_MEMOPS_GET_LE16(ss) (* (const lzo_memops_TU2p) (const lzo_memops_TU0p) (ss)) | | ------------------ ------------------ 285| |#else 286| | m_pos = op - 1; 287| | m_pos -= (ip[0] >> 2) + (ip[1] << 6); 288| |#endif 289| 51.2k|#endif /* COPY_DICT */ 290| 51.2k| ip += 2; 291| 51.2k| } 292| 6.18k| else if (t >= 16) /* a M4 match */ ------------------ | Branch (292:22): [True: 6.18k, False: 0] ------------------ 293| 6.18k| { 294| |#if defined(COPY_DICT) 295| | m_off = (t & 8) << 11; 296| |#else /* !COPY_DICT */ 297| 6.18k| m_pos = op; 298| 6.18k| m_pos -= (t & 8) << 11; 299| 6.18k|#endif /* COPY_DICT */ 300| 6.18k| t &= 7; 301| 6.18k| if (t == 0) ------------------ | Branch (301:21): [True: 3.49k, False: 2.68k] ------------------ 302| 3.49k| { 303| 6.91k| while (*ip == 0) ------------------ | Branch (303:28): [True: 3.42k, False: 3.49k] ------------------ 304| 3.42k| { 305| 3.42k| t += 255; 306| 3.42k| ip++; 307| 3.42k| TEST_OV(t); ------------------ | | 144| 3.42k|# define TEST_OV(x) ((void) 0) ------------------ 308| 3.42k| NEED_IP(1); ------------------ | | 137| 3.42k|# define NEED_IP(x) ((void) 0) ------------------ 309| 3.42k| } 310| 3.49k| t += 7 + *ip++; 311| 3.49k| NEED_IP(2); ------------------ | | 137| 3.49k|# define NEED_IP(x) ((void) 0) ------------------ 312| 3.49k| } 313| |#if defined(COPY_DICT) 314| |#if defined(LZO1Z) 315| | m_off += (ip[0] << 6) + (ip[1] >> 2); 316| |#else 317| | m_off += (ip[0] >> 2) + (ip[1] << 6); 318| |#endif 319| | ip += 2; 320| | if (m_off == 0) 321| | goto eof_found; 322| | m_off += 0x4000; 323| |#if defined(LZO1Z) 324| | last_m_off = m_off; 325| |#endif 326| |#else /* !COPY_DICT */ 327| |#if defined(LZO1Z) 328| | m_pos -= (ip[0] << 6) + (ip[1] >> 2); 329| |#elif (LZO_OPT_UNALIGNED16) && (LZO_ABI_LITTLE_ENDIAN) 330| 6.18k| m_pos -= UA_GET_LE16(ip) >> 2; ------------------ | | 349| 6.18k|#define UA_GET_LE16 LZO_MEMOPS_GET_LE16 | | ------------------ | | | | 352| 6.18k|#define LZO_MEMOPS_GET_LE16(ss) (* (const lzo_memops_TU2p) (const lzo_memops_TU0p) (ss)) | | ------------------ ------------------ 331| |#else 332| | m_pos -= (ip[0] >> 2) + (ip[1] << 6); 333| |#endif 334| 6.18k| ip += 2; 335| 6.18k| if (m_pos == op) ------------------ | Branch (335:21): [True: 540, False: 5.64k] ------------------ 336| 540| goto eof_found; 337| 5.64k| m_pos -= 0x4000; 338| |#if defined(LZO1Z) 339| | last_m_off = pd((const lzo_bytep)op, m_pos); 340| |#endif 341| 5.64k|#endif /* COPY_DICT */ 342| 5.64k| } 343| 0| else /* a M1 match */ 344| 0| { 345| |#if defined(COPY_DICT) 346| |#if defined(LZO1Z) 347| | m_off = 1 + (t << 6) + (*ip++ >> 2); 348| | last_m_off = m_off; 349| |#else 350| | m_off = 1 + (t >> 2) + (*ip++ << 2); 351| |#endif 352| | NEED_OP(2); 353| | t = 2; COPY_DICT(t,m_off) 354| |#else /* !COPY_DICT */ 355| |#if defined(LZO1Z) 356| | t = 1 + (t << 6) + (*ip++ >> 2); 357| | m_pos = op - t; 358| | last_m_off = t; 359| |#else 360| 0| m_pos = op - 1; 361| 0| m_pos -= t >> 2; 362| 0| m_pos -= *ip++ << 2; 363| 0|#endif 364| 0| TEST_LB(m_pos); NEED_OP(2); ------------------ | | 102| 0|# define TEST_LB(m_pos) ((void) 0) ------------------ TEST_LB(m_pos); NEED_OP(2); ------------------ | | 143| 0|# define NEED_OP(x) ((void) 0) ------------------ 365| 0| *op++ = *m_pos++; *op++ = *m_pos; 366| 0|#endif /* COPY_DICT */ 367| 0| goto match_done; 368| 0| } 369| | 370| | /* copy match */ 371| |#if defined(COPY_DICT) 372| | 373| | NEED_OP(t+3-1); 374| | t += 3-1; COPY_DICT(t,m_off) 375| | 376| |#else /* !COPY_DICT */ 377| | 378| 56.8k| TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1); ------------------ | | 102| 56.8k|# define TEST_LB(m_pos) ((void) 0) ------------------ TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1); ------------------ | | 143| 56.8k|# define NEED_OP(x) ((void) 0) ------------------ 379| 56.8k|#if (LZO_OPT_UNALIGNED64) && (LZO_OPT_UNALIGNED32) 380| 56.8k| if (op - m_pos >= 8) ------------------ | Branch (380:17): [True: 50.9k, False: 5.93k] ------------------ 381| 50.9k| { 382| 50.9k| t += (3 - 1); 383| 50.9k| if (t >= 8) do ------------------ | Branch (383:21): [True: 41.3k, False: 9.52k] ------------------ 384| 536k| { 385| 536k| UA_COPY8(op,m_pos); ------------------ | | 340| 536k|#define UA_COPY8 LZO_MEMOPS_COPY8 | | ------------------ | | | | 312| 536k| * (lzo_memops_TU8p) (lzo_memops_TU0p) (dd) = * (const lzo_memops_TU8p) (const lzo_memops_TU0p) (ss) | | ------------------ ------------------ 386| 536k| op += 8; m_pos += 8; t -= 8; 387| 536k| } while (t >= 8); ------------------ | Branch (387:26): [True: 494k, False: 41.3k] ------------------ 388| 50.9k| if (t >= 4) ------------------ | Branch (388:21): [True: 27.7k, False: 23.1k] ------------------ 389| 27.7k| { 390| 27.7k| UA_COPY4(op,m_pos); ------------------ | | 337| 27.7k|#define UA_COPY4 LZO_MEMOPS_COPY4 | | ------------------ | | | | 296| 27.7k| * (lzo_memops_TU4p) (lzo_memops_TU0p) (dd) = * (const lzo_memops_TU4p) (const lzo_memops_TU0p) (ss) | | ------------------ ------------------ 391| 27.7k| op += 4; m_pos += 4; t -= 4; 392| 27.7k| } 393| 50.9k| if (t > 0) ------------------ | Branch (393:21): [True: 36.0k, False: 14.8k] ------------------ 394| 36.0k| { 395| 36.0k| *op++ = m_pos[0]; 396| 36.0k| if (t > 1) { *op++ = m_pos[1]; if (t > 2) { *op++ = m_pos[2]; } } ------------------ | Branch (396:25): [True: 22.6k, False: 13.3k] | Branch (396:56): [True: 11.1k, False: 11.4k] ------------------ 397| 36.0k| } 398| 50.9k| } 399| 5.93k| else 400| |#elif (LZO_OPT_UNALIGNED32) || (LZO_ALIGNED_OK_4) 401| |#if !(LZO_OPT_UNALIGNED32) 402| | if (t >= 2 * 4 - (3 - 1) && PTR_ALIGNED2_4(op,m_pos)) 403| | { 404| | assert((op - m_pos) >= 4); /* both pointers are aligned */ 405| |#else 406| | if (t >= 2 * 4 - (3 - 1) && (op - m_pos) >= 4) 407| | { 408| |#endif 409| | UA_COPY4(op,m_pos); 410| | op += 4; m_pos += 4; t -= 4 - (3 - 1); 411| | do { 412| | UA_COPY4(op,m_pos); 413| | op += 4; m_pos += 4; t -= 4; 414| | } while (t >= 4); 415| | if (t > 0) do *op++ = *m_pos++; while (--t > 0); 416| | } 417| | else 418| |#endif 419| 5.93k| { 420| 39.6k|copy_match: 421| 39.6k| *op++ = *m_pos++; *op++ = *m_pos++; 422| 1.83M| do *op++ = *m_pos++; while (--t > 0); ------------------ | Branch (422:45): [True: 1.80M, False: 39.6k] ------------------ 423| 39.6k| } 424| | 425| 56.8k|#endif /* COPY_DICT */ 426| | 427| 90.5k|match_done: 428| |#if defined(LZO1Z) 429| | t = ip[-1] & 3; 430| |#else 431| 90.5k| t = ip[-2] & 3; 432| 90.5k|#endif 433| 90.5k| if (t == 0) ------------------ | Branch (433:17): [True: 67.6k, False: 22.9k] ------------------ 434| 67.6k| break; 435| | 436| | /* copy literals */ 437| 22.9k|match_next: 438| 22.9k| assert(t > 0); assert(t < 4); NEED_OP(t); NEED_IP(t+3); ------------------ | | 143| 22.9k|# define NEED_OP(x) ((void) 0) ------------------ assert(t > 0); assert(t < 4); NEED_OP(t); NEED_IP(t+3); ------------------ | | 137| 22.9k|# define NEED_IP(x) ((void) 0) ------------------ 439| |#if 0 440| | do *op++ = *ip++; while (--t > 0); 441| |#else 442| 22.9k| *op++ = *ip++; 443| 22.9k| if (t > 1) { *op++ = *ip++; if (t > 2) { *op++ = *ip++; } } ------------------ | Branch (443:17): [True: 8.76k, False: 14.1k] | Branch (443:45): [True: 4.05k, False: 4.71k] ------------------ 444| 22.9k|#endif 445| 22.9k| t = *ip++; 446| 22.9k| } 447| 0| } 448| | 449| 540|eof_found: 450| 540| *out_len = pd(op, out); ------------------ | | 70| 540|#define pd(a,b) ((lzo_uint) ((a)-(b))) ------------------ 451| 540| return (ip == ip_end ? LZO_E_OK : ------------------ | | 310| 540|#define LZO_E_OK 0 ------------------ | Branch (451:13): [True: 540, False: 0] ------------------ 452| 540| (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); ------------------ | | 318| 0|#define LZO_E_INPUT_NOT_CONSUMED (-8) ------------------ (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); ------------------ | | 314| 0|#define LZO_E_INPUT_OVERRUN (-4) ------------------ | Branch (452:13): [True: 0, False: 0] ------------------ 453| | 454| | 455| |#if defined(HAVE_NEED_IP) 456| |input_overrun: 457| | *out_len = pd(op, out); 458| | return LZO_E_INPUT_OVERRUN; 459| |#endif 460| | 461| |#if defined(HAVE_NEED_OP) 462| |output_overrun: 463| | *out_len = pd(op, out); 464| | return LZO_E_OUTPUT_OVERRUN; 465| |#endif 466| | 467| |#if defined(LZO_TEST_OVERRUN_LOOKBEHIND) 468| |lookbehind_overrun: 469| | *out_len = pd(op, out); 470| | return LZO_E_LOOKBEHIND_OVERRUN; 471| |#endif 472| 540|} lzo_init.c:lzo_bitops_ctlz32_func: 65| 32|{ 66| |#if (LZO_BITOPS_USE_MSC_BITSCAN) && (LZO_ARCH_AMD64 || LZO_ARCH_I386) 67| | unsigned long r; (void) _BitScanReverse(&r, v); return (unsigned) r ^ 31; 68| |#define lzo_bitops_ctlz32(v) lzo_bitops_ctlz32_func(v) 69| |#elif (LZO_BITOPS_USE_ASM_BITSCAN) && (LZO_ARCH_AMD64 || LZO_ARCH_I386) && (LZO_ASM_SYNTAX_GNUC) 70| | lzo_uint32_t r; 71| | __asm__("bsr %1,%0" : "=r" (r) : "rm" (v) __LZO_ASM_CLOBBER_LIST_CC); 72| | return (unsigned) r ^ 31; 73| |#define lzo_bitops_ctlz32(v) lzo_bitops_ctlz32_func(v) 74| |#elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_INT == 4) 75| | unsigned r; r = (unsigned) __builtin_clz(v); return r; 76| 32|#define lzo_bitops_ctlz32(v) ((unsigned) __builtin_clz(v)) 77| |#elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_LONG == 8) && (LZO_WORDSIZE >= 8) 78| | unsigned r; r = (unsigned) __builtin_clzl(v); return r ^ 32; 79| |#define lzo_bitops_ctlz32(v) (((unsigned) __builtin_clzl(v)) ^ 32) 80| |#else 81| | LZO_UNUSED(v); return 0; 82| |#endif 83| 32|} lzo_init.c:lzo_bitops_ctlz64_func: 87| 64|{ 88| |#if (LZO_BITOPS_USE_MSC_BITSCAN) && (LZO_ARCH_AMD64) 89| | unsigned long r; (void) _BitScanReverse64(&r, v); return (unsigned) r ^ 63; 90| |#define lzo_bitops_ctlz64(v) lzo_bitops_ctlz64_func(v) 91| |#elif (LZO_BITOPS_USE_ASM_BITSCAN) && (LZO_ARCH_AMD64) && (LZO_ASM_SYNTAX_GNUC) 92| | lzo_uint64_t r; 93| | __asm__("bsr %1,%0" : "=r" (r) : "rm" (v) __LZO_ASM_CLOBBER_LIST_CC); 94| | return (unsigned) r ^ 63; 95| |#define lzo_bitops_ctlz64(v) lzo_bitops_ctlz64_func(v) 96| |#elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_LONG == 8) && (LZO_WORDSIZE >= 8) 97| | unsigned r; r = (unsigned) __builtin_clzl(v); return r; 98| 64|#define lzo_bitops_ctlz64(v) ((unsigned) __builtin_clzl(v)) 99| |#elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_LONG_LONG == 8) && (LZO_WORDSIZE >= 8) 100| | unsigned r; r = (unsigned) __builtin_clzll(v); return r; 101| |#define lzo_bitops_ctlz64(v) ((unsigned) __builtin_clzll(v)) 102| |#else 103| | LZO_UNUSED(v); return 0; 104| |#endif 105| 64|} lzo_init.c:lzo_bitops_cttz32_func: 109| 32|{ 110| |#if (LZO_BITOPS_USE_MSC_BITSCAN) && (LZO_ARCH_AMD64 || LZO_ARCH_I386) 111| | unsigned long r; (void) _BitScanForward(&r, v); return (unsigned) r; 112| |#define lzo_bitops_cttz32(v) lzo_bitops_cttz32_func(v) 113| |#elif (LZO_BITOPS_USE_ASM_BITSCAN) && (LZO_ARCH_AMD64 || LZO_ARCH_I386) && (LZO_ASM_SYNTAX_GNUC) 114| | lzo_uint32_t r; 115| | __asm__("bsf %1,%0" : "=r" (r) : "rm" (v) __LZO_ASM_CLOBBER_LIST_CC); 116| | return (unsigned) r; 117| |#define lzo_bitops_cttz32(v) lzo_bitops_cttz32_func(v) 118| |#elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_INT >= 4) 119| | unsigned r; r = (unsigned) __builtin_ctz(v); return r; 120| 32|#define lzo_bitops_cttz32(v) ((unsigned) __builtin_ctz(v)) 121| |#else 122| | LZO_UNUSED(v); return 0; 123| |#endif 124| 32|} lzo_init.c:lzo_bitops_cttz64_func: 128| 64|{ 129| |#if (LZO_BITOPS_USE_MSC_BITSCAN) && (LZO_ARCH_AMD64) 130| | unsigned long r; (void) _BitScanForward64(&r, v); return (unsigned) r; 131| |#define lzo_bitops_cttz64(v) lzo_bitops_cttz64_func(v) 132| |#elif (LZO_BITOPS_USE_ASM_BITSCAN) && (LZO_ARCH_AMD64) && (LZO_ASM_SYNTAX_GNUC) 133| | lzo_uint64_t r; 134| | __asm__("bsf %1,%0" : "=r" (r) : "rm" (v) __LZO_ASM_CLOBBER_LIST_CC); 135| | return (unsigned) r; 136| |#define lzo_bitops_cttz64(v) lzo_bitops_cttz64_func(v) 137| |#elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_LONG >= 8) && (LZO_WORDSIZE >= 8) 138| | unsigned r; r = (unsigned) __builtin_ctzl(v); return r; 139| 64|#define lzo_bitops_cttz64(v) ((unsigned) __builtin_ctzl(v)) 140| |#elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_LONG_LONG >= 8) && (LZO_WORDSIZE >= 8) 141| | unsigned r; r = (unsigned) __builtin_ctzll(v); return r; 142| |#define lzo_bitops_cttz64(v) ((unsigned) __builtin_ctzll(v)) 143| |#else 144| | LZO_UNUSED(v); return 0; 145| |#endif 146| 64|} _lzo_config_check: 89| 1|{ 90| |#if (LZO_CC_CLANG && (LZO_CC_CLANG >= 0x030100ul && LZO_CC_CLANG < 0x030300ul)) 91| |# if 0 92| | /* work around a clang 3.1 and clang 3.2 compiler bug; clang 3.3 and 3.4 work */ 93| | volatile 94| |# endif 95| |#endif 96| 1| union lzo_config_check_union u; 97| 1| lzo_voidp p; ------------------ | | 150| 1|#define lzo_voidp void __LZO_MMODEL * ------------------ 98| 1| unsigned r = 1; 99| | 100| 1| u.a[0] = u.a[1] = 0; 101| 1| p = u2p(&u, 0); 102| 1| r &= ((* (lzo_bytep) p) == 0); 103| 1|#if !(LZO_CFG_NO_CONFIG_CHECK) 104| |#if (LZO_ABI_BIG_ENDIAN) 105| | u.a[0] = u.a[1] = 0; u.b[sizeof(lzo_uint) - 1] = 128; 106| | p = u2p(&u, 0); 107| | r &= ((* (lzo_uintp) p) == 128); 108| |#endif 109| 1|#if (LZO_ABI_LITTLE_ENDIAN) 110| 1| u.a[0] = u.a[1] = 0; u.b[0] = 128; 111| 1| p = u2p(&u, 0); 112| 1| r &= ((* (lzo_uintp) p) == 128); 113| 1|#endif 114| 1| u.a[0] = u.a[1] = 0; 115| 1| u.b[0] = 1; u.b[3] = 2; 116| 1| p = u2p(&u, 1); 117| 1| r &= UA_GET_NE16(p) == 0; ------------------ | | 360| 1|#define UA_GET_NE16 LZO_MEMOPS_GET_NE16 | | ------------------ | | | | 391| 1|#define LZO_MEMOPS_GET_NE16(ss) (* (const lzo_memops_TU2p) (const lzo_memops_TU0p) (ss)) | | ------------------ ------------------ 118| 1| r &= UA_GET_LE16(p) == 0; ------------------ | | 349| 1|#define UA_GET_LE16 LZO_MEMOPS_GET_LE16 | | ------------------ | | | | 352| 1|#define LZO_MEMOPS_GET_LE16(ss) (* (const lzo_memops_TU2p) (const lzo_memops_TU0p) (ss)) | | ------------------ ------------------ 119| 1| u.b[1] = 128; 120| 1| r &= UA_GET_LE16(p) == 128; ------------------ | | 349| 1|#define UA_GET_LE16 LZO_MEMOPS_GET_LE16 | | ------------------ | | | | 352| 1|#define LZO_MEMOPS_GET_LE16(ss) (* (const lzo_memops_TU2p) (const lzo_memops_TU0p) (ss)) | | ------------------ ------------------ 121| 1| u.b[2] = 129; 122| 1| r &= UA_GET_LE16(p) == LZO_UINT16_C(0x8180); ------------------ | | 349| 1|#define UA_GET_LE16 LZO_MEMOPS_GET_LE16 | | ------------------ | | | | 352| 1|#define LZO_MEMOPS_GET_LE16(ss) (* (const lzo_memops_TU2p) (const lzo_memops_TU0p) (ss)) | | ------------------ ------------------ r &= UA_GET_LE16(p) == LZO_UINT16_C(0x8180); ------------------ | | 3219| 1|# define LZO_UINT16_C(c) (c##U) ------------------ 123| |#if (LZO_ABI_BIG_ENDIAN) 124| | r &= UA_GET_NE16(p) == LZO_UINT16_C(0x8081); 125| |#endif 126| 1|#if (LZO_ABI_LITTLE_ENDIAN) 127| 1| r &= UA_GET_NE16(p) == LZO_UINT16_C(0x8180); ------------------ | | 360| 1|#define UA_GET_NE16 LZO_MEMOPS_GET_NE16 | | ------------------ | | | | 391| 1|#define LZO_MEMOPS_GET_NE16(ss) (* (const lzo_memops_TU2p) (const lzo_memops_TU0p) (ss)) | | ------------------ ------------------ r &= UA_GET_NE16(p) == LZO_UINT16_C(0x8180); ------------------ | | 3219| 1|# define LZO_UINT16_C(c) (c##U) ------------------ 128| 1|#endif 129| 1| u.a[0] = u.a[1] = 0; 130| 1| u.b[0] = 3; u.b[5] = 4; 131| 1| p = u2p(&u, 1); 132| 1| r &= UA_GET_NE32(p) == 0; ------------------ | | 363| 1|#define UA_GET_NE32 LZO_MEMOPS_GET_NE32 | | ------------------ | | | | 404| 1|#define LZO_MEMOPS_GET_NE32(ss) (* (const lzo_memops_TU4p) (const lzo_memops_TU0p) (ss)) | | ------------------ ------------------ 133| 1| r &= UA_GET_LE32(p) == 0; ------------------ | | 352| 1|#define UA_GET_LE32 LZO_MEMOPS_GET_LE32 | | ------------------ | | | | 374| 1|#define LZO_MEMOPS_GET_LE32(ss) (* (const lzo_memops_TU4p) (const lzo_memops_TU0p) (ss)) | | ------------------ ------------------ 134| 1| u.b[1] = 128; 135| 1| r &= UA_GET_LE32(p) == 128; ------------------ | | 352| 1|#define UA_GET_LE32 LZO_MEMOPS_GET_LE32 | | ------------------ | | | | 374| 1|#define LZO_MEMOPS_GET_LE32(ss) (* (const lzo_memops_TU4p) (const lzo_memops_TU0p) (ss)) | | ------------------ ------------------ 136| 1| u.b[2] = 129; u.b[3] = 130; u.b[4] = 131; 137| 1| r &= UA_GET_LE32(p) == LZO_UINT32_C(0x83828180); ------------------ | | 352| 1|#define UA_GET_LE32 LZO_MEMOPS_GET_LE32 | | ------------------ | | | | 374| 1|#define LZO_MEMOPS_GET_LE32(ss) (* (const lzo_memops_TU4p) (const lzo_memops_TU0p) (ss)) | | ------------------ ------------------ r &= UA_GET_LE32(p) == LZO_UINT32_C(0x83828180); ------------------ | | 3236| 1|# define LZO_UINT32_C(c) (c##U) ------------------ 138| |#if (LZO_ABI_BIG_ENDIAN) 139| | r &= UA_GET_NE32(p) == LZO_UINT32_C(0x80818283); 140| |#endif 141| 1|#if (LZO_ABI_LITTLE_ENDIAN) 142| 1| r &= UA_GET_NE32(p) == LZO_UINT32_C(0x83828180); ------------------ | | 363| 1|#define UA_GET_NE32 LZO_MEMOPS_GET_NE32 | | ------------------ | | | | 404| 1|#define LZO_MEMOPS_GET_NE32(ss) (* (const lzo_memops_TU4p) (const lzo_memops_TU0p) (ss)) | | ------------------ ------------------ r &= UA_GET_NE32(p) == LZO_UINT32_C(0x83828180); ------------------ | | 3236| 1|# define LZO_UINT32_C(c) (c##U) ------------------ 143| 1|#endif 144| 1|#if defined(UA_GET_NE64) 145| 1| u.c[0] = u.c[1] = 0; 146| 1| u.b[0] = 5; u.b[9] = 6; 147| 1| p = u2p(&u, 1); 148| 1| u.c[0] = u.c[1] = 0; 149| 1| r &= UA_GET_NE64(p) == 0; ------------------ | | 367| 1|#define UA_GET_NE64 LZO_MEMOPS_GET_NE64 | | ------------------ | | | | 411| 1|#define LZO_MEMOPS_GET_NE64(ss) (* (const lzo_memops_TU8p) (const lzo_memops_TU0p) (ss)) | | ------------------ ------------------ 150| 1|#if defined(UA_GET_LE64) 151| 1| r &= UA_GET_LE64(p) == 0; ------------------ | | 356| 1|#define UA_GET_LE64 LZO_MEMOPS_GET_LE64 | | ------------------ | | | | 380| 1|#define LZO_MEMOPS_GET_LE64(ss) (* (const lzo_memops_TU8p) (const lzo_memops_TU0p) (ss)) | | ------------------ ------------------ 152| 1| u.b[1] = 128; 153| 1| r &= UA_GET_LE64(p) == 128; ------------------ | | 356| 1|#define UA_GET_LE64 LZO_MEMOPS_GET_LE64 | | ------------------ | | | | 380| 1|#define LZO_MEMOPS_GET_LE64(ss) (* (const lzo_memops_TU8p) (const lzo_memops_TU0p) (ss)) | | ------------------ ------------------ 154| 1|#endif 155| 1|#endif 156| 1|#if defined(lzo_bitops_ctlz32) 157| 1| { unsigned i = 0; lzo_uint32_t v; ------------------ | | 3164| 1|#define lzo_uint32_t lzo_uint32e_t | | ------------------ | | | | 2886| 1|# define lzo_uint32e_t unsigned int | | ------------------ ------------------ 158| 33| for (v = 1; v != 0 && r == 1; v <<= 1, i++) { ------------------ | Branch (158:17): [True: 32, False: 1] | Branch (158:27): [True: 32, False: 0] ------------------ 159| 32| r &= lzo_bitops_ctlz32(v) == 31 - i; ------------------ | | 76| 32|#define lzo_bitops_ctlz32(v) ((unsigned) __builtin_clz(v)) ------------------ 160| 32| r &= lzo_bitops_ctlz32_func(v) == 31 - i; 161| 32| }} 162| 1|#endif 163| 1|#if defined(lzo_bitops_ctlz64) 164| 1| { unsigned i = 0; lzo_uint64_t v; ------------------ | | 3172| 1|#define lzo_uint64_t lzo_uint64e_t | | ------------------ | | | | 2944| 1|# define lzo_uint64e_t unsigned long int | | ------------------ ------------------ 165| 65| for (v = 1; v != 0 && r == 1; v <<= 1, i++) { ------------------ | Branch (165:17): [True: 64, False: 1] | Branch (165:27): [True: 64, False: 0] ------------------ 166| 64| r &= lzo_bitops_ctlz64(v) == 63 - i; ------------------ | | 98| 64|#define lzo_bitops_ctlz64(v) ((unsigned) __builtin_clzl(v)) ------------------ 167| 64| r &= lzo_bitops_ctlz64_func(v) == 63 - i; 168| 64| }} 169| 1|#endif 170| 1|#if defined(lzo_bitops_cttz32) 171| 1| { unsigned i = 0; lzo_uint32_t v; ------------------ | | 3164| 1|#define lzo_uint32_t lzo_uint32e_t | | ------------------ | | | | 2886| 1|# define lzo_uint32e_t unsigned int | | ------------------ ------------------ 172| 33| for (v = 1; v != 0 && r == 1; v <<= 1, i++) { ------------------ | Branch (172:17): [True: 32, False: 1] | Branch (172:27): [True: 32, False: 0] ------------------ 173| 32| r &= lzo_bitops_cttz32(v) == i; ------------------ | | 120| 32|#define lzo_bitops_cttz32(v) ((unsigned) __builtin_ctz(v)) ------------------ 174| 32| r &= lzo_bitops_cttz32_func(v) == i; 175| 32| }} 176| 1|#endif 177| 1|#if defined(lzo_bitops_cttz64) 178| 1| { unsigned i = 0; lzo_uint64_t v; ------------------ | | 3172| 1|#define lzo_uint64_t lzo_uint64e_t | | ------------------ | | | | 2944| 1|# define lzo_uint64e_t unsigned long int | | ------------------ ------------------ 179| 65| for (v = 1; v != 0 && r == 1; v <<= 1, i++) { ------------------ | Branch (179:17): [True: 64, False: 1] | Branch (179:27): [True: 64, False: 0] ------------------ 180| 64| r &= lzo_bitops_cttz64(v) == i; ------------------ | | 139| 64|#define lzo_bitops_cttz64(v) ((unsigned) __builtin_ctzl(v)) ------------------ 181| 64| r &= lzo_bitops_cttz64_func(v) == i; 182| 64| }} 183| 1|#endif 184| 1|#endif 185| 1| LZO_UNUSED_FUNC(lzo_bitops_unused_funcs); ------------------ | | 1481| 1|# define LZO_UNUSED_FUNC(func) ((void) &func) ------------------ 186| | 187| 1| return r == 1 ? LZO_E_OK : LZO_E_ERROR; ------------------ | | 310| 1|#define LZO_E_OK 0 ------------------ return r == 1 ? LZO_E_OK : LZO_E_ERROR; ------------------ | | 311| 0|#define LZO_E_ERROR (-1) ------------------ | Branch (187:12): [True: 1, False: 0] ------------------ 188| 1|} __lzo_init_v2: 198| 1|{ 199| 1| int r; 200| | 201| |#if defined(__LZO_IN_MINILZO) 202| |#elif (LZO_CC_MSC && ((_MSC_VER) < 700)) 203| |#else 204| 1|#define LZO_WANT_ACC_CHK_CH 1 205| 1|#undef LZOCHK_ASSERT 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) 207| 1|#include "lzo_supp.h" ------------------ | | 1| |/* lzo_supp.h -- architecture, OS and compiler specific defines | | 2| | | | 3| | This file is part of the LZO real-time data compression library. | | 4| | | | 5| | Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer | | 6| | All Rights Reserved. | | 7| | | | 8| | The LZO library is free software; you can redistribute it and/or | | 9| | modify it under the terms of the GNU General Public License as | | 10| | published by the Free Software Foundation; either version 2 of | | 11| | the License, or (at your option) any later version. | | 12| | | | 13| | The LZO library is distributed in the hope that it will be useful, | | 14| | but WITHOUT ANY WARRANTY; without even the implied warranty of | | 15| | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | | 16| | GNU General Public License for more details. | | 17| | | | 18| | You should have received a copy of the GNU General Public License | | 19| | along with the LZO library; see the file COPYING. | | 20| | If not, write to the Free Software Foundation, Inc., | | 21| | 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. | | 22| | | | 23| | Markus F.X.J. Oberhumer | | 24| | | | 25| | http://www.oberhumer.com/opensource/lzo/ | | 26| | */ | | 27| | | | 28| | | | 29| |#ifndef __LZO_SUPP_H_INCLUDED | | 30| |#define __LZO_SUPP_H_INCLUDED 1 | | 31| |#if (LZO_CFG_NO_CONFIG_HEADER) | | 32| |#elif defined(LZO_CFG_CONFIG_HEADER) | | 33| |#else | | 34| |#if !(LZO_CFG_AUTO_NO_HEADERS) | | 35| |#if (LZO_LIBC_NAKED) | | 36| |#elif (LZO_LIBC_FREESTANDING) | | 37| |# define HAVE_LIMITS_H 1 | | 38| |# define HAVE_STDARG_H 1 | | 39| |# define HAVE_STDDEF_H 1 | | 40| |#elif (LZO_LIBC_MOSTLY_FREESTANDING) | | 41| |# define HAVE_LIMITS_H 1 | | 42| |# define HAVE_SETJMP_H 1 | | 43| |# define HAVE_STDARG_H 1 | | 44| |# define HAVE_STDDEF_H 1 | | 45| |# define HAVE_STDIO_H 1 | | 46| |# define HAVE_STRING_H 1 | | 47| |#else | | 48| |#define STDC_HEADERS 1 | | 49| |#define HAVE_ASSERT_H 1 | | 50| |#define HAVE_CTYPE_H 1 | | 51| |#define HAVE_DIRENT_H 1 | | 52| |#define HAVE_ERRNO_H 1 | | 53| |#define HAVE_FCNTL_H 1 | | 54| |#define HAVE_FLOAT_H 1 | | 55| |#define HAVE_LIMITS_H 1 | | 56| |#define HAVE_MALLOC_H 1 | | 57| |#define HAVE_MEMORY_H 1 | | 58| |#define HAVE_SETJMP_H 1 | | 59| |#define HAVE_SIGNAL_H 1 | | 60| |#define HAVE_STDARG_H 1 | | 61| |#define HAVE_STDDEF_H 1 | | 62| |#define HAVE_STDIO_H 1 | | 63| |#define HAVE_STDLIB_H 1 | | 64| |#define HAVE_STRING_H 1 | | 65| |#define HAVE_TIME_H 1 | | 66| |#define HAVE_UNISTD_H 1 | | 67| |#define HAVE_UTIME_H 1 | | 68| |#define HAVE_SYS_STAT_H 1 | | 69| |#define HAVE_SYS_TIME_H 1 | | 70| |#define HAVE_SYS_TYPES_H 1 | | 71| |#if (LZO_OS_POSIX) | | 72| |# if (LZO_OS_POSIX_AIX) | | 73| |# define HAVE_SYS_RESOURCE_H 1 | | 74| |# elif (LZO_OS_POSIX_DARWIN || LZO_OS_POSIX_FREEBSD || LZO_OS_POSIX_NETBSD || LZO_OS_POSIX_OPENBSD) | | 75| |# define HAVE_STRINGS_H 1 | | 76| |# undef HAVE_MALLOC_H | | 77| |# elif (LZO_OS_POSIX_HPUX || LZO_OS_POSIX_INTERIX) | | 78| |# define HAVE_ALLOCA_H 1 | | 79| |# elif (LZO_OS_POSIX_DARWIN && LZO_LIBC_MSL) | | 80| |# undef HAVE_SYS_TIME_H | | 81| |# undef HAVE_SYS_TYPES_H | | 82| |# elif (LZO_OS_POSIX_SOLARIS || LZO_OS_POSIX_SUNOS) | | 83| |# define HAVE_ALLOCA_H 1 | | 84| |# endif | | 85| |# if (LZO_LIBC_DIETLIBC || LZO_LIBC_GLIBC || LZO_LIBC_UCLIBC) | | 86| |# define HAVE_STRINGS_H 1 | | 87| |# define HAVE_SYS_MMAN_H 1 | | 88| |# define HAVE_SYS_RESOURCE_H 1 | | 89| |# define HAVE_SYS_WAIT_H 1 | | 90| |# endif | | 91| |# if (LZO_LIBC_NEWLIB) | | 92| |# undef HAVE_STRINGS_H | | 93| |# endif | | 94| |#elif (LZO_OS_CYGWIN) | | 95| |# define HAVE_IO_H 1 | | 96| |#elif (LZO_OS_EMX) | | 97| |# define HAVE_ALLOCA_H 1 | | 98| |# define HAVE_IO_H 1 | | 99| |#elif (LZO_ARCH_M68K && LZO_OS_TOS && LZO_CC_GNUC) | | 100| |# if !defined(__MINT__) | | 101| |# undef HAVE_MALLOC_H | | 102| |# endif | | 103| |#elif (LZO_ARCH_M68K && LZO_OS_TOS && (LZO_CC_PUREC || LZO_CC_TURBOC)) | | 104| |# undef HAVE_DIRENT_H | | 105| |# undef HAVE_FCNTL_H | | 106| |# undef HAVE_MALLOC_H | | 107| |# undef HAVE_MEMORY_H | | 108| |# undef HAVE_UNISTD_H | | 109| |# undef HAVE_UTIME_H | | 110| |# undef HAVE_SYS_STAT_H | | 111| |# undef HAVE_SYS_TIME_H | | 112| |# undef HAVE_SYS_TYPES_H | | 113| |#endif | | 114| |#if (LZO_OS_DOS16 || LZO_OS_DOS32 || LZO_OS_OS2 || LZO_OS_OS216 || LZO_OS_WIN16 || LZO_OS_WIN32 || LZO_OS_WIN64) | | 115| |#define HAVE_CONIO_H 1 | | 116| |#define HAVE_DIRECT_H 1 | | 117| |#define HAVE_DOS_H 1 | | 118| |#define HAVE_IO_H 1 | | 119| |#define HAVE_SHARE_H 1 | | 120| |#if (LZO_CC_AZTECC) | | 121| |# undef HAVE_CONIO_H | | 122| |# undef HAVE_DIRECT_H | | 123| |# undef HAVE_DIRENT_H | | 124| |# undef HAVE_MALLOC_H | | 125| |# undef HAVE_SHARE_H | | 126| |# undef HAVE_UNISTD_H | | 127| |# undef HAVE_UTIME_H | | 128| |# undef HAVE_SYS_STAT_H | | 129| |# undef HAVE_SYS_TIME_H | | 130| |# undef HAVE_SYS_TYPES_H | | 131| |#elif (LZO_CC_BORLANDC) | | 132| |# undef HAVE_UNISTD_H | | 133| |# undef HAVE_SYS_TIME_H | | 134| |# if (LZO_OS_WIN32 || LZO_OS_WIN64) | | 135| |# undef HAVE_DIRENT_H | | 136| |# endif | | 137| |# if (__BORLANDC__ < 0x0400) | | 138| |# undef HAVE_DIRENT_H | | 139| |# undef HAVE_UTIME_H | | 140| |# endif | | 141| |#elif (LZO_CC_DMC) | | 142| |# undef HAVE_DIRENT_H | | 143| |# undef HAVE_UNISTD_H | | 144| |# define HAVE_SYS_DIRENT_H 1 | | 145| |#elif (LZO_OS_DOS32 && LZO_CC_GNUC) && defined(__DJGPP__) | | 146| |#elif (LZO_OS_DOS32 && LZO_CC_HIGHC) | | 147| |# define HAVE_ALLOCA_H 1 | | 148| |# undef HAVE_DIRENT_H | | 149| |# undef HAVE_UNISTD_H | | 150| |#elif (LZO_CC_IBMC && LZO_OS_OS2) | | 151| |# undef HAVE_DOS_H | | 152| |# undef HAVE_DIRENT_H | | 153| |# undef HAVE_UNISTD_H | | 154| |# undef HAVE_UTIME_H | | 155| |# undef HAVE_SYS_TIME_H | | 156| |# define HAVE_SYS_UTIME_H 1 | | 157| |#elif (LZO_CC_CLANG_C2 || LZO_CC_CLANG_MSC || LZO_CC_GHS || LZO_CC_INTELC_MSC || LZO_CC_MSC) | | 158| |# undef HAVE_DIRENT_H | | 159| |# undef HAVE_UNISTD_H | | 160| |# undef HAVE_UTIME_H | | 161| |# undef HAVE_SYS_TIME_H | | 162| |# define HAVE_SYS_UTIME_H 1 | | 163| |#elif (LZO_CC_LCCWIN32) | | 164| |# undef HAVE_DIRENT_H | | 165| |# undef HAVE_DOS_H | | 166| |# undef HAVE_UNISTD_H | | 167| |# undef HAVE_SYS_TIME_H | | 168| |#elif (LZO_OS_WIN32 && LZO_CC_GNUC) && defined(__MINGW32__) | | 169| |# undef HAVE_UTIME_H | | 170| |# define HAVE_SYS_UTIME_H 1 | | 171| |#elif (LZO_OS_WIN32 && LZO_LIBC_MSL) | | 172| |# define HAVE_ALLOCA_H 1 | | 173| |# undef HAVE_DOS_H | | 174| |# undef HAVE_SHARE_H | | 175| |# undef HAVE_SYS_TIME_H | | 176| |#elif (LZO_CC_NDPC) | | 177| |# undef HAVE_DIRENT_H | | 178| |# undef HAVE_DOS_H | | 179| |# undef HAVE_UNISTD_H | | 180| |# undef HAVE_UTIME_H | | 181| |# undef HAVE_SYS_TIME_H | | 182| |#elif (LZO_CC_PACIFICC) | | 183| |# undef HAVE_DIRECT_H | | 184| |# undef HAVE_DIRENT_H | | 185| |# undef HAVE_FCNTL_H | | 186| |# undef HAVE_IO_H | | 187| |# undef HAVE_MALLOC_H | | 188| |# undef HAVE_MEMORY_H | | 189| |# undef HAVE_SHARE_H | | 190| |# undef HAVE_UNISTD_H | | 191| |# undef HAVE_UTIME_H | | 192| |# undef HAVE_SYS_STAT_H | | 193| |# undef HAVE_SYS_TIME_H | | 194| |# undef HAVE_SYS_TYPES_H | | 195| |#elif (LZO_OS_WIN32 && LZO_CC_PELLESC) | | 196| |# undef HAVE_DIRENT_H | | 197| |# undef HAVE_DOS_H | | 198| |# undef HAVE_MALLOC_H | | 199| |# undef HAVE_SHARE_H | | 200| |# undef HAVE_UNISTD_H | | 201| |# undef HAVE_UTIME_H | | 202| |# undef HAVE_SYS_TIME_H | | 203| |# if (__POCC__ < 280) | | 204| |# else | | 205| |# define HAVE_SYS_UTIME_H 1 | | 206| |# endif | | 207| |#elif (LZO_OS_WIN32 && LZO_CC_PGI) && defined(__MINGW32__) | | 208| |# undef HAVE_UTIME_H | | 209| |# define HAVE_SYS_UTIME_H 1 | | 210| |#elif (LZO_OS_WIN32 && LZO_CC_GNUC) && defined(__PW32__) | | 211| |#elif (LZO_CC_SYMANTECC) | | 212| |# undef HAVE_DIRENT_H | | 213| |# undef HAVE_UNISTD_H | | 214| |# if (__SC__ < 0x700) | | 215| |# undef HAVE_UTIME_H | | 216| |# undef HAVE_SYS_TIME_H | | 217| |# endif | | 218| |#elif (LZO_CC_TOPSPEEDC) | | 219| |# undef HAVE_DIRENT_H | | 220| |# undef HAVE_UNISTD_H | | 221| |# undef HAVE_UTIME_H | | 222| |# undef HAVE_SYS_STAT_H | | 223| |# undef HAVE_SYS_TIME_H | | 224| |# undef HAVE_SYS_TYPES_H | | 225| |#elif (LZO_CC_TURBOC) | | 226| |# undef HAVE_UNISTD_H | | 227| |# undef HAVE_SYS_TIME_H | | 228| |# undef HAVE_SYS_TYPES_H | | 229| |# if (LZO_OS_WIN32 || LZO_OS_WIN64) | | 230| |# undef HAVE_DIRENT_H | | 231| |# endif | | 232| |# if (__TURBOC__ < 0x0200) | | 233| |# undef HAVE_SIGNAL_H | | 234| |# endif | | 235| |# if (__TURBOC__ < 0x0400) | | 236| |# undef HAVE_DIRECT_H | | 237| |# undef HAVE_DIRENT_H | | 238| |# undef HAVE_MALLOC_H | | 239| |# undef HAVE_MEMORY_H | | 240| |# undef HAVE_UTIME_H | | 241| |# endif | | 242| |#elif (LZO_CC_WATCOMC) | | 243| |# undef HAVE_DIRENT_H | | 244| |# undef HAVE_UTIME_H | | 245| |# undef HAVE_SYS_TIME_H | | 246| |# define HAVE_SYS_UTIME_H 1 | | 247| |# if (__WATCOMC__ < 950) | | 248| |# undef HAVE_UNISTD_H | | 249| |# endif | | 250| |#elif (LZO_CC_ZORTECHC) | | 251| |# undef HAVE_DIRENT_H | | 252| |# undef HAVE_MEMORY_H | | 253| |# undef HAVE_UNISTD_H | | 254| |# undef HAVE_UTIME_H | | 255| |# undef HAVE_SYS_TIME_H | | 256| |#endif | | 257| |#endif | | 258| |#if (LZO_OS_CONSOLE) | | 259| |# undef HAVE_DIRENT_H | | 260| |#endif | | 261| |#if (LZO_OS_EMBEDDED) | | 262| |# undef HAVE_DIRENT_H | | 263| |#endif | | 264| |#if (LZO_LIBC_ISOC90 || LZO_LIBC_ISOC99) | | 265| |# undef HAVE_DIRENT_H | | 266| |# undef HAVE_FCNTL_H | | 267| |# undef HAVE_MALLOC_H | | 268| |# undef HAVE_UNISTD_H | | 269| |# undef HAVE_UTIME_H | | 270| |# undef HAVE_SYS_STAT_H | | 271| |# undef HAVE_SYS_TIME_H | | 272| |# undef HAVE_SYS_TYPES_H | | 273| |#endif | | 274| |#if (LZO_LIBC_GLIBC >= 0x020100ul) | | 275| |# define HAVE_STDINT_H 1 | | 276| |#elif (LZO_LIBC_DIETLIBC) | | 277| |# undef HAVE_STDINT_H | | 278| |#elif (LZO_LIBC_UCLIBC) | | 279| |# define HAVE_STDINT_H 1 | | 280| |#elif (LZO_CC_BORLANDC) && (__BORLANDC__ >= 0x560) | | 281| |# undef HAVE_STDINT_H | | 282| |#elif (LZO_CC_DMC) && (__DMC__ >= 0x825) | | 283| |# define HAVE_STDINT_H 1 | | 284| |#endif | | 285| |#if (HAVE_SYS_TIME_H && HAVE_TIME_H) | | 286| |# define TIME_WITH_SYS_TIME 1 | | 287| |#endif | | 288| |#endif | | 289| |#endif | | 290| |#if !(LZO_CFG_AUTO_NO_FUNCTIONS) | | 291| |#if (LZO_LIBC_NAKED) | | 292| |#elif (LZO_LIBC_FREESTANDING) | | 293| |#elif (LZO_LIBC_MOSTLY_FREESTANDING) | | 294| |# define HAVE_LONGJMP 1 | | 295| |# define HAVE_MEMCMP 1 | | 296| |# define HAVE_MEMCPY 1 | | 297| |# define HAVE_MEMMOVE 1 | | 298| |# define HAVE_MEMSET 1 | | 299| |# define HAVE_SETJMP 1 | | 300| |#else | | 301| |#define HAVE_ACCESS 1 | | 302| |#define HAVE_ALLOCA 1 | | 303| |#define HAVE_ATEXIT 1 | | 304| |#define HAVE_ATOI 1 | | 305| |#define HAVE_ATOL 1 | | 306| |#define HAVE_CHMOD 1 | | 307| |#define HAVE_CHOWN 1 | | 308| |#define HAVE_CTIME 1 | | 309| |#define HAVE_DIFFTIME 1 | | 310| |#define HAVE_FILENO 1 | | 311| |#define HAVE_FSTAT 1 | | 312| |#define HAVE_GETENV 1 | | 313| |#define HAVE_GETTIMEOFDAY 1 | | 314| |#define HAVE_GMTIME 1 | | 315| |#define HAVE_ISATTY 1 | | 316| |#define HAVE_LOCALTIME 1 | | 317| |#define HAVE_LONGJMP 1 | | 318| |#define HAVE_LSTAT 1 | | 319| |#define HAVE_MEMCMP 1 | | 320| |#define HAVE_MEMCPY 1 | | 321| |#define HAVE_MEMMOVE 1 | | 322| |#define HAVE_MEMSET 1 | | 323| |#define HAVE_MKDIR 1 | | 324| |#define HAVE_MKTIME 1 | | 325| |#define HAVE_QSORT 1 | | 326| |#define HAVE_RAISE 1 | | 327| |#define HAVE_RMDIR 1 | | 328| |#define HAVE_SETJMP 1 | | 329| |#define HAVE_SIGNAL 1 | | 330| |#define HAVE_SNPRINTF 1 | | 331| |#define HAVE_STAT 1 | | 332| |#define HAVE_STRCHR 1 | | 333| |#define HAVE_STRDUP 1 | | 334| |#define HAVE_STRERROR 1 | | 335| |#define HAVE_STRFTIME 1 | | 336| |#define HAVE_STRRCHR 1 | | 337| |#define HAVE_STRSTR 1 | | 338| |#define HAVE_TIME 1 | | 339| |#define HAVE_UMASK 1 | | 340| |#define HAVE_UTIME 1 | | 341| |#define HAVE_VSNPRINTF 1 | | 342| |#if (LZO_OS_BEOS || LZO_OS_CYGWIN || LZO_OS_POSIX || LZO_OS_QNX || LZO_OS_VMS) | | 343| |# define HAVE_STRCASECMP 1 | | 344| |# define HAVE_STRNCASECMP 1 | | 345| |#elif (LZO_OS_WIN32 && LZO_CC_GNUC) && defined(__PW32__) | | 346| |# define HAVE_STRCASECMP 1 | | 347| |# define HAVE_STRNCASECMP 1 | | 348| |#else | | 349| |# define HAVE_STRICMP 1 | | 350| |# define HAVE_STRNICMP 1 | | 351| |#endif | | 352| |#if (LZO_OS_POSIX) | | 353| |# if (LZO_OS_POSIX_AIX) | | 354| |# define HAVE_GETRUSAGE 1 | | 355| |# elif (LZO_OS_POSIX_DARWIN && LZO_LIBC_MSL) | | 356| |# undef HAVE_CHOWN | | 357| |# undef HAVE_LSTAT | | 358| |# elif (LZO_OS_POSIX_UNICOS) | | 359| |# undef HAVE_ALLOCA | | 360| |# undef HAVE_SNPRINTF | | 361| |# undef HAVE_VSNPRINTF | | 362| |# endif | | 363| |# if (LZO_CC_TINYC) | | 364| |# undef HAVE_ALLOCA | | 365| |# endif | | 366| |# if (LZO_LIBC_DIETLIBC || LZO_LIBC_GLIBC || LZO_LIBC_UCLIBC) | | 367| |# define HAVE_GETRUSAGE 1 | | 368| |# define HAVE_GETPAGESIZE 1 | | 369| |# define HAVE_MMAP 1 | | 370| |# define HAVE_MPROTECT 1 | | 371| |# define HAVE_MUNMAP 1 | | 372| |# endif | | 373| |#elif (LZO_OS_CYGWIN) | | 374| |# if (LZO_CC_GNUC < 0x025a00ul) | | 375| |# undef HAVE_GETTIMEOFDAY | | 376| |# undef HAVE_LSTAT | | 377| |# endif | | 378| |# if (LZO_CC_GNUC < 0x025f00ul) | | 379| |# undef HAVE_SNPRINTF | | 380| |# undef HAVE_VSNPRINTF | | 381| |# endif | | 382| |#elif (LZO_OS_EMX) | | 383| |# undef HAVE_CHOWN | | 384| |# undef HAVE_LSTAT | | 385| |#elif (LZO_ARCH_M68K && LZO_OS_TOS && LZO_CC_GNUC) | | 386| |# if !defined(__MINT__) | | 387| |# undef HAVE_SNPRINTF | | 388| |# undef HAVE_VSNPRINTF | | 389| |# endif | | 390| |#elif (LZO_ARCH_M68K && LZO_OS_TOS && (LZO_CC_PUREC || LZO_CC_TURBOC)) | | 391| |# undef HAVE_ALLOCA | | 392| |# undef HAVE_ACCESS | | 393| |# undef HAVE_CHMOD | | 394| |# undef HAVE_CHOWN | | 395| |# undef HAVE_FSTAT | | 396| |# undef HAVE_GETTIMEOFDAY | | 397| |# undef HAVE_LSTAT | | 398| |# undef HAVE_SNPRINTF | | 399| |# undef HAVE_UMASK | | 400| |# undef HAVE_UTIME | | 401| |# undef HAVE_VSNPRINTF | | 402| |#endif | | 403| |#if (LZO_OS_DOS16 || LZO_OS_DOS32 || LZO_OS_OS2 || LZO_OS_OS216 || LZO_OS_WIN16 || LZO_OS_WIN32 || LZO_OS_WIN64) | | 404| |#undef HAVE_CHOWN | | 405| |#undef HAVE_GETTIMEOFDAY | | 406| |#undef HAVE_LSTAT | | 407| |#undef HAVE_UMASK | | 408| |#if (LZO_CC_AZTECC) | | 409| |# undef HAVE_ALLOCA | | 410| |# undef HAVE_DIFFTIME | | 411| |# undef HAVE_FSTAT | | 412| |# undef HAVE_STRDUP | | 413| |# undef HAVE_SNPRINTF | | 414| |# undef HAVE_UTIME | | 415| |# undef HAVE_VSNPRINTF | | 416| |#elif (LZO_CC_BORLANDC) | | 417| |# if (__BORLANDC__ < 0x0400) | | 418| |# undef HAVE_ALLOCA | | 419| |# undef HAVE_UTIME | | 420| |# endif | | 421| |# if ((__BORLANDC__ < 0x0410) && LZO_OS_WIN16) | | 422| |# undef HAVE_ALLOCA | | 423| |# endif | | 424| |# if (__BORLANDC__ < 0x0550) | | 425| |# undef HAVE_SNPRINTF | | 426| |# undef HAVE_VSNPRINTF | | 427| |# endif | | 428| |#elif (LZO_CC_DMC) | | 429| |# if (LZO_OS_WIN16) | | 430| |# undef HAVE_ALLOCA | | 431| |# endif | | 432| |# define snprintf _snprintf | | 433| |# define vsnprintf _vsnprintf | | 434| |#elif (LZO_OS_DOS32 && LZO_CC_GNUC) && defined(__DJGPP__) | | 435| |# undef HAVE_SNPRINTF | | 436| |# undef HAVE_VSNPRINTF | | 437| |#elif (LZO_OS_DOS32 && LZO_CC_HIGHC) | | 438| |# undef HAVE_SNPRINTF | | 439| |# undef HAVE_VSNPRINTF | | 440| |#elif (LZO_CC_GHS) | | 441| |# undef HAVE_ALLOCA | | 442| |# ifndef snprintf | | 443| |# define snprintf _snprintf | | 444| |# endif | | 445| |# ifndef vsnprintf | | 446| |# define vsnprintf _vsnprintf | | 447| |# endif | | 448| |#elif (LZO_CC_IBMC) | | 449| |# undef HAVE_SNPRINTF | | 450| |# undef HAVE_VSNPRINTF | | 451| |#elif (LZO_CC_CLANG_MSC || LZO_CC_INTELC_MSC) | | 452| |# ifndef snprintf | | 453| |# define snprintf _snprintf | | 454| |# endif | | 455| |# ifndef vsnprintf | | 456| |# define vsnprintf _vsnprintf | | 457| |# endif | | 458| |#elif (LZO_CC_LCCWIN32) | | 459| |# define utime _utime | | 460| |#elif (LZO_CC_CLANG_C2 || LZO_CC_MSC) | | 461| |# if (_MSC_VER < 600) | | 462| |# undef HAVE_STRFTIME | | 463| |# endif | | 464| |# if (_MSC_VER < 700) | | 465| |# undef HAVE_SNPRINTF | | 466| |# undef HAVE_VSNPRINTF | | 467| |# elif (_MSC_VER < 1500) | | 468| |# ifndef snprintf | | 469| |# define snprintf _snprintf | | 470| |# endif | | 471| |# ifndef vsnprintf | | 472| |# define vsnprintf _vsnprintf | | 473| |# endif | | 474| |# elif (_MSC_VER < 1900) | | 475| |# ifndef snprintf | | 476| |# define snprintf _snprintf | | 477| |# endif | | 478| |# endif | | 479| |# if ((_MSC_VER < 800) && LZO_OS_WIN16) | | 480| |# undef HAVE_ALLOCA | | 481| |# endif | | 482| |# if (LZO_ARCH_I086) && defined(__cplusplus) | | 483| |# undef HAVE_LONGJMP | | 484| |# undef HAVE_SETJMP | | 485| |# endif | | 486| |#elif (LZO_OS_WIN32 && LZO_CC_GNUC) && defined(__MINGW32__) | | 487| |# if (LZO_CC_GNUC < 0x025f00ul) | | 488| |# undef HAVE_SNPRINTF | | 489| |# undef HAVE_VSNPRINTF | | 490| |# else | | 491| |# define snprintf _snprintf | | 492| |# define vsnprintf _vsnprintf | | 493| |# endif | | 494| |#elif (LZO_OS_WIN32 && LZO_LIBC_MSL) | | 495| |# if (__MSL__ < 0x8000ul) | | 496| |# undef HAVE_CHMOD | | 497| |# endif | | 498| |#elif (LZO_CC_NDPC) | | 499| |# undef HAVE_ALLOCA | | 500| |# undef HAVE_SNPRINTF | | 501| |# undef HAVE_STRNICMP | | 502| |# undef HAVE_UTIME | | 503| |# undef HAVE_VSNPRINTF | | 504| |# if defined(__cplusplus) | | 505| |# undef HAVE_STAT | | 506| |# endif | | 507| |#elif (LZO_CC_PACIFICC) | | 508| |# undef HAVE_ACCESS | | 509| |# undef HAVE_ALLOCA | | 510| |# undef HAVE_CHMOD | | 511| |# undef HAVE_DIFFTIME | | 512| |# undef HAVE_FSTAT | | 513| |# undef HAVE_MKTIME | | 514| |# undef HAVE_RAISE | | 515| |# undef HAVE_SNPRINTF | | 516| |# undef HAVE_STRFTIME | | 517| |# undef HAVE_UTIME | | 518| |# undef HAVE_VSNPRINTF | | 519| |#elif (LZO_OS_WIN32 && LZO_CC_PELLESC) | | 520| |# if (__POCC__ < 280) | | 521| |# define alloca _alloca | | 522| |# undef HAVE_UTIME | | 523| |# endif | | 524| |#elif (LZO_OS_WIN32 && LZO_CC_PGI) && defined(__MINGW32__) | | 525| |# define snprintf _snprintf | | 526| |# define vsnprintf _vsnprintf | | 527| |#elif (LZO_OS_WIN32 && LZO_CC_GNUC) && defined(__PW32__) | | 528| |# undef HAVE_SNPRINTF | | 529| |# undef HAVE_VSNPRINTF | | 530| |#elif (LZO_CC_SYMANTECC) | | 531| |# if (LZO_OS_WIN16 && (LZO_MM_MEDIUM || LZO_MM_LARGE || LZO_MM_HUGE)) | | 532| |# undef HAVE_ALLOCA | | 533| |# endif | | 534| |# if (__SC__ < 0x600) | | 535| |# undef HAVE_SNPRINTF | | 536| |# undef HAVE_VSNPRINTF | | 537| |# else | | 538| |# define snprintf _snprintf | | 539| |# define vsnprintf _vsnprintf | | 540| |# endif | | 541| |# if (__SC__ < 0x700) | | 542| |# undef HAVE_DIFFTIME | | 543| |# undef HAVE_UTIME | | 544| |# endif | | 545| |#elif (LZO_CC_TOPSPEEDC) | | 546| |# undef HAVE_SNPRINTF | | 547| |# undef HAVE_VSNPRINTF | | 548| |#elif (LZO_CC_TURBOC) | | 549| |# undef HAVE_ALLOCA | | 550| |# undef HAVE_SNPRINTF | | 551| |# undef HAVE_VSNPRINTF | | 552| |# if (__TURBOC__ < 0x0200) | | 553| |# undef HAVE_RAISE | | 554| |# undef HAVE_SIGNAL | | 555| |# endif | | 556| |# if (__TURBOC__ < 0x0295) | | 557| |# undef HAVE_MKTIME | | 558| |# undef HAVE_STRFTIME | | 559| |# endif | | 560| |# if (__TURBOC__ < 0x0400) | | 561| |# undef HAVE_UTIME | | 562| |# endif | | 563| |#elif (LZO_CC_WATCOMC) | | 564| |# if (__WATCOMC__ < 1100) | | 565| |# undef HAVE_SNPRINTF | | 566| |# undef HAVE_VSNPRINTF | | 567| |# elif (__WATCOMC__ < 1200) | | 568| |# define snprintf _snprintf | | 569| |# define vsnprintf _vsnprintf | | 570| |# endif | | 571| |#elif (LZO_CC_ZORTECHC) | | 572| |# if (LZO_OS_WIN16 && (LZO_MM_MEDIUM || LZO_MM_LARGE || LZO_MM_HUGE)) | | 573| |# undef HAVE_ALLOCA | | 574| |# endif | | 575| |# undef HAVE_DIFFTIME | | 576| |# undef HAVE_SNPRINTF | | 577| |# undef HAVE_UTIME | | 578| |# undef HAVE_VSNPRINTF | | 579| |#endif | | 580| |#endif | | 581| |#if (LZO_OS_CONSOLE) | | 582| |# undef HAVE_ACCESS | | 583| |# undef HAVE_CHMOD | | 584| |# undef HAVE_CHOWN | | 585| |# undef HAVE_GETTIMEOFDAY | | 586| |# undef HAVE_LSTAT | | 587| |# undef HAVE_TIME | | 588| |# undef HAVE_UMASK | | 589| |# undef HAVE_UTIME | | 590| |#endif | | 591| |#if (LZO_LIBC_ISOC90 || LZO_LIBC_ISOC99) | | 592| |# undef HAVE_ACCESS | | 593| |# undef HAVE_CHMOD | | 594| |# undef HAVE_CHOWN | | 595| |# undef HAVE_FILENO | | 596| |# undef HAVE_FSTAT | | 597| |# undef HAVE_GETTIMEOFDAY | | 598| |# undef HAVE_LSTAT | | 599| |# undef HAVE_STAT | | 600| |# undef HAVE_UMASK | | 601| |# undef HAVE_UTIME | | 602| |# if 1 | | 603| |# undef HAVE_ALLOCA | | 604| |# undef HAVE_ISATTY | | 605| |# undef HAVE_MKDIR | | 606| |# undef HAVE_RMDIR | | 607| |# undef HAVE_STRDUP | | 608| |# undef HAVE_STRICMP | | 609| |# undef HAVE_STRNICMP | | 610| |# endif | | 611| |#endif | | 612| |#endif | | 613| |#endif | | 614| |#if !(LZO_CFG_AUTO_NO_SIZES) | | 615| |#if !defined(SIZEOF_SHORT) && defined(LZO_SIZEOF_SHORT) | | 616| |# define SIZEOF_SHORT LZO_SIZEOF_SHORT | | 617| |#endif | | 618| |#if !defined(SIZEOF_INT) && defined(LZO_SIZEOF_INT) | | 619| |# define SIZEOF_INT LZO_SIZEOF_INT | | 620| |#endif | | 621| |#if !defined(SIZEOF_LONG) && defined(LZO_SIZEOF_LONG) | | 622| |# define SIZEOF_LONG LZO_SIZEOF_LONG | | 623| |#endif | | 624| |#if !defined(SIZEOF_LONG_LONG) && defined(LZO_SIZEOF_LONG_LONG) | | 625| |# define SIZEOF_LONG_LONG LZO_SIZEOF_LONG_LONG | | 626| |#endif | | 627| |#if !defined(SIZEOF___INT32) && defined(LZO_SIZEOF___INT32) | | 628| |# define SIZEOF___INT32 LZO_SIZEOF___INT32 | | 629| |#endif | | 630| |#if !defined(SIZEOF___INT64) && defined(LZO_SIZEOF___INT64) | | 631| |# define SIZEOF___INT64 LZO_SIZEOF___INT64 | | 632| |#endif | | 633| |#if !defined(SIZEOF_VOID_P) && defined(LZO_SIZEOF_VOID_P) | | 634| |# define SIZEOF_VOID_P LZO_SIZEOF_VOID_P | | 635| |#endif | | 636| |#if !defined(SIZEOF_SIZE_T) && defined(LZO_SIZEOF_SIZE_T) | | 637| |# define SIZEOF_SIZE_T LZO_SIZEOF_SIZE_T | | 638| |#endif | | 639| |#if !defined(SIZEOF_PTRDIFF_T) && defined(LZO_SIZEOF_PTRDIFF_T) | | 640| |# define SIZEOF_PTRDIFF_T LZO_SIZEOF_PTRDIFF_T | | 641| |#endif | | 642| |#endif | | 643| |#if (HAVE_SIGNAL) && !defined(RETSIGTYPE) | | 644| |# define RETSIGTYPE void | | 645| |#endif | | 646| |#endif | | 647| |#if !(LZO_CFG_SKIP_LZO_TYPES) | | 648| |#if 1 && !defined(lzo_signo_t) && defined(__linux__) && defined(__dietlibc__) && (LZO_SIZEOF_INT != 4) | | 649| |# define lzo_signo_t lzo_int32e_t | | 650| |#endif | | 651| |#if !defined(lzo_signo_t) | | 652| |# define lzo_signo_t int | | 653| |#endif | | 654| |#if defined(__cplusplus) | | 655| |extern "C" { | | 656| |#endif | | 657| |#if (LZO_BROKEN_CDECL_ALT_SYNTAX) | | 658| |typedef void __lzo_cdecl_sighandler (*lzo_sighandler_t)(lzo_signo_t); | | 659| |#else | | 660| |typedef void (__lzo_cdecl_sighandler *lzo_sighandler_t)(lzo_signo_t); | | 661| |#endif | | 662| |#if defined(__cplusplus) | | 663| |} | | 664| |#endif | | 665| |#endif | | 666| |#endif | | 667| |#if defined(LZO_WANT_ACC_INCD_H) | | 668| |# undef LZO_WANT_ACC_INCD_H | | 669| |#ifndef __LZO_INCD_H_INCLUDED | | 670| |#define __LZO_INCD_H_INCLUDED 1 | | 671| |#if (LZO_LIBC_NAKED) | | 672| |#ifndef __LZO_FALLBACK_STDDEF_H_INCLUDED | | 673| |#define __LZO_FALLBACK_STDDEF_H_INCLUDED 1 | | 674| |#if defined(__PTRDIFF_TYPE__) | | 675| |typedef __PTRDIFF_TYPE__ lzo_fallback_ptrdiff_t; | | 676| |#elif defined(__MIPS_PSX2__) | | 677| |typedef int lzo_fallback_ptrdiff_t; | | 678| |#else | | 679| |typedef long lzo_fallback_ptrdiff_t; | | 680| |#endif | | 681| |#if defined(__SIZE_TYPE__) | | 682| |typedef __SIZE_TYPE__ lzo_fallback_size_t; | | 683| |#elif defined(__MIPS_PSX2__) | | 684| |typedef unsigned int lzo_fallback_size_t; | | 685| |#else | | 686| |typedef unsigned long lzo_fallback_size_t; | | 687| |#endif | | 688| |#if !defined(ptrdiff_t) | | 689| |typedef lzo_fallback_ptrdiff_t ptrdiff_t; | | 690| |#ifndef _PTRDIFF_T_DEFINED | | 691| |#define _PTRDIFF_T_DEFINED 1 | | 692| |#endif | | 693| |#endif | | 694| |#if !defined(size_t) | | 695| |typedef lzo_fallback_size_t size_t; | | 696| |#ifndef _SIZE_T_DEFINED | | 697| |#define _SIZE_T_DEFINED 1 | | 698| |#endif | | 699| |#endif | | 700| |#if !defined(__cplusplus) && !defined(wchar_t) | | 701| |typedef unsigned short wchar_t; | | 702| |#ifndef _WCHAR_T_DEFINED | | 703| |#define _WCHAR_T_DEFINED 1 | | 704| |#endif | | 705| |#endif | | 706| |#ifndef NULL | | 707| |#if defined(__cplusplus) && defined(__GNUC__) && (__GNUC__ >= 4) | | 708| |#define NULL __null | | 709| |#elif defined(__cplusplus) | | 710| |#define NULL 0 | | 711| |#else | | 712| |#define NULL ((void*)0) | | 713| |#endif | | 714| |#endif | | 715| |#ifndef offsetof | | 716| |#define offsetof(s,m) ((size_t)((ptrdiff_t)&(((s*)0)->m))) | | 717| |#endif | | 718| |#endif | | 719| |#elif (LZO_LIBC_FREESTANDING) | | 720| |# if defined(HAVE_STDDEF_H) && (HAVE_STDDEF_H+0) | | 721| |# include | | 722| |# endif | | 723| |# if defined(HAVE_STDINT_H) && (HAVE_STDINT_H+0) | | 724| |# include | | 725| |# endif | | 726| |#elif (LZO_LIBC_MOSTLY_FREESTANDING) | | 727| |# if defined(HAVE_STDIO_H) && (HAVE_STDIO_H+0) | | 728| |# include | | 729| |# endif | | 730| |# if defined(HAVE_STDDEF_H) && (HAVE_STDDEF_H+0) | | 731| |# include | | 732| |# endif | | 733| |# if defined(HAVE_STDINT_H) && (HAVE_STDINT_H+0) | | 734| |# include | | 735| |# endif | | 736| |#else | | 737| |#include | | 738| |#if defined(HAVE_TIME_H) && (HAVE_TIME_H+0) && defined(__MSL__) && defined(__cplusplus) | | 739| |# include | | 740| |#endif | | 741| |#if defined(HAVE_SYS_TYPES_H) && (HAVE_SYS_TYPES_H+0) | | 742| |# include | | 743| |#endif | | 744| |#if defined(HAVE_SYS_STAT_H) && (HAVE_SYS_STAT_H+0) | | 745| |# include | | 746| |#endif | | 747| |#if defined(STDC_HEADERS) && (STDC_HEADERS+0) | | 748| |# include | | 749| |#elif defined(HAVE_STDLIB_H) && (HAVE_STDLIB_H+0) | | 750| |# include | | 751| |#endif | | 752| |#include | | 753| |#if defined(HAVE_STRING_H) && (HAVE_STRING_H+0) | | 754| |# if defined(STDC_HEADERS) && (STDC_HEADERS+0) | | 755| |# elif defined(HAVE_MEMORY_H) && (HAVE_MEMORY_H+0) | | 756| |# include | | 757| |# endif | | 758| |# include | | 759| |#endif | | 760| |#if defined(HAVE_STRINGS_H) && (HAVE_STRINGS_H+0) | | 761| |# include | | 762| |#endif | | 763| |#if defined(HAVE_INTTYPES_H) && (HAVE_INTTYPES_H+0) | | 764| |# include | | 765| |#endif | | 766| |#if defined(HAVE_STDINT_H) && (HAVE_STDINT_H+0) | | 767| |# include | | 768| |#endif | | 769| |#if defined(HAVE_UNISTD_H) && (HAVE_UNISTD_H+0) | | 770| |# include | | 771| |#endif | | 772| |#endif | | 773| |#endif | | 774| |#endif | | 775| |#if defined(LZO_WANT_ACC_INCE_H) | | 776| |# undef LZO_WANT_ACC_INCE_H | | 777| |#ifndef __LZO_INCE_H_INCLUDED | | 778| |#define __LZO_INCE_H_INCLUDED 1 | | 779| |#if (LZO_LIBC_NAKED) | | 780| |#elif (LZO_LIBC_FREESTANDING) | | 781| |#elif (LZO_LIBC_MOSTLY_FREESTANDING) | | 782| |# if (HAVE_SETJMP_H) | | 783| |# include | | 784| |# endif | | 785| |#else | | 786| |#if (HAVE_STDARG_H) | | 787| |# include | | 788| |#endif | | 789| |#if (HAVE_CTYPE_H) | | 790| |# include | | 791| |#endif | | 792| |#if (HAVE_ERRNO_H) | | 793| |# include | | 794| |#endif | | 795| |#if (HAVE_MALLOC_H) | | 796| |# include | | 797| |#endif | | 798| |#if (HAVE_ALLOCA_H) | | 799| |# include | | 800| |#endif | | 801| |#if (HAVE_FCNTL_H) | | 802| |# include | | 803| |#endif | | 804| |#if (HAVE_DIRENT_H) | | 805| |# include | | 806| |#endif | | 807| |#if (HAVE_SETJMP_H) | | 808| |# include | | 809| |#endif | | 810| |#if (HAVE_SIGNAL_H) | | 811| |# include | | 812| |#endif | | 813| |#if (HAVE_SYS_TIME_H && HAVE_TIME_H) | | 814| |# include | | 815| |# include | | 816| |#elif (HAVE_TIME_H) | | 817| |# include | | 818| |#endif | | 819| |#if (HAVE_UTIME_H) | | 820| |# include | | 821| |#elif (HAVE_SYS_UTIME_H) | | 822| |# include | | 823| |#endif | | 824| |#if (HAVE_IO_H) | | 825| |# include | | 826| |#endif | | 827| |#if (HAVE_DOS_H) | | 828| |# include | | 829| |#endif | | 830| |#if (HAVE_DIRECT_H) | | 831| |# include | | 832| |#endif | | 833| |#if (HAVE_SHARE_H) | | 834| |# include | | 835| |#endif | | 836| |#if (LZO_CC_NDPC) | | 837| |# include | | 838| |#endif | | 839| |#if defined(__TOS__) && (defined(__PUREC__) || defined(__TURBOC__)) | | 840| |# include | | 841| |#endif | | 842| |#endif | | 843| |#endif | | 844| |#endif | | 845| |#if defined(LZO_WANT_ACC_INCI_H) | | 846| |# undef LZO_WANT_ACC_INCI_H | | 847| |#ifndef __LZO_INCI_H_INCLUDED | | 848| |#define __LZO_INCI_H_INCLUDED 1 | | 849| |#if (LZO_LIBC_NAKED) | | 850| |#elif (LZO_LIBC_FREESTANDING) | | 851| |#elif (LZO_LIBC_MOSTLY_FREESTANDING) | | 852| |#else | | 853| |#if (LZO_OS_TOS && (LZO_CC_PUREC || LZO_CC_TURBOC)) | | 854| |# include | | 855| |#elif (LZO_HAVE_WINDOWS_H) | | 856| |# if 1 && !defined(WIN32_LEAN_AND_MEAN) | | 857| |# define WIN32_LEAN_AND_MEAN 1 | | 858| |# endif | | 859| |# if 1 && !defined(_WIN32_WINNT) | | 860| |# define _WIN32_WINNT 0x0400 | | 861| |# endif | | 862| |# include | | 863| |# if (LZO_CC_BORLANDC || LZO_CC_TURBOC) | | 864| |# include | | 865| |# endif | | 866| |#elif (LZO_OS_DOS16 || LZO_OS_DOS32 || LZO_OS_WIN16) | | 867| |# if (LZO_CC_AZTECC) | | 868| |# include | | 869| |# include | | 870| |# elif (LZO_CC_BORLANDC || LZO_CC_TURBOC) | | 871| |# include | | 872| |# include | | 873| |# elif (LZO_OS_DOS32 && LZO_CC_GNUC) && defined(__DJGPP__) | | 874| |# include | | 875| |# elif (LZO_CC_PACIFICC) | | 876| |# include | | 877| |# include | | 878| |# include | | 879| |# elif (LZO_CC_WATCOMC) | | 880| |# include | | 881| |# endif | | 882| |#elif (LZO_OS_OS216) | | 883| |# if (LZO_CC_WATCOMC) | | 884| |# include | | 885| |# endif | | 886| |#endif | | 887| |#if (HAVE_SYS_MMAN_H) | | 888| |# include | | 889| |#endif | | 890| |#if (HAVE_SYS_RESOURCE_H) | | 891| |# include | | 892| |#endif | | 893| |#if (LZO_OS_DOS16 || LZO_OS_OS216 || LZO_OS_WIN16) | | 894| |# if defined(FP_OFF) | | 895| |# define LZO_PTR_FP_OFF(x) FP_OFF(x) | | 896| |# elif defined(_FP_OFF) | | 897| |# define LZO_PTR_FP_OFF(x) _FP_OFF(x) | | 898| |# else | | 899| |# define LZO_PTR_FP_OFF(x) (((const unsigned __far*)&(x))[0]) | | 900| |# endif | | 901| |# if defined(FP_SEG) | | 902| |# define LZO_PTR_FP_SEG(x) FP_SEG(x) | | 903| |# elif defined(_FP_SEG) | | 904| |# define LZO_PTR_FP_SEG(x) _FP_SEG(x) | | 905| |# else | | 906| |# define LZO_PTR_FP_SEG(x) (((const unsigned __far*)&(x))[1]) | | 907| |# endif | | 908| |# if defined(MK_FP) | | 909| |# define LZO_PTR_MK_FP(s,o) MK_FP(s,o) | | 910| |# elif defined(_MK_FP) | | 911| |# define LZO_PTR_MK_FP(s,o) _MK_FP(s,o) | | 912| |# else | | 913| |# define LZO_PTR_MK_FP(s,o) ((void __far*)(((unsigned long)(s)<<16)+(unsigned)(o))) | | 914| |# endif | | 915| |# if 0 | | 916| |# undef LZO_PTR_FP_OFF | | 917| |# undef LZO_PTR_FP_SEG | | 918| |# undef LZO_PTR_MK_FP | | 919| |# define LZO_PTR_FP_OFF(x) (((const unsigned __far*)&(x))[0]) | | 920| |# define LZO_PTR_FP_SEG(x) (((const unsigned __far*)&(x))[1]) | | 921| |# define LZO_PTR_MK_FP(s,o) ((void __far*)(((unsigned long)(s)<<16)+(unsigned)(o))) | | 922| |# endif | | 923| |#endif | | 924| |#endif | | 925| |#endif | | 926| |#endif | | 927| |#if defined(LZO_WANT_ACC_LIB_H) | | 928| |# undef LZO_WANT_ACC_LIB_H | | 929| |#ifndef __LZO_LIB_H_INCLUDED | | 930| |#define __LZO_LIB_H_INCLUDED 1 | | 931| |#if !defined(__LZOLIB_FUNCNAME) | | 932| |# define __LZOLIB_FUNCNAME(f) f | | 933| |#endif | | 934| |#if !defined(LZOLIB_EXTERN) | | 935| |# define LZOLIB_EXTERN(r,f) extern r __LZOLIB_FUNCNAME(f) | | 936| |#endif | | 937| |#if !defined(LZOLIB_EXTERN_NOINLINE) | | 938| |# if defined(__lzo_noinline) | | 939| |# define LZOLIB_EXTERN_NOINLINE(r,f) extern __lzo_noinline r __LZOLIB_FUNCNAME(f) | | 940| |# else | | 941| |# define LZOLIB_EXTERN_NOINLINE(r,f) extern r __LZOLIB_FUNCNAME(f) | | 942| |# endif | | 943| |#endif | | 944| |#if (LZO_SIZEOF_LONG > LZO_SIZEOF_VOID_P) | | 945| |# define lzolib_handle_t long | | 946| |#else | | 947| |# define lzolib_handle_t lzo_intptr_t | | 948| |#endif | | 949| |#if 0 | | 950| |LZOLIB_EXTERN(int, lzo_ascii_digit) (int); | | 951| |LZOLIB_EXTERN(int, lzo_ascii_islower) (int); | | 952| |LZOLIB_EXTERN(int, lzo_ascii_isupper) (int); | | 953| |LZOLIB_EXTERN(int, lzo_ascii_tolower) (int); | | 954| |LZOLIB_EXTERN(int, lzo_ascii_toupper) (int); | | 955| |LZOLIB_EXTERN(int, lzo_ascii_utolower) (int); | | 956| |LZOLIB_EXTERN(int, lzo_ascii_utoupper) (int); | | 957| |#endif | | 958| |#define lzo_ascii_isdigit(c) ((LZO_ICAST(unsigned, c) - 48) < 10) | | 959| |#define lzo_ascii_islower(c) ((LZO_ICAST(unsigned, c) - 97) < 26) | | 960| |#define lzo_ascii_isupper(c) ((LZO_ICAST(unsigned, c) - 65) < 26) | | 961| |#define lzo_ascii_tolower(c) (LZO_ICAST(int, c) + (lzo_ascii_isupper(c) << 5)) | | 962| |#define lzo_ascii_toupper(c) (LZO_ICAST(int, c) - (lzo_ascii_islower(c) << 5)) | | 963| |#define lzo_ascii_utolower(c) lzo_ascii_tolower(LZO_ITRUNC(unsigned char, c)) | | 964| |#define lzo_ascii_utoupper(c) lzo_ascii_toupper(LZO_ITRUNC(unsigned char, c)) | | 965| |#ifndef lzo_hsize_t | | 966| |#if (LZO_HAVE_MM_HUGE_PTR) | | 967| |# define lzo_hsize_t unsigned long | | 968| |# define lzo_hvoid_p void __huge * | | 969| |# define lzo_hchar_p char __huge * | | 970| |# define lzo_hchar_pp char __huge * __huge * | | 971| |# define lzo_hbyte_p unsigned char __huge * | | 972| |#else | | 973| |# define lzo_hsize_t size_t | | 974| |# define lzo_hvoid_p void * | | 975| |# define lzo_hchar_p char * | | 976| |# define lzo_hchar_pp char ** | | 977| |# define lzo_hbyte_p unsigned char * | | 978| |#endif | | 979| |#endif | | 980| |LZOLIB_EXTERN(lzo_hvoid_p, lzo_halloc) (lzo_hsize_t); | | 981| |LZOLIB_EXTERN(void, lzo_hfree) (lzo_hvoid_p); | | 982| |#if (LZO_OS_DOS16 || LZO_OS_OS216) | | 983| |LZOLIB_EXTERN(void __far*, lzo_dos_alloc) (unsigned long); | | 984| |LZOLIB_EXTERN(int, lzo_dos_free) (void __far*); | | 985| |#endif | | 986| |LZOLIB_EXTERN(int, lzo_hmemcmp) (const lzo_hvoid_p, const lzo_hvoid_p, lzo_hsize_t); | | 987| |LZOLIB_EXTERN(lzo_hvoid_p, lzo_hmemcpy) (lzo_hvoid_p, const lzo_hvoid_p, lzo_hsize_t); | | 988| |LZOLIB_EXTERN(lzo_hvoid_p, lzo_hmemmove) (lzo_hvoid_p, const lzo_hvoid_p, lzo_hsize_t); | | 989| |LZOLIB_EXTERN(lzo_hvoid_p, lzo_hmemset) (lzo_hvoid_p, int, lzo_hsize_t); | | 990| |LZOLIB_EXTERN(lzo_hsize_t, lzo_hstrlen) (const lzo_hchar_p); | | 991| |LZOLIB_EXTERN(int, lzo_hstrcmp) (const lzo_hchar_p, const lzo_hchar_p); | | 992| |LZOLIB_EXTERN(int, lzo_hstrncmp)(const lzo_hchar_p, const lzo_hchar_p, lzo_hsize_t); | | 993| |LZOLIB_EXTERN(int, lzo_ascii_hstricmp) (const lzo_hchar_p, const lzo_hchar_p); | | 994| |LZOLIB_EXTERN(int, lzo_ascii_hstrnicmp)(const lzo_hchar_p, const lzo_hchar_p, lzo_hsize_t); | | 995| |LZOLIB_EXTERN(int, lzo_ascii_hmemicmp) (const lzo_hvoid_p, const lzo_hvoid_p, lzo_hsize_t); | | 996| |LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrstr) (const lzo_hchar_p, const lzo_hchar_p); | | 997| |LZOLIB_EXTERN(lzo_hchar_p, lzo_ascii_hstristr) (const lzo_hchar_p, const lzo_hchar_p); | | 998| |LZOLIB_EXTERN(lzo_hvoid_p, lzo_hmemmem) (const lzo_hvoid_p, lzo_hsize_t, const lzo_hvoid_p, lzo_hsize_t); | | 999| |LZOLIB_EXTERN(lzo_hvoid_p, lzo_ascii_hmemimem) (const lzo_hvoid_p, lzo_hsize_t, const lzo_hvoid_p, lzo_hsize_t); | | 1000| |LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrcpy) (lzo_hchar_p, const lzo_hchar_p); | | 1001| |LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrcat) (lzo_hchar_p, const lzo_hchar_p); | | 1002| |LZOLIB_EXTERN(lzo_hsize_t, lzo_hstrlcpy) (lzo_hchar_p, const lzo_hchar_p, lzo_hsize_t); | | 1003| |LZOLIB_EXTERN(lzo_hsize_t, lzo_hstrlcat) (lzo_hchar_p, const lzo_hchar_p, lzo_hsize_t); | | 1004| |LZOLIB_EXTERN(int, lzo_hstrscpy) (lzo_hchar_p, const lzo_hchar_p, lzo_hsize_t); | | 1005| |LZOLIB_EXTERN(int, lzo_hstrscat) (lzo_hchar_p, const lzo_hchar_p, lzo_hsize_t); | | 1006| |LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrccpy) (lzo_hchar_p, const lzo_hchar_p, int); | | 1007| |LZOLIB_EXTERN(lzo_hvoid_p, lzo_hmemccpy) (lzo_hvoid_p, const lzo_hvoid_p, int, lzo_hsize_t); | | 1008| |LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrchr) (const lzo_hchar_p, int); | | 1009| |LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrrchr) (const lzo_hchar_p, int); | | 1010| |LZOLIB_EXTERN(lzo_hchar_p, lzo_ascii_hstrichr) (const lzo_hchar_p, int); | | 1011| |LZOLIB_EXTERN(lzo_hchar_p, lzo_ascii_hstrrichr) (const lzo_hchar_p, int); | | 1012| |LZOLIB_EXTERN(lzo_hvoid_p, lzo_hmemchr) (const lzo_hvoid_p, int, lzo_hsize_t); | | 1013| |LZOLIB_EXTERN(lzo_hvoid_p, lzo_hmemrchr) (const lzo_hvoid_p, int, lzo_hsize_t); | | 1014| |LZOLIB_EXTERN(lzo_hvoid_p, lzo_ascii_hmemichr) (const lzo_hvoid_p, int, lzo_hsize_t); | | 1015| |LZOLIB_EXTERN(lzo_hvoid_p, lzo_ascii_hmemrichr) (const lzo_hvoid_p, int, lzo_hsize_t); | | 1016| |LZOLIB_EXTERN(lzo_hsize_t, lzo_hstrspn) (const lzo_hchar_p, const lzo_hchar_p); | | 1017| |LZOLIB_EXTERN(lzo_hsize_t, lzo_hstrrspn) (const lzo_hchar_p, const lzo_hchar_p); | | 1018| |LZOLIB_EXTERN(lzo_hsize_t, lzo_hstrcspn) (const lzo_hchar_p, const lzo_hchar_p); | | 1019| |LZOLIB_EXTERN(lzo_hsize_t, lzo_hstrrcspn) (const lzo_hchar_p, const lzo_hchar_p); | | 1020| |LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrpbrk) (const lzo_hchar_p, const lzo_hchar_p); | | 1021| |LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrrpbrk) (const lzo_hchar_p, const lzo_hchar_p); | | 1022| |LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrsep) (lzo_hchar_pp, const lzo_hchar_p); | | 1023| |LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrrsep) (lzo_hchar_pp, const lzo_hchar_p); | | 1024| |LZOLIB_EXTERN(lzo_hchar_p, lzo_ascii_hstrlwr) (lzo_hchar_p); | | 1025| |LZOLIB_EXTERN(lzo_hchar_p, lzo_ascii_hstrupr) (lzo_hchar_p); | | 1026| |LZOLIB_EXTERN(lzo_hvoid_p, lzo_ascii_hmemlwr) (lzo_hvoid_p, lzo_hsize_t); | | 1027| |LZOLIB_EXTERN(lzo_hvoid_p, lzo_ascii_hmemupr) (lzo_hvoid_p, lzo_hsize_t); | | 1028| |LZOLIB_EXTERN(lzo_hsize_t, lzo_hfread) (void *, lzo_hvoid_p, lzo_hsize_t); | | 1029| |LZOLIB_EXTERN(lzo_hsize_t, lzo_hfwrite) (void *, const lzo_hvoid_p, lzo_hsize_t); | | 1030| |#if (LZO_HAVE_MM_HUGE_PTR) | | 1031| |LZOLIB_EXTERN(long, lzo_hread) (int, lzo_hvoid_p, long); | | 1032| |LZOLIB_EXTERN(long, lzo_hwrite) (int, const lzo_hvoid_p, long); | | 1033| |#endif | | 1034| |LZOLIB_EXTERN(long, lzo_safe_hread) (int, lzo_hvoid_p, long); | | 1035| |LZOLIB_EXTERN(long, lzo_safe_hwrite) (int, const lzo_hvoid_p, long); | | 1036| |LZOLIB_EXTERN(unsigned, lzo_ua_get_be16) (const lzo_hvoid_p); | | 1037| |LZOLIB_EXTERN(lzo_uint32l_t, lzo_ua_get_be24) (const lzo_hvoid_p); | | 1038| |LZOLIB_EXTERN(lzo_uint32l_t, lzo_ua_get_be32) (const lzo_hvoid_p); | | 1039| |LZOLIB_EXTERN(void, lzo_ua_set_be16) (lzo_hvoid_p, unsigned); | | 1040| |LZOLIB_EXTERN(void, lzo_ua_set_be24) (lzo_hvoid_p, lzo_uint32l_t); | | 1041| |LZOLIB_EXTERN(void, lzo_ua_set_be32) (lzo_hvoid_p, lzo_uint32l_t); | | 1042| |LZOLIB_EXTERN(unsigned, lzo_ua_get_le16) (const lzo_hvoid_p); | | 1043| |LZOLIB_EXTERN(lzo_uint32l_t, lzo_ua_get_le24) (const lzo_hvoid_p); | | 1044| |LZOLIB_EXTERN(lzo_uint32l_t, lzo_ua_get_le32) (const lzo_hvoid_p); | | 1045| |LZOLIB_EXTERN(void, lzo_ua_set_le16) (lzo_hvoid_p, unsigned); | | 1046| |LZOLIB_EXTERN(void, lzo_ua_set_le24) (lzo_hvoid_p, lzo_uint32l_t); | | 1047| |LZOLIB_EXTERN(void, lzo_ua_set_le32) (lzo_hvoid_p, lzo_uint32l_t); | | 1048| |#if defined(lzo_int64l_t) | | 1049| |LZOLIB_EXTERN(lzo_uint64l_t, lzo_ua_get_be64) (const lzo_hvoid_p); | | 1050| |LZOLIB_EXTERN(void, lzo_ua_set_be64) (lzo_hvoid_p, lzo_uint64l_t); | | 1051| |LZOLIB_EXTERN(lzo_uint64l_t, lzo_ua_get_le64) (const lzo_hvoid_p); | | 1052| |LZOLIB_EXTERN(void, lzo_ua_set_le64) (lzo_hvoid_p, lzo_uint64l_t); | | 1053| |#endif | | 1054| |LZOLIB_EXTERN_NOINLINE(short, lzo_vget_short) (short, int); | | 1055| |LZOLIB_EXTERN_NOINLINE(int, lzo_vget_int) (int, int); | | 1056| |LZOLIB_EXTERN_NOINLINE(long, lzo_vget_long) (long, int); | | 1057| |#if defined(lzo_int64l_t) | | 1058| |LZOLIB_EXTERN_NOINLINE(lzo_int64l_t, lzo_vget_lzo_int64l_t) (lzo_int64l_t, int); | | 1059| |#endif | | 1060| |LZOLIB_EXTERN_NOINLINE(lzo_hsize_t, lzo_vget_lzo_hsize_t) (lzo_hsize_t, int); | | 1061| |#if !(LZO_CFG_NO_FLOAT) | | 1062| |LZOLIB_EXTERN_NOINLINE(float, lzo_vget_float) (float, int); | | 1063| |#endif | | 1064| |#if !(LZO_CFG_NO_DOUBLE) | | 1065| |LZOLIB_EXTERN_NOINLINE(double, lzo_vget_double) (double, int); | | 1066| |#endif | | 1067| |LZOLIB_EXTERN_NOINLINE(lzo_hvoid_p, lzo_vget_lzo_hvoid_p) (lzo_hvoid_p, int); | | 1068| |LZOLIB_EXTERN_NOINLINE(const lzo_hvoid_p, lzo_vget_lzo_hvoid_cp) (const lzo_hvoid_p, int); | | 1069| |#if !defined(LZO_FN_PATH_MAX) | | 1070| |#if (LZO_OS_DOS16 || LZO_OS_WIN16) | | 1071| |# define LZO_FN_PATH_MAX 143 | | 1072| |#elif (LZO_OS_DOS32 || LZO_OS_OS2 || LZO_OS_OS216 || LZO_OS_WIN32 || LZO_OS_WIN64) | | 1073| |# define LZO_FN_PATH_MAX 259 | | 1074| |#elif (LZO_OS_TOS) | | 1075| |# define LZO_FN_PATH_MAX 259 | | 1076| |#endif | | 1077| |#endif | | 1078| |#if !defined(LZO_FN_PATH_MAX) | | 1079| |# define LZO_FN_PATH_MAX 1023 | | 1080| |#endif | | 1081| |#if !defined(LZO_FN_NAME_MAX) | | 1082| |#if (LZO_OS_DOS16 || LZO_OS_WIN16) | | 1083| |# define LZO_FN_NAME_MAX 12 | | 1084| |#elif (LZO_ARCH_M68K && LZO_OS_TOS && (LZO_CC_PUREC || LZO_CC_TURBOC)) | | 1085| |# define LZO_FN_NAME_MAX 12 | | 1086| |#elif (LZO_OS_DOS32 && LZO_CC_GNUC) && defined(__DJGPP__) | | 1087| |#elif (LZO_OS_DOS32) | | 1088| |# define LZO_FN_NAME_MAX 12 | | 1089| |#endif | | 1090| |#endif | | 1091| |#if !defined(LZO_FN_NAME_MAX) | | 1092| |# define LZO_FN_NAME_MAX LZO_FN_PATH_MAX | | 1093| |#endif | | 1094| |#define LZO_FNMATCH_NOESCAPE 1 | | 1095| |#define LZO_FNMATCH_PATHNAME 2 | | 1096| |#define LZO_FNMATCH_PATHSTAR 4 | | 1097| |#define LZO_FNMATCH_PERIOD 8 | | 1098| |#define LZO_FNMATCH_ASCII_CASEFOLD 16 | | 1099| |LZOLIB_EXTERN(int, lzo_fnmatch) (const lzo_hchar_p, const lzo_hchar_p, int); | | 1100| |#undef __LZOLIB_USE_OPENDIR | | 1101| |#if (HAVE_DIRENT_H || LZO_CC_WATCOMC) | | 1102| |# define __LZOLIB_USE_OPENDIR 1 | | 1103| |# if (LZO_OS_DOS32 && defined(__BORLANDC__)) | | 1104| |# elif (LZO_OS_DOS32 && LZO_CC_GNUC) && defined(__DJGPP__) | | 1105| |# elif (LZO_OS_OS2 || LZO_OS_OS216) | | 1106| |# elif (LZO_ARCH_M68K && LZO_OS_TOS && LZO_CC_GNUC) | | 1107| |# elif (LZO_OS_WIN32 && !(LZO_HAVE_WINDOWS_H)) | | 1108| |# elif (LZO_OS_DOS16 || LZO_OS_DOS32 || LZO_OS_OS2 || LZO_OS_OS216 || LZO_OS_TOS || LZO_OS_WIN16 || LZO_OS_WIN32 || LZO_OS_WIN64) | | 1109| |# undef __LZOLIB_USE_OPENDIR | | 1110| |# endif | | 1111| |#endif | | 1112| |typedef struct | | 1113| |{ | | 1114| |#if defined(__LZOLIB_USE_OPENDIR) | | 1115| | void* u_dirp; | | 1116| |# if (LZO_CC_WATCOMC) | | 1117| | unsigned short f_time; | | 1118| | unsigned short f_date; | | 1119| | unsigned long f_size; | | 1120| |# endif | | 1121| | char f_name[LZO_FN_NAME_MAX+1]; | | 1122| |#elif (LZO_OS_WIN32 || LZO_OS_WIN64) | | 1123| | lzolib_handle_t u_handle; | | 1124| | unsigned f_attr; | | 1125| | unsigned f_size_low; | | 1126| | unsigned f_size_high; | | 1127| | char f_name[LZO_FN_NAME_MAX+1]; | | 1128| |#elif (LZO_OS_DOS16 || LZO_OS_DOS32 || LZO_OS_TOS || LZO_OS_WIN16) | | 1129| | char u_dta[21]; | | 1130| | unsigned char f_attr; | | 1131| | unsigned short f_time; | | 1132| | unsigned short f_date; | | 1133| | unsigned short f_size_low; | | 1134| | unsigned short f_size_high; | | 1135| | char f_name[LZO_FN_NAME_MAX+1]; | | 1136| | char u_dirp; | | 1137| |#else | | 1138| | void* u_dirp; | | 1139| | char f_name[LZO_FN_NAME_MAX+1]; | | 1140| |#endif | | 1141| |} lzo_dir_t; | | 1142| |#ifndef lzo_dir_p | | 1143| |#define lzo_dir_p lzo_dir_t * | | 1144| |#endif | | 1145| |LZOLIB_EXTERN(int, lzo_opendir) (lzo_dir_p, const char*); | | 1146| |LZOLIB_EXTERN(int, lzo_readdir) (lzo_dir_p); | | 1147| |LZOLIB_EXTERN(int, lzo_closedir) (lzo_dir_p); | | 1148| |#if (LZO_CC_GNUC) && (defined(__CYGWIN__) || defined(__MINGW32__)) | | 1149| |# define lzo_alloca(x) __builtin_alloca((x)) | | 1150| |#elif (LZO_CC_GNUC) && (LZO_OS_CONSOLE_PS2) | | 1151| |# define lzo_alloca(x) __builtin_alloca((x)) | | 1152| |#elif (LZO_CC_BORLANDC || LZO_CC_LCC) && defined(__linux__) | | 1153| |#elif (HAVE_ALLOCA) | | 1154| |# define lzo_alloca(x) LZO_STATIC_CAST(void *, alloca((x))) | | 1155| |#endif | | 1156| |#if (LZO_OS_DOS32 && LZO_CC_GNUC) && defined(__DJGPP__) | | 1157| |# define lzo_stackavail() stackavail() | | 1158| |#elif (LZO_ARCH_I086 && LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0410)) | | 1159| |# define lzo_stackavail() stackavail() | | 1160| |#elif (LZO_ARCH_I086 && LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0400)) | | 1161| |# if (LZO_OS_WIN16) && (LZO_MM_TINY || LZO_MM_SMALL || LZO_MM_MEDIUM) | | 1162| |# else | | 1163| |# define lzo_stackavail() stackavail() | | 1164| |# endif | | 1165| |#elif ((LZO_ARCH_I086 || LZO_ARCH_I386) && (LZO_CC_DMC || LZO_CC_SYMANTECC)) | | 1166| |# define lzo_stackavail() stackavail() | | 1167| |#elif ((LZO_ARCH_I086) && LZO_CC_MSC && (_MSC_VER >= 700)) | | 1168| |# define lzo_stackavail() _stackavail() | | 1169| |#elif ((LZO_ARCH_I086) && LZO_CC_MSC) | | 1170| |# define lzo_stackavail() stackavail() | | 1171| |#elif ((LZO_ARCH_I086 || LZO_ARCH_I386) && LZO_CC_TURBOC && (__TURBOC__ >= 0x0450)) | | 1172| |# define lzo_stackavail() stackavail() | | 1173| |#elif (LZO_ARCH_I086 && LZO_CC_TURBOC && (__TURBOC__ >= 0x0400)) | | 1174| | LZO_EXTERN_C size_t __cdecl stackavail(void); | | 1175| |# define lzo_stackavail() stackavail() | | 1176| |#elif ((LZO_ARCH_I086 || LZO_ARCH_I386) && (LZO_CC_WATCOMC)) | | 1177| |# define lzo_stackavail() stackavail() | | 1178| |#elif (LZO_ARCH_I086 && LZO_CC_ZORTECHC) | | 1179| |# define lzo_stackavail() _chkstack() | | 1180| |#endif | | 1181| |LZOLIB_EXTERN(lzo_intptr_t, lzo_get_osfhandle) (int); | | 1182| |LZOLIB_EXTERN(const char *, lzo_getenv) (const char *); | | 1183| |LZOLIB_EXTERN(int, lzo_isatty) (int); | | 1184| |LZOLIB_EXTERN(int, lzo_mkdir) (const char*, unsigned); | | 1185| |LZOLIB_EXTERN(int, lzo_rmdir) (const char*); | | 1186| |LZOLIB_EXTERN(int, lzo_response) (int*, char***); | | 1187| |LZOLIB_EXTERN(int, lzo_set_binmode) (int, int); | | 1188| |#if defined(lzo_int32e_t) | | 1189| |LZOLIB_EXTERN(lzo_int32e_t, lzo_muldiv32s) (lzo_int32e_t, lzo_int32e_t, lzo_int32e_t); | | 1190| |LZOLIB_EXTERN(lzo_uint32e_t, lzo_muldiv32u) (lzo_uint32e_t, lzo_uint32e_t, lzo_uint32e_t); | | 1191| |#endif | | 1192| |LZOLIB_EXTERN(void, lzo_wildargv) (int*, char***); | | 1193| |LZOLIB_EXTERN_NOINLINE(void, lzo_debug_break) (void); | | 1194| |LZOLIB_EXTERN_NOINLINE(void, lzo_debug_nop) (void); | | 1195| |LZOLIB_EXTERN_NOINLINE(int, lzo_debug_align_check_query) (void); | | 1196| |LZOLIB_EXTERN_NOINLINE(int, lzo_debug_align_check_enable) (int); | | 1197| |LZOLIB_EXTERN_NOINLINE(unsigned, lzo_debug_running_on_qemu) (void); | | 1198| |LZOLIB_EXTERN_NOINLINE(unsigned, lzo_debug_running_on_valgrind) (void); | | 1199| |#if defined(lzo_int32e_t) | | 1200| |LZOLIB_EXTERN(int, lzo_tsc_read) (lzo_uint32e_t*); | | 1201| |#endif | | 1202| |struct lzo_pclock_handle_t; | | 1203| |struct lzo_pclock_t; | | 1204| |typedef struct lzo_pclock_handle_t lzo_pclock_handle_t; | | 1205| |typedef struct lzo_pclock_t lzo_pclock_t; | | 1206| |#ifndef lzo_pclock_handle_p | | 1207| |#define lzo_pclock_handle_p lzo_pclock_handle_t * | | 1208| |#endif | | 1209| |#ifndef lzo_pclock_p | | 1210| |#define lzo_pclock_p lzo_pclock_t * | | 1211| |#endif | | 1212| |#define LZO_PCLOCK_REALTIME 0 | | 1213| |#define LZO_PCLOCK_MONOTONIC 1 | | 1214| |#define LZO_PCLOCK_PROCESS_CPUTIME_ID 2 | | 1215| |#define LZO_PCLOCK_THREAD_CPUTIME_ID 3 | | 1216| |typedef int (*lzo_pclock_gettime_t) (lzo_pclock_handle_p, lzo_pclock_p); | | 1217| |struct lzo_pclock_handle_t { | | 1218| | lzolib_handle_t h; | | 1219| | int mode; | | 1220| | int read_error; | | 1221| | const char* name; | | 1222| | lzo_pclock_gettime_t gettime; | | 1223| |#if defined(lzo_int64l_t) | | 1224| | lzo_uint64l_t ticks_base; | | 1225| |#endif | | 1226| |}; | | 1227| |struct lzo_pclock_t { | | 1228| |#if defined(lzo_int64l_t) | | 1229| | lzo_int64l_t tv_sec; | | 1230| |#else | | 1231| | lzo_int32l_t tv_sec_high; | | 1232| | lzo_uint32l_t tv_sec_low; | | 1233| |#endif | | 1234| | lzo_uint32l_t tv_nsec; | | 1235| |}; | | 1236| |LZOLIB_EXTERN(int, lzo_pclock_open) (lzo_pclock_handle_p, int); | | 1237| |LZOLIB_EXTERN(int, lzo_pclock_open_default) (lzo_pclock_handle_p); | | 1238| |LZOLIB_EXTERN(int, lzo_pclock_close) (lzo_pclock_handle_p); | | 1239| |LZOLIB_EXTERN(void, lzo_pclock_read) (lzo_pclock_handle_p, lzo_pclock_p); | | 1240| |#if !(LZO_CFG_NO_DOUBLE) | | 1241| |LZOLIB_EXTERN(double, lzo_pclock_get_elapsed) (lzo_pclock_handle_p, const lzo_pclock_p, const lzo_pclock_p); | | 1242| |#endif | | 1243| |LZOLIB_EXTERN(int, lzo_pclock_flush_cpu_cache) (lzo_pclock_handle_p, unsigned); | | 1244| |struct lzo_getopt_t; | | 1245| |typedef struct lzo_getopt_t lzo_getopt_t; | | 1246| |#ifndef lzo_getopt_p | | 1247| |#define lzo_getopt_p lzo_getopt_t * | | 1248| |#endif | | 1249| |struct lzo_getopt_longopt_t; | | 1250| |typedef struct lzo_getopt_longopt_t lzo_getopt_longopt_t; | | 1251| |#ifndef lzo_getopt_longopt_p | | 1252| |#define lzo_getopt_longopt_p lzo_getopt_longopt_t * | | 1253| |#endif | | 1254| |struct lzo_getopt_longopt_t { | | 1255| | const char* name; | | 1256| | int has_arg; | | 1257| | int* flag; | | 1258| | int val; | | 1259| |}; | | 1260| |typedef void (*lzo_getopt_opterr_t)(lzo_getopt_p, const char*, void *); | | 1261| |struct lzo_getopt_t { | | 1262| | void *user; | | 1263| | const char *progname; | | 1264| | int bad_option; | | 1265| | char *optarg; | | 1266| | lzo_getopt_opterr_t opterr; | | 1267| | int optind; | | 1268| | int optopt; | | 1269| | int errcount; | | 1270| | int argc; char** argv; | | 1271| | int eof; int shortpos; | | 1272| | int pending_rotate_first, pending_rotate_middle; | | 1273| |}; | | 1274| |enum { LZO_GETOPT_NO_ARG, LZO_GETOPT_REQUIRED_ARG, LZO_GETOPT_OPTIONAL_ARG, LZO_GETOPT_EXACT_ARG = 0x10 }; | | 1275| |enum { LZO_GETOPT_PERMUTE, LZO_GETOPT_RETURN_IN_ORDER, LZO_GETOPT_REQUIRE_ORDER }; | | 1276| |LZOLIB_EXTERN(void, lzo_getopt_init) (lzo_getopt_p g, | | 1277| | int start_argc, int argc, char** argv); | | 1278| |LZOLIB_EXTERN(int, lzo_getopt) (lzo_getopt_p g, | | 1279| | const char* shortopts, | | 1280| | const lzo_getopt_longopt_p longopts, | | 1281| | int* longind); | | 1282| |typedef struct { | | 1283| | lzo_uint32l_t seed; | | 1284| |} lzo_rand31_t; | | 1285| |#ifndef lzo_rand31_p | | 1286| |#define lzo_rand31_p lzo_rand31_t * | | 1287| |#endif | | 1288| |LZOLIB_EXTERN(void, lzo_srand31) (lzo_rand31_p, lzo_uint32l_t); | | 1289| |LZOLIB_EXTERN(lzo_uint32l_t, lzo_rand31) (lzo_rand31_p); | | 1290| |#if defined(lzo_int64l_t) | | 1291| |typedef struct { | | 1292| | lzo_uint64l_t seed; | | 1293| |} lzo_rand48_t; | | 1294| |#ifndef lzo_rand48_p | | 1295| |#define lzo_rand48_p lzo_rand48_t * | | 1296| |#endif | | 1297| |LZOLIB_EXTERN(void, lzo_srand48) (lzo_rand48_p, lzo_uint32l_t); | | 1298| |LZOLIB_EXTERN(lzo_uint32l_t, lzo_rand48) (lzo_rand48_p); | | 1299| |LZOLIB_EXTERN(lzo_uint32l_t, lzo_rand48_r32) (lzo_rand48_p); | | 1300| |#endif | | 1301| |#if defined(lzo_int64l_t) | | 1302| |typedef struct { | | 1303| | lzo_uint64l_t seed; | | 1304| |} lzo_rand64_t; | | 1305| |#ifndef lzo_rand64_p | | 1306| |#define lzo_rand64_p lzo_rand64_t * | | 1307| |#endif | | 1308| |LZOLIB_EXTERN(void, lzo_srand64) (lzo_rand64_p, lzo_uint64l_t); | | 1309| |LZOLIB_EXTERN(lzo_uint32l_t, lzo_rand64) (lzo_rand64_p); | | 1310| |LZOLIB_EXTERN(lzo_uint32l_t, lzo_rand64_r32) (lzo_rand64_p); | | 1311| |#endif | | 1312| |typedef struct { | | 1313| | unsigned n; | | 1314| | lzo_uint32l_t s[624]; | | 1315| |} lzo_randmt_t; | | 1316| |#ifndef lzo_randmt_p | | 1317| |#define lzo_randmt_p lzo_randmt_t * | | 1318| |#endif | | 1319| |LZOLIB_EXTERN(void, lzo_srandmt) (lzo_randmt_p, lzo_uint32l_t); | | 1320| |LZOLIB_EXTERN(lzo_uint32l_t, lzo_randmt) (lzo_randmt_p); | | 1321| |LZOLIB_EXTERN(lzo_uint32l_t, lzo_randmt_r32) (lzo_randmt_p); | | 1322| |#if defined(lzo_int64l_t) | | 1323| |typedef struct { | | 1324| | unsigned n; | | 1325| | lzo_uint64l_t s[312]; | | 1326| |} lzo_randmt64_t; | | 1327| |#ifndef lzo_randmt64_p | | 1328| |#define lzo_randmt64_p lzo_randmt64_t * | | 1329| |#endif | | 1330| |LZOLIB_EXTERN(void, lzo_srandmt64) (lzo_randmt64_p, lzo_uint64l_t); | | 1331| |LZOLIB_EXTERN(lzo_uint64l_t, lzo_randmt64_r64) (lzo_randmt64_p); | | 1332| |#endif | | 1333| |#define LZO_SPAWN_P_WAIT 0 | | 1334| |#define LZO_SPAWN_P_NOWAIT 1 | | 1335| |LZOLIB_EXTERN(int, lzo_spawnv) (int mode, const char* fn, const char* const * argv); | | 1336| |LZOLIB_EXTERN(int, lzo_spawnvp) (int mode, const char* fn, const char* const * argv); | | 1337| |LZOLIB_EXTERN(int, lzo_spawnve) (int mode, const char* fn, const char* const * argv, const char * const envp); | | 1338| |#endif | | 1339| |#endif | | 1340| |#if defined(LZO_WANT_ACC_CXX_H) | | 1341| |# undef LZO_WANT_ACC_CXX_H | | 1342| |#ifndef __LZO_CXX_H_INCLUDED | | 1343| |#define __LZO_CXX_H_INCLUDED 1 | | 1344| |#if defined(__cplusplus) | | 1345| |#if defined(LZO_CXX_NOTHROW) | | 1346| |#elif (LZO_CC_GNUC && (LZO_CC_GNUC < 0x020800ul)) | | 1347| |#elif (LZO_CC_BORLANDC && (__BORLANDC__ < 0x0450)) | | 1348| |#elif (LZO_CC_GHS && !defined(__EXCEPTIONS)) | | 1349| |#elif (LZO_CC_HIGHC) | | 1350| |#elif (LZO_CC_MSC && (_MSC_VER < 1100)) | | 1351| |#elif (LZO_CC_NDPC) | | 1352| |#elif (LZO_CC_TURBOC) | | 1353| |#elif (LZO_CC_WATCOMC && !defined(_CPPUNWIND)) | | 1354| |#elif (LZO_CC_ZORTECHC) | | 1355| |#else | | 1356| |# define LZO_CXX_NOTHROW throw() | | 1357| |#endif | | 1358| |#if !defined(LZO_CXX_NOTHROW) | | 1359| |# define LZO_CXX_NOTHROW /*empty*/ | | 1360| |#endif | | 1361| |#if defined(__LZO_CXX_DO_NEW) | | 1362| |#elif (LZO_CC_GHS || LZO_CC_NDPC || LZO_CC_PGI) | | 1363| |# define __LZO_CXX_DO_NEW { return 0; } | | 1364| |#elif ((LZO_CC_BORLANDC || LZO_CC_TURBOC) && LZO_ARCH_I086) | | 1365| |# define __LZO_CXX_DO_NEW { return 0; } | | 1366| |#else | | 1367| |# define __LZO_CXX_DO_NEW ; | | 1368| |#endif | | 1369| |#if defined(__LZO_CXX_DO_DELETE) | | 1370| |#elif (LZO_CC_BORLANDC || LZO_CC_TURBOC) | | 1371| |# define __LZO_CXX_DO_DELETE { } | | 1372| |#else | | 1373| |# define __LZO_CXX_DO_DELETE LZO_CXX_NOTHROW { } | | 1374| |#endif | | 1375| |#if (LZO_CC_BORLANDC && (__BORLANDC__ < 0x0450)) | | 1376| |#elif (LZO_CC_MSC && LZO_MM_HUGE) | | 1377| |# define LZO_CXX_DISABLE_NEW_DELETE private: | | 1378| |#elif (LZO_CC_MSC && (_MSC_VER < 1100)) | | 1379| |#elif (LZO_CC_NDPC) | | 1380| |#elif (LZO_CC_SYMANTECC || LZO_CC_ZORTECHC) | | 1381| |#elif (LZO_CC_TURBOC) | | 1382| |#elif (LZO_CC_WATCOMC && (__WATCOMC__ < 1100)) | | 1383| |#else | | 1384| |# define __LZO_CXX_HAVE_ARRAY_NEW 1 | | 1385| |#endif | | 1386| |#if (__LZO_CXX_HAVE_ARRAY_NEW) | | 1387| |# define __LZO_CXX_HAVE_PLACEMENT_NEW 1 | | 1388| |#endif | | 1389| |#if (__LZO_CXX_HAVE_PLACEMENT_NEW) | | 1390| |# if (LZO_CC_GNUC >= 0x030000ul) | | 1391| |# define __LZO_CXX_HAVE_PLACEMENT_DELETE 1 | | 1392| |# elif (LZO_CC_INTELC) | | 1393| |# define __LZO_CXX_HAVE_PLACEMENT_DELETE 1 | | 1394| |# elif (LZO_CC_MSC && (_MSC_VER >= 1200)) | | 1395| |# define __LZO_CXX_HAVE_PLACEMENT_DELETE 1 | | 1396| |# elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) | | 1397| |# define __LZO_CXX_HAVE_PLACEMENT_DELETE 1 | | 1398| |# elif (LZO_CC_PGI) | | 1399| |# define __LZO_CXX_HAVE_PLACEMENT_DELETE 1 | | 1400| |# endif | | 1401| |#endif | | 1402| |#if defined(LZO_CXX_DISABLE_NEW_DELETE) | | 1403| |#elif defined(new) || defined(delete) | | 1404| |# define LZO_CXX_DISABLE_NEW_DELETE private: | | 1405| |#elif (LZO_CC_GNUC && (LZO_CC_GNUC < 0x025b00ul)) | | 1406| |# define LZO_CXX_DISABLE_NEW_DELETE private: | | 1407| |#elif (LZO_CC_HIGHC) | | 1408| |# define LZO_CXX_DISABLE_NEW_DELETE private: | | 1409| |#elif !(__LZO_CXX_HAVE_ARRAY_NEW) | | 1410| |# define LZO_CXX_DISABLE_NEW_DELETE \ | | 1411| | protected: static void operator delete(void*) __LZO_CXX_DO_DELETE \ | | 1412| | protected: static void* operator new(size_t) __LZO_CXX_DO_NEW \ | | 1413| | private: | | 1414| |#else | | 1415| |# define LZO_CXX_DISABLE_NEW_DELETE \ | | 1416| | protected: static void operator delete(void*) __LZO_CXX_DO_DELETE \ | | 1417| | static void operator delete[](void*) __LZO_CXX_DO_DELETE \ | | 1418| | private: static void* operator new(size_t) __LZO_CXX_DO_NEW \ | | 1419| | static void* operator new[](size_t) __LZO_CXX_DO_NEW | | 1420| |#endif | | 1421| |#if defined(LZO_CXX_TRIGGER_FUNCTION) | | 1422| |#else | | 1423| |# define LZO_CXX_TRIGGER_FUNCTION \ | | 1424| | protected: virtual const void* lzo_cxx_trigger_function() const; \ | | 1425| | private: | | 1426| |#endif | | 1427| |#if defined(LZO_CXX_TRIGGER_FUNCTION_IMPL) | | 1428| |#else | | 1429| |# define LZO_CXX_TRIGGER_FUNCTION_IMPL(klass) \ | | 1430| | const void* klass::lzo_cxx_trigger_function() const { return LZO_STATIC_CAST(const void *, 0); } | | 1431| |#endif | | 1432| |#endif | | 1433| |#endif | | 1434| |#endif | | 1435| 1|#if defined(LZO_WANT_ACC_CHK_CH) | | 1436| 1|# undef LZO_WANT_ACC_CHK_CH | | 1437| |#if !defined(LZOCHK_ASSERT) | | 1438| |# define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT_HEADER(expr) | | 1439| |#endif | | 1440| |#if !defined(LZOCHK_ASSERT_SIGN_T) | | 1441| |# define LZOCHK_ASSERT_SIGN_T(type,relop) \ | | 1442| | LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | 1443| | LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | 1444| | LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | 1445| |#endif | | 1446| |#if !defined(LZOCHK_ASSERT_IS_SIGNED_T) | | 1447| |# define LZOCHK_ASSERT_IS_SIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,<) | | 1448| |#endif | | 1449| |#if !defined(LZOCHK_ASSERT_IS_UNSIGNED_T) | | 1450| |# if (LZO_BROKEN_INTEGRAL_PROMOTION) | | 1451| |# define LZOCHK_ASSERT_IS_UNSIGNED_T(type) \ | | 1452| | LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) > LZO_STATIC_CAST(type, 0) ) | | 1453| |# else | | 1454| |# define LZOCHK_ASSERT_IS_UNSIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,>) | | 1455| |# endif | | 1456| |#endif | | 1457| |#if defined(LZOCHK_CFG_PEDANTIC) | | 1458| |#if (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0550) && (__BORLANDC__ < 0x0560)) | | 1459| |# pragma option push -w-8055 | | 1460| |#elif (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0530) && (__BORLANDC__ < 0x0550)) | | 1461| |# pragma option push -w-osh | | 1462| |#endif | | 1463| |#endif | | 1464| |#if (LZO_0xffffffffL - LZO_UINT32_C(4294967294) != 1) | | 1465| |# error "preprocessor error" | | 1466| |#endif | | 1467| |#if (LZO_0xffffffffL - LZO_UINT32_C(0xfffffffd) != 2) | | 1468| |# error "preprocessor error" | | 1469| |#endif | | 1470| |#if +0 | | 1471| |# error "preprocessor error" | | 1472| |#endif | | 1473| |#if -0 | | 1474| |# error "preprocessor error" | | 1475| |#endif | | 1476| |#if +0 != 0 | | 1477| |# error "preprocessor error" | | 1478| |#endif | | 1479| |#if -0 != 0 | | 1480| |# error "preprocessor error" | | 1481| |#endif | | 1482| 1|#define LZOCHK_VAL 1 | | 1483| 1|#define LZOCHK_TMP1 LZOCHK_VAL | | 1484| 1|#undef LZOCHK_VAL | | 1485| 1|#define LZOCHK_VAL 2 | | 1486| 1|#define LZOCHK_TMP2 LZOCHK_VAL | | 1487| |#if (LZOCHK_TMP1 != 2) | | 1488| |# error "preprocessor error 3a" | | 1489| |#endif | | 1490| |#if (LZOCHK_TMP2 != 2) | | 1491| |# error "preprocessor error 3b" | | 1492| |#endif | | 1493| 1|#undef LZOCHK_VAL | | 1494| |#if (LZOCHK_TMP2) | | 1495| |# error "preprocessor error 3c" | | 1496| |#endif | | 1497| |#if (LZOCHK_TMP2 + 0 != 0) | | 1498| |# error "preprocessor error 3d" | | 1499| |#endif | | 1500| 1|#undef LZOCHK_TMP1 | | 1501| 1|#undef LZOCHK_TMP2 | | 1502| |#if 0 || defined(LZOCHK_CFG_PEDANTIC) | | 1503| |# if (LZO_ARCH_MIPS) && defined(_MIPS_SZINT) | | 1504| | LZOCHK_ASSERT((_MIPS_SZINT) == 8 * sizeof(int)) | | 1505| |# endif | | 1506| |# if (LZO_ARCH_MIPS) && defined(_MIPS_SZLONG) | | 1507| | LZOCHK_ASSERT((_MIPS_SZLONG) == 8 * sizeof(long)) | | 1508| |# endif | | 1509| |# if (LZO_ARCH_MIPS) && defined(_MIPS_SZPTR) | | 1510| | LZOCHK_ASSERT((_MIPS_SZPTR) == 8 * sizeof(void *)) | | 1511| |# endif | | 1512| |#endif | | 1513| 1| LZOCHK_ASSERT(1 == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1514| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(1u,1) == 1u) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1515| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(1u,2) == 3u) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1516| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(1u,3) == 7u) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1517| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(1u,8) == 255u) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1518| 1|#if (LZO_SIZEOF_INT >= 2) | | 1519| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(1,15) == 32767) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1520| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(1u,16) == 0xffffU) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1521| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(0u,16) == 0u) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1522| 1|#endif | | 1523| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(1ul,16) == 0xffffUL) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1524| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(0ul,16) == 0ul) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1525| 1|#if (LZO_SIZEOF_INT >= 4) | | 1526| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(1,31) == 2147483647) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1527| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(1u,32) == 0xffffffffU) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1528| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(0u,32) == 0u) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1529| 1|#endif | | 1530| 1|#if (LZO_SIZEOF_LONG >= 4) | | 1531| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(1ul,32) == 0xffffffffUL) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1532| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(0ul,32) == 0ul) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1533| 1|#endif | | 1534| 1|#if (LZO_SIZEOF_LONG >= 8) | | 1535| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(1ul,64) == 0xffffffffffffffffUL) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1536| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(0ul,64) == 0ul) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1537| 1|#endif | | 1538| 1|#if !(LZO_BROKEN_INTEGRAL_PROMOTION) | | 1539| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(1u,LZO_SIZEOF_INT*8) == ~0u) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1540| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(1ul,LZO_SIZEOF_LONG*8) == ~0ul) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1541| 1|#endif | | 1542| 1|#if 1 | | 1543| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(0,0) == 0) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1544| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(1,0) == 0) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1545| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(2,0) == 0) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1546| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(4,0) == 0) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1547| 1|#endif | | 1548| 1|#if 1 | | 1549| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(2,1) == 2) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1550| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(4,1) == 4) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1551| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(8,1) == 8) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1552| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(2,2) == 2+4) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1553| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(4,2) == 4+8) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1554| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(8,2) == 8+16) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1555| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(2,3) == 2+4+8) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1556| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(4,3) == 4+8+16) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1557| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(8,3) == 8+16+32) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1558| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(7,1) == 7) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1559| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(7,2) == 7+14) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1560| 1| LZOCHK_ASSERT(__LZO_MASK_GEN(7,3) == 7+14+28) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1561| 1|#endif | | 1562| 1|#if !(LZO_BROKEN_SIGNED_RIGHT_SHIFT) | | 1563| 1| LZOCHK_ASSERT(((-1) >> 7) == -1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1564| 1|#endif | | 1565| 1| LZOCHK_ASSERT(((1) >> 7) == 0) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1566| |#if (LZO_CC_INTELC && (__INTEL_COMPILER >= 900)) | | 1567| |# pragma warning(push) | | 1568| |# pragma warning(disable: 1025) | | 1569| |#endif | | 1570| 1| LZOCHK_ASSERT((~0l & ~0) == ~0l) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1571| 1| LZOCHK_ASSERT((~0l & ~0u) == ~0u) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1572| 1| LZOCHK_ASSERT((~0ul & ~0) == ~0ul) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1573| 1| LZOCHK_ASSERT((~0ul & ~0u) == ~0u) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1574| |#if defined(__MSDOS__) && defined(__TURBOC__) && (__TURBOC__ < 0x0150) | | 1575| |#elif (LZO_SIZEOF_INT == 2) | | 1576| | LZOCHK_ASSERT((~0l & ~0u) == 0xffffU) | | 1577| | LZOCHK_ASSERT((~0ul & ~0u) == 0xffffU) | | 1578| |#elif (LZO_SIZEOF_INT == 4) | | 1579| 1| LZOCHK_ASSERT((~0l & ~0u) == 0xffffffffU) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1580| 1| LZOCHK_ASSERT((~0ul & ~0u) == 0xffffffffU) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1581| 1|#endif | | 1582| |#if (LZO_CC_INTELC && (__INTEL_COMPILER >= 900)) | | 1583| |# pragma warning(pop) | | 1584| |#endif | | 1585| 1| LZOCHK_ASSERT_IS_SIGNED_T(signed char) | | ------------------ | | | | 1447| 1|# define LZOCHK_ASSERT_IS_SIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,<) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1586| 1| LZOCHK_ASSERT_IS_UNSIGNED_T(unsigned char) | | ------------------ | | | | 1454| 1|# define LZOCHK_ASSERT_IS_UNSIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,>) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1587| 1| LZOCHK_ASSERT(sizeof(signed char) == sizeof(char)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1588| 1| LZOCHK_ASSERT(sizeof(unsigned char) == sizeof(char)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1589| 1| LZOCHK_ASSERT(sizeof(char) == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1590| |#if (LZO_CC_CILLY) && (!defined(__CILLY__) || (__CILLY__ < 0x010302L)) | | 1591| |#else | | 1592| 1| LZOCHK_ASSERT(sizeof(char) == sizeof(LZO_STATIC_CAST(char, 0))) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1593| 1|#endif | | 1594| |#if defined(__cplusplus) | | 1595| | LZOCHK_ASSERT(sizeof('\0') == sizeof(char)) | | 1596| |#else | | 1597| |# if (LZO_CC_DMC) | | 1598| |# else | | 1599| 1| LZOCHK_ASSERT(sizeof('\0') == sizeof(int)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1600| 1|# endif | | 1601| 1|#endif | | 1602| 1|#if defined(__lzo_alignof) | | 1603| 1| LZOCHK_ASSERT(__lzo_alignof(char) == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1604| 1| LZOCHK_ASSERT(__lzo_alignof(signed char) == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1605| 1| LZOCHK_ASSERT(__lzo_alignof(unsigned char) == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1606| 1|#if defined(lzo_int16e_t) | | 1607| 1| LZOCHK_ASSERT(__lzo_alignof(lzo_int16e_t) >= 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1608| 1| LZOCHK_ASSERT(__lzo_alignof(lzo_int16e_t) <= 2) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1609| 1|#endif | | 1610| 1|#if defined(lzo_int32e_t) | | 1611| 1| LZOCHK_ASSERT(__lzo_alignof(lzo_int32e_t) >= 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1612| 1| LZOCHK_ASSERT(__lzo_alignof(lzo_int32e_t) <= 4) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1613| 1|#endif | | 1614| 1|#endif | | 1615| 1| LZOCHK_ASSERT_IS_SIGNED_T(short) | | ------------------ | | | | 1447| 1|# define LZOCHK_ASSERT_IS_SIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,<) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1616| 1| LZOCHK_ASSERT_IS_UNSIGNED_T(unsigned short) | | ------------------ | | | | 1454| 1|# define LZOCHK_ASSERT_IS_UNSIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,>) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1617| 1| LZOCHK_ASSERT(sizeof(short) == sizeof(unsigned short)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1618| 1|#if !(LZO_ABI_I8LP16) | | 1619| 1| LZOCHK_ASSERT(sizeof(short) >= 2) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1620| 1|#endif | | 1621| 1| LZOCHK_ASSERT(sizeof(short) >= sizeof(char)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1622| |#if (LZO_CC_CILLY) && (!defined(__CILLY__) || (__CILLY__ < 0x010302L)) | | 1623| |#else | | 1624| 1| LZOCHK_ASSERT(sizeof(short) == sizeof(LZO_STATIC_CAST(short, 0))) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1625| 1|#endif | | 1626| 1|#if (LZO_SIZEOF_SHORT > 0) | | 1627| 1| LZOCHK_ASSERT(sizeof(short) == LZO_SIZEOF_SHORT) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1628| 1|#endif | | 1629| 1| LZOCHK_ASSERT_IS_SIGNED_T(int) | | ------------------ | | | | 1447| 1|# define LZOCHK_ASSERT_IS_SIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,<) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1630| 1| LZOCHK_ASSERT_IS_UNSIGNED_T(unsigned int) | | ------------------ | | | | 1454| 1|# define LZOCHK_ASSERT_IS_UNSIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,>) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1631| 1| LZOCHK_ASSERT(sizeof(int) == sizeof(unsigned int)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1632| 1|#if !(LZO_ABI_I8LP16) | | 1633| 1| LZOCHK_ASSERT(sizeof(int) >= 2) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1634| 1|#endif | | 1635| 1| LZOCHK_ASSERT(sizeof(int) >= sizeof(short)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1636| 1| LZOCHK_ASSERT(sizeof(int) == sizeof(0)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1637| 1| LZOCHK_ASSERT(sizeof(int) == sizeof(LZO_STATIC_CAST(int, 0))) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1638| 1|#if (LZO_SIZEOF_INT > 0) | | 1639| 1| LZOCHK_ASSERT(sizeof(int) == LZO_SIZEOF_INT) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1640| 1|#endif | | 1641| 1| LZOCHK_ASSERT(sizeof(0) == sizeof(int)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1642| 1| LZOCHK_ASSERT_IS_SIGNED_T(long) | | ------------------ | | | | 1447| 1|# define LZOCHK_ASSERT_IS_SIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,<) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1643| 1| LZOCHK_ASSERT_IS_UNSIGNED_T(unsigned long) | | ------------------ | | | | 1454| 1|# define LZOCHK_ASSERT_IS_UNSIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,>) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1644| 1| LZOCHK_ASSERT(sizeof(long) == sizeof(unsigned long)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1645| 1|#if !(LZO_ABI_I8LP16) | | 1646| 1| LZOCHK_ASSERT(sizeof(long) >= 4) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1647| 1|#endif | | 1648| 1| LZOCHK_ASSERT(sizeof(long) >= sizeof(int)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1649| 1| LZOCHK_ASSERT(sizeof(long) == sizeof(0L)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1650| 1| LZOCHK_ASSERT(sizeof(long) == sizeof(LZO_STATIC_CAST(long, 0))) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1651| 1|#if (LZO_SIZEOF_LONG > 0) | | 1652| 1| LZOCHK_ASSERT(sizeof(long) == LZO_SIZEOF_LONG) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1653| 1|#endif | | 1654| 1| LZOCHK_ASSERT(sizeof(0L) == sizeof(long)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1655| 1| LZOCHK_ASSERT_IS_UNSIGNED_T(size_t) | | ------------------ | | | | 1454| 1|# define LZOCHK_ASSERT_IS_UNSIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,>) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1656| 1| LZOCHK_ASSERT(sizeof(size_t) >= sizeof(int)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1657| 1| LZOCHK_ASSERT(sizeof(size_t) == sizeof(sizeof(0))) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1658| 1|#if (LZO_SIZEOF_SIZE_T > 0) | | 1659| 1| LZOCHK_ASSERT(sizeof(size_t) == LZO_SIZEOF_SIZE_T) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1660| 1|#endif | | 1661| 1| LZOCHK_ASSERT_IS_SIGNED_T(ptrdiff_t) | | ------------------ | | | | 1447| 1|# define LZOCHK_ASSERT_IS_SIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,<) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1662| 1| LZOCHK_ASSERT(sizeof(ptrdiff_t) >= sizeof(int)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1663| 1| LZOCHK_ASSERT(sizeof(ptrdiff_t) >= sizeof(size_t)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1664| 1|#if !(LZO_BROKEN_SIZEOF) | | 1665| 1| LZOCHK_ASSERT(sizeof(ptrdiff_t) == sizeof(LZO_STATIC_CAST(char*, 0) - LZO_STATIC_CAST(char*, 0))) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1666| |# if (LZO_HAVE_MM_HUGE_PTR) | | 1667| | LZOCHK_ASSERT(4 == sizeof(LZO_STATIC_CAST(char __huge*, 0) - LZO_STATIC_CAST(char __huge*, 0))) | | 1668| |# endif | | 1669| 1|#endif | | 1670| 1|#if (LZO_SIZEOF_PTRDIFF_T > 0) | | 1671| 1| LZOCHK_ASSERT(sizeof(ptrdiff_t) == LZO_SIZEOF_PTRDIFF_T) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1672| 1|#endif | | 1673| 1| LZOCHK_ASSERT(sizeof(void*) >= sizeof(char*)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1674| 1|#if (LZO_SIZEOF_VOID_P > 0) | | 1675| 1| LZOCHK_ASSERT(sizeof(void*) == LZO_SIZEOF_VOID_P) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1676| 1| LZOCHK_ASSERT(sizeof(char*) == LZO_SIZEOF_VOID_P) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1677| 1|#endif | | 1678| |#if (LZO_HAVE_MM_HUGE_PTR) | | 1679| | LZOCHK_ASSERT(4 == sizeof(void __huge*)) | | 1680| | LZOCHK_ASSERT(4 == sizeof(char __huge*)) | | 1681| |#endif | | 1682| |#if (LZO_ABI_I8LP16) | | 1683| | LZOCHK_ASSERT((((1u << 7) + 1) >> 7) == 1) | | 1684| | LZOCHK_ASSERT((((1ul << 15) + 1) >> 15) == 1) | | 1685| |#else | | 1686| 1| LZOCHK_ASSERT((((1u << 15) + 1) >> 15) == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1687| 1| LZOCHK_ASSERT((((1ul << 31) + 1) >> 31) == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1688| 1|#endif | | 1689| |#if defined(LZOCHK_CFG_PEDANTIC) | | 1690| |#if defined(__MSDOS__) && defined(__TURBOC__) && (__TURBOC__ < 0x0150) | | 1691| |#else | | 1692| | LZOCHK_ASSERT((1 << (8*LZO_SIZEOF_INT-1)) < 0) | | 1693| |#endif | | 1694| |#endif | | 1695| 1| LZOCHK_ASSERT((1u << (8*LZO_SIZEOF_INT-1)) > 0) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1696| |#if defined(LZOCHK_CFG_PEDANTIC) | | 1697| | LZOCHK_ASSERT((1l << (8*LZO_SIZEOF_LONG-1)) < 0) | | 1698| |#endif | | 1699| 1| LZOCHK_ASSERT((1ul << (8*LZO_SIZEOF_LONG-1)) > 0) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1700| 1|#if defined(lzo_int16e_t) | | 1701| 1| LZOCHK_ASSERT(sizeof(lzo_int16e_t) == 2) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1702| 1| LZOCHK_ASSERT(sizeof(lzo_int16e_t) == LZO_SIZEOF_LZO_INT16E_T) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1703| 1| LZOCHK_ASSERT(sizeof(lzo_uint16e_t) == 2) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1704| 1| LZOCHK_ASSERT(sizeof(lzo_int16e_t) == sizeof(lzo_uint16e_t)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1705| 1| LZOCHK_ASSERT_IS_SIGNED_T(lzo_int16e_t) | | ------------------ | | | | 1447| 1|# define LZOCHK_ASSERT_IS_SIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,<) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1706| 1| LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint16e_t) | | ------------------ | | | | 1454| 1|# define LZOCHK_ASSERT_IS_UNSIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,>) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1707| |#if defined(__MSDOS__) && defined(__TURBOC__) && (__TURBOC__ < 0x0150) | | 1708| |#else | | 1709| 1| LZOCHK_ASSERT((LZO_STATIC_CAST(lzo_uint16e_t, (~LZO_STATIC_CAST(lzo_uint16e_t,0ul))) >> 15) == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1710| 1|#endif | | 1711| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(lzo_int16e_t, (1 + ~LZO_STATIC_CAST(lzo_int16e_t, 0))) == 0) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1712| |#if defined(LZOCHK_CFG_PEDANTIC) | | 1713| | LZOCHK_ASSERT( LZO_STATIC_CAST(lzo_uint16e_t, (1 + ~LZO_STATIC_CAST(lzo_uint16e_t, 0))) == 0) | | 1714| |#endif | | 1715| 1|#endif | | 1716| 1|#if defined(lzo_int32e_t) | | 1717| 1| LZOCHK_ASSERT(sizeof(lzo_int32e_t) == 4) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1718| 1| LZOCHK_ASSERT(sizeof(lzo_int32e_t) == LZO_SIZEOF_LZO_INT32E_T) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1719| 1| LZOCHK_ASSERT(sizeof(lzo_uint32e_t) == 4) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1720| 1| LZOCHK_ASSERT(sizeof(lzo_int32e_t) == sizeof(lzo_uint32e_t)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1721| 1| LZOCHK_ASSERT_IS_SIGNED_T(lzo_int32e_t) | | ------------------ | | | | 1447| 1|# define LZOCHK_ASSERT_IS_SIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,<) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1722| 1| LZOCHK_ASSERT(((( LZO_STATIC_CAST(lzo_int32e_t, 1) << 30) + 1) >> 30) == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1723| 1| LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint32e_t) | | ------------------ | | | | 1454| 1|# define LZOCHK_ASSERT_IS_UNSIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,>) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1724| 1| LZOCHK_ASSERT(((( LZO_STATIC_CAST(lzo_uint32e_t, 1) << 31) + 1) >> 31) == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1725| 1| LZOCHK_ASSERT((LZO_STATIC_CAST(lzo_uint32e_t, (~LZO_STATIC_CAST(lzo_uint32e_t, 0ul))) >> 31) == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1726| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(lzo_int32e_t, (1 + ~LZO_STATIC_CAST(lzo_int32e_t, 0))) == 0) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1727| |#if defined(LZOCHK_CFG_PEDANTIC) | | 1728| | LZOCHK_ASSERT( LZO_STATIC_CAST(lzo_uint32e_t, (1 + ~LZO_STATIC_CAST(lzo_uint32e_t, 0))) == 0) | | 1729| |#endif | | 1730| 1|#endif | | 1731| 1|#if defined(lzo_int32e_t) | | 1732| 1| LZOCHK_ASSERT(sizeof(lzo_int32l_t) >= sizeof(lzo_int32e_t)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1733| 1|#endif | | 1734| 1| LZOCHK_ASSERT(sizeof(lzo_int32l_t) >= 4) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1735| 1| LZOCHK_ASSERT(sizeof(lzo_int32l_t) == LZO_SIZEOF_LZO_INT32L_T) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1736| 1| LZOCHK_ASSERT(sizeof(lzo_uint32l_t) >= 4) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1737| 1| LZOCHK_ASSERT(sizeof(lzo_int32l_t) == sizeof(lzo_uint32l_t)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1738| 1| LZOCHK_ASSERT_IS_SIGNED_T(lzo_int32l_t) | | ------------------ | | | | 1447| 1|# define LZOCHK_ASSERT_IS_SIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,<) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1739| 1| LZOCHK_ASSERT(((( LZO_STATIC_CAST(lzo_int32l_t, 1) << 30) + 1) >> 30) == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1740| 1| LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint32l_t) | | ------------------ | | | | 1454| 1|# define LZOCHK_ASSERT_IS_UNSIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,>) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1741| 1| LZOCHK_ASSERT(((( LZO_STATIC_CAST(lzo_uint32l_t, 1) << 31) + 1) >> 31) == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1742| 1| LZOCHK_ASSERT(sizeof(lzo_int32f_t) >= sizeof(int)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1743| 1|#if defined(lzo_int32e_t) | | 1744| 1| LZOCHK_ASSERT(sizeof(lzo_int32f_t) >= sizeof(lzo_int32e_t)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1745| 1|#endif | | 1746| 1| LZOCHK_ASSERT(sizeof(lzo_int32f_t) >= sizeof(lzo_int32l_t)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1747| 1| LZOCHK_ASSERT(sizeof(lzo_int32f_t) >= 4) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1748| 1| LZOCHK_ASSERT(sizeof(lzo_int32f_t) >= sizeof(lzo_int32l_t)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1749| 1| LZOCHK_ASSERT(sizeof(lzo_int32f_t) == LZO_SIZEOF_LZO_INT32F_T) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1750| 1| LZOCHK_ASSERT(sizeof(lzo_uint32f_t) >= 4) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1751| 1| LZOCHK_ASSERT(sizeof(lzo_uint32f_t) >= sizeof(lzo_uint32l_t)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1752| 1| LZOCHK_ASSERT(sizeof(lzo_int32f_t) == sizeof(lzo_uint32f_t)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1753| 1| LZOCHK_ASSERT_IS_SIGNED_T(lzo_int32f_t) | | ------------------ | | | | 1447| 1|# define LZOCHK_ASSERT_IS_SIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,<) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1754| 1| LZOCHK_ASSERT(((( LZO_STATIC_CAST(lzo_int32f_t, 1) << 30) + 1) >> 30) == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1755| 1| LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint32f_t) | | ------------------ | | | | 1454| 1|# define LZOCHK_ASSERT_IS_UNSIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,>) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1756| 1| LZOCHK_ASSERT(((( LZO_STATIC_CAST(lzo_uint32f_t, 1) << 31) + 1) >> 31) == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1757| 1|#if defined(lzo_int64e_t) | | 1758| 1| LZOCHK_ASSERT(sizeof(lzo_int64e_t) == 8) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1759| 1| LZOCHK_ASSERT(sizeof(lzo_int64e_t) == LZO_SIZEOF_LZO_INT64E_T) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1760| 1| LZOCHK_ASSERT(sizeof(lzo_uint64e_t) == 8) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1761| 1| LZOCHK_ASSERT(sizeof(lzo_int64e_t) == sizeof(lzo_uint64e_t)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1762| 1| LZOCHK_ASSERT_IS_SIGNED_T(lzo_int64e_t) | | ------------------ | | | | 1447| 1|# define LZOCHK_ASSERT_IS_SIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,<) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1763| |#if (LZO_CC_BORLANDC && (__BORLANDC__ < 0x0530)) | | 1764| |#else | | 1765| 1| LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint64e_t) | | ------------------ | | | | 1454| 1|# define LZOCHK_ASSERT_IS_UNSIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,>) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1766| 1|#endif | | 1767| 1|#endif | | 1768| 1|#if defined(lzo_int64l_t) | | 1769| 1|#if defined(lzo_int64e_t) | | 1770| 1| LZOCHK_ASSERT(sizeof(lzo_int64l_t) >= sizeof(lzo_int64e_t)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1771| 1|#endif | | 1772| 1| LZOCHK_ASSERT(sizeof(lzo_int64l_t) >= 8) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1773| 1| LZOCHK_ASSERT(sizeof(lzo_int64l_t) == LZO_SIZEOF_LZO_INT64L_T) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1774| 1| LZOCHK_ASSERT(sizeof(lzo_uint64l_t) >= 8) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1775| 1| LZOCHK_ASSERT(sizeof(lzo_int64l_t) == sizeof(lzo_uint64l_t)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1776| 1| LZOCHK_ASSERT_IS_SIGNED_T(lzo_int64l_t) | | ------------------ | | | | 1447| 1|# define LZOCHK_ASSERT_IS_SIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,<) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1777| 1| LZOCHK_ASSERT(((( LZO_STATIC_CAST(lzo_int64l_t, 1) << 62) + 1) >> 62) == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1778| 1| LZOCHK_ASSERT(((( LZO_INT64_C(1) << 62) + 1) >> 62) == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1779| |#if (LZO_CC_BORLANDC && (__BORLANDC__ < 0x0530)) | | 1780| |#else | | 1781| 1| LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint64l_t) | | ------------------ | | | | 1454| 1|# define LZOCHK_ASSERT_IS_UNSIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,>) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1782| 1| LZOCHK_ASSERT(LZO_UINT64_C(18446744073709551615) > 0) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1783| 1|#endif | | 1784| 1| LZOCHK_ASSERT(((( LZO_STATIC_CAST(lzo_uint64l_t, 1) << 63) + 1) >> 63) == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1785| 1| LZOCHK_ASSERT(((( LZO_UINT64_C(1) << 63) + 1) >> 63) == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1786| |#if (LZO_CC_GNUC && (LZO_CC_GNUC < 0x020600ul)) | | 1787| | LZOCHK_ASSERT(LZO_INT64_C(9223372036854775807) > LZO_INT64_C(0)) | | 1788| |#else | | 1789| 1| LZOCHK_ASSERT(LZO_INT64_C(9223372036854775807) > 0) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1790| 1|#endif | | 1791| 1| LZOCHK_ASSERT(LZO_INT64_C(-9223372036854775807) - 1 < 0) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1792| 1| LZOCHK_ASSERT( LZO_INT64_C(9223372036854775807) % LZO_INT32_C(2147483629) == 721) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1793| 1| LZOCHK_ASSERT( LZO_INT64_C(9223372036854775807) % LZO_INT32_C(2147483647) == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1794| 1| LZOCHK_ASSERT(LZO_UINT64_C(9223372036854775807) % LZO_UINT32_C(2147483629) == 721) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1795| 1| LZOCHK_ASSERT(LZO_UINT64_C(9223372036854775807) % LZO_UINT32_C(2147483647) == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1796| 1|#endif | | 1797| 1|#if defined(lzo_int64f_t) | | 1798| 1|#if defined(lzo_int64e_t) | | 1799| 1| LZOCHK_ASSERT(sizeof(lzo_int64f_t) >= sizeof(lzo_int64e_t)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1800| 1|#endif | | 1801| 1| LZOCHK_ASSERT(sizeof(lzo_int64f_t) >= sizeof(lzo_int64l_t)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1802| 1| LZOCHK_ASSERT(sizeof(lzo_int64f_t) >= 8) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1803| 1| LZOCHK_ASSERT(sizeof(lzo_int64f_t) >= sizeof(lzo_int64l_t)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1804| 1| LZOCHK_ASSERT(sizeof(lzo_int64f_t) == LZO_SIZEOF_LZO_INT64F_T) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1805| 1| LZOCHK_ASSERT(sizeof(lzo_uint64f_t) >= 8) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1806| 1| LZOCHK_ASSERT(sizeof(lzo_uint64f_t) >= sizeof(lzo_uint64l_t)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1807| 1| LZOCHK_ASSERT(sizeof(lzo_int64f_t) == sizeof(lzo_uint64f_t)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1808| 1| LZOCHK_ASSERT_IS_SIGNED_T(lzo_int64f_t) | | ------------------ | | | | 1447| 1|# define LZOCHK_ASSERT_IS_SIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,<) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1809| |#if (LZO_CC_BORLANDC && (__BORLANDC__ < 0x0530)) | | 1810| |#else | | 1811| 1| LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint64f_t) | | ------------------ | | | | 1454| 1|# define LZOCHK_ASSERT_IS_UNSIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,>) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1812| 1|#endif | | 1813| 1|#endif | | 1814| 1|#if !defined(__LZO_INTPTR_T_IS_POINTER) | | 1815| 1| LZOCHK_ASSERT_IS_SIGNED_T(lzo_intptr_t) | | ------------------ | | | | 1447| 1|# define LZOCHK_ASSERT_IS_SIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,<) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1816| 1| LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uintptr_t) | | ------------------ | | | | 1454| 1|# define LZOCHK_ASSERT_IS_UNSIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,>) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1817| 1|#endif | | 1818| 1| LZOCHK_ASSERT(sizeof(lzo_intptr_t) >= sizeof(void *)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1819| 1| LZOCHK_ASSERT(sizeof(lzo_intptr_t) == LZO_SIZEOF_LZO_INTPTR_T) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1820| 1| LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(lzo_uintptr_t)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1821| 1|#if defined(lzo_word_t) | | 1822| 1| LZOCHK_ASSERT(LZO_WORDSIZE == LZO_SIZEOF_LZO_WORD_T) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1823| 1| LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_word_t) | | ------------------ | | | | 1454| 1|# define LZOCHK_ASSERT_IS_UNSIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,>) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1824| 1| LZOCHK_ASSERT_IS_SIGNED_T(lzo_sword_t) | | ------------------ | | | | 1447| 1|# define LZOCHK_ASSERT_IS_SIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,<) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1825| 1| LZOCHK_ASSERT(sizeof(lzo_word_t) == LZO_SIZEOF_LZO_WORD_T) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1826| 1| LZOCHK_ASSERT(sizeof(lzo_word_t) == sizeof(lzo_sword_t)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1827| 1|#endif | | 1828| 1| LZOCHK_ASSERT(sizeof(lzo_int8_t) == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1829| 1| LZOCHK_ASSERT(sizeof(lzo_uint8_t) == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1830| 1| LZOCHK_ASSERT(sizeof(lzo_int8_t) == sizeof(lzo_uint8_t)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1831| 1| LZOCHK_ASSERT_IS_SIGNED_T(lzo_int8_t) | | ------------------ | | | | 1447| 1|# define LZOCHK_ASSERT_IS_SIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,<) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1832| 1| LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint8_t) | | ------------------ | | | | 1454| 1|# define LZOCHK_ASSERT_IS_UNSIGNED_T(type) LZOCHK_ASSERT_SIGN_T(type,>) | | | | ------------------ | | | | | | 1442| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, -1) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1443| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) relop LZO_STATIC_CAST(type, 0)) \ | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1444| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(type, ~LZO_STATIC_CAST(type, 0)) == LZO_STATIC_CAST(type, -1)) | | | | | | ------------------ | | | | | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | | | | | ------------------ | | | | | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1833| 1|#if defined(LZO_INT16_C) | | 1834| 1| LZOCHK_ASSERT(sizeof(LZO_INT16_C(0)) >= 2) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1835| 1| LZOCHK_ASSERT(sizeof(LZO_UINT16_C(0)) >= 2) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1836| 1| LZOCHK_ASSERT((LZO_UINT16_C(0xffff) >> 15) == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1837| 1|#endif | | 1838| 1|#if defined(LZO_INT32_C) | | 1839| 1| LZOCHK_ASSERT(sizeof(LZO_INT32_C(0)) >= 4) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1840| 1| LZOCHK_ASSERT(sizeof(LZO_UINT32_C(0)) >= 4) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1841| 1| LZOCHK_ASSERT((LZO_UINT32_C(0xffffffff) >> 31) == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1842| 1|#endif | | 1843| 1|#if defined(LZO_INT64_C) | | 1844| |#if (LZO_CC_BORLANDC && (__BORLANDC__ < 0x0560)) | | 1845| |#else | | 1846| 1| LZOCHK_ASSERT(sizeof(LZO_INT64_C(0)) >= 8) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1847| 1| LZOCHK_ASSERT(sizeof(LZO_UINT64_C(0)) >= 8) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1848| 1|#endif | | 1849| 1| LZOCHK_ASSERT((LZO_UINT64_C(0xffffffffffffffff) >> 63) == 1) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1850| 1| LZOCHK_ASSERT((LZO_UINT64_C(0xffffffffffffffff) & ~0) == LZO_UINT64_C(0xffffffffffffffff)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1851| 1| LZOCHK_ASSERT((LZO_UINT64_C(0xffffffffffffffff) & ~0l) == LZO_UINT64_C(0xffffffffffffffff)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1852| 1|#if (LZO_SIZEOF_INT == 4) | | 1853| |# if (LZO_CC_GNUC && (LZO_CC_GNUC < 0x020000ul)) | | 1854| |# else | | 1855| 1| LZOCHK_ASSERT((LZO_UINT64_C(0xffffffffffffffff) & (~0u+0u)) == 0xffffffffu) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1856| 1|# endif | | 1857| 1|#endif | | 1858| |#if (LZO_SIZEOF_LONG == 4) | | 1859| |# if (LZO_CC_GNUC && (LZO_CC_GNUC < 0x020000ul)) | | 1860| |# else | | 1861| | LZOCHK_ASSERT((LZO_UINT64_C(0xffffffffffffffff) & (~0ul+0ul)) == 0xfffffffful) | | 1862| |# endif | | 1863| |#endif | | 1864| 1|#endif | | 1865| |#if (LZO_MM_TINY || LZO_MM_SMALL || LZO_MM_MEDIUM) | | 1866| | LZOCHK_ASSERT(sizeof(void*) == 2) | | 1867| | LZOCHK_ASSERT(sizeof(ptrdiff_t) == 2) | | 1868| |#elif (LZO_MM_COMPACT || LZO_MM_LARGE || LZO_MM_HUGE) | | 1869| | LZOCHK_ASSERT(sizeof(void*) == 4) | | 1870| |#endif | | 1871| |#if (LZO_MM_TINY || LZO_MM_SMALL || LZO_MM_COMPACT) | | 1872| | LZOCHK_ASSERT(sizeof(void (*)(void)) == 2) | | 1873| |#elif (LZO_MM_MEDIUM || LZO_MM_LARGE || LZO_MM_HUGE) | | 1874| | LZOCHK_ASSERT(sizeof(void (*)(void)) == 4) | | 1875| |#endif | | 1876| |#if (LZO_ABI_ILP32) | | 1877| | LZOCHK_ASSERT(sizeof(int) == 4) | | 1878| | LZOCHK_ASSERT(sizeof(long) == 4) | | 1879| | LZOCHK_ASSERT(sizeof(void*) == 4) | | 1880| | LZOCHK_ASSERT(sizeof(ptrdiff_t) == sizeof(void*)) | | 1881| | LZOCHK_ASSERT(sizeof(size_t) == sizeof(void*)) | | 1882| | LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(void *)) | | 1883| |#endif | | 1884| |#if (LZO_ABI_ILP64) | | 1885| | LZOCHK_ASSERT(sizeof(int) == 8) | | 1886| | LZOCHK_ASSERT(sizeof(long) == 8) | | 1887| | LZOCHK_ASSERT(sizeof(void*) == 8) | | 1888| | LZOCHK_ASSERT(sizeof(ptrdiff_t) == sizeof(void*)) | | 1889| | LZOCHK_ASSERT(sizeof(size_t) == sizeof(void*)) | | 1890| | LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(void *)) | | 1891| |#endif | | 1892| |#if (LZO_ABI_IP32L64) | | 1893| | LZOCHK_ASSERT(sizeof(int) == 4) | | 1894| | LZOCHK_ASSERT(sizeof(long) == 8) | | 1895| | LZOCHK_ASSERT(sizeof(void*) == 4) | | 1896| | LZOCHK_ASSERT(sizeof(ptrdiff_t) == sizeof(void*)) | | 1897| | LZOCHK_ASSERT(sizeof(size_t) == sizeof(void*)) | | 1898| | LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(void *)) | | 1899| |#endif | | 1900| |#if (LZO_ABI_LLP64) | | 1901| | LZOCHK_ASSERT(sizeof(int) == 4) | | 1902| | LZOCHK_ASSERT(sizeof(long) == 4) | | 1903| | LZOCHK_ASSERT(sizeof(void*) == 8) | | 1904| | LZOCHK_ASSERT(sizeof(ptrdiff_t) == sizeof(void*)) | | 1905| | LZOCHK_ASSERT(sizeof(size_t) == sizeof(void*)) | | 1906| | LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(void *)) | | 1907| |#endif | | 1908| |#if (LZO_ABI_LP32) | | 1909| | LZOCHK_ASSERT(sizeof(int) == 2) | | 1910| | LZOCHK_ASSERT(sizeof(long) == 4) | | 1911| | LZOCHK_ASSERT(sizeof(void*) == 4) | | 1912| | LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(void *)) | | 1913| |#endif | | 1914| 1|#if (LZO_ABI_LP64) | | 1915| 1| LZOCHK_ASSERT(sizeof(int) == 4) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1916| 1| LZOCHK_ASSERT(sizeof(long) == 8) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1917| 1| LZOCHK_ASSERT(sizeof(void*) == 8) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1918| 1| LZOCHK_ASSERT(sizeof(ptrdiff_t) == sizeof(void*)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1919| 1| LZOCHK_ASSERT(sizeof(size_t) == sizeof(void*)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1920| 1| LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(void *)) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1921| 1|#endif | | 1922| |#if (LZO_ABI_IP32W64) | | 1923| | LZOCHK_ASSERT(sizeof(int) == 4) | | 1924| | LZOCHK_ASSERT(sizeof(void*) == 4) | | 1925| | LZOCHK_ASSERT(sizeof(ptrdiff_t) == sizeof(void*)) | | 1926| | LZOCHK_ASSERT(sizeof(size_t) == sizeof(void*)) | | 1927| | LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(void *)) | | 1928| | LZOCHK_ASSERT(LZO_WORDSIZE == 8) | | 1929| |#endif | | 1930| |#if (LZO_ARCH_I086) | | 1931| | LZOCHK_ASSERT(sizeof(size_t) == 2) | | 1932| | LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(void *)) | | 1933| |#elif (LZO_ARCH_I386 || LZO_ARCH_M68K) | | 1934| | LZOCHK_ASSERT(sizeof(size_t) == 4) | | 1935| | LZOCHK_ASSERT(sizeof(ptrdiff_t) == 4) | | 1936| | LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(void *)) | | 1937| |#endif | | 1938| |#if (LZO_OS_DOS32 || LZO_OS_OS2 || LZO_OS_WIN32) | | 1939| | LZOCHK_ASSERT(sizeof(size_t) == 4) | | 1940| | LZOCHK_ASSERT(sizeof(ptrdiff_t) == 4) | | 1941| | LZOCHK_ASSERT(sizeof(void (*)(void)) == 4) | | 1942| |#elif (LZO_OS_WIN64) | | 1943| | LZOCHK_ASSERT(sizeof(size_t) == 8) | | 1944| | LZOCHK_ASSERT(sizeof(ptrdiff_t) == 8) | | 1945| | LZOCHK_ASSERT(sizeof(void (*)(void)) == 8) | | 1946| |#endif | | 1947| |#if (LZO_CC_NDPC) | | 1948| |#elif (LZO_SIZEOF_INT > 1) | | 1949| 1| LZOCHK_ASSERT( LZO_STATIC_CAST(int, LZO_STATIC_CAST(unsigned char, LZO_STATIC_CAST(signed char, -1))) == 255) | | ------------------ | | | | 206| 1|#define LZOCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) | | | | ------------------ | | | | | | 1989| 1|# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __LZO_CTA_NAME(lzo_cta_t__)[1-2*!(e)] __attribute__((__unused__));} | | | | ------------------ | | ------------------ | | 1950| 1|#endif | | 1951| |#if defined(LZOCHK_CFG_PEDANTIC) | | 1952| |#if (LZO_CC_KEILC) | | 1953| |#elif (LZO_CC_NDPC) | | 1954| |#elif !(LZO_BROKEN_INTEGRAL_PROMOTION) && (LZO_SIZEOF_INT > 1) | | 1955| | LZOCHK_ASSERT( ((LZO_STATIC_CAST(unsigned char, 128)) << LZO_STATIC_CAST(int, (8*sizeof(int)-8))) < 0) | | 1956| |#endif | | 1957| |#endif | | 1958| |#if defined(LZOCHK_CFG_PEDANTIC) | | 1959| |#if (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0530) && (__BORLANDC__ < 0x0560)) | | 1960| |# pragma option pop | | 1961| |#endif | | 1962| |#endif | | 1963| 1|#endif | | 1964| |#if defined(LZO_WANT_ACCLIB_VGET) | | 1965| |# undef LZO_WANT_ACCLIB_VGET | | 1966| |#define __LZOLIB_VGET_CH_INCLUDED 1 | | 1967| |#if !defined(LZOLIB_PUBLIC) | | 1968| |# define LZOLIB_PUBLIC(r,f) r __LZOLIB_FUNCNAME(f) | | 1969| |#endif | | 1970| |#if !defined(LZOLIB_PUBLIC_NOINLINE) | | 1971| |# if !defined(__lzo_noinline) | | 1972| |# define LZOLIB_PUBLIC_NOINLINE(r,f) r __LZOLIB_FUNCNAME(f) | | 1973| |# elif (LZO_CC_CLANG || (LZO_CC_GNUC >= 0x030400ul) || LZO_CC_LLVM) | | 1974| |# define LZOLIB_PUBLIC_NOINLINE(r,f) __lzo_noinline __attribute__((__used__)) r __LZOLIB_FUNCNAME(f) | | 1975| |# else | | 1976| |# define LZOLIB_PUBLIC_NOINLINE(r,f) __lzo_noinline r __LZOLIB_FUNCNAME(f) | | 1977| |# endif | | 1978| |#endif | | 1979| |extern void* volatile lzo_vget_ptr__; | | 1980| |#if (LZO_CC_CLANG || (LZO_CC_GNUC >= 0x030400ul) || LZO_CC_LLVM) | | 1981| |void* volatile __attribute__((__used__)) lzo_vget_ptr__ = LZO_STATIC_CAST(void *, 0); | | 1982| |#else | | 1983| |void* volatile lzo_vget_ptr__ = LZO_STATIC_CAST(void *, 0); | | 1984| |#endif | | 1985| |#ifndef __LZOLIB_VGET_BODY | | 1986| |#define __LZOLIB_VGET_BODY(T) \ | | 1987| | if __lzo_unlikely(lzo_vget_ptr__) { \ | | 1988| | typedef T __lzo_may_alias TT; \ | | 1989| | unsigned char e; expr &= 255; e = LZO_STATIC_CAST(unsigned char, expr); \ | | 1990| | * LZO_STATIC_CAST(TT *, lzo_vget_ptr__) = v; \ | | 1991| | * LZO_STATIC_CAST(unsigned char *, lzo_vget_ptr__) = e; \ | | 1992| | v = * LZO_STATIC_CAST(TT *, lzo_vget_ptr__); \ | | 1993| | } \ | | 1994| | return v; | | 1995| |#endif | | 1996| |LZOLIB_PUBLIC_NOINLINE(short, lzo_vget_short) (short v, int expr) | | 1997| |{ | | 1998| | __LZOLIB_VGET_BODY(short) | | 1999| |} | | 2000| |LZOLIB_PUBLIC_NOINLINE(int, lzo_vget_int) (int v, int expr) | | 2001| |{ | | 2002| | __LZOLIB_VGET_BODY(int) | | 2003| |} | | 2004| |LZOLIB_PUBLIC_NOINLINE(long, lzo_vget_long) (long v, int expr) | | 2005| |{ | | 2006| | __LZOLIB_VGET_BODY(long) | | 2007| |} | | 2008| |#if defined(lzo_int64l_t) | | 2009| |LZOLIB_PUBLIC_NOINLINE(lzo_int64l_t, lzo_vget_lzo_int64l_t) (lzo_int64l_t v, int expr) | | 2010| |{ | | 2011| | __LZOLIB_VGET_BODY(lzo_int64l_t) | | 2012| |} | | 2013| |#endif | | 2014| |LZOLIB_PUBLIC_NOINLINE(lzo_hsize_t, lzo_vget_lzo_hsize_t) (lzo_hsize_t v, int expr) | | 2015| |{ | | 2016| | __LZOLIB_VGET_BODY(lzo_hsize_t) | | 2017| |} | | 2018| |#if !(LZO_CFG_NO_DOUBLE) | | 2019| |LZOLIB_PUBLIC_NOINLINE(double, lzo_vget_double) (double v, int expr) | | 2020| |{ | | 2021| | __LZOLIB_VGET_BODY(double) | | 2022| |} | | 2023| |#endif | | 2024| |LZOLIB_PUBLIC_NOINLINE(lzo_hvoid_p, lzo_vget_lzo_hvoid_p) (lzo_hvoid_p v, int expr) | | 2025| |{ | | 2026| | __LZOLIB_VGET_BODY(lzo_hvoid_p) | | 2027| |} | | 2028| |#if (LZO_ARCH_I086 && LZO_CC_TURBOC && (__TURBOC__ == 0x0295)) && !defined(__cplusplus) | | 2029| |LZOLIB_PUBLIC_NOINLINE(lzo_hvoid_p, lzo_vget_lzo_hvoid_cp) (const lzo_hvoid_p vv, int expr) | | 2030| |{ | | 2031| | lzo_hvoid_p v = (lzo_hvoid_p) vv; | | 2032| | __LZOLIB_VGET_BODY(lzo_hvoid_p) | | 2033| |} | | 2034| |#else | | 2035| |LZOLIB_PUBLIC_NOINLINE(const lzo_hvoid_p, lzo_vget_lzo_hvoid_cp) (const lzo_hvoid_p v, int expr) | | 2036| |{ | | 2037| | __LZOLIB_VGET_BODY(const lzo_hvoid_p) | | 2038| |} | | 2039| |#endif | | 2040| |#endif | | 2041| |#if defined(LZO_WANT_ACCLIB_HMEMCPY) | | 2042| |# undef LZO_WANT_ACCLIB_HMEMCPY | | 2043| |#define __LZOLIB_HMEMCPY_CH_INCLUDED 1 | | 2044| |#if !defined(LZOLIB_PUBLIC) | | 2045| |# define LZOLIB_PUBLIC(r,f) r __LZOLIB_FUNCNAME(f) | | 2046| |#endif | | 2047| |LZOLIB_PUBLIC(int, lzo_hmemcmp) (const lzo_hvoid_p s1, const lzo_hvoid_p s2, lzo_hsize_t len) | | 2048| |{ | | 2049| |#if (LZO_HAVE_MM_HUGE_PTR) || !(HAVE_MEMCMP) | | 2050| | const lzo_hbyte_p p1 = LZO_STATIC_CAST(const lzo_hbyte_p, s1); | | 2051| | const lzo_hbyte_p p2 = LZO_STATIC_CAST(const lzo_hbyte_p, s2); | | 2052| | if __lzo_likely(len > 0) do | | 2053| | { | | 2054| | int d = *p1 - *p2; | | 2055| | if (d != 0) | | 2056| | return d; | | 2057| | p1++; p2++; | | 2058| | } while __lzo_likely(--len > 0); | | 2059| | return 0; | | 2060| |#else | | 2061| | return memcmp(s1, s2, len); | | 2062| |#endif | | 2063| |} | | 2064| |LZOLIB_PUBLIC(lzo_hvoid_p, lzo_hmemcpy) (lzo_hvoid_p dest, const lzo_hvoid_p src, lzo_hsize_t len) | | 2065| |{ | | 2066| |#if (LZO_HAVE_MM_HUGE_PTR) || !(HAVE_MEMCPY) | | 2067| | lzo_hbyte_p p1 = LZO_STATIC_CAST(lzo_hbyte_p, dest); | | 2068| | const lzo_hbyte_p p2 = LZO_STATIC_CAST(const lzo_hbyte_p, src); | | 2069| | if (!(len > 0) || p1 == p2) | | 2070| | return dest; | | 2071| | do | | 2072| | *p1++ = *p2++; | | 2073| | while __lzo_likely(--len > 0); | | 2074| | return dest; | | 2075| |#else | | 2076| | return memcpy(dest, src, len); | | 2077| |#endif | | 2078| |} | | 2079| |LZOLIB_PUBLIC(lzo_hvoid_p, lzo_hmemmove) (lzo_hvoid_p dest, const lzo_hvoid_p src, lzo_hsize_t len) | | 2080| |{ | | 2081| |#if (LZO_HAVE_MM_HUGE_PTR) || !(HAVE_MEMMOVE) | | 2082| | lzo_hbyte_p p1 = LZO_STATIC_CAST(lzo_hbyte_p, dest); | | 2083| | const lzo_hbyte_p p2 = LZO_STATIC_CAST(const lzo_hbyte_p, src); | | 2084| | if (!(len > 0) || p1 == p2) | | 2085| | return dest; | | 2086| | if (p1 < p2) | | 2087| | { | | 2088| | do | | 2089| | *p1++ = *p2++; | | 2090| | while __lzo_likely(--len > 0); | | 2091| | } | | 2092| | else | | 2093| | { | | 2094| | p1 += len; | | 2095| | p2 += len; | | 2096| | do | | 2097| | *--p1 = *--p2; | | 2098| | while __lzo_likely(--len > 0); | | 2099| | } | | 2100| | return dest; | | 2101| |#else | | 2102| | return memmove(dest, src, len); | | 2103| |#endif | | 2104| |} | | 2105| |LZOLIB_PUBLIC(lzo_hvoid_p, lzo_hmemset) (lzo_hvoid_p s, int cc, lzo_hsize_t len) | | 2106| |{ | | 2107| |#if (LZO_HAVE_MM_HUGE_PTR) || !(HAVE_MEMSET) | | 2108| | lzo_hbyte_p p = LZO_STATIC_CAST(lzo_hbyte_p, s); | | 2109| | unsigned char c = LZO_ITRUNC(unsigned char, cc); | | 2110| | if __lzo_likely(len > 0) do | | 2111| | *p++ = c; | | 2112| | while __lzo_likely(--len > 0); | | 2113| | return s; | | 2114| |#else | | 2115| | return memset(s, cc, len); | | 2116| |#endif | | 2117| |} | | 2118| |#endif | | 2119| |#if defined(LZO_WANT_ACCLIB_RAND) | | 2120| |# undef LZO_WANT_ACCLIB_RAND | | 2121| |#define __LZOLIB_RAND_CH_INCLUDED 1 | | 2122| |#if !defined(LZOLIB_PUBLIC) | | 2123| |# define LZOLIB_PUBLIC(r,f) r __LZOLIB_FUNCNAME(f) | | 2124| |#endif | | 2125| |LZOLIB_PUBLIC(void, lzo_srand31) (lzo_rand31_p r, lzo_uint32l_t seed) | | 2126| |{ | | 2127| | r->seed = seed & LZO_UINT32_C(0xffffffff); | | 2128| |} | | 2129| |LZOLIB_PUBLIC(lzo_uint32l_t, lzo_rand31) (lzo_rand31_p r) | | 2130| |{ | | 2131| | r->seed = r->seed * LZO_UINT32_C(1103515245) + 12345; | | 2132| | r->seed &= LZO_UINT32_C(0x7fffffff); | | 2133| | return r->seed; | | 2134| |} | | 2135| |#if defined(lzo_int64l_t) | | 2136| |LZOLIB_PUBLIC(void, lzo_srand48) (lzo_rand48_p r, lzo_uint32l_t seed) | | 2137| |{ | | 2138| | r->seed = seed & LZO_UINT32_C(0xffffffff); | | 2139| | r->seed <<= 16; r->seed |= 0x330e; | | 2140| |} | | 2141| |LZOLIB_PUBLIC(lzo_uint32l_t, lzo_rand48) (lzo_rand48_p r) | | 2142| |{ | | 2143| | lzo_uint64l_t a; | | 2144| | r->seed = r->seed * LZO_UINT64_C(25214903917) + 11; | | 2145| | r->seed &= LZO_UINT64_C(0xffffffffffff); | | 2146| | a = r->seed >> 17; | | 2147| | return LZO_STATIC_CAST(lzo_uint32l_t, a); | | 2148| |} | | 2149| |LZOLIB_PUBLIC(lzo_uint32l_t, lzo_rand48_r32) (lzo_rand48_p r) | | 2150| |{ | | 2151| | lzo_uint64l_t a; | | 2152| | r->seed = r->seed * LZO_UINT64_C(25214903917) + 11; | | 2153| | r->seed &= LZO_UINT64_C(0xffffffffffff); | | 2154| | a = r->seed >> 16; | | 2155| | return LZO_STATIC_CAST(lzo_uint32l_t, a); | | 2156| |} | | 2157| |#endif | | 2158| |#if defined(lzo_int64l_t) | | 2159| |LZOLIB_PUBLIC(void, lzo_srand64) (lzo_rand64_p r, lzo_uint64l_t seed) | | 2160| |{ | | 2161| | r->seed = seed & LZO_UINT64_C(0xffffffffffffffff); | | 2162| |} | | 2163| |LZOLIB_PUBLIC(lzo_uint32l_t, lzo_rand64) (lzo_rand64_p r) | | 2164| |{ | | 2165| | lzo_uint64l_t a; | | 2166| | r->seed = r->seed * LZO_UINT64_C(6364136223846793005) + 1; | | 2167| |#if (LZO_SIZEOF_LZO_INT64L_T > 8) | | 2168| | r->seed &= LZO_UINT64_C(0xffffffffffffffff); | | 2169| |#endif | | 2170| | a = r->seed >> 33; | | 2171| | return LZO_STATIC_CAST(lzo_uint32l_t, a); | | 2172| |} | | 2173| |LZOLIB_PUBLIC(lzo_uint32l_t, lzo_rand64_r32) (lzo_rand64_p r) | | 2174| |{ | | 2175| | lzo_uint64l_t a; | | 2176| | r->seed = r->seed * LZO_UINT64_C(6364136223846793005) + 1; | | 2177| |#if (LZO_SIZEOF_LZO_INT64L_T > 8) | | 2178| | r->seed &= LZO_UINT64_C(0xffffffffffffffff); | | 2179| |#endif | | 2180| | a = r->seed >> 32; | | 2181| | return LZO_STATIC_CAST(lzo_uint32l_t, a); | | 2182| |} | | 2183| |#endif | | 2184| |LZOLIB_PUBLIC(void, lzo_srandmt) (lzo_randmt_p r, lzo_uint32l_t seed) | | 2185| |{ | | 2186| | unsigned i = 0; | | 2187| | do { | | 2188| | r->s[i++] = (seed &= LZO_UINT32_C(0xffffffff)); | | 2189| | seed ^= seed >> 30; | | 2190| | seed = seed * LZO_UINT32_C(0x6c078965) + i; | | 2191| | } while (i != 624); | | 2192| | r->n = i; | | 2193| |} | | 2194| |LZOLIB_PUBLIC(lzo_uint32l_t, lzo_randmt) (lzo_randmt_p r) | | 2195| |{ | | 2196| | return (__LZOLIB_FUNCNAME(lzo_randmt_r32)(r)) >> 1; | | 2197| |} | | 2198| |LZOLIB_PUBLIC(lzo_uint32l_t, lzo_randmt_r32) (lzo_randmt_p r) | | 2199| |{ | | 2200| | lzo_uint32l_t v; | | 2201| | if __lzo_unlikely(r->n == 624) { | | 2202| | unsigned i = 0, j; | | 2203| | r->n = 0; | | 2204| | do { | | 2205| | j = i - 623; if (LZO_STATIC_CAST(int, j) < 0) j += 624; | | 2206| | v = (r->s[i] & LZO_UINT32_C(0x80000000)) ^ (r->s[j] & LZO_UINT32_C(0x7fffffff)); | | 2207| | j = i - 227; if (LZO_STATIC_CAST(int, j) < 0) j += 624; | | 2208| | r->s[i] = r->s[j] ^ (v >> 1); | | 2209| | if (v & 1) r->s[i] ^= LZO_UINT32_C(0x9908b0df); | | 2210| | } while (++i != 624); | | 2211| | } | | 2212| | { unsigned i = r->n++; v = r->s[i]; } | | 2213| | v ^= v >> 11; v ^= (v & LZO_UINT32_C(0x013a58ad)) << 7; | | 2214| | v ^= (v & LZO_UINT32_C(0x0001df8c)) << 15; v ^= v >> 18; | | 2215| | return v; | | 2216| |} | | 2217| |#if defined(lzo_int64l_t) | | 2218| |LZOLIB_PUBLIC(void, lzo_srandmt64) (lzo_randmt64_p r, lzo_uint64l_t seed) | | 2219| |{ | | 2220| | unsigned i = 0; | | 2221| | do { | | 2222| | r->s[i++] = (seed &= LZO_UINT64_C(0xffffffffffffffff)); | | 2223| | seed ^= seed >> 62; | | 2224| | seed = seed * LZO_UINT64_C(0x5851f42d4c957f2d) + i; | | 2225| | } while (i != 312); | | 2226| | r->n = i; | | 2227| |} | | 2228| |#if 0 | | 2229| |LZOLIB_PUBLIC(lzo_uint32l_t, lzo_randmt64) (lzo_randmt64_p r) | | 2230| |{ | | 2231| | lzo_uint64l_t v; | | 2232| | v = (__LZOLIB_FUNCNAME(lzo_randmt64_r64)(r)) >> 33; | | 2233| | return LZO_STATIC_CAST(lzo_uint32l_t, v); | | 2234| |} | | 2235| |#endif | | 2236| |LZOLIB_PUBLIC(lzo_uint64l_t, lzo_randmt64_r64) (lzo_randmt64_p r) | | 2237| |{ | | 2238| | lzo_uint64l_t v; | | 2239| | if __lzo_unlikely(r->n == 312) { | | 2240| | unsigned i = 0, j; | | 2241| | r->n = 0; | | 2242| | do { | | 2243| | j = i - 311; if (LZO_STATIC_CAST(int, j) < 0) j += 312; | | 2244| | v = (r->s[i] & LZO_UINT64_C(0xffffffff80000000)) ^ (r->s[j] & LZO_UINT64_C(0x7fffffff)); | | 2245| | j = i - 156; if (LZO_STATIC_CAST(int, j) < 0) j += 312; | | 2246| | r->s[i] = r->s[j] ^ (v >> 1); | | 2247| | if (v & 1) r->s[i] ^= LZO_UINT64_C(0xb5026f5aa96619e9); | | 2248| | } while (++i != 312); | | 2249| | } | | 2250| | { unsigned i = r->n++; v = r->s[i]; } | | 2251| | v ^= (v & LZO_UINT64_C(0xaaaaaaaaa0000000)) >> 29; | | 2252| | v ^= (v & LZO_UINT64_C(0x38eb3ffff6d3)) << 17; | | 2253| | v ^= (v & LZO_UINT64_C(0x7ffbf77)) << 37; | | 2254| | return v ^ (v >> 43); | | 2255| |} | | 2256| |#endif | | 2257| |#endif | | 2258| |#if defined(LZO_WANT_ACCLIB_RDTSC) | | 2259| |# undef LZO_WANT_ACCLIB_RDTSC | | 2260| |#define __LZOLIB_RDTSC_CH_INCLUDED 1 | | 2261| |#if !defined(LZOLIB_PUBLIC) | | 2262| |# define LZOLIB_PUBLIC(r,f) r __LZOLIB_FUNCNAME(f) | | 2263| |#endif | | 2264| |#if defined(lzo_int32e_t) | | 2265| |#if (LZO_OS_WIN32 && LZO_CC_PELLESC && (__POCC__ >= 290)) | | 2266| |# pragma warn(push) | | 2267| |# pragma warn(disable:2007) | | 2268| |#endif | | 2269| |#if (LZO_ARCH_AMD64 || LZO_ARCH_I386) && (LZO_ASM_SYNTAX_GNUC) | | 2270| |#if (LZO_ARCH_AMD64 && LZO_CC_INTELC) | | 2271| |# define __LZOLIB_RDTSC_REGS : : "c" (t) : "memory", "rax", "rdx" | | 2272| |#elif (LZO_ARCH_AMD64) | | 2273| |# define __LZOLIB_RDTSC_REGS : : "c" (t) : "cc", "memory", "rax", "rdx" | | 2274| |#elif (LZO_ARCH_I386 && LZO_CC_GNUC && (LZO_CC_GNUC < 0x020000ul)) | | 2275| |# define __LZOLIB_RDTSC_REGS : : "c" (t) : "ax", "dx" | | 2276| |#elif (LZO_ARCH_I386 && LZO_CC_INTELC) | | 2277| |# define __LZOLIB_RDTSC_REGS : : "c" (t) : "memory", "eax", "edx" | | 2278| |#else | | 2279| |# define __LZOLIB_RDTSC_REGS : : "c" (t) : "cc", "memory", "eax", "edx" | | 2280| |#endif | | 2281| |#endif | | 2282| |LZOLIB_PUBLIC(int, lzo_tsc_read) (lzo_uint32e_t* t) | | 2283| |{ | | 2284| |#if (LZO_ARCH_AMD64 || LZO_ARCH_I386) && (LZO_ASM_SYNTAX_GNUC) | | 2285| | __asm__ __volatile__( | | 2286| | "clc \n" ".byte 0x0f,0x31\n" | | 2287| | "movl %%eax,(%0)\n" "movl %%edx,4(%0)\n" | | 2288| | __LZOLIB_RDTSC_REGS | | 2289| | ); | | 2290| | return 0; | | 2291| |#elif (LZO_ARCH_I386) && (LZO_ASM_SYNTAX_MSC) | | 2292| | LZO_UNUSED(t); | | 2293| | __asm { | | 2294| | mov ecx, t | | 2295| | clc | | 2296| |# if (LZO_CC_MSC && (_MSC_VER < 1200)) | | 2297| | _emit 0x0f | | 2298| | _emit 0x31 | | 2299| |# else | | 2300| | rdtsc | | 2301| |# endif | | 2302| | mov [ecx], eax | | 2303| | mov [ecx+4], edx | | 2304| | } | | 2305| | return 0; | | 2306| |#else | | 2307| | t[0] = t[1] = 0; return -1; | | 2308| |#endif | | 2309| |} | | 2310| |#if (LZO_OS_WIN32 && LZO_CC_PELLESC && (__POCC__ >= 290)) | | 2311| |# pragma warn(pop) | | 2312| |#endif | | 2313| |#endif | | 2314| |#endif | | 2315| |#if defined(LZO_WANT_ACCLIB_DOSALLOC) | | 2316| |# undef LZO_WANT_ACCLIB_DOSALLOC | | 2317| |#define __LZOLIB_DOSALLOC_CH_INCLUDED 1 | | 2318| |#if !defined(LZOLIB_PUBLIC) | | 2319| |# define LZOLIB_PUBLIC(r,f) r __LZOLIB_FUNCNAME(f) | | 2320| |#endif | | 2321| |#if (LZO_OS_OS216) | | 2322| |LZO_EXTERN_C unsigned short __far __pascal DosAllocHuge(unsigned short, unsigned short, unsigned short __far *, unsigned short, unsigned short); | | 2323| |LZO_EXTERN_C unsigned short __far __pascal DosFreeSeg(unsigned short); | | 2324| |#endif | | 2325| |#if (LZO_OS_DOS16 || LZO_OS_WIN16) | | 2326| |#if !(LZO_CC_AZTECC) | | 2327| |LZOLIB_PUBLIC(void __far*, lzo_dos_alloc) (unsigned long size) | | 2328| |{ | | 2329| | void __far* p = 0; | | 2330| | union REGS ri, ro; | | 2331| | if ((long)size <= 0) | | 2332| | return p; | | 2333| | size = (size + 15) >> 4; | | 2334| | if (size > 0xffffu) | | 2335| | return p; | | 2336| | ri.x.ax = 0x4800; | | 2337| | ri.x.bx = (unsigned short) size; | | 2338| | int86(0x21, &ri, &ro); | | 2339| | if ((ro.x.cflag & 1) == 0) | | 2340| | p = (void __far*) LZO_PTR_MK_FP(ro.x.ax, 0); | | 2341| | return p; | | 2342| |} | | 2343| |LZOLIB_PUBLIC(int, lzo_dos_free) (void __far* p) | | 2344| |{ | | 2345| | union REGS ri, ro; | | 2346| | struct SREGS rs; | | 2347| | if (!p) | | 2348| | return 0; | | 2349| | if (LZO_PTR_FP_OFF(p) != 0) | | 2350| | return -1; | | 2351| | segread(&rs); | | 2352| | ri.x.ax = 0x4900; | | 2353| | rs.es = LZO_PTR_FP_SEG(p); | | 2354| | int86x(0x21, &ri, &ro, &rs); | | 2355| | if (ro.x.cflag & 1) | | 2356| | return -1; | | 2357| | return 0; | | 2358| |} | | 2359| |#endif | | 2360| |#endif | | 2361| |#if (LZO_OS_OS216) | | 2362| |LZOLIB_PUBLIC(void __far*, lzo_dos_alloc) (unsigned long size) | | 2363| |{ | | 2364| | void __far* p = 0; | | 2365| | unsigned short sel = 0; | | 2366| | if ((long)size <= 0) | | 2367| | return p; | | 2368| | if (DosAllocHuge((unsigned short)(size >> 16), (unsigned short)size, &sel, 0, 0) == 0) | | 2369| | p = (void __far*) LZO_PTR_MK_FP(sel, 0); | | 2370| | return p; | | 2371| |} | | 2372| |LZOLIB_PUBLIC(int, lzo_dos_free) (void __far* p) | | 2373| |{ | | 2374| | if (!p) | | 2375| | return 0; | | 2376| | if (LZO_PTR_FP_OFF(p) != 0) | | 2377| | return -1; | | 2378| | if (DosFreeSeg(LZO_PTR_FP_SEG(p)) != 0) | | 2379| | return -1; | | 2380| | return 0; | | 2381| |} | | 2382| |#endif | | 2383| |#endif | | 2384| |#if defined(LZO_WANT_ACCLIB_GETOPT) | | 2385| |# undef LZO_WANT_ACCLIB_GETOPT | | 2386| |#define __LZOLIB_GETOPT_CH_INCLUDED 1 | | 2387| |#if !defined(LZOLIB_PUBLIC) | | 2388| |# define LZOLIB_PUBLIC(r,f) r __LZOLIB_FUNCNAME(f) | | 2389| |#endif | | 2390| |LZOLIB_PUBLIC(void, lzo_getopt_init) (lzo_getopt_p g, | | 2391| | int start_argc, int argc, char** argv) | | 2392| |{ | | 2393| | memset(g, 0, sizeof(*g)); | | 2394| | g->optind = start_argc; | | 2395| | g->argc = argc; g->argv = argv; | | 2396| | g->optopt = -1; | | 2397| |} | | 2398| |static int __LZOLIB_FUNCNAME(lzo_getopt_rotate) (char** p, int first, int middle, int last) | | 2399| |{ | | 2400| | int i = middle, n = middle - first; | | 2401| | if (first >= middle || middle >= last) return 0; | | 2402| | for (;;) | | 2403| | { | | 2404| | char* t = p[first]; p[first] = p[i]; p[i] = t; | | 2405| | if (++first == middle) | | 2406| | { | | 2407| | if (++i == last) break; | | 2408| | middle = i; | | 2409| | } | | 2410| | else if (++i == last) | | 2411| | i = middle; | | 2412| | } | | 2413| | return n; | | 2414| |} | | 2415| |static int __LZOLIB_FUNCNAME(lzo_getopt_perror) (lzo_getopt_p g, int ret, const char* f, ...) | | 2416| |{ | | 2417| | if (g->opterr) | | 2418| | { | | 2419| |#if (HAVE_STDARG_H) | | 2420| | struct { va_list ap; } s; | | 2421| | va_start(s.ap, f); | | 2422| | g->opterr(g, f, &s); | | 2423| | va_end(s.ap); | | 2424| |#else | | 2425| | g->opterr(g, f, NULL); | | 2426| |#endif | | 2427| | } | | 2428| | ++g->errcount; | | 2429| | return ret; | | 2430| |} | | 2431| |LZOLIB_PUBLIC(int, lzo_getopt) (lzo_getopt_p g, | | 2432| | const char* shortopts, | | 2433| | const lzo_getopt_longopt_p longopts, | | 2434| | int* longind) | | 2435| |{ | | 2436| |#define pe __LZOLIB_FUNCNAME(lzo_getopt_perror) | | 2437| | int ordering = LZO_GETOPT_PERMUTE; | | 2438| | int missing_arg_ret = g->bad_option; | | 2439| | char* a; | | 2440| | if (shortopts) | | 2441| | { | | 2442| | if (*shortopts == '-' || *shortopts == '+') | | 2443| | ordering = *shortopts++ == '-' ? LZO_GETOPT_RETURN_IN_ORDER : LZO_GETOPT_REQUIRE_ORDER; | | 2444| | if (*shortopts == ':') | | 2445| | missing_arg_ret = *shortopts++; | | 2446| | } | | 2447| | g->optarg = NULL; | | 2448| | if (g->optopt == -1) | | 2449| | g->optopt = g->bad_option; | | 2450| | if (longind) | | 2451| | *longind = -1; | | 2452| | if (g->eof) | | 2453| | return -1; | | 2454| | if (g->shortpos) | | 2455| | goto lzo_label_next_shortopt; | | 2456| | g->optind -= __LZOLIB_FUNCNAME(lzo_getopt_rotate)(g->argv, g->pending_rotate_first, g->pending_rotate_middle, g->optind); | | 2457| | g->pending_rotate_first = g->pending_rotate_middle = g->optind; | | 2458| | if (ordering == LZO_GETOPT_PERMUTE) | | 2459| | { | | 2460| | while (g->optind < g->argc && !(g->argv[g->optind][0] == '-' && g->argv[g->optind][1])) | | 2461| | ++g->optind; | | 2462| | g->pending_rotate_middle = g->optind; | | 2463| | } | | 2464| | if (g->optind >= g->argc) | | 2465| | { | | 2466| | g->optind = g->pending_rotate_first; | | 2467| | goto lzo_label_eof; | | 2468| | } | | 2469| | a = g->argv[g->optind]; | | 2470| | if (a[0] == '-' && a[1] == '-') | | 2471| | { | | 2472| | size_t l = 0; | | 2473| | const lzo_getopt_longopt_p o; | | 2474| | const lzo_getopt_longopt_p o1 = NULL; | | 2475| | const lzo_getopt_longopt_p o2 = NULL; | | 2476| | int need_exact = 0; | | 2477| | ++g->optind; | | 2478| | if (!a[2]) | | 2479| | goto lzo_label_eof; | | 2480| | for (a += 2; a[l] && a[l] != '=' && a[l] != '#'; ) | | 2481| | ++l; | | 2482| | for (o = longopts; l && o && o->name; ++o) | | 2483| | { | | 2484| | if (strncmp(a, o->name, l) != 0) | | 2485| | continue; | | 2486| | if (!o->name[l]) | | 2487| | goto lzo_label_found_o; | | 2488| | need_exact |= o->has_arg & LZO_GETOPT_EXACT_ARG; | | 2489| | if (o1) o2 = o; | | 2490| | else o1 = o; | | 2491| | } | | 2492| | if (!o1 || need_exact) | | 2493| | return pe(g, g->bad_option, "unrecognized option '--%s'", a); | | 2494| | if (o2) | | 2495| | return pe(g, g->bad_option, "option '--%s' is ambiguous (could be '--%s' or '--%s')", a, o1->name, o2->name); | | 2496| | o = o1; | | 2497| | lzo_label_found_o: | | 2498| | a += l; | | 2499| | switch (o->has_arg & 0x2f) | | 2500| | { | | 2501| | case LZO_GETOPT_OPTIONAL_ARG: | | 2502| | if (a[0]) | | 2503| | g->optarg = a + 1; | | 2504| | break; | | 2505| | case LZO_GETOPT_REQUIRED_ARG: | | 2506| | if (a[0]) | | 2507| | g->optarg = a + 1; | | 2508| | else if (g->optind < g->argc) | | 2509| | g->optarg = g->argv[g->optind++]; | | 2510| | if (!g->optarg) | | 2511| | return pe(g, missing_arg_ret, "option '--%s' requires an argument", o->name); | | 2512| | break; | | 2513| | case LZO_GETOPT_REQUIRED_ARG | 0x20: | | 2514| | if (a[0] && a[1]) | | 2515| | g->optarg = a + 1; | | 2516| | if (!g->optarg) | | 2517| | return pe(g, missing_arg_ret, "option '--%s=' requires an argument", o->name); | | 2518| | break; | | 2519| | default: | | 2520| | if (a[0]) | | 2521| | return pe(g, g->bad_option, "option '--%s' doesn't allow an argument", o->name); | | 2522| | break; | | 2523| | } | | 2524| | if (longind) | | 2525| | *longind = (int) (o - longopts); | | 2526| | if (o->flag) | | 2527| | { | | 2528| | *o->flag = o->val; | | 2529| | return 0; | | 2530| | } | | 2531| | return o->val; | | 2532| | } | | 2533| | if (a[0] == '-' && a[1]) | | 2534| | { | | 2535| | unsigned char c; | | 2536| | const char* s; | | 2537| | lzo_label_next_shortopt: | | 2538| | a = g->argv[g->optind] + ++g->shortpos; | | 2539| | c = (unsigned char) *a++; s = NULL; | | 2540| | if (c != ':' && shortopts) | | 2541| | s = strchr(shortopts, c); | | 2542| | if (!s || s[1] != ':') | | 2543| | { | | 2544| | if (!a[0]) | | 2545| | { ++g->optind; g->shortpos = 0; } | | 2546| | if (!s) | | 2547| | { | | 2548| | g->optopt = c; | | 2549| | return pe(g, g->bad_option, "invalid option '-%c'", c); | | 2550| | } | | 2551| | } | | 2552| | else | | 2553| | { | | 2554| | ++g->optind; g->shortpos = 0; | | 2555| | if (a[0]) | | 2556| | g->optarg = a; | | 2557| | else if (s[2] != ':') | | 2558| | { | | 2559| | if (g->optind < g->argc) | | 2560| | g->optarg = g->argv[g->optind++]; | | 2561| | else | | 2562| | { | | 2563| | g->optopt = c; | | 2564| | return pe(g, missing_arg_ret, "option '-%c' requires an argument", c); | | 2565| | } | | 2566| | } | | 2567| | } | | 2568| | return c; | | 2569| | } | | 2570| | if (ordering == LZO_GETOPT_RETURN_IN_ORDER) | | 2571| | { | | 2572| | ++g->optind; | | 2573| | g->optarg = a; | | 2574| | return 1; | | 2575| | } | | 2576| |lzo_label_eof: | | 2577| | g->optind -= __LZOLIB_FUNCNAME(lzo_getopt_rotate)(g->argv, g->pending_rotate_first, g->pending_rotate_middle, g->optind); | | 2578| | g->pending_rotate_first = g->pending_rotate_middle = g->optind; | | 2579| | g->eof = 1; | | 2580| | return -1; | | 2581| |#undef pe | | 2582| |} | | 2583| |#endif | | 2584| |#if defined(LZO_WANT_ACCLIB_HALLOC) | | 2585| |# undef LZO_WANT_ACCLIB_HALLOC | | 2586| |#define __LZOLIB_HALLOC_CH_INCLUDED 1 | | 2587| |#if !defined(LZOLIB_PUBLIC) | | 2588| |# define LZOLIB_PUBLIC(r,f) r __LZOLIB_FUNCNAME(f) | | 2589| |#endif | | 2590| |#if (LZO_HAVE_MM_HUGE_PTR) | | 2591| |#if 1 && (LZO_OS_DOS16 && defined(BLX286)) | | 2592| |# define __LZOLIB_HALLOC_USE_DAH 1 | | 2593| |#elif 1 && (LZO_OS_DOS16 && defined(DOSX286)) | | 2594| |# define __LZOLIB_HALLOC_USE_DAH 1 | | 2595| |#elif 1 && (LZO_OS_OS216) | | 2596| |# define __LZOLIB_HALLOC_USE_DAH 1 | | 2597| |#elif 1 && (LZO_OS_WIN16) | | 2598| |# define __LZOLIB_HALLOC_USE_GA 1 | | 2599| |#elif 1 && (LZO_OS_DOS16) && (LZO_CC_BORLANDC) && defined(__DPMI16__) | | 2600| |# define __LZOLIB_HALLOC_USE_GA 1 | | 2601| |#endif | | 2602| |#endif | | 2603| |#if (__LZOLIB_HALLOC_USE_DAH) | | 2604| |#if 0 && (LZO_OS_OS216) | | 2605| |#include | | 2606| |#else | | 2607| |LZO_EXTERN_C unsigned short __far __pascal DosAllocHuge(unsigned short, unsigned short, unsigned short __far *, unsigned short, unsigned short); | | 2608| |LZO_EXTERN_C unsigned short __far __pascal DosFreeSeg(unsigned short); | | 2609| |#endif | | 2610| |#endif | | 2611| |#if (__LZOLIB_HALLOC_USE_GA) | | 2612| |#if 0 | | 2613| |#define STRICT 1 | | 2614| |#include | | 2615| |#else | | 2616| |LZO_EXTERN_C const void __near* __far __pascal GlobalAlloc(unsigned, unsigned long); | | 2617| |LZO_EXTERN_C const void __near* __far __pascal GlobalFree(const void __near*); | | 2618| |LZO_EXTERN_C unsigned long __far __pascal GlobalHandle(unsigned); | | 2619| |LZO_EXTERN_C void __far* __far __pascal GlobalLock(const void __near*); | | 2620| |LZO_EXTERN_C int __far __pascal GlobalUnlock(const void __near*); | | 2621| |#endif | | 2622| |#endif | | 2623| |LZOLIB_PUBLIC(lzo_hvoid_p, lzo_halloc) (lzo_hsize_t size) | | 2624| |{ | | 2625| | lzo_hvoid_p p = LZO_STATIC_CAST(lzo_hvoid_p, 0); | | 2626| | if (!(size > 0)) | | 2627| | return p; | | 2628| |#if 0 && defined(__palmos__) | | 2629| | p = MemPtrNew(size); | | 2630| |#elif !(LZO_HAVE_MM_HUGE_PTR) | | 2631| | if (size < LZO_STATIC_CAST(size_t, -1)) | | 2632| | p = malloc(LZO_STATIC_CAST(size_t, size)); | | 2633| |#else | | 2634| | if (LZO_STATIC_CAST(long, size) <= 0) | | 2635| | return p; | | 2636| |{ | | 2637| |#if (__LZOLIB_HALLOC_USE_DAH) | | 2638| | unsigned short sel = 0; | | 2639| | if (DosAllocHuge((unsigned short)(size >> 16), (unsigned short)size, &sel, 0, 0) == 0) | | 2640| | p = (lzo_hvoid_p) LZO_PTR_MK_FP(sel, 0); | | 2641| |#elif (__LZOLIB_HALLOC_USE_GA) | | 2642| | const void __near* h = GlobalAlloc(2, size); | | 2643| | if (h) { | | 2644| | p = GlobalLock(h); | | 2645| | if (p && LZO_PTR_FP_OFF(p) != 0) { | | 2646| | GlobalUnlock(h); | | 2647| | p = 0; | | 2648| | } | | 2649| | if (!p) | | 2650| | GlobalFree(h); | | 2651| | } | | 2652| |#elif (LZO_CC_MSC && (_MSC_VER >= 700)) | | 2653| | p = _halloc(size, 1); | | 2654| |#elif (LZO_CC_MSC || LZO_CC_WATCOMC) | | 2655| | p = halloc(size, 1); | | 2656| |#elif (LZO_CC_DMC || LZO_CC_SYMANTECC || LZO_CC_ZORTECHC) | | 2657| | p = farmalloc(size); | | 2658| |#elif (LZO_CC_BORLANDC || LZO_CC_TURBOC) | | 2659| | p = farmalloc(size); | | 2660| |#elif (LZO_CC_AZTECC) | | 2661| | p = lmalloc(size); | | 2662| |#else | | 2663| | if (size < LZO_STATIC_CAST(size_t, -1)) | | 2664| | p = malloc(LZO_STATIC_CAST(size_t, size)); | | 2665| |#endif | | 2666| |} | | 2667| |#endif | | 2668| | return p; | | 2669| |} | | 2670| |LZOLIB_PUBLIC(void, lzo_hfree) (lzo_hvoid_p p) | | 2671| |{ | | 2672| | if (!p) | | 2673| | return; | | 2674| |#if 0 && defined(__palmos__) | | 2675| | MemPtrFree(p); | | 2676| |#elif !(LZO_HAVE_MM_HUGE_PTR) | | 2677| | free(p); | | 2678| |#else | | 2679| |#if (__LZOLIB_HALLOC_USE_DAH) | | 2680| | if (LZO_PTR_FP_OFF(p) == 0) | | 2681| | DosFreeSeg((unsigned short) LZO_PTR_FP_SEG(p)); | | 2682| |#elif (__LZOLIB_HALLOC_USE_GA) | | 2683| | if (LZO_PTR_FP_OFF(p) == 0) { | | 2684| | const void __near* h = (const void __near*) (unsigned) GlobalHandle(LZO_PTR_FP_SEG(p)); | | 2685| | if (h) { | | 2686| | GlobalUnlock(h); | | 2687| | GlobalFree(h); | | 2688| | } | | 2689| | } | | 2690| |#elif (LZO_CC_MSC && (_MSC_VER >= 700)) | | 2691| | _hfree(p); | | 2692| |#elif (LZO_CC_MSC || LZO_CC_WATCOMC) | | 2693| | hfree(p); | | 2694| |#elif (LZO_CC_DMC || LZO_CC_SYMANTECC || LZO_CC_ZORTECHC) | | 2695| | farfree((void __far*) p); | | 2696| |#elif (LZO_CC_BORLANDC || LZO_CC_TURBOC) | | 2697| | farfree((void __far*) p); | | 2698| |#elif (LZO_CC_AZTECC) | | 2699| | lfree(p); | | 2700| |#else | | 2701| | free(p); | | 2702| |#endif | | 2703| |#endif | | 2704| |} | | 2705| |#endif | | 2706| |#if defined(LZO_WANT_ACCLIB_HFREAD) | | 2707| |# undef LZO_WANT_ACCLIB_HFREAD | | 2708| |#define __LZOLIB_HFREAD_CH_INCLUDED 1 | | 2709| |#if !defined(LZOLIB_PUBLIC) | | 2710| |# define LZOLIB_PUBLIC(r,f) r __LZOLIB_FUNCNAME(f) | | 2711| |#endif | | 2712| |LZOLIB_PUBLIC(lzo_hsize_t, lzo_hfread) (void* vfp, lzo_hvoid_p buf, lzo_hsize_t size) | | 2713| |{ | | 2714| | FILE* fp = LZO_STATIC_CAST(FILE *, vfp); | | 2715| |#if (LZO_HAVE_MM_HUGE_PTR) | | 2716| |#if (LZO_MM_TINY || LZO_MM_SMALL || LZO_MM_MEDIUM) | | 2717| |#define __LZOLIB_REQUIRE_HMEMCPY_CH 1 | | 2718| | unsigned char tmp[512]; | | 2719| | lzo_hsize_t l = 0; | | 2720| | while (l < size) | | 2721| | { | | 2722| | size_t n = size - l > sizeof(tmp) ? sizeof(tmp) : (size_t) (size - l); | | 2723| | n = fread(tmp, 1, n, fp); | | 2724| | if (n == 0) | | 2725| | break; | | 2726| | __LZOLIB_FUNCNAME(lzo_hmemcpy)((lzo_hbyte_p)buf + l, tmp, (lzo_hsize_t)n); | | 2727| | l += n; | | 2728| | } | | 2729| | return l; | | 2730| |#elif (LZO_MM_COMPACT || LZO_MM_LARGE || LZO_MM_HUGE) | | 2731| | lzo_hbyte_p b = (lzo_hbyte_p) buf; | | 2732| | lzo_hsize_t l = 0; | | 2733| | while (l < size) | | 2734| | { | | 2735| | size_t n; | | 2736| | n = LZO_PTR_FP_OFF(b); n = (n <= 1) ? 0x8000u : (0u - n); | | 2737| | if ((lzo_hsize_t) n > size - l) | | 2738| | n = (size_t) (size - l); | | 2739| | n = fread((void __far*)b, 1, n, fp); | | 2740| | if (n == 0) | | 2741| | break; | | 2742| | b += n; l += n; | | 2743| | } | | 2744| | return l; | | 2745| |#else | | 2746| |# error "unknown memory model" | | 2747| |#endif | | 2748| |#else | | 2749| | return fread(buf, 1, size, fp); | | 2750| |#endif | | 2751| |} | | 2752| |LZOLIB_PUBLIC(lzo_hsize_t, lzo_hfwrite) (void* vfp, const lzo_hvoid_p buf, lzo_hsize_t size) | | 2753| |{ | | 2754| | FILE* fp = LZO_STATIC_CAST(FILE *, vfp); | | 2755| |#if (LZO_HAVE_MM_HUGE_PTR) | | 2756| |#if (LZO_MM_TINY || LZO_MM_SMALL || LZO_MM_MEDIUM) | | 2757| |#define __LZOLIB_REQUIRE_HMEMCPY_CH 1 | | 2758| | unsigned char tmp[512]; | | 2759| | lzo_hsize_t l = 0; | | 2760| | while (l < size) | | 2761| | { | | 2762| | size_t n = size - l > sizeof(tmp) ? sizeof(tmp) : (size_t) (size - l); | | 2763| | __LZOLIB_FUNCNAME(lzo_hmemcpy)(tmp, (const lzo_hbyte_p)buf + l, (lzo_hsize_t)n); | | 2764| | n = fwrite(tmp, 1, n, fp); | | 2765| | if (n == 0) | | 2766| | break; | | 2767| | l += n; | | 2768| | } | | 2769| | return l; | | 2770| |#elif (LZO_MM_COMPACT || LZO_MM_LARGE || LZO_MM_HUGE) | | 2771| | const lzo_hbyte_p b = (const lzo_hbyte_p) buf; | | 2772| | lzo_hsize_t l = 0; | | 2773| | while (l < size) | | 2774| | { | | 2775| | size_t n; | | 2776| | n = LZO_PTR_FP_OFF(b); n = (n <= 1) ? 0x8000u : (0u - n); | | 2777| | if ((lzo_hsize_t) n > size - l) | | 2778| | n = (size_t) (size - l); | | 2779| | n = fwrite((void __far*)b, 1, n, fp); | | 2780| | if (n == 0) | | 2781| | break; | | 2782| | b += n; l += n; | | 2783| | } | | 2784| | return l; | | 2785| |#else | | 2786| |# error "unknown memory model" | | 2787| |#endif | | 2788| |#else | | 2789| | return fwrite(buf, 1, size, fp); | | 2790| |#endif | | 2791| |} | | 2792| |#endif | | 2793| |#if defined(LZO_WANT_ACCLIB_HSREAD) | | 2794| |# undef LZO_WANT_ACCLIB_HSREAD | | 2795| |#define __LZOLIB_HSREAD_CH_INCLUDED 1 | | 2796| |#if !defined(LZOLIB_PUBLIC) | | 2797| |# define LZOLIB_PUBLIC(r,f) r __LZOLIB_FUNCNAME(f) | | 2798| |#endif | | 2799| |LZOLIB_PUBLIC(long, lzo_safe_hread) (int fd, lzo_hvoid_p buf, long size) | | 2800| |{ | | 2801| | lzo_hbyte_p b = (lzo_hbyte_p) buf; | | 2802| | long l = 0; | | 2803| | int saved_errno; | | 2804| | saved_errno = errno; | | 2805| | while (l < size) | | 2806| | { | | 2807| | long n = size - l; | | 2808| |#if (LZO_HAVE_MM_HUGE_PTR) | | 2809| |# define __LZOLIB_REQUIRE_HREAD_CH 1 | | 2810| | errno = 0; n = lzo_hread(fd, b, n); | | 2811| |#elif (LZO_OS_DOS32) && defined(__DJGPP__) | | 2812| | errno = 0; n = _read(fd, b, n); | | 2813| |#else | | 2814| | errno = 0; n = read(fd, b, n); | | 2815| |#endif | | 2816| | if (n == 0) | | 2817| | break; | | 2818| | if (n < 0) { | | 2819| |#if defined(EAGAIN) | | 2820| | if (errno == (EAGAIN)) continue; | | 2821| |#endif | | 2822| |#if defined(EINTR) | | 2823| | if (errno == (EINTR)) continue; | | 2824| |#endif | | 2825| | if (errno == 0) errno = 1; | | 2826| | return l; | | 2827| | } | | 2828| | b += n; l += n; | | 2829| | } | | 2830| | errno = saved_errno; | | 2831| | return l; | | 2832| |} | | 2833| |LZOLIB_PUBLIC(long, lzo_safe_hwrite) (int fd, const lzo_hvoid_p buf, long size) | | 2834| |{ | | 2835| | const lzo_hbyte_p b = (const lzo_hbyte_p) buf; | | 2836| | long l = 0; | | 2837| | int saved_errno; | | 2838| | saved_errno = errno; | | 2839| | while (l < size) | | 2840| | { | | 2841| | long n = size - l; | | 2842| |#if (LZO_HAVE_MM_HUGE_PTR) | | 2843| |# define __LZOLIB_REQUIRE_HREAD_CH 1 | | 2844| | errno = 0; n = lzo_hwrite(fd, b, n); | | 2845| |#elif (LZO_OS_DOS32) && defined(__DJGPP__) | | 2846| | errno = 0; n = _write(fd, b, n); | | 2847| |#else | | 2848| | errno = 0; n = write(fd, b, n); | | 2849| |#endif | | 2850| | if (n == 0) | | 2851| | break; | | 2852| | if (n < 0) { | | 2853| |#if defined(EAGAIN) | | 2854| | if (errno == (EAGAIN)) continue; | | 2855| |#endif | | 2856| |#if defined(EINTR) | | 2857| | if (errno == (EINTR)) continue; | | 2858| |#endif | | 2859| | if (errno == 0) errno = 1; | | 2860| | return l; | | 2861| | } | | 2862| | b += n; l += n; | | 2863| | } | | 2864| | errno = saved_errno; | | 2865| | return l; | | 2866| |} | | 2867| |#endif | | 2868| |#if defined(LZO_WANT_ACCLIB_PCLOCK) | | 2869| |# undef LZO_WANT_ACCLIB_PCLOCK | | 2870| |#define __LZOLIB_PCLOCK_CH_INCLUDED 1 | | 2871| |#if !defined(LZOLIB_PUBLIC) | | 2872| |# define LZOLIB_PUBLIC(r,f) r __LZOLIB_FUNCNAME(f) | | 2873| |#endif | | 2874| |#if 1 && (LZO_OS_POSIX_LINUX && LZO_ARCH_AMD64 && LZO_ASM_SYNTAX_GNUC && !LZO_CFG_NO_SYSCALL) | | 2875| |#ifndef lzo_pclock_syscall_clock_gettime | | 2876| |#define lzo_pclock_syscall_clock_gettime lzo_pclock_syscall_clock_gettime | | 2877| |#endif | | 2878| |__lzo_static_noinline long lzo_pclock_syscall_clock_gettime(long clockid, struct timespec *ts) | | 2879| |{ | | 2880| | unsigned long r = 228; | | 2881| | __asm__ __volatile__("syscall\n" : "=a" (r), "=m" (*ts) : "0" (r), "D" (clockid), "S" (ts) __LZO_ASM_CLOBBER_LIST_CC); | | 2882| | return LZO_ICAST(long, r); | | 2883| |} | | 2884| |#endif | | 2885| |#if 1 && (LZO_OS_POSIX_LINUX && LZO_ARCH_I386 && LZO_ASM_SYNTAX_GNUC && !LZO_CFG_NO_SYSCALL) && defined(lzo_int64l_t) | | 2886| |#ifndef lzo_pclock_syscall_clock_gettime | | 2887| |#define lzo_pclock_syscall_clock_gettime lzo_pclock_syscall_clock_gettime | | 2888| |#endif | | 2889| |__lzo_static_noinline long lzo_pclock_syscall_clock_gettime(long clockid, struct timespec *ts) | | 2890| |{ | | 2891| | unsigned long r = 265; | | 2892| | __asm__ __volatile__("pushl %%ebx\n pushl %%edx\n popl %%ebx\n int $0x80\n popl %%ebx\n": "=a" (r), "=m" (*ts) : "0" (r), "d" (clockid), "c" (ts) __LZO_ASM_CLOBBER_LIST_CC); | | 2893| | return LZO_ICAST(long, r); | | 2894| |} | | 2895| |#endif | | 2896| |#if 0 && defined(lzo_pclock_syscall_clock_gettime) | | 2897| |#ifndef lzo_pclock_read_clock_gettime_r_syscall | | 2898| |#define lzo_pclock_read_clock_gettime_r_syscall lzo_pclock_read_clock_gettime_r_syscall | | 2899| |#endif | | 2900| |static int lzo_pclock_read_clock_gettime_r_syscall(lzo_pclock_handle_p h, lzo_pclock_p c) | | 2901| |{ | | 2902| | struct timespec ts; | | 2903| | if (lzo_pclock_syscall_clock_gettime(0, &ts) != 0) | | 2904| | return -1; | | 2905| | c->tv_sec = ts.tv_sec; | | 2906| | c->tv_nsec = LZO_STATIC_CAST(lzo_uint32l_t, ts.tv_nsec); | | 2907| | LZO_UNUSED(h); return 0; | | 2908| |} | | 2909| |#endif | | 2910| |#if (HAVE_GETTIMEOFDAY) | | 2911| |#ifndef lzo_pclock_read_gettimeofday | | 2912| |#define lzo_pclock_read_gettimeofday lzo_pclock_read_gettimeofday | | 2913| |#endif | | 2914| |static int lzo_pclock_read_gettimeofday(lzo_pclock_handle_p h, lzo_pclock_p c) | | 2915| |{ | | 2916| | struct timeval tv; | | 2917| | if (gettimeofday(&tv, NULL) != 0) | | 2918| | return -1; | | 2919| |#if defined(lzo_int64l_t) | | 2920| | c->tv_sec = tv.tv_sec; | | 2921| |#else | | 2922| | c->tv_sec_high = 0; | | 2923| | c->tv_sec_low = tv.tv_sec; | | 2924| |#endif | | 2925| | c->tv_nsec = LZO_STATIC_CAST(lzo_uint32l_t, (tv.tv_usec * 1000u)); | | 2926| | LZO_UNUSED(h); return 0; | | 2927| |} | | 2928| |#endif | | 2929| |#if defined(CLOCKS_PER_SEC) && !(LZO_CFG_NO_DOUBLE) | | 2930| |#ifndef lzo_pclock_read_clock | | 2931| |#define lzo_pclock_read_clock lzo_pclock_read_clock | | 2932| |#endif | | 2933| |static int lzo_pclock_read_clock(lzo_pclock_handle_p h, lzo_pclock_p c) | | 2934| |{ | | 2935| | clock_t ticks; | | 2936| | double secs; | | 2937| |#if defined(lzo_int64l_t) | | 2938| | lzo_uint64l_t nsecs; | | 2939| | ticks = clock(); | | 2940| | secs = LZO_STATIC_CAST(double, ticks) / (CLOCKS_PER_SEC); | | 2941| | nsecs = LZO_STATIC_CAST(lzo_uint64l_t, (secs * 1000000000.0)); | | 2942| | c->tv_sec = LZO_STATIC_CAST(lzo_int64l_t, (nsecs / 1000000000ul)); | | 2943| | nsecs = (nsecs % 1000000000ul); | | 2944| | c->tv_nsec = LZO_STATIC_CAST(lzo_uint32l_t, nsecs); | | 2945| |#else | | 2946| | ticks = clock(); | | 2947| | secs = LZO_STATIC_CAST(double, ticks) / (CLOCKS_PER_SEC); | | 2948| | c->tv_sec_high = 0; | | 2949| | c->tv_sec_low = LZO_STATIC_CAST(lzo_uint32l_t, (secs + 0.5)); | | 2950| | c->tv_nsec = 0; | | 2951| |#endif | | 2952| | LZO_UNUSED(h); return 0; | | 2953| |} | | 2954| |#endif | | 2955| |#if 1 && defined(lzo_pclock_syscall_clock_gettime) | | 2956| |#ifndef lzo_pclock_read_clock_gettime_m_syscall | | 2957| |#define lzo_pclock_read_clock_gettime_m_syscall lzo_pclock_read_clock_gettime_m_syscall | | 2958| |#endif | | 2959| |static int lzo_pclock_read_clock_gettime_m_syscall(lzo_pclock_handle_p h, lzo_pclock_p c) | | 2960| |{ | | 2961| | struct timespec ts; | | 2962| | if (lzo_pclock_syscall_clock_gettime(1, &ts) != 0) | | 2963| | return -1; | | 2964| | c->tv_sec = ts.tv_sec; | | 2965| | c->tv_nsec = LZO_STATIC_CAST(lzo_uint32l_t, ts.tv_nsec); | | 2966| | LZO_UNUSED(h); return 0; | | 2967| |} | | 2968| |#endif | | 2969| |#if (LZO_OS_DOS32 && LZO_CC_GNUC) && defined(__DJGPP__) && defined(UCLOCKS_PER_SEC) && !(LZO_CFG_NO_DOUBLE) | | 2970| |#ifndef lzo_pclock_read_uclock | | 2971| |#define lzo_pclock_read_uclock lzo_pclock_read_uclock | | 2972| |#endif | | 2973| |static int lzo_pclock_read_uclock(lzo_pclock_handle_p h, lzo_pclock_p c) | | 2974| |{ | | 2975| | lzo_uint64l_t ticks; | | 2976| | double secs; | | 2977| | lzo_uint64l_t nsecs; | | 2978| | ticks = uclock(); | | 2979| | secs = LZO_STATIC_CAST(double, ticks) / (UCLOCKS_PER_SEC); | | 2980| | nsecs = LZO_STATIC_CAST(lzo_uint64l_t, (secs * 1000000000.0)); | | 2981| | c->tv_sec = nsecs / 1000000000ul; | | 2982| | c->tv_nsec = LZO_STATIC_CAST(lzo_uint32l_t, (nsecs % 1000000000ul)); | | 2983| | LZO_UNUSED(h); return 0; | | 2984| |} | | 2985| |#endif | | 2986| |#if 1 && (HAVE_CLOCK_GETTIME) && defined(CLOCK_PROCESS_CPUTIME_ID) && defined(lzo_int64l_t) | | 2987| |#ifndef lzo_pclock_read_clock_gettime_p_libc | | 2988| |#define lzo_pclock_read_clock_gettime_p_libc lzo_pclock_read_clock_gettime_p_libc | | 2989| |#endif | | 2990| |static int lzo_pclock_read_clock_gettime_p_libc(lzo_pclock_handle_p h, lzo_pclock_p c) | | 2991| |{ | | 2992| | struct timespec ts; | | 2993| | if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts) != 0) | | 2994| | return -1; | | 2995| | c->tv_sec = ts.tv_sec; | | 2996| | c->tv_nsec = LZO_STATIC_CAST(lzo_uint32l_t, ts.tv_nsec); | | 2997| | LZO_UNUSED(h); return 0; | | 2998| |} | | 2999| |#endif | | 3000| |#if 1 && defined(lzo_pclock_syscall_clock_gettime) | | 3001| |#ifndef lzo_pclock_read_clock_gettime_p_syscall | | 3002| |#define lzo_pclock_read_clock_gettime_p_syscall lzo_pclock_read_clock_gettime_p_syscall | | 3003| |#endif | | 3004| |static int lzo_pclock_read_clock_gettime_p_syscall(lzo_pclock_handle_p h, lzo_pclock_p c) | | 3005| |{ | | 3006| | struct timespec ts; | | 3007| | if (lzo_pclock_syscall_clock_gettime(2, &ts) != 0) | | 3008| | return -1; | | 3009| | c->tv_sec = ts.tv_sec; | | 3010| | c->tv_nsec = LZO_STATIC_CAST(lzo_uint32l_t, ts.tv_nsec); | | 3011| | LZO_UNUSED(h); return 0; | | 3012| |} | | 3013| |#endif | | 3014| |#if (LZO_OS_CYGWIN || LZO_OS_WIN32 || LZO_OS_WIN64) && (LZO_HAVE_WINDOWS_H) && defined(lzo_int64l_t) | | 3015| |#ifndef lzo_pclock_read_getprocesstimes | | 3016| |#define lzo_pclock_read_getprocesstimes lzo_pclock_read_getprocesstimes | | 3017| |#endif | | 3018| |static int lzo_pclock_read_getprocesstimes(lzo_pclock_handle_p h, lzo_pclock_p c) | | 3019| |{ | | 3020| | FILETIME ct, et, kt, ut; | | 3021| | lzo_uint64l_t ticks; | | 3022| | if (GetProcessTimes(GetCurrentProcess(), &ct, &et, &kt, &ut) == 0) | | 3023| | return -1; | | 3024| | ticks = (LZO_STATIC_CAST(lzo_uint64l_t, ut.dwHighDateTime) << 32) | ut.dwLowDateTime; | | 3025| | if __lzo_unlikely(h->ticks_base == 0) | | 3026| | h->ticks_base = ticks; | | 3027| | else | | 3028| | ticks -= h->ticks_base; | | 3029| | c->tv_sec = LZO_STATIC_CAST(lzo_int64l_t, (ticks / 10000000ul)); | | 3030| | ticks = (ticks % 10000000ul) * 100u; | | 3031| | c->tv_nsec = LZO_STATIC_CAST(lzo_uint32l_t, ticks); | | 3032| | LZO_UNUSED(h); return 0; | | 3033| |} | | 3034| |#endif | | 3035| |#if (HAVE_GETRUSAGE) && defined(RUSAGE_SELF) | | 3036| |#ifndef lzo_pclock_read_getrusage | | 3037| |#define lzo_pclock_read_getrusage lzo_pclock_read_getrusage | | 3038| |#endif | | 3039| |static int lzo_pclock_read_getrusage(lzo_pclock_handle_p h, lzo_pclock_p c) | | 3040| |{ | | 3041| | struct rusage ru; | | 3042| | if (getrusage(RUSAGE_SELF, &ru) != 0) | | 3043| | return -1; | | 3044| |#if defined(lzo_int64l_t) | | 3045| | c->tv_sec = ru.ru_utime.tv_sec; | | 3046| |#else | | 3047| | c->tv_sec_high = 0; | | 3048| | c->tv_sec_low = ru.ru_utime.tv_sec; | | 3049| |#endif | | 3050| | c->tv_nsec = LZO_STATIC_CAST(lzo_uint32l_t, (ru.ru_utime.tv_usec * 1000u)); | | 3051| | LZO_UNUSED(h); return 0; | | 3052| |} | | 3053| |#endif | | 3054| |#if 1 && (HAVE_CLOCK_GETTIME) && defined(CLOCK_THREAD_CPUTIME_ID) && defined(lzo_int64l_t) | | 3055| |#ifndef lzo_pclock_read_clock_gettime_t_libc | | 3056| |#define lzo_pclock_read_clock_gettime_t_libc lzo_pclock_read_clock_gettime_t_libc | | 3057| |#endif | | 3058| |static int lzo_pclock_read_clock_gettime_t_libc(lzo_pclock_handle_p h, lzo_pclock_p c) | | 3059| |{ | | 3060| | struct timespec ts; | | 3061| | if (clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts) != 0) | | 3062| | return -1; | | 3063| | c->tv_sec = ts.tv_sec; | | 3064| | c->tv_nsec = (lzo_uint32l_t) ts.tv_nsec; | | 3065| | LZO_UNUSED(h); return 0; | | 3066| |} | | 3067| |#endif | | 3068| |#if 1 && defined(lzo_pclock_syscall_clock_gettime) | | 3069| |#ifndef lzo_pclock_read_clock_gettime_t_syscall | | 3070| |#define lzo_pclock_read_clock_gettime_t_syscall lzo_pclock_read_clock_gettime_t_syscall | | 3071| |#endif | | 3072| |static int lzo_pclock_read_clock_gettime_t_syscall(lzo_pclock_handle_p h, lzo_pclock_p c) | | 3073| |{ | | 3074| | struct timespec ts; | | 3075| | if (lzo_pclock_syscall_clock_gettime(3, &ts) != 0) | | 3076| | return -1; | | 3077| | c->tv_sec = ts.tv_sec; | | 3078| | c->tv_nsec = LZO_STATIC_CAST(lzo_uint32l_t, ts.tv_nsec); | | 3079| | LZO_UNUSED(h); return 0; | | 3080| |} | | 3081| |#endif | | 3082| |#if (LZO_OS_CYGWIN || LZO_OS_WIN32 || LZO_OS_WIN64) && (LZO_HAVE_WINDOWS_H) && defined(lzo_int64l_t) | | 3083| |#ifndef lzo_pclock_read_getthreadtimes | | 3084| |#define lzo_pclock_read_getthreadtimes lzo_pclock_read_getthreadtimes | | 3085| |#endif | | 3086| |static int lzo_pclock_read_getthreadtimes(lzo_pclock_handle_p h, lzo_pclock_p c) | | 3087| |{ | | 3088| | FILETIME ct, et, kt, ut; | | 3089| | lzo_uint64l_t ticks; | | 3090| | if (GetThreadTimes(GetCurrentThread(), &ct, &et, &kt, &ut) == 0) | | 3091| | return -1; | | 3092| | ticks = (LZO_STATIC_CAST(lzo_uint64l_t, ut.dwHighDateTime) << 32) | ut.dwLowDateTime; | | 3093| | if __lzo_unlikely(h->ticks_base == 0) | | 3094| | h->ticks_base = ticks; | | 3095| | else | | 3096| | ticks -= h->ticks_base; | | 3097| | c->tv_sec = LZO_STATIC_CAST(lzo_int64l_t, (ticks / 10000000ul)); | | 3098| | ticks = (ticks % 10000000ul) * 100u; | | 3099| | c->tv_nsec = LZO_STATIC_CAST(lzo_uint32l_t, ticks); | | 3100| | LZO_UNUSED(h); return 0; | | 3101| |} | | 3102| |#endif | | 3103| |LZOLIB_PUBLIC(int, lzo_pclock_open) (lzo_pclock_handle_p h, int mode) | | 3104| |{ | | 3105| | lzo_pclock_t c; | | 3106| | int i; | | 3107| | h->h = LZO_STATIC_CAST(lzolib_handle_t, 0); | | 3108| | h->mode = -1; | | 3109| | h->read_error = 2; | | 3110| | h->name = NULL; | | 3111| | h->gettime = LZO_STATIC_CAST(lzo_pclock_gettime_t, 0); | | 3112| |#if defined(lzo_int64l_t) | | 3113| | h->ticks_base = 0; | | 3114| |#endif | | 3115| | switch (mode) | | 3116| | { | | 3117| | case LZO_PCLOCK_REALTIME: | | 3118| |# if defined(lzo_pclock_read_clock_gettime_r_syscall) | | 3119| | if (lzo_pclock_read_clock_gettime_r_syscall(h, &c) == 0) { | | 3120| | h->gettime = lzo_pclock_read_clock_gettime_r_syscall; | | 3121| | h->name = "CLOCK_REALTIME/syscall"; | | 3122| | break; | | 3123| | } | | 3124| |# endif | | 3125| |# if defined(lzo_pclock_read_gettimeofday) | | 3126| | if (lzo_pclock_read_gettimeofday(h, &c) == 0) { | | 3127| | h->gettime = lzo_pclock_read_gettimeofday; | | 3128| | h->name = "gettimeofday"; | | 3129| | break; | | 3130| | } | | 3131| |# endif | | 3132| | break; | | 3133| | case LZO_PCLOCK_MONOTONIC: | | 3134| |# if defined(lzo_pclock_read_clock_gettime_m_syscall) | | 3135| | if (lzo_pclock_read_clock_gettime_m_syscall(h, &c) == 0) { | | 3136| | h->gettime = lzo_pclock_read_clock_gettime_m_syscall; | | 3137| | h->name = "CLOCK_MONOTONIC/syscall"; | | 3138| | break; | | 3139| | } | | 3140| |# endif | | 3141| |# if defined(lzo_pclock_read_uclock) | | 3142| | if (lzo_pclock_read_uclock(h, &c) == 0) { | | 3143| | h->gettime = lzo_pclock_read_uclock; | | 3144| | h->name = "uclock"; | | 3145| | break; | | 3146| | } | | 3147| |# endif | | 3148| |# if defined(lzo_pclock_read_clock) | | 3149| | if (lzo_pclock_read_clock(h, &c) == 0) { | | 3150| | h->gettime = lzo_pclock_read_clock; | | 3151| | h->name = "clock"; | | 3152| | break; | | 3153| | } | | 3154| |# endif | | 3155| | break; | | 3156| | case LZO_PCLOCK_PROCESS_CPUTIME_ID: | | 3157| |# if defined(lzo_pclock_read_getprocesstimes) | | 3158| | if (lzo_pclock_read_getprocesstimes(h, &c) == 0) { | | 3159| | h->gettime = lzo_pclock_read_getprocesstimes; | | 3160| | h->name = "GetProcessTimes"; | | 3161| | break; | | 3162| | } | | 3163| |# endif | | 3164| |# if defined(lzo_pclock_read_clock_gettime_p_syscall) | | 3165| | if (lzo_pclock_read_clock_gettime_p_syscall(h, &c) == 0) { | | 3166| | h->gettime = lzo_pclock_read_clock_gettime_p_syscall; | | 3167| | h->name = "CLOCK_PROCESS_CPUTIME_ID/syscall"; | | 3168| | break; | | 3169| | } | | 3170| |# endif | | 3171| |# if defined(lzo_pclock_read_clock_gettime_p_libc) | | 3172| | if (lzo_pclock_read_clock_gettime_p_libc(h, &c) == 0) { | | 3173| | h->gettime = lzo_pclock_read_clock_gettime_p_libc; | | 3174| | h->name = "CLOCK_PROCESS_CPUTIME_ID/libc"; | | 3175| | break; | | 3176| | } | | 3177| |# endif | | 3178| |# if defined(lzo_pclock_read_getrusage) | | 3179| | if (lzo_pclock_read_getrusage(h, &c) == 0) { | | 3180| | h->gettime = lzo_pclock_read_getrusage; | | 3181| | h->name = "getrusage"; | | 3182| | break; | | 3183| | } | | 3184| |# endif | | 3185| | break; | | 3186| | case LZO_PCLOCK_THREAD_CPUTIME_ID: | | 3187| |# if defined(lzo_pclock_read_getthreadtimes) | | 3188| | if (lzo_pclock_read_getthreadtimes(h, &c) == 0) { | | 3189| | h->gettime = lzo_pclock_read_getthreadtimes; | | 3190| | h->name = "GetThreadTimes"; | | 3191| | } | | 3192| |# endif | | 3193| |# if defined(lzo_pclock_read_clock_gettime_t_syscall) | | 3194| | if (lzo_pclock_read_clock_gettime_t_syscall(h, &c) == 0) { | | 3195| | h->gettime = lzo_pclock_read_clock_gettime_t_syscall; | | 3196| | h->name = "CLOCK_THREAD_CPUTIME_ID/syscall"; | | 3197| | break; | | 3198| | } | | 3199| |# endif | | 3200| |# if defined(lzo_pclock_read_clock_gettime_t_libc) | | 3201| | if (lzo_pclock_read_clock_gettime_t_libc(h, &c) == 0) { | | 3202| | h->gettime = lzo_pclock_read_clock_gettime_t_libc; | | 3203| | h->name = "CLOCK_THREAD_CPUTIME_ID/libc"; | | 3204| | break; | | 3205| | } | | 3206| |# endif | | 3207| | break; | | 3208| | } | | 3209| | if (!h->gettime) | | 3210| | return -1; | | 3211| | if (!h->h) | | 3212| | h->h = LZO_STATIC_CAST(lzolib_handle_t, 1); | | 3213| | h->mode = mode; | | 3214| | h->read_error = 0; | | 3215| | if (!h->name) | | 3216| | h->name = "unknown"; | | 3217| | for (i = 0; i < 10; i++) { | | 3218| | __LZOLIB_FUNCNAME(lzo_pclock_read)(h, &c); | | 3219| | } | | 3220| | return 0; | | 3221| |} | | 3222| |LZOLIB_PUBLIC(int, lzo_pclock_open_default) (lzo_pclock_handle_p h) | | 3223| |{ | | 3224| | if (__LZOLIB_FUNCNAME(lzo_pclock_open)(h, LZO_PCLOCK_PROCESS_CPUTIME_ID) == 0) | | 3225| | return 0; | | 3226| | if (__LZOLIB_FUNCNAME(lzo_pclock_open)(h, LZO_PCLOCK_MONOTONIC) == 0) | | 3227| | return 0; | | 3228| | if (__LZOLIB_FUNCNAME(lzo_pclock_open)(h, LZO_PCLOCK_REALTIME) == 0) | | 3229| | return 0; | | 3230| | if (__LZOLIB_FUNCNAME(lzo_pclock_open)(h, LZO_PCLOCK_THREAD_CPUTIME_ID) == 0) | | 3231| | return 0; | | 3232| | return -1; | | 3233| |} | | 3234| |LZOLIB_PUBLIC(int, lzo_pclock_close) (lzo_pclock_handle_p h) | | 3235| |{ | | 3236| | h->h = LZO_STATIC_CAST(lzolib_handle_t, 0); | | 3237| | h->mode = -1; | | 3238| | h->name = NULL; | | 3239| | h->gettime = LZO_STATIC_CAST(lzo_pclock_gettime_t, 0); | | 3240| | return 0; | | 3241| |} | | 3242| |LZOLIB_PUBLIC(void, lzo_pclock_read) (lzo_pclock_handle_p h, lzo_pclock_p c) | | 3243| |{ | | 3244| | if (h->gettime) { | | 3245| | if (h->gettime(h, c) == 0) | | 3246| | return; | | 3247| | } | | 3248| | h->read_error = 1; | | 3249| |#if defined(lzo_int64l_t) | | 3250| | c->tv_sec = 0; | | 3251| |#else | | 3252| | c->tv_sec_high = 0; | | 3253| | c->tv_sec_low = 0; | | 3254| |#endif | | 3255| | c->tv_nsec = 0; | | 3256| |} | | 3257| |#if !(LZO_CFG_NO_DOUBLE) | | 3258| |LZOLIB_PUBLIC(double, lzo_pclock_get_elapsed) (lzo_pclock_handle_p h, const lzo_pclock_p start, const lzo_pclock_p stop) | | 3259| |{ | | 3260| | if (!h->h) { h->mode = -1; return 0.0; } | | 3261| | { | | 3262| |#if 1 && (LZO_ARCH_I386 && LZO_CC_GNUC) && defined(__STRICT_ALIGNMENT__) | | 3263| | float tstop, tstart; | | 3264| | tstop = LZO_STATIC_CAST(float, (stop->tv_sec + stop->tv_nsec / 1000000000.0)); | | 3265| | tstart = LZO_STATIC_CAST(float, (start->tv_sec + start->tv_nsec / 1000000000.0)); | | 3266| |#elif defined(lzo_int64l_t) | | 3267| | double tstop, tstart; | | 3268| |#if 1 && (LZO_CC_INTELC) | | 3269| | { lzo_int64l_t a = stop->tv_sec; lzo_uint32l_t b = stop->tv_nsec; | | 3270| | tstop = a + b / 1000000000.0; } | | 3271| | { lzo_int64l_t a = start->tv_sec; lzo_uint32l_t b = start->tv_nsec; | | 3272| | tstart = a + b / 1000000000.0; } | | 3273| |#else | | 3274| | tstop = stop->tv_sec + stop->tv_nsec / 1000000000.0; | | 3275| | tstart = start->tv_sec + start->tv_nsec / 1000000000.0; | | 3276| |#endif | | 3277| |#else | | 3278| | double tstop, tstart; | | 3279| | tstop = stop->tv_sec_low + stop->tv_nsec / 1000000000.0; | | 3280| | tstart = start->tv_sec_low + start->tv_nsec / 1000000000.0; | | 3281| |#endif | | 3282| | return tstop - tstart; | | 3283| | } | | 3284| |} | | 3285| |#endif | | 3286| |LZOLIB_PUBLIC(int, lzo_pclock_flush_cpu_cache) (lzo_pclock_handle_p h, unsigned flags) | | 3287| |{ | | 3288| | LZO_UNUSED(h); LZO_UNUSED(flags); | | 3289| | return -1; | | 3290| |} | | 3291| |#endif | | 3292| |#if defined(LZO_WANT_ACCLIB_MISC) | | 3293| |# undef LZO_WANT_ACCLIB_MISC | | 3294| |#define __LZOLIB_MISC_CH_INCLUDED 1 | | 3295| |#if !defined(LZOLIB_PUBLIC) | | 3296| |# define LZOLIB_PUBLIC(r,f) r __LZOLIB_FUNCNAME(f) | | 3297| |#endif | | 3298| |#if !defined(LZOLIB_PUBLIC_NOINLINE) | | 3299| |# if !defined(__lzo_noinline) | | 3300| |# define LZOLIB_PUBLIC_NOINLINE(r,f) r __LZOLIB_FUNCNAME(f) | | 3301| |# elif (LZO_CC_CLANG || (LZO_CC_GNUC >= 0x030400ul) || LZO_CC_LLVM) | | 3302| |# define LZOLIB_PUBLIC_NOINLINE(r,f) __lzo_noinline __attribute__((__used__)) r __LZOLIB_FUNCNAME(f) | | 3303| |# else | | 3304| |# define LZOLIB_PUBLIC_NOINLINE(r,f) __lzo_noinline r __LZOLIB_FUNCNAME(f) | | 3305| |# endif | | 3306| |#endif | | 3307| |#if (LZO_OS_WIN32 && LZO_CC_PELLESC && (__POCC__ >= 290)) | | 3308| |# pragma warn(push) | | 3309| |# pragma warn(disable:2007) | | 3310| |#endif | | 3311| |LZOLIB_PUBLIC(const char *, lzo_getenv) (const char *s) | | 3312| |{ | | 3313| |#if (HAVE_GETENV) | | 3314| | return getenv(s); | | 3315| |#else | | 3316| | LZO_UNUSED(s); return LZO_STATIC_CAST(const char *, 0); | | 3317| |#endif | | 3318| |} | | 3319| |LZOLIB_PUBLIC(lzo_intptr_t, lzo_get_osfhandle) (int fd) | | 3320| |{ | | 3321| | if (fd < 0) | | 3322| | return -1; | | 3323| |#if (LZO_OS_CYGWIN) | | 3324| | return get_osfhandle(fd); | | 3325| |#elif (LZO_OS_EMX && defined(__RSXNT__)) | | 3326| | return -1; | | 3327| |#elif (LZO_OS_WIN32 && LZO_CC_GNUC) && defined(__PW32__) | | 3328| | return -1; | | 3329| |#elif (LZO_OS_WIN32 || LZO_OS_WIN64) | | 3330| |# if (LZO_CC_PELLESC && (__POCC__ < 280)) | | 3331| | return -1; | | 3332| |# elif (LZO_CC_WATCOMC && (__WATCOMC__ < 1000)) | | 3333| | return -1; | | 3334| |# elif (LZO_CC_WATCOMC && (__WATCOMC__ < 1100)) | | 3335| | return _os_handle(fd); | | 3336| |# else | | 3337| | return _get_osfhandle(fd); | | 3338| |# endif | | 3339| |#else | | 3340| | return fd; | | 3341| |#endif | | 3342| |} | | 3343| |LZOLIB_PUBLIC(int, lzo_set_binmode) (int fd, int binary) | | 3344| |{ | | 3345| |#if (LZO_ARCH_M68K && LZO_OS_TOS && LZO_CC_GNUC) && defined(__MINT__) | | 3346| | FILE* fp; int old_binary; | | 3347| | if (fd == STDIN_FILENO) fp = stdin; | | 3348| | else if (fd == STDOUT_FILENO) fp = stdout; | | 3349| | else if (fd == STDERR_FILENO) fp = stderr; | | 3350| | else return -1; | | 3351| | old_binary = fp->__mode.__binary; | | 3352| | __set_binmode(fp, binary ? 1 : 0); | | 3353| | return old_binary ? 1 : 0; | | 3354| |#elif (LZO_ARCH_M68K && LZO_OS_TOS) | | 3355| | LZO_UNUSED(fd); LZO_UNUSED(binary); | | 3356| | return -1; | | 3357| |#elif (LZO_OS_DOS16 && (LZO_CC_AZTECC || LZO_CC_PACIFICC)) | | 3358| | LZO_UNUSED(fd); LZO_UNUSED(binary); | | 3359| | return -1; | | 3360| |#elif (LZO_OS_DOS32 && LZO_CC_GNUC) && defined(__DJGPP__) | | 3361| | int r; unsigned old_flags = __djgpp_hwint_flags; | | 3362| | LZO_COMPILE_TIME_ASSERT(O_BINARY > 0) | | 3363| | LZO_COMPILE_TIME_ASSERT(O_TEXT > 0) | | 3364| | if (fd < 0) return -1; | | 3365| | r = setmode(fd, binary ? O_BINARY : O_TEXT); | | 3366| | if ((old_flags & 1u) != (__djgpp_hwint_flags & 1u)) | | 3367| | __djgpp_set_ctrl_c(!(old_flags & 1)); | | 3368| | if (r == -1) return -1; | | 3369| | return (r & O_TEXT) ? 0 : 1; | | 3370| |#elif (LZO_OS_WIN32 && LZO_CC_GNUC) && defined(__PW32__) | | 3371| | if (fd < 0) return -1; | | 3372| | LZO_UNUSED(binary); | | 3373| | return 1; | | 3374| |#elif (LZO_OS_DOS32 && LZO_CC_HIGHC) | | 3375| | FILE* fp; int r; | | 3376| | if (fd == fileno(stdin)) fp = stdin; | | 3377| | else if (fd == fileno(stdout)) fp = stdout; | | 3378| | else if (fd == fileno(stderr)) fp = stderr; | | 3379| | else return -1; | | 3380| | r = _setmode(fp, binary ? _BINARY : _TEXT); | | 3381| | if (r == -1) return -1; | | 3382| | return (r & _BINARY) ? 1 : 0; | | 3383| |#elif (LZO_OS_WIN32 && LZO_CC_MWERKS) && defined(__MSL__) | | 3384| | LZO_UNUSED(fd); LZO_UNUSED(binary); | | 3385| | return -1; | | 3386| |#elif (LZO_OS_CYGWIN && (LZO_CC_GNUC < 0x025a00ul)) | | 3387| | LZO_UNUSED(fd); LZO_UNUSED(binary); | | 3388| | return -1; | | 3389| |#elif (LZO_OS_CYGWIN || LZO_OS_DOS16 || LZO_OS_DOS32 || LZO_OS_EMX || LZO_OS_OS2 || LZO_OS_OS216 || LZO_OS_WIN16 || LZO_OS_WIN32 || LZO_OS_WIN64) | | 3390| | int r; | | 3391| |#if !(LZO_CC_ZORTECHC) | | 3392| | LZO_COMPILE_TIME_ASSERT(O_BINARY > 0) | | 3393| |#endif | | 3394| | LZO_COMPILE_TIME_ASSERT(O_TEXT > 0) | | 3395| | if (fd < 0) return -1; | | 3396| | r = setmode(fd, binary ? O_BINARY : O_TEXT); | | 3397| | if (r == -1) return -1; | | 3398| | return (r & O_TEXT) ? 0 : 1; | | 3399| |#else | | 3400| | if (fd < 0) return -1; | | 3401| | LZO_UNUSED(binary); | | 3402| | return 1; | | 3403| |#endif | | 3404| |} | | 3405| |LZOLIB_PUBLIC(int, lzo_isatty) (int fd) | | 3406| |{ | | 3407| | if (fd < 0) | | 3408| | return 0; | | 3409| |#if (LZO_OS_DOS16 && !(LZO_CC_AZTECC)) | | 3410| | { | | 3411| | union REGS ri, ro; | | 3412| | ri.x.ax = 0x4400; ri.x.bx = fd; | | 3413| | int86(0x21, &ri, &ro); | | 3414| | if ((ro.x.cflag & 1) == 0) | | 3415| | if ((ro.x.ax & 0x83) != 0x83) | | 3416| | return 0; | | 3417| | } | | 3418| |#elif (LZO_OS_DOS32 && LZO_CC_WATCOMC) | | 3419| | { | | 3420| | union REGS ri, ro; | | 3421| | ri.w.ax = 0x4400; ri.w.bx = LZO_STATIC_CAST(unsigned short, fd); | | 3422| | int386(0x21, &ri, &ro); | | 3423| | if ((ro.w.cflag & 1) == 0) | | 3424| | if ((ro.w.ax & 0x83) != 0x83) | | 3425| | return 0; | | 3426| | } | | 3427| |#elif (LZO_HAVE_WINDOWS_H) | | 3428| | { | | 3429| | lzo_intptr_t h = __LZOLIB_FUNCNAME(lzo_get_osfhandle)(fd); | | 3430| | LZO_COMPILE_TIME_ASSERT(sizeof(h) == sizeof(HANDLE)) | | 3431| | if (h != -1) | | 3432| | { | | 3433| | DWORD d = 0; | | 3434| | if (GetConsoleMode(LZO_REINTERPRET_CAST(HANDLE, h), &d) == 0) | | 3435| | return 0; | | 3436| | } | | 3437| | } | | 3438| |#endif | | 3439| |#if (HAVE_ISATTY) | | 3440| | return (isatty(fd)) ? 1 : 0; | | 3441| |#else | | 3442| | return 0; | | 3443| |#endif | | 3444| |} | | 3445| |LZOLIB_PUBLIC(int, lzo_mkdir) (const char* name, unsigned mode) | | 3446| |{ | | 3447| |#if !(HAVE_MKDIR) | | 3448| | LZO_UNUSED(name); LZO_UNUSED(mode); | | 3449| | return -1; | | 3450| |#elif (LZO_ARCH_M68K && LZO_OS_TOS && (LZO_CC_PUREC || LZO_CC_TURBOC)) | | 3451| | LZO_UNUSED(mode); | | 3452| | return Dcreate(name); | | 3453| |#elif (LZO_OS_DOS32 && LZO_CC_GNUC) && defined(__DJGPP__) | | 3454| | return mkdir(name, mode); | | 3455| |#elif (LZO_OS_WIN32 && LZO_CC_GNUC) && defined(__PW32__) | | 3456| | return mkdir(name, mode); | | 3457| |#elif ((LZO_OS_DOS16 || LZO_OS_DOS32) && (LZO_CC_HIGHC || LZO_CC_PACIFICC)) | | 3458| | LZO_UNUSED(mode); | | 3459| | return mkdir(LZO_UNCONST_CAST(char *, name)); | | 3460| |#elif (LZO_OS_DOS16 || LZO_OS_DOS32 || LZO_OS_OS2 || LZO_OS_OS216 || LZO_OS_WIN16 || LZO_OS_WIN32 || LZO_OS_WIN64) | | 3461| | LZO_UNUSED(mode); | | 3462| | return mkdir(name); | | 3463| |#elif (LZO_CC_WATCOMC) | | 3464| | return mkdir(name, LZO_STATIC_CAST(mode_t, mode)); | | 3465| |#else | | 3466| | return mkdir(name, mode); | | 3467| |#endif | | 3468| |} | | 3469| |LZOLIB_PUBLIC(int, lzo_rmdir) (const char* name) | | 3470| |{ | | 3471| |#if !(HAVE_RMDIR) | | 3472| | LZO_UNUSED(name); | | 3473| | return -1; | | 3474| |#elif ((LZO_OS_DOS16 || LZO_OS_DOS32) && (LZO_CC_HIGHC || LZO_CC_PACIFICC)) | | 3475| | return rmdir(LZO_UNCONST_CAST(char *, name)); | | 3476| |#else | | 3477| | return rmdir(name); | | 3478| |#endif | | 3479| |} | | 3480| |#if defined(lzo_int32e_t) | | 3481| |LZOLIB_PUBLIC(lzo_int32e_t, lzo_muldiv32s) (lzo_int32e_t a, lzo_int32e_t b, lzo_int32e_t x) | | 3482| |{ | | 3483| | lzo_int32e_t r = 0; | | 3484| | if __lzo_likely(x != 0) | | 3485| | { | | 3486| |#if defined(lzo_int64l_t) | | 3487| | lzo_int64l_t rr = (LZO_ICONV(lzo_int64l_t, a) * b) / x; | | 3488| | r = LZO_ITRUNC(lzo_int32e_t, rr); | | 3489| |#else | | 3490| | LZO_UNUSED(a); LZO_UNUSED(b); | | 3491| |#endif | | 3492| | } | | 3493| | return r; | | 3494| |} | | 3495| |LZOLIB_PUBLIC(lzo_uint32e_t, lzo_muldiv32u) (lzo_uint32e_t a, lzo_uint32e_t b, lzo_uint32e_t x) | | 3496| |{ | | 3497| | lzo_uint32e_t r = 0; | | 3498| | if __lzo_likely(x != 0) | | 3499| | { | | 3500| |#if defined(lzo_int64l_t) | | 3501| | lzo_uint64l_t rr = (LZO_ICONV(lzo_uint64l_t, a) * b) / x; | | 3502| | r = LZO_ITRUNC(lzo_uint32e_t, rr); | | 3503| |#else | | 3504| | LZO_UNUSED(a); LZO_UNUSED(b); | | 3505| |#endif | | 3506| | } | | 3507| | return r; | | 3508| |} | | 3509| |#endif | | 3510| |#if (LZO_OS_WIN16) | | 3511| |LZO_EXTERN_C void __far __pascal DebugBreak(void); | | 3512| |#endif | | 3513| |LZOLIB_PUBLIC_NOINLINE(void, lzo_debug_break) (void) | | 3514| |{ | | 3515| |#if (LZO_OS_WIN16) | | 3516| | DebugBreak(); | | 3517| |#elif (LZO_ARCH_I086) | | 3518| |#elif (LZO_OS_WIN64) && (LZO_HAVE_WINDOWS_H) | | 3519| | DebugBreak(); | | 3520| |#elif (LZO_ARCH_AMD64 || LZO_ARCH_I386) && (LZO_ASM_SYNTAX_GNUC) | | 3521| | __asm__ __volatile__("int $3\n" : : __LZO_ASM_CLOBBER_LIST_CC_MEMORY); | | 3522| |#elif (LZO_ARCH_I386) && (LZO_ASM_SYNTAX_MSC) | | 3523| | __asm { int 3 } | | 3524| |#elif (LZO_OS_WIN32) && (LZO_HAVE_WINDOWS_H) | | 3525| | DebugBreak(); | | 3526| |#else | | 3527| | volatile lzo_intptr_t a = -1; | | 3528| | * LZO_STATIC_CAST(volatile unsigned long *, LZO_REINTERPRET_CAST(volatile void *, a)) = ~0ul; | | 3529| |#endif | | 3530| |} | | 3531| |LZOLIB_PUBLIC_NOINLINE(void, lzo_debug_nop) (void) | | 3532| |{ | | 3533| |} | | 3534| |LZOLIB_PUBLIC_NOINLINE(int, lzo_debug_align_check_query) (void) | | 3535| |{ | | 3536| |#if (LZO_ARCH_AMD64 || LZO_ARCH_I386) && (LZO_ASM_SYNTAX_GNUC) | | 3537| |# if (LZO_ARCH_AMD64) | | 3538| | lzo_uint64e_t r = 0; | | 3539| |# else | | 3540| | size_t r = 0; | | 3541| |# endif | | 3542| | __asm__ __volatile__("pushf\n pop %0\n" : "=a" (r) : __LZO_ASM_CLOBBER_LIST_CC_MEMORY); | | 3543| | return LZO_ICONV(int, (r >> 18) & 1); | | 3544| |#elif (LZO_ARCH_I386) && (LZO_ASM_SYNTAX_MSC) | | 3545| | unsigned long r; | | 3546| | __asm { | | 3547| | pushf | | 3548| | pop eax | | 3549| | mov r,eax | | 3550| | } | | 3551| | return LZO_ICONV(int, (r >> 18) & 1); | | 3552| |#else | | 3553| | return -1; | | 3554| |#endif | | 3555| |} | | 3556| |LZOLIB_PUBLIC_NOINLINE(int, lzo_debug_align_check_enable) (int v) | | 3557| |{ | | 3558| |#if (LZO_ARCH_AMD64) && (LZO_ASM_SYNTAX_GNUC) | | 3559| | if (v) { | | 3560| | __asm__ __volatile__("pushf\n orl $262144,(%%rsp)\n popf\n" : : __LZO_ASM_CLOBBER_LIST_CC_MEMORY); | | 3561| | } else { | | 3562| | __asm__ __volatile__("pushf\n andl $-262145,(%%rsp)\n popf\n" : : __LZO_ASM_CLOBBER_LIST_CC_MEMORY); | | 3563| | } | | 3564| | return 0; | | 3565| |#elif (LZO_ARCH_I386) && (LZO_ASM_SYNTAX_GNUC) | | 3566| | if (v) { | | 3567| | __asm__ __volatile__("pushf\n orl $262144,(%%esp)\n popf\n" : : __LZO_ASM_CLOBBER_LIST_CC_MEMORY); | | 3568| | } else { | | 3569| | __asm__ __volatile__("pushf\n andl $-262145,(%%esp)\n popf\n" : : __LZO_ASM_CLOBBER_LIST_CC_MEMORY); | | 3570| | } | | 3571| | return 0; | | 3572| |#elif (LZO_ARCH_I386) && (LZO_ASM_SYNTAX_MSC) | | 3573| | if (v) { __asm { | | 3574| | pushf | | 3575| | or dword ptr [esp],262144 | | 3576| | popf | | 3577| | }} else { __asm { | | 3578| | pushf | | 3579| | and dword ptr [esp],-262145 | | 3580| | popf | | 3581| | }} | | 3582| | return 0; | | 3583| |#else | | 3584| | LZO_UNUSED(v); return -1; | | 3585| |#endif | | 3586| |} | | 3587| |LZOLIB_PUBLIC_NOINLINE(unsigned, lzo_debug_running_on_qemu) (void) | | 3588| |{ | | 3589| | unsigned r = 0; | | 3590| |#if (LZO_OS_POSIX_LINUX || LZO_OS_WIN32 || LZO_OS_WIN64) | | 3591| | const char* p; | | 3592| | p = __LZOLIB_FUNCNAME(lzo_getenv)(LZO_PP_STRINGIZE(LZO_ENV_RUNNING_ON_QEMU)); | | 3593| | if (p) { | | 3594| | if (p[0] == 0) r = 0; | | 3595| | else if ((p[0] >= '0' && p[0] <= '9') && p[1] == 0) r = LZO_ICAST(unsigned, p[0]) - '0'; | | 3596| | else r = 1; | | 3597| | } | | 3598| |#endif | | 3599| | return r; | | 3600| |} | | 3601| |LZOLIB_PUBLIC_NOINLINE(unsigned, lzo_debug_running_on_valgrind) (void) | | 3602| |{ | | 3603| |#if (LZO_ARCH_AMD64 && LZO_ABI_ILP32) | | 3604| | return 0; | | 3605| |#elif (LZO_ARCH_AMD64 || LZO_ARCH_I386) && (LZO_ASM_SYNTAX_GNUC) | | 3606| | volatile size_t a[6]; | | 3607| | size_t r = 0; | | 3608| | a[0] = 0x1001; a[1] = 0; a[2] = 0; a[3] = 0; a[4] = 0; a[5] = 0; | | 3609| |# if (LZO_ARCH_AMD64) | | 3610| | __asm__ __volatile__(".byte 0x48,0xc1,0xc7,0x03,0x48,0xc1,0xc7,0x0d,0x48,0xc1,0xc7,0x3d,0x48,0xc1,0xc7,0x33,0x48,0x87,0xdb\n" : "=d" (r) : "a" (&a[0]), "d" (r) __LZO_ASM_CLOBBER_LIST_CC_MEMORY); | | 3611| |# elif (LZO_ARCH_I386) | | 3612| | __asm__ __volatile__(".byte 0xc1,0xc7,0x03,0xc1,0xc7,0x0d,0xc1,0xc7,0x1d,0xc1,0xc7,0x13,0x87,0xdb\n" : "=d" (r) : "a" (&a[0]), "d" (r) __LZO_ASM_CLOBBER_LIST_CC_MEMORY); | | 3613| |# endif | | 3614| | return LZO_ITRUNC(unsigned, r); | | 3615| |#else | | 3616| | return 0; | | 3617| |#endif | | 3618| |} | | 3619| |#if (LZO_OS_WIN32 && LZO_CC_PELLESC && (__POCC__ >= 290)) | | 3620| |# pragma warn(pop) | | 3621| |#endif | | 3622| |#endif | | 3623| |#if defined(LZO_WANT_ACCLIB_WILDARGV) | | 3624| |# undef LZO_WANT_ACCLIB_WILDARGV | | 3625| |#define __LZOLIB_WILDARGV_CH_INCLUDED 1 | | 3626| |#if !defined(LZOLIB_PUBLIC) | | 3627| |# define LZOLIB_PUBLIC(r,f) r __LZOLIB_FUNCNAME(f) | | 3628| |#endif | | 3629| |#if (LZO_OS_DOS16 || LZO_OS_OS216 || LZO_OS_WIN16) | | 3630| |#if 0 && (LZO_CC_MSC) | | 3631| |LZO_EXTERN_C int __lzo_cdecl __setargv(void); | | 3632| |LZO_EXTERN_C int __lzo_cdecl _setargv(void); | | 3633| |LZO_EXTERN_C int __lzo_cdecl _setargv(void) { return __setargv(); } | | 3634| |#endif | | 3635| |#endif | | 3636| |#if (LZO_OS_WIN32 || LZO_OS_WIN64) | | 3637| |#if (LZO_CC_MSC && (_MSC_VER >= 1900)) | | 3638| |#elif (LZO_CC_INTELC || LZO_CC_MSC) | | 3639| |LZO_EXTERN_C int __lzo_cdecl __setargv(void); | | 3640| |LZO_EXTERN_C int __lzo_cdecl _setargv(void); | | 3641| |LZO_EXTERN_C int __lzo_cdecl _setargv(void) { return __setargv(); } | | 3642| |#endif | | 3643| |#endif | | 3644| |#if (LZO_OS_EMX) | | 3645| |#define __LZOLIB_HAVE_LZO_WILDARGV 1 | | 3646| |LZOLIB_PUBLIC(void, lzo_wildargv) (int* argc, char*** argv) | | 3647| |{ | | 3648| | if (argc && argv) { | | 3649| | _response(argc, argv); | | 3650| | _wildcard(argc, argv); | | 3651| | } | | 3652| |} | | 3653| |#endif | | 3654| |#if (LZO_OS_CONSOLE_PSP) && defined(__PSPSDK_DEBUG__) | | 3655| |#define __LZOLIB_HAVE_LZO_WILDARGV 1 | | 3656| |LZO_EXTERN_C int lzo_psp_init_module(int*, char***, int); | | 3657| |LZOLIB_PUBLIC(void, lzo_wildargv) (int* argc, char*** argv) | | 3658| |{ | | 3659| | lzo_psp_init_module(argc, argv, -1); | | 3660| |} | | 3661| |#endif | | 3662| |#if !(__LZOLIB_HAVE_LZO_WILDARGV) | | 3663| |#define __LZOLIB_HAVE_LZO_WILDARGV 1 | | 3664| |LZOLIB_PUBLIC(void, lzo_wildargv) (int* argc, char*** argv) | | 3665| |{ | | 3666| |#if 1 && (LZO_ARCH_I086PM) | | 3667| | if (LZO_MM_AHSHIFT != 3) { exit(1); } | | 3668| |#elif 1 && (LZO_ARCH_M68K && LZO_OS_TOS && LZO_CC_GNUC) && defined(__MINT__) | | 3669| | __binmode(1); | | 3670| | if (isatty(1)) __set_binmode(stdout, 0); | | 3671| | if (isatty(2)) __set_binmode(stderr, 0); | | 3672| |#endif | | 3673| | LZO_UNUSED(argc); LZO_UNUSED(argv); | | 3674| |} | | 3675| |#endif | | 3676| |#endif | | 3677| | | | 3678| |/* vim:set ts=4 sw=4 et: */ ------------------ 208| 1|#endif 209| 1|#undef LZOCHK_ASSERT 210| | 211| 1| if (v == 0) ------------------ | Branch (211:9): [True: 0, False: 1] ------------------ 212| 0| return LZO_E_ERROR; ------------------ | | 311| 0|#define LZO_E_ERROR (-1) ------------------ 213| | 214| 1| r = (s1 == -1 || s1 == (int) sizeof(short)) && ------------------ | Branch (214:10): [True: 0, False: 1] | Branch (214:22): [True: 1, False: 0] ------------------ 215| 1| (s2 == -1 || s2 == (int) sizeof(int)) && ------------------ | Branch (215:10): [True: 0, False: 1] | Branch (215:22): [True: 1, False: 0] ------------------ 216| 1| (s3 == -1 || s3 == (int) sizeof(long)) && ------------------ | Branch (216:10): [True: 0, False: 1] | Branch (216:22): [True: 1, False: 0] ------------------ 217| 1| (s4 == -1 || s4 == (int) sizeof(lzo_uint32_t)) && ------------------ | Branch (217:10): [True: 0, False: 1] | Branch (217:22): [True: 1, False: 0] ------------------ 218| 1| (s5 == -1 || s5 == (int) sizeof(lzo_uint)) && ------------------ | Branch (218:10): [True: 0, False: 1] | Branch (218:22): [True: 1, False: 0] ------------------ 219| 1| (s6 == -1 || s6 == (int) lzo_sizeof_dict_t) && ------------------ | | 327| 1|# define lzo_sizeof_dict_t ((unsigned)sizeof(lzo_bytep)) ------------------ | Branch (219:10): [True: 0, False: 1] | Branch (219:22): [True: 1, False: 0] ------------------ 220| 1| (s7 == -1 || s7 == (int) sizeof(char *)) && ------------------ | Branch (220:10): [True: 0, False: 1] | Branch (220:22): [True: 1, False: 0] ------------------ 221| 1| (s8 == -1 || s8 == (int) sizeof(lzo_voidp)) && ------------------ | Branch (221:10): [True: 0, False: 1] | Branch (221:22): [True: 1, False: 0] ------------------ 222| 1| (s9 == -1 || s9 == (int) sizeof(lzo_callback_t)); ------------------ | Branch (222:10): [True: 0, False: 1] | Branch (222:22): [True: 1, False: 0] ------------------ 223| 1| if (!r) ------------------ | Branch (223:9): [True: 0, False: 1] ------------------ 224| 0| return LZO_E_ERROR; ------------------ | | 311| 0|#define LZO_E_ERROR (-1) ------------------ 225| | 226| 1| r = _lzo_config_check(); 227| 1| if (r != LZO_E_OK) ------------------ | | 310| 1|#define LZO_E_OK 0 ------------------ | Branch (227:9): [True: 0, False: 1] ------------------ 228| 0| return r; 229| | 230| 1| return r; 231| 1|} lzo_init.c:u2p: 81| 5|{ 82| 5| return (lzo_voidp) ((lzo_bytep) ptr + off); 83| 5|} LLVMFuzzerTestOneInput: 37| 924|extern int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { 38| 924| int r; 39| 924| lzo_uint compressed_len; 40| 924| lzo_uint decompressed_len; 41| | 42| | /* Since we allocate in/out on the stack, 43| | * we can't handle too large size. 44| | */ 45| 924| if (size > (1 << 20)) { ------------------ | Branch (45:7): [True: 0, False: 924] ------------------ 46| 0| size = 1 << 20; 47| 0| } 48| | 49| | /* We want to compress the data block at 'in' with length 'IN_LEN' to 50| | * the block at 'out'. Because the input block may be incompressible, 51| | * we must provide a little more output space in case that compression 52| | * is not possible. 53| | */ 54| 924| unsigned char* __LZO_MMODEL decompressed = malloc(size + 1); 55| 924| if (!decompressed) { ------------------ | Branch (55:7): [True: 0, False: 924] ------------------ 56| 0| return 0; 57| 0| } 58| 924| unsigned char* __LZO_MMODEL compressed = malloc(size + size / 16 + 64 + 3); 59| 924| if (!compressed) { ------------------ | Branch (59:7): [True: 0, False: 924] ------------------ 60| 0| free(decompressed); 61| 0| return 0; 62| 0| } 63| | 64| 924| static bool isInit = false; 65| 924| if (!isInit) { ------------------ | Branch (65:7): [True: 1, False: 923] ------------------ 66| 1| if (lzo_init() != LZO_E_OK) { ------------------ | | 336| 1|#define lzo_init() __lzo_init_v2(LZO_VERSION,(int)sizeof(short),(int)sizeof(int),\ | | ------------------ | | | | 32| 1|#define LZO_VERSION 0x20a0 /* 2.10 */ | | ------------------ | | 337| 1| (int)sizeof(long),(int)sizeof(lzo_uint32_t),(int)sizeof(lzo_uint),\ | | 338| 1| (int)lzo_sizeof_dict_t,(int)sizeof(char *),(int)sizeof(lzo_voidp),\ | | ------------------ | | | | 327| 1|# define lzo_sizeof_dict_t ((unsigned)sizeof(lzo_bytep)) | | ------------------ | | 339| 1| (int)sizeof(lzo_callback_t)) ------------------ if (lzo_init() != LZO_E_OK) { ------------------ | | 310| 1|#define LZO_E_OK 0 ------------------ | Branch (66:9): [True: 0, False: 1] ------------------ 67| |#ifdef __DEBUG__ 68| | printf("internal error - lzo_init() failed !!!\n"); 69| |#endif 70| 0| free(compressed); 71| 0| free(decompressed); 72| 0| return 0; 73| 0| } 74| 1| isInit = true; 75| 1| } 76| | 77| | /* Compress with LZO1X-1. */ 78| 924| r = lzo1x_1_compress(data, size, compressed, &compressed_len, wrkmem); 79| 924| assert(r == LZO_E_OK); 80| |#ifdef __DEBUG__ 81| | printf("compressed %lu bytes into %lu bytes\n", (unsigned long)size, 82| | (unsigned long)out_len); 83| |#endif 84| | 85| | /* check for an incompressible block */ 86| 924| if (compressed_len >= size) { ------------------ | Branch (86:7): [True: 384, False: 540] ------------------ 87| |#ifdef __DEBUG__ 88| | printf("This block contains incompressible data.\n"); 89| |#endif 90| 384| free(compressed); 91| 384| free(decompressed); 92| 384| return 0; 93| 384| } 94| | 95| | // Decompress; allow 1 extra byte of output to make sure decoder does not 96| | // produce unexpected output. 97| 540| decompressed_len = size + 1; 98| 540| r = lzo1x_decompress(compressed, compressed_len, decompressed, 99| 540| &decompressed_len, /*wrkmem=*/NULL); 100| 540| assert(r == LZO_E_OK && decompressed_len == size); 101| |#ifdef __DEBUG__ 102| | printf("decompressed %lu bytes back into %lu bytes\n", (unsigned long)out_len, 103| | (unsigned long)size); 104| |#endif 105| 540| free(compressed); 106| 540| free(decompressed); 107| 540| return 0; 108| 540|}