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

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

Refactored build process. Added log2 support.

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