6.2.482

   1 To: vim-dev@vim.org
   2 Subject: Patch 6.2.482
   3 Fcc: outbox
   4 From: Bram Moolenaar <Bram@moolenaar.net>
   5 Mime-Version: 1.0
   6 Content-Type: text/plain; charset=ISO-8859-1
   7 Content-Transfer-Encoding: 8bit
   8 ------------
   9
  10 Patch 6.2.482
  11 Problem:    Repeating insert of CTRL-K 1 S doesn't work.  The superscript 1 is
  12             considered to be a digit. (Juergen Kraemer)
  13 Solution:   In vim_isdigit() only accept '0' to '9'.  Use VIM_ISDIGIT() for
  14             speed where possible.  Also add vim_isxdigit().
  15 Files:      src/buffer.c, src/charset.c, src/diff.c, src/digraph.c,
  16             src/edit.c, src/eval.c,, src/ex_cmds.c, src/ex_cmds2.c,
  17             src/ex_docmd.c, src/ex_eval.c, src/ex_getln.c,
  18             src/if_xcmdsrv.c, src/farsi.c, src/fileio.c, src/fold.c,
  19             src/getchar.c, src/gui.c, src/if_cscope.c, src/macros.h,
  20             src/main.c, src/mark.c, src/mbyte.c, src/menu.c, src/misc1.c,
  21             src/misc2.c, src/normal.c, src/ops.c, src/option.c,
  22             src/proto/charset.pro, src/regexp.c, src/screen.c, src/search.c,
  23             src/syntax.c, src/tag.c, src/term.c, src/termlib.c
  24
  25
  26 *** ../vim-6.2.481/src/buffer.c Sun Apr  4 12:06:41 2004
  27 --- src/buffer.c        Mon Apr 19 19:00:31 2004
  28 ***************
  29 *** 783,789 ****
  30                 arg = skipwhite(arg);
  31                 if (*arg == NUL)
  32                     break;
  33 !               if (!isdigit(*arg))
  34                 {
  35                     p = skiptowhite_esc(arg);
  36                     bnr = buflist_findpat(arg, p, command == DOBUF_WIPE, FALSE);
  37 --- 783,789 ----
  38                 arg = skipwhite(arg);
  39                 if (*arg == NUL)
  40                     break;
  41 !               if (!VIM_ISDIGIT(*arg))
  42                 {
  43                     p = skiptowhite_esc(arg);
  44                     bnr = buflist_findpat(arg, p, command == DOBUF_WIPE, FALSE);
  45 ***************
  46 *** 3241,3247 ****
  47             s++;
  48             l = -1;
  49         }
  50 !       if (isdigit(*s))
  51         {
  52             minwid = (int)getdigits(&s);
  53             if (minwid < 0)     /* overflow */
  54 --- 3241,3247 ----
  55             s++;
  56             l = -1;
  57         }
  58 !       if (VIM_ISDIGIT(*s))
  59         {
  60             minwid = (int)getdigits(&s);
  61             if (minwid < 0)     /* overflow */
  62 ***************
  63 *** 3259,3265 ****
  64         if (*s == '.')
  65         {
  66             s++;
  67 !           if (isdigit(*s))
  68             {
  69                 maxwid = (int)getdigits(&s);
  70                 if (maxwid <= 0)        /* overflow */
  71 --- 3259,3265 ----
  72         if (*s == '.')
  73         {
  74             s++;
  75 !           if (VIM_ISDIGIT(*s))
  76             {
  77                 maxwid = (int)getdigits(&s);
  78                 if (maxwid <= 0)        /* overflow */
  79 ***************
  80 *** 3550,3556 ****
  81                 for (; l < minwid && p + 1 < out + outlen; l++)
  82                 {
  83                     /* Don't put a "-" in front of a digit. */
  84 !                   if (l + 1 == minwid && fillchar == '-' && isdigit(*t))
  85                         *p++ = ' ';
  86                     else
  87                         *p++ = fillchar;
  88 --- 3550,3556 ----
  89                 for (; l < minwid && p + 1 < out + outlen; l++)
  90                 {
  91                     /* Don't put a "-" in front of a digit. */
  92 !                   if (l + 1 == minwid && fillchar == '-' && VIM_ISDIGIT(*t))
  93                         *p++ = ' ';
  94                     else
  95                         *p++ = fillchar;
  96 ***************
  97 *** 3565,3571 ****
  98                 /* Change a space by fillchar, unless fillchar is '-' and a
  99                  * digit follows. */
 100                 if (fillable && p[-1] == ' '
 101 !                                        && (!isdigit(*t) || fillchar != '-'))
 102                     p[-1] = fillchar;
 103             }
 104             for (; l < minwid && p + 1 < out + outlen; l++)
 105 --- 3565,3571 ----
 106                 /* Change a space by fillchar, unless fillchar is '-' and a
 107                  * digit follows. */
 108                 if (fillable && p[-1] == ' '
 109 !                                    && (!VIM_ISDIGIT(*t) || fillchar != '-'))
 110                     p[-1] = fillchar;
 111             }
 112             for (; l < minwid && p + 1 < out + outlen; l++)
 113 *** ../vim-6.2.481/src/charset.c        Tue Mar 23 23:11:09 2004
 114 --- src/charset.c       Mon Apr 19 19:00:38 2004
 115 ***************
 116 *** 170,176 ****
 117                 tilde = TRUE;
 118                 ++p;
 119             }
 120 !           if (isdigit(*p))
 121                 c = getdigits(&p);
 122             else
 123                 c = *p++;
 124 --- 170,176 ----
 125                 tilde = TRUE;
 126                 ++p;
 127             }
 128 !           if (VIM_ISDIGIT(*p))
 129                 c = getdigits(&p);
 130             else
 131                 c = *p++;
 132 ***************
 133 *** 178,184 ****
 134             if (*p == '-' && p[1] != NUL)
 135             {
 136                 ++p;
 137 !               if (isdigit(*p))
 138                     c2 = getdigits(&p);
 139                 else
 140                     c2 = *p++;
 141 --- 178,184 ----
 142             if (*p == '-' && p[1] != NUL)
 143             {
 144                 ++p;
 145 !               if (VIM_ISDIGIT(*p))
 146                     c2 = getdigits(&p);
 147                 else
 148                     c2 = *p++;
 149 ***************
 150 *** 1432,1450 ****
 151   skipdigits(p)
 152       char_u    *p;
 153   {
 154 !     while (isdigit(*p))       /* skip to next non-digit */
 155         ++p;
 156       return p;
 157   }
 158
 159   /*
 160 !  * vim_isdigit: version of isdigit() that can handle characters > 0x100.
 161    */
 162       int
 163   vim_isdigit(c)
 164 !     int           c;
 165   {
 166 !     return (c > 0 && c < 0x100 && isdigit(c));
 167   }
 168
 169   /*
 170 --- 1433,1468 ----
 171   skipdigits(p)
 172       char_u    *p;
 173   {
 174 !     while (VIM_ISDIGIT(*p))   /* skip to next non-digit */
 175         ++p;
 176       return p;
 177   }
 178
 179   /*
 180 !  * Variant of isdigit() that can handle characters > 0x100.
 181 !  * We don't use isdigit() here, because on some systems it also considers
 182 !  * superscript 1 to be a digit.
 183 !  * Use the VIM_ISDIGIT() macro for simple arguments.
 184    */
 185       int
 186   vim_isdigit(c)
 187 !     int               c;
 188 ! {
 189 !     return (c >= '0' && c <= '9');
 190 ! }
 191 !
 192 ! /*
 193 !  * Variant of isxdigit() that can handle characters > 0x100.
 194 !  * We don't use isxdigit() here, because on some systems it also considers
 195 !  * superscript 1 to be a digit.
 196 !  */
 197 !     int
 198 ! vim_isxdigit(c)
 199 !     int               c;
 200   {
 201 !     return (c >= '0' && c <= '9')
 202 !       || (c >= 'a' && c <= 'f')
 203 !       || (c >= 'A' && c <= 'F');
 204   }
 205
 206   /*
 207 ***************
 208 *** 1549,1559 ****
 209       if (ptr[0] == '0')                        /* could be hex or octal */
 210       {
 211         hex = ptr[1];
 212 !       if (dohex && (hex == 'X' || hex == 'x') && isxdigit(ptr[2]))
 213             ptr += 2;                   /* hexadecimal */
 214         else
 215         {
 216 !           if (dooct && isdigit(hex))
 217                 hex = '0';              /* octal */
 218             else
 219                 hex = 0;                /* 0 by itself is decimal */
 220 --- 1567,1577 ----
 221       if (ptr[0] == '0')                        /* could be hex or octal */
 222       {
 223         hex = ptr[1];
 224 !       if (dohex && (hex == 'X' || hex == 'x') && vim_isxdigit(ptr[2]))
 225             ptr += 2;                   /* hexadecimal */
 226         else
 227         {
 228 !           if (dooct && VIM_ISDIGIT(hex))
 229                 hex = '0';              /* octal */
 230             else
 231                 hex = 0;                /* 0 by itself is decimal */
 232 ***************
 233 *** 1578,1584 ****
 234         else
 235         {
 236             /* hex */
 237 !           while (isxdigit(*ptr))
 238             {
 239                 n = 16 * n + (long)hex2nr(*ptr);
 240                 un = 16 * un + (unsigned long)hex2nr(*ptr);
 241 --- 1596,1602 ----
 242         else
 243         {
 244             /* hex */
 245 !           while (vim_isxdigit(*ptr))
 246             {
 247                 n = 16 * n + (long)hex2nr(*ptr);
 248                 un = 16 * un + (unsigned long)hex2nr(*ptr);
 249 ***************
 250 *** 1589,1595 ****
 251       else
 252       {
 253         /* decimal */
 254 !       while (isdigit(*ptr))
 255         {
 256             n = 10 * n + (long)(*ptr - '0');
 257             un = 10 * un + (unsigned long)(*ptr - '0');
 258 --- 1607,1613 ----
 259       else
 260       {
 261         /* decimal */
 262 !       while (VIM_ISDIGIT(*ptr))
 263         {
 264             n = 10 * n + (long)(*ptr - '0');
 265             un = 10 * un + (unsigned long)(*ptr - '0');
 266 ***************
 267 *** 1635,1641 ****
 268   hexhex2nr(p)
 269       char_u    *p;
 270   {
 271 !     if (!isxdigit(p[0]) || !isxdigit(p[1]))
 272         return -1;
 273       return (hex2nr(p[0]) << 4) + hex2nr(p[1]);
 274   }
 275 --- 1653,1659 ----
 276   hexhex2nr(p)
 277       char_u    *p;
 278   {
 279 !     if (!vim_isxdigit(p[0]) || !vim_isxdigit(p[1]))
 280         return -1;
 281       return (hex2nr(p[0]) << 4) + hex2nr(p[1]);
 282   }
 283 *** ../vim-6.2.481/src/diff.c   Wed Mar  3 21:08:15 2004
 284 --- src/diff.c  Mon Apr 19 19:00:42 2004
 285 ***************
 286 *** 1539,1545 ****
 287             p += 6;
 288             diff_flags_new |= DIFF_FILLER;
 289         }
 290 !       else if (STRNCMP(p, "context:", 8) == 0 && isdigit(p[8]))
 291         {
 292             p += 8;
 293             diff_context_new = getdigits(&p);
 294 --- 1539,1545 ----
 295             p += 6;
 296             diff_flags_new |= DIFF_FILLER;
 297         }
 298 !       else if (STRNCMP(p, "context:", 8) == 0 && VIM_ISDIGIT(p[8]))
 299         {
 300             p += 8;
 301             diff_context_new = getdigits(&p);
 302 ***************
 303 *** 1791,1797 ****
 304         p = eap->arg + STRLEN(eap->arg);
 305         while (p > eap->arg && vim_iswhite(p[-1]))
 306             --p;
 307 !       for (i = 0; isdigit(eap->arg[i]) && eap->arg + i < p; ++i)
 308             ;
 309         if (eap->arg + i == p)      /* digits only */
 310             i = atol((char *)eap->arg);
 311 --- 1791,1797 ----
 312         p = eap->arg + STRLEN(eap->arg);
 313         while (p > eap->arg && vim_iswhite(p[-1]))
 314             --p;
 315 !       for (i = 0; vim_isdigit(eap->arg[i]) && eap->arg + i < p; ++i)
 316             ;
 317         if (eap->arg + i == p)      /* digits only */
 318             i = atol((char *)eap->arg);
 319 *** ../vim-6.2.481/src/digraph.c        Sun Mar 14 20:12:26 2004
 320 --- src/digraph.c       Mon Apr 19 19:00:45 2004
 321 ***************
 322 *** 2200,2206 ****
 323             return;
 324         }
 325         str = skipwhite(str);
 326 !       if (!isdigit(*str))
 327         {
 328             EMSG(_(e_number_exp));
 329             return;
 330 --- 2200,2206 ----
 331             return;
 332         }
 333         str = skipwhite(str);
 334 !       if (!VIM_ISDIGIT(*str))
 335         {
 336             EMSG(_(e_number_exp));
 337             return;
 338 *** ../vim-6.2.481/src/edit.c   Sat Apr  3 17:00:08 2004
 339 --- src/edit.c  Mon Apr 19 19:00:48 2004
 340 ***************
 341 *** 3713,3732 ****
 342   #endif
 343                     )
 344             {
 345 !               /* Careful: isxdigit() on Win32 can handle only 0-255 */
 346 !               if (nc < 0 || nc > 255 || (!vim_isdigit(nc) && !isxdigit(nc)))
 347                     break;
 348                 cc = cc * 16 + hex2nr(nc);
 349             }
 350             else if (octal)
 351             {
 352 !               if (!vim_isdigit(nc) || (nc > '7'))
 353                     break;
 354                 cc = cc * 8 + nc - '0';
 355             }
 356             else
 357             {
 358 !               if (!vim_isdigit(nc))
 359                     break;
 360                 cc = cc * 10 + nc - '0';
 361             }
 362 --- 3713,3731 ----
 363   #endif
 364                     )
 365             {
 366 !               if (!vim_isxdigit(nc))
 367                     break;
 368                 cc = cc * 16 + hex2nr(nc);
 369             }
 370             else if (octal)
 371             {
 372 !               if (nc < '0' || nc > '7')
 373                     break;
 374                 cc = cc * 8 + nc - '0';
 375             }
 376             else
 377             {
 378 !               if (!VIM_ISDIGIT(nc))
 379                     break;
 380                 cc = cc * 10 + nc - '0';
 381             }
 382 ***************
 383 *** 4566,4572 ****
 384
 385       /* Only digits need special treatment.  Translate them into a string of
 386        * three digits. */
 387 !     if (vim_isdigit(c))
 388       {
 389         sprintf((char *)buf, "%03d", c);
 390         AppendToRedobuff(buf);
 391 --- 4565,4571 ----
 392
 393       /* Only digits need special treatment.  Translate them into a string of
 394        * three digits. */
 395 !     if (VIM_ISDIGIT(c))
 396       {
 397         sprintf((char *)buf, "%03d", c);
 398         AppendToRedobuff(buf);
 399 diff: src/eval.c,: No such file or directory
 400 *** ../vim-6.2.481/src/ex_cmds.c        Wed Apr 14 22:39:35 2004
 401 --- src/ex_cmds.c       Mon Apr 19 19:00:57 2004
 402 ***************
 403 *** 1833,1839 ****
 404       char_u    *s, *d;
 405       long      len;
 406
 407 !     if (virp->vir_line[off] == Ctrl_V && isdigit(virp->vir_line[off + 1]))
 408       {
 409         len = atol((char *)virp->vir_line + off + 1);
 410         retval = lalloc(len, TRUE);
 411 --- 1833,1839 ----
 412       char_u    *s, *d;
 413       long      len;
 414
 415 !     if (virp->vir_line[off] == Ctrl_V && vim_isdigit(virp->vir_line[off + 1]))
 416       {
 417         len = atol((char *)virp->vir_line + off + 1);
 418         retval = lalloc(len, TRUE);
 419 ***************
 420 *** 3334,3340 ****
 421
 422       if (*x != 0)
 423       {
 424 !       if (!isdigit(*x))
 425         {
 426             EMSG(_("E144: non-numeric argument to :z"));
 427             return;
 428 --- 3334,3340 ----
 429
 430       if (*x != 0)
 431       {
 432 !       if (!VIM_ISDIGIT(*x))
 433         {
 434             EMSG(_("E144: non-numeric argument to :z"));
 435             return;
 436 ***************
 437 *** 3647,3653 ****
 438        * check for a trailing count
 439        */
 440       cmd = skipwhite(cmd);
 441 !     if (isdigit(*cmd))
 442       {
 443         i = getdigits(&cmd);
 444         if (i <= 0 && !eap->skip && do_error)
 445 --- 3647,3653 ----
 446        * check for a trailing count
 447        */
 448       cmd = skipwhite(cmd);
 449 !     if (VIM_ISDIGIT(*cmd))
 450       {
 451         i = getdigits(&cmd);
 452         if (i <= 0 && !eap->skip && do_error)
 453 ***************
 454 *** 5573,5579 ****
 455
 456                     /* If the name is a number use that for the typenr,
 457                      * otherwise use a negative number. */
 458 !                   if (isdigit(*arg))
 459                         sp->sn_typenr = atoi((char *)arg);
 460                     else
 461                     {
 462 --- 5573,5579 ----
 463
 464                     /* If the name is a number use that for the typenr,
 465                      * otherwise use a negative number. */
 466 !                   if (VIM_ISDIGIT(*arg))
 467                         sp->sn_typenr = atoi((char *)arg);
 468                     else
 469                     {
 470 ***************
 471 *** 5753,5759 ****
 472
 473         /* first arg could be placed sign id */
 474         arg1 = arg;
 475 !       if (isdigit(*arg))
 476         {
 477             id = getdigits(&arg);
 478             if (!vim_iswhite(*arg) && *arg != NUL)
 479 --- 5753,5759 ----
 480
 481         /* first arg could be placed sign id */
 482         arg1 = arg;
 483 !       if (VIM_ISDIGIT(*arg))
 484         {
 485             id = getdigits(&arg);
 486             if (!vim_iswhite(*arg) && *arg != NUL)
 487 *** ../vim-6.2.481/src/ex_cmds2.c       Fri Apr  2 22:25:53 2004
 488 --- src/ex_cmds2.c      Mon Apr 19 19:01:02 2004
 489 ***************
 490 *** 393,399 ****
 491       p = skipwhite(p + 4);
 492
 493       /* Find optional line number. */
 494 !     if (isdigit(*p))
 495       {
 496         bp->dbg_lnum = getdigits(&p);
 497         p = skipwhite(p);
 498 --- 393,399 ----
 499       p = skipwhite(p + 4);
 500
 501       /* Find optional line number. */
 502 !     if (VIM_ISDIGIT(*p))
 503       {
 504         bp->dbg_lnum = getdigits(&p);
 505         p = skipwhite(p);
 506 ***************
 507 *** 502,508 ****
 508       int               i;
 509       linenr_T  best_lnum = 0;
 510
 511 !     if (isdigit(*eap->arg))
 512       {
 513         /* ":breakdel {nr}" */
 514         nr = atol((char *)eap->arg);
 515 --- 502,508 ----
 516       int               i;
 517       linenr_T  best_lnum = 0;
 518
 519 !     if (vim_isdigit(*eap->arg))
 520       {
 521         /* ":breakdel {nr}" */
 522         nr = atol((char *)eap->arg);
 523 ***************
 524 *** 4688,4694 ****
 525        */
 526       fontsize = PRT_PS_DEFAULT_FONTSIZE;
 527       for (p = p_pfn; (p = vim_strchr(p, ':')) != NULL; ++p)
 528 !       if (p[1] == 'h' && isdigit(p[2]))
 529             fontsize = atoi((char *)p + 2);
 530       prt_font_metrics(fontsize);
 531
 532 --- 4688,4694 ----
 533        */
 534       fontsize = PRT_PS_DEFAULT_FONTSIZE;
 535       for (p = p_pfn; (p = vim_strchr(p, ':')) != NULL; ++p)
 536 !       if (p[1] == 'h' && VIM_ISDIGIT(p[2]))
 537             fontsize = atoi((char *)p + 2);
 538       prt_font_metrics(fontsize);
 539
 540 *** ../vim-6.2.481/src/ex_docmd.c       Fri Apr 16 11:14:51 2004
 541 --- src/ex_docmd.c      Mon Apr 19 19:01:12 2004
 542 ***************
 543 *** 1625,1631 ****
 544    * 2. handle command modifiers.
 545    */
 546         p = ea.cmd;
 547 !       if (isdigit(*ea.cmd))
 548             p = skipwhite(skipdigits(ea.cmd));
 549         switch (*p)
 550         {
 551 --- 1625,1631 ----
 552    * 2. handle command modifiers.
 553    */
 554         p = ea.cmd;
 555 !       if (VIM_ISDIGIT(*ea.cmd))
 556             p = skipwhite(skipdigits(ea.cmd));
 557         switch (*p)
 558         {
 559 ***************
 560 *** 2253,2259 ****
 561   #else
 562             && valid_yank_reg(*ea.arg, ea.cmdidx != CMD_put)
 563   #endif
 564 !           && !((ea.argt & COUNT) && isdigit(*ea.arg)))
 565       {
 566         ea.regname = *ea.arg++;
 567   #ifdef FEAT_EVAL
 568 --- 2251,2257 ----
 569   #else
 570             && valid_yank_reg(*ea.arg, ea.cmdidx != CMD_put)
 571   #endif
 572 !           && !((ea.argt & COUNT) && VIM_ISDIGIT(*ea.arg)))
 573       {
 574         ea.regname = *ea.arg++;
 575   #ifdef FEAT_EVAL
 576 ***************
 577 *** 2271,2277 ****
 578        * Check for a count.  When accepting a BUFNAME, don't use "123foo" as a
 579        * count, it's a buffer name.
 580        */
 581 !     if ((ea.argt & COUNT) && isdigit(*ea.arg)
 582             && (!(ea.argt & BUFNAME) || *(p = skipdigits(ea.arg)) == NUL
 583                                                           || vim_iswhite(*p)))
 584       {
 585 --- 2269,2275 ----
 586        * Check for a count.  When accepting a BUFNAME, don't use "123foo" as a
 587        * count, it's a buffer name.
 588        */
 589 !     if ((ea.argt & COUNT) && VIM_ISDIGIT(*ea.arg)
 590             && (!(ea.argt & BUFNAME) || *(p = skipdigits(ea.arg)) == NUL
 591                                                           || vim_iswhite(*p)))
 592       {
 593 ***************
 594 *** 2669,2675 ****
 595                     k = 0;
 596                     while (k < len && *np != NUL && *cp++ == *np++)
 597                         k++;
 598 !                   if (k == len || (*np == NUL && isdigit(eap->cmd[k])))
 599                     {
 600                         /* If finding a second match, the command is
 601                          * ambiguous.  But not if a buffer-local command
 602 --- 2667,2673 ----
 603                     k = 0;
 604                     while (k < len && *np != NUL && *cp++ == *np++)
 605                         k++;
 606 !                   if (k == len || (*np == NUL && vim_isdigit(eap->cmd[k])))
 607                     {
 608                         /* If finding a second match, the command is
 609                          * ambiguous.  But not if a buffer-local command
 610 ***************
 611 *** 2941,2947 ****
 612                     k = 0;
 613                     while (k < i && *np != NUL && *cp++ == *np++)
 614                         k++;
 615 !                   if (k == i || (*np == NUL && isdigit(cmd[k])))
 616                     {
 617                         if (k == i && found)
 618                         {
 619 --- 2939,2945 ----
 620                     k = 0;
 621                     while (k < i && *np != NUL && *cp++ == *np++)
 622                         k++;
 623 !                   if (k == i || (*np == NUL && VIM_ISDIGIT(cmd[k])))
 624                     {
 625                         if (k == i && found)
 626                         {
 627 ***************
 628 *** 3564,3570 ****
 629   {
 630       int               delim;
 631
 632 !     while (*cmd != NUL && (vim_isspace(*cmd) || isdigit(*cmd) ||
 633                             vim_strchr((char_u *)".$%'/?-+,;", *cmd) != NULL))
 634       {
 635         if (*cmd == '\'')
 636 --- 3562,3568 ----
 637   {
 638       int               delim;
 639
 640 !     while (*cmd != NUL && (vim_isspace(*cmd) || VIM_ISDIGIT(*cmd) ||
 641                             vim_strchr((char_u *)".$%'/?-+,;", *cmd) != NULL))
 642       {
 643         if (*cmd == '\'')
 644 ***************
 645 *** 3745,3767 ****
 646                         break;
 647
 648             default:
 649 !                       if (isdigit(*cmd))      /* absolute line number */
 650                             lnum = getdigits(&cmd);
 651         }
 652
 653         for (;;)
 654         {
 655             cmd = skipwhite(cmd);
 656 !           if (*cmd != '-' && *cmd != '+' && !isdigit(*cmd))
 657                 break;
 658
 659             if (lnum == MAXLNUM)
 660                 lnum = curwin->w_cursor.lnum;   /* "+1" is same as ".+1" */
 661 !           if (isdigit(*cmd))
 662                 i = '+';                /* "number" is same as "+number" */
 663             else
 664                 i = *cmd++;
 665 !           if (!isdigit(*cmd))         /* '+' is '+1', but '+0' is not '+1' */
 666                 n = 1;
 667             else
 668                 n = getdigits(&cmd);
 669 --- 3743,3765 ----
 670                         break;
 671
 672             default:
 673 !                       if (VIM_ISDIGIT(*cmd))  /* absolute line number */
 674                             lnum = getdigits(&cmd);
 675         }
 676
 677         for (;;)
 678         {
 679             cmd = skipwhite(cmd);
 680 !           if (*cmd != '-' && *cmd != '+' && !VIM_ISDIGIT(*cmd))
 681                 break;
 682
 683             if (lnum == MAXLNUM)
 684                 lnum = curwin->w_cursor.lnum;   /* "+1" is same as ".+1" */
 685 !           if (VIM_ISDIGIT(*cmd))
 686                 i = '+';                /* "number" is same as "+number" */
 687             else
 688                 i = *cmd++;
 689 !           if (!VIM_ISDIGIT(*cmd))     /* '+' is '+1', but '+0' is not '+1' */
 690                 n = 1;
 691             else
 692                 n = getdigits(&cmd);
 693 ***************
 694 *** 7525,7531 ****
 695       /* ":mkview" or ":mkview 9": generate file name with 'viewdir' */
 696       if (eap->cmdidx == CMD_mkview
 697             && (*eap->arg == NUL
 698 !               || (isdigit(*eap->arg) && eap->arg[1] == NUL)))
 699       {
 700         eap->forceit = TRUE;
 701         fname = get_view_file(*eap->arg);
 702 --- 7523,7529 ----
 703       /* ":mkview" or ":mkview 9": generate file name with 'viewdir' */
 704       if (eap->cmdidx == CMD_mkview
 705             && (*eap->arg == NUL
 706 !               || (vim_isdigit(*eap->arg) && eap->arg[1] == NUL)))
 707       {
 708         eap->forceit = TRUE;
 709         fname = get_view_file(*eap->arg);
 710 ***************
 711 *** 8002,8008 ****
 712       }
 713
 714       n = 1;
 715 !     if (isdigit(*eap->arg))   /* get count */
 716       {
 717         n = getdigits(&eap->arg);
 718         eap->arg = skipwhite(eap->arg);
 719 --- 8000,8006 ----
 720       }
 721
 722       n = 1;
 723 !     if (vim_isdigit(*eap->arg))       /* get count */
 724       {
 725         n = getdigits(&eap->arg);
 726         eap->arg = skipwhite(eap->arg);
 727 *** ../vim-6.2.481/src/ex_eval.c        Wed Apr 14 11:08:53 2004
 728 --- src/ex_eval.c       Mon Apr 19 19:01:17 2004
 729 ***************
 730 *** 283,291 ****
 731
 732                         /* Skip the extra "Vim " prefix for message "E458". */
 733                         tmsg = elem->msg;
 734 !                       if (STRNCMP(tmsg, "Vim E", 5) == 0 && isdigit(tmsg[5])
 735 !                               && isdigit(tmsg[6]) && isdigit(tmsg[7])
 736 !                               && tmsg[8] == ':' && tmsg[9] == ' ')
 737                             (*msg_list)->throw_msg = &tmsg[4];
 738                         else
 739                             (*msg_list)->throw_msg = tmsg;
 740 --- 283,294 ----
 741
 742                         /* Skip the extra "Vim " prefix for message "E458". */
 743                         tmsg = elem->msg;
 744 !                       if (STRNCMP(tmsg, "Vim E", 5) == 0
 745 !                               && VIM_ISDIGIT(tmsg[5])
 746 !                               && VIM_ISDIGIT(tmsg[6])
 747 !                               && VIM_ISDIGIT(tmsg[7])
 748 !                               && tmsg[8] == ':'
 749 !                               && tmsg[9] == ' ')
 750                             (*msg_list)->throw_msg = &tmsg[4];
 751                         else
 752                             (*msg_list)->throw_msg = tmsg;
 753 ***************
 754 *** 473,483 ****
 755          * parentheses and move it to the end. */
 756         for (p = mesg; ; p++)
 757         {
 758 !           if (*p == NUL || (*p == 'E' &&
 759 !                       isdigit(p[1]) &&
 760 !                       (p[2] == ':' || (isdigit(p[2]) &&
 761 !                                        (p[3] == ':' || (isdigit(p[3]) &&
 762 !                                                         p[4] == ':'))))))
 763             {
 764                 if (*p == NUL || p == mesg)  /* 'E123' missing or at beginning */
 765                     STRCAT(val, mesg);
 766 --- 476,489 ----
 767          * parentheses and move it to the end. */
 768         for (p = mesg; ; p++)
 769         {
 770 !           if (*p == NUL
 771 !                   || (*p == 'E'
 772 !                       && VIM_ISDIGIT(p[1])
 773 !                       && (p[2] == ':'
 774 !                           || (VIM_ISDIGIT(p[2])
 775 !                               && (p[3] == ':'
 776 !                                   || (VIM_ISDIGIT(p[3])
 777 !                                       && p[4] == ':'))))))
 778             {
 779                 if (*p == NUL || p == mesg)  /* 'E123' missing or at beginning */
 780                     STRCAT(val, mesg);
 781 *** ../vim-6.2.481/src/ex_getln.c       Fri Apr 16 11:14:51 2004
 782 --- src/ex_getln.c      Mon Apr 19 19:01:20 2004
 783 ***************
 784 *** 4702,4708 ****
 785       long      num;
 786
 787       *str = skipwhite(*str);
 788 !     if (**str == '-' || isdigit(**str))       /* parse "from" part of range */
 789       {
 790         vim_str2nr(*str, NULL, &len, FALSE, FALSE, &num, NULL);
 791         *str += len;
 792 --- 4702,4708 ----
 793       long      num;
 794
 795       *str = skipwhite(*str);
 796 !     if (**str == '-' || vim_isdigit(**str))  /* parse "from" part of range */
 797       {
 798         vim_str2nr(*str, NULL, &len, FALSE, FALSE, &num, NULL);
 799         *str += len;
 800 ***************
 801 *** 4752,4758 ****
 802         return;
 803       }
 804
 805 !     if (!(isdigit(*arg) || *arg == '-' || *arg == ','))
 806       {
 807         end = arg;
 808         while (ASCII_ISALPHA(*end)
 809 --- 4752,4758 ----
 810         return;
 811       }
 812
 813 !     if (!(VIM_ISDIGIT(*arg) || *arg == '-' || *arg == ','))
 814       {
 815         end = arg;
 816         while (ASCII_ISALPHA(*end)
 817 *** ../vim-6.2.481/src/if_xcmdsrv.c     Thu Mar 25 19:25:28 2004
 818 --- src/if_xcmdsrv.c    Mon Apr 19 17:50:30 2004
 819 ***************
 820 *** 1198,1204 ****
 821                     case 'r':
 822                         end = skipwhite(p + 2);
 823                         resWindow = 0;
 824 !                       while (isxdigit(*end))
 825                         {
 826                             resWindow = 16 * resWindow + (long_u)hex2nr(*end);
 827                             ++end;
 828 --- 1198,1204 ----
 829                     case 'r':
 830                         end = skipwhite(p + 2);
 831                         resWindow = 0;
 832 !                       while (vim_isxdigit(*end))
 833                         {
 834                             resWindow = 16 * resWindow + (long_u)hex2nr(*end);
 835                             ++end;
 836 ***************
 837 *** 1436,1441 ****
 838   {
 839       int len = STRLEN(str);
 840
 841 !     return (len > 1 && isdigit(str[len - 1]));
 842   }
 843   #endif        /* FEAT_CLIENTSERVER */
 844 --- 1436,1441 ----
 845   {
 846       int len = STRLEN(str);
 847
 848 !     return (len > 1 && vim_isdigit(str[len - 1]));
 849   }
 850   #endif        /* FEAT_CLIENTSERVER */
 851 *** ../vim-6.2.481/src/farsi.c  Fri Feb 22 20:10:20 2002
 852 --- src/farsi.c Mon Apr 19 19:01:22 2004
 853 ***************
 854 *** 762,768 ****
 855       if (IS_SPECIAL(c))
 856         return c;
 857
 858 !     if (vim_isdigit(c) || ((c == '.' || c == '+' || c == '-' ||
 859         c == '^' || c == '%' || c == '#' || c == '=')  && revins))
 860       {
 861         if (!revins)
 862 --- 762,768 ----
 863       if (IS_SPECIAL(c))
 864         return c;
 865
 866 !     if (VIM_ISDIGIT(c) || ((c == '.' || c == '+' || c == '-' ||
 867         c == '^' || c == '%' || c == '#' || c == '=')  && revins))
 868       {
 869         if (!revins)
 870 *** ../vim-6.2.481/src/fileio.c Mon Apr 19 17:00:44 2004
 871 --- src/fileio.c        Mon Apr 19 19:01:43 2004
 872 ***************
 873 *** 4741,4747 ****
 874   get_win_fio_flags(ptr)
 875       char_u    *ptr;
 876   {
 877 !     if (ptr[0] == 'c' && ptr[1] == 'p' && isdigit(ptr[2]))
 878         return FIO_PUT_CP(atoi(ptr + 2)) | FIO_CODEPAGE;
 879       return 0;
 880   }
 881 --- 4754,4760 ----
 882   get_win_fio_flags(ptr)
 883       char_u    *ptr;
 884   {
 885 !     if (ptr[0] == 'c' && ptr[1] == 'p' && VIM_ISDIGIT(ptr[2]))
 886         return FIO_PUT_CP(atoi(ptr + 2)) | FIO_CODEPAGE;
 887       return 0;
 888   }
 889 *** ../vim-6.2.481/src/fold.c   Wed Apr 14 11:08:53 2004
 890 --- src/fold.c  Mon Apr 19 19:01:50 2004
 891 ***************
 892 *** 1874,1880 ****
 893         {
 894             /* Found the marker, include a digit if it's there. */
 895             len = markerlen;
 896 !           if (isdigit(p[len]))
 897                 ++len;
 898             if (*cms != NUL)
 899             {
 900 --- 1874,1880 ----
 901         {
 902             /* Found the marker, include a digit if it's there. */
 903             len = markerlen;
 904 !           if (VIM_ISDIGIT(p[len]))
 905                 ++len;
 906             if (*cms != NUL)
 907             {
 908 ***************
 909 *** 1950,1962 ****
 910         if (STRNCMP(s, curwin->w_p_fmr, foldstartmarkerlen) == 0)
 911         {
 912             len = foldstartmarkerlen;
 913 !           if (isdigit(s[len]))
 914                 ++len;
 915         }
 916         else if (STRNCMP(s, foldendmarker, foldendmarkerlen) == 0)
 917         {
 918             len = foldendmarkerlen;
 919 !           if (isdigit(s[len]))
 920                 ++len;
 921         }
 922         else if (cms_end != NULL)
 923 --- 1950,1962 ----
 924         if (STRNCMP(s, curwin->w_p_fmr, foldstartmarkerlen) == 0)
 925         {
 926             len = foldstartmarkerlen;
 927 !           if (VIM_ISDIGIT(s[len]))
 928                 ++len;
 929         }
 930         else if (STRNCMP(s, foldendmarker, foldendmarkerlen) == 0)
 931         {
 932             len = foldendmarkerlen;
 933 !           if (VIM_ISDIGIT(s[len]))
 934                 ++len;
 935         }
 936         else if (cms_end != NULL)
 937 ***************
 938 *** 3064,3070 ****
 939         {
 940             /* found startmarker: set flp->lvl */
 941             s += foldstartmarkerlen;
 942 !           if (isdigit(*s))
 943             {
 944                 n = atoi((char *)s);
 945                 if (n > 0)
 946 --- 3064,3070 ----
 947         {
 948             /* found startmarker: set flp->lvl */
 949             s += foldstartmarkerlen;
 950 !           if (VIM_ISDIGIT(*s))
 951             {
 952                 n = atoi((char *)s);
 953                 if (n > 0)
 954 ***************
 955 *** 3089,3095 ****
 956         {
 957             /* found endmarker: set flp->lvl_next */
 958             s += foldendmarkerlen;
 959 !           if (isdigit(*s))
 960             {
 961                 n = atoi((char *)s);
 962                 if (n > 0)
 963 --- 3089,3095 ----
 964         {
 965             /* found endmarker: set flp->lvl_next */
 966             s += foldendmarkerlen;
 967 !           if (VIM_ISDIGIT(*s))
 968             {
 969                 n = atoi((char *)s);
 970                 if (n > 0)
 971 *** ../vim-6.2.481/src/getchar.c        Sun Apr  4 12:10:13 2004
 972 --- src/getchar.c       Mon Apr 19 19:01:57 2004
 973 ***************
 974 *** 813,819 ****
 975       /* try to enter the count (in place of a previous count) */
 976       if (count)
 977       {
 978 !       while (isdigit(c))      /* skip "old" count */
 979             c = read_redo(FALSE, old_redo);
 980         add_num_buff(&stuffbuff, count);
 981       }
 982 --- 813,819 ----
 983       /* try to enter the count (in place of a previous count) */
 984       if (count)
 985       {
 986 !       while (VIM_ISDIGIT(c))  /* skip "old" count */
 987             c = read_redo(FALSE, old_redo);
 988         add_num_buff(&stuffbuff, count);
 989       }
 990 ***************
 991 *** 2083,2089 ****
 992                                 for (s = typebuf.tb_buf + typebuf.tb_off + 1;
 993                                         s < typebuf.tb_buf + typebuf.tb_off
 994                                                               + typebuf.tb_len
 995 !                                  && (isdigit(*s) || *s == ';' || *s == ' ');
 996                                         ++s)
 997                                     ;
 998                                 if (*s == 'r' || *s == '|') /* found one */
 999 --- 2083,2090 ----
1000                                 for (s = typebuf.tb_buf + typebuf.tb_off + 1;
1001                                         s < typebuf.tb_buf + typebuf.tb_off
1002                                                               + typebuf.tb_len
1003 !                                  && (VIM_ISDIGIT(*s) || *s == ';'
1004 !                                                               || *s == ' ');
1005                                         ++s)
1006                                     ;
1007                                 if (*s == 'r' || *s == '|') /* found one */
1008 *** ../vim-6.2.481/src/gui.c    Mon Apr 12 15:41:18 2004
1009 --- src/gui.c   Mon Apr 19 19:02:02 2004
1010 ***************
1011 *** 1499,1505 ****
1012         if (s[0] == ESC && s[1] == '|')
1013         {
1014             p = s + 2;
1015 !           if (isdigit(*p))
1016             {
1017                 arg1 = getdigits(&p);
1018                 if (p > s + len)
1019 --- 1499,1505 ----
1020         if (s[0] == ESC && s[1] == '|')
1021         {
1022             p = s + 2;
1023 !           if (VIM_ISDIGIT(*p))
1024             {
1025                 arg1 = getdigits(&p);
1026                 if (p > s + len)
1027 *** ../vim-6.2.481/src/if_cscope.c      Wed Apr 14 11:08:53 2004
1028 --- src/if_cscope.c     Mon Apr 19 19:02:28 2004
1029 ***************
1030 *** 1401,1408 ****
1031       }
1032
1033       /* only single digit positive and negative integers are allowed */
1034 !     if ((strlen(stok) < 2 && isdigit((int)(stok[0])))
1035 !           || (strlen(stok) < 3 && stok[0] == '-' && isdigit((int)(stok[1]))))
1036         i = atoi(stok);
1037       else
1038       {
1039 --- 1401,1409 ----
1040       }
1041
1042       /* only single digit positive and negative integers are allowed */
1043 !     if ((strlen(stok) < 2 && VIM_ISDIGIT((int)(stok[0])))
1044 !           || (strlen(stok) < 3 && stok[0] == '-'
1045 !                                             && VIM_ISDIGIT((int)(stok[1]))))
1046         i = atoi(stok);
1047       else
1048       {
1049 *** ../vim-6.2.481/src/macros.h Tue Apr  6 21:31:48 2004
1050 --- src/macros.h        Mon Apr 19 20:10:12 2004
1051 ***************
1052 *** 109,114 ****
1053 --- 109,120 ----
1054   # define ASCII_ISUPPER(c) ((c) < 0x7f && isupper(c))
1055   #endif
1056
1057 + /* Use our own isdigit() replacement, because on MS-Windows isdigit() returns
1058 +  * non-zero for superscript 1.  Also avoids that isdigit() crashes for numbers
1059 +  * below 0 and above 255.  For complicated arguments and in/decrement use
1060 +  * vim_isdigit() instead. */
1061 + #define VIM_ISDIGIT(c) ((c) >= '0' && (c) <= '9')
1062 +
1063   /* macro version of chartab().
1064    * Only works with values 0-255!
1065    * Doesn't work for UTF-8 mode with chars >= 0x80. */
1066 *** ../vim-6.2.481/src/main.c   Fri Apr 16 22:03:45 2004
1067 --- src/main.c  Mon Apr 19 17:50:59 2004
1068 ***************
1069 *** 809,815 ****
1070
1071             case 'w':           /* "-w{number}" set window height */
1072                                 /* "-w {scriptout}"     write to script */
1073 !               if (isdigit(((char_u *)argv[0])[argv_idx]))
1074                 {
1075                     argv_idx = -1;
1076                     break;                      /* not implemented, ignored */
1077 --- 809,815 ----
1078
1079             case 'w':           /* "-w{number}" set window height */
1080                                 /* "-w {scriptout}"     write to script */
1081 !               if (vim_isdigit(((char_u *)argv[0])[argv_idx]))
1082                 {
1083                     argv_idx = -1;
1084                     break;                      /* not implemented, ignored */
1085 ***************
1086 *** 2299,2308 ****
1087       int               *idx;       /* index in argument, is incremented */
1088       int               def;        /* default value */
1089   {
1090 !     if (isdigit(p[*idx]))
1091       {
1092         def = atoi((char *)&(p[*idx]));
1093 !       while (isdigit(p[*idx]))
1094             *idx = *idx + 1;
1095       }
1096       return def;
1097 --- 2299,2308 ----
1098       int               *idx;       /* index in argument, is incremented */
1099       int               def;        /* default value */
1100   {
1101 !     if (vim_isdigit(p[*idx]))
1102       {
1103         def = atoi((char *)&(p[*idx]));
1104 !       while (vim_isdigit(p[*idx]))
1105             *idx = *idx + 1;
1106       }
1107       return def;
1108 *** ../vim-6.2.481/src/mark.c   Tue Mar 30 22:19:53 2004
1109 --- src/mark.c  Mon Apr 19 19:02:37 2004
1110 ***************
1111 *** 371,379 ****
1112       {
1113         posp = &(curbuf->b_namedm[c - 'a']);
1114       }
1115 !     else if (ASCII_ISUPPER(c) || vim_isdigit(c))      /* named file mark */
1116       {
1117 !       if (vim_isdigit(c))
1118             c = c - '0' + NMARKS;
1119         else
1120             c -= 'A';
1121 --- 371,379 ----
1122       {
1123         posp = &(curbuf->b_namedm[c - 'a']);
1124       }
1125 !     else if (ASCII_ISUPPER(c) || VIM_ISDIGIT(c))      /* named file mark */
1126       {
1127 !       if (VIM_ISDIGIT(c))
1128             c = c - '0' + NMARKS;
1129         else
1130             c -= 'A';
1131 ***************
1132 *** 1220,1226 ****
1133   #ifndef EBCDIC
1134             *str <= 127 &&
1135   #endif
1136 !           ((*virp->vir_line == '\'' && (isdigit(*str) || isupper(*str)))
1137              || (*virp->vir_line == '-' && *str == '\'')))
1138       {
1139         if (*str == '\'')
1140 --- 1220,1226 ----
1141   #ifndef EBCDIC
1142             *str <= 127 &&
1143   #endif
1144 !           ((*virp->vir_line == '\'' && (VIM_ISDIGIT(*str) || isupper(*str)))
1145              || (*virp->vir_line == '-' && *str == '\'')))
1146       {
1147         if (*str == '\'')
1148 ***************
1149 *** 1243,1249 ****
1150             fm = NULL;
1151   #endif
1152         }
1153 !       else if (isdigit(*str))
1154             fm = &namedfm[*str - '0' + NMARKS];
1155         else
1156             fm = &namedfm[*str - 'A'];
1157 --- 1243,1249 ----
1158             fm = NULL;
1159   #endif
1160         }
1161 !       else if (VIM_ISDIGIT(*str))
1162             fm = &namedfm[*str - '0' + NMARKS];
1163         else
1164             fm = &namedfm[*str - 'A'];
1165 *** ../vim-6.2.481/src/mbyte.c  Wed Apr  7 10:52:49 2004
1166 --- src/mbyte.c Mon Apr 19 19:02:40 2004
1167 ***************
1168 *** 377,383 ****
1169       if (i >= 0)
1170         return enc_canon_table[i].prop;
1171   #ifdef WIN3264
1172 !     if (name[0] == 'c' && name[1] == 'p' && isdigit(name[2]))
1173       {
1174         CPINFO  cpinfo;
1175
1176 --- 377,383 ----
1177       if (i >= 0)
1178         return enc_canon_table[i].prop;
1179   #ifdef WIN3264
1180 !     if (name[0] == 'c' && name[1] == 'p' && VIM_ISDIGIT(name[2]))
1181       {
1182         CPINFO  cpinfo;
1183
1184 ***************
1185 *** 439,445 ****
1186       }
1187
1188   #ifdef WIN3264
1189 !     if (p_enc[0] == 'c' && p_enc[1] == 'p' && isdigit(p_enc[2]))
1190       {
1191         CPINFO  cpinfo;
1192
1193 --- 439,445 ----
1194       }
1195
1196   #ifdef WIN3264
1197 !     if (p_enc[0] == 'c' && p_enc[1] == 'p' && VIM_ISDIGIT(p_enc[2]))
1198       {
1199         CPINFO  cpinfo;
1200
1201 *** ../vim-6.2.481/src/menu.c   Mon Mar 22 20:54:36 2004
1202 --- src/menu.c  Mon Apr 19 19:02:44 2004
1203 ***************
1204 *** 164,170 ****
1205        * Fill in the priority table.
1206        */
1207       for (p = arg; *p; ++p)
1208 !       if (!isdigit(*p) && *p != '.')
1209             break;
1210       if (vim_iswhite(*p))
1211       {
1212 --- 164,170 ----
1213        * Fill in the priority table.
1214        */
1215       for (p = arg; *p; ++p)
1216 !       if (!VIM_ISDIGIT(*p) && *p != '.')
1217             break;
1218       if (vim_iswhite(*p))
1219       {
1220 ***************
1221 *** 1212,1218 ****
1222
1223       /* Check for priority numbers, enable and disable */
1224       for (p = arg; *p; ++p)
1225 !       if (!isdigit(*p) && *p != '.')
1226             break;
1227
1228       if (!vim_iswhite(*p))
1229 --- 1212,1218 ----
1230
1231       /* Check for priority numbers, enable and disable */
1232       for (p = arg; *p; ++p)
1233 !       if (!VIM_ISDIGIT(*p) && *p != '.')
1234             break;
1235
1236       if (!vim_iswhite(*p))
1237 *** ../vim-6.2.481/src/misc1.c  Mon Apr  5 20:28:39 2004
1238 --- src/misc1.c Mon Apr 19 19:02:56 2004
1239 ***************
1240 *** 396,402 ****
1241         return -1;
1242       line = ml_get(lnum);
1243       p = skipwhite(line);
1244 !     if (!isdigit(*p))
1245         return -1;
1246       p = skipdigits(p);
1247       if (vim_strchr((char_u *)":.)]}\t ", *p) == NULL)
1248 --- 396,402 ----
1249         return -1;
1250       line = ml_get(lnum);
1251       p = skipwhite(line);
1252 !     if (!VIM_ISDIGIT(*p))
1253         return -1;
1254       p = skipdigits(p);
1255       if (vim_strchr((char_u *)":.)]}\t ", *p) == NULL)
1256 ***************
1257 *** 983,989 ****
1258                     {
1259                         if (*p == COM_RIGHT || *p == COM_LEFT)
1260                             c = *p;
1261 !                       else if (isdigit(*p) || *p == '-')
1262                             off = getdigits(&p);
1263                     }
1264                     if (c == COM_RIGHT)    /* right adjusted leader */
1265 --- 983,989 ----
1266                     {
1267                         if (*p == COM_RIGHT || *p == COM_LEFT)
1268                             c = *p;
1269 !                       else if (VIM_ISDIGIT(*p) || *p == '-')
1270                             off = getdigits(&p);
1271                     }
1272                     if (c == COM_RIGHT)    /* right adjusted leader */
1273 ***************
1274 *** 2970,2976 ****
1275       {
1276         windgoto(msg_row, msg_col);
1277         c = safe_vgetc();
1278 !       if (vim_isdigit(c))
1279         {
1280             n = n * 10 + c - '0';
1281             msg_putchar(c);
1282 --- 2970,2976 ----
1283       {
1284         windgoto(msg_row, msg_col);
1285         c = safe_vgetc();
1286 !       if (VIM_ISDIGIT(c))
1287         {
1288             n = n * 10 + c - '0';
1289             msg_putchar(c);
1290 ***************
1291 *** 4290,4296 ****
1292             if (p[1] == '\\')               /* '\n' or '\000' */
1293             {
1294                 ++i;
1295 !               while (isdigit(p[i - 1]))   /* '\000' */
1296                     ++i;
1297             }
1298             if (p[i] == '\'')               /* check for trailing ' */
1299 --- 4290,4296 ----
1300             if (p[1] == '\\')               /* '\n' or '\000' */
1301             {
1302                 ++i;
1303 !               while (vim_isdigit(p[i - 1]))   /* '\000' */
1304                     ++i;
1305             }
1306             if (p[i] == '\'')               /* check for trailing ' */
1307 ***************
1308 *** 5165,5171 ****
1309         if (*options == '.')        /* ".5s" means a fraction */
1310         {
1311             fraction = atol((char *)++options);
1312 !           while (isdigit(*options))
1313             {
1314                 ++options;
1315                 if (divider)
1316 --- 5283,5289 ----
1317         if (*options == '.')        /* ".5s" means a fraction */
1318         {
1319             fraction = atol((char *)++options);
1320 !           while (VIM_ISDIGIT(*options))
1321             {
1322                 ++options;
1323                 if (divider)
1324 ***************
1325 *** 5311,5317 ****
1326                     what = *p++;
1327                 else if (*p == COM_LEFT || *p == COM_RIGHT)
1328                     align = *p++;
1329 !               else if (isdigit(*p) || *p == '-')
1330                     off = getdigits(&p);
1331                 else
1332                     ++p;
1333 --- 5431,5437 ----
1334                     what = *p++;
1335                 else if (*p == COM_LEFT || *p == COM_RIGHT)
1336                     align = *p++;
1337 !               else if (VIM_ISDIGIT(*p) || *p == '-')
1338                     off = getdigits(&p);
1339                 else
1340                     ++p;
1341 *** ../vim-6.2.481/src/misc2.c  Fri Apr 16 21:10:08 2004
1342 --- src/misc2.c Mon Apr 19 19:03:02 2004
1343 ***************
1344 *** 2215,2221 ****
1345       {
1346         end_of_name = bp + 1;
1347
1348 !       if (STRNICMP(src + 1, "char-", 5) == 0 && isdigit(src[6]))
1349         {
1350             /* <Char-123> or <Char-033> or <Char-0x33> */
1351             vim_str2nr(src + 6, NULL, NULL, TRUE, TRUE, NULL, &n);
1352 --- 2215,2221 ----
1353       {
1354         end_of_name = bp + 1;
1355
1356 !       if (STRNICMP(src + 1, "char-", 5) == 0 && VIM_ISDIGIT(src[6]))
1357         {
1358             /* <Char-123> or <Char-033> or <Char-0x33> */
1359             vim_str2nr(src + 6, NULL, NULL, TRUE, TRUE, NULL, &n);
1360 ***************
1361 *** 2866,2872 ****
1362                         {
1363                             if (mshape_names[i] == NULL)
1364                             {
1365 !                               if (!isdigit(*p))
1366                                     return (char_u *)N_("E547: Illegal mouseshape");
1367                                 if (round == 2)
1368                                     shape_table[idx].mshape =
1369 --- 2866,2872 ----
1370                         {
1371                             if (mshape_names[i] == NULL)
1372                             {
1373 !                               if (!VIM_ISDIGIT(*p))
1374                                     return (char_u *)N_("E547: Illegal mouseshape");
1375                                 if (round == 2)
1376                                     shape_table[idx].mshape =
1377 ***************
1378 *** 2906,2912 ****
1379                         if (len != 0)
1380                         {
1381                             p += len;
1382 !                           if (!isdigit(*p))
1383                                 return (char_u *)N_("E548: digit expected");
1384                             n = getdigits(&p);
1385                             if (len == 3)   /* "ver" or "hor" */
1386 --- 2906,2912 ----
1387                         if (len != 0)
1388                         {
1389                             p += len;
1390 !                           if (!VIM_ISDIGIT(*p))
1391                                 return (char_u *)N_("E548: digit expected");
1392                             n = getdigits(&p);
1393                             if (len == 3)   /* "ver" or "hor" */
1394 ***************
1395 *** 5326,5332 ****
1396
1397         if (table[idx].hasnum)
1398         {
1399 !           if (!isdigit(*p))
1400                 return (char_u *)N_("E552: digit expected");
1401
1402             table[idx].number = getdigits(&p); /*advances p*/
1403 --- 5342,5348 ----
1404
1405         if (table[idx].hasnum)
1406         {
1407 !           if (!VIM_ISDIGIT(*p))
1408                 return (char_u *)N_("E552: digit expected");
1409
1410             table[idx].number = getdigits(&p); /*advances p*/
1411 *** ../vim-6.2.481/src/normal.c Thu Apr  8 12:29:56 2004
1412 --- src/normal.c        Mon Apr 19 19:03:06 2004
1413 ***************
1414 *** 4259,4266 ****
1415       int               old_fen = curwin->w_p_fen;
1416   #endif
1417
1418 !     if (vim_isdigit(nchar))
1419       {
1420         if (checkclearop(cap->oap))
1421             return;
1422         n = nchar - '0';
1423 --- 4259,4269 ----
1424       int               old_fen = curwin->w_p_fen;
1425   #endif
1426
1427 !     if (VIM_ISDIGIT(nchar))
1428       {
1429 +       /*
1430 +        * "z123{nchar}": edit the count before obtaining {nchar}
1431 +        */
1432         if (checkclearop(cap->oap))
1433             return;
1434         n = nchar - '0';
1435 ***************
1436 *** 4282,4288 ****
1437   #endif
1438             if (nchar == K_DEL || nchar == K_KDEL)
1439                 n /= 10;
1440 !           else if (vim_isdigit(nchar))
1441                 n = n * 10 + (nchar - '0');
1442             else if (nchar == CAR)
1443             {
1444 --- 4285,4291 ----
1445   #endif
1446             if (nchar == K_DEL || nchar == K_KDEL)
1447                 n /= 10;
1448 !           else if (VIM_ISDIGIT(nchar))
1449                 n = n * 10 + (nchar - '0');
1450             else if (nchar == CAR)
1451             {
1452 ***************
1453 *** 8355,8361 ****
1454   # ifdef FEAT_CLIPBOARD
1455             adjust_clip_reg(&regname);
1456   # endif
1457 !           if (regname == 0 || isdigit(regname)
1458   # ifdef FEAT_CLIPBOARD
1459                     || (clip_unnamed && (regname == '*' || regname == '+'))
1460   # endif
1461 --- 8390,8396 ----
1462   # ifdef FEAT_CLIPBOARD
1463             adjust_clip_reg(&regname);
1464   # endif
1465 !           if (regname == 0 || VIM_ISDIGIT(regname)
1466   # ifdef FEAT_CLIPBOARD
1467                     || (clip_unnamed && (regname == '*' || regname == '+'))
1468   # endif
1469 *** ../vim-6.2.481/src/ops.c    Sun Apr  4 12:34:29 2004
1470 --- src/ops.c   Mon Apr 19 19:03:09 2004
1471 ***************
1472 *** 833,839 ****
1473         return;
1474       }
1475       i = regname;
1476 !     if (isdigit(i))
1477         i -= '0';
1478       else if (ASCII_ISLOWER(i))
1479         i = CharOrdLow(i) + 10;
1480 --- 833,839 ----
1481         return;
1482       }
1483       i = regname;
1484 !     if (VIM_ISDIGIT(i))
1485         i -= '0';
1486       else if (ASCII_ISLOWER(i))
1487         i = CharOrdLow(i) + 10;
1488 ***************
1489 *** 4627,4633 ****
1490                 {
1491                     bdp->endspaces = incr - bdp->endspaces;
1492                     if (pend != pstart)
1493 !                   pend = prev_pend;
1494                 }
1495             }
1496         }
1497 --- 4672,4678 ----
1498                 {
1499                     bdp->endspaces = incr - bdp->endspaces;
1500                     if (pend != pstart)
1501 !                       pend = prev_pend;
1502                 }
1503             }
1504         }
1505 ***************
1506 *** 4709,4722 ****
1507        */
1508       col = curwin->w_cursor.col;
1509       if (dohex)
1510 !       while (col > 0 && isxdigit(ptr[col]))
1511             --col;
1512       if (       dohex
1513             && col > 0
1514             && (ptr[col] == 'X'
1515                 || ptr[col] == 'x')
1516             && ptr[col - 1] == '0'
1517 !           && isxdigit(ptr[col + 1]))
1518       {
1519         /*
1520          * Found hexadecimal number, move to its start.
1521 --- 4754,4767 ----
1522        */
1523       col = curwin->w_cursor.col;
1524       if (dohex)
1525 !       while (col > 0 && vim_isxdigit(ptr[col]))
1526             --col;
1527       if (       dohex
1528             && col > 0
1529             && (ptr[col] == 'X'
1530                 || ptr[col] == 'x')
1531             && ptr[col - 1] == '0'
1532 !           && vim_isxdigit(ptr[col + 1]))
1533       {
1534         /*
1535          * Found hexadecimal number, move to its start.
1536 ***************
1537 *** 4731,4742 ****
1538         col = curwin->w_cursor.col;
1539
1540         while (ptr[col] != NUL
1541 !               && !isdigit(ptr[col])
1542                 && !(doalp && ASCII_ISALPHA(ptr[col])))
1543             ++col;
1544
1545         while (col > 0
1546 !               && isdigit(ptr[col - 1])
1547                 && !(doalp && ASCII_ISALPHA(ptr[col])))
1548             --col;
1549       }
1550 --- 4776,4787 ----
1551         col = curwin->w_cursor.col;
1552
1553         while (ptr[col] != NUL
1554 !               && !vim_isdigit(ptr[col])
1555                 && !(doalp && ASCII_ISALPHA(ptr[col])))
1556             ++col;
1557
1558         while (col > 0
1559 !               && vim_isdigit(ptr[col - 1])
1560                 && !(doalp && ASCII_ISALPHA(ptr[col])))
1561             --col;
1562       }
1563 ***************
1564 *** 4750,4756 ****
1565        */
1566       firstdigit = ptr[col];
1567       RLADDSUBFIX(ptr);
1568 !     if ((!isdigit(firstdigit) && !(doalp && ASCII_ISALPHA(firstdigit)))
1569             || u_save_cursor() != OK)
1570       {
1571         beep_flush();
1572 --- 4795,4801 ----
1573        */
1574       firstdigit = ptr[col];
1575       RLADDSUBFIX(ptr);
1576 !     if ((!VIM_ISDIGIT(firstdigit) && !(doalp && ASCII_ISALPHA(firstdigit)))
1577             || u_save_cursor() != OK)
1578       {
1579         beep_flush();
1580 *** ../vim-6.2.481/src/option.c Mon Apr 19 17:00:44 2004
1581 --- src/option.c        Mon Apr 19 19:03:26 2004
1582 ***************
1583 *** 3626,3632 ****
1584                                 && (*arg == '<'
1585                                     || *arg == '^'
1586                                     || ((!arg[1] || vim_iswhite(arg[1]))
1587 !                                       && !isdigit(*arg))))
1588                         {
1589                             value = string_to_key(arg);
1590                             if (value == 0 && (long *)varp != &p_wcm)
1591 --- 3638,3644 ----
1592                                 && (*arg == '<'
1593                                     || *arg == '^'
1594                                     || ((!arg[1] || vim_iswhite(arg[1]))
1595 !                                       && !VIM_ISDIGIT(*arg))))
1596                         {
1597                             value = string_to_key(arg);
1598                             if (value == 0 && (long *)varp != &p_wcm)
1599 ***************
1600 *** 3636,3642 ****
1601                             }
1602                         }
1603                                 /* allow negative numbers (for 'undolevels') */
1604 !                       else if (*arg == '-' || isdigit(*arg))
1605                         {
1606                             i = 0;
1607                             if (*arg == '-')
1608 --- 3648,3654 ----
1609                             }
1610                         }
1611                                 /* allow negative numbers (for 'undolevels') */
1612 !                       else if (*arg == '-' || VIM_ISDIGIT(*arg))
1613                         {
1614                             i = 0;
1615                             if (*arg == '-')
1616 ***************
1617 *** 3648,3654 ****
1618   #else
1619                             value = atol((char *)arg);
1620   #endif
1621 !                           while (isdigit(arg[i]))
1622                                 ++i;
1623                             if (arg[i] != NUL && !vim_iswhite(arg[i]))
1624                             {
1625 --- 3660,3666 ----
1626   #else
1627                             value = atol((char *)arg);
1628   #endif
1629 !                           while (VIM_ISDIGIT(arg[i]))
1630                                 ++i;
1631                             if (arg[i] != NUL && !vim_iswhite(arg[i]))
1632                             {
1633 ***************
1634 *** 3753,3759 ****
1635                              * backwards compatibility with Vim 3.0.
1636                              * Misuse errbuf[] for the resulting string.
1637                              */
1638 !                           else if (varp == (char_u *)&p_ww && isdigit(*arg))
1639                             {
1640                                 *errbuf = NUL;
1641                                 i = getdigits(&arg);
1642 --- 3765,3772 ----
1643                              * backwards compatibility with Vim 3.0.
1644                              * Misuse errbuf[] for the resulting string.
1645                              */
1646 !                           else if (varp == (char_u *)&p_ww
1647 !                                                        && VIM_ISDIGIT(*arg))
1648                             {
1649                                 *errbuf = NUL;
1650                                 i = getdigits(&arg);
1651 ***************
1652 *** 4217,4223 ****
1653       char_u  *p;
1654
1655       p = find_viminfo_parameter(type);
1656 !     if (p != NULL && isdigit(*p))
1657         return atoi((char *)p);
1658       return -1;
1659   }
1660 --- 4230,4236 ----
1661       char_u  *p;
1662
1663       p = find_viminfo_parameter(type);
1664 !     if (p != NULL && VIM_ISDIGIT(*p))
1665         return atoi((char *)p);
1666       return -1;
1667   }
1668 ***************
1669 *** 5004,5010 ****
1670             while (*s && *s != ':')
1671             {
1672                 if (vim_strchr((char_u *)COM_ALL, *s) == NULL
1673 !                                                && !isdigit(*s) && *s != '-')
1674                 {
1675                     errmsg = illegal_char(errbuf, *s);
1676                     break;
1677 --- 5017,5023 ----
1678             while (*s && *s != ':')
1679             {
1680                 if (vim_strchr((char_u *)COM_ALL, *s) == NULL
1681 !                                            && !VIM_ISDIGIT(*s) && *s != '-')
1682                 {
1683                     errmsg = illegal_char(errbuf, *s);
1684                     break;
1685 ***************
1686 *** 5075,5084 ****
1687                 ++s;            /* no extra chars */
1688             else                /* must have a number */
1689             {
1690 !               while (isdigit(*++s))
1691                     ;
1692
1693 !               if (!isdigit(*(s - 1)))
1694                 {
1695                     if (errbuf != NULL)
1696                     {
1697 --- 5088,5097 ----
1698                 ++s;            /* no extra chars */
1699             else                /* must have a number */
1700             {
1701 !               while (vim_isdigit(*++s))
1702                     ;
1703
1704 !               if (!VIM_ISDIGIT(*(s - 1)))
1705                 {
1706                     if (errbuf != NULL)
1707                     {
1708 ***************
1709 *** 5545,5551 ****
1710       /* 'backspace' */
1711       else if (varp == &p_bs)
1712       {
1713 !       if (isdigit(*p_bs))
1714         {
1715             if (*p_bs >'2' || p_bs[1] != NUL)
1716                 errmsg = e_invarg;
1717 --- 5558,5564 ----
1718       /* 'backspace' */
1719       else if (varp == &p_bs)
1720       {
1721 !       if (VIM_ISDIGIT(*p_bs))
1722         {
1723             if (*p_bs >'2' || p_bs[1] != NUL)
1724                 errmsg = e_invarg;
1725 ***************
1726 *** 5918,5931 ****
1727         }
1728         if (*s == '-')
1729             s++;
1730 !       while (isdigit(*s))
1731             s++;
1732         if (*s == STL_HIGHLIGHT)
1733             continue;
1734         if (*s == '.')
1735         {
1736             s++;
1737 !           while (*s && isdigit(*s))
1738                 s++;
1739         }
1740         if (*s == '(')
1741 --- 5931,5944 ----
1742         }
1743         if (*s == '-')
1744             s++;
1745 !       while (VIM_ISDIGIT(*s))
1746             s++;
1747         if (*s == STL_HIGHLIGHT)
1748             continue;
1749         if (*s == '.')
1750         {
1751             s++;
1752 !           while (*s && VIM_ISDIGIT(*s))
1753                 s++;
1754         }
1755         if (*s == '(')
1756 *** ../vim-6.2.481/src/proto/charset.pro        Sun Jun  1 12:26:05 2003
1757 --- src/proto/charset.pro       Mon Apr 19 19:00:00 2004
1758 ***************
1759 *** 33,38 ****
1760 --- 33,39 ----
1761   char_u *skipwhite __ARGS((char_u *p));
1762   char_u *skipdigits __ARGS((char_u *p));
1763   int vim_isdigit __ARGS((int c));
1764 + int vim_isxdigit __ARGS((int c));
1765   char_u *skiptowhite __ARGS((char_u *p));
1766   char_u *skiptowhite_esc __ARGS((char_u *p));
1767   long getdigits __ARGS((char_u **pp));
1768 *** ../vim-6.2.481/src/regexp.c Wed Apr 14 11:08:53 2004
1769 --- src/regexp.c        Mon Apr 19 19:04:33 2004
1770 ***************
1771 *** 1723,1729 ****
1772                           }
1773
1774                 default:
1775 !                         if (isdigit(c) || c == '<' || c == '>')
1776                           {
1777                               long_u    n = 0;
1778                               int       cmp;
1779 --- 1723,1729 ----
1780                           }
1781
1782                 default:
1783 !                         if (VIM_ISDIGIT(c) || c == '<' || c == '>')
1784                           {
1785                               long_u    n = 0;
1786                               int       cmp;
1787 ***************
1788 *** 1731,1737 ****
1789                               cmp = c;
1790                               if (cmp == '<' || cmp == '>')
1791                                   c = getchr();
1792 !                             while (isdigit(c))
1793                               {
1794                                   n = n * 10 + (c - '0');
1795                                   c = getchr();
1796 --- 1731,1737 ----
1797                               cmp = c;
1798                               if (cmp == '<' || cmp == '>')
1799                                   c = getchr();
1800 !                             while (VIM_ISDIGIT(c))
1801                               {
1802                                   n = n * 10 + (c - '0');
1803                                   c = getchr();
1804 ***************
1805 *** 1917,1923 ****
1806                                 break;
1807                             case CLASS_DIGIT:
1808                                 for (cu = 1; cu <= 255; cu++)
1809 !                                   if (isdigit(cu))
1810                                         regc(cu);
1811                                 break;
1812                             case CLASS_GRAPH:
1813 --- 1917,1923 ----
1814                                 break;
1815                             case CLASS_DIGIT:
1816                                 for (cu = 1; cu <= 255; cu++)
1817 !                                   if (VIM_ISDIGIT(cu))
1818                                         regc(cu);
1819                                 break;
1820                             case CLASS_GRAPH:
1821 ***************
1822 *** 1952,1958 ****
1823                                 break;
1824                             case CLASS_XDIGIT:
1825                                 for (cu = 1; cu <= 255; cu++)
1826 !                                   if (isxdigit(cu))
1827                                         regc(cu);
1828                                 break;
1829                             case CLASS_TAB:
1830 --- 1952,1958 ----
1831                                 break;
1832                             case CLASS_XDIGIT:
1833                                 for (cu = 1; cu <= 255; cu++)
1834 !                                   if (vim_isxdigit(cu))
1835                                         regc(cu);
1836                                 break;
1837                             case CLASS_TAB:
1838 ***************
1839 *** 2541,2552 ****
1840       *minval = getdigits(&regparse);
1841       if (*regparse == ',')         /* There is a comma */
1842       {
1843 !       if (isdigit(*++regparse))
1844             *maxval = getdigits(&regparse);
1845         else
1846             *maxval = MAX_LIMIT;
1847       }
1848 !     else if (isdigit(*first_char))
1849         *maxval = *minval;          /* It was \{n} or \{-n} */
1850       else
1851         *maxval = MAX_LIMIT;        /* It was \{} or \{-} */
1852 --- 2541,2552 ----
1853       *minval = getdigits(&regparse);
1854       if (*regparse == ',')         /* There is a comma */
1855       {
1856 !       if (vim_isdigit(*++regparse))
1857             *maxval = getdigits(&regparse);
1858         else
1859             *maxval = MAX_LIMIT;
1860       }
1861 !     else if (VIM_ISDIGIT(*first_char))
1862         *maxval = *minval;          /* It was \{n} or \{-n} */
1863       else
1864         *maxval = MAX_LIMIT;        /* It was \{} or \{-} */
1865 ***************
1866 *** 3405,3411 ****
1867             break;
1868
1869           case SIDENT:
1870 !           if (isdigit(*reginput) || !vim_isIDc(c))
1871                 return FALSE;
1872             ADVANCE_REGINPUT();
1873             break;
1874 --- 3405,3411 ----
1875             break;
1876
1877           case SIDENT:
1878 !           if (VIM_ISDIGIT(*reginput) || !vim_isIDc(c))
1879                 return FALSE;
1880             ADVANCE_REGINPUT();
1881             break;
1882 ***************
1883 *** 3417,3423 ****
1884             break;
1885
1886           case SKWORD:
1887 !           if (isdigit(*reginput) || !vim_iswordp(reginput))
1888                 return FALSE;
1889             ADVANCE_REGINPUT();
1890             break;
1891 --- 3417,3423 ----
1892             break;
1893
1894           case SKWORD:
1895 !           if (VIM_ISDIGIT(*reginput) || !vim_iswordp(reginput))
1896                 return FALSE;
1897             ADVANCE_REGINPUT();
1898             break;
1899 ***************
1900 *** 3429,3435 ****
1901             break;
1902
1903           case SFNAME:
1904 !           if (isdigit(*reginput) || !vim_isfilec(c))
1905                 return FALSE;
1906             ADVANCE_REGINPUT();
1907             break;
1908 --- 3429,3435 ----
1909             break;
1910
1911           case SFNAME:
1912 !           if (VIM_ISDIGIT(*reginput) || !vim_isfilec(c))
1913                 return FALSE;
1914             ADVANCE_REGINPUT();
1915             break;
1916 ***************
1917 *** 3441,3447 ****
1918             break;
1919
1920           case SPRINT:
1921 !           if (isdigit(*reginput) || ptr2cells(reginput) != 1)
1922                 return FALSE;
1923             ADVANCE_REGINPUT();
1924             break;
1925 --- 3441,3447 ----
1926             break;
1927
1928           case SPRINT:
1929 !           if (VIM_ISDIGIT(*reginput) || ptr2cells(reginput) != 1)
1930                 return FALSE;
1931             ADVANCE_REGINPUT();
1932             break;
1933 ***************
1934 *** 4339,4345 ****
1935         case SIDENT + ADD_NL:
1936         while (count < maxcount)
1937         {
1938 !           if (vim_isIDc(*scan) && (testval || !isdigit(*scan)))
1939             {
1940                 ADVANCE_P(scan);
1941             }
1942 --- 4339,4345 ----
1943         case SIDENT + ADD_NL:
1944         while (count < maxcount)
1945         {
1946 !           if (vim_isIDc(*scan) && (testval || !VIM_ISDIGIT(*scan)))
1947             {
1948                 ADVANCE_P(scan);
1949             }
1950 ***************
1951 *** 4368,4374 ****
1952         case SKWORD + ADD_NL:
1953         while (count < maxcount)
1954         {
1955 !           if (vim_iswordp(scan) && (testval || !isdigit(*scan)))
1956             {
1957                 ADVANCE_P(scan);
1958             }
1959 --- 4368,4374 ----
1960         case SKWORD + ADD_NL:
1961         while (count < maxcount)
1962         {
1963 !           if (vim_iswordp(scan) && (testval || !VIM_ISDIGIT(*scan)))
1964             {
1965                 ADVANCE_P(scan);
1966             }
1967 ***************
1968 *** 4397,4403 ****
1969         case SFNAME + ADD_NL:
1970         while (count < maxcount)
1971         {
1972 !           if (vim_isfilec(*scan) && (testval || !isdigit(*scan)))
1973             {
1974                 ADVANCE_P(scan);
1975             }
1976 --- 4397,4403 ----
1977         case SFNAME + ADD_NL:
1978         while (count < maxcount)
1979         {
1980 !           if (vim_isfilec(*scan) && (testval || !VIM_ISDIGIT(*scan)))
1981             {
1982                 ADVANCE_P(scan);
1983             }
1984 ***************
1985 *** 4435,4441 ****
1986                 if (got_int)
1987                     break;
1988             }
1989 !           else if (ptr2cells(scan) == 1 && (testval || !isdigit(*scan)))
1990             {
1991                 ADVANCE_P(scan);
1992             }
1993 --- 4435,4441 ----
1994                 if (got_int)
1995                     break;
1996             }
1997 !           else if (ptr2cells(scan) == 1 && (testval || !VIM_ISDIGIT(*scan)))
1998             {
1999                 ADVANCE_P(scan);
2000             }
2001 *** ../vim-6.2.481/src/screen.c Mon Apr  5 21:24:08 2004
2002 --- src/screen.c        Mon Apr 19 19:04:36 2004
2003 ***************
2004 *** 5253,5259 ****
2005             if (*++p == '-')
2006                 p++;
2007             if (atoi((char *) p))
2008 !               while (isdigit(*p))
2009                     p++;
2010             if (*p++ != '(')
2011                 p = p_ruf;
2012 --- 5253,5259 ----
2013             if (*++p == '-')
2014                 p++;
2015             if (atoi((char *) p))
2016 !               while (VIM_ISDIGIT(*p))
2017                     p++;
2018             if (*p++ != '(')
2019                 p = p_ruf;
2020 *** ../vim-6.2.481/src/search.c Fri Apr  9 19:30:09 2004
2021 --- src/search.c        Mon Apr 19 19:04:47 2004
2022 ***************
2023 *** 1038,1044 ****
2024              * offset, because it is meaningless and the 's' could be a
2025              * substitute command.
2026              */
2027 !           if (*p == '+' || *p == '-' || isdigit(*p))
2028                 spats[0].off.line = TRUE;
2029             else if ((options & SEARCH_OPT) &&
2030                                         (*p == 'e' || *p == 's' || *p == 'b'))
2031 --- 1038,1044 ----
2032              * offset, because it is meaningless and the 's' could be a
2033              * substitute command.
2034              */
2035 !           if (*p == '+' || *p == '-' || VIM_ISDIGIT(*p))
2036                 spats[0].off.line = TRUE;
2037             else if ((options & SEARCH_OPT) &&
2038                                         (*p == 'e' || *p == 's' || *p == 'b'))
2039 ***************
2040 *** 1047,1063 ****
2041                     spats[0].off.end = SEARCH_END;
2042                 ++p;
2043             }
2044 !           if (isdigit(*p) || *p == '+' || *p == '-')     /* got an offset */
2045             {
2046                                             /* 'nr' or '+nr' or '-nr' */
2047 !               if (isdigit(*p) || isdigit(*(p + 1)))
2048                     spats[0].off.off = atol((char *)p);
2049                 else if (*p == '-')         /* single '-' */
2050                     spats[0].off.off = -1;
2051                 else                        /* single '+' */
2052                     spats[0].off.off = 1;
2053                 ++p;
2054 !               while (isdigit(*p))         /* skip number */
2055                     ++p;
2056             }
2057
2058 --- 1047,1063 ----
2059                     spats[0].off.end = SEARCH_END;
2060                 ++p;
2061             }
2062 !           if (VIM_ISDIGIT(*p) || *p == '+' || *p == '-')  /* got an offset */
2063             {
2064                                             /* 'nr' or '+nr' or '-nr' */
2065 !               if (VIM_ISDIGIT(*p) || VIM_ISDIGIT(*(p + 1)))
2066                     spats[0].off.off = atol((char *)p);
2067                 else if (*p == '-')         /* single '-' */
2068                     spats[0].off.off = -1;
2069                 else                        /* single '+' */
2070                     spats[0].off.off = 1;
2071                 ++p;
2072 !               while (VIM_ISDIGIT(*p))     /* skip number */
2073                     ++p;
2074             }
2075
2076 *** ../vim-6.2.481/src/syntax.c Thu Apr  1 15:42:48 2004
2077 --- src/syntax.c        Mon Apr 19 19:04:54 2004
2078 ***************
2079 *** 5274,5280 ****
2080                 arg_end = key + 11;
2081             else
2082                 arg_end = key + 9;
2083 !           if (arg_end[-1] != '=' || !isdigit(*arg_end))
2084             {
2085                 illegal = TRUE;
2086                 break;
2087 --- 5274,5280 ----
2088                 arg_end = key + 11;
2089             else
2090                 arg_end = key + 9;
2091 !           if (arg_end[-1] != '=' || !VIM_ISDIGIT(*arg_end))
2092             {
2093                 illegal = TRUE;
2094                 break;
2095 ***************
2096 *** 6523,6529 ****
2097                 HL_TABLE()[idx].sg_cterm_bold = FALSE;
2098             }
2099
2100 !           if (isdigit(*arg))
2101                 color = atoi((char *)arg);
2102             else if (STRICMP(arg, "fg") == 0)
2103             {
2104 --- 6523,6529 ----
2105                 HL_TABLE()[idx].sg_cterm_bold = FALSE;
2106             }
2107
2108 !           if (VIM_ISDIGIT(*arg))
2109                 color = atoi((char *)arg);
2110             else if (STRICMP(arg, "fg") == 0)
2111             {
2112 *** ../vim-6.2.481/src/tag.c    Thu Apr 15 20:45:41 2004
2113 --- src/tag.c   Mon Apr 19 19:05:04 2004
2114 ***************
2115 *** 2414,2420 ****
2116         else
2117             ++p;
2118
2119 !       if (!isdigit(*p))           /* check for start of line number */
2120             return FAIL;
2121         tagp->command = p;
2122
2123 --- 2414,2420 ----
2124         else
2125             ++p;
2126
2127 !       if (!VIM_ISDIGIT(*p))       /* check for start of line number */
2128             return FAIL;
2129         tagp->command = p;
2130
2131 ***************
2132 *** 3347,3353 ****
2133       /* Repeat for addresses separated with ';' */
2134       for (;;)
2135       {
2136 !       if (isdigit(*str))
2137             str = skipdigits(str);
2138         else if (*str == '/' || *str == '?')
2139         {
2140 --- 3347,3353 ----
2141       /* Repeat for addresses separated with ';' */
2142       for (;;)
2143       {
2144 !       if (VIM_ISDIGIT(*str))
2145             str = skipdigits(str);
2146         else if (*str == '/' || *str == '?')
2147         {
2148 ***************
2149 *** 3360,3366 ****
2150         else
2151             str = NULL;
2152         if (str == NULL || *str != ';'
2153 !                     || !(isdigit(str[1]) || str[1] == '/' || str[1] == '?'))
2154             break;
2155         ++str;  /* skip ';' */
2156       }
2157 --- 3360,3366 ----
2158         else
2159             str = NULL;
2160         if (str == NULL || *str != ';'
2161 !                 || !(VIM_ISDIGIT(str[1]) || str[1] == '/' || str[1] == '?'))
2162             break;
2163         ++str;  /* skip ';' */
2164       }
2165 *** ../vim-6.2.481/src/term.c   Tue Mar 30 21:49:18 2004
2166 --- src/term.c  Mon Apr 19 19:05:20 2004
2167 ***************
2168 *** 3806,3812 ****
2169                      * key code.
2170                      */
2171                     if (termcodes[idx].name[0] == 'K'
2172 !                                          && isdigit(termcodes[idx].name[1]))
2173                     {
2174                         for (j = idx + 1; j < tc_len; ++j)
2175                             if (termcodes[j].len == slen &&
2176 --- 3806,3812 ----
2177                      * key code.
2178                      */
2179                     if (termcodes[idx].name[0] == 'K'
2180 !                                      && VIM_ISDIGIT(termcodes[idx].name[1]))
2181                     {
2182                         for (j = idx + 1; j < tc_len; ++j)
2183                             if (termcodes[j].len == slen &&
2184 ***************
2185 *** 3838,3844 ****
2186                 j = 0;
2187                 extra = 0;
2188                 for (i = 2 + (tp[0] != CSI);
2189 !                       i < len && (isdigit(tp[i])
2190                             || tp[i] == ';' || tp[i] == '.'); ++i)
2191                     if (tp[i] == ';' && ++j == 1)
2192                         extra = atoi((char *)tp + i + 1);
2193 --- 3838,3844 ----
2194                 j = 0;
2195                 extra = 0;
2196                 for (i = 2 + (tp[0] != CSI);
2197 !                       i < len && (VIM_ISDIGIT(tp[i])
2198                             || tp[i] == ';' || tp[i] == '.'); ++i)
2199                     if (tp[i] == ';' && ++j == 1)
2200                         extra = atoi((char *)tp + i + 1);
2201 ***************
2202 *** 4724,4730 ****
2203       /*
2204        * Check for #n at start only: function key n
2205        */
2206 !     if (from_part && src[0] == '#' && isdigit(src[1]))            /* function key */
2207       {
2208         result[dlen++] = K_SPECIAL;
2209         result[dlen++] = 'k';
2210 --- 4724,4730 ----
2211       /*
2212        * Check for #n at start only: function key n
2213        */
2214 !     if (from_part && src[0] == '#' && VIM_ISDIGIT(src[1]))  /* function key */
2215       {
2216         result[dlen++] = K_SPECIAL;
2217         result[dlen++] = 'k';
2218 *** ../vim-6.2.481/src/termlib.c        Sat Jul 26 21:25:27 2003
2219 --- src/termlib.c       Mon Apr 19 19:05:31 2004
2220 ***************
2221 *** 335,341 ****
2222                     case '9':
2223                         **buf = 0;
2224                             /* get up to three digits */
2225 !                       for (i = 0; i < 3 && isdigit(*tmp); ++i)
2226                             **buf = **buf * 8 + *tmp++ - '0';
2227                         (*buf)++;
2228                         tmp--;
2229 --- 335,341 ----
2230                     case '9':
2231                         **buf = 0;
2232                             /* get up to three digits */
2233 !                       for (i = 0; i < 3 && VIM_ISDIGIT(*tmp); ++i)
2234                             **buf = **buf * 8 + *tmp++ - '0';
2235                         (*buf)++;
2236                         tmp--;
2237 ***************
2238 *** 480,486 ****
2239       if (addup)                                        /* add upline */
2240         if (UP) {
2241             ptr=UP;
2242 !           while (isdigit(*ptr) || *ptr == '.')
2243                 ptr++;
2244             if (*ptr == '*')
2245                 ptr++;
2246 --- 480,486 ----
2247       if (addup)                                        /* add upline */
2248         if (UP) {
2249             ptr=UP;
2250 !           while (VIM_ISDIGIT(*ptr) || *ptr == '.')
2251                 ptr++;
2252             if (*ptr == '*')
2253                 ptr++;
2254 ***************
2255 *** 491,497 ****
2256       if (addbak)                                       /* add backspace */
2257         if (BC) {
2258             ptr=BC;
2259 !           while (isdigit(*ptr) || *ptr == '.')
2260                 ptr++;
2261             if (*ptr == '*')
2262                 ptr++;
2263 --- 491,497 ----
2264       if (addbak)                                       /* add backspace */
2265         if (BC) {
2266             ptr=BC;
2267 !           while (VIM_ISDIGIT(*ptr) || *ptr == '.')
2268                 ptr++;
2269             if (*ptr == '*')
2270                 ptr++;
2271 ***************
2272 *** 542,554 ****
2273         counter,                        /* digits */
2274         atol __ARGS((const char *));
2275
2276 !     if (isdigit(*cp)) {
2277         counter = 0;
2278         frac = 1000;
2279 !       while (isdigit(*cp))
2280             counter = counter * 10L + (long)(*cp++ - '0');
2281         if (*cp == '.')
2282 !           while (isdigit(*++cp)) {
2283                 counter = counter * 10L + (long)(*cp++ - '0');
2284                 frac = frac * 10;
2285             }
2286 --- 542,554 ----
2287         counter,                        /* digits */
2288         atol __ARGS((const char *));
2289
2290 !     if (VIM_ISDIGIT(*cp)) {
2291         counter = 0;
2292         frac = 1000;
2293 !       while (VIM_ISDIGIT(*cp))
2294             counter = counter * 10L + (long)(*cp++ - '0');
2295         if (*cp == '.')
2296 !           while (VIM_ISDIGIT(*++cp)) {
2297                 counter = counter * 10L + (long)(*cp++ - '0');
2298                 frac = frac * 10;
2299             }
2300 *** ../vim-6.2.481/src/version.c        Mon Apr 19 17:00:44 2004
2301 --- src/version.c       Mon Apr 19 20:14:42 2004
2302 ***************
2303 *** 639,640 ****
2304 --- 639,642 ----
2305   {   /* Add new patch number below this line */
2306 + /**/
2307 +     482,
2308   /**/
2309
2310 --
2311 If corn oil comes from corn, where does baby oil come from?
2312
2313  /// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net   \\\
2314 ///        Sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\
2315 \\\              Project leader for A-A-P -- http://www.A-A-P.org        ///
2316  \\\  Buy at Amazon and help AIDS victims -- http://ICCF.nl/click1.html ///