static int yaz_marc_line_gets(int (*getbyte)(void *client_data), void (*ungetbyte)(int b, void *client_data), void *client_data, WRBUF w) { int more; wrbuf_rewind(w); more = yaz_gets(getbyte, ungetbyte, client_data, w); if (!more) return 0; while (more) { int i; for (i = 0; i<4; i++) { int ch = getbyte(client_data); if (ch != ' ') { if (ch) ungetbyte(ch, client_data); return 1; } } if (wrbuf_len(w) > 60 && wrbuf_buf(w)[wrbuf_len(w)-1] == '=') wrbuf_cut_right(w, 1); else wrbuf_puts(w, " "); more = yaz_gets(getbyte, ungetbyte, client_data, w); } return 1; }
static void json_indent(WRBUF result, int indent) { size_t l = wrbuf_len(result); if (l == 0 || wrbuf_buf(result)[l-1] == '\n') { int i; for (i = 0; i < indent; i++) wrbuf_putc(result, ' '); } }
static int convert_solrmarc(void *info, WRBUF record, WRBUF wr_error) { WRBUF w = wrbuf_alloc(); const char *buf = wrbuf_buf(record); size_t i, sz = wrbuf_len(record); for (i = 0; i < sz; i++) { int ch; if (buf[i] == '#' && i < sz - 3 && buf[i+3] == ';' && atoi_n_check(buf+i+1, 2, &ch)) i += 3; else ch = buf[i]; wrbuf_putc(w, ch); } wrbuf_rewind(record); wrbuf_write(record, wrbuf_buf(w), wrbuf_len(w)); wrbuf_destroy(w); return 0; }
int solr_transform_rpn2solr_stream(solr_transform_t ct, void (*pr)(const char *buf, void *client_data), void *client_data, Z_RPNQuery *q) { WRBUF w = wrbuf_alloc(); int r = solr_transform_rpn2solr_stream_r(ct, w, pr, client_data, q); if (r) solr_transform_set_error(ct, r, wrbuf_len(w) ? wrbuf_cstr(w) : 0); wrbuf_destroy(w); return r; }
static int convert_xslt(void *vinfo, WRBUF record, WRBUF wr_error) { int ret = 0; struct xslt_info *info = vinfo; xmlDocPtr doc = xmlParseMemory(wrbuf_buf(record), wrbuf_len(record)); if (!doc) { wrbuf_printf(wr_error, "xmlParseMemory failed"); ret = -1; } else { xmlDocPtr xsp_doc = xmlCopyDoc(info->xsp_doc, 1); xsltStylesheetPtr xsp = xsltParseStylesheetDoc(xsp_doc); xmlDocPtr res = xsltApplyStylesheet(xsp, doc, info->xsl_parms); if (res) { xmlChar *out_buf = 0; int out_len; #if HAVE_XSLTSAVERESULTTOSTRING xsltSaveResultToString(&out_buf, &out_len, res, xsp); #else xmlDocDumpFormatMemory (res, &out_buf, &out_len, 1); #endif if (!out_buf) { wrbuf_printf(wr_error, "xsltSaveResultToString failed"); ret = -1; } else { wrbuf_rewind(record); wrbuf_write(record, (const char *) out_buf, out_len); xmlFree(out_buf); } xmlFreeDoc(res); } else { wrbuf_printf(wr_error, "xsltApplyStylesheet failed"); ret = -1; } xmlFreeDoc(doc); xsltFreeStylesheet(xsp); /* frees xsp_doc too */ } return ret; }
int yaz_marc_decode_buf (yaz_marc_t mt, const char *buf, int bsize, const char **result, size_t *rsize) { int r; wrbuf_rewind(mt->m_wr); r = yaz_marc_decode_wrbuf(mt, buf, bsize, mt->m_wr); if (result) *result = wrbuf_cstr(mt->m_wr); if (rsize) *rsize = wrbuf_len(mt->m_wr); return r; }
static int conv_convert_test(yaz_record_conv_t p, const char *input_record, const char *output_expect_record) { int ret = 0; if (!p) { YAZ_CHECK(ret); } else { WRBUF output_record = wrbuf_alloc(); int r = yaz_record_conv_record(p, input_record, strlen(input_record), output_record); if (r) { if (output_expect_record) { printf("yaz_record_conv error=%s\n", yaz_record_conv_get_error(p)); ret = 0; } else ret = 1; } else { if (!output_expect_record) { ret = 0; } else if (strcmp(output_expect_record, wrbuf_cstr(output_record))) { ret = 0; printf("got-output_record len=%ld: %s\n", (long) wrbuf_len(output_record), wrbuf_cstr(output_record)); printf("output_expect_record len=%ld %s\n", (long) strlen(output_expect_record), output_expect_record); } else { ret = 1; } } wrbuf_destroy(output_record); } return ret; }
static int convert_select(void *vinfo, WRBUF record, WRBUF wr_error) { int ret = 0; struct select_info *info = vinfo; xmlDocPtr doc = xmlParseMemory(wrbuf_buf(record), wrbuf_len(record)); if (!doc) { wrbuf_printf(wr_error, "xmlParseMemory failed"); ret = -1; } else { xmlXPathContextPtr xpathCtx = xmlXPathNewContext(doc); if (xpathCtx && info->xpath_expr) { xmlXPathObjectPtr xpathObj = xmlXPathEvalExpression((const xmlChar *) info->xpath_expr, xpathCtx); if (xpathObj) { xmlNodeSetPtr nodes = xpathObj->nodesetval; if (nodes) { int i; if (nodes->nodeNr > 0) wrbuf_rewind(record); for (i = 0; i < nodes->nodeNr; i++) { xmlNode *ptr = nodes->nodeTab[i]; if (ptr->type == XML_ELEMENT_NODE) ptr = ptr->children; for (; ptr; ptr = ptr->next) if (ptr->type == XML_TEXT_NODE) wrbuf_puts(record, (const char *) ptr->content); } } xmlXPathFreeObject(xpathObj); } xmlXPathFreeContext(xpathCtx); } xmlFreeDoc(doc); } return ret; }
int yaz_record_conv_opac_record(yaz_record_conv_t p, Z_OPACRecord *input_record, WRBUF output_record) { int ret = 0; struct yaz_record_conv_rule *r = p->rules; if (!r || r->type->construct != construct_marc) { wrbuf_puts(p->wr_error, "Expecting MARC rule as first rule for OPAC"); ret = -1; /* no marc rule so we can't do OPAC */ } else { struct marc_info *mi = r->info; const char *input_charset = mi->input_charset; yaz_iconv_t cd; WRBUF res = wrbuf_alloc(); yaz_marc_t mt = yaz_marc_create(); if (yaz_opac_check_marc21_coding(input_charset, input_record)) input_charset = "utf-8"; cd = yaz_iconv_open(mi->output_charset, input_charset); wrbuf_rewind(p->wr_error); yaz_marc_xml(mt, mi->output_format_mode); yaz_marc_iconv(mt, cd); yaz_opac_decode_wrbuf(mt, input_record, res); if (ret != -1) { ret = yaz_record_conv_record_rule(p, r->next, wrbuf_buf(res), wrbuf_len(res), output_record); } yaz_marc_destroy(mt); if (cd) yaz_iconv_close(cd); wrbuf_destroy(res); } return ret; }
static void tstwrbuf(void) { int step; WRBUF wr = wrbuf_alloc(); YAZ_CHECK(wr); wrbuf_destroy(wr); wr = wrbuf_alloc(); YAZ_CHECK(wr); for (step = 1; step < 65; step++) { int i, j, k; int len; char buf[64]; char *cp; for (j = 1; j<step; j++) { for (i = 0; i<j; i++) buf[i] = i+1; buf[i] = '\0'; wrbuf_puts(wr, buf); } cp = wrbuf_buf(wr); len = wrbuf_len(wr); YAZ_CHECK(len == step * (step-1) / 2); k = 0; for (j = 1; j<step; j++) for (i = 0; i<j; i++) { YAZ_CHECK(cp[k] == i+1); k++; } wrbuf_rewind(wr); } wrbuf_destroy(wr); }
static int yaz_query_charset_convert_buf(char *buf_in, int len_in, char **buf_out, int *len_out, ODR o, WRBUF wrbuf, yaz_iconv_t cd) { int r = 0; wrbuf_rewind(wrbuf); wrbuf_iconv_write(wrbuf, cd, buf_in, len_in); wrbuf_iconv_reset(wrbuf, cd); *len_out = wrbuf_len(wrbuf); if (*len_out == 0) { /* we assume conversion failed */ *buf_out = buf_in; *len_out = len_in; r = -1; } else { /* conversion OK */ *buf_out = (char*) odr_malloc(o, *len_out); memcpy(*buf_out, wrbuf_buf(wrbuf), *len_out); } return r; }
static int tst_convert_x(yaz_iconv_t cd, const char *buf, const char *cmpbuf, int expect_error) { int ret = 1; WRBUF b = wrbuf_alloc(); char outbuf[16]; size_t inbytesleft = strlen(buf); const char *inp = buf; int rounds = 0; for (rounds = 0; inbytesleft && rounds < (int) sizeof(outbuf); rounds++) { size_t outbytesleft = sizeof(outbuf); char *outp = outbuf; size_t r = yaz_iconv(cd, (char**) &inp, &inbytesleft, &outp, &outbytesleft); wrbuf_write(b, outbuf, outp - outbuf); if (r == (size_t) (-1)) { int e = yaz_iconv_error(cd); if (e != YAZ_ICONV_E2BIG) { if (expect_error != -1) if (e != expect_error) ret = 0; break; } } else { size_t outbytesleft = sizeof(outbuf); char *outp = outbuf; r = yaz_iconv(cd, 0, 0, &outp, &outbytesleft); wrbuf_write(b, outbuf, outp - outbuf); if (expect_error != -1) if (expect_error) ret = 0; break; } } if (wrbuf_len(b) == strlen(cmpbuf) && !memcmp(cmpbuf, wrbuf_buf(b), wrbuf_len(b))) ; else { WRBUF w = wrbuf_alloc(); ret = 0; wrbuf_rewind(w); wrbuf_puts_escaped(w, buf); yaz_log(YLOG_LOG, "input %s", wrbuf_cstr(w)); wrbuf_rewind(w); wrbuf_write_escaped(w, wrbuf_buf(b), wrbuf_len(b)); yaz_log(YLOG_LOG, "got %s", wrbuf_cstr(w)); wrbuf_rewind(w); wrbuf_puts_escaped(w, cmpbuf); yaz_log(YLOG_LOG, "exp %s", wrbuf_cstr(w)); wrbuf_destroy(w); } wrbuf_destroy(b); return ret; }
int yaz_marc_write_iso2709(yaz_marc_t mt, WRBUF wr) { struct yaz_marc_node *n; int indicator_length; int identifier_length; int length_data_entry; int length_starting; int length_implementation; int data_offset = 0; const char *leader = 0; WRBUF wr_dir, wr_head, wr_data_tmp; int base_address; for (n = mt->nodes; n; n = n->next) if (n->which == YAZ_MARC_LEADER) leader = n->u.leader; if (!leader) return -1; if (!atoi_n_check(leader+10, 1, &indicator_length)) return -1; if (!atoi_n_check(leader+11, 1, &identifier_length)) return -1; if (!atoi_n_check(leader+20, 1, &length_data_entry)) return -1; if (!atoi_n_check(leader+21, 1, &length_starting)) return -1; if (!atoi_n_check(leader+22, 1, &length_implementation)) return -1; wr_data_tmp = wrbuf_alloc(); wr_dir = wrbuf_alloc(); for (n = mt->nodes; n; n = n->next) { int data_length = 0; struct yaz_marc_subfield *s; switch(n->which) { case YAZ_MARC_DATAFIELD: wrbuf_printf(wr_dir, "%.3s", n->u.datafield.tag); data_length += indicator_length; wrbuf_rewind(wr_data_tmp); for (s = n->u.datafield.subfields; s; s = s->next) { /* write dummy IDFS + content */ wrbuf_iconv_putchar(wr_data_tmp, mt->iconv_cd, ' '); wrbuf_iconv_puts(wr_data_tmp, mt->iconv_cd, s->code_data); marc_iconv_reset(mt, wr_data_tmp); } /* write dummy FS (makes MARC-8 to become ASCII) */ wrbuf_iconv_putchar(wr_data_tmp, mt->iconv_cd, ' '); marc_iconv_reset(mt, wr_data_tmp); data_length += wrbuf_len(wr_data_tmp); break; case YAZ_MARC_CONTROLFIELD: wrbuf_printf(wr_dir, "%.3s", n->u.controlfield.tag); wrbuf_rewind(wr_data_tmp); wrbuf_iconv_puts(wr_data_tmp, mt->iconv_cd, n->u.controlfield.data); marc_iconv_reset(mt, wr_data_tmp); wrbuf_iconv_putchar(wr_data_tmp, mt->iconv_cd, ' ');/* field sep */ marc_iconv_reset(mt, wr_data_tmp); data_length += wrbuf_len(wr_data_tmp); break; case YAZ_MARC_COMMENT: break; case YAZ_MARC_LEADER: break; } if (data_length) { wrbuf_printf(wr_dir, "%0*d", length_data_entry, data_length); wrbuf_printf(wr_dir, "%0*d", length_starting, data_offset); data_offset += data_length; } } /* mark end of directory */ wrbuf_putc(wr_dir, ISO2709_FS); /* base address of data (comes after leader+directory) */ base_address = 24 + wrbuf_len(wr_dir); wr_head = wrbuf_alloc(); /* write record length */ wrbuf_printf(wr_head, "%05d", base_address + data_offset + 1); /* from "original" leader */ wrbuf_write(wr_head, leader+5, 7); /* base address of data */ wrbuf_printf(wr_head, "%05d", base_address); /* from "original" leader */ wrbuf_write(wr_head, leader+17, 7); wrbuf_write(wr, wrbuf_buf(wr_head), 24); wrbuf_write(wr, wrbuf_buf(wr_dir), wrbuf_len(wr_dir)); wrbuf_destroy(wr_head); wrbuf_destroy(wr_dir); wrbuf_destroy(wr_data_tmp); for (n = mt->nodes; n; n = n->next) { struct yaz_marc_subfield *s; switch(n->which) { case YAZ_MARC_DATAFIELD: wrbuf_write(wr, n->u.datafield.indicator, indicator_length); for (s = n->u.datafield.subfields; s; s = s->next) { wrbuf_putc(wr, ISO2709_IDFS); wrbuf_iconv_puts(wr, mt->iconv_cd, s->code_data); marc_iconv_reset(mt, wr); } wrbuf_putc(wr, ISO2709_FS); break; case YAZ_MARC_CONTROLFIELD: wrbuf_iconv_puts(wr, mt->iconv_cd, n->u.controlfield.data); marc_iconv_reset(mt, wr); wrbuf_putc(wr, ISO2709_FS); break; case YAZ_MARC_COMMENT: break; case YAZ_MARC_LEADER: break; } } wrbuf_printf(wr, "%c", ISO2709_RS); return 0; }
static struct http_buf *http_buf_bywrbuf(http_server_t hs, WRBUF wrbuf) { // Heavens to Betsy (buf)! return http_buf_bybuf(hs, wrbuf_buf(wrbuf), wrbuf_len(wrbuf)); }
int yaz_record_conv_configure_t(yaz_record_conv_t p, const xmlNode *ptr, struct yaz_record_conv_type *types) { struct yaz_record_conv_type bt[4]; size_t i = 0; /* register marc */ bt[i].construct = construct_marc; bt[i].convert = convert_marc; bt[i++].destroy = destroy_marc; bt[i-1].next = &bt[i]; bt[i].construct = construct_solrmarc; bt[i].convert = convert_solrmarc; bt[i++].destroy = destroy_solrmarc; bt[i-1].next = &bt[i]; bt[i].construct = construct_select; bt[i].convert = convert_select; bt[i++].destroy = destroy_select; #if YAZ_HAVE_XSLT /* register xslt */ bt[i-1].next = &bt[i]; bt[i].construct = construct_xslt; bt[i].convert = convert_xslt; bt[i++].destroy = destroy_xslt; #endif bt[i-1].next = types; yaz_record_conv_reset(p); /* parsing element children */ for (ptr = ptr->children; ptr; ptr = ptr->next) { struct yaz_record_conv_type *t; struct yaz_record_conv_rule *r; void *info = 0; if (ptr->type != XML_ELEMENT_NODE) continue; for (t = &bt[0]; t; t = t->next) { wrbuf_rewind(p->wr_error); info = t->construct(ptr, p->path, p->wr_error); if (info || wrbuf_len(p->wr_error)) break; /* info== 0 and no error reported , ie not handled by it */ } if (!info) { if (wrbuf_len(p->wr_error) == 0) wrbuf_printf(p->wr_error, "Element <backend>: " "unsupported element <%s>", ptr->name); return -1; } r = (struct yaz_record_conv_rule *) nmem_malloc(p->nmem, sizeof(*r)); r->next = 0; r->info = info; r->type = nmem_malloc(p->nmem, sizeof(*t)); memcpy(r->type, t, sizeof(*t)); *p->rules_p = r; p->rules_p = &r->next; } return 0; }
static int convert_marc(void *info, WRBUF record, WRBUF wr_error) { struct marc_info *mi = info; const char *input_charset = mi->input_charset; int ret = 0; yaz_marc_t mt = yaz_marc_create(); yaz_marc_xml(mt, mi->output_format_mode); if (mi->leader_spec) yaz_marc_leader_spec(mt, mi->leader_spec); if (mi->input_format_mode == YAZ_MARC_ISO2709) { int sz = yaz_marc_read_iso2709(mt, wrbuf_buf(record), wrbuf_len(record)); if (sz > 0) { if (yaz_marc_check_marc21_coding(input_charset, wrbuf_buf(record), wrbuf_len(record))) input_charset = "utf-8"; ret = 0; } else ret = -1; } else if (mi->input_format_mode == YAZ_MARC_MARCXML || mi->input_format_mode == YAZ_MARC_TURBOMARC) { xmlDocPtr doc = xmlParseMemory(wrbuf_buf(record), wrbuf_len(record)); if (!doc) { wrbuf_printf(wr_error, "xmlParseMemory failed"); ret = -1; } else { ret = yaz_marc_read_xml(mt, xmlDocGetRootElement(doc)); if (ret) wrbuf_printf(wr_error, "yaz_marc_read_xml failed"); } xmlFreeDoc(doc); } else { wrbuf_printf(wr_error, "unsupported input format"); ret = -1; } if (ret == 0) { yaz_iconv_t cd = yaz_iconv_open(mi->output_charset, input_charset); if (cd) yaz_marc_iconv(mt, cd); wrbuf_rewind(record); ret = yaz_marc_write_mode(mt, record); if (ret) wrbuf_printf(wr_error, "yaz_marc_write_mode failed"); if (cd) yaz_iconv_close(cd); } yaz_marc_destroy(mt); return ret; }
static void tst_convert3(void) { NMEM nmem = nmem_create(); int ret; yaz_record_conv_t p = 0; const char *iso2709_rec = "\x30\x30\x30\x37\x37\x6E\x61\x6D\x20\x20\x32\x32\x30\x30\x30\x34" "\x39\x38\x61\x20\x34\x35\x30\x30\x30\x30\x31\x30\x30\x31\x33\x30" "\x30\x30\x30\x30\x30\x31\x30\x30\x30\x31\x34\x30\x30\x30\x31\x33" "\x1E\x20\x20\x20\x31\x31\x32\x32\x34\x34\x36\x36\x20\x1E\x20\x20" "\x1F\x61\x6b\xb2\x62\x65\x6e\x68\x61\x76\x6e\x1E\x1D"; const char *opacxml_rec = "<opacRecord>\n" " <bibliographicRecord>\n" "<record xmlns=\"http://www.loc.gov/MARC21/slim\">\n" " <leader>00077nam a22000498a 4500</leader>\n" " <controlfield tag=\"001\"> 11224466 </controlfield>\n" " <datafield tag=\"010\" ind1=\" \" ind2=\" \">\n" " <subfield code=\"a\">k" "\xc3" "\xb8" /* oslash in UTF_8 */ "benhavn</subfield>\n" " </datafield>\n" "</record>\n" " </bibliographicRecord>\n" "<holdings>\n" " <holding>\n" " <typeOfRecord>u</typeOfRecord>\n" " <encodingLevel>U</encodingLevel>\n" " <receiptAcqStatus>0</receiptAcqStatus>\n" " <dateOfReport>000000</dateOfReport>\n" " <nucCode>s-FM/GC</nucCode>\n" " <localLocation>Main or Science/Business Reading Rms - STORED OFFSITE</localLocation>\n" " <callNumber>MLCM 89/00602 (N)</callNumber>\n" " <shelvingData>FT MEADE</shelvingData>\n" " <copyNumber>Copy 1</copyNumber>\n" " <volumes>\n" " <volume>\n" " <enumeration>1</enumeration>\n" " <chronology>2</chronology>\n" " <enumAndChron>3</enumAndChron>\n" " </volume>\n" " <volume>\n" " <enumeration>1</enumeration>\n" " <chronology>2</chronology>\n" " <enumAndChron>3</enumAndChron>\n" " </volume>\n" " </volumes>\n" " <circulations>\n" " <circulation>\n" " <availableNow value=\"1\"/>\n" " <availabilityDate>20130129</availabilityDate>\n" " <itemId>1226176</itemId>\n" " <renewable value=\"0\"/>\n" " <onHold value=\"0\"/>\n" " </circulation>\n" " </circulations>\n" " </holding>\n" "</holdings>\n" "</opacRecord>\n"; Z_OPACRecord *z_opac = nmem_malloc(nmem, sizeof(*z_opac)); Z_HoldingsAndCircData *h; Z_CircRecord *circ; z_opac->bibliographicRecord = z_ext_record_oid_nmem(nmem, yaz_oid_recsyn_usmarc, iso2709_rec, strlen(iso2709_rec)); z_opac->num_holdingsData = 1; z_opac->holdingsData = (Z_HoldingsRecord **) nmem_malloc(nmem, sizeof(Z_HoldingsRecord *) * 1); z_opac->holdingsData[0] = (Z_HoldingsRecord *) nmem_malloc(nmem, sizeof(Z_HoldingsRecord)); z_opac->holdingsData[0]->which = Z_HoldingsRecord_holdingsAndCirc; h = z_opac->holdingsData[0]->u.holdingsAndCirc = (Z_HoldingsAndCircData *) nmem_malloc(nmem, sizeof(*h)); h->typeOfRecord = nmem_strdup(nmem, "u"); h->encodingLevel = nmem_strdup(nmem, "U"); h->format = 0; h->receiptAcqStatus = nmem_strdup(nmem, "0"); h->generalRetention = 0; h->completeness = 0; h->dateOfReport = nmem_strdup(nmem, "000000"); h->nucCode = nmem_strdup(nmem, "s-FM/GC"); h->localLocation = nmem_strdup(nmem, "Main or Science/Business Reading " "Rms - STORED OFFSITE"); h->shelvingLocation = 0; h->callNumber = nmem_strdup(nmem, "MLCM 89/00602 (N)"); h->shelvingData = nmem_strdup(nmem, "FT MEADE"); h->copyNumber = nmem_strdup(nmem, "Copy 1"); h->publicNote = 0; h->reproductionNote = 0; h->termsUseRepro = 0; h->enumAndChron = 0; h->num_volumes = 2; h->volumes = 0; h->volumes = (Z_Volume **) nmem_malloc(nmem, 2 * sizeof(Z_Volume *)); h->volumes[0] = (Z_Volume *) nmem_malloc(nmem, sizeof(Z_Volume)); h->volumes[1] = h->volumes[0]; h->volumes[0]->enumeration = nmem_strdup(nmem, "1"); h->volumes[0]->chronology = nmem_strdup(nmem, "2"); h->volumes[0]->enumAndChron = nmem_strdup(nmem, "3"); h->num_circulationData = 1; h->circulationData = (Z_CircRecord **) nmem_malloc(nmem, 1 * sizeof(Z_CircRecord *)); circ = h->circulationData[0] = (Z_CircRecord *) nmem_malloc(nmem, sizeof(Z_CircRecord)); circ->availableNow = nmem_booldup(nmem, 1); circ->availablityDate = nmem_strdup(nmem, "20130129"); circ->availableThru = 0; circ->restrictions = 0; circ->itemId = nmem_strdup(nmem, "1226176"); circ->renewable = nmem_booldup(nmem, 0); circ->onHold = nmem_booldup(nmem, 0); circ->enumAndChron = 0; circ->midspine = 0; circ->temporaryLocation = 0; YAZ_CHECK(conv_configure_test("<backend>" "<marc" " inputcharset=\"marc-8\"" " outputcharset=\"utf-8\"" " inputformat=\"marc\"" " outputformat=\"marcxml\"" "/>" "</backend>", 0, &p)); if (p) { WRBUF output_record = wrbuf_alloc(); ret = yaz_record_conv_opac_record(p, z_opac, output_record); YAZ_CHECK(ret == 0); if (ret == 0) { ret = strcmp(wrbuf_cstr(output_record), opacxml_rec); YAZ_CHECK(ret == 0); if (ret) { printf("got-output_record len=%ld: %s\n", (long) wrbuf_len(output_record), wrbuf_cstr(output_record)); printf("output_expect_record len=%ld %s\n", (long) strlen(opacxml_rec), opacxml_rec); } } yaz_record_conv_destroy(p); wrbuf_destroy(output_record); } { Z_OPACRecord *opac = 0; yaz_marc_t mt = yaz_marc_create(); ret = yaz_xml_to_opac(mt, opacxml_rec, strlen(opacxml_rec), &opac, 0 /* iconv */, nmem, 0); YAZ_CHECK(ret); YAZ_CHECK(opac); if (opac) { WRBUF output_record = wrbuf_alloc(); char *p; yaz_marc_xml(mt, YAZ_MARC_MARCXML); yaz_opac_decode_wrbuf(mt, opac, output_record); /* change MARC size to 00077 from 00078, due to encoding of the aring (two bytes in UTF-8) */ p = strstr(wrbuf_buf(output_record), "00078"); YAZ_CHECK(p); if (p) p[4] = '7'; ret = strcmp(wrbuf_cstr(output_record), opacxml_rec); YAZ_CHECK(ret == 0); if (ret) { printf("got-output_record len=%ld: %s\n", (long) wrbuf_len(output_record), wrbuf_cstr(output_record)); printf("output_expect_record len=%ld %s\n", (long) strlen(opacxml_rec), opacxml_rec); } wrbuf_destroy(output_record); } yaz_marc_destroy(mt); } nmem_destroy(nmem); }
static void tstwrbuf(void) { int step; WRBUF wr; wr = 0; wrbuf_destroy(wr); wr = wrbuf_alloc(); YAZ_CHECK(wr); wrbuf_destroy(wr); wr = wrbuf_alloc(); YAZ_CHECK(wr); for (step = 1; step < 65; step++) { int i, j, k; int len; char buf[64]; char *cp; for (j = 1; j<step; j++) { for (i = 0; i<j; i++) buf[i] = i+1; buf[i] = '\0'; wrbuf_puts(wr, buf); } cp = wrbuf_buf(wr); len = wrbuf_len(wr); YAZ_CHECK(len == step * (step-1) / 2); k = 0; for (j = 1; j<step; j++) for (i = 0; i<j; i++) { YAZ_CHECK(cp[k] == i+1); k++; } wrbuf_rewind(wr); } wrbuf_rewind(wr); wrbuf_puts(wr, "1234"); wrbuf_insert(wr, 0, "abc", 3); YAZ_CHECK(!strcmp(wrbuf_cstr(wr), "abc1234")); wrbuf_rewind(wr); wrbuf_puts(wr, "1234"); wrbuf_insert(wr, 1, "abc", 3); YAZ_CHECK(!strcmp(wrbuf_cstr(wr), "1abc234")); wrbuf_rewind(wr); wrbuf_puts(wr, "1234"); wrbuf_insert(wr, 4, "abc", 3); YAZ_CHECK(!strcmp(wrbuf_cstr(wr), "1234abc")); wrbuf_rewind(wr); wrbuf_puts(wr, "1234"); wrbuf_insert(wr, 5, "abc", 3); YAZ_CHECK(!strcmp(wrbuf_cstr(wr), "1234")); wrbuf_destroy(wr); }