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()