No Arduino.h

examples/debug/debug.ino

@@ -39,8 +39,8 @@ void dump_stack(rpn_context & ctxt) {
 
 void dump_variables(rpn_context & ctxt) {
     Serial.printf("Variables\n--------------------\n");
-    rpn_variables_foreach(ctxt, [](const String& name, const rpn_value& value) {
-        Serial.printf("$%s = %.2f\n", name.c_str(), value.toFloat());
+    rpn_variables_foreach(ctxt, [](const char* name, const rpn_value& value) {
+        Serial.printf("$%s = %.2f\n", name, value.toFloat());
     });
 
     Serial.println();
@@ -85,7 +85,7 @@ void setup() {
     // Last parameter in rpn_process forces variable check,
     // the execution will fail if the variable does not exist
     if (!rpn_process(ctxt, "$temperatue 18 21 cmp3 1 + 1 $relay 0 3 index", true)) {
-        rpn_handle_error(ctxt.error, rpn_decode_errors([](const String& decoded) {
+        rpn_handle_error(ctxt.error, rpn_decode_errors([](const char* decoded) {
             Serial.println("rpn_process stopped after an error: ");
             Serial.println(decoded);
         }));

examples/host/repl.cpp

@@ -19,55 +19,28 @@ const char* stack_type(rpn_stack_value::Type type) {
     }
 }
 
-void dump_value(const rpn_value& val) {
-    switch (val.type) {
-        case rpn_value::Type::Boolean:
-            std::cout << (val.toBoolean() ? "true" : "false") << " (Boolean) ";
-            break;
-        case rpn_value::Type::Integer:
-            std::cout << val.toInt() << " (Integer) ";
-            break;
-        case rpn_value::Type::Unsigned:
-            std::cout << val.toUint() << " (Unsigned) ";
-            break;
-        case rpn_value::Type::Float:
-            std::cout << val.toFloat() << " (Float) ";
-            break;
-        case rpn_value::Type::String:
-            std::cout << val.toString().c_str() << " (String) ";
-            break;
-        case rpn_value::Type::Error:
-            std::cout << "error ";
-            break;
-        case rpn_value::Type::Null:
-            std::cout << "null ";
-            break;
-    }
-}
-
 void dump_variables(rpn_context & ctxt) {
-    rpn_variables_foreach(ctxt, [](const String& name, rpn_value& value) {
-        std::cout << "$" << name.c_str() << " is ";
-        dump_value(value);
-        std::cout << std::endl;
+    rpn_variables_foreach(ctxt, [](const char* name, rpn_value& value) {
+        std::cout << "$" << name << " is ";
+        std::cout << value.toString() << std::endl;
     });
 }
 
 void dump_stack(rpn_context & ctxt) {
     size_t index = rpn_stack_size(ctxt);
     rpn_stack_foreach(ctxt, [&index](rpn_stack_value::Type type, const rpn_value& value) {
         std::cout << std::setfill('0') << std::setw(3) << --index << ": ";
-        dump_value(value);
+        std::cout << value.toString();
         std::cout << " (" << stack_type(type) << ")" << std::endl;
     });
     std::cout << std::endl;
 }
 
 void dump_operators(rpn_context & ctxt) {
     size_t index = 0;
-    rpn_operators_foreach(ctxt, [&index](const String& name, size_t argc, rpn_operator::callback_type) {
+    rpn_operators_foreach(ctxt, [&index](const char* name, size_t argc, rpn_operator::callback_type) {
         std::cout << std::setfill('0') << std::setw(3) << ++index << ": ";
-        std::cout << name.c_str() << "(...), " << argc << std::endl;
+        std::cout << name << "(...), " << argc << std::endl;
     });
 }
 
@@ -151,14 +124,14 @@ int main(int argc, char** argv) {
             break;
         }
         if (!rpn_process(ctxt, input.c_str())) {
-            auto handler = [&ctxt](const String& decoded) {
+            auto handler = [&ctxt](const char* decoded) {
                 auto pos = ctxt.error.position;
                 std::cout << "    ";
                 while (--pos) {
                     std::cout << ' ';
                 }
                 std::cout << "^\n";
-                std::cout << "ERR: " << decoded.c_str() << std::endl;
+                std::cout << "ERR: " << decoded << std::endl;
             };
             rpn_handle_error(ctxt.error, rpn_decode_errors(handler));
         }

examples/time/time.ino

@@ -26,6 +26,10 @@ along with the rpnlib library.  If not, see <http://www.gnu.org/licenses/>.
 #include <sys/time.h>
 #include <rpnlib.h>
 
+// time_t value on ESP8266 could be either 4 or 8 bytes, but it might not always be able to fit into rpn_int
+// (but, it is possible to tweak time funcs to accept time_t as LOW and HIGH parts, requiring special operators to handle such values)
+static_assert(sizeof(rpn_int) >= sizeof(time_t), "time_t should be able to fit into a single rpn_value");
+
 void dump_stack(rpn_context & ctxt) {
     rpn_value value;
     auto index = rpn_stack_size(ctxt) - 1;
@@ -115,11 +119,11 @@ void setup() {
         return 0;
     });
 
-    rpn_variable_set(ctxt, F("time"),
+    rpn_variable_set(ctxt, "time",
         rpn_value(static_cast<rpn_int>(time(nullptr)))
     );
 
-    rpn_variables_foreach(ctxt, [](const String& name, const rpn_value& value) {
+    rpn_variables_foreach(ctxt, [](const char* name, const rpn_value& value) {
         Serial.println(name);
         Serial.println(value.toInt());
     });

src/rpnlib.cpp

@@ -127,8 +127,8 @@ rpn_input_buffer& rpn_input_buffer::write(const char* data, size_t data_length)
     return *this;
 }
 
-bool rpn_input_buffer::operator==(const String& other) const {
-    return other.equals(_buffer);
+bool rpn_input_buffer::operator==(const std::string& other) const {
+    return other == _buffer;
 }
 
 void rpn_input_buffer::reset() {

src/rpnlib.h

@@ -23,8 +23,6 @@ along with the rpnlib library.  If not, see <http://www.gnu.org/licenses/>.
 #ifndef rpnlib_h
 #define rpnlib_h
 
-#include <Arduino.h>
-
 #include "rpnlib_config.h"
 #include "rpnlib_error.h"
 
@@ -62,7 +60,7 @@ struct rpn_input_buffer {
 
     const char* c_str() const;
     size_t length() const;
-    bool operator==(const String& other) const;
+    bool operator==(const std::string& other) const;
 
     rpn_input_buffer& operator+=(char c);
     rpn_input_buffer& write(const char* data, size_t data_length);

src/rpnlib_config.h

@@ -21,6 +21,8 @@ along with the rpnlib library.  If not, see <http://www.gnu.org/licenses/>.
 
 #pragma once
 
+#include <cstdint>
+
 #ifndef RPNLIB_INT_TYPE
 #define RPNLIB_INT_TYPE int32_t
 #endif

src/rpnlib_error.h

@@ -22,6 +22,8 @@ along with the rpnlib library.  If not, see <http://www.gnu.org/licenses/>.
 
 #pragma once
 
+#include <cstddef>
+
 enum class rpn_error_category {
     Unknown,
     Processing,

src/rpnlib_operators.cpp

@@ -28,8 +28,6 @@ extern "C" {
     #include "fs_math.h"
 }
 
-#include "rpnlib_compat.h"
-
 #include <cmath>
 #include <cstdlib>
 #include <algorithm>
@@ -239,8 +237,8 @@ rpn_error _rpn_abs(rpn_context & ctxt) {
     }
 
     rpn_value result =
-        (top.isFloat()) ? rpn_value(rpnlib_abs(top.toFloat())) :
-        (top.isInt()) ? rpn_value(rpnlib_abs(top.toInt())) :
+        (top.isFloat()) ? rpn_value(std::abs(top.toFloat())) :
+        (top.isInt()) ? rpn_value(std::abs(top.toInt())) :
         (rpn_value{});
 
     _rpn_stack_eat(ctxt, 1);
@@ -392,7 +390,7 @@ rpn_error _rpn_index(rpn_context & ctxt) {
         return conversion.error();
     }
 
-    auto offset = rpnlib_round(conversion.value());
+    auto offset = std::round(conversion.value());
     if (offset >= 0.) {
         if ((offset + 1) > size) {
             return rpn_operator_error::InvalidArgument;
@@ -539,7 +537,7 @@ rpn_error _rpn_round(rpn_context & ctxt) {
         return conversion.error();
     }
 
-    rpn_float limit = rpnlib_round(conversion.value());
+    rpn_float limit = std::round(conversion.value());
     rpn_float multiplier = 1.0;
     for (int i = 0; i < limit; ++i) {
         multiplier *= 10.0;
@@ -742,12 +740,6 @@ rpn_error _rpn_assign(rpn_context & ctxt) {
 // Functions methods
 // ----------------------------------------------------------------------------
 
-rpn_operator::rpn_operator(const char* name, unsigned char argc, callback_type callback) :
-    name(name),
-    argc(argc),
-    callback(callback)
-{}
-
 bool rpn_operator_set(rpn_context & ctxt, const char * name, unsigned char argc, rpn_operator::callback_type callback) {
     ctxt.operators.emplace_front(name, argc, callback);
     return true;

src/rpnlib_operators.h

@@ -28,16 +28,18 @@ struct rpn_operator {
     using callback_type = rpn_error(*)(rpn_context &);
 
     rpn_operator() = delete;
-    rpn_operator(const char*, unsigned char, callback_type);
 
-    rpn_operator(const rpn_operator&) = default;
-    rpn_operator(rpn_operator&& other) noexcept :
-        name(std::move(other.name)),
-        argc(other.argc),
-        callback(other.callback)
+    template <typename T>
+    rpn_operator(T&& name_, unsigned char argc_, callback_type callback_) :
+        name(std::forward<T>(name_)),
+        argc(argc_),
+        callback(callback_)
     {}
 
-    String name;
+    rpn_operator(const rpn_operator&) = default;
+    rpn_operator(rpn_operator&& other) noexcept = default;
+
+    std::string name;
     unsigned char argc;
     callback_type callback;
 };

src/rpnlib_util.h

@@ -22,6 +22,8 @@ along with the rpnlib library.  If not, see <http://www.gnu.org/licenses/>.
 #pragma once
 
 #include "rpnlib.h"
+
+#include <cstdio>
 #include <utility>
 
 template <typename Callback>
@@ -35,14 +37,14 @@ void rpn_stack_foreach(rpn_context & ctxt, Callback callback) {
 template <typename Callback>
 void rpn_variables_foreach(rpn_context & ctxt, Callback callback) {
     for (auto& var : ctxt.variables) {
-        callback(var.name, *(var.value.get()));
+        callback(var.name.c_str(), *(var.value.get()));
     }
 }
 
 template <typename Callback>
 void rpn_operators_foreach(rpn_context & ctxt, Callback callback) {
     for (auto& op : ctxt.operators) {
-        callback(op.name, op.argc, op.callback);
+        callback(op.name.c_str(), op.argc, op.callback);
     }
 }
 
@@ -65,7 +67,6 @@ void rpn_handle_error(const rpn_error& error, Visitor&& visitor) {
 
 template <typename Callback>
 struct rpn_error_decoder {
-
     rpn_error_decoder(Callback&& callback) :
         callback(callback)
     {}
@@ -152,11 +153,12 @@ struct rpn_error_decoder {
     }
 
     void operator()(int code) {
-        callback(String("Unknown error #") + String(code));
+        char buffer[33];
+        snprintf(buffer, sizeof(buffer), "Unknown error #%d", code);
+        callback(buffer);
     }
 
     Callback callback;
-
 };
 
 template <typename Callback>