├── .gitignore
├── CMakeLists.txt
├── COPYING
├── COPYING.LESSER
├── COPYING.MIT
├── INSTALL
├── Makefile-all
├── README
├── README.md
├── README_PlanetLabs.md
├── cmake_uninstall.cmake.in
├── documentation
├── index.html
├── wjelement.html
├── wjreader.html
└── wjwriter.html
├── example
├── Makefile
├── example.c
├── layout.json
├── layout.schema
└── validate.c
├── include
├── CMakeLists.txt
├── memmgr.h
├── nmutil.h
├── wjelement.h
├── wjreader.h
├── wjwriter.h
└── xpl.h
├── pkg-config.pc.cmake
├── src
├── CMakeLists.txt
├── cli
│ ├── CMakeLists.txt
│ ├── cmds.c
│ ├── wje
│ ├── wjecli.c
│ └── wjecli.h
├── lib
│ ├── CMakeLists.txt
│ └── xpl.c
├── wjelement
│ ├── CMakeLists.txt
│ ├── element.c
│ ├── element.h
│ ├── hash.c
│ ├── schema.c
│ ├── search.c
│ ├── types.c
│ └── wjeunit.c
├── wjreader
│ ├── CMakeLists.txt
│ └── wjreader.c
└── wjwriter
│ ├── CMakeLists.txt
│ └── wjwriter.c
└── windows
├── wjelement-VC100.sln
├── wjelement-VC100.vcxproj
├── wjelement.sln
└── wjelement.vcproj
/.gitignore:
--------------------------------------------------------------------------------
1 | # CMake files
2 | CMakeCache.txt
3 | CMakeFiles
4 | CMakeScripts
5 | Makefile
6 | CTestTestfile.cmake
7 | cmake_install.cmake
8 | cmake_uninstall.cmake
9 | install_manifest.txt
10 |
11 | # Output files
12 | wjelement.pc
13 | wjecli
14 | wjeunit
15 |
16 | # Compiled Object files
17 | *.slo
18 | *.lo
19 | *.o
20 | *.obj
21 |
22 | # Precompiled Headers
23 | *.gch
24 | *.pch
25 |
26 | # Compiled Dynamic libraries
27 | *.so
28 | *.so.*
29 | *.dylib
30 | *.dll
31 |
32 | # Fortran module files
33 | *.mod
34 |
35 | # Compiled Static libraries
36 | *.lai
37 | *.la
38 | *.a
39 | *.lib
40 |
41 | # Executables
42 | *.exe
43 | *.out
44 | *.app
45 |
46 | # Log files
47 | *.log
48 |
49 | # Visual Studio specific files
50 | Win32/
51 | x64/
52 | ipch/
53 | *.suo
54 | *.sdf
55 | *.user
56 | *.tlog
57 |
58 |
--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | project(WJElement)
2 | cmake_minimum_required(VERSION 2.6)
3 | include(CheckIncludeFiles)
4 | include(CheckSymbolExists)
5 |
6 | option(STATIC_LIB "Compile as static libraries" OFF)
7 |
8 | if(STATIC_LIB)
9 | set(BUILD_SHARED_LIBS OFF)
10 | add_definitions(-DCOMPILE_AS_STATIC)
11 | else(STATIC_LIB)
12 | set(BUILD_SHARED_LIBS ON)
13 | endif(STATIC_LIB)
14 |
15 | option(DISTINGUISH_INTEGERS "Distinguish between integer and non-integer numbers" OFF)
16 | if(DISTINGUISH_INTEGERS)
17 | add_definitions(-DWJE_DISTINGUISH_INTEGER_TYPE)
18 | endif()
19 |
20 | if("${CMAKE_SYSTEM}" MATCHES "Linux")
21 | add_definitions(-D_GNU_SOURCE)
22 | endif()
23 |
24 | if(NOT CMAKE_INSTALL_PREFIX)
25 | set(CMAKE_INSTALL_PREFIX /usr/local)
26 | endif(NOT CMAKE_INSTALL_PREFIX)
27 | set(INC_DEST_DIR ${CMAKE_INSTALL_PREFIX}/include)
28 | if(NOT LIB_DEST_DIR)
29 | set(LIB_DEST_DIR ${CMAKE_INSTALL_PREFIX}/lib)
30 | endif(NOT LIB_DEST_DIR)
31 | set(BIN_DEST_DIR ${CMAKE_INSTALL_PREFIX}/bin)
32 |
33 | if(CMAKE_BUILD_TYPE MATCHES Debug)
34 | add_definitions(-DDEBUG)
35 | option(SHOWNOTES "Show preprocessor notes" OFF)
36 |
37 | if(CMAKE_COMPILER_IS_GNUCC)
38 | # GCC specific debug options
39 | set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O0 -g3 -ggdb3 -gdwarf-2")
40 | set(AVOID_VERSION -avoid-version)
41 | endif(CMAKE_COMPILER_IS_GNUCC)
42 | endif(CMAKE_BUILD_TYPE MATCHES Debug)
43 |
44 | add_definitions(-DHAVE_CONFIG_H)
45 |
46 | check_include_files(string.h HAVE_STRING_H)
47 | check_symbol_exists(strcasecmp "strings.h" HAVE_STRCASECMP)
48 |
49 | check_include_files(regex.h HAVE_REGEX_H)
50 | if(HAVE_REGEX_H)
51 | add_definitions(-DHAVE_REGEX_H)
52 | else(HAVE_REGEX_H)
53 | message("*** WARNING: GNU C regex library not found.")
54 | message(" WJESchemaValidate() will not support:")
55 | message(" pattern")
56 | message(" patternProperties")
57 | message(" format")
58 | endif(HAVE_REGEX_H)
59 |
60 | # use, i.e. don't skip the full RPATH for the build tree
61 | SET(CMAKE_SKIP_BUILD_RPATH FALSE)
62 | # when building, don't use the install RPATH already
63 | # (but later on when installing)
64 | SET(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
65 | # the RPATH to be used when installing
66 | SET(CMAKE_INSTALL_RPATH ${LIB_DEST_DIR})
67 | # add the automatically determined parts of the RPATH
68 | # which point to directories outside the build tree to the install RPATH
69 | SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
70 |
71 | ENABLE_TESTING(1)
72 |
73 | INSTALL(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/documentation/
74 | DESTINATION doc/wjelement/
75 | )
76 |
77 | include_directories(include)
78 | add_subdirectory(src)
79 | add_subdirectory(include)
80 |
81 | # pkg-config .pc
82 | SET(PKG_CONFIG_REQUIRES glib-2.0)
83 | SET(PKG_CONFIG_LIBDIR
84 | ${LIB_DEST_DIR}
85 | )
86 | SET(PKG_CONFIG_INCLUDEDIR
87 | ${INC_DEST_DIR}
88 | )
89 | SET(PKG_CONFIG_LIBS
90 | "-L\${libdir} -lwjelement -lwjreader -lwjwriter"
91 | )
92 | SET(PKG_CONFIG_CFLAGS
93 | "-I\${includedir}"
94 | )
95 | CONFIGURE_FILE(
96 | "${CMAKE_CURRENT_SOURCE_DIR}/pkg-config.pc.cmake"
97 | "${CMAKE_CURRENT_BINARY_DIR}/wjelement.pc"
98 | )
99 | INSTALL(FILES "${CMAKE_CURRENT_BINARY_DIR}/wjelement.pc"
100 | DESTINATION ${LIB_DEST_DIR}/pkgconfig)
101 |
102 | # uninstall target
103 | configure_file(
104 | "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in"
105 | "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
106 | IMMEDIATE @ONLY)
107 |
108 | add_custom_target(uninstall
109 | COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
110 |
111 | SET(MAJOR_VERSION 1)
112 | SET(MINOR_VERSION 0)
113 | SET(PATCH_VERSION 1)
114 | IF(EXISTS "${CMAKE_ROOT}/Modules/CPack.cmake")
115 |
116 | INCLUDE (InstallRequiredSystemLibraries)
117 |
118 | SET (CPACK_SET_DESTDIR "on")
119 | SET (CPACK_PACKAGING_INSTALL_PREFIX "/tmp")
120 | SET (CPACK_GENERATOR "DEB")
121 |
122 | SET (CPACK_DEBIAN_PACKAGE_PRIORITY "extra")
123 | SET (CPACK_DEBIAN_PACKAGE_SECTION "libs")
124 | SET (CPACK_DEBIAN_ARCHITECTURE ${CMAKE_SYSTEM_PROCESSOR})
125 | # autogenerate dependency information
126 | set (CPACK_DEBIAN_PACKAGE_SHLIBDEPS ON)
127 |
128 | SET (CPACK_PACKAGE_DESCRIPTION "Short description")
129 | SET (CPACK_PACKAGE_DESCRIPTION_SUMMARY "Long description")
130 | SET (CPACK_PACKAGE_VENDOR "Titan Lien (digbil)")
131 | SET (CPACK_PACKAGE_CONTACT "titan@digbil.com")
132 | SET (CPACK_PACKAGE_VERSION_MAJOR "${MAJOR_VERSION}")
133 | SET (CPACK_PACKAGE_VERSION_MINOR "${MINOR_VERSION}")
134 | SET (CPACK_PACKAGE_VERSION_PATCH "${PATCH_VERSION}")
135 |
136 | SET (CPACK_PACKAGE_FILE_NAME "${CMAKE_PROJECT_NAME}_${MAJOR_VERSION}.${MINOR_VERSION}.${CPACK_PACKAGE_VERSION_PATCH}")
137 | SET (CPACK_SOURCE_PACKAGE_FILE_NAME "${CMAKE_PROJECT_NAME}_${MAJOR_VERSION}.${MINOR_VERSION}.${CPACK_PACKAGE_VERSION_PATCH}")
138 |
139 | SET (CPACK_COMPONENTS_ALL Libraries ApplicationData)
140 | INCLUDE (CPack)
141 | ENDIF(EXISTS "${CMAKE_ROOT}/Modules/CPack.cmake")
142 |
143 |
--------------------------------------------------------------------------------
/COPYING.LESSER:
--------------------------------------------------------------------------------
1 | GNU LESSER GENERAL PUBLIC LICENSE
2 | Version 3, 29 June 2007
3 |
4 | Copyright (C) 2007 Free Software Foundation, Inc.
5 | Everyone is permitted to copy and distribute verbatim copies
6 | of this license document, but changing it is not allowed.
7 |
8 |
9 | This version of the GNU Lesser General Public License incorporates
10 | the terms and conditions of version 3 of the GNU General Public
11 | License, supplemented by the additional permissions listed below.
12 |
13 | 0. Additional Definitions.
14 |
15 | As used herein, "this License" refers to version 3 of the GNU Lesser
16 | General Public License, and the "GNU GPL" refers to version 3 of the GNU
17 | General Public License.
18 |
19 | "The Library" refers to a covered work governed by this License,
20 | other than an Application or a Combined Work as defined below.
21 |
22 | An "Application" is any work that makes use of an interface provided
23 | by the Library, but which is not otherwise based on the Library.
24 | Defining a subclass of a class defined by the Library is deemed a mode
25 | of using an interface provided by the Library.
26 |
27 | A "Combined Work" is a work produced by combining or linking an
28 | Application with the Library. The particular version of the Library
29 | with which the Combined Work was made is also called the "Linked
30 | Version".
31 |
32 | The "Minimal Corresponding Source" for a Combined Work means the
33 | Corresponding Source for the Combined Work, excluding any source code
34 | for portions of the Combined Work that, considered in isolation, are
35 | based on the Application, and not on the Linked Version.
36 |
37 | The "Corresponding Application Code" for a Combined Work means the
38 | object code and/or source code for the Application, including any data
39 | and utility programs needed for reproducing the Combined Work from the
40 | Application, but excluding the System Libraries of the Combined Work.
41 |
42 | 1. Exception to Section 3 of the GNU GPL.
43 |
44 | You may convey a covered work under sections 3 and 4 of this License
45 | without being bound by section 3 of the GNU GPL.
46 |
47 | 2. Conveying Modified Versions.
48 |
49 | If you modify a copy of the Library, and, in your modifications, a
50 | facility refers to a function or data to be supplied by an Application
51 | that uses the facility (other than as an argument passed when the
52 | facility is invoked), then you may convey a copy of the modified
53 | version:
54 |
55 | a) under this License, provided that you make a good faith effort to
56 | ensure that, in the event an Application does not supply the
57 | function or data, the facility still operates, and performs
58 | whatever part of its purpose remains meaningful, or
59 |
60 | b) under the GNU GPL, with none of the additional permissions of
61 | this License applicable to that copy.
62 |
63 | 3. Object Code Incorporating Material from Library Header Files.
64 |
65 | The object code form of an Application may incorporate material from
66 | a header file that is part of the Library. You may convey such object
67 | code under terms of your choice, provided that, if the incorporated
68 | material is not limited to numerical parameters, data structure
69 | layouts and accessors, or small macros, inline functions and templates
70 | (ten or fewer lines in length), you do both of the following:
71 |
72 | a) Give prominent notice with each copy of the object code that the
73 | Library is used in it and that the Library and its use are
74 | covered by this License.
75 |
76 | b) Accompany the object code with a copy of the GNU GPL and this license
77 | document.
78 |
79 | 4. Combined Works.
80 |
81 | You may convey a Combined Work under terms of your choice that,
82 | taken together, effectively do not restrict modification of the
83 | portions of the Library contained in the Combined Work and reverse
84 | engineering for debugging such modifications, if you also do each of
85 | the following:
86 |
87 | a) Give prominent notice with each copy of the Combined Work that
88 | the Library is used in it and that the Library and its use are
89 | covered by this License.
90 |
91 | b) Accompany the Combined Work with a copy of the GNU GPL and this license
92 | document.
93 |
94 | c) For a Combined Work that displays copyright notices during
95 | execution, include the copyright notice for the Library among
96 | these notices, as well as a reference directing the user to the
97 | copies of the GNU GPL and this license document.
98 |
99 | d) Do one of the following:
100 |
101 | 0) Convey the Minimal Corresponding Source under the terms of this
102 | License, and the Corresponding Application Code in a form
103 | suitable for, and under terms that permit, the user to
104 | recombine or relink the Application with a modified version of
105 | the Linked Version to produce a modified Combined Work, in the
106 | manner specified by section 6 of the GNU GPL for conveying
107 | Corresponding Source.
108 |
109 | 1) Use a suitable shared library mechanism for linking with the
110 | Library. A suitable mechanism is one that (a) uses at run time
111 | a copy of the Library already present on the user's computer
112 | system, and (b) will operate properly with a modified version
113 | of the Library that is interface-compatible with the Linked
114 | Version.
115 |
116 | e) Provide Installation Information, but only if you would otherwise
117 | be required to provide such information under section 6 of the
118 | GNU GPL, and only to the extent that such information is
119 | necessary to install and execute a modified version of the
120 | Combined Work produced by recombining or relinking the
121 | Application with a modified version of the Linked Version. (If
122 | you use option 4d0, the Installation Information must accompany
123 | the Minimal Corresponding Source and Corresponding Application
124 | Code. If you use option 4d1, you must provide the Installation
125 | Information in the manner specified by section 6 of the GNU GPL
126 | for conveying Corresponding Source.)
127 |
128 | 5. Combined Libraries.
129 |
130 | You may place library facilities that are a work based on the
131 | Library side by side in a single library together with other library
132 | facilities that are not Applications and are not covered by this
133 | License, and convey such a combined library under terms of your
134 | choice, if you do both of the following:
135 |
136 | a) Accompany the combined library with a copy of the same work based
137 | on the Library, uncombined with any other library facilities,
138 | conveyed under the terms of this License.
139 |
140 | b) Give prominent notice with the combined library that part of it
141 | is a work based on the Library, and explaining where to find the
142 | accompanying uncombined form of the same work.
143 |
144 | 6. Revised Versions of the GNU Lesser General Public License.
145 |
146 | The Free Software Foundation may publish revised and/or new versions
147 | of the GNU Lesser General Public License from time to time. Such new
148 | versions will be similar in spirit to the present version, but may
149 | differ in detail to address new problems or concerns.
150 |
151 | Each version is given a distinguishing version number. If the
152 | Library as you received it specifies that a certain numbered version
153 | of the GNU Lesser General Public License "or any later version"
154 | applies to it, you have the option of following the terms and
155 | conditions either of that published version or of any later version
156 | published by the Free Software Foundation. If the Library as you
157 | received it does not specify a version number of the GNU Lesser
158 | General Public License, you may choose any version of the GNU Lesser
159 | General Public License ever published by the Free Software Foundation.
160 |
161 | If the Library as you received it specifies that a proxy can decide
162 | whether future versions of the GNU Lesser General Public License shall
163 | apply, that proxy's public statement of acceptance of any version is
164 | permanent authorization for you to choose that version for the
165 | Library.
166 |
--------------------------------------------------------------------------------
/COPYING.MIT:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2015 Netmail / Reveal Data
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/INSTALL:
--------------------------------------------------------------------------------
1 | Compile and install WJElement:
2 |
3 | $ ccmake . #change settings if desired, 'c'onfigure and 'g'enerate
4 | $ cmake -DLIB_DEST_DIR=/usr/local/lib64 #set lib path if needed
5 | $ make
6 | # make install
7 |
8 | You may also use:
9 | $ cmake-gui .
10 | instead of ccmake.
11 |
12 |
13 | Use it in your program:
14 |
15 | #include
16 |
17 |
18 | Link against it in your project:
19 |
20 | -lwjelement
21 | (simple usage)
22 | -lwjelement -lwjreader -lwjwriter
23 | (advanced and lower-level functionality)
24 |
25 |
26 | By default, WJElement will install to /usr/local. If linking fails to find
27 | WJElement immediately after installation, you may need to run ldconfig.
28 |
--------------------------------------------------------------------------------
/Makefile-all:
--------------------------------------------------------------------------------
1 | #This file can be called with `make -f Makefile-all`
2 | #The windows build for this file uses mingw
3 |
4 | THIS = Makefile-all
5 |
6 | # Compiler
7 | CC = _
8 | CC_WIN32 = i686-w64-mingw32-gcc
9 | CC_WIN64 = x86_64-w64-mingw32-gcc
10 | CC_LINUX = gcc
11 | CC_MACOS = gcc
12 |
13 |
14 | MAKEDIR = @mkdir -p $(@D)
15 | PLATFORMDIR = _
16 | BUILDDIR = $(PLATFORMDIR)release/
17 | NAME_LIB = libwjelement
18 | CFLAGS += -Wall -Wextra -DWJE_DISTINGUISH_INTEGER_TYPE -Iinclude
19 |
20 | release: export CFLAGS=-O3
21 | release: all
22 |
23 | debug: export CFLAGS=-g -DDEBUG
24 | debug: all
25 |
26 |
27 | HDRDIR = ./include/
28 | SRCDIR = ./src/
29 | OBJDIR = $(BUILDDIR)obj/
30 |
31 | # Set platform-specific variables
32 | ifeq ($(OS),Windows_NT)
33 | OSFLAG := "WIN"
34 | PLATFORMDIR = ./windows/
35 | ifeq ($(PROCESSOR_ARCHITECTURE),x86)
36 | CC := $(CC_WIN32)
37 | endif
38 | ifeq ($(PROCESSOR_ARCHITECTURE),AMD64)
39 | CC := $(CC_WIN64)
40 | endif
41 | else
42 | UNAME_S := $(shell uname -s)
43 | PLATFORMDIR = ./unix/
44 | ifeq ($(UNAME_S),Linux)
45 | OSFLAG := "LINUX"
46 | CC := $(CC_LINUX)
47 | CFLAGS += -fPIC
48 | endif
49 | ifeq ($(UNAME_S),Darwin)
50 | OSFLAG := "MACOS"
51 | CC := $(CC_MACOS)
52 | endif
53 | endif
54 |
55 |
56 | SRCS = lib/xpl.c \
57 | wjelement/element.c \
58 | wjelement/schema.c \
59 | wjelement/hash.c \
60 | wjelement/search.c \
61 | wjelement/types.c \
62 | wjreader/wjreader.c \
63 | wjwriter/wjwriter.c
64 |
65 | OBJS = ${SRCS:%.c=$(OBJDIR)%.o}
66 |
67 |
68 |
69 | all: $(NAME_LIB)_static $(NAME_LIB)_dynamic
70 |
71 |
72 | # This rule compiles object files from source files
73 | $(OBJDIR)%.o : $(SRCDIR)%.c
74 | @$(MAKEDIR)
75 | @printf "Compiling file: "$@" -> "
76 | @$(CC) $(CFLAGS) -c $< -o $@ -I$(HDRDIR)
77 | @printf $(GREEN)"OK!"$(RESET)"\n"
78 |
79 | #This rule compiles the static version of libwjelement
80 | $(BUILDDIR)$(NAME_LIB).a: $(OBJS)
81 | @ar rs $@ $(OBJS)
82 |
83 | #This rule compiles the static version of libwjelement
84 | $(NAME_LIB)_static: $(BUILDDIR)$(NAME_LIB).a
85 |
86 | #This rule compiles the platform-specific dynamic version of libwjelement
87 | $(NAME_LIB)_dynamic: $(OBJS)
88 | @if [ $(OSFLAG) = "WIN" ]; then printf \
89 | "Compiling DLL: "$(BUILDDIR)$(NAME_LIB).dll" -> " ; \
90 | $(CC) -shared -o $(BUILDDIR)$(NAME_LIB).dll $(CFLAGS) $(OBJS) \
91 | -Wl,--output-def,$(BUILDDIR)$(NAME_LIB).def \
92 | -Wl,--out-implib,$(BUILDDIR)$(NAME_LIB).lib \
93 | -Wl,--export-all-symbols ; \
94 | elif [ $(OSFLAG) = "MACOS" ]; then printf \
95 | "Compiling dylib: "$(BUILDDIR)$(NAME_LIB).dylib" -> " ; \
96 | $(CC) -shared -o $(BUILDDIR)$(NAME_LIB).dylib $(CFLAGS) $(OBJS) ; \
97 | elif [ $(OSFLAG) = "LINUX" ]; then \
98 | printf "Compiling so: "$(BUILDDIR)$(NAME_LIB).so" -> " ; \
99 | $(CC) -shared -o $(BUILDDIR)$(NAME_LIB).so $(CFLAGS) $(OBJS) ; \
100 | fi
101 | @printf $(GREEN)"OK!"$(RESET)"\n"
102 |
103 | clean:
104 | @rm -rf $(BUILDDIR)*
105 |
106 | re: clean all
107 |
--------------------------------------------------------------------------------
/README:
--------------------------------------------------------------------------------
1 | WJElement - JSON manipulation in C
2 |
3 | WJElement is a very flexible JSON library developed by Messaging Architects.
4 | It was created for MA's "WARP" webserver ("Warp Json Elements"), and is built
5 | on top of the lower-level WJReader and WJWriter libraries (also included).
6 |
7 | WJReader and WJWriter are optimized for speed and memory-efficiency.
8 | WJElement focuses on flexibility and handy features, allowing C code to
9 | manipulate JSON documents with as few statements (fewer, sometimes!) as
10 | JavaScript itself. WJElement is also capable of json-schema validation.
11 |
12 | WJElement has grown into a generally-useful library, and is used across
13 | Messaging Architects' netmail and related projects. It is loved enough by
14 | MA's developers that we desire to use it elsewhere too, and we think others
15 | will enjoy it as well. So, here it is, ready to be consumed in any project,
16 | open or closed, as outlined by the GNU LGPL (any version). Include it as-is
17 | and link to it from your code, massage it into your own statically-linked
18 | package, or use it in ways we haven't thought of. Read the docs/headers, have
19 | fun, and if you use it for something awesome, let us know about it! :^)
20 |
21 |
22 | License:
23 | WJElement may be used, modified, and distributed under the terms of any of
24 | the following licenses.
25 | - GPL (see COPYING)
26 | - LGPL (see COPYING.LESSER)
27 | - MIT (aka Expat) (see COPYING.MIT)
28 |
29 |
30 | Owen Swerkstrom - community/repo admin, WJESchema
31 | Micah N Gorrell - primary author of WJElement
32 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | WJElement - JSON manipulation in C
2 | ==================================
3 |
4 | WJElement is a very flexible JSON library developed by Messaging Architects.
5 | It was created for MA's "WARP" webserver ("Warp Json Elements"), and is built
6 | on top of the lower-level WJReader and WJWriter libraries (also included).
7 |
8 | See the [wiki](https://github.com/netmail-open/wjelement/wiki) for more information,
9 | [example code](https://github.com/netmail-open/wjelement/wiki/WJElement-Example)
10 | and full [API](https://github.com/netmail-open/wjelement/wiki/WJElement-API) reference.
11 |
12 | WJReader and WJWriter are optimized for speed and memory-efficiency.
13 | WJElement focuses on flexibility and handy features, allowing C code to
14 | manipulate JSON documents with as few statements (fewer, sometimes!) as
15 | JavaScript itself. WJElement is also capable of json-schema validation.
16 |
17 | WJElement has grown into a generally-useful library, and is used across
18 | Messaging Architects' netmail and related projects. It is loved enough by
19 | MA's developers that we desire to use it elsewhere too, and we think others
20 | will enjoy it as well. So, here it is, ready to be consumed in any project,
21 | open or closed, as outlined by the GNU LGPL (any version). Include it as-is
22 | and link to it from your code, massage it into your own statically-linked
23 | package, or use it in ways we haven't thought of. Read the docs/headers, have
24 | fun, and if you use it for something awesome, let us know about it! :^)
25 |
26 |
27 | * Owen Swerkstrom <> - community/repo admin, WJESchema
28 | * Micah N Gorrell <> - primary author of WJElement
29 |
--------------------------------------------------------------------------------
/README_PlanetLabs.md:
--------------------------------------------------------------------------------
1 |
2 | Upstream: https://github.com/netmail-open/wjelement
3 |
4 | Packaging as a .deb in debuild/wjelement (package wjelement-pl)
5 |
6 | This package is used by plcompositor for JSON parsing and schema validation.
7 |
8 | This repo was cloned by Frank Warmerdam, and is lightly modified from
9 | upstream for clean building.
10 |
11 |
--------------------------------------------------------------------------------
/cmake_uninstall.cmake.in:
--------------------------------------------------------------------------------
1 | if(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
2 | message(FATAL_ERROR "Cannot find install manifest: @CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
3 | endif(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
4 |
5 | file(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files)
6 | string(REGEX REPLACE "\n" ";" files "${files}")
7 | foreach(file ${files})
8 | message(STATUS "Uninstalling $ENV{DESTDIR}${file}")
9 | if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
10 | exec_program(
11 | "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
12 | OUTPUT_VARIABLE rm_out
13 | RETURN_VALUE rm_retval
14 | )
15 | if(NOT "${rm_retval}" STREQUAL 0)
16 | message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}")
17 | endif(NOT "${rm_retval}" STREQUAL 0)
18 | else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
19 | message(STATUS "File $ENV{DESTDIR}${file} does not exist.")
20 | endif(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
21 | endforeach(file)
22 |
--------------------------------------------------------------------------------
/documentation/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 | WJElement Documentation: index
4 |
5 |
6 |
7 |
12 | WJElement is a very flexible JSON library developed by Messaging Architects.
13 | It was created for MA's "WARP" webserver, and is built on top of the
14 | (also-included) lower-level WJReader and WJWriter libraries.
15 |
16 |
17 |
18 |
19 | WJReader and WJWriter are optimized for speed and memory-efficiency.
20 |
21 |
22 | WJElement focuses on flexibility and handy features, allowing C code to
23 | manipulate JSON documents with as few statements (fewer, sometimes!) as
24 | JavaScript itself.
25 |
26 |
27 | WJElement provides complete
28 | JSON-schema validation
29 | (draft
30 | v3
31 | is fully supported; v4 support is working but incomplete).
32 |
33 |
34 |
35 |
36 |
37 |
38 |
License
39 |
40 | WJElement and its related libraries may be consumed in any project,
41 | open or closed, as outlined by the
42 | GNU Lesser
43 | General Public License (any version).
44 | Include it as-is and link to it
45 | from your code, massage it into your own statically-linked package, or use it
46 | in ways we haven't thought of. Read the docs/headers, have fun, and if you
47 | use it for something awesome, let us know about it! :^)
48 |
73 | In the spirit of being upfront, and to help you guage whether WJElement is
74 | right for you without asking you to invest too much time, there are a few
75 | things to note about this library:
76 |
77 |
78 |
79 |
80 | XplBool return values
81 |
82 |
83 | Many functions return TRUE on success. Deal. :^)
84 |
85 |
86 |
87 |
88 | Schema "backlink"
89 |
90 |
91 | This is something we're making use of in netmail, but is not
92 | part of the base json-schema spec.
93 | You can safely ignore it (or dig in and use it, why not? :^)
94 |
95 |
96 |
97 |
98 | Libraries, headers (stubs and #define's)
99 |
100 |
101 | Xpl (cross-platform library) provides a consistent set of utility
102 | functions within netmail. WJElement uses a subset of these functions
103 | and definitions, so they have been included.
104 |
105 |
106 | MemMgr (memory manager) provides optimized, slab-based memory management
107 | in netmail; for the sake of a general WJElement release, the MemMgr API
108 | simply calls malloc et al.
109 |
110 |
111 |
112 |
113 |
114 |
115 |
116 | You are free and encouraged to add and contribute features if
117 | you are so inclined. In some cases, there are comments or even empty code
118 | blocks, just waiting to be filled in. WJElement is great, but you can make it
119 | even better!
120 |
11 | The WJElement interfaces allow you to load an entire JSON document into
12 | memory and to then access elements within it more easily.
13 |
14 |
15 | WJElement uses UTF-8 encoding internally, as do the underlying
16 | WJReader
17 | and
18 | WJWriter.
19 | libraries.
20 | Adding other unicode support to WJR/WJW would not take too much work.
21 |
22 |
23 | WJElement is thread-safe, though an individual WJElement document and its
24 | children should not be used across threads without locking. WJElement does
25 | not provide locking, but its structure provides a handy client pointer which
26 | you may use for this or any other purpose.
27 |
28 |
29 |
WJElement Data Types
30 |
31 | WJElement
32 | is the main structure used for JSON documents. In most circumstances
33 | it will not be necessary to access anything within such a structure directly,
34 | but there are times when peeking at a JSON object's name or type (and other
35 | properties) comes in handy.
36 |
37 |
38 | From wjelement.h:
39 |
40 | typedef struct WJElementPublic {
41 | char *name;
42 | WJRType type;
43 |
44 | struct WJElementPublic *next;
45 | struct WJElementPublic *prev;
46 |
47 | struct WJElementPublic *child;
48 | struct WJElementPublic *parent;
49 |
50 | /* The number of children */
51 | int count;
52 |
53 | /*
54 | A count of changes that have been performed on this element, which can
55 | be reset by the consumer.
56 | */
57 | int changes;
58 |
59 | void *client;
60 |
61 | /*
62 | If set then this freecb will be called before actually free'ing a
63 | WJElement. If it returns FALSE then the WJElement will NOT be free'd.
64 |
65 | This can be used to allow caching of objects. If used in this way then
66 | the consumer that set the callback is responsible for ensuring that it
67 | does get free'd correctly at the correct time.
68 | */
69 | XplBool (* freecb)(struct WJElementPublic *);
70 | } WJElementPublic;
71 | typedef WJElementPublic * WJElement;
72 |
73 |
74 |
75 | WJEAction
76 | specifies which operation to carry out when calling the JSON manipulation
77 | functions.
78 |
162 | The _WJEParse version can be used to parse a document with a non-standard
163 | quote character. This allows easy parsing of simple documents directly in a
164 | C source file without having to escape double quote characters. Example:
165 |
180 | If a load callback is provided then it will be called before adding any new
181 | children, allowing the consumer to leave specific elements of the hierarchy.
182 |
183 |
184 | WJEWriteDocument
185 | - Write a WJElement object to the provided
186 | WJWriter
187 |
211 | WJEWriteMEM() allocates and returns a string containing the document.
212 | A maxlength of 0 means the string may be of unlimited length.
213 | The returned string must be freed with MemFree by the consumer.
214 |
239 | If a copy callback is provided, then it will be called with each element in
240 | order to allow filtered copying on an element-by-element basis, using any
241 | criteria.
242 |
243 |
244 | WJECopyDocument is normally used to create a new copy or to populate a new,
245 | empty document, but that is not required or enforced. If "to" is already
246 | populated, WJEMergeObjects is probably the desired function for copying in
247 | other contents.
248 |
249 |
250 | WJEDetach
251 | - Remove a WJElement from it's parent (and siblings)
252 |
287 | All JSON manipulation functions take a 'path' argument. This is a string as
288 | explained below, see WJElement Selectors
289 |
290 |
291 | Functions which take a 'last' parameter allow enumeration of multiple
292 | matching elements, if non-NULL is passed. Handy for looping through objects
293 | and arrays.
294 |
295 |
296 | WJEGet
297 | - Find the first element within the hierarchy of a WJElement that matches the
298 | specified path.
299 |
306 | In cases where a direct child of the WJElement is needed,
307 | WJEChild may be more suitable, especially if the child's
308 | name begins with a non-alphanumeric character.
309 |
310 |
311 | WJEBool
312 | - Access a boolean element
313 |
414 | WJE...F variants
415 | - Format-capable versions of element functions
416 |
417 |
418 | The following functions...
419 |
420 |
WJEGetF
421 |
WJEBoolF
422 |
WJEStringF
423 |
WJEStringNF
424 |
WJEObjectF
425 |
WJEArrayF
426 |
WJENullF
427 |
WJEInt32F
428 |
WJEUInt32F
429 |
WJEInt64F
430 |
WJEUInt64F
431 |
WJEDoubleF
432 |
433 | ...are identical to the non F variants except that the
434 | path argument has been moved to the end and is used as a format string. For
435 | example if you need a value by index, and that index is stored in the
436 | variable x:
437 |
442 | WJEChild
443 | - Find, create or update an element by name instead of path. This allows
444 | access to elements that would be difficult to reference by path. No selector
445 | syntax is used, so only direct children of the element can be found.
446 |
453 | Type specific actions may be done by passing the resulting WJElement and a
454 | NULL path to WJEBool(), WJENumber(), WJEString(), WJEObject(), WJEArray() or
455 | WJENull().
456 |
457 |
Data Processing
458 |
459 | WJEHash
460 | - Calculate a hash for a document
461 |
496 | Additional schema will be loaded
497 | via the load callback if needed. Any validation errors will be reported,
498 | printf-style, to errcb.
499 |
500 | If a the load callback is used to acquire schema but a NULL free callback is
501 | provided, WJECloseDocument will be used internally to release it.
502 |
503 |
504 | WJESchemaIsType
505 | - Determine if a document implements a specific schema.
506 |
515 | Additional schema will be loaded via the load callback if needed.
516 |
517 |
518 | If a load callback is not provided then the object type will still be checked
519 | but it will not be considered a match if it is a type that extends the
520 | specifed type.
521 |
522 |
523 | WJESchemaNameIsType
524 | - variation of WJESchemaIsType which acts on schema name instead of a document
525 |
547 | WJESchemaGetSelectors
548 | calls back matchcb for each WJElement selector which will fetch a property
549 | of a given type and format, from a given document. The load callback will be
550 | used to load all necessary schema, starting with the document's "describedby".
551 | stripat-type wildcards may be used; "Date*" will find "date" and "date-time".
552 |
553 |
554 | WJESchemaGetAllSelectors
555 | - variation of WJESchemaGetSelectors which provides selectors that
556 | could exist in objects of the given "describedby" schema name
557 |
611 | Elements within the hierarchy of a JSON document can be referenced using a
612 | path. Multiple levels of hierarchy can be referenced to find any element
613 | below the provided container. The following rules apply to any WJE
614 | functions that take a path argument.
615 |
616 |
617 | A child may be referenced with an alpha-numeric name, or a subscript within
618 | square brackets:
619 |
620 | foo
621 | ["foo"]
622 | ["$foo"]
623 |
624 |
625 |
626 | Additional levels of heirarchy can be referenced by appending an additional
627 | subscript, or appending a dot and an additional alpha-numeric name:
628 |
634 | Subscripts may contain double quoted names. Any special characters,
635 | (including .[]*?"'\) can be included by prefixing with a \.
636 |
637 | foo["bar.smeg"]
638 | foo["something with a \"quote\""]
639 |
640 |
641 |
642 | Subscripts may contain single quoted names, which behave as double quoted
643 | names but also allow for * and ? wild card substitution:
644 |
645 | foo['bar.*']
646 |
647 |
648 |
649 | Subscripts may reference an item by it's offset in an array (or object):
650 |
651 | foo[0]
652 | foo[3]
653 |
654 |
655 |
656 | Negative offsets are wrapped to the end of the array (or object) meaning
657 | that [-1] references the last item.
658 |
659 |
660 | Subscripts may reference a range of offsets by providing 2 offsets seperated
661 | by a colon:
662 |
663 | foo[2:5]
664 |
665 |
666 |
667 | Subscripts may reference a set of items by seperating offsets, offset,
668 | ranges, double quoted and single quoted values:
669 |
670 | foo[2,4:6,'bar.*', "smeg"]
671 |
672 |
673 |
674 | An empty subscript may be specified to reference all children.
675 |
676 | []
677 |
678 |
679 |
680 | A subscript of $ may be specified in actions perform creations to reference
681 | the item after the end of an array. This allows appending to an array.
682 |
683 | [$]
684 |
685 |
686 |
687 | A subscript may be prefixed by an | character to indicate that the subscript
688 | is optional. The portion of the selector from the | on will be ignored if
689 | there is a match and that match has no children.
690 |
691 |
692 | For example, if an element named foo may either be a string or an array of
693 | strings you can enumerate all values using a selector of:
694 |
695 | foo|[]
696 |
697 |
698 |
699 | A NULL path refers to the container itself.
700 |
701 |
702 | A path may end in a condition. The condition consists of an operator and a
703 | value. The value may be a number, a double quoted string, or a single
704 | quoted string. If a single quoted string is used it may contain * and ?
705 | wild cards.
706 |
707 |
708 | The following operators are supported for any value:
709 |
710 | ==, !=
711 |
712 |
713 |
714 | A number value may also use the following operators:
715 |
11 | The WARP JSON Reader provides the ability to parse a JSON document as a
12 | stream. All parsing is done with a portion of the document loaded into a
13 | buffer, and the buffer is reloaded as needed.
14 |
15 |
16 | This allows the parser to be very fast, but does require that data in the
17 | document is accessed in the order of the document.
18 |
19 |
20 |
WJReader Data Types
21 |
22 | WJReader
23 | is The WJReader document, the library's primary structure
24 |
84 | A callback function must be
85 | provided which will be used to read data as it is needed. The callback is
86 | expected to load data into the provided buffer and return the number of
87 | bytes that where loaded. If the number of bytes loaded is less than the
88 | requested length then it is assumed that the end of the document has been
89 | reached.
90 |
91 |
92 | If a buffer is provided to WJROpenDocument() then that buffer will be used,
93 | rather than allocating a new buffer. The size of the buffer must be
94 | provided as buffersize. If a buffer is not provided then one will be
95 | allocated of size buffersize.
96 |
97 |
98 | If a buffersize of 0 is passed to WJROpenDocument then the default size will
99 | be used (4KB). Some data is kept in the buffer while parsing, such as
100 | element names and values. If the buffer is not large enough for these then
101 | the document will fail to be parsed and will be aborted.
102 |
103 |
104 | WJROpenFILEDocument
105 | - helper to read from an open FILE *.
106 |
130 | An alternative method of opening a JSON document, which will provide a
131 | proper callback for reading from a pre-allocated buffer in memory.
132 |
133 |
134 | As with the standard WJROpenDocument() a buffersize of 0 will use the
135 | default buffer size.
136 |
137 |
138 | WJRCloseDocument
139 | - Close a WJReader document.
140 |
157 | Returns a string, which contains the name of the next element of the
158 | specified parent, prefixed by a single character that represents the type.
159 | The pointer returned may be used as the parent argument in future calls to
160 | WJRNext() in order to return the children of the current object.
161 |
162 |
163 | If the object's name is larger than the maxnamelen argument then it will be
164 | truncated.
165 |
166 |
167 | These WJReader functions
168 | Return the value of the last object returned by WJRNext(). The calling
169 | application is expected to know the type of the value, and call the
170 | appropriate function. When possible the value will be converted if it does
171 | not match the requested type.
172 |
173 |
174 | If the buffer is not large enough to contain the entire value then the
175 | WJRString() function may return a partial value. It may be called multiple
176 | times until a NULL is returned to ensure that the entire value has been
177 | read.
178 |
193 | WJRNegative
194 | - Check whether the current WJR_TYPE_NUMBER value is negative
195 |
196 |
197 |
198 | XplBool WJRNegative(WJReader doc);
199 |
200 |
201 |
202 | If the current element is a WJR_TYPE_NUMBER then this function can be used
203 | to determine if the value is negative or positive. If negative then TRUE
204 | will be returned.
205 |
11 | The WARP JSON Writer provides the ability to easily write a JSON document to
12 | a stream. All data formatting is done automatically.
13 |
14 |
15 |
WJWriter Data Types
16 |
17 | WJWriter
18 | is The WJWriter document, the library's primary structure
19 |
20 |
21 | From wjwriter.h:
22 |
23 | typedef struct {
24 | XplBool pretty;
25 |
26 | /*
27 | Base may be set to 8, 10 (default), or 16. Using a base other than 10
28 | will result in a non standard JSON document which may not be read
29 | properly by all parsers.
30 | */
31 | int base;
32 |
33 | struct {
34 | void *data;
35 | WJWriteCallback cb;
36 | } write;
37 |
38 | struct {
39 | void *data;
40 | void (* freecb)(void *data);
41 | } user;
42 | } WJWriterPublic;
43 | typedef WJWriterPublic* WJWriter;
44 |
88 | An alternative method of opening a JSON document for writing, which will
89 | provide a proper callback for writing the data to an open FILE *.
90 |
91 |
92 | WJWCloseDocument
93 | - Close a WJWriter document
94 |
137 | Open an object. All objects that are direct children of the object MUST be
138 | named. A value of NULL should NOT be passed as name for any such values.
139 |
140 |
141 | When all values of the object have been written it can be closed with
142 | WJWCloseObject().
143 |
144 |
145 | WJWCloseObject
146 | - Close an object.
147 |
148 |
149 |
150 | XplBool WJWCloseObject(WJWriter doc);
151 |
152 |
153 |
JSON Values
154 |
155 | These WJWriter functions
156 | write a value to the document. If any values are written that are a direct
157 | child of an object then a non-NULL name MUST be provided. If any values are
158 | written that are a direct child of an array then a non-NULL name MUST NOT be
159 | provided.
160 |
161 |
162 | A string value may be written in multiple pieces. A JSON string will be
163 | started with the first call to WJWString, or WJWStringN and the string will
164 | not be completed until the "done" argument is set to TRUE or there is a call
165 | to write a non-string type value.
166 |