開源項目cJSON具體實現3（字符串的解析）

3. JSON 字符串解析

文章目錄

3. JSON 字符串解析

3.1 JSON字符串的語法規則及解釋

/*
JSON 字符串是由前後兩個雙引號(quotation-mark)夾着零至多個字符組成。
字符分爲 無轉義字符 或 轉義字符。
轉義序列有 9 種，都是以反斜線開始，如常見的 \n 代表換行符，比較特殊的是 \uXXXX
*/
JSON-text = ws value ws
value = string
string = quotation-mark *char quotation-mark
char = unescaped /
   escape (
       %x22 /          ; "    quotation mark  U+0022
       %x5C /          ; \    reverse solidus U+005C
       %x2F /          ; /    solidus         U+002F
       %x62 /          ; b    backspace       U+0008
       %x66 /          ; f    form feed       U+000C
       %x6E /          ; n    line feed       U+000A
       %x72 /          ; r    carriage return U+000D
       %x74 /          ; t    tab             U+0009
       %x75 4HEXDIG )  ; uXXXX                U+XXXX
escape = %x5C          ; \
quotation-mark = %x22  ; "
unescaped = %x20-21 / %x23-5B / %x5D-10FFFF

3.2 設計頭文件

在 C 語言中，字符串一般表示爲空結尾字符串（’\0’）代表字符串的結束。然而，JSON 字符串是允許含有空字符的。所以如果純粹使用空結尾字符來表示 JSON 解析後的結果，就沒法處理空字符；爲此，我們的解決方法是即儲存解析後的字符，也記錄字符的長度。由於大部分 C 程序都假設字符串是空結尾字符串，我們還是在最後加上一個空字符。

所以我們這個結構就變成了：

typedef struct {
    char* s;   //string
    size_t len;   //string len
    double n;  //number
    lept_type type;   //類型
}lept_value;

注意：一個值不可能同時爲數字和字符串，因此我們可使用 C 語言的 union 來節省內存：

typedef struct {
    union {
        struct { char* s; size_t len; }s;  /* string */
        double n;                          /* number */
    }u;
    lept_type type;
}lept_value;

拓展，關於聯合：
union維護足夠的空間來放置多個數據成員中的一種，而不是每一個數據成員配置空間。在union中所有的數據成員共用一個空間，同一時間只能存儲一個數據成員。

API設計

const char* lept_get_string(const lept_value* v);
size_t lept_get_string_length(const lept_value* v);

在前兩個部分，我們只提供讀取值的 API，沒有寫入的 API，是因爲寫入時我們還要考慮釋放內存。我們在這裏把它們補全：

#define lept_init(v) do { (v)->type = LEPT_NULL; } while (0)     //用上 do { ... } while(0) 是爲了把表達式轉爲語句，模仿無返回值的函數。

#define lept_set_null(v) lept_free(v);//由於 lept_free() 實際上也會把 v 變成 null 值，我們只用一個宏來提供 lept_set_null() 這個 API。

int lept_parse(lept_value* v, const char* json);  

void lept_free(lept_value* v);

lept_type lept_get_type(const lept_value* v); 

int lept_get_boolean(const lept_value* v);
void lept_set_boolean(lept_value* v, int b);

double lept_get_number(const lept_value* v);
void lept_set_number(lept_value* v, double n);

const char* lept_get_string(const lept_value* v);
size_t lept_get_string_length(const lept_value* v);
void lept_set_string(lept_value* v, const char* s, size_t len);

關於 lept_init; lept_free; lept_set_null 這三個函數？

因爲現在在lept_value中加入了字符串的保存，並且由於這個字符串它的長度不是固定的，所以我們使用動態分配內存來完成存儲，即我們使用了指針；API 設計中我們加入了許多的set函數，在使用set時得對傳入的參數 lept_value* v 進行清空可能分配到的內存，所以設計了 lept_free 函數。

我們在解析JSON-text時，會對存儲樹形結構的 lept_value v 的類型進行改變，所以在調用這些函數之前，得進行初始化，又因爲初始化函數的實現非常簡單，所以我們用宏實現。

