Print utility extension

onnx/cpp2py_export.cc

@@ -12,6 +12,7 @@
 #include "onnx/checker.h"
 #include "onnx/defs/function.h"
 #include "onnx/defs/parser.h"
+#include "onnx/defs/printer.h"
 #include "onnx/defs/schema.h"
 #include "onnx/py_utils.h"
 #include "onnx/shape_inference/implementation.h"
@@ -31,6 +32,13 @@ static std::tuple<bool, py::bytes, py::bytes> Parse(const char* cstr) {
   return std::make_tuple(status.IsOK(), py::bytes(status.ErrorMessage()), py::bytes(out));
 }
 
+template <typename ProtoType>
+static std::string ProtoBytesToText(const py::bytes& bytes) {
+  ProtoType proto{};
+  ParseProtoFromPyBytes(&proto, bytes);
+  return ProtoToString(proto);
+}
+
 PYBIND11_MODULE(onnx_cpp2py_export, onnx_cpp2py_export) {
   onnx_cpp2py_export.doc() = "Python interface to onnx";
 
@@ -308,6 +316,15 @@ PYBIND11_MODULE(onnx_cpp2py_export, onnx_cpp2py_export) {
 
   parser.def("parse_model", Parse<ModelProto>);
   parser.def("parse_graph", Parse<GraphProto>);
+  parser.def("parse_function", Parse<FunctionProto>);
+
+  // Submodule `printer`
+  auto printer = onnx_cpp2py_export.def_submodule("printer");
+  printer.doc() = "Printer submodule";
+
+  printer.def("model_to_text", ProtoBytesToText<ModelProto>);
+  printer.def("function_to_text", ProtoBytesToText<FunctionProto>);
+  printer.def("graph_to_text", ProtoBytesToText<GraphProto>);
 }
 
 } // namespace ONNX_NAMESPACE

onnx/defs/parser.cc

@@ -20,6 +20,69 @@
 
 namespace ONNX_NAMESPACE {
 
+Status ParserBase::Parse(Literal& result) {
+  bool decimal_point = false;
+  auto nextch = NextChar();
+  auto from = next_;
+  if (nextch == '"') {
+    ++next_;
+    bool has_escape = false;
+    while ((next_ < end_) && (*next_ != '"')) {
+      if (*next_ == '\\') {
+        has_escape = true;
+        ++next_;
+        if (next_ >= end_)
+          return ParseError("Incomplete string literal.");
+      }
+      ++next_;
+    }
+    if (next_ >= end_)
+      return ParseError("Incomplete string literal.");
+    ++next_;
+    result.type = LiteralType::STRING_LITERAL;
+    if (has_escape) {
+      std::string& target = result.value;
+      target.clear();
+      target.reserve(next_ - from - 2); // upper bound
+      // *from is the starting quote. *(next_-1) is the ending quote.
+      // Copy what is in-between, except for the escape character
+      while (++from < next_ - 1) {
+        // Copy current char, if not escape, or next char otherwise.
+        target.push_back(*from != '\\' ? (*from) : *(++from));
+      }
+    } else
+      result.value = std::string(from + 1, next_ - from - 2); // skip enclosing quotes
+  } else if ((isdigit(nextch) || (nextch == '-'))) {
+    ++next_;
+
+    while ((next_ < end_) && (isdigit(*next_) || (*next_ == '.'))) {
+      if (*next_ == '.') {
+        if (decimal_point)
+          break; // Only one decimal point allowed in numeric literal
+        decimal_point = true;
+      }
+      ++next_;
+    }
+
+    if (next_ == from)
+      return ParseError("Value expected but not found.");
+
+    // Optional exponent syntax: (e|E)(+|-)?[0-9]+
+    if ((next_ < end_) && ((*next_ == 'e') || (*next_ == 'E'))) {
+      decimal_point = true; // treat as float-literal
+      ++next_;
+      if ((next_ < end_) && ((*next_ == '+') || (*next_ == '-')))
+        ++next_;
+      while ((next_ < end_) && (isdigit(*next_)))
+        ++next_;
+    }
+
+    result.value = std::string(from, next_ - from);
+    result.type = decimal_point ? LiteralType::FLOAT_LITERAL : LiteralType::INT_LITERAL;
+  }
+  return Status::OK();
+}
+
 Status OnnxParser::Parse(IdList& idlist) {
   idlist.Clear();
   std::string id;
@@ -348,6 +411,7 @@ Status OnnxParser::ParseSingleAttributeValue(AttributeProto& attr) {
 }
 
 Status OnnxParser::Parse(AttributeProto& attr) {
+  attr.Clear();
   std::string name;
   CHECK_PARSER_STATUS(ParseIdentifier(name));
   attr.set_name(name);

onnx/defs/parser.h

@@ -160,6 +160,15 @@ class KeyWordMap {
     return KeyWord::NONE;
   }
 
+  static const std::string& ToString(KeyWord kw) {
+    static std::string undefined("undefined");
+    for (const auto& pair : Instance()) {
+      if (pair.second == kw)
+        return pair.first;
+    }
+    return undefined;
+  }
+
  private:
   std::unordered_map<std::string, KeyWord> map_;
 };
@@ -263,49 +272,7 @@ class ParserBase {
     std::string value;
   };
 
-  Status Parse(Literal& result) {
-    bool decimal_point = false;
-    auto nextch = NextChar();
-    auto from = next_;
-    if (nextch == '"') {
-      ++next_;
-      // TODO: Handle escape characters
-      while ((next_ < end_) && (*next_ != '"')) {
-        ++next_;
-      }
-      ++next_;
-      result.type = LiteralType::STRING_LITERAL;
-      result.value = std::string(from + 1, next_ - from - 2); // skip enclosing quotes
-    } else if ((isdigit(nextch) || (nextch == '-'))) {
-      ++next_;
-
-      while ((next_ < end_) && (isdigit(*next_) || (*next_ == '.'))) {
-        if (*next_ == '.') {
-          if (decimal_point)
-            break; // Only one decimal point allowed in numeric literal
-          decimal_point = true;
-        }
-        ++next_;
-      }
-
-      if (next_ == from)
-        return ParseError("Value expected but not found.");
-
-      // Optional exponent syntax: (e|E)(+|-)?[0-9]+
-      if ((next_ < end_) && ((*next_ == 'e') || (*next_ == 'E'))) {
-        decimal_point = true; // treat as float-literal
-        ++next_;
-        if ((next_ < end_) && ((*next_ == '+') || (*next_ == '-')))
-          ++next_;
-        while ((next_ < end_) && (isdigit(*next_)))
-          ++next_;
-      }
-
-      result.value = std::string(from, next_ - from);
-      result.type = decimal_point ? LiteralType::FLOAT_LITERAL : LiteralType::INT_LITERAL;
-    }
-    return Status::OK();
-  }
+  Status Parse(Literal& result);
 
   Status Parse(int64_t& val) {
     Literal literal;