Warning-free clang build

buck-yeh · buck-yeh · commit 4945489d73ae · 2021-02-14T20:40:57.000+08:00
1. ✍️ Stop using `[[unlikely]]` until clang-12 is available.
2. ✍️ Eliminate clang warnings here &amp; there.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,8 +1,6 @@
 cmake_minimum_required (VERSION 3.18)
 cmake_policy(VERSION 3.18)
 
-#set(CMAKE_CXX_COMPILER "clang++")
-
 include(FetchContent)
 
 FetchContent_Declare(
@@ -21,6 +19,21 @@ FetchContent_MakeAvailable(FetchedBux FetchedCBrackets)
 
 project(ParserSuite)
 
+IF(CMAKE_CXX_COMPILER_ID MATCHES Clang|GNU)
+    string(APPEND CMAKE_CXX_FLAGS " -Wall -Wextra -Wshadow -Wconversion -Ofast -std=c++2a")
+    IF(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+        message("Clang")
+        string(APPEND CMAKE_CXX_FLAGS " -Wno-potentially-evaluated-expression -Wno-deprecated-anon-enum-enum-conversion")
+    ELSEIF(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        message("GNU")
+        #string(APPEND CMAKE_CXX_FLAGS " -Wno-maybe-uninitialized")
+    ELSE()
+        message("Else 1/2")
+    ENDIF()
+ELSE()
+    message("Else 2/2")
+ENDIF()
+
 add_subdirectory (ParserGen)
 add_subdirectory (ScannerGen)
 add_subdirectory (example)
diff --git a/ParserGen/BNFContext.cpp b/ParserGen/BNFContext.cpp
@@ -436,7 +436,7 @@ void C_BNFContext::wrapup(const bux::C_SourcePos &pos)
             {
                 auto out = fmt::format(FMT_STRING("Duplicate priority assignments on id {}"), id);
                 if (id < 127)
-                    out += fmt::format("(\'{}\')", asciiLiteral(char(id)));
+                    out += fmt::format("(\'{}\')", asciiLiteral(id));
                 log(LL_ERROR, pos, out);
             }
             break;
diff --git a/ParserGen/CMakeLists.txt b/ParserGen/CMakeLists.txt
@@ -1,9 +1,9 @@
-#set(CMAKE_CXX_COMPILER "clang++")
+#set(CMAKE_CXX_COMPILER_ID "Clang")
 
 include_directories("../../bux/include" "../../CBrackets") # ${Boost_INCLUDE_DIRS})
-#link_directories("../../lib/bux" "../CBrackets")
-string(APPEND CMAKE_CXX_FLAGS " -Wall -Wextra -Wconversion -Wno-parentheses -Wno-unknown-pragmas -O3 -std=c++2a")
-#string(APPEND CMAKE_CXX_FLAGS " -Wall -Wextra -Wno-parentheses -Wno-unknown-pragmas -g3 -Og -std=c++2a")
+string(APPEND CMAKE_CXX_FLAGS " -Wno-shadow")
+#string(APPEND CMAKE_CXX_FLAGS " -g3 -Og")
+
 set(COMMON_SRC
     BNFContext.cpp
     Parser.cpp ParseFile.cpp ParserGenBase.cpp
@@ -18,12 +18,12 @@ add_executable(parsergen
     ${COMMON_SRC}
     )
 #target_compile_options(parsergen PRIVATE -O0 -g3)
-target_link_libraries(parsergen bracketPairing bux fmt)
+target_link_libraries(parsergen bracketPairing bux fmt stdc++)
 #add_dependencies(parsergen bracketPairing bux)
 
 add_executable(grammarstrip
     GrammarStrip.cpp
     ${COMMON_SRC}
     )
-target_link_libraries(grammarstrip bracketPairing bux fmt)
+target_link_libraries(grammarstrip bracketPairing bux fmt stdc++)
 #add_dependencies(grammarstrip bracketPairing bux)
diff --git a/ParserGen/Cfa.cpp b/ParserGen/Cfa.cpp
@@ -265,7 +265,7 @@ void FC_CreateClosure::operator()(C_StateItems &dst) const
                             changed = true;
 
                         const auto n =la.size();
-                        for (auto k = seq.begin()+item.second; ++k != seq.end();)
+                        for (auto k = seq.begin()+std::ptrdiff_t(item.second); ++k != seq.end();)
                             if (auto const nt = dynamic_cast<C_Nonterminal*>(*k))
                             {
                                 auto &attrs =getAttr(nt->m_id);
@@ -433,8 +433,8 @@ FC_LessGotoKey::FC_LessGotoKey(const C_ParserInfo &parsed): m_LessTerm(parsed)
 
 bool FC_LessGotoKey::operator()(const C_GotoKey &a, const C_GotoKey &b) const
 {
-    return  a.first->m_id < b.first->m_id ||
-            a.first->m_id == b.first->m_id && m_LessTerm(a.second,b.second);
+    return  a.first->m_id < b.first->m_id || (
+            a.first->m_id == b.first->m_id && m_LessTerm(a.second,b.second));
 }
 
 C_GotoMap::C_GotoMap(const C_ParserInfo &parsed):
diff --git a/ParserGen/Output.h b/ParserGen/Output.h
@@ -14,7 +14,7 @@ enum
     //
     VERSION_MAJOR           = 1,
     VERSION_MINOR           = 6,
-    VERSION_RELEASE         = 2
+    VERSION_RELEASE         = 3
 };
 
 namespace bux { // reusability to be assessed
@@ -56,7 +56,7 @@ int findSubseq(const std::vector<T> &super, const std::vector<T> &sub)
     int ret = -1;
     if (!super.empty())
     {
-        for (auto i = super.begin(), end = super.end() - sub.size(); i <= end; ++i)
+        for (auto i = super.begin(), end = super.end() - ssize(sub); i <= end; ++i)
         {
             bool match = true;
             auto j = i;
diff --git a/ParserGen/Parser.cpp b/ParserGen/Parser.cpp
@@ -566,7 +566,7 @@ void _reduce_1(bux::LR1::C_Parser &_paRSeR_, const F_GetProduced &_geT_, C_RetLv
 
     if (auto targs = bux::tryUnlex<C_TemplateArgs>(_geT_(2)))
     {
-        if (auto err = c.setClassName(bux::unlex<C_StringList>(_geT_(1)), *targs)) [[unlikely]]
+        if (auto err = c.setClassName(bux::unlex<C_StringList>(_geT_(1)), *targs))
             _paRSeR_.onError(_geT_(0), *err);
     }
     else
@@ -609,7 +609,7 @@ void _reduce_4(bux::LR1::C_Parser &_paRSeR_, const F_GetProduced &_geT_, C_RetLv
         return;
 
     auto &prod = dynamic_cast<C_Production&>(*_geT_(0));
-    if (!c.addProduction(prod, bux::tryUnlex<C_Semantic>(_geT_(1)))) [[unlikely]]
+    if (!c.addProduction(prod, bux::tryUnlex<C_Semantic>(_geT_(1))))
         _paRSeR_.onError(_geT_(0), "Production re-defined:\n"
                              "\t" + prod.str());
 }
@@ -1148,9 +1148,9 @@ bux::T_StateID C_ParserPolicy::nextState(bux::T_StateID state, bux::T_LexID inpu
 bool C_ParserPolicy::changeToken(T_LexID &token, C_LexPtr &attr) const
 {
     // Grammar %UPCAST_TOKEN begins
-    if (isascii(token) && !iscntrl(token) && !isalnum(token) && !isspace(token))
+    if (const auto it = int(token); isascii(it) && !iscntrl(it) && !isalnum(it) && !isspace(it))
     {
-        attr.assign(bux::createLex<std::string>(1,char(token)), true);
+        attr.assign(bux::createLex<std::string>(1u,char(token)), true);
         token = TID_LEX_Operator;
         return true;
     }
diff --git a/ParserGen/ParserGenBase.cpp b/ParserGen/ParserGenBase.cpp
@@ -29,7 +29,7 @@ bool getNonterminalID(const std::string &str, std::string &dst)
 bool isKeyword(const std::string &str)
 {
     for (auto c: str)
-        if (!isascii(c) || c != '_' && !isalnum(c))
+        if (!isascii(c) || (c != '_' && !isalnum(c)))
             return false;
 
     return true;
@@ -38,16 +38,15 @@ bool isKeyword(const std::string &str)
 std::string literalSuffix(const std::string &s)
 {
     std::string ret;
-    for (auto i =s.begin(); i != s.end(); ++i)
+    for (auto c: s)
     {
-        unsigned char c =*i;
         if (isascii(c) && isalnum(c))
         {
-            ret +=c;
-            ret +='_';
+            ret += c;
+            ret += '_';
         }
         else
-            bux::addAsHex(ret, c);
+            bux::addAsHex(ret, (uint8_t)c);
     }
     return ret;
 }
@@ -238,7 +237,7 @@ std::string C_ParserInfo::outputId(const I_ProductionTerm *term) const
         idstr.assign("TID_LEX_").append(lex->m_Var);
     }
     else if (auto const slex =dynamic_cast<const C_StrLiteral*>(term))
-        return std::string(1,'\'').append(asciiLiteral(slex->m_Str[0])).append(1,'\'');
+        return std::string(1u,'\'').append(asciiLiteral(uint8_t(slex->m_Str[0]))).append(1u,'\'');
     else
         RUNTIME_ERROR("{}Fail to produce output id for {}", idstr, HRTN(*term));
 
diff --git a/ParserGen/ginc/grammar.cpp b/ParserGen/ginc/grammar.cpp
@@ -20,7 +20,7 @@
 
     if (auto targs = bux::tryUnlex<C_TemplateArgs>($3))
     {
-        if (auto err = c.setClassName(bux::unlex<C_StringList>($2), *targs)) [[unlikely]]
+        if (auto err = c.setClassName(bux::unlex<C_StringList>($2), *targs))
             $p.onError($1, *err);
     }
     else
@@ -55,7 +55,7 @@
         return;
 
     auto &prod = dynamic_cast<C_Production&>(*$1);
-    if (!c.addProduction(prod, bux::tryUnlex<C_Semantic>($2))) [[unlikely]]
+    if (!c.addProduction(prod, bux::tryUnlex<C_Semantic>($2)))
         $p.onError($1, "Production re-defined:\n"
                              "\t" + prod.str());
 ]]
diff --git a/ParserGen/ginc/impl.cpp b/ParserGen/ginc/impl.cpp
@@ -5,9 +5,9 @@
 ]]
 
 %UPCAST_TOKEN [[
-    if (isascii($token) && !iscntrl($token) && !isalnum($token) && !isspace($token))
+    if (const auto it = int($token); isascii(it) && !iscntrl(it) && !isalnum(it) && !isspace(it))
     {
-        $attr.assign(bux::createLex<std::string>(1,char($token)), true);
+        $attr.assign(bux::createLex<std::string>(1u,char($token)), true);
         $token = TID_LEX_Operator;
         return true;
     }
diff --git a/ScannerGen/CMakeLists.txt b/ScannerGen/CMakeLists.txt
@@ -1,7 +1,6 @@
-#set(CMAKE_CXX_COMPILER "clang++")
+#set(CMAKE_CXX_COMPILER_ID "Clang")
 
 include_directories("../../bux/include" "../../CBrackets")
-string(APPEND CMAKE_CXX_FLAGS " -Wall -Wextra -Wshadow -Wconversion -Wno-parentheses -Wno-unknown-pragmas -Wno-maybe-uninitialized -Ofast -std=c++2a")
 
 add_executable(scannergen
     Context.cpp
@@ -11,10 +10,10 @@ add_executable(scannergen
     spec2charset.cpp
     )
 #target_compile_options(scannergen PRIVATE -O0 -g3)
-target_link_libraries(scannergen bracketPairing bux fmt)
+target_link_libraries(scannergen bracketPairing bux fmt stdc++)
 
 add_executable(handycharset
     HandyCharset.cpp
     spec2charset.cpp
     )
-target_link_libraries(handycharset bux fmt)
+target_link_libraries(handycharset bux fmt stdc++)
diff --git a/ScannerGen/Parser.cpp b/ScannerGen/Parser.cpp
@@ -1078,7 +1078,7 @@ void _reduce_11(bux::LR1::C_Parser &, const F_GetProduced &_geT_, C_RetLval _reT
 {
     bux::C_NewNode<C_NfaLex> ret;
     for (auto i: bux::unlex<std::string>(_geT_(0)))
-        ret->m_NFA.append(C_LexSet(i));
+        ret->m_NFA.append(C_LexSet(uint8_t(i)));
 
     _reT_ = ret;
 }
@@ -1475,9 +1475,9 @@ bux::T_StateID C_ParserPolicy::nextState(bux::T_StateID state, bux::T_LexID inpu
 bool C_ParserPolicy::changeToken(T_LexID &token, C_LexPtr &attr) const
 {
     // Grammar %UPCAST_TOKEN begins
-    if (isascii(token) && !iscntrl(token) && !isalnum(token) && !isspace(token))
+    if (const auto it = int(token); isascii(it) && !iscntrl(it) && !isalnum(it) && !isspace(it))
     {
-        attr.assign(bux::createLex<std::string>(1,char(token)), true);
+        attr.assign(bux::createLex<std::string>(1u,char(token)), true);
         token = TID_LEX_Operator;
         return true;
     }
diff --git a/ScannerGen/grammar.txt b/ScannerGen/grammar.txt
@@ -90,7 +90,7 @@ right  ( ) { }
 <RegExprTerm> ::= $String           [[
     bux::C_NewNode<C_NfaLex> ret;
     for (auto i: bux::unlex<std::string>($1))
-        ret->m_NFA.append(C_LexSet(i));
+        ret->m_NFA.append(C_LexSet(uint8_t(i)));
 
     $r = ret;
 ]]
@@ -318,9 +318,9 @@ struct C_LexListLex: bux::I_LexAttr
 ]]
 
 %UPCAST_TOKEN [[
-    if (isascii($token) && !iscntrl($token) && !isalnum($token) && !isspace($token))
+    if (const auto it = int($token); isascii(it) && !iscntrl(it) && !isalnum(it) && !isspace(it))
     {
-        $attr.assign(bux::createLex<std::string>(1,char($token)), true);
+        $attr.assign(bux::createLex<std::string>(1u,char($token)), true);
         $token = TID_LEX_Operator;
         return true;
     }
diff --git a/ScannerGen/main.cpp b/ScannerGen/main.cpp
@@ -41,7 +41,7 @@ enum
     //
     VERSION_MAJOR           = 1,
     VERSION_MINOR           = 5,
-    VERSION_RELEASE         = 2,
+    VERSION_RELEASE         = 3,
     //
     //      Error Codes
     //
@@ -257,11 +257,11 @@ void C_Output::writeCpp(std::ostream &out, const std::string &base) const
     if (!m_NS.empty())
     {
         out <<"using namespace ";
-        first =true;
+        first = true;
         for (const auto &i: m_NS)
         {
             if (first)
-                first =false;
+                first = false;
             else
                 out <<"::";
 
@@ -291,33 +291,30 @@ void C_Output::writeCpp(std::ostream &out, const std::string &base) const
     for (const auto &i: rawTrans)
     {
         C_Lex2State cookedMap;
-        first =true;
-        bux::T_LexID prevUB;
+        std::optional<bux::T_LexID> prevUB;
         for (const auto &j: i.second)
         {
-            if (first)
-                first =false;
-            else if (++prevUB < j.first.first)
-                cookedMap.emplace_back(prevUB, std::numeric_limits<int>::max());
+            if (prevUB && ++*prevUB < j.first.first)
+                cookedMap.emplace_back(*prevUB, std::numeric_limits<int>::max());
 
             cookedMap.emplace_back(j.first.first, j.second);
             prevUB = j.first.second;
         }
-        if (prevUB != std::numeric_limits<bux::T_LexID>::max())
-            cookedMap.emplace_back(prevUB+1, std::numeric_limits<int>::max());
+        if (const auto t = prevUB.value(); t != std::numeric_limits<bux::T_LexID>::max())
+            cookedMap.emplace_back(t+1u, std::numeric_limits<int>::max());
 
-        cookedTrans[i.first] = cookedMaps.insert(C_StateMap2Index::value_type(cookedMap,0)).first;
+        cookedTrans[i.first] = cookedMaps.insert(std::pair{cookedMap,0}).first;
     }
 
     if (!cookedMaps.empty())
     {
         out <<"// ASCII TABLE:";
-        for (int i =0; i < 128; ++i)
+        for (uint32_t i = 0; i < 128; ++i)
         {
             if (i %0x20 == 0)
-                out <<"\n// " <<std::hex <<std::setw(2) <<i <<std::dec <<": ";
+                fmt::print(out, "\n// {:2x}: ", i);
 
-            out <<bux::asciiLiteral(char(i));
+            out <<bux::asciiLiteral(i);
         }
 
         int tag =0;
@@ -332,8 +329,8 @@ void C_Output::writeCpp(std::ostream &out, const std::string &base) const
             {
                 out <<(first?'{':',') <<"\n"
                       "    {";
-                if (isascii(j.first))
-                    out <<'\'' <<bux::asciiLiteral(char(j.first)) <<"\', ";
+                if (isascii(int(j.first)))
+                    out <<'\'' <<bux::asciiLiteral(j.first) <<"\', ";
                 else
                     out <<"0x" <<std::hex <<j.first <<std::dec <<", ";
 
@@ -366,7 +363,7 @@ void C_Output::writeCpp(std::ostream &out, const std::string &base) const
     writeUserSection(out, "LOCAL_ACTION_DEFS");
     if (!stateMap.empty())
     {
-        const size_t ARR_SIZE = stateMap.crbegin()->first + 1;
+        const auto ARR_SIZE = stateMap.crbegin()->first + 1;
         out <<"\n"
               "constinit const C_" <<m_Prefix <<"Scanner::C_StateRec STATES[" <<ARR_SIZE <<"] = {\n";
         int stopState = 0;
@@ -378,7 +375,7 @@ void C_Output::writeCpp(std::ostream &out, const std::string &base) const
             const auto val0 = std::get<0>(i.second);
             const auto val2 = std::get<2>(i.second);
             out <<"    { " <<(val0.empty()?"nullptr":val0) <<",\t" <<(val2.empty()?"nullptr":val2)
-                <<(i.first + 1U < ARR_SIZE? "\t},  ": "\t}}; ") <<"// " <<(stopState++) <<'\n';
+                <<(i.first + 1 < ARR_SIZE? "\t},  ": "\t}}; ") <<"// " <<(stopState++) <<'\n';
         }
         out <<"\n"
               "constinit const " <<m_Limits.inputType() <<" GOTO_SIZE[" <<ARR_SIZE <<"] = {\n";
@@ -389,7 +386,7 @@ void C_Output::writeCpp(std::ostream &out, const std::string &base) const
                 out <<"    0,\t// " <<(stopState++) <<'\n';
 
             out <<"    " <<std::get<1>(i.second)
-                <<(i.first + 1U < ARR_SIZE? ",": "};") <<"\t// " <<(stopState++) <<'\n';
+                <<(i.first + 1 < ARR_SIZE? ",": "};") <<"\t// " <<(stopState++) <<'\n';
         }
     }
     if (!firstFits.empty())
@@ -464,13 +461,13 @@ void C_Output::writeUserSection(std::ostream &out, const char *optionKey) const
     if (m_context.getOptionString(optionKey, value))
     {
         out <<"// Token-def %" <<optionKey <<" begins\n";
-        bool first =true;
+        bool first = true;
         for (const auto &i: value)
             if (i != '\r')
             {
                 if (first)
                 {
-                    first =false;
+                    first = false;
                     if (i == '\n')
                         continue;
                 }
@@ -542,7 +539,7 @@ void FC_GetLimits::operator()(int state, const C_LexSet &inputs, int)
     for (auto i: inputs)
     {
         if (i.first < m_InputMin)
-            m_InputMin =i.first;
+            m_InputMin = i.first;
         if (i.second > m_InputMax && i.second != std::numeric_limits<bux::T_LexID>::max())
             m_InputMax =i.second;
     }
diff --git a/example/BisonGLR/CMakeLists.txt b/example/BisonGLR/CMakeLists.txt
diff --git a/example/CalcInt/CMakeLists.txt b/example/CalcInt/CMakeLists.txt
diff --git a/example/MinLang/CMakeLists.txt b/example/MinLang/CMakeLists.txt
diff --git a/test/archlinux/aur_poc/CMakeLists.txt b/test/archlinux/aur_poc/CMakeLists.txt

Original file line number	Diff line number	Diff line change
`@@ -436,7 +436,7 @@ void C_BNFContext::wrapup(const bux::C_SourcePos &pos)`
`436`	`436`	`{`
`437`	`437`	`auto out = fmt::format(FMT_STRING("Duplicate priority assignments on id {}"), id);`
`438`	`438`	`if (id < 127)`
`439`		`- out += fmt::format("(\'{}\')", asciiLiteral(char(id)));`
	`439`	`+ out += fmt::format("(\'{}\')", asciiLiteral(id));`
`440`	`440`	`log(LL_ERROR, pos, out);`
`441`	`441`	`}`
`442`	`442`	`break;`
Original file line number	Diff line number	Diff line change
`@@ -265,7 +265,7 @@ void FC_CreateClosure::operator()(C_StateItems &dst) const`
`265`	`265`	`changed = true;`
`266`	`266`
`267`	`267`	`const auto n =la.size();`
`268`		`- for (auto k = seq.begin()+item.second; ++k != seq.end();)`
	`268`	`+ for (auto k = seq.begin()+std::ptrdiff_t(item.second); ++k != seq.end();)`
`269`	`269`	`if (auto const nt = dynamic_cast<C_Nonterminal>(k))`
`270`	`270`	`{`
`271`	`271`	`auto &attrs =getAttr(nt->m_id);`
`@@ -433,8 +433,8 @@ FC_LessGotoKey::FC_LessGotoKey(const C_ParserInfo &parsed): m_LessTerm(parsed)`
`433`	`433`
`434`	`434`	`bool FC_LessGotoKey::operator()(const C_GotoKey &a, const C_GotoKey &b) const`
`435`	`435`	`{`
`436`		`- return a.first->m_id < b.first->m_id \|\|`
`437`		`- a.first->m_id == b.first->m_id && m_LessTerm(a.second,b.second);`
	`436`	`+ return a.first->m_id < b.first->m_id \|\| (`
	`437`	`+ a.first->m_id == b.first->m_id && m_LessTerm(a.second,b.second));`
`438`	`438`	`}`
`439`	`439`
`440`	`440`	`C_GotoMap::C_GotoMap(const C_ParserInfo &parsed):`
Original file line number	Diff line number	Diff line change
`@@ -566,7 +566,7 @@ void _reduce_1(bux::LR1::C_Parser &_paRSeR_, const F_GetProduced &_geT_, C_RetLv`
`566`	`566`
`567`	`567`	`if (auto targs = bux::tryUnlex<C_TemplateArgs>(_geT_(2)))`
`568`	`568`	`{`
`569`		`- if (auto err = c.setClassName(bux::unlex<C_StringList>(_geT_(1)), *targs)) [[unlikely]]`
	`569`	`+ if (auto err = c.setClassName(bux::unlex<C_StringList>(_geT_(1)), *targs))`
`570`	`570`	`_paRSeR_.onError(_geT_(0), *err);`
`571`	`571`	`}`
`572`	`572`	`else`
`@@ -609,7 +609,7 @@ void _reduce_4(bux::LR1::C_Parser &_paRSeR_, const F_GetProduced &_geT_, C_RetLv`
`609`	`609`	`return;`
`610`	`610`
`611`	`611`	`auto &prod = dynamic_cast<C_Production&>(*_geT_(0));`
`612`		`- if (!c.addProduction(prod, bux::tryUnlex<C_Semantic>(_geT_(1)))) [[unlikely]]`
	`612`	`+ if (!c.addProduction(prod, bux::tryUnlex<C_Semantic>(_geT_(1))))`
`613`	`613`	`_paRSeR_.onError(_geT_(0), "Production re-defined:\n"`
`614`	`614`	`"\t" + prod.str());`
`615`	`615`	`}`
`@@ -1148,9 +1148,9 @@ bux::T_StateID C_ParserPolicy::nextState(bux::T_StateID state, bux::T_LexID inpu`
`1148`	`1148`	`bool C_ParserPolicy::changeToken(T_LexID &token, C_LexPtr &attr) const`
`1149`	`1149`	`{`
`1150`	`1150`	`// Grammar %UPCAST_TOKEN begins`
`1151`		`- if (isascii(token) && !iscntrl(token) && !isalnum(token) && !isspace(token))`
	`1151`	`+ if (const auto it = int(token); isascii(it) && !iscntrl(it) && !isalnum(it) && !isspace(it))`
`1152`	`1152`	`{`
`1153`		`- attr.assign(bux::createLex<std::string>(1,char(token)), true);`
	`1153`	`+ attr.assign(bux::createLex<std::string>(1u,char(token)), true);`
`1154`	`1154`	`token = TID_LEX_Operator;`
`1155`	`1155`	`return true;`
`1156`	`1156`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ bool getNonterminalID(const std::string &str, std::string &dst)`
`29`	`29`	`bool isKeyword(const std::string &str)`
`30`	`30`	`{`
`31`	`31`	`for (auto c: str)`
`32`		`- if (!isascii(c) \|\| c != '_' && !isalnum(c))`
	`32`	`+ if (!isascii(c) \|\| (c != '_' && !isalnum(c)))`
`33`	`33`	`return false;`
`34`	`34`
`35`	`35`	`return true;`
`@@ -38,16 +38,15 @@ bool isKeyword(const std::string &str)`
`38`	`38`	`std::string literalSuffix(const std::string &s)`
`39`	`39`	`{`
`40`	`40`	`std::string ret;`
`41`		`- for (auto i =s.begin(); i != s.end(); ++i)`
	`41`	`+ for (auto c: s)`
`42`	`42`	`{`
`43`		`- unsigned char c =*i;`
`44`	`43`	`if (isascii(c) && isalnum(c))`
`45`	`44`	`{`
`46`		`- ret +=c;`
`47`		`- ret +='_';`
	`45`	`+ ret += c;`
	`46`	`+ ret += '_';`
`48`	`47`	`}`
`49`	`48`	`else`
`50`		`- bux::addAsHex(ret, c);`
	`49`	`+ bux::addAsHex(ret, (uint8_t)c);`
`51`	`50`	`}`
`52`	`51`	`return ret;`
`53`	`52`	`}`
`@@ -238,7 +237,7 @@ std::string C_ParserInfo::outputId(const I_ProductionTerm *term) const`
`238`	`237`	`idstr.assign("TID_LEX_").append(lex->m_Var);`
`239`	`238`	`}`
`240`	`239`	`else if (auto const slex =dynamic_cast<const C_StrLiteral*>(term))`
`241`		`- return std::string(1,'\'').append(asciiLiteral(slex->m_Str[0])).append(1,'\'');`
	`240`	`+ return std::string(1u,'\'').append(asciiLiteral(uint8_t(slex->m_Str[0]))).append(1u,'\'');`
`242`	`241`	`else`
`243`	`242`	`RUNTIME_ERROR("{}Fail to produce output id for {}", idstr, HRTN(*term));`
`244`	`243`
Original file line number	Diff line number	Diff line change
`@@ -5,9 +5,9 @@`
`5`	`5`	`]]`
`6`	`6`
`7`	`7`	`%UPCAST_TOKEN [[`
`8`		`- if (isascii($token) && !iscntrl($token) && !isalnum($token) && !isspace($token))`
	`8`	`+ if (const auto it = int($token); isascii(it) && !iscntrl(it) && !isalnum(it) && !isspace(it))`
`9`	`9`	`{`
`10`		`- $attr.assign(bux::createLex<std::string>(1,char($token)), true);`
	`10`	`+ $attr.assign(bux::createLex<std::string>(1u,char($token)), true);`
`11`	`11`	`$token = TID_LEX_Operator;`
`12`	`12`	`return true;`
`13`	`13`	`}`