// Most of these could be wrapped if needed
%ignore get_cc;
%ignore get_cc_type_size;
%ignore set_argloc;
%ignore set_dt;
%ignore set_da;
%ignore set_de;
%ignore get_dt;
%ignore get_da;
%ignore get_de;
%ignore skip_ptr_type_header;
%ignore skip_array_type_header;
%ignore unpack_object_from_idb;
%ignore unpack_object_from_bv;
%ignore pack_object_to_idb;
%ignore pack_object_to_bv;
%ignore typend;
%ignore typlen;
%ignore typncpy;
%ignore tppncpy;
%ignore typcmp;
%ignore typdup;
%ignore equal_types;
%ignore resolve_typedef;
%ignore is_resolved_type_const;
%ignore is_resolved_type_void;
%ignore is_resolved_type_ptr;
%ignore is_resolved_type_func;
%ignore is_resolved_type_array;
%ignore is_resolved_type_complex;
%ignore is_resolved_type_struct;
%ignore is_resolved_type_union;
%ignore is_resolved_type_enum;
%ignore is_resolved_type_bitfld;
%ignore is_castable;
%ignore remove_constness;
%ignore remove_pointerness;
%ignore get_int_type_bit;
%ignore get_unk_type_bit;
%ignore tns;

%ignore til_t::base;
%ignore til_t::syms;
%ignore til_t::types;
%ignore til_t::macros;

%ignore add_base_tils;
%ignore sort_til;
%ignore til_add_macro;
%ignore til_next_macro;

%ignore get_type_size;
%ignore get_type_size0;
%ignore skip_type;
%ignore get_pointer_object_size;

%ignore descr_t;

%ignore unpack_type;
%ignore print_type_to_one_line;
%ignore print_type_to_many_lines;
%ignore print_type;
%ignore show_type;
%ignore show_plist;

%ignore extract_pstr;
%ignore extract_name;
%ignore skipName;
%ignore extract_comment;
%ignore skipComment;
%ignore extract_fargcmt;
%ignore skip_argloc;
%ignore extract_argloc;

%ignore h2ti;
%ignore h2ti_warning;
%ignore parse_type;
%ignore parse_types;
%ignore get_named_type;

%ignore set_named_type;
%ignore get_named_type_size;

%ignore decorate_name;
%ignore gen_decorate_name;
%ignore calc_bare_name;
%ignore predicate_t;
%ignore choose_named_type;
%ignore get_default_align;
%ignore align_size;
%ignore align_size;
%ignore get_default_enum_size;
%ignore max_ptr_size;
%ignore based_ptr_name_and_size;
%ignore calc_arglocs;

%ignore apply_type;
%ignore apply_callee_type;
%ignore guess_func_type;
%ignore guess_type;

%ignore build_funcarg_arrays;
%ignore free_funcarg_arrays;
%ignore extract_func_ret_type;
%ignore calc_names_cmts;
%ignore resolve_complex_type;
%ignore visit_strmems;
%ignore foreach_strmem;
%ignore is_type_scalar;
%ignore get_type_signness;
%ignore is_type_signed;
%ignore is_type_unsigned;
%ignore get_struct_member;
%ignore idb_type_to_til;
%ignore get_idb_type;
%ignore apply_type_to_stkarg;
%ignore use_regarg_type_cb;
%ignore set_op_type_t;
%ignore is_stkarg_load_t;
%ignore has_delay_slot_t;
%ignore gen_use_arg_types;
%ignore enable_numbered_types;

%ignore type_pair_vec_t::add_names;

// Kernel-only symbols
%ignore init_til;
%ignore save_til;
%ignore term_til;
%ignore determine_til;
%ignore sync_from_til;
%ignore get_tilpath;
%ignore autoload_til;
%ignore get_idainfo_by_type;
%ignore apply_callee_type;
%ignore propagate_stkargs;
%ignore build_anon_type_name;
%ignore type_names;
%ignore get_compiler_id;
%ignore reloc_info_t;
%ignore relobj_t;
%ignore regobj_t;
%ignore build_func_type;

%include "typeinf.hpp"

%{
//<code(py_typeinf)>
//-------------------------------------------------------------------------
// Utility function to convert a python object to an IDC object
// and sets a python exception on failure.
static bool convert_pyobj_to_idc_exc(PyObject *py_obj, idc_value_t *idc_obj)
{
  int sn = 0;
  if (pyvar_to_idcvar(py_obj, idc_obj, &sn) <= 0)
  {
    PyErr_SetString(PyExc_ValueError, "Could not convert Python object to IDC object!");
    return false;
  }
  return true;
}
//</code(py_typeinf)>
%}
// Custom wrappers

