This is the first header included in the IDA project. More...

Classes
struct	qstatbuf
	Describes miscellaneous file attributes. More...

struct	interr_exc_t

class	qvector< T >
	Reimplementation of vector class from STL. More...

class	qstack< T >
	Reimplementation of stack class from STL. More...

class	pool_allocator_t< T >
	A custom allocator for containers. More...

class	qrefcnt_t< T >
	Smart pointer to objects derived from qrefcnt_obj_t. More...

class	qrefcnt_obj_t
	Base class for reference count objects. More...

class	qiterator< T >
	Interface class for iterator types. More...

class	_qstring< qchar >
	Reimplementation of the string class from STL. More...

struct	std::hash< _qstring< T > >

class	bytevec_t
	Vector of bytes (use for dynamic memory) More...

struct	reloc_info_t
	Relocation information (relocatable objects - see relobj_t) More...

struct	relobj_t
	Relocatable object. More...

class	qlist< T >
	Linked list Note: linked list is not movable! More...

struct	memory_deserializer_t

struct	janitor_t< T >
	Resource janitor to facilitate use of the RAII idiom. More...

struct	has_compare_method< typename, typename >
	Template to compare any 2 values of the same type. Returns -1/0/1. More...

struct	has_compare_method< T, qvoid_t< decltype(std::declval< T >().compare(std::declval< T >()))> >

struct	channel_redir_t
	Tools for command line parsing. More...

struct	cliopt_t

struct	cliopts_t

struct	plugin_option_t
	Named option, supports two kinds of options: string option: <name>=bool option: <name>=[on\|off]. More...

struct	instant_dbgopts_t
	Options for instant debugging. More...

struct	launch_process_params_t
	Information for launching a process with IDA API Note: all string data such as paths (e.g., 'path', 'args' & 'startdir') or 'env' should be UTF-8 encoded. More...

class	qmutex_locker_t
	Mutex locker object. Will lock a given mutex upon creation and unlock it when the object is destroyed. More...

Namespaces
namespace	interval
	Functions to work with intervals.

Macros
#define	IDA_SDK_VERSION 820
	IDA SDK v8.2.

#define	BADMEMSIZE 0x7FFFFFFFul

#define	ENUM_SIZE(t) : t

#define	_CRT_DECLARE_NONSTDC_NAMES 1

#define	WIN32_LEAN_AND_MEAN

#define	STL_SUPPORT_PRESENT

#define	EXTERNC extern "C"

#define	C_INCLUDE

#define	C_INCLUDE_END }

#define	INLINE inline

#define	MAXSTR 1024
	maximum string size

#define	SMAXSTR QSTRINGIZE(MAXSTR)
	get MAXSTR as a string

#define	NT_CDECL __cdecl

#define	DEPRECATED __declspec(deprecated)

#define	NORETURN __declspec(noreturn)

#define	PACKED

#define	AS_STRFTIME(format_idx)

#define	AS_PRINTF(format_idx, varg_idx)

#define	AS_SCANF(format_idx, varg_idx)

#define	WARN_UNUSED_RESULT _Check_return_

#define	GCC_DIAG_OFF(x)

#define	GCC_DIAG_ON(x)

#define	DISABLE_ASAN

#define	__MF__ 0
	byte sex of our platform (Most significant byte First). More...

#define	qnotused(x) (void)x
	Macro to avoid of message 'Parameter x is never used'.

#define	NONNULL

#define	QUNUSED

#define	va_argi(va, type) va_arg(va, type)

#define	CONST_CAST(x) const_cast<x>
	cast a const to non-const

#define	_QSTRINGIZE(x) #x
	return x as a string. See SMAXSTR for example

#define	QSTRINGIZE(x) _QSTRINGIZE(x)
	see _QSTRINGIZE

#define	idaapi __stdcall

#define	ida_export idaapi

#define	idaman EXTERNC

#define	ida_export_data __declspec(dllimport)

#define	ida_module_data __declspec(dllexport)

#define	ida_local

#define	THREAD_SAFE
	Functions callable from any thread are marked with this keyword.

#define	newapi
	This keyword is used to introduce new virtual functions that do not override any existing virtual function.

#define	strtoull _strtoui64

#define	FMT_64 "I64"

#define	FMT_Z "u"

#define	FMT_ZX "X"

#define	FMT_ZS "d"

#define	SVAL_MIN INT_MIN

#define	SVAL_MAX INT_MAX

#define	FMT_EA ""

#define	DEFARG(decl, val) decl = val

#define	BADADDR ea_t(-1)
	this value is used for 'bad address'

#define	BADSEL sel_t(-1)
	'bad selector' value

#define	BADADDR32 ea32_t(-1ULL)

#define	BADADDR64 ea64_t(-1ULL)

#define	qoff64_t int64
	file offset

#define	for if(0); else for
	MSVC <= 1200 is not compliant to the ANSI standard.

#define	RELOBJ_MASK 0xF
	the first byte describes the relocation entry types

#define	RELSIZE_1 0
	8-bit relocations

#define	RELSIZE_2 1
	16-bit relocations

#define	RELSIZE_4 2
	32-bit relocations

#define	RELSIZE_8 3
	64-bit relocations

#define	RELSIZE_CUST 15
	custom relocations, should be handled internally

#define	RELOBJ_CNT 0x80
	counter present (not used yet)

#define	DEFINE_LIST_ITERATOR(iter, constness, cstr)
	Used for defining the 'iterator' and 'const_iterator' classes for qlist.

#define	DEFINE_REVERSE_ITERATOR(riter, iter)

#define	SCALAR_TYPE(n) class T, typename std::enable_if<std::is_scalar<T>::value && sizeof(T) == n, int>::type = 0

#define	IOREDIR_INPUT 0x01
	input redirection

#define	IOREDIR_OUTPUT 0x02
	output redirection

#define	IOREDIR_APPEND 0x04
	append, do not overwrite the output file

#define	IOREDIR_QUOTED 0x08
	the file name was quoted

#define	LP_NEW_CONSOLE 0x0001
	create new console (only ms windows)

#define	LP_TRACE 0x0002
	debug: unix: ptrace(TRACEME), windows: DEBUG_PROCESS

#define	LP_PATH_WITH_ARGS 0x0004
	'args' contains executable path too

#define	LP_USE_SHELL 0x0008
	use shell to launch the command. More...

#define	LP_LAUNCH_32_BIT 0x0010
	prefer to launch 32-bit part of file (only mac)

#define	LP_LAUNCH_64_BIT 0x0020
	prefer to launch 64-bit part of file (only mac); only one of LP_LAUNCH_*_BIT bits can be specified

#define	LP_NO_ASLR 0x0040
	disable ASLR (only mac)

#define	LP_DETACH_TTY 0x0080
	detach the current tty (unix)

#define	LP_HIDE_WINDOW 0x0100
	tries to hide new window on startup (only windows)

#define	LP_SUSPENDED 0x0200
	suspends the process on startup (only mac)

#define	LP_DETACHED 0x0400
	no need to reap the child (this bit is ignored on windows)

Typedefs
typedef unsigned char	uchar
	unsigned 8 bit value

typedef unsigned short	ushort
	unsigned 16 bit value

typedef unsigned int	uint
	unsigned 32 bit value

typedef char	int8
	signed 8 bit value

typedef signed char	sint8
	signed 8 bit value

typedef unsigned char	uint8
	unsigned 8 bit value

typedef short	int16
	signed 16 bit value

typedef unsigned short	uint16
	unsigned 16 bit value

typedef int	int32
	signed 32 bit value

typedef unsigned int	uint32
	unsigned 32 bit value

typedef wchar_t	wchar16_t

typedef uint32	wchar32_t

typedef ptrdiff_t	ssize_t
	Signed size_t - used to check for size overflows when the counter becomes negative. More...

typedef uint32	ea_t

typedef uint32	sel_t

typedef uint32	asize_t

typedef int32	adiff_t

typedef asize_t	uval_t
	unsigned value used by the processor. More...

typedef adiff_t	sval_t
	signed value used by the processor. More...

typedef uint32	ea32_t
	32-bit address, regardless of IDA bitness. More...

typedef uint64	ea64_t
	64-bit address, regardless of IDA bitness. More...

typedef int	error_t
	Error code (errno)

typedef uint8	op_dtype_t

typedef uval_t	inode_t
	The inode_t type is the specialization specific inode number. More...

typedef size_t	diffpos_t

typedef int32	qtime32_t
	we use our own time type because time_t can be 32-bit or 64-bit depending on the compiler

typedef uint64	qtime64_t
	64-bit time value expressed as seconds and microseconds since the Epoch

Functions
INLINE int64	qatoll (const char *nptr)

INLINE THREAD_SAFE uint32	get_secs (qtime64_t t)
	Get the 'seconds since the epoch' part of a qtime64_t.

INLINE THREAD_SAFE uint32	get_usecs (qtime64_t t)
	Get the microseconds part of a qtime64_t.

INLINE THREAD_SAFE qtime64_t	make_qtime64 (uint32 secs, DEFARG(int32 usecs, 0))
	Get a qtime64_t instance from a seconds value and microseconds value. More...

idaman THREAD_SAFE bool ida_export	qctime (char *buf, size_t bufsize, qtime32_t t)
	Converts calendar time into a string. More...

