to activate or cancel the filter
+# option.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+SEARCHENGINE = YES
+
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
+# implemented using a web server instead of a web client using Javascript. There
+# are two flavors of web server based searching depending on the EXTERNAL_SEARCH
+# setting. When disabled, doxygen will generate a PHP script for searching and
+# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
+# and searching needs to be provided by external tools. See the section
+# "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SERVER_BASED_SEARCH = NO
+
+# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
+# script for searching. Instead the search results are written to an XML file
+# which needs to be processed by an external indexer. Doxygen will invoke an
+# external search engine pointed to by the SEARCHENGINE_URL option to obtain the
+# search results.
+#
+# Doxygen ships with an example indexer (doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see: http://xapian.org/).
+#
+# See the section "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTERNAL_SEARCH = NO
+
+# The SEARCHENGINE_URL should point to a search engine hosted by a web server
+# which will return the search results when EXTERNAL_SEARCH is enabled.
+#
+# Doxygen ships with an example indexer (doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see: http://xapian.org/). See the section "External Indexing and
+# Searching" for details.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SEARCHENGINE_URL =
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
+# search data is written to a file for indexing by an external tool. With the
+# SEARCHDATA_FILE tag the name of this file can be specified.
+# The default file is: searchdata.xml.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SEARCHDATA_FILE = searchdata.xml
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
+# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
+# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
+# projects and redirect the results back to the right project.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTERNAL_SEARCH_ID =
+
+# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
+# projects other than the one defined by this configuration file, but that are
+# all added to the same external search index. Each project needs to have a
+# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
+# to a relative location where the documentation can be found. The format is:
+# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTRA_SEARCH_MAPPINGS =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES, doxygen will generate LaTeX output.
+# The default value is: YES.
+
+GENERATE_LATEX = NO
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: latex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_OUTPUT = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
+# invoked.
+#
+# Note that when enabling USE_PDFLATEX this option is only used for generating
+# bitmaps for formulas in the HTML output, but not in the Makefile that is
+# written to the output directory.
+# The default file is: latex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_CMD_NAME = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
+# index for LaTeX.
+# The default file is: makeindex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+MAKEINDEX_CMD_NAME = makeindex
+
+# If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+COMPACT_LATEX = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used by the
+# printer.
+# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
+# 14 inches) and executive (7.25 x 10.5 inches).
+# The default value is: a4.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+PAPER_TYPE = a4
+
+# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
+# that should be included in the LaTeX output. The package can be specified just
+# by its name or with the correct syntax as to be used with the LaTeX
+# \usepackage command. To get the times font for instance you can specify :
+# EXTRA_PACKAGES=times or EXTRA_PACKAGES={times}
+# To use the option intlimits with the amsmath package you can specify:
+# EXTRA_PACKAGES=[intlimits]{amsmath}
+# If left blank no extra packages will be included.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+EXTRA_PACKAGES =
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
+# generated LaTeX document. The header should contain everything until the first
+# chapter. If it is left blank doxygen will generate a standard header. See
+# section "Doxygen usage" for information on how to let doxygen write the
+# default header to a separate file.
+#
+# Note: Only use a user-defined header if you know what you are doing! The
+# following commands have a special meaning inside the header: $title,
+# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
+# $projectbrief, $projectlogo. Doxygen will replace $title with the empty
+# string, for the replacement values of the other commands the user is referred
+# to HTML_HEADER.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_HEADER =
+
+# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
+# generated LaTeX document. The footer should contain everything after the last
+# chapter. If it is left blank doxygen will generate a standard footer. See
+# LATEX_HEADER for more information on how to generate a default footer and what
+# special commands can be used inside the footer.
+#
+# Note: Only use a user-defined footer if you know what you are doing!
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_FOOTER =
+
+# The LATEX_EXTRA_STYLESHEET tag can be used to specify additional user-defined
+# LaTeX style sheets that are included after the standard style sheets created
+# by doxygen. Using this option one can overrule certain style aspects. Doxygen
+# will copy the style sheet files to the output directory.
+# Note: The order of the extra style sheet files is of importance (e.g. the last
+# style sheet in the list overrules the setting of the previous ones in the
+# list).
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EXTRA_STYLESHEET =
+
+# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the LATEX_OUTPUT output
+# directory. Note that the files will be copied as-is; there are no commands or
+# markers available.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EXTRA_FILES =
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
+# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
+# contain links (just like the HTML output) instead of page references. This
+# makes the output suitable for online browsing using a PDF viewer.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+PDF_HYPERLINKS = YES
+
+# If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
+# the PDF file directly from the LaTeX files. Set this option to YES, to get a
+# higher quality PDF documentation.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+USE_PDFLATEX = YES
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
+# command to the generated LaTeX files. This will instruct LaTeX to keep running
+# if errors occur, instead of asking the user for help. This option is also used
+# when generating formulas in HTML.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_BATCHMODE = NO
+
+# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
+# index chapters (such as File Index, Compound Index, etc.) in the output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_HIDE_INDICES = NO
+
+# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
+# code with syntax highlighting in the LaTeX output.
+#
+# Note that which sources are shown also depends on other settings such as
+# SOURCE_BROWSER.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_SOURCE_CODE = NO
+
+# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
+# bibliography, e.g. plainnat, or ieeetr. See
+# http://en.wikipedia.org/wiki/BibTeX and \cite for more info.
+# The default value is: plain.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_BIB_STYLE = plain
+
+# If the LATEX_TIMESTAMP tag is set to YES then the footer of each generated
+# page will contain the date and time when the page was generated. Setting this
+# to NO can help when comparing the output of multiple runs.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_TIMESTAMP = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES, doxygen will generate RTF output. The
+# RTF output is optimized for Word 97 and may not look too pretty with other RTF
+# readers/editors.
+# The default value is: NO.
+
+GENERATE_RTF = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: rtf.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_OUTPUT = rtf
+
+# If the COMPACT_RTF tag is set to YES, doxygen generates more compact RTF
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+COMPACT_RTF = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
+# contain hyperlink fields. The RTF file will contain links (just like the HTML
+# output) instead of page references. This makes the output suitable for online
+# browsing using Word or some other Word compatible readers that support those
+# fields.
+#
+# Note: WordPad (write) and others do not support links.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_HYPERLINKS = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's config
+# file, i.e. a series of assignments. You only have to provide replacements,
+# missing definitions are set to their default value.
+#
+# See also section "Doxygen usage" for information on how to generate the
+# default style sheet that doxygen normally uses.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_STYLESHEET_FILE =
+
+# Set optional variables used in the generation of an RTF document. Syntax is
+# similar to doxygen's config file. A template extensions file can be generated
+# using doxygen -e rtf extensionFile.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_EXTENSIONS_FILE =
+
+# If the RTF_SOURCE_CODE tag is set to YES then doxygen will include source code
+# with syntax highlighting in the RTF output.
+#
+# Note that which sources are shown also depends on other settings such as
+# SOURCE_BROWSER.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_SOURCE_CODE = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES, doxygen will generate man pages for
+# classes and files.
+# The default value is: NO.
+
+GENERATE_MAN = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it. A directory man3 will be created inside the directory specified by
+# MAN_OUTPUT.
+# The default directory is: man.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_OUTPUT = man
+
+# The MAN_EXTENSION tag determines the extension that is added to the generated
+# man pages. In case the manual section does not start with a number, the number
+# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
+# optional.
+# The default value is: .3.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_EXTENSION = .3
+
+# The MAN_SUBDIR tag determines the name of the directory created within
+# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
+# MAN_EXTENSION with the initial . removed.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_SUBDIR =
+
+# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
+# will generate one additional man file for each entity documented in the real
+# man page(s). These additional files only source the real man page, but without
+# them the man command would be unable to find the correct page.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_LINKS = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES, doxygen will generate an XML file that
+# captures the structure of the code including all documentation.
+# The default value is: NO.
+
+GENERATE_XML = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: xml.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_OUTPUT = xml
+
+# If the XML_PROGRAMLISTING tag is set to YES, doxygen will dump the program
+# listings (including syntax highlighting and cross-referencing information) to
+# the XML output. Note that enabling this will significantly increase the size
+# of the XML output.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_PROGRAMLISTING = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to the DOCBOOK output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_DOCBOOK tag is set to YES, doxygen will generate Docbook files
+# that can be used to generate PDF.
+# The default value is: NO.
+
+GENERATE_DOCBOOK = NO
+
+# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
+# front of it.
+# The default directory is: docbook.
+# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
+
+DOCBOOK_OUTPUT = docbook
+
+# If the DOCBOOK_PROGRAMLISTING tag is set to YES, doxygen will include the
+# program listings (including syntax highlighting and cross-referencing
+# information) to the DOCBOOK output. Note that enabling this will significantly
+# increase the size of the DOCBOOK output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
+
+DOCBOOK_PROGRAMLISTING = NO
+
+#---------------------------------------------------------------------------
+# Configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an
+# AutoGen Definitions (see http://autogen.sf.net) file that captures the
+# structure of the code including all documentation. Note that this feature is
+# still experimental and incomplete at the moment.
+# The default value is: NO.
+
+GENERATE_AUTOGEN_DEF = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES, doxygen will generate a Perl module
+# file that captures the structure of the code including all documentation.
+#
+# Note that this feature is still experimental and incomplete at the moment.
+# The default value is: NO.
+
+GENERATE_PERLMOD = NO
+
+# If the PERLMOD_LATEX tag is set to YES, doxygen will generate the necessary
+# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
+# output from the Perl module output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_LATEX = NO
+
+# If the PERLMOD_PRETTY tag is set to YES, the Perl module output will be nicely
+# formatted so it can be parsed by a human reader. This is useful if you want to
+# understand what is going on. On the other hand, if this tag is set to NO, the
+# size of the Perl module output will be much smaller and Perl will parse it
+# just the same.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_PRETTY = YES
+
+# The names of the make variables in the generated doxyrules.make file are
+# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
+# so different doxyrules.make files included by the same Makefile don't
+# overwrite each other's variables.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_MAKEVAR_PREFIX =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES, doxygen will evaluate all
+# C-preprocessor directives found in the sources and include files.
+# The default value is: YES.
+
+ENABLE_PREPROCESSING = YES
+
+# If the MACRO_EXPANSION tag is set to YES, doxygen will expand all macro names
+# in the source code. If set to NO, only conditional compilation will be
+# performed. Macro expansion can be done in a controlled way by setting
+# EXPAND_ONLY_PREDEF to YES.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+MACRO_EXPANSION = NO
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
+# the macro expansion is limited to the macros specified with the PREDEFINED and
+# EXPAND_AS_DEFINED tags.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+EXPAND_ONLY_PREDEF = NO
+
+# If the SEARCH_INCLUDES tag is set to YES, the include files in the
+# INCLUDE_PATH will be searched if a #include is found.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+SEARCH_INCLUDES = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that
+# contain include files that are not input files but should be processed by the
+# preprocessor.
+# This tag requires that the tag SEARCH_INCLUDES is set to YES.
+
+INCLUDE_PATH =
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
+# patterns (like *.h and *.hpp) to filter out the header-files in the
+# directories. If left blank, the patterns specified with FILE_PATTERNS will be
+# used.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+INCLUDE_FILE_PATTERNS =
+
+# The PREDEFINED tag can be used to specify one or more macro names that are
+# defined before the preprocessor is started (similar to the -D option of e.g.
+# gcc). The argument of the tag is a list of macros of the form: name or
+# name=definition (no spaces). If the definition and the "=" are omitted, "=1"
+# is assumed. To prevent a macro definition from being undefined via #undef or
+# recursively expanded use the := operator instead of the = operator.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+PREDEFINED =
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
+# tag can be used to specify a list of macro names that should be expanded. The
+# macro definition that is found in the sources will be used. Use the PREDEFINED
+# tag if you want to use a different macro definition that overrules the
+# definition found in the source code.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+EXPAND_AS_DEFINED =
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
+# remove all references to function-like macros that are alone on a line, have
+# an all uppercase name, and do not end with a semicolon. Such function macros
+# are typically used for boiler-plate code, and will confuse the parser if not
+# removed.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+SKIP_FUNCTION_MACROS = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES tag can be used to specify one or more tag files. For each tag
+# file the location of the external documentation should be added. The format of
+# a tag file without this location is as follows:
+# TAGFILES = file1 file2 ...
+# Adding location for the tag files is done as follows:
+# TAGFILES = file1=loc1 "file2 = loc2" ...
+# where loc1 and loc2 can be relative or absolute paths or URLs. See the
+# section "Linking to external documentation" for more information about the use
+# of tag files.
+# Note: Each tag file must have a unique name (where the name does NOT include
+# the path). If a tag file is not located in the directory in which doxygen is
+# run, you must also specify the path to the tagfile here.
+
+TAGFILES =
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create a
+# tag file that is based on the input files it reads. See section "Linking to
+# external documentation" for more information about the usage of tag files.
+
+GENERATE_TAGFILE =
+
+# If the ALLEXTERNALS tag is set to YES, all external class will be listed in
+# the class index. If set to NO, only the inherited external classes will be
+# listed.
+# The default value is: NO.
+
+ALLEXTERNALS = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES, all external groups will be listed
+# in the modules index. If set to NO, only the current project's groups will be
+# listed.
+# The default value is: YES.
+
+EXTERNAL_GROUPS = YES
+
+# If the EXTERNAL_PAGES tag is set to YES, all external pages will be listed in
+# the related pages index. If set to NO, only the current project's pages will
+# be listed.
+# The default value is: YES.
+
+EXTERNAL_PAGES = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script
+# interpreter (i.e. the result of 'which perl').
+# The default file (with absolute path) is: /usr/bin/perl.
+
+PERL_PATH = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram
+# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
+# NO turns the diagrams off. Note that this option also works with HAVE_DOT
+# disabled, but it is recommended to install and use dot, since it yields more
+# powerful graphs.
+# The default value is: YES.
+
+CLASS_DIAGRAMS = YES
+
+# You can define message sequence charts within doxygen comments using the \msc
+# command. Doxygen will then run the mscgen tool (see:
+# http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the
+# documentation. The MSCGEN_PATH tag allows you to specify the directory where
+# the mscgen tool resides. If left empty the tool is assumed to be found in the
+# default search path.
+
+MSCGEN_PATH =
+
+# You can include diagrams made with dia in doxygen documentation. Doxygen will
+# then run dia to produce the diagram and insert it in the documentation. The
+# DIA_PATH tag allows you to specify the directory where the dia binary resides.
+# If left empty dia is assumed to be found in the default search path.
+
+DIA_PATH =
+
+# If set to YES the inheritance and collaboration graphs will hide inheritance
+# and usage relations if the target is undocumented or is not a class.
+# The default value is: YES.
+
+HIDE_UNDOC_RELATIONS = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
+# available from the path. This tool is part of Graphviz (see:
+# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
+# Bell Labs. The other options in this section have no effect if this option is
+# set to NO
+# The default value is: NO.
+
+HAVE_DOT = NO
+
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
+# to run in parallel. When set to 0 doxygen will base this on the number of
+# processors available in the system. You can set it explicitly to a value
+# larger than 0 to get control over the balance between CPU load and processing
+# speed.
+# Minimum value: 0, maximum value: 32, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_NUM_THREADS = 0
+
+# When you want a differently looking font in the dot files that doxygen
+# generates you can specify the font name using DOT_FONTNAME. You need to make
+# sure dot is able to find the font, which can be done by putting it in a
+# standard location or by setting the DOTFONTPATH environment variable or by
+# setting DOT_FONTPATH to the directory containing the font.
+# The default value is: Helvetica.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTNAME = Helvetica
+
+# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
+# dot graphs.
+# Minimum value: 4, maximum value: 24, default value: 10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTSIZE = 10
+
+# By default doxygen will tell dot to use the default font as specified with
+# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
+# the path where dot can find it using this tag.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTPATH =
+
+# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
+# each documented class showing the direct and indirect inheritance relations.
+# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CLASS_GRAPH = YES
+
+# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
+# graph for each documented class showing the direct and indirect implementation
+# dependencies (inheritance, containment, and class references variables) of the
+# class with other documented classes.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+COLLABORATION_GRAPH = YES
+
+# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
+# groups, showing the direct groups dependencies.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GROUP_GRAPHS = YES
+
+# If the UML_LOOK tag is set to YES, doxygen will generate inheritance and
+# collaboration diagrams in a style similar to the OMG's Unified Modeling
+# Language.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+UML_LOOK = NO
+
+# If the UML_LOOK tag is enabled, the fields and methods are shown inside the
+# class node. If there are many fields or methods and many nodes the graph may
+# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
+# number of items for each type to make the size more manageable. Set this to 0
+# for no limit. Note that the threshold may be exceeded by 50% before the limit
+# is enforced. So when you set the threshold to 10, up to 15 fields may appear,
+# but if the number exceeds 15, the total amount of fields shown is limited to
+# 10.
+# Minimum value: 0, maximum value: 100, default value: 10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+UML_LIMIT_NUM_FIELDS = 10
+
+# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
+# collaboration graphs will show the relations between templates and their
+# instances.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+TEMPLATE_RELATIONS = NO
+
+# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
+# YES then doxygen will generate a graph for each documented file showing the
+# direct and indirect include dependencies of the file with other documented
+# files.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INCLUDE_GRAPH = YES
+
+# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
+# set to YES then doxygen will generate a graph for each documented file showing
+# the direct and indirect include dependencies of the file with other documented
+# files.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INCLUDED_BY_GRAPH = YES
+
+# If the CALL_GRAPH tag is set to YES then doxygen will generate a call
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable call graphs for selected
+# functions only using the \callgraph command. Disabling a call graph can be
+# accomplished by means of the command \hidecallgraph.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALL_GRAPH = NO
+
+# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable caller graphs for selected
+# functions only using the \callergraph command. Disabling a caller graph can be
+# accomplished by means of the command \hidecallergraph.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALLER_GRAPH = NO
+
+# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
+# hierarchy of all classes instead of a textual one.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GRAPHICAL_HIERARCHY = YES
+
+# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
+# dependencies a directory has on other directories in a graphical way. The
+# dependency relations are determined by the #include relations between the
+# files in the directories.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DIRECTORY_GRAPH = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
+# generated by dot. For an explanation of the image formats see the section
+# output formats in the documentation of the dot tool (Graphviz (see:
+# http://www.graphviz.org/)).
+# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
+# to make the SVG files visible in IE 9+ (other browsers do not have this
+# requirement).
+# Possible values are: png, jpg, gif, svg, png:gd, png:gd:gd, png:cairo,
+# png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and
+# png:gdiplus:gdiplus.
+# The default value is: png.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_IMAGE_FORMAT = png
+
+# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
+# enable generation of interactive SVG images that allow zooming and panning.
+#
+# Note that this requires a modern browser other than Internet Explorer. Tested
+# and working are Firefox, Chrome, Safari, and Opera.
+# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
+# the SVG files visible. Older versions of IE do not have SVG support.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INTERACTIVE_SVG = NO
+
+# The DOT_PATH tag can be used to specify the path where the dot tool can be
+# found. If left blank, it is assumed the dot tool can be found in the path.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_PATH =
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that
+# contain dot files that are included in the documentation (see the \dotfile
+# command).
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOTFILE_DIRS =
+
+# The MSCFILE_DIRS tag can be used to specify one or more directories that
+# contain msc files that are included in the documentation (see the \mscfile
+# command).
+
+MSCFILE_DIRS =
+
+# The DIAFILE_DIRS tag can be used to specify one or more directories that
+# contain dia files that are included in the documentation (see the \diafile
+# command).
+
+DIAFILE_DIRS =
+
+# When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
+# path where java can find the plantuml.jar file. If left blank, it is assumed
+# PlantUML is not used or called during a preprocessing step. Doxygen will
+# generate a warning when it encounters a \startuml command in this case and
+# will not generate output for the diagram.
+
+PLANTUML_JAR_PATH =
+
+# When using plantuml, the PLANTUML_CFG_FILE tag can be used to specify a
+# configuration file for plantuml.
+
+PLANTUML_CFG_FILE =
+
+# When using plantuml, the specified paths are searched for files specified by
+# the !include statement in a plantuml block.
+
+PLANTUML_INCLUDE_PATH =
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
+# that will be shown in the graph. If the number of nodes in a graph becomes
+# larger than this value, doxygen will truncate the graph, which is visualized
+# by representing a node as a red box. Note that doxygen if the number of direct
+# children of the root node in a graph is already larger than
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
+# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+# Minimum value: 0, maximum value: 10000, default value: 50.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_GRAPH_MAX_NODES = 50
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
+# generated by dot. A depth value of 3 means that only nodes reachable from the
+# root by following a path via at most 3 edges will be shown. Nodes that lay
+# further from the root node will be omitted. Note that setting this option to 1
+# or 2 may greatly reduce the computation time needed for large code bases. Also
+# note that the size of a graph can be further restricted by
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+# Minimum value: 0, maximum value: 1000, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+MAX_DOT_GRAPH_DEPTH = 0
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not seem
+# to support this out of the box.
+#
+# Warning: Depending on the platform used, enabling this option may lead to
+# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
+# read).
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_TRANSPARENT = NO
+
+# Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output
+# files in one run (i.e. multiple -o and -T options on the command line). This
+# makes dot run faster, but since only newer versions of dot (>1.8.10) support
+# this, this feature is disabled by default.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_MULTI_TARGETS = NO
+
+# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
+# explaining the meaning of the various boxes and arrows in the dot generated
+# graphs.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GENERATE_LEGEND = YES
+
+# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate dot
+# files that are used to generate the various graphs.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_CLEANUP = YES
diff --git a/detours/detours/zydis/Doxyfile-mcss b/detours/detours/zydis/Doxyfile-mcss
new file mode 100644
index 0000000..b6399a8
--- /dev/null
+++ b/detours/detours/zydis/Doxyfile-mcss
@@ -0,0 +1,6 @@
+@INCLUDE = Doxyfile
+GENERATE_HTML = NO
+GENERATE_XML = YES
+XML_PROGRAMLISTING = NO
+##!M_LINKS_NAVBAR1 = modules files
+##!M_LINKS_NAVBAR2 =
\ No newline at end of file
diff --git a/detours/detours/zydis/LICENSE b/detours/detours/zydis/LICENSE
new file mode 100644
index 0000000..fa20362
--- /dev/null
+++ b/detours/detours/zydis/LICENSE
@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2019 Florian Bernd
+Copyright (c) 2014-2019 Joel Höner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
diff --git a/detours/detours/zydis/README.md b/detours/detours/zydis/README.md
new file mode 100644
index 0000000..354d96a
--- /dev/null
+++ b/detours/detours/zydis/README.md
@@ -0,0 +1,154 @@
+
+ 
+
+
+
+ 
+
+ 
+
+
+ 
+
+
+ 
+
+
+
+Fast and lightweight x86/x86-64 disassembler library.
+
+## Features
+- Supports all x86 and x86-64 (AMD64) instructions and [extensions](./include/Zydis/Generated/EnumISAExt.h)
+- Optimized for high performance
+- No dynamic memory allocation ("malloc")
+- Thread-safe by design
+- Very small file-size overhead compared to other common disassembler libraries
+- Complete doxygen documentation ([master](https://zydis.re/doc/3/), [stable](https://zydis.re/doc/2/))
+- Absolutely no third party dependencies — not even libc
+ - Should compile on any platform with a working C99 compiler
+ - Tested on Windows, macOS, FreeBSD, Linux and UEFI, both user and kernel mode
+
+## Quick Example
+The following example program uses Zydis to disassemble a given memory buffer and prints the output to the console ([more examples here](./examples/)).
+
+```C
+#include
+#include
+#include
+
+int main()
+{
+ ZyanU8 data[] =
+ {
+ 0x51, 0x8D, 0x45, 0xFF, 0x50, 0xFF, 0x75, 0x0C, 0xFF, 0x75,
+ 0x08, 0xFF, 0x15, 0xA0, 0xA5, 0x48, 0x76, 0x85, 0xC0, 0x0F,
+ 0x88, 0xFC, 0xDA, 0x02, 0x00
+ };
+
+ // Initialize decoder context
+ ZydisDecoder decoder;
+ ZydisDecoderInit(&decoder, ZYDIS_MACHINE_MODE_LONG_64, ZYDIS_ADDRESS_WIDTH_64);
+
+ // Initialize formatter. Only required when you actually plan to do instruction
+ // formatting ("disassembling"), like we do here
+ ZydisFormatter formatter;
+ ZydisFormatterInit(&formatter, ZYDIS_FORMATTER_STYLE_INTEL);
+
+ // Loop over the instructions in our buffer.
+ // The runtime-address (instruction pointer) is chosen arbitrary here in order to better
+ // visualize relative addressing
+ ZyanU64 runtime_address = 0x007FFFFFFF400000;
+ ZyanUSize offset = 0;
+ const ZyanUSize length = sizeof(data);
+ ZydisDecodedInstruction instruction;
+ while (ZYAN_SUCCESS(ZydisDecoderDecodeBuffer(&decoder, data + offset, length - offset,
+ &instruction)))
+ {
+ // Print current instruction pointer.
+ printf("%016" PRIX64 " ", runtime_address);
+
+ // Format & print the binary instruction structure to human readable format
+ char buffer[256];
+ ZydisFormatterFormatInstruction(&formatter, &instruction, buffer, sizeof(buffer),
+ runtime_address);
+ puts(buffer);
+
+ offset += instruction.length;
+ runtime_address += instruction.length;
+ }
+}
+```
+
+## Sample Output
+The above example program generates the following output:
+
+```asm
+007FFFFFFF400000 push rcx
+007FFFFFFF400001 lea eax, [rbp-0x01]
+007FFFFFFF400004 push rax
+007FFFFFFF400005 push qword ptr [rbp+0x0C]
+007FFFFFFF400008 push qword ptr [rbp+0x08]
+007FFFFFFF40000B call [0x008000007588A5B1]
+007FFFFFFF400011 test eax, eax
+007FFFFFFF400013 js 0x007FFFFFFF42DB15
+```
+
+## Build
+
+#### Unix
+Zydis builds cleanly on most platforms without any external dependencies. You can use CMake to generate project files for your favorite C99 compiler.
+
+```bash
+git clone --recursive 'https://github.com/zyantific/zydis.git'
+cd zydis
+mkdir build && cd build
+cmake ..
+make
+```
+
+#### Windows
+Either use the [Visual Studio 2017 project](./msvc/) or build Zydis using [CMake](https://cmake.org/download/) ([video guide](https://www.youtube.com/watch?v=fywLDK1OAtQ)).
+
+## `ZydisInfo` tool
+
+
+## Bindings
+Official bindings exist for a selection of languages:
+- [Rust](https://github.com/zyantific/zydis-rs)
+- [Pascal](https://github.com/zyantific/zydis-pascal)
+
+Unofficial but actively maintained bindings:
+- [Python 3](https://github.com/novogen/pydis)
+- [LuaJIT](https://github.com/Wiladams/lj2zydis)
+
+## Versions
+
+#### Scheme
+Versions follow the [semantic versioning scheme](https://semver.org/). All stability guarantees apply to the API only — ABI stability between patches cannot be assumed unless explicitly mentioned in the release notes.
+
+#### Branches
+- `master` holds the bleeding edge code of the next, unreleased Zydis version. Elevated amounts of bugs and issues must be expected, API stability is not guaranteed outside of tagged commits.
+- `maintenance/v2` contains the code of the latest stable v2 release.
+
+## Credits
+- Intel (for open-sourcing [XED](https://github.com/intelxed/xed), allowing for automatic comparision of our tables against theirs, improving both)
+- [LLVM](https://llvm.org) (for providing pretty solid instruction data as well)
+- Christian Ludloff (http://sandpile.org, insanely helpful)
+- [LekoArts](https://www.lekoarts.de/) (for creating the project logo)
+- Our [contributors on GitHub](https://github.com/zyantific/zydis/graphs/contributors)
+
+## Troubleshooting
+
+#### `-fPIC` for shared library builds
+
+```
+/usr/bin/ld: ./libfoo.a(foo.c.o): relocation R_X86_64_PC32 against symbol `bar' can not be used when making a shared object; recompile with -fPIC
+```
+
+Under some circumstances (e.g. when building Zydis as a static library using
+CMake and then using Makefiles to manually link it into a shared library), CMake
+might fail to detect that relocation information must be emitted. This can be forced
+by passing `-DCMAKE_POSITION_INDEPENDENT_CODE=ON` to the CMake invocation.
+
+## License
+Zydis is licensed under the MIT license.
diff --git a/detours/detours/zydis/assets/ZydisExportConfigSample.h b/detours/detours/zydis/assets/ZydisExportConfigSample.h
new file mode 100644
index 0000000..8bc50d3
--- /dev/null
+++ b/detours/detours/zydis/assets/ZydisExportConfigSample.h
@@ -0,0 +1,41 @@
+
+#ifndef ZYDIS_EXPORT_H
+#define ZYDIS_EXPORT_H
+
+#ifdef ZYDIS_STATIC_DEFINE
+# define ZYDIS_EXPORT
+# define ZYDIS_NO_EXPORT
+#else
+# ifndef ZYDIS_EXPORT
+# ifdef Zydis_EXPORTS
+ /* We are building this library */
+# define ZYDIS_EXPORT
+# else
+ /* We are using this library */
+# define ZYDIS_EXPORT
+# endif
+# endif
+
+# ifndef ZYDIS_NO_EXPORT
+# define ZYDIS_NO_EXPORT
+# endif
+#endif
+
+#ifndef ZYDIS_DEPRECATED
+# define ZYDIS_DEPRECATED __attribute__ ((__deprecated__))
+#endif
+
+#ifndef ZYDIS_DEPRECATED_EXPORT
+# define ZYDIS_DEPRECATED_EXPORT ZYDIS_EXPORT ZYDIS_DEPRECATED
+#endif
+
+#ifndef ZYDIS_DEPRECATED_NO_EXPORT
+# define ZYDIS_DEPRECATED_NO_EXPORT ZYDIS_NO_EXPORT ZYDIS_DEPRECATED
+#endif
+
+#define DEFINE_NO_DEPRECATED 0
+#if DEFINE_NO_DEPRECATED
+# define ZYDIS_NO_DEPRECATED
+#endif
+
+#endif
diff --git a/detours/detours/zydis/assets/screenshots/ZydisInfo.png b/detours/detours/zydis/assets/screenshots/ZydisInfo.png
new file mode 100644
index 0000000..a24fd76
Binary files /dev/null and b/detours/detours/zydis/assets/screenshots/ZydisInfo.png differ
diff --git a/detours/detours/zydis/azure-pipelines.yml b/detours/detours/zydis/azure-pipelines.yml
new file mode 100644
index 0000000..042f4c5
--- /dev/null
+++ b/detours/detours/zydis/azure-pipelines.yml
@@ -0,0 +1,61 @@
+# C/C++ with GCC
+# Build your C/C++ project with GCC using make.
+# Add steps that publish test results, save build artifacts, deploy, and more:
+# https://docs.microsoft.com/azure/devops/pipelines/apps/c-cpp/gcc
+
+strategy:
+ matrix:
+ 'Linux':
+ imageName: 'ubuntu-16.04'
+ cmakeArgs: ''
+ runTests: 'true'
+ 'Linux (dev mode & release)':
+ imageName: 'ubuntu-16.04'
+ cmakeArgs: '-DZYAN_DEV_MODE=ON -DCMAKE_BUILD_TYPE=Release'
+ runTests: 'true'
+ # 'Linux (no libc)':
+ # imageName: 'ubuntu-16.04'
+ # cmakeArgs: '-DZYAN_NO_LIBC=ON'
+ # runTests: 'false'
+ 'Mac':
+ imageName: 'macos-10.13'
+ cmakeArgs: ''
+ runTests: 'true'
+ 'Mac (no libc)':
+ imageName: 'macos-10.13'
+ cmakeArgs: '-DZYAN_NO_LIBC=ON'
+ runTests: 'false'
+ 'Windows':
+ imageName: 'vs2017-win2016'
+ cmakeArgs: ''
+ runTests: 'true'
+ 'Windows (no libc)':
+ imageName: 'vs2017-win2016'
+ cmakeArgs: '-DZYAN_NO_LIBC=ON'
+ runTests: 'false'
+
+pool:
+ vmImage: $(imageName)
+
+steps:
+- bash: |
+ git submodule update --init
+ displayName: 'Cloning submodules'
+- bash: |
+ mkdir build
+ cd build
+ cmake $(cmakeArgs) ..
+ displayName: 'Configuring'
+- bash: |
+ cmake --build build --config Release
+ displayName: 'Building'
+- bash: |
+ cd build
+ ./ZydisInfo -64 cc
+ displayName: 'Disassembling INT3'
+ condition: and(eq(variables['runTests'], 'true'), ne(variables['Agent.OS'], 'Windows_NT'))
+- bash: |
+ cd build
+ Release\\ZydisInfo.exe -64 cc
+ displayName: 'Disassembling INT3'
+ condition: and(eq(variables['runTests'], 'true'), eq(variables['Agent.OS'], 'Windows_NT'))
diff --git a/detours/detours/zydis/dependencies/zycore/CMakeLists.txt b/detours/detours/zydis/dependencies/zycore/CMakeLists.txt
new file mode 100644
index 0000000..33532bf
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/CMakeLists.txt
@@ -0,0 +1,253 @@
+if (TARGET Zycore)
+ return()
+endif ()
+
+cmake_minimum_required(VERSION 3.1 FATAL_ERROR)
+include(GenerateExportHeader)
+include(GNUInstallDirs)
+
+project(Zycore VERSION 1.0.0.0 LANGUAGES C CXX)
+
+# =============================================================================================== #
+# Overridable options #
+# =============================================================================================== #
+
+# Global configuration
+option(ZYAN_WHOLE_PROGRAM_OPTIMIZATION
+ "Enable whole program optimization (all targets)"
+ OFF)
+option(ZYAN_NO_LIBC
+ "Don't use any C standard library functions (for exotic build-envs like kernel drivers)"
+ OFF)
+option(ZYAN_DEV_MODE
+ "Enable developer mode (-Wall, -Werror, ...)"
+ OFF)
+
+# Build configuration
+option(ZYCORE_BUILD_SHARED_LIB
+ "Build shared library"
+ OFF)
+option(ZYCORE_BUILD_EXAMPLES
+ "Build examples"
+ OFF)
+option(ZYCORE_BUILD_TESTS
+ "Build tests"
+ OFF)
+
+# =============================================================================================== #
+# GoogleTest #
+# =============================================================================================== #
+
+# Download and unpack googletest
+if (ZYCORE_BUILD_TESTS)
+ if (NOT DEFINED ZYCORE_DOWNLOADED_GTEST)
+ configure_file("CMakeLists.txt.in" "${CMAKE_BINARY_DIR}/gtest/download/CMakeLists.txt")
+ execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
+ RESULT_VARIABLE result
+ WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/gtest/download")
+ if (result)
+ message(FATAL_ERROR "CMake step for googletest failed: ${result}")
+ endif()
+ execute_process(COMMAND ${CMAKE_COMMAND} --build .
+ RESULT_VARIABLE result
+ WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/gtest/download")
+ if (result)
+ message(FATAL_ERROR "Build step for googletest failed: ${result}")
+ endif()
+
+ set(ZYCORE_DOWNLOADED_GTEST TRUE CACHE BOOL "")
+ mark_as_advanced(ZYCORE_DOWNLOADED_GTEST)
+ endif ()
+
+ set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+
+ add_subdirectory("${CMAKE_BINARY_DIR}/gtest/src" "${CMAKE_BINARY_DIR}/gtest/build"
+ EXCLUDE_FROM_ALL)
+endif ()
+
+# =============================================================================================== #
+# Exported functions #
+# =============================================================================================== #
+
+function (zyan_set_common_flags target)
+ if ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" OR
+ "${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" OR
+ "${CMAKE_C_COMPILER_ID}" STREQUAL "AppleClang")
+ target_compile_options("${target}" PRIVATE "-std=c99")
+ endif ()
+
+ if (ZYAN_DEV_MODE)
+ # If in developer mode, be pedantic.
+ if ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" OR
+ "${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" OR
+ "${CMAKE_C_COMPILER_ID}" STREQUAL "AppleClang")
+ target_compile_options("${target}" PUBLIC "-Wall" "-pedantic" "-Wextra" "-Werror")
+ elseif (MSVC)
+ target_compile_options("${target}" PUBLIC "/WX" "/W4")
+ endif ()
+ endif ()
+endfunction ()
+
+function (zyan_set_source_group target)
+ if (ZYAN_DEV_MODE)
+ if (((CMAKE_MAJOR_VERSION GREATER 3) OR (CMAKE_MAJOR_VERSION EQUAL 3)) AND
+ ((CMAKE_MINOR_VERSION GREATER 8) OR (CMAKE_MINOR_VERSION EQUAL 8)))
+ # Mirror directory structure in project files
+ get_property("TARGET_SOURCE_FILES" TARGET "${target}" PROPERTY SOURCES)
+ source_group(TREE "${CMAKE_CURRENT_LIST_DIR}" FILES ${TARGET_SOURCE_FILES})
+ endif ()
+ endif ()
+endfunction ()
+
+function (zyan_maybe_enable_wpo target)
+ if (ZYAN_WHOLE_PROGRAM_OPTIMIZATION AND MSVC)
+ set_target_properties("${target}" PROPERTIES COMPILE_FLAGS "/GL")
+ set_target_properties("${target}" PROPERTIES LINK_FLAGS_RELEASE "/LTCG")
+ endif ()
+endfunction ()
+
+function (zyan_maybe_enable_wpo_for_lib target)
+ if (ZYAN_WHOLE_PROGRAM_OPTIMIZATION AND MSVC)
+ set_target_properties("${target}" PROPERTIES COMPILE_FLAGS "/GL")
+ set_target_properties("${target}" PROPERTIES LINK_FLAGS_RELEASE "/LTCG")
+ set_target_properties("${target}" PROPERTIES STATIC_LIBRARY_FLAGS_RELEASE "/LTCG")
+ endif ()
+endfunction ()
+
+# =============================================================================================== #
+# Library configuration #
+# =============================================================================================== #
+
+if (ZYCORE_BUILD_SHARED_LIB)
+ add_library("Zycore" SHARED)
+else ()
+ add_library("Zycore" STATIC)
+endif ()
+
+set_target_properties("Zycore" PROPERTIES LINKER_LANGUAGE C)
+target_include_directories("Zycore"
+ PUBLIC "include" ${PROJECT_BINARY_DIR}
+ PRIVATE "src")
+target_compile_definitions("Zycore" PRIVATE "_CRT_SECURE_NO_WARNINGS" "ZYCORE_EXPORTS")
+zyan_set_common_flags("Zycore")
+zyan_maybe_enable_wpo_for_lib("Zycore")
+generate_export_header("Zycore" BASE_NAME "ZYCORE" EXPORT_FILE_NAME "ZycoreExportConfig.h")
+
+if (ZYAN_NO_LIBC)
+ target_compile_definitions("Zycore" PUBLIC "ZYAN_NO_LIBC")
+ if (UNIX)
+ target_link_options("Zycore" PUBLIC "-nostdlib" "-nodefaultlibs")
+ endif ()
+endif ()
+
+target_sources("Zycore"
+ PRIVATE
+ # API
+ "${CMAKE_CURRENT_LIST_DIR}/include/Zycore/API/Memory.h"
+ "${CMAKE_CURRENT_LIST_DIR}/include/Zycore/API/Synchronization.h"
+ "${CMAKE_CURRENT_LIST_DIR}/include/Zycore/API/Terminal.h"
+ "${CMAKE_CURRENT_LIST_DIR}/include/Zycore/API/Thread.h"
+ # Common
+ "${CMAKE_CURRENT_LIST_DIR}/include/Zycore/Allocator.h"
+ "${CMAKE_CURRENT_LIST_DIR}/include/Zycore/Bitset.h"
+ "${CMAKE_CURRENT_LIST_DIR}/include/Zycore/Comparison.h"
+ "${CMAKE_CURRENT_LIST_DIR}/include/Zycore/Defines.h"
+ "${CMAKE_CURRENT_LIST_DIR}/include/Zycore/Format.h"
+ "${CMAKE_CURRENT_LIST_DIR}/include/Zycore/LibC.h"
+ "${CMAKE_CURRENT_LIST_DIR}/include/Zycore/List.h"
+ "${CMAKE_CURRENT_LIST_DIR}/include/Zycore/Object.h"
+ "${CMAKE_CURRENT_LIST_DIR}/include/Zycore/Status.h"
+ "${CMAKE_CURRENT_LIST_DIR}/include/Zycore/String.h"
+ "${CMAKE_CURRENT_LIST_DIR}/include/Zycore/Types.h"
+ "${CMAKE_CURRENT_LIST_DIR}/include/Zycore/Vector.h"
+ "${CMAKE_CURRENT_LIST_DIR}/include/Zycore/Zycore.h"
+ # API
+ "src/API/Memory.c"
+ "src/API/Synchronization.c"
+ "src/API/Terminal.c"
+ "src/API/Thread.c"
+ # Common
+ "src/Allocator.c"
+ "src/Bitset.c"
+ "src/Format.c"
+ "src/List.c"
+ "src/String.c"
+ "src/Vector.c"
+ "src/Zycore.c")
+
+if (ZYCORE_BUILD_SHARED_LIB AND WIN32)
+ target_sources("Zycore" PRIVATE "resources/VersionInfo.rc")
+endif ()
+
+zyan_set_source_group("Zycore")
+
+if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux" AND NOT ZYAN_NO_LIBC)
+ target_compile_definitions("Zycore" PRIVATE "_GNU_SOURCE")
+ find_package(Threads REQUIRED)
+ target_link_libraries("Zycore" Threads::Threads)
+endif ()
+
+# TODO: Install CMake config.
+install(TARGETS "Zycore"
+ ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+ LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+ RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(FILES
+ "${PROJECT_BINARY_DIR}/ZycoreExportConfig.h"
+ DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
+install(DIRECTORY "include/" DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+
+# =============================================================================================== #
+# Developer mode #
+# =============================================================================================== #
+
+if (ZYAN_DEV_MODE)
+ set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+endif ()
+
+# =============================================================================================== #
+# Examples #
+# =============================================================================================== #
+
+if (ZYCORE_BUILD_EXAMPLES)
+ add_executable("String" "examples/String.c")
+ zyan_set_common_flags("String" "Zycore")
+ target_link_libraries("String" "Zycore")
+ set_target_properties("String" PROPERTIES FOLDER "Examples")
+ target_compile_definitions("String" PRIVATE "_CRT_SECURE_NO_WARNINGS")
+ zyan_maybe_enable_wpo("String")
+
+ add_executable("Vector" "examples/Vector.c")
+ zyan_set_common_flags("Vector" "Zycore")
+ target_link_libraries("Vector" "Zycore")
+ set_target_properties("Vector" PROPERTIES FOLDER "Examples")
+ target_compile_definitions("Vector" PRIVATE "_CRT_SECURE_NO_WARNINGS")
+ zyan_maybe_enable_wpo("Vector")
+endif ()
+
+# =============================================================================================== #
+# Tests #
+# =============================================================================================== #
+
+function (zyan_add_test test)
+ add_executable("Test${test}" "tests/${test}.cpp")
+
+ if ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" OR
+ "${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" OR
+ "${CMAKE_C_COMPILER_ID}" STREQUAL "AppleClang")
+ target_compile_options("Test${test}" PRIVATE "-std=c++14")
+ endif ()
+
+ target_link_libraries("Test${test}" "Zycore")
+ target_link_libraries("Test${test}" "gtest")
+ set_target_properties("Test${test}" PROPERTIES FOLDER "Tests")
+ target_compile_definitions("Test${test}" PRIVATE "_CRT_SECURE_NO_WARNINGS")
+ zyan_maybe_enable_wpo("Test${test}")
+endfunction ()
+
+if (ZYCORE_BUILD_TESTS)
+ zyan_add_test("String")
+ zyan_add_test("Vector")
+endif ()
+
+# =============================================================================================== #
diff --git a/detours/detours/zydis/dependencies/zycore/CMakeLists.txt.in b/detours/detours/zydis/dependencies/zycore/CMakeLists.txt.in
new file mode 100644
index 0000000..813eae2
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/CMakeLists.txt.in
@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 2.8.2)
+
+project(googletest-download NONE)
+
+include(ExternalProject)
+ExternalProject_Add(googletest
+ GIT_REPOSITORY https://github.com/google/googletest.git
+ GIT_TAG master
+ SOURCE_DIR "${CMAKE_BINARY_DIR}/gtest/src"
+ BINARY_DIR "${CMAKE_BINARY_DIR}/gtest/build"
+ CONFIGURE_COMMAND ""
+ BUILD_COMMAND ""
+ INSTALL_COMMAND ""
+ TEST_COMMAND ""
+)
diff --git a/detours/detours/zydis/dependencies/zycore/LICENSE b/detours/detours/zydis/dependencies/zycore/LICENSE
new file mode 100644
index 0000000..24a52f0
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/LICENSE
@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) 2018-2019 Florian Bernd
+Copyright (c) 2018-2019 Joel Höner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
diff --git a/detours/detours/zydis/dependencies/zycore/README.md b/detours/detours/zydis/dependencies/zycore/README.md
new file mode 100644
index 0000000..309a73b
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/README.md
@@ -0,0 +1,25 @@
+# Zyan Core Library for C
+
+Internal library providing platform independent types, macros and a fallback for environments without LibC.
+
+## Features
+
+- Platform independent types
+ - Integer types (`ZyanU8`, `ZyanI32`, `ZyanUSize`, ...)
+ - `ZyanBool` (+ `ZYAN_FALSE`, `ZYAN_TRUE`)
+ - `ZYAN_NULL`
+- Macros
+ - Compiler/Platform/Architecture detection
+ - Asserts and static asserts
+ - Utils (`ARRAY_LENGTH`, `FALLTHROUGH`, `UNUSED`, ...)
+- Common types
+ - `ZyanBitset`
+ - `ZyanString`/`ZyanStringView`
+- Container types
+ - `ZyanVector`
+ - `ZyanList`
+- LibC abstraction (WiP)
+
+## License
+
+Zycore is licensed under the MIT license.
diff --git a/detours/detours/zydis/dependencies/zycore/examples/String.c b/detours/detours/zydis/dependencies/zycore/examples/String.c
new file mode 100644
index 0000000..00c5b94
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/examples/String.c
@@ -0,0 +1,192 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+/**
+ * @file
+ * @brief Demonstrates the `String` implementation.
+ */
+
+#include
+#include
+#include
+#include
+#include
+#include
+
+/* ============================================================================================== */
+/* Enums and types */
+/* ============================================================================================== */
+
+
+/* ============================================================================================== */
+/* Helper functions */
+/* ============================================================================================== */
+
+/* ============================================================================================== */
+/* Tests */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Basic tests */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Performs some basic test on the given `ZyanString` instance.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus PerformBasicTests(ZyanString* string)
+{
+ ZYAN_ASSERT(string);
+ ZYAN_UNUSED(string);
+
+
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/**
+ * @brief Performs basic tests on a string that dynamically manages memory.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus TestDynamic(void)
+{
+ PerformBasicTests(ZYAN_NULL);
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/**
+ * @brief Performs basic tests on a string that uses a static buffer.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus TestStatic(void)
+{
+ PerformBasicTests(ZYAN_NULL);
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Custom allocator */
+/* ---------------------------------------------------------------------------------------------- */
+
+//static ZyanStatus AllocatorAllocate(ZyanAllocator* allocator, void** p, ZyanUSize element_size,
+// ZyanUSize n)
+//{
+// ZYAN_ASSERT(allocator);
+// ZYAN_ASSERT(p);
+// ZYAN_ASSERT(element_size);
+// ZYAN_ASSERT(n);
+//
+// ZYAN_UNUSED(allocator);
+//
+// *p = ZYAN_MALLOC(element_size * n);
+// if (!*p)
+// {
+// return ZYAN_STATUS_NOT_ENOUGH_MEMORY;
+// }
+//
+// return ZYAN_STATUS_SUCCESS;
+//}
+//
+//static ZyanStatus AllocatorReallocate(ZyanAllocator* allocator, void** p, ZyanUSize element_size,
+// ZyanUSize n)
+//{
+// ZYAN_ASSERT(allocator);
+// ZYAN_ASSERT(p);
+// ZYAN_ASSERT(element_size);
+// ZYAN_ASSERT(n);
+//
+// ZYAN_UNUSED(allocator);
+//
+// void* const x = ZYAN_REALLOC(*p, element_size * n);
+// if (!x)
+// {
+// return ZYAN_STATUS_NOT_ENOUGH_MEMORY;
+// }
+// *p = x;
+//
+// return ZYAN_STATUS_SUCCESS;
+//}
+//
+//static ZyanStatus AllocatorDeallocate(ZyanAllocator* allocator, void* p, ZyanUSize element_size,
+// ZyanUSize n)
+//{
+// ZYAN_ASSERT(allocator);
+// ZYAN_ASSERT(p);
+// ZYAN_ASSERT(element_size);
+// ZYAN_ASSERT(n);
+//
+// ZYAN_UNUSED(allocator);
+// ZYAN_UNUSED(element_size);
+// ZYAN_UNUSED(n);
+//
+// ZYAN_FREE(p);
+//
+// return ZYAN_STATUS_SUCCESS;
+//}
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Performs basic tests on a vector that dynamically manages memory using a custom
+ * allocator and modified growth-factor/shrink-threshold.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus TestAllocator(void)
+{
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+/* Entry point */
+/* ============================================================================================== */
+
+int main()
+{
+ if (!ZYAN_SUCCESS(TestDynamic()))
+ {
+ return EXIT_FAILURE;
+ }
+ if (!ZYAN_SUCCESS(TestStatic()))
+ {
+ return EXIT_FAILURE;
+ }
+ if (!ZYAN_SUCCESS(TestAllocator()))
+ {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+/* ============================================================================================== */
diff --git a/detours/detours/zydis/dependencies/zycore/examples/Vector.c b/detours/detours/zydis/dependencies/zycore/examples/Vector.c
new file mode 100644
index 0000000..88e544a
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/examples/Vector.c
@@ -0,0 +1,395 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+/**
+ * @file
+ * @brief Demonstrates the `ZyanVector` implementation.
+ */
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+/* ============================================================================================== */
+/* Enums and types */
+/* ============================================================================================== */
+
+/**
+ * @brief Defines the `TestStruct` struct that represents a single element in the vector.
+ */
+typedef struct TestStruct_
+{
+ ZyanU32 u32;
+ ZyanU64 u64;
+ float f;
+} TestStruct;
+
+/* ============================================================================================== */
+/* Helper functions */
+/* ============================================================================================== */
+
+/**
+ * @brief Initializes the given `TestStruct` struct.
+ *
+ * @param data A pointer to the `TestStruct` struct.
+ * @param n The number to initialize the struct with.
+ */
+static void InitTestdata(TestStruct* data, ZyanU32 n)
+{
+ ZYAN_ASSERT(data);
+
+ data->u32 = n;
+ data->u64 = n;
+ data->f = (float)n;
+}
+
+/* ============================================================================================== */
+/* Tests */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Basic tests */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Performs some basic test on the given `ZyanVector` instance.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus PerformBasicTests(ZyanVector* vector)
+{
+ ZYAN_ASSERT(vector);
+
+ static TestStruct e_v;
+ static const TestStruct* e_p;
+
+ // Insert `20` elements. The vector automatically manages its size
+ for (ZyanU32 i = 0; i < 20; ++i)
+ {
+ InitTestdata(&e_v, i);
+ ZYAN_CHECK(ZyanVectorPushBack(vector, &e_v));
+ }
+
+ // Remove elements `#05..#09`
+ ZYAN_CHECK(ZyanVectorDeleteRange(vector, 5, 5));
+
+ // Insert a new element at index `#05`
+ InitTestdata(&e_v, 12345678);
+ ZYAN_CHECK(ZyanVectorInsert(vector, 5, &e_v));
+
+ // Change value of element `#15`
+ InitTestdata(&e_v, 87654321);
+ ZYAN_CHECK(ZyanVectorSet(vector, 10, &e_v));
+
+ // Print `u64` of all vector elements
+ ZyanUSize value;
+ ZYAN_CHECK(ZyanVectorGetSize(vector, &value));
+ puts("ELEMENTS");
+ for (ZyanUSize i = 0; i < value; ++i)
+ {
+ ZYAN_CHECK(ZyanVectorGetPointer(vector, i, (const void**)&e_p));
+ printf(" Element #%02" PRIuPTR ": %08" PRIu64 "\n", i, e_p->u64);
+ }
+
+ // Print infos
+ puts("INFO");
+ printf(" Size : %08" PRIuPTR "\n", value);
+ ZYAN_CHECK(ZyanVectorGetCapacity(vector, &value));
+ printf(" Capacity : %08" PRIuPTR "\n\n", value);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/**
+ * @brief A dummy comparison function for the `TestStruct` that uses the `u32` field as key
+ * value.
+ *
+ * @param left A pointer to the first element.
+ * @param right A pointer to the second element.
+ *
+ * @return Returns values in the following range:
+ * `left == right -> result == 0`
+ * `left < right -> result < 0`
+ * `left > right -> result > 0`
+ */
+static ZyanI32 TestDataComparison(const TestStruct* left, const TestStruct* right)
+{
+ ZYAN_ASSERT(left);
+ ZYAN_ASSERT(right);
+
+ if (left->u32 < right->u32)
+ {
+ return -1;
+ }
+ if (left->u32 > right->u32)
+ {
+ return 1;
+ }
+ return 0;
+}
+
+/**
+ * @brief Tests the binary-search functionality of the given `ZyanVector` instance.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus PerformBinarySearchTest(ZyanVector* vector)
+{
+ ZYAN_ASSERT(vector);
+
+ static TestStruct e_v;
+ static const TestStruct* e_p;
+
+ ZyanUSize value;
+ ZYAN_CHECK(ZyanVectorGetCapacity(vector, &value));
+
+ // Create a sorted test vector
+ for (ZyanUSize i = 0; i < value; ++i)
+ {
+ const ZyanU32 n = rand() % 100;
+ InitTestdata(&e_v, n);
+
+ ZyanUSize found_index;
+ ZYAN_CHECK(ZyanVectorBinarySearch(vector, &e_v, &found_index,
+ (ZyanComparison)&TestDataComparison));
+ ZYAN_CHECK(ZyanVectorInsert(vector, found_index, &e_v));
+ }
+
+ // Print `u32` of all vector elements
+ ZYAN_CHECK(ZyanVectorGetSize(vector, &value));
+ puts("ELEMENTS");
+ for (ZyanUSize i = 0; i < value; ++i)
+ {
+ ZYAN_CHECK(ZyanVectorGetPointer(vector, i, (const void**)&e_p));
+ printf(" Element #%02" PRIuPTR ": %08" PRIu32 "\n", i, e_p->u32);
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/**
+ * @brief Performs basic tests on a vector that dynamically manages memory.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus TestDynamic(void)
+{
+ // Initialize vector with a base capacity of `10` elements
+ ZyanVector vector;
+ ZYAN_CHECK(ZyanVectorInit(&vector, sizeof(TestStruct), 10, ZYAN_NULL));
+
+ ZYAN_CHECK(PerformBasicTests(&vector));
+ ZYAN_CHECK(ZyanVectorClear(&vector));
+ ZYAN_CHECK(ZyanVectorReserve(&vector, 20));
+ ZYAN_CHECK(PerformBinarySearchTest(&vector));
+
+ // Cleanup
+ return ZyanVectorDestroy(&vector);
+}
+
+/**
+ * @brief Performs basic tests on a vector that uses a static buffer.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus TestStatic(void)
+{
+ static TestStruct buffer[20];
+
+ // Initialize vector to use a static buffer with a total capacity of `20` elements.
+ ZyanVector vector;
+ ZYAN_CHECK(ZyanVectorInitCustomBuffer(&vector, sizeof(TestStruct), buffer,
+ ZYAN_ARRAY_LENGTH(buffer), ZYAN_NULL));
+
+ // Compare elements
+ ZyanUSize size;
+ ZYAN_CHECK(ZyanVectorGetSize(&vector, &size));
+ for (ZyanUSize i = 0; i < size; ++i)
+ {
+ static TestStruct* element;
+ ZYAN_CHECK(ZyanVectorGetPointer(&vector, i, (const void**)&element));
+ if (element->u64 != buffer[i].u64)
+ {
+ return ZYAN_STATUS_INVALID_OPERATION;
+ }
+ }
+
+ ZYAN_CHECK(PerformBasicTests(&vector));
+ ZYAN_CHECK(ZyanVectorClear(&vector));
+ ZYAN_CHECK(PerformBinarySearchTest(&vector));
+
+ // Cleanup
+ return ZyanVectorDestroy(&vector);
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Custom allocator */
+/* ---------------------------------------------------------------------------------------------- */
+
+static ZyanStatus AllocatorAllocate(ZyanAllocator* allocator, void** p, ZyanUSize element_size,
+ ZyanUSize n)
+{
+ ZYAN_ASSERT(allocator);
+ ZYAN_ASSERT(p);
+ ZYAN_ASSERT(element_size);
+ ZYAN_ASSERT(n);
+
+ ZYAN_UNUSED(allocator);
+
+ *p = ZYAN_MALLOC(element_size * n);
+ if (!*p)
+ {
+ return ZYAN_STATUS_NOT_ENOUGH_MEMORY;
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+static ZyanStatus AllocatorReallocate(ZyanAllocator* allocator, void** p, ZyanUSize element_size,
+ ZyanUSize n)
+{
+ ZYAN_ASSERT(allocator);
+ ZYAN_ASSERT(p);
+ ZYAN_ASSERT(element_size);
+ ZYAN_ASSERT(n);
+
+ ZYAN_UNUSED(allocator);
+
+ void* const x = ZYAN_REALLOC(*p, element_size * n);
+ if (!x)
+ {
+ return ZYAN_STATUS_NOT_ENOUGH_MEMORY;
+ }
+ *p = x;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+static ZyanStatus AllocatorDeallocate(ZyanAllocator* allocator, void* p, ZyanUSize element_size,
+ ZyanUSize n)
+{
+ ZYAN_ASSERT(allocator);
+ ZYAN_ASSERT(p);
+ ZYAN_ASSERT(element_size);
+ ZYAN_ASSERT(n);
+
+ ZYAN_UNUSED(allocator);
+ ZYAN_UNUSED(element_size);
+ ZYAN_UNUSED(n);
+
+ ZYAN_FREE(p);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Performs basic tests on a vector that dynamically manages memory using a custom
+ * allocator and modified growth-factor/shrink-threshold.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus TestAllocator(void)
+{
+ ZyanAllocator allocator;
+ ZYAN_CHECK(ZyanAllocatorInit(&allocator, &AllocatorAllocate, &AllocatorReallocate,
+ &AllocatorDeallocate));
+
+ // Initialize vector with a base capacity of `10` elements. Growth-factor is set to 10 and
+ // dynamic shrinking is disabled
+ ZyanVector vector;
+ ZYAN_CHECK(ZyanVectorInitEx(&vector, sizeof(TestStruct), 5, ZYAN_NULL, &allocator,
+ 10.0f, 0.0f));
+
+ static TestStruct e_v;
+
+ // Insert `10` elements. The vector automatically manages its size
+ for (ZyanU32 i = 0; i < 10; ++i)
+ {
+ InitTestdata(&e_v, i);
+ ZYAN_CHECK(ZyanVectorPushBack(&vector, &e_v));
+ }
+
+ // Check capacity
+ ZyanUSize value;
+ ZYAN_CHECK(ZyanVectorGetCapacity(&vector, &value));
+ if (value != 60) // (5 + 1) * 10.0f
+ {
+ return ZYAN_STATUS_INVALID_OPERATION;
+ }
+
+ // Remove all elements
+ ZYAN_CHECK(ZyanVectorClear(&vector));
+
+ // Print infos
+ puts("INFO");
+ ZYAN_CHECK(ZyanVectorGetSize(&vector, &value));
+ printf(" Size : %08" PRIuPTR "\n", value);
+ ZYAN_CHECK(ZyanVectorGetCapacity(&vector, &value));
+ printf(" Capacity : %08" PRIuPTR "\n\n", value);
+
+ // Cleanup
+ return ZyanVectorDestroy(&vector);
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+/* Entry point */
+/* ============================================================================================== */
+
+int main()
+{
+ time_t t;
+ srand((unsigned)time(&t));
+
+ if (!ZYAN_SUCCESS(TestDynamic()))
+ {
+ return EXIT_FAILURE;
+ }
+ if (!ZYAN_SUCCESS(TestStatic()))
+ {
+ return EXIT_FAILURE;
+ }
+ if (!ZYAN_SUCCESS(TestAllocator()))
+ {
+ return EXIT_FAILURE;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+/* ============================================================================================== */
diff --git a/detours/detours/zydis/dependencies/zycore/include/Zycore/API/Memory.h b/detours/detours/zydis/dependencies/zycore/include/Zycore/API/Memory.h
new file mode 100644
index 0000000..79d1578
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/include/Zycore/API/Memory.h
@@ -0,0 +1,74 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+/**
+ * @file
+ * @brief
+ */
+
+#ifndef ZYCORE_MEMORY_H
+#define ZYCORE_MEMORY_H
+
+#include
+#include
+#include
+
+/* ============================================================================================== */
+/* Enums and types */
+/* ============================================================================================== */
+
+/**
+ * @brief Defines the `ZyanMemoryManager` struct.
+ */
+typedef struct ZyanMemoryManager_
+{
+ int a;
+} ZyanMemoryManager;
+
+/* ============================================================================================== */
+/* Exported functions */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Memory manager */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Returns the default memory manager.
+
+ * @return The default memory manager.
+ */
+ZYCORE_EXPORT const ZyanMemoryManager* ZyanMemoryManagerDefault(void);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* */
+/* ---------------------------------------------------------------------------------------------- */
+
+
+
+/* ============================================================================================== */
+
+#endif /* ZYCORE_MEMORY_H */
diff --git a/detours/detours/zydis/dependencies/zycore/include/Zycore/API/Synchronization.h b/detours/detours/zydis/dependencies/zycore/include/Zycore/API/Synchronization.h
new file mode 100644
index 0000000..09a72e0
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/include/Zycore/API/Synchronization.h
@@ -0,0 +1,133 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+/**
+ * @file
+ * @brief
+ */
+
+#ifndef ZYCORE_SYNCHRONIZATION_H
+#define ZYCORE_SYNCHRONIZATION_H
+
+#ifndef ZYAN_NO_LIBC
+
+#include
+#include
+#include
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ============================================================================================== */
+/* Enums and types */
+/* ============================================================================================== */
+
+#if defined(ZYAN_POSIX)
+
+#include
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Critical Section */
+/* ---------------------------------------------------------------------------------------------- */
+
+typedef pthread_mutex_t ZyanCriticalSection;
+
+/* ---------------------------------------------------------------------------------------------- */
+
+#elif defined(ZYAN_WINDOWS)
+
+#include
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Critical Section */
+/* ---------------------------------------------------------------------------------------------- */
+
+typedef CRITICAL_SECTION ZyanCriticalSection;
+
+/* ---------------------------------------------------------------------------------------------- */
+
+#else
+# error "Unsupported platform detected"
+#endif
+
+/* ============================================================================================== */
+/* Exported functions */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Critical Section */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Initializes a critical section.
+ *
+ * @param critical_section A pointer to the `ZyanCriticalSection` struct.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanCriticalSectionInitialize(ZyanCriticalSection* critical_section);
+
+/**
+ * @brief Enters a critical section.
+ *
+ * @param critical_section A pointer to the `ZyanCriticalSection` struct.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanCriticalSectionEnter(ZyanCriticalSection* critical_section);
+
+/**
+ * @brief Tries to enter a critical section.
+ *
+ * @param critical_section A pointer to the `ZyanCriticalSection` struct.
+ *
+ * @return Returns `ZYAN_TRUE` if the critical section was successfully entered or `ZYAN_FALSE`,
+ * if not.
+ */
+ZYCORE_EXPORT ZyanBool ZyanCriticalSectionTryEnter(ZyanCriticalSection* critical_section);
+
+/**
+ * @brief Leaves a critical section.
+ *
+ * @param critical_section A pointer to the `ZyanCriticalSection` struct.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanCriticalSectionLeave(ZyanCriticalSection* critical_section);
+
+/**
+ * @brief Deletes a critical section.
+ *
+ * @param critical_section A pointer to the `ZyanCriticalSection` struct.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanCriticalSectionDelete(ZyanCriticalSection* critical_section);
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZYAN_NO_LIBC */
+
+#endif /* ZYCORE_SYNCHRONIZATION_H */
diff --git a/detours/detours/zydis/dependencies/zycore/include/Zycore/API/Terminal.h b/detours/detours/zydis/dependencies/zycore/include/Zycore/API/Terminal.h
new file mode 100644
index 0000000..17bed5e
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/include/Zycore/API/Terminal.h
@@ -0,0 +1,163 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+/**
+ * @file Provides cross-platform terminal helper functions.
+ * @brief
+ */
+
+#ifndef ZYCORE_TERMINAL_H
+#define ZYCORE_TERMINAL_H
+
+#include
+#include
+#include
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef ZYAN_NO_LIBC
+
+/* ============================================================================================== */
+/* VT100 CSI SGR sequences */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* General */
+/* ---------------------------------------------------------------------------------------------- */
+
+#define ZYAN_VT100SGR_RESET "\033[0m"
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Foreground colors */
+/* ---------------------------------------------------------------------------------------------- */
+
+#define ZYAN_VT100SGR_FG_DEFAULT "\033[39m"
+
+#define ZYAN_VT100SGR_FG_BLACK "\033[30m"
+#define ZYAN_VT100SGR_FG_RED "\033[31m"
+#define ZYAN_VT100SGR_FG_GREEN "\033[32m"
+#define ZYAN_VT100SGR_FG_YELLOW "\033[33m"
+#define ZYAN_VT100SGR_FG_BLUE "\033[34m"
+#define ZYAN_VT100SGR_FG_MAGENTA "\033[35m"
+#define ZYAN_VT100SGR_FG_CYAN "\033[36m"
+#define ZYAN_VT100SGR_FG_WHITE "\033[37m"
+#define ZYAN_VT100SGR_FG_BRIGHT_BLACK "\033[90m"
+#define ZYAN_VT100SGR_FG_BRIGHT_RED "\033[91m"
+#define ZYAN_VT100SGR_FG_BRIGHT_GREEN "\033[92m"
+#define ZYAN_VT100SGR_FG_BRIGHT_YELLOW "\033[93m"
+#define ZYAN_VT100SGR_FG_BRIGHT_BLUE "\033[94m"
+#define ZYAN_VT100SGR_FG_BRIGHT_MAGENTA "\033[95m"
+#define ZYAN_VT100SGR_FG_BRIGHT_CYAN "\033[96m"
+#define ZYAN_VT100SGR_FG_BRIGHT_WHITE "\033[97m"
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Background color */
+/* ---------------------------------------------------------------------------------------------- */
+
+#define ZYAN_VT100SGR_BG_DEFAULT "\033[49m"
+
+#define ZYAN_VT100SGR_BG_BLACK "\033[40m"
+#define ZYAN_VT100SGR_BG_RED "\033[41m"
+#define ZYAN_VT100SGR_BG_GREEN "\033[42m"
+#define ZYAN_VT100SGR_BG_YELLOW "\033[43m"
+#define ZYAN_VT100SGR_BG_BLUE "\033[44m"
+#define ZYAN_VT100SGR_BG_MAGENTA "\033[45m"
+#define ZYAN_VT100SGR_BG_CYAN "\033[46m"
+#define ZYAN_VT100SGR_BG_WHITE "\033[47m"
+#define ZYAN_VT100SGR_BG_BRIGHT_BLACK "\033[100m"
+#define ZYAN_VT100SGR_BG_BRIGHT_RED "\033[101m"
+#define ZYAN_VT100SGR_BG_BRIGHT_GREEN "\033[102m"
+#define ZYAN_VT100SGR_BG_BRIGHT_YELLOW "\033[103m"
+#define ZYAN_VT100SGR_BG_BRIGHT_BLUE "\033[104m"
+#define ZYAN_VT100SGR_BG_BRIGHT_MAGENTA "\033[105m"
+#define ZYAN_VT100SGR_BG_BRIGHT_CYAN "\033[106m"
+#define ZYAN_VT100SGR_BG_BRIGHT_WHITE "\033[107m"
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+/* Enums and types */
+/* ============================================================================================== */
+
+/**
+ * @brief Declares the `ZyanStandardStream` enum.
+ */
+typedef enum ZyanStandardStream_
+{
+ /**
+ * @brief The default input stream.
+ */
+ ZYAN_STDSTREAM_IN,
+ /**
+ * @brief The default output stream.
+ */
+ ZYAN_STDSTREAM_OUT,
+ /**
+ * @brief The default error stream.
+ */
+ ZYAN_STDSTREAM_ERR
+} ZyanStandardStream;
+
+/* ============================================================================================== */
+/* Exported functions */
+/* ============================================================================================== */
+
+/**
+ * @brief Enables VT100 ansi escape codes for the given stream.
+ *
+ * @param stream Either `ZYAN_STDSTREAM_OUT` or `ZYAN_STDSTREAM_ERR`.
+ *
+ * @return A zyan status code.
+ *
+ * This functions returns `ZYAN_STATUS_SUCCESS` on all non-Windows systems without performing any
+ * operations, assuming that VT100 is supported by default.
+ *
+ * On Windows systems, VT100 functionality is only supported on Windows 10 build 1607 (anniversary
+ * update) and later.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanTerminalEnableVT100(ZyanStandardStream stream);
+
+/**
+ * @brief Checks, if the given standard stream reads from or writes to a terminal.
+ *
+ * @param stream The standard stream to check.
+ *
+ * @return `ZYAN_STATUS_TRUE`, if the stream is bound to a terminal, `ZYAN_STATUS_FALSE` if not,
+ * or another zyan status code if an error occured.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanTerminalIsTTY(ZyanStandardStream stream);
+
+/* ============================================================================================== */
+
+#endif // ZYAN_NO_LIBC
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZYCORE_TERMINAL_H */
diff --git a/detours/detours/zydis/dependencies/zycore/include/Zycore/API/Thread.h b/detours/detours/zydis/dependencies/zycore/include/Zycore/API/Thread.h
new file mode 100644
index 0000000..be2eaa9
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/include/Zycore/API/Thread.h
@@ -0,0 +1,244 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+/**
+ * @file
+ * @brief
+ */
+
+#ifndef ZYCORE_THREAD_H
+#define ZYCORE_THREAD_H
+
+#ifndef ZYAN_NO_LIBC
+
+#include
+#include
+#include
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ============================================================================================== */
+/* Enums and types */
+/* ============================================================================================== */
+
+#if defined(ZYAN_POSIX)
+
+#include
+
+/* ---------------------------------------------------------------------------------------------- */
+/* General */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Defines the `ZyanThread` datatype.
+ */
+typedef pthread_t ZyanThread;
+
+/**
+ * @brief Defines the `ZyanThreadId` datatype.
+ */
+typedef ZyanU64 ZyanThreadId;
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Thread Local Storage (TLS) */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Defines the `ZyanThreadTlsIndex` datatype.
+ */
+typedef pthread_key_t ZyanThreadTlsIndex;
+
+/**
+ * @brief Defines the `ZyanThreadTlsCallback` function prototype.
+ */
+typedef void(*ZyanThreadTlsCallback)(void* data);
+
+/**
+ * @brief Declares a Thread Local Storage (TLS) callback function.
+ *
+ * @param name The callback function name.
+ * @param param_type The callback data parameter type.
+ * @param param_name The callback data parameter name.
+ */
+#define ZYAN_THREAD_DECLARE_TLS_CALLBACK(name, param_type, param_name) \
+ void name(param_type* param_name)
+
+/* ---------------------------------------------------------------------------------------------- */
+
+#elif defined(ZYAN_WINDOWS)
+
+#include
+
+/* ---------------------------------------------------------------------------------------------- */
+/* General */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Defines the `ZyanThread` datatype.
+ */
+typedef HANDLE ZyanThread;
+
+/**
+ * @brief Defines the `ZyanThreadId` datatype.
+ */
+typedef DWORD ZyanThreadId;
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Thread Local Storage (TLS) */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Defines the `ZyanThreadTlsIndex` datatype.
+ */
+typedef DWORD ZyanThreadTlsIndex;
+
+/**
+ * @brief Defines the `ZyanThreadTlsCallback` function prototype.
+ */
+typedef PFLS_CALLBACK_FUNCTION ZyanThreadTlsCallback;
+
+/**
+ * @brief Declares a Thread Local Storage (TLS) callback function.
+ *
+ * @param name The callback function name.
+ * @param param_type The callback data parameter type.
+ * @param param_name The callback data parameter name.
+ */
+#define ZYAN_THREAD_DECLARE_TLS_CALLBACK(name, param_type, param_name) \
+ VOID NTAPI name(param_type* param_name)
+
+/* ---------------------------------------------------------------------------------------------- */
+
+#else
+# error "Unsupported platform detected"
+#endif
+
+/* ============================================================================================== */
+/* Exported functions */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* General */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Returns the handle of the current thread.
+ *
+ * @param thread Receives the handle of the current thread.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanThreadGetCurrentThread(ZyanThread* thread);
+
+/**
+ * @brief Returns the unique id of the current thread.
+ *
+ * @param thread_id Receives the unique id of the current thread.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanThreadGetCurrentThreadId(ZyanThreadId* thread_id);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Thread Local Storage (TLS) */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Allocates a new Thread Local Storage (TLS) slot.
+ *
+ * @param index Receives the TLS slot index.
+ * @param destructor A pointer to a destructor callback which is invoked to finalize the data
+ * in the TLS slot or `ZYAN_NULL`, if not needed.
+ *
+ * The maximum available number of TLS slots is implementation specific and different on each
+ * platform:
+ * - Windows
+ * - A total amount of 128 slots per process is guaranteed
+ * - POSIX
+ * - A total amount of 128 slots per process is guaranteed
+ * - Some systems guarantee larger amounts like e.g. 1024 slots per process
+ *
+ * Note that the invokation rules for the destructor callback are implementation specific and
+ * different on each platform:
+ * - Windows
+ * - The callback is invoked when a thread exits
+ * - The callback is invoked when the process exits
+ * - The callback is invoked when the TLS slot is released
+ * - POSIX
+ * - The callback is invoked when a thread exits and the stored value is not null
+ * - The callback is NOT invoked when the process exits
+ * - The callback is NOT invoked when the TLS slot is released
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanThreadTlsAlloc(ZyanThreadTlsIndex* index,
+ ZyanThreadTlsCallback destructor);
+
+/**
+ * @brief Releases a Thread Local Storage (TLS) slot.
+ *
+ * @param index The TLS slot index.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanThreadTlsFree(ZyanThreadTlsIndex index);
+
+/**
+ * @brief Returns the value inside the given Thread Local Storage (TLS) slot for the calling
+ * thread.
+ *
+ * @param index The TLS slot index.
+ * @param data Receives the value inside the given Thread Local Storage (TLS) slot for the
+ * calling thread.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanThreadTlsGetValue(ZyanThreadTlsIndex index, void** data);
+
+/**
+ * @brief Set the value of the given Thread Local Storage (TLS) slot for the calling thread.
+ *
+ * @param index The TLS slot index.
+ * @param data The value to store inside the given Thread Local Storage (TLS) slot for the
+ * calling thread
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanThreadTlsSetValue(ZyanThreadTlsIndex index, void* data);
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZYAN_NO_LIBC */
+
+#endif /* ZYCORE_THREAD_H */
diff --git a/detours/detours/zydis/dependencies/zycore/include/Zycore/Allocator.h b/detours/detours/zydis/dependencies/zycore/include/Zycore/Allocator.h
new file mode 100644
index 0000000..c643d06
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/include/Zycore/Allocator.h
@@ -0,0 +1,143 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+/**
+ * @file
+ * @brief
+ */
+
+#ifndef ZYCORE_ALLOCATOR_H
+#define ZYCORE_ALLOCATOR_H
+
+#include
+#include
+#include
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ============================================================================================== */
+/* Enums and types */
+/* ============================================================================================== */
+
+struct ZyanAllocator_;
+
+/**
+ * @brief Defines the `ZyanAllocatorAllocate` function prototype.
+ *
+ * @param allocator A pointer to the `ZyanAllocator` instance.
+ * @param p Receives a pointer to the first memory block sufficient to hold an
+ * array of `n` elements with a size of `element_size`.
+ * @param element_size The size of a single element.
+ * @param n The number of elements to allocate storage for.
+ *
+ * @return A zyan status code.
+ *
+ * This prototype is used for the `allocate()` and `reallocate()` functions.
+ *
+ * The result of the `reallocate()` function is undefined, if `p` does not point to a memory block
+ * previously obtained by `(re-)allocate()`.
+ */
+typedef ZyanStatus (*ZyanAllocatorAllocate)(struct ZyanAllocator_* allocator, void** p,
+ ZyanUSize element_size, ZyanUSize n);
+
+/**
+ * @brief Defines the `ZyanAllocatorDeallocate` function prototype.
+ *
+ * @param allocator A pointer to the `ZyanAllocator` instance.
+ * @param p The pointer obtained from `(re-)allocate()`.
+ * @param element_size The size of a single element.
+ * @param n The number of elements earlier passed to `(re-)allocate()`.
+ *
+ * @return A zyan status code.
+ */
+typedef ZyanStatus (*ZyanAllocatorDeallocate)(struct ZyanAllocator_* allocator, void* p,
+ ZyanUSize element_size, ZyanUSize n);
+
+/**
+ * @brief Defines the `ZyanAllocator` struct.
+ *
+ * This is the base class for all custom allocator implementations.
+ *
+ * All fields in this struct should be considered as "private". Any changes may lead to unexpected
+ * behavior.
+ */
+typedef struct ZyanAllocator_
+{
+ /**
+ * @brief The allocate function.
+ */
+ ZyanAllocatorAllocate allocate;
+ /**
+ * @brief The reallocate function.
+ */
+ ZyanAllocatorAllocate reallocate;
+ /**
+ * @brief The deallocate function.
+ */
+ ZyanAllocatorDeallocate deallocate;
+} ZyanAllocator;
+
+/* ============================================================================================== */
+/* Exported functions */
+/* ============================================================================================== */
+
+/**
+ * @brief Initializes the given `ZyanAllocator` instance.
+ *
+ * @param allocator A pointer to the `ZyanAllocator` instance.
+ * @param allocate The allocate function.
+ * @param reallocate The reallocate function.
+ * @param deallocate The deallocate function.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanAllocatorInit(ZyanAllocator* allocator, ZyanAllocatorAllocate allocate,
+ ZyanAllocatorAllocate reallocate, ZyanAllocatorDeallocate deallocate);
+
+#ifndef ZYAN_NO_LIBC
+
+/**
+ * @brief Returns the default `ZyanAllocator` instance.
+ *
+ * @return A pointer to the default `ZyanAllocator` instance.
+ *
+ * The default allocator uses the default memory manager to allocate memory on the heap.
+ *
+ * You should in no case modify the returned allocator instance to avoid unexpected behavior.
+ */
+ZYCORE_EXPORT ZYAN_REQUIRES_LIBC ZyanAllocator* ZyanAllocatorDefault(void);
+
+#endif // ZYAN_NO_LIBC
+
+/* ============================================================================================== */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZYCORE_ALLOCATOR_H */
diff --git a/detours/detours/zydis/dependencies/zycore/include/Zycore/Bitset.h b/detours/detours/zydis/dependencies/zycore/include/Zycore/Bitset.h
new file mode 100644
index 0000000..25372b4
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/include/Zycore/Bitset.h
@@ -0,0 +1,484 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+/**
+ * @file
+ * @brief Implements the bitset class.
+ */
+
+#ifndef ZYCORE_BITSET_H
+#define ZYCORE_BITSET_H
+
+#include
+#include
+#include
+#include
+#include
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ============================================================================================== */
+/* Enums and types */
+/* ============================================================================================== */
+
+/**
+ * @brief Defines the `ZyanVector` struct.
+ *
+ * All fields in this struct should be considered as "private". Any changes may lead to unexpected
+ * behavior.
+ */
+typedef struct ZyanBitset_
+{
+ /**
+ * @brief The bitset size.
+ */
+ ZyanUSize size;
+ /**
+ * @brief The bitset data.
+ */
+ ZyanVector bits;
+} ZyanBitset;
+
+/**
+ * @brief Defines the `ZyanBitsetByteOperation` function prototype.
+ *
+ * @param v1 A pointer to the first byte. This value receives the result after performing the
+ * desired operation.
+ * @param v2 A pointer to the second byte.
+ *
+ * @return A zyan status code.
+ *
+ * This function is used to perform byte-wise operations on two `ZyanBitset` instances.
+ */
+typedef ZyanStatus (*ZyanBitsetByteOperation)(ZyanU8* v1, const ZyanU8* v2);
+
+/* ============================================================================================== */
+/* Exported functions */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Constructor and destructor */
+/* ---------------------------------------------------------------------------------------------- */
+
+#ifndef ZYAN_NO_LIBC
+
+/**
+ * @brief Initializes the given `ZyanBitset` instance.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ * @param count The initial amount of bits.
+ *
+ * @return A zyan status code.
+ *
+ * The space for the bitset is dynamically allocated by the default allocator using the default
+ * growth factor of `2.0f` and the default shrink threshold of `0.5f`.
+ */
+ZYCORE_EXPORT ZYAN_REQUIRES_LIBC ZyanStatus ZyanBitsetInit(ZyanBitset* bitset, ZyanUSize count);
+
+#endif // ZYAN_NO_LIBC
+
+/**
+ * @brief Initializes the given `ZyanBitset` instance and sets a custom `allocator` and memory
+ * allocation/deallocation parameters.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ * @param count The initial amount of bits.
+ * @param allocator A pointer to a `ZyanAllocator` instance.
+ * @param growth_factor The growth factor (from `1.0f` to `x.xf`).
+ * @param shrink_threshold The shrink threshold (from `0.0f` to `1.0f`).
+ *
+ * @return A zyan status code.
+ *
+ * A growth factor of `1.0f` disables overallocation and a shrink threshold of `0.0f` disables
+ * dynamic shrinking.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetInitEx(ZyanBitset* bitset, ZyanUSize count,
+ ZyanAllocator* allocator, float growth_factor, float shrink_threshold);
+
+/**
+ * @brief Initializes the given `ZyanBitset` instance and configures it to use a custom user
+ * defined buffer with a fixed size.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ * @param count The initial amount of bits.
+ * @param buffer A pointer to the buffer that is used as storage for the bits.
+ * @param capacity The maximum capacity (number of bytes) of the buffer.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetInitBuffer(ZyanBitset* bitset, ZyanUSize count, void* buffer,
+ ZyanUSize capacity);
+
+/**
+ * @brief Destroys the given `ZyanBitset` instance.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetDestroy(ZyanBitset* bitset);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Logical operations */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Performs a byte-wise `operation` for every byte in the given `ZyanBitset` instances.
+ *
+ * @param destination A pointer to the `ZyanBitset` instance that is used as the first input and
+ * as the destination.
+ * @param source A pointer to the `ZyanBitset` instance that is used as the second input.
+ * @param operation A pointer to the function that performs the desired operation.
+ *
+ * @return A zyan status code.
+ *
+ * The `operation` callback is invoked once for every byte in the smallest of the `ZyanBitset`
+ * instances.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetPerformByteOperation(ZyanBitset* destination,
+ const ZyanBitset* source, ZyanBitsetByteOperation operation);
+
+/**
+ * @brief Performs a logical `AND` operation on the given `ZyanBitset` instances.
+ *
+ * @param destination A pointer to the `ZyanBitset` instance that is used as the first input and
+ * as the destination.
+ * @param source A pointer to the `ZyanBitset` instance that is used as the second input.
+ *
+ * @return A zyan status code.
+ *
+ * If the destination bitmask contains more bits than the source one, the state of the remaining
+ * bits will be undefined.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetAND(ZyanBitset* destination, const ZyanBitset* source);
+
+/**
+ * @brief Performs a logical `OR` operation on the given `ZyanBitset` instances.
+ *
+ * @param destination A pointer to the `ZyanBitset` instance that is used as the first input and
+ * as the destination.
+ * @param source A pointer to the `ZyanBitset` instance that is used as the second input.
+ *
+ * @return A zyan status code.
+ *
+ * If the destination bitmask contains more bits than the source one, the state of the remaining
+ * bits will be undefined.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetOR (ZyanBitset* destination, const ZyanBitset* source);
+
+/**
+ * @brief Performs a logical `XOR` operation on the given `ZyanBitset` instances.
+ *
+ * @param destination A pointer to the `ZyanBitset` instance that is used as the first input and
+ * as the destination.
+ * @param source A pointer to the `ZyanBitset` instance that is used as the second input.
+ *
+ * @return A zyan status code.
+ *
+ * If the destination bitmask contains more bits than the source one, the state of the remaining
+ * bits will be undefined.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetXOR(ZyanBitset* destination, const ZyanBitset* source);
+
+/**
+ * @brief Flips all bits of the given `ZyanBitset` instance.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetFlip(ZyanBitset* bitset);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Bit access */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Sets the bit at `index` of the given `ZyanBitset` instance to `1`.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ * @param index The bit index.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetSet(ZyanBitset* bitset, ZyanUSize index);
+
+/**
+ * @brief Sets the bit at `index` of the given `ZyanBitset` instance to `0`.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ * @param index The bit index.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetReset(ZyanBitset* bitset, ZyanUSize index);
+
+/**
+ * @brief Sets the bit at `index` of the given `ZyanBitset` instance to the specified `value`.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ * @param index The bit index.
+ * @param value The new value.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetAssign(ZyanBitset* bitset, ZyanUSize index, ZyanBool value);
+
+/**
+ * @brief Toggles the bit at `index` of the given `ZyanBitset` instance.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ * @param index The bit index.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetToggle(ZyanBitset* bitset, ZyanUSize index);
+
+/**
+ * @brief Returns the value of the bit at `index`.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ * @param index The bit index.
+ *
+ * @return `ZYAN_STATUS_TRUE`, if the bit is set or `ZYAN_STATUS_FALSE`, if not, Another zyan
+ * status code, if an error occured.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetTest(ZyanBitset* bitset, ZyanUSize index);
+
+/**
+ * @brief Returns the value of the most significant bit.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ *
+ * @return `ZYAN_STATUS_TRUE`, if the bit is set or `ZYAN_STATUS_FALSE`, if not. Another zyan
+ * status code, if an error occured.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetTestMSB(ZyanBitset* bitset);
+
+/**
+ * @brief Returns the value of the least significant bit.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ *
+ * @return `ZYAN_STATUS_TRUE`, if the bit is set or `ZYAN_STATUS_FALSE`, if not. Another zyan
+ * status code, if an error occured.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetTestLSB(ZyanBitset* bitset);
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Sets all bits of the given `ZyanBitset` instance to `1`.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetSetAll(ZyanBitset* bitset);
+
+/**
+ * @brief Sets all bits of the given `ZyanBitset` instance to `0`.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetResetAll(ZyanBitset* bitset);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Size management */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Adds a new bit at the end of the bitset.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ * @param value The value of the new bit.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetPush(ZyanBitset* bitset, ZyanBool value);
+
+/**
+ * @brief Removes the last bit of the bitset.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetPop(ZyanBitset* bitset);
+
+/**
+ * @brief Deletes all bits of the given `ZyanBitset` instance.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetClear(ZyanBitset* bitset);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Memory management */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Changes the capacity of the given `ZyanBitset` instance.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ * @param count The new capacity (number of bits).
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetReserve(ZyanBitset* bitset, ZyanUSize count);
+
+/**
+ * @brief Shrinks the capacity of the given bitset to match it's size.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetShrinkToFit(ZyanBitset* bitset);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Information */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Returns the current size of the bitset in bits.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ * @param size Receives the size of the bitset in bits.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetGetSize(const ZyanBitset* bitset, ZyanUSize* size);
+
+/**
+ * @brief Returns the current capacity of the bitset in bits.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ * @param capacity Receives the size of the bitset in bits.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetGetCapacity(const ZyanBitset* bitset, ZyanUSize* capacity);
+
+/**
+ * @brief Returns the current size of the bitset in bytes.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ * @param size Receives the size of the bitset in bytes.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetGetSizeBytes(const ZyanBitset* bitset, ZyanUSize* size);
+
+/**
+ * @brief Returns the current capacity of the bitset in bytes.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ * @param capacity Receives the size of the bitset in bytes.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetGetCapacityBytes(const ZyanBitset* bitset, ZyanUSize* capacity);
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Returns the amount of bits set in the given bitset.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ * @param count Receives the amount of bits set in the given bitset.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetCount(const ZyanBitset* bitset, ZyanUSize* count);
+
+/**
+ * @brief Checks, if all bits of the given bitset are set.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ *
+ * @return `ZYAN_STATUS_TRUE`, if all bits are set, `ZYAN_STATUS_FALSE`, if not. Another zyan
+ * status code, if an error occured.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetAll(const ZyanBitset* bitset);
+
+/**
+ * @brief Checks, if at least one bit of the given bitset is set.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ *
+ * @return `ZYAN_STATUS_TRUE`, if at least one bit is set, `ZYAN_STATUS_FALSE`, if not. Another
+ * zyan status code, if an error occured.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetAny(const ZyanBitset* bitset);
+
+/**
+ * @brief Checks, if none bits of the given bitset are set.
+ *
+ * @param bitset A pointer to the `ZyanBitset` instance.
+ *
+ * @return `ZYAN_STATUS_TRUE`, if none bits are set, `ZYAN_STATUS_FALSE`, if not. Another zyan
+ * status code, if an error occured.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanBitsetNone(const ZyanBitset* bitset);
+
+///* ---------------------------------------------------------------------------------------------- */
+//
+///**
+// * @brief Returns a 32-bit unsigned integer representation of the data.
+// *
+// * @param bitset A pointer to the `ZyanBitset` instance.
+// * @param value Receives the 32-bit unsigned integer representation of the data.
+// *
+// * @return A zyan status code.
+// */
+//ZYCORE_EXPORT ZyanStatus ZyanBitsetToU32(const ZyanBitset* bitset, ZyanU32* value);
+//
+///**
+// * @brief Returns a 64-bit unsigned integer representation of the data.
+// *
+// * @param bitset A pointer to the `ZyanBitset` instance.
+// * @param value Receives the 64-bit unsigned integer representation of the data.
+// *
+// * @return A zyan status code.
+// */
+//ZYCORE_EXPORT ZyanStatus ZyanBitsetToU64(const ZyanBitset* bitset, ZyanU64* value);
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZYCORE_BITSET_H */
diff --git a/detours/detours/zydis/dependencies/zycore/include/Zycore/Comparison.h b/detours/detours/zydis/dependencies/zycore/include/Zycore/Comparison.h
new file mode 100644
index 0000000..53d05e8
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/include/Zycore/Comparison.h
@@ -0,0 +1,316 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+/**
+ * @file
+ * @brief Defines prototypes of general-purpose comparison functions.
+ */
+
+#ifndef ZYCORE_COMPARISON_H
+#define ZYCORE_COMPARISON_H
+
+#include
+#include
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ============================================================================================== */
+/* Enums and types */
+/* ============================================================================================== */
+
+/**
+ * @brief Defines the `ZyanEqualityComparison` function prototype.
+ *
+ * @param left A pointer to the first element.
+ * @param right A pointer to the second element.
+ *
+ * @return This function should return `ZYAN_TRUE` if the `left` element equals the `right` one
+ * or `ZYAN_FALSE`, if not.
+ */
+typedef ZyanBool (*ZyanEqualityComparison)(const void* left, const void* right);
+
+/**
+ * @brief Defines the `ZyanComparison` function prototype.
+ *
+ * @param left A pointer to the first element.
+ * @param right A pointer to the second element.
+ *
+ * @return This function should return values in the following range:
+ * `left == right -> result == 0`
+ * `left < right -> result < 0`
+ * `left > right -> result > 0`
+ */
+typedef ZyanI32 (*ZyanComparison)(const void* left, const void* right);
+
+/* ============================================================================================== */
+/* Macros */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Equality comparison functions */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Declares a generic equality comparison function for an integral datatype.
+ *
+ * @param name The name of the function.
+ * @param type The name of the integral datatype.
+ */
+#define ZYAN_DECLARE_EQUALITY_COMPARISON(name, type) \
+ ZyanBool name(const type* left, const type* right) \
+ { \
+ ZYAN_ASSERT(left); \
+ ZYAN_ASSERT(right); \
+ \
+ return (*left == *right) ? ZYAN_TRUE : ZYAN_FALSE; \
+ }
+
+/**
+ * @brief Declares a generic equality comparison function that compares a single integral
+ * datatype field of a struct.
+ *
+ * @param name The name of the function.
+ * @param type The name of the integral datatype.
+ * @param field_name The name of the struct field.
+ */
+#define ZYAN_DECLARE_EQUALITY_COMPARISON_FOR_FIELD(name, type, field_name) \
+ ZyanBool name(const type* left, const type* right) \
+ { \
+ ZYAN_ASSERT(left); \
+ ZYAN_ASSERT(right); \
+ \
+ return (left->field_name == right->field_name) ? ZYAN_TRUE : ZYAN_FALSE; \
+ }
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Comparison functions */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Declares a generic comparison function for an integral datatype.
+ *
+ * @param name The name of the function.
+ * @param type The name of the integral datatype.
+ */
+#define ZYAN_DECLARE_COMPARISON(name, type) \
+ ZyanI32 name(const type* left, const type* right) \
+ { \
+ ZYAN_ASSERT(left); \
+ ZYAN_ASSERT(right); \
+ \
+ if (*left < *right) \
+ { \
+ return -1; \
+ } \
+ if (*left > *right) \
+ { \
+ return 1; \
+ } \
+ return 0; \
+ }
+
+/**
+ * @brief Declares a generic comparison function that compares a single integral datatype field
+ * of a struct.
+ *
+ * @param name The name of the function.
+ * @param type The name of the integral datatype.
+ * @param field_name The name of the struct field.
+ */
+#define ZYAN_DECLARE_COMPARISON_FOR_FIELD(name, type, field_name) \
+ ZyanI32 name(const type* left, const type* right) \
+ { \
+ ZYAN_ASSERT(left); \
+ ZYAN_ASSERT(right); \
+ \
+ if (left->field_name < right->field_name) \
+ { \
+ return -1; \
+ } \
+ if (left->field_name > right->field_name) \
+ { \
+ return 1; \
+ } \
+ return 0; \
+ }
+
+ /* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+/* Exported functions */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Default equality comparison functions */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Defines a default equality comparison function for pointer values.
+ *
+ * @param left A pointer to the first value.
+ * @param right A pointer to the second value.
+ *
+ * @return Returns `ZYAN_TRUE` if the `left` value equals the `right` one or `ZYAN_FALSE`, if
+ * not.
+ */
+ZYAN_INLINE ZYAN_DECLARE_EQUALITY_COMPARISON(ZyanEqualsPointer, void* const)
+
+/**
+ * @brief Defines a default equality comparison function for `ZyanBool` values.
+ *
+ * @param left A pointer to the first value.
+ * @param right A pointer to the second value.
+ *
+ * @return Returns `ZYAN_TRUE` if the `left` value equals the `right` one or `ZYAN_FALSE`, if
+ * not.
+ */
+ZYAN_INLINE ZYAN_DECLARE_EQUALITY_COMPARISON(ZyanEqualsBool, ZyanBool)
+
+/**
+ * @brief Defines a default equality comparison function for 8-bit numeric values.
+ *
+ * @param left A pointer to the first value.
+ * @param right A pointer to the second value.
+ *
+ * @return Returns `ZYAN_TRUE` if the `left` value equals the `right` one or `ZYAN_FALSE`, if
+ * not.
+ */
+ZYAN_INLINE ZYAN_DECLARE_EQUALITY_COMPARISON(ZyanEqualsNumeric8, ZyanU8)
+
+/**
+ * @brief Defines a default equality comparison function for 16-bit numeric values.
+ *
+ * @param left A pointer to the first value.
+ * @param right A pointer to the second value.
+ *
+ * @return Returns `ZYAN_TRUE` if the `left` value equals the `right` one or `ZYAN_FALSE`, if
+ * not.
+ */
+ZYAN_INLINE ZYAN_DECLARE_EQUALITY_COMPARISON(ZyanEqualsNumeric16, ZyanU16)
+
+/**
+ * @brief Defines a default equality comparison function for 32-bit numeric values.
+ *
+ * @param left A pointer to the first value.
+ * @param right A pointer to the second value.
+ *
+ * @return Returns `ZYAN_TRUE` if the `left` value equals the `right` one or `ZYAN_FALSE`, if
+ * not.
+ */
+ZYAN_INLINE ZYAN_DECLARE_EQUALITY_COMPARISON(ZyanEqualsNumeric32, ZyanU32)
+
+/**
+ * @brief Defines a default equality comparison function for 64-bit numeric values.
+ *
+ * @param left A pointer to the first value.
+ * @param right A pointer to the second value.
+ *
+ * @return Returns `ZYAN_TRUE` if the `left` value equals the `right` one or `ZYAN_FALSE`, if
+ * not.
+ */
+ZYAN_INLINE ZYAN_DECLARE_EQUALITY_COMPARISON(ZyanEqualsNumeric64, ZyanU64)
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Default comparison functions */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Defines a default comparison function for pointer values.
+ *
+ * @param left A pointer to the first value.
+ * @param right A pointer to the second value.
+ *
+ * @return Returns `0` if the `left` value equals the `right` one, `-1` if the `left` value is
+ * less than the `right` one, or `1` if the `left` value is greater than the `right` one.
+ */
+ZYAN_INLINE ZYAN_DECLARE_COMPARISON(ZyanComparePointer, void* const)
+
+/**
+ * @brief Defines a default comparison function for `ZyanBool` values.
+ *
+ * @param left A pointer to the first value.
+ * @param right A pointer to the second value.
+ *
+ * @return Returns `0` if the `left` value equals the `right` one, `-1` if the `left` value is
+ * less than the `right` one, or `1` if the `left` value is greater than the `right` one.
+ */
+ZYAN_INLINE ZYAN_DECLARE_COMPARISON(ZyanCompareBool, ZyanBool)
+
+/**
+ * @brief Defines a default comparison function for 8-bit numeric values.
+ *
+ * @param left A pointer to the first value.
+ * @param right A pointer to the second value.
+ *
+ * @return Returns `0` if the `left` value equals the `right` one, `-1` if the `left` value is
+ * less than the `right` one, or `1` if the `left` value is greater than the `right` one.
+ */
+ZYAN_INLINE ZYAN_DECLARE_COMPARISON(ZyanCompareNumeric8, ZyanU8)
+
+/**
+ * @brief Defines a default comparison function for 16-bit numeric values.
+ *
+ * @param left A pointer to the first value.
+ * @param right A pointer to the second value.
+ *
+ * @return Returns `0` if the `left` value equals the `right` one, `-1` if the `left` value is
+ * less than the `right` one, or `1` if the `left` value is greater than the `right` one.
+ */
+ZYAN_INLINE ZYAN_DECLARE_COMPARISON(ZyanCompareNumeric16, ZyanU16)
+
+/**
+ * @brief Defines a default comparison function for 32-bit numeric values.
+ *
+ * @param left A pointer to the first value.
+ * @param right A pointer to the second value.
+ *
+ * @return Returns `0` if the `left` value equals the `right` one, `-1` if the `left` value is
+ * less than the `right` one, or `1` if the `left` value is greater than the `right` one.
+ */
+ZYAN_INLINE ZYAN_DECLARE_COMPARISON(ZyanCompareNumeric32, ZyanU32)
+
+/**
+ * @brief Defines a default comparison function for 64-bit numeric values.
+ *
+ * @param left A pointer to the first value.
+ * @param right A pointer to the second value.
+ *
+ * @return Returns `0` if the `left` value equals the `right` one, `-1` if the `left` value is
+ * less than the `right` one, or `1` if the `left` value is greater than the `right` one.
+ */
+ZYAN_INLINE ZYAN_DECLARE_COMPARISON(ZyanCompareNumeric64, ZyanU64)
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZYCORE_COMPARISON_H */
diff --git a/detours/detours/zydis/dependencies/zycore/include/Zycore/Defines.h b/detours/detours/zydis/dependencies/zycore/include/Zycore/Defines.h
new file mode 100644
index 0000000..ee2761c
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/include/Zycore/Defines.h
@@ -0,0 +1,430 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd, Joel Hoener
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+/**
+ * @file
+ * @brief General helper and platform detection macros.
+ */
+
+#ifndef ZYCORE_DEFINES_H
+#define ZYCORE_DEFINES_H
+
+/* ============================================================================================== */
+/* Meta macros */
+/* ============================================================================================== */
+
+/**
+ * @brief Concatenates two values using the stringify operator (`##`).
+ *
+ * @brief x The first value.
+ * @brief y The second value.
+ *
+ * @return The combined string of the given values.
+ */
+#define ZYAN_MACRO_CONCAT(x, y) x ## y
+
+/**
+ * @brief Concatenates two values using the stringify operator (`##`) and expands the value to
+ * be used in another macro.
+ *
+ * @brief x The first value.
+ * @brief y The second value.
+ *
+ * @return The combined string of the given values.
+ */
+#define ZYAN_MACRO_CONCAT_EXPAND(x, y) ZYAN_MACRO_CONCAT(x, y)
+
+/* ============================================================================================== */
+/* Compiler detection */
+/* ============================================================================================== */
+
+#if defined(__clang__)
+# define ZYAN_CLANG
+# define ZYAN_GNUC
+#elif defined(__ICC) || defined(__INTEL_COMPILER)
+# define ZYAN_ICC
+#elif defined(__GNUC__) || defined(__GNUG__)
+# define ZYAN_GCC
+# define ZYAN_GNUC
+#elif defined(_MSC_VER)
+# define ZYAN_MSVC
+#elif defined(__BORLANDC__)
+# define ZYAN_BORLAND
+#else
+# define ZYAN_UNKNOWN_COMPILER
+#endif
+
+/* ============================================================================================== */
+/* Platform detection */
+/* ============================================================================================== */
+
+#if defined(_WIN32)
+# define ZYAN_WINDOWS
+#elif defined(__EMSCRIPTEN__)
+# define ZYAN_EMSCRIPTEN
+#elif defined(__APPLE__)
+# define ZYAN_APPLE
+# define ZYAN_POSIX
+#elif defined(__linux)
+# define ZYAN_LINUX
+# define ZYAN_POSIX
+#elif defined(__FreeBSD__)
+# define ZYAN_FREEBSD
+# define ZYAN_POSIX
+#elif defined(__unix)
+# define ZYAN_UNIX
+# define ZYAN_POSIX
+#elif defined(__posix)
+# define ZYAN_POSIX
+#else
+# define ZYAN_UNKNOWN_PLATFORM
+#endif
+
+/* ============================================================================================== */
+/* Kernel mode detection */
+/* ============================================================================================== */
+
+#if (defined(ZYAN_WINDOWS) && defined(_KERNEL_MODE)) || \
+ (defined(ZYAN_APPLE) && defined(KERNEL)) || \
+ (defined(ZYAN_LINUX) && defined(__KERNEL__)) || \
+ (defined(__FreeBSD_kernel__))
+# define ZYAN_KERNEL
+#else
+# define ZYAN_USER
+#endif
+
+/* ============================================================================================== */
+/* Architecture detection */
+/* ============================================================================================== */
+
+#if defined(_M_AMD64) || defined(__x86_64__)
+# define ZYAN_X64
+#elif defined(_M_IX86) || defined(__i386__)
+# define ZYAN_X86
+#elif defined(_M_ARM64) || defined(__aarch64__)
+# define ZYAN_AARCH64
+#elif defined(_M_ARM) || defined(_M_ARMT) || defined(__arm__) || defined(__thumb__)
+# define ZYAN_ARM
+#elif defined(__EMSCRIPTEN__)
+ // Nothing to do, `ZYAN_EMSCRIPTEN` is both platform and arch macro for this one.
+#else
+# error "Unsupported architecture detected"
+#endif
+
+/* ============================================================================================== */
+/* Debug/Release detection */
+/* ============================================================================================== */
+
+#if defined(ZYAN_MSVC) || defined(ZYAN_BORLAND)
+# ifdef _DEBUG
+# define ZYAN_DEBUG
+# else
+# define ZYAN_RELEASE
+# endif
+#elif defined(ZYAN_GNUC) || defined(ZYAN_ICC)
+# ifdef NDEBUG
+# define ZYAN_RELEASE
+# else
+# define ZYAN_DEBUG
+# endif
+#else
+# define ZYAN_RELEASE
+#endif
+
+/* ============================================================================================== */
+/* Misc compatibility macros */
+/* ============================================================================================== */
+
+#if defined(ZYAN_MSVC) || defined(ZYAN_BORLAND)
+# define ZYAN_INLINE __inline
+#else
+# define ZYAN_INLINE static inline
+#endif
+
+/* ============================================================================================== */
+/* Debugging and optimization macros */
+/* ============================================================================================== */
+
+/**
+ * @brief Runtime debug assersion.
+ */
+#if defined(ZYAN_NO_LIBC)
+# define ZYAN_ASSERT(condition) (void)(condition)
+#elif defined(ZYAN_WINDOWS) && defined(ZYAN_KERNEL)
+# include
+# define ZYAN_ASSERT(condition) NT_ASSERT(condition)
+#else
+# include
+# define ZYAN_ASSERT(condition) assert(condition)
+#endif
+
+/**
+ * @brief Compiler-time assertion.
+ */
+#if __STDC_VERSION__ >= 201112L
+# define ZYAN_STATIC_ASSERT(x) _Static_assert(x, #x)
+#else
+# define ZYAN_STATIC_ASSERT(x) \
+ typedef int ZYAN_MACRO_CONCAT_EXPAND(ZYAN_SASSERT_, __COUNTER__) [(x) ? 1 : -1]
+#endif
+
+/**
+ * @brief Marks the current code path as unreachable.
+ */
+#if defined(ZYAN_RELEASE)
+# if defined(ZYAN_CLANG) // GCC eagerly evals && RHS, we have to use nested ifs.
+# if __has_builtin(__builtin_unreachable)
+# define ZYAN_UNREACHABLE __builtin_unreachable()
+# else
+# define ZYAN_UNREACHABLE for(;;)
+# endif
+# elif defined(ZYAN_GCC) && ((__GNUC__ == 4 && __GNUC_MINOR__ > 4) || __GNUC__ > 4)
+# define ZYAN_UNREACHABLE __builtin_unreachable()
+# elif defined(ZYAN_ICC)
+# ifdef ZYAN_WINDOWS
+# include // "missing return statement" workaround
+# define ZYAN_UNREACHABLE __assume(0); (void)abort()
+# else
+# define ZYAN_UNREACHABLE __builtin_unreachable()
+# endif
+# elif defined(ZYAN_MSVC)
+# define ZYAN_UNREACHABLE __assume(0)
+# else
+# define ZYAN_UNREACHABLE for(;;)
+# endif
+#elif defined(ZYAN_NO_LIBC)
+# define ZYAN_UNREACHABLE for(;;)
+#elif defined(ZYAN_WINDOWS) && defined(ZYAN_KERNEL)
+# define ZYAN_UNREACHABLE { __fastfail(0); for(;;){} }
+#else
+# include
+# define ZYAN_UNREACHABLE { assert(0); abort(); }
+#endif
+
+/* ============================================================================================== */
+/* Utils */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* General purpose */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Marks the specified parameter as unused.
+ *
+ * @param x The name of the unused parameter.
+ */
+#define ZYAN_UNUSED(x) (void)(x)
+
+/**
+ * @brief Intentional fallthrough.
+ */
+#if defined(ZYAN_GCC) && __GNUC__ > 7
+# define ZYAN_FALLTHROUGH __attribute__ ((fallthrough))
+#else
+# define ZYAN_FALLTHROUGH
+#endif
+
+/**
+ * @brief Declares a bitfield.
+ *
+ * @param x The size (in bits) of the bitfield.
+ */
+#define ZYAN_BITFIELD(x) : x
+
+/**
+ * @brief Marks functions that require libc (cannot be used with `ZYAN_NO_LIBC`).
+ */
+#define ZYAN_REQUIRES_LIBC
+
+/**
+ * @brief Decorator for `printf`-style functions.
+ *
+ * @param format_index The 1-based index of the format string parameter.
+ * @param first_to_check The 1-based index of the format arguments parameter.
+ */
+#if defined(__RESHARPER__)
+# define ZYAN_PRINTF_ATTR(format_index, first_to_check) \
+ [[gnu::format(printf, format_index, first_to_check)]]
+#elif defined(ZYAN_GCC)
+# define ZYAN_PRINTF_ATTR(format_index, first_to_check) \
+ __attribute__((format(printf, format_index, first_to_check)))
+#else
+# define ZYAN_PRINTF_ATTR(format_index, first_to_check)
+#endif
+
+/**
+ * @brief Decorator for `wprintf`-style functions.
+ *
+ * @param format_index The 1-based index of the format string parameter.
+ * @param first_to_check The 1-based index of the format arguments parameter.
+ */
+#if defined(__RESHARPER__)
+# define ZYAN_WPRINTF_ATTR(format_index, first_to_check) \
+ [[rscpp::format(wprintf, format_index, first_to_check)]]
+#else
+# define ZYAN_WPRINTF_ATTR(format_index, first_to_check)
+#endif
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Arrays */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Returns the length (number of elements) of an array.
+ *
+ * @param a The name of the array.
+ *
+ * @return The number of elements of the given array.
+ */
+#define ZYAN_ARRAY_LENGTH(a) (sizeof(a) / sizeof((a)[0]))
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Arithmetic */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Returns the smaller value of `a` or `b`.
+ *
+ * @param a The first value.
+ * @param b The second value.
+ *
+ * @return The smaller value of `a` or `b`.
+ */
+#define ZYAN_MIN(a, b) (((a) < (b)) ? (a) : (b))
+
+/**
+ * @brief Returns the bigger value of `a` or `b`.
+ *
+ * @param a The first value.
+ * @param b The second value.
+ *
+ * @return The bigger value of `a` or `b`.
+ */
+#define ZYAN_MAX(a, b) (((a) > (b)) ? (a) : (b))
+
+/**
+ * @brief Returns the absolute value of `a`.
+ *
+ * @param a The value.
+ *
+ * @return The absolute value of `a`.
+ */
+#define ZYAN_ABS(a) (((a) < 0) ? -(a) : (a))
+
+/**
+ * @brief Checks, if the given value is a power of 2.
+ *
+ * @param x The value.
+ *
+ * @return `ZYAN_TRUE`, if the given value is a power of 2 or `ZYAN_FALSE`, if not.
+ *
+ * Note that this macro always returns `ZYAN_TRUE` for `x == 0`.
+ */
+#define ZYAN_IS_POWER_OF_2(x) (((x) & ((x) - 1)) == 0)
+
+/**
+ * @brief Checks, if the given value is properly aligned.
+ *
+ * Note that this macro only works for powers of 2.
+ */
+#define ZYAN_IS_ALIGNED_TO(x, align) ((x & (align - 1)) == 0)
+
+/**
+ * @brief Aligns the value to the nearest given alignment boundary (by rounding it up).
+ *
+ * @param x The value.
+ * @param align The desired alignment.
+ *
+ * @return The aligned value.
+ *
+ * Note that this macro only works for powers of 2.
+ */
+#define ZYAN_ALIGN_UP(x, align) (((x) + (align) - 1) & ~((align) - 1))
+
+/**
+ * @brief Aligns the value to the nearest given alignment boundary (by rounding it down).
+ *
+ * @param x The value.
+ * @param align The desired alignment.
+ *
+ * @return The aligned value.
+ *
+ * Note that this macro only works for powers of 2.
+ */
+#define ZYAN_ALIGN_DOWN(x, align) (((x) - 1) & ~((align) - 1))
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Bit operations */
+/* ---------------------------------------------------------------------------------------------- */
+
+/*
+ * @brief Checks, if the bit at index `b` is required to present the ordinal value `n`.
+ *
+ * @param n The ordinal value.
+ * @param b The bit index.
+ *
+ * @return `ZYAN_TRUE`, if the bit at index `b` is required to present the ordinal value `n` or
+ * `ZYAN_FALSE`, if not.
+ *
+ * Note that this macro always returns `ZYAN_FALSE` for `n == 0`.
+ */
+#define ZYAN_NEEDS_BIT(n, b) (((unsigned long)(n) >> (b)) > 0)
+
+/*
+ * @brief Returns the number of bits required to represent the ordinal value `n`.
+ *
+ * @param n The ordinal value.
+ *
+ * @return The number of bits required to represent the ordinal value `n`.
+ *
+ * Note that this macro returns `0` for `n == 0`.
+ */
+#define ZYAN_BITS_TO_REPRESENT(n) \
+ ( \
+ ZYAN_NEEDS_BIT(n, 0) + ZYAN_NEEDS_BIT(n, 1) + \
+ ZYAN_NEEDS_BIT(n, 2) + ZYAN_NEEDS_BIT(n, 3) + \
+ ZYAN_NEEDS_BIT(n, 4) + ZYAN_NEEDS_BIT(n, 5) + \
+ ZYAN_NEEDS_BIT(n, 6) + ZYAN_NEEDS_BIT(n, 7) + \
+ ZYAN_NEEDS_BIT(n, 8) + ZYAN_NEEDS_BIT(n, 9) + \
+ ZYAN_NEEDS_BIT(n, 10) + ZYAN_NEEDS_BIT(n, 11) + \
+ ZYAN_NEEDS_BIT(n, 12) + ZYAN_NEEDS_BIT(n, 13) + \
+ ZYAN_NEEDS_BIT(n, 14) + ZYAN_NEEDS_BIT(n, 15) + \
+ ZYAN_NEEDS_BIT(n, 16) + ZYAN_NEEDS_BIT(n, 17) + \
+ ZYAN_NEEDS_BIT(n, 18) + ZYAN_NEEDS_BIT(n, 19) + \
+ ZYAN_NEEDS_BIT(n, 20) + ZYAN_NEEDS_BIT(n, 21) + \
+ ZYAN_NEEDS_BIT(n, 22) + ZYAN_NEEDS_BIT(n, 23) + \
+ ZYAN_NEEDS_BIT(n, 24) + ZYAN_NEEDS_BIT(n, 25) + \
+ ZYAN_NEEDS_BIT(n, 26) + ZYAN_NEEDS_BIT(n, 27) + \
+ ZYAN_NEEDS_BIT(n, 28) + ZYAN_NEEDS_BIT(n, 29) + \
+ ZYAN_NEEDS_BIT(n, 30) + ZYAN_NEEDS_BIT(n, 31) \
+ )
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+
+#endif /* ZYCORE_DEFINES_H */
diff --git a/detours/detours/zydis/dependencies/zycore/include/Zycore/Format.h b/detours/detours/zydis/dependencies/zycore/include/Zycore/Format.h
new file mode 100644
index 0000000..2e0753b
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/include/Zycore/Format.h
@@ -0,0 +1,261 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+/**
+ * @file
+ * @brief Provides helper functions for performant number to string conversion.
+ */
+
+#ifndef ZYCORE_FORMAT_H
+#define ZYCORE_FORMAT_H
+
+#include
+#include
+#include
+#include
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ============================================================================================== */
+/* Exported functions */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Insertion */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Inserts formatted text in the destination string at the given `index`.
+ *
+ * @param string The destination string.
+ * @param index The insert index.
+ * @param format The format string.
+ * @param ... The format arguments.
+ *
+ * @return A zyan status code.
+ *
+ * This function will fail, if the `ZYAN_STRING_IS_IMMUTABLE` flag is set for the specified
+ * `ZyanString` instance.
+ */
+ZYAN_PRINTF_ATTR(3, 4)
+ZYCORE_EXPORT ZyanStatus ZyanStringInsertFormat(ZyanString* string, ZyanUSize index,
+ const char* format, ...);
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Formats the given unsigned ordinal `value` to its decimal text-representation and
+ * inserts it to the `string`.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ * @param index The insert index.
+ * @param value The value.
+ * @param padding_length Padds the converted value with leading zeros, if the number of chars is
+ * less than the `padding_length`.
+ *
+ * @return A zyan status code.
+ *
+ * This function will fail, if the `ZYAN_STRING_IS_IMMUTABLE` flag is set for the specified
+ * `ZyanString` instance.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringInsertDecU(ZyanString* string, ZyanUSize index, ZyanU64 value,
+ ZyanU8 padding_length);
+
+/**
+ * @brief Formats the given signed ordinal `value` to its decimal text-representation and
+ * inserts it to the `string`.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ * @param index The insert index.
+ * @param value The value.
+ * @param padding_length Padds the converted value with leading zeros, if the number of chars is
+ * less than the `padding_length`.
+ * @param force_sign Set `ZYAN_TRUE`, to force printing of the `+` sign for positive numbers.
+ * @param prefix The string to use as prefix or `ZYAN_NULL`, if not needed.
+ *
+ * @return A zyan status code.
+ *
+ * This function will fail, if the `ZYAN_STRING_IS_IMMUTABLE` flag is set for the specified
+ * `ZyanString` instance.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringInsertDecS(ZyanString* string, ZyanUSize index, ZyanI64 value,
+ ZyanU8 padding_length, ZyanBool force_sign, const ZyanString* prefix);
+
+/**
+ * @brief Formats the given unsigned ordinal `value` to its hexadecimal text-representation and
+ * inserts it to the `string`.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ * @param index The insert index.
+ * @param value The value.
+ * @param padding_length Padds the converted value with leading zeros, if the number of chars is
+ * less than the `padding_length`.
+ * @param uppercase Set `ZYAN_TRUE` to use uppercase letters ('A'-'F') instead of lowercase
+ * ones ('a'-'f').
+ *
+ * @return A zyan status code.
+ *
+ * This function will fail, if the `ZYAN_STRING_IS_IMMUTABLE` flag is set for the specified
+ * `ZyanString` instance.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringInsertHexU(ZyanString* string, ZyanUSize index, ZyanU64 value,
+ ZyanU8 padding_length, ZyanBool uppercase);
+
+/**
+ * @brief Formats the given signed ordinal `value` to its hexadecimal text-representation and
+ * inserts it to the `string`.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ * @param index The insert index.
+ * @param value The value.
+ * @param padding_length Padds the converted value with leading zeros, if the number of chars is
+ * less than the `padding_length`.
+ * @param uppercase Set `ZYAN_TRUE` to use uppercase letters ('A'-'F') instead of lowercase
+ * ones ('a'-'f').
+ * @param force_sign Set `ZYAN_TRUE`, to force printing of the `+` sign for positive numbers.
+ * @param prefix The string to use as prefix or `ZYAN_NULL`, if not needed.
+ *
+ * @return A zyan status code.
+ *
+ * This function will fail, if the `ZYAN_STRING_IS_IMMUTABLE` flag is set for the specified
+ * `ZyanString` instance.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringInsertHexS(ZyanString* string, ZyanUSize index, ZyanI64 value,
+ ZyanU8 padding_length, ZyanBool uppercase, ZyanBool force_sign, const ZyanString* prefix);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Appending */
+/* ---------------------------------------------------------------------------------------------- */
+
+#ifndef ZYAN_NO_LIBC
+
+/**
+ * @brief Appends formatted text to the destination string.
+ *
+ * @param string The destination string.
+ * @param format The format string.
+ * @param ... The format arguments.
+ *
+ * @return A zyan status code.
+ *
+ * This function will fail, if the `ZYAN_STRING_IS_IMMUTABLE` flag is set for the specified
+ * `ZyanString` instance.
+ */
+ZYAN_PRINTF_ATTR(2, 3)
+ZYCORE_EXPORT ZYAN_REQUIRES_LIBC ZyanStatus ZyanStringAppendFormat(
+ ZyanString* string, const char* format, ...);
+
+#endif // ZYAN_NO_LIBC
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Formats the given unsigned ordinal `value` to its decimal text-representation and
+ * appends it to the `string`.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ * @param value The value.
+ * @param padding_length Padds the converted value with leading zeros, if the number of chars is
+ * less than the `padding_length`.
+ *
+ * @return A zyan status code.
+ *
+ * This function will fail, if the `ZYAN_STRING_IS_IMMUTABLE` flag is set for the specified
+ * `ZyanString` instance.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringAppendDecU(ZyanString* string, ZyanU64 value,
+ ZyanU8 padding_length);
+
+/**
+ * @brief Formats the given signed ordinal `value` to its decimal text-representation and
+ * appends it to the `string`.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ * @param value The value.
+ * @param padding_length Padds the converted value with leading zeros, if the number of chars is
+ * less than the `padding_length`.
+ * @param force_sign Set `ZYAN_TRUE`, to force printing of the `+` sign for positive numbers.
+ * @param prefix The string to use as prefix or `ZYAN_NULL`, if not needed.
+ *
+ * @return A zyan status code.
+ *
+ * This function will fail, if the `ZYAN_STRING_IS_IMMUTABLE` flag is set for the specified
+ * `ZyanString` instance.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringAppendDecS(ZyanString* string, ZyanI64 value,
+ ZyanU8 padding_length, ZyanBool force_sign, const ZyanStringView* prefix);
+
+/**
+ * @brief Formats the given unsigned ordinal `value` to its hexadecimal text-representation and
+ * appends it to the `string`.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ * @param value The value.
+ * @param padding_length Padds the converted value with leading zeros, if the number of chars is
+ * less than the `padding_length`.
+ * @param uppercase Set `ZYAN_TRUE` to use uppercase letters ('A'-'F') instead of lowercase
+ * ones ('a'-'f').
+ *
+ * @return A zyan status code.
+ *
+ * This function will fail, if the `ZYAN_STRING_IS_IMMUTABLE` flag is set for the specified
+ * `ZyanString` instance.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringAppendHexU(ZyanString* string, ZyanU64 value,
+ ZyanU8 padding_length, ZyanBool uppercase);
+
+/**
+ * @brief Formats the given signed ordinal `value` to its hexadecimal text-representation and
+ * appends it to the `string`.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ * @param value The value.
+ * @param padding_length Padds the converted value with leading zeros, if the number of chars is
+ * less than the `padding_length`.
+ * @param uppercase Set `ZYAN_TRUE` to use uppercase letters ('A'-'F') instead of lowercase
+ * ones ('a'-'f').
+ * @param force_sign Set `ZYAN_TRUE`, to force printing of the `+` sign for positive numbers.
+ * @param prefix The string to use as prefix or `ZYAN_NULL`, if not needed.
+ *
+ * @return A zyan status code.
+ *
+ * This function will fail, if the `ZYAN_STRING_IS_IMMUTABLE` flag is set for the specified
+ * `ZyanString` instance.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringAppendHexS(ZyanString* string, ZyanI64 value,
+ ZyanU8 padding_length, ZyanBool uppercase, ZyanBool force_sign, const ZyanStringView* prefix);
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // ZYCORE_FORMAT_H
diff --git a/detours/detours/zydis/dependencies/zycore/include/Zycore/LibC.h b/detours/detours/zydis/dependencies/zycore/include/Zycore/LibC.h
new file mode 100644
index 0000000..f98e573
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/include/Zycore/LibC.h
@@ -0,0 +1,511 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd, Joel Hoener
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+/**
+ * @file
+ * @brief Provides a simple LibC abstraction and fallback routines.
+ */
+
+#ifndef ZYCORE_LIBC_H
+#define ZYCORE_LIBC_H
+
+#ifndef ZYAN_CUSTOM_LIBC
+
+// Include a custom LibC header and define `ZYAN_CUSTOM_LIBC` to provide your own LibC
+// replacement functions
+
+#ifndef ZYAN_NO_LIBC
+
+/* ============================================================================================== */
+/* LibC is available */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* errno.h */
+/* ---------------------------------------------------------------------------------------------- */
+
+#include
+
+#define ZYAN_ERRNO errno
+
+/* ---------------------------------------------------------------------------------------------- */
+/* stdarg.h */
+/* ---------------------------------------------------------------------------------------------- */
+
+#include
+
+/**
+ * @brief Defines the `ZyanVAList` datatype.
+ */
+typedef va_list ZyanVAList;
+
+#define ZYAN_VA_START va_start
+#define ZYAN_VA_ARG va_arg
+#define ZYAN_VA_END va_end
+#define ZYAN_VA_COPY(dest, source) va_copy((dest), (source))
+
+/* ---------------------------------------------------------------------------------------------- */
+/* stdio.h */
+/* ---------------------------------------------------------------------------------------------- */
+
+#include
+
+#define ZYAN_FPUTS fputs
+#define ZYAN_FPUTC fputc
+#define ZYAN_FPRINTF fprintf
+#define ZYAN_PRINTF printf
+#define ZYAN_PUTC putc
+#define ZYAN_PUTS puts
+#define ZYAN_SCANF scanf
+#define ZYAN_SSCANF sscanf
+#define ZYAN_VSNPRINTF vsnprintf
+
+/**
+ * @brief Defines the `ZyanFile` datatype.
+ */
+typedef FILE ZyanFile;
+
+#define ZYAN_STDIN stdin
+#define ZYAN_STDOUT stdout
+#define ZYAN_STDERR stderr
+
+/* ---------------------------------------------------------------------------------------------- */
+/* stdlib.h */
+/* ---------------------------------------------------------------------------------------------- */
+
+#include
+#define ZYAN_CALLOC calloc
+#define ZYAN_FREE free
+#define ZYAN_MALLOC malloc
+#define ZYAN_REALLOC realloc
+
+/* ---------------------------------------------------------------------------------------------- */
+/* string.h */
+/* ---------------------------------------------------------------------------------------------- */
+
+#include
+#define ZYAN_MEMCHR memchr
+#define ZYAN_MEMCMP memcmp
+#define ZYAN_MEMCPY memcpy
+#define ZYAN_MEMMOVE memmove
+#define ZYAN_MEMSET memset
+#define ZYAN_STRCAT strcat
+#define ZYAN_STRCHR strchr
+#define ZYAN_STRCMP strcmp
+#define ZYAN_STRCOLL strcoll
+#define ZYAN_STRCPY strcpy
+#define ZYAN_STRCSPN strcspn
+#define ZYAN_STRLEN strlen
+#define ZYAN_STRNCAT strncat
+#define ZYAN_STRNCMP strncmp
+#define ZYAN_STRNCPY strncpy
+#define ZYAN_STRPBRK strpbrk
+#define ZYAN_STRRCHR strrchr
+#define ZYAN_STRSPN strspn
+#define ZYAN_STRSTR strstr
+#define ZYAN_STRTOK strtok
+#define ZYAN_STRXFRM strxfrm
+
+/* ---------------------------------------------------------------------------------------------- */
+
+#else // if ZYAN_NO_LIBC
+
+/* ============================================================================================== */
+/* No LibC available, use our own functions */
+/* ============================================================================================== */
+
+#include
+#include
+
+/*
+ * These implementations are by no means optimized and will be outperformed by pretty much any
+ * libc implementation out there. We do not aim towards providing competetive implementations here,
+ * but towards providing a last resort fallback for environments without a working libc.
+ */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* stdarg.h */
+/* ---------------------------------------------------------------------------------------------- */
+
+#if defined(ZYAN_MSVC) || defined(ZYAN_ICC)
+
+/**
+ * @brief Defines the `ZyanVAList` datatype.
+ */
+typedef char* ZyanVAList;
+
+# define ZYAN_VA_START __crt_va_start
+# define ZYAN_VA_ARG __crt_va_arg
+# define ZYAN_VA_END __crt_va_end
+# define ZYAN_VA_COPY(destination, source) ((destination) = (source))
+
+#elif defined(ZYAN_GNUC)
+
+/**
+ * @brief Defines the `ZyanVAList` datatype.
+ */
+typedef __builtin_va_list ZyanVAList;
+
+# define ZYAN_VA_START(v, l) __builtin_va_start(v, l)
+# define ZYAN_VA_END(v) __builtin_va_end(v)
+# define ZYAN_VA_ARG(v, l) __builtin_va_arg(v, l)
+# define ZYAN_VA_COPY(d, s) __builtin_va_copy(d, s)
+
+#else
+# error "Unsupported compiler for no-libc mode."
+#endif
+
+/* ---------------------------------------------------------------------------------------------- */
+/* stdio.h */
+/* ---------------------------------------------------------------------------------------------- */
+
+// ZYAN_INLINE int ZYAN_VSNPRINTF (char* const buffer, ZyanUSize const count,
+// char const* const format, ZyanVAList args)
+// {
+// // We cant provide a fallback implementation for this function
+// ZYAN_UNUSED(buffer);
+// ZYAN_UNUSED(count);
+// ZYAN_UNUSED(format);
+// ZYAN_UNUSED(args);
+// return ZYAN_NULL;
+// }
+
+/* ---------------------------------------------------------------------------------------------- */
+/* stdlib.h */
+/* ---------------------------------------------------------------------------------------------- */
+
+// ZYAN_INLINE void* ZYAN_CALLOC(ZyanUSize nitems, ZyanUSize size)
+// {
+// // We cant provide a fallback implementation for this function
+// ZYAN_UNUSED(nitems);
+// ZYAN_UNUSED(size);
+// return ZYAN_NULL;
+// }
+//
+// ZYAN_INLINE void ZYAN_FREE(void *p)
+// {
+// // We cant provide a fallback implementation for this function
+// ZYAN_UNUSED(p);
+// }
+//
+// ZYAN_INLINE void* ZYAN_MALLOC(ZyanUSize n)
+// {
+// // We cant provide a fallback implementation for this function
+// ZYAN_UNUSED(n);
+// return ZYAN_NULL;
+// }
+//
+// ZYAN_INLINE void* ZYAN_REALLOC(void* p, ZyanUSize n)
+// {
+// // We cant provide a fallback implementation for this function
+// ZYAN_UNUSED(p);
+// ZYAN_UNUSED(n);
+// return ZYAN_NULL;
+// }
+
+/* ---------------------------------------------------------------------------------------------- */
+/* string.h */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZYAN_INLINE void* ZYAN_MEMCHR(const void* str, int c, ZyanUSize n)
+{
+ const ZyanU8* p = (ZyanU8*)str;
+ while (n--)
+ {
+ if (*p != (ZyanU8)c)
+ {
+ p++;
+ } else
+ {
+ return (void*)p;
+ }
+ }
+ return 0;
+}
+
+ZYAN_INLINE int ZYAN_MEMCMP(const void* s1, const void* s2, ZyanUSize n)
+{
+ const ZyanU8* p1 = s1, *p2 = s2;
+ while (n--)
+ {
+ if (*p1 != *p2)
+ {
+ return *p1 - *p2;
+ }
+ p1++, p2++;
+ }
+ return 0;
+}
+
+ZYAN_INLINE void* ZYAN_MEMCPY(void* dst, const void* src, ZyanUSize n)
+{
+ volatile ZyanU8* dp = dst;
+ const ZyanU8* sp = src;
+ while (n--)
+ {
+ *dp++ = *sp++;
+ }
+ return dst;
+}
+
+ZYAN_INLINE void* ZYAN_MEMMOVE(void* dst, const void* src, ZyanUSize n)
+{
+ volatile ZyanU8* pd = dst;
+ const ZyanU8* ps = src;
+ if (ps < pd)
+ {
+ for (pd += n, ps += n; n--;)
+ {
+ *--pd = *--ps;
+ }
+ } else
+ {
+ while (n--)
+ {
+ *pd++ = *ps++;
+ }
+ }
+ return dst;
+}
+
+ZYAN_INLINE void* ZYAN_MEMSET(void* dst, int val, ZyanUSize n)
+{
+ volatile ZyanU8* p = dst;
+ while (n--)
+ {
+ *p++ = (unsigned char)val;
+ }
+ return dst;
+}
+
+ZYAN_INLINE char* ZYAN_STRCAT(char* dest, const char* src)
+{
+ char* ret = dest;
+ while (*dest)
+ {
+ dest++;
+ }
+ while ((*dest++ = *src++));
+ return ret;
+}
+
+ZYAN_INLINE char* ZYAN_STRCHR(const char* s, int c)
+{
+ while (*s != (char)c)
+ {
+ if (!*s++)
+ {
+ return 0;
+ }
+ }
+ return (char*)s;
+}
+
+ZYAN_INLINE int ZYAN_STRCMP(const char* s1, const char* s2)
+{
+ while (*s1 && (*s1 == *s2))
+ {
+ s1++, s2++;
+ }
+ return *(const ZyanU8*)s1 - *(const ZyanU8*)s2;
+}
+
+ZYAN_INLINE int ZYAN_STRCOLL(const char *s1, const char *s2)
+{
+ // TODO: Implement
+
+ ZYAN_UNUSED(s1);
+ ZYAN_UNUSED(s2);
+
+ return 0;
+}
+
+ZYAN_INLINE char* ZYAN_STRCPY(char* dest, const char* src)
+{
+ char* ret = dest;
+ while ((*dest++ = *src++));
+ return ret;
+}
+
+ZYAN_INLINE ZyanUSize ZYAN_STRCSPN(const char *s1, const char *s2)
+{
+ ZyanUSize ret = 0;
+ while (*s1)
+ {
+ if (ZYAN_STRCHR(s2, *s1))
+ {
+ return ret;
+ }
+ s1++, ret++;
+ }
+ return ret;
+}
+
+ZYAN_INLINE ZyanUSize ZYAN_STRLEN(const char* str)
+{
+ const char* p = str;
+ while (*str)
+ {
+ ++str;
+ }
+ return str - p;
+}
+
+ZYAN_INLINE char* ZYAN_STRNCAT(char* dest, const char* src, ZyanUSize n)
+{
+ char* ret = dest;
+ while (*dest)
+ {
+ dest++;
+ }
+ while (n--)
+ {
+ if (!(*dest++ = *src++))
+ {
+ return ret;
+ }
+ }
+ *dest = 0;
+ return ret;
+}
+
+ZYAN_INLINE int ZYAN_STRNCMP(const char* s1, const char* s2, ZyanUSize n)
+{
+ while (n--)
+ {
+ if (*s1++ != *s2++)
+ {
+ return *(unsigned char*)(s1 - 1) - *(unsigned char*)(s2 - 1);
+ }
+ }
+ return 0;
+}
+
+ZYAN_INLINE char* ZYAN_STRNCPY(char* dest, const char* src, ZyanUSize n)
+{
+ char* ret = dest;
+ do
+ {
+ if (!n--)
+ {
+ return ret;
+ }
+ } while ((*dest++ = *src++));
+ while (n--)
+ {
+ *dest++ = 0;
+ }
+ return ret;
+}
+
+ZYAN_INLINE char* ZYAN_STRPBRK(const char* s1, const char* s2)
+{
+ while (*s1)
+ {
+ if(ZYAN_STRCHR(s2, *s1++))
+ {
+ return (char*)--s1;
+ }
+ }
+ return 0;
+}
+
+ZYAN_INLINE char* ZYAN_STRRCHR(const char* s, int c)
+{
+ char* ret = 0;
+ do
+ {
+ if (*s == (char)c)
+ {
+ ret = (char*)s;
+ }
+ } while (*s++);
+ return ret;
+}
+
+ZYAN_INLINE ZyanUSize ZYAN_STRSPN(const char* s1, const char* s2)
+{
+ ZyanUSize ret = 0;
+ while (*s1 && ZYAN_STRCHR(s2, *s1++))
+ {
+ ret++;
+ }
+ return ret;
+}
+
+ZYAN_INLINE char* ZYAN_STRSTR(const char* s1, const char* s2)
+{
+ const ZyanUSize n = ZYAN_STRLEN(s2);
+ while (*s1)
+ {
+ if (!ZYAN_MEMCMP(s1++, s2, n))
+ {
+ return (char*)(s1 - 1);
+ }
+ }
+ return 0;
+}
+
+ZYAN_INLINE char* ZYAN_STRTOK(char* str, const char* delim)
+{
+ static char* p = 0;
+ if (str)
+ {
+ p = str;
+ } else
+ if (!p)
+ {
+ return 0;
+ }
+ str = p + ZYAN_STRSPN(p, delim);
+ p = str + ZYAN_STRCSPN(str, delim);
+ if (p == str)
+ {
+ return p = 0;
+ }
+ p = *p ? *p = 0, p + 1 : 0;
+ return str;
+}
+
+ZYAN_INLINE ZyanUSize ZYAN_STRXFRM(char* dest, const char* src, ZyanUSize n)
+{
+ const ZyanUSize n2 = ZYAN_STRLEN(src);
+ if (n > n2)
+ {
+ ZYAN_STRCPY(dest, src);
+ }
+ return n2;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+
+#endif
+
+#endif
+
+/* ============================================================================================== */
+
+#endif /* ZYCORE_LIBC_H */
diff --git a/detours/detours/zydis/dependencies/zycore/include/Zycore/List.h b/detours/detours/zydis/dependencies/zycore/include/Zycore/List.h
new file mode 100644
index 0000000..9a70720
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/include/Zycore/List.h
@@ -0,0 +1,574 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+/**
+ * @file
+ * @brief Implements a doubly linked list.
+ */
+
+#ifndef ZYCORE_LIST_H
+#define ZYCORE_LIST_H
+
+#include
+#include
+#include
+#include
+#include
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ============================================================================================== */
+/* Enums and types */
+/* ============================================================================================== */
+
+/**
+ * @brief Defines the `ZyanListNode` struct.
+ *
+ * All fields in this struct should be considered as "private". Any changes may lead to unexpected
+ * behavior.
+ */
+typedef struct ZyanListNode_
+{
+ /**
+ * @brief A pointer to the previous list node.
+ */
+ struct ZyanListNode_* prev;
+ /**
+ * @brief A pointer to the next list node.
+ */
+ struct ZyanListNode_* next;
+} ZyanListNode;
+
+/**
+ * @brief Defines the `ZyanList` struct.
+ *
+ * All fields in this struct should be considered as "private". Any changes may lead to unexpected
+ * behavior.
+ */
+typedef struct ZyanList_
+{
+ /**
+ * @brief The memory allocator.
+ */
+ ZyanAllocator* allocator;
+ /**
+ * @brief The current number of elements in the list.
+ */
+ ZyanUSize size;
+ /**
+ * @brief The size of a single element in bytes.
+ */
+ ZyanUSize element_size;
+ /**
+ * @brief The element destructor callback.
+ */
+ ZyanMemberProcedure destructor;
+ /**
+ * @brief The head node.
+ */
+ ZyanListNode* head;
+ /**
+ * @brief The tail node.
+ */
+ ZyanListNode* tail;
+ /**
+ * @brief The data buffer.
+ *
+ * Only used for instances created by `ZyanListInitCustomBuffer`.
+ */
+ void* buffer;
+ /**
+ * @brief The data buffer capacity (number of bytes).
+ *
+ * Only used for instances created by `ZyanListInitCustomBuffer`.
+ */
+ ZyanUSize capacity;
+ /**
+ * @brief The first unused node.
+ *
+ * When removing a node, the first-unused value is updated to point at the removed node and the
+ * next node of the removed node will be updated to point at the old first-unused node.
+ *
+ * When appending the memory of the first unused-node is recycled to store the new node. The
+ * value of the first-unused node is then updated to point at the reused nodes next node.
+ *
+ * If the first-unused value is `ZYAN_NULL`, any new node will be "allocated" behind the tail
+ * node (if there is enough space left in the fixed size buffer).
+ *
+ * Only used for instances created by `ZyanListInitCustomBuffer`.
+ */
+ ZyanListNode* first_unused;
+} ZyanList;
+
+/* ============================================================================================== */
+/* Macros */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* General */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Defines an uninitialized `ZyanList` instance.
+ */
+#define ZYAN_LIST_INITIALIZER \
+ { \
+ /* allocator */ ZYAN_NULL, \
+ /* size */ 0, \
+ /* element_size */ 0, \
+ /* head */ ZYAN_NULL, \
+ /* destructor */ ZYAN_NULL, \
+ /* tail */ ZYAN_NULL, \
+ /* buffer */ ZYAN_NULL, \
+ /* capacity */ 0, \
+ /* first_unused */ ZYAN_NULL \
+ }
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Helper macros */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Returns the data value of the given `node`.
+ *
+ * @param type The desired value type.
+ * @param node A pointer to the `ZyanListNode` struct.
+ *
+ * @result The data value of the given `node`.
+ *
+ * Note that this function is unsafe and might dereference a null-pointer.
+ */
+#ifdef __cplusplus
+#define ZYAN_LIST_GET(type, node) \
+ (*reinterpret_cast(ZyanListGetNodeData(node)))
+#else
+#define ZYAN_LIST_GET(type, node) \
+ (*(const type*)ZyanListGetNodeData(node))
+#endif
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+/* Exported functions */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Constructor and destructor */
+/* ---------------------------------------------------------------------------------------------- */
+
+#ifndef ZYAN_NO_LIBC
+
+/**
+ * @brief Initializes the given `ZyanList` instance.
+ *
+ * @param list A pointer to the `ZyanList` instance.
+ * @param element_size The size of a single element in bytes.
+ * @param destructor A destructor callback that is invoked every time an item is deleted, or
+ * `ZYAN_NULL` if not needed.
+ *
+ * @return A zyan status code.
+ *
+ * The memory for the list elements is dynamically allocated by the default allocator.
+ *
+ * Finalization with `ZyanListDestroy` is required for all instances created by this function.
+ */
+ZYCORE_EXPORT ZYAN_REQUIRES_LIBC ZyanStatus ZyanListInit(ZyanList* list, ZyanUSize element_size,
+ ZyanMemberProcedure destructor);
+
+#endif // ZYAN_NO_LIBC
+
+/**
+ * @brief Initializes the given `ZyanList` instance and sets a custom `allocator`.
+ *
+ * @param list A pointer to the `ZyanList` instance.
+ * @param element_size The size of a single element in bytes.
+ * @param destructor A destructor callback that is invoked every time an item is deleted, or
+ * `ZYAN_NULL` if not needed.
+ * @param allocator A pointer to a `ZyanAllocator` instance.
+ *
+ * @return A zyan status code.
+ *
+ * Finalization with `ZyanListDestroy` is required for all instances created by this function.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanListInitEx(ZyanList* list, ZyanUSize element_size,
+ ZyanMemberProcedure destructor, ZyanAllocator* allocator);
+
+/**
+ * @brief Initializes the given `ZyanList` instance and configures it to use a custom user
+ * defined buffer with a fixed size.
+ *
+ * @param list A pointer to the `ZyanList` instance.
+ * @param element_size The size of a single element in bytes.
+ * @param destructor A destructor callback that is invoked every time an item is deleted, or
+ * `ZYAN_NULL` if not needed.
+ * @param buffer A pointer to the buffer that is used as storage for the elements.
+ * @param capacity The maximum capacity (number of bytes) of the buffer including the
+ * space required for the list-nodes.
+ *
+ * @return A zyan status code.
+ *
+ * The buffer capacity required to store `n` elements of type `T` is be calculated by:
+ * `size = n * sizeof(ZyanListNode) + n * sizeof(T)`
+ *
+ * Finalization is not required for instances created by this function.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanListInitCustomBuffer(ZyanList* list, ZyanUSize element_size,
+ ZyanMemberProcedure destructor, void* buffer, ZyanUSize capacity);
+
+/**
+ * @brief Destroys the given `ZyanList` instance.
+ *
+ * @param list A pointer to the `ZyanList` instance.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanListDestroy(ZyanList* list);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Duplication */
+/* ---------------------------------------------------------------------------------------------- */
+
+#ifndef ZYAN_NO_LIBC
+
+/**
+ * @brief Initializes a new `ZyanList` instance by duplicating an existing list.
+ *
+ * @param destination A pointer to the (uninitialized) destination `ZyanList` instance.
+ * @param source A pointer to the source list.
+ *
+ * @return A zyan status code.
+ *
+ * The memory for the list is dynamically allocated by the default allocator.
+ *
+ * Finalization with `ZyanListDestroy` is required for all instances created by this function.
+ */
+ZYCORE_EXPORT ZYAN_REQUIRES_LIBC ZyanStatus ZyanListDuplicate(ZyanList* destination,
+ const ZyanList* source);
+
+#endif // ZYAN_NO_LIBC
+
+/**
+ * @brief Initializes a new `ZyanList` instance by duplicating an existing list and sets a
+ * custom `allocator`.
+ *
+ * @param destination A pointer to the (uninitialized) destination `ZyanList` instance.
+ * @param source A pointer to the source list.
+ * @param allocator A pointer to a `ZyanAllocator` instance.
+ *
+ * @return A zyan status code.
+
+ * Finalization with `ZyanListDestroy` is required for all instances created by this function.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanListDuplicateEx(ZyanList* destination, const ZyanList* source,
+ ZyanAllocator* allocator);
+
+/**
+ * @brief Initializes a new `ZyanList` instance by duplicating an existing list and
+ * configures it to use a custom user defined buffer with a fixed size.
+ *
+ * @param destination A pointer to the (uninitialized) destination `ZyanList` instance.
+ * @param source A pointer to the source list.
+ * @param buffer A pointer to the buffer that is used as storage for the elements.
+ * @param capacity The maximum capacity (number of bytes) of the buffer including the
+ * space required for the list-nodes.
+
+ * This function will fail, if the capacity of the buffer is not sufficient
+ * to store all elements of the source list.
+ *
+ * @return A zyan status code.
+ *
+ * The buffer capacity required to store `n` elements of type `T` is be calculated by:
+ * `size = n * sizeof(ZyanListNode) + n * sizeof(T)`
+ *
+ * Finalization is not required for instances created by this function.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanListDuplicateCustomBuffer(ZyanList* destination,
+ const ZyanList* source, void* buffer, ZyanUSize capacity);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Item access */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Returns a pointer to the first `ZyanListNode` struct of the given list.
+ *
+ * @param list A pointer to the `ZyanList` instance.
+ * @param node Receives a pointer to the first `ZyanListNode` struct of the list.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanListGetHeadNode(const ZyanList* list, const ZyanListNode** node);
+
+/**
+ * @brief Returns a pointer to the last `ZyanListNode` struct of the given list.
+ *
+ * @param list A pointer to the `ZyanList` instance.
+ * @param node Receives a pointer to the last `ZyanListNode` struct of the list.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanListGetTailNode(const ZyanList* list, const ZyanListNode** node);
+
+/**
+ * @brief Receives a pointer to the previous `ZyanListNode` struct linked to the passed one.
+ *
+ * @param node Receives a pointer to the previous `ZyanListNode` struct linked to the passed
+ * one.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanListGetPrevNode(const ZyanListNode** node);
+
+/**
+ * @brief Receives a pointer to the next `ZyanListNode` struct linked to the passed one.
+ *
+ * @param node Receives a pointer to the next `ZyanListNode` struct linked to the passed one.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanListGetNextNode(const ZyanListNode** node);
+
+/**
+ * @brief Returns a constant pointer to the data of the given `node`.
+ *
+ * @param node A pointer to the `ZyanListNode` struct.
+ *
+ * @return A constant pointer to the the data of the given `node` or `ZYAN_NULL`, if an error
+ * occured.
+ *
+ * Take a look at `ZyanListGetNodeDataEx`, if you need a function that returns a zyan status code.
+ */
+ZYCORE_EXPORT const void* ZyanListGetNodeData(const ZyanListNode* node);
+
+/**
+ * @brief Returns a constant pointer to the data of the given `node`..
+ *
+ * @param node A pointer to the `ZyanListNode` struct.
+ * @param value Receives a constant pointer to the data of the given `node`.
+ *
+ * Take a look at `ZyanListGetNodeData`, if you need a function that directly returns a pointer.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanListGetNodeDataEx(const ZyanListNode* node, const void** value);
+
+/**
+ * @brief Returns a mutable pointer to the data of the given `node`.
+ *
+ * @param node A pointer to the `ZyanListNode` struct.
+ *
+ * @return A mutable pointer to the the data of the given `node` or `ZYAN_NULL`, if an error
+ * occured.
+ *
+ * Take a look at `ZyanListGetPointerMutableEx` instead, if you need a function that returns a
+ * zyan status code.
+ */
+ZYCORE_EXPORT void* ZyanListGetNodeDataMutable(const ZyanListNode* node);
+
+/**
+ * @brief Returns a mutable pointer to the data of the given `node`..
+ *
+ * @param node A pointer to the `ZyanListNode` struct.
+ * @param value Receives a mutable pointer to the data of the given `node`.
+ *
+ * Take a look at `ZyanListGetNodeDataMutable`, if you need a function that directly returns a
+ * pointer.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanListGetNodeDataMutableEx(const ZyanListNode* node, void** value);
+
+/**
+ * @brief Assigns a new data value to the given `node`.
+ *
+ * @param list A pointer to the `ZyanList` instance.
+ * @param node A pointer to the `ZyanListNode` struct.
+ * @param value The value to assign.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanListSetNodeData(const ZyanList* list, const ZyanListNode* node,
+ const void* value);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Insertion */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Adds a new `item` to the end of the list.
+ *
+ * @param list A pointer to the `ZyanList` instance.
+ * @param item A pointer to the item to add.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanListPushBack(ZyanList* list, const void* item);
+
+/**
+ * @brief Adds a new `item` to the beginning of the list.
+ *
+ * @param list A pointer to the `ZyanList` instance.
+ * @param item A pointer to the item to add.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanListPushFront(ZyanList* list, const void* item);
+
+/**
+ * @brief Constructs an `item` in-place at the end of the list.
+ *
+ * @param list A pointer to the `ZyanList` instance.
+ * @param item Receives a pointer to the new item.
+ * @param constructor The constructor callback or `ZYAN_NULL`. The new item will be in
+ * undefined state, if no constructor was passed.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanListEmplaceBack(ZyanList* list, void** item,
+ ZyanMemberFunction constructor);
+
+/**
+ * @brief Constructs an `item` in-place at the beginning of the list.
+ *
+ * @param list A pointer to the `ZyanList` instance.
+ * @param item Receives a pointer to the new item.
+ * @param constructor The constructor callback or `ZYAN_NULL`. The new item will be in
+ * undefined state, if no constructor was passed.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanListEmplaceFront(ZyanList* list, void** item,
+ ZyanMemberFunction constructor);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Deletion */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Removes the last element of the list.
+ *
+ * @param list A pointer to the `ZyanList` instance.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanListPopBack(ZyanList* list);
+
+/**
+ * @brief Removes the firstelement of the list.
+ *
+ * @param list A pointer to the `ZyanList` instance.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanListPopFront(ZyanList* list);
+
+/**
+ * @brief Removes the given `node` from the list.
+ *
+ * @param list A pointer to the `ZyanList` instance.
+ * @param node A pointer to the `ZyanListNode` struct.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanListRemove(ZyanList* list, const ZyanListNode* node);
+
+/**
+ * @brief Removes multiple nodes from the list.
+ *
+ * @param list A pointer to the `ZyanList` instance.
+ * @param first A pointer to the first node.
+ * @param last A pointer to the last node.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanListRemoveRange(ZyanList* list, const ZyanListNode* first,
+ const ZyanListNode* last);
+
+/**
+ * @brief Erases all elements of the list.
+ *
+ * @param list A pointer to the `ZyanList` instance.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanListClear(ZyanList* list);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Searching */
+/* ---------------------------------------------------------------------------------------------- */
+
+// TODO:
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Memory management */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Resizes the given `ZyanList` instance.
+ *
+ * @param list A pointer to the `ZyanList` instance.
+ * @param size The new size of the list.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanListResize(ZyanList* list, ZyanUSize size);
+
+/**
+ * @brief Resizes the given `ZyanList` instance.
+ *
+ * @param list A pointer to the `ZyanList` instance.
+ * @param size The new size of the list.
+ * @param initializer A pointer to a value to be used as initializer for new items.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanListResizeEx(ZyanList* list, ZyanUSize size, const void* initializer);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Information */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Returns the current size of the list.
+ *
+ * @param list A pointer to the `ZyanList` instance.
+ * @param size Receives the size of the list.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanListGetSize(const ZyanList* list, ZyanUSize* size);
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZYCORE_VECTOR_H */
diff --git a/detours/detours/zydis/dependencies/zycore/include/Zycore/Object.h b/detours/detours/zydis/dependencies/zycore/include/Zycore/Object.h
new file mode 100644
index 0000000..bbd0535
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/include/Zycore/Object.h
@@ -0,0 +1,84 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+/**
+ * @file
+ * @brief Defines some generic object-related datatypes.
+ */
+
+#ifndef ZYCORE_OBJECT_H
+#define ZYCORE_OBJECT_H
+
+#include
+#include
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ============================================================================================== */
+/* Enums and types */
+/* ============================================================================================== */
+
+/**
+ * @brief Defines the `ZyanMemberProcedure` function prototype.
+ *
+ * @param object A pointer to the object.
+ */
+typedef void (*ZyanMemberProcedure)(void* object);
+
+/**
+ * @brief Defines the `ZyanConstMemberProcedure` function prototype.
+ *
+ * @param object A pointer to the object.
+ */
+typedef void (*ZyanConstMemberProcedure)(const void* object);
+
+/**
+ * @brief Defines the `ZyanMemberFunction` function prototype.
+ *
+ * @param object A pointer to the object.
+ *
+ * @return A zyan status code.
+ */
+typedef ZyanStatus (*ZyanMemberFunction)(void* object);
+
+/**
+ * @brief Defines the `ZyanConstMemberFunction` function prototype.
+ *
+ * @param object A pointer to the object.
+ *
+ * @return A zyan status code.
+ */
+typedef ZyanStatus (*ZyanConstMemberFunction)(const void* object);
+
+/* ============================================================================================== */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZYCORE_OBJECT_H */
diff --git a/detours/detours/zydis/dependencies/zycore/include/Zycore/Status.h b/detours/detours/zydis/dependencies/zycore/include/Zycore/Status.h
new file mode 100644
index 0000000..6b16068
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/include/Zycore/Status.h
@@ -0,0 +1,241 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zyan-C)
+
+ Original Author : Florian Bernd, Joel Hoener
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+/**
+ * @file
+ * @brief Status code definitions and check macros.
+ */
+
+#ifndef ZYCORE_STATUS_H
+#define ZYCORE_STATUS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include
+
+/* ============================================================================================== */
+/* Enums and types */
+/* ============================================================================================== */
+
+/**
+ * @brief Defines the `ZyanStatus` datatype.
+ */
+typedef ZyanU32 ZyanStatus;
+
+/* ============================================================================================== */
+/* Macros */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Definition */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Defines a zyan status code.
+ *
+ * @param error `1`, if the status code signals an error or `0`, if not.
+ * @param module The module id.
+ * @param code The actual code.
+ *
+ * @return The zyan status code.
+ */
+#define ZYAN_MAKE_STATUS(error, module, code) \
+ (ZyanStatus)((((error) & 0x01) << 31) | (((module) & 0x7FF) << 20) | ((code) & 0xFFFFF))
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Checks */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Checks if a zyan operation was successfull.
+ *
+ * @param status The zyan status-code to check.
+ *
+ * @return `ZYAN_TRUE`, if the operation succeeded or `ZYAN_FALSE`, if not.
+ */
+#define ZYAN_SUCCESS(status) \
+ (!((status) & 0x80000000))
+
+/**
+ * @brief Checks if a zyan operation failed.
+ *
+ * @param status The zyan status-code to check.
+ *
+ * @return `ZYAN_TRUE`, if the operation failed or `ZYAN_FALSE`, if not.
+ */
+#define ZYAN_FAILED(status) \
+ ((status) & 0x80000000)
+
+/**
+ * @brief Checks if a zyan operation was successfull and returns with the status-code, if not.
+ *
+ * @param status The zyan status-code to check.
+ */
+#define ZYAN_CHECK(status) \
+ do \
+ { \
+ const ZyanStatus status_047620348 = (status); \
+ if (!ZYAN_SUCCESS(status_047620348)) \
+ { \
+ return status_047620348; \
+ } \
+ } while (0)
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Information */
+/* ---------------------------------------------------------------------------------------------- */
+
+ /**
+ * @brief Returns the module id of a zyan status-code.
+ *
+ * @param status The zyan status-code.
+ *
+ * @return The module id of the zyan status-code.
+ */
+#define ZYAN_STATUS_MODULE(status) \
+ (((status) >> 20) & 0x7FF)
+
+ /**
+ * @brief Returns the code of a zyan status-code.
+ *
+ * @param status The zyan status-code.
+ *
+ * @return The code of the zyan status-code.
+ */
+#define ZYAN_STATUS_CODE(status) \
+ ((status) & 0xFFFFF)
+
+/* ============================================================================================== */
+/* Status codes */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Module IDs */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief The zycore generic module id.
+ */
+#define ZYAN_MODULE_ZYCORE 0x001
+
+/**
+ * @brief The base module id for user-defined status codes.
+ */
+#define ZYAN_MODULE_USER 0x3FF
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Status codes */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief The operation completed successfully.
+ */
+#define ZYAN_STATUS_SUCCESS \
+ ZYAN_MAKE_STATUS(0, ZYAN_MODULE_ZYCORE, 0x00)
+
+/**
+ * @brief The operation failed with an generic error.
+ */
+#define ZYAN_STATUS_FAILED \
+ ZYAN_MAKE_STATUS(1, ZYAN_MODULE_ZYCORE, 0x01)
+
+/**
+ * @brief The operation completed successfully and returned `ZYAN_TRUE`.
+ */
+#define ZYAN_STATUS_TRUE \
+ ZYAN_MAKE_STATUS(0, ZYAN_MODULE_ZYCORE, 0x02)
+
+/**
+ * @brief The operation completed successfully and returned `ZYAN_FALSE`.
+ */
+#define ZYAN_STATUS_FALSE \
+ ZYAN_MAKE_STATUS(0, ZYAN_MODULE_ZYCORE, 0x03)
+
+/**
+ * @brief An invalid argument was passed to a function.
+ */
+#define ZYAN_STATUS_INVALID_ARGUMENT \
+ ZYAN_MAKE_STATUS(1, ZYAN_MODULE_ZYCORE, 0x04)
+
+/**
+ * @brief An attempt was made to perform an invalid operation.
+ */
+#define ZYAN_STATUS_INVALID_OPERATION \
+ ZYAN_MAKE_STATUS(1, ZYAN_MODULE_ZYCORE, 0x05)
+
+/**
+ * @brief Insufficient privileges to perform the requested operation.
+ */
+#define ZYAN_STATUS_ACCESS_DENIED \
+ ZYAN_MAKE_STATUS(1, ZYAN_MODULE_ZYCORE, 0x06)
+
+/**
+ * @brief The requested entity was not found.
+ */
+#define ZYAN_STATUS_NOT_FOUND \
+ ZYAN_MAKE_STATUS(1, ZYAN_MODULE_ZYCORE, 0x07)
+
+/**
+ * @brief An index passed to a function was out of bounds.
+ */
+#define ZYAN_STATUS_OUT_OF_RANGE \
+ ZYAN_MAKE_STATUS(1, ZYAN_MODULE_ZYCORE, 0x08)
+
+/**
+ * @brief A buffer passed to a function was too small to complete the requested operation.
+ */
+#define ZYAN_STATUS_INSUFFICIENT_BUFFER_SIZE \
+ ZYAN_MAKE_STATUS(1, ZYAN_MODULE_ZYCORE, 0x09)
+
+/**
+ * @brief Insufficient memory to perform the operation.
+ */
+#define ZYAN_STATUS_NOT_ENOUGH_MEMORY \
+ ZYAN_MAKE_STATUS(1, ZYAN_MODULE_ZYCORE, 0x0A)
+
+/**
+ * @brief An unknown error occured during a system function call.
+ */
+#define ZYAN_STATUS_BAD_SYSTEMCALL \
+ ZYAN_MAKE_STATUS(1, ZYAN_MODULE_ZYCORE, 0x0B)
+
+/**
+ * @brief The process ran out of resources while performing an operation.
+ */
+#define ZYAN_STATUS_OUT_OF_RESOURCES \
+ ZYAN_MAKE_STATUS(1, ZYAN_MODULE_ZYCORE, 0x0C)
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZYCORE_STATUS_H */
diff --git a/detours/detours/zydis/dependencies/zycore/include/Zycore/String.h b/detours/detours/zydis/dependencies/zycore/include/Zycore/String.h
new file mode 100644
index 0000000..8dfbb70
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/include/Zycore/String.h
@@ -0,0 +1,1000 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+/**
+ * @file
+ * @brief Implements a string type.
+ */
+
+#ifndef ZYCORE_STRING_H
+#define ZYCORE_STRING_H
+
+#include
+#include
+#include
+#include
+#include
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ============================================================================================== */
+/* Constants */
+/* ============================================================================================== */
+
+/**
+ * @brief The initial minimum capacity (number of characters) for all dynamically allocated
+ * string instances - not including the terminating '\0'-character.
+ */
+#define ZYAN_STRING_MIN_CAPACITY 32
+
+/**
+ * @brief The default growth factor for all string instances.
+ */
+#define ZYAN_STRING_DEFAULT_GROWTH_FACTOR 2.00f
+
+/**
+ * @brief The default shrink threshold for all string instances.
+ */
+#define ZYAN_STRING_DEFAULT_SHRINK_THRESHOLD 0.25f
+
+/* ============================================================================================== */
+/* Enums and types */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* String flags */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Defines the `ZyanStringFlags` datatype.
+ */
+typedef ZyanU8 ZyanStringFlags;
+
+/**
+ * @brief The string uses a custom user-defined buffer with a fixed capacity.
+ */
+#define ZYAN_STRING_HAS_FIXED_CAPACITY 0x01 // (1 << 0)
+
+/* ---------------------------------------------------------------------------------------------- */
+/* String */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Defines the `ZyanString` struct.
+ *
+ * The `ZyanString` type is implemented as a size-prefixed string - which allows for a lot of
+ * performance optimizations.
+ * Nevertheless null-termination is guaranteed at all times to provide maximum compatibility with
+ * default C-style strings (use `ZyanStringGetData` to access the C-style string).
+ *
+ * All fields in this struct should be considered as "private". Any changes may lead to unexpected
+ * behavior.
+ */
+typedef struct ZyanString_
+{
+ /**
+ * @brief String flags.
+ */
+ ZyanStringFlags flags;
+ /**
+ * @brief The vector that contains the actual string.
+ */
+ ZyanVector vector;
+} ZyanString;
+
+/* ---------------------------------------------------------------------------------------------- */
+/* View */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Defines the `ZyanStringView` struct.
+ *
+ * The `ZyanStringView` type provides a view inside a string (`ZyanString` instances, null-
+ * terminated C-style strings, or even not-null-terminated custom strings). A view is immutable
+ * by design and can't be directly converted to a C-style string.
+ *
+ * Views might become invalid (e.g. pointing to invalid memory), if the underlying string gets
+ * destroyed or resized.
+ *
+ * The `ZYAN_STRING_TO_VIEW` macro can be used to cast a `ZyanString` to a `ZyanStringView` pointer
+ * without any runtime overhead.
+ * Casting a view to a normal string is not supported and will lead to unexpected behavior (use
+ * `ZyanStringDuplicate` to create a deep-copy instead).
+ *
+ * All fields in this struct should be considered as "private". Any changes may lead to unexpected
+ * behavior.
+ */
+typedef struct ZyanStringView_
+{
+ /**
+ * @brief The string data.
+ *
+ * The view internally re-uses the normal string struct to allow casts without any runtime
+ * overhead.
+ */
+ ZyanString string;
+} ZyanStringView;
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+/* Macros */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* General */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Defines an uninitialized `ZyanString` instance.
+ */
+#define ZYAN_STRING_INITIALIZER \
+ { \
+ /* flags */ 0, \
+ /* vector */ ZYAN_VECTOR_INITIALIZER \
+ }
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Helper macros */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Casts a `ZyanString` pointer to a constant `ZyanStringView` pointer.
+ */
+#define ZYAN_STRING_TO_VIEW(string) (const ZyanStringView*)(string)
+
+/**
+ * @brief Defines a `ZyanStringView` struct that provides a view into a static C-style string.
+ *
+ * @param string The C-style string.
+ */
+#define ZYAN_DEFINE_STRING_VIEW(string) \
+ { \
+ /* string */ \
+ { \
+ /* flags */ 0, \
+ /* vector */ \
+ { \
+ /* allocator */ ZYAN_NULL, \
+ /* growth_factor */ 1.0f, \
+ /* shrink_threshold */ 0.0f, \
+ /* size */ sizeof(string), \
+ /* capacity */ sizeof(string), \
+ /* element_size */ sizeof(char), \
+ /* destructor */ ZYAN_NULL, \
+ /* data */ (char*)(string) \
+ } \
+ } \
+ }
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+/* Exported functions */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Constructor and destructor */
+/* ---------------------------------------------------------------------------------------------- */
+
+#ifndef ZYAN_NO_LIBC
+
+/**
+ * @brief Initializes the given `ZyanString` instance.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ * @param capacity The initial capacity (number of characters).
+ *
+ * @return A zyan status code.
+ *
+ * The memory for the string is dynamically allocated by the default allocator using the default
+ * growth factor of `2.0f` and the default shrink threshold of `0.25f`.
+ *
+ * The allocated buffer will be at least one character larger than the given `capacity`, to reserve
+ * space for the terminating '\0'.
+ *
+ * Finalization with `ZyanStringDestroy` is required for all strings created by this function.
+ */
+ZYCORE_EXPORT ZYAN_REQUIRES_LIBC ZyanStatus ZyanStringInit(ZyanString* string, ZyanUSize capacity);
+
+#endif // ZYAN_NO_LIBC
+
+/**
+ * @brief Initializes the given `ZyanString` instance and sets a custom `allocator` and memory
+ * allocation/deallocation parameters.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ * @param capacity The initial capacity (number of characters).
+ * @param allocator A pointer to a `ZyanAllocator` instance.
+ * @param growth_factor The growth factor (from `1.0f` to `x.xf`).
+ * @param shrink_threshold The shrink threshold (from `0.0f` to `1.0f`).
+ *
+ * @return A zyan status code.
+ *
+ * A growth factor of `1.0f` disables overallocation and a shrink threshold of `0.0f` disables
+ * dynamic shrinking.
+ *
+ * The allocated buffer will be at least one character larger than the given `capacity`, to reserve
+ * space for the terminating '\0'.
+ *
+ * Finalization with `ZyanStringDestroy` is required for all strings created by this function.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringInitEx(ZyanString* string, ZyanUSize capacity,
+ ZyanAllocator* allocator, float growth_factor, float shrink_threshold);
+
+/**
+ * @brief Initializes the given `ZyanString` instance and configures it to use a custom user
+ * defined buffer with a fixed size.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ * @param buffer A pointer to the buffer that is used as storage for the string.
+ * @param capacity The maximum capacity (number of characters) of the buffer, including
+ * the terminating '\0'.
+ *
+ * @return A zyan status code.
+ *
+ * Finalization is not required for strings created by this function.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringInitCustomBuffer(ZyanString* string, char* buffer,
+ ZyanUSize capacity);
+
+/**
+ * @brief Destroys the given `ZyanString` instance.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ *
+ * @return A zyan status code.
+ *
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringDestroy(ZyanString* string);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Duplication */
+/* ---------------------------------------------------------------------------------------------- */
+
+#ifndef ZYAN_NO_LIBC
+
+/**
+ * @brief Initializes a new `ZyanString` instance by duplicating an existing string.
+ *
+ * @param destination A pointer to the (uninitialized) destination `ZyanString` instance.
+ * @param source A pointer to the source string.
+ * @param capacity The initial capacity (number of characters).
+ *
+ * This value is automatically adjusted to the size of the source string, if
+ * a smaller value was passed.
+ *
+ * @return A zyan status code.
+ *
+ * The behavior of this function is undefined, if `source` is a view into the `destination`
+ * string or `destination` points to an already initialized `ZyanString` instance.
+ *
+ * The memory for the string is dynamically allocated by the default allocator using the default
+ * growth factor of `2.0f` and the default shrink threshold of `0.25f`.
+ *
+ * The allocated buffer will be at least one character larger than the given `capacity`, to reserve
+ * space for the terminating '\0'.
+ *
+ * Finalization with `ZyanStringDestroy` is required for all strings created by this function.
+ */
+ZYCORE_EXPORT ZYAN_REQUIRES_LIBC ZyanStatus ZyanStringDuplicate(ZyanString* destination,
+ const ZyanStringView* source, ZyanUSize capacity);
+
+#endif // ZYAN_NO_LIBC
+
+/**
+ * @brief Initializes a new `ZyanString` instance by duplicating an existing string and sets a
+ * custom `allocator` and memory allocation/deallocation parameters.
+ *
+ * @param destination A pointer to the (uninitialized) destination `ZyanString` instance.
+ * @param source A pointer to the source string.
+ * @param capacity The initial capacity (number of characters).
+
+ * This value is automatically adjusted to the size of the source
+ * string, if a smaller value was passed.
+ * @param allocator A pointer to a `ZyanAllocator` instance.
+ * @param growth_factor The growth factor (from `1.0f` to `x.xf`).
+ * @param shrink_threshold The shrink threshold (from `0.0f` to `1.0f`).
+ *
+ * @return A zyan status code.
+ *
+ * The behavior of this function is undefined, if `source` is a view into the `destination`
+ * string or `destination` points to an already initialized `ZyanString` instance.
+ *
+ * A growth factor of `1.0f` disables overallocation and a shrink threshold of `0.0f` disables
+ * dynamic shrinking.
+ *
+ * The allocated buffer will be at least one character larger than the given `capacity`, to reserve
+ * space for the terminating '\0'.
+ *
+ * Finalization with `ZyanStringDestroy` is required for all strings created by this function.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringDuplicateEx(ZyanString* destination,
+ const ZyanStringView* source, ZyanUSize capacity, ZyanAllocator* allocator,
+ float growth_factor, float shrink_threshold);
+
+/**
+ * @brief Initializes a new `ZyanString` instance by duplicating an existing string and
+ * configures it to use a custom user defined buffer with a fixed size.
+ *
+ * @param destination A pointer to the (uninitialized) destination `ZyanString` instance.
+ * @param source A pointer to the source string.
+ * @param buffer A pointer to the buffer that is used as storage for the string.
+ * @param capacity The maximum capacity (number of characters) of the buffer, including the
+ * terminating '\0'.
+
+ * This function will fail, if the capacity of the buffer is less or equal to
+ * the size of the source string.
+ *
+ * @return A zyan status code.
+ *
+ * The behavior of this function is undefined, if `source` is a view into the `destination`
+ * string or `destination` points to an already initialized `ZyanString` instance.
+ *
+ * Finalization is not required for strings created by this function.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringDuplicateCustomBuffer(ZyanString* destination,
+ const ZyanStringView* source, char* buffer, ZyanUSize capacity);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Concatenation */
+/* ---------------------------------------------------------------------------------------------- */
+
+#ifndef ZYAN_NO_LIBC
+
+/**
+ * @brief Initializes a new `ZyanString` instance by concatenating two existing strings.
+ *
+ * @param destination A pointer to the (uninitialized) destination `ZyanString` instance.
+ *
+ * This function will fail, if the destination `ZyanString` instance equals
+ * one of the source strings.
+ * @param s1 A pointer to the first source string.
+ * @param s2 A pointer to the second source string.
+ * @param capacity The initial capacity (number of characters).
+
+ * This value is automatically adjusted to the combined size of the source
+ * strings, if a smaller value was passed.
+ *
+ * @return A zyan status code.
+ *
+ * The behavior of this function is undefined, if `s1` or `s2` are views into the `destination`
+ * string or `destination` points to an already initialized `ZyanString` instance.
+ *
+ * The memory for the string is dynamically allocated by the default allocator using the default
+ * growth factor of `2.0f` and the default shrink threshold of `0.25f`.
+ *
+ * The allocated buffer will be at least one character larger than the given `capacity`, to reserve
+ * space for the terminating '\0'.
+ *
+ * Finalization with `ZyanStringDestroy` is required for all strings created by this function.
+ */
+ZYCORE_EXPORT ZYAN_REQUIRES_LIBC ZyanStatus ZyanStringConcat(ZyanString* destination,
+ const ZyanStringView* s1, const ZyanStringView* s2, ZyanUSize capacity);
+
+#endif // ZYAN_NO_LIBC
+
+/**
+ * @brief Initializes a new `ZyanString` instance by concatenating two existing strings and sets
+ * a custom `allocator` and memory allocation/deallocation parameters.
+ *
+ * @param destination A pointer to the (uninitialized) destination `ZyanString` instance.
+ *
+ * This function will fail, if the destination `ZyanString` instance
+ * equals one of the source strings.
+ * @param s1 A pointer to the first source string.
+ * @param s2 A pointer to the second source string.
+ * @param capacity The initial capacity (number of characters).
+ *
+ * This value is automatically adjusted to the combined size of the
+ * source strings, if a smaller value was passed.
+ * @param allocator A pointer to a `ZyanAllocator` instance.
+ * @param growth_factor The growth factor (from `1.0f` to `x.xf`).
+ * @param shrink_threshold The shrink threshold (from `0.0f` to `1.0f`).
+ *
+ * @return A zyan status code.
+ *
+ * The behavior of this function is undefined, if `s1` or `s2` are views into the `destination`
+ * string or `destination` points to an already initialized `ZyanString` instance.
+ *
+ * A growth factor of `1.0f` disables overallocation and a shrink threshold of `0.0f` disables
+ * dynamic shrinking.
+ *
+ * The allocated buffer will be at least one character larger than the given `capacity`, to reserve
+ * space for the terminating '\0'.
+ *
+ * Finalization with `ZyanStringDestroy` is required for all strings created by this function.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringConcatEx(ZyanString* destination, const ZyanStringView* s1,
+ const ZyanStringView* s2, ZyanUSize capacity, ZyanAllocator* allocator, float growth_factor,
+ float shrink_threshold);
+
+/**
+ * @brief Initializes a new `ZyanString` instance by concatenating two existing strings and
+ * configures it to use a custom user defined buffer with a fixed size.
+ *
+ * @param destination A pointer to the (uninitialized) destination `ZyanString` instance.
+ *
+ * This function will fail, if the destination `ZyanString` instance equals
+ * one of the source strings.
+ * @param s1 A pointer to the first source string.
+ * @param s2 A pointer to the second source string.
+ * @param buffer A pointer to the buffer that is used as storage for the string.
+ * @param capacity The maximum capacity (number of characters) of the buffer.
+ *
+ * This function will fail, if the capacity of the buffer is less or equal to
+ * the combined size of the source strings.
+ *
+ * @return A zyan status code.
+ *
+ * The behavior of this function is undefined, if `s1` or `s2` are views into the `destination`
+ * string or `destination` points to an already initialized `ZyanString` instance.
+ *
+ * Finalization is not required for strings created by this function.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringConcatCustomBuffer(ZyanString* destination,
+ const ZyanStringView* s1, const ZyanStringView* s2, char* buffer, ZyanUSize capacity);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Views */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Returns a view inside an existing view/string.
+ *
+ * @param view A pointer to the `ZyanStringView` instance.
+ * @param source A pointer to the source string.
+ *
+ * @return A zyan status code.
+ *
+ * The `ZYAN_STRING_TO_VEW` macro can be used to pass any `ZyanString` instance as value for the
+ * `source` string.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringViewInsideView(ZyanStringView* view,
+ const ZyanStringView* source);
+
+/**
+ * @brief Returns a view inside an existing view/string starting from the given `index`.
+ *
+ * @param view A pointer to the `ZyanStringView` instance.
+ * @param source A pointer to the source string.
+ * @param index The start index.
+ * @param count The number of characters.
+ *
+ * @return A zyan status code.
+ *
+ * The `ZYAN_STRING_TO_VEW` macro can be used to pass any `ZyanString` instance as value for the
+ * `source` string.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringViewInsideViewEx(ZyanStringView* view,
+ const ZyanStringView* source, ZyanUSize index, ZyanUSize count);
+
+/**
+ * @brief Returns a view inside a null-terminated C-style string.
+ *
+ * @param view A pointer to the `ZyanStringView` instance.
+ * @param string The C-style string.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringViewInsideBuffer(ZyanStringView* view, const char* string);
+
+/**
+ * @brief Returns a view inside a character buffer with custom length.
+ *
+ * @param view A pointer to the `ZyanStringView` instance.
+ * @param buffer A pointer to the buffer containing the string characters.
+ * @param length The length of the string (number of characters).
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringViewInsideBufferEx(ZyanStringView* view, const char* buffer,
+ ZyanUSize length);
+
+/**
+ * @brief Returns the size (number of characters) of the view.
+ *
+ * @param view A pointer to the `ZyanStringView` instance.
+ * @param size Receives the size (number of characters) of the view.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringViewGetSize(const ZyanStringView* view, ZyanUSize* size);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Character access */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Returns the character at the given `index`.
+ *
+ * @param string A pointer to the `ZyanStringView` instance.
+ * @param index The character index.
+ * @param value Receives the desired character of the string.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringGetChar(const ZyanStringView* string, ZyanUSize index,
+ char* value);
+
+/**
+ * @brief Returns a pointer to the character at the given `index`.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ * @param index The character index.
+ * @param value Receives a pointer to the desired character in the string.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringGetCharMutable(ZyanString* string, ZyanUSize index,
+ char** value);
+
+/**
+ * @brief Assigns a new value to the character at the given `index`.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ * @param index The character index.
+ * @param value The character to assign.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringSetChar(ZyanString* string, ZyanUSize index, char value);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Insertion */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Inserts the content of the source string in the destination string at the given `index`.
+ *
+ * @param destination The destination string.
+ * @param index The insert index.
+ * @param source The source string.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringInsert(ZyanString* destination, ZyanUSize index,
+ const ZyanStringView* source);
+
+/**
+ * @brief Inserts `count` characters of the source string in the destination string at the given
+ * `index`.
+ *
+ * @param destination The destination string.
+ * @param destination_index The insert index.
+ * @param source The source string.
+ * @param source_index The index of the first character to be inserted from the source
+ * string.
+ * @param count The number of chars to insert from the source string.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringInsertEx(ZyanString* destination, ZyanUSize destination_index,
+ const ZyanStringView* source, ZyanUSize source_index, ZyanUSize count);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Appending */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Appends the content of the source string to the end of the destination string.
+ *
+ * @param destination The destination string.
+ * @param source The source string.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringAppend(ZyanString* destination, const ZyanStringView* source);
+
+/**
+ * @brief Appends `count` characters of the source string to the end of the destination string.
+ *
+ * @param destination The destination string.
+ * @param source The source string.
+ * @param source_index The index of the first character to be appended from the source string.
+ * @param count The number of chars to append from the source string.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringAppendEx(ZyanString* destination, const ZyanStringView* source,
+ ZyanUSize source_index, ZyanUSize count);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Deletion */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Deletes characters from the given string, starting at `index`.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ * @param index The index of the first character to delete.
+ * @param count The number of characters to delete.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringDelete(ZyanString* string, ZyanUSize index, ZyanUSize count);
+
+/**
+ * @brief Deletes all remaining characters from the given string, starting at `index`.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ * @param index The index of the first character to delete.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringTruncate(ZyanString* string, ZyanUSize index);
+
+/**
+ * @brief Erases the given string.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringClear(ZyanString* string);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Searching */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Searches for the first occurrence of `needle` in the given `haystack` starting from the
+ * left.
+ *
+ * @param haystack The string to search in.
+ * @param needle The sub-string to search for.
+ * @param found_index A pointer to a variable that receives the index of the first occurrence of
+ * `needle`.
+ *
+ * @return `ZYAN_STATUS_TRUE`, if the needle was found, `ZYAN_STATUS_FALSE`, if not, or another
+ * zyan status code, if an error occured.
+ *
+ * The `found_index` is set to `-1`, if the needle was not found.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringLPos(const ZyanStringView* haystack,
+ const ZyanStringView* needle, ZyanISize* found_index);
+
+/**
+ * @brief Searches for the first occurrence of `needle` in the given `haystack` starting from the
+ * left.
+ *
+ * @param haystack The string to search in.
+ * @param needle The sub-string to search for.
+ * @param found_index A pointer to a variable that receives the index of the first occurrence of
+ * `needle`.
+ * @param index The start index.
+ * @param count The maximum number of characters to iterate, beginning from the start
+ * `index`.
+ *
+ * @return `ZYAN_STATUS_TRUE`, if the needle was found, `ZYAN_STATUS_FALSE`, if not, or another
+ * zyan status code, if an error occured.
+ *
+ * The `found_index` is set to `-1`, if the needle was not found.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringLPosEx(const ZyanStringView* haystack,
+ const ZyanStringView* needle, ZyanISize* found_index, ZyanUSize index, ZyanUSize count);
+
+/**
+ * @brief Performs a case-insensitive search for the first occurrence of `needle` in the given
+ * `haystack` starting from the left.
+ *
+ * @param haystack The string to search in.
+ * @param needle The sub-string to search for.
+ * @param found_index A pointer to a variable that receives the index of the first occurrence of
+ * `needle`.
+ *
+ * @return `ZYAN_STATUS_TRUE`, if the needle was found, `ZYAN_STATUS_FALSE`, if not, or another
+ * zyan status code, if an error occured.
+ *
+ * The `found_index` is set to `-1`, if the needle was not found.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringLPosI(const ZyanStringView* haystack,
+ const ZyanStringView* needle, ZyanISize* found_index);
+
+/**
+ * @brief Performs a case-insensitive search for the first occurrence of `needle` in the given
+ * `haystack` starting from the left.
+ *
+ * @param haystack The string to search in.
+ * @param needle The sub-string to search for.
+ * @param found_index A pointer to a variable that receives the index of the first occurrence of
+ * `needle`.
+ * @param index The start index.
+ * @param count The maximum number of characters to iterate, beginning from the start
+ * `index`.
+ *
+ * @return `ZYAN_STATUS_TRUE`, if the needle was found, `ZYAN_STATUS_FALSE`, if not, or another
+ * zyan status code, if an error occured.
+ *
+ * The `found_index` is set to `-1`, if the needle was not found.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringLPosIEx(const ZyanStringView* haystack,
+ const ZyanStringView* needle, ZyanISize* found_index, ZyanUSize index, ZyanUSize count);
+
+/**
+ * @brief Searches for the first occurrence of `needle` in the given `haystack` starting from the
+ * right.
+ *
+ * @param haystack The string to search in.
+ * @param needle The sub-string to search for.
+ * @param found_index A pointer to a variable that receives the index of the first occurrence of
+ * `needle`.
+ *
+ * @return `ZYAN_STATUS_TRUE`, if the needle was found, `ZYAN_STATUS_FALSE`, if not, or another
+ * zyan status code, if an error occured.
+ *
+ * The `found_index` is set to `-1`, if the needle was not found.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringRPos(const ZyanStringView* haystack,
+ const ZyanStringView* needle, ZyanISize* found_index);
+
+/**
+ * @brief Searches for the first occurrence of `needle` in the given `haystack` starting from the
+ * right.
+ *
+ * @param haystack The string to search in.
+ * @param needle The sub-string to search for.
+ * @param found_index A pointer to a variable that receives the index of the first occurrence of
+ * `needle`.
+ * @param index The start index.
+ * @param count The maximum number of characters to iterate, beginning from the start
+ * `index`.
+ *
+ * @return `ZYAN_STATUS_TRUE`, if the needle was found, `ZYAN_STATUS_FALSE`, if not, or another
+ * zyan status code, if an error occured.
+ *
+ * The `found_index` is set to `-1`, if the needle was not found.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringRPosEx(const ZyanStringView* haystack,
+ const ZyanStringView* needle, ZyanISize* found_index, ZyanUSize index, ZyanUSize count);
+
+/**
+ * @brief Performs a case-insensitive search for the first occurrence of `needle` in the given
+ * `haystack` starting from the right.
+ *
+ * @param haystack The string to search in.
+ * @param needle The sub-string to search for.
+ * @param found_index A pointer to a variable that receives the index of the first occurrence of
+ * `needle`.
+ *
+ * @return `ZYAN_STATUS_TRUE`, if the needle was found, `ZYAN_STATUS_FALSE`, if not, or another
+ * zyan status code, if an error occured.
+ *
+ * The `found_index` is set to `-1`, if the needle was not found.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringRPosI(const ZyanStringView* haystack,
+ const ZyanStringView* needle, ZyanISize* found_index);
+
+/**
+ * @brief Performs a case-insensitive search for the first occurrence of `needle` in the given
+ * `haystack` starting from the right.
+ *
+ * @param haystack The string to search in.
+ * @param needle The sub-string to search for.
+ * @param found_index A pointer to a variable that receives the index of the first occurrence of
+ * `needle`.
+ * @param index The start index.
+ * @param count The maximum number of characters to iterate, beginning from the start
+ * `index`.
+ *
+ * @return `ZYAN_STATUS_TRUE`, if the needle was found, `ZYAN_STATUS_FALSE`, if not, or another
+ * zyan status code, if an error occured.
+ *
+ * The `found_index` is set to `-1`, if the needle was not found.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringRPosIEx(const ZyanStringView* haystack,
+ const ZyanStringView* needle, ZyanISize* found_index, ZyanUSize index, ZyanUSize count);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Comparing */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Compares two strings.
+ *
+ * @param s1 The first string
+ * @param s2 The second string.
+ * @param result Receives the comparison result.
+ *
+ * Values:
+ * - `result < 0` -> The first character that does not match has a lower value
+ * in `s1` than in `s2`.
+ * - `result == 0` -> The contents of both strings are equal.
+ * - `result > 0` -> The first character that does not match has a greater value
+ * in `s1` than in `s2`.
+ *
+ * @return `ZYAN_STATUS_TRUE`, if the strings are equal, `ZYAN_STATUS_FALSE`, if not, or another
+ * zyan status code, if an error occured.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringCompare(const ZyanStringView* s1, const ZyanStringView* s2,
+ ZyanI32* result);
+
+/**
+ * @brief Performs a case-insensitive comparison of two strings.
+ *
+ * @param s1 The first string
+ * @param s2 The second string.
+ * @param result Receives the comparison result.
+ *
+ * Values:
+ * - `result < 0` -> The first character that does not match has a lower value
+ * in `s1` than in `s2`.
+ * - `result == 0` -> The contents of both strings are equal.
+ * - `result > 0` -> The first character that does not match has a greater value
+ * in `s1` than in `s2`.
+ *
+ * @return `ZYAN_STATUS_TRUE`, if the strings are equal, `ZYAN_STATUS_FALSE`, if not, or another
+ * zyan status code, if an error occured.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringCompareI(const ZyanStringView* s1, const ZyanStringView* s2,
+ ZyanI32* result);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Case conversion */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Converts the given string to lowercase letters.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ *
+ * @return A zyan status code.
+ *
+ * This function will fail, if the `ZYAN_STRING_IS_IMMUTABLE` flag is set for the specified
+ * `ZyanString` instance.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringToLowerCase(ZyanString* string);
+
+/**
+ * @brief Converts `count` characters of the given string to lowercase letters.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ * @param index The start index.
+ * @param count The number of characters to convert, beginning from the start `index`.
+ *
+ * @return A zyan status code.
+ *
+ * This function will fail, if the `ZYAN_STRING_IS_IMMUTABLE` flag is set for the specified
+ * `ZyanString` instance.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringToLowerCaseEx(ZyanString* string, ZyanUSize index,
+ ZyanUSize count);
+
+/**
+ * @brief Converts the given string to uppercase letters.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ *
+ * @return A zyan status code.
+ *
+ * This function will fail, if the `ZYAN_STRING_IS_IMMUTABLE` flag is set for the specified
+ * `ZyanString` instance.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringToUpperCase(ZyanString* string);
+
+/**
+ * @brief Converts `count` characters of the given string to uppercase letters.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ * @param index The start index.
+ * @param count The number of characters to convert, beginning from the start `index`.
+ *
+ * @return A zyan status code.
+ *
+ * This function will fail, if the `ZYAN_STRING_IS_IMMUTABLE` flag is set for the specified
+ * `ZyanString` instance.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringToUpperCaseEx(ZyanString* string, ZyanUSize index,
+ ZyanUSize count);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Memory management */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Resizes the given `ZyanString` instance.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ * @param size The new size of the string.
+ *
+ * @return A zyan status code.
+ *
+ * This function will fail, if the `ZYAN_STRING_IS_IMMUTABLE` flag is set for the specified
+ * `ZyanString` instance.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringResize(ZyanString* string, ZyanUSize size);
+
+/**
+ * @brief Changes the capacity of the given `ZyanString` instance.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ * @param capacity The new minimum capacity of the string.
+ *
+ * @return A zyan status code.
+ *
+ * This function will fail, if the `ZYAN_STRING_IS_IMMUTABLE` flag is set for the specified
+ * `ZyanString` instance.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringReserve(ZyanString* string, ZyanUSize capacity);
+
+/**
+ * @brief Shrinks the capacity of the given string to match it's size.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ *
+ * @return A zyan status code.
+ *
+ * This function will fail, if the `ZYAN_STRING_IS_IMMUTABLE` flag is set for the specified
+ * `ZyanString` instance.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringShrinkToFit(ZyanString* string);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Information */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Returns the current capacity of the string.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ * @param capacity Receives the size of the string.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringGetCapacity(const ZyanString* string, ZyanUSize* capacity);
+
+/**
+ * @brief Returns the current size (number of characters) of the string (excluding the
+ * terminating zero character).
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ * @param size Receives the size (number of characters) of the string.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringGetSize(const ZyanString* string, ZyanUSize* size);
+
+/**
+ * @brief Returns the C-style string of the given `ZyanString` instance.
+ *
+ * @param string A pointer to the `ZyanString` instance.
+ * @param value Receives a pointer to the C-style string.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanStringGetData(const ZyanString* string, const char** value);
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // ZYCORE_STRING_H
diff --git a/detours/detours/zydis/dependencies/zycore/include/Zycore/Types.h b/detours/detours/zydis/dependencies/zycore/include/Zycore/Types.h
new file mode 100644
index 0000000..23c35b9
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/include/Zycore/Types.h
@@ -0,0 +1,154 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zyan-C)
+
+ Original Author : Florian Bernd, Joel Hoener
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+/**
+ * @file
+ * @brief Includes and defines some default datatypes.
+ */
+
+#ifndef ZYCORE_TYPES_H
+#define ZYCORE_TYPES_H
+
+#include
+
+/* ============================================================================================== */
+/* Integer types */
+/* ============================================================================================== */
+
+#if !defined(ZYAN_NO_LIBC) && (!defined(ZYAN_MSVC) && defined(ZYAN_KERNEL)) // The WDK LibC lacks stdint.h.
+ // If is LibC present, we use stdint types.
+# include
+# include
+ typedef uint8_t ZyanU8;
+ typedef uint16_t ZyanU16;
+ typedef uint32_t ZyanU32;
+ typedef uint64_t ZyanU64;
+ typedef int8_t ZyanI8;
+ typedef int16_t ZyanI16;
+ typedef int32_t ZyanI32;
+ typedef int64_t ZyanI64;
+ typedef size_t ZyanUSize;
+ typedef ptrdiff_t ZyanISize;
+ typedef uintptr_t ZyanUPointer;
+ typedef intptr_t ZyanIPointer;
+#else
+ // No LibC, use compiler built-in types / macros.
+# if defined(ZYAN_MSVC) || defined(ZYAN_ICC)
+ typedef unsigned __int8 ZyanU8;
+ typedef unsigned __int16 ZyanU16;
+ typedef unsigned __int32 ZyanU32;
+ typedef unsigned __int64 ZyanU64;
+ typedef signed __int8 ZyanI8;
+ typedef signed __int16 ZyanI16;
+ typedef signed __int32 ZyanI32;
+ typedef signed __int64 ZyanI64;
+# if _WIN64
+ typedef ZyanU64 ZyanUSize;
+ typedef ZyanI64 ZyanISize;
+ typedef ZyanU64 ZyanUPointer;
+ typedef ZyanI64 ZyanIPointer;
+# else
+ typedef ZyanU32 ZyanUSize;
+ typedef ZyanI32 ZyanISize;
+ typedef ZyanU32 ZyanUPointer;
+ typedef ZyanI32 ZyanIPointer;
+# endif
+# elif defined(ZYAN_GNUC)
+ typedef __UINT8_TYPE__ ZyanU8;
+ typedef __UINT16_TYPE__ ZyanU16;
+ typedef __UINT32_TYPE__ ZyanU32;
+ typedef __UINT64_TYPE__ ZyanU64;
+ typedef __INT8_TYPE__ ZyanI8;
+ typedef __INT16_TYPE__ ZyanI16;
+ typedef __INT32_TYPE__ ZyanI32;
+ typedef __INT64_TYPE__ ZyanI64;
+ typedef __SIZE_TYPE__ ZyanUSize;
+ typedef __PTRDIFF_TYPE__ ZyanISize;
+ typedef __UINTPTR_TYPE__ ZyanUPointer;
+ typedef __INTPTR_TYPE__ ZyanIPointer;
+# else
+# error "Unsupported compiler for no-libc mode."
+# endif
+#endif
+
+// Verify size assumptions.
+ZYAN_STATIC_ASSERT(sizeof(ZyanU8 ) == 1 );
+ZYAN_STATIC_ASSERT(sizeof(ZyanU16 ) == 2 );
+ZYAN_STATIC_ASSERT(sizeof(ZyanU32 ) == 4 );
+ZYAN_STATIC_ASSERT(sizeof(ZyanU64 ) == 8 );
+ZYAN_STATIC_ASSERT(sizeof(ZyanI8 ) == 1 );
+ZYAN_STATIC_ASSERT(sizeof(ZyanI16 ) == 2 );
+ZYAN_STATIC_ASSERT(sizeof(ZyanI32 ) == 4 );
+ZYAN_STATIC_ASSERT(sizeof(ZyanI64 ) == 8 );
+ZYAN_STATIC_ASSERT(sizeof(ZyanUSize ) == sizeof(void*)); // TODO: This one is incorrect!
+ZYAN_STATIC_ASSERT(sizeof(ZyanISize ) == sizeof(void*)); // TODO: This one is incorrect!
+ZYAN_STATIC_ASSERT(sizeof(ZyanUPointer) == sizeof(void*));
+ZYAN_STATIC_ASSERT(sizeof(ZyanIPointer) == sizeof(void*));
+
+// Verify signedness assumptions (relies on size checks above).
+ZYAN_STATIC_ASSERT((ZyanI8 )-1 >> 1 < (ZyanI8 )((ZyanU8 )-1 >> 1));
+ZYAN_STATIC_ASSERT((ZyanI16)-1 >> 1 < (ZyanI16)((ZyanU16)-1 >> 1));
+ZYAN_STATIC_ASSERT((ZyanI32)-1 >> 1 < (ZyanI32)((ZyanU32)-1 >> 1));
+ZYAN_STATIC_ASSERT((ZyanI64)-1 >> 1 < (ZyanI64)((ZyanU64)-1 >> 1));
+
+/* ============================================================================================== */
+/* NULL */
+/* ============================================================================================== */
+
+#define ZYAN_NULL ((void*)0)
+
+/* ============================================================================================== */
+/* Logic types */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Boolean */
+/* ---------------------------------------------------------------------------------------------- */
+
+#define ZYAN_FALSE 0
+#define ZYAN_TRUE 1
+
+/**
+ * @brief Defines the `ZyanBool` datatype.
+ */
+typedef ZyanU8 ZyanBool;
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Ternary */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Defines the `ZyanTernary` datatype.
+ */
+typedef ZyanI8 ZyanTernary;
+
+#define ZYAN_TERNARY_FALSE (-1)
+#define ZYAN_TERNARY_UNKNOWN 0x00
+#define ZYAN_TERNARY_TRUE 0x01
+
+/* ============================================================================================== */
+
+#endif /* ZYCORE_TYPES_H */
diff --git a/detours/detours/zydis/dependencies/zycore/include/Zycore/Vector.h b/detours/detours/zydis/dependencies/zycore/include/Zycore/Vector.h
new file mode 100644
index 0000000..ae3ebef
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/include/Zycore/Vector.h
@@ -0,0 +1,679 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+/**
+ * @file
+ * @brief Implements the vector container class.
+ */
+
+#ifndef ZYCORE_VECTOR_H
+#define ZYCORE_VECTOR_H
+
+#include
+#include
+#include
+#include
+#include
+#include
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ============================================================================================== */
+/* Constants */
+/* ============================================================================================== */
+
+/**
+ * @brief The initial minimum capacity (number of elements) for all dynamically allocated vector
+ * instances.
+ */
+#define ZYAN_VECTOR_MIN_CAPACITY 1
+
+/**
+ * @brief The default growth factor for all vector instances.
+ */
+#define ZYAN_VECTOR_DEFAULT_GROWTH_FACTOR 2.00f
+
+/**
+ * @brief The default shrink threshold for all vector instances.
+ */
+#define ZYAN_VECTOR_DEFAULT_SHRINK_THRESHOLD 0.25f
+
+/* ============================================================================================== */
+/* Enums and types */
+/* ============================================================================================== */
+
+/**
+ * @brief Defines the `ZyanVector` struct.
+ *
+ * All fields in this struct should be considered as "private". Any changes may lead to unexpected
+ * behavior.
+ */
+typedef struct ZyanVector_
+{
+ /**
+ * @brief The memory allocator.
+ */
+ ZyanAllocator* allocator;
+ /**
+ * @brief The growth factor.
+ */
+ float growth_factor;
+ /**
+ * @brief The shrink threshold.
+ */
+ float shrink_threshold;
+ /**
+ * @brief The current number of elements in the vector.
+ */
+ ZyanUSize size;
+ /**
+ * @brief The maximum capacity (number of elements).
+ */
+ ZyanUSize capacity;
+ /**
+ * @brief The size of a single element in bytes.
+ */
+ ZyanUSize element_size;
+ /**
+ * @brief The element destructor callback.
+ */
+ ZyanMemberProcedure destructor;
+ /**
+ * @brief The data pointer.
+ */
+ void* data;
+} ZyanVector;
+
+/* ============================================================================================== */
+/* Macros */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* General */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Defines an uninitialized `ZyanVector` instance.
+ */
+#define ZYAN_VECTOR_INITIALIZER \
+ { \
+ /* allocator */ ZYAN_NULL, \
+ /* growth_factor */ 0.0f, \
+ /* shrink_threshold */ 0.0f, \
+ /* size */ 0, \
+ /* capacity */ 0, \
+ /* element_size */ 0, \
+ /* destructor */ ZYAN_NULL, \
+ /* data */ ZYAN_NULL \
+ }
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Helper macros */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Returns the value of the element at the given `index`.
+ *
+ * @param type The desired value type.
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param index The element index.
+ *
+ * @result The value of the desired element in the vector.
+ *
+ * Note that this function is unsafe and might dereference a null-pointer.
+ */
+#ifdef __cplusplus
+#define ZYAN_VECTOR_GET(type, vector, index) \
+ (*reinterpret_cast(ZyanVectorGet(vector, index)))
+#else
+#define ZYAN_VECTOR_GET(type, vector, index) \
+ (*(const type*)ZyanVectorGet(vector, index))
+#endif
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+/* Exported functions */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Constructor and destructor */
+/* ---------------------------------------------------------------------------------------------- */
+
+#ifndef ZYAN_NO_LIBC
+
+/**
+ * @brief Initializes the given `ZyanVector` instance.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param element_size The size of a single element in bytes.
+ * @param capacity The initial capacity (number of elements).
+ * @param destructor A destructor callback that is invoked every time an item is deleted, or
+ * `ZYAN_NULL` if not needed.
+ *
+ * @return A zyan status code.
+ *
+ * The memory for the vector elements is dynamically allocated by the default allocator using the
+ * default growth factor of `2.0f` and the default shrink threshold of `0.25f`.
+ *
+ * Finalization with `ZyanVectorDestroy` is required for all instances created by this function.
+ */
+ZYCORE_EXPORT ZYAN_REQUIRES_LIBC ZyanStatus ZyanVectorInit(ZyanVector* vector,
+ ZyanUSize element_size, ZyanUSize capacity, ZyanMemberProcedure destructor);
+
+#endif // ZYAN_NO_LIBC
+
+/**
+ * @brief Initializes the given `ZyanVector` instance and sets a custom `allocator` and memory
+ * allocation/deallocation parameters.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param element_size The size of a single element in bytes.
+ * @param capacity The initial capacity (number of elements).
+ * @param destructor A destructor callback that is invoked every time an item is deleted,
+ * or `ZYAN_NULL` if not needed.
+ * @param allocator A pointer to a `ZyanAllocator` instance.
+ * @param growth_factor The growth factor (from `1.0f` to `x.xf`).
+ * @param shrink_threshold The shrink threshold (from `0.0f` to `1.0f`).
+ *
+ * @return A zyan status code.
+ *
+ * A growth factor of `1.0f` disables overallocation and a shrink threshold of `0.0f` disables
+ * dynamic shrinking.
+ *
+ * Finalization with `ZyanVectorDestroy` is required for all instances created by this function.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorInitEx(ZyanVector* vector, ZyanUSize element_size,
+ ZyanUSize capacity, ZyanMemberProcedure destructor, ZyanAllocator* allocator,
+ float growth_factor, float shrink_threshold);
+
+/**
+ * @brief Initializes the given `ZyanVector` instance and configures it to use a custom user
+ * defined buffer with a fixed size.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param element_size The size of a single element in bytes.
+ * @param buffer A pointer to the buffer that is used as storage for the elements.
+ * @param capacity The maximum capacity (number of elements) of the buffer.
+ * @param destructor A destructor callback that is invoked every time an item is deleted, or
+ * `ZYAN_NULL` if not needed.
+ *
+ * @return A zyan status code.
+ *
+ * Finalization is not required for instances created by this function.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorInitCustomBuffer(ZyanVector* vector, ZyanUSize element_size,
+ void* buffer, ZyanUSize capacity, ZyanMemberProcedure destructor);
+
+/**
+ * @brief Destroys the given `ZyanVector` instance.
+ *
+ * @param vector A pointer to the `ZyanVector` instance..
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorDestroy(ZyanVector* vector);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Duplication */
+/* ---------------------------------------------------------------------------------------------- */
+
+#ifndef ZYAN_NO_LIBC
+
+/**
+ * @brief Initializes a new `ZyanVector` instance by duplicating an existing vector.
+ *
+ * @param destination A pointer to the (uninitialized) destination `ZyanVector` instance.
+ * @param source A pointer to the source vector.
+ * @param capacity The initial capacity (number of elements).
+ *
+ * This value is automatically adjusted to the size of the source vector, if
+ * a smaller value was passed.
+ *
+ * @return A zyan status code.
+ *
+ * The memory for the vector is dynamically allocated by the default allocator using the default
+ * growth factor of `2.0f` and the default shrink threshold of `0.25f`.
+ *
+ * Finalization with `ZyanVectorDestroy` is required for all instances created by this function.
+ */
+ZYCORE_EXPORT ZYAN_REQUIRES_LIBC ZyanStatus ZyanVectorDuplicate(ZyanVector* destination,
+ const ZyanVector* source, ZyanUSize capacity);
+
+#endif // ZYAN_NO_LIBC
+
+/**
+ * @brief Initializes a new `ZyanVector` instance by duplicating an existing vector and sets a
+ * custom `allocator` and memory allocation/deallocation parameters.
+ *
+ * @param destination A pointer to the (uninitialized) destination `ZyanVector` instance.
+ * @param source A pointer to the source vector.
+ * @param capacity The initial capacity (number of elements).
+
+ * This value is automatically adjusted to the size of the source
+ * vector, if a smaller value was passed.
+ * @param allocator A pointer to a `ZyanAllocator` instance.
+ * @param growth_factor The growth factor (from `1.0f` to `x.xf`).
+ * @param shrink_threshold The shrink threshold (from `0.0f` to `1.0f`).
+ *
+ * @return A zyan status code.
+ *
+ * A growth factor of `1.0f` disables overallocation and a shrink threshold of `0.0f` disables
+ * dynamic shrinking.
+ *
+ * Finalization with `ZyanVectorDestroy` is required for all instances created by this function.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorDuplicateEx(ZyanVector* destination, const ZyanVector* source,
+ ZyanUSize capacity, ZyanAllocator* allocator, float growth_factor, float shrink_threshold);
+
+/**
+ * @brief Initializes a new `ZyanVector` instance by duplicating an existing vector and
+ * configures it to use a custom user defined buffer with a fixed size.
+ *
+ * @param destination A pointer to the (uninitialized) destination `ZyanVector` instance.
+ * @param source A pointer to the source vector.
+ * @param buffer A pointer to the buffer that is used as storage for the elements.
+ * @param capacity The maximum capacity (number of elements) of the buffer.
+
+ * This function will fail, if the capacity of the buffer is less than the
+ * size of the source vector.
+ *
+ * @return A zyan status code.
+ *
+ * Finalization is not required for instances created by this function.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorDuplicateCustomBuffer(ZyanVector* destination,
+ const ZyanVector* source, void* buffer, ZyanUSize capacity);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Element access */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Returns a constant pointer to the element at the given `index`.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param index The element index.
+ *
+ * @return A constant pointer to the desired element in the vector or `ZYAN_NULL`, if an error
+ * occured.
+ *
+ * Note that the returned pointer might get invalid when the vector is resized by either a manual
+ * call to the memory-management functions or implicitly by inserting or removing elements.
+ *
+ * Take a look at `ZyanVectorGetPointer` instead, if you need a function that returns a zyan status
+ * code.
+ */
+ZYCORE_EXPORT const void* ZyanVectorGet(const ZyanVector* vector, ZyanUSize index);
+
+/**
+ * @brief Returns a mutable pointer to the element at the given `index`.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param index The element index.
+ *
+ * @return A mutable pointer to the desired element in the vector or `ZYAN_NULL`, if an error
+ * occured.
+ *
+ * Note that the returned pointer might get invalid when the vector is resized by either a manual
+ * call to the memory-management functions or implicitly by inserting or removing elements.
+ *
+ * Take a look at `ZyanVectorGetPointerMutable` instead, if you need a function that returns a
+ * zyan status code.
+ */
+ZYCORE_EXPORT void* ZyanVectorGetMutable(const ZyanVector* vector, ZyanUSize index);
+
+/**
+ * @brief Returns a constant pointer to the element at the given `index`.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param index The element index.
+ * @param value Receives a constant pointer to the desired element in the vector.
+ *
+ * Note that the returned pointer might get invalid when the vector is resized by either a manual
+ * call to the memory-management functions or implicitly by inserting or removing elements.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorGetPointer(const ZyanVector* vector, ZyanUSize index,
+ const void** value);
+
+/**
+ * @brief Returns a mutable pointer to the element at the given `index`.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param index The element index.
+ * @param value Receives a mutable pointer to the desired element in the vector.
+ *
+ * Note that the returned pointer might get invalid when the vector is resized by either a manual
+ * call to the memory-management functions or implicitly by inserting or removing elements.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorGetPointerMutable(const ZyanVector* vector, ZyanUSize index,
+ void** value);
+
+/**
+ * @brief Assigns a new value to the element at the given `index`.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param index The value index.
+ * @param value The value to assign.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorSet(ZyanVector* vector, ZyanUSize index,
+ const void* value);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Insertion */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Adds a new `element` to the end of the vector.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param element A pointer to the element to add.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorPushBack(ZyanVector* vector, const void* element);
+
+/**
+ * @brief Inserts an `element` at the given `index` of the vector.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param index The insert index.
+ * @param element A pointer to the element to insert.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorInsert(ZyanVector* vector, ZyanUSize index,
+ const void* element);
+
+/**
+ * @brief Inserts multiple `elements` at the given `index` of the vector.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param index The insert index.
+ * @param elements A pointer to the first element.
+ * @param count The number of elements to insert.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorInsertRange(ZyanVector* vector, ZyanUSize index,
+ const void* elements, ZyanUSize count);
+
+/**
+ * @brief Constructs an `element` in-place at the end of the vector.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param element Receives a pointer to the new element.
+ * @param constructor The constructor callback or `ZYAN_NULL`. The new element will be in
+ * undefined state, if no constructor was passed.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorEmplace(ZyanVector* vector, void** element,
+ ZyanMemberFunction constructor);
+
+/**
+ * @brief Constructs an `element` in-place and inserts it at the given `index` of the vector.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param index The insert index.
+ * @param element Receives a pointer to the new element.
+ * @param constructor The constructor callback or `ZYAN_NULL`. The new element will be in
+ * undefined state, if no constructor was passed.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorEmplaceEx(ZyanVector* vector, ZyanUSize index,
+ void** element, ZyanMemberFunction constructor);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Utils */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Swaps the element at `index_first` with the element at `index_second`.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param index_first The index of the first element.
+ * @param index_second The index of the second element.
+ *
+ * @return A zyan status code.
+ *
+ * This function requires the vector to have spare capacity for one temporary element. Call
+ * `ZyanVectorReserve` before this function to increase capacity, if needed.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorSwapElements(ZyanVector* vector, ZyanUSize index_first,
+ ZyanUSize index_second);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Deletion */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Deletes the element at the given `index` of the vector.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param index The element index.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorDelete(ZyanVector* vector, ZyanUSize index);
+
+/**
+ * @brief Deletes multiple elements from the given vector, starting at `index`.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param index The index of the first element to delete.
+ * @param count The number of elements to delete.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorDeleteRange(ZyanVector* vector, ZyanUSize index,
+ ZyanUSize count);
+
+/**
+ * @brief Removes the last element of the vector.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorPopBack(ZyanVector* vector);
+
+/**
+ * @brief Erases all elements of the given vector.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorClear(ZyanVector* vector);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Searching */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Sequentially searches for the first occurrence of `element` in the given vector.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param element A pointer to the element to search for.
+ * @param found_index A pointer to a variable that receives the index of the found element.
+ * @param comparison The comparison function to use.
+ *
+ * @return `ZYAN_STATUS_TRUE` if the element was found, `ZYAN_STATUS_FALSE` if not or a generic
+ * zyan status code if an error occured.
+ *
+ * The `found_index` is set to `-1`, if the element was not found.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorFind(const ZyanVector* vector, const void* element,
+ ZyanISize* found_index, ZyanEqualityComparison comparison);
+
+/**
+ * @brief Sequentially searches for the first occurrence of `element` in the given vector.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param element A pointer to the element to search for.
+ * @param found_index A pointer to a variable that receives the index of the found element.
+ * @param comparison The comparison function to use.
+ * @param index The start index.
+ * @param count The maximum number of elements to iterate, beginning from the start `index`.
+ *
+ * @return `ZYAN_STATUS_TRUE` if the element was found, `ZYAN_STATUS_FALSE` if not or a generic
+ * zyan status code if an error occured.
+ *
+ * The `found_index` is set to `-1`, if the element was not found.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorFindEx(const ZyanVector* vector, const void* element,
+ ZyanISize* found_index, ZyanEqualityComparison comparison, ZyanUSize index, ZyanUSize count);
+
+/**
+ * @brief Searches for the first occurrence of `element` in the given vector using a binary-
+ * search algorithm.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param element A pointer to the element to search for.
+ * @param found_index A pointer to a variable that receives the index of the found element.
+ * @param comparison The comparison function to use.
+ *
+ * @return `ZYAN_STATUS_TRUE` if the element was found, `ZYAN_STATUS_FALSE` if not or a generic
+ * zyan status code if an error occured.
+ *
+ * If found, `found_index` contains the zero-based index of `element`. If not found, `found_index`
+ * contains the index of the first entry larger than `element`.
+ *
+ * This function requires all elements in the vector to be strictly ordered (sorted).
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorBinarySearch(const ZyanVector* vector, const void* element,
+ ZyanUSize* found_index, ZyanComparison comparison);
+
+/**
+ * @brief Searches for the first occurrence of `element` in the given vector using a binary-
+ * search algorithm.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param element A pointer to the element to search for.
+ * @param found_index A pointer to a variable that receives the index of the found element.
+ * @param comparison The comparison function to use.
+ * @param index The start index.
+ * @param count The maximum number of elements to iterate, beginning from the start `index`.
+ *
+ * @return `ZYAN_STATUS_TRUE` if the element was found, `ZYAN_STATUS_FALSE` if not or a generic
+ * zyan status code if an error occured.
+ *
+ * If found, `found_index` contains the zero-based index of `element`. If not found, `found_index`
+ * contains the index of the first entry larger than `element`.
+ *
+ * This function requires all elements in the vector to be strictly ordered (sorted).
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorBinarySearchEx(const ZyanVector* vector, const void* element,
+ ZyanUSize* found_index, ZyanComparison comparison, ZyanUSize index, ZyanUSize count);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Memory management */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Resizes the given `ZyanVector` instance.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param size The new size of the vector.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorResize(ZyanVector* vector, ZyanUSize size);
+
+/**
+ * @brief Resizes the given `ZyanVector` instance.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param size The new size of the vector.
+ * @param initializer A pointer to a value to be used as initializer for new items.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorResizeEx(ZyanVector* vector, ZyanUSize size,
+ const void* initializer);
+
+/**
+ * @brief Changes the capacity of the given `ZyanVector` instance.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param capacity The new minimum capacity of the vector.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorReserve(ZyanVector* vector, ZyanUSize capacity);
+
+/**
+ * @brief Shrinks the capacity of the given vector to match it's size.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorShrinkToFit(ZyanVector* vector);
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Information */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Returns the current capacity of the vector.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param capacity Receives the size of the vector.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorGetCapacity(const ZyanVector* vector, ZyanUSize* capacity);
+
+/**
+ * @brief Returns the current size of the vector.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param size Receives the size of the vector.
+ *
+ * @return A zyan status code.
+ */
+ZYCORE_EXPORT ZyanStatus ZyanVectorGetSize(const ZyanVector* vector, ZyanUSize* size);
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZYCORE_VECTOR_H */
diff --git a/detours/detours/zydis/dependencies/zycore/include/Zycore/Zycore.h b/detours/detours/zydis/dependencies/zycore/include/Zycore/Zycore.h
new file mode 100644
index 0000000..b566688
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/include/Zycore/Zycore.h
@@ -0,0 +1,111 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+/**
+ * @file
+ * @brief Master include file, including everything else.
+ */
+
+#ifndef ZYCORE_H
+#define ZYCORE_H
+
+#include
+#include
+
+// TODO:
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ============================================================================================== */
+/* Macros */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Constants */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief A macro that defines the zycore version.
+ */
+#define ZYCORE_VERSION (ZyanU64)0x0001000000000000
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Helper macros */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Extracts the major-part of the zycore version.
+ *
+ * @param version The zycore version value
+ */
+#define ZYCORE_VERSION_MAJOR(version) (ZyanU16)((version & 0xFFFF000000000000) >> 48)
+
+/**
+ * @brief Extracts the minor-part of the zycore version.
+ *
+ * @param version The zycore version value
+ */
+#define ZYCORE_VERSION_MINOR(version) (ZyanU16)((version & 0x0000FFFF00000000) >> 32)
+
+/**
+ * @brief Extracts the patch-part of the zycore version.
+ *
+ * @param version The zycore version value
+ */
+#define ZYCORE_VERSION_PATCH(version) (ZyanU16)((version & 0x00000000FFFF0000) >> 16)
+
+/**
+ * @brief Extracts the build-part of the zycore version.
+ *
+ * @param version The zycore version value
+ */
+#define ZYCORE_VERSION_BUILD(version) (ZyanU16)(version & 0x000000000000FFFF)
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+/* Exported functions */
+/* ============================================================================================== */
+
+/**
+ * @brief Returns the zycore version.
+ *
+ * @return The zycore version.
+ *
+ * Use the macros provided in this file to extract the major, minor, patch and build part from the
+ * returned version value.
+ */
+ZYCORE_EXPORT ZyanU64 ZycoreGetVersion(void);
+
+/* ============================================================================================== */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZYCORE_H */
diff --git a/detours/detours/zydis/dependencies/zycore/resources/VersionInfo.rc b/detours/detours/zydis/dependencies/zycore/resources/VersionInfo.rc
new file mode 100644
index 0000000..3ce7947
Binary files /dev/null and b/detours/detours/zydis/dependencies/zycore/resources/VersionInfo.rc differ
diff --git a/detours/detours/zydis/dependencies/zycore/src/API/Memory.c b/detours/detours/zydis/dependencies/zycore/src/API/Memory.c
new file mode 100644
index 0000000..3471e70
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/src/API/Memory.c
@@ -0,0 +1,35 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+#include
+
+/* ============================================================================================== */
+/* Exported functions */
+/* ============================================================================================== */
+
+
+
+/* ============================================================================================== */
diff --git a/detours/detours/zydis/dependencies/zycore/src/API/Synchronization.c b/detours/detours/zydis/dependencies/zycore/src/API/Synchronization.c
new file mode 100644
index 0000000..6755002
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/src/API/Synchronization.c
@@ -0,0 +1,204 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+#ifndef ZYAN_NO_LIBC
+
+#include
+
+/* ============================================================================================== */
+/* Internal functions */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* */
+/* ---------------------------------------------------------------------------------------------- */
+
+
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+/* Exported functions */
+/* ============================================================================================== */
+
+#if defined(ZYAN_POSIX)
+
+#include
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Critical Section */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanCriticalSectionInitialize(ZyanCriticalSection* critical_section)
+{
+ pthread_mutexattr_t attribute;
+
+ int error = pthread_mutexattr_init(&attribute);
+ if (error != 0)
+ {
+ if (error == ENOMEM)
+ {
+ return ZYAN_STATUS_NOT_ENOUGH_MEMORY;
+ }
+ return ZYAN_STATUS_BAD_SYSTEMCALL;
+ }
+ pthread_mutexattr_settype(&attribute, PTHREAD_MUTEX_RECURSIVE);
+
+ error = pthread_mutex_init(critical_section, &attribute);
+ pthread_mutexattr_destroy(&attribute);
+ if (error != 0)
+ {
+ if (error == EAGAIN)
+ {
+ return ZYAN_STATUS_OUT_OF_RESOURCES;
+ }
+ if (error == ENOMEM)
+ {
+ return ZYAN_STATUS_NOT_ENOUGH_MEMORY;
+ }
+ if (error == EPERM)
+ {
+ return ZYAN_STATUS_ACCESS_DENIED;
+ }
+ if ((error == EBUSY) || (error == EINVAL))
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ return ZYAN_STATUS_BAD_SYSTEMCALL;
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanCriticalSectionEnter(ZyanCriticalSection* critical_section)
+{
+ const int error = pthread_mutex_lock(critical_section);
+ if (error != 0)
+ {
+ if (error == EINVAL)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ if (error == EAGAIN)
+ {
+ return ZYAN_STATUS_INVALID_OPERATION;
+ }
+ return ZYAN_STATUS_BAD_SYSTEMCALL;
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanBool ZyanCriticalSectionTryEnter(ZyanCriticalSection* critical_section)
+{
+ // No fine grained error handling for this one
+ return pthread_mutex_trylock(critical_section) ? ZYAN_FALSE : ZYAN_TRUE;
+}
+
+ZyanStatus ZyanCriticalSectionLeave(ZyanCriticalSection* critical_section)
+{
+ const int error = pthread_mutex_unlock(critical_section);
+ if (error != 0)
+ {
+ if (error == EINVAL)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ if (error == EPERM)
+ {
+ return ZYAN_STATUS_INVALID_OPERATION;
+ }
+ return ZYAN_STATUS_BAD_SYSTEMCALL;
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanCriticalSectionDelete(ZyanCriticalSection* critical_section)
+{
+ const int error = pthread_mutex_destroy(critical_section);
+ if (error != 0)
+ {
+ if ((error == EBUSY) || (error == EINVAL))
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ return ZYAN_STATUS_BAD_SYSTEMCALL;
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+
+#elif defined(ZYAN_WINDOWS)
+
+/* ---------------------------------------------------------------------------------------------- */
+/* General */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanCriticalSectionInitialize(ZyanCriticalSection* critical_section)
+{
+ InitializeCriticalSection(critical_section);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanCriticalSectionEnter(ZyanCriticalSection* critical_section)
+{
+ EnterCriticalSection(critical_section);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanBool ZyanCriticalSectionTryEnter(ZyanCriticalSection* critical_section)
+{
+ return TryEnterCriticalSection(critical_section) ? ZYAN_TRUE : ZYAN_FALSE;
+}
+
+ZyanStatus ZyanCriticalSectionLeave(ZyanCriticalSection* critical_section)
+{
+ LeaveCriticalSection(critical_section);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanCriticalSectionDelete(ZyanCriticalSection* critical_section)
+{
+ DeleteCriticalSection(critical_section);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+
+#else
+# error "Unsupported platform detected"
+#endif
+
+#endif /* ZYAN_NO_LIBC */
+
+/* ============================================================================================== */
diff --git a/detours/detours/zydis/dependencies/zycore/src/API/Terminal.c b/detours/detours/zydis/dependencies/zycore/src/API/Terminal.c
new file mode 100644
index 0000000..f743693
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/src/API/Terminal.c
@@ -0,0 +1,160 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+#include
+
+#ifndef ZYAN_NO_LIBC
+
+#if defined(ZYAN_POSIX)
+# include
+#elif defined(ZYAN_WINDOWS)
+# include
+# include
+#else
+# error "Unsupported platform detected"
+#endif
+
+// Provide fallback for old SDK versions
+#ifdef ZYAN_WINDOWS
+# ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
+# define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x0004
+# endif
+#endif
+
+/* ============================================================================================== */
+/* Exported functions */
+/* ============================================================================================== */
+
+ZyanStatus ZyanTerminalEnableVT100(ZyanStandardStream stream)
+{
+ if ((stream != ZYAN_STDSTREAM_OUT) && (stream != ZYAN_STDSTREAM_ERR))
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+#ifdef ZYAN_WINDOWS
+ // Get file descriptor
+ int file;
+ switch (stream)
+ {
+ case ZYAN_STDSTREAM_OUT:
+ file = _fileno(ZYAN_STDOUT);
+ break;
+ case ZYAN_STDSTREAM_ERR:
+ file = _fileno(ZYAN_STDERR);
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+ if (file < 0)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ HANDLE const handle = (HANDLE)_get_osfhandle(file);
+ if (handle == INVALID_HANDLE_VALUE)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ DWORD mode;
+ if (!GetConsoleMode(handle, &mode))
+ {
+ // The given standard stream is not bound to a terminal
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ mode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+ if (!SetConsoleMode(handle, mode))
+ {
+ return ZYAN_STATUS_BAD_SYSTEMCALL;
+ }
+#endif
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanTerminalIsTTY(ZyanStandardStream stream)
+{
+ // Get file descriptor
+ int file;
+#ifdef ZYAN_WINDOWS
+ switch (stream)
+ {
+ case ZYAN_STDSTREAM_IN:
+ file = _fileno(ZYAN_STDIN);
+ break;
+ case ZYAN_STDSTREAM_OUT:
+ file = _fileno(ZYAN_STDOUT);
+ break;
+ case ZYAN_STDSTREAM_ERR:
+ file = _fileno(ZYAN_STDERR);
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+ if (file < 0)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+#else
+ switch (stream)
+ {
+ case ZYAN_STDSTREAM_IN:
+ file = STDIN_FILENO;
+ break;
+ case ZYAN_STDSTREAM_OUT:
+ file = STDOUT_FILENO;
+ break;
+ case ZYAN_STDSTREAM_ERR:
+ file = STDERR_FILENO;
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+#endif
+
+#ifdef ZYAN_WINDOWS
+ if (_isatty(file))
+#else
+ if ( isatty(file))
+#endif
+ {
+ return ZYAN_STATUS_TRUE;
+ }
+ if (ZYAN_ERRNO == EBADF)
+ {
+ // Invalid file descriptor
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ //ZYAN_ASSERT((errno == EINVAL) || (errno == ENOTTY));
+
+ return ZYAN_STATUS_FALSE;
+}
+
+/* ============================================================================================== */
+
+#endif // ZYAN_NO_LIBC
diff --git a/detours/detours/zydis/dependencies/zycore/src/API/Thread.c b/detours/detours/zydis/dependencies/zycore/src/API/Thread.c
new file mode 100644
index 0000000..693bd02
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/src/API/Thread.c
@@ -0,0 +1,198 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+#ifndef ZYAN_NO_LIBC
+
+#include
+
+/* ============================================================================================== */
+/* Internal functions */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* */
+/* ---------------------------------------------------------------------------------------------- */
+
+
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+/* Exported functions */
+/* ============================================================================================== */
+
+#if defined(ZYAN_POSIX)
+
+#include
+
+/* ---------------------------------------------------------------------------------------------- */
+/* General */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanThreadGetCurrentThread(ZyanThread* thread)
+{
+ *thread = pthread_self();
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZYAN_STATIC_ASSERT(sizeof(ZyanThreadId) <= sizeof(ZyanU64));
+ZyanStatus ZyanThreadGetCurrentThreadId(ZyanThreadId* thread_id)
+{
+ // TODO: Use `pthread_getthreadid_np` on platforms where it is available
+
+ pthread_t ptid = pthread_self();
+ *thread_id = *(ZyanThreadId*)ptid;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Thread Local Storage */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanThreadTlsAlloc(ZyanThreadTlsIndex* index, ZyanThreadTlsCallback destructor)
+{
+ ZyanThreadTlsIndex value;
+ const int error = pthread_key_create(&value, destructor);
+ if (error != 0)
+ {
+ if (error == EAGAIN)
+ {
+ return ZYAN_STATUS_OUT_OF_RESOURCES;
+ }
+ if (error == ENOMEM)
+ {
+ return ZYAN_STATUS_NOT_ENOUGH_MEMORY;
+ }
+ return ZYAN_STATUS_BAD_SYSTEMCALL;
+ }
+
+ *index = value;
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanThreadTlsFree(ZyanThreadTlsIndex index)
+{
+ return !pthread_key_delete(index) ? ZYAN_STATUS_SUCCESS : ZYAN_STATUS_BAD_SYSTEMCALL;
+}
+
+ZyanStatus ZyanThreadTlsGetValue(ZyanThreadTlsIndex index, void** data)
+{
+ *data = pthread_getspecific(index);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanThreadTlsSetValue(ZyanThreadTlsIndex index, void* data)
+{
+ const int error = pthread_setspecific(index, data);
+ if (error != 0)
+ {
+ if (error == EINVAL)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ return ZYAN_STATUS_BAD_SYSTEMCALL;
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+
+#elif defined(ZYAN_WINDOWS)
+
+/* ---------------------------------------------------------------------------------------------- */
+/* General */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanThreadGetCurrentThread(ZyanThread* thread)
+{
+ *thread = GetCurrentThread();
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanThreadGetCurrentThreadId(ZyanThreadId* thread_id)
+{
+ *thread_id = GetCurrentThreadId();
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Thread Local Storage (TLS) */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanThreadTlsAlloc(ZyanThreadTlsIndex* index, ZyanThreadTlsCallback destructor)
+{
+ const ZyanThreadTlsIndex value = FlsAlloc(destructor);
+ if (value == FLS_OUT_OF_INDEXES)
+ {
+ return ZYAN_STATUS_OUT_OF_RESOURCES;
+ }
+
+ *index = value;
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanThreadTlsFree(ZyanThreadTlsIndex index)
+{
+ return FlsFree(index) ? ZYAN_STATUS_SUCCESS : ZYAN_STATUS_BAD_SYSTEMCALL;
+}
+
+ZyanStatus ZyanThreadTlsGetValue(ZyanThreadTlsIndex index, void** data)
+{
+ *data = FlsGetValue(index);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanThreadTlsSetValue(ZyanThreadTlsIndex index, void* data)
+{
+ if (!FlsSetValue(index, data))
+ {
+ const DWORD error = GetLastError();
+ if (error == ERROR_INVALID_PARAMETER)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ return ZYAN_STATUS_BAD_SYSTEMCALL;
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+
+#else
+# error "Unsupported platform detected"
+#endif
+
+#endif /* ZYAN_NO_LIBC */
+
+/* ============================================================================================== */
diff --git a/detours/detours/zydis/dependencies/zycore/src/Allocator.c b/detours/detours/zydis/dependencies/zycore/src/Allocator.c
new file mode 100644
index 0000000..5fadf64
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/src/Allocator.c
@@ -0,0 +1,134 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+#include
+#include
+
+/* ============================================================================================== */
+/* Internal functions */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Default allocator */
+/* ---------------------------------------------------------------------------------------------- */
+
+#ifndef ZYAN_NO_LIBC
+
+static ZyanStatus ZyanAllocatorDefaultAllocate(ZyanAllocator* allocator, void** p,
+ ZyanUSize element_size, ZyanUSize n)
+{
+ ZYAN_ASSERT(allocator);
+ ZYAN_ASSERT(p);
+ ZYAN_ASSERT(element_size);
+ ZYAN_ASSERT(n);
+
+ ZYAN_UNUSED(allocator);
+
+ *p = ZYAN_MALLOC(element_size * n);
+ if (!*p)
+ {
+ return ZYAN_STATUS_NOT_ENOUGH_MEMORY;
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+static ZyanStatus ZyanAllocatorDefaultReallocate(ZyanAllocator* allocator, void** p,
+ ZyanUSize element_size, ZyanUSize n)
+{
+ ZYAN_ASSERT(allocator);
+ ZYAN_ASSERT(p);
+ ZYAN_ASSERT(element_size);
+ ZYAN_ASSERT(n);
+
+ ZYAN_UNUSED(allocator);
+
+ void* const x = ZYAN_REALLOC(*p, element_size * n);
+ if (!x)
+ {
+ return ZYAN_STATUS_NOT_ENOUGH_MEMORY;
+ }
+ *p = x;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+static ZyanStatus ZyanAllocatorDefaultDeallocate(ZyanAllocator* allocator, void* p,
+ ZyanUSize element_size, ZyanUSize n)
+{
+ ZYAN_ASSERT(allocator);
+ ZYAN_ASSERT(p);
+ ZYAN_ASSERT(element_size);
+ ZYAN_ASSERT(n);
+
+ ZYAN_UNUSED(allocator);
+ ZYAN_UNUSED(element_size);
+ ZYAN_UNUSED(n);
+
+ ZYAN_FREE(p);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+#endif // ZYAN_NO_LIBC
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+/* Exported functions */
+/* ============================================================================================== */
+
+ZyanStatus ZyanAllocatorInit(ZyanAllocator* allocator, ZyanAllocatorAllocate allocate,
+ ZyanAllocatorAllocate reallocate, ZyanAllocatorDeallocate deallocate)
+{
+ if (!allocator || !allocate || !reallocate || !deallocate)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ allocator->allocate = allocate;
+ allocator->reallocate = reallocate;
+ allocator->deallocate = deallocate;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+#ifndef ZYAN_NO_LIBC
+
+ZyanAllocator* ZyanAllocatorDefault(void)
+{
+ static ZyanAllocator allocator =
+ {
+ &ZyanAllocatorDefaultAllocate,
+ &ZyanAllocatorDefaultReallocate,
+ &ZyanAllocatorDefaultDeallocate
+ };
+ return &allocator;
+}
+
+#endif
+
+/* ============================================================================================== */
diff --git a/detours/detours/zydis/dependencies/zycore/src/Bitset.c b/detours/detours/zydis/dependencies/zycore/src/Bitset.c
new file mode 100644
index 0000000..daf8b1e
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/src/Bitset.c
@@ -0,0 +1,670 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+#include
+#include
+
+/* ============================================================================================== */
+/* Internal constants */
+/* ============================================================================================== */
+
+#define ZYAN_BITSET_GROWTH_FACTOR 2.00f
+#define ZYAN_BITSET_SHRINK_THRESHOLD 0.50f
+
+/* ============================================================================================== */
+/* Internal macros */
+/* ============================================================================================== */
+
+/**
+ * @brief Computes the smallest integer value not less than `x`.
+ *
+ * @param x The value.
+ *
+ * @return The smallest integer value not less than `x`.
+ */
+#define ZYAN_BITSET_CEIL(x) \
+ (((x) == ((ZyanU32)(x))) ? (ZyanU32)(x) : ((ZyanU32)(x)) + 1)
+
+/**
+ * @brief Converts bits to bytes.
+ *
+ * @param x The value in bits.
+ *
+ * @return The amount of bytes needed to fit `x` bits.
+ */
+#define ZYAN_BITSET_BITS_TO_BYTES(x) \
+ ZYAN_BITSET_CEIL((x) / 8.0f)
+
+/**
+ * @brief Returns the offset of the given bit.
+ *
+ * @param index The bit index.
+ *
+ * @return The offset of the given bit.
+ */
+#define ZYAN_BITSET_BIT_OFFSET(index) \
+ (7 - ((index) % 8))
+
+/* ============================================================================================== */
+/* Internal functions */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Helper functions */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Initializes the given `vector` with `count` "zero"-bytes.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param count The number of bytes.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus ZyanBitsetInitVectorElements(ZyanVector* vector, ZyanUSize count)
+{
+ ZYAN_ASSERT(vector);
+
+ static const ZyanU8 zero = 0;
+ for (ZyanUSize i = 0; i < count; ++i)
+ {
+ ZYAN_CHECK(ZyanVectorPushBack(vector, &zero));
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Byte operations */
+/* ---------------------------------------------------------------------------------------------- */
+
+static ZyanStatus ZyanBitsetOperationAND(ZyanU8* b1, const ZyanU8* b2)
+{
+ *b1 &= *b2;
+ return ZYAN_STATUS_SUCCESS;
+}
+
+static ZyanStatus ZyanBitsetOperationOR (ZyanU8* b1, const ZyanU8* b2)
+{
+ *b1 |= *b2;
+ return ZYAN_STATUS_SUCCESS;
+}
+
+static ZyanStatus ZyanBitsetOperationXOR(ZyanU8* b1, const ZyanU8* b2)
+{
+ *b1 ^= *b2;
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+/* Exported functions */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Constructor and destructor */
+/* ---------------------------------------------------------------------------------------------- */
+
+#ifndef ZYAN_NO_LIBC
+
+ZyanStatus ZyanBitsetInit(ZyanBitset* bitset, ZyanUSize count)
+{
+ return ZyanBitsetInitEx(bitset, count, ZyanAllocatorDefault(), ZYAN_BITSET_GROWTH_FACTOR,
+ ZYAN_BITSET_SHRINK_THRESHOLD);
+}
+
+#endif // ZYAN_NO_LIBC
+
+ZyanStatus ZyanBitsetInitEx(ZyanBitset* bitset, ZyanUSize count, ZyanAllocator* allocator,
+ float growth_factor, float shrink_threshold)
+{
+ if (!bitset)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ const ZyanU32 bytes = ZYAN_BITSET_BITS_TO_BYTES(count);
+
+ bitset->size = count;
+ ZYAN_CHECK(ZyanVectorInitEx(&bitset->bits, sizeof(ZyanU8), bytes, ZYAN_NULL, allocator,
+ growth_factor, shrink_threshold));
+ ZYAN_CHECK(ZyanBitsetInitVectorElements(&bitset->bits, bytes));
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanBitsetInitBuffer(ZyanBitset* bitset, ZyanUSize count, void* buffer,
+ ZyanUSize capacity)
+{
+ if (!bitset)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ const ZyanU32 bytes = ZYAN_BITSET_BITS_TO_BYTES(count);
+ if (capacity < bytes)
+ {
+ return ZYAN_STATUS_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ bitset->size = count;
+ ZYAN_CHECK(ZyanVectorInitCustomBuffer(&bitset->bits, sizeof(ZyanU8), buffer, capacity,
+ ZYAN_NULL));
+ ZYAN_CHECK(ZyanBitsetInitVectorElements(&bitset->bits, bytes));
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanBitsetDestroy(ZyanBitset* bitset)
+{
+ if (!bitset)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ return ZyanVectorDestroy(&bitset->bits);
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Logical operations */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanBitsetPerformByteOperation(ZyanBitset* destination, const ZyanBitset* source,
+ ZyanBitsetByteOperation operation)
+{
+ if (!destination || !source || !operation)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ ZyanUSize s1;
+ ZyanUSize s2;
+ ZYAN_CHECK(ZyanVectorGetSize(&destination->bits, &s1));
+ ZYAN_CHECK(ZyanVectorGetSize(&source->bits, &s2));
+
+ const ZyanUSize min = ZYAN_MIN(s1, s2);
+ for (ZyanUSize i = 0; i < min; ++i)
+ {
+ ZyanU8* v1;
+ const ZyanU8* v2;
+ ZYAN_CHECK(ZyanVectorGetPointerMutable(&destination->bits, i, (void**)&v1));
+ ZYAN_CHECK(ZyanVectorGetPointer(&source->bits, i, (const void**)&v2));
+
+ ZYAN_ASSERT(v1);
+ ZYAN_ASSERT(v2);
+
+ ZYAN_CHECK(operation(v1, v2));
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanBitsetAND(ZyanBitset* destination, const ZyanBitset* source)
+{
+ return ZyanBitsetPerformByteOperation(destination, source, ZyanBitsetOperationAND);
+}
+
+ZyanStatus ZyanBitsetOR (ZyanBitset* destination, const ZyanBitset* source)
+{
+ return ZyanBitsetPerformByteOperation(destination, source, ZyanBitsetOperationOR );
+}
+
+ZyanStatus ZyanBitsetXOR(ZyanBitset* destination, const ZyanBitset* source)
+{
+ return ZyanBitsetPerformByteOperation(destination, source, ZyanBitsetOperationXOR);
+}
+
+ZyanStatus ZyanBitsetFlip(ZyanBitset* bitset)
+{
+ if (!bitset)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ ZyanUSize size;
+ ZYAN_CHECK(ZyanVectorGetSize(&bitset->bits, &size));
+ for (ZyanUSize i = 0; i < size; ++i)
+ {
+ ZyanU8* value;
+ ZYAN_CHECK(ZyanVectorGetPointerMutable(&bitset->bits, i, (void**)&value));
+ *value = ~(*value);
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Bit access */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanBitsetSet(ZyanBitset* bitset, ZyanUSize index)
+{
+ if (!bitset)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ if (index >= bitset->size)
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ ZyanU8* value;
+ ZYAN_CHECK(ZyanVectorGetPointerMutable(&bitset->bits, index / 8, (void**)&value));
+
+ *value |= (1 << ZYAN_BITSET_BIT_OFFSET(index));
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanBitsetReset(ZyanBitset* bitset, ZyanUSize index)
+{
+ if (!bitset)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ if (index >= bitset->size)
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ ZyanU8* value;
+ ZYAN_CHECK(ZyanVectorGetPointerMutable(&bitset->bits, index / 8, (void**)&value));
+ *value &= ~(1 << ZYAN_BITSET_BIT_OFFSET(index));
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanBitsetAssign(ZyanBitset* bitset, ZyanUSize index, ZyanBool value)
+{
+ if (value)
+ {
+ return ZyanBitsetSet(bitset, index);
+ }
+ return ZyanBitsetReset(bitset, index);
+}
+
+ZyanStatus ZyanBitsetToggle(ZyanBitset* bitset, ZyanUSize index)
+{
+ if (!bitset)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ if (index >= bitset->size)
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ ZyanU8* value;
+ ZYAN_CHECK(ZyanVectorGetPointerMutable(&bitset->bits, index / 8, (void**)&value));
+ *value ^= (1 << ZYAN_BITSET_BIT_OFFSET(index));
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanBitsetTest(ZyanBitset* bitset, ZyanUSize index)
+{
+ if (!bitset)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ if (index >= bitset->size)
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ const ZyanU8* value;
+ ZYAN_CHECK(ZyanVectorGetPointer(&bitset->bits, index / 8, (const void**)&value));
+ if ((*value & (1 << ZYAN_BITSET_BIT_OFFSET(index))) == 0)
+ {
+ return ZYAN_STATUS_FALSE;
+ }
+ return ZYAN_STATUS_TRUE;
+}
+
+ZyanStatus ZyanBitsetTestMSB(ZyanBitset* bitset)
+{
+ if (!bitset)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ return ZyanBitsetTest(bitset, bitset->size - 1);
+}
+
+ZyanStatus ZyanBitsetTestLSB(ZyanBitset* bitset)
+{
+ return ZyanBitsetTest(bitset, 0);
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanBitsetSetAll(ZyanBitset* bitset)
+{
+ if (!bitset)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ ZyanUSize size;
+ ZYAN_CHECK(ZyanVectorGetSize(&bitset->bits, &size));
+ for (ZyanUSize i = 0; i < size; ++i)
+ {
+ ZyanU8* value;
+ ZYAN_CHECK(ZyanVectorGetPointerMutable(&bitset->bits, i, (void**)&value));
+ *value = 0xFF;
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanBitsetResetAll(ZyanBitset* bitset)
+{
+ if (!bitset)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ ZyanUSize size;
+ ZYAN_CHECK(ZyanVectorGetSize(&bitset->bits, &size));
+ for (ZyanUSize i = 0; i < size; ++i)
+ {
+ ZyanU8* value;
+ ZYAN_CHECK(ZyanVectorGetPointerMutable(&bitset->bits, i, (void**)&value));
+ *value = 0x00;
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Size management */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanBitsetPush(ZyanBitset* bitset, ZyanBool value)
+{
+ if (!bitset)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ if ((bitset->size++ % 8) == 0)
+ {
+ static const ZyanU8 zero = 0;
+ ZYAN_CHECK(ZyanVectorPushBack(&bitset->bits, &zero));
+ }
+
+ return ZyanBitsetAssign(bitset, bitset->size - 1, value);
+}
+
+ZyanStatus ZyanBitsetPop(ZyanBitset* bitset)
+{
+ if (!bitset)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ if ((--bitset->size % 8) == 0)
+ {
+ return ZyanVectorPopBack(&bitset->bits);
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanBitsetClear(ZyanBitset* bitset)
+{
+ if (!bitset)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ bitset->size = 0;
+ return ZyanVectorClear(&bitset->bits);
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Memory management */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanBitsetReserve(ZyanBitset* bitset, ZyanUSize count)
+{
+ return ZyanVectorReserve(&bitset->bits, ZYAN_BITSET_BITS_TO_BYTES(count));
+}
+
+ZyanStatus ZyanBitsetShrinkToFit(ZyanBitset* bitset)
+{
+ return ZyanVectorShrinkToFit(&bitset->bits);
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Information */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanBitsetGetSize(const ZyanBitset* bitset, ZyanUSize* size)
+{
+ if (!bitset)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ *size = bitset->size;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanBitsetGetCapacity(const ZyanBitset* bitset, ZyanUSize* capacity)
+{
+ ZYAN_CHECK(ZyanBitsetGetCapacityBytes(bitset, capacity));
+ *capacity *= 8;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanBitsetGetSizeBytes(const ZyanBitset* bitset, ZyanUSize* size)
+{
+ if (!bitset)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ return ZyanVectorGetSize(&bitset->bits, size);
+}
+
+ZyanStatus ZyanBitsetGetCapacityBytes(const ZyanBitset* bitset, ZyanUSize* capacity)
+{
+ if (!bitset)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ return ZyanVectorGetCapacity(&bitset->bits, capacity);
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanBitsetCount(const ZyanBitset* bitset, ZyanUSize* count)
+{
+ if (!bitset || !count)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ *count = 0;
+
+ ZyanUSize size;
+ ZYAN_CHECK(ZyanVectorGetSize(&bitset->bits, &size));
+ for (ZyanUSize i = 0; i < size; ++i)
+ {
+ ZyanU8* value;
+ ZYAN_CHECK(ZyanVectorGetPointer(&bitset->bits, i, (const void**)&value));
+
+ ZyanU8 popcnt = *value;
+ popcnt = (popcnt & 0x55) + ((popcnt >> 1) & 0x55);
+ popcnt = (popcnt & 0x33) + ((popcnt >> 2) & 0x33);
+ popcnt = (popcnt & 0x0F) + ((popcnt >> 4) & 0x0F);
+
+ *count += popcnt;
+ }
+
+ *count = ZYAN_MIN(*count, bitset->size);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanBitsetAll(const ZyanBitset* bitset)
+{
+ if (!bitset)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ ZyanUSize size;
+ ZYAN_CHECK(ZyanVectorGetSize(&bitset->bits, &size));
+ for (ZyanUSize i = 0; i < size; ++i)
+ {
+ ZyanU8* value;
+ ZYAN_CHECK(ZyanVectorGetPointer(&bitset->bits, i, (const void**)&value));
+ if (i < (size - 1))
+ {
+ if (*value != 0xFF)
+ {
+ return ZYAN_STATUS_FALSE;
+ }
+ } else
+ {
+ const ZyanU8 mask = ~(8 - (bitset->size % 8));
+ if ((*value & mask) != mask)
+ {
+ return ZYAN_STATUS_FALSE;
+ }
+ }
+ }
+
+ return ZYAN_STATUS_TRUE;
+}
+
+ZyanStatus ZyanBitsetAny(const ZyanBitset* bitset)
+{
+ if (!bitset)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ ZyanUSize size;
+ ZYAN_CHECK(ZyanVectorGetSize(&bitset->bits, &size));
+ for (ZyanUSize i = 0; i < size; ++i)
+ {
+ ZyanU8* value;
+ ZYAN_CHECK(ZyanVectorGetPointer(&bitset->bits, i, (const void**)&value));
+ if (i < (size - 1))
+ {
+ if (*value != 0x00)
+ {
+ return ZYAN_STATUS_TRUE;
+ }
+ } else
+ {
+ const ZyanU8 mask = ~(8 - (bitset->size % 8));
+ if ((*value & mask) != 0x00)
+ {
+ return ZYAN_STATUS_TRUE;
+ }
+ }
+ }
+
+ return ZYAN_STATUS_FALSE;
+}
+
+ZyanStatus ZyanBitsetNone(const ZyanBitset* bitset)
+{
+ if (!bitset)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ ZyanUSize size;
+ ZYAN_CHECK(ZyanVectorGetSize(&bitset->bits, &size));
+ for (ZyanUSize i = 0; i < size; ++i)
+ {
+ ZyanU8* value;
+ ZYAN_CHECK(ZyanVectorGetPointer(&bitset->bits, i, (const void**)&value));
+ if (i < (size - 1))
+ {
+ if (*value != 0x00)
+ {
+ return ZYAN_STATUS_FALSE;
+ }
+ } else
+ {
+ const ZyanU8 mask = ~(8 - (bitset->size % 8));
+ if ((*value & mask) != 0x00)
+ {
+ return ZYAN_STATUS_FALSE;
+ }
+ }
+ }
+
+ return ZYAN_STATUS_TRUE;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+
+//ZyanStatus ZyanBitsetToU32(const ZyanBitset* bitset, ZyanU32* value)
+//{
+// if (!bitset)
+// {
+// return ZYAN_STATUS_INVALID_ARGUMENT;
+// }
+// if (bitset->size > 32)
+// {
+// return ZYAN_STATUS_INVALID_OPERATION;
+// }
+//
+// // TODO:
+//
+// return ZYAN_STATUS_SUCCESS;
+//}
+//
+//ZyanStatus ZyanBitsetToU64(const ZyanBitset* bitset, ZyanU64* value)
+//{
+// if (!bitset)
+// {
+// return ZYAN_STATUS_INVALID_ARGUMENT;
+// }
+// if (bitset->size > 64)
+// {
+// return ZYAN_STATUS_INVALID_OPERATION;
+// }
+//
+// // TODO:
+//
+// return ZYAN_STATUS_SUCCESS;
+//}
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
diff --git a/detours/detours/zydis/dependencies/zycore/src/Format.c b/detours/detours/zydis/dependencies/zycore/src/Format.c
new file mode 100644
index 0000000..a00196e
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/src/Format.c
@@ -0,0 +1,507 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+#include
+#include
+
+/* ============================================================================================== */
+/* Constants */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Defines */
+/* ---------------------------------------------------------------------------------------------- */
+
+#define ZYCORE_MAXCHARS_DEC_32 10
+#define ZYCORE_MAXCHARS_DEC_64 20
+#define ZYCORE_MAXCHARS_HEX_32 8
+#define ZYCORE_MAXCHARS_HEX_64 16
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Lookup Tables */
+/* ---------------------------------------------------------------------------------------------- */
+
+static const char* const DECIMAL_LOOKUP =
+ "00010203040506070809"
+ "10111213141516171819"
+ "20212223242526272829"
+ "30313233343536373839"
+ "40414243444546474849"
+ "50515253545556575859"
+ "60616263646566676869"
+ "70717273747576777879"
+ "80818283848586878889"
+ "90919293949596979899";
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Static strings */
+/* ---------------------------------------------------------------------------------------------- */
+
+static const ZyanStringView STR_ADD = ZYAN_DEFINE_STRING_VIEW("+");
+static const ZyanStringView STR_SUB = ZYAN_DEFINE_STRING_VIEW("-");
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+/* Internal macros */
+/* ============================================================================================== */
+
+/**
+ * @brief Writes a terminating '\0' character at the end of the string data.
+ */
+#define ZYCORE_STRING_NULLTERMINATE(string) \
+ *(char*)((ZyanU8*)(string)->vector.data + (string)->vector.size - 1) = '\0';
+
+/* ============================================================================================== */
+/* Internal functions */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Decimal */
+/* ---------------------------------------------------------------------------------------------- */
+
+#if defined(ZYAN_X86) || defined(ZYAN_ARM) || defined(ZYAN_EMSCRIPTEN)
+ZyanStatus ZyanStringAppendDecU32(ZyanString* string, ZyanU32 value, ZyanU8 padding_length)
+{
+ if (!string)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ char buffer[ZYCORE_MAXCHARS_DEC_32];
+ char *buffer_end = &buffer[ZYCORE_MAXCHARS_DEC_32];
+ char *buffer_write_pointer = buffer_end;
+ while (value >= 100)
+ {
+ const ZyanU32 value_old = value;
+ buffer_write_pointer -= 2;
+ value /= 100;
+ ZYAN_MEMCPY(buffer_write_pointer, &DECIMAL_LOOKUP[(value_old - (value * 100)) * 2], 2);
+ }
+ buffer_write_pointer -= 2;
+ ZYAN_MEMCPY(buffer_write_pointer, &DECIMAL_LOOKUP[value * 2], 2);
+
+ const ZyanUSize offset_odd = (ZyanUSize)(value < 10);
+ const ZyanUSize length_number = buffer_end - buffer_write_pointer - offset_odd;
+ const ZyanUSize length_total = ZYAN_MAX(length_number, padding_length);
+ const ZyanUSize length_target = string->vector.size;
+
+ if (string->vector.size + length_total > string->vector.capacity)
+ {
+ ZYAN_CHECK(ZyanStringResize(string, string->vector.size + length_total - 1));
+ }
+
+ ZyanUSize offset_write = 0;
+ if (padding_length > length_number)
+ {
+ offset_write = padding_length - length_number;
+ ZYAN_MEMSET((char*)string->vector.data + length_target - 1, '0', offset_write);
+ }
+
+ ZYAN_MEMCPY((char*)string->vector.data + length_target + offset_write - 1,
+ buffer_write_pointer + offset_odd, length_number);
+ string->vector.size = length_target + length_total;
+ ZYCORE_STRING_NULLTERMINATE(string);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+#endif
+
+ZyanStatus ZyanStringAppendDecU64(ZyanString* string, ZyanU64 value, ZyanU8 padding_length)
+{
+ if (!string)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ char buffer[ZYCORE_MAXCHARS_DEC_64];
+ char *buffer_end = &buffer[ZYCORE_MAXCHARS_DEC_64];
+ char *buffer_write_pointer = buffer_end;
+ while (value >= 100)
+ {
+ const ZyanU64 value_old = value;
+ buffer_write_pointer -= 2;
+ value /= 100;
+ ZYAN_MEMCPY(buffer_write_pointer, &DECIMAL_LOOKUP[(value_old - (value * 100)) * 2], 2);
+ }
+ buffer_write_pointer -= 2;
+ ZYAN_MEMCPY(buffer_write_pointer, &DECIMAL_LOOKUP[value * 2], 2);
+
+ const ZyanUSize offset_odd = (ZyanUSize)(value < 10);
+ const ZyanUSize length_number = buffer_end - buffer_write_pointer - offset_odd;
+ const ZyanUSize length_total = ZYAN_MAX(length_number, padding_length);
+ const ZyanUSize length_target = string->vector.size;
+
+ if (string->vector.size + length_total > string->vector.capacity)
+ {
+ ZYAN_CHECK(ZyanStringResize(string, string->vector.size + length_total - 1));
+ }
+
+ ZyanUSize offset_write = 0;
+ if (padding_length > length_number)
+ {
+ offset_write = padding_length - length_number;
+ ZYAN_MEMSET((char*)string->vector.data + length_target - 1, '0', offset_write);
+ }
+
+ ZYAN_MEMCPY((char*)string->vector.data + length_target + offset_write - 1,
+ buffer_write_pointer + offset_odd, length_number);
+ string->vector.size = length_target + length_total;
+ ZYCORE_STRING_NULLTERMINATE(string);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Hexadecimal */
+/* ---------------------------------------------------------------------------------------------- */
+
+#if defined(ZYAN_X86) || defined(ZYAN_ARM) || defined(ZYAN_EMSCRIPTEN)
+ZyanStatus ZyanStringAppendHexU32(ZyanString* string, ZyanU32 value, ZyanU8 padding_length,
+ ZyanBool uppercase)
+{
+ if (!string)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ const ZyanUSize len = string->vector.size;
+ ZyanUSize remaining = string->vector.capacity - string->vector.size;
+
+ if (remaining < (ZyanUSize)padding_length)
+ {
+ ZYAN_CHECK(ZyanStringResize(string, len + padding_length - 1));
+ remaining = padding_length;
+ }
+
+ if (!value)
+ {
+ const ZyanU8 n = (padding_length ? padding_length : 1);
+
+ if (remaining < (ZyanUSize)n)
+ {
+ ZYAN_CHECK(ZyanStringResize(string, string->vector.size + n - 1));
+ }
+
+ ZYAN_MEMSET((char*)string->vector.data + len - 1, '0', n);
+ string->vector.size = len + n;
+ ZYCORE_STRING_NULLTERMINATE(string);
+
+ return ZYAN_STATUS_SUCCESS;
+ }
+
+ ZyanU8 n = 0;
+ char* buffer = ZYAN_NULL;
+ for (ZyanI8 i = ZYCORE_MAXCHARS_HEX_32 - 1; i >= 0; --i)
+ {
+ const ZyanU8 v = (value >> i * 4) & 0x0F;
+ if (!n)
+ {
+ if (!v)
+ {
+ continue;
+ }
+ if (remaining <= (ZyanU8)i)
+ {
+ ZYAN_CHECK(ZyanStringResize(string, string->vector.size + i));
+ }
+ buffer = (char*)string->vector.data + len - 1;
+ if (padding_length > i)
+ {
+ n = padding_length - i - 1;
+ ZYAN_MEMSET(buffer, '0', n);
+ }
+ }
+ ZYAN_ASSERT(buffer);
+ if (uppercase)
+ {
+ buffer[n++] = "0123456789ABCDEF"[v];
+ } else
+ {
+ buffer[n++] = "0123456789abcdef"[v];
+ }
+ }
+ string->vector.size = len + n;
+ ZYCORE_STRING_NULLTERMINATE(string);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+#endif
+
+ZyanStatus ZyanStringAppendHexU64(ZyanString* string, ZyanU64 value, ZyanU8 padding_length,
+ ZyanBool uppercase)
+{
+ if (!string)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ const ZyanUSize len = string->vector.size;
+ ZyanUSize remaining = string->vector.capacity - string->vector.size;
+
+ if (remaining < (ZyanUSize)padding_length)
+ {
+ ZYAN_CHECK(ZyanStringResize(string, len + padding_length - 1));
+ remaining = padding_length;
+ }
+
+ if (!value)
+ {
+ const ZyanU8 n = (padding_length ? padding_length : 1);
+
+ if (remaining < (ZyanUSize)n)
+ {
+ ZYAN_CHECK(ZyanStringResize(string, string->vector.size + n - 1));
+ }
+
+ ZYAN_MEMSET((char*)string->vector.data + len - 1, '0', n);
+ string->vector.size = len + n;
+ ZYCORE_STRING_NULLTERMINATE(string);
+
+ return ZYAN_STATUS_SUCCESS;
+ }
+
+ ZyanU8 n = 0;
+ char* buffer = ZYAN_NULL;
+ for (ZyanI8 i = ((value & 0xFFFFFFFF00000000) ?
+ ZYCORE_MAXCHARS_HEX_64 : ZYCORE_MAXCHARS_HEX_32) - 1; i >= 0; --i)
+ {
+ const ZyanU8 v = (value >> i * 4) & 0x0F;
+ if (!n)
+ {
+ if (!v)
+ {
+ continue;
+ }
+ if (remaining <= (ZyanU8)i)
+ {
+ ZYAN_CHECK(ZyanStringResize(string, string->vector.size + i));
+ }
+ buffer = (char*)string->vector.data + len - 1;
+ if (padding_length > i)
+ {
+ n = padding_length - i - 1;
+ ZYAN_MEMSET(buffer, '0', n);
+ }
+ }
+ ZYAN_ASSERT(buffer);
+ if (uppercase)
+ {
+ buffer[n++] = "0123456789ABCDEF"[v];
+ } else
+ {
+ buffer[n++] = "0123456789abcdef"[v];
+ }
+ }
+ string->vector.size = len + n;
+ ZYCORE_STRING_NULLTERMINATE(string);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+/* Exported functions */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Insertion */
+/* ---------------------------------------------------------------------------------------------- */
+
+//ZyanStatus ZyanStringInsertFormat(ZyanString* string, ZyanUSize index, const char* format, ...)
+//{
+//
+//}
+//
+///* ---------------------------------------------------------------------------------------------- */
+//
+//ZyanStatus ZyanStringInsertDecU(ZyanString* string, ZyanUSize index, ZyanU64 value,
+// ZyanUSize padding_length)
+//{
+//
+//}
+//
+//ZyanStatus ZyanStringInsertDecS(ZyanString* string, ZyanUSize index, ZyanI64 value,
+// ZyanUSize padding_length, ZyanBool force_sign, const ZyanString* prefix)
+//{
+//
+//}
+//
+//ZyanStatus ZyanStringInsertHexU(ZyanString* string, ZyanUSize index, ZyanU64 value,
+// ZyanUSize padding_length, ZyanBool uppercase)
+//{
+//
+//}
+//
+//ZyanStatus ZyanStringInsertHexS(ZyanString* string, ZyanUSize index, ZyanI64 value,
+// ZyanUSize padding_length, ZyanBool uppercase, ZyanBool force_sign, const ZyanString* prefix)
+//{
+//
+//}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Appending */
+/* ---------------------------------------------------------------------------------------------- */
+
+#ifndef ZYAN_NO_LIBC
+
+ZyanStatus ZyanStringAppendFormat(ZyanString* string, const char* format, ...)
+{
+ if (!string || !format)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ ZyanVAList arglist;
+ ZYAN_VA_START(arglist, format);
+
+ const ZyanUSize len = string->vector.size;
+
+ ZyanI32 w = ZYAN_VSNPRINTF((char*)string->vector.data + len - 1,
+ string->vector.capacity - len + 1, format, arglist);
+ if (w < 0)
+ {
+ ZYAN_VA_END(arglist);
+ return ZYAN_STATUS_FAILED;
+ }
+ if (w <= (ZyanI32)(string->vector.capacity - len))
+ {
+ string->vector.size = len + w;
+
+ ZYAN_VA_END(arglist);
+ return ZYAN_STATUS_SUCCESS;
+ }
+
+ // The remaining capacity was not sufficent to fit the formatted string. Trying to resize ..
+ const ZyanStatus status = ZyanStringResize(string, string->vector.size + w - 1);
+ if (!ZYAN_SUCCESS(status))
+ {
+ ZYAN_VA_END(arglist);
+ return status;
+ }
+
+ w = ZYAN_VSNPRINTF((char*)string->vector.data + len - 1,
+ string->vector.capacity - string->vector.size + 1, format, arglist);
+ if (w < 0)
+ {
+ ZYAN_VA_END(arglist);
+ return ZYAN_STATUS_FAILED;
+ }
+ ZYAN_ASSERT(w <= (ZyanI32)(string->vector.capacity - string->vector.size));
+
+ ZYAN_VA_END(arglist);
+ return ZYAN_STATUS_SUCCESS;
+}
+
+#endif // ZYAN_NO_LIBC
+
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanStringAppendDecU(ZyanString* string, ZyanU64 value, ZyanU8 padding_length)
+{
+#if defined(ZYAN_X64) || defined(ZYAN_AARCH64)
+ return ZyanStringAppendDecU64(string, value, padding_length);
+#else
+ // Working with 64-bit values is slow on non 64-bit systems
+ if (value & 0xFFFFFFFF00000000)
+ {
+ return ZyanStringAppendDecU64(string, value, padding_length);
+ }
+ return ZyanStringAppendDecU32(string, (ZyanU32)value, padding_length);
+#endif
+}
+
+ZyanStatus ZyanStringAppendDecS(ZyanString* string, ZyanI64 value, ZyanU8 padding_length,
+ ZyanBool force_sign, const ZyanStringView* prefix)
+{
+ if (value < 0)
+ {
+ ZYAN_CHECK(ZyanStringAppend(string, &STR_SUB));
+ if (prefix)
+ {
+ ZYAN_CHECK(ZyanStringAppend(string, prefix));
+ }
+ return ZyanStringAppendDecU(string, -value, padding_length);
+ }
+
+ if (force_sign)
+ {
+ ZYAN_ASSERT(value >= 0);
+ ZYAN_CHECK(ZyanStringAppend(string, &STR_ADD));
+ }
+
+ if (prefix)
+ {
+ ZYAN_CHECK(ZyanStringAppend(string, prefix));
+ }
+ return ZyanStringAppendDecU(string, value, padding_length);
+}
+
+ZyanStatus ZyanStringAppendHexU(ZyanString* string, ZyanU64 value, ZyanU8 padding_length,
+ ZyanBool uppercase)
+{
+#if defined(ZYAN_X64) || defined(ZYAN_AARCH64)
+ return ZyanStringAppendHexU64(string, value, padding_length, uppercase);
+#else
+ // Working with 64-bit values is slow on non 64-bit systems
+ if (value & 0xFFFFFFFF00000000)
+ {
+ return ZyanStringAppendHexU64(string, value, padding_length, uppercase);
+ }
+ return ZyanStringAppendHexU32(string, (ZyanU32)value, padding_length, uppercase);
+#endif
+}
+
+ZyanStatus ZyanStringAppendHexS(ZyanString* string, ZyanI64 value, ZyanU8 padding_length,
+ ZyanBool uppercase, ZyanBool force_sign, const ZyanStringView* prefix)
+{
+ if (value < 0)
+ {
+ ZYAN_CHECK(ZyanStringAppend(string, &STR_SUB));
+ if (prefix)
+ {
+ ZYAN_CHECK(ZyanStringAppend(string, prefix));
+ }
+ return ZyanStringAppendHexU(string, -value, padding_length, uppercase);
+ }
+
+ if (force_sign)
+ {
+ ZYAN_ASSERT(value >= 0);
+ ZYAN_CHECK(ZyanStringAppend(string, &STR_ADD));
+ }
+
+ if (prefix)
+ {
+ ZYAN_CHECK(ZyanStringAppend(string, prefix));
+ }
+ return ZyanStringAppendHexU(string, value, padding_length, uppercase);
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
diff --git a/detours/detours/zydis/dependencies/zycore/src/List.c b/detours/detours/zydis/dependencies/zycore/src/List.c
new file mode 100644
index 0000000..128c7a9
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/src/List.c
@@ -0,0 +1,673 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+#include
+#include
+
+/* ============================================================================================== */
+/* Internal macros */
+/* ============================================================================================== */
+
+/**
+ * @brief Returns a pointer to the data of the given `node`.
+ *
+ * @param node A pointer to the `ZyanNodeData` struct.
+ *
+ * @return A pointer to the data of the given `node`.
+ */
+#define ZYCORE_LIST_GET_NODE_DATA(node) \
+ ((void*)(node + 1))
+
+/* ============================================================================================== */
+/* Internal functions */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Helper functions */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Allocates memory for a new list node.
+ *
+ * @param list A pointer to the `ZyanList` instance.
+ * @param node Receives a pointer to the new `ZyanListNode` struct.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus ZyanListAllocateNode(ZyanList* list, ZyanListNode** node)
+{
+ ZYAN_ASSERT(list);
+ ZYAN_ASSERT(node);
+
+ const ZyanBool is_dynamic = (list->allocator != ZYAN_NULL);
+ if (is_dynamic)
+ {
+ ZYAN_ASSERT(list->allocator->allocate);
+ ZYAN_CHECK(list->allocator->allocate(list->allocator, (void**)node,
+ sizeof(ZyanListNode) + list->element_size, 1));
+ } else
+ {
+ if (list->first_unused)
+ {
+ *node = list->first_unused;
+ list->first_unused = (*node)->next;
+ } else
+ {
+ const ZyanUSize size = list->size * (sizeof(ZyanListNode) + list->element_size);
+ if (size + (sizeof(ZyanListNode) + list->element_size) > list->capacity)
+ {
+ return ZYAN_STATUS_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ *node = (ZyanListNode*)((ZyanU8*)list->buffer + size);
+ }
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/**
+ * @brief Frees memory of a node.
+ *
+ * @param list A pointer to the `ZyanList` instance.
+ * @param node A pointer to the `ZyanListNode` struct.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus ZyanListDeallocateNode(ZyanList* list, ZyanListNode* node)
+{
+ ZYAN_ASSERT(list);
+ ZYAN_ASSERT(node);
+
+ const ZyanBool is_dynamic = (list->allocator != ZYAN_NULL);
+ if (is_dynamic)
+ {
+ ZYAN_ASSERT(list->allocator->deallocate);
+ ZYAN_CHECK(list->allocator->deallocate(list->allocator, (void*)node,
+ sizeof(ZyanListNode) + list->element_size, 1));
+ } else
+ {
+ node->next = list->first_unused;
+ list->first_unused = node;
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+/* Exported functions */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Constructor and destructor */
+/* ---------------------------------------------------------------------------------------------- */
+
+#ifndef ZYAN_NO_LIBC
+
+ZYAN_REQUIRES_LIBC ZyanStatus ZyanListInit(ZyanList* list, ZyanUSize element_size,
+ ZyanMemberProcedure destructor)
+{
+ return ZyanListInitEx(list, element_size, destructor, ZyanAllocatorDefault());
+}
+
+#endif // ZYAN_NO_LIBC
+
+ZyanStatus ZyanListInitEx(ZyanList* list, ZyanUSize element_size, ZyanMemberProcedure destructor,
+ ZyanAllocator* allocator)
+{
+ if (!list || !element_size || !allocator)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ list->allocator = allocator;
+ list->size = 0;
+ list->element_size = element_size;
+ list->destructor = destructor;
+ list->head = ZYAN_NULL;
+ list->tail = ZYAN_NULL;
+ list->buffer = ZYAN_NULL;
+ list->capacity = 0;
+ list->first_unused = ZYAN_NULL;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanListInitCustomBuffer(ZyanList* list, ZyanUSize element_size,
+ ZyanMemberProcedure destructor, void* buffer, ZyanUSize capacity)
+{
+ if (!list || !element_size || !buffer || !capacity)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ list->allocator = ZYAN_NULL;
+ list->size = 0;
+ list->element_size = element_size;
+ list->destructor = destructor;
+ list->head = ZYAN_NULL;
+ list->tail = ZYAN_NULL;
+ list->buffer = buffer;
+ list->capacity = capacity;
+ list->first_unused = ZYAN_NULL;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanListDestroy(ZyanList* list)
+{
+ if (!list)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ ZYAN_ASSERT(list->element_size);
+
+ const ZyanBool is_dynamic = (list->allocator != ZYAN_NULL);
+ ZyanListNode* node = (is_dynamic || list->destructor) ? list->head : ZYAN_NULL;
+ while (node)
+ {
+ if (list->destructor)
+ {
+ list->destructor(ZYCORE_LIST_GET_NODE_DATA(node));
+ }
+
+ ZyanListNode* const next = node->next;
+
+ if (is_dynamic)
+ {
+ ZYAN_CHECK(list->allocator->deallocate(list->allocator, node,
+ sizeof(ZyanListNode) + list->element_size, 1));
+ }
+
+ node = next;
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Duplication */
+/* ---------------------------------------------------------------------------------------------- */
+
+
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Item access */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanListGetHeadNode(const ZyanList* list, const ZyanListNode** node)
+{
+ if (!list)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ *node = list->head;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanListGetTailNode(const ZyanList* list, const ZyanListNode** node)
+{
+ if (!list)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ *node = list->tail;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanListGetPrevNode(const ZyanListNode** node)
+{
+ if (!node || !*node)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ *node = (*node)->prev;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanListGetNextNode(const ZyanListNode** node)
+{
+ if (!node || !*node)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ *node = (*node)->next;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+const void* ZyanListGetNodeData(const ZyanListNode* node)
+{
+ if (!node)
+ {
+ return ZYAN_NULL;
+ }
+
+ return (const void*)ZYCORE_LIST_GET_NODE_DATA(node);
+}
+
+ZyanStatus ZyanListGetNodeDataEx(const ZyanListNode* node, const void** value)
+{
+ if (!node)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ *value = (const void*)ZYCORE_LIST_GET_NODE_DATA(node);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+void* ZyanListGetNodeDataMutable(const ZyanListNode* node)
+{
+ if (!node)
+ {
+ return ZYAN_NULL;
+ }
+
+ return ZYCORE_LIST_GET_NODE_DATA(node);
+}
+
+ZyanStatus ZyanListGetNodeDataMutableEx(const ZyanListNode* node, void** value)
+{
+ if (!node)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ *value = ZYCORE_LIST_GET_NODE_DATA(node);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanListSetNodeData(const ZyanList* list, const ZyanListNode* node, const void* value)
+{
+ if (!list || !node || !value)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ if (list->destructor)
+ {
+ list->destructor(ZYCORE_LIST_GET_NODE_DATA(node));
+ }
+
+ ZYAN_ASSERT(list->element_size);
+ ZYAN_MEMCPY(ZYCORE_LIST_GET_NODE_DATA(node), value, list->element_size);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Insertion */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanListPushBack(ZyanList* list, const void* item)
+{
+ if (!list || !item)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ ZyanListNode* node;
+ ZYAN_CHECK(ZyanListAllocateNode(list, &node));
+ node->prev = list->tail;
+ node->next = ZYAN_NULL;
+
+ ZYAN_MEMCPY(ZYCORE_LIST_GET_NODE_DATA(node), item, list->element_size);
+
+ if (!list->head)
+ {
+ list->head = node;
+ list->tail = node;
+ } else
+ {
+ list->tail->next = node;
+ list->tail = node;
+ }
+ ++list->size;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanListPushFront(ZyanList* list, const void* item)
+{
+ if (!list || !item)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ ZyanListNode* node;
+ ZYAN_CHECK(ZyanListAllocateNode(list, &node));
+ node->prev = ZYAN_NULL;
+ node->next = list->head;
+
+ ZYAN_MEMCPY(ZYCORE_LIST_GET_NODE_DATA(node), item, list->element_size);
+
+ if (!list->head)
+ {
+ list->head = node;
+ list->tail = node;
+ } else
+ {
+ list->head->prev= node;
+ list->head = node;
+ }
+ ++list->size;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanListEmplaceBack(ZyanList* list, void** item, ZyanMemberFunction constructor)
+{
+ if (!list || !item)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ ZyanListNode* node;
+ ZYAN_CHECK(ZyanListAllocateNode(list, &node));
+ node->prev = list->tail;
+ node->next = ZYAN_NULL;
+
+ *item = ZYCORE_LIST_GET_NODE_DATA(node);
+ if (constructor)
+ {
+ constructor(*item);
+ }
+
+ if (!list->head)
+ {
+ list->head = node;
+ list->tail = node;
+ } else
+ {
+ list->tail->next = node;
+ list->tail = node;
+ }
+ ++list->size;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanListEmplaceFront(ZyanList* list, void** item, ZyanMemberFunction constructor)
+{
+ if (!list || !item)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ ZyanListNode* node;
+ ZYAN_CHECK(ZyanListAllocateNode(list, &node));
+ node->prev = ZYAN_NULL;
+ node->next = list->head;
+
+ *item = ZYCORE_LIST_GET_NODE_DATA(node);
+ if (constructor)
+ {
+ constructor(*item);
+ }
+
+ if (!list->head)
+ {
+ list->head = node;
+ list->tail = node;
+ } else
+ {
+ list->head->prev= node;
+ list->head = node;
+ }
+ ++list->size;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Deletion */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanListPopBack(ZyanList* list)
+{
+ if (!list)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ if (!list->tail)
+ {
+ return ZYAN_STATUS_INVALID_OPERATION;
+ }
+
+ ZyanListNode* const node = list->tail;
+
+ if (list->destructor)
+ {
+ list->destructor(ZYCORE_LIST_GET_NODE_DATA(node));
+ }
+
+ list->tail = node->prev;
+ if (list->tail)
+ {
+ list->tail->next = ZYAN_NULL;
+ }
+ if (list->head == node)
+ {
+ list->head = list->tail;
+ }
+ --list->size;
+
+ return ZyanListDeallocateNode(list, node);
+}
+
+ZyanStatus ZyanListPopFront(ZyanList* list)
+{
+ if (!list)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ if (!list->head)
+ {
+ return ZYAN_STATUS_INVALID_OPERATION;
+ }
+
+ ZyanListNode* const node = list->head;
+
+ if (list->destructor)
+ {
+ list->destructor(ZYCORE_LIST_GET_NODE_DATA(node));
+ }
+
+ list->head = node->next;
+ if (list->head)
+ {
+ list->head->prev = ZYAN_NULL;
+ }
+ if (list->tail == node)
+ {
+ list->tail = list->head;
+ }
+ --list->size;
+
+ return ZyanListDeallocateNode(list, node);
+}
+
+ZyanStatus ZyanListRemove(ZyanList* list, const ZyanListNode* node)
+{
+ ZYAN_UNUSED(list);
+ ZYAN_UNUSED(node);
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanListRemoveRange(ZyanList* list, const ZyanListNode* first, const ZyanListNode* last)
+{
+ ZYAN_UNUSED(list);
+ ZYAN_UNUSED(first);
+ ZYAN_UNUSED(last);
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanListClear(ZyanList* list)
+{
+ return ZyanListResizeEx(list, 0, ZYAN_NULL);
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Searching */
+/* ---------------------------------------------------------------------------------------------- */
+
+
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Memory management */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanListResize(ZyanList* list, ZyanUSize size)
+{
+ return ZyanListResizeEx(list, size, ZYAN_NULL);
+}
+
+ZyanStatus ZyanListResizeEx(ZyanList* list, ZyanUSize size, const void* initializer)
+{
+ if (!list)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ if (size == list->size)
+ {
+ return ZYAN_STATUS_SUCCESS;
+ }
+
+ if (size == 0)
+ {
+ const ZyanBool is_dynamic = (list->allocator != ZYAN_NULL);
+ ZyanListNode* node = (is_dynamic || list->destructor) ? list->head : ZYAN_NULL;
+ while (node)
+ {
+ if (list->destructor)
+ {
+ list->destructor(ZYCORE_LIST_GET_NODE_DATA(node));
+ }
+
+ ZyanListNode* const next = node->next;
+
+ if (is_dynamic)
+ {
+ ZYAN_CHECK(list->allocator->deallocate(list->allocator, node,
+ sizeof(ZyanListNode) + list->element_size, 1));
+ }
+
+ node = next;
+ }
+
+ list->size = 0;
+ list->head = 0;
+ list->tail = 0;
+ list->first_unused = ZYAN_NULL;
+
+ return ZYAN_STATUS_SUCCESS;
+ }
+
+ if (size > list->size)
+ {
+ ZyanListNode* node;
+ for (ZyanUSize i = list->size; i < size; ++i)
+ {
+ ZYAN_CHECK(ZyanListAllocateNode(list, &node));
+ node->prev = list->tail;
+ node->next = ZYAN_NULL;
+
+ if (initializer)
+ {
+ ZYAN_MEMCPY(ZYCORE_LIST_GET_NODE_DATA(node), initializer, list->element_size);
+ }
+
+ if (!list->head)
+ {
+ list->head = node;
+ list->tail = node;
+ } else
+ {
+ list->tail->next = node;
+ list->tail = node;
+ }
+
+ // `ZyanListAllocateNode` needs the list size
+ ++list->size;
+ }
+ } else
+ {
+ for (ZyanUSize i = size; i < list->size; ++i)
+ {
+ ZyanListNode* const node = list->tail;
+
+ if (list->destructor)
+ {
+ list->destructor(ZYCORE_LIST_GET_NODE_DATA(node));
+ }
+
+ list->tail = node->prev;
+ if (list->tail)
+ {
+ list->tail->next = ZYAN_NULL;
+ }
+
+ ZYAN_CHECK(ZyanListDeallocateNode(list, node));
+ }
+
+ list->size = size;
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Information */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanListGetSize(const ZyanList* list, ZyanUSize* size)
+{
+ if (!list)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ *size = list->size;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
diff --git a/detours/detours/zydis/dependencies/zycore/src/String.c b/detours/detours/zydis/dependencies/zycore/src/String.c
new file mode 100644
index 0000000..1c0ddf6
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/src/String.c
@@ -0,0 +1,1086 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+#include
+#include
+
+/* ============================================================================================== */
+/* Internal macros */
+/* ============================================================================================== */
+
+/**
+ * @brief Writes a terminating '\0' character at the end of the string data.
+ */
+#define ZYCORE_STRING_NULLTERMINATE(string) \
+ *(char*)((ZyanU8*)(string)->vector.data + (string)->vector.size - 1) = '\0';
+
+/**
+ * @brief Checks for a terminating '\0' character at the end of the string data.
+ */
+#define ZYCORE_STRING_ASSERT_NULLTERMINATION(string) \
+ ZYAN_ASSERT(*(char*)((ZyanU8*)(string)->vector.data + (string)->vector.size - 1) == '\0');
+
+/* ============================================================================================== */
+/* Exported functions */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Constructor and destructor */
+/* ---------------------------------------------------------------------------------------------- */
+
+#ifndef ZYAN_NO_LIBC
+
+ZyanStatus ZyanStringInit(ZyanString* string, ZyanUSize capacity)
+{
+ return ZyanStringInitEx(string, capacity, ZyanAllocatorDefault(),
+ ZYAN_STRING_DEFAULT_GROWTH_FACTOR, ZYAN_STRING_DEFAULT_SHRINK_THRESHOLD);
+}
+
+#endif // ZYAN_NO_LIBC
+
+ZyanStatus ZyanStringInitEx(ZyanString* string, ZyanUSize capacity, ZyanAllocator* allocator,
+ float growth_factor, float shrink_threshold)
+{
+ if (!string)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ string->flags = 0;
+ capacity = ZYAN_MAX(ZYAN_STRING_MIN_CAPACITY, capacity) + 1;
+ ZYAN_CHECK(ZyanVectorInitEx(&string->vector, sizeof(char), capacity, ZYAN_NULL, allocator,
+ growth_factor, shrink_threshold));
+ ZYAN_ASSERT(string->vector.capacity >= capacity);
+ // Some of the string code relies on `sizeof(char) == 1`
+ ZYAN_ASSERT(string->vector.element_size == 1);
+
+ *(char*)string->vector.data = '\0';
+ ++string->vector.size;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanStringInitCustomBuffer(ZyanString* string, char* buffer, ZyanUSize capacity)
+{
+ if (!string || !capacity)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ string->flags = ZYAN_STRING_HAS_FIXED_CAPACITY;
+ ZYAN_CHECK(ZyanVectorInitCustomBuffer(&string->vector, sizeof(char), (void*)buffer, capacity,
+ ZYAN_NULL));
+ ZYAN_ASSERT(string->vector.capacity == capacity);
+ // Some of the string code relies on `sizeof(char) == 1`
+ ZYAN_ASSERT(string->vector.element_size == 1);
+
+ *(char*)string->vector.data = '\0';
+ ++string->vector.size;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanStringDestroy(ZyanString* string)
+{
+ if (!string)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ if (string->flags & ZYAN_STRING_HAS_FIXED_CAPACITY)
+ {
+ return ZYAN_STATUS_SUCCESS;
+ }
+
+ return ZyanVectorDestroy(&string->vector);
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Duplication */
+/* ---------------------------------------------------------------------------------------------- */
+
+#ifndef ZYAN_NO_LIBC
+
+ZyanStatus ZyanStringDuplicate(ZyanString* destination, const ZyanStringView* source,
+ ZyanUSize capacity)
+{
+ return ZyanStringDuplicateEx(destination, source, capacity, ZyanAllocatorDefault(),
+ ZYAN_STRING_DEFAULT_GROWTH_FACTOR, ZYAN_STRING_DEFAULT_SHRINK_THRESHOLD);
+}
+
+#endif // ZYAN_NO_LIBC
+
+ZyanStatus ZyanStringDuplicateEx(ZyanString* destination, const ZyanStringView* source,
+ ZyanUSize capacity, ZyanAllocator* allocator, float growth_factor, float shrink_threshold)
+{
+ if (!source || !source->string.vector.size)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ const ZyanUSize len = source->string.vector.size;
+ capacity = ZYAN_MAX(capacity, len - 1);
+ ZYAN_CHECK(ZyanStringInitEx(destination, capacity, allocator, growth_factor, shrink_threshold));
+ ZYAN_ASSERT(destination->vector.capacity >= len);
+
+ ZYAN_MEMCPY(destination->vector.data, source->string.vector.data,
+ source->string.vector.size - 1);
+ destination->vector.size = len;
+ ZYCORE_STRING_NULLTERMINATE(destination);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanStringDuplicateCustomBuffer(ZyanString* destination, const ZyanStringView* source,
+ char* buffer, ZyanUSize capacity)
+{
+ if (!source || !source->string.vector.size)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ const ZyanUSize len = source->string.vector.size;
+ if (capacity < len)
+ {
+ return ZYAN_STATUS_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ ZYAN_CHECK(ZyanStringInitCustomBuffer(destination, buffer, capacity));
+ ZYAN_ASSERT(destination->vector.capacity >= len);
+
+ ZYAN_MEMCPY(destination->vector.data, source->string.vector.data,
+ source->string.vector.size - 1);
+ destination->vector.size = len;
+ ZYCORE_STRING_NULLTERMINATE(destination);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Concatenation */
+/* ---------------------------------------------------------------------------------------------- */
+
+#ifndef ZYAN_NO_LIBC
+
+ZyanStatus ZyanStringConcat(ZyanString* destination, const ZyanStringView* s1,
+ const ZyanStringView* s2, ZyanUSize capacity)
+{
+ return ZyanStringConcatEx(destination, s1, s2, capacity, ZyanAllocatorDefault(),
+ ZYAN_STRING_DEFAULT_GROWTH_FACTOR, ZYAN_STRING_DEFAULT_SHRINK_THRESHOLD);
+}
+
+#endif // ZYAN_NO_LIBC
+
+ZyanStatus ZyanStringConcatEx(ZyanString* destination, const ZyanStringView* s1,
+ const ZyanStringView* s2, ZyanUSize capacity, ZyanAllocator* allocator, float growth_factor,
+ float shrink_threshold)
+{
+ if (!s1 || !s2 || !s1->string.vector.size || !s2->string.vector.size)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ const ZyanUSize len = s1->string.vector.size + s2->string.vector.size - 1;
+ capacity = ZYAN_MAX(capacity, len - 1);
+ ZYAN_CHECK(ZyanStringInitEx(destination, capacity, allocator, growth_factor, shrink_threshold));
+ ZYAN_ASSERT(destination->vector.capacity >= len);
+
+ ZYAN_MEMCPY(destination->vector.data, s1->string.vector.data, s1->string.vector.size - 1);
+ ZYAN_MEMCPY((char*)destination->vector.data + s1->string.vector.size - 1,
+ s2->string.vector.data, s2->string.vector.size - 1);
+ destination->vector.size = len;
+ ZYCORE_STRING_NULLTERMINATE(destination);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanStringConcatCustomBuffer(ZyanString* destination, const ZyanStringView* s1,
+ const ZyanStringView* s2, char* buffer, ZyanUSize capacity)
+{
+ if (!s1 || !s2 || !s1->string.vector.size || !s2->string.vector.size)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ const ZyanUSize len = s1->string.vector.size + s2->string.vector.size - 1;
+ if (capacity < len)
+ {
+ return ZYAN_STATUS_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ ZYAN_CHECK(ZyanStringInitCustomBuffer(destination, buffer, capacity));
+ ZYAN_ASSERT(destination->vector.capacity >= len);
+
+ ZYAN_MEMCPY(destination->vector.data, s1->string.vector.data, s1->string.vector.size - 1);
+ ZYAN_MEMCPY((char*)destination->vector.data + s1->string.vector.size - 1,
+ s2->string.vector.data, s2->string.vector.size - 1);
+ destination->vector.size = len;
+ ZYCORE_STRING_NULLTERMINATE(destination);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Views */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanStringViewInsideView(ZyanStringView* view, const ZyanStringView* source)
+{
+ if (!view || !source)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ view->string.vector.data = source->string.vector.data;
+ view->string.vector.size = source->string.vector.size;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanStringViewInsideViewEx(ZyanStringView* view, const ZyanStringView* source,
+ ZyanUSize index, ZyanUSize count)
+{
+ if (!view || !source)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ if (index + count >= source->string.vector.size)
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ view->string.vector.data = (void*)((char*)source->string.vector.data + index);
+ view->string.vector.size = count;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanStringViewInsideBuffer(ZyanStringView* view, const char* string)
+{
+ if (!view || !string)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ view->string.vector.data = (void*)string;
+ view->string.vector.size = ZYAN_STRLEN(string) + 1;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanStringViewInsideBufferEx(ZyanStringView* view, const char* buffer, ZyanUSize length)
+{
+ if (!view || !buffer || !length)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ view->string.vector.data = (void*)buffer;
+ view->string.vector.size = length + 1;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanStringViewGetSize(const ZyanStringView* view, ZyanUSize* size)
+{
+ if (!view || !size)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ ZYAN_ASSERT(view->string.vector.size >= 1);
+ *size = view->string.vector.size - 1;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Character access */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanStringGetChar(const ZyanStringView* string, ZyanUSize index, char* value)
+{
+ if (!string || !value)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ // Don't allow direct access to the terminating '\0' character
+ if (index + 1 >= string->string.vector.size)
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ const char* chr;
+ ZYAN_CHECK(ZyanVectorGetPointer(&string->string.vector, index, (const void**)&chr));
+ *value = *chr;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanStringGetCharMutable(ZyanString* string, ZyanUSize index, char** value)
+{
+ if (!string)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ // Don't allow direct access to the terminating '\0' character
+ if (index + 1 >= string->vector.size)
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ return ZyanVectorGetPointerMutable(&string->vector, index, (void**)value);
+}
+
+ZyanStatus ZyanStringSetChar(ZyanString* string, ZyanUSize index, char value)
+{
+ if (!string)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ // Don't allow direct access to the terminating '\0' character
+ if (index + 1 >= string->vector.size)
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ return ZyanVectorSet(&string->vector, index, (void*)&value);
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Insertion */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanStringInsert(ZyanString* destination, ZyanUSize index, const ZyanStringView* source)
+{
+ if (!destination || !source || !source->string.vector.size)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ if (index == destination->vector.size)
+ {
+ return ZyanStringAppend(destination, source);
+ }
+
+ // Don't allow insertion after the terminating '\0' character
+ if (index >= destination->vector.size)
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ ZYAN_CHECK(ZyanVectorInsertRange(&destination->vector, index, source->string.vector.data,
+ source->string.vector.size - 1));
+ ZYCORE_STRING_ASSERT_NULLTERMINATION(destination);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanStringInsertEx(ZyanString* destination, ZyanUSize destination_index,
+ const ZyanStringView* source, ZyanUSize source_index, ZyanUSize count)
+{
+ if (!destination || !source || !source->string.vector.size)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ if (destination_index == destination->vector.size)
+ {
+ return ZyanStringAppendEx(destination, source, source_index, count);
+ }
+
+ // Don't allow insertion after the terminating '\0' character
+ if (destination_index >= destination->vector.size)
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ // Don't allow access to the terminating '\0' character
+ if (source_index + count >= source->string.vector.size)
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ ZYAN_CHECK(ZyanVectorInsertRange(&destination->vector, destination_index,
+ (char*)source->string.vector.data + source_index, count));
+ ZYCORE_STRING_ASSERT_NULLTERMINATION(destination);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Appending */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanStringAppend(ZyanString* destination, const ZyanStringView* source)
+{
+ if (!destination || !source || !source->string.vector.size)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ const ZyanUSize len = destination->vector.size;
+ ZYAN_CHECK(ZyanVectorResize(&destination->vector, len + source->string.vector.size - 1));
+ ZYAN_MEMCPY((char*)destination->vector.data + len - 1, source->string.vector.data,
+ source->string.vector.size - 1);
+ ZYCORE_STRING_NULLTERMINATE(destination);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanStringAppendEx(ZyanString* destination, const ZyanStringView* source,
+ ZyanUSize source_index, ZyanUSize count)
+{
+ if (!destination || !source || !source->string.vector.size)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ // Don't allow access to the terminating '\0' character
+ if (source_index + count >= source->string.vector.size)
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ const ZyanUSize len = destination->vector.size;
+ ZYAN_CHECK(ZyanVectorResize(&destination->vector, len + count));
+ ZYAN_MEMCPY((char*)destination->vector.data + len - 1,
+ (const char*)source->string.vector.data + source_index, count);
+ ZYCORE_STRING_NULLTERMINATE(destination);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Deletion */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanStringDelete(ZyanString* string, ZyanUSize index, ZyanUSize count)
+{
+ if (!string)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ // Don't allow removal of the terminating '\0' character
+ if (index + count >= string->vector.size)
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ ZYAN_CHECK(ZyanVectorDeleteRange(&string->vector, index, count));
+ ZYCORE_STRING_NULLTERMINATE(string);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanStringTruncate(ZyanString* string, ZyanUSize index)
+{
+ if (!string)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ // Don't allow removal of the terminating '\0' character
+ if (index >= string->vector.size)
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ ZYAN_CHECK(ZyanVectorDeleteRange(&string->vector, index, string->vector.size - index - 1));
+ ZYCORE_STRING_NULLTERMINATE(string);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanStringClear(ZyanString* string)
+{
+ if (!string)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ ZYAN_CHECK(ZyanVectorClear(&string->vector));
+ // `ZyanVector` guarantees a minimum capacity of 1 element/character
+ ZYAN_ASSERT(string->vector.capacity >= 1);
+
+ *(char*)string->vector.data = '\0';
+ string->vector.size++;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Searching */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanStringLPos(const ZyanStringView* haystack, const ZyanStringView* needle,
+ ZyanISize* found_index)
+{
+ if (!haystack)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ return ZyanStringLPosEx(haystack, needle, found_index, 0, haystack->string.vector.size - 1);
+}
+
+ZyanStatus ZyanStringLPosEx(const ZyanStringView* haystack, const ZyanStringView* needle,
+ ZyanISize* found_index, ZyanUSize index, ZyanUSize count)
+{
+ if (!haystack || !needle || !found_index)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ // Don't allow access to the terminating '\0' character
+ if (index + count >= haystack->string.vector.size)
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ if ((haystack->string.vector.size == 1) || (needle->string.vector.size == 1) ||
+ (haystack->string.vector.size < needle->string.vector.size))
+ {
+ *found_index = -1;
+ return ZYAN_STATUS_FALSE;
+ }
+
+ const char* s = (const char*)haystack->string.vector.data + index;
+ const char* b = (const char*)needle->string.vector.data;
+ for (; s + 1 < (const char*)haystack->string.vector.data + haystack->string.vector.size; ++s)
+ {
+ if (*s != *b)
+ {
+ continue;
+ }
+ const char* a = s;
+ for (;;)
+ {
+ if ((ZyanUSize)(a - (const char*)haystack->string.vector.data) > index + count)
+ {
+ *found_index = -1;
+ return ZYAN_STATUS_FALSE;
+ }
+ if (*b == 0)
+ {
+ *found_index = (ZyanISize)(s - (const char*)haystack->string.vector.data);
+ return ZYAN_STATUS_TRUE;
+ }
+ if (*a++ != *b++)
+ {
+ break;
+ }
+ }
+ b = (char*)needle->string.vector.data;
+ }
+
+ *found_index = -1;
+ return ZYAN_STATUS_FALSE;
+}
+
+ZyanStatus ZyanStringLPosI(const ZyanStringView* haystack, const ZyanStringView* needle,
+ ZyanISize* found_index)
+{
+ if (!haystack)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ return ZyanStringLPosIEx(haystack, needle, found_index, 0, haystack->string.vector.size - 1);
+}
+
+ZyanStatus ZyanStringLPosIEx(const ZyanStringView* haystack, const ZyanStringView* needle,
+ ZyanISize* found_index, ZyanUSize index, ZyanUSize count)
+{
+ // This solution assumes that characters are represented using ASCII representation, i.e.,
+ // codes for 'a', 'b', 'c', .. 'z' are 97, 98, 99, .. 122 respectively. And codes for 'A',
+ // 'B', 'C', .. 'Z' are 65, 66, .. 95 respectively.
+
+ if (!haystack || !needle || !found_index)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ // Don't allow access to the terminating '\0' character
+ if (index + count >= haystack->string.vector.size)
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ if ((haystack->string.vector.size == 1) || (needle->string.vector.size == 1) ||
+ (haystack->string.vector.size < needle->string.vector.size))
+ {
+ *found_index = -1;
+ return ZYAN_STATUS_FALSE;
+ }
+
+ const char* s = (const char*)haystack->string.vector.data + index;
+ const char* b = (const char*)needle->string.vector.data;
+ for (; s + 1 < (const char*)haystack->string.vector.data + haystack->string.vector.size; ++s)
+ {
+ if ((*s != *b) && ((*s ^ 32) != *b))
+ {
+ continue;
+ }
+ const char* a = s;
+ for (;;)
+ {
+ if ((ZyanUSize)(a - (const char*)haystack->string.vector.data) > index + count)
+ {
+ *found_index = -1;
+ return ZYAN_STATUS_FALSE;
+ }
+ if (*b == 0)
+ {
+ *found_index = (ZyanISize)(s - (const char*)haystack->string.vector.data);
+ return ZYAN_STATUS_TRUE;
+ }
+ const char c1 = *a++;
+ const char c2 = *b++;
+ if ((c1 != c2) && ((c1 ^ 32) != c2))
+ {
+ break;
+ }
+ }
+ b = (char*)needle->string.vector.data;
+ }
+
+ *found_index = -1;
+ return ZYAN_STATUS_FALSE;
+}
+
+ZyanStatus ZyanStringRPos(const ZyanStringView* haystack, const ZyanStringView* needle,
+ ZyanISize* found_index)
+{
+ if (!haystack)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ return ZyanStringRPosEx(haystack, needle, found_index, haystack->string.vector.size - 1,
+ haystack->string.vector.size - 1);
+}
+
+ZyanStatus ZyanStringRPosEx(const ZyanStringView* haystack, const ZyanStringView* needle,
+ ZyanISize* found_index, ZyanUSize index, ZyanUSize count)
+{
+ if (!haystack || !needle || !found_index)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ // Don't allow access to the terminating '\0' character
+ if ((index >= haystack->string.vector.size) || (count > index))
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ if (!index || !count ||
+ (haystack->string.vector.size == 1) || (needle->string.vector.size == 1) ||
+ (haystack->string.vector.size < needle->string.vector.size))
+ {
+ *found_index = -1;
+ return ZYAN_STATUS_FALSE;
+ }
+
+ const char* s = (const char*)haystack->string.vector.data + index - 1;
+ const char* b = (const char*)needle->string.vector.data + needle->string.vector.size - 2;
+ for (; s >= (const char*)haystack->string.vector.data; --s)
+ {
+ if (*s != *b)
+ {
+ continue;
+ }
+ const char* a = s;
+ for (;;)
+ {
+ if (b < (const char*)needle->string.vector.data)
+ {
+ *found_index = (ZyanISize)(a - (const char*)haystack->string.vector.data + 1);
+ return ZYAN_STATUS_TRUE;
+ }
+ if (a < (const char*)haystack->string.vector.data + index - count)
+ {
+ *found_index = -1;
+ return ZYAN_STATUS_FALSE;
+ }
+ if (*a-- != *b--)
+ {
+ break;
+ }
+ }
+ b = (char*)needle->string.vector.data + needle->string.vector.size - 2;
+ }
+
+ *found_index = -1;
+ return ZYAN_STATUS_FALSE;
+}
+
+ZyanStatus ZyanStringRPosI(const ZyanStringView* haystack, const ZyanStringView* needle,
+ ZyanISize* found_index)
+{
+ if (!haystack)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ return ZyanStringRPosIEx(haystack, needle, found_index, haystack->string.vector.size - 1,
+ haystack->string.vector.size - 1);
+}
+
+ZyanStatus ZyanStringRPosIEx(const ZyanStringView* haystack, const ZyanStringView* needle,
+ ZyanISize* found_index, ZyanUSize index, ZyanUSize count)
+{
+ // This solution assumes that characters are represented using ASCII representation, i.e.,
+ // codes for 'a', 'b', 'c', .. 'z' are 97, 98, 99, .. 122 respectively. And codes for 'A',
+ // 'B', 'C', .. 'Z' are 65, 66, .. 95 respectively.
+
+ if (!haystack || !needle || !found_index)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ // Don't allow access to the terminating '\0' character
+ if ((index >= haystack->string.vector.size) || (count > index))
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ if (!index || !count ||
+ (haystack->string.vector.size == 1) || (needle->string.vector.size == 1) ||
+ (haystack->string.vector.size < needle->string.vector.size))
+ {
+ *found_index = -1;
+ return ZYAN_STATUS_FALSE;
+ }
+
+ const char* s = (const char*)haystack->string.vector.data + index - 1;
+ const char* b = (const char*)needle->string.vector.data + needle->string.vector.size - 2;
+ for (; s >= (const char*)haystack->string.vector.data; --s)
+ {
+ if ((*s != *b) && ((*s ^ 32) != *b))
+ {
+ continue;
+ }
+ const char* a = s;
+ for (;;)
+ {
+ if (b < (const char*)needle->string.vector.data)
+ {
+ *found_index = (ZyanISize)(a - (const char*)haystack->string.vector.data + 1);
+ return ZYAN_STATUS_TRUE;
+ }
+ if (a < (const char*)haystack->string.vector.data + index - count)
+ {
+ *found_index = -1;
+ return ZYAN_STATUS_FALSE;
+ }
+ const char c1 = *a--;
+ const char c2 = *b--;
+ if ((c1 != c2) && ((c1 ^ 32) != c2))
+ {
+ break;
+ }
+ }
+ b = (char*)needle->string.vector.data + needle->string.vector.size - 2;
+ }
+
+ *found_index = -1;
+ return ZYAN_STATUS_FALSE;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Comparing */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanStringCompare(const ZyanStringView* s1, const ZyanStringView* s2, ZyanI32* result)
+{
+ if (!s1 || !s2)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ if (s1->string.vector.size < s2->string.vector.size)
+ {
+ *result = -1;
+ return ZYAN_STATUS_FALSE;
+ }
+ if (s1->string.vector.size > s2->string.vector.size)
+ {
+ *result = 1;
+ return ZYAN_STATUS_FALSE;
+ }
+
+ const char* const a = (char*)s1->string.vector.data;
+ const char* const b = (char*)s2->string.vector.data;
+ ZyanUSize i;
+ for (i = 0; (i + 1 < s1->string.vector.size) && (i + 1 < s2->string.vector.size); ++i)
+ {
+ if (a[i] == b[i])
+ {
+ continue;
+ }
+ break;
+ }
+
+ if (a[i] == b[i])
+ {
+ *result = 0;
+ return ZYAN_STATUS_TRUE;
+ }
+
+ if ((a[i] | 32) < (b[i] | 32))
+ {
+ *result = -1;
+ return ZYAN_STATUS_FALSE;
+ }
+
+ *result = 1;
+ return ZYAN_STATUS_FALSE;
+}
+
+ZyanStatus ZyanStringCompareI(const ZyanStringView* s1, const ZyanStringView* s2, ZyanI32* result)
+{
+ // This solution assumes that characters are represented using ASCII representation, i.e.,
+ // codes for 'a', 'b', 'c', .. 'z' are 97, 98, 99, .. 122 respectively. And codes for 'A',
+ // 'B', 'C', .. 'Z' are 65, 66, .. 95 respectively.
+
+ if (!s1 || !s2)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ if (s1->string.vector.size < s2->string.vector.size)
+ {
+ *result = -1;
+ return ZYAN_STATUS_FALSE;
+ }
+ if (s1->string.vector.size > s2->string.vector.size)
+ {
+ *result = 1;
+ return ZYAN_STATUS_FALSE;
+ }
+
+ const char* const a = (char*)s1->string.vector.data;
+ const char* const b = (char*)s2->string.vector.data;
+ ZyanUSize i;
+ for (i = 0; (i + 1 < s1->string.vector.size) && (i + 1 < s2->string.vector.size); ++i)
+ {
+ if ((a[i] == b[i]) || ((a[i] ^ 32) == b[i]))
+ {
+ continue;
+ }
+ break;
+ }
+
+ if (a[i] == b[i])
+ {
+ *result = 0;
+ return ZYAN_STATUS_TRUE;
+ }
+
+ if ((a[i] | 32) < (b[i] | 32))
+ {
+ *result = -1;
+ return ZYAN_STATUS_FALSE;
+ }
+
+ *result = 1;
+ return ZYAN_STATUS_FALSE;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Case conversion */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanStringToLowerCase(ZyanString* string)
+{
+ if (!string)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ return ZyanStringToLowerCaseEx(string, 0, string->vector.size - 1);
+}
+
+ZyanStatus ZyanStringToLowerCaseEx(ZyanString* string, ZyanUSize index, ZyanUSize count)
+{
+ // This solution assumes that characters are represented using ASCII representation, i.e.,
+ // codes for 'a', 'b', 'c', .. 'z' are 97, 98, 99, .. 122 respectively. And codes for 'A',
+ // 'B', 'C', .. 'Z' are 65, 66, .. 95 respectively.
+
+ if (!string)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ // Don't allow access to the terminating '\0' character
+ if (index + count >= string->vector.size)
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ char* s = (char*)string->vector.data + index;
+ for (ZyanUSize i = index; i < index + count; ++i)
+ {
+ const char c = *s;
+ if ((c >= 'A') && (c <= 'Z'))
+ {
+ *s = c | 32;
+ }
+ ++s;
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanStringToUpperCase(ZyanString* string)
+{
+ if (!string)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ return ZyanStringToUpperCaseEx(string, 0, string->vector.size - 1);
+}
+
+ZyanStatus ZyanStringToUpperCaseEx(ZyanString* string, ZyanUSize index, ZyanUSize count)
+{
+ // This solution assumes that characters are represented using ASCII representation, i.e.,
+ // codes for 'a', 'b', 'c', .. 'z' are 97, 98, 99, .. 122 respectively. And codes for 'A',
+ // 'B', 'C', .. 'Z' are 65, 66, .. 95 respectively.
+
+ if (!string)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ // Don't allow access to the terminating '\0' character
+ if (index + count >= string->vector.size)
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ char* s = (char*)string->vector.data + index;
+ for (ZyanUSize i = index; i < index + count; ++i)
+ {
+ const char c = *s;
+ if ((c >= 'a') && (c <= 'z'))
+ {
+ *s = c & ~32;
+ }
+ ++s;
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Memory management */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanStringResize(ZyanString* string, ZyanUSize size)
+{
+ if (!string)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ ZYAN_CHECK(ZyanVectorResize(&string->vector, size + 1));
+ ZYCORE_STRING_NULLTERMINATE(string);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanStringReserve(ZyanString* string, ZyanUSize capacity)
+{
+ if (!string)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ return ZyanVectorReserve(&string->vector, capacity);
+}
+
+ZyanStatus ZyanStringShrinkToFit(ZyanString* string)
+{
+ if (!string)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ return ZyanVectorShrinkToFit(&string->vector);
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Information */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanStringGetCapacity(const ZyanString* string, ZyanUSize* capacity)
+{
+ if (!string)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ ZYAN_ASSERT(string->vector.capacity >= 1);
+ *capacity = string->vector.capacity - 1;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanStringGetSize(const ZyanString* string, ZyanUSize* size)
+{
+ if (!string)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ ZYAN_ASSERT(string->vector.size >= 1);
+ *size = string->vector.size - 1;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanStringGetData(const ZyanString* string, const char** value)
+{
+ if (!string)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ *value = string->vector.data;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
diff --git a/detours/detours/zydis/dependencies/zycore/src/Vector.c b/detours/detours/zydis/dependencies/zycore/src/Vector.c
new file mode 100644
index 0000000..2f6c145
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/src/Vector.c
@@ -0,0 +1,847 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+#include
+#include
+
+/* ============================================================================================== */
+/* Internal macros */
+/* ============================================================================================== */
+
+/**
+ * @brief Checks, if the passed vector should grow.
+ *
+ * @param size The desired size of the vector.
+ * @param capacity The current capacity of the vector.
+ *
+ * @return `ZYAN_TRUE`, if the vector should grow or `ZYAN_FALSE`, if not.
+ */
+#define ZYCORE_VECTOR_SHOULD_GROW(size, capacity) \
+ ((size) > (capacity))
+
+/**
+ * @brief Checks, if the passed vector should shrink.
+ *
+ * @param size The desired size of the vector.
+ * @param capacity The current capacity of the vector.
+ * @param threshold The shrink threshold.
+ *
+ * @return `ZYAN_TRUE`, if the vector should shrink or `ZYAN_FALSE`, if not.
+ */
+#define ZYCORE_VECTOR_SHOULD_SHRINK(size, capacity, threshold) \
+ ((size) < (capacity) * (threshold))
+
+/**
+ * @brief Returns the offset of the element at the given `index`.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param index The element index.
+ *
+ * @return The offset of the element at the given `index`.
+ */
+#define ZYCORE_VECTOR_OFFSET(vector, index) \
+ ((void*)((ZyanU8*)(vector)->data + ((index) * (vector)->element_size)))
+
+/* ============================================================================================== */
+/* Internal functions */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Helper functions */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Reallocates the internal buffer of the vector.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param capacity The new capacity.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus ZyanVectorReallocate(ZyanVector* vector, ZyanUSize capacity)
+{
+ ZYAN_ASSERT(vector);
+ ZYAN_ASSERT(vector->capacity >= ZYAN_VECTOR_MIN_CAPACITY);
+ ZYAN_ASSERT(vector->element_size);
+ ZYAN_ASSERT(vector->data);
+
+ if (!vector->allocator)
+ {
+ if (vector->capacity < capacity)
+ {
+ return ZYAN_STATUS_INSUFFICIENT_BUFFER_SIZE;
+ }
+ return ZYAN_STATUS_SUCCESS;
+ }
+
+ ZYAN_ASSERT(vector->allocator);
+ ZYAN_ASSERT(vector->allocator->reallocate);
+
+ if (capacity < ZYAN_VECTOR_MIN_CAPACITY)
+ {
+ if (vector->capacity > ZYAN_VECTOR_MIN_CAPACITY)
+ {
+ capacity = ZYAN_VECTOR_MIN_CAPACITY;
+ } else
+ {
+ return ZYAN_STATUS_SUCCESS;
+ }
+ }
+
+ vector->capacity = capacity;
+ ZYAN_CHECK(vector->allocator->reallocate(vector->allocator, &vector->data,
+ vector->element_size, vector->capacity));
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/**
+ * @brief Shifts all elements starting at the specified `index` by the amount of `count` to the
+ * left.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param index The start index.
+ * @param count The amount of shift operations.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus ZyanVectorShiftLeft(ZyanVector* vector, ZyanUSize index, ZyanUSize count)
+{
+ ZYAN_ASSERT(vector);
+ ZYAN_ASSERT(vector->element_size);
+ ZYAN_ASSERT(vector->data);
+ ZYAN_ASSERT(count > 0);
+ //ZYAN_ASSERT((ZyanISize)count - (ZyanISize)index + 1 >= 0);
+
+ void* const source = ZYCORE_VECTOR_OFFSET(vector, index + count);
+ void* const dest = ZYCORE_VECTOR_OFFSET(vector, index);
+ const ZyanUSize size = (vector->size - index - count) * vector->element_size;
+ ZYAN_MEMMOVE(dest, source, size);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/**
+ * @brief Shifts all elements starting at the specified `index` by the amount of `count` to the
+ * right.
+ *
+ * @param vector A pointer to the `ZyanVector` instance.
+ * @param index The start index.
+ * @param count The amount of shift operations.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus ZyanVectorShiftRight(ZyanVector* vector, ZyanUSize index, ZyanUSize count)
+{
+ ZYAN_ASSERT(vector);
+ ZYAN_ASSERT(vector->element_size);
+ ZYAN_ASSERT(vector->data);
+ ZYAN_ASSERT(count > 0);
+ ZYAN_ASSERT(vector->size + count <= vector->capacity);
+
+ void* const source = ZYCORE_VECTOR_OFFSET(vector, index);
+ void* const dest = ZYCORE_VECTOR_OFFSET(vector, index + count);
+ const ZyanUSize size = (vector->size - index) * vector->element_size;
+ ZYAN_MEMMOVE(dest, source, size);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+/* Exported functions */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Constructor and destructor */
+/* ---------------------------------------------------------------------------------------------- */
+
+#ifndef ZYAN_NO_LIBC
+
+ZyanStatus ZyanVectorInit(ZyanVector* vector, ZyanUSize element_size, ZyanUSize capacity,
+ ZyanMemberProcedure destructor)
+{
+ return ZyanVectorInitEx(vector, element_size, capacity, destructor, ZyanAllocatorDefault(),
+ ZYAN_VECTOR_DEFAULT_GROWTH_FACTOR, ZYAN_VECTOR_DEFAULT_SHRINK_THRESHOLD);
+}
+
+#endif // ZYAN_NO_LIBC
+
+ZyanStatus ZyanVectorInitEx(ZyanVector* vector, ZyanUSize element_size, ZyanUSize capacity,
+ ZyanMemberProcedure destructor, ZyanAllocator* allocator, float growth_factor,
+ float shrink_threshold)
+{
+ if (!vector || !element_size || !allocator || (growth_factor < 1.0f) ||
+ (shrink_threshold < 0.0f) || (shrink_threshold > 1.0f))
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ ZYAN_ASSERT(allocator->allocate);
+
+ vector->allocator = allocator;
+ vector->growth_factor = growth_factor;
+ vector->shrink_threshold = shrink_threshold;
+ vector->size = 0;
+ vector->capacity = ZYAN_MAX(ZYAN_VECTOR_MIN_CAPACITY, capacity);
+ vector->element_size = element_size;
+ vector->destructor = destructor;
+ vector->data = ZYAN_NULL;
+
+ return allocator->allocate(vector->allocator, &vector->data, vector->element_size,
+ vector->capacity);
+}
+
+ZyanStatus ZyanVectorInitCustomBuffer(ZyanVector* vector, ZyanUSize element_size,
+ void* buffer, ZyanUSize capacity, ZyanMemberProcedure destructor)
+{
+ if (!vector || !element_size || !buffer || !capacity)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ vector->allocator = ZYAN_NULL;
+ vector->growth_factor = 1.0f;
+ vector->shrink_threshold = 0.0f;
+ vector->size = 0;
+ vector->capacity = capacity;
+ vector->element_size = element_size;
+ vector->destructor = destructor;
+ vector->data = buffer;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanVectorDestroy(ZyanVector* vector)
+{
+ if (!vector)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ ZYAN_ASSERT(vector->element_size);
+ ZYAN_ASSERT(vector->data);
+
+ if (vector->destructor)
+ {
+ for (ZyanUSize i = 0; i < vector->size; ++i)
+ {
+ vector->destructor(ZYCORE_VECTOR_OFFSET(vector, i));
+ }
+ }
+
+ if (vector->allocator && vector->capacity)
+ {
+ ZYAN_ASSERT(vector->allocator->deallocate);
+ ZYAN_CHECK(vector->allocator->deallocate(vector->allocator, vector->data,
+ vector->element_size, vector->capacity));
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Duplication */
+/* ---------------------------------------------------------------------------------------------- */
+
+#ifndef ZYAN_NO_LIBC
+
+ZyanStatus ZyanVectorDuplicate(ZyanVector* destination, const ZyanVector* source,
+ ZyanUSize capacity)
+{
+ return ZyanVectorDuplicateEx(destination, source, capacity, ZyanAllocatorDefault(),
+ ZYAN_VECTOR_DEFAULT_GROWTH_FACTOR, ZYAN_VECTOR_DEFAULT_SHRINK_THRESHOLD);
+}
+
+#endif // ZYAN_NO_LIBC
+
+ZyanStatus ZyanVectorDuplicateEx(ZyanVector* destination, const ZyanVector* source,
+ ZyanUSize capacity, ZyanAllocator* allocator, float growth_factor, float shrink_threshold)
+{
+ if (!source)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ const ZyanUSize len = source->size;
+
+ capacity = ZYAN_MAX(capacity, len);
+ ZYAN_CHECK(ZyanVectorInitEx(destination, source->element_size, capacity, source->destructor,
+ allocator, growth_factor, shrink_threshold));
+ ZYAN_ASSERT(destination->capacity >= len);
+
+ ZYAN_MEMCPY(destination->data, source->data, len * source->element_size);
+ destination->size = len;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanVectorDuplicateCustomBuffer(ZyanVector* destination, const ZyanVector* source,
+ void* buffer, ZyanUSize capacity)
+{
+ if (!source)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ const ZyanUSize len = source->size;
+
+ if (capacity < len)
+ {
+ return ZYAN_STATUS_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ ZYAN_CHECK(ZyanVectorInitCustomBuffer(destination, source->element_size, buffer, capacity,
+ source->destructor));
+ ZYAN_ASSERT(destination->capacity >= len);
+
+ ZYAN_MEMCPY(destination->data, source->data, len * source->element_size);
+ destination->size = len;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Element access */
+/* ---------------------------------------------------------------------------------------------- */
+
+const void* ZyanVectorGet(const ZyanVector* vector, ZyanUSize index)
+{
+ if (!vector || (index >= vector->size))
+ {
+ return ZYAN_NULL;
+ }
+
+ ZYAN_ASSERT(vector->element_size);
+ ZYAN_ASSERT(vector->data);
+
+ return ZYCORE_VECTOR_OFFSET(vector, index);
+}
+
+void* ZyanVectorGetMutable(const ZyanVector* vector, ZyanUSize index)
+{
+ if (!vector || (index >= vector->size))
+ {
+ return ZYAN_NULL;
+ }
+
+ ZYAN_ASSERT(vector->element_size);
+ ZYAN_ASSERT(vector->data);
+
+ return ZYCORE_VECTOR_OFFSET(vector, index);
+}
+
+ZyanStatus ZyanVectorGetPointer(const ZyanVector* vector, ZyanUSize index, const void** value)
+{
+ if (!vector || !value)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ if (index >= vector->size)
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ ZYAN_ASSERT(vector->element_size);
+ ZYAN_ASSERT(vector->data);
+
+ *value = (const void*)ZYCORE_VECTOR_OFFSET(vector, index);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanVectorGetPointerMutable(const ZyanVector* vector, ZyanUSize index, void** value)
+{
+ if (!vector || !value)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ if (index >= vector->size)
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ ZYAN_ASSERT(vector->element_size);
+ ZYAN_ASSERT(vector->data);
+
+ *value = ZYCORE_VECTOR_OFFSET(vector, index);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanVectorSet(ZyanVector* vector, ZyanUSize index, const void* value)
+{
+ if (!vector || !value)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ if (index >= vector->size)
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ ZYAN_ASSERT(vector->element_size);
+ ZYAN_ASSERT(vector->data);
+
+ void* const offset = ZYCORE_VECTOR_OFFSET(vector, index);
+ if (vector->destructor)
+ {
+ vector->destructor(offset);
+ }
+ ZYAN_MEMCPY(offset, value, vector->element_size);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Insertion */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanVectorPushBack(ZyanVector* vector, const void* element)
+{
+ if (!vector || !element)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ ZYAN_ASSERT(vector->element_size);
+ ZYAN_ASSERT(vector->data);
+
+ if (ZYCORE_VECTOR_SHOULD_GROW(vector->size + 1, vector->capacity))
+ {
+ ZYAN_CHECK(ZyanVectorReallocate(vector,
+ ZYAN_MAX(1, (ZyanUSize)((vector->size + 1) * vector->growth_factor))));
+ }
+
+ void* const offset = ZYCORE_VECTOR_OFFSET(vector, vector->size);
+ ZYAN_MEMCPY(offset, element, vector->element_size);
+
+ ++vector->size;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanVectorInsert(ZyanVector* vector, ZyanUSize index, const void* element)
+{
+ return ZyanVectorInsertRange(vector, index, element, 1);
+}
+
+ZyanStatus ZyanVectorInsertRange(ZyanVector* vector, ZyanUSize index, const void* elements,
+ ZyanUSize count)
+{
+ if (!vector || !elements || !count)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ if (index > vector->size)
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ ZYAN_ASSERT(vector->element_size);
+ ZYAN_ASSERT(vector->data);
+
+ if (ZYCORE_VECTOR_SHOULD_GROW(vector->size + count, vector->capacity))
+ {
+ ZYAN_CHECK(ZyanVectorReallocate(vector,
+ ZYAN_MAX(1, (ZyanUSize)((vector->size + count) * vector->growth_factor))));
+ }
+
+ if (index < vector->size)
+ {
+ ZYAN_CHECK(ZyanVectorShiftRight(vector, index, count));
+ }
+
+ void* const offset = ZYCORE_VECTOR_OFFSET(vector, index);
+ ZYAN_MEMCPY(offset, elements, count * vector->element_size);
+ vector->size += count;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanVectorEmplace(ZyanVector* vector, void** element, ZyanMemberFunction constructor)
+{
+ if (!vector)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ return ZyanVectorEmplaceEx(vector, vector->size, element, constructor);
+}
+
+ZyanStatus ZyanVectorEmplaceEx(ZyanVector* vector, ZyanUSize index, void** element,
+ ZyanMemberFunction constructor)
+{
+ if (!vector)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ if (index > vector->size)
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ ZYAN_ASSERT(vector->element_size);
+ ZYAN_ASSERT(vector->data);
+
+ if (ZYCORE_VECTOR_SHOULD_GROW(vector->size + 1, vector->capacity))
+ {
+ ZYAN_CHECK(ZyanVectorReallocate(vector,
+ ZYAN_MAX(1, (ZyanUSize)((vector->size + 1) * vector->growth_factor))));
+ }
+
+ if (index < vector->size)
+ {
+ ZYAN_CHECK(ZyanVectorShiftRight(vector, index, 1));
+ }
+
+ *element = ZYCORE_VECTOR_OFFSET(vector, index);
+ if (constructor)
+ {
+ ZYAN_CHECK(constructor(*element));
+ }
+
+ ++vector->size;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Utils */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanVectorSwapElements(ZyanVector* vector, ZyanUSize index_first, ZyanUSize index_second)
+{
+ if (!vector)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ if ((index_first >= vector->size) || (index_second >= vector->size))
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ if (vector->size == vector->capacity)
+ {
+ return ZYAN_STATUS_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ ZYAN_ASSERT(vector->element_size);
+ ZYAN_ASSERT(vector->data);
+
+ ZyanU64* const t = ZYCORE_VECTOR_OFFSET(vector, vector->size);
+ ZyanU64* const a = ZYCORE_VECTOR_OFFSET(vector, index_first);
+ ZyanU64* const b = ZYCORE_VECTOR_OFFSET(vector, index_second);
+ ZYAN_MEMCPY(t, a, vector->element_size);
+ ZYAN_MEMCPY(a, b, vector->element_size);
+ ZYAN_MEMCPY(b, t, vector->element_size);
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Deletion */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanVectorDelete(ZyanVector* vector, ZyanUSize index)
+{
+ return ZyanVectorDeleteRange(vector, index, 1);
+}
+
+ZyanStatus ZyanVectorDeleteRange(ZyanVector* vector, ZyanUSize index, ZyanUSize count)
+{
+ if (!vector || !count)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ if (index + count > vector->size)
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ if (vector->destructor)
+ {
+ for (ZyanUSize i = index; i < index + count; ++i)
+ {
+ vector->destructor(ZYCORE_VECTOR_OFFSET(vector, i));
+ }
+ }
+
+ if (index + count < vector->size)
+ {
+ ZYAN_CHECK(ZyanVectorShiftLeft(vector, index, count));
+ }
+
+ vector->size -= count;
+ if (ZYCORE_VECTOR_SHOULD_SHRINK(vector->size, vector->capacity, vector->shrink_threshold))
+ {
+ return ZyanVectorReallocate(vector,
+ ZYAN_MAX(1, (ZyanUSize)(vector->size * vector->growth_factor)));
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanVectorPopBack(ZyanVector* vector)
+{
+ if (!vector)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ if (vector->size == 0)
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ if (vector->destructor)
+ {
+ vector->destructor(ZYCORE_VECTOR_OFFSET(vector, vector->size - 1));
+ }
+
+ --vector->size;
+ if (ZYCORE_VECTOR_SHOULD_SHRINK(vector->size, vector->capacity, vector->shrink_threshold))
+ {
+ return ZyanVectorReallocate(vector,
+ ZYAN_MAX(1, (ZyanUSize)(vector->size * vector->growth_factor)));
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanVectorClear(ZyanVector* vector)
+{
+ return ZyanVectorResizeEx(vector, 0, ZYAN_NULL);
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Searching */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanVectorFind(const ZyanVector* vector, const void* element, ZyanISize* found_index,
+ ZyanEqualityComparison comparison)
+{
+ if (!vector)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ return ZyanVectorFindEx(vector, element, found_index, comparison, 0, vector->size);
+}
+
+ZyanStatus ZyanVectorFindEx(const ZyanVector* vector, const void* element, ZyanISize* found_index,
+ ZyanEqualityComparison comparison, ZyanUSize index, ZyanUSize count)
+{
+ if (!vector)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ if ((index + count > vector->size) || (index == vector->size))
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ if (!count)
+ {
+ *found_index = -1;
+ return ZYAN_STATUS_FALSE;
+ }
+
+ ZYAN_ASSERT(vector->element_size);
+ ZYAN_ASSERT(vector->data);
+
+ for (ZyanUSize i = index; i < index + count; ++i)
+ {
+ if (comparison(ZYCORE_VECTOR_OFFSET(vector, i), element))
+ {
+ *found_index = i;
+ return ZYAN_STATUS_TRUE;
+ }
+ }
+
+ *found_index = -1;
+ return ZYAN_STATUS_FALSE;
+}
+
+ZyanStatus ZyanVectorBinarySearch(const ZyanVector* vector, const void* element,
+ ZyanUSize* found_index, ZyanComparison comparison)
+{
+ if (!vector)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ return ZyanVectorBinarySearchEx(vector, element, found_index, comparison, 0, vector->size);
+}
+
+ZyanStatus ZyanVectorBinarySearchEx(const ZyanVector* vector, const void* element,
+ ZyanUSize* found_index, ZyanComparison comparison, ZyanUSize index, ZyanUSize count)
+{
+ if (!vector)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ if (((index >= vector->size) && (count > 0)) || (index + count > vector->size))
+ {
+ return ZYAN_STATUS_OUT_OF_RANGE;
+ }
+
+ if (!count)
+ {
+ *found_index = index;
+ return ZYAN_STATUS_FALSE;
+ }
+
+ ZYAN_ASSERT(vector->element_size);
+ ZYAN_ASSERT(vector->data);
+
+ ZyanStatus status = ZYAN_STATUS_FALSE;
+ ZyanISize l = index;
+ ZyanISize h = index + count - 1;
+ while (l <= h)
+ {
+ const ZyanUSize mid = l + ((h - l) >> 1);
+ const ZyanI32 cmp = comparison(ZYCORE_VECTOR_OFFSET(vector, mid), element);
+ if (cmp < 0)
+ {
+ l = mid + 1;
+ } else
+ {
+ h = mid - 1;
+ if (cmp == 0)
+ {
+ status = ZYAN_STATUS_TRUE;
+ }
+ }
+ }
+
+ *found_index = l;
+ return status;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Memory management */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanVectorResize(ZyanVector* vector, ZyanUSize size)
+{
+ return ZyanVectorResizeEx(vector, size, ZYAN_NULL);
+}
+
+ZyanStatus ZyanVectorResizeEx(ZyanVector* vector, ZyanUSize size, const void* initializer)
+{
+ if (!vector)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ if (size == vector->size)
+ {
+ return ZYAN_STATUS_SUCCESS;
+ }
+
+ if (vector->destructor && (size < vector->size))
+ {
+ for (ZyanUSize i = size; i < vector->size; ++i)
+ {
+ vector->destructor(ZYCORE_VECTOR_OFFSET(vector, i));
+ }
+ }
+
+ if (ZYCORE_VECTOR_SHOULD_GROW(size, vector->capacity) ||
+ ZYCORE_VECTOR_SHOULD_SHRINK(size, vector->capacity, vector->shrink_threshold))
+ {
+ ZYAN_CHECK(ZyanVectorReallocate(vector, (ZyanUSize)(size * vector->growth_factor)));
+ };
+
+ if (initializer && (size > vector->size))
+ {
+ for (ZyanUSize i = vector->size; i < size; ++i)
+ {
+ ZYAN_MEMCPY(ZYCORE_VECTOR_OFFSET(vector, i), initializer, vector->element_size);
+ }
+ }
+
+ vector->size = size;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanVectorReserve(ZyanVector* vector, ZyanUSize capacity)
+{
+ if (!vector)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ if (capacity > vector->capacity)
+ {
+ ZYAN_CHECK(ZyanVectorReallocate(vector, capacity));
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanVectorShrinkToFit(ZyanVector* vector)
+{
+ if (!vector)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ return ZyanVectorReallocate(vector, vector->size);
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Information */
+/* ---------------------------------------------------------------------------------------------- */
+
+ZyanStatus ZyanVectorGetCapacity(const ZyanVector* vector, ZyanUSize* capacity)
+{
+ if (!vector)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ *capacity = vector->capacity;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZyanStatus ZyanVectorGetSize(const ZyanVector* vector, ZyanUSize* size)
+{
+ if (!vector)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ *size = vector->size;
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
diff --git a/detours/detours/zydis/dependencies/zycore/src/Zycore.c b/detours/detours/zydis/dependencies/zycore/src/Zycore.c
new file mode 100644
index 0000000..9bbb200
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/src/Zycore.c
@@ -0,0 +1,38 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+#include
+
+/* ============================================================================================== */
+/* Exported functions */
+/* ============================================================================================== */
+
+ZyanU64 ZycoreGetVersion(void)
+{
+ return ZYCORE_VERSION;
+}
+
+/* ============================================================================================== */
diff --git a/detours/detours/zydis/dependencies/zycore/tests/String.cpp b/detours/detours/zydis/dependencies/zycore/tests/String.cpp
new file mode 100644
index 0000000..3c00fb9
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/tests/String.cpp
@@ -0,0 +1,69 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+/**
+ * @file
+ * @brief Tests the `ZyanString` implementation.
+ */
+
+#include
+#include
+
+/* ============================================================================================== */
+/* Enums and types */
+/* ============================================================================================== */
+
+
+
+/* ============================================================================================== */
+/* Helper functions */
+/* ============================================================================================== */
+
+
+
+/* ============================================================================================== */
+/* Tests */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* */
+/* ---------------------------------------------------------------------------------------------- */
+
+
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+/* Entry point */
+/* ============================================================================================== */
+
+int main(int argc, char **argv)
+{
+ ::testing::InitGoogleTest(&argc, argv);
+ return RUN_ALL_TESTS();
+}
+
+/* ============================================================================================== */
diff --git a/detours/detours/zydis/dependencies/zycore/tests/Vector.cpp b/detours/detours/zydis/dependencies/zycore/tests/Vector.cpp
new file mode 100644
index 0000000..bb87567
--- /dev/null
+++ b/detours/detours/zydis/dependencies/zycore/tests/Vector.cpp
@@ -0,0 +1,505 @@
+/***************************************************************************************************
+
+ Zyan Core Library (Zycore-C)
+
+ Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+/**
+ * @file
+ * @brief Tests the `ZyanVector` implementation.
+ */
+
+#include
+#include
+#include
+#include
+
+/* ============================================================================================== */
+/* Fixtures */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* VectorTestBase */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Implements a fixture-class that provides an initialized `ZyanVector` instance for
+ * `ZyanU64` values.
+ */
+class VectorTestBase : public ::testing::TestWithParam
+{
+protected:
+ static const ZyanUSize m_test_size = 100;
+ ZyanBool m_has_fixed_capacity;
+ ZyanVector m_vector;
+ std::vector m_buffer;
+protected:
+ void SetUp() override
+ {
+ m_has_fixed_capacity = GetParam();
+
+ if (!m_has_fixed_capacity)
+ {
+ ASSERT_EQ(ZyanVectorInit(&m_vector, sizeof(ZyanU64), m_test_size,
+ reinterpret_cast(ZYAN_NULL)), ZYAN_STATUS_SUCCESS);
+ } else
+ {
+ m_buffer.reserve(m_test_size);
+ ASSERT_EQ(ZyanVectorInitCustomBuffer(&m_vector, sizeof(ZyanU64), m_buffer.data(),
+ m_test_size, reinterpret_cast(ZYAN_NULL)),
+ ZYAN_STATUS_SUCCESS);
+ }
+ }
+
+ void TearDown() override
+ {
+ EXPECT_EQ(ZyanVectorDestroy(&m_vector), ZYAN_STATUS_SUCCESS);
+ }
+};
+
+/* ---------------------------------------------------------------------------------------------- */
+/* VectorTestFilled */
+/* ---------------------------------------------------------------------------------------------- */
+
+/**
+ * @brief Implements a fixture-class that provides an initialized `ZyanVector` instance which
+ * is filled with `ZyanU64` values from 0..100.
+ */
+class VectorTestFilled : public VectorTestBase
+{
+protected:
+ void SetUp() override
+ {
+ VectorTestBase::SetUp();
+
+ if (m_has_fixed_capacity)
+ {
+ m_buffer.resize(m_test_size);
+ }
+ for (ZyanU64 i = 0; i < m_test_size; ++i)
+ {
+ ASSERT_EQ(ZyanVectorPushBack(&m_vector, &i), ZYAN_STATUS_SUCCESS);
+ }
+ }
+};
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+/* Helper functions */
+/* ============================================================================================== */
+
+/**
+ * @brief A dummy constructor for `ZyanU64` objects.
+ *
+ * @param object A pointer to the object.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus InitZyanU64(ZyanU64* object)
+{
+ *object = 1337;
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/**
+ * @brief A dummy destructor for `ZyanU16` objects.
+ *
+ * @param object A pointer to the object.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus FreeZyanU16(ZyanU16* object)
+{
+ *object = 0;
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ============================================================================================== */
+/* Tests */
+/* ============================================================================================== */
+
+TEST(VectorTest, InitBasic)
+{
+ ZyanVector vector;
+
+ ASSERT_EQ(ZyanVectorInit(&vector, sizeof(ZyanU64), 0,
+ reinterpret_cast(ZYAN_NULL)), ZYAN_STATUS_SUCCESS);
+ EXPECT_EQ(vector.allocator, ZyanAllocatorDefault());
+ EXPECT_FLOAT_EQ(vector.growth_factor, ZYAN_VECTOR_DEFAULT_GROWTH_FACTOR);
+ EXPECT_FLOAT_EQ(vector.shrink_threshold, ZYAN_VECTOR_DEFAULT_SHRINK_THRESHOLD);
+ EXPECT_EQ(vector.size, static_cast(0));
+ EXPECT_EQ(vector.capacity, static_cast(ZYAN_VECTOR_MIN_CAPACITY));
+ EXPECT_EQ(vector.element_size, sizeof(ZyanU64));
+ EXPECT_NE(vector.data, ZYAN_NULL);
+ EXPECT_EQ(ZyanVectorDestroy(&vector), ZYAN_STATUS_SUCCESS);
+
+ // Custom capacity
+ EXPECT_EQ(ZyanVectorInit(&vector, sizeof(ZyanU16), 10,
+ reinterpret_cast(ZYAN_NULL)), ZYAN_STATUS_SUCCESS);
+ EXPECT_EQ(vector.capacity, static_cast(ZYAN_MAX(ZYAN_VECTOR_MIN_CAPACITY, 10)));
+ EXPECT_EQ(ZyanVectorDestroy(&vector), ZYAN_STATUS_SUCCESS);
+}
+
+TEST(VectorTest, InitAdvanced)
+{
+ ZyanVector vector;
+
+ ASSERT_EQ(ZyanVectorInitEx(&vector, sizeof(ZyanU16), 0,
+ reinterpret_cast(ZYAN_NULL), ZyanAllocatorDefault(), 1.0f, 0.0f),
+ ZYAN_STATUS_SUCCESS);
+ EXPECT_EQ(vector.allocator, ZyanAllocatorDefault());
+ EXPECT_FLOAT_EQ(vector.growth_factor, 1.0f);
+ EXPECT_FLOAT_EQ(vector.shrink_threshold, 0.0f);
+ EXPECT_EQ(vector.size, static_cast(0));
+ EXPECT_EQ(vector.capacity, static_cast(ZYAN_VECTOR_MIN_CAPACITY));
+ EXPECT_EQ(vector.element_size, sizeof(ZyanU16));
+ EXPECT_NE(vector.data, ZYAN_NULL);
+ EXPECT_EQ(ZyanVectorDestroy(&vector), ZYAN_STATUS_SUCCESS);
+
+ // Custom capacity
+ EXPECT_EQ(ZyanVectorInitEx(&vector, sizeof(ZyanU16), 10,
+ reinterpret_cast(ZYAN_NULL), ZyanAllocatorDefault(), 1.0f, 0.0f),
+ ZYAN_STATUS_SUCCESS);
+ EXPECT_EQ(vector.capacity, static_cast(ZYAN_MAX(ZYAN_VECTOR_MIN_CAPACITY, 10)));
+ EXPECT_EQ(ZyanVectorDestroy(&vector), ZYAN_STATUS_SUCCESS);
+}
+
+TEST(VectorTest, InitCustomBuffer)
+{
+ ZyanVector vector;
+
+ ZyanU16 buffer[32];
+ EXPECT_EQ(ZyanVectorInitCustomBuffer(&vector, sizeof(ZyanU16), &buffer, 0,
+ reinterpret_cast(ZYAN_NULL)), ZYAN_STATUS_INVALID_ARGUMENT);
+ ASSERT_EQ(ZyanVectorInitCustomBuffer(&vector, sizeof(ZyanU16), &buffer,
+ ZYAN_ARRAY_LENGTH(buffer), reinterpret_cast(ZYAN_NULL)),
+ ZYAN_STATUS_SUCCESS);
+ EXPECT_EQ(vector.allocator, ZYAN_NULL);
+ EXPECT_FLOAT_EQ(vector.growth_factor, 1.0f);
+ EXPECT_FLOAT_EQ(vector.shrink_threshold, 0.0f);
+ EXPECT_EQ(vector.size, static_cast(0));
+ EXPECT_EQ(vector.capacity, ZYAN_ARRAY_LENGTH(buffer));
+ EXPECT_EQ(vector.element_size, sizeof(ZyanU16));
+ EXPECT_EQ(vector.data, &buffer);
+ EXPECT_EQ(ZyanVectorDestroy(&vector), ZYAN_STATUS_SUCCESS);
+}
+
+TEST(VectorTest, Destructor)
+{
+ ZyanVector vector;
+
+ ZyanU16 buffer[16];
+ ASSERT_EQ(ZyanVectorInitCustomBuffer(&vector, sizeof(ZyanU16), &buffer,
+ ZYAN_ARRAY_LENGTH(buffer), reinterpret_cast(&FreeZyanU16)),
+ ZYAN_STATUS_SUCCESS);
+
+ for (ZyanUSize i = 0; i < ZYAN_ARRAY_LENGTH(buffer); ++i)
+ {
+ const auto element = static_cast