chromium/third_party/grpc/src/src/core/lib/gpr/string.cc

//
//
// Copyright 2015 gRPC authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
//

#include <grpc/support/port_platform.h>

#include "src/core/lib/gpr/string.h"

#include <ctype.h>
#include <limits.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include "absl/strings/str_cat.h"

#include <grpc/support/alloc.h>
#include <grpc/support/log.h>
#include <grpc/support/string_util.h>

#include "src/core/lib/gpr/useful.h"
#include "src/core/lib/gprpp/crash.h"

char* gpr_strdup(const char* src) { … }

std::string gpr_format_timespec(gpr_timespec tm) { … }

struct dump_out { … };

static dump_out dump_out_create(void) { … }

static void dump_out_append(dump_out* out, char c) { … }

static void hexdump(dump_out* out, const char* buf, size_t len) { … }

static void asciidump(dump_out* out, const char* buf, size_t len) { … }

char* gpr_dump_return_len(const char* buf, size_t len, uint32_t flags,
                          size_t* out_len) { … }

char* gpr_dump(const char* buf, size_t len, uint32_t flags) { … }

int gpr_parse_bytes_to_uint32(const char* buf, size_t len, uint32_t* result) { … }

void gpr_reverse_bytes(char* str, int len) { … }

int gpr_ltoa(long value, char* output) { … }

int int64_ttoa(int64_t value, char* output) { … }

int gpr_parse_nonnegative_int(const char* value) { … }

char* gpr_leftpad(const char* str, char flag, size_t length) { … }

char* gpr_strjoin(const char** strs, size_t nstrs, size_t* final_length) { … }

char* gpr_strjoin_sep(const char** strs, size_t nstrs, const char* sep,
                      size_t* final_length) { … }

int gpr_strincmp(const char* a, const char* b, size_t n) { … }

int gpr_stricmp(const char* a, const char* b) { … }

static void add_string_to_split(const char* beg, const char* end, char*** strs,
                                size_t* nstrs, size_t* capstrs) { … }

void gpr_string_split(const char* input, const char* sep, char*** strs,
                      size_t* nstrs) { … }

void* gpr_memrchr(const void* s, int c, size_t n) { … }

bool gpr_parse_bool_value(const char* value, bool* dst) { … }