static int check_keyword (char *name)
{
char *n, ch;
if (name == NULL) return 0;
if (check_ascii (name, 0) == -1) return -1;
n = name;
while ((ch = *n++) != 0)
{
if (((ch > 'Z') || (ch < 'A'))
&& ((ch > '9') || (ch < '0'))
&& (ch != '-') && (ch != '_'))
{
jdfits_error ("%s\n\
A FITS keyword must contain either UPPERCASE characters or '-' or '_'",
name);
return -1;
}
}
if ((int)strlen (name) > 8)
{
jdfits_error ("Keyword (%s) must be less than 8 characters.\n", name);
return -1;
}
return 0;
}
int jdfits_write_header_double (JDFits_Type *ft, char *name, double val, char *comment)
{
char buf[JDFITS_CARD_SIZE + 1];
char numbuf[64];
int prec;
if ((-1 == check_keyword (name))
|| (-1 == check_ascii(comment, 1)))
return -1;
/* According to the FITS NOST document, the resulting value should be right
* justified in columns 11-30. It must contain a decimal point and E must
* be used if with in exponential form.
*/
prec = 16;
do
{
if (-1 == format_double (val, prec, numbuf))
{
strcpy (numbuf, "Floating point exception");
jdfits_warning ("jdfits_write_header_double: unable to convert value\n");
prec = 0;
}
prec--;
sprintf (buf, "%-8s= %20s", name, numbuf);
}
while ((prec > 5) && (strlen (buf) > 30));
jdfits_append_comment (buf, comment);
return jdfits_write (ft, (unsigned char *) buf, JDFITS_CARD_SIZE);
}
static int
dissect_tapa_discover_unknown_new_tlv(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tapa_discover_tree, guint32 offset, gint remaining)
{
proto_item *item;
proto_tree *tapa_discover_item_tree;
guint8 item_type;
gint item_length;
const gchar *item_text;
/*const gchar *item_type_text;*/
gboolean is_ascii;
while (remaining > 3) { /* type(1) + flags(1) + length(2) */
item_type = tvb_get_guint8(tvb, offset);
/*item_type_text = val_to_str(item_type, tapa_discover_unknown_vals, "%d");*/
item_length = tvb_get_ntohs(tvb, offset + 2) - 4;
DISSECTOR_ASSERT(item_length > 0);
is_ascii = check_ascii(tvb, offset + 4, item_length);
if (is_ascii)
item_text = tvb_format_text(tvb, offset + 4, item_length);
else
item_text = "BINARY-DATA";
col_append_fstr(pinfo->cinfo, COL_INFO, ", T=%d L=%d",
item_type, item_length);
item = proto_tree_add_text(tapa_discover_tree, tvb, offset, 4 + item_length,
"Type %d, length %d, value %s",
item_type, item_length, item_text);
tapa_discover_item_tree = proto_item_add_subtree(item, ett_tapa_discover_req);
proto_tree_add_item(tapa_discover_item_tree, hf_tapa_discover_newtlv_type, tvb, offset, 1,
ENC_BIG_ENDIAN);
offset += 1;
proto_tree_add_item(tapa_discover_item_tree, hf_tapa_discover_newtlv_pad, tvb, offset, 1,
ENC_BIG_ENDIAN);
offset += 1;
proto_tree_add_item(tapa_discover_item_tree, hf_tapa_discover_newtlv_length, tvb, offset, 2,
ENC_BIG_ENDIAN);
offset += 2;
if (is_ascii)
proto_tree_add_item(tapa_discover_item_tree, hf_tapa_discover_newtlv_valuetext,
tvb, offset, item_length, ENC_ASCII|ENC_NA);
else
proto_tree_add_item(tapa_discover_item_tree, hf_tapa_discover_newtlv_valuehex,
tvb, offset, item_length, ENC_NA);
offset += item_length;
remaining -= (item_length + 4);
}
return offset;
}
static int
do_test (void)
{
int result = 0;
/* Check mapping of ASCII range for some character sets which have
ASCII as a subset. For those the wide char generated must have
the same value. */
setlocale (LC_ALL, "C");
result |= check_ascii (setlocale (LC_ALL, NULL));
setlocale (LC_ALL, "de_DE.UTF-8");
result |= check_ascii (setlocale (LC_ALL, NULL));
setlocale (LC_ALL, "ja_JP.EUC-JP");
result |= check_ascii (setlocale (LC_ALL, NULL));
return result;
}
int jdfits_write_header_string (JDFits_Type *ft, char *name, char *s, char *comment)
{
char buf[JDFITS_CARD_SIZE + 1];
char *b, *bmax, *bsave, ch;
if ((-1 == check_keyword (name))
|| (-1 == check_ascii (s, 0))
|| (-1 == check_ascii (comment, 1)))
return -1;
/* Strings must begin with a ' character in column 11 and have a closing one
* before the end of the card. Actually the closing one must be at column
* 20 or beyond.
*/
sprintf (buf, "%-8s= '", name);
bsave = b = buf + strlen(buf);
bmax = buf + JDFITS_CARD_SIZE;
while (b < bmax)
{
ch = *s++;
if (ch == 0)
{
/* Now pad it with blanks */
bmax = bsave + 8;
while (b < bmax) *b++ = ' ';
*b = '\'';
*(b + 1) = 0;
jdfits_append_comment (buf, comment);
return jdfits_write (ft, (unsigned char *) buf, JDFITS_CARD_SIZE);
}
if (ch == '\'')
{
*b++ = ch;
if (b == bmax) break;
}
*b++ = ch;
}
jdfits_error ("String is too long for keyword %s", name);
return -1;
}
int jdfits_write_header_integer (JDFits_Type *ft, char *name, int val, char *comment)
{
char buf[JDFITS_CARD_SIZE + 1];
if ((-1 == check_keyword (name))
|| (-1 == check_ascii(comment, 1)))
return -1;
sprintf (buf, "%-8s= %20d", name, val);
jdfits_append_comment (buf, comment);
return jdfits_write (ft, (unsigned char *) buf, JDFITS_CARD_SIZE);
}
void yaz_marc_set_leader(yaz_marc_t mt, const char *leader_c,
int *indicator_length,
int *identifier_length,
int *base_address,
int *length_data_entry,
int *length_starting,
int *length_implementation)
{
char leader[24];
memcpy(leader, leader_c, 24);
check_ascii(mt, leader, 5, 'a');
check_ascii(mt, leader, 6, 'a');
check_ascii(mt, leader, 7, 'a');
check_ascii(mt, leader, 8, '#');
check_ascii(mt, leader, 9, '#');
if (!atoi_n_check(leader+10, 1, indicator_length) || *indicator_length == 0)
{
yaz_marc_cprintf(mt, "Indicator length at offset 10 should"
" hold a number 1-9. Assuming 2");
leader[10] = '2';
*indicator_length = 2;
}
if (!atoi_n_check(leader+11, 1, identifier_length) || *identifier_length == 0)
{
yaz_marc_cprintf(mt, "Identifier length at offset 11 should "
" hold a number 1-9. Assuming 2");
leader[11] = '2';
*identifier_length = 2;
}
if (!atoi_n_check(leader+12, 5, base_address))
{
yaz_marc_cprintf(mt, "Base address at offsets 12..16 should"
" hold a number. Assuming 0");
*base_address = 0;
}
check_ascii(mt, leader, 17, '#');
check_ascii(mt, leader, 18, '#');
check_ascii(mt, leader, 19, '#');
if (!atoi_n_check(leader+20, 1, length_data_entry) ||
*length_data_entry < 3)
{
yaz_marc_cprintf(mt, "Length data entry at offset 20 should"
" hold a number 3-9. Assuming 4");
*length_data_entry = 4;
leader[20] = '4';
}
if (!atoi_n_check(leader+21, 1, length_starting) || *length_starting < 4)
{
yaz_marc_cprintf(mt, "Length starting at offset 21 should"
" hold a number 4-9. Assuming 5");
*length_starting = 5;
leader[21] = '5';
}
if (!atoi_n_check(leader+22, 1, length_implementation))
{
yaz_marc_cprintf(mt, "Length implementation at offset 22 should"
" hold a number. Assuming 0");
*length_implementation = 0;
leader[22] = '0';
}
check_ascii(mt, leader, 23, '0');
if (mt->debug)
{
yaz_marc_cprintf(mt, "Indicator length %5d", *indicator_length);
yaz_marc_cprintf(mt, "Identifier length %5d", *identifier_length);
yaz_marc_cprintf(mt, "Base address %5d", *base_address);
yaz_marc_cprintf(mt, "Length data entry %5d", *length_data_entry);
yaz_marc_cprintf(mt, "Length starting %5d", *length_starting);
yaz_marc_cprintf(mt, "Length implementation %5d", *length_implementation);
}
yaz_marc_add_leader(mt, leader, 24);
}
ostream& ostream::operator<<(char const* x) {
assert(check_ascii(x));
base << x;
return *this;
}
static int regression_tests(void)
{
struct regression_test_case *current = regression_test_cases;
const char *error;
const char *cpu_info;
int i, err_offs;
int is_successful, is_ascii_pattern, is_ascii_input;
int total = 0;
int successful = 0;
int counter = 0;
#ifdef SUPPORT_PCRE8
pcre *re8;
pcre_extra *extra8;
int ovector8_1[32];
int ovector8_2[32];
int return_value8_1, return_value8_2;
int utf8 = 0, ucp8 = 0;
int disabled_flags8 = 0;
#endif
#ifdef SUPPORT_PCRE16
pcre16 *re16;
pcre16_extra *extra16;
int ovector16_1[32];
int ovector16_2[32];
int return_value16_1, return_value16_2;
int utf16 = 0, ucp16 = 0;
int disabled_flags16 = 0;
int length16;
#endif
/* This test compares the behaviour of interpreter and JIT. Although disabling
utf or ucp may make tests fail, if the pcre_exec result is the SAME, it is
still considered successful from pcre_jit_test point of view. */
#ifdef SUPPORT_PCRE8
pcre_config(PCRE_CONFIG_JITTARGET, &cpu_info);
#else
pcre16_config(PCRE_CONFIG_JITTARGET, &cpu_info);
#endif
printf("Running JIT regression tests\n");
printf(" target CPU of SLJIT compiler: %s\n", cpu_info);
#ifdef SUPPORT_PCRE8
pcre_config(PCRE_CONFIG_UTF8, &utf8);
pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp8);
if (!utf8)
disabled_flags8 |= PCRE_UTF8;
if (!ucp8)
disabled_flags8 |= PCRE_UCP;
printf(" in 8 bit mode with utf8 %s and ucp %s:\n", utf8 ? "enabled" : "disabled", ucp8 ? "enabled" : "disabled");
#endif
#ifdef SUPPORT_PCRE16
pcre16_config(PCRE_CONFIG_UTF16, &utf16);
pcre16_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp16);
if (!utf16)
disabled_flags16 |= PCRE_UTF8;
if (!ucp16)
disabled_flags16 |= PCRE_UCP;
printf(" in 16 bit mode with utf16 %s and ucp %s:\n", utf16 ? "enabled" : "disabled", ucp16 ? "enabled" : "disabled");
#endif
while (current->pattern) {
/* printf("\nPattern: %s :\n", current->pattern); */
total++;
if (current->start_offset & F_PROPERTY) {
is_ascii_pattern = 0;
is_ascii_input = 0;
} else {
is_ascii_pattern = check_ascii(current->pattern);
is_ascii_input = check_ascii(current->input);
}
error = NULL;
#ifdef SUPPORT_PCRE8
re8 = NULL;
if (!(current->start_offset & F_NO8))
re8 = pcre_compile(current->pattern,
current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | disabled_flags8),
&error, &err_offs, tables(0));
extra8 = NULL;
if (re8) {
error = NULL;
extra8 = pcre_study(re8, PCRE_STUDY_JIT_COMPILE, &error);
if (!extra8) {
printf("\n8 bit: Cannot study pattern: %s\n", current->pattern);
pcre_free(re8);
re8 = NULL;
}
if (!(extra8->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
printf("\n8 bit: JIT compiler does not support: %s\n", current->pattern);
pcre_free_study(extra8);
pcre_free(re8);
re8 = NULL;
}
} else if (((utf8 && ucp8) || is_ascii_pattern) && !(current->start_offset & F_NO8))
printf("\n8 bit: Cannot compile pattern: %s\n", current->pattern);
#endif
#ifdef SUPPORT_PCRE16
if ((current->flags & PCRE_UTF8) || (current->start_offset & F_FORCECONV))
convert_utf8_to_utf16(current->pattern, regtest_buf, NULL, REGTEST_MAX_LENGTH);
else
copy_char8_to_char16(current->pattern, regtest_buf, REGTEST_MAX_LENGTH);
re16 = NULL;
if (!(current->start_offset & F_NO16))
re16 = pcre16_compile(regtest_buf,
current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | disabled_flags16),
&error, &err_offs, tables(0));
extra16 = NULL;
if (re16) {
error = NULL;
extra16 = pcre16_study(re16, PCRE_STUDY_JIT_COMPILE, &error);
if (!extra16) {
printf("\n16 bit: Cannot study pattern: %s\n", current->pattern);
pcre16_free(re16);
re16 = NULL;
}
if (!(extra16->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
printf("\n16 bit: JIT compiler does not support: %s\n", current->pattern);
pcre16_free_study(extra16);
pcre16_free(re16);
re16 = NULL;
}
} else if (((utf16 && ucp16) || is_ascii_pattern) && !(current->start_offset & F_NO16))
printf("\n16 bit: Cannot compile pattern: %s\n", current->pattern);
#endif
counter++;
if ((counter & 0x3) != 0) {
#ifdef SUPPORT_PCRE8
setstack8(NULL);
#endif
#ifdef SUPPORT_PCRE16
setstack16(NULL);
#endif
}
#ifdef SUPPORT_PCRE8
return_value8_1 = -1000;
return_value8_2 = -1000;
for (i = 0; i < 32; ++i)
ovector8_1[i] = -2;
for (i = 0; i < 32; ++i)
ovector8_2[i] = -2;
if (re8) {
setstack8(extra8);
return_value8_1 = pcre_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART), ovector8_1, 32);
return_value8_2 = pcre_exec(re8, NULL, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART), ovector8_2, 32);
}
#endif
#ifdef SUPPORT_PCRE16
return_value16_1 = -1000;
return_value16_2 = -1000;
for (i = 0; i < 32; ++i)
ovector16_1[i] = -2;
for (i = 0; i < 32; ++i)
ovector16_2[i] = -2;
if (re16) {
setstack16(extra16);
if ((current->flags & PCRE_UTF8) || (current->start_offset & F_FORCECONV))
length16 = convert_utf8_to_utf16(current->input, regtest_buf, regtest_offsetmap, REGTEST_MAX_LENGTH);
else
length16 = copy_char8_to_char16(current->input, regtest_buf, REGTEST_MAX_LENGTH);
return_value16_1 = pcre16_exec(re16, extra16, regtest_buf, length16, current->start_offset & OFFSET_MASK,
current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART), ovector16_1, 32);
return_value16_2 = pcre16_exec(re16, NULL, regtest_buf, length16, current->start_offset & OFFSET_MASK,
current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART), ovector16_2, 32);
}
#endif
/* If F_DIFF is set, just run the test, but do not compare the results.
Segfaults can still be captured. */
is_successful = 1;
if (!(current->start_offset & F_DIFF)) {
#if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
if (utf8 == utf16 && !(current->start_offset & F_FORCECONV)) {
/* All results must be the same. */
if (return_value8_1 != return_value8_2 || return_value8_1 != return_value16_1 || return_value8_1 != return_value16_2) {
printf("\n8 and 16 bit: Return value differs(%d:%d:%d:%d): [%d] '%s' @ '%s'\n",
return_value8_1, return_value8_2, return_value16_1, return_value16_2,
total, current->pattern, current->input);
is_successful = 0;
} else if (return_value8_1 >= 0) {
return_value8_1 *= 2;
/* Transform back the results. */
if (current->flags & PCRE_UTF8) {
for (i = 0; i < return_value8_1; ++i) {
if (ovector16_1[i] >= 0)
ovector16_1[i] = regtest_offsetmap[ovector16_1[i]];
if (ovector16_2[i] >= 0)
ovector16_2[i] = regtest_offsetmap[ovector16_2[i]];
}
}
for (i = 0; i < return_value8_1; ++i)
if (ovector8_1[i] != ovector8_2[i] || ovector8_1[i] != ovector16_1[i] || ovector8_1[i] != ovector16_2[i]) {
printf("\n8 and 16 bit: Ovector[%d] value differs(%d:%d:%d:%d): [%d] '%s' @ '%s' \n",
i, ovector8_1[i], ovector8_2[i], ovector16_1[i], ovector16_2[i],
total, current->pattern, current->input);
is_successful = 0;
}
}
} else {
#endif /* SUPPORT_PCRE8 && SUPPORT_PCRE16 */
/* Only the 8 bit and 16 bit results must be equal. */
#ifdef SUPPORT_PCRE8
if (return_value8_1 != return_value8_2) {
printf("\n8 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
return_value8_1, return_value8_2, total, current->pattern, current->input);
is_successful = 0;
} else if (return_value8_1 >= 0) {
return_value8_1 *= 2;
for (i = 0; i < return_value8_1; ++i)
if (ovector8_1[i] != ovector8_2[i]) {
printf("\n8 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
i, ovector8_1[i], ovector8_2[i], total, current->pattern, current->input);
is_successful = 0;
}
}
#endif
#ifdef SUPPORT_PCRE16
if (return_value16_1 != return_value16_2) {
printf("\n16 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
return_value16_1, return_value16_2, total, current->pattern, current->input);
is_successful = 0;
} else if (return_value16_1 >= 0) {
return_value16_1 *= 2;
for (i = 0; i < return_value16_1; ++i)
if (ovector16_1[i] != ovector16_2[i]) {
printf("\n16 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
i, ovector16_1[i], ovector16_2[i], total, current->pattern, current->input);
is_successful = 0;
}
}
#endif
#if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
}
#endif /* SUPPORT_PCRE8 && SUPPORT_PCRE16 */
}
if (is_successful) {
#ifdef SUPPORT_PCRE8
if (!(current->start_offset & F_NO8) && ((utf8 && ucp8) || is_ascii_input)) {
if (return_value8_1 < 0 && !(current->start_offset & F_NOMATCH)) {
printf("8 bit: Test should match: [%d] '%s' @ '%s'\n",
total, current->pattern, current->input);
is_successful = 0;
}
if (return_value8_1 >= 0 && (current->start_offset & F_NOMATCH)) {
printf("8 bit: Test should not match: [%d] '%s' @ '%s'\n",
total, current->pattern, current->input);
is_successful = 0;
}
}
#endif
#ifdef SUPPORT_PCRE16
if (!(current->start_offset & F_NO16) && ((utf16 && ucp16) || is_ascii_input)) {
if (return_value16_1 < 0 && !(current->start_offset & F_NOMATCH)) {
printf("16 bit: Test should match: [%d] '%s' @ '%s'\n",
total, current->pattern, current->input);
is_successful = 0;
}
if (return_value16_1 >= 0 && (current->start_offset & F_NOMATCH)) {
printf("16 bit: Test should not match: [%d] '%s' @ '%s'\n",
total, current->pattern, current->input);
is_successful = 0;
}
}
#endif
}
if (is_successful)
successful++;
#ifdef SUPPORT_PCRE8
if (re8) {
pcre_free_study(extra8);
pcre_free(re8);
}
#endif
#ifdef SUPPORT_PCRE16
if (re16) {
pcre16_free_study(extra16);
pcre16_free(re16);
}
#endif
/* printf("[%d-%d|%d-%d]%s", ovector8_1[0], ovector8_1[1], ovector16_1[0], ovector16_1[1], (current->flags & PCRE_CASELESS) ? "C" : ""); */
printf(".");
fflush(stdout);
current++;
}
tables(1);
#ifdef SUPPORT_PCRE8
setstack8(NULL);
#endif
#ifdef SUPPORT_PCRE16
setstack16(NULL);
#endif
if (total == successful) {
printf("\nAll JIT regression tests are successfully passed.\n");
return 0;
} else {
printf("\nSuccessful test ratio: %d%% (%d failed)\n", successful * 100 / total, total - successful);
return 1;
}
}
int jdfits_write_header_comment (JDFits_Type *ft, char *name, char *comment)
{
char buf[JDFITS_CARD_SIZE + 1];
char *bmin, *bmax, *b, ch;
if (name == NULL) name = "";
/* Check for all blanks which is ok for comments */
b = name;
while (((ch = *b++) != 0) && (ch == ' '))
;
if (ch == 0)
{
if (strlen (name) > 8)
{
jdfits_error ("A keyword must be less than 9 characters long.");
return -1;
}
}
else if (-1 == check_keyword (name))
return -1;
if (comment == NULL) comment = "";
if (-1 == check_ascii (comment, 1)) return -1;
sprintf (buf, "%-8s ", name);
bmin = buf + 9;
bmax = buf + JDFITS_CARD_SIZE;
while (1)
{
b = bmin;
while (((ch = *comment) != 0) && (b < bmax))
{
comment++;
if (ch == '\n') break;
*b++ = ch;
}
if ((b == bmax) && (ch != 0))
{
char *bmin_2;
unsigned int diff;
diff = bmax - bmin;
bmin_2 = bmin + (diff / 2);
/* Try to break it at a space. */
b--;
while ((b > bmin_2) && (*b != ' ')) b--;
if (b > bmin_2)
{
comment -= (bmax - b);
comment++; /* +1 to avoid the space */
ch = ' ';
}
else
{
comment--;
b = bmax;
*(b - 1) = '\\';
}
}
while (b < bmax) *b++ = ' ';
*b = 0;
if (-1 == jdfits_write (ft, (unsigned char *) buf, JDFITS_CARD_SIZE))
return -1;
if ((ch == '\n') && (*comment == 0)) break;
if (ch == 0) break;
}
return 0;
}