~2s build time

opendbc/can/dbc.cc

@@ -2,7 +2,7 @@
 #include <filesystem>
 #include <fstream>
 #include <map>
-#include <regex>
+#include <re2/re2.h>
 #include <set>
 #include <sstream>
 #include <vector>
@@ -14,11 +14,11 @@
 #include "opendbc/can/common.h"
 #include "opendbc/can/common_dbc.h"
 
-std::regex bo_regexp(R"(^BO_ (\w+) (\w+) *: (\w+) (\w+))");
-std::regex sg_regexp(R"(^SG_ (\w+) : (\d+)\|(\d+)@(\d+)([\+|\-]) \(([0-9.+\-eE]+),([0-9.+\-eE]+)\) \[([0-9.+\-eE]+)\|([0-9.+\-eE]+)\] \"(.*)\" (.*))");
-std::regex sgm_regexp(R"(^SG_ (\w+) (\w+) *: (\d+)\|(\d+)@(\d+)([\+|\-]) \(([0-9.+\-eE]+),([0-9.+\-eE]+)\) \[([0-9.+\-eE]+)\|([0-9.+\-eE]+)\] \"(.*)\" (.*))");
-std::regex val_regexp(R"(VAL_ (\w+) (\w+) (\s*[-+]?[0-9]+\s+\".+?\"[^;]*))");
-std::regex val_split_regexp{R"([\"]+)"};  // split on "
+RE2 bo_regexp(R"(^BO_ (\w+) (\w+) *: (\w+) (\w+))");
+RE2 sg_regexp(R"(^SG_ (\w+) : (\d+)\|(\d+)@(\d+)([\+|\-]) \(([0-9.+\-eE]+),([0-9.+\-eE]+)\) \[([0-9.+\-eE]+)\|([0-9.+\-eE]+)\] \"(.*)\" (.*))");
+RE2 sgm_regexp(R"(^SG_ (\w+) (\w+) *: (\d+)\|(\d+)@(\d+)([\+|\-]) \(([0-9.+\-eE]+),([0-9.+\-eE]+)\) \[([0-9.+\-eE]+)\|([0-9.+\-eE]+)\] \"(.*)\" (.*))");
+RE2 val_regexp(R"(VAL_ (\w+) (\w+) (.*))");
+RE2 val_split_regexp(R"((([0-9]) \"(.+?)\"))");
 
 #define DBC_ASSERT(condition, message)                             \
   do {                                                             \
@@ -121,20 +121,20 @@ DBC* dbc_parse_from_stream(const std::string &dbc_name, std::istream &stream, Ch
 
   std::string line;
   int line_num = 0;
-  std::smatch match;
+  std::string match1, match2, match3, match4, match5, match6, match7, ignore;
   // TODO: see if we can speed up the regex statements in this loop, SG_ is specifically the slowest
   while (std::getline(stream, line)) {
     line = trim(line);
     line_num += 1;
     if (startswith(line, "BO_ ")) {
       // new group
-      bool ret = std::regex_match(line, match, bo_regexp);
+      bool ret = RE2::FullMatch(line, bo_regexp, &match1, &match2, &match3);
       DBC_ASSERT(ret, "bad BO: " << line);
 
       Msg& msg = dbc->msgs.emplace_back();
-      address = msg.address = std::stoul(match[1].str());  // could be hex
-      msg.name = match[2].str();
-      msg.size = std::stoul(match[3].str());
+      address = msg.address = std::stoul(match1);  // could be hex
+      msg.name = match2;
+      msg.size = std::stoul(match3);
 
       // check for duplicates
       DBC_ASSERT(address_set.find(address) == address_set.end(), "Duplicate message address: " << address << " (" << msg.name << ")");
@@ -146,20 +146,18 @@ DBC* dbc_parse_from_stream(const std::string &dbc_name, std::istream &stream, Ch
       }
     } else if (startswith(line, "SG_ ")) {
       // new signal
-      int offset = 0;
-      if (!std::regex_search(line, match, sg_regexp)) {
-        bool ret = std::regex_search(line, match, sgm_regexp);
+      if (!RE2::FullMatch(line, sg_regexp, &match1, &match2, &match3, &match4, &match5, &match6, &match7)) {
+        bool ret = RE2::FullMatch(line, sgm_regexp, &match1, &ignore, &match2, &match3, &match4, &match5, &match6, &match7);
         DBC_ASSERT(ret, "bad SG: " << line);
-        offset = 1;
       }
       Signal& sig = signals[address].emplace_back();
-      sig.name = match[1].str();
-      sig.start_bit = std::stoi(match[offset + 2].str());
-      sig.size = std::stoi(match[offset + 3].str());
-      sig.is_little_endian = std::stoi(match[offset + 4].str()) == 1;
-      sig.is_signed = match[offset + 5].str() == "-";
-      sig.factor = std::stod(match[offset + 6].str());
-      sig.offset = std::stod(match[offset + 7].str());
+      sig.name = match1;
+      sig.start_bit = std::stoi(match2);
+      sig.size = std::stoi(match3);
+      sig.is_little_endian = std::stoi(match4) == 1;
+      sig.is_signed = match5 == "-";
+      sig.factor = std::stod(match6);
+      sig.offset = std::stod(match7);
       set_signal_type(sig, checksum, dbc_name, line_num);
       if (sig.is_little_endian) {
         sig.lsb = sig.start_bit;
@@ -176,21 +174,23 @@ DBC* dbc_parse_from_stream(const std::string &dbc_name, std::istream &stream, Ch
       signal_name_sets[address].insert(sig.name);
     } else if (startswith(line, "VAL_ ")) {
       // new signal value/definition
-      bool ret = std::regex_search(line, match, val_regexp);
+      bool ret = RE2::FullMatch(line, val_regexp, &match1, &match2, &match3);
       DBC_ASSERT(ret, "bad VAL: " << line);
 
       auto& val = dbc->vals.emplace_back();
-      val.address = std::stoul(match[1].str());  // could be hex
-      val.name = match[2].str();
+      val.address = std::stoul(match1);  // could be hex
+      val.name = match2;
 
-      auto defvals = match[3].str();
-      std::sregex_token_iterator it{defvals.begin(), defvals.end(), val_split_regexp, -1};
+      auto defvals = match3;
       // convert strings to UPPER_CASE_WITH_UNDERSCORES
-      std::vector<std::string> words{it, {}};
-      for (auto& w : words) {
-        w = trim(w);
-        std::transform(w.begin(), w.end(), w.begin(), ::toupper);
-        std::replace(w.begin(), w.end(), ' ', '_');
+      std::vector<std::string> words;
+      std::string full_match, number, word;
+      while (RE2::PartialMatch(defvals, val_split_regexp, &full_match, &number, &word)) {
+        word = trim(word);
+        std::transform(word.begin(), word.end(), word.begin(), ::toupper);
+        std::replace(word.begin(), word.end(), ' ', '_');
+        words.push_back(number + " " + word);
+        defvals = defvals.substr(full_match.length(), defvals.length() - full_match.length());
       }
       // join string
       std::stringstream s;