1 /*------------------------------------------------------------\
2 | |
3 | Tool : RDS |
4 | |
5 | File : rprparse.c |
6 | |
7 | Authors : Jacomme Ludovic |
8 | Picault Stephane *4p* |
9 | |
10 | Date : 27.06.95 |
11 | 15.07.98 *4p* |
12 | |
13 \------------------------------------------------------------*/
14 /*------------------------------------------------------------\
15 | |
16 | Include Files |
17 | |
18 \------------------------------------------------------------*/
19
20 # include <math.h>
21 # include <ctype.h>
22 # include <stdlib.h>
23 # include <string.h>
24 # include <libgen.h>
25
26 # include <mut.h>
27 # include <mph.h>
28 # include "rds.h"
29 # include "rtl.h"
30 # include "rpr.h"
31 # include "rwi.h"
32 # include "rut.h"
33
34 # include "rprerror.h"
35 # include "rprparse.h"
36
37 /*------------------------------------------------------------\
38 | |
39 | Constants |
40 | |
41 \------------------------------------------------------------*/
42
43 #define NO_FLAGS (0x00000000)
44 #define CAN_REACH_EOF (0x00000001)
45
46 /*------------------------------------------------------------\
47 | |
48 | Types |
49 | |
50 \------------------------------------------------------------*/
51 /*------------------------------------------------------------\
52 | |
53 | Variables |
54 | |
55 \------------------------------------------------------------*/
56
57 long RDS_PHYSICAL_GRID;
58 long RDS_LAMBDA;
59 long RDS_LAMBDA2;
60 long RDS_UNIT;
61 long RDS_UNIT2;
62
63 /*------------------------------------------------------------\
64 | |
65 | Table variables |
66 | |
67 \------------------------------------------------------------*/
68
69 unsigned char RDS_S2R_POST_TREAT_TABLE [ RDS_ALL_LAYER ][ RDS_S2R_POST_TREAT_FIELD ];
70 long RDS_S2R_OVERSIZE_TABLE [ RDS_ALL_LAYER ][ RDS_S2R_OVERSIZE_FIELD ];
71 long RDS_S2R_RING_WIDTH_TABLE [ RDS_ALL_LAYER ][ RDS_S2R_RING_WIDTH_FIELD ];
72 long RDS_S2R_LAYER_WIDTH_TABLE [ RDS_ALL_LAYER ][ RDS_S2R_LAYER_WIDTH_FIELD ];
73
74 long RDS_SEGMENT_TABLE [ MBK_MAX_LAYER ][ RDS_SEGMENT_FIELD ];
75 long RDS_VIA_TABLE [ MBK_MAX_VIA ][ RDS_VIA_FIELD ];
76 long RDS_CONNECTOR_TABLE [ MBK_MAX_LAYER ][ RDS_CONNECTOR_FIELD ];
77 long RDS_REFERENCE_TABLE [ MBK_MAX_REFERENCE ][ RDS_REFERENCE_FIELD ];
78
79 long RDS_BIGVIA_HOLE_TABLE[ MBK_MAX_VIA ][ RDS_BIGVIA_HOLE_FIELD ];
80 long RDS_BIGVIA_METAL_TABLE[ MBK_MAX_VIA ][ RDS_BIGVIA_METAL_FIELD ];
81 long RDS_TURNVIA_TABLE[ MBK_MAX_VIA ][ RDS_TURNVIA_FIELD ];
82
83 char *RDS_CIF_LAYER_TABLE [ RDS_ALL_LAYER ][ RDS_CIF_LAYER_FIELD ];
84 unsigned char RDS_GDS_LAYER_TABLE [ RDS_ALL_LAYER ][ RDS_GDS_LAYER_FIELD ];
85
86 unsigned char RDS_LYNX_BULK_IMPLICIT_TABLE /*4p*/
87 [ RDS_ALL_LAYER ][ RDS_LYNX_BULK_IMPLICIT_FIELD ]; /*4p*/
88
89 unsigned char RDS_LYNX_GRAPH_TABLE [ RDS_ALL_LAYER ][ RDS_LYNX_GRAPH_FIELD ];
90 float RDS_LYNX_CAPA_TABLE [ RDS_ALL_LAYER ][ RDS_LYNX_CAPA_FIELD ];
91 float RDS_LYNX_RESISTOR_TABLE [ RDS_ALL_LAYER ][ RDS_LYNX_RESISTOR_FIELD ];
92 unsigned char RDS_LYNX_TRANSISTOR_TABLE [ MBK_MAX_LAYER ][ RDS_LYNX_TRANSISTOR_FIELD ];
93 unsigned char RDS_LYNX_DIFFUSION_TABLE [ RDS_ALL_LAYER ][ RDS_LYNX_DIFFUSION_FIELD ];
94
95 extern long MBK_X_GRID, MBK_Y_GRID, MBK_Y_SLICE, MBK_WIDTH_VSS, MBK_WIDTH_VDD,
96 MBK_TRACK_WIDTH_ALU1, MBK_TRACK_WIDTH_ALU2,
97 MBK_TRACK_WIDTH_ALU3, MBK_TRACK_WIDTH_ALU4,
98 MBK_TRACK_WIDTH_ALU5, MBK_TRACK_WIDTH_ALU6,
99 MBK_TRACK_WIDTH_ALU7, MBK_TRACK_WIDTH_ALU8,
100 MBK_TRACK_SPACING_ALU1, MBK_TRACK_SPACING_ALU2,
101 MBK_TRACK_SPACING_ALU3, MBK_TRACK_SPACING_ALU4,
102 MBK_TRACK_SPACING_ALU5, MBK_TRACK_SPACING_ALU6,
103 MBK_TRACK_SPACING_ALU7, MBK_TRACK_SPACING_ALU8;
104 long *RDS_WIRESETTING_TABLE [ MBK_MAX_WIRESETTING ] =
105 {
106 &MBK_TRACK_SPACING_ALU1, &MBK_TRACK_SPACING_ALU2,
107 &MBK_TRACK_SPACING_ALU3, &MBK_TRACK_SPACING_ALU4,
108 &MBK_TRACK_SPACING_ALU5, &MBK_TRACK_SPACING_ALU6,
109 &MBK_TRACK_SPACING_ALU7, &MBK_TRACK_SPACING_ALU8,
110 &MBK_TRACK_WIDTH_ALU1, &MBK_TRACK_WIDTH_ALU2,
111 &MBK_TRACK_WIDTH_ALU3, &MBK_TRACK_WIDTH_ALU4,
112 &MBK_TRACK_WIDTH_ALU5, &MBK_TRACK_WIDTH_ALU6,
113 &MBK_TRACK_WIDTH_ALU7, &MBK_TRACK_WIDTH_ALU8,
114 &MBK_WIDTH_VDD,
115 &MBK_WIDTH_VSS,
116 &MBK_X_GRID, &MBK_Y_GRID, &MBK_Y_SLICE
117 };
118 /*------------------------------------------------------------\
119 | |
120 | Keywords variables |
121 | |
122 \------------------------------------------------------------*/
123
124 static char KeywordDefined = 0;
125
126 static char *DefineKeyword;
127 static char *TableKeyword;
128 static char *EndTableKeyword;
129 static char *EndRecordKeyword;
130 static char *LambdaKeyword;
131 static char *PhysicalGridKeyword;
132 static char *SegmentKeyword;
133 static char *ViaKeyword;
134 static char *ConnectorKeyword;
135 static char *ReferenceKeyword;
136 static char *CifLayerKeyword;
137 static char *GdsLayerKeyword;
138 static char *S2RPostTreatKeyword;
139 static char *S2ROversizeKeyword;
140 static char *S2RRingWidthKeyword;
141 static char *S2RLayerWidthKeyword;
142 static char *LynxGraphKeyword;
143 static char *LynxCapaKeyword;
144 static char *LynxResistorKeyword;
145 static char *LynxTransistorKeyword;
146 static char *LynxDiffusionKeyword;
147 static char *LynxBulkImplicitKeyword; /*4p*/
148 static char *BigViaHoleKeyword;
149 static char *BigViaMetalKeyword;
150 static char *TurnViaKeyword;
151
152 static char *DrcRulesKeword;
153 static char *WireSettingKeyword;
154
155 static keyword KeywordDefine [ RPR_MAX_KEYWORD ] =
156
157 {
158 { "alcw", RDS_TRANS_ALCW },
159 { "all", RDS_USE_ALL },
160 { "alu1", ALU1 },
161 { "alu2", ALU2 },
162 { "alu3", ALU3 },
163 { "alu4", ALU4 },
164 { "alu5", ALU5 },
165 { "alu6", ALU6 },
166 { "alu7", ALU7 },
167 { "alu8", ALU8 },
168 { "alu9", ALU9 },
169 { "arcw", RDS_TRANS_ARCW },
170 { "c_x_n", C_X_N },
171 { "c_x_p", C_X_P },
172 { "calu1", CALU1 },
173 { "calu2", CALU2 },
174 { "calu3", CALU3 },
175 { "calu4", CALU4 },
176 { "calu5", CALU5 },
177 { "calu6", CALU6 },
178 { "calu7", CALU7 },
179 { "calu8", CALU8 },
180 { "calu9", CALU9 },
181 { "cont_body_n", CONT_BODY_N },
182 { "cont_body_p", CONT_BODY_P },
183 { "cont_dif_n", CONT_DIF_N },
184 { "cont_dif_p", CONT_DIF_P },
185 { "cont_poly", CONT_POLY },
186 { "cont_poly2", CONT_POLY2 },
187 { "cont_turn1", CONT_TURN1 },
188 { "cont_turn2", CONT_TURN2 },
189 { "cont_turn3", CONT_TURN3 },
190 { "cont_turn4", CONT_TURN4 },
191 { "cont_turn5", CONT_TURN5 },
192 { "cont_turn6", CONT_TURN6 },
193 { "cont_turn7", CONT_TURN7 },
194 { "cont_turn8", CONT_TURN8 },
195 { "cont_turn9", CONT_TURN9 },
196 { "cont_via", CONT_VIA },
197 { "cont_via2", CONT_VIA2 },
198 { "cont_via3", CONT_VIA3 },
199 { "cont_via4", CONT_VIA4 },
200 { "cont_via5", CONT_VIA5 },
201 { "cont_via6", CONT_VIA6 },
202 { "cont_via7", CONT_VIA7 },
203 { "cont_via8", CONT_VIA8 },
204 { "drc", RDS_USE_DRC },
205 { "explicit", RDS_EXPLICIT }, /*4p*/
206 { "ext", RDS_USE_EXTRACT },
207 { "implicit", RDS_IMPLICIT }, /*4p*/
208 { "lcw", RDS_TRANS_LCW },
209 { "ndif", NDIF },
210 { "notreat", S2R_NOTREAT },
211 { "ntie", NTIE },
212 { "ntrans", NTRANS },
213 { "null", S2R_NOTREAT },
214 { "nwell", NWELL },
215 { "pdif", PDIF },
216 { "poly", POLY },
217 { "poly2", POLY2 },
218 { "ptie", PTIE },
219 { "ptrans", PTRANS },
220 { "pwell", PWELL },
221 { "rcw", RDS_TRANS_RCW },
222 { "rds_abox", RDS_LAYER_ABOX },
223 { "rds_activ", RDS_LAYER_ACTIV },
224 { "rds_alu1", RDS_LAYER_ALU1 },
225 { "rds_alu2", RDS_LAYER_ALU2 },
226 { "rds_alu3", RDS_LAYER_ALU3 },
227 { "rds_alu4", RDS_LAYER_ALU4 },
228 { "rds_alu5", RDS_LAYER_ALU5 },
229 { "rds_alu6", RDS_LAYER_ALU6 },
230 { "rds_alu7", RDS_LAYER_ALU7 },
231 { "rds_alu8", RDS_LAYER_ALU8 },
232 { "rds_alu9", RDS_LAYER_ALU9 },
233 { "rds_cont", RDS_LAYER_CONT },
234 { "rds_cont2", RDS_LAYER_CONT2 },
235 { "rds_cpas", RDS_LAYER_CPAS },
236 { "rds_gate", RDS_LAYER_GATE },
237 { "rds_ndif", RDS_LAYER_NDIF },
238 { "rds_nimp", RDS_LAYER_NIMP },
239 { "rds_ntie", RDS_LAYER_NTIE },
240 { "rds_nwell", RDS_LAYER_NWELL },
241 { "rds_pdif", RDS_LAYER_PDIF },
242 { "rds_pimp", RDS_LAYER_PIMP },
243 { "rds_poly", RDS_LAYER_POLY },
244 { "rds_poly2", RDS_LAYER_POLY2 },
245 { "rds_ptie", RDS_LAYER_PTIE },
246 { "rds_pwell", RDS_LAYER_PWELL },
247 { "rds_ref", RDS_LAYER_REF },
248 { "rds_talu1", RDS_LAYER_TALU1 },
249 { "rds_talu2", RDS_LAYER_TALU2 },
250 { "rds_talu3", RDS_LAYER_TALU3 },
251 { "rds_talu4", RDS_LAYER_TALU4 },
252 { "rds_talu5", RDS_LAYER_TALU5 },
253 { "rds_talu6", RDS_LAYER_TALU6 },
254 { "rds_talu7", RDS_LAYER_TALU7 },
255 { "rds_talu8", RDS_LAYER_TALU8 },
256 { "rds_tcont", RDS_LAYER_TCONT },
257 { "rds_tpoly", RDS_LAYER_TPOLY },
258 { "rds_tpoly2", RDS_LAYER_TPOLY2 },
259 { "rds_tvia1", RDS_LAYER_TVIA1 },
260 { "rds_tvia2", RDS_LAYER_TVIA2 },
261 { "rds_tvia3", RDS_LAYER_TVIA3 },
262 { "rds_tvia4", RDS_LAYER_TVIA4 },
263 { "rds_tvia5", RDS_LAYER_TVIA5 },
264 { "rds_tvia6", RDS_LAYER_TVIA6 },
265 { "rds_tvia7", RDS_LAYER_TVIA7 },
266 { "rds_tvia8", RDS_LAYER_TVIA8 },
267 { "rds_user0", RDS_LAYER_USER0 },
268 { "rds_user1", RDS_LAYER_USER1 },
269 { "rds_user2", RDS_LAYER_USER2 },
270 { "rds_user3", RDS_LAYER_USER3 },
271 { "rds_user4", RDS_LAYER_USER4 },
272 { "rds_user5", RDS_LAYER_USER5 },
273 { "rds_user6", RDS_LAYER_USER6 },
274 { "rds_user7", RDS_LAYER_USER7 },
275 { "rds_user8", RDS_LAYER_USER8 },
276 { "rds_user9", RDS_LAYER_USER9 },
277 { "rds_valu1", RDS_LAYER_VALU1 },
278 { "rds_valu2", RDS_LAYER_VALU2 },
279 { "rds_valu3", RDS_LAYER_VALU3 },
280 { "rds_valu4", RDS_LAYER_VALU4 },
281 { "rds_valu5", RDS_LAYER_VALU5 },
282 { "rds_valu6", RDS_LAYER_VALU6 },
283 { "rds_valu7", RDS_LAYER_VALU7 },
284 { "rds_valu8", RDS_LAYER_VALU8 },
285 { "rds_via1", RDS_LAYER_VIA1 },
286 { "rds_via2", RDS_LAYER_VIA2 },
287 { "rds_via3", RDS_LAYER_VIA3 },
288 { "rds_via4", RDS_LAYER_VIA4 },
289 { "rds_via5", RDS_LAYER_VIA5 },
290 { "rds_via6", RDS_LAYER_VIA6 },
291 { "rds_via7", RDS_LAYER_VIA7 },
292 { "rds_via8", RDS_LAYER_VIA8 },
293 { "rds_vpoly", RDS_LAYER_VPOLY },
294 { "ref_con", MBK_REF_CON },
295 { "ref_ref", MBK_REF_REF },
296 { "talu1", TALU1 },
297 { "talu2", TALU2 },
298 { "talu3", TALU3 },
299 { "talu4", TALU4 },
300 { "talu5", TALU5 },
301 { "talu6", TALU6 },
302 { "talu7", TALU7 },
303 { "talu8", TALU8 },
304 { "tpoly", TPOLY },
305 { "tpoly2", TPOLY2 },
306 { "treat", S2R_TREAT },
307 { "vw", RDS_TRANS_VW },
308 { "vws", RDS_TRANS_VWS }
309 };
310
311 /*------------------------------------------------------------\
312 | |
313 | Name |
314 | |
315 \------------------------------------------------------------*/
316
317 char RDS_TRANS_NAME [ RDS_MAX_TRANS ][ 4 ] =
318
319 {
320 "VW ",
321 "LCW",
322 "RCW"
323 };
324
325 char RDS_USE_NAME [ RDS_MAX_USE ][ 4 ] =
326
327 {
328 "ALL",
329 "EXT",
330 "DRC"
331 };
332
333 char MBK_VIA_NAME [ MBK_MAX_VIA ][ 12 ] =
334
335 {
336 "CONT_POLY ",
337 "CONT_DIF_N ",
338 "CONT_DIF_P ",
339 "CONT_BODY_N",
340 "CONT_BODY_P",
341 "CONT_VIA ",
342 "CONT_VIA2 ",
343 "CONT_VIA3 ",
344 "CONT_VIA4 ",
345 "CONT_VIA5 ",
346 "CONT_VIA6 ",
347 "CONT_VIA7 ",
348 "CONT_VIA8 ",
349 "CONT_POLY2 ",
350 "C_X_N ",
351 "C_X_P ",
352 "CONT_TURN1 ",
353 "CONT_TURN2 ",
354 "CONT_TURN3 ",
355 "CONT_TURN4 ",
356 "CONT_TURN5 ",
357 "CONT_TURN6 ",
358 "CONT_TURN7 ",
359 "CONT_TURN8 ",
360 "CONT_TURN9 "
361 };
362
363 char MBK_LAYER_NAME [ MBK_MAX_LAYER ][ 12 ] =
364
365 {
366 "NWELL ",
367 "PWELL ",
368 "NTIE ",
369 "PTIE ",
370 "NDIF ",
371 "PDIF ",
372 "NTRANS ",
373 "PTRANS ",
374 "NTRANS_FAST",
375 "PTRANS_FAST",
376 "NTRANS_HVIO",
377 "PTRANS_HVIO",
378 "POLY ",
379 "POLY2 ",
380 "ALU1 ",
381 "ALU2 ",
382 "ALU3 ",
383 "ALU4 ",
384 "ALU5 ",
385 "ALU6 ",
386 "ALU7 ",
387 "ALU8 ",
388 "ALU9 ",
389 "TPOLY ",
390 "TPOLY2 ",
391 "TALU1 ",
392 "TALU2 ",
393 "TALU3 ",
394 "TALU4 ",
395 "TALU5 ",
396 "TALU6 ",
397 "TALU7 ",
398 "TALU8 ",
399 "TALU9 ",
400 "CALU1 ",
401 "CALU2 ",
402 "CALU3 ",
403 "CALU4 ",
404 "CALU5 ",
405 "CALU6 ",
406 "CALU7 ",
407 "CALU8 ",
408 "CALU9 "
409 };
410
411 #define MBK_MAX_WIRESETTING_TLEN 23
412 char MBK_WIRESETTING_NAME [ MBK_MAX_WIRESETTING ][ MBK_MAX_WIRESETTING_TLEN ] =
413
414 {
415 "track_spacing_alu1",
416 "track_spacing_alu2",
417 "track_spacing_alu3",
418 "track_spacing_alu4",
419 "track_spacing_alu5",
420 "track_spacing_alu6",
421 "track_spacing_alu7",
422 "track_spacing_alu8",
423 "track_width_alu1",
424 "track_width_alu2",
425 "track_width_alu3",
426 "track_width_alu4",
427 "track_width_alu5",
428 "track_width_alu6",
429 "track_width_alu7",
430 "track_width_alu8",
431 "width_vdd",
432 "width_vss",
433 "x_grid",
434 "y_grid",
435 "y_slice"
436 };
437
438 /*------------------------------------------------------------\
439 | |
440 | File variables |
441 | |
442 \------------------------------------------------------------*/
443
444 static FILE *RprFile;
445 static char RprBuffer[ RPR_MAX_BUFFER ];
446 static long RprCurrentLine = 0;
447
448 /*------------------------------------------------------------\
449 | |
450 | Functions |
451 | |
452 \------------------------------------------------------------*/
453 /*------------------------------------------------------------\
454 | |
455 | Rpr Ascii to float (small numbers) |
456 | |
457 \------------------------------------------------------------*/
458
RprAtof(integer)459 double RprAtof( integer )
460
461 char *integer;
462 {
463 char *decimal;
464 long shift;
465 long i;
466
467 if ((decimal = strchr( integer, '.')) != (char *)0 )
468 {
469 *decimal = '\0';
470
471 decimal++;
472
473 for(i=strlen(decimal),shift=1 ; i; shift*=10, i--);
474
475 if (atol(integer) < 0)
476 {
477 return (double)(atol(integer)*shift - atol(decimal))/(double)(shift);
478 }
479 else
480 {
481 return (double)(atol(integer)*shift + atol(decimal))/(double)(shift);
482 }
483 }
484 else
485 {
486 return (double)(atol(integer));
487 }
488 }
489
490 /*------------------------------------------------------------\
491 | |
492 | Rpr Upper Case |
493 | |
494 \------------------------------------------------------------*/
495
RprUpperCase(Name)496 char *RprUpperCase( Name )
497
498 char *Name;
499 {
500 char *Target;
501 int Index;
502
503 if ( Name == (char *)NULL ) return( (char *)NULL );
504
505 Target = (char *)rdsallocblock( strlen( Name ) + 1 );
506
507 for ( Index = 0; Name[ Index ]; Index++ )
508 {
509 Target[ Index ] = (char)toupper( Name[ Index ] );
510 }
511 Target[ Index ] = '\0';
512
513 return( Target );
514 }
515
516 /*------------------------------------------------------------\
517 | |
518 | Rpr File Get String |
519 | |
520 \------------------------------------------------------------*/
521
RprFileGetString(String,Size)522 char *RprFileGetString( String, Size )
523
524 char *String;
525 int Size;
526 {
527 register char *RegisterString;
528 register int Register;
529
530 RegisterString = String;
531 Register = 0;
532
533 while (--Size > 0 && (Register = getc( RprFile )) != EOF )
534 {
535 if ((*RegisterString++ = Register) == '\\')
536 {
537 if ((Register = getc( RprFile )) == '\n')
538 {
539 RprCurrentLine++;
540
541 *(RegisterString - 1) = ' ';
542 }
543 else
544 {
545 ungetc( Register, RprFile );
546 }
547 }
548 else
549 {
550 if ( Register == '\n') break;
551 }
552 }
553
554 *RegisterString = '\0';
555
556 return ( ( Register == EOF ) &&
557 ( RegisterString == String ) ) ? (char *)NULL : String;
558 }
559
560 /*------------------------------------------------------------\
561 | |
562 | Rpr File Get Line |
563 | |
564 \------------------------------------------------------------*/
565
RprGetLine(Buffer,flags)566 void RprGetLine( Buffer, flags )
567
568 char *Buffer;
569 int flags;
570 {
571 char *RprBuffer = Buffer;
572 char *Check;
573 char *String;
574 char OneComment;
575
576 do
577 {
578 OneComment = 0;
579
580 Check = RprFileGetString( Buffer, RPR_MAX_BUFFER );
581
582 if ( Check != (char *)NULL )
583 {
584 RprCurrentLine++;
585 }
586 else
587 {
588 if (flags & CAN_REACH_EOF) {
589 *RprBuffer = '\0';
590 return;
591 }
592 rprerror( RPR_UNEXPECTED_EOF, (char *)NULL, RprCurrentLine );
593 }
594
595 if ( ( String = strchr( Buffer, RPR_COMMENT_CHAR )) != (char *)0 )
596 {
597 if ( String == Buffer )
598 {
599 OneComment = 1;
600 }
601 else
602 {
603 *(String - 1) = '\0';
604 }
605 }
606
607 while (*Buffer != '\0' && strchr( RPR_SEPARATORS_STRING, *Buffer))
608 {
609 Buffer = Buffer + 1;
610 }
611
612 if (*Buffer == '\0') OneComment = 1;
613
614 }
615 while ( OneComment == 1);
616 }
617
618 /*------------------------------------------------------------\
619 | |
620 | Rpr Check Keyword |
621 | |
622 \------------------------------------------------------------*/
623
RprCheckKeyword(Word)624 char RprCheckKeyword( Word )
625
626 char *Word;
627 {
628 if ( ( Word == DefineKeyword ) ||
629 ( Word == TableKeyword ) )
630 {
631 return 1;
632 }
633 else
634 {
635 return 0;
636 }
637 }
638
639 /*------------------------------------------------------------\
640 | |
641 | Rpr Get First word |
642 | |
643 \------------------------------------------------------------*/
644
RprGetFirstWord(Buffer,IsKeyword)645 char *RprGetFirstWord( Buffer, IsKeyword )
646
647 char *Buffer;
648 char IsKeyword;
649 {
650 char *String;
651
652 if ( ( String = (char *)strtok( Buffer, RPR_SEPARATORS_STRING )) != (char *)0 )
653 {
654 String = namealloc( String );
655
656 if ( ( IsKeyword ) && RprCheckKeyword( String ) )
657 {
658 rprerror( RPR_UNEXPECTED_LINE, String, RprCurrentLine );
659 }
660 }
661 return( String );
662 }
663
664 /*------------------------------------------------------------\
665 | |
666 | Rpr Get Next word |
667 | |
668 \------------------------------------------------------------*/
669
RprGetNextWord(IsKeyword)670 char *RprGetNextWord( IsKeyword )
671
672 char IsKeyword;
673 {
674 char *String;
675
676 if ( ( String = (char *)strtok( (char *)NULL, RPR_SEPARATORS_STRING )) != (char *)0 )
677 {
678 String = namealloc( String );
679
680 if ( ( IsKeyword ) && RprCheckKeyword( String ) )
681 {
682 rprerror( RPR_UNEXPECTED_LINE, String, RprCurrentLine );
683 }
684 }
685
686 return( String );
687 }
688
689 /*------------------------------------------------------------\
690 | |
691 | Rpr Translate Param |
692 | |
693 \------------------------------------------------------------*/
694
RprTranslateParam(Param)695 long RprTranslateParam( Param )
696
697 double Param;
698 {
699 double Multiple;
700
701 Param = Param * RDS_UNIT;
702 Multiple = Param / RDS_PHYSICAL_GRID;
703
704 if ( RDS_UNIT == -1 )
705 {
706 rprerror( RPR_NOT_DEFINED, PhysicalGridKeyword, RprCurrentLine );
707 }
708
709 if ( (Multiple < (floor(Multiple + (double).5) - RPR_EPSILON )) ||
710 (Multiple > (floor(Multiple + (double).5) + RPR_EPSILON )) )
711 {
712 sprintf( RprBuffer, "%g", Param / RDS_UNIT );
713
714 rprerror( RPR_MULTIPLE_GRID, RprBuffer, RprCurrentLine );
715 }
716
717 /*
718 *fprintf( stderr, "RprTranslateParam() - Param:%.18g rouding:%ld truncated:%ld\n"
719 * , (Param), lround(Param), (long)(Param) );
720 */
721 return( lround(Param) );
722 }
723
724 /*------------------------------------------------------------\
725 | |
726 | Rpr Compute Rds Unit |
727 | |
728 \------------------------------------------------------------*/
729
RprComputeRdsUnit(PhysicalGrid)730 void RprComputeRdsUnit( PhysicalGrid )
731
732 double PhysicalGrid;
733 {
734 long Number;
735 long RdsUnit;
736
737 if ( PhysicalGrid <= 0 )
738 {
739 rprerror( RPR_NEGATIVE_VALUE, PhysicalGridKeyword, RprCurrentLine );
740 }
741
742 RdsUnit = 1;
743
744 for ( Number = 1;
745 ! RprEqual( PhysicalGrid * (double)RdsUnit, (double)Number );
746 Number = Number + 1 )
747 {
748 if ( RdsUnit > RPR_MAX_RDS_UNIT )
749 {
750 rprerror( RPR_TOO_SMAL, PhysicalGridKeyword, RprCurrentLine );
751 }
752
753 for ( RdsUnit = RdsUnit - 1;
754 PhysicalGrid * (double)RdsUnit + RPR_EPSILON < (double)Number;
755 RdsUnit = RdsUnit + 1 );
756
757 if ( RprEqual( PhysicalGrid * (double)RdsUnit, (double)Number ))
758
759 break;
760 }
761
762 RDS_UNIT = RdsUnit << 1;
763 RDS_PHYSICAL_GRID = Number << 1;
764 RDS_UNIT2 = RDS_UNIT * RDS_UNIT;
765 }
766
767 /*------------------------------------------------------------\
768 | |
769 | Rpr Keyword Compare |
770 | |
771 \------------------------------------------------------------*/
772
RprKeywordCompare(FirstKey,SecondKey)773 int RprKeywordCompare( FirstKey, SecondKey )
774
775 keyword *FirstKey;
776 keyword *SecondKey;
777 {
778 return strcmp( FirstKey->NAME, SecondKey->NAME );
779 }
780
781 /*------------------------------------------------------------\
782 | |
783 | Rpr Get String Value |
784 | |
785 \------------------------------------------------------------*/
786
RprGetStringValue(String)787 long RprGetStringValue( String )
788
789 char *String;
790 {
791 double FloatValue;
792 long Value;
793 keyword *Keyword;
794 keyword Entry;
795
796 if ( strchr( String, '.' ))
797 {
798 if ( sscanf( String, "%32lf", &FloatValue) )
799
800 return( RprTranslateParam( FloatValue ) );
801
802 rprerror( RPR_ILLEGAL_FLOAT, String, RprCurrentLine );
803 }
804 else
805 {
806 if ( sscanf( String, "%22ld", &Value) )
807
808 return ( RprTranslateParam( (double)Value) );
809
810 Entry.NAME = String;
811
812 Keyword = (keyword *)bsearch( (char *)(&Entry),
813 (char *)KeywordDefine,
814 RPR_MAX_KEYWORD, sizeof( keyword ),
815 RprKeywordCompare );
816
817 if ( Keyword != (keyword *)NULL )
818 {
819
820 if ( ! strncmp( String, "rds", 3 ) )
821 {
822 RDS_DYNAMIC_LAYER[ (int)Keyword->VALUE ] = 1;
823 }
824
825 return( Keyword->VALUE );
826 }
827
828 rprerror( RPR_UNEXPECTED_LINE, String, RprCurrentLine );
829 }
830
831 return( -1 );
832 }
833
834 /*------------------------------------------------------------\
835 | |
836 | Rpr Get String Float |
837 | |
838 \------------------------------------------------------------*/
839
RprGetStringFloat(String)840 float RprGetStringFloat( String )
841
842 char *String;
843 {
844 float FloatValue;
845
846 if ( sscanf( String, "%32f", &FloatValue) )
847
848 return( FloatValue );
849
850 rprerror( RPR_ILLEGAL_FLOAT, String, RprCurrentLine );
851
852 return( 0.0 );
853 }
854
855 /*------------------------------------------------------------\
856 | |
857 | Rpr Get Number |
858 | |
859 \------------------------------------------------------------*/
860
RprGetNumber(String)861 long RprGetNumber( String )
862
863 char *String;
864 {
865 long Value;
866
867 if ( sscanf( String, "%22ld", &Value )) return Value;
868
869 rprerror( RPR_UNEXPECTED_LINE, "number", RprCurrentLine );
870
871 return( -1 );
872 }
873
874 /*------------------------------------------------------------\
875 | |
876 | Rpr Skip Table |
877 | |
878 \------------------------------------------------------------*/
879
RprSkipTable()880 void RprSkipTable()
881
882 {
883 char EndTable;
884 char *FirstWord;
885
886 EndTable = 0;
887
888 while ( EndTable != 1 )
889 {
890 RprGetLine( RprBuffer, NO_FLAGS );
891
892 FirstWord = RprGetFirstWord( RprBuffer, 1 );
893
894 if ( FirstWord == EndTableKeyword )
895 {
896 EndTable = 1;
897 }
898 }
899 }
900
901 /*------------------------------------------------------------\
902 | |
903 | Rpr Read Segment |
904 | |
905 \------------------------------------------------------------*/
906
RprReadSegment()907 void RprReadSegment()
908
909 {
910 int Layer;
911 int LayerCount;
912 int Field;
913 int EndTable;
914 int EndRecord;
915 char *FirstWord;
916
917 EndTable = 0;
918 LayerCount = 0;
919
920 while ( ( EndTable != 1 ) &&
921 ( LayerCount <= MBK_MAX_LAYER ) )
922 {
923 RprGetLine( RprBuffer, NO_FLAGS );
924
925 FirstWord = RprGetFirstWord( RprBuffer, 1 );
926
927 if ( FirstWord == EndTableKeyword )
928 {
929 EndTable = 1;
930 }
931 else
932 if ( LayerCount < MBK_MAX_LAYER )
933 {
934 Layer = RprGetStringValue( FirstWord );
935
936 EndRecord = 0;
937 Field = 0;
938
939 while ( ( EndRecord != 1 ) &&
940 ( Field < RDS_SEGMENT_FIELD ) )
941 {
942 FirstWord = RprGetNextWord( 1 );
943
944 if ( FirstWord == EndRecordKeyword )
945 {
946 if ( Field % 6 != 0 )
947 {
948 rprerror( RPR_MISSING_VALUE, (char *)NULL, RprCurrentLine );
949 }
950
951 EndRecord = 1;
952 }
953 else
954 {
955 RDS_SEGMENT_TABLE [ Layer ][ Field ] = RprGetStringValue( FirstWord );
956
957 Field = Field + 1;
958 }
959 }
960
961 if ( Field == RDS_SEGMENT_FIELD )
962 {
963 FirstWord = RprGetNextWord( 0 );
964
965 if ( FirstWord != EndRecordKeyword )
966 {
967 rprerror( RPR_TOO_MANY_WORDS, FirstWord, RprCurrentLine );
968 }
969 }
970 }
971
972 LayerCount = LayerCount + 1;
973 }
974
975 if ( EndTable == 0 )
976 {
977 rprerror( RPR_LINE_EXPECTED, EndTableKeyword, RprCurrentLine);
978 }
979 }
980
981 /*------------------------------------------------------------\
982 | |
983 | Rpr Read Connector |
984 | |
985 \------------------------------------------------------------*/
986
RprReadConnector()987 void RprReadConnector()
988
989 {
990 int Layer;
991 int LayerCount;
992 int Field;
993 int EndTable;
994 int EndRecord;
995 char *FirstWord;
996
997 EndTable = 0;
998 LayerCount = 0;
999
1000 while ( ( EndTable != 1 ) &&
1001 ( LayerCount <= MBK_MAX_LAYER ) )
1002 {
1003 RprGetLine( RprBuffer, NO_FLAGS );
1004
1005 FirstWord = RprGetFirstWord( RprBuffer, 1 );
1006
1007 if ( FirstWord == EndTableKeyword )
1008 {
1009 EndTable = 1;
1010 }
1011 else
1012 if ( LayerCount < MBK_MAX_LAYER )
1013 {
1014 Layer = RprGetStringValue( FirstWord );
1015 EndRecord = 0;
1016 Field = 0;
1017
1018 while ( ( EndRecord != 1 ) &&
1019 ( Field < RDS_CONNECTOR_FIELD ) )
1020 {
1021 FirstWord = RprGetNextWord( 1 );
1022
1023 if ( FirstWord == EndRecordKeyword )
1024 {
1025 if ( Field % 3 != 0 )
1026 {
1027 rprerror( RPR_MISSING_VALUE, (char *)NULL, RprCurrentLine );
1028 }
1029
1030 EndRecord = 1;
1031 }
1032 else
1033 {
1034 RDS_CONNECTOR_TABLE [ Layer ][ Field ] = RprGetStringValue( FirstWord );
1035
1036 Field = Field + 1;
1037 }
1038 }
1039
1040 if ( Field == RDS_CONNECTOR_FIELD )
1041 {
1042 FirstWord = RprGetNextWord( 0 );
1043
1044 if ( FirstWord != EndRecordKeyword )
1045 {
1046 rprerror( RPR_TOO_MANY_WORDS, FirstWord, RprCurrentLine );
1047 }
1048 }
1049 }
1050
1051 LayerCount = LayerCount + 1;
1052 }
1053
1054 if ( EndTable == 0 )
1055 {
1056 rprerror( RPR_LINE_EXPECTED, EndTableKeyword, RprCurrentLine);
1057 }
1058 }
1059
1060 /*------------------------------------------------------------\
1061 | |
1062 | Rpr Read Reference |
1063 | |
1064 \------------------------------------------------------------*/
1065
RprReadReference()1066 void RprReadReference()
1067
1068 {
1069 int Layer;
1070 int LayerCount;
1071 int Field;
1072 int EndTable;
1073 int EndRecord;
1074 char *FirstWord;
1075
1076 EndTable = 0;
1077 LayerCount = 0;
1078
1079 while ( ( EndTable != 1 ) &&
1080 ( LayerCount <= MBK_MAX_REFERENCE ) )
1081 {
1082 RprGetLine( RprBuffer, NO_FLAGS );
1083
1084 FirstWord = RprGetFirstWord( RprBuffer, 1 );
1085
1086 if ( FirstWord == EndTableKeyword )
1087 {
1088 EndTable = 1;
1089 }
1090 else
1091 if ( LayerCount < MBK_MAX_REFERENCE )
1092 {
1093 Layer = RprGetStringValue( FirstWord );
1094 EndRecord = 0;
1095 Field = 0;
1096
1097 while ( ( EndRecord != 1 ) &&
1098 ( Field < RDS_REFERENCE_FIELD ) )
1099 {
1100 FirstWord = RprGetNextWord( 1 );
1101
1102 if ( FirstWord == EndRecordKeyword )
1103 {
1104 if ( ( Field & 1 ) != 0 )
1105 {
1106 rprerror( RPR_MISSING_VALUE, (char *)NULL, RprCurrentLine );
1107 }
1108
1109 EndRecord = 1;
1110 }
1111 else
1112 {
1113 RDS_REFERENCE_TABLE [ Layer ][ Field ] = RprGetStringValue( FirstWord );
1114
1115 Field = Field + 1;
1116 }
1117 }
1118
1119 if ( Field == RDS_REFERENCE_FIELD )
1120 {
1121 FirstWord = RprGetNextWord( 0 );
1122
1123 if ( FirstWord != EndRecordKeyword )
1124 {
1125 rprerror( RPR_TOO_MANY_WORDS, FirstWord, RprCurrentLine );
1126 }
1127 }
1128 }
1129
1130 LayerCount = LayerCount + 1;
1131 }
1132
1133 if ( EndTable == 0 )
1134 {
1135 rprerror( RPR_LINE_EXPECTED, EndTableKeyword, RprCurrentLine);
1136 }
1137 }
1138
1139 /*------------------------------------------------------------\
1140 | |
1141 | Rpr Read Via |
1142 | |
1143 \------------------------------------------------------------*/
1144
RprReadVia()1145 void RprReadVia()
1146
1147 {
1148 int Layer;
1149 int LayerCount;
1150 int Field;
1151 int EndTable;
1152 int EndRecord;
1153 char *FirstWord;
1154
1155 EndTable = 0;
1156 LayerCount = 0;
1157
1158 while ( ( EndTable != 1 ) &&
1159 ( LayerCount <= MBK_MAX_VIA ) )
1160 {
1161 RprGetLine( RprBuffer, NO_FLAGS );
1162
1163 FirstWord = RprGetFirstWord( RprBuffer, 1 );
1164
1165 if ( FirstWord == EndTableKeyword )
1166 {
1167 EndTable = 1;
1168 }
1169 else
1170 if ( LayerCount < MBK_MAX_VIA )
1171 {
1172 Layer = RprGetStringValue( FirstWord );
1173 EndRecord = 0;
1174 Field = 0;
1175
1176 while ( ( EndRecord != 1 ) &&
1177 ( Field < RDS_VIA_FIELD ) )
1178 {
1179 FirstWord = RprGetNextWord( 1 );
1180
1181 if ( FirstWord == EndRecordKeyword )
1182 {
1183 if ( Field % 3 != 0 )
1184 {
1185 rprerror( RPR_MISSING_VALUE, (char *)NULL, RprCurrentLine );
1186 }
1187
1188 EndRecord = 1;
1189 }
1190 else
1191 {
1192 RDS_VIA_TABLE[ Layer ][ Field ] = RprGetStringValue( FirstWord );
1193
1194 Field = Field + 1;
1195 }
1196 }
1197
1198 if ( Field == RDS_VIA_FIELD )
1199 {
1200 FirstWord = RprGetNextWord( 0 );
1201
1202 if ( FirstWord != EndRecordKeyword )
1203 {
1204 rprerror( RPR_TOO_MANY_WORDS, FirstWord, RprCurrentLine );
1205 }
1206 }
1207 }
1208
1209 LayerCount = LayerCount + 1;
1210 }
1211
1212 if ( EndTable == 0 )
1213 {
1214 rprerror( RPR_LINE_EXPECTED, EndTableKeyword, RprCurrentLine);
1215 }
1216 }
1217
1218 /*------------------------------------------------------------\
1219 | |
1220 | Rpr Read Big Via Hole |
1221 | |
1222 \------------------------------------------------------------*/
1223
RprReadBigViaHole()1224 void RprReadBigViaHole()
1225
1226 {
1227 int Layer;
1228 int LayerCount;
1229 int Field;
1230 int EndTable;
1231 int EndRecord;
1232 char *FirstWord;
1233
1234 EndTable = 0;
1235 LayerCount = 0;
1236
1237 while ( ( EndTable != 1 ) &&
1238 ( LayerCount <= MBK_MAX_VIA ) )
1239 {
1240 RprGetLine( RprBuffer, NO_FLAGS );
1241
1242 FirstWord = RprGetFirstWord( RprBuffer, 1 );
1243
1244 if ( FirstWord == EndTableKeyword )
1245 {
1246 EndTable = 1;
1247 }
1248 else
1249 if ( LayerCount < MBK_MAX_VIA )
1250 {
1251 Layer = RprGetStringValue( FirstWord );
1252 EndRecord = 0;
1253 Field = 0;
1254
1255 while ( ( EndRecord != 1 ) &&
1256 ( Field < RDS_BIGVIA_HOLE_FIELD ) )
1257 {
1258 FirstWord = RprGetNextWord( 1 );
1259
1260 if ( FirstWord == EndRecordKeyword )
1261 {
1262 if ( Field % 4 != 0 )
1263 {
1264 rprerror( RPR_MISSING_VALUE, (char *)NULL, RprCurrentLine );
1265 }
1266
1267 EndRecord = 1;
1268 }
1269 else
1270 {
1271 RDS_BIGVIA_HOLE_TABLE[ Layer ][ Field ] = RprGetStringValue( FirstWord );
1272
1273 Field = Field + 1;
1274 }
1275 }
1276
1277 if ( Field == RDS_BIGVIA_HOLE_FIELD )
1278 {
1279 FirstWord = RprGetNextWord( 0 );
1280
1281 if ( FirstWord != EndRecordKeyword )
1282 {
1283 rprerror( RPR_TOO_MANY_WORDS, FirstWord, RprCurrentLine );
1284 }
1285 }
1286 }
1287
1288 LayerCount = LayerCount + 1;
1289 }
1290
1291 if ( EndTable == 0 )
1292 {
1293 rprerror( RPR_LINE_EXPECTED, EndTableKeyword, RprCurrentLine);
1294 }
1295 }
1296
1297 /*------------------------------------------------------------\
1298 | |
1299 | Rpr Read Big Via Metal |
1300 | |
1301 \------------------------------------------------------------*/
1302
RprReadBigViaMetal()1303 void RprReadBigViaMetal()
1304
1305 {
1306 int Layer;
1307 int LayerCount;
1308 int Field;
1309 int EndTable;
1310 int EndRecord;
1311 char *FirstWord;
1312
1313 EndTable = 0;
1314 LayerCount = 0;
1315
1316 while ( ( EndTable != 1 ) &&
1317 ( LayerCount <= MBK_MAX_VIA ) )
1318 {
1319 RprGetLine( RprBuffer, NO_FLAGS );
1320
1321 FirstWord = RprGetFirstWord( RprBuffer, 1 );
1322
1323 if ( FirstWord == EndTableKeyword )
1324 {
1325 EndTable = 1;
1326 }
1327 else
1328 if ( LayerCount < MBK_MAX_VIA )
1329 {
1330 Layer = RprGetStringValue( FirstWord );
1331 EndRecord = 0;
1332 Field = 0;
1333
1334 while ( ( EndRecord != 1 ) &&
1335 ( Field < RDS_BIGVIA_METAL_FIELD ) )
1336 {
1337 FirstWord = RprGetNextWord( 1 );
1338
1339 if ( FirstWord == EndRecordKeyword )
1340 {
1341 if ( Field % 4 != 0 )
1342 {
1343 rprerror( RPR_MISSING_VALUE, (char *)NULL, RprCurrentLine );
1344 }
1345
1346 EndRecord = 1;
1347 }
1348 else
1349 {
1350 RDS_BIGVIA_METAL_TABLE[ Layer ][ Field ] = RprGetStringValue( FirstWord );
1351
1352 Field = Field + 1;
1353 }
1354 }
1355
1356 if ( Field == RDS_BIGVIA_METAL_FIELD )
1357 {
1358 FirstWord = RprGetNextWord( 0 );
1359
1360 if ( FirstWord != EndRecordKeyword )
1361 {
1362 rprerror( RPR_TOO_MANY_WORDS, FirstWord, RprCurrentLine );
1363 }
1364 }
1365 }
1366
1367 LayerCount = LayerCount + 1;
1368 }
1369
1370 if ( EndTable == 0 )
1371 {
1372 rprerror( RPR_LINE_EXPECTED, EndTableKeyword, RprCurrentLine);
1373 }
1374 }
1375
1376 /*------------------------------------------------------------\
1377 | |
1378 | Rpr Read Turn Via |
1379 | |
1380 \------------------------------------------------------------*/
1381
RprReadTurnVia()1382 void RprReadTurnVia()
1383
1384 {
1385 int Layer;
1386 int LayerCount;
1387 int Field;
1388 int EndTable;
1389 int EndRecord;
1390 char *FirstWord;
1391
1392 EndTable = 0;
1393 LayerCount = 0;
1394
1395 while ( ( EndTable != 1 ) &&
1396 ( LayerCount <= MBK_MAX_VIA ) )
1397 {
1398 RprGetLine( RprBuffer, NO_FLAGS );
1399
1400 FirstWord = RprGetFirstWord( RprBuffer, 1 );
1401
1402 if ( FirstWord == EndTableKeyword )
1403 {
1404 EndTable = 1;
1405 }
1406 else
1407 if ( LayerCount < MBK_MAX_VIA )
1408 {
1409 Layer = RprGetStringValue( FirstWord );
1410 EndRecord = 0;
1411 Field = 0;
1412
1413 while ( ( EndRecord != 1 ) &&
1414 ( Field < RDS_TURNVIA_FIELD ) )
1415 {
1416 FirstWord = RprGetNextWord( 1 );
1417
1418 if ( FirstWord == EndRecordKeyword )
1419 {
1420 if ( Field % 3 != 0 )
1421 {
1422 rprerror( RPR_MISSING_VALUE, (char *)NULL, RprCurrentLine );
1423 }
1424
1425 EndRecord = 1;
1426 }
1427 else
1428 {
1429 RDS_TURNVIA_TABLE[ Layer ][ Field ] = RprGetStringValue( FirstWord );
1430
1431 Field = Field + 1;
1432 }
1433 }
1434
1435 if ( Field == RDS_TURNVIA_FIELD )
1436 {
1437 FirstWord = RprGetNextWord( 0 );
1438
1439 if ( FirstWord != EndRecordKeyword )
1440 {
1441 rprerror( RPR_TOO_MANY_WORDS, FirstWord, RprCurrentLine );
1442 }
1443 }
1444 }
1445
1446 LayerCount = LayerCount + 1;
1447 }
1448
1449 if ( EndTable == 0 )
1450 {
1451 rprerror( RPR_LINE_EXPECTED, EndTableKeyword, RprCurrentLine);
1452 }
1453 }
1454
1455 /*------------------------------------------------------------\
1456 | |
1457 | Rpr Read Cif Layer |
1458 | |
1459 \------------------------------------------------------------*/
1460
RprReadCifLayer()1461 void RprReadCifLayer()
1462
1463 {
1464 int Layer;
1465 int LayerCount;
1466 int Field;
1467 int EndTable;
1468 int EndRecord;
1469 char *FirstWord;
1470
1471 EndTable = 0;
1472 LayerCount = 0;
1473
1474 while ( ( EndTable != 1 ) &&
1475 ( LayerCount <= RDS_ALL_LAYER ) )
1476 {
1477 RprGetLine( RprBuffer, NO_FLAGS );
1478
1479 FirstWord = RprGetFirstWord( RprBuffer, 1 );
1480
1481 if ( FirstWord == EndTableKeyword )
1482 {
1483 EndTable = 1;
1484 }
1485 else
1486 if ( LayerCount < RDS_ALL_LAYER )
1487 {
1488 Layer = RprGetStringValue( FirstWord );
1489 EndRecord = 0;
1490 Field = 0;
1491
1492 while ( ( EndRecord != 1 ) &&
1493 ( Field < RDS_CIF_LAYER_FIELD ) )
1494 {
1495 FirstWord = RprGetNextWord( 1 );
1496
1497 if ( FirstWord == EndRecordKeyword )
1498 {
1499 if ( Field == 0 )
1500 {
1501 rprerror( RPR_MISSING_VALUE, (char *)NULL, RprCurrentLine );
1502 }
1503
1504 EndRecord = 1;
1505 }
1506 else
1507 {
1508 RDS_CIF_LAYER_TABLE[ Layer ][ Field ] = RprUpperCase( FirstWord );
1509
1510 Field = Field + 1;
1511 }
1512 }
1513
1514 if ( Field == RDS_CIF_LAYER_FIELD )
1515 {
1516 FirstWord = RprGetNextWord( 0 );
1517
1518 if ( FirstWord != EndRecordKeyword )
1519 {
1520 rprerror( RPR_TOO_MANY_WORDS, FirstWord, RprCurrentLine );
1521 }
1522 }
1523 }
1524
1525 LayerCount = LayerCount + 1;
1526 }
1527
1528 if ( EndTable == 0 )
1529 {
1530 rprerror( RPR_LINE_EXPECTED, EndTableKeyword, RprCurrentLine);
1531 }
1532 }
1533
1534 /*------------------------------------------------------------\
1535 | |
1536 | Rpr Read Gds Layer |
1537 | |
1538 \------------------------------------------------------------*/
1539
RprReadGdsLayer()1540 void RprReadGdsLayer()
1541
1542 {
1543 int Layer;
1544 int LayerCount;
1545 int Field;
1546 int EndTable;
1547 int EndRecord;
1548 char *FirstWord;
1549
1550 EndTable = 0;
1551 LayerCount = 0;
1552
1553 while ( ( EndTable != 1 ) &&
1554 ( LayerCount <= RDS_ALL_LAYER ) )
1555 {
1556 RprGetLine( RprBuffer, NO_FLAGS );
1557
1558 FirstWord = RprGetFirstWord( RprBuffer, 1 );
1559
1560 if ( FirstWord == EndTableKeyword )
1561 {
1562 EndTable = 1;
1563 }
1564 else
1565 if ( LayerCount < RDS_ALL_LAYER )
1566 {
1567 Layer = RprGetStringValue( FirstWord );
1568 EndRecord = 0;
1569 Field = 0;
1570
1571 while ( ( EndRecord != 1 ) &&
1572 ( Field < RDS_GDS_LAYER_FIELD ) )
1573 {
1574 FirstWord = RprGetNextWord( 1 );
1575
1576 if ( FirstWord == EndRecordKeyword )
1577 {
1578 if ( Field == 0 )
1579 {
1580 rprerror( RPR_MISSING_VALUE, (char *)NULL, RprCurrentLine );
1581 }
1582
1583 EndRecord = 1;
1584 }
1585 else
1586 {
1587 RDS_GDS_LAYER_TABLE[ Layer ][ Field ] = atoi( FirstWord );
1588
1589 Field = Field + 1;
1590 }
1591 }
1592
1593 if ( Field == RDS_GDS_LAYER_FIELD )
1594 {
1595 FirstWord = RprGetNextWord( 0 );
1596
1597 if ( FirstWord != EndRecordKeyword )
1598 {
1599 rprerror( RPR_TOO_MANY_WORDS, FirstWord, RprCurrentLine );
1600 }
1601 }
1602 }
1603
1604 LayerCount = LayerCount + 1;
1605 }
1606
1607 if ( EndTable == 0 )
1608 {
1609 rprerror( RPR_LINE_EXPECTED, EndTableKeyword, RprCurrentLine);
1610 }
1611 }
1612
1613
1614
1615 /*------------------------------------------------------------\
1616 | |
1617 | Rpr Read Wire Settings |
1618 | |
1619 \------------------------------------------------------------*/
1620
RprReadWireComp(const void * x,const void * y)1621 int RprReadWireComp(const void *x , const void *y) {
1622 return strncmp((char*)x, (char*)y,MBK_MAX_WIRESETTING_TLEN);
1623 }
1624
RprReadWireSetting()1625 void RprReadWireSetting()
1626
1627 {
1628 int Layer;
1629 int LayerCount;
1630 int EndTable;
1631 int EndRecord;
1632 char *FirstWord;
1633 void *res;
1634
1635 EndTable = 0;
1636 LayerCount = 0;
1637
1638 while ( ( EndTable != 1 ) &&
1639 ( LayerCount <= MBK_MAX_WIRESETTING ) )
1640 {
1641 RprGetLine( RprBuffer, NO_FLAGS );
1642
1643 FirstWord = RprGetFirstWord( RprBuffer, 1 );
1644 Layer = (char (*)[MBK_MAX_WIRESETTING_TLEN])bsearch(FirstWord, MBK_WIRESETTING_NAME[0],
1645 MBK_MAX_WIRESETTING, MBK_MAX_WIRESETTING_TLEN, RprReadWireComp) - MBK_WIRESETTING_NAME;
1646
1647 if ( FirstWord == EndTableKeyword )
1648 {
1649 EndTable = 1;
1650 }
1651 else
1652 if ( LayerCount < MBK_MAX_WIRESETTING )
1653 {
1654 EndRecord = 0;
1655
1656 FirstWord = RprGetNextWord( 1 );
1657
1658 if ( FirstWord == EndRecordKeyword || Layer > MBK_MAX_WIRESETTING || Layer < 0)
1659 {
1660 rprerror( RPR_MISSING_VALUE, (char *)NULL, RprCurrentLine );
1661
1662 EndRecord = 1;
1663 }
1664 else
1665 {
1666 *RDS_WIRESETTING_TABLE[ Layer ] = atol( FirstWord );
1667
1668 }
1669
1670 FirstWord = RprGetNextWord( 0 );
1671
1672 if ( FirstWord != EndRecordKeyword )
1673 {
1674 rprerror( RPR_TOO_MANY_WORDS, FirstWord, RprCurrentLine );
1675 }
1676 }
1677
1678 LayerCount = LayerCount + 1;
1679 }
1680
1681 if ( EndTable == 0 )
1682 {
1683 rprerror( RPR_LINE_EXPECTED, EndTableKeyword, RprCurrentLine);
1684 }
1685 }
1686
1687 /*------------------------------------------------------------\
1688 | |
1689 | Rpr Read Post Treat |
1690 | |
1691 \------------------------------------------------------------*/
1692
RprReadS2RPostTreat()1693 void RprReadS2RPostTreat()
1694
1695 {
1696 int Layer;
1697 int LayerCount;
1698 int EndTable;
1699 int EndRecord;
1700 int Field;
1701 char *FirstWord;
1702
1703 EndTable = 0;
1704 LayerCount = 0;
1705
1706 while ( ( EndTable != 1 ) &&
1707 ( LayerCount <= RDS_ALL_LAYER ) )
1708 {
1709 RprGetLine( RprBuffer, NO_FLAGS );
1710
1711 FirstWord = RprGetFirstWord( RprBuffer, 1 );
1712
1713 if ( FirstWord == EndTableKeyword )
1714 {
1715 EndTable = 1;
1716 }
1717 else
1718 if ( LayerCount < RDS_ALL_LAYER )
1719 {
1720 Layer = RprGetStringValue( FirstWord );
1721 EndRecord = 0;
1722 Field = 0;
1723
1724 while ( ( EndRecord != 1 ) &&
1725 ( Field < RDS_S2R_POST_TREAT_FIELD ) )
1726 {
1727 FirstWord = RprGetNextWord( 1 );
1728
1729 if ( FirstWord == EndRecordKeyword )
1730 {
1731 if ( Field == 0 )
1732 {
1733 rprerror( RPR_MISSING_VALUE, (char *)NULL, RprCurrentLine );
1734 }
1735
1736 EndRecord = 1;
1737 }
1738 else
1739 {
1740 RDS_S2R_POST_TREAT_TABLE[ Layer ][ Field ] = RprGetStringValue( FirstWord );
1741
1742 Field = Field + 1;
1743 }
1744 }
1745
1746 if ( Field == RDS_S2R_POST_TREAT_FIELD )
1747 {
1748 FirstWord = RprGetNextWord( 0 );
1749
1750 if ( FirstWord != EndRecordKeyword )
1751 {
1752 rprerror( RPR_TOO_MANY_WORDS, FirstWord, RprCurrentLine );
1753 }
1754 }
1755 }
1756
1757 LayerCount = LayerCount + 1;
1758 }
1759
1760 if ( EndTable == 0 )
1761 {
1762 rprerror( RPR_LINE_EXPECTED, EndTableKeyword, RprCurrentLine);
1763 }
1764 }
1765
1766 /*------------------------------------------------------------\
1767 | |
1768 | Rpr Read Over Size |
1769 | |
1770 \------------------------------------------------------------*/
1771
RprReadS2ROversize()1772 void RprReadS2ROversize()
1773
1774 {
1775 int Layer;
1776 int LayerCount;
1777 int Field;
1778 int EndTable;
1779 int EndRecord;
1780 char *FirstWord;
1781
1782 EndTable = 0;
1783 LayerCount = 0;
1784
1785 while ( ( EndTable != 1 ) &&
1786 ( LayerCount <= RDS_ALL_LAYER ) )
1787 {
1788 RprGetLine( RprBuffer, NO_FLAGS );
1789
1790 FirstWord = RprGetFirstWord( RprBuffer, 1 );
1791
1792 if ( FirstWord == EndTableKeyword )
1793 {
1794 EndTable = 1;
1795 }
1796 else
1797 if ( LayerCount < RDS_ALL_LAYER )
1798 {
1799 Layer = RprGetStringValue( FirstWord );
1800 EndRecord = 0;
1801 Field = 0;
1802
1803 while ( ( EndRecord != 1 ) &&
1804 ( Field < RDS_S2R_OVERSIZE_FIELD ) )
1805 {
1806 FirstWord = RprGetNextWord( 1 );
1807
1808 if ( FirstWord == EndRecordKeyword )
1809 {
1810 if ( Field == 0 )
1811 {
1812 rprerror( RPR_MISSING_VALUE, (char *)NULL, RprCurrentLine );
1813 }
1814
1815 EndRecord = 1;
1816 }
1817 else
1818 {
1819 RDS_S2R_OVERSIZE_TABLE[ Layer ][ Field ] = RprGetStringValue( FirstWord );
1820
1821 Field = Field + 1;
1822 }
1823 }
1824
1825 if ( Field == RDS_S2R_OVERSIZE_FIELD )
1826 {
1827 FirstWord = RprGetNextWord( 0 );
1828
1829 if ( FirstWord != EndRecordKeyword )
1830 {
1831 rprerror( RPR_TOO_MANY_WORDS, FirstWord, RprCurrentLine );
1832 }
1833 }
1834 }
1835
1836 LayerCount = LayerCount + 1;
1837 }
1838
1839 if ( EndTable == 0 )
1840 {
1841 rprerror( RPR_LINE_EXPECTED, EndTableKeyword, RprCurrentLine);
1842 }
1843 }
1844
1845 /*------------------------------------------------------------\
1846 | |
1847 | Rpr Read Ring Width |
1848 | |
1849 \------------------------------------------------------------*/
1850
RprReadS2RRingWidth()1851 void RprReadS2RRingWidth()
1852
1853 {
1854 int Layer;
1855 int LayerCount;
1856 int Field;
1857 int EndTable;
1858 int EndRecord;
1859 char *FirstWord;
1860
1861 EndTable = 0;
1862 LayerCount = 0;
1863
1864 while ( ( EndTable != 1 ) &&
1865 ( LayerCount <= RDS_ALL_LAYER ) )
1866 {
1867 RprGetLine( RprBuffer, NO_FLAGS );
1868
1869 FirstWord = RprGetFirstWord( RprBuffer, 1 );
1870
1871 if ( FirstWord == EndTableKeyword )
1872 {
1873 EndTable = 1;
1874 }
1875 else
1876 if ( LayerCount < RDS_ALL_LAYER )
1877 {
1878 Layer = RprGetStringValue( FirstWord );
1879 EndRecord = 0;
1880 Field = 0;
1881
1882 while ( ( EndRecord != 1 ) &&
1883 ( Field < RDS_S2R_RING_WIDTH_FIELD ) )
1884 {
1885 FirstWord = RprGetNextWord( 1 );
1886
1887 if ( FirstWord == EndRecordKeyword )
1888 {
1889 if ( Field == 0 )
1890 {
1891 rprerror( RPR_MISSING_VALUE, (char *)NULL, RprCurrentLine );
1892 }
1893
1894 EndRecord = 1;
1895 }
1896 else
1897 {
1898 RDS_S2R_RING_WIDTH_TABLE[ Layer ][ Field ] = RprGetStringValue( FirstWord );
1899
1900 Field = Field + 1;
1901 }
1902 }
1903
1904 if ( Field == RDS_S2R_RING_WIDTH_FIELD )
1905 {
1906 FirstWord = RprGetNextWord( 0 );
1907
1908 if ( FirstWord != EndRecordKeyword )
1909 {
1910 rprerror( RPR_TOO_MANY_WORDS, FirstWord, RprCurrentLine );
1911 }
1912 }
1913 }
1914
1915 LayerCount = LayerCount + 1;
1916 }
1917
1918 if ( EndTable == 0 )
1919 {
1920 rprerror( RPR_LINE_EXPECTED, EndTableKeyword, RprCurrentLine);
1921 }
1922 }
1923
1924 /*------------------------------------------------------------\
1925 | |
1926 | Rpr Read Layer Width |
1927 | |
1928 \------------------------------------------------------------*/
1929
RprReadS2RLayerWidth()1930 void RprReadS2RLayerWidth()
1931
1932 {
1933 int Layer;
1934 int LayerCount;
1935 int Field;
1936 int EndTable;
1937 int EndRecord;
1938 char *FirstWord;
1939
1940 EndTable = 0;
1941 LayerCount = 0;
1942
1943 while ( ( EndTable != 1 ) &&
1944 ( LayerCount <= RDS_ALL_LAYER ) )
1945 {
1946 RprGetLine( RprBuffer, NO_FLAGS );
1947
1948 FirstWord = RprGetFirstWord( RprBuffer, 1 );
1949
1950 if ( FirstWord == EndTableKeyword )
1951 {
1952 EndTable = 1;
1953 }
1954 else
1955 if ( LayerCount < RDS_ALL_LAYER )
1956 {
1957 Layer = RprGetStringValue( FirstWord );
1958 EndRecord = 0;
1959 Field = 0;
1960
1961 while ( ( EndRecord != 1 ) &&
1962 ( Field < RDS_S2R_LAYER_WIDTH_FIELD ) )
1963 {
1964 FirstWord = RprGetNextWord( 1 );
1965
1966 if ( FirstWord == EndRecordKeyword )
1967 {
1968 if ( Field == 0 )
1969 {
1970 rprerror( RPR_MISSING_VALUE, (char *)NULL, RprCurrentLine );
1971 }
1972
1973 EndRecord = 1;
1974 }
1975 else
1976 {
1977 RDS_S2R_LAYER_WIDTH_TABLE[ Layer ][ Field ] = RprGetStringValue( FirstWord );
1978
1979 Field = Field + 1;
1980 }
1981 }
1982
1983 if ( Field == RDS_S2R_LAYER_WIDTH_FIELD )
1984 {
1985 FirstWord = RprGetNextWord( 0 );
1986
1987 if ( FirstWord != EndRecordKeyword )
1988 {
1989 rprerror( RPR_TOO_MANY_WORDS, FirstWord, RprCurrentLine );
1990 }
1991 }
1992 }
1993
1994 LayerCount = LayerCount + 1;
1995 }
1996
1997 if ( EndTable == 0 )
1998 {
1999 rprerror( RPR_LINE_EXPECTED, EndTableKeyword, RprCurrentLine);
2000 }
2001 }
2002
2003 /*------------------------------------------------------------\
2004 | |
2005 | Rpr Read Lynx Graph |
2006 | |
2007 \------------------------------------------------------------*/
2008
RprReadLynxGraph()2009 void RprReadLynxGraph()
2010
2011 {
2012 int Layer;
2013 int LayerCount;
2014 int Field;
2015 int EndTable;
2016 int EndRecord;
2017 char *FirstWord;
2018
2019 EndTable = 0;
2020 LayerCount = 0;
2021
2022 while ( ( EndTable != 1 ) &&
2023 ( LayerCount <= RDS_ALL_LAYER ) )
2024 {
2025 RprGetLine( RprBuffer, NO_FLAGS );
2026
2027 FirstWord = RprGetFirstWord( RprBuffer, 1 );
2028
2029 if ( FirstWord == EndTableKeyword )
2030 {
2031 EndTable = 1;
2032 }
2033 else
2034 if ( LayerCount < RDS_ALL_LAYER )
2035 {
2036 Layer = RprGetStringValue( FirstWord );
2037 EndRecord = 0;
2038 Field = 0;
2039
2040 while ( ( EndRecord != 1 ) &&
2041 ( Field < RDS_LYNX_GRAPH_FIELD ) )
2042 {
2043 FirstWord = RprGetNextWord( 1 );
2044
2045 if ( FirstWord == EndRecordKeyword )
2046 {
2047 if ( Field == 0 )
2048 {
2049 rprerror( RPR_MISSING_VALUE, (char *)NULL, RprCurrentLine );
2050 }
2051
2052 EndRecord = 1;
2053 }
2054 else
2055 {
2056 RDS_LYNX_GRAPH_TABLE [ Layer ][ Field ] = RprGetStringValue( FirstWord );
2057
2058 Field = Field + 1;
2059 }
2060 }
2061
2062 if ( Field == RDS_LYNX_GRAPH_FIELD )
2063 {
2064 FirstWord = RprGetNextWord( 0 );
2065
2066 if ( FirstWord != EndRecordKeyword )
2067 {
2068 rprerror( RPR_TOO_MANY_WORDS, FirstWord, RprCurrentLine );
2069 }
2070 }
2071 }
2072
2073 LayerCount = LayerCount + 1;
2074 }
2075
2076 if ( EndTable == 0 )
2077 {
2078 rprerror( RPR_LINE_EXPECTED, EndTableKeyword, RprCurrentLine);
2079 }
2080 }
2081
2082 /*------------------------------------------------------------\
2083 | |
2084 | Rpr Read Lynx Diffusion |
2085 | |
2086 \------------------------------------------------------------*/
2087
RprReadLynxDiffusion()2088 void RprReadLynxDiffusion()
2089
2090 {
2091 int Layer;
2092 int LayerCount;
2093 int Field;
2094 int EndTable;
2095 int EndRecord;
2096 char *FirstWord;
2097
2098 EndTable = 0;
2099 LayerCount = 0;
2100
2101 while ( ( EndTable != 1 ) &&
2102 ( LayerCount <= RDS_ALL_LAYER ) )
2103 {
2104 RprGetLine( RprBuffer, NO_FLAGS );
2105
2106 FirstWord = RprGetFirstWord( RprBuffer, 1 );
2107
2108 if ( FirstWord == EndTableKeyword )
2109 {
2110 EndTable = 1;
2111 }
2112 else
2113 if ( LayerCount < RDS_ALL_LAYER )
2114 {
2115 Layer = RprGetStringValue( FirstWord );
2116 EndRecord = 0;
2117 Field = 0;
2118
2119 while ( ( EndRecord != 1 ) &&
2120 ( Field < RDS_LYNX_DIFFUSION_FIELD ) )
2121 {
2122 FirstWord = RprGetNextWord( 1 );
2123
2124 if ( FirstWord == EndRecordKeyword )
2125 {
2126 if ( Field & 0x1 )
2127 {
2128 rprerror( RPR_MISSING_VALUE, (char *)NULL, RprCurrentLine );
2129 }
2130
2131 EndRecord = 1;
2132 }
2133 else
2134 {
2135 if ( Field & 0x1 )
2136 {
2137 RDS_LYNX_DIFFUSION_TABLE [ Layer ][ Field ] = atoi( FirstWord );
2138 }
2139 else
2140 {
2141 RDS_LYNX_DIFFUSION_TABLE [ Layer ][ Field ] = RprGetStringValue( FirstWord );
2142 }
2143
2144 Field = Field + 1;
2145 }
2146 }
2147
2148 if ( Field == RDS_LYNX_DIFFUSION_FIELD )
2149 {
2150 FirstWord = RprGetNextWord( 0 );
2151
2152 if ( FirstWord != EndRecordKeyword )
2153 {
2154 rprerror( RPR_TOO_MANY_WORDS, FirstWord, RprCurrentLine );
2155 }
2156 }
2157 }
2158
2159 LayerCount = LayerCount + 1;
2160 }
2161
2162 if ( EndTable == 0 )
2163 {
2164 rprerror( RPR_LINE_EXPECTED, EndTableKeyword, RprCurrentLine);
2165 }
2166 }
2167
2168 /*------------------------------------------------------------\
2169 | |
2170 | Rpr Read Lynx Capa |
2171 | |
2172 \------------------------------------------------------------*/
2173
RprReadLynxCapa()2174 void RprReadLynxCapa()
2175
2176 {
2177 int Layer;
2178 int LayerCount;
2179 int Field;
2180 int EndTable;
2181 int EndRecord;
2182 char *FirstWord;
2183
2184 EndTable = 0;
2185 LayerCount = 0;
2186
2187 while ( ( EndTable != 1 ) &&
2188 ( LayerCount <= RDS_ALL_LAYER ) )
2189 {
2190 RprGetLine( RprBuffer, NO_FLAGS );
2191
2192 FirstWord = RprGetFirstWord( RprBuffer, 1 );
2193
2194 if ( FirstWord == EndTableKeyword )
2195 {
2196 EndTable = 1;
2197 }
2198 else
2199 if ( LayerCount < RDS_ALL_LAYER )
2200 {
2201 Layer = RprGetStringValue( FirstWord );
2202 EndRecord = 0;
2203 Field = 0;
2204
2205 while ( ( EndRecord != 1 ) &&
2206 ( Field < RDS_LYNX_CAPA_FIELD ) )
2207 {
2208 FirstWord = RprGetNextWord( 1 );
2209
2210 if ( FirstWord == EndRecordKeyword )
2211 {
2212 if ( Field == 0 )
2213 {
2214 rprerror( RPR_MISSING_VALUE, (char *)NULL, RprCurrentLine );
2215 }
2216
2217 EndRecord = 1;
2218 }
2219 else
2220 {
2221 if ( Field == 0 )
2222 {
2223 RDS_LYNX_CAPA_TABLE [ Layer ][ 0 ] =
2224
2225 RprGetStringFloat( FirstWord ) / RDS_UNIT2;
2226 }
2227 else
2228 {
2229 RDS_LYNX_CAPA_TABLE [ Layer ][ Field ] =
2230
2231 RprGetStringFloat( FirstWord ) / RDS_UNIT;
2232 }
2233
2234 Field = Field + 1;
2235 }
2236 }
2237
2238 if ( Field == RDS_LYNX_CAPA_FIELD )
2239 {
2240 FirstWord = RprGetNextWord( 0 );
2241
2242 if ( FirstWord != EndRecordKeyword )
2243 {
2244 rprerror( RPR_TOO_MANY_WORDS, FirstWord, RprCurrentLine );
2245 }
2246 }
2247 }
2248
2249 LayerCount = LayerCount + 1;
2250 }
2251
2252 if ( EndTable == 0 )
2253 {
2254 rprerror( RPR_LINE_EXPECTED, EndTableKeyword, RprCurrentLine);
2255 }
2256 }
2257
2258 /*------------------------------------------------------------\
2259 | |
2260 | Rpr Read Lynx Resistor |
2261 | |
2262 \------------------------------------------------------------*/
2263
RprReadLynxResistor()2264 void RprReadLynxResistor()
2265
2266 {
2267 int Layer;
2268 int LayerCount;
2269 int Field;
2270 int EndTable;
2271 int EndRecord;
2272 char *FirstWord;
2273
2274 EndTable = 0;
2275 LayerCount = 0;
2276
2277 while ( ( EndTable != 1 ) &&
2278 ( LayerCount <= RDS_ALL_LAYER ) )
2279 {
2280 RprGetLine( RprBuffer, NO_FLAGS );
2281
2282 FirstWord = RprGetFirstWord( RprBuffer, 1 );
2283
2284 if ( FirstWord == EndTableKeyword )
2285 {
2286 EndTable = 1;
2287 }
2288 else
2289 if ( LayerCount < RDS_ALL_LAYER )
2290 {
2291 Layer = RprGetStringValue( FirstWord );
2292 EndRecord = 0;
2293 Field = 0;
2294
2295 while ( ( EndRecord != 1 ) &&
2296 ( Field < RDS_LYNX_RESISTOR_FIELD ) )
2297 {
2298 FirstWord = RprGetNextWord( 1 );
2299
2300 if ( FirstWord == EndRecordKeyword )
2301 {
2302 EndRecord = 1;
2303 }
2304 else
2305 {
2306 RDS_LYNX_RESISTOR_TABLE [ Layer ][ Field ] =
2307
2308 RprGetStringFloat( FirstWord );
2309
2310 Field = Field + 1;
2311 }
2312 }
2313
2314 if ( Field == RDS_LYNX_RESISTOR_FIELD )
2315 {
2316 FirstWord = RprGetNextWord( 0 );
2317
2318 if ( FirstWord != EndRecordKeyword )
2319 {
2320 rprerror( RPR_TOO_MANY_WORDS, FirstWord, RprCurrentLine );
2321 }
2322 }
2323 }
2324
2325 LayerCount = LayerCount + 1;
2326 }
2327
2328 if ( EndTable == 0 )
2329 {
2330 rprerror( RPR_LINE_EXPECTED, EndTableKeyword, RprCurrentLine);
2331 }
2332 }
2333
2334 /*------------------------------------------------------------\
2335 | |
2336 | Rpr Read Lynx Transistor |
2337 | |
2338 \------------------------------------------------------------*/
2339
RprReadLynxTransistor()2340 void RprReadLynxTransistor()
2341
2342 {
2343 int Layer;
2344 int LayerCount;
2345 int Field;
2346 int EndTable;
2347 int EndRecord;
2348 char *FirstWord;
2349
2350 EndTable = 0;
2351 LayerCount = 0;
2352
2353 while ( ( EndTable != 1 ) &&
2354 ( LayerCount <= MBK_MAX_LAYER ) )
2355 {
2356 RprGetLine( RprBuffer, NO_FLAGS );
2357
2358 FirstWord = RprGetFirstWord( RprBuffer, 1 );
2359
2360 if ( FirstWord == EndTableKeyword )
2361 {
2362 EndTable = 1;
2363 }
2364 else
2365 if ( LayerCount < MBK_MAX_LAYER )
2366 {
2367 Layer = RprGetStringValue( FirstWord );
2368 EndRecord = 0;
2369 Field = 0;
2370
2371 while ( ( EndRecord != 1 ) &&
2372 ( Field < RDS_LYNX_TRANSISTOR_FIELD ) )
2373 {
2374 FirstWord = RprGetNextWord( 1 );
2375
2376 if ( FirstWord == EndRecordKeyword )
2377 {
2378 if ( Field < RDS_LYNX_TRANSISTOR_FIELD )
2379 {
2380 rprerror( RPR_MISSING_VALUE, (char *)NULL, RprCurrentLine );
2381 }
2382
2383 EndRecord = 1;
2384 }
2385 else
2386 {
2387 RDS_LYNX_TRANSISTOR_TABLE [ Layer ][ Field ] = RprGetStringValue( FirstWord );
2388
2389 Field = Field + 1;
2390 }
2391 }
2392
2393 if ( Field == RDS_LYNX_TRANSISTOR_FIELD )
2394 {
2395 FirstWord = RprGetNextWord( 0 );
2396
2397 if ( FirstWord != EndRecordKeyword )
2398 {
2399 rprerror( RPR_TOO_MANY_WORDS, FirstWord, RprCurrentLine );
2400 }
2401 }
2402 }
2403
2404 LayerCount = LayerCount + 1;
2405 }
2406
2407 if ( EndTable == 0 )
2408 {
2409 rprerror( RPR_LINE_EXPECTED, EndTableKeyword, RprCurrentLine);
2410 }
2411 }
2412
2413 /*------------------------------------------------------------\
2414 | |
2415 | Rpr Read Lynx Bulk Implicit |
2416 | |
2417 \------------------------------------------------------------*/
2418
RprReadLynxBulkImplicit()2419 void RprReadLynxBulkImplicit()
2420
2421 {
2422 int Layer;
2423 int LayerCount;
2424 int Field;
2425 int EndTable;
2426 int EndRecord;
2427 char *FirstWord;
2428
2429 EndTable = 0;
2430 LayerCount = 0;
2431
2432 while ( ( EndTable != 1 ) &&
2433 ( LayerCount <= RDS_ALL_LAYER ) )
2434 {
2435 RprGetLine( RprBuffer, NO_FLAGS );
2436
2437 FirstWord = RprGetFirstWord( RprBuffer, 1 );
2438
2439 if ( FirstWord == EndTableKeyword )
2440 {
2441 EndTable = 1;
2442 }
2443 else
2444 if ( LayerCount < RDS_ALL_LAYER )
2445 {
2446 Layer = RprGetStringValue( FirstWord );
2447 EndRecord = 0;
2448 Field = 0;
2449
2450 while ( ( EndRecord != 1 ) &&
2451 ( Field < RDS_LYNX_BULK_IMPLICIT_FIELD ) )
2452 {
2453 FirstWord = RprGetNextWord( 1 );
2454
2455 if ( FirstWord == EndRecordKeyword )
2456 {
2457 if ( Field == 0 )
2458 {
2459 rprerror( RPR_MISSING_VALUE, (char *)NULL, RprCurrentLine );
2460 }
2461
2462 EndRecord = 1;
2463 }
2464 else
2465 {
2466 RDS_LYNX_BULK_IMPLICIT_TABLE[ Layer ][ Field ] = RprGetStringValue( FirstWord );
2467
2468 Field = Field + 1;
2469 }
2470 }
2471
2472 if ( Field == RDS_LYNX_BULK_IMPLICIT_FIELD )
2473 {
2474 FirstWord = RprGetNextWord( 0 );
2475
2476 if ( FirstWord != EndRecordKeyword )
2477 {
2478 rprerror( RPR_TOO_MANY_WORDS, FirstWord, RprCurrentLine );
2479 }
2480 }
2481 }
2482
2483 LayerCount = LayerCount + 1;
2484 }
2485
2486 if ( EndTable == 0 )
2487 {
2488 rprerror( RPR_LINE_EXPECTED, EndTableKeyword, RprCurrentLine);
2489 }
2490 }
2491 /*------------------------------------------------------------\
2492 | |
2493 | Rpr Read Parameters |
2494 | |
2495 \------------------------------------------------------------*/
2496
RprReadParam()2497 void RprReadParam()
2498
2499 {
2500 char *FirstWord;
2501 char *SecondWord;
2502 long Continue;
2503 double FloatValue;
2504
2505 Continue = 0;
2506
2507 while ( Continue != RPR_ALL_DEFINED_MASK )
2508 {
2509 RprGetLine( RprBuffer, CAN_REACH_EOF );
2510 if ( ( (Continue & RPR_ALL_REQUIRED_MASK) == RPR_ALL_REQUIRED_MASK )
2511 && ( RprBuffer[0] == '\0' ) ) break;
2512
2513 FirstWord = RprGetFirstWord( RprBuffer, 0);
2514
2515 if ( FirstWord == DefineKeyword )
2516 {
2517 FirstWord = RprGetNextWord( 1 );
2518
2519 if (! FirstWord )
2520 {
2521 rprerror( RPR_MISSING_NAME, DefineKeyword, RprCurrentLine );
2522 }
2523
2524 SecondWord = RprGetNextWord(1);
2525
2526 if (! SecondWord )
2527 {
2528 rprerror( RPR_MISSING_VALUE, SecondWord, RprCurrentLine );
2529 }
2530
2531 if ( FirstWord == PhysicalGridKeyword )
2532 {
2533 sscanf( SecondWord, "%32lf", &FloatValue);
2534
2535 RprComputeRdsUnit( FloatValue );
2536
2537 Continue |= RPR_PHYSICAL_GRID_MASK;
2538 }
2539 else
2540 if ( FirstWord == LambdaKeyword )
2541 {
2542 sscanf( SecondWord, "%32lf", &FloatValue);
2543
2544 if ( FloatValue <= 0 )
2545 {
2546 rprerror( RPR_NEGATIVE_VALUE, LambdaKeyword, RprCurrentLine );
2547 }
2548
2549 RDS_LAMBDA = RprTranslateParam( FloatValue );
2550 RDS_LAMBDA2 = RDS_LAMBDA * RDS_LAMBDA;
2551
2552 Continue |= RPR_LAMBDA_MASK;
2553 }
2554 else
2555 {
2556 rprerror( RPR_UNKNOWN_DEFINE, FirstWord, RprCurrentLine );
2557 }
2558 }
2559 else
2560 if ( FirstWord == TableKeyword )
2561 {
2562 if (!( FirstWord = RprGetNextWord(1)))
2563 {
2564 rprerror( RPR_MISSING_NAME, TableKeyword, RprCurrentLine );
2565 }
2566
2567 if ( FirstWord == S2RPostTreatKeyword )
2568 {
2569 RprReadS2RPostTreat();
2570
2571 Continue |= RPR_S2R_POST_TREAT_MASK;
2572 }
2573 else
2574 if ( FirstWord == SegmentKeyword )
2575 {
2576 RprReadSegment();
2577
2578 Continue |= RPR_SEGMENT_MASK;
2579 }
2580 else
2581 if ( FirstWord == ConnectorKeyword )
2582 {
2583 RprReadConnector();
2584
2585 Continue |= RPR_CONNECTOR_MASK;
2586 }else
2587 if ( FirstWord == ReferenceKeyword )
2588 {
2589 RprReadReference();
2590
2591 Continue |= RPR_REFERENCE_MASK;
2592 }
2593 else
2594 if ( FirstWord == ViaKeyword )
2595 {
2596 RprReadVia();
2597
2598 Continue |= RPR_VIA_MASK;
2599 }
2600 else
2601 if ( FirstWord == CifLayerKeyword )
2602 {
2603 RprReadCifLayer();
2604
2605 Continue |= RPR_CIF_LAYER_MASK;
2606 }
2607 else
2608 if ( FirstWord == GdsLayerKeyword )
2609 {
2610 RprReadGdsLayer();
2611
2612 Continue |= RPR_GDS_LAYER_MASK;
2613 }
2614 else
2615 if ( FirstWord == S2ROversizeKeyword )
2616 {
2617 RprReadS2ROversize();
2618
2619 Continue |= RPR_S2R_OVERSIZE_MASK;
2620 }
2621 else
2622 if ( FirstWord == S2RRingWidthKeyword )
2623 {
2624 RprReadS2RRingWidth();
2625
2626 Continue |= RPR_S2R_RING_WIDTH_MASK;
2627 }
2628 else
2629 if ( FirstWord == S2RLayerWidthKeyword )
2630 {
2631 RprReadS2RLayerWidth();
2632
2633 Continue |= RPR_S2R_LAYER_WIDTH_MASK;
2634 }
2635 else
2636 if ( FirstWord == LynxGraphKeyword )
2637 {
2638 RprReadLynxGraph();
2639
2640 Continue |= RPR_LYNX_GRAPH_MASK;
2641 }
2642 else
2643 if ( FirstWord == LynxDiffusionKeyword )
2644 {
2645 RprReadLynxDiffusion();
2646
2647 Continue |= RPR_LYNX_DIFFUSION_MASK;
2648 }
2649 else
2650 if ( FirstWord == LynxCapaKeyword )
2651 {
2652 RprReadLynxCapa();
2653
2654 Continue |= RPR_LYNX_CAPA_MASK;
2655 }
2656 else
2657 if ( FirstWord == LynxResistorKeyword )
2658 {
2659 RprReadLynxResistor();
2660
2661 Continue |= RPR_LYNX_RESISTOR_MASK;
2662 }
2663 else
2664 if ( FirstWord == LynxTransistorKeyword )
2665 {
2666 RprReadLynxTransistor();
2667
2668 Continue |= RPR_LYNX_TRANSISTOR_MASK;
2669 }
2670 else /*4p*/
2671 if ( FirstWord == LynxBulkImplicitKeyword ) /* */
2672 { /* */
2673 RprReadLynxBulkImplicit(); /* */
2674 /* */
2675 Continue |= RPR_LYNX_BULK_IMPLICIT_MASK; /* */
2676 } /*4p*/
2677 else /*4p*/
2678 if ( FirstWord == BigViaHoleKeyword )
2679 {
2680 RprReadBigViaHole();
2681
2682 Continue |= RPR_BIGVIA_HOLE_MASK;
2683 }
2684 else
2685 if ( FirstWord == BigViaMetalKeyword )
2686 {
2687 RprReadBigViaMetal();
2688
2689 Continue |= RPR_BIGVIA_METAL_MASK;
2690 }
2691 else
2692 if ( FirstWord == TurnViaKeyword )
2693 {
2694 RprReadTurnVia();
2695
2696 Continue |= RPR_TURNVIA_MASK;
2697 }
2698 else
2699 if ( FirstWord == WireSettingKeyword )
2700 {
2701 RprReadWireSetting();
2702
2703 Continue |= RPR_WIRESETTING_MASK;
2704 }
2705 else RprSkipTable();
2706 }
2707 else
2708 {
2709 if ( FirstWord != DrcRulesKeword )
2710 {
2711 rprerror( RPR_SYNTAX_ERROR, FirstWord, RprCurrentLine );
2712 }
2713 else
2714 {
2715 if ( (Continue & RPR_ALL_REQUIRED_MASK) == RPR_ALL_REQUIRED_MASK ) return;
2716 rprerror( RPR_UNEXPECTED_EOF, (char *)0, RprCurrentLine );
2717 }
2718 }
2719 }
2720 }
2721
2722 /*------------------------------------------------------------\
2723 | |
2724 | Rpr Post Parameters |
2725 | |
2726 \------------------------------------------------------------*/
2727
RprPostParam()2728 void RprPostParam()
2729
2730 {
2731 int Field;
2732 int Layer;
2733 int Dynamic;
2734 int Convert;
2735
2736 for ( Layer = RDS_LAYER_USER0; Layer <= RDS_LAYER_ABOX; Layer++ )
2737 {
2738 RDS_DYNAMIC_LAYER[ Layer ] = 1;
2739 }
2740
2741 Dynamic = 0;
2742
2743 for ( Layer = 0; Layer < RDS_ALL_LAYER; Layer++ )
2744 {
2745 if ( RDS_DYNAMIC_LAYER[ Layer ] == 1 )
2746 {
2747 RDS_DYNAMIC_LAYER[ Layer ] = Dynamic++;
2748 }
2749 }
2750
2751 RDS_MAX_LAYER = Dynamic;
2752
2753 if ( RDS_LAYER_NAME != RDS_ALL_LAYER_NAME )
2754 {
2755 rdsfreeblock( RDS_LAYER_NAME );
2756 }
2757
2758 if ( RDS_STATIC_LAYER != RDS_DYNAMIC_LAYER )
2759 {
2760 rdsfreeblock( RDS_STATIC_LAYER );
2761 }
2762
2763 RDS_LAYER_NAME = (char **)rdsallocblock( sizeof( char *) * RDS_MAX_LAYER );
2764 RDS_STATIC_LAYER = (unsigned char *)rdsallocblock( sizeof( char ) * RDS_MAX_LAYER );
2765
2766 for ( Layer = 0; Layer < RDS_ALL_LAYER; Layer++ )
2767 {
2768 Dynamic = RDS_DYNAMIC_LAYER[ Layer ];
2769
2770 if ( Dynamic != RDS_LAYER_UNUSED )
2771 {
2772 RDS_LAYER_NAME[ Dynamic ] = RDS_ALL_LAYER_NAME[ Layer ];
2773 RDS_STATIC_LAYER[ Dynamic ] = Layer;
2774
2775 for ( Field = 0; Field < RDS_S2R_POST_TREAT_FIELD; Field++ )
2776 {
2777 Convert = RDS_S2R_POST_TREAT_TABLE [ Layer ][ Field ];
2778
2779 if ( ( Field == 1 ) &&
2780 ( Convert != RDS_S2R_POST_TREAT_EMPTY ) )
2781 {
2782 Convert = RDS_DYNAMIC_LAYER[ Convert ];
2783 }
2784
2785 RDS_S2R_POST_TREAT_TABLE [ Dynamic ][ Field ] = Convert;
2786 }
2787
2788 for ( Field = 0; Field < RDS_GDS_LAYER_FIELD; Field++ )
2789 {
2790 RDS_GDS_LAYER_TABLE [ Dynamic ][ Field ] =
2791 RDS_GDS_LAYER_TABLE [ Layer ][ Field ];
2792 }
2793
2794 for ( Field = 0; Field < RDS_CIF_LAYER_FIELD; Field++ )
2795 {
2796 RDS_CIF_LAYER_TABLE [ Dynamic ][ Field ] =
2797 RDS_CIF_LAYER_TABLE [ Layer ][ Field ];
2798 }
2799
2800 for ( Field = 0; Field < RDS_LYNX_BULK_IMPLICIT_FIELD; Field++ ) /*4p*/
2801 { /* */
2802 RDS_LYNX_BULK_IMPLICIT_TABLE [ Dynamic ][ Field ] = /* */
2803 RDS_LYNX_BULK_IMPLICIT_TABLE [ Layer ][ Field ]; /* */
2804 } /*4p*/
2805
2806 for ( Field = 0; Field < RDS_S2R_OVERSIZE_FIELD; Field++ )
2807 {
2808 RDS_S2R_OVERSIZE_TABLE [ Dynamic ][ Field ] =
2809 RDS_S2R_OVERSIZE_TABLE [ Layer ][ Field ];
2810 }
2811
2812 for ( Field = 0; Field < RDS_S2R_RING_WIDTH_FIELD; Field++ )
2813 {
2814 RDS_S2R_RING_WIDTH_TABLE [ Dynamic ][ Field ] =
2815 RDS_S2R_RING_WIDTH_TABLE [ Layer ][ Field ];
2816 }
2817
2818 for ( Field = 0; Field < RDS_S2R_LAYER_WIDTH_FIELD; Field++ )
2819 {
2820 RDS_S2R_LAYER_WIDTH_TABLE [ Dynamic ][ Field ] =
2821 RDS_S2R_LAYER_WIDTH_TABLE [ Layer ][ Field ];
2822 }
2823
2824 for ( Field = 0; Field < RDS_LYNX_GRAPH_FIELD; Field++ )
2825 {
2826 Convert = RDS_LYNX_GRAPH_TABLE [ Layer ][ Field ];
2827
2828 if ( Convert != RDS_LYNX_GRAPH_EMPTY )
2829 {
2830 Convert = RDS_DYNAMIC_LAYER[ Convert ];
2831 }
2832
2833 RDS_LYNX_GRAPH_TABLE [ Dynamic ][ Field ] = Convert;
2834 }
2835
2836 for ( Field = 0; Field < RDS_LYNX_DIFFUSION_FIELD; Field++ )
2837 {
2838 Convert = RDS_LYNX_DIFFUSION_TABLE [ Layer ][ Field ];
2839
2840 if ( ( Field & 0x1 ) == 0 )
2841 {
2842 if ( Convert != RDS_LYNX_DIFFUSION_EMPTY )
2843 {
2844 Convert = RDS_DYNAMIC_LAYER[ Convert ];
2845 }
2846 }
2847
2848 RDS_LYNX_DIFFUSION_TABLE [ Dynamic ][ Field ] = Convert;
2849 }
2850
2851 for ( Field = 0; Field < RDS_LYNX_CAPA_FIELD; Field++ )
2852 {
2853 RDS_LYNX_CAPA_TABLE[ Dynamic ][ Field ] =
2854 RDS_LYNX_CAPA_TABLE[ Layer ][ Field ];
2855 }
2856
2857 for ( Field = 0; Field < RDS_LYNX_RESISTOR_FIELD; Field++ )
2858 {
2859 RDS_LYNX_RESISTOR_TABLE[ Dynamic ][ Field ] =
2860 RDS_LYNX_RESISTOR_TABLE[ Layer ][ Field ];
2861 }
2862 }
2863 }
2864
2865 for ( Layer = 0; Layer < MBK_MAX_LAYER; Layer++ )
2866 {
2867 for ( Field = 0; Field < RDS_SEGMENT_FIELD; Field++ )
2868 {
2869 if ( Field % 6 == 0 )
2870 {
2871 Convert = RDS_SEGMENT_TABLE [ Layer ][ Field ];
2872
2873 if ( Convert != RDS_SEGMENT_EMPTY )
2874 {
2875 RDS_SEGMENT_TABLE[ Layer ][ Field ] = RDS_DYNAMIC_LAYER[ Convert ];
2876 }
2877 }
2878 }
2879
2880 for ( Field = 0; Field < RDS_LYNX_TRANSISTOR_FIELD; Field++ )
2881 {
2882 if ( Field >= 2 )
2883 {
2884 Convert = RDS_LYNX_TRANSISTOR_TABLE [ Layer ][ Field ];
2885
2886 if ( Convert != RDS_LYNX_TRANSISTOR_EMPTY )
2887 {
2888 RDS_LYNX_TRANSISTOR_TABLE[ Layer ][ Field ] = RDS_DYNAMIC_LAYER[ Convert ];
2889 }
2890 }
2891 }
2892
2893 for ( Field = 0; Field < RDS_CONNECTOR_FIELD; Field++ )
2894 {
2895 if ( Field == 0 )
2896 {
2897 Convert = RDS_CONNECTOR_TABLE [ Layer ][ Field ];
2898
2899 if ( Convert != RDS_CONNECTOR_EMPTY )
2900 {
2901 RDS_CONNECTOR_TABLE [ Layer ][ Field ] = RDS_DYNAMIC_LAYER[ Convert ];
2902 }
2903 }
2904 }
2905 }
2906
2907 for ( Layer = 0; Layer < MBK_MAX_REFERENCE; Layer++ )
2908 {
2909 for ( Field = 0; Field < RDS_REFERENCE_FIELD; Field++ )
2910 {
2911 if ( ( Field & 1 ) == 0 )
2912 {
2913 Convert = RDS_REFERENCE_TABLE [ Layer ][ Field ];
2914
2915 if ( Convert != RDS_REFERENCE_EMPTY )
2916 {
2917 RDS_REFERENCE_TABLE [ Layer ][ Field ] = RDS_DYNAMIC_LAYER[ Convert ];
2918 }
2919 }
2920 }
2921 }
2922
2923 for ( Layer = 0; Layer < MBK_MAX_VIA; Layer++ )
2924 {
2925 for ( Field = 0; Field < RDS_VIA_FIELD; Field++ )
2926 {
2927 if ( Field % 3 == 0 )
2928 {
2929 Convert = RDS_VIA_TABLE [ Layer ][ Field ];
2930
2931 if ( Convert != RDS_VIA_EMPTY )
2932 {
2933 RDS_VIA_TABLE [ Layer ][ Field ] = RDS_DYNAMIC_LAYER[ Convert ];
2934 }
2935 }
2936 }
2937 }
2938
2939 for ( Layer = 0; Layer < MBK_MAX_VIA; Layer++ )
2940 {
2941 for ( Field = 0; Field < RDS_BIGVIA_HOLE_FIELD; Field++ )
2942 {
2943 if ( Field % 4 == 0 )
2944 {
2945 Convert = RDS_BIGVIA_HOLE_TABLE [ Layer ][ Field ];
2946
2947 if ( Convert != RDS_BIGVIA_HOLE_EMPTY )
2948 {
2949 RDS_BIGVIA_HOLE_TABLE [ Layer ][ Field ] = RDS_DYNAMIC_LAYER[ Convert ];
2950 }
2951 }
2952 }
2953 }
2954
2955 for ( Layer = 0; Layer < MBK_MAX_VIA; Layer++ )
2956 {
2957 for ( Field = 0; Field < RDS_BIGVIA_METAL_FIELD; Field++ )
2958 {
2959 if ( Field % 4 == 0 )
2960 {
2961 Convert = RDS_BIGVIA_METAL_TABLE [ Layer ][ Field ];
2962
2963 if ( Convert != RDS_BIGVIA_METAL_EMPTY )
2964 {
2965 RDS_BIGVIA_METAL_TABLE [ Layer ][ Field ] = RDS_DYNAMIC_LAYER[ Convert ];
2966 }
2967 }
2968 }
2969 }
2970
2971 for ( Layer = 0; Layer < MBK_MAX_VIA; Layer++ )
2972 {
2973 for ( Field = 0; Field < RDS_TURNVIA_FIELD; Field++ )
2974 {
2975 if ( Field % 3 == 0 )
2976 {
2977 Convert = RDS_TURNVIA_TABLE [ Layer ][ Field ];
2978
2979 if ( Convert != RDS_TURNVIA_EMPTY )
2980 {
2981 RDS_TURNVIA_TABLE [ Layer ][ Field ] = RDS_DYNAMIC_LAYER[ Convert ];
2982 }
2983 }
2984 }
2985 }
2986 }
2987
2988 /*------------------------------------------------------------\
2989 | |
2990 | Rds Load Parameters |
2991 | |
2992 \------------------------------------------------------------*/
2993
loadrdsparam()2994 void loadrdsparam()
2995
2996 {
2997 int Field;
2998 int Layer;
2999
3000 if ( ! KeywordDefined )
3001 {
3002 DefineKeyword = namealloc( DEFINE_KEYWORD );
3003 TableKeyword = namealloc( TABLE_KEYWORD );
3004 EndTableKeyword = namealloc( END_TABLE_KEYWORD );
3005 EndRecordKeyword = namealloc( END_RECORD_KEYWORD );
3006 LambdaKeyword = namealloc( LAMBDA_KEYWORD );
3007 PhysicalGridKeyword = namealloc( PHYSICAL_GRID_KEYWORD );
3008 SegmentKeyword = namealloc( SEGMENT_KEYWORD );
3009 ViaKeyword = namealloc( VIA_KEYWORD );
3010 ConnectorKeyword = namealloc( CONNECTOR_KEYWORD );
3011 ReferenceKeyword = namealloc( REFERENCE_KEYWORD );
3012 CifLayerKeyword = namealloc( CIF_LAYER_KEYWORD );
3013 GdsLayerKeyword = namealloc( GDS_LAYER_KEYWORD );
3014 S2ROversizeKeyword = namealloc( S2R_OVERSIZE_KEYWORD );
3015 S2RRingWidthKeyword = namealloc( S2R_RING_WIDTH_KEYWORD );
3016 S2RLayerWidthKeyword = namealloc( S2R_LAYER_WIDTH_KEYWORD );
3017 S2RPostTreatKeyword = namealloc( S2R_POST_TREAT_KEYWORD );
3018 LynxGraphKeyword = namealloc( LYNX_GRAPH_KEYWORD );
3019 LynxCapaKeyword = namealloc( LYNX_CAPA_KEYWORD );
3020 LynxResistorKeyword = namealloc( LYNX_RESISTOR_KEYWORD );
3021 LynxTransistorKeyword = namealloc( LYNX_TRANSISTOR_KEYWORD );
3022 LynxDiffusionKeyword = namealloc( LYNX_DIFFUSION_KEYWORD );
3023 LynxBulkImplicitKeyword = namealloc( LYNX_BULK_IMPLICIT_KEYWORD ); /*4p*/
3024 BigViaHoleKeyword = namealloc( BIGVIA_HOLE_KEYWORD );
3025 BigViaMetalKeyword = namealloc( BIGVIA_METAL_KEYWORD );
3026 TurnViaKeyword = namealloc( TURNVIA_KEYWORD );
3027
3028 DrcRulesKeword = namealloc( DRC_RULES_KEYWORD );
3029 WireSettingKeyword = namealloc( WIRESETTING_KEYWORD );
3030
3031 KeywordDefined = 1;
3032 }
3033
3034 RDS_UNIT = -1;
3035
3036 for ( Layer = 0; Layer < RDS_ALL_LAYER; Layer++ )
3037 {
3038 RDS_DYNAMIC_LAYER[ Layer ] = RDS_LAYER_UNUSED;
3039
3040 for ( Field = 0; Field < RDS_S2R_POST_TREAT_FIELD; Field++ )
3041 {
3042 RDS_S2R_POST_TREAT_TABLE [ Layer ][ Field ] = RDS_S2R_POST_TREAT_EMPTY;
3043 }
3044
3045 for ( Field = 0; Field < RDS_GDS_LAYER_FIELD; Field++ )
3046 {
3047 RDS_GDS_LAYER_TABLE [ Layer ][ Field ] = RDS_GDS_LAYER_EMPTY;
3048 }
3049
3050 for ( Field = 0; Field < RDS_CIF_LAYER_FIELD; Field++ )
3051 {
3052 RDS_CIF_LAYER_TABLE [ Layer ][ Field ] = RDS_CIF_LAYER_EMPTY;
3053 }
3054
3055 for ( Field = 0; Field < RDS_S2R_OVERSIZE_FIELD; Field++ )
3056 {
3057 RDS_S2R_OVERSIZE_TABLE [ Layer ][ Field ] = RDS_S2R_OVERSIZE_EMPTY;
3058 }
3059
3060 for ( Field = 0; Field < RDS_S2R_RING_WIDTH_FIELD; Field++ )
3061 {
3062 RDS_S2R_RING_WIDTH_TABLE [ Layer ][ Field ] = RDS_S2R_RING_WIDTH_EMPTY;
3063 }
3064
3065 for ( Field = 0; Field < RDS_S2R_LAYER_WIDTH_FIELD; Field++ )
3066 {
3067 RDS_S2R_LAYER_WIDTH_TABLE [ Layer ][ Field ] = RDS_S2R_LAYER_WIDTH_EMPTY;
3068 }
3069
3070
3071 for ( Field = 0; Field < RDS_LYNX_BULK_IMPLICIT_FIELD; Field++ ) /*4p*/
3072 { /* */
3073 RDS_LYNX_BULK_IMPLICIT_TABLE [ Layer ][ Field ] = /* */
3074 RDS_LYNX_BULK_IMPLICIT_EMPTY; /* */
3075 } /*4p*/
3076
3077 for ( Field = 0; Field < RDS_LYNX_GRAPH_FIELD; Field++ )
3078 {
3079 RDS_LYNX_GRAPH_TABLE [ Layer ][ Field ] = RDS_LYNX_GRAPH_EMPTY;
3080 }
3081
3082 for ( Field = 0; Field < RDS_LYNX_DIFFUSION_FIELD; Field++ )
3083 {
3084 RDS_LYNX_DIFFUSION_TABLE [ Layer ][ Field ] = RDS_LYNX_DIFFUSION_EMPTY;
3085 }
3086
3087 for ( Field = 0; Field < RDS_LYNX_CAPA_FIELD; Field++ )
3088 {
3089 RDS_LYNX_CAPA_TABLE[ Layer ][ Field ] = RDS_LYNX_CAPA_EMPTY;
3090 }
3091 }
3092
3093 for ( Layer = 0; Layer < MBK_MAX_LAYER; Layer++ )
3094 {
3095 for ( Field = 0; Field < RDS_SEGMENT_FIELD; Field++ )
3096 {
3097 RDS_SEGMENT_TABLE [ Layer ][ Field ] = RDS_SEGMENT_EMPTY;
3098 }
3099
3100 for ( Field = 0; Field < RDS_LYNX_TRANSISTOR_FIELD; Field++ )
3101 {
3102 RDS_LYNX_TRANSISTOR_TABLE [ Layer ][ Field ] = RDS_LYNX_TRANSISTOR_EMPTY;
3103 }
3104
3105 for ( Field = 0; Field < RDS_CONNECTOR_FIELD; Field++ )
3106 {
3107 RDS_CONNECTOR_TABLE [ Layer ][ Field ] = RDS_CONNECTOR_EMPTY;
3108 }
3109 }
3110
3111 for ( Layer = 0; Layer < MBK_MAX_REFERENCE; Layer++ )
3112 {
3113 for ( Field = 0; Field < RDS_REFERENCE_FIELD; Field++ )
3114 {
3115 RDS_REFERENCE_TABLE [ Layer ][ Field ] = RDS_REFERENCE_EMPTY;
3116 }
3117 }
3118
3119 for ( Layer = 0; Layer < MBK_MAX_VIA; Layer++ )
3120 {
3121 for ( Field = 0; Field < RDS_VIA_FIELD; Field++ )
3122 {
3123 RDS_VIA_TABLE [ Layer ][ Field ] = RDS_VIA_EMPTY;
3124 }
3125 }
3126
3127 for ( Layer = 0; Layer < MBK_MAX_VIA; Layer++ )
3128 {
3129 for ( Field = 0; Field < RDS_BIGVIA_HOLE_FIELD; Field++ )
3130 {
3131 RDS_BIGVIA_HOLE_TABLE [ Layer ][ Field ] = RDS_BIGVIA_HOLE_EMPTY;
3132 }
3133 }
3134
3135 for ( Layer = 0; Layer < MBK_MAX_VIA; Layer++ )
3136 {
3137 for ( Field = 0; Field < RDS_BIGVIA_METAL_FIELD; Field++ )
3138 {
3139 RDS_BIGVIA_METAL_TABLE [ Layer ][ Field ] = RDS_BIGVIA_METAL_EMPTY;
3140 }
3141 }
3142
3143 for ( Layer = 0; Layer < MBK_MAX_VIA; Layer++ )
3144 {
3145 for ( Field = 0; Field < RDS_TURNVIA_FIELD; Field++ )
3146 {
3147 RDS_TURNVIA_TABLE [ Layer ][ Field ] = RDS_TURNVIA_EMPTY;
3148 }
3149 }
3150
3151 if ( !( RprFile = fopen( RDS_TECHNO_NAME, "r")))
3152
3153 rprerror( RPR_OPEN_FILE, NULL, 0);
3154
3155 RprReadParam();
3156 RprPostParam();
3157
3158 fclose( RprFile );
3159 }
3160