summaryrefslogtreecommitdiffstats
path: root/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/src/uncrustify_emscripten.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'debian/uncrustify-trinity/uncrustify-trinity-0.78.1/src/uncrustify_emscripten.cpp')
-rw-r--r--debian/uncrustify-trinity/uncrustify-trinity-0.78.1/src/uncrustify_emscripten.cpp1213
1 files changed, 1213 insertions, 0 deletions
diff --git a/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/src/uncrustify_emscripten.cpp b/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/src/uncrustify_emscripten.cpp
new file mode 100644
index 00000000..790e7ece
--- /dev/null
+++ b/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/src/uncrustify_emscripten.cpp
@@ -0,0 +1,1213 @@
+/*
+ * uncrustify_emscripten.cpp - JavaScript Emscripten binding interface
+ *
+ * Created on: May 8, 2016
+ * Author: Daniel Chumak
+ *
+ * INTERFACE:
+ * ============================================================================
+ * unsure about these:
+ * --check TODO ???
+ * --decode TODO ???
+ * --detect TODO needs uncrustify start and end which both are static
+ *
+ *
+ * will not be included:
+ * ----------------------------------------------------------------------------
+ * -t ( define via multiple --type )
+ * -d ( define via multiple --define )
+ * --assume ( no files available to guess the lang. based on the filename ending )
+ * --files ( no batch processing will be available )
+ * --prefix
+ * --suffix
+ * --assume
+ * --no-backup
+ * --replace
+ * --mtime
+ * --universalindent
+ * --ds/--dump-steps
+ * -help, -h, --usage, -?
+ *
+ *
+ * done:
+ * ----------------------------------------------------------------------------
+ * --update-config ( use show_config() )
+ * --update-config-with-doc ( show_config( bool withDoc = true ) )
+ * --version, -v ( use get_version() )
+ * --log, -L ( use log_type_enable( log_sev_t sev, bool value ) )
+ * -q ( use quiet() )
+ * --config, -c ( use loadConfig( string _cfg ) )
+ * --file, -f ( use uncrustify( string _file ) )
+ * --show ( use log_type_show_name( bool ) )
+ * --frag ( use uncrustify( string _file, bool frag = true ) )
+ * --type ( use add_keyword( string _type, E_Token type ) )
+ * -l ( use uncrustify() )
+ * --parsed, -p ( use debug() )
+ */
+
+
+#if defined (__linux__)
+
+
+#include "keywords.h"
+#include "log_levels.h"
+#include "logger.h"
+#include "option.h"
+#include "options.h"
+#include "output.h"
+#include "prototypes.h"
+#include "uncrustify.h"
+#include "uncrustify_version.h"
+#include "unicode.h"
+
+#include <iostream>
+#include <map>
+#include <memory>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unordered_map>
+#include <vector>
+
+
+#ifdef EMSCRIPTEN
+#include <emscripten/bind.h>
+#include <emscripten/val.h>
+using namespace emscripten;
+#else
+#define EMSCRIPTEN_BINDINGS(module) void dummyFcn()
+template<class T>
+struct base {};
+struct emscripten
+{
+ template<class... Args>
+ emscripten value(Args...) { return{}; }
+
+ template<class... Args>
+ static emscripten function(Args...) { return{}; }
+
+ template<class... Args>
+ emscripten property(Args...) { return{}; }
+};
+using Dummy = emscripten;
+
+
+template<class T>
+Dummy enum_(char const *const)
+{
+ return(Dummy{});
+}
+
+
+template<class T>
+Dummy register_vector(char const *const)
+{
+ return(Dummy{});
+}
+
+
+template<class... Args>
+Dummy class_(char const *const)
+{
+ return(Dummy{});
+}
+
+
+template<class T>
+Dummy select_overload(T)
+{
+ return(Dummy{});
+}
+#endif
+
+using namespace std;
+using namespace uncrustify;
+
+namespace
+{
+
+/**
+ * Loads options from a file represented as a single char array.
+ * Modifies: input char array, cpd.line_number
+ * Expects: \0 terminated char array
+ *
+ * @param configString char array that holds the whole config
+ * @return EXIT_SUCCESS on success
+ */
+int load_option_fileChar(char *configString)
+{
+ char *delimPos = &configString[0];
+ char *subStringStart = &configString[0];
+
+ cpd.line_number = 0;
+
+ // TODO: handle compat_level
+ int compat_level = 0;
+
+ while (true)
+ {
+ delimPos = strchr(delimPos, '\n');
+
+ if (delimPos == nullptr)
+ {
+ break;
+ }
+ // replaces \n with \0 -> string including multiple terminated substrings
+ *delimPos = '\0';
+
+
+ process_option_line(subStringStart, "", compat_level);
+
+ delimPos++;
+ subStringStart = delimPos;
+ }
+ //get last line, expectation: ends with \0
+ process_option_line(subStringStart, "", compat_level);
+
+ return(EXIT_SUCCESS);
+}
+
+
+/**
+ * adds a new keyword to Uncrustify's dynamic keyword map (dkwm, keywords.cpp)
+ *
+ * @param tag: keyword that is going to be added
+ * @param type: type of the keyword
+ */
+void _add_keyword(string tag, E_Token type)
+{
+ if (tag.empty())
+ {
+ LOG_FMT(LERR, "%s: input string is empty\n", __func__);
+ return;
+ }
+ add_keyword(tag, type);
+}
+
+
+//! clears Uncrustify's dynamic keyword map (dkwm, keywords.cpp)
+void clear_keywords()
+{
+ clear_keyword_file();
+}
+
+
+/**
+ * Show or hide the severity prefix "<1>"
+ *
+ * @param b: true=show, false=hide
+ */
+void show_log_type(bool b)
+{
+ log_show_sev(b);
+}
+
+
+//! returns the UNCRUSTIFY_VERSION string
+string get_version()
+{
+ return(UNCRUSTIFY_VERSION);
+}
+
+
+//! disables all logging messages
+void set_quiet()
+{
+ // set empty mask
+ log_set_mask({});
+}
+
+
+/**
+ * resets value of an option to its default
+ *
+ * @param name: name of the option
+ * @return options enum value of the found option or -1 if option was not found
+ */
+int reset_option(string name)
+{
+ if (name.empty())
+ {
+ LOG_FMT(LERR, "%s: name string is empty\n", __func__);
+ return(-1);
+ }
+ const auto option = find_option(name.c_str());
+
+ if (option == nullptr)
+ {
+ LOG_FMT(LERR, "Option %s not found\n", name.c_str());
+ return(-1);
+ }
+ option->reset();
+ return(0);
+}
+
+
+/**
+ * sets value of an option
+ *
+ * @param name: name of the option
+ * @param value: value that is going to be set
+ * @return options enum value of the found option or -1 if option was not found
+ */
+int set_option(string name, string value)
+{
+ if (name.empty())
+ {
+ LOG_FMT(LERR, "%s: name string is empty\n", __func__);
+ return(-1);
+ }
+
+ if (value.empty())
+ {
+ LOG_FMT(LERR, "%s: value string is empty\n", __func__);
+ return(-1);
+ }
+ const auto option = find_option(name.c_str());
+
+ if (option == nullptr)
+ {
+ LOG_FMT(LERR, "Option %s not found\n", name.c_str());
+ return(-1);
+ }
+
+ if (!option->read(value.c_str()))
+ {
+ LOG_FMT(
+ LERR,
+ "Failed to set value %s for option: %s of type: %s\n",
+ name.c_str(),
+ value.c_str(),
+ to_string(option->type())
+ );
+ return(-1);
+ }
+ return(0);
+}
+
+
+/**
+ * returns value of an option
+ *
+ * @param name: name of the option
+ * @return currently set value of the option
+ */
+string get_option(string name)
+{
+ if (name.empty())
+ {
+ LOG_FMT(LERR, "%s: input string is empty\n", __func__);
+ return("");
+ }
+ const auto option = find_option(name.c_str());
+
+ if (option == nullptr)
+ {
+ LOG_FMT(LWARN, "Option %s not found\n", name.c_str());
+ return("");
+ }
+ return(option->str());
+}
+
+
+/**
+ * returns the config file string based on the current configuration
+ *
+ * @param withDoc: false=without documentation,
+ * true=with documentation text lines
+ * @param only_not_default: false=containing all options,
+ * true=containing only options with non default values
+ * @return returns the config file string based on the current configuration
+ */
+string show_config(bool withDoc, bool only_not_default)
+{
+ char *buf;
+ size_t len;
+
+ FILE *stream = open_memstream(&buf, &len);
+
+ if (stream == nullptr)
+ {
+ LOG_FMT(LERR, "Failed to open_memstream\n");
+ fflush(stream);
+ fclose(stream);
+ free(buf);
+ return("");
+ }
+ save_option_file(stream, withDoc, only_not_default);
+
+ fflush(stream);
+ fclose(stream);
+
+ string out(buf);
+
+ free(buf);
+
+ return(out);
+}
+
+
+/**
+ * returns the config file string with all options based on the current configuration
+ *
+ * @param withDoc: false= without documentation, true=with documentation text lines
+ * @return returns the config file string with all options based on the current configuration
+ */
+string show_config(bool withDoc)
+{
+ return(show_config(withDoc, false));
+}
+
+
+//!returns the config file string with all options and without documentation based on the current configuration
+string show_config()
+{
+ return(show_config(false, false));
+}
+
+
+std::vector<OptionGroup *> get_groups()
+{
+ std::vector<OptionGroup *> groups;
+
+ groups.reserve(5);
+
+ for (size_t i = 0; true; ++i)
+ {
+ OptionGroup *group = get_option_group(i);
+
+ if (!group)
+ {
+ break;
+ }
+ groups.push_back(group);
+ }
+
+ return(groups);
+}
+
+
+std::vector<GenericOption *> get_options()
+{
+ std::vector<GenericOption *> options;
+
+ options.reserve(get_option_count());
+
+ for (size_t i = 0; true; ++i)
+ {
+ OptionGroup *group = get_option_group(i);
+
+ if (!group)
+ {
+ break;
+ }
+ options.insert(
+ end(options),
+ begin(group->options),
+ end(group->options)
+ );
+ }
+
+ return(options);
+}
+
+
+//! resets all options to their default values
+void reset_options()
+{
+ auto options = get_options();
+
+ for (auto *option : options)
+ {
+ option->reset();
+ }
+}
+
+
+/**
+ * initializes the current libUncrustify instance,
+ * used only for emscripten binding here and will be automatically called while
+ * module initialization
+ */
+void _initialize()
+{
+ register_options();
+ log_init(stdout);
+
+ LOG_FMT(LSYS, "Initialized libUncrustify - " UNCRUSTIFY_VERSION "\n");
+}
+
+
+//! destroys the current libUncrustify instance
+void destruct()
+{
+ clear_keyword_file();
+}
+
+
+/**
+ * reads option file string, sets the defined options
+ *
+ * @return returns EXIT_SUCCESS on success
+ */
+int _loadConfig(intptr_t _cfg)
+{
+ // reset everything in case a config was loaded previously
+ clear_keyword_file();
+ reset_options();
+
+ // embind complains about char* so we use an int to get the pointer and cast
+ // it, memory management is done in /emscripten/postfix_module.js
+ char *cfg = reinterpret_cast<char *>(_cfg);
+
+ if (load_option_fileChar(cfg) != EXIT_SUCCESS)
+ {
+ LOG_FMT(LERR, "unable to load the config\n");
+ return(EXIT_FAILURE);
+ }
+ // This relies on cpd.filename being the config file name
+ load_header_files();
+
+ LOG_FMT(LSYS, "finished loading config\n");
+ return(EXIT_SUCCESS);
+}
+
+
+/**
+ * format string
+ *
+ * @param file: pointer to the file char* string that is going to be formatted
+ * @param langIDX: specifies in which language the input file is written
+ * @param frag: true=fragmented code input, false=unfragmented code input
+ * @param defer: true=do not perform cleanup of Uncrustify structures
+ *
+ * @return pointer to the formatted file char* string
+ */
+intptr_t _uncrustify(intptr_t _file, lang_flag_e langIDX, bool frag, bool defer)
+{
+ // Problem: uncrustify originally is not a lib and uses global vars such as
+ // cpd.error_count for the whole program execution
+ // to know if errors occurred during the formatting step we reset this var here
+ cpd.filename = "stdin";
+ cpd.frag = frag;
+
+ if (langIDX == 0) // 0 == undefined
+ {
+ LOG_FMT(LWARN, "language of input file not defined, C++ will be assumed\n");
+ cpd.lang_flags = LANG_CPP;
+ }
+ else
+ {
+ cpd.lang_flags = langIDX;
+ }
+ // embind complains about char* so we use an intptr_t to get the pointer and
+ // cast it, memory management is done in /emscripten/postfix_module.js
+ char *file = reinterpret_cast<char *>(_file);
+
+ file_mem fm;
+
+ fm.raw.clear();
+ fm.data.clear();
+ fm.enc = char_encoding_e::e_ASCII;
+ fm.raw = vector<UINT8>();
+
+ char c;
+
+ for (auto idx = 0; (c = file[idx]) != 0; ++idx)
+ {
+ fm.raw.push_back(c);
+ }
+
+ if (!decode_unicode(fm.raw, fm.data, fm.enc, fm.bom))
+ {
+ LOG_FMT(LERR, "Failed to read code\n");
+ return(0);
+ }
+ // Done reading from stdin
+ LOG_FMT(LSYS, "Parsing: %zu bytes (%zu chars) from stdin as language %s\n",
+ fm.raw.size(), fm.data.size(),
+ language_name_from_flags(cpd.lang_flags));
+
+
+ char *buf = nullptr;
+ size_t len = 0;
+
+ // uncrustify uses FILE instead of streams for its outputs
+ // to redirect FILE writes into a char* open_memstream is used
+ // windows lacks open_memstream, only UNIX/BSD is supported
+ // apparently emscripten has its own implementation, if that is not working
+ // see: stackoverflow.com/questions/10305095#answer-10341073
+ FILE *stream = open_memstream(&buf, &len);
+
+ if (stream == nullptr)
+ {
+ LOG_FMT(LERR, "Failed to open_memstream\n");
+ return(0);
+ }
+ // TODO One way to implement the --parsed, -p functionality would
+ // be to let the uncrustify_file function run, throw away the formatted
+ // output and return the debug as a string. For this uncrustify_file would
+ // need to accept a stream, FILE or a char array pointer in which the output
+ // will be stored.
+ // Another option would be to check, inside the uncrustify_file function,
+ // if the current filename string matches stdout or stderr and use those as
+ // output locations. This is the easier fix but the debug info in the
+ // browsers console is littered with other unneeded text.
+ // Finally, the ugliest solution, would be also possible to re-route
+ // either stdout or stderr inside the Module var of emscripten to a js
+ // function which passes the debug output into a dedicated output js target.
+ // This therefore would introduce the dependency on the user to always have
+ // the output js target available.
+ uncrustify_file(fm, stream, nullptr, nullptr, defer);
+
+ fflush(stream);
+ fclose(stream);
+
+ if (len == 0)
+ {
+ return(0);
+ }
+ // buf is deleted inside js code
+ return(reinterpret_cast<intptr_t>(buf));
+} // uncrustify
+
+
+/**
+ * format string
+ *
+ * @param file: pointer to the file char* string that is going to be formatted
+ * @param langIDX: specifies in which language the input file is written
+ * @param frag: true=fragmented code input, false=unfragmented code input
+ *
+ * @return pointer to the formatted file char* string
+ */
+intptr_t _uncrustify(intptr_t file, lang_flag_e langIDX, bool frag)
+{
+ return(_uncrustify(file, langIDX, frag, false));
+}
+
+
+/**
+ * format string, assume unfragmented code input
+ *
+ * @param file: pointer to the file char* string that is going to be formatted
+ * @param langIDX: specifies in which language the input file is written
+ *
+ * @return pointer to the formatted file char* string
+ */
+intptr_t _uncrustify(intptr_t file, lang_flag_e langIDX)
+{
+ return(_uncrustify(file, langIDX, false, false));
+}
+
+
+/**
+ * generate debug output
+ *
+ * @param file: pointer to the file char* string that is going to be formatted
+ * @param langIDX: specifies in which language the input file is written
+ * @param frag: true=fragmented code input, false=unfragmented code input
+ *
+ * @return pointer to the debug file char* string
+ */
+intptr_t _debug(intptr_t _file, lang_flag_e langIDX, bool frag)
+{
+ auto formatted_str_ptr = _uncrustify(_file, langIDX, frag, true);
+ char *formatted_str = reinterpret_cast<char *>(formatted_str_ptr);
+
+ // Lazy solution: Throw away the formatted file output.
+ // Maybe later add option to return both formatted file string and debug
+ // file string together ... somehow.
+ free(formatted_str);
+
+ char *buf = nullptr;
+ size_t len = 0;
+ FILE *stream = open_memstream(&buf, &len);
+
+ if (stream == nullptr)
+ {
+ LOG_FMT(LERR, "Failed to open_memstream\n");
+ return(0);
+ }
+ output_parsed(stream);
+ fflush(stream);
+ fclose(stream);
+
+ // start deferred _uncrustify cleanup
+ uncrustify_end();
+
+ if (len == 0)
+ {
+ return(0);
+ }
+ // buf is deleted inside js code
+ return(reinterpret_cast<intptr_t>(buf));
+} // uncrustify
+
+
+/**
+ * generate debug output, assume unfragmented code input
+ *
+ * @param file: pointer to the file char* string that is going to be formatted
+ * @param langIDX: specifies in which language the input file is written
+ *
+ * @return pointer to the debug file char* string
+ */
+intptr_t _debug(intptr_t _file, lang_flag_e langIDX)
+{
+ return(_debug(_file, langIDX, false));
+}
+
+} // namespace
+
+EMSCRIPTEN_BINDINGS(MainModule)
+{
+ // region enum bindings
+ enum_<option_type_e>("OptionType")
+ .value("BOOL", option_type_e::BOOL)
+ .value("IARF", option_type_e::IARF)
+ .value("LINEEND", option_type_e::LINEEND)
+ .value("TOKENPOS", option_type_e::TOKENPOS)
+ .value("NUM", option_type_e::NUM)
+ .value("UNUM", option_type_e::UNUM)
+ .value("STRING", option_type_e::STRING);
+
+ enum_<iarf_e>("IARF")
+ .value("IGNORE", IARF_IGNORE)
+ .value("ADD", IARF_ADD)
+ .value("REMOVE", IARF_REMOVE)
+ .value("FORCE", IARF_FORCE);
+
+ enum_<line_end_e>("LineEnd")
+ .value("LF", line_end_e::LF)
+ .value("CRLF", line_end_e::CRLF)
+ .value("CR", line_end_e::CR)
+ .value("AUTO", line_end_e::AUTO);
+
+ enum_<token_pos_e>("TokenPos")
+ .value("IGNORE", token_pos_e::IGNORE)
+ .value("BREAK", token_pos_e::BREAK)
+ .value("FORCE", token_pos_e::FORCE)
+ .value("LEAD", token_pos_e::LEAD)
+ .value("TRAIL", token_pos_e::TRAIL)
+ .value("JOIN", token_pos_e::JOIN)
+ .value("LEAD_BREAK", token_pos_e::LEAD_BREAK)
+ .value("LEAD_FORCE", token_pos_e::LEAD_FORCE)
+ .value("TRAIL_BREAK", token_pos_e::TRAIL_BREAK)
+ .value("TRAIL_FORCE", token_pos_e::TRAIL_FORCE);
+
+ enum_<log_sev_t>("LogType")
+ .value("SYS", log_sev_t::LSYS)
+ .value("ERR", log_sev_t::LERR)
+ .value("WARN", log_sev_t::LWARN)
+ .value("NOTE", log_sev_t::LNOTE)
+ .value("INFO", log_sev_t::LINFO)
+ .value("DATA", log_sev_t::LDATA)
+ .value("FILELIST", log_sev_t::LFILELIST)
+ .value("LINEENDS", log_sev_t::LLINEENDS)
+ .value("CASTS", log_sev_t::LCASTS)
+ .value("ALBR", log_sev_t::LALBR)
+ .value("ALTD", log_sev_t::LALTD)
+ .value("ALPP", log_sev_t::LALPP)
+ .value("ALPROTO", log_sev_t::LALPROTO)
+ .value("ALNLC", log_sev_t::LALNLC)
+ .value("ALTC", log_sev_t::LALTC)
+ .value("ALADD", log_sev_t::LALADD)
+ .value("ALASS", log_sev_t::LALASS)
+ .value("FVD", log_sev_t::LFVD)
+ .value("FVD2", log_sev_t::LFVD2)
+ .value("INDENT", log_sev_t::LINDENT)
+ .value("INDENT2", log_sev_t::LINDENT2)
+ .value("INDPSE", log_sev_t::LINDPSE)
+ .value("INDPC", log_sev_t::LINDPC)
+ .value("NEWLINE", log_sev_t::LNEWLINE)
+ .value("PF", log_sev_t::LPF)
+ .value("STMT", log_sev_t::LSTMT)
+ .value("TOK", log_sev_t::LTOK)
+ .value("ALRC", log_sev_t::LALRC)
+ .value("CMTIND", log_sev_t::LCMTIND)
+ .value("INDLINE", log_sev_t::LINDLINE)
+ .value("SIB", log_sev_t::LSIB)
+ .value("RETURN", log_sev_t::LRETURN)
+ .value("BRDEL", log_sev_t::LBRDEL)
+ .value("FCN", log_sev_t::LFCN)
+ .value("FCNP", log_sev_t::LFCNP)
+ .value("PCU", log_sev_t::LPCU)
+ .value("DYNKW", log_sev_t::LDYNKW)
+ .value("OUTIND", log_sev_t::LOUTIND)
+ .value("BCSAFTER", log_sev_t::LBCSAFTER)
+ .value("BCSPOP", log_sev_t::LBCSPOP)
+ .value("BCSPUSH", log_sev_t::LBCSPUSH)
+ .value("BCSSWAP", log_sev_t::LBCSSWAP)
+ .value("FTOR", log_sev_t::LFTOR)
+ .value("AS", log_sev_t::LAS)
+ .value("PPIS", log_sev_t::LPPIS)
+ .value("TYPEDEF", log_sev_t::LTYPEDEF)
+ .value("VARDEF", log_sev_t::LVARDEF)
+ .value("DEFVAL", log_sev_t::LDEFVAL)
+ .value("PVSEMI", log_sev_t::LPVSEMI)
+ .value("PFUNC", log_sev_t::LPFUNC)
+ .value("SPLIT", log_sev_t::LSPLIT)
+ .value("FTYPE", log_sev_t::LFTYPE)
+ .value("TEMPL", log_sev_t::LTEMPL)
+ .value("PARADD", log_sev_t::LPARADD)
+ .value("PARADD2", log_sev_t::LPARADD2)
+ .value("BLANKD", log_sev_t::LBLANKD)
+ .value("TEMPFUNC", log_sev_t::LTEMPFUNC)
+ .value("SCANSEMI", log_sev_t::LSCANSEMI)
+ .value("DELSEMI", log_sev_t::LDELSEMI)
+ .value("FPARAM", log_sev_t::LFPARAM)
+ .value("NL1LINE", log_sev_t::LNL1LINE)
+ .value("PFCHK", log_sev_t::LPFCHK)
+ .value("AVDB", log_sev_t::LAVDB)
+ .value("SORT", log_sev_t::LSORT)
+ .value("SPACE", log_sev_t::LSPACE)
+ .value("ALIGN", log_sev_t::LALIGN)
+ .value("ALAGAIN", log_sev_t::LALAGAIN)
+ .value("OPERATOR", log_sev_t::LOPERATOR)
+ .value("ASFCP", log_sev_t::LASFCP)
+ .value("INDLINED", log_sev_t::LINDLINED)
+ .value("BCTRL", log_sev_t::LBCTRL)
+ .value("RMRETURN", log_sev_t::LRMRETURN)
+ .value("PPIF", log_sev_t::LPPIF)
+ .value("MCB", log_sev_t::LMCB)
+ .value("BRCH", log_sev_t::LBRCH)
+ .value("FCNR", log_sev_t::LFCNR)
+ .value("OCCLASS", log_sev_t::LOCCLASS)
+ .value("OCMSG", log_sev_t::LOCMSG)
+ .value("BLANK", log_sev_t::LBLANK)
+ .value("OBJCWORD", log_sev_t::LOBJCWORD)
+ .value("CHANGE", log_sev_t::LCHANGE)
+ .value("CONTTEXT", log_sev_t::LCONTTEXT)
+ .value("ANNOT", log_sev_t::LANNOT)
+ .value("OCBLK", log_sev_t::LOCBLK)
+ .value("FLPAREN", log_sev_t::LFLPAREN)
+ .value("OCMSGD", log_sev_t::LOCMSGD)
+ .value("INDENTAG", log_sev_t::LINDENTAG)
+ .value("NFD", log_sev_t::LNFD)
+ .value("JDBI", log_sev_t::LJDBI)
+ .value("SETPAR", log_sev_t::LSETPAR)
+ .value("SETTYP", log_sev_t::LSETTYP)
+ .value("SETFLG", log_sev_t::LSETFLG)
+ .value("NLFUNCT", log_sev_t::LNLFUNCT)
+ .value("CHUNK", log_sev_t::LCHUNK)
+ .value("GUY98", log_sev_t::LGUY98)
+ .value("GUY", log_sev_t::LGUY);
+
+ enum_<E_Token>("TokenType")
+ .value("NONE", E_Token::CT_NONE)
+ .value("EOF", E_Token::CT_EOF)
+ .value("UNKNOWN", E_Token::CT_UNKNOWN)
+ .value("JUNK", E_Token::CT_JUNK)
+ .value("WHITESPACE", E_Token::CT_WHITESPACE)
+ .value("SPACE", E_Token::CT_SPACE)
+ .value("NEWLINE", E_Token::CT_NEWLINE)
+ .value("NL_CONT", E_Token::CT_NL_CONT)
+ .value("COMMENT_CPP", E_Token::CT_COMMENT_CPP)
+ .value("COMMENT", E_Token::CT_COMMENT)
+ .value("COMMENT_MULTI", E_Token::CT_COMMENT_MULTI)
+ .value("COMMENT_EMBED", E_Token::CT_COMMENT_EMBED)
+ .value("COMMENT_START", E_Token::CT_COMMENT_START)
+ .value("COMMENT_END", E_Token::CT_COMMENT_END)
+ .value("COMMENT_WHOLE", E_Token::CT_COMMENT_WHOLE)
+ .value("COMMENT_CPP_ENDIF", E_Token::CT_COMMENT_CPP_ENDIF)
+ .value("COMMENT_ENDIF", E_Token::CT_COMMENT_ENDIF)
+ .value("IGNORED", E_Token::CT_IGNORED)
+ .value("WORD", E_Token::CT_WORD)
+ .value("NUMBER", E_Token::CT_NUMBER)
+ .value("NUMBER_FP", E_Token::CT_NUMBER_FP)
+ .value("STRING", E_Token::CT_STRING)
+ .value("STRING_MULTI", E_Token::CT_STRING_MULTI)
+ .value("IF", E_Token::CT_IF)
+ .value("ELSE", E_Token::CT_ELSE)
+ .value("ELSEIF", E_Token::CT_ELSEIF)
+ .value("FOR", E_Token::CT_FOR)
+ .value("WHILE", E_Token::CT_WHILE)
+ .value("WHILE_OF_DO", E_Token::CT_WHILE_OF_DO)
+ .value("SWITCH", E_Token::CT_SWITCH)
+ .value("CASE", E_Token::CT_CASE)
+ .value("DO", E_Token::CT_DO)
+ .value("SYNCHRONIZED", E_Token::CT_SYNCHRONIZED)
+ .value("VOLATILE", E_Token::CT_VOLATILE)
+ .value("TYPEDEF", E_Token::CT_TYPEDEF)
+ .value("STRUCT", E_Token::CT_STRUCT)
+ .value("ENUM", E_Token::CT_ENUM)
+ .value("ENUM_CLASS", E_Token::CT_ENUM_CLASS)
+ .value("SIZEOF", E_Token::CT_SIZEOF)
+ .value("DECLTYPE", E_Token::CT_DECLTYPE)
+ .value("RETURN", E_Token::CT_RETURN)
+ .value("BREAK", E_Token::CT_BREAK)
+ .value("UNION", E_Token::CT_UNION)
+ .value("GOTO", E_Token::CT_GOTO)
+ .value("CONTINUE", E_Token::CT_CONTINUE)
+ .value("C_CAST", E_Token::CT_C_CAST)
+ .value("CPP_CAST", E_Token::CT_CPP_CAST)
+ .value("D_CAST", E_Token::CT_D_CAST)
+ .value("TYPE_CAST", E_Token::CT_TYPE_CAST)
+ .value("TYPENAME", E_Token::CT_TYPENAME)
+ .value("TEMPLATE", E_Token::CT_TEMPLATE)
+ .value("WHERE_SPEC", E_Token::CT_WHERE_SPEC)
+ .value("ASSIGN", E_Token::CT_ASSIGN)
+ .value("ASSIGN_NL", E_Token::CT_ASSIGN_NL)
+ .value("SASSIGN", E_Token::CT_SASSIGN)
+ .value("ASSIGN_DEFAULT_ARG", E_Token::CT_ASSIGN_DEFAULT_ARG)
+ .value("ASSIGN_FUNC_PROTO", E_Token::CT_ASSIGN_FUNC_PROTO)
+ .value("COMPARE", E_Token::CT_COMPARE)
+ .value("SCOMPARE", E_Token::CT_SCOMPARE)
+ .value("BOOL", E_Token::CT_BOOL)
+ .value("SBOOL", E_Token::CT_SBOOL)
+ .value("ARITH", E_Token::CT_ARITH)
+ .value("SARITH", E_Token::CT_SARITH)
+ .value("CARET", E_Token::CT_CARET)
+ .value("DEREF", E_Token::CT_DEREF)
+ .value("INCDEC_BEFORE", E_Token::CT_INCDEC_BEFORE)
+ .value("INCDEC_AFTER", E_Token::CT_INCDEC_AFTER)
+ .value("MEMBER", E_Token::CT_MEMBER)
+ .value("DC_MEMBER", E_Token::CT_DC_MEMBER)
+ .value("C99_MEMBER", E_Token::CT_C99_MEMBER)
+ .value("INV", E_Token::CT_INV)
+ .value("DESTRUCTOR", E_Token::CT_DESTRUCTOR)
+ .value("NOT", E_Token::CT_NOT)
+ .value("D_TEMPLATE", E_Token::CT_D_TEMPLATE)
+ .value("ADDR", E_Token::CT_ADDR)
+ .value("NEG", E_Token::CT_NEG)
+ .value("POS", E_Token::CT_POS)
+ .value("STAR", E_Token::CT_STAR)
+ .value("PLUS", E_Token::CT_PLUS)
+ .value("MINUS", E_Token::CT_MINUS)
+ .value("AMP", E_Token::CT_AMP)
+ .value("BYREF", E_Token::CT_BYREF)
+ .value("POUND", E_Token::CT_POUND)
+ .value("PREPROC", E_Token::CT_PREPROC)
+ .value("PREPROC_INDENT", E_Token::CT_PREPROC_INDENT)
+ .value("PREPROC_BODY", E_Token::CT_PREPROC_BODY)
+ .value("PP", E_Token::CT_PP)
+ .value("ELLIPSIS", E_Token::CT_ELLIPSIS)
+ .value("RANGE", E_Token::CT_RANGE)
+ .value("NULLCOND", E_Token::CT_NULLCOND)
+ .value("SEMICOLON", E_Token::CT_SEMICOLON)
+ .value("VSEMICOLON", E_Token::CT_VSEMICOLON)
+ .value("COLON", E_Token::CT_COLON)
+ .value("ASM_COLON", E_Token::CT_ASM_COLON)
+ .value("CASE_COLON", E_Token::CT_CASE_COLON)
+ .value("CLASS_COLON", E_Token::CT_CLASS_COLON)
+ .value("CONSTR_COLON", E_Token::CT_CONSTR_COLON)
+ .value("D_ARRAY_COLON", E_Token::CT_D_ARRAY_COLON)
+ .value("COND_COLON", E_Token::CT_COND_COLON)
+ .value("WHERE_COLON", E_Token::CT_WHERE_COLON)
+ .value("QUESTION", E_Token::CT_QUESTION)
+ .value("COMMA", E_Token::CT_COMMA)
+ .value("ASM", E_Token::CT_ASM)
+ .value("ATTRIBUTE", E_Token::CT_ATTRIBUTE)
+ .value("AUTORELEASEPOOL", E_Token::CT_AUTORELEASEPOOL)
+ .value("OC_AVAILABLE", E_Token::CT_OC_AVAILABLE)
+ .value("OC_AVAILABLE_VALUE", E_Token::CT_OC_AVAILABLE_VALUE)
+ .value("CATCH", E_Token::CT_CATCH)
+ .value("WHEN", E_Token::CT_WHEN)
+ .value("WHERE", E_Token::CT_WHERE)
+ .value("CLASS", E_Token::CT_CLASS)
+ .value("DELETE", E_Token::CT_DELETE)
+ .value("EXPORT", E_Token::CT_EXPORT)
+ .value("FRIEND", E_Token::CT_FRIEND)
+ .value("NAMESPACE", E_Token::CT_NAMESPACE)
+ .value("PACKAGE", E_Token::CT_PACKAGE)
+ .value("NEW", E_Token::CT_NEW)
+ .value("OPERATOR", E_Token::CT_OPERATOR)
+ .value("OPERATOR_VAL", E_Token::CT_OPERATOR_VAL)
+ .value("ASSIGN_OPERATOR", E_Token::CT_ASSIGN_OPERATOR)
+ .value("ACCESS", E_Token::CT_ACCESS)
+ .value("ACCESS_COLON", E_Token::CT_ACCESS_COLON)
+ .value("THROW", E_Token::CT_THROW)
+ .value("NOEXCEPT", E_Token::CT_NOEXCEPT)
+ .value("TRY", E_Token::CT_TRY)
+ .value("BRACED_INIT_LIST", E_Token::CT_BRACED_INIT_LIST)
+ .value("USING", E_Token::CT_USING)
+ .value("USING_STMT", E_Token::CT_USING_STMT)
+ .value("USING_ALIAS", E_Token::CT_USING_ALIAS)
+ .value("D_WITH", E_Token::CT_D_WITH)
+ .value("D_MODULE", E_Token::CT_D_MODULE)
+ .value("SUPER", E_Token::CT_SUPER)
+ .value("DELEGATE", E_Token::CT_DELEGATE)
+ .value("BODY", E_Token::CT_BODY)
+ .value("DEBUG", E_Token::CT_DEBUG)
+ .value("DEBUGGER", E_Token::CT_DEBUGGER)
+ .value("INVARIANT", E_Token::CT_INVARIANT)
+ .value("UNITTEST", E_Token::CT_UNITTEST)
+ .value("UNSAFE", E_Token::CT_UNSAFE)
+ .value("FINALLY", E_Token::CT_FINALLY)
+ .value("FIXED", E_Token::CT_FIXED)
+ .value("IMPORT", E_Token::CT_IMPORT)
+ .value("D_SCOPE", E_Token::CT_D_SCOPE)
+ .value("D_SCOPE_IF", E_Token::CT_D_SCOPE_IF)
+ .value("LAZY", E_Token::CT_LAZY)
+ .value("D_MACRO", E_Token::CT_D_MACRO)
+ .value("D_VERSION", E_Token::CT_D_VERSION)
+ .value("D_VERSION_IF", E_Token::CT_D_VERSION_IF)
+ .value("PAREN_OPEN", E_Token::CT_PAREN_OPEN)
+ .value("PAREN_CLOSE", E_Token::CT_PAREN_CLOSE)
+ .value("ANGLE_OPEN", E_Token::CT_ANGLE_OPEN)
+ .value("ANGLE_CLOSE", E_Token::CT_ANGLE_CLOSE)
+ .value("SPAREN_OPEN", E_Token::CT_SPAREN_OPEN)
+ .value("SPAREN_CLOSE", E_Token::CT_SPAREN_CLOSE)
+ .value("FPAREN_OPEN", E_Token::CT_FPAREN_OPEN)
+ .value("FPAREN_CLOSE", E_Token::CT_FPAREN_CLOSE)
+ .value("TPAREN_OPEN", E_Token::CT_TPAREN_OPEN)
+ .value("TPAREN_CLOSE", E_Token::CT_TPAREN_CLOSE)
+ .value("BRACE_OPEN", E_Token::CT_BRACE_OPEN)
+ .value("BRACE_CLOSE", E_Token::CT_BRACE_CLOSE)
+ .value("VBRACE_OPEN", E_Token::CT_VBRACE_OPEN)
+ .value("VBRACE_CLOSE", E_Token::CT_VBRACE_CLOSE)
+ .value("SQUARE_OPEN", E_Token::CT_SQUARE_OPEN)
+ .value("SQUARE_CLOSE", E_Token::CT_SQUARE_CLOSE)
+ .value("TSQUARE", E_Token::CT_TSQUARE)
+ .value("MACRO_OPEN", E_Token::CT_MACRO_OPEN)
+ .value("MACRO_CLOSE", E_Token::CT_MACRO_CLOSE)
+ .value("MACRO_ELSE", E_Token::CT_MACRO_ELSE)
+ .value("LABEL", E_Token::CT_LABEL)
+ .value("LABEL_COLON", E_Token::CT_LABEL_COLON)
+ .value("FUNCTION", E_Token::CT_FUNCTION)
+ .value("FUNC_CALL", E_Token::CT_FUNC_CALL)
+ .value("FUNC_CALL_USER", E_Token::CT_FUNC_CALL_USER)
+ .value("FUNC_DEF", E_Token::CT_FUNC_DEF)
+ .value("FUNC_TYPE", E_Token::CT_FUNC_TYPE)
+ .value("FUNC_VAR", E_Token::CT_FUNC_VAR)
+ .value("FUNC_PROTO", E_Token::CT_FUNC_PROTO)
+ .value("FUNC_START", E_Token::CT_FUNC_START)
+ .value("FUNC_CLASS_DEF", E_Token::CT_FUNC_CLASS_DEF)
+ .value("FUNC_CLASS_PROTO", E_Token::CT_FUNC_CLASS_PROTO)
+ .value("FUNC_CTOR_VAR", E_Token::CT_FUNC_CTOR_VAR)
+ .value("FUNC_WRAP", E_Token::CT_FUNC_WRAP)
+ .value("PROTO_WRAP", E_Token::CT_PROTO_WRAP)
+ .value("MACRO_FUNC", E_Token::CT_MACRO_FUNC)
+ .value("MACRO", E_Token::CT_MACRO)
+ .value("QUALIFIER", E_Token::CT_QUALIFIER)
+ .value("EXTERN", E_Token::CT_EXTERN)
+ .value("DECLSPEC", E_Token::CT_DECLSPEC)
+ .value("ALIGN", E_Token::CT_ALIGN)
+ .value("TYPE", E_Token::CT_TYPE)
+ .value("PTR_TYPE", E_Token::CT_PTR_TYPE)
+ .value("TYPE_WRAP", E_Token::CT_TYPE_WRAP)
+ .value("CPP_LAMBDA", E_Token::CT_CPP_LAMBDA)
+ .value("CPP_LAMBDA_RET", E_Token::CT_CPP_LAMBDA_RET)
+ .value("TRAILING_RET", E_Token::CT_TRAILING_RET)
+ .value("BIT_COLON", E_Token::CT_BIT_COLON)
+ .value("OC_DYNAMIC", E_Token::CT_OC_DYNAMIC)
+ .value("OC_END", E_Token::CT_OC_END)
+ .value("OC_IMPL", E_Token::CT_OC_IMPL)
+ .value("OC_INTF", E_Token::CT_OC_INTF)
+ .value("OC_PROTOCOL", E_Token::CT_OC_PROTOCOL)
+ .value("OC_PROTO_LIST", E_Token::CT_OC_PROTO_LIST)
+ .value("OC_GENERIC_SPEC", E_Token::CT_OC_GENERIC_SPEC)
+ .value("OC_PROPERTY", E_Token::CT_OC_PROPERTY)
+ .value("OC_CLASS", E_Token::CT_OC_CLASS)
+ .value("OC_CLASS_EXT", E_Token::CT_OC_CLASS_EXT)
+ .value("OC_CATEGORY", E_Token::CT_OC_CATEGORY)
+ .value("OC_SCOPE", E_Token::CT_OC_SCOPE)
+ .value("OC_MSG", E_Token::CT_OC_MSG)
+ .value("OC_MSG_CLASS", E_Token::CT_OC_MSG_CLASS)
+ .value("OC_MSG_FUNC", E_Token::CT_OC_MSG_FUNC)
+ .value("OC_MSG_NAME", E_Token::CT_OC_MSG_NAME)
+ .value("OC_MSG_SPEC", E_Token::CT_OC_MSG_SPEC)
+ .value("OC_MSG_DECL", E_Token::CT_OC_MSG_DECL)
+ .value("OC_RTYPE", E_Token::CT_OC_RTYPE)
+ .value("OC_ATYPE", E_Token::CT_OC_ATYPE)
+ .value("OC_COLON", E_Token::CT_OC_COLON)
+ .value("OC_DICT_COLON", E_Token::CT_OC_DICT_COLON)
+ .value("OC_SEL", E_Token::CT_OC_SEL)
+ .value("OC_SEL_NAME", E_Token::CT_OC_SEL_NAME)
+ .value("OC_BLOCK", E_Token::CT_OC_BLOCK)
+ .value("OC_BLOCK_ARG", E_Token::CT_OC_BLOCK_ARG)
+ .value("OC_BLOCK_TYPE", E_Token::CT_OC_BLOCK_TYPE)
+ .value("OC_BLOCK_EXPR", E_Token::CT_OC_BLOCK_EXPR)
+ .value("OC_BLOCK_CARET", E_Token::CT_OC_BLOCK_CARET)
+ .value("OC_AT", E_Token::CT_OC_AT)
+ .value("OC_PROPERTY_ATTR", E_Token::CT_OC_PROPERTY_ATTR)
+ .value("PP_DEFINE", E_Token::CT_PP_DEFINE)
+ .value("PP_DEFINED", E_Token::CT_PP_DEFINED)
+ .value("PP_INCLUDE", E_Token::CT_PP_INCLUDE)
+ .value("PP_IF", E_Token::CT_PP_IF)
+ .value("PP_ELSE", E_Token::CT_PP_ELSE)
+ .value("PP_ENDIF", E_Token::CT_PP_ENDIF)
+ .value("PP_ASSERT", E_Token::CT_PP_ASSERT)
+ .value("PP_EMIT", E_Token::CT_PP_EMIT)
+ .value("PP_ENDINPUT", E_Token::CT_PP_ENDINPUT)
+ .value("PP_ERROR", E_Token::CT_PP_ERROR)
+ .value("PP_FILE", E_Token::CT_PP_FILE)
+ .value("PP_LINE", E_Token::CT_PP_LINE)
+ .value("PP_SECTION", E_Token::CT_PP_SECTION)
+ .value("PP_ASM", E_Token::CT_PP_ASM)
+ .value("PP_UNDEF", E_Token::CT_PP_UNDEF)
+ .value("PP_PROPERTY", E_Token::CT_PP_PROPERTY)
+ .value("PP_BODYCHUNK", E_Token::CT_PP_BODYCHUNK)
+ .value("PP_PRAGMA", E_Token::CT_PP_PRAGMA)
+ .value("PP_REGION", E_Token::CT_PP_REGION)
+ .value("PP_ENDREGION", E_Token::CT_PP_ENDREGION)
+ .value("PP_REGION_INDENT", E_Token::CT_PP_REGION_INDENT)
+ .value("PP_IF_INDENT", E_Token::CT_PP_IF_INDENT)
+ .value("PP_IGNORE", E_Token::CT_PP_IGNORE)
+ .value("PP_OTHER", E_Token::CT_PP_OTHER)
+ .value("CHAR", E_Token::CT_CHAR)
+ .value("DEFINED", E_Token::CT_DEFINED)
+ .value("FORWARD", E_Token::CT_FORWARD)
+ .value("NATIVE", E_Token::CT_NATIVE)
+ .value("STATE", E_Token::CT_STATE)
+ .value("STOCK", E_Token::CT_STOCK)
+ .value("TAGOF", E_Token::CT_TAGOF)
+ .value("DOT", E_Token::CT_DOT)
+ .value("TAG", E_Token::CT_TAG)
+ .value("TAG_COLON", E_Token::CT_TAG_COLON)
+ .value("LOCK", E_Token::CT_LOCK)
+ .value("AS", E_Token::CT_AS)
+ .value("IN", E_Token::CT_IN)
+ .value("BRACED", E_Token::CT_BRACED)
+ .value("THIS", E_Token::CT_THIS)
+ .value("BASE", E_Token::CT_BASE)
+ .value("DEFAULT", E_Token::CT_DEFAULT)
+ .value("GETSET", E_Token::CT_GETSET)
+ .value("GETSET_EMPTY", E_Token::CT_GETSET_EMPTY)
+ .value("CONCAT", E_Token::CT_CONCAT)
+ .value("CS_SQ_STMT", E_Token::CT_CS_SQ_STMT)
+ .value("CS_SQ_COLON", E_Token::CT_CS_SQ_COLON)
+ .value("CS_PROPERTY", E_Token::CT_CS_PROPERTY)
+ .value("SQL_EXEC", E_Token::CT_SQL_EXEC)
+ .value("SQL_BEGIN", E_Token::CT_SQL_BEGIN)
+ .value("SQL_END", E_Token::CT_SQL_END)
+ .value("SQL_WORD", E_Token::CT_SQL_WORD)
+ .value("SQL_ASSIGN", E_Token::CT_SQL_ASSIGN)
+ .value("CONSTRUCT", E_Token::CT_CONSTRUCT)
+ .value("LAMBDA", E_Token::CT_LAMBDA)
+ .value("ASSERT", E_Token::CT_ASSERT)
+ .value("ANNOTATION", E_Token::CT_ANNOTATION)
+ .value("FOR_COLON", E_Token::CT_FOR_COLON)
+ .value("DOUBLE_BRACE", E_Token::CT_DOUBLE_BRACE)
+ .value("CNG_HASINC", E_Token::CT_CNG_HASINC)
+ .value("CNG_HASINCN", E_Token::CT_CNG_HASINCN)
+ .value("Q_EMIT", E_Token::CT_Q_EMIT)
+ .value("Q_FOREACH", E_Token::CT_Q_FOREACH)
+ .value("Q_FOREVER", E_Token::CT_Q_FOREVER)
+ .value("Q_GADGET", E_Token::CT_Q_GADGET)
+ .value("Q_OBJECT", E_Token::CT_Q_OBJECT)
+ .value("MODE", E_Token::CT_MODE)
+ .value("DI", E_Token::CT_DI)
+ .value("HI", E_Token::CT_HI)
+ .value("QI", E_Token::CT_QI)
+ .value("SI", E_Token::CT_SI)
+ .value("NOTHROW", E_Token::CT_NOTHROW)
+ .value("WORD_", E_Token::CT_WORD_);
+
+ enum_<lang_flag_e>("Language")
+ .value("C", lang_flag_e::LANG_C)
+ .value("CPP", lang_flag_e::LANG_CPP)
+ .value("D", lang_flag_e::LANG_D)
+ .value("CS", lang_flag_e::LANG_CS)
+ .value("JAVA", lang_flag_e::LANG_JAVA)
+ .value("OC", lang_flag_e::LANG_OC)
+ .value("VALA", lang_flag_e::LANG_VALA)
+ .value("PAWN", lang_flag_e::LANG_PAWN)
+ .value("ECMA", lang_flag_e::LANG_ECMA);
+
+ // endregion enum bindings
+
+ register_vector<std::string>("strings");
+
+ class_<GenericOption>("GenericOption")
+ .function("type", &GenericOption::type)
+ .function("description", select_overload<std::string(const GenericOption &)>(
+ [](const GenericOption &o)
+ {
+ return((o.description() != nullptr) ? string(o.description()) : "");
+ }))
+ .function("name", select_overload<std::string(const GenericOption &)>(
+ [](const GenericOption &o)
+ {
+ return((o.name() != nullptr) ? string(o.name()) : "");
+ }))
+ .function("possible_values", select_overload<std::vector<std::string>(const GenericOption &)>(
+ [](const GenericOption &o)
+ {
+ std::vector<std::string> strings;
+
+ auto ptr = o.possibleValues();
+
+ for (auto c = *ptr; c; c = *++ptr)
+ {
+ strings.push_back(std::string{ c });
+ }
+
+ return(strings);
+ }))
+ .function("default", &GenericOption::defaultStr)
+ .function("min", &GenericOption::minStr)
+ .function("max", &GenericOption::maxStr)
+ .function("is_default", &GenericOption::isDefault)
+ .function("reset", &GenericOption::reset)
+ .function("set", select_overload<bool(GenericOption &o, const std::string &s)>(
+ [](GenericOption &o, const std::string &s)
+ {
+ return(o.read(s.c_str()));
+ }))
+ .function("value", &GenericOption::str);
+
+ register_vector<GenericOption *>("options");
+
+ class_<Option<iarf_e>, base<GenericOption> >("OptionIARF")
+ .function("value", &Option<iarf_e>::operator());
+
+ class_<Option<line_end_e>, base<GenericOption> >("OptionLineEnd")
+ .function("value", &Option<line_end_e>::operator());
+
+ class_<Option<token_pos_e>, base<GenericOption> >("OptionTokenPos")
+ .function("value", &Option<token_pos_e>::operator());
+
+ class_<Option<unsigned>, base<GenericOption> >("OptionUnsigned")
+ .function("value", &Option<unsigned>::operator());
+
+ class_<Option<signed>, base<GenericOption> >("OptionSigned")
+ .function("value", &Option<signed>::operator());
+
+ class_<Option<std::string>, base<GenericOption> >("OptionString")
+ .function("value", &Option<std::string>::operator());
+
+ class_<OptionGroup>("OptionGroup")
+ .property("description", select_overload<std::string(const OptionGroup &)>(
+ [](const OptionGroup &g)
+ {
+ return(std::string(g.description));
+ }))
+ .property("options", &OptionGroup::options);
+
+ register_vector<OptionGroup *>("groups");
+
+ emscripten::function("get_options", &get_options);
+ emscripten::function("get_groups", &get_groups);
+
+ emscripten::function("_initialize", &_initialize);
+ emscripten::function("destruct", &destruct);
+
+ emscripten::function("get_version", &get_version);
+
+ emscripten::function("add_keyword", &_add_keyword);
+ emscripten::function("clear_keywords", &clear_keywords);
+
+ emscripten::function("reset_options", &reset_options);
+ emscripten::function("option_reset_value", &reset_option);
+ emscripten::function("option_set_value", &set_option);
+ emscripten::function("option_get_value", &get_option);
+
+ emscripten::function("_load_config", &_loadConfig);
+ emscripten::function("show_config", select_overload<string(bool, bool)>(&show_config));
+ emscripten::function("show_config", select_overload<string(bool)>(&show_config));
+ emscripten::function("show_config", select_overload<string()>(&show_config));
+
+ emscripten::function("log_type_enable", &log_set_sev);
+ emscripten::function("log_type_show_name", &show_log_type);
+ emscripten::function("quiet", &set_quiet);
+
+ emscripten::function("_uncrustify", select_overload<intptr_t(intptr_t, lang_flag_e, bool, bool)>(&_uncrustify));
+ emscripten::function("_uncrustify", select_overload<intptr_t(intptr_t, lang_flag_e, bool)>(&_uncrustify));
+ emscripten::function("_uncrustify", select_overload<intptr_t(intptr_t, lang_flag_e)>(&_uncrustify));
+
+ emscripten::function("_debug", select_overload<intptr_t(intptr_t, lang_flag_e, bool)>(&_debug));
+ emscripten::function("_debug", select_overload<intptr_t(intptr_t, lang_flag_e)>(&_debug));
+};
+
+#endif