More work on moving engine into dlmalloc heap

luprex/core/cpp/driver-common.cpp

@@ -2,8 +2,8 @@
 #define CHBUF_SIZE (256*1024)
 #define POLLVEC_SIZE (DrivenEngine::MAX_CHAN+1)
 
-static drv::unique_ptr<char[]> chbuf;
-static drv::unique_ptr<struct pollfd[]> pollvec;
+static std::unique_ptr<char[]> chbuf;
+static std::unique_ptr<struct pollfd[]> pollvec;
 
 static MonoClock monoclock;
 
@@ -13,45 +13,33 @@ namespace util {
     }
 }
 
-static void initialize_engine() {
-    SourceDB::register_lua_builtins();
-    DrivenEngine::register_maker("textgame", make_TextGame);
-    DrivenEngine::register_maker("lpxclient", make_LpxClient);
-    DrivenEngine::register_maker("lpxserver", make_LpxServer);
-    DrivenEngine::register_maker("driverstubtest", make_DriverStubTest);
-    DrivenEngine::register_maker("driverwebservertest", make_DriverWebServerTest);
-    DrivenEngine::register_maker("driverdnsfailtest", make_DriverDNSFailTest);
-    DrivenEngine::register_maker("driverprintclocktest", make_DriverPrintClockTest);
-    DrivenEngine::register_maker("unittest", make_RunUnitTests);
-}
-
 static void allocate_buffers() {
     chbuf.reset(new char[CHBUF_SIZE]);
     pollvec.reset(new struct pollfd[POLLVEC_SIZE]);
 }    
 
-static void if_error_print_and_exit(const drv::string &str) {
+static void if_error_print_and_exit(const std::string &str) {
     if (!str.empty()) {
         std::cerr << std::endl << "error: " << str << std::endl;
         exit(1);
     }
 }
 
-static std::string_view read_file(const char *fn, char *buf, int bufsize, drv::string &err) {
+static std::string_view read_file(const char *fn, char *buf, int bufsize, std::string &err) {
     FILE *f = fopen(fn, "r");
     if (f == 0) {
-        err = drv::string("cannot read file") + fn;
+        err = std::string("cannot read file") + fn;
         buf[0] = 0;
         return std::string_view(buf, 0);        
     }
     int nread = fread(buf, 1, bufsize, f);
     if (nread < 0) {
-        err = drv::string("cannot read file: ") + fn;
+        err = std::string("cannot read file: ") + fn;
         buf[0] = 0;
         return std::string_view(buf, 0);
     }
     if (nread == bufsize) {
-        err = drv::string("file too large: ") + fn;
+        err = std::string("file too large: ") + fn;
         buf[0] = 0;
         return std::string_view(buf, 0);
     }
@@ -74,12 +62,12 @@ static SSL_CTX *new_ssl_context(bool server_cert, bool root_certs, std::string_v
     return ctx;
 }
 
-static drv::string err_print_errors_str() {
+static std::string err_print_errors_str() {
     BIO *bio = BIO_new(BIO_s_mem());
     ERR_print_errors(bio);
     char *buf;
     size_t len = BIO_get_mem_data(bio, &buf);
-    drv::string ret(buf, len);
+    std::string ret(buf, len);
     BIO_free(bio);
     return ret;
 }
@@ -133,8 +121,8 @@ public:
     };
 
     DrivenEngine *driven_;
-    drv::vector<ChanInfo> chans_;
-    drv::map<int, SOCKET> listen_sockets_;
+    std::vector<ChanInfo> chans_;
+    std::map<int, SOCKET> listen_sockets_;
     bool read_console_recently_;
 
     SSL_CTX *ssl_ctx_with_root_certs_;
@@ -146,7 +134,7 @@ public:
         const auto &listenports = driven_->drv_get_listen_ports();
         for (int port : listenports) {
             if (listen_sockets_.find(port) == listen_sockets_.end()) {
-                drv::string err;
+                std::string err;
                 SOCKET sock = listen_on_port(port, err);
                 if_error_print_and_exit(err);
                 assert(sock != INVALID_SOCKET);
@@ -157,13 +145,13 @@ public:
 
     void handle_lua_source() {
         if (driven_->drv_get_rescan_lua_source()) {
-            drv::string err;
+            std::string err;
             std::string_view ctrl = read_file("lua/control.lst", chbuf.get(), CHBUF_SIZE, err);
             if_error_print_and_exit(err);
-            drv::vector<drv::string> names = drv::parse_control_lst(ctrl);
+            std::vector<std::string> names = drv::parse_control_lst(ctrl);
             driven_->drv_clear_lua_source();
-            for (const drv::string &str : names) {
-                drv::string lfn = drv::string("lua/") + str;
+            for (const std::string &str : names) {
+                std::string lfn = std::string("lua/") + str;
                 std::string_view data = read_file(lfn.c_str(), chbuf.get(), CHBUF_SIZE, err);
                 if_error_print_and_exit(err);
                 driven_->drv_add_lua_source(str, data);
@@ -255,7 +243,7 @@ public:
     void handle_new_outgoing_sockets() {
         const auto &chans = driven_->drv_get_new_outgoing();
         for (int chid : chans) {
-            drv::string err;
+            std::string err;
             SOCKET sock = open_connection(driven_->drv_get_target(chid), err);
             if (sock == INVALID_SOCKET) {
                 driven_->drv_notify_close(chid, err);
@@ -270,7 +258,7 @@ public:
     }
 
     void accept_connection(int port, SOCKET sock) {
-        drv::string err;
+        std::string err;
         SOCKET socket = accept_on_socket(sock, err);
         if_error_print_and_exit(err);
         if (socket != INVALID_SOCKET) {
@@ -281,7 +269,7 @@ public:
     }
 
     void advance_plaintext(ChanInfo &chan) {
-        drv::string err;
+        std::string err;
 
         // If the channel has no outgoing bytes and has been released,
         // just close it.
@@ -418,7 +406,7 @@ public:
 
 
     void handle_socket_input_output() {
-        drv::string err;
+        std::string err;
         int mstimeout = read_console_recently_ ? 100 : 1000;
 
         // Peek output buffers and determine channel release flags.