idaman THREAD_SAFE bool ida_export	qctime_utc (char *buf, size_t bufsize, qtime32_t t)
	Converts calendar time into a string using Coordinated Universal Time (UTC). More...

idaman THREAD_SAFE bool ida_export	qlocaltime (struct tm *_tm, qtime32_t t)
	Converts a time value to a tm structure (local time) More...

INLINE THREAD_SAFE bool	qlocaltime64 (struct tm *_tm, qtime64_t t)
	Same as qlocaltime(struct tm *, qtime32_t), but accepts a 64-bit time value.

idaman bool ida_export	qgmtime (struct tm *_tm, qtime32_t t)
	Converts a time value to a tm structure (UTC time) More...

INLINE THREAD_SAFE bool	qgmtime64 (struct tm *_tm, qtime64_t t)
	Same as qgmtime(struct tm *, qtime32_t), but accepts a 64-bit time value.

idaman qtime32_t ida_export	qtimegm (const struct tm *ptm)

idaman	AS_STRFTIME (3) THREAD_SAFE size_t ida_export qstrftime(char *buf
	Get string representation of a qtime32_t (local time) Copies into 'buf' the content of 'format', expanding its format specifiers into the corresponding values that represent the time described in 't', with a limit of 'bufsize' characters see http://www.cplusplus.com/reference/ctime/strftime/ for more. More...

idaman THREAD_SAFE void ida_export	qsleep (int milliseconds)
	Suspend execution for given number of milliseconds.

idaman THREAD_SAFE uint64 ida_export	get_nsec_stamp (void)
	High resolution timer. More...

idaman THREAD_SAFE qtime64_t ida_export	qtime64 (void)
	Get the current time with microsecond resolution (in fact the resolution is worse on windows)

idaman THREAD_SAFE bool ida_export	gen_rand_buf (void *buffer, size_t bufsz)
	Generate a random buffer. More...

THREAD_SAFE constexpr uval_t	interval::last (uval_t off, asize_t s)
	max offset of the interval (assume s != 0)

THREAD_SAFE constexpr bool	interval::overlap (uval_t off1, asize_t s1, uval_t off2, asize_t s2)
	Do (off1,s1) and (off2,s2) overlap?

THREAD_SAFE constexpr bool	interval::includes (uval_t off1, asize_t s1, uval_t off2, asize_t s2)
	Does (off1,s1) include (off2,s2)?

THREAD_SAFE constexpr bool	interval::contains (uval_t off1, asize_t s1, uval_t off)
	Does (off1,s1) contain off?

strlen
Get the length of the given string
THREAD_SAFE size_t idaapi	qstrlen (const char *s)

THREAD_SAFE size_t idaapi	qstrlen (const uchar *s)

idaman THREAD_SAFE size_t ida_export	qstrlen (const wchar16_t *s)

strcmp
Lexical comparison of strings. Returns 0 if two strings are identical > 0 if 's1' is larger than 's2' < 0 if 's2' is larger than 's1' otherwise return first nonzero comparison between chars in 's1' and 's2'
THREAD_SAFE int idaapi	qstrcmp (const char s1, const char s2)

THREAD_SAFE int idaapi	qstrcmp (const uchar s1, const uchar s2)

idaman THREAD_SAFE int ida_export	qstrcmp (const wchar16_t s1, const wchar16_t s2)

strstr
Find a string within another string. Returns a pointer to the first occurrence of 's2' within 's1', nullptr if s2 is not found in s1
THREAD_SAFE const char *idaapi	qstrstr (const char s1, const char s2)

THREAD_SAFE const uchar *idaapi	qstrstr (const uchar s1, const uchar s2)

strchr
Find a character within a string. Returns a pointer to the first occurrence of 'c' within 's1', nullptr if c is not found in s1
THREAD_SAFE char *idaapi	qstrchr (char *s1, char c)

THREAD_SAFE const char *idaapi	qstrchr (const char *s1, char c)

THREAD_SAFE uchar *idaapi	qstrchr (uchar *s1, uchar c)

THREAD_SAFE const uchar *idaapi	qstrchr (const uchar *s1, uchar c)

idaman THREAD_SAFE const wchar16_t *ida_export	qstrchr (const wchar16_t *s1, wchar16_t c)

THREAD_SAFE wchar16_t *idaapi	qstrchr (wchar16_t *s1, wchar16_t c)

Variables
constexpr diffpos_t	BADDIFF = diffpos_t(-1)

idaman size_t	bufsize

idaman size_t const char *	format

idaman size_t const char qtime32_t	t

VS posix names
Shut up Visual Studio (VS deprecated posix names but there seems to be no good reason for that)
#define	chdir _chdir

#define	fileno _fileno

#define	getcwd _getcwd

#define	memicmp _memicmp

#define	F_OK 0

#define	W_OK 2

#define	R_OK 4

#define	eOk 0
	no error

#define	eOS 1
	os error, see errno

#define	eDiskFull 2
	disk full

#define	eReadError 3
	read error

#define	eFileTooLarge 4
	file too large

#define	ZZZ msg("%s:%d\n", __FILE__, __LINE__)

#define	BPT __debugbreak()

#define	CASSERT(cnd) static_assert((cnd), QSTRINGIZE(cnd))

#define	INTERR(code) do { if ( under_debugger ) BPT; interr(code); } while(1)

#define	QASSERT(code, cond) do if ( !(cond) ) INTERR(code); while (0)
	run time assertion

#define	QBUFCHECK(buf, size, src) ida_fill_buffer(buf, size, src, __FILE__, __LINE__)
	run time assertion

#define	INTERR_EXC_FMT

#define	qnew(t) ((t*)qalloc(sizeof(t)))
	create a new object in memory

#define	qnewarray(t, n) use_qalloc_array

#define	qnumber(array) _countof(array)

#define	qoffsetof offsetof

#define	va_copy(dst, src) dst = src

#define	set_vva(va2, vp) va_copy(va2, va_arg(vp, va_list))

#define	strnicmp _strnicmp

#define	stricmp _stricmp

#define	strcpy dont_use_strcpy
	use qstrncpy()

#define	stpcpy dont_use_stpcpy
	use qstpncpy()

#define	strncpy dont_use_strncpy
	use qstrncpy()

#define	strcat dont_use_strcat
	use qstrncat()

#define	strncat dont_use_strncat
	use qstrncat()

#define	gets dont_use_gets
	use qfgets()

#define	sprintf dont_use_sprintf
	use qsnprintf()

#define	snprintf dont_use_snprintf
	use qsnprintf()

#define	wsprintfA dont_use_wsprintf
	use qsnprintf()

#define	strcmpi dont_use_strcmpi
	use stricmp()

#define	strncmpi dont_use_strncmpi
	use strnicmp()

#define	getenv dont_use_getenv
	use qgetenv()

#define	setenv dont_use_setenv
	use qsetenv()

#define	putenv dont_use_putenv
	use qsetenv()

#define	strtok dont_use_strrok
	use qstrtok()

#define	strlwr dont_use_strlwr
	use qstrlwr()

#define	strupr dont_use_strupr
	use qstrupr()

#define	waitid dont_use_waitid
	use qwait()

#define	waitpid dont_use_waitpid
	use qwait()

#define	wait dont_use_wait
	use qwait()

#define	streq(s1, s2) (strcmp((s1), (s2)) == 0)
	convenient check for string equality

#define	strieq(s1, s2) (stricmp((s1), (s2)) == 0)
	see streq

#define	strneq(s1, s2, count) (strncmp((s1), (s2), (count)) == 0)
	see streq

#define	strnieq(s1, s2, count) (strnicmp((s1), (s2), (count)) == 0)
	see streq

#define	QMAXPATH 260

#define	QMAXFILE 260

#define	DELIMITER ";"
	Delimiter of directory lists. More...

#define	WPM_EXPLICIT_DOT 0x01

#define	SEEK_SET 0
	beginning of file

#define	SEEK_CUR 1
	current position of the file *

#define	SEEK_END 2
	end of file *

#define	qmin(a, b) ((a) < (b)? (a): (b))
	universal min

#define	qmax(a, b) ((a) > (b)? (a): (b))
	universal max

#define	OPERATOR_NEW(type, count) new type[count]

#define	MC2(c1, c2) ushort(((c2)<<8)\|c1)
	We cannot use multi-character constants because they are not portable - use this macro instead.

#define	MC3(c1, c2, c3) uint32(((((c3)<<8)\|(c2))<<8)\|c1)
	We cannot use multi-character constants because they are not portable - use this macro instead. More...

#define	MC4(c1, c2, c3, c4) uint32(((((((c4)<<8)\|(c3))<<8)\|(c2))<<8)\|c1)
	We cannot use multi-character constants because they are not portable - use this macro instead. More...

#define	read4bytes(h, res, mf) readbytes(h, res, 4, mf)
	see readbytes()

#define	write2bytes(h, l, mf) writebytes(h, l, 2, mf)
	see writebytes()

#define	write4bytes(h, l, mf) writebytes(h, l, 4, mf)
	see writebytes()

#define	swapea swap32

#define	qhtons(x) swap16(x)

#define	qntohs(x) swap16(x)

#define	qhtonl(x) swap32(x)

#define	qntohl(x) swap32(x)

idaman bool ida_export_data	is_ida_kernel
	Is this IDA kernel? If not, we are executing a standalone application.

idaman bool ida_export_data	under_debugger
	is IDA running under a debugger?

idaman THREAD_SAFE error_t ida_export	set_qerrno (error_t code)
	Set qerrno.

idaman THREAD_SAFE error_t ida_export	get_qerrno (void)
	Get qerrno.

idaman THREAD_SAFE NORETURN void ida_export	interr (int code)
	Show internal error message and terminate execution.

idaman THREAD_SAFE bool ida_export	set_interr_throws (bool enable)

idaman THREAD_SAFE void *ida_export	qalloc (size_t size)
	System independent malloc.

idaman THREAD_SAFE void *ida_export	qrealloc (void *alloc, size_t newsize)
	System independent realloc.

idaman THREAD_SAFE void *ida_export	qcalloc (size_t nitems, size_t itemsize)
	System independent calloc.

idaman THREAD_SAFE void ida_export	qfree (void *alloc)
	System independent free.

idaman THREAD_SAFE char *ida_export	qstrdup (const char *string)
	System independent strdup.

template<class T >
T *	qalloc_array (size_t n)
	Use this class to avoid integer overflows when allocating arrays.

template<class T >
T *	qrealloc_array (T *ptr, size_t n)
	Use this class to avoid integer overflows when allocating arrays.

idaman THREAD_SAFE void *ida_export	memrev (void *buf, ssize_t size)
	Reverse memory block. More...

idaman THREAD_SAFE char *ida_export	strrpl (char *str, int char1, int char2)
	Replace all occurrences of a character within a string. More...

INLINE THREAD_SAFE char *	tail (char *str)
	Get tail of a string.

THREAD_SAFE const char *	tail (const char *str)
	Get tail of a string. More...

idaman THREAD_SAFE char *ida_export	qstrncpy (char dst, const char src, size_t dstsize)
	A safer strncpy - makes sure that there is a terminating zero. More...

idaman THREAD_SAFE char *ida_export	qstpncpy (char dst, const char src, size_t dstsize)
	A safer stpncpy - returns pointer to the end of the destination nb: ssize_t(dstsize) must be > 0.

idaman THREAD_SAFE char *ida_export	qstrncat (char dst, const char src, size_t dstsize)
	A safer strncat - accepts the size of the 'dst' as 'dstsize' and returns dst nb: ssize_t(dstsize) must be > 0.

idaman THREAD_SAFE char *ida_export	qstrtok (char s, const char delim, char **save_ptr)
	Thread-safe version of strtok.

idaman THREAD_SAFE char *ida_export	qstrlwr (char *str)
	Convert the string to lowercase.

idaman THREAD_SAFE char *ida_export	qstrupr (char *str)
	Convert the string to uppercase.

idaman THREAD_SAFE const char *ida_export	stristr (const char s1, const char s2)
	Find one string in another (Case insensitive analog of strstr()). More...

char *idaapi	stristr (char s1, const char s2)
	Same as stristr(const char , const char ) but returns a non-const result.

INLINE THREAD_SAFE bool ida_local	qisascii (char c)

INLINE THREAD_SAFE bool ida_local	qisspace (char c)

INLINE THREAD_SAFE bool ida_local	qisalpha (char c)

INLINE THREAD_SAFE bool ida_local	qisalnum (char c)

INLINE THREAD_SAFE bool ida_local	qispunct (char c)

INLINE THREAD_SAFE bool ida_local	qislower (char c)

INLINE THREAD_SAFE bool ida_local	qisupper (char c)

INLINE THREAD_SAFE bool ida_local	qisprint (char c)

INLINE THREAD_SAFE bool ida_local	qisdigit (char c)

INLINE THREAD_SAFE bool ida_local	qisxdigit (char c)

INLINE THREAD_SAFE int ida_local	qtolower (char c)
	Get lowercase equivalent of given char.

INLINE THREAD_SAFE int ida_local	qtoupper (char c)
	Get uppercase equivalent of given char.

idaman THREAD_SAFE int ida_export	qsnprintf (char buffer, size_t n, const char format,...)
	A safer snprintf.

idaman THREAD_SAFE int ida_export	qsscanf (const char input, const char format,...)
	A safer sscanf.

idaman THREAD_SAFE int ida_export	qvsnprintf (char buffer, size_t n, const char format, va_list va)
	See qsnprintf()

idaman THREAD_SAFE int ida_export	qvsscanf (const char input, const char format, va_list va)
	See qsscanf()

idaman THREAD_SAFE int ida_export	append_snprintf (char buf, const char end, const char *format,...)
	Append result of sprintf to 'buf'.

	GCC_DIAG_OFF (format-nonliteral)
	qsnprintf that does not check its arguments. More...

INLINE int	nowarn_qsnprintf (char buf, size_t size, const char format,...)

	GCC_DIAG_ON (format-nonliteral)

idaman THREAD_SAFE char *ida_export	vqmakepath (char buf, size_t bufsize, const char s1, va_list)
	See qmakepath()

idaman THREAD_SAFE char *ida_export	qmakepath (char buf, size_t bufsize, const char s1,...)
	Construct a path from a null-terminated sequence of strings. More...

idaman void ida_export	qgetcwd (char *buf, size_t bufsize)
	Get the current working directory. More...

idaman int ida_export	qchdir (const char *path)
	Change the current working directory. More...

idaman THREAD_SAFE bool ida_export	qdirname (char buf, size_t bufsize, const char path)
	Get the directory part of the path. More...

idaman THREAD_SAFE char *ida_export	qmakefile (char buf, size_t bufsize, const char base, const char *ext)
	Construct filename from base name and extension. More...

idaman THREAD_SAFE char *ida_export	qsplitfile (char file, char base, char *ext)
	Split filename into base name and extension. More...

idaman THREAD_SAFE bool ida_export	qisabspath (const char *file)
	Is the file name absolute (not relative to the current dir?)

idaman THREAD_SAFE const char *ida_export	qbasename (const char *path)
	Get the file name part of the given path. More...

char *	qbasename (char *path)
	Same as qbasename(const char *), but accepts and returns non-const char pointers.

idaman THREAD_SAFE char *ida_export	qmake_full_path (char dst, size_t dstsize, const char src)
	Convert relative path to absolute path.

idaman THREAD_SAFE bool ida_export	search_path (char buf, size_t bufsize, const char file, bool search_cwd)
	Search for a file in the PATH environment variable or the current directory. More...

idaman THREAD_SAFE char *ida_export	set_file_ext (char outbuf, size_t bufsize, const char file, const char *ext)
	Set file name extension unconditionally. More...

idaman THREAD_SAFE const char *ida_export	get_file_ext (const char *file)
	Get pointer to extension of file name. More...

THREAD_SAFE bool idaapi	has_file_ext (const char *file)
	Does the given file name have an extension?

THREAD_SAFE char *idaapi	make_file_ext (char buf, size_t bufsize, const char file, const char *ext)
	Set file name extension if none exists. More...

idaman THREAD_SAFE bool ida_export	sanitize_file_name (char *name, size_t namesize)
	Sanitize the file name. More...

bool	wildcard_match (const char name, const char pattern)
	Match a name against a pattern. More...

bool	wildcard_path_match (const char name, const char _pattern, int flags=0)
	Match a path against a pattern. More...

idaman int ida_export	regex_match (const char str, const char pattern, bool sense_case)
	Match a string with a regular expression. More...

idaman THREAD_SAFE int ida_export	qopen (const char *file, int mode)
	Works the same as it's counterpart from Clib. More...

idaman THREAD_SAFE int ida_export	qopen_shared (const char *file, int mode, int share_mode)
	Open file with given sharing_mode (use O_RDONLY, O_WRONLY, O_RDWR flags), sets qerrno.

idaman THREAD_SAFE int ida_export	qcreate (const char *file, int stat)
	Create new file with O_RDWR, sets qerrno.

idaman THREAD_SAFE int ida_export	qread (int h, void *buf, size_t n)
	Works the same as it's counterpart from Clib. More...

idaman THREAD_SAFE int ida_export	qwrite (int h, const void *buf, size_t n)
	Works the same as it's counterpart from Clib. More...

idaman THREAD_SAFE qoff64_t ida_export	qtell (int h)
	Works the same as it's counterpart from Clib. More...

idaman THREAD_SAFE qoff64_t ida_export	qseek (int h, int64 offset, int whence)
	Works the same as it's counterpart from Clib. More...

idaman THREAD_SAFE int ida_export	qclose (int h)
	Works the same as it's counterpart from Clib. More...

idaman THREAD_SAFE int ida_export	qdup (int h)
	Works the same as it's counterpart from Clib. More...

idaman THREAD_SAFE int ida_export	qfsync (int h)
	Works the same as it's counterpart from Clib. More...

idaman THREAD_SAFE uint64 ida_export	qfilesize (const char *fname)
	Get the file size. More...

idaman THREAD_SAFE uint64 ida_export	qfilelength (int h)
	Get file length in bytes. More...

idaman THREAD_SAFE int ida_export	qchsize (int h, uint64 fsize)
	Change file size. More...

idaman THREAD_SAFE int ida_export	qmkdir (const char *file, int mode)
	Create an empty directory. More...

idaman THREAD_SAFE int ida_export	qrmdir (const char *file)
	Delete a directory. More...

idaman THREAD_SAFE bool ida_export	qfileexist (const char *file)
	Does the given file exist?

idaman THREAD_SAFE bool ida_export	qisdir (const char *file)
	Does the given path specify a directory?

idaman THREAD_SAFE int ida_export	qstat (const char path, struct qstatbuf buf)
	Get file status.

idaman THREAD_SAFE int ida_export	qfstat (int fd, struct qstatbuf *buf)

idaman THREAD_SAFE void ida_export	qatexit (void(idaapi *func)(void))
	Add a function to be called at exit time.

idaman THREAD_SAFE void ida_export	del_qatexit (void(idaapi *func)(void))
	Remove a previously added exit-time function.

idaman THREAD_SAFE NORETURN void ida_export	qexit (int code)
	Call qatexit functions, shut down UI and kernel, and exit. More...

template<class T >
T	qabs (T x)

INLINE THREAD_SAFE bool idaapi	test_bit (const uchar *bitmap, size_t bit)
	Test if 'bit' is set in 'bitmap'.

INLINE THREAD_SAFE void idaapi	set_bit (uchar *bitmap, size_t bit)
	Set 'bit' in 'bitmap'.

INLINE THREAD_SAFE void idaapi	clear_bit (uchar *bitmap, size_t bit)
	Clear 'bit' in 'bitmap'.

INLINE THREAD_SAFE void idaapi	set_bits (uchar *bitmap, size_t low, size_t high)
	Set bits between [low, high) in 'bitmap'.

INLINE THREAD_SAFE void idaapi	clear_bits (uchar *bitmap, size_t low, size_t high)
	Clear bits between [low, high) in 'bitmap'.

INLINE THREAD_SAFE void idaapi	set_all_bits (uchar *bitmap, size_t nbits)
	Set first 'nbits' of 'bitmap'.

INLINE THREAD_SAFE void idaapi	clear_all_bits (uchar *bitmap, size_t nbits)
	Clear first 'nbits' of 'bitmap'.

idaman int ida_export	log2ceil (uint64 d64)
	calculate ceil(log2(d64)) or floor(log2(d64)), it returns 0 if d64 == 0

idaman int ida_export	log2floor (uint64 d64)

idaman int ida_export	bitcount (uint64 x)
	calculate number of set bits (the population count)

idaman uint32 ida_export	round_up_power2 (uint32 x)
	round up or down to a power of 2

idaman uint32 ida_export	round_down_power2 (uint32 x)

template<class T >
constexpr bool	is_pow2 (T val)
	is power of 2? (or zero)

template<class T >
T	round_up (T val, T base)
	round up or down to an arbitrary number

template<class T >
T	round_down (T val, T base)

template<class T >
constexpr T	left_shift (const T &value, int shift)
	Shift by the amount exceeding the operand size*8 is undefined by the standard. More...

template<class T >
constexpr T	right_ushift (const T &value, int shift)
	Shift by the amount exceeding the operand size*8 is undefined by the standard. More...

template<class T >
constexpr T	right_sshift (const T &value, int shift)
	Shift by the amount exceeding the operand size*8 is undefined by the standard. More...

template<class T >
T	qrotl (T value, size_t count)
	Rotate left.

template<class T >
T	qrotr (T value, size_t count)
	Rotate right.

template<class T >
constexpr T	make_mask (int count)
	Make a mask of 'count' bits.

template<class T , class U >
void idaapi	setflag (T &where, U bit, bool cnd)
	Set a 'bit' in 'where' if 'value' if not zero.

template<class T >
bool	is_mul_ok (T count, T elsize)
	Check that unsigned multiplication does not overflow.

template<class U , class T >
bool	is_add_ok (U x, T y)
	Check that unsigned or unsigned+signed addition does not overflow.

template<class T >
bool	is_udiv_ok (T, T b)
	Check that unsigned division is permissible.

template<class T >
bool	is_sdiv_ok (T a, T b)
	Check that signed division is permissible.

idaman uint64 ida_export	extend_sign (uint64 v, int nbytes, bool sign_extend)
	Sign-, or zero-extend the value 'v' to occupy 64 bits. More...

idaman THREAD_SAFE int ida_export	readbytes (int h, uint32 *res, int size, bool mf)
	Read at most 4 bytes from file. More...

idaman THREAD_SAFE int ida_export	writebytes (int h, uint32 l, int size, bool mf)
	Write at most 4 bytes to file. More...

idaman THREAD_SAFE int ida_export	read2bytes (int h, uint16 *res, bool mf)
	Read a 2 byte entity from a file. More...

THREAD_SAFE constexpr uint32	swap32 (uint32 x)

THREAD_SAFE constexpr ushort	swap16 (ushort x)

idaman THREAD_SAFE void ida_export	swap_value (void dst, const void src, int size)
	Swap endianness of a given value in memory. More...

idaman THREAD_SAFE void ida_export	reloc_value (void *value, int size, adiff_t delta, bool mf)

idaman THREAD_SAFE uval_t ida_export	rotate_left (uval_t x, int count, size_t bits, size_t offset)
	Rotate left - can be used to rotate a value to the right if the count is negative. More...

template<class T >
THREAD_SAFE void	qswap (T &a, T &b)
	Swap 2 objects of the same type using memory copies.

THREAD_SAFE uchar *idaapi	pack_db (uchar ptr, uchar end, uchar x)
	Pack a byte into a character string. More...

THREAD_SAFE uchar idaapi	unpack_db (const uchar *pptr, const uchar end)
	Unpack a byte from a character string, pack_db()

idaman THREAD_SAFE uchar *ida_export	pack_dw (uchar ptr, uchar end, uint16 x)
	pack a word, see pack_db()

idaman THREAD_SAFE uchar *ida_export	pack_dd (uchar ptr, uchar end, uint32 x)
	pack a double word, see pack_db()

idaman THREAD_SAFE uchar *ida_export	pack_dq (uchar ptr, uchar end, uint64 x)
	pack a quadword, see pack_db()

idaman THREAD_SAFE ushort ida_export	unpack_dw (const uchar *pptr, const uchar end)
	unpack a word, see unpack_db()

idaman THREAD_SAFE uint32 ida_export	unpack_dd (const uchar *pptr, const uchar end)
	unpack a double word, see unpack_db()

idaman THREAD_SAFE uint64 ida_export	unpack_dq (const uchar *pptr, const uchar end)
	unpack a quadword, see unpack_db()

THREAD_SAFE uchar *	pack_ea (uchar ptr, uchar end, ea_t ea)
	Pack an ea value into a character string, see pack_dd()/pack_dq()

THREAD_SAFE ea_t	unpack_ea (const uchar *ptr, const uchar end)
	Unpack an ea value, see unpack_dd()/unpack_dq()

THREAD_SAFE ea64_t	unpack_ea64 (const uchar *ptr, const uchar end)
	Unpack an ea value (always use 64bit, use delta 1)

THREAD_SAFE void *idaapi	unpack_obj (void destbuf, size_t destsize, const uchar pptr, const uchar end)
	Unpack an object of a known size. More...

THREAD_SAFE void *idaapi	unpack_buf (const uchar *pptr, const uchar end)
	Unpack an object of an unknown size (packed with append_buf()). More...

THREAD_SAFE const void *idaapi	unpack_obj_inplace (const uchar *pptr, const uchar end, size_t objsize)
	In-place version of unpack_obj(). More...

THREAD_SAFE const void *idaapi	unpack_buf_inplace (const uchar *pptr, const uchar end)
	In-place version of unpack_buf(). More...

idaman THREAD_SAFE uchar *ida_export	pack_ds (uchar ptr, uchar end, const char *x, size_t len=0)
	Pack a string. More...

idaman THREAD_SAFE char *ida_export	unpack_ds (const uchar *pptr, const uchar end, bool empty_null)
	Unpack a string. More...

THREAD_SAFE bool	unpack_ds_to_buf (char dst, size_t dstsize, const uchar pptr, const uchar end)
	Unpack a string. More...

idaman THREAD_SAFE bool ida_export	unpack_xleb128 (void res, int nbits, bool is_signed, const uchar pptr, const uchar end)
	Unpack an LEB128 encoded (DWARF-3 style) signed/unsigned value. More...

template<class T >
THREAD_SAFE bool	unpack_uleb128 (T res, const uchar pptr, const uchar end)

template<class T >
THREAD_SAFE bool	unpack_sleb128 (T res, const uchar pptr, const uchar end)

THREAD_SAFE int	ds_packed_size (const char *s)

THREAD_SAFE constexpr int	dw_size (uchar first_byte)

THREAD_SAFE constexpr int	dd_size (uchar first_byte)

template<class T >
THREAD_SAFE uchar	extract_db (T &v)

template<class T >
THREAD_SAFE void *	extract_obj (T &v, void *destbuf, size_t destsize)

template<class T >
THREAD_SAFE uint16	extract_dw (T &v)

template<class T >
THREAD_SAFE uint32	extract_dd (T &v)

template<class T >
THREAD_SAFE uint64	extract_dq (T &v)

template<class T >
THREAD_SAFE ea_t	extract_ea (T &v)

template<class T >
THREAD_SAFE void *	extract_buf (T &v, size_t size)

template<class T >
THREAD_SAFE void *	extract_array (T &v, size_t *sz, size_t maxsize)

const char *	unpack_str (const uchar *pptr, const uchar end)

Safe buffer append
In the following macros, 'buf' must be always less than 'end'. When we run up to the end, we put a 0 there and don't increase buf anymore
#define	APPCHAR(buf, end, chr)
	Append a character to the buffer checking the buffer size. More...

#define	APPZERO(buf, end)
	Put a zero byte at buffer. More...

#define	APPEND(buf, end, name)
	Append a string to the buffer checking the buffer size. More...

#define	PLACEMENT_DELETE void operator delete(void , void ) {}

#define	DEFINE_MEMORY_ALLOCATION_FUNCS()

#define	DECLARE_COMPARISON_OPERATORS(type)
	Macro to declare standard inline comparison operators. More...

#define	DECLARE_COMPARISONS(type)
	Macro to declare comparisons for our classes. More...

typedef qvector< uval_t >	uvalvec_t
	vector of unsigned values

typedef qvector< sval_t >	svalvec_t
	vector of signed values

typedef qvector< ea_t >	eavec_t
	vector of addresses

typedef qvector< int >	intvec_t
	vector of integers

typedef qvector< bool >	boolvec_t
	vector of bools

typedef qvector< size_t >	sizevec_t
	vector of sizes

idaman THREAD_SAFE void *ida_export	qalloc_or_throw (size_t size)
	qalloc() 'size' bytes, and throw a "not enough memory" error if failed

idaman THREAD_SAFE void *ida_export	qrealloc_or_throw (void *ptr, size_t size)
	qrealloc() 'ptr' by 'size', and throw a "not enough memory" error if failed

idaman THREAD_SAFE void *ida_export	qvector_reserve (void vec, void old, size_t cnt, size_t elsize)
	Change capacity of given qvector. More...

template<class T >
void	shift_down (T dst, T src, size_t cnt)
	Move data down in memory. More...

template<class T >
void	shift_up (T dst, T src, size_t cnt)
	Move data up in memory. More...

template<class T >
int	lexcompare (const T &a, const T &b)
	Standard lexical comparison. More...

template<class T >
int	lexcompare_vectors (const T &a, const T &b)
	Lexical comparison of two vectors. More...

qstrrchr
Find a last occurrence of a character within a string. Returns a pointer to the last occurrence of 'c' within 's1', nullptr if c is not found in s1
#define	SSF_DROP_EMPTY 0x1
	drop empty parts

#define	QLIST_DEFINED
	signal that the qlist class has been defined

#define	DECLARE_MEMORY_DESERIALIZER(name)

#define	COMPARE_POINTERS2(ptr, cmp)

#define	COMPARE_POINTERS(ptr) COMPARE_POINTERS2(ptr, ::compare)

#define	COMPARE_FIELDS(fld)

#define	COMPARE_FIELDS_REV(fld)

#define	DECLARE_UNCOPYABLE(T) T &operator=(const T &); T(const T &);
	Declare class as uncopyable. More...

#define	IDBDEC_ESCAPE 0x00000001
	convert non-printable characters to C escapes ( , \xNN, \uNNNN)

#define	CP_ACP 0

#define	CP_OEM 1

#define	CP_UTF8 65001

#define	BADCP wchar32_t(-1)

#define	CP_BOM 0xFEFF

#define	UTF8_BOM "\xEF\xBB\xBF"

#define	UTF8_BOM_SZ (sizeof(UTF8_BOM) - 1)

#define	UTF16LE_BOM "\xFF\xFE"

#define	UTF16BE_BOM "\xFE\xFF"

#define	UTF16_BOM_SZ (sizeof(UTF16LE_BOM) - 1)

#define	UTF32LE_BOM "\xFF\xFE\x00\x00"

#define	UTF32BE_BOM "\x00\x00\xFE\xFF"

#define	UTF32_BOM_SZ (sizeof(UTF32LE_BOM) - 1)

#define	CP_ELLIPSIS 0x2026

#define	UTF8_ELLIPSIS "\xE2\x80\xA6"

#define	UTF8_ELLIPSIS_SZ (sizeof(UTF8_ELLIPSIS) - 1)

#define	CP_REPLCHAR 0xFFFD

#define	UTF8_REPLCHAR "\xEF\xBF\xBD"

#define	UTF8_REPLCHAR_SZ (sizeof(UTF8_REPLCHAR) - 1)

#define	MAX_UTF8_SEQ_LEN (6 + 1 + 1)

#define	CEF_RETERR 0x1

#define	ENC_WIN1252 "windows-1252"

#define	ENC_UTF8 "UTF-8"

#define	ENC_MUTF8 "MUTF-8"

#define	ENC_UTF16 "UTF-16"

#define	ENC_UTF16LE "UTF-16LE"

#define	ENC_UTF16BE "UTF-16BE"

#define	ENC_UTF32 "UTF-32"

#define	ENC_UTF32LE "UTF-32LE"

#define	ENC_UTF32BE "UTF-32BE"

#define	CP_UTF16 1200
	UTF-16 codepage.

#define	INVALID_FILE_ATTRIBUTES ((DWORD)-1)
	old Visual C++ compilers were not defining this

#define	BELOW_NORMAL_PRIORITY_CLASS 0x00004000
	old Visual C++ compilers were not defining this More...

#define	SUBSTCHAR '_'
	default char, used if a char cannot be represented in a codepage

#define	DEFCOLOR bgcolor_t(-1)
	default color (used in function, segment definitions)

#define	DEFINE_CLIOPTS_T_HELPERS(decl)

#define	DEFINE_PLUGIN_OPTION_T_HELPERS(decl) decl bool ida_export plugin_option_t_get_bool(const plugin_option_t , bool , const char *, bool);

#define	OPAQUE_HANDLE(n) typedef struct __ ## n {} *n
	Thread opaque handle.

enum	tty_control_t { TCT_UNKNOWN = 0 , TCT_OWNER , TCT_NOT_OWNER }
	Teletype control.

typedef _qstring< char >	qstring
	regular string

typedef _qstring< uchar >	qtype
	type string

typedef _qstring< wchar16_t >	qwstring
	unicode string

typedef qvector< qstring >	qstrvec_t
	vector of strings

typedef qvector< qwstring >	qwstrvec_t
	vector of unicode strings

template<class... >
using	qvoid_t = void

typedef uint32	flags_t
	32-bit flags for each address

typedef uint64	flags64_t
	64-bit flags for each address

typedef ea_t	tid_t
	type id (for enums, structs, etc)

typedef uint32	bgcolor_t
	background color in RGB

typedef qvector< channel_redir_t >	channel_redirs_t
	vector of channel_redir_t objects

typedef void	cliopt_handler_t(const char value, void ud)

typedef void	cliopt_poly_handler_t(int argc, const char *argv, void ud)

using	plugin_options_t = qvector< plugin_option_t >

typedef int idaapi	qthread_cb_t(void *ud)
	THREADS. More...

typedef void *	qhandle_t
	MS Windows HANDLE.

const qhandle_t	NULL_PIPE_HANDLE = nullptr

THREAD_SAFE const char *idaapi	qstrrchr (const char *s1, char c)

THREAD_SAFE char *idaapi	qstrrchr (char *s1, char c)

THREAD_SAFE const uchar *idaapi	qstrrchr (const uchar *s1, uchar c)

THREAD_SAFE uchar *idaapi	qstrrchr (uchar *s1, uchar c)

idaman THREAD_SAFE const wchar16_t *ida_export	qstrrchr (const wchar16_t *s1, wchar16_t c)

THREAD_SAFE wchar16_t *idaapi	qstrrchr (wchar16_t *s1, wchar16_t c)

idaman THREAD_SAFE bool ida_export	relocate_relobj (struct relobj_t *_relobj, ea_t ea, bool mf)

THREAD_SAFE void	unpack_eavec (eavec_t vec, ea_t ea, const uchar ptr, const uchar end)
	Unpack a vector of ea values. More...

THREAD_SAFE bool	unpack_bytevec (bytevec_t out, const uchar pptr, const uchar end)

bool	unpack_str (qstring out, const uchar pptr, const uchar end)

template<class T , typename std::enable_if< has_compare_method< T >::value, int >::type = 0>
int	compare (const T &a, const T &b)

template<class T >
int	compare (const qvector< T > &a, const qvector< T > &b)

template<class T >
int	compare (const qlist< T > &a, const qlist< T > &b)

template<class T , class U >
int	compare (const std::pair< T, U > &a, const std::pair< T, U > &b)

template<class T >
int	compare_containers (const T &l, const T &r)
	Template to compare any 2 containers of the same type. Returns -1/0/1.

template<class T , class U >
int	compare (const std::map< T, U > &a, const std::map< T, U > &b)

template<class T >
int	compare (const std::set< T > &a, const std::set< T > &b)

template<class T >
T	align_up (T val, int elsize)
	Align element up to nearest boundary.

template<class T >
T	align_down (T val, int elsize)
	Align element down to nearest boundary.

idaman THREAD_SAFE uint32 ida_export	calc_crc32 (uint32 crc, const void *buf, size_t len)
	Calculate CRC32 (polynom 0xEDB88320, zlib compatible). More...

idaman THREAD_SAFE uint32 ida_export	calc_file_crc32 (class linput_t *fp)
	Calculate an input source CRC32.

idaman THREAD_SAFE bool ida_export	base64_encode (qstring output, const void input, size_t size)
	Encode base64.

idaman THREAD_SAFE bool ida_export	base64_decode (bytevec_t output, const char input, size_t size)
	Decode base64. More...

idaman THREAD_SAFE bool ida_export	replace_tabs (qstring out, const char str, int tabsize)
	Convert tabulations to spaces. More...

idaman THREAD_SAFE char *ida_export	str2user (char dst, const char src, size_t dstsize)
	Make a user representation.

idaman THREAD_SAFE char *ida_export	user2str (char dst, const char src, size_t dstsize)
	Make an internal representation.

idaman THREAD_SAFE char ida_export	back_char (const char **p)
	Translate char after '\'.

idaman THREAD_SAFE void ida_export	qstr2user (qstring dst, const char src, int nsyms=-1)
	see str2user()

THREAD_SAFE void	qstr2user (qstring *dst, const qstring &src)

idaman THREAD_SAFE void ida_export	user2qstr (qstring *dst, const qstring &src)
	see user2str()

idaman THREAD_SAFE bool ida_export	is_valid_utf8 (const char *in)
	Does byte sequence consist of valid UTF-8-encoded codepoints? More...

idaman THREAD_SAFE bool ida_export	utf8_utf16 (qwstring out, const char in, int nsyms=-1)
	UTF-8 -> UTF-16. More...

idaman THREAD_SAFE bool ida_export	utf16_utf8 (qstring out, const wchar16_t in, int nsyms=-1)
	UTF-16 -> UTF-8. More...

constexpr bool	is_lead_surrogate (wchar32_t wch)

constexpr bool	is_tail_surrogate (wchar32_t wch)

constexpr wchar32_t	utf16_surrogates_to_cp (wchar16_t lead_surrogate, wchar16_t tail_surrogate)

idaman THREAD_SAFE bool ida_export	idb_utf8 (qstring out, const char in, int nsyms=-1, int flags=0)
	IDB default C string encoding -> UTF-8. More...

idaman THREAD_SAFE bool ida_export	change_codepage (qstring out, const char in, int incp, int outcp)

INLINE THREAD_SAFE bool	acp_utf8 (qstring out, const char in)

THREAD_SAFE constexpr wchar16_t	utf8_wchar16 (uchar b0, uchar b1)

THREAD_SAFE constexpr wchar16_t	utf8_wchar16 (uchar b0, uchar b1, uchar b2)

THREAD_SAFE constexpr wchar32_t	utf8_wchar32 (uchar b0, uchar b1, uchar b2, uchar b3)

idaman THREAD_SAFE wchar32_t ida_export	get_utf8_char (const char **pptr)
	Read one UTF-8 character from string. if error, return BADCP.

idaman THREAD_SAFE bool ida_export	prev_utf8_char (wchar32_t out_cp, const char p, const char begin)
	Get the UTF-8 character from string, before 'p'. More...

idaman THREAD_SAFE size_t ida_export	skip_utf8 (const char **putf8, size_t n)
	Advance by n codepoints into the UTF-8 buffer. More...

idaman THREAD_SAFE ssize_t ida_export	put_utf8_char (char *out, wchar32_t cp)
	Encode the codepoint into a UTF-8 byte sequence, and add terminating zero. More...

idaman THREAD_SAFE bool ida_export	is_cp_graphical (wchar32_t cp)
	Is the provided codepoint graphical?

idaman THREAD_SAFE size_t ida_export	qustrlen (const char *utf8)

idaman THREAD_SAFE bool ida_export	qustrncpy (char dst, const char utf8, size_t dstsize)
	A safer strncpy - makes sure that there is a terminating zero. More...

idaman ssize_t ida_export	convert_encoding (bytevec_t out, const char fromcode, const char tocode, const uchar indata, ssize_t insize, DEFARG(int flags, 0))
	Convert data from encoding fromcode into tocode. More...

ssize_t	convert_encoding (bytevec_t out, const char fromcode, const char tocode, const bytevec_t indata, DEFARG(int flags, 0))

idaman THREAD_SAFE size_t ida_export	parse_command_line (qstrvec_t args, channel_redirs_t redirs, const char *cmdline, int flags)
	Parse a space separated string (escaping with backslash is supported). More...

char **	expand_argv (int p_argc, int argc, const char const argv[])
	Copy and expand command line arguments. More...

INLINE void	free_argv (int argc, char **argv)
	Free 'argc' elements of 'argv'.

idaman bool ida_export	quote_cmdline_arg (qstring *arg)
	Quote a command line argument if it contains escape characters. More...

idaman bool ida_export	parse_plugin_options (plugin_options_t opts, const char optstring)
	Parse plugin options from IDA command line specified by -O<plugin_name>:<optstring> Note such options can be used not only for plugins, for example, currently we use them for merge (-Omerge:...) and vault server credentials (-Ovault:...) More...

idaman bool ida_export	parse_dbgopts (struct instant_dbgopts_t ido, const char r_switch)
	Parse the -r command line switch (for instant debugging). More...

idaman THREAD_SAFE void *ida_export	launch_process (const launch_process_params_t &lpp, qstring *errbuf=nullptr)
	Launch the specified process in parallel. More...

idaman THREAD_SAFE int ida_export	term_process (void *handle)
	Forcibly terminate a running process. More...

idaman THREAD_SAFE int ida_export	qwait_timed (int *status, int child, int flags, int timeout_ms)
	Wait for state changes in a child process (UNIX only). More...

idaman THREAD_SAFE int ida_export	check_process_exit (void handle, int exit_code, DEFARG(int msecs,-1))
	Check whether process has terminated or not. More...

idaman THREAD_SAFE enum tty_control_t ida_export	is_control_tty (int fd)
	Check if the current process is the owner of the TTY specified by 'fd' (typically an opened descriptor to /dev/tty). More...

idaman THREAD_SAFE void ida_export	qdetach_tty (void)
	If the current terminal is the controlling terminal of the calling process, give up this controlling terminal. More...

idaman THREAD_SAFE void ida_export	qcontrol_tty (void)
	Make the current terminal the controlling terminal of the calling process. More...

	OPAQUE_HANDLE (qthread_t)

idaman THREAD_SAFE qthread_t ida_export	qthread_create (qthread_cb_t thread_cb, void ud)
	Create a thread and return a thread handle.

idaman THREAD_SAFE void ida_export	qthread_free (qthread_t q)
	Free a thread resource (does not kill the thread) (calls pthread_detach under unix)

idaman THREAD_SAFE bool ida_export	qthread_join (qthread_t q)
	Wait a thread until it terminates.

idaman THREAD_SAFE bool ida_export	qthread_kill (qthread_t q)
	Forcefully kill a thread (calls pthread_cancel under unix)

idaman THREAD_SAFE qthread_t ida_export	qthread_self (void)
	Get current thread. Must call qthread_free() to free it!

idaman THREAD_SAFE bool ida_export	qthread_same (qthread_t q)
	Is the current thread the same as 'q'?

idaman THREAD_SAFE bool ida_export	qthread_equal (qthread_t q1, qthread_t q2)
	Are two threads equal?

idaman THREAD_SAFE bool ida_export	is_main_thread (void)
	Are we running in the main thread?

idaman THREAD_SAFE bool ida_export	qsetenv (const char varname, const char value)
	Thread safe function to work with the environment.

idaman THREAD_SAFE bool ida_export	qgetenv (const char varname, DEFARG(qstring buf, nullptr))
	Thread safe function to work with the environment. More...

	OPAQUE_HANDLE (qsemaphore_t)
	Semaphore. More...

idaman THREAD_SAFE qsemaphore_t ida_export	qsem_create (const char *name, int init_count)
	Create a new semaphore.

idaman THREAD_SAFE bool ida_export	qsem_free (qsemaphore_t sem)
	Free a semaphore.

idaman THREAD_SAFE bool ida_export	qsem_post (qsemaphore_t sem)
	Unlock a semaphore.

idaman THREAD_SAFE bool ida_export	qsem_wait (qsemaphore_t sem, int timeout_ms)
	Lock and decrement a semaphore. timeout = -1 means block indefinitely.

	OPAQUE_HANDLE (qmutex_t)
	Mutex.

idaman THREAD_SAFE bool ida_export	qmutex_free (qmutex_t m)
	Free a mutex.

idaman THREAD_SAFE qmutex_t ida_export	qmutex_create (void)
	Create a new mutex.

idaman THREAD_SAFE bool ida_export	qmutex_lock (qmutex_t m)
	Lock a mutex.

idaman THREAD_SAFE bool ida_export	qmutex_unlock (qmutex_t m)
	Unlock a mutex.

idaman THREAD_SAFE int ida_export	qpipe_create (qhandle_t handles[2])
	Create a pipe. More...

idaman THREAD_SAFE ssize_t ida_export	qpipe_read (qhandle_t handle, void *buf, size_t size)
	Read from a pipe. More...

idaman THREAD_SAFE bool ida_export	qpipe_read_n (qhandle_t handle, bytevec_t *out_bytes, size_t n)
	Read a specific amount of bytes from a pipe. More...

idaman THREAD_SAFE ssize_t ida_export	qpipe_write (qhandle_t handle, const void *buf, size_t size)
	Write to a pipe. More...

idaman THREAD_SAFE int ida_export	qpipe_close (qhandle_t handle)
	Close a pipe. More...

idaman THREAD_SAFE int ida_export	qwait_for_handles (int idx, const qhandle_t handles, int n, uint32 write_bitmask, int timeout_ms)
	Wait for file/socket/pipe handles. More...

Detailed Description

This is the first header included in the IDA project.

It defines the most common types, functions and data. Also, it tries to make system dependent definitions.

The following preprocessor macros are used in the project (the list may be incomplete)

Platform must be specified as one of:

__NT__ - MS Windows (all platforms)
__LINUX__ - Linux
__MAC__ - MAC OS X

__EA64__ - 64-bit address size (sizeof(ea_t)==8)
__X86__ - 32-bit debug servers (sizeof(void*)==4)
__X64__ - x64 processor (sizeof(void*)==8) default
__PPC__ - PowerPC
__ARM__ - ARM

Macro Definition Documentation

◆ C_INCLUDE

#define C_INCLUDE

Value:

EXTERNC \

{

◆ MF

#define __MF__ 0

byte sex of our platform (Most significant byte First).

0: little endian (Intel 80x86). 1: big endian (PowerPC).

◆ INTERR_EXC_FMT

#define INTERR_EXC_FMT

Value:

  "Internal error %d occurred when running a script. Either\n" \
  "  - the script misused the IDA API, or\n"                            \
  "  - there is a logic error in IDA\n"                                 \
  "Please check the script first.\n"                                    \
  "If it appears correct, send a bug report to <support@hex-rays.com>.\n" \
  "In any case we strongly recommend you to restart IDA as soon as possible."

◆ DELIMITER

#define DELIMITER ";"

Delimiter of directory lists.

for MS DOS, Windows, other systems - ':' for Unix

◆ MC3

#define MC3	(	c1,
		c2,
		c3
	)	uint32(((((c3)<<8)\|(c2))<<8)\|c1)

We cannot use multi-character constants because they are not portable - use this macro instead.

◆ MC4

#define MC4	(	c1,
		c2,
		c3,
		c4
	)	uint32(((((((c4)<<8)\|(c3))<<8)\|(c2))<<8)\|c1)