%rename (load_til) load_til_wrap;
%rename (get_type_size0) py_get_type_size0;
%rename (unpack_object_from_idb) py_unpack_object_from_idb;
%rename (unpack_object_from_bv) py_unpack_object_from_bv;
%rename (pack_object_to_idb) py_pack_object_to_idb;
%rename (pack_object_to_bv) py_pack_object_to_bv;
%inline %{
//<inline(py_typeinf)>
//-------------------------------------------------------------------------
PyObject *idc_parse_decl(til_t *ti, const char *decl, int flags)
{
  qtype fields, type;
  qstring name;
  bool ok = parse_decl(ti, decl, &name, &type, &fields, flags);
  if (!ok)
    Py_RETURN_NONE;
  return Py_BuildValue("(sss)", 
    name.c_str(),
    (char *)type.c_str(),
    (char *)fields.c_str());
}

//-------------------------------------------------------------------------
PyObject *py_get_type_size0(const til_t *ti, PyObject *tp)
{
  if (!PyString_Check(tp))
  {
    PyErr_SetString(PyExc_ValueError, "String expected!");
    return NULL;
  }
  size_t sz = get_type_size0(ti, (type_t *)PyString_AsString(tp));
  if (sz == BADSIZE)
    Py_RETURN_NONE;
  return PyInt_FromLong(sz);
}

//-------------------------------------------------------------------------
// Read a typed idc object from the database
PyObject *py_unpack_object_from_idb(
  til_t *ti,
  PyObject *py_type,
  PyObject *py_fields,
  ea_t ea,
  int pio_flags)
{
  if (!PyString_Check(py_type) && !PyString_Check(py_fields))
  {
    PyErr_SetString(PyExc_ValueError, "Typestring must be passed!");
    return NULL;
  }

  // Unpack
  type_t *type   = (type_t *) PyString_AsString(py_type);
  p_list *fields = (p_list *) PyString_AsString(py_fields);
  idc_value_t idc_obj;
  error_t err = unpack_object_from_idb(&idc_obj, ti, type, fields, ea, NULL, pio_flags);

  // Unpacking failed?
  if (err != eOk)
    return Py_BuildValue("(ii)", 0, err);

  // Convert
  PyObject *py_ret(NULL);
  err = idcvar_to_pyvar(idc_obj, &py_ret);
  // Conversion failed?
  if (err != CIP_OK)
    return Py_BuildValue("(ii)", 0, err);
  return Py_BuildValue("(iO)", 1, py_ret);
}

//-------------------------------------------------------------------------
// Read a typed idc object from the byte vector
PyObject *py_unpack_object_from_bv(
  til_t *ti,
  PyObject *py_type,
  PyObject *py_fields,
  PyObject *py_bytes,
  int pio_flags)
{
  if (!PyString_Check(py_type) && !PyString_Check(py_fields) && !PyString_Check(py_bytes))
  {
    PyErr_SetString(PyExc_ValueError, "Incorrect argument type!");
    return NULL;
  }

  // Get type strings
  type_t *type   = (type_t *) PyString_AsString(py_type);
  p_list *fields = (p_list *) PyString_AsString(py_fields);

  // Make a byte vector
  bytevec_t bytes;
  bytes.resize(PyString_Size(py_bytes));
  memcpy(bytes.begin(), PyString_AsString(py_bytes), bytes.size());

  idc_value_t idc_obj;
  error_t err = unpack_object_from_bv(&idc_obj, ti, type, fields, bytes, pio_flags);

  // Unpacking failed?
  if (err != eOk)
    return Py_BuildValue("(ii)", 0, err);

  // Convert
  PyObject *py_ret(NULL);
  err = idcvar_to_pyvar(idc_obj, &py_ret);
  // Conversion failed?
  if (err != CIP_OK)
    return Py_BuildValue("(ii)", 0, err);
  return Py_BuildValue("(iO)", 1, py_ret);
}

//-------------------------------------------------------------------------
// Write a typed idc object to the database
// Raises an exception if wrong parameters were passed or conversion fails
// Returns the error_t returned by idasdk.pack_object_to_idb
PyObject *py_pack_object_to_idb(
  PyObject *py_obj,
  til_t *ti,
  PyObject *py_type,
  PyObject *py_fields,
  ea_t ea,
  int pio_flags)
{
  if (!PyString_Check(py_type) && !PyString_Check(py_fields))
  {
    PyErr_SetString(PyExc_ValueError, "Typestring must be passed!");
    return NULL;
  }

  // Convert Python object to IDC object
  idc_value_t idc_obj;
  if (!convert_pyobj_to_idc_exc(py_obj, &idc_obj))
    return NULL;

  // Get type strings
  type_t *type   = (type_t *) PyString_AsString(py_type);
  p_list *fields = (p_list *) PyString_AsString(py_fields);

  // Pack
  error_t err = pack_object_to_idb(&idc_obj, ti, type, fields, ea, pio_flags);
  return PyInt_FromLong(err);
}

//-------------------------------------------------------------------------
// Returns a tuple(Boolean, PackedBuffer or Error Code)
PyObject *py_pack_object_to_bv(
  PyObject *py_obj,
  til_t *ti,
  PyObject *py_type,
  PyObject *py_fields,
  ea_t base_ea,
  int pio_flags=0)
{
  if (!PyString_Check(py_type) && !PyString_Check(py_fields))
  {
    PyErr_SetString(PyExc_ValueError, "Typestring must be passed!");
    return NULL;
  }

  // Convert Python object to IDC object
  idc_value_t idc_obj;
  if (!convert_pyobj_to_idc_exc(py_obj, &idc_obj))
    return NULL;

  // Get type strings
  type_t *type   = (type_t *) PyString_AsString(py_type);
  p_list *fields = (p_list *) PyString_AsString(py_fields);

  // Pack
  relobj_t bytes;
  error_t err = pack_object_to_bv(
    &idc_obj, 
    ti, 
    type, 
    fields, 
    &bytes, 
    NULL, 
    pio_flags);
  do 
  {
    if (err != eOk)
      break;
    if (!bytes.relocate(base_ea, inf.mf))
    {
      err = -1;
      break;
    }
    return Py_BuildValue("(is#)", 1, bytes.begin(), bytes.size());
  } while (false);
  return Py_BuildValue("(ii)", 0, err);
}
//</inline(py_typeinf)>
til_t * load_til(const char *tildir, const char *name)
{
    char errbuf[4096];
    til_t *res;

    res = load_til(tildir, name, errbuf, sizeof(errbuf));

    if (!res)
    {
        PyErr_SetString(PyExc_RuntimeError, errbuf);
        return NULL;
    }

    return res;
}
%}

