code stringlengths 1 1.05M | repo_name stringlengths 6 83 | path stringlengths 3 242 | language stringclasses 222
values | license stringclasses 20
values | size int64 1 1.05M |
|---|---|---|---|---|---|
/**
* Copyright (c) 2013 - 2017, Nordic Semiconductor ASA
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, 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.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS 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.
*
*/
//#include "sdk_common.h"
//#if NRF_MODULE_ENABLED(CRC16)
#include "crc16.h"
#include <stdlib.h>
uint16_t util_crc16_compute(uint8_t const *p_data, uint32_t size, uint16_t const *p_crc)
{
uint16_t crc = (p_crc == NULL) ? 0xFFFF : *p_crc;
for (uint32_t i = 0; i < size; i++)
{
crc = (uint8_t)(crc >> 8) | (crc << 8);
crc ^= p_data[i];
crc ^= (uint8_t)(crc & 0xFF) >> 4;
crc ^= (crc << 8) << 4;
crc ^= ((crc & 0xFF) << 4) << 1;
}
return crc;
}
uint16_t util_crc16_ccitt(uint8_t const *p_data, uint32_t size, uint16_t const *p_crc)
{
uint16_t crc = (p_crc == NULL) ? 0xFFFF : *p_crc;
uint8_t b = 0;
if (p_crc == NULL)
{
b = 0;
}
for (uint32_t i = 0; i < size; i++)
{
for (uint8_t j = 0; j < 8; j++)
{
b = ((p_data[i] << j) & 0x80) ^ ((crc & 0x8000) >> 8);
crc <<= 1;
if (b != 0)
{
crc ^= 0x1021;
}
}
}
return crc;
}
//#endif //NRF_MODULE_ENABLED(CRC16)
| YifuLiu/AliOS-Things | components/genie_service/utility/crc/crc16.c | C | apache-2.0 | 3,189 |
/**
* Copyright (c) 2013 - 2017, Nordic Semiconductor ASA
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, 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.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS 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.
*
*/
/** @file
*
* @defgroup crc16 CRC16 compute
* @{
* @ingroup hci_transport
*
* @brief This module implements CRC-16-CCITT (polynomial 0x1021) with 0xFFFF initial value.
* The data can be passed in multiple blocks.
*/
#ifndef CRC16_H__
#define CRC16_H__
#include <stdint.h>
#ifdef __cplusplus
extern "C"
{
#endif
/**@brief Function for calculating CRC-16 in blocks.
*
* Feed each consecutive data block into this function, along with the current value of p_crc as
* returned by the previous call of this function. The first call of this function should pass NULL
* as the initial value of the crc in p_crc.
*
* @param[in] p_data The input data block for computation.
* @param[in] size The size of the input data block in bytes.
* @param[in] p_crc The previous calculated CRC-16 value or NULL if first call.
*
* @return The updated CRC-16 value, based on the input supplied.
*/
uint16_t util_crc16_compute(uint8_t const *p_data, uint32_t size, uint16_t const *p_crc);
/**@brief Function for calculating CRC-16-CCITT in blocks.
*
* Feed each consecutive data block into this function, along with the current value of p_crc as
* returned by the previous call of this function. The first call of this function should pass NULL
* as the initial value of the crc in p_crc.
*
* @param[in] p_data The input data block for computation.
* @param[in] size The size of the input data block in bytes.
* @param[in] p_crc The previous calculated CRC-16 value or NULL if first call.
*
* @return The updated CRC-16-CCITT value, based on the input supplied.
*/
uint16_t util_crc16_ccitt(uint8_t const *p_data, uint32_t size, uint16_t const *p_crc);
#ifdef __cplusplus
}
#endif
#endif // CRC16_H__
/** @} */
| YifuLiu/AliOS-Things | components/genie_service/utility/crc/crc16.h | C | apache-2.0 | 3,892 |
/**
* Copyright (c) 2013 - 2017, Nordic Semiconductor ASA
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, 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.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS 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.
*
*/
//#include "sdk_common.h"
//#if NRF_MODULE_ENABLED(CRC32)
#include "crc32.h"
#include <stdlib.h>
uint32_t util_crc32_compute(uint8_t const *p_data, uint32_t size, uint32_t const *p_crc)
{
uint32_t crc;
crc = (p_crc == NULL) ? 0xFFFFFFFF : ~(*p_crc);
for (uint32_t i = 0; i < size; i++)
{
crc = crc ^ p_data[i];
for (uint32_t j = 8; j > 0; j--)
{
crc = (crc >> 1) ^ (0xEDB88320U & ((crc & 1) ? 0xFFFFFFFF : 0));
}
}
return ~crc;
}
//#endif //NRF_MODULE_ENABLED(CRC32)
| YifuLiu/AliOS-Things | components/genie_service/utility/crc/crc32.c | C | apache-2.0 | 2,637 |
/**
* Copyright (c) 2015 - 2017, Nordic Semiconductor ASA
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, 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.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS 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.
*
*/
/** @file
*
* @defgroup crc32 CRC32 compute
* @{
* @ingroup hci_transport
*
* @brief This module implements the CRC-32 calculation in the blocks.
*/
#ifndef CRC32_H__
#define CRC32_H__
#include <stdint.h>
#ifdef __cplusplus
extern "C"
{
#endif
/**@brief Function for calculating CRC-32 in blocks.
*
* Feed each consecutive data block into this function, along with the current value of p_crc as
* returned by the previous call of this function. The first call of this function should pass NULL
* as the initial value of the crc in p_crc.
*
* @param[in] p_data The input data block for computation.
* @param[in] size The size of the input data block in bytes.
* @param[in] p_crc The previous calculated CRC-32 value or NULL if first call.
*
* @return The updated CRC-32 value, based on the input supplied.
*/
uint32_t util_crc32_compute(uint8_t const *p_data, uint32_t size, uint32_t const *p_crc);
#ifdef __cplusplus
}
#endif
#endif // CRC32_H__
/** @} */
| YifuLiu/AliOS-Things | components/genie_service/utility/crc/crc32.h | C | apache-2.0 | 3,112 |
src = Split('''
crc16.c
crc32.c
''')
component = aos_component('crc', src)
component.add_global_includes('include')
| YifuLiu/AliOS-Things | components/genie_service/utility/crc/ucube.py | Python | apache-2.0 | 130 |
/*
* Copyright (C) 2015-2021 Alibaba Group Holding Limited
*/
#include "httpclient.h"
#if AOS_COMP_CLI
#include "aos/cli.h"
#endif
#include <string.h>
#include <stdio.h>
/* @brief http request buffer */
#define REQ_BUF_SIZE 2048
static char req_buf[REQ_BUF_SIZE];
/* @brief http response buffer */
#define RSP_BUF_SIZE 2048
static char rsp_buf[RSP_BUF_SIZE];
static void http_comp_example(int argc, char **argv)
{
httpclient_t client = {0};
httpclient_data_t client_data = {0};
char * req_url = "http://www.baidu.com/";
int ret;
char * customer_header = "Accept: */*\r\n";
if (argc > 1) {
req_url = argv[1];
}
memset(req_buf, 0, sizeof(req_buf));
client_data.header_buf = req_buf;
client_data.header_buf_len = sizeof(req_buf);
memset(rsp_buf, 0, sizeof(rsp_buf));
client_data.response_buf = rsp_buf;
client_data.response_buf_len = sizeof(rsp_buf);
printf("http request %s\r\n", req_url);
httpclient_set_custom_header(&client, customer_header);
ret = httpclient_get(&client, req_url, &client_data);
if( ret >= 0 ) {
printf("Data received: %s \r\n", client_data.response_buf);
printf("http comp test success!\r\n");
}
return;
}
#if AOS_COMP_CLI
/* reg args: fun, cmd, description*/
ALIOS_CLI_CMD_REGISTER(http_comp_example, http_example, http component base example)
#endif
| YifuLiu/AliOS-Things | components/http/example/http_example.c | C | apache-2.0 | 1,386 |
/**
* @file httpclient.h
* http API header file.
*
* @version V1.0
* @date 2019-12-24
* Copyright (C) 2015-2020 Alibaba Group Holding Limited
*/
#ifndef HTTPCLIENT_H
#define HTTPCLIENT_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdbool.h>
#include <stdint.h>
/** @defgroup aos_httpclient_api http
* @{
*/
/** @brief http requst type */
typedef enum {
HTTP_DELETE,
HTTP_GET,
HTTP_HEAD,
HTTP_POST,
HTTP_PUT
} HTTP_REQUEST_TYPE;
/** @brief http error code */
typedef enum {
HTTP_EAGAIN = 1, /**< more data to retrieved */
HTTP_SUCCESS = 0, /**< operation success */
HTTP_ENOBUFS = -1, /**< buffer error */
HTTP_EARG = -2, /**< illegal argument */
HTTP_ENOTSUPP = -3, /**< not support */
HTTP_EDNS = -4, /**< DNS fail */
HTTP_ECONN = -5, /**< connect fail */
HTTP_ESEND = -6, /**< send packet fail */
HTTP_ECLSD = -7, /**< connect closed */
HTTP_ERECV = -8, /**< recv packet fail */
HTTP_EPARSE = -9, /**< url parse error */
HTTP_EPROTO = -10, /**< protocol error */
HTTP_EUNKOWN = -11, /**< unknown error */
HTTP_ETIMEOUT = -12, /**< timeout */
} HTTPC_RESULT;
/** @brief This structure defines the httpclient_t structure */
typedef struct {
int socket; /**< socket ID */
int remote_port; /**< hTTP or HTTPS port */
int response_code; /**< response code */
char *header; /**< request custom header */
char *auth_user; /**< username for basic authentication */
char *auth_password; /**< password for basic authentication */
bool is_http; /**< http connection? if 1, http; if 0, https */
#if CONFIG_HTTP_SECURE
const char *server_cert; /**< server certification */
const char *client_cert; /**< client certification */
const char *client_pk; /**< client private key */
int server_cert_len; /**< server certification lenght, server_cert buffer size */
int client_cert_len; /**< client certification lenght, client_cert buffer size */
int client_pk_len; /**< client private key lenght, client_pk buffer size */
void *ssl; /**< ssl content */
#endif
} httpclient_t;
/** @brief This structure defines the HTTP data structure. */
typedef struct {
bool is_more; /**< indicates if more data needs to be retrieved. */
bool is_chunked; /**< response data is encoded in portions/chunks.*/
int retrieve_len; /**< content length to be retrieved. */
int response_content_len; /**< response content length. */
int content_block_len; /**< the content length of one block. */
int post_buf_len; /**< post data length. */
int response_buf_len; /**< response body buffer length. */
int header_buf_len; /**< response head buffer lehgth. */
char *post_content_type; /**< content type of the post data. */
char *post_buf; /**< user data to be posted. */
char *response_buf; /**< buffer to store the response body data. */
char *header_buf; /**< buffer to store the response head data. */
bool is_redirected; /**< redirected URL? if 1, has redirect url; if 0, no redirect url */
char* redirect_url; /**< redirect url when got http 3** response code. */
} httpclient_data_t;
/**
* This function executes a GET request on a given URL. It blocks until completion.
* @param[in] client client is a pointer to the #httpclient_t.
* @param[in] url url is the URL to run the request.
* @param[in, out] client_data client_data is a pointer to the #httpclient_data_t instance to collect the data returned by the request.
* @return Please refer to #HTTPC_RESULT.
*/
HTTPC_RESULT httpclient_get(httpclient_t *client, const char *url, httpclient_data_t *client_data);
/**
* This function executes a HEAD request on a given URL. It blocks until completion.
* @param[in] client client is a pointer to the #httpclient_t.
* @param[in] url url is the URL to run the request.
* @param[in, out] client_data client_data is a pointer to the #httpclient_data_t instance to collect the data returned by the request.
* @return Please refer to #HTTPC_RESULT.
*/
HTTPC_RESULT httpclient_head(httpclient_t *client, const char *url, httpclient_data_t *client_data);
/**
* This function executes a POST request on a given URL. It blocks until completion.
* @param[in] client client is a pointer to the #httpclient_t.
* @param[in] url url is the URL to run the request.
* @param[in, out] client_data client_data is a pointer to the #httpclient_data_t instance to collect the data returned by the request. It also contains the data to be posted.
* @return Please refer to #HTTPC_RESULT.
*/
HTTPC_RESULT httpclient_post(httpclient_t *client, const char *url, httpclient_data_t *client_data);
/**
* This function executes a PUT request on a given URL. It blocks until completion.
* @param[in] client client is a pointer to the #httpclient_t.
* @param[in] url url is the URL to run the request.
* @param[in, out] client_data client_data is a pointer to the #httpclient_data_t instance to collect the data returned by the request. It also contains the data to be put.
* @return Please refer to #HTTPC_RESULT.
*/
HTTPC_RESULT httpclient_put(httpclient_t *client, const char *url, httpclient_data_t *client_data);
/**
* This function executes a DELETE request on a given URL. It blocks until completion.
* @param[in] client client is a pointer to the #httpclient_t.
* @param[in] url url is the URL to run the request.
* @param[in, out] client_data client_data is a pointer to the #httpclient_data_t instance to collect the data returned by the request.
* @return Please refer to #HTTPC_RESULT.
*/
HTTPC_RESULT httpclient_delete(httpclient_t *client, const char *url, httpclient_data_t *client_data);
/**
* This function allocates buffer for http header/response
* @param[in] client_data pointer to the #httpclient_data_t.
* @param[in] header_size header buffer size
* @param[in] resp_size response buffer size
* @return HTTP_SUCCESS success
* @return HTTP_EUNKOWN fail
*/
HTTPC_RESULT httpclient_prepare(httpclient_data_t *client_data, int header_size, int resp_size);
/**
* This function deallocates buffer for http header/response.
* @param[in] client_data pointer to the #httpclient_data_t.
* @return HTTP_SUCCESS success
* @return HTTP_EUNKOWN fail
*/
HTTPC_RESULT httpclient_unprepare(httpclient_data_t *client_data);
/**
* This function reset buffer for http header/response.
* @param[in] client_data pointer to the #httpclient_data_t.
* @return None.
*/
void httpclient_reset(httpclient_data_t *client_data);
/**
* This function establish http/https connection.
* @param[in] client pointer to the #httpclient_t.
* @param[in] url remote URL
* @return Please refer to #HTTPC_RESULT.
*/
HTTPC_RESULT httpclient_conn(httpclient_t *client, const char *url);
/**
* This function sends HTTP request.
* @param[in] client a pointer to the #httpclient_t.
* @param[in] url remote URL
* @param[in] method http request method
* @param[in] client_data a pointer to #httpclient_data_t.
* @return Please refer to #HTTPC_RESULT.
*/
HTTPC_RESULT httpclient_send(httpclient_t *client, const char *url, int method, httpclient_data_t *client_data);
/**
* This function receives response from remote
* @param[in] client a pointer to #httpclient_t.
* @param[out] client_data a pointer to #httpclient_data_t.
* @return Please refer to #HTTPC_RESULT.
*/
HTTPC_RESULT httpclient_recv(httpclient_t *client, httpclient_data_t *client_data);
/**
* This function close http connection.
* @param[in] client client is a pointer to the #httpclient_t.
* @return None.
*/
void httpclient_clse(httpclient_t *client);
/**
* This function sets a custom header.
* @param[in] client client is a pointer to the #httpclient_t.
* @param[in] header header is a custom header string.
* @return None.
*/
void httpclient_set_custom_header(httpclient_t *client, char *header);
/**
* This function gets the HTTP response code assigned to the last request.
* @param[in] client client is a pointer to the #httpclient_t.
* @return The HTTP response code of the last request.
*/
int httpclient_get_response_code(httpclient_t *client);
/**
* This function get specified response header value.
* @param[in] header_buf header_buf is the response header buffer.
* @param[in] name name is the specified http response header name.
* @param[in, out] val_pos val_pos is the position of header value in header_buf.
* @param[in, out] val_len val_len is header value length.
* @return 0, if value is got. Others, if errors occurred.
*/
int httpclient_get_response_header_value(char *header_buf, char *name, int *val_pos, int *val_len);
/**
* This function add text formdata information.
* @param[in] client_data client_data is a pointer to the #httpclient_data_t.
* @param[in] content_disposition content_disposition is a pointer to the content disposition string.
* @param[in] content_type content_type is a pointer to the content type string.
* @param[in] name name is a pointer to the name string.
* @param[in] data data is a pointer to the data.
* @param[in] data_len data_len is the data length.
* @return The HTTP response code of the last request.
*/
int httpclient_formdata_addtext(httpclient_data_t* client_data, char* content_disposition, char* content_type, char* name, char* data, int data_len);
/**
* This function add file formdata information.
* @param[in] client_data client_data is a pointer to the #httpclient_data_t.
* @param[in] content_disposition content_disposition is a pointer to the content disposition string.
* @param[in] content_type content_type is a pointer to the content type string.
* @param[in] file_path file_path is a pointer to the file path.
* @return The HTTP response code of the last request.
*/
int httpclient_formdata_addfile(httpclient_data_t* client_data, char* content_disposition, char* name, char* content_type, char* file_path);
#ifdef __cplusplus
}
#endif
#endif /* HTTPCLIENT_H */
| YifuLiu/AliOS-Things | components/http/include/httpclient.h | C | apache-2.0 | 11,145 |
/*
* Copyright (C) 2015-2020 Alibaba Group Holding Limited
*/
#ifndef HTTP_FORM_DATA
#define HTTP_FORM_DATA
#define HTTP_DATA_SIZE 1500
#define FORM_DATA_MAXLEN 32
#define CLIENT_FORM_DATA_NUM 1
typedef struct formdata_node_t formdata_node_t;
struct formdata_node_t
{
formdata_node_t *next;
int is_file;
char file_path[FORM_DATA_MAXLEN];
char *data;
int data_len;
};
typedef struct {
int is_used;
formdata_node_t *form_data;
httpclient_data_t *client_data;
} formdata_info_t;
void httpclient_clear_form_data(httpclient_data_t * client_data);
int httpclient_formdata_len(httpclient_data_t *client_data);
int httpclient_send_formdata(httpclient_t *client, httpclient_data_t *client_data);
#endif
| YifuLiu/AliOS-Things | components/http/internal/http_form_data.h | C | apache-2.0 | 762 |
/*
* Copyright (C) 2015-2020 Alibaba Group Holding Limited
*/
#ifndef HTTP_OPTS_H
#define HTTP_OPTS_H
#ifndef HTTPCLIENT_AUTHB_SIZE
#define HTTPCLIENT_AUTHB_SIZE 128
#endif
#ifndef HTTPCLIENT_CHUNK_SIZE
#define HTTPCLIENT_CHUNK_SIZE (2048) // 1024
#endif
#ifndef HTTPCLIENT_SEND_BUF_SIZE
#define HTTPCLIENT_SEND_BUF_SIZE 2048 //512
#endif
#ifndef HTTPCLIENT_MAX_HOST_LEN
#define HTTPCLIENT_MAX_HOST_LEN 128
#endif
#ifndef HTTPCLIENT_MAX_URL_LEN
#define HTTPCLIENT_MAX_URL_LEN 1024 // 512
#endif
#ifndef HTTPCLIENT_MAX_RECV_WAIT_MS
#define HTTPCLIENT_MAX_RECV_WAIT_MS 5000
#endif
#ifndef HTTP_PORT
#define HTTP_PORT 80
#endif
#ifndef HTTPS_PORT
#define HTTPS_PORT 443
#endif
#endif /* HTTP_OPTS_H */
| YifuLiu/AliOS-Things | components/http/internal/http_opts.h | C | apache-2.0 | 728 |
/*
* Copyright (C) 2015-2020 Alibaba Group Holding Limited
*/
#ifndef HTTP_CLIENT_WRAPPER_H
#define HTTP_CLIENT_WRAPPER_H
#define HTTP_CLIENT_DEBUG 0
#define HAL_Printf printf
#if HTTP_CLIENT_DEBUG
#define http_info(fmt, arg...) do { HAL_Printf("[%s %d] "fmt" \r\n", __func__, __LINE__, ##arg); } while (0)
#define http_err(fmt, arg...) do { HAL_Printf("[%s %d] "fmt" \r\n", __func__, __LINE__, ##arg); } while (0)
#define http_debug(fmt, arg...) do { HAL_Printf("[%s %d] "fmt" \r\n", __func__, __LINE__, ##arg); } while (0)
#else
#define http_info(fmt, arg...)
#define http_err(fmt, arg...) do { HAL_Printf("[%s %d] "fmt" \r\n", __func__, __LINE__, ##arg); } while (0)
#define http_debug(fmt, arg...)
#endif
#ifndef MIN
#define MIN(x,y) (((x)<(y))?(x):(y))
#endif
#ifndef MAX
#define MAX(x,y) (((x)>(y))?(x):(y))
#endif
int http_tcp_conn_wrapper(httpclient_t *client, const char *host);
int http_tcp_close_wrapper(httpclient_t *client);
int http_tcp_send_wrapper(httpclient_t *client, const char *data, int length);
int http_tcp_recv_wrapper(httpclient_t *client, char *buf, int buflen, int timeout_ms, int *p_read_len);
#if CONFIG_HTTP_SECURE
int http_ssl_conn_wrapper(httpclient_t *client, const char *host);
int http_ssl_close_wrapper(httpclient_t *client);
int http_ssl_send_wrapper(httpclient_t *client, const char *data, size_t length);
int http_ssl_recv_wrapper(httpclient_t *client, char *buf, int buflen, int timeout_ms, int *p_read_len);
#endif
#endif /* HTTP_CLIENT_WRAPPER_H */
| YifuLiu/AliOS-Things | components/http/internal/http_wrappers.h | C | apache-2.0 | 1,512 |
/*
* Copyright (C) 2015-2020 Alibaba Group Holding Limited
*/
#include <stdio.h>
#include <string.h>
#include <sys/time.h>
#include <unistd.h>
#include "httpclient.h"
#include "http_opts.h"
#include "http_wrappers.h"
#include <netdb.h>
#include <sys/socket.h>
#if CONFIG_HTTP_SECURE
#include "mbedtls/net.h"
#include "mbedtls/ssl.h"
#include "mbedtls/certs.h"
#include "mbedtls/entropy.h"
#include "mbedtls/ctr_drbg.h"
/** @brief This structure defines the httpclient ssl structure. */
typedef struct {
mbedtls_ssl_context ssl_ctx; /**< mbedtls ssl context */
mbedtls_net_context net_ctx; /**< fill in socket id */
mbedtls_ssl_config ssl_conf; /**< entropy context */
mbedtls_entropy_context entropy; /**< ssl configuration */
mbedtls_ctr_drbg_context ctr_drbg; /**< ctr drbg context */
mbedtls_x509_crt_profile profile; /**< x509 cacert profile */
mbedtls_x509_crt cacert; /**< x509 cacert */
mbedtls_x509_crt clicert; /**< x509 client cacert */
mbedtls_pk_context pkey; /**< pkey context */
} httpclient_ssl_t;
#if defined(MBEDTLS_DEBUG_C)
#define DEBUG_LEVEL 2
#endif
#endif
/*
* Conncection wrapper function for HTTP
* @param[in] client pointer to the httpclient.
* @param[in] host host url
* @return 0 success other failed
*/
int http_tcp_conn_wrapper(httpclient_t *client, const char *host)
{
struct addrinfo hints, *addr_list, *cur;
int ret = 0;
char port[10] = {0};
memset( &hints, 0, sizeof( hints ) );
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
snprintf(port, sizeof(port), "%d", client->remote_port) ;
if ( getaddrinfo( host, port , &hints, &addr_list ) != 0 ) {
http_err("getaddrinfo != 0, return EDNS");
return HTTP_EDNS;
}
/* Try the sockaddrs until a connection succeeds */
ret = HTTP_EDNS;
for ( cur = addr_list; cur != NULL; cur = cur->ai_next ) {
client->socket = (int) socket( cur->ai_family, cur->ai_socktype,
cur->ai_protocol );
if ( client->socket < 0 ) {
ret = HTTP_ECONN;
continue;
}
if ( connect( client->socket, cur->ai_addr, (int)cur->ai_addrlen ) == 0 ) {
ret = 0;
break;
}
close(client->socket);
ret = HTTP_ECONN;
}
freeaddrinfo( addr_list );
return ret;
}
int http_tcp_close_wrapper(httpclient_t *client)
{
close(client->socket);
client->socket = -1;
return 0;
}
int http_tcp_send_wrapper(httpclient_t *client, const char *data, int length)
{
int written_len = 0;
while (written_len < length) {
int ret = send(client->socket, data + written_len, length - written_len, 0);
if (ret > 0) {
written_len += ret;
continue;
} else if (ret == 0) {
return written_len;
} else {
http_err("Connection err ret=%d errno=%d\n", ret, errno);
return -1; /* Connnection error */
}
}
return written_len;
}
int http_tcp_recv_wrapper(httpclient_t *client, char *buf, int buflen, int timeout_ms, int *p_read_len)
{
int ret = 0, select_ret;
size_t readLen = 0;
struct timeval timeout;
fd_set sets;
int err_record;
int sockfd = client->socket;
timeout.tv_sec = timeout_ms / 1000;
timeout.tv_usec = 0;
while (readLen < buflen) {
FD_ZERO(&sets);
FD_SET(sockfd, &sets);
select_ret = select(sockfd + 1, &sets, NULL, NULL, &timeout);
err_record = errno;
if (select_ret > 0) {
if (0 == FD_ISSET(sockfd, &sets)) {
ret = 0;
http_debug("select continue");
continue;
}
ret = recv(sockfd, buf + readLen, buflen - readLen, 0);
err_record = errno;
if (ret < 0 ) {
if ((EINTR == err_record) || (EAGAIN == err_record) || (EWOULDBLOCK == err_record) ||
(EPROTOTYPE == err_record) || (EALREADY == err_record) || (EINPROGRESS == err_record)) {
http_debug("recv continue %d ret %d", err_record, ret);
continue;
}
} else if (ret == 0) {
http_debug("recv return 0 disconnected");
ret = HTTP_ECLSD;
}
} else if (select_ret == 0) {
http_info("select return 0 may disconnected");
ret = HTTP_ECLSD;
} else {
http_debug("select return %d errno %d", select_ret, err_record);
if (err_record == EINTR) {
continue;
}
ret = select_ret;
}
if (ret > 0) {
readLen += ret;
} else if (ret == HTTP_ECLSD) {
break;
} else {
http_err("Connection error (recv returned %d readLen:%d)", ret,readLen);
*p_read_len = readLen;
return HTTP_ECONN;
}
}
*p_read_len = readLen;
if (ret == HTTP_ECLSD) {
return ret;
} else {
return HTTP_SUCCESS;
}
}
#if CONFIG_HTTP_SECURE
int http_ssl_send_wrapper(httpclient_t *client, const char *data, size_t length)
{
size_t written_len = 0;
httpclient_ssl_t *ssl = (httpclient_ssl_t *) client->ssl;
if (!ssl) {
return -1;
}
while (written_len < length) {
int ret = mbedtls_ssl_write(&ssl->ssl_ctx, (unsigned char *)(data + written_len), (length - written_len));
if (ret > 0) {
written_len += ret;
continue;
} else if (ret == 0) {
return written_len;
} else {
return -1; /* Connnection error */
}
}
return written_len;
}
static void httpclient_debug( void *ctx, int level, const char *file, int line, const char *str )
{
http_debug("%s", str);
}
static int httpclient_random(void *prng, unsigned char *output, size_t output_len)
{
uint32_t rnglen = output_len;
uint8_t rngoffset = 0;
struct timeval time;
memset(&time, 0, sizeof(struct timeval));
gettimeofday(&time, NULL);
aos_srand((unsigned int)(time.tv_sec * 1000 + time.tv_usec / 1000) + aos_rand());
while (rnglen > 0) {
*(output + rngoffset) = (uint8_t)aos_rand();
rngoffset++;
rnglen--;
}
return 0;
}
int http_ssl_conn_wrapper(httpclient_t *client, const char *host)
{
int authmode = MBEDTLS_SSL_VERIFY_NONE;
#ifdef MBEDTLS_ENTROPY_C
const char *pers = "https";
#endif
int value, ret = 0;
uint32_t flags;
char port[10] = {0};
httpclient_ssl_t *ssl;
client->ssl = (httpclient_ssl_t *)calloc(1, sizeof(httpclient_ssl_t));
if (!client->ssl) {
http_err("Memory malloc error.");
ret = -1;
goto exit;
}
ssl = (httpclient_ssl_t *)client->ssl;
if (client->server_cert)
authmode = MBEDTLS_SSL_VERIFY_REQUIRED;
/*
* Initialize the RNG and the session data
*/
#if defined(MBEDTLS_DEBUG_C)
mbedtls_debug_set_threshold(DEBUG_LEVEL);
#endif
mbedtls_net_init(&ssl->net_ctx);
mbedtls_ssl_init(&ssl->ssl_ctx);
mbedtls_ssl_config_init(&ssl->ssl_conf);
#ifdef MBEDTLS_X509_CRT_PARSE_C
mbedtls_x509_crt_init(&ssl->cacert);
mbedtls_x509_crt_init(&ssl->clicert);
#endif
mbedtls_pk_init(&ssl->pkey);
#ifdef MBEDTLS_ENTROPY_C
mbedtls_ctr_drbg_init(&ssl->ctr_drbg);
mbedtls_entropy_init(&ssl->entropy);
if ((value = mbedtls_ctr_drbg_seed(&ssl->ctr_drbg,
mbedtls_entropy_func,
&ssl->entropy,
(const unsigned char*)pers,
strlen(pers))) != 0) {
http_err("mbedtls_ctr_drbg_seed() failed, value:-0x%x.", -value);
ret = -1;
goto exit;
}
#endif
/*
* Load the Client certificate
*/
if (client->client_cert && client->client_pk) {
#ifdef MBEDTLS_X509_CRT_PARSE_C
ret = mbedtls_x509_crt_parse(&ssl->clicert, (const unsigned char *)client->client_cert, client->client_cert_len);
if (ret < 0) {
http_err("Loading cli_cert failed! mbedtls_x509_crt_parse returned -0x%x.", -ret);
ret = -1;
goto exit;
}
#endif
ret = mbedtls_pk_parse_key(&ssl->pkey, (const unsigned char *)client->client_pk, client->client_pk_len, NULL, 0);
if (ret != 0) {
http_err("failed! mbedtls_pk_parse_key returned -0x%x.", -ret);
ret = -1;
goto exit;
}
}
/*
* Load the trusted CA
*/
/* cert_len passed in is gotten from sizeof not strlen */
#ifdef MBEDTLS_X509_CRT_PARSE_C
if (client->server_cert && ((value = mbedtls_x509_crt_parse(&ssl->cacert,
(const unsigned char *)client->server_cert,
client->server_cert_len)) < 0)) {
http_err("mbedtls_x509_crt_parse() failed, value:-0x%x.", -value);
ret = -1;
goto exit;
}
#endif
/*
* Start the connection
*/
snprintf(port, sizeof(port), "%d", client->remote_port) ;
if ((ret = mbedtls_net_connect(&ssl->net_ctx, host, port, MBEDTLS_NET_PROTO_TCP)) != 0) {
http_err("failed! mbedtls_net_connect returned %d, port:%s.", ret, port);
ret = -1;
goto exit;
}
client->socket = ssl->net_ctx.fd;
/*
* Setup stuff
*/
if ((value = mbedtls_ssl_config_defaults(&ssl->ssl_conf,
MBEDTLS_SSL_IS_CLIENT,
MBEDTLS_SSL_TRANSPORT_STREAM,
MBEDTLS_SSL_PRESET_DEFAULT)) != 0) {
http_err("mbedtls_ssl_config_defaults() failed, value:-0x%x.", -value);
ret = -1;
goto exit;
}
// TODO: add customerization encryption algorithm
#ifdef MBEDTLS_X509_CRT_PARSE_C
memcpy(&ssl->profile, ssl->ssl_conf.cert_profile, sizeof(mbedtls_x509_crt_profile));
ssl->profile.allowed_mds = ssl->profile.allowed_mds | MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_MD5);
mbedtls_ssl_conf_cert_profile(&ssl->ssl_conf, &ssl->profile);
mbedtls_ssl_conf_authmode(&ssl->ssl_conf, authmode);
mbedtls_ssl_conf_ca_chain(&ssl->ssl_conf, &ssl->cacert, NULL);
if (client->client_cert && (ret = mbedtls_ssl_conf_own_cert(&ssl->ssl_conf, &ssl->clicert, &ssl->pkey)) != 0) {
http_err(" failed! mbedtls_ssl_conf_own_cert returned %d.", ret );
ret = -1;
goto exit;
}
#endif
mbedtls_ssl_conf_rng(&ssl->ssl_conf, httpclient_random, &ssl->ctr_drbg);
mbedtls_ssl_conf_dbg(&ssl->ssl_conf, httpclient_debug, NULL);
if ((value = mbedtls_ssl_setup(&ssl->ssl_ctx, &ssl->ssl_conf)) != 0) {
http_err("mbedtls_ssl_setup() failed, value:-0x%x.", -value);
ret = -1;
goto exit;
}
mbedtls_ssl_set_bio(&ssl->ssl_ctx, &ssl->net_ctx, mbedtls_net_send, mbedtls_net_recv, mbedtls_net_recv_timeout);
mbedtls_ssl_conf_read_timeout(&ssl->ssl_conf, 10000);
/*
* Handshake
*/
while ((ret = mbedtls_ssl_handshake(&ssl->ssl_ctx)) != 0) {
if (ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE) {
http_err("mbedtls_ssl_handshake() failed, ret:-0x%x.", -ret);
ret = -1;
goto exit;
}
}
/*
* Verify the server certificate
*/
if ((flags = mbedtls_ssl_get_verify_result(&ssl->ssl_ctx)) != 0) {
char vrfy_buf[512];
http_err("svr_cert varification failed.");
mbedtls_x509_crt_verify_info(vrfy_buf, sizeof(vrfy_buf), " ! ", flags);
http_debug("%s", vrfy_buf);
ret = -1;
} else {
http_info("svr_cert varification ok.");
}
exit:
if (ret != 0) {
http_debug("ret=%d.", ret);
http_ssl_close_wrapper(client);
}
return ret;
}
int http_ssl_close_wrapper(httpclient_t *client)
{
httpclient_ssl_t *ssl = (httpclient_ssl_t *)client->ssl;
if (!ssl)
return -1;
client->ssl = NULL;
client->client_cert = NULL;
client->server_cert = NULL;
client->client_pk = NULL;
client->socket = -1;
mbedtls_ssl_close_notify(&ssl->ssl_ctx);
mbedtls_net_free(&ssl->net_ctx);
#ifdef MBEDTLS_X509_CRT_PARSE_C
mbedtls_x509_crt_free(&ssl->cacert);
mbedtls_x509_crt_free(&ssl->clicert);
#endif
mbedtls_pk_free(&ssl->pkey);
mbedtls_ssl_free(&ssl->ssl_ctx);
mbedtls_ssl_config_free(&ssl->ssl_conf);
#ifdef MBEDTLS_ENTROPY_C
mbedtls_ctr_drbg_free(&ssl->ctr_drbg);
mbedtls_entropy_free(&ssl->entropy);
#endif
free(ssl);
ssl = NULL;
return 0;
}
int http_ssl_recv_wrapper(httpclient_t *client, char *buf, int buflen, int timeout_ms, int *p_read_len)
{
int ret = 0;
size_t readLen = 0;
httpclient_ssl_t *ssl = (httpclient_ssl_t *) client->ssl;
if (!ssl) {
return HTTP_ECONN;
}
mbedtls_ssl_conf_read_timeout(&ssl->ssl_conf, timeout_ms);
while (readLen < buflen) {
ret = mbedtls_ssl_read(&ssl->ssl_ctx, (unsigned char *)buf + readLen, buflen - readLen);
if (ret == 0) {
ret = HTTP_ECLSD;
} else if (ret < 0) {
http_debug("mbedtls_ssl_read, return:%d", ret);
if ((MBEDTLS_ERR_SSL_TIMEOUT == ret)
|| (MBEDTLS_ERR_SSL_CONN_EOF == ret)
|| (MBEDTLS_ERR_SSL_SESSION_TICKET_EXPIRED == ret)
|| (MBEDTLS_ERR_SSL_NON_FATAL == ret)) {
/* read already complete */
/* if call mbedtls_ssl_read again, it will return 0 (means EOF) */
}
if (MBEDTLS_ERR_SSL_WANT_READ == ret) {
continue;
}
if (ret == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY) {
ret = HTTP_ECLSD;
}
}
if (ret > 0) {
readLen += ret;
} else if (ret == HTTP_ECLSD) {
break;
} else {
http_err("Connection error (recv returned %d readLen:%d)", ret,readLen);
*p_read_len = readLen;
return HTTP_ECONN;
}
}
*p_read_len = readLen;
if (ret == HTTP_ECLSD) {
return ret;
} else {
return HTTP_SUCCESS;
}
}
#endif
| YifuLiu/AliOS-Things | components/http/src/http_aos_wrapper.c | C | apache-2.0 | 14,477 |
/*
* Copyright (C) 2015-2020 Alibaba Group Holding Limited
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "httpclient.h"
#include "http_wrappers.h"
#include "http_form_data.h"
#include "http_opts.h"
/* base64 encode */
static void httpclient_base64enc(char *out, const char *in)
{
const char code[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=" ;
int i = 0, x = 0, l = 0;
for (; *in; in++) {
x = x << 8 | *in;
for (l += 8; l >= 6; l -= 6) {
out[i++] = code[(x >> (l - 6)) & 0x3f];
}
}
if (l > 0) {
x <<= 6 - l;
out[i++] = code[x & 0x3f];
}
for (; i % 4;) {
out[i++] = '=';
}
out[i] = '\0' ;
}
/* parse url according to http[s]://host[:port][/[path]] */
static int httpclient_parse_url(const char *url, char *scheme, size_t max_scheme_len, char *host, size_t maxhost_len, int *port, char *path, size_t max_path_len)
{
char *scheme_ptr = (char *) url;
char *host_ptr = NULL;
size_t host_len = 0;
size_t path_len;
char *port_ptr;
char *path_ptr;
char *fragment_ptr;
if (url == NULL) {
http_err("Could not find url");
return HTTP_EPARSE;
}
host_ptr = (char *) strstr(url, "://");
if (host_ptr == NULL) {
http_err("Could not find host");
return HTTP_EPARSE; /* URL is invalid */
}
if ( max_scheme_len < host_ptr - scheme_ptr + 1 ) { /* including NULL-terminating char */
http_err("Scheme str is too small (%d >= %d)", max_scheme_len, host_ptr - scheme_ptr + 1);
return HTTP_EPARSE;
}
memcpy(scheme, scheme_ptr, host_ptr - scheme_ptr);
scheme[host_ptr - scheme_ptr] = '\0';
host_ptr += 3;
port_ptr = strchr(host_ptr, ':');
if ( port_ptr != NULL ) {
uint16_t tport;
host_len = port_ptr - host_ptr;
port_ptr++;
if ( sscanf(port_ptr, "%hu", &tport) != 1) {
http_err("Could not find port");
return HTTP_EPARSE;
}
*port = (int)tport;
} else {
*port = 0;
}
path_ptr = strchr(host_ptr, '/');
if(path_ptr == NULL) {
http_err("Could not find '/'");
return HTTP_EPARSE;
}
if ( host_len == 0 ) {
host_len = path_ptr - host_ptr;
}
if ( maxhost_len < host_len + 1 ) { /* including NULL-terminating char */
http_err("Host str is too small (%d >= %d)", maxhost_len, host_len + 1);
return HTTP_EPARSE;
}
memcpy(host, host_ptr, host_len);
host[host_len] = '\0';
fragment_ptr = strchr(host_ptr, '#');
if (fragment_ptr != NULL) {
path_len = fragment_ptr - path_ptr;
} else {
path_len = strlen(path_ptr);
}
if ( max_path_len < path_len + 1 ) { /* including NULL-terminating char */
http_err("Path str is too small (%d >= %d)", max_path_len, path_len + 1);
return HTTP_EPARSE;
}
memcpy(path, path_ptr, path_len);
path[path_len] = '\0';
return HTTP_SUCCESS;
}
static int httpclient_get_info(httpclient_t *client, char *send_buf, int *send_idx, char *buf, size_t len) /* 0 on success, err code on failure */
{
int ret ;
int cp_len ;
int idx = *send_idx;
if (len == 0) {
len = strlen(buf);
}
do {
if ((HTTPCLIENT_SEND_BUF_SIZE - idx) >= len) {
cp_len = len ;
} else {
cp_len = HTTPCLIENT_SEND_BUF_SIZE - idx ;
}
memcpy(send_buf + idx, buf, cp_len) ;
idx += cp_len ;
len -= cp_len ;
if (idx == HTTPCLIENT_SEND_BUF_SIZE) {
if (client->is_http == false) {
http_err("send buffer overflow");
return HTTP_EUNKOWN;
}
ret = http_tcp_send_wrapper(client, send_buf, HTTPCLIENT_SEND_BUF_SIZE) ;
if (ret) {
return (ret) ;
}
}
} while (len) ;
*send_idx = idx;
return HTTP_SUCCESS;
}
void httpclient_set_custom_header(httpclient_t *client, char *header)
{
client->header = header ;
}
int httpclient_basic_auth(httpclient_t *client, char *user, char *password)
{
if ((strlen(user) + strlen(password)) >= HTTPCLIENT_AUTHB_SIZE) {
return HTTP_EUNKOWN;
}
client->auth_user = user;
client->auth_password = password;
return HTTP_SUCCESS;
}
static int httpclient_send_auth(httpclient_t *client, char *send_buf, int *send_idx)
{
char b_auth[(int)((HTTPCLIENT_AUTHB_SIZE + 3) * 4 / 3 + 3)] ;
char base64buff[HTTPCLIENT_AUTHB_SIZE + 3] ;
httpclient_get_info(client, send_buf, send_idx, "Authorization: Basic ", 0) ;
snprintf(base64buff, sizeof(base64buff), "%s:%s", client->auth_user, client->auth_password) ;
http_debug("bAuth: %s", base64buff) ;
httpclient_base64enc(b_auth, base64buff) ;
b_auth[strlen(b_auth) + 2] = '\0' ;
b_auth[strlen(b_auth) + 1] = '\n' ;
b_auth[strlen(b_auth)] = '\r' ;
http_debug("b_auth:%s", b_auth) ;
httpclient_get_info(client, send_buf, send_idx, b_auth, 0) ;
return HTTP_SUCCESS;
}
static const char *boundary = "----WebKitFormBoundarypNjgoVtFRlzPquKE";
/* send request header */
static int httpclient_send_header(httpclient_t *client, const char *url, int method, httpclient_data_t *client_data)
{
char scheme[8] = {0};
char *host = NULL;
char *path = NULL;
int host_size = HTTPCLIENT_MAX_HOST_LEN;
int path_size = HTTPCLIENT_MAX_URL_LEN;
int len, formdata_len;
int total_len = 0;
char *send_buf = NULL;
char *buf = NULL;
int send_buf_size = HTTPCLIENT_SEND_BUF_SIZE;
int buf_size = HTTPCLIENT_SEND_BUF_SIZE;
char *meth = (method == HTTP_GET) ? "GET" : (method == HTTP_POST) ? "POST" : (method == HTTP_PUT) ? "PUT" : (method == HTTP_DELETE) ? "DELETE" : (method == HTTP_HEAD) ? "HEAD" : "";
int ret, port;
host = (char *) malloc(host_size);
if (!host) {
http_err("host malloc failed");
ret = HTTP_ENOBUFS;
goto exit;
}
memset(host, 0, host_size);
path = (char *) malloc(path_size);
if (!path) {
http_err("path malloc failed");
ret = HTTP_ENOBUFS;
goto exit;
}
memset(path, 0, path_size);
send_buf = (char *) malloc(send_buf_size);
if (!send_buf) {
http_err("send_buf malloc failed");
ret = HTTP_ENOBUFS;
goto exit;
}
memset(send_buf, 0, send_buf_size);
buf = (char *) malloc(buf_size);
if (!buf) {
http_err("buf malloc failed");
ret = HTTP_ENOBUFS;
goto exit;
}
memset(buf, 0, buf_size);
/* First we need to parse the url (http[s]://host[:port][/[path]]) */
int res = httpclient_parse_url(url, scheme, sizeof(scheme), host, host_size, &(port), path, path_size);
if (res != HTTP_SUCCESS) {
http_err("httpclient_parse_url returned %d", res);
ret = res;
goto exit;
}
/* Send request */
len = 0 ; /* Reset send buffer */
snprintf(buf, buf_size, "%s %s HTTP/1.1\r\nUser-Agent: AliOS-HTTP-Client/2.1\r\nCache-Control: no-cache\r\nConnection: close\r\nHost: %s\r\n", meth, path, host); /* Write request */
ret = httpclient_get_info(client, send_buf, &len, buf, strlen(buf));
if (ret) {
http_err("Could not write request");
ret = HTTP_ECONN;
goto exit;
}
/* Send all headers */
if (client->auth_user) {
httpclient_send_auth(client, send_buf, &len) ; /* send out Basic Auth header */
}
/* Add user header information */
if (client->header) {
httpclient_get_info(client, send_buf, &len, (char *)client->header, strlen(client->header));
}
if ((formdata_len = httpclient_formdata_len(client_data)) > 0) {
total_len += formdata_len;
memset(buf, 0, buf_size);
snprintf(buf, buf_size, "Accept: */*\r\n");
httpclient_get_info(client, send_buf, &len, buf, strlen(buf));
if (client_data->post_content_type != NULL) {
memset(buf, 0, buf_size);
snprintf(buf, buf_size, "Content-Type: %s\r\n", client_data->post_content_type);
httpclient_get_info(client, send_buf, &len, buf, strlen(buf));
} else {
memset(buf, 0, buf_size);
snprintf(buf, buf_size, "Content-Type: multipart/form-data; boundary=%s\r\n", boundary);
httpclient_get_info(client, send_buf, &len, buf, strlen(buf));
}
total_len += strlen(boundary) + 8;
snprintf(buf, buf_size, "Content-Length: %d\r\n", total_len);
httpclient_get_info(client, send_buf, &len, buf, strlen(buf));
} else if ( client_data->post_buf != NULL ) {
snprintf(buf, buf_size, "Content-Length: %d\r\n", client_data->post_buf_len);
httpclient_get_info(client, send_buf, &len, buf, strlen(buf));
if (client_data->post_content_type != NULL) {
snprintf(buf, buf_size, "Content-Type: %s\r\n", client_data->post_content_type);
httpclient_get_info(client, send_buf, &len, buf, strlen(buf));
}
} else {
http_debug("Do nothing");
}
/* Close headers */
httpclient_get_info(client, send_buf, &len, "\r\n", 0);
http_debug("Trying to write %d bytes http header:%s", len, send_buf);
#if CONFIG_HTTP_SECURE
if (client->is_http == false) {
if (http_ssl_send_wrapper(client, send_buf, len) != len) {
http_err("SSL_write failed");
ret = HTTP_EUNKOWN;
goto exit;
}
ret = HTTP_SUCCESS;
goto exit;
}
#endif
ret = http_tcp_send_wrapper(client, send_buf, len);
if (ret > 0) {
http_debug("Written %d bytes, socket = %d", ret, client->socket);
} else if ( ret == 0 ) {
http_err("ret == 0,Connection was closed by server");
ret = HTTP_ECLSD;
goto exit; /* Connection was closed by server */
} else {
http_err("Connection error (send returned %d)", ret);
ret = HTTP_ECONN;
goto exit;
}
ret = HTTP_SUCCESS;
exit:
if (host) {
free(host);
host = NULL;
}
if (path) {
free(path);
path = NULL;
}
if (send_buf) {
free(send_buf);
send_buf = NULL;
}
if (buf) {
free(buf);
buf = NULL;
}
return ret;
}
static int httpclient_send_userdata(httpclient_t *client, httpclient_data_t *client_data)
{
int ret = 0;
if (client_data->post_buf && client_data->post_buf_len) {
http_debug("client_data->post_buf:%s", client_data->post_buf);
#if CONFIG_HTTP_SECURE
if (client->is_http == false) {
if (http_ssl_send_wrapper(client, client_data->post_buf, client_data->post_buf_len) != client_data->post_buf_len) {
http_err("SSL_write failed");
return HTTP_EUNKOWN;
}
} else
#endif
{
ret = http_tcp_send_wrapper(client, client_data->post_buf, client_data->post_buf_len);
if (ret > 0) {
http_debug("Written %d bytes", ret);
} else if ( ret == 0 ) {
http_debug("ret == 0,Connection was closed by server");
return HTTP_ECLSD; /* Connection was closed by server */
} else {
http_err("Connection error (send returned %d)", ret);
return HTTP_ECONN;
}
}
} else if(httpclient_send_formdata(client, client_data) < 0) {
return HTTP_ECONN;
}
return HTTP_SUCCESS;
}
static int httpclient_recv_data(httpclient_t *client, char *buf, int min_len, int max_len, int *p_read_len)
{
int ret = 0;
int timeout_ms = 5000;
if (client->is_http) {
ret = http_tcp_recv_wrapper(client, buf, max_len, timeout_ms, p_read_len);
}
#if CONFIG_HTTP_SECURE
else {
ret = http_ssl_recv_wrapper(client, buf, max_len, timeout_ms, p_read_len);
}
#endif
return ret;
}
static int httpclient_retrieve_content(httpclient_t *client, char *data, int len, httpclient_data_t *client_data)
{
int count = 0;
int templen = 0;
int crlf_pos;
client_data->is_more = true;
if (client_data->response_content_len == -1 && client_data->is_chunked == false) {
while(true)
{
int ret, max_len;
if (count + len < client_data->response_buf_len - 1) {
memcpy(client_data->response_buf + count, data, len);
count += len;
client_data->response_buf[count] = '\0';
} else {
memcpy(client_data->response_buf + count, data, client_data->response_buf_len - 1 - count);
client_data->response_buf[client_data->response_buf_len - 1] = '\0';
client_data->content_block_len = client_data->response_buf_len - 1;
return HTTP_EAGAIN;
}
max_len = MIN(HTTPCLIENT_CHUNK_SIZE - 1, client_data->response_buf_len - 1 - count);
if (max_len <= 0) {
http_err("%s %d error max_len %d", __func__, __LINE__, max_len);
return HTTP_EUNKOWN;
}
ret = httpclient_recv_data(client, data, 1, max_len, &len);
/* Receive data */
http_debug("data len: %d %d", len, count);
if (ret == HTTP_ECONN) {
http_debug("ret == HTTP_ECONN");
client_data->content_block_len = count;
return ret;
}
if (len == 0) {/* read no more data */
http_debug("no more len == 0");
client_data->is_more = false;
return HTTP_SUCCESS;
}
http_debug("in loop %s %d ret %d len %d", __func__, __LINE__, ret, len);
}
}
while (true) {
size_t readLen = 0;
if ( client_data->is_chunked && client_data->retrieve_len <= 0) {
/* Read chunk header */
bool foundCrlf;
int n;
do {
int ret = -1;
foundCrlf = false;
crlf_pos = 0;
data[len] = 0;
if (len >= 2) {
for (; crlf_pos < len - 2; crlf_pos++) {
if ( data[crlf_pos] == '\r' && data[crlf_pos + 1] == '\n' ) {
foundCrlf = true;
break;
}
}
}
if (!foundCrlf) { /* Try to read more */
if ( len < HTTPCLIENT_CHUNK_SIZE ) {
int new_trf_len;
int max_recv = MIN(client_data->response_buf_len, HTTPCLIENT_CHUNK_SIZE);
if (max_recv - len - 1 <= 0) {
http_err("%s %d error max_len %d", __func__, __LINE__, max_recv - len - 1);
return HTTP_EUNKOWN;
}
ret = httpclient_recv_data(client, data + len, 0, max_recv - len - 1 , &new_trf_len);
len += new_trf_len;
if ((ret == HTTP_ECONN) || (ret == HTTP_ECLSD && new_trf_len == 0)) {
return ret;
} else {
http_debug("in loop %s %d ret %d len %d", __func__, __LINE__, ret, len);
continue;
}
} else {
return HTTP_EUNKOWN;
}
}
http_debug("in loop %s %d len %d ret %d", __func__, __LINE__, len, ret);
} while (!foundCrlf);
data[crlf_pos] = '\0';
n = sscanf(data, "%x", &readLen);/* chunk length */
client_data->retrieve_len = readLen;
client_data->response_content_len += client_data->retrieve_len;
if (n != 1) {
http_err("Could not read chunk length");
return HTTP_EPROTO;
}
memmove(data, &data[crlf_pos + 2], len - (crlf_pos + 2)); /* Not need to move NULL-terminating char any more */
len -= (crlf_pos + 2);
if ( readLen == 0 ) {
/* Last chunk */
client_data->is_more = false;
http_debug("no more (last chunk)");
break;
}
} else {
readLen = client_data->retrieve_len;
}
http_debug("Retrieving %d bytes, len:%d", readLen, len);
do {
int ret;
http_debug("readLen %d, len:%d", readLen, len);
templen = MIN(len, readLen);
if (count + templen < client_data->response_buf_len - 1) {
memcpy(client_data->response_buf + count, data, templen);
count += templen;
client_data->response_buf[count] = '\0';
client_data->retrieve_len -= templen;
} else {
memcpy(client_data->response_buf + count, data, client_data->response_buf_len - 1 - count);
client_data->response_buf[client_data->response_buf_len - 1] = '\0';
client_data->retrieve_len -= (client_data->response_buf_len - 1 - count);
client_data->content_block_len = client_data->response_buf_len - 1;
return HTTP_EAGAIN;
}
if ( len >= readLen ) {
http_debug("memmove %d %d %d", readLen, len, client_data->retrieve_len);
memmove(data, &data[readLen], len - readLen); /* chunk case, read between two chunks */
len -= readLen;
readLen = 0;
client_data->retrieve_len = 0;
} else {
readLen -= len;
}
if (readLen) {
int max_len = MIN(MIN(HTTPCLIENT_CHUNK_SIZE - 1, client_data->response_buf_len - 1 - count), readLen);
if (max_len <= 0) {
http_err("%s %d error max_len %d", __func__, __LINE__, max_len);
return HTTP_EUNKOWN;
}
ret = httpclient_recv_data(client, data, 1, max_len, &len);
if (ret == HTTP_ECONN || (ret == HTTP_ECLSD && len == 0)) {
return ret;
}
}
} while (readLen);
if ( client_data->is_chunked ) {
if (len < 2) {
int new_trf_len = 0, ret;
int max_recv = MIN(client_data->response_buf_len - 1 - count + 2, HTTPCLIENT_CHUNK_SIZE - len - 1);
if (max_recv <= 0) {
http_err("%s %d error max_len %d", __func__, __LINE__, max_recv);
return HTTP_EUNKOWN;
}
/* Read missing chars to find end of chunk */
ret = httpclient_recv_data(client, data + len, 2 - len, max_recv, &new_trf_len);
if ((ret == HTTP_ECONN) || (ret == HTTP_ECLSD && new_trf_len == 0)) {
return ret;
}
len += new_trf_len;
}
if ( (data[0] != '\r') || (data[1] != '\n') ) {
http_err("Format error, %s", data); /* after memmove, the beginning of next chunk */
return HTTP_EPROTO;
}
memmove(data, &data[2], len - 2); /* remove the \r\n */
len -= 2;
} else {
http_err("no more(content-length)");
client_data->is_more = false;
break;
}
}
client_data->content_block_len = count;
return HTTP_SUCCESS;
}
static int httpclient_response_parse(httpclient_t *client, char *data, int len, httpclient_data_t *client_data)
{
int crlf_pos;
int header_buf_len = client_data->header_buf_len;
char *header_buf = client_data->header_buf;
int read_result;
// reset the header buffer
if (header_buf) {
memset(header_buf, 0, header_buf_len);
}
client_data->response_content_len = -1;
char *crlf_ptr = strstr(data, "\r\n");
if (crlf_ptr == NULL) {
http_err("\r\n not found");
return HTTP_EPROTO;
}
crlf_pos = crlf_ptr - data;
data[crlf_pos] = '\0';
/* Parse HTTP response */
if ( sscanf(data, "HTTP/%*d.%*d %d %*[^\r\n]", &(client->response_code)) != 1 ) {
/* Cannot match string, error */
http_err("Not a correct HTTP answer : %s", data);
return HTTP_EPROTO;
}
if ( (client->response_code < 200) || (client->response_code >= 400) ) {
/* Did not return a 2xx code; TODO fetch headers/(&data?) anyway and implement a mean of writing/reading headers */
http_debug("Response code %d", client->response_code);
if (client->response_code == 416) {
http_err("Requested Range Not Satisfiable");
return HTTP_EUNKOWN;
}
}
memmove(data, &data[crlf_pos + 2], len - (crlf_pos + 2) + 1); /* Be sure to move NULL-terminating char as well */
len -= (crlf_pos + 2);
client_data->is_chunked = false;
/* Now get headers */
while ( true ) {
char *colon_ptr, *key_ptr, *value_ptr;
int key_len, value_len;
crlf_ptr = strstr(data, "\r\n");
if (crlf_ptr == NULL) {
if ( len < HTTPCLIENT_CHUNK_SIZE - 1 ) {
int new_trf_len = 0;
if (HTTPCLIENT_CHUNK_SIZE - len - 1 <= 0) {
http_err("%s %d error max_len %d", __func__, __LINE__, HTTPCLIENT_CHUNK_SIZE - len - 1);
return HTTP_EUNKOWN;
}
read_result = httpclient_recv_data(client, data + len, 1, HTTPCLIENT_CHUNK_SIZE - len - 1, &new_trf_len);
len += new_trf_len;
data[len] = '\0';
http_debug("Read %d chars; In buf: [%s]", new_trf_len, data);
if ((read_result == HTTP_ECONN) || (read_result == HTTP_ECLSD && new_trf_len == 0)) {
return read_result;
} else {
http_debug("in loop %s %d ret %d len %d", __func__, __LINE__, read_result, len);
continue;
}
} else {
http_err("header len > chunksize");
return HTTP_EUNKOWN;
}
}
crlf_pos = crlf_ptr - data;
if (crlf_pos == 0) { /* End of headers */
memmove(data, &data[2], len - 2 + 1); /* Be sure to move NULL-terminating char as well */
len -= 2;
break;
}
colon_ptr = strstr(data, ": ");
if (colon_ptr) {
if (header_buf_len >= crlf_pos + 2 && header_buf) {
/* copy response header to caller buffer */
memcpy(header_buf, data, crlf_pos + 2);
header_buf += crlf_pos + 2;
header_buf_len -= crlf_pos + 2;
}
key_len = colon_ptr - data;
value_len = crlf_ptr - colon_ptr - strlen(": ");
key_ptr = data;
value_ptr = colon_ptr + strlen(": ");
http_debug("Read header : %.*s: %.*s", key_len, key_ptr, value_len, value_ptr);
if (0 == strncasecmp(key_ptr, "Content-Length", key_len)) {
sscanf(value_ptr, "%d[^\r]", &(client_data->response_content_len));
client_data->retrieve_len = client_data->response_content_len;
} else if (0 == strncasecmp(key_ptr, "Transfer-Encoding", key_len)) {
if (0 == strncasecmp(value_ptr, "Chunked", value_len)) {
client_data->is_chunked = true;
client_data->response_content_len = 0;
client_data->retrieve_len = 0;
}
} else if ((client->response_code >= 300 && client->response_code < 400) && (0 == strncasecmp(key_ptr, "Location", key_len))) {
if ( HTTPCLIENT_MAX_URL_LEN < value_len + 1 ) {
http_err("url is too large (%d >= %d)", value_len + 1, HTTPCLIENT_MAX_URL_LEN);
return HTTP_EUNKOWN;
}
if(client_data->redirect_url == NULL) {
client_data->redirect_url = (char* )malloc(HTTPCLIENT_MAX_URL_LEN);
}
memset(client_data->redirect_url, 0, HTTPCLIENT_MAX_URL_LEN);
memcpy(client_data->redirect_url, value_ptr, value_len);
client_data->is_redirected = 1;
}
memmove(data, &data[crlf_pos + 2], len - (crlf_pos + 2) + 1); /* Be sure to move NULL-terminating char as well */
len -= (crlf_pos + 2);
} else {
http_err("Could not parse header");
return HTTP_EUNKOWN;
}
}
return httpclient_retrieve_content(client, data, len, client_data);
}
HTTPC_RESULT httpclient_conn(httpclient_t *client, const char *url)
{
int ret = HTTP_ECONN;
char *host = NULL;
char scheme[8] = {0};
char *path = NULL;
int host_size = HTTPCLIENT_MAX_HOST_LEN;
int path_size = HTTPCLIENT_MAX_URL_LEN;
host = (char *) malloc(host_size);
if (!host) {
http_err("host malloc failed");
ret = HTTP_ENOBUFS;
goto exit;
}
memset(host, 0, host_size);
path = (char *) malloc(path_size);
if (!path) {
http_err("path malloc failed");
ret = HTTP_ENOBUFS;
goto exit;
}
memset(path, 0, path_size);
/* First we need to parse the url (http[s]://host[:port][/[path]]) */
int res = httpclient_parse_url(url, scheme, sizeof(scheme), host, host_size, &(client->remote_port), path, path_size);
if (res != HTTP_SUCCESS) {
http_err("httpclient_parse_url returned %d", res);
ret = res;
goto exit;
}
// http or https
if (strcmp(scheme, "https") == 0) {
client->is_http = false;
}
else if (strcmp(scheme, "http") == 0)
{
client->is_http = true;
}
// default http 80 port, https 443 port
if (client->remote_port == 0) {
if (client->is_http) {
client->remote_port = HTTP_PORT;
} else {
client->remote_port = HTTPS_PORT;
}
}
client->socket = -1;
if (client->is_http) {
ret = http_tcp_conn_wrapper(client, host);
}
#if CONFIG_HTTP_SECURE
else {
ret = http_ssl_conn_wrapper(client, host);
}
#endif
exit:
if (host) {
free(host);
host = NULL;
}
if (path) {
free(path);
path = NULL;
}
http_debug("httpclient_conn() result:%d, client:%p", ret, client);
return (HTTPC_RESULT)ret;
}
HTTPC_RESULT httpclient_send(httpclient_t *client, const char *url, int method, httpclient_data_t *client_data)
{
int ret = HTTP_ECONN;
if (client->socket < 0) {
return (HTTPC_RESULT)ret;
}
ret = httpclient_send_header(client, url, method, client_data);
if (ret != 0) {
return (HTTPC_RESULT)ret;
}
if (method == HTTP_POST || method == HTTP_PUT) {
ret = httpclient_send_userdata(client, client_data);
}
http_debug("httpclient_send() result:%d, client:%p", ret, client);
return (HTTPC_RESULT)ret;
}
HTTPC_RESULT httpclient_recv(httpclient_t *client, httpclient_data_t *client_data)
{
int reclen = 0;
int ret = HTTP_ECONN;
// TODO: header format: name + value must not bigger than HTTPCLIENT_CHUNK_SIZE.
char *buf = NULL;
if (client_data->header_buf_len < HTTPCLIENT_CHUNK_SIZE ||
client_data->response_buf_len < HTTPCLIENT_CHUNK_SIZE) {
http_err("Error: header buffer or response buffer should not less than %d!", HTTPCLIENT_CHUNK_SIZE);
ret = HTTP_EARG;
goto exit;
}
buf = (char *) malloc(HTTPCLIENT_CHUNK_SIZE);
if (!buf) {
http_err("Malloc failed socket fd %d!", client->socket);
ret = HTTP_ENOBUFS;
goto exit;
}
memset(buf, 0, HTTPCLIENT_CHUNK_SIZE);
if (client->socket < 0) {
http_err("Invalid socket fd %d!", client->socket);
goto exit;
}
if (client_data->is_more) {
client_data->response_buf[0] = '\0';
ret = httpclient_retrieve_content(client, buf, reclen, client_data);
} else {
ret = httpclient_recv_data(client, buf, 1, HTTPCLIENT_CHUNK_SIZE - 1, &reclen);
if (ret != HTTP_SUCCESS && ret != HTTP_ECLSD) {
goto exit;
}
buf[reclen] = '\0';
if (reclen) {
http_debug("reclen:%d, buf:%s", reclen, buf);
ret = httpclient_response_parse(client, buf, reclen, client_data);
}
}
http_debug("httpclient_recv_data() result:%d, client:%p", ret, client);
exit:
if (buf) {
free(buf);
buf = NULL;
}
return (HTTPC_RESULT)ret;
}
void httpclient_clse(httpclient_t *client)
{
if (client->is_http) {
http_tcp_close_wrapper(client);
}
#if CONFIG_HTTP_SECURE
else
http_ssl_close_wrapper(client);
#endif
client->socket = -1;
http_debug("httpclient_clse() client:%p", client);
}
int httpclient_get_response_code(httpclient_t *client)
{
return client->response_code;
}
int httpclient_get_response_header_value(char *header_buf, char *name, int *val_pos, int *val_len)
{
char *data = header_buf;
char *crlf_ptr, *colon_ptr, *key_ptr, *value_ptr;
int key_len, value_len;
if (header_buf == NULL || name == NULL || val_pos == NULL || val_len == NULL )
return -1;
while (true) {
crlf_ptr = strstr(data, "\r\n");
colon_ptr = strstr(data, ": ");
if (crlf_ptr && colon_ptr) {
key_len = colon_ptr - data;
value_len = crlf_ptr - colon_ptr - strlen(": ");
key_ptr = data;
value_ptr = colon_ptr + strlen(": ");
http_debug("Response header: %.*s: %.*s", key_len, key_ptr, value_len, value_ptr);
if (0 == strncasecmp(key_ptr, name, key_len)) {
*val_pos = value_ptr - header_buf;
*val_len = value_len;
return 0;
} else {
data = crlf_ptr + 2;
continue;
}
} else
return -1;
}
}
HTTPC_RESULT httpclient_prepare(httpclient_data_t *client_data, int header_size, int resp_size)
{
HTTPC_RESULT ret = HTTP_SUCCESS;
if (!client_data)
return HTTP_EUNKOWN;
if (header_size < HTTPCLIENT_CHUNK_SIZE || resp_size < HTTPCLIENT_CHUNK_SIZE) {
http_err("Error: header buffer or response buffer should not less than %d!", HTTPCLIENT_CHUNK_SIZE);
return HTTP_EARG;
}
memset(client_data, 0, sizeof(httpclient_data_t));
client_data->header_buf = (char *) malloc (header_size);
client_data->response_buf = (char *) malloc (resp_size);
if (client_data->header_buf == NULL || client_data->response_buf == NULL){
http_err("httpc_prepare alloc memory failed");
if(client_data->header_buf){
free(client_data->header_buf);
client_data->header_buf = NULL;
}
if(client_data->response_buf){
free(client_data->response_buf);
client_data->response_buf = NULL;
}
ret = HTTP_EUNKOWN;
goto finish;
}
http_debug("httpc_prepare alloc memory");
client_data->header_buf_len = header_size;
client_data->response_buf_len = resp_size;
client_data->post_buf_len = 0;
client_data->is_redirected = 0;
client_data->redirect_url = NULL;
finish:
return ret;
}
void httpclient_reset(httpclient_data_t *client_data)
{
char *response_buf = client_data->response_buf;
char *header_buf = client_data->header_buf;
int response_buf_len = client_data->response_buf_len;
int header_buf_len = client_data->header_buf_len;
memset(client_data, 0, sizeof(httpclient_data_t));
client_data->response_buf = response_buf;
client_data->header_buf = header_buf;
client_data->response_buf_len = response_buf_len;
client_data->header_buf_len = header_buf_len;
}
HTTPC_RESULT httpclient_unprepare(httpclient_data_t *client_data)
{
HTTPC_RESULT ret = HTTP_SUCCESS;
if (!client_data){
ret = HTTP_EUNKOWN;
goto finish;
}
if(client_data->header_buf){
free(client_data->header_buf);
client_data->header_buf = NULL;
}
if(client_data->response_buf){
free(client_data->response_buf);
client_data->response_buf = NULL;
}
client_data->header_buf_len = 0;
client_data->response_buf_len = 0;
client_data->is_redirected = 0;
if (client_data->redirect_url) {
free(client_data->redirect_url);
client_data->redirect_url = NULL;
}
finish:
return ret;
}
| YifuLiu/AliOS-Things | components/http/src/http_client.c | C | apache-2.0 | 32,881 |
/*
* Copyright (C) 2015-2020 Alibaba Group Holding Limited
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include "httpclient.h"
#include "http_form_data.h"
#include "http_wrappers.h"
static formdata_info_t formdata_info[CLIENT_FORM_DATA_NUM] = {0};
static void form_data_clear(formdata_node_t* form_data) {
if(form_data != NULL) {
form_data_clear(form_data->next);
form_data->next = NULL;
if(form_data->data != NULL) {
free(form_data->data);
}
free(form_data);
}
}
formdata_info_t* found_formdata_info(httpclient_data_t * client_data) {
int i;
for(i = 0; i < CLIENT_FORM_DATA_NUM; i++) {
if((formdata_info[i].client_data == client_data)
&& (formdata_info[i].is_used == 1)) {
break;
}
}
if(i == CLIENT_FORM_DATA_NUM) {
return NULL;
}
return &formdata_info[i];
}
static formdata_info_t* found_empty_formdata_info() {
int i;
for(i = 0; i < CLIENT_FORM_DATA_NUM; i++) {
if(formdata_info[i].is_used == 0) {
break;
}
}
if(i == CLIENT_FORM_DATA_NUM) {
return NULL;
}
return &formdata_info[i];
}
#define TEXT_FORMAT "\r\nContent-Disposition: %s; name=\"%s\"\r\n\r\n%s\r\n"
#define TEXT_CONTENT_TYPE_FORMAT "\r\nContent-Disposition :%s; name=\"%s\"\r\nContent-Type:%s\r\n\r\n%s\r\n"
int httpclient_formdata_addtext(httpclient_data_t* client_data, char* content_disposition, char* content_type, char* name, char* data, int data_len)
{
int buf_len;
formdata_info_t* data_info;
formdata_node_t* previous;
formdata_node_t* current;
if((content_disposition == NULL) || (name == NULL) || (data == NULL) || (data_len == 0)) {
http_err("%s:%d invalid params", __func__, __LINE__);
return -1;
}
if(strlen(data) > data_len) {
http_err("%s:%d invalid data_len %d strlen data %d", __func__, __LINE__, data_len, strlen(data));
return -1;
}
if((data_info = found_formdata_info(client_data)) == NULL) {
if((data_info = found_empty_formdata_info()) == NULL) {
http_err("%s:%d found no client_data info", __func__, __LINE__);
return -1;
}
}
if(data_info->is_used == 0) {
data_info->is_used = 1;
data_info->client_data = client_data;
data_info->form_data = (formdata_node_t *)malloc(sizeof(formdata_node_t));
if(data_info->form_data == NULL) {
data_info->is_used = 0;
http_err("%s:%d form data malloc failed", __func__, __LINE__);
return -1;
}
previous = data_info->form_data;
current = data_info->form_data;
}
else {
current = data_info->form_data;
while(current->next != NULL) {
current = current->next;
}
current->next = (formdata_node_t *)malloc(sizeof(formdata_node_t));
if(current->next == NULL) {
http_err("%s:%d form data malloc failed", __func__, __LINE__);
return -1;
}
previous = current;
current = current->next;
}
memset(current, 0, sizeof(formdata_node_t));
if(content_type == NULL) {
buf_len = strlen(TEXT_FORMAT) - 6 + strlen(content_disposition) + strlen(name) + strlen(data) + 1;
}
else {
buf_len = strlen(TEXT_CONTENT_TYPE_FORMAT) - 8 + strlen(content_disposition) + strlen(name) + strlen(data) + strlen(content_type) + 1;
}
current->data = (char*)malloc(buf_len+1);
if( current->data == NULL) {
if(previous == current ) {
free(current);
memset(data_info, 0, sizeof(formdata_info_t));
}
else {
free(current);
previous->next = NULL;
}
http_err("%s:%d data malloc failed", __func__, __LINE__);
return -1;
}
memset(current->data, 0, sizeof(buf_len));
if(content_type == NULL) {
snprintf(current->data, buf_len, TEXT_FORMAT, content_disposition, name, data);
current->data_len = strlen(current->data);
}
else {
snprintf(current->data, buf_len, TEXT_CONTENT_TYPE_FORMAT, content_disposition, name, content_type, data);
current->data_len = strlen(current->data);
}
return 0;
}
static int get_url_file_name(char* url)
{
char * ptr = url;
int offset = 0;
int i = 0;
while(*ptr != '\0')
{
i++;
if(*ptr == '/') {
offset = i;
}
ptr++;
}
return offset;
}
void httpclient_clear_form_data(httpclient_data_t * client_data)
{
formdata_info_t * data_info;
formdata_node_t * current;
data_info = found_formdata_info(client_data);
if(data_info == NULL) {
http_err("No form data info found");
return;
}
current = data_info->form_data;
if(current != NULL) {
form_data_clear(current);
}
else {
http_err("No form data in form data info");
}
memset(data_info, 0, sizeof(formdata_info_t));
}
#define FILE_FORMAT_START "\r\nContent-Disposition: %s; name=\"%s\"; filename=\"%s\"\r\n"
#define FILE_FORMAT_END "\r\nContent-Disposition: %s; name=\"%s\"; filename=\"\"\r\n"
#define FILE_FORMAT_CONTENT_TYPE_START "\r\nContent-Disposition: %s; name=\"%s\"; filename=\"%s\"\r\nContent-Type: %s\r\n\r\n"
int httpclient_formdata_addfile(httpclient_data_t* client_data, char* content_disposition, char* name, char* content_type, char* file_path)
{
int buf_len;
formdata_info_t* data_info;
formdata_node_t* previous;
formdata_node_t* current;
if((content_disposition == NULL) || (name == NULL) || (file_path == NULL)) {
http_err("%s:%d invalid params", __func__, __LINE__);
return -1;
}
if((data_info = found_formdata_info(client_data)) == NULL) {
if((data_info = found_empty_formdata_info()) == NULL) {
http_err("%s:%d found no client_data info", __func__, __LINE__);
return -1;
}
}
if(data_info->is_used == 0) {
data_info->is_used = 1;
data_info->client_data = client_data;
data_info->form_data = (formdata_node_t *)malloc(sizeof(formdata_node_t));
if(data_info->form_data == NULL) {
data_info->is_used = 0;
http_err("%s:%d data malloc failed", __func__, __LINE__);
return -1;
}
previous = data_info->form_data;
current = data_info->form_data;
}
else {
current = data_info->form_data;
while(current->next != NULL) {
current = current->next;
}
current->next = (formdata_node_t *)malloc(sizeof(formdata_node_t));
if(current->next == NULL) {
http_err("%s:%d data malloc failed", __func__, __LINE__);
return -1;
}
previous = current;
current = current->next;
}
memset(current, 0, sizeof(formdata_node_t));
if(content_type == NULL) {
buf_len = strlen(FILE_FORMAT_START) - 6 + strlen(content_disposition) + strlen(name) + strlen(file_path) - get_url_file_name(file_path) + 1;
}
else {
buf_len = strlen(FILE_FORMAT_CONTENT_TYPE_START) - 8 + strlen(content_disposition) + strlen(name) + strlen(file_path) - get_url_file_name(file_path) + strlen(content_type) + 1;
}
current->data = (char*)malloc(buf_len + 1);
if( current->data == NULL) {
if(previous == current ) {
free(current);
} else {
free(current);
previous->next = NULL;
}
http_err("%s:%d data malloc failed", __func__, __LINE__);
return -1;
}
memset(current->data, 0, sizeof(buf_len));
current->is_file = 1;
memcpy(current->file_path, file_path, strlen(file_path));
if(content_type == NULL) {
snprintf(current->data, buf_len, FILE_FORMAT_START, content_disposition, name, file_path + get_url_file_name(file_path));
}
else {
snprintf(current->data, buf_len, FILE_FORMAT_CONTENT_TYPE_START, content_disposition, name, file_path + get_url_file_name(file_path), content_type);
}
current->data_len = strlen(current->data);
return 0;
}
static const char *boundary = "----WebKitFormBoundarypNjgoVtFRlzPquKE";
int httpclient_formdata_len(httpclient_data_t *client_data)
{
int total_len = 0;
formdata_info_t* data_info = NULL;
formdata_node_t * current;
data_info = found_formdata_info(client_data);
if ((NULL == data_info) || (0 == data_info->is_used)) {
return 0;
}
current = data_info->form_data;
/* calculate content-length*/
do {
#if CONFIG_HTTP_FILE_OPERATE
if(current->is_file == 1) {
FILE* fd;
long size;
fd = fopen(current->file_path, "rb");
if(fd == NULL) {
http_err("%s: open file(%s) failed errno=%d", __func__, current->file_path, errno);
return -1;
}
fseek(fd,0,SEEK_END);
size=ftell(fd);
fseek(fd,0,SEEK_SET);
fclose(fd);
total_len += size;
}
#endif
total_len += current->data_len;
total_len += strlen(boundary) + 4;
current = current->next;
} while(current != NULL);
return total_len;
}
int httpclient_send_formdata(httpclient_t *client, httpclient_data_t *client_data)
{
int ret;
formdata_info_t* data_info = NULL;
formdata_node_t * current;
char data[HTTP_DATA_SIZE] = {0};
data_info = found_formdata_info(client_data);
if ((NULL == data_info) || (0 == data_info->is_used)) {
return 0;
}
current = data_info->form_data;
while(current != NULL) {
/* set boundary */
memset(data, 0, sizeof(data));
snprintf(data, sizeof(data), "\r\n--%s", boundary);
ret = http_tcp_send_wrapper(client, data, strlen(data));
if (ret <= 0) {
return -1;
}
ret = http_tcp_send_wrapper(client, current->data, current->data_len);
if (ret <= 0) {
return -1;
}
if(current->is_file == 1 ) {
break;
}
current = current->next;
}
if(current == NULL) {
return -1;
}
#if CONFIG_HTTP_FILE_OPERATE
{
FILE* fd = fopen(current->file_path, "rb");
if(fd == NULL) {
http_err("%s: open file(%s) failed errno=%d", __func__, current->file_path, errno);
return -1;
}
while(!feof(fd)) {
ret = fread(data, 1, sizeof(data), fd);
if(ret <= 0) {
http_err("fread failed returned %d errno=%d", ret, errno);
return -1;
}
ret = http_tcp_send_wrapper(client, data, ret);
if (ret > 0) {
http_err("Written %d bytes", ret);
} else if ( ret == 0 ) {
http_err("ret == 0,Connection was closed by server");
return HTTP_ECLSD; /* Connection was closed by server */
} else {
http_err("Connection error (send returned %d) errno=%d", ret, errno);
return HTTP_ECONN;
}
memset(data, 0, sizeof(data));
aos_msleep(100);
}
fclose(fd);
}
#endif
current = current->next;
while(current != NULL) {
memset(data, 0, sizeof(data));
snprintf(data, sizeof(data), "\r\n--%s", boundary);
ret = http_tcp_send_wrapper(client, data, strlen(data));
if (ret <= 0) {
return -1;
}
ret = http_tcp_send_wrapper(client, current->data, current->data_len);
if (ret <= 0) {
return -1;
}
current = current->next;
}
memset(data, 0, sizeof(data));
snprintf(data, sizeof(data), "\r\n--%s--\r\n", boundary);
ret = http_tcp_send_wrapper(client, data, strlen(data));
if (ret <= 0) {
return -1;
}
return 0;
}
| YifuLiu/AliOS-Things | components/http/src/http_formdata.c | C | apache-2.0 | 12,012 |
/*
* Copyright (C) 2015-2020 Alibaba Group Holding Limited
*/
#include <stdio.h>
#include <stdlib.h>
#include "httpclient.h"
#include "http_wrappers.h"
#include "http_form_data.h"
static HTTPC_RESULT httpclient_common(httpclient_t *client, const char *url, int method, httpclient_data_t *client_data)
{
HTTPC_RESULT ret = HTTP_ECONN;
/* reset httpclient redirect flag */
client_data->is_redirected = 0;
ret = httpclient_conn(client, url);
if (!ret) {
ret = httpclient_send(client, url, method, client_data);
if (!ret) {
ret = httpclient_recv(client, client_data);
}
}
/* Don't reset form data when got a redirected response */
if(client_data->is_redirected == 0) {
httpclient_clear_form_data(client_data);
}
httpclient_clse(client);
return ret;
}
HTTPC_RESULT httpclient_get(httpclient_t *client, const char *url, httpclient_data_t *client_data)
{
int ret = httpclient_common(client, url, HTTP_GET, client_data);
while((0 == ret) && (1 == client_data->is_redirected)) {
ret = httpclient_common(client, client_data->redirect_url, HTTP_GET, client_data);
}
if(client_data->redirect_url != NULL) {
free(client_data->redirect_url);
client_data->redirect_url = NULL;
}
return ret;
}
HTTPC_RESULT httpclient_head(httpclient_t *client, const char *url, httpclient_data_t *client_data)
{
int ret = httpclient_common(client, url, HTTP_HEAD, client_data);
while((0 == ret) && (1 == client_data->is_redirected)) {
ret = httpclient_common(client, client_data->redirect_url, HTTP_HEAD, client_data);
}
if(client_data->redirect_url != NULL) {
free(client_data->redirect_url);
client_data->redirect_url = NULL;
}
return ret;
}
HTTPC_RESULT httpclient_post(httpclient_t *client, const char *url, httpclient_data_t *client_data)
{
int ret = httpclient_common(client, url, HTTP_POST, client_data);
while((0 == ret) && (1 == client_data->is_redirected)) {
ret = httpclient_common(client, client_data->redirect_url, HTTP_POST, client_data);
}
if(client_data->redirect_url != NULL) {
free(client_data->redirect_url);
client_data->redirect_url = NULL;
}
return ret;
}
HTTPC_RESULT httpclient_put(httpclient_t *client, const char *url, httpclient_data_t *client_data)
{
int ret = httpclient_common(client, url, HTTP_PUT, client_data);
while((0 == ret) && (1 == client_data->is_redirected)) {
ret = httpclient_common(client, client_data->redirect_url, HTTP_PUT, client_data);
}
if(client_data->redirect_url != NULL) {
free(client_data->redirect_url);
client_data->redirect_url = NULL;
}
return ret;
}
HTTPC_RESULT httpclient_delete(httpclient_t *client, const char *url, httpclient_data_t *client_data)
{
return httpclient_common(client, url, HTTP_DELETE, client_data);
}
| YifuLiu/AliOS-Things | components/http/src/http_method_api.c | C | apache-2.0 | 2,954 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#include <fcntl.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#if(CONFIG_AOS_LWIP > 0)
#include <sys/socket.h>
#endif
#include "aos/init.h"
#if(AOS_COMP_CLI > 0)
#include "aos/cli.h"
#endif
#include "ulog/ulog.h"
// #include "uagent.h"
#include "aos/kernel.h"
#if(AOS_COMP_WIFI > 0)
#include "aos/hal/wifi.h"
#endif
#ifdef AOS_COMP_PWRMGMT
#include <pwrmgmt_api.h>
#endif
#ifdef AOS_COMP_LITTLEFS
#include "littlefs.h"
#endif
#ifdef AOS_COMP_FATFS
#include "fatfs.h"
#endif
#if AOS_COMP_DEBUG
#include "aos/debug.h"
#endif
#ifdef AOS_COMP_UND
#include "und/und.h"
#endif
#include "k_api.h"
#ifdef IPERF_ENABLED
extern int iperf_cli_register(void);
#endif
#ifdef PING_ENABLED
extern int ping_cli_register(void);
#endif
extern int vfs_init(void);
#ifdef AOS_LOOP
#include "aos/yloop.h"
extern aos_loop_t aos_loop_init(void);
#endif
extern int32_t kv_init(void);
extern void ota_service_init(void);
extern void dumpsys_cli_init(void);
#ifdef WITH_SAL
extern int sal_device_init(void);
#endif
#ifdef WITH_MAL
extern int mal_device_init(void);
#endif
#if defined(CONFIG_DRV_VFS) && (CONFIG_DRV_VFS == 1)
int u_driver_entry(char* string);
int u_post_driver_entry(char* string);
#endif
#ifdef AOS_BINS
extern void *kmbins_tbl[];
extern char app_info_addr;
extern k_mm_head *g_kmm_head;
struct m_app_info_t *app_info = (struct m_app_info_t *) &app_info_addr;
static void app_pre_init(void)
{
memcpy((void *)(app_info->data_ram_start), (void *)(app_info->data_flash_begin),
app_info->data_ram_end - app_info->data_ram_start);
memset((void *)(app_info->bss_start), 0, app_info->bss_end - app_info->bss_start);
krhino_add_mm_region(g_kmm_head, (void *)(app_info->heap_start),
app_info->heap_end - app_info->heap_start);
}
#endif
#if (AOS_COMP_CLI > 0)
#ifndef CONFIG_NO_LWIP
#if (CONFIG_AOS_LWIP > 0)
static void udp_cmd(char *buf, int len, int argc, char **argv)
{
struct sockaddr_in saddr;
if (argc < 4) {
return;
}
memset(&saddr, 0, sizeof(saddr));
saddr.sin_family = AF_INET;
saddr.sin_port = htons(atoi(argv[2]));
saddr.sin_addr.s_addr = inet_addr(argv[1]);
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) {
aos_cli_printf("error creating socket!\n");
return;
}
int ret = sendto(sockfd, argv[3], strlen(argv[3]), 0,
(struct sockaddr *)&saddr, sizeof(saddr));
if (ret < 0) {
aos_cli_printf("error send data %d!\n", ret);
}
close(sockfd);
}
struct cli_command tcpip_cli_cmd[] = {
/* net */
{"udp", "[ip] [port] [string data] send udp data", udp_cmd},
};
static void tcpip_cli_init(void)
{
aos_cli_register_commands(&tcpip_cli_cmd[0],sizeof(tcpip_cli_cmd) / sizeof(struct cli_command));
}
#ifdef AOS_NET_WITH_WIFI
static uint8_t hex(char c)
{
if (c >= '0' && c <= '9')
return c - '0';
if (c >= 'a' && c <= 'z')
return c - 'a' + 10;
if (c >= 'A' && c <= 'Z')
return c - 'A' + 10;
return 0;
}
static void hexstr2bin(const char *macstr, uint8_t *mac, int len)
{
int i;
for (i=0;i < len && macstr[2 * i];i++) {
mac[i] = hex(macstr[2 * i]) << 4;
mac[i] |= hex(macstr[2 * i + 1]);
}
}
static void wifi_debug_cmd(char *buf, int len, int argc, char **argv)
{
hal_wifi_start_debug_mode(NULL);
}
static void mac_cmd(char *buf, int len, int argc, char **argv)
{
uint8_t mac[6];
if (argc == 1)
{
hal_wifi_get_mac_addr(NULL, mac);
aos_cli_printf("MAC address: %02x-%02x-%02x-%02x-%02x-%02x\r\n",
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
}
else if(argc == 2)
{
hexstr2bin(argv[1], mac, 6);
hal_wifi_set_mac_addr(NULL, mac);
aos_cli_printf("Set MAC address: %02x-%02x-%02x-%02x-%02x-%02x\r\n",
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
}
else
{
aos_cli_printf("invalid cmd\r\n");
}
}
static struct cli_command wifi_cli_cmd[] = {
{ "wifi_debug", "wifi debug mode", wifi_debug_cmd },
{ "mac", "get/set mac", mac_cmd },
};
static void hal_wifi_cli_init(void)
{
aos_cli_register_commands(&wifi_cli_cmd[0],sizeof(wifi_cli_cmd) / sizeof(struct cli_command));
}
#endif /* AOS_NET_WITH_WIFI */
#endif /* CONFIG_AOS_LWIP */
#endif /*!defined CONFIG_NO_LWIP */
void cli_service_init(kinit_t *kinit)
{
if (kinit->cli_enable)
{
aos_cli_init();
/*kernel basic cmds reg*/
#ifndef CONFIG_NO_LWIP
#if(CONFIG_AOS_LWIP > 0)
tcpip_cli_init();
#ifdef AOS_NET_WITH_WIFI
hal_wifi_cli_init();
#endif
#ifdef IPERF_ENABLED
iperf_cli_register();
#endif
#ifdef PING_ENABLED
ping_cli_register();
#endif
#endif
#endif
}
return;
}
#endif
void aos_show_welcome(void)
{
puts(" Welcome to AliOS Things ");
#ifdef CONFIG_AOS_INIT_WELCOME
puts(" �����������[ �����[ �����[ �������������[ ���������������[ ");
puts(" �����X�T�T�����[�����U �����U�����X�T�T�T�����[�����X�T�T�T�T�a ");
puts(" ���������������U�����U �����U�����U �����U���������������[ ");
puts(" �����X�T�T�����U�����U �����U�����U �����U�^�T�T�T�T�����U ");
puts(" �����U �����U���������������[�����U�^�������������X�a���������������U ");
puts(" �^�T�a �^�T�a�^�T�T�T�T�T�T�a�^�T�a �^�T�T�T�T�T�a �^�T�T�T�T�T�T�a ");
puts("�����������������[�����[ �����[�����[�������[ �����[ �������������[ ���������������[");
puts("�^�T�T�����X�T�T�a�����U �����U�����U���������[ �����U�����X�T�T�T�T�a �����X�T�T�T�T�a");
puts(" �����U ���������������U�����U�����X�����[ �����U�����U �������[���������������[");
puts(" �����U �����X�T�T�����U�����U�����U�^�����[�����U�����U �����U�^�T�T�T�T�����U");
puts(" �����U �����U �����U�����U�����U �^���������U�^�������������X�a���������������U");
puts(" �^�T�a �^�T�a �^�T�a�^�T�a�^�T�a �^�T�T�T�a �^�T�T�T�T�T�a �^�T�T�T�T�T�T�a");
#endif
}
int aos_components_init(kinit_t *kinit)
{
#ifdef AOS_COMP_VFS
vfs_init();
#endif
#if defined(CONFIG_DRV_VFS) && (CONFIG_DRV_VFS == 1)
u_driver_entry("aos_components_init");
#endif
#ifdef AOS_COMP_UAGENT
uagent_init();
#endif
#if AOS_COMP_CLI
cli_service_init(kinit);
#endif
#if defined(CONFIG_DRV_VFS) && (CONFIG_DRV_VFS == 1)
u_post_driver_entry("aos_components_init");
#endif
#ifdef AOS_COMP_TRACE
TRACE_INIT();
#endif
#ifdef AOS_COMP_NFTL
nftl_init();
#endif
#ifdef AOS_COMP_FATFS
fatfs_register();
#endif
#ifdef AOS_COMP_LITTLEFS
littlefs_register();
#endif
#ifdef AOS_COMP_ULOG
ulog_init();
#endif
#ifdef AOS_COMP_KV
kv_init();
#endif
#ifdef WITH_SAL
sal_device_init();
#endif
#ifdef WITH_MAL
mal_device_init();
#endif
#ifdef AOS_LOOP
aos_loop_init();
#endif
#ifdef AOS_UOTA
ota_service_init();
#endif
#ifdef AOS_COMP_SENSOR
sensor_init();
#endif
#ifdef AOS_COMP_PWRMGMT
pwrmgmt_init();
#endif
#if AOS_COMP_DEBUG
aos_debug_init();
#endif
#ifdef AOS_COMP_UND
und_init();
#endif
aos_show_welcome();
#ifdef AOS_BINS
app_pre_init();
if (app_info->app_entry) {
app_info->app_entry((void *)kmbins_tbl, 0, NULL);
}
#endif
return 0;
}
| YifuLiu/AliOS-Things | components/init/aos_init.c | C | apache-2.0 | 8,728 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef AOS_INIT_H
#define AOS_INIT_H
#include <stdbool.h>
/** @defgroup init_aos_api init
* @{
*/
/* aos_component_init初始化参数 */
typedef struct {
int argc; /**< 参数个数 */
char **argv; /**< 参数内容 */
bool cli_enable; /**< cli是否初始化生效 */
} kinit_t;
/**
* aos 基础模块初始化.
*
* @param[in] kinit kinit_t类型的初始化参数.
*
* @return 固定返回0.
*/
extern int aos_components_init(kinit_t *kinit);
#ifndef AOS_BINS
/**
* 定义了用户app的入口函数形式定义。该函数由用户在app内自定义实现。
*
* @param[in] argc aos_components_init时传入的参数数目.
* @param[in] argv aos_components_init时传入的参数内容.
*
* @return 用户自定义.
*/
extern int application_start(int argc, char **argv);
#endif
/**
* @}
*/
/**
* AOS_BINS是多bin功能，HAAS单板不使用。
*/
#ifdef AOS_BINS
#include <k_api.h>
struct app_info_t {
void (*app_entry)(void *ksyscall_tbl, void *fsyscall_tbl, int argc, char *argv[]);
unsigned int data_ram_start;
unsigned int data_ram_end;
unsigned int data_flash_begin;
unsigned int bss_start;
unsigned int bss_end;
unsigned int heap_start;
unsigned int heap_end;
};
struct framework_info_t {
void (*framework_entry)(void *syscall_tbl, int argc, char *argv[]);
unsigned int data_ram_start;
unsigned int data_ram_end;
unsigned int data_flash_begin;
unsigned int bss_start;
unsigned int bss_end;
unsigned int heap_start;
unsigned int heap_end;
};
struct m_app_info_t {
void (*app_entry)(void *ksyscall_tbl, int argc, char *argv[]);
unsigned int data_ram_start;
unsigned int data_ram_end;
unsigned int data_flash_begin;
unsigned int bss_start;
unsigned int bss_end;
unsigned int heap_start;
unsigned int heap_end;
/* reserve for other */
unsigned int reserve0;
unsigned int reserve1;
/* this bin_type must be here, 0x28, uniform with single bin & kernel bin,
arm cortex not used */
unsigned int bin_type;
unsigned int reserve2;
unsigned int reserve3;
unsigned int reserve4;
unsigned int reserve5;
unsigned int reserve6;
};
#endif
#endif /* AOS_INIT_H */
| YifuLiu/AliOS-Things | components/init/include/aos/init.h | C | apache-2.0 | 2,367 |
set(CMAKE_HOST_SYSTEM "Linux-4.4.0-87-generic")
set(CMAKE_HOST_SYSTEM_NAME "Linux")
set(CMAKE_HOST_SYSTEM_VERSION "4.4.0-87-generic")
set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64")
set(CMAKE_SYSTEM "Linux-4.4.0-87-generic")
set(CMAKE_SYSTEM_NAME "Linux")
set(CMAKE_SYSTEM_VERSION "4.4.0-87-generic")
set(CMAKE_SYSTEM_PROCESSOR "x86_64")
set(CMAKE_CROSSCOMPILING "FALSE")
set(CMAKE_SYSTEM_LOADED 1)
| YifuLiu/AliOS-Things | components/jsoncpp/CMakeFiles/3.19.2/CMakeSystem.cmake | CMake | apache-2.0 | 398 |
/* This source file must have a .cpp extension so that all C++ compilers
recognize the extension without flags. Borland does not know .cxx for
example. */
#ifndef __cplusplus
# error "A C compiler has been selected for C++."
#endif
/* Version number components: V=Version, R=Revision, P=Patch
Version date components: YYYY=Year, MM=Month, DD=Day */
#if defined(__COMO__)
# define COMPILER_ID "Comeau"
/* __COMO_VERSION__ = VRR */
# define COMPILER_VERSION_MAJOR DEC(__COMO_VERSION__ / 100)
# define COMPILER_VERSION_MINOR DEC(__COMO_VERSION__ % 100)
#elif defined(__INTEL_COMPILER) || defined(__ICC)
# define COMPILER_ID "Intel"
# if defined(_MSC_VER)
# define SIMULATE_ID "MSVC"
# endif
# if defined(__GNUC__)
# define SIMULATE_ID "GNU"
# endif
/* __INTEL_COMPILER = VRP */
# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100)
# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10)
# if defined(__INTEL_COMPILER_UPDATE)
# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE)
# else
# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER % 10)
# endif
# if defined(__INTEL_COMPILER_BUILD_DATE)
/* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */
# define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE)
# endif
# if defined(_MSC_VER)
/* _MSC_VER = VVRR */
# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
# endif
# if defined(__GNUC__)
# define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
# elif defined(__GNUG__)
# define SIMULATE_VERSION_MAJOR DEC(__GNUG__)
# endif
# if defined(__GNUC_MINOR__)
# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
# endif
# if defined(__GNUC_PATCHLEVEL__)
# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
# endif
#elif defined(__PATHCC__)
# define COMPILER_ID "PathScale"
# define COMPILER_VERSION_MAJOR DEC(__PATHCC__)
# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__)
# if defined(__PATHCC_PATCHLEVEL__)
# define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__)
# endif
#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__)
# define COMPILER_ID "Embarcadero"
# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF)
# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF)
# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__ & 0xFFFF)
#elif defined(__BORLANDC__)
# define COMPILER_ID "Borland"
/* __BORLANDC__ = 0xVRR */
# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8)
# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF)
#elif defined(__WATCOMC__) && __WATCOMC__ < 1200
# define COMPILER_ID "Watcom"
/* __WATCOMC__ = VVRR */
# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100)
# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
# if (__WATCOMC__ % 10) > 0
# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
# endif
#elif defined(__WATCOMC__)
# define COMPILER_ID "OpenWatcom"
/* __WATCOMC__ = VVRP + 1100 */
# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100)
# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
# if (__WATCOMC__ % 10) > 0
# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
# endif
#elif defined(__SUNPRO_CC)
# define COMPILER_ID "SunPro"
# if __SUNPRO_CC >= 0x5100
/* __SUNPRO_CC = 0xVRRP */
# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>12)
# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xFF)
# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF)
# else
/* __SUNPRO_CC = 0xVRP */
# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>8)
# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xF)
# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF)
# endif
#elif defined(__HP_aCC)
# define COMPILER_ID "HP"
/* __HP_aCC = VVRRPP */
# define COMPILER_VERSION_MAJOR DEC(__HP_aCC/10000)
# define COMPILER_VERSION_MINOR DEC(__HP_aCC/100 % 100)
# define COMPILER_VERSION_PATCH DEC(__HP_aCC % 100)
#elif defined(__DECCXX)
# define COMPILER_ID "Compaq"
/* __DECCXX_VER = VVRRTPPPP */
# define COMPILER_VERSION_MAJOR DEC(__DECCXX_VER/10000000)
# define COMPILER_VERSION_MINOR DEC(__DECCXX_VER/100000 % 100)
# define COMPILER_VERSION_PATCH DEC(__DECCXX_VER % 10000)
#elif defined(__IBMCPP__) && defined(__COMPILER_VER__)
# define COMPILER_ID "zOS"
/* __IBMCPP__ = VRP */
# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100)
# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10)
#elif defined(__ibmxl__) && defined(__clang__)
# define COMPILER_ID "XLClang"
# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__)
# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__)
# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__)
# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__)
#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ >= 800
# define COMPILER_ID "XL"
/* __IBMCPP__ = VRP */
# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100)
# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10)
#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ < 800
# define COMPILER_ID "VisualAge"
/* __IBMCPP__ = VRP */
# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100)
# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10)
#elif defined(__PGI)
# define COMPILER_ID "PGI"
# define COMPILER_VERSION_MAJOR DEC(__PGIC__)
# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__)
# if defined(__PGIC_PATCHLEVEL__)
# define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__)
# endif
#elif defined(_CRAYC)
# define COMPILER_ID "Cray"
# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR)
# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR)
#elif defined(__TI_COMPILER_VERSION__)
# define COMPILER_ID "TI"
/* __TI_COMPILER_VERSION__ = VVVRRRPPP */
# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000)
# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000 % 1000)
# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__ % 1000)
#elif defined(__FUJITSU) || defined(__FCC_VERSION) || defined(__fcc_version)
# define COMPILER_ID "Fujitsu"
#elif defined(__ghs__)
# define COMPILER_ID "GHS"
/* __GHS_VERSION_NUMBER = VVVVRP */
# ifdef __GHS_VERSION_NUMBER
# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100)
# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10)
# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER % 10)
# endif
#elif defined(__SCO_VERSION__)
# define COMPILER_ID "SCO"
#elif defined(__ARMCC_VERSION) && !defined(__clang__)
# define COMPILER_ID "ARMCC"
#if __ARMCC_VERSION >= 1000000
/* __ARMCC_VERSION = VRRPPPP */
# define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000)
# define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100)
# define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000)
#else
/* __ARMCC_VERSION = VRPPPP */
# define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000)
# define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10)
# define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000)
#endif
#elif defined(__clang__) && defined(__apple_build_version__)
# define COMPILER_ID "AppleClang"
# if defined(_MSC_VER)
# define SIMULATE_ID "MSVC"
# endif
# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
# if defined(_MSC_VER)
/* _MSC_VER = VVRR */
# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
# endif
# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__)
#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION)
# define COMPILER_ID "ARMClang"
# define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000)
# define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100)
# define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION % 10000)
# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION)
#elif defined(__clang__)
# define COMPILER_ID "Clang"
# if defined(_MSC_VER)
# define SIMULATE_ID "MSVC"
# endif
# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
# if defined(_MSC_VER)
/* _MSC_VER = VVRR */
# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
# endif
#elif defined(__GNUC__) || defined(__GNUG__)
# define COMPILER_ID "GNU"
# if defined(__GNUC__)
# define COMPILER_VERSION_MAJOR DEC(__GNUC__)
# else
# define COMPILER_VERSION_MAJOR DEC(__GNUG__)
# endif
# if defined(__GNUC_MINOR__)
# define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__)
# endif
# if defined(__GNUC_PATCHLEVEL__)
# define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
# endif
#elif defined(_MSC_VER)
# define COMPILER_ID "MSVC"
/* _MSC_VER = VVRR */
# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100)
# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100)
# if defined(_MSC_FULL_VER)
# if _MSC_VER >= 1400
/* _MSC_FULL_VER = VVRRPPPPP */
# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000)
# else
/* _MSC_FULL_VER = VVRRPPPP */
# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000)
# endif
# endif
# if defined(_MSC_BUILD)
# define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD)
# endif
#elif defined(__VISUALDSPVERSION__) || defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__)
# define COMPILER_ID "ADSP"
#if defined(__VISUALDSPVERSION__)
/* __VISUALDSPVERSION__ = 0xVVRRPP00 */
# define COMPILER_VERSION_MAJOR HEX(__VISUALDSPVERSION__>>24)
# define COMPILER_VERSION_MINOR HEX(__VISUALDSPVERSION__>>16 & 0xFF)
# define COMPILER_VERSION_PATCH HEX(__VISUALDSPVERSION__>>8 & 0xFF)
#endif
#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
# define COMPILER_ID "IAR"
# if defined(__VER__) && defined(__ICCARM__)
# define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000)
# define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000)
# define COMPILER_VERSION_PATCH DEC((__VER__) % 1000)
# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__))
# define COMPILER_VERSION_MAJOR DEC((__VER__) / 100)
# define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100))
# define COMPILER_VERSION_PATCH DEC(__SUBVERSION__)
# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
# endif
/* These compilers are either not known or too old to define an
identification macro. Try to identify the platform and guess that
it is the native compiler. */
#elif defined(__hpux) || defined(__hpua)
# define COMPILER_ID "HP"
#else /* unknown compiler */
# define COMPILER_ID ""
#endif
/* Construct the string literal in pieces to prevent the source from
getting matched. Store it in a pointer rather than an array
because some compilers will just produce instructions to fill the
array rather than assigning a pointer to a static array. */
char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]";
#ifdef SIMULATE_ID
char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]";
#endif
#ifdef __QNXNTO__
char const* qnxnto = "INFO" ":" "qnxnto[]";
#endif
#if defined(_CRAYC) || defined(__cray__)
char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]";
#endif
#define STRINGIFY_HELPER(X) #X
#define STRINGIFY(X) STRINGIFY_HELPER(X)
/* Identify known platforms by name. */
#if defined(__linux) || defined(__linux__) || defined(linux)
# define PLATFORM_ID "Linux"
#elif defined(__CYGWIN__)
# define PLATFORM_ID "Cygwin"
#elif defined(__MINGW32__)
# define PLATFORM_ID "MinGW"
#elif defined(__APPLE__)
# define PLATFORM_ID "Darwin"
#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
# define PLATFORM_ID "Windows"
#elif defined(__FreeBSD__) || defined(__FreeBSD)
# define PLATFORM_ID "FreeBSD"
#elif defined(__NetBSD__) || defined(__NetBSD)
# define PLATFORM_ID "NetBSD"
#elif defined(__OpenBSD__) || defined(__OPENBSD)
# define PLATFORM_ID "OpenBSD"
#elif defined(__sun) || defined(sun)
# define PLATFORM_ID "SunOS"
#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__)
# define PLATFORM_ID "AIX"
#elif defined(__hpux) || defined(__hpux__)
# define PLATFORM_ID "HP-UX"
#elif defined(__HAIKU__)
# define PLATFORM_ID "Haiku"
#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS)
# define PLATFORM_ID "BeOS"
#elif defined(__QNX__) || defined(__QNXNTO__)
# define PLATFORM_ID "QNX"
#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__)
# define PLATFORM_ID "Tru64"
#elif defined(__riscos) || defined(__riscos__)
# define PLATFORM_ID "RISCos"
#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__)
# define PLATFORM_ID "SINIX"
#elif defined(__UNIX_SV__)
# define PLATFORM_ID "UNIX_SV"
#elif defined(__bsdos__)
# define PLATFORM_ID "BSDOS"
#elif defined(_MPRAS) || defined(MPRAS)
# define PLATFORM_ID "MP-RAS"
#elif defined(__osf) || defined(__osf__)
# define PLATFORM_ID "OSF1"
#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv)
# define PLATFORM_ID "SCO_SV"
#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX)
# define PLATFORM_ID "ULTRIX"
#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX)
# define PLATFORM_ID "Xenix"
#elif defined(__WATCOMC__)
# if defined(__LINUX__)
# define PLATFORM_ID "Linux"
# elif defined(__DOS__)
# define PLATFORM_ID "DOS"
# elif defined(__OS2__)
# define PLATFORM_ID "OS2"
# elif defined(__WINDOWS__)
# define PLATFORM_ID "Windows3x"
# elif defined(__VXWORKS__)
# define PLATFORM_ID "VxWorks"
# else /* unknown platform */
# define PLATFORM_ID
# endif
#elif defined(__INTEGRITY)
# if defined(INT_178B)
# define PLATFORM_ID "Integrity178"
# else /* regular Integrity */
# define PLATFORM_ID "Integrity"
# endif
#else /* unknown platform */
# define PLATFORM_ID
#endif
/* For windows compilers MSVC and Intel we can determine
the architecture of the compiler being used. This is because
the compilers do not have flags that can change the architecture,
but rather depend on which compiler is being used
*/
#if defined(_WIN32) && defined(_MSC_VER)
# if defined(_M_IA64)
# define ARCHITECTURE_ID "IA64"
# elif defined(_M_X64) || defined(_M_AMD64)
# define ARCHITECTURE_ID "x64"
# elif defined(_M_IX86)
# define ARCHITECTURE_ID "X86"
# elif defined(_M_ARM64)
# define ARCHITECTURE_ID "ARM64"
# elif defined(_M_ARM)
# if _M_ARM == 4
# define ARCHITECTURE_ID "ARMV4I"
# elif _M_ARM == 5
# define ARCHITECTURE_ID "ARMV5I"
# else
# define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM)
# endif
# elif defined(_M_MIPS)
# define ARCHITECTURE_ID "MIPS"
# elif defined(_M_SH)
# define ARCHITECTURE_ID "SHx"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__WATCOMC__)
# if defined(_M_I86)
# define ARCHITECTURE_ID "I86"
# elif defined(_M_IX86)
# define ARCHITECTURE_ID "X86"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
# if defined(__ICCARM__)
# define ARCHITECTURE_ID "ARM"
# elif defined(__ICCRX__)
# define ARCHITECTURE_ID "RX"
# elif defined(__ICCRH850__)
# define ARCHITECTURE_ID "RH850"
# elif defined(__ICCRL78__)
# define ARCHITECTURE_ID "RL78"
# elif defined(__ICCRISCV__)
# define ARCHITECTURE_ID "RISCV"
# elif defined(__ICCAVR__)
# define ARCHITECTURE_ID "AVR"
# elif defined(__ICC430__)
# define ARCHITECTURE_ID "MSP430"
# elif defined(__ICCV850__)
# define ARCHITECTURE_ID "V850"
# elif defined(__ICC8051__)
# define ARCHITECTURE_ID "8051"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__ghs__)
# if defined(__PPC64__)
# define ARCHITECTURE_ID "PPC64"
# elif defined(__ppc__)
# define ARCHITECTURE_ID "PPC"
# elif defined(__ARM__)
# define ARCHITECTURE_ID "ARM"
# elif defined(__x86_64__)
# define ARCHITECTURE_ID "x64"
# elif defined(__i386__)
# define ARCHITECTURE_ID "X86"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__TI_COMPILER_VERSION__)
# if defined(__TI_ARM__)
# define ARCHITECTURE_ID "ARM"
# elif defined(__MSP430__)
# define ARCHITECTURE_ID "MSP430"
# elif defined(__TMS320C28XX__)
# define ARCHITECTURE_ID "TMS320C28x"
# elif defined(__TMS320C6X__) || defined(_TMS320C6X)
# define ARCHITECTURE_ID "TMS320C6x"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#else
# define ARCHITECTURE_ID
#endif
/* Convert integer to decimal digit literals. */
#define DEC(n) \
('0' + (((n) / 10000000)%10)), \
('0' + (((n) / 1000000)%10)), \
('0' + (((n) / 100000)%10)), \
('0' + (((n) / 10000)%10)), \
('0' + (((n) / 1000)%10)), \
('0' + (((n) / 100)%10)), \
('0' + (((n) / 10)%10)), \
('0' + ((n) % 10))
/* Convert integer to hex digit literals. */
#define HEX(n) \
('0' + ((n)>>28 & 0xF)), \
('0' + ((n)>>24 & 0xF)), \
('0' + ((n)>>20 & 0xF)), \
('0' + ((n)>>16 & 0xF)), \
('0' + ((n)>>12 & 0xF)), \
('0' + ((n)>>8 & 0xF)), \
('0' + ((n)>>4 & 0xF)), \
('0' + ((n) & 0xF))
/* Construct a string literal encoding the version number components. */
#ifdef COMPILER_VERSION_MAJOR
char const info_version[] = {
'I', 'N', 'F', 'O', ':',
'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[',
COMPILER_VERSION_MAJOR,
# ifdef COMPILER_VERSION_MINOR
'.', COMPILER_VERSION_MINOR,
# ifdef COMPILER_VERSION_PATCH
'.', COMPILER_VERSION_PATCH,
# ifdef COMPILER_VERSION_TWEAK
'.', COMPILER_VERSION_TWEAK,
# endif
# endif
# endif
']','\0'};
#endif
/* Construct a string literal encoding the internal version number. */
#ifdef COMPILER_VERSION_INTERNAL
char const info_version_internal[] = {
'I', 'N', 'F', 'O', ':',
'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_',
'i','n','t','e','r','n','a','l','[',
COMPILER_VERSION_INTERNAL,']','\0'};
#endif
/* Construct a string literal encoding the version number components. */
#ifdef SIMULATE_VERSION_MAJOR
char const info_simulate_version[] = {
'I', 'N', 'F', 'O', ':',
's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[',
SIMULATE_VERSION_MAJOR,
# ifdef SIMULATE_VERSION_MINOR
'.', SIMULATE_VERSION_MINOR,
# ifdef SIMULATE_VERSION_PATCH
'.', SIMULATE_VERSION_PATCH,
# ifdef SIMULATE_VERSION_TWEAK
'.', SIMULATE_VERSION_TWEAK,
# endif
# endif
# endif
']','\0'};
#endif
/* Construct the string literal in pieces to prevent the source from
getting matched. Store it in a pointer rather than an array
because some compilers will just produce instructions to fill the
array rather than assigning a pointer to a static array. */
char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]";
char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]";
#if defined(__INTEL_COMPILER) && defined(_MSVC_LANG) && _MSVC_LANG < 201403L
# if defined(__INTEL_CXX11_MODE__)
# if defined(__cpp_aggregate_nsdmi)
# define CXX_STD 201402L
# else
# define CXX_STD 201103L
# endif
# else
# define CXX_STD 199711L
# endif
#elif defined(_MSC_VER) && defined(_MSVC_LANG)
# define CXX_STD _MSVC_LANG
#else
# define CXX_STD __cplusplus
#endif
const char* info_language_dialect_default = "INFO" ":" "dialect_default["
#if CXX_STD > 201703L
"20"
#elif CXX_STD >= 201703L
"17"
#elif CXX_STD >= 201402L
"14"
#elif CXX_STD >= 201103L
"11"
#else
"98"
#endif
"]";
/*--------------------------------------------------------------------------*/
int main(int argc, char* argv[])
{
int require = 0;
require += info_compiler[argc];
require += info_platform[argc];
#ifdef COMPILER_VERSION_MAJOR
require += info_version[argc];
#endif
#ifdef COMPILER_VERSION_INTERNAL
require += info_version_internal[argc];
#endif
#ifdef SIMULATE_ID
require += info_simulate[argc];
#endif
#ifdef SIMULATE_VERSION_MAJOR
require += info_simulate_version[argc];
#endif
#if defined(_CRAYC) || defined(__cray__)
require += info_cray[argc];
#endif
require += info_language_dialect_default[argc];
(void)argv;
return require;
}
| YifuLiu/AliOS-Things | components/jsoncpp/CMakeFiles/3.19.2/CompilerIdCXX/CMakeCXXCompilerId.cpp | C++ | apache-2.0 | 20,544 |
# vim: et ts=4 sts=4 sw=4 tw=0
# ==== Define cmake build policies that affect compilation and linkage default behaviors
#
# Set the JSONCPP_NEWEST_VALIDATED_POLICIES_VERSION string to the newest cmake version
# policies that provide successful builds. By setting JSONCPP_NEWEST_VALIDATED_POLICIES_VERSION
# to a value greater than the oldest policies, all policies between
# JSONCPP_OLDEST_VALIDATED_POLICIES_VERSION and CMAKE_VERSION (used for this build)
# are set to their NEW behaivor, thereby suppressing policy warnings related to policies
# between the JSONCPP_OLDEST_VALIDATED_POLICIES_VERSION and CMAKE_VERSION.
#
# CMake versions greater than the JSONCPP_NEWEST_VALIDATED_POLICIES_VERSION policies will
# continue to generate policy warnings "CMake Warning (dev)...Policy CMP0XXX is not set:"
#
set(JSONCPP_OLDEST_VALIDATED_POLICIES_VERSION "3.8.0")
set(JSONCPP_NEWEST_VALIDATED_POLICIES_VERSION "3.13.2")
cmake_minimum_required(VERSION ${JSONCPP_OLDEST_VALIDATED_POLICIES_VERSION})
if("${CMAKE_VERSION}" VERSION_LESS "${JSONCPP_NEWEST_VALIDATED_POLICIES_VERSION}")
#Set and use the newest available cmake policies that are validated to work
set(JSONCPP_CMAKE_POLICY_VERSION "${CMAKE_VERSION}")
else()
set(JSONCPP_CMAKE_POLICY_VERSION "${JSONCPP_NEWEST_VALIDATED_POLICIES_VERSION}")
endif()
cmake_policy(VERSION ${JSONCPP_CMAKE_POLICY_VERSION})
#
# Now enumerate specific policies newer than JSONCPP_NEWEST_VALIDATED_POLICIES_VERSION
# that may need to be individually set to NEW/OLD
#
foreach(pnew "") # Currently Empty
if(POLICY ${pnew})
cmake_policy(SET ${pnew} NEW)
endif()
endforeach()
foreach(pold "") # Currently Empty
if(POLICY ${pold})
cmake_policy(SET ${pold} OLD)
endif()
endforeach()
# Build the library with C++11 standard support, independent from other including
# software which may use a different CXX_STANDARD or CMAKE_CXX_STANDARD.
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_EXTENSIONS OFF)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# Ensure that CMAKE_BUILD_TYPE has a value specified for single configuration generators.
if(NOT DEFINED CMAKE_BUILD_TYPE AND NOT DEFINED CMAKE_CONFIGURATION_TYPES)
set(CMAKE_BUILD_TYPE Release CACHE STRING
"Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel Coverage.")
endif()
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
# ---------------------------------------------------------------------------
# use ccache if found, has to be done before project()
# ---------------------------------------------------------------------------
find_program(CCACHE_EXECUTABLE "ccache" HINTS /usr/local/bin /opt/local/bin)
if(CCACHE_EXECUTABLE)
message(STATUS "use ccache")
set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_EXECUTABLE}" CACHE PATH "ccache" FORCE)
set(CMAKE_C_COMPILER_LAUNCHER "${CCACHE_EXECUTABLE}" CACHE PATH "ccache" FORCE)
endif()
project(jsoncpp
# Note: version must be updated in three places when doing a release. This
# annoying process ensures that amalgamate, CMake, and meson all report the
# correct version.
# 1. ./meson.build
# 2. ./include/json/version.h
# 3. ./CMakeLists.txt
# IMPORTANT: also update the PROJECT_SOVERSION!!
VERSION 1.9.4 # <major>[.<minor>[.<patch>[.<tweak>]]]
LANGUAGES CXX)
message(STATUS "JsonCpp Version: ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}")
set(PROJECT_SOVERSION 24)
include(${CMAKE_CURRENT_SOURCE_DIR}/include/PreventInSourceBuilds.cmake)
include(${CMAKE_CURRENT_SOURCE_DIR}/include/PreventInBuildInstalls.cmake)
option(JSONCPP_WITH_TESTS "Compile and (for jsoncpp_check) run JsonCpp test executables" ON)
option(JSONCPP_WITH_POST_BUILD_UNITTEST "Automatically run unit-tests as a post build step" ON)
option(JSONCPP_WITH_WARNING_AS_ERROR "Force compilation to fail if a warning occurs" OFF)
option(JSONCPP_WITH_STRICT_ISO "Issue all the warnings demanded by strict ISO C and ISO C++" ON)
option(JSONCPP_WITH_PKGCONFIG_SUPPORT "Generate and install .pc files" ON)
option(JSONCPP_WITH_CMAKE_PACKAGE "Generate and install cmake package files" ON)
option(JSONCPP_WITH_EXAMPLE "Compile JsonCpp example" OFF)
option(BUILD_SHARED_LIBS "Build jsoncpp_lib as a shared library." ON)
option(BUILD_STATIC_LIBS "Build jsoncpp_lib as a static library." ON)
option(BUILD_OBJECT_LIBS "Build jsoncpp_lib as a object library." ON)
# Adhere to GNU filesystem layout conventions
include(GNUInstallDirs)
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib" CACHE PATH "Archive output dir.")
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib" CACHE PATH "Library output dir.")
set(CMAKE_PDB_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin" CACHE PATH "PDB (MSVC debug symbol)output dir.")
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin" CACHE PATH "Executable/dll output dir.")
set(JSONCPP_USE_SECURE_MEMORY "0" CACHE STRING "-D...=1 to use memory-wiping allocator for STL")
configure_file("${PROJECT_SOURCE_DIR}/version.in"
"${PROJECT_BINARY_DIR}/version"
NEWLINE_STYLE UNIX)
macro(use_compilation_warning_as_error)
if(MSVC)
# Only enabled in debug because some old versions of VS STL generate
# warnings when compiled in release configuration.
add_compile_options($<$<CONFIG:Debug>:/WX>)
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
add_compile_options(-Werror)
if(JSONCPP_WITH_STRICT_ISO)
add_compile_options(-pedantic-errors)
endif()
endif()
endmacro()
# Include our configuration header
include_directories(${jsoncpp_SOURCE_DIR}/include)
if(MSVC)
# Only enabled in debug because some old versions of VS STL generate
# unreachable code warning when compiled in release configuration.
add_compile_options($<$<CONFIG:Debug>:/W4>)
endif()
if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
# using regular Clang or AppleClang
add_compile_options(-Wall -Wconversion -Wshadow -Werror=conversion -Werror=sign-compare)
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
# using GCC
add_compile_options(-Wall -Wconversion -Wshadow -Wextra)
# not yet ready for -Wsign-conversion
if(JSONCPP_WITH_STRICT_ISO)
add_compile_options(-Wpedantic)
endif()
if(JSONCPP_WITH_WARNING_AS_ERROR)
add_compile_options(-Werror=conversion)
endif()
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
# using Intel compiler
add_compile_options(-Wall -Wconversion -Wshadow -Wextra -Werror=conversion)
if(JSONCPP_WITH_STRICT_ISO AND NOT JSONCPP_WITH_WARNING_AS_ERROR)
add_compile_options(-Wpedantic)
endif()
endif()
if(JSONCPP_WITH_WARNING_AS_ERROR)
use_compilation_warning_as_error()
endif()
if(JSONCPP_WITH_PKGCONFIG_SUPPORT)
include(JoinPaths)
join_paths(libdir_for_pc_file "\${exec_prefix}" "${CMAKE_INSTALL_LIBDIR}")
join_paths(includedir_for_pc_file "\${prefix}" "${CMAKE_INSTALL_INCLUDEDIR}")
configure_file(
"pkg-config/jsoncpp.pc.in"
"pkg-config/jsoncpp.pc"
@ONLY)
install(FILES "${CMAKE_CURRENT_BINARY_DIR}/pkg-config/jsoncpp.pc"
DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
endif()
if(JSONCPP_WITH_CMAKE_PACKAGE)
include(CMakePackageConfigHelpers)
install(EXPORT jsoncpp
DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/jsoncpp
FILE jsoncppConfig.cmake)
write_basic_package_version_file("${CMAKE_CURRENT_BINARY_DIR}/jsoncppConfigVersion.cmake"
VERSION ${PROJECT_VERSION}
COMPATIBILITY SameMajorVersion)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/jsoncppConfigVersion.cmake
DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/jsoncpp)
endif()
if(JSONCPP_WITH_TESTS)
enable_testing()
include(CTest)
endif()
# Build the different applications
add_subdirectory(src)
#install the includes
add_subdirectory(include)
#install the example
if(JSONCPP_WITH_EXAMPLE)
add_subdirectory(example)
endif()
| YifuLiu/AliOS-Things | components/jsoncpp/CMakeLists.txt | CMake | apache-2.0 | 8,016 |
## This file should be placed in the root directory of your project.
## Then modify the CMakeLists.txt file in the root directory of your
## project to incorporate the testing dashboard.
##
## # The following are required to submit to the CDash dashboard:
## ENABLE_TESTING()
## INCLUDE(CTest)
set(CTEST_PROJECT_NAME "jsoncpp")
set(CTEST_NIGHTLY_START_TIME "01:23:45 UTC")
set(CTEST_DROP_METHOD "https")
set(CTEST_DROP_SITE "my.cdash.org")
set(CTEST_DROP_LOCATION "/submit.php?project=jsoncpp")
set(CTEST_DROP_SITE_CDASH TRUE)
| YifuLiu/AliOS-Things | components/jsoncpp/CTestConfig.cmake | CMake | apache-2.0 | 533 |
# This module provides a function for joining paths
# known from most languages
#
# SPDX-License-Identifier: (MIT OR CC0-1.0)
# Copyright 2020 Jan Tojnar
# https://github.com/jtojnar/cmake-snips
#
# Modelled after Python’s os.path.join
# https://docs.python.org/3.7/library/os.path.html#os.path.join
# Windows not supported
function(join_paths joined_path first_path_segment)
set(temp_path "${first_path_segment}")
foreach(current_segment IN LISTS ARGN)
if(NOT ("${current_segment}" STREQUAL ""))
if(IS_ABSOLUTE "${current_segment}")
set(temp_path "${current_segment}")
else()
set(temp_path "${temp_path}/${current_segment}")
endif()
endif()
endforeach()
set(${joined_path} "${temp_path}" PARENT_SCOPE)
endfunction()
| YifuLiu/AliOS-Things | components/jsoncpp/cmake/JoinPaths.cmake | CMake | apache-2.0 | 819 |
# This is only for jsoncpp developers/contributors.
# We use this to sign releases, generate documentation, etc.
VER?=$(shell cat version.txt)
default:
@echo "VER=${VER}"
sign: jsoncpp-${VER}.tar.gz
gpg --armor --detach-sign $<
gpg --verify $<.asc
# Then upload .asc to the release.
jsoncpp-%.tar.gz:
curl https://github.com/open-source-parsers/jsoncpp/archive/$*.tar.gz -o $@
dox:
python doxybuild.py --doxygen=$$(which doxygen) --in doc/web_doxyfile.in
rsync -va -c --delete dist/doxygen/jsoncpp-api-html-${VER}/ ../jsoncpp-docs/doxygen/
# Then 'git add -A' and 'git push' in jsoncpp-docs.
build:
mkdir -p build/debug
cd build/debug; cmake -DCMAKE_BUILD_TYPE=debug -DBUILD_SHARED_LIBS=ON -G "Unix Makefiles" ../..
make -C build/debug
# Currently, this depends on include/json/version.h generated
# by cmake.
test-amalgamate:
python2.7 amalgamate.py
python3.4 amalgamate.py
cd dist; gcc -I. -c jsoncpp.cpp
valgrind:
valgrind --error-exitcode=42 --leak-check=full ./build/debug/src/test_lib_json/jsoncpp_test
clean:
\rm -rf *.gz *.asc dist/
.PHONY: build
| YifuLiu/AliOS-Things | components/jsoncpp/dev.makefile | Makefile | apache-2.0 | 1,076 |
<!-- HTML footer for doxygen 1.8.13-->
<!-- start footer part -->
<!--BEGIN GENERATE_TREEVIEW-->
<div id="nav-path" class="navpath"><!-- id is needed for treeview function! -->
<ul>
$navpath
<li class="footer">$generatedby
<a href="http://www.doxygen.org/index.html">
<img class="footer" src="$relpath^doxygen.png" alt="doxygen"/></a> $doxygenversion </li>
</ul>
</div>
<!--END GENERATE_TREEVIEW-->
<!--BEGIN !GENERATE_TREEVIEW-->
<hr class="footer"/><address class="footer"><small>
$generatedby  <a href="http://www.doxygen.org/index.html">
<img class="footer" src="$relpath^doxygen.png" alt="doxygen"/>
</a> $doxygenversion
</small></address>
<!--END !GENERATE_TREEVIEW-->
</body>
</html>
| YifuLiu/AliOS-Things | components/jsoncpp/doc/footer.html | HTML | apache-2.0 | 716 |
<!-- HTML header for doxygen 1.8.13-->
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<meta name="generator" content="Doxygen $doxygenversion"/>
<meta name="viewport" content="width=device-width, initial-scale=1"/>
<link href="$relpath^tabs.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="$relpath^jquery.js"></script>
<script type="text/javascript" src="$relpath^dynsections.js"></script>
$treeview
$search
$mathjax
<link href="$relpath^$stylesheet" rel="stylesheet" type="text/css" />
$extrastylesheet
</head>
<body>
<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
<!--BEGIN TITLEAREA-->
<div id="titlearea">
<table cellspacing="0" cellpadding="0">
<tbody>
<tr style="height: 56px;">
<!--BEGIN PROJECT_LOGO-->
<td id="projectlogo"><img alt="Logo" src="$relpath^$projectlogo"/></td>
<!--END PROJECT_LOGO-->
<!--BEGIN DISABLE_INDEX-->
<!--BEGIN SEARCHENGINE-->
<td>$searchbox</td>
<!--END SEARCHENGINE-->
<!--END DISABLE_INDEX-->
</tr>
</tbody>
</table>
</div>
<!--END TITLEAREA-->
<body bgcolor="#ffffff">
<table width="100%">
<tr>
<td width="30%" align="left" valign="center">
<a href="https://github.com/open-source-parsers/jsoncpp">
JsonCpp project page
</a>
</td>
<td width="20%" align="center" valign="center">
<a href="hierarchy.html">
Classes
</a>
</td>
<td width="20%" align="center" valign="center">
<a href="namespace_json.html">
Namespace
</a>
</td>
<td width="30%" align="right" valign="center">
<a href="http://open-source-parsers.github.io/jsoncpp-docs/doxygen/">JsonCpp home page</a>
</td>
</tr>
</table>
<hr>
<!-- end header part -->
| YifuLiu/AliOS-Things | components/jsoncpp/doc/header.html | HTML | apache-2.0 | 1,975 |
#vim: et ts =4 sts = 4 sw = 4 tw = 0
set(EXAMPLES
readFromString
readFromStream
stringWrite
streamWrite
)
add_definitions(-D_GLIBCXX_USE_CXX11_ABI)
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
add_compile_options(-Wall -Wextra)
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
add_definitions(
-D_SCL_SECURE_NO_WARNINGS
-D_CRT_SECURE_NO_WARNINGS
-D_WIN32_WINNT=0x601
-D_WINSOCK_DEPRECATED_NO_WARNINGS
)
endif()
foreach(example ${EXAMPLES})
add_executable(${example} ${example}/${example}.cpp)
target_include_directories(${example} PUBLIC ${CMAKE_SOURCE_DIR}/include)
target_link_libraries(${example} jsoncpp_lib)
endforeach()
add_custom_target(examples ALL DEPENDS ${EXAMPLES})
| YifuLiu/AliOS-Things | components/jsoncpp/example/CMakeLists.txt | CMake | apache-2.0 | 788 |
#include "json/json.h"
#include <fstream>
#include <iostream>
#if AOS_COMP_CLI
#include "aos/cli.h"
#endif
/** \brief Parse from stream, collect comments and capture error info.
* Example Usage:
* $g++ readFromStream.cpp -ljsoncpp -std=c++11 -o readFromStream
* $./readFromStream
* // comment head
* {
* // comment before
* "key" : "value"
* }
* // comment after
* // comment tail
*/
// int main(int argc, char* argv[]) {
extern "C" {
int jsoncpp_comp_read_stream_example(int argc, char **argv)
{
Json::Value root;
std::ifstream ifs;
ifs.open(argv[1]);
Json::CharReaderBuilder builder;
builder["collectComments"] = true;
JSONCPP_STRING errs;
if (!parseFromStream(builder, ifs, &root, &errs)) {
// std::cout << errs << std::endl;
printf("Read json error!\r\n");
return EXIT_FAILURE;
}
// std::cout << root << std::endl;
printf("josn read root = %s !\r\n", root);
return EXIT_SUCCESS;
}
/** \brief Write the Value object to a stream.
* Example Usage:
* $g++ streamWrite.cpp -ljsoncpp -std=c++11 -o streamWrite
* $./streamWrite
* {
* "Age" : 20,
* "Name" : "robin"
* }
*/
int jsoncpp_comp_write_stream_example(int argc, char **argv)
{
Json::Value root;
Json::StreamWriterBuilder builder;
const std::unique_ptr<Json::StreamWriter> writer(builder.newStreamWriter());
root["Name"] = "robin";
root["Age"] = 20;
writer->write(root, &std::cout);
return EXIT_SUCCESS;
}
/**
* \brief Parse a raw string into Value object using the CharReaderBuilder
* class, or the legacy Reader class.
* Example Usage:
* $g++ readFromString.cpp -ljsoncpp -std=c++11 -o readFromString
* $./readFromString
* colin
* 20
*/
int jsoncpp_comp_read_string_example(int argc, char **argv)
{
const std::string rawJson = R"({"Age": 20, "Name": "colin"})";
const auto rawJsonLength = static_cast<int>(rawJson.length());
constexpr bool shouldUseOldWay = false;
JSONCPP_STRING err;
Json::Value root;
if (shouldUseOldWay) {
Json::Reader reader;
reader.parse(rawJson, root);
} else {
Json::CharReaderBuilder builder;
const std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
if (!reader->parse(rawJson.c_str(), rawJson.c_str() + rawJsonLength, &root,
&err)) {
printf("Read json error!\r\n");
// std::cout << "error" << std::endl;
return EXIT_FAILURE;
}
}
const std::string name = root["Name"].asString();
const int age = root["Age"].asInt();
// std::cout << name << std::endl;
// std::cout << age << std::endl;
printf("json read name = %s !\r\n", name.c_str());
printf("josn read age = %d !\r\n", age);
return EXIT_SUCCESS;
}
/** \brief Write a Value object to a string.
* Example Usage:
* $g++ stringWrite.cpp -ljsoncpp -std=c++11 -o stringWrite
* $./stringWrite
* {
* "action" : "run",
* "data" :
* {
* "number" : 1
* }
* }
*/
int jsoncpp_comp_write_string_example(int argc, char **argv)
{
Json::Value root;
Json::Value data;
constexpr bool shouldUseOldWay = false;
root["action"] = "run";
data["number"] = 1;
root["data"] = data;
if (shouldUseOldWay) {
Json::FastWriter writer;
const std::string json_file = writer.write(root);
// std::cout << json_file << std::endl;
printf("json write json_file = %s !\r\n", json_file.c_str());
} else {
Json::StreamWriterBuilder builder;
const std::string json_file = Json::writeString(builder, root);
// std::cout << json_file << std::endl;
printf("json write json_file = %s !\r\n", json_file.c_str());
}
return EXIT_SUCCESS;
}
}
#if AOS_COMP_CLI
/* reg args: fun, cmd, description*/
// ALIOS_CLI_CMD_REGISTER(jsoncpp_comp_read_stream_example, jsoncpp_read_stream_example, jsoncpp component base example)
// ALIOS_CLI_CMD_REGISTER(jsoncpp_comp_write_stream_example, jsoncpp_write_stream_example, jsoncpp component base example)
ALIOS_CLI_CMD_REGISTER(jsoncpp_comp_read_string_example, jsoncpp_read_string_example, jsoncpp component base example)
ALIOS_CLI_CMD_REGISTER(jsoncpp_comp_write_string_example, jsoncpp_write_string_example, jsoncpp component base example)
#endif
| YifuLiu/AliOS-Things | components/jsoncpp/example/jsoncpp_comp_example.cpp | C++ | apache-2.0 | 4,168 |
#include "json/json.h"
#include <fstream>
#include <iostream>
/** \brief Parse from stream, collect comments and capture error info.
* Example Usage:
* $g++ readFromStream.cpp -ljsoncpp -std=c++11 -o readFromStream
* $./readFromStream
* // comment head
* {
* // comment before
* "key" : "value"
* }
* // comment after
* // comment tail
*/
int main(int argc, char* argv[]) {
Json::Value root;
std::ifstream ifs;
ifs.open(argv[1]);
Json::CharReaderBuilder builder;
builder["collectComments"] = true;
JSONCPP_STRING errs;
if (!parseFromStream(builder, ifs, &root, &errs)) {
std::cout << errs << std::endl;
return EXIT_FAILURE;
}
std::cout << root << std::endl;
return EXIT_SUCCESS;
}
| YifuLiu/AliOS-Things | components/jsoncpp/example/readFromStream/readFromStream.cpp | C++ | apache-2.0 | 727 |
#include "json/json.h"
#include <iostream>
/**
* \brief Parse a raw string into Value object using the CharReaderBuilder
* class, or the legacy Reader class.
* Example Usage:
* $g++ readFromString.cpp -ljsoncpp -std=c++11 -o readFromString
* $./readFromString
* colin
* 20
*/
int main() {
const std::string rawJson = R"({"Age": 20, "Name": "colin"})";
const auto rawJsonLength = static_cast<int>(rawJson.length());
constexpr bool shouldUseOldWay = false;
JSONCPP_STRING err;
Json::Value root;
if (shouldUseOldWay) {
Json::Reader reader;
reader.parse(rawJson, root);
} else {
Json::CharReaderBuilder builder;
const std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
if (!reader->parse(rawJson.c_str(), rawJson.c_str() + rawJsonLength, &root,
&err)) {
std::cout << "error" << std::endl;
return EXIT_FAILURE;
}
}
const std::string name = root["Name"].asString();
const int age = root["Age"].asInt();
std::cout << name << std::endl;
std::cout << age << std::endl;
return EXIT_SUCCESS;
}
| YifuLiu/AliOS-Things | components/jsoncpp/example/readFromString/readFromString.cpp | C++ | apache-2.0 | 1,094 |
#include "json/json.h"
#include <iostream>
/** \brief Write the Value object to a stream.
* Example Usage:
* $g++ streamWrite.cpp -ljsoncpp -std=c++11 -o streamWrite
* $./streamWrite
* {
* "Age" : 20,
* "Name" : "robin"
* }
*/
int main() {
Json::Value root;
Json::StreamWriterBuilder builder;
const std::unique_ptr<Json::StreamWriter> writer(builder.newStreamWriter());
root["Name"] = "robin";
root["Age"] = 20;
writer->write(root, &std::cout);
return EXIT_SUCCESS;
}
| YifuLiu/AliOS-Things | components/jsoncpp/example/streamWrite/streamWrite.cpp | C++ | apache-2.0 | 500 |
#include "json/json.h"
#include <iostream>
/** \brief Write a Value object to a string.
* Example Usage:
* $g++ stringWrite.cpp -ljsoncpp -std=c++11 -o stringWrite
* $./stringWrite
* {
* "action" : "run",
* "data" :
* {
* "number" : 1
* }
* }
*/
int main() {
Json::Value root;
Json::Value data;
constexpr bool shouldUseOldWay = false;
root["action"] = "run";
data["number"] = 1;
root["data"] = data;
if (shouldUseOldWay) {
Json::FastWriter writer;
const std::string json_file = writer.write(root);
std::cout << json_file << std::endl;
} else {
Json::StreamWriterBuilder builder;
const std::string json_file = Json::writeString(builder, root);
std::cout << json_file << std::endl;
}
return EXIT_SUCCESS;
}
| YifuLiu/AliOS-Things | components/jsoncpp/example/stringWrite/stringWrite.cpp | C++ | apache-2.0 | 785 |
file(GLOB INCLUDE_FILES "json/*.h")
install(FILES
${INCLUDE_FILES}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/json)
| YifuLiu/AliOS-Things | components/jsoncpp/include/CMakeLists.txt | CMake | apache-2.0 | 122 |
string(TOLOWER "${CMAKE_INSTALL_PREFIX}" _PREFIX)
string(TOLOWER "${ITK_BINARY_DIR}" _BUILD)
if("${_PREFIX}" STREQUAL "${_BUILD}")
message(FATAL_ERROR
"The current CMAKE_INSTALL_PREFIX points at the build tree:\n"
" ${CMAKE_INSTALL_PREFIX}\n"
"This is not supported."
)
endif()
| YifuLiu/AliOS-Things | components/jsoncpp/include/PreventInBuildInstalls.cmake | CMake | apache-2.0 | 297 |
#
# This function will prevent in-source builds
function(AssureOutOfSourceBuilds)
# make sure the user doesn't play dirty with symlinks
get_filename_component(srcdir "${CMAKE_SOURCE_DIR}" REALPATH)
get_filename_component(bindir "${CMAKE_BINARY_DIR}" REALPATH)
# disallow in-source builds
if("${srcdir}" STREQUAL "${bindir}")
message("######################################################")
message("# jsoncpp should not be configured & built in the jsoncpp source directory")
message("# You must run cmake in a build directory.")
message("# For example:")
message("# mkdir jsoncpp-Sandbox ; cd jsoncpp-sandbox")
message("# git clone https://github.com/open-source-parsers/jsoncpp.git # or download & unpack the source tarball")
message("# mkdir jsoncpp-build")
message("# this will create the following directory structure")
message("#")
message("# jsoncpp-Sandbox")
message("# +--jsoncpp")
message("# +--jsoncpp-build")
message("#")
message("# Then you can proceed to configure and build")
message("# by using the following commands")
message("#")
message("# cd jsoncpp-build")
message("# cmake ../jsoncpp # or ccmake, or cmake-gui ")
message("# make")
message("#")
message("# NOTE: Given that you already tried to make an in-source build")
message("# CMake have already created several files & directories")
message("# in your source tree. run 'git status' to find them and")
message("# remove them by doing:")
message("#")
message("# cd jsoncpp-Sandbox/jsoncpp")
message("# git clean -n -d")
message("# git clean -f -d")
message("# git checkout --")
message("#")
message("######################################################")
message(FATAL_ERROR "Quitting configuration")
endif()
endfunction()
AssureOutOfSourceBuilds()
| YifuLiu/AliOS-Things | components/jsoncpp/include/PreventInSourceBuilds.cmake | CMake | apache-2.0 | 1,913 |
// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#ifndef JSON_ALLOCATOR_H_INCLUDED
#define JSON_ALLOCATOR_H_INCLUDED
#include <cstring>
#include <memory>
#pragma pack(push, 8)
namespace Json {
template <typename T> class SecureAllocator {
public:
// Type definitions
using value_type = T;
using pointer = T*;
using const_pointer = const T*;
using reference = T&;
using const_reference = const T&;
using size_type = std::size_t;
using difference_type = std::ptrdiff_t;
/**
* Allocate memory for N items using the standard allocator.
*/
pointer allocate(size_type n) {
// allocate using "global operator new"
return static_cast<pointer>(::operator new(n * sizeof(T)));
}
/**
* Release memory which was allocated for N items at pointer P.
*
* The memory block is filled with zeroes before being released.
*/
void deallocate(pointer p, size_type n) {
// memset_s is used because memset may be optimized away by the compiler
memset_s(p, n * sizeof(T), 0, n * sizeof(T));
// free using "global operator delete"
::operator delete(p);
}
/**
* Construct an item in-place at pointer P.
*/
template <typename... Args> void construct(pointer p, Args&&... args) {
// construct using "placement new" and "perfect forwarding"
::new (static_cast<void*>(p)) T(std::forward<Args>(args)...);
}
size_type max_size() const { return size_t(-1) / sizeof(T); }
pointer address(reference x) const { return std::addressof(x); }
const_pointer address(const_reference x) const { return std::addressof(x); }
/**
* Destroy an item in-place at pointer P.
*/
void destroy(pointer p) {
// destroy using "explicit destructor"
p->~T();
}
// Boilerplate
SecureAllocator() {}
template <typename U> SecureAllocator(const SecureAllocator<U>&) {}
template <typename U> struct rebind { using other = SecureAllocator<U>; };
};
template <typename T, typename U>
bool operator==(const SecureAllocator<T>&, const SecureAllocator<U>&) {
return true;
}
template <typename T, typename U>
bool operator!=(const SecureAllocator<T>&, const SecureAllocator<U>&) {
return false;
}
} // namespace Json
#pragma pack(pop)
#endif // JSON_ALLOCATOR_H_INCLUDED
| YifuLiu/AliOS-Things | components/jsoncpp/include/json/allocator.h | C++ | apache-2.0 | 2,447 |
// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#ifndef JSON_ASSERTIONS_H_INCLUDED
#define JSON_ASSERTIONS_H_INCLUDED
#include <cstdlib>
#include <sstream>
#if !defined(JSON_IS_AMALGAMATION)
#include "config.h"
#endif // if !defined(JSON_IS_AMALGAMATION)
/** It should not be possible for a maliciously designed file to
* cause an abort() or seg-fault, so these macros are used only
* for pre-condition violations and internal logic errors.
*/
#if JSON_USE_EXCEPTION
// @todo <= add detail about condition in exception
#define JSON_ASSERT(condition) \
do { \
if (!(condition)) { \
Json::throwLogicError("assert json failed"); \
} \
} while (0)
#define JSON_FAIL_MESSAGE(message) \
do { \
OStringStream oss; \
oss << message; \
Json::throwLogicError(oss.str()); \
abort(); \
} while (0)
#else // JSON_USE_EXCEPTION
#define JSON_ASSERT(condition) assert(condition)
// The call to assert() will show the failure message in debug builds. In
// release builds we abort, for a core-dump or debugger.
#define JSON_FAIL_MESSAGE(message) \
{ \
OStringStream oss; \
oss << message; \
assert(false && oss.str().c_str()); \
abort(); \
}
#endif
#define JSON_ASSERT_MESSAGE(condition, message) \
do { \
if (!(condition)) { \
JSON_FAIL_MESSAGE(message); \
} \
} while (0)
#endif // JSON_ASSERTIONS_H_INCLUDED
| YifuLiu/AliOS-Things | components/jsoncpp/include/json/assertions.h | C | apache-2.0 | 2,817 |
// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#ifndef JSON_CONFIG_H_INCLUDED
#define JSON_CONFIG_H_INCLUDED
#include <cstddef>
#include <cstdint>
#include <istream>
#include <memory>
#include <ostream>
#include <sstream>
#include <string>
#include <type_traits>
// If non-zero, the library uses exceptions to report bad input instead of C
// assertion macros. The default is to use exceptions.
#ifndef JSON_USE_EXCEPTION
#define JSON_USE_EXCEPTION 0
#endif
// Temporary, tracked for removal with issue #982.
#ifndef JSON_USE_NULLREF
#define JSON_USE_NULLREF 1
#endif
/// If defined, indicates that the source file is amalgamated
/// to prevent private header inclusion.
/// Remarks: it is automatically defined in the generated amalgamated header.
// #define JSON_IS_AMALGAMATION
// Export macros for DLL visibility
#if defined(JSON_DLL_BUILD)
#if defined(_MSC_VER) || defined(__MINGW32__)
#define JSON_API __declspec(dllexport)
#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING
#elif defined(__GNUC__) || defined(__clang__)
#define JSON_API __attribute__((visibility("default")))
#endif // if defined(_MSC_VER)
#elif defined(JSON_DLL)
#if defined(_MSC_VER) || defined(__MINGW32__)
#define JSON_API __declspec(dllimport)
#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING
#endif // if defined(_MSC_VER)
#endif // ifdef JSON_DLL_BUILD
#if !defined(JSON_API)
#define JSON_API
#endif
#if defined(_MSC_VER) && _MSC_VER < 1800
#error \
"ERROR: Visual Studio 12 (2013) with _MSC_VER=1800 is the oldest supported compiler with sufficient C++11 capabilities"
#endif
#if defined(_MSC_VER) && _MSC_VER < 1900
// As recommended at
// https://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010
extern JSON_API int msvc_pre1900_c99_snprintf(char* outBuf, size_t size,
const char* format, ...);
#define jsoncpp_snprintf msvc_pre1900_c99_snprintf
#else
#define jsoncpp_snprintf std::snprintf
#endif
// If JSON_NO_INT64 is defined, then Json only support C++ "int" type for
// integer
// Storages, and 64 bits integer support is disabled.
// #define JSON_NO_INT64 1
// JSONCPP_OVERRIDE is maintained for backwards compatibility of external tools.
// C++11 should be used directly in JSONCPP.
#define JSONCPP_OVERRIDE override
#ifdef __clang__
#if __has_extension(attribute_deprecated_with_message)
#define JSONCPP_DEPRECATED(message) __attribute__((deprecated(message)))
#endif
#elif defined(__GNUC__) // not clang (gcc comes later since clang emulates gcc)
#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))
#define JSONCPP_DEPRECATED(message) __attribute__((deprecated(message)))
#elif (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
#define JSONCPP_DEPRECATED(message) __attribute__((__deprecated__))
#endif // GNUC version
#elif defined(_MSC_VER) // MSVC (after clang because clang on Windows emulates
// MSVC)
#define JSONCPP_DEPRECATED(message) __declspec(deprecated(message))
#endif // __clang__ || __GNUC__ || _MSC_VER
#if !defined(JSONCPP_DEPRECATED)
#define JSONCPP_DEPRECATED(message)
#endif // if !defined(JSONCPP_DEPRECATED)
#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 6))
#define JSON_USE_INT64_DOUBLE_CONVERSION 1
#endif
#if !defined(JSON_IS_AMALGAMATION)
#include "allocator.h"
#include "version.h"
#endif // if !defined(JSON_IS_AMALGAMATION)
namespace Json {
using Int = int;
using UInt = unsigned int;
#if defined(JSON_NO_INT64)
using LargestInt = int;
using LargestUInt = unsigned int;
#undef JSON_HAS_INT64
#else // if defined(JSON_NO_INT64)
// For Microsoft Visual use specific types as long long is not supported
#if defined(_MSC_VER) // Microsoft Visual Studio
using Int64 = __int64;
using UInt64 = unsigned __int64;
#else // if defined(_MSC_VER) // Other platforms, use long long
using Int64 = int64_t;
using UInt64 = uint64_t;
#endif // if defined(_MSC_VER)
using LargestInt = Int64;
using LargestUInt = UInt64;
#define JSON_HAS_INT64
#endif // if defined(JSON_NO_INT64)
template <typename T>
using Allocator =
typename std::conditional<JSONCPP_USING_SECURE_MEMORY, SecureAllocator<T>,
std::allocator<T>>::type;
using String = std::basic_string<char, std::char_traits<char>, Allocator<char>>;
using IStringStream =
std::basic_istringstream<String::value_type, String::traits_type,
String::allocator_type>;
using OStringStream =
std::basic_ostringstream<String::value_type, String::traits_type,
String::allocator_type>;
using IStream = std::istream;
using OStream = std::ostream;
} // namespace Json
// Legacy names (formerly macros).
using JSONCPP_STRING = Json::String;
using JSONCPP_ISTRINGSTREAM = Json::IStringStream;
using JSONCPP_OSTRINGSTREAM = Json::OStringStream;
using JSONCPP_ISTREAM = Json::IStream;
using JSONCPP_OSTREAM = Json::OStream;
#endif // JSON_CONFIG_H_INCLUDED
| YifuLiu/AliOS-Things | components/jsoncpp/include/json/config.h | C++ | apache-2.0 | 5,272 |
// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#ifndef JSON_FORWARDS_H_INCLUDED
#define JSON_FORWARDS_H_INCLUDED
#if !defined(JSON_IS_AMALGAMATION)
#include "config.h"
#endif // if !defined(JSON_IS_AMALGAMATION)
namespace Json {
// writer.h
class StreamWriter;
class StreamWriterBuilder;
class Writer;
class FastWriter;
class StyledWriter;
class StyledStreamWriter;
// reader.h
class Reader;
class CharReader;
class CharReaderBuilder;
// json_features.h
class Features;
// value.h
using ArrayIndex = unsigned int;
class StaticString;
class Path;
class PathArgument;
class Value;
class ValueIteratorBase;
class ValueIterator;
class ValueConstIterator;
} // namespace Json
#endif // JSON_FORWARDS_H_INCLUDED
| YifuLiu/AliOS-Things | components/jsoncpp/include/json/forwards.h | C++ | apache-2.0 | 917 |
// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#ifndef JSON_JSON_H_INCLUDED
#define JSON_JSON_H_INCLUDED
#include "config.h"
#include "json_features.h"
#include "reader.h"
#include "value.h"
#include "writer.h"
#endif // JSON_JSON_H_INCLUDED
| YifuLiu/AliOS-Things | components/jsoncpp/include/json/json.h | C | apache-2.0 | 447 |
// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#ifndef JSON_FEATURES_H_INCLUDED
#define JSON_FEATURES_H_INCLUDED
#if !defined(JSON_IS_AMALGAMATION)
#include "forwards.h"
#endif // if !defined(JSON_IS_AMALGAMATION)
#pragma pack(push, 8)
namespace Json {
/** \brief Configuration passed to reader and writer.
* This configuration object can be used to force the Reader or Writer
* to behave in a standard conforming way.
*/
class JSON_API Features {
public:
/** \brief A configuration that allows all features and assumes all strings
* are UTF-8.
* - C & C++ comments are allowed
* - Root object can be any JSON value
* - Assumes Value strings are encoded in UTF-8
*/
static Features all();
/** \brief A configuration that is strictly compatible with the JSON
* specification.
* - Comments are forbidden.
* - Root object must be either an array or an object value.
* - Assumes Value strings are encoded in UTF-8
*/
static Features strictMode();
/** \brief Initialize the configuration like JsonConfig::allFeatures;
*/
Features();
/// \c true if comments are allowed. Default: \c true.
bool allowComments_{true};
/// \c true if root must be either an array or an object value. Default: \c
/// false.
bool strictRoot_{false};
/// \c true if dropped null placeholders are allowed. Default: \c false.
bool allowDroppedNullPlaceholders_{false};
/// \c true if numeric object key are allowed. Default: \c false.
bool allowNumericKeys_{false};
};
} // namespace Json
#pragma pack(pop)
#endif // JSON_FEATURES_H_INCLUDED
| YifuLiu/AliOS-Things | components/jsoncpp/include/json/json_features.h | C++ | apache-2.0 | 1,793 |
// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#ifndef JSON_READER_H_INCLUDED
#define JSON_READER_H_INCLUDED
#if !defined(JSON_IS_AMALGAMATION)
#include "json_features.h"
#include "value.h"
#endif // if !defined(JSON_IS_AMALGAMATION)
#include <deque>
#include <iosfwd>
#include <istream>
#include <stack>
#include <string>
// Disable warning C4251: <data member>: <type> needs to have dll-interface to
// be used by...
#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
#pragma warning(push)
#pragma warning(disable : 4251)
#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
#pragma pack(push, 8)
namespace Json {
/** \brief Unserialize a <a HREF="http://www.json.org">JSON</a> document into a
* Value.
*
* \deprecated Use CharReader and CharReaderBuilder.
*/
class JSONCPP_DEPRECATED(
"Use CharReader and CharReaderBuilder instead.") JSON_API Reader {
public:
using Char = char;
using Location = const Char*;
/** \brief An error tagged with where in the JSON text it was encountered.
*
* The offsets give the [start, limit) range of bytes within the text. Note
* that this is bytes, not codepoints.
*/
struct StructuredError {
ptrdiff_t offset_start;
ptrdiff_t offset_limit;
String message;
};
/** \brief Constructs a Reader allowing all features for parsing.
*/
JSONCPP_DEPRECATED("Use CharReader and CharReaderBuilder instead")
Reader();
/** \brief Constructs a Reader allowing the specified feature set for parsing.
*/
JSONCPP_DEPRECATED("Use CharReader and CharReaderBuilder instead")
Reader(const Features& features);
/** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a>
* document.
*
* \param document UTF-8 encoded string containing the document
* to read.
* \param[out] root Contains the root value of the document if it
* was successfully parsed.
* \param collectComments \c true to collect comment and allow writing
* them back during serialization, \c false to
* discard comments. This parameter is ignored
* if Features::allowComments_ is \c false.
* \return \c true if the document was successfully parsed, \c false if an
* error occurred.
*/
bool parse(const std::string& document, Value& root,
bool collectComments = true);
/** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a>
* document.
*
* \param beginDoc Pointer on the beginning of the UTF-8 encoded
* string of the document to read.
* \param endDoc Pointer on the end of the UTF-8 encoded string
* of the document to read. Must be >= beginDoc.
* \param[out] root Contains the root value of the document if it
* was successfully parsed.
* \param collectComments \c true to collect comment and allow writing
* them back during serialization, \c false to
* discard comments. This parameter is ignored
* if Features::allowComments_ is \c false.
* \return \c true if the document was successfully parsed, \c false if an
* error occurred.
*/
bool parse(const char* beginDoc, const char* endDoc, Value& root,
bool collectComments = true);
/// \brief Parse from input stream.
/// \see Json::operator>>(std::istream&, Json::Value&).
bool parse(IStream& is, Value& root, bool collectComments = true);
/** \brief Returns a user friendly string that list errors in the parsed
* document.
*
* \return Formatted error message with the list of errors with their
* location in the parsed document. An empty string is returned if no error
* occurred during parsing.
* \deprecated Use getFormattedErrorMessages() instead (typo fix).
*/
JSONCPP_DEPRECATED("Use getFormattedErrorMessages() instead.")
String getFormatedErrorMessages() const;
/** \brief Returns a user friendly string that list errors in the parsed
* document.
*
* \return Formatted error message with the list of errors with their
* location in the parsed document. An empty string is returned if no error
* occurred during parsing.
*/
String getFormattedErrorMessages() const;
/** \brief Returns a vector of structured errors encountered while parsing.
*
* \return A (possibly empty) vector of StructuredError objects. Currently
* only one error can be returned, but the caller should tolerate multiple
* errors. This can occur if the parser recovers from a non-fatal parse
* error and then encounters additional errors.
*/
std::vector<StructuredError> getStructuredErrors() const;
/** \brief Add a semantic error message.
*
* \param value JSON Value location associated with the error
* \param message The error message.
* \return \c true if the error was successfully added, \c false if the Value
* offset exceeds the document size.
*/
bool pushError(const Value& value, const String& message);
/** \brief Add a semantic error message with extra context.
*
* \param value JSON Value location associated with the error
* \param message The error message.
* \param extra Additional JSON Value location to contextualize the error
* \return \c true if the error was successfully added, \c false if either
* Value offset exceeds the document size.
*/
bool pushError(const Value& value, const String& message, const Value& extra);
/** \brief Return whether there are any errors.
*
* \return \c true if there are no errors to report \c false if errors have
* occurred.
*/
bool good() const;
private:
enum TokenType {
tokenEndOfStream = 0,
tokenObjectBegin,
tokenObjectEnd,
tokenArrayBegin,
tokenArrayEnd,
tokenString,
tokenNumber,
tokenTrue,
tokenFalse,
tokenNull,
tokenArraySeparator,
tokenMemberSeparator,
tokenComment,
tokenError
};
class Token {
public:
TokenType type_;
Location start_;
Location end_;
};
class ErrorInfo {
public:
Token token_;
String message_;
Location extra_;
};
using Errors = std::deque<ErrorInfo>;
bool readToken(Token& token);
void skipSpaces();
bool match(const Char* pattern, int patternLength);
bool readComment();
bool readCStyleComment();
bool readCppStyleComment();
bool readString();
void readNumber();
bool readValue();
bool readObject(Token& token);
bool readArray(Token& token);
bool decodeNumber(Token& token);
bool decodeNumber(Token& token, Value& decoded);
bool decodeString(Token& token);
bool decodeString(Token& token, String& decoded);
bool decodeDouble(Token& token);
bool decodeDouble(Token& token, Value& decoded);
bool decodeUnicodeCodePoint(Token& token, Location& current, Location end,
unsigned int& unicode);
bool decodeUnicodeEscapeSequence(Token& token, Location& current,
Location end, unsigned int& unicode);
bool addError(const String& message, Token& token, Location extra = nullptr);
bool recoverFromError(TokenType skipUntilToken);
bool addErrorAndRecover(const String& message, Token& token,
TokenType skipUntilToken);
void skipUntilSpace();
Value& currentValue();
Char getNextChar();
void getLocationLineAndColumn(Location location, int& line,
int& column) const;
String getLocationLineAndColumn(Location location) const;
void addComment(Location begin, Location end, CommentPlacement placement);
void skipCommentTokens(Token& token);
static bool containsNewLine(Location begin, Location end);
static String normalizeEOL(Location begin, Location end);
using Nodes = std::stack<Value*>;
Nodes nodes_;
Errors errors_;
String document_;
Location begin_{};
Location end_{};
Location current_{};
Location lastValueEnd_{};
Value* lastValue_{};
String commentsBefore_;
Features features_;
bool collectComments_{};
}; // Reader
/** Interface for reading JSON from a char array.
*/
class JSON_API CharReader {
public:
virtual ~CharReader() = default;
/** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a>
* document. The document must be a UTF-8 encoded string containing the
* document to read.
*
* \param beginDoc Pointer on the beginning of the UTF-8 encoded string
* of the document to read.
* \param endDoc Pointer on the end of the UTF-8 encoded string of the
* document to read. Must be >= beginDoc.
* \param[out] root Contains the root value of the document if it was
* successfully parsed.
* \param[out] errs Formatted error messages (if not NULL) a user
* friendly string that lists errors in the parsed
* document.
* \return \c true if the document was successfully parsed, \c false if an
* error occurred.
*/
virtual bool parse(char const* beginDoc, char const* endDoc, Value* root,
String* errs) = 0;
class JSON_API Factory {
public:
virtual ~Factory() = default;
/** \brief Allocate a CharReader via operator new().
* \throw std::exception if something goes wrong (e.g. invalid settings)
*/
virtual CharReader* newCharReader() const = 0;
}; // Factory
}; // CharReader
/** \brief Build a CharReader implementation.
*
* Usage:
* \code
* using namespace Json;
* CharReaderBuilder builder;
* builder["collectComments"] = false;
* Value value;
* String errs;
* bool ok = parseFromStream(builder, std::cin, &value, &errs);
* \endcode
*/
class JSON_API CharReaderBuilder : public CharReader::Factory {
public:
// Note: We use a Json::Value so that we can add data-members to this class
// without a major version bump.
/** Configuration of this builder.
* These are case-sensitive.
* Available settings (case-sensitive):
* - `"collectComments": false or true`
* - true to collect comment and allow writing them back during
* serialization, false to discard comments. This parameter is ignored
* if allowComments is false.
* - `"allowComments": false or true`
* - true if comments are allowed.
* - `"allowTrailingCommas": false or true`
* - true if trailing commas in objects and arrays are allowed.
* - `"strictRoot": false or true`
* - true if root must be either an array or an object value
* - `"allowDroppedNullPlaceholders": false or true`
* - true if dropped null placeholders are allowed. (See
* StreamWriterBuilder.)
* - `"allowNumericKeys": false or true`
* - true if numeric object keys are allowed.
* - `"allowSingleQuotes": false or true`
* - true if '' are allowed for strings (both keys and values)
* - `"stackLimit": integer`
* - Exceeding stackLimit (recursive depth of `readValue()`) will cause an
* exception.
* - This is a security issue (seg-faults caused by deeply nested JSON), so
* the default is low.
* - `"failIfExtra": false or true`
* - If true, `parse()` returns false when extra non-whitespace trails the
* JSON value in the input string.
* - `"rejectDupKeys": false or true`
* - If true, `parse()` returns false when a key is duplicated within an
* object.
* - `"allowSpecialFloats": false or true`
* - If true, special float values (NaNs and infinities) are allowed and
* their values are lossfree restorable.
*
* You can examine 'settings_` yourself to see the defaults. You can also
* write and read them just like any JSON Value.
* \sa setDefaults()
*/
Json::Value settings_;
CharReaderBuilder();
~CharReaderBuilder() override;
CharReader* newCharReader() const override;
/** \return true if 'settings' are legal and consistent;
* otherwise, indicate bad settings via 'invalid'.
*/
bool validate(Json::Value* invalid) const;
/** A simple way to update a specific setting.
*/
Value& operator[](const String& key);
/** Called by ctor, but you can use this to reset settings_.
* \pre 'settings' != NULL (but Json::null is fine)
* \remark Defaults:
* \snippet src/lib_json/json_reader.cpp CharReaderBuilderDefaults
*/
static void setDefaults(Json::Value* settings);
/** Same as old Features::strictMode().
* \pre 'settings' != NULL (but Json::null is fine)
* \remark Defaults:
* \snippet src/lib_json/json_reader.cpp CharReaderBuilderStrictMode
*/
static void strictMode(Json::Value* settings);
};
/** Consume entire stream and use its begin/end.
* Someday we might have a real StreamReader, but for now this
* is convenient.
*/
bool JSON_API parseFromStream(CharReader::Factory const&, IStream&, Value* root,
String* errs);
/** \brief Read from 'sin' into 'root'.
*
* Always keep comments from the input JSON.
*
* This can be used to read a file into a particular sub-object.
* For example:
* \code
* Json::Value root;
* cin >> root["dir"]["file"];
* cout << root;
* \endcode
* Result:
* \verbatim
* {
* "dir": {
* "file": {
* // The input stream JSON would be nested here.
* }
* }
* }
* \endverbatim
* \throw std::exception on parse error.
* \see Json::operator<<()
*/
JSON_API IStream& operator>>(IStream&, Value&);
} // namespace Json
#pragma pack(pop)
#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
#pragma warning(pop)
#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
#endif // JSON_READER_H_INCLUDED
| YifuLiu/AliOS-Things | components/jsoncpp/include/json/reader.h | C++ | apache-2.0 | 14,110 |
// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#ifndef JSON_H_INCLUDED
#define JSON_H_INCLUDED
#if !defined(JSON_IS_AMALGAMATION)
#include "forwards.h"
#endif // if !defined(JSON_IS_AMALGAMATION)
// Conditional NORETURN attribute on the throw functions would:
// a) suppress false positives from static code analysis
// b) possibly improve optimization opportunities.
#if !defined(JSONCPP_NORETURN)
#if defined(_MSC_VER) && _MSC_VER == 1800
#define JSONCPP_NORETURN __declspec(noreturn)
#else
#define JSONCPP_NORETURN [[noreturn]]
#endif
#endif
// Support for '= delete' with template declarations was a late addition
// to the c++11 standard and is rejected by clang 3.8 and Apple clang 8.2
// even though these declare themselves to be c++11 compilers.
#if !defined(JSONCPP_TEMPLATE_DELETE)
#if defined(__clang__) && defined(__apple_build_version__)
#if __apple_build_version__ <= 8000042
#define JSONCPP_TEMPLATE_DELETE
#endif
#elif defined(__clang__)
#if __clang_major__ == 3 && __clang_minor__ <= 8
#define JSONCPP_TEMPLATE_DELETE
#endif
#endif
#if !defined(JSONCPP_TEMPLATE_DELETE)
#define JSONCPP_TEMPLATE_DELETE = delete
#endif
#endif
#include <array>
#include <exception>
#include <map>
#include <memory>
#include <string>
#include <vector>
// Disable warning C4251: <data member>: <type> needs to have dll-interface to
// be used by...
#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
#pragma warning(push)
#pragma warning(disable : 4251)
#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
#pragma pack(push, 8)
/** \brief JSON (JavaScript Object Notation).
*/
namespace Json {
#if JSON_USE_EXCEPTION
/** Base class for all exceptions we throw.
*
* We use nothing but these internally. Of course, STL can throw others.
*/
class JSON_API Exception : public std::exception {
public:
Exception(String msg);
~Exception() noexcept override;
char const* what() const noexcept override;
protected:
String msg_;
};
/** Exceptions which the user cannot easily avoid.
*
* E.g. out-of-memory (when we use malloc), stack-overflow, malicious input
*
* \remark derived from Json::Exception
*/
class JSON_API RuntimeError : public Exception {
public:
RuntimeError(String const& msg);
};
/** Exceptions thrown by JSON_ASSERT/JSON_FAIL macros.
*
* These are precondition-violations (user bugs) and internal errors (our bugs).
*
* \remark derived from Json::Exception
*/
class JSON_API LogicError : public Exception {
public:
LogicError(String const& msg);
};
#endif
/// used internally
JSONCPP_NORETURN void throwRuntimeError(String const& msg);
/// used internally
JSONCPP_NORETURN void throwLogicError(String const& msg);
/** \brief Type of the value held by a Value object.
*/
enum ValueType {
nullValue = 0, ///< 'null' value
intValue, ///< signed integer value
uintValue, ///< unsigned integer value
realValue, ///< double value
stringValue, ///< UTF-8 string value
booleanValue, ///< bool value
arrayValue, ///< array value (ordered list)
objectValue ///< object value (collection of name/value pairs).
};
enum CommentPlacement {
commentBefore = 0, ///< a comment placed on the line before a value
commentAfterOnSameLine, ///< a comment just after a value on the same line
commentAfter, ///< a comment on the line after a value (only make sense for
/// root value)
numberOfCommentPlacement
};
/** \brief Type of precision for formatting of real values.
*/
enum PrecisionType {
significantDigits = 0, ///< we set max number of significant digits in string
decimalPlaces ///< we set max number of digits after "." in string
};
/** \brief Lightweight wrapper to tag static string.
*
* Value constructor and objectValue member assignment takes advantage of the
* StaticString and avoid the cost of string duplication when storing the
* string or the member name.
*
* Example of usage:
* \code
* Json::Value aValue( StaticString("some text") );
* Json::Value object;
* static const StaticString code("code");
* object[code] = 1234;
* \endcode
*/
class JSON_API StaticString {
public:
explicit StaticString(const char* czstring) : c_str_(czstring) {}
operator const char*() const { return c_str_; }
const char* c_str() const { return c_str_; }
private:
const char* c_str_;
};
/** \brief Represents a <a HREF="http://www.json.org">JSON</a> value.
*
* This class is a discriminated union wrapper that can represents a:
* - signed integer [range: Value::minInt - Value::maxInt]
* - unsigned integer (range: 0 - Value::maxUInt)
* - double
* - UTF-8 string
* - boolean
* - 'null'
* - an ordered list of Value
* - collection of name/value pairs (javascript object)
*
* The type of the held value is represented by a #ValueType and
* can be obtained using type().
*
* Values of an #objectValue or #arrayValue can be accessed using operator[]()
* methods.
* Non-const methods will automatically create the a #nullValue element
* if it does not exist.
* The sequence of an #arrayValue will be automatically resized and initialized
* with #nullValue. resize() can be used to enlarge or truncate an #arrayValue.
*
* The get() methods can be used to obtain default value in the case the
* required element does not exist.
*
* It is possible to iterate over the list of member keys of an object using
* the getMemberNames() method.
*
* \note #Value string-length fit in size_t, but keys must be < 2^30.
* (The reason is an implementation detail.) A #CharReader will raise an
* exception if a bound is exceeded to avoid security holes in your app,
* but the Value API does *not* check bounds. That is the responsibility
* of the caller.
*/
class JSON_API Value {
friend class ValueIteratorBase;
public:
using Members = std::vector<String>;
using iterator = ValueIterator;
using const_iterator = ValueConstIterator;
using UInt = Json::UInt;
using Int = Json::Int;
#if defined(JSON_HAS_INT64)
using UInt64 = Json::UInt64;
using Int64 = Json::Int64;
#endif // defined(JSON_HAS_INT64)
using LargestInt = Json::LargestInt;
using LargestUInt = Json::LargestUInt;
using ArrayIndex = Json::ArrayIndex;
// Required for boost integration, e. g. BOOST_TEST
using value_type = std::string;
#if JSON_USE_NULLREF
// Binary compatibility kludges, do not use.
static const Value& null;
static const Value& nullRef;
#endif
// null and nullRef are deprecated, use this instead.
static Value const& nullSingleton();
/// Minimum signed integer value that can be stored in a Json::Value.
static constexpr LargestInt minLargestInt =
LargestInt(~(LargestUInt(-1) / 2));
/// Maximum signed integer value that can be stored in a Json::Value.
static constexpr LargestInt maxLargestInt = LargestInt(LargestUInt(-1) / 2);
/// Maximum unsigned integer value that can be stored in a Json::Value.
static constexpr LargestUInt maxLargestUInt = LargestUInt(-1);
/// Minimum signed int value that can be stored in a Json::Value.
static constexpr Int minInt = Int(~(UInt(-1) / 2));
/// Maximum signed int value that can be stored in a Json::Value.
static constexpr Int maxInt = Int(UInt(-1) / 2);
/// Maximum unsigned int value that can be stored in a Json::Value.
static constexpr UInt maxUInt = UInt(-1);
#if defined(JSON_HAS_INT64)
/// Minimum signed 64 bits int value that can be stored in a Json::Value.
static constexpr Int64 minInt64 = Int64(~(UInt64(-1) / 2));
/// Maximum signed 64 bits int value that can be stored in a Json::Value.
static constexpr Int64 maxInt64 = Int64(UInt64(-1) / 2);
/// Maximum unsigned 64 bits int value that can be stored in a Json::Value.
static constexpr UInt64 maxUInt64 = UInt64(-1);
#endif // defined(JSON_HAS_INT64)
/// Default precision for real value for string representation.
static constexpr UInt defaultRealPrecision = 17;
// The constant is hard-coded because some compiler have trouble
// converting Value::maxUInt64 to a double correctly (AIX/xlC).
// Assumes that UInt64 is a 64 bits integer.
static constexpr double maxUInt64AsDouble = 18446744073709551615.0;
// Workaround for bug in the NVIDIAs CUDA 9.1 nvcc compiler
// when using gcc and clang backend compilers. CZString
// cannot be defined as private. See issue #486
#ifdef __NVCC__
public:
#else
private:
#endif
#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
class CZString {
public:
enum DuplicationPolicy { noDuplication = 0, duplicate, duplicateOnCopy };
CZString(ArrayIndex index);
CZString(char const* str, unsigned length, DuplicationPolicy allocate);
CZString(CZString const& other);
CZString(CZString&& other) noexcept;
~CZString();
CZString& operator=(const CZString& other);
CZString& operator=(CZString&& other) noexcept;
bool operator<(CZString const& other) const;
bool operator==(CZString const& other) const;
ArrayIndex index() const;
// const char* c_str() const; ///< \deprecated
char const* data() const;
unsigned length() const;
bool isStaticString() const;
private:
void swap(CZString& other);
struct StringStorage {
unsigned policy_ : 2;
unsigned length_ : 30; // 1GB max
};
char const* cstr_; // actually, a prefixed string, unless policy is noDup
union {
ArrayIndex index_;
StringStorage storage_;
};
};
public:
typedef std::map<CZString, Value> ObjectValues;
#endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
public:
/**
* \brief Create a default Value of the given type.
*
* This is a very useful constructor.
* To create an empty array, pass arrayValue.
* To create an empty object, pass objectValue.
* Another Value can then be set to this one by assignment.
* This is useful since clear() and resize() will not alter types.
*
* Examples:
* \code
* Json::Value null_value; // null
* Json::Value arr_value(Json::arrayValue); // []
* Json::Value obj_value(Json::objectValue); // {}
* \endcode
*/
Value(ValueType type = nullValue);
Value(Int value);
Value(UInt value);
#if defined(JSON_HAS_INT64)
Value(Int64 value);
Value(UInt64 value);
#endif // if defined(JSON_HAS_INT64)
Value(double value);
Value(const char* value); ///< Copy til first 0. (NULL causes to seg-fault.)
Value(const char* begin, const char* end); ///< Copy all, incl zeroes.
/**
* \brief Constructs a value from a static string.
*
* Like other value string constructor but do not duplicate the string for
* internal storage. The given string must remain alive after the call to
* this constructor.
*
* \note This works only for null-terminated strings. (We cannot change the
* size of this class, so we have nowhere to store the length, which might be
* computed later for various operations.)
*
* Example of usage:
* \code
* static StaticString foo("some text");
* Json::Value aValue(foo);
* \endcode
*/
Value(const StaticString& value);
Value(const String& value);
Value(bool value);
Value(std::nullptr_t ptr) = delete;
Value(const Value& other);
Value(Value&& other) noexcept;
~Value();
/// \note Overwrite existing comments. To preserve comments, use
/// #swapPayload().
Value& operator=(const Value& other);
Value& operator=(Value&& other) noexcept;
/// Swap everything.
void swap(Value& other);
/// Swap values but leave comments and source offsets in place.
void swapPayload(Value& other);
/// copy everything.
void copy(const Value& other);
/// copy values but leave comments and source offsets in place.
void copyPayload(const Value& other);
ValueType type() const;
/// Compare payload only, not comments etc.
bool operator<(const Value& other) const;
bool operator<=(const Value& other) const;
bool operator>=(const Value& other) const;
bool operator>(const Value& other) const;
bool operator==(const Value& other) const;
bool operator!=(const Value& other) const;
int compare(const Value& other) const;
const char* asCString() const; ///< Embedded zeroes could cause you trouble!
#if JSONCPP_USING_SECURE_MEMORY
unsigned getCStringLength() const; // Allows you to understand the length of
// the CString
#endif
String asString() const; ///< Embedded zeroes are possible.
/** Get raw char* of string-value.
* \return false if !string. (Seg-fault if str or end are NULL.)
*/
bool getString(char const** begin, char const** end) const;
Int asInt() const;
UInt asUInt() const;
#if defined(JSON_HAS_INT64)
Int64 asInt64() const;
UInt64 asUInt64() const;
#endif // if defined(JSON_HAS_INT64)
LargestInt asLargestInt() const;
LargestUInt asLargestUInt() const;
float asFloat() const;
double asDouble() const;
bool asBool() const;
bool isNull() const;
bool isBool() const;
bool isInt() const;
bool isInt64() const;
bool isUInt() const;
bool isUInt64() const;
bool isIntegral() const;
bool isDouble() const;
bool isNumeric() const;
bool isString() const;
bool isArray() const;
bool isObject() const;
/// The `as<T>` and `is<T>` member function templates and specializations.
template <typename T> T as() const JSONCPP_TEMPLATE_DELETE;
template <typename T> bool is() const JSONCPP_TEMPLATE_DELETE;
bool isConvertibleTo(ValueType other) const;
/// Number of values in array or object
ArrayIndex size() const;
/// \brief Return true if empty array, empty object, or null;
/// otherwise, false.
bool empty() const;
/// Return !isNull()
explicit operator bool() const;
/// Remove all object members and array elements.
/// \pre type() is arrayValue, objectValue, or nullValue
/// \post type() is unchanged
void clear();
/// Resize the array to newSize elements.
/// New elements are initialized to null.
/// May only be called on nullValue or arrayValue.
/// \pre type() is arrayValue or nullValue
/// \post type() is arrayValue
void resize(ArrayIndex newSize);
//@{
/// Access an array element (zero based index). If the array contains less
/// than index element, then null value are inserted in the array so that
/// its size is index+1.
/// (You may need to say 'value[0u]' to get your compiler to distinguish
/// this from the operator[] which takes a string.)
Value& operator[](ArrayIndex index);
Value& operator[](int index);
//@}
//@{
/// Access an array element (zero based index).
/// (You may need to say 'value[0u]' to get your compiler to distinguish
/// this from the operator[] which takes a string.)
const Value& operator[](ArrayIndex index) const;
const Value& operator[](int index) const;
//@}
/// If the array contains at least index+1 elements, returns the element
/// value, otherwise returns defaultValue.
Value get(ArrayIndex index, const Value& defaultValue) const;
/// Return true if index < size().
bool isValidIndex(ArrayIndex index) const;
/// \brief Append value to array at the end.
///
/// Equivalent to jsonvalue[jsonvalue.size()] = value;
Value& append(const Value& value);
Value& append(Value&& value);
/// \brief Insert value in array at specific index
bool insert(ArrayIndex index, const Value& newValue);
bool insert(ArrayIndex index, Value&& newValue);
/// Access an object value by name, create a null member if it does not exist.
/// \note Because of our implementation, keys are limited to 2^30 -1 chars.
/// Exceeding that will cause an exception.
Value& operator[](const char* key);
/// Access an object value by name, returns null if there is no member with
/// that name.
const Value& operator[](const char* key) const;
/// Access an object value by name, create a null member if it does not exist.
/// \param key may contain embedded nulls.
Value& operator[](const String& key);
/// Access an object value by name, returns null if there is no member with
/// that name.
/// \param key may contain embedded nulls.
const Value& operator[](const String& key) const;
/** \brief Access an object value by name, create a null member if it does not
* exist.
*
* If the object has no entry for that name, then the member name used to
* store the new entry is not duplicated.
* Example of use:
* \code
* Json::Value object;
* static const StaticString code("code");
* object[code] = 1234;
* \endcode
*/
Value& operator[](const StaticString& key);
/// Return the member named key if it exist, defaultValue otherwise.
/// \note deep copy
Value get(const char* key, const Value& defaultValue) const;
/// Return the member named key if it exist, defaultValue otherwise.
/// \note deep copy
/// \note key may contain embedded nulls.
Value get(const char* begin, const char* end,
const Value& defaultValue) const;
/// Return the member named key if it exist, defaultValue otherwise.
/// \note deep copy
/// \param key may contain embedded nulls.
Value get(const String& key, const Value& defaultValue) const;
/// Most general and efficient version of isMember()const, get()const,
/// and operator[]const
/// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30
Value const* find(char const* begin, char const* end) const;
/// Most general and efficient version of object-mutators.
/// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30
/// \return non-zero, but JSON_ASSERT if this is neither object nor nullValue.
Value* demand(char const* begin, char const* end);
/// \brief Remove and return the named member.
///
/// Do nothing if it did not exist.
/// \pre type() is objectValue or nullValue
/// \post type() is unchanged
void removeMember(const char* key);
/// Same as removeMember(const char*)
/// \param key may contain embedded nulls.
void removeMember(const String& key);
/// Same as removeMember(const char* begin, const char* end, Value* removed),
/// but 'key' is null-terminated.
bool removeMember(const char* key, Value* removed);
/** \brief Remove the named map member.
*
* Update 'removed' iff removed.
* \param key may contain embedded nulls.
* \return true iff removed (no exceptions)
*/
bool removeMember(String const& key, Value* removed);
/// Same as removeMember(String const& key, Value* removed)
bool removeMember(const char* begin, const char* end, Value* removed);
/** \brief Remove the indexed array element.
*
* O(n) expensive operations.
* Update 'removed' iff removed.
* \return true if removed (no exceptions)
*/
bool removeIndex(ArrayIndex index, Value* removed);
/// Return true if the object has a member named key.
/// \note 'key' must be null-terminated.
bool isMember(const char* key) const;
/// Return true if the object has a member named key.
/// \param key may contain embedded nulls.
bool isMember(const String& key) const;
/// Same as isMember(String const& key)const
bool isMember(const char* begin, const char* end) const;
/// \brief Return a list of the member names.
///
/// If null, return an empty list.
/// \pre type() is objectValue or nullValue
/// \post if type() was nullValue, it remains nullValue
Members getMemberNames() const;
/// \deprecated Always pass len.
JSONCPP_DEPRECATED("Use setComment(String const&) instead.")
void setComment(const char* comment, CommentPlacement placement) {
setComment(String(comment, strlen(comment)), placement);
}
/// Comments must be //... or /* ... */
void setComment(const char* comment, size_t len, CommentPlacement placement) {
setComment(String(comment, len), placement);
}
/// Comments must be //... or /* ... */
void setComment(String comment, CommentPlacement placement);
bool hasComment(CommentPlacement placement) const;
/// Include delimiters and embedded newlines.
String getComment(CommentPlacement placement) const;
String toStyledString() const;
const_iterator begin() const;
const_iterator end() const;
iterator begin();
iterator end();
// Accessors for the [start, limit) range of bytes within the JSON text from
// which this value was parsed, if any.
void setOffsetStart(ptrdiff_t start);
void setOffsetLimit(ptrdiff_t limit);
ptrdiff_t getOffsetStart() const;
ptrdiff_t getOffsetLimit() const;
private:
void setType(ValueType v) {
bits_.value_type_ = static_cast<unsigned char>(v);
}
bool isAllocated() const { return bits_.allocated_; }
void setIsAllocated(bool v) { bits_.allocated_ = v; }
void initBasic(ValueType type, bool allocated = false);
void dupPayload(const Value& other);
void releasePayload();
void dupMeta(const Value& other);
Value& resolveReference(const char* key);
Value& resolveReference(const char* key, const char* end);
// struct MemberNamesTransform
//{
// typedef const char *result_type;
// const char *operator()( const CZString &name ) const
// {
// return name.c_str();
// }
//};
union ValueHolder {
LargestInt int_;
LargestUInt uint_;
double real_;
bool bool_;
char* string_; // if allocated_, ptr to { unsigned, char[] }.
ObjectValues* map_;
} value_;
struct {
// Really a ValueType, but types should agree for bitfield packing.
unsigned int value_type_ : 8;
// Unless allocated_, string_ must be null-terminated.
unsigned int allocated_ : 1;
} bits_;
class Comments {
public:
Comments() = default;
Comments(const Comments& that);
Comments(Comments&& that) noexcept;
Comments& operator=(const Comments& that);
Comments& operator=(Comments&& that) noexcept;
bool has(CommentPlacement slot) const;
String get(CommentPlacement slot) const;
void set(CommentPlacement slot, String comment);
private:
using Array = std::array<String, numberOfCommentPlacement>;
std::unique_ptr<Array> ptr_;
};
Comments comments_;
// [start, limit) byte offsets in the source JSON text from which this Value
// was extracted.
ptrdiff_t start_;
ptrdiff_t limit_;
};
template <> inline bool Value::as<bool>() const { return asBool(); }
template <> inline bool Value::is<bool>() const { return isBool(); }
template <> inline Int Value::as<Int>() const { return asInt(); }
template <> inline bool Value::is<Int>() const { return isInt(); }
template <> inline UInt Value::as<UInt>() const { return asUInt(); }
template <> inline bool Value::is<UInt>() const { return isUInt(); }
#if defined(JSON_HAS_INT64)
template <> inline Int64 Value::as<Int64>() const { return asInt64(); }
template <> inline bool Value::is<Int64>() const { return isInt64(); }
template <> inline UInt64 Value::as<UInt64>() const { return asUInt64(); }
template <> inline bool Value::is<UInt64>() const { return isUInt64(); }
#endif
template <> inline double Value::as<double>() const { return asDouble(); }
template <> inline bool Value::is<double>() const { return isDouble(); }
template <> inline String Value::as<String>() const { return asString(); }
template <> inline bool Value::is<String>() const { return isString(); }
/// These `as` specializations are type conversions, and do not have a
/// corresponding `is`.
template <> inline float Value::as<float>() const { return asFloat(); }
template <> inline const char* Value::as<const char*>() const {
return asCString();
}
/** \brief Experimental and untested: represents an element of the "path" to
* access a node.
*/
class JSON_API PathArgument {
public:
friend class Path;
PathArgument();
PathArgument(ArrayIndex index);
PathArgument(const char* key);
PathArgument(String key);
private:
enum Kind { kindNone = 0, kindIndex, kindKey };
String key_;
ArrayIndex index_{};
Kind kind_{kindNone};
};
/** \brief Experimental and untested: represents a "path" to access a node.
*
* Syntax:
* - "." => root node
* - ".[n]" => elements at index 'n' of root node (an array value)
* - ".name" => member named 'name' of root node (an object value)
* - ".name1.name2.name3"
* - ".[0][1][2].name1[3]"
* - ".%" => member name is provided as parameter
* - ".[%]" => index is provided as parameter
*/
class JSON_API Path {
public:
Path(const String& path, const PathArgument& a1 = PathArgument(),
const PathArgument& a2 = PathArgument(),
const PathArgument& a3 = PathArgument(),
const PathArgument& a4 = PathArgument(),
const PathArgument& a5 = PathArgument());
const Value& resolve(const Value& root) const;
Value resolve(const Value& root, const Value& defaultValue) const;
/// Creates the "path" to access the specified node and returns a reference on
/// the node.
Value& make(Value& root) const;
private:
using InArgs = std::vector<const PathArgument*>;
using Args = std::vector<PathArgument>;
void makePath(const String& path, const InArgs& in);
void addPathInArg(const String& path, const InArgs& in,
InArgs::const_iterator& itInArg, PathArgument::Kind kind);
static void invalidPath(const String& path, int location);
Args args_;
};
/** \brief base class for Value iterators.
*
*/
class JSON_API ValueIteratorBase {
public:
using iterator_category = std::bidirectional_iterator_tag;
using size_t = unsigned int;
using difference_type = int;
using SelfType = ValueIteratorBase;
bool operator==(const SelfType& other) const { return isEqual(other); }
bool operator!=(const SelfType& other) const { return !isEqual(other); }
difference_type operator-(const SelfType& other) const {
return other.computeDistance(*this);
}
/// Return either the index or the member name of the referenced value as a
/// Value.
Value key() const;
/// Return the index of the referenced Value, or -1 if it is not an
/// arrayValue.
UInt index() const;
/// Return the member name of the referenced Value, or "" if it is not an
/// objectValue.
/// \note Avoid `c_str()` on result, as embedded zeroes are possible.
String name() const;
/// Return the member name of the referenced Value. "" if it is not an
/// objectValue.
/// \deprecated This cannot be used for UTF-8 strings, since there can be
/// embedded nulls.
JSONCPP_DEPRECATED("Use `key = name();` instead.")
char const* memberName() const;
/// Return the member name of the referenced Value, or NULL if it is not an
/// objectValue.
/// \note Better version than memberName(). Allows embedded nulls.
char const* memberName(char const** end) const;
protected:
/*! Internal utility functions to assist with implementing
* other iterator functions. The const and non-const versions
* of the "deref" protected methods expose the protected
* current_ member variable in a way that can often be
* optimized away by the compiler.
*/
const Value& deref() const;
Value& deref();
void increment();
void decrement();
difference_type computeDistance(const SelfType& other) const;
bool isEqual(const SelfType& other) const;
void copy(const SelfType& other);
private:
Value::ObjectValues::iterator current_;
// Indicates that iterator is for a null value.
bool isNull_{true};
public:
// For some reason, BORLAND needs these at the end, rather
// than earlier. No idea why.
ValueIteratorBase();
explicit ValueIteratorBase(const Value::ObjectValues::iterator& current);
};
/** \brief const iterator for object and array value.
*
*/
class JSON_API ValueConstIterator : public ValueIteratorBase {
friend class Value;
public:
using value_type = const Value;
// typedef unsigned int size_t;
// typedef int difference_type;
using reference = const Value&;
using pointer = const Value*;
using SelfType = ValueConstIterator;
ValueConstIterator();
ValueConstIterator(ValueIterator const& other);
private:
/*! \internal Use by Value to create an iterator.
*/
explicit ValueConstIterator(const Value::ObjectValues::iterator& current);
public:
SelfType& operator=(const ValueIteratorBase& other);
SelfType operator++(int) {
SelfType temp(*this);
++*this;
return temp;
}
SelfType operator--(int) {
SelfType temp(*this);
--*this;
return temp;
}
SelfType& operator--() {
decrement();
return *this;
}
SelfType& operator++() {
increment();
return *this;
}
reference operator*() const { return deref(); }
pointer operator->() const { return &deref(); }
};
/** \brief Iterator for object and array value.
*/
class JSON_API ValueIterator : public ValueIteratorBase {
friend class Value;
public:
using value_type = Value;
using size_t = unsigned int;
using difference_type = int;
using reference = Value&;
using pointer = Value*;
using SelfType = ValueIterator;
ValueIterator();
explicit ValueIterator(const ValueConstIterator& other);
ValueIterator(const ValueIterator& other);
private:
/*! \internal Use by Value to create an iterator.
*/
explicit ValueIterator(const Value::ObjectValues::iterator& current);
public:
SelfType& operator=(const SelfType& other);
SelfType operator++(int) {
SelfType temp(*this);
++*this;
return temp;
}
SelfType operator--(int) {
SelfType temp(*this);
--*this;
return temp;
}
SelfType& operator--() {
decrement();
return *this;
}
SelfType& operator++() {
increment();
return *this;
}
/*! The return value of non-const iterators can be
* changed, so the these functions are not const
* because the returned references/pointers can be used
* to change state of the base class.
*/
reference operator*() { return deref(); }
pointer operator->() { return &deref(); }
};
inline void swap(Value& a, Value& b) { a.swap(b); }
} // namespace Json
#pragma pack(pop)
#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
#pragma warning(pop)
#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
#endif // JSON_H_INCLUDED
| YifuLiu/AliOS-Things | components/jsoncpp/include/json/value.h | C++ | apache-2.0 | 30,234 |
#ifndef JSON_VERSION_H_INCLUDED
#define JSON_VERSION_H_INCLUDED
// Note: version must be updated in three places when doing a release. This
// annoying process ensures that amalgamate, CMake, and meson all report the
// correct version.
// 1. /meson.build
// 2. /include/json/version.h
// 3. /CMakeLists.txt
// IMPORTANT: also update the SOVERSION!!
#define JSONCPP_VERSION_STRING "1.9.4"
#define JSONCPP_VERSION_MAJOR 1
#define JSONCPP_VERSION_MINOR 9
#define JSONCPP_VERSION_PATCH 4
#define JSONCPP_VERSION_QUALIFIER
#define JSONCPP_VERSION_HEXA \
((JSONCPP_VERSION_MAJOR << 24) | (JSONCPP_VERSION_MINOR << 16) | \
(JSONCPP_VERSION_PATCH << 8))
#ifdef JSONCPP_USING_SECURE_MEMORY
#undef JSONCPP_USING_SECURE_MEMORY
#endif
#define JSONCPP_USING_SECURE_MEMORY 0
// If non-zero, the library zeroes any memory that it has allocated before
// it frees its memory.
#endif // JSON_VERSION_H_INCLUDED
| YifuLiu/AliOS-Things | components/jsoncpp/include/json/version.h | C | apache-2.0 | 966 |
// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#ifndef JSON_WRITER_H_INCLUDED
#define JSON_WRITER_H_INCLUDED
#if !defined(JSON_IS_AMALGAMATION)
#include "value.h"
#endif // if !defined(JSON_IS_AMALGAMATION)
#include <ostream>
#include <string>
#include <vector>
// Disable warning C4251: <data member>: <type> needs to have dll-interface to
// be used by...
#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING) && defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4251)
#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
#pragma pack(push, 8)
namespace Json {
class Value;
/**
*
* Usage:
* \code
* using namespace Json;
* void writeToStdout(StreamWriter::Factory const& factory, Value const& value)
* { std::unique_ptr<StreamWriter> const writer( factory.newStreamWriter());
* writer->write(value, &std::cout);
* std::cout << std::endl; // add lf and flush
* }
* \endcode
*/
class JSON_API StreamWriter {
protected:
OStream* sout_; // not owned; will not delete
public:
StreamWriter();
virtual ~StreamWriter();
/** Write Value into document as configured in sub-class.
* Do not take ownership of sout, but maintain a reference during function.
* \pre sout != NULL
* \return zero on success (For now, we always return zero, so check the
* stream instead.) \throw std::exception possibly, depending on
* configuration
*/
virtual int write(Value const& root, OStream* sout) = 0;
/** \brief A simple abstract factory.
*/
class JSON_API Factory {
public:
virtual ~Factory();
/** \brief Allocate a CharReader via operator new().
* \throw std::exception if something goes wrong (e.g. invalid settings)
*/
virtual StreamWriter* newStreamWriter() const = 0;
}; // Factory
}; // StreamWriter
/** \brief Write into stringstream, then return string, for convenience.
* A StreamWriter will be created from the factory, used, and then deleted.
*/
String JSON_API writeString(StreamWriter::Factory const& factory,
Value const& root);
/** \brief Build a StreamWriter implementation.
* Usage:
* \code
* using namespace Json;
* Value value = ...;
* StreamWriterBuilder builder;
* builder["commentStyle"] = "None";
* builder["indentation"] = " "; // or whatever you like
* std::unique_ptr<Json::StreamWriter> writer(
* builder.newStreamWriter());
* writer->write(value, &std::cout);
* std::cout << std::endl; // add lf and flush
* \endcode
*/
class JSON_API StreamWriterBuilder : public StreamWriter::Factory {
public:
// Note: We use a Json::Value so that we can add data-members to this class
// without a major version bump.
/** Configuration of this builder.
* Available settings (case-sensitive):
* - "commentStyle": "None" or "All"
* - "indentation": "<anything>".
* - Setting this to an empty string also omits newline characters.
* - "enableYAMLCompatibility": false or true
* - slightly change the whitespace around colons
* - "dropNullPlaceholders": false or true
* - Drop the "null" string from the writer's output for nullValues.
* Strictly speaking, this is not valid JSON. But when the output is being
* fed to a browser's JavaScript, it makes for smaller output and the
* browser can handle the output just fine.
* - "useSpecialFloats": false or true
* - If true, outputs non-finite floating point values in the following way:
* NaN values as "NaN", positive infinity as "Infinity", and negative
* infinity as "-Infinity".
* - "precision": int
* - Number of precision digits for formatting of real values.
* - "precisionType": "significant"(default) or "decimal"
* - Type of precision for formatting of real values.
* You can examine 'settings_` yourself
* to see the defaults. You can also write and read them just like any
* JSON Value.
* \sa setDefaults()
*/
Json::Value settings_;
StreamWriterBuilder();
~StreamWriterBuilder() override;
/**
* \throw std::exception if something goes wrong (e.g. invalid settings)
*/
StreamWriter* newStreamWriter() const override;
/** \return true if 'settings' are legal and consistent;
* otherwise, indicate bad settings via 'invalid'.
*/
bool validate(Json::Value* invalid) const;
/** A simple way to update a specific setting.
*/
Value& operator[](const String& key);
/** Called by ctor, but you can use this to reset settings_.
* \pre 'settings' != NULL (but Json::null is fine)
* \remark Defaults:
* \snippet src/lib_json/json_writer.cpp StreamWriterBuilderDefaults
*/
static void setDefaults(Json::Value* settings);
};
/** \brief Abstract class for writers.
* \deprecated Use StreamWriter. (And really, this is an implementation detail.)
*/
class JSONCPP_DEPRECATED("Use StreamWriter instead") JSON_API Writer {
public:
virtual ~Writer();
virtual String write(const Value& root) = 0;
};
/** \brief Outputs a Value in <a HREF="http://www.json.org">JSON</a> format
*without formatting (not human friendly).
*
* The JSON document is written in a single line. It is not intended for 'human'
*consumption,
* but may be useful to support feature such as RPC where bandwidth is limited.
* \sa Reader, Value
* \deprecated Use StreamWriterBuilder.
*/
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4996) // Deriving from deprecated class
#endif
class JSONCPP_DEPRECATED("Use StreamWriterBuilder instead") JSON_API FastWriter
: public Writer {
public:
FastWriter();
~FastWriter() override = default;
void enableYAMLCompatibility();
/** \brief Drop the "null" string from the writer's output for nullValues.
* Strictly speaking, this is not valid JSON. But when the output is being
* fed to a browser's JavaScript, it makes for smaller output and the
* browser can handle the output just fine.
*/
void dropNullPlaceholders();
void omitEndingLineFeed();
public: // overridden from Writer
String write(const Value& root) override;
private:
void writeValue(const Value& value);
String document_;
bool yamlCompatibilityEnabled_{false};
bool dropNullPlaceholders_{false};
bool omitEndingLineFeed_{false};
};
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
/** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a
*human friendly way.
*
* The rules for line break and indent are as follow:
* - Object value:
* - if empty then print {} without indent and line break
* - if not empty the print '{', line break & indent, print one value per
*line
* and then unindent and line break and print '}'.
* - Array value:
* - if empty then print [] without indent and line break
* - if the array contains no object value, empty array or some other value
*types,
* and all the values fit on one lines, then print the array on a single
*line.
* - otherwise, it the values do not fit on one line, or the array contains
* object or non empty array, then print one value per line.
*
* If the Value have comments then they are outputed according to their
*#CommentPlacement.
*
* \sa Reader, Value, Value::setComment()
* \deprecated Use StreamWriterBuilder.
*/
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4996) // Deriving from deprecated class
#endif
class JSONCPP_DEPRECATED("Use StreamWriterBuilder instead") JSON_API
StyledWriter : public Writer {
public:
StyledWriter();
~StyledWriter() override = default;
public: // overridden from Writer
/** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
* \param root Value to serialize.
* \return String containing the JSON document that represents the root value.
*/
String write(const Value& root) override;
private:
void writeValue(const Value& value);
void writeArrayValue(const Value& value);
bool isMultilineArray(const Value& value);
void pushValue(const String& value);
void writeIndent();
void writeWithIndent(const String& value);
void indent();
void unindent();
void writeCommentBeforeValue(const Value& root);
void writeCommentAfterValueOnSameLine(const Value& root);
static bool hasCommentForValue(const Value& value);
static String normalizeEOL(const String& text);
using ChildValues = std::vector<String>;
ChildValues childValues_;
String document_;
String indentString_;
unsigned int rightMargin_{74};
unsigned int indentSize_{3};
bool addChildValues_{false};
};
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
/** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a
human friendly way,
to a stream rather than to a string.
*
* The rules for line break and indent are as follow:
* - Object value:
* - if empty then print {} without indent and line break
* - if not empty the print '{', line break & indent, print one value per
line
* and then unindent and line break and print '}'.
* - Array value:
* - if empty then print [] without indent and line break
* - if the array contains no object value, empty array or some other value
types,
* and all the values fit on one lines, then print the array on a single
line.
* - otherwise, it the values do not fit on one line, or the array contains
* object or non empty array, then print one value per line.
*
* If the Value have comments then they are outputed according to their
#CommentPlacement.
*
* \sa Reader, Value, Value::setComment()
* \deprecated Use StreamWriterBuilder.
*/
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4996) // Deriving from deprecated class
#endif
class JSONCPP_DEPRECATED("Use StreamWriterBuilder instead") JSON_API
StyledStreamWriter {
public:
/**
* \param indentation Each level will be indented by this amount extra.
*/
StyledStreamWriter(String indentation = "\t");
~StyledStreamWriter() = default;
public:
/** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
* \param out Stream to write to. (Can be ostringstream, e.g.)
* \param root Value to serialize.
* \note There is no point in deriving from Writer, since write() should not
* return a value.
*/
void write(OStream& out, const Value& root);
private:
void writeValue(const Value& value);
void writeArrayValue(const Value& value);
bool isMultilineArray(const Value& value);
void pushValue(const String& value);
void writeIndent();
void writeWithIndent(const String& value);
void indent();
void unindent();
void writeCommentBeforeValue(const Value& root);
void writeCommentAfterValueOnSameLine(const Value& root);
static bool hasCommentForValue(const Value& value);
static String normalizeEOL(const String& text);
using ChildValues = std::vector<String>;
ChildValues childValues_;
OStream* document_;
String indentString_;
unsigned int rightMargin_{74};
String indentation_;
bool addChildValues_ : 1;
bool indented_ : 1;
};
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
#if defined(JSON_HAS_INT64)
String JSON_API valueToString(Int value);
String JSON_API valueToString(UInt value);
#endif // if defined(JSON_HAS_INT64)
String JSON_API valueToString(LargestInt value);
String JSON_API valueToString(LargestUInt value);
String JSON_API valueToString(
double value, unsigned int precision = Value::defaultRealPrecision,
PrecisionType precisionType = PrecisionType::significantDigits);
String JSON_API valueToString(bool value);
String JSON_API valueToQuotedString(const char* value);
/// \brief Output using the StyledStreamWriter.
/// \see Json::operator>>()
JSON_API OStream& operator<<(OStream&, const Value& root);
} // namespace Json
#pragma pack(pop)
#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
#pragma warning(pop)
#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
#endif // JSON_WRITER_H_INCLUDED
| YifuLiu/AliOS-Things | components/jsoncpp/include/json/writer.h | C++ | apache-2.0 | 12,202 |
project(
'jsoncpp',
'cpp',
# Note: version must be updated in three places when doing a release. This
# annoying process ensures that amalgamate, CMake, and meson all report the
# correct version.
# 1. /meson.build
# 2. /include/json/version.h
# 3. /CMakeLists.txt
# IMPORTANT: also update the SOVERSION!!
version : '1.9.4',
default_options : [
'buildtype=release',
'cpp_std=c++11',
'warning_level=1'],
license : 'Public Domain',
meson_version : '>= 0.49.0')
jsoncpp_headers = files([
'include/json/allocator.h',
'include/json/assertions.h',
'include/json/config.h',
'include/json/json_features.h',
'include/json/forwards.h',
'include/json/json.h',
'include/json/reader.h',
'include/json/value.h',
'include/json/version.h',
'include/json/writer.h',
])
jsoncpp_include_directories = include_directories('include')
install_headers(
jsoncpp_headers,
subdir : 'json')
if get_option('default_library') == 'shared' and meson.get_compiler('cpp').get_id() == 'msvc'
dll_export_flag = '-DJSON_DLL_BUILD'
dll_import_flag = '-DJSON_DLL'
else
dll_export_flag = []
dll_import_flag = []
endif
jsoncpp_lib = library(
'jsoncpp', files([
'src/lib_json/json_reader.cpp',
'src/lib_json/json_value.cpp',
'src/lib_json/json_writer.cpp',
]),
soversion : 24,
install : true,
include_directories : jsoncpp_include_directories,
cpp_args: dll_export_flag)
import('pkgconfig').generate(
libraries : jsoncpp_lib,
version : meson.project_version(),
name : 'jsoncpp',
filebase : 'jsoncpp',
description : 'A C++ library for interacting with JSON')
# for libraries bundling jsoncpp
jsoncpp_dep = declare_dependency(
include_directories : jsoncpp_include_directories,
link_with : jsoncpp_lib,
version : meson.project_version())
# tests
if meson.is_subproject() or not get_option('tests')
subdir_done()
endif
python = import('python').find_installation()
jsoncpp_test = executable(
'jsoncpp_test', files([
'src/test_lib_json/jsontest.cpp',
'src/test_lib_json/main.cpp',
'src/test_lib_json/fuzz.cpp',
]),
include_directories : jsoncpp_include_directories,
link_with : jsoncpp_lib,
install : false,
cpp_args: dll_import_flag)
test(
'unittest_jsoncpp_test',
jsoncpp_test)
jsontestrunner = executable(
'jsontestrunner',
'src/jsontestrunner/main.cpp',
include_directories : jsoncpp_include_directories,
link_with : jsoncpp_lib,
install : false,
cpp_args: dll_import_flag)
test(
'unittest_jsontestrunner',
python,
args : [
'-B',
join_paths(meson.current_source_dir(), 'test/runjsontests.py'),
jsontestrunner,
join_paths(meson.current_source_dir(), 'test/data')],
)
test(
'jsonchecker_jsontestrunner',
python,
is_parallel : false,
args : [
'-B',
join_paths(meson.current_source_dir(), 'test/runjsontests.py'),
'--with-json-checker',
jsontestrunner,
join_paths(meson.current_source_dir(), 'test/data')],
workdir : join_paths(meson.current_source_dir(), 'test/data'),
)
| YifuLiu/AliOS-Things | components/jsoncpp/meson.build | Meson | apache-2.0 | 3,049 |
option(
'tests',
type : 'boolean',
value : true,
description : 'Enable building tests')
| YifuLiu/AliOS-Things | components/jsoncpp/meson_options.txt | Meson | apache-2.0 | 96 |
find src -name '*.cpp' -or -name '*.h' | xargs clang-format -i
| YifuLiu/AliOS-Things | components/jsoncpp/reformat.sh | Shell | apache-2.0 | 63 |
add_subdirectory(lib_json)
if(JSONCPP_WITH_TESTS)
add_subdirectory(jsontestrunner)
add_subdirectory(test_lib_json)
endif()
| YifuLiu/AliOS-Things | components/jsoncpp/src/CMakeLists.txt | CMake | apache-2.0 | 131 |
if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.12.0)
# The new Python3 module is much more robust than the previous PythonInterp
find_package(Python3 COMPONENTS Interpreter)
# Set variables for backwards compatibility with cmake < 3.12.0
set(PYTHONINTERP_FOUND ${Python3_Interpreter_FOUND})
set(PYTHON_EXECUTABLE ${Python3_EXECUTABLE})
else()
set(Python_ADDITIONAL_VERSIONS 3.8)
find_package(PythonInterp 3)
endif()
add_executable(jsontestrunner_exe
main.cpp
)
if(BUILD_SHARED_LIBS)
if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.12.0)
add_compile_definitions( JSON_DLL )
else()
add_definitions(-DJSON_DLL)
endif()
target_link_libraries(jsontestrunner_exe jsoncpp_lib)
else()
target_link_libraries(jsontestrunner_exe jsoncpp_static)
endif()
set_target_properties(jsontestrunner_exe PROPERTIES OUTPUT_NAME jsontestrunner_exe)
if(PYTHONINTERP_FOUND)
# Run end to end parser/writer tests
set(TEST_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../test)
set(RUNJSONTESTS_PATH ${TEST_DIR}/runjsontests.py)
# Run unit tests in post-build
# (default cmake workflow hides away the test result into a file, resulting in poor dev workflow?!?)
add_custom_target(jsoncpp_readerwriter_tests
"${PYTHON_EXECUTABLE}" -B "${RUNJSONTESTS_PATH}" $<TARGET_FILE:jsontestrunner_exe> "${TEST_DIR}/data"
DEPENDS jsontestrunner_exe jsoncpp_test
)
add_custom_target(jsoncpp_check DEPENDS jsoncpp_readerwriter_tests)
## Create tests for dashboard submission, allows easy review of CI results https://my.cdash.org/index.php?project=jsoncpp
add_test(NAME jsoncpp_readerwriter
COMMAND "${PYTHON_EXECUTABLE}" -B "${RUNJSONTESTS_PATH}" $<TARGET_FILE:jsontestrunner_exe> "${TEST_DIR}/data"
WORKING_DIRECTORY "${TEST_DIR}/data"
)
add_test(NAME jsoncpp_readerwriter_json_checker
COMMAND "${PYTHON_EXECUTABLE}" -B "${RUNJSONTESTS_PATH}" --with-json-checker $<TARGET_FILE:jsontestrunner_exe> "${TEST_DIR}/data"
WORKING_DIRECTORY "${TEST_DIR}/data"
)
endif()
| YifuLiu/AliOS-Things | components/jsoncpp/src/jsontestrunner/CMakeLists.txt | CMake | apache-2.0 | 2,072 |
// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#elif defined(_MSC_VER)
#pragma warning(disable : 4996)
#endif
/* This executable is used for testing parser/writer using real JSON files.
*/
#include <algorithm> // sort
#include <cstdio>
#include <iostream>
#include <json/json.h>
#include <memory>
#include <sstream>
struct Options {
Json::String path;
Json::Features features;
bool parseOnly;
using writeFuncType = Json::String (*)(Json::Value const&);
writeFuncType write;
};
static Json::String normalizeFloatingPointStr(double value) {
char buffer[32];
jsoncpp_snprintf(buffer, sizeof(buffer), "%.16g", value);
buffer[sizeof(buffer) - 1] = 0;
Json::String s(buffer);
Json::String::size_type index = s.find_last_of("eE");
if (index != Json::String::npos) {
Json::String::size_type hasSign =
(s[index + 1] == '+' || s[index + 1] == '-') ? 1 : 0;
Json::String::size_type exponentStartIndex = index + 1 + hasSign;
Json::String normalized = s.substr(0, exponentStartIndex);
Json::String::size_type indexDigit =
s.find_first_not_of('0', exponentStartIndex);
Json::String exponent = "0";
if (indexDigit != Json::String::npos) // There is an exponent different
// from 0
{
exponent = s.substr(indexDigit);
}
return normalized + exponent;
}
return s;
}
static Json::String readInputTestFile(const char* path) {
FILE* file = fopen(path, "rb");
if (!file)
return "";
fseek(file, 0, SEEK_END);
auto const size = ftell(file);
auto const usize = static_cast<size_t>(size);
fseek(file, 0, SEEK_SET);
auto buffer = new char[size + 1];
buffer[size] = 0;
Json::String text;
if (fread(buffer, 1, usize, file) == usize)
text = buffer;
fclose(file);
delete[] buffer;
return text;
}
static void printValueTree(FILE* fout, Json::Value& value,
const Json::String& path = ".") {
if (value.hasComment(Json::commentBefore)) {
fprintf(fout, "%s\n", value.getComment(Json::commentBefore).c_str());
}
switch (value.type()) {
case Json::nullValue:
fprintf(fout, "%s=null\n", path.c_str());
break;
case Json::intValue:
fprintf(fout, "%s=%s\n", path.c_str(),
Json::valueToString(value.asLargestInt()).c_str());
break;
case Json::uintValue:
fprintf(fout, "%s=%s\n", path.c_str(),
Json::valueToString(value.asLargestUInt()).c_str());
break;
case Json::realValue:
fprintf(fout, "%s=%s\n", path.c_str(),
normalizeFloatingPointStr(value.asDouble()).c_str());
break;
case Json::stringValue:
fprintf(fout, "%s=\"%s\"\n", path.c_str(), value.asString().c_str());
break;
case Json::booleanValue:
fprintf(fout, "%s=%s\n", path.c_str(), value.asBool() ? "true" : "false");
break;
case Json::arrayValue: {
fprintf(fout, "%s=[]\n", path.c_str());
Json::ArrayIndex size = value.size();
for (Json::ArrayIndex index = 0; index < size; ++index) {
static char buffer[16];
jsoncpp_snprintf(buffer, sizeof(buffer), "[%u]", index);
printValueTree(fout, value[index], path + buffer);
}
} break;
case Json::objectValue: {
fprintf(fout, "%s={}\n", path.c_str());
Json::Value::Members members(value.getMemberNames());
std::sort(members.begin(), members.end());
Json::String suffix = *(path.end() - 1) == '.' ? "" : ".";
for (const auto& name : members) {
printValueTree(fout, value[name], path + suffix + name);
}
} break;
default:
break;
}
if (value.hasComment(Json::commentAfter)) {
fprintf(fout, "%s\n", value.getComment(Json::commentAfter).c_str());
}
}
static int parseAndSaveValueTree(const Json::String& input,
const Json::String& actual,
const Json::String& kind,
const Json::Features& features, bool parseOnly,
Json::Value* root, bool use_legacy) {
if (!use_legacy) {
Json::CharReaderBuilder builder;
builder.settings_["allowComments"] = features.allowComments_;
builder.settings_["strictRoot"] = features.strictRoot_;
builder.settings_["allowDroppedNullPlaceholders"] =
features.allowDroppedNullPlaceholders_;
builder.settings_["allowNumericKeys"] = features.allowNumericKeys_;
std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
Json::String errors;
const bool parsingSuccessful =
reader->parse(input.data(), input.data() + input.size(), root, &errors);
if (!parsingSuccessful) {
std::cerr << "Failed to parse " << kind << " file: " << std::endl
<< errors << std::endl;
return 1;
}
// We may instead check the legacy implementation (to ensure it doesn't
// randomly get broken).
} else {
Json::Reader reader(features);
const bool parsingSuccessful =
reader.parse(input.data(), input.data() + input.size(), *root);
if (!parsingSuccessful) {
std::cerr << "Failed to parse " << kind << " file: " << std::endl
<< reader.getFormatedErrorMessages() << std::endl;
return 1;
}
}
if (!parseOnly) {
FILE* factual = fopen(actual.c_str(), "wt");
if (!factual) {
std::cerr << "Failed to create '" << kind << "' actual file."
<< std::endl;
return 2;
}
printValueTree(factual, *root);
fclose(factual);
}
return 0;
}
// static Json::String useFastWriter(Json::Value const& root) {
// Json::FastWriter writer;
// writer.enableYAMLCompatibility();
// return writer.write(root);
// }
static Json::String useStyledWriter(Json::Value const& root) {
Json::StyledWriter writer;
return writer.write(root);
}
static Json::String useStyledStreamWriter(Json::Value const& root) {
Json::StyledStreamWriter writer;
Json::OStringStream sout;
writer.write(sout, root);
return sout.str();
}
static Json::String useBuiltStyledStreamWriter(Json::Value const& root) {
Json::StreamWriterBuilder builder;
return Json::writeString(builder, root);
}
static int rewriteValueTree(const Json::String& rewritePath,
const Json::Value& root,
Options::writeFuncType write,
Json::String* rewrite) {
*rewrite = write(root);
FILE* fout = fopen(rewritePath.c_str(), "wt");
if (!fout) {
std::cerr << "Failed to create rewrite file: " << rewritePath << std::endl;
return 2;
}
fprintf(fout, "%s\n", rewrite->c_str());
fclose(fout);
return 0;
}
static Json::String removeSuffix(const Json::String& path,
const Json::String& extension) {
if (extension.length() >= path.length())
return Json::String("");
Json::String suffix = path.substr(path.length() - extension.length());
if (suffix != extension)
return Json::String("");
return path.substr(0, path.length() - extension.length());
}
static void printConfig() {
// Print the configuration used to compile JsonCpp
#if defined(JSON_NO_INT64)
std::cout << "JSON_NO_INT64=1" << std::endl;
#else
std::cout << "JSON_NO_INT64=0" << std::endl;
#endif
}
static int printUsage(const char* argv[]) {
std::cout << "Usage: " << argv[0] << " [--strict] input-json-file"
<< std::endl;
return 3;
}
static int parseCommandLine(int argc, const char* argv[], Options* opts) {
opts->parseOnly = false;
opts->write = &useStyledWriter;
if (argc < 2) {
return printUsage(argv);
}
int index = 1;
if (Json::String(argv[index]) == "--json-checker") {
opts->features = Json::Features::strictMode();
opts->parseOnly = true;
++index;
}
if (Json::String(argv[index]) == "--json-config") {
printConfig();
return 3;
}
if (Json::String(argv[index]) == "--json-writer") {
++index;
Json::String const writerName(argv[index++]);
if (writerName == "StyledWriter") {
opts->write = &useStyledWriter;
} else if (writerName == "StyledStreamWriter") {
opts->write = &useStyledStreamWriter;
} else if (writerName == "BuiltStyledStreamWriter") {
opts->write = &useBuiltStyledStreamWriter;
} else {
std::cerr << "Unknown '--json-writer' " << writerName << std::endl;
return 4;
}
}
if (index == argc || index + 1 < argc) {
return printUsage(argv);
}
opts->path = argv[index];
return 0;
}
static int runTest(Options const& opts, bool use_legacy) {
int exitCode = 0;
Json::String input = readInputTestFile(opts.path.c_str());
if (input.empty()) {
std::cerr << "Invalid input file: " << opts.path << std::endl;
return 3;
}
Json::String basePath = removeSuffix(opts.path, ".json");
if (!opts.parseOnly && basePath.empty()) {
std::cerr << "Bad input path '" << opts.path
<< "'. Must end with '.expected'" << std::endl;
return 3;
}
Json::String const actualPath = basePath + ".actual";
Json::String const rewritePath = basePath + ".rewrite";
Json::String const rewriteActualPath = basePath + ".actual-rewrite";
Json::Value root;
exitCode = parseAndSaveValueTree(input, actualPath, "input", opts.features,
opts.parseOnly, &root, use_legacy);
if (exitCode || opts.parseOnly) {
return exitCode;
}
Json::String rewrite;
exitCode = rewriteValueTree(rewritePath, root, opts.write, &rewrite);
if (exitCode) {
return exitCode;
}
Json::Value rewriteRoot;
exitCode = parseAndSaveValueTree(rewrite, rewriteActualPath, "rewrite",
opts.features, opts.parseOnly, &rewriteRoot,
use_legacy);
return exitCode;
}
int main(int argc, const char* argv[]) {
Options opts;
try {
int exitCode = parseCommandLine(argc, argv, &opts);
if (exitCode != 0) {
std::cerr << "Failed to parse command-line." << std::endl;
return exitCode;
}
const int modern_return_code = runTest(opts, false);
if (modern_return_code) {
return modern_return_code;
}
const std::string filename =
opts.path.substr(opts.path.find_last_of("\\/") + 1);
const bool should_run_legacy = (filename.rfind("legacy_", 0) == 0);
if (should_run_legacy) {
return runTest(opts, true);
}
} catch (const std::exception& e) {
std::cerr << "Unhandled exception:" << std::endl << e.what() << std::endl;
return 1;
}
}
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
| YifuLiu/AliOS-Things | components/jsoncpp/src/jsontestrunner/main.cpp | C++ | apache-2.0 | 10,862 |
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.1.2)
#-Werror=* was introduced -after- GCC 4.1.2
add_compile_options("-Werror=strict-aliasing")
endif()
include(CheckIncludeFileCXX)
include(CheckTypeSize)
include(CheckStructHasMember)
include(CheckCXXSymbolExists)
check_include_file_cxx(clocale HAVE_CLOCALE)
check_cxx_symbol_exists(localeconv clocale HAVE_LOCALECONV)
if(CMAKE_VERSION VERSION_LESS 3.0.0)
# The "LANGUAGE CXX" parameter is not supported in CMake versions below 3,
# so the C compiler and header has to be used.
check_include_file(locale.h HAVE_LOCALE_H)
set(CMAKE_EXTRA_INCLUDE_FILES locale.h)
check_type_size("struct lconv" LCONV_SIZE)
unset(CMAKE_EXTRA_INCLUDE_FILES)
check_struct_has_member("struct lconv" decimal_point locale.h HAVE_DECIMAL_POINT)
else()
set(CMAKE_EXTRA_INCLUDE_FILES clocale)
check_type_size(lconv LCONV_SIZE LANGUAGE CXX)
unset(CMAKE_EXTRA_INCLUDE_FILES)
check_struct_has_member(lconv decimal_point clocale HAVE_DECIMAL_POINT LANGUAGE CXX)
endif()
if(NOT (HAVE_CLOCALE AND HAVE_LCONV_SIZE AND HAVE_DECIMAL_POINT AND HAVE_LOCALECONV))
message(WARNING "Locale functionality is not supported")
if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.12.0)
add_compile_definitions(JSONCPP_NO_LOCALE_SUPPORT)
else()
add_definitions(-DJSONCPP_NO_LOCALE_SUPPORT)
endif()
endif()
set(JSONCPP_INCLUDE_DIR ../../include)
set(PUBLIC_HEADERS
${JSONCPP_INCLUDE_DIR}/json/config.h
${JSONCPP_INCLUDE_DIR}/json/forwards.h
${JSONCPP_INCLUDE_DIR}/json/json_features.h
${JSONCPP_INCLUDE_DIR}/json/value.h
${JSONCPP_INCLUDE_DIR}/json/reader.h
${JSONCPP_INCLUDE_DIR}/json/version.h
${JSONCPP_INCLUDE_DIR}/json/writer.h
${JSONCPP_INCLUDE_DIR}/json/assertions.h
)
source_group("Public API" FILES ${PUBLIC_HEADERS})
set(JSONCPP_SOURCES
json_tool.h
json_reader.cpp
json_valueiterator.inl
json_value.cpp
json_writer.cpp
)
# Install instructions for this target
if(JSONCPP_WITH_CMAKE_PACKAGE)
set(INSTALL_EXPORT EXPORT jsoncpp)
else()
set(INSTALL_EXPORT)
endif()
# Specify compiler features required when compiling a given target.
# See https://cmake.org/cmake/help/v3.1/prop_gbl/CMAKE_CXX_KNOWN_FEATURES.html#prop_gbl:CMAKE_CXX_KNOWN_FEATURES
# for complete list of features available
list(APPEND REQUIRED_FEATURES
cxx_std_11 # Compiler mode is aware of C++ 11.
#MSVC 1900 cxx_alignas # Alignment control alignas, as defined in N2341.
#MSVC 1900 cxx_alignof # Alignment control alignof, as defined in N2341.
#MSVC 1900 cxx_attributes # Generic attributes, as defined in N2761.
cxx_auto_type # Automatic type deduction, as defined in N1984.
#MSVC 1900 cxx_constexpr # Constant expressions, as defined in N2235.
cxx_decltype # Decltype, as defined in N2343.
cxx_default_function_template_args # Default template arguments for function templates, as defined in DR226
cxx_defaulted_functions # Defaulted functions, as defined in N2346.
#MSVC 1900 cxx_defaulted_move_initializers # Defaulted move initializers, as defined in N3053.
cxx_delegating_constructors # Delegating constructors, as defined in N1986.
#MSVC 1900 cxx_deleted_functions # Deleted functions, as defined in N2346.
cxx_enum_forward_declarations # Enum forward declarations, as defined in N2764.
cxx_explicit_conversions # Explicit conversion operators, as defined in N2437.
cxx_extended_friend_declarations # Extended friend declarations, as defined in N1791.
cxx_extern_templates # Extern templates, as defined in N1987.
cxx_final # Override control final keyword, as defined in N2928, N3206 and N3272.
#MSVC 1900 cxx_func_identifier # Predefined __func__ identifier, as defined in N2340.
#MSVC 1900 cxx_generalized_initializers # Initializer lists, as defined in N2672.
#MSVC 1900 cxx_inheriting_constructors # Inheriting constructors, as defined in N2540.
#MSVC 1900 cxx_inline_namespaces # Inline namespaces, as defined in N2535.
cxx_lambdas # Lambda functions, as defined in N2927.
#MSVC 1900 cxx_local_type_template_args # Local and unnamed types as template arguments, as defined in N2657.
cxx_long_long_type # long long type, as defined in N1811.
#MSVC 1900 cxx_noexcept # Exception specifications, as defined in N3050.
#MSVC 1900 cxx_nonstatic_member_init # Non-static data member initialization, as defined in N2756.
cxx_nullptr # Null pointer, as defined in N2431.
cxx_override # Override control override keyword, as defined in N2928, N3206 and N3272.
cxx_range_for # Range-based for, as defined in N2930.
cxx_raw_string_literals # Raw string literals, as defined in N2442.
#MSVC 1900 cxx_reference_qualified_functions # Reference qualified functions, as defined in N2439.
cxx_right_angle_brackets # Right angle bracket parsing, as defined in N1757.
cxx_rvalue_references # R-value references, as defined in N2118.
#MSVC 1900 cxx_sizeof_member # Size of non-static data members, as defined in N2253.
cxx_static_assert # Static assert, as defined in N1720.
cxx_strong_enums # Strongly typed enums, as defined in N2347.
#MSVC 1900 cxx_thread_local # Thread-local variables, as defined in N2659.
cxx_trailing_return_types # Automatic function return type, as defined in N2541.
#MSVC 1900 cxx_unicode_literals # Unicode string literals, as defined in N2442.
cxx_uniform_initialization # Uniform initialization, as defined in N2640.
#MSVC 1900 cxx_unrestricted_unions # Unrestricted unions, as defined in N2544.
#MSVC 1900 cxx_user_literals # User-defined literals, as defined in N2765.
cxx_variadic_macros # Variadic macros, as defined in N1653.
cxx_variadic_templates # Variadic templates, as defined in N2242.
)
if(BUILD_SHARED_LIBS)
if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.12.0)
add_compile_definitions(JSON_DLL_BUILD)
else()
add_definitions(-DJSON_DLL_BUILD)
endif()
set(SHARED_LIB ${PROJECT_NAME}_lib)
add_library(${SHARED_LIB} SHARED ${PUBLIC_HEADERS} ${JSONCPP_SOURCES})
set_target_properties(${SHARED_LIB} PROPERTIES
OUTPUT_NAME jsoncpp
VERSION ${PROJECT_VERSION}
SOVERSION ${PROJECT_SOVERSION}
POSITION_INDEPENDENT_CODE ON
)
# Set library's runtime search path on OSX
if(APPLE)
set_target_properties(${SHARED_LIB} PROPERTIES INSTALL_RPATH "@loader_path/.")
endif()
target_compile_features(${SHARED_LIB} PUBLIC ${REQUIRED_FEATURES})
if(NOT CMAKE_VERSION VERSION_LESS 2.8.11)
target_include_directories(${SHARED_LIB} PUBLIC
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/${JSONCPP_INCLUDE_DIR}>
$<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include/json>
)
endif()
list(APPEND CMAKE_TARGETS ${SHARED_LIB})
endif()
if(BUILD_STATIC_LIBS)
set(STATIC_LIB ${PROJECT_NAME}_static)
add_library(${STATIC_LIB} STATIC ${PUBLIC_HEADERS} ${JSONCPP_SOURCES})
# avoid name clashes on windows as the shared import lib is alse named jsoncpp.lib
if(NOT DEFINED STATIC_SUFFIX AND BUILD_SHARED_LIBS)
set(STATIC_SUFFIX "_static")
endif()
set_target_properties(${STATIC_LIB} PROPERTIES
OUTPUT_NAME jsoncpp${STATIC_SUFFIX}
VERSION ${PROJECT_VERSION}
)
# Set library's runtime search path on OSX
if(APPLE)
set_target_properties(${STATIC_LIB} PROPERTIES INSTALL_RPATH "@loader_path/.")
endif()
target_compile_features(${STATIC_LIB} PUBLIC ${REQUIRED_FEATURES})
if(NOT CMAKE_VERSION VERSION_LESS 2.8.11)
target_include_directories(${STATIC_LIB} PUBLIC
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/${JSONCPP_INCLUDE_DIR}>
$<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include/json>
)
endif()
list(APPEND CMAKE_TARGETS ${STATIC_LIB})
endif()
if(BUILD_OBJECT_LIBS)
set(OBJECT_LIB ${PROJECT_NAME}_object)
add_library(${OBJECT_LIB} OBJECT ${PUBLIC_HEADERS} ${JSONCPP_SOURCES})
set_target_properties(${OBJECT_LIB} PROPERTIES
OUTPUT_NAME jsoncpp
VERSION ${PROJECT_VERSION}
SOVERSION ${PROJECT_SOVERSION}
POSITION_INDEPENDENT_CODE ON
)
# Set library's runtime search path on OSX
if(APPLE)
set_target_properties(${OBJECT_LIB} PROPERTIES INSTALL_RPATH "@loader_path/.")
endif()
target_compile_features(${OBJECT_LIB} PUBLIC ${REQUIRED_FEATURES})
if(NOT CMAKE_VERSION VERSION_LESS 2.8.11)
target_include_directories(${OBJECT_LIB} PUBLIC
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/${JSONCPP_INCLUDE_DIR}>
$<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include/json>
)
endif()
list(APPEND CMAKE_TARGETS ${OBJECT_LIB})
endif()
install(TARGETS ${CMAKE_TARGETS} ${INSTALL_EXPORT}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
OBJECTS DESTINATION ${CMAKE_INSTALL_LIBDIR}
)
| YifuLiu/AliOS-Things | components/jsoncpp/src/lib_json/CMakeLists.txt | CMake | apache-2.0 | 9,444 |
// Copyright 2007-2011 Baptiste Lepilleur and The JsonCpp Authors
// Copyright (C) 2016 InfoTeCS JSC. All rights reserved.
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#if !defined(JSON_IS_AMALGAMATION)
#include "json_tool.h"
#include <json/assertions.h>
#include <json/reader.h>
#include <json/value.h>
#endif // if !defined(JSON_IS_AMALGAMATION)
#include <algorithm>
#include <cassert>
#include <cstring>
#include <iostream>
#include <istream>
#include <limits>
#include <memory>
#include <set>
#include <sstream>
#include <utility>
#include <cstdio>
#if __cplusplus >= 201103L
#if !defined(sscanf)
#define sscanf std::sscanf
#endif
#endif //__cplusplus
#if defined(_MSC_VER)
#if !defined(_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES)
#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1
#endif //_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES
#endif //_MSC_VER
#if defined(_MSC_VER)
// Disable warning about strdup being deprecated.
#pragma warning(disable : 4996)
#endif
// Define JSONCPP_DEPRECATED_STACK_LIMIT as an appropriate integer at compile
// time to change the stack limit
#if !defined(JSONCPP_DEPRECATED_STACK_LIMIT)
#define JSONCPP_DEPRECATED_STACK_LIMIT 1000
#endif
static size_t const stackLimit_g =
JSONCPP_DEPRECATED_STACK_LIMIT; // see readValue()
namespace Json {
#if __cplusplus >= 201103L || (defined(_CPPLIB_VER) && _CPPLIB_VER >= 520)
using CharReaderPtr = std::unique_ptr<CharReader>;
#else
using CharReaderPtr = std::auto_ptr<CharReader>;
#endif
// Implementation of class Features
// ////////////////////////////////
Features::Features() = default;
Features Features::all() { return {}; }
Features Features::strictMode() {
Features features;
features.allowComments_ = false;
features.strictRoot_ = true;
features.allowDroppedNullPlaceholders_ = false;
features.allowNumericKeys_ = false;
return features;
}
// Implementation of class Reader
// ////////////////////////////////
bool Reader::containsNewLine(Reader::Location begin, Reader::Location end) {
return std::any_of(begin, end, [](char b) { return b == '\n' || b == '\r'; });
}
// Class Reader
// //////////////////////////////////////////////////////////////////
Reader::Reader() : features_(Features::all()) {}
Reader::Reader(const Features& features) : features_(features) {}
bool Reader::parse(const std::string& document, Value& root,
bool collectComments) {
document_.assign(document.begin(), document.end());
const char* begin = document_.c_str();
const char* end = begin + document_.length();
return parse(begin, end, root, collectComments);
}
bool Reader::parse(std::istream& is, Value& root, bool collectComments) {
// std::istream_iterator<char> begin(is);
// std::istream_iterator<char> end;
// Those would allow streamed input from a file, if parse() were a
// template function.
// Since String is reference-counted, this at least does not
// create an extra copy.
String doc;
std::getline(is, doc, static_cast<char> EOF);
return parse(doc.data(), doc.data() + doc.size(), root, collectComments);
}
bool Reader::parse(const char* beginDoc, const char* endDoc, Value& root,
bool collectComments) {
if (!features_.allowComments_) {
collectComments = false;
}
begin_ = beginDoc;
end_ = endDoc;
collectComments_ = collectComments;
current_ = begin_;
lastValueEnd_ = nullptr;
lastValue_ = nullptr;
commentsBefore_.clear();
errors_.clear();
while (!nodes_.empty())
nodes_.pop();
nodes_.push(&root);
bool successful = readValue();
Token token;
skipCommentTokens(token);
if (collectComments_ && !commentsBefore_.empty())
root.setComment(commentsBefore_, commentAfter);
if (features_.strictRoot_) {
if (!root.isArray() && !root.isObject()) {
// Set error location to start of doc, ideally should be first token found
// in doc
token.type_ = tokenError;
token.start_ = beginDoc;
token.end_ = endDoc;
addError(
"A valid JSON document must be either an array or an object value.",
token);
return false;
}
}
return successful;
}
bool Reader::readValue() {
// readValue() may call itself only if it calls readObject() or ReadArray().
// These methods execute nodes_.push() just before and nodes_.pop)() just
// after calling readValue(). parse() executes one nodes_.push(), so > instead
// of >=.
if (nodes_.size() > stackLimit_g)
throwRuntimeError("Exceeded stackLimit in readValue().");
Token token;
skipCommentTokens(token);
bool successful = true;
if (collectComments_ && !commentsBefore_.empty()) {
currentValue().setComment(commentsBefore_, commentBefore);
commentsBefore_.clear();
}
switch (token.type_) {
case tokenObjectBegin:
successful = readObject(token);
currentValue().setOffsetLimit(current_ - begin_);
break;
case tokenArrayBegin:
successful = readArray(token);
currentValue().setOffsetLimit(current_ - begin_);
break;
case tokenNumber:
successful = decodeNumber(token);
break;
case tokenString:
successful = decodeString(token);
break;
case tokenTrue: {
Value v(true);
currentValue().swapPayload(v);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
} break;
case tokenFalse: {
Value v(false);
currentValue().swapPayload(v);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
} break;
case tokenNull: {
Value v;
currentValue().swapPayload(v);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
} break;
case tokenArraySeparator:
case tokenObjectEnd:
case tokenArrayEnd:
if (features_.allowDroppedNullPlaceholders_) {
// "Un-read" the current token and mark the current value as a null
// token.
current_--;
Value v;
currentValue().swapPayload(v);
currentValue().setOffsetStart(current_ - begin_ - 1);
currentValue().setOffsetLimit(current_ - begin_);
break;
} // Else, fall through...
default:
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return addError("Syntax error: value, object or array expected.", token);
}
if (collectComments_) {
lastValueEnd_ = current_;
lastValue_ = ¤tValue();
}
return successful;
}
void Reader::skipCommentTokens(Token& token) {
if (features_.allowComments_) {
do {
readToken(token);
} while (token.type_ == tokenComment);
} else {
readToken(token);
}
}
bool Reader::readToken(Token& token) {
skipSpaces();
token.start_ = current_;
Char c = getNextChar();
bool ok = true;
switch (c) {
case '{':
token.type_ = tokenObjectBegin;
break;
case '}':
token.type_ = tokenObjectEnd;
break;
case '[':
token.type_ = tokenArrayBegin;
break;
case ']':
token.type_ = tokenArrayEnd;
break;
case '"':
token.type_ = tokenString;
ok = readString();
break;
case '/':
token.type_ = tokenComment;
ok = readComment();
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case '-':
token.type_ = tokenNumber;
readNumber();
break;
case 't':
token.type_ = tokenTrue;
ok = match("rue", 3);
break;
case 'f':
token.type_ = tokenFalse;
ok = match("alse", 4);
break;
case 'n':
token.type_ = tokenNull;
ok = match("ull", 3);
break;
case ',':
token.type_ = tokenArraySeparator;
break;
case ':':
token.type_ = tokenMemberSeparator;
break;
case 0:
token.type_ = tokenEndOfStream;
break;
default:
ok = false;
break;
}
if (!ok)
token.type_ = tokenError;
token.end_ = current_;
return ok;
}
void Reader::skipSpaces() {
while (current_ != end_) {
Char c = *current_;
if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
++current_;
else
break;
}
}
bool Reader::match(const Char* pattern, int patternLength) {
if (end_ - current_ < patternLength)
return false;
int index = patternLength;
while (index--)
if (current_[index] != pattern[index])
return false;
current_ += patternLength;
return true;
}
bool Reader::readComment() {
Location commentBegin = current_ - 1;
Char c = getNextChar();
bool successful = false;
if (c == '*')
successful = readCStyleComment();
else if (c == '/')
successful = readCppStyleComment();
if (!successful)
return false;
if (collectComments_) {
CommentPlacement placement = commentBefore;
if (lastValueEnd_ && !containsNewLine(lastValueEnd_, commentBegin)) {
if (c != '*' || !containsNewLine(commentBegin, current_))
placement = commentAfterOnSameLine;
}
addComment(commentBegin, current_, placement);
}
return true;
}
String Reader::normalizeEOL(Reader::Location begin, Reader::Location end) {
String normalized;
normalized.reserve(static_cast<size_t>(end - begin));
Reader::Location current = begin;
while (current != end) {
char c = *current++;
if (c == '\r') {
if (current != end && *current == '\n')
// convert dos EOL
++current;
// convert Mac EOL
normalized += '\n';
} else {
normalized += c;
}
}
return normalized;
}
void Reader::addComment(Location begin, Location end,
CommentPlacement placement) {
assert(collectComments_);
const String& normalized = normalizeEOL(begin, end);
if (placement == commentAfterOnSameLine) {
assert(lastValue_ != nullptr);
lastValue_->setComment(normalized, placement);
} else {
commentsBefore_ += normalized;
}
}
bool Reader::readCStyleComment() {
while ((current_ + 1) < end_) {
Char c = getNextChar();
if (c == '*' && *current_ == '/')
break;
}
return getNextChar() == '/';
}
bool Reader::readCppStyleComment() {
while (current_ != end_) {
Char c = getNextChar();
if (c == '\n')
break;
if (c == '\r') {
// Consume DOS EOL. It will be normalized in addComment.
if (current_ != end_ && *current_ == '\n')
getNextChar();
// Break on Moc OS 9 EOL.
break;
}
}
return true;
}
void Reader::readNumber() {
Location p = current_;
char c = '0'; // stopgap for already consumed character
// integral part
while (c >= '0' && c <= '9')
c = (current_ = p) < end_ ? *p++ : '\0';
// fractional part
if (c == '.') {
c = (current_ = p) < end_ ? *p++ : '\0';
while (c >= '0' && c <= '9')
c = (current_ = p) < end_ ? *p++ : '\0';
}
// exponential part
if (c == 'e' || c == 'E') {
c = (current_ = p) < end_ ? *p++ : '\0';
if (c == '+' || c == '-')
c = (current_ = p) < end_ ? *p++ : '\0';
while (c >= '0' && c <= '9')
c = (current_ = p) < end_ ? *p++ : '\0';
}
}
bool Reader::readString() {
Char c = '\0';
while (current_ != end_) {
c = getNextChar();
if (c == '\\')
getNextChar();
else if (c == '"')
break;
}
return c == '"';
}
bool Reader::readObject(Token& token) {
Token tokenName;
String name;
Value init(objectValue);
currentValue().swapPayload(init);
currentValue().setOffsetStart(token.start_ - begin_);
while (readToken(tokenName)) {
bool initialTokenOk = true;
while (tokenName.type_ == tokenComment && initialTokenOk)
initialTokenOk = readToken(tokenName);
if (!initialTokenOk)
break;
if (tokenName.type_ == tokenObjectEnd && name.empty()) // empty object
return true;
name.clear();
if (tokenName.type_ == tokenString) {
if (!decodeString(tokenName, name))
return recoverFromError(tokenObjectEnd);
} else if (tokenName.type_ == tokenNumber && features_.allowNumericKeys_) {
Value numberName;
if (!decodeNumber(tokenName, numberName))
return recoverFromError(tokenObjectEnd);
name = numberName.asString();
} else {
break;
}
Token colon;
if (!readToken(colon) || colon.type_ != tokenMemberSeparator) {
return addErrorAndRecover("Missing ':' after object member name", colon,
tokenObjectEnd);
}
Value& value = currentValue()[name];
nodes_.push(&value);
bool ok = readValue();
nodes_.pop();
if (!ok) // error already set
return recoverFromError(tokenObjectEnd);
Token comma;
if (!readToken(comma) ||
(comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator &&
comma.type_ != tokenComment)) {
return addErrorAndRecover("Missing ',' or '}' in object declaration",
comma, tokenObjectEnd);
}
bool finalizeTokenOk = true;
while (comma.type_ == tokenComment && finalizeTokenOk)
finalizeTokenOk = readToken(comma);
if (comma.type_ == tokenObjectEnd)
return true;
}
return addErrorAndRecover("Missing '}' or object member name", tokenName,
tokenObjectEnd);
}
bool Reader::readArray(Token& token) {
Value init(arrayValue);
currentValue().swapPayload(init);
currentValue().setOffsetStart(token.start_ - begin_);
skipSpaces();
if (current_ != end_ && *current_ == ']') // empty array
{
Token endArray;
readToken(endArray);
return true;
}
int index = 0;
for (;;) {
Value& value = currentValue()[index++];
nodes_.push(&value);
bool ok = readValue();
nodes_.pop();
if (!ok) // error already set
return recoverFromError(tokenArrayEnd);
Token currentToken;
// Accept Comment after last item in the array.
ok = readToken(currentToken);
while (currentToken.type_ == tokenComment && ok) {
ok = readToken(currentToken);
}
bool badTokenType = (currentToken.type_ != tokenArraySeparator &&
currentToken.type_ != tokenArrayEnd);
if (!ok || badTokenType) {
return addErrorAndRecover("Missing ',' or ']' in array declaration",
currentToken, tokenArrayEnd);
}
if (currentToken.type_ == tokenArrayEnd)
break;
}
return true;
}
bool Reader::decodeNumber(Token& token) {
Value decoded;
if (!decodeNumber(token, decoded))
return false;
currentValue().swapPayload(decoded);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return true;
}
bool Reader::decodeNumber(Token& token, Value& decoded) {
// Attempts to parse the number as an integer. If the number is
// larger than the maximum supported value of an integer then
// we decode the number as a double.
Location current = token.start_;
bool isNegative = *current == '-';
if (isNegative)
++current;
// TODO: Help the compiler do the div and mod at compile time or get rid of
// them.
Value::LargestUInt maxIntegerValue =
isNegative ? Value::LargestUInt(Value::maxLargestInt) + 1
: Value::maxLargestUInt;
Value::LargestUInt threshold = maxIntegerValue / 10;
Value::LargestUInt value = 0;
while (current < token.end_) {
Char c = *current++;
if (c < '0' || c > '9')
return decodeDouble(token, decoded);
auto digit(static_cast<Value::UInt>(c - '0'));
if (value >= threshold) {
// We've hit or exceeded the max value divided by 10 (rounded down). If
// a) we've only just touched the limit, b) this is the last digit, and
// c) it's small enough to fit in that rounding delta, we're okay.
// Otherwise treat this number as a double to avoid overflow.
if (value > threshold || current != token.end_ ||
digit > maxIntegerValue % 10) {
return decodeDouble(token, decoded);
}
}
value = value * 10 + digit;
}
if (isNegative && value == maxIntegerValue)
decoded = Value::minLargestInt;
else if (isNegative)
decoded = -Value::LargestInt(value);
else if (value <= Value::LargestUInt(Value::maxInt))
decoded = Value::LargestInt(value);
else
decoded = value;
return true;
}
bool Reader::decodeDouble(Token& token) {
Value decoded;
if (!decodeDouble(token, decoded))
return false;
currentValue().swapPayload(decoded);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return true;
}
bool Reader::decodeDouble(Token& token, Value& decoded) {
double value = 0;
String buffer(token.start_, token.end_);
IStringStream is(buffer);
if (!(is >> value))
return addError(
"'" + String(token.start_, token.end_) + "' is not a number.", token);
decoded = value;
return true;
}
bool Reader::decodeString(Token& token) {
String decoded_string;
if (!decodeString(token, decoded_string))
return false;
Value decoded(decoded_string);
currentValue().swapPayload(decoded);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return true;
}
bool Reader::decodeString(Token& token, String& decoded) {
decoded.reserve(static_cast<size_t>(token.end_ - token.start_ - 2));
Location current = token.start_ + 1; // skip '"'
Location end = token.end_ - 1; // do not include '"'
while (current != end) {
Char c = *current++;
if (c == '"')
break;
if (c == '\\') {
if (current == end)
return addError("Empty escape sequence in string", token, current);
Char escape = *current++;
switch (escape) {
case '"':
decoded += '"';
break;
case '/':
decoded += '/';
break;
case '\\':
decoded += '\\';
break;
case 'b':
decoded += '\b';
break;
case 'f':
decoded += '\f';
break;
case 'n':
decoded += '\n';
break;
case 'r':
decoded += '\r';
break;
case 't':
decoded += '\t';
break;
case 'u': {
unsigned int unicode;
if (!decodeUnicodeCodePoint(token, current, end, unicode))
return false;
decoded += codePointToUTF8(unicode);
} break;
default:
return addError("Bad escape sequence in string", token, current);
}
} else {
decoded += c;
}
}
return true;
}
bool Reader::decodeUnicodeCodePoint(Token& token, Location& current,
Location end, unsigned int& unicode) {
if (!decodeUnicodeEscapeSequence(token, current, end, unicode))
return false;
if (unicode >= 0xD800 && unicode <= 0xDBFF) {
// surrogate pairs
if (end - current < 6)
return addError(
"additional six characters expected to parse unicode surrogate pair.",
token, current);
if (*(current++) == '\\' && *(current++) == 'u') {
unsigned int surrogatePair;
if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) {
unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
} else
return false;
} else
return addError("expecting another \\u token to begin the second half of "
"a unicode surrogate pair",
token, current);
}
return true;
}
bool Reader::decodeUnicodeEscapeSequence(Token& token, Location& current,
Location end,
unsigned int& ret_unicode) {
if (end - current < 4)
return addError(
"Bad unicode escape sequence in string: four digits expected.", token,
current);
int unicode = 0;
for (int index = 0; index < 4; ++index) {
Char c = *current++;
unicode *= 16;
if (c >= '0' && c <= '9')
unicode += c - '0';
else if (c >= 'a' && c <= 'f')
unicode += c - 'a' + 10;
else if (c >= 'A' && c <= 'F')
unicode += c - 'A' + 10;
else
return addError(
"Bad unicode escape sequence in string: hexadecimal digit expected.",
token, current);
}
ret_unicode = static_cast<unsigned int>(unicode);
return true;
}
bool Reader::addError(const String& message, Token& token, Location extra) {
ErrorInfo info;
info.token_ = token;
info.message_ = message;
info.extra_ = extra;
errors_.push_back(info);
return false;
}
bool Reader::recoverFromError(TokenType skipUntilToken) {
size_t const errorCount = errors_.size();
Token skip;
for (;;) {
if (!readToken(skip))
errors_.resize(errorCount); // discard errors caused by recovery
if (skip.type_ == skipUntilToken || skip.type_ == tokenEndOfStream)
break;
}
errors_.resize(errorCount);
return false;
}
bool Reader::addErrorAndRecover(const String& message, Token& token,
TokenType skipUntilToken) {
addError(message, token);
return recoverFromError(skipUntilToken);
}
Value& Reader::currentValue() { return *(nodes_.top()); }
Reader::Char Reader::getNextChar() {
if (current_ == end_)
return 0;
return *current_++;
}
void Reader::getLocationLineAndColumn(Location location, int& line,
int& column) const {
Location current = begin_;
Location lastLineStart = current;
line = 0;
while (current < location && current != end_) {
Char c = *current++;
if (c == '\r') {
if (*current == '\n')
++current;
lastLineStart = current;
++line;
} else if (c == '\n') {
lastLineStart = current;
++line;
}
}
// column & line start at 1
column = int(location - lastLineStart) + 1;
++line;
}
String Reader::getLocationLineAndColumn(Location location) const {
int line, column;
getLocationLineAndColumn(location, line, column);
char buffer[18 + 16 + 16 + 1];
jsoncpp_snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
return buffer;
}
// Deprecated. Preserved for backward compatibility
String Reader::getFormatedErrorMessages() const {
return getFormattedErrorMessages();
}
String Reader::getFormattedErrorMessages() const {
String formattedMessage;
for (const auto& error : errors_) {
formattedMessage +=
"* " + getLocationLineAndColumn(error.token_.start_) + "\n";
formattedMessage += " " + error.message_ + "\n";
if (error.extra_)
formattedMessage +=
"See " + getLocationLineAndColumn(error.extra_) + " for detail.\n";
}
return formattedMessage;
}
std::vector<Reader::StructuredError> Reader::getStructuredErrors() const {
std::vector<Reader::StructuredError> allErrors;
for (const auto& error : errors_) {
Reader::StructuredError structured;
structured.offset_start = error.token_.start_ - begin_;
structured.offset_limit = error.token_.end_ - begin_;
structured.message = error.message_;
allErrors.push_back(structured);
}
return allErrors;
}
bool Reader::pushError(const Value& value, const String& message) {
ptrdiff_t const length = end_ - begin_;
if (value.getOffsetStart() > length || value.getOffsetLimit() > length)
return false;
Token token;
token.type_ = tokenError;
token.start_ = begin_ + value.getOffsetStart();
token.end_ = begin_ + value.getOffsetLimit();
ErrorInfo info;
info.token_ = token;
info.message_ = message;
info.extra_ = nullptr;
errors_.push_back(info);
return true;
}
bool Reader::pushError(const Value& value, const String& message,
const Value& extra) {
ptrdiff_t const length = end_ - begin_;
if (value.getOffsetStart() > length || value.getOffsetLimit() > length ||
extra.getOffsetLimit() > length)
return false;
Token token;
token.type_ = tokenError;
token.start_ = begin_ + value.getOffsetStart();
token.end_ = begin_ + value.getOffsetLimit();
ErrorInfo info;
info.token_ = token;
info.message_ = message;
info.extra_ = begin_ + extra.getOffsetStart();
errors_.push_back(info);
return true;
}
bool Reader::good() const { return errors_.empty(); }
// Originally copied from the Features class (now deprecated), used internally
// for features implementation.
class OurFeatures {
public:
static OurFeatures all();
bool allowComments_;
bool allowTrailingCommas_;
bool strictRoot_;
bool allowDroppedNullPlaceholders_;
bool allowNumericKeys_;
bool allowSingleQuotes_;
bool failIfExtra_;
bool rejectDupKeys_;
bool allowSpecialFloats_;
bool skipBom_;
size_t stackLimit_;
}; // OurFeatures
OurFeatures OurFeatures::all() { return {}; }
// Implementation of class Reader
// ////////////////////////////////
// Originally copied from the Reader class (now deprecated), used internally
// for implementing JSON reading.
class OurReader {
public:
using Char = char;
using Location = const Char*;
struct StructuredError {
ptrdiff_t offset_start;
ptrdiff_t offset_limit;
String message;
};
explicit OurReader(OurFeatures const& features);
bool parse(const char* beginDoc, const char* endDoc, Value& root,
bool collectComments = true);
String getFormattedErrorMessages() const;
std::vector<StructuredError> getStructuredErrors() const;
private:
OurReader(OurReader const&); // no impl
void operator=(OurReader const&); // no impl
enum TokenType {
tokenEndOfStream = 0,
tokenObjectBegin,
tokenObjectEnd,
tokenArrayBegin,
tokenArrayEnd,
tokenString,
tokenNumber,
tokenTrue,
tokenFalse,
tokenNull,
tokenNaN,
tokenPosInf,
tokenNegInf,
tokenArraySeparator,
tokenMemberSeparator,
tokenComment,
tokenError
};
class Token {
public:
TokenType type_;
Location start_;
Location end_;
};
class ErrorInfo {
public:
Token token_;
String message_;
Location extra_;
};
using Errors = std::deque<ErrorInfo>;
bool readToken(Token& token);
void skipSpaces();
void skipBom(bool skipBom);
bool match(const Char* pattern, int patternLength);
bool readComment();
bool readCStyleComment(bool* containsNewLineResult);
bool readCppStyleComment();
bool readString();
bool readStringSingleQuote();
bool readNumber(bool checkInf);
bool readValue();
bool readObject(Token& token);
bool readArray(Token& token);
bool decodeNumber(Token& token);
bool decodeNumber(Token& token, Value& decoded);
bool decodeString(Token& token);
bool decodeString(Token& token, String& decoded);
bool decodeDouble(Token& token);
bool decodeDouble(Token& token, Value& decoded);
bool decodeUnicodeCodePoint(Token& token, Location& current, Location end,
unsigned int& unicode);
bool decodeUnicodeEscapeSequence(Token& token, Location& current,
Location end, unsigned int& unicode);
bool addError(const String& message, Token& token, Location extra = nullptr);
bool recoverFromError(TokenType skipUntilToken);
bool addErrorAndRecover(const String& message, Token& token,
TokenType skipUntilToken);
void skipUntilSpace();
Value& currentValue();
Char getNextChar();
void getLocationLineAndColumn(Location location, int& line,
int& column) const;
String getLocationLineAndColumn(Location location) const;
void addComment(Location begin, Location end, CommentPlacement placement);
void skipCommentTokens(Token& token);
static String normalizeEOL(Location begin, Location end);
static bool containsNewLine(Location begin, Location end);
using Nodes = std::stack<Value*>;
Nodes nodes_{};
Errors errors_{};
String document_{};
Location begin_ = nullptr;
Location end_ = nullptr;
Location current_ = nullptr;
Location lastValueEnd_ = nullptr;
Value* lastValue_ = nullptr;
bool lastValueHasAComment_ = false;
String commentsBefore_{};
OurFeatures const features_;
bool collectComments_ = false;
}; // OurReader
// complete copy of Read impl, for OurReader
bool OurReader::containsNewLine(OurReader::Location begin,
OurReader::Location end) {
return std::any_of(begin, end, [](char b) { return b == '\n' || b == '\r'; });
}
OurReader::OurReader(OurFeatures const& features) : features_(features) {}
bool OurReader::parse(const char* beginDoc, const char* endDoc, Value& root,
bool collectComments) {
if (!features_.allowComments_) {
collectComments = false;
}
begin_ = beginDoc;
end_ = endDoc;
collectComments_ = collectComments;
current_ = begin_;
lastValueEnd_ = nullptr;
lastValue_ = nullptr;
commentsBefore_.clear();
errors_.clear();
while (!nodes_.empty())
nodes_.pop();
nodes_.push(&root);
// skip byte order mark if it exists at the beginning of the UTF-8 text.
skipBom(features_.skipBom_);
bool successful = readValue();
nodes_.pop();
Token token;
skipCommentTokens(token);
if (features_.failIfExtra_ && (token.type_ != tokenEndOfStream)) {
addError("Extra non-whitespace after JSON value.", token);
return false;
}
if (collectComments_ && !commentsBefore_.empty())
root.setComment(commentsBefore_, commentAfter);
if (features_.strictRoot_) {
if (!root.isArray() && !root.isObject()) {
// Set error location to start of doc, ideally should be first token found
// in doc
token.type_ = tokenError;
token.start_ = beginDoc;
token.end_ = endDoc;
addError(
"A valid JSON document must be either an array or an object value.",
token);
return false;
}
}
return successful;
}
bool OurReader::readValue() {
// To preserve the old behaviour we cast size_t to int.
if (nodes_.size() > features_.stackLimit_)
throwRuntimeError("Exceeded stackLimit in readValue().");
Token token;
skipCommentTokens(token);
bool successful = true;
if (collectComments_ && !commentsBefore_.empty()) {
currentValue().setComment(commentsBefore_, commentBefore);
commentsBefore_.clear();
}
switch (token.type_) {
case tokenObjectBegin:
successful = readObject(token);
currentValue().setOffsetLimit(current_ - begin_);
break;
case tokenArrayBegin:
successful = readArray(token);
currentValue().setOffsetLimit(current_ - begin_);
break;
case tokenNumber:
successful = decodeNumber(token);
break;
case tokenString:
successful = decodeString(token);
break;
case tokenTrue: {
Value v(true);
currentValue().swapPayload(v);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
} break;
case tokenFalse: {
Value v(false);
currentValue().swapPayload(v);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
} break;
case tokenNull: {
Value v;
currentValue().swapPayload(v);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
} break;
case tokenNaN: {
Value v(std::numeric_limits<double>::quiet_NaN());
currentValue().swapPayload(v);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
} break;
case tokenPosInf: {
Value v(std::numeric_limits<double>::infinity());
currentValue().swapPayload(v);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
} break;
case tokenNegInf: {
Value v(-std::numeric_limits<double>::infinity());
currentValue().swapPayload(v);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
} break;
case tokenArraySeparator:
case tokenObjectEnd:
case tokenArrayEnd:
if (features_.allowDroppedNullPlaceholders_) {
// "Un-read" the current token and mark the current value as a null
// token.
current_--;
Value v;
currentValue().swapPayload(v);
currentValue().setOffsetStart(current_ - begin_ - 1);
currentValue().setOffsetLimit(current_ - begin_);
break;
} // else, fall through ...
default:
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return addError("Syntax error: value, object or array expected.", token);
}
if (collectComments_) {
lastValueEnd_ = current_;
lastValueHasAComment_ = false;
lastValue_ = ¤tValue();
}
return successful;
}
void OurReader::skipCommentTokens(Token& token) {
if (features_.allowComments_) {
do {
readToken(token);
} while (token.type_ == tokenComment);
} else {
readToken(token);
}
}
bool OurReader::readToken(Token& token) {
skipSpaces();
token.start_ = current_;
Char c = getNextChar();
bool ok = true;
switch (c) {
case '{':
token.type_ = tokenObjectBegin;
break;
case '}':
token.type_ = tokenObjectEnd;
break;
case '[':
token.type_ = tokenArrayBegin;
break;
case ']':
token.type_ = tokenArrayEnd;
break;
case '"':
token.type_ = tokenString;
ok = readString();
break;
case '\'':
if (features_.allowSingleQuotes_) {
token.type_ = tokenString;
ok = readStringSingleQuote();
} else {
// If we don't allow single quotes, this is a failure case.
ok = false;
}
break;
case '/':
token.type_ = tokenComment;
ok = readComment();
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
token.type_ = tokenNumber;
readNumber(false);
break;
case '-':
if (readNumber(true)) {
token.type_ = tokenNumber;
} else {
token.type_ = tokenNegInf;
ok = features_.allowSpecialFloats_ && match("nfinity", 7);
}
break;
case '+':
if (readNumber(true)) {
token.type_ = tokenNumber;
} else {
token.type_ = tokenPosInf;
ok = features_.allowSpecialFloats_ && match("nfinity", 7);
}
break;
case 't':
token.type_ = tokenTrue;
ok = match("rue", 3);
break;
case 'f':
token.type_ = tokenFalse;
ok = match("alse", 4);
break;
case 'n':
token.type_ = tokenNull;
ok = match("ull", 3);
break;
case 'N':
if (features_.allowSpecialFloats_) {
token.type_ = tokenNaN;
ok = match("aN", 2);
} else {
ok = false;
}
break;
case 'I':
if (features_.allowSpecialFloats_) {
token.type_ = tokenPosInf;
ok = match("nfinity", 7);
} else {
ok = false;
}
break;
case ',':
token.type_ = tokenArraySeparator;
break;
case ':':
token.type_ = tokenMemberSeparator;
break;
case 0:
token.type_ = tokenEndOfStream;
break;
default:
ok = false;
break;
}
if (!ok)
token.type_ = tokenError;
token.end_ = current_;
return ok;
}
void OurReader::skipSpaces() {
while (current_ != end_) {
Char c = *current_;
if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
++current_;
else
break;
}
}
void OurReader::skipBom(bool skipBom) {
// The default behavior is to skip BOM.
if (skipBom) {
if ((end_ - begin_) >= 3 && strncmp(begin_, "\xEF\xBB\xBF", 3) == 0) {
begin_ += 3;
current_ = begin_;
}
}
}
bool OurReader::match(const Char* pattern, int patternLength) {
if (end_ - current_ < patternLength)
return false;
int index = patternLength;
while (index--)
if (current_[index] != pattern[index])
return false;
current_ += patternLength;
return true;
}
bool OurReader::readComment() {
const Location commentBegin = current_ - 1;
const Char c = getNextChar();
bool successful = false;
bool cStyleWithEmbeddedNewline = false;
const bool isCStyleComment = (c == '*');
const bool isCppStyleComment = (c == '/');
if (isCStyleComment) {
successful = readCStyleComment(&cStyleWithEmbeddedNewline);
} else if (isCppStyleComment) {
successful = readCppStyleComment();
}
if (!successful)
return false;
if (collectComments_) {
CommentPlacement placement = commentBefore;
if (!lastValueHasAComment_) {
if (lastValueEnd_ && !containsNewLine(lastValueEnd_, commentBegin)) {
if (isCppStyleComment || !cStyleWithEmbeddedNewline) {
placement = commentAfterOnSameLine;
lastValueHasAComment_ = true;
}
}
}
addComment(commentBegin, current_, placement);
}
return true;
}
String OurReader::normalizeEOL(OurReader::Location begin,
OurReader::Location end) {
String normalized;
normalized.reserve(static_cast<size_t>(end - begin));
OurReader::Location current = begin;
while (current != end) {
char c = *current++;
if (c == '\r') {
if (current != end && *current == '\n')
// convert dos EOL
++current;
// convert Mac EOL
normalized += '\n';
} else {
normalized += c;
}
}
return normalized;
}
void OurReader::addComment(Location begin, Location end,
CommentPlacement placement) {
assert(collectComments_);
const String& normalized = normalizeEOL(begin, end);
if (placement == commentAfterOnSameLine) {
assert(lastValue_ != nullptr);
lastValue_->setComment(normalized, placement);
} else {
commentsBefore_ += normalized;
}
}
bool OurReader::readCStyleComment(bool* containsNewLineResult) {
*containsNewLineResult = false;
while ((current_ + 1) < end_) {
Char c = getNextChar();
if (c == '*' && *current_ == '/')
break;
if (c == '\n')
*containsNewLineResult = true;
}
return getNextChar() == '/';
}
bool OurReader::readCppStyleComment() {
while (current_ != end_) {
Char c = getNextChar();
if (c == '\n')
break;
if (c == '\r') {
// Consume DOS EOL. It will be normalized in addComment.
if (current_ != end_ && *current_ == '\n')
getNextChar();
// Break on Moc OS 9 EOL.
break;
}
}
return true;
}
bool OurReader::readNumber(bool checkInf) {
Location p = current_;
if (checkInf && p != end_ && *p == 'I') {
current_ = ++p;
return false;
}
char c = '0'; // stopgap for already consumed character
// integral part
while (c >= '0' && c <= '9')
c = (current_ = p) < end_ ? *p++ : '\0';
// fractional part
if (c == '.') {
c = (current_ = p) < end_ ? *p++ : '\0';
while (c >= '0' && c <= '9')
c = (current_ = p) < end_ ? *p++ : '\0';
}
// exponential part
if (c == 'e' || c == 'E') {
c = (current_ = p) < end_ ? *p++ : '\0';
if (c == '+' || c == '-')
c = (current_ = p) < end_ ? *p++ : '\0';
while (c >= '0' && c <= '9')
c = (current_ = p) < end_ ? *p++ : '\0';
}
return true;
}
bool OurReader::readString() {
Char c = 0;
while (current_ != end_) {
c = getNextChar();
if (c == '\\')
getNextChar();
else if (c == '"')
break;
}
return c == '"';
}
bool OurReader::readStringSingleQuote() {
Char c = 0;
while (current_ != end_) {
c = getNextChar();
if (c == '\\')
getNextChar();
else if (c == '\'')
break;
}
return c == '\'';
}
bool OurReader::readObject(Token& token) {
Token tokenName;
String name;
Value init(objectValue);
currentValue().swapPayload(init);
currentValue().setOffsetStart(token.start_ - begin_);
while (readToken(tokenName)) {
bool initialTokenOk = true;
while (tokenName.type_ == tokenComment && initialTokenOk)
initialTokenOk = readToken(tokenName);
if (!initialTokenOk)
break;
if (tokenName.type_ == tokenObjectEnd &&
(name.empty() ||
features_.allowTrailingCommas_)) // empty object or trailing comma
return true;
name.clear();
if (tokenName.type_ == tokenString) {
if (!decodeString(tokenName, name))
return recoverFromError(tokenObjectEnd);
} else if (tokenName.type_ == tokenNumber && features_.allowNumericKeys_) {
Value numberName;
if (!decodeNumber(tokenName, numberName))
return recoverFromError(tokenObjectEnd);
name = numberName.asString();
} else {
break;
}
if (name.length() >= (1U << 30))
throwRuntimeError("keylength >= 2^30");
if (features_.rejectDupKeys_ && currentValue().isMember(name)) {
String msg = "Duplicate key: '" + name + "'";
return addErrorAndRecover(msg, tokenName, tokenObjectEnd);
}
Token colon;
if (!readToken(colon) || colon.type_ != tokenMemberSeparator) {
return addErrorAndRecover("Missing ':' after object member name", colon,
tokenObjectEnd);
}
Value& value = currentValue()[name];
nodes_.push(&value);
bool ok = readValue();
nodes_.pop();
if (!ok) // error already set
return recoverFromError(tokenObjectEnd);
Token comma;
if (!readToken(comma) ||
(comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator &&
comma.type_ != tokenComment)) {
return addErrorAndRecover("Missing ',' or '}' in object declaration",
comma, tokenObjectEnd);
}
bool finalizeTokenOk = true;
while (comma.type_ == tokenComment && finalizeTokenOk)
finalizeTokenOk = readToken(comma);
if (comma.type_ == tokenObjectEnd)
return true;
}
return addErrorAndRecover("Missing '}' or object member name", tokenName,
tokenObjectEnd);
}
bool OurReader::readArray(Token& token) {
Value init(arrayValue);
currentValue().swapPayload(init);
currentValue().setOffsetStart(token.start_ - begin_);
int index = 0;
for (;;) {
skipSpaces();
if (current_ != end_ && *current_ == ']' &&
(index == 0 ||
(features_.allowTrailingCommas_ &&
!features_.allowDroppedNullPlaceholders_))) // empty array or trailing
// comma
{
Token endArray;
readToken(endArray);
return true;
}
Value& value = currentValue()[index++];
nodes_.push(&value);
bool ok = readValue();
nodes_.pop();
if (!ok) // error already set
return recoverFromError(tokenArrayEnd);
Token currentToken;
// Accept Comment after last item in the array.
ok = readToken(currentToken);
while (currentToken.type_ == tokenComment && ok) {
ok = readToken(currentToken);
}
bool badTokenType = (currentToken.type_ != tokenArraySeparator &&
currentToken.type_ != tokenArrayEnd);
if (!ok || badTokenType) {
return addErrorAndRecover("Missing ',' or ']' in array declaration",
currentToken, tokenArrayEnd);
}
if (currentToken.type_ == tokenArrayEnd)
break;
}
return true;
}
bool OurReader::decodeNumber(Token& token) {
Value decoded;
if (!decodeNumber(token, decoded))
return false;
currentValue().swapPayload(decoded);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return true;
}
bool OurReader::decodeNumber(Token& token, Value& decoded) {
// Attempts to parse the number as an integer. If the number is
// larger than the maximum supported value of an integer then
// we decode the number as a double.
Location current = token.start_;
const bool isNegative = *current == '-';
if (isNegative) {
++current;
}
// We assume we can represent the largest and smallest integer types as
// unsigned integers with separate sign. This is only true if they can fit
// into an unsigned integer.
static_assert(Value::maxLargestInt <= Value::maxLargestUInt,
"Int must be smaller than UInt");
// We need to convert minLargestInt into a positive number. The easiest way
// to do this conversion is to assume our "threshold" value of minLargestInt
// divided by 10 can fit in maxLargestInt when absolute valued. This should
// be a safe assumption.
static_assert(Value::minLargestInt <= -Value::maxLargestInt,
"The absolute value of minLargestInt must be greater than or "
"equal to maxLargestInt");
static_assert(Value::minLargestInt / 10 >= -Value::maxLargestInt,
"The absolute value of minLargestInt must be only 1 magnitude "
"larger than maxLargest Int");
static constexpr Value::LargestUInt positive_threshold =
Value::maxLargestUInt / 10;
static constexpr Value::UInt positive_last_digit = Value::maxLargestUInt % 10;
// For the negative values, we have to be more careful. Since typically
// -Value::minLargestInt will cause an overflow, we first divide by 10 and
// then take the inverse. This assumes that minLargestInt is only a single
// power of 10 different in magnitude, which we check above. For the last
// digit, we take the modulus before negating for the same reason.
static constexpr auto negative_threshold =
Value::LargestUInt(-(Value::minLargestInt / 10));
static constexpr auto negative_last_digit =
Value::UInt(-(Value::minLargestInt % 10));
const Value::LargestUInt threshold =
isNegative ? negative_threshold : positive_threshold;
const Value::UInt max_last_digit =
isNegative ? negative_last_digit : positive_last_digit;
Value::LargestUInt value = 0;
while (current < token.end_) {
Char c = *current++;
if (c < '0' || c > '9')
return decodeDouble(token, decoded);
const auto digit(static_cast<Value::UInt>(c - '0'));
if (value >= threshold) {
// We've hit or exceeded the max value divided by 10 (rounded down). If
// a) we've only just touched the limit, meaing value == threshold,
// b) this is the last digit, or
// c) it's small enough to fit in that rounding delta, we're okay.
// Otherwise treat this number as a double to avoid overflow.
if (value > threshold || current != token.end_ ||
digit > max_last_digit) {
return decodeDouble(token, decoded);
}
}
value = value * 10 + digit;
}
if (isNegative) {
// We use the same magnitude assumption here, just in case.
const auto last_digit = static_cast<Value::UInt>(value % 10);
decoded = -Value::LargestInt(value / 10) * 10 - last_digit;
} else if (value <= Value::LargestUInt(Value::maxLargestInt)) {
decoded = Value::LargestInt(value);
} else {
decoded = value;
}
return true;
}
bool OurReader::decodeDouble(Token& token) {
Value decoded;
if (!decodeDouble(token, decoded))
return false;
currentValue().swapPayload(decoded);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return true;
}
bool OurReader::decodeDouble(Token& token, Value& decoded) {
double value = 0;
const String buffer(token.start_, token.end_);
IStringStream is(buffer);
if (!(is >> value)) {
return addError(
"'" + String(token.start_, token.end_) + "' is not a number.", token);
}
decoded = value;
return true;
}
bool OurReader::decodeString(Token& token) {
String decoded_string;
if (!decodeString(token, decoded_string))
return false;
Value decoded(decoded_string);
currentValue().swapPayload(decoded);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return true;
}
bool OurReader::decodeString(Token& token, String& decoded) {
decoded.reserve(static_cast<size_t>(token.end_ - token.start_ - 2));
Location current = token.start_ + 1; // skip '"'
Location end = token.end_ - 1; // do not include '"'
while (current != end) {
Char c = *current++;
if (c == '"')
break;
if (c == '\\') {
if (current == end)
return addError("Empty escape sequence in string", token, current);
Char escape = *current++;
switch (escape) {
case '"':
decoded += '"';
break;
case '/':
decoded += '/';
break;
case '\\':
decoded += '\\';
break;
case 'b':
decoded += '\b';
break;
case 'f':
decoded += '\f';
break;
case 'n':
decoded += '\n';
break;
case 'r':
decoded += '\r';
break;
case 't':
decoded += '\t';
break;
case 'u': {
unsigned int unicode;
if (!decodeUnicodeCodePoint(token, current, end, unicode))
return false;
decoded += codePointToUTF8(unicode);
} break;
default:
return addError("Bad escape sequence in string", token, current);
}
} else {
decoded += c;
}
}
return true;
}
bool OurReader::decodeUnicodeCodePoint(Token& token, Location& current,
Location end, unsigned int& unicode) {
if (!decodeUnicodeEscapeSequence(token, current, end, unicode))
return false;
if (unicode >= 0xD800 && unicode <= 0xDBFF) {
// surrogate pairs
if (end - current < 6)
return addError(
"additional six characters expected to parse unicode surrogate pair.",
token, current);
if (*(current++) == '\\' && *(current++) == 'u') {
unsigned int surrogatePair;
if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) {
unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
} else
return false;
} else
return addError("expecting another \\u token to begin the second half of "
"a unicode surrogate pair",
token, current);
}
return true;
}
bool OurReader::decodeUnicodeEscapeSequence(Token& token, Location& current,
Location end,
unsigned int& ret_unicode) {
if (end - current < 4)
return addError(
"Bad unicode escape sequence in string: four digits expected.", token,
current);
int unicode = 0;
for (int index = 0; index < 4; ++index) {
Char c = *current++;
unicode *= 16;
if (c >= '0' && c <= '9')
unicode += c - '0';
else if (c >= 'a' && c <= 'f')
unicode += c - 'a' + 10;
else if (c >= 'A' && c <= 'F')
unicode += c - 'A' + 10;
else
return addError(
"Bad unicode escape sequence in string: hexadecimal digit expected.",
token, current);
}
ret_unicode = static_cast<unsigned int>(unicode);
return true;
}
bool OurReader::addError(const String& message, Token& token, Location extra) {
ErrorInfo info;
info.token_ = token;
info.message_ = message;
info.extra_ = extra;
errors_.push_back(info);
return false;
}
bool OurReader::recoverFromError(TokenType skipUntilToken) {
size_t errorCount = errors_.size();
Token skip;
for (;;) {
if (!readToken(skip))
errors_.resize(errorCount); // discard errors caused by recovery
if (skip.type_ == skipUntilToken || skip.type_ == tokenEndOfStream)
break;
}
errors_.resize(errorCount);
return false;
}
bool OurReader::addErrorAndRecover(const String& message, Token& token,
TokenType skipUntilToken) {
addError(message, token);
return recoverFromError(skipUntilToken);
}
Value& OurReader::currentValue() { return *(nodes_.top()); }
OurReader::Char OurReader::getNextChar() {
if (current_ == end_)
return 0;
return *current_++;
}
void OurReader::getLocationLineAndColumn(Location location, int& line,
int& column) const {
Location current = begin_;
Location lastLineStart = current;
line = 0;
while (current < location && current != end_) {
Char c = *current++;
if (c == '\r') {
if (*current == '\n')
++current;
lastLineStart = current;
++line;
} else if (c == '\n') {
lastLineStart = current;
++line;
}
}
// column & line start at 1
column = int(location - lastLineStart) + 1;
++line;
}
String OurReader::getLocationLineAndColumn(Location location) const {
int line, column;
getLocationLineAndColumn(location, line, column);
char buffer[18 + 16 + 16 + 1];
jsoncpp_snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
return buffer;
}
String OurReader::getFormattedErrorMessages() const {
String formattedMessage;
for (const auto& error : errors_) {
formattedMessage +=
"* " + getLocationLineAndColumn(error.token_.start_) + "\n";
formattedMessage += " " + error.message_ + "\n";
if (error.extra_)
formattedMessage +=
"See " + getLocationLineAndColumn(error.extra_) + " for detail.\n";
}
return formattedMessage;
}
std::vector<OurReader::StructuredError> OurReader::getStructuredErrors() const {
std::vector<OurReader::StructuredError> allErrors;
for (const auto& error : errors_) {
OurReader::StructuredError structured;
structured.offset_start = error.token_.start_ - begin_;
structured.offset_limit = error.token_.end_ - begin_;
structured.message = error.message_;
allErrors.push_back(structured);
}
return allErrors;
}
class OurCharReader : public CharReader {
bool const collectComments_;
OurReader reader_;
public:
OurCharReader(bool collectComments, OurFeatures const& features)
: collectComments_(collectComments), reader_(features) {}
bool parse(char const* beginDoc, char const* endDoc, Value* root,
String* errs) override {
bool ok = reader_.parse(beginDoc, endDoc, *root, collectComments_);
if (errs) {
*errs = reader_.getFormattedErrorMessages();
}
return ok;
}
};
CharReaderBuilder::CharReaderBuilder() { setDefaults(&settings_); }
CharReaderBuilder::~CharReaderBuilder() = default;
CharReader* CharReaderBuilder::newCharReader() const {
bool collectComments = settings_["collectComments"].asBool();
OurFeatures features = OurFeatures::all();
features.allowComments_ = settings_["allowComments"].asBool();
features.allowTrailingCommas_ = settings_["allowTrailingCommas"].asBool();
features.strictRoot_ = settings_["strictRoot"].asBool();
features.allowDroppedNullPlaceholders_ =
settings_["allowDroppedNullPlaceholders"].asBool();
features.allowNumericKeys_ = settings_["allowNumericKeys"].asBool();
features.allowSingleQuotes_ = settings_["allowSingleQuotes"].asBool();
// Stack limit is always a size_t, so we get this as an unsigned int
// regardless of it we have 64-bit integer support enabled.
features.stackLimit_ = static_cast<size_t>(settings_["stackLimit"].asUInt());
features.failIfExtra_ = settings_["failIfExtra"].asBool();
features.rejectDupKeys_ = settings_["rejectDupKeys"].asBool();
features.allowSpecialFloats_ = settings_["allowSpecialFloats"].asBool();
features.skipBom_ = settings_["skipBom"].asBool();
return new OurCharReader(collectComments, features);
}
bool CharReaderBuilder::validate(Json::Value* invalid) const {
static const auto& valid_keys = *new std::set<String>{
"collectComments",
"allowComments",
"allowTrailingCommas",
"strictRoot",
"allowDroppedNullPlaceholders",
"allowNumericKeys",
"allowSingleQuotes",
"stackLimit",
"failIfExtra",
"rejectDupKeys",
"allowSpecialFloats",
"skipBom",
};
for (auto si = settings_.begin(); si != settings_.end(); ++si) {
auto key = si.name();
if (valid_keys.count(key))
continue;
if (invalid)
(*invalid)[key] = *si;
else
return false;
}
return invalid ? invalid->empty() : true;
}
Value& CharReaderBuilder::operator[](const String& key) {
return settings_[key];
}
// static
void CharReaderBuilder::strictMode(Json::Value* settings) {
//! [CharReaderBuilderStrictMode]
(*settings)["allowComments"] = false;
(*settings)["allowTrailingCommas"] = false;
(*settings)["strictRoot"] = true;
(*settings)["allowDroppedNullPlaceholders"] = false;
(*settings)["allowNumericKeys"] = false;
(*settings)["allowSingleQuotes"] = false;
(*settings)["stackLimit"] = 1000;
(*settings)["failIfExtra"] = true;
(*settings)["rejectDupKeys"] = true;
(*settings)["allowSpecialFloats"] = false;
(*settings)["skipBom"] = true;
//! [CharReaderBuilderStrictMode]
}
// static
void CharReaderBuilder::setDefaults(Json::Value* settings) {
//! [CharReaderBuilderDefaults]
(*settings)["collectComments"] = true;
(*settings)["allowComments"] = true;
(*settings)["allowTrailingCommas"] = true;
(*settings)["strictRoot"] = false;
(*settings)["allowDroppedNullPlaceholders"] = false;
(*settings)["allowNumericKeys"] = false;
(*settings)["allowSingleQuotes"] = false;
(*settings)["stackLimit"] = 1000;
(*settings)["failIfExtra"] = false;
(*settings)["rejectDupKeys"] = false;
(*settings)["allowSpecialFloats"] = false;
(*settings)["skipBom"] = true;
//! [CharReaderBuilderDefaults]
}
//////////////////////////////////
// global functions
bool parseFromStream(CharReader::Factory const& fact, IStream& sin, Value* root,
String* errs) {
OStringStream ssin;
ssin << sin.rdbuf();
String doc = ssin.str();
char const* begin = doc.data();
char const* end = begin + doc.size();
// Note that we do not actually need a null-terminator.
CharReaderPtr const reader(fact.newCharReader());
return reader->parse(begin, end, root, errs);
}
IStream& operator>>(IStream& sin, Value& root) {
CharReaderBuilder b;
String errs;
bool ok = parseFromStream(b, sin, &root, &errs);
if (!ok) {
throwRuntimeError(errs);
}
return sin;
}
} // namespace Json
| YifuLiu/AliOS-Things | components/jsoncpp/src/lib_json/json_reader.cpp | C++ | apache-2.0 | 58,050 |
// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#ifndef LIB_JSONCPP_JSON_TOOL_H_INCLUDED
#define LIB_JSONCPP_JSON_TOOL_H_INCLUDED
#if !defined(JSON_IS_AMALGAMATION)
#include <json/config.h>
#endif
// Also support old flag NO_LOCALE_SUPPORT
#ifdef NO_LOCALE_SUPPORT
#define JSONCPP_NO_LOCALE_SUPPORT
#endif
#ifndef JSONCPP_NO_LOCALE_SUPPORT
#include <clocale>
#endif
/* This header provides common string manipulation support, such as UTF-8,
* portable conversion from/to string...
*
* It is an internal header that must not be exposed.
*/
namespace Json {
static inline char getDecimalPoint() {
#ifdef JSONCPP_NO_LOCALE_SUPPORT
return '\0';
#else
struct lconv* lc = localeconv();
return lc ? *(lc->decimal_point) : '\0';
#endif
}
/// Converts a unicode code-point to UTF-8.
static inline String codePointToUTF8(unsigned int cp) {
String result;
// based on description from http://en.wikipedia.org/wiki/UTF-8
if (cp <= 0x7f) {
result.resize(1);
result[0] = static_cast<char>(cp);
} else if (cp <= 0x7FF) {
result.resize(2);
result[1] = static_cast<char>(0x80 | (0x3f & cp));
result[0] = static_cast<char>(0xC0 | (0x1f & (cp >> 6)));
} else if (cp <= 0xFFFF) {
result.resize(3);
result[2] = static_cast<char>(0x80 | (0x3f & cp));
result[1] = static_cast<char>(0x80 | (0x3f & (cp >> 6)));
result[0] = static_cast<char>(0xE0 | (0xf & (cp >> 12)));
} else if (cp <= 0x10FFFF) {
result.resize(4);
result[3] = static_cast<char>(0x80 | (0x3f & cp));
result[2] = static_cast<char>(0x80 | (0x3f & (cp >> 6)));
result[1] = static_cast<char>(0x80 | (0x3f & (cp >> 12)));
result[0] = static_cast<char>(0xF0 | (0x7 & (cp >> 18)));
}
return result;
}
enum {
/// Constant that specify the size of the buffer that must be passed to
/// uintToString.
uintToStringBufferSize = 3 * sizeof(LargestUInt) + 1
};
// Defines a char buffer for use with uintToString().
using UIntToStringBuffer = char[uintToStringBufferSize];
/** Converts an unsigned integer to string.
* @param value Unsigned integer to convert to string
* @param current Input/Output string buffer.
* Must have at least uintToStringBufferSize chars free.
*/
static inline void uintToString(LargestUInt value, char*& current) {
*--current = 0;
do {
*--current = static_cast<char>(value % 10U + static_cast<unsigned>('0'));
value /= 10;
} while (value != 0);
}
/** Change ',' to '.' everywhere in buffer.
*
* We had a sophisticated way, but it did not work in WinCE.
* @see https://github.com/open-source-parsers/jsoncpp/pull/9
*/
template <typename Iter> Iter fixNumericLocale(Iter begin, Iter end) {
for (; begin != end; ++begin) {
if (*begin == ',') {
*begin = '.';
}
}
return begin;
}
template <typename Iter> void fixNumericLocaleInput(Iter begin, Iter end) {
char decimalPoint = getDecimalPoint();
if (decimalPoint == '\0' || decimalPoint == '.') {
return;
}
for (; begin != end; ++begin) {
if (*begin == '.') {
*begin = decimalPoint;
}
}
}
/**
* Return iterator that would be the new end of the range [begin,end), if we
* were to delete zeros in the end of string, but not the last zero before '.'.
*/
template <typename Iter>
Iter fixZerosInTheEnd(Iter begin, Iter end, unsigned int precision) {
for (; begin != end; --end) {
if (*(end - 1) != '0') {
return end;
}
// Don't delete the last zero before the decimal point.
if (begin != (end - 1) && begin != (end - 2) && *(end - 2) == '.') {
if (precision) {
return end;
}
return end - 2;
}
}
return end;
}
} // namespace Json
#endif // LIB_JSONCPP_JSON_TOOL_H_INCLUDED
| YifuLiu/AliOS-Things | components/jsoncpp/src/lib_json/json_tool.h | C++ | apache-2.0 | 3,913 |
// Copyright 2011 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#if !defined(JSON_IS_AMALGAMATION)
#include <json/assertions.h>
#include <json/value.h>
#include <json/writer.h>
#endif // if !defined(JSON_IS_AMALGAMATION)
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstddef>
#include <cstring>
#include <iostream>
#include <sstream>
#include <utility>
// Provide implementation equivalent of std::snprintf for older _MSC compilers
#if defined(_MSC_VER) && _MSC_VER < 1900
#include <stdarg.h>
static int msvc_pre1900_c99_vsnprintf(char* outBuf, size_t size,
const char* format, va_list ap) {
int count = -1;
if (size != 0)
count = _vsnprintf_s(outBuf, size, _TRUNCATE, format, ap);
if (count == -1)
count = _vscprintf(format, ap);
return count;
}
int JSON_API msvc_pre1900_c99_snprintf(char* outBuf, size_t size,
const char* format, ...) {
va_list ap;
va_start(ap, format);
const int count = msvc_pre1900_c99_vsnprintf(outBuf, size, format, ap);
va_end(ap);
return count;
}
#endif
// Disable warning C4702 : unreachable code
#if defined(_MSC_VER)
#pragma warning(disable : 4702)
#endif
#define JSON_ASSERT_UNREACHABLE assert(false)
namespace Json {
template <typename T>
static std::unique_ptr<T> cloneUnique(const std::unique_ptr<T>& p) {
std::unique_ptr<T> r;
if (p) {
r = std::unique_ptr<T>(new T(*p));
}
return r;
}
// This is a walkaround to avoid the static initialization of Value::null.
// kNull must be word-aligned to avoid crashing on ARM. We use an alignment of
// 8 (instead of 4) as a bit of future-proofing.
#if defined(__ARMEL__)
#define ALIGNAS(byte_alignment) __attribute__((aligned(byte_alignment)))
#else
#define ALIGNAS(byte_alignment)
#endif
// static
Value const& Value::nullSingleton() {
static Value const nullStatic;
return nullStatic;
}
#if JSON_USE_NULLREF
// for backwards compatibility, we'll leave these global references around, but
// DO NOT use them in JSONCPP library code any more!
// static
Value const& Value::null = Value::nullSingleton();
// static
Value const& Value::nullRef = Value::nullSingleton();
#endif
#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
template <typename T, typename U>
static inline bool InRange(double d, T min, U max) {
// The casts can lose precision, but we are looking only for
// an approximate range. Might fail on edge cases though. ~cdunn
return d >= static_cast<double>(min) && d <= static_cast<double>(max);
}
#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
static inline double integerToDouble(Json::UInt64 value) {
return static_cast<double>(Int64(value / 2)) * 2.0 +
static_cast<double>(Int64(value & 1));
}
template <typename T> static inline double integerToDouble(T value) {
return static_cast<double>(value);
}
template <typename T, typename U>
static inline bool InRange(double d, T min, U max) {
return d >= integerToDouble(min) && d <= integerToDouble(max);
}
#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
/** Duplicates the specified string value.
* @param value Pointer to the string to duplicate. Must be zero-terminated if
* length is "unknown".
* @param length Length of the value. if equals to unknown, then it will be
* computed using strlen(value).
* @return Pointer on the duplicate instance of string.
*/
static inline char* duplicateStringValue(const char* value, size_t length) {
// Avoid an integer overflow in the call to malloc below by limiting length
// to a sane value.
if (length >= static_cast<size_t>(Value::maxInt))
length = Value::maxInt - 1;
auto newString = static_cast<char*>(malloc(length + 1));
if (newString == nullptr) {
throwRuntimeError("in Json::Value::duplicateStringValue(): "
"Failed to allocate string value buffer");
}
memcpy(newString, value, length);
newString[length] = 0;
return newString;
}
/* Record the length as a prefix.
*/
static inline char* duplicateAndPrefixStringValue(const char* value,
unsigned int length) {
// Avoid an integer overflow in the call to malloc below by limiting length
// to a sane value.
JSON_ASSERT_MESSAGE(length <= static_cast<unsigned>(Value::maxInt) -
sizeof(unsigned) - 1U,
"in Json::Value::duplicateAndPrefixStringValue(): "
"length too big for prefixing");
size_t actualLength = sizeof(length) + length + 1;
auto newString = static_cast<char*>(malloc(actualLength));
if (newString == nullptr) {
throwRuntimeError("in Json::Value::duplicateAndPrefixStringValue(): "
"Failed to allocate string value buffer");
}
*reinterpret_cast<unsigned*>(newString) = length;
memcpy(newString + sizeof(unsigned), value, length);
newString[actualLength - 1U] =
0; // to avoid buffer over-run accidents by users later
return newString;
}
inline static void decodePrefixedString(bool isPrefixed, char const* prefixed,
unsigned* length, char const** value) {
if (!isPrefixed) {
*length = static_cast<unsigned>(strlen(prefixed));
*value = prefixed;
} else {
*length = *reinterpret_cast<unsigned const*>(prefixed);
*value = prefixed + sizeof(unsigned);
}
}
/** Free the string duplicated by
* duplicateStringValue()/duplicateAndPrefixStringValue().
*/
#if JSONCPP_USING_SECURE_MEMORY
static inline void releasePrefixedStringValue(char* value) {
unsigned length = 0;
char const* valueDecoded;
decodePrefixedString(true, value, &length, &valueDecoded);
size_t const size = sizeof(unsigned) + length + 1U;
memset(value, 0, size);
free(value);
}
static inline void releaseStringValue(char* value, unsigned length) {
// length==0 => we allocated the strings memory
size_t size = (length == 0) ? strlen(value) : length;
memset(value, 0, size);
free(value);
}
#else // !JSONCPP_USING_SECURE_MEMORY
static inline void releasePrefixedStringValue(char* value) { free(value); }
static inline void releaseStringValue(char* value, unsigned) { free(value); }
#endif // JSONCPP_USING_SECURE_MEMORY
} // namespace Json
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// ValueInternals...
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
#if !defined(JSON_IS_AMALGAMATION)
// #include "json_valueiterator.inl"
#include "json_valueiterator.h"
#endif // if !defined(JSON_IS_AMALGAMATION)
namespace Json {
#if JSON_USE_EXCEPTION
Exception::Exception(String msg) : msg_(std::move(msg)) {}
Exception::~Exception() noexcept = default;
char const* Exception::what() const noexcept { return msg_.c_str(); }
RuntimeError::RuntimeError(String const& msg) : Exception(msg) {}
LogicError::LogicError(String const& msg) : Exception(msg) {}
JSONCPP_NORETURN void throwRuntimeError(String const& msg) {
throw RuntimeError(msg);
}
JSONCPP_NORETURN void throwLogicError(String const& msg) {
throw LogicError(msg);
}
#else // !JSON_USE_EXCEPTION
JSONCPP_NORETURN void throwRuntimeError(String const& msg) {
std::cerr << msg << std::endl;
abort();
}
JSONCPP_NORETURN void throwLogicError(String const& msg) {
std::cerr << msg << std::endl;
abort();
}
#endif
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// class Value::CZString
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// Notes: policy_ indicates if the string was allocated when
// a string is stored.
Value::CZString::CZString(ArrayIndex index) : cstr_(nullptr), index_(index) {}
Value::CZString::CZString(char const* str, unsigned length,
DuplicationPolicy allocate)
: cstr_(str) {
// allocate != duplicate
storage_.policy_ = allocate & 0x3;
storage_.length_ = length & 0x3FFFFFFF;
}
Value::CZString::CZString(const CZString& other) {
cstr_ = (other.storage_.policy_ != noDuplication && other.cstr_ != nullptr
? duplicateStringValue(other.cstr_, other.storage_.length_)
: other.cstr_);
storage_.policy_ =
static_cast<unsigned>(
other.cstr_
? (static_cast<DuplicationPolicy>(other.storage_.policy_) ==
noDuplication
? noDuplication
: duplicate)
: static_cast<DuplicationPolicy>(other.storage_.policy_)) &
3U;
storage_.length_ = other.storage_.length_;
}
Value::CZString::CZString(CZString&& other) noexcept
: cstr_(other.cstr_), index_(other.index_) {
other.cstr_ = nullptr;
}
Value::CZString::~CZString() {
if (cstr_ && storage_.policy_ == duplicate) {
releaseStringValue(const_cast<char*>(cstr_),
storage_.length_ + 1U); // +1 for null terminating
// character for sake of
// completeness but not actually
// necessary
}
}
void Value::CZString::swap(CZString& other) {
std::swap(cstr_, other.cstr_);
std::swap(index_, other.index_);
}
Value::CZString& Value::CZString::operator=(const CZString& other) {
cstr_ = other.cstr_;
index_ = other.index_;
return *this;
}
Value::CZString& Value::CZString::operator=(CZString&& other) noexcept {
cstr_ = other.cstr_;
index_ = other.index_;
other.cstr_ = nullptr;
return *this;
}
bool Value::CZString::operator<(const CZString& other) const {
if (!cstr_)
return index_ < other.index_;
// return strcmp(cstr_, other.cstr_) < 0;
// Assume both are strings.
unsigned this_len = this->storage_.length_;
unsigned other_len = other.storage_.length_;
unsigned min_len = std::min<unsigned>(this_len, other_len);
JSON_ASSERT(this->cstr_ && other.cstr_);
int comp = memcmp(this->cstr_, other.cstr_, min_len);
if (comp < 0)
return true;
if (comp > 0)
return false;
return (this_len < other_len);
}
bool Value::CZString::operator==(const CZString& other) const {
if (!cstr_)
return index_ == other.index_;
// return strcmp(cstr_, other.cstr_) == 0;
// Assume both are strings.
unsigned this_len = this->storage_.length_;
unsigned other_len = other.storage_.length_;
if (this_len != other_len)
return false;
JSON_ASSERT(this->cstr_ && other.cstr_);
int comp = memcmp(this->cstr_, other.cstr_, this_len);
return comp == 0;
}
ArrayIndex Value::CZString::index() const { return index_; }
// const char* Value::CZString::c_str() const { return cstr_; }
const char* Value::CZString::data() const { return cstr_; }
unsigned Value::CZString::length() const { return storage_.length_; }
bool Value::CZString::isStaticString() const {
return storage_.policy_ == noDuplication;
}
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// class Value::Value
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
/*! \internal Default constructor initialization must be equivalent to:
* memset( this, 0, sizeof(Value) )
* This optimization is used in ValueInternalMap fast allocator.
*/
Value::Value(ValueType type) {
static char const emptyString[] = "";
initBasic(type);
switch (type) {
case nullValue:
break;
case intValue:
case uintValue:
value_.int_ = 0;
break;
case realValue:
value_.real_ = 0.0;
break;
case stringValue:
// allocated_ == false, so this is safe.
value_.string_ = const_cast<char*>(static_cast<char const*>(emptyString));
break;
case arrayValue:
case objectValue:
value_.map_ = new ObjectValues();
break;
case booleanValue:
value_.bool_ = false;
break;
default:
JSON_ASSERT_UNREACHABLE;
}
}
Value::Value(Int value) {
initBasic(intValue);
value_.int_ = value;
}
Value::Value(UInt value) {
initBasic(uintValue);
value_.uint_ = value;
}
#if defined(JSON_HAS_INT64)
Value::Value(Int64 value) {
initBasic(intValue);
value_.int_ = value;
}
Value::Value(UInt64 value) {
initBasic(uintValue);
value_.uint_ = value;
}
#endif // defined(JSON_HAS_INT64)
Value::Value(double value) {
initBasic(realValue);
value_.real_ = value;
}
Value::Value(const char* value) {
initBasic(stringValue, true);
JSON_ASSERT_MESSAGE(value != nullptr,
"Null Value Passed to Value Constructor");
value_.string_ = duplicateAndPrefixStringValue(
value, static_cast<unsigned>(strlen(value)));
}
Value::Value(const char* begin, const char* end) {
initBasic(stringValue, true);
value_.string_ =
duplicateAndPrefixStringValue(begin, static_cast<unsigned>(end - begin));
}
Value::Value(const String& value) {
initBasic(stringValue, true);
value_.string_ = duplicateAndPrefixStringValue(
value.data(), static_cast<unsigned>(value.length()));
}
Value::Value(const StaticString& value) {
initBasic(stringValue);
value_.string_ = const_cast<char*>(value.c_str());
}
Value::Value(bool value) {
initBasic(booleanValue);
value_.bool_ = value;
}
Value::Value(const Value& other) {
dupPayload(other);
dupMeta(other);
}
Value::Value(Value&& other) noexcept {
initBasic(nullValue);
swap(other);
}
Value::~Value() {
releasePayload();
value_.uint_ = 0;
}
Value& Value::operator=(const Value& other) {
Value(other).swap(*this);
return *this;
}
Value& Value::operator=(Value&& other) noexcept {
other.swap(*this);
return *this;
}
void Value::swapPayload(Value& other) {
std::swap(bits_, other.bits_);
std::swap(value_, other.value_);
}
void Value::copyPayload(const Value& other) {
releasePayload();
dupPayload(other);
}
void Value::swap(Value& other) {
swapPayload(other);
std::swap(comments_, other.comments_);
std::swap(start_, other.start_);
std::swap(limit_, other.limit_);
}
void Value::copy(const Value& other) {
copyPayload(other);
dupMeta(other);
}
ValueType Value::type() const {
return static_cast<ValueType>(bits_.value_type_);
}
int Value::compare(const Value& other) const {
if (*this < other)
return -1;
if (*this > other)
return 1;
return 0;
}
bool Value::operator<(const Value& other) const {
int typeDelta = type() - other.type();
if (typeDelta)
return typeDelta < 0;
switch (type()) {
case nullValue:
return false;
case intValue:
return value_.int_ < other.value_.int_;
case uintValue:
return value_.uint_ < other.value_.uint_;
case realValue:
return value_.real_ < other.value_.real_;
case booleanValue:
return value_.bool_ < other.value_.bool_;
case stringValue: {
if ((value_.string_ == nullptr) || (other.value_.string_ == nullptr)) {
return other.value_.string_ != nullptr;
}
unsigned this_len;
unsigned other_len;
char const* this_str;
char const* other_str;
decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len,
&this_str);
decodePrefixedString(other.isAllocated(), other.value_.string_, &other_len,
&other_str);
unsigned min_len = std::min<unsigned>(this_len, other_len);
JSON_ASSERT(this_str && other_str);
int comp = memcmp(this_str, other_str, min_len);
if (comp < 0)
return true;
if (comp > 0)
return false;
return (this_len < other_len);
}
case arrayValue:
case objectValue: {
auto thisSize = value_.map_->size();
auto otherSize = other.value_.map_->size();
if (thisSize != otherSize)
return thisSize < otherSize;
return (*value_.map_) < (*other.value_.map_);
}
default:
JSON_ASSERT_UNREACHABLE;
}
return false; // unreachable
}
bool Value::operator<=(const Value& other) const { return !(other < *this); }
bool Value::operator>=(const Value& other) const { return !(*this < other); }
bool Value::operator>(const Value& other) const { return other < *this; }
bool Value::operator==(const Value& other) const {
if (type() != other.type())
return false;
switch (type()) {
case nullValue:
return true;
case intValue:
return value_.int_ == other.value_.int_;
case uintValue:
return value_.uint_ == other.value_.uint_;
case realValue:
return value_.real_ == other.value_.real_;
case booleanValue:
return value_.bool_ == other.value_.bool_;
case stringValue: {
if ((value_.string_ == nullptr) || (other.value_.string_ == nullptr)) {
return (value_.string_ == other.value_.string_);
}
unsigned this_len;
unsigned other_len;
char const* this_str;
char const* other_str;
decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len,
&this_str);
decodePrefixedString(other.isAllocated(), other.value_.string_, &other_len,
&other_str);
if (this_len != other_len)
return false;
JSON_ASSERT(this_str && other_str);
int comp = memcmp(this_str, other_str, this_len);
return comp == 0;
}
case arrayValue:
case objectValue:
return value_.map_->size() == other.value_.map_->size() &&
(*value_.map_) == (*other.value_.map_);
default:
JSON_ASSERT_UNREACHABLE;
}
return false; // unreachable
}
bool Value::operator!=(const Value& other) const { return !(*this == other); }
const char* Value::asCString() const {
JSON_ASSERT_MESSAGE(type() == stringValue,
"in Json::Value::asCString(): requires stringValue");
if (value_.string_ == nullptr)
return nullptr;
unsigned this_len;
char const* this_str;
decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len,
&this_str);
return this_str;
}
#if JSONCPP_USING_SECURE_MEMORY
unsigned Value::getCStringLength() const {
JSON_ASSERT_MESSAGE(type() == stringValue,
"in Json::Value::asCString(): requires stringValue");
if (value_.string_ == 0)
return 0;
unsigned this_len;
char const* this_str;
decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len,
&this_str);
return this_len;
}
#endif
bool Value::getString(char const** begin, char const** end) const {
if (type() != stringValue)
return false;
if (value_.string_ == nullptr)
return false;
unsigned length;
decodePrefixedString(this->isAllocated(), this->value_.string_, &length,
begin);
*end = *begin + length;
return true;
}
String Value::asString() const {
switch (type()) {
case nullValue:
return "";
case stringValue: {
if (value_.string_ == nullptr)
return "";
unsigned this_len;
char const* this_str;
decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len,
&this_str);
return String(this_str, this_len);
}
case booleanValue:
return value_.bool_ ? "true" : "false";
case intValue:
return valueToString(value_.int_);
case uintValue:
return valueToString(value_.uint_);
case realValue:
return valueToString(value_.real_);
default:
JSON_FAIL_MESSAGE("Type is not convertible to string");
}
}
Value::Int Value::asInt() const {
switch (type()) {
case intValue:
JSON_ASSERT_MESSAGE(isInt(), "LargestInt out of Int range");
return Int(value_.int_);
case uintValue:
JSON_ASSERT_MESSAGE(isInt(), "LargestUInt out of Int range");
return Int(value_.uint_);
case realValue:
JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt, maxInt),
"double out of Int range");
return Int(value_.real_);
case nullValue:
return 0;
case booleanValue:
return value_.bool_ ? 1 : 0;
default:
break;
}
JSON_FAIL_MESSAGE("Value is not convertible to Int.");
}
Value::UInt Value::asUInt() const {
switch (type()) {
case intValue:
JSON_ASSERT_MESSAGE(isUInt(), "LargestInt out of UInt range");
return UInt(value_.int_);
case uintValue:
JSON_ASSERT_MESSAGE(isUInt(), "LargestUInt out of UInt range");
return UInt(value_.uint_);
case realValue:
JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt),
"double out of UInt range");
return UInt(value_.real_);
case nullValue:
return 0;
case booleanValue:
return value_.bool_ ? 1 : 0;
default:
break;
}
JSON_FAIL_MESSAGE("Value is not convertible to UInt.");
}
#if defined(JSON_HAS_INT64)
Value::Int64 Value::asInt64() const {
switch (type()) {
case intValue:
return Int64(value_.int_);
case uintValue:
JSON_ASSERT_MESSAGE(isInt64(), "LargestUInt out of Int64 range");
return Int64(value_.uint_);
case realValue:
JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt64, maxInt64),
"double out of Int64 range");
return Int64(value_.real_);
case nullValue:
return 0;
case booleanValue:
return value_.bool_ ? 1 : 0;
default:
break;
}
JSON_FAIL_MESSAGE("Value is not convertible to Int64.");
}
Value::UInt64 Value::asUInt64() const {
switch (type()) {
case intValue:
JSON_ASSERT_MESSAGE(isUInt64(), "LargestInt out of UInt64 range");
return UInt64(value_.int_);
case uintValue:
return UInt64(value_.uint_);
case realValue:
JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt64),
"double out of UInt64 range");
return UInt64(value_.real_);
case nullValue:
return 0;
case booleanValue:
return value_.bool_ ? 1 : 0;
default:
break;
}
JSON_FAIL_MESSAGE("Value is not convertible to UInt64.");
}
#endif // if defined(JSON_HAS_INT64)
LargestInt Value::asLargestInt() const {
#if defined(JSON_NO_INT64)
return asInt();
#else
return asInt64();
#endif
}
LargestUInt Value::asLargestUInt() const {
#if defined(JSON_NO_INT64)
return asUInt();
#else
return asUInt64();
#endif
}
double Value::asDouble() const {
switch (type()) {
case intValue:
return static_cast<double>(value_.int_);
case uintValue:
#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
return static_cast<double>(value_.uint_);
#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
return integerToDouble(value_.uint_);
#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
case realValue:
return value_.real_;
case nullValue:
return 0.0;
case booleanValue:
return value_.bool_ ? 1.0 : 0.0;
default:
break;
}
JSON_FAIL_MESSAGE("Value is not convertible to double.");
}
float Value::asFloat() const {
switch (type()) {
case intValue:
return static_cast<float>(value_.int_);
case uintValue:
#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
return static_cast<float>(value_.uint_);
#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
// This can fail (silently?) if the value is bigger than MAX_FLOAT.
return static_cast<float>(integerToDouble(value_.uint_));
#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
case realValue:
return static_cast<float>(value_.real_);
case nullValue:
return 0.0;
case booleanValue:
return value_.bool_ ? 1.0F : 0.0F;
default:
break;
}
JSON_FAIL_MESSAGE("Value is not convertible to float.");
}
bool Value::asBool() const {
switch (type()) {
case booleanValue:
return value_.bool_;
case nullValue:
return false;
case intValue:
return value_.int_ != 0;
case uintValue:
return value_.uint_ != 0;
case realValue: {
// According to JavaScript language zero or NaN is regarded as false
const auto value_classification = std::fpclassify(value_.real_);
return value_classification != FP_ZERO && value_classification != FP_NAN;
}
default:
break;
}
JSON_FAIL_MESSAGE("Value is not convertible to bool.");
}
bool Value::isConvertibleTo(ValueType other) const {
switch (other) {
case nullValue:
return (isNumeric() && asDouble() == 0.0) ||
(type() == booleanValue && !value_.bool_) ||
(type() == stringValue && asString().empty()) ||
(type() == arrayValue && value_.map_->empty()) ||
(type() == objectValue && value_.map_->empty()) ||
type() == nullValue;
case intValue:
return isInt() ||
(type() == realValue && InRange(value_.real_, minInt, maxInt)) ||
type() == booleanValue || type() == nullValue;
case uintValue:
return isUInt() ||
(type() == realValue && InRange(value_.real_, 0, maxUInt)) ||
type() == booleanValue || type() == nullValue;
case realValue:
return isNumeric() || type() == booleanValue || type() == nullValue;
case booleanValue:
return isNumeric() || type() == booleanValue || type() == nullValue;
case stringValue:
return isNumeric() || type() == booleanValue || type() == stringValue ||
type() == nullValue;
case arrayValue:
return type() == arrayValue || type() == nullValue;
case objectValue:
return type() == objectValue || type() == nullValue;
}
JSON_ASSERT_UNREACHABLE;
return false;
}
/// Number of values in array or object
ArrayIndex Value::size() const {
switch (type()) {
case nullValue:
case intValue:
case uintValue:
case realValue:
case booleanValue:
case stringValue:
return 0;
case arrayValue: // size of the array is highest index + 1
if (!value_.map_->empty()) {
ObjectValues::const_iterator itLast = value_.map_->end();
--itLast;
return (*itLast).first.index() + 1;
}
return 0;
case objectValue:
return ArrayIndex(value_.map_->size());
}
JSON_ASSERT_UNREACHABLE;
return 0; // unreachable;
}
bool Value::empty() const {
if (isNull() || isArray() || isObject())
return size() == 0U;
return false;
}
Value::operator bool() const { return !isNull(); }
void Value::clear() {
JSON_ASSERT_MESSAGE(type() == nullValue || type() == arrayValue ||
type() == objectValue,
"in Json::Value::clear(): requires complex value");
start_ = 0;
limit_ = 0;
switch (type()) {
case arrayValue:
case objectValue:
value_.map_->clear();
break;
default:
break;
}
}
void Value::resize(ArrayIndex newSize) {
JSON_ASSERT_MESSAGE(type() == nullValue || type() == arrayValue,
"in Json::Value::resize(): requires arrayValue");
if (type() == nullValue)
*this = Value(arrayValue);
ArrayIndex oldSize = size();
if (newSize == 0)
clear();
else if (newSize > oldSize)
this->operator[](newSize - 1);
else {
for (ArrayIndex index = newSize; index < oldSize; ++index) {
value_.map_->erase(index);
}
JSON_ASSERT(size() == newSize);
}
}
Value& Value::operator[](ArrayIndex index) {
JSON_ASSERT_MESSAGE(
type() == nullValue || type() == arrayValue,
"in Json::Value::operator[](ArrayIndex): requires arrayValue");
if (type() == nullValue)
*this = Value(arrayValue);
CZString key(index);
auto it = value_.map_->lower_bound(key);
if (it != value_.map_->end() && (*it).first == key)
return (*it).second;
ObjectValues::value_type defaultValue(key, nullSingleton());
it = value_.map_->insert(it, defaultValue);
return (*it).second;
}
Value& Value::operator[](int index) {
JSON_ASSERT_MESSAGE(
index >= 0,
"in Json::Value::operator[](int index): index cannot be negative");
return (*this)[ArrayIndex(index)];
}
const Value& Value::operator[](ArrayIndex index) const {
JSON_ASSERT_MESSAGE(
type() == nullValue || type() == arrayValue,
"in Json::Value::operator[](ArrayIndex)const: requires arrayValue");
if (type() == nullValue)
return nullSingleton();
CZString key(index);
ObjectValues::const_iterator it = value_.map_->find(key);
if (it == value_.map_->end())
return nullSingleton();
return (*it).second;
}
const Value& Value::operator[](int index) const {
JSON_ASSERT_MESSAGE(
index >= 0,
"in Json::Value::operator[](int index) const: index cannot be negative");
return (*this)[ArrayIndex(index)];
}
void Value::initBasic(ValueType type, bool allocated) {
setType(type);
setIsAllocated(allocated);
comments_ = Comments{};
start_ = 0;
limit_ = 0;
}
void Value::dupPayload(const Value& other) {
setType(other.type());
setIsAllocated(false);
switch (type()) {
case nullValue:
case intValue:
case uintValue:
case realValue:
case booleanValue:
value_ = other.value_;
break;
case stringValue:
if (other.value_.string_ && other.isAllocated()) {
unsigned len;
char const* str;
decodePrefixedString(other.isAllocated(), other.value_.string_, &len,
&str);
value_.string_ = duplicateAndPrefixStringValue(str, len);
setIsAllocated(true);
} else {
value_.string_ = other.value_.string_;
}
break;
case arrayValue:
case objectValue:
value_.map_ = new ObjectValues(*other.value_.map_);
break;
default:
JSON_ASSERT_UNREACHABLE;
}
}
void Value::releasePayload() {
switch (type()) {
case nullValue:
case intValue:
case uintValue:
case realValue:
case booleanValue:
break;
case stringValue:
if (isAllocated())
releasePrefixedStringValue(value_.string_);
break;
case arrayValue:
case objectValue:
delete value_.map_;
break;
default:
JSON_ASSERT_UNREACHABLE;
}
}
void Value::dupMeta(const Value& other) {
comments_ = other.comments_;
start_ = other.start_;
limit_ = other.limit_;
}
// Access an object value by name, create a null member if it does not exist.
// @pre Type of '*this' is object or null.
// @param key is null-terminated.
Value& Value::resolveReference(const char* key) {
JSON_ASSERT_MESSAGE(
type() == nullValue || type() == objectValue,
"in Json::Value::resolveReference(): requires objectValue");
if (type() == nullValue)
*this = Value(objectValue);
CZString actualKey(key, static_cast<unsigned>(strlen(key)),
CZString::noDuplication); // NOTE!
auto it = value_.map_->lower_bound(actualKey);
if (it != value_.map_->end() && (*it).first == actualKey)
return (*it).second;
ObjectValues::value_type defaultValue(actualKey, nullSingleton());
it = value_.map_->insert(it, defaultValue);
Value& value = (*it).second;
return value;
}
// @param key is not null-terminated.
Value& Value::resolveReference(char const* key, char const* end) {
JSON_ASSERT_MESSAGE(
type() == nullValue || type() == objectValue,
"in Json::Value::resolveReference(key, end): requires objectValue");
if (type() == nullValue)
*this = Value(objectValue);
CZString actualKey(key, static_cast<unsigned>(end - key),
CZString::duplicateOnCopy);
auto it = value_.map_->lower_bound(actualKey);
if (it != value_.map_->end() && (*it).first == actualKey)
return (*it).second;
ObjectValues::value_type defaultValue(actualKey, nullSingleton());
it = value_.map_->insert(it, defaultValue);
Value& value = (*it).second;
return value;
}
Value Value::get(ArrayIndex index, const Value& defaultValue) const {
const Value* value = &((*this)[index]);
return value == &nullSingleton() ? defaultValue : *value;
}
bool Value::isValidIndex(ArrayIndex index) const { return index < size(); }
Value const* Value::find(char const* begin, char const* end) const {
JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue,
"in Json::Value::find(begin, end): requires "
"objectValue or nullValue");
if (type() == nullValue)
return nullptr;
CZString actualKey(begin, static_cast<unsigned>(end - begin),
CZString::noDuplication);
ObjectValues::const_iterator it = value_.map_->find(actualKey);
if (it == value_.map_->end())
return nullptr;
return &(*it).second;
}
Value* Value::demand(char const* begin, char const* end) {
JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue,
"in Json::Value::demand(begin, end): requires "
"objectValue or nullValue");
return &resolveReference(begin, end);
}
const Value& Value::operator[](const char* key) const {
Value const* found = find(key, key + strlen(key));
if (!found)
return nullSingleton();
return *found;
}
Value const& Value::operator[](const String& key) const {
Value const* found = find(key.data(), key.data() + key.length());
if (!found)
return nullSingleton();
return *found;
}
Value& Value::operator[](const char* key) {
return resolveReference(key, key + strlen(key));
}
Value& Value::operator[](const String& key) {
return resolveReference(key.data(), key.data() + key.length());
}
Value& Value::operator[](const StaticString& key) {
return resolveReference(key.c_str());
}
Value& Value::append(const Value& value) { return append(Value(value)); }
Value& Value::append(Value&& value) {
JSON_ASSERT_MESSAGE(type() == nullValue || type() == arrayValue,
"in Json::Value::append: requires arrayValue");
if (type() == nullValue) {
*this = Value(arrayValue);
}
return this->value_.map_->emplace(size(), std::move(value)).first->second;
}
bool Value::insert(ArrayIndex index, const Value& newValue) {
return insert(index, Value(newValue));
}
bool Value::insert(ArrayIndex index, Value&& newValue) {
JSON_ASSERT_MESSAGE(type() == nullValue || type() == arrayValue,
"in Json::Value::insert: requires arrayValue");
ArrayIndex length = size();
if (index > length) {
return false;
}
for (ArrayIndex i = length; i > index; i--) {
(*this)[i] = std::move((*this)[i - 1]);
}
(*this)[index] = std::move(newValue);
return true;
}
Value Value::get(char const* begin, char const* end,
Value const& defaultValue) const {
Value const* found = find(begin, end);
return !found ? defaultValue : *found;
}
Value Value::get(char const* key, Value const& defaultValue) const {
return get(key, key + strlen(key), defaultValue);
}
Value Value::get(String const& key, Value const& defaultValue) const {
return get(key.data(), key.data() + key.length(), defaultValue);
}
bool Value::removeMember(const char* begin, const char* end, Value* removed) {
if (type() != objectValue) {
return false;
}
CZString actualKey(begin, static_cast<unsigned>(end - begin),
CZString::noDuplication);
auto it = value_.map_->find(actualKey);
if (it == value_.map_->end())
return false;
if (removed)
*removed = std::move(it->second);
value_.map_->erase(it);
return true;
}
bool Value::removeMember(const char* key, Value* removed) {
return removeMember(key, key + strlen(key), removed);
}
bool Value::removeMember(String const& key, Value* removed) {
return removeMember(key.data(), key.data() + key.length(), removed);
}
void Value::removeMember(const char* key) {
JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue,
"in Json::Value::removeMember(): requires objectValue");
if (type() == nullValue)
return;
CZString actualKey(key, unsigned(strlen(key)), CZString::noDuplication);
value_.map_->erase(actualKey);
}
void Value::removeMember(const String& key) { removeMember(key.c_str()); }
bool Value::removeIndex(ArrayIndex index, Value* removed) {
if (type() != arrayValue) {
return false;
}
CZString key(index);
auto it = value_.map_->find(key);
if (it == value_.map_->end()) {
return false;
}
if (removed)
*removed = it->second;
ArrayIndex oldSize = size();
// shift left all items left, into the place of the "removed"
for (ArrayIndex i = index; i < (oldSize - 1); ++i) {
CZString keey(i);
(*value_.map_)[keey] = (*this)[i + 1];
}
// erase the last one ("leftover")
CZString keyLast(oldSize - 1);
auto itLast = value_.map_->find(keyLast);
value_.map_->erase(itLast);
return true;
}
bool Value::isMember(char const* begin, char const* end) const {
Value const* value = find(begin, end);
return nullptr != value;
}
bool Value::isMember(char const* key) const {
return isMember(key, key + strlen(key));
}
bool Value::isMember(String const& key) const {
return isMember(key.data(), key.data() + key.length());
}
Value::Members Value::getMemberNames() const {
JSON_ASSERT_MESSAGE(
type() == nullValue || type() == objectValue,
"in Json::Value::getMemberNames(), value must be objectValue");
if (type() == nullValue)
return Value::Members();
Members members;
members.reserve(value_.map_->size());
ObjectValues::const_iterator it = value_.map_->begin();
ObjectValues::const_iterator itEnd = value_.map_->end();
for (; it != itEnd; ++it) {
members.push_back(String((*it).first.data(), (*it).first.length()));
}
return members;
}
static bool IsIntegral(double d) {
double integral_part;
return modf(d, &integral_part) == 0.0;
}
bool Value::isNull() const { return type() == nullValue; }
bool Value::isBool() const { return type() == booleanValue; }
bool Value::isInt() const {
switch (type()) {
case intValue:
#if defined(JSON_HAS_INT64)
return value_.int_ >= minInt && value_.int_ <= maxInt;
#else
return true;
#endif
case uintValue:
return value_.uint_ <= UInt(maxInt);
case realValue:
return value_.real_ >= minInt && value_.real_ <= maxInt &&
IsIntegral(value_.real_);
default:
break;
}
return false;
}
bool Value::isUInt() const {
switch (type()) {
case intValue:
#if defined(JSON_HAS_INT64)
return value_.int_ >= 0 && LargestUInt(value_.int_) <= LargestUInt(maxUInt);
#else
return value_.int_ >= 0;
#endif
case uintValue:
#if defined(JSON_HAS_INT64)
return value_.uint_ <= maxUInt;
#else
return true;
#endif
case realValue:
return value_.real_ >= 0 && value_.real_ <= maxUInt &&
IsIntegral(value_.real_);
default:
break;
}
return false;
}
bool Value::isInt64() const {
#if defined(JSON_HAS_INT64)
switch (type()) {
case intValue:
return true;
case uintValue:
return value_.uint_ <= UInt64(maxInt64);
case realValue:
// Note that maxInt64 (= 2^63 - 1) is not exactly representable as a
// double, so double(maxInt64) will be rounded up to 2^63. Therefore we
// require the value to be strictly less than the limit.
return value_.real_ >= double(minInt64) &&
value_.real_ < double(maxInt64) && IsIntegral(value_.real_);
default:
break;
}
#endif // JSON_HAS_INT64
return false;
}
bool Value::isUInt64() const {
#if defined(JSON_HAS_INT64)
switch (type()) {
case intValue:
return value_.int_ >= 0;
case uintValue:
return true;
case realValue:
// Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
// double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
// require the value to be strictly less than the limit.
return value_.real_ >= 0 && value_.real_ < maxUInt64AsDouble &&
IsIntegral(value_.real_);
default:
break;
}
#endif // JSON_HAS_INT64
return false;
}
bool Value::isIntegral() const {
switch (type()) {
case intValue:
case uintValue:
return true;
case realValue:
#if defined(JSON_HAS_INT64)
// Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
// double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
// require the value to be strictly less than the limit.
return value_.real_ >= double(minInt64) &&
value_.real_ < maxUInt64AsDouble && IsIntegral(value_.real_);
#else
return value_.real_ >= minInt && value_.real_ <= maxUInt &&
IsIntegral(value_.real_);
#endif // JSON_HAS_INT64
default:
break;
}
return false;
}
bool Value::isDouble() const {
return type() == intValue || type() == uintValue || type() == realValue;
}
bool Value::isNumeric() const { return isDouble(); }
bool Value::isString() const { return type() == stringValue; }
bool Value::isArray() const { return type() == arrayValue; }
bool Value::isObject() const { return type() == objectValue; }
Value::Comments::Comments(const Comments& that)
: ptr_{cloneUnique(that.ptr_)} {}
Value::Comments::Comments(Comments&& that) noexcept
: ptr_{std::move(that.ptr_)} {}
Value::Comments& Value::Comments::operator=(const Comments& that) {
ptr_ = cloneUnique(that.ptr_);
return *this;
}
Value::Comments& Value::Comments::operator=(Comments&& that) noexcept {
ptr_ = std::move(that.ptr_);
return *this;
}
bool Value::Comments::has(CommentPlacement slot) const {
return ptr_ && !(*ptr_)[slot].empty();
}
String Value::Comments::get(CommentPlacement slot) const {
if (!ptr_)
return {};
return (*ptr_)[slot];
}
void Value::Comments::set(CommentPlacement slot, String comment) {
if (!ptr_) {
ptr_ = std::unique_ptr<Array>(new Array());
}
// check comments array boundry.
if (slot < CommentPlacement::numberOfCommentPlacement) {
(*ptr_)[slot] = std::move(comment);
}
}
void Value::setComment(String comment, CommentPlacement placement) {
if (!comment.empty() && (comment.back() == '\n')) {
// Always discard trailing newline, to aid indentation.
comment.pop_back();
}
JSON_ASSERT(!comment.empty());
JSON_ASSERT_MESSAGE(
comment[0] == '\0' || comment[0] == '/',
"in Json::Value::setComment(): Comments must start with /");
comments_.set(placement, std::move(comment));
}
bool Value::hasComment(CommentPlacement placement) const {
return comments_.has(placement);
}
String Value::getComment(CommentPlacement placement) const {
return comments_.get(placement);
}
void Value::setOffsetStart(ptrdiff_t start) { start_ = start; }
void Value::setOffsetLimit(ptrdiff_t limit) { limit_ = limit; }
ptrdiff_t Value::getOffsetStart() const { return start_; }
ptrdiff_t Value::getOffsetLimit() const { return limit_; }
String Value::toStyledString() const {
StreamWriterBuilder builder;
String out = this->hasComment(commentBefore) ? "\n" : "";
out += Json::writeString(builder, *this);
out += '\n';
return out;
}
Value::const_iterator Value::begin() const {
switch (type()) {
case arrayValue:
case objectValue:
if (value_.map_)
return const_iterator(value_.map_->begin());
break;
default:
break;
}
return {};
}
Value::const_iterator Value::end() const {
switch (type()) {
case arrayValue:
case objectValue:
if (value_.map_)
return const_iterator(value_.map_->end());
break;
default:
break;
}
return {};
}
Value::iterator Value::begin() {
switch (type()) {
case arrayValue:
case objectValue:
if (value_.map_)
return iterator(value_.map_->begin());
break;
default:
break;
}
return iterator();
}
Value::iterator Value::end() {
switch (type()) {
case arrayValue:
case objectValue:
if (value_.map_)
return iterator(value_.map_->end());
break;
default:
break;
}
return iterator();
}
// class PathArgument
// //////////////////////////////////////////////////////////////////
PathArgument::PathArgument() = default;
PathArgument::PathArgument(ArrayIndex index)
: index_(index), kind_(kindIndex) {}
PathArgument::PathArgument(const char* key) : key_(key), kind_(kindKey) {}
PathArgument::PathArgument(String key) : key_(std::move(key)), kind_(kindKey) {}
// class Path
// //////////////////////////////////////////////////////////////////
Path::Path(const String& path, const PathArgument& a1, const PathArgument& a2,
const PathArgument& a3, const PathArgument& a4,
const PathArgument& a5) {
InArgs in;
in.reserve(5);
in.push_back(&a1);
in.push_back(&a2);
in.push_back(&a3);
in.push_back(&a4);
in.push_back(&a5);
makePath(path, in);
}
void Path::makePath(const String& path, const InArgs& in) {
const char* current = path.c_str();
const char* end = current + path.length();
auto itInArg = in.begin();
while (current != end) {
if (*current == '[') {
++current;
if (*current == '%')
addPathInArg(path, in, itInArg, PathArgument::kindIndex);
else {
ArrayIndex index = 0;
for (; current != end && *current >= '0' && *current <= '9'; ++current)
index = index * 10 + ArrayIndex(*current - '0');
args_.push_back(index);
}
if (current == end || *++current != ']')
invalidPath(path, int(current - path.c_str()));
} else if (*current == '%') {
addPathInArg(path, in, itInArg, PathArgument::kindKey);
++current;
} else if (*current == '.' || *current == ']') {
++current;
} else {
const char* beginName = current;
while (current != end && !strchr("[.", *current))
++current;
args_.push_back(String(beginName, current));
}
}
}
void Path::addPathInArg(const String& /*path*/, const InArgs& in,
InArgs::const_iterator& itInArg,
PathArgument::Kind kind) {
if (itInArg == in.end()) {
// Error: missing argument %d
} else if ((*itInArg)->kind_ != kind) {
// Error: bad argument type
} else {
args_.push_back(**itInArg++);
}
}
void Path::invalidPath(const String& /*path*/, int /*location*/) {
// Error: invalid path.
}
const Value& Path::resolve(const Value& root) const {
const Value* node = &root;
for (const auto& arg : args_) {
if (arg.kind_ == PathArgument::kindIndex) {
if (!node->isArray() || !node->isValidIndex(arg.index_)) {
// Error: unable to resolve path (array value expected at position... )
return Value::nullSingleton();
}
node = &((*node)[arg.index_]);
} else if (arg.kind_ == PathArgument::kindKey) {
if (!node->isObject()) {
// Error: unable to resolve path (object value expected at position...)
return Value::nullSingleton();
}
node = &((*node)[arg.key_]);
if (node == &Value::nullSingleton()) {
// Error: unable to resolve path (object has no member named '' at
// position...)
return Value::nullSingleton();
}
}
}
return *node;
}
Value Path::resolve(const Value& root, const Value& defaultValue) const {
const Value* node = &root;
for (const auto& arg : args_) {
if (arg.kind_ == PathArgument::kindIndex) {
if (!node->isArray() || !node->isValidIndex(arg.index_))
return defaultValue;
node = &((*node)[arg.index_]);
} else if (arg.kind_ == PathArgument::kindKey) {
if (!node->isObject())
return defaultValue;
node = &((*node)[arg.key_]);
if (node == &Value::nullSingleton())
return defaultValue;
}
}
return *node;
}
Value& Path::make(Value& root) const {
Value* node = &root;
for (const auto& arg : args_) {
if (arg.kind_ == PathArgument::kindIndex) {
if (!node->isArray()) {
// Error: node is not an array at position ...
}
node = &((*node)[arg.index_]);
} else if (arg.kind_ == PathArgument::kindKey) {
if (!node->isObject()) {
// Error: node is not an object at position...
}
node = &((*node)[arg.key_]);
}
}
return *node;
}
} // namespace Json
| YifuLiu/AliOS-Things | components/jsoncpp/src/lib_json/json_value.cpp | C++ | apache-2.0 | 48,209 |
// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
// included by json_value.cpp
namespace Json {
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// class ValueIteratorBase
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
ValueIteratorBase::ValueIteratorBase() : current_() {}
ValueIteratorBase::ValueIteratorBase(
const Value::ObjectValues::iterator& current)
: current_(current), isNull_(false) {}
Value& ValueIteratorBase::deref() { return current_->second; }
const Value& ValueIteratorBase::deref() const { return current_->second; }
void ValueIteratorBase::increment() { ++current_; }
void ValueIteratorBase::decrement() { --current_; }
ValueIteratorBase::difference_type
ValueIteratorBase::computeDistance(const SelfType& other) const {
// Iterator for null value are initialized using the default
// constructor, which initialize current_ to the default
// std::map::iterator. As begin() and end() are two instance
// of the default std::map::iterator, they can not be compared.
// To allow this, we handle this comparison specifically.
if (isNull_ && other.isNull_) {
return 0;
}
// Usage of std::distance is not portable (does not compile with Sun Studio 12
// RogueWave STL,
// which is the one used by default).
// Using a portable hand-made version for non random iterator instead:
// return difference_type( std::distance( current_, other.current_ ) );
difference_type myDistance = 0;
for (Value::ObjectValues::iterator it = current_; it != other.current_;
++it) {
++myDistance;
}
return myDistance;
}
bool ValueIteratorBase::isEqual(const SelfType& other) const {
if (isNull_) {
return other.isNull_;
}
return current_ == other.current_;
}
void ValueIteratorBase::copy(const SelfType& other) {
current_ = other.current_;
isNull_ = other.isNull_;
}
Value ValueIteratorBase::key() const {
const Value::CZString czstring = (*current_).first;
if (czstring.data()) {
if (czstring.isStaticString())
return Value(StaticString(czstring.data()));
return Value(czstring.data(), czstring.data() + czstring.length());
}
return Value(czstring.index());
}
UInt ValueIteratorBase::index() const {
const Value::CZString czstring = (*current_).first;
if (!czstring.data())
return czstring.index();
return Value::UInt(-1);
}
String ValueIteratorBase::name() const {
char const* keey;
char const* end;
keey = memberName(&end);
if (!keey)
return String();
return String(keey, end);
}
char const* ValueIteratorBase::memberName() const {
const char* cname = (*current_).first.data();
return cname ? cname : "";
}
char const* ValueIteratorBase::memberName(char const** end) const {
const char* cname = (*current_).first.data();
if (!cname) {
*end = nullptr;
return nullptr;
}
*end = cname + (*current_).first.length();
return cname;
}
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// class ValueConstIterator
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
ValueConstIterator::ValueConstIterator() = default;
ValueConstIterator::ValueConstIterator(
const Value::ObjectValues::iterator& current)
: ValueIteratorBase(current) {}
ValueConstIterator::ValueConstIterator(ValueIterator const& other)
: ValueIteratorBase(other) {}
ValueConstIterator& ValueConstIterator::
operator=(const ValueIteratorBase& other) {
copy(other);
return *this;
}
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// class ValueIterator
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
ValueIterator::ValueIterator() = default;
ValueIterator::ValueIterator(const Value::ObjectValues::iterator& current)
: ValueIteratorBase(current) {}
ValueIterator::ValueIterator(const ValueConstIterator& other)
: ValueIteratorBase(other) {
throwRuntimeError("ConstIterator to Iterator should never be allowed.");
}
ValueIterator::ValueIterator(const ValueIterator& other) = default;
ValueIterator& ValueIterator::operator=(const SelfType& other) {
copy(other);
return *this;
}
} // namespace Json
| YifuLiu/AliOS-Things | components/jsoncpp/src/lib_json/json_valueiterator.h | C++ | apache-2.0 | 5,214 |
// Copyright 2011 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#if !defined(JSON_IS_AMALGAMATION)
#include "json_tool.h"
#include <json/writer.h>
#endif // if !defined(JSON_IS_AMALGAMATION)
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cstring>
#include <iomanip>
#include <memory>
#include <set>
#include <sstream>
#include <utility>
#if __cplusplus >= 201103L
#include <cmath>
#include <cstdio>
#if !defined(isnan)
#define isnan std::isnan
#endif
#if !defined(isfinite)
#define isfinite std::isfinite
#endif
#else
#include <cmath>
#include <cstdio>
#if defined(_MSC_VER)
#if !defined(isnan)
#include <float.h>
#define isnan _isnan
#endif
#if !defined(isfinite)
#include <float.h>
#define isfinite _finite
#endif
#if !defined(_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES)
#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1
#endif //_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES
#endif //_MSC_VER
#if defined(__sun) && defined(__SVR4) // Solaris
#if !defined(isfinite)
#include <ieeefp.h>
#define isfinite finite
#endif
#endif
#if defined(__hpux)
#if !defined(isfinite)
#if defined(__ia64) && !defined(finite)
#define isfinite(x) \
((sizeof(x) == sizeof(float) ? _Isfinitef(x) : _IsFinite(x)))
#endif
#endif
#endif
#if !defined(isnan)
// IEEE standard states that NaN values will not compare to themselves
#define isnan(x) (x != x)
#endif
#if !defined(__APPLE__)
#if !defined(isfinite)
#define isfinite finite
#endif
#endif
#endif
#if defined(_MSC_VER)
// Disable warning about strdup being deprecated.
#pragma warning(disable : 4996)
#endif
namespace Json {
#if __cplusplus >= 201103L || (defined(_CPPLIB_VER) && _CPPLIB_VER >= 520)
using StreamWriterPtr = std::unique_ptr<StreamWriter>;
#else
using StreamWriterPtr = std::auto_ptr<StreamWriter>;
#endif
String valueToString(LargestInt value) {
UIntToStringBuffer buffer;
char* current = buffer + sizeof(buffer);
if (value == Value::minLargestInt) {
uintToString(LargestUInt(Value::maxLargestInt) + 1, current);
*--current = '-';
} else if (value < 0) {
uintToString(LargestUInt(-value), current);
*--current = '-';
} else {
uintToString(LargestUInt(value), current);
}
assert(current >= buffer);
return current;
}
String valueToString(LargestUInt value) {
UIntToStringBuffer buffer;
char* current = buffer + sizeof(buffer);
uintToString(value, current);
assert(current >= buffer);
return current;
}
#if defined(JSON_HAS_INT64)
String valueToString(Int value) { return valueToString(LargestInt(value)); }
String valueToString(UInt value) { return valueToString(LargestUInt(value)); }
#endif // # if defined(JSON_HAS_INT64)
namespace {
String valueToString(double value, bool useSpecialFloats,
unsigned int precision, PrecisionType precisionType) {
// Print into the buffer. We need not request the alternative representation
// that always has a decimal point because JSON doesn't distinguish the
// concepts of reals and integers.
if (!isfinite(value)) {
static const char* const reps[2][3] = {{"NaN", "-Infinity", "Infinity"},
{"null", "-1e+9999", "1e+9999"}};
return reps[useSpecialFloats ? 0 : 1]
[isnan(value) ? 0 : (value < 0) ? 1 : 2];
}
String buffer(size_t(36), '\0');
while (true) {
int len = jsoncpp_snprintf(
&*buffer.begin(), buffer.size(),
(precisionType == PrecisionType::significantDigits) ? "%.*g" : "%.*f",
precision, value);
assert(len >= 0);
auto wouldPrint = static_cast<size_t>(len);
if (wouldPrint >= buffer.size()) {
buffer.resize(wouldPrint + 1);
continue;
}
buffer.resize(wouldPrint);
break;
}
buffer.erase(fixNumericLocale(buffer.begin(), buffer.end()), buffer.end());
// try to ensure we preserve the fact that this was given to us as a double on
// input
if (buffer.find('.') == buffer.npos && buffer.find('e') == buffer.npos) {
buffer += ".0";
}
// strip the zero padding from the right
if (precisionType == PrecisionType::decimalPlaces) {
buffer.erase(fixZerosInTheEnd(buffer.begin(), buffer.end(), precision),
buffer.end());
}
return buffer;
}
} // namespace
String valueToString(double value, unsigned int precision,
PrecisionType precisionType) {
return valueToString(value, false, precision, precisionType);
}
String valueToString(bool value) { return value ? "true" : "false"; }
static bool doesAnyCharRequireEscaping(char const* s, size_t n) {
assert(s || !n);
return std::any_of(s, s + n, [](unsigned char c) {
return c == '\\' || c == '"' || c < 0x20 || c > 0x7F;
});
}
static unsigned int utf8ToCodepoint(const char*& s, const char* e) {
const unsigned int REPLACEMENT_CHARACTER = 0xFFFD;
unsigned int firstByte = static_cast<unsigned char>(*s);
if (firstByte < 0x80)
return firstByte;
if (firstByte < 0xE0) {
if (e - s < 2)
return REPLACEMENT_CHARACTER;
unsigned int calculated =
((firstByte & 0x1F) << 6) | (static_cast<unsigned int>(s[1]) & 0x3F);
s += 1;
// oversized encoded characters are invalid
return calculated < 0x80 ? REPLACEMENT_CHARACTER : calculated;
}
if (firstByte < 0xF0) {
if (e - s < 3)
return REPLACEMENT_CHARACTER;
unsigned int calculated = ((firstByte & 0x0F) << 12) |
((static_cast<unsigned int>(s[1]) & 0x3F) << 6) |
(static_cast<unsigned int>(s[2]) & 0x3F);
s += 2;
// surrogates aren't valid codepoints itself
// shouldn't be UTF-8 encoded
if (calculated >= 0xD800 && calculated <= 0xDFFF)
return REPLACEMENT_CHARACTER;
// oversized encoded characters are invalid
return calculated < 0x800 ? REPLACEMENT_CHARACTER : calculated;
}
if (firstByte < 0xF8) {
if (e - s < 4)
return REPLACEMENT_CHARACTER;
unsigned int calculated = ((firstByte & 0x07) << 18) |
((static_cast<unsigned int>(s[1]) & 0x3F) << 12) |
((static_cast<unsigned int>(s[2]) & 0x3F) << 6) |
(static_cast<unsigned int>(s[3]) & 0x3F);
s += 3;
// oversized encoded characters are invalid
return calculated < 0x10000 ? REPLACEMENT_CHARACTER : calculated;
}
return REPLACEMENT_CHARACTER;
}
static const char hex2[] = "000102030405060708090a0b0c0d0e0f"
"101112131415161718191a1b1c1d1e1f"
"202122232425262728292a2b2c2d2e2f"
"303132333435363738393a3b3c3d3e3f"
"404142434445464748494a4b4c4d4e4f"
"505152535455565758595a5b5c5d5e5f"
"606162636465666768696a6b6c6d6e6f"
"707172737475767778797a7b7c7d7e7f"
"808182838485868788898a8b8c8d8e8f"
"909192939495969798999a9b9c9d9e9f"
"a0a1a2a3a4a5a6a7a8a9aaabacadaeaf"
"b0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
"c0c1c2c3c4c5c6c7c8c9cacbcccdcecf"
"d0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
"e0e1e2e3e4e5e6e7e8e9eaebecedeeef"
"f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff";
static String toHex16Bit(unsigned int x) {
const unsigned int hi = (x >> 8) & 0xff;
const unsigned int lo = x & 0xff;
String result(4, ' ');
result[0] = hex2[2 * hi];
result[1] = hex2[2 * hi + 1];
result[2] = hex2[2 * lo];
result[3] = hex2[2 * lo + 1];
return result;
}
static void appendRaw(String& result, unsigned ch) {
result += static_cast<char>(ch);
}
static void appendHex(String& result, unsigned ch) {
result.append("\\u").append(toHex16Bit(ch));
}
static String valueToQuotedStringN(const char* value, unsigned length,
bool emitUTF8 = false) {
if (value == nullptr)
return "";
if (!doesAnyCharRequireEscaping(value, length))
return String("\"") + value + "\"";
// We have to walk value and escape any special characters.
// Appending to String is not efficient, but this should be rare.
// (Note: forward slashes are *not* rare, but I am not escaping them.)
String::size_type maxsize = length * 2 + 3; // allescaped+quotes+NULL
String result;
result.reserve(maxsize); // to avoid lots of mallocs
result += "\"";
char const* end = value + length;
for (const char* c = value; c != end; ++c) {
switch (*c) {
case '\"':
result += "\\\"";
break;
case '\\':
result += "\\\\";
break;
case '\b':
result += "\\b";
break;
case '\f':
result += "\\f";
break;
case '\n':
result += "\\n";
break;
case '\r':
result += "\\r";
break;
case '\t':
result += "\\t";
break;
// case '/':
// Even though \/ is considered a legal escape in JSON, a bare
// slash is also legal, so I see no reason to escape it.
// (I hope I am not misunderstanding something.)
// blep notes: actually escaping \/ may be useful in javascript to avoid </
// sequence.
// Should add a flag to allow this compatibility mode and prevent this
// sequence from occurring.
default: {
if (emitUTF8) {
unsigned codepoint = static_cast<unsigned char>(*c);
if (codepoint < 0x20) {
appendHex(result, codepoint);
} else {
appendRaw(result, codepoint);
}
} else {
unsigned codepoint = utf8ToCodepoint(c, end); // modifies `c`
if (codepoint < 0x20) {
appendHex(result, codepoint);
} else if (codepoint < 0x80) {
appendRaw(result, codepoint);
} else if (codepoint < 0x10000) {
// Basic Multilingual Plane
appendHex(result, codepoint);
} else {
// Extended Unicode. Encode 20 bits as a surrogate pair.
codepoint -= 0x10000;
appendHex(result, 0xd800 + ((codepoint >> 10) & 0x3ff));
appendHex(result, 0xdc00 + (codepoint & 0x3ff));
}
}
} break;
}
}
result += "\"";
return result;
}
String valueToQuotedString(const char* value) {
return valueToQuotedStringN(value, static_cast<unsigned int>(strlen(value)));
}
// Class Writer
// //////////////////////////////////////////////////////////////////
Writer::~Writer() = default;
// Class FastWriter
// //////////////////////////////////////////////////////////////////
FastWriter::FastWriter()
= default;
void FastWriter::enableYAMLCompatibility() { yamlCompatibilityEnabled_ = true; }
void FastWriter::dropNullPlaceholders() { dropNullPlaceholders_ = true; }
void FastWriter::omitEndingLineFeed() { omitEndingLineFeed_ = true; }
String FastWriter::write(const Value& root) {
document_.clear();
writeValue(root);
if (!omitEndingLineFeed_)
document_ += '\n';
return document_;
}
void FastWriter::writeValue(const Value& value) {
switch (value.type()) {
case nullValue:
if (!dropNullPlaceholders_)
document_ += "null";
break;
case intValue:
document_ += valueToString(value.asLargestInt());
break;
case uintValue:
document_ += valueToString(value.asLargestUInt());
break;
case realValue:
document_ += valueToString(value.asDouble());
break;
case stringValue: {
// Is NULL possible for value.string_? No.
char const* str;
char const* end;
bool ok = value.getString(&str, &end);
if (ok)
document_ += valueToQuotedStringN(str, static_cast<unsigned>(end - str));
break;
}
case booleanValue:
document_ += valueToString(value.asBool());
break;
case arrayValue: {
document_ += '[';
ArrayIndex size = value.size();
for (ArrayIndex index = 0; index < size; ++index) {
if (index > 0)
document_ += ',';
writeValue(value[index]);
}
document_ += ']';
} break;
case objectValue: {
Value::Members members(value.getMemberNames());
document_ += '{';
for (auto it = members.begin(); it != members.end(); ++it) {
const String& name = *it;
if (it != members.begin())
document_ += ',';
document_ += valueToQuotedStringN(name.data(),
static_cast<unsigned>(name.length()));
document_ += yamlCompatibilityEnabled_ ? ": " : ":";
writeValue(value[name]);
}
document_ += '}';
} break;
}
}
// Class StyledWriter
// //////////////////////////////////////////////////////////////////
StyledWriter::StyledWriter() = default;
String StyledWriter::write(const Value& root) {
document_.clear();
addChildValues_ = false;
indentString_.clear();
writeCommentBeforeValue(root);
writeValue(root);
writeCommentAfterValueOnSameLine(root);
document_ += '\n';
return document_;
}
void StyledWriter::writeValue(const Value& value) {
switch (value.type()) {
case nullValue:
pushValue("null");
break;
case intValue:
pushValue(valueToString(value.asLargestInt()));
break;
case uintValue:
pushValue(valueToString(value.asLargestUInt()));
break;
case realValue:
pushValue(valueToString(value.asDouble()));
break;
case stringValue: {
// Is NULL possible for value.string_? No.
char const* str;
char const* end;
bool ok = value.getString(&str, &end);
if (ok)
pushValue(valueToQuotedStringN(str, static_cast<unsigned>(end - str)));
else
pushValue("");
break;
}
case booleanValue:
pushValue(valueToString(value.asBool()));
break;
case arrayValue:
writeArrayValue(value);
break;
case objectValue: {
Value::Members members(value.getMemberNames());
if (members.empty())
pushValue("{}");
else {
writeWithIndent("{");
indent();
auto it = members.begin();
for (;;) {
const String& name = *it;
const Value& childValue = value[name];
writeCommentBeforeValue(childValue);
writeWithIndent(valueToQuotedString(name.c_str()));
document_ += " : ";
writeValue(childValue);
if (++it == members.end()) {
writeCommentAfterValueOnSameLine(childValue);
break;
}
document_ += ',';
writeCommentAfterValueOnSameLine(childValue);
}
unindent();
writeWithIndent("}");
}
} break;
}
}
void StyledWriter::writeArrayValue(const Value& value) {
unsigned size = value.size();
if (size == 0)
pushValue("[]");
else {
bool isArrayMultiLine = isMultilineArray(value);
if (isArrayMultiLine) {
writeWithIndent("[");
indent();
bool hasChildValue = !childValues_.empty();
unsigned index = 0;
for (;;) {
const Value& childValue = value[index];
writeCommentBeforeValue(childValue);
if (hasChildValue)
writeWithIndent(childValues_[index]);
else {
writeIndent();
writeValue(childValue);
}
if (++index == size) {
writeCommentAfterValueOnSameLine(childValue);
break;
}
document_ += ',';
writeCommentAfterValueOnSameLine(childValue);
}
unindent();
writeWithIndent("]");
} else // output on a single line
{
assert(childValues_.size() == size);
document_ += "[ ";
for (unsigned index = 0; index < size; ++index) {
if (index > 0)
document_ += ", ";
document_ += childValues_[index];
}
document_ += " ]";
}
}
}
bool StyledWriter::isMultilineArray(const Value& value) {
ArrayIndex const size = value.size();
bool isMultiLine = size * 3 >= rightMargin_;
childValues_.clear();
for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
const Value& childValue = value[index];
isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
!childValue.empty());
}
if (!isMultiLine) // check if line length > max line length
{
childValues_.reserve(size);
addChildValues_ = true;
ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
for (ArrayIndex index = 0; index < size; ++index) {
if (hasCommentForValue(value[index])) {
isMultiLine = true;
}
writeValue(value[index]);
lineLength += static_cast<ArrayIndex>(childValues_[index].length());
}
addChildValues_ = false;
isMultiLine = isMultiLine || lineLength >= rightMargin_;
}
return isMultiLine;
}
void StyledWriter::pushValue(const String& value) {
if (addChildValues_)
childValues_.push_back(value);
else
document_ += value;
}
void StyledWriter::writeIndent() {
if (!document_.empty()) {
char last = document_[document_.length() - 1];
if (last == ' ') // already indented
return;
if (last != '\n') // Comments may add new-line
document_ += '\n';
}
document_ += indentString_;
}
void StyledWriter::writeWithIndent(const String& value) {
writeIndent();
document_ += value;
}
void StyledWriter::indent() { indentString_ += String(indentSize_, ' '); }
void StyledWriter::unindent() {
assert(indentString_.size() >= indentSize_);
indentString_.resize(indentString_.size() - indentSize_);
}
void StyledWriter::writeCommentBeforeValue(const Value& root) {
if (!root.hasComment(commentBefore))
return;
document_ += '\n';
writeIndent();
const String& comment = root.getComment(commentBefore);
String::const_iterator iter = comment.begin();
while (iter != comment.end()) {
document_ += *iter;
if (*iter == '\n' && ((iter + 1) != comment.end() && *(iter + 1) == '/'))
writeIndent();
++iter;
}
// Comments are stripped of trailing newlines, so add one here
document_ += '\n';
}
void StyledWriter::writeCommentAfterValueOnSameLine(const Value& root) {
if (root.hasComment(commentAfterOnSameLine))
document_ += " " + root.getComment(commentAfterOnSameLine);
if (root.hasComment(commentAfter)) {
document_ += '\n';
document_ += root.getComment(commentAfter);
document_ += '\n';
}
}
bool StyledWriter::hasCommentForValue(const Value& value) {
return value.hasComment(commentBefore) ||
value.hasComment(commentAfterOnSameLine) ||
value.hasComment(commentAfter);
}
// Class StyledStreamWriter
// //////////////////////////////////////////////////////////////////
StyledStreamWriter::StyledStreamWriter(String indentation)
: document_(nullptr), indentation_(std::move(indentation)),
addChildValues_(), indented_(false) {}
void StyledStreamWriter::write(OStream& out, const Value& root) {
document_ = &out;
addChildValues_ = false;
indentString_.clear();
indented_ = true;
writeCommentBeforeValue(root);
if (!indented_)
writeIndent();
indented_ = true;
writeValue(root);
writeCommentAfterValueOnSameLine(root);
*document_ << "\n";
document_ = nullptr; // Forget the stream, for safety.
}
void StyledStreamWriter::writeValue(const Value& value) {
switch (value.type()) {
case nullValue:
pushValue("null");
break;
case intValue:
pushValue(valueToString(value.asLargestInt()));
break;
case uintValue:
pushValue(valueToString(value.asLargestUInt()));
break;
case realValue:
pushValue(valueToString(value.asDouble()));
break;
case stringValue: {
// Is NULL possible for value.string_? No.
char const* str;
char const* end;
bool ok = value.getString(&str, &end);
if (ok)
pushValue(valueToQuotedStringN(str, static_cast<unsigned>(end - str)));
else
pushValue("");
break;
}
case booleanValue:
pushValue(valueToString(value.asBool()));
break;
case arrayValue:
writeArrayValue(value);
break;
case objectValue: {
Value::Members members(value.getMemberNames());
if (members.empty())
pushValue("{}");
else {
writeWithIndent("{");
indent();
auto it = members.begin();
for (;;) {
const String& name = *it;
const Value& childValue = value[name];
writeCommentBeforeValue(childValue);
writeWithIndent(valueToQuotedString(name.c_str()));
*document_ << " : ";
writeValue(childValue);
if (++it == members.end()) {
writeCommentAfterValueOnSameLine(childValue);
break;
}
*document_ << ",";
writeCommentAfterValueOnSameLine(childValue);
}
unindent();
writeWithIndent("}");
}
} break;
}
}
void StyledStreamWriter::writeArrayValue(const Value& value) {
unsigned size = value.size();
if (size == 0)
pushValue("[]");
else {
bool isArrayMultiLine = isMultilineArray(value);
if (isArrayMultiLine) {
writeWithIndent("[");
indent();
bool hasChildValue = !childValues_.empty();
unsigned index = 0;
for (;;) {
const Value& childValue = value[index];
writeCommentBeforeValue(childValue);
if (hasChildValue)
writeWithIndent(childValues_[index]);
else {
if (!indented_)
writeIndent();
indented_ = true;
writeValue(childValue);
indented_ = false;
}
if (++index == size) {
writeCommentAfterValueOnSameLine(childValue);
break;
}
*document_ << ",";
writeCommentAfterValueOnSameLine(childValue);
}
unindent();
writeWithIndent("]");
} else // output on a single line
{
assert(childValues_.size() == size);
*document_ << "[ ";
for (unsigned index = 0; index < size; ++index) {
if (index > 0)
*document_ << ", ";
*document_ << childValues_[index];
}
*document_ << " ]";
}
}
}
bool StyledStreamWriter::isMultilineArray(const Value& value) {
ArrayIndex const size = value.size();
bool isMultiLine = size * 3 >= rightMargin_;
childValues_.clear();
for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
const Value& childValue = value[index];
isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
!childValue.empty());
}
if (!isMultiLine) // check if line length > max line length
{
childValues_.reserve(size);
addChildValues_ = true;
ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
for (ArrayIndex index = 0; index < size; ++index) {
if (hasCommentForValue(value[index])) {
isMultiLine = true;
}
writeValue(value[index]);
lineLength += static_cast<ArrayIndex>(childValues_[index].length());
}
addChildValues_ = false;
isMultiLine = isMultiLine || lineLength >= rightMargin_;
}
return isMultiLine;
}
void StyledStreamWriter::pushValue(const String& value) {
if (addChildValues_)
childValues_.push_back(value);
else
*document_ << value;
}
void StyledStreamWriter::writeIndent() {
// blep intended this to look at the so-far-written string
// to determine whether we are already indented, but
// with a stream we cannot do that. So we rely on some saved state.
// The caller checks indented_.
*document_ << '\n' << indentString_;
}
void StyledStreamWriter::writeWithIndent(const String& value) {
if (!indented_)
writeIndent();
*document_ << value;
indented_ = false;
}
void StyledStreamWriter::indent() { indentString_ += indentation_; }
void StyledStreamWriter::unindent() {
assert(indentString_.size() >= indentation_.size());
indentString_.resize(indentString_.size() - indentation_.size());
}
void StyledStreamWriter::writeCommentBeforeValue(const Value& root) {
if (!root.hasComment(commentBefore))
return;
if (!indented_)
writeIndent();
const String& comment = root.getComment(commentBefore);
String::const_iterator iter = comment.begin();
while (iter != comment.end()) {
*document_ << *iter;
if (*iter == '\n' && ((iter + 1) != comment.end() && *(iter + 1) == '/'))
// writeIndent(); // would include newline
*document_ << indentString_;
++iter;
}
indented_ = false;
}
void StyledStreamWriter::writeCommentAfterValueOnSameLine(const Value& root) {
if (root.hasComment(commentAfterOnSameLine))
*document_ << ' ' << root.getComment(commentAfterOnSameLine);
if (root.hasComment(commentAfter)) {
writeIndent();
*document_ << root.getComment(commentAfter);
}
indented_ = false;
}
bool StyledStreamWriter::hasCommentForValue(const Value& value) {
return value.hasComment(commentBefore) ||
value.hasComment(commentAfterOnSameLine) ||
value.hasComment(commentAfter);
}
//////////////////////////
// BuiltStyledStreamWriter
/// Scoped enums are not available until C++11.
struct CommentStyle {
/// Decide whether to write comments.
enum Enum {
None, ///< Drop all comments.
Most, ///< Recover odd behavior of previous versions (not implemented yet).
All ///< Keep all comments.
};
};
struct BuiltStyledStreamWriter : public StreamWriter {
BuiltStyledStreamWriter(String indentation, CommentStyle::Enum cs,
String colonSymbol, String nullSymbol,
String endingLineFeedSymbol, bool useSpecialFloats,
bool emitUTF8, unsigned int precision,
PrecisionType precisionType);
int write(Value const& root, OStream* sout) override;
private:
void writeValue(Value const& value);
void writeArrayValue(Value const& value);
bool isMultilineArray(Value const& value);
void pushValue(String const& value);
void writeIndent();
void writeWithIndent(String const& value);
void indent();
void unindent();
void writeCommentBeforeValue(Value const& root);
void writeCommentAfterValueOnSameLine(Value const& root);
static bool hasCommentForValue(const Value& value);
using ChildValues = std::vector<String>;
ChildValues childValues_;
String indentString_;
unsigned int rightMargin_;
String indentation_;
CommentStyle::Enum cs_;
String colonSymbol_;
String nullSymbol_;
String endingLineFeedSymbol_;
bool addChildValues_ : 1;
bool indented_ : 1;
bool useSpecialFloats_ : 1;
bool emitUTF8_ : 1;
unsigned int precision_;
PrecisionType precisionType_;
};
BuiltStyledStreamWriter::BuiltStyledStreamWriter(
String indentation, CommentStyle::Enum cs, String colonSymbol,
String nullSymbol, String endingLineFeedSymbol, bool useSpecialFloats,
bool emitUTF8, unsigned int precision, PrecisionType precisionType)
: rightMargin_(74), indentation_(std::move(indentation)), cs_(cs),
colonSymbol_(std::move(colonSymbol)), nullSymbol_(std::move(nullSymbol)),
endingLineFeedSymbol_(std::move(endingLineFeedSymbol)),
addChildValues_(false), indented_(false),
useSpecialFloats_(useSpecialFloats), emitUTF8_(emitUTF8),
precision_(precision), precisionType_(precisionType) {}
int BuiltStyledStreamWriter::write(Value const& root, OStream* sout) {
sout_ = sout;
addChildValues_ = false;
indented_ = true;
indentString_.clear();
writeCommentBeforeValue(root);
if (!indented_)
writeIndent();
indented_ = true;
writeValue(root);
writeCommentAfterValueOnSameLine(root);
*sout_ << endingLineFeedSymbol_;
sout_ = nullptr;
return 0;
}
void BuiltStyledStreamWriter::writeValue(Value const& value) {
switch (value.type()) {
case nullValue:
pushValue(nullSymbol_);
break;
case intValue:
pushValue(valueToString(value.asLargestInt()));
break;
case uintValue:
pushValue(valueToString(value.asLargestUInt()));
break;
case realValue:
pushValue(valueToString(value.asDouble(), useSpecialFloats_, precision_,
precisionType_));
break;
case stringValue: {
// Is NULL is possible for value.string_? No.
char const* str;
char const* end;
bool ok = value.getString(&str, &end);
if (ok)
pushValue(valueToQuotedStringN(str, static_cast<unsigned>(end - str),
emitUTF8_));
else
pushValue("");
break;
}
case booleanValue:
pushValue(valueToString(value.asBool()));
break;
case arrayValue:
writeArrayValue(value);
break;
case objectValue: {
Value::Members members(value.getMemberNames());
if (members.empty())
pushValue("{}");
else {
writeWithIndent("{");
indent();
auto it = members.begin();
for (;;) {
String const& name = *it;
Value const& childValue = value[name];
writeCommentBeforeValue(childValue);
writeWithIndent(valueToQuotedStringN(
name.data(), static_cast<unsigned>(name.length()), emitUTF8_));
*sout_ << colonSymbol_;
writeValue(childValue);
if (++it == members.end()) {
writeCommentAfterValueOnSameLine(childValue);
break;
}
*sout_ << ",";
writeCommentAfterValueOnSameLine(childValue);
}
unindent();
writeWithIndent("}");
}
} break;
}
}
void BuiltStyledStreamWriter::writeArrayValue(Value const& value) {
unsigned size = value.size();
if (size == 0)
pushValue("[]");
else {
bool isMultiLine = (cs_ == CommentStyle::All) || isMultilineArray(value);
if (isMultiLine) {
writeWithIndent("[");
indent();
bool hasChildValue = !childValues_.empty();
unsigned index = 0;
for (;;) {
Value const& childValue = value[index];
writeCommentBeforeValue(childValue);
if (hasChildValue)
writeWithIndent(childValues_[index]);
else {
if (!indented_)
writeIndent();
indented_ = true;
writeValue(childValue);
indented_ = false;
}
if (++index == size) {
writeCommentAfterValueOnSameLine(childValue);
break;
}
*sout_ << ",";
writeCommentAfterValueOnSameLine(childValue);
}
unindent();
writeWithIndent("]");
} else // output on a single line
{
assert(childValues_.size() == size);
*sout_ << "[";
if (!indentation_.empty())
*sout_ << " ";
for (unsigned index = 0; index < size; ++index) {
if (index > 0)
*sout_ << ((!indentation_.empty()) ? ", " : ",");
*sout_ << childValues_[index];
}
if (!indentation_.empty())
*sout_ << " ";
*sout_ << "]";
}
}
}
bool BuiltStyledStreamWriter::isMultilineArray(Value const& value) {
ArrayIndex const size = value.size();
bool isMultiLine = size * 3 >= rightMargin_;
childValues_.clear();
for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
Value const& childValue = value[index];
isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
!childValue.empty());
}
if (!isMultiLine) // check if line length > max line length
{
childValues_.reserve(size);
addChildValues_ = true;
ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
for (ArrayIndex index = 0; index < size; ++index) {
if (hasCommentForValue(value[index])) {
isMultiLine = true;
}
writeValue(value[index]);
lineLength += static_cast<ArrayIndex>(childValues_[index].length());
}
addChildValues_ = false;
isMultiLine = isMultiLine || lineLength >= rightMargin_;
}
return isMultiLine;
}
void BuiltStyledStreamWriter::pushValue(String const& value) {
if (addChildValues_)
childValues_.push_back(value);
else
*sout_ << value;
}
void BuiltStyledStreamWriter::writeIndent() {
// blep intended this to look at the so-far-written string
// to determine whether we are already indented, but
// with a stream we cannot do that. So we rely on some saved state.
// The caller checks indented_.
if (!indentation_.empty()) {
// In this case, drop newlines too.
*sout_ << '\n' << indentString_;
}
}
void BuiltStyledStreamWriter::writeWithIndent(String const& value) {
if (!indented_)
writeIndent();
*sout_ << value;
indented_ = false;
}
void BuiltStyledStreamWriter::indent() { indentString_ += indentation_; }
void BuiltStyledStreamWriter::unindent() {
assert(indentString_.size() >= indentation_.size());
indentString_.resize(indentString_.size() - indentation_.size());
}
void BuiltStyledStreamWriter::writeCommentBeforeValue(Value const& root) {
if (cs_ == CommentStyle::None)
return;
if (!root.hasComment(commentBefore))
return;
if (!indented_)
writeIndent();
const String& comment = root.getComment(commentBefore);
String::const_iterator iter = comment.begin();
while (iter != comment.end()) {
*sout_ << *iter;
if (*iter == '\n' && ((iter + 1) != comment.end() && *(iter + 1) == '/'))
// writeIndent(); // would write extra newline
*sout_ << indentString_;
++iter;
}
indented_ = false;
}
void BuiltStyledStreamWriter::writeCommentAfterValueOnSameLine(
Value const& root) {
if (cs_ == CommentStyle::None)
return;
if (root.hasComment(commentAfterOnSameLine))
*sout_ << " " + root.getComment(commentAfterOnSameLine);
if (root.hasComment(commentAfter)) {
writeIndent();
*sout_ << root.getComment(commentAfter);
}
}
// static
bool BuiltStyledStreamWriter::hasCommentForValue(const Value& value) {
return value.hasComment(commentBefore) ||
value.hasComment(commentAfterOnSameLine) ||
value.hasComment(commentAfter);
}
///////////////
// StreamWriter
StreamWriter::StreamWriter() : sout_(nullptr) {}
StreamWriter::~StreamWriter() = default;
StreamWriter::Factory::~Factory() = default;
StreamWriterBuilder::StreamWriterBuilder() { setDefaults(&settings_); }
StreamWriterBuilder::~StreamWriterBuilder() = default;
StreamWriter* StreamWriterBuilder::newStreamWriter() const {
const String indentation = settings_["indentation"].asString();
const String cs_str = settings_["commentStyle"].asString();
const String pt_str = settings_["precisionType"].asString();
const bool eyc = settings_["enableYAMLCompatibility"].asBool();
const bool dnp = settings_["dropNullPlaceholders"].asBool();
const bool usf = settings_["useSpecialFloats"].asBool();
const bool emitUTF8 = settings_["emitUTF8"].asBool();
unsigned int pre = settings_["precision"].asUInt();
CommentStyle::Enum cs = CommentStyle::All;
if (cs_str == "All") {
cs = CommentStyle::All;
} else if (cs_str == "None") {
cs = CommentStyle::None;
} else {
throwRuntimeError("commentStyle must be 'All' or 'None'");
}
PrecisionType precisionType(significantDigits);
if (pt_str == "significant") {
precisionType = PrecisionType::significantDigits;
} else if (pt_str == "decimal") {
precisionType = PrecisionType::decimalPlaces;
} else {
throwRuntimeError("precisionType must be 'significant' or 'decimal'");
}
String colonSymbol = " : ";
if (eyc) {
colonSymbol = ": ";
} else if (indentation.empty()) {
colonSymbol = ":";
}
String nullSymbol = "null";
if (dnp) {
nullSymbol.clear();
}
if (pre > 17)
pre = 17;
String endingLineFeedSymbol;
return new BuiltStyledStreamWriter(indentation, cs, colonSymbol, nullSymbol,
endingLineFeedSymbol, usf, emitUTF8, pre,
precisionType);
}
bool StreamWriterBuilder::validate(Json::Value* invalid) const {
static const auto& valid_keys = *new std::set<String>{
"indentation",
"commentStyle",
"enableYAMLCompatibility",
"dropNullPlaceholders",
"useSpecialFloats",
"emitUTF8",
"precision",
"precisionType",
};
for (auto si = settings_.begin(); si != settings_.end(); ++si) {
auto key = si.name();
if (valid_keys.count(key))
continue;
if (invalid)
(*invalid)[key] = *si;
else
return false;
}
return invalid ? invalid->empty() : true;
}
Value& StreamWriterBuilder::operator[](const String& key) {
return settings_[key];
}
// static
void StreamWriterBuilder::setDefaults(Json::Value* settings) {
//! [StreamWriterBuilderDefaults]
(*settings)["commentStyle"] = "All";
(*settings)["indentation"] = "\t";
(*settings)["enableYAMLCompatibility"] = false;
(*settings)["dropNullPlaceholders"] = false;
(*settings)["useSpecialFloats"] = false;
(*settings)["emitUTF8"] = false;
(*settings)["precision"] = 17;
(*settings)["precisionType"] = "significant";
//! [StreamWriterBuilderDefaults]
}
String writeString(StreamWriter::Factory const& factory, Value const& root) {
OStringStream sout;
StreamWriterPtr const writer(factory.newStreamWriter());
writer->write(root, &sout);
return sout.str();
}
OStream& operator<<(OStream& sout, Value const& root) {
StreamWriterBuilder builder;
StreamWriterPtr const writer(builder.newStreamWriter());
writer->write(root, &sout);
return sout;
}
} // namespace Json
| YifuLiu/AliOS-Things | components/jsoncpp/src/lib_json/json_writer.cpp | C++ | apache-2.0 | 37,333 |
# vim: et ts=4 sts=4 sw=4 tw=0
add_executable(jsoncpp_test
jsontest.cpp
jsontest.h
fuzz.cpp
fuzz.h
main.cpp
)
if(BUILD_SHARED_LIBS)
if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.12.0)
add_compile_definitions( JSON_DLL )
else()
add_definitions( -DJSON_DLL )
endif()
target_link_libraries(jsoncpp_test jsoncpp_lib)
else()
target_link_libraries(jsoncpp_test jsoncpp_static)
endif()
# another way to solve issue #90
#set_target_properties(jsoncpp_test PROPERTIES COMPILE_FLAGS -ffloat-store)
## Create tests for dashboard submission, allows easy review of CI results https://my.cdash.org/index.php?project=jsoncpp
add_test(NAME jsoncpp_test
COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:jsoncpp_test>
)
set_target_properties(jsoncpp_test PROPERTIES OUTPUT_NAME jsoncpp_test)
# Run unit tests in post-build
# (default cmake workflow hides away the test result into a file, resulting in poor dev workflow?!?)
if(JSONCPP_WITH_POST_BUILD_UNITTEST)
add_custom_command(TARGET jsoncpp_test
POST_BUILD
COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:jsoncpp_test>
)
endif()
| YifuLiu/AliOS-Things | components/jsoncpp/src/test_lib_json/CMakeLists.txt | CMake | apache-2.0 | 1,163 |
// Copyright 2007-2019 The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#include "fuzz.h"
#include <cstdint>
#include <json/config.h>
#include <json/json.h>
#include <memory>
#include <string>
namespace Json {
class Exception;
}
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
Json::CharReaderBuilder builder;
if (size < sizeof(uint32_t)) {
return 0;
}
const uint32_t hash_settings = static_cast<uint32_t>(data[0]) |
(static_cast<uint32_t>(data[1]) << 8) |
(static_cast<uint32_t>(data[2]) << 16) |
(static_cast<uint32_t>(data[3]) << 24);
data += sizeof(uint32_t);
size -= sizeof(uint32_t);
builder.settings_["failIfExtra"] = hash_settings & (1 << 0);
builder.settings_["allowComments_"] = hash_settings & (1 << 1);
builder.settings_["strictRoot_"] = hash_settings & (1 << 2);
builder.settings_["allowDroppedNullPlaceholders_"] = hash_settings & (1 << 3);
builder.settings_["allowNumericKeys_"] = hash_settings & (1 << 4);
builder.settings_["allowSingleQuotes_"] = hash_settings & (1 << 5);
builder.settings_["failIfExtra_"] = hash_settings & (1 << 6);
builder.settings_["rejectDupKeys_"] = hash_settings & (1 << 7);
builder.settings_["allowSpecialFloats_"] = hash_settings & (1 << 8);
builder.settings_["collectComments"] = hash_settings & (1 << 9);
builder.settings_["allowTrailingCommas_"] = hash_settings & (1 << 10);
std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
Json::Value root;
const auto data_str = reinterpret_cast<const char*>(data);
try {
reader->parse(data_str, data_str + size, &root, nullptr);
} catch (Json::Exception const&) {
}
// Whether it succeeded or not doesn't matter.
return 0;
}
| YifuLiu/AliOS-Things | components/jsoncpp/src/test_lib_json/fuzz.cpp | C++ | apache-2.0 | 1,971 |
// Copyright 2007-2010 The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#ifndef FUZZ_H_INCLUDED
#define FUZZ_H_INCLUDED
#include <cstddef>
#include <stdint.h>
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size);
#endif // ifndef FUZZ_H_INCLUDED
| YifuLiu/AliOS-Things | components/jsoncpp/src/test_lib_json/fuzz.h | C | apache-2.0 | 423 |
// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#define _CRT_SECURE_NO_WARNINGS 1 // Prevents deprecation warning with MSVC
#include "jsontest.h"
#include <cstdio>
#include <string>
#if defined(_MSC_VER)
// Used to install a report hook that prevent dialog on assertion and error.
#include <crtdbg.h>
#endif // if defined(_MSC_VER)
#if defined(_WIN32)
// Used to prevent dialog on memory fault.
// Limits headers included by Windows.h
#define WIN32_LEAN_AND_MEAN
#define NOSERVICE
#define NOMCX
#define NOIME
#define NOSOUND
#define NOCOMM
#define NORPC
#define NOGDI
#define NOUSER
#define NODRIVERS
#define NOLOGERROR
#define NOPROFILER
#define NOMEMMGR
#define NOLFILEIO
#define NOOPENFILE
#define NORESOURCE
#define NOATOM
#define NOLANGUAGE
#define NOLSTRING
#define NODBCS
#define NOKEYBOARDINFO
#define NOGDICAPMASKS
#define NOCOLOR
#define NOGDIOBJ
#define NODRAWTEXT
#define NOTEXTMETRIC
#define NOSCALABLEFONT
#define NOBITMAP
#define NORASTEROPS
#define NOMETAFILE
#define NOSYSMETRICS
#define NOSYSTEMPARAMSINFO
#define NOMSG
#define NOWINSTYLES
#define NOWINOFFSETS
#define NOSHOWWINDOW
#define NODEFERWINDOWPOS
#define NOVIRTUALKEYCODES
#define NOKEYSTATES
#define NOWH
#define NOMENUS
#define NOSCROLL
#define NOCLIPBOARD
#define NOICONS
#define NOMB
#define NOSYSCOMMANDS
#define NOMDI
#define NOCTLMGR
#define NOWINMESSAGES
#include <windows.h>
#endif // if defined(_WIN32)
namespace JsonTest {
// class TestResult
// //////////////////////////////////////////////////////////////////
TestResult::TestResult() {
// The root predicate has id 0
rootPredicateNode_.id_ = 0;
rootPredicateNode_.next_ = nullptr;
predicateStackTail_ = &rootPredicateNode_;
}
void TestResult::setTestName(const Json::String& name) { name_ = name; }
TestResult& TestResult::addFailure(const char* file, unsigned int line,
const char* expr) {
/// Walks the PredicateContext stack adding them to failures_ if not already
/// added.
unsigned int nestingLevel = 0;
PredicateContext* lastNode = rootPredicateNode_.next_;
for (; lastNode != nullptr; lastNode = lastNode->next_) {
if (lastNode->id_ > lastUsedPredicateId_) // new PredicateContext
{
lastUsedPredicateId_ = lastNode->id_;
addFailureInfo(lastNode->file_, lastNode->line_, lastNode->expr_,
nestingLevel);
// Link the PredicateContext to the failure for message target when
// popping the PredicateContext.
lastNode->failure_ = &(failures_.back());
}
++nestingLevel;
}
// Adds the failed assertion
addFailureInfo(file, line, expr, nestingLevel);
messageTarget_ = &(failures_.back());
return *this;
}
void TestResult::addFailureInfo(const char* file, unsigned int line,
const char* expr, unsigned int nestingLevel) {
Failure failure;
failure.file_ = file;
failure.line_ = line;
if (expr) {
failure.expr_ = expr;
}
failure.nestingLevel_ = nestingLevel;
failures_.push_back(failure);
}
TestResult& TestResult::popPredicateContext() {
PredicateContext* lastNode = &rootPredicateNode_;
while (lastNode->next_ != nullptr && lastNode->next_->next_ != nullptr) {
lastNode = lastNode->next_;
}
// Set message target to popped failure
PredicateContext* tail = lastNode->next_;
if (tail != nullptr && tail->failure_ != nullptr) {
messageTarget_ = tail->failure_;
}
// Remove tail from list
predicateStackTail_ = lastNode;
lastNode->next_ = nullptr;
return *this;
}
bool TestResult::failed() const { return !failures_.empty(); }
void TestResult::printFailure(bool printTestName) const {
if (failures_.empty()) {
return;
}
if (printTestName) {
printf("* Detail of %s test failure:\n", name_.c_str());
}
// Print in reverse to display the callstack in the right order
for (const auto& failure : failures_) {
Json::String indent(failure.nestingLevel_ * 2, ' ');
if (failure.file_) {
printf("%s%s(%u): ", indent.c_str(), failure.file_, failure.line_);
}
if (!failure.expr_.empty()) {
printf("%s\n", failure.expr_.c_str());
} else if (failure.file_) {
printf("\n");
}
if (!failure.message_.empty()) {
Json::String reindented = indentText(failure.message_, indent + " ");
printf("%s\n", reindented.c_str());
}
}
}
Json::String TestResult::indentText(const Json::String& text,
const Json::String& indent) {
Json::String reindented;
Json::String::size_type lastIndex = 0;
while (lastIndex < text.size()) {
Json::String::size_type nextIndex = text.find('\n', lastIndex);
if (nextIndex == Json::String::npos) {
nextIndex = text.size() - 1;
}
reindented += indent;
reindented += text.substr(lastIndex, nextIndex - lastIndex + 1);
lastIndex = nextIndex + 1;
}
return reindented;
}
TestResult& TestResult::addToLastFailure(const Json::String& message) {
if (messageTarget_ != nullptr) {
messageTarget_->message_ += message;
}
return *this;
}
TestResult& TestResult::operator<<(Json::Int64 value) {
return addToLastFailure(Json::valueToString(value));
}
TestResult& TestResult::operator<<(Json::UInt64 value) {
return addToLastFailure(Json::valueToString(value));
}
TestResult& TestResult::operator<<(bool value) {
return addToLastFailure(value ? "true" : "false");
}
// class TestCase
// //////////////////////////////////////////////////////////////////
TestCase::TestCase() = default;
TestCase::~TestCase() = default;
void TestCase::run(TestResult& result) {
result_ = &result;
runTestCase();
}
// class Runner
// //////////////////////////////////////////////////////////////////
Runner::Runner() = default;
Runner& Runner::add(TestCaseFactory factory) {
tests_.push_back(factory);
return *this;
}
size_t Runner::testCount() const { return tests_.size(); }
Json::String Runner::testNameAt(size_t index) const {
TestCase* test = tests_[index]();
Json::String name = test->testName();
delete test;
return name;
}
void Runner::runTestAt(size_t index, TestResult& result) const {
TestCase* test = tests_[index]();
result.setTestName(test->testName());
printf("Testing %s: ", test->testName());
fflush(stdout);
#if JSON_USE_EXCEPTION
try {
#endif // if JSON_USE_EXCEPTION
test->run(result);
#if JSON_USE_EXCEPTION
} catch (const std::exception& e) {
result.addFailure(__FILE__, __LINE__, "Unexpected exception caught:")
<< e.what();
}
#endif // if JSON_USE_EXCEPTION
delete test;
const char* status = result.failed() ? "FAILED" : "OK";
printf("%s\n", status);
fflush(stdout);
}
bool Runner::runAllTest(bool printSummary) const {
size_t const count = testCount();
std::deque<TestResult> failures;
for (size_t index = 0; index < count; ++index) {
TestResult result;
runTestAt(index, result);
if (result.failed()) {
failures.push_back(result);
}
}
if (failures.empty()) {
if (printSummary) {
printf("All %zu tests passed\n", count);
}
return true;
}
for (auto& result : failures) {
result.printFailure(count > 1);
}
if (printSummary) {
size_t const failedCount = failures.size();
size_t const passedCount = count - failedCount;
printf("%zu/%zu tests passed (%zu failure(s))\n", passedCount, count,
failedCount);
}
return false;
}
bool Runner::testIndex(const Json::String& testName, size_t& indexOut) const {
const size_t count = testCount();
for (size_t index = 0; index < count; ++index) {
if (testNameAt(index) == testName) {
indexOut = index;
return true;
}
}
return false;
}
void Runner::listTests() const {
const size_t count = testCount();
for (size_t index = 0; index < count; ++index) {
printf("%s\n", testNameAt(index).c_str());
}
}
int Runner::runCommandLine(int argc, const char* argv[]) const {
// typedef std::deque<String> TestNames;
Runner subrunner;
for (int index = 1; index < argc; ++index) {
Json::String opt = argv[index];
if (opt == "--list-tests") {
listTests();
return 0;
}
if (opt == "--test-auto") {
preventDialogOnCrash();
} else if (opt == "--test") {
++index;
if (index < argc) {
size_t testNameIndex;
if (testIndex(argv[index], testNameIndex)) {
subrunner.add(tests_[testNameIndex]);
} else {
fprintf(stderr, "Test '%s' does not exist!\n", argv[index]);
return 2;
}
} else {
printUsage(argv[0]);
return 2;
}
} else {
printUsage(argv[0]);
return 2;
}
}
bool succeeded;
if (subrunner.testCount() > 0) {
succeeded = subrunner.runAllTest(subrunner.testCount() > 1);
} else {
succeeded = runAllTest(true);
}
return succeeded ? 0 : 1;
}
#if defined(_MSC_VER) && defined(_DEBUG)
// Hook MSVCRT assertions to prevent dialog from appearing
static int msvcrtSilentReportHook(int reportType, char* message,
int* /*returnValue*/) {
// The default CRT handling of error and assertion is to display
// an error dialog to the user.
// Instead, when an error or an assertion occurs, we force the
// application to terminate using abort() after display
// the message on stderr.
if (reportType == _CRT_ERROR || reportType == _CRT_ASSERT) {
// calling abort() cause the ReportHook to be called
// The following is used to detect this case and let's the
// error handler fallback on its default behaviour (
// display a warning message)
static volatile bool isAborting = false;
if (isAborting) {
return TRUE;
}
isAborting = true;
fprintf(stderr, "CRT Error/Assert:\n%s\n", message);
fflush(stderr);
abort();
}
// Let's other reportType (_CRT_WARNING) be handled as they would by default
return FALSE;
}
#endif // if defined(_MSC_VER)
void Runner::preventDialogOnCrash() {
#if defined(_MSC_VER) && defined(_DEBUG)
// Install a hook to prevent MSVCRT error and assertion from
// popping a dialog
// This function a NO-OP in release configuration
// (which cause warning since msvcrtSilentReportHook is not referenced)
_CrtSetReportHook(&msvcrtSilentReportHook);
#endif // if defined(_MSC_VER)
// @todo investigate this handler (for buffer overflow)
// _set_security_error_handler
#if defined(_WIN32)
// Prevents the system from popping a dialog for debugging if the
// application fails due to invalid memory access.
SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX |
SEM_NOOPENFILEERRORBOX);
#endif // if defined(_WIN32)
}
void Runner::printUsage(const char* appName) {
printf("Usage: %s [options]\n"
"\n"
"If --test is not specified, then all the test cases be run.\n"
"\n"
"Valid options:\n"
"--list-tests: print the name of all test cases on the standard\n"
" output and exit.\n"
"--test TESTNAME: executes the test case with the specified name.\n"
" May be repeated.\n"
"--test-auto: prevent dialog prompting for debugging on crash.\n",
appName);
}
// Assertion functions
// //////////////////////////////////////////////////////////////////
Json::String ToJsonString(const char* toConvert) {
return Json::String(toConvert);
}
Json::String ToJsonString(Json::String in) { return in; }
#if JSONCPP_USING_SECURE_MEMORY
Json::String ToJsonString(std::string in) {
return Json::String(in.data(), in.data() + in.length());
}
#endif
TestResult& checkStringEqual(TestResult& result, const Json::String& expected,
const Json::String& actual, const char* file,
unsigned int line, const char* expr) {
if (expected != actual) {
result.addFailure(file, line, expr);
result << "Expected: '" << expected << "'\n";
result << "Actual : '" << actual << "'";
}
return result;
}
} // namespace JsonTest
| YifuLiu/AliOS-Things | components/jsoncpp/src/test_lib_json/jsontest.cpp | C++ | apache-2.0 | 12,268 |
// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#ifndef JSONTEST_H_INCLUDED
#define JSONTEST_H_INCLUDED
#include <cstdio>
#include <deque>
#include <iomanip>
#include <json/config.h>
#include <json/value.h>
#include <json/writer.h>
#include <sstream>
#include <string>
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// Mini Unit Testing framework
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
/** \brief Unit testing framework.
* \warning: all assertions are non-aborting, test case execution will continue
* even if an assertion namespace.
* This constraint is for portability: the framework needs to compile
* on Visual Studio 6 and must not require exception usage.
*/
namespace JsonTest {
class Failure {
public:
const char* file_;
unsigned int line_;
Json::String expr_;
Json::String message_;
unsigned int nestingLevel_;
};
/// Context used to create the assertion callstack on failure.
/// Must be a POD to allow inline initialisation without stepping
/// into the debugger.
struct PredicateContext {
using Id = unsigned int;
Id id_;
const char* file_;
unsigned int line_;
const char* expr_;
PredicateContext* next_;
/// Related Failure, set when the PredicateContext is converted
/// into a Failure.
Failure* failure_;
};
class TestResult {
public:
TestResult();
/// \internal Implementation detail for assertion macros
/// Not encapsulated to prevent step into when debugging failed assertions
/// Incremented by one on assertion predicate entry, decreased by one
/// by addPredicateContext().
PredicateContext::Id predicateId_{1};
/// \internal Implementation detail for predicate macros
PredicateContext* predicateStackTail_;
void setTestName(const Json::String& name);
/// Adds an assertion failure.
TestResult& addFailure(const char* file, unsigned int line,
const char* expr = nullptr);
/// Removes the last PredicateContext added to the predicate stack
/// chained list.
/// Next messages will be targed at the PredicateContext that was removed.
TestResult& popPredicateContext();
bool failed() const;
void printFailure(bool printTestName) const;
// Generic operator that will work with anything ostream can deal with.
template <typename T> TestResult& operator<<(const T& value) {
Json::OStringStream oss;
oss << std::setprecision(16) << std::hexfloat << value;
return addToLastFailure(oss.str());
}
// Specialized versions.
TestResult& operator<<(bool value);
// std:ostream does not support 64bits integers on all STL implementation
TestResult& operator<<(Json::Int64 value);
TestResult& operator<<(Json::UInt64 value);
private:
TestResult& addToLastFailure(const Json::String& message);
/// Adds a failure or a predicate context
void addFailureInfo(const char* file, unsigned int line, const char* expr,
unsigned int nestingLevel);
static Json::String indentText(const Json::String& text,
const Json::String& indent);
using Failures = std::deque<Failure>;
Failures failures_;
Json::String name_;
PredicateContext rootPredicateNode_;
PredicateContext::Id lastUsedPredicateId_{0};
/// Failure which is the target of the messages added using operator <<
Failure* messageTarget_{nullptr};
};
class TestCase {
public:
TestCase();
virtual ~TestCase();
void run(TestResult& result);
virtual const char* testName() const = 0;
protected:
TestResult* result_{nullptr};
private:
virtual void runTestCase() = 0;
};
/// Function pointer type for TestCase factory
using TestCaseFactory = TestCase* (*)();
class Runner {
public:
Runner();
/// Adds a test to the suite
Runner& add(TestCaseFactory factory);
/// Runs test as specified on the command-line
/// If no command-line arguments are provided, run all tests.
/// If --list-tests is provided, then print the list of all test cases
/// If --test <testname> is provided, then run test testname.
int runCommandLine(int argc, const char* argv[]) const;
/// Runs all the test cases
bool runAllTest(bool printSummary) const;
/// Returns the number of test case in the suite
size_t testCount() const;
/// Returns the name of the test case at the specified index
Json::String testNameAt(size_t index) const;
/// Runs the test case at the specified index using the specified TestResult
void runTestAt(size_t index, TestResult& result) const;
static void printUsage(const char* appName);
private: // prevents copy construction and assignment
Runner(const Runner& other) = delete;
Runner& operator=(const Runner& other) = delete;
private:
void listTests() const;
bool testIndex(const Json::String& testName, size_t& indexOut) const;
static void preventDialogOnCrash();
private:
using Factories = std::deque<TestCaseFactory>;
Factories tests_;
};
template <typename T, typename U>
TestResult& checkEqual(TestResult& result, T expected, U actual,
const char* file, unsigned int line, const char* expr) {
if (static_cast<U>(expected) != actual) {
result.addFailure(file, line, expr);
result << "Expected: " << static_cast<U>(expected) << "\n";
result << "Actual : " << actual;
}
return result;
}
Json::String ToJsonString(const char* toConvert);
Json::String ToJsonString(Json::String in);
#if JSONCPP_USING_SECURE_MEMORY
Json::String ToJsonString(std::string in);
#endif
TestResult& checkStringEqual(TestResult& result, const Json::String& expected,
const Json::String& actual, const char* file,
unsigned int line, const char* expr);
} // namespace JsonTest
/// \brief Asserts that the given expression is true.
/// JSONTEST_ASSERT( x == y ) << "x=" << x << ", y=" << y;
/// JSONTEST_ASSERT( x == y );
#define JSONTEST_ASSERT(expr) \
if (expr) { \
} else \
result_->addFailure(__FILE__, __LINE__, #expr)
/// \brief Asserts that the given predicate is true.
/// The predicate may do other assertions and be a member function of the
/// fixture.
#define JSONTEST_ASSERT_PRED(expr) \
do { \
JsonTest::PredicateContext _minitest_Context = { \
result_->predicateId_, __FILE__, __LINE__, #expr, NULL, NULL}; \
result_->predicateStackTail_->next_ = &_minitest_Context; \
result_->predicateId_ += 1; \
result_->predicateStackTail_ = &_minitest_Context; \
(expr); \
result_->popPredicateContext(); \
} while (0)
/// \brief Asserts that two values are equals.
#define JSONTEST_ASSERT_EQUAL(expected, actual) \
JsonTest::checkEqual(*result_, expected, actual, __FILE__, __LINE__, \
#expected " == " #actual)
/// \brief Asserts that two values are equals.
#define JSONTEST_ASSERT_STRING_EQUAL(expected, actual) \
JsonTest::checkStringEqual(*result_, JsonTest::ToJsonString(expected), \
JsonTest::ToJsonString(actual), __FILE__, \
__LINE__, #expected " == " #actual)
/// \brief Asserts that a given expression throws an exception
#define JSONTEST_ASSERT_THROWS(expr) \
do { \
bool _threw = false; \
try { \
expr; \
} catch (...) { \
_threw = true; \
} \
if (!_threw) \
result_->addFailure(__FILE__, __LINE__, \
"expected exception thrown: " #expr); \
} while (0)
/// \brief Begin a fixture test case.
#define JSONTEST_FIXTURE(FixtureType, name) \
class Test##FixtureType##name : public FixtureType { \
public: \
static JsonTest::TestCase* factory() { \
return new Test##FixtureType##name(); \
} \
\
public: /* overridden from TestCase */ \
const char* testName() const override { return #FixtureType "/" #name; } \
void runTestCase() override; \
}; \
\
void Test##FixtureType##name::runTestCase()
#define JSONTEST_FIXTURE_FACTORY(FixtureType, name) \
&Test##FixtureType##name::factory
#define JSONTEST_REGISTER_FIXTURE(runner, FixtureType, name) \
(runner).add(JSONTEST_FIXTURE_FACTORY(FixtureType, name))
/// \brief Begin a fixture test case.
#define JSONTEST_FIXTURE_V2(FixtureType, name, collections) \
class Test##FixtureType##name : public FixtureType { \
public: \
static JsonTest::TestCase* factory() { \
return new Test##FixtureType##name(); \
} \
static bool collect() { \
(collections).push_back(JSONTEST_FIXTURE_FACTORY(FixtureType, name)); \
return true; \
} \
\
public: /* overridden from TestCase */ \
const char* testName() const override { return #FixtureType "/" #name; } \
void runTestCase() override; \
}; \
\
static bool test##FixtureType##name##collect = \
Test##FixtureType##name::collect(); \
\
void Test##FixtureType##name::runTestCase()
#endif // ifndef JSONTEST_H_INCLUDED
| YifuLiu/AliOS-Things | components/jsoncpp/src/test_lib_json/jsontest.h | C++ | apache-2.0 | 12,005 |
// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#elif defined(_MSC_VER)
#pragma warning(disable : 4996)
#endif
#include "fuzz.h"
#include "jsontest.h"
#include <cmath>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <json/config.h>
#include <json/json.h>
#include <limits>
#include <memory>
#include <sstream>
#include <string>
using CharReaderPtr = std::unique_ptr<Json::CharReader>;
// Make numeric limits more convenient to talk about.
// Assumes int type in 32 bits.
#define kint32max Json::Value::maxInt
#define kint32min Json::Value::minInt
#define kuint32max Json::Value::maxUInt
#define kint64max Json::Value::maxInt64
#define kint64min Json::Value::minInt64
#define kuint64max Json::Value::maxUInt64
// static const double kdint64max = double(kint64max);
// static const float kfint64max = float(kint64max);
static const float kfint32max = float(kint32max);
static const float kfuint32max = float(kuint32max);
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// Json Library test cases
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
static inline double uint64ToDouble(Json::UInt64 value) {
return static_cast<double>(value);
}
#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
static inline double uint64ToDouble(Json::UInt64 value) {
return static_cast<double>(Json::Int64(value / 2)) * 2.0 +
static_cast<double>(Json::Int64(value & 1));
}
#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
// local_ is the collection for the testcases in this code file.
static std::deque<JsonTest::TestCaseFactory> local_;
#define JSONTEST_FIXTURE_LOCAL(FixtureType, name) \
JSONTEST_FIXTURE_V2(FixtureType, name, local_)
struct ValueTest : JsonTest::TestCase {
Json::Value null_;
Json::Value emptyArray_{Json::arrayValue};
Json::Value emptyObject_{Json::objectValue};
Json::Value integer_{123456789};
Json::Value unsignedInteger_{34567890};
Json::Value smallUnsignedInteger_{Json::Value::UInt(Json::Value::maxInt)};
Json::Value real_{1234.56789};
Json::Value float_{0.00390625f};
Json::Value array1_;
Json::Value object1_;
Json::Value emptyString_{""};
Json::Value string1_{"a"};
Json::Value string_{"sometext with space"};
Json::Value true_{true};
Json::Value false_{false};
ValueTest() {
array1_.append(1234);
object1_["id"] = 1234;
}
struct IsCheck {
/// Initialize all checks to \c false by default.
IsCheck();
bool isObject_{false};
bool isArray_{false};
bool isBool_{false};
bool isString_{false};
bool isNull_{false};
bool isInt_{false};
bool isInt64_{false};
bool isUInt_{false};
bool isUInt64_{false};
bool isIntegral_{false};
bool isDouble_{false};
bool isNumeric_{false};
};
void checkConstMemberCount(const Json::Value& value,
unsigned int expectedCount);
void checkMemberCount(Json::Value& value, unsigned int expectedCount);
void checkIs(const Json::Value& value, const IsCheck& check);
void checkIsLess(const Json::Value& x, const Json::Value& y);
void checkIsEqual(const Json::Value& x, const Json::Value& y);
/// Normalize the representation of floating-point number by stripped leading
/// 0 in exponent.
static Json::String normalizeFloatingPointStr(const Json::String& s);
};
Json::String ValueTest::normalizeFloatingPointStr(const Json::String& s) {
auto index = s.find_last_of("eE");
if (index == s.npos)
return s;
std::size_t signWidth = (s[index + 1] == '+' || s[index + 1] == '-') ? 1 : 0;
auto exponentStartIndex = index + 1 + signWidth;
Json::String normalized = s.substr(0, exponentStartIndex);
auto indexDigit = s.find_first_not_of('0', exponentStartIndex);
Json::String exponent = "0";
if (indexDigit != s.npos) { // nonzero exponent
exponent = s.substr(indexDigit);
}
return normalized + exponent;
}
JSONTEST_FIXTURE_LOCAL(ValueTest, checkNormalizeFloatingPointStr) {
struct TestData {
std::string in;
std::string out;
} const testData[] = {
{"0.0", "0.0"},
{"0e0", "0e0"},
{"1234.0", "1234.0"},
{"1234.0e0", "1234.0e0"},
{"1234.0e-1", "1234.0e-1"},
{"1234.0e+0", "1234.0e+0"},
{"1234.0e+001", "1234.0e+1"},
{"1234e-1", "1234e-1"},
{"1234e+000", "1234e+0"},
{"1234e+001", "1234e+1"},
{"1234e10", "1234e10"},
{"1234e010", "1234e10"},
{"1234e+010", "1234e+10"},
{"1234e-010", "1234e-10"},
{"1234e+100", "1234e+100"},
{"1234e-100", "1234e-100"},
};
for (const auto& td : testData) {
JSONTEST_ASSERT_STRING_EQUAL(normalizeFloatingPointStr(td.in), td.out);
}
}
JSONTEST_FIXTURE_LOCAL(ValueTest, memberCount) {
JSONTEST_ASSERT_PRED(checkMemberCount(emptyArray_, 0));
JSONTEST_ASSERT_PRED(checkMemberCount(emptyObject_, 0));
JSONTEST_ASSERT_PRED(checkMemberCount(array1_, 1));
JSONTEST_ASSERT_PRED(checkMemberCount(object1_, 1));
JSONTEST_ASSERT_PRED(checkMemberCount(null_, 0));
JSONTEST_ASSERT_PRED(checkMemberCount(integer_, 0));
JSONTEST_ASSERT_PRED(checkMemberCount(unsignedInteger_, 0));
JSONTEST_ASSERT_PRED(checkMemberCount(smallUnsignedInteger_, 0));
JSONTEST_ASSERT_PRED(checkMemberCount(real_, 0));
JSONTEST_ASSERT_PRED(checkMemberCount(emptyString_, 0));
JSONTEST_ASSERT_PRED(checkMemberCount(string_, 0));
JSONTEST_ASSERT_PRED(checkMemberCount(true_, 0));
JSONTEST_ASSERT_PRED(checkMemberCount(false_, 0));
JSONTEST_ASSERT_PRED(checkMemberCount(string1_, 0));
JSONTEST_ASSERT_PRED(checkMemberCount(float_, 0));
}
JSONTEST_FIXTURE_LOCAL(ValueTest, objects) {
// Types
IsCheck checks;
checks.isObject_ = true;
JSONTEST_ASSERT_PRED(checkIs(emptyObject_, checks));
JSONTEST_ASSERT_PRED(checkIs(object1_, checks));
JSONTEST_ASSERT_EQUAL(Json::objectValue, emptyObject_.type());
// Empty object okay
JSONTEST_ASSERT(emptyObject_.isConvertibleTo(Json::nullValue));
// Non-empty object not okay
JSONTEST_ASSERT(!object1_.isConvertibleTo(Json::nullValue));
// Always okay
JSONTEST_ASSERT(emptyObject_.isConvertibleTo(Json::objectValue));
// Never okay
JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::arrayValue));
JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::realValue));
JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::booleanValue));
JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::stringValue));
// Access through const reference
const Json::Value& constObject = object1_;
JSONTEST_ASSERT_EQUAL(Json::Value(1234), constObject["id"]);
JSONTEST_ASSERT_EQUAL(Json::Value(), constObject["unknown id"]);
// Access through find()
const char idKey[] = "id";
const Json::Value* foundId = object1_.find(idKey, idKey + strlen(idKey));
JSONTEST_ASSERT(foundId != nullptr);
JSONTEST_ASSERT_EQUAL(Json::Value(1234), *foundId);
const char unknownIdKey[] = "unknown id";
const Json::Value* foundUnknownId =
object1_.find(unknownIdKey, unknownIdKey + strlen(unknownIdKey));
JSONTEST_ASSERT_EQUAL(nullptr, foundUnknownId);
// Access through demand()
const char yetAnotherIdKey[] = "yet another id";
const Json::Value* foundYetAnotherId =
object1_.find(yetAnotherIdKey, yetAnotherIdKey + strlen(yetAnotherIdKey));
JSONTEST_ASSERT_EQUAL(nullptr, foundYetAnotherId);
Json::Value* demandedYetAnotherId = object1_.demand(
yetAnotherIdKey, yetAnotherIdKey + strlen(yetAnotherIdKey));
JSONTEST_ASSERT(demandedYetAnotherId != nullptr);
*demandedYetAnotherId = "baz";
JSONTEST_ASSERT_EQUAL(Json::Value("baz"), object1_["yet another id"]);
// Access through non-const reference
JSONTEST_ASSERT_EQUAL(Json::Value(1234), object1_["id"]);
JSONTEST_ASSERT_EQUAL(Json::Value(), object1_["unknown id"]);
object1_["some other id"] = "foo";
JSONTEST_ASSERT_EQUAL(Json::Value("foo"), object1_["some other id"]);
JSONTEST_ASSERT_EQUAL(Json::Value("foo"), object1_["some other id"]);
// Remove.
Json::Value got;
bool did;
did = object1_.removeMember("some other id", &got);
JSONTEST_ASSERT_EQUAL(Json::Value("foo"), got);
JSONTEST_ASSERT_EQUAL(true, did);
got = Json::Value("bar");
did = object1_.removeMember("some other id", &got);
JSONTEST_ASSERT_EQUAL(Json::Value("bar"), got);
JSONTEST_ASSERT_EQUAL(false, did);
object1_["some other id"] = "foo";
Json::Value* gotPtr = nullptr;
did = object1_.removeMember("some other id", gotPtr);
JSONTEST_ASSERT_EQUAL(nullptr, gotPtr);
JSONTEST_ASSERT_EQUAL(true, did);
// Using other removeMember interfaces, the test idea is the same as above.
object1_["some other id"] = "foo";
const Json::String key("some other id");
did = object1_.removeMember(key, &got);
JSONTEST_ASSERT_EQUAL(Json::Value("foo"), got);
JSONTEST_ASSERT_EQUAL(true, did);
got = Json::Value("bar");
did = object1_.removeMember(key, &got);
JSONTEST_ASSERT_EQUAL(Json::Value("bar"), got);
JSONTEST_ASSERT_EQUAL(false, did);
object1_["some other id"] = "foo";
object1_.removeMember(key);
JSONTEST_ASSERT_EQUAL(Json::nullValue, object1_[key]);
}
JSONTEST_FIXTURE_LOCAL(ValueTest, arrays) {
const unsigned int index0 = 0;
// Types
IsCheck checks;
checks.isArray_ = true;
JSONTEST_ASSERT_PRED(checkIs(emptyArray_, checks));
JSONTEST_ASSERT_PRED(checkIs(array1_, checks));
JSONTEST_ASSERT_EQUAL(Json::arrayValue, array1_.type());
// Empty array okay
JSONTEST_ASSERT(emptyArray_.isConvertibleTo(Json::nullValue));
// Non-empty array not okay
JSONTEST_ASSERT(!array1_.isConvertibleTo(Json::nullValue));
// Always okay
JSONTEST_ASSERT(emptyArray_.isConvertibleTo(Json::arrayValue));
// Never okay
JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::objectValue));
JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::realValue));
JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::booleanValue));
JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::stringValue));
// Access through const reference
const Json::Value& constArray = array1_;
JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[index0]);
JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[0]);
// Access through non-const reference
JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[index0]);
JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[0]);
array1_[2] = Json::Value(17);
JSONTEST_ASSERT_EQUAL(Json::Value(), array1_[1]);
JSONTEST_ASSERT_EQUAL(Json::Value(17), array1_[2]);
Json::Value got;
JSONTEST_ASSERT_EQUAL(true, array1_.removeIndex(2, &got));
JSONTEST_ASSERT_EQUAL(Json::Value(17), got);
JSONTEST_ASSERT_EQUAL(false, array1_.removeIndex(2, &got)); // gone now
}
JSONTEST_FIXTURE_LOCAL(ValueTest, resizeArray) {
Json::Value array;
{
for (Json::ArrayIndex i = 0; i < 10; i++)
array[i] = i;
JSONTEST_ASSERT_EQUAL(array.size(), 10);
// The length set is greater than the length of the array.
array.resize(15);
JSONTEST_ASSERT_EQUAL(array.size(), 15);
// The length set is less than the length of the array.
array.resize(5);
JSONTEST_ASSERT_EQUAL(array.size(), 5);
// The length of the array is set to 0.
array.resize(0);
JSONTEST_ASSERT_EQUAL(array.size(), 0);
}
{
for (Json::ArrayIndex i = 0; i < 10; i++)
array[i] = i;
JSONTEST_ASSERT_EQUAL(array.size(), 10);
array.clear();
JSONTEST_ASSERT_EQUAL(array.size(), 0);
}
}
JSONTEST_FIXTURE_LOCAL(ValueTest, getArrayValue) {
Json::Value array;
for (Json::ArrayIndex i = 0; i < 5; i++)
array[i] = i;
JSONTEST_ASSERT_EQUAL(array.size(), 5);
const Json::Value defaultValue(10);
Json::ArrayIndex index = 0;
for (; index <= 4; index++)
JSONTEST_ASSERT_EQUAL(index, array.get(index, defaultValue).asInt());
index = 4;
JSONTEST_ASSERT_EQUAL(array.isValidIndex(index), true);
index = 5;
JSONTEST_ASSERT_EQUAL(array.isValidIndex(index), false);
JSONTEST_ASSERT_EQUAL(defaultValue, array.get(index, defaultValue));
JSONTEST_ASSERT_EQUAL(array.isValidIndex(index), false);
}
JSONTEST_FIXTURE_LOCAL(ValueTest, arrayIssue252) {
int count = 5;
Json::Value root;
Json::Value item;
root["array"] = Json::Value::nullSingleton();
for (int i = 0; i < count; i++) {
item["a"] = i;
item["b"] = i;
root["array"][i] = item;
}
// JSONTEST_ASSERT_EQUAL(5, root["array"].size());
}
JSONTEST_FIXTURE_LOCAL(ValueTest, arrayInsertAtRandomIndex) {
Json::Value array;
const Json::Value str0("index2");
const Json::Value str1("index3");
array.append("index0"); // append rvalue
array.append("index1");
array.append(str0); // append lvalue
std::vector<Json::Value*> vec; // storage value address for checking
for (Json::ArrayIndex i = 0; i < 3; i++) {
vec.push_back(&array[i]);
}
JSONTEST_ASSERT_EQUAL(Json::Value("index0"), array[0]); // check append
JSONTEST_ASSERT_EQUAL(Json::Value("index1"), array[1]);
JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array[2]);
// insert lvalue at the head
JSONTEST_ASSERT(array.insert(0, str1));
JSONTEST_ASSERT_EQUAL(Json::Value("index3"), array[0]);
JSONTEST_ASSERT_EQUAL(Json::Value("index0"), array[1]);
JSONTEST_ASSERT_EQUAL(Json::Value("index1"), array[2]);
JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array[3]);
// checking address
for (Json::ArrayIndex i = 0; i < 3; i++) {
JSONTEST_ASSERT_EQUAL(vec[i], &array[i]);
}
vec.push_back(&array[3]);
// insert rvalue at middle
JSONTEST_ASSERT(array.insert(2, "index4"));
JSONTEST_ASSERT_EQUAL(Json::Value("index3"), array[0]);
JSONTEST_ASSERT_EQUAL(Json::Value("index0"), array[1]);
JSONTEST_ASSERT_EQUAL(Json::Value("index4"), array[2]);
JSONTEST_ASSERT_EQUAL(Json::Value("index1"), array[3]);
JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array[4]);
// checking address
for (Json::ArrayIndex i = 0; i < 4; i++) {
JSONTEST_ASSERT_EQUAL(vec[i], &array[i]);
}
vec.push_back(&array[4]);
// insert rvalue at the tail
JSONTEST_ASSERT(array.insert(5, "index5"));
JSONTEST_ASSERT_EQUAL(Json::Value("index3"), array[0]);
JSONTEST_ASSERT_EQUAL(Json::Value("index0"), array[1]);
JSONTEST_ASSERT_EQUAL(Json::Value("index4"), array[2]);
JSONTEST_ASSERT_EQUAL(Json::Value("index1"), array[3]);
JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array[4]);
JSONTEST_ASSERT_EQUAL(Json::Value("index5"), array[5]);
// checking address
for (Json::ArrayIndex i = 0; i < 5; i++) {
JSONTEST_ASSERT_EQUAL(vec[i], &array[i]);
}
vec.push_back(&array[5]);
// beyond max array size, it should not be allowed to insert into its tail
JSONTEST_ASSERT(!array.insert(10, "index10"));
}
JSONTEST_FIXTURE_LOCAL(ValueTest, null) {
JSONTEST_ASSERT_EQUAL(Json::nullValue, null_.type());
IsCheck checks;
checks.isNull_ = true;
JSONTEST_ASSERT_PRED(checkIs(null_, checks));
JSONTEST_ASSERT(null_.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(null_.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(null_.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT(null_.isConvertibleTo(Json::realValue));
JSONTEST_ASSERT(null_.isConvertibleTo(Json::booleanValue));
JSONTEST_ASSERT(null_.isConvertibleTo(Json::stringValue));
JSONTEST_ASSERT(null_.isConvertibleTo(Json::arrayValue));
JSONTEST_ASSERT(null_.isConvertibleTo(Json::objectValue));
JSONTEST_ASSERT_EQUAL(Json::Int(0), null_.asInt());
JSONTEST_ASSERT_EQUAL(Json::LargestInt(0), null_.asLargestInt());
JSONTEST_ASSERT_EQUAL(Json::UInt(0), null_.asUInt());
JSONTEST_ASSERT_EQUAL(Json::LargestUInt(0), null_.asLargestUInt());
JSONTEST_ASSERT_EQUAL(0.0, null_.asDouble());
JSONTEST_ASSERT_EQUAL(0.0, null_.asFloat());
JSONTEST_ASSERT_STRING_EQUAL("", null_.asString());
JSONTEST_ASSERT_EQUAL(Json::Value::nullSingleton(), null_);
// Test using a Value in a boolean context (false iff null)
JSONTEST_ASSERT_EQUAL(null_, false);
JSONTEST_ASSERT_EQUAL(object1_, true);
JSONTEST_ASSERT_EQUAL(!null_, true);
JSONTEST_ASSERT_EQUAL(!object1_, false);
}
JSONTEST_FIXTURE_LOCAL(ValueTest, strings) {
JSONTEST_ASSERT_EQUAL(Json::stringValue, string1_.type());
IsCheck checks;
checks.isString_ = true;
JSONTEST_ASSERT_PRED(checkIs(emptyString_, checks));
JSONTEST_ASSERT_PRED(checkIs(string_, checks));
JSONTEST_ASSERT_PRED(checkIs(string1_, checks));
// Empty string okay
JSONTEST_ASSERT(emptyString_.isConvertibleTo(Json::nullValue));
// Non-empty string not okay
JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::nullValue));
// Always okay
JSONTEST_ASSERT(string1_.isConvertibleTo(Json::stringValue));
// Never okay
JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::objectValue));
JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::arrayValue));
JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::realValue));
JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asString());
JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asCString());
}
JSONTEST_FIXTURE_LOCAL(ValueTest, bools) {
JSONTEST_ASSERT_EQUAL(Json::booleanValue, false_.type());
IsCheck checks;
checks.isBool_ = true;
JSONTEST_ASSERT_PRED(checkIs(false_, checks));
JSONTEST_ASSERT_PRED(checkIs(true_, checks));
// False okay
JSONTEST_ASSERT(false_.isConvertibleTo(Json::nullValue));
// True not okay
JSONTEST_ASSERT(!true_.isConvertibleTo(Json::nullValue));
// Always okay
JSONTEST_ASSERT(true_.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(true_.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT(true_.isConvertibleTo(Json::realValue));
JSONTEST_ASSERT(true_.isConvertibleTo(Json::booleanValue));
JSONTEST_ASSERT(true_.isConvertibleTo(Json::stringValue));
// Never okay
JSONTEST_ASSERT(!true_.isConvertibleTo(Json::arrayValue));
JSONTEST_ASSERT(!true_.isConvertibleTo(Json::objectValue));
JSONTEST_ASSERT_EQUAL(true, true_.asBool());
JSONTEST_ASSERT_EQUAL(1, true_.asInt());
JSONTEST_ASSERT_EQUAL(1, true_.asLargestInt());
JSONTEST_ASSERT_EQUAL(1, true_.asUInt());
JSONTEST_ASSERT_EQUAL(1, true_.asLargestUInt());
JSONTEST_ASSERT_EQUAL(1.0, true_.asDouble());
JSONTEST_ASSERT_EQUAL(1.0, true_.asFloat());
JSONTEST_ASSERT_EQUAL(false, false_.asBool());
JSONTEST_ASSERT_EQUAL(0, false_.asInt());
JSONTEST_ASSERT_EQUAL(0, false_.asLargestInt());
JSONTEST_ASSERT_EQUAL(0, false_.asUInt());
JSONTEST_ASSERT_EQUAL(0, false_.asLargestUInt());
JSONTEST_ASSERT_EQUAL(0.0, false_.asDouble());
JSONTEST_ASSERT_EQUAL(0.0, false_.asFloat());
}
JSONTEST_FIXTURE_LOCAL(ValueTest, integers) {
IsCheck checks;
Json::Value val;
// Conversions that don't depend on the value.
JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::realValue));
JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::stringValue));
JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::booleanValue));
JSONTEST_ASSERT(!Json::Value(17).isConvertibleTo(Json::arrayValue));
JSONTEST_ASSERT(!Json::Value(17).isConvertibleTo(Json::objectValue));
JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::realValue));
JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::stringValue));
JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::booleanValue));
JSONTEST_ASSERT(!Json::Value(17U).isConvertibleTo(Json::arrayValue));
JSONTEST_ASSERT(!Json::Value(17U).isConvertibleTo(Json::objectValue));
JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::realValue));
JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::stringValue));
JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::booleanValue));
JSONTEST_ASSERT(!Json::Value(17.0).isConvertibleTo(Json::arrayValue));
JSONTEST_ASSERT(!Json::Value(17.0).isConvertibleTo(Json::objectValue));
// Default int
val = Json::Value(Json::intValue);
JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
checks = IsCheck();
checks.isInt_ = true;
checks.isInt64_ = true;
checks.isUInt_ = true;
checks.isUInt64_ = true;
checks.isIntegral_ = true;
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL(0, val.asInt());
JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
JSONTEST_ASSERT_EQUAL(0, val.asUInt());
JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
JSONTEST_ASSERT_EQUAL(false, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
// Default uint
val = Json::Value(Json::uintValue);
JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
checks = IsCheck();
checks.isInt_ = true;
checks.isInt64_ = true;
checks.isUInt_ = true;
checks.isUInt64_ = true;
checks.isIntegral_ = true;
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL(0, val.asInt());
JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
JSONTEST_ASSERT_EQUAL(0, val.asUInt());
JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
JSONTEST_ASSERT_EQUAL(false, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
// Default real
val = Json::Value(Json::realValue);
JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
checks = IsCheck();
checks.isInt_ = true;
checks.isInt64_ = true;
checks.isUInt_ = true;
checks.isUInt64_ = true;
checks.isIntegral_ = true;
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT_EQUAL(0, val.asInt());
JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
JSONTEST_ASSERT_EQUAL(0, val.asUInt());
JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
JSONTEST_ASSERT_EQUAL(false, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL("0.0", val.asString());
// Zero (signed constructor arg)
val = Json::Value(0);
JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
checks = IsCheck();
checks.isInt_ = true;
checks.isInt64_ = true;
checks.isUInt_ = true;
checks.isUInt64_ = true;
checks.isIntegral_ = true;
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL(0, val.asInt());
JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
JSONTEST_ASSERT_EQUAL(0, val.asUInt());
JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
JSONTEST_ASSERT_EQUAL(false, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
// Zero (unsigned constructor arg)
val = Json::Value(0u);
JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
checks = IsCheck();
checks.isInt_ = true;
checks.isInt64_ = true;
checks.isUInt_ = true;
checks.isUInt64_ = true;
checks.isIntegral_ = true;
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL(0, val.asInt());
JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
JSONTEST_ASSERT_EQUAL(0, val.asUInt());
JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
JSONTEST_ASSERT_EQUAL(false, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
// Zero (floating-point constructor arg)
val = Json::Value(0.0);
JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isInt_ = true;
checks.isInt64_ = true;
checks.isUInt_ = true;
checks.isUInt64_ = true;
checks.isIntegral_ = true;
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL(0, val.asInt());
JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
JSONTEST_ASSERT_EQUAL(0, val.asUInt());
JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
JSONTEST_ASSERT_EQUAL(false, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL("0.0", val.asString());
// 2^20 (signed constructor arg)
val = Json::Value(1 << 20);
JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
checks = IsCheck();
checks.isInt_ = true;
checks.isInt64_ = true;
checks.isUInt_ = true;
checks.isUInt64_ = true;
checks.isIntegral_ = true;
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL("1048576", val.asString());
// 2^20 (unsigned constructor arg)
val = Json::Value(Json::UInt(1 << 20));
JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
checks = IsCheck();
checks.isInt_ = true;
checks.isInt64_ = true;
checks.isUInt_ = true;
checks.isUInt64_ = true;
checks.isIntegral_ = true;
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL("1048576", val.asString());
// 2^20 (floating-point constructor arg)
val = Json::Value((1 << 20) / 1.0);
JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isInt_ = true;
checks.isInt64_ = true;
checks.isUInt_ = true;
checks.isUInt64_ = true;
checks.isIntegral_ = true;
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL(
"1048576.0",
normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
// -2^20
val = Json::Value(-(1 << 20));
JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
checks = IsCheck();
checks.isInt_ = true;
checks.isInt64_ = true;
checks.isIntegral_ = true;
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asInt());
JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asLargestInt());
JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asDouble());
JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL("-1048576", val.asString());
// int32 max
val = Json::Value(kint32max);
JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
checks = IsCheck();
checks.isInt_ = true;
checks.isInt64_ = true;
checks.isUInt_ = true;
checks.isUInt64_ = true;
checks.isIntegral_ = true;
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL(kint32max, val.asInt());
JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestInt());
JSONTEST_ASSERT_EQUAL(kint32max, val.asUInt());
JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestUInt());
JSONTEST_ASSERT_EQUAL(kint32max, val.asDouble());
JSONTEST_ASSERT_EQUAL(kfint32max, val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL("2147483647", val.asString());
// int32 min
val = Json::Value(kint32min);
JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
checks = IsCheck();
checks.isInt_ = true;
checks.isInt64_ = true;
checks.isIntegral_ = true;
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL(kint32min, val.asInt());
JSONTEST_ASSERT_EQUAL(kint32min, val.asLargestInt());
JSONTEST_ASSERT_EQUAL(kint32min, val.asDouble());
JSONTEST_ASSERT_EQUAL(kint32min, val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL("-2147483648", val.asString());
// uint32 max
val = Json::Value(kuint32max);
JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
checks = IsCheck();
checks.isInt64_ = true;
checks.isUInt_ = true;
checks.isUInt64_ = true;
checks.isIntegral_ = true;
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
#ifndef JSON_NO_INT64
JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestInt());
#endif
JSONTEST_ASSERT_EQUAL(kuint32max, val.asUInt());
JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestUInt());
JSONTEST_ASSERT_EQUAL(kuint32max, val.asDouble());
JSONTEST_ASSERT_EQUAL(kfuint32max, val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL("4294967295", val.asString());
#ifdef JSON_NO_INT64
// int64 max
val = Json::Value(double(kint64max));
JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL(double(kint64max), val.asDouble());
JSONTEST_ASSERT_EQUAL(float(kint64max), val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL("9.22337e+18", val.asString());
// int64 min
val = Json::Value(double(kint64min));
JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL(double(kint64min), val.asDouble());
JSONTEST_ASSERT_EQUAL(float(kint64min), val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL("-9.22337e+18", val.asString());
// uint64 max
val = Json::Value(double(kuint64max));
JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL(double(kuint64max), val.asDouble());
JSONTEST_ASSERT_EQUAL(float(kuint64max), val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL("1.84467e+19", val.asString());
#else // ifdef JSON_NO_INT64
// 2^40 (signed constructor arg)
val = Json::Value(Json::Int64(1) << 40);
JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
checks = IsCheck();
checks.isInt64_ = true;
checks.isUInt64_ = true;
checks.isIntegral_ = true;
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL("1099511627776", val.asString());
// 2^40 (unsigned constructor arg)
val = Json::Value(Json::UInt64(1) << 40);
JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
checks = IsCheck();
checks.isInt64_ = true;
checks.isUInt64_ = true;
checks.isIntegral_ = true;
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL("1099511627776", val.asString());
// 2^40 (floating-point constructor arg)
val = Json::Value((Json::Int64(1) << 40) / 1.0);
JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isInt64_ = true;
checks.isUInt64_ = true;
checks.isIntegral_ = true;
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL(
"1099511627776.0",
normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
// -2^40
val = Json::Value(-(Json::Int64(1) << 40));
JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
checks = IsCheck();
checks.isInt64_ = true;
checks.isIntegral_ = true;
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asInt64());
JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asLargestInt());
JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asDouble());
JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL("-1099511627776", val.asString());
// int64 max
val = Json::Value(Json::Int64(kint64max));
JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
checks = IsCheck();
checks.isInt64_ = true;
checks.isUInt64_ = true;
checks.isIntegral_ = true;
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL(kint64max, val.asInt64());
JSONTEST_ASSERT_EQUAL(kint64max, val.asLargestInt());
JSONTEST_ASSERT_EQUAL(kint64max, val.asUInt64());
JSONTEST_ASSERT_EQUAL(kint64max, val.asLargestUInt());
JSONTEST_ASSERT_EQUAL(double(kint64max), val.asDouble());
JSONTEST_ASSERT_EQUAL(float(kint64max), val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL("9223372036854775807", val.asString());
// int64 max (floating point constructor). Note that kint64max is not exactly
// representable as a double, and will be rounded up to be higher.
val = Json::Value(double(kint64max));
JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isUInt64_ = true;
checks.isIntegral_ = true;
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL(Json::UInt64(1) << 63, val.asUInt64());
JSONTEST_ASSERT_EQUAL(Json::UInt64(1) << 63, val.asLargestUInt());
JSONTEST_ASSERT_EQUAL(uint64ToDouble(Json::UInt64(1) << 63), val.asDouble());
JSONTEST_ASSERT_EQUAL(float(Json::UInt64(1) << 63), val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL(
"9.2233720368547758e+18",
normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
// int64 min
val = Json::Value(Json::Int64(kint64min));
JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
checks = IsCheck();
checks.isInt64_ = true;
checks.isIntegral_ = true;
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL(kint64min, val.asInt64());
JSONTEST_ASSERT_EQUAL(kint64min, val.asLargestInt());
JSONTEST_ASSERT_EQUAL(double(kint64min), val.asDouble());
JSONTEST_ASSERT_EQUAL(float(kint64min), val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL("-9223372036854775808", val.asString());
// int64 min (floating point constructor). Note that kint64min *is* exactly
// representable as a double.
val = Json::Value(double(kint64min));
JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isInt64_ = true;
checks.isIntegral_ = true;
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL(kint64min, val.asInt64());
JSONTEST_ASSERT_EQUAL(kint64min, val.asLargestInt());
JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asDouble());
JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL(
"-9.2233720368547758e+18",
normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
// 10^19
const auto ten_to_19 = static_cast<Json::UInt64>(1e19);
val = Json::Value(Json::UInt64(ten_to_19));
JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
checks = IsCheck();
checks.isUInt64_ = true;
checks.isIntegral_ = true;
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL(ten_to_19, val.asUInt64());
JSONTEST_ASSERT_EQUAL(ten_to_19, val.asLargestUInt());
JSONTEST_ASSERT_EQUAL(uint64ToDouble(ten_to_19), val.asDouble());
JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(ten_to_19)), val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL("10000000000000000000", val.asString());
// 10^19 (double constructor). Note that 10^19 is not exactly representable
// as a double.
val = Json::Value(uint64ToDouble(ten_to_19));
JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isUInt64_ = true;
checks.isIntegral_ = true;
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL(1e19, val.asDouble());
JSONTEST_ASSERT_EQUAL(1e19, val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL(
"1e+19",
normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
// uint64 max
val = Json::Value(Json::UInt64(kuint64max));
JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
checks = IsCheck();
checks.isUInt64_ = true;
checks.isIntegral_ = true;
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL(kuint64max, val.asUInt64());
JSONTEST_ASSERT_EQUAL(kuint64max, val.asLargestUInt());
JSONTEST_ASSERT_EQUAL(uint64ToDouble(kuint64max), val.asDouble());
JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(kuint64max)), val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL("18446744073709551615", val.asString());
// uint64 max (floating point constructor). Note that kuint64max is not
// exactly representable as a double, and will be rounded up to be higher.
val = Json::Value(uint64ToDouble(kuint64max));
JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asDouble());
JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asFloat());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_STRING_EQUAL(
"1.8446744073709552e+19",
normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
#endif
}
JSONTEST_FIXTURE_LOCAL(ValueTest, nonIntegers) {
IsCheck checks;
Json::Value val;
// Small positive number
val = Json::Value(1.5);
JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
JSONTEST_ASSERT_EQUAL(1.5, val.asDouble());
JSONTEST_ASSERT_EQUAL(1.5, val.asFloat());
JSONTEST_ASSERT_EQUAL(1, val.asInt());
JSONTEST_ASSERT_EQUAL(1, val.asLargestInt());
JSONTEST_ASSERT_EQUAL(1, val.asUInt());
JSONTEST_ASSERT_EQUAL(1, val.asLargestUInt());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_EQUAL("1.5", val.asString());
// Small negative number
val = Json::Value(-1.5);
JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
JSONTEST_ASSERT_EQUAL(-1.5, val.asDouble());
JSONTEST_ASSERT_EQUAL(-1.5, val.asFloat());
JSONTEST_ASSERT_EQUAL(-1, val.asInt());
JSONTEST_ASSERT_EQUAL(-1, val.asLargestInt());
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_EQUAL("-1.5", val.asString());
// A bit over int32 max
val = Json::Value(kint32max + 0.5);
JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
JSONTEST_ASSERT_EQUAL(2147483647.5, val.asDouble());
JSONTEST_ASSERT_EQUAL(float(2147483647.5), val.asFloat());
JSONTEST_ASSERT_EQUAL(2147483647U, val.asUInt());
#ifdef JSON_HAS_INT64
JSONTEST_ASSERT_EQUAL(2147483647L, val.asLargestInt());
JSONTEST_ASSERT_EQUAL(2147483647U, val.asLargestUInt());
#endif
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_EQUAL(
"2147483647.5",
normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
// A bit under int32 min
val = Json::Value(kint32min - 0.5);
JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
JSONTEST_ASSERT_EQUAL(-2147483648.5, val.asDouble());
JSONTEST_ASSERT_EQUAL(float(-2147483648.5), val.asFloat());
#ifdef JSON_HAS_INT64
JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 31), val.asLargestInt());
#endif
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_EQUAL(
"-2147483648.5",
normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
// A bit over uint32 max
val = Json::Value(kuint32max + 0.5);
JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
checks = IsCheck();
checks.isDouble_ = true;
checks.isNumeric_ = true;
JSONTEST_ASSERT_PRED(checkIs(val, checks));
JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
JSONTEST_ASSERT_EQUAL(4294967295.5, val.asDouble());
JSONTEST_ASSERT_EQUAL(float(4294967295.5), val.asFloat());
#ifdef JSON_HAS_INT64
JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 32) - 1, val.asLargestInt());
JSONTEST_ASSERT_EQUAL((Json::UInt64(1) << 32) - Json::UInt64(1),
val.asLargestUInt());
#endif
JSONTEST_ASSERT_EQUAL(true, val.asBool());
JSONTEST_ASSERT_EQUAL(
"4294967295.5",
normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
val = Json::Value(1.2345678901234);
JSONTEST_ASSERT_STRING_EQUAL(
"1.2345678901234001",
normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
// A 16-digit floating point number.
val = Json::Value(2199023255552000.0f);
JSONTEST_ASSERT_EQUAL(float(2199023255552000.0f), val.asFloat());
JSONTEST_ASSERT_STRING_EQUAL(
"2199023255552000.0",
normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
// A very large floating point number.
val = Json::Value(3.402823466385289e38);
JSONTEST_ASSERT_EQUAL(float(3.402823466385289e38), val.asFloat());
JSONTEST_ASSERT_STRING_EQUAL(
"3.402823466385289e+38",
normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
// An even larger floating point number.
val = Json::Value(1.2345678e300);
JSONTEST_ASSERT_EQUAL(double(1.2345678e300), val.asDouble());
JSONTEST_ASSERT_STRING_EQUAL(
"1.2345678e+300",
normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
}
void ValueTest::checkConstMemberCount(const Json::Value& value,
unsigned int expectedCount) {
unsigned int count = 0;
Json::Value::const_iterator itEnd = value.end();
for (Json::Value::const_iterator it = value.begin(); it != itEnd; ++it) {
++count;
}
JSONTEST_ASSERT_EQUAL(expectedCount, count) << "Json::Value::const_iterator";
}
void ValueTest::checkMemberCount(Json::Value& value,
unsigned int expectedCount) {
JSONTEST_ASSERT_EQUAL(expectedCount, value.size());
unsigned int count = 0;
Json::Value::iterator itEnd = value.end();
for (Json::Value::iterator it = value.begin(); it != itEnd; ++it) {
++count;
}
JSONTEST_ASSERT_EQUAL(expectedCount, count) << "Json::Value::iterator";
JSONTEST_ASSERT_PRED(checkConstMemberCount(value, expectedCount));
}
ValueTest::IsCheck::IsCheck() = default;
void ValueTest::checkIs(const Json::Value& value, const IsCheck& check) {
JSONTEST_ASSERT_EQUAL(check.isObject_, value.isObject());
JSONTEST_ASSERT_EQUAL(check.isArray_, value.isArray());
JSONTEST_ASSERT_EQUAL(check.isBool_, value.isBool());
JSONTEST_ASSERT_EQUAL(check.isDouble_, value.isDouble());
JSONTEST_ASSERT_EQUAL(check.isInt_, value.isInt());
JSONTEST_ASSERT_EQUAL(check.isUInt_, value.isUInt());
JSONTEST_ASSERT_EQUAL(check.isIntegral_, value.isIntegral());
JSONTEST_ASSERT_EQUAL(check.isNumeric_, value.isNumeric());
JSONTEST_ASSERT_EQUAL(check.isString_, value.isString());
JSONTEST_ASSERT_EQUAL(check.isNull_, value.isNull());
#ifdef JSON_HAS_INT64
JSONTEST_ASSERT_EQUAL(check.isInt64_, value.isInt64());
JSONTEST_ASSERT_EQUAL(check.isUInt64_, value.isUInt64());
#else
JSONTEST_ASSERT_EQUAL(false, value.isInt64());
JSONTEST_ASSERT_EQUAL(false, value.isUInt64());
#endif
}
JSONTEST_FIXTURE_LOCAL(ValueTest, compareNull) {
JSONTEST_ASSERT_PRED(checkIsEqual(Json::Value(), Json::Value()));
JSONTEST_ASSERT_PRED(
checkIsEqual(Json::Value::nullSingleton(), Json::Value()));
JSONTEST_ASSERT_PRED(
checkIsEqual(Json::Value::nullSingleton(), Json::Value::nullSingleton()));
}
JSONTEST_FIXTURE_LOCAL(ValueTest, compareInt) {
JSONTEST_ASSERT_PRED(checkIsLess(0, 10));
JSONTEST_ASSERT_PRED(checkIsEqual(10, 10));
JSONTEST_ASSERT_PRED(checkIsEqual(-10, -10));
JSONTEST_ASSERT_PRED(checkIsLess(-10, 0));
}
JSONTEST_FIXTURE_LOCAL(ValueTest, compareUInt) {
JSONTEST_ASSERT_PRED(checkIsLess(0u, 10u));
JSONTEST_ASSERT_PRED(checkIsLess(0u, Json::Value::maxUInt));
JSONTEST_ASSERT_PRED(checkIsEqual(10u, 10u));
}
JSONTEST_FIXTURE_LOCAL(ValueTest, compareDouble) {
JSONTEST_ASSERT_PRED(checkIsLess(0.0, 10.0));
JSONTEST_ASSERT_PRED(checkIsEqual(10.0, 10.0));
JSONTEST_ASSERT_PRED(checkIsEqual(-10.0, -10.0));
JSONTEST_ASSERT_PRED(checkIsLess(-10.0, 0.0));
}
JSONTEST_FIXTURE_LOCAL(ValueTest, compareString) {
JSONTEST_ASSERT_PRED(checkIsLess("", " "));
JSONTEST_ASSERT_PRED(checkIsLess("", "a"));
JSONTEST_ASSERT_PRED(checkIsLess("abcd", "zyui"));
JSONTEST_ASSERT_PRED(checkIsLess("abc", "abcd"));
JSONTEST_ASSERT_PRED(checkIsEqual("abcd", "abcd"));
JSONTEST_ASSERT_PRED(checkIsEqual(" ", " "));
JSONTEST_ASSERT_PRED(checkIsLess("ABCD", "abcd"));
JSONTEST_ASSERT_PRED(checkIsEqual("ABCD", "ABCD"));
}
JSONTEST_FIXTURE_LOCAL(ValueTest, compareBoolean) {
JSONTEST_ASSERT_PRED(checkIsLess(false, true));
JSONTEST_ASSERT_PRED(checkIsEqual(false, false));
JSONTEST_ASSERT_PRED(checkIsEqual(true, true));
}
JSONTEST_FIXTURE_LOCAL(ValueTest, compareArray) {
// array compare size then content
Json::Value emptyArray(Json::arrayValue);
Json::Value l1aArray;
l1aArray.append(0);
Json::Value l1bArray;
l1bArray.append(10);
Json::Value l2aArray;
l2aArray.append(0);
l2aArray.append(0);
Json::Value l2bArray;
l2bArray.append(0);
l2bArray.append(10);
JSONTEST_ASSERT_PRED(checkIsLess(emptyArray, l1aArray));
JSONTEST_ASSERT_PRED(checkIsLess(emptyArray, l2aArray));
JSONTEST_ASSERT_PRED(checkIsLess(l1aArray, l1bArray));
JSONTEST_ASSERT_PRED(checkIsLess(l1bArray, l2aArray));
JSONTEST_ASSERT_PRED(checkIsLess(l2aArray, l2bArray));
JSONTEST_ASSERT_PRED(checkIsEqual(emptyArray, Json::Value(emptyArray)));
JSONTEST_ASSERT_PRED(checkIsEqual(l1aArray, Json::Value(l1aArray)));
JSONTEST_ASSERT_PRED(checkIsEqual(l1bArray, Json::Value(l1bArray)));
JSONTEST_ASSERT_PRED(checkIsEqual(l2aArray, Json::Value(l2aArray)));
JSONTEST_ASSERT_PRED(checkIsEqual(l2bArray, Json::Value(l2bArray)));
}
JSONTEST_FIXTURE_LOCAL(ValueTest, compareObject) {
// object compare size then content
Json::Value emptyObject(Json::objectValue);
Json::Value l1aObject;
l1aObject["key1"] = 0;
Json::Value l1bObject;
l1bObject["key1"] = 10;
Json::Value l2aObject;
l2aObject["key1"] = 0;
l2aObject["key2"] = 0;
Json::Value l2bObject;
l2bObject["key1"] = 10;
l2bObject["key2"] = 0;
JSONTEST_ASSERT_PRED(checkIsLess(emptyObject, l1aObject));
JSONTEST_ASSERT_PRED(checkIsLess(l1aObject, l1bObject));
JSONTEST_ASSERT_PRED(checkIsLess(l1bObject, l2aObject));
JSONTEST_ASSERT_PRED(checkIsLess(l2aObject, l2bObject));
JSONTEST_ASSERT_PRED(checkIsEqual(emptyObject, Json::Value(emptyObject)));
JSONTEST_ASSERT_PRED(checkIsEqual(l1aObject, Json::Value(l1aObject)));
JSONTEST_ASSERT_PRED(checkIsEqual(l1bObject, Json::Value(l1bObject)));
JSONTEST_ASSERT_PRED(checkIsEqual(l2aObject, Json::Value(l2aObject)));
JSONTEST_ASSERT_PRED(checkIsEqual(l2bObject, Json::Value(l2bObject)));
{
Json::Value aObject;
aObject["a"] = 10;
Json::Value bObject;
bObject["b"] = 0;
Json::Value cObject;
cObject["c"] = 20;
cObject["f"] = 15;
Json::Value dObject;
dObject["d"] = -2;
dObject["e"] = 10;
JSONTEST_ASSERT_PRED(checkIsLess(aObject, bObject));
JSONTEST_ASSERT_PRED(checkIsLess(bObject, cObject));
JSONTEST_ASSERT_PRED(checkIsLess(cObject, dObject));
JSONTEST_ASSERT_PRED(checkIsEqual(aObject, Json::Value(aObject)));
JSONTEST_ASSERT_PRED(checkIsEqual(bObject, Json::Value(bObject)));
JSONTEST_ASSERT_PRED(checkIsEqual(cObject, Json::Value(cObject)));
JSONTEST_ASSERT_PRED(checkIsEqual(dObject, Json::Value(dObject)));
}
}
JSONTEST_FIXTURE_LOCAL(ValueTest, compareType) {
// object of different type are ordered according to their type
JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(), Json::Value(1)));
JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(1), Json::Value(1u)));
JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(1u), Json::Value(1.0)));
JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(1.0), Json::Value("a")));
JSONTEST_ASSERT_PRED(checkIsLess(Json::Value("a"), Json::Value(true)));
JSONTEST_ASSERT_PRED(
checkIsLess(Json::Value(true), Json::Value(Json::arrayValue)));
JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(Json::arrayValue),
Json::Value(Json::objectValue)));
}
JSONTEST_FIXTURE_LOCAL(ValueTest, CopyObject) {
Json::Value arrayVal;
arrayVal.append("val1");
arrayVal.append("val2");
arrayVal.append("val3");
Json::Value stringVal("string value");
Json::Value copy1, copy2;
{
Json::Value arrayCopy, stringCopy;
arrayCopy.copy(arrayVal);
stringCopy.copy(stringVal);
JSONTEST_ASSERT_PRED(checkIsEqual(arrayCopy, arrayVal));
JSONTEST_ASSERT_PRED(checkIsEqual(stringCopy, stringVal));
arrayCopy.append("val4");
JSONTEST_ASSERT(arrayCopy.size() == 4);
arrayVal.append("new4");
arrayVal.append("new5");
JSONTEST_ASSERT(arrayVal.size() == 5);
JSONTEST_ASSERT(!(arrayCopy == arrayVal));
stringCopy = "another string";
JSONTEST_ASSERT(!(stringCopy == stringVal));
copy1.copy(arrayCopy);
copy2.copy(stringCopy);
}
JSONTEST_ASSERT(arrayVal.size() == 5);
JSONTEST_ASSERT(stringVal == "string value");
JSONTEST_ASSERT(copy1.size() == 4);
JSONTEST_ASSERT(copy2 == "another string");
copy1.copy(stringVal);
JSONTEST_ASSERT(copy1 == "string value");
copy2.copy(arrayVal);
JSONTEST_ASSERT(copy2.size() == 5);
{
Json::Value srcObject, objectCopy, otherObject;
srcObject["key0"] = 10;
objectCopy.copy(srcObject);
JSONTEST_ASSERT(srcObject["key0"] == 10);
JSONTEST_ASSERT(objectCopy["key0"] == 10);
JSONTEST_ASSERT(srcObject.getMemberNames().size() == 1);
JSONTEST_ASSERT(objectCopy.getMemberNames().size() == 1);
otherObject["key1"] = 15;
otherObject["key2"] = 16;
JSONTEST_ASSERT(otherObject.getMemberNames().size() == 2);
objectCopy.copy(otherObject);
JSONTEST_ASSERT(objectCopy["key1"] == 15);
JSONTEST_ASSERT(objectCopy["key2"] == 16);
JSONTEST_ASSERT(objectCopy.getMemberNames().size() == 2);
otherObject["key1"] = 20;
JSONTEST_ASSERT(objectCopy["key1"] == 15);
}
}
void ValueTest::checkIsLess(const Json::Value& x, const Json::Value& y) {
JSONTEST_ASSERT(x < y);
JSONTEST_ASSERT(y > x);
JSONTEST_ASSERT(x <= y);
JSONTEST_ASSERT(y >= x);
JSONTEST_ASSERT(!(x == y));
JSONTEST_ASSERT(!(y == x));
JSONTEST_ASSERT(!(x >= y));
JSONTEST_ASSERT(!(y <= x));
JSONTEST_ASSERT(!(x > y));
JSONTEST_ASSERT(!(y < x));
JSONTEST_ASSERT(x.compare(y) < 0);
JSONTEST_ASSERT(y.compare(x) >= 0);
}
void ValueTest::checkIsEqual(const Json::Value& x, const Json::Value& y) {
JSONTEST_ASSERT(x == y);
JSONTEST_ASSERT(y == x);
JSONTEST_ASSERT(x <= y);
JSONTEST_ASSERT(y <= x);
JSONTEST_ASSERT(x >= y);
JSONTEST_ASSERT(y >= x);
JSONTEST_ASSERT(!(x < y));
JSONTEST_ASSERT(!(y < x));
JSONTEST_ASSERT(!(x > y));
JSONTEST_ASSERT(!(y > x));
JSONTEST_ASSERT(x.compare(y) == 0);
JSONTEST_ASSERT(y.compare(x) == 0);
}
JSONTEST_FIXTURE_LOCAL(ValueTest, typeChecksThrowExceptions) {
#if JSON_USE_EXCEPTION
Json::Value intVal(1);
Json::Value strVal("Test");
Json::Value objVal(Json::objectValue);
Json::Value arrVal(Json::arrayValue);
JSONTEST_ASSERT_THROWS(intVal["test"]);
JSONTEST_ASSERT_THROWS(strVal["test"]);
JSONTEST_ASSERT_THROWS(arrVal["test"]);
JSONTEST_ASSERT_THROWS(intVal.removeMember("test"));
JSONTEST_ASSERT_THROWS(strVal.removeMember("test"));
JSONTEST_ASSERT_THROWS(arrVal.removeMember("test"));
JSONTEST_ASSERT_THROWS(intVal.getMemberNames());
JSONTEST_ASSERT_THROWS(strVal.getMemberNames());
JSONTEST_ASSERT_THROWS(arrVal.getMemberNames());
JSONTEST_ASSERT_THROWS(intVal[0]);
JSONTEST_ASSERT_THROWS(objVal[0]);
JSONTEST_ASSERT_THROWS(strVal[0]);
JSONTEST_ASSERT_THROWS(intVal.clear());
JSONTEST_ASSERT_THROWS(intVal.resize(1));
JSONTEST_ASSERT_THROWS(strVal.resize(1));
JSONTEST_ASSERT_THROWS(objVal.resize(1));
JSONTEST_ASSERT_THROWS(intVal.asCString());
JSONTEST_ASSERT_THROWS(objVal.asString());
JSONTEST_ASSERT_THROWS(arrVal.asString());
JSONTEST_ASSERT_THROWS(strVal.asInt());
JSONTEST_ASSERT_THROWS(objVal.asInt());
JSONTEST_ASSERT_THROWS(arrVal.asInt());
JSONTEST_ASSERT_THROWS(strVal.asUInt());
JSONTEST_ASSERT_THROWS(objVal.asUInt());
JSONTEST_ASSERT_THROWS(arrVal.asUInt());
JSONTEST_ASSERT_THROWS(strVal.asInt64());
JSONTEST_ASSERT_THROWS(objVal.asInt64());
JSONTEST_ASSERT_THROWS(arrVal.asInt64());
JSONTEST_ASSERT_THROWS(strVal.asUInt64());
JSONTEST_ASSERT_THROWS(objVal.asUInt64());
JSONTEST_ASSERT_THROWS(arrVal.asUInt64());
JSONTEST_ASSERT_THROWS(strVal.asDouble());
JSONTEST_ASSERT_THROWS(objVal.asDouble());
JSONTEST_ASSERT_THROWS(arrVal.asDouble());
JSONTEST_ASSERT_THROWS(strVal.asFloat());
JSONTEST_ASSERT_THROWS(objVal.asFloat());
JSONTEST_ASSERT_THROWS(arrVal.asFloat());
JSONTEST_ASSERT_THROWS(strVal.asBool());
JSONTEST_ASSERT_THROWS(objVal.asBool());
JSONTEST_ASSERT_THROWS(arrVal.asBool());
#endif
}
JSONTEST_FIXTURE_LOCAL(ValueTest, offsetAccessors) {
Json::Value x;
JSONTEST_ASSERT(x.getOffsetStart() == 0);
JSONTEST_ASSERT(x.getOffsetLimit() == 0);
x.setOffsetStart(10);
x.setOffsetLimit(20);
JSONTEST_ASSERT(x.getOffsetStart() == 10);
JSONTEST_ASSERT(x.getOffsetLimit() == 20);
Json::Value y(x);
JSONTEST_ASSERT(y.getOffsetStart() == 10);
JSONTEST_ASSERT(y.getOffsetLimit() == 20);
Json::Value z;
z.swap(y);
JSONTEST_ASSERT(z.getOffsetStart() == 10);
JSONTEST_ASSERT(z.getOffsetLimit() == 20);
JSONTEST_ASSERT(y.getOffsetStart() == 0);
JSONTEST_ASSERT(y.getOffsetLimit() == 0);
}
JSONTEST_FIXTURE_LOCAL(ValueTest, StaticString) {
char mutant[] = "hello";
Json::StaticString ss(mutant);
Json::String regular(mutant);
mutant[1] = 'a';
JSONTEST_ASSERT_STRING_EQUAL("hallo", ss.c_str());
JSONTEST_ASSERT_STRING_EQUAL("hello", regular.c_str());
{
Json::Value root;
root["top"] = ss;
JSONTEST_ASSERT_STRING_EQUAL("hallo", root["top"].asString());
mutant[1] = 'u';
JSONTEST_ASSERT_STRING_EQUAL("hullo", root["top"].asString());
}
{
Json::Value root;
root["top"] = regular;
JSONTEST_ASSERT_STRING_EQUAL("hello", root["top"].asString());
mutant[1] = 'u';
JSONTEST_ASSERT_STRING_EQUAL("hello", root["top"].asString());
}
}
JSONTEST_FIXTURE_LOCAL(ValueTest, WideString) {
// https://github.com/open-source-parsers/jsoncpp/issues/756
const std::string uni = u8"\u5f0f\uff0c\u8fdb"; // "式，进"
std::string styled;
{
Json::Value v;
v["abc"] = uni;
styled = v.toStyledString();
}
Json::Value root;
{
JSONCPP_STRING errs;
std::istringstream iss(styled);
bool ok = parseFromStream(Json::CharReaderBuilder(), iss, &root, &errs);
JSONTEST_ASSERT(ok);
if (!ok) {
std::cerr << "errs: " << errs << std::endl;
}
}
JSONTEST_ASSERT_STRING_EQUAL(root["abc"].asString(), uni);
}
JSONTEST_FIXTURE_LOCAL(ValueTest, CommentBefore) {
Json::Value val; // fill val
val.setComment(Json::String("// this comment should appear before"),
Json::commentBefore);
Json::StreamWriterBuilder wbuilder;
wbuilder.settings_["commentStyle"] = "All";
{
char const expected[] = "// this comment should appear before\nnull";
Json::String result = Json::writeString(wbuilder, val);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
Json::String res2 = val.toStyledString();
Json::String exp2 = "\n";
exp2 += expected;
exp2 += "\n";
JSONTEST_ASSERT_STRING_EQUAL(exp2, res2);
}
Json::Value other = "hello";
val.swapPayload(other);
{
char const expected[] = "// this comment should appear before\n\"hello\"";
Json::String result = Json::writeString(wbuilder, val);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
Json::String res2 = val.toStyledString();
Json::String exp2 = "\n";
exp2 += expected;
exp2 += "\n";
JSONTEST_ASSERT_STRING_EQUAL(exp2, res2);
JSONTEST_ASSERT_STRING_EQUAL("null\n", other.toStyledString());
}
val = "hello";
// val.setComment("// this comment should appear before",
// Json::CommentPlacement::commentBefore); Assignment over-writes comments.
{
char const expected[] = "\"hello\"";
Json::String result = Json::writeString(wbuilder, val);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
Json::String res2 = val.toStyledString();
Json::String exp2;
exp2 += expected;
exp2 += "\n";
JSONTEST_ASSERT_STRING_EQUAL(exp2, res2);
}
}
JSONTEST_FIXTURE_LOCAL(ValueTest, zeroes) {
char const cstr[] = "h\0i";
Json::String binary(cstr, sizeof(cstr)); // include trailing 0
JSONTEST_ASSERT_EQUAL(4U, binary.length());
Json::StreamWriterBuilder b;
{
Json::Value root;
root = binary;
JSONTEST_ASSERT_STRING_EQUAL(binary, root.asString());
}
{
char const top[] = "top";
Json::Value root;
root[top] = binary;
JSONTEST_ASSERT_STRING_EQUAL(binary, root[top].asString());
Json::Value removed;
bool did;
did = root.removeMember(top, top + sizeof(top) - 1U, &removed);
JSONTEST_ASSERT(did);
JSONTEST_ASSERT_STRING_EQUAL(binary, removed.asString());
did = root.removeMember(top, top + sizeof(top) - 1U, &removed);
JSONTEST_ASSERT(!did);
JSONTEST_ASSERT_STRING_EQUAL(binary, removed.asString()); // still
}
}
JSONTEST_FIXTURE_LOCAL(ValueTest, zeroesInKeys) {
char const cstr[] = "h\0i";
Json::String binary(cstr, sizeof(cstr)); // include trailing 0
JSONTEST_ASSERT_EQUAL(4U, binary.length());
{
Json::Value root;
root[binary] = "there";
JSONTEST_ASSERT_STRING_EQUAL("there", root[binary].asString());
JSONTEST_ASSERT(!root.isMember("h"));
JSONTEST_ASSERT(root.isMember(binary));
JSONTEST_ASSERT_STRING_EQUAL(
"there", root.get(binary, Json::Value::nullSingleton()).asString());
Json::Value removed;
bool did;
did = root.removeMember(binary.data(), binary.data() + binary.length(),
&removed);
JSONTEST_ASSERT(did);
JSONTEST_ASSERT_STRING_EQUAL("there", removed.asString());
did = root.removeMember(binary.data(), binary.data() + binary.length(),
&removed);
JSONTEST_ASSERT(!did);
JSONTEST_ASSERT_STRING_EQUAL("there", removed.asString()); // still
JSONTEST_ASSERT(!root.isMember(binary));
JSONTEST_ASSERT_STRING_EQUAL(
"", root.get(binary, Json::Value::nullSingleton()).asString());
}
}
JSONTEST_FIXTURE_LOCAL(ValueTest, specialFloats) {
Json::StreamWriterBuilder b;
b.settings_["useSpecialFloats"] = true;
Json::Value v = std::numeric_limits<double>::quiet_NaN();
Json::String expected = "NaN";
Json::String result = Json::writeString(b, v);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
v = std::numeric_limits<double>::infinity();
expected = "Infinity";
result = Json::writeString(b, v);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
v = -std::numeric_limits<double>::infinity();
expected = "-Infinity";
result = Json::writeString(b, v);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
JSONTEST_FIXTURE_LOCAL(ValueTest, precision) {
Json::StreamWriterBuilder b;
b.settings_["precision"] = 5;
Json::Value v = 100.0 / 3;
Json::String expected = "33.333";
Json::String result = Json::writeString(b, v);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
v = 0.25000000;
expected = "0.25";
result = Json::writeString(b, v);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
v = 0.2563456;
expected = "0.25635";
result = Json::writeString(b, v);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
b.settings_["precision"] = 1;
expected = "0.3";
result = Json::writeString(b, v);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
b.settings_["precision"] = 17;
v = 1234857476305.256345694873740545068;
expected = "1234857476305.2563";
result = Json::writeString(b, v);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
b.settings_["precision"] = 24;
v = 0.256345694873740545068;
expected = "0.25634569487374054";
result = Json::writeString(b, v);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
b.settings_["precision"] = 5;
b.settings_["precisionType"] = "decimal";
v = 0.256345694873740545068;
expected = "0.25635";
result = Json::writeString(b, v);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
b.settings_["precision"] = 1;
b.settings_["precisionType"] = "decimal";
v = 0.256345694873740545068;
expected = "0.3";
result = Json::writeString(b, v);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
b.settings_["precision"] = 0;
b.settings_["precisionType"] = "decimal";
v = 123.56345694873740545068;
expected = "124";
result = Json::writeString(b, v);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
b.settings_["precision"] = 1;
b.settings_["precisionType"] = "decimal";
v = 1230.001;
expected = "1230.0";
result = Json::writeString(b, v);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
b.settings_["precision"] = 0;
b.settings_["precisionType"] = "decimal";
v = 1230.001;
expected = "1230";
result = Json::writeString(b, v);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
b.settings_["precision"] = 0;
b.settings_["precisionType"] = "decimal";
v = 1231.5;
expected = "1232";
result = Json::writeString(b, v);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
b.settings_["precision"] = 10;
b.settings_["precisionType"] = "decimal";
v = 0.23300000;
expected = "0.233";
result = Json::writeString(b, v);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
JSONTEST_FIXTURE_LOCAL(ValueTest, searchValueByPath) {
Json::Value root, subroot;
root["property1"][0] = 0;
root["property1"][1] = 1;
subroot["object"] = "object";
root["property2"] = subroot;
const Json::Value defaultValue("error");
Json::FastWriter writer;
{
const Json::String expected("{"
"\"property1\":[0,1],"
"\"property2\":{\"object\":\"object\"}"
"}\n");
Json::String outcome = writer.write(root);
JSONTEST_ASSERT_STRING_EQUAL(expected, outcome);
// Array member exists.
const Json::Path path1(".property1.[%]", 1);
Json::Value result = path1.resolve(root);
JSONTEST_ASSERT_EQUAL(Json::Value(1), result);
result = path1.resolve(root, defaultValue);
JSONTEST_ASSERT_EQUAL(Json::Value(1), result);
// Array member does not exist.
const Json::Path path2(".property1.[2]");
result = path2.resolve(root);
JSONTEST_ASSERT_EQUAL(Json::nullValue, result);
result = path2.resolve(root, defaultValue);
JSONTEST_ASSERT_EQUAL(defaultValue, result);
// Access array path form error
const Json::Path path3(".property1.0");
result = path3.resolve(root);
JSONTEST_ASSERT_EQUAL(Json::nullValue, result);
result = path3.resolve(root, defaultValue);
JSONTEST_ASSERT_EQUAL(defaultValue, result);
// Object member exists.
const Json::Path path4(".property2.%", "object");
result = path4.resolve(root);
JSONTEST_ASSERT_EQUAL(Json::Value("object"), result);
result = path4.resolve(root, defaultValue);
JSONTEST_ASSERT_EQUAL(Json::Value("object"), result);
// Object member does not exist.
const Json::Path path5(".property2.hello");
result = path5.resolve(root);
JSONTEST_ASSERT_EQUAL(Json::nullValue, result);
result = path5.resolve(root, defaultValue);
JSONTEST_ASSERT_EQUAL(defaultValue, result);
// Access object path form error
const Json::Path path6(".property2.[0]");
result = path5.resolve(root);
JSONTEST_ASSERT_EQUAL(Json::nullValue, result);
result = path6.resolve(root, defaultValue);
JSONTEST_ASSERT_EQUAL(defaultValue, result);
// resolve will not change the value
outcome = writer.write(root);
JSONTEST_ASSERT_STRING_EQUAL(expected, outcome);
}
{
const Json::String expected("{"
"\"property1\":[0,1,null],"
"\"property2\":{"
"\"hello\":null,"
"\"object\":\"object\"}}\n");
Json::Path path1(".property1.[%]", 2);
Json::Value& value1 = path1.make(root);
JSONTEST_ASSERT_EQUAL(Json::nullValue, value1);
Json::Path path2(".property2.%", "hello");
Json::Value& value2 = path2.make(root);
JSONTEST_ASSERT_EQUAL(Json::nullValue, value2);
// make will change the value
const Json::String outcome = writer.write(root);
JSONTEST_ASSERT_STRING_EQUAL(expected, outcome);
}
}
struct FastWriterTest : JsonTest::TestCase {};
JSONTEST_FIXTURE_LOCAL(FastWriterTest, dropNullPlaceholders) {
Json::FastWriter writer;
Json::Value nullValue;
JSONTEST_ASSERT(writer.write(nullValue) == "null\n");
writer.dropNullPlaceholders();
JSONTEST_ASSERT(writer.write(nullValue) == "\n");
}
JSONTEST_FIXTURE_LOCAL(FastWriterTest, enableYAMLCompatibility) {
Json::FastWriter writer;
Json::Value root;
root["hello"] = "world";
JSONTEST_ASSERT(writer.write(root) == "{\"hello\":\"world\"}\n");
writer.enableYAMLCompatibility();
JSONTEST_ASSERT(writer.write(root) == "{\"hello\": \"world\"}\n");
}
JSONTEST_FIXTURE_LOCAL(FastWriterTest, omitEndingLineFeed) {
Json::FastWriter writer;
Json::Value nullValue;
JSONTEST_ASSERT(writer.write(nullValue) == "null\n");
writer.omitEndingLineFeed();
JSONTEST_ASSERT(writer.write(nullValue) == "null");
}
JSONTEST_FIXTURE_LOCAL(FastWriterTest, writeNumericValue) {
Json::FastWriter writer;
const Json::String expected("{"
"\"emptyValue\":null,"
"\"false\":false,"
"\"null\":\"null\","
"\"number\":-6200000000000000.0,"
"\"real\":1.256,"
"\"uintValue\":17"
"}\n");
Json::Value root;
root["emptyValue"] = Json::nullValue;
root["false"] = false;
root["null"] = "null";
root["number"] = -6.2e+15;
root["real"] = 1.256;
root["uintValue"] = Json::Value(17U);
const Json::String result = writer.write(root);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
JSONTEST_FIXTURE_LOCAL(FastWriterTest, writeArrays) {
Json::FastWriter writer;
const Json::String expected("{"
"\"property1\":[\"value1\",\"value2\"],"
"\"property2\":[]"
"}\n");
Json::Value root;
root["property1"][0] = "value1";
root["property1"][1] = "value2";
root["property2"] = Json::arrayValue;
const Json::String result = writer.write(root);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
JSONTEST_FIXTURE_LOCAL(FastWriterTest, writeNestedObjects) {
Json::FastWriter writer;
const Json::String expected("{"
"\"object1\":{"
"\"bool\":true,"
"\"nested\":123"
"},"
"\"object2\":{}"
"}\n");
Json::Value root, child;
child["nested"] = 123;
child["bool"] = true;
root["object1"] = child;
root["object2"] = Json::objectValue;
const Json::String result = writer.write(root);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
struct StyledWriterTest : JsonTest::TestCase {};
JSONTEST_FIXTURE_LOCAL(StyledWriterTest, writeNumericValue) {
Json::StyledWriter writer;
const Json::String expected("{\n"
" \"emptyValue\" : null,\n"
" \"false\" : false,\n"
" \"null\" : \"null\",\n"
" \"number\" : -6200000000000000.0,\n"
" \"real\" : 1.256,\n"
" \"uintValue\" : 17\n"
"}\n");
Json::Value root;
root["emptyValue"] = Json::nullValue;
root["false"] = false;
root["null"] = "null";
root["number"] = -6.2e+15;
root["real"] = 1.256;
root["uintValue"] = Json::Value(17U);
const Json::String result = writer.write(root);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
JSONTEST_FIXTURE_LOCAL(StyledWriterTest, writeArrays) {
Json::StyledWriter writer;
const Json::String expected("{\n"
" \"property1\" : [ \"value1\", \"value2\" ],\n"
" \"property2\" : []\n"
"}\n");
Json::Value root;
root["property1"][0] = "value1";
root["property1"][1] = "value2";
root["property2"] = Json::arrayValue;
const Json::String result = writer.write(root);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
JSONTEST_FIXTURE_LOCAL(StyledWriterTest, writeNestedObjects) {
Json::StyledWriter writer;
const Json::String expected("{\n"
" \"object1\" : {\n"
" \"bool\" : true,\n"
" \"nested\" : 123\n"
" },\n"
" \"object2\" : {}\n"
"}\n");
Json::Value root, child;
child["nested"] = 123;
child["bool"] = true;
root["object1"] = child;
root["object2"] = Json::objectValue;
const Json::String result = writer.write(root);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
JSONTEST_FIXTURE_LOCAL(StyledWriterTest, multiLineArray) {
Json::StyledWriter writer;
{
// Array member has more than 20 print effect rendering lines
const Json::String expected("[\n "
"0,\n 1,\n 2,\n "
"3,\n 4,\n 5,\n "
"6,\n 7,\n 8,\n "
"9,\n 10,\n 11,\n "
"12,\n 13,\n 14,\n "
"15,\n 16,\n 17,\n "
"18,\n 19,\n 20\n]\n");
Json::Value root;
for (Json::ArrayIndex i = 0; i < 21; i++)
root[i] = i;
const Json::String result = writer.write(root);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
{
// Array members do not exceed 21 print effects to render a single line
const Json::String expected("[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]\n");
Json::Value root;
for (Json::ArrayIndex i = 0; i < 10; i++)
root[i] = i;
const Json::String result = writer.write(root);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
}
JSONTEST_FIXTURE_LOCAL(StyledWriterTest, writeValueWithComment) {
Json::StyledWriter writer;
{
const Json::String expected("\n//commentBeforeValue\n\"hello\"\n");
Json::Value root = "hello";
root.setComment(Json::String("//commentBeforeValue"), Json::commentBefore);
const Json::String result = writer.write(root);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
{
const Json::String expected("\"hello\" //commentAfterValueOnSameLine\n");
Json::Value root = "hello";
root.setComment(Json::String("//commentAfterValueOnSameLine"),
Json::commentAfterOnSameLine);
const Json::String result = writer.write(root);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
{
const Json::String expected("\"hello\"\n//commentAfter\n\n");
Json::Value root = "hello";
root.setComment(Json::String("//commentAfter"), Json::commentAfter);
const Json::String result = writer.write(root);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
}
struct StyledStreamWriterTest : JsonTest::TestCase {};
JSONTEST_FIXTURE_LOCAL(StyledStreamWriterTest, writeNumericValue) {
Json::StyledStreamWriter writer;
const Json::String expected("{\n"
"\t\"emptyValue\" : null,\n"
"\t\"false\" : false,\n"
"\t\"null\" : \"null\",\n"
"\t\"number\" : -6200000000000000.0,\n"
"\t\"real\" : 1.256,\n"
"\t\"uintValue\" : 17\n"
"}\n");
Json::Value root;
root["emptyValue"] = Json::nullValue;
root["false"] = false;
root["null"] = "null";
root["number"] = -6.2e+15; // big float number
root["real"] = 1.256; // float number
root["uintValue"] = Json::Value(17U);
Json::OStringStream sout;
writer.write(sout, root);
const Json::String result = sout.str();
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
JSONTEST_FIXTURE_LOCAL(StyledStreamWriterTest, writeArrays) {
Json::StyledStreamWriter writer;
const Json::String expected("{\n"
"\t\"property1\" : [ \"value1\", \"value2\" ],\n"
"\t\"property2\" : []\n"
"}\n");
Json::Value root;
root["property1"][0] = "value1";
root["property1"][1] = "value2";
root["property2"] = Json::arrayValue;
Json::OStringStream sout;
writer.write(sout, root);
const Json::String result = sout.str();
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
JSONTEST_FIXTURE_LOCAL(StyledStreamWriterTest, writeNestedObjects) {
Json::StyledStreamWriter writer;
const Json::String expected("{\n"
"\t\"object1\" : \n"
"\t"
"{\n"
"\t\t\"bool\" : true,\n"
"\t\t\"nested\" : 123\n"
"\t},\n"
"\t\"object2\" : {}\n"
"}\n");
Json::Value root, child;
child["nested"] = 123;
child["bool"] = true;
root["object1"] = child;
root["object2"] = Json::objectValue;
Json::OStringStream sout;
writer.write(sout, root);
const Json::String result = sout.str();
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
JSONTEST_FIXTURE_LOCAL(StyledStreamWriterTest, multiLineArray) {
{
// Array member has more than 20 print effect rendering lines
const Json::String expected("[\n\t0,"
"\n\t1,"
"\n\t2,"
"\n\t3,"
"\n\t4,"
"\n\t5,"
"\n\t6,"
"\n\t7,"
"\n\t8,"
"\n\t9,"
"\n\t10,"
"\n\t11,"
"\n\t12,"
"\n\t13,"
"\n\t14,"
"\n\t15,"
"\n\t16,"
"\n\t17,"
"\n\t18,"
"\n\t19,"
"\n\t20\n]\n");
Json::StyledStreamWriter writer;
Json::Value root;
for (Json::ArrayIndex i = 0; i < 21; i++)
root[i] = i;
Json::OStringStream sout;
writer.write(sout, root);
const Json::String result = sout.str();
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
{
Json::StyledStreamWriter writer;
// Array members do not exceed 21 print effects to render a single line
const Json::String expected("[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]\n");
Json::Value root;
for (Json::ArrayIndex i = 0; i < 10; i++)
root[i] = i;
Json::OStringStream sout;
writer.write(sout, root);
const Json::String result = sout.str();
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
}
JSONTEST_FIXTURE_LOCAL(StyledStreamWriterTest, writeValueWithComment) {
Json::StyledStreamWriter writer("\t");
{
const Json::String expected("//commentBeforeValue\n\"hello\"\n");
Json::Value root = "hello";
Json::OStringStream sout;
root.setComment(Json::String("//commentBeforeValue"), Json::commentBefore);
writer.write(sout, root);
const Json::String result = sout.str();
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
{
const Json::String expected("\"hello\" //commentAfterValueOnSameLine\n");
Json::Value root = "hello";
Json::OStringStream sout;
root.setComment(Json::String("//commentAfterValueOnSameLine"),
Json::commentAfterOnSameLine);
writer.write(sout, root);
const Json::String result = sout.str();
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
{
const Json::String expected("\"hello\"\n//commentAfter\n");
Json::Value root = "hello";
Json::OStringStream sout;
root.setComment(Json::String("//commentAfter"), Json::commentAfter);
writer.write(sout, root);
const Json::String result = sout.str();
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
}
struct StreamWriterTest : JsonTest::TestCase {};
JSONTEST_FIXTURE_LOCAL(StreamWriterTest, writeNumericValue) {
Json::StreamWriterBuilder writer;
const Json::String expected("{\n"
"\t\"emptyValue\" : null,\n"
"\t\"false\" : false,\n"
"\t\"null\" : \"null\",\n"
"\t\"number\" : -6200000000000000.0,\n"
"\t\"real\" : 1.256,\n"
"\t\"uintValue\" : 17\n"
"}");
Json::Value root;
root["emptyValue"] = Json::nullValue;
root["false"] = false;
root["null"] = "null";
root["number"] = -6.2e+15;
root["real"] = 1.256;
root["uintValue"] = Json::Value(17U);
const Json::String result = Json::writeString(writer, root);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
JSONTEST_FIXTURE_LOCAL(StreamWriterTest, writeArrays) {
Json::StreamWriterBuilder writer;
const Json::String expected("{\n"
"\t\"property1\" : \n"
"\t[\n"
"\t\t\"value1\",\n"
"\t\t\"value2\"\n"
"\t],\n"
"\t\"property2\" : []\n"
"}");
Json::Value root;
root["property1"][0] = "value1";
root["property1"][1] = "value2";
root["property2"] = Json::arrayValue;
const Json::String result = Json::writeString(writer, root);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
JSONTEST_FIXTURE_LOCAL(StreamWriterTest, writeNestedObjects) {
Json::StreamWriterBuilder writer;
const Json::String expected("{\n"
"\t\"object1\" : \n"
"\t{\n"
"\t\t\"bool\" : true,\n"
"\t\t\"nested\" : 123\n"
"\t},\n"
"\t\"object2\" : {}\n"
"}");
Json::Value root, child;
child["nested"] = 123;
child["bool"] = true;
root["object1"] = child;
root["object2"] = Json::objectValue;
const Json::String result = Json::writeString(writer, root);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
JSONTEST_FIXTURE_LOCAL(StreamWriterTest, multiLineArray) {
Json::StreamWriterBuilder wb;
wb.settings_["commentStyle"] = "None";
{
// When wb.settings_["commentStyle"] = "None", the effect of
// printing multiple lines will be displayed when there are
// more than 20 array members.
const Json::String expected("[\n\t0,"
"\n\t1,"
"\n\t2,"
"\n\t3,"
"\n\t4,"
"\n\t5,"
"\n\t6,"
"\n\t7,"
"\n\t8,"
"\n\t9,"
"\n\t10,"
"\n\t11,"
"\n\t12,"
"\n\t13,"
"\n\t14,"
"\n\t15,"
"\n\t16,"
"\n\t17,"
"\n\t18,"
"\n\t19,"
"\n\t20\n]");
Json::Value root;
for (Json::ArrayIndex i = 0; i < 21; i++)
root[i] = i;
const Json::String result = Json::writeString(wb, root);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
{
// Array members do not exceed 21 print effects to render a single line
const Json::String expected("[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]");
Json::Value root;
for (Json::ArrayIndex i = 0; i < 10; i++)
root[i] = i;
const Json::String result = Json::writeString(wb, root);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
}
JSONTEST_FIXTURE_LOCAL(StreamWriterTest, dropNullPlaceholders) {
Json::StreamWriterBuilder b;
Json::Value nullValue;
b.settings_["dropNullPlaceholders"] = false;
JSONTEST_ASSERT(Json::writeString(b, nullValue) == "null");
b.settings_["dropNullPlaceholders"] = true;
JSONTEST_ASSERT(Json::writeString(b, nullValue).empty());
}
JSONTEST_FIXTURE_LOCAL(StreamWriterTest, enableYAMLCompatibility) {
Json::StreamWriterBuilder b;
Json::Value root;
root["hello"] = "world";
b.settings_["indentation"] = "";
JSONTEST_ASSERT(Json::writeString(b, root) == "{\"hello\":\"world\"}");
b.settings_["enableYAMLCompatibility"] = true;
JSONTEST_ASSERT(Json::writeString(b, root) == "{\"hello\": \"world\"}");
b.settings_["enableYAMLCompatibility"] = false;
JSONTEST_ASSERT(Json::writeString(b, root) == "{\"hello\":\"world\"}");
}
JSONTEST_FIXTURE_LOCAL(StreamWriterTest, indentation) {
Json::StreamWriterBuilder b;
Json::Value root;
root["hello"] = "world";
b.settings_["indentation"] = "";
JSONTEST_ASSERT(Json::writeString(b, root) == "{\"hello\":\"world\"}");
b.settings_["indentation"] = "\t";
JSONTEST_ASSERT(Json::writeString(b, root) ==
"{\n\t\"hello\" : \"world\"\n}");
}
JSONTEST_FIXTURE_LOCAL(StreamWriterTest, writeZeroes) {
Json::String binary("hi", 3); // include trailing 0
JSONTEST_ASSERT_EQUAL(3, binary.length());
Json::String expected(R"("hi\u0000")"); // unicoded zero
Json::StreamWriterBuilder b;
{
Json::Value root;
root = binary;
JSONTEST_ASSERT_STRING_EQUAL(binary, root.asString());
Json::String out = Json::writeString(b, root);
JSONTEST_ASSERT_EQUAL(expected.size(), out.size());
JSONTEST_ASSERT_STRING_EQUAL(expected, out);
}
{
Json::Value root;
root["top"] = binary;
JSONTEST_ASSERT_STRING_EQUAL(binary, root["top"].asString());
Json::String out = Json::writeString(b, root["top"]);
JSONTEST_ASSERT_STRING_EQUAL(expected, out);
}
}
JSONTEST_FIXTURE_LOCAL(StreamWriterTest, unicode) {
// Create a Json value containing UTF-8 string with some chars that need
// escape (tab,newline).
Json::Value root;
root["test"] = "\t\n\xF0\x91\xA2\xA1\x3D\xC4\xB3\xF0\x9B\x84\x9B\xEF\xBD\xA7";
Json::StreamWriterBuilder b;
// Default settings - should be unicode escaped.
JSONTEST_ASSERT(Json::writeString(b, root) ==
"{\n\t\"test\" : "
"\"\\t\\n\\ud806\\udca1=\\u0133\\ud82c\\udd1b\\uff67\"\n}");
b.settings_["emitUTF8"] = true;
// Should not be unicode escaped.
JSONTEST_ASSERT(
Json::writeString(b, root) ==
"{\n\t\"test\" : "
"\"\\t\\n\xF0\x91\xA2\xA1=\xC4\xB3\xF0\x9B\x84\x9B\xEF\xBD\xA7\"\n}");
b.settings_["emitUTF8"] = false;
// Should be unicode escaped.
JSONTEST_ASSERT(Json::writeString(b, root) ==
"{\n\t\"test\" : "
"\"\\t\\n\\ud806\\udca1=\\u0133\\ud82c\\udd1b\\uff67\"\n}");
}
// Control chars should be escaped regardless of UTF-8 input encoding.
JSONTEST_FIXTURE_LOCAL(StreamWriterTest, escapeControlCharacters) {
auto uEscape = [](unsigned ch) {
static const char h[] = "0123456789abcdef";
std::string r = "\\u";
r += h[(ch >> (3 * 4)) & 0xf];
r += h[(ch >> (2 * 4)) & 0xf];
r += h[(ch >> (1 * 4)) & 0xf];
r += h[(ch >> (0 * 4)) & 0xf];
return r;
};
auto shortEscape = [](unsigned ch) -> const char* {
switch (ch) {
case '\"':
return "\\\"";
case '\\':
return "\\\\";
case '\b':
return "\\b";
case '\f':
return "\\f";
case '\n':
return "\\n";
case '\r':
return "\\r";
case '\t':
return "\\t";
default:
return nullptr;
}
};
Json::StreamWriterBuilder b;
for (bool emitUTF8 : {true, false}) {
b.settings_["emitUTF8"] = emitUTF8;
for (unsigned i = 0; i != 0x100; ++i) {
if (!emitUTF8 && i >= 0x80)
break; // The algorithm would try to parse UTF-8, so stop here.
std::string raw({static_cast<char>(i)});
std::string esc = raw;
if (i < 0x20)
esc = uEscape(i);
if (const char* shEsc = shortEscape(i))
esc = shEsc;
// std::cout << "emit=" << emitUTF8 << ", i=" << std::hex << i << std::dec
// << std::endl;
Json::Value root;
root["test"] = raw;
JSONTEST_ASSERT_STRING_EQUAL(
std::string("{\n\t\"test\" : \"").append(esc).append("\"\n}"),
Json::writeString(b, root))
<< ", emit=" << emitUTF8 << ", i=" << i << ", raw=\"" << raw << "\""
<< ", esc=\"" << esc << "\"";
}
}
}
#ifdef _WIN32
JSONTEST_FIXTURE_LOCAL(StreamWriterTest, escapeTabCharacterWindows) {
// Get the current locale before changing it
std::string currentLocale = setlocale(LC_ALL, NULL);
setlocale(LC_ALL, "English_United States.1252");
Json::Value root;
root["test"] = "\tTabTesting\t";
Json::StreamWriterBuilder b;
JSONTEST_ASSERT(Json::writeString(b, root) == "{\n\t\"test\" : "
"\"\\tTabTesting\\t\"\n}");
b.settings_["emitUTF8"] = true;
JSONTEST_ASSERT(Json::writeString(b, root) == "{\n\t\"test\" : "
"\"\\tTabTesting\\t\"\n}");
b.settings_["emitUTF8"] = false;
JSONTEST_ASSERT(Json::writeString(b, root) == "{\n\t\"test\" : "
"\"\\tTabTesting\\t\"\n}");
// Restore the locale
if (!currentLocale.empty())
setlocale(LC_ALL, currentLocale.c_str());
}
#endif
struct ReaderTest : JsonTest::TestCase {
void setStrictMode() {
reader = std::unique_ptr<Json::Reader>(
new Json::Reader(Json::Features{}.strictMode()));
}
void setFeatures(Json::Features& features) {
reader = std::unique_ptr<Json::Reader>(new Json::Reader(features));
}
void checkStructuredErrors(
const std::vector<Json::Reader::StructuredError>& actual,
const std::vector<Json::Reader::StructuredError>& expected) {
JSONTEST_ASSERT_EQUAL(expected.size(), actual.size());
for (size_t i = 0; i < actual.size(); ++i) {
const auto& a = actual[i];
const auto& e = expected[i];
JSONTEST_ASSERT_EQUAL(e.offset_start, a.offset_start) << i;
JSONTEST_ASSERT_EQUAL(e.offset_limit, a.offset_limit) << i;
JSONTEST_ASSERT_EQUAL(e.message, a.message) << i;
}
}
template <typename Input> void checkParse(Input&& input) {
JSONTEST_ASSERT(reader->parse(input, root));
}
template <typename Input>
void
checkParse(Input&& input,
const std::vector<Json::Reader::StructuredError>& structured) {
JSONTEST_ASSERT(!reader->parse(input, root));
checkStructuredErrors(reader->getStructuredErrors(), structured);
}
template <typename Input>
void checkParse(Input&& input,
const std::vector<Json::Reader::StructuredError>& structured,
const std::string& formatted) {
checkParse(input, structured);
JSONTEST_ASSERT_EQUAL(formatted, reader->getFormattedErrorMessages());
}
std::unique_ptr<Json::Reader> reader{new Json::Reader()};
Json::Value root;
};
JSONTEST_FIXTURE_LOCAL(ReaderTest, parseWithNoErrors) {
checkParse(R"({ "property" : "value" })");
}
JSONTEST_FIXTURE_LOCAL(ReaderTest, parseObject) {
checkParse(R"({"property"})",
{{11, 12, "Missing ':' after object member name"}},
"* Line 1, Column 12\n Missing ':' after object member name\n");
checkParse(
R"({"property" : "value" )",
{{22, 22, "Missing ',' or '}' in object declaration"}},
"* Line 1, Column 23\n Missing ',' or '}' in object declaration\n");
checkParse(R"({"property" : "value", )",
{{23, 23, "Missing '}' or object member name"}},
"* Line 1, Column 24\n Missing '}' or object member name\n");
}
JSONTEST_FIXTURE_LOCAL(ReaderTest, parseArray) {
checkParse(
R"([ "value" )", {{10, 10, "Missing ',' or ']' in array declaration"}},
"* Line 1, Column 11\n Missing ',' or ']' in array declaration\n");
checkParse(
R"([ "value1" "value2" ] )",
{{11, 19, "Missing ',' or ']' in array declaration"}},
"* Line 1, Column 12\n Missing ',' or ']' in array declaration\n");
}
JSONTEST_FIXTURE_LOCAL(ReaderTest, parseString) {
checkParse(R"([ "\u8a2a" ])");
checkParse(
R"([ "\ud801" ])",
{{2, 10,
"additional six characters expected to parse unicode surrogate "
"pair."}},
"* Line 1, Column 3\n"
" additional six characters expected to parse unicode surrogate pair.\n"
"See Line 1, Column 10 for detail.\n");
checkParse(R"([ "\ud801\d1234" ])",
{{2, 16,
"expecting another \\u token to begin the "
"second half of a unicode surrogate pair"}},
"* Line 1, Column 3\n"
" expecting another \\u token to begin the "
"second half of a unicode surrogate pair\n"
"See Line 1, Column 12 for detail.\n");
checkParse(R"([ "\ua3t@" ])",
{{2, 10,
"Bad unicode escape sequence in string: "
"hexadecimal digit expected."}},
"* Line 1, Column 3\n"
" Bad unicode escape sequence in string: "
"hexadecimal digit expected.\n"
"See Line 1, Column 9 for detail.\n");
checkParse(
R"([ "\ua3t" ])",
{{2, 9, "Bad unicode escape sequence in string: four digits expected."}},
"* Line 1, Column 3\n"
" Bad unicode escape sequence in string: four digits expected.\n"
"See Line 1, Column 6 for detail.\n");
}
JSONTEST_FIXTURE_LOCAL(ReaderTest, parseComment) {
checkParse(
R"({ /*commentBeforeValue*/ "property" : "value" }//commentAfterValue)"
"\n");
checkParse(" true //comment1\n//comment2\r//comment3\r\n");
}
JSONTEST_FIXTURE_LOCAL(ReaderTest, streamParseWithNoErrors) {
std::string styled = R"({ "property" : "value" })";
std::istringstream iss(styled);
checkParse(iss);
}
JSONTEST_FIXTURE_LOCAL(ReaderTest, parseWithNoErrorsTestingOffsets) {
checkParse(R"({)"
R"( "property" : ["value", "value2"],)"
R"( "obj" : { "nested" : -6.2e+15, "bool" : true},)"
R"( "null" : null,)"
R"( "false" : false)"
R"( })");
auto checkOffsets = [&](const Json::Value& v, int start, int limit) {
JSONTEST_ASSERT_EQUAL(start, v.getOffsetStart());
JSONTEST_ASSERT_EQUAL(limit, v.getOffsetLimit());
};
checkOffsets(root, 0, 115);
checkOffsets(root["property"], 15, 34);
checkOffsets(root["property"][0], 16, 23);
checkOffsets(root["property"][1], 25, 33);
checkOffsets(root["obj"], 44, 81);
checkOffsets(root["obj"]["nested"], 57, 65);
checkOffsets(root["obj"]["bool"], 76, 80);
checkOffsets(root["null"], 92, 96);
checkOffsets(root["false"], 108, 113);
}
JSONTEST_FIXTURE_LOCAL(ReaderTest, parseWithOneError) {
checkParse(R"({ "property" :: "value" })",
{{14, 15, "Syntax error: value, object or array expected."}},
"* Line 1, Column 15\n Syntax error: value, object or array "
"expected.\n");
checkParse("s", {{0, 1, "Syntax error: value, object or array expected."}},
"* Line 1, Column 1\n Syntax error: value, object or array "
"expected.\n");
}
JSONTEST_FIXTURE_LOCAL(ReaderTest, parseSpecialFloat) {
checkParse(R"({ "a" : Infi })",
{{8, 9, "Syntax error: value, object or array expected."}},
"* Line 1, Column 9\n Syntax error: value, object or array "
"expected.\n");
checkParse(R"({ "a" : Infiniaa })",
{{8, 9, "Syntax error: value, object or array expected."}},
"* Line 1, Column 9\n Syntax error: value, object or array "
"expected.\n");
}
JSONTEST_FIXTURE_LOCAL(ReaderTest, strictModeParseNumber) {
setStrictMode();
checkParse(
"123",
{{0, 3,
"A valid JSON document must be either an array or an object value."}},
"* Line 1, Column 1\n"
" A valid JSON document must be either an array or an object value.\n");
}
JSONTEST_FIXTURE_LOCAL(ReaderTest, parseChineseWithOneError) {
checkParse(R"({ "pr)"
u8"\u4f50\u85e4" // 佐藤
R"(erty" :: "value" })",
{{18, 19, "Syntax error: value, object or array expected."}},
"* Line 1, Column 19\n Syntax error: value, object or array "
"expected.\n");
}
JSONTEST_FIXTURE_LOCAL(ReaderTest, parseWithDetailError) {
checkParse(R"({ "property" : "v\alue" })",
{{15, 23, "Bad escape sequence in string"}},
"* Line 1, Column 16\n"
" Bad escape sequence in string\n"
"See Line 1, Column 20 for detail.\n");
}
JSONTEST_FIXTURE_LOCAL(ReaderTest, pushErrorTest) {
checkParse(R"({ "AUTHOR" : 123 })");
if (!root["AUTHOR"].isString()) {
JSONTEST_ASSERT(
reader->pushError(root["AUTHOR"], "AUTHOR must be a string"));
}
JSONTEST_ASSERT_STRING_EQUAL(reader->getFormattedErrorMessages(),
"* Line 1, Column 14\n"
" AUTHOR must be a string\n");
checkParse(R"({ "AUTHOR" : 123 })");
if (!root["AUTHOR"].isString()) {
JSONTEST_ASSERT(reader->pushError(root["AUTHOR"], "AUTHOR must be a string",
root["AUTHOR"]));
}
JSONTEST_ASSERT_STRING_EQUAL(reader->getFormattedErrorMessages(),
"* Line 1, Column 14\n"
" AUTHOR must be a string\n"
"See Line 1, Column 14 for detail.\n");
}
JSONTEST_FIXTURE_LOCAL(ReaderTest, allowNumericKeysTest) {
Json::Features features;
features.allowNumericKeys_ = true;
setFeatures(features);
checkParse(R"({ 123 : "abc" })");
}
struct CharReaderTest : JsonTest::TestCase {};
JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseWithNoErrors) {
Json::CharReaderBuilder b;
CharReaderPtr reader(b.newCharReader());
Json::String errs;
Json::Value root;
char const doc[] = R"({ "property" : "value" })";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(ok);
JSONTEST_ASSERT(errs.empty());
}
JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseWithNoErrorsTestingOffsets) {
Json::CharReaderBuilder b;
CharReaderPtr reader(b.newCharReader());
Json::String errs;
Json::Value root;
char const doc[] = "{ \"property\" : [\"value\", \"value2\"], \"obj\" : "
"{ \"nested\" : -6.2e+15, \"num\" : +123, \"bool\" : "
"true}, \"null\" : null, \"false\" : false }";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(ok);
JSONTEST_ASSERT(errs.empty());
}
JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseNumber) {
Json::CharReaderBuilder b;
CharReaderPtr reader(b.newCharReader());
Json::String errs;
Json::Value root;
{
// if intvalue > threshold, treat the number as a double.
// 21 digits
char const doc[] = "[111111111111111111111]";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(ok);
JSONTEST_ASSERT(errs.empty());
JSONTEST_ASSERT_EQUAL(1.1111111111111111e+020, root[0]);
}
}
JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseString) {
Json::CharReaderBuilder b;
CharReaderPtr reader(b.newCharReader());
Json::Value root;
Json::String errs;
{
char const doc[] = "[\"\"]";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(ok);
JSONTEST_ASSERT(errs.empty());
JSONTEST_ASSERT_EQUAL("", root[0]);
}
{
char const doc[] = R"(["\u8A2a"])";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(ok);
JSONTEST_ASSERT(errs.empty());
JSONTEST_ASSERT_EQUAL(u8"\u8A2a", root[0].asString()); // "訪"
}
{
char const doc[] = R"([ "\uD801" ])";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(!ok);
JSONTEST_ASSERT(errs == "* Line 1, Column 3\n"
" additional six characters expected to "
"parse unicode surrogate pair.\n"
"See Line 1, Column 10 for detail.\n");
}
{
char const doc[] = R"([ "\uD801\d1234" ])";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(!ok);
JSONTEST_ASSERT(errs == "* Line 1, Column 3\n"
" expecting another \\u token to begin the "
"second half of a unicode surrogate pair\n"
"See Line 1, Column 12 for detail.\n");
}
{
char const doc[] = R"([ "\ua3t@" ])";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(!ok);
JSONTEST_ASSERT(errs == "* Line 1, Column 3\n"
" Bad unicode escape sequence in string: "
"hexadecimal digit expected.\n"
"See Line 1, Column 9 for detail.\n");
}
{
char const doc[] = R"([ "\ua3t" ])";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(!ok);
JSONTEST_ASSERT(
errs ==
"* Line 1, Column 3\n"
" Bad unicode escape sequence in string: four digits expected.\n"
"See Line 1, Column 6 for detail.\n");
}
{
b.settings_["allowSingleQuotes"] = true;
CharReaderPtr charreader(b.newCharReader());
char const doc[] = R"({'a': 'x\ty', "b":'x\\y'})";
bool ok = charreader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(ok);
JSONTEST_ASSERT_STRING_EQUAL("", errs);
JSONTEST_ASSERT_EQUAL(2u, root.size());
JSONTEST_ASSERT_STRING_EQUAL("x\ty", root["a"].asString());
JSONTEST_ASSERT_STRING_EQUAL("x\\y", root["b"].asString());
}
}
JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseComment) {
Json::CharReaderBuilder b;
CharReaderPtr reader(b.newCharReader());
Json::Value root;
Json::String errs;
{
char const doc[] = "//comment1\n { //comment2\n \"property\" :"
" \"value\" //comment3\n } //comment4\n";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(ok);
JSONTEST_ASSERT(errs.empty());
JSONTEST_ASSERT_EQUAL("value", root["property"]);
}
{
char const doc[] = "{ \"property\" //comment\n : \"value\" }";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(!ok);
JSONTEST_ASSERT(errs == "* Line 1, Column 14\n"
" Missing ':' after object member name\n");
}
{
char const doc[] = "//comment1\n [ //comment2\n \"value\" //comment3\n,"
" //comment4\n true //comment5\n ] //comment6\n";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(ok);
JSONTEST_ASSERT(errs.empty());
JSONTEST_ASSERT_EQUAL("value", root[0]);
JSONTEST_ASSERT_EQUAL(true, root[1]);
}
}
JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseObjectWithErrors) {
Json::CharReaderBuilder b;
CharReaderPtr reader(b.newCharReader());
Json::Value root;
Json::String errs;
{
char const doc[] = R"({ "property" : "value" )";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(!ok);
JSONTEST_ASSERT(errs == "* Line 1, Column 24\n"
" Missing ',' or '}' in object declaration\n");
JSONTEST_ASSERT_EQUAL("value", root["property"]);
}
{
char const doc[] = R"({ "property" : "value" ,)";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(!ok);
JSONTEST_ASSERT(errs == "* Line 1, Column 25\n"
" Missing '}' or object member name\n");
JSONTEST_ASSERT_EQUAL("value", root["property"]);
}
}
JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseArrayWithErrors) {
Json::CharReaderBuilder b;
CharReaderPtr reader(b.newCharReader());
Json::Value root;
Json::String errs;
{
char const doc[] = "[ \"value\" ";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(!ok);
JSONTEST_ASSERT(errs == "* Line 1, Column 11\n"
" Missing ',' or ']' in array declaration\n");
JSONTEST_ASSERT_EQUAL("value", root[0]);
}
{
char const doc[] = R"([ "value1" "value2" ])";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(!ok);
JSONTEST_ASSERT(errs == "* Line 1, Column 12\n"
" Missing ',' or ']' in array declaration\n");
JSONTEST_ASSERT_EQUAL("value1", root[0]);
}
}
JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseWithOneError) {
Json::CharReaderBuilder b;
CharReaderPtr reader(b.newCharReader());
Json::String errs;
Json::Value root;
char const doc[] = R"({ "property" :: "value" })";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(!ok);
JSONTEST_ASSERT(errs ==
"* Line 1, Column 15\n Syntax error: value, object or array "
"expected.\n");
}
JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseChineseWithOneError) {
Json::CharReaderBuilder b;
CharReaderPtr reader(b.newCharReader());
Json::String errs;
Json::Value root;
char const doc[] = "{ \"pr佐藤erty\" :: \"value\" }";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(!ok);
JSONTEST_ASSERT(errs ==
"* Line 1, Column 19\n Syntax error: value, object or array "
"expected.\n");
}
JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseWithDetailError) {
Json::CharReaderBuilder b;
CharReaderPtr reader(b.newCharReader());
Json::String errs;
Json::Value root;
char const doc[] = R"({ "property" : "v\alue" })";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(!ok);
JSONTEST_ASSERT(errs ==
"* Line 1, Column 16\n Bad escape sequence in string\nSee "
"Line 1, Column 20 for detail.\n");
}
JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseWithStackLimit) {
Json::CharReaderBuilder b;
Json::Value root;
char const doc[] = R"({ "property" : "value" })";
{
b.settings_["stackLimit"] = 2;
CharReaderPtr reader(b.newCharReader());
Json::String errs;
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(ok);
JSONTEST_ASSERT(errs.empty());
JSONTEST_ASSERT_EQUAL("value", root["property"]);
}
{
b.settings_["stackLimit"] = 1;
CharReaderPtr reader(b.newCharReader());
Json::String errs;
JSONTEST_ASSERT_THROWS(
reader->parse(doc, doc + std::strlen(doc), &root, &errs));
}
}
JSONTEST_FIXTURE_LOCAL(CharReaderTest, testOperator) {
const std::string styled = R"({ "property" : "value" })";
std::istringstream iss(styled);
Json::Value root;
iss >> root;
JSONTEST_ASSERT_EQUAL("value", root["property"]);
}
struct CharReaderStrictModeTest : JsonTest::TestCase {};
JSONTEST_FIXTURE_LOCAL(CharReaderStrictModeTest, dupKeys) {
Json::CharReaderBuilder b;
Json::Value root;
char const doc[] =
R"({ "property" : "value", "key" : "val1", "key" : "val2" })";
{
b.strictMode(&b.settings_);
CharReaderPtr reader(b.newCharReader());
Json::String errs;
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(!ok);
JSONTEST_ASSERT_STRING_EQUAL("* Line 1, Column 41\n"
" Duplicate key: 'key'\n",
errs);
JSONTEST_ASSERT_EQUAL("val1", root["key"]); // so far
}
}
struct CharReaderFailIfExtraTest : JsonTest::TestCase {};
JSONTEST_FIXTURE_LOCAL(CharReaderFailIfExtraTest, issue164) {
// This is interpreted as a string value followed by a colon.
Json::CharReaderBuilder b;
Json::Value root;
char const doc[] = R"( "property" : "value" })";
{
b.settings_["failIfExtra"] = false;
CharReaderPtr reader(b.newCharReader());
Json::String errs;
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(ok);
JSONTEST_ASSERT(errs.empty());
JSONTEST_ASSERT_EQUAL("property", root);
}
{
b.settings_["failIfExtra"] = true;
CharReaderPtr reader(b.newCharReader());
Json::String errs;
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(!ok);
JSONTEST_ASSERT_STRING_EQUAL("* Line 1, Column 13\n"
" Extra non-whitespace after JSON value.\n",
errs);
JSONTEST_ASSERT_EQUAL("property", root);
}
{
b.strictMode(&b.settings_);
CharReaderPtr reader(b.newCharReader());
Json::String errs;
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(!ok);
JSONTEST_ASSERT_STRING_EQUAL("* Line 1, Column 13\n"
" Extra non-whitespace after JSON value.\n",
errs);
JSONTEST_ASSERT_EQUAL("property", root);
}
{
b.strictMode(&b.settings_);
b.settings_["failIfExtra"] = false;
CharReaderPtr reader(b.newCharReader());
Json::String errs;
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(!ok);
JSONTEST_ASSERT_STRING_EQUAL(
"* Line 1, Column 1\n"
" A valid JSON document must be either an array or an object value.\n",
errs);
JSONTEST_ASSERT_EQUAL("property", root);
}
}
JSONTEST_FIXTURE_LOCAL(CharReaderFailIfExtraTest, issue107) {
// This is interpreted as an int value followed by a colon.
Json::CharReaderBuilder b;
Json::Value root;
char const doc[] = "1:2:3";
b.settings_["failIfExtra"] = true;
CharReaderPtr reader(b.newCharReader());
Json::String errs;
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(!ok);
JSONTEST_ASSERT_STRING_EQUAL("* Line 1, Column 2\n"
" Extra non-whitespace after JSON value.\n",
errs);
JSONTEST_ASSERT_EQUAL(1, root.asInt());
}
JSONTEST_FIXTURE_LOCAL(CharReaderFailIfExtraTest, commentAfterObject) {
Json::CharReaderBuilder b;
Json::Value root;
{
char const doc[] = "{ \"property\" : \"value\" } //trailing\n//comment\n";
b.settings_["failIfExtra"] = true;
CharReaderPtr reader(b.newCharReader());
Json::String errs;
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(ok);
JSONTEST_ASSERT_STRING_EQUAL("", errs);
JSONTEST_ASSERT_EQUAL("value", root["property"]);
}
}
JSONTEST_FIXTURE_LOCAL(CharReaderFailIfExtraTest, commentAfterArray) {
Json::CharReaderBuilder b;
Json::Value root;
char const doc[] = "[ \"property\" , \"value\" ] //trailing\n//comment\n";
b.settings_["failIfExtra"] = true;
CharReaderPtr reader(b.newCharReader());
Json::String errs;
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(ok);
JSONTEST_ASSERT_STRING_EQUAL("", errs);
JSONTEST_ASSERT_EQUAL("value", root[1u]);
}
JSONTEST_FIXTURE_LOCAL(CharReaderFailIfExtraTest, commentAfterBool) {
Json::CharReaderBuilder b;
Json::Value root;
char const doc[] = " true /*trailing\ncomment*/";
b.settings_["failIfExtra"] = true;
CharReaderPtr reader(b.newCharReader());
Json::String errs;
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(ok);
JSONTEST_ASSERT_STRING_EQUAL("", errs);
JSONTEST_ASSERT_EQUAL(true, root.asBool());
}
JSONTEST_FIXTURE_LOCAL(CharReaderFailIfExtraTest, parseComment) {
Json::CharReaderBuilder b;
b.settings_["failIfExtra"] = true;
CharReaderPtr reader(b.newCharReader());
Json::Value root;
Json::String errs;
{
char const doc[] = " true //comment1\n//comment2\r//comment3\r\n";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(ok);
JSONTEST_ASSERT_STRING_EQUAL("", errs);
JSONTEST_ASSERT_EQUAL(true, root.asBool());
}
{
char const doc[] = " true //com\rment";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(!ok);
JSONTEST_ASSERT_STRING_EQUAL("* Line 2, Column 1\n"
" Extra non-whitespace after JSON value.\n",
errs);
JSONTEST_ASSERT_EQUAL(true, root.asBool());
}
{
char const doc[] = " true //com\nment";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(!ok);
JSONTEST_ASSERT_STRING_EQUAL("* Line 2, Column 1\n"
" Extra non-whitespace after JSON value.\n",
errs);
JSONTEST_ASSERT_EQUAL(true, root.asBool());
}
}
struct CharReaderAllowDropNullTest : JsonTest::TestCase {
using Value = Json::Value;
using ValueCheck = std::function<void(const Value&)>;
Value nullValue = Value{Json::nullValue};
Value emptyArray = Value{Json::arrayValue};
ValueCheck checkEq(const Value& v) {
return [=](const Value& root) { JSONTEST_ASSERT_EQUAL(root, v); };
}
static ValueCheck objGetAnd(std::string idx, ValueCheck f) {
return [=](const Value& root) { f(root.get(idx, true)); };
}
static ValueCheck arrGetAnd(int idx, ValueCheck f) {
return [=](const Value& root) { f(root[idx]); };
}
};
JSONTEST_FIXTURE_LOCAL(CharReaderAllowDropNullTest, issue178) {
struct TestSpec {
int line;
std::string doc;
size_t rootSize;
ValueCheck onRoot;
};
const TestSpec specs[] = {
{__LINE__, R"({"a":,"b":true})", 2, objGetAnd("a", checkEq(nullValue))},
{__LINE__, R"({"a":,"b":true})", 2, objGetAnd("a", checkEq(nullValue))},
{__LINE__, R"({"a":})", 1, objGetAnd("a", checkEq(nullValue))},
{__LINE__, "[]", 0, checkEq(emptyArray)},
{__LINE__, "[null]", 1, nullptr},
{__LINE__, "[,]", 2, nullptr},
{__LINE__, "[,,,]", 4, nullptr},
{__LINE__, "[null,]", 2, nullptr},
{__LINE__, "[,null]", 2, nullptr},
{__LINE__, "[,,]", 3, nullptr},
{__LINE__, "[null,,]", 3, nullptr},
{__LINE__, "[,null,]", 3, nullptr},
{__LINE__, "[,,null]", 3, nullptr},
{__LINE__, "[[],,,]", 4, arrGetAnd(0, checkEq(emptyArray))},
{__LINE__, "[,[],,]", 4, arrGetAnd(1, checkEq(emptyArray))},
{__LINE__, "[,,,[]]", 4, arrGetAnd(3, checkEq(emptyArray))},
};
for (const auto& spec : specs) {
Json::CharReaderBuilder b;
b.settings_["allowDroppedNullPlaceholders"] = true;
std::unique_ptr<Json::CharReader> reader(b.newCharReader());
Json::Value root;
Json::String errs;
bool ok = reader->parse(spec.doc.data(), spec.doc.data() + spec.doc.size(),
&root, &errs);
JSONTEST_ASSERT(ok);
JSONTEST_ASSERT_STRING_EQUAL(errs, "");
if (spec.onRoot) {
spec.onRoot(root);
}
}
}
struct CharReaderAllowNumericKeysTest : JsonTest::TestCase {};
JSONTEST_FIXTURE_LOCAL(CharReaderAllowNumericKeysTest, allowNumericKeys) {
Json::CharReaderBuilder b;
b.settings_["allowNumericKeys"] = true;
Json::Value root;
Json::String errs;
CharReaderPtr reader(b.newCharReader());
char const doc[] = "{15:true,-16:true,12.01:true}";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(ok);
JSONTEST_ASSERT_STRING_EQUAL("", errs);
JSONTEST_ASSERT_EQUAL(3u, root.size());
JSONTEST_ASSERT_EQUAL(true, root.get("15", false));
JSONTEST_ASSERT_EQUAL(true, root.get("-16", false));
JSONTEST_ASSERT_EQUAL(true, root.get("12.01", false));
}
struct CharReaderAllowSingleQuotesTest : JsonTest::TestCase {};
JSONTEST_FIXTURE_LOCAL(CharReaderAllowSingleQuotesTest, issue182) {
Json::CharReaderBuilder b;
b.settings_["allowSingleQuotes"] = true;
Json::Value root;
Json::String errs;
CharReaderPtr reader(b.newCharReader());
{
char const doc[] = "{'a':true,\"b\":true}";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(ok);
JSONTEST_ASSERT_STRING_EQUAL("", errs);
JSONTEST_ASSERT_EQUAL(2u, root.size());
JSONTEST_ASSERT_EQUAL(true, root.get("a", false));
JSONTEST_ASSERT_EQUAL(true, root.get("b", false));
}
{
char const doc[] = "{'a': 'x', \"b\":'y'}";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(ok);
JSONTEST_ASSERT_STRING_EQUAL("", errs);
JSONTEST_ASSERT_EQUAL(2u, root.size());
JSONTEST_ASSERT_STRING_EQUAL("x", root["a"].asString());
JSONTEST_ASSERT_STRING_EQUAL("y", root["b"].asString());
}
}
struct CharReaderAllowZeroesTest : JsonTest::TestCase {};
JSONTEST_FIXTURE_LOCAL(CharReaderAllowZeroesTest, issue176) {
Json::CharReaderBuilder b;
b.settings_["allowSingleQuotes"] = true;
Json::Value root;
Json::String errs;
CharReaderPtr reader(b.newCharReader());
{
char const doc[] = "{'a':true,\"b\":true}";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(ok);
JSONTEST_ASSERT_STRING_EQUAL("", errs);
JSONTEST_ASSERT_EQUAL(2u, root.size());
JSONTEST_ASSERT_EQUAL(true, root.get("a", false));
JSONTEST_ASSERT_EQUAL(true, root.get("b", false));
}
{
char const doc[] = "{'a': 'x', \"b\":'y'}";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(ok);
JSONTEST_ASSERT_STRING_EQUAL("", errs);
JSONTEST_ASSERT_EQUAL(2u, root.size());
JSONTEST_ASSERT_STRING_EQUAL("x", root["a"].asString());
JSONTEST_ASSERT_STRING_EQUAL("y", root["b"].asString());
}
}
struct CharReaderAllowSpecialFloatsTest : JsonTest::TestCase {};
JSONTEST_FIXTURE_LOCAL(CharReaderAllowSpecialFloatsTest, specialFloat) {
Json::CharReaderBuilder b;
CharReaderPtr reader(b.newCharReader());
Json::Value root;
Json::String errs;
{
char const doc[] = "{\"a\": NaN}";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(!ok);
JSONTEST_ASSERT_STRING_EQUAL(
"* Line 1, Column 7\n"
" Syntax error: value, object or array expected.\n",
errs);
}
{
char const doc[] = "{\"a\": Infinity}";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(!ok);
JSONTEST_ASSERT_STRING_EQUAL(
"* Line 1, Column 7\n"
" Syntax error: value, object or array expected.\n",
errs);
}
}
JSONTEST_FIXTURE_LOCAL(CharReaderAllowSpecialFloatsTest, issue209) {
Json::CharReaderBuilder b;
b.settings_["allowSpecialFloats"] = true;
Json::Value root;
Json::String errs;
CharReaderPtr reader(b.newCharReader());
{
char const doc[] = R"({"a":NaN,"b":Infinity,"c":-Infinity,"d":+Infinity})";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(ok);
JSONTEST_ASSERT_STRING_EQUAL("", errs);
JSONTEST_ASSERT_EQUAL(4u, root.size());
double n = root["a"].asDouble();
JSONTEST_ASSERT(std::isnan(n));
JSONTEST_ASSERT_EQUAL(std::numeric_limits<double>::infinity(),
root.get("b", 0.0));
JSONTEST_ASSERT_EQUAL(-std::numeric_limits<double>::infinity(),
root.get("c", 0.0));
JSONTEST_ASSERT_EQUAL(std::numeric_limits<double>::infinity(),
root.get("d", 0.0));
}
struct TestData {
int line;
bool ok;
Json::String in;
};
const TestData test_data[] = {
{__LINE__, true, "{\"a\":9}"}, //
{__LINE__, false, "{\"a\":0Infinity}"}, //
{__LINE__, false, "{\"a\":1Infinity}"}, //
{__LINE__, false, "{\"a\":9Infinity}"}, //
{__LINE__, false, "{\"a\":0nfinity}"}, //
{__LINE__, false, "{\"a\":1nfinity}"}, //
{__LINE__, false, "{\"a\":9nfinity}"}, //
{__LINE__, false, "{\"a\":nfinity}"}, //
{__LINE__, false, "{\"a\":.nfinity}"}, //
{__LINE__, false, "{\"a\":9nfinity}"}, //
{__LINE__, false, "{\"a\":-nfinity}"}, //
{__LINE__, true, "{\"a\":Infinity}"}, //
{__LINE__, false, "{\"a\":.Infinity}"}, //
{__LINE__, false, "{\"a\":_Infinity}"}, //
{__LINE__, false, "{\"a\":_nfinity}"}, //
{__LINE__, true, "{\"a\":-Infinity}"}, //
{__LINE__, true, "{\"a\":+Infinity}"} //
};
for (const auto& td : test_data) {
bool ok = reader->parse(&*td.in.begin(), &*td.in.begin() + td.in.size(),
&root, &errs);
JSONTEST_ASSERT(td.ok == ok) << "line:" << td.line << "\n"
<< " expected: {"
<< "ok:" << td.ok << ", in:\'" << td.in << "\'"
<< "}\n"
<< " actual: {"
<< "ok:" << ok << "}\n";
}
{
char const doc[] = R"({"posInf": +Infinity, "NegInf": -Infinity})";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(ok);
JSONTEST_ASSERT_STRING_EQUAL("", errs);
JSONTEST_ASSERT_EQUAL(2u, root.size());
JSONTEST_ASSERT_EQUAL(std::numeric_limits<double>::infinity(),
root["posInf"].asDouble());
JSONTEST_ASSERT_EQUAL(-std::numeric_limits<double>::infinity(),
root["NegInf"].asDouble());
}
}
struct EscapeSequenceTest : JsonTest::TestCase {};
JSONTEST_FIXTURE_LOCAL(EscapeSequenceTest, readerParseEscapeSequence) {
Json::Reader reader;
Json::Value root;
bool ok = reader.parse("[\"\\\"\",\"\\/\",\"\\\\\",\"\\b\","
"\"\\f\",\"\\n\",\"\\r\",\"\\t\","
"\"\\u0278\",\"\\ud852\\udf62\"]\n",
root);
JSONTEST_ASSERT(ok);
JSONTEST_ASSERT(reader.getFormattedErrorMessages().empty());
JSONTEST_ASSERT(reader.getStructuredErrors().empty());
}
JSONTEST_FIXTURE_LOCAL(EscapeSequenceTest, charReaderParseEscapeSequence) {
Json::CharReaderBuilder b;
CharReaderPtr reader(b.newCharReader());
Json::Value root;
Json::String errs;
char const doc[] = "[\"\\\"\",\"\\/\",\"\\\\\",\"\\b\","
"\"\\f\",\"\\n\",\"\\r\",\"\\t\","
"\"\\u0278\",\"\\ud852\\udf62\"]";
bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
JSONTEST_ASSERT(ok);
JSONTEST_ASSERT(errs.empty());
}
JSONTEST_FIXTURE_LOCAL(EscapeSequenceTest, writeEscapeSequence) {
Json::FastWriter writer;
const Json::String expected("[\"\\\"\",\"\\\\\",\"\\b\","
"\"\\f\",\"\\n\",\"\\r\",\"\\t\","
"\"\\u0278\",\"\\ud852\\udf62\"]\n");
Json::Value root;
root[0] = "\"";
root[1] = "\\";
root[2] = "\b";
root[3] = "\f";
root[4] = "\n";
root[5] = "\r";
root[6] = "\t";
root[7] = "ɸ";
root[8] = "𤭢";
const Json::String result = writer.write(root);
JSONTEST_ASSERT_STRING_EQUAL(expected, result);
}
struct BuilderTest : JsonTest::TestCase {};
JSONTEST_FIXTURE_LOCAL(BuilderTest, settings) {
{
Json::Value errs;
Json::CharReaderBuilder rb;
JSONTEST_ASSERT_EQUAL(false, rb.settings_.isMember("foo"));
JSONTEST_ASSERT_EQUAL(true, rb.validate(&errs));
rb["foo"] = "bar";
JSONTEST_ASSERT_EQUAL(true, rb.settings_.isMember("foo"));
JSONTEST_ASSERT_EQUAL(false, rb.validate(&errs));
}
{
Json::Value errs;
Json::StreamWriterBuilder wb;
JSONTEST_ASSERT_EQUAL(false, wb.settings_.isMember("foo"));
JSONTEST_ASSERT_EQUAL(true, wb.validate(&errs));
wb["foo"] = "bar";
JSONTEST_ASSERT_EQUAL(true, wb.settings_.isMember("foo"));
JSONTEST_ASSERT_EQUAL(false, wb.validate(&errs));
}
}
struct BomTest : JsonTest::TestCase {};
JSONTEST_FIXTURE_LOCAL(BomTest, skipBom) {
const std::string with_bom = "\xEF\xBB\xBF{\"key\" : \"value\"}";
Json::Value root;
JSONCPP_STRING errs;
std::istringstream iss(with_bom);
bool ok = parseFromStream(Json::CharReaderBuilder(), iss, &root, &errs);
// The default behavior is to skip the BOM, so we can parse it normally.
JSONTEST_ASSERT(ok);
JSONTEST_ASSERT(errs.empty());
JSONTEST_ASSERT_STRING_EQUAL(root["key"].asString(), "value");
}
JSONTEST_FIXTURE_LOCAL(BomTest, notSkipBom) {
const std::string with_bom = "\xEF\xBB\xBF{\"key\" : \"value\"}";
Json::Value root;
JSONCPP_STRING errs;
std::istringstream iss(with_bom);
Json::CharReaderBuilder b;
b.settings_["skipBom"] = false;
bool ok = parseFromStream(b, iss, &root, &errs);
// Detect the BOM, and failed on it.
JSONTEST_ASSERT(!ok);
JSONTEST_ASSERT(!errs.empty());
}
struct IteratorTest : JsonTest::TestCase {};
JSONTEST_FIXTURE_LOCAL(IteratorTest, convert) {
Json::Value j;
const Json::Value& cj = j;
auto it = j.begin();
Json::Value::const_iterator cit;
cit = it;
JSONTEST_ASSERT(cit == cj.begin());
}
JSONTEST_FIXTURE_LOCAL(IteratorTest, decrement) {
Json::Value json;
json["k1"] = "a";
json["k2"] = "b";
std::vector<std::string> values;
for (auto it = json.end(); it != json.begin();) {
--it;
values.push_back(it->asString());
}
JSONTEST_ASSERT((values == std::vector<std::string>{"b", "a"}));
}
JSONTEST_FIXTURE_LOCAL(IteratorTest, reverseIterator) {
Json::Value json;
json["k1"] = "a";
json["k2"] = "b";
std::vector<std::string> values;
using Iter = decltype(json.begin());
auto re = std::reverse_iterator<Iter>(json.begin());
for (auto it = std::reverse_iterator<Iter>(json.end()); it != re; ++it) {
values.push_back(it->asString());
}
JSONTEST_ASSERT((values == std::vector<std::string>{"b", "a"}));
}
JSONTEST_FIXTURE_LOCAL(IteratorTest, distance) {
{
Json::Value json;
json["k1"] = "a";
json["k2"] = "b";
int i = 0;
auto it = json.begin();
for (;; ++it, ++i) {
auto dist = it - json.begin();
JSONTEST_ASSERT_EQUAL(i, dist);
if (it == json.end())
break;
}
}
{
Json::Value empty;
JSONTEST_ASSERT_EQUAL(0, empty.end() - empty.end());
JSONTEST_ASSERT_EQUAL(0, empty.end() - empty.begin());
}
}
JSONTEST_FIXTURE_LOCAL(IteratorTest, nullValues) {
{
Json::Value json;
auto end = json.end();
auto endCopy = end;
JSONTEST_ASSERT(endCopy == end);
endCopy = end;
JSONTEST_ASSERT(endCopy == end);
}
{
// Same test, now with const Value.
const Json::Value json;
auto end = json.end();
auto endCopy = end;
JSONTEST_ASSERT(endCopy == end);
endCopy = end;
JSONTEST_ASSERT(endCopy == end);
}
}
JSONTEST_FIXTURE_LOCAL(IteratorTest, staticStringKey) {
Json::Value json;
json[Json::StaticString("k1")] = "a";
JSONTEST_ASSERT_EQUAL(Json::Value("k1"), json.begin().key());
}
JSONTEST_FIXTURE_LOCAL(IteratorTest, names) {
Json::Value json;
json["k1"] = "a";
json["k2"] = "b";
Json::ValueIterator it = json.begin();
JSONTEST_ASSERT(it != json.end());
JSONTEST_ASSERT_EQUAL(Json::Value("k1"), it.key());
JSONTEST_ASSERT_STRING_EQUAL("k1", it.name());
JSONTEST_ASSERT_STRING_EQUAL("k1", it.memberName());
JSONTEST_ASSERT_EQUAL(-1, it.index());
++it;
JSONTEST_ASSERT(it != json.end());
JSONTEST_ASSERT_EQUAL(Json::Value("k2"), it.key());
JSONTEST_ASSERT_STRING_EQUAL("k2", it.name());
JSONTEST_ASSERT_STRING_EQUAL("k2", it.memberName());
JSONTEST_ASSERT_EQUAL(-1, it.index());
++it;
JSONTEST_ASSERT(it == json.end());
}
JSONTEST_FIXTURE_LOCAL(IteratorTest, indexes) {
Json::Value json;
json[0] = "a";
json[1] = "b";
Json::ValueIterator it = json.begin();
JSONTEST_ASSERT(it != json.end());
JSONTEST_ASSERT_EQUAL(Json::Value(Json::ArrayIndex(0)), it.key());
JSONTEST_ASSERT_STRING_EQUAL("", it.name());
JSONTEST_ASSERT_EQUAL(0, it.index());
++it;
JSONTEST_ASSERT(it != json.end());
JSONTEST_ASSERT_EQUAL(Json::Value(Json::ArrayIndex(1)), it.key());
JSONTEST_ASSERT_STRING_EQUAL("", it.name());
JSONTEST_ASSERT_EQUAL(1, it.index());
++it;
JSONTEST_ASSERT(it == json.end());
}
JSONTEST_FIXTURE_LOCAL(IteratorTest, constness) {
Json::Value const v;
JSONTEST_ASSERT_THROWS(
Json::Value::iterator it(v.begin())); // Compile, but throw.
Json::Value value;
for (int i = 9; i < 12; ++i) {
Json::OStringStream out;
out << std::setw(2) << i;
Json::String str = out.str();
value[str] = str;
}
Json::OStringStream out;
// in old code, this will get a compile error
Json::Value::const_iterator iter = value.begin();
for (; iter != value.end(); ++iter) {
out << *iter << ',';
}
Json::String expected = R"(" 9","10","11",)";
JSONTEST_ASSERT_STRING_EQUAL(expected, out.str());
}
struct RValueTest : JsonTest::TestCase {};
JSONTEST_FIXTURE_LOCAL(RValueTest, moveConstruction) {
Json::Value json;
json["key"] = "value";
Json::Value moved = std::move(json);
JSONTEST_ASSERT(moved != json); // Possibly not nullValue; definitely not
// equal.
JSONTEST_ASSERT_EQUAL(Json::objectValue, moved.type());
JSONTEST_ASSERT_EQUAL(Json::stringValue, moved["key"].type());
}
struct FuzzTest : JsonTest::TestCase {};
// Build and run the fuzz test without any fuzzer, so that it's guaranteed not
// go out of date, even if it's never run as an actual fuzz test.
JSONTEST_FIXTURE_LOCAL(FuzzTest, fuzzDoesntCrash) {
const std::string example = "{}";
JSONTEST_ASSERT_EQUAL(
0,
LLVMFuzzerTestOneInput(reinterpret_cast<const uint8_t*>(example.c_str()),
example.size()));
}
int main(int argc, const char* argv[]) {
JsonTest::Runner runner;
for (auto& local : local_) {
runner.add(local);
}
return runner.runCommandLine(argc, argv);
}
struct MemberTemplateAs : JsonTest::TestCase {
template <typename T, typename F>
JsonTest::TestResult& EqEval(T v, F f) const {
const Json::Value j = v;
return JSONTEST_ASSERT_EQUAL(j.as<T>(), f(j));
}
};
JSONTEST_FIXTURE_LOCAL(MemberTemplateAs, BehavesSameAsNamedAs) {
const Json::Value jstr = "hello world";
JSONTEST_ASSERT_STRING_EQUAL(jstr.as<const char*>(), jstr.asCString());
JSONTEST_ASSERT_STRING_EQUAL(jstr.as<Json::String>(), jstr.asString());
EqEval(Json::Int(64), [](const Json::Value& j) { return j.asInt(); });
EqEval(Json::UInt(64), [](const Json::Value& j) { return j.asUInt(); });
#if defined(JSON_HAS_INT64)
EqEval(Json::Int64(64), [](const Json::Value& j) { return j.asInt64(); });
EqEval(Json::UInt64(64), [](const Json::Value& j) { return j.asUInt64(); });
#endif // if defined(JSON_HAS_INT64)
EqEval(Json::LargestInt(64),
[](const Json::Value& j) { return j.asLargestInt(); });
EqEval(Json::LargestUInt(64),
[](const Json::Value& j) { return j.asLargestUInt(); });
EqEval(69.69f, [](const Json::Value& j) { return j.asFloat(); });
EqEval(69.69, [](const Json::Value& j) { return j.asDouble(); });
EqEval(false, [](const Json::Value& j) { return j.asBool(); });
EqEval(true, [](const Json::Value& j) { return j.asBool(); });
}
class MemberTemplateIs : public JsonTest::TestCase {};
JSONTEST_FIXTURE_LOCAL(MemberTemplateIs, BehavesSameAsNamedIs) {
const Json::Value values[] = {true, 142, 40.63, "hello world"};
for (const Json::Value& j : values) {
JSONTEST_ASSERT_EQUAL(j.is<bool>(), j.isBool());
JSONTEST_ASSERT_EQUAL(j.is<Json::Int>(), j.isInt());
JSONTEST_ASSERT_EQUAL(j.is<Json::Int64>(), j.isInt64());
JSONTEST_ASSERT_EQUAL(j.is<Json::UInt>(), j.isUInt());
JSONTEST_ASSERT_EQUAL(j.is<Json::UInt64>(), j.isUInt64());
JSONTEST_ASSERT_EQUAL(j.is<double>(), j.isDouble());
JSONTEST_ASSERT_EQUAL(j.is<Json::String>(), j.isString());
}
}
class VersionTest : public JsonTest::TestCase {};
JSONTEST_FIXTURE_LOCAL(VersionTest, VersionNumbersMatch) {
std::ostringstream vstr;
vstr << JSONCPP_VERSION_MAJOR << '.' << JSONCPP_VERSION_MINOR << '.'
<< JSONCPP_VERSION_PATCH;
JSONTEST_ASSERT_EQUAL(vstr.str(), std::string(JSONCPP_VERSION_STRING));
}
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
| YifuLiu/AliOS-Things | components/jsoncpp/src/test_lib_json/main.cpp | C++ | apache-2.0 | 140,187 |
/*
* Copyright (C) 2015-2021 Alibaba Group Holding Limited
*/
#include "aos/kv.h"
#if AOS_COMP_CLI
#include "aos/cli.h"
#endif
/*
kv_init has been called in aos_components_init, but can called repeatedly.
#ifdef AOS_COMP_KV
kv_init();
#endif
*/
static void kv_comp_example(int argc, char **argv)
{
(void)argc;
(void)argv;
char *key = "test_kv_key";
char *set_value = "test_kv_value";
int set_len = strlen(set_value);
char get_value[32] = {0};
int get_len = 32;
int ret = -1;
ret = aos_kv_set(key, set_value, set_len, 1);
if(ret){
printf("kv comp test fail! aos_kv_set ret:%d\r\n", ret);
return;
}
ret = aos_kv_get(key, get_value, &get_len);
if(ret){
printf("kv comp test fail! aos_kv_get ret:%d\r\n", ret);
return;
}
if(get_len != set_len){
printf("kv comp test fail! get_len != set_len, get_len:%d\r\n", get_len);
return;
}
if(strcmp(get_value, set_value)){
printf("kv comp test fail! get value not right! get_value:%s\r\n", get_value);
return;
}
printf("kv comp test success!\r\n");
return;
}
#if AOS_COMP_CLI
/* reg args: fun, cmd, description*/
ALIOS_CLI_CMD_REGISTER(kv_comp_example, kv_example, kv component base example)
#endif
| YifuLiu/AliOS-Things | components/kv/example/kv_example.c | C | apache-2.0 | 1,297 |
/*
* Copyright (C) 2017-2021 Alibaba Group Holding Limited
*/
#ifndef AOS_KV_H
#define AOS_KV_H
#include <aos/kernel.h>
#include <string.h>
#ifdef __cplusplus
extern "C" {
#endif
/** @defgroup kv_aos_api kv
* @{
*/
/**
* Init the kv module.
*
* @retrun 0 on success, otherwise will be failed.
*/
int aos_kv_init(void);
/**
* Deinit the kv module.
*
* @retrun none
*/
void aos_kv_deinit(void);
/**
* Add a new KV pair.
*
* @param[in] key the key of the KV pair.
* @param[in] value the value of the KV pair.
* @param[in] len the length of the value.
* @param[in] sync save the KV pair to flash right now (should always be 1).
*
* @return 0 on success, negative error on failure.
*/
int aos_kv_set(const char *key, const void *value, int len, int sync);
/**
* Get the KV pair's value stored in buffer by its key.
*
* @note: the buffer_len should be larger than the real length of the value,
* otherwise buffer would be NULL.
*
* @param[in] key the key of the KV pair to get.
* @param[out] buffer the memory to store the value.
* @param[in-out] buffer_len in: the length of the input buffer.
* out: the real length of the value.
*
* @return 0 on success, negative error on failure.
*/
int aos_kv_get(const char *key, void *buffer, int *buffer_len);
/**
* Delete the KV pair by its key.
*
* @param[in] key the key of the KV pair to delete.
*
* @return 0 on success, negative error on failure.
*/
int aos_kv_del(const char *key);
/**
* Delete the KV pair by its prefix.
*
* @param[in] prefix the prefix of the kv pair which is need to delete.
*
* @return 0 on success, negative error on failure.
*/
int aos_kv_del_by_prefix(const char *prefix);
/**
* Add a new KV pair with encryption.
*
* @param[in] key the key of the KV pair.
* @param[in] value the value of the KV pair.
* @param[in] len the length of the value.
* @param[in] sync save the KV pair to flash right now (should always be 1).
*
* @return 0 on success, negative error on failure.
*/
int aos_kv_secure_set(const char *key, const void *value, int len, int sync);
/**
* Get the KV pair's value stored in buffer by its key with decrypt.
*
* @note: the buffer_len should be larger than the real length of the value,
* otherwise buffer would be NULL.
*
* @param[in] key the key of the KV pair to get.
* @param[out] buffer the memory to store the value.
* @param[in-out] buffer_len in: the length of the input buffer.
* out: the real length of the value.
*
* @return 0 on success, negative error on failure.
*/
int aos_kv_secure_get(const char *key, void *buffer, int *buffer_len);
/**
* @}
*/
#ifdef __cplusplus
}
#endif
#endif /* AOS_KV_H */
| YifuLiu/AliOS-Things | components/kv/include/aos/kv.h | C | apache-2.0 | 2,833 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef KV_API_H
#define KV_API_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdint.h>
/* Key-value function return code description */
#define KV_OK 0 /* Successed */
#define KV_LOOP_CONTINUE 10000 /* Loop Continue */
#define KV_ERR_NO_SPACE -10001 /* The space is out of range */
#define KV_ERR_INVALID_PARAM -10002 /* The parameter is invalid */
#define KV_ERR_MALLOC_FAILED -10003 /* The os memory malloc error */
#define KV_ERR_NOT_FOUND -10004 /* Could not found the item */
#define KV_ERR_FLASH_READ -10005 /* The flash read operation error */
#define KV_ERR_FLASH_WRITE -10006 /* The flash write operation error */
#define KV_ERR_FLASH_ERASE -10007 /* The flash erase operation error */
#define KV_ERR_OS_LOCK -10008 /* The error related to os lock */
#define KV_ERR_OS_SEM -10009 /* The error related to os semaphose */
#define KV_ERR_ENCRYPT -10010 /* Data encryption error */
#define KV_ERR_DECRYPT -10011 /* Data decryption error */
#define KV_ERR_NOT_SUPPORT -10012 /* The function is not support yet */
/**
* @brief Initialize the kv module
*
* @retrun 0 on success, otherwise will be failed.
*
*/
int32_t kv_init(void);
/**
* @brief De-initialize the kv module
*
* @retrun none
*/
void kv_deinit(void);
/**
* Add a new KV pair.
*
* @param[in] key the key of the KV pair.
* @param[in] val the value of the KV pair.
* @param[in] len the length of the value.
*
* @return 0 on success, negative error on failure.
*/
int32_t kv_item_set(const char *key, const void *val, int32_t len);
/**
* Get the KV pair's value stored in buffer by its key.
*
* @note: the buffer_len should be larger than the real length of the value,
* otherwise buffer would be NULL.
*
* @param[in] key the key of the KV pair to get.
* @param[out] buffer the memory to store the value.
* @param[in-out] buffer_len in: the length of the input buffer.
* out: the real length of the value.
*
* @return 0 on success, negative error on failure.
*/
int32_t kv_item_get(const char *key, void *buffer, int32_t *buffer_len);
/**
* Delete the KV pair by its key.
*
* @param[in] key the key of the KV pair to delete.
*
* @return 0 on success, negative error on failure.
*/
int32_t kv_item_delete(const char *key);
/**
* Delete the KV pair by its prefix.
*
* @param[in] prefix the prefix of the kv pair which is need to delete.
*
* @return 0 on success, negative error on failure.
*/
int32_t kv_item_delete_by_prefix(const char *prefix);
/**
* Add a new KV pair (secure mode).
*
* @param[in] key the key of the KV pair.
* @param[in] val the value of the KV pair.
* @param[in] len the length of the value.
*
* @return 0 on success, negative error on failure.
*/
int32_t kv_item_secure_set(const char *key, const void *val, int32_t len);
/**
* Get the KV pair's value stored in buffer by its key. (secure mode)
*
* @note: the buffer_len should be larger than the real length of the value,
* otherwise buffer would be NULL.
*
* @param[in] key the key of the KV pair to get.
* @param[out] buffer the memory to store the value.
* @param[in-out] buffer_len in: the length of the input buffer.
* out: the real length of the value.
*
* @return 0 on success, negative error on failure.
*/
int32_t kv_item_secure_get(const char *key, void *buffer, int32_t *buffer_len);
#ifdef __cplusplus
}
#endif
#endif /* KV_API_H */
| YifuLiu/AliOS-Things | components/kv/include/kv_api.h | C | apache-2.0 | 3,648 |
/**
* @file kv.h
* @copyright Copyright (C) 2015-2018 Alibaba Group Holding Limited
*/
#ifndef AOS_KV_H
#define AOS_KV_H
#ifdef __cplusplus
extern "C" {
#endif
#include <kv_api.h>
/** @addtogroup aos_kv KV
* KV AOS API: Data storing service based on key-value paring.
*
* @{
*/
/**
* Init the kv module.
*
* @retrun 0 on success, otherwise will be failed.
*/
int aos_kv_init(void);
/**
* Deinit the kv module.
*
* @retrun none
*/
void aos_kv_deinit(void);
/**
* Add a new KV pair.
*
* @param[in] key the key of the KV pair.
* @param[in] value the value of the KV pair.
* @param[in] len the length of the value.
* @param[in] sync save the KV pair to flash right now (should always be 1).
*
* @return 0 on success, negative error on failure.
*/
int aos_kv_set(const char *key, const void *value, int len, int sync);
/**
* Get the KV pair's value stored in buffer by its key.
*
* @note: the buffer_len should not be smaller than the real length of the value,
* otherwise buffer would be NULL.
*
* @param[in] key the key of the KV pair to get.
* @param[out] buffer the memory to store the value.
* @param[in,out] buffer_len in: the length of the input buffer.
* out: the real length of the value.
*
* @return 0 on success, negative error on failure.
*/
int aos_kv_get(const char *key, void *buffer, int *buffer_len);
/**
* Delete the KV pair by its key.
*
* @param[in] key the key of the KV pair to delete.
*
* @return 0 on success, negative error on failure.
*/
int aos_kv_del(const char *key);
/**
* Delete the KV pair by its prefix.
*
* @param[in] prefix the prefix of the kv pair which is need to delete.
*
* @return 0 on success, negative error on failure.
*/
int aos_kv_del_by_prefix(const char *prefix);
/**
* Add a new KV pair with encryption.
*
* @param[in] key the key of the KV pair.
* @param[in] value the value of the KV pair.
* @param[in] len the length of the value.
* @param[in] sync save the KV pair to flash right now (should always be 1).
*
* @return 0 on success, negative error on failure.
*/
int aos_kv_secure_set(const char *key, const void *value, int len, int sync);
/**
* Get the KV pair's value stored in buffer by its key with decrypt.
*
* @note: the buffer_len should be larger than the real length of the value,
* otherwise buffer would be NULL.
*
* @param[in] key the key of the KV pair to get.
* @param[out] buffer the memory to store the value.
* @param[in-out] buffer_len in: the length of the input buffer.
* out: the real length of the value.
*
* @return 0 on success, negative error on failure.
*/
int aos_kv_secure_get(const char *key, void *buffer, int *buffer_len);
/** @} */
#ifdef __cplusplus
}
#endif
#endif /* AOS_KV_H */
| YifuLiu/AliOS-Things | components/kv/internal/kv.h | C | apache-2.0 | 2,903 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef KV_ADAPT_H
#define KV_ADAPT_H
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Read KV flash partition
*
* @param[in] offset the offset of the partition
* @param[out] buf the store buffer for read
* @param[in] nbytes the length to read
*
* @return 0 on success, otherwise will be failed
*/
int32_t kv_flash_read(uint32_t offset, void *buf, uint32_t nbytes);
/**
* @brief Write KV flash partition
*
* @param[in] offset the offset of the partition
* @param[in] buf the store buffer for write
* @param[in] nbytes the length to write
*
* @return 0 on success, otherwise will be failed
*/
int32_t kv_flash_write(uint32_t offset, void *buf, uint32_t nbytes);
/**
* @brief Erase KV flash partition
*
* @param[in] offset the offset of the partition
* @param[in] size the length to erase
*
* @return 0 on success, otherwise will be failed
*/
int32_t kv_flash_erase(uint32_t offset, uint32_t size);
/**
* @brief Create OS lock
*
* @return lock pointer for success, NULL is failed
*/
void *kv_lock_create(void);
/**
* @breif Free OS lock
*
* @param[in] lock pointer to the os lock
*
* @return 0 on success, otherwise is failed
*
*/
int32_t kv_lock_free(void *lock);
/**
* @brief Lock the lock
*
* @param[in] lock pointer to the os lock
*
* @return 0 on success, otherwise is failed
*
*/
int32_t kv_lock(void *lock);
/**
* @brief Unlock the lock
*
* @param[in] lock pointer to the os lock
*
* @return 0 on success, otherwise is failed
*
*/
int32_t kv_unlock(void *lock);
/**
* @brief Create OS semaphore
*
* @return semaphore pointer for success, NULL is failed
*
*/
void *kv_sem_create(void);
/**
* @brief Delete OS semaphore
*
* @param[in] sem pointer to the os semaphore
*
* @return 0 on success, otherwise is failed
*
*/
int32_t kv_sem_free(void *sem);
/**
* @brief Take a semaphore
*
* @param[in] sem pointer to the semaphore
*
* @return 0 on success, otherwise is failed
*
*/
int32_t kv_sem_wait(void *sem);
/**
* @brief Give a semaphore and wakeup all waiting task
*
* @param[in] sem pointer to the semaphore
*
* @return 0 on success, otherwise is failed
*
*/
int32_t kv_sem_post_all(void *sem);
/**
* @brief Create a task
*
* @param[in] name name of the task
* @param[in] fn the entry function of task
* @param[in] arg the parameter of task entry function
* @param[in] stack the size of task stack
*
* @return 0 on success, otherwise is failed
*/
int32_t kv_start_task(const char *name, void (*fn)(void *), void *arg,
uint32_t stack);
/**
* @brief Delete a task
*
* @return none
*/
void kv_delete_task(void);
/**
* @brief wrapper of MM allocation
*
* @param[in] size size of the mem to alloc
*
* @return NULL is error, other is memory address
*
*/
void *kv_malloc(uint32_t size);
/**
* @brief wrapper of MM free
*
* @param[in] ptr address point of the mem
*
*/
void kv_free(void *ptr);
/**
* @brief Encrypt data
*
* @param[in] input the pointer to the input data
* @param[out] output the pointer to the encryption result
* @param[in] input_len the length of the input data
*
* @return 0 on success, otherwise is failed
*/
int32_t kv_secure_encrypt(uint8_t *input, uint8_t *output, uint32_t input_len);
/**
* @brief Decrypt data
*
* @param[in] input the pointer to the input data
* @param[out] output the pointer to the decryption result
* @param[in] input_len the length of the input data
*
* @return 0 on success, otherwise is failed
*/
int32_t kv_secure_decrypt(uint8_t *input, uint8_t *output, uint32_t input_len);
/**
* @brief Get the key for encrypt/decrypt algorithm
*
* @param[in] key_len the length of the key
*
* @return key buffer pointer, NULL is error
*/
uint8_t *kv_secure_get_key(uint32_t key_len);
/**
* @brief Get the iv for encrypt/decrypt algorithm
*
* @param[in] iv_len the length of the iv
*
* @return iv buffer pointer, NULL is error
*/
uint8_t *kv_secure_get_iv(uint32_t iv_len);
#ifdef __cplusplus
}
#endif
#endif /* KV_ADAPT_H */
| YifuLiu/AliOS-Things | components/kv/internal/kv_adapt.h | C | apache-2.0 | 4,154 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef KV_CONF_H
#define KV_CONF_H
/* The totally storage size for key-value store */
#ifndef KV_CONFIG_TOTAL_SIZE
#define KV_TOTAL_SIZE (8 * 1024)
#else
#define KV_TOTAL_SIZE KV_CONFIG_TOTAL_SIZE
#endif
/* The physical parition for key-value store */
#ifndef KV_CONFIG_PARTITION
#define KV_PARTITION HAL_PARTITION_PARAMETER_2
#else
#define KV_PARTITION KV_CONFIG_PARTITION
#endif
/* The number of bits in block size */
#ifndef KV_CONFIG_BLOCK_SIZE_BITS
/* Default is 4K bytes, should equal or larger than erase sector size */
#define KV_BLOCK_SIZE_BITS 12
#else
#define KV_BLOCK_SIZE_BITS KV_CONFIG_BLOCK_SIZE_BITS
#endif
#ifndef KV_CONFIG_TASK_PRIORITY
#define KV_TASK_PRIORITY 32
#else
#define KV_TASK_PRIORITY KV_CONFIG_TASK_PRIORITY
#endif
#ifndef KV_CONFIG_TASK_STACK_SIZE
#define KV_TASK_STACK_SIZE (4 * 1024)
#else
#define KV_TASK_STACK_SIZE KV_CONFIG_TASK_STACK_SIZE
#endif
#ifndef KV_CONFIG_MAX_KEY_LEN
#define KV_MAX_KEY_LEN 128
#else
#define KV_MAX_KEY_LEN KV_CONFIG_MAX_KEY_LEN
#endif
#ifndef KV_CONFIG_MAX_VAL_LEN
#define KV_MAX_VAL_LEN 512
#else
#define KV_MAX_VAL_LEN KV_CONFIG_MAX_VAL_LEN
#endif
#ifndef KV_CONFIG_SECURE_SUPPORT
#define KV_SECURE_SUPPORT 0
#else
#define KV_SECURE_SUPPORT KV_CONFIG_SECURE_SUPPORT
#endif
#if (KV_SECURE_SUPPORT > 0)
#ifndef KV_CONFIG_SECURE_LEVEL
#define KV_SECURE_LEVEL 1
#else
#define KV_SECURE_LEVEL KV_CONFIG_SECURE_LEVEL
#endif
#ifndef KV_CONFIG_SECURE_CRYPT_IMPL
#define KV_SECURE_CRYPT_IMPL 1
#else
#define KV_SECURE_CRYPT_IMPL KV_CONFIG_SECURE_CRYPT_IMPL
#endif
#endif
#endif /* KV_CONF_H */
| YifuLiu/AliOS-Things | components/kv/internal/kv_conf.h | C | apache-2.0 | 1,631 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef KV_TYPES_H
#define KV_TYPES_H
#include <stdint.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include "kv_conf.h"
#if (KV_BLOCK_SIZE_BITS >= 16) || (KV_TOTAL_SIZE >= 0x10000)
typedef uint32_t kv_size_t; /* If more than 64KB */
#else
typedef uint16_t kv_size_t;
#endif
#ifdef _WIN32
#define KVMAGR_PKD
#else
#define KVMAGR_PKD __attribute__((packed))
#endif
#ifdef _WIN32
#pragma pack(push, 1)
#endif
/**
* Flash block header description
*
* magic: The magic number of block
* state: The state of the block
*
*/
typedef struct _block_header_t
{
uint8_t magic;
uint8_t state;
uint8_t reserved[2];
} KVMAGR_PKD block_hdr_t;
/**
* Key-value item header description
*
* magic: The magic number of key-value item
* state: The state of key-value item
* crc: The crc-8 value of key-value item
* key_len: The length of the key
* val_len: The length of the value
* origin_off: The origin item offset
*
*/
typedef struct _item_header_t
{
uint8_t magic;
uint8_t state;
uint8_t crc;
uint8_t key_len;
uint16_t val_len;
kv_size_t origin_off;
} KVMAGR_PKD item_hdr_t;
#ifdef _WIN32
#pragma pack(pop)
#endif
/**
* Defination of block information
*
* KV_BLOCK_SIZE: block size, default is 4K bytes
* KV_BLOCK_NUMS: numbers of blocks, must be bigger than KV_GC_RESERVED
* KV_BLOCK_OFF_MASK: the mask of the block offset in kv store
* KV_BLOCK_HDR_SIZE: The block header size, default is 4 bytes
*
*/
#define KV_BLOCK_SIZE (1 << KV_BLOCK_SIZE_BITS)
#define KV_BLOCK_NUMS (KV_TOTAL_SIZE >> KV_BLOCK_SIZE_BITS)
#define KV_BLOCK_OFF_MASK ~(KV_BLOCK_SIZE - 1)
#define KV_BLOCK_HDR_SIZE sizeof(block_hdr_t)
/**
* Block state information
*
* KV_BLOCK_STATE_USED: block is inused and without dirty data
* KV_BLOCK_STATE_CLEAN: block is clean, ready for used
* KV_BLOCK_STATE_DIRTY: block is inused and with dirty data
*
*/
#define KV_BLOCK_STATE_USED 0xCC
#define KV_BLOCK_STATE_CLEAN 0xEE
#define KV_BLOCK_STATE_DIRTY 0x44
#define INVALID_BLK_STATE(state) (((state) != KV_BLOCK_STATE_USED) && \
((state) != KV_BLOCK_STATE_CLEAN) && \
((state) != KV_BLOCK_STATE_DIRTY))
/**
* Defination of item information
*
* KV_ITEM_HDR_SIZE: the item header size
* KV_ITEM_MAX_LEN: the max length of the item
*
*/
#define KV_ITEM_HDR_SIZE sizeof(item_hdr_t)
#define KV_ITEM_MAX_LEN (KV_ITEM_HDR_SIZE + KV_MAX_KEY_LEN + KV_MAX_VAL_LEN)
/**
* Item state information
*
* KV_ITEM_STATE_NORMAL: the item is valid
* KV_ITEM_STATE_DELETE: the item had beed deleted
*
*/
#define KV_ITEM_STATE_NORMAL 0xEE
#define KV_ITEM_STATE_DELETE 0x00
/**
* Defination of the key-value store information
*
* KV_STATE_OFFSET: the offset of block/item state in header structure
* KV_ALIGN_MASK: the mask of the key-value store alignment
* KV_DELETE_FLAG: the flag of item is deleted by self
* KV_UPDATE_FLAG: the flag of item is deleted by update
*
*/
#define KV_STATE_OFFSET 1
#define KV_ALIGN_MASK ~(sizeof(void *) - 1)
#define KV_DELETE_FLAG 0
#define KV_UPDATE_FLAG 1
/**
* Garbage collection related defination
*
* KV_RESERVED_BLOCKS: the reserved block for garbage collection
*
*/
#define KV_RESERVED_BLOCKS 1
/**
* Key-value item descriptor defination
*
* hdr: the header of the item
* store: the store buffer for key-value pair
* len: the length of the buffer
* pos: the store position of the key-value item
*
*/
typedef struct _kv_item_t {
item_hdr_t hdr;
char *store;
uint16_t len;
kv_size_t pos;
} kv_item_t;
/**
* Block information struct for management
*
* space: free space in current block
* state: the state of current block
*
*/
typedef struct _block_info_t {
kv_size_t space;
uint8_t state;
} block_info_t;
/**
* Key-value module management struct
*
* inited: the flag to indicate the module is inited
* gc_trigger: the flag to indicate GC is triggered
* gc_waiter: numbers of the task wait for GC finished
* clean_blk_nums: numbers of the clean block
* write_pos: current write position
* block_info[]: the array to record the block management info
*
*/
typedef struct _kv_mgr_t {
uint8_t inited;
uint8_t gc_trigger;
uint8_t gc_waiter;
uint8_t clean_blk_nums;
kv_size_t write_pos;
void *gc_sem;
void *lock;
block_info_t block_info[KV_BLOCK_NUMS];
} kv_mgr_t;
typedef struct _kv_store_t {
char *p;
int res;
uint16_t len;
} kv_store_t;
/**
* Magic Number for block & item
*/
static const uint8_t KV_BLOCK_MAGIC_NUM = 'K';
static const uint8_t KV_ITEM_MAGIC_NUM = 'I';
/**
* The function to be invoked while polling the used block
*/
typedef int32_t (*item_func)(kv_item_t *item, const char *key);
#define KV_ALIGN(x) ((x + ~KV_ALIGN_MASK) & KV_ALIGN_MASK)
#endif /* KV_INTERNAL_H */
| YifuLiu/AliOS-Things | components/kv/internal/kv_types.h | C | apache-2.0 | 5,112 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#include <stdint.h>
#include "kv.h"
#include "kv_conf.h"
#include "kv_adapt.h"
#include "kv_types.h"
static kv_mgr_t g_kv_mgr;
static void kv_gc_task(void *arg);
kv_item_t *kv_item_traverse(item_func func, uint8_t blk_idx, const char *key);
/******************************************************/
/****************** Internal Interface ****************/
/******************************************************/
/**
* @brief CRC-8: the poly is 0x31 (x^8 + x^5 + x^4 + 1)
*
* @param[in] buf the buffer which is need calculate crc
* @param[in] length the length of the buffer
*
* @return the crc value
*/
static uint8_t calc_crc8(uint8_t *buf, uint16_t length)
{
uint8_t crc = 0x00;
uint8_t i = 0;
while (length--) {
crc ^= *buf++;
for (i = 8; i > 0; i--) {
if (crc & 0x80) {
crc = (crc << 1) ^ 0x31;
} else {
crc <<= 1;
}
}
}
return crc;
}
/**
* @brief Trigger garbage collection process
*
* @return none
*/
static void kv_trigger_gc(void)
{
if (g_kv_mgr.gc_trigger != 0) {
return;
}
g_kv_mgr.gc_waiter = 0;
g_kv_mgr.gc_trigger = 1;
kv_start_task("kv_gc", kv_gc_task, NULL, KV_TASK_STACK_SIZE);
}
/**
* @brief Free item resource
*
* @param[in] item pointer to item
*
* @return none
*/
static void kv_item_free(kv_item_t *item)
{
if (item) {
if (item->store) {
kv_free(item->store);
}
kv_free(item);
}
}
/**
* @brief Set block state bit
*
* @param[in] blk_idx the position of the block index
* @param[in] state the state which want to set
*
* @return 0 on success, otherwise will be failed
*/
static int32_t kv_set_block_state(uint8_t blk_idx, uint8_t state)
{
int32_t ret;
uint32_t pos = (blk_idx << KV_BLOCK_SIZE_BITS) + KV_STATE_OFFSET;
ret = kv_flash_write(pos, &state, 1);
if (ret != KV_OK) {
return ret;
}
g_kv_mgr.block_info[blk_idx].state = state;
return KV_OK;
}
/**
* @brief Set item state bit
*
* @param[in] pos the position of the item
* @param[in] state the state which want to set
*
* @return 0 on success, otherwise will be failed
*/
static int32_t kv_set_item_state(kv_size_t pos, uint8_t state)
{
return kv_flash_write(pos + KV_STATE_OFFSET, &state, 1);
}
/**
* @brief Format block header
*
* @param[in] blk_idx the index of the block
*
* @return 0 on success, otherwise will be failed
*/
static int32_t kv_block_format(uint8_t blk_idx)
{
block_hdr_t hdr;
kv_size_t pos = (blk_idx << KV_BLOCK_SIZE_BITS);
memset(&hdr, 0, sizeof(block_hdr_t));
hdr.magic = KV_BLOCK_MAGIC_NUM;
if (!kv_flash_erase(pos, KV_BLOCK_SIZE)) {
hdr.state = KV_BLOCK_STATE_CLEAN;
} else {
return KV_ERR_FLASH_ERASE;
}
if (kv_flash_write(pos, &hdr, KV_BLOCK_HDR_SIZE) != KV_OK) {
return KV_ERR_FLASH_WRITE;
}
g_kv_mgr.block_info[blk_idx].state = KV_BLOCK_STATE_CLEAN;
g_kv_mgr.block_info[blk_idx].space = KV_BLOCK_SIZE - KV_BLOCK_HDR_SIZE;
g_kv_mgr.clean_blk_nums++;
return KV_OK;
}
/**
* @brief Calculcate the item wtite position
*
* @param[in] len the item length
*
* @return write position, 0 means there is no space to store
*/
static kv_size_t kv_calc_position(uint16_t len)
{
uint8_t blk_idx;
block_info_t *blk_info;
#if KV_BLOCK_NUMS > KV_RESERVED_BLOCKS + 1
uint8_t i;
uint32_t blk_start;
#endif
blk_idx = (g_kv_mgr.write_pos) >> KV_BLOCK_SIZE_BITS;
blk_info = &(g_kv_mgr.block_info[blk_idx]);
if (blk_info->space > len) {
if (((blk_info->space - len) < KV_ITEM_MAX_LEN) && \
(g_kv_mgr.clean_blk_nums <= KV_RESERVED_BLOCKS)) {
kv_trigger_gc();
}
return g_kv_mgr.write_pos;
}
if(g_kv_mgr.clean_blk_nums <= KV_RESERVED_BLOCKS){
uint8_t blk_idx_tmp;
block_info_t *blk_info_tmp;
kv_trigger_gc();
blk_idx_tmp = (g_kv_mgr.write_pos) >> KV_BLOCK_SIZE_BITS;
blk_info_tmp = &(g_kv_mgr.block_info[blk_idx_tmp]);
if(blk_info_tmp->space >= len + KV_ITEM_MAX_LEN){
return g_kv_mgr.write_pos;
}
}
#if KV_BLOCK_NUMS > KV_RESERVED_BLOCKS + 1
for (i = blk_idx + 1; i != blk_idx; i++) {
if (i == KV_BLOCK_NUMS) {
i = 0;
}
blk_info = &(g_kv_mgr.block_info[i]);
if ((blk_info->space) > len) {
blk_start = (i << KV_BLOCK_SIZE_BITS);
g_kv_mgr.write_pos = blk_start + KV_BLOCK_SIZE - blk_info->space;
if (blk_info->state == KV_BLOCK_STATE_CLEAN) {
if (kv_set_block_state(i, KV_BLOCK_STATE_USED) != KV_OK) {
return 0;
}
g_kv_mgr.clean_blk_nums--;
}
return g_kv_mgr.write_pos;
}
}
#endif
kv_trigger_gc();
return 0;
}
/**
* @brief Key-value pair item delete
*
* @param[in] item pointer to the key-value pair need to deleted
* @param[in] flag the flag indicate item delete request is from del or update
*
* @return 0 on success, otherwise is failed
*/
static int32_t kv_item_del(kv_item_t *item, int flag)
{
uint8_t i;
kv_size_t off;
item_hdr_t hdr;
int res = KV_OK;
char *ori = NULL;
char *new = NULL;
if (flag == KV_DELETE_FLAG) {
off = item->pos;
} else if (flag == KV_UPDATE_FLAG) {
off = item->hdr.origin_off;
memset(&hdr, 0, KV_ITEM_HDR_SIZE);
if (kv_flash_read(off, &hdr, KV_ITEM_HDR_SIZE) != KV_OK) {
return KV_ERR_FLASH_READ;
}
if ((hdr.magic != KV_ITEM_MAGIC_NUM) || \
(hdr.state != KV_ITEM_STATE_NORMAL) || \
(hdr.key_len != item->hdr.key_len)) {
return KV_OK;
}
ori = (char *)kv_malloc(hdr.key_len);
if (!ori) {
return KV_ERR_MALLOC_FAILED;
}
new = (char *)kv_malloc(hdr.key_len);
if (!new) {
kv_free(ori);
return KV_ERR_MALLOC_FAILED;
}
kv_flash_read(off + KV_ITEM_HDR_SIZE, ori, hdr.key_len);
kv_flash_read(item->pos + KV_ITEM_HDR_SIZE, new, hdr.key_len);
if (memcmp(ori, new, hdr.key_len) != 0) {
kv_free(ori);
kv_free(new);
return KV_OK;
}
kv_free(ori);
kv_free(new);
} else {
return KV_ERR_INVALID_PARAM;
}
if ((res = kv_set_item_state(off, KV_ITEM_STATE_DELETE)) != KV_OK) {
return res;
}
i = off >> KV_BLOCK_SIZE_BITS;
if (g_kv_mgr.block_info[i].state == KV_BLOCK_STATE_USED) {
res = kv_set_block_state(i, KV_BLOCK_STATE_DIRTY);
}
return res;
}
/**
* @brief recovery callback function when polling the block
*
* @param[in] item pointer to the key-value pair item
* @param[in] key pointer to the key
*
* @return KV_LOOP_CONTINUE: continue to polling, otherwise is failed
*/
static int32_t __item_recovery_cb(kv_item_t *item, const char *key)
{
int32_t res;
char *p = (char *)kv_malloc(item->len);
if (!p) {
return KV_ERR_MALLOC_FAILED;
}
res = kv_flash_read(item->pos + KV_ITEM_HDR_SIZE, p, item->len);
if (res != KV_OK) {
kv_free(p);
return KV_ERR_FLASH_READ;
}
if (item->hdr.crc == calc_crc8((uint8_t *)p, item->len)) {
if ((item->hdr.origin_off != 0) && \
(item->pos != item->hdr.origin_off)) {
kv_item_del(item, KV_UPDATE_FLAG);
}
} else {
kv_item_del(item, KV_DELETE_FLAG);
}
kv_free(p);
return KV_LOOP_CONTINUE;
}
/**
* @brief find callback function when polling the block
*
* @param[in] item pointer to the key-value pair item
* @param[in] key pointer to the key
*
* @return KV_OK: find the item;
* KV_LOOP_CONTINUE: continue to polling,
* otherwise is failed
*/
static int32_t __item_find_cb(kv_item_t *item, const char *key)
{
int32_t res;
if (item->hdr.key_len != strlen(key)) {
return KV_LOOP_CONTINUE;
}
item->store = (char *)kv_malloc(item->hdr.key_len + item->hdr.val_len);
if (!item->store) {
return KV_ERR_MALLOC_FAILED;
}
res = kv_flash_read(item->pos + KV_ITEM_HDR_SIZE, item->store,
item->len);
if (res != KV_OK) {
return KV_ERR_FLASH_READ;
}
if (memcmp(item->store, key, strlen(key)) == 0) {
return KV_OK;
}
return KV_LOOP_CONTINUE;
}
/**
* @brief GC callback function when polling the block
*
* @param[in] item pointer to the key-value pair item
* @param[in] key pointer to the key
*
* @return KV_LOOP_CONTINUE: continue to polling, otherwise is failed
*/
static int32_t __item_gc_cb(kv_item_t *item, const char *key)
{
char *p;
int32_t res;
uint8_t idx;
uint16_t len;
len = KV_ALIGN(KV_ITEM_HDR_SIZE + item->len);
p = (char *)kv_malloc(len);
if (!p) {
return KV_ERR_MALLOC_FAILED;
}
if (kv_flash_read(item->pos, p, len) != KV_OK) {
res = KV_ERR_FLASH_READ;
goto err;
}
if (kv_flash_write(g_kv_mgr.write_pos, p, len) != KV_OK) {
res = KV_ERR_FLASH_WRITE;
goto err;
}
g_kv_mgr.write_pos += len;
idx = (g_kv_mgr.write_pos) >> KV_BLOCK_SIZE_BITS;
g_kv_mgr.block_info[idx].space -= len;
res = KV_LOOP_CONTINUE;
err:
kv_free(p);
return res;
}
/**
* @brief Group delete callback function when polling the block
*
* @param[in] item pointer to the key-value pair item
* @param[in] key pointer to the key
*
* @return KV_LOOP_CONTINUE: continue to polling, otherwise is failed
*/
static int32_t __item_del_by_prefix_cb(kv_item_t *item, const char *prefix)
{
char *key = NULL;
if (prefix != NULL && item->hdr.key_len < strlen(prefix)) {
return KV_LOOP_CONTINUE;
}
key = (char *)kv_malloc(item->hdr.key_len + 1);
if (!key) {
return KV_ERR_MALLOC_FAILED;
}
memset(key, 0, item->hdr.key_len + 1);
kv_flash_read(item->pos + KV_ITEM_HDR_SIZE, key, item->hdr.key_len);
if (prefix == NULL || strncmp(key, prefix, strlen(prefix)) == 0) {
kv_item_del(item, KV_DELETE_FLAG);
}
kv_free(key);
return KV_LOOP_CONTINUE;
}
/**
* @brief Search key-value pair item
*
* @param[in] key pointer to the item key
*
* @return key-value item or NULL
*/
static kv_item_t *kv_item_search(const char *key)
{
uint8_t i;
kv_item_t *item = NULL;
for (i = 0; i < KV_BLOCK_NUMS; i++) {
if (g_kv_mgr.block_info[i].state != KV_BLOCK_STATE_CLEAN) {
item = kv_item_traverse(__item_find_cb, i, key);
if (item != NULL) {
return item;
}
}
}
return NULL;
}
/**
* @brief Store key-value item
*
* @param[in] key pointer to the item key
* @param[in] val pointer to the item value
* @param[in] len the length of the value
* @param[in] origin_off the old item position offset
*
* @return 0 on success, otherwise is failed
*/
static int32_t kv_item_store(const char *key, const void *val, int len,
kv_size_t origin_off)
{
char *p;
uint8_t idx;
kv_size_t pos;
item_hdr_t hdr;
kv_store_t store;
hdr.magic = KV_ITEM_MAGIC_NUM;
hdr.state = KV_ITEM_STATE_NORMAL;
hdr.key_len = strlen(key);
hdr.val_len = len;
hdr.origin_off = origin_off;
store.len = KV_ALIGN(KV_ITEM_HDR_SIZE + hdr.key_len + hdr.val_len);
store.p = (char *)kv_malloc(store.len);
if (!store.p) {
return KV_ERR_MALLOC_FAILED;
}
memset(store.p, 0, store.len);
p = store.p + KV_ITEM_HDR_SIZE;
memcpy(p, key, hdr.key_len);
p += hdr.key_len;
memcpy(p, val, hdr.val_len);
p -= hdr.key_len;
hdr.crc = calc_crc8((uint8_t *)p, hdr.key_len + hdr.val_len);
memcpy(store.p, &hdr, KV_ITEM_HDR_SIZE);
pos = kv_calc_position(store.len);
if (pos > 0) {
store.res = kv_flash_write(pos, store.p, store.len);
if (store.res == KV_OK) {
g_kv_mgr.write_pos = pos + store.len;
idx = (uint8_t)(g_kv_mgr.write_pos >> KV_BLOCK_SIZE_BITS);
g_kv_mgr.block_info[idx].space -= store.len;
}
} else {
store.res = KV_ERR_NO_SPACE;
}
if (store.p) {
kv_free(store.p);
}
return store.res;
}
/**
* @brief Update the item value
*
* @param[in] item pointer to the key-value item
* @param[in] key pointer to the item key
* @param[in] val pointer to the item value
* @param[in] len the length of the item value
*
* @return 0 on success, otherwise is failed
*/
static int32_t kv_item_update(kv_item_t *item, const char *key, const void *val,
int32_t len)
{
int res;
if (item->hdr.val_len == len) {
if (!memcmp(item->store + item->hdr.key_len, val, len)) {
return KV_OK;
}
}
res = kv_item_store(key, val, len, item->pos);
if (res != KV_OK) {
return res;
}
res = kv_item_del(item, KV_DELETE_FLAG);
return res;
}
/**
* @brief Initialize the KV module
*
* @return 0 on success, otherwise is failed
*/
static int32_t kv_init_internal(void)
{
uint8_t i;
uint8_t next;
block_hdr_t hdr;
int32_t res = KV_OK;
int32_t nums = 0;
uint8_t unclean[KV_BLOCK_NUMS] = {0};
for (i = 0; i < KV_BLOCK_NUMS; i++) {
memset(&hdr, 0, KV_BLOCK_HDR_SIZE);
kv_flash_read((i << KV_BLOCK_SIZE_BITS), &hdr, KV_BLOCK_HDR_SIZE);
if (hdr.magic == KV_BLOCK_MAGIC_NUM) {
if (INVALID_BLK_STATE(hdr.state)) {
if ((res = kv_block_format(i)) != KV_OK) {
return res;
} else {
continue;
}
}
g_kv_mgr.block_info[i].state = hdr.state;
kv_item_traverse(__item_recovery_cb, i, NULL);
if (hdr.state == KV_BLOCK_STATE_CLEAN) {
if (g_kv_mgr.block_info[i].space != (KV_BLOCK_SIZE - KV_BLOCK_HDR_SIZE)) {
unclean[nums] = i;
nums++;
} else {
g_kv_mgr.clean_blk_nums++;
}
}
} else {
if ((res = kv_block_format(i)) != KV_OK) {
return res;
}
}
}
while (nums > 0) {
i = unclean[nums - 1];
if (g_kv_mgr.clean_blk_nums >= KV_RESERVED_BLOCKS) {
res = kv_set_block_state(i, KV_BLOCK_STATE_DIRTY);
if (res != KV_OK) {
return res;
}
} else {
if ((res = kv_block_format(i)) != KV_OK) {
return res;
}
}
nums--;
}
if (g_kv_mgr.clean_blk_nums == 0) {
if ((res = kv_block_format(0)) != KV_OK) {
return res;
}
}
if (g_kv_mgr.clean_blk_nums == KV_BLOCK_NUMS) {
g_kv_mgr.write_pos = KV_BLOCK_HDR_SIZE;
i = (uint8_t)(g_kv_mgr.write_pos & KV_BLOCK_OFF_MASK);
res = kv_set_block_state(i, KV_BLOCK_STATE_USED);
if (res != KV_OK) {
return res;
}
g_kv_mgr.clean_blk_nums--;
} else {
for (i = 0; i < KV_BLOCK_NUMS; i++) {
if ((g_kv_mgr.block_info[i].state == KV_BLOCK_STATE_USED) || \
(g_kv_mgr.block_info[i].state == KV_BLOCK_STATE_DIRTY)) {
next = ((i + 1) == KV_BLOCK_NUMS) ? 0 : (i + 1);
if (g_kv_mgr.block_info[next].state == KV_BLOCK_STATE_CLEAN) {
g_kv_mgr.write_pos = (i << KV_BLOCK_SIZE_BITS) + \
KV_BLOCK_SIZE - \
g_kv_mgr.block_info[i].space;
break;
}
}
}
}
return KV_OK;
}
/**
* Garbage collection task
*
* @param[in] arg pointer to the argument
*
* @return none
*/
static void kv_gc_task(void *arg)
{
kv_size_t origin_pos;
uint8_t i;
uint8_t gc_idx;
uint8_t gc_copy = 0;
if ((kv_lock(g_kv_mgr.lock)) != KV_OK) {
goto exit;
}
origin_pos = g_kv_mgr.write_pos;
if (g_kv_mgr.clean_blk_nums == 0) {
goto exit;
}
for (gc_idx = 0; gc_idx < KV_BLOCK_NUMS; gc_idx++) {
if (g_kv_mgr.block_info[gc_idx].state == KV_BLOCK_STATE_CLEAN) {
g_kv_mgr.write_pos = (gc_idx << KV_BLOCK_SIZE_BITS) + KV_BLOCK_HDR_SIZE;
break;
}
}
if (gc_idx == KV_BLOCK_NUMS) {
goto exit;
}
i = (origin_pos >> KV_BLOCK_SIZE_BITS) + 1;
while (1) {
if (i == KV_BLOCK_NUMS) {
i = 0;
}
if (g_kv_mgr.block_info[i].state == KV_BLOCK_STATE_DIRTY) {
kv_item_traverse(__item_gc_cb, i, NULL);
gc_copy = 1;
if (kv_block_format(i) != KV_OK) {
goto exit;
}
kv_set_block_state(gc_idx, KV_BLOCK_STATE_USED);
g_kv_mgr.clean_blk_nums--;
break;
}
if (i == (origin_pos >> KV_BLOCK_SIZE_BITS)) {
break;
}
i++;
}
if (gc_copy == 0) {
g_kv_mgr.write_pos = origin_pos;
}
exit:
g_kv_mgr.gc_trigger = 0;
kv_unlock(g_kv_mgr.lock);
if (g_kv_mgr.gc_waiter > 0) {
kv_sem_post_all(g_kv_mgr.gc_sem);
}
kv_delete_task();
}
/**
* @brief polling flash block
*
* @param[in] func pointer to callback function
* @param[in] blk_idx the block index
* @param[in] key pointer to the key
*
* @return the key-value item or NULL.
*/
kv_item_t *kv_item_traverse(item_func func, uint8_t blk_idx, const char *key)
{
int32_t res;
uint16_t len;
kv_size_t pos;
kv_size_t end;
kv_item_t *item;
item_hdr_t *hdr;
pos = (blk_idx << KV_BLOCK_SIZE_BITS) + KV_BLOCK_HDR_SIZE;
end = (blk_idx << KV_BLOCK_SIZE_BITS) + KV_BLOCK_SIZE;
len = 0;
do {
item = (kv_item_t *)kv_malloc(sizeof(kv_item_t));
if (!item) {
return NULL;
}
memset(item, 0, sizeof(kv_item_t));
hdr = &(item->hdr);
if (kv_flash_read(pos, hdr, KV_ITEM_HDR_SIZE) != KV_OK) {
kv_item_free(item);
return NULL;
}
if (hdr->magic != KV_ITEM_MAGIC_NUM) {
if ((hdr->magic == 0xFF) && (hdr->state == 0xFF)) {
kv_item_free(item);
break;
}
hdr->val_len = 0xFFFF;
}
if ((hdr->val_len > KV_MAX_VAL_LEN) || \
(hdr->key_len > KV_MAX_KEY_LEN) || \
(hdr->val_len == 0) || (hdr->key_len == 0)) {
pos += KV_ITEM_HDR_SIZE;
kv_item_free(item);
if (g_kv_mgr.block_info[blk_idx].state == KV_BLOCK_STATE_USED) {
kv_set_block_state(blk_idx, KV_BLOCK_STATE_DIRTY);
}
continue;
}
len = KV_ALIGN(KV_ITEM_HDR_SIZE + hdr->key_len + hdr->val_len);
if (hdr->state == KV_ITEM_STATE_NORMAL) {
item->pos = pos;
item->len = hdr->key_len + hdr->val_len;
res = func(item, key);
if (res == KV_OK) {
return item;
} else if (res != KV_LOOP_CONTINUE) {
kv_item_free(item);
return NULL;
}
} else {
if (g_kv_mgr.block_info[blk_idx].state == KV_BLOCK_STATE_USED) {
kv_set_block_state(blk_idx, KV_BLOCK_STATE_DIRTY);
}
}
kv_item_free(item);
pos += len;
} while (end > (pos + KV_ITEM_HDR_SIZE));
if (end > pos) {
g_kv_mgr.block_info[blk_idx].space = end - pos;
} else {
g_kv_mgr.block_info[blk_idx].space = KV_ITEM_HDR_SIZE;
}
return NULL;
}
/******************************************************/
/****************** Public Interface ******************/
/******************************************************/
int32_t kv_init(void)
{
int32_t res;
uint8_t blk_idx;
if (g_kv_mgr.inited) {
return KV_OK;
}
if (KV_BLOCK_NUMS <= KV_RESERVED_BLOCKS) {
return KV_ERR_INVALID_PARAM;
}
memset(&g_kv_mgr, 0, sizeof(kv_mgr_t));
g_kv_mgr.lock = kv_lock_create();
if (g_kv_mgr.lock == NULL) {
return KV_ERR_OS_LOCK;
}
g_kv_mgr.gc_sem = kv_sem_create();
if (g_kv_mgr.gc_sem == NULL) {
return KV_ERR_OS_SEM;
}
if ((res = kv_init_internal()) != KV_OK) {
return res;
}
g_kv_mgr.inited = 1;
blk_idx = (g_kv_mgr.write_pos >> KV_BLOCK_SIZE_BITS);
if (((g_kv_mgr.block_info[blk_idx].space) < KV_ITEM_MAX_LEN) && \
(g_kv_mgr.clean_blk_nums < KV_RESERVED_BLOCKS + 1)) {
kv_trigger_gc();
}
#if AOS_COMP_CLI
extern void kv_register_cli_command(void);
kv_register_cli_command();
#endif
return KV_OK;
}
void kv_deinit(void)
{
g_kv_mgr.inited = 0;
kv_sem_free(g_kv_mgr.gc_sem);
kv_lock_free(g_kv_mgr.lock);
}
int32_t kv_item_set(const char *key, const void *val, int32_t len)
{
int32_t res;
kv_item_t *item = NULL;
#if (KV_SECURE_SUPPORT) && (KV_SECURE_LEVEL > 1)
return kv_item_secure_set(key, val, len);
#endif
if (!key || !val || (len <= 0) || (strlen(key) > KV_MAX_KEY_LEN) || \
(len > KV_MAX_VAL_LEN)) {
return KV_ERR_INVALID_PARAM;
}
if (g_kv_mgr.gc_trigger != 0) {
g_kv_mgr.gc_waiter++;
kv_sem_wait(g_kv_mgr.gc_sem);
}
if ((res = kv_lock(g_kv_mgr.lock)) != KV_OK) {
return KV_ERR_OS_LOCK;
}
item = kv_item_search(key);
if (item != NULL) {
res = kv_item_update(item, key, val, len);
kv_item_free(item);
} else {
res = kv_item_store(key, val, len, 0);
}
kv_unlock(g_kv_mgr.lock);
return res;
}
int32_t kv_item_get(const char *key, void *buffer, int32_t *buffer_len)
{
kv_item_t *item = NULL;
#if (KV_SECURE_SUPPORT) && (KV_SECURE_LEVEL > 1)
return kv_item_secure_get(key, buffer, buffer_len);
#endif
if (!key || !buffer || !buffer_len || (*buffer_len <= 0)) {
return KV_ERR_INVALID_PARAM;
}
if ((kv_lock(g_kv_mgr.lock)) != KV_OK) {
return KV_ERR_OS_LOCK;
}
item = kv_item_search(key);
kv_unlock(g_kv_mgr.lock);
if (!item) {
return KV_ERR_NOT_FOUND;
}
if (*buffer_len < item->hdr.val_len) {
*buffer_len = item->hdr.val_len;
kv_item_free(item);
return KV_ERR_NO_SPACE;
} else {
memcpy(buffer, (item->store + item->hdr.key_len), item->hdr.val_len);
*buffer_len = item->hdr.val_len;
}
kv_item_free(item);
return KV_OK;
}
int32_t kv_item_delete(const char *key)
{
int32_t res;
kv_item_t *item = NULL;
if ((res = kv_lock(g_kv_mgr.lock)) != KV_OK) {
return KV_ERR_OS_LOCK;
}
item = kv_item_search(key);
if (!item) {
kv_unlock(g_kv_mgr.lock);
return KV_ERR_NOT_FOUND;
}
res = kv_item_del(item, KV_DELETE_FLAG);
kv_item_free(item);
kv_unlock(g_kv_mgr.lock);
return res;
}
int32_t kv_item_delete_by_prefix(const char *prefix)
{
int32_t i;
if ((kv_lock(g_kv_mgr.lock)) != KV_OK) {
return KV_ERR_OS_LOCK;
}
for (i = 0; i < KV_BLOCK_NUMS; i++) {
kv_item_traverse(__item_del_by_prefix_cb, i, prefix);
}
kv_unlock(g_kv_mgr.lock);
return KV_OK;
}
#if (KV_SECURE_SUPPORT)
int32_t kv_item_secure_set(const char *key, const void *val, int32_t len)
{
int32_t res;
uint8_t *data = NULL;
kv_item_t *item = NULL;
if (!key || !val || (len <= 0) || (strlen(key) > KV_MAX_KEY_LEN) || \
(len > KV_MAX_VAL_LEN)) {
return KV_ERR_INVALID_PARAM;
}
if (g_kv_mgr.gc_trigger != 0) {
g_kv_mgr.gc_waiter++;
kv_sem_wait(g_kv_mgr.gc_sem);
}
if ((res = kv_lock(g_kv_mgr.lock)) != KV_OK) {
return KV_ERR_OS_LOCK;
}
data = (uint8_t *)kv_malloc(len);
if (data == NULL) {
return KV_ERR_NO_SPACE;
}
memset(data, 0, len);
res = kv_secure_encrypt((uint8_t *)val, data, len);
if (res != KV_OK) {
kv_free(data);
data = NULL;
return KV_ERR_ENCRYPT;
}
item = kv_item_search(key);
if (item != NULL) {
res = kv_item_update(item, key, data, len);
kv_item_free(item);
} else {
res = kv_item_store(key, data, len, 0);
}
kv_unlock(g_kv_mgr.lock);
kv_free(data);
data = NULL;
return res;
}
int32_t kv_item_secure_get(const char *key, void *buffer, int32_t *buffer_len)
{
int32_t res;
uint8_t *data = NULL;
kv_item_t *item = NULL;
if (!key || !buffer || !buffer_len || (*buffer_len <= 0)) {
return KV_ERR_INVALID_PARAM;
}
if ((res = kv_lock(g_kv_mgr.lock)) != KV_OK) {
return KV_ERR_OS_LOCK;
}
item = kv_item_search(key);
kv_unlock(g_kv_mgr.lock);
if (!item) {
return KV_ERR_NOT_FOUND;
}
if (*buffer_len < item->hdr.val_len) {
*buffer_len = item->hdr.val_len;
kv_item_free(item);
return KV_ERR_NO_SPACE;
} else {
data = (uint8_t *)kv_malloc(item->hdr.val_len);
if (data == NULL) {
return KV_ERR_NO_SPACE;
}
memset(data, 0, item->hdr.val_len);
res = kv_secure_decrypt((uint8_t *)(item->store + item->hdr.key_len), data, item->hdr.val_len);
if (res != KV_OK) {
kv_free(data);
data = NULL;
return KV_ERR_DECRYPT;
}
memcpy(buffer, data, item->hdr.val_len);
*buffer_len = item->hdr.val_len;
}
kv_item_free(item);
kv_free(data);
data = NULL;
return KV_OK;
}
#else
int32_t kv_item_secure_set(const char *key, const void *val, int32_t len)
{
return KV_ERR_NOT_SUPPORT;
}
int32_t kv_item_secure_get(const char *key, void *buffer, int32_t *buffer_len)
{
return KV_ERR_NOT_SUPPORT;
}
#endif
| YifuLiu/AliOS-Things | components/kv/src/kv.c | C | apache-2.0 | 26,301 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#include <unistd.h>
#include <stdio.h>
#include "k_api.h"
#include "kv_conf.h"
#include "kv_adapt.h"
#include <aos/flashpart.h>
#include <aos/hal/flash.h>
static aos_flashpart_ref_t kv_flashpart_ref = AOS_DEV_REF_INIT_VAL;
static aos_status_t kv_flash_open(void)
{
return aos_flashpart_get(&kv_flashpart_ref, KV_PARTITION);
}
int32_t kv_flash_read(uint32_t offset, void *buf, uint32_t nbytes)
{
aos_status_t r;
if (!aos_dev_ref_is_valid(&kv_flashpart_ref) && kv_flash_open())
return -1;
r = aos_flashpart_read(&kv_flashpart_ref, offset, buf, nbytes);
return (r >= 0 && r < AOS_FLASH_ECC_ERROR) ? 0 : -1;
}
int32_t kv_flash_write(uint32_t offset, void *buf, uint32_t nbytes)
{
if (!aos_dev_ref_is_valid(&kv_flashpart_ref) && kv_flash_open())
return -1;
return aos_flashpart_write(&kv_flashpart_ref, offset, buf, nbytes) ? -1 : 0;
}
int32_t kv_flash_erase(uint32_t offset, uint32_t size)
{
if (!aos_dev_ref_is_valid(&kv_flashpart_ref) && kv_flash_open())
return -1;
return aos_flashpart_erase(&kv_flashpart_ref, offset, size) ? -1 : 0;
}
void *kv_lock_create(void)
{
int32_t ret;
kmutex_t *m;
m = krhino_mm_alloc(sizeof(kmutex_t));
if (m == NULL) {
return NULL;
}
ret = krhino_mutex_create(m, "KV");
if (ret != RHINO_SUCCESS) {
krhino_mm_free(m);
return NULL;
}
return (void *)m;
}
int32_t kv_lock_free(void *lock)
{
int32_t ret;
kmutex_t *m = (kmutex_t *)lock;
if (m == NULL) {
return -1;
}
ret = krhino_mutex_del(m);
if (ret != RHINO_SUCCESS) {
return ret;
}
krhino_mm_free(m);
return ret;
}
int32_t kv_lock(void *lock)
{
return krhino_mutex_lock((kmutex_t *)lock, RHINO_WAIT_FOREVER);
}
int32_t kv_unlock(void *lock)
{
return krhino_mutex_unlock((kmutex_t *)lock);
}
void *kv_sem_create(void)
{
int32_t ret;
ksem_t *s;
s = krhino_mm_alloc(sizeof(ksem_t));
if (s == NULL) {
return NULL;
}
ret = krhino_sem_create(s, "KV", 0);
if (ret != RHINO_SUCCESS) {
krhino_mm_free(s);
return NULL;
}
return (void *)s;
}
int32_t kv_sem_free(void *sem)
{
int32_t ret;
ksem_t *m = (ksem_t *)sem;
if (m == NULL) {
return -1;
}
ret = krhino_sem_del(m);
if (ret != RHINO_SUCCESS) {
return ret;
}
krhino_mm_free(m);
return ret;
}
int32_t kv_sem_wait(void *sem)
{
return krhino_sem_take((ksem_t *)sem, RHINO_WAIT_FOREVER);
}
int32_t kv_sem_post_all(void *sem)
{
return krhino_sem_give_all((ksem_t *)sem);
}
int32_t kv_start_task(const char *name, void (*fn)(void *), void *arg,
uint32_t stack)
{
ktask_t *task_handle = NULL;
return krhino_task_dyn_create(&task_handle, name, arg, KV_TASK_PRIORITY, 0,
stack / sizeof(cpu_stack_t), fn, 1u);
}
void kv_delete_task(void)
{
krhino_task_dyn_del(NULL);
}
void *kv_malloc(uint32_t size)
{
return krhino_mm_alloc(size);
}
void kv_free(void *ptr)
{
krhino_mm_free(ptr);
}
| YifuLiu/AliOS-Things | components/kv/src/kv_adapt.c | C | apache-2.0 | 3,172 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#include <fcntl.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/ioctl.h>
#include "kv_conf.h"
#include "kv_adapt.h"
#include "aos/kernel.h"
#include "aos_hal_flash.h"
static aos_task_t kv_task;
int32_t kv_start_task(const char *name, void (*fn)(void *), void *arg,
uint32_t stack)
{
return aos_task_new_ext(&kv_task, name, fn, arg, stack, KV_TASK_PRIORITY);
}
void kv_delete_task(void)
{
aos_task_exit(0);
}
int32_t kv_flash_read(uint32_t offset, void *buf, uint32_t nbytes)
{
return aos_hal_flash_read(HAL_PARTITION_PARAMETER_2, &offset, buf, nbytes);
}
int32_t kv_flash_write(uint32_t offset, void *buf, uint32_t nbytes)
{
return aos_hal_flash_write(HAL_PARTITION_PARAMETER_2, &offset, buf, nbytes);
}
int32_t kv_flash_erase(uint32_t offset, uint32_t size)
{
return aos_hal_flash_erase(HAL_PARTITION_PARAMETER_2, offset, size);
}
void *kv_lock_create(void)
{
aos_mutex_t mutex;
aos_mutex_new(&mutex);
return (void *)mutex;
}
int32_t kv_lock_free(void *lock)
{
aos_mutex_free((aos_mutex_t *)&lock);
return 0;
}
int32_t kv_lock(void *lock)
{
return aos_mutex_lock((aos_mutex_t *)&lock, AOS_WAIT_FOREVER);
}
int32_t kv_unlock(void *lock)
{
return aos_mutex_unlock((aos_mutex_t *)&lock);
}
void *kv_sem_create(void)
{
aos_sem_t sem;
aos_sem_new(&sem, 0);
return (void *)sem;
}
int32_t kv_sem_free(void *sem)
{
aos_sem_free((aos_sem_t *)&sem);
return 0;
}
int32_t kv_sem_wait(void *sem)
{
return aos_sem_wait((aos_sem_t *)&sem, AOS_WAIT_FOREVER);
}
int32_t kv_sem_post_all(void *sem)
{
aos_sem_signal_all((aos_sem_t *)&sem);
return 0;
}
void *kv_malloc(uint32_t size)
{
return aos_malloc(size);
}
void kv_free(void *ptr)
{
aos_free(ptr);
}
| YifuLiu/AliOS-Things | components/kv/src/kv_adapt_aos.c | C | apache-2.0 | 1,857 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#include <stdint.h>
#include "kv.h"
#include "aos/errno.h"
static int _kv_to_aos_res(int res)
{
switch (res) {
case KV_OK:
return 0;
case KV_ERR_NO_SPACE:
return -ENOSPC;
case KV_ERR_INVALID_PARAM:
return -EINVAL;
case KV_ERR_MALLOC_FAILED:
return -ENOMEM;
case KV_ERR_NOT_FOUND:
return -ENOENT;
case KV_ERR_FLASH_READ:
case KV_ERR_FLASH_WRITE:
case KV_ERR_FLASH_ERASE:
return -EIO;
case KV_ERR_NOT_SUPPORT:
return -ENOSYS;
default:
return -EBUSY;
}
}
int aos_kv_init(void)
{
return _kv_to_aos_res(kv_init());
}
void aos_kv_deinit(void)
{
kv_deinit();
}
int aos_kv_set(const char *key, const void *value, int len, int sync)
{
return _kv_to_aos_res(kv_item_set(key, value, len));
}
int aos_kv_get(const char *key, void *buffer, int *buffer_len)
{
return _kv_to_aos_res(kv_item_get(key, buffer, (int32_t *)buffer_len));
}
int aos_kv_del(const char *key)
{
return _kv_to_aos_res(kv_item_delete(key));
}
int aos_kv_del_by_prefix(const char *prefix)
{
return _kv_to_aos_res(kv_item_delete_by_prefix(prefix));
}
int aos_kv_secure_set(const char *key, const void *value, int len, int sync)
{
return _kv_to_aos_res(kv_item_secure_set(key, value, len));
}
int aos_kv_secure_get(const char *key, void *buffer, int *buffer_len)
{
return _kv_to_aos_res(kv_item_secure_get(key, buffer, (int32_t *)buffer_len));
}
| YifuLiu/AliOS-Things | components/kv/src/kv_aos.c | C | apache-2.0 | 1,591 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#if AOS_COMP_CLI
#include <stdint.h>
#include "kv.h"
#include "kv_adapt.h"
#include "kv_types.h"
#include "aos/cli.h"
extern kv_item_t *kv_item_traverse(item_func func, uint8_t blk_idx, const char *key);
extern int32_t cli_printf(const char *fmt, ...);
static int32_t __item_print_cb(kv_item_t *item, const char *key)
{
kv_size_t off;
char *p_key = NULL;
char *p_val = NULL;
p_key = (char *)kv_malloc(item->hdr.key_len + 1);
if (!p_key) {
return KV_ERR_MALLOC_FAILED;
}
memset(p_key, 0, item->hdr.key_len + 1);
off = item->pos + KV_ITEM_HDR_SIZE;
kv_flash_read(off, p_key, item->hdr.key_len);
p_val = (char *)kv_malloc(item->hdr.val_len + 1);
if (!p_val) {
kv_free(p_key);
return KV_ERR_MALLOC_FAILED;
}
memset(p_val, 0, item->hdr.val_len + 1);
off = item->pos + KV_ITEM_HDR_SIZE + item->hdr.key_len;
kv_flash_read(off, p_val, item->hdr.val_len);
cli_printf("%s = %s\r\n", p_key, p_val);
kv_free(p_key);
kv_free(p_val);
return KV_LOOP_CONTINUE;
}
static void handle_kv_cmd(char *pwbuf, int blen, int argc, char **argv)
{
int i = 0;
int num = 0;
int res = KV_OK;
int len = KV_MAX_VAL_LEN;
char *buffer = NULL;
const char *rtype = argc > 1 ? argv[1] : "";
if (strcmp(rtype, "set") == KV_OK) {
if (argc != 4) {
return;
}
res = kv_item_set(argv[2], argv[3], strlen(argv[3]));
if (res != KV_OK) {
cli_printf("cli set kv failed %d.\r\n", res);
}
} else if (strcmp(rtype, "get") == KV_OK) {
if (argc != 3) {
return;
}
buffer = (char *)kv_malloc(KV_MAX_VAL_LEN);
if (!buffer) {
cli_printf("there is no space\r\n");
return;
}
memset(buffer, 0, KV_MAX_VAL_LEN);
res = kv_item_get(argv[2], buffer, (int32_t *)&len);
if (res != 0) {
cli_printf("cli: no paired kv\r\n");
} else {
cli_printf("value is %s\r\n", buffer);
}
if (buffer) {
kv_free(buffer);
}
} else if (strcmp(rtype, "del") == KV_OK) {
if (argc != 3) {
return;
}
res = kv_item_delete(argv[2]);
if (res != KV_OK) {
cli_printf("cli kv del failed %d\r\n", res);
}
} else if (strcmp(rtype, "list") == KV_OK) {
for (i = 0; i < KV_BLOCK_NUMS; i++) {
kv_item_traverse(__item_print_cb, i, NULL);
}
} else if (strcmp(rtype, "seti") == KV_OK) {
if (argc != 4) {
return;
}
num = atoi(argv[3]);
res = kv_item_set(argv[2], (void *)(&num), sizeof(int));
if (res != KV_OK) {
cli_printf("cli set integer kv failed %d.\r\n", res);
}
} else if (strcmp(rtype, "geti") == KV_OK) {
num = 0;
len = sizeof(int);
if (argc != 3) {
return;
}
res = kv_item_get(argv[2], &num, (int32_t *)&len);
if (res != 0) {
cli_printf("cli: no paired kv\r\n");
} else {
cli_printf("value is %d\r\n", num);
}
} else if (strcmp(rtype, "clr") == KV_OK) {
cli_printf("kv list before clear:\r\n", res);
for (i = 0; i < KV_BLOCK_NUMS; i++) {
kv_item_traverse(__item_print_cb, i, NULL);
}
kv_item_delete_by_prefix(NULL);
cli_printf("kv clear success!\r\n", res);
}
return;
}
static struct cli_command kv_cmd = {
"kv", "kv [set key value | get key | del key | seti key int_val | geti key | list | clr]", handle_kv_cmd
};
void kv_register_cli_command(void)
{
aos_cli_register_command(&kv_cmd);
}
#endif /* AOS_COMP_CLI */
| YifuLiu/AliOS-Things | components/kv/src/kv_cli.c | C | apache-2.0 | 3,829 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#include "kv_conf.h"
#if (KV_SECURE_SUPPORT)
#include <stdint.h>
#include <string.h>
#include "aos/kv.h"
#include "kv_adapt.h"
#if (KV_SECURE_CRYPT_IMPL == 1)
#include "mbedtls/aes.h"
#define OFB_KEY_LEN 32
#define OFB_IV_LEN 16
static mbedtls_aes_context aes_context;
static int32_t _ofb_encrypt_wrap(uint8_t *ofb_key, uint8_t *ofb_iv,
uint8_t *input, uint8_t *output, uint32_t len)
{
int32_t ret;
uint32_t offset = 0;
uint8_t iv[OFB_IV_LEN] = {0};
if ((input == NULL) || (output == NULL)) {
return KV_ERR_INVALID_PARAM;
}
memcpy(iv, ofb_iv, sizeof(iv));
ret = mbedtls_aes_setkey_enc(&aes_context, ofb_key, OFB_KEY_LEN * 8);
if (ret != KV_OK) {
return ret;
}
ret = mbedtls_aes_crypt_ofb(&aes_context, len, &offset, iv, input, output);
if (ret != KV_OK) {
return ret;
}
return KV_OK;
}
int32_t kv_secure_encrypt(uint8_t *input, uint8_t *output, uint32_t input_len)
{
uint8_t *ofb_key = NULL;
uint8_t *ofb_iv = NULL;
ofb_key = kv_secure_getkey(OFB_KEY_LEN);
ofb_iv = kv_secure_getiv(OFB_IV_LEN);
if ((ofb_key == NULL) || (ofb_iv == NULL)) {
return KV_ERR_ENCRYPT;
}
if (_ofb_encrypt_wrap(ofb_key, ofb_iv, input, output, input_len) != KV_OK) {
return KV_ERR_ENCRYPT;
}
return KV_OK;
}
int32_t kv_secure_decrypt(uint8_t *input, uint8_t *output, uint32_t input_len)
{
uint8_t *ofb_key = NULL;
uint8_t *ofb_iv = NULL;
ofb_key = kv_secure_get_key(OFB_KEY_LEN);
ofb_iv = kv_secure_get_iv(OFB_IV_LEN);
if ((ofb_key == NULL) || (ofb_iv == NULL)) {
return KV_ERR_ENCRYPT;
}
if (_ofb_encrypt_wrap(ofb_key, ofb_iv, input, output, input_len) != KV_OK) {
return KV_ERR_ENCRYPT;
}
return KV_OK;
}
#else /* User defined encrypt/decrypt implement here */
int32_t kv_secure_encrypt(uint8_t *input, uint8_t *output, uint32_t input_len)
{
return KV_ERR_NOT_SUPPORT;
}
int32_t kv_secure_decrypt(uint8_t *input, uint8_t *output, uint32_t input_len)
{
return KV_ERR_NOT_SUPPORT;
}
#endif /* KV_SECURE_CRYPT_IMPL */
#endif /* KV_SECURE_SUPPORT */
| YifuLiu/AliOS-Things | components/kv/src/kv_secure.c | C | apache-2.0 | 2,246 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#include <string.h>
#include <stdio.h>
#include <sys/time.h>
#include "k_config.h"
#include "aos/kernel.h"
#include "aos/hal/uart.h"
volatile int errno = 0;
extern uart_dev_t uart_0;
#if defined (__CC_ARM) && defined(__MICROLIB)
void __aeabi_assert(const char *expr, const char *file, int line)
{
while (1);
}
extern uint64_t krhino_sys_time_get(void);
int gettimeofday(struct timeval *tv, void *tzp)
{
uint64_t t = krhino_sys_time_get();
tv->tv_sec = t / 1000;
tv->tv_usec = (t % 1000) * 1000;
return 0;
}
volatile int *__aeabi_errno_addr()
{
return &errno;
}
#if (RHINO_CONFIG_MM_TLF > 0)
#define AOS_UNSIGNED_INT_MSB (1u << (sizeof(unsigned int) * 8 - 1))
extern void *aos_malloc(unsigned int size);
extern void aos_alloc_trace(void *addr, size_t allocator);
extern void aos_free(void *mem);
extern void *aos_realloc(void *mem, unsigned int size);
void *malloc(size_t size)
{
void *mem;
#if (RHINO_CONFIG_MM_DEBUG > 0u)
mem = aos_malloc(size | AOS_UNSIGNED_INT_MSB);
#else
mem = aos_malloc(size);
#endif
return mem;
}
void free(void *mem)
{
aos_free(mem);
}
void *realloc(void *old, size_t newlen)
{
void *mem;
#if (RHINO_CONFIG_MM_DEBUG > 0u)
mem = aos_realloc(old, newlen | AOS_UNSIGNED_INT_MSB);
#else
mem = aos_realloc(old, newlen);
#endif
return mem;
}
void *calloc(size_t len, size_t elsize)
{
void *mem;
#if (RHINO_CONFIG_MM_DEBUG > 0u)
mem = aos_malloc((elsize * len) | AOS_UNSIGNED_INT_MSB);
#else
mem = aos_malloc(elsize * len);
#endif
if (mem) {
memset(mem, 0, elsize * len);
}
return mem;
}
char * strdup(const char *s)
{
size_t len = strlen(s) +1;
void *dup_str = aos_malloc(len);
if (dup_str == NULL)
return NULL;
return (char *)memcpy(dup_str, s, len);
}
#endif
#pragma weak fputc
int fputc(int ch, FILE *f)
{
/* Send data. */
if (ch == '\n') {
hal_uart_send(&uart_0, (void *)"\r", 1, AOS_WAIT_FOREVER);
}
hal_uart_send(&uart_0, &ch, 1, AOS_WAIT_FOREVER);
return ch;
}
//referred from ota_socket.o
void bzero()
{
}
//referred from ssl_cli.o
time_t time(time_t *t)
{
return 0;
}
//referred from aos_network.o
int accept(int sock, long *addr, long *addrlen)
{
return 0;
}
int listen(int sock, int backlog)
{
return 0;
}
//referred from timing.o
unsigned int alarm(unsigned int seconds)
{
return 0;
}
#endif
| YifuLiu/AliOS-Things | components/libc_stub/compilers/armlibc/armcc_libc.c | C | apache-2.0 | 2,474 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#include <string.h>
#include <stdio.h>
#include <sys/time.h>
#include "k_config.h"
#include <aos/hal/uart.h>
#include <umm.h>
#if defined (__CC_ARM)
#pragma weak __aeabi_assert
void __aeabi_assert(const char *expr, const char *file, int line)
{
while (1);
}
#pragma weak __stack_chk_fail
void __stack_chk_fail(void)
{
}
unsigned long __stack_chk_guard __attribute__((weak)) = 0xDEADDEAD;
extern uint64_t krhino_sys_time_get(void);
#pragma weak gettimeofday
int gettimeofday(struct timeval *tv, void *tzp)
{
uint64_t t;
t = krhino_sys_time_get();
tv->tv_sec = t / 1000;
tv->tv_usec = (t % 1000) * 1000;
return 0;
}
#pragma weak malloc
void *malloc(size_t size)
{
void *mem;
mem = umm_alloc(size);
return mem;
}
#pragma weak free
void free(void *mem)
{
umm_free(mem);
}
#pragma weak realloc
void *realloc(void *old, size_t newlen)
{
void *mem;
mem = umm_realloc(old, newlen);
return mem;
}
#pragma weak calloc
void *calloc(size_t len, size_t elsize)
{
void *mem;
mem = umm_alloc(elsize * len);
if (mem) {
memset(mem, 0, elsize * len);
}
return mem;
}
#pragma weak strdup
char * strdup(const char *s)
{
size_t len = strlen(s) +1;
void *dup_str = umm_alloc(len);
if (dup_str == NULL)
return NULL;
return (char *)memcpy(dup_str, s, len);
}
#pragma weak fputc
int fputc(int ch, FILE *f)
{
uart_dev_t uart_stdio;
memset(&uart_stdio, 0, sizeof(uart_stdio));
uart_stdio.port = HAL_UART_STDIO_PORT;
/* Send data. */
return hal_uart_send(&uart_stdio, (uint8_t *)(&ch), 1, 1000);
}
#pragma weak bzero
/* referred from ota_socket.o */
void bzero()
{
}
/* referred from ssl_cli.o */
#pragma weak time
time_t time(time_t *t)
{
return 0;
}
/* referred from aos_network.o */
#pragma weak accept
int accept(int sock, long *addr, long *addrlen)
{
return 0;
}
#pragma weak listen
int listen(int sock, int backlog)
{
return 0;
}
/* referred from timing.o */
#pragma weak alarm
unsigned int alarm(unsigned int seconds)
{
return 0;
}
#endif
| YifuLiu/AliOS-Things | components/libc_stub/compilers/armlibc/armcc_libc_uspace.c | C | apache-2.0 | 2,155 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#include "sys/fcntl.h"
| YifuLiu/AliOS-Things | components/libc_stub/compilers/armlibc/fcntl.h | C | apache-2.0 | 88 |
#include "aos/compiler.h"
#define adc_dev_t void
#define pwm_dev_t void
#define rtc_dev_t void
#define rtc_time_t void
#define wdg_dev_t void
WEAK int hal_adc_finalize(adc_dev_t *adc)
{
return 0;
}
WEAK int hal_adc_init(adc_dev_t *adc)
{
return 0;
}
WEAK int hal_adc_value_get(adc_dev_t *adc, unsigned int *output, unsigned int timeout)
{
return 0;
}
WEAK int hal_pwm_finalize(pwm_dev_t *pwm)
{
return 0;
}
WEAK int hal_pwm_init(pwm_dev_t *pwm)
{
return 0;
}
WEAK int hal_pwm_start(pwm_dev_t *pwm)
{
return 0;
}
WEAK int hal_pwm_stop(pwm_dev_t *pwm)
{
return 0;
}
WEAK int hal_rtc_finalize(rtc_dev_t *rtc)
{
return 0;
}
WEAK int hal_rtc_get_time(rtc_dev_t *rtc, rtc_time_t *time)
{
return 0;
}
WEAK int hal_rtc_init(rtc_dev_t *rtc)
{
return 0;
}
WEAK int hal_rtc_set_time(rtc_dev_t *rtc, const rtc_time_t *time)
{
return 0;
}
WEAK int hal_wdg_finalize(wdg_dev_t *wdg)
{
return 0;
}
WEAK int hal_wdg_init(wdg_dev_t *wdg)
{
return 0;
}
WEAK void hal_wdg_reload(wdg_dev_t *wdg)
{
}
| YifuLiu/AliOS-Things | components/libc_stub/compilers/armlibc/hal_stub.c | C | apache-2.0 | 1,024 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef _SYS_ERRNO_H__
#define _SYS_ERRNO_H__
#define EPERM 1 /* Operation not permitted */
#define ENOENT 2 /* No such file or directory */
#define ESRCH 3 /* No such process */
#define EINTR 4 /* Interrupted system call */
#define EIO 5 /* I/O error */
#define ENXIO 6 /* No such device or address */
#define E2BIG 7 /* Arg list too long */
#define ENOEXEC 8 /* Exec format error */
#define EBADF 9 /* Bad file number */
#define ECHILD 10 /* No child processes */
#define EAGAIN 11 /* Try again */
#define ENOMEM 12 /* Out of memory */
#define EACCES 13 /* Permission denied */
#define EFAULT 14 /* Bad address */
#define ENOTBLK 15 /* Block device required */
#define EBUSY 16 /* Device or resource busy */
#define EEXIST 17 /* File exists */
#define EXDEV 18 /* Cross-device link */
#define ENODEV 19 /* No such device */
#define ENOTDIR 20 /* Not a directory */
#define EISDIR 21 /* Is a directory */
#define EINVAL 22 /* Invalid argument */
#define ENFILE 23 /* File table overflow */
#define EMFILE 24 /* Too many open files */
#define ENOTTY 25 /* Not a typewriter */
#define ETXTBSY 26 /* Text file busy */
#define EFBIG 27 /* File too large */
#define ENOSPC 28 /* No space left on device */
#define ESPIPE 29 /* Illegal seek */
#define EROFS 30 /* Read-only file system */
#define EMLINK 31 /* Too many links */
#define EPIPE 32 /* Broken pipe */
#define EDOM 33 /* Math argument out of domain of func */
#define ERANGE 34 /* Math result not representable */
#define EDEADLK 35 /* Resource deadlock would occur */
#define ENAMETOOLONG 36 /* File name too long */
#define ENOLCK 37 /* No record locks available */
#define ENOSYS 38 /* Function not implemented */
#define ENOTEMPTY 39 /* Directory not empty */
#define ELOOP 40 /* Too many symbolic links encountered */
#define EWOULDBLOCK EAGAIN /* Operation would block */
#define ENOMSG 42 /* No message of desired type */
#define EIDRM 43 /* Identifier removed */
#define ECHRNG 44 /* Channel number out of range */
#define EL2NSYNC 45 /* Level 2 not synchronized */
#define EL3HLT 46 /* Level 3 halted */
#define EL3RST 47 /* Level 3 reset */
#define ELNRNG 48 /* Link number out of range */
#define EUNATCH 49 /* Protocol driver not attached */
#define ENOCSI 50 /* No CSI structure available */
#define EL2HLT 51 /* Level 2 halted */
#define EBADE 52 /* Invalid exchange */
#define EBADR 53 /* Invalid request descriptor */
#define EXFULL 54 /* Exchange full */
#define ENOANO 55 /* No anode */
#define EBADRQC 56 /* Invalid request code */
#define EBADSLT 57 /* Invalid slot */
#define EDEADLOCK EDEADLK
#define EBFONT 59 /* Bad font file format */
#define ENOSTR 60 /* Device not a stream */
#define ENODATA 61 /* No data available */
#define ETIME 62 /* Timer expired */
#define ENOSR 63 /* Out of streams resources */
#define ENONET 64 /* Machine is not on the network */
#define ENOPKG 65 /* Package not installed */
#define EREMOTE 66 /* Object is remote */
#define ENOLINK 67 /* Link has been severed */
#define EADV 68 /* Advertise error */
#define ESRMNT 69 /* Srmount error */
#define ECOMM 70 /* Communication error on send */
#define EPROTO 71 /* Protocol error */
#define EMULTIHOP 72 /* Multihop attempted */
#define EDOTDOT 73 /* RFS specific error */
#define EBADMSG 74 /* Not a data message */
#define EOVERFLOW 75 /* Value too large for defined data type */
#define ENOTUNIQ 76 /* Name not unique on network */
#define EBADFD 77 /* File descriptor in bad state */
#define EREMCHG 78 /* Remote address changed */
#define ELIBACC 79 /* Can not access a needed shared library */
#define ELIBBAD 80 /* Accessing a corrupted shared library */
#define ELIBSCN 81 /* .lib section in a.out corrupted */
#define ELIBMAX 82 /* Attempting to link in too many shared libraries */
#define ELIBEXEC 83 /* Cannot exec a shared library directly */
#define EILSEQ 84 /* Illegal byte sequence */
#define ERESTART 85 /* Interrupted system call should be restarted */
#define ESTRPIPE 86 /* Streams pipe error */
#define EUSERS 87 /* Too many users */
#define ENOTSOCK 88 /* Socket operation on non-socket */
#define EDESTADDRREQ 89 /* Destination address required */
#define EMSGSIZE 90 /* Message too long */
#define EPROTOTYPE 91 /* Protocol wrong type for socket */
#define ENOPROTOOPT 92 /* Protocol not available */
#define EPROTONOSUPPORT 93 /* Protocol not supported */
#define ESOCKTNOSUPPORT 94 /* Socket type not supported */
#define EOPNOTSUPP 95 /* Operation not supported on transport endpoint */
#define EPFNOSUPPORT 96 /* Protocol family not supported */
#define EAFNOSUPPORT 97 /* Address family not supported by protocol */
#define EADDRINUSE 98 /* Address already in use */
#define EADDRNOTAVAIL 99 /* Cannot assign requested address */
#define ENETDOWN 100 /* Network is down */
#define ENETUNREACH 101 /* Network is unreachable */
#define ENETRESET 102 /* Network dropped connection because of reset */
#define ECONNABORTED 103 /* Software caused connection abort */
#define ECONNRESET 104 /* Connection reset by peer */
#define ENOBUFS 105 /* No buffer space available */
#define EISCONN 106 /* Transport endpoint is already connected */
#define ENOTCONN 107 /* Transport endpoint is not connected */
#define ESHUTDOWN 108 /* Cannot send after transport endpoint shutdown */
#define ETOOMANYREFS 109 /* Too many references: cannot splice */
#define ETIMEDOUT 110 /* Connection timed out */
#define ECONNREFUSED 111 /* Connection refused */
#define EHOSTDOWN 112 /* Host is down */
#define EHOSTUNREACH 113 /* No route to host */
#define EALREADY 114 /* Operation already in progress */
#define EINPROGRESS 115 /* Operation now in progress */
#define ESTALE 116 /* Stale NFS file handle */
#define EUCLEAN 117 /* Structure needs cleaning */
#define ENOTNAM 118 /* Not a XENIX named type file */
#define ENAVAIL 119 /* No XENIX semaphores available */
#define EISNAM 120 /* Is a named type file */
#define EREMOTEIO 121 /* Remote I/O error */
#define EDQUOT 122 /* Quota exceeded */
#define ENOMEDIUM 123 /* No medium found */
#define EMEDIUMTYPE 124 /* Wrong medium type */
#define ENSROK 0 /* DNS server returned answer with no data */
#define ENSRNODATA 160 /* DNS server returned answer with no data */
#define ENSRFORMERR 161 /* DNS server claims query was misformatted */
#define ENSRSERVFAIL 162 /* DNS server returned general failure */
#define ENSRNOTFOUND 163 /* Domain name not found */
#define ENSRNOTIMP 164 /* DNS server does not implement requested operation */
#define ENSRREFUSED 165 /* DNS server refused query */
#define ENSRBADQUERY 166 /* Misformatted DNS query */
#define ENSRBADNAME 167 /* Misformatted domain name */
#define ENSRBADFAMILY 168 /* Unsupported address family */
#define ENSRBADRESP 169 /* Misformatted DNS reply */
#define ENSRCONNREFUSED 170 /* Could not contact DNS servers */
#define ENSRTIMEOUT 171 /* Timeout while contacting DNS servers */
#define ENSROF 172 /* End of file */
#define ENSRFILE 173 /* Error reading file */
#define ENSRNOMEM 174 /* Out of memory */
#define ENSRDESTRUCTION 175 /* Application terminated lookup */
#define ENSRQUERYDOMAINTOOLONG 176 /* Domain name is too long */
#define ENSRCNAMELOOP 177 /* Domain name is too long */
#endif /* _SYS_ERROR_H */
#ifndef errno
extern int errno;
#endif
| YifuLiu/AliOS-Things | components/libc_stub/compilers/armlibc/sys/errno_bak.h | C | apache-2.0 | 8,446 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef LIBC_FCNTL_H__
#define LIBC_FCNTL_H__
#define O_RDONLY 00
#define O_WRONLY 01
#define O_RDWR 02
#define O_CREAT 0100
#define O_EXCL 0200
#define O_NOCTTY 0400
#define O_TRUNC 01000
#define O_APPEND 02000
#define O_NONBLOCK 04000
#define O_DSYNC 010000
#define O_SYNC 04010000
#define O_RSYNC 04010000
#define O_BINARY 0100000
#define O_DIRECTORY 0200000
#define O_NOFOLLOW 0400000
#define O_CLOEXEC 02000000
#define O_ASYNC 020000
#define O_DIRECT 040000
#define O_LARGEFILE 0100000
#define O_NOATIME 01000000
#define O_PATH 010000000
#define O_TMPFILE 020200000
#define O_NDELAY O_NONBLOCK
#define O_SEARCH O_PATH
#define O_EXEC O_PATH
#define O_ACCMODE (03|O_SEARCH)
#define F_DUPFD 0
#define F_GETFD 1
#define F_SETFD 2
#define F_GETFL 3
#define F_SETFL 4
#define F_SETOWN 8
#define F_GETOWN 9
#define F_SETSIG 10
#define F_GETSIG 11
#define F_GETLK 12
#define F_SETLK 13
#define F_SETLKW 14
#define F_SETOWN_EX 15
#define F_GETOWN_EX 16
#define F_GETOWNER_UIDS 17
#endif
| YifuLiu/AliOS-Things | components/libc_stub/compilers/armlibc/sys/fcntl.h | C | apache-2.0 | 1,160 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef _SYS_SELECT_H__
#define _SYS_SELECT_H__
#ifndef FD_SETSIZE
#define FD_SETSIZE 256
#endif
#define NBBY 8 /* number of bits in a byte */
typedef long fd_mask;
#define NFDBITS (sizeof (fd_mask) * NBBY) /* bits per mask */
#ifndef howmany
#define howmany(x,y) (((x)+((y)-1))/(y))
#endif
/* We use a macro for fd_set so that including Sockets.h afterwards
can work. */
typedef struct _types_fd_set {
fd_mask fds_bits[howmany(FD_SETSIZE, NFDBITS)];
} _types_fd_set;
#define fd_set _types_fd_set
#define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] |= (1L << ((n) % NFDBITS)))
#define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1L << ((n) % NFDBITS)))
#define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1L << ((n) % NFDBITS)))
#define FD_ZERO(p) memset((void*)(p), 0, sizeof(*(p)))
#endif
| YifuLiu/AliOS-Things | components/libc_stub/compilers/armlibc/sys/select.h | C | apache-2.0 | 875 |
#ifndef _SIGNAL_H_
#define _SIGNAL_H_
#define SIGALRM 14
#endif
// eof
| YifuLiu/AliOS-Things | components/libc_stub/compilers/armlibc/sys/signal.h | C | apache-2.0 | 75 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef _SYS_STAT_H__
#define _SYS_STAT_H__
#define S_IFMT 00170000
#define S_IFSOCK 0140000
#define S_IFLNK 0120000
#define S_IFREG 0100000
#define S_IFBLK 0060000
#define S_IFDIR 0040000
#define S_IFCHR 0020000
#define S_IFIFO 0010000
#define S_ISUID 0004000
#define S_ISGID 0002000
#define S_ISVTX 0001000
#define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
#define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
#define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
#define S_ISCHR(m) (((m) & S_IFMT) == S_IFCHR)
#define S_ISBLK(m) (((m) & S_IFMT) == S_IFBLK)
#define S_ISFIFO(m) (((m) & S_IFMT) == S_IFIFO)
#define S_ISSOCK(m) (((m) & S_IFMT) == S_IFSOCK)
#define S_IRWXU 00700
#define S_IRUSR 00400
#define S_IWUSR 00200
#define S_IXUSR 00100
#define S_IRWXG 00070
#define S_IRGRP 00040
#define S_IWGRP 00020
#define S_IXGRP 00010
#define S_IRWXO 00007
#define S_IROTH 00004
#define S_IWOTH 00002
#define S_IXOTH 00001
/* stat structure */
#include <stdint.h>
#include <time.h>
struct stat
{
struct rt_device* st_dev;
uint16_t st_mode;
uint32_t st_size;
time_t st_mtime;
uint32_t st_blksize;
};
#endif
| YifuLiu/AliOS-Things | components/libc_stub/compilers/armlibc/sys/stat.h | C | apache-2.0 | 1,551 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef _SYS_TIME_H_
#define _SYS_TIME_H_
#include <time.h>
#include <sys/types.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifndef _TIMEVAL_DEFINED
#define _TIMEVAL_DEFINED
/*
* Structure returned by gettimeofday(2) system call,
* and used in other calls.
*/
struct timeval {
long tv_sec; /* seconds */
long tv_usec; /* and microseconds */
};
#endif /* _TIMEVAL_DEFINED */
#ifndef _TIMESPEC_DEFINED
#define _TIMESPEC_DEFINED
/*
* Structure defined by POSIX.1b to be like a timeval.
*/
struct timespec {
time_t tv_sec; /* seconds */
long tv_nsec; /* and nanoseconds */
};
#endif /* _TIMESPEC_DEFINED */
struct timezone {
int tz_minuteswest; /* minutes west of Greenwich */
int tz_dsttime; /* type of dst correction */
};
int gettimeofday(struct timeval *tp, void *ignore);
#ifdef __cplusplus
}
#endif
#endif /* _SYS_TIME_H_ */
| YifuLiu/AliOS-Things | components/libc_stub/compilers/armlibc/sys/time.h | C | apache-2.0 | 956 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef _SYS_TYPES_H
#define _SYS_TYPES_H
#include <stdint.h>
typedef uint32_t clockid_t;
typedef uint32_t key_t; /* Used for interprocess communication. */
typedef uint32_t pid_t; /* Used for process IDs and process group IDs. */
typedef signed long ssize_t; /* Used for a count of bytes or an error indication. */
typedef long long off_t;
typedef long suseconds_t;
#ifndef PATH_MAX
#define PATH_MAX 1024
#endif
#if __BSD_VISIBLE
#include <sys/select.h>
#endif
#endif /* _SYS_TYPES_H */
| YifuLiu/AliOS-Things | components/libc_stub/compilers/armlibc/sys/types.h | C | apache-2.0 | 595 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef _SYS_UNISTD_H
#define _SYS_UNISTD_H
#endif /* _SYS_UNISTD_H */
| YifuLiu/AliOS-Things | components/libc_stub/compilers/armlibc/sys/unistd.h | C | apache-2.0 | 138 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#include "sys/unistd.h"
| YifuLiu/AliOS-Things | components/libc_stub/compilers/armlibc/unistd.h | C | apache-2.0 | 89 |
/*
* Copyright (C) 2019-2020 Alibaba Group Holding Limited
*/
#ifndef SYS_IOCTL_H
#define SYS_IOCTL_H
#ifdef __cplusplus
extern "C" {
#endif
int ioctl(int fd, int req, ...);
#ifdef __cplusplus
}
#endif
#endif /* SYS_IOCTL_H */
| YifuLiu/AliOS-Things | components/libc_stub/compilers/gcc/sys/ioctl.h | C | apache-2.0 | 234 |
/*
* Copyright (C) 2020-2021 Alibaba Group Holding Limited
* A modified version of termios in Haiku OS
* Distributed under the terms of the MIT License.
*/
#ifndef SYS_TERMIOS_H
#define SYS_TERMIOS_H
#include <errno.h>
#if (defined(AOS_KERNEL_BUILD) && defined(AOS_COMP_DEVFS)) || !defined(AOS_KERNEL_BUILD)
#include <sys/ioctl.h>
#endif
typedef unsigned long tcflag_t;
typedef unsigned long speed_t;
typedef unsigned char cc_t;
#define NCCS 12 /* number of control characters */
struct termios {
tcflag_t c_iflag; /* input modes */
tcflag_t c_oflag; /* output modes */
tcflag_t c_cflag; /* control modes */
tcflag_t c_lflag; /* local modes */
cc_t c_cc[NCCS]; /* control characters */
};
/* control characters */
#define VINTR 0
#define VQUIT 1
#define VERASE 2
#define VKILL 3
#define VEOF 4
#define VEOL 5
#define VMIN 6
#define VTIME 7
#define VEOL2 8
#define VSTART 9
#define VSTOP 10
#define VSUSP 11
/* c_iflag - input control modes */
#define IGNBRK 0x0001 /* ignore break condition */
#define BRKINT 0x0002 /* break sends interrupt */
#define IGNPAR 0x0004 /* ignore characters with parity errors */
#define PARMRK 0x0008 /* mark parity errors */
#define INPCK 0x0010 /* enable input parity checking */
#define ISTRIP 0x0020 /* strip high bit from characters */
#define INLCR 0x0040 /* maps newline to CR on input */
#define IGNCR 0x0080 /* ignore carriage returns */
#define ICRNL 0x0100 /* map CR to newline on input */
#define IUCLC 0x0200 /* map all upper case to lower */
#define IXON 0x0400 /* enable input SW flow control */
#define IXANY 0x0800 /* any character will restart input */
#define IXOFF 0x1000 /* enable output SW flow control */
/* c_oflag - output control modes */
#define OPOST 0x0001 /* enable postprocessing of output */
#define OLCUC 0x0002 /* map lowercase to uppercase */
#define ONLCR 0x0004 /* map NL to CR-NL on output */
#define OCRNL 0x0008 /* map CR to NL on output */
#define ONOCR 0x0010 /* no CR output when at column 0 */
#define ONLRET 0x0020 /* newline performs CR function */
#define OFILL 0x0040 /* use fill characters for delays */
#define OFDEL 0x0080 /* Fills are DEL, otherwise NUL */
#define NLDLY 0x0100 /* Newline delays: */
#define NL0 0x0000
#define NL1 0x0100
#define CRDLY 0x0600 /* Carriage return delays: */
#define CR0 0x0000
#define CR1 0x0200
#define CR2 0x0400
#define CR3 0x0600
#define TABDLY 0x1800 /* Tab delays: */
#define TAB0 0x0000
#define TAB1 0x0800
#define TAB2 0x1000
#define TAB3 0x1800
#define BSDLY 0x2000 /* Backspace delays: */
#define BS0 0x0000
#define BS1 0x2000
#define VTDLY 0x4000 /* Vertical tab delays: */
#define VT0 0x0000
#define VT1 0x4000
#define FFDLY 0x8000 /* Form feed delays: */
#define FF0 0x0000
#define FF1 0x8000
/* c_cflag - control modes */
#define CBAUD 0x1000F /* line speed definitions */
#define B0 0x00 /* hang up */
#define B50 0x01 /* 50 baud */
#define B75 0x02
#define B110 0x03
#define B134 0x04
#define B150 0x05
#define B200 0x06
#define B300 0x07
#define B600 0x08
#define B1200 0x09
#define B1800 0x0A
#define B2400 0x0B
#define B4800 0x0C
#define B9600 0x0D
#define B19200 0x0E
#define B38400 0x0F
#define CBAUDEX 0x10000
#define B57600 0x10001
#define B115200 0x10002
#define B230400 0x10003
#define B460800 0x10004
#define B500000 0x10005
#define B576000 0x10006
#define B921600 0x10007
#define B1000000 0x10008
#define B1152000 0x10009
#define B1500000 0x1000A
#define B2000000 0x1000B
#define B2500000 0x1000C
#define B3000000 0x1000D
#define B3500000 0x1000E
#define B4000000 0x1000F
#define CSIZE 0x0030 /* character size */
#define CS5 0x0000
#define CS6 0x0010
#define CS7 0x0020
#define CS8 0x0030
#define CSTOPB 0x0040 /* send 2 stop bits, not 1 */
#define CREAD 0x0080 /* enable receiver */
#define PARENB 0x0100 /* parity enable */
#define PARODD 0x0200 /* odd parity, else even */
#define HUPCL 0x0400 /* hangs up on last close */
#define CLOCAL 0x0800 /* indicates local line */
#define XLOBLK 0x1000 /* block layer output? */
#define CTSFLOW 0x2000 /* enable CTS flow */
#define RTSFLOW 0x4000 /* enable RTS flow */
#define CRTSCTS (RTSFLOW | CTSFLOW)
/* c_lflag - local modes */
#define ISIG 0x0001 /* enable signals */
#define ICANON 0x0002 /* Canonical input */
#define XCASE 0x0004 /* Canonical u/l case */
#define ECHO 0x0008 /* Enable echo */
#define ECHOE 0x0010 /* Echo erase as bs-sp-bs */
#define ECHOK 0x0020 /* Echo nl after kill */
#define ECHONL 0x0040 /* Echo nl */
#define NOFLSH 0x0080 /* Disable flush after int or quit */
#define TOSTOP 0x0100 /* stop bg processes that write to tty */
#define IEXTEN 0x0200 /* implementation defined extensions */
#define ECHOCTL 0x0400
#define ECHOPRT 0x0800
#define ECHOKE 0x1000
#define FLUSHO 0x2000
#define PENDIN 0x4000
/* options to tcsetattr() */
#define TCSANOW 0x01 /* make change immediate */
#define TCSADRAIN 0x02 /* drain output, then change */
#define TCSAFLUSH 0x04 /* drain output, flush input */
/* actions for tcflow() */
#define TCOOFF 0x01 /* suspend output */
#define TCOON 0x02 /* restart output */
#define TCIOFF 0x04 /* transmit STOP character, intended to stop input data */
#define TCION 0x08 /* transmit START character, intended to resume input data */
/* values for tcflush() */
#define TCIFLUSH 0x01 /* flush pending input */
#define TCOFLUSH 0x02 /* flush untransmitted output */
#define TCIOFLUSH 0x03 /* flush both */
#if (defined(AOS_KERNEL_BUILD) && defined(AOS_COMP_DEVFS)) || !defined(AOS_KERNEL_BUILD)
struct winsize {
unsigned short ws_row;
unsigned short ws_col;
unsigned short ws_xpixel;
unsigned short ws_ypixel;
};
#define TCGETS 0x5401
#define TCSETS 0x5402
#define TCSETSW 0x5403
#define TCSETSF 0x5404
#define TCSBRK 0x5405
#define TCXONC 0x5406
#define TCFLSH 0x5407
#define TIOCGWINSZ 0x5408
#define TIOCSWINSZ 0x5409
#endif /* (defined(AOS_KERNEL_BUILD) && defined(AOS_COMP_DEVFS)) || !defined(AOS_KERNEL_BUILD) */
#ifdef __cplusplus
extern "C" {
#endif
static inline void cfmakeraw(struct termios *termios)
{
termios->c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON);
termios->c_oflag &= ~OPOST;
termios->c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
termios->c_cflag &= ~(CSIZE | PARENB | PARODD);
termios->c_cflag |= CS8;
}
static inline speed_t cfgetspeed(const struct termios *termios)
{
speed_t ret;
if (!termios)
return 0;
switch (termios->c_cflag & CBAUD) {
case B0:
ret = 0;
break;
case B50:
ret = 50;
break;
case B75:
ret = 75;
break;
case B110:
ret = 110;
break;
case B134:
ret = 134;
break;
case B150:
ret = 150;
break;
case B200:
ret = 200;
break;
case B300:
ret = 300;
break;
case B600:
ret = 600;
break;
case B1200:
ret = 1200;
break;
case B1800:
ret = 1800;
break;
case B2400:
ret = 2400;
break;
case B4800:
ret = 4800;
break;
case B9600:
ret = 9600;
break;
case B19200:
ret = 19200;
break;
case B38400:
ret = 38400;
break;
case B57600:
ret = 57600;
break;
case B115200:
ret = 115200;
break;
case B230400:
ret = 230400;
break;
case B460800:
ret = 460800;
break;
case B500000:
ret = 500000;
break;
case B576000:
ret = 576000;
break;
case B921600:
ret = 921600;
break;
case B1000000:
ret = 1000000;
break;
case B1152000:
ret = 1152000;
break;
case B1500000:
ret = 1500000;
break;
case B2000000:
ret = 2000000;
break;
case B2500000:
ret = 2500000;
break;
case B3000000:
ret = 3000000;
break;
case B3500000:
ret = 3500000;
break;
case B4000000:
ret = 4000000;
break;
default:
ret = 0;
break;
}
return ret;
}
static inline speed_t cfgetispeed(const struct termios *termios)
{
return cfgetspeed(termios);
}
static inline speed_t cfgetospeed(const struct termios *termios)
{
return cfgetspeed(termios);
}
static inline int cfsetspeed(struct termios *termios, speed_t speed)
{
tcflag_t flag;
if (!termios) {
errno = EINVAL;
return -1;
}
switch (speed) {
case 0:
flag = B0;
break;
case 50:
flag = B50;
break;
case 75:
flag = B75;
break;
case 110:
flag = B110;
break;
case 134:
flag = B134;
break;
case 150:
flag = B150;
break;
case 200:
flag = B200;
break;
case 300:
flag = B300;
break;
case 600:
flag = B600;
break;
case 1200:
flag = B1200;
break;
case 1800:
flag = B1800;
break;
case 2400:
flag = B2400;
break;
case 4800:
flag = B4800;
break;
case 9600:
flag = B9600;
break;
case 19200:
flag = B19200;
break;
case 38400:
flag = B38400;
break;
case 57600:
flag = B57600;
break;
case 115200:
flag = B115200;
break;
case 230400:
flag = B230400;
break;
case 460800:
flag = B460800;
break;
case 500000:
flag = B500000;
break;
case 576000:
flag = B576000;
break;
case 921600:
flag = B921600;
break;
case 1000000:
flag = B1000000;
break;
case 1152000:
flag = B1152000;
break;
case 1500000:
flag = B1500000;
break;
case 2000000:
flag = B2000000;
break;
case 2500000:
flag = B2500000;
break;
case 3000000:
flag = B3000000;
break;
case 3500000:
flag = B3500000;
break;
case 4000000:
flag = B4000000;
break;
default:
errno = EINVAL;
return -1;
}
termios->c_cflag &= ~CBAUD;
termios->c_cflag |= flag;
return 0;
}
static inline int cfsetispeed(struct termios *termios, speed_t speed)
{
return cfsetspeed(termios, speed);
}
static inline int cfsetospeed(struct termios *termios, speed_t speed)
{
return cfsetspeed(termios, speed);
}
#if (defined(AOS_KERNEL_BUILD) && defined(AOS_COMP_DEVFS)) || !defined(AOS_KERNEL_BUILD)
static inline int tcgetattr(int fd, struct termios *termios)
{
return ioctl(fd, TCGETS, termios);
}
static inline int tcsetattr(int fd, int optional_actions, const struct termios *termios)
{
int cmd;
switch (optional_actions) {
case TCSANOW:
cmd = TCSETS;
break;
case TCSADRAIN:
cmd = TCSETSW;
break;
case TCSAFLUSH:
cmd = TCSETSF;
break;
default:
errno = EINVAL;
return -1;
}
return ioctl(fd, cmd, termios);
}
static inline int tcsendbreak(int fd, int duration)
{
return ioctl(fd, TCSBRK, duration);
}
static inline int tcdrain(int fd)
{
return tcsendbreak(fd, 1);
}
static inline int tcflush(int fd, int where)
{
return ioctl(fd, TCFLSH, where);
}
static inline int tcflow(int fd, int action)
{
return ioctl(fd, TCXONC, action);
}
#endif /* (defined(AOS_KERNEL_BUILD) && defined(AOS_COMP_DEVFS)) || !defined(AOS_KERNEL_BUILD) */
#ifdef __cplusplus
}
#endif
#endif /* SYS_TERMIOS_H */
| YifuLiu/AliOS-Things | components/libc_stub/compilers/gcc/sys/termios.h | C | apache-2.0 | 12,827 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#include "sys/fcntl.h"
| YifuLiu/AliOS-Things | components/libc_stub/compilers/iar/fcntl.h | C | apache-2.0 | 88 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifdef __ICCARM__
#include <stdarg.h>
#include <sys/types.h>
#include <time.h>
#include <stdio.h>
#include <string.h>
#include "aos/kernel.h"
#include "aos/hal/uart.h"
int errno;
extern void *aos_malloc(unsigned int size);
extern void aos_alloc_trace(void *addr, size_t allocator);
extern void aos_free(void *mem);
extern void *aos_realloc(void *mem, unsigned int size);
extern long long aos_now_ms(void);
__ATTRIBUTES void *malloc(unsigned int size)
{
void *mem;
#if (RHINO_CONFIG_MM_DEBUG > 0u)
mem = aos_malloc(size | AOS_UNSIGNED_INT_MSB);
#else
mem = aos_malloc(size);
#endif
return mem;
}
__ATTRIBUTES void *realloc(void *old, unsigned int newlen)
{
void *mem;
#if (RHINO_CONFIG_MM_DEBUG > 0u)
mem = aos_realloc(old, newlen | AOS_UNSIGNED_INT_MSB);
#else
mem = aos_realloc(old, newlen);
#endif
return mem;
}
__ATTRIBUTES void *calloc(size_t len, size_t elsize)
{
void *mem;
#if (RHINO_CONFIG_MM_DEBUG > 0u)
mem = aos_malloc((elsize * len) | AOS_UNSIGNED_INT_MSB);
#else
mem = aos_malloc(elsize * len);
#endif
if (mem) {
memset(mem, 0, elsize * len);
}
return mem;
}
__ATTRIBUTES void free(void *mem)
{
aos_free(mem);
}
__ATTRIBUTES time_t time(time_t *tod)
{
uint64_t t = aos_now_ms();
return (time_t)(t / 1000);
}
int *__errno _PARAMS ((void))
{
return 0;
}
void __assert_func(const char *a, int b, const char *c, const char *d)
{
while (1);
}
/*TO DO*/
#pragma weak __write
size_t __write(int handle, const unsigned char *buffer, size_t size)
{
uart_dev_t uart_stdio;
int i;
memset(&uart_stdio, 0, sizeof(uart_stdio));
uart_stdio.port = HAL_UART_STDIO_PORT;
if (buffer == 0) {
/*
* This means that we should flush internal buffers. Since we don't we just return.
* (Remember, "handle" == -1 means that all handles should be flushed.)
*/
return 0;
}
/* This function only writes to "standard out" and "standard err" for all other file handles it returns failure. */
if ((handle != 1) && (handle != 2)) {
return ((size_t) - 1);
}
/* Send data. */
for (i = 0; i < size; i++) {
if (buffer[i] == '\n') {
hal_uart_send(&uart_stdio, (void *)"\r", 1, AOS_WAIT_FOREVER);
}
hal_uart_send(&uart_stdio, &buffer[i], 1, AOS_WAIT_FOREVER);
}
return size;
}
void bzero()
{
}
void __lseek()
{
}
void __close()
{
}
int remove(char const *p)
{
return 0;
}
void gettimeofday()
{
}
void getopt()
{
}
void optarg()
{
}
#endif
| YifuLiu/AliOS-Things | components/libc_stub/compilers/iar/iar_libc.c | C | apache-2.0 | 2,666 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifdef __ICCARM__
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include "aos/kernel.h"
#include "sys/types.h"
#include "sys/time.h"
#include "aos/hal/uart.h"
#include "umm.h"
int errno;
extern long long aos_now_ms(void);
__ATTRIBUTES void *malloc(unsigned int size)
{
return umm_alloc(size);
}
__ATTRIBUTES void *realloc(void *old, unsigned int newlen)
{
return umm_realloc(old, newlen);
}
__ATTRIBUTES void *calloc(size_t len, size_t elsize)
{
void *mem;
mem = umm_alloc(elsize * len);
if (mem) {
memset(mem, 0, elsize * len);
}
return mem;
}
__ATTRIBUTES void free(void *mem)
{
umm_free(mem);
}
__ATTRIBUTES time_t time(time_t *tod)
{
uint64_t t = aos_now_ms();
return (time_t)(t / 1000);
}
int *__errno _PARAMS ((void))
{
return 0;
}
void __assert_func(const char *a, int b, const char *c, const char *d)
{
while (1);
}
/*TO DO*/
#pragma weak __write
size_t __write(int handle, const unsigned char *buffer, size_t size)
{
uart_dev_t uart_stdio;
int i;
memset(&uart_stdio, 0, sizeof(uart_stdio));
uart_stdio.port = HAL_UART_STDIO_PORT;
if (buffer == 0) {
/*
* This means that we should flush internal buffers. Since we don't we just return.
* (Remember, "handle" == -1 means that all handles should be flushed.)
*/
return 0;
}
/* This function only writes to "standard out" and "standard err" for all other file handles it returns failure. */
if ((handle != 1) && (handle != 2)) {
return ((size_t) - 1);
}
/* Send data. */
for (i = 0; i < size; i++) {
if (buffer[i] == '\n') {
hal_uart_send(&uart_stdio, (void *)"\r", 1, AOS_WAIT_FOREVER);
}
hal_uart_send(&uart_stdio, &buffer[i], 1, AOS_WAIT_FOREVER);
}
return size;
}
void bzero()
{
}
void __lseek()
{
}
void __close()
{
}
int remove(char const *p)
{
return 0;
}
int gettimeofday(struct timeval *tp, void *ignore)
{
return 0;
}
void getopt()
{
}
void optarg()
{
}
#endif
| YifuLiu/AliOS-Things | components/libc_stub/compilers/iar/iar_libc_uspace.c | C | apache-2.0 | 2,142 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
/* This header file provides the reentrancy. */
/* The reentrant system calls here serve two purposes:
1) Provide reentrant versions of the system calls the ANSI C library
requires.
2) Provide these system calls in a namespace clean way.
It is intended that *all* system calls that the ANSI C library needs
be declared here. It documents them all in one place. All library access
to the system is via some form of these functions.
The target may provide the needed syscalls by any of the following:
1) Define the reentrant versions of the syscalls directly.
(eg: _open_r, _close_r, etc.). Please keep the namespace clean.
When you do this, set "syscall_dir" to "syscalls" and add
-DREENTRANT_SYSCALLS_PROVIDED to newlib_cflags in configure.host.
2) Define namespace clean versions of the system calls by prefixing
them with '_' (eg: _open, _close, etc.). Technically, there won't be
true reentrancy at the syscall level, but the library will be namespace
clean.
When you do this, set "syscall_dir" to "syscalls" in configure.host.
3) Define or otherwise provide the regular versions of the syscalls
(eg: open, close, etc.). The library won't be reentrant nor namespace
clean, but at least it will work.
When you do this, add -DMISSING_SYSCALL_NAMES to newlib_cflags in
configure.host.
4) Define or otherwise provide the regular versions of the syscalls,
and do not supply functional interfaces for any of the reentrant
calls. With this method, the reentrant syscalls are redefined to
directly call the regular system call without the reentrancy argument.
When you do this, specify both -DREENTRANT_SYSCALLS_PROVIDED and
-DMISSING_SYSCALL_NAMES via newlib_cflags in configure.host and do
not specify "syscall_dir".
Stubs of the reentrant versions of the syscalls exist in the libc/reent
source directory and are provided if REENTRANT_SYSCALLS_PROVIDED isn't
defined. These stubs call the native system calls: _open, _close, etc.
if MISSING_SYSCALL_NAMES is *not* defined, otherwise they call the
non-underscored versions: open, close, etc. when MISSING_SYSCALL_NAMES
*is* defined.
By default, newlib functions call the reentrant syscalls internally,
passing a reentrancy structure as an argument. This reentrancy structure
contains data that is thread-specific. For example, the errno value is
kept in the reentrancy structure. If multiple threads exist, each will
keep a separate errno value which is intuitive since the application flow
cannot check for failure reliably otherwise.
The reentrant syscalls are either provided by the platform, by the
libc/reent stubs, or in the case of both MISSING_SYSCALL_NAMES and
REENTRANT_SYSCALLS_PROVIDED being defined, the calls are redefined to
simply call the regular syscalls with no reentrancy struct argument.
A single-threaded application does not need to worry about the reentrancy
structure. It is used internally.
A multi-threaded application needs either to manually manage reentrancy
structures or use dynamic reentrancy.
Manually managing reentrancy structures entails calling special reentrant
versions of newlib functions that have an additional reentrancy argument.
For example, _printf_r. By convention, the first argument is the
reentrancy structure. By default, the normal version of the function
uses the default reentrancy structure: _REENT. The reentrancy structure
is passed internally, eventually to the reentrant syscalls themselves.
How the structures are stored and accessed in this model is up to the
application.
Dynamic reentrancy is specified by the __DYNAMIC_REENT__ flag. This
flag denotes setting up a macro to replace _REENT with a function call
to __getreent(). This function needs to be implemented by the platform
and it is meant to return the reentrancy structure for the current
thread. When the regular C functions (e.g. printf) go to call internal
routines with the default _REENT structure, they end up calling with
the reentrancy structure for the thread. Thus, application code does not
need to call the _r routines nor worry about reentrancy structures. */
/* WARNING: All identifiers here must begin with an underscore. This file is
included by stdio.h and others and we therefore must only use identifiers
in the namespace allotted to us. */
#ifndef _REENT_H_
#ifdef __cplusplus
extern "C" {
#endif
#define _REENT_H_
#include <sys/reent.h>
#ifdef __cplusplus
}
#endif
#endif /* _REENT_H_ */
| YifuLiu/AliOS-Things | components/libc_stub/compilers/iar/reent.h | C | apache-2.0 | 4,748 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef _SYS_ERRNO_H__
#define _SYS_ERRNO_H__
#define EPERM 1 /* Operation not permitted */
#define ENOENT 2 /* No such file or directory */
#define ESRCH 3 /* No such process */
#define EINTR 4 /* Interrupted system call */
#define EIO 5 /* I/O error */
#define ENXIO 6 /* No such device or address */
#define E2BIG 7 /* Arg list too long */
#define ENOEXEC 8 /* Exec format error */
#define EBADF 9 /* Bad file number */
#define ECHILD 10 /* No child processes */
#define EAGAIN 11 /* Try again */
#define ENOMEM 12 /* Out of memory */
#define EACCES 13 /* Permission denied */
#define EFAULT 14 /* Bad address */
#define ENOTBLK 15 /* Block device required */
#define EBUSY 16 /* Device or resource busy */
#define EEXIST 17 /* File exists */
#define EXDEV 18 /* Cross-device link */
#define ENODEV 19 /* No such device */
#define ENOTDIR 20 /* Not a directory */
#define EISDIR 21 /* Is a directory */
#define EINVAL 22 /* Invalid argument */
#define ENFILE 23 /* File table overflow */
#define EMFILE 24 /* Too many open files */
#define ENOTTY 25 /* Not a typewriter */
#define ETXTBSY 26 /* Text file busy */
#define EFBIG 27 /* File too large */
#define ENOSPC 28 /* No space left on device */
#define ESPIPE 29 /* Illegal seek */
#define EROFS 30 /* Read-only file system */
#define EMLINK 31 /* Too many links */
#define EPIPE 32 /* Broken pipe */
#define EDOM 33 /* Math argument out of domain of func */
#define ERANGE 34 /* Math result not representable */
#define EDEADLK 35 /* Resource deadlock would occur */
#define ENAMETOOLONG 36 /* File name too long */
#define ENOLCK 37 /* No record locks available */
#define ENOSYS 38 /* Function not implemented */
#define ENOTEMPTY 39 /* Directory not empty */
#define ELOOP 40 /* Too many symbolic links encountered */
#define EWOULDBLOCK EAGAIN /* Operation would block */
#define ENOMSG 42 /* No message of desired type */
#define EIDRM 43 /* Identifier removed */
#define ECHRNG 44 /* Channel number out of range */
#define EL2NSYNC 45 /* Level 2 not synchronized */
#define EL3HLT 46 /* Level 3 halted */
#define EL3RST 47 /* Level 3 reset */
#define ELNRNG 48 /* Link number out of range */
#define EUNATCH 49 /* Protocol driver not attached */
#define ENOCSI 50 /* No CSI structure available */
#define EL2HLT 51 /* Level 2 halted */
#define EBADE 52 /* Invalid exchange */
#define EBADR 53 /* Invalid request descriptor */
#define EXFULL 54 /* Exchange full */
#define ENOANO 55 /* No anode */
#define EBADRQC 56 /* Invalid request code */
#define EBADSLT 57 /* Invalid slot */
#define EDEADLOCK EDEADLK
#define EBFONT 59 /* Bad font file format */
#define ENOSTR 60 /* Device not a stream */
#define ENODATA 61 /* No data available */
#define ETIME 62 /* Timer expired */
#define ENOSR 63 /* Out of streams resources */
#define ENONET 64 /* Machine is not on the network */
#define ENOPKG 65 /* Package not installed */
#define EREMOTE 66 /* Object is remote */
#define ENOLINK 67 /* Link has been severed */
#define EADV 68 /* Advertise error */
#define ESRMNT 69 /* Srmount error */
#define ECOMM 70 /* Communication error on send */
#define EPROTO 71 /* Protocol error */
#define EMULTIHOP 72 /* Multihop attempted */
#define EDOTDOT 73 /* RFS specific error */
#define EBADMSG 74 /* Not a data message */
#define EOVERFLOW 75 /* Value too large for defined data type */
#define ENOTUNIQ 76 /* Name not unique on network */
#define EBADFD 77 /* File descriptor in bad state */
#define EREMCHG 78 /* Remote address changed */
#define ELIBACC 79 /* Can not access a needed shared library */
#define ELIBBAD 80 /* Accessing a corrupted shared library */
#define ELIBSCN 81 /* .lib section in a.out corrupted */
#define ELIBMAX 82 /* Attempting to link in too many shared libraries */
#define ELIBEXEC 83 /* Cannot exec a shared library directly */
#define EILSEQ 84 /* Illegal byte sequence */
#define ERESTART 85 /* Interrupted system call should be restarted */
#define ESTRPIPE 86 /* Streams pipe error */
#define EUSERS 87 /* Too many users */
#define ENOTSOCK 88 /* Socket operation on non-socket */
#define EDESTADDRREQ 89 /* Destination address required */
#define EMSGSIZE 90 /* Message too long */
#define EPROTOTYPE 91 /* Protocol wrong type for socket */
#define ENOPROTOOPT 92 /* Protocol not available */
#define EPROTONOSUPPORT 93 /* Protocol not supported */
#define ESOCKTNOSUPPORT 94 /* Socket type not supported */
#define EOPNOTSUPP 95 /* Operation not supported on transport endpoint */
#define EPFNOSUPPORT 96 /* Protocol family not supported */
#define EAFNOSUPPORT 97 /* Address family not supported by protocol */
#define EADDRINUSE 98 /* Address already in use */
#define EADDRNOTAVAIL 99 /* Cannot assign requested address */
#define ENETDOWN 100 /* Network is down */
#define ENETUNREACH 101 /* Network is unreachable */
#define ENETRESET 102 /* Network dropped connection because of reset */
#define ECONNABORTED 103 /* Software caused connection abort */
#define ECONNRESET 104 /* Connection reset by peer */
#define ENOBUFS 105 /* No buffer space available */
#define EISCONN 106 /* Transport endpoint is already connected */
#define ENOTCONN 107 /* Transport endpoint is not connected */
#define ESHUTDOWN 108 /* Cannot send after transport endpoint shutdown */
#define ETOOMANYREFS 109 /* Too many references: cannot splice */
#define ETIMEDOUT 110 /* Connection timed out */
#define ECONNREFUSED 111 /* Connection refused */
#define EHOSTDOWN 112 /* Host is down */
#define EHOSTUNREACH 113 /* No route to host */
#define EALREADY 114 /* Operation already in progress */
#define EINPROGRESS 115 /* Operation now in progress */
#define ESTALE 116 /* Stale NFS file handle */
#define EUCLEAN 117 /* Structure needs cleaning */
#define ENOTNAM 118 /* Not a XENIX named type file */
#define ENAVAIL 119 /* No XENIX semaphores available */
#define EISNAM 120 /* Is a named type file */
#define EREMOTEIO 121 /* Remote I/O error */
#define EDQUOT 122 /* Quota exceeded */
#define ENOMEDIUM 123 /* No medium found */
#define EMEDIUMTYPE 124 /* Wrong medium type */
#define ENSROK 0 /* DNS server returned answer with no data */
#define ENOTSUP 134 /* Not supported */
#define ENSRNODATA 160 /* DNS server returned answer with no data */
#define ENSRFORMERR 161 /* DNS server claims query was misformatted */
#define ENSRSERVFAIL 162 /* DNS server returned general failure */
#define ENSRNOTFOUND 163 /* Domain name not found */
#define ENSRNOTIMP 164 /* DNS server does not implement requested operation */
#define ENSRREFUSED 165 /* DNS server refused query */
#define ENSRBADQUERY 166 /* Misformatted DNS query */
#define ENSRBADNAME 167 /* Misformatted domain name */
#define ENSRBADFAMILY 168 /* Unsupported address family */
#define ENSRBADRESP 169 /* Misformatted DNS reply */
#define ENSRCONNREFUSED 170 /* Could not contact DNS servers */
#define ENSRTIMEOUT 171 /* Timeout while contacting DNS servers */
#define ENSROF 172 /* End of file */
#define ENSRFILE 173 /* Error reading file */
#define ENSRNOMEM 174 /* Out of memory */
#define ENSRDESTRUCTION 175 /* Application terminated lookup */
#define ENSRQUERYDOMAINTOOLONG 176 /* Domain name is too long */
#define ENSRCNAMELOOP 177 /* Domain name is too long */
#endif /* _SYS_ERROR_H */
| YifuLiu/AliOS-Things | components/libc_stub/compilers/iar/sys/errno.h | C | apache-2.0 | 8,447 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef LIBC_FCNTL_H__
#define LIBC_FCNTL_H__
#define O_RDONLY 00
#define O_WRONLY 01
#define O_RDWR 02
#define O_CREAT 0100
#define O_EXCL 0200
#define O_NOCTTY 0400
#define O_TRUNC 01000
#define O_APPEND 02000
#define O_NONBLOCK 04000
#define O_DSYNC 010000
#define O_SYNC 04010000
#define O_RSYNC 04010000
#define O_BINARY 0100000
#define O_DIRECTORY 0200000
#define O_NOFOLLOW 0400000
#define O_CLOEXEC 02000000
#define O_ASYNC 020000
#define O_DIRECT 040000
#define O_LARGEFILE 0100000
#define O_NOATIME 01000000
#define O_PATH 010000000
#define O_TMPFILE 020200000
#define O_NDELAY O_NONBLOCK
#define O_SEARCH O_PATH
#define O_EXEC O_PATH
#define O_ACCMODE (03|O_SEARCH)
#define F_DUPFD 0
#define F_GETFD 1
#define F_SETFD 2
#define F_GETFL 3
#define F_SETFL 4
#define F_SETOWN 8
#define F_GETOWN 9
#define F_SETSIG 10
#define F_GETSIG 11
#define F_GETLK 12
#define F_SETLK 13
#define F_SETLKW 14
#define F_SETOWN_EX 15
#define F_GETOWN_EX 16
#define F_GETOWNER_UIDS 17
#endif
| YifuLiu/AliOS-Things | components/libc_stub/compilers/iar/sys/fcntl.h | C | apache-2.0 | 1,160 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
/* This header file provides the reentrancy. */
/* WARNING: All identifiers here must begin with an underscore. This file is
included by stdio.h and others and we therefore must only use identifiers
in the namespace allotted to us. */
#ifndef _SYS_REENT_H_
#ifdef __cplusplus
extern "C" {
#endif
#define _SYS_REENT_H_
#include <errno.h>
/* This version of _reent is laid out with "int"s in pairs, to help
* ports with 16-bit int's but 32-bit pointers, align nicely. */
struct _reent
{
/* As an exception to the above put _errno first for binary
compatibility with non _REENT_SMALL targets. */
int _errno; /* local copy of errno */
};
#ifdef __cplusplus
}
#endif
#endif /* _SYS_REENT_H_ */
| YifuLiu/AliOS-Things | components/libc_stub/compilers/iar/sys/reent.h | C | apache-2.0 | 784 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef _SYS_SELECT_H__
#define _SYS_SELECT_H__
#ifndef FD_SETSIZE
#define FD_SETSIZE 256
#endif
#define NBBY 8 /* number of bits in a byte */
typedef long fd_mask;
#define NFDBITS (sizeof (fd_mask) * NBBY) /* bits per mask */
#ifndef howmany
#define howmany(x,y) (((x)+((y)-1))/(y))
#endif
/* We use a macro for fd_set so that including Sockets.h afterwards
can work. */
typedef struct _types_fd_set {
fd_mask fds_bits[howmany(FD_SETSIZE, NFDBITS)];
} _types_fd_set;
#define fd_set _types_fd_set
#define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] |= (1L << ((n) % NFDBITS)))
#define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1L << ((n) % NFDBITS)))
#define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1L << ((n) % NFDBITS)))
#define FD_ZERO(p) memset((void*)(p), 0, sizeof(*(p)))
#endif
| YifuLiu/AliOS-Things | components/libc_stub/compilers/iar/sys/select.h | C | apache-2.0 | 875 |
#ifndef _SIGNAL_H_
#define _SIGNAL_H_
#define SIGALRM 14
#endif
// eof
| YifuLiu/AliOS-Things | components/libc_stub/compilers/iar/sys/signal.h | C | apache-2.0 | 75 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef _SYS_STAT_H__
#define _SYS_STAT_H__
#define S_IFMT 00170000
#define S_IFSOCK 0140000
#define S_IFLNK 0120000
#define S_IFREG 0100000
#define S_IFBLK 0060000
#define S_IFDIR 0040000
#define S_IFCHR 0020000
#define S_IFIFO 0010000
#define S_ISUID 0004000
#define S_ISGID 0002000
#define S_ISVTX 0001000
#define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
#define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
#define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
#define S_ISCHR(m) (((m) & S_IFMT) == S_IFCHR)
#define S_ISBLK(m) (((m) & S_IFMT) == S_IFBLK)
#define S_ISFIFO(m) (((m) & S_IFMT) == S_IFIFO)
#define S_ISSOCK(m) (((m) & S_IFMT) == S_IFSOCK)
#define S_IRWXU 00700
#define S_IRUSR 00400
#define S_IWUSR 00200
#define S_IXUSR 00100
#define S_IRWXG 00070
#define S_IRGRP 00040
#define S_IWGRP 00020
#define S_IXGRP 00010
#define S_IRWXO 00007
#define S_IROTH 00004
#define S_IWOTH 00002
#define S_IXOTH 00001
/* stat structure */
#include <stdint.h>
#include <time.h>
struct stat
{
struct rt_device* st_dev;
uint16_t st_mode;
uint32_t st_size;
time_t st_mtime;
uint32_t st_blksize;
};
#endif
| YifuLiu/AliOS-Things | components/libc_stub/compilers/iar/sys/stat.h | C | apache-2.0 | 1,551 |
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef _SYS_TIME_H_
#define _SYS_TIME_H_
#include <time.h>
#include <sys/types.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifndef _TIMEVAL_DEFINED
#define _TIMEVAL_DEFINED
/*
* Structure returned by gettimeofday(2) system call,
* and used in other calls.
*/
struct timeval {
long tv_sec; /* seconds */
long tv_usec; /* and microseconds */
};
#endif /* _TIMEVAL_DEFINED */
#ifndef _TIMESPEC_DEFINED
#define _TIMESPEC_DEFINED
/*
* Structure defined by POSIX.1b to be like a timeval.
*/
struct timespec {
time_t tv_sec; /* seconds */
long tv_nsec; /* and nanoseconds */
};
#endif /* _TIMESPEC_DEFINED */
struct timezone {
int tz_minuteswest; /* minutes west of Greenwich */
int tz_dsttime; /* type of dst correction */
};
int gettimeofday(struct timeval *tp, void *ignore);
#ifdef __cplusplus
}
#endif
#endif /* _SYS_TIME_H_ */
| YifuLiu/AliOS-Things | components/libc_stub/compilers/iar/sys/time.h | C | apache-2.0 | 970 |