We cannot use multi-character constants because they are not portable - use this macro instead.

◆ APPCHAR

#define APPCHAR	(	buf,
		end,
		chr
	)

Value:

  do                                        \
  {                                         \
    char __chr = (chr);                     \
    QASSERT(518, (buf) < (end));            \
    *(buf)++ = __chr;                       \
    if ( (buf) >= (end) )                   \
    {                                       \
      (buf) = (end)-1;                      \
      (buf)[0] = '\0';                      \
    }                                       \
  } while (0)

Append a character to the buffer checking the buffer size.

◆ APPZERO

#define APPZERO	(	buf,
		end
	)

Value:

  do                                        \
  {                                         \
    QASSERT(519, (buf) < (end));            \
    *(buf) = '\0';                          \
  } while (0)

Put a zero byte at buffer.

NB: does not increase buf pointer!

◆ APPEND

#define APPEND	(	buf,
		end,
		name
	)

Value:

  do                                        \
  {                                         \
    QASSERT(520, (buf) < (end));            \
    const char *__ida_in = (name);          \
    while ( true )                          \
    {                                       \
      if ( (buf) == (end)-1 )               \
      {                                     \
        (buf)[0] = '\0';                    \
        break;                              \
      }                                     \
      if ( (*(buf) = *__ida_in++) == '\0' ) \
        break;                              \
      (buf)++;                              \
    }                                       \
  } while ( 0 )

