/[pcre]/code/trunk/pcre_dfa_exec.c
ViewVC logotype

Diff of /code/trunk/pcre_dfa_exec.c

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

revision 1320 by ph10, Wed May 1 16:39:35 2013 UTC revision 1379 by ph10, Mon Oct 14 13:54:07 2013 UTC
# Line 120  static const pcre_uint8 coptable[] = { Line 120  static const pcre_uint8 coptable[] = {
120    0, 0,                          /* \P, \p                                 */    0, 0,                          /* \P, \p                                 */
121    0, 0, 0, 0, 0,                 /* \R, \H, \h, \V, \v                     */    0, 0, 0, 0, 0,                 /* \R, \H, \h, \V, \v                     */
122    0,                             /* \X                                     */    0,                             /* \X                                     */
123    0, 0, 0, 0, 0, 0,              /* \Z, \z, ^, ^M, $, $M                   */    0, 0, 0, 0, 0, 0,              /* \Z, \z, $, $M, ^, ^M                   */
124    1,                             /* Char                                   */    1,                             /* Char                                   */
125    1,                             /* Chari                                  */    1,                             /* Chari                                  */
126    1,                             /* not                                    */    1,                             /* not                                    */
# Line 151  static const pcre_uint8 coptable[] = { Line 151  static const pcre_uint8 coptable[] = {
151    /* Character class & ref repeats                                         */    /* Character class & ref repeats                                         */
152    0, 0, 0, 0, 0, 0,              /* *, *?, +, +?, ?, ??                    */    0, 0, 0, 0, 0, 0,              /* *, *?, +, +?, ?, ??                    */
153    0, 0,                          /* CRRANGE, CRMINRANGE                    */    0, 0,                          /* CRRANGE, CRMINRANGE                    */
154      0, 0, 0, 0,                    /* Possessive *+, ++, ?+, CRPOSRANGE      */
155    0,                             /* CLASS                                  */    0,                             /* CLASS                                  */
156    0,                             /* NCLASS                                 */    0,                             /* NCLASS                                 */
157    0,                             /* XCLASS - variable length               */    0,                             /* XCLASS - variable length               */
158    0,                             /* REF                                    */    0,                             /* REF                                    */
159    0,                             /* REFI                                   */    0,                             /* REFI                                   */
160      0,                             /* DNREF                                  */
161      0,                             /* DNREFI                                 */
162    0,                             /* RECURSE                                */    0,                             /* RECURSE                                */
163    0,                             /* CALLOUT                                */    0,                             /* CALLOUT                                */
164    0,                             /* Alt                                    */    0,                             /* Alt                                    */
# Line 171  static const pcre_uint8 coptable[] = { Line 174  static const pcre_uint8 coptable[] = {
174    0, 0,                          /* ONCE, ONCE_NC                          */    0, 0,                          /* ONCE, ONCE_NC                          */
175    0, 0, 0, 0, 0,                 /* BRA, BRAPOS, CBRA, CBRAPOS, COND       */    0, 0, 0, 0, 0,                 /* BRA, BRAPOS, CBRA, CBRAPOS, COND       */
176    0, 0, 0, 0, 0,                 /* SBRA, SBRAPOS, SCBRA, SCBRAPOS, SCOND  */    0, 0, 0, 0, 0,                 /* SBRA, SBRAPOS, SCBRA, SCBRAPOS, SCOND  */
177    0, 0,                          /* CREF, NCREF                            */    0, 0,                          /* CREF, DNCREF                           */
178    0, 0,                          /* RREF, NRREF                            */    0, 0,                          /* RREF, DNRREF                           */
179    0,                             /* DEF                                    */    0,                             /* DEF                                    */
180    0, 0, 0,                       /* BRAZERO, BRAMINZERO, BRAPOSZERO        */    0, 0, 0,                       /* BRAZERO, BRAMINZERO, BRAPOSZERO        */
181    0, 0, 0,                       /* MARK, PRUNE, PRUNE_ARG                 */    0, 0, 0,                       /* MARK, PRUNE, PRUNE_ARG                 */
# Line 194  static const pcre_uint8 poptable[] = { Line 197  static const pcre_uint8 poptable[] = {
197    1, 1,                          /* \P, \p                                 */    1, 1,                          /* \P, \p                                 */
198    1, 1, 1, 1, 1,                 /* \R, \H, \h, \V, \v                     */    1, 1, 1, 1, 1,                 /* \R, \H, \h, \V, \v                     */
199    1,                             /* \X                                     */    1,                             /* \X                                     */
200    0, 0, 0, 0, 0, 0,              /* \Z, \z, ^, ^M, $, $M                   */    0, 0, 0, 0, 0, 0,              /* \Z, \z, $, $M, ^, ^M                   */
201    1,                             /* Char                                   */    1,                             /* Char                                   */
202    1,                             /* Chari                                  */    1,                             /* Chari                                  */
203    1,                             /* not                                    */    1,                             /* not                                    */
# Line 220  static const pcre_uint8 poptable[] = { Line 223  static const pcre_uint8 poptable[] = {
223    /* Character class & ref repeats                                         */    /* Character class & ref repeats                                         */
224    1, 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */    1, 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */
225    1, 1,                          /* CRRANGE, CRMINRANGE                    */    1, 1,                          /* CRRANGE, CRMINRANGE                    */
226      1, 1, 1, 1,                    /* Possessive *+, ++, ?+, CRPOSRANGE      */
227    1,                             /* CLASS                                  */    1,                             /* CLASS                                  */
228    1,                             /* NCLASS                                 */    1,                             /* NCLASS                                 */
229    1,                             /* XCLASS - variable length               */    1,                             /* XCLASS - variable length               */
230    0,                             /* REF                                    */    0,                             /* REF                                    */
231    0,                             /* REFI                                   */    0,                             /* REFI                                   */
232      0,                             /* DNREF                                  */
233      0,                             /* DNREFI                                 */
234    0,                             /* RECURSE                                */    0,                             /* RECURSE                                */
235    0,                             /* CALLOUT                                */    0,                             /* CALLOUT                                */
236    0,                             /* Alt                                    */    0,                             /* Alt                                    */
# Line 240  static const pcre_uint8 poptable[] = { Line 246  static const pcre_uint8 poptable[] = {
246    0, 0,                          /* ONCE, ONCE_NC                          */    0, 0,                          /* ONCE, ONCE_NC                          */
247    0, 0, 0, 0, 0,                 /* BRA, BRAPOS, CBRA, CBRAPOS, COND       */    0, 0, 0, 0, 0,                 /* BRA, BRAPOS, CBRA, CBRAPOS, COND       */
248    0, 0, 0, 0, 0,                 /* SBRA, SBRAPOS, SCBRA, SCBRAPOS, SCOND  */    0, 0, 0, 0, 0,                 /* SBRA, SBRAPOS, SCBRA, SCBRAPOS, SCOND  */
249    0, 0,                          /* CREF, NCREF                            */    0, 0,                          /* CREF, DNCREF                           */
250    0, 0,                          /* RREF, NRREF                            */    0, 0,                          /* RREF, DNRREF                           */
251    0,                             /* DEF                                    */    0,                             /* DEF                                    */
252    0, 0, 0,                       /* BRAZERO, BRAMINZERO, BRAPOSZERO        */    0, 0, 0,                       /* BRAZERO, BRAMINZERO, BRAPOSZERO        */
253    0, 0, 0,                       /* MARK, PRUNE, PRUNE_ARG                 */    0, 0, 0,                       /* MARK, PRUNE, PRUNE_ARG                 */
# Line 636  for (;;) Line 642  for (;;)
642      const pcre_uchar *code;      const pcre_uchar *code;
643      int state_offset = current_state->offset;      int state_offset = current_state->offset;
644      int codevalue, rrc;      int codevalue, rrc;
645      unsigned int count;      int count;
646    
647  #ifdef PCRE_DEBUG  #ifdef PCRE_DEBUG
648      printf ("%.*sProcessing state %d c=", rlevel*2-2, SP, state_offset);      printf ("%.*sProcessing state %d c=", rlevel*2-2, SP, state_offset);
# Line 1094  for (;;) Line 1100  for (;;)
1100                 PRIV(ucp_gentype)[prop->chartype] == ucp_N;                 PRIV(ucp_gentype)[prop->chartype] == ucp_N;
1101            break;            break;
1102    
1103            case PT_SPACE:    /* Perl space */            /* Perl space used to exclude VT, but from Perl 5.18 it is included,
1104            OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z ||            which means that Perl space and POSIX space are now identical. PCRE
1105                 c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;            was changed at release 8.34. */
           break;  
