def convert_next_token(self, parsed_object, parsed_object_iter, pnl,
synthesized_pnls, pkg_dict):
"""
Takes individual parsed objects from the parsed line object
Populate ParsedNetlistLine class with all information necessary to create a Statement
Many hacks contained here
"""
temper_bool = False
if (parsed_object.types[0] == SpiritCommon.data_model_type.PARAM_NAME
or parsed_object.types[0]
== SpiritCommon.data_model_type.DEFAULT_PARAM_NAME) and (
pnl.type == ".OPTION" or pnl.local_type == ".OPTIONS"):
pnl.type = ".OPTIONS"
pnl.local_type = ".OPTIONS"
# GITLAB ISSUE #252: all options now will only appear once, at top netlist
if not self._top_level_file:
pnl.flag_top_pnl = True
# find the adm option name
orig_param_name = parsed_object.value.upper()
param_name = orig_param_name
# find all adm packages that use this parameter
pkgs = pkg_dict.get(param_name.upper())
# TODO: Hack Bugzilla 2020, ITL1 => NONLIN MAXSTEP (default 200)
# TODO: Hack Bugzilla 2020, ITL4 => NONLIN-TRAN MAXSTEP (default 20)
# TODO: Hack Bugzilla 2020, VNTOL => ABSTOL
param_name, pkgs = self.hack_packages_bugzilla_2020(
param_name.upper(), pkgs)
if pkgs and param_name.upper() in ["TNOM", "SCALE"]:
if param_name.upper() == "TNOM":
self._tnom_defined = True
pnl.name = ""
if parsed_object.types[
0] == SpiritCommon.data_model_type.PARAM_NAME:
param_value_parsed_object = next(parsed_object_iter)
param_value = param_value_parsed_object.value
else:
param_value = self.get_default(orig_param_name)
pnl.add_known_object(pkgs[0], Types.optionPkgTypeValue)
# converting .OPTIONS METHOD=DEFAULT to .OPTIONS TIMEINT METHOD=TRAP
if param_name.upper() == "METHOD" and param_value.upper(
) == "DEFAULT":
param_value = "TRAP"
pnl.add_param_value_pair(param_name.upper(), param_value)
if "COMMENT" in pnl.params_dict:
pnl.add_inline_comment(pnl.params_dict["COMMENT"])
pnl.params_dict.pop("COMMENT")
for otherPkg in pkgs[1:]:
pnl_synth = ParsedNetlistLine(
pnl.filename,
pnl.linenum) # what to do with line numbers?
pnl_synth.type = ".OPTIONS"
pnl_synth.add_known_object(otherPkg,
Types.optionPkgTypeValue)
pnl_synth.add_param_value_pair(param_name.upper(),
param_value)
synthesized_pnls.append(pnl_synth)
else:
logging.warning("In file:\"" +
str(os.path.basename(pnl.filename)) +
"\" at line:" + str(pnl.linenum) +
". Could not accept .OPTIONS \"" +
orig_param_name.upper() +
"\". Retained (as a comment). Continuing.")
param_value_parsed_object = next(parsed_object_iter)
if pnl.known_objects:
pnl.type = ".OPTIONS"
pnl.name = ""
if pnl.comment:
pnl.add_inline_comment(pnl.comment + " " +
".OPTIONS " + orig_param_name +
" " +
param_value_parsed_object.value)
else:
pnl.add_inline_comment(".OPTIONS " + orig_param_name +
" " +
param_value_parsed_object.value)
else:
pnl.type = "COMMENT"
pnl.name = ".OPTIONS " + orig_param_name
if "COMMENT" in pnl.params_dict:
pnl.add_comment(pnl.params_dict["COMMENT"] + " " +
".OPTIONS " + orig_param_name + " " +
param_value_parsed_object.value)
else:
pnl.add_comment(".OPTIONS " + orig_param_name + " " +
param_value_parsed_object.value)
elif parsed_object.types[
0] == SpiritCommon.data_model_type.DIRECTIVE_NAME and parsed_object.value.upper(
) == ".IF":
pnl.type = "COMMENT"
pnl.add_comment(parsed_object.value)
self._if_statement = True
self._nested_if_statement_count += 1
elif parsed_object.types[
0] == SpiritCommon.data_model_type.DIRECTIVE_NAME and parsed_object.value.upper(
) == ".ELSEIF":
pnl.type = "COMMENT"
pnl.add_comment(parsed_object.value)
elif parsed_object.types[
0] == SpiritCommon.data_model_type.DIRECTIVE_NAME and parsed_object.value.upper(
) == ".ELSE":
pnl.type = "COMMENT"
pnl.add_comment(parsed_object.value)
elif parsed_object.types[
0] == SpiritCommon.data_model_type.DIRECTIVE_NAME and parsed_object.value.upper(
) == ".ENDIF":
pnl.type = "COMMENT"
pnl.add_comment(parsed_object.value)
self._nested_if_statement_count -= 1
if self._nested_if_statement_count == 0:
self._if_statement = False
self._comment_end_of_if_statement = True
elif parsed_object.types[
0] == SpiritCommon.data_model_type.DIRECTIVE_NAME and parsed_object.value.upper(
) == ".MACRO":
pnl.type = ".SUBCKT"
elif parsed_object.types[
0] == SpiritCommon.data_model_type.DIRECTIVE_NAME and parsed_object.value.upper(
) == ".EOM":
pnl.type = ".ENDS"
elif parsed_object.types[
0] == SpiritCommon.data_model_type.DIRECTIVE_NAME and parsed_object.value.upper(
) == ".MEAS":
pnl.type = ".MEASURE"
elif parsed_object.types[
0] == SpiritCommon.data_model_type.DIRECTIVE_NAME and parsed_object.value.upper(
) == ".PROBE" or parsed_object.value.upper() == ".PROBE64":
pnl.type = ".PRINT"
pnl.add_known_object("TRAN",
Types.analysisTypeValue) # default tran type
elif parsed_object.types[
0] == SpiritCommon.data_model_type.OUTPUT_VARIABLE:
#remove [] from HSPICE print variables -- eventually this will be replaced in the writer
output_variable_clean = self.clean_hspice_output_variable(
parsed_object.value)
pnl.add_output_variable_value(output_variable_clean)
elif parsed_object.types[
0] == SpiritCommon.data_model_type.MODEL_TYPE and pnl.type == ".MODEL":
# convert hspice type into the general type supported by the ADM
adm_type = hspice_to_adm_model_type_map.get(
parsed_object.value.upper())
# if not mapped, then use current value
if not adm_type:
adm_type = parsed_object.value.upper()
pnl.add_known_object(adm_type, Types.modelType)
# create a pnl for model binning option
if "." in pnl.name:
pnl_synth = ParsedNetlistLine(
pnl.filename, [0]) # what to do with line numbers?
pnl_synth.type = ".OPTIONS"
pnl_synth.local_type = ".OPTIONS"
pnl_synth.add_known_object("PARSER", Types.optionPkgTypeValue)
pnl_synth.add_param_value_pair("model_binning", "true")
pnl_synth.flag_top_pnl = True
synthesized_pnls.append(pnl_synth)
elif parsed_object.types[
0] == SpiritCommon.data_model_type.GENERALNODE and not pnl.type in [
".IC", ".DCVOLT", ".NODESET"
]:
output_node = parsed_object.value.replace(".", ":")
if BoostParserInterface.boost_xdm_map_dict[parsed_object.types[
0]] in pnl.known_objects and pnl.type == ".GLOBAL":
pnl_synth = ParsedNetlistLine(pnl.filename, pnl.linenum)
pnl_synth.type = ".GLOBAL"
pnl_synth.local_type = ".GLOBAL"
pnl_synth.add_known_object(
output_node, BoostParserInterface.boost_xdm_map_dict[
parsed_object.types[0]])
synthesized_pnls.append(pnl_synth)
else:
pnl.add_known_object(
output_node, BoostParserInterface.boost_xdm_map_dict[
parsed_object.types[0]])
elif parsed_object.types[
0] == SpiritCommon.data_model_type.FUNC_NAME_VALUE:
# For lines with mixed parameter and function statements in HSPICE, separate them out
# into different ParsedNetlistLine objects and store it in synthesized pnl
if pnl.params_dict or "FUNC_EXPRESSION" in pnl.known_objects:
pnl_synth = ParsedNetlistLine(
pnl.filename, pnl.linenum) # what to do with line numbers?
pnl_synth.type = ".FUNC"
pnl_synth.local_type = ".FUNC"
pnl_synth.add_known_object(
parsed_object.value,
BoostParserInterface.boost_xdm_map_dict[
parsed_object.types[0]])
func_arg_parsed_object = next(parsed_object_iter)
while func_arg_parsed_object.types[
0] == SpiritCommon.data_model_type.FUNC_ARG_VALUE:
pnl_synth.add_func_arg_value(func_arg_parsed_object.value)
func_arg_parsed_object = next(parsed_object_iter)
func_expression_parsed_object = func_arg_parsed_object
temper_bool = self.hack_detect_temper(
func_expression_parsed_object.value)
processed_value = self.hack_ternary_operator(
func_expression_parsed_object.value)
processed_value = self.hack_exponentiation_symbol(
processed_value)
pnl_synth.add_known_object(
processed_value, BoostParserInterface.boost_xdm_map_dict[
func_expression_parsed_object.types[0]])
synthesized_pnls.append(pnl_synth)
else:
pnl.type = ".FUNC"
pnl.local_type = ".FUNC"
pnl.add_known_object(
parsed_object.value,
BoostParserInterface.boost_xdm_map_dict[
parsed_object.types[0]])
func_arg_parsed_object = next(parsed_object_iter)
while func_arg_parsed_object.types[
0] == SpiritCommon.data_model_type.FUNC_ARG_VALUE:
pnl.add_func_arg_value(func_arg_parsed_object.value)
func_arg_parsed_object = next(parsed_object_iter)
func_expression_parsed_object = func_arg_parsed_object
temper_bool = self.hack_detect_temper(
func_expression_parsed_object.value)
processed_value = self.hack_ternary_operator(
func_expression_parsed_object.value)
processed_value = self.hack_exponentiation_symbol(
processed_value)
pnl.add_known_object(
processed_value, BoostParserInterface.boost_xdm_map_dict[
func_expression_parsed_object.types[0]])
elif parsed_object.types[0] == SpiritCommon.data_model_type.PARAM_NAME:
param_value_parsed_object = next(parsed_object_iter)
if param_value_parsed_object.types[
0] != SpiritCommon.data_model_type.PARAM_VALUE:
logging.error(
"Line(s):" + str(pnl.linenum) +
". Parser passed wrong token. Expected PARAM_VALUE. Got "
+ str(param_value_parsed_object.types[0]))
raise Exception(
"Next Token is not a PARAM_VALUE. Something went wrong!")
if pnl.type == ".FUNC":
# Same as above, for lines with mixed parameter and function statements in HSPICE, separate them out
# into different ParsedNetlistLine objects and store it in synthesized pnl
if synthesized_pnls:
temper_bool = self.hack_detect_temper(
param_value_parsed_object.value)
processed_value = self.hack_ternary_operator(
param_value_parsed_object.value)
processed_value = self.hack_exponentiation_symbol(
processed_value)
synthesized_pnls[-1].add_param_value_pair(
parsed_object.value.upper(), processed_value)
else:
pnl_synth = ParsedNetlistLine(
pnl.filename,
pnl.linenum) # what to do with line numbers?
pnl_synth.type = ".PARAM"
pnl_synth.local_type = ".PARAM"
temper_bool = self.hack_detect_temper(
param_value_parsed_object.value)
processed_value = self.hack_ternary_operator(
param_value_parsed_object.value)
processed_value = self.hack_exponentiation_symbol(
processed_value)
pnl_synth.add_param_value_pair(parsed_object.value.upper(),
processed_value)
synthesized_pnls.append(pnl_synth)
else:
temper_bool = self.hack_detect_temper(
param_value_parsed_object.value)
processed_value = self.hack_ternary_operator(
param_value_parsed_object.value)
if pnl.type in [
".PARAM", ".SUBCKT", ".MODEL", ".MACRO",
".GLOBAL_PARAM"
] or pnl.type in supported_devices:
processed_value = self.curly_braces_for_expressions(
processed_value)
processed_value = self.hack_exponentiation_symbol(
processed_value)
pnl.add_param_value_pair(parsed_object.value.upper(),
processed_value)
elif parsed_object.types[
0] == SpiritCommon.data_model_type.PARAM_VALUE and pnl.params_dict:
# Same as above, for lines with mixed parameter and function statements in HSPICE, separate them out
# into different ParsedNetlistLine objects and store it in synthesized pnl
if pnl.type == ".FUNC":
last_key = synthesized_pnls[-1].params_dict.keys()[-1]
prev_param_value = synthesized_pnls[-1].params_dict[last_key]
temper_bool = self.hack_detect_temper(parsed_object.value)
processed_value = self.hack_ternary_operator(
parsed_object.value)
processed_value = self.hack_exponentiation_symbol(
processed_value)
synthesized_pnls[-1].params_dict[
last_key] = prev_param_value + " " + processed_value
else:
last_key = pnl.params_dict.keys()[-1]
prev_param_value = pnl.params_dict[last_key]
temper_bool = self.hack_detect_temper(parsed_object.value)
processed_value = self.hack_ternary_operator(
parsed_object.value)
if pnl.type in [
".PARAM", ".SUBCKT", ".MODEL", ".MACRO",
".GLOBAL_PARAM"
] or pnl.type in supported_devices:
processed_value = self.curly_braces_for_expressions(
processed_value)
processed_value = self.hack_exponentiation_symbol(
processed_value)
pnl.params_dict[
last_key] = prev_param_value + " " + processed_value
elif parsed_object.types[0] == SpiritCommon.data_model_type.COMMENT:
pnl.type = "COMMENT"
if parsed_object.value.startswith("//"):
pnl.name = parsed_object.value[2:]
pnl.add_comment(parsed_object.value[2:])
else:
pnl.name = parsed_object.value[1:]
pnl.add_comment(parsed_object.value[1:])
elif parsed_object.types == [
SpiritCommon.data_model_type.MODEL_NAME,
SpiritCommon.data_model_type.VALUE
]:
lst = []
for typ in parsed_object.types:
lst.append(BoostParserInterface.boost_xdm_map_dict[typ])
temper_bool = self.hack_detect_temper(parsed_object.value)
processed_value = self.hack_ternary_operator(parsed_object.value)
processed_value = self.hack_exponentiation_symbol(processed_value)
pnl.add_lazy_statement(processed_value, lst)
# for resistors, check if the resistance is an ABM expression involving a voltage
# at a node or between two nodes. Change into a B-element if it is.
if pnl.type == "R" and self.hack_detect_abm(parsed_object.value):
pnl.type = "B"
pnl.local_type = "B"
processed_value = self.hack_exponentiation_symbol(
parsed_object.value.strip("'"))
pnl.add_known_object(
"{V(%s,%s)/(%s)}" %
(pnl.known_objects["POS_NODE_NAME"],
pnl.known_objects["NEG_NODE_NAME"], processed_value),
Types.expression)
pnl.add_known_object(
"{V(%s,%s)/(%s)}" %
(pnl.known_objects["POS_NODE_NAME"],
pnl.known_objects["NEG_NODE_NAME"], processed_value),
Types.current)
pnl.lazy_statement = {}
elif parsed_object.types[0] in [
SpiritCommon.data_model_type.DC_VALUE_VALUE,
SpiritCommon.data_model_type.AC_MAG_VALUE,
SpiritCommon.data_model_type.AC_PHASE_VALUE
]:
processed_value = self.curly_braces_for_expressions(
parsed_object.value)
pnl.add_known_object(
processed_value, BoostParserInterface.boost_xdm_map_dict[
parsed_object.types[0]])
elif parsed_object.types[
0] == SpiritCommon.data_model_type.DATA_TABLE_NAME:
if pnl.type == ".DATA":
pnl.add_known_object(
parsed_object.value,
BoostParserInterface.boost_xdm_map_dict[
parsed_object.types[0]])
elif pnl.type == ".TRAN":
pnl_synth = ParsedNetlistLine(pnl.filename, pnl.linenum)
pnl_synth.type = ".STEP"
pnl_synth.local_type = ".STEP"
pnl_synth.add_sweep_param_value("DATA")
pnl_synth.add_sweep_param_value(parsed_object.value)
synthesized_pnls.append(pnl_synth)
elif pnl.type == ".DC" or pnl.type == ".AC":
pnl.add_sweep_param_value("DATA")
pnl.add_sweep_param_value(parsed_object.value)
elif parsed_object.types[
0] == SpiritCommon.data_model_type.TRANS_REF_NAME:
processed_value = self.curly_braces_for_expressions(
parsed_object.value)
pnl.add_transient_value(processed_value)
elif parsed_object.types[
0] == SpiritCommon.data_model_type.CONDITIONAL_STATEMENT:
comment = pnl.params_dict[Types.comment] + parsed_object.value
pnl.add_comment(comment)
else:
XyceNetlistBoostParserInterface.convert_next_token(
parsed_object, parsed_object_iter, pnl, synthesized_pnls)
# if "TEMPER" special variable detected, a .GLOBAL_PARAM statement pnl will be synthesized and flagged
# to indicate it belongs at the top circuit level
if temper_bool:
hack_pnl_synth = ParsedNetlistLine(pnl.filename, [0])
hack_pnl_synth.type = ".GLOBAL_PARAM"
hack_pnl_synth.local_type = ".GLOBAL_PARAM"
hack_pnl_synth.add_param_value_pair("XYCE_TEMPER", "25")
hack_pnl_synth.flag_top_pnl = True
synthesized_pnls.append(hack_pnl_synth)
def convert_next_token(self, parsed_object, parsed_object_iter, pnl,
synthesized_pnls):
"""
Takes individual parsed objects from the parsed line object
Populate ParsedNetlistLine class with all information necessary to create a Statement
Many hacks contained here
"""
temp_bool = False
if parsed_object.types[
0] == SpiritCommon.data_model_type.BLOCK_DELIMITER:
if parsed_object.value == "{":
self._delimited_block = True
else:
self._delimited_block = False
if self._if_statement:
self._if_statement = False
self._comment_end_of_if_statement = True
elif self._if_statement:
pnl.type = "COMMENT"
elif parsed_object.types[
0] == SpiritCommon.data_model_type.DIRECTIVE_NAME or parsed_object.types[
0] == SpiritCommon.data_model_type.DEVICE_TYPE:
if spectre_to_adm_model_type_map.get(parsed_object.value):
pnl.type = spectre_to_adm_model_type_map[parsed_object.value]
pnl.local_type = parsed_object.value
else:
logging.warning(
"Possible error. Spectre type not recognized: " +
str(parsed_object.value))
# If directive is .GLOBAL, for now get rid of first listed node. This first node is
# considered a ground node.
if pnl.type == ".GLOBAL":
next(parsed_object_iter)
if pnl.type == "if":
pnl.type = "COMMENT"
pnl.add_comment(parsed_object.value)
self._if_statement = True
elif parsed_object.types[
0] == SpiritCommon.data_model_type.MODEL_NAME and not pnl.type == ".MODEL":
if spectre_to_adm_model_type_map.get(parsed_object.value):
pnl.type = spectre_to_adm_model_type_map[parsed_object.value]
pnl.local_type = parsed_object.value
else:
pnl.add_known_object(parsed_object.value, Types.modelName)
elif parsed_object.types[
0] == SpiritCommon.data_model_type.MODEL_TYPE and pnl.type == ".MODEL":
adm_type = spectre_to_adm_model_type_map.get(parsed_object.value)
# For Spectre, different models aren't distinguished by a "LEVEL" parameter. Instead,
# it uses a name to distinguish what model is being used (ex., bsimsoi instead of
# LEVEL=10, or vbic instead of LEVEL=10).
if adm_type == "M" or adm_type == "Q" or adm_type == "J":
pnl.add_param_value_pair("LEVEL", parsed_object.value)
if not adm_type:
adm_type = parsed_object.value
# Default to NMOS for type
if adm_type == "M":
pnl.add_known_object("NMOS", Types.modelType)
pnl.add_param_value_pair("type", "N")
elif adm_type == "J":
pnl.add_known_object("NJF", Types.modelType)
pnl.add_param_value_pair("type", "N")
else:
pnl.add_known_object(adm_type, Types.modelType)
elif parsed_object.types[
0] == SpiritCommon.data_model_type.DEVICE_NAME or (
parsed_object.types[0]
== SpiritCommon.data_model_type.MODEL_NAME
and pnl.type == ".MODEL"):
pnl.name = parsed_object.value
elif pnl.type == ".DC":
# .DC and .AC directives need four PARAM_NAME/PARAM_VALUE pairs - a sweep variable name,
# a start value, a stop value, and a step value
if not pnl.sweep_param_list:
pnl.add_unused_sweep_params("dc")
sweep_list = ["", "", "", ""]
for sweep_item in sweep_list:
pnl.add_sweep_param_value(sweep_item)
if parsed_object.types[
0] == SpiritCommon.data_model_type.DC_SWEEP_DEV:
pnl.add_unused_sweep_params("dev=" + parsed_object.value)
# Only save if dc analysis does not involve a param
if not pnl.sweep_param_list[0]:
pnl.sweep_param_list[0] = parsed_object.value
pnl.flag_unresolved_device = True
elif parsed_object.types[
0] == SpiritCommon.data_model_type.DC_SWEEP_PARAM:
pnl.add_unused_sweep_params("param=" + parsed_object.value)
if not parsed_object.value == "dc":
# Overwrite dc analysis with dev if it exists, reset unresolved
# device flag to False
pnl.sweep_param_list[0] = parsed_object.value
pnl.flag_unresolved_device = False
elif parsed_object.types[
0] == SpiritCommon.data_model_type.DC_SWEEP_START:
pnl.sweep_param_list[1] = parsed_object.value
elif parsed_object.types[
0] == SpiritCommon.data_model_type.DC_SWEEP_STOP:
pnl.sweep_param_list[2] = parsed_object.value
elif parsed_object.types[
0] == SpiritCommon.data_model_type.DC_SWEEP_STEP:
pnl.sweep_param_list[3] = parsed_object.value
elif parsed_object.types[
0] == SpiritCommon.data_model_type.PARAM_NAME:
sweep_param_name = parsed_object.value
sweep_parsed_object = next(parsed_object_iter)
if not sweep_parsed_object.types[
0] == SpiritCommon.data_model_type.PARAM_VALUE:
logging.error(
"Line(s):" + str(pnl.linenum) +
". Parser passed wrong token. Expected PARAM_VALUE. Got "
+ str(sweep_parsed_object.types[0]))
raise Exception(
"Next Token is not a PARAM_VALUE. Something went wrong!"
)
sweep_param_value = sweep_parsed_object.value
pnl.add_unused_sweep_params(sweep_param_name + "=" +
sweep_param_value)
# For translation of port instance parameters to names recognized internally by XDM
elif parsed_object.types[
0] == SpiritCommon.data_model_type.PARAM_NAME and pnl.type == "P":
param_value_parsed_object = next(parsed_object_iter)
if parsed_object.value == "num":
pnl.add_param_value_pair("PORT",
param_value_parsed_object.value)
elif parsed_object.value == "r":
pnl.add_param_value_pair("Z0", param_value_parsed_object.value)
elif parsed_object.value == "mag":
pnl.add_param_value_pair("AC", param_value_parsed_object.value)
elif parsed_object.value == "type":
pass
else:
pnl.add_param_value_pair(parsed_object.value.upper(),
param_value_parsed_object.value)
elif parsed_object.types[
0] == SpiritCommon.data_model_type.GENERALNODE and not pnl.type in [
".IC", ".DCVOLT", ".NODESET"
]:
output_node = parsed_object.value
if BoostParserInterface.boost_xdm_map_dict[parsed_object.types[
0]] in pnl.known_objects and pnl.type == ".GLOBAL":
pnl_synth = ParsedNetlistLine(pnl.filename, pnl.linenum)
pnl_synth.type = ".GLOBAL"
pnl_synth.local_type = ".GLOBAL"
pnl_synth.add_known_object(
output_node, BoostParserInterface.boost_xdm_map_dict[
parsed_object.types[0]])
synthesized_pnls.append(pnl_synth)
else:
pnl.add_known_object(
output_node, BoostParserInterface.boost_xdm_map_dict[
parsed_object.types[0]])
elif parsed_object.types[0] == SpiritCommon.data_model_type.PARAM_NAME:
# For Spectre, the polarity of the device (ex. NMOS or PMOS, or NPN or PNP)
# isn't declared as a separate identifier in the .MODEL statement. Instead,
# it is saved as a model parameter called "type". The polarity needs to be
# extracted and saved in the data model consistent with SPICE parsing
if pnl.type == ".MODEL" and parsed_object.value.upper() == "TYPE":
param_value_parsed_object = next(parsed_object_iter)
if pnl.known_objects.get(Types.modelType).endswith("MOS"):
pnl.add_known_object(
param_value_parsed_object.value.upper() + "MOS",
Types.modelType)
elif pnl.known_objects.get(Types.modelType).endswith("JF"):
pnl.add_known_object(
param_value_parsed_object.value.upper() + "JF",
Types.modelType)
else:
pnl.add_known_object(param_value_parsed_object.value,
Types.modelType)
pnl.add_param_value_pair(parsed_object.value,
param_value_parsed_object.value)
elif pnl.type == ".MODEL" and parsed_object.value.upper(
) == "VERSION":
param_value_parsed_object = next(parsed_object_iter)
pnl.add_param_value_pair(parsed_object.value.upper(),
param_value_parsed_object.value)
elif not parsed_object.value == "wave":
param_value_parsed_object = next(parsed_object_iter)
if pnl.type and pnl.type == ".TRAN":
self.set_tran_param(pnl, parsed_object.value,
param_value_parsed_object.value)
elif pnl.type and pnl.type == "V" or pnl.type == "I":
processed_value = param_value_parsed_object.value
# Some source paramters don't need curly braces, such as:
# The "type" parameter indicates source type, such as PULSE or PWL.
# The "file" parameter indicates the file to be opened.
if not parsed_object.value == "type" and not parsed_object.value == "file":
processed_value, temp_bool, msg = convert_to_xyce(
processed_value)
processed_value = self.hack_ternary_operator(
processed_value)
pnl.source_params[parsed_object.value] = processed_value
else:
if param_value_parsed_object.types[
0] != SpiritCommon.data_model_type.PARAM_VALUE:
raise Exception(
"Next Token is not a PARAM_VALUE. Something went wrong!"
)
if (parsed_object.value.upper()
== "M") and pnl.type not in ['R', 'L', 'C']:
pnl.m_param = param_value_parsed_object.value
msg = None
# expression = None
if param_value_parsed_object.value.startswith(
'[') and param_value_parsed_object.value.endswith(
']'):
expression = param_value_parsed_object.value
elif is_a_number(param_value_parsed_object.value):
processed_value = param_value_parsed_object.value
expression = convert_si_unit_prefix(processed_value)
else:
# For parameters that refer to control devices, skip convert_to_xyce
# In the future, this will include cccs, etc.
processed_value, temp_bool, msg = convert_to_xyce(
param_value_parsed_object.value)
expression = self.hack_ternary_operator(
processed_value)
if expression:
pnl.add_param_value_pair(parsed_object.value,
expression)
else:
pnl.add_param_value_pair(
parsed_object.value,
param_value_parsed_object.value)
if msg:
logging.warning("Error in expression: " + msg +
str(parsed_object.value))
elif parsed_object.types[
0] == SpiritCommon.data_model_type.DC_VALUE_VALUE:
processed_value, temp_bool, msg = convert_to_xyce(
parsed_object.value)
processed_value = self.hack_ternary_operator(processed_value)
pnl.add_lazy_statement(
processed_value, BoostParserInterface.boost_xdm_map_dict[
parsed_object.types[0]])
elif parsed_object.types[0] in [
SpiritCommon.data_model_type.AC_MAG_VALUE,
SpiritCommon.data_model_type.AC_PHASE_VALUE
]:
processed_value, temp_bool, msg = convert_to_xyce(
parsed_object.value)
processed_value = self.hack_ternary_operator(processed_value)
if parsed_object.types[
0] == SpiritCommon.data_model_type.AC_MAG_VALUE:
pnl.add_known_object("AC", Types.acValue)
pnl.add_known_object(
processed_value, BoostParserInterface.boost_xdm_map_dict[
parsed_object.types[0]])
elif parsed_object.types[
0] == SpiritCommon.data_model_type.CONTROL_DEVICE:
control_dev_name_obj = next(parsed_object_iter)
if control_dev_name_obj.types[
0] != SpiritCommon.data_model_type.CONTROL_DEVICE_NAME:
logging.error(
"Line(s):" + str(pnl.linenum) +
". Parser passed wrong token. Expected CONTROL_DEVICE_NAME. Got "
+ str(control_dev_name_obj.types[0]))
raise Exception(
"Next Token is not a CONTROL_DEVICE_NAME. Something went wrong!"
)
pnl.add_control_param_value(control_dev_name_obj.value)
elif parsed_object.types[
0] == SpiritCommon.data_model_type.OUTPUT_VARIABLE:
formatted_output_variable = format_output_variable(
parsed_object.value)
pnl.add_output_variable_value(formatted_output_variable)
elif parsed_object.types[
0] == SpiritCommon.data_model_type.UNKNOWN_NODE:
pnl.add_unknown_node(parsed_object.value)
elif parsed_object.types[0] == SpiritCommon.data_model_type.COMMENT:
# If a comment comes in the middle of a delimited block, synthesize a PNL
# object for the comment and leave the original PNL unmolested
if self._delimited_block:
pnl_synth = ParsedNetlistLine(pnl.filename, [pnl.linenum[-1]])
pnl_synth.type = "COMMENT"
pnl_synth.name = parsed_object.value
pnl_synth.add_comment(parsed_object.value)
synthesized_pnls.append(pnl_synth)
else:
pnl.type = "COMMENT"
pnl.name = parsed_object.value
pnl.add_comment(parsed_object.value)
elif parsed_object.types[
0] == SpiritCommon.data_model_type.LIB_ENTRY and pnl.type and not pnl.type == ".ENDL":
# convert to .lib from .include
pnl.type = ".LIB"
pnl.add_known_object(
parsed_object.value, BoostParserInterface.boost_xdm_map_dict[
parsed_object.types[0]])
elif parsed_object.types[
0] == SpiritCommon.data_model_type.FUNC_EXPRESSION:
processed_value, temp_bool, msg = convert_to_xyce(
parsed_object.value)
processed_value = self.hack_ternary_operator(processed_value)
if not processed_value.startswith("{"):
processed_value = "{" + processed_value + "}"
pnl.add_known_object(
processed_value, BoostParserInterface.boost_xdm_map_dict[
parsed_object.types[0]])
elif parsed_object.types[
0] == SpiritCommon.data_model_type.CONDITIONAL_STATEMENT:
comment = pnl.params_dict[Types.comment] + parsed_object.value
pnl.add_comment(comment)
elif parsed_object.types[
0] == SpiritCommon.data_model_type.BINNED_MODEL_NAME:
# create a pnl for model binning option
if not self._write_model_binning_option:
pnl_synth = ParsedNetlistLine(
pnl.filename, [0]) # what to do with line numbers?
pnl_synth.type = ".OPTIONS"
pnl_synth.local_type = ".OPTIONS"
pnl_synth.add_known_object("PARSER", Types.optionPkgTypeValue)
pnl_synth.add_param_value_pair("model_binning", "true")
synthesized_pnls.append(pnl_synth)
self._model_binning_option = True
# if "." already in model name, need to create synthesized pnl for next
# binned model
if "." in pnl.name:
model_name = pnl.name.split(".")[0]
pnl_synth = ParsedNetlistLine(pnl.filename, [pnl.linenum[-1]])
pnl_synth.type = ".MODEL"
pnl_synth.local_type = "model"
pnl_synth.name = model_name + "." + parsed_object.value
pnl_synth.add_param_value_pair("LEVEL",
pnl.params_dict["LEVEL"])
pnl_synth.add_known_object(pnl.known_objects["MODEL_TYPE"],
Types.modelType)
synthesized_pnls.append(pnl_synth)
self._modify_synth_pnl = True
else:
pnl.name = pnl.name + "." + parsed_object.value
elif parsed_object.types[
0] == SpiritCommon.data_model_type.VOLTAGE or parsed_object.types[
0] == SpiritCommon.data_model_type.CURRENT:
expression_obj = next(parsed_object_iter)
if expression_obj.types[
0] != SpiritCommon.data_model_type.EXPRESSION:
logging.error(
"Line(s):" + str(pnl.linenum) +
". Parser passed wrong token. Expected EXPRESSION. Got "
+ str(expression_obj.types[0]))
raise Exception(
"Next Token is not a EXPRESSION. Something went wrong!")
processed_value, temp_bool, msg = convert_to_xyce(
expression_obj.value)
processed_value = self.hack_ternary_operator(processed_value)
pnl.add_known_object(processed_value, Types.expression)
if parsed_object.types[0] == SpiritCommon.data_model_type.VOLTAGE:
pnl.add_known_object(processed_value, Types.voltage)
if parsed_object.types[0] == SpiritCommon.data_model_type.CURRENT:
pnl.add_known_object(processed_value, Types.current)
else:
if is_a_number(parsed_object.value):
parsed_object.value = convert_si_unit_prefix(
parsed_object.value)
XyceNetlistBoostParserInterface.convert_next_token(
parsed_object, parsed_object_iter, pnl, synthesized_pnls)
# if "temp" special variable detected, a .GLOBAL_PARAM statement pnl will be synthesized and flagged
# to indicate it belongs at the top circuit level
if temp_bool:
hack_pnl_synth = ParsedNetlistLine(pnl.filename, [0])
hack_pnl_synth.type = ".GLOBAL_PARAM"
hack_pnl_synth.local_type = ".GLOBAL_PARAM"
hack_pnl_synth.add_param_value_pair("XYCE_temp", "27")
hack_pnl_synth.flag_top_pnl = True
synthesized_pnls.append(hack_pnl_synth)