From c0a50de92300080a1cf11bf4ff0ec3b2d6240c10 Mon Sep 17 00:00:00 2001 From: Josh Haberman Date: Tue, 21 Aug 2018 14:47:50 -0700 Subject: Removed a bunch of obsolete code. A lot of this code was experimental or temporarily useful, but is no longer needed. --- README.md | 100 ++------------------------------------------------------------ 1 file changed, 3 insertions(+), 97 deletions(-) (limited to 'README.md') diff --git a/README.md b/README.md index 3fb508c..36d1273 100644 --- a/README.md +++ b/README.md @@ -1,32 +1,10 @@ -# Unleaded - small, fast parsers for the 21st century +# μpb - a small protobuf implementation in C [![Build Status](https://travis-ci.org/google/upb.svg?branch=master)](https://travis-ci.org/google/upb) [![Coverage Status](https://img.shields.io/coveralls/google/upb.svg)](https://coveralls.io/r/google/upb?branch=master) -Unleaded is a library of fast parsers and serializers. These -parsers/serializers are written in C and use every available -avenue (particularly JIT compilation) to achieve the fastest -possible speed. However they are also extremely lightweight -(less than 100k of object code) and low-overhead. - -The library started as a Protocol Buffers library (upb originally -meant μpb: Micro Protocol Buffers). It still uses -protobuf-like schemas as a core abstraction, but **it has expanded -beyond just Protocol Buffers** to JSON, and other formats are -planned. - -The library itself is written in C, but very idiomatic APIs -are provided for C++ and popular dynamic languages such as -Lua. See the rest of this README for more information about -these bindings. - -Some parts of Unleaded are mature (most notably parsing of -Protocol Buffers) but others are still immature or nonexistent. -The core library abstractions are rapidly converging (this -is saying a lot; it was a long road of about 5 years to make -this happen), which should make it possible to begin building -out the encoders and decoders in earnest. +μpb is a small protobuf implementation written in C. API and ABI are both subject to change! Please do not distribute as a shared library for this reason (for now at least). @@ -47,88 +25,16 @@ Other useful targets: $ make tests $ make test -## How the library is organized - -Unleaded tries to stay very small, but also aims to support -lots of different formats. We reconcile these goals by -being *aggressively modular*. The source tree and the build -artifacts both reflect this organization: - -* **upb**: the core library of handlers and defs (schemas) -* **upb/pb**: encoders/decoders for Protocol Buffers -* **upb/json**: encoders/decoders for JSON -* **upb/descriptor**: building upb defs from protobuf desciptors - (ie. descriptor.proto) -* **upb/bindings/googlepb**: binding to the Google protobuf - library. -* **upb/bindings/lua**: binding to the Lua C API (Lua and LuaJIT). -* more to come! - ## C and C++ API The public C/C++ API is defined by all of the .h files in `upb/` except `.int.h` files (which are internal-only). -The `.h` files define both C and C++ APIs. Both languages -have 100% complete and first-class APIs. The C++ API is a -wrapper around the C API, but all of the wrapping is done in -inline methods in `.h` files, so there is no overhead to -this. - -For a more detailed description of the scheme we use to -provide both C and C++ APIs, see: -[CAndCPlusPlusAPI](https://github.com/google/upb/wiki/CAndCPlusPlusAPI). - -All of the code that is under `upb/` but *not* under -`upb/bindings/` forms the namespace of upb's cross-language -public API. For example, the code in upb/descriptor would -be exposed as follows: - - * **in C/C++:** `#include "upb/descriptor/X.h"` - * **in Lua:** `require "upb.descriptor"` - * **in Python:** `import upb.descriptor` - * etc. - -## Google protobuf bindings - -Unleaded supports integration with the -[Google protobuf library](https://github.com/google/protobuf). -These bindings let you: - -* convert protobuf schema objects (`Descriptor`, `FieldDescriptor`, etc). - to their Unleaded equivalents (`upb::MessageDef`, `upb::FieldDef`). -* use Unleaded parsers to populate protobuf generated classes. - Unleaded's parsers are much faster than protobuf's `DynamicMessage`. - If you are generating C++ with the protobuf compiler, then protobuf's - parsers are the same speed or a little faster than Unleaded in JIT - mode, but Unleaded will have smaller binaries because you don't - have to generate the code ahead of time. - -To build the Google protobuf integration you must have the protobuf -libraries already installed. Once they are installed run: - - $ make googlepb - -To test run: - - $ make googlepbtests - $ make test - ## Lua bindings -Lua bindings provide Unleaded's functionality to Lua programs. +Lua bindings provide μpb's functionality to Lua programs. The bindings target Lua 5.1, Lua 5.2, LuaJIT, and (soon) Lua 5.3. -Right now the Lua bindings support: - -* Building schema objects manually (eg. you can essentially write - .proto files natively in Lua). -* creating message objects. -* parsing Protocol Buffers into message objects. - -Other capabilities (parse/serialize JSON, serialize Protocol Buffers) -are coming. - To build the Lua bindings, the Lua libraries must be installed. Once they are installed, run: -- cgit v1.2.3