google-protobuf 3.0.0.alpha.3 → 3.0.0.alpha.3.1.pre
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of google-protobuf might be problematic. Click here for more details.
- checksums.yaml +7 -0
- data/ext/google/protobuf_c/defs.c +5 -3
- data/ext/google/protobuf_c/encode_decode.c +85 -75
- data/ext/google/protobuf_c/extconf.rb +1 -3
- data/ext/google/protobuf_c/message.c +9 -44
- data/ext/google/protobuf_c/protobuf.c +7 -10
- data/ext/google/protobuf_c/protobuf.h +9 -9
- data/ext/google/protobuf_c/repeated_field.c +55 -95
- data/ext/google/protobuf_c/storage.c +2 -5
- data/ext/google/protobuf_c/upb.c +248 -822
- data/ext/google/protobuf_c/upb.h +467 -511
- data/lib/google/protobuf.rb +0 -27
- data/tests/basic.rb +9 -119
- metadata +17 -27
- data/lib/google/protobuf/message_exts.rb +0 -53
- data/lib/google/protobuf/repeated_field.rb +0 -188
data/ext/google/protobuf_c/upb.h
CHANGED
@@ -99,15 +99,6 @@
|
|
99
99
|
#define UPB_INLINE static inline
|
100
100
|
#endif
|
101
101
|
|
102
|
-
// For use in C/C++ source files (not headers), forces inlining within the file.
|
103
|
-
#ifdef __GNUC__
|
104
|
-
#define UPB_FORCEINLINE inline __attribute__((always_inline))
|
105
|
-
#define UPB_NOINLINE __attribute__((noinline))
|
106
|
-
#else
|
107
|
-
#define UPB_FORCEINLINE
|
108
|
-
#define UPB_NOINLINE
|
109
|
-
#endif
|
110
|
-
|
111
102
|
#if __STDC_VERSION__ >= 199901L
|
112
103
|
#define UPB_C99
|
113
104
|
#endif
|
@@ -4814,8 +4805,10 @@ UPB_DEFINE_STRUCT0(upb_byteshandler,
|
|
4814
4805
|
));
|
4815
4806
|
|
4816
4807
|
void upb_byteshandler_init(upb_byteshandler *h);
|
4808
|
+
void upb_byteshandler_uninit(upb_byteshandler *h);
|
4817
4809
|
|
4818
4810
|
// Caller must ensure that "d" outlives the handlers.
|
4811
|
+
// TODO(haberman): support handlerfree function for the data.
|
4819
4812
|
// TODO(haberman): should this have a "freeze" operation? It's not necessary
|
4820
4813
|
// for memory management, but could be useful to force immutability and provide
|
4821
4814
|
// a convenient moment to verify that all registration succeeded.
|
@@ -4990,17 +4983,12 @@ template <class T> struct disable_if_same<T, T> {};
|
|
4990
4983
|
template <class T> void DeletePointer(void *p) { delete static_cast<T>(p); }
|
4991
4984
|
|
4992
4985
|
template <class T1, class T2>
|
4993
|
-
struct
|
4986
|
+
struct FirstUnlessVoid {
|
4994
4987
|
typedef T1 value;
|
4995
4988
|
};
|
4996
4989
|
|
4997
4990
|
template <class T2>
|
4998
|
-
struct
|
4999
|
-
typedef T2 value;
|
5000
|
-
};
|
5001
|
-
|
5002
|
-
template <class T2>
|
5003
|
-
struct FirstUnlessVoidOrBool<bool, T2> {
|
4991
|
+
struct FirstUnlessVoid<void, T2> {
|
5004
4992
|
typedef T2 value;
|
5005
4993
|
};
|
5006
4994
|
|
@@ -5382,14 +5370,10 @@ inline MethodSig4<R, C, P1, P2, P3, P4> MatchFunc(R (C::*f)(P1, P2, P3, P4)) {
|
|
5382
5370
|
//
|
5383
5371
|
// 1. If the function returns void, make it return the expected type and with
|
5384
5372
|
// a value that always indicates success.
|
5385
|
-
// 2. If the function
|
5386
|
-
//
|
5387
|
-
//
|
5388
|
-
//
|
5389
|
-
// 1. void* for start handlers. If the closure parameter has a different type
|
5390
|
-
// we will cast it to void* for the return in the success case.
|
5391
|
-
// 2. size_t for string buffer handlers.
|
5392
|
-
// 3. bool for everything else.
|
5373
|
+
// 2. If the function is expected to return void* but doesn't, wrap it so it
|
5374
|
+
// does (either by returning the closure param if the wrapped function
|
5375
|
+
// returns void or by casting a different pointer type to void* for
|
5376
|
+
// return).
|
5393
5377
|
|
5394
5378
|
// Template parameters are FuncN type and desired return type.
|
5395
5379
|
template <class F, class R, class Enable = void>
|
@@ -5778,13 +5762,10 @@ inline Handler<T>::Handler(F func)
|
|
5778
5762
|
attr_.SetClosureType(UniquePtrForType<typename F::FuncInfo::Closure>());
|
5779
5763
|
|
5780
5764
|
// We use the closure type (from the first parameter) if the return type is
|
5781
|
-
// void
|
5782
|
-
//
|
5783
|
-
|
5784
|
-
|
5785
|
-
// in that case the value will be ignored.
|
5786
|
-
typedef typename FirstUnlessVoidOrBool<typename F::FuncInfo::Return,
|
5787
|
-
typename F::FuncInfo::Closure>::value
|
5765
|
+
// void. This is all nonsense for non START* handlers, but it doesn't matter
|
5766
|
+
// because in that case the value will be ignored.
|
5767
|
+
typedef typename FirstUnlessVoid<typename F::FuncInfo::Return,
|
5768
|
+
typename F::FuncInfo::Closure>::value
|
5788
5769
|
EffectiveReturn;
|
5789
5770
|
attr_.SetReturnClosureType(UniquePtrForType<EffectiveReturn>());
|
5790
5771
|
}
|
@@ -5979,7 +5960,9 @@ inline BytesHandler::BytesHandler() {
|
|
5979
5960
|
upb_byteshandler_init(this);
|
5980
5961
|
}
|
5981
5962
|
|
5982
|
-
inline BytesHandler::~BytesHandler() {
|
5963
|
+
inline BytesHandler::~BytesHandler() {
|
5964
|
+
upb_byteshandler_uninit(this);
|
5965
|
+
}
|
5983
5966
|
|
5984
5967
|
} // namespace upb
|
5985
5968
|
|
@@ -6000,261 +5983,6 @@ inline BytesHandler::~BytesHandler() {}
|
|
6000
5983
|
#endif // UPB_HANDLERS_INL_H_
|
6001
5984
|
|
6002
5985
|
#endif // UPB_HANDLERS_H
|
6003
|
-
/*
|
6004
|
-
* upb - a minimalist implementation of protocol buffers.
|
6005
|
-
*
|
6006
|
-
* Copyright (c) 2014 Google Inc. See LICENSE for details.
|
6007
|
-
* Author: Josh Haberman <jhaberman@gmail.com>
|
6008
|
-
*
|
6009
|
-
* A upb::Environment provides a means for injecting malloc and an
|
6010
|
-
* error-reporting callback into encoders/decoders. This allows them to be
|
6011
|
-
* independent of nearly all assumptions about their actual environment.
|
6012
|
-
*
|
6013
|
-
* It is also a container for allocating the encoders/decoders themselves that
|
6014
|
-
* insulates clients from knowing their actual size. This provides ABI
|
6015
|
-
* compatibility even if the size of the objects change. And this allows the
|
6016
|
-
* structure definitions to be in the .c files instead of the .h files, making
|
6017
|
-
* the .h files smaller and more readable.
|
6018
|
-
*/
|
6019
|
-
|
6020
|
-
|
6021
|
-
#ifndef UPB_ENV_H_
|
6022
|
-
#define UPB_ENV_H_
|
6023
|
-
|
6024
|
-
#ifdef __cplusplus
|
6025
|
-
namespace upb {
|
6026
|
-
class Environment;
|
6027
|
-
class SeededAllocator;
|
6028
|
-
}
|
6029
|
-
#endif
|
6030
|
-
|
6031
|
-
UPB_DECLARE_TYPE(upb::Environment, upb_env);
|
6032
|
-
UPB_DECLARE_TYPE(upb::SeededAllocator, upb_seededalloc);
|
6033
|
-
|
6034
|
-
typedef void *upb_alloc_func(void *ud, void *ptr, size_t oldsize, size_t size);
|
6035
|
-
typedef void upb_cleanup_func(void *ud);
|
6036
|
-
typedef bool upb_error_func(void *ud, const upb_status *status);
|
6037
|
-
|
6038
|
-
// An environment is *not* thread-safe.
|
6039
|
-
UPB_DEFINE_CLASS0(upb::Environment,
|
6040
|
-
public:
|
6041
|
-
Environment();
|
6042
|
-
~Environment();
|
6043
|
-
|
6044
|
-
// Set a custom memory allocation function for the environment. May ONLY
|
6045
|
-
// be called before any calls to Malloc()/Realloc()/AddCleanup() below.
|
6046
|
-
// If this is not called, the system realloc() function will be used.
|
6047
|
-
// The given user pointer "ud" will be passed to the allocation function.
|
6048
|
-
//
|
6049
|
-
// The allocation function will not receive corresponding "free" calls. it
|
6050
|
-
// must ensure that the memory is valid for the lifetime of the Environment,
|
6051
|
-
// but it may be reclaimed any time thereafter. The likely usage is that
|
6052
|
-
// "ud" points to a stateful allocator, and that the allocator frees all
|
6053
|
-
// memory, arena-style, when it is destroyed. In this case the allocator must
|
6054
|
-
// outlive the Environment. Another possibility is that the allocation
|
6055
|
-
// function returns GC-able memory that is guaranteed to be GC-rooted for the
|
6056
|
-
// life of the Environment.
|
6057
|
-
void SetAllocationFunction(upb_alloc_func* alloc, void* ud);
|
6058
|
-
|
6059
|
-
template<class T>
|
6060
|
-
void SetAllocator(T* allocator) {
|
6061
|
-
SetAllocationFunction(allocator->GetAllocationFunction(), allocator);
|
6062
|
-
}
|
6063
|
-
|
6064
|
-
// Set a custom error reporting function.
|
6065
|
-
void SetErrorFunction(upb_error_func* func, void* ud);
|
6066
|
-
|
6067
|
-
// Set the error reporting function to simply copy the status to the given
|
6068
|
-
// status and abort.
|
6069
|
-
void ReportErrorsTo(Status* status);
|
6070
|
-
|
6071
|
-
// Returns true if all allocations and AddCleanup() calls have succeeded,
|
6072
|
-
// and no errors were reported with ReportError() (except ones that recovered
|
6073
|
-
// successfully).
|
6074
|
-
bool ok() const;
|
6075
|
-
|
6076
|
-
//////////////////////////////////////////////////////////////////////////////
|
6077
|
-
// Functions for use by encoders/decoders.
|
6078
|
-
|
6079
|
-
// Reports an error to this environment's callback, returning true if
|
6080
|
-
// the caller should try to recover.
|
6081
|
-
bool ReportError(const Status* status);
|
6082
|
-
|
6083
|
-
// Allocate memory. Uses the environment's allocation function.
|
6084
|
-
//
|
6085
|
-
// There is no need to free(). All memory will be freed automatically, but is
|
6086
|
-
// guaranteed to outlive the Environment.
|
6087
|
-
void* Malloc(size_t size);
|
6088
|
-
|
6089
|
-
// Reallocate memory. Preserves "oldsize" bytes from the existing buffer
|
6090
|
-
// Requires: oldsize <= existing_size.
|
6091
|
-
//
|
6092
|
-
// TODO(haberman): should we also enforce that oldsize <= size?
|
6093
|
-
void* Realloc(void* ptr, size_t oldsize, size_t size);
|
6094
|
-
|
6095
|
-
// Add a cleanup function to run when the environment is destroyed.
|
6096
|
-
// Returns false on out-of-memory.
|
6097
|
-
//
|
6098
|
-
// The first call to AddCleanup() after SetAllocationFunction() is guaranteed
|
6099
|
-
// to return true -- this makes it possible to robustly set a cleanup handler
|
6100
|
-
// for a custom allocation function.
|
6101
|
-
bool AddCleanup(upb_cleanup_func* func, void* ud);
|
6102
|
-
|
6103
|
-
// Total number of bytes that have been allocated. It is undefined what
|
6104
|
-
// Realloc() does to this counter.
|
6105
|
-
size_t BytesAllocated() const;
|
6106
|
-
|
6107
|
-
private:
|
6108
|
-
UPB_DISALLOW_COPY_AND_ASSIGN(Environment);
|
6109
|
-
,
|
6110
|
-
UPB_DEFINE_STRUCT0(upb_env,
|
6111
|
-
bool ok_;
|
6112
|
-
size_t bytes_allocated;
|
6113
|
-
|
6114
|
-
// Alloc function.
|
6115
|
-
upb_alloc_func *alloc;
|
6116
|
-
void *alloc_ud;
|
6117
|
-
|
6118
|
-
// Error-reporting function.
|
6119
|
-
upb_error_func *err;
|
6120
|
-
void *err_ud;
|
6121
|
-
|
6122
|
-
// Userdata for default alloc func.
|
6123
|
-
void *default_alloc_ud;
|
6124
|
-
|
6125
|
-
// Cleanup entries. Pointer to a cleanup_ent, defined in env.c
|
6126
|
-
void *cleanup_head;
|
6127
|
-
|
6128
|
-
// For future expansion, since the size of this struct is exposed to users.
|
6129
|
-
void *future1;
|
6130
|
-
void *future2;
|
6131
|
-
));
|
6132
|
-
|
6133
|
-
UPB_BEGIN_EXTERN_C
|
6134
|
-
|
6135
|
-
void upb_env_init(upb_env *e);
|
6136
|
-
void upb_env_uninit(upb_env *e);
|
6137
|
-
void upb_env_setallocfunc(upb_env *e, upb_alloc_func *func, void *ud);
|
6138
|
-
void upb_env_seterrorfunc(upb_env *e, upb_error_func *func, void *ud);
|
6139
|
-
void upb_env_reporterrorsto(upb_env *e, upb_status *status);
|
6140
|
-
bool upb_env_ok(const upb_env *e);
|
6141
|
-
bool upb_env_reporterror(upb_env *e, const upb_status *status);
|
6142
|
-
void *upb_env_malloc(upb_env *e, size_t size);
|
6143
|
-
void *upb_env_realloc(upb_env *e, void *ptr, size_t oldsize, size_t size);
|
6144
|
-
bool upb_env_addcleanup(upb_env *e, upb_cleanup_func *func, void *ud);
|
6145
|
-
size_t upb_env_bytesallocated(const upb_env *e);
|
6146
|
-
|
6147
|
-
UPB_END_EXTERN_C
|
6148
|
-
|
6149
|
-
// An allocator that allocates from an initial memory region (likely the stack)
|
6150
|
-
// before falling back to another allocator.
|
6151
|
-
UPB_DEFINE_CLASS0(upb::SeededAllocator,
|
6152
|
-
public:
|
6153
|
-
SeededAllocator(void *mem, size_t len);
|
6154
|
-
~SeededAllocator();
|
6155
|
-
|
6156
|
-
// Set a custom fallback memory allocation function for the allocator, to use
|
6157
|
-
// once the initial region runs out.
|
6158
|
-
//
|
6159
|
-
// May ONLY be called before GetAllocationFunction(). If this is not
|
6160
|
-
// called, the system realloc() will be the fallback allocator.
|
6161
|
-
void SetFallbackAllocator(upb_alloc_func *alloc, void *ud);
|
6162
|
-
|
6163
|
-
// Gets the allocation function for this allocator.
|
6164
|
-
upb_alloc_func* GetAllocationFunction();
|
6165
|
-
|
6166
|
-
private:
|
6167
|
-
UPB_DISALLOW_COPY_AND_ASSIGN(SeededAllocator);
|
6168
|
-
,
|
6169
|
-
UPB_DEFINE_STRUCT0(upb_seededalloc,
|
6170
|
-
// Fallback alloc function.
|
6171
|
-
upb_alloc_func *alloc;
|
6172
|
-
upb_cleanup_func *alloc_cleanup;
|
6173
|
-
void *alloc_ud;
|
6174
|
-
bool need_cleanup;
|
6175
|
-
bool returned_allocfunc;
|
6176
|
-
|
6177
|
-
// Userdata for default alloc func.
|
6178
|
-
void *default_alloc_ud;
|
6179
|
-
|
6180
|
-
// Pointers for the initial memory region.
|
6181
|
-
char *mem_base;
|
6182
|
-
char *mem_ptr;
|
6183
|
-
char *mem_limit;
|
6184
|
-
|
6185
|
-
// For future expansion, since the size of this struct is exposed to users.
|
6186
|
-
void *future1;
|
6187
|
-
void *future2;
|
6188
|
-
));
|
6189
|
-
|
6190
|
-
UPB_BEGIN_EXTERN_C
|
6191
|
-
|
6192
|
-
void upb_seededalloc_init(upb_seededalloc *a, void *mem, size_t len);
|
6193
|
-
void upb_seededalloc_uninit(upb_seededalloc *a);
|
6194
|
-
void upb_seededalloc_setfallbackalloc(upb_seededalloc *a, upb_alloc_func *func,
|
6195
|
-
void *ud);
|
6196
|
-
upb_alloc_func *upb_seededalloc_getallocfunc(upb_seededalloc *a);
|
6197
|
-
|
6198
|
-
UPB_END_EXTERN_C
|
6199
|
-
|
6200
|
-
#ifdef __cplusplus
|
6201
|
-
|
6202
|
-
namespace upb {
|
6203
|
-
|
6204
|
-
inline Environment::Environment() {
|
6205
|
-
upb_env_init(this);
|
6206
|
-
}
|
6207
|
-
inline Environment::~Environment() {
|
6208
|
-
upb_env_uninit(this);
|
6209
|
-
}
|
6210
|
-
inline void Environment::SetAllocationFunction(upb_alloc_func *alloc,
|
6211
|
-
void *ud) {
|
6212
|
-
upb_env_setallocfunc(this, alloc, ud);
|
6213
|
-
}
|
6214
|
-
inline void Environment::SetErrorFunction(upb_error_func *func, void *ud) {
|
6215
|
-
upb_env_seterrorfunc(this, func, ud);
|
6216
|
-
}
|
6217
|
-
inline void Environment::ReportErrorsTo(Status* status) {
|
6218
|
-
upb_env_reporterrorsto(this, status);
|
6219
|
-
}
|
6220
|
-
inline bool Environment::ok() const {
|
6221
|
-
return upb_env_ok(this);
|
6222
|
-
}
|
6223
|
-
inline bool Environment::ReportError(const Status* status) {
|
6224
|
-
return upb_env_reporterror(this, status);
|
6225
|
-
}
|
6226
|
-
inline void *Environment::Malloc(size_t size) {
|
6227
|
-
return upb_env_malloc(this, size);
|
6228
|
-
}
|
6229
|
-
inline void *Environment::Realloc(void *ptr, size_t oldsize, size_t size) {
|
6230
|
-
return upb_env_realloc(this, ptr, oldsize, size);
|
6231
|
-
}
|
6232
|
-
inline bool Environment::AddCleanup(upb_cleanup_func *func, void *ud) {
|
6233
|
-
return upb_env_addcleanup(this, func, ud);
|
6234
|
-
}
|
6235
|
-
inline size_t Environment::BytesAllocated() const {
|
6236
|
-
return upb_env_bytesallocated(this);
|
6237
|
-
}
|
6238
|
-
|
6239
|
-
inline SeededAllocator::SeededAllocator(void *mem, size_t len) {
|
6240
|
-
upb_seededalloc_init(this, mem, len);
|
6241
|
-
}
|
6242
|
-
inline SeededAllocator::~SeededAllocator() {
|
6243
|
-
upb_seededalloc_uninit(this);
|
6244
|
-
}
|
6245
|
-
inline void SeededAllocator::SetFallbackAllocator(upb_alloc_func *alloc,
|
6246
|
-
void *ud) {
|
6247
|
-
upb_seededalloc_setfallbackalloc(this, alloc, ud);
|
6248
|
-
}
|
6249
|
-
inline upb_alloc_func *SeededAllocator::GetAllocationFunction() {
|
6250
|
-
return upb_seededalloc_getallocfunc(this);
|
6251
|
-
}
|
6252
|
-
|
6253
|
-
} // namespace upb
|
6254
|
-
|
6255
|
-
#endif // __cplusplus
|
6256
|
-
|
6257
|
-
#endif // UPB_ENV_H_
|
6258
5986
|
/*
|
6259
5987
|
* upb - a minimalist implementation of protocol buffers.
|
6260
5988
|
*
|
@@ -6290,6 +6018,27 @@ UPB_DECLARE_TYPE(upb::BufferSource, upb_bufsrc);
|
|
6290
6018
|
UPB_DECLARE_TYPE(upb::BytesSink, upb_bytessink);
|
6291
6019
|
UPB_DECLARE_TYPE(upb::Sink, upb_sink);
|
6292
6020
|
|
6021
|
+
// Internal-only struct for the sink.
|
6022
|
+
struct upb_sinkframe {
|
6023
|
+
UPB_PRIVATE_FOR_CPP
|
6024
|
+
const upb_handlers *h;
|
6025
|
+
void *closure;
|
6026
|
+
|
6027
|
+
// For any frames besides the top, this is the END* callback that will run
|
6028
|
+
// when the subframe is popped (for example, for a "sequence" frame the frame
|
6029
|
+
// above it will be a UPB_HANDLER_ENDSEQ handler). But this is only
|
6030
|
+
// necessary for assertion checking inside upb_sink and can be omitted if the
|
6031
|
+
// sink has only one caller.
|
6032
|
+
//
|
6033
|
+
// TODO(haberman): have a mechanism for ensuring that a sink only has one
|
6034
|
+
// caller.
|
6035
|
+
upb_selector_t selector;
|
6036
|
+
};
|
6037
|
+
|
6038
|
+
// The maximum nesting depth that upb::Sink will allow. Matches proto2's limit.
|
6039
|
+
// TODO: make this a runtime-settable property of Sink.
|
6040
|
+
#define UPB_SINK_MAX_NESTING 64
|
6041
|
+
|
6293
6042
|
// A upb::Sink is an object that binds a upb::Handlers object to some runtime
|
6294
6043
|
// state. It represents an endpoint to which data can be sent.
|
6295
6044
|
//
|
@@ -6849,11 +6598,45 @@ class Reader;
|
|
6849
6598
|
|
6850
6599
|
UPB_DECLARE_TYPE(upb::descriptor::Reader, upb_descreader);
|
6851
6600
|
|
6852
|
-
|
6601
|
+
// Internal-only structs used by Reader.
|
6602
|
+
|
6603
|
+
// upb_deflist is an internal-only dynamic array for storing a growing list of
|
6604
|
+
// upb_defs.
|
6605
|
+
typedef struct {
|
6606
|
+
UPB_PRIVATE_FOR_CPP
|
6607
|
+
upb_def **defs;
|
6608
|
+
size_t len;
|
6609
|
+
size_t size;
|
6610
|
+
bool owned;
|
6611
|
+
} upb_deflist;
|
6612
|
+
|
6613
|
+
// We keep a stack of all the messages scopes we are currently in, as well as
|
6614
|
+
// the top-level file scope. This is necessary to correctly qualify the
|
6615
|
+
// definitions that are contained inside. "name" tracks the name of the
|
6616
|
+
// message or package (a bare name -- not qualified by any enclosing scopes).
|
6617
|
+
typedef struct {
|
6618
|
+
UPB_PRIVATE_FOR_CPP
|
6619
|
+
char *name;
|
6620
|
+
// Index of the first def that is under this scope. For msgdefs, the
|
6621
|
+
// msgdef itself is at start-1.
|
6622
|
+
int start;
|
6623
|
+
} upb_descreader_frame;
|
6624
|
+
|
6625
|
+
// The maximum number of nested declarations that are allowed, ie.
|
6626
|
+
// message Foo {
|
6627
|
+
// message Bar {
|
6628
|
+
// message Baz {
|
6629
|
+
// }
|
6630
|
+
// }
|
6631
|
+
// }
|
6632
|
+
//
|
6633
|
+
// This is a resource limit that affects how big our runtime stack can grow.
|
6634
|
+
// TODO: make this a runtime-settable property of the Reader instance.
|
6635
|
+
#define UPB_MAX_MESSAGE_NESTING 64
|
6853
6636
|
|
6854
6637
|
// Class that receives descriptor data according to the descriptor.proto schema
|
6855
6638
|
// and use it to build upb::Defs corresponding to that schema.
|
6856
|
-
|
6639
|
+
UPB_DEFINE_CLASS0(upb::descriptor::Reader,
|
6857
6640
|
public:
|
6858
6641
|
// These handlers must have come from NewHandlers() and must outlive the
|
6859
6642
|
// Reader.
|
@@ -6863,7 +6646,11 @@ class upb::descriptor::Reader {
|
|
6863
6646
|
// to build/memory-manage the handlers at runtime at all). Unfortunately this
|
6864
6647
|
// is a bit tricky to implement for Handlers, but necessary to simplify this
|
6865
6648
|
// interface.
|
6866
|
-
|
6649
|
+
Reader(const Handlers* handlers, Status* status);
|
6650
|
+
~Reader();
|
6651
|
+
|
6652
|
+
// Resets the reader's state and discards any defs it may have built.
|
6653
|
+
void Reset();
|
6867
6654
|
|
6868
6655
|
// The reader's input; this is where descriptor.proto data should be sent.
|
6869
6656
|
Sink* input();
|
@@ -6879,30 +6666,45 @@ class upb::descriptor::Reader {
|
|
6879
6666
|
|
6880
6667
|
// Builds and returns handlers for the reader, owned by "owner."
|
6881
6668
|
static Handlers* NewHandlers(const void* owner);
|
6669
|
+
,
|
6670
|
+
UPB_DEFINE_STRUCT0(upb_descreader,
|
6671
|
+
upb_sink sink;
|
6672
|
+
upb_deflist defs;
|
6673
|
+
upb_descreader_frame stack[UPB_MAX_MESSAGE_NESTING];
|
6674
|
+
int stack_len;
|
6882
6675
|
|
6883
|
-
|
6884
|
-
|
6885
|
-
|
6676
|
+
uint32_t number;
|
6677
|
+
char *name;
|
6678
|
+
bool saw_number;
|
6679
|
+
bool saw_name;
|
6886
6680
|
|
6887
|
-
|
6681
|
+
char *default_string;
|
6888
6682
|
|
6889
|
-
|
6683
|
+
upb_fielddef *f;
|
6684
|
+
));
|
6685
|
+
|
6686
|
+
UPB_BEGIN_EXTERN_C // {
|
6890
6687
|
|
6891
6688
|
// C API.
|
6892
|
-
|
6689
|
+
void upb_descreader_init(upb_descreader *r, const upb_handlers *handlers,
|
6690
|
+
upb_status *status);
|
6691
|
+
void upb_descreader_uninit(upb_descreader *r);
|
6692
|
+
void upb_descreader_reset(upb_descreader *r);
|
6893
6693
|
upb_sink *upb_descreader_input(upb_descreader *r);
|
6894
6694
|
upb_def **upb_descreader_getdefs(upb_descreader *r, void *owner, int *n);
|
6895
6695
|
const upb_handlers *upb_descreader_newhandlers(const void *owner);
|
6896
6696
|
|
6897
|
-
UPB_END_EXTERN_C
|
6697
|
+
UPB_END_EXTERN_C // }
|
6898
6698
|
|
6899
6699
|
#ifdef __cplusplus
|
6900
6700
|
// C++ implementation details. /////////////////////////////////////////////////
|
6901
6701
|
namespace upb {
|
6902
6702
|
namespace descriptor {
|
6903
|
-
inline Reader
|
6904
|
-
|
6703
|
+
inline Reader::Reader(const Handlers *h, Status *s) {
|
6704
|
+
upb_descreader_init(this, h, s);
|
6905
6705
|
}
|
6706
|
+
inline Reader::~Reader() { upb_descreader_uninit(this); }
|
6707
|
+
inline void Reader::Reset() { upb_descreader_reset(this); }
|
6906
6708
|
inline Sink* Reader::input() { return upb_descreader_input(this); }
|
6907
6709
|
inline upb::Def** Reader::GetDefs(void* owner, int* n) {
|
6908
6710
|
return upb_descreader_getdefs(this, owner, n);
|
@@ -6962,6 +6764,44 @@ UPB_DECLARE_TYPE(upb::pb::Decoder, upb_pbdecoder);
|
|
6962
6764
|
UPB_DECLARE_TYPE(upb::pb::DecoderMethod, upb_pbdecodermethod);
|
6963
6765
|
UPB_DECLARE_TYPE(upb::pb::DecoderMethodOptions, upb_pbdecodermethodopts);
|
6964
6766
|
|
6767
|
+
// The maximum that any submessages can be nested. Matches proto2's limit.
|
6768
|
+
// This specifies the size of the decoder's statically-sized array and therefore
|
6769
|
+
// setting it high will cause the upb::pb::Decoder object to be larger.
|
6770
|
+
//
|
6771
|
+
// If necessary we can add a runtime-settable property to Decoder that allow
|
6772
|
+
// this to be larger than the compile-time setting, but this would add
|
6773
|
+
// complexity, particularly since we would have to decide how/if to give users
|
6774
|
+
// the ability to set a custom memory allocation function.
|
6775
|
+
#define UPB_DECODER_MAX_NESTING 64
|
6776
|
+
|
6777
|
+
// Internal-only struct used by the decoder.
|
6778
|
+
typedef struct {
|
6779
|
+
UPB_PRIVATE_FOR_CPP
|
6780
|
+
// Space optimization note: we store two pointers here that the JIT
|
6781
|
+
// doesn't need at all; the upb_handlers* inside the sink and
|
6782
|
+
// the dispatch table pointer. We can optimze so that the JIT uses
|
6783
|
+
// smaller stack frames than the interpreter. The only thing we need
|
6784
|
+
// to guarantee is that the fallback routines can find end_ofs.
|
6785
|
+
upb_sink sink;
|
6786
|
+
|
6787
|
+
// The absolute stream offset of the end-of-frame delimiter.
|
6788
|
+
// Non-delimited frames (groups and non-packed repeated fields) reuse the
|
6789
|
+
// delimiter of their parent, even though the frame may not end there.
|
6790
|
+
//
|
6791
|
+
// NOTE: the JIT stores a slightly different value here for non-top frames.
|
6792
|
+
// It stores the value relative to the end of the enclosed message. But the
|
6793
|
+
// top frame is still stored the same way, which is important for ensuring
|
6794
|
+
// that calls from the JIT into C work correctly.
|
6795
|
+
uint64_t end_ofs;
|
6796
|
+
const uint32_t *base;
|
6797
|
+
|
6798
|
+
// 0 indicates a length-delimited field.
|
6799
|
+
// A positive number indicates a known group.
|
6800
|
+
// A negative number indicates an unknown group.
|
6801
|
+
int32_t groupnum;
|
6802
|
+
upb_inttable *dispatch; // Not used by the JIT.
|
6803
|
+
} upb_pbdecoder_frame;
|
6804
|
+
|
6965
6805
|
// The parameters one uses to construct a DecoderMethod.
|
6966
6806
|
// TODO(haberman): move allowjit here? Seems more convenient for users.
|
6967
6807
|
UPB_DEFINE_CLASS0(upb::pb::DecoderMethodOptions,
|
@@ -7039,31 +6879,22 @@ UPB_DEFINE_STRUCT(upb_pbdecodermethod, upb_refcounted,
|
|
7039
6879
|
upb_inttable dispatch;
|
7040
6880
|
));
|
7041
6881
|
|
7042
|
-
// Preallocation hint: decoder won't allocate more bytes than this when first
|
7043
|
-
// constructed. This hint may be an overestimate for some build configurations.
|
7044
|
-
// But if the decoder library is upgraded without recompiling the application,
|
7045
|
-
// it may be an underestimate.
|
7046
|
-
#define UPB_PB_DECODER_SIZE 4400
|
7047
|
-
|
7048
|
-
#ifdef __cplusplus
|
7049
|
-
|
7050
6882
|
// A Decoder receives binary protobuf data on its input sink and pushes the
|
7051
6883
|
// decoded data to its output sink.
|
7052
|
-
|
6884
|
+
UPB_DEFINE_CLASS0(upb::pb::Decoder,
|
7053
6885
|
public:
|
7054
6886
|
// Constructs a decoder instance for the given method, which must outlive this
|
7055
6887
|
// decoder. Any errors during parsing will be set on the given status, which
|
7056
6888
|
// must also outlive this decoder.
|
7057
|
-
|
7058
|
-
|
7059
|
-
static Decoder* Create(Environment* env, const DecoderMethod* method,
|
7060
|
-
Sink* output);
|
6889
|
+
Decoder(const DecoderMethod* method, Status* status);
|
6890
|
+
~Decoder();
|
7061
6891
|
|
7062
6892
|
// Returns the DecoderMethod this decoder is parsing from.
|
6893
|
+
// TODO(haberman): Do users need to be able to rebind this?
|
7063
6894
|
const DecoderMethod* method() const;
|
7064
6895
|
|
7065
|
-
//
|
7066
|
-
|
6896
|
+
// Resets the state of the decoder.
|
6897
|
+
void Reset();
|
7067
6898
|
|
7068
6899
|
// Returns number of bytes successfully parsed.
|
7069
6900
|
//
|
@@ -7074,25 +6905,76 @@ class upb::pb::Decoder {
|
|
7074
6905
|
// callback.
|
7075
6906
|
uint64_t BytesParsed() const;
|
7076
6907
|
|
7077
|
-
//
|
7078
|
-
//
|
7079
|
-
// is a resource limit that controls the amount of memory used by the parsing
|
7080
|
-
// stack.
|
6908
|
+
// Resets the output sink of the Decoder.
|
6909
|
+
// The given sink must match method()->dest_handlers().
|
7081
6910
|
//
|
7082
|
-
//
|
7083
|
-
//
|
7084
|
-
|
7085
|
-
|
7086
|
-
|
7087
|
-
void Reset();
|
6911
|
+
// This must be called at least once before the decoder can be used. It may
|
6912
|
+
// only be called with the decoder is in a state where it was just created or
|
6913
|
+
// reset with pipeline.Reset(). The given sink must be from the same pipeline
|
6914
|
+
// as this decoder.
|
6915
|
+
bool ResetOutput(Sink* sink);
|
7088
6916
|
|
7089
|
-
|
6917
|
+
// The sink on which this decoder receives input.
|
6918
|
+
BytesSink* input();
|
7090
6919
|
|
7091
6920
|
private:
|
7092
|
-
|
7093
|
-
|
6921
|
+
UPB_DISALLOW_COPY_AND_ASSIGN(Decoder);
|
6922
|
+
,
|
6923
|
+
UPB_DEFINE_STRUCT0(upb_pbdecoder, UPB_QUOTE(
|
6924
|
+
// Our input sink.
|
6925
|
+
upb_bytessink input_;
|
7094
6926
|
|
7095
|
-
|
6927
|
+
// The decoder method we are parsing with (owned).
|
6928
|
+
const upb_pbdecodermethod *method_;
|
6929
|
+
|
6930
|
+
size_t call_len;
|
6931
|
+
const uint32_t *pc, *last;
|
6932
|
+
|
6933
|
+
// Current input buffer and its stream offset.
|
6934
|
+
const char *buf, *ptr, *end, *checkpoint;
|
6935
|
+
|
6936
|
+
// End of the delimited region, relative to ptr, or NULL if not in this buf.
|
6937
|
+
const char *delim_end;
|
6938
|
+
|
6939
|
+
// End of the delimited region, relative to ptr, or end if not in this buf.
|
6940
|
+
const char *data_end;
|
6941
|
+
|
6942
|
+
// Overall stream offset of "buf."
|
6943
|
+
uint64_t bufstart_ofs;
|
6944
|
+
|
6945
|
+
// Buffer for residual bytes not parsed from the previous buffer.
|
6946
|
+
// The maximum number of residual bytes we require is 12; a five-byte
|
6947
|
+
// unknown tag plus an eight-byte value, less one because the value
|
6948
|
+
// is only a partial value.
|
6949
|
+
char residual[12];
|
6950
|
+
char *residual_end;
|
6951
|
+
|
6952
|
+
// Stores the user buffer passed to our decode function.
|
6953
|
+
const char *buf_param;
|
6954
|
+
size_t size_param;
|
6955
|
+
const upb_bufhandle *handle;
|
6956
|
+
|
6957
|
+
#ifdef UPB_USE_JIT_X64
|
6958
|
+
// Used momentarily by the generated code to store a value while a user
|
6959
|
+
// function is called.
|
6960
|
+
uint32_t tmp_len;
|
6961
|
+
|
6962
|
+
const void *saved_rsp;
|
6963
|
+
#endif
|
6964
|
+
|
6965
|
+
upb_status *status;
|
6966
|
+
|
6967
|
+
// Our internal stack.
|
6968
|
+
upb_pbdecoder_frame *top, *limit;
|
6969
|
+
upb_pbdecoder_frame stack[UPB_DECODER_MAX_NESTING];
|
6970
|
+
#ifdef UPB_USE_JIT_X64
|
6971
|
+
// Each native stack frame needs two pointers, plus we need a few frames for
|
6972
|
+
// the enter/exit trampolines.
|
6973
|
+
const uint32_t *callstack[(UPB_DECODER_MAX_NESTING * 2) + 10];
|
6974
|
+
#else
|
6975
|
+
const uint32_t *callstack[UPB_DECODER_MAX_NESTING];
|
6976
|
+
#endif
|
6977
|
+
)));
|
7096
6978
|
|
7097
6979
|
// A class for caching protobuf processing code, whether bytecode for the
|
7098
6980
|
// interpreted decoder or machine code for the JIT.
|
@@ -7141,15 +7023,14 @@ UPB_DEFINE_STRUCT0(upb_pbcodecache,
|
|
7141
7023
|
|
7142
7024
|
UPB_BEGIN_EXTERN_C // {
|
7143
7025
|
|
7144
|
-
upb_pbdecoder *
|
7145
|
-
|
7146
|
-
|
7026
|
+
void upb_pbdecoder_init(upb_pbdecoder *d, const upb_pbdecodermethod *method,
|
7027
|
+
upb_status *status);
|
7028
|
+
void upb_pbdecoder_uninit(upb_pbdecoder *d);
|
7029
|
+
void upb_pbdecoder_reset(upb_pbdecoder *d);
|
7147
7030
|
const upb_pbdecodermethod *upb_pbdecoder_method(const upb_pbdecoder *d);
|
7031
|
+
bool upb_pbdecoder_resetoutput(upb_pbdecoder *d, upb_sink *sink);
|
7148
7032
|
upb_bytessink *upb_pbdecoder_input(upb_pbdecoder *d);
|
7149
7033
|
uint64_t upb_pbdecoder_bytesparsed(const upb_pbdecoder *d);
|
7150
|
-
size_t upb_pbdecoder_maxnesting(const upb_pbdecoder *d);
|
7151
|
-
bool upb_pbdecoder_setmaxnesting(upb_pbdecoder *d, size_t max);
|
7152
|
-
void upb_pbdecoder_reset(upb_pbdecoder *d);
|
7153
7034
|
|
7154
7035
|
void upb_pbdecodermethodopts_init(upb_pbdecodermethodopts *opts,
|
7155
7036
|
const upb_handlers *h);
|
@@ -7184,27 +7065,27 @@ namespace upb {
|
|
7184
7065
|
|
7185
7066
|
namespace pb {
|
7186
7067
|
|
7187
|
-
|
7188
|
-
|
7189
|
-
|
7190
|
-
|
7068
|
+
inline Decoder::Decoder(const DecoderMethod* m, Status* s) {
|
7069
|
+
upb_pbdecoder_init(this, m, s);
|
7070
|
+
}
|
7071
|
+
inline Decoder::~Decoder() {
|
7072
|
+
upb_pbdecoder_uninit(this);
|
7191
7073
|
}
|
7192
7074
|
inline const DecoderMethod* Decoder::method() const {
|
7193
7075
|
return upb_pbdecoder_method(this);
|
7194
7076
|
}
|
7195
|
-
inline
|
7196
|
-
|
7077
|
+
inline void Decoder::Reset() {
|
7078
|
+
upb_pbdecoder_reset(this);
|
7197
7079
|
}
|
7198
7080
|
inline uint64_t Decoder::BytesParsed() const {
|
7199
7081
|
return upb_pbdecoder_bytesparsed(this);
|
7200
7082
|
}
|
7201
|
-
inline
|
7202
|
-
return
|
7083
|
+
inline bool Decoder::ResetOutput(Sink* sink) {
|
7084
|
+
return upb_pbdecoder_resetoutput(this, sink);
|
7203
7085
|
}
|
7204
|
-
inline
|
7205
|
-
return
|
7086
|
+
inline BytesSink* Decoder::input() {
|
7087
|
+
return upb_pbdecoder_input(this);
|
7206
7088
|
}
|
7207
|
-
inline void Decoder::Reset() { upb_pbdecoder_reset(this); }
|
7208
7089
|
|
7209
7090
|
inline DecoderMethodOptions::DecoderMethodOptions(const Handlers* h) {
|
7210
7091
|
upb_pbdecodermethodopts_init(this, h);
|
@@ -7361,95 +7242,6 @@ typedef struct {
|
|
7361
7242
|
#endif
|
7362
7243
|
} mgroup;
|
7363
7244
|
|
7364
|
-
// The maximum that any submessages can be nested. Matches proto2's limit.
|
7365
|
-
// This specifies the size of the decoder's statically-sized array and therefore
|
7366
|
-
// setting it high will cause the upb::pb::Decoder object to be larger.
|
7367
|
-
//
|
7368
|
-
// If necessary we can add a runtime-settable property to Decoder that allow
|
7369
|
-
// this to be larger than the compile-time setting, but this would add
|
7370
|
-
// complexity, particularly since we would have to decide how/if to give users
|
7371
|
-
// the ability to set a custom memory allocation function.
|
7372
|
-
#define UPB_DECODER_MAX_NESTING 64
|
7373
|
-
|
7374
|
-
// Internal-only struct used by the decoder.
|
7375
|
-
typedef struct {
|
7376
|
-
// Space optimization note: we store two pointers here that the JIT
|
7377
|
-
// doesn't need at all; the upb_handlers* inside the sink and
|
7378
|
-
// the dispatch table pointer. We can optimze so that the JIT uses
|
7379
|
-
// smaller stack frames than the interpreter. The only thing we need
|
7380
|
-
// to guarantee is that the fallback routines can find end_ofs.
|
7381
|
-
upb_sink sink;
|
7382
|
-
|
7383
|
-
// The absolute stream offset of the end-of-frame delimiter.
|
7384
|
-
// Non-delimited frames (groups and non-packed repeated fields) reuse the
|
7385
|
-
// delimiter of their parent, even though the frame may not end there.
|
7386
|
-
//
|
7387
|
-
// NOTE: the JIT stores a slightly different value here for non-top frames.
|
7388
|
-
// It stores the value relative to the end of the enclosed message. But the
|
7389
|
-
// top frame is still stored the same way, which is important for ensuring
|
7390
|
-
// that calls from the JIT into C work correctly.
|
7391
|
-
uint64_t end_ofs;
|
7392
|
-
const uint32_t *base;
|
7393
|
-
|
7394
|
-
// 0 indicates a length-delimited field.
|
7395
|
-
// A positive number indicates a known group.
|
7396
|
-
// A negative number indicates an unknown group.
|
7397
|
-
int32_t groupnum;
|
7398
|
-
upb_inttable *dispatch; // Not used by the JIT.
|
7399
|
-
} upb_pbdecoder_frame;
|
7400
|
-
|
7401
|
-
struct upb_pbdecoder {
|
7402
|
-
upb_env *env;
|
7403
|
-
|
7404
|
-
// Our input sink.
|
7405
|
-
upb_bytessink input_;
|
7406
|
-
|
7407
|
-
// The decoder method we are parsing with (owned).
|
7408
|
-
const upb_pbdecodermethod *method_;
|
7409
|
-
|
7410
|
-
size_t call_len;
|
7411
|
-
const uint32_t *pc, *last;
|
7412
|
-
|
7413
|
-
// Current input buffer and its stream offset.
|
7414
|
-
const char *buf, *ptr, *end, *checkpoint;
|
7415
|
-
|
7416
|
-
// End of the delimited region, relative to ptr, or NULL if not in this buf.
|
7417
|
-
const char *delim_end;
|
7418
|
-
|
7419
|
-
// End of the delimited region, relative to ptr, or end if not in this buf.
|
7420
|
-
const char *data_end;
|
7421
|
-
|
7422
|
-
// Overall stream offset of "buf."
|
7423
|
-
uint64_t bufstart_ofs;
|
7424
|
-
|
7425
|
-
// Buffer for residual bytes not parsed from the previous buffer.
|
7426
|
-
// The maximum number of residual bytes we require is 12; a five-byte
|
7427
|
-
// unknown tag plus an eight-byte value, less one because the value
|
7428
|
-
// is only a partial value.
|
7429
|
-
char residual[12];
|
7430
|
-
char *residual_end;
|
7431
|
-
|
7432
|
-
// Stores the user buffer passed to our decode function.
|
7433
|
-
const char *buf_param;
|
7434
|
-
size_t size_param;
|
7435
|
-
const upb_bufhandle *handle;
|
7436
|
-
|
7437
|
-
// Our internal stack.
|
7438
|
-
upb_pbdecoder_frame *stack, *top, *limit;
|
7439
|
-
const uint32_t **callstack;
|
7440
|
-
size_t stack_size;
|
7441
|
-
|
7442
|
-
upb_status *status;
|
7443
|
-
|
7444
|
-
#ifdef UPB_USE_JIT_X64
|
7445
|
-
// Used momentarily by the generated code to store a value while a user
|
7446
|
-
// function is called.
|
7447
|
-
uint32_t tmp_len;
|
7448
|
-
|
7449
|
-
const void *saved_rsp;
|
7450
|
-
#endif
|
7451
|
-
};
|
7452
|
-
|
7453
7245
|
// Decoder entry points; used as handlers.
|
7454
7246
|
void *upb_pbdecoder_startbc(void *closure, const void *pc, size_t size_hint);
|
7455
7247
|
void *upb_pbdecoder_startjit(void *closure, const void *hd, size_t size_hint);
|
@@ -7717,42 +7509,101 @@ UPB_DECLARE_TYPE(upb::pb::Encoder, upb_pb_encoder);
|
|
7717
7509
|
|
7718
7510
|
/* upb::pb::Encoder ***********************************************************/
|
7719
7511
|
|
7720
|
-
//
|
7721
|
-
//
|
7722
|
-
//
|
7723
|
-
//
|
7724
|
-
|
7725
|
-
|
7726
|
-
|
7512
|
+
// The output buffer is divided into segments; a segment is a string of data
|
7513
|
+
// that is "ready to go" -- it does not need any varint lengths inserted into
|
7514
|
+
// the middle. The seams between segments are where varints will be inserted
|
7515
|
+
// once they are known.
|
7516
|
+
//
|
7517
|
+
// We also use the concept of a "run", which is a range of encoded bytes that
|
7518
|
+
// occur at a single submessage level. Every segment contains one or more runs.
|
7519
|
+
//
|
7520
|
+
// A segment can span messages. Consider:
|
7521
|
+
//
|
7522
|
+
// .--Submessage lengths---------.
|
7523
|
+
// | | |
|
7524
|
+
// | V V
|
7525
|
+
// V | |--------------- | |-----------------
|
7526
|
+
// Submessages: | |-----------------------------------------------
|
7527
|
+
// Top-level msg: ------------------------------------------------------------
|
7528
|
+
//
|
7529
|
+
// Segments: ----- ------------------- -----------------
|
7530
|
+
// Runs: *---- *--------------*--- *----------------
|
7531
|
+
// (* marks the start)
|
7532
|
+
//
|
7533
|
+
// Note that the top-level menssage is not in any segment because it does not
|
7534
|
+
// have any length preceding it.
|
7535
|
+
//
|
7536
|
+
// A segment is only interrupted when another length needs to be inserted. So
|
7537
|
+
// observe how the second segment spans both the inner submessage and part of
|
7538
|
+
// the next enclosing message.
|
7539
|
+
typedef struct {
|
7540
|
+
UPB_PRIVATE_FOR_CPP
|
7541
|
+
uint32_t msglen; // The length to varint-encode before this segment.
|
7542
|
+
uint32_t seglen; // Length of the segment.
|
7543
|
+
} upb_pb_encoder_segment;
|
7727
7544
|
|
7728
|
-
|
7545
|
+
UPB_DEFINE_CLASS0(upb::pb::Encoder,
|
7729
7546
|
public:
|
7730
|
-
|
7731
|
-
|
7732
|
-
|
7733
|
-
|
7547
|
+
Encoder(const upb::Handlers* handlers);
|
7548
|
+
~Encoder();
|
7549
|
+
|
7550
|
+
static reffed_ptr<const Handlers> NewHandlers(const upb::MessageDef* msg);
|
7551
|
+
|
7552
|
+
// Resets the state of the printer, so that it will expect to begin a new
|
7553
|
+
// document.
|
7554
|
+
void Reset();
|
7555
|
+
|
7556
|
+
// Resets the output pointer which will serve as our closure.
|
7557
|
+
void ResetOutput(BytesSink* output);
|
7734
7558
|
|
7735
7559
|
// The input to the encoder.
|
7736
7560
|
Sink* input();
|
7737
7561
|
|
7738
|
-
|
7739
|
-
|
7562
|
+
private:
|
7563
|
+
UPB_DISALLOW_COPY_AND_ASSIGN(Encoder);
|
7564
|
+
,
|
7565
|
+
UPB_DEFINE_STRUCT0(upb_pb_encoder, UPB_QUOTE(
|
7566
|
+
// Our input and output.
|
7567
|
+
upb_sink input_;
|
7568
|
+
upb_bytessink *output_;
|
7740
7569
|
|
7741
|
-
|
7570
|
+
// The "subclosure" -- used as the inner closure as part of the bytessink
|
7571
|
+
// protocol.
|
7572
|
+
void *subc;
|
7742
7573
|
|
7743
|
-
|
7744
|
-
|
7745
|
-
|
7574
|
+
// The output buffer and limit, and our current write position. "buf"
|
7575
|
+
// initially points to "initbuf", but is dynamically allocated if we need to
|
7576
|
+
// grow beyond the initial size.
|
7577
|
+
char *buf, *ptr, *limit;
|
7746
7578
|
|
7747
|
-
|
7579
|
+
// The beginning of the current run, or undefined if we are at the top level.
|
7580
|
+
char *runbegin;
|
7581
|
+
|
7582
|
+
// The list of segments we are accumulating.
|
7583
|
+
upb_pb_encoder_segment *segbuf, *segptr, *seglimit;
|
7584
|
+
|
7585
|
+
// The stack of enclosing submessages. Each entry in the stack points to the
|
7586
|
+
// segment where this submessage's length is being accumulated.
|
7587
|
+
int stack[UPB_PBENCODER_MAX_NESTING], *top, *stacklimit;
|
7588
|
+
|
7589
|
+
// Depth of startmsg/endmsg calls.
|
7590
|
+
int depth;
|
7591
|
+
|
7592
|
+
// Initial buffers for the output buffer and segment buffer. If we outgrow
|
7593
|
+
// these we will dynamically allocate bigger ones.
|
7594
|
+
char initbuf[256];
|
7595
|
+
upb_pb_encoder_segment seginitbuf[32];
|
7596
|
+
)));
|
7748
7597
|
|
7749
7598
|
UPB_BEGIN_EXTERN_C
|
7750
7599
|
|
7751
7600
|
const upb_handlers *upb_pb_encoder_newhandlers(const upb_msgdef *m,
|
7752
7601
|
const void *owner);
|
7602
|
+
void upb_pb_encoder_reset(upb_pb_encoder *e);
|
7753
7603
|
upb_sink *upb_pb_encoder_input(upb_pb_encoder *p);
|
7754
|
-
upb_pb_encoder
|
7755
|
-
|
7604
|
+
void upb_pb_encoder_init(upb_pb_encoder *e, const upb_handlers *h);
|
7605
|
+
void upb_pb_encoder_resetoutput(upb_pb_encoder *e, upb_bytessink *output);
|
7606
|
+
void upb_pb_encoder_uninit(upb_pb_encoder *e);
|
7756
7607
|
|
7757
7608
|
UPB_END_EXTERN_C
|
7758
7609
|
|
@@ -7760,9 +7611,17 @@ UPB_END_EXTERN_C
|
|
7760
7611
|
|
7761
7612
|
namespace upb {
|
7762
7613
|
namespace pb {
|
7763
|
-
inline Encoder
|
7764
|
-
|
7765
|
-
|
7614
|
+
inline Encoder::Encoder(const upb::Handlers* handlers) {
|
7615
|
+
upb_pb_encoder_init(this, handlers);
|
7616
|
+
}
|
7617
|
+
inline Encoder::~Encoder() {
|
7618
|
+
upb_pb_encoder_uninit(this);
|
7619
|
+
}
|
7620
|
+
inline void Encoder::Reset() {
|
7621
|
+
upb_pb_encoder_reset(this);
|
7622
|
+
}
|
7623
|
+
inline void Encoder::ResetOutput(BytesSink* output) {
|
7624
|
+
upb_pb_encoder_resetoutput(this, output);
|
7766
7625
|
}
|
7767
7626
|
inline Sink* Encoder::input() {
|
7768
7627
|
return upb_pb_encoder_input(this);
|
@@ -7880,51 +7739,58 @@ class TextPrinter;
|
|
7880
7739
|
|
7881
7740
|
UPB_DECLARE_TYPE(upb::pb::TextPrinter, upb_textprinter);
|
7882
7741
|
|
7883
|
-
|
7884
|
-
|
7885
|
-
class upb::pb::TextPrinter {
|
7742
|
+
UPB_DEFINE_CLASS0(upb::pb::TextPrinter,
|
7886
7743
|
public:
|
7887
7744
|
// The given handlers must have come from NewHandlers(). It must outlive the
|
7888
7745
|
// TextPrinter.
|
7889
|
-
|
7890
|
-
BytesSink *output);
|
7746
|
+
explicit TextPrinter(const upb::Handlers* handlers);
|
7891
7747
|
|
7892
7748
|
void SetSingleLineMode(bool single_line);
|
7893
7749
|
|
7750
|
+
bool ResetOutput(BytesSink* output);
|
7894
7751
|
Sink* input();
|
7895
7752
|
|
7896
7753
|
// If handler caching becomes a requirement we can add a code cache as in
|
7897
7754
|
// decoder.h
|
7898
7755
|
static reffed_ptr<const Handlers> NewHandlers(const MessageDef* md);
|
7899
|
-
};
|
7900
7756
|
|
7901
|
-
|
7757
|
+
private:
|
7758
|
+
,
|
7759
|
+
UPB_DEFINE_STRUCT0(upb_textprinter,
|
7760
|
+
upb_sink input_;
|
7761
|
+
upb_bytessink *output_;
|
7762
|
+
int indent_depth_;
|
7763
|
+
bool single_line_;
|
7764
|
+
void *subc;
|
7765
|
+
));
|
7902
7766
|
|
7903
|
-
UPB_BEGIN_EXTERN_C
|
7767
|
+
UPB_BEGIN_EXTERN_C // {
|
7904
7768
|
|
7905
7769
|
// C API.
|
7906
|
-
|
7907
|
-
|
7770
|
+
void upb_textprinter_init(upb_textprinter *p, const upb_handlers *h);
|
7771
|
+
void upb_textprinter_uninit(upb_textprinter *p);
|
7772
|
+
bool upb_textprinter_resetoutput(upb_textprinter *p, upb_bytessink *output);
|
7908
7773
|
void upb_textprinter_setsingleline(upb_textprinter *p, bool single_line);
|
7909
7774
|
upb_sink *upb_textprinter_input(upb_textprinter *p);
|
7910
7775
|
|
7911
7776
|
const upb_handlers *upb_textprinter_newhandlers(const upb_msgdef *m,
|
7912
7777
|
const void *owner);
|
7913
7778
|
|
7914
|
-
UPB_END_EXTERN_C
|
7779
|
+
UPB_END_EXTERN_C // }
|
7915
7780
|
|
7916
7781
|
#ifdef __cplusplus
|
7917
7782
|
|
7918
7783
|
namespace upb {
|
7919
7784
|
namespace pb {
|
7920
|
-
inline TextPrinter
|
7921
|
-
|
7922
|
-
BytesSink *output) {
|
7923
|
-
return upb_textprinter_create(env, handlers, output);
|
7785
|
+
inline TextPrinter::TextPrinter(const upb::Handlers* handlers) {
|
7786
|
+
upb_textprinter_init(this, handlers);
|
7924
7787
|
}
|
7925
7788
|
inline void TextPrinter::SetSingleLineMode(bool single_line) {
|
7926
7789
|
upb_textprinter_setsingleline(this, single_line);
|
7927
7790
|
}
|
7791
|
+
inline bool TextPrinter::ResetOutput(BytesSink* output) {
|
7792
|
+
return upb_textprinter_resetoutput(this, output);
|
7793
|
+
}
|
7928
7794
|
inline Sink* TextPrinter::input() {
|
7929
7795
|
return upb_textprinter_input(this);
|
7930
7796
|
}
|
@@ -7963,32 +7829,96 @@ class Parser;
|
|
7963
7829
|
|
7964
7830
|
UPB_DECLARE_TYPE(upb::json::Parser, upb_json_parser);
|
7965
7831
|
|
7966
|
-
|
7832
|
+
// Internal-only struct used by the parser. A parser frame corresponds
|
7833
|
+
// one-to-one with a handler (sink) frame.
|
7834
|
+
typedef struct {
|
7835
|
+
UPB_PRIVATE_FOR_CPP
|
7836
|
+
upb_sink sink;
|
7837
|
+
// The current message in which we're parsing, and the field whose value we're
|
7838
|
+
// expecting next.
|
7839
|
+
const upb_msgdef *m;
|
7840
|
+
const upb_fielddef *f;
|
7841
|
+
|
7842
|
+
// We are in a repeated-field context, ready to emit mapentries as
|
7843
|
+
// submessages. This flag alters the start-of-object (open-brace) behavior to
|
7844
|
+
// begin a sequence of mapentry messages rather than a single submessage.
|
7845
|
+
bool is_map;
|
7846
|
+
// We are in a map-entry message context. This flag is set when parsing the
|
7847
|
+
// value field of a single map entry and indicates to all value-field parsers
|
7848
|
+
// (subobjects, strings, numbers, and bools) that the map-entry submessage
|
7849
|
+
// should end as soon as the value is parsed.
|
7850
|
+
bool is_mapentry;
|
7851
|
+
// If |is_map| or |is_mapentry| is true, |mapfield| refers to the parent
|
7852
|
+
// message's map field that we're currently parsing. This differs from |f|
|
7853
|
+
// because |f| is the field in the *current* message (i.e., the map-entry
|
7854
|
+
// message itself), not the parent's field that leads to this map.
|
7855
|
+
const upb_fielddef *mapfield;
|
7856
|
+
} upb_jsonparser_frame;
|
7967
7857
|
|
7968
|
-
// Preallocation hint: parser won't allocate more bytes than this when first
|
7969
|
-
// constructed. This hint may be an overestimate for some build configurations.
|
7970
|
-
// But if the parser library is upgraded without recompiling the application,
|
7971
|
-
// it may be an underestimate.
|
7972
|
-
#define UPB_JSON_PARSER_SIZE 3568
|
7973
7858
|
|
7974
|
-
|
7859
|
+
/* upb::json::Parser **********************************************************/
|
7860
|
+
|
7861
|
+
#define UPB_JSON_MAX_DEPTH 64
|
7975
7862
|
|
7976
7863
|
// Parses an incoming BytesStream, pushing the results to the destination sink.
|
7977
|
-
|
7864
|
+
UPB_DEFINE_CLASS0(upb::json::Parser,
|
7978
7865
|
public:
|
7979
|
-
|
7866
|
+
Parser(Status* status);
|
7867
|
+
~Parser();
|
7868
|
+
|
7869
|
+
// Resets the state of the printer, so that it will expect to begin a new
|
7870
|
+
// document.
|
7871
|
+
void Reset();
|
7980
7872
|
|
7873
|
+
// Resets the output pointer which will serve as our closure. Implies
|
7874
|
+
// Reset().
|
7875
|
+
void ResetOutput(Sink* output);
|
7876
|
+
|
7877
|
+
// The input to the printer.
|
7981
7878
|
BytesSink* input();
|
7879
|
+
,
|
7880
|
+
UPB_DEFINE_STRUCT0(upb_json_parser,
|
7881
|
+
upb_byteshandler input_handler_;
|
7882
|
+
upb_bytessink input_;
|
7982
7883
|
|
7983
|
-
|
7984
|
-
|
7985
|
-
|
7884
|
+
// Stack to track the JSON scopes we are in.
|
7885
|
+
upb_jsonparser_frame stack[UPB_JSON_MAX_DEPTH];
|
7886
|
+
upb_jsonparser_frame *top;
|
7887
|
+
upb_jsonparser_frame *limit;
|
7986
7888
|
|
7987
|
-
|
7889
|
+
upb_status *status;
|
7890
|
+
|
7891
|
+
// Ragel's internal parsing stack for the parsing state machine.
|
7892
|
+
int current_state;
|
7893
|
+
int parser_stack[UPB_JSON_MAX_DEPTH];
|
7894
|
+
int parser_top;
|
7895
|
+
|
7896
|
+
// The handle for the current buffer.
|
7897
|
+
const upb_bufhandle *handle;
|
7898
|
+
|
7899
|
+
// Accumulate buffer. See details in parser.rl.
|
7900
|
+
const char *accumulated;
|
7901
|
+
size_t accumulated_len;
|
7902
|
+
char *accumulate_buf;
|
7903
|
+
size_t accumulate_buf_size;
|
7904
|
+
|
7905
|
+
// Multi-part text data. See details in parser.rl.
|
7906
|
+
int multipart_state;
|
7907
|
+
upb_selector_t string_selector;
|
7908
|
+
|
7909
|
+
// Input capture. See details in parser.rl.
|
7910
|
+
const char *capture;
|
7911
|
+
|
7912
|
+
// Intermediate result of parsing a unicode escape sequence.
|
7913
|
+
uint32_t digit;
|
7914
|
+
));
|
7988
7915
|
|
7989
7916
|
UPB_BEGIN_EXTERN_C
|
7990
7917
|
|
7991
|
-
|
7918
|
+
void upb_json_parser_init(upb_json_parser *p, upb_status *status);
|
7919
|
+
void upb_json_parser_uninit(upb_json_parser *p);
|
7920
|
+
void upb_json_parser_reset(upb_json_parser *p);
|
7921
|
+
void upb_json_parser_resetoutput(upb_json_parser *p, upb_sink *output);
|
7992
7922
|
upb_bytessink *upb_json_parser_input(upb_json_parser *p);
|
7993
7923
|
|
7994
7924
|
UPB_END_EXTERN_C
|
@@ -7997,8 +7927,11 @@ UPB_END_EXTERN_C
|
|
7997
7927
|
|
7998
7928
|
namespace upb {
|
7999
7929
|
namespace json {
|
8000
|
-
inline Parser
|
8001
|
-
|
7930
|
+
inline Parser::Parser(Status* status) { upb_json_parser_init(this, status); }
|
7931
|
+
inline Parser::~Parser() { upb_json_parser_uninit(this); }
|
7932
|
+
inline void Parser::Reset() { upb_json_parser_reset(this); }
|
7933
|
+
inline void Parser::ResetOutput(Sink* output) {
|
7934
|
+
upb_json_parser_resetoutput(this, output);
|
8002
7935
|
}
|
8003
7936
|
inline BytesSink* Parser::input() {
|
8004
7937
|
return upb_json_parser_input(this);
|
@@ -8037,48 +7970,71 @@ UPB_DECLARE_TYPE(upb::json::Printer, upb_json_printer);
|
|
8037
7970
|
|
8038
7971
|
/* upb::json::Printer *********************************************************/
|
8039
7972
|
|
8040
|
-
#define UPB_JSON_PRINTER_SIZE 168
|
8041
|
-
|
8042
|
-
#ifdef __cplusplus
|
8043
|
-
|
8044
7973
|
// Prints an incoming stream of data to a BytesSink in JSON format.
|
8045
|
-
|
7974
|
+
UPB_DEFINE_CLASS0(upb::json::Printer,
|
8046
7975
|
public:
|
8047
|
-
|
8048
|
-
|
7976
|
+
Printer(const upb::Handlers* handlers);
|
7977
|
+
~Printer();
|
7978
|
+
|
7979
|
+
// Resets the state of the printer, so that it will expect to begin a new
|
7980
|
+
// document.
|
7981
|
+
void Reset();
|
7982
|
+
|
7983
|
+
// Resets the output pointer which will serve as our closure. Implies
|
7984
|
+
// Reset().
|
7985
|
+
void ResetOutput(BytesSink* output);
|
8049
7986
|
|
8050
7987
|
// The input to the printer.
|
8051
7988
|
Sink* input();
|
8052
7989
|
|
8053
7990
|
// Returns handlers for printing according to the specified schema.
|
8054
7991
|
static reffed_ptr<const Handlers> NewHandlers(const upb::MessageDef* md);
|
7992
|
+
,
|
7993
|
+
UPB_DEFINE_STRUCT0(upb_json_printer,
|
7994
|
+
upb_sink input_;
|
7995
|
+
// BytesSink closure.
|
7996
|
+
void *subc_;
|
7997
|
+
upb_bytessink *output_;
|
7998
|
+
|
7999
|
+
// We track the depth so that we know when to emit startstr/endstr on the
|
8000
|
+
// output.
|
8001
|
+
int depth_;
|
8002
|
+
// Have we emitted the first element? This state is necessary to emit commas
|
8003
|
+
// without leaving a trailing comma in arrays/maps. We keep this state per
|
8004
|
+
// frame depth.
|
8005
|
+
//
|
8006
|
+
// Why max_depth * 2? UPB_MAX_HANDLER_DEPTH counts depth as nested messages.
|
8007
|
+
// We count frames (contexts in which we separate elements by commas) as both
|
8008
|
+
// repeated fields and messages (maps), and the worst case is a
|
8009
|
+
// message->repeated field->submessage->repeated field->... nesting.
|
8010
|
+
bool first_elem_[UPB_MAX_HANDLER_DEPTH * 2];
|
8011
|
+
));
|
8055
8012
|
|
8056
|
-
|
8057
|
-
|
8058
|
-
private:
|
8059
|
-
UPB_DISALLOW_POD_OPS(Printer, upb::json::Printer);
|
8060
|
-
};
|
8061
|
-
|
8062
|
-
#endif
|
8063
|
-
|
8064
|
-
UPB_BEGIN_EXTERN_C
|
8013
|
+
UPB_BEGIN_EXTERN_C // {
|
8065
8014
|
|
8066
8015
|
// Native C API.
|
8067
|
-
|
8068
|
-
|
8016
|
+
|
8017
|
+
void upb_json_printer_init(upb_json_printer *p, const upb_handlers *h);
|
8018
|
+
void upb_json_printer_uninit(upb_json_printer *p);
|
8019
|
+
void upb_json_printer_reset(upb_json_printer *p);
|
8020
|
+
void upb_json_printer_resetoutput(upb_json_printer *p, upb_bytessink *output);
|
8069
8021
|
upb_sink *upb_json_printer_input(upb_json_printer *p);
|
8070
8022
|
const upb_handlers *upb_json_printer_newhandlers(const upb_msgdef *md,
|
8071
8023
|
const void *owner);
|
8072
8024
|
|
8073
|
-
UPB_END_EXTERN_C
|
8025
|
+
UPB_END_EXTERN_C // }
|
8074
8026
|
|
8075
8027
|
#ifdef __cplusplus
|
8076
8028
|
|
8077
8029
|
namespace upb {
|
8078
8030
|
namespace json {
|
8079
|
-
inline Printer
|
8080
|
-
|
8081
|
-
|
8031
|
+
inline Printer::Printer(const upb::Handlers* handlers) {
|
8032
|
+
upb_json_printer_init(this, handlers);
|
8033
|
+
}
|
8034
|
+
inline Printer::~Printer() { upb_json_printer_uninit(this); }
|
8035
|
+
inline void Printer::Reset() { upb_json_printer_reset(this); }
|
8036
|
+
inline void Printer::ResetOutput(BytesSink* output) {
|
8037
|
+
upb_json_printer_resetoutput(this, output);
|
8082
8038
|
}
|
8083
8039
|
inline Sink* Printer::input() { return upb_json_printer_input(this); }
|
8084
8040
|
inline reffed_ptr<const Handlers> Printer::NewHandlers(
|