def dump_operand_accessors(self,agi):
''' Dump operand accessor to inspect the data
structure xed_operand_storage_t '''
fo_list = []
h_fname = get_operand_accessors_fn()
c_fname = h_fname.replace('.h', '.c')
for opname in list(self.operand_fields.keys()):
getter_fo = self._gen_op_getter_fo(opname)
setter_fo = self._gen_op_setter_fo(opname)
fo_list.append(getter_fo)
fo_list.append(setter_fo)
# generate a generic getter
generic_getter = self._gen_generic_getter()
generic_setter = self._gen_generic_setter()
xeddir = os.path.abspath(agi.common.options.xeddir)
gendir = agi.common.options.gendir
h_file = codegen.xed_file_emitter_t(xeddir,gendir,
h_fname, shell_file=False,
is_private=False)
h_file.add_header(['xed-decoded-inst.h','xed-operand-storage.h'])
h_file.start()
for fo in fo_list:
decl = fo.emit_header()
h_file.add_code(decl)
h_file.add_code(generic_getter.emit_header())
h_file.add_code(generic_setter.emit_header())
for fo in fo_list:
fo.emit_file_emitter(h_file)
h_file.close()
c_file = codegen.file_emitter_t(gendir,
c_fname, shell_file=False)
c_file.add_header(h_fname)
c_file.start()
generic_getter.emit_file_emitter(c_file)
generic_setter.emit_file_emitter(c_file)
c_file.close()
def __init__(self,
type_name,
prefix,
values,
cfn,
hfn,
gendir,
namespace=None,
stream_guard=None,
add_last_element=True,
cplusplus=False,
proto_prefix='',
extra_header=None,
density='automatic',
string_convert=1):
"""
@type type_name: string
@param type_name: the name of the generated type
@type prefix: string
@param prefix: prepended to all enumeration names
@type values: list
@param values: list of L{enumer_value_t} objects
@type cfn: string
@param cfn: output source file name
@type hfn: string
@param hfn: output header file name
@type gendir: string
@param gendir: output directory
@type namespace: string
@param namespace: namespace wrapper
@type stream_guard: string
@param stream_guard: #ifdef test for ostream/istream functionality
@type add_last_element: xed_bool_t
@param add_last_element: If True (default), add a _LAST element.
@type cplusplus: xed_bool_t
@param cplusplus: True=>C++ or False=>C
@type proto_prefix: string
@param proto_prefix: default is empty string. useful for DLL export decorations
@type extra_header: string or list
@param extra_header: another header to include in the .H file.
@type density: string
@param density: density of enumerated values. Can be sparse (default) or dense. Default is automatic which use the presence or absence of preset values to determine density
@type string_convert: integer
@param string_convert: 1=default, generate convert routines, 0=empty stubs, -1=no-stubs or prototypes
"""
self.debug = False
self.proto_prefix = proto_prefix
self.cplusplus = cplusplus
self.type_name = type_name
self.prefix = prefix
self.cfn = cfn
self.hfn = hfn
self.density = density
self.string_convert = string_convert
self.extra_header = extra_header
self.values = self._unique(values) # list of enumer_value_t's
self.can_be_dense = True
self.preset_values = self._scan_for_preset_values(self.values)
if self.preset_values:
self.can_be_dense = \
self._scan_for_dense_zero_based_preset_values(self.values)
#sys.stderr.write("Can be dense %s\n" % (str(self.can_be_dense)))
#sys.stderr.write("Preset values %s\n" % (str(self.preset_values)))
if self.density == 'automatic':
if self.can_be_dense:
self.density = 'dense'
else:
self.density = 'sparse'
if self.preset_values and \
self.can_be_dense == False and \
self.density == 'dense':
sys.stderr.write(
"\nERROR(enumer.py): dense enum had some values specified preventing dense-enum generation\n\n"
)
sys.exit(1)
self.add_last_element = add_last_element
if add_last_element:
self.values.append(enumer_value_t('LAST'))
(unique, duplicates) = self._partition_duplicates(self.values)
# clobber the values with just the unique values
self.values = unique
self.duplicates = duplicates
self.namespace = namespace
self.stream_guard = stream_guard
self.system_headers = ["string.h"]
if self.cplusplus:
self.system_headers.append("cassert")
self.system_headers.append("string")
else:
self.system_headers.append('assert.h')
self.convert_function_headers = [_make_str2foo(), _make_foo2str()]
if self.cplusplus:
self.ostream_function_headers = [
'std::ostream& operator<<(std::ostream& o, const %s& v)',
'std::istream& operator>>(std::istream& o, %s& v)'
]
self.operator_function_headers = [
'%s& operator++(%s& x, int)', '%s& operator--(%s& x, int)'
]
else:
self.ostream_function_headers = []
self.operator_function_headers = []
if self.cplusplus:
namespace = self.namespace
else:
namespace = None
full_header_file_name = mbuild.join(gendir, self.hfn)
self.hf = codegen.file_emitter_t(gendir, self.hfn, namespace=namespace)
if type(self.extra_header) == list:
for hdr in self.extra_header:
self.hf.add_header(hdr)
elif self.extra_header:
self.hf.add_header(self.extra_header)
full_source_file_name = mbuild.join(gendir, self.cfn)
self.cf = codegen.file_emitter_t(gendir, self.cfn, namespace=namespace)
self.cf.add_header(self.hfn)
for sh in self.system_headers:
self.cf.add_system_header(sh)
if self.cplusplus:
if self.stream_guard and self.stream_guard != '':
self.hf.add_misc_header("#if %s==1" % self.stream_guard)
self.hf.add_misc_header("# include <iostream>")
self.hf.add_misc_header("#endif")
else:
self.hf.add_misc_header("#include <iostream>")
self.hf.start()
self.cf.start()
