source: proto/s2k/trunk/framework/output/cpplang/grep/grep_definitions.hpp @ 3782

Last change on this file since 3782 was 3782, checked in by ksherdy, 5 years ago

Added graph to b2k. Updated grammars. Added S2K to B2K support.

File size: 11.6 KB
Line 
1// GENERATED CODE. DO NOT MODIFY.
2//
3// This template includes the minimal set of runtime support libraries required
4// to support compilation of s2k generated C++ code (bitblock.hpp, carryQ.hpp,
5// pabloSupport.hpp, bitblock_iterator.hpp)
6//
7// (c) 2012, 2013 Robert D. Cameron, Ken Herdy
8// All rights reserved.
9// Licensed to International Characters, Inc. under Academic Free License 3.0
10//
11//////////////////////////////////////////////////////////////////////////////////////////
12// @ global - Stream structure and stream function declarations.
13//
14//////////////////////////////////////////////////////////////////////////////////////////
15//
16#ifndef GREP_DEFINITIONS_HPP
17#define GREP_DEFINITIONS_HPP
18
19//
20// runtime libraries
21#include <simd-lib/bitblock.hpp>
22#include <simd-lib/carrySet.hpp>
23#include <simd-lib/pabloSupport.hpp>
24#include <simd-lib/bitblock_iterator.hpp>
25
26//
27#define BASIS_BITS
28#include <simd-lib/transpose.hpp>
29//#include <simd-lib/s2p.hpp>
30
31// namespace s2k
32// {
33struct Lex
34{
35        BitBlock a;
36        BitBlock p;
37        BitBlock l;
38        BitBlock e;
39        BitBlock LF;
40};
41 
42struct Output
43{
44        BitBlock match_follows;
45        BitBlock lines;
46        BitBlock line_starts;
47        BitBlock line_ends;
48};
49 
50struct ClassifyBytes
51{
52        ClassifyBytes()
53        {
54        }
55       
56        IDISA_INLINE void do_block(struct Basis_bits & basis_bits,struct Lex & lex)
57        {
58                BitBlock temp1;
59                temp1 = simd_andc(basis_bits.bit_1,basis_bits.bit_0);
60                BitBlock temp2;
61                temp2 = simd_andc(basis_bits.bit_2,basis_bits.bit_3);
62                BitBlock temp3;
63                temp3 = simd_and(temp1,temp2);
64                BitBlock temp4;
65                temp4 = simd_or(basis_bits.bit_4,basis_bits.bit_5);
66                BitBlock temp5;
67                temp5 = simd_andc(basis_bits.bit_7,basis_bits.bit_6);
68                BitBlock temp6;
69                temp6 = simd_andc(temp5,temp4);
70                lex.a = simd_and(temp3,temp6);
71                BitBlock temp7;
72                temp7 = simd_and(basis_bits.bit_2,basis_bits.bit_3);
73                BitBlock temp8;
74                temp8 = simd_and(temp1,temp7);
75                BitBlock temp9;
76                temp9 = simd_or(basis_bits.bit_6,basis_bits.bit_7);
77                BitBlock temp10;
78                temp10 = simd_or(temp4,temp9);
79                lex.p = simd_andc(temp8,temp10);
80                BitBlock temp11;
81                temp11 = simd_and(basis_bits.bit_4,basis_bits.bit_5);
82                BitBlock temp12;
83                temp12 = simd_andc(temp11,temp9);
84                lex.l = simd_and(temp3,temp12);
85                BitBlock temp13;
86                temp13 = simd_andc(basis_bits.bit_5,basis_bits.bit_4);
87                BitBlock temp14;
88                temp14 = simd_and(temp13,temp5);
89                lex.e = simd_and(temp3,temp14);
90                BitBlock temp15;
91                temp15 = simd_or(basis_bits.bit_0,basis_bits.bit_1);
92                BitBlock temp16;
93                temp16 = simd_or(basis_bits.bit_2,basis_bits.bit_3);
94                BitBlock temp17;
95                temp17 = simd_or(temp15,temp16);
96                BitBlock temp18;
97                temp18 = simd_andc(basis_bits.bit_4,basis_bits.bit_5);
98                BitBlock temp19;
99                temp19 = simd_andc(basis_bits.bit_6,basis_bits.bit_7);
100                BitBlock temp20;
101                temp20 = simd_and(temp18,temp19);
102                lex.LF = simd_andc(temp20,temp17);
103        }
104       
105        void do_final_block(struct Basis_bits & basis_bits,struct Lex & lex,BitBlock & EOF_mask)
106        {
107                BitBlock temp1;
108                temp1 = simd_andc(basis_bits.bit_1,basis_bits.bit_0);
109                BitBlock temp2;
110                temp2 = simd_andc(basis_bits.bit_2,basis_bits.bit_3);
111                BitBlock temp3;
112                temp3 = simd_and(temp1,temp2);
113                BitBlock temp4;
114                temp4 = simd_or(basis_bits.bit_4,basis_bits.bit_5);
115                BitBlock temp5;
116                temp5 = simd_andc(basis_bits.bit_7,basis_bits.bit_6);
117                BitBlock temp6;
118                temp6 = simd_andc(temp5,temp4);
119                lex.a = simd_and(temp3,temp6);
120                BitBlock temp7;
121                temp7 = simd_and(basis_bits.bit_2,basis_bits.bit_3);
122                BitBlock temp8;
123                temp8 = simd_and(temp1,temp7);
124                BitBlock temp9;
125                temp9 = simd_or(basis_bits.bit_6,basis_bits.bit_7);
126                BitBlock temp10;
127                temp10 = simd_or(temp4,temp9);
128                lex.p = simd_andc(temp8,temp10);
129                BitBlock temp11;
130                temp11 = simd_and(basis_bits.bit_4,basis_bits.bit_5);
131                BitBlock temp12;
132                temp12 = simd_andc(temp11,temp9);
133                lex.l = simd_and(temp3,temp12);
134                BitBlock temp13;
135                temp13 = simd_andc(basis_bits.bit_5,basis_bits.bit_4);
136                BitBlock temp14;
137                temp14 = simd_and(temp13,temp5);
138                lex.e = simd_and(temp3,temp14);
139                BitBlock temp15;
140                temp15 = simd_or(basis_bits.bit_0,basis_bits.bit_1);
141                BitBlock temp16;
142                temp16 = simd_or(basis_bits.bit_2,basis_bits.bit_3);
143                BitBlock temp17;
144                temp17 = simd_or(temp15,temp16);
145                BitBlock temp18;
146                temp18 = simd_andc(basis_bits.bit_4,basis_bits.bit_5);
147                BitBlock temp19;
148                temp19 = simd_andc(basis_bits.bit_6,basis_bits.bit_7);
149                BitBlock temp20;
150                temp20 = simd_and(temp18,temp19);
151                lex.LF = simd_andc(temp20,temp17);
152        }
153       
154        void clear()
155        {
156               
157        }
158       
159        CarryDeclare(carry_set_0,0,0);
160};
161 
162struct Match
163{
164        Match()
165        {
166        }
167       
168        IDISA_INLINE void do_block(struct Lex & lex,struct Output & output)
169        {
170                BitBlock cursor;
171                carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(lex.a,carry_set_0.getCarry(0),cursor));
172                carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(simd_and(cursor,lex.p),carry_set_0.getCarry(1),cursor));
173                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(simd_and(cursor,lex.p),carry_set_0.getCarry(2),cursor));
174                carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(simd_and(cursor,lex.l),carry_set_0.getCarry(3),cursor));
175                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(simd_and(cursor,lex.e),carry_set_0.getCarry(4),cursor));
176                output.match_follows = cursor;
177                carry_set_0.carryAdjust(5);
178        }
179       
180        void do_final_block(struct Lex & lex,struct Output & output,BitBlock & EOF_mask)
181        {
182                BitBlock cursor;
183                carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(lex.a,carry_set_0.getCarry(0),cursor));
184                carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(simd_and(cursor,lex.p),carry_set_0.getCarry(1),cursor));
185                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(simd_and(cursor,lex.p),carry_set_0.getCarry(2),cursor));
186                carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(simd_and(cursor,lex.l),carry_set_0.getCarry(3),cursor));
187                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(simd_and(cursor,lex.e),carry_set_0.getCarry(4),cursor));
188                output.match_follows = cursor;
189        }
190       
191        void clear()
192        {
193               
194        }
195       
196        CarryDeclare(carry_set_0,5,0);
197};
198 
199struct MatchLines
200{
201        MatchLines()
202        {
203                carry_set_0.setCarry(carry_set_0.carryFlip(0),0);
204                carry_set_0.setCarry(carry_set_0.carryFlip(2),2);
205        }
206       
207        IDISA_INLINE void do_block(struct Lex & lex,struct Output & output)
208        {
209                BitBlock all_line_starts;
210                BitBlock _temp0;
211                BitBlock _temp1;
212                carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanToFirst(simd_not(lex.LF),carry_set_0.getCarry(0),_temp0));
213                carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(lex.LF,carry_set_0.getCarry(1),_temp1));
214                all_line_starts = simd_or(_temp0,simd_andc(_temp1,lex.LF));
215                BitBlock all_line_ends;
216                all_line_ends = lex.LF;
217                BitBlock last_line_start;
218                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanToFirst(all_line_starts,carry_set_0.getCarry(2),last_line_start));
219                BitBlock cursor;
220                cursor = last_line_start;
221                if (bitblock::any(simd_or(cursor,carry_set_0.carryRange(3,3))))
222                {
223                        if (bitblock::any(simd_and(cursor,all_line_starts)))
224                        {
225                                last_line_start = cursor;
226                        }
227                        if (bitblock::any(simd_or(simd_and(cursor,output.match_follows),carry_set_0.carryRange(3,2))))
228                        {
229                                carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(cursor,simd_not(lex.LF),carry_set_0.getCarry(3),cursor));
230                                BitBlock _temp2;
231                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_InclusiveSpan(last_line_start,cursor,carry_set_0.getCarry(4),_temp2));
232                                output.lines = simd_or(output.lines,_temp2);
233                        }
234                        else
235                        {
236                                carry_set_0.carryDequeueEnqueue(3,2);
237                        }
238                        carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(cursor,simd_not(simd_or(all_line_starts,output.match_follows)),carry_set_0.getCarry(5),cursor));
239                        while (bitblock::any(cursor))
240                        {
241                                CarryDeclare(carry_set_1,3,0);
242                                if (bitblock::any(simd_and(cursor,all_line_starts)))
243                                {
244                                        last_line_start = cursor;
245                                }
246                                if (bitblock::any(simd_and(cursor,output.match_follows)))
247                                {
248                                        carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(cursor,simd_not(lex.LF),carry_set_1.getCarry(0),cursor));
249                                        BitBlock _temp2;
250                                        carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_InclusiveSpan(last_line_start,cursor,carry_set_1.getCarry(1),_temp2));
251                                        output.lines = simd_or(output.lines,_temp2);
252                                }
253                                carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(cursor,simd_not(simd_or(all_line_starts,output.match_follows)),carry_set_1.getCarry(2),cursor));
254                                LocalCarryCombine(carry_set_0,carry_set_1,3,3);
255                        }
256                }
257                else
258                {
259                        carry_set_0.carryDequeueEnqueue(3,3);
260                }
261                output.line_starts = simd_and(output.lines,all_line_starts);
262                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(output.line_starts,simd_not(simd_and(output.lines,all_line_ends)),carry_set_0.getCarry(6),output.line_ends));
263                carry_set_0.carryAdjust(7);
264        }
265       
266        void do_final_block(struct Lex & lex,struct Output & output,BitBlock & EOF_mask)
267        {
268                BitBlock all_line_starts;
269                BitBlock _temp0;
270                BitBlock _temp1;
271                carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanToFirst(simd_or(simd_not(lex.LF),simd_not(EOF_mask)),carry_set_0.getCarry(0),_temp0));
272                carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(lex.LF,carry_set_0.getCarry(1),_temp1));
273                all_line_starts = simd_or(_temp0,simd_andc(_temp1,lex.LF));
274                BitBlock all_line_ends;
275                all_line_ends = lex.LF;
276                BitBlock last_line_start;
277                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanToFirst(simd_or(all_line_starts,simd_not(EOF_mask)),carry_set_0.getCarry(2),last_line_start));
278                BitBlock cursor;
279                cursor = last_line_start;
280                if (bitblock::any(simd_and(simd_or(simd_and(cursor,EOF_mask),carry_set_0.carryRange(3,3)),EOF_mask)))
281                {
282                        if (bitblock::any(simd_and(cursor,all_line_starts)))
283                        {
284                                last_line_start = cursor;
285                        }
286                        if (bitblock::any(simd_or(simd_and(cursor,output.match_follows),carry_set_0.carryRange(3,2))))
287                        {
288                                carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(cursor,simd_andc(EOF_mask,lex.LF),carry_set_0.getCarry(3),cursor));
289                                BitBlock _temp2;
290                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_InclusiveSpan(last_line_start,cursor,carry_set_0.getCarry(4),_temp2));
291                                output.lines = simd_or(output.lines,_temp2);
292                        }
293                        else
294                        {
295                                carry_set_0.carryDequeueEnqueue(3,2);
296                        }
297                        carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(cursor,simd_andc(EOF_mask,simd_or(all_line_starts,output.match_follows)),carry_set_0.getCarry(5),cursor));
298                        while (bitblock::any(simd_and(simd_and(cursor,EOF_mask),EOF_mask)))
299                        {
300                                CarryDeclare(carry_set_1,3,0);
301                                if (bitblock::any(simd_and(cursor,all_line_starts)))
302                                {
303                                        last_line_start = cursor;
304                                }
305                                if (bitblock::any(simd_and(cursor,output.match_follows)))
306                                {
307                                        carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(cursor,simd_andc(EOF_mask,lex.LF),carry_set_1.getCarry(0),cursor));
308                                        BitBlock _temp2;
309                                        carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_InclusiveSpan(last_line_start,cursor,carry_set_1.getCarry(1),_temp2));
310                                        output.lines = simd_or(output.lines,_temp2);
311                                }
312                                carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(cursor,simd_andc(EOF_mask,simd_or(all_line_starts,output.match_follows)),carry_set_1.getCarry(2),cursor));
313                                LocalCarryCombine(carry_set_0,carry_set_1,3,3);
314                        }
315                }
316                else
317                {
318                        carry_set_0.carryDequeueEnqueue(3,3);
319                }
320                output.line_starts = simd_and(output.lines,all_line_starts);
321                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(output.line_starts,simd_andc(EOF_mask,simd_and(output.lines,all_line_ends)),carry_set_0.getCarry(6),output.line_ends));
322        }
323       
324        void clear()
325        {
326                carry_set_0.setCarry(carry_set_0.carryFlip(0),0);
327                carry_set_0.setCarry(carry_set_0.carryFlip(2),2);
328        }
329       
330        CarryDeclare(carry_set_0,7,0);
331};
332 
333
334// }
335
336#endif // GREP_DEFINITIONS_HPP
337
Note: See TracBrowser for help on using the repository browser.