/****** cull/dump_scan/lUndumpObject() ******************************************
* NAME
* lUndumpObject() -- Reads a by lDumpList dumped dump
*
* SYNOPSIS
* lListElem* lUndumpObject(FILE *fp)
*
* FUNCTION
* Reads a by lDumpList dumped dump into the memory.
*
* INPUTS
* FILE *fp - file pointer
*
* RESULT
* lListElem* - Read list element
*
* NOTES
*
******************************************************************************/
lListElem *lUndumpObject(FILE *fp)
{
lListElem *ep;
lDescr *dp = NULL;
DENTER(CULL_LAYER, "lUndumpObject");
if (!fp) {
LERROR(LEFILENULL);
DEXIT;
return NULL;
}
/* read bra */
if (fGetBra(fp)) {
printf("bra is missing\n");
LERROR(LESYNTAX);
DEXIT;
return NULL;
}
/* read Descriptor from file */
if ((dp = lUndumpDescr(fp)) == NULL) {
LERROR(LEFGETDESCR);
DEXIT;
return NULL;
}
if (lCountDescr(dp) <= 0) {
LERROR(LECOUNTDESCR);
free(dp);
DEXIT;
return NULL;
}
if ((ep = lUndumpElemFp(fp, dp)) == NULL) {
LERROR(LEUNDUMPELEM);
free(dp);
DEXIT;
return NULL;
}
free(dp);
/* read ket */
if (fGetKet(fp)) {
lFreeElem(&ep);
printf("ket is missing\n");
LERROR(LESYNTAX);
DEXIT;
return NULL;
}
DEXIT;
return ep;
}
bool test_lReduceDescr(void)
{
bool ret = true;
lEnumeration *what1 = lWhat("%T(ALL)", TEST_Type);
lEnumeration *what2 = lWhat("%T(NONE)", TEST_Type);
lEnumeration *what3 = lWhat("%T(%I %I "
"%I -> %T(%I %I -> %T(%I %I)) "
"%I -> %T(NONE) "
"%I -> %T(ALL))",
TEST_Type, TEST_int, TEST_host,
TEST_list, TEST1_Type, TEST1_int, TEST1_object,
TEST1_Type, TEST1_int, TEST1_host,
TEST_object, TEST1_Type,
TEST_ref, TEST1_Type);
lDescr *dst_descriptor1 = NULL;
lDescr *dst_descriptor2 = NULL;
lDescr *dst_descriptor3 = NULL;
lReduceDescr(&dst_descriptor1, TEST_Type, what1);
lReduceDescr(&dst_descriptor2, TEST_Type, what2);
lReduceDescr(&dst_descriptor3, TEST_Type, what3);
#if 0
fprintf(stderr, sge_u32"\n", lCountDescr(dst_descriptor1));
fprintf(stderr, sge_u32"\n", lCountDescr(dst_descriptor2));
fprintf(stderr, sge_u32"\n", lCountDescr(dst_descriptor3));
fprintf(stderr, sge_u32"\n", lCountWhat(what1, TEST_Type));
fprintf(stderr, sge_u32"\n", lCountWhat(what2, TEST_Type));
fprintf(stderr, sge_u32"\n", lCountWhat(what3, TEST_Type));
#endif
ret &= (lCountDescr(dst_descriptor1) == 12);
ret &= (12 == lCountWhat(what1, TEST_Type));
ret &= (lCountDescr(dst_descriptor2) == -1);
ret &= (0 == lCountWhat(what2, TEST_Type));
ret &= (lCountDescr(dst_descriptor3) == 5);
ret &= (5 == lCountWhat(what3, TEST_Type));
lFreeWhat(&what1);
lFreeWhat(&what2);
lFreeWhat(&what3);
sge_free(&dst_descriptor1);
sge_free(&dst_descriptor2);
sge_free(&dst_descriptor3);
return ret;
}
/****** cull/dump_scan/lDumpDescr() ****************************************
* NAME
* lDumpDescr() -- Write a descriptor (for debugging purpose)
*
* SYNOPSIS
* int lDumpDescr(FILE *fp, const lDescr *dp, int indent)
*
* FUNCTION
* Write a descriptor (for debugging purpose)
*
* INPUTS
* FILE *fp - file pointer
* const lDescr *dp - descriptor
* int indent -
*
* RESULT
* int - error state
* 0 - OK
* -1 - Error
******************************************************************************/
int lDumpDescr(FILE *fp, const lDescr *dp, int indent)
{
int i, ret = ~EOF;
char space[256];
DENTER(CULL_LAYER, "lDumpDescr");
space[0] = '\0';
for (i = 0; i < indent; i++)
strcat(space, INDENT_STRING);
if (!fp) {
LERROR(LEFILENULL);
DEXIT;
return -1;
}
ret = fprintf(fp, "%s{ /* DESCR BEGIN */\n", space);
if (!dp) {
LERROR(LEDESCRNULL);
DEXIT;
return -1;
}
ret = fprintf(fp, "%s/* NUMBER OF DESCR FIELDS */ %d\n", space,
lCountDescr(dp));
for (i = 0; mt_get_type(dp[i].mt) != lEndT && ret != EOF; i++) {
ret = fprintf(fp, "%s/* %-20.20s */ { %d, %d }\n", space,
lNm2Str(dp[i].nm), dp[i].nm, dp[i].mt);
}
ret = fprintf(fp, "%s} /* DESCR END */\n", space);
DEXIT;
return (ret == EOF) ? -1 : 0;
}
/****** cull/dump_scan/lUndumpList() ******************************************
* NAME
* lUndumpList() -- Reads a by lDumpList dumped dump
*
* SYNOPSIS
* lList* lUndumpList(FILE *fp, const char *name, const lDescr *dp)
*
* FUNCTION
* Reads a by lDumpList dumped dump into the memory.
*
* INPUTS
* FILE *fp - file pointer
* const char *name - new name of list or NULL if the old name in the
* dumpfile should be used as listname
* const lDescr *dp - new list descriptor or NULL if the old list
* descriptor should be used as list descriptor
*
* RESULT
* lList* - Read list
*
* NOTES
* Actually a type/name matching is only performed for the list
* itself and not for its sublists.
* If an implementation of changed sublist descriptors is desired
* we can probably use the following syntax for lUndumpList.
* lList* lUndumpList(fp, name, formatstring, ...)
* with formatstring like "%T(%I -> %T(%I->%T))" and the varargs
* list: ".....", lDescr1, fieldname1, lDescr2, fieldname2, lDescr3
* or write a wrapper around lUndumpList which parses this format and
* hands over the varargs list to lUndumpList
******************************************************************************/
lList *lUndumpList(FILE *fp, const char *name, const lDescr *dp)
{
lList *lp = NULL;
lListElem *fep, *ep;
lDescr *fdp = NULL;
int i, j, nelem, n, k;
int *found;
char *oldname;
DENTER(CULL_LAYER, "lUndumpList");
if (!fp) {
LERROR(LEFILENULL);
DRETURN(NULL);
}
/* read bra */
if (fGetBra(fp)) {
printf("bra is missing\n");
LERROR(LESYNTAX);
DRETURN(NULL);
}
/* read listname */
if (fGetString(fp, &oldname)) {
printf("fGetString failed\n");
LERROR(LEFIELDREAD);
DRETURN(NULL);
}
/* read number of elems */
if (fGetInt(fp, &nelem)) {
printf("fGetInt failed\n");
LERROR(LEFIELDREAD);
DRETURN(NULL);
}
/* read Descriptor from file */
if (!(fdp = lUndumpDescr(fp))) {
LERROR(LEFGETDESCR);
DRETURN(NULL);
}
if (!dp) /* dp is NULL, use lDescr from dumpfile */
dp = fdp;
/* use old name (from file) if name is NULL */
if (!(lp = lCreateList((name) ? name : oldname, dp))) {
FREE(fdp);
LERROR(LECREATELIST);
DRETURN(NULL);
}
free(oldname); /* fGetString strdup's */
if ((n = lCountDescr(dp)) <= 0) {
LERROR(LECOUNTDESCR);
FREE(fdp);
lFreeList(&lp);
DRETURN(NULL);
}
if (!(found = (int *) malloc(sizeof(int) * n))) {
LERROR(LEMALLOC);
FREE(fdp);
lFreeList(&lp);
DRETURN(NULL);
}
/* Initialize found array */
for (i = 0; i < n; i++)
found[i] = -1;
/* Here warnings are displayed if there are additional or missing fields */
for (j = 0; fdp[j].nm != NoName; j++) {
for (i = 0; i < n; i++) {
if (dp[i].nm == fdp[j].nm &&
dp[i].mt == fdp[j].mt) {
if (found[i] != -1)
DPRINTF(("lUndumpList: field %s found twice\n",
lNm2Str(dp[i].nm)));
found[i] = j;
break;
}
}
if (i == n)
DPRINTF(("lUndumpList: field %s not needed\n", lNm2Str(fdp[j].nm)));
}
for (i = 0; i < n; i++)
if (found[i] == -1)
DPRINTF(("lUndumpList: field %s not found\n", lNm2Str(dp[i].nm)));
/* LOOP OVER THE LIST ELEMENTS */
for (k = 0; k < nelem; k++) {
if (!(fep = lUndumpElemFp(fp, fdp))) {
LERROR(LEUNDUMPELEM);
lFreeList(&lp);
FREE(found);
FREE(fdp);
DRETURN(NULL);
}
if (!(ep = lCreateElem(dp))) {
lFreeList(&lp);
FREE(found);
FREE(fdp);
LERROR(LECREATEELEM);
DRETURN(NULL);
}
for (i = 0; i < n; i++) {
if (found[i] == -1) {
continue;
} else if (lCopySwitchPack(fep, ep, found[i], i, true, NULL, NULL) == -1) {
lFreeList(&lp);
lFreeElem(&ep);
FREE(found);
FREE(fdp);
LERROR(LECOPYSWITCH);
DRETURN(NULL);
}
}
lFreeElem(&fep);
if (lAppendElem(lp, ep) == -1) {
lFreeList(&lp);
lFreeElem(&ep);
FREE(found);
FREE(fdp);
LERROR(LEAPPENDELEM);
DRETURN(NULL);
}
}
/* read ket */
if (fGetKet(fp)) {
lFreeList(&lp);
printf("ket is missing\n");
LERROR(LESYNTAX);
}
FREE(found);
FREE(fdp);
DRETURN(lp);
}
/****** cull/dump_scan/lUndumpElemFp() ******************************************
* NAME
* lUndumpElemFp() -- Read element from FILE stream
*
* SYNOPSIS
* lListElem* lUndumpElemFp(FILE *fp, const lDescr *dp)
*
* FUNCTION
* Read element from FILE stream
*
* INPUTS
* FILE *fp - file stream
* const lDescr *dp - descriptor
*
* RESULT
* lListElem* - Read element
******************************************************************************/
lListElem *lUndumpElemFp(FILE *fp, const lDescr *dp)
{
lListElem *ep;
int n, i;
int ret = 0;
char *str;
u_long32 dummy;
DENTER(CULL_LAYER, "lUndumpElemFp");
if (!fp) {
LERROR(LEFILENULL);
DEXIT;
return NULL;
}
if (!dp) {
LERROR(LEDESCRNULL);
DEXIT;
return NULL;
}
if (!(ep = lCreateElem(dp))) {
LERROR(LECREATEELEM);
DEXIT;
return NULL;
}
if ((n = lCountDescr(dp)) <= 0) {
LERROR(LECOUNTDESCR);
lFreeElem(&ep);
DEXIT;
return NULL;
}
/* read bra */
if (fGetBra(fp)) {
printf("bra is missing\n");
LERROR(LESYNTAX);
lFreeElem(&ep);
DEXIT;
return NULL;
}
for (i = 0; i < n && ret == 0; i++) {
switch (mt_get_type(dp[i].mt)) {
case lIntT:
ret = fGetInt(fp, &(ep->cont[i].i));
break;
case lUlongT:
ret = fGetUlong(fp, &(ep->cont[i].ul));
break;
case lStringT:
ret = fGetString(fp, &str);
if (ret == 0) {
lSetPosString(ep, i, str);
free(str); /* fGetString strdup's */
}
break;
case lHostT:
ret = fGetHost(fp, &str);
if (ret == 0) {
lSetPosHost(ep, i, str);
free(str); /* fGetHost strdup's */
}
break;
case lFloatT:
ret = fGetFloat(fp, &(ep->cont[i].fl));
break;
case lDoubleT:
ret = fGetDouble(fp, &(ep->cont[i].db));
break;
case lLongT:
ret = fGetLong(fp, &(ep->cont[i].l));
break;
case lCharT:
ret = fGetChar(fp, &(ep->cont[i].c));
break;
case lBoolT:
ret = fGetBool(fp, &(ep->cont[i].b));
break;
case lRefT:
/* we will not undump references! But we have to skip the line! */
ret = fGetUlong(fp, &dummy);
ep->cont[i].ref = NULL;
break;
case lObjectT:
ret = fGetObject(fp, &(ep->cont[i].obj));
break;
case lListT:
ret = fGetList(fp, &(ep->cont[i].glp));
break;
default:
lFreeElem(&ep);
unknownType("lUndumpElemFp");
}
}
/* error handling for loop */
if (ret != 0) {
lFreeElem(&ep);
LERROR(LEFIELDREAD);
DEXIT;
return NULL;
}
/* read ket */
if (fGetKet(fp)) {
lFreeElem(&ep);
printf("ket is missing\n");
LERROR(LESYNTAX);
DEXIT;
return NULL;
}
DEXIT;
return ep;
}
