You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1214 lines
39 KiB
1214 lines
39 KiB
/*
|
|
* 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
|