Append a string to the buffer checking the buffer size.

◆ DEFINE_MEMORY_ALLOCATION_FUNCS

#define DEFINE_MEMORY_ALLOCATION_FUNCS ( )

Value:

      void *operator new  (size_t _s) { return qalloc_or_throw(_s); } \
      void *operator new[](size_t _s) { return qalloc_or_throw(_s); } \
      void *operator new(size_t /*size*/, void *_v) { return _v; }    \
      void operator delete  (void *_blk) { qfree(_blk); }             \
      void operator delete[](void *_blk) { qfree(_blk); }             \
      PLACEMENT_DELETE

◆ DECLARE_COMPARISON_OPERATORS

#define DECLARE_COMPARISON_OPERATORS ( type )

Value:

  bool operator==(const type &r) const { return compare(r) == 0; }      \
  bool operator!=(const type &r) const { return compare(r) != 0; }      \
  bool operator< (const type &r) const { return compare(r) <  0; }      \
  bool operator> (const type &r) const { return compare(r) >  0; }      \
  bool operator<=(const type &r) const { return compare(r) <= 0; }      \
  bool operator>=(const type &r) const { return compare(r) >= 0; }

Macro to declare standard inline comparison operators.

◆ DECLARE_COMPARISONS

#define DECLARE_COMPARISONS ( type )