1106    
1107              case PT_SPACE:    /* Perl space */
1108            case PT_PXSPACE:  /* POSIX space */            case PT_PXSPACE:  /* POSIX space */
1109            OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z ||            switch(c)
1110                 c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||              {
1111                 c == CHAR_FF || c == CHAR_CR;              HSPACE_CASES:
1112                VSPACE_CASES:
1113                OK = TRUE;
1114                break;
1115    
1116                default:
1117                OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z;
1118                break;
1119                }
1120            break;            break;
1121    
1122            case PT_WORD:            case PT_WORD:
# Line 1255  for (;;) Line 1269  for (;;)
1269                (d != OP_ANY || !IS_NEWLINE(ptr)) &&                (d != OP_ANY || !IS_NEWLINE(ptr)) &&
1270                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
1271            {            {
1272            if (++count >= GET2(code, 1))            if (++count >= (int)GET2(code, 1))
1273              { ADD_NEW(state_offset + 1 + IMM2_SIZE + 1, 0); }              { ADD_NEW(state_offset + 1 + IMM2_SIZE + 1, 0); }
1274            else            else
1275              { ADD_NEW(state_offset, count); }              { ADD_NEW(state_offset, count); }
# Line 1289  for (;;) Line 1303  for (;;)
1303              active_count--;           /* Remove non-match possibility */              active_count--;           /* Remove non-match possibility */
1304              next_active_state--;              next_active_state--;
1305              }              }
1306            if (++count >= GET2(code, 1))            if (++count >= (int)GET2(code, 1))
1307              { ADD_NEW(state_offset + 2 + IMM2_SIZE, 0); }              { ADD_NEW(state_offset + 2 + IMM2_SIZE, 0); }
1308            else            else
1309              { ADD_NEW(state_offset, count); }              { ADD_NEW(state_offset, count); }
# Line 1344  for (;;) Line 1358  for (;;)
1358                 PRIV(ucp_gentype)[prop->chartype] == ucp_N;                 PRIV(ucp_gentype)[prop->chartype] == ucp_N;
1359            break;            break;
1360    
1361            case PT_SPACE:    /* Perl space */            /* Perl space used to exclude VT, but from Perl 5.18 it is included,
1362            OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z ||            which means that Perl space and POSIX space are now identical. PCRE
1363                 c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;            was changed at release 8.34. */
           break;  
