X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=zutil%2Fsrw.c;h=5b6657e1a2da73cb1c00bd6731ef1ae4d662c96f;hb=c39a893dfdae5f792139177132e7e7a70e010aa7;hp=61e15092d96d0d66248653614041cb9e5d164060;hpb=1f20fcf7c28b057d36b866ce9ba63dee95c27d41;p=yaz-moved-to-github.git diff --git a/zutil/srw.c b/zutil/srw.c index 61e1509..5b6657e 100644 --- a/zutil/srw.c +++ b/zutil/srw.c @@ -2,7 +2,7 @@ * Copyright (c) 2002-2003, Index Data. * See the file LICENSE for details. * - * $Id: srw.c,v 1.4 2003-02-17 22:35:48 adam Exp $ + * $Id: srw.c,v 1.15 2003-05-12 22:36:10 adam Exp $ */ #include @@ -11,6 +11,21 @@ #include #include +static void add_XML_n(xmlNodePtr ptr, const char *elem, char *val, int len) +{ + if (val) + { + xmlDocPtr doc = xmlParseMemory(val,len); + if (doc) + { + xmlNodePtr c = xmlNewChild(ptr, 0, elem, 0); + xmlNodePtr t = xmlDocGetRootElement(doc); + xmlAddChild(c, xmlCopyNode(t,1)); + xmlFreeDoc(doc); + } + } +} + static void add_xsd_string_n(xmlNodePtr ptr, const char *elem, char *val, int len) { @@ -45,13 +60,17 @@ static int match_element(xmlNodePtr ptr, const char *elem) return 0; } +#define CHECK_TYPE 0 + static int match_xsd_string_n(xmlNodePtr ptr, const char *elem, ODR o, char **val, int *len) { +#if CHECK_TYPE struct _xmlAttr *attr; +#endif if (!match_element(ptr, elem)) return 0; -#if 0 +#if CHECK_TYPE for (attr = ptr->properties; attr; attr = attr->next) if (!strcmp(attr->name, "type") && attr->children && attr->children->type == XML_TEXT_NODE) @@ -82,13 +101,42 @@ static int match_xsd_string(xmlNodePtr ptr, const char *elem, ODR o, { return match_xsd_string_n(ptr, elem, o, val, 0); } + +static int match_xsd_XML_n(xmlNodePtr ptr, const char *elem, ODR o, + char **val, int *len) +{ + xmlBufferPtr buf; + + if (!match_element(ptr, elem)) + return 0; + ptr = ptr->children; + if (!ptr) + return 0; + buf = xmlBufferCreate(); + + xmlNodeDump(buf, ptr->doc, ptr, 0, 0); + + *val = odr_malloc(o, buf->use+1); + memcpy (*val, buf->content, buf->use); + (*val)[buf->use] = '\0'; + + if (len) + *len = buf->use; + + xmlBufferFree(buf); + + return 1; +} + static int match_xsd_integer(xmlNodePtr ptr, const char *elem, ODR o, int **val) { +#if CHECK_TYPE struct _xmlAttr *attr; +#endif if (!match_element(ptr, elem)) return 0; -#if 0 +#if CHECK_TYPE for (attr = ptr->properties; attr; attr = attr->next) if (!strcmp(attr->name, "type") && attr->children && attr->children->type == XML_TEXT_NODE) @@ -135,6 +183,7 @@ static int yaz_srw_records(ODR o, xmlNodePtr pptr, Z_SRW_record **recs, { xmlNodePtr rptr; (*recs)[i].recordSchema = 0; + (*recs)[i].recordPacking = Z_SRW_recordPacking_string; (*recs)[i].recordData_buf = 0; (*recs)[i].recordData_len = 0; (*recs)[i].recordPosition = 0; @@ -147,6 +196,10 @@ static int yaz_srw_records(ODR o, xmlNodePtr pptr, Z_SRW_record **recs, &(*recs)[i].recordData_buf, &(*recs)[i].recordData_len)) ; + else if (match_xsd_XML_n(rptr, "recordXML", o, + &(*recs)[i].recordData_buf, + &(*recs)[i].recordData_len)) + (*recs)[i].recordPacking = Z_SRW_recordPacking_XML; else if (match_xsd_integer(rptr, "recordPosition", o, &(*recs)[i].recordPosition)) ; @@ -161,8 +214,17 @@ static int yaz_srw_records(ODR o, xmlNodePtr pptr, Z_SRW_record **recs, { xmlNodePtr rptr = xmlNewChild(pptr, 0, "record", 0); add_xsd_string(rptr, "recordSchema", (*recs)[i].recordSchema); - add_xsd_string_n(rptr, "recordData", (*recs)[i].recordData_buf, - (*recs)[i].recordData_len); + switch((*recs)[i].recordPacking) + { + case Z_SRW_recordPacking_string: + add_xsd_string_n(rptr, "recordData", (*recs)[i].recordData_buf, + (*recs)[i].recordData_len); + break; + case Z_SRW_recordPacking_XML: + add_XML_n(rptr, "recordXML", (*recs)[i].recordData_buf, + (*recs)[i].recordData_len); + break; + } add_xsd_integer(rptr, "recordPosition", (*recs)[i].recordPosition); } } @@ -221,7 +283,7 @@ static int yaz_srw_diagnostics(ODR o, xmlNodePtr pptr, Z_SRW_diagnostic **recs, } -int yaz_srw_codec(ODR o, void * vptr, Z_SRW_searchRetrieve **handler_data, +int yaz_srw_codec(ODR o, void * vptr, Z_SRW_PDU **handler_data, void *client_data, const char *ns) { xmlNodePtr pptr = vptr; @@ -232,21 +294,21 @@ int yaz_srw_codec(ODR o, void * vptr, Z_SRW_searchRetrieve **handler_data, while (method && method->type == XML_TEXT_NODE) method = method->next; - if (method->type != XML_ELEMENT_NODE) + if (!method || method->type != XML_ELEMENT_NODE) return -1; - if (method && !strcmp(method->name, "searchRetrieveRequest")) + if (!strcmp(method->name, "searchRetrieveRequest")) { - Z_SRW_searchRetrieve **p = handler_data; + Z_SRW_PDU **p = handler_data; xmlNodePtr ptr = method->children; Z_SRW_searchRetrieveRequest *req; *p = odr_malloc(o, sizeof(**p)); (*p)->which = Z_SRW_searchRetrieve_request; req = (*p)->u.request = odr_malloc(o, sizeof(*req)); - req->query = 0; - req->xQuery = 0; - req->sortKeys = 0; - req->xSortKeys = 0; + req->query_type = Z_SRW_query_type_cql; + req->query.cql = 0; + req->sort_type = Z_SRW_sort_type_none; + req->sort.none = 0; req->startRecord = 0; req->maximumRecords = 0; req->recordSchema = 0; @@ -256,14 +318,17 @@ int yaz_srw_codec(ODR o, void * vptr, Z_SRW_searchRetrieve **handler_data, for (; ptr; ptr = ptr->next) { if (match_xsd_string(ptr, "query", o, - &req->query)) - ; + &req->query.cql)) + req->query_type = Z_SRW_query_type_cql; else if (match_xsd_string(ptr, "pQuery", o, - &req->pQuery)) - ; + &req->query.pqf)) + req->query_type = Z_SRW_query_type_pqf; + else if (match_xsd_string(ptr, "xQuery", o, + &req->query.xcql)) + req->query_type = Z_SRW_query_type_xcql; else if (match_xsd_string(ptr, "sortKeys", o, - &req->sortKeys)) - ; + &req->sort.sortKeys)) + req->sort_type = Z_SRW_sort_type_sort; else if (match_xsd_string(ptr, "recordSchema", o, &req->recordSchema)) ; @@ -282,9 +347,9 @@ int yaz_srw_codec(ODR o, void * vptr, Z_SRW_searchRetrieve **handler_data, /* missing is xQuery, xSortKeys .. */ } } - else if (method && !strcmp(method->name, "searchRetrieveResponse")) + else if (!strcmp(method->name, "searchRetrieveResponse")) { - Z_SRW_searchRetrieve **p = handler_data; + Z_SRW_PDU **p = handler_data; xmlNodePtr ptr = method->children; Z_SRW_searchRetrieveResponse *res; @@ -324,7 +389,35 @@ int yaz_srw_codec(ODR o, void * vptr, Z_SRW_searchRetrieve **handler_data, &res->nextRecordPosition)) ; } + } + else if (!strcmp(method->name, "explainRequest")) + { + Z_SRW_PDU **p = handler_data; + Z_SRW_explainRequest *req; + + *p = odr_malloc(o, sizeof(**p)); + (*p)->which = Z_SRW_explain_request; + req = (*p)->u.explain_request = odr_malloc(o, sizeof(*req)); + req->dummy = 0; + } + else if (!strcmp(method->name, "explainResponse")) + { + Z_SRW_PDU **p = handler_data; + Z_SRW_explainResponse *res; + xmlNodePtr ptr = method->children; + *p = odr_malloc(o, sizeof(**p)); + (*p)->which = Z_SRW_explain_response; + res = (*p)->u.explain_response = odr_malloc(o, sizeof(*res)); + res->explainData_buf = 0; + res->explainData_len = 0; + res->explainPacking = Z_SRW_recordPacking_string; + for (; ptr; ptr = ptr->next) + { + match_xsd_string_n(ptr, "Explain", o, + &res->explainData_buf, + &res->explainData_len); + } } else return -1; @@ -332,17 +425,39 @@ int yaz_srw_codec(ODR o, void * vptr, Z_SRW_searchRetrieve **handler_data, } else if (o->direction == ODR_ENCODE) { - Z_SRW_searchRetrieve **p = handler_data; + Z_SRW_PDU **p = handler_data; if ((*p)->which == Z_SRW_searchRetrieve_request) { Z_SRW_searchRetrieveRequest *req = (*p)->u.request; - xmlNsPtr ns_srw = xmlNewNs(pptr, ns, "zs"); - xmlNodePtr ptr = xmlNewChild(pptr, ns_srw, + xmlNodePtr ptr = xmlNewChild(pptr, 0, "searchRetrieveRequest", 0); + xmlNsPtr ns_srw = xmlNewNs(ptr, ns, "zs"); + + xmlSetNs(ptr, ns_srw); - add_xsd_string(ptr, "query", req->query); - add_xsd_string(ptr, "pQuery", req->pQuery); - add_xsd_string(ptr, "sortKeys", req->sortKeys); + switch(req->query_type) + { + case Z_SRW_query_type_cql: + add_xsd_string(ptr, "query", req->query.cql); + break; + case Z_SRW_query_type_xcql: + add_xsd_string(ptr, "xQuery", req->query.xcql); + break; + case Z_SRW_query_type_pqf: + add_xsd_string(ptr, "pQuery", req->query.pqf); + break; + } + switch(req->sort_type) + { + case Z_SRW_sort_type_none: + break; + case Z_SRW_sort_type_sort: + add_xsd_string(ptr, "sortKeys", req->sort.sortKeys); + break; + case Z_SRW_sort_type_xSort: + add_xsd_string(ptr, "xSortKeys", req->sort.xSortKeys); + break; + } add_xsd_integer(ptr, "startRecord", req->startRecord); add_xsd_integer(ptr, "maximumRecords", req->maximumRecords); add_xsd_string(ptr, "recordSchema", req->recordSchema); @@ -352,10 +467,11 @@ int yaz_srw_codec(ODR o, void * vptr, Z_SRW_searchRetrieve **handler_data, else if ((*p)->which == Z_SRW_searchRetrieve_response) { Z_SRW_searchRetrieveResponse *res = (*p)->u.response; - xmlNsPtr ns_srw = xmlNewNs(pptr, ns, "zs"); - xmlNodePtr ptr = xmlNewChild(pptr, ns_srw, + xmlNodePtr ptr = xmlNewChild(pptr, 0, "searchRetrieveResponse", 0); + xmlNsPtr ns_srw = xmlNewNs(ptr, ns, "zs"); + xmlSetNs(ptr, ns_srw); add_xsd_integer(ptr, "numberOfRecords", res->numberOfRecords); add_xsd_string(ptr, "resultSetId", res->resultSetId); add_xsd_integer(ptr, "resultSetIdleTime", res->resultSetIdleTime); @@ -373,6 +489,24 @@ int yaz_srw_codec(ODR o, void * vptr, Z_SRW_searchRetrieve **handler_data, } add_xsd_integer(ptr, "nextRecordPosition", res->nextRecordPosition); } + else if ((*p)->which == Z_SRW_explain_request) + { + xmlNodePtr ptr = xmlNewChild(pptr, 0, "explainRequest", 0); + xmlNsPtr ns_srw = xmlNewNs(ptr, ns, "zs"); + + xmlSetNs(ptr, ns_srw); + } + else if ((*p)->which == Z_SRW_explain_response) + { + Z_SRW_explainResponse *res = (*p)->u.explain_response; + xmlNodePtr ptr = xmlNewChild(pptr, 0, "explainResponse", 0); + xmlNsPtr ns_srw = xmlNewNs(ptr, ns, "zs"); + + xmlSetNs(ptr, ns_srw); + + add_xsd_string_n(ptr, "Explain", res->explainData_buf, + res->explainData_len); + } else return -1; @@ -380,19 +514,19 @@ int yaz_srw_codec(ODR o, void * vptr, Z_SRW_searchRetrieve **handler_data, return 0; } -Z_SRW_searchRetrieve *yaz_srw_get(ODR o, int which) +Z_SRW_PDU *yaz_srw_get(ODR o, int which) { - Z_SRW_searchRetrieve *sr = odr_malloc(o, sizeof(*o)); + Z_SRW_PDU *sr = odr_malloc(o, sizeof(*o)); sr->which = which; switch(which) { case Z_SRW_searchRetrieve_request: - sr->u.request = odr_malloc(o, sizeof(*sr->u.request)); - sr->u.request->query = 0; - sr->u.request->xQuery = 0; - sr->u.request->pQuery = 0; - sr->u.request->sortKeys = 0; - sr->u.request->xSortKeys = 0; + sr->u.request = (Z_SRW_searchRetrieveRequest *) + odr_malloc(o, sizeof(*sr->u.request)); + sr->u.request->query_type = Z_SRW_query_type_cql; + sr->u.request->query.cql = 0; + sr->u.request->sort_type = Z_SRW_sort_type_none; + sr->u.request->sort.none = 0; sr->u.request->startRecord = 0; sr->u.request->maximumRecords = 0; sr->u.request->recordSchema = 0; @@ -400,7 +534,8 @@ Z_SRW_searchRetrieve *yaz_srw_get(ODR o, int which) sr->u.request->database = 0; break; case Z_SRW_searchRetrieve_response: - sr->u.response = odr_malloc(o, sizeof(*sr->u.response)); + sr->u.response = (Z_SRW_searchRetrieveResponse *) + odr_malloc(o, sizeof(*sr->u.response)); sr->u.response->numberOfRecords = 0; sr->u.response->resultSetId = 0; sr->u.response->resultSetIdleTime = 0; @@ -409,6 +544,18 @@ Z_SRW_searchRetrieve *yaz_srw_get(ODR o, int which) sr->u.response->diagnostics = 0; sr->u.response->num_diagnostics = 0; sr->u.response->nextRecordPosition = 0; + break; + case Z_SRW_explain_request: + sr->u.explain_request = (Z_SRW_explainRequest *) + odr_malloc(o, sizeof(*sr->u.explain_request)); + sr->u.explain_request->dummy = 0; + break; + case Z_SRW_explain_response: + sr->u.explain_response = (Z_SRW_explainResponse *) + odr_malloc(o, sizeof(*sr->u.explain_response)); + sr->u.explain_response->explainPacking = 0; + sr->u.explain_response->explainData_buf = 0; + sr->u.explain_response->explainData_len = 0; } return sr; } @@ -416,98 +563,293 @@ Z_SRW_searchRetrieve *yaz_srw_get(ODR o, int which) #endif -const char *yaz_srw_error_str (int code) -{ - return "SRW error"; -} - -#if 0 - -1 Permanent system error -2 System temporarily unavailable -3 Authentication error - /* Diagnostics Relating to CQL */ -Number Description -10 Illegal query -11 Unsupported query type (XCQL vs CQL) -12 Too many characters in query -13 Unbalanced or illegal use of parentheses -14 Unbalanced or illegal use of quotes -15 Illegal or unsupported index set -16 Illegal or unsupported index -17 Illegal or unsupported combination of index and index set -18 Illegal or unsupported combination of indexes -19 Illegal or unsupported relation -20 Illegal or unsupported relation modifier -21 Illegal or unsupported combination of relation modifers -22 Illegal or unsupported combination of relation and index -23 Too many characters in term -24 Illegal combination of relation and term -25 Special characters not quoted in term -26 Non special character escaped in term -27 Empty term unsupported -28 Masking character not supported -29 Masked words too short -30 Too many masking characters in term -31 Anchoring character not supported -32 Anchoring character in illegal or unsupported position -33 Combination of proximity/adjacency and masking characters not supported -34 Combination of proximity/adjacency and anchoring characters not supported -35 Terms only exclusion (stop) words -36 Term in invalid format for index or relation -37 Illegal or unsupported boolean operator -38 Too many boolean operators in query -39 Proximity not supported -40 Illegal or unsupported proximity relation -41 Illegal or unsupported proximity distance -42 Illegal or unsupported proximity unit -43 Illegal or unsupported proximity ordering -44 Illegal or unsupported combination of proximity modifiers -45 Index set name (prefix) assigned to multiple identifiers +static struct { + int code; + const char *msg; +} yaz_srw_codes [] = { +{1, "Permanent system error"}, +{2, "System temporarily unavailable"}, +{3, "Authentication error"}, +/* Diagnostics Relating to CQL */ +{10, "Illegal query"}, +{11, "Unsupported query type (XCQL vs CQL)"}, +{12, "Too many characters in query"}, +{13, "Unbalanced or illegal use of parentheses"}, +{14, "Unbalanced or illegal use of quotes"}, +{15, "Illegal or unsupported index set"}, +{16, "Illegal or unsupported index"}, +{17, "Illegal or unsupported combination of index and index set"}, +{18, "Illegal or unsupported combination of indexes"}, +{19, "Illegal or unsupported relation"}, +{20, "Illegal or unsupported relation modifier"}, +{21, "Illegal or unsupported combination of relation modifers"}, +{22, "Illegal or unsupported combination of relation and index"}, +{23, "Too many characters in term"}, +{24, "Illegal combination of relation and term"}, +{25, "Special characters not quoted in term"}, +{26, "Non special character escaped in term"}, +{27, "Empty term unsupported"}, +{28, "Masking character not supported"}, +{29, "Masked words too short"}, +{30, "Too many masking characters in term"}, +{31, "Anchoring character not supported"}, +{32, "Anchoring character in illegal or unsupported position"}, +{33, "Combination of proximity/adjacency and masking characters not supported"}, +{34, "Combination of proximity/adjacency and anchoring characters not supported"}, +{35, "Terms only exclusion (stop) words"}, +{36, "Term in invalid format for index or relation"}, +{37, "Illegal or unsupported boolean operator"}, +{38, "Too many boolean operators in query"}, +{39, "Proximity not supported"}, +{40, "Illegal or unsupported proximity relation"}, +{41, "Illegal or unsupported proximity distance"}, +{42, "Illegal or unsupported proximity unit"}, +{43, "Illegal or unsupported proximity ordering"}, +{44, "Illegal or unsupported combination of proximity modifiers"}, +{45, "Index set name (prefix) assigned to multiple identifiers"}, /* Diagnostics Relating to Result Sets */ -Number Description -50 Result sets not supported -51 Result set does not exist -52 Result set temporarily unavailable -53 Result sets only supported for retrieval -54 Retrieval may only occur from an existing result set -55 Combination of result sets with search terms not supported -56 Only combination of single result set with search terms supported -57 Result set created but no records available -58 Result set created with unpredictable partial results available -59 Result set created with valid partial results available +{50, "Result sets not supported"}, +{51, "Result set does not exist"}, +{52, "Result set temporarily unavailable"}, +{53, "Result sets only supported for retrieval"}, +{54, "Retrieval may only occur from an existing result set"}, +{55, "Combination of result sets with search terms not supported"}, +{56, "Only combination of single result set with search terms supported"}, +{57, "Result set created but no records available"}, +{58, "Result set created with unpredictable partial results available"}, +{59, "Result set created with valid partial results available"}, /* Diagnostics Relating to Records */ -Number Description -60 Too many records retrieved -61 First record position out of range -62 Negative number of records requested -63 System error in retrieving records -64 Record temporarily unavailable -65 Record does not exist -66 Unknown schema for retrieval -67 Record not available in this schema -68 Not authorised to send record -69 Not authorised to send record in this schema -70 Record too large to send +{60, "Too many records retrieved"}, +{61, "First record position out of range"}, +{62, "Negative number of records requested"}, +{63, "System error in retrieving records"}, +{64, "Record temporarily unavailable"}, +{65, "Record does not exist"}, +{66, "Unknown schema for retrieval"}, +{67, "Record not available in this schema"}, +{68, "Not authorised to send record"}, +{69, "Not authorised to send record in this schema"}, +{70, "Record too large to send"}, /* Diagnostics Relating to Sorting */ -Number Description -80 Sort not supported -81 Unsupported sort type (sortKeys vs xSortKeys) -82 Illegal or unsupported sort sequence -83 Too many records -84 Too many sort keys -85 Duplicate sort keys -86 Incompatible record formats -87 Unsupported schema for sort -88 Unsupported tag path for sort -89 Tag path illegal or unsupported for schema -90 Illegal or unsupported direction value -91 Illegal or unsupported case value -92 Illegal or unsupported missing value action +{80, "Sort not supported"}, +{81, "Unsupported sort type (sortKeys vs xSortKeys)"}, +{82, "Illegal or unsupported sort sequence"}, +{83, "Too many records"}, +{84, "Too many sort keys"}, +{85, "Duplicate sort keys"}, +{86, "Incompatible record formats"}, +{87, "Unsupported schema for sort"}, +{88, "Unsupported tag path for sort"}, +{89, "Tag path illegal or unsupported for schema"}, +{90, "Illegal or unsupported direction value"}, +{91, "Illegal or unsupported case value"}, +{92, "Illegal or unsupported missing value action"}, /* Diagnostics Relating to Explain */ -Number Description -100 Explain not supported -101 Explain request type not supported (SOAP vs GET) -102 Explain record temporarily unavailable +{100, "Explain not supported"}, +{101, "Explain request type not supported (SOAP vs GET)"}, +{102, "Explain record temporarily unavailable"}, +{0, 0} +}; -#endif +const char *yaz_diag_srw_str (int code) +{ + int i; + for (i = 0; yaz_srw_codes[i].code; i++) + if (yaz_srw_codes[i].code == code) + return yaz_srw_codes[i].msg; + return 0; +} + + +/* bib1:srw */ +static int srw_bib1_map[] = { + 1, 1, + 2, 2, + 3, 11, + 4, 35, + 5, 12, + 6, 38, + 7, 30, + 8, 32, + 9, 29, + 10, 10, + 11, 12, + 11, 23, + 12, 60, + 13, 61, + 13, 62, + 14, 63, + 14, 64, + 14, 65, + 15, 68, + 15, 69, + 16, 70, + 17, 70, + 18, 50, + 19, 55, + 20, 56, + 21, 52, + 22, 50, + 23, 1, /* bad map */ + 24, 63, /* bad map */ + 25, 63, /* bad map */ + 26, 63, /* bad map */ + 27, 51, + 28, 52, + 29, 52, + 30, 51, + 31, 57, + 32, 58, + 33, 59, + 100, 1, /* bad map */ + 101, 3, + 102, 3, + 103, 3, + 104, 3, + 105, 3, + 106, 66, + 107, 11, + 108, 10, + 108, 13, + 108, 14, + 108, 25, + 108, 26, + 108, 27, + 108, 45, + + 109, 1, + 110, 37, + 111, 1, + 112, 58, + 113, 10, + 114, 16, + 115, 16, + 116, 16, + 117, 19, + 118, 22, + 119, 32, + 119, 31, + 120, 28, + 121, 15, + 122, 32, + 123, 22, + 123, 17, + 123, 18, + 124, 24, + 125, 36, + 126, 36, + 127, 36, + 128, 51, + 129, 39, + 130, 43, + 131, 40, + 132, 42, + 201, 44, + 201, 33, + 201, 34, + 202, 41, + 203, 43, + 205, 1, /* bad map */ + 206, 1, /* bad map */ + 207, 89, + 208, 1, /* bad map */ + 209, 80, + 210, 80, + 210, 81, + 211, 84, + 212, 85, + 213, 92, + 214, 90, + 215, 91, + 216, 92, + 217, 63, + 218, 1, /* bad map */ + 219, 1, /* bad map */ + 220, 1, /* bad map */ + 221, 1, /* bad map */ + 222, 1, /* bad map */ + 223, 1, /* bad map */ + 224, 1, /* bad map */ + 225, 1, /* bad map */ + 226, 1, /* bad map */ + 227, 66, + 228, 1, /* bad map */ + 229, 36, + 230, 83, + 231, 89, + 232, 1, + 233, 1, /* bad map */ + 234, 1, /* bad map */ + 235, 2, + 236, 3, + 237, 82, + 238, 67, + 239, 66, + 240, 1, /* bad map */ + 241, 1, /* bad map */ + 242, 70, + 243, 1, /* bad map */ + 244, 66, + 245, 10, + 246, 10, + 247, 10, + 1001, 1, /* bad map */ + 1002, 1, /* bad map */ + 1003, 1, /* bad map */ + 1004, 1, /* bad map */ + 1005, 1, /* bad map */ + 1006, 1, /* bad map */ + 1007, 100, + 1008, 1, + 1009, 1, + 1010, 3, + 1011, 3, + 1012, 3, + 1013, 3, + 1014, 3, + 1015, 3, + 1015, 3, + 1016, 3, + 1017, 3, + 1018, 2, + 1019, 2, + 1020, 2, + 1021, 3, + 1022, 3, + 1023, 3, + 1024, 16, + 1025, 3, + 1026, 64, + 1027, 1, + 1028, 65, + 1029, 1, + 1040, 1, + /* 1041-1065 */ + 1066, 66, + 1066, 67, + 0 +}; + +int yaz_diag_bib1_to_srw (int code) +{ + const int *p = srw_bib1_map; + while (*p) + { + if (code == p[0]) + return p[1]; + p += 2; + } + return 1; +} + +int yaz_diag_srw_to_bib1(int code) +{ + const int *p = srw_bib1_map; + while (*p) + { + if (code == p[1]) + return p[0]; + p += 2; + } + return 1; +}