home *** CD-ROM | disk | FTP | other *** search
/ vim.ftp.fu-berlin.de / 2015-02-03.vim.ftp.fu-berlin.de.tar / vim.ftp.fu-berlin.de / patches / 7.3 / 7.3.1036 < prev    next >
Encoding:
Internet Message Format  |  2013-05-27  |  13.2 KB
  1. To: vim_dev@googlegroups.com
  2. Subject: Patch 7.3.1036
  3. Fcc: outbox
  4. From: Bram Moolenaar <Bram@moolenaar.net>
  5. Mime-Version: 1.0
  6. Content-Type: text/plain; charset=UTF-8
  7. Content-Transfer-Encoding: 8bit
  8. ------------
  9.  
  10. Patch 7.3.1036
  11. Problem:    Can't build on HP-UX.
  12. Solution:   Give the union a name. (John Marriott)
  13. Files:        src/regexp_nfa.c
  14.  
  15.  
  16. *** ../vim-7.3.1035/src/regexp_nfa.c    2013-05-28 22:30:22.000000000 +0200
  17. --- src/regexp_nfa.c    2013-05-28 22:35:55.000000000 +0200
  18. ***************
  19. *** 2493,2512 ****
  20.   {
  21.       int        in_use; /* number of subexpr with useful info */
  22.   
  23. !     /* When REG_MULTI is TRUE multilist is used, otherwise linelist. */
  24.       union
  25.       {
  26.       struct multipos
  27.       {
  28.           lpos_T    start;
  29.           lpos_T    end;
  30. !     } multilist[NSUBEXP];
  31.       struct linepos
  32.       {
  33.           char_u    *start;
  34.           char_u    *end;
  35. !     } linelist[NSUBEXP];
  36. !     };
  37.   } regsub_T;
  38.   
  39.   /* nfa_thread_T contains execution information of a NFA state */
  40. --- 2493,2512 ----
  41.   {
  42.       int        in_use; /* number of subexpr with useful info */
  43.   
  44. !     /* When REG_MULTI is TRUE list.multi is used, otherwise list.line. */
  45.       union
  46.       {
  47.       struct multipos
  48.       {
  49.           lpos_T    start;
  50.           lpos_T    end;
  51. !     } multi[NSUBEXP];
  52.       struct linepos
  53.       {
  54.           char_u    *start;
  55.           char_u    *end;
  56. !     } line[NSUBEXP];
  57. !     } list;
  58.   } regsub_T;
  59.   
  60.   /* nfa_thread_T contains execution information of a NFA state */
  61. ***************
  62. *** 2536,2550 ****
  63.       if (REG_MULTI)
  64.           fprintf(log_fd, "\n *** group %d, start: c=%d, l=%d, end: c=%d, l=%d",
  65.               j,
  66. !             sub->multilist[j].start.col,
  67. !             (int)sub->multilist[j].start.lnum,
  68. !             sub->multilist[j].end.col,
  69. !             (int)sub->multilist[j].end.lnum);
  70.       else
  71.           fprintf(log_fd, "\n *** group %d, start: \"%s\", end: \"%s\"",
  72.               j,
  73. !             (char *)sub->linelist[j].start,
  74. !             (char *)sub->linelist[j].end);
  75.       fprintf(log_fd, "\n");
  76.   }
  77.   #endif
  78. --- 2536,2550 ----
  79.       if (REG_MULTI)
  80.           fprintf(log_fd, "\n *** group %d, start: c=%d, l=%d, end: c=%d, l=%d",
  81.               j,
  82. !             sub->list.multi[j].start.col,
  83. !             (int)sub->list.multi[j].start.lnum,
  84. !             sub->list.multi[j].end.col,
  85. !             (int)sub->list.multi[j].end.lnum);
  86.       else
  87.           fprintf(log_fd, "\n *** group %d, start: \"%s\", end: \"%s\"",
  88.               j,
  89. !             (char *)sub->list.line[j].start,
  90. !             (char *)sub->list.line[j].end);
  91.       fprintf(log_fd, "\n");
  92.   }
  93.   #endif
  94. ***************
  95. *** 2626,2637 ****
  96.           {
  97.           /* Copy the match start and end positions. */
  98.           if (REG_MULTI)
  99. !             mch_memmove(&lastthread->sub.multilist[0],
  100. !                 &sub->multilist[0],
  101.                   sizeof(struct multipos) * sub->in_use);
  102.           else
  103. !             mch_memmove(&lastthread->sub.linelist[0],
  104. !                 &sub->linelist[0],
  105.                   sizeof(struct linepos) * sub->in_use);
  106.           }
  107.       }
  108. --- 2626,2637 ----
  109.           {
  110.           /* Copy the match start and end positions. */
  111.           if (REG_MULTI)
  112. !             mch_memmove(&lastthread->sub.list.multi[0],
  113. !                 &sub->list.multi[0],
  114.                   sizeof(struct multipos) * sub->in_use);
  115.           else
  116. !             mch_memmove(&lastthread->sub.list.line[0],
  117. !                 &sub->list.line[0],
  118.                   sizeof(struct linepos) * sub->in_use);
  119.           }
  120.       }
  121. ***************
  122. *** 2705,2711 ****
  123.           {
  124.           if (subidx < sub->in_use)
  125.           {
  126. !             save_lpos = sub->multilist[subidx].start;
  127.               save_in_use = -1;
  128.           }
  129.           else
  130. --- 2705,2711 ----
  131.           {
  132.           if (subidx < sub->in_use)
  133.           {
  134. !             save_lpos = sub->list.multi[subidx].start;
  135.               save_in_use = -1;
  136.           }
  137.           else
  138. ***************
  139. *** 2713,2732 ****
  140.               save_in_use = sub->in_use;
  141.               for (i = sub->in_use; i < subidx; ++i)
  142.               {
  143. !             sub->multilist[i].start.lnum = -1;
  144. !             sub->multilist[i].end.lnum = -1;
  145.               }
  146.               sub->in_use = subidx + 1;
  147.           }
  148.           if (off == -1)
  149.           {
  150. !             sub->multilist[subidx].start.lnum = reglnum + 1;
  151. !             sub->multilist[subidx].start.col = 0;
  152.           }
  153.           else
  154.           {
  155. !             sub->multilist[subidx].start.lnum = reglnum;
  156. !             sub->multilist[subidx].start.col =
  157.                         (colnr_T)(reginput - regline + off);
  158.           }
  159.           }
  160. --- 2713,2732 ----
  161.               save_in_use = sub->in_use;
  162.               for (i = sub->in_use; i < subidx; ++i)
  163.               {
  164. !             sub->list.multi[i].start.lnum = -1;
  165. !             sub->list.multi[i].end.lnum = -1;
  166.               }
  167.               sub->in_use = subidx + 1;
  168.           }
  169.           if (off == -1)
  170.           {
  171. !             sub->list.multi[subidx].start.lnum = reglnum + 1;
  172. !             sub->list.multi[subidx].start.col = 0;
  173.           }
  174.           else
  175.           {
  176. !             sub->list.multi[subidx].start.lnum = reglnum;
  177. !             sub->list.multi[subidx].start.col =
  178.                         (colnr_T)(reginput - regline + off);
  179.           }
  180.           }
  181. ***************
  182. *** 2734,2740 ****
  183.           {
  184.           if (subidx < sub->in_use)
  185.           {
  186. !             save_ptr = sub->linelist[subidx].start;
  187.               save_in_use = -1;
  188.           }
  189.           else
  190. --- 2734,2740 ----
  191.           {
  192.           if (subidx < sub->in_use)
  193.           {
  194. !             save_ptr = sub->list.line[subidx].start;
  195.               save_in_use = -1;
  196.           }
  197.           else
  198. ***************
  199. *** 2742,2753 ****
  200.               save_in_use = sub->in_use;
  201.               for (i = sub->in_use; i < subidx; ++i)
  202.               {
  203. !             sub->linelist[i].start = NULL;
  204. !             sub->linelist[i].end = NULL;
  205.               }
  206.               sub->in_use = subidx + 1;
  207.           }
  208. !         sub->linelist[subidx].start = reginput + off;
  209.           }
  210.   
  211.           addstate(l, state->out, sub, off);
  212. --- 2742,2753 ----
  213.               save_in_use = sub->in_use;
  214.               for (i = sub->in_use; i < subidx; ++i)
  215.               {
  216. !             sub->list.line[i].start = NULL;
  217. !             sub->list.line[i].end = NULL;
  218.               }
  219.               sub->in_use = subidx + 1;
  220.           }
  221. !         sub->list.line[subidx].start = reginput + off;
  222.           }
  223.   
  224.           addstate(l, state->out, sub, off);
  225. ***************
  226. *** 2755,2763 ****
  227.           if (save_in_use == -1)
  228.           {
  229.           if (REG_MULTI)
  230. !             sub->multilist[subidx].start = save_lpos;
  231.           else
  232. !             sub->linelist[subidx].start = save_ptr;
  233.           }
  234.           else
  235.           sub->in_use = save_in_use;
  236. --- 2755,2763 ----
  237.           if (save_in_use == -1)
  238.           {
  239.           if (REG_MULTI)
  240. !             sub->list.multi[subidx].start = save_lpos;
  241.           else
  242. !             sub->list.line[subidx].start = save_ptr;
  243.           }
  244.           else
  245.           sub->in_use = save_in_use;
  246. ***************
  247. *** 2793,2823 ****
  248.           sub->in_use = subidx + 1;
  249.           if (REG_MULTI)
  250.           {
  251. !         save_lpos = sub->multilist[subidx].end;
  252.           if (off == -1)
  253.           {
  254. !             sub->multilist[subidx].end.lnum = reglnum + 1;
  255. !             sub->multilist[subidx].end.col = 0;
  256.           }
  257.           else
  258.           {
  259. !             sub->multilist[subidx].end.lnum = reglnum;
  260. !             sub->multilist[subidx].end.col =
  261.                         (colnr_T)(reginput - regline + off);
  262.           }
  263.           }
  264.           else
  265.           {
  266. !         save_ptr = sub->linelist[subidx].end;
  267. !         sub->linelist[subidx].end = reginput + off;
  268.           }
  269.   
  270.           addstate(l, state->out, sub, off);
  271.   
  272.           if (REG_MULTI)
  273. !         sub->multilist[subidx].end = save_lpos;
  274.           else
  275. !         sub->linelist[subidx].end = save_ptr;
  276.           sub->in_use = save_in_use;
  277.           break;
  278.       }
  279. --- 2793,2823 ----
  280.           sub->in_use = subidx + 1;
  281.           if (REG_MULTI)
  282.           {
  283. !         save_lpos = sub->list.multi[subidx].end;
  284.           if (off == -1)
  285.           {
  286. !             sub->list.multi[subidx].end.lnum = reglnum + 1;
  287. !             sub->list.multi[subidx].end.col = 0;
  288.           }
  289.           else
  290.           {
  291. !             sub->list.multi[subidx].end.lnum = reglnum;
  292. !             sub->list.multi[subidx].end.col =
  293.                         (colnr_T)(reginput - regline + off);
  294.           }
  295.           }
  296.           else
  297.           {
  298. !         save_ptr = sub->list.line[subidx].end;
  299. !         sub->list.line[subidx].end = reginput + off;
  300.           }
  301.   
  302.           addstate(l, state->out, sub, off);
  303.   
  304.           if (REG_MULTI)
  305. !         sub->list.multi[subidx].end = save_lpos;
  306.           else
  307. !         sub->list.line[subidx].end = save_ptr;
  308.           sub->in_use = save_in_use;
  309.           break;
  310.       }
  311. ***************
  312. *** 2975,2987 ****
  313.   
  314.       if (REG_MULTI)
  315.       {
  316. !     if (sub->multilist[subidx].start.lnum < 0
  317. !                        || sub->multilist[subidx].end.lnum < 0)
  318.           goto retempty;
  319.       /* TODO: line breaks */
  320. !     len = sub->multilist[subidx].end.col
  321. !                      - sub->multilist[subidx].start.col;
  322. !     if (cstrncmp(regline + sub->multilist[subidx].start.col,
  323.                               reginput, &len) == 0)
  324.       {
  325.           *bytelen = len;
  326. --- 2975,2987 ----
  327.   
  328.       if (REG_MULTI)
  329.       {
  330. !     if (sub->list.multi[subidx].start.lnum < 0
  331. !                        || sub->list.multi[subidx].end.lnum < 0)
  332.           goto retempty;
  333.       /* TODO: line breaks */
  334. !     len = sub->list.multi[subidx].end.col
  335. !                      - sub->list.multi[subidx].start.col;
  336. !     if (cstrncmp(regline + sub->list.multi[subidx].start.col,
  337.                               reginput, &len) == 0)
  338.       {
  339.           *bytelen = len;
  340. ***************
  341. *** 2990,3000 ****
  342.       }
  343.       else
  344.       {
  345. !     if (sub->linelist[subidx].start == NULL
  346. !                      || sub->linelist[subidx].end == NULL)
  347.           goto retempty;
  348. !     len = (int)(sub->linelist[subidx].end - sub->linelist[subidx].start);
  349. !     if (cstrncmp(sub->linelist[subidx].start, reginput, &len) == 0)
  350.       {
  351.           *bytelen = len;
  352.           return TRUE;
  353. --- 2990,3000 ----
  354.       }
  355.       else
  356.       {
  357. !     if (sub->list.line[subidx].start == NULL
  358. !                     || sub->list.line[subidx].end == NULL)
  359.           goto retempty;
  360. !     len = (int)(sub->list.line[subidx].end - sub->list.line[subidx].start);
  361. !     if (cstrncmp(sub->list.line[subidx].start, reginput, &len) == 0)
  362.       {
  363.           *bytelen = len;
  364.           return TRUE;
  365. ***************
  366. *** 3260,3274 ****
  367.           if (REG_MULTI)
  368.               for (j = 0; j < submatch->in_use; j++)
  369.               {
  370. !             submatch->multilist[j].start =
  371. !                             t->sub.multilist[j].start;
  372. !             submatch->multilist[j].end = t->sub.multilist[j].end;
  373.               }
  374.           else
  375.               for (j = 0; j < submatch->in_use; j++)
  376.               {
  377. !             submatch->linelist[j].start = t->sub.linelist[j].start;
  378. !             submatch->linelist[j].end = t->sub.linelist[j].end;
  379.               }
  380.   #ifdef ENABLE_LOG
  381.           log_subexpr(&t->sub);
  382. --- 3260,3275 ----
  383.           if (REG_MULTI)
  384.               for (j = 0; j < submatch->in_use; j++)
  385.               {
  386. !             submatch->list.multi[j].start =
  387. !                            t->sub.list.multi[j].start;
  388. !             submatch->list.multi[j].end = t->sub.list.multi[j].end;
  389.               }
  390.           else
  391.               for (j = 0; j < submatch->in_use; j++)
  392.               {
  393. !             submatch->list.line[j].start =
  394. !                             t->sub.list.line[j].start;
  395. !             submatch->list.line[j].end = t->sub.list.line[j].end;
  396.               }
  397.   #ifdef ENABLE_LOG
  398.           log_subexpr(&t->sub);
  399. ***************
  400. *** 3355,3368 ****
  401.               if (REG_MULTI)
  402.               for (j = 1; j < m->in_use; j++)
  403.               {
  404. !                 t->sub.multilist[j].start = m->multilist[j].start;
  405. !                 t->sub.multilist[j].end = m->multilist[j].end;
  406.               }
  407.               else
  408.               for (j = 1; j < m->in_use; j++)
  409.               {
  410. !                 t->sub.linelist[j].start = m->linelist[j].start;
  411. !                 t->sub.linelist[j].end = m->linelist[j].end;
  412.               }
  413.               t->sub.in_use = m->in_use;
  414.   
  415. --- 3356,3369 ----
  416.               if (REG_MULTI)
  417.               for (j = 1; j < m->in_use; j++)
  418.               {
  419. !                 t->sub.list.multi[j].start = m->list.multi[j].start;
  420. !                 t->sub.list.multi[j].end = m->list.multi[j].end;
  421.               }
  422.               else
  423.               for (j = 1; j < m->in_use; j++)
  424.               {
  425. !                 t->sub.list.line[j].start = m->list.line[j].start;
  426. !                 t->sub.list.line[j].end = m->list.line[j].end;
  427.               }
  428.               t->sub.in_use = m->in_use;
  429.   
  430. ***************
  431. *** 3907,3919 ****
  432.       if (REG_MULTI)
  433.       {
  434.       /* Use 0xff to set lnum to -1 */
  435. !     vim_memset(sub.multilist, 0xff, sizeof(struct multipos) * nfa_nsubexpr);
  436. !     vim_memset(m.multilist, 0xff, sizeof(struct multipos) * nfa_nsubexpr);
  437.       }
  438.       else
  439.       {
  440. !     vim_memset(sub.linelist, 0, sizeof(struct linepos) * nfa_nsubexpr);
  441. !     vim_memset(m.linelist, 0, sizeof(struct linepos) * nfa_nsubexpr);
  442.       }
  443.       sub.in_use = 0;
  444.       m.in_use = 0;
  445. --- 3908,3920 ----
  446.       if (REG_MULTI)
  447.       {
  448.       /* Use 0xff to set lnum to -1 */
  449. !     vim_memset(sub.list.multi, 0xff, sizeof(struct multipos) * nfa_nsubexpr);
  450. !     vim_memset(m.list.multi, 0xff, sizeof(struct multipos) * nfa_nsubexpr);
  451.       }
  452.       else
  453.       {
  454. !     vim_memset(sub.list.line, 0, sizeof(struct linepos) * nfa_nsubexpr);
  455. !     vim_memset(m.list.line, 0, sizeof(struct linepos) * nfa_nsubexpr);
  456.       }
  457.       sub.in_use = 0;
  458.       m.in_use = 0;
  459. ***************
  460. *** 3926,3933 ****
  461.       {
  462.       for (i = 0; i < sub.in_use; i++)
  463.       {
  464. !         reg_startpos[i] = sub.multilist[i].start;
  465. !         reg_endpos[i] = sub.multilist[i].end;
  466.       }
  467.   
  468.       if (reg_startpos[0].lnum < 0)
  469. --- 3927,3934 ----
  470.       {
  471.       for (i = 0; i < sub.in_use; i++)
  472.       {
  473. !         reg_startpos[i] = sub.list.multi[i].start;
  474. !         reg_endpos[i] = sub.list.multi[i].end;
  475.       }
  476.   
  477.       if (reg_startpos[0].lnum < 0)
  478. ***************
  479. *** 3949,3956 ****
  480.       {
  481.       for (i = 0; i < sub.in_use; i++)
  482.       {
  483. !         reg_startp[i] = sub.linelist[i].start;
  484. !         reg_endp[i] = sub.linelist[i].end;
  485.       }
  486.   
  487.       if (reg_startp[0] == NULL)
  488. --- 3950,3957 ----
  489.       {
  490.       for (i = 0; i < sub.in_use; i++)
  491.       {
  492. !         reg_startp[i] = sub.list.line[i].start;
  493. !         reg_endp[i] = sub.list.line[i].end;
  494.       }
  495.   
  496.       if (reg_startp[0] == NULL)
  497. *** ../vim-7.3.1035/src/version.c    2013-05-28 22:31:43.000000000 +0200
  498. --- src/version.c    2013-05-28 22:37:01.000000000 +0200
  499. ***************
  500. *** 730,731 ****
  501. --- 730,733 ----
  502.   {   /* Add new patch number below this line */
  503. + /**/
  504. +     1036,
  505.   /**/
  506.  
  507. -- 
  508. hundred-and-one symptoms of being an internet addict:
  509. 9. All your daydreaming is preoccupied with getting a faster connection to the
  510.    net: 28.8...ISDN...cable modem...T1...T3.
  511.  
  512.  /// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net   \\\
  513. ///        sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\
  514. \\\  an exciting new programming language -- http://www.Zimbu.org        ///
  515.  \\\            help me help AIDS victims -- http://ICCF-Holland.org    ///
  516.