THUAI6/CAPI/cpp/grpc/include/upb/upb.h

/*
 * Copyright (c) 2009-2021, Google LLC
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of Google LLC nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * This file contains shared definitions that are widely used across upb.
 */

#ifndef UPB_H_
#define UPB_H_

#include <assert.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>

// TODO(b/232091617): Remove these and fix everything that breaks as a result.
#include "upb/arena.h"
#include "upb/status.h"

// Must be last.
#include "upb/port_def.inc"

#ifdef __cplusplus
extern "C"
{
#endif

    /** upb_StringView ************************************************************/

    typedef struct
    {
        const char* data;
        size_t size;
    } upb_StringView;

    UPB_INLINE upb_StringView upb_StringView_FromDataAndSize(const char* data, size_t size)
    {
        upb_StringView ret;
        ret.data = data;
        ret.size = size;
        return ret;
    }

    UPB_INLINE upb_StringView upb_StringView_FromString(const char* data)
    {
        return upb_StringView_FromDataAndSize(data, strlen(data));
    }

    UPB_INLINE bool upb_StringView_IsEqual(upb_StringView a, upb_StringView b)
    {
        return a.size == b.size && memcmp(a.data, b.data, a.size) == 0;
    }

#define UPB_STRINGVIEW_INIT(ptr, len) \
    {                                 \
        ptr, len                      \
    }

#define UPB_STRINGVIEW_FORMAT "%.*s"
#define UPB_STRINGVIEW_ARGS(view) (int)(view).size, (view).data

    /* Constants ******************************************************************/

    /* A list of types as they are encoded on-the-wire. */
    typedef enum
    {
        kUpb_WireType_Varint = 0,
        kUpb_WireType_64Bit = 1,
        kUpb_WireType_Delimited = 2,
        kUpb_WireType_StartGroup = 3,
        kUpb_WireType_EndGroup = 4,
        kUpb_WireType_32Bit = 5
    } upb_WireType;

    /* The types a field can have.  Note that this list is not identical to the
     * types defined in descriptor.proto, which gives INT32 and SINT32 separate
     * types (we distinguish the two with the "integer encoding" enum below). */
    typedef enum
    {
        kUpb_CType_Bool = 1,
        kUpb_CType_Float = 2,
        kUpb_CType_Int32 = 3,
        kUpb_CType_UInt32 = 4,
        kUpb_CType_Enum = 5, /* Enum values are int32. */
        kUpb_CType_Message = 6,
        kUpb_CType_Double = 7,
        kUpb_CType_Int64 = 8,
        kUpb_CType_UInt64 = 9,
        kUpb_CType_String = 10,
        kUpb_CType_Bytes = 11
    } upb_CType;

    /* The repeated-ness of each field; this matches descriptor.proto. */
    typedef enum
    {
        kUpb_Label_Optional = 1,
        kUpb_Label_Required = 2,
        kUpb_Label_Repeated = 3
    } upb_Label;

    /* Descriptor types, as defined in descriptor.proto. */
    typedef enum
    {
        kUpb_FieldType_Double = 1,
        kUpb_FieldType_Float = 2,
        kUpb_FieldType_Int64 = 3,
        kUpb_FieldType_UInt64 = 4,
        kUpb_FieldType_Int32 = 5,
        kUpb_FieldType_Fixed64 = 6,
        kUpb_FieldType_Fixed32 = 7,
        kUpb_FieldType_Bool = 8,
        kUpb_FieldType_String = 9,
        kUpb_FieldType_Group = 10,
        kUpb_FieldType_Message = 11,
        kUpb_FieldType_Bytes = 12,
        kUpb_FieldType_UInt32 = 13,
        kUpb_FieldType_Enum = 14,
        kUpb_FieldType_SFixed32 = 15,
        kUpb_FieldType_SFixed64 = 16,
        kUpb_FieldType_SInt32 = 17,
        kUpb_FieldType_SInt64 = 18
    } upb_FieldType;

#define kUpb_Map_Begin ((size_t)-1)

    UPB_INLINE bool _upb_IsLittleEndian(void)
    {
        int x = 1;
        return *(char*)&x == 1;
    }

    UPB_INLINE uint32_t _upb_BigEndian_Swap32(uint32_t val)
    {
        if (_upb_IsLittleEndian())
        {
            return val;
        }
        else
        {
            return ((val & 0xff) << 24) | ((val & 0xff00) << 8) |
                   ((val & 0xff0000) >> 8) | ((val & 0xff000000) >> 24);
        }
    }

    UPB_INLINE uint64_t _upb_BigEndian_Swap64(uint64_t val)
    {
        if (_upb_IsLittleEndian())
        {
            return val;
        }
        else
        {
            return ((uint64_t)_upb_BigEndian_Swap32((uint32_t)val) << 32) |
                   _upb_BigEndian_Swap32((uint32_t)(val >> 32));
        }
    }

    UPB_INLINE int _upb_Log2Ceiling(int x)
    {
        if (x <= 1)
            return 0;
#ifdef __GNUC__
        return 32 - __builtin_clz(x - 1);
#else
    int lg2 = 0;
    while (1 << lg2 < x)
        lg2++;
    return lg2;
#endif
    }

    UPB_INLINE int _upb_Log2CeilingSize(int x)
    {
        return 1 << _upb_Log2Ceiling(x);
    }

#include "upb/port_undef.inc"

#ifdef __cplusplus
} /* extern "C" */
#endif

#endif /* UPB_H_ */