至於 lept_set_null 函數的作用與 lept_free() 相同，所以用一個宏來實現 lept_set_null()

API函數的實現

int lept_parse(lept_value* v, const char* json) {
    /*  */
    lept_init(v);
    lept_parse_whitespace(&c);
    /*  */
}

void lept_free(lept_value* v) {
    assert(v != NULL);
    if (v->type == LEPT_STRING)//僅當值是字符串類型，我們纔要處理
        free(v->u.s.s);//對數組的釋放
    v->type = LEPT_NULL;//對對象的釋放
 }

lept_type lept_get_type(const lept_value* v) {
    assert(v != NULL);
    return v->type;
}

int lept_get_boolean(const lept_value* v) {
    assert(v != NULL && (v->type == LEPT_TRUE || v->type == LEPT_FALSE));
    return v->type == LEPT_TRUE;
}

void lept_set_boolean(lept_value* v, int b) {
    lept_free(v);
    v->type = b ? LEPT_TRUE : LEPT_FALSE;
}

double lept_get_number(const lept_value* v) {
    assert(v != NULL && v->type == LEPT_NUMBER);
    return v->u.n;
}

void lept_set_number(lept_value* v, double n) {
    lept_free(v);
    v->u.n = n;
    v->type = LEPT_NUMBER;
}

const char* lept_get_string(const lept_value* v) {
    assert(v != NULL && v->type == LEPT_STRING);
    return v->u.s.s;
}

size_t lept_get_string_length(const lept_value* v) {
    assert(v != NULL && v->type == LEPT_STRING);
    return v->u.s.len;
}

/*  我們來實現lept_set_string函數，即把參數中的字符串複製一份  */
void lept_set_string(lept_value* v, const char* s, size_t len) {
    assert(v != NULL && (s != NULL || len == 0));//非空指針（有具體的字符串）或是零長度的字符串都是合法的。
    lept_free(v);
    v->u.s.s = (char*)malloc(len + 1);//+ 1 是因爲結尾空字符
    memcpy(v->u.s.s, s, len);
    v->u.s.s[len] = '\0';//補上結尾空字符
    v->u.s.len = len;
    v->type = LEPT_STRING;
}

3.3 測試代碼

先捋個邏輯：首先因爲現在的lept_value結構體裏面包含了一個字符指針，所以代碼在調用 lept_parse() 之後，最終也應該調用 lept_free() 去釋放內存。如果不使用 lept_parse()，我們需要初始化值lept_init()，最後 lept_free()。所以之前的單元測試要加入此調用。（lept_parse中已經初始化過就不用了）

static void test_parse_null() {
    lept_value v;
    lept_init(&v);  //相當於之前的 v.type = LEPT_FALSE; 作用
    lept_set_boolean(&v, 0);
    EXPECT_EQ_INT(LEPT_PARSE_OK, lept_parse(&v, "null"));
    EXPECT_EQ_INT(LEPT_NULL, lept_get_type(&v));
    lept_free(&v);
}

static void test_parse_true() {
    lept_value v;
    lept_init(&v);
    lept_set_boolean(&v, 0);
    EXPECT_EQ_INT(LEPT_PARSE_OK, lept_parse(&v, "true"));
    EXPECT_EQ_INT(LEPT_TRUE, lept_get_type(&v));
    lept_free(&v);
}

static void test_parse_false() {
    lept_value v;
    lept_init(&v);
    lept_set_boolean(&v, 1);
    EXPECT_EQ_INT(LEPT_PARSE_OK, lept_parse(&v, "false"));
    EXPECT_EQ_INT(LEPT_FALSE, lept_get_type(&v));
    lept_free(&v);
}

#define TEST_NUMBER(expect, json)\
    do {\
        lept_value v;\
        lept_init(&v);\  //注意得加上初始化
        EXPECT_EQ_INT(LEPT_PARSE_OK, lept_parse(&v, json));\
        EXPECT_EQ_INT(LEPT_NUMBER, lept_get_type(&v));\
        EXPECT_EQ_DOUBLE(expect, lept_get_number(&v));\
        lept_free(&v);\
    } while(0)


