1 /******************************************************************************
2 *
3 * Copyright (C) 2006, The Gentee Group. All rights reserved.
4 * This file is part of the Gentee open source project - http://www.gentee.com.
5 *
6 * THIS FILE IS PROVIDED UNDER THE TERMS OF THE GENTEE LICENSE ("AGREEMENT").
7 * ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS FILE CONSTITUTES RECIPIENTS
8 * ACCEPTANCE OF THE AGREEMENT.
9 *
10 * ID: lex 18.10.06 0.0.A.
11 *
12 * Author: Alexey Krivonogov ( gentee )
13 *
14 ******************************************************************************/
15
16 #include "lex.h"
17 #include "lextbl.h"
18 //! temporary
19 #include "../os/user/defines.h"
20
21 //----------------------------------------------------------------------------
22
23 uint STDCALL gentee_lexptr( pubyte in, plex pl, parr output )
24 {
25 plexitem pli, pn;
26 plexexp pexp = 0;
27 uint pos, i, posoff = 0;
28 // pubyte in = buf_ptr( input ); // Входящий буфер
29 puint pmain = ( puint )buf_ptr( &pl->tbl );
30 puint ptbl = pmain; // текущая строка разбора
31 uint cur = 0; // Номер текущего разбираемого символа
32
33 uint newstate, cmd, nameoff, len;
34 uint flag, val, keyword = 0, istext = 0;
35 lextry ltry;
36 uint sn_pos, sn_len = 0;
37 uint isnew = 0;
38 uint pair = 0;
39
40 arr_clear( &pl->state );
41 arr_clear( &pl->expr );
42 arr_clear( &pl->litems );
43 arr_clear( &pl->mitems );
44 pl->imulti = 0;
45 // arr_appendnum( &pl->state, 0 );
46 do
47 {
48 val = ptbl[ in[ cur ]]; // Получаем новое состояние
49 rettry:
50 // printf("val=%x %c cur=%i li=%i\n", val, in[cur], cur, arr_count( &pl->litems ));
51 if ( pexp && ptbl == pmain )
52 {
53 if ( in[cur] == pexp->left )
54 pexp->count++;
55 if ( in[cur] == pexp->right )
56 {
57 if ( pexp->count )
58 pexp->count--;
59 else
60 {
61 val = ( pexp->state + 1 ) << 16;
62 val |= LEXF_ITSTATE | LEXF_POS;
63 arr_pop( &pl->expr );
64 pexp = ( plexexp )arr_top( &pl->expr );
65 }
66 }
67 }
68 flag = val & 0xFFFF;
69 if ( isnew )
70 {
71 flag |= LEXF_ITSTATE | LEXF_POS;
72 // isnew = 0;
73 }
74 if ( flag & LEXF_PAIR )
75 {
76 switch ( in[ cur ] )
77 {
78 case '[' :
79 pair++;
80 flag = 0;
81 val = LEX_OK;
82 break;
83 case ']' :
84 if ( pair )
85 {
86 pair--;
87 val = LEX_OK;
88 flag = 0;
89 }
90 break;
91 }
92 }
93 if ( flag & LEXF_MULTI )
94 {
95 uint curm, count, k;
96 plexmulti pmulti;
97 pubyte pcmp;
98
99 curm = val >> 24;
100 count = (( val >> 16 ) & 0xff );
101 for ( i = 1; i <= count; i++ )
102 {
103 pmulti = ( plexmulti )arr_ptr( &pl->mitems, curm * 8 + i );
104 pcmp = ( pubyte )&pmulti->chars;
105 // printf( "CMP XXX %s ==% s len = %i\n",
106 // pcmp, in + cur, pmulti->len );
107 for ( k = 1; k < pmulti->len; k++ )
108 {
109 if ( pcmp[k] != in[ cur + k ] )
110 break;
111 }
112 if ( k == pmulti->len )
113 {
114 val = pmulti->value;
115 pos = cur;
116 cur += pmulti->len - 1;
117 if ( val & LEXF_POS )
118 posoff = pmulti->len - 1;
119 // printf( "Multi XXX %i val=%x pos = %i len = %i\n",
120 // cur, val, pos, pmulti->len );
121 goto rettry;
122 }
123 }
124 val = (( plexmulti )arr_ptr( &pl->mitems, curm * 8 ))->value;
125 // printf("Ooops 1= %x\n", val );
126 goto rettry;
127 }
128 newstate = ( val >> 16 ) & 0xFF;
129 cmd = val & 0xFF000000;
130 if ( flag & LEXF_TRY )
131 {
132 ltry.pos = cur;
133 // ltry.state = ((( pubyte )ptbl - buf_ptr( &pl->tbl )) >> 10 ) + 1;
134 ltry.ret = cmd >> 24;
135 }
136 if ( flag & LEXF_RET )
137 {
138 // printf("Ret=%i\n", cur );
139 cur = ltry.pos;//arr_pop( &pl->itry );
140 val = *( puint )( buf_ptr( &pl->tbl ) + (( ltry.ret - 1 ) << 10 ) +
141 sizeof( uint ));
142 // val &= ~LEXF_RET;
143 goto rettry;
144 }
145
146 if ( flag & LEXF_POS )
147 {
148 pos = cur - posoff;
149 posoff = 0;
150 }
151 if ( flag & LEXF_ITCMD || flag & LEXF_ITSTATE )
152 {
153 if ( istext && in[cur] == 0xa )
154 {
155 newstate = 2;
156 istext = 0;
157 }
158 if ( keyword ) // Надо проверить предыдущую лексему на keyword
159 {
160 ubyte curch = in[ pli->pos + pli->len ];
161
162 keyword = 0;
163 in[ pli->pos + pli->len ] = 0;
164 pli->value = hash_getuint( &pl->keywords, in + pli->pos );
165 // printf( ">%s< %i = %i\n", in + pli->pos, pli->len, pli->value );
166 if ( pli->value == 255 &&
167 *( puint )( in + pli->pos ) == 0x74786574 )// text for gentee
168 {
169 in[ pli->pos + pli->len ] = curch;
170 cur = pli->pos + pli->len;
171 istext = 1;
172 continue;
173 }
174 else
175 in[ pli->pos + pli->len ] = curch;
176 }
177 // Добавляем лексему
178 pli = arr_append( output );
179 pli->type = ( flag & LEXF_ITCMD ) ? cmd : ( val & 0xFF0000 );
180 pli->pos = pos;
181 if ( isnew )
182 {
183 pli->type = (((( pubyte )ptbl - buf_ptr( &pl->tbl )) >> 10 ) + 1 ) << 16 ;
184 // printf( "TYPE NEW = %i\n", pli->type );
185 isnew = 0;
186 }
187 pli->value = 0;
188 pli->len = cur - pos + 1;
189 if ( flag & LEXF_STAY )
190 pli->len--;
191 if ( flag & LEXF_VALUE )
192 {
193 for ( i = 0; i < pli->len; i++ )
194 pli->value |= in[ pos + i ] << ( i << 3 );
195 }
196 if ( flag & LEXF_KEYWORD )
197 keyword = 1;
198 // printf("LEX_ITEM %i %i state=%x val=%x\n", pli->pos, pli->len, pli->type, val & 0xFF0000 );
199 }
200 switch ( cmd )
201 {
202 case LEX_STRNAME:
203 if ( sn_len )
204 {
205 if ( mem_cmp( in + cur, in + sn_pos, sn_len ))
206 {
207 cur++;
208 continue;
209 }
210 sn_len = 0;
211 }
212 else
213 {
214 sn_pos = cur;
215 while ( in[ cur ] && in[cur] != ']' )
216 cur++;
217 sn_len = cur - sn_pos + 1;
218 // printf("STR_NAME %i %i\n", sn_pos, sn_len );
219 cur--;
220 }
221 break;
222 case LEX_EXPR:
223 pexp = ( plexexp )arr_append( &pl->expr );
224 pexp->left = in[cur];
225 pexp->right = in[cur] != '{' ? ')' : '}';
226 pexp->count = 0;
227 pexp->state = (( pubyte )ptbl - buf_ptr( &pl->tbl )) >> 10;
228 case LEX_OK:
229 pli->len = cur - pli->pos + 1;//++;
230 // printf("LEX_OK %i %i cur = %i c=%c\n", pli->pos, pli->len, cur, in[ cur ] );
231 break;
232 case LEX_GTNAME:
233 pn = ( plexitem )arr_ptr( output, arr_getlast( &pl->litems ));
234 nameoff = pn->pos + 1;
235 if ( in[ nameoff ] == '|' )
236 nameoff++;
237 if ( in[ nameoff ] == '*' )
238 nameoff++;
239 len = pn->len - ( nameoff - pn->pos );
240
241 for ( i = 0; i < len; i++ )
242 {
243 if ( in[ cur + i ] != in[ nameoff + i ])
244 break;
245 }
246 // printf("OK %i %c == %c\n", i, in[ cur + i], in[ nameoff + i ]);
247
248 if ( i == len && in[ cur + i ] == '>' )
249 {
250 cur += i;
251 continue;
252 }
253 else
254 {
255 // cur++;
256 // val = //ptbl[ 1 ];
257 cur = ltry.pos;//arr_pop( &pl->itry );
258 val = *( puint )( buf_ptr( &pl->tbl ) + (( ltry.ret - 1 ) << 10 ) +
259 sizeof( uint ));
260 // printf( "GTNAME=%i %x\n", cur, val );
261 goto rettry;
262 }
263 break;
264 }
265 if ( flag & LEXF_PUSHLI )
266 {
267 arr_appendnum( &pl->litems, arr_count( output ) - 1 );
268 // printf("PUSHLI now = %i\n", arr_count( &pl->litems ));
269 }
270 if ( flag & LEXF_PUSH )
271 {
272 // arr_appendnum( &pl->litems, arr_count( output ) - 1 );
273 i = (( pubyte )ptbl - buf_ptr( &pl->tbl )) >> 10;
274 arr_appendnum( &pl->state, i + 1 );
275 // printf("PUSH newstate = %x now = %i first=%i\n", i + 1,
276 // arr_count( &pl->state ), *( puint )arr_ptr( &pl->state, 0 ));
277 // if ( flag & LEXF_NAME )
278 // arr_appendnum( &pl->litems, arr_count( output ) - 1 );
279 }
280 if ( flag & LEXF_POPLI )
281 {
282 arr_pop( &pl->litems );
283 // printf("POPLI now = %i\n", arr_count( &pl->litems ));
284 }
285 if ( flag & LEXF_POP )// && !newstate )
286 {
287 uint l = arr_pop( &pl->state );
288 if ( !newstate )
289 newstate = l;
290 if ( flag & LEXF_NEW )
291 {
292 isnew = 1;
293 // printf("NEW\n");
294 // printf("POP newstate = %x remain = %i first=%i\n", newstate,
295 // arr_count( &pl->state ), *( puint )arr_ptr( &pl->state, 0 ));
296 }
297 // printf("POP newstate = %x remain = %i first=%i\n", newstate,
298 // arr_count( &pl->state ), *( puint )arr_ptr( &pl->state, 0 ));
299 }
300 if ( newstate )
301 ptbl = ( puint )( buf_ptr( &pl->tbl ) + (( newstate - 1 ) << 10 ));
302 if ( !( flag & LEXF_STAY ))
303 cur++;
304
305 } while ( cmd != LEX_STOP );
306
307 return 1;
308 }
309
310 //----------------------------------------------------------------------------
311
312 uint STDCALL gentee_lex( pbuf input, plex pl, parr output )
313 {
314 return gentee_lexptr( buf_ptr( input ), pl, output );
315 }
316
317 //----------------------------------------------------------------------------
318
319 plex STDCALL lex_init( plex pl, puint ptbl )
320 {
321 if ( !pl )
322 {
323 pl = ( plex )mem_alloc( sizeof( lex ));
324 pl->alloced = 1;
325 }
326 else
327 pl->alloced = 0;
328
329 buf_init( &pl->tbl );
330 arr_init( &pl->state, sizeof( uint ));
331 arr_init( &pl->litems, sizeof( uint ));
332 arr_init( &pl->mitems, sizeof( lexmulti ));
333 arr_appenditems( &pl->mitems, 64 * 8 );
334 pl->imulti = 0;
335 hash_init( &pl->keywords, sizeof( uint ));
336 arr_init( &pl->expr, sizeof( lexexp ));
337
338 if ( ptbl )
339 lex_tbl( pl, ptbl );
340 return pl;
341 }
342
343 //----------------------------------------------------------------------------
344
345 void STDCALL lex_delete( plex pl )
346 {
347 buf_delete( &pl->tbl );
348 arr_delete( &pl->state );
349 arr_delete( &pl->litems );
350 arr_delete( &pl->mitems );
351 arr_delete( &pl->expr );
352 hash_delete( &pl->keywords );
353 if ( pl->alloced )
354 mem_free( pl );
355 }
356
Дизайн web-сайта
Copyright © 2004-06 Gentee, Inc., 2006-09 The Gentee Group. Все права защищены.