1364    
1365              case PT_SPACE:    /* Perl space */
1366            case PT_PXSPACE:  /* POSIX space */            case PT_PXSPACE:  /* POSIX space */
1367            OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z ||            switch(c)
1368                 c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||              {
1369                 c == CHAR_FF || c == CHAR_CR;              HSPACE_CASES:
1370                VSPACE_CASES:
1371                OK = TRUE;
1372                break;
1373    
1374                default:
1375                OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z;
1376                break;
1377                }
1378            break;            break;
1379    
1380            case PT_WORD:            case PT_WORD:
# Line 1588  for (;;) Line 1610  for (;;)
1610                 PRIV(ucp_gentype)[prop->chartype] == ucp_N;                 PRIV(ucp_gentype)[prop->chartype] == ucp_N;
1611            break;            break;
1612    
1613            case PT_SPACE:    /* Perl space */            /* Perl space used to exclude VT, but from Perl 5.18 it is included,
1614            OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z ||            which means that Perl space and POSIX space are now identical. PCRE
1615                 c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;            was changed at release 8.34. */
           break;  
1616    
1617              case PT_SPACE:    /* Perl space */
1618            case PT_PXSPACE:  /* POSIX space */            case PT_PXSPACE:  /* POSIX space */
1619            OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z ||            switch(c)
1620                 c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||              {
1621                 c == CHAR_FF || c == CHAR_CR;              HSPACE_CASES:
1622                VSPACE_CASES:
1623                OK = TRUE;
1624                break;
1625    
1626                default:
1627                OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z;
1628                break;
1629                }
1630            break;            break;
1631    
1632            case PT_WORD:            case PT_WORD:
# Line 1857  for (;;) Line 1887  for (;;)
1887                 PRIV(ucp_gentype)[prop->chartype] == ucp_N;                 PRIV(ucp_gentype)[prop->chartype] == ucp_N;
1888            break;            break;
1889    
1890            case PT_SPACE:    /* Perl space */            /* Perl space used to exclude VT, but from Perl 5.18 it is included,
1891            OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z ||            which means that Perl space and POSIX space are now identical. PCRE
1892                 c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;            was changed at release 8.34. */
           break;  
