Enter your search terms Submit search form
	Web pdp-10.trailing-edge.com

-*-Text-*- 

This is the DOCOND source from which INTER.GUIDE and the
INFO file for INTER are generated.

{Alternatives:LPT,XGP,INFO} {Flag:?LPT} {Flag:?XGP}
{Flag:?INFO}

Set up GUIDE to be LPT or XGP.
{Implies:+LPT=>+GUIDE}
{Implies:+XGP=>+GUIDE}
{Implies:+INFO=>-GUIDE}
{Flag:?GUIDE}

{Flag:+TRUTH}   Always true, for unconditional replacements.

{Char Replace:-XGP=>->^}

Note that the characters  followed by 

 cause themselves and the
following line to be conditionalized for the INFO version only.
It should be the INFO node header.  The line will simply be deleted in the GUIDE
version, so no conditionals should begin or end within it unless
completely contained within it.

The best way to put an INFO footnote at the end of a paragraph is: {+INFO:
*Note footnote: node, here is the footnote.}

"Chapter:", "Section:" or "Subsection:" at the front of the line
is a no-op in the INFO version, but in the GUIDE version it puts
@CHAPTER(...), etc., around the rest of the line.

{Char Replace:+INFO=>Chapter:->}
{Char Replace:+GUIDE=>Chapter:-->>0L I@ S: -DI[ :L I]}
{Char Replace:+INFO=>Subsection:->}    Must precede Section!
{Char Replace:+GUIDE=>Subsection:-->>0L I@ S: -DI[ :L I]}
{Char Replace:+INFO=>Section:->}
{Char Replace:+GUIDE=>Section:-->>0L I@ S: -DI[ :L I]}
{Char Replace:+INFO=>
Paragraph:->
}
{Char Replace:+GUIDE=>
Paragraph:-->>0L I@ S: -DI[ :L I]}
{Char Replace:+GUIDE=>

-->>2R 2K}

SCRIBE requires two @'s whenever one is wanted.  That's the way it
should be in this file.  For the INFO version, we collapse them.
The SCRIBE "@:" construct must be used when a sentence ends with a
one-letter word.  "@." must be used when a sentence end appears to
occur after an abbreviation.

{Char Replace:+INFO=>@@->@}
{Char Replace:+INFO=>@:->.}
{Char Replace:+INFO=>@.->.}

An indented list of commands should be surrounded by lines
saying simply 
  Textunit:@Commands[
and
  Textunit:]

These Textunit lines are not significant in that they do not
contribute CRLFs to the output (at least in the INFO version).
The lines in between will have all leading whitespace deleted to
produce the SCRIBE input.  The first tab within a line (not at the
front) will turn into a @\ command, and that line will get a blank
line in front of it.
You can control the indentations used by choosing @Commands,
or @WideCommands, @DoubleWideCommands, or @GrossCommands
Other things like @Example and @Quotation are also reasonable.

{Char Replace:+INFO=>Textunit:-->> 0LK}