#define TEST_ERROR(error, json)\
    do {\
        lept_value v;\
        lept_init(&v);\  //注意得加上初始化
        EXPECT_EQ_INT(error, lept_parse(&v, json));\
        EXPECT_EQ_INT(LEPT_NULL, lept_get_type(&v));\
        lept_free(&v);\
    } while(0)

接下來是字符串的測試代碼

#define EXPECT_EQ_STRING(expect, actual, alength) \
    EXPECT_EQ_BASE(sizeof(expect) - 1 == alength && memcmp(expect, actual, alength) == 0, expect, actual, "%s")

#define TEST_STRING(expect, json)\
    do {\
        lept_value v;\
        lept_init(&v);\
        EXPECT_EQ_INT(LEPT_PARSE_OK, lept_parse(&v, json));\
        EXPECT_EQ_INT(LEPT_STRING, lept_get_type(&v));\
        EXPECT_EQ_STRING(expect, lept_get_string(&v), lept_get_string_length(&v));\
        lept_free(&v);\
    } while(0)

static void test_parse_string() {
    TEST_STRING("", "\"\"");
    TEST_STRING("Hello", "\"Hello\"");
    
     TEST_STRING("Hello\nWorld", "\"Hello\\nWorld\"");
    TEST_STRING("\" \\ / \b \f \n \r \t", "\"\\\" \\\\ \\/ \\b \\f \\n \\r \\t\"");
}

//錯誤的測試案例
/*引號不全*/
static void test_parse_missing_quotation_mark() {
    TEST_ERROR(LEPT_PARSE_MISS_QUOTATION_MARK, "\"");
    TEST_ERROR(LEPT_PARSE_MISS_QUOTATION_MARK, "\"abc");
}

/*不合法的字符轉義*/
static void test_parse_invalid_string_escape() {
   TEST_ERROR(LEPT_PARSE_INVALID_STRING_ESCAPE, "\"\\v\""); TEST_ERROR(LEPT_PARSE_INVALID_STRING_ESCAPE, "\"\\'\"");
    TEST_ERROR(LEPT_PARSE_INVALID_STRING_ESCAPE, "\"\\0\"");
    TEST_ERROR(LEPT_PARSE_INVALID_STRING_ESCAPE, "\"\\x12\"");

}

/*不合法的字符*/
static void test_parse_invalid_string_char() {
    TEST_ERROR(LEPT_PARSE_INVALID_STRING_CHAR, "\"\x01\"");
    TEST_ERROR(LEPT_PARSE_INVALID_STRING_CHAR, "\"\x1F\"");

}

static void test_parse() {
    /*  */
    test_parse_string();
    test_parse_missing_quotation_mark();
    test_parse_invalid_string_escape();
    test_parse_invalid_string_char();
}

注意：因爲現在我們在頭文件裏提供了API訪問函數：lept_set_boolean、lept_set_numbe、lept_set_string、lept_set_null，所以這些也是要測試的。

#define EXPECT_TRUE(actual) EXPECT_EQ_BASE((actual) != 0, "true", "false", "%s")

#define EXPECT_FALSE(actual) EXPECT_EQ_BASE((actual) == 0, "false", "true", "%s")

static void test_access_null() {
    lept_value v;
    lept_init(&v);
    lept_set_string(&v, "a", 1);//爲什麼先設成字符串？可以測試設置爲其他類型時，有沒有調用 lept_free() 去釋放內存，因爲先設置成 string類型一定改變了內存

    lept_set_null(&v);
    EXPECT_EQ_INT(LEPT_NULL, lept_get_type(&v));
    lept_free(&v);
}

static void test_access_boolean() {
        lept_value v;
        lept_init(&v);
        lept_set_string(&v, "a", 1);
        lept_set_boolean(&v, 1);
        EXPECT_TRUE(lept_get_boolean(&v));
        lept_set_boolean(&v, 0);
        EXPECT_FALSE(lept_get_boolean(&v));
        lept_free(&v);
}


