[Getdata-commits] SF.net SVN: getdata:[889] trunk/getdata
Scientific Database Format
Brought to you by:
ketiltrout
Menu
▾
▴
[Getdata-commits] SF.net SVN: getdata:[889] trunk/getdata
|
From: <ket...@us...> - 2014-04-30 18:10:30
|
Revision: 889
http://sourceforge.net/p/getdata/code/889
Author: ketiltrout
Date: 2014-04-30 18:10:25 +0000 (Wed, 30 Apr 2014)
Log Message:
-----------
Bump DSV. INDIR and SINDIR.
Modified Paths:
--------------
trunk/getdata/ChangeLog
trunk/getdata/src/add.c
trunk/getdata/src/common.c
trunk/getdata/src/del.c
trunk/getdata/src/entry.c
trunk/getdata/src/errors.c
trunk/getdata/src/flimits.c
trunk/getdata/src/flush.c
trunk/getdata/src/fpos.c
trunk/getdata/src/getdata.c
trunk/getdata/src/getdata.h.in
trunk/getdata/src/internal.h
trunk/getdata/src/legacy.c
trunk/getdata/src/mod.c
trunk/getdata/src/name.c
trunk/getdata/src/native.c
trunk/getdata/src/parse.c
trunk/getdata/src/putdata.c
trunk/getdata/src/spf.c
trunk/getdata/src/string.c
trunk/getdata/test/Makefile.am
trunk/getdata/test/name_updb.c
trunk/getdata/test/native_const.c
trunk/getdata/test/version_9_strict.c
trunk/getdata/test/version_9_write.c
Added Paths:
-----------
trunk/getdata/test/add_indir.c
trunk/getdata/test/add_sarray_nil.c
trunk/getdata/test/add_sindir.c
trunk/getdata/test/alter_entry_sarray.c
trunk/getdata/test/alter_indir.c
trunk/getdata/test/alter_sindir.c
trunk/getdata/test/get_indir.c
trunk/getdata/test/get_sindir.c
trunk/getdata/test/getstr_here.c
trunk/getdata/test/getstr_sindir.c
trunk/getdata/test/getstr_type.c
trunk/getdata/test/madd_indir.c
trunk/getdata/test/madd_sindir.c
trunk/getdata/test/name_updb_carray.c
trunk/getdata/test/name_updb_sarray.c
trunk/getdata/test/parse_indir.c
trunk/getdata/test/parse_sindir.c
trunk/getdata/test/put_indir.c
trunk/getdata/test/put_sindir.c
Property Changed:
----------------
trunk/getdata/test/
Modified: trunk/getdata/ChangeLog
===================================================================
--- trunk/getdata/ChangeLog 2014-04-27 21:29:36 UTC (rev 888)
+++ trunk/getdata/ChangeLog 2014-04-30 18:10:25 UTC (rev 889)
@@ -1,5 +1,46 @@
-2014-04-03 D. V. Wiebe <ge...@ke...> svn:887
+2014-04-30 D. V. Wiebe <ge...@ke...> svn:889
+ * test/parse_indir.c test/get_sindir.c test/alter_entry_sarray.c
+ test/add_sindir.c test/getstr_sindir.c test/name_updb_sarray.c
+ test/add_indir.c test/get_indir.c test/getstr_here.c test/alter_sindir.c
+ test/parse_sindir.c test/alter_indir.c test/getstr_type.c
+ test/name_updb_carray.c test/madd_sindir.c test/put_indir.c
+ test/put_sindir.c test/madd_indir.c test/add_sarray_nil.c: Added.
+ * test/name_updb.c test/native_const.c: Update.
+
* src/entry.c (_GD_FreeE _GD_CalculateEntry gd_entry gd_validate)
+ src/legacy.c (GetFormat) src/getdata.c (_GD_DoField gd_getdata64) src/name.c
+ (_GD_UpdateInputs) src/flush.c (_GD_Flush _GD_FieldSpec _GD_FindVersion)
+ src/native.c (_GD_NativeType) src/spf.c (_GD_GetSPF) src/putdata.c
+ (_GD_DoFieldOut) src/del.c (_GD_ClearDerived _GD_DeReference _GD_Delete)
+ src/flimits.c (_GD_GetEOF _GD_GetBOF) src/fpos.c (_GD_GetFilePos _GD_Seek)
+ src/parse.c (_GD_ParseFieldSpec) src/mod.c (_GD_Change) src/add.c
+ (_GD_InvalidEntype _GD_Add): Handle INDIR and SINDIR.
+ * src/getdata.c (_GD_IndirData _GD_DoIndir gd_getstrdata64 gd_getdata64)
+ src/parse.c (_GD_ParseYoke) src/mod.c (_GD_AlterYoke gd_alter_indir
+ gd_alter_sindir) src/add.c (_GD_AddYoke gd_add_indir gd_add_sindir
+ _GD_MAddYoke gd_madd_indir gd_madd_sindir): Added.
+ * src/common.c (_GD_BadInput): Add entry type parameter and allow non-vector
+ input fields.
+
+ * src/parse.c (_GD_ParseDivide _GD_ParseMultiply): Deleted (merged into
+ _GD_ParseYoke).
+ * src/mod.c (gd_alter_divide gd_alter_multiply): Call _GD_AlterYoke.
+ * src/add.c (gd_add_multiply gd_add_divide): Call _GD_AddYoke.
+ * src/add.c (gd_madd_multiply gd_madd_divide): Call _GD_MAddYoke.
+
+ * src/errors.c: Add GD_E_FIELD_FORMAT and GD_E_FIELD_STR.
+
+ * src/native.c (_GD_NativeType): Return internal type for CONST/CARRAY not
+ storage type (ie. run it through _GD_ConstType).
+
+ * src/string.c (gd_get_sarray_slice gd_get_sarray) src/mod.c (_GD_Change)
+ src/add.c (_GD_Add): Nilify new SARRAYs on creation, not on read.
+
+ * src/getdata.h.in: Bump GD_DIRFILE_STANDARDS_VERSION. Add GD_INDIR_ENTRY
+ and GD_SINDIR_ENTRY.
+
+2014-04-27 D. V. Wiebe <ge...@ke...> svn:887
+ * src/entry.c (_GD_FreeE _GD_CalculateEntry gd_entry gd_validate)
src/legacy.c (GetFormat) src/getdata.c (_GD_DoField) src/name.c
(_GD_UpdateInputs) src/flush.c (_GD_Flush _GD_FieldSpec _GD_FindVersion)
src/native.c (_GD_NativeType) src/spf.c (_GD_GetSPF) src/putdata.c
Modified: trunk/getdata/src/add.c
===================================================================
--- trunk/getdata/src/add.c 2014-04-27 21:29:36 UTC (rev 888)
+++ trunk/getdata/src/add.c 2014-04-30 18:10:25 UTC (rev 889)
@@ -28,7 +28,7 @@
t != GD_CONST_ENTRY && t != GD_POLYNOM_ENTRY && t != GD_SBIT_ENTRY &&
t != GD_DIVIDE_ENTRY && t != GD_RECIP_ENTRY && t != GD_WINDOW_ENTRY &&
t != GD_MPLEX_ENTRY && t != GD_CARRAY_ENTRY && t != GD_STRING_ENTRY &&
- t != GD_SARRAY_ENTRY)
+ t != GD_SARRAY_ENTRY && t != GD_INDIR_ENTRY && t != GD_SINDIR_ENTRY)
{
dreturn("%i", -1);
return -1;
@@ -131,6 +131,7 @@
int i, is_dot, offset;
void *new_list;
void *new_ref = NULL;
+ size_t z;
unsigned int u;
unsigned mask;
gd_entry_t *E;
@@ -364,6 +365,8 @@
break;
case GD_MULTIPLY_ENTRY:
case GD_DIVIDE_ENTRY:
+ case GD_INDIR_ENTRY:
+ case GD_SINDIR_ENTRY:
if (_GD_CheckCodeAffixes(D, NULL, entry->in_fields[0],
entry->fragment_index, 1) || _GD_CheckCodeAffixes(D, NULL,
entry->in_fields[1], entry->fragment_index, 1))
@@ -509,17 +512,13 @@
}
break;
case GD_SARRAY_ENTRY:
- E->EN(scalar,const_type) = GD_NULL;
E->EN(scalar,array_len) = entry->EN(scalar,array_len);
- if (E->EN(scalar,array_len) > GD_MAX_CARRAY_LENGTH)
- _GD_SetError(D, GD_E_BOUNDS, 0, NULL, 0, NULL);
- else {
- size_t size = sizeof(const char *) * E->EN(scalar,array_len);
- E->e->u.scalar.d = _GD_Malloc(D, size);
- if (E->e->u.scalar.d)
- memset(E->e->u.scalar.d, 0, size);
- }
+ E->e->u.scalar.d = _GD_Malloc(D,
+ sizeof(const char *) * E->EN(scalar,array_len));
+ if (E->e->u.scalar.d)
+ for (z = 0; z < E->EN(scalar,array_len); ++z)
+ ((const char**)E->e->u.scalar.d)[z] = _GD_Strdup(D, "");
break;
case GD_STRING_ENTRY:
E->e->u.string = _GD_Strdup(D, "");
@@ -1008,15 +1007,14 @@
return error;
}
-/* add a MULTIPLY entry */
-int gd_add_multiply(DIRFILE* D, const char* field_code, const char* in_field1,
- const char* in_field2, int fragment_index) gd_nothrow
+static int _GD_AddYoke(DIRFILE* D, gd_entype_t t, const char* field_code,
+ const char* in_field1, const char* in_field2, int fragment_index) gd_nothrow
{
gd_entry_t M;
int error;
- dtrace("%p, \"%s\", \"%s\", \"%s\", %i", D, field_code, in_field1, in_field2,
- fragment_index);
+ dtrace("%p, 0x%X, \"%s\", \"%s\", \"%s\", %i", D, t, field_code, in_field1,
+ in_field2, fragment_index);
if (D->flags & GD_INVALID) {/* don't crash */
_GD_SetError(D, GD_E_BAD_DIRFILE, 0, NULL, 0, NULL);
@@ -1026,7 +1024,7 @@
memset(&M, 0, sizeof(gd_entry_t));
M.field = (char *)field_code;
- M.field_type = GD_MULTIPLY_ENTRY;
+ M.field_type = t;
M.in_fields[0] = (char *)in_field1;
M.in_fields[1] = (char *)in_field2;
M.fragment_index = fragment_index;
@@ -1036,32 +1034,32 @@
return error;
}
-/* add a DIVIDE entry */
+int gd_add_multiply(DIRFILE* D, const char* field_code, const char* in_field1,
+ const char* in_field2, int fragment_index) gd_nothrow
+{
+ return _GD_AddYoke(D, GD_MULTIPLY_ENTRY, field_code, in_field1, in_field2,
+ fragment_index);
+}
+
int gd_add_divide(DIRFILE* D, const char* field_code, const char* in_field1,
const char* in_field2, int fragment_index) gd_nothrow
{
- gd_entry_t E;
- int error;
+ return _GD_AddYoke(D, GD_DIVIDE_ENTRY, field_code, in_field1, in_field2,
+ fragment_index);
+}
- dtrace("%p, \"%s\", \"%s\", \"%s\", %i", D, field_code, in_field1, in_field2,
+int gd_add_indir(DIRFILE* D, const char* field_code, const char* in_field1,
+ const char* in_field2, int fragment_index) gd_nothrow
+{
+ return _GD_AddYoke(D, GD_INDIR_ENTRY, field_code, in_field1, in_field2,
fragment_index);
+}
- if (D->flags & GD_INVALID) {/* don't crash */
- _GD_SetError(D, GD_E_BAD_DIRFILE, 0, NULL, 0, NULL);
- dreturn("%i", -1);
- return -1;
- }
-
- memset(&E, 0, sizeof(gd_entry_t));
- E.field = (char *)field_code;
- E.field_type = GD_DIVIDE_ENTRY;
- E.in_fields[0] = (char *)in_field1;
- E.in_fields[1] = (char *)in_field2;
- E.fragment_index = fragment_index;
- error = (_GD_Add(D, &E, NULL) == NULL) ? -1 : 0;
-
- dreturn("%i", error);
- return error;
+int gd_add_sindir(DIRFILE* D, const char* field_code, const char* in_field1,
+ const char* in_field2, int fragment_index) gd_nothrow
+{
+ return _GD_AddYoke(D, GD_SINDIR_ENTRY, field_code, in_field1, in_field2,
+ fragment_index);
}
/* add a RECIP entry */
@@ -1660,14 +1658,14 @@
return error;
}
-/* add a META MULTIPLY entry */
-int gd_madd_multiply(DIRFILE* D, const char* parent, const char* field_code,
- const char* in_field1, const char* in_field2) gd_nothrow
+static int _GD_MAddYoke(DIRFILE* D, gd_entype_t t, const char* parent,
+ const char* field_code, const char* in_field1, const char* in_field2)
+gd_nothrow
{
gd_entry_t M;
int error;
- dtrace("%p, \"%s\", \"%s\", \"%s\", \"%s\"", D, field_code, parent,
+ dtrace("%p, 0x%X, \"%s\", \"%s\", \"%s\", \"%s\"", D, t, field_code, parent,
in_field1, in_field2);
if (D->flags & GD_INVALID) {/* don't crash */
@@ -1678,7 +1676,7 @@
memset(&M, 0, sizeof(gd_entry_t));
M.field = (char *)field_code;
- M.field_type = GD_MULTIPLY_ENTRY;
+ M.field_type = t;
M.in_fields[0] = (char *)in_field1;
M.in_fields[1] = (char *)in_field2;
M.fragment_index = 0;
@@ -1688,6 +1686,13 @@
return error;
}
+int gd_madd_multiply(DIRFILE* D, const char *parent, const char* field_code,
+ const char* in_field1, const char* in_field2) gd_nothrow
+{
+ return _GD_MAddYoke(D, GD_MULTIPLY_ENTRY, parent, field_code, in_field1,
+ in_field2);
+}
+
/* add a META PHASE entry */
int gd_madd_phase(DIRFILE* D, const char* parent, const char* field_code,
const char* in_field, gd_shift_t shift) gd_nothrow
@@ -1798,31 +1803,25 @@
return error;
}
-/* add a META DIVIDE entry */
int gd_madd_divide(DIRFILE* D, const char *parent, const char* field_code,
const char* in_field1, const char* in_field2) gd_nothrow
{
- int error;
- gd_entry_t E;
+ return _GD_MAddYoke(D, GD_DIVIDE_ENTRY, parent, field_code, in_field1,
+ in_field2);
+}
- dtrace("%p, \"%s\", \"%s\", \"%s\", \"%s\"", D, parent, field_code, in_field1,
+int gd_madd_indir(DIRFILE* D, const char *parent, const char* field_code,
+ const char* in_field1, const char* in_field2) gd_nothrow
+{
+ return _GD_MAddYoke(D, GD_INDIR_ENTRY, parent, field_code, in_field1,
in_field2);
+}
- if (D->flags & GD_INVALID) {/* don't crash */
- _GD_SetError(D, GD_E_BAD_DIRFILE, 0, NULL, 0, NULL);
- dreturn("%i", -1);
- return -1;
- }
-
- memset(&E, 0, sizeof(gd_entry_t));
- E.field = (char *)field_code;
- E.field_type = GD_DIVIDE_ENTRY;
- E.in_fields[0] = (char *)in_field1;
- E.in_fields[1] = (char *)in_field2;
- error = (_GD_Add(D, &E, parent) == NULL) ? -1 : 0;
-
- dreturn("%i", error);
- return error;
+int gd_madd_sindir(DIRFILE *D, const char *parent, const char* field_code,
+ const char* in_field1, const char* in_field2) gd_nothrow
+{
+ return _GD_MAddYoke(D, GD_SINDIR_ENTRY, parent, field_code, in_field1,
+ in_field2);
}
/* add a RECIP entry */
Modified: trunk/getdata/src/common.c
===================================================================
--- trunk/getdata/src/common.c 2014-04-27 21:29:36 UTC (rev 888)
+++ trunk/getdata/src/common.c 2014-04-30 18:10:25 UTC (rev 889)
@@ -855,11 +855,11 @@
}
/* Ensure that an input field has been identified (with error checking) */
-int _GD_BadInput(DIRFILE *D, const gd_entry_t *E, int i, int err)
+int _GD_BadInput(DIRFILE *D, const gd_entry_t *E, int i, gd_entype_t t, int err)
{
char *code;
- dtrace("%p, %p, %i, %i", D, E, i, err);
+ dtrace("%p, %p, %i, 0x%X, %i", D, E, i, t, err);
if (E->e->entry[i] == NULL) {
E->e->entry[i] = _GD_FindFieldAndRepr(D, E->in_fields[i], &code,
@@ -874,9 +874,17 @@
free(code);
}
- /* scalar entries not allowed */
- if (E->e->entry[i]->field_type & GD_SCALAR_ENTRY_BIT) {
- _GD_SetError(D, GD_E_DIMENSION, GD_E_DIM_FORMAT, E->field, 0,
+ /* check field type */
+ if (t == GD_NO_ENTRY) {
+ /* scalar entries not allowed */
+ if (E->e->entry[i]->field_type & GD_SCALAR_ENTRY_BIT) {
+ _GD_SetError(D, GD_E_DIMENSION, GD_E_DIM_FORMAT, E->field, 0,
+ E->e->entry[i]->field);
+ dreturn("%i", 1);
+ return 1;
+ }
+ } else if (E->e->entry[i]->field_type != t) {
+ _GD_SetError(D, GD_E_BAD_FIELD_TYPE, GD_E_FIELD_FORMAT, E->field, 0,
E->e->entry[i]->field);
dreturn("%i", 1);
return 1;
Modified: trunk/getdata/src/del.c
===================================================================
--- trunk/getdata/src/del.c 2014-04-27 21:29:36 UTC (rev 888)
+++ trunk/getdata/src/del.c 2014-04-30 18:10:25 UTC (rev 889)
@@ -42,6 +42,8 @@
case GD_DIVIDE_ENTRY:
case GD_WINDOW_ENTRY:
case GD_MPLEX_ENTRY:
+ case GD_INDIR_ENTRY:
+ case GD_SINDIR_ENTRY:
if (strcmp(E->in_fields[1], C->field) == 0) {
if (check)
_GD_SetError(D, GD_E_DELETE, GD_E_DEL_DERIVED, E->field, 0,
@@ -214,6 +216,8 @@
case GD_CONST_ENTRY:
case GD_CARRAY_ENTRY:
case GD_SARRAY_ENTRY:
+ case GD_INDIR_ENTRY:
+ case GD_SINDIR_ENTRY:
case GD_INDEX_ENTRY:
case GD_ALIAS_ENTRY:
break;
@@ -308,8 +312,10 @@
if ((del_list[i]->field_type == GD_CONST_ENTRY ||
del_list[i]->field_type == GD_CARRAY_ENTRY) &&
~flags & GD_DEL_DEREF)
+ {
_GD_DeReference(D, D->entry[j], del_list[i], 1);
- else if (del_list[i]->field_type != GD_STRING_ENTRY)
+ }
+ if (!D->error)
_GD_ClearDerived(D, D->entry[j], del_list[i], 1);
if (D->error) {
Modified: trunk/getdata/src/entry.c
===================================================================
--- trunk/getdata/src/entry.c 2014-04-27 21:29:36 UTC (rev 888)
+++ trunk/getdata/src/entry.c 2014-04-30 18:10:25 UTC (rev 889)
@@ -55,6 +55,8 @@
break;
case GD_DIVIDE_ENTRY:
case GD_MULTIPLY_ENTRY:
+ case GD_INDIR_ENTRY:
+ case GD_SINDIR_ENTRY:
free(entry->in_fields[1]);
free(entry->in_fields[0]);
break;
@@ -312,6 +314,8 @@
case GD_CONST_ENTRY:
case GD_CARRAY_ENTRY:
case GD_SARRAY_ENTRY:
+ case GD_INDIR_ENTRY:
+ case GD_SINDIR_ENTRY:
case GD_INDEX_ENTRY:
case GD_ALIAS_ENTRY:
break;
@@ -451,6 +455,8 @@
break;
case GD_MULTIPLY_ENTRY:
case GD_DIVIDE_ENTRY:
+ case GD_INDIR_ENTRY:
+ case GD_SINDIR_ENTRY:
entry->in_fields[0] = strdup(E->in_fields[0]);
entry->in_fields[1] = strdup(E->in_fields[1]);
break;
@@ -817,13 +823,21 @@
switch (E->field_type) {
case GD_LINCOM_ENTRY:
for (i = 0; i < E->EN(lincom,n_fields); ++i)
- _GD_BadInput(D, E, i, 1);
+ _GD_BadInput(D, E, i, GD_NO_ENTRY, 1);
break;
+ case GD_INDIR_ENTRY:
+ _GD_BadInput(D, E, 0, GD_NO_ENTRY, 1);
+ _GD_BadInput(D, E, 0, GD_CARRAY_ENTRY, 1);
+ break;
+ case GD_SINDIR_ENTRY:
+ _GD_BadInput(D, E, 0, GD_NO_ENTRY, 1);
+ _GD_BadInput(D, E, 0, GD_SARRAY_ENTRY, 1);
+ break;
case GD_DIVIDE_ENTRY:
case GD_MULTIPLY_ENTRY:
case GD_WINDOW_ENTRY:
case GD_MPLEX_ENTRY:
- _GD_BadInput(D, E, 1, 1);
+ _GD_BadInput(D, E, 1, GD_NO_ENTRY, 1);
/* fallthrough */
case GD_LINTERP_ENTRY:
case GD_BIT_ENTRY:
@@ -831,7 +845,7 @@
case GD_POLYNOM_ENTRY:
case GD_SBIT_ENTRY:
case GD_RECIP_ENTRY:
- _GD_BadInput(D, E, 0, 1);
+ _GD_BadInput(D, E, 0, GD_NO_ENTRY, 1);
/* Fallthrough */
case GD_RAW_ENTRY:
case GD_CONST_ENTRY:
Modified: trunk/getdata/src/errors.c
===================================================================
--- trunk/getdata/src/errors.c 2014-04-27 21:29:36 UTC (rev 888)
+++ trunk/getdata/src/errors.c 2014-04-30 18:10:25 UTC (rev 889)
@@ -114,10 +114,13 @@
"Recursion too deep including {4} on line {3} of {2}", 0 },
/* GD_E_BAD_DIRFILE: (nothing) */
{ GD_E_BAD_DIRFILE, 0, "Invalid dirfile", 0 },
- /* GD_E_BAD_FIELD_TYPE: 4 = fieldcode */
+ /* GD_E_BAD_FIELD_TYPE: 2 = parent field (if any) 4 = fieldcode */
{ GD_E_BAD_FIELD_TYPE, GD_E_FIELD_PUT, "No method to write field {4}", 0 },
{ GD_E_BAD_FIELD_TYPE, GD_E_FIELD_BAD, "Invalid field type for {4}", 0 },
{ GD_E_BAD_FIELD_TYPE, GD_E_FIELD_MATCH, "Field type mismatch for {4}", 0 },
+ { GD_E_BAD_FIELD_TYPE, GD_E_FIELD_FORMAT,
+ "Bad field type for {4} in definition of {2}", 0 },
+ { GD_E_BAD_FIELD_TYPE, GD_E_FIELD_STR, "Non-numeric data in {4}", 0 },
/* GD_E_ACCMODE: (nothing) */
{ GD_E_ACCMODE, 0, "Dirfile has been opened read-only", 0 },
/* GD_E_UNSUPPORTED: (nothing) */
Modified: trunk/getdata/src/flimits.c
===================================================================
--- trunk/getdata/src/flimits.c 2014-04-27 21:29:36 UTC (rev 888)
+++ trunk/getdata/src/flimits.c 2014-04-30 18:10:25 UTC (rev 889)
@@ -216,7 +216,9 @@
case GD_SBIT_ENTRY:
case GD_POLYNOM_ENTRY:
case GD_RECIP_ENTRY:
- if (_GD_BadInput(D, E, 0, 1))
+ case GD_INDIR_ENTRY:
+ case GD_SINDIR_ENTRY:
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1))
break;
ns = _GD_GetEOF(D, E->e->entry[0], E->field, is_index);
@@ -225,8 +227,11 @@
case GD_MULTIPLY_ENTRY:
case GD_WINDOW_ENTRY:
case GD_MPLEX_ENTRY:
- if (_GD_BadInput(D, E, 0, 1) || _GD_BadInput(D, E, 1, 1))
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1) ||
+ _GD_BadInput(D, E, 1, GD_NO_ENTRY, 1))
+ {
break;
+ }
ns = _GD_GetEOF(D, E->e->entry[0], E->field, is_index);
@@ -263,7 +268,7 @@
}
break;
case GD_LINCOM_ENTRY:
- if (_GD_BadInput(D, E, 0, 1))
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1))
break;
ns = _GD_GetEOF(D, E->e->entry[0], E->field, is_index);
@@ -284,7 +289,7 @@
}
for (i = 1; i < E->EN(lincom,n_fields); ++i) {
- if (_GD_BadInput(D, E, i, 1)) {
+ if (_GD_BadInput(D, E, i, GD_NO_ENTRY, 1)) {
ns = -1;
break;
}
@@ -313,7 +318,7 @@
}
break;
case GD_PHASE_ENTRY:
- if (_GD_BadInput(D, E, 0, 1))
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1))
break;
ns = _GD_GetEOF(D, E->e->entry[0], E->field, is_index);
@@ -423,13 +428,15 @@
case GD_LINTERP_ENTRY:
case GD_POLYNOM_ENTRY:
case GD_RECIP_ENTRY:
- if (_GD_BadInput(D, E, 0, 1))
+ case GD_INDIR_ENTRY:
+ case GD_SINDIR_ENTRY:
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1))
break;
bof = _GD_GetBOF(D, E->e->entry[0], E->field, spf, ds);
break;
case GD_PHASE_ENTRY:
- if (_GD_BadInput(D, E, 0, 1))
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1))
break;
bof = _GD_GetBOF(D, E->e->entry[0], E->field, spf, ds);
@@ -458,8 +465,11 @@
case GD_DIVIDE_ENTRY:
case GD_WINDOW_ENTRY:
case GD_MPLEX_ENTRY:
- if (_GD_BadInput(D, E, 0, 1) || _GD_BadInput(D, E, 1, 1))
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1) ||
+ _GD_BadInput(D, E, 1, GD_NO_ENTRY, 1))
+ {
break;
+ }
bof = _GD_GetBOF(D, E->e->entry[0], E->field, spf, ds);
@@ -483,7 +493,7 @@
}
break;
case GD_LINCOM_ENTRY:
- if (_GD_BadInput(D, E, 0, 1))
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1))
break;
bof = _GD_GetBOF(D, E->e->entry[0], E->field, spf, ds);
@@ -494,7 +504,7 @@
}
for (i = 1; i < E->EN(lincom,n_fields); ++i) {
- if (_GD_BadInput(D, E, i, 1)) {
+ if (_GD_BadInput(D, E, i, GD_NO_ENTRY, 1)) {
bof = -1;
break;
}
Modified: trunk/getdata/src/flush.c
===================================================================
--- trunk/getdata/src/flush.c 2014-04-27 21:29:36 UTC (rev 888)
+++ trunk/getdata/src/flush.c 2014-04-30 18:10:25 UTC (rev 889)
@@ -1,4 +1,4 @@
-/* Copyright (C) 2008-2012 D. V. Wiebe
+/* Copyright (C) 2008-2012, 2014 D. V. Wiebe
*
***************************************************************************
*
@@ -58,7 +58,7 @@
break;
case GD_LINCOM_ENTRY:
for (i = 0; i < E->EN(lincom,n_fields); ++i) {
- if (!_GD_BadInput(D, E, i, 0))
+ if (!_GD_BadInput(D, E, i, GD_NO_ENTRY, 0))
_GD_Flush(D, E->e->entry[i], syn, clo);
}
break;
@@ -66,7 +66,7 @@
case GD_DIVIDE_ENTRY:
case GD_WINDOW_ENTRY:
case GD_MPLEX_ENTRY:
- if (!_GD_BadInput(D, E, 1, 0))
+ if (!_GD_BadInput(D, E, 1, GD_NO_ENTRY, 0))
_GD_Flush(D, E->e->entry[1], syn, clo);
/* fallthrough */
case GD_LINTERP_ENTRY:
@@ -75,7 +75,9 @@
case GD_POLYNOM_ENTRY:
case GD_SBIT_ENTRY:
case GD_RECIP_ENTRY:
- if (!_GD_BadInput(D, E, 0, 0))
+ case GD_INDIR_ENTRY:
+ case GD_SINDIR_ENTRY:
+ if (!_GD_BadInput(D, E, 0, GD_NO_ENTRY, 0))
_GD_Flush(D, E->e->entry[0], syn, clo);
case GD_CONST_ENTRY:
case GD_CARRAY_ENTRY:
@@ -731,6 +733,26 @@
}
}
break;
+ case GD_INDIR_ENTRY:
+ if (fprintf(stream, " INDIR%s ", pretty ? " " : "") < 0 ||
+ _GD_WriteFieldCode(D, stream, me, E->in_fields[0], permissive,
+ D->standards, 1) < 0 ||
+ _GD_WriteFieldCode(D, stream, me, E->in_fields[1], permissive,
+ D->standards, 0) < 0)
+ {
+ goto WRITE_ERR;
+ }
+ break;
+ case GD_SINDIR_ENTRY:
+ if (fprintf(stream, " SINDIR%s ", pretty ? " " : "") < 0 ||
+ _GD_WriteFieldCode(D, stream, me, E->in_fields[0], permissive,
+ D->standards, 1) < 0 ||
+ _GD_WriteFieldCode(D, stream, me, E->in_fields[1], permissive,
+ D->standards, 0) < 0)
+ {
+ goto WRITE_ERR;
+ }
+ break;
case GD_INDEX_ENTRY:
case GD_ALIAS_ENTRY:
case GD_NO_ENTRY:
@@ -1318,6 +1340,8 @@
D->av &= GD_VERS_GE_6;
break;
case GD_SARRAY_ENTRY:
+ case GD_INDIR_ENTRY:
+ case GD_SINDIR_ENTRY:
D->av &= GD_VERS_GE_10;
break;
case GD_BIT_ENTRY:
Modified: trunk/getdata/src/fpos.c
===================================================================
--- trunk/getdata/src/fpos.c 2014-04-27 21:29:36 UTC (rev 888)
+++ trunk/getdata/src/fpos.c 2014-04-30 18:10:25 UTC (rev 889)
@@ -47,13 +47,13 @@
D->fragment[E->fragment_index].frame_offset;
break;
case GD_LINCOM_ENTRY:
- if (_GD_BadInput(D, E, 0, 1))
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1))
break;
pos = _GD_GetFilePos(D, E->e->entry[0], -1);
if (!D->error)
for (i = 1; i < E->EN(lincom,n_fields); ++i) {
- if (_GD_BadInput(D, E, i, 1)) {
+ if (_GD_BadInput(D, E, i, GD_NO_ENTRY, 1)) {
pos = -1;
break;
}
@@ -70,7 +70,9 @@
case GD_POLYNOM_ENTRY:
case GD_SBIT_ENTRY:
case GD_RECIP_ENTRY:
- if (_GD_BadInput(D, E, 0, 1))
+ case GD_INDIR_ENTRY:
+ case GD_SINDIR_ENTRY:
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1))
break;
pos = _GD_GetFilePos(D, E->e->entry[0], -1);
break;
@@ -78,8 +80,11 @@
case GD_DIVIDE_ENTRY:
case GD_WINDOW_ENTRY:
case GD_MPLEX_ENTRY:
- if (_GD_BadInput(D, E, 0, 1) || _GD_BadInput(D, E, 1, 1))
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1) ||
+ _GD_BadInput(D, E, 1, GD_NO_ENTRY, 1))
+ {
break;
+ }
pos = _GD_GetFilePos(D, E->e->entry[0], -1);
if (D->error)
break;
@@ -90,7 +95,7 @@
}
break;
case GD_PHASE_ENTRY:
- if (_GD_BadInput(D, E, 0, 1))
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1))
break;
pos = _GD_GetFilePos(D, E->e->entry[0], -1);
if (pos >= 0)
@@ -280,7 +285,7 @@
break;
case GD_LINCOM_ENTRY:
for (i = 0; i < E->EN(lincom,n_fields); ++i)
- if (!_GD_BadInput(D, E, i, 1))
+ if (!_GD_BadInput(D, E, i, GD_NO_ENTRY, 1))
_GD_Seek(D, E->e->entry[i], offset, mode);
else
break;
@@ -289,7 +294,7 @@
case GD_DIVIDE_ENTRY:
case GD_WINDOW_ENTRY:
case GD_MPLEX_ENTRY:
- if (_GD_BadInput(D, E, 1, 1))
+ if (_GD_BadInput(D, E, 1, GD_NO_ENTRY, 1))
break;
if (_GD_Seek(D, E->e->entry[1], offset, mode))
break;
@@ -299,11 +304,13 @@
case GD_POLYNOM_ENTRY:
case GD_SBIT_ENTRY:
case GD_RECIP_ENTRY:
- if (!_GD_BadInput(D, E, 0, 1))
+ case GD_INDIR_ENTRY:
+ case GD_SINDIR_ENTRY:
+ if (!_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1))
_GD_Seek(D, E->e->entry[0], offset, mode);
break;
case GD_PHASE_ENTRY:
- if (!_GD_BadInput(D, E, 0, 1))
+ if (!_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1))
_GD_Seek(D, E->e->entry[0], offset - E->EN(phase,shift), mode);
break;
case GD_INDEX_ENTRY:
Modified: trunk/getdata/src/getdata.c
===================================================================
--- trunk/getdata/src/getdata.c 2014-04-27 21:29:36 UTC (rev 888)
+++ trunk/getdata/src/getdata.c 2014-04-30 18:10:25 UTC (rev 889)
@@ -983,7 +983,7 @@
/* input field checks */
for (i = 0; i < E->EN(lincom,n_fields); ++i) {
- if (_GD_BadInput(D, E, i, 1)) {
+ if (_GD_BadInput(D, E, i, GD_NO_ENTRY, 1)) {
dreturn("%i", 0);
return 0;
}
@@ -1116,12 +1116,12 @@
num_samp, return_type, data_out);
/* Check input fields */
- if (_GD_BadInput(D, E, 0, 1)) {
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1)) {
dreturn("%i", 0);
return 0;
}
- if (_GD_BadInput(D, E, 1, 1)) {
+ if (_GD_BadInput(D, E, 1, GD_NO_ENTRY, 1)) {
dreturn("%i", 0);
return 0;
}
@@ -1209,7 +1209,7 @@
num_samp, return_type, data_out);
/* Check input fields */
- if (_GD_BadInput(D, E, 0, 1)) {
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1)) {
dreturn("%i", 0);
return 0;
}
@@ -1255,7 +1255,9 @@
num_samp, return_type, data_out);
/* Check input fields */
- if (_GD_BadInput(D, E, 0, 1) || _GD_BadInput(D, E, 1, 1)) {
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1) ||
+ _GD_BadInput(D, E, 1, GD_NO_ENTRY, 1))
+ {
dreturn("%i", 0);
return 0;
}
@@ -1350,7 +1352,7 @@
dtrace("%p, %p, %i, %lli, %" PRNsize_t ", 0x%X, %p", D, E, is_signed,
(long long)first_samp, num_samp, return_type, data_out);
- if (_GD_BadInput(D, E, 0, 1)) {
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1)) {
dreturn("%i", 0);
return 0;
}
@@ -1403,7 +1405,7 @@
dtrace("%p, %p, %lli, %" PRNsize_t ", 0x%X, %p", D, E, (long long)first_samp,
num_samp, return_type, data_out);
- if (_GD_BadInput(D, E, 0, 1)) {
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1)) {
dreturn("%i", 0);
return 0;
}
@@ -1427,7 +1429,7 @@
dtrace("%p, %p, %lli, %" PRNsize_t ", 0x%X, %p", D, E, (long long)first_samp,
num_samp, return_type, data_out);
- if (_GD_BadInput(D, E, 0, 1)) {
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1)) {
dreturn("%i", 0);
return 0;
}
@@ -1469,7 +1471,7 @@
dtrace("%p, %p, %lli, %" PRNsize_t ", 0x%X, %p", D, E, (long long)first_samp,
num_samp, return_type, data_out);
- if (_GD_BadInput(D, E, 0, 1)) {
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1)) {
dreturn("%i", 0);
return 0;
}
@@ -1516,12 +1518,12 @@
num_samp, return_type, data_out);
/* Check input fields */
- if (_GD_BadInput(D, E, 0, 1)) {
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1)) {
dreturn("%i", 0);
return 0;
}
- if (_GD_BadInput(D, E, 1, 1)) {
+ if (_GD_BadInput(D, E, 1, GD_NO_ENTRY, 1)) {
dreturn("%i", 0);
return 0;
}
@@ -1622,12 +1624,12 @@
num_samp, return_type, data_out);
/* Check input fields */
- if (_GD_BadInput(D, E, 0, 1)) {
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1)) {
dreturn("%i", 0);
return 0;
}
- if (_GD_BadInput(D, E, 1, 1)) {
+ if (_GD_BadInput(D, E, 1, GD_NO_ENTRY, 1)) {
dreturn("%i", 0);
return 0;
}
@@ -1789,8 +1791,7 @@
return n_read;
}
-/* _GD_DoConst: Read from a const. Returns number of samples read (ie. 1).
-*/
+/* _GD_DoConst: Read from a const. Returns number of samples read */
static size_t _GD_DoConst(DIRFILE *restrict D, const gd_entry_t *restrict E,
off64_t first, size_t len, gd_type_t return_type, void *restrict data_out)
{
@@ -1812,6 +1813,94 @@
return len;
}
+/* simple */
+static void _GD_IndirData(DIRFILE *restrict D, char *restrict cbuf,
+ gd_type_t ctype, const int64_t *restrict ibuf, size_t n, const void *carray,
+ size_t len)
+{
+ size_t i;
+ const int size = GD_SIZE(ctype);
+ int64_t ilen = (len > GD_INT64_MAX) ? GD_INT64_MAX : len;
+
+ dtrace("%p, %p, 0x%X, %p, %" PRNsize_t ", %p, %" PRNsize_t, D, cbuf, ctype,
+ ibuf, n, carray, len);
+
+ for (i = 0; i < n; ++i)
+ if (ibuf[i] < 0 || ibuf[i] >= ilen)
+ _GD_FillZero(cbuf + size * i, ctype, 1);
+ else
+ memcpy(cbuf + size * i, carray + size * ibuf[i], size);
+
+ dreturnvoid();
+}
+
+/* _GD_DoIndir: Read from an indir. */
+static size_t _GD_DoIndir(DIRFILE *restrict D, const gd_entry_t *restrict E,
+ off64_t first_samp, size_t num_samp, gd_type_t return_type,
+ void *restrict data_out)
+{
+ size_t n_read;
+ int64_t *ibuf = NULL;
+ void *cbuf = NULL;
+ gd_type_t ctype;
+
+ dtrace("%p, %p, %lli, %" PRNsize_t ", 0x%X, %p", D, E, (long long)first_samp,
+ num_samp, return_type, data_out);
+
+ /* Check input fields */
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1)) {
+ dreturn("%i", 0);
+ return 0;
+ }
+
+ if (_GD_BadInput(D, E, 1, GD_CARRAY_ENTRY, 1)) {
+ dreturn("%i", 0);
+ return 0;
+ }
+
+ /* index buffer */
+ ibuf = _GD_Alloc(D, GD_INT64, num_samp);
+ if (D->error) {
+ dreturn("%i", 0);
+ return 0;
+ }
+
+ /* read the index field and record the number of samples returned */
+ n_read = _GD_DoField(D, E->e->entry[0], E->e->repr[0], first_samp, num_samp,
+ GD_INT64, ibuf);
+
+ if (D->error || n_read == 0) {
+ free(ibuf);
+ dreturn("%i", 0);
+ return 0;
+ }
+
+ /* the intermediate buffer: it has the load type of the carray */
+ ctype = _GD_ConstType(D, E->e->entry[1]->EN(scalar,const_type));
+ cbuf = _GD_Alloc(D, ctype, n_read);
+ if (D->error) {
+ free(ibuf);
+ dreturn("%i", 0);
+ return 0;
+ }
+
+ _GD_IndirData(D, cbuf, GD_SIZE(ctype), ibuf, n_read,
+ E->e->entry[1]->e->u.scalar.d, E->e->entry[1]->EN(scalar,array_len));
+
+ free(ibuf);
+
+ /* type convert into output buffer */
+ _GD_ConvertType(D, cbuf, ctype, data_out, return_type, n_read);
+
+ free(cbuf);
+
+ if (D->error)
+ n_read = 0;
+
+ dreturn("%" PRNsize_t, n_read);
+ return n_read;
+}
+
/* _GD_DoField: Locate the field in the database and read it.
*/
size_t _GD_DoField(DIRFILE *restrict D, gd_entry_t *restrict E, int repr,
@@ -1927,8 +2016,12 @@
case GD_CARRAY_ENTRY:
n_read = _GD_DoConst(D, E, first_samp, num_samp, return_type, data_out);
break;
+ case GD_INDIR_ENTRY:
+ n_read = _GD_DoIndir(D, E, first_samp, num_samp, return_type, data_out);
+ break;
case GD_STRING_ENTRY:
case GD_SARRAY_ENTRY:
+ case GD_SINDIR_ENTRY:
case GD_ALIAS_ENTRY:
case GD_NO_ENTRY:
/* Can't get here */
@@ -1949,6 +2042,110 @@
return n_read;
}
+/* this returns string vector data (ie. SINDIR) */
+size_t gd_getstrdata64(DIRFILE *D, const char *field_code, off64_t first_frame,
+ off64_t first_samp, size_t num_frames, size_t num_samp,
+ const char **data_out)
+{
+ size_t i, n_read = 0;
+ gd_entry_t *E;
+ unsigned int spf;
+ int64_t *ibuf = NULL;
+ int64_t len;
+
+ dtrace("%p, \"%s\", %lli %lli, %" PRNsize_t ", %" PRNsize_t ", %p", D,
+ field_code, (long long)first_frame, (long long)first_samp, num_frames,
+ num_samp, data_out);
+
+ if (D->flags & GD_INVALID) {
+ _GD_SetError(D, GD_E_BAD_DIRFILE, 0, NULL, 0, NULL);
+ dreturn("%i", 0);
+ return 0;
+ }
+
+ _GD_ClearError(D);
+
+ E = _GD_FindField(D, field_code, D->entry, D->n_entries, 1, NULL);
+
+ if (E == NULL) {
+ _GD_SetError(D, GD_E_BAD_CODE, GD_E_CODE_MISSING, NULL, 0, field_code);
+ dreturn("%i", 0);
+ return 0;
+ }
+
+ if (E->field_type != GD_SINDIR_ENTRY) {
+ _GD_SetError(D, GD_E_BAD_FIELD_TYPE, GD_E_FIELD_BAD, NULL, 0, field_code);
+ dreturn("%i", 0);
+ return 0;
+ }
+
+ if (first_frame == GD_HERE || first_samp == GD_HERE) {
+ first_samp = GD_HERE;
+ first_frame = 0;
+ }
+
+ if (first_frame > 0 || num_frames > 0) {
+ /* get the samples per frame */
+ spf = _GD_GetSPF(D, E);
+
+ if (D->error) {
+ dreturn("%i", 0);
+ return 0;
+ }
+
+ first_samp += spf * first_frame;
+ num_samp += spf * num_frames;
+ }
+
+ if (first_samp < 0 && (first_samp != GD_HERE || first_frame != 0)) {
+ _GD_SetError(D, GD_E_RANGE, GD_E_OUT_OF_RANGE, NULL, 0, NULL);
+ dreturn("%i", 0);
+ return 0;
+ }
+
+ /* Check input fields */
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1)) {
+ dreturn("%i", 0);
+ return 0;
+ }
+
+ if (_GD_BadInput(D, E, 1, GD_SARRAY_ENTRY, 1)) {
+ dreturn("%i", 0);
+ return 0;
+ }
+
+ /* index buffer */
+ ibuf = _GD_Alloc(D, GD_INT64, num_samp);
+ if (D->error) {
+ dreturn("%i", 0);
+ return 0;
+ }
+
+ /* read the index field and record the number of samples returned */
+ n_read = _GD_DoField(D, E->e->entry[0], E->e->repr[0], first_samp, num_samp,
+ GD_INT64, ibuf);
+
+ if (D->error || n_read == 0) {
+ free(ibuf);
+ dreturn("%i", 0);
+ return 0;
+ }
+
+ len = (E->e->entry[1]->EN(scalar,array_len) > GD_INT64_MAX) ? GD_INT64_MAX
+ : E->e->entry[1]->EN(scalar,array_len);
+
+ for (i = 0; i < n_read; ++i)
+ if (ibuf[i] < 0 || ibuf[i] >= len)
+ data_out[i] = NULL;
+ else
+ data_out[i] = ((const char **)E->e->entry[1]->e->u.scalar.d)[ibuf[i]];
+
+ free(ibuf);
+
+ dreturn("%" PRNsize_t, n_read);
+ return n_read;
+}
+
/* this function is little more than a public boilerplate for _GD_DoField */
size_t gd_getdata64(DIRFILE* D, const char *field_code_in, off64_t first_frame,
off64_t first_samp, size_t num_frames, size_t num_samp,
@@ -1982,6 +2179,8 @@
if (entry->field_type & GD_SCALAR_ENTRY_BIT)
_GD_SetError(D, GD_E_DIMENSION, GD_E_DIM_CALLER, NULL, 0, field_code);
+ else if (entry->field_type == GD_SINDIR_ENTRY)
+ _GD_SetError(D, GD_E_BAD_FIELD_TYPE, GD_E_FIELD_STR, NULL, 0, field_code);
if (field_code != field_code_in)
free(field_code);
@@ -2023,6 +2222,13 @@
}
/* 32(ish)-bit wrapper for the 64-bit version, when needed */
+size_t gd_getstrdata(DIRFILE *D, const char *field_code, off_t first_frame,
+ off_t first_samp, size_t num_frames, size_t num_samp, const char **data_out)
+{
+ return gd_getstrdata64(D, field_code, first_frame, first_samp, num_frames,
+ num_samp, data_out);
+}
+
size_t gd_getdata(DIRFILE* D, const char *field_code, off_t first_frame,
off_t first_samp, size_t num_frames, size_t num_samp,
gd_type_t return_type, void *data_out)
Modified: trunk/getdata/src/getdata.h.in
===================================================================
--- trunk/getdata/src/getdata.h.in 2014-04-27 21:29:36 UTC (rev 888)
+++ trunk/getdata/src/getdata.h.in 2014-04-30 18:10:25 UTC (rev 889)
@@ -59,7 +59,7 @@
#endif
/* The most recent standards version supported by this library */
-#define GD_DIRFILE_STANDARDS_VERSION 9
+#define GD_DIRFILE_STANDARDS_VERSION 10
#include <math.h>
#include <sys/types.h>
@@ -241,6 +241,8 @@
GD_RECIP_ENTRY = 0x0B,
GD_WINDOW_ENTRY = 0x0C,
GD_MPLEX_ENTRY = 0x0D,
+ GD_INDIR_ENTRY = 0x0E,
+ GD_SINDIR_ENTRY = 0x0F,
GD_CONST_ENTRY = GD_SCALAR_ENTRY_BIT | 0x00,
GD_STRING_ENTRY = GD_SCALAR_ENTRY_BIT | 0x01,
GD_CARRAY_ENTRY = GD_SCALAR_ENTRY_BIT | 0x02,
@@ -546,6 +548,10 @@
const char *in_field1, const char *in_field2, int fragment_index)
gd_nothrow gd_nonnull ((1,2,3,4));
+extern int gd_add_indir(DIRFILE *dirfile, const char *field_code,
+ const char *in_field1, const char *in_field2, int fragment_index)
+gd_nothrow gd_nonnull ((1,2,3,4));
+
extern int gd_add_lincom(DIRFILE *dirfile, const char *field_code, int n_fields,
const char **in_fields, const double *m, const double *b,
int fragment_index) gd_nothrow gd_nonnull ((1,2,4,5,6));
@@ -582,6 +588,10 @@
const char *in_field, int bitnum, int numbits,
int fragment_index) gd_nothrow gd_nonnull ((1,2,3));
+extern int gd_add_sindir(DIRFILE *dirfile, const char *field_code,
+ const char *in_field1, const char *in_field2, int fragment_index)
+gd_nothrow gd_nonnull ((1,2,3,4));
+
extern int gd_add_string(DIRFILE *dirfile, const char *field_code,
const char *value, int fragment_index) gd_nothrow gd_nonnull((1,2,3));
@@ -632,6 +642,9 @@
extern int gd_alter_divide(DIRFILE *dirfile, const char *field_code,
const char *in_field1, const char *in_field2) gd_nothrow gd_nonnull((1,2));
+extern int gd_alter_indir(DIRFILE *dirfile, const char *field_code,
+ const char *in_field1, const char *in_field2) gd_nothrow gd_nonnull((1,2));
+
extern int gd_alter_lincom(DIRFILE *dirfile, const char *field_code,
int n_fields, const char **in_fields, const double *m, const double *b)
gd_nothrow gd_nonnull((1,2));
@@ -660,6 +673,9 @@
const char *in_field, int bitnum, int numbits) gd_nothrow
gd_nonnull((1,2));
+extern int gd_alter_sindir(DIRFILE *dirfile, const char *field_code,
+ const char *in_field1, const char *in_field2) gd_nothrow gd_nonnull((1,2));
+
extern int gd_alter_window(DIRFILE *dirfile, const char *field_code,
const char *in_field, const char *check_field, gd_windop_t windop,
gd_triplet_t threshold) gd_nothrow gd_nonnull((1,2));
@@ -792,6 +808,10 @@
const char *field_code, const char *in_field1, const char *in_field2)
gd_nothrow gd_nonnull ((1,2,3,4,5));
+extern int gd_madd_indir(DIRFILE *dirfile, const char *parent,
+ const char *field_code, const char *in_field1, const char *in_field2)
+gd_nothrow gd_nonnull ((1,2,3,4,5));
+
extern int gd_madd_lincom(DIRFILE *dirfile, const char *parent,
const char *field_code, int n_fields, const char **in_fields,
const double *m, const double *b) gd_nothrow gd_nonnull((1,2,3,5,6,7));
@@ -829,6 +849,10 @@
const char *field_code, const char *in_field, int bitnum,
int numbits) gd_nothrow gd_nonnull ((1,2,3,4));
+extern int gd_madd_sindir(DIRFILE *dirfile, const char *parent,
+ const char *field_code, const char *in_field1, const char *in_field2)
+gd_nothrow gd_nonnull ((1,2,3,4,5));
+
extern int gd_madd_spec(DIRFILE *dirfile, const char *line,
const char *parent) gd_nothrow gd_nonnull ((1,2,3));
@@ -1041,6 +1065,10 @@
off_t first_frame, off_t first_sample, size_t num_frames,
size_t num_samples, gd_type_t return_type, void *data) gd_nonnull ((1, 2));
+extern size_t gd_getstrdata(DIRFILE *dirfile, const char *field_code,
+ off_t first_frame, off_t first_sample, size_t num_frames,
+ size_t num_samples, const char **data) gd_nonnull ((1, 2));
+
extern size_t gd_putdata(DIRFILE *dirfile, const char *field_code,
off_t first_frame, off_t first_sample, size_t num_frames,
size_t num_samples, gd_type_t data_type, const void *data)
@@ -1089,6 +1117,11 @@
off_t first_frame, off_t first_samp, size_t num_frames, size_t num_samp,
gd_type_t return_type, void *data), gd_getdata64) gd_nonnull ((1, 2));
+extern size_t __REDIRECT (gd_getstrdata, (DIRFILE *dirfile,
+ const char *field_code, off_t first_frame, off_t first_samp,
+ size_t num_frames, size_t num_samp, const char **data), gd_getstrdata64)
+gd_nonnull ((1, 2));
+
extern size_t __REDIRECT (gd_putdata, (DIRFILE *dirfile, const char *field_code,
off_t first_frame, off_t first_sample, size_t num_frames,
size_t num_samples, gd_type_t data_type, const void *data),
@@ -1110,6 +1143,7 @@
# else
# define gd_alter_frameoffset gd_alter_frameoffset64
# define gd_getdata gd_getdata64
+# define gd_getstrdata gd_getstrdata64
# define gd_putdata gd_putdata64
# define gd_nframes gd_nframes64
# define gd_eof gd_eof64
@@ -1142,6 +1176,10 @@
gd_off64_t first_frame, gd_off64_t first_samp, size_t num_frames,
size_t num_samp, gd_type_t return_type, void *data) gd_nonnull ((1, 2));
+extern size_t gd_getstrdata64(DIRFILE *dirfile, const char *field_code,
+ gd_off64_t first_frame, gd_off64_t first_samp, size_t num_frames,
+ size_t num_samp, const char **data) gd_nonnull ((1, 2));
+
extern size_t gd_putdata64(DIRFILE *dirfile, const char *field_code,
gd_off64_t first_frame, gd_off64_t first_sample, size_t num_frames,
size_t num_samples, gd_type_t data_type, const void *data)
Modified: trunk/getdata/src/internal.h
===================================================================
--- trunk/getdata/src/internal.h 2014-04-27 21:29:36 UTC (rev 888)
+++ trunk/getdata/src/internal.h 2014-04-30 18:10:25 UTC (rev 889)
@@ -269,16 +269,18 @@
#define SIZEOF_UNSIGNED_INT (sizeof(unsigned int))
#endif
+#define GD_INT_TYPE ((gd_type_t)(SIZEOF_INT | GD_SIGNED))
+#define GD_UINT_TYPE ((gd_type_t)(SIZEOF_UNSIGNED_INT))
+
+/* a few integer limits */
#ifndef SIZEOF_SIZE_T
#define SIZEOF_SIZE_T (sizeof(size_t))
#endif
+#define GD_INT64_MAX ((int64_t)((uint64_t)-1>>1))
#define GD_SSIZE_T_MAX ((ssize_t)((size_t)-1>>1))
#define GD_SIZE_T_MAX ((size_t)-1)
-#define GD_INT_TYPE ((gd_type_t)(SIZEOF_INT | GD_SIGNED))
-#define GD_UINT_TYPE ((gd_type_t)(SIZEOF_UNSIGNED_INT))
-
/* default buffer size */
#if SIZEOF_INT < 4
#define GD_BUFFER_SIZE 32767
@@ -753,6 +755,8 @@
#define GD_E_FIELD_PUT 1
#define GD_E_FIELD_BAD 2
#define GD_E_FIELD_MATCH 3
+#define GD_E_FIELD_FORMAT 4
+#define GD_E_FIELD_STR 5
#define GD_E_ENTRY_TYPE 1
#define GD_E_ENTRY_METARAW 2
@@ -1101,7 +1105,7 @@
/* forward declarations */
void *_GD_Alloc(DIRFILE*, gd_type_t, size_t) __attribute_malloc__;
-int _GD_BadInput(DIRFILE *, const gd_entry_t *, int, int);
+int _GD_BadInput(DIRFILE *, const gd_entry_t *, int, gd_entype_t, int);
#define _GD_BadWindop(op) \
( \
Modified: trunk/getdata/src/legacy.c
===================================================================
--- trunk/getdata/src/legacy.c 2014-04-27 21:29:36 UTC (rev 888)
+++ trunk/getdata/src/legacy.c 2014-04-30 18:10:25 UTC (rev 889)
@@ -439,6 +439,8 @@
break;
case GD_MULTIPLY_ENTRY:
case GD_DIVIDE_ENTRY:
+ case GD_INDIR_ENTRY:
+ case GD_SINDIR_ENTRY:
Format.n_multiply++;
break;
case GD_PHASE_ENTRY:
@@ -517,6 +519,8 @@
break;
case GD_MULTIPLY_ENTRY:
case GD_DIVIDE_ENTRY:
+ case GD_INDIR_ENTRY:
+ case GD_SINDIR_ENTRY:
CopyMultDivEntry(&Format.multiplyEntries[nmultiply++], D->entry[i]);
break;
case GD_PHASE_ENTRY:
Modified: trunk/getdata/src/mod.c
===================================================================
--- trunk/getdata/src/mod.c 2014-04-27 21:29:36 UTC (rev 888)
+++ trunk/getdata/src/mod.c 2014-04-30 18:10:25 UTC (rev 889)
@@ -614,6 +614,8 @@
break;
case GD_MULTIPLY_ENTRY:
case GD_DIVIDE_ENTRY:
+ case GD_INDIR_ENTRY:
+ case GD_SINDIR_ENTRY:
j = _GD_AlterInField(D, 0, Q.in_fields, N->in_fields, E->in_fields,
E->fragment_index, 0);
if (j < 0)
@@ -974,9 +976,9 @@
break;
if (Q.EN(scalar,array_len) > E->EN(scalar,array_len)) {
- memset(((char**)Qe.u.scalar.d) + E->EN(scalar,array_len), 0,
- sizeof(char**) * (Q.EN(scalar,array_len) -
- E->EN(scalar,array_len)));
+ size_t i;
+ for (i = E->EN(scalar,array_len); i < Q.EN(scalar,array_len); ++i)
+ ((const char**)Qe.u.scalar.d)[i] = _GD_Strdup(D, "");
}
} else
Qe.u.scalar.d = E->e->u.scalar.d;
@@ -1375,13 +1377,14 @@
return ret;
}
-int gd_alter_divide(DIRFILE* D, const char* field_code, const char* in_field1,
- const char* in_field2) gd_nothrow
+static int _GD_AlterYoke(DIRFILE* D, gd_entype_t t, const char* field_code,
+ const char* in_field1, const char* in_field2) gd_nothrow
{
int ret;
gd_entry_t N;
- dtrace("%p, \"%s\", \"%s\", \"%s\"", D, field_code, in_field1, in_field2);
+ dtrace("%p, 0x%X, \"%s\", \"%s\", \"%s\"", D, t, field_code, in_field1,
+ in_field2);
if (D->flags & GD_INVALID) {/* don't crash */
_GD_SetError(D, GD_E_BAD_DIRFILE, 0, NULL, 0, NULL);
@@ -1390,7 +1393,7 @@
}
memset(&N, 0, sizeof(gd_entry_t));
- N.field_type = GD_DIVIDE_ENTRY;
+ N.field_type = t;
N.in_fields[0] = (char *)in_field1;
N.in_fields[1] = (char *)in_field2;
@@ -1400,29 +1403,28 @@
return ret;
}
+int gd_alter_divide(DIRFILE* D, const char* field_code, const char* in_field1,
+ const char* in_field2) gd_nothrow
+{
+ return _GD_AlterYoke(D, GD_DIVIDE_ENTRY, field_code, in_field1, in_field2);
+}
+
int gd_alter_multiply(DIRFILE* D, const char* field_code, const char* in_field1,
const char* in_field2) gd_nothrow
{
- int ret;
- gd_entry_t N;
+ return _GD_AlterYoke(D, GD_MULTIPLY_ENTRY, field_code, in_field1, in_field2);
+}
- dtrace("%p, \"%s\", \"%s\", \"%s\"", D, field_code, in_field1, in_field2);
+int gd_alter_indir(DIRFILE* D, const char* field_code, const char* in_field1,
+ const char* in_field2) gd_nothrow
+{
+ return _GD_AlterYoke(D, GD_INDIR_ENTRY, field_code, in_field1, in_field2);
+}
- if (D->flags & GD_INVALID) {/* don't crash */
- _GD_SetError(D, GD_E_BAD_DIRFILE, 0, NULL, 0, NULL);
- dreturn("%i", -1);
- return -1;
- }
-
- memset(&N, 0, sizeof(gd_entry_t));
- N.field_type = GD_MULTIPLY_ENTRY;
- N.in_fields[0] = (char *)in_field1;
- N.in_fields[1] = (char *)in_field2;
-
- ret = _GD_Change(D, field_code, &N, 0);
-
- dreturn("%i", ret);
- return ret;
+int gd_alter_sindir(DIRFILE* D, const char* field_code, const char* in_field1,
+ const char* in_field2) gd_nothrow
+{
+ return _GD_AlterYoke(D, GD_SINDIR_ENTRY, field_code, in_field1, in_field2);
}
int gd_alter_phase(DIRFILE* D, const char* field_code, const char* in_field,
Modified: trunk/getdata/src/name.c
===================================================================
--- trunk/getdata/src/name.c 2014-04-27 21:29:36 UTC (rev 888)
+++ trunk/getdata/src/name.c 2014-04-30 18:10:25 UTC (rev 889)
@@ -451,46 +451,72 @@
rdat->n_code = 0;
for (u = 0; u < D->n_entries; ++u) {
- if (update_vectors)
- switch (D->entry[u]->field_type) {
- case GD_LINCOM_ENTRY:
+ switch (D->entry[u]->field_type) {
+ case GD_LINCOM_ENTRY:
+ if (update_vectors)
for (i = 0; i < D->entry[u]->EN(lincom,n_fields); ++i) {
if (_GD_UpdateInField(D, D->entry[u], rdat, i, search_meta, mode)) {
dreturn("%i", -1);
return -1;
}
}
- break;
- case GD_MULTIPLY_ENTRY:
- case GD_DIVIDE_ENTRY:
- case GD_WINDOW_ENTRY:
- case GD_MPLEX_ENTRY:
+ break;
+ case GD_MULTIPLY_ENTRY:
+ case GD_DIVIDE_ENTRY:
+ case GD_WINDOW_ENTRY:
+ case GD_MPLEX_ENTRY:
+ if (update_vectors)
if (_GD_UpdateInField(D, D->entry[u], rdat, 1, search_meta, mode)) {
dreturn("%i", -1);
return -1;
}
- /* Fallthrough */
- case GD_LINTERP_ENTRY:
- case GD_BIT_ENTRY:
- case GD_PHASE_ENTRY:
- case GD_POLYNOM_ENTRY:
- case GD_RECIP_ENTRY:
- case GD_SBIT_ENTRY:
+ /* Fallthrough */
+ case GD_LINTERP_ENTRY:
+ case GD_BIT_ENTRY:
+ case GD_PHASE_ENTRY:
+ case GD_POLYNOM_ENTRY:
+ case GD_RECIP_ENTRY:
+ case GD_SBIT_ENTRY:
+ if (update_vectors)
if (_GD_UpdateInField(D, D->entry[u], rdat, 0, search_meta, mode)) {
dreturn("%i", -1);
return -1;
}
- break;
- case GD_INDEX_ENTRY:
- case GD_RAW_ENTRY:
- case GD_NO_ENTRY:
- case GD_CONST_ENTRY:
- case GD_CARRAY_ENTRY:
- case GD_SARRAY_ENTRY:
- case GD_STRING_ENTRY:
- case GD_ALIAS_ENTRY:
- break;
- }
+ break;
+ case GD_INDIR_ENTRY:
+ if (update_vectors)
+ if (_GD_UpdateInField(D, D->entry[u], rdat, 0, search_meta, mode)) {
+ dreturn("%i", -1);
+ return -1;
+ }
+ if (rdat->E->field_type == GD_CARRAY_ENTRY || search_meta)
+ if (_GD_UpdateInField(D, D->entry[u], rdat, 1, search_meta, mode)) {
+ dreturn("%i", -1);
+ return -1;
+ }
+ break;
+ case GD_SINDIR_ENTRY:
+ if (update_vectors)
+ if (_GD_UpdateInField(D, D->entry[u], rdat, 0, search_meta, mode)) {
+ dreturn("%i", -1);
+ return -1;
+ }
+ if (rdat->E->field_type == GD_SARRAY_ENTRY || search_meta)
+ if (_GD_UpdateInField(D, D->entry[u], rdat, 1, search_meta, mode)) {
+ dreturn("%i", -1);
+ return -1;
+ }
+ break;
+ case GD_INDEX_ENTRY:
+ case GD_RAW_ENTRY:
+ case GD_NO_ENTRY:
+ case GD_CONST_ENTRY:
+ case GD_CARRAY_ENTRY:
+ case GD_SARRAY_ENTRY:
+ case GD_STRING_ENTRY:
+ case GD_ALIAS_ENTRY:
+ break;
+ }
if (update_scalars)
switch (D->entry[u]->field_type) {
case GD_LINCOM_ENTRY:
@@ -536,6 +562,8 @@
case GD_CONST_ENTRY:
case GD_CARRAY_ENTRY:
case GD_SARRAY_ENTRY:
+ case GD_INDIR_ENTRY:
+ case GD_SINDIR_ENTRY:
case GD_ALIAS_ENTRY:
break;
}
Modified: trunk/getdata/src/native.c
===================================================================
--- trunk/getdata/src/native.c 2014-04-27 21:29:36 UTC (rev 888)
+++ trunk/getdata/src/native.c 2014-04-30 18:10:25 UTC (rev 889)
@@ -1,4 +1,4 @@
-/* Copyright (C) 2009-2012 D. V. Wiebe
+/* Copyright (C) 2009-2012, 2014 D. V. Wiebe
*
***************************************************************************
*
@@ -49,7 +49,7 @@
type = GD_FLOAT64;
for (i = 0; i < E->EN(lincom,n_fields); ++i) {
- if (_GD_BadInput(D, E, i, 1))
+ if (_GD_BadInput(D, E, i, GD_NO_ENTRY, 1))
break;
if (_GD_NativeType(D, E->e->entry[i], E->e->repr[i]) & GD_COMPLEX) {
@@ -70,8 +70,11 @@
break;
case GD_MULTIPLY_ENTRY:
case GD_DIVIDE_ENTRY:
- if (_GD_BadInput(D, E, 0, 1) || _GD_BadInput(D, E, 1, 1))
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1) ||
+ _GD_BadInput(D, E, 1, GD_NO_ENTRY, 1))
+ {
break;
+ }
type = (_GD_NativeType(D, E->e->entry[0], E->e->repr[0]) & GD_COMPLEX
|| _GD_NativeType(D, E->e->entry[1], E->e->repr[1]) & GD_COMPLEX)
@@ -81,7 +84,7 @@
if (!(E->flags & GD_EN_CALC))
_GD_CalculateEntry(D, E, 1);
- if (_GD_BadInput(D, E, 0, 1))
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1))
break;
type = ((_GD_NativeType(D, E->e->entry[0], E->e->repr[0]) & GD_COMPLEX)
@@ -94,7 +97,7 @@
case GD_PHASE_ENTRY:
case GD_WINDOW_ENTRY:
case GD_MPLEX_ENTRY:
- if (_GD_BadInput(D, E, 0, 1))
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1))
break;
type = _GD_NativeType(D, E->e->entry[0], E->e->repr[0]);
@@ -108,7 +111,7 @@
break;
}
- if (_GD_BadInput(D, E, 0, 1))
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1))
break;
type = (_GD_NativeType(D, E->e->entry[0], E->e->repr[0]) & GD_COMPLEX) ?
@@ -120,10 +123,18 @@
break;
case GD_CONST_ENTRY:
case GD_CARRAY_ENTRY:
- type = E->EN(scalar,const_type);
+ type = _GD_ConstType(D, E->EN(scalar,const_type));
break;
+ case GD_INDIR_ENTRY:
+ if (_GD_BadInput(D, E, 1, GD_CARRAY_ENTRY, 1))
+ break;
+
+ type = _GD_NativeType(D, E->e->entry[1], E->e->repr[1]);
+
+ break;
case GD_STRING_ENTRY:
case GD_SARRAY_ENTRY:
+ case GD_SINDIR_ENTRY:
type = GD_NULL;
break;
case GD_NO_ENTRY:
Modified: trunk/getdata/src/parse.c
===================================================================
--- trunk/getdata/src/parse.c 2014-04-27 21:29:36 UTC (rev 888)
+++ trunk/getdata/src/parse.c 2014-04-30 18:10:25 UTC (rev 889)
@@ -526,9 +526,10 @@
return E;
}
-/* _GD_ParseMultiply: parse MULTIPLY entry in format file.
+/* _GD_ParseYoke: parse a field specified by two input fields only (MULTIPLY,
+ * DIVIDE, INDIR, SINDIR)
*/
-static gd_entry_t *_GD_ParseMultiply(DIRFILE *restrict D,
+static gd_entry_t *_GD_ParseYoke(DIRFILE *restrict D, gd_entype_t type,
char *gd_restrict_arr in_cols[MAX_IN_COLS], int n_cols,
const gd_entry_t *restrict parent, const char *restrict format_file,
int line, int me, int standards, int pedantic, int *restrict is_dot)
@@ -536,8 +537,8 @@
gd_entry_t *E;
int offset;
- dtrace("%p, %p, %i, %p, \"%s\", %i, %i, %i, %i, %p", D, in_cols, n_cols,
- parent, format_file, line, me, standards, pedantic, is_dot);
+ dtrace("%p, 0x%X, %p, %i, %p, \"%s\", %i, %i, %i, %i, %p", D, type, in_cols,
+ n_cols, parent, format_file, line, me, standards, pedantic, is_dot);
if (n_cols < 4) {
_GD_SetError(D, GD_E_FORMAT, GD_E_FORMAT_N_TOK, format_file, line, NULL);
@@ -561,7 +562,7 @@
}
memset(E->e, 0, sizeof(struct gd_private_entry_));
- E->field_type = GD_MULTIPLY_ENTRY;
+ E->field_type = type;
E->in_fields[0] = E->in_fields[1] = NULL;
E->e->entry[0] = E->e->entry[1] = NULL;
E->flags |= GD_EN_CALC;
@@ -818,69 +819,6 @@
return E;
}
-/* _GD_ParseDivide: parse DIVIDE entry in format file.
-*/
-static gd_entry_t *_GD_ParseDivide(DIRFILE *restrict D,
- char *gd_restrict_arr in_cols[MAX_IN_COLS], int n_cols,
- const gd_entry_t *restrict parent, const char *restrict format_file,
- int line, int me, int standards, int pedantic, int *restrict is_dot)
-{
- gd_entry_t *E;
- int offset;
-
- dtrace("%p, %p, %i, %p, \"%s\", %i, %i, %i, %i, %p", D, in_cols, n_cols,
- parent, format_file, line, me, standards, pedantic, is_dot);
-
- if (n_cols < 4) {
- _GD_SetError(D, GD_E_FORMAT, GD_E_FORMAT_N_TOK, format_file, line, NULL);
- dreturn("%p", NULL);
- return NULL;
- }
-
- E = (gd_entry_t *)_GD_Malloc(D, sizeof(gd_entry_t));
- if (E == NULL) {
- dreturn("%p", NULL);
- return NULL;
- }
- memset(E, 0, sizeof(gd_entry_t));
-
- E->e = (struct gd_private_entry_ *)_GD_Malloc(D,
- sizeof(struct gd_private_entry_));
- if (E->e == NULL) {
- free(E);
- dreturn("%p", NULL);
- return NULL;
- }
- memset(E->e, 0, sizeof(struct gd_private_entry_));
-
- E->field_type = GD_DIVIDE_ENTRY;
- E->in_fields[0] = E->in_fields[1] = NULL;
- E->e->entry[0] = E->e->entry[1] = NULL;
-
- E->field = _GD_MungeFromFrag(D, parent, me, in_cols[0], &offset);
- if (E->field && _GD_ValidateField(E->field + offset, standards, pedantic, 0,
- is_dot))
- {
- _GD_SetError(D, GD_E_FORMAT, GD_E_FORMAT_BAD_NAME, format_file, line,
- in_cols[0]);
- _GD_FreeE(D, E, 1);
- dreturn("%p", NULL);
- return NULL;
- }
-
- E->in_fields[0] = _GD_MungeFromFrag(D, NULL, me, in_cols[2], &offset);
- E->in_fields[1] = _GD_MungeFromFrag(D, NULL, me, in_cols[3], &offset);
-
- if (D->error) {
- _GD_FreeE(D, E, 1);
- dreturn("%p", NULL);
- return NULL;
- }
-
- dreturn("%p", E);
- return E;
-}
-
/* _GD_ParseBit: parse BIT entry in format file.
*/
static gd_entry_t *_GD_ParseBit(DIRFILE *restrict D, int is_signed,
@@ -1602,8 +1540,8 @@
E = _GD_ParseLinterp(D, in_cols, n_cols, P, format_file, linenum, me,
standards, pedantic, &is_dot);
else if (strcmp(in_cols[1], "MULTIPLY") == 0 && (!pedantic || standards >= 2))
- E = _GD_ParseMultiply(D, in_cols, n_cols, P, format_file, linenum, me,
- standards, pedantic, &is_dot);
+ E = _GD_ParseYoke(D, GD_MULTIPLY_ENTRY, in_cols, n_cols, P, format_file,
+ linenum, me, standards, pedantic, &is_dot);
else if (strcmp(in_cols[1], "BIT") == 0)
E = _GD_ParseBit(D, 0, in_cols, n_cols, P, format_file, linenum, me,
standards, pedantic, &is_dot);
@@ -1617,8 +1555,8 @@
E = _GD_ParseBit(D, 1, in_cols, n_cols, P, format_file, linenum, me,
standards, pedantic, &is_dot);
else if (strcmp(in_cols[1], "DIVIDE") == 0 && (!pedantic || standards >= 8))
- E = _GD_ParseDivide(D, in_cols, n_cols, P, format_file, linenum, me,
- standards, pedantic, &is_dot);
+ E = _GD_ParseYoke(D, GD_DIVIDE_ENTRY, in_cols, n_cols, P, format_file,
+ linenum, me, standards, pedantic, &is_dot);
else if (strcmp(in_cols[1], "RECIP") == 0 && (!pedantic || standards >= 8))
E = _GD_ParseRecip(D, in_cols, n_cols, P, format_file, linenum, me,
standards, pedantic, &is_dot);
@@ -1628,6 +1566,12 @@
else if (strcmp(in_cols[1], "MPLEX") == 0 && (!pedantic || standards >= 9))
E = _GD_ParseMplex(D, in_cols, n_cols, P, format_file, linenum, me,
standards, pedantic, &is_dot);
+ else if (strcmp(in_cols[1], "INDIR") == 0 && (!pedantic || standards >= 10))
+ E = _GD_ParseYoke(D, GD_INDIR_ENTRY, in_cols, n_cols, P, format_file,
+ linenum, me, standards, pedantic, &is_dot);
+ else if (strcmp(in_cols[1], "SINDIR") == 0 && (!pedantic || standards >= 10))
+ E = _GD_ParseYoke(D, GD_SINDIR_ENTRY, in_cols, n_cols, P, format_file,
+ linenum, me, standards, pedantic, &is_dot);
else if (strcmp(in_cols[1], "CONST") == 0 && (!pedantic || standards >= 6))
E = _GD_ParseConst(D, in_cols, n_cols, P, format_file, linenum, me,
standards, pedantic, &is_dot);
@@ -1637,7 +1581,7 @@
else if (strcmp(in_cols[1], "STRING") == 0 && (!pedantic || standards >= 6))
E = _GD_ParseString(D, in_cols, n_cols, P, format_file, linenum, me,
standards, pedantic, &is_dot);
- else if (strcmp(in_cols[1], "SARRAY") == 0 && (!pedantic || standards >= 8))
+ else if (strcmp(in_cols[1], "SARRAY") == 0 && (!pedantic || standards >= 10))
E = _GD_ParseArray(D, 1, in_cols, n_cols, P, format_file, linenum, me,
standards, pedantic, &is_dot, outstring, tok_pos);
else if (standards <= GD_DIRFILE_STANDARDS_VERSION || pedantic)
Modified: trunk/getdata/src/putdata.c
===================================================================
--- trunk/getdata/src/putdata.c 2014-04-27 21:29:36 UTC (rev 888)
+++ trunk/getdata/src/putdata.c 2014-04-30 18:10:25 UTC (rev 889)
@@ -116,7 +116,7 @@
dtrace("%p, %p, %lli, %" PRNsize_t ", 0x%X, %p", D, E, (long long)first_samp,
num_samp, data_type, data_in);
- if (_GD_BadInput(D, E, 0, 1)) {
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1)) {
dreturn("%i", 0);
return 0;
}
@@ -226,7 +226,7 @@
return 0;
}
- if (_GD_BadInput(D, E, 0, 1)) {
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1)) {
dreturn("%i", 0);
return 0;
}
@@ -296,7 +296,7 @@
dtrace("%p, %p, %lli, %" PRNsize_t ", 0x%X, %p", D, E, (long long)first_samp,
num_samp, data_type, data_in);
- if (_GD_BadInput(D, E, 0, 1)) {
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1)) {
dreturn("%i", 0);
return 0;
}
@@ -351,7 +351,7 @@
dtrace("%p, %p, %lli, %" PRNsize_t ", 0x%X, %p", D, E, (long long)first_samp,
num_samp, data_type, data_in);
- if (_GD_BadInput(D, E, 0, 1)) {
+ if (_GD_BadInput(D, E, 0, GD_NO_ENTRY, 1)) {
dreturn("%i", 0);
return 0;
}
@@ -374,7 +374,7 @@
dtrace("%p, %p, %lli, %" PRNsize_t ", ...
[truncated message content] |
