Protocol Buffers - Google's data interchange format (grpc依赖) https://developers.google.com/protocol-buffers/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

224 lines
7.6 KiB

// Protocol Buffers - Google's data interchange format
// Copyright 2024 Google LLC. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd
#include "upb/text/debug_string.h"
#include <inttypes.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "upb/base/descriptor_constants.h"
#include "upb/message/array.h"
#include "upb/message/internal/iterator.h"
#include "upb/message/internal/map_entry.h"
#include "upb/message/internal/map_sorter.h"
#include "upb/message/map.h"
#include "upb/message/message.h"
#include "upb/message/value.h"
#include "upb/mini_table/extension.h"
#include "upb/mini_table/field.h"
#include "upb/mini_table/internal/field.h"
#include "upb/mini_table/internal/message.h"
#include "upb/mini_table/message.h"
#include "upb/text/internal/encode.h"
// Must be last.
#include "upb/port/def.inc"
static void _upb_MessageDebugString(txtenc* e, const upb_Message* msg,
const upb_MiniTable* mt);
static void _upb_FieldDebugString(txtenc* e, upb_MessageValue val,
const upb_MiniTableField* f,
const upb_MiniTable* mt, const char* label,
const upb_MiniTableExtension* ext) {
UPB_PRIVATE(_upb_TextEncode_Indent)(e);
const upb_CType ctype = upb_MiniTableField_CType(f);
const bool is_ext = upb_MiniTableField_IsExtension(f);
char number[10]; // A 32-bit integer can hold up to 10 digits.
snprintf(number, sizeof(number), "%" PRIu32, upb_MiniTableField_Number(f));
// label is to pass down whether we're dealing with a "key" of a map or
// a "value" of a map.
if (!label) label = number;
if (is_ext) {
UPB_PRIVATE(_upb_TextEncode_Printf)(e, "[%s]", label);
} else {
UPB_PRIVATE(_upb_TextEncode_Printf)(e, "%s", label);
}
if (ctype == kUpb_CType_Message) {
UPB_PRIVATE(_upb_TextEncode_Printf)(e, " {");
UPB_PRIVATE(_upb_TextEncode_EndField)(e);
e->indent_depth++;
const upb_MiniTable* subm = ext ? upb_MiniTableExtension_GetSubMessage(ext)
: upb_MiniTable_SubMessage(mt, f);
_upb_MessageDebugString(e, val.msg_val, subm);
e->indent_depth--;
UPB_PRIVATE(_upb_TextEncode_Indent)(e);
UPB_PRIVATE(_upb_TextEncode_PutStr)(e, "}");
UPB_PRIVATE(_upb_TextEncode_EndField)(e);
return;
}
UPB_PRIVATE(_upb_TextEncode_Printf)(e, ": ");
if (ctype ==
kUpb_CType_Enum) { // Enum has to be processed separately because of
// divergent behavior between encoders
UPB_PRIVATE(_upb_TextEncode_Printf)(e, "%" PRId32, val.int32_val);
} else {
UPB_PRIVATE(_upb_TextEncode_Scalar)(e, val, ctype);
}
UPB_PRIVATE(_upb_TextEncode_EndField)(e);
}
/*
* Arrays print as simple repeated elements, eg.
*
* 5: 1
* 5: 2
* 5: 3
*/
static void _upb_ArrayDebugString(txtenc* e, const upb_Array* arr,
const upb_MiniTableField* f,
const upb_MiniTable* mt,
const upb_MiniTableExtension* ext) {
for (size_t i = 0, n = upb_Array_Size(arr); i < n; i++) {
_upb_FieldDebugString(e, upb_Array_Get(arr, i), f, mt, NULL, ext);
}
}
static void _upb_MapEntryDebugString(txtenc* e, upb_MessageValue key,
upb_MessageValue val,
const upb_MiniTableField* f,
const upb_MiniTable* mt) {
const upb_MiniTable* entry = upb_MiniTable_SubMessage(mt, f);
const upb_MiniTableField* key_f = upb_MiniTable_MapKey(entry);
const upb_MiniTableField* val_f = upb_MiniTable_MapValue(entry);
UPB_PRIVATE(_upb_TextEncode_Indent)(e);
UPB_PRIVATE(_upb_TextEncode_Printf)(e, "%u {", upb_MiniTableField_Number(f));
UPB_PRIVATE(_upb_TextEncode_EndField)(e);
e->indent_depth++;
_upb_FieldDebugString(e, key, key_f, entry, "key", NULL);
_upb_FieldDebugString(e, val, val_f, entry, "value", NULL);
e->indent_depth--;
UPB_PRIVATE(_upb_TextEncode_Indent)(e);
UPB_PRIVATE(_upb_TextEncode_PutStr)(e, "}");
UPB_PRIVATE(_upb_TextEncode_EndField)(e);
}
/*
* Maps print as messages of key/value, etc.
*
* 1 {
* key: "abc"
* value: 123
* }
* 2 {
* key: "def"
* value: 456
* }
*/
static void _upb_MapDebugString(txtenc* e, const upb_Map* map,
const upb_MiniTableField* f,
const upb_MiniTable* mt) {
if (e->options & UPB_TXTENC_NOSORT) {
size_t iter = kUpb_Map_Begin;
upb_MessageValue key, val;
while (upb_Map_Next(map, &key, &val, &iter)) {
_upb_MapEntryDebugString(e, key, val, f, mt);
}
} else {
if (upb_Map_Size(map) == 0) return;
const upb_MiniTable* entry = upb_MiniTable_SubMessage(mt, f);
const upb_MiniTableField* key_f = upb_MiniTable_GetFieldByIndex(entry, 0);
_upb_sortedmap sorted;
upb_MapEntry ent;
_upb_mapsorter_pushmap(&e->sorter, upb_MiniTableField_Type(key_f), map,
&sorted);
while (_upb_sortedmap_next(&e->sorter, map, &sorted, &ent)) {
upb_MessageValue key, val;
memcpy(&key, &ent.k, sizeof(key));
memcpy(&val, &ent.v, sizeof(val));
_upb_MapEntryDebugString(e, key, val, f, mt);
}
_upb_mapsorter_popmap(&e->sorter, &sorted);
}
}
static void _upb_MessageDebugString(txtenc* e, const upb_Message* msg,
const upb_MiniTable* mt) {
size_t iter = kUpb_BaseField_Begin;
const upb_MiniTableField* f;
upb_MessageValue val;
// Base fields will be printed out first, followed by extension fields, and
// finally unknown fields.
while (UPB_PRIVATE(_upb_Message_NextBaseField)(msg, mt, &f, &val, &iter)) {
if (upb_MiniTableField_IsMap(f)) {
_upb_MapDebugString(e, val.map_val, f, mt);
} else if (upb_MiniTableField_IsArray(f)) {
// ext set to NULL as we're not dealing with extensions yet
_upb_ArrayDebugString(e, val.array_val, f, mt, NULL);
} else {
// ext set to NULL as we're not dealing with extensions yet
// label set to NULL as we're not currently working with a MapEntry
_upb_FieldDebugString(e, val, f, mt, NULL, NULL);
}
}
const upb_MiniTableExtension* ext;
upb_MessageValue val_ext;
iter = kUpb_Extension_Begin;
while (
UPB_PRIVATE(_upb_Message_NextExtension)(msg, mt, &ext, &val_ext, &iter)) {
const upb_MiniTableField* f = &ext->UPB_PRIVATE(field);
// It is not sufficient to only pass |f| as we lose valuable information
// about sub-messages. It is required that we pass |ext|.
if (upb_MiniTableField_IsMap(f)) {
UPB_UNREACHABLE(); // Maps cannot be extensions.
break;
} else if (upb_MiniTableField_IsArray(f)) {
_upb_ArrayDebugString(e, val_ext.array_val, f, mt, ext);
} else {
// label set to NULL as we're not currently working with a MapEntry
_upb_FieldDebugString(e, val_ext, f, mt, NULL, ext);
}
}
UPB_PRIVATE(_upb_TextEncode_ParseUnknown)(e, msg);
}
size_t upb_DebugString(const upb_Message* msg, const upb_MiniTable* mt,
int options, char* buf, size_t size) {
txtenc e;
e.buf = buf;
e.ptr = buf;
e.end = UPB_PTRADD(buf, size);
e.overflow = 0;
e.indent_depth = 0;
e.options = options;
e.ext_pool = NULL;
_upb_mapsorter_init(&e.sorter);
_upb_MessageDebugString(&e, msg, mt);
_upb_mapsorter_destroy(&e.sorter);
return UPB_PRIVATE(_upb_TextEncode_Nullz)(&e, size);
}