1

#include "str.h"

     2

     3

#include <ctype.h>

     4

#include <stdio.h>

     5

#include <string.h>

     6

#include <stdbool.h>

     7

     8

#include <assert.h>

     9

    10

const struct error_list str_errors = ERROR_LIST("str",

    11

    ERROR_TYPE(     ERR_STR_FMT_TAG,            "invalid parameter tag syntax"      ),

    12

    ERROR_TYPE(     ERR_STR_FMT_NAME_LEN,       "invalid parameter name length"     ),

    13

    ERROR_TYPE(     ERR_STR_FMT_NAME,           "invalid/unknown parameter name"    ),

    14

    ERROR_TYPE(     ERR_STR_FMT_FLAGS_LEN,      "invalid paramter flags length"     ),

    15

    ERROR_TYPE(     ERR_STR_FMT_FLAG,           "invalid paramter flag"             ),

    16

    ERROR_TYPE(     ERR_STR_FMT_BUF_LEN,        "output buffer ran out"             )

    17

);

    18

    19

size_t str_append_num (char *buf, size_t buf_size, const char *str, ssize_t len)

    20

{

    21

    size_t str_len;

    22

    23

    // copy the bytes

    24

    // len will either be >0 or <0

    25

    for (str_len = 0; *str && buf_size > 1 && len != 0; str_len++, buf_size--, len--)

    26

        *buf++ = *str++;

    27

    28

    // count the rest

    29

    for (; *str && len != 0; str++, len--)

    30

        str_len++;

    31

    32

    if (buf_size)

    33

        // NUL-terminate

    34

        *buf = '\0';

    35

    36

    // ok

    37

    return str_len;

    38

    39

}

    40

    41

size_t str_append (char *buf, size_t buf_size, const char *str)

    42

{

    43

    return str_append_num(buf, buf_size, str, -1);

    44

}

    45

    46

size_t str_append_char (char *buf, size_t buf_size, char c)

    47

{

    48

    if (buf_size > 1)

    49

        *buf++ = c;

    50

    51

    if (buf_size > 0)

    52

        *buf = '\0';

    53

    54

    return 1;

    55

}

    56

    57

size_t str_append_fmt_va (char *buf, size_t buf_size, const char *fmt, va_list vargs)

    58

{

    59

    int ret;

    60

    61

    // do the formatting

    62

    ret = vsnprintf(buf, buf_size, fmt, vargs);

    63

    64

    // XXX: not all vsnprintf implementations do this

    65

    assert(ret >= 0);

    66

    67

    // ok

    68

    return ret;

    69

}

    70

    71

size_t str_append_fmt (char *buf, size_t buf_size, const char *fmt, ...)

    72

{

    73

    va_list vargs;

    74

    int ret;

    75

    76

    va_start(vargs, fmt);

    77

    ret = str_append_fmt_va(buf, buf_size, fmt, vargs);

    78

    va_end(vargs);

    79

    80

    return ret;

    81

}

    82

    83

static const struct str_quote_item {

    84

    /** The char value to quote */

    85

    char c;

    86

    87

    /** The quoted value */

    88

    const char *out;

    89

} _quote_table[] = {

    90

    { '\'', "\\'"   },

    91

    { '\\', "\\\\"  },

    92

    { '\0', "\\0"   },

    93

    { '\r', "\\r"   },

    94

    { '\n', "\\n"   },

    95

    { 0,    NULL    }

    96

};

    97

    98

size_t str_quote_char (char *buf, size_t buf_size, char c)

    99

{

   100

    const struct str_quote_item *quote_item = _quote_table;

   101

   102

    // special quote?

   103

    for (quote_item = _quote_table; quote_item->c || quote_item->out; quote_item++) {

   104

        if (quote_item->c == c)

   105

            return str_append(buf, buf_size, quote_item->out);

   106

    }

   107

   108

    // output directly?

   109

    if (isprint(c))

   110

        return str_append_char(buf, buf_size, c); 

   111

   112

    else 

   113

        return str_append_fmt(buf, buf_size, "\\x%02x", c);

   114

}

   115

   116

size_t str_advance (size_t *data_size, size_t *buf_size, size_t len)

   117

{

   118

    if (data_size)

   119

        *data_size += len;

   120

   121

    if (len > *buf_size)

   122

        *buf_size = 0;

   123

   124

    else

   125

        *buf_size -= len;

   126

   127

    return len;

   128

}

   129

   130

/**

   131

 * Number of bytes reserved by str_quote for the trailing overflow stuff

   132

 */

   133

#define STR_QUOTE_RESERVED 5

   134

   135

size_t str_quote (char *buf, size_t buf_size, const char *str, ssize_t str_len)

   136

