/* * 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 #include #include #include #include #include #include #ifdef EMSCRIPTEN #include #include using namespace emscripten; #else #define EMSCRIPTEN_BINDINGS(module) void dummyFcn() template struct base {}; struct emscripten { template emscripten value(Args...) { return{}; } template static emscripten function(Args...) { return{}; } template emscripten property(Args...) { return{}; } }; using Dummy = emscripten; template Dummy enum_(char const *const) { return(Dummy{}); } template Dummy register_vector(char const *const) { return(Dummy{}); } template Dummy class_(char const *const) { return(Dummy{}); } template 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 get_groups() { std::vector 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 get_options() { std::vector 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(_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(_file); file_mem fm; fm.raw.clear(); fm.data.clear(); fm.enc = char_encoding_e::e_ASCII; fm.raw = vector(); 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(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(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(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_("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") .value("IGNORE", IARF_IGNORE) .value("ADD", IARF_ADD) .value("REMOVE", IARF_REMOVE) .value("FORCE", IARF_FORCE); enum_("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_("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_("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_("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_("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("strings"); class_("GenericOption") .function("type", &GenericOption::type) .function("description", select_overload( [](const GenericOption &o) { return((o.description() != nullptr) ? string(o.description()) : ""); })) .function("name", select_overload( [](const GenericOption &o) { return((o.name() != nullptr) ? string(o.name()) : ""); })) .function("possible_values", select_overload(const GenericOption &)>( [](const GenericOption &o) { std::vector 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( [](GenericOption &o, const std::string &s) { return(o.read(s.c_str())); })) .function("value", &GenericOption::str); register_vector("options"); class_, base >("OptionIARF") .function("value", &Option::operator()); class_, base >("OptionLineEnd") .function("value", &Option::operator()); class_, base >("OptionTokenPos") .function("value", &Option::operator()); class_, base >("OptionUnsigned") .function("value", &Option::operator()); class_, base >("OptionSigned") .function("value", &Option::operator()); class_, base >("OptionString") .function("value", &Option::operator()); class_("OptionGroup") .property("description", select_overload( [](const OptionGroup &g) { return(std::string(g.description)); })) .property("options", &OptionGroup::options); register_vector("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(&show_config)); emscripten::function("show_config", select_overload(&show_config)); emscripten::function("show_config", select_overload(&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(&_uncrustify)); emscripten::function("_uncrustify", select_overload(&_uncrustify)); emscripten::function("_uncrustify", select_overload(&_uncrustify)); emscripten::function("_debug", select_overload(&_debug)); emscripten::function("_debug", select_overload(&_debug)); }; #endif