Value:

DECLARE_COMPARISON_OPERATORS(type) \

int compare(const type &r) const

DECLARE_COMPARISON_OPERATORS

#define DECLARE_COMPARISON_OPERATORS(type)

Macro to declare standard inline comparison operators.

Definition: pro.h:2115

Macro to declare comparisons for our classes.

All comparison operators call the compare() function which returns -1/0/1

◆ DEFINE_REVERSE_ITERATOR

#define DEFINE_REVERSE_ITERATOR	(	riter,
		iter
	)

Value:

  class riter                                                           \
  {                                                                     \
    iter p;                                                             \
  public:                                                               \
    riter(void) {}                                                      \
    riter(const iter &x) : p(x) {}                                      \
    typename iter::value_type &operator*(void) const { iter q=p; return *--q; }  \
    typename iter::value_type *operator->(void) const { return &(operator*()); } \
    riter &operator++(void) { --p; return *this; }                      \
    riter  operator++(int) { iter q=p; --p; return q; }                 \
    riter &operator--(void) { ++p; return *this; }                      \
    riter  operator--(int) { iter q=p; ++p; return q; }                 \
    bool operator==(const riter &x) const { return p == x.p; }          \
    bool operator!=(const riter &x) const { return p != x.p; }          \
  };

◆ DECLARE_MEMORY_DESERIALIZER