1893    
1894              case PT_SPACE:    /* Perl space */
1895            case PT_PXSPACE:  /* POSIX space */            case PT_PXSPACE:  /* POSIX space */
1896            OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z ||            switch(c)
1897                 c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||              {
1898                 c == CHAR_FF || c == CHAR_CR;              HSPACE_CASES:
1899                VSPACE_CASES:
1900                OK = TRUE;
1901                break;
1902    
1903                default:
1904                OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z;
1905                break;
1906                }
1907            break;            break;
1908    
1909            case PT_WORD:            case PT_WORD:
# Line 1903  for (;;) Line 1941  for (;;)
1941              active_count--;           /* Remove non-match possibility */              active_count--;           /* Remove non-match possibility */
1942              next_active_state--;              next_active_state--;
1943              }              }
1944            if (++count >= GET2(code, 1))            if (++count >= (int)GET2(code, 1))
1945              { ADD_NEW(state_offset + 1 + IMM2_SIZE + 3, 0); }              { ADD_NEW(state_offset + 1 + IMM2_SIZE + 3, 0); }
1946            else            else
1947              { ADD_NEW(state_offset, count); }              { ADD_NEW(state_offset, count); }
# Line 1942  for (;;) Line 1980  for (;;)
1980            }            }
1981          if (nptr >= end_subject && (md->moptions & PCRE_PARTIAL_HARD) != 0)          if (nptr >= end_subject && (md->moptions & PCRE_PARTIAL_HARD) != 0)
1982              reset_could_continue = TRUE;              reset_could_continue = TRUE;
1983          if (++count >= GET2(code, 1))          if (++count >= (int)GET2(code, 1))
1984            { ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, ncount); }            { ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, ncount); }
1985          else          else
1986            { ADD_NEW_DATA(-state_offset, count, ncount); }            { ADD_NEW_DATA(-state_offset, count, ncount); }
# Line 1984  for (;;) Line 2022  for (;;)
2022              active_count--;           /* Remove non-match possibility */              active_count--;           /* Remove non-match possibility */
2023              next_active_state--;              next_active_state--;
2024              }              }
2025            if (++count >= GET2(code, 1))            if (++count >= (int)GET2(code, 1))
2026              { ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, ncount); }              { ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, ncount); }
2027            else            else
2028              { ADD_NEW_DATA(-state_offset, count, ncount); }              { ADD_NEW_DATA(-state_offset, count, ncount); }
# Line 2024  for (;;) Line 2062  for (;;)
2062              active_count--;           /* Remove non-match possibility */              active_count--;           /* Remove non-match possibility */
2063              next_active_state--;              next_active_state--;
2064              }              }
2065            if (++count >= GET2(code, 1))            if (++count >= (int)GET2(code, 1))
2066              { ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, 0); }              { ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, 0); }
2067            else            else
2068              { ADD_NEW_DATA(-state_offset, count, 0); }              { ADD_NEW_DATA(-state_offset, count, 0); }
# Line 2061  for (;;) Line 2099  for (;;)
2099              active_count--;           /* Remove non-match possibility */              active_count--;           /* Remove non-match possibility */
2100              next_active_state--;              next_active_state--;
2101              }              }
2102            if (++count >= GET2(code, 1))            if (++count >= (int)GET2(code, 1))
2103              { ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, 0); }              { ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, 0); }
2104            else            else
2105              { ADD_NEW_DATA(-state_offset, count, 0); }              { ADD_NEW_DATA(-state_offset, count, 0); }
# Line 2431  for (;;) Line 2469  for (;;)
2469            }            }
2470          if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR))          if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR))
2471            {            {
2472            if (++count >= GET2(code, 1))            if (++count >= (int)GET2(code, 1))
2473              { ADD_NEW(state_offset + dlen + 1 + IMM2_SIZE, 0); }              { ADD_NEW(state_offset + dlen + 1 + IMM2_SIZE, 0); }
2474            else            else
2475              { ADD_NEW(state_offset, count); }              { ADD_NEW(state_offset, count); }
# Line 2480  for (;;) Line 2518  for (;;)
2518              active_count--;             /* Remove non-match possibility */              active_count--;             /* Remove non-match possibility */
2519              next_active_state--;              next_active_state--;
2520              }              }
2521            if (++count >= GET2(code, 1))            if (++count >= (int)GET2(code, 1))
2522              { ADD_NEW(state_offset + dlen + 1 + IMM2_SIZE, 0); }              { ADD_NEW(state_offset + dlen + 1 + IMM2_SIZE, 0); }
2523            else            else
2524              { ADD_NEW(state_offset, count); }              { ADD_NEW(state_offset, count); }
# Line 2533  for (;;) Line 2571  for (;;)
2571            {            {
2572            case OP_CRSTAR:            case OP_CRSTAR:
2573            case OP_CRMINSTAR:            case OP_CRMINSTAR:
2574              case OP_CRPOSSTAR:
2575            ADD_ACTIVE(next_state_offset + 1, 0);            ADD_ACTIVE(next_state_offset + 1, 0);
2576            if (isinclass) { ADD_NEW(state_offset, 0); }            if (isinclass)
2577                {
2578                if (*ecode == OP_CRPOSSTAR)
2579                  {
2580                  active_count--;           /* Remove non-match possibility */
2581                  next_active_state--;
2582                  }
2583                ADD_NEW(state_offset, 0);
2584                }
2585            break;            break;
2586    
2587            case OP_CRPLUS:            case OP_CRPLUS:
2588            case OP_CRMINPLUS:            case OP_CRMINPLUS:
2589              case OP_CRPOSPLUS:
2590            count = current_state->count;  /* Already matched */            count = current_state->count;  /* Already matched */
2591            if (count > 0) { ADD_ACTIVE(next_state_offset + 1, 0); }            if (count > 0) { ADD_ACTIVE(next_state_offset + 1, 0); }
2592            if (isinclass) { count++; ADD_NEW(state_offset, count); }            if (isinclass)
2593                {
2594                if (count > 0 && *ecode == OP_CRPOSPLUS)
2595                  {
2596                  active_count--;           /* Remove non-match possibility */
2597                  next_active_state--;
2598                  }
2599                count++;
2600                ADD_NEW(state_offset, count);
2601                }
2602            break;            break;
2603    
2604            case OP_CRQUERY:            case OP_CRQUERY:
2605            case OP_CRMINQUERY:            case OP_CRMINQUERY:
2606              case OP_CRPOSQUERY:
2607            ADD_ACTIVE(next_state_offset + 1, 0);            ADD_ACTIVE(next_state_offset + 1, 0);
2608            if (isinclass) { ADD_NEW(next_state_offset + 1, 0); }            if (isinclass)
2609                {
2610                if (*ecode == OP_CRPOSQUERY)
2611                  {
2612                  active_count--;           /* Remove non-match possibility */
2613                  next_active_state--;
2614                  }
2615                ADD_NEW(next_state_offset + 1, 0);
2616                }
2617            break;            break;
2618    
2619            case OP_CRRANGE:            case OP_CRRANGE:
2620            case OP_CRMINRANGE:            case OP_CRMINRANGE:
2621              case OP_CRPOSRANGE:
2622            count = current_state->count;  /* Already matched */            count = current_state->count;  /* Already matched */
2623            if (count >= GET2(ecode, 1))            if (count >= (int)GET2(ecode, 1))
2624              { ADD_ACTIVE(next_state_offset + 1 + 2 * IMM2_SIZE, 0); }              { ADD_ACTIVE(next_state_offset + 1 + 2 * IMM2_SIZE, 0); }
2625            if (isinclass)            if (isinclass)
2626              {              {
2627              unsigned int max = GET2(ecode, 1 + IMM2_SIZE);              int max = (int)GET2(ecode, 1 + IMM2_SIZE);
2628                if (*ecode == OP_CRPOSRANGE)
2629                  {
2630                  active_count--;           /* Remove non-match possibility */
2631                  next_active_state--;
2632                  }
2633              if (++count >= max && max != 0)   /* Max 0 => no limit */              if (++count >= max && max != 0)   /* Max 0 => no limit */
2634                { ADD_NEW(next_state_offset + 1 + 2 * IMM2_SIZE, 0); }                { ADD_NEW(next_state_offset + 1 + 2 * IMM2_SIZE, 0); }
2635              else              else
# Line 2657  for (;;) Line 2729  for (;;)
2729    
2730          condcode = code[LINK_SIZE+1];          condcode = code[LINK_SIZE+1];
2731    
2732          /* Back reference conditions are not supported */          /* Back reference conditions and duplicate named recursion conditions
2733            are not supported */
2734    
2735          if (condcode == OP_CREF || condcode == OP_NCREF)          if (condcode == OP_CREF || condcode == OP_DNCREF ||
2736                condcode == OP_DNRREF)
2737            return PCRE_ERROR_DFA_UCOND;            return PCRE_ERROR_DFA_UCOND;
2738    
2739          /* The DEFINE condition is always false */          /* The DEFINE condition is always false */
# Line 2671  for (;;) Line 2745  for (;;)
2745          which means "test if in any recursion". We can't test for specifically          which means "test if in any recursion". We can't test for specifically
2746          recursed groups. */          recursed groups. */
2747    
2748          else if (condcode == OP_RREF || condcode == OP_NRREF)          else if (condcode == OP_RREF)
2749            {            {
2750            int value = GET2(code, LINK_SIZE + 2);            int value = GET2(code, LINK_SIZE + 2);
2751            if (value != RREF_ANY) return PCRE_ERROR_DFA_UCOND;            if (value != RREF_ANY) return PCRE_ERROR_DFA_UCOND;

Legend:
Removed from v.1320  
changed lines
  Added in v.1379

  ViewVC Help
Powered by ViewVC 1.1.5