def loadStyles ( stylesTable, fromFile ):
global displayFile
displayFile = fromFile
try:
# Check for three levels of tuple for a correct <styleTable>.
if not isinstance(stylesTable,tuple):
raise ErrorMessage(1,['Malformed <styleTable>, not even a one level deep tuple.'])
if not isinstance(stylesTable[0],tuple):
raise ErrorMessage(1,['Malformed <styleTable>, only two level deep tuple.'])
for styleTuple in stylesTable:
loadStyleTuple( styleTuple )
except Exception as e:
styleTableExample = [ 'Should be a three level deep tuple:'
,' ( ( (Style, id, description)'
,' , (Entry1, ...)'
,' , (Entry2, ...)'
,' , (EntryN, ...)'
,' )'
,' ,)'
,'If only one style is defined, do not forget the last extra comma.'
,'(putting a level of parenthesis do not create a tuple for one item)'
,'In %s:<styleTable>.' % displayFile
]
ErrorMessage.wrapPrint(e, styleTableExample)
return
def loadGdsLayers ( realLayersTable, confFile ):
realFile = confFile
technology = DataBase.getDB().getTechnology()
entryNo = 0
for entry in realLayersTable:
entryNo += 1
try:
if len(entry) != 3:
raise ErrorMessage(1,['Malformed entry in <realLayersTable>.'
,'Must have exactly three fields: (symb_name,real_name,GDSII_extnb).'
,str(entry)
])
symbName, realName, gdsiiExtractNumber = entry
if not isinstance(gdsiiExtractNumber,int):
raise ErrorMessage(1,['Incoherency in <realLayersTable> entry.'
,'GDSII exctract number is not of int type (%s).' \
% helpers.stype(gdsiiExtractNumber)
,str(entry)
])
basicLayer = technology.getBasicLayer(symbName)
if not basicLayer:
raise ErrorMessage(1,['Incoherency in <realLayersTable> entry.'
,'The real layer "%s" associated to the GDSII "%s" do not exists.' \
% (symbName,realName)
,str(entry)
])
basicLayer.setRealName ( realName )
basicLayer.setExtractNumber( gdsiiExtractNumber )
except Exception, e:
ErrorMessage.wrapPrint(e,'In %s:<realLayersTable> at index %d.' % (realFile,entryNo))
def loadCellGaugesTable(cellGaugesTable, fromFile):
global allianceFile
allianceFile = fromFile
af = AllianceFramework.get()
for gaugeName in cellGaugesTable.keys():
gaugeDatas = cellGaugesTable[gaugeName]
gauge = None
try:
if len(gaugeDatas) != 4:
raise ErrorMessage(1, [
'Malformed gaugeDatas in <cellGaugesTable[%s]>.' %
gaugeName,
'Parameters list must have exactly four fields:',
' (terminal_metal, xy_common_pitch, slice_height, slice_step)',
str(gaugeDatas)
])
gauge = CellGauge.create(
gaugeName,
gaugeDatas[0] # pinLayerName.
,
DbU.fromLambda(gaugeDatas[1]) # pitch.
,
DbU.fromLambda(gaugeDatas[2]) # sliceHeight.
,
DbU.fromLambda(gaugeDatas[3]) # sliceStep.
)
except Exception, e:
ErrorMessage.wrapPrint(
e, 'In %s:<cellGaugesTable> at index %d.' %
(allianceFile, gaugeDatasNo))
if gauge: af.addCellGauge(gauge)
def loadRoutingGaugesTable(routingGaugesTable, fromFile):
global allianceFile
allianceFile = fromFile
af = AllianceFramework.get()
for gaugeName in routingGaugesTable.keys():
gaugeDatas = routingGaugesTable[gaugeName]
technology = DataBase.getDB().getTechnology()
gauge = RoutingGauge.create(gaugeName)
entryNo = 0
for entry in gaugeDatas:
entryNo += 1
try:
if len(entry) != 2:
raise ErrorMessage(1, [
'Malformed entry in <routingGaugesTable[%s]>.' %
gaugeName,
'Must have exactly two fields ("METAL_LAYER", (parameters_list)).',
str(entry)
])
if len(entry[1]) != 8:
raise ErrorMessage(1, [
'Malformed entry in <routingGaugesTable[%s]>.' %
gaugeName,
'Parameters list must have exactly eight fields:',
' (direction, type, depth, density, offset, pitch, wire_width, via_width)',
str(entry)
])
gauge.addLayerGauge(
RoutingLayerGauge.create(
technology.getLayer(entry[0]),
Gauge.toRlGauge(entry[1][0]) # Direction.
,
Gauge.toRlGauge(entry[1][1]) # Type.
,
entry[1][2] # Depth.
,
entry[1][3] # Density.
,
DbU.fromLambda(entry[1][4]) # Offset.
,
DbU.fromLambda(entry[1][5]) # Pitch.
,
DbU.fromLambda(entry[1][6]) # Wire width.
,
DbU.fromLambda(entry[1][7]) # Via width.
))
except Exception, e:
ErrorMessage.wrapPrint(
e, 'In %s:<routingGaugesTable> at index %d.' %
(allianceFile, entryNo))
af.addRoutingGauge(gauge)
def loadViewerConfig ( viewerConfig, confFile ):
global symbolicFile
symbolicFile = confFile
try:
if 'precision' in viewerConfig: DbU.setPrecision(viewerConfig['precision'])
except Exception as e:
ErrorMessage.wrapPrint(e,'In %s:<viewerConfig>.')
return
def loadViewerConfig(viewerConfig, confFile):
global symbolicFile
symbolicFile = confFile
try:
if viewerConfig.has_key('precision'):
DbU.setPrecision(viewerConfig['precision'])
except Exception, e:
ErrorMessage.wrapPrint(e, 'In %s:<viewerConfig>.')
def loadSymbolicRules ( symbolicRulesTable, confFile ):
global symbolicFile
symbolicFile = confFile
technology = DataBase.getDB().getTechnology()
entryNo = 0
for rule in symbolicRulesTable:
entryNo += 1
try:
if len(rule) != 2:
raise ErrorMessage(1,['Malformed entry in <symbolicRulesTable>.'
,'Must contains exactly two fields: ( rule_path, value ).'
,str(rule)
])
if not isinstance(rule[1],int) and not isinstance(rule[1],float):
raise ErrorMessage(1,['Invalid entry in <symbolicRulesTable>.'
,'Rule value must be of integer or float type.'
,str(rule)
])
value = DbU.fromLambda(rule[1])
elements = rule[0].split('.')
if len(elements) < 3:
raise ErrorMessage(1,['Invalid entry in <symbolicRulesTable>.'
,'Rule name must contains at least three components: \"LAYER.category.dimension\".'
,str(rule)
])
ruleLayer = layersLUT.lookup( elements[0], LayersLUT.Symbolic|LayersLUT.MissingError )
subLayer = layersLUT.lookup( elements[1], LayersLUT.Real )
if subLayer: ruleTag = ".".join(elements[2:])
else: ruleTag = ".".join(elements[1:])
if ruleTag == 'extention.cap': ruleLayer.setExtentionCap ( subLayer, value )
elif ruleTag == 'extention.width': ruleLayer.setExtentionWidth( subLayer, value )
elif ruleTag == 'enclosure': ruleLayer.setEnclosure ( subLayer, value )
elif ruleTag == 'minimum.width': ruleLayer.setMinimalSize ( value )
elif ruleTag == 'minimum.side': ruleLayer.setMinimalSize ( value )
else:
raise ErrorMessage(1,['Invalid entry in <symbolicRulesTable>.'
,'Unknown rule kind: \".%s\", should be any of:' % ruleTag
,' * "RULE_HEAD.extention.cap"'
,' * "RULE_HEAD.extention.width"'
,' * "RULE_HEAD.enclosure"'
,' * "RULE_HEAD.minimum.width"'
,' * "RULE_HEAD.minimum.side"'
,str(rule)
])
except Exception as e:
ErrorMessage.wrapPrint(e,'In %s:<symbolicRulesTable> at index %d.' % (symbolicFile,entryNo))
return
def loadWorkingLayers ( workingLayersTable, confFile ):
global symbolicFile
symbolicFile = confFile
technology = DataBase.getDB().getTechnology()
entryNo = 0
for layerName in workingLayersTable:
entryNo += 1
try:
# This call is just to generate an error if the layer is non-existent.
layersLUT.lookup(layerName,LayersLUT.Real|LayersLUT.Symbolic|LayersLUT.MissingError)
technology.setWorkingLayer(layerName)
except Exception as e:
ErrorMessage.wrapPrint(e,'In %s:<symbolicRulesTable> at index %d.' % (symbolicFile,entryNo))
return
def _loadAllianceConfig ( af, allianceConfig ):
env = af.getEnvironment()
entryNo = 0
for entry in allianceConfig:
entryNo += 1
try:
if len(entry) != 2:
raise ErrorMessage(1,['Malformed entry in <allianceConfig>.'
,'Must have exactly two fields ("key", <value>).'
,str(entry)
])
key, value = entry
if key == 'DISPLAY': env.setDISPLAY(value)
if key == 'CATALOG': env.setCATALOG(value)
if key == 'SCALE_X': env.setSCALE_X(value)
if key == 'IN_LO': env.setIN_LO(value)
if key == 'IN_PH': env.setIN_PH(value)
if key == 'OUT_PH': env.setOUT_PH(value)
if key == 'OUT_LO': env.setOUT_LO(value)
if key == 'POWER': env.setPOWER(value)
if key == 'GROUND': env.setGROUND(value)
if key == 'CLOCK': env.setCLOCK(value)
if key == 'BLOCKAGE': env.setBLOCKAGE(value)
if key == 'PAD': env.setPad(value)
if key == 'WORKING_LIBRARY': env.setWORKING_LIBRARY(value)
if key == 'SYSTEM_LIBRARY':
for libraryEntry in value:
if len(libraryEntry) != 2:
raise ErrorMessage(1,['Malformed system library entry in <allianceConfig>.'
,'Must have exactly two fields ("path", <mode>).'
,str(libraryEntry)
])
libPath, mode = libraryEntry
env.addSYSTEM_LIBRARY(library=libPath,mode=AddMode.toEnvironment(mode))
except Exception as e:
ErrorMessage.wrapPrint(e,'In %s:<Alliance> at index %d.' % (allianceFile,entryNo))
try:
env.validate()
except Exception as e:
ErrorMessage.wrapPrint(e,'In %s:<Alliance>.' % (allianceFile))
sys.exit(1)
return
def load(self, allianceConfig, allianceFile):
entryNo = 0
for entry in allianceConfig:
entryNo += 1
try:
if len(entry) != 2:
raise ErrorMessage(1, [
'Malformed entry in <allianceConfig>.',
'Must have exactly two fields ("key", <value>).',
str(entry)
])
key, value = entry
if key == 'ALLIANCE_TOP': self.mbkEnv[key] = value
if key == 'GRAAL_TECHNO_NAME': self.mbkEnv[key] = value
if key == 'RDS_TECHNO_NAME': self.mbkEnv[key] = value
if key == 'CATALOG': self.mbkEnv[key] = value
if key == 'SCALE_X': self.mbkEnv[key] = value
if key == 'IN_LO': self.mbkEnv[key] = value
if key == 'IN_PH': self.mbkEnv[key] = value
if key == 'OUT_PH': self.mbkEnv[key] = value
if key == 'OUT_LO': self.mbkEnv[key] = value
if key == 'POWER': self.mbkEnv[key] = value
if key == 'GROUND': self.mbkEnv[key] = value
if key == 'MBK_TARGET_LIB': self.mbkEnv[key] = value
if key == 'WORKING_LIBRARY': self.mbkEnv[key] = value
if key == 'SYSTEM_LIBRARY':
for libraryEntry in value:
if len(libraryEntry) != 2:
raise ErrorMessage(1, [
'Malformed system library entry in <allianceConfig>.',
'Must have exactly two fields ("path", <mode>).',
str(libraryEntry)
])
libPath, mode = libraryEntry
self.mbkEnv['MBK_CATA_LIB'].add(libPath, mode)
except Exception as e:
ErrorMessage.wrapPrint(
e,
'In %s:<Alliance> at index %d.' % (allianceFile, entryNo))
self.mbkEnv['LD_LIBRARY_PATH'] = self.mbkEnv['ALLIANCE_TOP'] + '/lib'
return
def loadTechnoConfig ( technoConfig, confFile ):
realFile = confFile
technology = DataBase.getDB().getTechnology()
gridValue = 1
gridUnit = DbU.UnitPowerMicro
for key in [ 'gridUnit', 'gridValue', 'gridsPerLambda' ]:
try:
if key == 'gridUnit':
if key in technoConfig:
gridUnit = technoConfig[key]
if gridUnit != DbU.UnitPowerPico and \
gridUnit != DbU.UnitPowerNano and \
gridUnit != DbU.UnitPowerMicro and \
gridUnit != DbU.UnitPowerMilli and \
gridUnit != DbU.UnitPowerUnity and \
gridUnit != DbU.UnitPowerKilo:
raise ErrorMessage(1,'In <technoConfig>, invalid DbU unit power for gridUnit, reseting to Micro.')
else:
raise ErrorMessage(1,'<technoConfig> has no <gridUnit> defined, assuming Micro.')
elif key == 'gridValue':
if 'gridValue' in technoConfig:
gridValue = technoConfig['gridValue']
if not isinstance(gridUnit,float) and not isinstance(gridUnit,int):
raise ErrorMessage(1,['In <technoConfig>, <gridValue> must be of type float (and not: %s).'
% helpers.stype(gridValue)
])
DbU.setPhysicalsPerGrid(gridValue,gridUnit)
else:
raise ErrorMessage(1,'<technoConfig> has no <gridValue> defined.')
elif key == 'gridsPerLambda':
if 'gridsPerLambda' in technoConfig:
gridsPerLambda = technoConfig['gridsPerLambda']
if not isinstance(gridsPerLambda,int):
raise ErrorMessage(1,['In <technoConfig>, <gridsPerLambda> must be of type int (and not: %s).'
% helpers.stype(gridsPerLambda)
])
DbU.setGridsPerLambda(gridsPerLambda)
except Exception as e:
ErrorMessage.wrapPrint(e)
return
def loadPatterns(patternsData, fromFile):
global patternsLUT
global confFile
confFile = fromFile
entryNo = 0
for entry in patternsData:
entryNo += 1
try:
if not isinstance(entry, dict):
raise ErrorMessage(1, [
'Malformed entry in <patternsTable>.',
'Not a dictionary {\'key1\':\'value1\', ...}.',
str(entry)
])
if 'name' not in entry:
raise ErrorMessage(1, [
'Malformed entry in <patternsTable>.',
'Pattern has no \'name\' key.',
str(entry)
])
arguments = {'name': entry['name']}
if 'bits' in entry:
arguments['bits'] = entry['bits']
if 'hexa' in entry:
if 'bits' in entry:
w = WarningMessage(
'Pattern <%s> has both bits & hexa, ignoring hexa.' %
entry['name'])
print(w)
else:
arguments['hexa'] = entry['hexa']
patternsLUT[entry['name']] = Pattern(**arguments)
except Exception as e:
ErrorMessage.wrapPrint(
e, 'In %s:<patternsTable> at index %d.' % (confFile, entryNo))
return
def loadRealLayers(realLayersTable, confFile):
global symbolicFile
symbolicFile = confFile
technology = DataBase.getDB().getTechnology()
entryNo = 0
for entry in realLayersTable:
entryNo += 1
try:
if len(entry) < 2:
raise ErrorMessage(1, [
'Malformed entry in <realLayersTable>.',
'Less than two fields: missing name and/or material.',
str(entry)
])
if len(entry) > 2:
if entry[1] != BasicLayer.Material.blockage:
raise ErrorMessage(1, [
'Invalid entry in <realLayersTable>.',
'Only blockage material can have a third field.',
str(entry)
])
routingLayer = technology.getBasicLayer(entry[2])
if not routingLayer:
raise ErrorMessage(1, [
'Incoherency in <realLayersTable> entry at.',
'The metal <%s> associated to the blockage doesn\'t exist (yet?).'
% entry[2],
str(entry)
])
basicLayer = BasicLayer.create(technology, entry[0],
BasicLayer.Material(entry[1]))
layersLUT.add(basicLayer)
if len(entry) > 2:
routingLayer.setBlockageLayer(basicLayer)
except Exception, e:
ErrorMessage.wrapPrint(
e, 'In %s:<symbolicLayersTable> at index %d.' %
(symbolicFile, entryNo))
raise ErrorMessage(1, [
'Malformed system library entry in <allianceConfig>.',
'Must have exactly two fields ("path", <mode>).',
str(libraryEntry)
])
libPath, mode = libraryEntry
env.addSYSTEM_LIBRARY(library=libPath,
mode=AddMode.toEnvironment(mode))
except Exception, e:
ErrorMessage.wrapPrint(
e, 'In %s:<Alliance> at index %d.' % (allianceFile, entryNo))
try:
env.validate()
except Exception, e:
ErrorMessage.wrapPrint(e, 'In %s:<Alliance>.' % (allianceFile))
sys.exit(1)
return
def loadRoutingGaugesTable(routingGaugesTable, fromFile):
global allianceFile
allianceFile = fromFile
af = AllianceFramework.get()
for gaugeName in routingGaugesTable.keys():
gaugeDatas = routingGaugesTable[gaugeName]
technology = DataBase.getDB().getTechnology()
gauge = RoutingGauge.create(gaugeName)
def loadParameters(parametersData, fromFile):
global confFile
confFile = fromFile
entryNo = 0
for entry in parametersData:
entryNo += 1
try:
if len(entry) < 3:
raise ErrorMessage(1, [
'Malformed entry in <parametersTable>.',
'Less than three fields: (path_name, Type, default_value [,options]).',
str(entry)
])
if len(entry) == 3:
pathName, paramType, value = entry
options = None
elif len(entry) == 4:
pathName, paramType, value, options = entry
else:
raise ErrorMessage(1, [
'Malformed entry in <parametersTable>.',
'More than four fields: (path_name, Type, default_value [,options]).',
str(entry)
])
if paramType == TypeBool:
param = Cfg.getParamBool(pathName)
param.setBool(value)
if paramType == TypeInt:
param = Cfg.getParamInt(pathName)
param.setInt(value)
if paramType == TypeEnumerate:
param = Cfg.getParamEnumerate(pathName)
param.setInt(value)
if paramType == TypePercentage:
param = Cfg.getParamPercentage(pathName)
param.setPercentage(value)
if paramType == TypeDouble:
param = Cfg.getParamDouble(pathName)
param.setDouble(value)
if paramType == TypeString:
param = Cfg.getParamString(pathName)
param.setString(value)
if options and param:
for key in options.keys():
if key == 'min': param.setMin(options[key])
elif key == 'max': param.setMax(options[key])
elif key == 'values':
for name, value in options[key]:
param.addValue(name, value)
elif key == 'slaves':
for slave in options[key]:
param.addSlave(slave)
elif key == 'flags':
param.flags = options[key]
except Exception, e:
ErrorMessage.wrapPrint(
e,
'In %s:<parametersTable> at index %d.' % (confFile, entryNo))
def loadLayout(layoutData, fromFile):
global confFile
confFile = fromFile
layout = Cfg.Configuration.get().getLayout()
tabName = None
entryNo = 0
for entry in layoutData:
entryNo += 1
try:
if not isinstance(entry, tuple):
raise ErrorMessage(1, [
'Malformed entry in <layoutTable>.',
'Not a tuple (a, b, c, ...) or (a,).',
str(entry)
])
if entry[0] == TypeTab:
if len(entry) != 3:
raise ErrorMessage(1, [
'Malformed entry in <layoutTable>.',
'Tab must have exactly three fields: (TypeTab, tab_name, tag).',
str(entry)
])
layoutType, tabName, tagName = entry
layout.addTab(tabName, tagName)
if not tabName:
raise ErrorMessage(1, [
'Bad entry order in <layoutTable>.',
'First entry must be of Tab type.'
])
if entry[0] == TypeTitle:
if len(entry) != 2:
raise ErrorMessage(1, [
'Malformed entry in <layoutTable>.',
'Title must have exactly two fields: (TypeTitle, title).',
str(entry)
])
layoutType, title = entry
layout.addTitle(tabName, title)
elif entry[0] == TypeSection:
if len(entry) != 3:
raise ErrorMessage(1, [
'Malformed entry in <layoutTable>.',
'Section must have exactly three fields: (TypeSection, section, column).',
str(entry)
])
layoutType, section, column = entry
layout.addSection(tabName, section, column)
elif entry[0] == TypeRule:
if len(entry) != 1:
raise ErrorMessage(1, [
'Malformed entry in <layoutTable>.',
'Rule must have exactly one fields: (TypeRule,).',
str(entry)
])
layout.addRule(tabName)
elif entry[0] == TypeOption:
if len(entry) < 4:
raise ErrorMessage(1, [
'Malformed entry in <layoutTable>.',
'Option must have at least four fields: (TypeOption,path_name,text,column[,span,flags]).',
str(entry)
])
if len(entry) == 4:
layoutType, pathName, text, column = entry
layout.addParameter(tabName, pathName, text, column)
elif len(entry) == 5:
layoutType, pathName, text, column, span = entry
layout.addParameter(tabName, pathName, text, column, span)
elif len(entry) == 6:
layoutType, pathName, text, column, span, flags = entry
layout.addParameter(tabName, pathName, text, column, span,
flags)
except Exception, e:
ErrorMessage.wrapPrint(
e, 'In %s:<layoutTable> at index %d.' % (confFile, entryNo))
def loadStyleTuple ( styleTuple ):
style = None
group = 'NoGroup'
entryNo = 0
for styleEntry in styleTuple:
entryNo += 1
try:
if styleEntry[0] == Style:
if len(styleEntry) != 3:
raise ErrorMessage(1,['Malformed entry in <styleTable>.'
,'Style must have exactly three fields: (Style,id,description).'
,str(styleEntry)
])
styleType, styleId, description = styleEntry
if not isinstance(styleId,str):
raise ErrorMessage(1,['The second Style field, <id> must be a string, not a %s.' % helpers.stype(styleId)
,str(styleEntry)])
if not isinstance(description,str):
raise ErrorMessage(1,['The third Style field, <description> must be a string, not a %s.' % helpers.stype(styleId)
,str(styleEntry)])
style = Viewer.DisplayStyle(styleId)
style.setDescription(description)
if not style:
raise ErrorMessage(1,['Bad entry order in <styleTable>.'
,'First entry must be of Style type.'
])
if styleEntry[0] == Inherit:
if len(styleEntry) != 2:
raise ErrorMessage(1,['Malformed entry in <didplayTable>.'
,'Inherit must have exactly two fields: (Inherit,id).'
,str(styleEntry)
])
styleType, styleId = styleEntry
if not isinstance(styleId,str):
raise ErrorMessage(1,['The second Inherit field, <id> must be a string, not a %s.' % helpers.stype(styleId)
,str(styleEntry)])
style.inheritFrom(styleId)
if styleEntry[0] == Darkening:
if len(styleEntry) != 4:
raise ErrorMessage(1,['Malformed entry in <didplayTable>.'
,'Darkening (HSV color) must have exactly four fields: (Darkening,hue,value,saturation).'
,str(styleEntry)
])
styleType, hue, value, saturation = styleEntry
if not isinstance(hue ,float) or \
not isinstance(value ,float) or \
not isinstance(saturation,float) :
raise ErrorMessage(1,['<hue>, <val> & <sat> fields of Darkening must be floats.'
,'%s is (Type, %s, %s, %s)' % (str(styleEntry)
,helpers.stype(hue)
,helpers.stype(value)
,helpers.stype(saturation))
])
style.setDarkening(Viewer.DisplayStyle.HSVr( hue, value, saturation ))
elif styleEntry[0] == Group:
if len(styleEntry) != 2:
raise ErrorMessage(1,['Malformed entry in <styleTable>.'
,'Group must have exactly two fields: (Group,group).'
,str(styleEntry)
])
styleType, group = styleEntry
if not isinstance(group,str):
raise ErrorMessage(1,['The second Group field, <group> must be a string, not a %s.' % helpers.stype(group)
,str(styleEntry)])
elif styleEntry[0] == Drawing:
if len(styleEntry) != 3:
raise ErrorMessage(1,['Malformed entry in <styleTable>.'
,'Rule must have exactly three fields: (Drawing,dname,{dict}).'
,str(styleEntry)
])
styleType, name, options = styleEntry
arguments = { 'group':group, 'name':name }
for key in list(options.keys()):
if key == 'color':
arguments[key] = checkColor(options[key])
continue
elif key == 'border': checkAttribute(options,'border',int)
elif key == 'pattern':
if options[key] in patternsLUT:
arguments[key] = patternsLUT[ options[key] ].hexa
continue
pass
elif key == 'threshold': checkAttribute(options,'threshold',float)
elif key == 'goMatched': checkAttribute(options,'goMatched',bool)
else:
w = WarningMessage( ['Unknown Drawing option: <%s>' % key
,'In %s:<styleTable>:"%s" at index %d.' \
% (displayFile,style.getName(),entryNo)] )
print(w)
continue
arguments[key] = options[key]
style.addDrawingStyle( **arguments )
except Exception as e:
if style:
footer = 'In %s:<styleTable>:"%s" at index %d.' % (displayFile,style.getName(),entryNo)
else:
footer = 'In %s:<styleTable> at index %d.' % (displayFile,entryNo)
ErrorMessage.wrapPrint(e,footer)
if not style: break
if style != None:
Viewer.Graphics.addStyle( style )
return
def loadSymbolicLayers ( symbolicLayersData, confFile ):
global symbolicFile
symbolicFile = confFile
technology = DataBase.getDB().getTechnology()
entryNo = 0
for entry in symbolicLayersData:
entryNo += 1
try:
if len(entry) != 3:
raise ErrorMessage(1,['Malformed entry in <symbolicLayersTable>.'
,'Must contains exactly three fields: ( name, type, (real_layers,) ).'
,str(entry)
])
name, layerType, realLayers = entry
if not isinstance(layerType,SymbolicLayerType):
raise ErrorMessage(1,['Invalid entry in <symbolicLayersTable>.'
,'The layer type code is not valid, should be any of:'
,' * TypeRegular'
,' * TypeDiffusion'
,' * TypeTransistor'
,' * TypeContact'
,' * TypeVia'
,str(entry)
])
if layerType.realLayerLength() != len(realLayers):
raise ErrorMessage(1,['Invalid entry in <symbolicLayersTable>.'
,'Layer of type <%s> contains %d real layers instead of %d.' \
% (layerType,len(realLayers),layerType.realLayerLength())
,str(entry)
])
realLayersArgs = []
for layerName in realLayers:
if layerName:
realLayersArgs += [ layersLUT.lookup(layerName
,LayersLUT.Real
|LayersLUT.Symbolic
|LayersLUT.MissingError) ]
else:
realLayersArgs += [ None ]
symbolicLayer = None
if layerType == TypeRegular:
symbolicLayer = RegularLayer.create(technology,entry[0])
symbolicLayer.setBasicLayer( *realLayersArgs )
elif layerType == TypeDiffusion:
symbolicLayer = DiffusionLayer.create(technology ,entry[0], *realLayersArgs)
elif layerType == TypeTransistor:
symbolicLayer = TransistorLayer.create(technology ,entry[0], *realLayersArgs)
elif layerType == TypeContact:
symbolicLayer = ContactLayer.create(technology ,entry[0], *realLayersArgs)
elif layerType == TypeVia:
symbolicLayer = ViaLayer.create(technology ,entry[0], *realLayersArgs)
layersLUT.add( symbolicLayer )
except Exception as e:
ErrorMessage.wrapPrint(e,'In %s:<symbolicLayersTable> at index %d.' % (symbolicFile,entryNo))
return
