static gdImagePtr _gd2CreateFromFile (gdIOCtxPtr in, int *sx, int *sy, int *cs, int *vers, int *fmt, int *ncx, int *ncy, t_chunk_info ** cidx)
{
gdImagePtr im;
if (_gd2GetHeader (in, sx, sy, cs, vers, fmt, ncx, ncy, cidx) != 1) {
GD2_DBG(gd_error("Bad GD2 header"));
goto fail1;
}
if (gd2_truecolor(*fmt)) {
im = gdImageCreateTrueColor(*sx, *sy);
} else {
im = gdImageCreate(*sx, *sy);
}
if (im == NULL) {
GD2_DBG(gd_error("Could not create gdImage"));
goto fail2;
}
if (!_gdGetColors(in, im, (*vers) == 2)) {
GD2_DBG(gd_error("Could not read color palette"));
goto fail3;
}
GD2_DBG(gd_error("Image palette completed: %d colours", im->colorsTotal));
return im;
fail3:
gdImageDestroy(im);
fail2:
gdFree(*cidx);
fail1:
return 0;
}
/* gdImageWBMPCtx
* --------------
* Write the image as a wbmp file
* Parameters are:
* image: gd image structure;
* fg: the index of the foreground color. any other value will be
* considered as background and will not be written
* out: the stream where to write
*/
BGD_DECLARE(void) gdImageWBMPCtx(gdImagePtr image, int fg, gdIOCtx *out)
{
int x, y, pos;
Wbmp *wbmp;
/* create the WBMP */
if((wbmp = createwbmp(gdImageSX(image), gdImageSY(image), WBMP_WHITE)) == NULL) {
gd_error("Could not create WBMP\n");
return;
}
/* fill up the WBMP structure */
pos = 0;
for(y = 0; y < gdImageSY(image); y++) {
for(x = 0; x < gdImageSX(image); x++) {
if(gdImageGetPixel(image, x, y) == fg) {
wbmp->bitmap[pos] = WBMP_BLACK;
}
pos++;
}
}
/* write the WBMP to a gd file descriptor */
if(writewbmp(wbmp, &gd_putout, out)) {
gd_error("Could not save WBMP\n");
}
/* des submitted this bugfix: gdFree the memory. */
freewbmp(wbmp);
}
static void jpeg_emit_message(j_common_ptr jpeg_info, int level)
{
char message[JMSG_LENGTH_MAX];
jmpbuf_wrapper *jmpbufw;
int ignore_warning = 0;
jmpbufw = (jmpbuf_wrapper *) jpeg_info->client_data;
if (jmpbufw != 0) {
ignore_warning = jmpbufw->ignore_warning;
}
(jpeg_info->err->format_message)(jpeg_info,message);
/* It is a warning message */
if (level < 0) {
/* display only the 1st warning, as would do a default libjpeg
* unless strace_level >= 3
*/
if ((jpeg_info->err->num_warnings == 0) || (jpeg_info->err->trace_level >= 3)) {
if (!ignore_warning) {
gd_error("gd-jpeg, libjpeg: recoverable error: %s\n", message);
}
}
jpeg_info->err->num_warnings++;
} else {
/* strace msg, Show it if trace_level >= level. */
if (jpeg_info->err->trace_level >= level) {
if (!ignore_warning) {
gd_error("gd-jpeg, libjpeg: strace message: %s\n", message);
}
}
}
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *data = "dirfile/data";
const char *count = "dirfile/count";
const char *format_data =
"mplex MPLEX data count 7 8\n"
"count RAW UINT8 8\n"
"data RAW UINT8 8\n";
unsigned char c[8];
unsigned char data_data[256];
int fd, n, i, e1, e2, r = 0;
DIRFILE *D;
rmdirfile();
mkdir(filedir, 0777);
fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format_data, strlen(format_data));
close(fd);
for (fd = 0; fd < 256; ++fd)
data_data[fd] = (unsigned char)fd;
data_data[0] = 111;
fd = open(data, O_CREAT | O_EXCL | O_WRONLY | O_BINARY, 0666);
write(fd, data_data, 256);
close(fd);
for (fd = 0; fd < 256; ++fd)
data_data[fd] %= 3;
data_data[0] = 7;
fd = open(count, O_CREAT | O_EXCL | O_WRONLY | O_BINARY, 0666);
write(fd, data_data, 256);
close(fd);
D = gd_open(filedir, GD_RDONLY | GD_VERBOSE);
gd_mplex_lookback(D, GD_LOOKBACK_ALL);
e1 = gd_error(D);
n = gd_getdata(D, "mplex", 12, 0, 1, 0, GD_UINT8, &c);
e2 = gd_error(D);
gd_close(D);
unlink(count);
unlink(data);
unlink(format);
rmdir(filedir);
CHECKI(e1, 0);
CHECKI(e2, 0);
CHECKI(n, 8);
for (i = 0; i < 8; ++i)
CHECKIi(i, c[i], 111);
return r;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *format_data =
"early PHASE data 0\n"
"late PHASE data 0\n"
"/ALIAS bata data\n"
"data RAW UINT8 8\n";
int fd, e1, e2, e3, e4, r = 0;
char *s1, *s2, *s3;
DIRFILE *D;
gd_entry_t E;
rmdirfile();
mkdir(filedir, 0777);
fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format_data, strlen(format_data));
close(fd);
D = gd_open(filedir, GD_RDWR);
gd_validate(D, "early");
gd_rename(D, "data", "zata", GD_REN_UPDB);
e1 = gd_error(D);
gd_spf(D, "early");
e2 = gd_error(D);
gd_spf(D, "late");
e3 = gd_error(D);
gd_entry(D, "early", &E);
s1 = E.in_fields[0];
E.in_fields[0] = NULL;
gd_free_entry_strings(&E);
gd_entry(D, "late", &E);
s2 = E.in_fields[0];
E.in_fields[0] = NULL;
gd_free_entry_strings(&E);
gd_entry(D, "bata", &E);
e4 = gd_error(D);
s3 = strdup(gd_alias_target(D, "bata"));
gd_discard(D);
unlink(format);
rmdir(filedir);
CHECKI(e1,0);
CHECKI(e2,0);
CHECKI(e3,0);
CHECKI(e4,0);
CHECKS(s1, "zata");
CHECKS(s2, "zata");
CHECKS(s3, "zata");
return r;
}
/*
Function: gdImageGd2Ptr
*/
BGD_DECLARE(void *) gdImageGd2Ptr (gdImagePtr im, int cs, int fmt, int *size)
{
void *rv;
gdIOCtx *out = gdNewDynamicCtx (2048, NULL);
if (out == NULL) return NULL;
_gdImageGd2 (im, out, cs, fmt);
rv = gdDPExtractData (out, size);
out->gd_free (out);
return rv;
}
#else /* no HAVE_LIBZ or !ENABLE_GD_FORMATS */
static void _noGd2Error (void)
{
#if !ENABLE_GD_FORMATS
gd_error("GD2 image support has been disabled\n");
#else
gd_error("GD2 support is not available - no libz\n");
#endif
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *format_data =
"REFERENCE data1\n"
"data1 RAW UINT8 1\n"
"data2 RAW UINT8 1\n"
"REFERENCE data2\n"
;
const char *data1 = "dirfile/data1";
const char *data2 = "dirfile/data2";
uint8_t data_data[4] = { 0, 1, 2, 3 };
int fd, error, error2, r = 0;
DIRFILE *D;
off_t nf;
rmdirfile();
mkdir(filedir, 0777);
fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format_data, strlen(format_data));
close(fd);
fd = open(data1, O_CREAT | O_EXCL | O_WRONLY | O_BINARY, 0666);
write(fd, data_data, 4);
close(fd);
fd = open(data2, O_CREAT | O_EXCL | O_WRONLY | O_BINARY, 0666);
write(fd, data_data, 3);
close(fd);
D = gd_open(filedir, GD_RDONLY | GD_VERBOSE);
error = gd_error(D);
CHECKI(error, 0);
nf = gd_nframes(D);
error2 = gd_error(D);
CHECKI(error2, 0);
CHECKI(nf,3);
gd_close(D);
unlink(format);
unlink(data1);
unlink(data2);
rmdir(filedir);
return r;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *format1 = "dirfile/format1";
const char *format_data =
"data RAW UINT16 2\n"
"/FRAMEOFFSET 35\n"
"lincom LINCOM 2 data2 1. 0. data 1. 0.\n"
"lincom2 LINCOM 2 data 1. 0. data2 1. 0.\n"
"INCLUDE format1\n";
const char *format1_data = "data2 RAW UINT8 3\nFRAMEOFFSET 33\n";
int fd, error1, error2, error3, error4, r = 0;
off_t bof_data, bof_data2, bof_lincom, bof_lincom2;
DIRFILE *D;
rmdirfile();
mkdir(filedir, 0777);
fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format_data, strlen(format_data));
close(fd);
fd = open(format1, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format1_data, strlen(format1_data));
close(fd);
D = gd_open(filedir, GD_RDONLY);
bof_data = gd_bof(D, "data");
error1 = gd_error(D);
bof_data2 = gd_bof(D, "data2");
error2 = gd_error(D);
bof_lincom = gd_bof(D, "lincom");
error3 = gd_error(D);
bof_lincom2 = gd_bof(D, "lincom2");
error4 = gd_error(D);
gd_close(D);
unlink(format1);
unlink(format);
rmdir(filedir);
CHECKI(error1, 0);
CHECKI(bof_data, 70);
CHECKI(error2, 0);
CHECKI(bof_data2, 99);
CHECKI(error3, 0);
CHECKI(bof_lincom, 105);
CHECKI(error4, 0);
CHECKI(bof_lincom2, 70);
return r;
}
int overflow2(int a, int b)
{
if(a <= 0 || b <= 0) {
gd_error("gd warning: one parameter to a memory allocation multiplication is negative or zero, failing operation gracefully\n");
return 1;
}
if(a > INT_MAX / b) {
gd_error("gd warning: product of memory allocation multiplication would exceed INT_MAX, failing operation gracefully\n");
return 1;
}
return 0;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *format_data =
"raw1 RAW UINT8 1\n"
"META raw1 linterp1 LINTERP raw2 table\n"
"META raw1 linterp2 LINTERP raw3 table\n"
"META raw1 linterp3 LINTERP raw4 table\n"
"META raw1 const CONST UINT8 1\n"
"META raw1 string STRING value\n"
"META raw1 string2 STRING value\n"
"raw2 RAW UINT8 1\n"
"raw3 RAW UINT8 1\n"
"raw4 RAW UINT8 1\n"
"const CONST UINT8 1\n"
"string STRING value\n"
"string2 STRING value\n";
int fd, error, error2, error3, r = 0;
unsigned int nvec, nvec2, nvec3;
DIRFILE *D;
rmdirfile();
mkdir(filedir, 0777);
fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format_data, strlen(format_data));
close(fd);
D = gd_open(filedir, GD_RDWR | GD_VERBOSE);
nvec = gd_nmvectors(D, "raw1");
error = gd_error(D);
gd_delete(D, "raw1/linterp3", 0);
nvec2 = gd_nmvectors(D, "raw1");
error2 = gd_error(D);
gd_delete(D, "raw1/string", 0);
nvec3 = gd_nmvectors(D, "raw1");
error3 = gd_error(D);
gd_discard(D);
unlink(format);
rmdir(filedir);
CHECKI(error,0);
CHECKI(nvec,3);
CHECKI(error2,0);
CHECKI(nvec2,2);
CHECKI(error3,0);
CHECKI(nvec3,2);
return r;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
int error, r = 0;
DIRFILE *D;
gd_entry_t E, e;
E.field = "data";
E.field_type = GD_LINCOM_ENTRY;
E.fragment_index = 0;
E.EN(lincom,n_fields) = 1;
E.comp_scal = 0;
E.in_fields[0] = "INDEX";
E.EN(lincom,m)[0] = 1.;
E.scalar[0] = NULL;
E.scalar[0 + GD_MAX_LINCOM] = "c";
E.scalar_ind[0 + GD_MAX_LINCOM] = 3;
rmdirfile();
D = gd_open(filedir, GD_RDWR | GD_CREAT | GD_VERBOSE);
gd_add_spec(D, "c CARRAY INT64 1 2 3 4", 0);
gd_add(D, &E);
error = gd_error(D);
/* check */
gd_entry(D, "data", &e);
if (gd_error(D))
r = 1;
else {
CHECKI(e.field_type, GD_LINCOM_ENTRY);
CHECKI(e.fragment_index, 0);
CHECKI(e.EN(lincom,n_fields), 1);
CHECKF(e.EN(lincom,m)[0], 1);
CHECKF(e.EN(lincom,b)[0], 4);
CHECKP(e.scalar[0]);
CHECKS(e.scalar[0 + GD_MAX_LINCOM], "c");
CHECKI(e.scalar_ind[0 + GD_MAX_LINCOM], 3);
gd_free_entry_strings(&e);
}
gd_close(D);
unlink(format);
rmdir(filedir);
CHECKI(error, GD_E_OK);
return r;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *data = "dirfile/data";
int error, ge_error, n, r = 0;
gd_entry_t e;
DIRFILE *D;
gd_entry_t E;
memset(&E, 0, sizeof(E));
E.field = "data";
E.field_type = GD_RAW_ENTRY;
E.fragment_index = 0;
E.EN(raw,spf) = 2;
E.EN(raw,data_type) = GD_UINT8;
rmdirfile();
D = gd_open(filedir, GD_RDWR | GD_CREAT | GD_VERBOSE);
gd_add(D, &E);
E.field_type = GD_CONST_ENTRY;
E.EN(scalar,const_type) = GD_UINT8;
E.fragment_index = 99;
gd_madd(D, &E, "data");
error = gd_error(D);
/* check */
n = gd_nfields(D);
gd_entry(D, "data/data", &e);
ge_error = gd_error(D);
gd_close(D);
unlink(data);
unlink(format);
rmdir(filedir);
CHECKI(error, GD_E_OK);
CHECKI(ge_error, 0);
CHECKI(n, 2);
if (!r) {
CHECKI(e.field_type, GD_CONST_ENTRY);
CHECKI(e.fragment_index, 0);
CHECKI(e.EN(scalar,const_type), GD_UINT8);
gd_free_entry_strings(&e);
}
return r;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
int r = 0;
int error, j;
gd_entry_t e;
DIRFILE *D;
#ifdef GD_NO_C99_API
const double a[8] = {1, 29.03, 0.3, 12.34, 0.5, 99.55, 1.8, 45.32};
#else
const double complex a[4] = {1 + _Complex_I * 29.03, 0.3 + _Complex_I * 12.34,
0.5 + _Complex_I * 99.55, 1.8 + _Complex_I * 45.32};
#endif
rmdirfile();
D = gd_open(filedir, GD_RDWR | GD_CREAT | GD_VERBOSE);
gd_add_cpolynom(D, "new", 3, "in", a, 0);
error = gd_error(D);
/* check */
gd_entry(D, "new", &e);
if (gd_error(D))
r = 1;
else {
CHECKI(e.field_type, GD_POLYNOM_ENTRY);
CHECKS(e.in_fields[0], "in");
CHECKI(e.fragment_index, 0);
CHECKI(e.EN(polynom,poly_ord), 3);
CHECKI(e.comp_scal, 1);
for (j = 0; j < 4; ++j) {
#ifdef GD_NO_C99_API
CHECKCi(j,e.EN(polynom,ca)[j], a + 2 * j);
#else
CHECKCi(j,e.EN(polynom,ca)[j], a[j]);
#endif
}
gd_free_entry_strings(&e);
}
gd_close(D);
unlink(format);
rmdir(filedir);
CHECKI(error, GD_E_OK);
return r;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format1 = "dirfile/format1";
const char *format1_data = "data RAW UINT8 11\n";
int fd, error, r = 0;
DIRFILE *D;
rmdirfile();
mkdir(filedir, 0777);
fd = open(format1, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format1_data, strlen(format1_data));
close(fd);
D = gd_open(filedir, GD_RDONLY);
gd_include(D, "format1", 0, 0);
error = gd_error(D);
gd_close(D);
unlink(format1);
rmdir(filedir);
CHECKI(error, GD_E_BAD_DIRFILE);
return r;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *format_data = "lincom LINCOM in1 1 0 in2\n";
int fd, error, r = 0;
DIRFILE *D;
rmdirfile();
mkdir(filedir, 0777);
fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format_data, strlen(format_data));
close(fd);
D = gd_open(filedir, GD_RDONLY);
error = gd_error(D);
gd_close(D);
unlink(format);
rmdir(filedir);
CHECKI(error,GD_E_FORMAT);
return r;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *format_data = "const CONST FLOAT64 8.3\n";
double c;
int fd, n, error, r = 0;
DIRFILE *D;
rmdirfile();
mkdir(filedir, 0777);
fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format_data, strlen(format_data));
close(fd);
D = gd_open(filedir, GD_RDONLY | GD_VERBOSE);
n = gd_get_constant(D, "const", GD_FLOAT64, &c);
error = gd_error(D);
gd_close(D);
unlink(format);
rmdir(filedir);
CHECKI(error, 0);
CHECKI(n, 0);
CHECKF(c, 8.3);
return r;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *format_data =
"data RAW UINT8 1\n"
"cata CONST UINT8 1\n"
"/ALIAS data/eata cata\n";
int fd, error, r = 0;
DIRFILE *D;
rmdirfile();
mkdir(filedir, 0777);
fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format_data, strlen(format_data));
close(fd);
D = gd_open(filedir, GD_RDONLY | GD_VERBOSE);
error = gd_error(D);
gd_discard(D);
unlink(format);
rmdir(filedir);
CHECKI(error,0);
return r;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *format_data =
"parent RAW UINT8 1\n"
"const CONST UINT8 1\n"
"ALIAS parent/alias const\n"
"META parent/alias grandchild CONST UINT8 1\n";
int fd, error, r = 0;
DIRFILE *D;
rmdirfile();
mkdir(filedir, 0777);
fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format_data, strlen(format_data));
close(fd);
D = gd_open(filedir, GD_RDONLY);
error = gd_error(D);
gd_close(D);
unlink(format);
rmdir(filedir);
CHECKI(error,GD_E_FORMAT);
return r;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
int error, n, m, r = 0;
DIRFILE *D;
rmdirfile();
D = gd_open(filedir, GD_RDWR | GD_CREAT);
gd_madd_spec(D, "META INDEX RAW UINT8 2", "INDEX");
error = gd_error(D);
/* check */
n = gd_nfields(D);
m = gd_nmfields(D, "INDEX");
gd_close(D);
unlink(format);
rmdir(filedir);
CHECKI(n, 1);
CHECKI(m, 0);
CHECKI(error, GD_E_FORMAT);
return r;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *format_data = "/ALIAS alias target\n/ALIAS target next\n";
int fd, e, r = 0;
DIRFILE *D;
const char *t;
rmdirfile();
mkdir(filedir, 0777);
fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format_data, strlen(format_data));
close(fd);
D = gd_open(filedir, GD_RDONLY | GD_VERBOSE);
t = gd_alias_target(D, "alias");
CHECKS(t, "target");
e = gd_error(D);
CHECKI(e, GD_E_OK);
gd_close(D);
unlink(format);
rmdir(filedir);
return r;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
int error, n, r = 0;
DIRFILE *D;
rmdirfile();
D = gd_open(filedir, GD_RDWR | GD_CREAT);
gd_add_bit(D, "new", "input", 1, 99, 0);
error = gd_error(D);
/* check */
n = gd_nfields(D);
gd_close(D);
unlink(format);
rmdir(filedir);
CHECKI(n, 1);
CHECKI(error, GD_E_BAD_ENTRY);
return r;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
uint8_t val[] = {0, 0, 0, 0, 0, 0, 0, 0};
int r = 0, error, i;
DIRFILE *D;
rmdirfile();
D = gd_open(filedir, GD_RDWR | GD_CREAT | GD_VERBOSE);
gd_add_carray(D, "data", GD_UINT8, 8, GD_UINT8, &val, 0);
for (i = 0; i < 8; ++i)
val[i] = i * (i + 1);
gd_put_carray_slice(D, "data", 2, 3, GD_UINT8, &val);
error = gd_error(D);
gd_close(D);
/* check */
memset(val, 0, 8);
D = gd_open(filedir, GD_RDONLY | GD_VERBOSE);
gd_get_carray(D, "data", GD_UINT8, &val);
gd_close(D);
unlink(format);
rmdir(filedir);
for (i = 0; i < 8; ++i)
if (i >= 2 && i <= 4) {
CHECKIi(i, val[i], (i - 2) * (i - 1));
} else
CHECKIi(i, val[i], 0);
CHECKI(error,GD_E_OK);
return r;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
int error, n, r = 0;
gd_entry_t E;
DIRFILE *D;
E.field = "ne/w";
E.field_type = GD_RAW_ENTRY;
E.fragment_index = 0;
E.EN(raw,spf) = 2;
E.EN(raw,data_type) = GD_UINT8;
rmdirfile();
D = gd_open(filedir, GD_RDWR | GD_CREAT);
gd_add(D, &E);
error = gd_error(D);
/* check */
n = gd_nfields(D);
gd_close(D);
unlink(format);
rmdir(filedir);
CHECKI(n, 1);
CHECKI(error, GD_E_BAD_CODE);
return r;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *format_data = "ENDIAN badendianness\n";
int fd, error, r = 0;
DIRFILE *D;
rmdirfile();
mkdir(filedir, 0777);
fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format_data, strlen(format_data));
close(fd);
D = gd_open(filedir, GD_RDONLY | GD_FORCE_ENDIAN | GD_VERBOSE);
error = gd_error(D);
gd_close(D);
unlink(format);
rmdir(filedir);
CHECKI(error,GD_E_OK);
return r;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *format_data = "data RAW UINT8 8\n"
"META data e CONST UINT8 1\n"
"META data q CONST UINT8 2\n"
"META data a CONST UINT8 3\n"
"META data b CONST UINT8 4\n"
"META data z CONST UINT8 5\n"
"META data l CONST UINT8 6\n";
int fd, ret, error, r = 0;
DIRFILE *D;
rmdirfile();
mkdir(filedir, 0777);
fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format_data, strlen(format_data));
close(fd);
D = gd_open(filedir, GD_RDWR);
ret = gd_delete(D, "data", 0);
error = gd_error(D);
gd_close(D);
unlink(format);
rmdir(filedir);
CHECKI(error, GD_E_DELETE);
CHECKI(ret, -1);
return r;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *format_data = "carray CARRAY FLOAT64 8.3 7.2 6.1 5.0 3.9 2.8 1.7\n";
double c[7];
int fd, i, n, error, r = 0;
DIRFILE *D;
rmdirfile();
mkdir(filedir, 0777);
fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format_data, strlen(format_data));
close(fd);
D = gd_open(filedir, GD_RDONLY | GD_VERBOSE);
n = gd_get_carray(D, "carray", GD_FLOAT64, c);
error = gd_error(D);
gd_close(D);
unlink(format);
rmdir(filedir);
CHECKI(error, 0);
CHECKI(n, 0);
for (i = 0; i < 7; ++i)
CHECKFi(i, c[i], 8.3 - i * 1.1);
return r;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *format_data = "data RAW UINT8 8\n";
int fd, n, h, m, error, r = 0;
DIRFILE *D;
rmdirfile();
mkdir(filedir, 0777);
fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format_data, strlen(format_data));
close(fd);
D = gd_open(filedir, GD_RDWR | GD_VERBOSE);
n = gd_nfields(D);
h = gd_hide(D, "data");
error = gd_error(D);
m = gd_nfields(D);
gd_close(D);
unlink(format);
rmdir(filedir);
CHECKI(error, GD_E_OK);
CHECKI(n, 2);
CHECKI(h, 0);
CHECKI(m, 1);
return r;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *format_data = "INCLUDE non_existent_file\n";
int fd, error, r = 0;
DIRFILE *D;
rmdirfile();
mkdir(filedir, 0777);
fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format_data, strlen(format_data));
close(fd);
D = gd_open(filedir, GD_RDONLY);
error = gd_error(D);
gd_close(D);
unlink(format);
rmdir(filedir);
CHECKI(error,GD_E_OPEN_INCLUDE);
return r;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *format_data = "data CONST UINT8 8\nPROTECT all\n";
uint8_t d = 3;
int fd, n, error, r = 0;
DIRFILE *D;
rmdirfile();
mkdir(filedir, 0777);
fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format_data, strlen(format_data));
close(fd);
D = gd_open(filedir, GD_RDWR | GD_UNENCODED);
n = gd_put_constant(D, "data", GD_UINT8, &d);
error = gd_error(D);
gd_close(D);
unlink(format);
rmdir(filedir);
CHECKI(error, GD_E_PROTECTED);
CHECKI(n, -1);
return r;
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *data = "dirfile/data";
int error, r = 0;
DIRFILE *D;
rmdirfile();
mkdir(filedir, 0777);
close(open(format, O_CREAT | O_EXCL | O_WRONLY, 0666));
close(open(data, O_CREAT | O_EXCL | O_WRONLY, 0666));
chmod(filedir, 0555);
/* ensure filesystem honours read-onlyness */
if (!unlink(data) || errno != EACCES) {
unlink(format);
rmdir(filedir);
return 77;
}
D = gd_open(filedir, GD_RDWR | GD_TRUNC);
error = gd_error(D);
gd_discard(D);
chmod(filedir, 0777);
unlink(data);
unlink(format);
rmdir(filedir);
CHECKI(error, GD_E_TRUNC);
return r;
}
