X-Git-Url: http://git.indexdata.com/?p=idzebra-moved-to-github.git;a=blobdiff_plain;f=index%2Fzinfo.c;h=72245838cd03a35dbc3427e13b42d293ecc87078;hp=2e6dae9cb5dfd858ad7acb67a9d78e3928a309ff;hb=1ccf2613ceef2359f589cb3dd7e72a899c618b2f;hpb=48d26dcea283f57c49f77b82d6a987e41d775749 diff --git a/index/zinfo.c b/index/zinfo.c index 2e6dae9..7224583 100644 --- a/index/zinfo.c +++ b/index/zinfo.c @@ -1,10 +1,46 @@ /* - * Copyright (C) 1994-1998, Index Data I/S + * Copyright (C) 1994-2000, Index Data * All rights reserved. * Sebastian Hammer, Adam Dickmeiss * * $Log: zinfo.c,v $ - * Revision 1.10 1998-06-08 14:43:15 adam + * Revision 1.21 2000-12-05 10:01:44 adam + * Fixed bug regarding user-defined attribute sets. + * + * Revision 1.20 2000/11/29 14:24:01 adam + * Script configure uses yaz pthreads options. Added locking for + * zebra_register_{lock,unlock}. + * + * Revision 1.19 2000/07/07 12:49:20 adam + * Optimized resultSetInsert{Rank,Sort}. + * + * Revision 1.18 2000/03/20 19:08:36 adam + * Added remote record import using Z39.50 extended services and Segment + * Requests. + * + * Revision 1.17 1999/07/14 10:53:51 adam + * Updated various routines to handle missing explain schema. + * + * Revision 1.16 1999/05/26 07:49:13 adam + * C++ compilation. + * + * Revision 1.15 1999/01/25 13:47:54 adam + * Fixed bug. + * + * Revision 1.14 1998/11/04 16:31:32 adam + * Fixed bug regarding recordBytes in databaseInfo. + * + * Revision 1.13 1998/11/03 10:17:09 adam + * Fixed bug regarding creation of some data1 nodes for Explain records. + * + * Revision 1.12 1998/10/13 20:37:11 adam + * Changed the way attribute sets are saved in Explain database to + * reflect "dynamic" OIDs. + * + * Revision 1.11 1998/06/09 12:16:48 adam + * Implemented auto-generation of CategoryList records. + * + * Revision 1.10 1998/06/08 14:43:15 adam * Added suport for EXPLAIN Proxy servers - added settings databasePath * and explainDatabase to facilitate this. Increased maximum number * of databases and attributes in one register. @@ -105,6 +141,12 @@ struct zebraExplainAttset { struct zebraExplainAttset *next; }; +struct zebraCategoryListInfo { + int dirty; + int sysno; + data1_node *data1_categoryList; +}; + struct zebraExplainInfo { int ordinalSU; int runNumber; @@ -115,6 +157,7 @@ struct zebraExplainInfo { struct zebraExplainAttset *attsets; NMEM nmem; data1_node *data1_target; + struct zebraCategoryListInfo *categoryList; struct zebDatabaseInfoB *databaseInfo; struct zebDatabaseInfoB *curDatabaseInfo; zebAccessInfo accessInfo; @@ -150,16 +193,11 @@ static data1_node *data1_add_tag (data1_handle dh, data1_node *at, const char *tag, NMEM nmem) { data1_node *partag = get_parent_tag(dh, at); - data1_node *res = data1_mk_node (dh, nmem); + data1_node *res = data1_mk_node_type (dh, nmem, DATA1N_tag); data1_element *e = NULL; res->parent = at; - res->which = DATA1N_tag; res->u.tag.tag = data1_insert_string (dh, res, nmem, tag); - res->u.tag.node_selected = 0; - res->u.tag.make_variantlist = 0; - res->u.tag.no_data_requested = 0; - res->u.tag.get_bytes = -1; if (partag) e = partag->u.tag.element; @@ -257,9 +295,9 @@ static data1_node *data1_make_tagdata_text (data1_handle dh, data1_node *at, { data1_node *node_data = node->child; node_data->u.data.what = DATA1I_text; - node_data->u.data.data = node_data->lbuf; - strcpy (node_data->u.data.data, str); - node_data->u.data.len = strlen (node_data->u.data.data); + node_data->u.data.len = strlen (str); + node_data->u.data.data = data1_insert_string (dh, node_data, + nmem, str); return node_data; } } @@ -275,6 +313,10 @@ static void zebraExplain_writeTarget (ZebraExplainInfo zei, int key_flush); static void zebraExplain_writeAttributeSet (ZebraExplainInfo zei, zebAccessObject o, int key_flush); +static void zebraExplain_writeCategoryList (ZebraExplainInfo zei, + struct zebraCategoryListInfo *zcl, + int key_flush); + static Record createRecord (Records records, int *sysno) { @@ -298,15 +340,14 @@ static Record createRecord (Records records, int *sysno) return rec; } -void zebraExplain_close (ZebraExplainInfo zei, int writeFlag, - int (*updateH)(Record drec, data1_node *n)) +void zebraExplain_flush (ZebraExplainInfo zei, int writeFlag, void *handle) { - struct zebDatabaseInfoB *zdi; - - logf (LOG_DEBUG, "zebraExplain_close wr=%d", writeFlag); + zei->updateHandle = handle; if (writeFlag) { + struct zebDatabaseInfoB *zdi; zebAccessObject o; + /* write each database info record */ for (zdi = zei->databaseInfo; zdi; zdi = zdi->next) { @@ -315,7 +356,9 @@ void zebraExplain_close (ZebraExplainInfo zei, int writeFlag, zdi->databaseName, 1); } zebraExplain_writeTarget (zei, 1); - + zebraExplain_writeCategoryList (zei, + zei->categoryList, + 1); assert (zei->accessInfo); for (o = zei->accessInfo->attributeSetIds; o; o = o->next) if (!o->sysno) @@ -333,10 +376,18 @@ void zebraExplain_close (ZebraExplainInfo zei, int writeFlag, zdi->databaseName, 0); } zebraExplain_writeTarget (zei, 0); - } +} + +void zebraExplain_close (ZebraExplainInfo zei, int writeFlag) +{ +#if ZINFO_DEBUG + logf (LOG_LOG, "zebraExplain_close wr=%d", writeFlag); +#endif + if (!zei) + return; + zebraExplain_flush (zei, writeFlag, zei->updateHandle); nmem_destroy (zei->nmem); - xfree (zei); } void zebraExplain_mergeOids (ZebraExplainInfo zei, data1_node *n, @@ -369,7 +420,7 @@ void zebraExplain_mergeOids (ZebraExplainInfo zei, data1_node *n, } if (!ao) { - ao = nmem_malloc (zei->nmem, sizeof(*ao)); + ao = (zebAccessObject) nmem_malloc (zei->nmem, sizeof(*ao)); ao->handle = NULL; ao->sysno = 1; ao->oid = oid; @@ -386,7 +437,8 @@ void zebraExplain_mergeAccessInfo (ZebraExplainInfo zei, data1_node *n, if (!n) { - *accessInfo = nmem_malloc (zei->nmem, sizeof(**accessInfo)); + *accessInfo = (zebAccessInfo) + nmem_malloc (zei->nmem, sizeof(**accessInfo)); (*accessInfo)->attributeSetIds = NULL; (*accessInfo)->schemas = NULL; } @@ -415,18 +467,26 @@ ZebraExplainInfo zebraExplain_open ( struct zebDatabaseInfoB **zdip; time_t our_time; struct tm *tm; + NMEM nmem = nmem_create (); - logf (LOG_DEBUG, "zebraExplain_open wr=%d", writeFlag); - zei = xmalloc (sizeof(*zei)); +#if ZINFO_DEBUG + logf (LOG_LOG, "zebraExplain_open wr=%d", writeFlag); +#endif + zei = (ZebraExplainInfo) nmem_malloc (nmem, sizeof(*zei)); zei->updateHandle = updateHandle; zei->updateFunc = updateFunc; zei->dirty = 0; zei->curDatabaseInfo = NULL; zei->records = records; - zei->nmem = nmem_create (); + zei->nmem = nmem; zei->dh = dh; zei->attsets = NULL; zei->res = res; + zei->categoryList = (struct zebraCategoryListInfo *) + nmem_malloc (zei->nmem, sizeof(*zei->categoryList)); + zei->categoryList->sysno = 0; + zei->categoryList->dirty = 0; + zei->categoryList->data1_categoryList = NULL; time (&our_time); tm = localtime (&our_time); @@ -437,13 +497,21 @@ ZebraExplainInfo zebraExplain_open ( zdip = &zei->databaseInfo; trec = rec_get (records, 1); /* get "root" record */ + zei->ordinalSU = 1; + zei->runNumber = 0; + zebraExplain_mergeAccessInfo (zei, 0, &zei->accessInfo); if (trec) /* targetInfo already exists ... */ { data1_node *node_tgtinfo, *node_zebra, *node_list, *np; zei->data1_target = read_sgml_rec (zei->dh, zei->nmem, trec); - + if (!zei->data1_target || !zei->data1_target->u.root.absyn) + { + logf (LOG_FATAL, "Explain schema missing. Check profilePath"); + nmem_destroy (zei->nmem); + return 0; + } #if ZINFO_DEBUG data1_pr_tree (zei->dh, zei->data1_target, stderr); #endif @@ -454,9 +522,15 @@ ZebraExplainInfo zebraExplain_open ( node_zebra = data1_search_tag (zei->dh, node_tgtinfo->child, "zebraInfo"); - node_list = data1_search_tag (zei->dh, node_zebra->child, - "databaseList"); - for (np = node_list->child; np; np = np->next) + np = 0; + if (node_zebra) + { + node_list = data1_search_tag (zei->dh, node_zebra->child, + "databaseList"); + if (node_list) + np = node_list->child; + } + for (; np; np = np->next) { data1_node *node_name = NULL; data1_node *node_id = NULL; @@ -477,8 +551,8 @@ ZebraExplainInfo zebraExplain_open ( } assert (node_id && node_name && node_aid); - *zdip = nmem_malloc (zei->nmem, sizeof(**zdip)); - + *zdip = (struct zebDatabaseInfoB *) + nmem_malloc (zei->nmem, sizeof(**zdip)); (*zdip)->readFlag = 1; (*zdip)->dirty = 0; (*zdip)->data1_database = NULL; @@ -486,14 +560,14 @@ ZebraExplainInfo zebraExplain_open ( (*zdip)->recordBytes = 0; zebraExplain_mergeAccessInfo (zei, 0, &(*zdip)->accessInfo); - (*zdip)->databaseName = nmem_malloc (zei->nmem, - 1+node_name->u.data.len); + (*zdip)->databaseName = (char *) + nmem_malloc (zei->nmem, 1+node_name->u.data.len); memcpy ((*zdip)->databaseName, node_name->u.data.data, node_name->u.data.len); (*zdip)->databaseName[node_name->u.data.len] = '\0'; (*zdip)->sysno = atoi_n (node_id->u.data.data, node_id->u.data.len); - (*zdip)->attributeDetails = + (*zdip)->attributeDetails = (zebAttributeDetails) nmem_malloc (zei->nmem, sizeof(*(*zdip)->attributeDetails)); (*zdip)->attributeDetails->sysno = atoi_n (node_aid->u.data.data, node_aid->u.data.len); @@ -503,26 +577,28 @@ ZebraExplainInfo zebraExplain_open ( zdip = &(*zdip)->next; } - np = data1_search_tag (zei->dh, node_zebra->child, - "ordinalSU"); - np = np->child; - assert (np && np->which == DATA1N_data); - zei->ordinalSU = atoi_n (np->u.data.data, np->u.data.len); - - np = data1_search_tag (zei->dh, node_zebra->child, - "runNumber"); - np = np->child; - assert (np && np->which == DATA1N_data); - zei->runNumber = atoi_n (np->u.data.data, np->u.data.len); - *zdip = NULL; + if (node_zebra) + { + np = data1_search_tag (zei->dh, node_zebra->child, + "ordinalSU"); + np = np->child; + assert (np && np->which == DATA1N_data); + zei->ordinalSU = atoi_n (np->u.data.data, np->u.data.len); + + np = data1_search_tag (zei->dh, node_zebra->child, + "runNumber"); + np = np->child; + assert (np && np->which == DATA1N_data); + zei->runNumber = atoi_n (np->u.data.data, np->u.data.len); + *zdip = NULL; + } rec_rm (&trec); } else /* create initial targetInfo */ { data1_node *node_tgtinfo; - zei->ordinalSU = 1; - zei->runNumber = 0; + *zdip = NULL; if (writeFlag) { char *sgml_buf; @@ -536,12 +612,16 @@ ZebraExplainInfo zebraExplain_open ( "1\n" "Zebra\n" "\n" ); - + if (!zei->data1_target || !zei->data1_target->u.root.absyn) + { + logf (LOG_FATAL, "Explain schema missing. Check profilePath"); + nmem_destroy (zei->nmem); + return 0; + } node_tgtinfo = data1_search_tag (zei->dh, zei->data1_target->child, "targetInfo"); assert (node_tgtinfo); - zebraExplain_initCommonInfo (zei, node_tgtinfo); zebraExplain_initAccessInfo (zei, node_tgtinfo); @@ -553,15 +633,37 @@ ZebraExplainInfo zebraExplain_open ( rec_strdup ("IR-Explain-1", &trec->size[recInfo_databaseName]); sgml_buf = data1_nodetoidsgml(dh, zei->data1_target, 0, &sgml_len); - trec->info[recInfo_storeData] = xmalloc (sgml_len); + trec->info[recInfo_storeData] = (char *) xmalloc (sgml_len); memcpy (trec->info[recInfo_storeData], sgml_buf, sgml_len); trec->size[recInfo_storeData] = sgml_len; rec_put (records, &trec); + rec_rm (&trec); + } - *zdip = NULL; - rec_rm (&trec); zebraExplain_newDatabase (zei, "IR-Explain-1", 0); + + if (!zei->categoryList->dirty) + { + struct zebraCategoryListInfo *zcl = zei->categoryList; + data1_node *node_cl; + + zcl->dirty = 1; + zcl->data1_categoryList = + data1_read_sgml (zei->dh, zei->nmem, + "CategoryList\n" + "\n"); + + if (zcl->data1_categoryList) + { + assert (zcl->data1_categoryList->child); + node_cl = data1_search_tag (zei->dh, + zcl->data1_categoryList->child, + "categoryList"); + assert (node_cl); + zebraExplain_initCommonInfo (zei, node_cl); + } + } } return zei; } @@ -590,6 +692,9 @@ static void zebraExplain_readAttributeDetails (ZebraExplainInfo zei, data1_node *node_use = NULL; data1_node *node_ordinal = NULL; data1_node *np2; + char oid_str[128]; + int oid_str_len; + if (np->which != DATA1N_tag || strcmp (np->u.tag.tag, "attr")) continue; for (np2 = np->child; np2; np2 = np2->next) @@ -605,10 +710,17 @@ static void zebraExplain_readAttributeDetails (ZebraExplainInfo zei, node_ordinal = np2->child; } assert (node_set && node_use && node_ordinal); - - *zsuip = nmem_malloc (zei->nmem, sizeof(**zsuip)); - (*zsuip)->info.set = atoi_n (node_set->u.data.data, - node_set->u.data.len); + + oid_str_len = node_set->u.data.len; + if (oid_str_len >= (int) sizeof(oid_str)) + oid_str_len = sizeof(oid_str)-1; + memcpy (oid_str, node_set->u.data.data, oid_str_len); + oid_str[oid_str_len] = '\0'; + + *zsuip = (struct zebSUInfoB *) + nmem_malloc (zei->nmem, sizeof(**zsuip)); + (*zsuip)->info.set = oid_getvalbyname (oid_str); + (*zsuip)->info.use = atoi_n (node_use->u.data.data, node_use->u.data.len); (*zsuip)->info.ordinal = atoi_n (node_ordinal->u.data.data, @@ -639,9 +751,10 @@ static void zebraExplain_readDatabase (ZebraExplainInfo zei, node_zebra = data1_search_tag (zei->dh, node_dbinfo->child, "zebraInfo"); - np = data1_search_tag (zei->dh, node_dbinfo->child, - "recordBytes"); - if (np && np->child && np->child->which == DATA1N_data) + if (node_zebra + && (np = data1_search_tag (zei->dh, node_zebra->child, + "recordBytes")) + && np->child && np->child->which == DATA1N_data) zdi->recordBytes = atoi_n (np->child->u.data.data, np->child->u.data.len); if ((np = data1_search_tag (zei->dh, node_dbinfo->child, @@ -652,7 +765,7 @@ static void zebraExplain_readDatabase (ZebraExplainInfo zei, { zdi->recordCount = atoi_n (np->child->u.data.data, np->child->u.data.len); - } + } zdi->readFlag = 0; rec_rm (&rec); } @@ -757,7 +870,7 @@ int zebraExplain_newDatabase (ZebraExplainInfo zei, const char *database, if (zdi) return -1; /* it's new really. make it */ - zdi = nmem_malloc (zei->nmem, sizeof(*zdi)); + zdi = (struct zebDatabaseInfoB *) nmem_malloc (zei->nmem, sizeof(*zdi)); zdi->next = zei->databaseInfo; zei->databaseInfo = zdi; zdi->sysno = 0; @@ -775,6 +888,8 @@ int zebraExplain_newDatabase (ZebraExplainInfo zei, const char *database, data1_read_sgml (zei->dh, zei->nmem, "DatabaseInfo\n" "\n"); + if (!zdi->data1_database) + return -2; node_dbinfo = data1_search_tag (zei->dh, zdi->data1_database->child, "databaseInfo"); @@ -803,7 +918,7 @@ int zebraExplain_newDatabase (ZebraExplainInfo zei, const char *database, zei->dirty = 1; zei->curDatabaseInfo = zdi; - zdi->attributeDetails = + zdi->attributeDetails = (zebAttributeDetails) nmem_malloc (zei->nmem, sizeof(*zdi->attributeDetails)); zdi->attributeDetails->readFlag = 0; zdi->attributeDetails->sysno = 0; @@ -849,6 +964,67 @@ static void writeAttributeValueDetails (ZebraExplainInfo zei, } } +static void zebraExplain_writeCategoryList (ZebraExplainInfo zei, + struct zebraCategoryListInfo *zcl, + int key_flush) +{ + char *sgml_buf; + int sgml_len; + int i; + Record drec; + data1_node *node_ci, *node_categoryList; + int sysno = 0; + static char *category[] = { + "CategoryList", + "TargetInfo", + "DatabaseInfo", + "AttributeDetails", + NULL + }; + + assert (zcl); + if (!zcl->dirty) + return ; + zcl->dirty = 1; + node_categoryList = zcl->data1_categoryList; + +#if ZINFO_DEBUG + logf (LOG_LOG, "zebraExplain_writeCategoryList"); +#endif + + drec = createRecord (zei->records, &sysno); + + node_ci = data1_search_tag (zei->dh, node_categoryList->child, + "categoryList"); + assert (node_ci); + node_ci = data1_add_tag (zei->dh, node_ci, "categories", zei->nmem); + assert (node_ci); + + for (i = 0; category[i]; i++) + { + data1_node *node_cat = data1_add_tag (zei->dh, node_ci, + "category", zei->nmem); + + data1_add_tagdata_text (zei->dh, node_cat, "name", + category[i], zei->nmem); + } + /* extract *searchable* keys from it. We do this here, because + record count, etc. is affected */ + if (key_flush) + (*zei->updateFunc)(zei->updateHandle, drec, node_categoryList); + + /* convert to "SGML" and write it */ +#if ZINFO_DEBUG + data1_pr_tree (zei->dh, node_categoryList, stderr); +#endif + sgml_buf = data1_nodetoidsgml(zei->dh, node_categoryList, 0, &sgml_len); + drec->info[recInfo_storeData] = (char *) xmalloc (sgml_len); + memcpy (drec->info[recInfo_storeData], sgml_buf, sgml_len); + drec->size[recInfo_storeData] = sgml_len; + + rec_put (zei->records, &drec); +} + static void zebraExplain_writeAttributeDetails (ZebraExplainInfo zei, zebAttributeDetails zad, const char *databaseName, @@ -916,22 +1092,22 @@ static void zebraExplain_writeAttributeDetails (ZebraExplainInfo zei, oe.proto = PROTO_Z3950; oe.oclass = CLASS_ATTSET; - oe.value = set_ordinal; + oe.value = (enum oid_value) set_ordinal; if (oid_ent_to_oid (&oe, oid)) { data1_node *node_abt, *node_atd, *node_atvs; data1_add_tagdata_oid (zei->dh, node_asd, "oid", oid, zei->nmem); - + node_abt = data1_add_tag (zei->dh, node_asd, "attributesByType", zei->nmem); node_atd = data1_add_tag (zei->dh, node_abt, "attributeTypeDetails", zei->nmem); data1_add_tagdata_int (zei->dh, node_atd, - "type", 1, zei->nmem); + "type", 1, zei->nmem); node_atvs = data1_add_tag (zei->dh, node_atd, - "attributeValues", zei->nmem); + "attributeValues", zei->nmem); writeAttributeValueDetails (zei, zad, node_atvs, attset); } } @@ -943,15 +1119,23 @@ static void zebraExplain_writeAttributeDetails (ZebraExplainInfo zei, "attrlist", zei->nmem); for (zsui = zad->SUInfo; zsui; zsui = zsui->next) { + struct oident oident; + int oid[OID_SIZE]; data1_node *node_attr; - node_attr = data1_add_tag (zei->dh, node_list, - "attr", zei->nmem); - data1_add_tagdata_int (zei->dh, node_attr, "set", - zsui->info.set, zei->nmem); + + node_attr = data1_add_tag (zei->dh, node_list, "attr", zei->nmem); + + oident.proto = PROTO_Z3950; + oident.oclass = CLASS_ATTSET; + oident.value = (enum oid_value) zsui->info.set; + oid_ent_to_oid (&oident, oid); + + data1_add_tagdata_text (zei->dh, node_attr, "set", + oident.desc, zei->nmem); data1_add_tagdata_int (zei->dh, node_attr, "use", - zsui->info.use, zei->nmem); + zsui->info.use, zei->nmem); data1_add_tagdata_int (zei->dh, node_attr, "ordinal", - zsui->info.ordinal, zei->nmem); + zsui->info.ordinal, zei->nmem); } /* convert to "SGML" and write it */ #if ZINFO_DEBUG @@ -959,7 +1143,7 @@ static void zebraExplain_writeAttributeDetails (ZebraExplainInfo zei, #endif sgml_buf = data1_nodetoidsgml(zei->dh, zad->data1_tree, 0, &sgml_len); - drec->info[recInfo_storeData] = xmalloc (sgml_len); + drec->info[recInfo_storeData] = (char *) xmalloc (sgml_len); memcpy (drec->info[recInfo_storeData], sgml_buf, sgml_len); drec->size[recInfo_storeData] = sgml_len; @@ -1011,7 +1195,7 @@ static void zebraExplain_writeDatabase (ZebraExplainInfo zei, #endif sgml_buf = data1_nodetoidsgml(zei->dh, zdi->data1_database, 0, &sgml_len); - drec->info[recInfo_storeData] = xmalloc (sgml_len); + drec->info[recInfo_storeData] = (char *) xmalloc (sgml_len); memcpy (drec->info[recInfo_storeData], sgml_buf, sgml_len); drec->size[recInfo_storeData] = sgml_len; @@ -1107,7 +1291,7 @@ static void zebraExplain_writeAttributeSet (ZebraExplainInfo zei, data1_pr_tree (zei->dh, node_root, stderr); #endif sgml_buf = data1_nodetoidsgml(zei->dh, node_root, 0, &sgml_len); - drec->info[recInfo_storeData] = xmalloc (sgml_len); + drec->info[recInfo_storeData] = (char *) xmalloc (sgml_len); memcpy (drec->info[recInfo_storeData], sgml_buf, sgml_len); drec->size[recInfo_storeData] = sgml_len; @@ -1169,7 +1353,7 @@ static void zebraExplain_writeTarget (ZebraExplainInfo zei, int key_flush) #endif sgml_buf = data1_nodetoidsgml(zei->dh, zei->data1_target, 0, &sgml_len); - trec->info[recInfo_storeData] = xmalloc (sgml_len); + trec->info[recInfo_storeData] = (char *) xmalloc (sgml_len); memcpy (trec->info[recInfo_storeData], sgml_buf, sgml_len); trec->size[recInfo_storeData] = sgml_len; @@ -1199,7 +1383,7 @@ zebAccessObject zebraExplain_announceOid (ZebraExplainInfo zei, break; if (!ao) { - ao = nmem_malloc (zei->nmem, sizeof(*ao)); + ao = (zebAccessObject) nmem_malloc (zei->nmem, sizeof(*ao)); ao->handle = NULL; ao->sysno = 0; ao->oid = odr_oiddup_nmem (zei->nmem, oid); @@ -1216,7 +1400,7 @@ void zebraExplain_addAttributeSet (ZebraExplainInfo zei, int set) oe.proto = PROTO_Z3950; oe.oclass = CLASS_ATTSET; - oe.value = set; + oe.value = (enum oid_value) set; if (oid_ent_to_oid (&oe, oid)) { @@ -1236,7 +1420,7 @@ int zebraExplain_addSU (ZebraExplainInfo zei, int set, int use) if (zsui->info.use == use && zsui->info.set == set) return -1; zebraExplain_addAttributeSet (zei, set); - zsui = nmem_malloc (zei->nmem, sizeof(*zsui)); + zsui = (struct zebSUInfoB *) nmem_malloc (zei->nmem, sizeof(*zsui)); zsui->next = zei->curDatabaseInfo->attributeDetails->SUInfo; zei->curDatabaseInfo->attributeDetails->SUInfo = zsui; zei->curDatabaseInfo->attributeDetails->dirty = 1; @@ -1289,7 +1473,7 @@ RecordAttr *rec_init_attr (ZebraExplainInfo zei, Record rec) if (rec->info[recInfo_attr]) return (RecordAttr *) rec->info[recInfo_attr]; - recordAttr = xmalloc (sizeof(*recordAttr)); + recordAttr = (RecordAttr *) xmalloc (sizeof(*recordAttr)); rec->info[recInfo_attr] = (char *) recordAttr; rec->size[recInfo_attr] = sizeof(*recordAttr); @@ -1301,7 +1485,7 @@ RecordAttr *rec_init_attr (ZebraExplainInfo zei, Record rec) static void att_loadset(void *p, const char *n, const char *name) { - data1_handle dh = p; + data1_handle dh = (data1_handle) p; if (!data1_get_attset (dh, name)) logf (LOG_WARN, "Couldn't load attribute set %s", name); }