json_t *json_loads(const char *string, json_error_t *error)
{
lex_t lex;
json_t *result;
string_data_t stream_data = {
.data = string,
.pos = 0
};
if(lex_init(&lex, string_get, string_eof, (void *)&stream_data))
return NULL;
result = parse_json(&lex, error);
if(!result)
goto out;
lex_scan(&lex, error);
if(lex.token != TOKEN_EOF) {
error_set(error, &lex, "end of file expected");
json_decref(result);
result = NULL;
}
out:
lex_close(&lex);
return result;
}
json_t *json_loadf(FILE *input, json_error_t *error)
{
lex_t lex;
json_t *result;
if(lex_init(&lex, (get_func)fgetc, (eof_func)feof, input))
return NULL;
result = parse_json(&lex, error);
if(!result)
goto out;
lex_scan(&lex, error);
if(lex.token != TOKEN_EOF) {
error_set(error, &lex, "end of file expected");
json_decref(result);
result = NULL;
}
out:
lex_close(&lex);
return result;
}
json_t *json_loadf(FILE *input, size_t flags, json_error_t *error)
{
lex_t lex;
const char *source;
json_t *result;
if(input == stdin)
source = "<stdin>";
else
source = "<stream>";
jsonp_error_init(error, source);
if (input == NULL) {
error_set(error, NULL, "wrong arguments");
return NULL;
}
if(lex_init(&lex, (get_func)fgetc, input))
return NULL;
result = parse_json(&lex, flags, error);
lex_close(&lex);
return result;
}
json_t *json_loadb(const char *buffer, size_t buflen, size_t flags, json_error_t *error)
{
lex_t lex;
json_t *result;
buffer_data_t stream_data;
jsonp_error_init(error, "<buffer>");
if (buffer == NULL) {
error_set(error, NULL, "wrong arguments");
return NULL;
}
stream_data.data = buffer;
stream_data.pos = 0;
stream_data.len = buflen;
if(lex_init(&lex, buffer_get, (void *)&stream_data))
return NULL;
result = parse_json(&lex, flags, error);
lex_close(&lex);
return result;
}
json_t *json_load_callback(json_load_callback_t callback, void *arg, size_t flags, json_error_t *error)
{
lex_t lex;
json_t *result;
callback_data_t stream_data;
memset(&stream_data, 0, sizeof(stream_data));
stream_data.callback = callback;
stream_data.arg = arg;
jsonp_error_init(error, "<callback>");
if (callback == NULL) {
error_set(error, NULL, "wrong arguments");
return NULL;
}
if(lex_init(&lex, (get_func)callback_get, &stream_data))
return NULL;
result = parse_json(&lex, flags, error);
lex_close(&lex);
return result;
}
json_t *json_loadf(FILE *input, size_t flags, json_error_t *error)
{
lex_t lex;
const char *source;
json_t *result;
(void)flags; /* unused */
if(lex_init(&lex, (get_func)fgetc, input))
return NULL;
if(input == stdin)
source = "<stdin>";
else
source = "<stream>";
jsonp_error_init(error, source);
result = parse_json(&lex, error);
if(!result)
goto out;
lex_scan(&lex, error);
if(lex.token != TOKEN_EOF) {
error_set(error, &lex, "end of file expected");
json_decref(result);
result = NULL;
}
out:
lex_close(&lex);
return result;
}
json_t *json_loads(const char *string, size_t flags, json_error_t *error)
{
lex_t lex;
json_t *result;
string_data_t stream_data = {string, 0};
(void)flags; /* unused */
if(lex_init(&lex, string_get, (void *)&stream_data))
return NULL;
jsonp_error_init(error, "<string>");
result = parse_json(&lex, error);
if(!result)
goto out;
lex_scan(&lex, error);
if(lex.token != TOKEN_EOF) {
error_set(error, &lex, "end of file expected");
json_decref(result);
result = NULL;
}
out:
lex_close(&lex);
return result;
}
json_t *json_loads(const char *string, json_error_t *error)
{
lex_t lex;
json_t *result;
string_data_t stream_data = {
/*.data = */string,
/*.pos = */0
};
if(lex_init(&lex, string_get, string_eof, (void *)&stream_data))
return NULL;
result = parse_json(&lex, error);
if(!result)
goto out;
lex_scan(&lex, error);
if(lex.token != TOKEN_EOF) {
error_set(error, &lex, "end of file expected");
json_decref(result);
result = NULL;
}
out:
lex_close(&lex);
return result;
}
static struct FILE_INFO *
_drop_stack_do(
struct FILE_INFO * head
)
{
struct FILE_INFO * tail;
while (NULL != head) {
tail = head->st_next;
lex_close(head);
head = tail;
}
return head;
}
/* Pop, close & free the top of the include stack, unless the stack
* contains only a singleton input object. In that case the function
* fails, because the parser does not expect the input stack to be
* empty.
*
* Returns TRUE if an object was successfuly popped from the stack.
*/
int/*BOOL*/
lex_pop_file(void)
{
struct FILE_INFO * head = lex_stack;
struct FILE_INFO * tail = NULL;
if (NULL != head) {
tail = head->st_next;
if (NULL != tail) {
lex_stack = tail;
lex_close(head);
}
}
return (NULL != tail);
}
/*------------------------------------------------------------------------- * Function: lex_close * * Purpose: Closes a lexer input file. * * Return: Success: NULL * * Failure: NULL * * Programmer: Robb Matzke * [email protected] * Dec 10 1996 * * Modifications: * Robb Matzke, 2000-07-10 * Modified to work with stack input items. *------------------------------------------------------------------------- */ lex_t * lex_close(lex_t *f) { int i; assert(f); if (f==LEX_STDIN) LEX_STDIN=NULL; if (f->f) fclose(f->f); if (f->s) free(f->s); for (i=0; i<f->nstack; i++) lex_close(f->stack[i]); memset(f, 0, sizeof(lex_t)); free(f); return NULL; }
json_t *json_loadf(FILE *input, json_error_t *error)
{
lex_t lex;
json_t *result;
if(lex_init(&lex, (get_func)fgetc, (eof_func)feof, input))
return NULL;
result = parse_json(&lex, error);
if(!result)
goto out;
lex_scan(&lex, error);
if(lex.token != TOKEN_EOF) {
error_set(error, &lex, "end of file expected");
json_decref(result);
result = NULL;
}
out:
lex_close(&lex);
return result;
}
json_ref json_loads(const char *string, size_t flags, json_error_t *error)
{
lex_t lex;
string_data_t stream_data;
jsonp_error_init(error, "<string>");
if (string == nullptr) {
error_set(error, nullptr, "wrong arguments");
return nullptr;
}
stream_data.data = string;
stream_data.pos = 0;
if(lex_init(&lex, string_get, (void *)&stream_data))
return nullptr;
auto result = parse_json(&lex, flags, error);
lex_close(&lex);
return result;
}
/*------------------------------------------------------------------------- * Function: lex_getc * * Purpose: Similar to getc(3) except uses the GNU readline library * and issues prompts as necessary. * * Return: Success: Next character * * Failure: EOF * * Programmer: Robb Matzke * [email protected] * Dec 10 1996 * * Modifications: * Robb Matzke, 29 Jul 1997 * If the line-feed is escaped with a backslash, then the backslash * and line-feed are both ignored. * * Jeremy Meredith, Thu Aug 26 09:59:44 PDT 1999 * Changed use of strdup() to safe_strdup(). * * Robb Matzke, 2000-07-10 * Modified to work with stacked input streams. *------------------------------------------------------------------------- */ int lex_getc(lex_t *f) { int c=EOF; #ifdef HAVE_READLINE_HISTORY static char buf[1024]; #endif if (f->s) { c = f->s[f->at++]; if (!f->s[f->at]) { free(f->s); f->s = NULL; f->at = 0; } } else if (f->f && isatty(fileno(f->f))) { /* Input is from the standard input stream. Use readline() to * get it and add it to the history if different than the * previous line. */ #if defined(HAVE_READLINE_READLINE_H) && defined(HAVE_LIBREADLINE) char *temp = readline(f->prompt); if (temp) { f->s = malloc(strlen(temp)+2); strcpy(f->s, temp); strcat(f->s, "\n"); } #else char temp[4096]; fputs(f->prompt, stdout); if (fgets(temp, sizeof(temp), f->f)) { f->s = safe_strdup(temp); } else { f->s = NULL; } #endif f->at = 0; #if defined(HAVE_READLINE_READLINE_H) && defined(HAVE_READLINE_HISTORY) if (f->s && f->s[0] && strncmp(buf, f->s, sizeof(buf))) { add_history(f->s); strncpy(buf, f->s, sizeof(buf)); } #endif c = (f->s ? lex_getc(f) : EOF); } else if (f->f) { /* Input is from a non-interactive stream. */ c = getc(f->f); } else if (f->nstack) { while (f->nstack && EOF==(c=lex_getc(f->stack[f->nstack-1]))) { lex_close(f->stack[f->nstack-1]); f->stack[--f->nstack] = NULL; } return c; } else { return EOF; } /* If this character is a backslash and the following character * is a line-feed, then ignore both of them and return the following * character instead. This allows us to always continue a line by * escaping the line-feed. */ if ('\\'==c) { int peek = lex_getc(f); if ('\n'!=peek) lex_ungetc(f, peek); else c = lex_getc(f); } return c; }
