int main( int argc, char **argv ) {
// Check if zlib is ok. Taken from zlib's example.c file.
static const char* myVersion = ZLIB_VERSION;
if( zlibVersion()[ 0 ] != myVersion[ 0 ] ) {
fprintf( stderr, "incompatible zlib version\n" );
exit( 1 );
} else if( strcmp( zlibVersion(), ZLIB_VERSION ) != 0 ) {
fprintf( stderr, "warning: different zlib version\n" );
}
// printf( "zlib version %s = 0x%04x, compile flags = 0x%lx\n", ZLIB_VERSION, ZLIB_VERNUM, zlibCompileFlags() );
// End of zlib check.
QPEApplication a( argc, argv );
Controller* controller = new Controller();
//controller->loadTermData();
if( !controller->init() ) {
cerr << "Cannot initialize controller. Check disk space and file permissions." << endl;
exit( 2 );
}
QFont labelsFont( controller->getPreferences().getLabelsFont() );
qApp->setFont( labelsFont );
MainWindow* mainWindow = new MainWindow( controller );
a.connect( &a, SIGNAL(lastWindowClosed()), &a, SLOT(quit()) );
a.showMainWidget( mainWindow );
return a.exec();
}
/* static */ bool wxZlibInputStream::CanHandleGZip()
{
const char *dot = strchr(zlibVersion(), '.');
int major = atoi(zlibVersion());
int minor = dot ? atoi(dot + 1) : 0;
return major > 1 || (major == 1 && minor >= 2);
}
int main(
int argc,
char *argv[])
{
Byte *compr, *uncompr;
uLong comprLen = 10000*sizeof(int); /* don't overflow on MSDOS */
uLong uncomprLen = comprLen;
static const char* myVersion = ZLIB_VERSION;
if (zlibVersion()[0] != myVersion[0]) {
fprintf(stderr, "incompatible zlib version\n");
exit(1);
} else if (strcmp(zlibVersion(), ZLIB_VERSION) != 0) {
fprintf(stderr, "warning: different zlib version\n");
}
printf("zlib version %s = 0x%04x, compile flags = 0x%lx\n",
ZLIB_VERSION, ZLIB_VERNUM, zlibCompileFlags());
compr = (Byte*)calloc((uInt)comprLen, 1);
uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
/* compr and uncompr are cleared to avoid reading uninitialized
* data and to ensure that uncompr compresses well.
*/
if (compr == Z_NULL || uncompr == Z_NULL) {
printf("out of memory\n");
exit(1);
}
test_compress(compr, comprLen, uncompr, uncomprLen);
test_gzio((argc > 1 ? argv[1] : TESTFILE),
uncompr, uncomprLen);
test_deflate(compr, comprLen);
test_inflate(compr, comprLen, uncompr, uncomprLen);
test_large_deflate(compr, comprLen, uncompr, uncomprLen);
test_large_inflate(compr, comprLen, uncompr, uncomprLen);
test_flush(compr, &comprLen);
test_sync(compr, comprLen, uncompr, uncomprLen);
comprLen = uncomprLen;
test_dict_deflate(compr, comprLen);
test_dict_inflate(compr, comprLen, uncompr, uncomprLen);
free(compr);
free(uncompr);
return 0;
}
static void __comp_fetch_init(void)
{
char *ptr = NULL;
int i;
#ifdef USE_SLZ
slz_make_crc_table();
slz_prepare_dist_table();
#endif
#if defined(USE_ZLIB) && defined(DEFAULT_MAXZLIBMEM)
global.maxzlibmem = DEFAULT_MAXZLIBMEM * 1024U * 1024U;
#endif
#ifdef USE_ZLIB
HA_SPIN_INIT(&comp_pool_lock);
memprintf(&ptr, "Built with zlib version : " ZLIB_VERSION);
memprintf(&ptr, "%s\nRunning on zlib version : %s", ptr, zlibVersion());
#elif defined(USE_SLZ)
memprintf(&ptr, "Built with libslz for stateless compression.");
#else
memprintf(&ptr, "Built without compression support (neither USE_ZLIB nor USE_SLZ are set).");
#endif
memprintf(&ptr, "%s\nCompression algorithms supported :", ptr);
for (i = 0; comp_algos[i].cfg_name; i++)
memprintf(&ptr, "%s%s %s(\"%s\")", ptr, (i == 0 ? "" : ","), comp_algos[i].cfg_name, comp_algos[i].ua_name);
if (i == 0)
memprintf(&ptr, "%s none", ptr);
hap_register_build_opts(ptr, 1);
cfg_register_keywords(&cfg_kws);
}
static void
lz_assert(lua_State *L, int result, struct filter *flt) {
z_stream* stream;
if ( result == Z_OK || result == Z_STREAM_END || result == Z_BUF_ERROR )
return;
stream = flt->stream;
switch ( result ) {
case Z_NEED_DICT:
lua_pushfstring(L, "RequiresDictionary: input stream requires a dictionary to be deflated (%s)", stream->msg);
break;
case Z_STREAM_ERROR:
lua_pushfstring(L, "InternalError: inconsistent internal zlib stream (%s)", stream->msg);
break;
case Z_DATA_ERROR:
lua_pushfstring(L, "InvalidInput: input string does not conform to zlib format or checksum failed");
break;
case Z_MEM_ERROR:
lua_pushfstring(L, "OutOfMemory: not enough memory (%s)", stream->msg);
break;
case Z_VERSION_ERROR:
lua_pushfstring(L, "IncompatibleLibrary: built with version %s, but dynamically linked with version %s (%s)",
ZLIB_VERSION, zlibVersion(), stream->msg);
break;
default:
lua_pushfstring(L, "ZLibError: unknown code %d (%s)", result, stream->msg);
break;
}
flt->end(stream);
lua_error(L);
}
static int lz_assert(lua_State *L, int result, const z_stream* stream, const char* file, int line) {
/* Both of these are "normal" return codes: */
if ( result == Z_OK || result == Z_STREAM_END ) return result;
switch ( result ) {
case Z_NEED_DICT:
lua_pushfstring(L, "RequiresDictionary: input stream requires a dictionary to be deflated (%s) at %s line %d",
stream->msg, file, line);
break;
case Z_STREAM_ERROR:
lua_pushfstring(L, "InternalError: inconsistent internal zlib stream (%s) at %s line %d",
stream->msg, file, line);
break;
case Z_DATA_ERROR:
lua_pushfstring(L, "InvalidInput: input string does not conform to zlib format or checksum failed at %s line %d",
file, line);
break;
case Z_MEM_ERROR:
lua_pushfstring(L, "OutOfMemory: not enough memory (%s) at %s line %d",
stream->msg, file, line);
break;
case Z_BUF_ERROR:
lua_pushfstring(L, "InternalError: no progress possible (%s) at %s line %d",
stream->msg, file, line);
break;
case Z_VERSION_ERROR:
lua_pushfstring(L, "IncompatibleLibrary: built with version %s, but dynamically linked with version %s (%s) at %s line %d",
ZLIB_VERSION, zlibVersion(), stream->msg, file, line);
break;
default:
lua_pushfstring(L, "ZLibError: unknown code %d (%s) at %s line %d",
result, stream->msg, file, line);
}
lua_error(L);
return result;
}
static SQRESULT sq_check_result(HSQUIRRELVM v, int result, const z_stream* stream) {
/* Both of these are "normal" return codes: */
if ( result == Z_OK || result == Z_STREAM_END ) return SQ_OK;
switch ( result ) {
case Z_NEED_DICT:
return sq_throwerror(v, _SC("RequiresDictionary: input stream requires a dictionary to be deflated (%s)"),
stream->msg);
break;
case Z_STREAM_ERROR:
return sq_throwerror(v, _SC("InternalError: inconsistent internal zlib stream (%s)"),
stream->msg);
break;
case Z_DATA_ERROR:
return sq_throwerror(v, _SC("InvalidInput: input string does not conform to zlib format or checksum"));
break;
case Z_MEM_ERROR:
return sq_throwerror(v, _SC("OutOfMemory: not enough memory (%s)"), stream->msg);
break;
case Z_BUF_ERROR:
return sq_throwerror(v, _SC("InternalError: no progress possible (%s)"), stream->msg);
break;
case Z_VERSION_ERROR:
return sq_throwerror(v, _SC("IncompatibleLibrary: built with version %s, but dynamically linked with version %s (%s)"),
ZLIB_VERSION, zlibVersion(), stream->msg);
break;
default:
return sq_throwerror(v, _SC("ZLibError: unknown code %d (%s)"), result, stream->msg);
}
return SQ_OK;
}
char *curl_version(void)
{
static char version[200];
char *ptr=version;
size_t len;
size_t left = sizeof(version);
strcpy(ptr, LIBCURL_NAME "/" LIBCURL_VERSION );
ptr=strchr(ptr, '\0');
left -= strlen(ptr);
len = Curl_ssl_version(ptr, left);
left -= len;
ptr += len;
#ifdef HAVE_LIBZ
len = snprintf(ptr, left, " zlib/%s", zlibVersion());
left -= len;
ptr += len;
#endif
#ifdef USE_ARES
/* this function is only present in c-ares, not in the original ares */
len = snprintf(ptr, left, " c-ares/%s", ares_version(NULL));
left -= len;
ptr += len;
#endif
#ifdef USE_LIBIDN
if(stringprep_check_version(LIBIDN_REQUIRED_VERSION)) {
len = snprintf(ptr, left, " libidn/%s", stringprep_check_version(NULL));
left -= len;
ptr += len;
}
#endif
return version;
}
/* Gzip handler. */
static CURLcode gzip_init_writer(struct connectdata *conn,
contenc_writer *writer)
{
zlib_params *zp = (zlib_params *) &writer->params;
z_stream *z = &zp->z; /* zlib state structure */
if(!writer->downstream)
return CURLE_WRITE_ERROR;
/* Initialize zlib */
z->zalloc = (alloc_func) zalloc_cb;
z->zfree = (free_func) zfree_cb;
if(strcmp(zlibVersion(), "1.2.0.4") >= 0) {
/* zlib ver. >= 1.2.0.4 supports transparent gzip decompressing */
if(inflateInit2(z, MAX_WBITS + 32) != Z_OK) {
return process_zlib_error(conn, z);
}
zp->zlib_init = ZLIB_INIT_GZIP; /* Transparent gzip decompress state */
}
else {
/* we must parse the gzip header and trailer ourselves */
if(inflateInit2(z, -MAX_WBITS) != Z_OK) {
return process_zlib_error(conn, z);
}
zp->trailerlen = 8; /* A CRC-32 and a 32-bit input size (RFC 1952, 2.2) */
zp->zlib_init = ZLIB_INIT; /* Initial call state */
}
return CURLE_OK;
}
Z1Ctx *createZ1(Z1Ctx *Zc,int de){
int siz = sizeof(Z64_stream);
const char *ver;
Z64_stream *Z1;
int rcode;
if( gzipInit() != 0 ){
fprintf(stderr,"----createZ1 FATAL Zlib unavailable\n");
return 0;
}
ver = zlibVersion();
Z1 = (Z64_stream*)malloc(siz);
bzero(Z1,siz);
Z1->zalloc = zalloc;
Z1->zfree = zfree;
Z1->opaque = Zc;
Zc->z1_Z1 = Z1;
if( de ){
rcode = XdeflateInit_(Zc,Z_BEST_SPEED,ver,siz);
}else{
rcode = XinflateInit_(Zc,ver,siz);
}
if( rcode != Z_OK ){
fprintf(stderr,"----createZ1(de=%d)=%X rcode=%d\n",de,p2i(Z1),rcode);
}
return Zc;
}
curl_version_info_data *curl_version_info(CURLversion stamp)
{
#ifdef USE_SSL
static char ssl_buffer[80];
Curl_ssl_version(ssl_buffer, sizeof(ssl_buffer));
version_info.ssl_version = ssl_buffer;
#endif
#ifdef HAVE_LIBZ
version_info.libz_version = zlibVersion();
/* libz left NULL if non-existing */
#endif
#ifdef USE_ARES
{
int aresnum;
version_info.ares = ares_version(&aresnum);
version_info.ares_num = aresnum;
}
#endif
#ifdef USE_LIBIDN
/* This returns a version string if we use the given version or later,
otherwise it returns NULL */
version_info.libidn = stringprep_check_version(LIBIDN_REQUIRED_VERSION);
if(version_info.libidn)
version_info.features |= CURL_VERSION_IDN;
#endif
(void)stamp; /* avoid compiler warnings, we don't use this */
return &version_info;
}
LUALIB_API int luaopen_luvi(lua_State *L) {
#ifdef WITH_OPENSSL
char buffer[1024];
#endif
lua_newtable(L);
#ifdef LUVI_VERSION
lua_pushstring(L, ""LUVI_VERSION"");
lua_setfield(L, -2, "version");
#endif
lua_newtable(L);
#ifdef WITH_OPENSSL
snprintf(buffer, sizeof(buffer), "%s, lua-openssl %s",
SSLeay_version(SSLEAY_VERSION), LOPENSSL_VERSION);
lua_pushstring(L, buffer);
lua_setfield(L, -2, "ssl");
#endif
#ifdef WITH_ZLIB
lua_pushstring(L, zlibVersion());
lua_setfield(L, -2, "zlib");
#endif
#ifdef WITH_WINSVC
lua_pushboolean(L, 1);
lua_setfield(L, -2, "winsvc");
#endif
lua_setfield(L, -2, "options");
return 1;
}
int upx_zlib_init(void)
{
#if defined(UPX_OFFICIAL_BUILD)
if (strcmp(ZLIB_VERSION, zlibVersion()) != 0)
return -2;
#endif
return 0;
}
ZlibUtils::ZlibUtils() :
isFirstTime_(true), compressionErrorCount_(0) {
deflateStream_.zalloc = Z_NULL;
deflateStream_.zfree = Z_NULL;
deflateStream_.opaque = Z_NULL;
inflateStream_.zalloc = Z_NULL;
inflateStream_.zfree = Z_NULL;
static const char* currentVersion = ZLIB_VERSION;
if (currentVersion[0] != zlibVersion()[0]) {
GS_THROW_USER_ERROR(GS_ERROR_CM_INCOMPATIBLE_ZLIB_VERSION,
"the zlib library version (zlib_version) is incompatible"
<< " with the version assumed, " << currentVersion
<< ", but the library version, " << zlibVersion());
}
}
JSBool SJS_PluginInit(JSContext *cx, sjs_data *rtd)
{
PLUGIN_API_CHECK;
grtd = rtd;
JS_snprintf(version, 200, "zlib/%s", zlibVersion());
zip = JSZip::JSInit(cx, JS_GetGlobalObject(cx), NULL);
return (zip != NULL);
}
static void
get_mergecap_runtime_info(GString *str)
{
/* zlib */
#if defined(HAVE_LIBZ) && !defined(_WIN32)
g_string_append_printf(str, ", with libz %s", zlibVersion());
#endif
}
curl_version_info_data *curl_version_info(CURLversion stamp)
{
static bool initialized;
#ifdef USE_LIBSSH2
static char ssh_buffer[80];
#endif
#ifdef USE_SSL
static char ssl_buffer[80];
#endif
if(initialized)
return &version_info;
#ifdef USE_SSL
Curl_ssl_version(ssl_buffer, sizeof(ssl_buffer));
version_info.ssl_version = ssl_buffer;
#endif
#ifdef HAVE_LIBZ
version_info.libz_version = zlibVersion();
/* libz left NULL if non-existing */
#endif
#ifdef USE_ARES
{
int aresnum;
version_info.ares = ares_version(&aresnum);
version_info.ares_num = aresnum;
}
#endif
#ifdef USE_LIBIDN2
/* This returns a version string if we use the given version or later,
otherwise it returns NULL */
version_info.libidn = idn2_check_version(IDN2_VERSION);
if(version_info.libidn)
version_info.features |= CURL_VERSION_IDN;
#elif defined(USE_WIN32_IDN)
version_info.features |= CURL_VERSION_IDN;
#endif
#if defined(HAVE_ICONV) && defined(CURL_DOES_CONVERSIONS)
#ifdef _LIBICONV_VERSION
version_info.iconv_ver_num = _LIBICONV_VERSION;
#else
/* version unknown */
version_info.iconv_ver_num = -1;
#endif /* _LIBICONV_VERSION */
#endif
#ifdef USE_LIBSSH2
snprintf(ssh_buffer, sizeof(ssh_buffer), "libssh2/%s", LIBSSH2_VERSION);
version_info.libssh_version = ssh_buffer;
#endif
(void)stamp; /* avoid compiler warnings, we don't use this */
initialized = true;
return &version_info;
}
/*
* All command line parameters have the syntax "-f string" or "-fstring"
* OPTIONS:
* -d filename - specify d:line file
* -f filename - specify config file
* -h hostname - specify server name
* -k filename - specify k:line file
* -l filename - specify log file
* -n - do not fork, run in foreground
* -v - print daemon version and exit
* -x - set debug level, if compiled for debug logging
*/
static void parse_command_line(int argc, char* argv[])
{
const char* options = "d:f:h:k:l:nvx:";
int opt;
while ((opt = getopt(argc, argv, options)) != EOF) {
switch (opt) {
case 'd':
if (optarg)
ConfigFileEntry.dpath = optarg;
break;
case 'f':
#ifdef CMDLINE_CONFIG
if (optarg)
ConfigFileEntry.configfile = optarg;
#endif
break;
case 'k':
#ifdef KPATH
if (optarg)
ConfigFileEntry.klinefile = optarg;
#endif
break;
case 'h':
if (optarg)
strncpy_irc(me.name, optarg, HOSTLEN);
break;
case 'l':
if (optarg)
logFileName = optarg;
break;
case 'n':
bootDaemon = 0;
break;
case 'v':
printf("ircd %s\n\tzlib %s\n\tircd_dir: %s\n", ircd_version,
#ifndef ZIP_LINKS
"not used",
#else
zlibVersion(),
#endif
ConfigFileEntry.dpath);
exit(0);
break; /* NOT REACHED */
case 'x':
#ifdef DEBUGMODE
if (optarg) {
debuglevel = atoi(optarg);
debugmode = optarg;
}
#endif
break;
default:
bad_command();
break;
}
}
}
char *curl_version(void)
{
static char version[200];
char *ptr=version;
size_t len;
size_t left = sizeof(version);
strcpy(ptr, LIBCURL_NAME "/" LIBCURL_VERSION );
len = strlen(ptr);
left -= len;
ptr += len;
if(left > 1) {
len = Curl_ssl_version(ptr + 1, left - 1);
if(len > 0) {
*ptr = ' ';
left -= ++len;
ptr += len;
}
}
#ifdef HAVE_LIBZ
len = snprintf(ptr, left, " zlib/%s", zlibVersion());
left -= len;
ptr += len;
#endif
#ifdef USE_ARES
/* this function is only present in c-ares, not in the original ares */
len = snprintf(ptr, left, " c-ares/%s", ares_version(NULL));
left -= len;
ptr += len;
#endif
#ifdef USE_LIBIDN
if(stringprep_check_version(LIBIDN_REQUIRED_VERSION)) {
len = snprintf(ptr, left, " libidn/%s", stringprep_check_version(NULL));
left -= len;
ptr += len;
}
#endif
#if defined(HAVE_ICONV) && defined(CURL_DOES_CONVERSIONS)
#ifdef _LIBICONV_VERSION
len = snprintf(ptr, left, " iconv/%d.%d",
_LIBICONV_VERSION >> 8, _LIBICONV_VERSION & 255);
#else
/* version unknown */
len = snprintf(ptr, left, " iconv");
#endif /* _LIBICONV_VERSION */
left -= len;
ptr += len;
#endif
#ifdef USE_LIBSSH2
len = snprintf(ptr, left, " libssh2/%s", CURL_LIBSSH2_VERSION);
left -= len;
ptr += len;
#endif
return version;
}
jint Java_com_tencent_mobileqq_persistence_FTSDatatbaseDao_initFTS(JNIEnv* env, jobject thiz)
{
int errCode = sqlite3_open_v2(DB_FILE, &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
if (SQLITE_OK != errCode)
{
logError("Can't open database IndexQQMsg.db, ", sqlite3_errmsg(db));
sqlite3_close(db);
return errCode;
}
errCode = sqlite3_exec(db, "PRAGMA cache_size=4000;", NULL, NULL, NULL);
if (SQLITE_OK != errCode)
{
logError("Can't set PRAGMA cache_size = 4000, ", sqlite3_errmsg(db));
sqlite3_close(db);
return errCode;
}
errCode = sqlite3_create_function(db, "qqcompress", 1, SQLITE_UTF8, NULL, qqcompress, NULL, NULL);
if (SQLITE_OK != errCode)
{
logError("Can't create function, ", sqlite3_errmsg(db));
sqlite3_close(db);
return errCode;
}
errCode = sqlite3_create_function(db, "qquncompress", 1, SQLITE_UTF8, NULL, qquncompress, NULL, NULL);
if (SQLITE_OK != errCode)
{
logError("Can't create function, ", sqlite3_errmsg(db));
sqlite3_close(db);
return errCode;
}
char* sql = "CREATE VIRTUAL TABLE IF NOT EXISTS IndexMsg USING fts4(type, content, contentindex, oid, ext1, ext2，ext3，exts, compress=qqcompress, uncompress=qquncompress);";
// char* sql = "CREATE VIRTUAL TABLE IF NOT EXISTS IndexMsg USING fts4(type, content, contentindex, oid, ext1, ext2，ext3，exts);";
errCode = sqlite3_exec(db, sql, NULL, NULL, NULL);
if (SQLITE_OK != errCode)
{
logError("Can't create virtual table IndexMsg, ", sqlite3_errmsg(db));
sqlite3_close(db);
return errCode;
}
#ifdef ZIP
const char* version = zlibVersion();
logInfo("FTS init zlib version = ", version);
#endif
logInfo("FTS init...", NULL);
return 0;
}
QString getVersionString ()
{
QString result = QString("avalon 1.0rc3 build ") + QString::number(getBuildNumber());
#ifdef AVALON_USE_ZLIB
result += ", zlib " + QString(zlibVersion());
#endif
return result;
}
rc_t call_zlib( void )
{
const char * zlib_vers;
zlib_vers = zlibVersion();
if ( zlib_vers == NULL )
return RC( rcExe, rcCondition, rcValidating, rcInterface, rcInvalid );
OUTMSG (( "zlib version is : '%s'\n", zlib_vers ));
return 0;
}
int main(int, char **)
{
z_streamp stream;
stream = 0;
const char *ver = zlibVersion();
ver = 0;
// compress2 was added in zlib version 1.0.8
int res = compress2(0, 0, 0, 0, 1);
res = 0;
return 0;
}
int camlzip_zlibversion(void)
{
CAMLparam0 ();
CAMLlocal1 (v);
#ifdef HAVE_ZLIBVERSION
v = copy_string (zlibVersion());
CAMLreturn (v);
#else
failwith("zlibVersion not found");
#endif
}
void help(int exitval)
{
printf("untgz version 0.2.1\n"
" using zlib version %s\n\n",
zlibVersion());
printf("Usage: untgz file.tgz extract all files\n"
" untgz file.tgz fname ... extract selected files\n"
" untgz -l file.tgz list archive contents\n"
" untgz -h display this help\n");
exit(exitval);
}
void debug_init(void)
{
#ifdef HAVE_SYS_UTSNAME_H
struct utsname buf;
#endif
DEBUG_LOCK;
if ((debug_file = fopen (GBL_DEBUG_FILE, "w")) == NULL)
ERROR_MSG("Couldn't open for writing %s", GBL_DEBUG_FILE);
fprintf (debug_file, "\n==============================================================\n\n");
fprintf (debug_file, "-> ${prefix} %s\n", INSTALL_PREFIX);
fprintf (debug_file, "-> ${exec_prefix} %s\n", INSTALL_EXECPREFIX);
fprintf (debug_file, "-> ${bindir} %s\n", INSTALL_BINDIR);
fprintf (debug_file, "-> ${libdir} %s\n", INSTALL_LIBDIR);
fprintf (debug_file, "-> ${sysconfdir} %s\n", INSTALL_SYSCONFDIR);
fprintf (debug_file, "-> ${datadir} %s\n\n", INSTALL_DATADIR);
fprintf (debug_file, "-> %s %s\n\n", GBL_PROGRAM, GBL_VERSION);
#ifdef HAVE_SYS_UTSNAME_H
uname(&buf);
fprintf (debug_file, "-> running on %s %s %s\n", buf.sysname, buf.release, buf.machine);
#endif
#if defined (__GNUC__) && defined (__GNUC_MINOR__)
fprintf (debug_file, "-> compiled with gcc %d.%d (%s)\n", __GNUC__, __GNUC_MINOR__, GCC_VERSION);
#endif
#if defined (__GLIBC__) && defined (__GLIBC_MINOR__)
fprintf (debug_file, "-> glibc version %d.%d\n", __GLIBC__, __GLIBC_MINOR__);
#endif
fprintf(debug_file, "-> %s\n", pcap_lib_version());
fprintf(debug_file, "-> libnet version %s\n", LIBNET_VERSION);
fprintf(debug_file, "-> libz version %s\n", zlibVersion());
#ifdef HAVE_PCRE
fprintf(debug_file, "-> libpcre version %s\n", pcre_version());
#endif
#ifdef HAVE_OPENSSL
fprintf (debug_file, "-> lib %s\n", SSLeay_version(SSLEAY_VERSION));
fprintf (debug_file, "-> headers %s\n", OPENSSL_VERSION_TEXT);
#endif
#ifdef HAVE_NCURSES
fprintf (debug_file, "-> %s\n", curses_version());
#endif
#ifdef HAVE_GTK
fprintf (debug_file, "-> gtk+ %d.%d.%d\n", gtk_major_version, gtk_minor_version, gtk_micro_version);
#endif
fprintf (debug_file, "\n\nDEVICE OPENED FOR %s DEBUGGING\n\n", GBL_PROGRAM);
fflush(debug_file);
DEBUG_UNLOCK;
atexit(debug_close);
}
const char *ZlibVersion(){
if( 0 < zlib_dl )
{
if( isCYGWIN() ){
gzipInit();
}
return zlibVersion();
}
if( zlib_dl == 0 )
return "Not Yet";
return "Not Found";
}
TInt CTestlibz::libzversion()
{
__UHEAP_MARK;
char buf[]="1.2.3";
INFO_PRINTF1(_L("zlibVersion()\n"));
if( (strcmp( buf, zlibVersion() ) != 0) ){
INFO_PRINTF1(_L("zlibversion failed\n"));
return KErrGeneral;
}
__UHEAP_MARKEND;
return KErrNone;
}
/* {{{ PHP_MINFO_FUNCTION */
static PHP_MINFO_FUNCTION(zlib)
{
php_info_print_table_start();
php_info_print_table_header(2, "ZLib Support", "enabled");
php_info_print_table_row(2, "Stream Wrapper", "compress.zlib://");
php_info_print_table_row(2, "Stream Filter", "zlib.inflate, zlib.deflate");
php_info_print_table_row(2, "Compiled Version", ZLIB_VERSION);
php_info_print_table_row(2, "Linked Version", (char *) zlibVersion());
php_info_print_table_end();
DISPLAY_INI_ENTRIES();
}
int main(int argc, char *argv[]) {
ParseOptions(argc, argv);
if (test_mode == HELP_MODE) {
printf("Usage: %s [OPTION]... [FILE]...\n"
"Version: zlib-%s\n"
"Options:\n"
" -d, --deflate 圧縮します (default)\n"
" -i, --inflate 伸長します\n"
" -g, --gzip gzip 形式で圧縮します\n"
" -z, --zlib zlib 形式で圧縮します (default)\n"
" -l, --level=[0-9] 圧縮レベルを指定します (default: 6)\n"
" -o, --output=[FILE] 出力ファイルを指定します (default: stdout)\n"
" -h, --help このヘルプを表示します\n",
argv[0], zlibVersion());
return 0;
}
FILE *output_file = stdout;
if (output_file_name != NULL) {
output_file = fopen(output_file_name, "wb");
if (output_file == NULL) {
ERROR("%s", output_file_name);
}
}
// 入力ファイルの指定がなければ，標準入力を使います．
if (optind >= argc) {
Code(stdin, output_file);
} else {
for (int i = optind; i < argc; ++i) {
const char *input_file_name = argv[i];
FILE *input_file = fopen(input_file_name, "rb");
if (input_file == NULL) {
ERROR("%s", input_file_name);
}
Code(input_file, output_file);
if (fclose(input_file) != 0) {
ERROR("%s", input_file_name);
}
}
}
if (output_file != stdout) {
if (fclose(output_file) != 0) {
ERROR("%s", output_file_name);
}
}
return 0;
}
