immibis
/
colobot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Replaced boost::bimap with std::map 

Code extracted from f0f6f61cab
dev
Tomasz Kapuściński 2023-08-09 16:25:18 +02:00
parent f9714c35f7
commit beb29333d5
4 changed files with 110 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

218
CBot/src/CBot/CBotToken.cpp
View File

@ -21,133 +21,117 @@
#include <cstdarg> #include <cstdarg>
#include <cassert> #include <cassert>
#include <boost/bimap.hpp> #include <map>
namespace CBot namespace CBot
{ {
namespace namespace
{ {
template <typename L, typename R> static const std::string TX_UNDEF_VALUE = "undefined";
boost::bimap<L, R> makeBimap(std::initializer_list<typename boost::bimap<L, R>::value_type> list)
{
return boost::bimap<L, R>(list.begin(), list.end());
}
} }
//! \brief Keeps the string corresponding to keyword ID //! \brief Keeps the string corresponding to keyword ID
//! Map is filled with id-string pars that are needed for CBot language parsing //! Map is filled with id-string pars that are needed for CBot language parsing
static const boost::bimap<TokenId, std::string> KEYWORDS = makeBimap<TokenId, std::string>({ static const std::map<std::string, TokenId> KEYWORDS{
{ID_IF, "if"}, {"if", ID_IF},
{ID_ELSE, "else"}, {"else", ID_ELSE},
{ID_WHILE, "while"}, {"while", ID_WHILE},
{ID_DO, "do"}, {"do", ID_DO},
{ID_FOR, "for"}, {"for", ID_FOR},
{ID_BREAK, "break"}, {"break", ID_BREAK},
{ID_CONTINUE, "continue"}, {"continue", ID_CONTINUE},
{ID_SWITCH, "switch"}, {"switch", ID_SWITCH},
{ID_CASE, "case"}, {"case", ID_CASE},
{ID_DEFAULT, "default"}, {"default", ID_DEFAULT},
{ID_TRY, "try"}, {"try", ID_TRY},
{ID_THROW, "throw"}, {"throw", ID_THROW},
{ID_CATCH, "catch"}, {"catch", ID_CATCH},
{ID_FINALLY, "finally"}, {"finally", ID_FINALLY},
{ID_TXT_AND, "and"}, {"and", ID_TXT_AND},
{ID_TXT_OR, "or"}, {"or", ID_TXT_OR},
{ID_TXT_NOT, "not"}, {"not", ID_TXT_NOT},
{ID_RETURN, "return"}, {"return", ID_RETURN},
{ID_CLASS, "class"}, {"class", ID_CLASS},
{ID_EXTENDS, "extends"}, {"extends", ID_EXTENDS},
{ID_SYNCHO, "synchronized"}, {"synchronized", ID_SYNCHO},
{ID_NEW, "new"}, {"new", ID_NEW},
{ID_PUBLIC, "public"}, {"public", ID_PUBLIC},
{ID_EXTERN, "extern"}, {"extern", ID_EXTERN},
{ID_STATIC, "static"}, {"static", ID_STATIC},
{ID_PROTECTED, "protected"}, {"protected", ID_PROTECTED},
{ID_PRIVATE, "private"}, {"private", ID_PRIVATE},
{ID_REPEAT, "repeat"}, {"repeat", ID_REPEAT},
{ID_INT, "int"}, {"int", ID_INT},
{ID_FLOAT, "float"}, {"float", ID_FLOAT},
{ID_BOOLEAN, "boolean"}, {"boolean", ID_BOOLEAN},
{ID_STRING, "string"}, {"string", ID_STRING},
{ID_VOID, "void"}, {"void", ID_VOID},
{ID_BOOL, "bool"}, {"bool", ID_BOOL},
{ID_BYTE, "byte"}, {"byte", ID_BYTE},
{ID_SHORT, "short"}, {"short", ID_SHORT},
{ID_CHAR, "char"}, {"char", ID_CHAR},
{ID_LONG, "long"}, {"long", ID_LONG},
{ID_DOUBLE, "double"}, {"double", ID_DOUBLE},
{ID_TRUE, "true"}, {"true", ID_TRUE},
{ID_FALSE, "false"}, {"false", ID_FALSE},
{ID_NULL, "null"}, {"null", ID_NULL},
{ID_NAN, "nan"}, {"nan", ID_NAN},
{ID_OPENPAR, "("}, {"(", ID_OPENPAR},
{ID_CLOSEPAR, ")"}, {")", ID_CLOSEPAR},
{ID_OPBLK, "{"}, {"{", ID_OPBLK},
{ID_CLBLK, "}"}, {"}", ID_CLBLK},
{ID_SEP, ";"}, {";", ID_SEP},
{ID_COMMA, ","}, {",", ID_COMMA},
{ID_DOTS, ":"}, {":", ID_DOTS},
{ID_DOT, "."}, {".", ID_DOT},
{ID_OPBRK, "["}, {"[", ID_OPBRK},
{ID_CLBRK, "]"}, {"]", ID_CLBRK},
{ID_DBLDOTS, "::"}, {"::", ID_DBLDOTS},
{ID_LOGIC, "?"}, {"?", ID_LOGIC},
{ID_ADD, "+"}, {"+", ID_ADD},
{ID_SUB, "-"}, {"-", ID_SUB},
{ID_MUL, "*"}, {"*", ID_MUL},
{ID_DIV, "/"}, {"/", ID_DIV},
{ID_ASS, "="}, {"=", ID_ASS},
{ID_ASSADD, "+="}, {"+=", ID_ASSADD},
{ID_ASSSUB, "-="}, {"-=", ID_ASSSUB},
{ID_ASSMUL, "*="}, {"*=", ID_ASSMUL},
{ID_ASSDIV, "/="}, {"/=", ID_ASSDIV},
{ID_ASSOR, "|="}, {"|=", ID_ASSOR},
{ID_ASSAND, "&="}, {"&=", ID_ASSAND},
{ID_ASSXOR, "^="}, {"^=", ID_ASSXOR},
{ID_ASSSL, "<<="}, {"<<=", ID_ASSSL},
{ID_ASSSR, ">>>="}, {">>>=", ID_ASSSR},
{ID_ASSASR, ">>="}, {">>=", ID_ASSASR},
{ID_SL, "<<"}, {"<<", ID_SL},
{ID_SR, ">>>"}, {">>>", ID_SR},
{ID_ASR, ">>"}, {">>", ID_ASR},
{ID_INC, "++"}, {"++", ID_INC},
{ID_DEC, "--"}, {"--", ID_DEC},
{ID_LO, "<"}, {"<", ID_LO},
{ID_HI, ">"}, {">", ID_HI},
{ID_LS, "<="}, {"<=", ID_LS},
{ID_HS, ">="}, {">=", ID_HS},
{ID_EQ, "=="}, {"==", ID_EQ},
{ID_NE, "!="}, {"!=", ID_NE},
{ID_AND, "&"}, {"&", ID_AND},
{ID_XOR, "^"}, {"^", ID_XOR},
{ID_OR, "|"}, {"|", ID_OR},
{ID_LOG_AND, "&&"}, {"&&", ID_LOG_AND},
{ID_LOG_OR, "||"}, {"||", ID_LOG_OR},
{ID_LOG_NOT, "!"}, {"!", ID_LOG_NOT},
{ID_NOT, "~"}, {"~", ID_NOT},
{ID_MODULO, "%"}, {"%", ID_MODULO},
{ID_POWER, "**"}, {"**", ID_POWER},
{ID_ASSMODULO, "%="}, {"%=", ID_ASSMODULO},
{TX_UNDEF, "undefined"}, {TX_UNDEF_VALUE, TX_UNDEF},
{TX_NAN, "not a number"} {"not a number", TX_NAN}
}); };
namespace const std::string& UndefinedTokenString()
{ {
static const std::string emptyString = ""; return TX_UNDEF_VALUE;
}
const std::string& LoadString(TokenId id)
{
auto it = KEYWORDS.left.find(id);
if (it != KEYWORDS.left.end())
{
return it->second;
}
else
{
return emptyString;
}
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@ -504,8 +488,8 @@ std::unique_ptr<CBotToken> CBotToken::CompileTokens(const std::string& program)
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
int CBotToken::GetKeyWord(const std::string& w) int CBotToken::GetKeyWord(const std::string& w)
{ {
auto it = KEYWORDS.right.find(w); auto it = KEYWORDS.find(w);
if (it != KEYWORDS.right.end()) if (it != KEYWORDS.end())
{ {
return it->second; return it->second;
} }

11
CBot/src/CBot/CBotToken.h
View File

@ -242,10 +242,13 @@ extern bool IsOfType(CBotToken* &p, int type1, int type2 = -1);
extern bool IsOfTypeList(CBotToken* &p, int type1, ...); extern bool IsOfTypeList(CBotToken* &p, int type1, ...);
/** /**
* \brief Maps given ID to its string equivalent * \brief Return the value associated with TX_UNDEF TokenId
* \param id Token type identifier *
* \return String if found, empty string otherwise * Mapping other TokenIds to its string values was not used and does not seem useful
* so the only supported mapping is TX_UNDEF -> value.
*
* \return String associated with TX_UNDEF TokenId
*/ */
const std::string& LoadString(TokenId id); const std::string& UndefinedTokenString();
} // namespace CBot } // namespace CBot

2
CBot/src/CBot/CBotVar/CBotVarChar.h
View File

@ -35,7 +35,7 @@ public:
std::string GetValString() const override std::string GetValString() const override
{ {
if (m_binit == CBotVar::InitType::UNDEF) if (m_binit == CBotVar::InitType::UNDEF)
return LoadString(TX_UNDEF); return UndefinedTokenString();
if (0x10FFFF < m_val || (0xD7FF < m_val && m_val < 0xE000)) if (0x10FFFF < m_val || (0xD7FF < m_val && m_val < 0xE000))
return "\xEF\xBF\xBD"; // replacement character U+FFFD return "\xEF\xBF\xBD"; // replacement character U+FFFD

2
CBot/src/CBot/CBotVar/CBotVarValue.h
View File

@ -65,7 +65,7 @@ public:
std::string GetValString() const override std::string GetValString() const override
{ {
if (m_binit == CBotVar::InitType::UNDEF) if (m_binit == CBotVar::InitType::UNDEF)
return LoadString(TX_UNDEF); return UndefinedTokenString();
std::ostringstream s; std::ostringstream s;
s << std::boolalpha << m_val; s << std::boolalpha << m_val;