pax_global_header00006660000000000000000000000064126705614160014522gustar00rootroot0000000000000052 comment=8f550d6c21d2baff595e7bf535f1c1d1701fbb82 jo-1.0/000077500000000000000000000000001267056141600117725ustar00rootroot00000000000000jo-1.0/.gitignore000066400000000000000000000005701267056141600137640ustar00rootroot00000000000000*.dSYM .DS_Store *.o *.so *.la *.lai *.so.* # Autotools junk .libs .deps .dirstamp libtool *.log stamp-h1 config.log config.status autom4te.cache INSTALL Makefile jo-*.tar.gz configure aclocal.m4 Makefile.in version.h config.cache m4/libtool.m4 m4/ltoptions.m4 m4/ltsugar.m4 m4/ltversion.m4 m4/lt~obsolete.m4 *.trs install-sh depcomp missing build-aux/ tests/jo.07.sh jo g jo-1.0/AUTHORS000066400000000000000000000000411267056141600130350ustar00rootroot00000000000000Jan-Piet Mens jo-1.0/COPYING000066400000000000000000000037401267056141600130310ustar00rootroot00000000000000/* * Copyright (C) 2016 Jan-Piet Mens * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #-------------------------------------------------------------------- json.[ch] /* Copyright (C) 2011 Joseph A. Adams (joeyadams3.14159@gmail.com) All rights reserved. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ jo-1.0/ChangeLog000066400000000000000000000017101267056141600135430ustar00rootroot00000000000000 2016-03-11 1.0 - NEW: read JSON element values from files (#22) - FIX: usage diagnostic - NEW: add support for OpenBSD pledge(2) (#21) 2016-03-10 0.9 - UPD: revert support for $JO_PRETTY et. al; it was a bad idea 2016-03-10 0.8 - UPD: new test suite - NEW: support for nested elements (#19) - NEW: if $JO_PRETTY is set, jo will always pretty-print - NEW: Define $JO_SPACER to any desired number of spaces or tabs for pretty-printing (#18) 2016-03-09 0.7 - NEW: strings "true"/"false" now default to booleans; avoid with -B (#17) - FIX: test.sh get quotes to prevent failures with pdksh (#16) - FIX: pretty-print Version if requested (#15) - FIX: Add cast to suppress warning when compiling with GCC 4.8.4 (#14) 2016-03-08 0.6 - FIX: make build work on CentOS 6 (#13) - NEW: JSONy version with -V 2016-03-08 0.5 - FIX: fileno error (#12) 2016-03-08 0.4 - NEW: Win32 support for CJK contributed by @mattn 2016-03-08 0.3 - NEW: autotools support - NEW: option -v jo-1.0/Makefile.am000066400000000000000000000020041267056141600140220ustar00rootroot00000000000000 AM_CFLAGS = -Wall -O2 bin_PROGRAMS = jo jo_SOURCES = jo.c json.c json.h base64.c base64.h jo_EXTRA = jo.pandoc dist_man_MANS = jo.1 jo_LDADD = -lm if USE_PANDOC # Add targets to rebuild pages jo.1: jo.pandoc @test -n "$(PANDOC)" || \ { echo 'pandoc' not found during configure.; exit 1; } $(PANDOC) -s -w man -o $@ $< jo.md: jo.pandoc @test -n "$(PANDOC)" || \ { echo 'pandoc' not found during configure.; exit 1; } $(PANDOC) -s -w markdown -o $@ $< endif # docdir = $(datadir)/doc/@PACKAGE@ # doc_DATA = README.md TEST_LOG_DRIVER = env AM_TAP_AWK='$(AWK)' $(SHELL) \ $(top_srcdir)/build-aux/tap-driver.sh TESTS = tests/jo.test EXTRA_DIST = $(jo_EXTRA) \ $(TESTS) \ tests/jo.01.sh tests/jo.01.exp \ tests/jo.02.sh tests/jo.02.exp \ tests/jo.03.sh tests/jo.03.exp \ tests/jo.04.sh tests/jo.04.exp \ tests/jo.05.sh tests/jo.05.exp \ tests/jo.06.sh tests/jo.06.exp \ tests/jo.07.sh.in \ tests/jo.08.sh tests/jo.08.exp \ tests/jo.09.sh tests/jo.09.exp jo-1.0/NEWS000066400000000000000000000000001267056141600124570ustar00rootroot00000000000000jo-1.0/README000077700000000000000000000000001267056141600141242README.mdustar00rootroot00000000000000jo-1.0/README.md000066400000000000000000000022751267056141600132570ustar00rootroot00000000000000# jo ![jo logo](jo-logo.png) This is `jo`, a small utility to create JSON objects ```bash $ jo -p name=jo n=17 parser=false { "name": "jo", "n": 17, "parser": false } ``` or arrays ```bash $ seq 1 10 | jo -a [1,2,3,4,5,6,7,8,9,10] ``` It has a [manual](jo.md), and you can read [why I wrote jo](http://jpmens.net/2016/03/05/a-shell-command-to-create-json-jo/). ## Build from Github To install from the repository, you will need a C compiler as well as a relatively recent version of _automake_ and _autoconf_. ```bash git clone git://github.com/jpmens/jo.git cd jo autoreconf -i ./configure make check make install ``` ## Build from Release tarball To build from [a release](https://github.com/jpmens/jo/releases) you will need a C compiler to install from a source tarball. ```bash tar xvzf jo-0.?.tar.gz cd jo-0.? ./configure make check make install ``` ## Homebrew To install with Homebrew, use [the tap](https://github.com/caius/homebrew-jo). ```bash brew tap caius/jo brew install jo ``` ## Others * [voidlinux](https://github.com/voidlinux/void-packages/tree/master/srcpkgs/jo) * [ArchLinux](https://aur.archlinux.org/packages/jo/) * [OpenBSD](http://openports.se/textproc/jo) jo-1.0/base64.c000066400000000000000000000044761267056141600132350ustar00rootroot00000000000000/* This code is public domain software. */ #include "base64.h" #include #include // base64 encoding // // buf: binary input data // size: size of input (bytes) // return: base64-encoded string (null-terminated) // memory for output will be allocated here, free it later // char* base64_encode(const void* buf, size_t size) { static const char base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; char* str = (char*) malloc((size+3)*4/3 + 1); char* p = str; const unsigned char* q = (const unsigned char*) buf; size_t i = 0; while (i < size) { int c = q[i++]; c *= 256; if (i < size) c += q[i]; i++; c *= 256; if (i < size) c += q[i]; i++; *p++ = base64[(c & 0x00fc0000) >> 18]; *p++ = base64[(c & 0x0003f000) >> 12]; if (i > size + 1) *p++ = '='; else *p++ = base64[(c & 0x00000fc0) >> 6]; if (i > size) *p++ = '='; else *p++ = base64[c & 0x0000003f]; } *p = 0; return str; } // single base64 character conversion // static int POS(char c) { if (c>='A' && c<='Z') return c - 'A'; if (c>='a' && c<='z') return c - 'a' + 26; if (c>='0' && c<='9') return c - '0' + 52; if (c == '+') return 62; if (c == '/') return 63; if (c == '=') return -1; return -2; } // base64 decoding // // s: base64 string, must be null-terminated // data: output buffer for decoded data // data_len size of decoded data // return: allocated data buffer // void* base64_decode(const char* s, size_t *data_len) { const char *p; unsigned char *q, *data; int n[4] = { 0, 0, 0, 0 }; size_t len = strlen(s); if (len % 4) return NULL; data = (unsigned char*) malloc(len/4*3); q = (unsigned char*) data; for (p = s; *p; ) { n[0] = POS(*p++); n[1] = POS(*p++); n[2] = POS(*p++); n[3] = POS(*p++); if (n[0] == -2 || n[1] == -2 || n[2] == -2 || n[3] == -2) return NULL; if (n[0] == -1 || n[1] == -1) return NULL; if (n[2] == -1 && n[3] != -1) return NULL; q[0] = (n[0] << 2) + (n[1] >> 4); if (n[2] != -1) q[1] = ((n[1] & 15) << 4) + (n[2] >> 2); if (n[3] != -1) q[2] = ((n[2] & 3) << 6) + n[3]; q += 3; } *data_len = q-data - (n[2]==-1) - (n[3]==-1); return data; } jo-1.0/base64.h000066400000000000000000000002651267056141600132320ustar00rootroot00000000000000#ifndef BASE64_H_GUARD #define BASE64_H_GUARD #include char* base64_encode(const void* buf, size_t size); void* base64_decode(const char* s, size_t *data_len); #endif jo-1.0/configure.ac000066400000000000000000000022151267056141600142600ustar00rootroot00000000000000AC_PREREQ([2.69]) AC_INIT([jo], [1.0], [jpmens@gmail.com]) AC_CONFIG_AUX_DIR([build-aux]) AC_CONFIG_SRCDIR([jo.c]) # Checks for programs. AC_PROG_CC # Checks for header files. AC_USE_SYSTEM_EXTENSIONS AC_CHECK_HEADERS([stddef.h stdint.h stdlib.h string.h unistd.h stdbool.h]) # Checks for library functions. AC_FUNC_MALLOC AC_FUNC_REALLOC AC_FUNC_STRTOD AC_CHECK_FUNCS([strchr strrchr strlcpy strlcat snprintf pledge err errx]) AM_INIT_AUTOMAKE([foreign -Wall]) AM_SILENT_RULES([yes]) AC_REQUIRE_AUX_FILE([tap-driver.sh]) AC_ARG_VAR(PANDOC, [pandoc path]) AC_PATH_PROG(PANDOC, [pandoc], []) if test -z "$PANDOC" then AC_MSG_WARN([pandoc not found, man pages rebuild will not be possible]) fi AM_CONDITIONAL([USE_PANDOC], [test -n "$PANDOC"]) AC_CONFIG_FILES([Makefile tests/jo.07.sh]) AC_OUTPUT echo " Jo.............: version $PACKAGE_VERSION Prefix.........: $prefix C compiler.....: $CC $CFLAGS $CPPFLAGS Pandoc.........: ${PANDOC:-NONE} Now type 'make @<:@@:>@' where the optional is: all - build all binaries check - run the tests install - install everything " jo-1.0/jo-logo.png000066400000000000000000000176221267056141600140560ustar00rootroot00000000000000PNG  IHDR,,y}usRGBLIDATx \E}2d/$d@@!`)rTrE DA q *k&Ȓ >I&dzҙ:}Oי~yt9TթS%B Y1Ν!ȎqSRMMU/PaႥnuQGN(HU:f>fu?v<'U1T to: A `eq1be=! *BzN̂ Y@7,߸ C! &8X>7P@~+: O/kd#:zl\q^QD `B@?c*Xt Me00!`P" ` 7` `B2D@ n@eB8,+܀ ˄q + XV#  %@V@pF@&,Jā `YL X&XA @L(e00!`P" ` 7` `B2D@ n@eB8,+܀ ˄q + XV#  %@V@pF@&,Jā `YL X&XA @L(e00!`P" ` 7` `B2D@ n@eB8,+܀ ˄q + XV#  %@V@pF@&,Jā `YL X&XA @L(e00!`P" ` 7` `B2D@ n@eB8,+܀ ˄q + XV#  %@V@pF@&,Jā `YL X&XA @L(e00!`P" ` 7` `B2D@ n@eB8,+܀ ˄q + XV#  %@V@pF@&,Jā `YL X&XA @L(e00!`P" ` 7` `B2D@ n@eB8,+܀ ˄q + XV#  %@V@pF@&,Jā `YL X&XA @L(e00!`P" ` 7` `B2D@ n@eB8,+܀ ˄q + XV#  %@V@pF@&,Jā `YL X&XA @L(e00!c8سYNrFݫ*J]Ƃo>LX( 901_t&ysu}J;WV:52CCoԯcR\t"X@XZAZZN|m,}qP\i'nihNu۳5f,i\:Ugv{n 0)!y&QUt<{ef: W.::ѢU.)֥nύ+w}m@?,QH|䩔"g^']ھ%7'gRn -_.ߗG޹UP&$fؗMqNb`G=!`Y o i/-ǿ#Fm,( 9P&onHưRSJeꤢ%Tu [ݭ7b-:n/2Ne 䕮8f!;"c!/'K1"_뛫䩗} tZ)Y8bu׭GT ݱU #>;vX~ =UR#{+{=\Yft:G ]ת~),P\%Xs?Waؙ/Ax$m] Ϗ[ ##~TGE Ǐ70?[n_TYƄQY` A5mL<1Tɠ}K;O3tX?a[ e2~9KgGt!U+ wnuJO"oã**1:G6vxdG 'Jpzvz,&Ej5̻|>k5j.5q"W9Tpw)cg #u I5lC;3l'mFtՊ`e,2IdW!=yz_3j9,O ɶ]>"G ;TkW;?9./Thٷ':5wDG,u?qakj9q0[CuM$sգAQ@gvHe VG:[NŹmWS"r&Ew1zPz+e'B}MM,?"::;z󑚃uuO}.b&1\_Eu7 |F|CiQ \I?`uӄY}Cj)mlK+Y#j]յ)P.zl\V5\(o^A򇟬rku5wz(jwHJ@|tߪfd^z&K{nu)m< X31%.~F~DCOӏ&8s" j.!s$u@46&}Gʤǎ/x0")MFYyj2Իj ~ɲř}bGVs7z~>t6nuՅ}OFȅ-3z^jrqrڠaŢo`jy\LKH[$ѡOn"yoiUR3"VyK/+}Y7z͎]~2Po\.LD~|syiTUMh3M6JOkulW:,;++VoXiyzB70eN [NuLˀ7jꝫyG[Md9 StU"wzzM>%_:eOyn1oŕ4o 9l8ޅj$MzG Cz+ճXb8^ANw֭Z&Skכx6q͟,-VW2rFg,5B1x,V;8 }x+߭s4ײכjz>85+)47Wkg;E?el=^q2L;+.E9A=ln7jeNc&ee A ?'=ϭ/w?3hm(1CsѴ`K3D,ufR++X [U\-v>mp6@k; 2ae^˒|rCzF>2q G%+/+gT',8V3'*Z:ލ#]04 slV.+ul9l;M?D^|`T{%*ղzF&df 7xcDdxB?)眔9QJ cӎwds"?w,w|c*A* K|姂,?y˥;ECs8t7pL1,k- ,\?;ۿF~ဝ&`Fַ]VQF)/yC1,o86^\`SAVAH(KVh}MMkmwKCWlxzO9Sχ6 7!R{9,H=ZX)d\*zqxXmHݸK>G?C8ҶS}/&c)؜XN)٪wgd֝[,'qę'+913/uasSf3:lO/8WpNBO[zU?}X k+u++O cayL#`eǩ/|L0F4S_ca:2i1td+v6]oZY$q5e/oK<R5M]Y]"3f,RvɴvK̜^f֗g!@|>\팣 /3֨§{\G#dh5/?/[yPj !w+d^ *MηOѓYfV003X][O׫ϜN#6?"_ع\#Z>X zѣȼ/ӏ+G.yku4+,`7nֹwedf Q>6ڸnUjsǟ- 5KD;Pnj9qrq|e:YēM;u-%i{h}R+.B-VwX; ]TF5dju5QCbKU++꽭?r+Vow?>tS h(ܷx7c7V5/^R TP_JۯO\nS콰2#@ +1n֧҂]G 7}=szY)*zl٢AF;ZZ6 G+ ]?m /SwuqΠ[Iܸ\542<y3$8/@}lntVpOox+l1ۛ$ ֒ ˄ C5Uqp(T5# 7}8*+ʆ֨K?}A$P%)'FT+ol$GtP1aCư+Gw]-~iq|69ٽW  \Yp- gg/ d6?yM8;SxdRy=;͍2-? ?[&Rغs.Ks7o _`\r?ѽ}ѭdBybzLܷZXR좮 _}~ti?)M'#SJ5aoQ-=`x ZM_;E;~\="ͻS jneZ%ٲ*޲`.Y=_VV8[x]{oLyi |/l&>-UqAvEš_wYs2eqj=ZdB;a[r'-z@\t׷%EyޡuRUN,R5B gG'=!VO-Q/=j]dɔ'7\qzU׭# q:TŅxUV{*t*L} Uk|_~KuRQ;d3>J>Zd4?!e?j$L +)A-jZwtW' ڧ1xgIJZFu3]F5J:@*(鳊 `yA9e1!ʨYRleNydc#zOsdj] p qMr Ηfrw*˙߁|f"= xJ7An Xn)n @#- )S!`GZ@S) pCrC,OqS i!O X0@  =B@"} $\ jo\ filename=AUTHORS\ content=%AUTHORS {"filename":"AUTHORS","content":"SmFuLVBpZXQgTWVucyA8anBtZW5zQGdtYWlsLmNvbT4K"} \f[] .fi .SH OPTIONS .PP \f[I]jo\f[] understands the following options. .TP .B \-a Interpret the list of \f[I]words\f[] as array values and produce an array instead of an object. .RS .RE .TP .B \-B By default \f[I]jo\f[] interprets the strings "\f[C]true\f[]" and "\f[C]false\f[]" as boolean elements \f[C]true\f[] and \f[C]false\f[] respectively. Disable with this option. .RS .RE .TP .B \-p Pretty\-print the JSON string on output instead of the terse one\-line output it prints by default. .RS .RE .TP .B \-v Show version and exit. .RS .RE .TP .B \-V Show version as a JSON object and exit. .RS .RE .SH BUGS .PP Probably. .PP If a value given to \f[I]jo\f[] expands to empty in the shell, then \f[I]jo\f[] produces a \f[C]null\f[] in object mode, and might appear to hang in array mode; it is not hanging, rather it\[aq]s reading \f[I]stdin\f[]. This is not a bug. .PP Numeric values are converted to numbers which can produce undesired results. If you quote a numeric value, \f[I]jo\f[] will make it a string. Compare the following: .IP .nf \f[C] $\ jo\ a=1.0 {"a":1} $\ jo\ a=\\"1.0\\" {"a":"1.0"} \f[] .fi .PP Omitting a closing bracket on a nested element causes a diagnostic message to print, but the output contains garbage anyway. This was designed thusly. .SH RETURN CODES .PP \f[I]jo\f[] exits with a code 0 on success and non\-zero on failure after indicating what caused the failure. .SH AVAILABILITY .PP .SH CREDITS .IP \[bu] 2 This program uses \f[C]json.[ch]\f[], by Joseph A. Adams. .SH SEE ALSO .IP \[bu] 2 .IP \[bu] 2 .IP \[bu] 2 strtod(3) .SH AUTHOR .PP Jan\-Piet Mens jo-1.0/jo.c000066400000000000000000000277531267056141600125640ustar00rootroot00000000000000#include #include #include #include #include #include #include #include #ifndef WIN32 # include #endif #include "json.h" #include "base64.h" /* * Copyright (C) 2016 Jan-Piet Mens * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #define SPACER " " #define FLAG_ARRAY 0x01 #define FLAG_PRETTY 0x02 #define FLAG_NOBOOL 0x04 #define FLAG_BOOLEAN 0x08 static JsonNode *pile; /* pile of nested objects/arrays */ #ifdef _WIN32 # define err(n, s) { fprintf(stderr, s); exit(n); } # define errx(n, f, a) { fprintf(stderr, f, a); exit(n); } # define fseeko fseek # define ftello ftell #endif void json_copy_to_object(JsonNode * obj, JsonNode * object_or_array, int clobber) { JsonNode *node; if (obj->tag != JSON_OBJECT && obj->tag != JSON_ARRAY) return; json_foreach(node, object_or_array) { if (!clobber & (json_find_member(obj, node->key) != NULL)) continue; /* Don't clobber existing keys */ if (obj->tag == JSON_OBJECT) { if (node->tag == JSON_STRING) json_append_member(obj, node->key, json_mkstring(node->string_)); else if (node->tag == JSON_NUMBER) json_append_member(obj, node->key, json_mknumber(node->number_)); else if (node->tag == JSON_BOOL) json_append_member(obj, node->key, json_mkbool(node->bool_)); else if (node->tag == JSON_NULL) json_append_member(obj, node->key, json_mknull()); else fprintf(stderr, "PANIC: unhandled JSON type %d\n", node->tag); } else if (obj->tag == JSON_ARRAY) { if (node->tag == JSON_STRING) json_append_element(obj, json_mkstring(node->string_)); if (node->tag == JSON_NUMBER) json_append_element(obj, json_mknumber(node->number_)); if (node->tag == JSON_BOOL) json_append_element(obj, json_mkbool(node->bool_)); if (node->tag == JSON_NULL) json_append_element(obj, json_mknull()); } } } char *slurp_file(FILE *fp, off_t *len, bool fold_newlines) { char *buf, *bp; int ch; if (fseeko(fp, 0, SEEK_END) != 0) { fclose(fp); return (NULL); } *len = ftello(fp); fseeko(fp, 0, SEEK_SET); if ((bp = buf = malloc(*len + 1)) == NULL) { fclose(fp); return (NULL); } while ((ch = fgetc(fp)) != EOF) { if (ch == '\n') { if (!fold_newlines) *bp++ = ch; } else *bp++ = ch; } *bp = 0; return (buf); } /* * Attempt to "sniff" the type of data in `str' and return * a JsonNode of the correct JSON type. */ JsonNode *vnode(char *str, int flags) { if (strlen(str) == 0) { return json_mknull(); } /* If str begins with a double quote, keep it a string */ if (*str == '"') { char *bp = str + strlen(str) - 1; if (bp > str && *bp == '"') *bp = 0; /* Chop closing double quote */ return json_mkstring(str + 1); } char *endptr; double num = strtod(str, &endptr); if (!*endptr && isfinite(num)) { return json_mknumber(num); } if (!(flags & FLAG_NOBOOL)) { if (strcmp(str, "true") == 0) { return json_mkbool(true); } else if (strcmp(str, "false") == 0) { return json_mkbool(false); } } if (*str == '@' || *str == '%') { char *filename = str + 1, *content; bool binmode = (*str == '%'); off_t len = 0; JsonNode *j; FILE *fp; if ((fp = fopen(filename, binmode ? "rb" : "r")) == NULL) { errx(1, "Cannot open %s for reading", filename); } if ((content = slurp_file(fp, &len, false)) == NULL) { errx(1, "Error reading file %s", filename); } fclose(fp); if (binmode) { char *encoded; if ((encoded = base64_encode(content, len)) == NULL) { errx(1, "Cannot base64-encode file %s", filename); } j = json_mkstring(encoded); free(encoded); } else { char *bp = content + strlen(content) - 1; if (*bp == '\n') *bp-- = 0; if (*bp == '\r') *bp = 0; j = json_mkstring(content); } free(content); return (j); } if (*str == '{' || *str == '[') { JsonNode *obj = json_decode(str); if (obj == NULL) { /* JSON cannot be decoded; return the string */ // fprintf(stderr, "Cannot decode JSON from %s\n", str); obj = json_mkstring(str); } return (obj); } return json_mkstring(str); } /* * Attempt to sniff `str' into a boolean; return a * corresponding JsonNode for it. */ JsonNode *boolnode(char *str) { if (strlen(str) == 0) { return json_mknull(); } if (tolower((unsigned char) *str) == 't') { return json_mkbool(1); } return json_mkbool(atoi(str)); } int usage(char *prog) { fprintf(stderr, "Usage: %s [-a] [-B] [-p] [-v] [-V] [word...]\n", prog); fprintf(stderr, "\tword is key=value or key@value\n"); fprintf(stderr, "\t-a creates an array of words\n"); fprintf(stderr, "\t-B disable boolean true/false\n"); fprintf(stderr, "\t-p pretty-prints JSON on output\n"); fprintf(stderr, "\t-v show version\n"); fprintf(stderr, "\t-V show version in JSON\n"); return (-1); } /* * Check whether we're being given nested arrays or objects. * `kv' contains the "key" such as "number" or "point[]" or * "geo[lat]". `value' the actual value for that element. */ bool nested(int flags, char *key, char *value) { char *member = NULL, *bo, *bc; /* bracket open, close */ JsonNode *op; int found = false; /* Check for geo[] or geo[lat] */ if ((bo = strchr(key, '[')) != NULL) { if (*(bo+1) == ']') { *bo = 0; } else if ((bc = strchr(bo + 1, ']')) == NULL) { fprintf(stderr, "missing closing bracket on %s\n", key); return (-1); } else { *bo = *bc = 0; member = bo + 1; } /* * key is now `geo' for both `geo[]` and `geo[lat]` * member is null for the former and "lat" for the latter. * Find an existing object in the pile for this member name * or create a new one if we don't have it. */ if ((op = json_find_member(pile, key)) != NULL) { found = true; } else { op = (member == NULL) ? json_mkarray() : json_mkobject(); } if (member == NULL) { /* we're doing an array */ if (flags & FLAG_BOOLEAN) { json_append_element(op, boolnode(value)); } else { json_append_element(op, vnode(value, flags)); } } else { /* we're doing an object */ if (flags & FLAG_BOOLEAN) { json_append_member(op, member, boolnode(value)); } else { json_append_member(op, member, vnode(value, flags)); } } if (!found) { json_append_member(pile, key, op); } return (true); } return (false); } int member_to_object(JsonNode *object, int flags, char *kv) { /* we expect key=value or key:value (boolean on last) */ char *p = strchr(kv, '='); char *q = strchr(kv, '@'); if (!p && !q) { return (-1); } if (p) { *p = 0; if (nested(flags, kv, p+1)) return (0); json_append_member(object, kv, vnode(p+1, flags)); } else { *q = 0; if (nested(flags | FLAG_BOOLEAN, kv, q+1)) return (0); json_append_member(object, kv, boolnode(q+1)); } return (0); } /* * Append kv to the array or object. */ void append_kv(JsonNode *object_or_array, int flags, char *kv) { if (flags & FLAG_ARRAY) { json_append_element(object_or_array, vnode(kv, flags)); } else { if (member_to_object(object_or_array, flags, kv) == -1) { fprintf(stderr, "Argument `%s' is neither k=v nor k@v\n", kv); } } } #ifdef _WIN32 #include char* utf8_from_locale(const char *str, size_t len) { wchar_t* wcsp; char* mbsp; size_t mbssize, wcssize; if (len == 0) { return strdup(""); } if (len == -1) { len = strlen(str); } wcssize = MultiByteToWideChar(GetACP(), 0, str, len, NULL, 0); wcsp = (wchar_t*) malloc((wcssize + 1) * sizeof(wchar_t)); if (!wcsp) { return NULL; } wcssize = MultiByteToWideChar(GetACP(), 0, str, len, wcsp, wcssize + 1); wcsp[wcssize] = 0; mbssize = WideCharToMultiByte(CP_UTF8, 0, (LPCWSTR) wcsp, -1, NULL, 0, NULL, NULL); mbsp = (char*) malloc((mbssize + 1)); if (!mbsp) { free(wcsp); return NULL; } mbssize = WideCharToMultiByte(CP_UTF8, 0, (LPCWSTR) wcsp, -1, mbsp, mbssize, NULL, NULL); mbsp[mbssize] = 0; free(wcsp); return mbsp; } # define utf8_free(p) free(p) char* locale_from_utf8(const char *utf8, size_t len) { wchar_t* wcsp; char* mbsp; size_t mbssize, wcssize; if (len == 0) { return strdup(""); } if (len == -1) { len = strlen(utf8); } wcssize = MultiByteToWideChar(CP_UTF8, 0, utf8, len, NULL, 0); wcsp = (wchar_t*) malloc((wcssize + 1) * sizeof(wchar_t)); if (!wcsp) { return NULL; } wcssize = MultiByteToWideChar(CP_UTF8, 0, utf8, len, wcsp, wcssize + 1); wcsp[wcssize] = 0; mbssize = WideCharToMultiByte(GetACP(), 0, (LPCWSTR) wcsp, -1, NULL, 0, NULL, NULL); mbsp = (char*) malloc((mbssize + 1)); if (!mbsp) { free(wcsp); return NULL; } mbssize = WideCharToMultiByte(GetACP(), 0, (LPCWSTR) wcsp, -1, mbsp, mbssize, NULL, NULL); mbsp[mbssize] = 0; free(wcsp); return mbsp; } # define locale_free(p) free(p) #else # define utf8_from_locale(p, l) (p) # define utf8_free(p) # define locale_from_utf8(p, l) (p) # define locale_free(p) #endif char *stringify(JsonNode *json, int flags) { int pretty = flags & FLAG_PRETTY; return json_stringify(json, (pretty) ? SPACER : NULL); } int version(int flags) { JsonNode *json = json_mkobject(); char *js; json_append_member(json, "program", json_mkstring("jo")); json_append_member(json, "author", json_mkstring("Jan-Piet Mens")); json_append_member(json, "repo", json_mkstring("https://github.com/jpmens/jo")); json_append_member(json, "version", json_mkstring(PACKAGE_VERSION)); if ((js = stringify(json, flags)) != NULL) { printf("%s\n", js); free(js); } json_delete(json); return (0); } int main(int argc, char **argv) { int c; bool showversion = false; char *kv, *js_string, *progname, buf[BUFSIZ], *p; int ttyin = isatty(fileno(stdin)), ttyout = isatty(fileno(stdout)); int flags = 0; JsonNode *json, *op; #if HAVE_PLEDGE if (pledge("stdio rpath", NULL) == -1) { err(1, "pledge"); } #endif progname = (progname = strrchr(*argv, '/')) ? progname + 1 : *argv; while ((c = getopt(argc, argv, "aBhpvV")) != EOF) { switch (c) { case 'a': flags |= FLAG_ARRAY; break; case 'B': flags |= FLAG_NOBOOL; break; case 'h': usage(progname); return (0); case 'p': flags |= FLAG_PRETTY; break; case 'v': printf("jo %s\n", PACKAGE_VERSION); exit(0); case 'V': showversion = true; break; default: exit(usage(progname)); } } if (showversion) { return(version(flags)); } argc -= optind; argv += optind; pile = json_mkobject(); json = (flags & FLAG_ARRAY) ? json_mkarray() : json_mkobject(); if (argc == 0) { while (fgets(buf, sizeof(buf), stdin) != NULL) { if (buf[strlen(buf) - 1] == '\n') buf[strlen(buf) - 1] = 0; p = ttyin ? utf8_from_locale(buf, -1) : buf; append_kv(json, flags, p); if (ttyin) utf8_free(p); } } else { while ((kv = *argv++)) { p = utf8_from_locale(kv, -1); append_kv(json, flags, p); utf8_free(p); } } /* * See if we have any nested objects or arrays in the pile, * and copy these into our main object if so. */ json_foreach(op, pile) { JsonNode *o; if (op->tag == JSON_ARRAY) { o = json_mkarray(); } else if (op->tag == JSON_OBJECT) { o = json_mkobject(); } else { continue; } json_copy_to_object(o, op, 0); json_append_member(json, op->key, o); } if ((js_string = stringify(json, flags)) == NULL) { fprintf(stderr, "Invalid JSON\n"); exit(2); } p = ttyout ? locale_from_utf8(js_string, -1) : js_string; printf("%s\n", p); if (ttyout) locale_free(p); free(js_string); json_delete(json); json_delete(pile); return (0); } jo-1.0/jo.md000066400000000000000000000106071267056141600127300ustar00rootroot00000000000000NAME ==== jo - JSON output from a shell SYNOPSIS ======== jo [-p] [-a] [-B] [-v] [-V] [word ...] DESCRIPTION =========== *jo* creates a JSON string on *stdout* from *word*s given it as arguments or read from *stdin*. Without option `-a` it generates an object whereby each *word* is a `key=value` (or `key@value`) pair with *key* being the JSON object element and *value* its value. *jo* attempts to guess the type of *value* in order to create number (using *strtod(3)*), string, or null values in JSON. *jo* treats `key@value` specifically as boolean JSON elements: if the value begins with `T`, `t`, or the numeric value is greater than zero, the result is `true`, else `false`. A missing or empty value behind the colon results in a `null` JSON element. *jo* creates an array instead of an object when `-a` is specified. EXAMPLES ======== Create an object. Note how the incorrectly-formatted float value becomes a string: $ jo tst=1457081292 lat=12.3456 cc=FR badfloat=3.14159.26 name="JP Mens" nada= coffee@T {"tst":1457081292,"lat":12.3456,"cc":"FR","badfloat":"3.14159.26","name":"JP Mens","nada":null,"coffee":true} Pretty-print an array with a list of files in the current directory: $ jo -p -a * [ "Makefile", "README.md", "jo.1", "jo.c", "jo.pandoc", "json.c", "json.h" ] Create objects within objects; this works because if the first character of value is an open brace or a bracket we attempt to decode the remainder as JSON. Beware spaces in strings ... $ jo -p name=JP object=$(jo fruit=Orange hungry@0 point=$(jo x=10 y=20 list=$(jo -a 1 2 3 4 5)) number=17) sunday@0 { "name": "JP", "object": { "fruit": "Orange", "hungry": false, "point": { "x": 10, "y": 20, "list": [ 1, 2, 3, 4, 5 ] }, "number": 17 }, "sunday": false } Booleans as strings or as boolean (pay particular attention to *switch*; the `-B` option disables the default detection of the "`true`" and "`false`" strings): $ jo switch=true morning@0 {"switch":true,"morning":false} $ jo -B switch=true morning@0 {"switch":"true","morning":false} Elements (objects and arrays) can be nested. The following example nests an array called *point* and an object named *geo*: $ jo -p name=Jane point[]=1 point[]=2 geo[lat]=10 geo[lon]=20 { "name": "Jane", "point": [ 1, 2 ], "geo": { "lat": 10, "lon": 20 } } Read element values from files: a value which starts with `@` is read in plain whereas if it begins with a `%` it will be base64-encoded: $ jo program=jo authors=@AUTHORS {"program":"jo","authors":"Jan-Piet Mens "} $ jo filename=AUTHORS content=%AUTHORS {"filename":"AUTHORS","content":"SmFuLVBpZXQgTWVucyA8anBtZW5zQGdtYWlsLmNvbT4K"} OPTIONS ======= *jo* understands the following options. -a : Interpret the list of *words* as array values and produce an array instead of an object. -B : By default *jo* interprets the strings "`true`" and "`false`" as boolean elements `true` and `false` respectively. Disable with this option. -p : Pretty-print the JSON string on output instead of the terse one-line output it prints by default. -v : Show version and exit. -V : Show version as a JSON object and exit. BUGS ==== Probably. If a value given to *jo* expands to empty in the shell, then *jo* produces a `null` in object mode, and might appear to hang in array mode; it is not hanging, rather it's reading *stdin*. This is not a bug. Numeric values are converted to numbers which can produce undesired results. If you quote a numeric value, *jo* will make it a string. Compare the following: $ jo a=1.0 {"a":1} $ jo a=\"1.0\" {"a":"1.0"} Omitting a closing bracket on a nested element causes a diagnostic message to print, but the output contains garbage anyway. This was designed thusly. RETURN CODES ============ *jo* exits with a code 0 on success and non-zero on failure after indicating what caused the failure. AVAILABILITY ============ CREDITS ======= - This program uses `json.[ch]`, by Joseph A. Adams. SEE ALSO ======== - - - strtod(3) AUTHOR ====== Jan-Piet Mens jo-1.0/jo.pandoc000066400000000000000000000102331267056141600135670ustar00rootroot00000000000000% JO(1) User Manuals # NAME jo - JSON output from a shell # SYNOPSIS jo [-p] [-a] [-B] [-v] [-V] [word ...] # DESCRIPTION *jo* creates a JSON string on _stdout_ from _word_s given it as arguments or read from _stdin_. Without option `-a` it generates an object whereby each _word_ is a `key=value` (or `key@value`) pair with _key_ being the JSON object element and _value_ its value. *jo* attempts to guess the type of _value_ in order to create number (using _strtod(3)_), string, or null values in JSON. *jo* treats `key@value` specifically as boolean JSON elements: if the value begins with `T`, `t`, or the numeric value is greater than zero, the result is `true`, else `false`. A missing or empty value behind the colon results in a `null` JSON element. *jo* creates an array instead of an object when `-a` is specified. # EXAMPLES Create an object. Note how the incorrectly-formatted float value becomes a string: $ jo tst=1457081292 lat=12.3456 cc=FR badfloat=3.14159.26 name="JP Mens" nada= coffee@T {"tst":1457081292,"lat":12.3456,"cc":"FR","badfloat":"3.14159.26","name":"JP Mens","nada":null,"coffee":true} Pretty-print an array with a list of files in the current directory: $ jo -p -a * [ "Makefile", "README.md", "jo.1", "jo.c", "jo.pandoc", "json.c", "json.h" ] Create objects within objects; this works because if the first character of value is an open brace or a bracket we attempt to decode the remainder as JSON. Beware spaces in strings ... $ jo -p name=JP object=$(jo fruit=Orange hungry@0 point=$(jo x=10 y=20 list=$(jo -a 1 2 3 4 5)) number=17) sunday@0 { "name": "JP", "object": { "fruit": "Orange", "hungry": false, "point": { "x": 10, "y": 20, "list": [ 1, 2, 3, 4, 5 ] }, "number": 17 }, "sunday": false } Booleans as strings or as boolean (pay particular attention to _switch_; the `-B` option disables the default detection of the "`true`" and "`false`" strings): $ jo switch=true morning@0 {"switch":true,"morning":false} $ jo -B switch=true morning@0 {"switch":"true","morning":false} Elements (objects and arrays) can be nested. The following example nests an array called _point_ and an object named _geo_: $ jo -p name=Jane point[]=1 point[]=2 geo[lat]=10 geo[lon]=20 { "name": "Jane", "point": [ 1, 2 ], "geo": { "lat": 10, "lon": 20 } } Read element values from files: a value which starts with `@` is read in plain whereas if it begins with a `%` it will be base64-encoded: $ jo program=jo authors=@AUTHORS {"program":"jo","authors":"Jan-Piet Mens "} $ jo filename=AUTHORS content=%AUTHORS {"filename":"AUTHORS","content":"SmFuLVBpZXQgTWVucyA8anBtZW5zQGdtYWlsLmNvbT4K"} # OPTIONS *jo* understands the following options. -a : Interpret the list of _words_ as array values and produce an array instead of an object. -B : By default *jo* interprets the strings "`true`" and "`false`" as boolean elements `true` and `false` respectively. Disable with this option. -p : Pretty-print the JSON string on output instead of the terse one-line output it prints by default. -v : Show version and exit. -V : Show version as a JSON object and exit. # BUGS Probably. If a value given to *jo* expands to empty in the shell, then *jo* produces a `null` in object mode, and might appear to hang in array mode; it is not hanging, rather it's reading _stdin_. This is not a bug. Numeric values are converted to numbers which can produce undesired results. If you quote a numeric value, *jo* will make it a string. Compare the following: $ jo a=1.0 {"a":1} $ jo a=\"1.0\" {"a":"1.0"} Omitting a closing bracket on a nested element causes a diagnostic message to print, but the output contains garbage anyway. This was designed thusly. # RETURN CODES *jo* exits with a code 0 on success and non-zero on failure after indicating what caused the failure. # AVAILABILITY # CREDITS * This program uses `json.[ch]`, by Joseph A. Adams. # SEE ALSO * * * strtod(3) # AUTHOR Jan-Piet Mens jo-1.0/json.c000066400000000000000000000714271267056141600131220ustar00rootroot00000000000000/* Copyright (C) 2011 Joseph A. Adams (joeyadams3.14159@gmail.com) All rights reserved. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #include "json.h" #include #include #include #include #include #define out_of_memory() do { \ fprintf(stderr, "Out of memory.\n"); \ exit(EXIT_FAILURE); \ } while (0) /* Sadly, strdup is not portable. */ static char *json_strdup(const char *str) { size_t n = strlen(str) + 1; char *ret = (char*) malloc(n); if (ret == NULL) out_of_memory(); #if HAVE_STRLCPY strlcpy(ret, str, n); #else strcpy(ret, str); #endif return ret; } /* String buffer */ typedef struct { char *cur; char *end; char *start; } SB; static void sb_init(SB *sb) { sb->start = (char*) malloc(17); if (sb->start == NULL) out_of_memory(); sb->cur = sb->start; sb->end = sb->start + 16; } /* sb and need may be evaluated multiple times. */ #define sb_need(sb, need) do { \ if ((sb)->end - (sb)->cur < (need)) \ sb_grow(sb, need); \ } while (0) static void sb_grow(SB *sb, int need) { size_t length = sb->cur - sb->start; size_t alloc = sb->end - sb->start; do { alloc *= 2; } while (alloc < length + need); sb->start = (char*) realloc(sb->start, alloc + 1); if (sb->start == NULL) out_of_memory(); sb->cur = sb->start + length; sb->end = sb->start + alloc; } static void sb_put(SB *sb, const char *bytes, int count) { sb_need(sb, count); memcpy(sb->cur, bytes, count); sb->cur += count; } #define sb_putc(sb, c) do { \ if ((sb)->cur >= (sb)->end) \ sb_grow(sb, 1); \ *(sb)->cur++ = (c); \ } while (0) static void sb_puts(SB *sb, const char *str) { sb_put(sb, str, strlen(str)); } static char *sb_finish(SB *sb) { *sb->cur = 0; assert(sb->start <= sb->cur && strlen(sb->start) == (size_t)(sb->cur - sb->start)); return sb->start; } static void sb_free(SB *sb) { free(sb->start); } /* * Unicode helper functions * * These are taken from the ccan/charset module and customized a bit. * Putting them here means the compiler can (choose to) inline them, * and it keeps ccan/json from having a dependency. */ /* * Type for Unicode codepoints. * We need our own because wchar_t might be 16 bits. */ typedef uint32_t uchar_t; /* * Validate a single UTF-8 character starting at @s. * The string must be null-terminated. * * If it's valid, return its length (1 thru 4). * If it's invalid or clipped, return 0. * * This function implements the syntax given in RFC3629, which is * the same as that given in The Unicode Standard, Version 6.0. * * It has the following properties: * * * All codepoints U+0000..U+10FFFF may be encoded, * except for U+D800..U+DFFF, which are reserved * for UTF-16 surrogate pair encoding. * * UTF-8 byte sequences longer than 4 bytes are not permitted, * as they exceed the range of Unicode. * * The sixty-six Unicode "non-characters" are permitted * (namely, U+FDD0..U+FDEF, U+xxFFFE, and U+xxFFFF). */ static int utf8_validate_cz(const char *s) { unsigned char c = *s++; if (c <= 0x7F) { /* 00..7F */ return 1; } else if (c <= 0xC1) { /* 80..C1 */ /* Disallow overlong 2-byte sequence. */ return 0; } else if (c <= 0xDF) { /* C2..DF */ /* Make sure subsequent byte is in the range 0x80..0xBF. */ if (((unsigned char)*s++ & 0xC0) != 0x80) return 0; return 2; } else if (c <= 0xEF) { /* E0..EF */ /* Disallow overlong 3-byte sequence. */ if (c == 0xE0 && (unsigned char)*s < 0xA0) return 0; /* Disallow U+D800..U+DFFF. */ if (c == 0xED && (unsigned char)*s > 0x9F) return 0; /* Make sure subsequent bytes are in the range 0x80..0xBF. */ if (((unsigned char)*s++ & 0xC0) != 0x80) return 0; if (((unsigned char)*s++ & 0xC0) != 0x80) return 0; return 3; } else if (c <= 0xF4) { /* F0..F4 */ /* Disallow overlong 4-byte sequence. */ if (c == 0xF0 && (unsigned char)*s < 0x90) return 0; /* Disallow codepoints beyond U+10FFFF. */ if (c == 0xF4 && (unsigned char)*s > 0x8F) return 0; /* Make sure subsequent bytes are in the range 0x80..0xBF. */ if (((unsigned char)*s++ & 0xC0) != 0x80) return 0; if (((unsigned char)*s++ & 0xC0) != 0x80) return 0; if (((unsigned char)*s++ & 0xC0) != 0x80) return 0; return 4; } else { /* F5..FF */ return 0; } } /* Validate a null-terminated UTF-8 string. */ static bool utf8_validate(const char *s) { int len; for (; *s != 0; s += len) { len = utf8_validate_cz(s); if (len == 0) return false; } return true; } /* * Read a single UTF-8 character starting at @s, * returning the length, in bytes, of the character read. * * This function assumes input is valid UTF-8, * and that there are enough characters in front of @s. */ static int utf8_read_char(const char *s, uchar_t *out) { const unsigned char *c = (const unsigned char*) s; assert(utf8_validate_cz(s)); if (c[0] <= 0x7F) { /* 00..7F */ *out = c[0]; return 1; } else if (c[0] <= 0xDF) { /* C2..DF (unless input is invalid) */ *out = ((uchar_t)c[0] & 0x1F) << 6 | ((uchar_t)c[1] & 0x3F); return 2; } else if (c[0] <= 0xEF) { /* E0..EF */ *out = ((uchar_t)c[0] & 0xF) << 12 | ((uchar_t)c[1] & 0x3F) << 6 | ((uchar_t)c[2] & 0x3F); return 3; } else { /* F0..F4 (unless input is invalid) */ *out = ((uchar_t)c[0] & 0x7) << 18 | ((uchar_t)c[1] & 0x3F) << 12 | ((uchar_t)c[2] & 0x3F) << 6 | ((uchar_t)c[3] & 0x3F); return 4; } } /* * Write a single UTF-8 character to @s, * returning the length, in bytes, of the character written. * * @unicode must be U+0000..U+10FFFF, but not U+D800..U+DFFF. * * This function will write up to 4 bytes to @out. */ static int utf8_write_char(uchar_t unicode, char *out) { unsigned char *o = (unsigned char*) out; assert(unicode <= 0x10FFFF && !(unicode >= 0xD800 && unicode <= 0xDFFF)); if (unicode <= 0x7F) { /* U+0000..U+007F */ *o++ = unicode; return 1; } else if (unicode <= 0x7FF) { /* U+0080..U+07FF */ *o++ = 0xC0 | unicode >> 6; *o++ = 0x80 | (unicode & 0x3F); return 2; } else if (unicode <= 0xFFFF) { /* U+0800..U+FFFF */ *o++ = 0xE0 | unicode >> 12; *o++ = 0x80 | (unicode >> 6 & 0x3F); *o++ = 0x80 | (unicode & 0x3F); return 3; } else { /* U+10000..U+10FFFF */ *o++ = 0xF0 | unicode >> 18; *o++ = 0x80 | (unicode >> 12 & 0x3F); *o++ = 0x80 | (unicode >> 6 & 0x3F); *o++ = 0x80 | (unicode & 0x3F); return 4; } } /* * Compute the Unicode codepoint of a UTF-16 surrogate pair. * * @uc should be 0xD800..0xDBFF, and @lc should be 0xDC00..0xDFFF. * If they aren't, this function returns false. */ static bool from_surrogate_pair(uint16_t uc, uint16_t lc, uchar_t *unicode) { if (uc >= 0xD800 && uc <= 0xDBFF && lc >= 0xDC00 && lc <= 0xDFFF) { *unicode = 0x10000 + ((((uchar_t)uc & 0x3FF) << 10) | (lc & 0x3FF)); return true; } else { return false; } } /* * Construct a UTF-16 surrogate pair given a Unicode codepoint. * * @unicode must be U+10000..U+10FFFF. */ static void to_surrogate_pair(uchar_t unicode, uint16_t *uc, uint16_t *lc) { uchar_t n; assert(unicode >= 0x10000 && unicode <= 0x10FFFF); n = unicode - 0x10000; *uc = ((n >> 10) & 0x3FF) | 0xD800; *lc = (n & 0x3FF) | 0xDC00; } #define is_space(c) ((c) == '\t' || (c) == '\n' || (c) == '\r' || (c) == ' ') #define is_digit(c) ((c) >= '0' && (c) <= '9') static bool parse_value (const char **sp, JsonNode **out); static bool parse_string (const char **sp, char **out); static bool parse_number (const char **sp, double *out); static bool parse_array (const char **sp, JsonNode **out); static bool parse_object (const char **sp, JsonNode **out); static bool parse_hex16 (const char **sp, uint16_t *out); static bool expect_literal (const char **sp, const char *str); static void skip_space (const char **sp); static void emit_value (SB *out, const JsonNode *node); static void emit_value_indented (SB *out, const JsonNode *node, const char *space, int indent_level); static void emit_string (SB *out, const char *str); static void emit_number (SB *out, double num); static void emit_array (SB *out, const JsonNode *array); static void emit_array_indented (SB *out, const JsonNode *array, const char *space, int indent_level); static void emit_object (SB *out, const JsonNode *object); static void emit_object_indented (SB *out, const JsonNode *object, const char *space, int indent_level); static int write_hex16(char *out, uint16_t val); static JsonNode *mknode(JsonTag tag); static void append_node(JsonNode *parent, JsonNode *child); static void prepend_node(JsonNode *parent, JsonNode *child); static void append_member(JsonNode *object, char *key, JsonNode *value); /* Assertion-friendly validity checks */ static bool tag_is_valid(unsigned int tag); static bool number_is_valid(const char *num); JsonNode *json_decode(const char *json) { const char *s = json; JsonNode *ret; skip_space(&s); if (!parse_value(&s, &ret)) return NULL; skip_space(&s); if (*s != 0) { json_delete(ret); return NULL; } return ret; } char *json_encode(const JsonNode *node) { return json_stringify(node, NULL); } char *json_encode_string(const char *str) { SB sb; sb_init(&sb); emit_string(&sb, str); return sb_finish(&sb); } char *json_stringify(const JsonNode *node, const char *space) { SB sb; sb_init(&sb); if (space != NULL) emit_value_indented(&sb, node, space, 0); else emit_value(&sb, node); return sb_finish(&sb); } void json_delete(JsonNode *node) { if (node != NULL) { json_remove_from_parent(node); switch (node->tag) { case JSON_STRING: free(node->string_); break; case JSON_ARRAY: case JSON_OBJECT: { JsonNode *child, *next; for (child = node->children.head; child != NULL; child = next) { next = child->next; json_delete(child); } break; } default:; } free(node); } } bool json_validate(const char *json) { const char *s = json; skip_space(&s); if (!parse_value(&s, NULL)) return false; skip_space(&s); if (*s != 0) return false; return true; } JsonNode *json_find_element(JsonNode *array, int index) { JsonNode *element; int i = 0; if (array == NULL || array->tag != JSON_ARRAY) return NULL; json_foreach(element, array) { if (i == index) return element; i++; } return NULL; } JsonNode *json_find_member(JsonNode *object, const char *name) { JsonNode *member; if (object == NULL || object->tag != JSON_OBJECT) return NULL; json_foreach(member, object) if (strcmp(member->key, name) == 0) return member; return NULL; } JsonNode *json_first_child(const JsonNode *node) { if (node != NULL && (node->tag == JSON_ARRAY || node->tag == JSON_OBJECT)) return node->children.head; return NULL; } static JsonNode *mknode(JsonTag tag) { JsonNode *ret = (JsonNode*) calloc(1, sizeof(JsonNode)); if (ret == NULL) out_of_memory(); ret->tag = tag; return ret; } JsonNode *json_mknull(void) { return mknode(JSON_NULL); } JsonNode *json_mkbool(bool b) { JsonNode *ret = mknode(JSON_BOOL); ret->bool_ = b; return ret; } static JsonNode *mkstring(char *s) { JsonNode *ret = mknode(JSON_STRING); ret->string_ = s; return ret; } JsonNode *json_mkstring(const char *s) { return mkstring(json_strdup(s)); } JsonNode *json_mknumber(double n) { JsonNode *node = mknode(JSON_NUMBER); node->number_ = n; return node; } JsonNode *json_mkarray(void) { return mknode(JSON_ARRAY); } JsonNode *json_mkobject(void) { return mknode(JSON_OBJECT); } static void append_node(JsonNode *parent, JsonNode *child) { child->parent = parent; child->prev = parent->children.tail; child->next = NULL; if (parent->children.tail != NULL) parent->children.tail->next = child; else parent->children.head = child; parent->children.tail = child; } static void prepend_node(JsonNode *parent, JsonNode *child) { child->parent = parent; child->prev = NULL; child->next = parent->children.head; if (parent->children.head != NULL) parent->children.head->prev = child; else parent->children.tail = child; parent->children.head = child; } static void append_member(JsonNode *object, char *key, JsonNode *value) { value->key = key; append_node(object, value); } void json_append_element(JsonNode *array, JsonNode *element) { assert(array->tag == JSON_ARRAY); assert(element->parent == NULL); append_node(array, element); } void json_prepend_element(JsonNode *array, JsonNode *element) { assert(array->tag == JSON_ARRAY); assert(element->parent == NULL); prepend_node(array, element); } void json_append_member(JsonNode *object, const char *key, JsonNode *value) { assert(object->tag == JSON_OBJECT); assert(value->parent == NULL); append_member(object, json_strdup(key), value); } void json_prepend_member(JsonNode *object, const char *key, JsonNode *value) { assert(object->tag == JSON_OBJECT); assert(value->parent == NULL); value->key = json_strdup(key); prepend_node(object, value); } void json_remove_from_parent(JsonNode *node) { JsonNode *parent = node->parent; if (parent != NULL) { if (node->prev != NULL) node->prev->next = node->next; else parent->children.head = node->next; if (node->next != NULL) node->next->prev = node->prev; else parent->children.tail = node->prev; free(node->key); node->parent = NULL; node->prev = node->next = NULL; node->key = NULL; } } static bool parse_value(const char **sp, JsonNode **out) { const char *s = *sp; switch (*s) { case 'n': if (expect_literal(&s, "null")) { if (out) *out = json_mknull(); *sp = s; return true; } return false; case 'f': if (expect_literal(&s, "false")) { if (out) *out = json_mkbool(false); *sp = s; return true; } return false; case 't': if (expect_literal(&s, "true")) { if (out) *out = json_mkbool(true); *sp = s; return true; } return false; case '"': { char *str; if (parse_string(&s, out ? &str : NULL)) { if (out) *out = mkstring(str); *sp = s; return true; } return false; } case '[': if (parse_array(&s, out)) { *sp = s; return true; } return false; case '{': if (parse_object(&s, out)) { *sp = s; return true; } return false; default: { double num; if (parse_number(&s, out ? &num : NULL)) { if (out) *out = json_mknumber(num); *sp = s; return true; } return false; } } } static bool parse_array(const char **sp, JsonNode **out) { const char *s = *sp; JsonNode *ret = out ? json_mkarray() : NULL; JsonNode *element; if (*s++ != '[') goto failure; skip_space(&s); if (*s == ']') { s++; goto success; } for (;;) { if (!parse_value(&s, out ? &element : NULL)) goto failure; skip_space(&s); if (out) json_append_element(ret, element); if (*s == ']') { s++; goto success; } if (*s++ != ',') goto failure; skip_space(&s); } success: *sp = s; if (out) *out = ret; return true; failure: json_delete(ret); return false; } static bool parse_object(const char **sp, JsonNode **out) { const char *s = *sp; JsonNode *ret = out ? json_mkobject() : NULL; char *key; JsonNode *value; if (*s++ != '{') goto failure; skip_space(&s); if (*s == '}') { s++; goto success; } for (;;) { if (!parse_string(&s, out ? &key : NULL)) goto failure; skip_space(&s); if (*s++ != ':') goto failure_free_key; skip_space(&s); if (!parse_value(&s, out ? &value : NULL)) goto failure_free_key; skip_space(&s); if (out) append_member(ret, key, value); if (*s == '}') { s++; goto success; } if (*s++ != ',') goto failure; skip_space(&s); } success: *sp = s; if (out) *out = ret; return true; failure_free_key: if (out) free(key); failure: json_delete(ret); return false; } bool parse_string(const char **sp, char **out) { const char *s = *sp; SB sb; char throwaway_buffer[4]; /* enough space for a UTF-8 character */ char *b; if (*s++ != '"') return false; if (out) { sb_init(&sb); sb_need(&sb, 4); b = sb.cur; } else { b = throwaway_buffer; } while (*s != '"') { unsigned char c = *s++; /* Parse next character, and write it to b. */ if (c == '\\') { c = *s++; switch (c) { case '"': case '\\': case '/': *b++ = c; break; case 'b': *b++ = '\b'; break; case 'f': *b++ = '\f'; break; case 'n': *b++ = '\n'; break; case 'r': *b++ = '\r'; break; case 't': *b++ = '\t'; break; case 'u': { uint16_t uc, lc; uchar_t unicode; if (!parse_hex16(&s, &uc)) goto failed; if (uc >= 0xD800 && uc <= 0xDFFF) { /* Handle UTF-16 surrogate pair. */ if (*s++ != '\\' || *s++ != 'u' || !parse_hex16(&s, &lc)) goto failed; /* Incomplete surrogate pair. */ if (!from_surrogate_pair(uc, lc, &unicode)) goto failed; /* Invalid surrogate pair. */ } else if (uc == 0) { /* Disallow "\u0000". */ goto failed; } else { unicode = uc; } b += utf8_write_char(unicode, b); break; } default: /* Invalid escape */ goto failed; } } else if (c <= 0x1F) { /* Control characters are not allowed in string literals. */ goto failed; } else { /* Validate and echo a UTF-8 character. */ int len; s--; len = utf8_validate_cz(s); if (len == 0) goto failed; /* Invalid UTF-8 character. */ while (len--) *b++ = *s++; } /* * Update sb to know about the new bytes, * and set up b to write another character. */ if (out) { sb.cur = b; sb_need(&sb, 4); b = sb.cur; } else { b = throwaway_buffer; } } s++; if (out) *out = sb_finish(&sb); *sp = s; return true; failed: if (out) sb_free(&sb); return false; } /* * The JSON spec says that a number shall follow this precise pattern * (spaces and quotes added for readability): * '-'? (0 | [1-9][0-9]*) ('.' [0-9]+)? ([Ee] [+-]? [0-9]+)? * * However, some JSON parsers are more liberal. For instance, PHP accepts * '.5' and '1.'. JSON.parse accepts '+3'. * * This function takes the strict approach. */ bool parse_number(const char **sp, double *out) { const char *s = *sp; /* '-'? */ if (*s == '-') s++; /* (0 | [1-9][0-9]*) */ if (*s == '0') { s++; } else { if (!is_digit(*s)) return false; do { s++; } while (is_digit(*s)); } /* ('.' [0-9]+)? */ if (*s == '.') { s++; if (!is_digit(*s)) return false; do { s++; } while (is_digit(*s)); } /* ([Ee] [+-]? [0-9]+)? */ if (*s == 'E' || *s == 'e') { s++; if (*s == '+' || *s == '-') s++; if (!is_digit(*s)) return false; do { s++; } while (is_digit(*s)); } if (out) *out = strtod(*sp, NULL); *sp = s; return true; } static void skip_space(const char **sp) { const char *s = *sp; while (is_space(*s)) s++; *sp = s; } static void emit_value(SB *out, const JsonNode *node) { assert(tag_is_valid(node->tag)); switch (node->tag) { case JSON_NULL: sb_puts(out, "null"); break; case JSON_BOOL: sb_puts(out, node->bool_ ? "true" : "false"); break; case JSON_STRING: emit_string(out, node->string_); break; case JSON_NUMBER: emit_number(out, node->number_); break; case JSON_ARRAY: emit_array(out, node); break; case JSON_OBJECT: emit_object(out, node); break; default: assert(false); } } void emit_value_indented(SB *out, const JsonNode *node, const char *space, int indent_level) { assert(tag_is_valid(node->tag)); switch (node->tag) { case JSON_NULL: sb_puts(out, "null"); break; case JSON_BOOL: sb_puts(out, node->bool_ ? "true" : "false"); break; case JSON_STRING: emit_string(out, node->string_); break; case JSON_NUMBER: emit_number(out, node->number_); break; case JSON_ARRAY: emit_array_indented(out, node, space, indent_level); break; case JSON_OBJECT: emit_object_indented(out, node, space, indent_level); break; default: assert(false); } } static void emit_array(SB *out, const JsonNode *array) { const JsonNode *element; sb_putc(out, '['); json_foreach(element, array) { emit_value(out, element); if (element->next != NULL) sb_putc(out, ','); } sb_putc(out, ']'); } static void emit_array_indented(SB *out, const JsonNode *array, const char *space, int indent_level) { const JsonNode *element = array->children.head; int i; if (element == NULL) { sb_puts(out, "[]"); return; } sb_puts(out, "[\n"); while (element != NULL) { for (i = 0; i < indent_level + 1; i++) sb_puts(out, space); emit_value_indented(out, element, space, indent_level + 1); element = element->next; sb_puts(out, element != NULL ? ",\n" : "\n"); } for (i = 0; i < indent_level; i++) sb_puts(out, space); sb_putc(out, ']'); } static void emit_object(SB *out, const JsonNode *object) { const JsonNode *member; sb_putc(out, '{'); json_foreach(member, object) { emit_string(out, member->key); sb_putc(out, ':'); emit_value(out, member); if (member->next != NULL) sb_putc(out, ','); } sb_putc(out, '}'); } static void emit_object_indented(SB *out, const JsonNode *object, const char *space, int indent_level) { const JsonNode *member = object->children.head; int i; if (member == NULL) { sb_puts(out, "{}"); return; } sb_puts(out, "{\n"); while (member != NULL) { for (i = 0; i < indent_level + 1; i++) sb_puts(out, space); emit_string(out, member->key); sb_puts(out, ": "); emit_value_indented(out, member, space, indent_level + 1); member = member->next; sb_puts(out, member != NULL ? ",\n" : "\n"); } for (i = 0; i < indent_level; i++) sb_puts(out, space); sb_putc(out, '}'); } void emit_string(SB *out, const char *str) { bool escape_unicode = false; const char *s = str; char *b; assert(utf8_validate(str)); /* * 14 bytes is enough space to write up to two * \uXXXX escapes and two quotation marks. */ sb_need(out, 14); b = out->cur; *b++ = '"'; while (*s != 0) { unsigned char c = *s++; /* Encode the next character, and write it to b. */ switch (c) { case '"': *b++ = '\\'; *b++ = '"'; break; case '\\': *b++ = '\\'; *b++ = '\\'; break; case '\b': *b++ = '\\'; *b++ = 'b'; break; case '\f': *b++ = '\\'; *b++ = 'f'; break; case '\n': *b++ = '\\'; *b++ = 'n'; break; case '\r': *b++ = '\\'; *b++ = 'r'; break; case '\t': *b++ = '\\'; *b++ = 't'; break; default: { int len; s--; len = utf8_validate_cz(s); if (len == 0) { /* * Handle invalid UTF-8 character gracefully in production * by writing a replacement character (U+FFFD) * and skipping a single byte. * * This should never happen when assertions are enabled * due to the assertion at the beginning of this function. */ assert(false); if (escape_unicode) { #if HAVE_STRLCPY strlcpy(b, "\\uFFFD", out->end - out->start ); #else strcpy(b, "\\uFFFD"); #endif b += 6; } else { *b++ = 0xEF; *b++ = 0xBF; *b++ = 0xBD; } s++; } else if (c < 0x1F || (c >= 0x80 && escape_unicode)) { /* Encode using \u.... */ uint32_t unicode; s += utf8_read_char(s, &unicode); if (unicode <= 0xFFFF) { *b++ = '\\'; *b++ = 'u'; b += write_hex16(b, unicode); } else { /* Produce a surrogate pair. */ uint16_t uc, lc; assert(unicode <= 0x10FFFF); to_surrogate_pair(unicode, &uc, &lc); *b++ = '\\'; *b++ = 'u'; b += write_hex16(b, uc); *b++ = '\\'; *b++ = 'u'; b += write_hex16(b, lc); } } else { /* Write the character directly. */ while (len--) *b++ = *s++; } break; } } /* * Update *out to know about the new bytes, * and set up b to write another encoded character. */ out->cur = b; sb_need(out, 14); b = out->cur; } *b++ = '"'; out->cur = b; } static void emit_number(SB *out, double num) { /* * This isn't exactly how JavaScript renders numbers, * but it should produce valid JSON for reasonable numbers * preserve precision well enough, and avoid some oddities * like 0.3 -> 0.299999999999999988898 . */ char buf[64]; snprintf(buf, sizeof(buf), "%.16g", num); if (number_is_valid(buf)) sb_puts(out, buf); else sb_puts(out, "null"); } static bool tag_is_valid(unsigned int tag) { return (/* tag >= JSON_NULL && */ tag <= JSON_OBJECT); } static bool number_is_valid(const char *num) { return (parse_number(&num, NULL) && *num == '\0'); } static bool expect_literal(const char **sp, const char *str) { const char *s = *sp; while (*str != '\0') if (*s++ != *str++) return false; *sp = s; return true; } /* * Parses exactly 4 hex characters (capital or lowercase). * Fails if any input chars are not [0-9A-Fa-f]. */ static bool parse_hex16(const char **sp, uint16_t *out) { const char *s = *sp; uint16_t ret = 0; uint16_t i; uint16_t tmp; char c; for (i = 0; i < 4; i++) { c = *s++; if (c >= '0' && c <= '9') tmp = c - '0'; else if (c >= 'A' && c <= 'F') tmp = c - 'A' + 10; else if (c >= 'a' && c <= 'f') tmp = c - 'a' + 10; else return false; ret <<= 4; ret += tmp; } if (out) *out = ret; *sp = s; return true; } /* * Encodes a 16-bit number into hexadecimal, * writing exactly 4 hex chars. */ static int write_hex16(char *out, uint16_t val) { const char *hex = "0123456789ABCDEF"; *out++ = hex[(val >> 12) & 0xF]; *out++ = hex[(val >> 8) & 0xF]; *out++ = hex[(val >> 4) & 0xF]; *out++ = hex[ val & 0xF]; return 4; } bool json_check(const JsonNode *node, char errmsg[256]) { #define problem(...) do { \ if (errmsg != NULL) \ snprintf(errmsg, 256, __VA_ARGS__); \ return false; \ } while (0) if (node->key != NULL && !utf8_validate(node->key)) problem("key contains invalid UTF-8"); if (!tag_is_valid(node->tag)) problem("tag is invalid (%u)", node->tag); if (node->tag == JSON_BOOL) { if (node->bool_ != false && node->bool_ != true) problem("bool_ is neither false (%d) nor true (%d)", (int)false, (int)true); } else if (node->tag == JSON_STRING) { if (node->string_ == NULL) problem("string_ is NULL"); if (!utf8_validate(node->string_)) problem("string_ contains invalid UTF-8"); } else if (node->tag == JSON_ARRAY || node->tag == JSON_OBJECT) { JsonNode *head = node->children.head; JsonNode *tail = node->children.tail; if (head == NULL || tail == NULL) { if (head != NULL) problem("tail is NULL, but head is not"); if (tail != NULL) problem("head is NULL, but tail is not"); } else { JsonNode *child; JsonNode *last = NULL; if (head->prev != NULL) problem("First child's prev pointer is not NULL"); for (child = head; child != NULL; last = child, child = child->next) { if (child == node) problem("node is its own child"); if (child->next == child) problem("child->next == child (cycle)"); if (child->next == head) problem("child->next == head (cycle)"); if (child->parent != node) problem("child does not point back to parent"); if (child->next != NULL && child->next->prev != child) problem("child->next does not point back to child"); if (node->tag == JSON_ARRAY && child->key != NULL) problem("Array element's key is not NULL"); if (node->tag == JSON_OBJECT && child->key == NULL) problem("Object member's key is NULL"); if (!json_check(child, errmsg)) return false; } if (last != tail) problem("tail does not match pointer found by starting at head and following next links"); } } return true; #undef problem } jo-1.0/json.h000066400000000000000000000066441267056141600131260ustar00rootroot00000000000000/* Copyright (C) 2011 Joseph A. Adams (joeyadams3.14159@gmail.com) All rights reserved. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef CCAN_JSON_H #define CCAN_JSON_H #include #include typedef enum { JSON_NULL, JSON_BOOL, JSON_STRING, JSON_NUMBER, JSON_ARRAY, JSON_OBJECT, } JsonTag; typedef struct JsonNode JsonNode; struct JsonNode { /* only if parent is an object or array (NULL otherwise) */ JsonNode *parent; JsonNode *prev, *next; /* only if parent is an object (NULL otherwise) */ char *key; /* Must be valid UTF-8. */ JsonTag tag; union { /* JSON_BOOL */ bool bool_; /* JSON_STRING */ char *string_; /* Must be valid UTF-8. */ /* JSON_NUMBER */ double number_; /* JSON_ARRAY */ /* JSON_OBJECT */ struct { JsonNode *head, *tail; } children; }; }; /*** Encoding, decoding, and validation ***/ JsonNode *json_decode (const char *json); char *json_encode (const JsonNode *node); char *json_encode_string (const char *str); char *json_stringify (const JsonNode *node, const char *space); void json_delete (JsonNode *node); bool json_validate (const char *json); /*** Lookup and traversal ***/ JsonNode *json_find_element (JsonNode *array, int index); JsonNode *json_find_member (JsonNode *object, const char *key); JsonNode *json_first_child (const JsonNode *node); #define json_foreach(i, object_or_array) \ for ((i) = json_first_child(object_or_array); \ (i) != NULL; \ (i) = (i)->next) /*** Construction and manipulation ***/ JsonNode *json_mknull(void); JsonNode *json_mkbool(bool b); JsonNode *json_mkstring(const char *s); JsonNode *json_mknumber(double n); JsonNode *json_mkarray(void); JsonNode *json_mkobject(void); void json_append_element(JsonNode *array, JsonNode *element); void json_prepend_element(JsonNode *array, JsonNode *element); void json_append_member(JsonNode *object, const char *key, JsonNode *value); void json_prepend_member(JsonNode *object, const char *key, JsonNode *value); void json_remove_from_parent(JsonNode *node); /*** Debugging ***/ /* * Look for structure and encoding problems in a JsonNode or its descendents. * * If a problem is detected, return false, writing a description of the problem * to errmsg (unless errmsg is NULL). */ bool json_check(const JsonNode *node, char errmsg[256]); #endif jo-1.0/press.md000066400000000000000000000057471267056141600134650ustar00rootroot00000000000000## "Press" reports * [Hacker News](https://news.ycombinator.com/item?id=11230023) * [Lobsters](https://lobste.rs/s/tyehi1/a_shell_command_to_create_json_jo) * [reddit](https://www.reddit.com/r/programming/comments/49sx6x/a_shell_command_to_create_json_jo) jo-1.0/tests/000077500000000000000000000000001267056141600131345ustar00rootroot00000000000000jo-1.0/tests/jo.01.exp000066400000000000000000000000071267056141600144760ustar00rootroot00000000000000["jo"] jo-1.0/tests/jo.01.sh000066400000000000000000000000351267056141600143150ustar00rootroot00000000000000# basic logo ${JO:-jo} -a jo jo-1.0/tests/jo.02.exp000066400000000000000000000000071267056141600144770ustar00rootroot00000000000000["jo"] jo-1.0/tests/jo.02.sh000066400000000000000000000000551267056141600143200ustar00rootroot00000000000000# basic logo (stdin) echo jo | ${JO:-jo} -a jo-1.0/tests/jo.03.exp000066400000000000000000000000341267056141600145000ustar00rootroot00000000000000{"pass":true,"type":"text"} jo-1.0/tests/jo.03.sh000066400000000000000000000000611267056141600143160ustar00rootroot00000000000000# basic two values ${JO:-jo} pass=true type=text jo-1.0/tests/jo.04.exp000066400000000000000000000000711267056141600145020ustar00rootroot00000000000000{"name":"Jane Jolie","data":{"age":null,"country":"ES"}} jo-1.0/tests/jo.04.sh000066400000000000000000000003131267056141600143170ustar00rootroot00000000000000# nested with executable ${JO:-jo} name="Jane Jolie" data="$(${JO:-jo} age= country=ES)" # the double quotes around data are required for OpenBSD 5.8 # which mucks up the input with its pdksh otherwise jo-1.0/tests/jo.05.exp000066400000000000000000000000501267056141600145000ustar00rootroot00000000000000{"a":[1,2],"geo":{"lat":111,"lon":222}} jo-1.0/tests/jo.05.sh000066400000000000000000000001001267056141600143120ustar00rootroot00000000000000# nested native ${JO:-jo} a[]=1 a[]=2 geo[lat]=111 geo[lon]=222 jo-1.0/tests/jo.06.exp000066400000000000000000000001161267056141600145040ustar00rootroot00000000000000{ "artist": "Vanessa Paradis", "song": "Joe le taxi", "year": 1987 } jo-1.0/tests/jo.06.sh000066400000000000000000000001531267056141600143230ustar00rootroot00000000000000# strings and numbers; pretty (Vanessa) ${JO:-jo} -p artist="Vanessa Paradis" song="Joe le taxi" year=1987 jo-1.0/tests/jo.07.sh.in000066400000000000000000000000771267056141600147360ustar00rootroot00000000000000# version check [ "$(${JO:-jo} -v)" = "jo @PACKAGE_VERSION@" ] jo-1.0/tests/jo.08.exp000066400000000000000000000000761267056141600145130ustar00rootroot00000000000000{"program":"jo","authors":"Jan-Piet Mens "} jo-1.0/tests/jo.08.sh000066400000000000000000000001141267056141600143220ustar00rootroot00000000000000# data from file: text ${JO:-jo} program="jo" authors=@${srcdir:=.}/AUTHORS jo-1.0/tests/jo.09.exp000066400000000000000000000001121267056141600145030ustar00rootroot00000000000000{"program":"jo","authors":"SmFuLVBpZXQgTWVucyA8anBtZW5zQGdtYWlsLmNvbT4K"} jo-1.0/tests/jo.09.sh000066400000000000000000000001261267056141600143260ustar00rootroot00000000000000# data from file: base64-encoded ${JO:-jo} program="jo" authors=%${srcdir:=.}/AUTHORS jo-1.0/tests/jo.test000077500000000000000000000020061267056141600144460ustar00rootroot00000000000000#!/bin/sh # input file (jo.??.in) is a shell script; the first line must # be a comment and is used as the name of the test: # # # basic logo # $JO -a jo # # the expect file (jo.??.exp) is a file which will be diff'd # against the output of the corresponding .in file: # # ["jo"] # JO="$(pwd)/jo" TESTDIR="${0%/*}" NTESTS=$(expr $(ls $TESTDIR/jo.??.sh 2>/dev/null | wc -l)) export JO export TESTDIR echo "1..$NTESTS" # Number of tests to be executed. n=0 for t in $TESTDIR/jo.??.sh; do n=$(expr $n + 1) input=$t expected="$TESTDIR/$(basename $t .sh).exp" output=$(mktemp /tmp/jo.XXXXXX) title=$(head -1 $input | sed -e 's/^#//') sh $input > $output RC=$? if [ $RC -ne 0 ]; then echo "not ok $n - $title" rm -f $output continue fi # if self-contained test (i.e. no 'expected' file exists) # use the previous RC if test -f "$expected"; then diff "$output" "$expected" > /dev/null RC=$? fi status="ok" if [ $RC -ne 0 ]; then status="not ok" fi echo "$status $n - $title" rm -f $output done