状态机学习（六）解析JSON2

来自

从零开始的 JSON 库教程

从零开始教授如何写一个符合标准的 C 语言 JSON 库

作者 Milo Yip

https://zhuanlan.zhihu.com/json-tutorial

根据第二课教程 自己重新编写 做了一点修改 加深学习印象

这里写的有点随便 怎么方便怎么来

浮点的判断也是使用的函数 判断范围比json的要宽松些 仅作为练手练习使用

 #ifndef LEPTJSON_H
 #define LEPTJSON_H
 #include <string>

 enum DefParseResult{
     DEF_PARSE_OK = ,
     DEF_PARSE_EXPECT_VALUE,
     DEF_PARSE_INVALID_VALUE,
     DEF_PARSE_ROOT_NOT_SINGULAR
 };

 enum DefType {
     DEF_NONE = ,
     DEF_NULL,
     DEF_FALSE,
     DEF_TRUE,
     DEF_NUMBER,
     DEF_STRING,
     DEF_ARRAY,
     DEF_OBJECT
 };

 struct MyJsonStruct {
     double d;
     std::string jsonStr;
     size_t index;
     DefType type;
 };

 DefParseResult DefParse(MyJsonStruct& jstruct);
 MyJsonStruct InitJsonStruct(char* str);
 DefType GetJsonStructType( MyJsonStruct& jstruct);
 double GetJsonStructNumber( MyJsonStruct& jstruct);

 #endif // LEPTJSON_H

 #include "leptjson.h"
 #include <string>
 #include <exception>

 void DefParseWhiteSpace(MyJsonStruct& jstruct)
 {
     if(jstruct.index == jstruct.jsonStr.size()-){
         jstruct.index++;
         return;
     }
     while( isspace(jstruct.jsonStr[jstruct.index])){
         jstruct.index++;
     }
 }

 DefParseResult DefParseType(MyJsonStruct& jstruct){
     if( jstruct.jsonStr[jstruct.index] == 'n'){
         if(jstruct.jsonStr[jstruct.index+] == 'u'  &&
             jstruct.jsonStr[jstruct.index+] == 'l' &&
             jstruct.jsonStr[jstruct.index+] == 'l')
         {
             jstruct.index += ;
             jstruct.type = DEF_NULL;
             return DEF_PARSE_OK;
         }

     }else if(jstruct.jsonStr[jstruct.index] == 't'){
         if(jstruct.jsonStr[jstruct.index+] == 'r'  &&
             jstruct.jsonStr[jstruct.index+] == 'u' &&
             jstruct.jsonStr[jstruct.index+] == 'e')
         {
             jstruct.index += ;
             jstruct.type = DEF_TRUE;
             return DEF_PARSE_OK;
         }
     }else if(jstruct.jsonStr[jstruct.index] == 'f'){
         if(jstruct.jsonStr[jstruct.index+] == 'a'  &&
             jstruct.jsonStr[jstruct.index+] == 'l' &&
             jstruct.jsonStr[jstruct.index+] == 's' &&
             jstruct.jsonStr[jstruct.index+] == 'e')
         {
             jstruct.index += ;
             jstruct.type = DEF_FALSE;
             return DEF_PARSE_OK;
         }
     }

     return DEF_PARSE_INVALID_VALUE;
 }

 #define ISDIGIT(ch)         ((ch) >= '0' && (ch) <= '9')
 #define ISDIGIT1TO9(ch)     ((ch) >= '1' && (ch) <= '9')
 DefParseResult DefParseNumber(MyJsonStruct& jstruct)
 {
     try{
         jstruct.d = std::stod(jstruct.jsonStr);
         jstruct.index = jstruct.jsonStr.find_first_of("\t\r\n ");
     }catch(std::exception& e){
         return DEF_PARSE_INVALID_VALUE;
     }

     jstruct.type = DEF_NUMBER;

     return DEF_PARSE_OK;
 }

 DefParseResult DefParseValue(MyJsonStruct& jstruct)
 {
     if(jstruct.index > jstruct.jsonStr.size())
         return DEF_PARSE_INVALID_VALUE;
     switch(jstruct.jsonStr[jstruct.index]){
     case 'n':
     case 'f':
     case 't':
         return DefParseType(jstruct);
     default:
         return DefParseNumber(jstruct);
     }
 }

 MyJsonStruct InitJsonStruct(char* str){
     if(str == nullptr){
         return MyJsonStruct{0.0,NULL,NULL,DEF_NONE};
     }

     return MyJsonStruct{0.0,str,,DEF_NONE};
 }

 DefType GetJsonStructType( MyJsonStruct& jstruct){
    return  jstruct.type;
 }

 double GetJsonStructNumber( MyJsonStruct& jstruct)
 {
     return  jstruct.d;
 }

 DefParseResult DefParse(MyJsonStruct& jstruct)
 {
     DefParseResult ret = DEF_PARSE_INVALID_VALUE;
     DefParseWhiteSpace(jstruct);

     ret = DefParseValue(jstruct);
     if(ret != DEF_PARSE_OK){
         return ret;
     }

     DefParseWhiteSpace(jstruct);
     if(jstruct.index < jstruct.jsonStr.size()){
         ret = DEF_PARSE_ROOT_NOT_SINGULAR;
         jstruct.type = DEF_NONE;
     }

     return ret;
 }

 #include <iostream>
 #include "leptjson.h"

 class MyTestClass {
     static size_t testCount_;
     static size_t testPass_;
 public:
     template<typename E,typename A>
     bool ExceptEqual(E e, A a)
     {
         testCount_++;
         if (e == a){
             testPass_++;
             return true;
         }
         return false;
     }

     void PrintResult(){
         std::cout << testPass_ << "/" << testCount_ << "\t" << "("<<(testPass_ * 100.0 / testCount_) << "%)" << " passed." << std::endl;
     }
 };
 size_t MyTestClass::testCount_ = ;
 size_t MyTestClass::testPass_ = ;

 #define ERROR_PRINT(expect,actual)                  \
  std::cerr << __FILE__ <<":"<< __LINE__ << "\r\nexpect: " << expect << "  actual: " << actual << std::endl;

 #define EXPECT_EQ(expect, actual)           \
 do{                                         \
     MyTestClass TEST;                       \
     if(!TEST.ExceptEqual(expect, actual)){  \
         ERROR_PRINT(expect,actual)          \
     }                                       \
 }while()

 #define PRINT_TEST_RESULT()                 \
 do{                                         \
     MyTestClass TEST;                       \
     TEST.PrintResult();                     \
 }while()
 //=======================================================================
 using namespace std;

 static void TestParseNULL(){
     MyJsonStruct jsonStruct = InitJsonStruct("null");
     EXPECT_EQ(DEF_PARSE_OK,DefParse(jsonStruct));
     EXPECT_EQ(DEF_NULL, GetJsonStructType(jsonStruct));
 }

 static void TestParseTRUE(){
     MyJsonStruct jsonStruct = InitJsonStruct("true");
     EXPECT_EQ(DEF_PARSE_OK,DefParse(jsonStruct));
     EXPECT_EQ(DEF_TRUE, GetJsonStructType(jsonStruct));
 }

 static void TestParseFALSE(){
     MyJsonStruct jsonStruct = InitJsonStruct("false");
     EXPECT_EQ(DEF_PARSE_OK,DefParse(jsonStruct));
     EXPECT_EQ(DEF_FALSE, GetJsonStructType(jsonStruct));
 }

 #define TEST_ERROR(error, json)\
     do {\
         MyJsonStruct jsonStruct = InitJsonStruct(json);\
         EXPECT_EQ(error, DefParse(jsonStruct));\
         EXPECT_EQ(DEF_NONE, GetJsonStructType(jsonStruct));\
     } while()

 static void TestParseInvaliValue(){
     TEST_ERROR(DEF_PARSE_INVALID_VALUE,"nul");
     TEST_ERROR(DEF_PARSE_INVALID_VALUE,"?");

     TEST_ERROR(DEF_PARSE_INVALID_VALUE,"nul");
     TEST_ERROR(DEF_PARSE_INVALID_VALUE,"?");

 }

 static void TestParseRootNotSingular(){
     MyJsonStruct jsonStruct = InitJsonStruct("null x");
     EXPECT_EQ(DEF_PARSE_ROOT_NOT_SINGULAR, DefParse(jsonStruct));
     EXPECT_EQ(DEF_NONE, GetJsonStructType(jsonStruct));
 }

 #define TEST_NUMBER(expect, json)\
     do {\
         MyJsonStruct jsonStruct = InitJsonStruct(json);  \
         EXPECT_EQ(DEF_PARSE_OK, DefParse(jsonStruct));\
         EXPECT_EQ(DEF_NUMBER, GetJsonStructType(jsonStruct));\
         EXPECT_EQ(expect, GetJsonStructNumber(jsonStruct));\
     } while()

 static void TestParseNumber(){
     TEST_NUMBER(0.0, "");
     TEST_NUMBER(0.0, "-0");
     TEST_NUMBER(0.0, "-0.0");
     TEST_NUMBER(1.0, "");
     TEST_NUMBER(-1.0, "-1");
     TEST_NUMBER(1.5, "1.5");
     TEST_NUMBER(-1.5, "-1.5");
     TEST_NUMBER(3.1416, "3.1416");
     TEST_NUMBER(1E10, "1E10");
     TEST_NUMBER(1e10, "1e10");
     TEST_NUMBER(1E+, "1E+10");
     TEST_NUMBER(1E-, "1E-10");
     TEST_NUMBER(-1E10, "-1E10");
     TEST_NUMBER(-1e10, "-1e10");
     TEST_NUMBER(-1E+, "-1E+10");
     TEST_NUMBER(-1E-, "-1E-10");
     TEST_NUMBER(1.234E+10, "1.234E+10");
     TEST_NUMBER(1.234E-10, "1.234E-10");

     TEST_NUMBER(1.0000000000000002, "1.0000000000000002"); /* the smallest number > 1 */
     TEST_NUMBER( 2.2250738585072014e-308, "2.2250738585072014e-308");  /* Min normal positive double */
     TEST_NUMBER(-2.2250738585072014e-308, "-2.2250738585072014e-308");
     TEST_NUMBER( 1.7976931348623157e+308, "1.7976931348623157e+308");  /* Max double */
     TEST_NUMBER(-1.7976931348623157e+308, "-1.7976931348623157e+308");
 }

 void TestParse()
 {
     TestParseNULL();
     TestParseTRUE();
     TestParseFALSE();
     TestParseInvaliValue();
     TestParseRootNotSingular();
     TestParseNumber();
 }

 int main(int argc, char *argv[])
 {
     TestParse();
     PRINT_TEST_RESULT();
     return ;
 }

显示结果