%rename (load_til_header) load_til_header_wrap;
%inline %{
til_t * load_til_header_wrap(const char *tildir, const char *name)
{
    char errbuf[4096];
    til_t *res;

    res = load_til_header(tildir, name, errbuf, sizeof(errbuf));;

    if (!res)
    {
        PyErr_SetString(PyExc_RuntimeError, errbuf);
        return NULL;
    }

    return res;
}
%}

%cstring_output_maxsize(char *buf, size_t maxsize);

%inline %{
/* Parse types from a string or file. See ParseTypes() in idc.py */
int idc_parse_types(const char *input, int flags)
{
    int hti = ((flags >> 4) & 7) << HTI_PAK_SHIFT;

    if ((flags & 1) != 0)
        hti |= HTI_FIL;

    return parse_types2(input, (flags & 2) == 0 ? msg : NULL, hti);
}

char *idc_get_type(ea_t ea, char *buf, size_t bufsize)
{
    type_t type[MAXSTR];
    p_list fnames[MAXSTR];

    if (get_ti(ea, type, sizeof(type), fnames, sizeof(fnames)))
    {
        int code = print_type_to_one_line(buf, bufsize, idati, type,
                                          NULL, NULL, fnames);
        if (code == T_NORMAL)
            return buf;
    }                                                              \
    return NULL;
}

char *idc_guess_type(ea_t ea, char *buf, size_t bufsize)
{
    type_t type[MAXSTR];
    p_list fnames[MAXSTR];

    if (guess_type(ea, type, sizeof(type), fnames, sizeof(fnames)))
    {
        int code = print_type_to_one_line(buf, bufsize, idati, type,
                                          NULL, NULL, fnames);
        if (code == T_NORMAL)
            return buf;
    }                                                              \
    return NULL;
}

int idc_set_local_type(int ordinal, const char *dcl, int flags)
{
    if (dcl == NULL || dcl[0] == '\0')
    {
        if (!del_numbered_type(idati, ordinal))
            return 0;
    }
    else
    {
        qstring name;
        qtype type;
        qtype fields;

        if (!parse_decl(idati, dcl, &name, &type, &fields, flags))
            return 0;

        if (ordinal <= 0)
	{
            if (!name.empty())
                ordinal = get_type_ordinal(idati, name.c_str());

            if (ordinal <= 0)
                ordinal = alloc_type_ordinal(idati);
	}

        if (!set_numbered_type(idati, ordinal, 0, name.c_str(), type.c_str(), fields.c_str()))
            return 0;
    }
    return ordinal;
}

int idc_get_local_type(int ordinal, int flags, char *buf, size_t maxsize)
{
    const type_t *type;
    const p_list *fields;

    if (!get_numbered_type(idati, ordinal, &type, &fields))
    {
        buf[0] = 0;
        return false;
    }

    qstring res;
    const char *name = get_numbered_type_name(idati, ordinal);

    if (print_type_to_qstring(&res, NULL, 2, 40, flags, idati, type, name, NULL, fields) <= 0)
    {
        buf[0] = 0;
        return false;
    }

    qstrncpy(buf, res.c_str(), maxsize);
    return true;
}

char idc_get_local_type_name(int ordinal, char *buf, size_t bufsize)
{
    const char *name = get_numbered_type_name(idati, ordinal);

    if (name == NULL)
        return false;

    qstrncpy(buf, name, bufsize);
    return true;
}
%}