#define DECLARE_MEMORY_DESERIALIZER ( name )

Value:

name(const void *p, size_t s) : memory_deserializer_t(p, s) {} \

using memory_deserializer_t::unpack; \

memory_deserializer_t

Definition: pro.h:4186

◆ COMPARE_POINTERS2

#define COMPARE_POINTERS2	(	ptr,
		cmp
	)

Value:

  do                                      \
  {                                       \
    if ( ptr != nullptr && r.ptr != nullptr )   \
    {                                     \
      int _code = cmp(*ptr, *r.ptr);      \
      if ( _code != 0 )                   \
        return _code;                     \
    }                                     \
    else if ( r.ptr != nullptr )             \
    {                                     \
      return -1;                          \
    }                                     \
    else if ( ptr != nullptr )               \
    {                                     \
      return 1;                           \
    }                                     \
  } while (0)

◆ COMPARE_FIELDS

#define COMPARE_FIELDS ( fld )

Value:

  do                                   \
  {                                    \
    int _code = ::compare(fld, r.fld); \
    if ( _code != 0 )                  \
      return _code;                    \
  } while (0)

◆ COMPARE_FIELDS_REV

#define COMPARE_FIELDS_REV ( fld )

Value:

  do                                   \
  {                                    \
    int _code = ::compare(r.fld, fld); \
    if ( _code != 0 )                  \
      return _code;                    \
  } while (0)