{Char Replace:+GUIDE=>Textunit:@-->>
  R0K L .[0 
  STextunit: 0K
  .[1
  Q0J FSZ-Q1F[VZ
  < .-Z;
    @F 	K
 I :FB	"L -D  @F	 K I@\  0L I
'
    L >
  Q0J }

The SCRIBE constructs @U and @I cannot be used.  Instead, use @XXU and
@XXI for underlining and italicizing.  The name change is to make it
easier to find them to delete them from the INFO version.
Alternatively, use @XXUU and @XXII, which will turn into all caps in
the INFO version.

{Char Replace:+INFO=>@XX-->>
  1A-(2A)"'E[1
  -3D .[0 S[ Q0,.K
  S] -D
  Q1"N Q0,.@FC' }

To put things in the index, do
Indexentry:foo,bar,ugh

{Char Replace:+INFO=>Indexentry:-->> 0lk}
{Char Replace:-INFO=>Indexentry:-->>
  0k
  < :@f"e 0;'
    i@index 123i
    s,

    fkc 125i
    1a-,"e d'
  >}
{end}
{+INFO: -*-Text-*-
This file documents INTER, an interface between EMACS and INTERLISP.  
Don't edit this file! It is produced by DOCOND from the INTED file.
}

File: INTER,  Node: Top,  Up: (DIR), Next:Intro
{+GUIDE:Chapter: An Interface Between EMACS and INTERLISP.
Section: Introduction
}
INTER provides a means for using EMACS from within INTERLISP to edit or create
LISP functions, variables, etc.  You can learn enough to use INTER from
the{+INFO: node Intro.}{+GUIDE: following section.  In the remainder of this
section, we discuss two advantages to using EMACS from within INTERLISP.}
{+INFO:
* Menu:
* Intro::	A quick course.
* Functions::   The INTERLISP routines.
* Commands::	The EMACS commands.
* Syntax::	Details about lexical analysis and pretty-printing.
* Hints::	A miscellany.
* EDITE::	Using EMACS from within the structure editor.
}
{+GUIDE:First, the interface makes it possible to use EMACS in
place of the standard
INTERLISP editor (the one described in Chapter 9 of the INTERLISP manual).  The
standard editor, which was designed long before high speed terminals were
widely available, does not distinguish between those users who are working on
100 baud teletypes and those who are using high speed display terminals.  In
the standard editor, the user often types P and PP commands to see where he is
and what he has done.  That is probably just right for a 100 baud teletype.
But it is silly for a fast display terminal, with its ability to keep
constantly before your eyes what you are working on.  Until EMACS was modified
to run on TOPS-20, however, the only display oriented editors working on
TOPS-20 were designed mostly to edit text, not INTERLISP code.  Editing
INTERLISP code with text oriented editors is arguably more painful than using
the standard INTERLISP editor, which knows so much about the structure of
INTERLISP expressions.  But EMACS has been designed to make editing LISP code
easy.  Using the "control-meta" commands of EMACS, it is possible to move over,
grab, or delete entire LISP expressions.

Second, when you are typing to INTERLISP, you are already using a text editor,
namely the line editor.  But the line editor is a poor editor.  It offers only
the primitive editing commands hung on the characters delete, ^U, ^W, and ^R.
If you use the interface between EMACS and INTERLISP described in this
document, you have far more control over your terminal input to INTERLISP.  You
can arbitrarily backup and edit an expression before giving it to INTERLISP to
evaluate.  Furthermore, with EMACS it becomes very difficult to make
parenthesis mistakes:  if you type Linefeed instead of Return, the next line is
indented to an appropriate place, a la pretty printing.  And when you type a
closing parenthesis, the cursor momentarily bounces to the corresponding open
parenthesis.

The INTER system works on TOPS-20, Release 3, and
on TENEX 134, using  the 133 version of INTERLISP
(and hopefully with later versions).  It definitely does not work with some
earlier versions of INTERLISP.}


File: INTER,	Node: INTRO,	Up: Top,   Next: Functions
{+GUIDE:Section: A Short Course
indexentry:INTER.COM,START.EMACS,CF,C-T E
}
Suppose you are in INTERLISP and would like to edit a function.  LOAD the file
<EMACS>INTER.COM. 

To edit the function FOO call CF(FOO) instead of EDITF(FOO).  FOO's definition
is written into the EMACS buffer surrounded with a (DEFINEQ ...).  Edit the
definition with EMACS.  When you are finished editing, return to INTERLISP
with C-T U.  INTERLISP will read the (modified) "(DEFINEQ ... )" in the EMACS
buffer and execute it.  When the DEFINEQ is executed, the INTERLISP definition
of the function is changed.  The DEFINEQ is executed as though you had typed
it in at the top level.  Hence the DEFINEQ may be UNDOne, FIXed, ??ed, etc.
INTERLISP's file package keeps track of changes to functions via DEFINEQ as
well as changes via EDITF.

indexentry:C-T Z,EMACS
While you are editing a function in EMACS, you can return without effect to
INTERLISP with C-T Z.  INTERLISP will not change the definition of the function
you are editing.  You can later continue editing in EMACS where you left off by
calling (EMACS T).

To define a new function (in general, to construct any expression for
evaluation by INTERLISP), enter EMACS by calling (EMACS).  You are placed in an
empty EMACS buffer.  Exit to INTERLISP with C-T U.

indexentry:CV,CP,CREC
To edit a variable, property list, or record, use CV, CP, or CREC instead of
EDITV, EDITP, or EDITREC.

There are more INTERLISP functions and EMACS commands for INTER.  They are
described in the next two {+INFO: nodes.} {+GUIDE: sections.}



File: INTER,	Node: Functions, Up: Top,   Next: Commands
{+GUIDE:Section: The INTERLISP Routines}
Here are the top-level functions that are defined in INTERLISP by the loading
of <EMACS>INTER.COM.
indexentry:START.EMACS
{+INFO:* Menu:
* CF::		CF edits a function.
* CFNS::	CFNS edits several functions.
* CV::		CV edits a variable.
* CP::		CP edits a property list.				
* CREC::	CREC edits a record declaration.
* Continuing::	EMACS continues with an empty buffer, or just continues.
* Evaluation::	E. evaluates the expression after the cursor.
* Multiple::	E! evaluates several expressions after the cursor.
* DIYS::	DOWN lets you do it yourself.
* REFRESH::	REFRESH refreshes the display.
* DRIBBLE::	EDIT.DRIBBLE.FILE inserts the DRIBBLE file in an EMACS buffer.
* Starting::	START.EMACS creates an EMACS fork.
* FLUSH::	FLUSH.EMACS gets rid of a fork created by this interface.
}



File: INTER,	Node: CF, Up: Functions, Next: CFNS
indexentry:CF

CF[FNNAME] inserts the definition of a function at the bottom of the EMACS
virtual buffer and dives down to EMACS with the cursor at the beginning of the
insertion.  The definition is written inside a "(DEFINEQ ...)" and hence is
suitable for later execution with C-T U or E.[].  The definition of the
function is fetched much the way that EDITF does except that no spelling
correction is attempted.  If FNNAME is NIL, the value of LASTWORD is used.  If
FNNAME has a LISTP definition, the unadvised, unbroken version is used (unless
the result is not LISTP).  Else if FNNAME has an EXPR property it is used.
Otherwise, the definition is taken from the first file said to contain it.
WHEREIS is used to find the file and filemaps are used to get the definition
into the EMACS buffer quickly.  If EMACS.FASTREADFLG is NIL (default T), then
the definition is first read into LISP then prettyprinted for EMACS.
Setting EMACS.FASTREADFLG to NIL is useful if there are square brackets in the
definition of the function.  If you exit from EMACS with C-T Z, the function's
LISP definition is not changed; to cause the redefinition, use E. or E!, or
else exit from EMACS with C-T U.



File: INTER,	Node: CFNS, Up: Functions, Next: CV
indexentry:CFNS

CFNS[LST] behaves like CF except that it takes a list of function names, and a
definition of each is placed in the EMACS buffer.



File: INTER,	Node: CV, Up: Functions, Next: CP
indexentry:CV

CV[X] writes a variable name and definition inside an "(RPAQQ ...  )" into the
EMACS buffer and descends to EMACS.  The INTERLISP value of the variable is not
changed if you return to INTERLISP with C-T Z; to set the variable, use E.  or
E! or else exit from EMACS with C-T U.



File: INTER,	Node: CP, Up: Functions, Next: CREC
indexentry:CP

CP[X] writes a litatom and its property list inside a "(SETPROPLIST ... )" into
the EMACS buffer and descends to EMACS.  The property list is not changed if
you return to INTERLISP with C-T Z; to set the property list, use E. or E!  or
else exit from EMACS with C-T U.



File: INTER, Node: CREC, Up: Functions, Next: Continuing
indexentry:CREC

CREC[X] writes an INTERLISP record declaration into the EMACS buffer and
descends to EMACS.  The declaration is not changed if you return to INTERLISP
with C-T Z; to declare the edited declaration, use E. or E! or else exit from
EMACS with C-T U.



File: INTER,	Node: Continuing, Up: Functions, Next: Evaluation
indexentry:EMACS

EMACS[OLDBUFFER] returns to EMACS.  If OLDBUFFER is non-NIL, you are in the
same EMACS state you were when you last left.  If OLDBUFFER is NIL, then you
are placed in an empty virtual buffer, which is useful if you want to write a
definition from scratch.



File: INTER,	Node: Evaluation, Up: Functions, Next: Multiple
indexentry:E.

E.[] reads and then executes the expression starting at the cursor in the EMACS
buffer.  The execution is recorded as an event on the INTERLISP history list
just as if it had been typed into the top level READ-PRINT-EVAL loop.  The
appearance of the execution on your terminal is faked by printing it shallow.
But the event is really there, so ??, REDO, UNDO, etc. all work.



File: INTER,	Node: Multiple, Up: Functions, Next: DIYS
indexentry:E!

E![N] reads and executes expressions starting at the cursor in the EMACS
buffer.  If N is a number, then N expressions are read and executed.  If N is
NIL, then all the expressions in the buffer after the cursor are executed.



File: INTER,	Node: DIYS, Up: Functions, Next: REFRESH
indexentry:DOWN

DOWN[NEGATE.ARG.FLG] passes control to EMACS.  CF, CV, CP, and CREC all result
in calls to DOWN.  DOWN causes EMACS to read from the file that is the value of
the INTERLISP variable EMACS.TEMP.FILE.  If NEGATE.ARG.FLG is NIL, then EMACS
inserts at the end of the virtual buffer named *FROM-LISP* everything in the
file EMACS.TEMP.FILE up to the current file pointer (not the end of the file).
If there is something to insert (i.e., the file pointer is not 0), then the
virtual buffer boundaries are narrowed to what is inserted.  (The buffer
boundaries can be widened to the whole buffer with ^R Set Bounds Full.)  If
NEGATE.ARG.FLG is not NIL, the text that would have been inserted is placed in
EMACS' register A and executed.  (Thus to get EMACS to insert text at the
bottom of the virtual buffer named *FROM-LISP*, simply PRINT to EMACS.TEMP.FILE
and call (DOWN).)  Upon return to INTERLISP, the file pointer of
EMACS.TEMP.FILE is set to 0.  The screen is refreshed with NUMBER.OF.LINES of
text from the dribble file unless (a) the terminal is not a display terminal,
(b) the user had a dribble file running at the time START.EMACS was called, or
(c) because the user has called DRIBBLE since START.EMACS was called, there is
no longer a dribble file or it is not the one created by START.EMACS.
NUMBER.OF.LINES is set in START.EMACS, but you can reset it.



File: INTER,	Node: REFRESH, Up: Functions, Next: DRIBBLE
indexentry:REFRESH

REFRESH[] causes the last screenful of characters in the dribble file to be
printed on your terminal.  Your screen is refreshed when you return to
INTERLISP from EMACS under certain conditions enumerated in the documentation
for DOWN.



File: INTER,	Node: DRIBBLE, Up: Functions, Next: Starting
indexentry:EDIT.DRIBBLE.FILE

EDIT.DRIBBLE.FILE[] runs EMACS after inserting the dribble file into an EMACS
buffer called *LISP-DRIBBLE*.  This command is useful for reviewing LISP
terminal output that has rolled off the screen.  The previous contents of the
buffer *LISP-DRIBBLE* are deleted.



File: INTER,	Node: Starting, Up: Functions, Next: FLUSH

indexentry:START.EMACS

START.EMACS[] creates an inferior process (i.e., fork), loads EMACS into the
process, and returns to INTERLISP.  This function is called by the above
functions if the EMACS-INTERLISP interface has not been initialized.  Two
temporary files are created for communication between EMACS and INTERLISP.
Furthermore, if the user does not currently have a dribble file open, a
temporary dribble file is opened so that on return to INTERLISP from EMACS the
display can be refreshed with some of the characters that were there before
the descent to EMACS.



File: INTER,	Node: FLUSH, Up: Functions
indexentry:FLUSH.EMACS

FLUSH.EMACS[] kills the current EMACS created by START.EMACS, if there is one.
Among other things, FLUSH.EMACS kills the EMACS process, closes the two files
that EMACS and INTERLISP use to communicate, and releases a few INTERLISP
pages.  If START.EMACS created a dribble file, then it will be closed by
FLUSH.EMACS if it is still open.  If START.EMACS created a dribble file, no
harm will result if you close it or create another; but if you do, DOWN and
REFRESH will not refresh your screen.  If you close EMACS.TEMP.FILE or
EMACS.MAP.FILE, the EMACS-INTERLISP interface is as good as dead.  CLOSEALL()
will not close them, but CLOSEF and CLOSEALL(T) will.  Since all of the files
created by this EMACS-INTERLISP interface are temporary, they will all be
deleted and expunged when you log off.



File: INTER,	Node: Commands,	Up: Top,   Next: Syntax
{+GUIDE:Section: The EMACS Commands
indexentry:C-T,C-T C-T
}
All of the INTER commands in EMACS begin with the prefix character C-T.  A
prefix character is a character like C-X that expects another character to be
typed.  The old definition of C-T, ^R Transpose Characters, is hung on C-T C-T.

{+INFO:* Menu:
* Exit::	Exit to LISP but don't evaluate anything in the buffer.
* Up::		Exit to LISP and evaluate everything in the buffer.
* EVAL::	Exit to LISP and EVAL the expression after the cursor.
* DEFINEQ::	Exit to LISP and DEFINEQ the expression after the cursor.
* QUOTE::	Exit to LISP and QUOTE the expression after the cursor.
* PP::		Pretty-print the virtual buffer with PRINTDEF.
* EV&PP::	EVAL the expression after the cursor & PRINT into other window.
* SHALLOW::	Shallow print the expression into the other window. 
* ARGS::	PRINT the arglist of the expression into the other window.
* HELP::	The list of C-T commands.
* FIND::	Tell the structure editor to move.
* REPLACE::	Tell the structure editor to replace.
* ERROR::	Return to INTERLISP with an ERROR.
* RESET::	Return to INTERLISP with a RESET.
}


File: INTER,	Node: Exit, Up: Commands, Next: Up
indexentry:C-T Z

C-T Z (^R Exit to LISP) simply returns control from EMACS to LISP.  No
expressions in the EMACS buffer are evaluated.  To resume editing in the same
EMACS state, call (EMACS T).



File: INTER,	Node: Up, Up: Commands, Next: EVAL
indexentry:C-T U

C-T U (^R EVAL) returns to INTERLISP and causes INTERLISP to read and evaluate
each expression in the (virtual) buffer as though it were typed directly into
INTERLISP.



File: INTER,	Node: EVAL, Up: Commands, Next: DEFINEQ
indexentry:C-T E

C-T E (^R EVAL) returns to INTERLISP and causes INTERLISP to read and evaluate
the expression after the cursor as though it were typed directly into
INTERLISP.  Approximately identical to C-T Z followed by E..  (If an explicit
argument is supplied, that many expressions are read and evaluated.  A
0 arg means evaluate everything in the (virtual) buffer.



File: INTER,	Node: DEFINEQ, Up: Commands, Next: QUOTE
indexentry:C-T D

C-T D (^R DEFINEQ) returns to INTERLISP and causes LISP to read and then
evaluate the expression after the cursor as an argument to DEFINEQ.  For
example, if the cursor is just in front of "(FOO (X) (EQUAL X 3))" then C-T D
will result in FOO's being defined as the function that tests whether its
argument X is 3.  This command is useful for perusing files made by MAKEFILE,
because such files usually have just one "DEFINEQ" at the top.  (If an explicit
argument is supplied, that many expressions are read and given to DEFINEQ.
A 0 arg means to DEFINEQ everything in the (virtual) buffer).



File: INTER,	Node: QUOTE, Up: Commands, Next: PP
indexentry:C-T Q

C-T Q (^R QUOTE) returns to INTERLISP and makes the expression after the cursor
be the value of the next INTERLISP history event.  This command is useful for
getting your INTERLISP hands on an expression in the EMACS buffer.  After you
return to LISP, the expression can be obtained via the INTERLISP function
VALUEOF.  (If an explicit argument is supplied, that many expressions are read
and quoted. A 0 arg means read and quote each expression in the 
(virtual) buffer.)



File: INTER,	Node: PP, Up: Commands, Next: EV&PP
indexentry:C-T P

C-T P (^R Pretty Print) prettyprints the expressions after the cursor
using the LISP pretty printer.  The effect can be undone with the
EMACS command UNDO.



File: INTER,	Node: EV&PP, Up: Commands, Next: SHALLOW
indexentry:C-T S

C-T S (^R Eval Sexpr) evaluates in INTERLISP the expression after the cursor in
the EMACS buffer and prints the result into the buffer named *LISP-PRINT* in
the other window.  The previous contents of the buffer named *LISP-PRINT* are
deleted.



File: INTER,	Node: SHALLOW, Up: Commands, Next: ARGS
indexentry:C-T L

C-T L (^R Print to Level) shallowly prints the expression after the cursor into
the buffer named *LISP-PRINT* in the other window.  Useful if the expression
after the cursor is bigger than a screen full.  The previous contents of the
buffer named *LISP-PRINT* are deleted.



File: INTER,	Node: ARGS, Up: Commands, Next: HELP
indexentry:C-T A

C-T A (^R Arglist) prints the arglist of the function after the cursor (or
after the open parenthesis after the cursor if there is one.)



File: INTER,	Node: HELP, Up: Commands, Next: FIND
indexentry:C-T ?

C-T ? prints short documentation on the ^T commands.



File: INTER,	Node: FIND, Up: Commands, Next: REPLACE
indexentry:C-T F

C-T F (^R Find Sexp) is for use under the editmacro EMACS: of the standard
INTERLISP structure editor.  This command manufactures a search command for the
structure editor that changes the structure editors's attention to the
expression after the cursor.  One use is in conjunction with BREAKIN to set a
breakpoint in the body of a function definition.  For example (BREAKIN FOO
(AROUND EMACS:)) allows one to insert a breakpoint in the body of FOO by moving
the cursor to the desired spot and entering C-T F.  To use this command, the
cursor should be directly in front of the open parenthesis of the expression
you want to have found.



File: INTER,	Node: REPLACE, Up: Commands, Next: ERROR
indexentry:C-T C

C-T C (^R Replace Sexp) is for use under the editmacro EMACS: of the standard
INTERLISP structure editor.  This command causes the manufacture of a
replacement command for the structure editor that when executed replaces the
current expression of the structure editor with the contents of the current
EMACS virtual buffer.



File: INTER,	Node: ERROR, Up: Commands, Next: RESET
indexentry:C-T C-E

C-T C-E (^R LISP ERROR) returns to INTERLISP with an ERROR.  This
command is particularly useful if you are under the structure editor
EDITMACRO EMACS: and wish to return to the structure editor,
no change having been made.



File: INTER,	Node: RESET, Up: Commands
indexentry:RESET

C-T C-D (^R LISP RESET) returns to INTERLISP with a RESET.  That takes you
back to the very toplevel of LISP.


File: INTER,	Node: Syntax,	Up: Top, Next: Hints
{+GUIDE:
indexentry:Interlisp Mode 
}
The EMACS function Interlisp Mode sets the delimiter table of EMACS to reflect
INTERLISP syntax.  Interlisp Mode can thus be useful even if you are not using
INTER.  % quotes the next character.  " delimits strings.  (The characters /,
|, and semicolon have no special significance, but are treated just as
alphabetic characters.)
{+GUIDE:
indexentry:#RPARS
}
Square brackets are treated just as alphabetic characters.  A function
definition containing square brackets is certainly editable in EMACS, but the
INTERLISP oriented commands of EMACS do not respect the INTERLISP meaning of
square brackets.  Of course, INTERLISP will respect the square brackets when
it reads a modified definition from the EMACS buffer.  If #RPARS is NIL, then
the INTERLISP pretty printer, PRINTDEF, will not use square brackets for
parentheses, even during MAKEFILE.  You can still type them into LISP.  The
value of #RPARS is set to NIL in START.EMACS.  
{+GUIDE:
indexentry:C-M-Q,C-T C-P,Grind Sexp
}
When you are in EMACS, you can pretty print expressions in two ways.  C-M-Q
(^R Indent Sexp) will readjust the number of spaces in the sexpression after
the cursor.  This often works well on slightly edited function.  To get a
genuine LISP pretty printing job done you can use C-T C-P (^R Pretty Print),
which pretty prints the expression after the cursor.  It is unadvisable to use
the EMACS routine Grind Sexp on INTERLISP; Grind Sexp was written for MACLISP.
Grind Sexp is disabled by INTER; if you really want to use it, then call Load
Library on the file GRIND to restore the original definition of Grind Sexp.



File: INTER,	Node: Hints,	Up: Top,   Next: EDITE
{+GUIDE:Section:  A Miscellany
}
It is OK to use multiple EMACS buffers.  Any reference to "the" EMACS buffer in
the documentation of INTER should be construed as a reference to the "current"
EMACS buffer.  E.g., if you execute (E.), then the expression that is evaluated
is the expression after "point" in the "current" EMACS buffer.

When you enter EMACS from INTERLISP with text to be inserted (e.g., by using
CF), the text is inserted at the bottom of the current virtual buffer.  The
text that was already in the buffer (i.e., the text that was there when you
last left EMACS) is undisturbed.  But the "virtual" buffer boundaries are
narrowed to the definition; so all you can see is the definition.  You can
easily obtain access to what's in the rest of the buffer by "widening" the
virtual buffer boundaries to the whole buffer; just invoke ^R Set Bounds Full.

If you are in EMACS perusing a huge file produced by MAKEFILE and decide to use
C-T D to pull in a definition, it will happen faster if you narrow the virtual
buffer to the expression that you are interested in.  All the commands that
draw INTERLISP's attention to the EMACS buffer copy characters out of the EMACS
buffer starting either at the cursor or at the top of the virtual buffer and
going all the way to the end of the virtual buffer.  We copy all the way to the
end because there is no command in EMACS that can perfectly calculate how far
one INTERLISP read will go.  The main problem is the square bracket, which
is likely to occur in files produced by MAKEFILE.
{+GUIDE:
indexentry:NORMALCOMMENTSFLG
}
If you set NORMALCOMMENTSFLG to NIL and if you print to EMACS.TEMP.FILE
yourself, be sure to readjust PRETTYPRINTMACROS by consing on (* . GETTCOMMENT)
or you'll get your comments mapped into the EMACS temp file and later munged.

The details of the hook EMACS has for communicating with other processes are
found in the last few pages of <INFO>TECORD.



File: INTER,	Node: EDITE,	Up: Top
{+GUIDE:Section: Using EMACS from Within the Structure Editor.
indexentry:C-T C-D,C-T C-E,C-T C-D,C-T C-E,BREAKIN
}
Several INTERLISP utility functions invoke the standard structure editor.  For
example, in a break, the EDIT BREAKMACRO permits you to edit the current
expression.  BREAKIN permits you to place a BREAK at a spot in a function as
found by interactive editing.  It is possible to invoke EMACS from within the
standard editor on the current expression via the EDITMACRO EMACS:.  When you
are under EMACS:, you can return in four ways.  C-T F (^R Find Sexp) tells the
structure editor to find the expression right after the cursor.  C-T C (^R
Replace Sexp) tells the structure editor to replace its current expression with
the contents of the virtual buffer.  C-T C-D (^R LISP RESET) causes LISP to
quit to the top level.  C-T C-E (^R LISP ERROR) aborts EMACS: and returns you
to the structure editor, no changes having been made.

It should be noted that this interface is consistent with the normal usage of
BREAKIN, EDITF etc. The edit chain remains intact and the operations are
generally undoable.

{+INFO:

}
{-TRUTH:

Local Modes:
Fill Column:78
End:}