source: trunk/symbol_table/src/symbol_table.hpp @ 2106

Last change on this file since 2106 was 2106, checked in by ksherdy, 7 years ago

Added bit / byte strategy. Added length test to hash table.

File size: 16.5 KB
RevLine 
[1967]1/*
[2052]2 * id_symbol_table.hpp
[1967]3 * Created on: 18-December-2011
4 * Author: Ken Herdy
5 *
[2052]6 * BitBlock type arguments must adhere to the 'full-block invariant'
7 * and mask partial block with null bytes.
[1967]8 *
[2052]9 * Number of length groups must coincide with the
10 * number compiler generated length groups.
11 *
[1967]12 */
[2052]13#ifndef ID_SYMBOL_TABLE_TEMPLATE_HPP
14#define ID_SYMBOL_TABLE_TEMPLATE_HPP
[1967]15
[2092]16
[2106]17#include "strategy_types.hpp"
[2052]18#include "buffer.hpp"
[2028]19#include "gid.hpp"
[2001]20#include "hash_table.hpp"
[2052]21#include "../lib/carryQ.hpp"
22#include "../lib/bitblock_iterator.hpp"
23#include "../lib/bitblock_scan.hpp"
24#include <cstdlib>
[2001]25#include <vector>
[1967]26using namespace std;
27
[2052]28#ifdef ID_SYMBOL_TABLE_TEMPLATE_HPP_DEBUG
29static void print_symbol_debug(gid_type gid, const uint8_t buffer [], const int32_t spos, const uint32_t epos, const uint32_t lgth) {
30        cout << "{Symbol:{";
[2101]31        cout << "GID:" << gid;
32        cout << ",Length:" << lgth;
33        cout << ",Value:'" << string((char *)&(buffer[spos]), lgth) << "'";
34        cout << ",Start:" << spos;
35        cout << ",Follows:" << epos;
[2052]36        cout << "}}" << endl;
37}
38#endif
39
[1995]40///////////////////////////////////////////////////////////////////////////
[2052]41// Symbol Type - do_block()
42///////////////////////////////////////////////////////////////////////////
[2067]43template<class GIDS, class HASH_TABLE>
[2052]44void do_block(uint32_t blk_offset,
45              HASH_TABLE & h_table,
[2097]46              BitBlock follows,
[2052]47              uint8_t buffer [], const uint32_t lgth,
[2053]48              uint8_t h0 [], uint8_t h1 [], const uint32_t h_block_size,
[2067]49              GIDS & gids, GIDFactory & gid_factory, GIDData & gid_data);
[2052]50
[2067]51template<class GIDS, class HASH_TABLE>
[2052]52void do_block(uint32_t blk_offset,
53              HASH_TABLE & h_table,
[2097]54              BitBlock starts [], BitBlock follows [],
[2052]55              uint8_t buffer [],
[2053]56              uint8_t h0 [], uint8_t h1 [], const uint32_t h_block_size,
[2067]57              GIDS & gids, GIDFactory & gid_factory, GIDData & gid_data);
[2052]58
59///////////////////////////////////////////////////////////////////////////
[2029]60// Symbol Type - Array gids.
[1995]61///////////////////////////////////////////////////////////////////////////
[2001]62
[2062]63template<uint32_t SIZE>
64class gid {
[1967]65public:
[2062]66    gid_type at[SIZE];
[2001]67    //vector<BitBlock> gids_idx;   // gids index
[1992]68};
[1967]69
[2106]70
[2062]71template<class GIDS, class ALLOCATOR>
[2052]72class symbol_table {
[1967]73public:
[2052]74        symbol_table()/*:hash_table_1(256)*/{}
75        ~symbol_table() {
[2106]76//      hash_table_x.print_table();
[2052]77#ifdef HASH_TABLE_HPP_DEBUG
[2106]78//      hash_table_x.print_diagnostics();
[2052]79#endif
80        }
[1967]81
[2052]82        // Groups & groups
[2103]83        void resolve(uint8_t buffer [], Groups groups [],  BitBlock starts [], BitBlock follows_0 [],
[2062]84                                 BitBlock h0 [], BitBlock h1 [], uint32_t segment_blocks, GIDS & gids) {
[2001]85
[2062]86                        for(uint32_t blk = 0; blk < segment_blocks; blk++) {
[2052]87                                const uint32_t blk_offset = blk * BLOCKSIZE;
[2062]88                                resolve(blk_offset, &buffer[blk_offset], groups[blk], &starts[blk], &h0[blk], &h1[blk], gids);
[2052]89                        }
90        }
[2001]91
[2052]92        // Groups & groups
[2069]93        IDISA_ALWAYS_INLINE void resolve(uint32_t blk_offset, uint8_t buffer [], Groups & groups,  BitBlock starts[],
[2062]94                                 BitBlock * h0, BitBlock * h1, GIDS & gids) {
[2052]95
96                        ///////////////////////////////////////////////////////////////////////////////
[2067]97                        // Byte Space Hash (Fixed Length)
[2052]98                        ///////////////////////////////////////////////////////////////////////////////
[2092]99                        #define BYTE_HASH_FIXED(GROUP_STRATEGY, HASH_STRATEGY, LGTH) \
[2097]100                                if(bitblock::any(groups.follows_##LGTH)) { \
[2092]101                                        do_block<GIDS, GROUP_STRATEGY##_hash_table <LGTH, GROUP_STRATEGY, HASH_STRATEGY, ALLOCATOR> > \
[2052]102                                                (blk_offset, \
103                                                 hash_table_##LGTH, \
[2097]104                                                 groups.follows_##LGTH, \
[2052]105                                                 buffer, LGTH, /* buffer, symbol length */ \
[2053]106                                                 buffer, buffer, BLOCK_SIZE, /* h0, h1, hash block size (bits) */ \
[2062]107                                                 gids, this->gid_factory, this->gid_data); \
[2052]108                                }
109
[2067]110                        /////////////////////////////////////////////////////////////////////////////
111                        // Byte Space Variable Lengths (groups contain variable lengths)
[2052]112                        ///////////////////////////////////////////////////////////////////////////////
[2092]113                        #define BYTE_HASH_VARIABLE(GROUP_STRATEGY, HASH_STRATEGY, LGTH) \
[2097]114                                if(bitblock::any(groups.follows_##LGTH)) { \
[2092]115                                        do_block<GIDS, GROUP_STRATEGY##_hash_table <LGTH, GROUP_STRATEGY, HASH_STRATEGY, ALLOCATOR> > \
[2067]116                                                (blk_offset, \
117                                                 hash_table_##LGTH, \
118                                                 starts, \
[2097]119                                                 &groups.follows_##LGTH, \
[2067]120                                                 buffer, \
121                                                 buffer, buffer, BLOCK_SIZE, /* h0, h1, hash block size (bits) */ \
122                                                 gids, this->gid_factory, this->gid_data); \
123                                }
124
125
[2052]126                        ///////////////////////////////////////////////////////////////////////////////
[2067]127                        // Bit Space Hash (Fixed Length)
128                        ///////////////////////////////////////////////////////////////////////////////
[2092]129                        #define BIT_HASH_FIXED(GROUP_STRATEGY, HASH_STRATEGY, LGTH) \
[2097]130                                if(bitblock::any(groups.follows_##LGTH)) { \
[2092]131                                        do_block<GIDS, GROUP_STRATEGY##_hash_table <LGTH, GROUP_STRATEGY, HASH_STRATEGY, ALLOCATOR> > \
[2052]132                                                (blk_offset, \
133                                                 hash_table_##LGTH, \
[2097]134                                                 groups.follows_##LGTH, \
[2052]135                                                 buffer, LGTH, \
[2053]136                                                 (uint8_t *)h0, (uint8_t *)h1, (BLOCK_SIZE / 8), \
[2062]137                                                 gids, this->gid_factory, this->gid_data); \
[2052]138                                }
139
[2069]140                        /////////////////////////////////////////////////////////////////////////////
141                        // Byte Space Variable Lengths (groups contain variable lengths)
142                        ///////////////////////////////////////////////////////////////////////////////
[2092]143                        #define BIT_HASH_VARIABLE(GROUP_STRATEGY, HASH_STRATEGY, LGTH) \
[2097]144                                if(bitblock::any(groups.follows_##LGTH)) { \
[2092]145                                        do_block<GIDS, GROUP_STRATEGY##_hash_table <LGTH, GROUP_STRATEGY, HASH_STRATEGY, ALLOCATOR> > \
[2069]146                                                (blk_offset, \
147                                                 hash_table_##LGTH, \
148                                                 starts, \
[2097]149                                                 &groups.follows_##LGTH, \
[2069]150                                                 buffer, \
151                                                 (uint8_t *)h0, (uint8_t *)h1, (BLOCK_SIZE / 8), /* h0, h1, hash block size (bits) */ \
152                                                 gids, this->gid_factory, this->gid_data); \
153                                }
[2052]154
[2069]155                        ///////////////////////////////////////////////////////////////////////////////
156                        // WARNING: BYTE_HASH max 8 bytes under the shift XOR hash approach of hash.hpp
[2079]157                        //     ---> (id,7),(div2,6),(logbase2,4)
[2069]158                        ///////////////////////////////////////////////////////////////////////////////
159                        #ifdef ID_STRATEGY
[2092]160                            BYTE_HASH_FIXED(id,byte,1);
161                            BYTE_HASH_FIXED(id,byte,2);
162                            BYTE_HASH_FIXED(id,byte,3);
163                            BYTE_HASH_FIXED(id,byte,4);
164                            BYTE_HASH_FIXED(id,byte,5);
165                            BYTE_HASH_FIXED(id,byte,6);
166                            BYTE_HASH_FIXED(id,byte,7);
167                            BIT_HASH_FIXED(id,bit,8);
168                            BIT_HASH_FIXED(id,bit,9);
169                            BIT_HASH_FIXED(id,bit,10);
170                            BIT_HASH_FIXED(id,bit,11);
171                            BIT_HASH_FIXED(id,bit,12);
172                            BIT_HASH_FIXED(id,bit,13);
173                            BIT_HASH_FIXED(id,bit,14);
174                            BIT_HASH_FIXED(id,bit,15);
175                            BIT_HASH_FIXED(id,bit,16);
[2103]176                            BIT_HASH_VARIABLE(id,bit,0);
[2069]177                        #elif DIV2_STRATEGY
[2092]178                            BYTE_HASH_FIXED(div2,byte,2);
179                            BYTE_HASH_FIXED(div2,byte,4);
180                            BYTE_HASH_FIXED(div2,byte,6);
181                            BIT_HASH_FIXED(div2,bit,8);
182                            BIT_HASH_FIXED(div2,bit,10);
183                            BIT_HASH_FIXED(div2,bit,12);
184                            BIT_HASH_FIXED(div2,bit,14);
185                            BIT_HASH_FIXED(div2,bit,16);
[2103]186                            BIT_HASH_VARIABLE(id,bit,0);
[2098]187                        #elif LOGBASE2_STRATEGY
[2092]188                            BYTE_HASH_VARIABLE(logbase2,byte,1);
189                            BYTE_HASH_VARIABLE(logbase2,byte,2);
190                            BYTE_HASH_VARIABLE(logbase2,byte,4);
191                            BIT_HASH_VARIABLE(logbase2,bit,8);
192                            BIT_HASH_VARIABLE(logbase2,bit,16);
[2103]193                            BIT_HASH_VARIABLE(id,bit,0);
[2098]194                        #elif DIV2_LOGBASE2_STRATEGY
195                            BYTE_HASH_FIXED(div2,byte,2);
196                            BYTE_HASH_FIXED(div2,byte,4);
197                            BYTE_HASH_FIXED(div2,byte,6);
198                            BIT_HASH_FIXED(div2,bit,8);
199                            BIT_HASH_VARIABLE(logbase2,bit,16);
[2103]200                            BIT_HASH_VARIABLE(id,bit,0);
[2106]201                        #elif BIT_BYTE_STRATEGY
202                            BYTE_HASH_VARIABLE(bit_byte,byte,7);
203                            BIT_HASH_VARIABLE(bit_byte,bit,0);
[2069]204                        #endif
205
206                        #undef BYTE_HASH_FIXED
207                        #undef BYTE_HASH_VARIABLE
[2067]208                        #undef BIT_HASH_FIXED
[2069]209                        #undef BIT_HASH_VARIABLE
[2052]210
211        }
212
213        IDISA_ALWAYS_INLINE uint8_t * get_raw_data(uint32_t idx) const { return gid_data.get_raw_bytes(idx); }
214        IDISA_ALWAYS_INLINE uint32_t get_lgth(uint32_t idx) const { return gid_data.get_bytes_lgth(idx); }
[2092]215        IDISA_ALWAYS_INLINE gid_type get_max_gid() const { return gid_data.max(); }
[2052]216
217private:
218        GIDFactory gid_factory;
219        GIDData gid_data;
220
221        ///////////////////////////////////////////////////////////////////////////////
222        // Byte Space Hash
223        ///////////////////////////////////////////////////////////////////////////////
[2069]224        #ifdef ID_STRATEGY
[2092]225            id_hash_table<1, id, byte, ALLOCATOR> hash_table_1;
226            id_hash_table<2, id, byte, ALLOCATOR> hash_table_2;
227            id_hash_table<3, id, byte, ALLOCATOR> hash_table_3;
228            id_hash_table<4, id, byte, ALLOCATOR> hash_table_4;
229            id_hash_table<5, id, byte, ALLOCATOR> hash_table_5;
230            id_hash_table<6, id, byte, ALLOCATOR> hash_table_6;
231            id_hash_table<7, id, byte, ALLOCATOR> hash_table_7;
232            id_hash_table<8, id, bit, ALLOCATOR> hash_table_8;
233            id_hash_table<9, id, bit, ALLOCATOR> hash_table_9;
234            id_hash_table<10, id, bit, ALLOCATOR> hash_table_10;
235            id_hash_table<11, id, bit, ALLOCATOR> hash_table_11;
236            id_hash_table<12, id, bit, ALLOCATOR> hash_table_12;
237            id_hash_table<13, id, bit, ALLOCATOR> hash_table_13;
238            id_hash_table<14, id, bit, ALLOCATOR> hash_table_14;
239            id_hash_table<15, id, bit, ALLOCATOR> hash_table_15;
240            id_hash_table<16, id, bit, ALLOCATOR> hash_table_16;
[2103]241            id_hash_table<0, id, bit, ALLOCATOR> hash_table_0;
[2069]242        #elif DIV2_STRATEGY
[2092]243            div2_hash_table<2, div2, byte, ALLOCATOR> hash_table_2;
244            div2_hash_table<4, div2, byte, ALLOCATOR> hash_table_4;
245            div2_hash_table<6, div2, byte, ALLOCATOR> hash_table_6;
246            div2_hash_table<8, div2, bit, ALLOCATOR> hash_table_8;
247            div2_hash_table<10, div2, bit, ALLOCATOR> hash_table_10;
248            div2_hash_table<12, div2, bit, ALLOCATOR> hash_table_12;
249            div2_hash_table<14, div2, bit, ALLOCATOR> hash_table_14;
250            div2_hash_table<16, div2, bit, ALLOCATOR> hash_table_16;
[2103]251            id_hash_table<0, id, bit, ALLOCATOR> hash_table_0;
[2098]252        #elif LOGBASE2_STRATEGY
[2092]253            logbase2_hash_table<1, logbase2, byte, ALLOCATOR> hash_table_1;
254            logbase2_hash_table<2, logbase2, byte, ALLOCATOR> hash_table_2;
255            logbase2_hash_table<4, logbase2, byte, ALLOCATOR> hash_table_4;
256            logbase2_hash_table<8, logbase2, bit, ALLOCATOR> hash_table_8;
257            logbase2_hash_table<16, logbase2, bit, ALLOCATOR> hash_table_16;
[2103]258            id_hash_table<0, id, bit, ALLOCATOR> hash_table_0;
[2098]259        #elif DIV2_LOGBASE2_STRATEGY
260            div2_hash_table<2, div2, byte, ALLOCATOR> hash_table_2;
261            div2_hash_table<4, div2, byte, ALLOCATOR> hash_table_4;
262            div2_hash_table<6, div2, byte, ALLOCATOR> hash_table_6;
263            div2_hash_table<8, div2, bit, ALLOCATOR> hash_table_8;
264//      id_hash_table<1, id, byte, ALLOCATOR> hash_table_1;
265//      id_hash_table<2, id, byte, ALLOCATOR> hash_table_2;
266//      id_hash_table<3, id, byte, ALLOCATOR> hash_table_3;
267//      id_hash_table<4, id, byte, ALLOCATOR> hash_table_4;
268//      id_hash_table<5, id, byte, ALLOCATOR> hash_table_5;
269//      id_hash_table<6, id, byte, ALLOCATOR> hash_table_6;
270//      id_hash_table<7, id, byte, ALLOCATOR> hash_table_7;
271//      id_hash_table<8, id, bit, ALLOCATOR> hash_table_8;
272            logbase2_hash_table<16, logbase2, bit, ALLOCATOR> hash_table_16;
[2103]273            id_hash_table<0, id, bit, ALLOCATOR> hash_table_0;
[2106]274        #elif BIT_BYTE_STRATEGY
275            bit_byte_hash_table<7, bit_byte, byte, ALLOCATOR> hash_table_7;
276            bit_byte_hash_table<0, bit_byte, bit, ALLOCATOR> hash_table_0;
[2069]277        #else
[2106]278            #error "Length group strategy not specified. #define {ID_STRATEGY,DIV2_STRATEGY,LOGBASE2_STRATEGY,DIV2_LOGBASE2_STRATEGY,BIT_BYTE}."
[2069]279        #endif
[2054]280
[2103]281
[1967]282};
283
[2052]284/* NOTE: C++ template code and Pablo generated length groups must coincide. */
285
286// Fixed Lengths - REVERSE SCAN LOGIC - Scan each BLOCK MSB to LSB
[2062]287template<class GIDS, class HASH_TABLE>
[2014]288void do_block(uint32_t blk_offset,
[2052]289                  HASH_TABLE & h_table,
[2097]290                  BitBlock follows,
[2052]291                  uint8_t buffer [], const uint32_t lgth,
[2053]292                  uint8_t h0 [], uint8_t h1 [], const uint32_t h_block_size,
[2062]293                  GIDS & gids, GIDFactory & gid_factory, GIDData & gid_data) {
[1979]294
[2052]295                uint8_t * buffer_base = buffer;
296                uint8_t * h0_base = h0;
297                uint8_t * h1_base = h1;
298
299                gid_type gid;
[2101]300                int32_t fpos;
[2052]301                int32_t spos;
302                uint32_t blk_count;
303
[2097]304        ReverseScanner<BitBlock, scanword_t> rscanner(&follows);
[2052]305
306        rscanner.scan_to_next();
[2101]307        fpos = rscanner.get_pos();
[2052]308
309                while(!rscanner.is_done()) {
310
[2101]311                spos = fpos - lgth;
[2052]312
313                        if(spos < 0) { // boundary case
314                                        spos = (BLOCK_SIZE - (-1 * spos)) & (BLOCK_SIZE - 1);
315                                        blk_count = (lgth/BLOCK_SIZE)+1;
316                                        buffer_base -= (BLOCK_SIZE * blk_count);
317                                        h0_base -= (h_block_size * blk_count);
318                                        h1_base -= (h_block_size * blk_count);
319                        }
320
[2053]321                        gid = h_table.lookup_or_insert(buffer_base, spos, lgth, h0_base, h1_base, gid_factory, gid_data); // WARNING: spos must be >= 0
[2052]322
[2101]323                        #ifdef ID_SYMBOL_STORE_SYMBOL_GIDS_AT_FOLLOW_POSITION
[2062]324                        gids.at[blk_offset + epos] = gid;
[2052]325                        #else
[2101]326                        gids.at[blk_offset + fpos - gid_data.get_bytes_lgth(gid)] = gid;
[2052]327                        #endif
328
329                        #ifdef ID_SYMBOL_TABLE_TEMPLATE_HPP_DEBUG
[2101]330                                print_symbol_debug(gid, buffer_base, spos, fpos, gid_data.get_bytes_lgth(gid));
[2052]331                        #endif
332
333                        rscanner.scan_to_next();
[2101]334                        fpos = rscanner.get_pos();
[2052]335                }
336        }
337
338
339// Variable Lengths, reverse scanner logic
340// Precondition: A symbol end is marked iff a symbol start is marked within a buffer segment.
[2014]341template<class SYMBOL, class HASH_TABLE>
342void do_block(uint32_t blk_offset,
[2052]343                          HASH_TABLE & h_table,
[2097]344                          BitBlock starts [], BitBlock follows [],
[2052]345                          uint8_t buffer [],
[2053]346                          uint8_t h0 [], uint8_t h1 [], const uint32_t h_block_size,
[2062]347                          SYMBOL & gids, GIDFactory & gid_factory, GIDData & gid_data) {
[1979]348
[2052]349        BitBlock * starts_base = starts;
350        uint8_t * buffer_base = buffer;
351        uint8_t * h0_base = h0;
352        uint8_t * h1_base = h1;
[1967]353
[2052]354        gid_type gid;
[2101]355        int32_t fpos;
[2052]356        int32_t spos;
357        uint32_t lgth;
358        uint32_t blk_count = 0;
[1967]359
[2097]360        ReverseScanner<BitBlock, scanword_t> follows_rscanner(follows);
[2052]361        ReverseScanner<BitBlock, scanword_t> starts_rscanner(starts);
[1967]362
[2097]363        follows_rscanner.scan_to_next();
[2101]364        fpos = follows_rscanner.get_pos();
[1979]365
[2097]366        while(!follows_rscanner.is_done()) {
[2052]367
[2101]368                starts_rscanner.move_to(fpos);
[2052]369                starts_rscanner.scan_to_next();
370                spos = starts_rscanner.get_pos();
[2101]371                lgth = fpos - spos;
[2052]372
373                while(starts_rscanner.is_done()) { // boundary case
374                          starts_base--;
375
376                        blk_count++;
377
378                        starts_rscanner.init(starts_base);
379                        starts_rscanner.scan_to_next();
380
381                        if(!starts_rscanner.is_done()) { // found start
[2101]382                                        lgth = fpos + (BLOCK_SIZE - starts_rscanner.get_pos()) + (BLOCK_SIZE * (blk_count-1));
[2052]383                                        spos = starts_rscanner.get_pos();
384                                        buffer_base -= (BLOCK_SIZE * blk_count);
385                                        h0_base -= (h_block_size * blk_count);
386                                        h1_base -= (h_block_size * blk_count);
387                                        break;
388                        }
389
390                }
391
[2053]392                gid = h_table.lookup_or_insert(buffer_base, spos, lgth, h0_base, h1_base, gid_factory, gid_data); // WARNING: spos must be >= 0
[2052]393
394                #ifdef ID_SYMBOL_STORE_SYMBOL_GIDS_AT_END_POSITION
[2062]395                gids.at[blk_offset + epos] = gid;
[2052]396                #else
[2101]397                gids.at[blk_offset + fpos - lgth] = gid;
[2052]398                #endif
399
400                #ifdef ID_SYMBOL_TABLE_TEMPLATE_HPP_DEBUG
[2101]401                        //print_symbol_debug(gid, buffer, spos, fpos, lgth);
402                        print_symbol_debug(gid, buffer_base, spos, fpos, gid_data.get_bytes_lgth(gid));
[2052]403                #endif
404
[2097]405                follows_rscanner.scan_to_next();
[2101]406                fpos = follows_rscanner.get_pos();
[2052]407        }
408}
409
410#endif // ID_SYMBOL_TABLE_TEMPLATE_HPP
411
[2053]412
413/* // Forward Scan
[2052]414void do_block(uint32_t blk_offset,
415                  HASH_TABLE & h_table,
[2097]416                  BitBlock follows,
[2052]417                  uint8_t buffer [], const uint32_t lgth,
418                  uint8_t h0 [], uint8_t h1 [], const uint32_t h_lgth, const uint32_t h_block_size,
419                  SYMBOL & symbols, GIDFactory & gid_factory, GIDData & gid_data) {
[1979]420
[2052]421        gid_type gid;
422        int32_t spos;
423        int32_t epos;
[2097]424        ForwardScanner<BitBlock, scanword_t> fscanner(&follows);
[1979]425
[2052]426        fscanner.scan_to_next();
427        epos = fscanner.get_pos();
428        spos = (epos - lgth);
429
430        if(!fscanner.is_done() && (spos < 0) ) { // block boundary case
431
432        ////////////////////////////////////////////////////////////////////
433        // Start - Review boundary logic
434        ////////////////////////////////////////////////////////////////////
435        uint8_t * lb_buffer = buffer - ((lgth / BLOCK_SIZE) + 1)*BLOCK_SIZE;
436        int32_t lb_spos = (BLOCK_SIZE - (-1*spos)) & (BLOCK_SIZE-1);
437
438        uint8_t * lb_h0 = h0 - ((lgth / BLOCK_SIZE) + 1)*h_block_size;
439        uint8_t * lb_h1 = h1 - ((lgth / BLOCK_SIZE) + 1)*h_block_size;
440
441        gid = h_table.lookup_or_insert(lb_buffer, lb_spos, lgth, lb_h0, lb_h1, h_lgth, gid_factory, gid_data);
442
443        symbols.gids[blk_offset + spos] = gid;
444        ////////////////////////////////////////////////////////////////////
445        // End
446        ////////////////////////////////////////////////////////////////////
447
448        #ifdef ID_SYMBOL_TABLE_TEMPLATE_HPP_DEBUG
449                        print_symbol_debug(gid, lb_buffer, lb_spos, epos, lgth);
450        #endif
451
452        fscanner.scan_to_next();
453        epos = fscanner.get_pos();
454        spos = (epos - lgth);
455
456        }
457
458        while(!fscanner.is_done()) {
459
460                gid = h_table.lookup_or_insert(buffer, spos, lgth, h0, h1, h_lgth, gid_factory, gid_data);
461                symbols.gids[blk_offset + spos] = gid;
462
463        #ifdef ID_SYMBOL_TABLE_TEMPLATE_HPP_DEBUG
464                print_symbol_debug(gid, buffer, spos, epos, lgth);
465        #endif
466
467                fscanner.scan_to_next();
468                epos = fscanner.get_pos();
469                spos = (epos - lgth);
470        }
471
472}
[1979]473*/
474
Note: See TracBrowser for help on using the repository browser.