Mercurial > emacs
comparison src/syntax.c @ 30626:9d47c133b357
* syntax.c (skip_chars): Fix previous change. Make the handling of
unibyte string consistent with that of regex search.
author | Kenichi Handa <handa@m17n.org> |
---|---|
date | Mon, 07 Aug 2000 05:57:08 +0000 |
parents | 48a9e9f4fd9d |
children | 00943ea58fd1 |
comparison
equal
deleted
inserted
replaced
30625:13ae6fb12020 | 30626:9d47c133b357 |
---|---|
1368 else | 1368 else |
1369 nbytes = XSTRING (string)->size; | 1369 nbytes = XSTRING (string)->size; |
1370 if (nbytes != size_byte) | 1370 if (nbytes != size_byte) |
1371 { | 1371 { |
1372 str = (unsigned char *) alloca (nbytes); | 1372 str = (unsigned char *) alloca (nbytes); |
1373 copy_text (XSTRING (string)->data, str, nbytes, | 1373 copy_text (XSTRING (string)->data, str, size_byte, |
1374 string_multibyte, multibyte); | 1374 string_multibyte, multibyte); |
1375 size_byte = nbytes; | 1375 size_byte = nbytes; |
1376 } | 1376 } |
1377 } | 1377 } |
1378 | 1378 |
1438 i_byte += len; | 1438 i_byte += len; |
1439 | 1439 |
1440 if (SINGLE_BYTE_CHAR_P (c)) | 1440 if (SINGLE_BYTE_CHAR_P (c)) |
1441 { | 1441 { |
1442 if (! SINGLE_BYTE_CHAR_P (c2)) | 1442 if (! SINGLE_BYTE_CHAR_P (c2)) |
1443 error ("Invalid character range: %s", | 1443 { |
1444 XSTRING (string)->data); | 1444 /* Handle a range such as \177-\377 in multibyte |
1445 mode. Split that into two ranges, the low | |
1446 one ending at 0237, and the high one starting | |
1447 at the smallest character in the charset of | |
1448 C2 and ending at C2. */ | |
1449 int charset = CHAR_CHARSET (c2); | |
1450 int c1 = MAKE_CHAR (charset, 0, 0); | |
1451 | |
1452 fastmap[c2_leading_code] = 1; | |
1453 char_ranges[n_char_ranges++] = c1; | |
1454 char_ranges[n_char_ranges++] = c2; | |
1455 c2 = 0237; | |
1456 } | |
1445 while (c <= c2) | 1457 while (c <= c2) |
1446 { | 1458 { |
1447 fastmap[c] = 1; | 1459 fastmap[c] = 1; |
1448 c++; | 1460 c++; |
1449 } | 1461 } |
1450 } | 1462 } |
1451 else | 1463 else if (! SINGLE_BYTE_CHAR_P (c2)) |
1452 { | 1464 { |
1453 if (c_leading_code != c2_leading_code) | 1465 if (c_leading_code != c2_leading_code) |
1454 error ("Invalid character range: %s", | 1466 error ("Invalid character range: %s", |
1455 XSTRING (string)->data); | 1467 XSTRING (string)->data); |
1456 fastmap[c_leading_code] = 1; | |
1457 if (c <= c2) | 1468 if (c <= c2) |
1458 { | 1469 { |
1470 fastmap[c_leading_code] = 1; | |
1459 char_ranges[n_char_ranges++] = c; | 1471 char_ranges[n_char_ranges++] = c; |
1460 char_ranges[n_char_ranges++] = c2; | 1472 char_ranges[n_char_ranges++] = c2; |
1461 } | 1473 } |
1462 } | 1474 } |
1463 } | 1475 } |
1464 else | 1476 else |
1465 { | 1477 { |
1466 fastmap[c_leading_code] = 1; | 1478 if (SINGLE_BYTE_CHAR_P (c)) |
1467 if (!SINGLE_BYTE_CHAR_P (c)) | 1479 fastmap[c] = 1; |
1480 else | |
1468 { | 1481 { |
1482 fastmap[c_leading_code] = 1; | |
1469 char_ranges[n_char_ranges++] = c; | 1483 char_ranges[n_char_ranges++] = c; |
1470 char_ranges[n_char_ranges++] = c; | 1484 char_ranges[n_char_ranges++] = c; |
1471 } | 1485 } |
1472 } | 1486 } |
1473 } | 1487 } |
1560 if (forwardp) | 1574 if (forwardp) |
1561 { | 1575 { |
1562 if (multibyte) | 1576 if (multibyte) |
1563 while (pos < XINT (lim) && fastmap[(c = FETCH_BYTE (pos_byte))]) | 1577 while (pos < XINT (lim) && fastmap[(c = FETCH_BYTE (pos_byte))]) |
1564 { | 1578 { |
1565 if (!BASE_LEADING_CODE_P (c)) | 1579 /* If we are looking at a multibyte character, we |
1566 INC_BOTH (pos, pos_byte); | 1580 must look up the character in the table |
1567 else if (n_char_ranges) | 1581 CHAR_RANGES. If there's no data in the table, |
1582 that character is not what we want to skip. */ | |
1583 if (BASE_LEADING_CODE_P (c) | |
1584 && (c = FETCH_MULTIBYTE_CHAR (pos_byte), | |
1585 ! SINGLE_BYTE_CHAR_P (c))) | |
1568 { | 1586 { |
1569 /* We much check CHAR_RANGES for a multibyte | 1587 /* The following code do the right thing even if |
1570 character. */ | 1588 n_char_ranges is zero (i.e. no data in |
1571 ch = FETCH_MULTIBYTE_CHAR (pos_byte); | 1589 CHAR_RANGES). */ |
1572 for (i = 0; i < n_char_ranges; i += 2) | 1590 for (i = 0; i < n_char_ranges; i += 2) |
1573 if ((ch >= char_ranges[i] && ch <= char_ranges[i + 1])) | 1591 if (c >= char_ranges[i] && c <= char_ranges[i + 1]) |
1574 break; | 1592 break; |
1575 if (!(negate ^ (i < n_char_ranges))) | 1593 if (!(negate ^ (i < n_char_ranges))) |
1576 break; | 1594 break; |
1577 | |
1578 INC_BOTH (pos, pos_byte); | |
1579 } | 1595 } |
1580 else | 1596 INC_BOTH (pos, pos_byte); |
1581 { | |
1582 if (!negate) break; | |
1583 INC_BOTH (pos, pos_byte); | |
1584 } | |
1585 } | 1597 } |
1586 else | 1598 else |
1587 while (pos < XINT (lim) && fastmap[FETCH_BYTE (pos)]) | 1599 while (pos < XINT (lim) && fastmap[FETCH_BYTE (pos)]) |
1588 pos++; | 1600 pos++; |
1589 } | 1601 } |
1590 else | 1602 else |
1591 { | 1603 { |
1592 if (multibyte) | 1604 if (multibyte) |
1593 while (pos > XINT (lim)) | 1605 while (pos > XINT (lim)) |
1594 { | 1606 { |
1595 int savepos = pos_byte; | 1607 int prev_pos_byte = pos_byte; |
1596 DEC_BOTH (pos, pos_byte); | 1608 |
1597 if (fastmap[(c = FETCH_BYTE (pos_byte))]) | 1609 DEC_POS (prev_pos_byte); |
1610 if (!fastmap[(c = FETCH_BYTE (prev_pos_byte))]) | |
1611 break; | |
1612 | |
1613 /* See the comment in the previous similar code. */ | |
1614 if (BASE_LEADING_CODE_P (c) | |
1615 && (c = FETCH_MULTIBYTE_CHAR (prev_pos_byte), | |
1616 ! SINGLE_BYTE_CHAR_P (c))) | |
1598 { | 1617 { |
1599 if (!BASE_LEADING_CODE_P (c)) | 1618 for (i = 0; i < n_char_ranges; i += 2) |
1600 ; | 1619 if (c >= char_ranges[i] && c <= char_ranges[i + 1]) |
1601 else if (n_char_ranges) | 1620 break; |
1602 { | 1621 if (!(negate ^ (i < n_char_ranges))) |
1603 /* We much check CHAR_RANGES for a multibyte | 1622 break; |
1604 character. */ | |
1605 ch = FETCH_MULTIBYTE_CHAR (pos_byte); | |
1606 for (i = 0; i < n_char_ranges; i += 2) | |
1607 if (ch >= char_ranges[i] && ch <= char_ranges[i + 1]) | |
1608 break; | |
1609 if (!(negate ^ (i < n_char_ranges))) | |
1610 { | |
1611 pos++; | |
1612 pos_byte = savepos; | |
1613 break; | |
1614 } | |
1615 } | |
1616 else | |
1617 if (!negate) | |
1618 { | |
1619 pos++; | |
1620 pos_byte = savepos; | |
1621 break; | |
1622 } | |
1623 } | 1623 } |
1624 else | 1624 pos--; |
1625 { | 1625 pos_byte = prev_pos_byte; |
1626 pos++; | |
1627 pos_byte = savepos; | |
1628 break; | |
1629 } | |
1630 } | 1626 } |
1631 else | 1627 else |
1632 while (pos > XINT (lim) && fastmap[FETCH_BYTE (pos - 1)]) | 1628 while (pos > XINT (lim) && fastmap[FETCH_BYTE (pos - 1)]) |
1633 pos--; | 1629 pos--; |
1634 } | 1630 } |