home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume2 / vi-tag-stack < prev    next >
Encoding:
Internet Message Format  |  1991-08-07  |  6.9 KB
  1. From: michael@garfield.UUCP (Mike Rendell)
  2. Newsgroups: comp.sources.misc
  3. Subject: v02i055: Diffs for a tag stack in vi (v3.7)
  4. Message-ID: <7223@ncoast.UUCP>
  5. Date: 11 Feb 88 01:00:52 GMT
  6. Approved: allbery@ncoast.UUCP
  7.  
  8. Comp.sources.misc: Volume 2, Issue 55
  9. Submitted-By: "Mike Rendell" <michael@garfield.UUCP>
  10. Archive-Name: vi-tag-stack
  11.  
  12. [I held on to this while trying to post to comp.bugs.4bsd on r$'s suggestion.
  13. Alas, ncoast never heard of it and our news admin isn't interested.  ++bsa]
  14.  
  15. After using vi on the sun, which has a tag stack, I decided to hack it into
  16. our vaxen's vi (4.3bsd).  The following are the resulting patches for
  17. ex_tagio.c, ex_vmain.c, ex_cmds.c and ex_cmdsub.c.
  18.  
  19. For those of you who don't have suns and don't know what I'm talking about
  20. [and probably most of you with suns, as this feature seems to be
  21. undocumented] this is what the tag stack does:  When you tag something, your
  22. current file (and your current position) are saved on a stack.  When you
  23. want to get back to the previous file(s) you hit ^T.  This is similar to
  24. ^^ except that you can go back multiple levels.  Also I have added a ":push"
  25. command that acts like ":next" except that it pushes the current file on the
  26. tag stack. ":pop" is the same as ^T (really visa versa, for those who know
  27. how vi does these things...). By the way, ^T can take a count to indicate
  28. how many levels to pop.
  29.  
  30. This feature is invaluable when poking around large programs with many
  31. source files.
  32.  
  33.                 Mike Rendell
  34.                 cdnnet: michael@garfield.mun.cdn
  35.                 uucp: michael@garfield
  36.                     {uunet,utai}!garfield!michael
  37.  
  38. Index: ex_tagio.c
  39.  
  40. *** /tmp/,RCSt1014586    Thu Nov  5 17:45:30 1987
  41. --- /tmp/,RCSt2014586    Thu Nov  5 17:45:34 1987
  42. ***************
  43. *** 14,19 ****
  44. --- 14,23 ----
  45.   
  46.   #include <sys/file.h>
  47.   #include "ex.h"
  48. + #ifdef    TAGSTACK
  49. + #include "ex_temp.h"
  50. + #include "ex_vis.h"
  51. + #endif    /* TAGSTACK */
  52.   
  53.   static long offset = -1;
  54.   static long block = -1;
  55. ***************
  56. *** 102,105 ****
  57. --- 106,242 ----
  58.       block = -1;
  59.       bcnt = 0;
  60.   }
  61. + # ifdef    TAGSTACK
  62. + 
  63. + #define    TSTACKMEMSIZE    (10*1024)        /* 10k should suffice */
  64. + 
  65. + typedef struct tstack_str Tstack;
  66. + struct tstack_str {
  67. +     char    *t_file;
  68. +     line    t_dot;
  69. +     int    t_cursor;
  70. +     Tstack    *t_prev;
  71. + };
  72. + 
  73. + int        tstack_cnt = 1;
  74. + static char    tstack_mem[TSTACKMEMSIZE];
  75. + static char    *tstack_ptr = tstack_mem;
  76. + static Tstack    *tstack = (Tstack *) 0;
  77. + 
  78. + /*
  79. +  * save current file/lineno/cursor
  80. +  */
  81. + tag_push(fname)
  82. +     char    *fname;
  83. + {
  84. +     int        len;
  85. +     Tstack        *tp;
  86. + 
  87. +     /* Don't bother if there is no current file */
  88. +     if (fname[0] == '\0')
  89. +         return;
  90. + 
  91. +     /* See how much space we will need */
  92. +     len = sizeof(Tstack) + strlen(fname) + 1;
  93. +     /* keep things word aligned */
  94. +     len += len & 3;
  95. +     if (tstack_ptr + len >= &tstack_mem[TSTACKMEMSIZE]) {
  96. +         lprintf("[Tag stack full] ");
  97. +         return;
  98. +     }
  99. +     tp = (Tstack *) tstack_ptr;
  100. +     tp->t_prev = tstack;
  101. +     tp->t_file = tstack_ptr + sizeof(Tstack);
  102. +     (void) strcpy(tp->t_file, fname);
  103. +     tp->t_dot = lineDOT();
  104. +     tp->t_cursor = inopen ? cursor - linebuf : 0;
  105. +     tstack_ptr += len;
  106. +     tstack = tp;
  107. + }
  108. + 
  109. + tag_pop(bang)
  110. +     int    bang;
  111. + {
  112. +     Tstack        *tp;
  113. +     line        *addr;
  114. +     bool        samef = 1;
  115. +     int        i;
  116. + 
  117. +     /* Do this first so tstack_cnt will be reset regardless */
  118. +     i = tstack_cnt;
  119. +     tstack_cnt = 1;
  120. + 
  121. +     if (!tstack)
  122. +         error("Tag stack empty");
  123. + 
  124. +     for (tp = tstack ; --i > 0 && tp ; tp = tp->t_prev)
  125. +         ;
  126. +     if (!tp)
  127. +         error("Tag stack not that deep");
  128. + 
  129. +     if (strcmp(tp->t_file, savedfile) || !edited) {
  130. +         char cmdbuf2[sizeof(savedfile) + 10];
  131. +         char *oglobp;
  132. +         int omagic;
  133. +         char opeek;
  134. + 
  135. +         if (!bang) {
  136. +             ckaw();
  137. +             if (chng && dol > zero)
  138. +                 error("No write@since last change (:pop! overrides)");
  139. +         }
  140. +         omagic = value(MAGIC);
  141. +         oglobp = globp;
  142. +         strcpy(cmdbuf2, "e! ");
  143. +         strcat(cmdbuf2, tp->t_file);
  144. +         globp = cmdbuf2;
  145. +         opeek = peekc; ungetchar(0);
  146. +         commands(1, 1);
  147. +         peekc = opeek;
  148. +         globp = oglobp;
  149. +         value(MAGIC) = omagic;
  150. +         samef = 0;
  151. +     }
  152. +     /*
  153. +      * Update these now that we know everything is ok
  154. +      */
  155. +     tstack = tp->t_prev;
  156. +     tstack_ptr = (char *) tp;
  157. + 
  158. +     /*
  159. +      *    Try to find the line that we were on
  160. +      */
  161. +     addr = zero + tp->t_dot;
  162. + 
  163. +     /*
  164. +      *    Line is gone?
  165. +      */
  166. +     if (addr <= zero || addr > dol)
  167. +         addr = one;
  168. +     /*
  169. +      * Try to find position on the line
  170. +      */
  171. +     if (inopen) {
  172. +         char    *s;
  173. + 
  174. +         if (samef && addr != dot)
  175. +             markDOT();
  176. +         getline(*addr);
  177. +         s = linebuf + (inopen ? tp->t_cursor : 0);
  178. +         if (s >= linebuf && s < strend(linebuf)) {
  179. +             char    tbuf[8]; /* 001024 (max line) + ' ' + \0 */
  180. + 
  181. +             if (s != linebuf)
  182. +                 (void) sprintf(tbuf, "00%d ", s - linebuf);
  183. +             else
  184. +                 tbuf[0] = '0', tbuf[1] = '0', tbuf[2] = '\0';
  185. +             macpush(tbuf, 0);
  186. +         }
  187. +     }
  188. +     dot = addr;
  189. +     if (ospeed > B300)
  190. +         hold |= HOLDWIG;
  191. +     return;
  192. + }
  193. + # endif    TAGSTACK
  194.   #endif
  195.  
  196. Index: ex_cmds.c
  197.  
  198. *** /tmp/,RCSt1014564    Thu Nov  5 17:45:06 1987
  199. --- /tmp/,RCSt2014564    Thu Nov  5 17:45:19 1987
  200. ***************
  201. *** 410,418 ****
  202.           case 'P':
  203.               switch (peekchar()) {
  204.   
  205. - /* put */
  206.               case 'u':
  207.                   tail("put");
  208.                   setdot();
  209.                   c = cmdreg();
  210.                   eol();
  211. --- 410,439 ----
  212.           case 'P':
  213.               switch (peekchar()) {
  214.   
  215.               case 'u':
  216. + #ifdef    TAGSTACK
  217. + /* push */
  218. +                 ignchar();
  219. +                 if (peekchar() == 's') {
  220. +                     tail2of("push");
  221. +                     setnoaddr();
  222. +                     ckaw();
  223. +                     ignore(quickly());
  224. +                     if (getargs())
  225. +                         makargs();
  226. +                     next();
  227. +                     tag_push(altfile);
  228. +                     c = 'e';
  229. +                     filename(c);
  230. +                     goto doecmd;
  231. + 
  232. +                 }
  233. + /* put */
  234. +                 tail2of("put");
  235. + #else    /* TAGSTACK */
  236. + /* put */
  237.                   tail("put");
  238. + #endif    /* TAGSTACK */
  239.                   setdot();
  240.                   c = cmdreg();
  241.                   eol();
  242. ***************
  243. *** 437,442 ****
  244. --- 458,482 ----
  245.                   tail2of("print");
  246.                   break;
  247.   
  248. + #ifdef    TAGSTACK    
  249. +             case 'o':
  250. + /* pop */
  251. +                 {
  252. +                     int    bang;
  253. + 
  254. +                     tail("pop");
  255. +                     setnoaddr();
  256. +                     bang = exclam();
  257. +                     eol();
  258. +                     tag_pop(bang);
  259. +                     if (!inopen)
  260. +                         lchng = chng - 1;
  261. +                     else
  262. +                         nochng();
  263. +                     continue;
  264. +                 }
  265. + #endif    TAGSTACK
  266. +     
  267.               default:
  268.                   tail("print");
  269.                   break;
  270.  
  271. Index: ex_cmdsub.c
  272.  
  273. *** /tmp/,RCSt1014573    Thu Nov  5 17:45:40 1987
  274. --- /tmp/,RCSt2014573    Thu Nov  5 17:45:54 1987
  275. ***************
  276. *** 623,628 ****
  277. --- 623,631 ----
  278.                   }
  279.               }
  280.               strcpy(cmdbuf, cp);
  281. + #ifdef    TAGSTACK
  282. +             tag_push(savedfile);
  283. + #endif    /* TAGSTACK */
  284.               if (strcmp(filebuf, savedfile) || !edited) {
  285.                   char cmdbuf2[sizeof filebuf + 10];
  286.   
  287.  
  288. Index: ex_vmain.c
  289.  
  290. *** /tmp/,RCSt1014581    Thu Nov  5 17:45:46 1987
  291. --- /tmp/,RCSt2014581    Thu Nov  5 17:46:02 1987
  292. ***************
  293. *** 844,850 ****
  294. --- 844,866 ----
  295.                   globp = "e #";
  296.               goto gogo;
  297.   
  298. + #ifdef    TAGSTACK
  299.           /*
  300. +          *    Pop a tag off the stack
  301. +          */
  302. +         case CTRL(t):
  303. +             if (hadcnt) {
  304. +                 extern int tstack_cnt;
  305. + 
  306. +                 tstack_cnt = cnt;
  307. +             }
  308. +             vsave();
  309. +             oglobp = globp;
  310. +             globp = "pop";
  311. +             goto gogo;
  312. + #endif    /* TAGSTACK */
  313. + 
  314. +         /*
  315.            * ^]        Takes word after cursor as tag, and then does
  316.            *        tag command.  Read ``go right to''.
  317.            */
  318.