static void test_access_number() {
    lept_value v;
        lept_init(&v);
        lept_set_string(&v, "a", 1);
        lept_set_number(&v,1234.5);
        EXPECT_EQ_DOUBLE(1234.5, lept_get_number(&v));
        lept_free(&v);
}


static void test_access_string() {
    lept_value v;
    lept_init(&v);
    lept_set_string(&v, "", 0);
    EXPECT_EQ_STRING("", lept_get_string(&v), lept_get_string_length(&v));
    lept_set_string(&v, "Hello", 5);
    EXPECT_EQ_STRING("Hello", lept_get_string(&v), lept_get_string_length(&v));
    lept_free(&v);
}

static void test_parse() {
    /*  */
    test_parse_string();
    test_parse_missing_quotation_mark();
    test_parse_invalid_string_escape();
    test_parse_invalid_string_char();

    test_access_null();
    test_access_boolean();
    test_access_number();
    test_access_string();
}

3.4 實現解析器

注意：我們解析字符串（以及之後的數組、對象）時，需要把每一個字符解析後的結果先儲存在一個臨時的緩衝區，最後再用 lept_set_string() 把緩衝區的結果放入 lept_value 中。在完成解析一個字符串之前，這個緩衝區的大小是不能預知的。因此，我們可以採用動態數組（dynamic array）這種數據結構。

如果每次解析字符串時，都重新建一個動態數組，那麼是比較耗時的。所以我們希望可以重用這個動態數組，在每次解析 JSON 時就只需要創建一個。而且我們將會發現，無論是解析字符串、數組或對象，我們也只需要以先進後出的方式訪問這個動態數組。換句話說，我們需要一個動態的堆棧數據結構。所以可以在 lept_context 裏放入一個動態堆棧。

typedef struct {
    const char* json;
    char* stack;
    size_t size, top;// size 是當前的堆棧容量，top 是棧頂的位置，由於我們會擴展 stack，所以不要把 top 用指針形式存儲
}lept_context;

注意：既然現在lept_context 裏面包含了一個動態堆棧，就要記得一個原理：使用前先初始化，使用完後記得free。

還是先在lept_parse中添加字符串類型。

static int lept_parse_value(lept_context* c, lept_value* v) {
    switch (*c->json) {
        case 't':  return lept_parse_literal(c, v, "true", LEPT_TRUE);
        case 'f':  return lept_parse_literal(c, v, "false", LEPT_FALSE);
        case 'n':  return lept_parse_literal(c, v, "null", LEPT_NULL);
        default:   return lept_parse_number(c, v);
        case '"':  return lept_parse_string(c, v);  //string
        case '\0': return LEPT_PARSE_EXPECT_VALUE;
    }
}

int lept_parse(lept_value* v, const char* json) {
    int ret;
     assert(v != NULL);
    
    //創建c並初始化stack
    lept_context c;   
   	c.json = json;
    c.stack = NULL;
    c.size = c.top = 0;
    
    lept_init(v);
    lept_parse_whitespace(&c);
    if ((ret = lept_parse_value(&c, v)) == LEPT_PARSE_OK) {
        lept_parse_whitespace(&c);
        if (*c.json != '\0') {
            v->type = LEPT_NULL;
            ret = LEPT_PARSE_ROOT_NOT_SINGULAR;

        }
    }

    assert(c.top == 0);//釋放前加入斷言確保所有數據都被彈出。
    free(c.stack);//記得free
    return ret;
}

實現堆棧的壓入及彈出操作。和普通的堆棧不一樣，我們這個堆棧是以字節儲存的。每次可要求壓入任意大小的數據，它會返回數據起始的指針。

#ifndef LEPT_PARSE_STACK_INIT_SIZE
#define LEPT_PARSE_STACK_INIT_SIZE 256
#endif

static void* lept_context_push(lept_context* c, size_t size) {
    void* ret;
    assert(size > 0);
    if (c->top + size >= c->size) {
        if (c->size == 0)
            c->size = LEPT_PARSE_STACK_INIT_SIZE;
        while (c->top + size >= c->size)
            c->size += c->size >> 1;  /* c->size * 1.5 */
        c->stack = (char*)realloc(c->stack, c->size);
    }
    ret = c->stack + c->top;
    c->top += size;
    return ret;
}