◆ DECLARE_UNCOPYABLE

#define DECLARE_UNCOPYABLE ( T ) T &operator=(const T &); T(const T &);

Declare class as uncopyable.

(copy assignment and copy ctr are undefined, so if anyone calls them, there will be a compilation or link error)

◆ BELOW_NORMAL_PRIORITY_CLASS

#define BELOW_NORMAL_PRIORITY_CLASS 0x00004000

old Visual C++ compilers were not defining this

◆ DEFINE_CLIOPTS_T_HELPERS

#define DEFINE_CLIOPTS_T_HELPERS ( decl )

Value:

  decl void ida_export cliopts_t_add(cliopts_t &, const cliopt_t *, size_t); \
  decl int ida_export cliopts_t_apply(cliopts_t &, int, const char *[], void *); \
  decl const cliopt_t *ida_export cliopts_t_find_short(const cliopts_t &, char); \
  decl const cliopt_t *ida_export cliopts_t_find_long(const cliopts_t &, const char *); \
  decl NORETURN void ida_export cliopts_t_usage(const cliopts_t &, bool);

◆ LP_USE_SHELL

#define LP_USE_SHELL 0x0008

use shell to launch the command.

'path' is ignored in this case.

Typedef Documentation

◆ ssize_t

typedef ptrdiff_t ssize_t

Signed size_t - used to check for size overflows when the counter becomes negative.

Also signed size_t allows us to signal an error condition using a negative value, for example, as a function return value.

◆ uval_t

typedef asize_t uval_t

unsigned value used by the processor.

for 32-bit ::ea_t - uint32
for 64-bit ::ea_t - ::uint64

◆ sval_t

typedef adiff_t sval_t

signed value used by the processor.

for 32-bit ::ea_t - int32
for 64-bit ::ea_t - ::int64

◆ ea32_t

typedef uint32 ea32_t

32-bit address, regardless of IDA bitness.

this type can be used when we know in advance that 32 bits are enough to hold an address.

◆ ea64_t

typedef uint64 ea64_t

64-bit address, regardless of IDA bitness.

we need this type for interoperability with debug servers, lumina, etc

◆ inode_t

typedef uval_t inode_t

The inode_t type is the specialization specific inode number.

For example, it can represent a local type ordinal or a structure id.

◆ qthread_cb_t

typedef int idaapi qthread_cb_t(void *ud)

THREADS.

