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 General Public |
11 | 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 | |
30 | Tool : GRAAL |
31 | |
32 | File : GsbParse.c |
33 | |
34 | Authors : Jacomme Ludovic |
35 | |
36 | Date : 28.03.95 |
37 | |
38 \------------------------------------------------------------*/
39
40 /*------------------------------------------------------------\
41 | |
42 | Include Files |
43 | |
44 \------------------------------------------------------------*/
45
46 # include <stdlib.h>
47 # include <string.h>
48 # include "mut.h"
49 # include "mph.h"
50 # include "rds.h"
51 # include "rwi.h"
52 # include "rut.h"
53 # include "rpr.h"
54 # include "GSB.h"
55 # include "GSB_error.h"
56 # include "GSB_parse.h"
57
58 /*------------------------------------------------------------\
59 | |
60 | Constants |
61 | |
62 \------------------------------------------------------------*/
63 /*------------------------------------------------------------\
64 | |
65 | Types |
66 | |
67 \------------------------------------------------------------*/
68 /*------------------------------------------------------------\
69 | |
70 | Global Variables |
71 | |
72 \------------------------------------------------------------*/
73
74 char *GRAAL_TECHNO_NAME = (char *)NULL;
75
76 long GRAAL_RDS_LAMBDA = 0;
77 float GRAAL_SCALE_X = 0.0;
78 long GRAAL_SCALE = 1;
79
80 /*------------------------------------------------------------\
81 | |
82 | Private Variables |
83 | |
84 \------------------------------------------------------------*/
85 /*------------------------------------------------------------\
86 | |
87 | Table variables |
88 | |
89 \------------------------------------------------------------*/
90
91 char *GRAAL_VIA_NAME_TABLE[ MBK_MAX_VIA ][ 3 ];
92 char *GRAAL_BIGVIA_NAME_TABLE[ MBK_MAX_VIA ][ 3 ];
93 char *GRAAL_SYMMETRY_NAME_TABLE[ MBK_MAX_SYMMETRY ][ 3 ];
94 char *GRAAL_ORIENT_NAME_TABLE[ MBK_MAX_ORIENT ][ 3 ];
95 char *GRAAL_REFERENCE_NAME_TABLE[ MBK_MAX_REFERENCE ][ 3 ];
96 char *GRAAL_SEGMENT_NAME_TABLE[ MBK_MAX_LAYER ][ 3 ];
97 char *GRAAL_TRANSISTOR_NAME_TABLE[ MBK_MAX_LAYER ][ 3 ];
98 char *GRAAL_CONNECTOR_NAME_TABLE[ MBK_MAX_LAYER ][ 3 ];
99 char *GRAAL_RDS_LAYER_NAME_TABLE[ RDS_ALL_LAYER ][ 3 ];
100 char *GRAAL_CURSOR_COLOR_NAME;
101 int GRAAL_RDS_LAYER_PATTERN_TABLE[ RDS_ALL_LAYER ];
102
103 float GRAAL_SEGMENT_VALUE_TABLE[ MBK_MAX_LAYER ][ 2 ];
104 float GRAAL_BIGVIA_VALUE_TABLE[ MBK_MAX_LAYER ][ 1 ];
105 long GRAAL_PEEK_BOUND;
106 long GRAAL_CURSOR_SIZE;
107
108 float GRAAL_LOWER_GRID_STEP;
109 float GRAAL_LOWER_FIGURE_STEP;
110 float GRAAL_LOWER_INSTANCE_STEP;
111 float GRAAL_LOWER_CONNECTOR_STEP;
112 float GRAAL_LOWER_SEGMENT_STEP;
113 float GRAAL_LOWER_REFERENCE_STEP;
114
115 /*------------------------------------------------------------\
116 | |
117 | Keywords variables |
118 | |
119 \------------------------------------------------------------*/
120
121 static char KeywordDefined = 0;
122
123 static char *DefineKeyword;
124 static char *TableKeyword;
125 static char *EndTableKeyword;
126 static char *EndRecordKeyword;
127 static char *PeekBoundKeyword;
128 static char *LowerGridStepKeyword;
129 static char *LowerFigureStepKeyword;
130 static char *LowerInstanceStepKeyword;
131 static char *LowerSegmentStepKeyword;
132 static char *LowerReferenceStepKeyword;
133 static char *LowerConnectorStepKeyword;
134 static char *SegmentNameKeyword;
135 static char *TransistorNameKeyword;
136 static char *ConnectorNameKeyword;
137 static char *SegmentValueKeyword;
138 static char *ViaNameKeyword;
139 static char *BigViaNameKeyword;
140 static char *BigViaValueKeyword;
141 static char *SymmetryNameKeyword;
142 static char *OrientNameKeyword;
143 static char *ReferenceNameKeyword;
144 static char *RdsLayerNameKeyword;
145 static char *CursorColorNameKeyword;
146 static char *CursorSizeKeyword;
147
148
149 static keyword KeywordDefine[ GSB_MAX_KEYWORD ] =
150
151
152 {
153 { "alu1", ALU1 },
154 { "alu2", ALU2 },
155 { "alu3", ALU3 },
156 { "alu4", ALU4 },
157 { "alu5", ALU5 },
158 { "alu6", ALU6 },
159 { "alu7", ALU7 },
160 { "alu8", ALU8 },
161 { "alu9", ALU9 },
162 { "c_x_n", C_X_N },
163 { "c_x_p", C_X_P },
164 { "calu1", CALU1 },
165 { "calu2", CALU2 },
166 { "calu3", CALU3 },
167 { "calu4", CALU4 },
168 { "calu5", CALU5 },
169 { "calu6", CALU6 },
170 { "calu7", CALU7 },
171 { "calu8", CALU8 },
172 { "calu9", CALU9 },
173 { "cont_body_n", CONT_BODY_N },
174 { "cont_body_p", CONT_BODY_P },
175 { "cont_dif_n", CONT_DIF_N },
176 { "cont_dif_p", CONT_DIF_P },
177 { "cont_poly", CONT_POLY },
178 { "cont_poly2", CONT_POLY2 },
179 { "cont_turn1", CONT_TURN1 },
180 { "cont_turn2", CONT_TURN2 },
181 { "cont_turn3", CONT_TURN3 },
182 { "cont_turn4", CONT_TURN4 },
183 { "cont_turn5", CONT_TURN5 },
184 { "cont_turn6", CONT_TURN6 },
185 { "cont_turn7", CONT_TURN7 },
186 { "cont_turn8", CONT_TURN8 },
187 { "cont_turn9", CONT_TURN9 },
188 { "cont_via", CONT_VIA },
189 { "cont_via2", CONT_VIA2 },
190 { "cont_via3", CONT_VIA3 },
191 { "cont_via4", CONT_VIA4 },
192 { "cont_via5", CONT_VIA5 },
193 { "cont_via6", CONT_VIA6 },
194 { "cont_via7", CONT_VIA7 },
195 { "cont_via8", CONT_VIA8 },
196 { "east", GRAAL_EAST },
197 { "ndif", NDIF },
198 { "north", GRAAL_NORTH },
199 { "nosym", NOSYM },
200 { "ntie", NTIE },
201 { "ntrans", NTRANS },
202 { "nwell", NWELL },
203 { "pdif", PDIF },
204 { "poly", POLY },
205 { "poly2", POLY2 },
206 { "ptie", PTIE },
207 { "ptrans", PTRANS },
208 { "pwell", PWELL },
209 { "rds_abox", RDS_LAYER_ABOX },
210 { "rds_activ", RDS_LAYER_ACTIV },
211 { "rds_alu1", RDS_LAYER_ALU1 },
212 { "rds_alu2", RDS_LAYER_ALU2 },
213 { "rds_alu3", RDS_LAYER_ALU3 },
214 { "rds_alu4", RDS_LAYER_ALU4 },
215 { "rds_alu5", RDS_LAYER_ALU5 },
216 { "rds_alu6", RDS_LAYER_ALU6 },
217 { "rds_alu7", RDS_LAYER_ALU7 },
218 { "rds_alu8", RDS_LAYER_ALU8 },
219 { "rds_alu9", RDS_LAYER_ALU9 },
220 { "rds_cont", RDS_LAYER_CONT },
221 { "rds_cont2", RDS_LAYER_CONT2 },
222 { "rds_cpas", RDS_LAYER_CPAS },
223 { "rds_gate", RDS_LAYER_GATE },
224 { "rds_ndif", RDS_LAYER_NDIF },
225 { "rds_nimp", RDS_LAYER_NIMP },
226 { "rds_ntie", RDS_LAYER_NTIE },
227 { "rds_nwell", RDS_LAYER_NWELL },
228 { "rds_pdif", RDS_LAYER_PDIF },
229 { "rds_pimp", RDS_LAYER_PIMP },
230 { "rds_poly", RDS_LAYER_POLY },
231 { "rds_poly2", RDS_LAYER_POLY2 },
232 { "rds_ptie", RDS_LAYER_PTIE },
233 { "rds_pwell", RDS_LAYER_PWELL },
234 { "rds_ref", RDS_LAYER_REF },
235 { "rds_talu1", RDS_LAYER_TALU1 },
236 { "rds_talu2", RDS_LAYER_TALU2 },
237 { "rds_talu3", RDS_LAYER_TALU3 },
238 { "rds_talu4", RDS_LAYER_TALU4 },
239 { "rds_talu5", RDS_LAYER_TALU5 },
240 { "rds_talu6", RDS_LAYER_TALU6 },
241 { "rds_talu7", RDS_LAYER_TALU7 },
242 { "rds_talu8", RDS_LAYER_TALU8 },
243 { "rds_tcont", RDS_LAYER_TCONT },
244 { "rds_tpoly", RDS_LAYER_TPOLY },
245 { "rds_tpoly2", RDS_LAYER_TPOLY2 },
246 { "rds_tvia1", RDS_LAYER_TVIA1 },
247 { "rds_tvia2", RDS_LAYER_TVIA2 },
248 { "rds_tvia3", RDS_LAYER_TVIA3 },
249 { "rds_tvia4", RDS_LAYER_TVIA4 },
250 { "rds_tvia5", RDS_LAYER_TVIA5 },
251 { "rds_tvia6", RDS_LAYER_TVIA6 },
252 { "rds_tvia7", RDS_LAYER_TVIA7 },
253 { "rds_tvia8", RDS_LAYER_TVIA8 },
254 { "rds_user0", RDS_LAYER_USER0 },
255 { "rds_user1", RDS_LAYER_USER1 },
256 { "rds_user2", RDS_LAYER_USER2 },
257 { "rds_user3", RDS_LAYER_USER3 },
258 { "rds_user4", RDS_LAYER_USER4 },
259 { "rds_user5", RDS_LAYER_USER5 },
260 { "rds_user6", RDS_LAYER_USER6 },
261 { "rds_user7", RDS_LAYER_USER7 },
262 { "rds_user8", RDS_LAYER_USER8 },
263 { "rds_user9", RDS_LAYER_USER9 },
264 { "rds_valu1", RDS_LAYER_VALU1 },
265 { "rds_valu2", RDS_LAYER_VALU2 },
266 { "rds_valu3", RDS_LAYER_VALU3 },
267 { "rds_valu4", RDS_LAYER_VALU4 },
268 { "rds_valu5", RDS_LAYER_VALU5 },
269 { "rds_valu6", RDS_LAYER_VALU6 },
270 { "rds_valu7", RDS_LAYER_VALU7 },
271 { "rds_valu8", RDS_LAYER_VALU8 },
272 { "rds_via1", RDS_LAYER_VIA1 },
273 { "rds_via2", RDS_LAYER_VIA2 },
274 { "rds_via3", RDS_LAYER_VIA3 },
275 { "rds_via4", RDS_LAYER_VIA4 },
276 { "rds_via5", RDS_LAYER_VIA5 },
277 { "rds_via6", RDS_LAYER_VIA6 },
278 { "rds_via7", RDS_LAYER_VIA7 },
279 { "rds_via8", RDS_LAYER_VIA8 },
280 { "rds_vpoly", RDS_LAYER_VPOLY },
281 { "ref_con", MBK_REF_CON },
282 { "ref_ref", MBK_REF_REF },
283 { "rot_m", ROT_M },
284 { "rot_p", ROT_P },
285 { "south", GRAAL_SOUTH },
286 { "sy_rm", SY_RM },
287 { "sy_rp", SY_RP },
288 { "sym_x", SYM_X },
289 { "sym_y", SYM_Y },
290 { "symxy", SYMXY },
291 { "talu1", TALU1 },
292 { "talu2", TALU2 },
293 { "talu3", TALU3 },
294 { "talu4", TALU4 },
295 { "talu5", TALU5 },
296 { "talu6", TALU6 },
297 { "talu7", TALU7 },
298 { "talu8", TALU8 },
299 { "tpoly", TPOLY },
300 { "tpoly2", TPOLY2 },
301 { "west", GRAAL_WEST }
302 };
303
304 /*------------------------------------------------------------\
305 | |
306 | File variables |
307 | |
308 \------------------------------------------------------------*/
309
310 static FILE *GsbFile;
311 static char GsbBuffer[ GSB_MAX_BUFFER ];
312 static long GsbCurrentLine;
313
314 /*------------------------------------------------------------\
315 | |
316 | Functions |
317 | |
318 \------------------------------------------------------------*/
319 /*------------------------------------------------------------\
320 | |
321 | Gsb File Get String |
322 | |
323 \------------------------------------------------------------*/
324
GsbFileGetString(String,Size)325 char *GsbFileGetString( String, Size )
326
327 char *String;
328 int Size;
329 {
330 register char *RegisterString;
331 register int Register = 0;
332
333 rdsbegin();
334
335 RegisterString = String;
336
337 while (--Size > 0 && (Register = getc( GsbFile )) != EOF )
338 {
339 if ((*RegisterString++ = Register) == '\\')
340 {
341 if ((Register = getc( GsbFile )) == '\n')
342 {
343 *(RegisterString - 1) = ' ';
344 }
345 else
346 {
347 ungetc( Register, GsbFile );
348 }
349 }
350 else
351 {
352 if ( Register == '\n') break;
353 }
354 }
355
356 *RegisterString = '\0';
357
358 rdsend();
359 return ( ( Register == EOF ) &&
360 ( RegisterString == String ) ) ? (char *)NULL : String;
361 }
362
363 /*------------------------------------------------------------\
364 | |
365 | Gsb File Get Line |
366 | |
367 \------------------------------------------------------------*/
368
GsbGetLine(Buffer)369 void GsbGetLine( Buffer )
370
371 char *Buffer;
372 {
373 char *Check;
374 char *String;
375 char OneComment;
376
377 rdsbegin();
378
379 do
380 {
381 OneComment = 0;
382
383 Check = GsbFileGetString( Buffer, GSB_MAX_BUFFER );
384
385 if ( Check != (char *)NULL )
386 {
387 GsbCurrentLine++;
388 }
389 else
390 {
391 GsbError( UNEXPECTED_EOF, (char *)NULL, GsbCurrentLine );
392 }
393
394 if ( (String = strchr( Buffer, GSB_COMMENT_CHAR )) )
395 {
396 if ( String == Buffer )
397 {
398 OneComment = 1;
399 }
400 else
401 {
402 *(String - 1) = '\0';
403 }
404 }
405
406 while (*Buffer != '\0' && strchr( GSB_SEPARATORS_STRING, *Buffer))
407 {
408 Buffer = Buffer + 1;;
409 }
410
411 if (*Buffer == '\0') OneComment = 1;
412
413 }
414 while ( OneComment == 1);
415
416 rdsend();
417 }
418
419 /*------------------------------------------------------------\
420 | |
421 | Gsb Check Keyword |
422 | |
423 \------------------------------------------------------------*/
424
GsbCheckKeyword(Word)425 char GsbCheckKeyword( Word )
426
427 char *Word;
428 {
429 if ( ( Word == DefineKeyword ) ||
430 ( Word == TableKeyword ) )
431 {
432 return 1;
433 }
434 else
435 {
436 return 0;
437 }
438 }
439
440 /*------------------------------------------------------------\
441 | |
442 | Gsb Get First word |
443 | |
444 \------------------------------------------------------------*/
445
GsbGetFirstWord(Buffer,IsKeyword,Hash)446 char *GsbGetFirstWord( Buffer, IsKeyword, Hash )
447
448 char *Buffer;
449 char IsKeyword;
450 char Hash;
451 {
452 char *String;
453 char *Text;
454 int Index;
455
456 rdsbegin();
457
458 if ( (String = (char *)strtok( Buffer, GSB_SEPARATORS_STRING )) )
459 {
460 if ( Hash )
461 {
462 String = namealloc( String );
463 }
464 else
465 {
466 Text = malloc( strlen( String ) + 1 );
467 strcpy( Text, String );
468 String = Text;
469
470 for ( Index = 0; Text[ Index ]; Index++ )
471 {
472 if ( Text[ Index ] == '_' ) Text[ Index ] = ' ';
473 }
474 }
475
476 if ( ( IsKeyword ) && GsbCheckKeyword( String ) )
477 {
478 GsbError( UNEXPECTED_LINE, String, GsbCurrentLine );
479 }
480 }
481
482 rdsend();
483 return( String );
484 }
485
486 /*------------------------------------------------------------\
487 | |
488 | Gsb Get Next word |
489 | |
490 \------------------------------------------------------------*/
491
GsbGetNextWord(IsKeyword,Hash)492 char *GsbGetNextWord( IsKeyword, Hash )
493
494 char IsKeyword;
495 char Hash;
496 {
497 char *String;
498 char *Text;
499 int Index;
500
501 rdsbegin();
502
503 if ( (String = (char *)strtok( (char *)NULL, GSB_SEPARATORS_STRING )) )
504 {
505 if ( Hash )
506 {
507 String = namealloc( String );
508 }
509 else
510 {
511 Text = malloc( strlen( String ) + 1 );
512 strcpy( Text, String );
513 String = Text;
514
515 for ( Index = 0; Text[ Index ]; Index++ )
516 {
517 if ( Text[ Index ] == '_' ) Text[ Index ] = ' ';
518 }
519 }
520
521 if ( ( IsKeyword ) && GsbCheckKeyword( String ) )
522 {
523 GsbError( UNEXPECTED_LINE, String, GsbCurrentLine );
524 }
525 }
526
527 rdsend();
528 return( String );
529 }
530
531 /*------------------------------------------------------------\
532 | |
533 | Gsb Keyword Compare |
534 | |
535 \------------------------------------------------------------*/
536
GsbKeywordCompare(FirstKey,SecondKey)537 int GsbKeywordCompare( FirstKey, SecondKey )
538
539 keyword *FirstKey;
540 keyword *SecondKey;
541 {
542 return strcmp( FirstKey->NAME, SecondKey->NAME );
543 }
544
545 /*------------------------------------------------------------\
546 | |
547 | Gsb Get String Value |
548 | |
549 \------------------------------------------------------------*/
550
GsbGetStringValue(String)551 long GsbGetStringValue( String )
552
553 char *String;
554 {
555 long Value;
556 keyword *Keyword;
557 keyword Entry;
558
559 rdsbegin();
560
561 if ( sscanf( String, "%ld", &Value) )
562 {
563 rdsend();
564 return ( Value );
565 }
566
567 Entry.NAME = String;
568
569 Keyword = (keyword *)bsearch( (char *)(&Entry),
570 (char *)KeywordDefine,
571 GSB_MAX_KEYWORD, sizeof( keyword ),
572 GsbKeywordCompare );
573
574 if ( Keyword == (keyword *)NULL )
575 {
576 GsbError( UNEXPECTED_LINE, String, GsbCurrentLine );
577 }
578
579 rdsend();
580 return( Keyword->VALUE );
581 }
582
583 /*------------------------------------------------------------\
584 | |
585 | Gsb Get String Float |
586 | |
587 \------------------------------------------------------------*/
588
GsbGetStringFloat(String)589 float GsbGetStringFloat( String )
590
591 char *String;
592 {
593 float Value;
594
595 rdsbegin();
596
597 if ( ! sscanf( String, "%g", &Value) )
598 {
599 GsbError( ILLEGAL_FLOAT, String, GsbCurrentLine );
600 }
601
602 rdsend();
603 return ( Value );
604 }
605
606 /*------------------------------------------------------------\
607 | |
608 | Gsb Get Number |
609 | |
610 \------------------------------------------------------------*/
611
GsbGetNumber(String)612 long GsbGetNumber( String )
613
614 char *String;
615 {
616 long Value;
617
618 rdsbegin();
619
620 if ( ! sscanf( String, "%22ld", &Value ))
621 {
622 GsbError( UNEXPECTED_LINE, "number", GsbCurrentLine );
623 }
624
625 rdsend();
626 return Value;
627 }
628
629 /*------------------------------------------------------------\
630 | |
631 | Gsb Read Segment Name |
632 | |
633 \------------------------------------------------------------*/
634
GsbReadSegmentName()635 void GsbReadSegmentName()
636
637 {
638 char Layer;
639 char Field;
640 char LayerCount;
641 char EndTable;
642 char *FirstWord;
643
644 rdsbegin();
645
646 EndTable = 0;
647 LayerCount = 0;
648
649 while ( ( EndTable != 1 ) &&
650 ( LayerCount <= MBK_MAX_LAYER ) )
651 {
652 GsbGetLine( GsbBuffer );
653
654 FirstWord = GsbGetFirstWord( GsbBuffer, 1, 1 );
655
656 if ( FirstWord == EndTableKeyword )
657 {
658 EndTable = 1;
659 }
660 else
661 if ( LayerCount < MBK_MAX_LAYER )
662 {
663 Layer = GsbGetStringValue( FirstWord );
664
665 for ( Field = 0; Field < 3; Field++ )
666 {
667 FirstWord = GsbGetNextWord( 0, 0 );
668
669 if ( FirstWord == EndRecordKeyword )
670 {
671 GsbError( MISSING_VALUE, (char *)NULL, GsbCurrentLine );
672 }
673 else
674 if ( GET_SEGMENT_LAYER( Layer, 0 ) != RDS_SEGMENT_EMPTY )
675
676 {
677 GRAAL_SEGMENT_NAME_TABLE [ (int)Layer ][ (int)Field ] = FirstWord;
678 }
679 }
680
681 FirstWord = GsbGetNextWord( 0, 1 );
682
683 if ( FirstWord != EndRecordKeyword )
684 {
685 GsbError( TOO_MANY_WORDS, FirstWord, GsbCurrentLine );
686 }
687 }
688
689 LayerCount = LayerCount + 1;
690 }
691
692 if ( EndTable == 0 )
693 {
694 GsbError( LINE_EXPECTED, EndTableKeyword, GsbCurrentLine);
695 }
696
697 rdsend();
698 }
699
700 /*------------------------------------------------------------\
701 | |
702 | Gsb Read Transistor Name |
703 | |
704 \------------------------------------------------------------*/
705
GsbReadTransistorName()706 void GsbReadTransistorName()
707
708 {
709 char Layer;
710 char Field;
711 char LayerCount;
712 char EndTable;
713 char *FirstWord;
714
715 rdsbegin();
716
717 EndTable = 0;
718 LayerCount = 0;
719
720 while ( ( EndTable != 1 ) &&
721 ( LayerCount <= MBK_MAX_LAYER ) )
722 {
723 GsbGetLine( GsbBuffer );
724
725 FirstWord = GsbGetFirstWord( GsbBuffer, 1, 1 );
726
727 if ( FirstWord == EndTableKeyword )
728 {
729 EndTable = 1;
730 }
731 else
732 if ( LayerCount < MBK_MAX_LAYER )
733 {
734 Layer = GsbGetStringValue( FirstWord );
735
736 for ( Field = 0; Field < 3; Field++ )
737 {
738 FirstWord = GsbGetNextWord( 0, 0 );
739
740 if ( FirstWord == EndRecordKeyword )
741 {
742 GsbError( MISSING_VALUE, (char *)NULL, GsbCurrentLine );
743 }
744 else
745 if ( GET_SEGMENT_LAYER( Layer, 0 ) != RDS_SEGMENT_EMPTY )
746 {
747 GRAAL_TRANSISTOR_NAME_TABLE [ (int)Layer ][ (int)Field ] = FirstWord;
748 }
749 }
750
751 FirstWord = GsbGetNextWord( 0, 1 );
752
753 if ( FirstWord != EndRecordKeyword )
754 {
755 GsbError( TOO_MANY_WORDS, FirstWord, GsbCurrentLine );
756 }
757 }
758
759 LayerCount = LayerCount + 1;
760 }
761
762 if ( EndTable == 0 )
763 {
764 GsbError( LINE_EXPECTED, EndTableKeyword, GsbCurrentLine);
765 }
766
767 rdsend();
768 }
769
770 /*------------------------------------------------------------\
771 | |
772 | Gsb Read Connector Name |
773 | |
774 \------------------------------------------------------------*/
775
GsbReadConnectorName()776 void GsbReadConnectorName()
777
778 {
779 char Layer;
780 char Field;
781 char LayerCount;
782 char EndTable;
783 char *FirstWord;
784
785 rdsbegin();
786
787 EndTable = 0;
788 LayerCount = 0;
789
790 while ( ( EndTable != 1 ) &&
791 ( LayerCount <= MBK_MAX_LAYER ) )
792 {
793 GsbGetLine( GsbBuffer );
794
795 FirstWord = GsbGetFirstWord( GsbBuffer, 1, 1 );
796
797 if ( FirstWord == EndTableKeyword )
798 {
799 EndTable = 1;
800 }
801 else
802 if ( LayerCount < MBK_MAX_LAYER )
803 {
804 Layer = GsbGetStringValue( FirstWord );
805
806 for ( Field = 0; Field < 3; Field++ )
807 {
808 FirstWord = GsbGetNextWord( 0, 0 );
809
810 if ( FirstWord == EndRecordKeyword )
811 {
812 GsbError( MISSING_VALUE, (char *)NULL, GsbCurrentLine );
813 }
814 else
815 if ( GET_SEGMENT_LAYER( Layer, 0 ) != RDS_SEGMENT_EMPTY )
816 {
817 GRAAL_CONNECTOR_NAME_TABLE [ (int)Layer ][ (int)Field ] = FirstWord;
818 }
819 }
820
821 FirstWord = GsbGetNextWord( 0, 1 );
822
823 if ( FirstWord != EndRecordKeyword )
824 {
825 GsbError( TOO_MANY_WORDS, FirstWord, GsbCurrentLine );
826 }
827 }
828
829 LayerCount = LayerCount + 1;
830 }
831
832 if ( EndTable == 0 )
833 {
834 GsbError( LINE_EXPECTED, EndTableKeyword, GsbCurrentLine);
835 }
836
837 rdsend();
838 }
839
840 /*------------------------------------------------------------\
841 | |
842 | Gsb Read Segment Value |
843 | |
844 \------------------------------------------------------------*/
845
GsbReadSegmentValue()846 void GsbReadSegmentValue()
847
848 {
849 char Layer;
850 char Field;
851 char LayerCount;
852 char EndTable;
853 char *FirstWord;
854
855 rdsbegin();
856
857 EndTable = 0;
858 LayerCount = 0;
859
860 while ( ( EndTable != 1 ) &&
861 ( LayerCount <= MBK_MAX_LAYER ) )
862 {
863 GsbGetLine( GsbBuffer );
864
865 FirstWord = GsbGetFirstWord( GsbBuffer, 1, 1 );
866
867 if ( FirstWord == EndTableKeyword )
868 {
869 EndTable = 1;
870 }
871 else
872 if ( LayerCount < MBK_MAX_LAYER )
873 {
874 Layer = GsbGetStringValue( FirstWord );
875
876 for ( Field = 0; Field < 2; Field++ )
877 {
878 FirstWord = GsbGetNextWord( 0, 0 );
879
880 if ( FirstWord == EndRecordKeyword )
881 {
882 GsbError( MISSING_VALUE, (char *)NULL, GsbCurrentLine );
883 }
884 else
885 if ( GET_SEGMENT_LAYER( Layer, 0 ) != RDS_SEGMENT_EMPTY )
886 {
887 GRAAL_SEGMENT_VALUE_TABLE [ (int)Layer ][ (int)Field ] = GsbGetStringFloat( FirstWord );
888 }
889 }
890
891 FirstWord = GsbGetNextWord( 0, 1 );
892
893 if ( FirstWord != EndRecordKeyword )
894 {
895 GsbError( TOO_MANY_WORDS, FirstWord, GsbCurrentLine );
896 }
897 }
898
899 LayerCount = LayerCount + 1;
900 }
901
902 if ( EndTable == 0 )
903 {
904 GsbError( LINE_EXPECTED, EndTableKeyword, GsbCurrentLine);
905 }
906
907 rdsend();
908 }
909
910 /*------------------------------------------------------------\
911 | |
912 | Gsb Read BigVia Value |
913 | |
914 \------------------------------------------------------------*/
915
GsbReadBigViaValue()916 void GsbReadBigViaValue()
917
918 {
919 char Layer;
920 char LayerCount;
921 char EndTable;
922 char *FirstWord;
923
924 rdsbegin();
925
926 EndTable = 0;
927 LayerCount = 0;
928
929 while ( ( EndTable != 1 ) &&
930 ( LayerCount <= MBK_MAX_VIA ) )
931 {
932 GsbGetLine( GsbBuffer );
933
934 FirstWord = GsbGetFirstWord( GsbBuffer, 1, 1 );
935
936 if ( FirstWord == EndTableKeyword )
937 {
938 EndTable = 1;
939 }
940 else
941 if ( LayerCount < MBK_MAX_VIA )
942 {
943 Layer = GsbGetStringValue( FirstWord );
944
945 FirstWord = GsbGetNextWord( 0, 0 );
946
947 if ( FirstWord == EndRecordKeyword )
948 {
949 GsbError( MISSING_VALUE, (char *)NULL, GsbCurrentLine );
950 }
951 else
952 if ( ( GET_BIGVIA_HOLE_LAYER( Layer, 0 ) != RDS_BIGVIA_HOLE_EMPTY ) ||
953 ( GET_TURNVIA_LAYER( Layer, 0 ) != RDS_TURNVIA_EMPTY ) )
954 {
955 GRAAL_BIGVIA_VALUE_TABLE [ (int)Layer ][ 0 ] = GsbGetStringFloat( FirstWord );
956 }
957
958 FirstWord = GsbGetNextWord( 0, 1 );
959
960 if ( FirstWord != EndRecordKeyword )
961 {
962 GsbError( TOO_MANY_WORDS, FirstWord, GsbCurrentLine );
963 }
964 }
965
966 LayerCount = LayerCount + 1;
967 }
968
969 if ( EndTable == 0 )
970 {
971 GsbError( LINE_EXPECTED, EndTableKeyword, GsbCurrentLine);
972 }
973
974 rdsend();
975 }
976
977 /*------------------------------------------------------------\
978 | |
979 | Gsb Read Reference Name |
980 | |
981 \------------------------------------------------------------*/
982
GsbReadReferenceName()983 void GsbReadReferenceName()
984
985 {
986 char Layer;
987 char Field;
988 char LayerCount;
989 char EndTable;
990 char *FirstWord;
991
992 rdsbegin();
993
994 EndTable = 0;
995 LayerCount = 0;
996
997 while ( ( EndTable != 1 ) &&
998 ( LayerCount <= MBK_MAX_REFERENCE ) )
999 {
1000 GsbGetLine( GsbBuffer );
1001
1002 FirstWord = GsbGetFirstWord( GsbBuffer, 1, 1 );
1003
1004 if ( FirstWord == EndTableKeyword )
1005 {
1006 EndTable = 1;
1007 }
1008 else
1009 if ( LayerCount < MBK_MAX_REFERENCE )
1010 {
1011 Layer = GsbGetStringValue( FirstWord );
1012
1013 for ( Field = 0; Field < 3; Field++ )
1014 {
1015 FirstWord = GsbGetNextWord( 0, 0 );
1016
1017 if ( FirstWord == EndRecordKeyword )
1018 {
1019 GsbError( MISSING_VALUE, (char *)NULL, GsbCurrentLine );
1020 }
1021 else
1022 if ( GET_REFERENCE_LAYER( Layer, 0 ) != RDS_REFERENCE_EMPTY )
1023 {
1024 GRAAL_REFERENCE_NAME_TABLE [ (int)Layer ][ (int)Field ] = FirstWord;
1025 }
1026 }
1027
1028 FirstWord = GsbGetNextWord( 0, 1 );
1029
1030 if ( FirstWord != EndRecordKeyword )
1031 {
1032 GsbError( TOO_MANY_WORDS, FirstWord, GsbCurrentLine );
1033 }
1034 }
1035
1036 LayerCount = LayerCount + 1;
1037 }
1038
1039 if ( EndTable == 0 )
1040 {
1041 GsbError( LINE_EXPECTED, EndTableKeyword, GsbCurrentLine);
1042 }
1043
1044 rdsend();
1045 }
1046
1047 /*------------------------------------------------------------\
1048 | |
1049 | Gsb Read Orient Name |
1050 | |
1051 \------------------------------------------------------------*/
1052
GsbReadOrientName()1053 void GsbReadOrientName()
1054
1055 {
1056 char Layer;
1057 char Field;
1058 char LayerCount;
1059 char EndTable;
1060 char *FirstWord;
1061
1062 rdsbegin();
1063
1064 EndTable = 0;
1065 LayerCount = 0;
1066
1067 while ( ( EndTable != 1 ) &&
1068 ( LayerCount <= MBK_MAX_ORIENT ) )
1069 {
1070 GsbGetLine( GsbBuffer );
1071
1072 FirstWord = GsbGetFirstWord( GsbBuffer, 1, 1 );
1073
1074 if ( FirstWord == EndTableKeyword )
1075 {
1076 EndTable = 1;
1077 }
1078 else
1079 if ( LayerCount < MBK_MAX_ORIENT )
1080 {
1081 Layer = GsbGetStringValue( FirstWord );
1082
1083 for ( Field = 0; Field < 3; Field++ )
1084 {
1085 FirstWord = GsbGetNextWord( 0, 0 );
1086
1087 if ( FirstWord == EndRecordKeyword )
1088 {
1089 GsbError( MISSING_VALUE, (char *)NULL, GsbCurrentLine );
1090 }
1091 else
1092 {
1093 GRAAL_ORIENT_NAME_TABLE [ (int)Layer ][ (int)Field ] = FirstWord;
1094 }
1095 }
1096
1097 FirstWord = GsbGetNextWord( 0, 1 );
1098
1099 if ( FirstWord != EndRecordKeyword )
1100 {
1101 GsbError( TOO_MANY_WORDS, FirstWord, GsbCurrentLine );
1102 }
1103 }
1104
1105 LayerCount = LayerCount + 1;
1106 }
1107
1108 if ( EndTable == 0 )
1109 {
1110 GsbError( LINE_EXPECTED, EndTableKeyword, GsbCurrentLine);
1111 }
1112
1113 rdsend();
1114 }
1115
1116 /*------------------------------------------------------------\
1117 | |
1118 | Gsb Read Symmetry Name |
1119 | |
1120 \------------------------------------------------------------*/
1121
GsbReadSymmetryName()1122 void GsbReadSymmetryName()
1123
1124 {
1125 char Layer;
1126 char Field;
1127 char LayerCount;
1128 char EndTable;
1129 char *FirstWord;
1130
1131 rdsbegin();
1132
1133 EndTable = 0;
1134 LayerCount = 0;
1135
1136 while ( ( EndTable != 1 ) &&
1137 ( LayerCount <= MBK_MAX_SYMMETRY ) )
1138 {
1139 GsbGetLine( GsbBuffer );
1140
1141 FirstWord = GsbGetFirstWord( GsbBuffer, 1, 1 );
1142
1143 if ( FirstWord == EndTableKeyword )
1144 {
1145 EndTable = 1;
1146 }
1147 else
1148 if ( LayerCount < MBK_MAX_SYMMETRY )
1149 {
1150 Layer = GsbGetStringValue( FirstWord );
1151
1152 for ( Field = 0; Field < 3; Field++ )
1153 {
1154 FirstWord = GsbGetNextWord( 0, 0 );
1155
1156 if ( FirstWord == EndRecordKeyword )
1157 {
1158 GsbError( MISSING_VALUE, (char *)NULL, GsbCurrentLine );
1159 }
1160 else
1161 {
1162 GRAAL_SYMMETRY_NAME_TABLE [ (int)Layer ][ (int)Field ] = FirstWord;
1163 }
1164 }
1165
1166 FirstWord = GsbGetNextWord( 0, 1 );
1167
1168 if ( FirstWord != EndRecordKeyword )
1169 {
1170 GsbError( TOO_MANY_WORDS, FirstWord, GsbCurrentLine );
1171 }
1172 }
1173
1174 LayerCount = LayerCount + 1;
1175 }
1176
1177 if ( EndTable == 0 )
1178 {
1179 GsbError( LINE_EXPECTED, EndTableKeyword, GsbCurrentLine);
1180 }
1181
1182 rdsend();
1183 }
1184
1185 /*------------------------------------------------------------\
1186 | |
1187 | Gsb Read Big Via Name |
1188 | |
1189 \------------------------------------------------------------*/
1190
GsbReadBigViaName()1191 void GsbReadBigViaName()
1192
1193 {
1194 char Layer;
1195 char LayerCount;
1196 char EndTable;
1197 char Field;
1198 char *FirstWord;
1199
1200 rdsbegin();
1201
1202 EndTable = 0;
1203 LayerCount = 0;
1204
1205 while ( ( EndTable != 1 ) &&
1206 ( LayerCount <= MBK_MAX_VIA ) )
1207 {
1208 GsbGetLine( GsbBuffer );
1209
1210 FirstWord = GsbGetFirstWord( GsbBuffer, 1, 1 );
1211
1212 if ( FirstWord == EndTableKeyword )
1213 {
1214 EndTable = 1;
1215 }
1216 else
1217 if ( LayerCount < MBK_MAX_VIA )
1218 {
1219 Layer = GsbGetStringValue( FirstWord );
1220
1221 for ( Field = 0; Field < 3; Field++ )
1222 {
1223 FirstWord = GsbGetNextWord( 1, 0 );
1224
1225 if ( FirstWord == EndRecordKeyword )
1226 {
1227 GsbError( MISSING_VALUE, (char *)NULL, GsbCurrentLine );
1228 }
1229 else
1230 if ( ( GET_BIGVIA_HOLE_LAYER( Layer, 0 ) != RDS_BIGVIA_HOLE_EMPTY ) ||
1231 ( GET_TURNVIA_LAYER( Layer, 0 ) != RDS_TURNVIA_EMPTY ) )
1232 {
1233 GRAAL_BIGVIA_NAME_TABLE [ (int)Layer ][ (int)Field ] = FirstWord;
1234 }
1235 }
1236
1237 FirstWord = GsbGetNextWord( 0, 1 );
1238
1239 if ( FirstWord != EndRecordKeyword )
1240 {
1241 GsbError( TOO_MANY_WORDS, FirstWord, GsbCurrentLine );
1242 }
1243 }
1244
1245 LayerCount = LayerCount + 1;
1246 }
1247
1248 if ( EndTable == 0 )
1249 {
1250 GsbError( LINE_EXPECTED, EndTableKeyword, GsbCurrentLine);
1251 }
1252
1253 rdsend();
1254 }
1255
1256 /*------------------------------------------------------------\
1257 | |
1258 | Gsb Read Via Name |
1259 | |
1260 \------------------------------------------------------------*/
1261
GsbReadViaName()1262 void GsbReadViaName()
1263
1264 {
1265 char Layer;
1266 char LayerCount;
1267 char EndTable;
1268 char Field;
1269 char *FirstWord;
1270
1271 rdsbegin();
1272
1273 EndTable = 0;
1274 LayerCount = 0;
1275
1276 while ( ( EndTable != 1 ) &&
1277 ( LayerCount <= MBK_MAX_VIA ) )
1278 {
1279 GsbGetLine( GsbBuffer );
1280
1281 FirstWord = GsbGetFirstWord( GsbBuffer, 1, 1 );
1282
1283 if ( FirstWord == EndTableKeyword )
1284 {
1285 EndTable = 1;
1286 }
1287 else
1288 if ( LayerCount < MBK_MAX_VIA )
1289 {
1290 Layer = GsbGetStringValue( FirstWord );
1291
1292 for ( Field = 0; Field < 3; Field++ )
1293 {
1294 FirstWord = GsbGetNextWord( 1, 0 );
1295
1296 if ( FirstWord == EndRecordKeyword )
1297 {
1298 GsbError( MISSING_VALUE, (char *)NULL, GsbCurrentLine );
1299 }
1300 else
1301 if ( GET_VIA_LAYER( Layer, 0 ) != RDS_VIA_EMPTY )
1302 {
1303 GRAAL_VIA_NAME_TABLE [ (int)Layer ][ (int)Field ] = FirstWord;
1304 }
1305 }
1306
1307 FirstWord = GsbGetNextWord( 0, 1 );
1308
1309 if ( FirstWord != EndRecordKeyword )
1310 {
1311 GsbError( TOO_MANY_WORDS, FirstWord, GsbCurrentLine );
1312 }
1313 }
1314
1315 LayerCount = LayerCount + 1;
1316 }
1317
1318 if ( EndTable == 0 )
1319 {
1320 GsbError( LINE_EXPECTED, EndTableKeyword, GsbCurrentLine);
1321 }
1322
1323 rdsend();
1324 }
1325
1326 /*------------------------------------------------------------\
1327 | |
1328 | Gsb Read Rds Layer Name |
1329 | |
1330 \------------------------------------------------------------*/
1331
GsbReadRdsLayerName()1332 void GsbReadRdsLayerName()
1333
1334 {
1335 char Layer;
1336 char Pattern;
1337 char LayerCount;
1338 char EndTable;
1339 char Field;
1340 char *FirstWord;
1341
1342 rdsbegin();
1343
1344 EndTable = 0;
1345 LayerCount = 0;
1346
1347 while ( ( EndTable != 1 ) &&
1348 ( LayerCount <= RDS_ALL_LAYER ) )
1349 {
1350 GsbGetLine( GsbBuffer );
1351
1352 FirstWord = GsbGetFirstWord( GsbBuffer, 1, 1 );
1353
1354 if ( FirstWord == EndTableKeyword )
1355 {
1356 EndTable = 1;
1357 }
1358 else
1359 if ( LayerCount < RDS_ALL_LAYER )
1360 {
1361 Layer = GsbGetStringValue( FirstWord );
1362
1363 for ( Field = 0; Field < 3; Field++ )
1364 {
1365 FirstWord = GsbGetNextWord( 1, 0 );
1366
1367 if ( FirstWord == EndRecordKeyword )
1368 {
1369 GsbError( MISSING_VALUE, (char *)NULL, GsbCurrentLine );
1370 }
1371 else
1372 if ( RDS_DYNAMIC_LAYER[ (int)Layer ] != RDS_LAYER_UNUSED )
1373 {
1374 GRAAL_RDS_LAYER_NAME_TABLE [ (int)Layer ][ (int)Field ] = FirstWord;
1375 }
1376 }
1377
1378 FirstWord = GsbGetNextWord( 0, 1 );
1379
1380 if ( FirstWord != EndRecordKeyword )
1381 {
1382 Pattern = GsbGetStringValue( FirstWord );
1383
1384 if ( RDS_DYNAMIC_LAYER[ (int)Layer ] != RDS_LAYER_UNUSED )
1385 {
1386 GRAAL_RDS_LAYER_PATTERN_TABLE[ (int)Layer ] = (int)Pattern;
1387 }
1388
1389 FirstWord = GsbGetNextWord( 0, 1 );
1390 if ( FirstWord != EndRecordKeyword )
1391 {
1392 GsbError( TOO_MANY_WORDS, FirstWord, GsbCurrentLine );
1393 }
1394 }
1395 }
1396
1397 LayerCount = LayerCount + 1;
1398 }
1399
1400 rdsend();
1401 }
1402
1403 /*------------------------------------------------------------\
1404 | |
1405 | Gsb Read Parameters |
1406 | |
1407 \------------------------------------------------------------*/
1408
GsbReadParam()1409 void GsbReadParam()
1410
1411 {
1412 char *FirstWord;
1413 char *SecondWord;
1414 long Continue;
1415
1416 rdsbegin();
1417
1418 Continue = 0;
1419
1420 while ( Continue != GSB_ALL_DEFINED_MASK )
1421 {
1422 GsbGetLine( GsbBuffer );
1423
1424 FirstWord = GsbGetFirstWord( GsbBuffer, 0, 1);
1425
1426 if ( FirstWord == DefineKeyword )
1427 {
1428 FirstWord = GsbGetNextWord( 1, 1 );
1429
1430 if (! FirstWord )
1431 {
1432 GsbError( MISSING_NAME, DefineKeyword, GsbCurrentLine );
1433 }
1434
1435 SecondWord = GsbGetNextWord( 1, 0 );
1436
1437 if (! SecondWord )
1438 {
1439 GsbError( MISSING_VALUE, SecondWord, GsbCurrentLine );
1440 }
1441
1442 if ( FirstWord == PeekBoundKeyword )
1443 {
1444 GRAAL_PEEK_BOUND = GsbGetStringValue( SecondWord ) * GRAAL_RDS_LAMBDA;
1445
1446 Continue |= GSB_PEEK_BOUND_MASK;
1447 }
1448 else
1449 if ( FirstWord == LowerGridStepKeyword )
1450 {
1451 GRAAL_LOWER_GRID_STEP = GsbGetStringFloat( SecondWord );
1452
1453 Continue |= GSB_LOWER_GRID_STEP_MASK;
1454 }
1455 else
1456 if ( FirstWord == LowerFigureStepKeyword )
1457 {
1458 GRAAL_LOWER_FIGURE_STEP = GsbGetStringFloat( SecondWord ) / GRAAL_SCALE;
1459
1460 Continue |= GSB_LOWER_FIGURE_STEP_MASK;
1461 }
1462 else
1463 if ( FirstWord == LowerInstanceStepKeyword )
1464 {
1465 GRAAL_LOWER_INSTANCE_STEP = GsbGetStringFloat( SecondWord ) / GRAAL_SCALE;
1466
1467 Continue |= GSB_LOWER_INSTANCE_STEP_MASK;
1468 }
1469 else
1470 if ( FirstWord == LowerSegmentStepKeyword )
1471 {
1472 GRAAL_LOWER_SEGMENT_STEP = GsbGetStringFloat( SecondWord ) / GRAAL_SCALE;
1473
1474 Continue |= GSB_LOWER_SEGMENT_STEP_MASK;
1475 }
1476 else
1477 if ( FirstWord == LowerConnectorStepKeyword )
1478 {
1479 GRAAL_LOWER_CONNECTOR_STEP = GsbGetStringFloat( SecondWord ) / GRAAL_SCALE;
1480
1481 Continue |= GSB_LOWER_CONNECTOR_STEP_MASK;
1482 }
1483 else
1484 if ( FirstWord == LowerReferenceStepKeyword )
1485 {
1486 GRAAL_LOWER_REFERENCE_STEP = GsbGetStringFloat( SecondWord ) / GRAAL_SCALE;
1487
1488 Continue |= GSB_LOWER_REFERENCE_STEP_MASK;
1489 }
1490 else
1491 if ( FirstWord == CursorColorNameKeyword )
1492 {
1493 GRAAL_CURSOR_COLOR_NAME = namealloc( SecondWord );
1494
1495 Continue |= GSB_CURSOR_COLOR_NAME_MASK;
1496 }
1497 else
1498 if ( FirstWord == CursorSizeKeyword )
1499 {
1500 GRAAL_CURSOR_SIZE = GsbGetStringValue( SecondWord );
1501
1502 Continue |= GSB_CURSOR_SIZE_MASK;
1503 }
1504 else
1505 {
1506 GsbError( UNKNOWN_DEFINE, FirstWord, GsbCurrentLine );
1507 }
1508 }
1509 else
1510 if ( FirstWord == TableKeyword )
1511 {
1512 if (!( FirstWord = GsbGetNextWord(1, 1)))
1513 {
1514 GsbError( MISSING_NAME, TableKeyword );
1515 }
1516
1517 if ( FirstWord == ConnectorNameKeyword )
1518 {
1519 GsbReadConnectorName();
1520
1521 Continue |= GSB_CONNECTOR_NAME_MASK;
1522 }
1523 else
1524 if ( FirstWord == SegmentNameKeyword )
1525 {
1526 GsbReadSegmentName();
1527
1528 Continue |= GSB_SEGMENT_NAME_MASK;
1529 }
1530 else
1531 if ( FirstWord == SegmentValueKeyword )
1532 {
1533 GsbReadSegmentValue();
1534
1535 Continue |= GSB_SEGMENT_VALUE_MASK;
1536 }
1537 else
1538 if ( FirstWord == BigViaValueKeyword )
1539 {
1540 GsbReadBigViaValue();
1541
1542 Continue |= GSB_BIGVIA_VALUE_MASK;
1543 }
1544 else
1545 if ( FirstWord == TransistorNameKeyword )
1546 {
1547 GsbReadTransistorName();
1548
1549 Continue |= GSB_TRANSISTOR_NAME_MASK;
1550 }
1551 else
1552 if ( FirstWord == ViaNameKeyword )
1553 {
1554 GsbReadViaName();
1555
1556 Continue |= GSB_VIA_NAME_MASK;
1557 }
1558 else
1559 if ( FirstWord == BigViaNameKeyword )
1560 {
1561 GsbReadBigViaName();
1562
1563 Continue |= GSB_BIGVIA_NAME_MASK;
1564 }
1565 else
1566 if ( FirstWord == ReferenceNameKeyword )
1567 {
1568 GsbReadReferenceName();
1569
1570 Continue |= GSB_REFERENCE_NAME_MASK;
1571 }
1572 else
1573 if ( FirstWord == OrientNameKeyword )
1574 {
1575 GsbReadOrientName();
1576
1577 Continue |= GSB_ORIENT_NAME_MASK;
1578 }
1579 else
1580 if ( FirstWord == SymmetryNameKeyword )
1581 {
1582 GsbReadSymmetryName();
1583
1584 Continue |= GSB_SYMMETRY_NAME_MASK;
1585 }
1586 else
1587 if ( FirstWord == RdsLayerNameKeyword )
1588 {
1589 GsbReadRdsLayerName();
1590
1591 Continue |= GSB_RDS_LAYER_NAME_MASK;
1592 }
1593 else
1594 {
1595 GsbError( UNKNOWN_TABLE, FirstWord, GsbCurrentLine );
1596 }
1597 }
1598 else
1599 {
1600 GsbError( SYNTAX_ERROR, FirstWord, GsbCurrentLine );
1601 }
1602 }
1603
1604 rdsend();
1605 }
1606
1607 /*------------------------------------------------------------\
1608 | |
1609 | Gsb Load Parameters |
1610 | |
1611 \------------------------------------------------------------*/
1612
GraalLoadParameters()1613 void GraalLoadParameters()
1614
1615 {
1616 char Layer;
1617 char Buffer[ 512 ];
1618 char *String;
1619
1620 rdsbegin();
1621
1622 GRAAL_TECHNO_NAME = mbkgetenv( "GRAAL_TECHNO_NAME" );
1623
1624 if ( GRAAL_TECHNO_NAME == (char *)NULL )
1625 {
1626 String = mbkgetenv( "ALLIANCE_TOP" );
1627 if ( String == (char *)NULL ) String = ALLIANCE_TOP;
1628
1629 sprintf( Buffer, "%s/%s", String, GRAAL_DEFAULT_TECHNO_NAME );
1630 GRAAL_TECHNO_NAME = mbkstrdup( Buffer );
1631 }
1632
1633 GRAAL_RDS_LAMBDA = RDS_LAMBDA / GRAAL_SCALE;
1634 GRAAL_SCALE_X = (float)SCALE_X / (float)GRAAL_SCALE;
1635
1636 if ( ! KeywordDefined )
1637 {
1638 DefineKeyword = namealloc( DEFINE_KEYWORD );
1639 TableKeyword = namealloc( TABLE_KEYWORD );
1640 EndTableKeyword = namealloc( END_TABLE_KEYWORD );
1641 EndRecordKeyword = namealloc( END_RECORD_KEYWORD );
1642 PeekBoundKeyword = namealloc( PEEK_BOUND_KEYWORD );
1643 LowerGridStepKeyword = namealloc( LOWER_GRID_STEP_KEYWORD );
1644 LowerFigureStepKeyword = namealloc( LOWER_FIGURE_STEP_KEYWORD );
1645 LowerInstanceStepKeyword = namealloc( LOWER_INSTANCE_STEP_KEYWORD );
1646 LowerReferenceStepKeyword = namealloc( LOWER_REFERENCE_STEP_KEYWORD );
1647 LowerSegmentStepKeyword = namealloc( LOWER_SEGMENT_STEP_KEYWORD );
1648 LowerConnectorStepKeyword = namealloc( LOWER_CONNECTOR_STEP_KEYWORD );
1649 CursorColorNameKeyword = namealloc( CURSOR_COLOR_NAME_KEYWORD );
1650 CursorSizeKeyword = namealloc( CURSOR_SIZE_KEYWORD );
1651 SegmentNameKeyword = namealloc( SEGMENT_NAME_KEYWORD );
1652 TransistorNameKeyword = namealloc( TRANSISTOR_NAME_KEYWORD );
1653 ConnectorNameKeyword = namealloc( CONNECTOR_NAME_KEYWORD );
1654 SegmentValueKeyword = namealloc( SEGMENT_VALUE_KEYWORD );
1655 ViaNameKeyword = namealloc( VIA_NAME_KEYWORD );
1656 BigViaNameKeyword = namealloc( BIGVIA_NAME_KEYWORD );
1657 BigViaValueKeyword = namealloc( BIGVIA_VALUE_KEYWORD );
1658 ReferenceNameKeyword = namealloc( REFERENCE_NAME_KEYWORD );
1659 OrientNameKeyword = namealloc( ORIENT_NAME_KEYWORD );
1660 SymmetryNameKeyword = namealloc( SYMMETRY_NAME_KEYWORD );
1661 RdsLayerNameKeyword = namealloc( RDS_LAYER_NAME_KEYWORD );
1662
1663 KeywordDefined = 1;
1664 }
1665
1666 for ( Layer = 0; Layer < MBK_MAX_LAYER; Layer++ )
1667 {
1668 GRAAL_CONNECTOR_NAME_TABLE[ (int)Layer ][0] = (char *)NULL;;
1669 GRAAL_CONNECTOR_NAME_TABLE[ (int)Layer ][1] = (char *)NULL;
1670 GRAAL_CONNECTOR_NAME_TABLE[ (int)Layer ][2] = (char *)NULL;
1671
1672 GRAAL_SEGMENT_NAME_TABLE[ (int)Layer ][0] = (char *)NULL;;
1673 GRAAL_SEGMENT_NAME_TABLE[ (int)Layer ][1] = (char *)NULL;
1674 GRAAL_SEGMENT_NAME_TABLE[ (int)Layer ][2] = (char *)NULL;
1675
1676 GRAAL_TRANSISTOR_NAME_TABLE[ (int)Layer ][0] = (char *)NULL;;
1677 GRAAL_TRANSISTOR_NAME_TABLE[ (int)Layer ][1] = (char *)NULL;
1678 GRAAL_TRANSISTOR_NAME_TABLE[ (int)Layer ][2] = (char *)NULL;
1679
1680 GRAAL_SEGMENT_VALUE_TABLE[ (int)Layer ][0] = 0;
1681 GRAAL_SEGMENT_VALUE_TABLE[ (int)Layer ][1] = 0;
1682 }
1683
1684 for ( Layer = 0; Layer < MBK_MAX_VIA; Layer++ )
1685 {
1686 GRAAL_VIA_NAME_TABLE[ (int)Layer ][0] = (char *)NULL;;
1687 GRAAL_VIA_NAME_TABLE[ (int)Layer ][1] = (char *)NULL;
1688 GRAAL_VIA_NAME_TABLE[ (int)Layer ][2] = (char *)NULL;
1689
1690 GRAAL_BIGVIA_NAME_TABLE[ (int)Layer ][0] = (char *)NULL;;
1691 GRAAL_BIGVIA_NAME_TABLE[ (int)Layer ][1] = (char *)NULL;
1692 GRAAL_BIGVIA_NAME_TABLE[ (int)Layer ][2] = (char *)NULL;
1693
1694 GRAAL_BIGVIA_VALUE_TABLE[ (int)Layer ][0] = 0;
1695 }
1696
1697 for ( Layer = 0; Layer < MBK_MAX_REFERENCE; Layer++ )
1698 {
1699 GRAAL_REFERENCE_NAME_TABLE[ (int)Layer ][0] = (char *)NULL;;
1700 GRAAL_REFERENCE_NAME_TABLE[ (int)Layer ][1] = (char *)NULL;
1701 GRAAL_REFERENCE_NAME_TABLE[ (int)Layer ][2] = (char *)NULL;
1702 }
1703
1704 for ( Layer = 0; Layer < RDS_ALL_LAYER; Layer++ )
1705 {
1706 GRAAL_RDS_LAYER_NAME_TABLE[ (int)Layer ][0] = (char *)NULL;;
1707 GRAAL_RDS_LAYER_NAME_TABLE[ (int)Layer ][1] = (char *)NULL;
1708 GRAAL_RDS_LAYER_NAME_TABLE[ (int)Layer ][2] = (char *)NULL;
1709 GRAAL_RDS_LAYER_PATTERN_TABLE[ (int)Layer ] = -1;
1710 }
1711
1712 for ( Layer = 0; Layer < MBK_MAX_SYMMETRY; Layer++ )
1713 {
1714 GRAAL_SYMMETRY_NAME_TABLE[ (int)Layer ][0] = (char *)NULL;;
1715 GRAAL_SYMMETRY_NAME_TABLE[ (int)Layer ][1] = (char *)NULL;
1716 GRAAL_SYMMETRY_NAME_TABLE[ (int)Layer ][2] = (char *)NULL;
1717 }
1718
1719 for ( Layer = 0; Layer < MBK_MAX_ORIENT; Layer++ )
1720 {
1721 GRAAL_ORIENT_NAME_TABLE[ (int)Layer ][0] = (char *)NULL;;
1722 GRAAL_ORIENT_NAME_TABLE[ (int)Layer ][1] = (char *)NULL;
1723 GRAAL_ORIENT_NAME_TABLE[ (int)Layer ][2] = (char *)NULL;
1724 }
1725
1726 GRAAL_PEEK_BOUND = 0;
1727 GRAAL_LOWER_GRID_STEP = 0.0;
1728 GRAAL_LOWER_FIGURE_STEP = 0.0;
1729 GRAAL_LOWER_INSTANCE_STEP = 0.0;
1730 GRAAL_LOWER_CONNECTOR_STEP = 0.0;
1731 GRAAL_LOWER_SEGMENT_STEP = 0.0;
1732 GRAAL_LOWER_REFERENCE_STEP = 0.0;
1733 GRAAL_CURSOR_COLOR_NAME = (char *)NULL;
1734 GRAAL_CURSOR_SIZE = 5;
1735
1736 if ( !( GsbFile = fopen( GRAAL_TECHNO_NAME, "r")))
1737
1738 GsbError( OPEN_FILE, NULL, 0);
1739
1740 GsbReadParam();
1741
1742 fclose( GsbFile );
1743
1744 rdsend();
1745 }
1746
1747 /*------------------------------------------------------------\
1748 | |
1749 | Gsb View Parameters |
1750 | |
1751 \------------------------------------------------------------*/
1752
1753 # ifdef DEBUG
1754
GraalViewParameters()1755 void GraalViewParameters()
1756
1757 {
1758 char Layer;
1759
1760 rdsbegin();
1761
1762 fprintf( stdout, "\nPEEK_BOUND DEFINE %d\n",
1763 GRAAL_PEEK_BOUND / GRAAL_RDS_LAMBDA );
1764
1765 fprintf( stdout, "\nSEGMENT TABLE\n" );
1766
1767 for ( Layer = 0; Layer < MBK_MAX_LAYER; Layer++ )
1768 {
1769 fprintf( stdout, "\nLayer:%d %s %s %s %e %e",
1770 Layer,
1771 GRAAL_SEGMENT_NAME_TABLE[ Layer ][0],
1772 GRAAL_SEGMENT_NAME_TABLE[ Layer ][1],
1773 GRAAL_SEGMENT_NAME_TABLE[ Layer ][2],
1774 GRAAL_SEGMENT_VALUE_TABLE[ Layer ][0],
1775 GRAAL_SEGMENT_VALUE_TABLE[ Layer ][1] );
1776 }
1777
1778 fprintf( stdout, "\n\nEND\n" );
1779
1780 fprintf( stdout, "\nTRANSISTOR TABLE\n" );
1781
1782 for ( Layer = 0; Layer < MBK_MAX_LAYER; Layer++ )
1783 {
1784 fprintf( stdout, "\nLayer:%d %s %s %s",
1785 Layer,
1786 GRAAL_TRANSISTOR_NAME_TABLE[ Layer ][0],
1787 GRAAL_TRANSISTOR_NAME_TABLE[ Layer ][1],
1788 GRAAL_TRANSISTOR_NAME_TABLE[ Layer ][2] );
1789 }
1790
1791 fprintf( stdout, "\n\nEND\n" );
1792
1793 fprintf( stdout, "\nCONNECTOR TABLE\n" );
1794
1795 for ( Layer = 0; Layer < MBK_MAX_LAYER; Layer++ )
1796 {
1797 fprintf( stdout, "\nLayer:%d %s %s %s",
1798 Layer,
1799 GRAAL_CONNECTOR_NAME_TABLE[ Layer ][0],
1800 GRAAL_CONNECTOR_NAME_TABLE[ Layer ][1],
1801 GRAAL_CONNECTOR_NAME_TABLE[ Layer ][2] );
1802 }
1803
1804 fprintf( stdout, "\n\nEND\n" );
1805
1806 fprintf( stdout, "\nVIA TABLE\n" );
1807
1808 for ( Layer = 0; Layer < MBK_MAX_VIA; Layer++ )
1809 {
1810 fprintf( stdout, "\nVia:%d %s %s %s",
1811 Layer,
1812 GRAAL_VIA_NAME_TABLE[ Layer ][0],
1813 GRAAL_VIA_NAME_TABLE[ Layer ][1],
1814 GRAAL_VIA_NAME_TABLE[ Layer ][2] );
1815 }
1816
1817 fprintf( stdout, "\n\nEND\n" );
1818
1819 fprintf( stdout, "\nBIGVIA TABLE\n" );
1820
1821 for ( Layer = 0; Layer < MBK_MAX_VIA; Layer++ )
1822 {
1823 fprintf( stdout, "\nVia:%d %s %s %s",
1824 Layer,
1825 GRAAL_BIGVIA_NAME_TABLE[ Layer ][0],
1826 GRAAL_BIGVIA_NAME_TABLE[ Layer ][1],
1827 GRAAL_BIGVIA_NAME_TABLE[ Layer ][2] );
1828 }
1829
1830 fprintf( stdout, "\n\nEND\n" );
1831
1832 fprintf( stdout, "\nREFERENCE TABLE\n" );
1833
1834 for ( Layer = 0; Layer < MBK_MAX_REFERENCE; Layer++ )
1835 {
1836 fprintf( stdout, "\nReference:%d %s %s %s",
1837 Layer,
1838 GRAAL_REFERENCE_NAME_TABLE[ Layer ][0],
1839 GRAAL_REFERENCE_NAME_TABLE[ Layer ][1],
1840 GRAAL_REFERENCE_NAME_TABLE[ Layer ][2] );
1841 }
1842
1843 fprintf( stdout, "\nORIENT TABLE\n" );
1844
1845 for ( Layer = 0; Layer < MBK_MAX_ORIENT; Layer++ )
1846 {
1847 fprintf( stdout, "\nSymmetry:%d %s %s %s",
1848 Layer,
1849 GRAAL_ORIENT_NAME_TABLE[ Layer ][0],
1850 GRAAL_ORIENT_NAME_TABLE[ Layer ][1],
1851 GRAAL_ORIENT_NAME_TABLE[ Layer ][2] );
1852 }
1853
1854 fprintf( stdout, "\nSYMMETRY TABLE\n" );
1855
1856 for ( Layer = 0; Layer < MBK_MAX_SYMMETRY; Layer++ )
1857 {
1858 fprintf( stdout, "\nReference:%d %s %s %s",
1859 Layer,
1860 GRAAL_SYMMETRY_NAME_TABLE[ Layer ][0],
1861 GRAAL_SYMMETRY_NAME_TABLE[ Layer ][1],
1862 GRAAL_SYMMETRY_NAME_TABLE[ Layer ][2] );
1863 }
1864
1865 fprintf( stdout, "\n\nEND\n" );
1866
1867 fprintf( stdout, "\nRDS_LAYER TABLE\n" );
1868
1869 for ( Layer = 0; Layer < RDS_ALL_LAYER; Layer++ )
1870 {
1871 fprintf( stdout, "\nLayer:%d %s %s %s",
1872 Layer,
1873 GRAAL_RDS_LAYER_NAME_TABLE[ Layer ][0],
1874 GRAAL_RDS_LAYER_NAME_TABLE[ Layer ][1],
1875 GRAAL_RDS_LAYER_NAME_TABLE[ Layer ][2] );
1876 }
1877
1878 fprintf( stdout, "\n\nEND\n" );
1879
1880 rdsend();
1881 }
1882
1883 # endif
1884