1 /* lzo_dict.h -- dictionary definitions for the the LZO library 2 3 This file is part of the LZO real-time data compression library. 4 5 Copyright (C) 1996-2014 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 <markus (at) oberhumer.com> 25 http://www.oberhumer.com/opensource/lzo/ 26 */ 27 28 29 /* WARNING: this file should *not* be used by applications. It is 30 part of the implementation of the library and is subject 31 to change. 32 */ 33 34 35 #ifndef __LZO_DICT_H 36 #define __LZO_DICT_H 1 37 38 #ifdef __cplusplus 39 extern "C" { 40 #endif 41 42 43 44 /*********************************************************************** 45 // dictionary size 46 ************************************************************************/ 47 48 /* dictionary needed for compression */ 49 #if !defined(D_BITS) && defined(DBITS) 50 # define D_BITS DBITS 51 #endif 52 #if !defined(D_BITS) 53 # error "D_BITS is not defined" 54 #endif 55 #if (D_BITS < 16) 56 # define D_SIZE LZO_SIZE(D_BITS) 57 # define D_MASK LZO_MASK(D_BITS) 58 #else 59 # define D_SIZE LZO_USIZE(D_BITS) 60 # define D_MASK LZO_UMASK(D_BITS) 61 #endif 62 #define D_HIGH ((D_MASK >> 1) + 1) 63 64 65 /* dictionary depth */ 66 #if !defined(DD_BITS) 67 # define DD_BITS 0 68 #endif 69 #define DD_SIZE LZO_SIZE(DD_BITS) 70 #define DD_MASK LZO_MASK(DD_BITS) 71 72 /* dictionary length */ 73 #if !defined(DL_BITS) 74 # define DL_BITS (D_BITS - DD_BITS) 75 #endif 76 #if (DL_BITS < 16) 77 # define DL_SIZE LZO_SIZE(DL_BITS) 78 # define DL_MASK LZO_MASK(DL_BITS) 79 #else 80 # define DL_SIZE LZO_USIZE(DL_BITS) 81 # define DL_MASK LZO_UMASK(DL_BITS) 82 #endif 83 84 85 #if (D_BITS != DL_BITS + DD_BITS) 86 # error "D_BITS does not match" 87 #endif 88 #if (D_BITS < 6 || D_BITS > 18) 89 # error "invalid D_BITS" 90 #endif 91 #if (DL_BITS < 6 || DL_BITS > 20) 92 # error "invalid DL_BITS" 93 #endif 94 #if (DD_BITS < 0 || DD_BITS > 6) 95 # error "invalid DD_BITS" 96 #endif 97 98 99 #if !defined(DL_MIN_LEN) 100 # define DL_MIN_LEN 3 101 #endif 102 #if !defined(DL_SHIFT) 103 # define DL_SHIFT ((DL_BITS + (DL_MIN_LEN - 1)) / DL_MIN_LEN) 104 #endif 105 106 107 108 /*********************************************************************** 109 // dictionary access 110 ************************************************************************/ 111 112 #define LZO_HASH_GZIP 1 113 #define LZO_HASH_GZIP_INCREMENTAL 2 114 #define LZO_HASH_LZO_INCREMENTAL_A 3 115 #define LZO_HASH_LZO_INCREMENTAL_B 4 116 117 #if !defined(LZO_HASH) 118 # error "choose a hashing strategy" 119 #endif 120 121 #undef DM 122 #undef DX 123 124 #if (DL_MIN_LEN == 3) 125 # define _DV2_A(p,shift1,shift2) \ 126 (((( (lzo_xint)((p)[0]) << shift1) ^ (p)[1]) << shift2) ^ (p)[2]) 127 # define _DV2_B(p,shift1,shift2) \ 128 (((( (lzo_xint)((p)[2]) << shift1) ^ (p)[1]) << shift2) ^ (p)[0]) 129 # define _DV3_B(p,shift1,shift2,shift3) \ 130 ((_DV2_B((p)+1,shift1,shift2) << (shift3)) ^ (p)[0]) 131 #elif (DL_MIN_LEN == 2) 132 # define _DV2_A(p,shift1,shift2) \ 133 (( (lzo_xint)(p[0]) << shift1) ^ p[1]) 134 # define _DV2_B(p,shift1,shift2) \ 135 (( (lzo_xint)(p[1]) << shift1) ^ p[2]) 136 #else 137 # error "invalid DL_MIN_LEN" 138 #endif 139 #define _DV_A(p,shift) _DV2_A(p,shift,shift) 140 #define _DV_B(p,shift) _DV2_B(p,shift,shift) 141 #define DA2(p,s1,s2) \ 142 (((((lzo_xint)((p)[2]) << (s2)) + (p)[1]) << (s1)) + (p)[0]) 143 #define DS2(p,s1,s2) \ 144 (((((lzo_xint)((p)[2]) << (s2)) - (p)[1]) << (s1)) - (p)[0]) 145 #define DX2(p,s1,s2) \ 146 (((((lzo_xint)((p)[2]) << (s2)) ^ (p)[1]) << (s1)) ^ (p)[0]) 147 #define DA3(p,s1,s2,s3) ((DA2((p)+1,s2,s3) << (s1)) + (p)[0]) 148 #define DS3(p,s1,s2,s3) ((DS2((p)+1,s2,s3) << (s1)) - (p)[0]) 149 #define DX3(p,s1,s2,s3) ((DX2((p)+1,s2,s3) << (s1)) ^ (p)[0]) 150 #define DMS(v,s) ((lzo_uint) (((v) & (D_MASK >> (s))) << (s))) 151 #define DM(v) DMS(v,0) 152 153 154 #if (LZO_HASH == LZO_HASH_GZIP) 155 /* hash function like in gzip/zlib (deflate) */ 156 # define _DINDEX(dv,p) (_DV_A((p),DL_SHIFT)) 157 158 #elif (LZO_HASH == LZO_HASH_GZIP_INCREMENTAL) 159 /* incremental hash like in gzip/zlib (deflate) */ 160 # define __LZO_HASH_INCREMENTAL 1 161 # define DVAL_FIRST(dv,p) dv = _DV_A((p),DL_SHIFT) 162 # define DVAL_NEXT(dv,p) dv = (((dv) << DL_SHIFT) ^ p[2]) 163 # define _DINDEX(dv,p) (dv) 164 # define DVAL_LOOKAHEAD DL_MIN_LEN 165 166 #elif (LZO_HASH == LZO_HASH_LZO_INCREMENTAL_A) 167 /* incremental LZO hash version A */ 168 # define __LZO_HASH_INCREMENTAL 1 169 # define DVAL_FIRST(dv,p) dv = _DV_A((p),5) 170 # define DVAL_NEXT(dv,p) \ 171 dv ^= (lzo_xint)(p[-1]) << (2*5); dv = (((dv) << 5) ^ p[2]) 172 # define _DINDEX(dv,p) ((DMUL(0x9f5f,dv)) >> 5) 173 # define DVAL_LOOKAHEAD DL_MIN_LEN 174 175 #elif (LZO_HASH == LZO_HASH_LZO_INCREMENTAL_B) 176 /* incremental LZO hash version B */ 177 # define __LZO_HASH_INCREMENTAL 1 178 # define DVAL_FIRST(dv,p) dv = _DV_B((p),5) 179 # define DVAL_NEXT(dv,p) \ 180 dv ^= p[-1]; dv = (((dv) >> 5) ^ ((lzo_xint)(p[2]) << (2*5))) 181 # define _DINDEX(dv,p) ((DMUL(0x9f5f,dv)) >> 5) 182 # define DVAL_LOOKAHEAD DL_MIN_LEN 183 184 #else 185 # error "choose a hashing strategy" 186 #endif 187 188 189 #ifndef DINDEX 190 #define DINDEX(dv,p) ((lzo_uint)((_DINDEX(dv,p)) & DL_MASK) << DD_BITS) 191 #endif 192 #if !defined(DINDEX1) && defined(D_INDEX1) 193 #define DINDEX1 D_INDEX1 194 #endif 195 #if !defined(DINDEX2) && defined(D_INDEX2) 196 #define DINDEX2 D_INDEX2 197 #endif 198 199 200 201 #if !defined(__LZO_HASH_INCREMENTAL) 202 # define DVAL_FIRST(dv,p) ((void) 0) 203 # define DVAL_NEXT(dv,p) ((void) 0) 204 # define DVAL_LOOKAHEAD 0 205 #endif 206 207 208 #if !defined(DVAL_ASSERT) 209 #if defined(__LZO_HASH_INCREMENTAL) && !defined(NDEBUG) 210 #if (LZO_CC_CLANG || (LZO_CC_GNUC >= 0x020700ul) || LZO_CC_LLVM) 211 static void __attribute__((__unused__)) 212 #else 213 static void 214 #endif 215 DVAL_ASSERT(lzo_xint dv, const lzo_bytep p) 216 { 217 lzo_xint df; 218 DVAL_FIRST(df,(p)); 219 assert(DINDEX(dv,p) == DINDEX(df,p)); 220 } 221 #else 222 # define DVAL_ASSERT(dv,p) ((void) 0) 223 #endif 224 #endif 225 226 227 228 /*********************************************************************** 229 // dictionary updating 230 ************************************************************************/ 231 232 #if (LZO_DICT_USE_PTR) 233 # define DENTRY(p,in) (p) 234 # define GINDEX(m_pos,m_off,dict,dindex,in) m_pos = dict[dindex] 235 #else 236 # define DENTRY(p,in) ((lzo_dict_t) pd(p, in)) 237 # define GINDEX(m_pos,m_off,dict,dindex,in) m_off = dict[dindex] 238 #endif 239 240 241 #if (DD_BITS == 0) 242 243 # define UPDATE_D(dict,drun,dv,p,in) dict[ DINDEX(dv,p) ] = DENTRY(p,in) 244 # define UPDATE_I(dict,drun,index,p,in) dict[index] = DENTRY(p,in) 245 # define UPDATE_P(ptr,drun,p,in) (ptr)[0] = DENTRY(p,in) 246 247 #else 248 249 # define UPDATE_D(dict,drun,dv,p,in) \ 250 dict[ DINDEX(dv,p) + drun++ ] = DENTRY(p,in); drun &= DD_MASK 251 # define UPDATE_I(dict,drun,index,p,in) \ 252 dict[ (index) + drun++ ] = DENTRY(p,in); drun &= DD_MASK 253 # define UPDATE_P(ptr,drun,p,in) \ 254 (ptr) [ drun++ ] = DENTRY(p,in); drun &= DD_MASK 255 256 #endif 257 258 259 /*********************************************************************** 260 // test for a match 261 ************************************************************************/ 262 263 #if (LZO_DICT_USE_PTR) 264 265 /* m_pos is either NULL or a valid pointer */ 266 #define LZO_CHECK_MPOS_DET(m_pos,m_off,in,ip,max_offset) \ 267 (m_pos == NULL || (m_off = pd(ip, m_pos)) > max_offset) 268 269 /* m_pos may point anywhere... */ 270 #define LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,max_offset) \ 271 (BOUNDS_CHECKING_OFF_IN_EXPR(( \ 272 m_pos = ip - (lzo_uint) PTR_DIFF(ip,m_pos), \ 273 PTR_LT(m_pos,in) || \ 274 (m_off = (lzo_uint) PTR_DIFF(ip,m_pos)) == 0 || \ 275 m_off > max_offset ))) 276 277 #else 278 279 #define LZO_CHECK_MPOS_DET(m_pos,m_off,in,ip,max_offset) \ 280 (m_off == 0 || \ 281 ((m_off = pd(ip, in) - m_off) > max_offset) || \ 282 (m_pos = (ip) - (m_off), 0) ) 283 284 #define LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,max_offset) \ 285 (pd(ip, in) <= m_off || \ 286 ((m_off = pd(ip, in) - m_off) > max_offset) || \ 287 (m_pos = (ip) - (m_off), 0) ) 288 289 #endif 290 291 292 #if (LZO_DETERMINISTIC) 293 # define LZO_CHECK_MPOS LZO_CHECK_MPOS_DET 294 #else 295 # define LZO_CHECK_MPOS LZO_CHECK_MPOS_NON_DET 296 #endif 297 298 299 300 #ifdef __cplusplus 301 } /* extern "C" */ 302 #endif 303 304 #endif /* already included */ 305 306 /* 307 vi:ts=4:et 308 */ 309 310