static void* lept_context_pop(lept_context* c, size_t size) {
    assert(c->top >= size);
    return c->stack + (c->top -= size);
 }

lept_parse_string 函數的實現

#define PUTC(c, ch) do { *(char*)lept_context_push(c, sizeof(char)) = (ch); } while(0)

/*
函數目的：解析字符串
參數：1. lept_context* c :要被解析的value
     2. lept_value* v :解析後要被保存的位置
     3. 
解析思路：只需要先備份棧頂，然後把解析到的字符壓棧，最後計算出長度並一次性把所有字符彈出，再設置到值裏便可以。

注意：
1. 對於不合法的轉義字符返回 LEPT_PARSE_INVALID_STRING_ESCAPE
2. 對於不合法字符，首先由`unescaped = %x20-21 / %x23-5B / %x5D-10FFFF`可知。當中空缺的 %x22 是雙引號，%x5C 是反斜線，都已經處理。所以不合法的字符是 %x00 至 %x1F。
*/
static int lept_parse_string(lept_context* c, lept_value* v) {
        size_t head = c->top;//備份棧頂
        size_t len;
	    EXPECT(c, '\"');//判斷c是否爲string類型
        const char* p = c->json;//p指向的是字符串開始的字符

	    for (;;) {
       		char ch = *p++;
        	switch (ch) {
                       case '\\':             //轉義字符的處理
                              switch (*p++){
                              case '\"': PUTC(c, '\"'); break;
                              case '\\': PUTC(c, '\\'); break;
                              case '/':  PUTC(c, '/'); break;
                              case 'b':  PUTC(c, '\b'); break;
                              case 'f':  PUTC(c, '\f'); break;
                              case 'n':  PUTC(c, '\n'); break;
                              case 'r':  PUTC(c, '\r'); break;
                              case 't':  PUTC(c, '\t'); break;
                              default:
                                      c->top = head;
                                      return LEPT_PARSE_INVALID_STRING_ESCAPE;
                              }
                              break;
            case '\"':
                len = c->top - head; 
                lept_set_string(v, (const char*)lept_context_pop(c, len), len);//將所有字符一次性彈出
                c->json = p;
                return LEPT_PARSE_OK;
            case '\0':
                c->top = head;
                return LEPT_PARSE_MISS_QUOTATION_MARK;
            default:
                              if ((unsigned char)ch < 0x20){  //剩餘的情況下有不合法字符串的情況：%x00 至 %x1F
                                      c->top = head;
                                      return LEPT_PARSE_INVALID_STRING_CHAR;//不合法的字符串
                              }
                PUTC(c, ch); //把解析的字符串壓棧
        }
    }
}

3.5 拓展，關於內存泄漏的檢測方法。

Windows下的內存泄漏檢測方法

在 Windows 下，可使用 Visual C++ 的 C Runtime Library（CRT）檢測內存泄漏。

首先，我們在 .c 文件首行插入這一段代碼：

#ifdef _WINDOWS
#define _CRTDBG_MAP_ALLOC
#include <crtdbg.h>
#endif

並在 main() 函數開始位置插入：

#ifdef _WINDOWS
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif

就可以在調試的輸出窗口看到。

如果檢測不到內存泄漏的話（前提是要有內存泄漏），可以試試：

在代碼最上面多加上一條：#define _WINDOWS
在main退出前加上一句：_CrtDumpMemoryLeaks();

開源項目cJSON具體實現3（字符串的解析）

3. JSON 字符串解析

文章目錄

3.1 JSON字符串的語法規則及解釋

3.2 設計頭文件

3.3 測試代碼

3.4 實現解析器

3.5 拓展，關於內存泄漏的檢測方法。

Linux中的權限問題

開源項目cJSON具體實現5（數組的解析）

開源項目cJSON具體實現3（字符串的解析）

Linux相關（3）Linux下建立Git與GitHub的連接以及安裝git時的n個解決問題辦法

開源項目cJSON具體實現1（NULL 與 Boolean的解析）

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結