本文介绍在Ubuntu 9.04环境下编译Libjson共享库遇到的问题及解决方案，包括修改Makefile和JSONOptions.h文件的具体细节，旨在帮助开发者成功编译并使用Libjson。
1: carit@carit-desktop:~/lighttpd/sbin$ sudo g++ -I/usr/include/fastcgi -I/usr/include/libjson/ -ljson -lfcgi++ echo-cpp1.cpp -o fastcgi
环境：
Ubuntu 9.04
libjson_7.1.1.zip
lighttpd-1.4.28.tar.gz
fcgi-2.4.0.tar.gz
编译 libjson 的共享库时出现问题 没办法编译出共享库
后来修改了一下MakeFile才解决。
把原来的两行修改成如下
1: BUILD_TYPE="debug"2: SHARED=1
JSONOptions.h 文件也有作修改，要不然会编译不通过。
忘记修改了哪里，没办法全都贴出来吧。
#ifndef JSON_OPTIONS_H#define JSON_OPTIONS_H/*** This file holds all of the compiling options for easy access and so* that you don't have to remember them, or look them up all the time*//** JSON_LIBRARY must be declared if libjson is compiled as a static or dynamic* library. This exposes a C-style interface, but none of the inner workings of libjson*///#define JSON_LIBRARY/** JSON_STRICT removes all of libjson's extensions. Meaning no comments, no special numbers*///#define JSON_STRICT/** JSON_DEBUG is used to perform extra error checking. Because libjson usually* does on the fly parsing, validation is impossible, so this option will allow* you to register an error callback so that you can record what is going wrong* before the library crashes. This option does not protect from these errors,* it simply tells you about them, which is nice for debugging, but not preferable* for release candidates*///#define JSON_DEBUG/** JSON_ISO_STRICT turns off all code that uses non-standard C++. This removes all* references to long long and long double as well as a few others*///#define JSON_ISO_STRICT/** JSON_SAFE performs similarly to JSON_DEBUG, except this option does protect* from the errors that it encounters. This option is recommended for those who* feel it's possible for their program to encounter invalid json.*/#define JSON_SAFE/** JSON_STDERROR routes error messages to cerr instead of a callback, this* option hides the callback registering function. This will usually display* messages in the console*///#define JSON_STDERROR/** JSON_PREPARSE causes all parsing to be done immediately. By default, libjson* parses nodes on the fly as they are needed, this makes parsing much faster if* your program gets a lot of information that it doesn't need. An example of* this would be a client application communicating with a server if the server* returns things like last modified date and other things that you don't use.*///#define JSON_PREPARSE/** JSON_LESS_MEMORY will force libjson to let go of memory as quickly as it can* this is recommended for software that has to run on less than optimal machines.* It will cut libjson's memory usage by about 20%, but also run slightly slower.* It's recommended that you also compile using the -Os option, as this will also* reduce the size of the library*///#define JSON_LESS_MEMORY/** JSON_UNICODE tells libjson to use wstrings instead of regular strings, this* means that libjson supports the full array of unicode characters, but also takes* much more memory and processing power.*///#define JSON_UNICODE/** JSON_REF_COUNT causes libjson to reference count JSONNodes, which makes copying* and passing them around much faster. It is recommended that this stay on for* most uses*/#define JSON_REF_COUNT/** JSON_BINARY is used to support binary, which is base64 encoded and decoded by libjson,* if this option is not turned on, no base64 support is included*///#define JSON_BINARY/** JSON_EXPOSE_BASE64 is used to turn on the functionality of libjson's base64 encoding* and decoding. This may be useful if you want to obfuscate your json, or send binary data over* a network*///#define JSON_EXPOSE_BASE64/** JSON_ITERATORS turns on all of libjson's iterating functionality. This would usually* only be turned off while compiling for use with C*/#define JSON_ITERATORS/** JSON_STREAM turns on libjson's streaming functionality. This allows you to give parts of* your json into a stream, which will automatically hit a callback when full nodes are* completed*///#define JSON_STREAM/** JSON_MEMORY_CALLBACKS exposes functions to register callbacks for allocating, resizing,* and freeing memory. Because libjson is designed for costomizability, it is feasible* that some users would like to further add speed by having the library utilize a memory* pool. With this option turned on, the default behavior is still done internally unless* a callback is registered. So you can have this option on and mot use it.*///#define JSON_MEMORY_CALLBACKS/** JSON_MEMORY_MANAGE is used to create functionality to automatically track and clean* up memory that has been allocated by the user. This includes strings, binary data, and* nodes. It also exposes bulk delete functions.*///#define JSON_MEMORY_MANAGE/** JSON_MUTEX_CALLBACKS exposes functions to register callbacks to lock and unlock* mutexs and functions to lock and unlock JSONNodes and all of it's children. This* does not prevent other threads from accessing the node, but will prevent them from* locking it. It is much easier for the end programmer to allow libjson to manage* your mutexs because of reference counting and manipulating trees, libjson automatically* tracks mutex controls for you, so you only ever lock what you need to*///#define JSON_MUTEX_CALLBACKS/** JSON_MUTEX_MANAGE lets you set mutexes and forget them, libjson will not only keep* track of the mutex, but also keep a count of how many nodes are using it, and delete* it when there are no more references*///#define JSON_MUTEX_MANAGE/** JSON_NO_C_CONSTS removes consts from the C interface. It still acts the same way, but* this may be useful for using the header with languages or variants that don't have const*///#define JSON_NO_C_CONSTS/** JSON_OCTAL allows libjson to use octal values in numbers.*///#define JSON_OCTAL/** JSON_WRITE_PRIORITY turns on libjson's writing capabilties. Without this libjson can only* read and parse json, this allows it to write back out. Changing the value of the writer* changes how libjson compiles, and how fast it will go when writing*/#define JSON_WRITE_PRIORITY MED/** JSON_READ_PRIORITY turns on libjson's reading capabilties. Changing the value of the reader* changes how libjson compiles, and how fast it will go when writing*/#define JSON_READ_PRIORITY HIGH/** JSON_NEWLINE affects how libjson writes. If this option is turned on, libjson* will use whatever it's defined as for the newline signifier, otherwise, it will use* standard unix /n.*///#define JSON_NEWLINE "/r/n" ///r/n is standard for most windows and dos programs/** JSON_INDENT affects how libjson writes. If this option is turned on, libjson* will use /t to indent formatted json, otherwise it will use the number of characters* that you specify. If this is not turned on, then it will use the tab (/t) character*///#define JSON_INDENT " "/** JSON_ESCAPE_WRITES tells the libjson engine to escape special characters when it writes* out. If this option is turned off, the json it outputs may not adhere to JSON standards*/#define JSON_ESCAPE_WRITES/** JSON_COMMENTS tells libjson to store and write comments. libjson always supports* parsing json that has comments in it as it simply ignores them, but with this option* it keeps the comments and allows you to insert further comments*///#define JSON_COMMENTS/** JSON_WRITE_BASH_COMMENTS will cause libjson to write all comments in bash (#) style* if this option is not turned on, then it will use C-style comments. Bash comments are* all single line*///#define JSON_WRITE_BASH_COMMENTS/** JSON_WRITE_SINGLE_LINE_COMMENTS will cause libjson to write all comments in using //* notation, or (#) if that option is on. Some parsers do not support multiline C comments* although, this option is not needed for bash comments, as they are all single line anyway*///#define JSON_WRITE_SINGLE_LINE_COMMENTS/** JSON_ARRAY_SIZE_ON_ON_LINE allows you to put small arrays of primitives all on one line* in a write_formatted. This is common for tuples, like coordinates. If must be defined* as an integer*///#define JSON_ARRAY_SIZE_ON_ONE_LINE 2/** JSON_VALIDATE turns on validation features of libjson. This option requires JSON_SAFE*///#define JSON_VALIDATE/** JSON_CASE_INSENSITIVE_FUNCTIONS turns on funtions for finding child nodes in a case-* insenititve way*///#define JSON_CASE_INSENSITIVE_FUNCTIONS/** JSON_INDEX_TYPE allows you th change the size type for the children functions. If this* option is not used then unsigned int is used. This option is useful for cutting down* on memory, or using huge numbers of child nodes (over 4 billion)*///#define JSON_INDEX_TYPE unsigned int/** JSON_BOOL_TYPE lets you change the bool type for the C interface. Because before C99 there* was no bool, and even then it's just a typedef, you may want to use something else. If this* is not defined, it will revert to int*///#define JSON_BOOL_TYPE char/** JSON_INT_TYPE lets you change the int type for as_int. If you ommit this option, the default* long will be used*///#define JSON_INT_TYPE long/** JSON_STRING_HEADER allows you to change the type of string that libjson uses both for the* interface and internally. It must implement most of the STL string interface, but not all* of it. Things like wxString or QString should wourk without much trouble*///#define JSON_STRING_HEADER "../TestSuite/StringTest.h"/** JSON_UNIT_TEST is used to maintain and debug the libjson. It makes all private* members and functions public so that tests can do checks of the inner workings* of libjson. This should not be turned on by end users.*///#define JSON_UNIT_TEST/** JSON_NO_EXCEPTIONS turns off any exception trhowing by the library. It may still use exceptions* internally, but the interface will never throw anything.*///#define JSON_NO_EXCEPTIONS/** JSON_DEPRECATED_FUNCTIONS turns on functions that have been deprecated, this is for backwards* compatibility between major releases. It is highly recommended that you move your functions* over to the new equivalents*/#define JSON_DEPRECATED_FUNCTIONS#endif
扫一扫
620
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
