1 // *****************************************************************************
2 // *****************************************************************************
3 // Copyright 2012 - 2017, Cadence Design Systems
4 //
5 // This file is part of the Cadence LEF/DEF Open Source
6 // Distribution, Product Version 5.8.
7 //
8 // Licensed under the Apache License, Version 2.0 (the "License");
9 // you may not use this file except in compliance with the License.
10 // You may obtain a copy of the License at
11 //
12 // http://www.apache.org/licenses/LICENSE-2.0
13 //
14 // Unless required by applicable law or agreed to in writing, software
15 // distributed under the License is distributed on an "AS IS" BASIS,
16 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
17 // implied. See the License for the specific language governing
18 // permissions and limitations under the License.
19 //
20 // For updates, support, or to become part of the LEF/DEF Community,
21 // check www.openeda.org for details.
22 //
23 // $Author: dell $
24 // $Revision: #1 $
25 // $Date: 2017/06/06 $
26 // $State: $
27 // *****************************************************************************
28 // *****************************************************************************
29 #include "lefrReader.hpp"
30 #include "lex.h"
31 #include <stdlib.h>
32 #include <string.h>
33
34 #include "lefiDebug.hpp"
35 #include "lefrData.hpp"
36 #include "lefrSettings.hpp"
37 #include "lefrCallBacks.hpp"
38
39 #define NOCBK 100
40 #define NOLEFMSG 4701 // 4701 = 4700 + 1, message starts on 1
41
42 # define LEF_INIT lef_init(__FUNCTION__)
43
44 BEGIN_LEFDEF_PARSER_NAMESPACE
45
46 static const char *init_call_func = NULL;
47
48 void
lef_init(const char * func)49 lef_init(const char *func)
50 {
51 if (lefSettings == NULL) {
52 lefrSettings::reset();
53 init_call_func = func;
54 }
55
56 if (lefCallbacks == NULL) {
57 lefrCallbacks::reset();
58 init_call_func = func;
59 }
60 }
61
62
63 void
lefiNerr(int i)64 lefiNerr(int i)
65 {
66 sprintf(lefData->lefrErrMsg, "ERROR number %d\n", i);
67 lefiError(1, 0, lefData->lefrErrMsg);
68 exit(2);
69 }
70
71 void
lefiNwarn(int i)72 lefiNwarn(int i)
73 {
74 sprintf(lefData->lefrErrMsg, "WARNING number %d\n", i);
75 lefiError(1, 0, lefData->lefrErrMsg);
76 exit(2);
77 }
78
79 double
convert_name2num(const char * versionName)80 convert_name2num(const char *versionName)
81 {
82 char majorNm[80];
83 char minorNm[80];
84 char *subMinorNm = NULL;
85
86 char *versionNm = strdup(versionName);
87
88 double major = 0, minor = 0, subMinor = 0;
89 double version, versionNumber;
90 char finalVersion[80];
91
92 sscanf(versionNm, "%[^.].%s", majorNm, minorNm);
93 char *p1 = strchr(minorNm, '.');
94 if (p1) {
95 subMinorNm = p1 + 1;
96 *p1 = '\0';
97 }
98 major = atof(majorNm);
99 minor = atof(minorNm);
100 if (subMinorNm)
101 subMinor = atof(subMinorNm);
102
103 version = major;
104
105 if (minor > 0)
106 version = major + minor / 10;
107
108 if (subMinor > 0)
109 version = version + subMinor / 1000;
110
111 lefFree(versionNm);
112
113 sprintf(finalVersion, "%.4f", version);
114
115 versionNumber = atof(finalVersion);
116
117 return versionNumber;
118 }
119
120 bool
validateMaskNumber(int num)121 validateMaskNumber(int num)
122 {
123 int digit = 0;
124 int index = 0;
125
126 if (num < 0) {
127 return false;
128 }
129
130 while (num > 0) {
131 digit = num % 10;
132
133 if (digit > 3) {
134 return false;
135 }
136
137 index++;
138 num = num / 10;
139 }
140
141 if (index > 3) {
142 return false;
143 }
144
145 return true;
146 }
147
148 // *****************************************************************************s
149 // Global variables
150 // *****************************************************************************
151
152 // 5.6 END LIBRARY is optional.
153 // Function to initialize global variables.
154 // This make sure the global variables are initialized
155
156 // User control warning to be printed by the parser
157 void
lefrDisableParserMsgs(int nMsg,int * msgs)158 lefrDisableParserMsgs(int nMsg,
159 int *msgs)
160 {
161 LEF_INIT;
162 if (nMsg <= 0)
163 return;
164
165 for (int i = 0; i < nMsg; i++) {
166 lefSettings->disableMsg(msgs[i]);
167 }
168 }
169
170 void
lefrEnableParserMsgs(int nMsg,int * msgs)171 lefrEnableParserMsgs(int nMsg,
172 int *msgs)
173 {
174 LEF_INIT;
175 for (int i = 0; i < nMsg; i++) {
176 lefSettings->enableMsg(msgs[i]);
177 }
178 }
179
180 void
lefrEnableAllMsgs()181 lefrEnableAllMsgs()
182 {
183 LEF_INIT;
184 lefSettings->enableAllMsgs();
185 lefSettings->dAllMsgs = 0;
186 }
187
188 void
lefrSetTotalMsgLimit(int totNumMsgs)189 lefrSetTotalMsgLimit(int totNumMsgs)
190 {
191 LEF_INIT;
192 lefSettings->TotalMsgLimit = totNumMsgs;
193 }
194
195 void
lefrSetLimitPerMsg(int msgId,int numMsg)196 lefrSetLimitPerMsg(int msgId,
197 int numMsg)
198 {
199 LEF_INIT;
200
201 if ((msgId > 0) && (msgId < NOLEFMSG)) {
202 lefSettings->MsgLimit[msgId] = numMsg;
203 }
204 }
205
206 // *****************************************************************************
207 // Since the lef parser only keep one list of disable message ids, and does
208 // not have a list of enable message ids, if the API lefrDisableAllMsgs is
209 // called to disable all message ids, user has to call API lefrEnableAllMsgs
210 // to enable all message ids lefData->first, before calling lefrDisableParserMsgs &
211 // lefrEnableParserMsgs.
212 // Users cannot call lefrDisableAllMsgs and call lefrEnableParserMsgs to
213 // enable a small list of message ids since lefrDisableAllMsgs does not have
214 // a list of all message ids, hence there isn't a list for lefrEnableParserMsgs
215 // to work on to enable the message ids.
216 // *****************************************************************************
217 void
lefrDisableAllMsgs()218 lefrDisableAllMsgs()
219 {
220 LEF_INIT;
221 lefSettings->enableAllMsgs();
222 lefSettings->dAllMsgs = 1;
223 }
224
225 // Parser control by the user.
226 // Reader initialization
227 int
lefrInit()228 lefrInit()
229 {
230 return lefrInitSession(0);
231 }
232
233 int
lefrInitSession(int startSession)234 lefrInitSession(int startSession)
235 {
236 if (startSession) {
237 if (init_call_func != NULL) {
238 fprintf(stderr, "ERROR: Attempt to call configuration function '%s' in LEF parser before lefrInit() call in session-based mode.\n", init_call_func);
239 return 1;
240 }
241
242 lefrCallbacks::reset();
243 lefrSettings::reset();
244 } else {
245 if (lefCallbacks == NULL) {
246 lefrCallbacks::reset();
247 }
248
249 if (lefSettings == NULL) {
250 lefrSettings::reset();
251 }
252 }
253
254 return 0;
255 }
256
257 int
lefrReset()258 lefrReset()
259 {
260 // obsoleted.
261 return 0;
262 }
263
264
265 int
lefrClear()266 lefrClear()
267 {
268 delete lefData;
269 lefData = NULL;
270
271 delete lefCallbacks;
272 lefCallbacks = NULL;
273
274 delete lefSettings;
275 lefSettings = NULL;
276
277 return 0;
278 }
279
280
281 const char *
lefrFName()282 lefrFName()
283 {
284 return lefData->lefrFileName;
285 }
286
287 int
lefrReleaseNResetMemory()288 lefrReleaseNResetMemory()
289 {
290 return 0;
291 }
292
293 int
lefrRead(FILE * f,const char * fName,lefiUserData uData)294 lefrRead(FILE *f,
295 const char *fName,
296 lefiUserData uData)
297 {
298 LEF_INIT;
299 int status;
300
301 lefrData::reset();
302
303 lefData->versionNum = (lefSettings->VersionNum == 0.0) ?
304 CURRENT_VERSION :
305 lefSettings->VersionNum;
306
307 if (lefSettings->CaseSensitiveSet) {
308 lefData->namesCaseSensitive = lefSettings->CaseSensitive;
309 } else if (lefData->versionNum > 5.5) {
310 lefData->namesCaseSensitive = true;
311 }
312
313 lefData->lefrFileName = (char*) fName;
314 lefData->lefrFile = f;
315 lefSettings->UserData = uData;
316
317 status = lefyyparse();
318
319 return status;
320 }
321
322 void
lefrSetUnusedCallbacks(lefrVoidCbkFnType func)323 lefrSetUnusedCallbacks(lefrVoidCbkFnType func)
324 {
325 // Set all of the callbacks that have not been set yet to
326 // the given function.
327 LEF_INIT;
328
329 if (lefCallbacks->ArrayBeginCbk == 0)
330 lefCallbacks->ArrayBeginCbk = (lefrStringCbkFnType) func;
331 if (lefCallbacks->ArrayCbk == 0)
332 lefCallbacks->ArrayCbk = (lefrArrayCbkFnType) func;
333 if (lefCallbacks->ArrayEndCbk == 0)
334 lefCallbacks->ArrayEndCbk = (lefrStringCbkFnType) func;
335 if (lefCallbacks->DividerCharCbk == 0)
336 lefCallbacks->DividerCharCbk = (lefrStringCbkFnType) func;
337 if (lefCallbacks->BusBitCharsCbk == 0)
338 lefCallbacks->BusBitCharsCbk = (lefrStringCbkFnType) func;
339 if (lefCallbacks->CaseSensitiveCbk == 0)
340 lefCallbacks->CaseSensitiveCbk = (lefrIntegerCbkFnType) func;
341 if (lefCallbacks->NoWireExtensionCbk == 0)
342 lefCallbacks->NoWireExtensionCbk = (lefrStringCbkFnType) func;
343 if (lefCallbacks->CorrectionTableCbk == 0)
344 lefCallbacks->CorrectionTableCbk = (lefrCorrectionTableCbkFnType) func;
345 if (lefCallbacks->DielectricCbk == 0)
346 lefCallbacks->DielectricCbk = (lefrDoubleCbkFnType) func;
347 if (lefCallbacks->EdgeRateScaleFactorCbk == 0)
348 lefCallbacks->EdgeRateScaleFactorCbk = (lefrDoubleCbkFnType) func;
349 if (lefCallbacks->EdgeRateThreshold1Cbk == 0)
350 lefCallbacks->EdgeRateThreshold1Cbk = (lefrDoubleCbkFnType) func;
351 if (lefCallbacks->EdgeRateThreshold2Cbk == 0)
352 lefCallbacks->EdgeRateThreshold2Cbk = (lefrDoubleCbkFnType) func;
353 if (lefCallbacks->IRDropBeginCbk == 0)
354 lefCallbacks->IRDropBeginCbk = (lefrVoidCbkFnType) func;
355 if (lefCallbacks->IRDropCbk == 0)
356 lefCallbacks->IRDropCbk = (lefrIRDropCbkFnType) func;
357 if (lefCallbacks->IRDropEndCbk == 0)
358 lefCallbacks->IRDropEndCbk = (lefrVoidCbkFnType) func;
359 if (lefCallbacks->LayerCbk == 0)
360 lefCallbacks->LayerCbk = (lefrLayerCbkFnType) func;
361 if (lefCallbacks->LibraryEndCbk == 0)
362 lefCallbacks->LibraryEndCbk = (lefrVoidCbkFnType) func;
363 if (lefCallbacks->MacroBeginCbk == 0)
364 lefCallbacks->MacroBeginCbk = (lefrStringCbkFnType) func;
365 if (lefCallbacks->MacroCbk == 0)
366 lefCallbacks->MacroCbk = (lefrMacroCbkFnType) func;
367 if (lefCallbacks->MacroClassTypeCbk == 0)
368 lefCallbacks->MacroClassTypeCbk = (lefrStringCbkFnType) func;
369 if (lefCallbacks->MacroOriginCbk == 0)
370 lefCallbacks->MacroOriginCbk = (lefrMacroNumCbkFnType) func;
371 if (lefCallbacks->MacroSiteCbk == 0)
372 lefCallbacks->MacroSiteCbk = (lefrMacroSiteCbkFnType) func;
373 if (lefCallbacks->MacroForeignCbk == 0)
374 lefCallbacks->MacroForeignCbk = (lefrMacroForeignCbkFnType) func;
375 if (lefCallbacks->MacroSizeCbk == 0)
376 lefCallbacks->MacroSizeCbk = (lefrMacroNumCbkFnType) func;
377 if (lefCallbacks->MacroFixedMaskCbk == 0)
378 lefCallbacks->MacroFixedMaskCbk = (lefrIntegerCbkFnType) func;
379 if (lefCallbacks->TimingCbk == 0)
380 lefCallbacks->TimingCbk = (lefrTimingCbkFnType) func;
381 if (lefCallbacks->MinFeatureCbk == 0)
382 lefCallbacks->MinFeatureCbk = (lefrMinFeatureCbkFnType) func;
383 if (lefCallbacks->NoiseMarginCbk == 0)
384 lefCallbacks->NoiseMarginCbk = (lefrNoiseMarginCbkFnType) func;
385 if (lefCallbacks->NoiseTableCbk == 0)
386 lefCallbacks->NoiseTableCbk = (lefrNoiseTableCbkFnType) func;
387 if (lefCallbacks->NonDefaultCbk == 0)
388 lefCallbacks->NonDefaultCbk = (lefrNonDefaultCbkFnType) func;
389 if (lefCallbacks->ObstructionCbk == 0)
390 lefCallbacks->ObstructionCbk = (lefrObstructionCbkFnType) func;
391 if (lefCallbacks->PinCbk == 0)
392 lefCallbacks->PinCbk = (lefrPinCbkFnType) func;
393 if (lefCallbacks->PropBeginCbk == 0)
394 lefCallbacks->PropBeginCbk = (lefrVoidCbkFnType) func;
395 if (lefCallbacks->PropCbk == 0)
396 lefCallbacks->PropCbk = (lefrPropCbkFnType) func;
397 if (lefCallbacks->PropEndCbk == 0)
398 lefCallbacks->PropEndCbk = (lefrVoidCbkFnType) func;
399 if (lefCallbacks->SiteCbk == 0)
400 lefCallbacks->SiteCbk = (lefrSiteCbkFnType) func;
401 if (lefCallbacks->SpacingBeginCbk == 0)
402 lefCallbacks->SpacingBeginCbk = (lefrVoidCbkFnType) func;
403 if (lefCallbacks->SpacingCbk == 0)
404 lefCallbacks->SpacingCbk = (lefrSpacingCbkFnType) func;
405 if (lefCallbacks->SpacingEndCbk == 0)
406 lefCallbacks->SpacingEndCbk = (lefrVoidCbkFnType) func;
407 if (lefCallbacks->UnitsCbk == 0)
408 lefCallbacks->UnitsCbk = (lefrUnitsCbkFnType) func;
409 if ((lefCallbacks->VersionCbk == 0) && (lefCallbacks->VersionStrCbk == 0)) {
410 // both version callbacks weren't set, if either one is set, it is ok
411 lefCallbacks->VersionCbk = (lefrDoubleCbkFnType) func;
412 lefCallbacks->VersionStrCbk = (lefrStringCbkFnType) func;
413 }
414 if (lefCallbacks->ViaCbk == 0)
415 lefCallbacks->ViaCbk = (lefrViaCbkFnType) func;
416 if (lefCallbacks->ViaRuleCbk == 0)
417 lefCallbacks->ViaRuleCbk = (lefrViaRuleCbkFnType) func;
418 if (lefCallbacks->InputAntennaCbk == 0)
419 lefCallbacks->InputAntennaCbk = (lefrDoubleCbkFnType) func;
420 if (lefCallbacks->OutputAntennaCbk == 0)
421 lefCallbacks->OutputAntennaCbk = (lefrDoubleCbkFnType) func;
422 if (lefCallbacks->InoutAntennaCbk == 0)
423 lefCallbacks->InoutAntennaCbk = (lefrDoubleCbkFnType) func;
424
425 // NEW CALLBACK - Add a line here for each new callback routine
426 if (lefCallbacks->AntennaInputCbk == 0)
427 lefCallbacks->AntennaInputCbk = (lefrDoubleCbkFnType) func;
428 if (lefCallbacks->AntennaInoutCbk == 0)
429 lefCallbacks->AntennaInoutCbk = (lefrDoubleCbkFnType) func;
430 if (lefCallbacks->AntennaOutputCbk == 0)
431 lefCallbacks->AntennaOutputCbk = (lefrDoubleCbkFnType) func;
432 if (lefCallbacks->ManufacturingCbk == 0)
433 lefCallbacks->ManufacturingCbk = (lefrDoubleCbkFnType) func;
434 if (lefCallbacks->UseMinSpacingCbk == 0)
435 lefCallbacks->UseMinSpacingCbk = (lefrUseMinSpacingCbkFnType) func;
436 if (lefCallbacks->ClearanceMeasureCbk == 0)
437 lefCallbacks->ClearanceMeasureCbk = (lefrStringCbkFnType) func;
438 if (lefCallbacks->MacroClassTypeCbk == 0)
439 lefCallbacks->MacroClassTypeCbk = (lefrStringCbkFnType) func;
440 if (lefCallbacks->MacroOriginCbk == 0)
441 lefCallbacks->MacroOriginCbk = (lefrMacroNumCbkFnType) func;
442 if (lefCallbacks->MacroSiteCbk == 0)
443 lefCallbacks->MacroSiteCbk = (lefrMacroSiteCbkFnType) func;
444 if (lefCallbacks->MacroForeignCbk == 0)
445 lefCallbacks->MacroForeignCbk = (lefrMacroForeignCbkFnType) func;
446 if (lefCallbacks->MacroSizeCbk == 0)
447 lefCallbacks->MacroSizeCbk = (lefrMacroNumCbkFnType) func;
448 if (lefCallbacks->MacroFixedMaskCbk == 0)
449 lefCallbacks->MacroFixedMaskCbk = (lefrIntegerCbkFnType) func;
450 if (lefCallbacks->MacroEndCbk == 0)
451 lefCallbacks->MacroEndCbk = (lefrStringCbkFnType) func;
452 if (lefCallbacks->MaxStackViaCbk == 0)
453 lefCallbacks->MaxStackViaCbk = (lefrMaxStackViaCbkFnType) func;
454 if (lefCallbacks->ExtensionCbk == 0)
455 lefCallbacks->ExtensionCbk = (lefrStringCbkFnType) func;
456 if (lefCallbacks->DensityCbk == 0)
457 lefCallbacks->DensityCbk = (lefrDensityCbkFnType) func;
458 if (lefCallbacks->FixedMaskCbk == 0)
459 lefCallbacks->FixedMaskCbk = (lefrIntegerCbkFnType) func;
460 }
461
462 // These count up the number of times an unset callback is called...
463 static int lefrUnusedCount[NOCBK];
464
465 int
lefrCountFunc(lefrCallbackType_e e,void * v,lefiUserData d)466 lefrCountFunc(lefrCallbackType_e e,
467 void *v,
468 lefiUserData d)
469 {
470 LEF_INIT;
471 int i = (int) e;
472 if (lefiDebug(23))
473 printf("count %d 0x%p 0x%p\n", (int) e, v, d);
474 if (i >= 0 && i < NOCBK) {
475 lefrUnusedCount[i] += 1;
476 return 0;
477 }
478 return 1;
479 }
480
481 void
lefrSetRegisterUnusedCallbacks()482 lefrSetRegisterUnusedCallbacks()
483 {
484 LEF_INIT;
485 int i;
486 lefSettings->RegisterUnused = 1;
487 lefrSetUnusedCallbacks(lefrCountFunc);
488 for (i = 0; i < NOCBK; i++)
489 lefrUnusedCount[i] = 0;
490 }
491
492 void
lefrPrintUnusedCallbacks(FILE * f)493 lefrPrintUnusedCallbacks(FILE *f)
494 {
495 LEF_INIT;
496 int i;
497 int firstCB = 1;
498 int trueCB = 1;
499
500 if (lefSettings->RegisterUnused == 0) {
501 fprintf(f,
502 "ERROR (LEFPARS-101): lefrSetRegisterUnusedCallbacks was not called to setup this data.\n");
503 return;
504 }
505
506 for (i = 0; i < NOCBK; i++) {
507 if (lefrUnusedCount[i]) {
508 // Do not need to print yet if i is:
509 // lefrMacroClassTypeCbkType
510 // lefrMacroOriginCbkType
511 // lefrMacroSizeCbkType
512 // lefrMacroEndCbkType
513 // it will be taken care later
514 if (firstCB &&
515 (lefrCallbackType_e) i != lefrMacroClassTypeCbkType &&
516 (lefrCallbackType_e) i != lefrMacroOriginCbkType &&
517 (lefrCallbackType_e) i != lefrMacroSiteCbkType &&
518 (lefrCallbackType_e) i != lefrMacroForeignCbkType &&
519 (lefrCallbackType_e) i != lefrMacroSizeCbkType &&
520 (lefrCallbackType_e) i != lefrMacroFixedMaskCbkType &&
521 (lefrCallbackType_e) i != lefrMacroEndCbkType) {
522 fprintf(f,
523 "WARNING (LEFPARS-201): LEF items that were present but ignored because of no callback:\n");
524 firstCB = 0;
525 }
526 switch ((lefrCallbackType_e) i) {
527 case lefrArrayBeginCbkType:
528 fprintf(f, "ArrayBegin");
529 break;
530 case lefrArrayCbkType:
531 fprintf(f, "Array");
532 break;
533 case lefrArrayEndCbkType:
534 fprintf(f, "ArrayEnd");
535 break;
536 case lefrDividerCharCbkType:
537 fprintf(f, "DividerChar");
538 break;
539 case lefrBusBitCharsCbkType:
540 fprintf(f, "BusBitChars");
541 break;
542 case lefrNoWireExtensionCbkType:
543 fprintf(f, "NoWireExtensionAtPins");
544 break;
545 case lefrCaseSensitiveCbkType:
546 fprintf(f, "CaseSensitive");
547 break;
548 case lefrCorrectionTableCbkType:
549 fprintf(f, "CorrectionTable");
550 break;
551 case lefrDielectricCbkType:
552 fprintf(f, "Dielectric");
553 break;
554 case lefrEdgeRateScaleFactorCbkType:
555 fprintf(f, "EdgeRateScaleFactor");
556 break;
557 case lefrEdgeRateThreshold1CbkType:
558 fprintf(f, "EdgeRateThreshold1");
559 break;
560 case lefrEdgeRateThreshold2CbkType:
561 fprintf(f, "EdgeRateThreshold2");
562 break;
563 case lefrIRDropBeginCbkType:
564 fprintf(f, "IRDropBegin");
565 break;
566 case lefrIRDropCbkType:
567 fprintf(f, "IRDrop");
568 break;
569 case lefrIRDropEndCbkType:
570 fprintf(f, "IRDropEnd");
571 break;
572 case lefrLayerCbkType:
573 fprintf(f, "Layer");
574 break;
575 case lefrLibraryEndCbkType:
576 fprintf(f, "LibraryEnd");
577 break;
578 case lefrMacroBeginCbkType:
579 fprintf(f, "MacroBegin");
580 break;
581 case lefrMacroCbkType:
582 fprintf(f, "Macro");
583 break;
584 case lefrMinFeatureCbkType:
585 fprintf(f, "MinFeature");
586 break;
587 case lefrNoiseMarginCbkType:
588 fprintf(f, "NoiseMargin");
589 break;
590 case lefrNoiseTableCbkType:
591 fprintf(f, "NoiseTable");
592 break;
593 case lefrNonDefaultCbkType:
594 fprintf(f, "NonDefault");
595 break;
596 case lefrObstructionCbkType:
597 fprintf(f, "Obstruction");
598 break;
599 case lefrPinCbkType:
600 fprintf(f, "Pin");
601 break;
602 case lefrPropBeginCbkType:
603 fprintf(f, "PropBegin");
604 break;
605 case lefrPropCbkType:
606 fprintf(f, "Prop");
607 break;
608 case lefrPropEndCbkType:
609 fprintf(f, "PropEnd");
610 break;
611 case lefrSiteCbkType:
612 fprintf(f, "Site");
613 break;
614 case lefrSpacingBeginCbkType:
615 fprintf(f, "SpacingBegin");
616 break;
617 case lefrSpacingCbkType:
618 fprintf(f, "Spacing");
619 break;
620 case lefrSpacingEndCbkType:
621 fprintf(f, "SpacingEnd");
622 break;
623 case lefrUnitsCbkType:
624 fprintf(f, "Units");
625 break;
626 case lefrVersionCbkType:
627 fprintf(f, "Version");
628 break;
629 case lefrVersionStrCbkType:
630 fprintf(f, "Version");
631 break;
632 case lefrViaCbkType:
633 fprintf(f, "Via");
634 break;
635 case lefrViaRuleCbkType:
636 fprintf(f, "ViaRule");
637 break;
638 case lefrInputAntennaCbkType:
639 fprintf(f, "InputAntenna");
640 break;
641 case lefrOutputAntennaCbkType:
642 fprintf(f, "OutputAntenna");
643 break;
644 case lefrInoutAntennaCbkType:
645 fprintf(f, "InoutAntenna");
646 break;
647 case lefrAntennaInputCbkType:
648 fprintf(f, "AntennaInput");
649 break;
650 case lefrAntennaInoutCbkType:
651 fprintf(f, "AntennaInout");
652 break;
653 case lefrAntennaOutputCbkType:
654 fprintf(f, "AntennaOutput");
655 break;
656 case lefrManufacturingCbkType:
657 fprintf(f, "Manufacturing");
658 break;
659 case lefrUseMinSpacingCbkType:
660 fprintf(f, "UseMinSpacing");
661 break;
662 case lefrClearanceMeasureCbkType:
663 fprintf(f, "ClearanceMeasure");
664 break;
665 case lefrTimingCbkType:
666 fprintf(f, "Timing");
667 break;
668 case lefrMaxStackViaCbkType:
669 fprintf(f, "MaxStackVia");
670 break;
671 case lefrExtensionCbkType:
672 fprintf(f, "Extension");
673 break;
674 // 07/13/2001 - Wanda da Rosa
675 // Don't need to print MacroClassType if it is not set,
676 // since this is an extra CB for Ambit only.
677 // Other users should not have to deal with it.
678 // case lefrMacroClassTypeCbkType: fprintf(f, "MacroClassType"); break;
679 case lefrMacroClassTypeCbkType:
680 case lefrMacroOriginCbkType:
681 case lefrMacroSiteCbkType:
682 case lefrMacroForeignCbkType:
683 case lefrMacroSizeCbkType:
684 case lefrMacroFixedMaskCbkType:
685 case lefrMacroEndCbkType:
686 trueCB = 0;
687 break;
688 // NEW CALLBACK add the print here
689 case lefrDensityCbkType:
690 fprintf(f, "Density");
691 break;
692 case lefrFixedMaskCbkType:
693 fprintf(f, "FixedMask");
694 break;
695 default:
696 fprintf(f, "BOGUS ENTRY");
697 break;
698 }
699 if (trueCB)
700 fprintf(f, " %d\n", lefrUnusedCount[i]);
701 else
702 trueCB = 1;
703 }
704 }
705 }
706
707 void
lefrUnsetCallbacks()708 lefrUnsetCallbacks()
709 {
710 lefrCallbacks::reset();
711 }
712
713 // Unset callbacks functions
714 void
lefrUnsetAntennaInoutCbk()715 lefrUnsetAntennaInoutCbk()
716 {
717 LEF_INIT;
718 lefCallbacks->AntennaInoutCbk = 0;
719 }
720
721 void
lefrUnsetAntennaInputCbk()722 lefrUnsetAntennaInputCbk()
723 {
724 LEF_INIT;
725 lefCallbacks->AntennaInputCbk = 0;
726 }
727
728 void
lefrUnsetAntennaOutputCbk()729 lefrUnsetAntennaOutputCbk()
730 {
731 LEF_INIT;
732 lefCallbacks->AntennaOutputCbk = 0;
733 }
734
735 void
lefrUnsetArrayBeginCbk()736 lefrUnsetArrayBeginCbk()
737 {
738 LEF_INIT;
739 lefCallbacks->ArrayBeginCbk = 0;
740 }
741
742 void
lefrUnsetArrayCbk()743 lefrUnsetArrayCbk()
744 {
745 LEF_INIT;
746 lefCallbacks->ArrayCbk = 0;
747 }
748
749 void
lefrUnsetArrayEndCbk()750 lefrUnsetArrayEndCbk()
751 {
752 LEF_INIT;
753 lefCallbacks->ArrayEndCbk = 0;
754 }
755
756 void
lefrUnsetBusBitCharsCbk()757 lefrUnsetBusBitCharsCbk()
758 {
759 LEF_INIT;
760 lefCallbacks->BusBitCharsCbk = 0;
761 }
762
763 void
lefrUnsetCaseSensitiveCbk()764 lefrUnsetCaseSensitiveCbk()
765 {
766 LEF_INIT;
767 lefCallbacks->CaseSensitiveCbk = 0;
768 }
769
770 void
lefrUnsetClearanceMeasureCbk()771 lefrUnsetClearanceMeasureCbk()
772 {
773 LEF_INIT;
774 lefCallbacks->ClearanceMeasureCbk = 0;
775 }
776
777 void
lefrUnsetCorrectionTableCbk()778 lefrUnsetCorrectionTableCbk()
779 {
780 LEF_INIT;
781 lefCallbacks->CorrectionTableCbk = 0;
782 }
783
784 void
lefrUnsetDensityCbk()785 lefrUnsetDensityCbk()
786 {
787 LEF_INIT;
788 lefCallbacks->DensityCbk = 0;
789 }
790
791 void
lefrUnsetDielectricCbk()792 lefrUnsetDielectricCbk()
793 {
794 LEF_INIT;
795 lefCallbacks->DielectricCbk = 0;
796 }
797
798 void
lefrUnsetDividerCharCbk()799 lefrUnsetDividerCharCbk()
800 {
801 LEF_INIT;
802 lefCallbacks->DividerCharCbk = 0;
803 }
804
805 void
lefrUnsetEdgeRateScaleFactorCbk()806 lefrUnsetEdgeRateScaleFactorCbk()
807 {
808 LEF_INIT;
809 lefCallbacks->EdgeRateScaleFactorCbk = 0;
810 }
811
812 void
lefrUnsetEdgeRateThreshold1Cbk()813 lefrUnsetEdgeRateThreshold1Cbk()
814 {
815 LEF_INIT;
816 lefCallbacks->EdgeRateThreshold1Cbk = 0;
817 }
818
819 void
lefrUnsetEdgeRateThreshold2Cbk()820 lefrUnsetEdgeRateThreshold2Cbk()
821 {
822 LEF_INIT;
823 lefCallbacks->EdgeRateThreshold2Cbk = 0;
824 }
825
826 void
lefrUnsetExtensionCbk()827 lefrUnsetExtensionCbk()
828 {
829 LEF_INIT;
830 lefCallbacks->ExtensionCbk = 0;
831 }
832
833 void
lefrUnsetFixedMaskCbk()834 lefrUnsetFixedMaskCbk()
835 {
836 LEF_INIT;
837 lefCallbacks->FixedMaskCbk = 0;
838 }
839 void
lefrUnsetIRDropBeginCbk()840 lefrUnsetIRDropBeginCbk()
841 {
842 LEF_INIT;
843 lefCallbacks->IRDropBeginCbk = 0;
844 }
845
846 void
lefrUnsetIRDropCbk()847 lefrUnsetIRDropCbk()
848 {
849 LEF_INIT;
850 lefCallbacks->IRDropCbk = 0;
851 }
852
853 void
lefrUnsetIRDropEndCbk()854 lefrUnsetIRDropEndCbk()
855 {
856 LEF_INIT;
857 lefCallbacks->IRDropEndCbk = 0;
858 }
859
860 void
lefrUnsetInoutAntennaCbk()861 lefrUnsetInoutAntennaCbk()
862 {
863 LEF_INIT;
864 lefCallbacks->InoutAntennaCbk = 0;
865 }
866
867 void
lefrUnsetInputAntennaCbk()868 lefrUnsetInputAntennaCbk()
869 {
870 LEF_INIT;
871 lefCallbacks->InputAntennaCbk = 0;
872 }
873
874 void
lefrUnsetLayerCbk()875 lefrUnsetLayerCbk()
876 {
877 LEF_INIT;
878 lefCallbacks->LayerCbk = 0;
879 }
880
881 void
lefrUnsetLibraryEndCbk()882 lefrUnsetLibraryEndCbk()
883 {
884 LEF_INIT;
885 lefCallbacks->LibraryEndCbk = 0;
886 }
887
888 void
lefrUnsetMacroBeginCbk()889 lefrUnsetMacroBeginCbk()
890 {
891 LEF_INIT;
892 lefCallbacks->MacroBeginCbk = 0;
893 }
894
895 void
lefrUnsetMacroCbk()896 lefrUnsetMacroCbk()
897 {
898 LEF_INIT;
899 lefCallbacks->MacroCbk = 0;
900 }
901
902 void
lefrUnsetMacroClassTypeCbk()903 lefrUnsetMacroClassTypeCbk()
904 {
905 LEF_INIT;
906 lefCallbacks->MacroClassTypeCbk = 0;
907 }
908
909 void
lefrUnsetMacroEndCbk()910 lefrUnsetMacroEndCbk()
911 {
912 LEF_INIT;
913 lefCallbacks->MacroEndCbk = 0;
914 }
915
916 void
lefrUnsetMacroFixedMaskCbk()917 lefrUnsetMacroFixedMaskCbk()
918 {
919 LEF_INIT;
920 lefCallbacks->MacroFixedMaskCbk = 0;
921 }
922
923 void
lefrUnsetMacroOriginCbk()924 lefrUnsetMacroOriginCbk()
925 {
926 LEF_INIT;
927 lefCallbacks->MacroOriginCbk = 0;
928 }
929
930 void
lefrUnsetMacroSiteCbk()931 lefrUnsetMacroSiteCbk()
932 {
933 LEF_INIT;
934 lefCallbacks->MacroSiteCbk = 0;
935 }
936
937 void
lefrUnsetMacroForeignCbk()938 lefrUnsetMacroForeignCbk()
939 {
940 LEF_INIT;
941 lefCallbacks->MacroForeignCbk = 0;
942 }
943
944 void
lefrUnsetMacroSizeCbk()945 lefrUnsetMacroSizeCbk()
946 {
947 LEF_INIT;
948 lefCallbacks->MacroSizeCbk = 0;
949 }
950
951 void
lefrUnsetManufacturingCbk()952 lefrUnsetManufacturingCbk()
953 {
954 LEF_INIT;
955 lefCallbacks->ManufacturingCbk = 0;
956 }
957
958 void
lefrUnsetMaxStackViaCbk()959 lefrUnsetMaxStackViaCbk()
960 {
961 LEF_INIT;
962 lefCallbacks->MaxStackViaCbk = 0;
963 }
964
965 void
lefrUnsetMinFeatureCbk()966 lefrUnsetMinFeatureCbk()
967 {
968 LEF_INIT;
969 lefCallbacks->MinFeatureCbk = 0;
970 }
971
972 void
lefrUnsetNoWireExtensionCbk()973 lefrUnsetNoWireExtensionCbk()
974 {
975 LEF_INIT;
976 lefCallbacks->NoWireExtensionCbk = 0;
977 }
978
979 void
lefrUnsetNoiseMarginCbk()980 lefrUnsetNoiseMarginCbk()
981 {
982 LEF_INIT;
983 lefCallbacks->NoiseMarginCbk = 0;
984 }
985
986 void
lefrUnsetNoiseTableCbk()987 lefrUnsetNoiseTableCbk()
988 {
989 LEF_INIT;
990 lefCallbacks->NoiseTableCbk = 0;
991 }
992
993 void
lefrUnsetNonDefaultCbk()994 lefrUnsetNonDefaultCbk()
995 {
996 LEF_INIT;
997 lefCallbacks->NonDefaultCbk = 0;
998 }
999
1000 void
lefrUnsetObstructionCbk()1001 lefrUnsetObstructionCbk()
1002 {
1003 LEF_INIT;
1004 lefCallbacks->ObstructionCbk = 0;
1005 }
1006
1007 void
lefrUnsetOutputAntennaCbk()1008 lefrUnsetOutputAntennaCbk()
1009 {
1010 LEF_INIT;
1011 lefCallbacks->OutputAntennaCbk = 0;
1012 }
1013
1014 void
lefrUnsetPinCbk()1015 lefrUnsetPinCbk()
1016 {
1017 LEF_INIT;
1018 lefCallbacks->PinCbk = 0;
1019 }
1020
1021 void
lefrUnsetPropBeginCbk()1022 lefrUnsetPropBeginCbk()
1023 {
1024 LEF_INIT;
1025 lefCallbacks->PropBeginCbk = 0;
1026 }
1027
1028 void
lefrUnsetPropCbk()1029 lefrUnsetPropCbk()
1030 {
1031 LEF_INIT;
1032 lefCallbacks->PropCbk = 0;
1033 }
1034
1035 void
lefrUnsetPropEndCbk()1036 lefrUnsetPropEndCbk()
1037 {
1038 LEF_INIT;
1039 lefCallbacks->PropEndCbk = 0;
1040 }
1041
1042 void
lefrUnsetSiteCbk()1043 lefrUnsetSiteCbk()
1044 {
1045 LEF_INIT;
1046 lefCallbacks->SiteCbk = 0;
1047 }
1048
1049 void
lefrUnsetSpacingBeginCbk()1050 lefrUnsetSpacingBeginCbk()
1051 {
1052 LEF_INIT;
1053 lefCallbacks->SpacingBeginCbk = 0;
1054 }
1055
1056 void
lefrUnsetSpacingCbk()1057 lefrUnsetSpacingCbk()
1058 {
1059 LEF_INIT;
1060 lefCallbacks->SpacingCbk = 0;
1061 }
1062
1063 void
lefrUnsetSpacingEndCbk()1064 lefrUnsetSpacingEndCbk()
1065 {
1066 LEF_INIT;
1067 lefCallbacks->SpacingEndCbk = 0;
1068 }
1069
1070 void
lefrUnsetTimingCbk()1071 lefrUnsetTimingCbk()
1072 {
1073 LEF_INIT;
1074 lefCallbacks->TimingCbk = 0;
1075 }
1076
1077 void
lefrUnsetUnitsCbk()1078 lefrUnsetUnitsCbk()
1079 {
1080 LEF_INIT;
1081 lefCallbacks->UnitsCbk = 0;
1082 }
1083
1084 void
lefrUnsetUseMinSpacingCbk()1085 lefrUnsetUseMinSpacingCbk()
1086 {
1087 LEF_INIT;
1088 lefCallbacks->UseMinSpacingCbk = 0;
1089 }
1090
1091 void
lefrUnsetVersionCbk()1092 lefrUnsetVersionCbk()
1093 {
1094 LEF_INIT;
1095 lefCallbacks->VersionCbk = 0;
1096 }
1097
1098 void
lefrUnsetVersionStrCbk()1099 lefrUnsetVersionStrCbk()
1100 {
1101 LEF_INIT;
1102 lefCallbacks->VersionStrCbk = 0;
1103 }
1104
1105 void
lefrUnsetViaCbk()1106 lefrUnsetViaCbk()
1107 {
1108 LEF_INIT;
1109 lefCallbacks->ViaCbk = 0;
1110 }
1111
1112 void
lefrUnsetViaRuleCbk()1113 lefrUnsetViaRuleCbk()
1114 {
1115 LEF_INIT;
1116 lefCallbacks->ViaRuleCbk = 0;
1117 }
1118
1119 // Setting of user data.
1120 void
lefrSetUserData(lefiUserData d)1121 lefrSetUserData(lefiUserData d)
1122 {
1123 LEF_INIT;
1124 lefSettings->UserData = d;
1125 }
1126
1127 lefiUserData
lefrGetUserData()1128 lefrGetUserData()
1129 {
1130 LEF_INIT;
1131 return lefSettings->UserData;
1132 }
1133
1134 // Callbacks set functions.
1135
1136 void
lefrSetAntennaInoutCbk(lefrDoubleCbkFnType f)1137 lefrSetAntennaInoutCbk(lefrDoubleCbkFnType f)
1138 {
1139 LEF_INIT;
1140 lefCallbacks->AntennaInoutCbk = f;
1141 }
1142
1143 void
lefrSetAntennaInputCbk(lefrDoubleCbkFnType f)1144 lefrSetAntennaInputCbk(lefrDoubleCbkFnType f)
1145 {
1146 LEF_INIT;
1147 lefCallbacks->AntennaInputCbk = f;
1148 }
1149
1150 void
lefrSetAntennaOutputCbk(lefrDoubleCbkFnType f)1151 lefrSetAntennaOutputCbk(lefrDoubleCbkFnType f)
1152 {
1153 LEF_INIT;
1154 lefCallbacks->AntennaOutputCbk = f;
1155 }
1156
1157 void
lefrSetArrayBeginCbk(lefrStringCbkFnType f)1158 lefrSetArrayBeginCbk(lefrStringCbkFnType f)
1159 {
1160 LEF_INIT;
1161 lefCallbacks->ArrayBeginCbk = f;
1162 }
1163
1164 void
lefrSetArrayCbk(lefrArrayCbkFnType f)1165 lefrSetArrayCbk(lefrArrayCbkFnType f)
1166 {
1167 LEF_INIT;
1168 lefCallbacks->ArrayCbk = f;
1169 }
1170
1171 void
lefrSetArrayEndCbk(lefrStringCbkFnType f)1172 lefrSetArrayEndCbk(lefrStringCbkFnType f)
1173 {
1174 LEF_INIT;
1175 lefCallbacks->ArrayEndCbk = f;
1176 }
1177
1178 void
lefrSetBusBitCharsCbk(lefrStringCbkFnType f)1179 lefrSetBusBitCharsCbk(lefrStringCbkFnType f)
1180 {
1181 LEF_INIT;
1182 lefCallbacks->BusBitCharsCbk = f;
1183 }
1184
1185 void
lefrSetCaseSensitiveCbk(lefrIntegerCbkFnType f)1186 lefrSetCaseSensitiveCbk(lefrIntegerCbkFnType f)
1187 {
1188 LEF_INIT;
1189 lefCallbacks->CaseSensitiveCbk = f;
1190 }
1191
1192 void
lefrSetClearanceMeasureCbk(lefrStringCbkFnType f)1193 lefrSetClearanceMeasureCbk(lefrStringCbkFnType f)
1194 {
1195 LEF_INIT;
1196 lefCallbacks->ClearanceMeasureCbk = f;
1197 }
1198
1199 void
lefrSetCorrectionTableCbk(lefrCorrectionTableCbkFnType f)1200 lefrSetCorrectionTableCbk(lefrCorrectionTableCbkFnType f)
1201 {
1202 LEF_INIT;
1203 lefCallbacks->CorrectionTableCbk = f;
1204 }
1205
1206 void
lefrSetDensityCbk(lefrDensityCbkFnType f)1207 lefrSetDensityCbk(lefrDensityCbkFnType f)
1208 {
1209 LEF_INIT;
1210 lefCallbacks->DensityCbk = f;
1211 }
1212
1213 void
lefrSetDielectricCbk(lefrDoubleCbkFnType f)1214 lefrSetDielectricCbk(lefrDoubleCbkFnType f)
1215 {
1216 LEF_INIT;
1217 lefCallbacks->DielectricCbk = f;
1218 }
1219
1220 void
lefrSetDividerCharCbk(lefrStringCbkFnType f)1221 lefrSetDividerCharCbk(lefrStringCbkFnType f)
1222 {
1223 LEF_INIT;
1224 lefCallbacks->DividerCharCbk = f;
1225 }
1226
1227 void
lefrSetEdgeRateScaleFactorCbk(lefrDoubleCbkFnType f)1228 lefrSetEdgeRateScaleFactorCbk(lefrDoubleCbkFnType f)
1229 {
1230 LEF_INIT;
1231 lefCallbacks->EdgeRateScaleFactorCbk = f;
1232 }
1233
1234 void
lefrSetEdgeRateThreshold1Cbk(lefrDoubleCbkFnType f)1235 lefrSetEdgeRateThreshold1Cbk(lefrDoubleCbkFnType f)
1236 {
1237 LEF_INIT;
1238 lefCallbacks->EdgeRateThreshold1Cbk = f;
1239 }
1240
1241 void
lefrSetEdgeRateThreshold2Cbk(lefrDoubleCbkFnType f)1242 lefrSetEdgeRateThreshold2Cbk(lefrDoubleCbkFnType f)
1243 {
1244 LEF_INIT;
1245 lefCallbacks->EdgeRateThreshold2Cbk = f;
1246 }
1247
1248 void
lefrSetExtensionCbk(lefrStringCbkFnType f)1249 lefrSetExtensionCbk(lefrStringCbkFnType f)
1250 {
1251 LEF_INIT;
1252 lefCallbacks->ExtensionCbk = f;
1253 }
1254
1255 void
lefrSetFixedMaskCbk(lefrIntegerCbkFnType f)1256 lefrSetFixedMaskCbk(lefrIntegerCbkFnType f)
1257 {
1258 LEF_INIT;
1259 lefCallbacks->FixedMaskCbk = f;
1260 }
1261
1262 void
lefrSetIRDropBeginCbk(lefrVoidCbkFnType f)1263 lefrSetIRDropBeginCbk(lefrVoidCbkFnType f)
1264 {
1265 LEF_INIT;
1266 lefCallbacks->IRDropBeginCbk = f;
1267 }
1268
1269 void
lefrSetIRDropCbk(lefrIRDropCbkFnType f)1270 lefrSetIRDropCbk(lefrIRDropCbkFnType f)
1271 {
1272 LEF_INIT;
1273 lefCallbacks->IRDropCbk = f;
1274 }
1275
1276 void
lefrSetIRDropEndCbk(lefrVoidCbkFnType f)1277 lefrSetIRDropEndCbk(lefrVoidCbkFnType f)
1278 {
1279 LEF_INIT;
1280 lefCallbacks->IRDropEndCbk = f;
1281 }
1282
1283 void
lefrSetInoutAntennaCbk(lefrDoubleCbkFnType f)1284 lefrSetInoutAntennaCbk(lefrDoubleCbkFnType f)
1285 {
1286 LEF_INIT;
1287 lefCallbacks->InoutAntennaCbk = f;
1288 }
1289
1290 void
lefrSetInputAntennaCbk(lefrDoubleCbkFnType f)1291 lefrSetInputAntennaCbk(lefrDoubleCbkFnType f)
1292 {
1293 LEF_INIT;
1294 lefCallbacks->InputAntennaCbk = f;
1295 }
1296
1297 void
lefrSetLayerCbk(lefrLayerCbkFnType f)1298 lefrSetLayerCbk(lefrLayerCbkFnType f)
1299 {
1300 LEF_INIT;
1301 lefCallbacks->LayerCbk = f;
1302 }
1303
1304 void
lefrSetLibraryEndCbk(lefrVoidCbkFnType f)1305 lefrSetLibraryEndCbk(lefrVoidCbkFnType f)
1306 {
1307 LEF_INIT;
1308 lefCallbacks->LibraryEndCbk = f;
1309 }
1310
1311 void
lefrSetMacroBeginCbk(lefrStringCbkFnType f)1312 lefrSetMacroBeginCbk(lefrStringCbkFnType f)
1313 {
1314 LEF_INIT;
1315 lefCallbacks->MacroBeginCbk = f;
1316 }
1317
1318 void
lefrSetMacroCbk(lefrMacroCbkFnType f)1319 lefrSetMacroCbk(lefrMacroCbkFnType f)
1320 {
1321 LEF_INIT;
1322 lefCallbacks->MacroCbk = f;
1323 }
1324
1325 void
lefrSetMacroClassTypeCbk(lefrStringCbkFnType f)1326 lefrSetMacroClassTypeCbk(lefrStringCbkFnType f)
1327 {
1328 LEF_INIT;
1329 lefCallbacks->MacroClassTypeCbk = f;
1330 }
1331
1332 void
lefrSetMacroEndCbk(lefrStringCbkFnType f)1333 lefrSetMacroEndCbk(lefrStringCbkFnType f)
1334 {
1335 LEF_INIT;
1336 lefCallbacks->MacroEndCbk = f;
1337 }
1338
1339 void
lefrSetMacroFixedMaskCbk(lefrIntegerCbkFnType f)1340 lefrSetMacroFixedMaskCbk(lefrIntegerCbkFnType f)
1341 {
1342 LEF_INIT;
1343 lefCallbacks->MacroFixedMaskCbk = f;
1344 }
1345
1346 void
lefrSetMacroOriginCbk(lefrMacroNumCbkFnType f)1347 lefrSetMacroOriginCbk(lefrMacroNumCbkFnType f)
1348 {
1349 LEF_INIT;
1350 lefCallbacks->MacroOriginCbk = f;
1351 }
1352
1353 void
lefrSetMacroSiteCbk(lefrMacroSiteCbkFnType f)1354 lefrSetMacroSiteCbk(lefrMacroSiteCbkFnType f)
1355 {
1356 LEF_INIT;
1357 lefCallbacks->MacroSiteCbk = f;
1358 }
1359
1360 void
lefrSetMacroForeignCbk(lefrMacroForeignCbkFnType f)1361 lefrSetMacroForeignCbk(lefrMacroForeignCbkFnType f)
1362 {
1363 LEF_INIT;
1364 lefCallbacks->MacroForeignCbk = f;
1365 }
1366
1367 void
lefrSetMacroSizeCbk(lefrMacroNumCbkFnType f)1368 lefrSetMacroSizeCbk(lefrMacroNumCbkFnType f)
1369 {
1370 LEF_INIT;
1371 lefCallbacks->MacroSizeCbk = f;
1372 }
1373
1374 void
lefrSetManufacturingCbk(lefrDoubleCbkFnType f)1375 lefrSetManufacturingCbk(lefrDoubleCbkFnType f)
1376 {
1377 LEF_INIT;
1378 lefCallbacks->ManufacturingCbk = f;
1379 }
1380
1381 void
lefrSetMaxStackViaCbk(lefrMaxStackViaCbkFnType f)1382 lefrSetMaxStackViaCbk(lefrMaxStackViaCbkFnType f)
1383 {
1384 LEF_INIT;
1385 lefCallbacks->MaxStackViaCbk = f;
1386 }
1387
1388 void
lefrSetMinFeatureCbk(lefrMinFeatureCbkFnType f)1389 lefrSetMinFeatureCbk(lefrMinFeatureCbkFnType f)
1390 {
1391 LEF_INIT;
1392 lefCallbacks->MinFeatureCbk = f;
1393 }
1394
1395 void
lefrSetNoWireExtensionCbk(lefrStringCbkFnType f)1396 lefrSetNoWireExtensionCbk(lefrStringCbkFnType f)
1397 {
1398 LEF_INIT;
1399 lefCallbacks->NoWireExtensionCbk = f;
1400 }
1401
1402 void
lefrSetNoiseMarginCbk(lefrNoiseMarginCbkFnType f)1403 lefrSetNoiseMarginCbk(lefrNoiseMarginCbkFnType f)
1404 {
1405 LEF_INIT;
1406 lefCallbacks->NoiseMarginCbk = f;
1407 }
1408
1409 void
lefrSetNoiseTableCbk(lefrNoiseTableCbkFnType f)1410 lefrSetNoiseTableCbk(lefrNoiseTableCbkFnType f)
1411 {
1412 LEF_INIT;
1413 lefCallbacks->NoiseTableCbk = f;
1414 }
1415
1416 void
lefrSetNonDefaultCbk(lefrNonDefaultCbkFnType f)1417 lefrSetNonDefaultCbk(lefrNonDefaultCbkFnType f)
1418 {
1419 LEF_INIT;
1420 lefCallbacks->NonDefaultCbk = f;
1421 }
1422
1423 void
lefrSetObstructionCbk(lefrObstructionCbkFnType f)1424 lefrSetObstructionCbk(lefrObstructionCbkFnType f)
1425 {
1426 LEF_INIT;
1427 lefCallbacks->ObstructionCbk = f;
1428 }
1429
1430 void
lefrSetOutputAntennaCbk(lefrDoubleCbkFnType f)1431 lefrSetOutputAntennaCbk(lefrDoubleCbkFnType f)
1432 {
1433 LEF_INIT;
1434 lefCallbacks->OutputAntennaCbk = f;
1435 }
1436
1437 void
lefrSetPinCbk(lefrPinCbkFnType f)1438 lefrSetPinCbk(lefrPinCbkFnType f)
1439 {
1440 LEF_INIT;
1441 lefCallbacks->PinCbk = f;
1442 }
1443
1444 void
lefrSetPropBeginCbk(lefrVoidCbkFnType f)1445 lefrSetPropBeginCbk(lefrVoidCbkFnType f)
1446 {
1447 LEF_INIT;
1448 lefCallbacks->PropBeginCbk = f;
1449 }
1450
1451 void
lefrSetPropCbk(lefrPropCbkFnType f)1452 lefrSetPropCbk(lefrPropCbkFnType f)
1453 {
1454 LEF_INIT;
1455 lefCallbacks->PropCbk = f;
1456 }
1457
1458 void
lefrSetPropEndCbk(lefrVoidCbkFnType f)1459 lefrSetPropEndCbk(lefrVoidCbkFnType f)
1460 {
1461 LEF_INIT;
1462 lefCallbacks->PropEndCbk = f;
1463 }
1464
1465 void
lefrSetSiteCbk(lefrSiteCbkFnType f)1466 lefrSetSiteCbk(lefrSiteCbkFnType f)
1467 {
1468 LEF_INIT;
1469 lefCallbacks->SiteCbk = f;
1470 }
1471
1472 void
lefrSetSpacingBeginCbk(lefrVoidCbkFnType f)1473 lefrSetSpacingBeginCbk(lefrVoidCbkFnType f)
1474 {
1475 LEF_INIT;
1476 lefCallbacks->SpacingBeginCbk = f;
1477 }
1478
1479 void
lefrSetSpacingCbk(lefrSpacingCbkFnType f)1480 lefrSetSpacingCbk(lefrSpacingCbkFnType f)
1481 {
1482 LEF_INIT;
1483 lefCallbacks->SpacingCbk = f;
1484 }
1485
1486 void
lefrSetSpacingEndCbk(lefrVoidCbkFnType f)1487 lefrSetSpacingEndCbk(lefrVoidCbkFnType f)
1488 {
1489 LEF_INIT;
1490 lefCallbacks->SpacingEndCbk = f;
1491 }
1492
1493 void
lefrSetTimingCbk(lefrTimingCbkFnType f)1494 lefrSetTimingCbk(lefrTimingCbkFnType f)
1495 {
1496 LEF_INIT;
1497 lefCallbacks->TimingCbk = f;
1498 }
1499
1500 void
lefrSetUnitsCbk(lefrUnitsCbkFnType f)1501 lefrSetUnitsCbk(lefrUnitsCbkFnType f)
1502 {
1503 LEF_INIT;
1504 lefCallbacks->UnitsCbk = f;
1505 }
1506
1507 void
lefrSetUseMinSpacingCbk(lefrUseMinSpacingCbkFnType f)1508 lefrSetUseMinSpacingCbk(lefrUseMinSpacingCbkFnType f)
1509 {
1510 LEF_INIT;
1511 lefCallbacks->UseMinSpacingCbk = f;
1512 }
1513
1514 void
lefrSetVersionCbk(lefrDoubleCbkFnType f)1515 lefrSetVersionCbk(lefrDoubleCbkFnType f)
1516 {
1517 LEF_INIT;
1518 lefCallbacks->VersionCbk = f;
1519 }
1520
1521 void
lefrSetVersionStrCbk(lefrStringCbkFnType f)1522 lefrSetVersionStrCbk(lefrStringCbkFnType f)
1523 {
1524 LEF_INIT;
1525 lefCallbacks->VersionStrCbk = f;
1526 }
1527
1528 void
lefrSetViaCbk(lefrViaCbkFnType f)1529 lefrSetViaCbk(lefrViaCbkFnType f)
1530 {
1531 LEF_INIT;
1532 lefCallbacks->ViaCbk = f;
1533 }
1534
1535 void
lefrSetViaRuleCbk(lefrViaRuleCbkFnType f)1536 lefrSetViaRuleCbk(lefrViaRuleCbkFnType f)
1537 {
1538 LEF_INIT;
1539 lefCallbacks->ViaRuleCbk = f;
1540 }
1541
1542 int
lefrLineNumber()1543 lefrLineNumber()
1544 {
1545 // Compatibility feature: in old versions the translators,
1546 // the function can be called before lefData initialization.
1547 return lefData ? lefData->lef_nlines : 0;
1548 }
1549
1550 void
lefrSetLogFunction(LEFI_LOG_FUNCTION f)1551 lefrSetLogFunction(LEFI_LOG_FUNCTION f)
1552 {
1553 LEF_INIT;
1554 lefSettings->ErrorLogFunction = f;
1555 }
1556
1557 void
lefrSetWarningLogFunction(LEFI_WARNING_LOG_FUNCTION f)1558 lefrSetWarningLogFunction(LEFI_WARNING_LOG_FUNCTION f)
1559 {
1560 LEF_INIT;
1561 lefSettings->WarningLogFunction = f;
1562 }
1563
1564 void
lefrSetMallocFunction(LEFI_MALLOC_FUNCTION f)1565 lefrSetMallocFunction(LEFI_MALLOC_FUNCTION f)
1566 {
1567 LEF_INIT;
1568 lefSettings->MallocFunction = f;
1569 }
1570
1571 void
lefrSetReallocFunction(LEFI_REALLOC_FUNCTION f)1572 lefrSetReallocFunction(LEFI_REALLOC_FUNCTION f)
1573 {
1574 LEF_INIT;
1575 lefSettings->ReallocFunction = f;
1576 }
1577
1578 void
lefrSetFreeFunction(LEFI_FREE_FUNCTION f)1579 lefrSetFreeFunction(LEFI_FREE_FUNCTION f)
1580 {
1581 LEF_INIT;
1582 lefSettings->FreeFunction = f;
1583 }
1584
1585 void
lefrSetLineNumberFunction(LEFI_LINE_NUMBER_FUNCTION f)1586 lefrSetLineNumberFunction(LEFI_LINE_NUMBER_FUNCTION f)
1587 {
1588 LEF_INIT;
1589 lefSettings->LineNumberFunction = f;
1590 }
1591
1592 void
lefrSetDeltaNumberLines(int numLines)1593 lefrSetDeltaNumberLines(int numLines)
1594 {
1595 LEF_INIT;
1596 lefSettings->DeltaNumberLines = numLines;
1597 }
1598
1599 // from the lexer
1600
1601 void
lefrSetShiftCase()1602 lefrSetShiftCase()
1603 {
1604 LEF_INIT;
1605 lefSettings->ShiftCase = 1;
1606 }
1607
1608 void
lefrSetCommentChar(char c)1609 lefrSetCommentChar(char c)
1610 {
1611 LEF_INIT;
1612 lefSettings->CommentChar = c;
1613 }
1614
1615 void
lefrSetCaseSensitivity(int caseSense)1616 lefrSetCaseSensitivity(int caseSense)
1617 {
1618 LEF_INIT;
1619 lefSettings->CaseSensitive = caseSense;
1620 lefSettings->CaseSensitiveSet = TRUE;
1621 if (lefData) {
1622 lefData->namesCaseSensitive = caseSense;
1623 }
1624 }
1625
1626 void
lefrSetRelaxMode()1627 lefrSetRelaxMode()
1628 {
1629 LEF_INIT;
1630 lefSettings->RelaxMode = TRUE;
1631 }
1632
1633 void
lefrUnsetRelaxMode()1634 lefrUnsetRelaxMode()
1635 {
1636 LEF_INIT;
1637 lefSettings->RelaxMode = FALSE;
1638 }
1639
1640 void
lefrSetVersionValue(const char * version)1641 lefrSetVersionValue(const char *version)
1642 {
1643 LEF_INIT;
1644 lefSettings->VersionNum = convert_name2num(version);
1645 }
1646
1647 void
lefrSetOpenLogFileAppend()1648 lefrSetOpenLogFileAppend()
1649 {
1650 LEF_INIT;
1651 lefSettings->LogFileAppend = TRUE;
1652 }
1653
1654 void
lefrUnsetOpenLogFileAppend()1655 lefrUnsetOpenLogFileAppend()
1656 {
1657 LEF_INIT;
1658 lefSettings->LogFileAppend = FALSE;
1659 }
1660
1661 void
lefrSetReadFunction(LEFI_READ_FUNCTION f)1662 lefrSetReadFunction(LEFI_READ_FUNCTION f)
1663 {
1664 LEF_INIT;
1665 lefSettings->ReadFunction = f;
1666 }
1667
1668 void
lefrUnsetReadFunction()1669 lefrUnsetReadFunction()
1670 {
1671 LEF_INIT;
1672 lefSettings->ReadFunction = 0;
1673 }
1674
1675 // Set the maximum number of warnings
1676 //
1677 // *****************************************************************************
1678
1679 void
lefrSetAntennaInoutWarnings(int warn)1680 lefrSetAntennaInoutWarnings(int warn)
1681 {
1682 LEF_INIT;
1683 lefSettings->AntennaInoutWarnings = warn;
1684 }
1685
1686 void
lefrSetAntennaInputWarnings(int warn)1687 lefrSetAntennaInputWarnings(int warn)
1688 {
1689 LEF_INIT;
1690 lefSettings->AntennaInputWarnings = warn;
1691 }
1692
1693 void
lefrSetAntennaOutputWarnings(int warn)1694 lefrSetAntennaOutputWarnings(int warn)
1695 {
1696 LEF_INIT;
1697 lefSettings->AntennaOutputWarnings = warn;
1698 }
1699
1700 void
lefrSetArrayWarnings(int warn)1701 lefrSetArrayWarnings(int warn)
1702 {
1703 LEF_INIT;
1704 lefSettings->ArrayWarnings = warn;
1705 }
1706
1707 void
lefrSetCaseSensitiveWarnings(int warn)1708 lefrSetCaseSensitiveWarnings(int warn)
1709 {
1710 LEF_INIT;
1711 lefSettings->CaseSensitiveWarnings = warn;
1712 }
1713
1714 void
lefrSetCorrectionTableWarnings(int warn)1715 lefrSetCorrectionTableWarnings(int warn)
1716 {
1717 LEF_INIT;
1718 lefSettings->CorrectionTableWarnings = warn;
1719 }
1720
1721 void
lefrSetDielectricWarnings(int warn)1722 lefrSetDielectricWarnings(int warn)
1723 {
1724 LEF_INIT;
1725 lefSettings->DielectricWarnings = warn;
1726 }
1727
1728 void
lefrSetEdgeRateThreshold1Warnings(int warn)1729 lefrSetEdgeRateThreshold1Warnings(int warn)
1730 {
1731 LEF_INIT;
1732 lefSettings->EdgeRateThreshold1Warnings = warn;
1733 }
1734
1735 void
lefrSetEdgeRateThreshold2Warnings(int warn)1736 lefrSetEdgeRateThreshold2Warnings(int warn)
1737 {
1738 LEF_INIT;
1739 lefSettings->EdgeRateThreshold2Warnings = warn;
1740 }
1741
1742 void
lefrSetEdgeRateScaleFactorWarnings(int warn)1743 lefrSetEdgeRateScaleFactorWarnings(int warn)
1744 {
1745 LEF_INIT;
1746 lefSettings->EdgeRateScaleFactorWarnings = warn;
1747 }
1748
1749 void
lefrSetInoutAntennaWarnings(int warn)1750 lefrSetInoutAntennaWarnings(int warn)
1751 {
1752 LEF_INIT;
1753 lefSettings->InoutAntennaWarnings = warn;
1754 }
1755
1756 void
lefrSetInputAntennaWarnings(int warn)1757 lefrSetInputAntennaWarnings(int warn)
1758 {
1759 LEF_INIT;
1760 lefSettings->InputAntennaWarnings = warn;
1761 }
1762
1763 void
lefrSetIRDropWarnings(int warn)1764 lefrSetIRDropWarnings(int warn)
1765 {
1766 LEF_INIT;
1767 lefSettings->IRDropWarnings = warn;
1768 }
1769
1770 void
lefrSetLayerWarnings(int warn)1771 lefrSetLayerWarnings(int warn)
1772 {
1773 LEF_INIT;
1774 lefSettings->LayerWarnings = warn;
1775 }
1776
1777 void
lefrSetMacroWarnings(int warn)1778 lefrSetMacroWarnings(int warn)
1779 {
1780 LEF_INIT;
1781 lefSettings->MacroWarnings = warn;
1782 }
1783
1784 void
lefrSetMaxStackViaWarnings(int warn)1785 lefrSetMaxStackViaWarnings(int warn)
1786 {
1787 LEF_INIT;
1788 lefSettings->MaxStackViaWarnings = warn;
1789 }
1790
1791 void
lefrSetMinFeatureWarnings(int warn)1792 lefrSetMinFeatureWarnings(int warn)
1793 {
1794 LEF_INIT;
1795 lefSettings->MinFeatureWarnings = warn;
1796 }
1797
1798 void
lefrSetNoiseMarginWarnings(int warn)1799 lefrSetNoiseMarginWarnings(int warn)
1800 {
1801 LEF_INIT;
1802 lefSettings->NoiseMarginWarnings = warn;
1803 }
1804
1805 void
lefrSetNoiseTableWarnings(int warn)1806 lefrSetNoiseTableWarnings(int warn)
1807 {
1808 LEF_INIT;
1809 lefSettings->NoiseTableWarnings = warn;
1810 }
1811
1812 void
lefrSetNonDefaultWarnings(int warn)1813 lefrSetNonDefaultWarnings(int warn)
1814 {
1815 LEF_INIT;
1816 lefSettings->NonDefaultWarnings = warn;
1817 }
1818
1819 void
lefrSetNoWireExtensionWarnings(int warn)1820 lefrSetNoWireExtensionWarnings(int warn)
1821 {
1822 LEF_INIT;
1823 lefSettings->NoWireExtensionWarnings = warn;
1824 }
1825
1826 void
lefrSetOutputAntennaWarnings(int warn)1827 lefrSetOutputAntennaWarnings(int warn)
1828 {
1829 LEF_INIT;
1830 lefSettings->OutputAntennaWarnings = warn;
1831 }
1832
1833 void
lefrSetPinWarnings(int warn)1834 lefrSetPinWarnings(int warn)
1835 {
1836 LEF_INIT;
1837 lefSettings->PinWarnings = warn;
1838 }
1839
1840 void
lefrSetSiteWarnings(int warn)1841 lefrSetSiteWarnings(int warn)
1842 {
1843 LEF_INIT;
1844 lefSettings->SiteWarnings = warn;
1845 }
1846
1847 void
lefrSetSpacingWarnings(int warn)1848 lefrSetSpacingWarnings(int warn)
1849 {
1850 LEF_INIT;
1851 lefSettings->SpacingWarnings = warn;
1852 }
1853
1854 void
lefrSetTimingWarnings(int warn)1855 lefrSetTimingWarnings(int warn)
1856 {
1857 LEF_INIT;
1858 lefSettings->TimingWarnings = warn;
1859 }
1860
1861 void
lefrSetUnitsWarnings(int warn)1862 lefrSetUnitsWarnings(int warn)
1863 {
1864 LEF_INIT;
1865 lefSettings->UnitsWarnings = warn;
1866 }
1867
1868 void
lefrSetUseMinSpacingWarnings(int warn)1869 lefrSetUseMinSpacingWarnings(int warn)
1870 {
1871 LEF_INIT;
1872 lefSettings->UseMinSpacingWarnings = warn;
1873 }
1874
1875 void
lefrSetViaRuleWarnings(int warn)1876 lefrSetViaRuleWarnings(int warn)
1877 {
1878 LEF_INIT;
1879 lefSettings->ViaRuleWarnings = warn;
1880 }
1881
1882 void
lefrSetViaWarnings(int warn)1883 lefrSetViaWarnings(int warn)
1884 {
1885 LEF_INIT;
1886 lefSettings->ViaWarnings = warn;
1887 }
1888
1889 void
lefrDisablePropStrProcess()1890 lefrDisablePropStrProcess()
1891 {
1892 LEF_INIT;
1893 lefSettings->DisPropStrProcess = 1;
1894 }
1895
1896 void
lefrRegisterLef58Type(const char * lef58Type,const char * layerType)1897 lefrRegisterLef58Type(const char *lef58Type,
1898 const char *layerType)
1899 {
1900 LEF_INIT;
1901 const char *typeLayers[] = {layerType, ""};
1902
1903 lefSettings->addLef58Type(lef58Type, typeLayers);
1904 }
1905
1906 END_LEFDEF_PARSER_NAMESPACE
1907
1908