feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

C++ Tools: apply clang-format on cplusplus-keywordgen.cpp

Browse Source 
There is no history for this file after it was moved, so there's no harm
of beautifying it to be able to read and change.

Change-Id: Iec2ad5bc9d8553589b2d2512f69991f772808d89
Reviewed-by: Nikolai Kosjar <nikolai.kosjar@qt.io>
This commit is contained in:
Volodymyr Zibarov
2020-05-26 13:05:07 +03:00
parent 078ca0cdff
commit fcf364d61a
1 changed files with 257 additions and 236 deletions
Download Patch File Download Diff File Expand all files Collapse all files

493
src/tools/3rdparty/cplusplus-keywordgen/cplusplus-keywordgen.cpp vendored
View File

@@ -19,16 +19,16 @@
// ### TODO: Rewrite me.
#include <string>
#include <iostream>
#include <map>
#include <list>
#include <vector>
#include <set>
#include <cstdlib>
#include <cctype>
#include <functional>
#include <algorithm>
#include <cctype>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <set>
#include <string>
#include <vector>
class State;
class DottedItem;
@@ -40,102 +40,108 @@ typedef StateList::iterator StatePtr;
typedef std::string::iterator Dot;
typedef std::vector<DottedItem>::iterator DottedItemPtr;
class DottedItem {
class DottedItem
{
public:
RulePtr rule;
Dot dot;
RulePtr rule;
Dot dot;
DottedItem() {}
DottedItem() {}
DottedItem(RulePtr rule, Dot dot):
rule(rule), dot(dot) {}
DottedItem(RulePtr rule, Dot dot)
: rule(rule)
, dot(dot)
{}
bool operator == (const DottedItem &other) const {
return rule == other.rule && dot == other.dot;
}
bool operator==(const DottedItem &other) const
{
return rule == other.rule && dot == other.dot;
}
bool operator != (const DottedItem &other) const {
return ! operator == (other);
}
bool operator!=(const DottedItem &other) const { return !operator==(other); }
bool terminal() const {
return dot == rule->end();
}
bool terminal() const { return dot == rule->end(); }
DottedItem next() const {
DottedItem item;
item.rule = rule;
item.dot = dot;
++item.dot;
return item;
}
DottedItem next() const
{
DottedItem item;
item.rule = rule;
item.dot = dot;
++item.dot;
return item;
}
};
class State {
class State
{
public:
State() {}
State() {}
template <typename _ForwardIterator>
State(_ForwardIterator first, _ForwardIterator last) {
_items.insert(_items.end(), first, last);
}
static State &intern(const State &state) {
StatePtr ptr = std::find(first_state(), last_state(), state);
if (ptr == last_state())
ptr = states().insert(last_state(), state);
return *ptr;
}
State &next(char ch) {
std::vector<DottedItem> n;
for (DottedItemPtr it = first_item(); it != last_item(); ++it) {
if (! it->terminal() && *it->dot == ch)
n.push_back(it->next());
template<typename _ForwardIterator>
State(_ForwardIterator first, _ForwardIterator last)
{
_items.insert(_items.end(), first, last);
}
return intern(State(n.begin(), n.end()));
}
std::set<char> firsts() {
std::set<char> s;
for (DottedItemPtr it = first_item(); it != last_item(); ++it) {
if (! it->terminal())
s.insert(*it->dot);
static State &intern(const State &state)
{
StatePtr ptr = std::find(first_state(), last_state(), state);
if (ptr == last_state())
ptr = states().insert(last_state(), state);
return *ptr;
}
return s;
}
size_t item_count() const { return _items.size(); }
State &next(char ch)
{
std::vector<DottedItem> n;
for (DottedItemPtr it = first_item(); it != last_item(); ++it) {
if (!it->terminal() && *it->dot == ch)
n.push_back(it->next());
}
return intern(State(n.begin(), n.end()));
}
DottedItemPtr first_item() { return _items.begin(); }
DottedItemPtr last_item() { return _items.end(); }
std::set<char> firsts()
{
std::set<char> s;
for (DottedItemPtr it = first_item(); it != last_item(); ++it) {
if (!it->terminal())
s.insert(*it->dot);
}
return s;
}
static StatePtr first_state() { return states().begin(); }
static StatePtr last_state() { return states().end(); }
size_t item_count() const { return _items.size(); }
bool operator == (const State &other) const { return _items == other._items; }
bool operator != (const State &other) const { return _items != other._items; }
DottedItemPtr first_item() { return _items.begin(); }
DottedItemPtr last_item() { return _items.end(); }
template <typename _Iterator>
static State &start(_Iterator first, _Iterator last) {
std::vector<DottedItem> items;
for (; first != last; ++first)
items.push_back(DottedItem(first, first->begin()));
return intern(State(items.begin(), items.end()));
}
static StatePtr first_state() { return states().begin(); }
static StatePtr last_state() { return states().end(); }
static void reset() {
states().clear();
}
bool operator==(const State &other) const { return _items == other._items; }
bool operator!=(const State &other) const { return _items != other._items; }
template<typename _Iterator>
static State &start(_Iterator first, _Iterator last)
{
std::vector<DottedItem> items;
for (; first != last; ++first)
items.push_back(DottedItem(first, first->begin()));
return intern(State(items.begin(), items.end()));
}
static void reset() { states().clear(); }
private:
static StateList &states() {
static StateList _states;
return _states;
}
static StateList &states()
{
static StateList _states;
return _states;
}
private:
std::vector<DottedItem> _items;
std::vector<DottedItem> _items;
};
static bool option_no_enums = false;
@@ -147,186 +153,201 @@ static std::string option_unicode_function = "";
std::string token_id(const std::string &id)
{
std::string token = option_token_prefix;
std::string token = option_token_prefix;
if (! option_toupper)
token += id;
else {
for (size_t i = 0; i < id.size(); ++i)
token += toupper(id[i]);
}
if (!option_toupper)
token += id;
else {
for (size_t i = 0; i < id.size(); ++i)
token += toupper(id[i]);
}
return token;
return token;
}
bool starts_with(const std::string &line, const std::string &text) {
if (text.length() < line.length()) {
return std::equal(line.begin(), line.begin() + text.size(), text.begin());
}
return false;
bool starts_with(const std::string &line, const std::string &text)
{
if (text.length() < line.length()) {
return std::equal(line.begin(), line.begin() + text.size(), text.begin());
}
return false;
}
void doit(State &state)
{
static int depth{0};
static int depth{0};
++depth;
++depth;
std::string indent(depth * 2, ' ');
std::string indent(depth * 2, ' ');
std::set<char> firsts = state.firsts();
for (std::set<char>::iterator it = firsts.begin(); it != firsts.end(); ++it) {
std::string _else = it == firsts.begin() ? "" : "else ";
std::cout << indent << _else << "if (s[" << (depth - 1) << "]" << option_unicode_function << " == '" << *it << "') {" << std::endl;
State &next_state = state.next(*it);
std::set<char> firsts = state.firsts();
for (std::set<char>::iterator it = firsts.begin(); it != firsts.end(); ++it) {
std::string _else = it == firsts.begin() ? "" : "else ";
std::cout << indent << _else << "if (s[" << (depth - 1) << "]" << option_unicode_function
<< " == '" << *it << "') {" << std::endl;
State &next_state = state.next(*it);
bool found = false;
for (DottedItemPtr item = next_state.first_item(); item != next_state.last_item(); ++item) {
if (item->terminal()) {
if (found) {
std::cerr << "*** Error. Too many accepting states" << std::endl;
exit(EXIT_FAILURE);
}
found = true;
std::cout << indent << " return " << option_namespace_name << token_id(*item->rule) << ";" << std::endl;
}
bool found = false;
for (DottedItemPtr item = next_state.first_item(); item != next_state.last_item(); ++item) {
if (item->terminal()) {
if (found) {
std::cerr << "*** Error. Too many accepting states" << std::endl;
exit(EXIT_FAILURE);
}
found = true;
std::cout << indent << " return " << option_namespace_name << token_id(*item->rule)
<< ";" << std::endl;
}
}
if (!found)
doit(next_state);
std::cout << indent << "}" << std::endl;
}
if (! found)
doit(next_state);
std::cout << indent << "}" << std::endl;
}
--depth;
--depth;
}
void gen_classify_n(State &start_state, int N)
{
std::cout << "static inline int classify" << N << "(const " << option_char_type << " *s) {" << std::endl;
doit(start_state);
std::cout << " return " << option_namespace_name << token_id("identifier") << ";" << std::endl
<< "}" << std::endl << std::endl;
std::cout << "static inline int classify" << N << "(const " << option_char_type << " *s) {"
<< std::endl;
doit(start_state);
std::cout << " return " << option_namespace_name << token_id("identifier") << ";" << std::endl
<< "}" << std::endl
<< std::endl;
}
void gen_classify(const std::multimap<size_t, std::string> &keywords)
{
std::cout << "int " << option_namespace_name << "classify(const " << option_char_type << " *s, int n) {" << std::endl
<< " switch (n) {" << std::endl;
std::multimap<size_t, std::string>::const_iterator it = keywords.begin();
while (it != keywords.end()) {
size_t size = it->first;
std::cout << " case " << size << ": return classify" << size << "(s);" << std::endl;
do { ++it; } while (it != keywords.end() && it->first == size);
}
std::cout << " default: return " << option_namespace_name << token_id("identifier") << ";" << std::endl
<< " } // switch" << std::endl
<< "}" << std::endl << std::endl;
std::cout << "int " << option_namespace_name << "classify(const " << option_char_type
<< " *s, int n) {" << std::endl
<< " switch (n) {" << std::endl;
std::multimap<size_t, std::string>::const_iterator it = keywords.begin();
while (it != keywords.end()) {
size_t size = it->first;
std::cout << " case " << size << ": return classify" << size << "(s);" << std::endl;
do {
++it;
} while (it != keywords.end() && it->first == size);
}
std::cout << " default: return " << option_namespace_name << token_id("identifier") << ";"
<< std::endl
<< " } // switch" << std::endl
<< "}" << std::endl
<< std::endl;
}
void gen_enums(const std::multimap<size_t, std::string> &keywords)
{
std::cout << "enum {" << std::endl;
std::multimap<size_t, std::string>::const_iterator it = keywords.begin();
for (; it != keywords.end(); ++it) {
std::cout << " " << token_id(it->second) << "," << std::endl;
}
std::cout << " " << token_id("identifier") << std::endl
<< "};" << std::endl << std::endl;
}
inline bool not_whitespace_p(char ch) {
return ! std::isspace(ch);
}
int main(int argc, char *argv[]) {
const std::string ns = "--namespace=";
for (int i = 0; i < argc; ++i) {
const std::string arg(argv[i]);
if (arg == "--no-enums")
option_no_enums = true;
else if (starts_with(arg, ns)) {
option_namespace_name.assign(arg.begin() + ns.size(), arg.end());
option_namespace_name += "::";
std::cout << "enum {" << std::endl;
std::multimap<size_t, std::string>::const_iterator it = keywords.begin();
for (; it != keywords.end(); ++it) {
std::cout << " " << token_id(it->second) << "," << std::endl;
}
}
std::multimap<size_t, std::string> keywords;
std::string textline;
bool readKeywords = false;
const std::string opt_no_enums = "%no-enums";
const std::string opt_toupper = "%toupper";
const std::string opt_ns = "%namespace=";
const std::string opt_tok_prefix = "%token-prefix=";
const std::string opt_char_type = "%char-type=";
const std::string opt_unicode_function = "%unicode-function=";
while (getline(std::cin, textline)) {
// remove trailing spaces
textline.assign(textline.begin(), std::find_if(textline.rbegin(), textline.rend(), not_whitespace_p).base());
if (! readKeywords) {
if (textline.size() >= 2 && textline[0] == '%') {
if (textline[1] == '%') {
readKeywords = true;
} else if (textline == opt_no_enums) {
option_no_enums = true;
} else if (textline == opt_toupper) {
option_toupper = true;
} else if (starts_with(textline, opt_tok_prefix)) {
option_token_prefix.assign(textline.begin() + opt_tok_prefix.size(), textline.end());
} else if (starts_with(textline, opt_char_type)) {
option_char_type.assign(textline.begin() + opt_char_type.size(), textline.end());
} else if (starts_with(textline, opt_unicode_function)) {
option_unicode_function.assign(textline.begin() + opt_unicode_function.size(), textline.end());
} else if (starts_with(textline, opt_ns)) {
option_namespace_name.assign(textline.begin() + opt_ns.size(), textline.end());
option_namespace_name += "::";
}
continue;
}
std::cout << textline << std::endl;
} else {
if (textline.empty())
continue;
std::string::iterator start = textline.begin();
while (start != textline.end() && std::isspace(*start))
++start;
std::string::iterator stop = start;
while (stop != textline.end() && (std::isalnum(*stop) || *stop == '_'))
++stop;
if (start != stop) {
std::string keyword(start, stop);
if (keyword == "identifier") {
std::cerr << "*** Error. `identifier' is reserved" << std::endl;
exit(EXIT_FAILURE);
}
keywords.insert(std::make_pair(keyword.size(), keyword));
}
}
}
if (! option_no_enums)
gen_enums(keywords);
std::multimap<size_t, std::string>::iterator it = keywords.begin();
while (it != keywords.end()) {
size_t size = it->first;
RuleList rules;
do { rules.push_back(it->second); ++it; }
while (it != keywords.end() && it->first == size);
gen_classify_n(State::start(rules.begin(), rules.end()), size);
State::reset();
}
gen_classify(keywords);
std::cout << " " << token_id("identifier") << std::endl << "};" << std::endl << std::endl;
}
inline bool not_whitespace_p(char ch)
{
return !std::isspace(ch);
}
int main(int argc, char *argv[])
{
const std::string ns = "--namespace=";
for (int i = 0; i < argc; ++i) {
const std::string arg(argv[i]);
if (arg == "--no-enums")
option_no_enums = true;
else if (starts_with(arg, ns)) {
option_namespace_name.assign(arg.begin() + ns.size(), arg.end());
option_namespace_name += "::";
}
}
std::multimap<size_t, std::string> keywords;
std::string textline;
bool readKeywords = false;
const std::string opt_no_enums = "%no-enums";
const std::string opt_toupper = "%toupper";
const std::string opt_ns = "%namespace=";
const std::string opt_tok_prefix = "%token-prefix=";
const std::string opt_char_type = "%char-type=";
const std::string opt_unicode_function = "%unicode-function=";
while (getline(std::cin, textline)) {
// remove trailing spaces
textline.assign(textline.begin(),
std::find_if(textline.rbegin(), textline.rend(), not_whitespace_p).base());
if (!readKeywords) {
if (textline.size() >= 2 && textline[0] == '%') {
if (textline[1] == '%') {
readKeywords = true;
} else if (textline == opt_no_enums) {
option_no_enums = true;
} else if (textline == opt_toupper) {
option_toupper = true;
} else if (starts_with(textline, opt_tok_prefix)) {
option_token_prefix.assign(textline.begin() + opt_tok_prefix.size(),
textline.end());
} else if (starts_with(textline, opt_char_type)) {
option_char_type.assign(textline.begin() + opt_char_type.size(), textline.end());
} else if (starts_with(textline, opt_unicode_function)) {
option_unicode_function.assign(textline.begin() + opt_unicode_function.size(),
textline.end());
} else if (starts_with(textline, opt_ns)) {
option_namespace_name.assign(textline.begin() + opt_ns.size(), textline.end());
option_namespace_name += "::";
}
continue;
}
std::cout << textline << std::endl;
} else {
if (textline.empty())
continue;
std::string::iterator start = textline.begin();
while (start != textline.end() && std::isspace(*start))
++start;
std::string::iterator stop = start;
while (stop != textline.end() && (std::isalnum(*stop) || *stop == '_'))
++stop;
if (start != stop) {
std::string keyword(start, stop);
if (keyword == "identifier") {
std::cerr << "*** Error. `identifier' is reserved" << std::endl;
exit(EXIT_FAILURE);
}
keywords.insert(std::make_pair(keyword.size(), keyword));
}
}
}
if (!option_no_enums)
gen_enums(keywords);
std::multimap<size_t, std::string>::iterator it = keywords.begin();
while (it != keywords.end()) {
size_t size = it->first;
RuleList rules;
do {
rules.push_back(it->second);
++it;
} while (it != keywords.end() && it->first == size);
gen_classify_n(State::start(rules.begin(), rules.end()), size);
State::reset();
}
gen_classify(keywords);
}