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

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

Updated symbol table to represent group 0 as the arbitrary length group.

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