static ucl_node_t
alloc_node (int value)
{
ucl_node_t N = ucl_malloc(ucl_memory_allocator, sizeof(ucl_node_tag_t));
VAL(N) = value;
return N;
}
ucl_alloc(ucl_uint nelems, ucl_uint size)
{
ucl_uint s = nelems * size;
if (nelems <= 0 || s / nelems != size)
return NULL;
return ucl_malloc(s);
}
int main(int argc, char *argv[])
{
int r;
ucl_bytep in;
ucl_bytep out;
ucl_uint in_len;
ucl_uint out_len;
ucl_uint new_len;
int level = 5; /* compression level (1-10) */
if (argc < 0 && argv == NULL) /* avoid warning about unused args */
return 0;
printf("\nUCL data compression library (v%s, %s).\n",
ucl_version_string(), ucl_version_date());
printf("Copyright (C) 1996-2003 Markus Franz Xaver Johannes Oberhumer\n");
printf("http://www.oberhumer.com/opensource/ucl/\n\n");
/*
* Step 1: initialize the UCL library
*/
if (ucl_init() != UCL_E_OK)
{
printf("internal error - ucl_init() failed !!!\n");
printf("(this usually indicates a compiler bug - try recompiling\nwithout optimizations, and enable `-DUCL_DEBUG' for diagnostics)\n");
return 1;
}
/*
* Step 2: setup memory
*
* We want to compress the data block at `in' with length `in_len' to
* the block at `out'. Because the input block may be incompressible,
* we must provide a little more output space in case that compression
* is not possible.
*/
in_len = 256 * 1024L;
#if defined(ACC_MM_AHSHIFT)
/* reduce memory requirements for ancient 640kB DOS real-mode */
if (ACC_MM_AHSHIFT != 3)
in_len = 16 * 1024L;
#endif
out_len = in_len + in_len / 8 + 256;
in = (ucl_bytep) ucl_malloc(in_len);
out = (ucl_bytep) ucl_malloc(out_len);
if (in == NULL || out == NULL)
{
printf("out of memory\n");
return 2;
}
/*
* Step 3: prepare the input block that will get compressed.
* We just fill it with zeros in this example program,
* but you would use your real-world data here.
*/
ucl_memset(in, 0, in_len);
/*
* Step 4: compress from `in' to `out' with UCL NRV2B
*/
r = ucl_nrv2b_99_compress(in,in_len,out,&out_len,NULL,level,NULL,NULL);
if (r == UCL_E_OUT_OF_MEMORY)
{
printf("out of memory in compress\n");
return 3;
}
if (r == UCL_E_OK)
printf("compressed %lu bytes into %lu bytes\n",
(long) in_len, (long) out_len);
else
{
/* this should NEVER happen */
printf("internal error - compression failed: %d\n", r);
return 4;
}
/* check for an incompressible block */
if (out_len >= in_len)
{
printf("This block contains incompressible data.\n");
return 0;
}
/*
* Step 5: decompress again, now going back from `out' to `in'
*/
new_len = in_len;
#if defined(UCL_USE_ASM)
r = ucl_nrv2b_decompress_asm_8(out,out_len,in,&new_len,NULL);
#else
r = ucl_nrv2b_decompress_8(out,out_len,in,&new_len,NULL);
#endif
if (r == UCL_E_OK && new_len == in_len)
printf("decompressed %lu bytes back into %lu bytes\n",
(long) out_len, (long) in_len);
else
{
/* this should NEVER happen */
printf("internal error - decompression failed: %d\n", r);
return 5;
}
ucl_free(out);
ucl_free(in);
printf("\n");
#if defined(UCL_USE_ASM)
printf("i386 assembler version is enabled.\n");
#endif
printf("Simple compression test passed.\n");
return 0;
}
None.
Side effects:
None.
*/
char *
ucl_strtok_constructor (strtok_t *this, size_t size)
{
char * ptr;
ptr = (char *) ucl_malloc(sizeof(char) * size);
if (ptr)
{
this->size = size;
this->len = 0;
this->ptr = ptr;
memset(ptr, '\0', sizeof(char) * size);
}
return ptr;
}
/* ucl_strtok_destructor --
Destroys the string token structure. The dynamically allocated