1 /*------------------------------------------------------------\
2 | |
3 | This file is part of the Alliance CAD System Copyright |
4 | (C) Laboratoire LIP6 - D�partement ASIM Universite P&M Curie|
5 | |
6 | Home page : http://www-asim.lip6.fr/alliance/ |
7 | E-mail : mailto:alliance-users@asim.lip6.fr |
8 | |
9 | This progam is free software; you can redistribute it |
10 | and/or modify it under the terms of the GNU Library General|
11 | Public License as published by the Free Software Foundation |
12 | either version 2 of the License, or (at your option) any |
13 | later version. |
14 | |
15 | Alliance VLSI CAD System is distributed in the hope that |
16 | it will be useful, but WITHOUT ANY WARRANTY; |
17 | without even the implied warranty of MERCHANTABILITY or |
18 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General |
19 | Public License for more details. |
20 | |
21 | You should have received a copy of the GNU General Public |
22 | License along with the GNU C Library; see the file COPYING. |
23 | If not, write to the Free Software Foundation, Inc., |
24 | 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. |
25 | |
26 \------------------------------------------------------------*/
27 /*------------------------------------------------------------\
28 | |
29 | Tool : Abl |
30 | |
31 | File : ablstr.c |
32 | |
33 | Date : 03.12.96 |
34 | |
35 | Author : Jacomme Ludovic |
36 | |
37 \------------------------------------------------------------*/
38 /*------------------------------------------------------------\
39 | |
40 | Include Files |
41 | |
42 \------------------------------------------------------------*/
43
44 # include "mut.h"
45 # include "aut.h"
46 # include "abl.h"
47
48 # include <stdio.h>
49 # include <ctype.h>
50 # include <string.h>
51 # include "ablstr.h"
52 # include "ablerror.h"
53
54 /*------------------------------------------------------------\
55 | |
56 | Constants |
57 | |
58 \------------------------------------------------------------*/
59 /*------------------------------------------------------------\
60 | |
61 | Types |
62 | |
63 \------------------------------------------------------------*/
64 /*------------------------------------------------------------\
65 | |
66 | Variables |
67 | |
68 \------------------------------------------------------------*/
69
70 static char *AblScanString = (char *)0;
71 static char AblStringOper = 0;
72
73 /*------------------------------------------------------------\
74 | |
75 | Functions |
76 | |
77 \------------------------------------------------------------*/
78 /*------------------------------------------------------------\
79 | |
80 | Skip Blank |
81 | |
82 \------------------------------------------------------------*/
83
loc_strablskipblank()84 static void loc_strablskipblank()
85
86 {
87 while ( ( *AblScanString != '\0' ) &&
88 ( isspace( (int)*AblScanString ) ) )
89 {
90 AblScanString = AblScanString + 1;
91 }
92 }
93
94 /*------------------------------------------------------------\
95 | |
96 | End Word |
97 | |
98 \------------------------------------------------------------*/
99
loc_strablendword()100 static void loc_strablendword()
101
102 {
103 int Open;
104
105 Open = 0;
106
107 while ( ( *AblScanString != '\0' ) &&
108 ( ! isspace( (int)*AblScanString ) ) )
109 {
110 if ( *AblScanString == '(' )
111 {
112 if ( Open == 0 )
113 {
114 Open = 1; *AblScanString = ' ';
115 }
116 else break;
117 }
118 else
119 if ( *AblScanString == ')' )
120 {
121 if ( Open == 1 )
122 {
123 Open = 0; *AblScanString = '\0';
124 }
125 else break;
126 }
127
128 AblScanString = AblScanString + 1;
129 }
130 }
131
132 /*------------------------------------------------------------\
133 | |
134 | Get Word |
135 | |
136 \------------------------------------------------------------*/
137
loc_strablgetword()138 static char *loc_strablgetword()
139
140 {
141 char *BeginWord;
142 char *EndWord;
143 char SwapChar;
144
145 BeginWord = AblScanString;
146 loc_strablendword();
147 EndWord = AblScanString;
148
149 if ( BeginWord == EndWord )
150 {
151 return( (char *)0 );
152 }
153
154 SwapChar = *EndWord;
155 *EndWord = '\0';
156 BeginWord = namealloc( BeginWord );
157 *EndWord = SwapChar;
158
159 return( BeginWord );
160 }
161
162 /*------------------------------------------------------------\
163 | |
164 | Str Functions |
165 | |
166 \------------------------------------------------------------*/
167 /*------------------------------------------------------------\
168 | |
169 | Str Abl Infix Expr |
170 | |
171 \------------------------------------------------------------*/
172
loc_strablinfix()173 static ablexpr *loc_strablinfix()
174 {
175 ablexpr *Expr;
176 ablexpr *ExprQueue;
177 ablexpr *ExprStr;
178 char ToggleOper;
179 char *Name;
180 long Oper;
181
182 loc_strablskipblank();
183
184 if ( *AblScanString == '(' )
185 {
186 AblScanString = AblScanString + 1;
187 loc_strablskipblank();
188
189 if ( *AblScanString != '\0' )
190 {
191 ExprStr = loc_strablinfix();
192
193 if ( ExprStr == (ablexpr *)0 )
194 {
195 return( (ablexpr *)0 );
196 }
197
198 Expr = addchain( (ablexpr *)0,
199 (void *)ExprStr );
200 ExprQueue = Expr;
201
202 if ( AblStringOper )
203 {
204 AblStringOper = 0;
205
206 Oper = ABL_OPER( Expr );
207 ToggleOper = 0;
208 }
209 else
210 {
211 Oper = -1;
212 ToggleOper = 1;
213 }
214
215 loc_strablskipblank();
216
217 while ( ( *AblScanString != ')' ) &&
218 ( *AblScanString != '\0' ) )
219 {
220 ExprStr = loc_strablinfix();
221
222 if ( ExprStr == (ablexpr *)0 )
223 {
224 freeablexpr( Expr );
225 return( (ablexpr *)0 );
226 }
227
228 if ( AblStringOper )
229 {
230 AblStringOper = 0;
231
232 if ( ! ToggleOper )
233 {
234 freeablexpr( ExprStr );
235 freeablexpr( Expr );
236 return( (ablexpr *)0 );
237 }
238
239 if ( Oper == -1 )
240 {
241 Expr = addchain( Expr, (void *)ExprStr );
242 Oper = ABL_OPER( Expr );
243 }
244 else
245 {
246 if ( Oper != (long)ABL_CAR( ExprStr ) )
247 {
248 freeablexpr( ExprStr );
249 freeablexpr( Expr );
250 return( (ablexpr *)0 );
251 }
252
253 freeablexpr( ExprStr );
254 }
255 }
256 else
257 {
258 if ( ToggleOper )
259 {
260 freeablexpr( ExprStr );
261 freeablexpr( Expr );
262 return( (ablexpr *)0 );
263 }
264
265 ABL_CDR( ExprQueue ) = addchain( (ablexpr *)0,
266 (void *)ExprStr );
267 ExprQueue = ABL_CDR( ExprQueue );
268 }
269
270 loc_strablskipblank();
271
272 ToggleOper = ! ToggleOper;
273 }
274
275 if ( Oper == -1 )
276 {
277 ExprStr = ABL_CAR( Expr );
278 freechain( Expr );
279 Expr = ExprStr;
280 }
281 else
282 if ( isablunaryoper( Oper ) )
283 {
284 if ( ABL_CDDR( Expr ) != (ablexpr *)0 )
285 {
286 freeablexpr( Expr );
287 return( (ablexpr *)0 );
288 }
289 }
290 else
291 if ( ABL_CDDR( Expr ) == (ablexpr *)0 )
292 {
293 freeablexpr( Expr );
294 return( (ablexpr *)0 );
295 }
296 }
297 else
298 {
299 return( (ablexpr *)0 );
300 }
301
302 if ( *AblScanString == ')' )
303 {
304 AblScanString = AblScanString + 1;
305 }
306 else
307 {
308 freeablexpr( Expr );
309 return( (ablexpr *)0 );
310 }
311 }
312 else
313 {
314 Name = loc_strablgetword();
315
316 if ( Name == (char *)0 )
317 {
318 return( (ablexpr *)0 );
319 }
320
321 Oper = getabloperbyname( Name );
322
323 if ( Oper == -1 )
324 {
325 Expr = addchain( (ablexpr *)0, (void *)Name );
326 }
327 else
328 {
329 Expr = addchain( (ablexpr *)0, (void *)Oper );
330 AblStringOper = 1;
331 }
332 }
333
334 return( Expr );
335 }
336
337 /*------------------------------------------------------------\
338 | |
339 | Str Abl Prefix Expr |
340 | |
341 \------------------------------------------------------------*/
342
loc_strablprefix()343 static ablexpr *loc_strablprefix()
344 {
345 ablexpr *Expr;
346 ablexpr *ExprQueue;
347 ablexpr *ExprStr;
348 char *Name;
349 long Oper;
350
351 loc_strablskipblank();
352
353 if ( *AblScanString == '(' )
354 {
355 AblScanString = AblScanString + 1;
356 loc_strablskipblank();
357
358 Name = loc_strablgetword();
359
360 if ( Name == (char *)0 )
361 {
362 return( (ablexpr *)0 );
363 }
364
365 Oper = getabloperbyname( Name );
366
367 loc_strablskipblank();
368
369 if ( *AblScanString == ')' )
370 {
371 if ( Oper == -1 )
372 {
373 Expr = addchain( (ablexpr *)0, Name );
374 }
375 else
376 {
377 return( (ablexpr *)0 );
378 }
379 }
380 else
381 if ( *AblScanString != '\0' )
382 {
383 Expr = addchain( (ablexpr *)0,
384 (void *)addchain( (ablexpr *)0,
385 (void *)Oper ) );
386
387 ExprQueue = Expr;
388
389 do
390 {
391 ExprStr = loc_strablprefix();
392
393 if ( ExprStr == (ablexpr *)0 )
394 {
395 freeablexpr( Expr );
396 return( (ablexpr *)0 );
397 }
398
399 ABL_CDR( ExprQueue ) = addchain( (ablexpr *)0,
400 (void *)ExprStr );
401 ExprQueue = ABL_CDR( ExprQueue );
402
403 loc_strablskipblank();
404 }
405 while ( ( *AblScanString != ')' ) &&
406 ( *AblScanString != '\0' ) );
407
408 if ( isablunaryoper( Oper ) )
409 {
410 if ( ABL_CDDR( Expr ) != (ablexpr *)0 )
411 {
412 freeablexpr( Expr );
413 return( (ablexpr *)0 );
414 }
415 }
416 else
417 if ( ABL_CDDR( Expr ) == (ablexpr *)0 )
418 {
419 freeablexpr( Expr );
420 return( (ablexpr *)0 );
421 }
422 }
423 else
424 {
425 return( (ablexpr *)0 );
426 }
427
428 if ( *AblScanString == ')' )
429 {
430 AblScanString = AblScanString + 1;
431 }
432 else
433 {
434 freeablexpr( Expr );
435 return( (ablexpr *)0 );
436 }
437 }
438 else
439 {
440 Name = loc_strablgetword();
441
442 if ( Name == (char *)0 )
443 {
444 return( (ablexpr *)0 );
445 }
446
447 Oper = getabloperbyname( Name );
448
449 if ( Oper == -1 )
450 {
451 Expr = addchain( (ablexpr *)0, (void *)Name );
452 }
453 else
454 {
455 return( (ablexpr *)0 );
456 }
457 }
458
459 return( Expr );
460 }
461
462 /*------------------------------------------------------------\
463 | |
464 | Str Abl Postfix Expr |
465 | |
466 \------------------------------------------------------------*/
467
loc_strablpostfix()468 static ablexpr *loc_strablpostfix()
469 {
470 ablexpr *Expr;
471 ablexpr *ExprQueue;
472 ablexpr *ExprStr;
473 char *Name;
474 long Oper;
475
476 loc_strablskipblank();
477
478 if ( *AblScanString == '(' )
479 {
480 AblScanString = AblScanString + 1;
481 loc_strablskipblank();
482
483 if ( *AblScanString != '\0' )
484 {
485 ExprStr = loc_strablpostfix();
486
487 if ( ExprStr == (ablexpr *)0 )
488 {
489 return( (ablexpr *)0 );
490 }
491
492 if ( AblStringOper )
493 {
494 AblStringOper = 0;
495
496 freeablexpr( ExprStr );
497 return( (ablexpr *)0 );
498 }
499
500 Expr = addchain( (ablexpr *)0,
501 (void *)ExprStr );
502
503 ExprQueue = Expr;
504 Oper = -1;
505
506 loc_strablskipblank();
507
508 while ( ( Oper == -1 ) &&
509 ( *AblScanString != ')' ) &&
510 ( *AblScanString != '\0' ) )
511 {
512 ExprStr = loc_strablpostfix();
513
514 if ( ExprStr == (ablexpr *)0 )
515 {
516 freeablexpr( Expr );
517 return( (ablexpr *)0 );
518 }
519
520 if ( AblStringOper )
521 {
522 Expr = addchain( Expr, (void *)ExprStr );
523 Oper = ABL_OPER( Expr );
524 AblStringOper = 0;
525 }
526 else
527 {
528 ABL_CDR( ExprQueue ) = addchain( (ablexpr *)0,
529 (void *)ExprStr );
530 ExprQueue = ABL_CDR( ExprQueue );
531 }
532
533 loc_strablskipblank();
534 }
535
536 if ( Oper == -1 )
537 {
538 if ( ABL_CDR( Expr ) != (ablexpr *)0 )
539 {
540 freeablexpr( Expr );
541 return( (ablexpr *)0 );
542 }
543
544 ExprStr = ABL_CAR( Expr );
545 freechain( Expr );
546 Expr = ExprStr;
547 }
548 else
549 if ( isablunaryoper( Oper ) )
550 {
551 if ( ABL_CDDR( Expr ) != (ablexpr *)0 )
552 {
553 freeablexpr( Expr );
554 return( (ablexpr *)0 );
555 }
556 }
557 else
558 if ( ABL_CDDR( Expr ) == (ablexpr *)0 )
559 {
560 freeablexpr( Expr );
561 return( (ablexpr *)0 );
562 }
563 }
564 else
565 {
566 return( (ablexpr *)0 );
567 }
568
569 if ( *AblScanString == ')' )
570 {
571 AblScanString = AblScanString + 1;
572 }
573 else
574 {
575 freeablexpr( Expr );
576 return( (ablexpr *)0 );
577 }
578 }
579 else
580 {
581 Name = loc_strablgetword();
582
583 if ( Name == (char *)0 )
584 {
585 return( (ablexpr *)0 );
586 }
587
588 Oper = getabloperbyname( Name );
589
590 if ( Oper == -1 )
591 {
592 Expr = addchain( (ablexpr *)0, (void *)Name );
593 }
594 else
595 {
596 Expr = addchain( (ablexpr *)0, (void *)Oper );
597 AblStringOper = 1;
598 }
599 }
600
601 return( Expr );
602 }
603
604 /*------------------------------------------------------------\
605 | |
606 | Str Abl Expr |
607 | |
608 \------------------------------------------------------------*/
609
strablexpr(String,Mode)610 ablexpr *strablexpr( String, Mode )
611
612 char *String;
613 int Mode;
614 {
615 ablexpr *Expr;
616
617 String = mbkstrdup( String );
618
619 AblScanString = String;
620 AblStringOper = 0;
621
622 if ( Mode == ABL_VIEW_INFIX )
623 {
624 Expr = loc_strablinfix();
625 }
626 else
627 if ( Mode == ABL_VIEW_PREFIX )
628 {
629 Expr = loc_strablprefix();
630 }
631 else
632 {
633 Expr = loc_strablpostfix();
634 }
635
636 loc_strablskipblank();
637
638 if ( ( AblStringOper ) ||
639 ( *AblScanString != '\0' ) )
640 {
641 freeablexpr( Expr );
642 Expr = (ablexpr *)0;
643 }
644
645 mbkfree( String );
646
647 return( Expr );
648 }
649