{

   137

    size_t data_size = 0;

   138

   139

    // NULL?

   140

    if (str == NULL) {

   141

        return str_append(buf, buf_size, "NULL");

   142

   143

    } else {

   144

        // calc length?

   145

        if (str_len < 0)

   146

            str_len = strlen(str);

   147

   148

        // quote

   149

        buf += str_advance(&data_size, &buf_size, str_append_char(buf, buf_size, '\''));

   150

   151

        // dump each char

   152

        while (str_len--) { 

   153

            if (buf_size > STR_QUOTE_RESERVED) {

   154

                size_t char_size;

   155

   156

                // output and count the chars

   157

                char_size = str_quote_char(buf, buf_size, *str++);

   158

   159

                // if there's still enough room left, commit this and continue

   160

                if (buf_size > char_size && buf_size - char_size >= STR_QUOTE_RESERVED)

   161

                    buf += str_advance(&data_size, &buf_size, char_size);

   162

   163

                else

   164

                    // keep the buf pointer intact, we'll overwrite it now

   165

                    data_size += char_size;

   166

   167

            } else {

   168

                // continue counting the chars, but don't output anything anymore

   169

                data_size += str_quote_char(NULL, 0, *str++);

   170

            }

   171

        }

   172

   173

        // end quote

   174

        buf += str_advance(&data_size, &buf_size, str_append_char(buf, buf_size, '\''));

   175

    }        

   176

   177

    // overflow -> mark

   178

    if (buf_size < STR_QUOTE_RESERVED)

   179

        buf += str_advance(NULL, &buf_size, str_append(buf, buf_size, "..."));

   180

   181

    // the total outputted chars

   182

    return data_size;

   183

}

   184

   185

/**

   186

 * Output the data for a single parameter

   187

 */

   189

{

   190

    const char *value;

   191

    ssize_t value_len = -1;

   192

    char flag;

   193

    bool use_quote = false;

   194

   195

    // look it up

   198

   199

    // not found?

   200

    if (!value)

   202

   203

    // parse flags

   204

    while ((flag = *flags++)) {

   205

        switch (flag) {

   206

            case 'r':

   207

                // quote

   208

                use_quote = true;

   209

   210

                break;

   211

   212

            default:

   213

                // unknown flag

   215

   216

        }

   217

    }

   218

   219

    // output value

   220

    if (use_quote)

   221

        *buf += str_advance(NULL, buf_size, str_quote(*buf, *buf_size, value, value_len));

   222

   223

    else

   224

        *buf += str_advance(NULL, buf_size, str_append_num(*buf, *buf_size, value, value_len));

   225

   226

    // ok

   227

    return SUCCESS;

   228

}

   229

   230

err_t str_format (char *buf, size_t buf_size, const char *format, str_format_cb func, void *arg, error_t *err)

   231

{

   232

    char name_buf[STR_FORMAT_PARAM_MAX + 1], *name_ptr;

   233

    size_t name_size;

   234

    char flags_buf[STR_FORMAT_FLAGS_MAX + 1], *flags_ptr;

   235

    size_t flags_size;

   236

    bool in_param = false, in_param_flags = false;

   237

   238

    // iterate over the format string

   239

    do {

   240

        // check buffer state

   241

        if (!buf_size)

   242

            return SET_ERROR(err, &str_errors, ERR_STR_FMT_BUF_LEN);

   243

   244

        // inspect this char

   245

        switch (*format) {

   246

            case '{':

   247

                // syntax

   248

                if (in_param)

   249

                    return SET_ERROR(err, &str_errors, ERR_STR_FMT_TAG);

   250

   251

                // init state

   252

                in_param = true;

   253

                name_ptr = name_buf;

   254

                name_size = sizeof(name_buf);

   255

                flags_ptr = flags_buf;

   256

                flags_size = sizeof(flags_buf);

   257

   258

                *name_ptr = *flags_ptr = '\0';

   259

   260

                break;

   261

   262

            case '}':

   263

                // syntax

   264

                if (!in_param)

   265

                    return SET_ERROR(err, &str_errors, ERR_STR_FMT_TAG);

   266

   267

                // reset state

   268

                in_param = false;

   269

                in_param_flags = false;

   270

   271

                // output token

   272

                if (str_format_param(&buf, &buf_size, name_buf, flags_buf, func, arg, err))

   273

                    return error_code(err);

   274

   275

                break;

   276

   277

            case ':':

   278

                if (in_param) {

   279

                    // set state

   280

                    in_param_flags = true;

   281

   282

                    break;

   283

                }

   284

   285

                /* Fallthrough */

   286

   287

            default:

   288

                if (in_param && in_param_flags ) {

   289

                    // add to param flags

   290

                    flags_ptr += str_advance(NULL, &flags_size, str_append_char(flags_ptr, flags_size, *format));

   291

   292

                    if (!flags_size)

   293

                        return SET_ERROR(err, &str_errors, ERR_STR_FMT_FLAGS_LEN);

   294

   295

                } else if (in_param) {

   296

                    // add to param name

   297

                    name_ptr += str_advance(NULL, &name_size, str_append_char(name_ptr, name_size, *format));

   298

   299

                    if (!name_size)

   300

                        return SET_ERROR(err, &str_errors, ERR_STR_FMT_NAME_LEN);

   301

   302

                } else {

   303

                    // add to output

   304

                    buf += str_advance(NULL, &buf_size, str_append_char(buf, buf_size, *format));

   305

   306

                }

   307

   308

                break;

   309

        }

   310

    } while (*format++);

   311

   312

    // syntax

   313

    if (in_param)

   314

        return SET_ERROR(err, &str_errors, ERR_STR_FMT_TAG);

   315

   316

    // ok

   317

    return SUCCESS;

   318

}

   319