![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ch16.r CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / ucb / lisp / lisplib / manual|
Return to ch16.r CVS log | Up to [CSRG BSD Unix] / 42BSD / ucb / lisp / lisplib / manual |
1.1 ! root 1: ! 2: ! 3: ! 4: ! 5: ! 6: ! 7: ! 8: CHAPTER 16 ! 9: ! 10: ! 11: The LISP Editor ! 12: ! 13: ! 14: ! 15: ! 16: ! 17: ! 18: ! 19: 16.1. The Editors ! 20: ! 21: It is quite possible to use VI, Emacs or other stan- ! 22: dard editors to edit your lisp programs, and many peo- ! 23: ple do just that. However there is a lisp structure ! 24: editor which is particularly good for the editing of ! 25: lisp programs, and operates in a rather different ! 26: fashion, namely within a lisp environment. applica- ! 27: tion. It is handy to know how to use it for fixing ! 28: problems without exiting from the lisp system (e.g. ! 29: from the debugger so you can continue to execute ! 30: rather than having to start over.) The editor is not ! 31: quite like the top-level and debugger, in that it ! 32: expects you to type editor commands to it. It will ! 33: not evaluate whatever you happen to type. (There is ! 34: an editor command to evaluate things, though.) ! 35: ! 36: The editor is available (assuming your system is set ! 37: up correctly with a lisp library) by typing (load ! 38: 'cmufncs) and (load 'cmuedit). ! 39: ! 40: The most frequent use of the editor is to change ! 41: function definitions by starting the editor with one ! 42: of the commands described in section 16.14. (see ! 43: _e_d_i_t_f), values (_e_d_i_t_v), properties (_e_d_i_t_p), and ! 44: expressions (_e_d_i_t_e). The beginner is advised to ! 45: start with the following (very basic) commands: _o_k, ! 46: _u_n_d_o, _p, #, under which are explained two different ! 47: basic commands which start with numbers, and f. ! 48: ! 49: This documentation, and the editor, were imported from ! 50: PDP-10 CMULisp by Don Cohen. PDP-10 CMULisp is based ! 51: on UCILisp, and the editor itself was derived from an ! 52: early version of Interlisp. Lars Ericson, the author ! 53: of this section, has provided this very concise sum- ! 54: mary. Tutorial examples and implementation details ! 55: may be found in the Interlisp Reference Manual, where ! 56: a similar editor is described. ! 57: ! 58: ! 59: ! 60: 9 ! 61: ! 62: 9The LISP Editor 16-1 ! 63: ! 64: ! 65: ! 66: ! 67: ! 68: ! 69: ! 70: The LISP Editor 16-2 ! 71: ! 72: ! 73: 16.2. Scope of Attention ! 74: ! 75: Attention-changing commands allow you to look at a ! 76: different part of a Lisp expression you are editing. ! 77: The sub-structure upon which the editor's attention is ! 78: centered is called "the current expression". Chang- ! 79: ing the current expression means shifting attention ! 80: and not actually modifying any structure. ! 81: ! 82: ____________________________________________________________ ! 83: ! 84: _S_C_O_P_E _O_F _A_T_T_E_N_T_I_O_N _C_O_M_M_A_N_D _S_U_M_M_A_R_Y ! 85: ! 86: _n (_n>_0) . Makes the nth element of the current expression be ! 87: the new current expression. ! 88: ! 89: -_n (_n>_0). Makes the nth element from the end of the current ! 90: expression be the new current expression. ! 91: ! 92: _0. Makes the next higher expression be the new correct ! 93: expression. If the intention is to go back to the next ! 94: higher left parenthesis, use the command !0. ! 95: ! 96: _u_p . If a p command would cause the editor to type ... ! 97: before typing the current expression, (the current expres- ! 98: sion is a tail of the next higher expression) then has no ! 99: effect; else, up makes the old current expression the first ! 100: element in the new current expression. ! 101: ! 102: !_0 . Goes back to the next higher left parenthesis. ! 103: ! 104: ^ . Makes the top level expression be the current expres- ! 105: sion. ! 106: ! 107: _n_x . Makes the current expression be the next expression. ! 108: ! 109: (_n_x _n) equivalent to n nx commands. ! 110: ! 111: !_n_x . Makes current expression be the next expression at a ! 112: higher level. Goes through any number of right parentheses ! 113: to get to the next expression. ! 114: ! 115: _b_k . Makes the current expression be the previous expres- ! 116: sion in the next higher expression. ! 117: ! 118: (_n_t_h _n) _n>_0 . Makes the list starting with the nth element ! 119: of the current expression be the current expression. ! 120: ! 121: (_n_t_h $) - _g_e_n_e_r_a_l_i_z_e_d _n_t_h _c_o_m_m_a_n_d. nth locates $, and then ! 122: backs up to the current level, where the new current expres- ! 123: sion is the tail whose first element contains, however dee- ! 124: ply, the expression that was the terminus of the location ! 125: operation. ! 126: ! 127: ! 128: Printed: July 21, 1983 ! 129: ! 130: ! 131: ! 132: ! 133: ! 134: ! 135: ! 136: The LISP Editor 16-3 ! 137: ! 138: ! 139: :: . (pattern :: . $) e.g., (cond :: return). finds a ! 140: cond that contains a return, at any depth. ! 141: ! 142: (_b_e_l_o_w _c_o_m _x) . The below command is useful for locating a ! 143: substructure by specifying something it contains. (below ! 144: cond) will cause the cond clause containing the current ! 145: expression to become the new current expression. Suppose ! 146: you are editing a list of lists, and want to find a sublist ! 147: that contains a foo (at any depth). Then simply executes f ! 148: foo (below ). ! 149: ! 150: (_n_e_x _x) . same as (_b_e_l_o_w _x) followed by nx. For example, ! 151: if you are deep inside of a selectq clause, you can advance ! 152: to the next clause with (_n_e_x _s_e_l_e_c_t_q). ! 153: ! 154: _n_e_x. The atomic form of _n_e_x is useful if you will be ! 155: performing repeated executions of (_n_e_x _x). By simply ! 156: marking the chain corresponding to x, you can use _n_e_x to ! 157: step through the sublists. ! 158: ____________________________________________________________ ! 159: ! 160: ! 161: ! 162: ! 163: ! 164: 16.3. Pattern Matching Commands ! 165: ! 166: Many editor commands that search take patterns. A ! 167: pattern _p_a_t matches with x if: ! 168: ! 169: ____________________________________________________________ ! 170: ! 171: _P_A_T_T_E_R_N _S_P_E_C_I_F_I_C_A_T_I_O_N _S_U_M_M_A_R_Y ! 172: ! 173: - _p_a_t is _e_q to x. ! 174: ! 175: - _p_a_t is &. ! 176: ! 177: - _p_a_t is a number and equal to x. ! 178: ! 179: - if (car _p_a_t) is the atom *any*, (cdr _p_a_t) is a list of ! 180: patterns, and _p_a_t matches x if and only if one of the pat- ! 181: terns on (cdr _p_a_t) matches x. ! 182: ! 183: - if _p_a_t is a literal atom or string, and (nthchar _p_a_t -1) ! 184: is @, then _p_a_t matches with any literal atom or string which ! 185: has the same initial characters as _p_a_t, e.g. ver@ matches ! 186: with verylongatom, as well as "verylongstring". ! 187: ! 188: - if (car _p_a_t) is the atom --, _p_a_t matches x if (a) (cdr ! 189: _p_a_t)=nil, i.e. _p_a_t=(--), e.g., (a --) matches (a) (a b c) ! 190: and (a . b) in other words, -- can match any tail of a ! 191: list. (b) (cdr _p_a_t) matches with some tail of x, e.g. (a ! 192: ! 193: ! 194: Printed: July 21, 1983 ! 195: ! 196: ! 197: ! 198: ! 199: ! 200: ! 201: ! 202: The LISP Editor 16-4 ! 203: ! 204: ! 205: -- (&)) will match with (a b c (d)), but not (a b c d), or ! 206: (a b c (d) e). however, note that (a -- (&) --) will match ! 207: with (a b c (d) e). in other words, -- will match any inte- ! 208: rior segment of a list. ! 209: ! 210: - if (car _p_a_t) is the atom ==, _p_a_t matches x if and only if ! 211: (cdr _p_a_t) is _e_q to x. (this pattern is for use by programs ! 212: that call the editor as a subroutine, since any non-atomic ! 213: expression in a command typed in by the user obviously can- ! 214: not be _e_q to existing structure.) - otherwise if x is a ! 215: list, _p_a_t matches x if (car _p_a_t) matches (car x), and (cdr ! 216: _p_a_t) matches (cdr x). ! 217: ! 218: - when searching, the pattern matching routine is called ! 219: only to match with elements in the structure, unless the ! 220: pattern begins with :::, in which case cdr of the pattern is ! 221: matched against tails in the structure. (in this case, the ! 222: tail does not have to be a proper tail, e.g. (::: a --) ! 223: will match with the element (a b c) as well as with cdr of ! 224: (x a b c), since (a b c) is a tail of (a b c).) ! 225: ____________________________________________________________ ! 226: ! 227: ! 228: ! 229: ! 230: ! 231: 16.3.1. Commands That Search ! 232: ! 233: ____________________________________________________________ ! 234: ! 235: _S_E_A_R_C_H _C_O_M_M_A_N_D _S_U_M_M_A_R_Y ! 236: ! 237: _f _p_a_t_t_e_r_n . f informs the editor that the next command is ! 238: to be interpreted as a pattern. If no pattern is given on ! 239: the same line as the f then the last pattern is used. f ! 240: pattern means find the next instance of pattern. ! 241: ! 242: (_f _p_a_t_t_e_r_n _n). Finds the next instance of pattern. ! 243: ! 244: (_f _p_a_t_t_e_r_n _t). similar to f pattern, except, for example, ! 245: if the current expression is (cond ..), f cond will look for ! 246: the next cond, but (f cond t) will 'stay here'. ! 247: ! 248: (_f _p_a_t_t_e_r_n _n) _n>_0. Finds the nth place that pattern ! 249: matches. If the current expression is (foo1 foo2 foo3), (f ! 250: f00@ 3) will find foo3. ! 251: ! 252: (_f _p_a_t_t_e_r_n) _o_r (_f _p_a_t_t_e_r_n _n_i_l). only matches with elements ! 253: at the top level of the current expression. If the current ! 254: expression is (_p_r_o_g _n_i_l (_s_e_t_q _x (_c_o_n_d & &)) (_c_o_n_d &) ...) f ! 255: (cond --) will find the cond inside the setq, whereas (f ! 256: (cond --)) will find the top level cond, i.e., the second ! 257: one. ! 258: ! 259: ! 260: Printed: July 21, 1983 ! 261: ! 262: ! 263: ! 264: ! 265: ! 266: ! 267: ! 268: The LISP Editor 16-5 ! 269: ! 270: ! 271: (_s_e_c_o_n_d . $) . same as (lc . $) followed by another (lc . ! 272: $) except that if the first succeeds and second fails, no ! 273: change is made to the edit chain. ! 274: ! 275: (_t_h_i_r_d . $) . Similar to second. ! 276: ! 277: (_f_s _p_a_t_t_e_r_n_1 ... _p_a_t_t_e_r_n_n) . equivalent to f pattern1 fol- ! 278: lowed by f pattern2 ... followed by f pattern n, so that if ! 279: f pattern m fails, edit chain is left at place pattern m-1 ! 280: matched. ! 281: ! 282: (_f= _e_x_p_r_e_s_s_i_o_n _x) . Searches for a structure eq to expres- ! 283: sion. ! 284: ! 285: (_o_r_f _p_a_t_t_e_r_n_1 ... _p_a_t_t_e_r_n_n) . Searches for an expression ! 286: that is matched by either pattern1 or ... patternn. ! 287: ! 288: _b_f _p_a_t_t_e_r_n . backwards find. If the current expression is ! 289: (_p_r_o_g _n_i_l (_s_e_t_q _x (_s_e_t_q _y (_l_i_s_t _z))) (_c_o_n_d ((_s_e_t_q _w --) --)) ! 290: --) f list followed by bf setq will leave the current ! 291: expression as (setq y (list z)), as will f cond followed by ! 292: bf setq ! 293: ! 294: (_b_f _p_a_t_t_e_r_n _t). backwards find. Search always includes ! 295: current expression, i.e., starts at end of current expres- ! 296: sion and works backward, then ascends and backs up, etc. ! 297: ____________________________________________________________ ! 298: ! 299: ! 300: ! 301: ! 302: ! 303: 16.3.1.1. Location Specifications Many editor ! 304: commands use a method of specifying position ! 305: called a location specification. The meta- ! 306: symbol $ is used to denote a location specifica- ! 307: tion. $ is a list of commands interpreted as ! 308: described above. $ can also be atomic, in which ! 309: case it is interpreted as (list $). a location ! 310: specification is a list of edit commands that ! 311: are executed in the normal fashion with two ! 312: exceptions. first, all commands not recognized ! 313: by the editor are interpreted as though they had ! 314: been preceded by f. The location specification ! 315: (cond 2 3) specifies the 3rd element in the ! 316: first clause of the next cond. ! 317: ! 318: the if command and the ## function provide a way ! 319: of using in location specifications arbitrary ! 320: predicates applied to elements in the current ! 321: expression. ! 322: ! 323: In insert, delete, replace and change, if $ is ! 324: ! 325: ! 326: Printed: July 21, 1983 ! 327: ! 328: ! 329: ! 330: ! 331: ! 332: ! 333: ! 334: The LISP Editor 16-6 ! 335: ! 336: ! 337: nil (empty), the corresponding operation is per- ! 338: formed on the current edit chain, i.e. (replace ! 339: with (car x)) is equivalent to (:(car x)). for ! 340: added readability, here is also permitted, e.g., ! 341: (insert (print x) before here) will insert ! 342: (print x) before the current expression (but not ! 343: change the edit chain). It is perfectly legal ! 344: to ascend to insert, replace, or delete. for ! 345: example (insert (_r_e_t_u_r_n) after ^ prog -1) will ! 346: go to the top, find the first prog, and insert a ! 347: (_r_e_t_u_r_n) at its end, and not change the current ! 348: edit chain. ! 349: ! 350: The a, b, and : commands all make special ! 351: checks in e1 thru em for expressions of the form ! 352: (## . coms). In this case, the expression used ! 353: for inserting or replacing is a copy of the ! 354: current expression after executing coms, a list ! 355: of edit commands. (insert (## f cond -1 -1) ! 356: after3) will make a copy of the last form in ! 357: the last clause of the next cond, and insert it ! 358: after the third element of the current expres- ! 359: sion. ! 360: ! 361: $. In descriptions of the editor, the meta- ! 362: symbol $ is used to denote a location specifica- ! 363: tion. $ is a list of commands interpreted as ! 364: described above. $ can also be atomic. ! 365: ! 366: ____________________________________________________________ ! 367: ! 368: _L_O_C_A_T_I_O_N _C_O_M_M_A_N_D _S_U_M_M_A_R_Y ! 369: ! 370: (_l_c . $) . Provides a way of explicitly invoking the loca- ! 371: tion operation. (lc cond 2 3) will perform search. ! 372: ! 373: (_l_c_l . $) . Same as lc except search is confined to current ! 374: expression. To find a cond containing a _r_e_t_u_r_n, one might ! 375: use the location specification (cond (lcl _r_e_t_u_r_n) ) where ! 376: the would reverse the effects of the lcl command, and make ! 377: the final current expression be the cond. ! 378: ____________________________________________________________ ! 379: ! 380: ! 381: ! 382: ! 383: ! 384: 16.3.2. The Edit Chain The edit-chain is a list of ! 385: which the first element is the the one you are now ! 386: editing ("current expression"), the next element is ! 387: what would become the current expression if you ! 388: were to do a 0, etc., until the last element which ! 389: is the expression that was passed to the editor. ! 390: ! 391: ! 392: Printed: July 21, 1983 ! 393: ! 394: ! 395: ! 396: ! 397: ! 398: ! 399: ! 400: The LISP Editor 16-7 ! 401: ! 402: ! 403: ____________________________________________________________ ! 404: ! 405: _E_D_I_T _C_H_A_I_N _C_O_M_M_A_N_D _S_U_M_M_A_R_Y ! 406: ! 407: _m_a_r_k . Adds the current edit chain to the front of the list ! 408: marklst. ! 409: ! 410: _ . Makes the new edit chain be (car marklst). ! 411: ! 412: (_ _p_a_t_t_e_r_n) . Ascends the edit chain looking for a link ! 413: which matches pattern. for example: ! 414: ! 415: __ . Similar to _ but also erases the mark. ! 416: ! 417: \ . Makes the edit chain be the value of unfind. unfind is ! 418: set to the current edit chain by each command that makes a ! 419: "big jump", i.e., a command that usually performs more than ! 420: a single ascent or descent, namely ^, _, __, !nx, all com- ! 421: mands that involve a search, e.g., f, lc, ::, below, et al ! 422: and and themselves. ! 423: if the user types f cond, and then f car, would take him ! 424: back to the cond. another would take him back to the car, ! 425: etc. ! 426: ! 427: \_p . Restores the edit chain to its state as of the last ! 428: print operation. If the edit chain has not changed since ! 429: the last printing, \p restores it to its state as of the ! 430: printing before that one. If the user types p followed by 3 ! 431: 2 1 p, \p will return to the first p, i.e., would be ! 432: equivalent to 0 0 0. Another \p would then take him back to ! 433: the second p. ! 434: ____________________________________________________________ ! 435: ! 436: ! 437: ! 438: ! 439: ! 440: 16.4. Printing Commands ! 441: ! 442: ____________________________________________________________ ! 443: ! 444: _P_R_I_N_T_I_N_G _C_O_M_M_A_N_D _S_U_M_M_A_R_Y ! 445: ! 446: _p Prints current expression in abbreviated form. (p m) ! 447: prints mth element of current expression in abbreviated ! 448: form. (p m n) prints mth element of current expression as ! 449: though printlev were given a depth of n. (p 0 n) prints ! 450: current expression as though printlev were given a depth of ! 451: n. (p cond 3) will work. ! 452: ! 453: ? . prints the current expression as though printlev were ! 454: given a depth of 100. ! 455: 9 ! 456: ! 457: 9 Printed: July 21, 1983 ! 458: ! 459: ! 460: ! 461: ! 462: ! 463: ! 464: ! 465: The LISP Editor 16-8 ! 466: ! 467: ! 468: _p_p . pretty-prints the current expression. ! 469: ! 470: _p_p*. is like pp, but forces comments to be shown. ! 471: ____________________________________________________________ ! 472: ! 473: ! 474: ! 475: ! 476: ! 477: 16.5. Structure Modification Commands ! 478: ! 479: All structure modification commands are undoable. See ! 480: _u_n_d_o. ! 481: ! 482: ! 483: ____________________________________________________________ ! 484: ! 485: _S_T_R_U_C_T_U_R_E _M_O_D_I_F_I_C_A_T_I_O_N _C_O_M_M_A_N_D _S_U_M_M_A_R_Y ! 486: ! 487: # [_e_d_i_t_o_r _c_o_m_m_a_n_d_s] (n) n>1 deletes the corresponding ele- ! 488: ment from the current expression. ! 489: ! 490: (_n _e_1 ... _e_m) _n,_m>_1 replaces the nth element in the current ! 491: expression with e1 ... em. ! 492: ! 493: (-_n _e_1 ... _e_m) _n,_m>_1 inserts e1 ... em before the n ele- ! 494: ment in the current expression. ! 495: ! 496: (_n _e_1 ... _e_m) (the letter "n" for "next" or "nconc", not a ! 497: number) m>1 attaches e1 ... em at the end of the current ! 498: expression. ! 499: ! 500: (_a _e_1 ... _e_m) . inserts e1 ... em after the current ! 501: expression (or after its first element if it is a tail). ! 502: ! 503: (_b _e_1 ... _e_m) . inserts e1 ... em before the current ! 504: expression. to insert foo before the last element in the ! 505: current expression, perform -1 and then (b foo). ! 506: ! 507: (: _e_1 ... _e_m) . replaces the current expression by e1 ... ! 508: em. If the current expression is a tail then replace its ! 509: first element. ! 510: ! 511: _d_e_l_e_t_e _o_r (:) . deletes the current expression, or if the ! 512: current expression is a tail, deletes its first element. ! 513: ! 514: (_d_e_l_e_t_e . $). does a (lc . $) followed by delete. current ! 515: edit chain is not changed. ! 516: ! 517: (_i_n_s_e_r_t _e_1 ... _e_m _b_e_f_o_r_e . $) . similar to (lc. $) fol- ! 518: lowed by (b e1 ... em). ! 519: ! 520: (_i_n_s_e_r_t _e_1 ... _e_m _a_f_t_e_r . $). similar to insert before ! 521: ! 522: ! 523: Printed: July 21, 1983 ! 524: ! 525: ! 526: ! 527: ! 528: ! 529: ! 530: ! 531: The LISP Editor 16-9 ! 532: ! 533: ! 534: except uses a instead of b. ! 535: ! 536: (_i_n_s_e_r_t _e_1 ... _e_m _f_o_r . $). similar to insert before ! 537: except uses : for b. ! 538: ! 539: (_r_e_p_l_a_c_e $ _w_i_t_h _e_1 ... _e_m) . here $ is the segment of the ! 540: command between replace and with. ! 541: ! 542: (_c_h_a_n_g_e $ _t_o _e_1 ... _e_m) . same as replace with. ! 543: ____________________________________________________________ ! 544: ! 545: ! 546: ! 547: ! 548: ! 549: 16.6. Extraction and Embedding Commands ! 550: ! 551: ____________________________________________________________ ! 552: ! 553: _E_X_T_R_A_C_T_I_O_N _A_N_D _E_M_B_E_D_D_I_N_G _C_O_M_M_A_N_D _S_U_M_M_A_R_Y ! 554: ! 555: (_x_t_r . $) . replaces the original current expression with ! 556: the expression that is current after performing (lcl . $). ! 557: ! 558: (_m_b_d _x) . x is a list, substitutes the current expression ! 559: for all instances of the atom * in x, and replaces the ! 560: current expression with the result of that substitution. ! 561: (mbd x) : x atomic, same as (mbd (x *)). ! 562: ! 563: (_e_x_t_r_a_c_t $_1 _f_r_o_m $_2) . extract is an editor command which ! 564: replaces the current expression with one of its subexpres- ! 565: sions (from any depth). ($1 is the segment between extract ! 566: and from.) example: if the current expression is (print ! 567: (cond ((null x) y) (t z))) then following (extract y from ! 568: cond), the current expression will be (print y). (extract 2 ! 569: -1 from cond), (extract y from 2), (extract 2 -1 from 2) ! 570: will all produce the same result. ! 571: ! 572: (_e_m_b_e_d $ _i_n . _x) . embed replaces the current expression ! 573: with a new expression which contains it as a subexpression. ! 574: ($ is the segment between embed and in.) example: (embed ! 575: print in setq x), (embed 3 2 in _r_e_t_u_r_n), (embed cond 3 1 in ! 576: (or * (null x))). ! 577: ____________________________________________________________ ! 578: ! 579: ! 580: ! 581: ! 582: ! 583: 16.7. Move and Copy Commands ! 584: ! 585: ! 586: 9 ! 587: ! 588: 9 Printed: July 21, 1983 ! 589: ! 590: ! 591: ! 592: ! 593: ! 594: ! 595: ! 596: The LISP Editor 16-10 ! 597: ! 598: ! 599: ____________________________________________________________ ! 600: ! 601: _M_O_V_E _A_N_D _C_O_P_Y _C_O_M_M_A_N_D _S_U_M_M_A_R_Y ! 602: ! 603: (_m_o_v_e $_1 _t_o _c_o_m . $_2) . ($1 is the segment between move and ! 604: to.) where com is before, after, or the name of a list com- ! 605: mand, e.g., :, n, etc. If $2 is nil, or (here), the current ! 606: position specifies where the operation is to take place. If ! 607: $1 is nil, the move command allows the user to specify some ! 608: place the current expression is to be moved to. if the ! 609: current expression is (a b d c), (move 2 to after 4) will ! 610: make the new current expression be (a c d b). ! 611: ! 612: (_m_v _c_o_m . $) . is the same as (move here to com . $). ! 613: ! 614: (_c_o_p_y $_1 _t_o _c_o_m . $_2) is like move except that the source ! 615: expression is not deleted. ! 616: ! 617: (_c_p _c_o_m . $). is like mv except that the source expression ! 618: is not deleted. ! 619: ____________________________________________________________ ! 620: ! 621: ! 622: ! 623: ! 624: ! 625: 16.8. Parentheses Moving Commands The commands ! 626: presented in this section permit modification of the ! 627: list structure itself, as opposed to modifying com- ! 628: ponents thereof. their effect can be described as ! 629: inserting or removing a single left or right ! 630: parenthesis, or pair of left and right parentheses. ! 631: ! 632: ____________________________________________________________ ! 633: ! 634: _P_A_R_E_N_T_H_E_S_E_S _M_O_V_I_N_G _C_O_M_M_A_N_D _S_U_M_M_A_R_Y ! 635: ! 636: (_b_i _n _m) . both in. inserts parentheses before the nth ! 637: element and after the mth element in the current expression. ! 638: example: if the current expression is (a b (c d e) f g), ! 639: then (bi 2 4) will modify it to be (a (b (c d e) f) g). (bi ! 640: n) : same as (bi n n). example: if the current expression ! 641: is (a b (c d e) f g), then (bi -2) will modify it to be (a b ! 642: (c d e) (f) g). ! 643: ! 644: (_b_o _n) . both out. removes both parentheses from the nth ! 645: element. example: if the current expression is (a b (c d ! 646: e) f g), then (bo d) will modify it to be (a b c d e f g). ! 647: ! 648: (_l_i _n) . left in. inserts a left parenthesis before the ! 649: nth element (and a matching right parenthesis at the end of ! 650: the current expression). example: if the current expres- ! 651: sion is (a b (c d e) f g), then (li 2) will modify it to be ! 652: ! 653: ! 654: Printed: July 21, 1983 ! 655: ! 656: ! 657: ! 658: ! 659: ! 660: ! 661: ! 662: The LISP Editor 16-11 ! 663: ! 664: ! 665: (a (b (c d e) f g)). ! 666: ! 667: (_l_o _n) . left out. removes a left parenthesis from the ! 668: nth element. all elements following the nth element are ! 669: deleted. example: if the current expression is (a b (c d e) ! 670: f g), then (lo 3) will modify it to be (a b c d e). ! 671: ! 672: (_r_i _n _m) . right in. move the right parenthesis at the ! 673: end of the nth element in to after the mth element. inserts ! 674: a right parenthesis after the mth element of the nth ele- ! 675: ment. The rest of the nth element is brought up to the ! 676: level of the current expression. example: if the current ! 677: expression is (a (b c d e) f g), (ri 2 2) will modify it to ! 678: be (a (b c) d e f g). ! 679: ! 680: (_r_o _n) . right out. move the right parenthesis at the end ! 681: of the nth element out to the end of the current expres- ! 682: sion. removes the right parenthesis from the nth element, ! 683: moving it to the end of the current expression. all elements ! 684: following the nth element are moved inside of the nth ! 685: element. example: if the current expression is (a b (c d e) ! 686: f g), (ro 3) will modify it to be (a b (c d e f g)). ! 687: ! 688: (_r _x _y) replaces all instances of x by y in the current ! 689: expression, e.g., (r caadr cadar). x can be the s- ! 690: expression (or atom) to be substituted for, or can be a pat- ! 691: tern which specifies that s-expression (or atom). ! 692: ! 693: (_s_w _n _m) switches the nth and mth elements of the current ! 694: expression. for example, if the current expression is (list ! 695: (cons (car x) (car y)) (cons (cdr y))), (sw 2 3) will ! 696: modify it to be (list (cons (cdr x) (cdr y)) (cons (car x) ! 697: (car y))). (sw car cdr) would produce the same result. ! 698: ____________________________________________________________ ! 699: ! 700: ! 701: ! 702: ! 703: ! 704: 16.8.1. Using to and thru ! 705: ! 706: to, thru, extract, embed, delete, replace, and move ! 707: can be made to operate on several contiguous ele- ! 708: ments, i.e., a segment of a list, by using the to ! 709: or thru command in their respective location ! 710: specifications. thru and to are intended to be ! 711: used in conjunction with extract, embed, delete, ! 712: replace, and move. to and thru can also be used ! 713: directly with xtr (which takes after a location ! 714: specification), as in (xtr (2 thru 4)) (from the ! 715: current expression). ! 716: ! 717: 9 ! 718: ! 719: 9 Printed: July 21, 1983 ! 720: ! 721: ! 722: ! 723: ! 724: ! 725: ! 726: ! 727: The LISP Editor 16-12 ! 728: ! 729: ! 730: ____________________________________________________________ ! 731: ! 732: _T_O _A_N_D _T_H_R_U _C_O_M_M_A_N_D _S_U_M_M_A_R_Y ! 733: ! 734: ($_1 _t_o $_2) . same as thru except last element not ! 735: included. ! 736: ! 737: ($_1 _t_o). same as ($1 thru -1) ! 738: ! 739: ($_1 _t_h_r_u $_2) . If the current expression is (a (b (c d) ! 740: (e) (f g h) i) j k), following (c thru g), the current ! 741: expression will be ((c d) (e) (f g h)). If both $1 and $2 ! 742: are numbers, and $2 is greater than $1, then $2 counts from ! 743: the beginning of the current expression, the same as $1. in ! 744: other words, if the current expression is (a b c d e f g), ! 745: (3 thru 4) means (c thru d), not (c thru f). in this case, ! 746: the corresponding bi command is (bi 1 $2-$1+1). ! 747: ! 748: ($_1 _t_h_r_u). same as ($_1 _t_h_r_u -_1). ! 749: ____________________________________________________________ ! 750: ! 751: ! 752: ! 753: ! 754: ! 755: 16.9. Undoing Commands each command that causes struc- ! 756: ture modification automatically adds an entry to the ! 757: front of undolst containing the information required ! 758: to restore all pointers that were changed by the com- ! 759: mand. The undo command undoes the last, i.e., most ! 760: recent such command. ! 761: ! 762: ____________________________________________________________ ! 763: ! 764: _U_N_D_O _C_O_M_M_A_N_D _S_U_M_M_A_R_Y ! 765: ! 766: _u_n_d_o . the undo command undoes most recent, structure ! 767: modification command that has not yet been undone, and ! 768: prints the name of that command, e.g., mbd undone. The edit ! 769: chain is then exactly what it was before the 'undone' com- ! 770: mand had been performed. ! 771: ! 772: !_u_n_d_o . undoes all modifications performed during this ! 773: editing session, i.e., this call to the editor. ! 774: ! 775: _u_n_b_l_o_c_k . removes an undo-block. If executed at a non- ! 776: blocked state, i.e., if undo or !undo could operate, types ! 777: not blocked. ! 778: ! 779: _t_e_s_t . adds an undo-block at the front of undolst. note ! 780: that test together with !undo provide a 'tentative' ! 781: mode for editing, i.e., the user can perform a number of ! 782: changes, and then undo all of them with a single !undo ! 783: ! 784: ! 785: Printed: July 21, 1983 ! 786: ! 787: ! 788: ! 789: ! 790: ! 791: ! 792: ! 793: The LISP Editor 16-13 ! 794: ! 795: ! 796: command. ! 797: ! 798: _u_n_d_o_l_s_t [_v_a_l_u_e]. each editor command that causes structure ! 799: modification automatically adds an entry to the front of ! 800: undolst containing the information required to restore all ! 801: pointers that were changed by the command. ! 802: ! 803: ?? prints the entries on undolst. The entries are listed ! 804: most recent entry first. ! 805: ____________________________________________________________ ! 806: ! 807: ! 808: ! 809: ! 810: ! 811: 16.10. Commands that Evaluate ! 812: ! 813: ____________________________________________________________ ! 814: ! 815: _E_V_A_L_U_A_T_I_O_N _C_O_M_M_A_N_D _S_U_M_M_A_R_Y ! 816: ! 817: _e . only when typed in, (i.e., (insert d before e) will ! 818: treat e as a pattern) causes the editor to call the ! 819: lisp interpreter giving it the next input as argument. ! 820: ! 821: (_e _x) evaluates x, and prints the result. (e x t) same ! 822: as (e x) but does not print. ! 823: ! 824: (_i _c _x_1 ... _x_n) same as (c y1 ... yn) where yi=(eval xi). ! 825: example: (i 3 (cdr foo)) will replace the 3rd element of ! 826: the current expression with the cdr of the value of foo. (i ! 827: n foo (car fie)) will attach the value of foo and car of the ! 828: value of fie to the end of the current expression. (i f= ! 829: foo t) will search for an expression eq to the value of foo. ! 830: If c is not an atom, it is evaluated as well. ! 831: ! 832: (_c_o_m_s _x_1 ... _x_n) . each xi is evaluated and its value ! 833: executed as a command. The i command is not very convenient ! 834: for computing an entire edit command for execution, since ! 835: it computes the command name and its arguments separately. ! 836: also, the i command cannot be used to compute an atomic ! 837: command. The coms and comsq commands provide more gen- ! 838: eral ways of computing commands. (coms (cond (x (list 1 ! 839: x)))) will replace the first element of the current expres- ! 840: sion with the value of x if non-nil, otherwise do nothing. ! 841: (nil as a command is a nop.) ! 842: ! 843: (_c_o_m_s_q _c_o_m_1 ... _c_o_m_n) . executes com1 ... comn. comsq is ! 844: mainly useful in conjunction with the coms command. for ! 845: example, suppose the user wishes to compute an entire list ! 846: of commands for evaluation, as opposed to computing each ! 847: command one at a time as does the coms command. he would ! 848: then write (coms (cons (quote comsq) x)) where x computed ! 849: ! 850: ! 851: Printed: July 21, 1983 ! 852: ! 853: ! 854: ! 855: ! 856: ! 857: ! 858: ! 859: The LISP Editor 16-14 ! 860: ! 861: ! 862: the list of commands, e.g., (coms (cons (quote comsq) ! 863: (get foo (quote commands)))) ! 864: ____________________________________________________________ ! 865: ! 866: ! 867: ! 868: ! 869: ! 870: 16.11. Commands that Test ! 871: ! 872: ____________________________________________________________ ! 873: ! 874: _T_E_S_T_I_N_G _C_O_M_M_A_N_D _S_U_M_M_A_R_Y ! 875: ! 876: (_i_f _x) generates an error unless the value of (eval x) is ! 877: non-nil, i.e., if (eval x) causes an error or (eval x)=nil, ! 878: if will cause an error. (if x coms1 coms2) if (eval x) is ! 879: non-nil, execute coms1; if (eval x) causes an error or is ! 880: equal to nil, execute coms2. (if x coms1) if (eval x) ! 881: is non-nil, execute coms1; otherwise generate an error. ! 882: ! 883: (_l_p . _c_o_m_s) . repeatedly executes coms, a list of commands, ! 884: until an error occurs. (lp f print (n t)) will ! 885: attach a t at the end of every print expression. (lp f ! 886: print (if (## 3) nil ((n t)))) will attach a t at the end ! 887: of each print expression which does not already have a ! 888: second argument. (i.e. the form (## 3) will cause an ! 889: error if the edit command 3 causes an error, thereby select- ! 890: ing ((n t)) as the list of commands to be executed. The if ! 891: could also be written as (if (cddr (##)) nil ((n t))).). ! 892: ! 893: (_l_p_q . _c_o_m_s) same as lp but does not print n occurrences. ! 894: ! 895: (_o_r_r _c_o_m_s_1 ... _c_o_m_s_n) . orr begins by executing coms1, a ! 896: list of commands. If no error occurs, orr is finished. ! 897: otherwise, orr restores the edit chain to its original ! 898: value, and continues by executing coms2, etc. If none of ! 899: the command lists execute without errors, i.e., the orr ! 900: "drops off the end", orr generates an error. otherwise, the ! 901: edit chain is left as of the completion of the first command ! 902: list which executes without error. ! 903: ____________________________________________________________ ! 904: ! 905: ! 906: ! 907: ! 908: ! 909: 16.12. Editor Macros ! 910: ! 911: Many of the more sophisticated branching commands in ! 912: the editor, such as orr, if, etc., are most often ! 913: used in conjunction with edit macros. The macro ! 914: feature permits the user to define new commands and ! 915: ! 916: ! 917: Printed: July 21, 1983 ! 918: ! 919: ! 920: ! 921: ! 922: ! 923: ! 924: ! 925: The LISP Editor 16-15 ! 926: ! 927: ! 928: thereby expand the editor's repertoire. (however, ! 929: built in commands always take precedence over mac- ! 930: ros, i.e., the editor's repertoire can be expanded, ! 931: but not modified.) macros are defined by using the m ! 932: command. ! 933: ! 934: (_m _c . _c_o_m_s) for c an atom, m defines c as an atomic ! 935: command. (if a macro is redefined, its new defini- ! 936: tion replaces its old.) executing c is then the same ! 937: as executing the list of commands coms. macros ! 938: can also define list commands, i.e., commands that ! 939: take arguments. (m (c) (arg[1] ... arg[n]) . coms) c ! 940: an atom. m defines c as a list command. executing (c ! 941: e1 ... en) is then performed by substituting e1 ! 942: for arg[1], ... en for arg[n] throughout coms, ! 943: and then executing coms. a list command can be ! 944: defined via a macro so as to take a fixed or ! 945: indefinite number of 'arguments'. The form given ! 946: above specified a macro with a fixed number of argu- ! 947: ments, as indicated by its argument list. if the of ! 948: arguments. (m (c) args . coms) c, args both atoms, ! 949: defines c as a list command. executing (c e1 ... ! 950: en) is performed by substituting (e1 ... en), i.e., ! 951: cdr of the command, for args throughout coms, and then ! 952: executing coms. ! 953: ! 954: (m bp bk up p) will define bp as an atomic command ! 955: which does three things, a bk, an up, and a p. note ! 956: that macros can use commands defined by macros as well ! 957: as built in commands in their definitions. for ! 958: example, suppose z is defined by (m z -1 (if (null ! 959: (##)) nil (p))), i.e. z does a -1, and then if the ! 960: current expression is not nil, a p. now we can define ! 961: zz by (m zz -1 z), and zzz by (m zzz -1 -1 z) or (m ! 962: zzz -1 zz). we could define a more general bp by (m ! 963: (bp) (n) (bk n) up p). (bp 3) would perform (bk ! 964: 3), followed by an up, followed by a p. The com- ! 965: mand second can be defined as a macro by (m (2nd) x ! 966: (orr ((lc . x) (lc . x)))). ! 967: ! 968: Note that for all editor commands, 'built in' com- ! 969: mands as well as commands defined by macros, atomic ! 970: definitions and list definitions are completely ! 971: independent. in other words, the existence of an ! 972: atomic definition for c in no way affects the treat- ! 973: ment of c when it appears as car of a list command, ! 974: and the existence of a list definition for c in no way ! 975: affects the treatment of c when it appears as an ! 976: atom. in particular, c can be used as the name of ! 977: either an atomic command, or a list command, or both. ! 978: in the latter case, two entirely different defini- ! 979: tions can be used. note also that once c is ! 980: defined as an atomic command via a macro definition, ! 981: ! 982: ! 983: Printed: July 21, 1983 ! 984: ! 985: ! 986: ! 987: ! 988: ! 989: ! 990: ! 991: The LISP Editor 16-16 ! 992: ! 993: ! 994: it will not be searched for when used in a location ! 995: specification, unless c is preceded by an f. (insert ! 996: -- before bp) would not search for bp, but instead ! 997: perform a bk, an up, and a p, and then do the inser- ! 998: tion. The corresponding also holds true for list com- ! 999: mands. ! 1000: ! 1001: (_b_i_n_d . _c_o_m_s) bind is an edit command which is ! 1002: useful mainly in macros. it binds three dummy vari- ! 1003: ables #1, #2, #3, (initialized to nil), and then exe- ! 1004: cutes the edit commands coms. note that these ! 1005: bindings are only in effect while the commands are ! 1006: being executed, and that bind can be used recursively; ! 1007: it will rebind #1, #2, and #3 each time it is ! 1008: invoked. ! 1009: ! 1010: _u_s_e_r_m_a_c_r_o_s [_v_a_l_u_e]. this variable contains the ! 1011: users editing macros . if you want to save your mac- ! 1012: ros then you should save usermacros. you should ! 1013: probably also save editcomsl. ! 1014: ! 1015: _e_d_i_t_c_o_m_s_l [_v_a_l_u_e]. editcomsl is the list of "list ! 1016: commands" recognized by the editor. (these are the ! 1017: ones of the form (command arg1 arg2 ...).) ! 1018: ! 1019: ! 1020: ! 1021: ! 1022: 16.13. Miscellaneous Editor Commands ! 1023: ! 1024: ____________________________________________________________ ! 1025: ! 1026: _M_I_S_C_E_L_L_A_N_E_O_U_S _E_D_I_T_O_R _C_O_M_M_A_N_D _S_U_M_M_A_R_Y ! 1027: ! 1028: _o_k . Exits from the editor. ! 1029: ! 1030: _n_i_l . Unless preceded by f or bf, is always a null opera- ! 1031: tion. ! 1032: ! 1033: _t_t_y: . Calls the editor recursively. The user can then ! 1034: type in commands, and have them executed. The tty: command ! 1035: is completed when the user exits from the lower editor ! 1036: (with ok or stop). the tty: command is extremely use- ! 1037: ful. it enables the user to set up a complex operation, ! 1038: and perform interactive attention-changing commands part ! 1039: way through it. for example the command (move 3 to after ! 1040: cond 3 p tty:) allows the user to interact, in effect, ! 1041: within the move command. he can verify for himself ! 1042: that the correct location has been found, or complete the ! 1043: specification "by hand". in effect, tty: says "I'll tell you ! 1044: what you should do when you get there." ! 1045: ! 1046: _s_t_o_p . exits from the editor with an error. mainly for use ! 1047: ! 1048: ! 1049: Printed: July 21, 1983 ! 1050: ! 1051: ! 1052: ! 1053: ! 1054: ! 1055: ! 1056: ! 1057: The LISP Editor 16-17 ! 1058: ! 1059: ! 1060: in conjunction with tty: commands that the user wants to ! 1061: abort. since all of the commands in the editor are errset ! 1062: protected, the user must exit from the editor via a command. ! 1063: stop provides a way of distinguishing between a successful ! 1064: and unsuccessful (from the user's standpoint) editing ses- ! 1065: sion. ! 1066: ! 1067: _t_l . tl calls (top-level). to return to the editor just ! 1068: use the _r_e_t_u_r_n top-level command. ! 1069: ! 1070: _r_e_p_a_c_k . permits the 'editing' of an atom or string. ! 1071: ! 1072: (_r_e_p_a_c_k $) does (lc . $) followed by repack, e.g. (repack ! 1073: this@). ! 1074: ! 1075: (_m_a_k_e_f_n _f_o_r_m _a_r_g_s _n _m) . makes (car form) an expr with the ! 1076: nth through mth elements of the current expression with ! 1077: each occurrence of an element of (cdr form) replaced by ! 1078: the corresponding element of args. The nth through mth ! 1079: elements are replaced by form. ! 1080: ! 1081: (_m_a_k_e_f_n _f_o_r_m _a_r_g_s _n). same as (makefn form args n n). ! 1082: ! 1083: (_s _v_a_r . $) . sets var (using setq) to the current expres- ! 1084: sion after performing (lc . $). (s foo) will set ! 1085: foo to the current expression, (s foo -1 1) will set foo to ! 1086: the first element in the last element of the current expres- ! 1087: sion. ! 1088: ____________________________________________________________ ! 1089: ! 1090: ! 1091: ! 1092: ! 1093: ! 1094: 16.14. Editor Functions ! 1095: ! 1096: ! 1097: (editf s_x1 ...) ! 1098: ! 1099: SIDE EFFECT: edits a function. s_x1 is the name of the ! 1100: function, any additional arguments are an ! 1101: optional list of commands. ! 1102: ! 1103: RETURNS: s_x1. ! 1104: ! 1105: NOTE: if s_x1 is not an editable function, editf gen- ! 1106: erates an fn not editable error. ! 1107: ! 1108: ! 1109: ! 1110: ! 1111: ! 1112: 9 ! 1113: ! 1114: 9 Printed: July 21, 1983 ! 1115: ! 1116: ! 1117: ! 1118: ! 1119: ! 1120: ! 1121: ! 1122: The LISP Editor 16-18 ! 1123: ! 1124: ! 1125: (edite l_expr l_coms s_atm)) ! 1126: edits an expression. its value is the last element of ! 1127: (editl (list l_expr) l_coms s_atm nil nil). ! 1128: ! 1129: ! 1130: (editracefn s_com) ! 1131: is available to help the user debug complex edit macros, or ! 1132: subroutine calls to the editor. editracefn is to be ! 1133: defined by the user. whenever the value of editracefn is ! 1134: non-nil, the editor calls the function editracefn ! 1135: before executing each command (at any level), giving it ! 1136: that command as its argument. editracefn is initially equal ! 1137: to nil, and undefined. ! 1138: ! 1139: ! 1140: (editv s_var [ g_com1 ... ]) ! 1141: ! 1142: SIDE EFFECT: similar to editf, for editing values. ! 1143: editv sets the variable to the value ! 1144: returned. ! 1145: ! 1146: RETURNS: the name of the variable whose value was ! 1147: edited. ! 1148: ! 1149: ! 1150: (editp s_x) ! 1151: ! 1152: SIDE EFFECT: similar to editf for editing property ! 1153: lists. used if x is nil. ! 1154: ! 1155: RETURNS: the atom whose property list was edited. ! 1156: ! 1157: ! 1158: (editl coms atm marklst mess) ! 1159: ! 1160: SIDE EFFECT: editl is the editor. its first argument ! 1161: is the edit chain, and its value is an ! 1162: edit chain, namely the value of l at the ! 1163: time editl is exited. (l is a special ! 1164: variable, and so can be examined or set by ! 1165: edit commands. ^ is equivalent to (e ! 1166: (setq l(last l)) t).) coms is an optional ! 1167: list of commands. for interactive edit- ! 1168: ing, coms is nil. in this case, editl ! 1169: types edit and then waits for input from ! 1170: the teletype. (if mess is not nil editl ! 1171: types it instead of edit. for example, ! 1172: the tty: command is essentially (setq l ! 1173: (editl l nil nil nil (quote tty:))).) ! 1174: exit occurs only via an ok, stop, or save ! 1175: command. If coms is not nil, no message ! 1176: is typed, and each member of coms is ! 1177: treated as a command and executed. If an ! 1178: ! 1179: ! 1180: Printed: July 21, 1983 ! 1181: ! 1182: ! 1183: ! 1184: ! 1185: ! 1186: ! 1187: ! 1188: The LISP Editor 16-19 ! 1189: ! 1190: ! 1191: error occurs in the execution of one of ! 1192: the commands, no error message is printed ! 1193: , the rest of the commands are ignored, ! 1194: and editl exits with an error, i.e., the ! 1195: effect is the same as though a stop com- ! 1196: mand had been executed. If all commands ! 1197: execute successfully, editl returns the ! 1198: current value of l. marklst is the list ! 1199: of marks. on calls from editf, atm is the ! 1200: name of the function being edited; on ! 1201: calls from editv, the name of the vari- ! 1202: able, and calls from editp, the atom of ! 1203: which some property of its property list ! 1204: is being edited. The property list of atm ! 1205: is used by the save command for saving the ! 1206: state of the edit. save will not save ! 1207: anything if atm=nil i.e., when editing ! 1208: arbitrary expressions via edite or editl ! 1209: directly. ! 1210: ! 1211: ! 1212: (editfns s_x [ g_coms1 ... ]) ! 1213: fsubr function, used to perform the same editing operations ! 1214: on several functions. editfns maps down the list of func- ! 1215: tions, prints the name of each function, and calls the edi- ! 1216: tor (via editf) on that function. ! 1217: ! 1218: EXAMPLE: editfns foofns (r fie fum)) will change every ! 1219: fie to fum in each of the functions on ! 1220: foofns. ! 1221: ! 1222: NOTE: the call to the editor is errset protected, ! 1223: so that if the editing of one function causes an ! 1224: error, editfns will proceed to the next func- ! 1225: tion. in the above example, if one of the ! 1226: functions did not contain a fie, the r command ! 1227: would cause an error, but editing would con- ! 1228: tinue with the next function. The value of ! 1229: editfns is nil. ! 1230: ! 1231: ! 1232: (edit4e pat y) ! 1233: ! 1234: SIDE EFFECT: is the pattern match routine. ! 1235: ! 1236: RETURNS: t if pat matches y. see edit-match for defini- ! 1237: tion of 'match'. ! 1238: ! 1239: NOTE: before each search operation in the editor ! 1240: begins, the entire pattern is scanned for ! 1241: atoms or strings that end in at-signs. These ! 1242: are replaced by patterns of the form (cons ! 1243: (quote /@) (explodec atom)). from the ! 1244: ! 1245: ! 1246: Printed: July 21, 1983 ! 1247: ! 1248: ! 1249: ! 1250: ! 1251: ! 1252: ! 1253: ! 1254: The LISP Editor 16-20 ! 1255: ! 1256: ! 1257: standpoint of edit4e, pattern type 5, atoms or ! 1258: strings ending in at-signs, is really "if ! 1259: car[pat] is the atom @ (at-sign), pat will match ! 1260: with any literal atom or string whose ini- ! 1261: tial character codes (up to the @) are the same ! 1262: as those in cdr[pat]." if the user wishes to ! 1263: call edit4e directly, he must therefore convert ! 1264: any patterns which contain atoms or strings ! 1265: ending in at-signs to the form recognized by ! 1266: edit4e. this can be done via the function ! 1267: editfpat. ! 1268: ! 1269: (editfpat pat flg) ! 1270: makes a copy of pat with all patterns of type 5 (see edit- ! 1271: match) converted to the form expected by edit4e. flg should ! 1272: be passed as nil (flg=t is for internal use by the editor). ! 1273: ! 1274: ! 1275: (editfindp x pat flg) ! 1276: ! 1277: NOTE: Allows a program to use the edit find command as ! 1278: a pure predicate from outside the editor. x is ! 1279: an expression, pat a pattern. The value of edit- ! 1280: findp is t if the command f pat would succeed, ! 1281: nil otherwise. editfindp calls editfpat to con- ! 1282: vert pat to the form expected by edit4e, unless ! 1283: flg=t. if the program is applying editfindp to ! 1284: several different expressions using the same pat- ! 1285: tern, it will be more efficient to call editfpat ! 1286: once, and then call editfindp with the converted ! 1287: pattern and flg=t. ! 1288: ! 1289: ! 1290: (## g_com1 ...) ! 1291: ! 1292: RETURNS: what the current expression would be after ! 1293: executing the edit commands com1 ... starting ! 1294: from the present edit chain. generates an ! 1295: error if any of comi cause errors. The ! 1296: current edit chain is never changed. example: ! 1297: (i r (quote x) (## (cons ..z))) replaces all ! 1298: x's in the current expression by the first ! 1299: cons containing a z. ! 1300: ! 1301: ! 1302: ! 1303: ! 1304: ! 1305: ! 1306: ! 1307: ! 1308: ! 1309: 9 ! 1310: ! 1311: 9 Printed: July 21, 1983 ! 1312: ! 1313: ! 1314:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.