1504 |
int start_point = PT; |
int start_point = PT; |
1505 |
int pos = PT; |
int pos = PT; |
1506 |
int pos_byte = PT_BYTE; |
int pos_byte = PT_BYTE; |
1507 |
|
unsigned char *p = PT_ADDR, *endp, *stop; |
1508 |
|
|
1509 |
|
if (forwardp) |
1510 |
|
{ |
1511 |
|
endp = (XINT (lim) == GPT) ? GPT_ADDR : CHAR_POS_ADDR (XINT (lim)); |
1512 |
|
stop = (pos < GPT && GPT < XINT (lim)) ? GPT_ADDR : endp; |
1513 |
|
} |
1514 |
|
else |
1515 |
|
{ |
1516 |
|
endp = CHAR_POS_ADDR (XINT (lim)); |
1517 |
|
stop = (pos >= GPT && GPT > XINT (lim)) ? GAP_END_ADDR : endp; |
1518 |
|
} |
1519 |
|
|
1520 |
immediate_quit = 1; |
immediate_quit = 1; |
1521 |
if (syntaxp) |
if (syntaxp) |
1524 |
if (forwardp) |
if (forwardp) |
1525 |
{ |
{ |
1526 |
if (multibyte) |
if (multibyte) |
1527 |
{ |
while (1) |
1528 |
if (pos < XINT (lim)) |
{ |
1529 |
while (fastmap[(int) SYNTAX (FETCH_CHAR (pos_byte))]) |
int nbytes; |
1530 |
{ |
|
1531 |
/* Since we already checked for multibyteness, |
if (p >= stop) |
1532 |
avoid using INC_BOTH which checks again. */ |
{ |
1533 |
INC_POS (pos_byte); |
if (p >= endp) |
1534 |
pos++; |
break; |
1535 |
if (pos >= XINT (lim)) |
p = GAP_END_ADDR; |
1536 |
break; |
stop = endp; |
|
UPDATE_SYNTAX_TABLE_FORWARD (pos); |
|
1537 |
} |
} |
1538 |
} |
c = STRING_CHAR_AND_LENGTH (p, MAX_MULTIBYTE_LENGTH, nbytes); |
1539 |
|
if (! fastmap[(int) SYNTAX (c)]) |
1540 |
|
break; |
1541 |
|
p += nbytes, pos++, pos_byte += nbytes; |
1542 |
|
UPDATE_SYNTAX_TABLE_FORWARD (pos); |
1543 |
|
} |
1544 |
else |
else |
1545 |
{ |
while (1) |
1546 |
while (pos < XINT (lim) |
{ |
1547 |
&& fastmap[(int) SYNTAX (FETCH_BYTE (pos))]) |
if (p >= stop) |
1548 |
{ |
{ |
1549 |
pos++; |
if (p >= endp) |
1550 |
UPDATE_SYNTAX_TABLE_FORWARD (pos); |
break; |
1551 |
} |
p = GAP_END_ADDR; |
1552 |
} |
stop = endp; |
1553 |
|
} |
1554 |
|
if (! fastmap[(int) SYNTAX (*p)]) |
1555 |
|
break; |
1556 |
|
p++, pos++; |
1557 |
|
UPDATE_SYNTAX_TABLE_FORWARD (pos); |
1558 |
|
} |
1559 |
} |
} |
1560 |
else |
else |
1561 |
{ |
{ |
1562 |
if (multibyte) |
if (multibyte) |
1563 |
{ |
while (1) |
1564 |
while (pos > XINT (lim)) |
{ |
1565 |
{ |
unsigned char *prev_p; |
1566 |
int savepos = pos_byte; |
int nbytes; |
1567 |
/* Since we already checked for multibyteness, |
|
1568 |
avoid using DEC_BOTH which checks again. */ |
if (p <= stop) |
1569 |
pos--; |
{ |
1570 |
DEC_POS (pos_byte); |
if (p <= endp) |
1571 |
UPDATE_SYNTAX_TABLE_BACKWARD (pos); |
break; |
1572 |
if (!fastmap[(int) SYNTAX (FETCH_CHAR (pos_byte))]) |
p = GPT_ADDR; |
1573 |
{ |
stop = endp; |
1574 |
pos++; |
} |
1575 |
pos_byte = savepos; |
prev_p = p; |
1576 |
break; |
while (--p >= stop && ! CHAR_HEAD_P (*p)); |
1577 |
} |
PARSE_MULTIBYTE_SEQ (p, MAX_MULTIBYTE_LENGTH, nbytes); |
1578 |
} |
if (prev_p - p > nbytes) |
1579 |
} |
p = prev_p - 1, c = *p, nbytes = 1; |
1580 |
|
else |
1581 |
|
c = STRING_CHAR (p, MAX_MULTIBYTE_LENGTH); |
1582 |
|
pos--, pos_byte -= nbytes; |
1583 |
|
UPDATE_SYNTAX_TABLE_BACKWARD (pos); |
1584 |
|
if (! fastmap[(int) SYNTAX (c)]) |
1585 |
|
{ |
1586 |
|
pos++; |
1587 |
|
pos_byte += nbytes; |
1588 |
|
break; |
1589 |
|
} |
1590 |
|
} |
1591 |
else |
else |
1592 |
{ |
while (1) |
1593 |
if (pos > XINT (lim)) |
{ |
1594 |
while (fastmap[(int) SYNTAX (FETCH_BYTE (pos - 1))]) |
if (p <= stop) |
1595 |
{ |
{ |
1596 |
pos--; |
if (p <= endp) |
|
if (pos <= XINT (lim)) |
|
1597 |
break; |
break; |
1598 |
UPDATE_SYNTAX_TABLE_BACKWARD (pos - 1); |
p = GPT_ADDR; |
1599 |
|
stop = endp; |
1600 |
} |
} |
1601 |
} |
if (! fastmap[(int) SYNTAX (p[-1])]) |
1602 |
|
break; |
1603 |
|
p--, pos--; |
1604 |
|
UPDATE_SYNTAX_TABLE_BACKWARD (pos - 1); |
1605 |
|
} |
1606 |
} |
} |
1607 |
} |
} |
1608 |
else |
else |
1610 |
if (forwardp) |
if (forwardp) |
1611 |
{ |
{ |
1612 |
if (multibyte) |
if (multibyte) |
1613 |
while (pos < XINT (lim)) |
while (1) |
1614 |
{ |
{ |
1615 |
c = FETCH_MULTIBYTE_CHAR (pos_byte); |
int nbytes; |
1616 |
|
|
1617 |
|
if (p >= stop) |
1618 |
|
{ |
1619 |
|
if (p >= endp) |
1620 |
|
break; |
1621 |
|
p = GAP_END_ADDR; |
1622 |
|
stop = endp; |
1623 |
|
} |
1624 |
|
c = STRING_CHAR_AND_LENGTH (p, MAX_MULTIBYTE_LENGTH, nbytes); |
1625 |
if (SINGLE_BYTE_CHAR_P (c)) |
if (SINGLE_BYTE_CHAR_P (c)) |
1626 |
{ |
{ |
1627 |
if (!fastmap[c]) |
if (!fastmap[c]) |
1644 |
if (!(negate ^ (i < n_char_ranges))) |
if (!(negate ^ (i < n_char_ranges))) |
1645 |
break; |
break; |
1646 |
} |
} |
1647 |
INC_BOTH (pos, pos_byte); |
p += nbytes, pos++, pos_byte += nbytes; |
1648 |
} |
} |
1649 |
else |
else |
1650 |
while (pos < XINT (lim) && fastmap[FETCH_BYTE (pos)]) |
while (1) |
1651 |
pos++; |
{ |
1652 |
|
if (p >= stop) |
1653 |
|
{ |
1654 |
|
if (p >= endp) |
1655 |
|
break; |
1656 |
|
p = GAP_END_ADDR; |
1657 |
|
stop = endp; |
1658 |
|
} |
1659 |
|
if (fastmap[*p]) |
1660 |
|
break; |
1661 |
|
p++, pos++; |
1662 |
|
} |
1663 |
} |
} |
1664 |
else |
else |
1665 |
{ |
{ |
1666 |
if (multibyte) |
if (multibyte) |
1667 |
while (pos > XINT (lim)) |
while (1) |
1668 |
{ |
{ |
1669 |
int prev_pos_byte = pos_byte; |
unsigned char *prev_p; |
1670 |
|
int nbytes; |
1671 |
|
|
1672 |
DEC_POS (prev_pos_byte); |
if (p <= stop) |
1673 |
c = FETCH_MULTIBYTE_CHAR (prev_pos_byte); |
{ |
1674 |
|
if (p <= endp) |
1675 |
|
break; |
1676 |
|
p = GPT_ADDR; |
1677 |
|
stop = endp; |
1678 |
|
} |
1679 |
|
prev_p = p; |
1680 |
|
while (--p >= stop && ! CHAR_HEAD_P (*p)); |
1681 |
|
PARSE_MULTIBYTE_SEQ (p, MAX_MULTIBYTE_LENGTH, nbytes); |
1682 |
|
if (prev_p - p > nbytes) |
1683 |
|
p = prev_p - 1, c = *p, nbytes = 1; |
1684 |
|
else |
1685 |
|
c = STRING_CHAR (p, MAX_MULTIBYTE_LENGTH); |
1686 |
if (SINGLE_BYTE_CHAR_P (c)) |
if (SINGLE_BYTE_CHAR_P (c)) |
1687 |
{ |
{ |
1688 |
if (!fastmap[c]) |
if (!fastmap[c]) |
1697 |
if (!(negate ^ (i < n_char_ranges))) |
if (!(negate ^ (i < n_char_ranges))) |
1698 |
break; |
break; |
1699 |
} |
} |
1700 |
pos--; |
pos--, pos_byte -= nbytes; |
|
pos_byte = prev_pos_byte; |
|
1701 |
} |
} |
1702 |
else |
else |
1703 |
while (pos > XINT (lim) && fastmap[FETCH_BYTE (pos - 1)]) |
while (1) |
1704 |
pos--; |
{ |
1705 |
|
if (p <= stop) |
1706 |
|
{ |
1707 |
|
if (p <= endp) |
1708 |
|
break; |
1709 |
|
p = GPT_ADDR; |
1710 |
|
stop = endp; |
1711 |
|
} |
1712 |
|
if (fastmap[p[-1]]) |
1713 |
|
break; |
1714 |
|
p--, pos--; |
1715 |
|
} |
1716 |
} |
} |
1717 |
} |
} |
1718 |
|
|