comparison src/text.c @ 4906:6ef8256a020a

implement equalp in C, fix case-folding, add equal() method for keymaps -------------------- ChangeLog entries follow: -------------------- lisp/ChangeLog addition: 2010-02-01 Ben Wing <ben@xemacs.org> * cl-extra.el: * cl-extra.el (cl-string-vector-equalp): Removed. * cl-extra.el (cl-bit-vector-vector-equalp): Removed. * cl-extra.el (cl-vector-array-equalp): Removed. * cl-extra.el (cl-hash-table-contents-equalp): Removed. * cl-extra.el (equalp): Removed. * cl-extra.el (cl-mapcar-many): Comment out the whole `equalp' implementation for the moment; remove once we're sure the C implementation works. * cl-macs.el: * cl-macs.el (equalp): Simplify the compiler-macro for `equalp' -- once it's in C, we don't need to try so hard to expand it. src/ChangeLog addition: 2010-02-01 Ben Wing <ben@xemacs.org> * abbrev.c (abbrev_match_mapper): * buffer.h (CANON_TABLE_OF): * buffer.h: * editfns.c (Fchar_equal): * minibuf.c (scmp_1): * text.c (qxestrcasecmp_i18n): * text.c (qxestrncasecmp_i18n): * text.c (qxetextcasecmp): * text.c (qxetextcasecmp_matching): Create new macro CANONCASE that converts to a canonical mapping and use it to do caseless comparisons instead of DOWNCASE. * alloc.c: * alloc.c (cons_equal): * alloc.c (vector_equal): * alloc.c (string_equal): * bytecode.c (compiled_function_equal): * chartab.c (char_table_entry_equal): * chartab.c (char_table_equal): * data.c (weak_list_equal): * data.c (weak_box_equal): * data.c (ephemeron_equal): * device-msw.c (equal_devmode): * elhash.c (hash_table_equal): * events.c (event_equal): * extents.c (properties_equal): * extents.c (extent_equal): * faces.c: * faces.c (face_equal): * faces.c (face_hash): * floatfns.c (float_equal): * fns.c: * fns.c (bit_vector_equal): * fns.c (plists_differ): * fns.c (Fplists_eq): * fns.c (Fplists_equal): * fns.c (Flax_plists_eq): * fns.c (Flax_plists_equal): * fns.c (internal_equal): * fns.c (internal_equalp): * fns.c (internal_equal_0): * fns.c (syms_of_fns): * glyphs.c (image_instance_equal): * glyphs.c (glyph_equal): * glyphs.c (glyph_hash): * gui.c (gui_item_equal): * lisp.h: * lrecord.h (struct lrecord_implementation): * marker.c (marker_equal): * number.c (bignum_equal): * number.c (ratio_equal): * number.c (bigfloat_equal): * objects.c (color_instance_equal): * objects.c (font_instance_equal): * opaque.c (equal_opaque): * opaque.c (equal_opaque_ptr): * rangetab.c (range_table_equal): * specifier.c (specifier_equal): Add a `foldcase' param to the equal() method and use it to implement `equalp' comparisons. Also add to plists_differ(), although we don't currently use it here. Rewrite internal_equalp(). Implement cross-type vector comparisons. Don't implement our own handling of numeric promotion -- just use the `=' primitive. Add internal_equal_0(), which takes a `foldcase' param and calls either internal_equal() or internal_equalp(). * buffer.h: When given a 0 for buffer (which is the norm when functions don't have a specific buffer available), use the current buffer's table, not `standard-case-table'; otherwise the current settings are ignored. * casetab.c: * casetab.c (set_case_table): When handling old-style vectors of 256 in `set-case-table' don't overwrite the existing table! Instead create a new table and populate. * device-msw.c (sync_printer_with_devmode): * lisp.h: * text.c (lisp_strcasecmp_ascii): Rename lisp_strcasecmp to lisp_strcasecmp_ascii and use lisp_strcasecmp_i18n for caseless comparisons in some places. * elhash.c: Delete unused lisp_string_hash and lisp_string_equal(). * events.h: * keymap-buttons.h: * keymap.h: * keymap.c (keymap_lookup_directly): * keymap.c (keymap_store): * keymap.c (FROB): * keymap.c (key_desc_list_to_event): * keymap.c (describe_map_mapper): * keymap.c (INCLUDE_BUTTON_ZERO): New file keymap-buttons.h; use to handle buttons 1-26 in place of duplicating code 26 times. * frame-gtk.c (allocate_gtk_frame_struct): * frame-msw.c (mswindows_init_frame_1): Fix some comments about internal_equal() in redisplay that don't apply any more. * keymap-slots.h: * keymap.c: New file keymap-slots.h. Use it to notate the slots in a keymap structure, similar to frameslots.h or coding-system-slots.h. * keymap.c (MARKED_SLOT): * keymap.c (keymap_equal): * keymap.c (keymap_hash): Implement. tests/ChangeLog addition: 2010-02-01 Ben Wing <ben@xemacs.org> * automated/case-tests.el: * automated/case-tests.el (uni-mappings): * automated/search-tests.el: Delete old pristine-case-table code. Rewrite the Unicode torture test to take into account whether overlapping mappings exist for more than one character, and not doing the upcase/downcase comparisons in such cases. * automated/lisp-tests.el (foo): * automated/lisp-tests.el (string-variable): * automated/lisp-tests.el (featurep): Replace Assert (equal ... with Assert-equal; same for other types of equality. Replace some awkward equivalents of Assert-equalp with Assert-equalp. Add lots of equalp tests. * automated/case-tests.el: * automated/regexp-tests.el: * automated/search-tests.el: Fix up the comments at the top of the files. Move rules about where to put tests into case-tests.el. * automated/test-harness.el: * automated/test-harness.el (test-harness-aborted-summary-template): New. * automated/test-harness.el (test-harness-from-buffer): * automated/test-harness.el (batch-test-emacs): Fix Assert-test-not. Create Assert-not-equal and variants. Delete the doc strings from all these convenience functions to avoid excessive repetition; instead use one copy in a comment.
author Ben Wing <ben@xemacs.org>
date Mon, 01 Feb 2010 01:02:40 -0600
parents 38493c0fb952
children e813cf16c015
comparison
equal deleted inserted replaced
4903:70089046adef 4906:6ef8256a020a
1420 int 1420 int
1421 qxestrcasecmp_i18n (const Ibyte *s1, const Ibyte *s2) 1421 qxestrcasecmp_i18n (const Ibyte *s1, const Ibyte *s2)
1422 { 1422 {
1423 while (*s1 && *s2) 1423 while (*s1 && *s2)
1424 { 1424 {
1425 if (DOWNCASE (0, itext_ichar (s1)) != 1425 if (CANONCASE (0, itext_ichar (s1)) !=
1426 DOWNCASE (0, itext_ichar (s2))) 1426 CANONCASE (0, itext_ichar (s2)))
1427 break; 1427 break;
1428 INC_IBYTEPTR (s1); 1428 INC_IBYTEPTR (s1);
1429 INC_IBYTEPTR (s2); 1429 INC_IBYTEPTR (s2);
1430 } 1430 }
1431 1431
1432 return (DOWNCASE (0, itext_ichar (s1)) - 1432 return (CANONCASE (0, itext_ichar (s1)) -
1433 DOWNCASE (0, itext_ichar (s2))); 1433 CANONCASE (0, itext_ichar (s2)));
1434 } 1434 }
1435 1435
1436 /* The only difference between these next two and 1436 /* The only difference between these next two and
1437 qxememcasecmp()/qxememcasecmp_i18n() is that these two will stop if 1437 qxememcasecmp()/qxememcasecmp_i18n() is that these two will stop if
1438 both strings are equal and less than LEN in length, while 1438 both strings are equal and less than LEN in length, while
1479 Bytecount len_from_s1) 1479 Bytecount len_from_s1)
1480 { 1480 {
1481 while (len_from_s1 > 0) 1481 while (len_from_s1 > 0)
1482 { 1482 {
1483 const Ibyte *old_s1 = s1; 1483 const Ibyte *old_s1 = s1;
1484 int diff = (DOWNCASE (0, itext_ichar (s1)) - 1484 int diff = (CANONCASE (0, itext_ichar (s1)) -
1485 DOWNCASE (0, itext_ichar (s2))); 1485 CANONCASE (0, itext_ichar (s2)));
1486 if (diff != 0) 1486 if (diff != 0)
1487 return diff; 1487 return diff;
1488 if (!*s1) 1488 if (!*s1)
1489 return 0; 1489 return 0;
1490 INC_IBYTEPTR (s1); 1490 INC_IBYTEPTR (s1);
1602 { 1602 {
1603 while (len1 > 0 && len2 > 0) 1603 while (len1 > 0 && len2 > 0)
1604 { 1604 {
1605 const Ibyte *old_s1 = s1; 1605 const Ibyte *old_s1 = s1;
1606 const Ibyte *old_s2 = s2; 1606 const Ibyte *old_s2 = s2;
1607 int diff = (DOWNCASE (0, itext_ichar (s1)) - 1607 int diff = (CANONCASE (0, itext_ichar (s1)) -
1608 DOWNCASE (0, itext_ichar (s2))); 1608 CANONCASE (0, itext_ichar (s2)));
1609 if (diff != 0) 1609 if (diff != 0)
1610 return diff; 1610 return diff;
1611 INC_IBYTEPTR (s1); 1611 INC_IBYTEPTR (s1);
1612 INC_IBYTEPTR (s2); 1612 INC_IBYTEPTR (s2);
1613 len1 -= s1 - old_s1; 1613 len1 -= s1 - old_s1;
1629 *matching = 0; 1629 *matching = 0;
1630 while (len1 > 0 && len2 > 0) 1630 while (len1 > 0 && len2 > 0)
1631 { 1631 {
1632 const Ibyte *old_s1 = s1; 1632 const Ibyte *old_s1 = s1;
1633 const Ibyte *old_s2 = s2; 1633 const Ibyte *old_s2 = s2;
1634 int diff = (DOWNCASE (0, itext_ichar (s1)) - 1634 int diff = (CANONCASE (0, itext_ichar (s1)) -
1635 DOWNCASE (0, itext_ichar (s2))); 1635 CANONCASE (0, itext_ichar (s2)));
1636 if (diff != 0) 1636 if (diff != 0)
1637 return diff; 1637 return diff;
1638 INC_IBYTEPTR (s1); 1638 INC_IBYTEPTR (s1);
1639 INC_IBYTEPTR (s2); 1639 INC_IBYTEPTR (s2);
1640 len1 -= s1 - old_s1; 1640 len1 -= s1 - old_s1;
1645 assert (len1 >= 0 && len2 >= 0); 1645 assert (len1 >= 0 && len2 >= 0);
1646 return len1 - len2; 1646 return len1 - len2;
1647 } 1647 }
1648 1648
1649 int 1649 int
1650 lisp_strcasecmp (Lisp_Object s1, Lisp_Object s2) 1650 lisp_strcasecmp_ascii (Lisp_Object s1, Lisp_Object s2)
1651 { 1651 {
1652 Ibyte *cm = strcasecmp_charmap; 1652 Ibyte *cm = strcasecmp_charmap;
1653 Ibyte *p1 = XSTRING_DATA (s1); 1653 Ibyte *p1 = XSTRING_DATA (s1);
1654 Ibyte *p2 = XSTRING_DATA (s2); 1654 Ibyte *p2 = XSTRING_DATA (s2);
1655 Ibyte *e1 = p1 + XSTRING_LENGTH (s1); 1655 Ibyte *e1 = p1 + XSTRING_LENGTH (s1);