zTC1/mico-os/libraries/utilities/json_c/json_util.c

/*
 * $Id: json_util.c,v 1.4 2006/01/30 23:07:57 mclark Exp $
 *
 * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd.
 * Michael Clark <michael@metaparadigm.com>
 *
 * This library is free software; you can redistribute it and/or modify
 * it under the terms of the MIT license. See COPYING for details.
 *
 */

#include "config.h"
#undef realloc

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

#if HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif /* HAVE_SYS_TYPES_H */

#if HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif /* HAVE_SYS_STAT_H */

#if HAVE_FCNTL_H
#include <fcntl.h>
#endif /* HAVE_FCNTL_H */

#if HAVE_UNISTD_H
# include <unistd.h>
#endif /* HAVE_UNISTD_H */

#ifdef WIN32
# define WIN32_LEAN_AND_MEAN
# include <windows.h>
# include <io.h>
#endif /* defined(WIN32) */

#if !HAVE_OPEN && defined(WIN32)
# define open _open
#endif


#include "bits.h"
#include "json_debug.h"
#include "printbuf.h"
#include "json_inttypes.h"
#include "json_object.h"
#include "json_tokener.h"
#include "json_util.h"

// struct json_object* json_object_from_file(const char *filename)
// {
//   struct printbuf *pb;
//   struct json_object *obj;
//   char buf[JSON_FILE_BUF_SIZE];
//   int ret;
//   FILE * fd;

//   if((fd = fopen(filename, "R")) < 0) {
//     MC_ERROR("json_object_from_file: error reading file %s: %s\n",
// 	     filename, strerror(errno));
//     return (struct json_object*)error_ptr(-1);
//   }
//   if(!(pb = printbuf_new())) {
//     fclose(fd);
//     MC_ERROR("json_object_from_file: printbuf_new failed\n");
//     return (struct json_object*)error_ptr(-1);
//   }
//   while((ret = fread(buf,JSON_FILE_BUF_SIZE, sizeof(char), fd)) > 0) {
//   //while((ret = fread(fd, buf, JSON_FILE_BUF_SIZE)) > 0) {
//     printbuf_memappend(pb, buf, ret);
//   }
//   fclose(fd);
//   if(ret < 0) {
//     MC_ABORT("json_object_from_file: error reading file %s: %s\n",
// 	     filename, strerror(errno));
//     printbuf_free(pb);
//     return (struct json_object*)error_ptr(-1);
//   }
//   obj = json_tokener_parse(pb->buf);
//   printbuf_free(pb);
//   return obj;
// }

// int json_object_to_file(char *filename, struct json_object *obj)
// {
//   const char *json_str;
//   int ret;
//   unsigned int wpos, wsize;
//   FILE * fd;

//   if(!obj) {
//     MC_ERROR("json_object_to_file: object is null\n");
//     return -1;
//   }

//   if((fd = fopen(filename, "W")) < 0) {
//     MC_ERROR("json_object_to_file: error opening file %s: %s\n",
// 	     filename, strerror(errno));
//     return -1;
//   }

//   if(!(json_str = json_object_to_json_string(obj))) {
//     fclose(fd);
//     return -1;
//   }

//   wsize = (unsigned int)(strlen(json_str) & UINT_MAX); /* CAW: probably unnecessary, but the most 64bit safe */
//   wpos = 0;
//   while(wpos < wsize) {
//     if((ret = fwrite(json_str + wpos, wsize-wpos, sizeof(char), fd)) < 0) {
// //    if((ret = write(fd, json_str + wpos, wsize-wpos)) < 0) {
//       fclose(fd);
//       MC_ERROR("json_object_to_file: error writing file %s: %s\n",
// 	     filename, strerror(errno));
//       return -1;
//     }

// 	/* because of the above check for ret < 0, we can safely cast and add */
//     wpos += (unsigned int)ret;
//   }

//   fclose(fd);
//   return 0;
// }

int json_parse_int64(const char *buf, int64_t *retval)
{
	int32_t num64;
	if (sscanf(buf, "%ld", &num64) != 1)
	{
		MC_DEBUG("Failed to parse, sscanf != 1\n");
		return 1;
	}
	const char *buf_skip_space = buf;
	int orig_has_neg = 0;
	// Skip leading spaces
	while (isspace((int)*buf_skip_space) && *buf_skip_space)
		buf_skip_space++;
	if (*buf_skip_space == '-')
	{
		buf_skip_space++;
		orig_has_neg = 1;
	}
	// Skip leading zeros, but keep at least one digit
	while (buf_skip_space[0] == '0' && buf_skip_space[1] != '\0')
		buf_skip_space++;
	if (buf_skip_space[0] == '0' && buf_skip_space[1] == '\0')
		orig_has_neg = 0; // "-0" is the same as just plain "0"
	
	if (errno != ERANGE)
	{
		char buf_cmp[100];
		char *buf_cmp_start = buf_cmp;
		int recheck_has_neg = 0;
		snprintf(buf_cmp_start, sizeof(buf_cmp), "%ld", num64);
                
		if (*buf_cmp_start == '-')
		{
			recheck_has_neg = 1;
			buf_cmp_start++;
		}
		// No need to skip leading spaces or zeros here.

		int buf_cmp_len = strlen(buf_cmp_start);
		/**
		 * If the sign is different, or
		 * some of the digits are different, or
		 * there is another digit present in the original string
		 * then we NOT successfully parsed the value.
		 */
		if (orig_has_neg != recheck_has_neg ||
		    strncmp(buf_skip_space, buf_cmp_start, strlen(buf_cmp_start)) != 0 ||
			(strlen(buf_skip_space) != buf_cmp_len &&
			 isdigit((int)buf_skip_space[buf_cmp_len])
		    )
		   )
		{
			errno = ERANGE;
		}
	}
	if (errno == ERANGE)
	{
		if (orig_has_neg)
			num64 = INT32_MIN;
		else
			num64 = INT32_MAX;
	}
	*retval = num64;
	return 0;
}

#if HAVE_REALLOC == 0
void* rpl_realloc(void* p, size_t n)
{
	if (n == 0)
		n = 1;
	if (p == 0)
		return malloc(n);
	return realloc(p, n);
}
#endif

#define NELEM(a)        (sizeof(a) / sizeof(a[0]))
static const char* json_type_name[] = {
  /* If you change this, be sure to update the enum json_type definition too */
  "null",
  "boolean",
  "double",
  "int",
  "object",
  "array",
  "string",
};

const char *json_type_to_name(enum json_type o_type)
{
	if (o_type >= NELEM(json_type_name))
	{
		MC_ERROR("json_type_to_name: type %d is out of range [0,%d]\n", o_type, NELEM(json_type_name));
		return NULL;
	}
	return json_type_name[o_type];
}