@ -182,11 +182,19 @@ static bool putkey(void *closure, const void *handler_data) {
return true ; \
} \
static bool repeated_ # # type ( void * closure , const void * handler_data , \
type val ) { \
type val ) { \
upb_json_printer * p = closure ; \
print_comma ( p ) ; \
CHK ( put # # type ( closure , handler_data , val ) ) ; \
return true ; \
} \
static bool putmapkey_ # # type ( void * closure , const void * handler_data , \
type val ) { \
upb_json_printer * p = closure ; \
print_data ( p , " \" " , 1 ) ; \
CHK ( put # # type ( closure , handler_data , val ) ) ; \
print_data ( p , " \" : " , 2 ) ; \
return true ; \
}
TYPE_HANDLERS ( double , fmt_double ) ;
@ -222,20 +230,36 @@ static bool scalar_enum(void *closure, const void *handler_data,
return true ;
}
static bool repeated_enum ( void * closure , const void * handler_data ,
int32_t val ) {
const EnumHandlerData * hd = handler_data ;
upb_json_printer * p = closure ;
print_comma ( p ) ;
const char * symbolic_name = upb_enumdef_iton ( hd - > enumdef , val ) ;
static void print_enum_symbolic_name ( upb_json_printer * p ,
const upb_enumdef * def ,
int32_t val ) {
const char * symbolic_name = upb_enumdef_iton ( def , val ) ;
if ( symbolic_name ) {
print_data ( p , " \" " , 1 ) ;
putstring ( p , symbolic_name , strlen ( symbolic_name ) ) ;
print_data ( p , " \" " , 1 ) ;
} else {
putint32_t ( closure , NULL , val ) ;
putint32_t ( p , NULL , val ) ;
}
}
static bool repeated_enum ( void * closure , const void * handler_data ,
int32_t val ) {
const EnumHandlerData * hd = handler_data ;
upb_json_printer * p = closure ;
print_comma ( p ) ;
print_enum_symbolic_name ( p , hd - > enumdef , val ) ;
return true ;
}
static bool mapvalue_enum ( void * closure , const void * handler_data ,
int32_t val ) {
const EnumHandlerData * hd = handler_data ;
upb_json_printer * p = closure ;
print_enum_symbolic_name ( p , hd - > enumdef , val ) ;
return true ;
}
@ -251,25 +275,35 @@ static void *repeated_startsubmsg(void *closure, const void *handler_data) {
return closure ;
}
static bool startmap ( void * closure , const void * handler_data ) {
static void start_frame ( upb_json_printer * p ) {
p - > depth_ + + ;
p - > first_elem_ [ p - > depth_ ] = true ;
print_data ( p , " { " , 1 ) ;
}
static void end_frame ( upb_json_printer * p ) {
print_data ( p , " } " , 1 ) ;
p - > depth_ - - ;
}
static bool printer_startmsg ( void * closure , const void * handler_data ) {
UPB_UNUSED ( handler_data ) ;
upb_json_printer * p = closure ;
if ( p - > depth_ + + = = 0 ) {
if ( p - > depth_ = = 0 ) {
upb_bytessink_start ( p - > output_ , 0 , & p - > subc_ ) ;
}
p - > first_elem_ [ p - > depth_ ] = true ;
print_data ( p , " { " , 1 ) ;
start_frame ( p ) ;
return true ;
}
static bool endmap ( void * closure , const void * handler_data , upb_status * s ) {
static bool printer_endmsg ( void * closure , const void * handler_data , upb_status * s ) {
UPB_UNUSED ( handler_data ) ;
UPB_UNUSED ( s ) ;
upb_json_printer * p = closure ;
if ( - - p - > depth_ = = 0 ) {
end_frame ( p ) ;
if ( p - > depth_ = = 0 ) {
upb_bytessink_end ( p - > output_ ) ;
}
print_data ( p , " } " , 1 ) ;
return true ;
}
@ -290,6 +324,23 @@ static bool endseq(void *closure, const void *handler_data) {
return true ;
}
static void * startmap ( void * closure , const void * handler_data ) {
upb_json_printer * p = closure ;
CHK ( putkey ( closure , handler_data ) ) ;
p - > depth_ + + ;
p - > first_elem_ [ p - > depth_ ] = true ;
print_data ( p , " { " , 1 ) ;
return closure ;
}
static bool endmap ( void * closure , const void * handler_data ) {
UPB_UNUSED ( handler_data ) ;
upb_json_printer * p = closure ;
print_data ( p , " } " , 1 ) ;
p - > depth_ - - ;
return true ;
}
static size_t putstr ( void * closure , const void * handler_data , const char * str ,
size_t len , const upb_bufhandle * handle ) {
UPB_UNUSED ( handler_data ) ;
@ -404,6 +455,36 @@ static bool repeated_endstr(void *closure, const void *handler_data) {
return true ;
}
static void * mapkeyval_startstr ( void * closure , const void * handler_data ,
size_t size_hint ) {
UPB_UNUSED ( handler_data ) ;
UPB_UNUSED ( size_hint ) ;
upb_json_printer * p = closure ;
print_data ( p , " \" " , 1 ) ;
return p ;
}
static size_t mapkey_str ( void * closure , const void * handler_data ,
const char * str , size_t len ,
const upb_bufhandle * handle ) {
CHK ( putstr ( closure , handler_data , str , len , handle ) ) ;
return len ;
}
static bool mapkey_endstr ( void * closure , const void * handler_data ) {
UPB_UNUSED ( handler_data ) ;
upb_json_printer * p = closure ;
print_data ( p , " \" : " , 2 ) ;
return true ;
}
static bool mapvalue_endstr ( void * closure , const void * handler_data ) {
UPB_UNUSED ( handler_data ) ;
upb_json_printer * p = closure ;
print_data ( p , " \" " , 1 ) ;
return true ;
}
static size_t scalar_bytes ( void * closure , const void * handler_data ,
const char * str , size_t len ,
const upb_bufhandle * handle ) {
@ -421,31 +502,161 @@ static size_t repeated_bytes(void *closure, const void *handler_data,
return len ;
}
void printer_sethandlers ( const void * closure , upb_handlers * h ) {
static size_t mapkey_bytes ( void * closure , const void * handler_data ,
const char * str , size_t len ,
const upb_bufhandle * handle ) {
upb_json_printer * p = closure ;
CHK ( putbytes ( closure , handler_data , str , len , handle ) ) ;
print_data ( p , " : " , 1 ) ;
return len ;
}
static void set_enum_hd ( upb_handlers * h ,
const upb_fielddef * f ,
upb_handlerattr * attr ) {
EnumHandlerData * hd = malloc ( sizeof ( EnumHandlerData ) ) ;
hd - > enumdef = ( const upb_enumdef * ) upb_fielddef_subdef ( f ) ;
hd - > keyname = newstrpc ( h , f ) ;
upb_handlers_addcleanup ( h , hd , free ) ;
upb_handlerattr_sethandlerdata ( attr , hd ) ;
}
// Set up handlers for a mapentry submessage (i.e., an individual key/value pair
// in a map).
//
// TODO: Handle missing key, missing value, out-of-order key/value, or repeated
// key or value cases properly. The right way to do this is to allocate a
// temporary structure at the start of a mapentry submessage, store key and
// value data in it as key and value handlers are called, and then print the
// key/value pair once at the end of the submessage. If we don't do this, we
// should at least detect the case and throw an error. However, so far all of
// our sources that emit mapentry messages do so canonically (with one key
// field, and then one value field), so this is not a pressing concern at the
// moment.
void printer_sethandlers_mapentry ( const void * closure , upb_handlers * h ) {
UPB_UNUSED ( closure ) ;
const upb_msgdef * md = upb_handlers_msgdef ( h ) ;
// A mapentry message is printed simply as '"key": value'. Rather than
// special-case key and value for every type below, we just handle both
// fields explicitly here.
const upb_fielddef * key_field = upb_msgdef_itof ( md , UPB_MAPENTRY_KEY ) ;
const upb_fielddef * value_field = upb_msgdef_itof ( md , UPB_MAPENTRY_VALUE ) ;
upb_handlerattr empty_attr = UPB_HANDLERATTR_INITIALIZER ;
upb_handlers_setstartmsg ( h , startmap , & empty_attr ) ;
upb_handlers_setendmsg ( h , endmap , & empty_attr ) ;
# define TYPE(type, name, ctype) \
case type : \
if ( upb_fielddef_isseq ( f ) ) { \
upb_handlers_set # # name ( h , f , repeated_ # # ctype , & empty_attr ) ; \
} else { \
upb_handlers_set # # name ( h , f , scalar_ # # ctype , & name_attr ) ; \
} \
switch ( upb_fielddef_type ( key_field ) ) {
case UPB_TYPE_INT32 :
upb_handlers_setint32 ( h , key_field , putmapkey_int32_t , & empty_attr ) ;
break ;
case UPB_TYPE_INT64 :
upb_handlers_setint64 ( h , key_field , putmapkey_int64_t , & empty_attr ) ;
break ;
case UPB_TYPE_UINT32 :
upb_handlers_setuint32 ( h , key_field , putmapkey_uint32_t , & empty_attr ) ;
break ;
case UPB_TYPE_UINT64 :
upb_handlers_setuint64 ( h , key_field , putmapkey_uint64_t , & empty_attr ) ;
break ;
case UPB_TYPE_BOOL :
upb_handlers_setbool ( h , key_field , putmapkey_bool , & empty_attr ) ;
break ;
case UPB_TYPE_STRING :
upb_handlers_setstartstr ( h , key_field , mapkeyval_startstr , & empty_attr ) ;
upb_handlers_setstring ( h , key_field , mapkey_str , & empty_attr ) ;
upb_handlers_setendstr ( h , key_field , mapkey_endstr , & empty_attr ) ;
break ;
case UPB_TYPE_BYTES :
upb_handlers_setstring ( h , key_field , mapkey_bytes , & empty_attr ) ;
break ;
default :
assert ( false ) ;
break ;
}
switch ( upb_fielddef_type ( value_field ) ) {
case UPB_TYPE_INT32 :
upb_handlers_setint32 ( h , value_field , putint32_t , & empty_attr ) ;
break ;
case UPB_TYPE_INT64 :
upb_handlers_setint64 ( h , value_field , putint64_t , & empty_attr ) ;
break ;
case UPB_TYPE_UINT32 :
upb_handlers_setuint32 ( h , value_field , putuint32_t , & empty_attr ) ;
break ;
case UPB_TYPE_UINT64 :
upb_handlers_setuint64 ( h , value_field , putuint64_t , & empty_attr ) ;
break ;
case UPB_TYPE_BOOL :
upb_handlers_setbool ( h , value_field , putbool , & empty_attr ) ;
break ;
case UPB_TYPE_FLOAT :
upb_handlers_setfloat ( h , value_field , putfloat , & empty_attr ) ;
break ;
case UPB_TYPE_DOUBLE :
upb_handlers_setdouble ( h , value_field , putdouble , & empty_attr ) ;
break ;
case UPB_TYPE_STRING :
upb_handlers_setstartstr ( h , value_field , mapkeyval_startstr , & empty_attr ) ;
upb_handlers_setstring ( h , value_field , putstr , & empty_attr ) ;
upb_handlers_setendstr ( h , value_field , mapvalue_endstr , & empty_attr ) ;
break ;
case UPB_TYPE_BYTES :
upb_handlers_setstring ( h , value_field , putbytes , & empty_attr ) ;
break ;
case UPB_TYPE_ENUM : {
upb_handlerattr enum_attr = UPB_HANDLERATTR_INITIALIZER ;
set_enum_hd ( h , value_field , & enum_attr ) ;
upb_handlers_setint32 ( h , value_field , mapvalue_enum , & enum_attr ) ;
upb_handlerattr_uninit ( & enum_attr ) ;
break ;
}
case UPB_TYPE_MESSAGE :
// No handler necessary -- the submsg handlers will print the message
// as appropriate.
break ;
}
upb_handlerattr_uninit ( & empty_attr ) ;
}
void printer_sethandlers ( const void * closure , upb_handlers * h ) {
UPB_UNUSED ( closure ) ;
const upb_msgdef * md = upb_handlers_msgdef ( h ) ;
bool is_mapentry = upb_msgdef_mapentry ( md ) ;
upb_handlerattr empty_attr = UPB_HANDLERATTR_INITIALIZER ;
if ( is_mapentry ) {
// mapentry messages are sufficiently different that we handle them
// separately.
printer_sethandlers_mapentry ( closure , h ) ;
return ;
}
upb_handlers_setstartmsg ( h , printer_startmsg , & empty_attr ) ;
upb_handlers_setendmsg ( h , printer_endmsg , & empty_attr ) ;
# define TYPE(type, name, ctype) \
case type : \
if ( upb_fielddef_isseq ( f ) ) { \
upb_handlers_set # # name ( h , f , repeated_ # # ctype , & empty_attr ) ; \
} else { \
upb_handlers_set # # name ( h , f , scalar_ # # ctype , & name_attr ) ; \
} \
break ;
upb_msg_field_iter i ;
upb_msg_field_begin ( & i , upb_handlers_msgdef ( h ) ) ;
upb_msg_field_begin ( & i , md ) ;
for ( ; ! upb_msg_field_done ( & i ) ; upb_msg_field_next ( & i ) ) {
const upb_fielddef * f = upb_msg_iter_field ( & i ) ;
upb_handlerattr name_attr = UPB_HANDLERATTR_INITIALIZER ;
upb_handlerattr_sethandlerdata ( & name_attr , newstrpc ( h , f ) ) ;
if ( upb_fielddef_isseq ( f ) ) {
if ( upb_fielddef_ismap ( f ) ) {
upb_handlers_setstartseq ( h , f , startmap , & name_attr ) ;
upb_handlers_setendseq ( h , f , endmap , & name_attr ) ;
} else if ( upb_fielddef_isseq ( f ) ) {
upb_handlers_setstartseq ( h , f , startseq , & name_attr ) ;
upb_handlers_setendseq ( h , f , endseq , & empty_attr ) ;
}
@ -462,12 +673,8 @@ void printer_sethandlers(const void *closure, upb_handlers *h) {
// For now, we always emit symbolic names for enums. We may want an
// option later to control this behavior, but we will wait for a real
// need first.
EnumHandlerData * hd = malloc ( sizeof ( EnumHandlerData ) ) ;
hd - > enumdef = ( const upb_enumdef * ) upb_fielddef_subdef ( f ) ;
hd - > keyname = newstrpc ( h , f ) ;
upb_handlers_addcleanup ( h , hd , free ) ;
upb_handlerattr enum_attr = UPB_HANDLERATTR_INITIALIZER ;
upb_handlerattr_sethandlerdata ( & enum_attr , hd ) ;
set_enum_hd ( h , f , & enum_attr ) ;
if ( upb_fielddef_isseq ( f ) ) {
upb_handlers_setint32 ( h , f , repeated_enum , & enum_attr ) ;
Chris Fallin
10 years ago