/[emacs]/emacs/src/syntax.c
ViewVC logotype

Diff of /emacs/src/syntax.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.163 by monnier, Tue Feb 25 01:36:23 2003 UTC revision 1.164 by handa, Thu Apr 24 01:27:55 2003 UTC
# Line 1504  skip_chars (forwardp, syntaxp, string, l Line 1504  skip_chars (forwardp, syntaxp, string, l
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)
# Line 1512  skip_chars (forwardp, syntaxp, string, l Line 1524  skip_chars (forwardp, syntaxp, string, l
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
# Line 1573  skip_chars (forwardp, syntaxp, string, l Line 1610  skip_chars (forwardp, syntaxp, string, l
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])
# Line 1598  skip_chars (forwardp, syntaxp, string, l Line 1644  skip_chars (forwardp, syntaxp, string, l
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])
# Line 1627  skip_chars (forwardp, syntaxp, string, l Line 1697  skip_chars (forwardp, syntaxp, string, l
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    

Legend:
Removed from v.1.163  
changed lines
  Added in v.1.164

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26