| commit | 7f0d3bb83dbb7590f3008182a8b27ecf9f0220d3 | [log] [tgz] |
|---|---|---|
| author | Josh Haberman <jhaberman@gmail.com> | Tue Mar 08 16:21:37 2016 -0800 |
| committer | Josh Haberman <jhaberman@gmail.com> | Tue Mar 08 16:21:37 2016 -0800 |
| tree | 783d68c8df77a2a628f1517c0576f20df634dec3 | |
| parent | f73baf670e8b14ef15fedfaa593ba71ba94dcfc8 [diff] |
Make OneofDef stop deriving from Def. It is clear now that oneofs are different form other defs in one important way: they are not top-level constructs that can stand on their own in a SymbolTable, for example. If you are iterating over a list of Defs in a SymbolTable, there is no chance you will run into a oneof. To reflect this reality, OneofDef no longer derives from Def, and the UPB_DEF_ONEOF is no longer an enum value that needs to be handled.
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.
API and ABI are both subject to change! Please do not distribute as a shared library for this reason (for now at least).
The core libraries are pure C99 and have no dependencies.
$ make
This will create a separate C library for each core library in lib/. They are built separately to help your binaries slim, so you don't need to link in things you neither want or need.
Other useful targets:
$ make tests $ make test
Unleaded tries to stay very small, but also aims to support lots of different formats. We reconcile these goals by being aggresively modular. The source tree and the build artifacts both reflect this organization:
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.
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:
#include "upb/descriptor/X.h"require "upb.descriptor"import upb.descriptorUnleaded supports integration with the Google protobuf library. These bindings let you:
Descriptor, FieldDescriptor, etc). to their Unleaded equivalents (upb::MessageDef, upb::FieldDef).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 provide Unleaded'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:
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:
$ make lua
Note that if the Lua headers are not in a standard place, you may need to pass custom flags:
$ make lua USER_CPPFLAGS=`pkg-config lua5.2 --cflags`
To test the Lua bindings:
$ make testlua
Author: Josh Haberman (jhaberman@gmail.com, haberman@google.com)