Thread callback function

Function Documentation

◆ make_qtime64()

INLINE THREAD_SAFE qtime64_t make_qtime64	(	uint32	secs,
		DEFARG(int32 usecs, 0)
	)

Get a qtime64_t instance from a seconds value and microseconds value.

Parameters

secs	seconds
usecs	microseconds

◆ qctime()

idaman THREAD_SAFE bool ida_export qctime	(	char *	buf,
		size_t	bufsize,
		qtime32_t	t
	)

Converts calendar time into a string.

Puts 'wrong timestamp\n' into the buffer if failed

Parameters

buf	output buffer
bufsize	size of the output buffer
t	calendar time

Returns: success See also qstrftime()

◆ qctime_utc()

idaman THREAD_SAFE bool ida_export qctime_utc	(	char *	buf,
		size_t	bufsize,
		qtime32_t	t
	)

Converts calendar time into a string using Coordinated Universal Time (UTC).

Function is equivalent to asctime(gmtime(t)). Puts 'wrong timestamp\n' into the buffer if failed.

Parameters

buf	output buffer
bufsize	of the output buffer
t	calendar time

Returns: success

◆ qlocaltime()

idaman THREAD_SAFE bool ida_export qlocaltime	(	struct tm *	_tm,
		qtime32_t	t
	)

Converts a time value to a tm structure (local time)

Parameters

[out]	_tm	result
	t	calendar time

Returns: success

◆ qgmtime()

idaman bool ida_export qgmtime	(	struct tm *	_tm,
		qtime32_t	t
	)

Converts a time value to a tm structure (UTC time)

Parameters

[out]	_tm	result
	t	calendar time

Returns: success

◆ AS_STRFTIME()

idaman AS_STRFTIME ( 3 )

Get string representation of a qtime32_t (local time) Copies into 'buf' the content of 'format', expanding its format specifiers into the corresponding values that represent the time described in 't', with a limit of 'bufsize' characters see http://www.cplusplus.com/reference/ctime/strftime/ for more.

Same as qstrftime(), but accepts a 64-bit time value.

Parameters

buf	output buffer
bufsize	of the output buffer
format	format string
t	calendar time value

Returns: length of the resulting string See also qctime()

◆ get_nsec_stamp()

idaman THREAD_SAFE uint64 ida_export get_nsec_stamp ( void )

High resolution timer.

On Unix systems, returns current time in nanoseconds. On Windows, returns a high resolution counter (QueryPerformanceCounter)

Returns: stamp in nanoseconds

◆ gen_rand_buf()

idaman THREAD_SAFE bool ida_export gen_rand_buf	(	void *	buffer,
		size_t	bufsz
	)

Generate a random buffer.

Parameters

[out]	buffer	pointer to result
	bufsz	size of buffer

Returns: success

◆ set_interr_throws()

idaman THREAD_SAFE bool ida_export set_interr_throws ( bool enable )

Parameters

enable if true, interr() throws interr_exc_t otherwise it terminates IDA after showing an error message

Returns: previous setting

◆ memrev()

idaman THREAD_SAFE void *ida_export memrev	(	void *	buf,
		ssize_t	size
	)

Reverse memory block.

Analog of strrev() function

Parameters

buf	pointer to buffer to reverse
size	size of buffer

Returns: pointer to buffer

◆ strrpl()

idaman THREAD_SAFE char *ida_export strrpl	(	char *	str,
		int	char1,
		int	char2
	)

Replace all occurrences of a character within a string.

Parameters

str	to modify
char1	char to be replaced
char2	replacement char

Returns: pointer to resulting string

◆ tail()

THREAD_SAFE const char * tail ( const char * str )

inline

Get tail of a string.

◆ qstrncpy()

idaman THREAD_SAFE char *ida_export qstrncpy	(	char *	dst,
		const char *	src,
		size_t	dstsize
	)

A safer strncpy - makes sure that there is a terminating zero.

nb: this function doesn't fill the whole buffer zeroes as strncpy does nb: ssize_t(dstsize) must be > 0

◆ stristr()

idaman THREAD_SAFE const char *ida_export stristr	(	const char *	s1,
		const char *	s2
	)

Find one string in another (Case insensitive analog of strstr()).

Parameters

s1	string to be searched
s2	string to search for

Returns: a pointer to the first occurrence of s2 within s1, nullptr if none exists

◆ GCC_DIAG_OFF()

GCC_DIAG_OFF ( format- nonliteral )

qsnprintf that does not check its arguments.

Normally gcc complains about the non-literal formats. However, sometimes we still need to call qsnprintf with a dynamically built format string. OTOH, there are absolutely no checks of the input arguments, so be careful!

◆ qmakepath()

idaman THREAD_SAFE char *ida_export qmakepath	(	char *	buf,
		size_t	bufsize,
		const char *	s1,
			...
	)

Construct a path from a null-terminated sequence of strings.

Parameters

buf	output buffer. Can be == s1, but must not be nullptr
bufsize	size of buffer
s1	the first path component. it may be followed by more components. the argument list must end with nullptr.

Returns: pointer to result

◆ qgetcwd()

idaman void ida_export qgetcwd	(	char *	buf,
		size_t	bufsize
	)

Get the current working directory.

Parameters

buf	output buffer
bufsize	size of buffer This function calls error() if any problem occurs.

◆ qchdir()

idaman int ida_export qchdir ( const char * path )

Change the current working directory.

Parameters

path	the new directory The possible return values are the same as those of the POSIX 'chdir'

◆ qdirname()

idaman THREAD_SAFE bool ida_export qdirname	(	char *	buf,
		size_t	bufsize,
		const char *	path
	)

Get the directory part of the path.

path and buf may point to the same buffer

Parameters

[out]	buf	buffer for the directory part. can be nullptr.
[out]	bufsize	size of this buffer
	path	path to split

Return values

true	ok
false	input buffer did not have the directory part. In this case the buffer is filled with "."

◆ qmakefile()

idaman THREAD_SAFE char *ida_export qmakefile	(	char *	buf,
		size_t	bufsize,
		const char *	base,
		const char *	ext
	)

Construct filename from base name and extension.

Parameters

buf	output buffer. Can be == base, but must not be nullptr
bufsize	size of buffer
base	base name
ext	extension

Returns: pointer to result

◆ qsplitfile()

idaman THREAD_SAFE char *ida_export qsplitfile	(	char *	file,
		char **	base,
		char **	ext
	)

Split filename into base name and extension.

Parameters

file	filename, may be changed
base	filled with base part, can be nullptr
ext	filled with extension part, can be nullptr

Returns: the base part

◆ qbasename()

idaman THREAD_SAFE const char *ida_export qbasename ( const char * path )

Get the file name part of the given path.

Returns: nullptr if path is nullptr

◆ search_path()

idaman THREAD_SAFE bool ida_export search_path	(	char *	buf,
		size_t	bufsize,
		const char *	file,
		bool	search_cwd
	)

Search for a file in the PATH environment variable or the current directory.

Parameters

buf	output buffer to hold the full file path
bufsize	output buffer size
file	the file name to look for. If the file is an absolute path then buf will return the file value.
search_cwd	search the current directory if file was not found in the PATH

Returns: true if the file was found and false otherwise

◆ set_file_ext()

idaman THREAD_SAFE char *ida_export set_file_ext	(	char *	outbuf,
		size_t	bufsize,
		const char *	file,
		const char *	ext
	)

Set file name extension unconditionally.

Parameters

outbuf	buffer to hold the answer. may be the same as the file name.
bufsize	output buffer size
file	the file name
ext	new extension (with or without '.')

Returns: pointer to the new file name

◆ get_file_ext()

idaman THREAD_SAFE const char *ida_export get_file_ext ( const char * file )

Get pointer to extension of file name.

Parameters

file filename

Returns: pointer to the file extension or nullptr if extension doesn't exist

◆ make_file_ext()

THREAD_SAFE char *idaapi make_file_ext	(	char *	buf,
		size_t	bufsize,
		const char *	file,
		const char *	ext
	)

inline

Set file name extension if none exists.

This function appends the extension to a file name. It won't change file name if extension already exists

Parameters

buf	output buffer
bufsize	size of the output buffer
file	file name
ext	extension (with or without '.')

Returns: pointer to the new file name

◆ sanitize_file_name()

idaman THREAD_SAFE bool ida_export sanitize_file_name	(	char *	name,
		size_t	namesize
	)

Sanitize the file name.

Remove the directory path, and replace wildcards ? * and chars<' ' with _. If the file name is empty, then:

namesize != 0: generate a new temporary name, return true
namesize == 0: return false

◆ wildcard_match()

bool wildcard_match	(	const char *	name,
		const char *	pattern
	)

Match a name against a pattern.

Only * and ? wildcards are supported.

Parameters

name	name to match
pattern	pattern to match against

Returns: true is matched

◆ wildcard_path_match()

bool wildcard_path_match	(	const char *	name,
		const char *	_pattern,
		int	flags = `0`
	)

Match a path against a pattern.

**, *, ?, and ranges like [a-zA-Z] are supported.

Parameters

name	name to match
_pattern	pattern to match against
flags	combination of WPM_... bits

Returns: true is matched

◆ regex_match()

idaman int ida_export regex_match	(	const char *	str,
		const char *	pattern,
		bool	sense_case
	)

Match a string with a regular expression.

Return values

0	no match
1	match
-1	error