605 lines
27 KiB
Plaintext
605 lines
27 KiB
Plaintext
Xedit is a simple text editor for X.
|
|
|
|
Please check xedit(1) for information about resources and configurable
|
|
options.
|
|
|
|
The authors file should list the original authors of all files, but
|
|
unfortunately most collaborators and people that changed portions of the
|
|
code is not listed.
|
|
|
|
|
|
List of default keyboard commands.
|
|
Uppercase letters means both, uppercase and lowercase.
|
|
Lowercase letter usually means Shift key is not pressed.
|
|
C- Means Control key.
|
|
M- Means Meta key.
|
|
Usually Alt key has the same effect.
|
|
S- Means Shift key.
|
|
|
|
C-A Move cursor to beginning of line.
|
|
C-B or Left
|
|
Move cursor backwards one character.
|
|
C-C Insert CUT_BUFFER0 selection at cursor position.
|
|
C-D Delete next character.
|
|
C-E Move cursor to end of line.
|
|
C-F or Right
|
|
Move cursor forwards one character.
|
|
C-G Keyboard reset.
|
|
Use it to switch direction in the Undo stack, i.e. switch between
|
|
Undo and Redo.
|
|
It can also be used to stop the lisp interpreter if it is executing
|
|
code.
|
|
C-H Deletes character before cursor.
|
|
C-J Adds a newline and indent.
|
|
If the current buffer is the *scratch* buffer, it will work
|
|
like C-X,C-E, but print the lisp output directly to the scratch
|
|
buffer. Examples:
|
|
(list 1 2 3) C-J will print (1 2 3) and move the cursor to
|
|
the next line.
|
|
C-K Deletes text from cursor position to end of line.
|
|
C-L Redraw text window.
|
|
C-M Adds a newline.
|
|
C-N or Down
|
|
Move cursor to next line.
|
|
C-O Adds one newline at cursor position without moving cursor.
|
|
C-P or Up
|
|
Move cursor to previous line.
|
|
C-R Opens search dialog, searching backwards.
|
|
C-S Opens search dialog, searching forwards.
|
|
C-T Transpose characters.
|
|
C-U Starts multiply mode.
|
|
Multiply mode means that most keyboard commands will be repeated
|
|
by its parameter. After pressing C-U type a number, that can be
|
|
negative. Examples:
|
|
C-U 10 C-F will move the cursor 10 characters forwards
|
|
C-U -10 C-F will move the cursor 10 characters backwards
|
|
If no number is specified, or if the number zero is specified,
|
|
the default value is 4.
|
|
C-V or PageDown
|
|
Move cursor to next page.
|
|
C-W Kills current selection.
|
|
C-W is also useful when there is no active selection, to return to
|
|
the previous position the left mouse was clicked in the text window.
|
|
C-Y Inserts SECONDARY selection.
|
|
This usually means text delete with commands other than by just
|
|
pressing Backspace or Delete (that can be multiplied)
|
|
C-Z Scroll one line up.
|
|
M-B or C-Left
|
|
Move cursor backwards one word.
|
|
C-Left only moves over alphabetic or numeric characters
|
|
M-C Capitalize word under cursor position, or next word.
|
|
M-F or C-Right
|
|
Move cursor forwards one word.
|
|
C-Right only moves over alphabetic or numeric characters.
|
|
M-I Opens a dialog prompting for a file name to be inserted at the
|
|
cursor position.
|
|
(This isn't very user friendly, this is a cavemen interface, you will
|
|
love it, you will never use it).
|
|
M-K Kills text from cursor position to end of paragraph.
|
|
M-L Downcase word at cursor position or next word.
|
|
M-Q Format paragraph.
|
|
Xedit interfaces Xaw code that allows several types of text
|
|
formatting. To use it, you need to Select "Auto Fill" in the
|
|
"Edit Menu" and select values for "Break Columns". After that,
|
|
Select "Edit Menu"->"Justification" for the available options.
|
|
Text typed will usually be automatically corrected, but if you
|
|
need to change text in the middle of a previous line, use M-Q
|
|
to reformat, and C-_ to undo if required.
|
|
Examples of text:
|
|
|
|
This text with align
|
|
left and break
|
|
columns at 20 and
|
|
40.
|
|
|
|
This text with align
|
|
right and break
|
|
columns at 25 and
|
|
45. Remember that
|
|
Auto Fill must be
|
|
selected. And it may
|
|
be required to press
|
|
M-Q when going back
|
|
to edit previous
|
|
lines.
|
|
|
|
This text with align center
|
|
and break columns at 40 and
|
|
70. A good tip is to make sure
|
|
there are empty lines before
|
|
and after the aligned text, so
|
|
that M-Q will not format more
|
|
text than it should.
|
|
|
|
This text with full align,
|
|
note that it will spread the
|
|
words to fully fill the
|
|
configured break columns, in
|
|
this case 15 and 45. Also note
|
|
that it doesn't remove any
|
|
extra indentation from the
|
|
first line. This may be
|
|
considered a bug or feature,
|
|
but it doesn't respect 2
|
|
spaces after an '.' dot. And
|
|
it doesn't align the last line
|
|
of text.
|
|
|
|
This text with Auto Fill disabled. When Auto Fill is disabled, tabs are
|
|
usually preserved, like this, and this. But it
|
|
will basically format the text to not be larger than the text widget screen
|
|
width and. But it the screen is scrolled horizontally, it will not work as
|
|
expected, the advantage over the above interface is that is considers font
|
|
characters width, while the other interface assumes fixed width characters.
|
|
|
|
Notice that "auto formatting" with Auto Fill mode is done when
|
|
pressing enter, but information isn't saved per paragraph, so
|
|
if values of align or break columns are changed, trying to edit
|
|
a text block with different configuration will not give the expected
|
|
results.
|
|
Also notice that lines starting with non printable characters aren't
|
|
automatically formatted. This is helpful for some editing modes
|
|
where symbols can be used before lines in a paragraph. If you don't
|
|
need this feature, usually pressing Space or Tab is enough to put the
|
|
cursor at the proper position.
|
|
M-U Upcase word at cursor position or next word.
|
|
M-V or PageUp
|
|
Move cursor to previous page.
|
|
M-Y Kill ring yank feature. Basically it will circulate over all
|
|
text that has been cut in the current session. Keep pressing it
|
|
until happy :-)
|
|
M-Z Scrolls one line down.
|
|
M-D Kill word at cursor position or next word.
|
|
S-M-D Delete word at cursor position or next word.
|
|
Does not go to the kill ring.
|
|
M-H or M-Delete or M-Backspace.
|
|
Kill word at cursor position or previous word.
|
|
S-M-H or S-M-Delete or S-M-Backspace
|
|
Delete word at cursor position or previous word.
|
|
Does not go to the kill ring.
|
|
M-. Find definition/declaration of symbol string of selected text, and/or
|
|
finds next tag when more than one definition exists for the symbol.
|
|
M-< or Home
|
|
Move cursor to beginning of file.
|
|
M-> or End
|
|
Move cursor to end of file.
|
|
M-] or C-Down
|
|
Move cursor to next paragraph.
|
|
M-[ or C-Up
|
|
Move cursor to previous paragraph.
|
|
C-_ or C-X,U
|
|
Undo.
|
|
If enabled in the given textwidget. Not enabled by default in the
|
|
message window and filename window, or any of the other text widgets
|
|
in the several available dialogs.
|
|
C-\ or C-Kanji
|
|
Reconnect Input Method.
|
|
In international mode (probably broken interface).
|
|
S-Insert
|
|
Insert PRIMARY selection from CUT_BUFFER0.
|
|
C-Q
|
|
Followed by any character, will insert the next typed character
|
|
useful to insert control characters. For example C-Q,C-L will
|
|
insert ^L at the cursor position.
|
|
LeftMouseButton
|
|
When pressed marks the start of a PRIMARY selection at CUTBUFFER0
|
|
When moved while pressed extends the selection.
|
|
MiddleMouseButton
|
|
When pressed, inserts the PRIMARY selection at CUTBUFFER0 at
|
|
the cursor position.
|
|
RightMouseButton
|
|
Can be used to adjust a selection done with LeftMouseButton.
|
|
C-A,Tab
|
|
If the loaded file has a indentation rules file, C or Lisp, xedit
|
|
will reindent the line. Also, entering a fresh character on a
|
|
newline should be enough to move the cursor to the proper position.
|
|
To override it, you may need to use the C-U to multiply the action,
|
|
as it will only indent if only one character was added.
|
|
C-X,C-C or (Pressing the Quit button)
|
|
Exits xedit.
|
|
If there are unsaved files, a message will be printed asking to
|
|
"exit" again, or save the files.
|
|
C-X,C-E
|
|
Execute lisp expression before the cursor position.
|
|
C-X,C-F
|
|
Changes keyboard input focus to the filename text input window.
|
|
In this mode, pressing Tab will try to complete the filename
|
|
being typed.
|
|
When more than one match exists, pressing Tab again will display
|
|
the directory navigation window.
|
|
The initial search path usually is the basename of the file loaded
|
|
in the current textwindow, or currently directory from where
|
|
xedit was started if the *scratch* is the current "buffer".
|
|
The character ~ can be used as a shortcut for the home directory
|
|
and ~username will be replaced by the home directory of "username"
|
|
if it exists.
|
|
C-X,C-S or (Pressing the Save button)
|
|
Saves the file in the current text window.
|
|
C-X,Tab
|
|
Indents the current paragraph.
|
|
Use the C-U modifier to specify the number of spaces to insert
|
|
or remove if the C-U parameter is negative.
|
|
C-X,0
|
|
Deletes the current window.
|
|
The file being edited is not unloaded.
|
|
C-X,1
|
|
Deletes the other window.
|
|
The file being edited is not unloaded.
|
|
C-X,2
|
|
Splits vertically the current window.
|
|
C-X,3
|
|
Splits vertically the current window.
|
|
C-X,b
|
|
Switch the contents of the current window to the next file in
|
|
the list of loaded files.
|
|
C-X,d
|
|
Displays the directory listing window.
|
|
In this window, it is possible to navigate in the file system
|
|
to choose a file to edit.
|
|
Usually, this is the same as pressing C-X,C-F,Tab
|
|
See C-X,C-F for more information.
|
|
C-X,k
|
|
Unloads the file being edited.
|
|
If the file has not been saved, a message will be displayed,
|
|
asking to either press C-X,k again, or save the file
|
|
The *scratch* buffer cannot be killed and will always
|
|
prints a warning when exiting xedit. This is the expected behavior.
|
|
C-X,o
|
|
Switch input focus to the other window, making it the current one
|
|
If the editor doesn't have splited windows, this command is ignored.
|
|
Insert
|
|
Switches between insert and overwrite mode.
|
|
In overwrite mode text is typed over existing file contents,
|
|
only extending the file contents when typing at the end of
|
|
a line (or file).
|
|
Escape
|
|
Enters the line edit mode.
|
|
In this mode it is possible to use regex expressions to search and
|
|
replace the contents of the file loaded in the current text window.
|
|
Refer to the xedit(1) manpage for more information of the regex
|
|
expression format.
|
|
Note that the regex used by xedit isn't IEEE Std 1003.2 compliant,
|
|
and not compliant with most regex implementations in that it doesn't
|
|
support some complex search patterns, usually involving patterns
|
|
like ((.*)+)? that may require too much restarts or have several
|
|
correct interpretations for multiple matches. Also, it always does
|
|
minimal matching, and it is not configurable like in pcre, example:
|
|
searching "a1a1a1" with the pattern "(.*)\d" will find "a1" and
|
|
not "a1a1a1" as could be expected.
|
|
Please refer to lisp/re/README for more information on the supported
|
|
regex expressions.
|
|
C-LeftMouseButton
|
|
Displays the "File Menu" from where it is possible to select a
|
|
new file to be edited in the current window.
|
|
C-MiddleMouseButton
|
|
Displays the "Edit Menu" that usually has the following options:
|
|
+------------------+-------------+
|
|
| Wrapping -> | Never |
|
|
| | Line |
|
|
| | Word |
|
|
| Auto Fill +-------------+
|
|
| +-------------+
|
|
| Justification -> | Left |
|
|
| | Right |
|
|
| | Center |
|
|
| | Full |
|
|
| +-------------+
|
|
| Break Columns... |
|
|
| +-------------+
|
|
| Scrollbars -> | Vertical |
|
|
| | Horizontal |
|
|
| +-------------+
|
|
| +-------------+
|
|
| Edit Mode -> | Plain/None |
|
|
| | C/C++ |
|
|
| | Lisp/Scheme |
|
|
| | X imake |
|
|
| | Makefile |
|
|
| | Unix shell |
|
|
| | SGML |
|
|
| | HTML |
|
|
| | Man page |
|
|
| | X resource |
|
|
| | XF86Config |
|
|
| | RPM spec |
|
|
| | XFree86 log |
|
|
| | Patch file |
|
|
+------------------+-------------+
|
|
"Wrapping" is disabled if "Auto Fill" is enabled.
|
|
"Justification" and "Break Columns..." are enabled if "Auto Fill"
|
|
is also enabled.
|
|
"Edit Mode" lists the available syntax highlight and indentation
|
|
rules defined.
|
|
Note that most of these options don't work in "international" mode.
|
|
Several xedit interfaces works only with 8 bits encodings, and
|
|
doesn't properly handle UTF-8.
|
|
C-RightMouseButton
|
|
Displays the "Option Menu".
|
|
Currently the only option is an Ispell frontend.
|
|
FourthMouseButton (usually also moving up the mouse wheel)
|
|
Scroll one line down
|
|
FifthMouseButton (usually also moving down the mouse wheel)
|
|
Scroll one line up
|
|
|
|
|
|
|
|
There is also some documentation in lisp/README, lisp/TODO,
|
|
lisp/re/README, lisp/re/tests.txt, and comments/justifications/wishlists for
|
|
the cases the interpreter fail to give the proper result for a given test.
|
|
|
|
The lisp interpreter implements most of a standard COMMON LISP
|
|
environment, but the compiler generates only byte code and not everything
|
|
can be compiled, in those cases the interpreter does the work. Examples are
|
|
constructs involving UNWIND-PROTECT or any kind of jump outside of the
|
|
current function body.
|
|
|
|
For more information please consult any COMMON LISP documentation or
|
|
tutorial.
|
|
|
|
|
|
|
|
Simple tutorial on writing a "foolang" syntax highlight mode for xedit.
|
|
|
|
Create a file called foolang.lsp
|
|
Add:
|
|
--
|
|
(require "syntax")
|
|
(require "indent")
|
|
(in-package "XEDIT")
|
|
--
|
|
to foolang.lsp
|
|
Check the available files if you want a custom property, or to know about
|
|
the available ones. One example is:
|
|
--
|
|
(defsynprop *prop-foolang*
|
|
"foolang"
|
|
:font "fixed"
|
|
:foreground "rgb:a/b/c"
|
|
:background "rgb:1/2/3"
|
|
:underline t
|
|
:overstrike t)
|
|
--
|
|
Check lisp/modules/xedit.lsp for the other options, like subscript,
|
|
superscript and/or combining XLFD properties.
|
|
Create a syntax definition for foolang. Check the definition of defsyntax in
|
|
lisp/modules/syntax.lsp for more details. One example for foolang is:
|
|
--
|
|
(defsyntax *foolang-mode* :foolang nil nil nil
|
|
;; use the sample property created for foolang whenever the string
|
|
;; foolang is found at the toplevel
|
|
(syntoken "\\<foolang\\>" :property *prop-foolang*)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; process C style comments
|
|
(syntoken "/*" :nospec t :begin :comment :contained t)
|
|
;; contained is an option to not "export" this definition to child
|
|
;; tables
|
|
|
|
(syntable :comment *prop-comment* #'default-indent
|
|
;; #'default-indent means a very simple indent that follows indentation
|
|
;; of previous line. Use nil for no indentation
|
|
|
|
;; Don't start a new table, instead flag as an error if nested
|
|
(syntoken "/*" :nospec t :property *prop-error*)
|
|
;; :nospec t sets the RE_NOSPEC flag for the regex, i.e. searches
|
|
;; a literal string, and * will not be a special character
|
|
|
|
(syntoken "XXX|TODO|FIXME" :property *prop-annotation*)
|
|
;; just to make it easier to flag some important comment
|
|
|
|
(syntoken "*/" :nospec t :switch -1)
|
|
;; The :switch argument is the number of tables to "pop", in
|
|
;; this case, we are at table :comment, and :switch -1 returns
|
|
;; to table :foolang, that is the "root" table
|
|
)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; Process lisp comments that can nest
|
|
(syntable :lisp-comment *prop-comment* nil
|
|
|
|
;; Start a comment, possibly nested
|
|
(syntoken "#|" :nospec t :begin :lisp-comment)
|
|
|
|
;; Returns to previous comment in stack or to main :foolang table
|
|
(syntoken "|#" :nospec t :switch -1)
|
|
|
|
;; For easier flagging important comments
|
|
(syntoken "XXX|FIXME|TODO" :property *prop-annotation*)
|
|
)
|
|
|
|
;; This is usually in the end of the list, but can be anywhere,
|
|
;; just that if it isn't at the end, conflicting rules are resolved
|
|
;; by declaration order
|
|
(synaugment :lisp-comment)
|
|
;; Adds the :lisp-comment table to :foolang table
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; Lisp like strings that don't need a \ at the end of the line
|
|
(syntable :lisp-string *prop-string* nil
|
|
;; ignore a escaped " in the middle of the string
|
|
(syntoken "\\\\.")
|
|
;; Note that no options are used, just keep using the current
|
|
;; property. Unfortunately, backslashes must be escaped twice.
|
|
;; Once for the lisp reader and once for the regex compiler.
|
|
|
|
(syntoken "\"" :nospec: t :switch -1)
|
|
;; :nospec is used just to create a faster regex. switch -1
|
|
;; returns to the previous syntax table. It isn't an error to
|
|
;; try to go down the "root" table, but if that happens, it
|
|
;; probably means either wrong syntax definition of malformed input.
|
|
)
|
|
|
|
(synaugment :lisp-string)
|
|
;; Adds the :lisp-string table to :foolang table
|
|
;; Note that since there isn't a rule to start a string in the
|
|
;; :lisp-string table, it cannot nest, maybe because the ending
|
|
;; character is the starting character ? :-))
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; C style string rules
|
|
(syntable :string *prop-string* nil
|
|
;; Ignore escaped characters
|
|
(syntoken "\\\\.")
|
|
|
|
;; Match, most, printf arguments.
|
|
(syntoken "%%|%([+-]?\\d+)?(l?[deEfgiouxX]|[cdeEfgiopsuxX])"
|
|
:property *prop-format*)
|
|
;; Just for fun. This makes easier to see printf formats in strings
|
|
;; *prop-format* is *prop-string* with the :underline option
|
|
|
|
(syntoken "\\\\$")
|
|
;; a backslash extends the string to the next line
|
|
|
|
;; A nonscaped " inside a string finishes it, since this table doesn't
|
|
;; have sub tables, and cannot nest, should return to :foolang table
|
|
;; from here
|
|
(syntoken "\"" :nospec t :switch -1)
|
|
|
|
;; This token rule starts a new table called :error because end of line
|
|
;; has been matched. Note that it is defined last, so that a line
|
|
;; ending with " or \ will be processed first.
|
|
(syntoken ".?$" :begin :error)
|
|
|
|
(synaugment :string)
|
|
;; Adds the :string table to :foolang table
|
|
|
|
;; This table is used by :string, but could be shared for other patterns
|
|
;; like characters constants, etc.
|
|
;; It uses :switch -2 because it is started inside the :string table,
|
|
;; but it is also a table, so, pops two tables from the table stack
|
|
(syntable :error *prop-error* nil
|
|
(syntoken "^.*$" :switch -2)
|
|
)
|
|
)
|
|
--
|
|
|
|
Indentation rules are significantly more complex. I suggest looking at
|
|
lisp/modules/indent.lsp for the macros and function definitions;
|
|
and lisp/modules/progmodes/lisp.lsp and lisp/modules/progmodes/c.lsp for two
|
|
sample implementations of indentation for Lisp/Scheme and C/C++
|
|
respectively.
|
|
|
|
Note also that indentation is parsed backwards, what can cause some
|
|
confusion, and make "visualization" of order or precedence of evaluation for
|
|
rules harder to understand.
|
|
|
|
A simple indentation rules definition for foolang could be:
|
|
|
|
--
|
|
(defindent *foolang-mode-indent* :foolang
|
|
;; This must be the first token and usually the only token matching
|
|
;; BOL (Beginning of Line)
|
|
(indtoken "^\\s*" :indent
|
|
:code (or *offset* (setq *offset* (+ *ind-offset* *ind-length*))))
|
|
;; the keyword :indent is a pattern put on a list when there is
|
|
;; a match, so that later patterns can be "reduced" by some other
|
|
;; rule, i.e.: (:indent :indent) could be reduced to (:indent)
|
|
|
|
(indtoken "//.*$" nil)
|
|
;; C++ style comment. Returning nil instead of a token basically
|
|
;; ignores the token, as it should not enter the reduction pattern
|
|
;; list
|
|
|
|
;; Sample C comment pattern
|
|
(indtoken "*/" :ccomment :nospec t :begin :comment)
|
|
;; Note that the indaugment macro doesn't need to be used, and actually
|
|
;; would be an error. In this example, the indentation compiler checks
|
|
;; the :begin :comment and handles it internally, as it already needs
|
|
;; to check for things like typos, unreachable labels, detectable
|
|
;; non resolving rules, etc. There is runtime check also, so it should
|
|
;; never enter an infinite loop when trying to resolve reduction rules.
|
|
;; Check lisp/modules/indent.lsp:(compile-indent-table) for the
|
|
;; implementation and more comments.
|
|
|
|
;; Indentation rules also have stacked tables
|
|
(indtable :comment
|
|
(indtoken "/*" :ocomment :nospec t :switch -1))
|
|
;; Note that the name is :ocomment (open comment), but that the
|
|
;; the table is finished when matching the open comment pattern
|
|
|
|
;; A simple initialization of a variable used by the indentation rules
|
|
(indinit (parens 0))
|
|
;; This variable can be declared anywhere in the body of defindent,
|
|
;; It will be properly moved to a "variables declaration section"
|
|
;; when expanding and compiling the table.
|
|
|
|
(indtoken "(" :oparen :nospec t :code (incf parens))
|
|
(indtoken ")" :cparen :nospec t :code (decf parens))
|
|
;; These two tokes add the patterns :oparen and :cparen to the
|
|
;; "pattern list", and also have code to remember the balancing
|
|
;; of parenthesis.
|
|
|
|
|
|
;; One of the simplest reduction rules :-)
|
|
(indreduce nil
|
|
t
|
|
((:comment)))
|
|
;; Once the boundings of a comment are found, just ignore it, like
|
|
;; what was done with the // pattern, but in that case, the boundings
|
|
;; were readily available.
|
|
;; The t (True) parameter means that this rule is always evaluated,
|
|
;; but conditional code may be used, and implicit code may be added
|
|
;; to the end of the indreduce macro.
|
|
;; Since it is a macro, code can be compiled to optimized bytecode
|
|
;; after the macro is expanded.
|
|
|
|
(indinit (indent 0))
|
|
;; Note that there is a special *indent* variable that should hold the
|
|
;; proper indentation value, but it may be required to "overwrite"
|
|
;; without forgetting that value, for things like:
|
|
;;
|
|
;; foo(bar(baz(blah
|
|
;; ^ ^
|
|
;; | |
|
|
;; indent |
|
|
;; effective indentation to be used
|
|
;;
|
|
;; where it is desirable to align the code in the next line with the
|
|
;; last open parenthesis.
|
|
|
|
|
|
Since the interface is, unfortunately, complex enough to not expect
|
|
casual users to have something like a $HOME/.xedit file, if you want to add
|
|
new modes, please check lisp/modules/xedit.lsp:*auto-modes*
|
|
|
|
There is some documentation about the variable. It should be possible to
|
|
change/update the variable from the lisp interface in the *scratch* buffer,
|
|
but for safety, it is suggested that if you add new rules, you should
|
|
restart xedit after it. Also note that there is compiled code in
|
|
lisp/xedit.c that expects that variable to follow an specific format.
|
|
|
|
You may notice that several .lsp files aren't "properly indented"; this
|
|
is because the lisp indentation rules file was made long after most of the
|
|
other files were done, and it was considered a bad practice to gratuitously
|
|
reindent all files.
|
|
|
|
|
|
|
|
At the time of this writing, the ispell interface should be again
|
|
functional, but it may be required to use some old ispell program to handle
|
|
non utf8 text. But it should work properly for the english language, and in
|
|
international mode, should work with any language. But there are problems in
|
|
international mode not fixed.
|
|
|
|
I (Paulo Cesar) considered several times to extend the normal
|
|
textwidget to handle utf8, but this is probably a lot of work/time badly
|
|
spent and I prefer to work on other personal projects, but still xedit is
|
|
the editor I use for programming. The XPRINT support unfortunately is broken
|
|
due to it. Note that xedit, like pretty much any other Xaw application can
|
|
be linked against Xaw with XPRINT support. In the case of xedit, a flag
|
|
could be used, like the "international" variable to, at runtime, disable all
|
|
the related code, if required.
|
|
|
|
Also at the time of this writing, the tags interface was added, as well
|
|
as several other bug fixes. The tags interface is documented in the manpage,
|
|
but the action shortcut may not be clear. The default shortcut is M-. .
|
|
There is no support for more than one tags file, or changing the tags file
|
|
at runtime. But the code should be easy to adapt for this case, as all
|
|
related functions receive pointers to the appropriate structures. One option
|
|
could be to descend from the directory of the loaded file searching for a
|
|
tags file, and then associate the file with the tags definition, if it isn't
|
|
already loaded. Shouldn't be hard to implement. For "inter project" files,
|
|
it should be better to have one xedit window per "project", i.e. searching
|
|
the definition of something like a libc symbol should probably be done in
|
|
another xedit window.
|