Compare commits

...

261 Commits

Author SHA1 Message Date
Benno Schulenberg
59edef55dc po: update translations and regenerate POT file and PO files 2017-01-10 11:35:00 +01:00
Benno Schulenberg
f119a90fe5 bump version numbers and add a news item for the 2.7.4 release 2017-01-10 11:29:34 +01:00
Benno Schulenberg
4920030384 docs: snip some obsolete items from the FAQ, and normalize its dates 2017-01-09 21:43:59 +01:00
Benno Schulenberg
a898fa5dcc tweaks: if there is no end match, there is nothing to paint
When there is no end match after a start, it is pointless to look
for any more starts because also they will not have any end match,
so nothing will get painted -- just cut the loop short.
2017-01-09 19:14:51 +01:00
Benno Schulenberg
c0aa5ad258 tweaks: miscellaneous frobbings 2017-01-09 18:25:25 +01:00
Benno Schulenberg
58c3dd6cd0 softwrap: when typing M-/, ensure the last line is fully visible 2017-01-09 15:21:15 +01:00
Benno Schulenberg
5ca765f107 tweaks: discard some conditional compilation 2017-01-09 15:09:06 +01:00
Benno Schulenberg
cf75da9888 softwrap: when pasting an overlong line, ensure it is fully visible
This fixes https://savannah.gnu.org/bugs/?50009.
2017-01-09 15:00:29 +01:00
Benno Schulenberg
14c62dbf11 build: check for GNU-style word-boundary support also in the tiny version
The tiny version can do regex searches nowadays, so the user might use
the \< and \> anchors in their regexes.

This fixes https://savannah.gnu.org/bugs/?50008.
2017-01-09 14:32:01 +01:00
Benno Schulenberg
f6fbc1572d tweaks: adjust whitespace after the previous change 2017-01-09 12:01:27 +01:00
Benno Schulenberg
38d7362f20 tweaks: rename two variables to be just one as they play the same role
The renamed variable 'index' is not the start of a match (as some comment
mistakenly said), but from where in the line we start looking for a next
match.

Also, use one more goto to allow unindenting a big piece of code, and
shortcircuit two while loops for two more small unindents.
2017-01-09 11:39:37 +01:00
Benno Schulenberg
26683a9e5f tweaks: frob some comments, and transform one variable 2017-01-08 21:31:49 +01:00
David Lawrence Ramsey
d35ecd02b8 weeding: remove another unnecessary setting of openfile->current_y
The setting of current_y in copy_from_filestruct() also appears to be
a holdover from the days of a more-common STATIONARY scrolling mode.

do_cut_text() uses the above function when copying text (uncutting
text again right after cutting it).  Since the text is effectively
the same afterward, current_y doesn't need to change.

do_uncut_text(), however, does need current_y up to date in one case:
when uncutting a full screen or less' worth of lines, focusing will be
FALSE, and it uses edit_refresh(), so it will use STATIONARY scrolling
mode then.  Take a cue from do_insertfile() and call reset_cursor() to
get an updated current_y.

(Note that the check for a full screen or less' worth of lines uses
incorrect values when in softwrap mode, but that's a separate problem.)

undo_cut(), do_redo(), and backup_lines() do not need set current_y
because they all result in edit_refresh() with focusing = TRUE, so
they do a CENTERING scroll which does not need current_y.
2017-01-08 17:18:28 +01:00
Benno Schulenberg
61bc248555 tweaks: chuck a couple of useless asserts 2017-01-08 15:27:48 +01:00
David Lawrence Ramsey
c38f571d4b tweaks: line numbers are ssize_t, not int 2017-01-08 15:13:11 +01:00
Benno Schulenberg
a89437219d tweaks: don't use a variable for two different purposes
At first paintlen was computed as a column span, and then converted
to a character count...  Confusing.
2017-01-08 13:34:10 +01:00
Benno Schulenberg
aa28441071 tweaks: the starting point for painting /cannot/ be offscreen
The top_x variable has already been forced to become equal to from_x
if it was before it.  So start_col will be at least zero.
2017-01-08 13:34:04 +01:00
Benno Schulenberg
5dbd288254 tweaks: rename another variable, to show it refers to columns not chars 2017-01-08 13:12:40 +01:00
Benno Schulenberg
8f21d256fb tweaks: rename two variables, for distinguishing characters from columns 2017-01-08 13:12:36 +01:00
Benno Schulenberg
08cfdbcbdb tweaks: don't compare a character offset with a column position
It is the misuse of "x_" to mean a column position on screen, and the
misuse of "_col" to mean a character position in a string that causes
this confusion.
2017-01-08 13:12:11 +01:00
Benno Schulenberg
6103c47f1c tweaks: rename three painting variables, to be more distinct
All these different "start"s and "end"s are confusing.  Use instead
'from_x and 'till_x' to remember which part of the current line is
visible now on screen and is thus represented in 'converted'.
2017-01-08 11:35:07 +01:00
Benno Schulenberg
88cf22f804 tweaks: rearrange and reindent some lines in the painting routines
Also adjust a few comments.
2017-01-08 11:33:57 +01:00
Benno Schulenberg
8177e62c18 screen: examine the whole line when painting, to set the correct info
In order to determine the correct multidata for a line that doesn't
have such data yet, the whole line must be examined, not just the
part that fits within the screen width.

This fixes https://savannah.gnu.org/bugs/?49978.
2017-01-08 11:33:57 +01:00
Benno Schulenberg
124a859516 syntax: html: be more precise with tags, and paint attribute names
A tag begins not merely with a "<" but it must be followed by an
ASCII alphabetic character or one of "/", "!" and "?".

Further, color all the valid attribute names in red.
2017-01-08 11:32:30 +01:00
Benno Schulenberg
322120c980 undo: properly create separate items for deletes at different positions
That is: only extend the current Del or Backspace undo item when the
cursor is still (or again) at the same spot.

This fixes https://savannah.gnu.org/bugs/?50006.
2017-01-08 11:05:52 +01:00
Benno Schulenberg
54e6fe2b4a build: install the Info and Html manuals even when 'makeinfo' is missing
If the system on which nano is configured does not have the 'makeinfo'
program installed, the prebuilt and packaged nano.info and nano.html
should nevertheless be installed.

Also, the TEXINFOS primary has built-in rules for generating HTML files
from the texinfo sources, so an explicit rule is not needed.

This indirectly addresses https://savannah.gnu.org/bugs/?49969.
2017-01-06 20:01:41 +01:00
Benno Schulenberg
fa56310454 build: include the old Changelogs in the tarball
(This should have been updated when the Changelogs were renamed.)
2017-01-06 19:31:48 +01:00
David Lawrence Ramsey
f35c3dbd57 softwrap: ensure the current line is fully visible after inserting a file
This fixes https://savannah.gnu.org/bugs/?49994.
Reported-by: David Lawrence Ramsey <pooka109@gmail.com>
2017-01-06 14:01:47 +01:00
David Lawrence Ramsey
acb394aec0 screen: properly place the cursor after inserting a file
Instead of setting openfile->current_y (and wrongly so), just call
reset_cursor() to recompute current_y and place the cursor on that
line (if it is not offscreen).
2017-01-06 14:00:37 +01:00
Benno Schulenberg
4223b83f75 tweaks: condense two ifs to a single one 2017-01-06 10:57:53 +01:00
Benno Schulenberg
4a1302ef55 tweaks: rename two variables, to be more telling 2017-01-05 22:47:01 +01:00
Benno Schulenberg
cbf7e57ed0 search: make a regex with a beginning-of-word anchor work correctly
The search routine begins searching right after the cursor and behaves
as if the line starts there, which means that a beginning-of-word anchor
(\< or \b) will match there also when in fact the cursor is sitting in
the middle of a word.  To prevent finding a false match, verify that
for a regex that starts with a BOW anchor the found match is actually
the start of a word.

This fixes https://savannah.gnu.org/bugs/?45630.
2017-01-05 22:38:10 +01:00
Benno Schulenberg
e36e829ad0 tweaks: set the length of a search match in a clearer manner 2017-01-05 21:25:30 +01:00
Benno Schulenberg
121c53f3b8 docs: add a new Changelog -- a list of the short commit messages 2017-01-04 16:19:39 +01:00
Benno Schulenberg
5b9683cd64 docs: rename the Changelogs to indicate which periods they cover 2017-01-04 16:01:50 +01:00
Benno Schulenberg
7c1dfea59e tweaks: terminate lots of sentences with a period in the old Changelog 2017-01-04 15:52:20 +01:00
Benno Schulenberg
4a073a0f3e docs: fix some spellos and trim some trailing tabs in the old Changelog 2017-01-04 13:48:25 +01:00
Benno Schulenberg
f8841f0927 docs: standardize the dates in the old Changelog
(Hooray for nano's regex replacements.)
2017-01-04 12:52:37 +01:00
Benno Schulenberg
8d692a87dc softwrap: don't scroll half a page when just a few lines will do
This fixes https://savannah.gnu.org/bugs/?49824.
2017-01-03 15:26:05 +01:00
Benno Schulenberg
13176792f0 tweaks: frob some comments, elide a variable, and use 'while' loops 2017-01-03 15:05:42 +01:00
David Lawrence Ramsey
d7fbc70a72 tweaks: avoid an unnecessary fiddling with current_y in do_mouse()
Since do_mouse() uses edit_redraw(), openfile->current_y will be
immediately recalculated, so there's no point in changing it now.
Use a temporary variable instead.
2017-01-03 14:44:53 +01:00
David Lawrence Ramsey
1dd01eb4e1 tweaks: move a setting, fix a type, and rearrange a line in do_mouse()
The value of sameline doesn't change, so it can be initialized to that.

Since i holds openfile->current_y, it should be ssize_t, not size_t.

And it's better to do the most significant part of a calculation first.
2017-01-03 14:23:40 +01:00
Benno Schulenberg
fd0589d8bc tweaks: remove the cluttering conditional compilation of a parameter
The conditionalizing saved negligible amounts of space, of memory, and
of speed.
2017-01-03 14:11:45 +01:00
Benno Schulenberg
a381021ffc tweaks: when allow_tabs is FALSE, allow_files is irrelevant
In that case setting the latter to TRUE is misleading.  So don't do that.
2017-01-03 14:02:52 +01:00
Benno Schulenberg
0b0ddb1e5f tweaks: rename a variable, chuck an assert, and frob a comment 2017-01-03 14:01:35 +01:00
Benno Schulenberg
991e49a36a docs: bring some air into the FAQ, so that <Ctrl+Up/Down> become useful 2017-01-03 14:00:21 +01:00
David Lawrence Ramsey
b1c20629f5 weeding: remove unnecessary settings of openfile->current_y
Many of the adjustments of the value of openfile->current_y appear to be
a holdover from the days when certain functions had to account for what
is now called STATIONARY scrolling mode, which depends on the value of
current_y.  Remove these adjustement where they are superfluous.

do_para_begin(), do_para_end(), and do_bracket_match() update the screen
through edit_redraw(), which uses either CENTERING or FLOWING scrolling
mode, so their setting of current_y is redundant and useless, as it will
be ignored and then overridden by the next call to reset_cursor().

findnextstr() is called by go_looking() [which calls edit_redraw(), see
above], and by do_replace_loop() and do_int_spell_fix(), which both call
edit_refresh(), which in this case only uses CENTERING scrolling mode
since focusing is TRUE.

(Additionally, the adjustments of current_y in findnextstr() and
do_bracket_match() use incorrect values when in softwrap mode.)

find_paragraph() doesn't need to save or restore current_y, because it
doesn't do any screen updates.  do_justify() calls edit_refresh() with
focusing set to TRUE, so it uses the CENTERING scrolling mode.

do_alt_speller() and do_formatter() do not need to save and restore
current_y, because they don't modify it in any way.

This addresses https://savannah.gnu.org/patch/?9197.
2017-01-02 12:40:21 +01:00
Benno Schulenberg
7373e4cd46 tweaks: fix compilation when configured with --disable-wrapping 2017-01-01 16:33:40 +01:00
Benno Schulenberg
5f30775d62 inserting: adjust the desired x position (don't restore the old one)
This makes nano's cursor behavior consistent across 1) typing text by
hand; 2) pasting in text with ^U; 3) inserting text from a file; and
4) redoing with M-E that same typing or pasting or inserting.

This fixes https://savannah.gnu.org/bugs/?49968.
2017-01-01 15:32:25 +01:00
Benno Schulenberg
69bd4d1f06 tweaks: slightly condense a function and its comment 2017-01-01 15:06:39 +01:00
Benno Schulenberg
d3429a7a57 copy: properly set preferred x position when region was marked backwards
This fixes https://savannah.gnu.org/bugs/?49964.
2016-12-31 16:36:14 +01:00
Benno Schulenberg
e1538e6dc3 tweaks: reshuffle a statement to a better place and condense some comments 2016-12-31 13:55:52 +01:00
Benno Schulenberg
1c46551ce8 cut: indicate a buffer as modified only if actually something was deleted
This fixes https://savannah.gnu.org/bugs/?49962.
2016-12-31 13:10:06 +01:00
Benno Schulenberg
f1b87f960c build: rename the sample config file, so it will be colored like a nanorc 2016-12-30 22:05:01 +01:00
Benno Schulenberg
b0ef2e2803 build: move the syntax files out of the doc/ directory
They are not documentation, they are functional elements of nano.
2016-12-30 22:05:01 +01:00
Benno Schulenberg
6981294c9d build: move all documentation into a single directory
There are just a handful of source files for the documentation --
it is wasteful and cumbersome to have these in separate directories.

Also: remove the French man pages -- they are too far out of date.
(And anyway, we should acquire a general framework for translating
the documentation.)
2016-12-30 22:05:00 +01:00
Felix Janda
fc89ac11d2 speller: fix build when tiny build is enabled
URL: https://bugs.gentoo.org/604000
2016-12-29 13:43:06 -05:00
Benno Schulenberg
9f92fb3ec4 po: update translations and regenerate POT file and PO files 2016-12-28 12:58:50 +01:00
Benno Schulenberg
293423bdda bump version numbers and add a news item for the 2.7.3 release 2016-12-28 12:24:05 +01:00
Benno Schulenberg
32719d64a1 locking: disable an annoying warning
The warning is wrong when the user has just saved a buffer under a
new name.  And when --quickblank is used, the warning most likely
gets cleared off before it is seen, and the user would just hear
the beep and be left wondering what happened.

This avoids https://savannah.gnu.org/bugs/?49875.
2016-12-28 12:04:55 +01:00
Benno Schulenberg
f4321250ef docs: clarify the difference between "Esc Esc ddd" and "M-V xxxxxx" 2016-12-28 11:54:49 +01:00
Benno Schulenberg
908663e8fc input: discard a verbatim 0x0A or 0x00 byte, depending on the mode
This disallows entering a verbatim ^J (0x0A) when typing text or
search terms, and disallows a verbatim ^@ (0x00) when typing a
filename.  Nano beeps when the disallowed code is attempted.

This addresses https://savannah.gnu.org/bugs/?49897.
2016-12-27 16:46:09 +01:00
Benno Schulenberg
1fb820386b tweaks: chuck a special case, and reduce the scope of two variables
A KEY_WINCH does not need to be separately treated since the basic
action for anything that is not recognized at the yes-no prompt is:
to continue.
2016-12-26 20:25:06 +01:00
Benno Schulenberg
9973366685 prompt: represent newlines as ^J instead of breaking the bar
Also at the yes-no prompt, a 0x0A byte should be displayed as a ^J
instead of splitting the prompt bar in two and spreading it over
two lines.

This fixes https://savannah.gnu.org/bugs/?49934.
2016-12-26 19:59:51 +01:00
Benno Schulenberg
e72db0e350 files: show newlines in filenames as ^J also in error messages
When a given file is, for example, unreadable or unwritable, the
error message should use ^J instead of ^@ in its name.
2016-12-26 12:35:50 +01:00
Benno Schulenberg
87b2df6dea utils: go on to parse the line number even if the column number is bad
This fixes https://savannah.gnu.org/bugs/?49933.
2016-12-26 11:45:38 +01:00
Benno Schulenberg
c24caf5fb8 tweaks: rename four variables, for density and aptness 2016-12-26 11:01:40 +01:00
Benno Schulenberg
8db21b68d5 tweaks: use memory on the stack instead of calling malloc() and free() 2016-12-26 10:39:48 +01:00
Benno Schulenberg
cb31e45f6c tweaks: remove pointless or obscuring asserts 2016-12-26 10:29:57 +01:00
Benno Schulenberg
588daf949e tweaks: condense the setting of three flags 2016-12-25 13:11:17 +01:00
Benno Schulenberg
d21a9c8fc3 text: discard the undo stack after formatting and after spell checking
After a call to the Formatter or the Alternate spell checker, the data
on the undo stack could refer to line positions that don't exist any
more -- the chance is small, but it is there.  So... throw the whole
undo stack away, to prevent undoing things wrongly or even crashing.

(Changes made with the internal spell checker can be undone and redone
without a problem -- nano keeps full track of those.  But the changes
made with a formatter or an external spell checker happen in another
process, so nano has no record of them.)

This fixes https://savannah.gnu.org/bugs/?49920.
2016-12-24 12:22:50 +01:00
Benno Schulenberg
edbc1e5950 text: avoid a crash when a spell-checked line has gotten shorter
When using an external spell checker or formatter, the line with
the cursor might become shorter, which might result in the stored
cursor position being beyond the end-of-line.  So, when restoring
the x position, make sure to limit it to the length of the line.

This fixes https://savannah.gnu.org/bugs/?49923.
2016-12-24 12:22:17 +01:00
Benno Schulenberg
dc18746cbd tweaks: retype, rename, and reshuffle a function 2016-12-23 13:51:58 +01:00
Benno Schulenberg
c92b9be6cd tweaks: rename three variables, to be more fitting 2016-12-23 13:01:15 +01:00
Benno Schulenberg
eef7d1047a screen: display byte value 0x0A in the right places as ^@ or as ^J
In path names and file names, 0x0A means an embedded newline and
should be shown as ^J, but in anything related to the file's data,
0x0A is an encoded NUL and should be displayed as ^@.

So... switch mode at the two main entry points into the "file system"
(reading in a file, and writing out a file), and also when drawing the
titlebar.  Switch back to the default mode in the main loop.

This fixes https://savannah.gnu.org/bugs/?49893.
2016-12-23 11:00:55 +01:00
Benno Schulenberg
d49d4f7b56 history: search items *can* contain newlines -- encoded NUL bytes
Decode 0x0A bytes to 0x00 when saving the search history, and encode
them again when reading the file back in, to prevent nano from hanging
or aborting when encountering 0x00 on a line by itself.
2016-12-23 10:54:09 +01:00
Arturo Borrero González
2fbb71d555 syntax: nftables: add two new families, and add set references
Signed-off-by: Arturo Borrero González <arturo@debian.org>
2016-12-23 09:47:44 +01:00
Benno Schulenberg
66356ec7e2 screen: draw new content immediately, to prevent color flashes
After updating the color palette, the corresponding new window content
should be drawn immediately, before some other part of the code calls
doupdate(), to prevent the old content being shown in the new colors.

This fixes https://savannah.gnu.org/bugs/?49912.
Reported-by: Mike Frysinger <vapier@gentoo.org>
2016-12-23 09:25:29 +01:00
Benno Schulenberg
4edc83c3c2 tweaks: move a setting to a better place -- it needs setting just once 2016-12-22 17:08:10 +01:00
Benno Schulenberg
e6350aaba4 prompt: do not treat a leading newline in a filename specially
This fixes https://savannah.gnu.org/bugs/?49884.
2016-12-22 13:46:53 +01:00
Benno Schulenberg
8bf8682b17 binding: use the code for the Enter directly instead of a function call
And certainly don't return zero when the key wouldn't have been found,
because that would have meant jumping a word to the right.
2016-12-22 12:13:03 +01:00
Benno Schulenberg
a9b5a0e029 tweaks: rename a function to something less abbrevy
Also, swap the logic around, to use less braces.
2016-12-22 12:04:10 +01:00
Benno Schulenberg
026393a91a binding: use plain codes instead of function calls for the jumping keys
Which is possible because those keycodes are hard-bound to the relevant
functions.
2016-12-22 11:50:24 +01:00
Benno Schulenberg
db897b574f input: detect again when both Shift and Ctrl are being held on a VT
In nano 2.7.1 and 2.7.2, pressing Shift+Ctrl+Arrow on a Linux console
would behave as if Shift wasn't held.  It got broken three months ago,
by commit 08cd197b, messing up the proper order of the checks.

This fixes https://savannah.gnu.org/bugs/?49906.
2016-12-22 11:13:39 +01:00
Benno Schulenberg
2b1bc6866a input: don't crash when receiving a KEY_CANCEL
On some systems, typing ^C apparently results in a KEY_CANCEL in
the input stream, which gets hard-bound to the do_cancel function.
But in the main menu there is no Cancel function.  So... in that
case, let it fall back to the plain old Ctrl-C code: 0x03.

Reported-by: Liam Gretton <liam.gretton@leicester.ac.uk>
2016-12-21 17:42:15 +01:00
Benno Schulenberg
90b959a677 history: avoid crashing when the positionlog file is malformed 2016-12-21 17:28:09 +01:00
Benno Schulenberg
116d9e6f01 chars: use memory on the stack instead of calling malloc() and free() 2016-12-20 10:05:09 +01:00
Benno Schulenberg
6620acbff4 tweaks: use a faster comparison 2016-12-20 10:03:53 +01:00
Benno Schulenberg
1cb6619d6a undo: there are just two forms of deletion: backspacing and deleting
A third method does not exist.
2016-12-19 21:18:43 +01:00
Benno Schulenberg
79a4bf81dc tweaks: rename five variables, for uniformity with a few others 2016-12-19 19:58:15 +01:00
Benno Schulenberg
b77e6bd99d general: simplify the detection of a SIGWINCH
There is no need for a counter, nor an old counter to compare it with.
2016-12-19 10:04:01 +01:00
Benno Schulenberg
2bcc6d7f66 tweaks: start searching at a better place
Taking the terminating newline into account, and that there is
at least one digit per number.
2016-12-19 09:57:31 +01:00
Benno Schulenberg
cd705a7c4c tweaks: elide a counter and a comparison
For clarity and a tiny bit more speed.  Also rename some variables.
2016-12-19 09:44:30 +01:00
Benno Schulenberg
ecd18c1694 history: search for the two position numbers from EOL instead of BOL
A filename might contain spaces, so we can't look for the numbers
(the second and third elements) starting from the head of the line
-- we have to start at the tail and work backward.

This fixes https://savannah.gnu.org/bugs/?49879.
2016-12-18 19:57:33 +01:00
Benno Schulenberg
bc8a3a50a4 tweaks: rename three variables, for visibility
(I don't /see/ single-letter variables -- they are too small.)
2016-12-18 19:31:11 +01:00
Benno Schulenberg
9b90ec877a tweaks: drive closer to the edge 2016-12-18 17:56:18 +01:00
Benno Schulenberg
8b483c10ba history: don't bother encoding search items -- they cannot contain newlines 2016-12-18 17:55:39 +01:00
Benno Schulenberg
f915a28d30 tweaks: don't bother trimming the final newline from a position item
It is irrelevant -- the line is discarded as soon as the data has been
extracted.
2016-12-18 16:44:39 +01:00
Benno Schulenberg
cb3fc8892a tweaks: rename a variable and rewrap two lines 2016-12-18 16:34:19 +01:00
Benno Schulenberg
06d9ee89e5 history: encode newlines in filenames as nulls
So they will not break a line in the positionlog file in two.

(Strangely, the reading in of such a log file already decodes
nulls back into newlines.)

This fixes https://savannah.gnu.org/bugs/?49877.
2016-12-18 12:27:55 +01:00
Benno Schulenberg
0b0b812206 files: don't change embedded newlines into nulls in filenames
Because changing anything to a null effectively means to truncate
the name.

This fixes https://savannah.gnu.org/bugs/?49868
and fixes https://savannah.gnu.org/bugs/?49874.
2016-12-18 11:37:57 +01:00
Benno Schulenberg
eafae5d417 screen: show an embedded newline in filenames as ^J instead of ^@
The byte 0x0A means 0x00 *only* when it is found in nano's internal
representation of a file's data, not when it occurs in a file name.

This fixes the second part of https://savannah.gnu.org/bugs/?49867.
2016-12-18 11:13:50 +01:00
Benno Schulenberg
dfff78dffe titlebar: always pass a pathname through display_string()
So that embedded control characters will be represented
instead of acted upon.

This fixes the first part of https://savannah.gnu.org/bugs/?49867.
2016-12-18 11:13:49 +01:00
Benno Schulenberg
40acb8714c oops: forgot to add and amend this to the previous commit 2016-12-18 11:12:04 +01:00
Benno Schulenberg
d7af590c6b memory: don't bother making a snug fit for things that will be freed soon
Most full paths are needed only temporarily and will be freed within
milliseconds.  Only 'full_operating_dir' and 'backup_dir' continue to
exist for the whole current session.  Any partition, too, will soon be
unpartitioned, so the extra reallocation is just a waste of time.
2016-12-18 10:33:30 +01:00
Benno Schulenberg
8c7e4f5108 tweaks: rename a function to describe what it does
It doesn't align anything -- any allocations are already aligned to
whatever multiple is required -- it just shrinks the allocated space.
2016-12-18 10:30:35 +01:00
Benno Schulenberg
1144d38316 tweaks: don't bother reallocating a string of which there is only one
And which normally is just some ten or twenty characters long, and
never gets wildly overallocated.
2016-12-18 10:28:30 +01:00
Benno Schulenberg
0562d27b9c tweaks: delete a bunch of unneeded asserts
Nano would crash straight afterward if any of these asserts would fail,
so they don't add anything.  A few others are simply superfluous.
2016-12-15 21:15:32 +01:00
Benno Schulenberg
c5f49167ea tweaks: write two pieces of conditionalized code like all others
Also trim or improve a few comments.
2016-12-15 19:48:09 +01:00
Benno Schulenberg
9765c2faa0 tweaks: elide a function that is called just once 2016-12-15 19:28:43 +01:00
Benno Schulenberg
85ebe971e2 chars: optimize for the most common case
That is: elide a second test from the most travelled path: a valid
character.  This adds a second call of mblen() when parse_mbchar()
is called on a terminating zero, but that should never happen.
2016-12-15 17:44:18 +01:00
Benno Schulenberg
fc101a6ded tweaks: rename a variable to be shorter and clearer 2016-12-15 15:50:07 +01:00
Benno Schulenberg
eb88ad980a tweaks: use a slightly faster comparison 2016-12-15 13:15:46 +01:00
Benno Schulenberg
9fa95a3680 tweaks: put some prototypes in the proper order, and move a bit of code 2016-12-15 13:04:52 +01:00
Benno Schulenberg
d6cc2c40fe tweaks: conditionalize a function that is not used in the tiny version
The fsfromline() function is mostly used by the undo functions, which
are not present in the tiny version.  It is also used by the comment/
uncomment feature, but this feature cannot be enabled when --enable-tiny
is in effect.
2016-12-15 12:45:02 +01:00
Benno Schulenberg
1df4115013 version: properly mention --disable-wordcomp if it was used 2016-12-15 12:38:47 +01:00
Benno Schulenberg
ea9f62fc0f tweaks: adjust some comments and indentation and ordering 2016-12-13 19:27:33 +01:00
Benno Schulenberg
a772194102 tweaks: rename two variables, for self-documentation 2016-12-13 17:13:38 +01:00
Benno Schulenberg
faf77fb1ec tweaks: don't bother making the next line of an end point NULL 2016-12-13 17:12:52 +01:00
Benno Schulenberg
b0b24d9c3a utils: slightly speed up the calculation of the size of a buffer
Achieve this by eliding two conditions from the inner loop,
which is possible because 'end' will never be NULL.
2016-12-13 17:11:08 +01:00
David Lawrence Ramsey
c9f743f676 tweaks: elide two unneeded variables from line numbering mode
Instead compute directly whether we're at a softwrapped part or not.
2016-12-13 17:01:39 +01:00
David Lawrence Ramsey
bd920b1f49 tweaks: adjust the type of two arguments
Convert digits() to take a ssize_t instead of an int, since it's
used on ssize_t line numbers.  And properly use the long modifier
when displaying a line number.

Also, conditionalize the digits() prototype.
2016-12-13 13:06:20 +01:00
Benno Schulenberg
29e094cd21 po: update translations and regenerate POT file and PO files 2016-12-12 15:12:16 +01:00
Benno Schulenberg
7a8ae90dac bump version numbers and add a news item for 2.7.2 2016-12-12 15:05:34 +01:00
Benno Schulenberg
13ec5d8ce9 spelling: correctly restore the selected region
An added magic linefeed should be removed again /before/ restoring
the x position, as the latter needs to be calculated from the real
last line of the region.

This fixes https://savannah.gnu.org/bugs/?49817.
Reported-by: Mike Frysinger <vapier@gentoo.org>
2016-12-11 09:55:38 +01:00
Benno Schulenberg
30591c5e01 tweaks: use a while loop when the end point is not known in advance
It is easier to see the order of steps and what the terminating
condition is.
2016-12-10 21:18:10 +01:00
Benno Schulenberg
3f8e30efb1 tweaks: delete some obscuring debugging stuff
When wanting to debug something, it is far more useful
to temporarily insert lines like:

    statusline(ALERT, "name = %i", variable);

It provides instant feedback, and it slows things down,
so you can kind of see what happens.
2016-12-10 21:01:07 +01:00
Benno Schulenberg
e9fde7d7dc mouse: use the correct screen width for calculating the cursor position
When there are line numbers, the effective available screen width is
smaller than COLS: editwincols.

This fixes https://savannah.gnu.org/bugs/?49821.
2016-12-10 20:06:59 +01:00
Benno Schulenberg
fd3423f79a syntax: give the statistics part of a git patch a different color
Also, be more selective when coloring a git diff line.  And color
an svn index line too.
2016-12-10 17:53:53 +01:00
Benno Schulenberg
a4044a7e5d tweaks: remove some cluttering conditional compilation 2016-12-09 13:32:15 +01:00
Benno Schulenberg
2fa93ae999 tweaks: rename two variables to make more sense 2016-12-09 12:47:00 +01:00
David Lawrence Ramsey
c8c6340ce8 tweaks: conditionalize a bit of softwrap code
This addresses https://savannah.gnu.org/bugs/?49803.
2016-12-09 12:34:56 +01:00
David Lawrence Ramsey
6263416355 moving: always account for the margin when in line numbering mode
Like do_down() does already, do_pageup() and do_right() should use
editwincols instead of COLS.

This addresses https://savannah.gnu.org/bugs/?49796.
2016-12-09 12:23:23 +01:00
David Lawrence Ramsey
84d6f1a5b6 tweaks: adjust the type of four lockfile variables
The functions read() and fwrite() take size_t, not ssize_t.

And line numbers in the file should be displayed as a long type instead
of an int, since the effective type of ssize_t is not int, but long.
2016-12-09 10:05:33 +01:00
Benno Schulenberg
ecccb8d027 tweaks: correct the wording of a string 2016-12-07 21:06:05 +01:00
Benno Schulenberg
173bbe11ef tweaks: add a few translator hints 2016-12-07 21:05:41 +01:00
Benno Schulenberg
7531b71fa1 docs: note Sumedh as the author of the word-completion feature 2016-12-07 21:05:23 +01:00
Benno Schulenberg
964c10db17 tweaks: miscellaneous frobbings and rewrappings 2016-12-07 20:37:08 +01:00
Benno Schulenberg
0e01080983 binding: allow to rebind the word-completion function, and document it 2016-12-07 17:18:56 +01:00
Benno Schulenberg
68a0314500 build: add configure option --disable-wordcomp to disable word completion
(The variable 'pletion_line' is not conditionalized with this option, as
it would become messy.  The compiler will probably be able to elide it.)

When using --enable-tiny, it is not possible to use --enable-wordcomp,
because the word completion function uses the undo system.
2016-12-07 17:02:25 +01:00
Sumedh Pendurkar
dca4ab5d8f new feature: complete a fragment to a longer word found in the buffer
Executing the 'complete_a_word' function will search from the start
of the current buffer for entire words that begin with the fragment
that is before the cursor, and will complete this fragment to the
first word that is found.  Each consecutive call of 'complete_a_word'
will search for the next matching word and will complete the fragment
to that.  By default the function is bound to the ^] keystroke.

Signed-off-by: Sumedh Pendurkar <sumedh.pendurkar@gmail.com>
Signed-off-by: Benno Schulenberg <bensberg@justemail.net>
2016-12-07 16:42:39 +01:00
Benno Schulenberg
86121cf3fc tweaks: move a cursor-on switch to a more logical place (again)
But do it correctly this time: don't switch it on when replacing.
2016-12-05 15:47:44 +01:00
Benno Schulenberg
f03f5d5b51 docs: correct and improve the description of --disable-wrapping 2016-12-04 17:14:11 +01:00
Benno Schulenberg
379b1556ed prompt: remove two fragments of dead code
None of the prompts offer a total-refresh shortcut -- only the
edit window, the help viewer, and the file browser provide this.
2016-12-04 12:34:56 +01:00
Benno Schulenberg
bfcce57b69 screen: remove an unneeded blanking of the statusbar
It's redundant because the call of total_refresh() wipes everything.
2016-12-04 12:32:59 +01:00
Benno Schulenberg
4eac699df3 tweaks: remove some more annoying conditional compilation 2016-12-04 12:26:33 +01:00
Benno Schulenberg
454f5cbdce tweaks: remove a superfluous cleanup call
At the very beginning of do_replace(), nothing has been changed
or initialized yet, so there is nothing to refresh or clean up.
2016-12-04 11:56:13 +01:00
Benno Schulenberg
248d7be8ef build: clean out the revision.h file, to make 'make distcheck' pass 2016-12-04 11:21:10 +01:00
Benno Schulenberg
372bd0f7dd screen: switch the cursor back on only in the main loop
This fixes https://savannah.gnu.org/bugs/?49750.
2016-12-03 18:03:11 +01:00
Benno Schulenberg
f920e0d30c tweaks: replace some unneeded direct calls of edit_refresh() 2016-12-03 17:00:28 +01:00
Benno Schulenberg
0f3e303d1a tweaks: get rid of some spurious textual references to edit_refresh() 2016-12-02 18:13:10 +01:00
Benno Schulenberg
c9680b8b64 input: add the shifted PageUp and PageDown keycodes produced by VTE
Modern VTE-based terminals now produce codes for those keys and
no longer swallow them when nano is active.

This addresses https://savannah.gnu.org/bugs/?49746.
2016-12-01 17:34:57 +01:00
Benno Schulenberg
656563beda screen: don't restore the previous menu after a yesno prompt
There is no need for that -- it just causes flicker.

This fixes https://savannah.gnu.org/bugs/?49742.
2016-12-01 15:54:56 +01:00
Benno Schulenberg
8f95f9b1aa tweaks: reshuffle three initializations and trim some comments 2016-12-01 15:28:59 +01:00
Benno Schulenberg
c6512a9717 screen: don't request an update of the edit window for every yesno prompt
Only when doing replacements does the edit window need a refresh: for
every new spotlight.  So, do the update request in the latter routine.
2016-12-01 15:20:05 +01:00
Benno Schulenberg
07ce01c189 docs: tweak some lines in the NEWS file
(The previous commit fixed https://savannah.gnu.org/bugs/?49737.)
2016-12-01 14:01:38 +01:00
David Lawrence Ramsey
b5400ffe65 general: gettextize three overlooked statusbar messages
This fixes https://savannah.gnu.org/bugs/?48622.
2016-12-01 13:02:43 +01:00
Benno Schulenberg
ac41587d4e oops: the yesno prompt for replacing does not want a visible cursor 2016-11-30 13:47:50 +01:00
Benno Schulenberg
e4b8d6fab5 tweaks: remove a bit of obscuring conditional compilation 2016-11-30 11:46:05 +01:00
Benno Schulenberg
72e8bcb027 tweaks: move a switching on of the cursor to a more logical place 2016-11-30 11:11:06 +01:00
Benno Schulenberg
7401670d58 tweaks: fix compilation when configured with --enable-tiny 2016-11-30 11:05:07 +01:00
David Lawrence Ramsey
87fbe24283 docs: add info about Slang to README.GIT, and improve info about glib2
For UTF-8 support under Slang, at least Slang 2.0 is needed.
And glib2 is also used for snprintf() if it's unavailable.
2016-11-29 12:28:23 +01:00
David Lawrence Ramsey
e4d452424b files: give feedback when restricted mode prevents overwriting a file
Achieve this by reusing the code that gives feedback when trying to
save a buffer while using --tempfile and the file has no name yet.

This fixes https://savannah.gnu.org/bugs/?48622.
2016-11-29 12:08:39 +01:00
David Lawrence Ramsey
d48071b2b2 input: properly check the full escape sequences for all keys
Also for Delete, End, PageUp and PageDown (on some terminals)
the last byte in the sequence needs to be checked.

This fixes https://savannah.gnu.org/bugs/?49710.
2016-11-27 20:31:12 +01:00
Benno Schulenberg
c1a484270b rcfile: actually avoid opening directories and devices
Achieve this elegantly by factoring out the reading of one rcfile.
2016-11-27 18:21:04 +01:00
Benno Schulenberg
981a1d39bf tweaks: factor out a small function 2016-11-27 17:30:53 +01:00
Benno Schulenberg
925a001658 rcfile: check the vital shortcuts just once, not for every included file 2016-11-27 16:40:54 +01:00
Benno Schulenberg
77023a749b tweaks: remove an annoying conditional compilation of an argument
Also remove some unneeded prototypes, adjust some comments, and
move a constant definition to the top of the file.
2016-11-27 16:34:34 +01:00
Benno Schulenberg
1762920808 rcfile: actually don't try to open things that cannot be syntax files 2016-11-26 17:48:31 +01:00
Benno Schulenberg
281a56fb74 tweaks: reshuffle some things in a more linear manner
Also improve or correct some comments.
2016-11-26 17:42:27 +01:00
Benno Schulenberg
592d0d6c9a files: trying to open a non-existent file will never succeed
If it would, the returned file descriptor would make nano crash,
because the corresponding stream has not been opened.  And when
returning zero instead (as the code did originally), nano would
open an empty buffer, although it claims to be reading the file.

In short: I think this is a leftover of an attempted fix of
https://savannah.gnu.org/bugs/?25297, from commit 2823c99.
2016-11-26 17:00:41 +01:00
Benno Schulenberg
3cc561e36e input: distinguish <Shift+Home> from <Home> on an rxvt terminal
That is: when --rebindkeypad is in effect -- without this option
they were already getting distinguished.
2016-11-26 12:25:36 +01:00
Benno Schulenberg
0333b87ad7 input: distinguish <Alt+Left> from <Alt+Right> on an rxvt terminal
Both would jump a word to the left -- now each jumps a word in the
proper direction.
2016-11-26 12:07:33 +01:00
David Lawrence Ramsey
059c8efb44 input: make Shift+Alt+Arrow work properly on rxvt and Eterm terminals
This fixes https://savannah.gnu.org/bugs/?49636.
2016-11-26 11:57:39 +01:00
Mike Frysinger
eb68cd1c6b syntax: avoid using black colors
We should avoid defining color schemes that are unreadable on common
white-on-black or black-on-white terminals.  Change the black in the
autoconf error strings to brightred for that reason.
2016-11-23 21:08:59 +01:00
Mike Frysinger
ecea413802 configure: fix ncurses lib symbol checking
When probing symbols provided by ncurses, use the sublibs that pkg-config
reported in case they're needed (like when libtinfo is a sep library).

URL: https://savannah.gnu.org/bugs/?49614
2016-11-23 14:26:03 -05:00
Benno Schulenberg
95253231e8 docs: mention that libncursesw5-dev is needed for building from git
In addition, tweak some of the wording.
2016-11-20 18:04:21 +01:00
Benno Schulenberg
eb5968f845 startup: activate restricted mode earlier, so --help will reflect it
Kind-of-discovered-by: Markus Bergholz <markuman@gmail.com>
2016-11-17 18:05:09 +01:00
Benno Schulenberg
f2c72bf759 binding: always initialize some keycode variables to a standard value
Also when somehow key_defined() is missing.

This fixes https://savannah.gnu.org/bugs/?49614.
Reported-by: Mike Frysinger <vapier@gentoo.org>
2016-11-17 17:32:28 +01:00
Mike Frysinger
e472b72565 syntax: gentoo: various updates
- make version highlight less blindly greedy and conform to real versions
- move version matching before USE matching to avoid hitting USE flags
  that look like versions
- change USE regex to match the Gentoo PMS
- extend arch match to include more keywords
- make category matching more restrictive to avoid false positives
- drop operators =< and => that Gentoo doesn't support

URL: https://savannah.gnu.org/bugs/?49569
Reported-by: Konstantin Shakhnov <kastian@mail.ru>
2016-11-14 13:44:53 -05:00
Benno Schulenberg
e332d2df74 docs: harmonize the indentation of the README, and tweak some wordings 2016-11-13 20:35:19 +01:00
Benno Schulenberg
ed165827bc screen: don't hide the cursor when --constantshow is used
(Bug was introduced yesterday, by commit a4132e2.)
2016-11-13 20:00:31 +01:00
Benno Schulenberg
65bf36baa5 rcfile: let a 'set fill' reenable hardwrapping
Otherwise the user can override a 'set nowrap' in /etc/nanorc only
via the command line.

This fixes https://savannah.gnu.org/bugs/?49593 reported by Shirish.
2016-11-13 19:47:15 +01:00
Benno Schulenberg
7598b77e75 screen: use the correct width to determine whether a softwrap occurred
This fixes the two bugs reported by Anton Minaev
in https://savannah.gnu.org/bugs/?49511.
2016-11-13 19:20:38 +01:00
Benno Schulenberg
a4132e2e64 screen: do a refresh before changing the value of 'focusing'
This fixes https://savannah.gnu.org/bugs/?49530.
2016-11-12 18:02:03 +01:00
Benno Schulenberg
8a66c820ab syntax: don't leave the number after 'fill' and 'tabsize' in red
Also, don't use ignore-case for things that don't contain letters.
2016-11-12 13:00:09 +01:00
Benno Schulenberg
af0f81f71d docs: mention that a foreground color can be bright
Also replace some backslashed spaces because they hinder the
justification of the man page.
2016-10-30 10:03:06 +01:00
Benno Schulenberg
ea1afac9db po: update translations and regenerate POT file and PO files 2016-10-29 11:53:44 +02:00
Benno Schulenberg
04aab233d0 bump version numbers and add a news item for 2.7.1 2016-10-29 11:11:33 +02:00
Benno Schulenberg
33bc848c5b binding: properly conditionalize the UTF-8 parts
Reported-by: Sumedh Pendurkar <sumedh.pendurkar@gmail.com>
2016-10-29 10:19:28 +02:00
Benno Schulenberg
4c476bc872 scrolling: use a comparison that will work also in softwrap mode
This fixes https://savannah.gnu.org/bugs/?49467.
2016-10-28 11:38:58 +02:00
Benno Schulenberg
9c2e270b3e softwrap: initialize 'editwincols' early, for computing the number of wraps
When giving a line number on the command line, do_gotolinecolumn() needs
to know the width of the screen to be able to (roughly) place the target
line in the center of the screen.

This fixes https://savannah.gnu.org/bugs/?49462.
2016-10-28 10:50:06 +02:00
Benno Schulenberg
0eef5610eb files: mark a new buffer as modified after inserting command output
This fixes https://savannah.gnu.org/bugs/?49423.
2016-10-27 20:05:05 +02:00
Benno Schulenberg
2a55d2b29a tweaks: adjust some comments and reduce the scope of some variables
Also remove some cluttering conditional compilation.
2016-10-27 20:04:50 +02:00
Benno Schulenberg
5416b9c09d tweaks: remove a band-aid condition that is no longer needed
Also, don't bother conditionalizing two booleans for the tiny version.
2016-10-27 20:00:01 +02:00
Benno Schulenberg
7287300e0d tweaks: compile two parameters unconditionally 2016-10-27 12:24:41 +02:00
Benno Schulenberg
ffeb0f9d4b tweaks: don't spread a statement over multiple lines unnecessarily 2016-10-27 11:41:49 +02:00
Benno Schulenberg
10c9093942 general: add the option -g/--showcursor, to match Pico
The nanorc option already exists, but not the corresponding one
for the command line.
2016-10-27 11:34:41 +02:00
Benno Schulenberg
b38cbfe173 startup: always initialize 'margin' and 'editwincols'
This fixes https://savannah.gnu.org/bugs/?49428.
2016-10-24 17:40:06 +02:00
Benno Schulenberg
702b09c859 tweaks: elide a parameter that is always FALSE 2016-10-23 20:07:39 +02:00
Benno Schulenberg
2cd8ca4eb1 tweaks: stop compiling the whole_word_only parameter conditionally
This make tiny nano slightly less tiny, but makes the code more readable.
2016-10-23 20:07:30 +02:00
Benno Schulenberg
55b1403542 tweaks: adjust some whitespace and a comment 2016-10-23 17:26:19 +02:00
Benno Schulenberg
9d5ee16614 tweaks: don't bother redrawing some lines when whole screen will be redrawn 2016-10-23 17:26:19 +02:00
Benno Schulenberg
01bbf7e82f tweaks: rename a function to better describe what it does
It does not update anything -- it just picks a new point from
where to start displaying the buffer.  All actual updating of
the screen is done by edit_refresh() and edit_redraw() and such.
2016-10-23 17:26:19 +02:00
Benno Schulenberg
3ed5ddba31 docs: remove a reference that was only valid on Debian systems 2016-10-23 17:22:30 +02:00
Benno Schulenberg
6cacd1e320 tweaks: make several small adjustments to the documentation 2016-10-23 12:29:21 +02:00
Benno Schulenberg
d9cae81a0e docs: mention the existence of the toggles in the man page 2016-10-22 17:27:15 +02:00
Benno Schulenberg
83ee1feda4 docs: add 'set linenumbers' and '--linenumbers' to the texinfo document
Also mention the corresponding toggle (M-#).
2016-10-22 17:06:50 +02:00
Benno Schulenberg
c7610ba356 docs: add 'linenumbers' and 'numbercolor' to the sample nanorc 2016-10-22 13:49:13 +02:00
Benno Schulenberg
ae648778e2 screen: refresh when a new magicline is added in line-numbering mode
This fixes https://savannah.gnu.org/bugs/?49406.
2016-10-21 15:59:16 +02:00
Benno Schulenberg
023edffe3d screen: move the margin determination to the main loop
There is no need to look at this for every painted line, because
the margin can only change when some key is struck.
2016-10-21 14:56:56 +02:00
Benno Schulenberg
2789bb0813 screen: repaint the edit window in a single place -- the main loop
Instead of doing this in two places: after interpreting shortcuts,
and after injecting characters.
2016-10-21 14:56:53 +02:00
Benno Schulenberg
4d996e4c39 screen: suppress line numbers when the terminal is very narrow
To prevent the display from getting messed up, making nano unusable.
2016-10-21 14:55:43 +02:00
Benno Schulenberg
de2aa4f24a rcfile: add an option to customize the color of line numbers 2016-10-20 16:48:45 +02:00
Faissal Bensefia
de95ca68f7 new feature: the ability to show line numbers before the text
It can be activated with --linenumbers on the command line or with
'set linenumbers' in a nanorc file, and it can be toggled with M-#.

Signed-off-by: Faissal Bensefia <faissaloo@gmail.com>
Signed-off-by: Benno Schulenberg <bensberg@justemail.net>
2016-10-20 16:47:52 +02:00
Benno Schulenberg
55878efe5d binding: supply the keycode for most special keys directly
Instead of figuring them out from the string.  This is possible
because those dedicated editing keys cannot be rebound anyway.
2016-10-18 20:38:27 +02:00
Benno Schulenberg
43f35fc7a9 softwrap: ensure the current line is fully visible when moving in it
This fixes https://savannah.gnu.org/bugs/?49099,
and fixes the unreported corresponding bugs for
<End> and <Del> and typing extra characters.
2016-10-18 15:07:47 +02:00
Benno Schulenberg
d66ea08473 moving: adjust the Y position to correspond with the changed X position
So the softwrap code in do_down() can compute the correct amount to scroll.

This fixes https://savannah.gnu.org/bugs/?49374.
2016-10-18 11:46:15 +02:00
Benno Schulenberg
8476bf86a1 tweaks: fix compilation when configured with --enable-tiny 2016-10-15 18:05:01 +02:00
Benno Schulenberg
c92982d60f binding: fix some duplicated carets and too restrictive menus 2016-10-15 17:18:51 +02:00
Benno Schulenberg
7a274d621a binding: use arrows instead of words to designate the cursor keys 2016-10-15 17:04:01 +02:00
Benno Schulenberg
fdee0df849 input: keep the Ctrl+Arrow keys working when their synonyms are unbound
This fixes https://savannah.gnu.org/bugs/?49058 reported by Rishabh Dave.
2016-10-15 17:03:10 +02:00
Benno Schulenberg
00efa50385 build: avoid updated PO files being remerged upon every make 2016-10-15 15:09:34 +02:00
Benno Schulenberg
a35803d502 build: avoid an annoying warning at configure time 2016-10-15 15:06:18 +02:00
Benno Schulenberg
7013039c3a tweaks: rename a variable, for consistency 2016-10-12 21:10:04 +02:00
Benno Schulenberg
925ad6393a tweaks: remove a superfluous setting, and add a comment 2016-10-12 21:07:16 +02:00
Benno Schulenberg
3264d0c5be tweaks: move a variable that doesn't need to be global 2016-10-12 19:59:26 +02:00
Benno Schulenberg
d9148e7b3f tweaks: elide an unneeded variable 2016-10-12 19:20:39 +02:00
Benno Schulenberg
0a18d8912b screen: defeat a VTE bug by doing an extra cursor move and update
This fixes https://savannah.gnu.org/bugs/?49106.
2016-10-12 13:56:48 +02:00
Benno Schulenberg
815b326864 syntax: show another deprecated keyword (replace2) in red 2016-10-11 20:57:57 +02:00
Rishabh Dave
01bf034bb6 rcfile: reject rebindings that have no effect or have side effects
Also, show in green only the ^ and M- combinations that are valid.

This fixes https://savannah.gnu.org/bugs/?49097.

Signed-off-by: Rishabh Dave <rishabhddave@gmail.com>
Signed-off-by: Benno Schulenberg <bensberg@justemail.net>
2016-10-11 19:46:18 +02:00
Benno Schulenberg
d716809228 scrolling: don't put the last line at the bottom when softwrap in on
This avoids https://savannah.gnu.org/bugs/?49298.
2016-10-10 13:19:51 +02:00
Benno Schulenberg
8041627cc3 tweaks: remove a bit of duplication 2016-09-20 12:54:16 +02:00
Benno Schulenberg
598e0af7af softwrap: scroll the current line fully into view when jumping words
This fixes https://savannah.gnu.org/bugs/?47710
and fixes https://savannah.gnu.org/bugs/?49088.
2016-09-20 12:29:10 +02:00
Benno Schulenberg
8ba57cf87b input: don't return zero when some function is completely unbound
Returning a zero would mean returning a ^Space -- the keycode that
by default is bound to the Next-Word function.  So, unbinding the
keys to which the modified Arrow keys are hard bound would cause
the latter ones to mysteriously jump to the next word.

This partially fixes https://savannah.gnu.org/bugs/?49058.
2016-09-20 11:11:44 +02:00
Rishabh Dave
e2027aee15 rcfile: reject key names that are wrong or too long
Meta keys should have a dash as second character, and apart from ^Space
and M-Space key names should be at most two or three characters long.

This fixes https://savannah.gnu.org/bugs/?44688.

Reviewed-by: Benno Schulenberg <bensberg@justemail.net>
Signed-off-by: Rishabh Dave <rishabhddave@gmail.com>
2016-09-14 19:53:38 +02:00
Benno Schulenberg
97f6ae5267 softwrap: scroll 'enough' whenever it surpasses 'amount'
This fixes https://savannah.gnu.org/bugs/?49086.
2016-09-14 12:40:58 +02:00
Benno Schulenberg
fc9c7b4917 softwrap: scroll when searching lands on an overlong bottom line
This fixes https://savannah.gnu.org/bugs/index.php?42189.
2016-09-14 11:02:36 +02:00
Benno Schulenberg
77a1a5c3e4 tweaks: reshuffle some ifdefs, for less fragmentation 2016-09-14 11:00:18 +02:00
Benno Schulenberg
bc8bb7e942 screen: keep the help items nicely lined up also in the tiny version 2016-09-13 09:29:44 +02:00
Benno Schulenberg
08cd197bf1 general: include word-jumping and block-jumping into the tiny version
And also case-sensitive searches, backward searches, and searching again.
2016-09-13 09:27:04 +02:00
Benno Schulenberg
4de0a5049b tweaks: reshuffle an if statement 2016-09-11 21:43:47 +02:00
Benno Schulenberg
dc76e84657 files: alert about an unwritable file also in the tiny version 2016-09-11 21:40:50 +02:00
Benno Schulenberg
1c2b35675e tweaks: adjust some indentation 2016-09-11 21:36:46 +02:00
Benno Schulenberg
add0d698b7 syntax: show deprecated keywords in red, and 'wordchars' in green 2016-09-11 12:22:02 +02:00
Benno Schulenberg
09e95b2d91 tweaks: frob a few comments 2016-09-11 11:26:09 +02:00
Benno Schulenberg
03fd6f3af8 tweaks: remove a useless cursor movement 2016-09-11 10:43:21 +02:00
Benno Schulenberg
b92d35d1f2 browser: add the option showcursor, to place the cursor on the highlight
This lets users of braille displays find the selected item immediately.

This fulfills a request by Enrico Mioso.
See https://lists.gnu.org/archive/html/nano-devel/2016-09/msg00025.html.
2016-09-11 09:41:52 +02:00
Benno Schulenberg
9eeb1c8fb8 docs: brush up the TODO list 2016-09-08 12:11:38 +02:00
Benno Schulenberg
ad83ed22d9 input: handle the "resize key" in a better way
And correct a comment: the key /does/ occur also in the tiny version.
2016-09-06 12:09:18 +02:00
Benno Schulenberg
3ddf6ff955 syntax: make the contents of the X-Bugs field in a PO file stand out 2016-09-06 10:58:03 +02:00
Benno Schulenberg
d04c0b7555 docs: refresh some info in the FAQ 2016-09-03 21:46:22 +02:00
Benno Schulenberg
f13707fd1d history: slate the search-history migration for removal 2016-09-03 21:04:17 +02:00
Benno Schulenberg
ed9e5d7183 docs: mark some rebindable function names as deprecated 2016-09-03 20:12:29 +02:00
Benno Schulenberg
2fd497e3ef tweaks: remove a superfluous blanking of the statusbar
The prompt from which the browser was invoked has already blanked it.
2016-09-03 15:34:44 +02:00
Benno Schulenberg
fd6308d6d3 tweaks: reshuffle a couple of items 2016-09-03 13:42:19 +02:00
Benno Schulenberg
1dbebbcadc screen: keep the help items aligned in more configurations
This fixes https://savannah.gnu.org/bugs/?48987.
2016-09-03 13:35:19 +02:00
Benno Schulenberg
57d1755d10 tweaks: preen some comments, and reshuffle a few ifdefs 2016-09-03 12:14:08 +02:00
Benno Schulenberg
bace664fbc startup: allow to rebind the RegExp toggle also in the tiny version
This fixes https://savannah.gnu.org/bugs/?48988.
2016-09-03 11:45:49 +02:00
Benno Schulenberg
acd8809d71 tweaks: use hard-baked keycodes where possible
These keycodes have non-rebindable entries in the list of shortcuts, so
they will always be there -- no need for a function call to find them.
2016-09-02 12:04:29 +02:00
Benno Schulenberg
7b7d2bf7c9 tweaks: make tiny nano a teeny bit smaller 2016-09-02 12:01:03 +02:00
128 changed files with 27671 additions and 26314 deletions

View File

@@ -39,7 +39,7 @@ Mike Frysinger <vapier@gentoo.org>
* Gentoo package maintainer. Whitespace display mode,
--enable-utf8/--disable-utf8 configure options for ncurses,
many new color regexes and improvements to existing color
regexes for nanorc.sample, and miscellaneous bug fixes.
regexes in syntax/*.nanorc, and miscellaneous bug fixes.
Mark Majeres <mark@engine12.com>
* A functional undo/redo system, and coloring nano's interface.
@@ -50,6 +50,12 @@ Mahyar Abbaspour <mahyar.abaspour@gmail.com>
Mike Scalora <mike@scalora.org>
* The comment/uncomment feature.
Faissal Bensefia <faissaloo@gmail.com>
* Line numbers.
Sumedh Pendurkar <sumedh.pendurkar@gmail.com>
* The word-completion feature.
Benno Schulenberg <bensberg@justemail.net>
* An array of small bug fixes, the cut-word and block-jump
routines, text selection by holding Shift, and some extra

4773
ChangeLog

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

4010
ChangeLog.2007-2015 Normal file

File diff suppressed because it is too large Load Diff

View File

@@ -1,6 +1,10 @@
Improvements in GNU nano
========================
Since 2.7.0:
- The keystroke ^] to complete a fragment to an existing full word.
- The ability to display line numbers in front of the text (M-#).
Since 2.6.0:
- Shift plus the cursor keys can be used for selecting text.
- Ctrl+Arrow should now work also on a Linux virtual console.

View File

@@ -2,6 +2,11 @@ AUTOMAKE_OPTIONS = gnu no-dependencies
SUBDIRS = doc m4 po src
EXTRA_DIST = ChangeLog.pre-2.1 IMPROVEMENTS README.GIT nano.spec
if USE_COLOR
SUBDIRS += syntax
endif
EXTRA_DIST = ChangeLog.1999-2006 ChangeLog.2007-2015 \
IMPROVEMENTS README.GIT nano.spec
ACLOCAL_AMFLAGS = -I m4

78
NEWS
View File

@@ -1,3 +1,47 @@
2017.01.10 - GNU nano 2.7.4 "Red dress" undoes deletions in an orderly
manner again (bug was introduced in previous version),
sets the preferred x position for vertical movements
more consistently, avoids some scrolling problems in
softwrap mode, installs the Info manual also when your
system lacks 'makeinfo', and corrects the behavior of
the beginning-of-word anchor (\<) in regex searches.
2016.12.28 - GNU nano 2.7.3 "Ontbijtkoek" wipes away a handful of bugs:
your editor is now able to handle filenames that contain
newlines, avoids a brief flash of color when switching
between buffers that are governed by different syntaxes,
makes the Shift+Ctrl+Arrow keys select text again on a
Linux console, is more resistant against malformations
in the positionlog file, and does not crash when ^C is
typed on systems where it produces the code KEY_CANCEL.
Oh, and it no longer mistakenly warns about editing an
unlocked file just after saving a new one. That's it.
Tastes great with thick butter.
2016.12.12 - GNU nano 2.7.2 "Shemesh! Shemesh!" brings another feature:
the ability to complete with one keystroke (^] by default)
a fragment of a word to a full word existing elsewhere in
the current buffer. Besides, this release fixes two bugs
related to using line numbers in softwrap mode, allows to
use the PageUp and PageDown keys together with Shift on
VTE-based terminals, stops the help lines from flickering
during interactive replacing, makes a "set fill" override
an earlier "set nowrap", properly restores the selected
region after an external spell check, and improves a few
other tidbits. If you should find any more bugs, please
run 'man nano | grep bugs' and report them there.
2016.10.29 - GNU nano 2.7.1 "Leuven" adds an often-asked-for feature: the
ability to display line numbers beside the text. This can
be activated with -l or --linenumbers on the command line,
or with 'set linenumbers' in your nanorc, or toggled with
M-#. The coloring of these numbers can be chosen via the
option 'set numbercolor'. This release furthermore fixes
some bugs with scrolling in softwrap mode, is more strict
in the parsing of key rebindings, and marks a new buffer
as modified when the output of a command (^R ^X) has been
read into it. Come and check it out!
2016.09.01 - GNU nano 2.7.0 "Suni" adds a new feature: allowing text to be
selected by holding Shift together with the cursor keys.
Besides that, nano now works also when run in very tiny
@@ -192,7 +236,7 @@
linter support (see the nanorc man page for details). Also
included are much improved syntax highlighting code, and
configurations for JSON, texinfo, Go, and a default syntax
for catch all highlighting. Finally, nano now has the
for catch-all highlighting. Finally, nano now has the
ability to set the color of the title bar, status bar, and
shortcut keys (e.g. "^X") and their descriptions. Again
see the nanorc page for details. There's much more, too
@@ -1001,19 +1045,19 @@
Also, the "show position" code now shows the starting
column as 1 instead of 0. Have fun!
2002.03.05 - GNU nano 1.1.7 "lets change everything and see what breaks"
is released. New features include new flags
-N, --noconvert to stop any file format conversion and
-Q, --quotestr for the new quoted text justification, a
new tempnam() implementation to avoid silly warnings,
2002.03.05 - GNU nano 1.1.7 "let's change everything and see what breaks"
is released. New features include the new flags
-N, --noconvert (to stop any file format conversion) and
-Q, --quotestr (for the new quoted text justification),
a new tempnam() implementation to avoid silly warnings,
DOS and Mac file options in the Write File dialog,
multiple save files (file.1) for abnormal exits, ^C now
shows column as well as character position, and
multibuffer allows duplicate files, even unnamed ones.
Also, the static shortcut and toggle lengths are
history, nano now reads SYSCONFDIR/nanorc if rc file
support is enabled, and nano is now built with (and
requires for rebuilding) autoconf 2.5.
multiple save files (file.1) for abnormal exits,
^C now showing column as well as character position, and
multibuffer allowing duplicate files, even unnamed ones.
Also, the static shortcut and toggle lengths are history,
nano now reads SYSCONFDIR/nanorc if rc file support is
enabled, and nano is now built with (and for rebuilding
requires) autoconf 2.5.
This release also includes fixes for some memory
leaks, detecting DOS and Mac file format, justification,
suspending keys, search & replace under various
@@ -1289,7 +1333,7 @@
New features include better (not yet perfect) binary
display support and toggle support for most of the
program flags (M-c, M-i, M-z, M-x, M-p, M-w, M-m, M-k
and M-e for -c, -i, -x, -p, -w, -k, and -R).
and M-e for -c, -i, -z, -x, -p, -w, -m, -k, and -R).
2000.08.09 - Nano 0.9.16, after some struggling, is released. This
release should fix a few of the holes that 0.9.15 dug.
@@ -1324,8 +1368,8 @@
other major changes, this should be the feature set for
nano 1.0, whenever it might be released =-)
2000.07.07 - Nano 0.9.12 (The "lucky day" release) is bursting with new
features, bug fixes, and yummy fruit flavor. For
2000.07.07 - Nano 0.9.12 (the "lucky day" release) is bursting with
new features, bug fixes, and yummy fruit flavor. For
changes, the alternate replace keystroke ^W^T is now
^W^R to be compatible with later versions of Pico. ^W^T
is now goto line, again for Pico compatibility. As for
@@ -1422,7 +1466,7 @@
path. The bug was in the new code for checking whether
nano is invoked as 'pico'.
2000.04.14 - 0.9.1 has some more Pico compatibility built-in. The
2000.04.14 - Nano 0.9.1 has some more Pico compatibility built-in. The
option to switch to/from Search and Search/Replace (^T)
is now available, and nano now displays the more
Pico-like shortcut list when invoked as 'pico' (i.e. if

81
README
View File

@@ -1,70 +1,67 @@
GNU nano - an enhanced clone of the Pico text editor.
GNU nano -- an enhanced clone of the Pico text editor
Overview
The nano project was started because of a few "problems" with the
wonderfully easy-to-use and friendly Pico text editor.
The nano project was started because of a few "problems" with the
wonderfully easy-to-use and friendly Pico text editor.
First and foremost was its license: the Pine suite does not use
the GPL or a GPL-friendly license, and has unclear restrictions on
redistribution. Because of this, Pine and Pico are not included
with many GNU/Linux distributions. Also, other features (like
go-to-line-number or search-and-replace) were unavailable until
recently or require a command-line flag. Yuck.
First and foremost was its license: the Pine suite does not use
the GPL or a GPL-friendly license, and has unclear restrictions on
redistribution. Because of this, Pine and Pico are not included
with many GNU/Linux distributions. Also, other features (like
go-to-line-number or search-and-replace) were unavailable until
recently or require a command-line flag. Yuck.
nano aims to solve these problems by emulating the functionality of
Pico as closely as possible while addressing the problems above and
providing other extra functionality.
nano aims to solve these problems by emulating the functionality of
Pico as closely as possible while addressing the problems above and
providing other extra functionality.
The nano editor is an official GNU package. For more information on
GNU and the Free Software Foundation, please see http://www.gnu.org/.
The nano editor is an official GNU package. For more information on
GNU and the Free Software Foundation, please see http://www.gnu.org/.
How to compile and install nano
Download the nano source code, then:
Download the nano source code, then:
tar zxvf nano-x.y.z.tar.gz
cd nano-x.y.z
./configure
make
make install
tar xvzf nano-x.y.z.tar.gz
cd nano-x.y.z
./configure
make
make install
It's that simple. Use --prefix with configure to override the
default installation directory of /usr/local.
It's that simple. Use --prefix with configure to override the
default installation directory of /usr/local.
If you haven't configured with the "--disable-nanorc" option, after
installation you may want to copy the doc/nanorc.sample to your
home directory, rename it to ".nanorc", and then edit it according
to your taste.
If you haven't configured with the --disable-nanorc option, after
installation you may want to copy the doc/sample.nanorc file to
your home directory, rename it to ".nanorc", and then edit it
according to your taste.
Web Page
https://nano-editor.org/
Mailing Lists and Bug Reports
Mailing Lists
Savannah hosts all the nano-related mailing-lists.
There are three nano-related mailing-lists.
+ info-nano@gnu.org is a very low traffic list used to announce
new nano versions or other important information about the
project.
new nano versions or other important info about the project.
+ help-nano@gnu.org is for those seeking to get help without
wanting to hear about the technical details of its development.
+ nano-devel@gnu.org is the list used by the people that make
nano and a general development discussion list, with moderate
traffic.
+ nano-devel@gnu.org is the list used by the people that make nano
and a general development discussion list, with moderate traffic.
To subscribe, send email to <name>-request@gnu.org with a
subject of "subscribe", where <name> is the list you want to
subscribe to.
To subscribe, send email to <name>-request@gnu.org with a subject
of "subscribe", where <name> is the list you want to subscribe to.
For general bug reports, please file a description of the problem
on the Savannah bug tracker page for nano
(https://savannah.gnu.org/bugs/?group=nano). The issue may have
already been reported, and we are better able to track the state
of the issue and whom to notify when fixed, the more the bug
tracker is used.
Bug Reports
To report a bug, please file a description of the problem on nano's
bug tracker (https://savannah.gnu.org/bugs/?group=nano -- hover on
"Bugs", then click "Submit new"). The issue may have already been
reported, so please look first.
Current Status

View File

@@ -1,39 +1,42 @@
INSTRUCTIONS TO COMPILE AND INSTALL NANO GIT VERSIONS
=====================================================
INSTRUCTIONS FOR COMPILING AND INSTALLING NANO FROM GIT
=======================================================
The latest version of GNU nano is available via git, but building this needs
a bit more care than the official stable and unstable tarballs.
The latest changes and fixes for GNU nano are available via git, but
building this needs a bit more care than the official tarballs.
Prerequisites
-------------
To successfully compile GNU nano from the git repo, you'll need the following
To successfully compile GNU nano from git, you'll need the following
packages:
- autoconf (version >= 2.61)
- automake (version >= 1.7)
- autopoint (version >= 0.11.5)
- gettext (version >= 0.11.5)
- git (version >= 2.7.4)
- groff (version >= 1.12)
- pkg-config (version >= 0.22)
- texinfo (version >= 4.0)
- glib 2.x (in case your system doesn't have vsnprintf(), which the
configure script will check for)
- make, gcc, and
- the normal development libraries (curses or slang, etc.)
- gcc (any version)
- make (any version)
If you want UTF-8 support, you will also need libncursesw5-dev installed
(version >= 5.7), or libslang2-dev (version >= 2.0) if you use --with-slang.
If your system doesn't have 'snprintf' or 'vsnprintf' (which the configure
script will check for), you will also need glib-2.x installed.
These should all be available in your distro's package manager or software
center, or otherwise on any GNU mirror. Note that you'll need a version of
curses or slang with wide character support if you want nano to use UTF-8.
center, or otherwise on any GNU mirror.
Download the source
-------------------
To obtain the current nano development code (called 'master', or sometimes
'trunk'), use the following command. It will create a copy of the files in
a subdirectory of your current working directory called 'nano':
To obtain the current nano development branch (called 'master'), use the
following command. It will create in your current working directory a
subdirectory called 'nano' containing a copy of all of the files:
$ git clone git://git.savannah.gnu.org/nano.git nano

40
TODO
View File

@@ -1,9 +1,8 @@
TODO file (? means the feature may be implemented, but not definitely)
------------------------------------------------------------------------
A list of desired features
--------------------------
For the future (no targeted version, catch-all)
Vague musings:
- FriBidi support?
- Port to DJGPP?
- Make matching bracket searches sophisticated enough to skip over
brackets inside comments?
- Allow indentation of marked text by spaces as well as tabs?
@@ -12,26 +11,27 @@ For the future (no targeted version, catch-all)
- Allow conversion between different character sets. Maybe use glib's
iconv() if the system's iconv() is inadequate, since we already use
glib's vsnprintf() if the system lacks vsnprintf()?
- Allow setting marks (saved positions, not to be confused with the mark
set via Ctrl-^) at various lines and/or columns in the buffer, and
allow movement between them with a single keystroke?
- Allow searching for and replacing newlines?
See also https://savannah.gnu.org/bugs/?47053.
- New regression framework built on expect?
- Add the ability to move to different lines of the screen with a single
keystroke, e.g. M-` (M-~) to go to the top line, M-& (M-7) to go to
the center line, and M-' (M-") to go to the last line?
Somewhat urgent:
- Allow text searches in the help viewer.
See https://savannah.gnu.org/bugs/?28994.
- Detect when text is being pasted, so that we can handle it faster.
See https://savannah.gnu.org/bugs/?40060.
- Allow color syntaxes to apply to more than just color, so that we can
e.g. specify a different alternate spell checker depending on which
file type we have open.
- Allow setting marks (saved positions, not to be confused with the mark
set via Ctrl-^) at various lines and/or columns in the buffer, and
allow movement between them with a single keystroke? (We're running
out of keystrokes, though.)
- Allow searching for and replacing newlines.
For version 2.6:
- New regression framework built on expect.
- Allow text searches in the help viewer.
- Add the ability to move to different lines of the screen with a single
keystroke, e.g. M-` (M-~) to go to the top line, M-& (M-7) to go to
the center line, and M-' (M-") to go to the last line.
- Detect when we're pasting text, so that we can handle it differently
(i.e. faster than currently with screen redraws).
- Allow piping marked text to an external command and replacing it with
the command's output (as the internal spell checker already does with
the "spell" command)?
the command's output -- that is: generalize the spell-check flow.
See also https://savannah.gnu.org/bugs/?28993.
For version 2.4:
- Handle window resizes better. After we've resized, we should stay

View File

@@ -16,7 +16,7 @@
# You should have received a copy of the GNU General Public License
# along with this program. If not, see http://www.gnu.org/licenses/.
AC_INIT([GNU nano], [2.7.0], [nano-devel@gnu.org], [nano])
AC_INIT([GNU nano], [2.7.4], [nano-devel@gnu.org], [nano])
AC_CONFIG_SRCDIR([src/nano.c])
AC_CANONICAL_HOST
AM_INIT_AUTOMAKE
@@ -88,13 +88,12 @@ if test "x$enable_tiny" = xyes; then
if test "x$enable_comment" = xyes; then
AC_MSG_ERROR([--enable-comment cannot work with --enable-tiny])
else
# Disabling nanorc silently disables comment support.
enable_comment=no
fi
fi
if test "x$disable_comment" != xyes; then
if test "x$enable_comment" != xno; then
AC_DEFINE(ENABLE_COMMENT, 1, [Define this to disable the comment/uncomment functionality.])
AC_DEFINE(ENABLE_COMMENT, 1, [Define this to enable the comment/uncomment function.])
fi
fi
@@ -125,6 +124,19 @@ fi
AC_ARG_ENABLE(libmagic,
AS_HELP_STRING([--disable-libmagic], [Disable detection of file types via libmagic]))
AC_ARG_ENABLE(linenumbers,
AS_HELP_STRING([--disable-linenumbers], [Disable line numbering]))
if test "x$enable_tiny" = xyes; then
if test "x$enable_linenumbers" != xyes; then
enable_linenumbers=no
fi
fi
if test "x$disable_linenumbers" != xyes; then
if test "x$enable_linenumbers" != xno; then
AC_DEFINE(ENABLE_LINENUMBERS, 1, [Define this to enable line numbering.])
fi
fi
AC_ARG_ENABLE(mouse,
AS_HELP_STRING([--disable-mouse], [Disable mouse support (and -m flag)]))
if test "x$enable_mouse" = xno; then
@@ -160,7 +172,22 @@ fi
AC_ARG_ENABLE(tabcomp,
AS_HELP_STRING([--disable-tabcomp], [Disable tab completion functions]))
if test "x$enable_tabcomp" = xno; then
AC_DEFINE(DISABLE_TABCOMP, 1, [Define this to disable the tab completion functions for files and search strings.])
AC_DEFINE(DISABLE_TABCOMP, 1, [Define this to disable the tab completion functions for filenames and search strings.])
fi
AC_ARG_ENABLE(wordcomp,
AS_HELP_STRING([--disable-wordcomp], [Disable the word completion function]))
if test "x$enable_tiny" = xyes; then
if test "x$enable_wordcomp" = xyes; then
AC_MSG_ERROR([--enable-wordcomp cannot work with --enable-tiny])
else
enable_wordcomp=no
fi
fi
if test "x$disable_wordcomp" != xyes; then
if test "x$enable_wordcomp" != xno; then
AC_DEFINE(ENABLE_WORDCOMPLETION, 1, [Define this to enable the word completion function.])
fi
fi
AC_ARG_ENABLE(wrapping,
@@ -538,8 +565,12 @@ else
AC_MSG_RESULT([Using $CURSES_LIB_NAME as the curses library])
fi
AC_CHECK_LIB([$CURSES_LIB_NAME], use_default_colors, AC_DEFINE(HAVE_USE_DEFAULT_COLORS, 1, [Define this if your curses library has the use_default_colors() command.]))
AC_CHECK_LIB([$CURSES_LIB_NAME], key_defined, AC_DEFINE(HAVE_KEY_DEFINED, 1, [Define this if your curses library has the key_defined() command.]))
AC_CHECK_LIB([$CURSES_LIB_NAME], [use_default_colors],
[AC_DEFINE(HAVE_USE_DEFAULT_COLORS, 1, [Define this if your curses library has the use_default_colors() command.])],
[], [$CURSES_LIB])
AC_CHECK_LIB([$CURSES_LIB_NAME], [key_defined],
[AC_DEFINE(HAVE_KEY_DEFINED, 1, [Define this if your curses library has the key_defined() command.])],
[], [$CURSES_LIB])
dnl Parse any configure options.
@@ -597,12 +628,10 @@ AC_CACHE_CHECK([for enhanced regular expression flag], nano_cv_flag_reg_extended
AC_DEFINE_UNQUOTED(NANO_REG_EXTENDED, $nano_cv_flag_reg_extended,
[Flag(s) to use to get the full range of extended regular expressions])
if test x$color_support = xyes; then
# Now check for the end-of-word boundary support (/< and />).
AC_MSG_CHECKING([for GNU-style word boundary regex support])
AC_ARG_WITH(wordbounds,
AS_HELP_STRING([--with-wordbounds], [Use GNU-style word boundary delimiters]),
# Check for word-boundary support (/< and />).
AC_MSG_CHECKING([for GNU-style word boundary regex support])
AC_ARG_WITH(wordbounds,
AS_HELP_STRING([--with-wordbounds], [Use GNU-style word boundary delimiters]),
[ case "$with_wordbounds" in
no)
AC_MSG_RESULT(no)
@@ -639,6 +668,7 @@ int main(void)
)
])
if test x$color_support = xyes; then
# if test x$CURSES_LIB_NAME = xcurses; then
AC_MSG_CHECKING([whether _XOPEN_SOURCE_EXTENDED is needed])
AC_TRY_RUN([
@@ -702,10 +732,6 @@ else
fi
AM_CONDITIONAL(GROFF_HTML, test x$groff_html_support = xyes)
# Check for the availability of makeinfo.
AC_CHECK_PROG(haveit, makeinfo, yes, no)
AM_CONDITIONAL(HAVE_MAKEINFO, test x$haveit = xyes)
# Check whether this is a git repository.
AC_MSG_CHECKING([whether building from git])
if test -d .git ; then
@@ -720,14 +746,11 @@ AM_CONDITIONAL(BUILDING_FROM_GIT, test x$from_git = xyes)
AC_CONFIG_FILES([
Makefile
doc/Makefile
doc/nanorc.sample
doc/man/Makefile
doc/man/fr/Makefile
doc/syntax/Makefile
doc/texinfo/Makefile
doc/sample.nanorc
m4/Makefile
po/Makefile.in
src/Makefile
syntax/Makefile
nano.spec
])

8
doc/.gitignore vendored
View File

@@ -1 +1,7 @@
/nanorc.sample
nano.1.html
rnano.1.html
nanorc.5.html
texinfo.tex
nano.info
nano.html
sample.nanorc

View File

@@ -1,11 +1,33 @@
SUBDIRS = man
if HAVE_MAKEINFO
SUBDIRS += texinfo
endif
if USE_COLOR
SUBDIRS += syntax
endif
SUBDIRS =
BUILT_SOURCES =
dist_html_DATA = faq.html
dist_man_MANS = nano.1 rnano.1
html_pages = nano.1.html rnano.1.html
if USE_NANORC
dist_man_MANS += nanorc.5
html_pages += nanorc.5.html
endif
nano.1.html: nano.1
groff -t -mandoc -Thtml < $? > $@
nanorc.5.html: nanorc.5
groff -t -mandoc -Thtml < $? > $@
rnano.1.html: rnano.1
groff -t -mandoc -Thtml < $? > $@
if GROFF_HTML
BUILT_SOURCES += $(html_pages)
dist_html_DATA += $(html_pages)
endif
info_TEXINFOS = nano.texi
BUILT_SOURCES += nano.html
dist_html_DATA += nano.html
AM_MAKEINFOHTMLFLAGS = --no-split
EXTRA_DIST = $(BUILT_SOURCES) $(info_TEXINFOS)

View File

@@ -5,6 +5,7 @@
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
</head>
<body text="#330000" bgcolor="#ffffff" link="#0000ef" vlink="#51188e" alink="#ff0000">
<h1>The GNU nano editor FAQ</h1>
<h2>Table of Contents</h2>
<h2><a href="#1">1. General</a></h2>
@@ -38,15 +39,11 @@
<a href="#4.5">4.5. How do I type the F13-F16 keys shown in the help browser? My keyboard only has F1-F12!</a><br>
<a href="#4.6">4.6. nano crashes when I type &lt;insert keystroke here&gt;!</a><br>
<a href="#4.7">4.7. nano crashes when I resize my window. How can I fix that?</a><br>
<a href="#4.8">4.8. [version 1.3.12 and later] I'm using glibc 2.2.3, and nano crashes when I use color support or do regular expression searches. How can I fix that?</a><br>
<a href="#4.9">4.9. [version 1.1.12 and earlier] Why does nano show ^\ in the shortcut list instead of ^J?</a><br>
<a href="#4.10a">4.10a. [version 1.1.12 and earlier] When I type in a search string, the string I last searched for is already in front of my cursor! What happened?!</a><br>
<a href="#4.10b">4.10b. [version 1.1.99pre1 and later] Hey, the search string behavior has reverted, it's now like Pico, what happened to the consistency?</a><br>
<a href="#4.11">4.11. How do I make nano my default editor (in Pine, mutt, etc.)?</a><br>
<a href="#4.12">4.12. I've compiled nano with color support, but I don't see any color when I run it!</a><br>
<a href="#4.13">4.13. How do I select text for or paste text from the clipboard in an X terminal when I'm running nano in one and nano's mouse support is turned on?</a><br>
<a href="#4.14">4.14. When I paste text into a document, each line gets indented further than the last. Why does nano do this, and how can I avoid it?</a><br>
<a href="#4.15">4.15. On startup I get a message that says "Detected a legacy nano history file". Now older nano versions can't find my search history!</a></p></blockquote>
<a href="#4.8">4.8. When I paste text into a document, each line gets indented further than the last. Why does nano do this, and how can I avoid it?</a><br>
<a href="#4.9">4.9. I've compiled nano with color support, but I don't see any color when I run it!</a><br>
<a href="#4.10">4.10. How do I make nano my default editor (in Pine, mutt, etc.)?</a><br>
<a href="#4.11">4.11. How do I select text for or paste text from the clipboard in an X terminal when I'm running nano in one and nano's mouse support is turned on?</a><br>
<a href="#4.12">4.12. On startup I get a message that says "Detected a legacy nano history file". Now older nano versions can't find my search history!</a></p></blockquote>
<h2><a href="#5">5. Internationalization</a></h2>
<blockquote><p><a href="#5.1">5.1. There's no translation for my language!</a><br>
<a href="#5.2">5.2. I don't like the translation for &lt;x&gt; in my language. How can I fix it?</a><br>
@@ -64,13 +61,14 @@
<a href="#7.5">7.5. Can I have write access to the GIT tree?</a></p></blockquote>
<h2><a href="#8">8. ChangeLog</a></h2>
<hr width="100%">
<h1><a name="1"></a>1. General</h1>
<h2><a name="1.1"></a>1.1 About this FAQ</h2>
<blockquote><p>This FAQ was originally written and maintained by Chris Allegretta &lt;<a href="mailto:chrisa@asty.org">chrisa@asty.org</a>&gt;, who also happens to be the creator of nano. It was then maintained by David Lawrence Ramsey &lt;<a href="mailto:pooka109@gmail.com">pooka109@gmail.com</a>&gt;. Maybe someone else will volunteer to maintain this FAQ someday, who knows...</p></blockquote>
<h2><a name="1.2"></a>1.2. How do I contribute to it?</h2>
<blockquote><p>Your best bet is to send it to the nano email address, <a href="mailto:nano@nano-editor.org">nano@nano-editor.org</a> and if it is useful enough it will be included in future versions.</p></blockquote>
<h2><a name="1.3"></a>1.3. What is GNU nano?</h2>
<blockquote><p>GNU nano is designed to be a free replacement for the Pico text editor, part of the Pine email suite from <a href="http://www.washington.edu/pine/">The University of Washington</a>. It aims to &quot;emulate Pico as closely as possible and perhaps include extra functionality&quot;.</p></blockquote>
<blockquote><p>GNU nano is designed to be a free replacement for the Pico text editor, part of the Pine email suite from <a href="http://www.washington.edu/pine/">The University of Washington</a>. It aims to &quot;emulate Pico as closely as possible and then include extra functionality&quot;.</p></blockquote>
<h2><a name="1.4"></a>1.4. What is the history behind nano?</h2>
<blockquote><p>Funny you should ask!</p>
<p><b>In the beginning...</b></p>
@@ -79,29 +77,32 @@
<p>The <a href="http://www.debian.org/">Debian GNU/Linux</a> distribution, known for its strict standards in distributing truly &quot;free&quot; software (i.e. software with no restrictions on redistribution), would not include a binary package for Pine or Pico. Many people had a serious dilemma: they loved these programs, but the versions available at the time were not truly free software in the <a href="http://www.gnu.org/philosophy/free-sw.html">GNU</a> sense of the word.</p>
<p><b>The event...</b></p>
<p>It was in late 1999 when Chris Allegretta (our hero) was yet again complaining to himself about the less-than-perfect license Pico was distributed under, the 1000 makefiles that came with it and how just a few small improvements could make it the Best Editor in the World (TM). Having been a convert from Slackware to Debian, he missed having a simple binary package that included Pine and Pico, and had grown tired of downloading them himself.</p>
<p>Finally something snapped inside and Chris coded and hacked like a madman for many hours straight one weekend to make a (barely usable) Pico clone, at the time called TIP (Tip Isn't Pico). The program could not be invoked without a filename, could not save files, had no help text display, spell checker, and so forth. But over time it improved, and with the help of a few great coders it matured to the (hopefully) stable state it is today.</p>
<p>Finally something snapped inside and Chris coded and hacked like a madman for many hours straight one weekend to make a (barely usable) Pico clone, at the time called TIP (Tip Isn't Pico). The program could not be invoked without a filename, could not save files, had no help text display, spell checker, and so forth. But over time it improved, and with the help of a few great coders it matured to the (hopefully) stable state it is in today.</p>
<p>In February 2001, nano was declared an official GNU program by Richard Stallman. nano also reached its first production release on March 22, 2001.</p></blockquote>
<h2><a name="1.5"></a>1.5. Why the name change from TIP?</h2>
<blockquote><p>On January 10, 2000, TIP was officially renamed to nano because of a namespace conflict with another program called 'tip'. The original 'tip' program &quot;establishes a full duplex terminal connection to a remote host&quot;, and was included with many older Unix systems (and newer ones like Solaris). The conflict was not noticed at first because there is no 'tip' utility included with most GNU/Linux distributions (where nano was developed).</p></blockquote>
<h2><a name="1.6"></a>1.6. What is the current version of nano?</h2>
<blockquote><p>The current stable version of nano *should* be 2.4.2. Of course, you should always check the <a href="https://nano-editor.org/">nano homepage</a> to see what the latest and greatest version is.</p></blockquote>
<blockquote><p>The current version of nano <i>should</i> be <b>2.7.4</b>. Of course, you should always check the <a href="https://nano-editor.org/">nano homepage</a> to see what the latest and greatest version is.</p></blockquote>
<h2><a name="1.7"></a>1.7. I want to read the man page without having to download the program!</h2>
<blockquote><p>Jeez, demanding, aren't we? Okay, look <a href="https://nano-editor.org/dist/v2.6/nano.1.html">here</a>.</p></blockquote>
<blockquote><p>Jeez, demanding, aren't we? Okay, look <a href="https://nano-editor.org/dist/latest/nano.1.html">here</a>.</p></blockquote>
<hr width="100%">
<h1><a name="2"></a>2. Where to get GNU nano.</h1>
<h2><a name="2.1"></a>2.1. FTP and WWW sites that carry nano.</h2>
<blockquote><p>The nano distribution can be downloaded at the following web sites:</p>
<h2><a name="2.1"></a>2.1. Web sites that carry nano.</h2>
<blockquote><p>The nano source tarballs can be downloaded from the following web sites:</p>
<ul>
<li><a href="https://nano-editor.org/dist/">https://nano-editor.org/dist/</a></li>
<li><a href="https://ftp.gnu.org/gnu/nano/">https://ftp.gnu.org/gnu/nano/</a></li>
</ul>
</blockquote>
<h2><a name="2.2"></a>2.2. RedHat and derivatives (.rpm) packages.</h2>
<h2><a name="2.2"></a>2.2. RPM packages (RedHat, OpenSuse, and derivatives).</h2>
<blockquote>
<ul>
<li><a href="https://nano-editor.org/dist/v2.5/RPMS/">https://nano-editor.org/dist/v2.5/RPMS/</a></li>
<li><a href="https://kojipkgs.fedoraproject.org//packages/nano/">https://kojipkgs.fedoraproject.org//packages/nano/</a></li>
<li><a href="https://software.opensuse.org/package/nano">https://software.opensuse.org/package/nano</a></li>
</ul>
</blockquote>
<h2><a name="2.3"></a>2.3. Debian (.deb) packages.</h2>
<h2><a name="2.3"></a>2.3. Deb packages (Debian and derivatives):</h2>
<blockquote><p>Debian users can check out the current nano packages for:</p>
<ul>
<li><a href="http://packages.debian.org/stable/editors/nano">stable</a></li>
@@ -113,6 +114,7 @@
<h2><a name="2.4"></a>2.4. By GIT (for the brave).</h2>
<blockquote><p>For the 'bleeding edge' current version of nano, you can use GIT to download the current source code. <b>Note:</b> believe it or not, by downloading code that has not yet stabilized into an official release, there could quite possibly be bugs, in fact the code may not even compile! Anyway, see <a href="http://git.savannah.gnu.org/cgit/nano.git/tree/README.GIT">the nano GIT document</a> for info on anonymous GIT access to the nano source.</p></blockquote>
<hr width="100%">
<h1><a name="3"></a>3. Installation and Configuration</h1>
<h2><a name="3.1"></a>3.1. How do I install the RPM or DEB package?</h2>
<blockquote><p>It's simple really! As root, type <b>rpm -Uvh nano-x.y.z-1.i386.rpm</b> if you have a RedHat-ish system or <b>dpkg -i nano_x.y.z-1.deb</b> if you have a Debian-ish system, where <b>x.y.z</b> is the release of nano. There are other programs to install packages, and if you wish to use those, knock yourself out.</p></blockquote>
@@ -147,23 +149,25 @@
<b>--disable-operatingdir</b> Disable the setting of an operating directory
<b>--disable-speller</b> Disable spell checker functions
<b>--disable-tabcomp</b> Disable tab completion functions
<b>--disable-wordcomp</b> Disable the word completion function
<b>--disable-wrapping</b> Disable all hard-wrapping of text</pre>
<p>There's also the <b>--enable-tiny</b> option which disables everything above, as well as some larger chunks of the program (like the marker code that you use with Control-^ to select text). Also, if you know you aren't going to be using other languages you can use <b>--disable-nls</b> to disable internationalization and save a few K to a few dozen K depending on if you have locale support on your system. And finally there's always good old <b>strip</b> to strip all debugging code and code that exists in libraries on your system.</p>
<p>There's also the <b>--enable-tiny</b> option which disables everything above, as well as some larger chunks of the program (like the marker code that you use with Control-^ to select text). Also, if you know you aren't going to be using other languages, you can use <b>--disable-nls</b> to disable internationalization and save a few K to a few dozen K depending on whether you have locale support on your system. And finally, there's always good old <b>strip</b> to strip all debugging code and code that exists in libraries on your system.</p>
<p>With <b>--disable-wrapping-as-root</b> you can disable any hard-wrapping by default when the user is root, useful to prevent accidentally changing long lines in system configuration files.</p>
</blockquote>
<h2><a name="3.7"></a>3.7. Tell me more about this multibuffer stuff!</h2>
<blockquote><p>To use multiple file buffers, you must be using nano 1.1.0 or newer, and you must not have configured it with <b>--disable-multibuffer</b> nor with <b>--enable-tiny</b> (use <b>nano -V</b> to check the compilation options). Then when you want to insert a file into its own buffer instead of into the current file, just hit <b>Meta-F</b>, then insert the file as normal with <b>^R</b>. If you always want files to be loaded into their own buffers, use the <b>--multibuffer</b> or <b>-F</b> flag when you invoke nano.</p>
<p>You can move between the buffers you have open with the <b>Meta-&lt;</b> and <b>Meta-&gt;</b> keys, or more easily with <b>Meta-,</b> and <b>Meta-.</b> (clear as mud, right? =-). When you have more than one file buffer open, the ^X shortcut will say &quot;Close&quot;, instead of the normal &quot;Exit&quot; when only one buffer is open.</p></blockquote>
<blockquote><p>To use multiple file buffers, you must not have configured nano with <b>--disable-multibuffer</b> nor with <b>--enable-tiny</b> (use <b>nano -V</b> to check the compilation options). Then when you want to insert a file into its own buffer instead of into the current file, just hit <b>Meta-F</b>, then insert the file as normal with <b>^R</b>. If you always want files to be loaded into their own buffers, use the <b>--multibuffer</b> or <b>-F</b> flag when you invoke nano.</p>
<p>You can move between the buffers you have open with the <b>Meta-&lt;</b> and <b>Meta-&gt;</b> keys, or more easily without holding Shift: <b>Meta-,</b> and <b>Meta-.</b> (clear as mud, right? =-). When you have more than one file buffer open, the ^X shortcut will say &quot;Close&quot;, instead of the normal &quot;Exit&quot; when only one buffer is open.</p></blockquote>
<h2><a name="3.8"></a>3.8. Tell me more about this verbatim input stuff!</h2>
<blockquote><p>To use verbatim input, you must be using nano 1.3.1 or newer. When you want to insert a literal character into the file you're editing, such as a control character that nano usually treats as a command, first press <b>Meta-V</b> (if you're not at a prompt, you'll get the message &quot;Verbatim Input&quot;), then press the key(s) that generate the character you want.</p>
<p>Alternatively, if you've enabled Unicode support (see section <a href="#5.3">5.3</a>), you can press <b>Meta-V</b> and then type a six-digit hexadecimal code (from 000000 to 10FFFF, case-insensitive), and the character with the corresponding value will be inserted instead. The prompt will change to &quot;Unicode Input&quot; when you do this.</p></blockquote>
<h2><a name="3.9a"></a>3.9a. How do I make a .nanorc file that nano will read when I start it?</h2>
<blockquote><p>It's not hard at all! But, your version of nano must <b>not</b> have been compiled with <b>--disable-nanorc</b>, and must be version 1.1.12 or newer (use nano -V to check your version and compiled features). Then simply copy the <b>nanorc.sample</b> that came with the nano source or your nano package (most likely in /usr/doc/nano) to .nanorc in your home directory. If you didn't get one, the syntax is simple. Flags are turned on and off by using the words <b>set</b> and <b>unset</b> plus the long option name for the feature. For example, &quot;set nowrap&quot; or &quot;set smarthome&quot;.</p></blockquote>
<blockquote><p>When you want to insert a literal character into the file you're editing, such as a control character that nano usually treats as a command, first press <b>Meta-V</b> (if you're not at a prompt, you'll get the message &quot;Verbatim Input&quot; on the statusbar), then press the key(s) that generate the character you want.</p>
<p>Alternatively, if you've enabled Unicode support (see section <a href="#5.3">5.3</a>), you can press <b>Meta-V</b> and then type a six-digit hexadecimal code (from 000000 to 10FFFF, case-insensitive), and the character with the corresponding value will be inserted. The statubar will change to &quot;Unicode Input: ......&quot; when you do this.</p></blockquote>
<h2><a name="3.9a"></a>3.9a. How do I make a .nanorc file that will be read when I start nano?</h2>
<blockquote><p>It's not hard at all! But, your nano must <b>not</b> have been compiled with <b>--disable-nanorc</b>. Then simply copy the <b>sample.nanorc</b> that came with the nano source or your nano package (most likely in /usr/doc/nano) to .nanorc in your home directory. If you didn't get one, the syntax of the file is simple. Flags are turned on and off by using the words <b>set</b> and <b>unset</b> plus the long option name for the feature. For example, &quot;set nowrap&quot; or &quot;set smarthome&quot;.</p></blockquote>
<h2><a name="3.9b"></a>3.9b. How about in Win32?</h2>
<blockquote><p>If you're using the official nano .zip file and have extracted all the files, you should take the file nano.rc and place it somewhere on your Win32 system (for example, if you have write permission to do so, at the top of C:\). Then you must create an Environment variable called HOME which points to the directory where you put nano.rc. In Windows XP, you can get to Environment variables by right-clicking "My Computer" either on the desktop or in the Start Menu, and selecting Properties. This should bring up the System Properties panel. Then click the Advanced Tab, and there should be a button called Environment Variables. Click that to bring up the Environment Variables section. Now, under User Variables you should be able to click the New button, and make a new Variables Name called HOME, with the Variable Value of whatever path you copied nano.rc into (just the directory name; don't add nano.rc onto the end).</p>
<p>We're still working on documentation for enabling syntax highlighting on Win32; please bear with us.</p>
<p>Note that the nano.rc file must remain Unix-formatted in order for nano to understand it. In other words, you should probably use only nano to edit its config file. Other programs like Wordpad and Notepad will convert the file to DOS format when saving, and the latter does not even properly read Unix-formatted files to begin with.</p></blockquote>
<hr width="100%">
<h1><a name="4"></a>4. Running</h1>
<h2><a name="4.1"></a>4.1. How do I open a file with a name beginning with '+' from the command line?</h2>
<blockquote><p>If a command-line option that begins with '+' is followed by another option, the former is always treated as a starting line and column number, and the latter is always treated as a filename. If a command-line option that begins with '+' isn't followed by another option, it's always treated as a filename. Examples:</p>
@@ -185,16 +189,12 @@
<h2><a name="4.6"></a>4.6. nano crashes when I type &lt;insert keystroke here&gt;!</h2>
<blockquote><p>If you aren't trying some bizarre keystroke combination with some bizarre $TERM entry, chances are you have found a bug. You are welcome to submit it to the <a href="mailto:nano-devel@gnu.org">nano-devel</a> list or in the <a href="https://savannah.gnu.org/bugs/?group=nano">bug tracker</a> on Savannah.</p></blockquote>
<h2><a name="4.7"></a>4.7. nano crashes when I resize my window. How can I fix that?</h2>
<blockquote><p>Older versions of nano had this problem, please upgrade to a newer version (at least 0.9.9, but 2.4.2 is recommended).</p></blockquote>
<h2><a name="4.8"></a>4.8. [version 1.3.12 and later] I'm using glibc 2.2.3, and nano crashes when I use color support or do regular expression searches. How can I fix that?</h2>
<blockquote><p>It's a bug in glibc 2.2.3. You should upgrade to at least glibc 2.2.4.</p></blockquote>
<h2><a name="4.9"></a>4.9. [version 1.1.12 and earlier] Why does nano show ^\ in the shortcut list instead of ^J?</h2>
<blockquote><p>The help (^G) and justify (^J) functions were among the last to be written. To show the improvements that nano had over Pico (go to line number, and replace), ^_ and ^\ were put on the shortcut list. Later, ^G came back in place of ^_ as it proved to be very valuable for new Unix users.</p></blockquote>
<h2><a name="4.10a"></a>4.10a. [version 1.1.12 and earlier] When I type in a search string, the string I last searched for is already in front of my cursor! What happened?!</h2>
<blockquote><p>Since nano version 0.9.20, the default was to have a completely consistent user interface across all user input functions. This means that regardless of whether you're being asked for a filename to insert or write, or a string to search for, the previous value is already inserted before the cursor.</p></blockquote>
<h2><a name="4.10b"></a>4.10b. [version 1.1.99pre1 and later] Hey, the search string behavior has reverted, it's now like Pico, what happened to the consistency?</h2>
<blockquote><p>It was decided that consistency was nice, but people are used to Pico's inconsistent behavior. Also, in version 1.1.99pre1, search and replace history was introduced. If you wish to edit your previous search/replace entry (or any previous entry), you can do so by hitting the up arrow to cycle through your history. This method allows the best of both worlds: You don't need to erase the previous string if you want to enter a new one, but you can with one keystroke recall previous entries for editing. Therefore there is now no "Pico mode", nano is and has always been a Pico <b>clone</b>, and clones by default should be compatible.</p></blockquote>
<h2><a name="4.11"></a>4.11. How do I make nano my default editor (in Pine, mutt, etc.)?</h2>
<blockquote><p>Older versions of nano had this problem. Please upgrade to version 2.7.0 or newer.</p></blockquote>
<h2><a name="4.8"></a>4.8. When I paste text into a document, each line gets indented further than the last. Why does nano do this, and how can I avoid it?</h2>
<blockquote><p>You have the autoindent feature turned on. Hit Meta-I to turn it off, paste your text, and then hit Meta-I again to turn it back on.</p></blockquote>
<h2><a name="4.9"></a>4.9. I've compiled nano with color support, but I don't see any color when I run it!</h2>
<blockquote><p>If you want nano to actually use color, you have to specify the color configurations you want it to use in your .nanorc. Several example configurations are in the <b>doc/syntax</b> subdirectory of the nano source, which are normally installed to <b>/usr/local/share/nano</b>. To enable all of them, uncomment the line <b># include "/usr/local/share/nano/*.nanorc"</b> in your nanorc. See also section <a href="#3.9a">3.9a</a>.</p></blockquote>
<h2><a name="4.10"></a>4.10. How do I make nano my default editor (in Pine, mutt, etc.)?</h2>
<blockquote><p>You need to make nano your $EDITOR. If you want this to be saved, you should put a line like this in your <b>.bashrc</b> if you use bash (or <b>.zshrc</b> if you believe in zsh):</p>
<p><b>export EDITOR=/usr/local/bin/nano</b></p>
<p>or, if you use tcsh, put this in your <b>.cshrc</b> file:</p>
@@ -207,18 +207,14 @@
<p>If you're a mutt user, you should see an effect immediately the next time you log in. No further configuration is needed. However, if you want to let people know you use nano to compose your email messages, you can put a line like this in your <b>.muttrc</b>:</p>
<p><b>my_hdr X-Composer: nano x.y.z</b></p>
<p>Again, replace x.y.z with the version of nano you use.</p></blockquote>
<h2><a name="4.12"></a>4.12. I've compiled nano with color support, but I don't see any color when I run it!</h2>
<blockquote><p>If you want nano to actually use color, you have to specify the color configurations you want it to use in your .nanorc. Several example configurations are in the <b>doc/syntax</b> subdirectory of the nano source, which are normally installed to <b>/usr/local/share/nano</b>. To enable all of them, uncomment the line <b># include "/usr/local/share/nano/*.nanorc"</b> in your nanorc. See also section <a href="#3.9a">3.9a</a>.</p></blockquote>
<h2><a name="4.13"></a>4.13. How do I select text for or paste text from the clipboard in an X terminal when I'm running nano in one and nano's mouse support is turned on?</h2>
<h2><a name="4.11"></a>4.11. How do I select text for or paste text from the clipboard in an X terminal when I'm running nano in one and nano's mouse support is turned on?</h2>
<blockquote><p>Try holding down the Shift key and selecting or pasting the text as you normally would.</p></blockquote>
<h2><a name="4.14"></a>4.14. When I paste text into a document, each line gets indented further than the last. Why does nano do this, and how can I avoid it?</h2>
<blockquote><p>You have the autoindent feature turned on. Hit Meta-I to turn it off, paste your text, and then hit Meta-I again to turn it back on.</p></blockquote>
<h2><a name="4.15"></a>4.15. On startup I get a message that says "Detected a legacy nano history file". Now older nano versions can't find my search history!</h2>
<blockquote><p>In nano 2.3.0, cursor-position history was introduced, and both history files now reside under a .nano directory in your home. nano was trying to move this file into the new location so it could continue to use it. This means that if you try and use an earlier version of nano, it will be unable to see your current search history. To fix this, run the following commands:<br>
<p><b>mv ~/.nano/search_history ~/.nano_history</b><br>
<b>ln -sf ~/.nano_history ~/.nano/search_history</b></p>
</p></blockquote>
<h2><a name="4.12"></a>4.12. On startup I get a message that says "Detected a legacy nano history file". Now older nano versions can't find my search history!</h2>
<blockquote><p>In nano 2.3.0, cursor-position history was introduced, and both history files now reside in a .nano subdirectory in your home directory. A newer nano will move an existing search-history file to this new location so it can continue to be used. This means that if you then try and use an earlier version of nano, it will be unable to see your current search history. To fix this, run the following command:<br>
<p><b>ln -sf ~/.nano/search_history ~/.nano_history</b></p>
</p><p>The "migration service" (moving the search-history file to its new location) will be deleted from nano in early 2018.</p></blockquote>
<hr width="100%">
<h1><a name="5"></a>5. Internationalization</h1>
<h2><a name="5.1"></a>5.1. There's no translation for my language!</h2>
<blockquote><p>In June 2001, GNU nano entered the <a href="http://translationproject.org/html/welcome.html">Translation Project</a> and since then, translations should be managed from there.</p>
@@ -227,8 +223,9 @@
<h2><a name="5.2"></a>5.2. I don't like the translation for &lt;x&gt; in my language. How can I fix it?</h2>
<blockquote><p>The best way would probably be to send an e-mail to the team's mailing listed mentione in the <code>Language-Team:</code> field in the <b>&lt;your_language&gt;.po</b> file with your suggested corrections, and then they can make the changes reach the nano-devel list.</p></blockquote>
<h2><a name="5.3"></a>5.3. What is the status of Unicode support?</h2>
<blockquote><p>In version 1.3.12 or later, Unicode should be usable. With your terminal, locale (LC_ALL and similar environment variables), and encoding configured to properly support UTF-8, you should be able to enter and save Unicode text.</p></blockquote>
<blockquote><p>Since versions 1.3.12, Unicode should be usable. With your terminal, locale (LC_ALL and similar environment variables), and encoding configured to properly support UTF-8, you should be able to enter and save Unicode text.</p></blockquote>
<hr width="100%">
<h1><a name="6"></a>6. Advocacy and Licensing</h1>
<h2><a name="6.1"></a>6.1. Why should I use nano instead of Pico?</h2>
<blockquote><p>There are many reasons to use nano instead of Pico. A more complete list can be found at the <a href="https://nano-editor.org/">nano homepage</a>.</p></blockquote>
@@ -240,6 +237,7 @@
<blockquote><p>If you are looking to use a Free Software program similar to Pine, and Emacs is not your thing, you should definitely take a look at <a href="http://www.mutt.org/">mutt</a>. It is a full-screen, console based mail program that actually has a lot more flexibility than Pine, but has a keymap included in the distribution that allows you to use the same keystrokes as Pine would to send and receive mail. It's also under the GNU General Public License, version 2.0.<P>
Of course, due to the license change you can now use the <A HREF="http://www.washington.edu/alpine/">Alpine distribution</A> of PINE as it is now considered Free Software, but you would be sacrificing many of nano's features to do so.</p></blockquote>
<hr width="100%">
<h1><a name="7"></a>7. Miscellaneous</h1>
<h2><a name="7.1"></a>7.1. nano-related mailing lists.</h2>
<blockquote><p>There are three mailing lists for nano hosted at <a href="http://savannah.gnu.org/">Savannah</a>: info-nano, help-nano and nano-devel. info-nano is a very low traffic list where new versions of nano are announced (surprise!). help-nano is for getting help with the editor without needing to hear all of the development issues surrounding it. nano-devel is a normally low, sometimes high traffic list for discussing the present and future development of nano. Here are links to where you can sign up for a given list:</p>
@@ -247,7 +245,7 @@ Of course, due to the license change you can now use the <A HREF="http://www.was
help-nano - <a href="http://mail.gnu.org/mailman/listinfo/help-nano/">http://mail.gnu.org/mailman/listinfo/help-nano/</a><br>
nano-devel - <a href="http://mail.gnu.org/mailman/listinfo/nano-devel/">http://mail.gnu.org/mailman/listinfo/nano-devel/</a></p></blockquote>
<h2><a name="7.2"></a>7.2. I want to send the development team a big load of cash (or just a thank you).</h2>
<blockquote><p>That's fine. Send it <a href="mailto:nano-devel@gnu.org">our way</a>! Better yet, fix a <a href="https://savannah.gnu.org/bugs/?group=nano">bug</a> in the program or implement a <a href="https://nano-editor.org/dist/v2.6/TODO">cool feature</a> and send us that instead (though cash is fine too).</p></blockquote>
<blockquote><p>That's fine. Send it <a href="mailto:nano-devel@gnu.org">our way</a>! Better yet, fix a <a href="https://savannah.gnu.org/bugs/?group=nano">bug</a> in the program or implement a <a href="https://nano-editor.org/dist/latest/TODO">cool feature</a> and send us that instead (though cash is fine too).</p></blockquote>
<h2><a name="7.3"></a>7.3. How do I submit a bug report or patch?</h2>
<blockquote>
<p>The best place to submit bugs is to the <a href="https://savannah.gnu.org/bugs/?group=nano">Savannah bug tracker</a> as you can check whether the bug you are submitting has already been submitted.
@@ -255,76 +253,79 @@ Of course, due to the license change you can now use the <A HREF="http://www.was
<h2><a name="7.4"></a>7.4. How do I join the development team?</h2>
<blockquote><p>The easiest way is to consistently send in good patches that add some needed functionality, fix a bug or two, and/or make the program more optimized/efficient. Then ask nicely and you will probably be added to the Savannah development list and be given write access after a while. There is a lot of responsibility that goes along with being a team member, so don't think it's just something to add to your resume.</p></blockquote>
<h2><a name="7.5"></a>7.5. Can I have write access to the git tree?</h2>
<blockquote><p>Re-read Section <a href="#7.4">7.4</a> and you should know the answer.</p></blockquote>
<h2><a name="8"></a>8. ChangeLog</h2>
<blockquote><p>Re-read section <a href="#7.4">7.4</a> and you should know the answer.</p></blockquote>
<hr width="100%">
<h1><a name="8"></a>8. ChangeLog</h1>
<blockquote><p>
2016/04/17 - Update docs to refer to GIT instead of subversion. (Mike)<br>
2015/07/18 - More small fixes and updates. (Benno)<br>
2014/04/24 - A bunch of small fixes and updates. (Benno)<br>
2009/11/30 - Update various bits for nano 2.2.x. (DLR)<br>
2009/11/18 - Typo fix. (j.mader@gmail.com)<br>
2008/03/16 - Update docs to refer to subversion instead of CVS, add more words about Alpine, and refer to Savannah for bugs and patches. (chrisa)<br>
2007/12/21 - Update maintainer information. (DLR)<br>
2007/12/09 - Add minor punctuation and wording fixes, and update various sections to account for Alpine. (DLR)<br>
2007/08/26 - Update links to the Free Translation Project. (DLR)<br>
2007/07/29 - Update RPM links for nano 2.0.x. (DLR)<br>
2007/04/18 - Add a new section 4.14 to explain how autoindent affects pasted text. (John M. Gabriele, minor tweaks by DLR)<br>
2007/04/04 - Update email address. (DLR)<br>
2007/01/01 - Update section 4.1 to describe how to open files with names beginning with '+' at specified columns as well as lines. (DLR)<br>
2006/11/25 - Add miscellaneous wording and capitalization fixes. (DLR)<br>
2006/10/28 - Update various links for the 2.0 branch of nano. (DLR)<br>
2006/10/06 - Update the question in section 4.13 to match the version of it in the answer section. (DLR)<br>
2006/07/25 - Update section 5.3 again to not state &quot;the latest development version&quot; before 1.3.12, as it's no longer accurate. Also add some minor spacing fixes. (DLR)<br>
2006/06/12 - Update section 5.3, due to the display fix for two-column Unicode characters. (DLR)<br>
2006/06/05 - Add a new section 4.8, and move all section 4 entries after it down one number, to explain how to deal with glibc 2.2.3's crashes involving extended regular expressions. (DLR)<br>
2006/06/04 - Add minor punctuation, wording, and typo fixes. (DLR)<br>
2006/05/27 - Update section 3.8 to mention the new "Unicode Input" prompt, and how Unicode input only works when Unicode support is enabled. (DLR)<br>
2006/05/12 - Remove section 4.4, and move all section 4 entries after it up one number, since it no longer applies. Meta-] and Meta-[ are no longer used to indent and unindent marked text, since they require that the bracket matching key change to Ctrl-], which is used as the telnet escape key (found by Chris). Also, make the link to the nano CVS page a bit more readable. (DLR)<br>
2006/05/08 - Add a new section 4.5, and move all section 4 entries after it down one number, to explain a problem that can occur when holding down keys to generate Meta sequences. Also add a few more capitalization and wording fixes. (Benno Schulenberg, minor tweaks by DLR)<br>
2006/05/01 - Add a new section 4.4, and move all section 4 entries after it down one number, to explain how to deal with problems typing Meta-[. Also add a few capitalization and wording fixes. (DLR)<br>
2006/04/14 - Clarify section 1.4: help menu -> help text display. (DLR, suggested by Benno Schulenberg)<br>
2006/03/16 - Update the Free Translation Project's address, change the character set to UTF-8, and remove broken links to contributed RedHat nano packages. (DLR)<br>
2005/11/21 - Clarify section 5.3 to better explain how to enable Unicode support, and remove the mention of quirks, since they turned out to not be a nano problem. (Mike Frysinger and DLR)<br>
2005/11/19 - Add a new section 5.3 to explain the status of nano's Unicode support. (Mike Frysinger, minor tweaks by DLR)<br>
2005/08/27 - Update email address. (DLR)<br>
2005/08/10 - Add a new section 4.3, and move all section 4 entries after it down one number, to explain how to deal with numeric keypad problems. (DLR)<br>
2005/08/08 - Update section 3.8 to mention that verbatim input mode now takes a six-digit hexadecimal number. (DLR)<br>
2005/07/04 - Update section 4.10 to mention that pasting from the X clipboard via the middle mouse button also works when the Shift key is used. (DLR)<br>
2005/06/15 - Update description of --enable-extra, and add missing line breaks. (DLR)<br>
2005/06/13 - Minor capitalization and wording fixes. (DLR)<br>
2005/06/08 - Updated section 1.1 to mention the current maintainer. (DLR)<br>
2005/03/09 - Added question about opening files with names beginning with '+'s, and added a few more miscellaneous cosmetic fixes. (DLR)<br>
2005/01/03 - Removed now-inaccurate note about verbatim input's not working at prompts, and update its description to mention that it handles hexadecimal values now. (DLR)<br>
2004/11/21 - Listed sh as an example of a Bourne shell. (DLR)<br>
2004/11/05 - Fixed inaccuracy: Pico compatibility mode was made the default in nano 1.1.99pre1, not 1.2.2. Also added question about how to type F13-F16 on terminals lacking keys past F12 (suggested by Chris), question about how to select text for the clipboard in X terminals with nano's mouse support turned on (answer found by Joseph Birthisel), and misc. fixes and link updates. (DLR)<br>
2004/04/07 - Removed NumLock glitch question, as it's no longer needed. (DLR)<br>
2004/01/30 - Fixed inaccuracy: multibuffer mode was first in nano 1.1.0, not 1.1.12. (DLR)<br>
2003/12/31 - Added question about the new verbatim input function, and a few minor fixes. Removed reference to &quot;set pico&quot; (DLR).<br>
2003/07/02 - Added question about nano's not showing color when it's compiled with color support (DLR; suggested by Jordi).<br>
2003/02/23 - Updated RPM links for nano 1.2.x (DLR).<br>
2003/01/16 - Split section 4.5 into 4.5a and 4.5b for search string behavior. Added --enable-all docs.<br>
2002/12/28 - More misc. fixes (David Benbennick, DLR).<br>
2002/10/25 - Misc. fixes and link updates (DLR).<br>
2002/09/10 - Another typo fix (DLR).<br>
2002/05/15 - Typo fix (DLR).<br>
2001/12/26 - Misc. fixes (Aaron S. Hawley, DLR).<br>
2001/10/02 - Update for Free Translation Project.<br>
2001/10/02 - Assorted fixes, Debian additions.<br>
2001/06/30 - Silly typo fix.<br>
2001/05/05 - Spelling fixes by David Lawrence Ramsey.<br>
2001/05/02 - Misc fixes.<br>
2001/03/26 - Typo fix in an URL.<br>
2001/02/17 - Advocacy updates.<br>
2001/02/15 - Added GNU notes for 0.9.99pre3.<br>
2001/02/06 - Typo fixes.<br>
2001/01/14 - Added note about NumLock glitch.<br>
2001/01/10 - Linux -&gt; GNU/Linux.<br>
2001/01/09 - Added &quot;making exe smaller&quot; section.<br>
2000/12/19 - Typo and assorted error fixes.<br>
2000/11/28 - Added blurb about make install-strip.<br>
2000/11/19 - Changed Debian frozen to stable.<br>
2000/11/18 - Previous string display (4.5).<br>
2000/09/27 - Moved addresses to nano-editor.org.<br>
2000/06/31 - Initial framework.</p></blockquote>
2017.01.09 - Delete some obsolete items and update a few others. (Benno)<br>
2016.04.17 - Update docs to refer to GIT instead of subversion. (Mike)<br>
2015.07.18 - More small fixes and updates. (Benno)<br>
2014.04.24 - A bunch of small fixes and updates. (Benno)<br>
2009.11.30 - Update various bits for nano 2.2.x. (DLR)<br>
2009.11.18 - Typo fix. (j.mader@gmail.com)<br>
2008.03.16 - Update docs to refer to subversion instead of CVS, add more words about Alpine, and refer to Savannah for bugs and patches. (Chris)<br>
2007.12.21 - Update maintainer information. (DLR)<br>
2007.12.09 - Add minor punctuation and wording fixes, and update various sections to account for Alpine. (DLR)<br>
2007.08.26 - Update links to the Free Translation Project. (DLR)<br>
2007.07.29 - Update RPM links for nano 2.0.x. (DLR)<br>
2007.04.18 - Add a new section 4.14 to explain how autoindent affects pasted text. (John M. Gabriele, minor tweaks by DLR)<br>
2007.04.04 - Update email address. (DLR)<br>
2007.01.01 - Update section 4.1 to describe how to open files with names beginning with '+' at specified columns as well as lines. (DLR)<br>
2006.11.25 - Add miscellaneous wording and capitalization fixes. (DLR)<br>
2006.10.28 - Update various links for the 2.0 branch of nano. (DLR)<br>
2006.10.06 - Update the question in section 4.13 to match the version of it in the answer section. (DLR)<br>
2006.07.25 - Update section 5.3 again to not state &quot;the latest development version&quot; before 1.3.12, as it's no longer accurate. Also add some minor spacing fixes. (DLR)<br>
2006.06.12 - Update section 5.3, due to the display fix for two-column Unicode characters. (DLR)<br>
2006.06.05 - Add a new section 4.8, and move all section 4 entries after it down one number, to explain how to deal with glibc 2.2.3's crashes involving extended regular expressions. (DLR)<br>
2006.06.04 - Add minor punctuation, wording, and typo fixes. (DLR)<br>
2006.05.27 - Update section 3.8 to mention the new "Unicode Input" prompt, and how Unicode input only works when Unicode support is enabled. (DLR)<br>
2006.05.12 - Remove section 4.4, and move all section 4 entries after it up one number, since it no longer applies. Meta-] and Meta-[ are no longer used to indent and unindent marked text, since they require that the bracket matching key change to Ctrl-], which is used as the telnet escape key (found by Chris). Also, make the link to the nano CVS page a bit more readable. (DLR)<br>
2006.05.08 - Add a new section 4.5, and move all section 4 entries after it down one number, to explain a problem that can occur when holding down keys to generate Meta sequences. Also add a few more capitalization and wording fixes. (Benno Schulenberg, minor tweaks by DLR)<br>
2006.05.01 - Add a new section 4.4, and move all section 4 entries after it down one number, to explain how to deal with problems typing Meta-[. Also add a few capitalization and wording fixes. (DLR)<br>
2006.04.14 - Clarify section 1.4: help menu -> help text display. (DLR, suggested by Benno Schulenberg)<br>
2006.03.16 - Update the Free Translation Project's address, change the character set to UTF-8, and remove broken links to contributed RedHat nano packages. (DLR)<br>
2005.11.21 - Clarify section 5.3 to better explain how to enable Unicode support, and remove the mention of quirks, since they turned out to not be a nano problem. (Mike Frysinger and DLR)<br>
2005.11.19 - Add a new section 5.3 to explain the status of nano's Unicode support. (Mike Frysinger, minor tweaks by DLR)<br>
2005.08.27 - Update email address. (DLR)<br>
2005.08.10 - Add a new section 4.3, and move all section 4 entries after it down one number, to explain how to deal with numeric keypad problems. (DLR)<br>
2005.08.08 - Update section 3.8 to mention that verbatim input mode now takes a six-digit hexadecimal number. (DLR)<br>
2005.07.04 - Update section 4.10 to mention that pasting from the X clipboard via the middle mouse button also works when the Shift key is used. (DLR)<br>
2005.06.15 - Update description of --enable-extra, and add missing line breaks. (DLR)<br>
2005.06.13 - Minor capitalization and wording fixes. (DLR)<br>
2005.06.08 - Updated section 1.1 to mention the current maintainer. (DLR)<br>
2005.03.09 - Added question about opening files with names beginning with '+'s, and added a few more miscellaneous cosmetic fixes. (DLR)<br>
2005.01.03 - Removed now-inaccurate note about verbatim input's not working at prompts, and update its description to mention that it handles hexadecimal values now. (DLR)<br>
2004.11.21 - Listed sh as an example of a Bourne shell. (DLR)<br>
2004.11.05 - Fixed inaccuracy: Pico compatibility mode was made the default in nano 1.1.99pre1, not 1.2.2. Also added question about how to type F13-F16 on terminals lacking keys past F12 (suggested by Chris), question about how to select text for the clipboard in X terminals with nano's mouse support turned on (answer found by Joseph Birthisel), and misc. fixes and link updates. (DLR)<br>
2004.04.07 - Removed NumLock glitch question, as it's no longer needed. (DLR)<br>
2004.01.30 - Fixed inaccuracy: multibuffer mode was first in nano 1.1.0, not 1.1.12. (DLR)<br>
2003.12.31 - Added question about the new verbatim input function, and a few minor fixes. Removed reference to &quot;set pico&quot; (DLR).<br>
2003.07.02 - Added question about nano's not showing color when it's compiled with color support (DLR; suggested by Jordi).<br>
2003.02.23 - Updated RPM links for nano 1.2.x (DLR).<br>
2003.01.16 - Split section 4.5 into 4.5a and 4.5b for search string behavior. Added --enable-all docs.<br>
2002.12.28 - More misc. fixes (David Benbennick, DLR).<br>
2002.10.25 - Misc. fixes and link updates (DLR).<br>
2002.09.10 - Another typo fix (DLR).<br>
2002.05.15 - Typo fix (DLR).<br>
2001.12.26 - Misc. fixes (Aaron S. Hawley, DLR).<br>
2001.10.02 - Update for Free Translation Project.<br>
2001.10.02 - Assorted fixes, Debian additions.<br>
2001.06.30 - Silly typo fix.<br>
2001.05.05 - Spelling fixes by David Lawrence Ramsey.<br>
2001.05.02 - Misc fixes.<br>
2001.03.26 - Typo fix in an URL.<br>
2001.02.17 - Advocacy updates.<br>
2001.02.15 - Added GNU notes for 0.9.99pre3.<br>
2001.02.06 - Typo fixes.<br>
2001.01.14 - Added note about NumLock glitch.<br>
2001.01.10 - Linux -&gt; GNU/Linux.<br>
2001.01.09 - Added &quot;making exe smaller&quot; section.<br>
2000.12.19 - Typo and assorted error fixes.<br>
2000.11.28 - Added blurb about make install-strip.<br>
2000.11.19 - Changed Debian frozen to stable.<br>
2000.11.18 - Previous string display (4.5).<br>
2000.09.27 - Moved addresses to nano-editor.org.<br>
2000.06.31 - Initial framework.</p></blockquote>
</body>
</html>

3
doc/man/.gitignore vendored
View File

@@ -1,3 +0,0 @@
nano.1.html
nanorc.5.html
rnano.1.html

View File

@@ -1,28 +0,0 @@
SUBDIRS =
BUILT_SOURCES =
if USE_NLS
SUBDIRS += fr
endif
dist_man_MANS = nano.1 rnano.1
html_pages = nano.1.html rnano.1.html
if USE_NANORC
dist_man_MANS += nanorc.5
html_pages += nanorc.5.html
endif
nano.1.html: nano.1
groff -t -mandoc -Thtml < $? > $@
nanorc.5.html: nanorc.5
groff -t -mandoc -Thtml < $? > $@
rnano.1.html: rnano.1
groff -t -mandoc -Thtml < $? > $@
if GROFF_HTML
BUILT_SOURCES += $(html_pages)
dist_html_DATA = $(html_pages)
endif
EXTRA_DIST = $(BUILT_SOURCES)

View File

@@ -1,26 +0,0 @@
mandir = @mandir@/fr
htmldir = @htmldir@/fr
BUILT_SOURCES =
dist_man_MANS = nano.1 rnano.1
html_pages = nano.1.html rnano.1.html
if USE_NANORC
dist_man_MANS += nanorc.5
html_pages += nanorc.5.html
endif
nano.1.html: nano.1
groff -t -mandoc -Thtml < $? > $@
nanorc.5.html: nanorc.5
groff -t -mandoc -Thtml < $? > $@
rnano.1.html: rnano.1
groff -t -mandoc -Thtml < $? > $@
if GROFF_HTML
BUILT_SOURCES += $(html_pages)
dist_html_DATA = $(html_pages)
endif
EXTRA_DIST = $(BUILT_SOURCES)

View File

@@ -1,324 +0,0 @@
.\" Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
.\" Free Software Foundation, Inc.
.\"
.\" Le travail d'adaptation française de cette page de manuel a été
.\" réalisé par Jean-Philippe Guérard, en 2003, 2004, 2005, 2006 et 2007.
.\" Ce travail d'adaptation est dans le domaine public. Attention, la
.\" page traduite reste soumise au droit d'auteur de ses auteurs
.\" originaux.
.\"
.\" The French translation of this document is a public domain work of
.\" Jean-Philippe Guérard. This translation work was made in 2003, 2004,
.\" 2005, 2006 and 2007. The translated man page in itself is still
.\" subject to the copyright of its original authors.
.\"
.\" This document is dual-licensed. You may distribute and/or modify it
.\" under the terms of either of the following licenses:
.\"
.\" * The GNU General Public License, as published by the Free Software
.\" Foundation, version 3 or (at your option) any later version. You
.\" should have received a copy of the GNU General Public License
.\" along with this program. If not, see
.\" <http://www.gnu.org/licenses/>.
.\"
.\" * The GNU Free Documentation License, as published by the Free
.\" Software Foundation, version 1.2 or (at your option) any later
.\" version, with no Invariant Sections, no Front-Cover Texts, and no
.\" Back-Cover Texts. You should have received a copy of the GNU Free
.\" Documentation License along with this program. If not, see
.\" <http://www.gnu.org/licenses/>.
.\"
.\" Ce document est publié sous une double licence. Vous pouvez
.\" le distribuer et le modifier selon les termes de l'une des deux
.\" licences ci-dessous :
.\"
.\" * La Licence publique générale GNU (GNU GPL) version 3 ou, à
.\" votre choix, supérieure, telle que publiée par la Free
.\" Software Foundation. Vous devriez avoir reçu une copie de la
.\" Licence publique générale GNU avec ce programme. Si ce n'est pas
.\" le cas, consultez <http://www.gnu.org/licenses/>.
.\"
.\" * La Licence de documentation libre GNU (GNU FDL), version 1.2 ou,
.\" à votre choix, supérieure, telle que publiée par la Free
.\" Software Foundation, sans section invariante, ni texte de
.\" première ou de quatrième de couverture. Vous devriez avoir reçu
.\" une copie de la Licence de documentation libre GNU avec ce
.\" programme. Si ce n'est pas le cas, consultez
.\" <http://www.gnu.org/licenses/>.
.\"
.TH NANO 1 "version 2.0.0" "29\ novembre\ 2007"
.\" Please adjust this date whenever revising the manpage.
.\" Merci de modifier ces dates à chaque mise à jour de cette page.
.\"
.SH NOM
nano \- NAno un NOuvel éditeur, un clone libre et amélioré de Pico
.SH SYNOPSIS
.B nano
.I [OPTIONS]\ [[+LIGNE,COLONNE]\ FICHIER]...
.br
.SH DESCRIPTION
Cette page de manuel décrit brièvement la commande \fBnano\fR.
.PP
.\" TeX users may be more comfortable with the \fB<whatever>\fP and
.\" \fI<whatever>\fP escape sequences to invoke bold face and italics,
.\" respectively.
\fBnano\fR est un éditeur petit, sympathique et libre, qui vise à remplacer
Pico, l'éditeur par défaut du logiciel non libre Pine. \fBnano\fR ne se
contentant pas de copier l'interface et l'ergonomie de Pico, il offre
également certaines fonctions manquantes (ou désactivées par défaut)
dans Pico. Ces fonctionnalités sont, par exemple, les fonctions de
recherche et de remplacement, et la possibilité de sauter directement à
une ligne et à une colonne précise.
.SH OPTIONS
.TP
.B +\fILIGNE\fP,\fICOLONNE\fP
Démarre avec le curseur positionné à la colonne \fICOLONNE\fP de
la ligne \fILIGNE\fR (l'un des deux, au moins, devant être spécifié) au
lieu de démarrer à la colonne\ 1, ligne\ 1.
.TP
.B \-?
Identique à \fB\-h (\-\-help)\fP.
.TP
.B \-A (\-\-smarthome)
Rend plus malin le fonctionnement de la touche «\ Début\ ». Lorsque l'on
appuie sur cette touche à n'importe quel endroit excepté au tout début
du texte d'une ligne (i.\ e. au premier caractère non blanc), le curseur
se positionnera au début du texte de la ligne (qu'il soit en avant ou en
arrière). Si le curseur est déjà là, il se placera au vrai début de la
ligne.
.TP
.B \-B (\-\-backup)
Lors de l'écriture d'un fichier, crée une copie de sécurité de la
version précédente, en ajoutant un tilde (~) au nom du fichier.
.TP
.B \-D (\-\-boldtext)
Utilise des caractères gras à la place de la vidéo inverse.
.TP
.B \-C \fIrépertoire\fP (\-\-backupdir=\fIrépertoire\fP)
Définit le répertoire utilisé par \fBnano\fP pour enregistrer les copies
de sécurité uniques si celles-ci sont activées.
.TP
.B \-E (\-\-tabstospaces)
Convertit les tabulations clavier en espaces.
.TP
.B \-F (\-\-multibuffer)
Active le mode multi-espace, autorisant l'édition simultanée de
plusieurs fichiers, si ce mode est disponible.
.TP
.B \-H (\-\-historylog)
Enregistre les chaînes ayant fait l'objet d'une recherche ou d'un
remplacement dans le fichier \fI~/.nano_history\fR afin de permettre leur
réutilisation. Ceci n'est possible que si \fBnano\fR est configuré pour
utiliser les fichiers nanorc.
.TP
.B \-I (\-\-ignorercfiles)
Ne pas utiliser pas les fichiers \fISYSCONFDIR/nanorc\fR et
\fI~/.nanorc\fR (si \fBnano\fR est capable de les utiliser).
.TP
.B \-K (\-\-rebindkeypad)
Interprète les touches du pavé numérique afin qu'elles fonctionnent
toutes correctement. Vous ne devriez utiliser cette option que si ce
n'est pas le cas, car nano ne sera plus capable d'utiliser la souris
correctement lorsque cette option sera activée.
.TP
.B \-L (\-\-nonewlines)
Ne pas ajouter de passage à la ligne à la fin des fichiers.
.TP
.B \-N (\-\-noconvert)
Désactive la conversion automatique des fichiers depuis les formats Mac et
DOS.
.TP
.B \-O (\-\-morespace)
Utiliser la ligne blanche située sous la ligne de titre comme
espace supplémentaire d'édition.
.TP
.B \-Q \fIchaîne\fP (\-\-quotestr=\fIchaîne\fP)
Définit le préfixe par défaut des citations. Nano utilise ce préfixe
pour réaliser une justification correcte des citations. Si nano est
capable d'utiliser des expressions rationnelles, le préfixe par défaut
sera "\fI^([\ \\t]*[#:>\\|}])+\fP", sinon, ce sera "\fI>\ \fP". Dans
l'expression rationnelle précédente, «\ \fI\\t\fP\ » représente une
tabulation.
.TP
.B \-R (\-\-restricted)
Mode restreint\ : aucune lecture ou écriture de fichiers non indiqués
sur la ligne de commande, pas de lecture des fichiers nanorc,
interdiction de suspendre, interdiction d'ajouter au début, à la fin,
de sauvegarder un fichier ayant déjà un nom sous un nom différent,
d'utiliser une copie de sécurité ou le correcteur orthographique. Cette
option peut aussi être activée en appelant \fBnano\fP sous un nom
commençant par «\ r\ » (par exemple «\ rnano\ »).
.TP
.B \-S (\-\-smooth)
Active le défilement progressif. Le texte défilera ligne-par-ligne au lieu
de défiler morceau-par-morceau.
.TP
.B \-T \fInombre\fP (\-\-tabsize=\fInombre\fP)
Définit la taille (largeur) des tabulations en nombre de colonnes. Le
nombre indiqué doit être strictement supérieur à 0. La valeur par défaut
est de 8.
.TP
.B \-U (\-\-quickblank)
Effacement rapide de la ligne d'état. Les messages affichés par la ligne
d'état disparaîtront après une frappe clavier au lieu de 25. Notez que
l'option \fB-c\fP prend le pas sur cette option.
.TP
.B \-V (\-\-version)
Affiche la version, puis s'arrête.
.TP
.B \-W (\-\-wordbounds)
Détection plus précise des limites de mots, obtenue en considérant les
caractères de ponctuation comme faisant partie des mots.
.TP
.B \-Y \fIchaîne\fP (\-\-syntax=\fIchaîne\fP)
Indique quel mode de colorisation syntaxique adopter, parmi les modes
définis dans le fichier \fI.nanorc\fR, si cette fonctionnalité est
disponible.
.TP
.B \-c (\-\-const)
Affiche en permanence la position du curseur. Notez que cette option
prend le pas sur l'option \fB-U\fP.
.TP
.B \-d (\-\-rebinddelete)
Interprète différemment la touche «\ Supprimer\ », afin que les touches
«\ Effacement arrière\ » et «\ Supprimer\ » fonctionnent correctement.
Vous ne devriez avoir besoin de cette option que si, sur votre système,
la touche «\ Effacement arrière\ » produit l'effet de la touche
«\ Supprimer\ ».
.TP
.B \-h (\-\-help)
Affiche un résumé des options de lancement de nano, puis s'arrête.
.TP
.B \-i (\-\-autoindent)
Indentation automatique. Commence chaque nouvelle ligne au même niveau que
la ligne précédente. Utile pour l'édition de code source.
.TP
.B \-k (\-\-cut)
Coupe le texte du curseur à la fin de la ligne, au lieu de couper la
ligne entière.
.TP
.B \-l (\-\-nofollow)
Si le fichier édité est un lien symbolique, au lieu de le suivre,
remplace le lien par le nouveau fichier. Sans doute utile pour éditer
les fichiers de \fI/tmp\fR, non\ ?
.TP
.B \-m (\-\-mouse)
Active l'utilisation de la souris, si elle est disponible pour votre
système. Lorsque celle-ci est activée, il est possible d'utiliser la
souris pour positionner le curseur, pour marquer le texte (avec un
double-clic) et pour lancer les fonctions correspondant aux raccourcis.
Il est possible d'utiliser la souris sous X\ Window ou en mode console
avec gpm.
.TP
.B \-o \fIrépertoire\fP (\-\-operatingdir=\fIrépertoire\fP)
Définit le répertoire de travail. Demande à \fBnano\fP de mettre en place
quelque chose de similaire à un environnement d'exécution restreint
(\fIchroot\fR).
.TP
.B \-p (\-\-preserve)
Préserve les séquences XON et XOFF (^Q et ^S), afin qu'elle soient reçues
par le terminal.
.TP
.B \-r \fIcolonne\fP (\-\-fill=\fIcolonne\fP)
Passe automatiquement à la ligne une fois arrivé à la colonne
\fIcolonne\fR. Si la valeur indiquée est de 0 ou moins, le point de
passage à la ligne aura lieu à la taille de l'écran moins \fIcolonne\fR.
Cela permet de faire varier le point de passage à la ligne lorsque l'on
change la taille de l'écran. La valeur par défaut est de \-8.
.TP
.B \-s \fIprogramme\fP (\-\-speller=\fIprogramme\fP)
Choix d'un correcteur orthographique de remplacement.
.TP
.B \-t (\-\-tempfile)
S'il a été modifié, le fichier sera sauvegardé automatiquement sans
demande de confirmation. Identique à l'option \fB-t\fP de Pico.
.TP
.B \-v (\-\-view)
Mode visualisation (lecture seule).
.TP
.B \-w (\-\-nowrap)
Désactive le passage automatique à la ligne.
.TP
.B \-x (\-\-nohelp)
Désactive la barre d'aide affichée en bas de l'écran.
.TP
.B \-z (\-\-suspend)
Autorise à suspendre l'éditeur.
.TP
.B \-a, \-b, \-e, \-f, \-g, \-j
Ignoré, pour être compatible avec Pico.
.SH "FICHIERS D'INITIALISATION"
\fBnano\fR lit les fichiers d'initialisation dans l'ordre suivant\ :
\fISYSCONFDIR/nanorc\fR, puis \fI~/.nanorc\fR. Référez-vous à la page de
manuel de \fBnanorc(5)\fR et au fichier d'exemple \fInanorc.sample\fR,
qui devraient tous les deux être livrés avec \fBnano\fR.
.SH NOTES
Si aucun correcteur orthographique de remplacement n'est indiqué dans la
ligne de commande ou dans l'un des fichiers nanorc, \fBnano\fR prendra
la commande indiquée par la variable d'environnement \fBSPELL\fR si
elle est définie.
Dans certains cas, \fBnano\fR essaiera de sauvegarder le fichier en cours
d'édition dans un fichier de secours. Cela arrivera principalement si
\fBnano\fR reçoit un signal SIGHUP ou SIGTERM, ou bien se trouve à court de
mémoire. Le nom de ce fichier de secours sera \fInano.save\fR si le fichier en
cours n'avait pas encore de nom, ou sera composé du nom du fichier en cours
suivi du suffixe «\ .save\ ». Si un fichier de ce nom existe déjà dans
le répertoire, un «\ .save\ » et un nombre seront ajoutés à la fin du
nom du fichier en cours afin de le rendre unique (par exemple,
«\ .save.1\ »). En mode multi-espace, \fBnano\fR réalisera une
sauvegarde de tous les fichiers en cours dans leurs fichiers de secours
respectifs.
.SH BOGUES
Merci de nous faire parvenir vos commentaires et de nous signaler les
bogues, en écrivant, en anglais, à \fBnano@nano-editor.org\fR.
La liste de discussion anglophone \fBnano\fR est disponible à l'adresse
\fBnano-devel@gnu.org\fR.
Pour vous abonner, envoyez un courrier électronique à
\fBnano-devel-request@gnu.org\fR, ayant pour objet «\ subscribe\ ».
N'hésitez pas également à envoyez vos commentaires, suggestions et
corrections relatives à l'adaptation française de cette page de manuel
ou du logiciel à \fBjean-philippe.guerard@tigreraye.org\fR.
.SH "SITE INTERNET"
http://www.nano-editor.org/
.SH "VOIR AUSSI"
.PD 0
.TP
\fBnanorc\fR(5)
.PP
\fI/usr/share/doc/nano/\fR (ou son équivalent sur votre système)
.SH AUTEUR
Chris Allegretta <chrisa@asty.org> et d'autres (voir les fichiers
\fIAUTHORS\fR et \fITHANKS\fR pour plus d'information). Cette page de
manuel a été initialement rédigée par Jordi Mallach <jordi@gnu.org> pour
le système Debian (mais elle peut être utilisée par d'autres).
.SH TRADUCTION
Cette adaptation française a été réalisée par Jean-Philippe\ Guérard
<jean-philippe.guerard@tigreraye.org> le 29\ novembre\ 2007 à partir
de la version 1.54 du 11\ octobre\ 2007 de la page de manuel de nano
2.0.0. Cette page a été relue par Gérard Delafond.
Un maximum de soin a été apporté lors de l'élaboration de cette
traduction\ ; néanmoins, quelques imperfections peuvent subsister. Si
vous en rencontrez, que ce soit dans la version française ou dans la
version originale, n'hésitez pas à les signaler à l'auteur ou au
traducteur.
La version originale la plus à jour de ce document est toujours
consultable via la commande\ :
LANGUAGE=en man nano

View File

@@ -1,374 +0,0 @@
.\" Copyright (C) 2003, 2004, 2005, 2006, 2007
.\" Free Software Foundation, Inc.
.\"
.\" Le travail d'adaptation française de cette page de manuel a été
.\" réalisé par Jean-Philippe Guérard, en 2003, 2004, 2005, 2006 et 2007.
.\" Ce travail d'adaptation est dans le domaine public. Attention, la
.\" page traduite reste soumise au droit d'auteur de ses auteurs
.\" originaux.
.\"
.\" The French translation of this document is a public domain work of
.\" Jean-Philippe Guérard. This translation work was made in 2003, 2004,
.\" 2005, 2006 and 2007. The translated man page in itself is still
.\" subject to the copyright of its original authors.
.\"
.\" This document is dual-licensed. You may distribute and/or modify it
.\" under the terms of either of the following licenses:
.\"
.\" * The GNU General Public License, as published by the Free Software
.\" Foundation, version 3 or (at your option) any later version. You
.\" should have received a copy of the GNU General Public License
.\" along with this program. If not, see
.\" <http://www.gnu.org/licenses/>.
.\"
.\" * The GNU Free Documentation License, as published by the Free
.\" Software Foundation, version 1.2 or (at your option) any later
.\" version, with no Invariant Sections, no Front-Cover Texts, and no
.\" Back-Cover Texts. You should have received a copy of the GNU Free
.\" Documentation License along with this program. If not, see
.\" <http://www.gnu.org/licenses/>.
.\"
.\" Ce document est publié sous une double licence. Vous pouvez
.\" le distribuer et le modifier selon les termes de l'une des deux
.\" licences ci-dessous :
.\"
.\" * La Licence publique générale GNU (GNU GPL) version 3 ou, à
.\" votre choix, supérieure, telle que publiée par la Free
.\" Software Foundation. Vous devriez avoir reçu une copie de la
.\" Licence publique générale GNU avec ce programme. Si ce n'est
.\" pas le cas, consultez <http://www.gnu.org/licenses/>.
.\"
.\" * La Licence de documentation libre GNU (GNU FDL), version 1.2
.\" ou, à votre choix, supérieure, telle que publiée par la Free
.\" Software Foundation, sans section invariante, ni texte de
.\" première ou de quatrième de couverture. Vous devriez avoir reçu
.\" une copie de la Licence de documentation libre GNU avec ce
.\" programme. Si ce n'est pas le cas, consultez
.\" <http://www.gnu.org/licenses/>.
.\"
.TH NANORC 5 "version 2.0.0" "29\ novembre\ 2007"
.\" Please adjust this date whenever revising the manpage.
.\" Merci de modifier ces dates à chaque mise à jour de cette page.
.SH NOM
nanorc \- fichier de configuration de l'éditeur nano du projet GNU
.SH DESCRIPTION
Cette page de manuel décrit brièvement le fichier de configuration de
l'éditeur \fBnano\fP GNU.
.PP
\fBnano\fP est un petit éditeur sympathique et libre, qui vise à
remplacer Pico, l'éditeur par défaut du logiciel non libre Pine.
\fBnano\fP ne se contentant pas de copier l'interface et l'ergonomie de
Pico, il offre également certaines fonctionnalités manquantes (ou
désactivées par défaut) de Pico. Ces fonctionnalités sont, par exemple,
les fonctions de recherche et de remplacement et la possibilité de
sauter directement à une ligne et à une colonne précise.
.PP
Le fichier \fInanorc\fP contient les paramètres par défaut de
\fBnano\fP. Il ne doit pas être au format DOS ou Mac. Lors de son
démarrage, nano commencera par lire le fichier de configuration général
\fISYSCONFDIR/nanorc\fP, puis lira le fichier de configuration personnel
de l'utilisateur \fI~/.nanorc\fP.
.SH OPTIONS
Le fichier de configuration accepte une série de commandes \fBset\fP
(activer) et \fBunset\fP (désactiver), qui permettent de définir le
paramétrage de nano au démarrage sans avoir à utiliser d'options de
ligne de commande. De plus, les mots clefs \fBsyntax\fP (syntaxe),
\fBcolor\fP (couleur) et \fBicolor\fP (couleur insensible à la casse)
sont utilisés pour définir les règles de colorisation pour différents
motifs de texte. \fBnano\fP lit une commande par ligne.
Les options du fichier de configuration ont priorité sur les valeurs par
défaut utilisées par nano. Les options de la ligne de commande sont
prioritaires par rapport aux options du fichier de configuration. Les
options sont désactivées (unset) par défaut, sauf les options prenant un
argument.
Les apostrophes («\ \fI'\fP\ ») et les guillemets droits («\ \fI"\fP\ »)
présents dans des chaînes de caractères utilisées comme paramètres n'ont
pas besoin d'être précédées d'une barre oblique inversée
\ \fI\\\fP\ »). La chaîne sera terminée par le dernier guillemet
droit. Par exemple, pour l'option \fBbrackets\fP, "\fI"')>]}\fP"
correspondra à \fI"\fP, \fI'\fP, \fI)\fP, \fI>\fP, \fI]\fP et \fI}\fP.
Les commandes et arguments reconnus sont\ :
.TP 3
.B set/unset autoindent
Active l'indentation automatique.
.TP
.B set/unset backup
Crée des copies de sécurité nommées
.IR nom_du_fichier~ .
.TP
.B set backupdir "\fIrépertoire\fP"
Définit le répertoire utilisé par \fBnano\fP pour enregistrer les copies
de sécurité uniques, si l'enregistrement de copies de sécurité est
activé.
.TP
.B set/unset backwards
Par défaut, les recherches se font vers l'arrière.
.TP
.B set/unset boldtext
Utilise des caractères gras à la place de la vidéo inverse.
.TP
.B set brackets "\fIchaîne\fP"
Définit les caractères considérés comme des crochets fermants lors de la
justification des paragraphes. Ces caractères ne doivent pas contenir
d'espaces. Seules les ponctuations terminales, éventuellement suivies
de crochets fermants, peuvent terminer une phrase.
La valeur par défaut de cette option est\ : "\fI"')>]}\fP".
N.D.T.\ : reportez-vous au paragraphe sur l'option \fBpunct\fR pour
plus d'informations.
.TP
.B set/unset casesensitive
Par défaut, les recherches ne tiennent pas compte de la casse.
.TP
.B set/unset const
Affiche en permanence la position du curseur dans la ligne d'état.
.TP
.B set/unset cut
Par défaut, coupe le texte du curseur à la fin de la ligne, au lieu de
couper la ligne entière.
.TP
.B set fill \fIn\fP
Passe automatiquement à la ligne une fois arrivé à la colonne
\fIn\fR. Si la valeur indiquée est de 0 ou moins, le point de passage à
la ligne aura lieu à la taille de l'écran moins \fIn\fR. Cela permet de
faire varier le point de passage à la ligne lorsque l'on change la
taille de l'écran. La valeur par défaut est de \-8.
.TP
.B set/unset historylog
Active l'utilisation de
.I ~/.nano_history
pour enregistrer et relire les chaînes ayant fait l'objet d'une
recherche ou d'un remplacement.
.TP
.B set matchbrackets "\fIchaîne\fP"
Définit les crochets ouvrants et fermant pour la recherche de crochets
correspondants. Cette liste ne doit pas contenir de blancs. L'ensemble
des crochets ouvrants doit être indiqué en premier, suivi de l'ensemble
des crochets fermant, qui doit être dans le même ordre. La valeur par
défaut de cette option est "\fI(<[{)>]}\fP".
.TP
.B set/unset morespace
Utiliser la ligne blanche située sous la ligne de titre comme espace
supplémentaire d'édition.
.TP
.B set/unset mouse
Active l'utilisation de la souris, si elle est disponible pour votre
système. Lorsque celle-ci est activée, il est possible d'utiliser la
souris pour positionner le curseur, pour marquer le texte (avec un
double-clic) et pour lancer les fonctions correspondant aux raccourcis.
Il est possible d'utiliser la souris sous X\ Window ou en mode console
avec gpm.
.TP
.B set/unset multibuffer
Mode multi-espace\ : permet de charger les fichiers dans leur propre
espace.
.TP
.B set/unset noconvert
Pas de conversion depuis les formats DOS et Mac.
.TP
.B set/unset nofollow
Ne suit pas les liens symboliques lors de l'écriture des fichiers.
.TP
.B set/unset nohelp
Désactive les lignes d'aide affichée en bas de l'écran.
.TP
.B set/unset nonewlines
Ne pas ajouter de passage à la ligne à la fin des fichiers.
.TP
.B set/unset nowrap
Désactive le passage automatique à la ligne.
.TP
.B set operatingdir "\fIrépertoire\fP"
\fBnano\fP ne lira et n'écrira des fichiers qu'à l'intérieur du
\fIrépertoire\fP et de ses sous-répertoires. De plus, celui-ci devient
le répertoire courant, afin que les fichiers soient lus depuis ce
répertoire. Par défaut, cette fonction est désactivée.
.TP
.B set/unset preserve
Préserve les séquences XON et XOFF (^Q et ^S).
.TP
.B set punct "\fIchaîne\fP"
Définit les caractères interprétés comme des ponctuations terminales
lors de la justification des paragraphes. Ces caractères ne peuvent
inclure de blancs. Seules les ponctuations terminales, éventuellement
suivies de crochets fermants, peuvent terminer une phrase. La valeur par
défaut de cette option est "\fI!.?\fP".
N.D.T.\ : ce réglage permet, lors de la justification, de conserver
2\ espaces au lieu d'une derrière les ponctuations terminales, ce qui
correspond aux normes typographiques anglo-saxonnes, mais n'a pas lieu
d'être en français. Pour le français, le plus simple est d'indiquer,
dans le fichier nanorc, une chaîne vide pour ce paramètre.
.TP
.B set/unset quickblank
Effacement rapide de la ligne d'état. Les messages affichés par la ligne
d'état disparaîtront après une frappe clavier au lieu de 25.
.TP
.B set quotestr "\fIchaîne\fP"
Définit le préfixe par défaut utilisé pour les citations dans les
courriers électroniques. Ce préfixe est utilisé pour réaliser une
justification correcte de ces citations. Il s'agira, si votre système le
permet, d'une expression rationnelle étendue. Dans le cas
contraire, il s'agira d'une chaîne de texte brut. Si vous disposez des
expressions rationnelles, la valeur par défaut de cette option sera
"\fI^([\ \\t]*[#:>\\|}])+\fP", sinon, ce sera ">\ ". Notez que le
«\ \\t\ » ci-dessus correspond à un caractère de tabulation.
.TP
.B set/unset rebinddelete
Interprète différemment la touche «\ Supprimer\ », afin que les touches
«\ Effacement arrière\ » et «\ Supprimer\ » fonctionnent correctement.
Vous ne devriez avoir besoin de cette option que si, sur votre système,
la touche «\ Effacement arrière\ » produit l'effet de la touche «\
Supprimer\ ».
.TP
.B set/unset rebindkeypad
Interprète les touches du pavé numérique afin qu'elles fonctionnent
toutes correctement. Vous ne devriez utiliser cette option que si ce
n'est pas le cas, car nano ne sera plus capable d'utiliser la souris
correctement lorsque cette option sera activée.
.TP
.B set/unset regexp
Utilise par défaut des expressions rationnelles étendues pour les
recherches.
.TP
.B set/unset smarthome
Rend plus malin le fonctionnement de la touche «\ Début\ ». Lorsque
cette touche est pressée à n'importe quel endroit excepté au tout début
du texte d'une ligne (i.\ e. au premier caractère non blanc), le curseur
se positionnera au début du texte de la ligne (qu'il soit en avant ou en
arrière). Si le curseur est déjà là, il se placera au vrai début de la
ligne.
.TP
.B set/unset smooth
Active le défilement ligne-par-ligne du texte.
.TP
.B set speller "\fIprogramme\fP"
Utilise le correcteur orthographique \fIprogramme\fP au lieu du
correcteur intégré, qui s'appuie sur \fIspell\fP.
.TP
.B set/unset suspend
Autorise à suspendre \fBnano\fP.
.TP
.B set tabsize \fIn\fP
Utilise une taille de tabulation de \fIn\fP colonnes. Cette valeur doit
être strictement supérieure à 0. La valeur par défaut est de\ 8.
.TP
.B set/unset tabstospaces
Convertit les tabulations clavier en espaces.
.TP
.B set/unset tempfile
S'il a été modifié, le fichier sera sauvegardé automatiquement en
quittant, sans demande de confirmation.
.TP
.B set/unset view
Interdit de modifier les fichiers.
.TP
.B set whitespace "\fIchaîne\fP"
Définit les deux caractères utilisés pour afficher les premiers
caractères des tabulations et des espaces. Ces deux caractères doivent
être mono-colonne.
.TP
.B set/unset wordbounds
Détection plus précise des limites de mots, obtenue en considérant les
caractères de ponctuation comme faisant partie des mots.
.TP
.B syntax "\fIchaîne\fP" ["\fImotif_de_fichier\fP" ... ]
Définit une syntaxe nommée \fIchaîne\fP qui pourra être activé via
l'option \fB-Y\fP (ou \fB--syntax\fP) ou qui sera automatiquement
activée si le nom du fichier en cours correspond à l'expression
rationnelle étendue \fImotif_de_fichier\fP. Toutes les instructions
suivantes de colorisation \fBcolor\fP ou \fBicolor\fP s'appliqueront à
cette syntaxe, jusqu'à la définition d'une nouvelle syntaxe.
La syntaxe nommée \fInone\fP (aucune) est réservée\ ; si elle est
indiquée dans la ligne de commande, cela revient à ne définir aucune
syntaxe. La syntaxe nommée \fIdefault\fP (par défaut) est spéciale, elle
ne nécessite aucun motif de \fImotif_de_fichier\fP, et s'applique aux
fichiers ne correspondant à aucun des \fImotif_de_fichier\fP des autres
syntaxes.
.TP
.B color \fIcouleur_texte\fP[,\fIcouleur_fond\fP] "\fImotif\fP" ...
Pour la syntaxe en cours, affiche toutes les expressions correspondant à
l'expression rationnelle étendue \fImotif\fP en utilisant la couleur de
texte \fIcouleur_texte\fP et la couleur de fond \fIcouleur_fond\fP,
l'une de ces deux couleurs au moins devant être définie. Les couleurs
acceptées par \fBnano\fP pour le texte et le fond sont\ : \fIwhite\fP
(blanc), \fIblack\fP (noir), \fIred\fP (rouge), \fIblue\fP (bleu),
\fIgreen\fP (vert), \fIyellow\fP (jaune), \fImagenta\fP, et \fIcyan\fP.
Pour la couleur du texte, vous pouvez ajouter à ces couleurs le préfixe
\fIbright\fP (lumineux) pour obtenir une couleur plus lumineuse. Si
votre terminal est capable de gérer la transparence, ne pas spécifier de
\fIcouleur_fond\fP indique à \fBnano\fP d'essayer d'utiliser un fond
transparent.
.TP
.B icolor \fIcouleur_texte\fP[,\fIcouleur_fond\fP] "\fImotif\fP" ...
Comme ci-dessus, mais la recherche des motifs est effectuée sans tenir
compte de la casse.
.TP
.B color \fIcouleur_texte\fP[,\fIcouleur_fond\fP] start="\fImotif_début\fP" end="\fImotif_fin\fP"
Affiche les expressions commençant par l'expression rationnelle étendue
\fImotif_début\fP et se terminant par l'expression rationnelle étendue
\fImotif_fin\fP en utilisant la couleur de texte \fIcouleur_texte\fP
et la couleur de fond \fIcouleur_fond\fP, l'une de ces deux couleurs au
moins devant être définie. Cela permet à la colorisation syntaxique de
s'étendre sur plusieurs lignes. Notez que toutes les occurrences
successives de \fImotif_début\fP après le \fImotif_début\fP initial
seront surlignées jusqu'à la prochaine instance de \fImotif_fin\fP.
.TP
.B icolor \fIcouleur_texte\fP[,\fIcouleur_fond\fP] start="\fImotif_début\fP" end="\fImotif_fin\fP"
Comme ci-dessus, mais la recherche des motifs est effectuée sans tenir
compte de la casse.
.TP
.B include "\fIfichier_de_syntaxes\fP"
Lit le fichier \fIfichier_de_syntaxes\fP contenant une liste
autosuffisante de définitions de syntaxes. Ce fichier ne doit contenir
que des commandes \fBsyntax\fP, \fBcolor\fP et \fBicolor\fP.
.SH FICHIERS
.TP
.I $SYSCONFDIR/nanorc
Fichier de configuration général
.TP
.I ~/.nanorc
Fichier de configuration personnel
.SH VOIR AUSSI
.PD 0
.TP
\fBnano\fP(1)
.PP
\fI/usr/share/doc/nano/examples/nanorc.sample\fP (ou son équivalent sur
votre système)
.SH AUTEUR
Chris Allegretta <chrisa@asty.org> et d'autres (voir les fichiers
\fIAUTHORS\fP et \fITHANKS\fP pour plus d'information). Cette page de
manuel a été initialement rédigée par Jordi Mallach <jordi@gnu.org> pour
le système Debian (mais elle peut être utilisée par d'autres).
.SH TRADUCTION
Cette adaptation française a été réalisée par Jean-Philippe\ Guérard
<jean-philippe.guerard@tigreraye.org> le 29\ novembre\ 2007 à partir de
la version 1.56 du 11\ octobre\ 2007 de la page de manuel de nanorc
(pour la version 2.0.0 de nano). Cette page a été relue par Gérard
Delafond.
Un maximum de soin a été apporté lors de l'élaboration de cette
traduction\ ; néanmoins, quelques imperfections peuvent subsister. Si
vous en rencontrez, que ce soit dans la version française ou dans la
version originale, n'hésitez pas à les signaler à l'auteur ou au
traducteur.
La version originale la plus à jour de ce document est toujours
consultable via la commande\ :
LANGUAGE=en man nano

View File

@@ -1,152 +0,0 @@
.\" Copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc.
.\" Skeleton based on nano-tiny.1:
.\" Copyright (C) 2002 Free Software Foundation, Inc.
.\"
.\" Le travail d'adaptation française de cette page de manuel a été
.\" réalisé par Jean-Philippe Guérard, en 2006 et 2007. Ce travail
.\" d'adaptation est dans le domaine public. Attention, la page traduite
.\" reste soumise au droit d'auteur de ses auteurs originaux.
.\"
.\" The French translation of this document is a public domain work of
.\" Jean-Philippe Guérard. This translation work was made in 2006 and
.\" 2007. The translated man page in itself is still subject to the
.\" copyright of its original authors.
.\"
.\" This document is dual-licensed. You may distribute and/or modify it
.\" under the terms of either of the following licenses:
.\"
.\" * The GNU General Public License, as published by the Free Software
.\" Foundation, version 3 or (at your option) any later version. You
.\" should have received a copy of the GNU General Public License
.\" along with this program. If not, see
.\" <http://www.gnu.org/licenses/>.
.\"
.\" * The GNU Free Documentation License, as published by the Free
.\" Software Foundation, version 1.2 or (at your option) any later
.\" version, with no Invariant Sections, no Front-Cover Texts, and no
.\" Back-Cover Texts. You should have received a copy of the GNU Free
.\" Documentation License along with this program. If not, see
.\" <http://www.gnu.org/licenses/>.
.\"
.\" Ce document est publié sous une double licence. Vous pouvez
.\" le distribuer et le modifier selon les termes de l'une des deux
.\" licences ci-dessous :
.\"
.\" * La Licence publique générale GNU (GNU GPL) version 3 ou, à
.\" votre choix, supérieure, telle que publiée par la Free
.\" Software Foundation. Vous devriez avoir reçu une copie de la
.\" Licence publique générale GNU avec ce programme. Si ce n'est pas
.\" le cas, consultez <http://www.gnu.org/licenses/>.
.\"
.\" * La Licence de documentation libre GNU (GNU FDL), version 1.2 ou,
.\" à votre choix, supérieure, telle que publiée par la Free
.\" Software Foundation, sans section invariante, ni texte de
.\" première ou de quatrième de couverture. Vous devriez avoir reçu
.\" une copie de la Licence de documentation libre GNU avec ce
.\" programme. Si ce n'est pas le cas, consultez
.\" <http://www.gnu.org/licenses/>.
.\"
.TH RNANO 1 "version 2.0.0" "29\ novembre\ 20O7"
.\" Please adjust this date whenever revising the manpage.
.\" Merci de modifier ces dates à chaque mise à jour de cette page.
.\"
.SH NOM
rnano \- Le mode restreint de NAno un NOuvel éditeur, un clone libre et
amélioré de Pico
.SH SYNOPSIS
.B rnano
.I [OPTIONS]\ [[+LIGNE,COLONNE]\ FICHIER]...
.br
.SH DESCRIPTION
Cette page de manuel décrit brièvement la commande \fBrnano\fR.
.PP
.\" TeX users may be more comfortable with the \fB<whatever>\fP and
.\" \fI<whatever>\fP escape sequences to invoke bold face and italics,
.\" respectively.
\fBnano\fR est un éditeur petit, sympathique et libre, qui vise à
remplacer Pico, l'éditeur par défaut du logiciel non libre Pine.
\fBnano\fR ne se contentant pas de copier l'interface et l'ergonomie de
Pico, il offre également certaines fonctions manquantes (ou désactivées
par défaut) dans Pico. Ces fonctionnalités sont, par exemple, les
fonctions de recherche et de remplacement, et la possibilité de sauter
directement à une ligne et à une colonne précise..
.PP
\fBrnano\fP est une version de \fBnano\fP fonctionnant en mode
restreint, qui ne permet d'éditer que les fichiers indiqués et qui
n'autorise pas l'utilisateur à accéder au système de fichier ou à un
interpréteur de commandes.
.PP
En mode restreint, \fBnano\fP refusera\ :
.IP \[bu] 2
de lire ou d'écrire dans un fichier n'ayant pas été indiqué dans la
ligne de commande\ ;
.IP \[bu]
de lire un fichier nanorc\ ;
.IP \[bu]
de permettre de suspendre l'édition\ ;
.IP \[bu]
de permettre d'ajouter en début ou en fin d'un fichier, ou de
l'enregistrer sous un nom différent\ ;
.IP \[bu]
l'utilisation de copies de sécurité ou de la correction orthographique.
.SH OPTIONS
.TP
.B +\fILIGNE\fP,\fICOLONNE\fP
Démarre avec le curseur positionné à la colonne \fICOLONNE\fP de
la ligne \fILIGNE\fR (l'un des deux, au moins, devant être spécifié) au
lieu de démarrer à la colonne\ 1, ligne\ 1.
.TP
.B \-?
Identique à \fB\-h (\-\-help)\fP.
.TP
.B \-h (\-\-help)
Affiche un résumé des options de lancement de nano, puis s'arrête.
.TP
.B \-V (\-\-version)
Affiche la version, puis s'arrête.
.PP
Reportez-vous à la page de manuel \fBnano\fP(1) si vous souhaitez
consulter la documentation complète de \fBnano\fP.
.SH BOGUES
Merci de nous faire parvenir vos commentaires et de nous signaler les
bogues, en écrivant, en anglais, à \fBnano@nano-editor.org\fR.
La liste de discussion anglophone \fBnano\fR est disponible à l'adresse
\fBnano-devel@gnu.org\fR.
Pour vous abonner, envoyez un courrier électronique à
\fBnano-devel-request@gnu.org\fR, ayant pour objet «\ subscribe\ ».
N'hésitez pas également à envoyez vos commentaires, suggestions et
corrections relatives à l'adaptation française de cette page de manuel
ou du logiciel à \fBjean-philippe.guerard@tigreraye.org\fR.
.SH "SITE INTERNET"
http://www.nano-editor.org/
.SH AUTEUR
Chris Allegretta <chrisa@asty.org> et d'autres (voir le fichier
\fIAUTHORS\fR). Cette page de manuel a été initialement rédigée par
Thijs Kinkhorst <thijs@kinkhorst.com>, pour le système GNU Debian (mais
elle peut être utilisée par d'autres).
.SH TRADUCTION
Cette adaptation française a été réalisée par Jean-Philippe\ Guérard
<jean-philippe.guerard@tigreraye.org> le 29\ novembre\ 2007 à partir
de la version 1.19 du 6\ novembre\ 2007 de la page de manuel de rnano
(pour la version 2.0.0 de nano).
Un maximum de soin a été apporté lors de l'élaboration de cette
traduction\ ; néanmoins, quelques imperfections peuvent subsister. Si
vous en rencontrez, que ce soit dans la version française ou dans la
version originale, n'hésitez pas à les signaler à l'auteur ou au
traducteur.
La version originale la plus à jour de ce document est toujours
consultable via la commande\ :
LANGUAGE=en man nano

View File

@@ -1,79 +0,0 @@
.\" Copyright (C) 2002, 2005, 2006, 2007, 2014 Free Software Foundation, Inc.
.\"
.\" This document is dual-licensed. You may distribute and/or modify it
.\" under the terms of either of the following licenses:
.\"
.\" * The GNU General Public License, as published by the Free Software
.\" Foundation, version 3 or (at your option) any later version. You
.\" should have received a copy of the GNU General Public License
.\" along with this program. If not, see
.\" <http://www.gnu.org/licenses/>.
.\"
.\" * The GNU Free Documentation License, as published by the Free
.\" Software Foundation, version 1.2 or (at your option) any later
.\" version, with no Invariant Sections, no Front-Cover Texts, and no
.\" Back-Cover Texts. You should have received a copy of the GNU Free
.\" Documentation License along with this program. If not, see
.\" <http://www.gnu.org/licenses/>.
.\"
.TH RNANO 1 "version 2.7.0" "September 2016"
.\" Please adjust this date whenever revising the manpage.
.\"
.SH NAME
rnano \- Restricted mode for Nano's ANOther editor, an enhanced free
Pico clone
.SH SYNOPSIS
.B rnano
.RI [ options "] [[+" line , column "]\ " file "]..."
.SH DESCRIPTION
\fBnano\fP is a small, free and friendly editor which aims to replace
Pico, the default editor included in the non-free Pine package. On
top of copying Pico's look and feel, \fBnano\fP also implements some
missing (or disabled by default) features in Pico, such as "search and
replace" and "go to line and column number".
.PP
\fBrnano\fP is a restricted version of \fBnano\fP, which only edits
specific files and doesn't allow the user access to the filesystem or a
command shell.
.PP
In restricted mode, \fBnano\fP will \fInot\/\fP:
.IP \[bu] 2
read or write to any file not specified on the command line;
.IP \[bu]
read any nanorc files;
.IP \[bu]
allow suspending;
.IP \[bu]
allow a file to be appended to, prepended to, or saved under a different
name;
.IP \[bu]
use backup files or spell checking.
.SH OPTIONS
.TP
.BR \-h ", " \-\-help
Show a summary of command-line options and exit.
.TP
.BR \-V ", " \-\-version
Show the current version number and exit.
.PP
See the \fBnano\fP(1) manpage for all of the possible options.
.SH BUGS
Please send any comments or bug reports to \fBnano@nano-editor.org\fP.
The \fBnano\fP mailing list is available from \fBnano-devel@gnu.org\fP.
To subscribe, email to \fBnano-devel-request@gnu.org\fP with a subject
of "subscribe".
.SH HOMEPAGE
http://www.nano-editor.org/
.SH AUTHOR
Chris Allegretta <chrisa@asty.org>, et al (see the file AUTHORS for details).
This manual page was originally written by Thijs Kinkhorst
<thijs@kinkhorst.com>, for the Debian system (but may be used by
others).

View File

@@ -17,16 +17,15 @@
.\" Documentation License along with this program. If not, see
.\" <http://www.gnu.org/licenses/>.
.\"
.TH NANO 1 "version 2.7.0" "September 2016"
.TH NANO 1 "version 2.7.4" "January 2017"
.\" Please adjust this date whenever revising the manpage.
.\"
.SH NAME
nano \- Nano's ANOther editor, an enhanced free Pico clone
.SH SYNOPSIS
.B nano
.RI [ options "] [[+" line , column "]\ " file "]..."
.RI [ options "] [[+" line [, column "]]\ " file "]..."
.SH DESCRIPTION
\fBnano\fP is a small, free and friendly editor which aims to replace
@@ -38,7 +37,7 @@ replace" and "go to line and column number".
.SH EDITING
Entering text and moving around in a file is straightforward: typing the
letters and using the normal cursor movement keys. Commands are entered
by using the Control (^) and the Alt or Meta (M-) keys.
by using the Control (^) and the Alt or Meta (M\-) keys.
Typing \fB^K\fR deletes the current line and puts it in the cutbuffer.
Consecutive \fB^K\fRs will put all deleted lines together in the cutbuffer.
Any cursor movement or executing any other command will cause the next
@@ -47,7 +46,7 @@ contents of the cutbuffer at the current cursor position.
.PP
When a more precise piece of text needs to be cut or copied, one can mark
its start with \fB^6\fR, move the cursor to its end (the marked text will be
highlighted), and then use \fB^K\fR to cut it, or \fBM-6\fR to copy it to the
highlighted), and then use \fB^K\fR to cut it, or \fBM\-6\fR to copy it to the
cutbuffer. One can also save the marked text to a file with \fB^O\fR, or
spell check it with \fB^T\fR.
.PP
@@ -172,6 +171,10 @@ Interpret the Delete key differently so that both Backspace and Delete
work properly. You should only need to use this option if Backspace
acts like Delete on your system.
.TP
.BR \-g ", " \-\-showcursor
Make the cursor visible in the file browser, putting it on the
highlighted item. Useful for braille users.
.TP
.BR \-h ", " \-\-help
Show a summary of the available command-line options and exit.
.TP
@@ -180,9 +183,12 @@ Indent new lines to the previous line's indentation. Useful when
editing source code.
.TP
.BR \-k ", " \-\-cut
Make the 'Cut Text' command (normally ^K) cut from the current cursor
Make the 'Cut Text' command (normally \fB^K\fR) cut from the current cursor
position to the end of the line, instead of cutting the entire line.
.TP
.BR \-l ", " \-\-linenumbers
Display line numbers to the left of the text area.
.TP
.BR \-m ", " \-\-mouse
Enable mouse support, if available for your system. When enabled, mouse
clicks can be used to place the cursor, set the mark (with a double
@@ -214,15 +220,13 @@ Hard-wrap lines at column \fInumber\fP. If this value is 0 or less, wrapping
will occur at the width of the screen less \fInumber\fP columns, allowing
the wrap point to vary along with the width of the screen if the screen
is resized. The default value is \-8. This option conflicts with
.B \-w
-- the last one given takes effect.
\fB\-w\fR -- the last one given takes effect.
.TP
.BR \-s\ \fIprogram\fR ", " \-\-speller= \fIprogram
Use this alternative spell checker command.
.TP
.BR \-t ", " \-\-tempfile
Always save a changed buffer without prompting. Same as Pico's \fB\-t\fP
option.
Save a changed buffer without prompting (when exiting with \fB^X\fR).
.TP
.BR \-u ", " \-\-unix
Save a file by default in Unix format. This overrides nano's
@@ -230,12 +234,11 @@ default behavior of saving a file in the format that it had.
(This option has no effect when you also use \fB\-\-noconvert\fR.)
.TP
.BR \-v ", " \-\-view
View-file (read-only) mode.
Just view the file and disallow editing: read-only mode.
.TP
.BR \-w ", " \-\-nowrap
Disable the hard-wrapping of long lines. This option conflicts with
.B \-r
-- the last one given takes effect.
\fB\-r\fR -- the last one given takes effect.
.TP
.BR \-x ", " \-\-nohelp
Don't show the two help lines at the bottom of the screen.
@@ -251,9 +254,17 @@ continuing it over multiple screen lines. Since
this option last when using other options (e.g.\& 'nano \-wS$') or pass it
separately (e.g.\& 'nano \-wS \-$').
.TP
.BR \-a ", " \-b ", " \-e ", " \-f ", " \-g ", " \-j
.BR \-a ", " \-b ", " \-e ", " \-f ", " \-j
Ignored, for compatibility with Pico.
.SH TOGGLES
Several of the above options can be switched on and off also while
\fBnano\fR is running. For example, \fBM\-L\fR toggles the
hard-wrapping of long lines, \fBM\-$\fR toggles soft-wrapping,
\fBM\-#\fR toggles line numbers, \fBM\-M\fR toggles the mouse,
\fBM\-I\fR auto-indentation, and \fBM\-X\fR the help lines.
See at the end of the \fB^G\fR help text for a complete list.
.SH INITIALIZATION FILE
\fBnano\fP will read initialization files in the following order:
the system's \fBnanorc\fP (if it exists), and then the user's
@@ -265,7 +276,7 @@ for more information on the possible contents of those files.
If no alternative spell checker command is specified on the command
line nor in one of the \fInanorc\fP files, \fBnano\fP will check the
\fBSPELL\fP environment variable for one.
.sp
In some cases \fBnano\fP will try to dump the buffer into an emergency
file. This will happen mainly if \fBnano\fP receives a SIGHUP or
SIGTERM or runs out of memory. It will write the buffer into a file
@@ -277,27 +288,25 @@ it unique. In multibuffer mode, \fBnano\fP will write all the open
buffers to their respective emergency files.
.SH BUGS
Justifications (\fB^J\fR) and reindentations (\fBM-{\fR and \fBM-}\fR)
Justifications (\fB^J\fR) and reindentations (\fBM\-{\fR and \fBM\-}\fR)
are not yet covered by the general undo system. So after a justification
that is not immediately undone, or after any reindentation, earlier edits
cannot be undone any more. The workaround is, of course, to exit without
saving.
.sp
Please report any other bugs that you encounter via
https://savannah.gnu.org/bugs/?group=nano.
Please report any other bugs that you encounter via:
.br
\fIhttps://savannah.gnu.org/bugs/?group=nano\fR.
.SH HOMEPAGE
https://nano-editor.org/
.SH SEE ALSO
.PD 0
.TP
\fBnanorc\fP(5)
.BR nanorc (5)
.PP
\fI/usr/share/doc/nano/\fP (or equivalent on your system)
.SH AUTHOR
Chris Allegretta <chrisa@asty.org>, et al (see the files \fIAUTHORS\fP and
Chris Allegretta and others (see the files \fIAUTHORS\fR and
\fITHANKS\fP for details). This manual page was originally written by
Jordi Mallach <jordi@gnu.org>, for the Debian system (but may be used by
others).
Jordi Mallach for the Debian system (but may be used by others).

View File

@@ -6,8 +6,8 @@
@smallbook
@set EDITION 0.4
@set VERSION 2.7.0
@set UPDATED September 2016
@set VERSION 2.7.4
@set UPDATED January 2017
@dircategory Editors
@direntry
@@ -21,7 +21,7 @@
@titlepage
@title GNU @code{nano}
@subtitle a small and friendly text editor.
@subtitle version 2.7.0
@subtitle version 2.7.4
@author Chris Allegretta
@page
@@ -256,6 +256,11 @@ Interpret the Delete key differently so that both Backspace and Delete
work properly. You should only need to use this option if Backspace
acts like Delete on your system.
@item -g
@itemx --showcursor
Make the cursor visible in the file browser, putting it on the
highlighted item. Useful for braille users.
@item -h
@itemx --help
Show a summary of command-line options and exit.
@@ -270,6 +275,10 @@ the previous line.
Make the 'Cut Text' command (normally ^K) cut from the current cursor
position to the end of the line, instead of cutting the entire line.
@item -l
@itemx --linenumbers
Display line numbers to the left of the text area.
@item -m
@itemx --mouse
Enable mouse support, if available for your system. When enabled, mouse
@@ -319,8 +328,8 @@ the @command{spell} program to be installed on your system.
@item -t
@itemx --tempfile
Don't ask whether or not to save the current contents of the file when
exiting, assume yes. This is most useful when using @command{nano} as the
Don't ask whether to save a modified buffer when exiting with ^X, but
assume yes. This option is useful when @command{nano} is used as the
composer of a mailer program.
@item -u
@@ -368,7 +377,6 @@ separately (e.g.@: @code{nano -wS -$}).
@itemx -b
@itemx -e
@itemx -f
@itemx -g
@itemx -j
Ignored, for compatibility with Pico.
@@ -402,14 +410,19 @@ Characters not present on the keyboard can be entered in two ways:
@item
For characters with a single-byte code,
pressing the Esc key twice and then typing a three-digit decimal number
(from 000 to 255) will enter the character with the corresponding value.
(from 000 to 255) will make @code{nano} behave as if you typed the key
with that value.
@item
For any possible character, pressing M-V (Alt+V) and then typing a
six-digit hexadecimal number (starting with 0 or 1) will enter the
character with the corresponding Unicode value.
corresponding Unicode character into the buffer.
@end itemize
For example, typing "Esc Esc 2 3 4" will enter the character "ê" ---
useful when going to a French party. Typing "M-V 0 0 2 5 c 6" will
enter the symbol "◆", a little black diamond.
@node Commands
@section Commands
@@ -592,6 +605,9 @@ toggles the @code{-z} (@code{--suspend}) command-line option.
@item Soft Wrapping Toggle (Meta-$)
toggles the @code{-$} (@code{--softwrap}) command-line option.
@item Line Numbers Toggle (Meta-#)
toggles the @code{-l} (@code{--linenumbers}) command-line option.
@end table
@@ -700,6 +716,9 @@ Specify the color combination to use for the shortcut key combos
in the two help lines at the bottom of the screen.
See @code{set titlecolor} for more details.
@item set linenumbers
Display line numbers to the left of the text area.
@item set locking
Enable vim-style lock-files for when editing files.
@@ -731,6 +750,10 @@ Don't add newlines to the ends of files.
@item set nowrap
Don't hard-wrap text at all.
@item set numbercolor @var{fgcolor},@var{bgcolor}
Specify the color combination to use for line numbers.
See @code{set titlecolor} for more details.
@item set operatingdir "directory"
@code{nano} will only read and write files inside "directory" and its
subdirectories. Also, the current directory is changed to here, so
@@ -782,6 +805,10 @@ won't work properly with this option enabled.
@item set regexp
Do extended regular expression searches by default.
@item set showcursor
Put the cursor on the highlighted item in the file browser, to aid
braille users.
@item set smarthome
Make the Home key smarter. When Home is pressed anywhere but at the
very beginning of non-whitespace characters on a line, the cursor will
@@ -819,7 +846,8 @@ Save automatically on exit, don't prompt.
@item set titlecolor @var{fgcolor},@var{bgcolor}
Specify the color combination to use for the titlebar.
Valid color names for foreground and background are:
white, black, red, blue, green, yellow, magenta, and cyan.
white, black, blue, green, red, cyan, yellow, and magenta.
The name of the foreground color may be prefixed with 'bright'.
And either @var{fgcolor} or @var{,bgcolor} may be left out.
@item set unix
@@ -1008,6 +1036,7 @@ a string in the current list in the file browser
@item searchagain
Repeats the last search command without prompting.
(The form 'research' is deprecated.)
@item findprevious
As @code{searchagain}, but always in the backward direction.
@@ -1042,6 +1071,7 @@ Cuts all text from the cursor position till the end of the buffer.
@item curpos
Shows the current cursor position: the line, column, and character positions.
(The form 'cursorpos' is deprecated.)
@item wordcount
Counts the number of words, lines and characters in the current buffer.
@@ -1066,6 +1096,10 @@ Unindents (shifts to the left) the currently marked text.
Comments or uncomments the current line or marked lines, using the comment
style specified in the active syntax.
@item complete
Completes the fragment before the cursor to a full word found elsewhere
in the current buffer.
@item left
Goes left one position (in the editor or browser).
@@ -1171,6 +1205,7 @@ Toggles case sensitivity in searching (search/replace menus only).
@item regexp
Toggles whether searching/replacing is based on literal strings or regular expressions.
(The form 'regex' is deprecated.)
@item backwards
Toggles whether searching/replacing goes forward or backward.
@@ -1183,6 +1218,7 @@ Shows the next history entry in the prompt menus (e.g.@: search).
@item flipreplace
Toggles between searching for something and replacing something.
(The form 'dontreplace' is deprecated.)
@item flipexecute
Toggles between inserting a file and executing a command.
@@ -1190,6 +1226,7 @@ Toggles between inserting a file and executing a command.
@item flipnewbuffer
Toggles between inserting into the current buffer and into a new
empty buffer.
(The form 'newbuffer' is deprecated.)
@item dosformat
When writing a file, switches to writing a DOS format (CR/LF).
@@ -1294,6 +1331,7 @@ The 'search to replace' menu.
@item replacewith
The 'replace with' menu, which comes up after 'search to replace'.
(The form 'replace2' is deprecated.)
@item gotoline
The 'goto line (and column)' menu.
@@ -1472,18 +1510,21 @@ Disable use of the spell checker. This also eliminates the @code{-s}
command-line option, which allows specifying an alternate spell checker.
@item --disable-tabcomp
Disable the tab completion code when reading or writing files.
Disable tab completion (when nano asks for a filename or a search string).
@item --disable-wordcomp
Disable word completion.
@item --disable-wrapping
Disable hard-wrapping of overlong lines. This also eliminates the @code{-w}
command-line option, which enables long-line wrapping.
Disable all hard-wrapping of overlong lines. This also eliminates the
@code{-w} command-line option, which switches long-line wrapping off.
@item --enable-tiny
This option disables all the above. It also disables some of the larger
internals of the editor, like the marking code and the cut-to-end-of-line
code. It also disables the function toggles. By using the enabling
This option implies all of the above. It also disables some other
internals of the editor, like the marking code, the cut-to-end-of-line
code, and the function toggles. By using the enabling
counterpart of the above options together with @code{--enable-tiny},
specific features can be switched back on.
specific features can be switched back on --- but a few cannot.
@item --enable-debug
Enable support for runtime debug output. This can get pretty messy, so

View File

@@ -17,11 +17,12 @@
.\" Documentation License along with this program. If not, see
.\" <http://www.gnu.org/licenses/>.
.\"
.TH NANORC 5 "version 2.7.0" "September 2016"
.TH NANORC 5 "version 2.7.4" "January 2017"
.\" Please adjust this date whenever revising the manpage.
.\"
.SH NAME
nanorc \- GNU nano's rcfile
nanorc \- GNU nano's configuration file
.SH DESCRIPTION
The \fInanorc\fP file contains the default settings for \fBnano\fP, a
small and friendly editor. The file should be in Unix format, not in
@@ -116,6 +117,9 @@ Specify the color combination to use for the shortcut key combos
in the two help lines at the bottom of the screen.
See \fBset titlecolor\fR for more details.
.TP
.B set linenumbers
Display line numbers to the left of the text area.
.TP
.B set locking
Enable vim-style lock-files for when editing files.
.TP
@@ -150,6 +154,10 @@ Don't automatically add a newline to the ends of files.
.B set nowrap
Don't hard-wrap text at all.
.TP
.B set numbercolor \fIfgcolor\fR,\fIbgcolor\fR
Specify the color combination to use for line numbers.
See \fBset titlecolor\fR for more details.
.TP
.B set operatingdir "\fIdirectory\fP"
\fBnano\fP will only read and write files inside \fIdirectory\fP and its
subdirectories. Also, the current directory is changed to here, so
@@ -200,6 +208,10 @@ won't work properly with this option enabled.
.B set regexp
Do extended regular expression searches by default.
.TP
.B set showcursor
Put the cursor on the highlighted item in the file browser, to aid
braille users.
.TP
.B set smarthome
Make the Home key smarter. When Home is pressed anywhere but at the
very beginning of non-whitespace characters on a line, the cursor will
@@ -236,8 +248,9 @@ Save automatically on exit, don't prompt.
.TP
.B set titlecolor \fIfgcolor\fR,\fIbgcolor\fR
Specify the color combination to use for the titlebar.
Valid color names for foreground and background are:
.BR white , \ black , \ red , \ blue , \ green , \ yellow , \ magenta ", and " cyan .
Valid names for the foreground and background colors are:
.BR white ", " black ", " blue ", " green ", " red ", " cyan ", " yellow ", and " magenta .
The name of the foreground color may be prefixed with \fBbright\fR.
And either "\fIfgcolor\fR" or ",\fIbgcolor\fR" may be left out.
.TP
.B set unix
@@ -413,6 +426,7 @@ a string in the current list in the file browser.
.TP
.B searchagain
Repeats the last search command without prompting.
(The form 'research' is deprecated.)
.TP
.B findprevious
As \fBsearchagain\fR, but always in the backward direction.
@@ -447,6 +461,7 @@ Cuts all text from the cursor position till the end of the buffer.
.TP
.B curpos
Shows the current cursor position: the line, column, and character positions.
(The form 'cursorpos' is deprecated.)
.TP
.B wordcount
Counts the number of words, lines and characters in the current buffer.
@@ -474,6 +489,10 @@ Unindents (shifts to the left) the currently marked text.
Comments or uncomments the current line or marked lines, using the comment
style specified in the active syntax.
.TP
.B complete
Completes the fragment before the cursor to a full word found elsewhere
in the current buffer.
.TP
.B left
Goes left one position (in the editor or browser).
.TP
@@ -579,6 +598,7 @@ Toggles case sensitivity in searching (search/replace menus only).
.TP
.B regexp
Toggles whether searching/replacing is based on literal strings or regular expressions.
(The form 'regex' is deprecated.)
.TP
.B backwards
Toggles whether searching/replacing goes forward or backward.
@@ -591,6 +611,7 @@ Shows the next history entry in the prompt menus (e.g. search).
.TP
.B flipreplace
Toggles between searching for something and replacing something.
(The form 'dontreplace' is deprecated.)
.TP
.B flipexecute
Toggles between inserting a file and executing a command.
@@ -598,6 +619,7 @@ Toggles between inserting a file and executing a command.
.B flipnewbuffer
Toggles between inserting into the current buffer and into a new
empty buffer.
(The form 'newbuffer' is deprecated.)
.TP
.B dosformat
When writing a file, switches to writing a DOS format (CR/LF).
@@ -701,6 +723,7 @@ The 'search to replace' menu.
.TP
.B replacewith
The 'replace with' menu, which comes up after 'search to replace'.
(The form 'replace2' is deprecated.)
.TP
.B gotoline
The 'goto line (and column)' menu.
@@ -745,14 +768,11 @@ System-wide configuration file.
.TP
.B ~/.nanorc
Per-user configuration file.
.SH SEE ALSO
.TP
\fBnano\fP(1)
.PP
\fI/usr/share/doc/nano/examples/nanorc.sample\fP (or equivalent on your
system)
.BR nano (1)
.SH AUTHOR
Chris Allegretta <chrisa@asty.org>, et al (see \fIAUTHORS\fP and
Chris Allegretta and others (see the files \fIAUTHORS\fP and
\fITHANKS\fP for details). This manual page was originally written by
Jordi Mallach <jordi@gnu.org>, for the Debian system (but may be used by
others).
Jordi Mallach for the Debian system (but may be used by others).

67
doc/rnano.1 Normal file
View File

@@ -0,0 +1,67 @@
.\" Copyright (C) 2002, 2005, 2006, 2007, 2014 Free Software Foundation, Inc.
.\"
.\" This document is dual-licensed. You may distribute and/or modify it
.\" under the terms of either of the following licenses:
.\"
.\" * The GNU General Public License, as published by the Free Software
.\" Foundation, version 3 or (at your option) any later version. You
.\" should have received a copy of the GNU General Public License
.\" along with this program. If not, see
.\" <http://www.gnu.org/licenses/>.
.\"
.\" * The GNU Free Documentation License, as published by the Free
.\" Software Foundation, version 1.2 or (at your option) any later
.\" version, with no Invariant Sections, no Front-Cover Texts, and no
.\" Back-Cover Texts. You should have received a copy of the GNU Free
.\" Documentation License along with this program. If not, see
.\" <http://www.gnu.org/licenses/>.
.\"
.TH RNANO 1 "version 2.7.4" "January 2017"
.\" Please adjust this date whenever revising the manpage.
.SH NAME
rnano \- a restricted nano
.SH SYNOPSIS
.B rnano
.RI [ options "] [[+" line [, column "]]\ " file "]..."
.SH DESCRIPTION
\fBrnano\fR runs the \fBnano\fR editor in restricted mode. This allows
editing only the specified file or files, and doesn't allow the user
access to the filesystem nor to a command shell.
.PP
In restricted mode, \fBnano\fR will:
.IP \[bu] 2
not read any nanorc files;
.IP \[bu]
not allow suspending;
.IP \[bu]
not read nor write any file not specified on the command line;
.IP \[bu]
not allow saving a file under a different name;
.IP \[bu]
not allow appending or prepending to any file;
.IP \[bu]
not make backup files nor do spell checking.
.SH OPTIONS
.TP
.BR \-h ", " \-\-help
Show a summary of command-line options and exit.
.PP
See the \fBnano\fP(1) manpage for all available options.
.SH BUGS
Please report bugs via \fIhttps://savannah.gnu.org/bugs/?group=nano\fR.
.SH HOMEPAGE
https://nano-editor.org/
.SH SEE ALSO
.BR nano (1)
.SH AUTHOR
Chris Allegretta and others (see the files \fIAUTHORS\fR and \fITHANKS\fR
for details). This manual page was originally written by Thijs Kinkhorst
for the Debian system (but may be used by others).

View File

@@ -63,6 +63,9 @@
## Make the justify command kill whitespace at the end of lines.
# set justifytrim
## Display line numbers to the left of the text.
# set linenumbers
## Enable vim-style lock-files. This is just to let a vim user know you
## are editing a file [s]he is trying to edit and vice versa. There are
## no plans to implement vim-style undo state in these files.
@@ -138,6 +141,10 @@
## Do extended regular expression searches by default.
# set regexp
## Put the cursor on the highlighted item in the file browser;
## useful for people who use a braille display.
# set showcursor
## Make the Home key smarter. When Home is pressed anywhere but at the
## very beginning of non-whitespace characters on a line, the cursor
## will jump to that beginning (either forwards or backwards). If the
@@ -189,8 +196,9 @@
## Paint the interface elements of nano.
## This is an example; by default there are no colors.
## These are examples; by default there are no colors.
# set titlecolor brightwhite,blue
# set numbercolor cyan
# set statuscolor brightwhite,green
# set keycolor green
# set functioncolor yellow

View File

@@ -1,11 +0,0 @@
## Here is a short example for HTML.
syntax "html" "\.html?$"
magic "HTML document text"
comment "<!--|-->"
color cyan start="<" end=">"
color red "&[^;[:space:]]*;"
color green ""(\\.|[^"])*""
color yellow start="<!--" end="-->"

View File

@@ -1,29 +0,0 @@
## Here is an example for nanorc files.
syntax "nanorc" "\.?nanorc$"
comment "#"
# Possible errors and parameters
icolor brightred "^[[:space:]]*((un)?(bind|set)|include|syntax|header|comment|magic|linter|i?color|extendsyntax).*$"
# Keywords
icolor brightgreen "^[[:space:]]*(set|unset)[[:space:]]+(allow_insecure_backup|autoindent|backup|backwards|boldtext|casesensitive|const(antshow)?|cut|fill|historylog|justifytrim|locking|morespace|mouse|multibuffer|noconvert|nohelp|nonewlines|nowrap|pos(ition)?log|preserve|quickblank|quiet|rebinddelete|rebindkeypad|regexp|smarthome|smooth|softwrap|suspend|tabsize|tabstospaces|tempfile|unix|view|wordbounds)\>"
icolor yellow "^[[:space:]]*set[[:space:]]+(functioncolor|keycolor|statuscolor|titlecolor)[[:space:]]+(bright)?(white|black|red|blue|green|yellow|magenta|cyan)?(,(white|black|red|blue|green|yellow|magenta|cyan))?\>"
icolor brightgreen "^[[:space:]]*set[[:space:]]+(backupdir|brackets|functioncolor|keycolor|matchbrackets|operatingdir|punct|quotestr|speller|statuscolor|titlecolor|whitespace)[[:space:]]+"
icolor brightgreen "^[[:space:]]*bind[[:space:]]+((\^|M-)([[:alpha:]]|space|[]]|[0-9^_=+{}|;:'\",./<>\?-])|F([1-9]|1[0-6])|Ins|Del)[[:space:]]+[[:alpha:]]+[[:space:]]+(all|main|search|replace(2|with)?|gotoline|writeout|insert|ext(ernal)?cmd|help|spell|linter|browser|whereisfile|gotodir)([[:space:]]+#|[[:space:]]*$)"
icolor brightgreen "^[[:space:]]*unbind[[:space:]]+((\^|M-)([[:alpha:]]|space|[]]|[0-9^_=+{}|;:'\",./<>\?-])|F([1-9]|1[0-6])|Ins|Del)[[:space:]]+(all|main|search|replace(2|with)?|gotoline|writeout|insert|ext(ernal)?cmd|help|spell|linter|browser|whereisfile|gotodir)([[:space:]]+#|[[:space:]]*$)"
icolor brightgreen "^[[:space:]]*extendsyntax[[:space:]]+[[:alpha:]]+[[:space:]]+(i?color|header|magic|comment|linter|formatter)[[:space:]]+.*$"
icolor green "^[[:space:]]*((un)?(bind|set)|include|syntax|header|magic|comment|linter|formatter|extendsyntax)\>"
# Colors
icolor yellow "^[[:space:]]*i?color[[:space:]]*(bright)?(white|black|red|blue|green|yellow|magenta|cyan)?(,(white|black|red|blue|green|yellow|magenta|cyan))?\>"
icolor magenta "^[[:space:]]*i?color\>" "\<(start|end)="
# Strings
icolor brightmagenta ""(\\.|[^"])*""
# Comments
icolor brightblue "(^|[[:space:]]+)#.*$"
icolor cyan "^[[:space:]]*##.*$"
# Trailing whitespace
color ,green "[[:space:]]+$"

View File

@@ -1,3 +0,0 @@
texinfo.tex
nano.html
nano.info

View File

@@ -1,10 +0,0 @@
info_TEXINFOS = nano.texi
MAKEINFO = makeinfo --no-split
BUILT_SOURCES = nano.html
nano.html: nano.texi
makeinfo --no-split --html < $< > $@
EXTRA_DIST = $(info_TEXINFOS) $(BUILT_SOURCES)

View File

@@ -43,7 +43,7 @@ fi
%files
%defattr(-,root,root)
%doc AUTHORS COPYING ChangeLog INSTALL NEWS README THANKS TODO doc/faq.html doc/nanorc.sample
%doc AUTHORS COPYING ChangeLog INSTALL NEWS README THANKS TODO doc/faq.html doc/sample.nanorc
%{_bindir}/*
%{_docdir}/nano/*
%{_mandir}/man*/*

1068
po/bg.po

File diff suppressed because it is too large Load Diff

1114
po/ca.po

File diff suppressed because it is too large Load Diff

1299
po/cs.po

File diff suppressed because it is too large Load Diff

1333
po/da.po

File diff suppressed because it is too large Load Diff

1296
po/de.po

File diff suppressed because it is too large Load Diff

1104
po/eo.po

File diff suppressed because it is too large Load Diff

1128
po/es.po

File diff suppressed because it is too large Load Diff

1068
po/eu.po

File diff suppressed because it is too large Load Diff

1104
po/fi.po

File diff suppressed because it is too large Load Diff

1107
po/fr.po

File diff suppressed because it is too large Load Diff

1068
po/ga.po

File diff suppressed because it is too large Load Diff

1105
po/gl.po

File diff suppressed because it is too large Load Diff

1078
po/hr.po

File diff suppressed because it is too large Load Diff

1131
po/hu.po

File diff suppressed because it is too large Load Diff

1050
po/id.po

File diff suppressed because it is too large Load Diff

1145
po/it.po

File diff suppressed because it is too large Load Diff

1458
po/ja.po

File diff suppressed because it is too large Load Diff

1073
po/ms.po

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

1089
po/nb.po

File diff suppressed because it is too large Load Diff

1110
po/nl.po

File diff suppressed because it is too large Load Diff

1050
po/nn.po

File diff suppressed because it is too large Load Diff

1076
po/pl.po

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

1087
po/ro.po

File diff suppressed because it is too large Load Diff

1077
po/ru.po

File diff suppressed because it is too large Load Diff

1076
po/sl.po

File diff suppressed because it is too large Load Diff

1251
po/sr.po

File diff suppressed because it is too large Load Diff

1080
po/sv.po

File diff suppressed because it is too large Load Diff

1050
po/tr.po

File diff suppressed because it is too large Load Diff

1095
po/uk.po

File diff suppressed because it is too large Load Diff

View File

@@ -17,3 +17,10 @@ fi
echo "Regenerating POT file and remerging and recompiling PO files..."
make update-po
# Ensure that the PO files are newer than the POT.
touch *.po
# If needed, fix a problem in the Makefile template.
grep -q '^datarootdir' Makefile.in.in || \
sed -i 's/^\(datadir.*\)/datarootdir = @datarootdir@\n\1/' Makefile.in.in

1089
po/vi.po

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -1,5 +1,7 @@
AM_CPPFLAGS = -DLOCALEDIR=\"$(localedir)\" -DSYSCONFDIR=\"$(sysconfdir)\"
CLEANFILES = revision.h
if BUILDING_FROM_GIT
SOMETHING = "REVISION \"$(shell git describe --tags 2>/dev/null)\""
else

View File

@@ -59,7 +59,6 @@ char *do_browser(char *path)
/* Don't show a cursor in the file list. */
curs_set(0);
blank_statusbar();
read_directory_contents:
/* We come here when we refresh or select a new directory. */
@@ -70,7 +69,7 @@ char *do_browser(char *path)
dir = opendir(path);
if (path == NULL || dir == NULL) {
statusline(ALERT, "Cannot open directory: %s", strerror(errno));
statusline(ALERT, _("Cannot open directory: %s"), strerror(errno));
/* If we don't have a file list yet, there is nothing to show. */
if (filelist == NULL) {
napms(1200);
@@ -148,7 +147,7 @@ char *do_browser(char *path)
/* If we selected the same filename as last time, fake a
* press of the Enter key so that the file is read in. */
if (old_selected == selected)
unget_kbinput(sc_seq_or(do_enter, 0), FALSE);
unget_kbinput(KEY_ENTER, FALSE);
}
continue;
@@ -220,28 +219,18 @@ char *do_browser(char *path)
selected = filelist_len - 1;
} else if (func == goto_dir_void) {
/* Ask for the directory to go to. */
int i = do_prompt(TRUE,
#ifndef DISABLE_TABCOMP
FALSE,
#endif
MGOTODIR, NULL,
int i = do_prompt(TRUE, FALSE, MGOTODIR, NULL,
#ifndef DISABLE_HISTORIES
NULL,
#endif
/* TRANSLATORS: This is a prompt. */
browser_refresh, _("Go To Directory"));
/* If the directory begins with a newline (i.e. an
* encoded null), treat it as though it's blank. */
if (i < 0 || *answer == '\n') {
if (i < 0) {
statusbar(_("Cancelled"));
continue;
}
/* Convert newlines to nulls in the directory name. */
sunder(answer);
align(&answer);
path = free_and_assign(path, real_dir_from_tilde(answer));
/* If the given path is relative, join it with the current path. */
@@ -355,8 +344,6 @@ char *do_browse_from(const char *inpath)
char *path;
/* This holds the tilde-expanded version of inpath. */
assert(inpath != NULL);
path = real_dir_from_tilde(inpath);
/* Perhaps path is a directory. If so, we'll pass it to
@@ -376,12 +363,11 @@ char *do_browse_from(const char *inpath)
if (path == NULL) {
free(currentdir);
statusline(MILD, "The working directory has disappeared");
statusline(MILD, _("The working directory has disappeared"));
beep();
napms(1200);
return NULL;
} else
align(&path);
}
}
}
@@ -503,6 +489,8 @@ void browser_refresh(void)
size_t i;
int line = 0, col = 0;
/* The current line and column while the list is getting displayed. */
int the_line = 0, the_column = 0;
/* The line and column of the selected item. */
char *info;
/* The additional information that we'll display about a file. */
@@ -522,28 +510,27 @@ void browser_refresh(void)
size_t infolen;
/* The length of the file information in columns. */
int infomaxlen = 7;
/* The maximum length of the file information in
* columns: seven for "--", "(dir)", or the file size,
* and 12 for "(parent dir)". */
/* The maximum length of the file information in columns:
* normally seven, but will be twelve for "(parent dir)". */
bool dots = (COLS >= 15 && namelen >= longest - infomaxlen);
/* Do we put an ellipsis before the filename? Don't set
* this to TRUE if we have fewer than 15 columns (i.e.
* one column for padding, plus seven columns for a
* filename other than ".."). */
char *disp = display_string(thename, dots ? namelen -
longest + infomaxlen + 4 : 0, longest, FALSE);
/* If we put an ellipsis before the filename, reserve
* one column for padding, plus seven columns for "--",
* "(dir)", or the file size, plus three columns for the
* ellipsis. */
/* Whether to put an ellipsis before the filename? We don't
* waste space on dots when there are fewer than 15 columns. */
char *disp = display_string(thename, dots ?
namelen + infomaxlen + 4 - longest : 0, longest, FALSE);
/* The filename (or a fragment of it) in displayable format.
* When a fragment, account for dots plus one space padding. */
/* Start highlighting the currently selected file or directory. */
if (i == selected)
/* If this is the selected item, start its highlighting, and
* remember its location to be able to place the cursor on it. */
if (i == selected) {
wattron(edit, hilite_attribute);
the_line = line;
the_column = col;
}
blank_line(edit, line, col, longest);
/* If dots is TRUE, we will display something like "...ename". */
/* If the name is too long, we display something like "...ename". */
if (dots)
mvwaddstr(edit, line, col, "...");
mvwaddstr(edit, line, dots ? col + 3 : col, disp);
@@ -552,21 +539,16 @@ void browser_refresh(void)
col += longest;
/* Show information about the file. We don't want to report
* file sizes for links, so we use lstat(). */
/* Show information about the file: "--" for symlinks (except when
* they point to a directory) and for files that have disappeared,
* "(dir)" for directories, and the file size for normal files. */
if (lstat(filelist[i], &st) == -1 || S_ISLNK(st.st_mode)) {
/* If the file doesn't exist (i.e. it's been deleted while
* the file browser is open), or it's a symlink that doesn't
* point to a directory, display "--". */
if (stat(filelist[i], &st) == -1 || !S_ISDIR(st.st_mode))
info = mallocstrcpy(NULL, "--");
/* If the file is a symlink that points to a directory,
* display it as a directory. */
else
/* TRANSLATORS: Try to keep this at most 7 characters. */
info = mallocstrcpy(NULL, _("(dir)"));
} else if (S_ISDIR(st.st_mode)) {
/* If the file is a directory, display it as such. */
if (strcmp(thename, "..") == 0) {
/* TRANSLATORS: Try to keep this at most 12 characters. */
info = mallocstrcpy(NULL, _("(parent dir)"));
@@ -579,6 +561,7 @@ void browser_refresh(void)
info = charalloc(infomaxlen + 1);
/* Massage the file size into a human-readable form. */
if (st.st_size < (1 << 10))
modifier = ' '; /* bytes */
else if (st.st_size < (1 << 20)) {
@@ -592,8 +575,7 @@ void browser_refresh(void)
modifier = 'G'; /* gigabytes */
}
/* Show the size if less than a terabyte,
* otherwise show "(huge)". */
/* Show the size if less than a terabyte, else show "(huge)". */
if (result < (1 << 10))
sprintf(info, "%4ju %cB", (intmax_t)result, modifier);
else
@@ -611,7 +593,7 @@ void browser_refresh(void)
mvwaddstr(edit, line, col - infolen, info);
/* Finish highlighting the currently selected file or directory. */
/* If this is the selected item, finish its highlighting. */
if (i == selected)
wattroff(edit, hilite_attribute);
@@ -626,8 +608,12 @@ void browser_refresh(void)
line++;
col = 0;
}
}
wmove(edit, line, col);
/* If requested, put the cursor on the selected item and switch it on. */
if (ISSET(SHOW_CURSOR)) {
wmove(edit, the_line, the_column);
curs_set(1);
}
wnoutrefresh(edit);
@@ -678,11 +664,7 @@ int filesearch_init(void)
buf = mallocstrcpy(NULL, "");
/* This is now one simple call. It just does a lot. */
input = do_prompt(FALSE,
#ifndef DISABLE_TABCOMP
TRUE,
#endif
MWHEREISFILE, NULL,
input = do_prompt(FALSE, FALSE, MWHEREISFILE, NULL,
#ifndef DISABLE_HISTORIES
&search_history,
#endif
@@ -715,7 +697,7 @@ void findnextfile(const char *needle)
/* Save the settings of all flags. */
memcpy(stash, flags, sizeof(flags));
/* Search forward, case insensitive and without regexes. */
/* Search forward, case insensitive, and without regexes. */
UNSET(BACKWARDS_SEARCH);
UNSET(CASE_SENSITIVE);
UNSET(USE_REGEXP);
@@ -806,8 +788,6 @@ char *striponedir(const char *path)
{
char *retval, *tmp;
assert(path != NULL);
retval = mallocstrcpy(NULL, path);
tmp = strrchr(retval, '/');

View File

@@ -88,11 +88,6 @@ void mbtowc_reset(void)
IGNORE_CALL_RESULT(mbtowc(NULL, NULL, 0));
}
void wctomb_reset(void)
{
IGNORE_CALL_RESULT(wctomb(NULL, 0));
}
/* This function is equivalent to isalpha() for multibyte characters. */
bool is_alpha_mbchar(const char *c)
{
@@ -172,8 +167,6 @@ bool is_cntrl_char(int c)
* their high bits set. */
bool is_cntrl_mbchar(const char *c)
{
assert(c != NULL);
#ifdef ENABLE_UTF8
if (use_utf8) {
return ((c[0] & 0xE0) == 0 || c[0] == 127 ||
@@ -208,8 +201,6 @@ bool is_punct_mbchar(const char *c)
* punctuation when allow_punct is TRUE), and FALSE otherwise. */
bool is_word_mbchar(const char *c, bool allow_punct)
{
assert(c != NULL);
if (*c == '\0')
return FALSE;
@@ -217,15 +208,11 @@ bool is_word_mbchar(const char *c, bool allow_punct)
return TRUE;
if (word_chars != NULL && *word_chars != '\0') {
bool wordforming;
char *symbol = charalloc(MB_CUR_MAX + 1);
char symbol[mb_cur_max() + 1];
int symlen = parse_mbchar(c, symbol, NULL);
symbol[symlen] = '\0';
wordforming = (strstr(word_chars, symbol) != NULL);
free(symbol);
return wordforming;
return (strstr(word_chars, symbol) != NULL);
}
return (allow_punct && is_punct_mbchar(c));
@@ -234,12 +221,7 @@ bool is_word_mbchar(const char *c, bool allow_punct)
/* Return the visible representation of control character c. */
char control_rep(const signed char c)
{
assert(is_cntrl_char(c));
/* An embedded newline is an encoded null. */
if (c == '\n')
return '@';
else if (c == DEL_CODE)
if (c == DEL_CODE)
return '?';
else if (c == -97)
return '=';
@@ -250,9 +232,11 @@ char control_rep(const signed char c)
}
/* Return the visible representation of multibyte control character c. */
char control_mbrep(const char *c)
char control_mbrep(const char *c, bool isdata)
{
assert(c != NULL);
/* An embedded newline is an encoded NUL if it is data. */
if (*c == '\n' && (isdata || as_an_at))
return '@';
#ifdef ENABLE_UTF8
if (use_utf8) {
@@ -325,27 +309,25 @@ int mbwidth(const char *c)
return 1;
}
/* Return the maximum width in bytes of a multibyte character. */
/* Return the maximum length (in bytes) of a character. */
int mb_cur_max(void)
{
return
#ifdef ENABLE_UTF8
use_utf8 ? MB_CUR_MAX :
if (use_utf8)
return MB_CUR_MAX;
else
#endif
1;
return 1;
}
/* Convert the Unicode value in chr to a multibyte character with the
* same wide character value as chr, if possible. If the conversion
* succeeds, return the (dynamically allocated) multibyte character and
* its length. Otherwise, return an undefined (dynamically allocated)
* multibyte character and a length of zero. */
/* Convert the Unicode value in chr to a multibyte character, if possible.
* If the conversion succeeds, return the (dynamically allocated) multibyte
* character and its length. Otherwise, return an undefined (dynamically
* allocated) multibyte character and a length of zero. */
char *make_mbchar(long chr, int *chr_mb_len)
{
char *chr_mb;
assert(chr_mb_len != NULL);
#ifdef ENABLE_UTF8
if (use_utf8) {
chr_mb = charalloc(MB_CUR_MAX);
@@ -353,7 +335,7 @@ char *make_mbchar(long chr, int *chr_mb_len)
/* Reject invalid Unicode characters. */
if (*chr_mb_len < 0 || !is_valid_unicode((wchar_t)chr)) {
wctomb_reset();
IGNORE_CALL_RESULT(wctomb(NULL, 0));
*chr_mb_len = 0;
}
} else
@@ -368,37 +350,35 @@ char *make_mbchar(long chr, int *chr_mb_len)
/* Parse a multibyte character from buf. Return the number of bytes
* used. If chr isn't NULL, store the multibyte character in it. If
* col isn't NULL, store the new display width in it. If *buf is '\t',
* we expect col to have the current display width. */
* col isn't NULL, add the character's width (in columns) to it. */
int parse_mbchar(const char *buf, char *chr, size_t *col)
{
int buf_mb_len;
int length;
assert(buf != NULL);
#ifdef ENABLE_UTF8
if (use_utf8) {
/* Get the number of bytes in the multibyte character. */
buf_mb_len = mblen(buf, MB_CUR_MAX);
length = mblen(buf, MB_CUR_MAX);
/* When the multibyte sequence is invalid, only take the first byte. */
if (buf_mb_len < 0) {
if (length <= 0) {
IGNORE_CALL_RESULT(mblen(NULL, 0));
buf_mb_len = 1;
} else if (buf_mb_len == 0)
buf_mb_len++;
length = 1;
}
/* When requested, store the multibyte character in chr. */
if (chr != NULL) {
int i;
for (i = 0; i < buf_mb_len; i++)
for (i = 0; i < length; i++)
chr[i] = buf[i];
}
/* When requested, store the width of the wide character in col. */
/* When requested, add the width of the character to col. */
if (col != NULL) {
/* If we have a tab, get its width in columns using the
/* If we have a tab, compute its width in columns based on the
* current value of col. */
if (*buf == '\t')
*col += tabsize - *col % tabsize;
@@ -406,8 +386,7 @@ int parse_mbchar(const char *buf, char *chr, size_t *col)
* column for the "^", and one for the visible character. */
else if (is_cntrl_mbchar(buf)) {
*col += 2;
/* If we have a normal character, get its width in columns
* normally. */
/* If we have a normal character, get its width normally. */
} else
*col += mbwidth(buf);
}
@@ -415,15 +394,15 @@ int parse_mbchar(const char *buf, char *chr, size_t *col)
#endif
{
/* A byte character is one byte long. */
buf_mb_len = 1;
length = 1;
/* When requested, store the byte character in chr. */
if (chr != NULL)
*chr = *buf;
/* When requested, store the width of the wide character in col. */
/* When requested, add the width of the character to col. */
if (col != NULL) {
/* If we have a tab, get its width in columns using the
/* If we have a tab, compute its width in columns using the
* current value of col. */
if (*buf == '\t')
*col += tabsize - *col % tabsize;
@@ -437,7 +416,7 @@ int parse_mbchar(const char *buf, char *chr, size_t *col)
}
}
return buf_mb_len;
return length;
}
/* Return the index in buf of the beginning of the multibyte character
@@ -492,8 +471,6 @@ int nstrncasecmp(const char *s1, const char *s2, size_t n)
if (s1 == s2)
return 0;
assert(s1 != NULL && s2 != NULL);
for (; *s1 != '\0' && *s2 != '\0' && n > 0; s1++, s2++, n--) {
if (tolower(*s1) != tolower(*s2))
break;
@@ -510,8 +487,6 @@ int mbstrncasecmp(const char *s1, const char *s2, size_t n)
if (use_utf8) {
wchar_t wc1, wc2;
assert(s1 != NULL && s2 != NULL);
while (*s1 != '\0' && *s2 != '\0' && n > 0) {
bool bad1 = FALSE, bad2 = FALSE;
@@ -555,8 +530,6 @@ char *nstrcasestr(const char *haystack, const char *needle)
{
size_t needle_len;
assert(haystack != NULL && needle != NULL);
if (*needle == '\0')
return (char *)haystack;
@@ -580,8 +553,6 @@ char *mbstrcasestr(const char *haystack, const char *needle)
if (use_utf8) {
size_t needle_len;
assert(haystack != NULL && needle != NULL);
if (*needle == '\0')
return (char *)haystack;
@@ -600,37 +571,32 @@ char *mbstrcasestr(const char *haystack, const char *needle)
return (char *) strcasestr(haystack, needle);
}
#if !defined(NANO_TINY) || !defined(DISABLE_TABCOMP)
/* This function is equivalent to strstr(), except in that it scans the
* string in reverse, starting at rev_start. */
char *revstrstr(const char *haystack, const char *needle, const char
*rev_start)
char *revstrstr(const char *haystack, const char *needle,
const char *pointer)
{
size_t rev_start_len, needle_len;
size_t needle_len = strlen(needle);
size_t tail_len = strlen(pointer);
assert(haystack != NULL && needle != NULL && rev_start != NULL);
if (*needle == '\0')
return (char *)rev_start;
needle_len = strlen(needle);
if (needle_len == 0)
return (char *)pointer;
if (strlen(haystack) < needle_len)
return NULL;
rev_start_len = strlen(rev_start);
if (tail_len < needle_len)
pointer += tail_len - needle_len;
for (; rev_start >= haystack; rev_start--, rev_start_len++) {
if (rev_start_len >= needle_len && strncmp(rev_start, needle,
needle_len) == 0)
return (char *)rev_start;
while (pointer >= haystack) {
if (strncmp(pointer, needle, needle_len) == 0)
return (char *)pointer;
pointer--;
}
return NULL;
}
#endif /* !NANO_TINY || !DISABLE_TABCOMP */
#ifndef NANO_TINY
/* This function is equivalent to strcasestr(), except in that it scans
* the string in reverse, starting at rev_start. */
char *revstrcasestr(const char *haystack, const char *needle, const char
@@ -638,8 +604,6 @@ char *revstrcasestr(const char *haystack, const char *needle, const char
{
size_t rev_start_len, needle_len;
assert(haystack != NULL && needle != NULL && rev_start != NULL);
if (*needle == '\0')
return (char *)rev_start;
@@ -668,8 +632,6 @@ char *mbrevstrcasestr(const char *haystack, const char *needle, const
if (use_utf8) {
size_t rev_start_len, needle_len;
assert(haystack != NULL && needle != NULL && rev_start != NULL);
if (*needle == '\0')
return (char *)rev_start;
@@ -696,7 +658,6 @@ char *mbrevstrcasestr(const char *haystack, const char *needle, const
#endif
return revstrcasestr(haystack, needle, rev_start);
}
#endif /* !NANO_TINY */
/* This function is equivalent to strlen() for multibyte strings. */
size_t mbstrlen(const char *s)
@@ -710,8 +671,6 @@ size_t nstrnlen(const char *s, size_t maxlen)
{
size_t n = 0;
assert(s != NULL);
for (; *s != '\0' && maxlen > 0; s++, maxlen--, n++)
;
@@ -722,8 +681,6 @@ size_t nstrnlen(const char *s, size_t maxlen)
/* This function is equivalent to strnlen() for multibyte strings. */
size_t mbstrnlen(const char *s, size_t maxlen)
{
assert(s != NULL);
#ifdef ENABLE_UTF8
if (use_utf8) {
size_t n = 0;
@@ -747,7 +704,7 @@ char *mbstrchr(const char *s, const char *c)
#ifdef ENABLE_UTF8
if (use_utf8) {
bool bad_s_mb = FALSE, bad_c_mb = FALSE;
char *s_mb = charalloc(MB_CUR_MAX);
char symbol[MB_CUR_MAX];
const char *q = s;
wchar_t ws, wc;
@@ -758,9 +715,9 @@ char *mbstrchr(const char *s, const char *c)
}
while (*s != '\0') {
int s_mb_len = parse_mbchar(s, s_mb, NULL);
int sym_len = parse_mbchar(s, symbol, NULL);
if (mbtowc(&ws, s_mb, s_mb_len) < 0) {
if (mbtowc(&ws, symbol, sym_len) < 0) {
mbtowc_reset();
ws = (unsigned char)*s;
bad_s_mb = TRUE;
@@ -769,12 +726,10 @@ char *mbstrchr(const char *s, const char *c)
if (bad_s_mb == bad_c_mb && ws == wc)
break;
s += s_mb_len;
q += s_mb_len;
s += sym_len;
q += sym_len;
}
free(s_mb);
if (*s == '\0')
q = NULL;
@@ -789,8 +744,6 @@ char *mbstrchr(const char *s, const char *c)
/* This function is equivalent to strpbrk() for multibyte strings. */
char *mbstrpbrk(const char *s, const char *accept)
{
assert(s != NULL && accept != NULL);
#ifdef ENABLE_UTF8
if (use_utf8) {
for (; *s != '\0'; s += move_mbright(s, 0)) {
@@ -861,8 +814,6 @@ char *mbrevstrpbrk(const char *s, const char *accept, const char
* and FALSE otherwise. */
bool has_blank_chars(const char *s)
{
assert(s != NULL);
for (; *s != '\0'; s++) {
if (isblank(*s))
return TRUE;
@@ -875,25 +826,18 @@ bool has_blank_chars(const char *s)
* multibyte characters, and FALSE otherwise. */
bool has_blank_mbchars(const char *s)
{
assert(s != NULL);
#ifdef ENABLE_UTF8
if (use_utf8) {
bool retval = FALSE;
char *chr_mb = charalloc(MB_CUR_MAX);
char symbol[MB_CUR_MAX];
for (; *s != '\0'; s += move_mbright(s, 0)) {
parse_mbchar(s, chr_mb, NULL);
parse_mbchar(s, symbol, NULL);
if (is_blank_mbchar(chr_mb)) {
retval = TRUE;
break;
}
if (is_blank_mbchar(symbol))
return TRUE;
}
free(chr_mb);
return retval;
return FALSE;
} else
#endif
return has_blank_chars(s);
@@ -916,12 +860,11 @@ bool is_valid_unicode(wchar_t wc)
* is, and FALSE otherwise. */
bool is_valid_mbstring(const char *s)
{
assert(s != NULL);
return
#ifdef ENABLE_UTF8
use_utf8 ? (mbstowcs(NULL, s, 0) != (size_t)-1) :
if (use_utf8)
return (mbstowcs(NULL, s, 0) != (size_t)-1);
else
#endif
TRUE;
return TRUE;
}
#endif /* !DISABLE_NANORC */

View File

@@ -108,8 +108,6 @@ void color_init(void)
bool using_defaults = FALSE;
short foreground, background;
assert(openfile != NULL);
/* If the terminal is not capable of colors, forget it. */
if (!has_colors())
return;
@@ -164,8 +162,6 @@ void color_update(void)
syntaxtype *sint = NULL;
colortype *ink;
assert(openfile != NULL);
/* If the rcfiles were not read, or contained no syntaxes, get out. */
if (syntaxes == NULL)
return;

View File

@@ -60,13 +60,13 @@ void cut_line(void)
#ifndef NANO_TINY
/* Move all currently marked text into the cutbuffer, and set the
* current place we want to where the text used to start. */
void cut_marked(void)
void cut_marked(bool *right_side_up)
{
filestruct *top, *bot;
size_t top_x, bot_x;
mark_order((const filestruct **)&top, &top_x,
(const filestruct **)&bot, &bot_x, NULL);
(const filestruct **)&bot, &bot_x, right_side_up);
move_to_filestruct(&cutbuffer, &cutbottom, top, top_x, bot, bot_x);
openfile->placewewant = xplustabs();
@@ -82,8 +82,6 @@ void cut_to_eol(void)
{
size_t data_len = strlen(openfile->current->data);
assert(openfile->current_x <= data_len);
if (openfile->current_x < data_len)
/* If we're not at the end of the line, move all the text from
* the current position up to it, not counting the newline at
@@ -115,13 +113,7 @@ void cut_to_eof(void)
* copy_text is TRUE, copy the text back into the filestruct afterward.
* If cut_till_eof is TRUE, move all text from the current cursor
* position to the end of the file into the cutbuffer. */
void do_cut_text(
#ifndef NANO_TINY
bool copy_text, bool cut_till_eof
#else
void
#endif
)
void do_cut_text(bool copy_text, bool cut_till_eof)
{
#ifndef NANO_TINY
filestruct *cb_save = NULL;
@@ -130,45 +122,39 @@ void do_cut_text(
/* The length of the string at the current end of the cutbuffer,
* before we add text to it. */
bool old_no_newlines = ISSET(NO_NEWLINES);
bool right_side_up = TRUE;
/* There *is* no region, *or* it is marked forward. */
#endif
size_t was_totsize = openfile->totsize;
assert(openfile->current != NULL && openfile->current->data != NULL);
/* Empty the cutbuffer when a chain of cuts is broken. */
/* If a chain of cuts was broken, empty the cutbuffer. */
if (!keep_cutbuffer) {
free_filestruct(cutbuffer);
cutbuffer = NULL;
#ifdef DEBUG
fprintf(stderr, "Blew away cutbuffer =)\n");
#endif
/* Indicate that future cuts should add to the cutbuffer. */
keep_cutbuffer = TRUE;
}
#ifndef NANO_TINY
if (copy_text) {
/* If the cutbuffer isn't empty, remember where it currently ends. */
if (cutbuffer != NULL) {
/* If the cutbuffer isn't empty, save where it currently
* ends. This is where we'll add the new text. */
cb_save = cutbottom;
cb_save_len = strlen(cutbottom->data);
}
/* Set NO_NEWLINES to TRUE, so that we don't disturb the last
* line of the file when moving text to the cutbuffer. */
/* Don't add a magicline when moving text to the cutbuffer. */
SET(NO_NEWLINES);
}
#endif
/* Ensure that the text we're going to move into the cutbuffer will
* be added to the text already there, instead of replacing it. */
keep_cutbuffer = TRUE;
#ifndef NANO_TINY
if (cut_till_eof) {
/* Move all text up to the end of the file into the cutbuffer. */
cut_to_eof();
} else if (openfile->mark_set) {
/* Move the marked text to the cutbuffer, and turn the mark off. */
cut_marked();
cut_marked(&right_side_up);
openfile->mark_set = FALSE;
} else if (ISSET(CUT_TO_END))
/* Move all text up to the end of the line into the cutbuffer. */
@@ -180,10 +166,9 @@ void do_cut_text(
#ifndef NANO_TINY
if (copy_text) {
/* Copy the text in the cutbuffer, starting at its saved end if
* there is one, back into the filestruct. This effectively
* uncuts the text we just cut without marking the file as
* modified. */
/* Copy the text that is in the cutbuffer (starting at its saved end,
* if there is one) back into the current buffer. This effectively
* uncuts the text we just cut. */
if (cutbuffer != NULL) {
if (cb_save != NULL) {
cb_save->data += cb_save_len;
@@ -192,17 +177,18 @@ void do_cut_text(
} else
copy_from_filestruct(cutbuffer);
/* Set the current place we want to where the text from the
* cutbuffer ends. */
openfile->placewewant = xplustabs();
/* If the copied region was marked forward, put the new desired
* x position at its end; otherwise, leave it at its beginning. */
if (right_side_up)
openfile->placewewant = xplustabs();
}
/* Set NO_NEWLINES back to what it was before, since we're done
* disturbing the text. */
/* Restore the magicline behavior now that we're done fiddling. */
if (!old_no_newlines)
UNSET(NO_NEWLINES);
} else
#endif /* !NANO_TINY */
/* Only set the modification flag if actually something was cut. */
if (openfile->totsize != was_totsize)
set_modified();
refresh_needed = TRUE;
@@ -221,10 +207,10 @@ void do_cut_text_void(void)
{
#ifndef NANO_TINY
add_undo(CUT);
#endif
do_cut_text(FALSE, FALSE);
#ifndef NANO_TINY
update_undo(CUT);
#else
do_cut_text();
#endif
}
@@ -270,11 +256,9 @@ void do_cut_till_eof(void)
/* Copy text from the cutbuffer into the current filestruct. */
void do_uncut_text(void)
{
int was_lineno = openfile->current->lineno;
ssize_t was_lineno = openfile->current->lineno;
assert(openfile->current != NULL && openfile->current->data != NULL);
/* If the cutbuffer is empty, get out. */
/* If the cutbuffer is empty, there is nothing to do. */
if (cutbuffer == NULL)
return;
@@ -293,13 +277,17 @@ void do_uncut_text(void)
if (openfile->current->lineno - was_lineno < editwinrows)
focusing = FALSE;
/* Set the current place we want to where the text from the
* cutbuffer ends. */
/* Set the desired x position to where the pasted text ends. */
openfile->placewewant = xplustabs();
/* Mark the file as modified. */
set_modified();
/* Update the cursor position to account for the inserted lines. */
reset_cursor();
ensure_line_is_visible();
refresh_needed = TRUE;
#ifndef DISABLE_COLOR

View File

@@ -148,8 +148,9 @@ void set_modified(void)
if (openfile->lock_filename == NULL) {
/* TRANSLATORS: Keep the next ten messages at most 76 characters. */
statusline(ALERT, _("Warning: Modifying a file which is not locked,"
" check directory permission?"));
// statusline(ALERT, _("Warning: Modifying a file which is not locked,"
// " check directory permission?"));
;
} else {
char *fullname = get_full_path(openfile->filename);
write_lockfile(openfile->lock_filename, fullname, TRUE);
@@ -179,8 +180,8 @@ int write_lockfile(const char *lockfilename, const char *origfilename, bool modi
struct stat fileinfo;
char *lockdata = charalloc(1024);
char myhostname[32];
ssize_t lockdatalen = 1024;
ssize_t wroteamt;
size_t lockdatalen = 1024;
size_t wroteamt;
mypid = getpid();
myuid = geteuid();
@@ -264,7 +265,7 @@ int write_lockfile(const char *lockfilename, const char *origfilename, bool modi
wroteamt = fwrite(lockdata, sizeof(char), lockdatalen, filestream);
if (wroteamt < lockdatalen) {
statusline(MILD, _("Error writing lock file %s: %s"),
lockfilename, ferror(filestream));
lockfilename, ferror(filestream));
goto free_the_data;
}
@@ -274,7 +275,7 @@ int write_lockfile(const char *lockfilename, const char *origfilename, bool modi
if (fclose(filestream) == EOF) {
statusline(MILD, _("Error writing lock file %s: %s"),
lockfilename, strerror(errno));
lockfilename, strerror(errno));
goto free_the_data;
}
@@ -320,8 +321,8 @@ int do_lockfile(const char *filename)
fprintf(stderr, "lock file name is %s\n", lockfilename);
#endif
if (stat(lockfilename, &fileinfo) != -1) {
ssize_t readtot = 0;
ssize_t readamt = 0;
size_t readtot = 0;
size_t readamt = 0;
char *lockbuf, *question, *pidstring, *postedname, *promptstr;
int room, response;
@@ -422,12 +423,8 @@ void stat_with_alloc(const char *filename, struct stat **pstat)
* or into a new buffer when MULTIBUFFER is set or there is no buffer yet. */
bool open_buffer(const char *filename, bool undoable)
{
bool new_buffer = (openfile == NULL
#ifndef DISABLE_MULTIBUFFER
|| ISSET(MULTIBUFFER)
#endif
);
/* Whether we load into this buffer or a new one. */
bool new_buffer = (openfile == NULL || ISSET(MULTIBUFFER));
/* Whether we load into the current buffer or a new one. */
char *realname;
/* The filename after tilde expansion. */
FILE *f;
@@ -437,6 +434,9 @@ bool open_buffer(const char *filename, bool undoable)
assert(filename != NULL);
/* Display newlines in filenames as ^J. */
as_an_at = FALSE;
#ifndef DISABLE_OPERATINGDIR
if (check_operating_dir(filename, FALSE)) {
statusline(ALERT, _("Can't insert file from outside of %s"),
@@ -567,7 +567,7 @@ void display_buffer(void)
precalc_multicolorinfo();
#endif
/* Update the edit window. */
/* Update the content of the edit window straightaway. */
edit_refresh();
}
@@ -755,8 +755,6 @@ void read_file(FILE *f, int fd, const char *filename, bool undoable, bool checkw
/* 0 = *nix, 1 = DOS, 2 = Mac, 3 = both DOS and Mac. */
#endif
assert(openfile->fileage != NULL && openfile->current != NULL);
buf = charalloc(bufx);
#ifndef NANO_TINY
@@ -908,55 +906,49 @@ void read_file(FILE *f, int fd, const char *filename, bool undoable, bool checkw
openfile->current_x = 0;
}
/* Set the current place we want to the end of the last line of the
* file we inserted. */
/* Set the desired x position at the end of what was inserted. */
openfile->placewewant = xplustabs();
#ifndef NANO_TINY
if (undoable)
update_undo(INSERT);
if (!writable)
statusline(ALERT, "File '%s' is unwritable", filename);
statusline(ALERT, _("File '%s' is unwritable"), filename);
#ifndef NANO_TINY
else if (format == 3) {
statusline(HUSH,
/* TRANSLATORS: Keep the next four messages at most 76 characters. */
P_("Read %lu line (Converted from DOS and Mac format)",
"Read %lu lines (Converted from DOS and Mac format)",
(unsigned long)num_lines), (unsigned long)num_lines);
/* TRANSLATORS: Keep the next four messages at most 78 characters. */
statusline(HUSH, P_("Read %lu line (Converted from DOS and Mac format)",
"Read %lu lines (Converted from DOS and Mac format)",
(unsigned long)num_lines), (unsigned long)num_lines);
} else if (format == 2) {
openfile->fmt = MAC_FILE;
statusline(HUSH,
P_("Read %lu line (Converted from Mac format)",
"Read %lu lines (Converted from Mac format)",
(unsigned long)num_lines), (unsigned long)num_lines);
statusline(HUSH, P_("Read %lu line (Converted from Mac format)",
"Read %lu lines (Converted from Mac format)",
(unsigned long)num_lines), (unsigned long)num_lines);
} else if (format == 1) {
openfile->fmt = DOS_FILE;
statusline(HUSH,
P_("Read %lu line (Converted from DOS format)",
"Read %lu lines (Converted from DOS format)",
(unsigned long)num_lines), (unsigned long)num_lines);
} else
#endif /* !NANO_TINY */
statusline(HUSH, P_("Read %lu line", "Read %lu lines",
(unsigned long)num_lines), (unsigned long)num_lines);
statusline(HUSH, P_("Read %lu line (Converted from DOS format)",
"Read %lu lines (Converted from DOS format)",
(unsigned long)num_lines), (unsigned long)num_lines);
}
#endif
else
statusline(HUSH, P_("Read %lu line", "Read %lu lines",
(unsigned long)num_lines), (unsigned long)num_lines);
if (num_lines < editwinrows)
focusing = FALSE;
#ifndef NANO_TINY
if (undoable)
update_undo(INSERT);
if (ISSET(MAKE_IT_UNIX))
openfile->fmt = NIX_FILE;
#endif
}
/* Open the file (and decide if it exists). If newfie is TRUE, display
* "New File" if the file is missing. Otherwise, say "[filename] not
* found".
*
/* Open the file with the given name. If the file does not exist, display
* "New File" if newfie is TRUE, and say "File not found" otherwise.
* Return -2 if we say "New File", -1 if the file isn't opened, and the
* fd opened otherwise. The file might still have an error while reading
* with a 0 return value. *f is set to the opened file. */
* obtained fd otherwise. *f is set to the opened file. */
int open_file(const char *filename, bool newfie, bool quiet, FILE **f)
{
struct stat fileinfo, fileinfo2;
@@ -971,43 +963,39 @@ int open_file(const char *filename, bool newfie, bool quiet, FILE **f)
/* Okay, if we can't stat the path due to a component's
* permissions, just try the relative one. */
if (full_filename == NULL || (stat(full_filename, &fileinfo) == -1 &&
stat(filename, &fileinfo2) != -1))
stat(filename, &fileinfo2) != -1))
full_filename = mallocstrcpy(full_filename, filename);
if (stat(full_filename, &fileinfo) == -1) {
/* All cases below return. */
free(full_filename);
/* Well, maybe we can open the file even if the OS says it's
* not there. */
if ((fd = open(filename, O_RDONLY)) != -1) {
if (!quiet)
statusbar(_("Reading File"));
return fd;
}
if (newfie) {
if (!quiet)
statusbar(_("New File"));
free(full_filename);
return -2;
}
statusline(ALERT, _("File \"%s\" not found"), filename);
return -1;
} else if (S_ISDIR(fileinfo.st_mode) || S_ISCHR(fileinfo.st_mode) ||
S_ISBLK(fileinfo.st_mode)) {
free(full_filename);
/* Don't open directories, character files, or block files. */
statusline(ALERT, S_ISDIR(fileinfo.st_mode) ?
_("\"%s\" is a directory") :
_("\"%s\" is a device file"), filename);
return -1;
} else if ((fd = open(full_filename, O_RDONLY)) == -1) {
statusline(ALERT, _("File \"%s\" not found"), filename);
free(full_filename);
statusline(ALERT, _("Error reading %s: %s"), filename, strerror(errno));
return -1;
} else {
/* The file is A-OK. Open it. */
}
/* Don't open directories, character files, or block files. */
if (S_ISDIR(fileinfo.st_mode) || S_ISCHR(fileinfo.st_mode) ||
S_ISBLK(fileinfo.st_mode)) {
statusline(ALERT, S_ISDIR(fileinfo.st_mode) ?
_("\"%s\" is a directory") :
_("\"%s\" is a device file"), filename);
free(full_filename);
return -1;
}
/* Try opening the file. */
fd = open(full_filename, O_RDONLY);
if (fd == -1)
statusline(ALERT, _("Error reading %s: %s"), filename, strerror(errno));
else {
/* The file is A-OK. Associate a stream with it. */
*f = fdopen(fd, "rb");
if (*f == NULL) {
@@ -1061,30 +1049,21 @@ char *get_next_filename(const char *name, const char *suffix)
return buf;
}
/* Insert a file into a new buffer if the MULTIBUFFER flag is set, or
* into the current buffer if it isn't. If execute is TRUE, insert the
* output of an executed command instead of a file. */
void do_insertfile(
#ifndef NANO_TINY
bool execute
#else
void
#endif
)
/* Insert a file into the current buffer, or into a new buffer when
* the MULTIBUFFER flag is set. */
void do_insertfile(void)
{
int i;
const char *msg;
char *given = mallocstrcpy(NULL, "");
/* The last answer the user typed at the statusbar prompt. */
filestruct *edittop_save = openfile->edittop;
ssize_t was_current_lineno = openfile->current->lineno;
size_t was_current_x = openfile->current_x;
ssize_t was_current_y = openfile->current_y;
bool edittop_inside = FALSE;
#ifndef NANO_TINY
bool right_side_up = FALSE, single_line = FALSE;
bool execute = FALSE, right_side_up = FALSE, single_line = FALSE;
#endif
/* Display newlines in filenames as ^J. */
as_an_at = FALSE;
while (TRUE) {
#ifndef NANO_TINY
if (execute) {
@@ -1107,10 +1086,7 @@ void do_insertfile(
present_path = mallocstrcpy(present_path, "./");
i = do_prompt(TRUE,
#ifndef DISABLE_TABCOMP
TRUE,
#endif
i = do_prompt(TRUE, TRUE,
#ifndef NANO_TINY
execute ? MEXTCMD :
#endif
@@ -1126,18 +1102,15 @@ void do_insertfile(
"./");
/* If we're in multibuffer mode and the filename or command is
* blank, open a new buffer instead of canceling. If the
* filename or command begins with a newline (i.e. an encoded
* null), treat it as though it's blank. */
if (i == -1 || ((i == -2 || *answer == '\n')
#ifndef DISABLE_MULTIBUFFER
&& !ISSET(MULTIBUFFER)
#endif
)) {
* blank, open a new buffer instead of canceling. */
if (i == -1 || (i == -2 && !ISSET(MULTIBUFFER))) {
statusbar(_("Cancelled"));
break;
} else {
size_t pww_save = openfile->placewewant;
filestruct *edittop_save = openfile->edittop;
ssize_t was_current_lineno = openfile->current->lineno;
size_t was_current_x = openfile->current_x;
bool current_was_at_top = FALSE;
#if !defined(NANO_TINY) || !defined(DISABLE_BROWSER)
functionptrtype func = func_from_key(&i);
#endif
@@ -1146,7 +1119,7 @@ void do_insertfile(
#ifndef NANO_TINY
#ifndef DISABLE_MULTIBUFFER
if (func == new_buffer_void) {
/* Don't allow toggling if we're in view mode. */
/* Don't allow toggling when in view mode. */
if (!ISSET(VIEW_MODE))
TOGGLE(MULTIBUFFER);
else
@@ -1164,21 +1137,17 @@ void do_insertfile(
if (func == to_files_void) {
char *chosen = do_browse_from(answer);
/* If no file was chosen, go back to the prompt. */
if (chosen == NULL)
continue;
/* We have a file now. Indicate this. */
free(answer);
answer = chosen;
i = 0;
}
#endif
/* If we don't have a file yet, go back to the statusbar prompt. */
if (i != 0
#ifndef DISABLE_MULTIBUFFER
&& (i != -2 || !ISSET(MULTIBUFFER))
#endif
)
/* If we don't have a file yet, go back to the prompt. */
if (i != 0 && (!ISSET(MULTIBUFFER) || i != -2))
continue;
#ifndef NANO_TINY
@@ -1194,43 +1163,34 @@ void do_insertfile(
single_line = (top == bot);
}
#endif
#ifndef DISABLE_MULTIBUFFER
if (!ISSET(MULTIBUFFER))
#endif
{
/* If we're not inserting into a new buffer, partition
* the filestruct so that it contains no text and hence
* looks like a new buffer, and keep track of whether
* the top of the edit window is inside the partition. */
/* When not inserting into a new buffer, partition the filestruct
* so that it contains no text and hence looks like a new buffer,
* and remember whether the current line is the first on screen. */
if (!ISSET(MULTIBUFFER)) {
filepart = partition_filestruct(openfile->current,
openfile->current_x, openfile->current,
openfile->current_x);
edittop_inside = (openfile->edittop == openfile->fileage);
current_was_at_top = (openfile->edittop == openfile->fileage);
}
/* Convert newlines to nulls in the given filename. */
sunder(answer);
align(&answer);
#ifndef NANO_TINY
if (execute) {
#ifndef DISABLE_MULTIBUFFER
/* When in multibuffer mode, first open a blank buffer. */
if (ISSET(MULTIBUFFER))
/* Open a blank buffer. */
open_buffer("", FALSE);
#endif
/* Save the command's output in the current buffer. */
execute_command(answer);
#ifndef DISABLE_MULTIBUFFER
/* If this is a new buffer, put the cursor at the top. */
if (ISSET(MULTIBUFFER)) {
/* Move back to the beginning of the first line of
* the buffer. */
openfile->current = openfile->fileage;
openfile->current_x = 0;
openfile->placewewant = 0;
set_modified();
}
#endif
} else
@@ -1252,21 +1212,20 @@ void do_insertfile(
#ifndef NANO_TINY
if (!execute)
#endif
if (check_poshistory(answer, &priorline, &priorcol))
if (has_old_position(answer, &priorline, &priorcol))
do_gotolinecolumn(priorline, priorcol, FALSE, FALSE);
}
#endif /* !DISABLE_HISTORIES */
/* Update the screen to account for the current buffer. */
/* Update stuff to account for the current buffer. */
display_buffer();
} else
#endif /* !DISABLE_MULTIBUFFER */
{
filestruct *top_save = openfile->fileage;
/* If we were at the top of the edit window before, set
* the saved value of edittop to the new top of the edit
* window. */
if (edittop_inside)
/* If we were at the top of the edit window before, change the
* saved value of edittop to the start of inserted stuff. */
if (current_was_at_top)
edittop_save = openfile->fileage;
/* Update the current x-coordinate to account for the
@@ -1297,10 +1256,6 @@ void do_insertfile(
}
#endif
/* Update the current y-coordinate to account for the
* number of lines inserted. */
openfile->current_y += was_current_y;
/* Unpartition the filestruct so that it contains all
* the text again. Note that we've replaced the
* non-text originally in the partition with the text in
@@ -1314,16 +1269,20 @@ void do_insertfile(
/* Restore the old edittop. */
openfile->edittop = edittop_save;
/* Restore the old place we want. */
openfile->placewewant = pww_save;
/* Set the desired x position to the current one. */
openfile->placewewant = xplustabs();
/* Mark the file as modified if it changed. */
if (openfile->current->lineno != was_current_lineno ||
openfile->current_x != was_current_x)
set_modified();
/* Update the screen. */
edit_refresh();
/* Update the cursor position to account for inserted lines. */
reset_cursor();
ensure_line_is_visible();
refresh_needed = TRUE;
}
break;
@@ -1333,26 +1292,17 @@ void do_insertfile(
free(given);
}
/* Insert a file into a new buffer or the current buffer, depending on
* whether the MULTIBUFFER flag is set. If we're in view mode, only
* allow inserting a file into a new buffer. */
/* If the current mode of operation allows it, go insert a file. */
void do_insertfile_void(void)
{
if (ISSET(RESTRICTED)) {
if (ISSET(RESTRICTED))
show_restricted_warning();
return;
}
#ifndef DISABLE_MULTIBUFFER
if (ISSET(VIEW_MODE) && !ISSET(MULTIBUFFER))
else if (ISSET(VIEW_MODE) && !ISSET(MULTIBUFFER))
statusbar(_("Key invalid in non-multibuffer mode"));
#endif
else
#endif
do_insertfile(
#ifndef NANO_TINY
FALSE
#endif
);
do_insertfile();
}
/* When passed "[relative path]" or "[relative path][filename]" in
@@ -1387,8 +1337,6 @@ char *get_full_path(const char *origpath)
/* If we succeeded, canonicalize it in d_here. */
if (d_here != NULL) {
align(&d_here);
/* If the current directory isn't "/", tack a slash onto the end
* of it. */
if (strcmp(d_here, "/") != 0) {
@@ -1450,8 +1398,6 @@ char *get_full_path(const char *origpath)
/* If we succeeded, canonicalize it in d_there. */
if (d_there != NULL) {
align(&d_there);
/* If the current directory isn't "/", tack a slash onto
* the end of it. */
if (strcmp(d_there, "/") != 0) {
@@ -1574,6 +1520,8 @@ void init_operating_dir(void)
/* If the operating directory is inaccessible, fail. */
if (full_operating_dir == NULL || chdir(full_operating_dir) == -1)
die("Invalid operating directory\n");
snuggly_fit(&full_operating_dir);
}
/* Check to see if we're inside the operating directory. Return FALSE
@@ -1664,6 +1612,7 @@ void init_backup_dir(void)
} else {
free(backup_dir);
backup_dir = full_backup_dir;
snuggly_fit(&backup_dir);
}
}
#endif /* !NANO_TINY */
@@ -1741,8 +1690,6 @@ bool write_file(const char *name, FILE *f_open, bool tmp,
char *tempname = NULL;
/* The name of the temporary file we write to on prepend. */
assert(name != NULL);
if (*name == '\0')
return -1;
@@ -2035,10 +1982,6 @@ bool write_file(const char *name, FILE *f_open, bool tmp,
}
}
/* There might not be a magicline. There won't be when writing out
* a selection. */
assert(openfile->fileage != NULL && openfile->filebot != NULL);
while (fileptr != NULL) {
size_t data_len = strlen(fileptr->data), size;
@@ -2186,8 +2129,6 @@ bool write_marked_file(const char *name, FILE *f_open, bool tmp,
filestruct *top, *bot;
size_t top_x, bot_x;
assert(openfile->mark_set);
/* Partition the filestruct so that it contains only the marked text. */
mark_order((const filestruct **)&top, &top_x,
(const filestruct **)&bot, &bot_x, NULL);
@@ -2235,6 +2176,9 @@ int do_writeout(bool exiting)
static bool did_credits = FALSE;
#endif
/* Display newlines in filenames as ^J. */
as_an_at = FALSE;
if (exiting && ISSET(TEMP_FILE) && openfile->filename[0] != '\0') {
if (write_file(openfile->filename, NULL, FALSE, OVERWRITE, FALSE))
return 1;
@@ -2262,6 +2206,7 @@ int do_writeout(bool exiting)
* it allows reading from or writing to files not specified on
* the command line. */
if (openfile->mark_set && !exiting && !ISSET(RESTRICTED))
/* TRANSLATORS: The next six strings are prompts. */
msg = (method == PREPEND) ? _("Prepend Selection to File") :
(method == APPEND) ? _("Append Selection to File") :
_("Write Selection to File");
@@ -2275,12 +2220,8 @@ int do_writeout(bool exiting)
/* If we're using restricted mode, and the filename isn't blank,
* disable tab completion. */
i = do_prompt(!ISSET(RESTRICTED) ||
openfile->filename[0] == '\0',
#ifndef DISABLE_TABCOMP
TRUE,
#endif
MWRITEFILE, given,
i = do_prompt(!ISSET(RESTRICTED) || openfile->filename[0] == '\0',
TRUE, MWRITEFILE, given,
#ifndef DISABLE_HISTORIES
NULL,
#endif
@@ -2292,9 +2233,7 @@ int do_writeout(bool exiting)
#endif
);
/* If the filename or command begins with a newline (i.e. an
* encoded null), treat it as though it's blank. */
if (i < 0 || *answer == '\n') {
if (i < 0) {
statusbar(_("Cancelled"));
break;
} else {
@@ -2373,15 +2312,10 @@ int do_writeout(bool exiting)
#endif
if (method == OVERWRITE) {
size_t answer_len = strlen(answer);
bool name_exists, do_warning;
char *full_answer, *full_filename;
struct stat st;
/* Convert newlines to nulls, just before we get the
* full path. */
sunder(answer);
full_answer = get_full_path(answer);
full_filename = get_full_path(openfile->filename);
name_exists = (stat((full_answer == NULL) ?
@@ -2393,22 +2327,19 @@ int do_writeout(bool exiting)
answer : full_answer, (full_filename == NULL) ?
openfile->filename : full_filename) != 0);
/* Convert nulls to newlines. answer_len is the
* string's real length. */
unsunder(answer, answer_len);
free(full_filename);
free(full_answer);
if (do_warning) {
/* If we're using restricted mode, we aren't allowed
* to overwrite an existing file with the current
* file. We also aren't allowed to change the name
* of the current file if it has one, because that
* would allow reading from or writing to files not
* specified on the command line. */
if (ISSET(RESTRICTED))
/* When in restricted mode, we aren't allowed to overwrite
* an existing file with the current buffer, nor to change
* the name of the current file if it already has one. */
if (ISSET(RESTRICTED)) {
/* TRANSLATORS: Restricted mode forbids overwriting. */
warn_and_shortly_pause(_("File exists -- "
"cannot overwrite"));
continue;
}
if (!maychange) {
#ifndef NANO_TINY
@@ -2451,10 +2382,6 @@ int do_writeout(bool exiting)
#endif
}
/* Convert newlines to nulls, just before we save the file. */
sunder(answer);
align(&answer);
/* Here's where we allow the selected text to be written to
* a separate file. If we're using restricted mode, this
* function is disabled, since it allows reading from or
@@ -2500,8 +2427,6 @@ char *real_dir_from_tilde(const char *buf)
{
char *retval;
assert(buf != NULL);
if (*buf == '~') {
size_t i = 1;
char *tilde_dir;
@@ -2584,8 +2509,6 @@ bool is_dir(const char *buf)
struct stat fileinfo;
bool retval;
assert(buf != NULL);
dirptr = real_dir_from_tilde(buf);
retval = (stat(dirptr, &fileinfo) != -1 && S_ISDIR(fileinfo.st_mode));
@@ -2782,31 +2705,26 @@ char *input_tab(char *buf, bool allow_files, size_t *place,
char *mzero, *glued;
const char *lastslash = revstrstr(buf, "/", buf + *place);
size_t lastslash_len = (lastslash == NULL) ? 0 : lastslash - buf + 1;
char *match1 = charalloc(mb_cur_max());
char *match2 = charalloc(mb_cur_max());
int match1_len, match2_len;
char char1[mb_cur_max()], char2[mb_cur_max()];
int len1, len2;
/* Get the number of characters that all matches have in common. */
while (TRUE) {
match1_len = parse_mbchar(matches[0] + common_len, match1, NULL);
len1 = parse_mbchar(matches[0] + common_len, char1, NULL);
for (match = 1; match < num_matches; match++) {
match2_len = parse_mbchar(matches[match] + common_len,
match2, NULL);
if (match1_len != match2_len ||
strncmp(match1, match2, match2_len) != 0)
len2 = parse_mbchar(matches[match] + common_len, char2, NULL);
if (len1 != len2 || strncmp(char1, char2, len2) != 0)
break;
}
if (match < num_matches || matches[0][common_len] == '\0')
break;
common_len += match1_len;
common_len += len1;
}
free(match1);
free(match2);
mzero = charalloc(lastslash_len + common_len + 1);
strncpy(mzero, buf, lastslash_len);
@@ -2940,8 +2858,8 @@ char *histfilename(void)
return construct_filename("/.nano/search_history");
}
/* Construct the legacy history filename.
* (Deprecate in 2.5, delete later.) */
/* Construct the legacy history filename. */
/* (To be removed in 2018.) */
char *legacyhistfilename(void)
{
return construct_filename("/.nano_history");
@@ -3001,6 +2919,8 @@ void load_history(void)
char *legacyhist = legacyhistfilename();
struct stat hstat;
/* If there is an old history file, migrate it. */
/* (To be removed in 2018.) */
if (stat(legacyhist, &hstat) != -1 && stat(nanohist, &hstat) == -1) {
if (rename(legacyhist, nanohist) == -1)
history_error(N_("Detected a legacy nano history file (%s) which I tried to move\n"
@@ -3032,12 +2952,10 @@ void load_history(void)
size_t buf_len = 0;
ssize_t read;
while ((read = getline(&line, &buf_len, hist)) >= 0) {
if (read > 0 && line[read - 1] == '\n') {
read--;
line[read] = '\0';
}
while ((read = getline(&line, &buf_len, hist)) > 0) {
line[--read] = '\0';
if (read > 0) {
/* Encode any embedded NUL as 0x0A. */
unsunder(line, read);
update_history(history, line);
} else
@@ -3052,22 +2970,23 @@ void load_history(void)
}
}
/* Write the lines of a history list, starting with the line at h, to
/* Write the lines of a history list, starting with the line at head, to
* the open file at hist. Return TRUE if the write succeeded, and FALSE
* otherwise. */
bool writehist(FILE *hist, filestruct *h)
bool writehist(FILE *hist, const filestruct *head)
{
filestruct *p;
const filestruct *item;
/* Write a history list from the oldest entry to the newest. Assume
* the last history entry is a blank line. */
for (p = h; p != NULL; p = p->next) {
size_t p_len = strlen(p->data);
/* Write a history list, from the oldest item to the newest. */
for (item = head; item != NULL; item = item->next) {
size_t length = strlen(item->data);
sunder(p->data);
/* Decode 0x0A bytes as embedded NULs. */
sunder(item->data);
if (fwrite(p->data, sizeof(char), p_len, hist) < p_len ||
putc('\n', hist) == EOF)
if (fwrite(item->data, sizeof(char), length, hist) < length)
return FALSE;
if (putc('\n', hist) == EOF)
return FALSE;
}
@@ -3112,7 +3031,6 @@ void save_history(void)
void save_poshistory(void)
{
char *poshist = poshistfilename();
char *statusstr = NULL;
poshiststruct *posptr;
FILE *hist;
@@ -3128,14 +3046,25 @@ void save_poshistory(void)
chmod(poshist, S_IRUSR | S_IWUSR);
for (posptr = position_history; posptr != NULL; posptr = posptr->next) {
char *path_and_place;
size_t length;
/* Assume 20 decimal positions each for line and column number,
* plus two spaces, plus the line feed, plus the null byte. */
statusstr = charalloc(strlen(posptr->filename) + 44);
sprintf(statusstr, "%s %ld %ld\n", posptr->filename, (long)posptr->lineno,
(long)posptr->xno);
if (fwrite(statusstr, sizeof(char), strlen(statusstr), hist) < strlen(statusstr))
fprintf(stderr, _("Error writing %s: %s\n"), poshist, strerror(errno));
free(statusstr);
path_and_place = charalloc(strlen(posptr->filename) + 44);
sprintf(path_and_place, "%s %ld %ld\n", posptr->filename,
(long)posptr->lineno, (long)posptr->xno);
length = strlen(path_and_place);
/* Encode newlines in filenames as nulls. */
sunder(path_and_place);
/* Restore the terminating newline. */
path_and_place[length - 1] = '\n';
if (fwrite(path_and_place, sizeof(char), length, hist) < length)
fprintf(stderr, _("Error writing %s: %s\n"),
poshist, strerror(errno));
free(path_and_place);
}
fclose(hist);
}
@@ -3204,27 +3133,28 @@ void update_poshistory(char *filename, ssize_t lineno, ssize_t xpos)
free(fullpath);
}
/* Check the recorded last file positions to see if the given file
* matches an existing entry. If so, return 1 and set line and column
* to the retrieved values. Otherwise, return 0. */
int check_poshistory(const char *file, ssize_t *line, ssize_t *column)
/* Check whether the given file matches an existing entry in the recorded
* last file positions. If not, return FALSE. If yes, return TRUE and
* set line and column to the retrieved values. */
bool has_old_position(const char *file, ssize_t *line, ssize_t *column)
{
poshiststruct *posptr;
poshiststruct *posptr = position_history;
char *fullpath = get_full_path(file);
if (fullpath == NULL)
return 0;
return FALSE;
while (posptr != NULL && strcmp(posptr->filename, fullpath) != 0)
posptr = posptr->next;
for (posptr = position_history; posptr != NULL; posptr = posptr->next) {
if (!strcmp(posptr->filename, fullpath)) {
*line = posptr->lineno;
*column = posptr->xno;
free(fullpath);
return 1;
}
}
free(fullpath);
return 0;
if (posptr == NULL)
return FALSE;
*line = posptr->lineno;
*column = posptr->xno;
return TRUE;
}
/* Load the recorded file positions from ~/.nano/filepos_history. */
@@ -3252,13 +3182,21 @@ void load_poshistory(void)
poshiststruct *record_ptr = NULL, *newrecord;
/* Read and parse each line, and store the extracted data. */
while ((read = getline(&line, &buf_len, hist)) > 2) {
if (line[read - 1] == '\n')
line[--read] = '\0';
while ((read = getline(&line, &buf_len, hist)) > 5) {
/* Decode nulls as embedded newlines. */
unsunder(line, read);
lineptr = parse_next_word(line);
xptr = parse_next_word(lineptr);
/* Find where the x index and line number are in the line. */
xptr = revstrstr(line, " ", line + read - 3);
if (xptr == NULL)
continue;
lineptr = revstrstr(line, " ", xptr - 2);
if (lineptr == NULL)
continue;
/* Now separate the three elements of the line. */
*(xptr++) = '\0';
*(lineptr++) = '\0';
/* Create a new position record. */
newrecord = (poshiststruct *)nmalloc(sizeof(poshiststruct));

View File

@@ -1,5 +1,5 @@
/**************************************************************************
* global.c -- This file is part of GNU nano. *
* global.c -- This file is part of GNU nano. *
* *
* Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, *
* 2008, 2009, 2010, 2011, 2013, 2014 Free Software Foundation, Inc. *
@@ -29,11 +29,11 @@
/* Global variables. */
#ifndef NANO_TINY
volatile sig_atomic_t sigwinch_counter = 0;
/* Is incremented by the handler whenever a SIGWINCH occurs. */
volatile sig_atomic_t the_window_resized = FALSE;
/* Set to TRUE by the handler whenever a SIGWINCH occurs. */
#endif
#if defined(__linux__) && !defined(NANO_TINY)
#ifdef __linux__
bool console;
/* Whether we're running on a Linux VC (TRUE) or under X (FALSE). */
#endif
@@ -45,11 +45,22 @@ bool shift_held;
bool focusing = TRUE;
/* Whether an update of the edit window should center the cursor. */
bool as_an_at = TRUE;
/* Whether a 0x0A byte should be shown as a ^@ instead of a ^J. */
int margin = 0;
/* The amount of space reserved at the left for line numbers. */
int editwincols = -1;
/* The number of usable columns in the edit window: COLS - margin. */
message_type lastmessage = HUSH;
/* Messages of type HUSH should not overwrite type MILD nor ALERT. */
#ifndef NANO_TINY
filestruct *pletion_line = NULL;
/* The line where the last completion was found, if any. */
int controlleft, controlright, controlup, controldown;
#ifndef NANO_TINY
int shiftcontrolleft, shiftcontrolright, shiftcontrolup, shiftcontroldown;
int shiftaltleft, shiftaltright, shiftaltup, shiftaltdown;
#endif
@@ -89,13 +100,9 @@ int maxrows = 0;
filestruct *cutbuffer = NULL;
/* The buffer where we store cut text. */
filestruct *cutbottom = NULL;
#ifndef DISABLE_JUSTIFY
filestruct *jusbuffer = NULL;
/* The buffer where we store unjustified text. */
#endif
/* The last line in the cutbuffer. */
partition *filepart = NULL;
/* The partition where we store a portion of the current
* file. */
/* The "partition" where we store a portion of the current file. */
openfilestruct *openfile = NULL;
/* The list of all open file buffers. */
@@ -128,7 +135,7 @@ char *quoteerr = NULL;
size_t quotelen;
/* The length of the quoting string in bytes. */
#endif
#endif
#endif /* !DISABLE_JUSTIFY */
char *word_chars = NULL;
/* Nonalphanumeric characters that also form words. */
@@ -140,8 +147,7 @@ char *answer = NULL;
/* The answer string used by the statusbar prompt. */
ssize_t tabsize = -1;
/* The width of a tab in spaces. The default value is set in
* main(). */
/* The width of a tab in spaces. The default is set in main(). */
#ifndef NANO_TINY
char *backup_dir = NULL;
@@ -179,15 +185,15 @@ bool refresh_needed = FALSE;
int currmenu = MMOST;
/* The currently active menu, initialized to a dummy value. */
sc *sclist = NULL;
/* Pointer to the start of the shortcuts list. */
/* The start of the shortcuts list. */
subnfunc *allfuncs = NULL;
/* Pointer to the start of the functions list. */
/* The start of the functions list. */
subnfunc *tailfunc;
/* Pointer to the last function in the list. */
/* The last function in the list. */
subnfunc *exitfunc;
/* Pointer to the special Exit/Close item. */
/* A pointer to the special Exit/Close item. */
subnfunc *uncutfunc;
/* Pointer to the special Uncut/Unjustify item. */
/* A pointer to the special Uncut/Unjustify item. */
#ifndef DISABLE_HISTORIES
filestruct *search_history = NULL;
@@ -206,7 +212,6 @@ poshiststruct *position_history = NULL;
/* The cursor position history list. */
#endif
/* Regular expressions. */
#ifdef HAVE_REGEX_H
regex_t search_regexp;
/* The compiled regular expression to use in searches. */
@@ -216,7 +221,7 @@ regmatch_t regmatches[10];
#endif
int hilite_attribute = A_REVERSE;
/* The curses attribute we use for reverse video. */
/* The curses attribute we use to highlight something. */
#ifndef DISABLE_COLOR
char* specified_color_combo[] = {};
/* The color combinations as specified in the rcfile. */
@@ -227,6 +232,7 @@ int interface_color_pair[] = {};
char *homedir = NULL;
/* The user's home directory, from $HOME or /etc/passwd. */
/* Return the number of entries in the shortcut list for a given menu. */
size_t length_of_list(int menu)
{
@@ -323,10 +329,13 @@ void add_to_funcs(void (*func)(void), int menus, const char *desc, const char *h
}
/* Add a key combo to the shortcut list. */
void add_to_sclist(int menus, const char *scstring, void (*func)(void), int toggle)
void add_to_sclist(int menus, const char *scstring, const int keycode,
void (*func)(void), int toggle)
{
static sc *tailsc;
#ifndef NANO_TINY
static int counter = 0;
#endif
sc *s = (sc *)nmalloc(sizeof(sc));
/* Start the list, or tack on the next item. */
@@ -340,10 +349,12 @@ void add_to_sclist(int menus, const char *scstring, void (*func)(void), int togg
/* Fill in the data. */
s->menus = menus;
s->scfunc = func;
#ifndef NANO_TINY
s->toggle = toggle;
if (toggle)
s->ordinal = ++counter;
assign_keyinfo(s, scstring);
#endif
assign_keyinfo(s, scstring, keycode);
#ifdef DEBUG
fprintf(stderr, "Setting keycode to %d for shortcut \"%s\" in menus %x\n", s->keycode, scstring, s->menus);
@@ -377,18 +388,17 @@ const sc *first_sc_for(int menu, void (*func)(void))
return NULL;
}
/* Return the given menu's first shortcut sequence, or the default value
* (2nd arg). Assumes currmenu for the menu to check. */
int sc_seq_or(void (*func)(void), int defaultval)
/* Return the first keycode that is bound to the given function in the
* current menu, if any; otherwise, return the given default value. */
int the_code_for(void (*func)(void), int defaultval)
{
const sc *s = first_sc_for(currmenu, func);
if (s) {
meta_key = s->meta;
return s->keycode;
}
/* else */
return defaultval;
if (s == NULL)
return defaultval;
meta_key = s->meta;
return s->keycode;
}
/* Return a pointer to the function that is bound to the given key. */
@@ -403,53 +413,31 @@ functionptrtype func_from_key(int *kbinput)
}
/* Set the string and its corresponding keycode for the given shortcut s. */
void assign_keyinfo(sc *s, const char *keystring)
void assign_keyinfo(sc *s, const char *keystring, const int keycode)
{
s->keystr = keystring;
s->meta = (keystring[0] == 'M');
assert(strlen(keystring) > 1 && (!s->meta || strlen(keystring) > 2));
if (keystring[0] == '^') {
s->keycode = keystring[1] - 64;
if (keycode)
s->keycode = keycode;
else if (keystring[0] == '^') {
if (strcasecmp(keystring, "^Space") == 0)
s->keycode = 0;
else
s->keycode = keystring[1] - 64;
} else if (s->meta) {
s->keycode = tolower((int)keystring[2]);
if (strcasecmp(keystring, "M-Space") == 0)
s->keycode = (int)' ';
else
s->keycode = tolower((int)keystring[2]);
} else if (keystring[0] == 'F')
s->keycode = KEY_F0 + atoi(&keystring[1]);
/* Catch the strings that don't bind as easily as we'd like. */
else if (!strcasecmp(keystring, "Up"))
s->keycode = KEY_UP;
else if (!strcasecmp(keystring, "Down"))
s->keycode = KEY_DOWN;
else if (!strcasecmp(keystring, "Left"))
s->keycode = KEY_LEFT;
else if (!strcasecmp(keystring, "Right"))
s->keycode = KEY_RIGHT;
else if (!strcasecmp(keystring, "Ins"))
s->keycode = KEY_IC;
else if (!strcasecmp(keystring, "Del"))
s->keycode = KEY_DC;
else if (!strcasecmp(keystring, "Bsp"))
s->keycode = KEY_BACKSPACE;
/* The Tab and Enter keys don't actually produce special codes
* but the exact integer values of ^I and ^M. Rebinding the
* latter therefore also rebinds Tab and Enter. */
else if (!strcasecmp(keystring, "Tab"))
s->keycode = TAB_CODE;
else if (!strcasecmp(keystring, "Enter"))
s->keycode = KEY_ENTER;
else if (!strcasecmp(keystring, "PgUp"))
s->keycode = KEY_PPAGE;
else if (!strcasecmp(keystring, "PgDn"))
s->keycode = KEY_NPAGE;
else if (!strcasecmp(keystring, "Home"))
s->keycode = KEY_HOME;
else if (!strcasecmp(keystring, "End"))
s->keycode = KEY_END;
}
#ifdef DEBUG
@@ -493,10 +481,8 @@ void shortcut_init(void)
const char *fulljustify_tag = N_("FullJstify");
#endif
const char *refresh_tag = N_("Refresh");
#ifndef NANO_TINY
/* TRANSLATORS: Try to keep this string at most 12 characters. */
const char *whereis_next_tag = N_("WhereIs Next");
#endif
#ifndef DISABLE_HELP
#ifndef DISABLE_JUSTIFY
@@ -544,26 +530,19 @@ void shortcut_init(void)
N_("Copy the current line and store it in the cutbuffer");
const char *nano_indent_msg = N_("Indent the current line");
const char *nano_unindent_msg = N_("Unindent the current line");
#ifdef ENABLE_COMMENT
const char *nano_comment_msg = N_("Comment/uncomment the current line or marked lines");
#endif
const char *nano_undo_msg = N_("Undo the last operation");
const char *nano_redo_msg = N_("Redo the last undone operation");
#endif
const char *nano_back_msg = N_("Go back one character");
const char *nano_forward_msg = N_("Go forward one character");
#ifndef NANO_TINY
const char *nano_prevword_msg = N_("Go back one word");
const char *nano_nextword_msg = N_("Go forward one word");
#endif
const char *nano_prevline_msg = N_("Go to previous line");
const char *nano_nextline_msg = N_("Go to next line");
const char *nano_home_msg = N_("Go to beginning of current line");
const char *nano_end_msg = N_("Go to end of current line");
#ifndef NANO_TINY
const char *nano_prevblock_msg = N_("Go to previous block of text");
const char *nano_nextblock_msg = N_("Go to next block of text");
#endif
#ifndef DISABLE_JUSTIFY
const char *nano_parabegin_msg =
N_("Go to beginning of paragraph; then of previous paragraph");
@@ -608,6 +587,13 @@ void shortcut_init(void)
N_("Refresh (redraw) the current screen");
const char *nano_suspend_msg =
N_("Suspend the editor (if suspension is enabled)");
#ifdef ENABLE_WORDCOMPLETION
const char *nano_completion_msg = N_("Try and complete the current word");
#endif
#ifdef ENABLE_COMMENT
const char *nano_comment_msg =
N_("Comment/uncomment the current line or marked lines");
#endif
#ifndef NANO_TINY
const char *nano_savefile_msg = N_("Save file without prompting");
const char *nano_findprev_msg = N_("Search next occurrence backward");
@@ -764,20 +750,25 @@ void shortcut_init(void)
#endif
}
#ifndef NANO_TINY
add_to_funcs(case_sens_void, MWHEREIS|MREPLACE,
N_("Case Sens"), IFSCHELP(nano_case_msg), TOGETHER, VIEW);
add_to_funcs(do_cursorpos_void, MMAIN,
N_("Cur Pos"), IFSCHELP(nano_cursorpos_msg), TOGETHER, VIEW);
#if (!defined(DISABLE_JUSTIFY) && (!defined(DISABLE_SPELLER) || !defined(DISABLE_COLOR)) || \
defined(DISABLE_JUSTIFY) && defined(DISABLE_SPELLER) && defined(DISABLE_COLOR))
/* Conditionally placing this one here or further on, to keep the
* help items nicely paired in most conditions. */
add_to_funcs(do_gotolinecolumn_void, MMAIN,
gotoline_tag, IFSCHELP(nano_gotoline_msg), BLANKAFTER, VIEW);
#endif
add_to_funcs(case_sens_void, MWHEREIS|MREPLACE,
N_("Case Sens"), IFSCHELP(nano_case_msg), TOGETHER, VIEW);
#ifdef HAVE_REGEX_H
add_to_funcs(regexp_void, MWHEREIS|MREPLACE,
N_("Regexp"), IFSCHELP(nano_regexp_msg), TOGETHER, VIEW);
#endif
#ifndef NANO_TINY
add_to_funcs(backwards_void, MWHEREIS|MREPLACE,
N_("Backwards"), IFSCHELP(nano_reverse_msg), TOGETHER, VIEW);
#endif
add_to_funcs(flip_replace_void, MWHEREIS,
replace_tag, IFSCHELP(nano_replace_msg), BLANKAFTER, VIEW);
@@ -788,15 +779,8 @@ void shortcut_init(void)
#ifndef DISABLE_JUSTIFY
add_to_funcs(do_full_justify, MWHEREIS,
fulljustify_tag, IFSCHELP(nano_fulljustify_msg), TOGETHER, NOVIEW);
#endif
add_to_funcs(do_cursorpos_void, MMAIN,
N_("Cur Pos"), IFSCHELP(nano_cursorpos_msg), TOGETHER, VIEW);
#if defined(DISABLE_COLOR) || !defined(DISABLE_JUSTIFY)
/* Conditionally placing this one here or further on, to keep the
* help items nicely paired in most conditions. */
add_to_funcs(do_gotolinecolumn_void, MMAIN|MWHEREIS,
add_to_funcs(do_gotolinecolumn_void, MWHEREIS,
gotoline_tag, IFSCHELP(nano_gotoline_msg), BLANKAFTER, VIEW);
#endif
@@ -846,12 +830,10 @@ void shortcut_init(void)
N_("Forward"), IFSCHELP(nano_forwardfile_msg), TOGETHER, VIEW);
#endif
#ifndef NANO_TINY
add_to_funcs(do_prev_word_void, MMAIN,
N_("Prev Word"), IFSCHELP(nano_prevword_msg), TOGETHER, VIEW);
add_to_funcs(do_next_word_void, MMAIN,
N_("Next Word"), IFSCHELP(nano_nextword_msg), TOGETHER, VIEW);
#endif
add_to_funcs(do_home, MMAIN,
N_("Home"), IFSCHELP(nano_home_msg), TOGETHER, VIEW);
@@ -863,12 +845,10 @@ void shortcut_init(void)
add_to_funcs(do_down_void, MMAIN|MBROWSER,
next_line_tag, IFSCHELP(nano_nextline_msg), BLANKAFTER, VIEW);
#ifndef NANO_TINY
add_to_funcs(do_prev_block, MMAIN,
N_("Prev Block"), IFSCHELP(nano_prevblock_msg), TOGETHER, VIEW);
add_to_funcs(do_next_block, MMAIN,
N_("Next Block"), IFSCHELP(nano_nextblock_msg), TOGETHER, VIEW);
#endif
#ifndef DISABLE_JUSTIFY
add_to_funcs(do_para_begin_void, MMAIN|MWHEREIS,
@@ -891,11 +871,18 @@ void shortcut_init(void)
N_("Next File"), IFSCHELP(nano_nextfile_msg), BLANKAFTER, VIEW);
#endif
#if !defined(DISABLE_COLOR) && defined(DISABLE_JUSTIFY)
#if (defined(DISABLE_JUSTIFY) && (!defined(DISABLE_SPELLER) || !defined(DISABLE_COLOR)) || \
!defined(DISABLE_JUSTIFY) && defined(DISABLE_SPELLER) && defined(DISABLE_COLOR))
add_to_funcs(do_gotolinecolumn_void, MMAIN,
gotoline_tag, IFSCHELP(nano_gotoline_msg), BLANKAFTER, VIEW);
#endif
#ifdef NANO_TINY
/* Place this one here only in the tiny version; otherwise further up. */
add_to_funcs(do_research, MMAIN,
whereis_next_tag, IFSCHELP(nano_whereis_next_msg), TOGETHER, VIEW);
#endif
add_to_funcs(do_verbatim_input, MMAIN,
N_("Verbatim"), IFSCHELP(nano_verbatim_msg), TOGETHER, NOVIEW);
@@ -941,6 +928,10 @@ void shortcut_init(void)
add_to_funcs(do_suspend_void, MMAIN,
N_("Suspend"), IFSCHELP(nano_suspend_msg), BLANKAFTER, VIEW);
#ifdef ENABLE_WORDCOMPLETION
add_to_funcs(complete_a_word, MMAIN,
N_("Complete"), IFSCHELP(nano_completion_msg), TOGETHER, NOVIEW);
#endif
#ifdef ENABLE_COMMENT
add_to_funcs(do_comment, MMAIN,
N_("Comment Lines"), IFSCHELP(nano_comment_msg), BLANKAFTER, NOVIEW);
@@ -964,7 +955,7 @@ void shortcut_init(void)
N_("NextHstory"), IFSCHELP(nano_next_history_msg), BLANKAFTER, VIEW);
#endif
#if !defined(DISABLE_COLOR) && defined(DISABLE_JUSTIFY)
#ifdef DISABLE_JUSTIFY
add_to_funcs(do_gotolinecolumn_void, MWHEREIS,
gotoline_tag, IFSCHELP(nano_gotoline_msg), BLANKAFTER, VIEW);
#endif
@@ -1052,224 +1043,244 @@ void shortcut_init(void)
/* Start associating key combos with functions in specific menus. */
add_to_sclist(MMOST, "^G", do_help_void, 0);
add_to_sclist(MMOST, "F1", do_help_void, 0);
add_to_sclist(MMAIN|MHELP|MBROWSER, "^X", do_exit, 0);
add_to_sclist(MMAIN|MHELP|MBROWSER, "F2", do_exit, 0);
add_to_sclist(MMAIN, "^O", do_writeout_void, 0);
add_to_sclist(MMAIN, "F3", do_writeout_void, 0);
add_to_sclist(MMAIN, "^R", do_insertfile_void, 0);
add_to_sclist(MMAIN, "F5", do_insertfile_void, 0);
add_to_sclist(MMAIN, "Ins", do_insertfile_void, 0);
add_to_sclist(MMAIN|MBROWSER, "^W", do_search, 0);
add_to_sclist(MMAIN|MBROWSER, "F6", do_search, 0);
add_to_sclist(MMAIN, "^\\", do_replace, 0);
add_to_sclist(MMAIN, "M-R", do_replace, 0);
add_to_sclist(MMAIN, "F14", do_replace, 0);
add_to_sclist(MMOST, "^K", do_cut_text_void, 0);
add_to_sclist(MMOST, "F9", do_cut_text_void, 0);
add_to_sclist(MMAIN, "^U", do_uncut_text, 0);
add_to_sclist(MMAIN, "F10", do_uncut_text, 0);
add_to_sclist(MMOST, "^G", 0, do_help_void, 0);
add_to_sclist(MMOST, "F1", 0, do_help_void, 0);
add_to_sclist(MMAIN|MHELP|MBROWSER, "^X", 0, do_exit, 0);
add_to_sclist(MMAIN|MHELP|MBROWSER, "F2", 0, do_exit, 0);
add_to_sclist(MMAIN, "^O", 0, do_writeout_void, 0);
add_to_sclist(MMAIN, "F3", 0, do_writeout_void, 0);
add_to_sclist(MMAIN, "^R", 0, do_insertfile_void, 0);
add_to_sclist(MMAIN, "F5", 0, do_insertfile_void, 0);
add_to_sclist(MMAIN, "Ins", 0, do_insertfile_void, 0);
add_to_sclist(MMAIN|MBROWSER, "^W", 0, do_search, 0);
add_to_sclist(MMAIN|MBROWSER, "F6", 0, do_search, 0);
add_to_sclist(MMAIN, "^\\", 0, do_replace, 0);
add_to_sclist(MMAIN, "M-R", 0, do_replace, 0);
add_to_sclist(MMAIN, "F14", 0, do_replace, 0);
add_to_sclist(MMOST, "^K", 0, do_cut_text_void, 0);
add_to_sclist(MMOST, "F9", 0, do_cut_text_void, 0);
add_to_sclist(MMAIN, "^U", 0, do_uncut_text, 0);
add_to_sclist(MMAIN, "F10", 0, do_uncut_text, 0);
#ifndef DISABLE_JUSTIFY
add_to_sclist(MMAIN, "^J", do_justify_void, 0);
add_to_sclist(MMAIN, "F4", do_justify_void, 0);
add_to_sclist(MMAIN, "^J", 0, do_justify_void, 0);
add_to_sclist(MMAIN, "F4", 0, do_justify_void, 0);
#endif
#ifndef DISABLE_SPELLER
add_to_sclist(MMAIN, "^T", do_spell, 0);
add_to_sclist(MMAIN, "F12", do_spell, 0);
add_to_sclist(MMAIN, "^T", 0, do_spell, 0);
add_to_sclist(MMAIN, "F12", 0, do_spell, 0);
#else
#ifndef DISABLE_COLOR
add_to_sclist(MMAIN, "^T", do_linter, 0);
add_to_sclist(MMAIN, "F12", do_linter, 0);
add_to_sclist(MMAIN, "^T", 0, do_linter, 0);
add_to_sclist(MMAIN, "F12", 0, do_linter, 0);
#endif
#endif
add_to_sclist(MMAIN, "^C", do_cursorpos_void, 0);
add_to_sclist(MMAIN, "F11", do_cursorpos_void, 0);
add_to_sclist(MMAIN, "^_", do_gotolinecolumn_void, 0);
add_to_sclist(MMAIN, "M-G", do_gotolinecolumn_void, 0);
add_to_sclist(MMAIN, "F13", do_gotolinecolumn_void, 0);
add_to_sclist(MMAIN|MHELP|MBROWSER|MLINTER, "^Y", do_page_up, 0);
add_to_sclist(MMAIN|MHELP|MBROWSER|MLINTER, "F7", do_page_up, 0);
add_to_sclist(MMAIN|MHELP|MBROWSER|MLINTER, "PgUp", do_page_up, 0);
add_to_sclist(MMAIN|MHELP|MBROWSER|MLINTER, "^V", do_page_down, 0);
add_to_sclist(MMAIN|MHELP|MBROWSER|MLINTER, "F8", do_page_down, 0);
add_to_sclist(MMAIN|MHELP|MBROWSER|MLINTER, "PgDn", do_page_down, 0);
add_to_sclist(MMAIN|MHELP, "M-\\", do_first_line, 0);
add_to_sclist(MMAIN|MHELP, "M-|", do_first_line, 0);
add_to_sclist(MMAIN|MHELP, "M-/", do_last_line, 0);
add_to_sclist(MMAIN|MHELP, "M-?", do_last_line, 0);
add_to_sclist(MMAIN, "^C", 0, do_cursorpos_void, 0);
add_to_sclist(MMAIN, "F11", 0, do_cursorpos_void, 0);
add_to_sclist(MMAIN, "^_", 0, do_gotolinecolumn_void, 0);
add_to_sclist(MMAIN, "M-G", 0, do_gotolinecolumn_void, 0);
add_to_sclist(MMAIN, "F13", 0, do_gotolinecolumn_void, 0);
add_to_sclist(MMAIN|MHELP|MBROWSER|MLINTER, "^Y", 0, do_page_up, 0);
add_to_sclist(MMAIN|MHELP|MBROWSER|MLINTER, "F7", 0, do_page_up, 0);
add_to_sclist(MMAIN|MHELP|MBROWSER|MLINTER, "PgUp", KEY_PPAGE, do_page_up, 0);
add_to_sclist(MMAIN|MHELP|MBROWSER|MLINTER, "^V", 0, do_page_down, 0);
add_to_sclist(MMAIN|MHELP|MBROWSER|MLINTER, "F8", 0, do_page_down, 0);
add_to_sclist(MMAIN|MHELP|MBROWSER|MLINTER, "PgDn", KEY_NPAGE, do_page_down, 0);
add_to_sclist(MMAIN|MHELP, "M-\\", 0, do_first_line, 0);
add_to_sclist(MMAIN|MHELP, "M-|", 0, do_first_line, 0);
add_to_sclist(MMAIN|MHELP, "M-/", 0, do_last_line, 0);
add_to_sclist(MMAIN|MHELP, "M-?", 0, do_last_line, 0);
add_to_sclist(MMAIN|MBROWSER, "M-W", 0, do_research, 0);
add_to_sclist(MMAIN|MBROWSER, "F16", 0, do_research, 0);
#ifndef NANO_TINY
add_to_sclist(MMAIN|MBROWSER, "M-W", do_research, 0);
add_to_sclist(MMAIN|MBROWSER, "F16", do_research, 0);
add_to_sclist(MMAIN, "M-]", do_find_bracket, 0);
add_to_sclist(MMAIN, "^^", do_mark, 0);
add_to_sclist(MMAIN, "M-A", do_mark, 0);
add_to_sclist(MMAIN, "F15", do_mark, 0);
add_to_sclist(MMAIN, "M-^", do_copy_text, 0);
add_to_sclist(MMAIN, "M-6", do_copy_text, 0);
add_to_sclist(MMAIN, "M-}", do_indent_void, 0);
add_to_sclist(MMAIN, "M-{", do_unindent, 0);
add_to_sclist(MMAIN, "M-U", do_undo, 0);
add_to_sclist(MMAIN, "M-E", do_redo, 0);
add_to_sclist(MMAIN, "M-]", 0, do_find_bracket, 0);
add_to_sclist(MMAIN, "^^", 0, do_mark, 0);
add_to_sclist(MMAIN, "M-A", 0, do_mark, 0);
add_to_sclist(MMAIN, "F15", 0, do_mark, 0);
add_to_sclist(MMAIN, "M-^", 0, do_copy_text, 0);
add_to_sclist(MMAIN, "M-6", 0, do_copy_text, 0);
add_to_sclist(MMAIN, "M-}", 0, do_indent_void, 0);
add_to_sclist(MMAIN, "M-{", 0, do_unindent, 0);
add_to_sclist(MMAIN, "M-U", 0, do_undo, 0);
add_to_sclist(MMAIN, "M-E", 0, do_redo, 0);
#endif
#ifdef ENABLE_WORDCOMPLETION
add_to_sclist(MMAIN, "^]", 0, complete_a_word, 0);
#endif
#ifdef ENABLE_COMMENT
add_to_sclist(MMAIN, "M-3", do_comment, 0);
add_to_sclist(MMAIN, "M-3", 0, do_comment, 0);
#endif
add_to_sclist(MMOST, "^B", do_left, 0);
add_to_sclist(MMOST, "Left", do_left, 0);
add_to_sclist(MMOST, "^F", do_right, 0);
add_to_sclist(MMOST, "Right", do_right, 0);
#ifndef NANO_TINY
add_to_sclist(MMOST, "M-Space", do_prev_word_void, 0);
add_to_sclist(MMOST, "^Space", do_next_word_void, 0);
add_to_sclist(MMOST, "^B", 0, do_left, 0);
add_to_sclist(MMOST, "Left", KEY_LEFT, do_left, 0);
add_to_sclist(MMOST, "^F", 0, do_right, 0);
add_to_sclist(MMOST, "Right", KEY_RIGHT, do_right, 0);
#ifdef ENABLE_UTF8
if (using_utf8()) {
add_to_sclist(MMOST, "^\xE2\x86\x90", CONTROL_LEFT, do_prev_word_void, 0);
add_to_sclist(MMOST, "^\xE2\x86\x92", CONTROL_RIGHT, do_next_word_void, 0);
} else
#endif
add_to_sclist((MMOST & ~MBROWSER), "^A", do_home, 0);
add_to_sclist((MMOST & ~MBROWSER), "Home", do_home, 0);
add_to_sclist((MMOST & ~MBROWSER), "^E", do_end, 0);
add_to_sclist((MMOST & ~MBROWSER), "End", do_end, 0);
add_to_sclist(MMAIN|MHELP|MBROWSER, "^P", do_up_void, 0);
add_to_sclist(MMAIN|MHELP|MBROWSER, "Up", do_up_void, 0);
add_to_sclist(MMAIN|MHELP|MBROWSER, "^N", do_down_void, 0);
add_to_sclist(MMAIN|MHELP|MBROWSER, "Down", do_down_void, 0);
#ifndef NANO_TINY
add_to_sclist(MMAIN, "M-7", do_prev_block, 0);
add_to_sclist(MMAIN, "M-8", do_next_block, 0);
{
add_to_sclist(MMOST, "^Left", CONTROL_LEFT, do_prev_word_void, 0);
add_to_sclist(MMOST, "^Right", CONTROL_RIGHT, do_next_word_void, 0);
}
add_to_sclist(MMOST, "M-Space", 0, do_prev_word_void, 0);
add_to_sclist(MMOST, "^Space", 0, do_next_word_void, 0);
add_to_sclist((MMOST & ~MBROWSER), "^A", 0, do_home, 0);
add_to_sclist((MMOST & ~MBROWSER), "Home", KEY_HOME, do_home, 0);
add_to_sclist((MMOST & ~MBROWSER), "^E", 0, do_end, 0);
add_to_sclist((MMOST & ~MBROWSER), "End", KEY_END, do_end, 0);
add_to_sclist(MMAIN|MHELP|MBROWSER, "^P", 0, do_up_void, 0);
add_to_sclist(MMAIN|MHELP|MBROWSER, "Up", KEY_UP, do_up_void, 0);
add_to_sclist(MMAIN|MHELP|MBROWSER, "^N", 0, do_down_void, 0);
add_to_sclist(MMAIN|MHELP|MBROWSER, "Down", KEY_DOWN, do_down_void, 0);
#ifdef ENABLE_UTF8
if (using_utf8()) {
add_to_sclist(MMAIN, "^\xE2\x86\x91", CONTROL_UP, do_prev_block, 0);
add_to_sclist(MMAIN, "^\xE2\x86\x93", CONTROL_DOWN, do_next_block, 0);
} else
#endif
{
add_to_sclist(MMAIN, "^Up", CONTROL_UP, do_prev_block, 0);
add_to_sclist(MMAIN, "^Down", CONTROL_DOWN, do_next_block, 0);
}
add_to_sclist(MMAIN, "M-7", 0, do_prev_block, 0);
add_to_sclist(MMAIN, "M-8", 0, do_next_block, 0);
#ifndef DISABLE_JUSTIFY
add_to_sclist(MMAIN, "M-(", do_para_begin_void, 0);
add_to_sclist(MMAIN, "M-9", do_para_begin_void, 0);
add_to_sclist(MMAIN, "M-)", do_para_end_void, 0);
add_to_sclist(MMAIN, "M-0", do_para_end_void, 0);
add_to_sclist(MMAIN, "M-(", 0, do_para_begin_void, 0);
add_to_sclist(MMAIN, "M-9", 0, do_para_begin_void, 0);
add_to_sclist(MMAIN, "M-)", 0, do_para_end_void, 0);
add_to_sclist(MMAIN, "M-0", 0, do_para_end_void, 0);
#endif
#ifndef NANO_TINY
add_to_sclist(MMAIN, "M--", do_scroll_up, 0);
add_to_sclist(MMAIN, "M-_", do_scroll_up, 0);
add_to_sclist(MMAIN, "M-+", do_scroll_down, 0);
add_to_sclist(MMAIN, "M-=", do_scroll_down, 0);
add_to_sclist(MMAIN, "M--", 0, do_scroll_up, 0);
add_to_sclist(MMAIN, "M-_", 0, do_scroll_up, 0);
add_to_sclist(MMAIN, "M-+", 0, do_scroll_down, 0);
add_to_sclist(MMAIN, "M-=", 0, do_scroll_down, 0);
#endif
#ifndef DISABLE_MULTIBUFFER
add_to_sclist(MMAIN, "M-<", switch_to_prev_buffer_void, 0);
add_to_sclist(MMAIN, "M-,", switch_to_prev_buffer_void, 0);
add_to_sclist(MMAIN, "M->", switch_to_next_buffer_void, 0);
add_to_sclist(MMAIN, "M-.", switch_to_next_buffer_void, 0);
add_to_sclist(MMAIN, "M-<", 0, switch_to_prev_buffer_void, 0);
add_to_sclist(MMAIN, "M-,", 0, switch_to_prev_buffer_void, 0);
add_to_sclist(MMAIN, "M->", 0, switch_to_next_buffer_void, 0);
add_to_sclist(MMAIN, "M-.", 0, switch_to_next_buffer_void, 0);
#endif
add_to_sclist(MMOST, "M-V", do_verbatim_input, 0);
add_to_sclist(MMOST, "M-V", 0, do_verbatim_input, 0);
#ifndef NANO_TINY
add_to_sclist(MMAIN, "M-T", do_cut_till_eof, 0);
add_to_sclist(MMAIN, "M-D", do_wordlinechar_count, 0);
add_to_sclist(MMAIN, "M-T", 0, do_cut_till_eof, 0);
add_to_sclist(MMAIN, "M-D", 0, do_wordlinechar_count, 0);
#endif
#ifndef DISABLE_JUSTIFY
add_to_sclist(MMAIN|MWHEREIS, "M-J", do_full_justify, 0);
add_to_sclist(MMAIN|MWHEREIS, "M-J", 0, do_full_justify, 0);
#endif
add_to_sclist(MMAIN|MHELP, "^L", total_refresh, 0);
add_to_sclist(MMAIN, "^Z", do_suspend_void, 0);
add_to_sclist(MMAIN|MHELP, "^L", 0, total_refresh, 0);
add_to_sclist(MMAIN, "^Z", 0, do_suspend_void, 0);
#ifndef NANO_TINY
/* Group of "Appearance" toggles. */
add_to_sclist(MMAIN, "M-X", do_toggle_void, NO_HELP);
add_to_sclist(MMAIN, "M-C", do_toggle_void, CONST_UPDATE);
add_to_sclist(MMAIN, "M-O", do_toggle_void, MORE_SPACE);
add_to_sclist(MMAIN, "M-S", do_toggle_void, SMOOTH_SCROLL);
add_to_sclist(MMAIN, "M-$", do_toggle_void, SOFTWRAP);
add_to_sclist(MMAIN, "M-P", do_toggle_void, WHITESPACE_DISPLAY);
add_to_sclist(MMAIN, "M-X", 0, do_toggle_void, NO_HELP);
add_to_sclist(MMAIN, "M-C", 0, do_toggle_void, CONST_UPDATE);
add_to_sclist(MMAIN, "M-O", 0, do_toggle_void, MORE_SPACE);
add_to_sclist(MMAIN, "M-S", 0, do_toggle_void, SMOOTH_SCROLL);
add_to_sclist(MMAIN, "M-$", 0, do_toggle_void, SOFTWRAP);
#ifdef ENABLE_LINENUMBERS
add_to_sclist(MMAIN, "M-#", 0, do_toggle_void, LINE_NUMBERS);
#endif
add_to_sclist(MMAIN, "M-P", 0, do_toggle_void, WHITESPACE_DISPLAY);
#ifndef DISABLE_COLOR
add_to_sclist(MMAIN, "M-Y", do_toggle_void, NO_COLOR_SYNTAX);
add_to_sclist(MMAIN, "M-Y", 0, do_toggle_void, NO_COLOR_SYNTAX);
#endif
/* Group of "Editing-behavior" toggles. */
add_to_sclist(MMAIN, "M-H", do_toggle_void, SMART_HOME);
add_to_sclist(MMAIN, "M-I", do_toggle_void, AUTOINDENT);
add_to_sclist(MMAIN, "M-K", do_toggle_void, CUT_TO_END);
add_to_sclist(MMAIN, "M-H", 0, do_toggle_void, SMART_HOME);
add_to_sclist(MMAIN, "M-I", 0, do_toggle_void, AUTOINDENT);
add_to_sclist(MMAIN, "M-K", 0, do_toggle_void, CUT_TO_END);
#ifndef DISABLE_WRAPPING
add_to_sclist(MMAIN, "M-L", do_toggle_void, NO_WRAP);
add_to_sclist(MMAIN, "M-L", 0, do_toggle_void, NO_WRAP);
#endif
add_to_sclist(MMAIN, "M-Q", do_toggle_void, TABS_TO_SPACES);
add_to_sclist(MMAIN, "M-Q", 0, do_toggle_void, TABS_TO_SPACES);
/* Group of "Peripheral-feature" toggles. */
add_to_sclist(MMAIN, "M-B", do_toggle_void, BACKUP_FILE);
add_to_sclist(MMAIN, "M-B", 0, do_toggle_void, BACKUP_FILE);
#ifndef DISABLE_MULTIBUFFER
add_to_sclist(MMAIN, "M-F", do_toggle_void, MULTIBUFFER);
add_to_sclist(MMAIN, "M-F", 0, do_toggle_void, MULTIBUFFER);
#endif
#ifndef DISABLE_MOUSE
add_to_sclist(MMAIN, "M-M", do_toggle_void, USE_MOUSE);
add_to_sclist(MMAIN, "M-M", 0, do_toggle_void, USE_MOUSE);
#endif
add_to_sclist(MMAIN, "M-N", do_toggle_void, NO_CONVERT);
add_to_sclist(MMAIN, "M-Z", do_toggle_void, SUSPEND);
add_to_sclist(MMAIN, "M-N", 0, do_toggle_void, NO_CONVERT);
add_to_sclist(MMAIN, "M-Z", 0, do_toggle_void, SUSPEND);
#endif /* !NANO_TINY */
add_to_sclist(MMAIN, "^Q", xon_complaint, 0);
add_to_sclist(MMAIN, "^S", xoff_complaint, 0);
add_to_sclist(MMAIN, "^Q", 0, xon_complaint, 0);
add_to_sclist(MMAIN, "^S", 0, xoff_complaint, 0);
add_to_sclist(((MMOST & ~MMAIN & ~MBROWSER) | MYESNO), "^C", do_cancel, 0);
add_to_sclist(((MMOST & ~MMAIN & ~MBROWSER) | MYESNO), "^C", 0, do_cancel, 0);
#ifndef NANO_TINY
add_to_sclist(MWHEREIS|MREPLACE, "M-B", backwards_void, 0);
add_to_sclist(MWHEREIS|MREPLACE, "M-C", case_sens_void, 0);
#endif
add_to_sclist(MWHEREIS|MREPLACE, "M-R", regexp_void, 0);
add_to_sclist(MWHEREIS|MREPLACE, "^R", flip_replace_void, 0);
add_to_sclist(MWHEREIS|MREPLACE|MREPLACEWITH|MGOTOLINE, "^Y", do_first_line, 0);
add_to_sclist(MWHEREIS|MREPLACE|MREPLACEWITH|MGOTOLINE, "^V", do_last_line, 0);
add_to_sclist(MWHEREIS|MREPLACE, "M-C", 0, case_sens_void, 0);
add_to_sclist(MWHEREIS|MREPLACE, "M-R", 0, regexp_void, 0);
add_to_sclist(MWHEREIS|MREPLACE, "M-B", 0, backwards_void, 0);
add_to_sclist(MWHEREIS|MREPLACE, "^R", 0, flip_replace_void, 0);
add_to_sclist(MWHEREIS|MREPLACE|MREPLACEWITH|MGOTOLINE, "^Y", 0, do_first_line, 0);
add_to_sclist(MWHEREIS|MREPLACE|MREPLACEWITH|MGOTOLINE, "^V", 0, do_last_line, 0);
#ifndef DISABLE_JUSTIFY
add_to_sclist(MWHEREIS|MREPLACE|MREPLACEWITH, "^W", do_para_begin_void, 0);
add_to_sclist(MWHEREIS|MREPLACE|MREPLACEWITH, "^O", do_para_end_void, 0);
add_to_sclist(MWHEREIS|MREPLACE|MREPLACEWITH, "^W", 0, do_para_begin_void, 0);
add_to_sclist(MWHEREIS|MREPLACE|MREPLACEWITH, "^O", 0, do_para_end_void, 0);
#endif
add_to_sclist(MWHEREIS, "^T", do_gotolinecolumn_void, 0);
add_to_sclist(MGOTOLINE, "^T", gototext_void, 0);
add_to_sclist(MWHEREIS, "^T", 0, do_gotolinecolumn_void, 0);
add_to_sclist(MGOTOLINE, "^T", 0, gototext_void, 0);
#ifndef DISABLE_HISTORIES
add_to_sclist(MWHEREIS|MREPLACE|MREPLACEWITH|MWHEREISFILE, "^P", get_history_older_void, 0);
add_to_sclist(MWHEREIS|MREPLACE|MREPLACEWITH|MWHEREISFILE, "Up", get_history_older_void, 0);
add_to_sclist(MWHEREIS|MREPLACE|MREPLACEWITH|MWHEREISFILE, "^N", get_history_newer_void, 0);
add_to_sclist(MWHEREIS|MREPLACE|MREPLACEWITH|MWHEREISFILE, "Down", get_history_newer_void, 0);
add_to_sclist(MWHEREIS|MREPLACE|MREPLACEWITH|MWHEREISFILE, "^P", 0, get_history_older_void, 0);
add_to_sclist(MWHEREIS|MREPLACE|MREPLACEWITH|MWHEREISFILE, "Up", KEY_UP, get_history_older_void, 0);
add_to_sclist(MWHEREIS|MREPLACE|MREPLACEWITH|MWHEREISFILE, "^N", 0, get_history_newer_void, 0);
add_to_sclist(MWHEREIS|MREPLACE|MREPLACEWITH|MWHEREISFILE, "Down", KEY_DOWN, get_history_newer_void, 0);
#endif
#ifndef DISABLE_BROWSER
add_to_sclist(MWHEREISFILE, "^Y", do_first_file, 0);
add_to_sclist(MWHEREISFILE, "^V", do_last_file, 0);
add_to_sclist(MBROWSER|MWHEREISFILE, "M-\\", do_first_file, 0);
add_to_sclist(MBROWSER|MWHEREISFILE, "M-|", do_first_file, 0);
add_to_sclist(MBROWSER|MWHEREISFILE, "M-/", do_last_file, 0);
add_to_sclist(MBROWSER|MWHEREISFILE, "M-?", do_last_file, 0);
add_to_sclist(MBROWSER, "Home", do_first_file, 0);
add_to_sclist(MBROWSER, "End", do_last_file, 0);
add_to_sclist(MBROWSER, "^_", goto_dir_void, 0);
add_to_sclist(MBROWSER, "M-G", goto_dir_void, 0);
add_to_sclist(MBROWSER, "F13", goto_dir_void, 0);
add_to_sclist(MBROWSER, "^L", total_refresh, 0);
add_to_sclist(MWHEREISFILE, "^Y", 0, do_first_file, 0);
add_to_sclist(MWHEREISFILE, "^V", 0, do_last_file, 0);
add_to_sclist(MBROWSER|MWHEREISFILE, "M-\\", 0, do_first_file, 0);
add_to_sclist(MBROWSER|MWHEREISFILE, "M-|", 0, do_first_file, 0);
add_to_sclist(MBROWSER|MWHEREISFILE, "M-/", 0, do_last_file, 0);
add_to_sclist(MBROWSER|MWHEREISFILE, "M-?", 0, do_last_file, 0);
add_to_sclist(MBROWSER, "Home", KEY_HOME, do_first_file, 0);
add_to_sclist(MBROWSER, "End", KEY_END, do_last_file, 0);
add_to_sclist(MBROWSER, "^_", 0, goto_dir_void, 0);
add_to_sclist(MBROWSER, "M-G", 0, goto_dir_void, 0);
add_to_sclist(MBROWSER, "F13", 0, goto_dir_void, 0);
add_to_sclist(MBROWSER, "^L", 0, total_refresh, 0);
#endif
if (ISSET(TEMP_FILE))
add_to_sclist(MWRITEFILE, "^Q", discard_buffer, 0);
add_to_sclist(MWRITEFILE, "M-D", dos_format_void, 0);
add_to_sclist(MWRITEFILE, "M-M", mac_format_void, 0);
add_to_sclist(MWRITEFILE, "^Q", 0, discard_buffer, 0);
add_to_sclist(MWRITEFILE, "M-D", 0, dos_format_void, 0);
add_to_sclist(MWRITEFILE, "M-M", 0, mac_format_void, 0);
if (!ISSET(RESTRICTED)) {
/* Don't allow Appending, Prepending, nor Backups in restricted mode. */
add_to_sclist(MWRITEFILE, "M-A", append_void, 0);
add_to_sclist(MWRITEFILE, "M-P", prepend_void, 0);
add_to_sclist(MWRITEFILE, "M-B", backup_file_void, 0);
add_to_sclist(MWRITEFILE, "M-A", 0, append_void, 0);
add_to_sclist(MWRITEFILE, "M-P", 0, prepend_void, 0);
add_to_sclist(MWRITEFILE, "M-B", 0, backup_file_void, 0);
#ifndef DISABLE_BROWSER
add_to_sclist(MWRITEFILE|MINSERTFILE, "^T", to_files_void, 0);
add_to_sclist(MWRITEFILE|MINSERTFILE, "^T", 0, to_files_void, 0);
#endif
add_to_sclist(MINSERTFILE|MEXTCMD, "^X", flip_execute_void, 0);
add_to_sclist(MINSERTFILE|MEXTCMD, "M-F", new_buffer_void, 0);
add_to_sclist(MINSERTFILE|MEXTCMD, "^X", 0, flip_execute_void, 0);
add_to_sclist(MINSERTFILE|MEXTCMD, "M-F", 0, new_buffer_void, 0);
}
add_to_sclist(MHELP|MBROWSER, "^C", do_exit, 0);
add_to_sclist(MHELP|MBROWSER, "^C", 0, do_exit, 0);
/* Allow exiting from the file browser and the help viewer with
* the same key as they were entered. */
#ifndef DISABLE_BROWSER
add_to_sclist(MBROWSER, "^T", do_exit, 0);
add_to_sclist(MBROWSER, "^T", 0, do_exit, 0);
#endif
#ifndef DISABLE_HELP
add_to_sclist(MHELP, "^G", do_exit, 0);
add_to_sclist(MHELP, "Home", do_first_line, 0);
add_to_sclist(MHELP, "End", do_last_line, 0);
add_to_sclist(MHELP, "^G", 0, do_exit, 0);
add_to_sclist(MHELP, "Home", KEY_HOME, do_first_line, 0);
add_to_sclist(MHELP, "End", KEY_END, do_last_line, 0);
#endif
add_to_sclist(MMOST, "^I", do_tab, 0);
add_to_sclist(MMOST, "Tab", do_tab, 0);
add_to_sclist(MMOST, "^M", do_enter, 0);
add_to_sclist(MMOST, "Enter", do_enter, 0);
add_to_sclist(MMOST, "^D", do_delete, 0);
add_to_sclist(MMOST, "Del", do_delete, 0);
add_to_sclist(MMOST, "^H", do_backspace, 0);
add_to_sclist(MMOST, "Bsp", do_backspace, 0);
add_to_sclist(MMOST, "^I", 0, do_tab, 0);
add_to_sclist(MMOST, "Tab", TAB_CODE, do_tab, 0);
add_to_sclist(MMOST, "^M", 0, do_enter, 0);
add_to_sclist(MMOST, "Enter", KEY_ENTER, do_enter, 0);
add_to_sclist(MMOST, "^D", 0, do_delete, 0);
add_to_sclist(MMOST, "Del", 0, do_delete, 0);
add_to_sclist(MMOST, "^H", 0, do_backspace, 0);
add_to_sclist(MMOST, "Bsp", KEY_BACKSPACE, do_backspace, 0);
#ifdef DEBUG
print_sclist();
@@ -1351,6 +1362,8 @@ const char *flagtostr(int flag)
return N_("No conversion from DOS/Mac format");
case SUSPEND:
return N_("Suspension");
case LINE_NUMBERS:
return N_("Line numbering");
default:
return "?????";
}
@@ -1362,10 +1375,11 @@ const char *flagtostr(int flag)
* shortcut struct with the corresponding function filled in. */
sc *strtosc(const char *input)
{
sc *s;
sc *s = nmalloc(sizeof(sc));
s = (sc *)nmalloc(sizeof(sc));
#ifndef NANO_TINY
s->toggle = 0;
#endif
#ifndef DISABLE_HELP
if (!strcasecmp(input, "help"))
@@ -1388,10 +1402,10 @@ sc *strtosc(const char *input)
s->scfunc = do_insertfile_void;
else if (!strcasecmp(input, "whereis"))
s->scfunc = do_search;
#ifndef NANO_TINY
else if (!strcasecmp(input, "searchagain") ||
!strcasecmp(input, "research"))
!strcasecmp(input, "research")) /* Deprecated. Remove in 2018. */
s->scfunc = do_research;
#ifndef NANO_TINY
else if (!strcasecmp(input, "findprevious"))
s->scfunc = do_findprevious;
else if (!strcasecmp(input, "findnext"))
@@ -1421,7 +1435,7 @@ sc *strtosc(const char *input)
s->scfunc = do_linter;
#endif
else if (!strcasecmp(input, "curpos") ||
!strcasecmp(input, "cursorpos"))
!strcasecmp(input, "cursorpos")) /* Deprecated. Remove in 2018. */
s->scfunc = do_cursorpos_void;
else if (!strcasecmp(input, "gotoline"))
s->scfunc = do_gotolinecolumn_void;
@@ -1439,6 +1453,10 @@ sc *strtosc(const char *input)
else if (!strcasecmp(input, "comment"))
s->scfunc = do_comment;
#endif
#ifdef ENABLE_WORDCOMPLETION
else if (!strcasecmp(input, "complete"))
s->scfunc = complete_a_word;
#endif
#ifndef NANO_TINY
else if (!strcasecmp(input, "indent"))
s->scfunc = do_indent_void;
@@ -1517,15 +1535,13 @@ sc *strtosc(const char *input)
s->scfunc = do_suspend_void;
else if (!strcasecmp(input, "casesens"))
s->scfunc = case_sens_void;
#ifndef NANO_TINY
else if (!strcasecmp(input, "regexp") ||
!strcasecmp(input, "regex"))
!strcasecmp(input, "regex")) /* Deprecated. Remove in 2018. */
s->scfunc = regexp_void;
else if (!strcasecmp(input, "backwards"))
s->scfunc = backwards_void;
#endif
else if (!strcasecmp(input, "flipreplace") ||
!strcasecmp(input, "dontreplace"))
!strcasecmp(input, "dontreplace")) /* Deprecated. Remove in 2018. */
s->scfunc = flip_replace_void;
else if (!strcasecmp(input, "gototext"))
s->scfunc = gototext_void;
@@ -1551,7 +1567,7 @@ sc *strtosc(const char *input)
#endif
#ifndef DISABLE_MULTIBUFFER
else if (!strcasecmp(input, "flipnewbuffer") ||
!strcasecmp(input, "newbuffer"))
!strcasecmp(input, "newbuffer")) /* Deprecated. Remove in 2018. */
s->scfunc = new_buffer_void;
#endif
#ifndef DISABLE_BROWSER
@@ -1565,8 +1581,8 @@ sc *strtosc(const char *input)
else if (!strcasecmp(input, "lastfile"))
s->scfunc = do_last_file;
#endif
#ifndef NANO_TINY
else {
#ifndef NANO_TINY
s->scfunc = do_toggle_void;
if (!strcasecmp(input, "nohelp"))
s->toggle = NO_HELP;
@@ -1610,14 +1626,13 @@ sc *strtosc(const char *input)
s->toggle = NO_CONVERT;
else if (!strcasecmp(input, "suspendenable"))
s->toggle = SUSPEND;
else
#endif /* !NANO_TINY */
else {
{
free(s);
return NULL;
}
#ifndef NANO_TINY
}
#endif
return s;
}
@@ -1632,7 +1647,7 @@ int strtomenu(const char *input)
return MWHEREIS;
else if (!strcasecmp(input, "replace"))
return MREPLACE;
else if (!strcasecmp(input, "replace2") ||
else if (!strcasecmp(input, "replace2") || /* Deprecated. Remove in 2018. */
!strcasecmp(input, "replacewith"))
return MREPLACEWITH;
else if (!strcasecmp(input, "gotoline"))
@@ -1701,9 +1716,6 @@ void thanks_for_all_the_fish(void)
free(alt_speller);
#endif
free_filestruct(cutbuffer);
#ifndef DISABLE_JUSTIFY
free_filestruct(jusbuffer);
#endif
/* Free the memory associated with each open file buffer. */
while (openfile != openfile->next) {
openfile = openfile->next;

View File

@@ -419,7 +419,11 @@ void help_init(void)
* but allow it to spill into the second, for "M-Space". */
if (scsfound == 1) {
sprintf(ptr, "%s ", s->keystr);
ptr += 6;
/* Unicode arrows take three bytes instead of one. */
if (s->keystr[1] == '\xE2')
ptr += 8;
else
ptr += 6;
} else {
ptr += sprintf(ptr, "(%s)\t", s->keystr);
break;

View File

@@ -28,7 +28,7 @@
/* Move to the first line of the file. */
void do_first_line(void)
{
openfile->current = openfile->edittop = openfile->fileage;
openfile->current = openfile->fileage;
openfile->current_x = 0;
openfile->placewewant = 0;
@@ -41,7 +41,10 @@ void do_last_line(void)
openfile->current = openfile->filebot;
openfile->current_x = strlen(openfile->filebot->data);
openfile->placewewant = xplustabs();
/* Set the last line of the screen as the target for the cursor. */
openfile->current_y = editwinrows - 1;
ensure_line_is_visible();
refresh_needed = TRUE;
focusing = FALSE;
@@ -54,10 +57,7 @@ void do_page_up(void)
/* If the cursor is less than a page away from the top of the file,
* put it at the beginning of the first line. */
if (openfile->current->lineno == 1 || (
#ifndef NANO_TINY
!ISSET(SOFTWRAP) &&
#endif
if (openfile->current->lineno == 1 || (!ISSET(SOFTWRAP) &&
openfile->current->lineno <= editwinrows - 2)) {
do_first_line();
return;
@@ -65,10 +65,7 @@ void do_page_up(void)
/* If we're not in smooth scrolling mode, put the cursor at the
* beginning of the top line of the edit window, as Pico does. */
#ifndef NANO_TINY
if (!ISSET(SMOOTH_SCROLL))
#endif
{
if (!ISSET(SMOOTH_SCROLL)) {
openfile->current = openfile->edittop;
openfile->placewewant = openfile->current_y = 0;
}
@@ -79,9 +76,9 @@ void do_page_up(void)
openfile->current = openfile->current->prev;
#ifndef NANO_TINY
if (ISSET(SOFTWRAP) && openfile->current) {
skipped += strlenpt(openfile->current->data) / COLS;
skipped += strlenpt(openfile->current->data) / editwincols;
#ifdef DEBUG
fprintf(stderr, "do_page_up: i = %d, skipped = %d based on line %ld len %lu\n",
fprintf(stderr, "paging up: i = %d, skipped = %d based on line %ld len %lu\n",
i, skipped, (long)openfile->current->lineno, (unsigned long)strlenpt(openfile->current->data));
#endif
}
@@ -91,13 +88,8 @@ void do_page_up(void)
openfile->current_x = actual_x(openfile->current->data,
openfile->placewewant);
#ifdef DEBUG
fprintf(stderr, "do_page_up: openfile->current->lineno = %lu, skipped = %d\n",
(unsigned long)openfile->current->lineno, skipped);
#endif
/* Scroll the edit window up a page. */
edit_update(STATIONARY);
adjust_viewport(STATIONARY);
refresh_needed = TRUE;
}
@@ -115,10 +107,7 @@ void do_page_down(void)
/* If we're not in smooth scrolling mode, put the cursor at the
* beginning of the top line of the edit window, as Pico does. */
#ifndef NANO_TINY
if (!ISSET(SMOOTH_SCROLL))
#endif
{
if (!ISSET(SMOOTH_SCROLL)) {
openfile->current = openfile->edittop;
openfile->placewewant = openfile->current_y = 0;
}
@@ -128,7 +117,7 @@ void do_page_down(void)
for (i = mustmove; i > 0 && openfile->current != openfile->filebot; i--) {
openfile->current = openfile->current->next;
#ifdef DEBUG
fprintf(stderr, "do_page_down: moving to line %lu\n", (unsigned long)openfile->current->lineno);
fprintf(stderr, "paging down: moving to line %lu\n", (unsigned long)openfile->current->lineno);
#endif
}
@@ -137,7 +126,7 @@ void do_page_down(void)
openfile->placewewant);
/* Scroll the edit window down a page. */
edit_update(STATIONARY);
adjust_viewport(STATIONARY);
refresh_needed = TRUE;
}
@@ -147,19 +136,18 @@ void do_page_down(void)
* afterwards. */
void do_para_begin(bool allow_update)
{
filestruct *current_save = openfile->current;
filestruct *was_current = openfile->current;
if (openfile->current != openfile->fileage) {
do {
do
openfile->current = openfile->current->prev;
openfile->current_y--;
} while (!begpar(openfile->current));
while (!begpar(openfile->current));
}
openfile->current_x = 0;
if (allow_update)
edit_redraw(current_save);
edit_redraw(was_current);
}
/* Move up to the beginning of the last beginning-of-paragraph line
@@ -177,7 +165,7 @@ void do_para_begin_void(void)
* paragraph or isn't in a paragraph. */
void do_para_end(bool allow_update)
{
filestruct *const current_save = openfile->current;
filestruct *was_current = openfile->current;
while (openfile->current != openfile->filebot &&
!inpar(openfile->current))
@@ -187,7 +175,6 @@ void do_para_end(bool allow_update)
inpar(openfile->current->next) &&
!begpar(openfile->current->next)) {
openfile->current = openfile->current->next;
openfile->current_y++;
}
if (openfile->current != openfile->filebot) {
@@ -197,7 +184,7 @@ void do_para_end(bool allow_update)
openfile->current_x = strlen(openfile->current->data);
if (allow_update)
edit_redraw(current_save);
edit_redraw(was_current);
}
/* Move down to the beginning of the last line of the current paragraph.
@@ -209,7 +196,6 @@ void do_para_end_void(void)
}
#endif /* !DISABLE_JUSTIFY */
#ifndef NANO_TINY
/* Move to the preceding block of text in the file. */
void do_prev_block(void)
{
@@ -255,7 +241,7 @@ void do_next_block(void)
* screen afterwards. */
void do_prev_word(bool allow_punct, bool allow_update)
{
filestruct *current_save = openfile->current;
filestruct *was_current = openfile->current;
bool seen_a_word = FALSE, step_forward = FALSE;
assert(openfile->current != NULL && openfile->current->data != NULL);
@@ -295,7 +281,7 @@ void do_prev_word(bool allow_punct, bool allow_update)
/* If allow_update is TRUE, update the screen. */
if (allow_update) {
focusing = FALSE;
edit_redraw(current_save);
edit_redraw(was_current);
}
}
@@ -312,7 +298,7 @@ void do_prev_word_void(void)
* otherwise. */
bool do_next_word(bool allow_punct, bool allow_update)
{
filestruct *current_save = openfile->current;
filestruct *was_current = openfile->current;
bool started_on_word = is_word_mbchar(openfile->current->data +
openfile->current_x, allow_punct);
bool seen_space = !started_on_word;
@@ -347,7 +333,7 @@ bool do_next_word(bool allow_punct, bool allow_update)
/* If allow_update is TRUE, update the screen. */
if (allow_update) {
focusing = FALSE;
edit_redraw(current_save);
edit_redraw(was_current);
}
/* Return whether we started on a word. */
@@ -360,7 +346,19 @@ void do_next_word_void(void)
{
do_next_word(ISSET(WORD_BOUNDS), TRUE);
}
#endif /* !NANO_TINY */
/* Make sure that the current line, when it is partially scrolled off the
* screen in softwrap mode, is scrolled fully into view. */
void ensure_line_is_visible(void)
{
#ifndef NANO_TINY
if (ISSET(SOFTWRAP) && strlenpt(openfile->current->data) / editwincols +
openfile->current_y >= editwinrows) {
adjust_viewport(ISSET(SMOOTH_SCROLL) ? FLOWING : CENTERING);
refresh_needed = TRUE;
}
#endif
}
/* Move to the beginning of the current line. If the SMART_HOME flag is
* set, move to the first non-whitespace character of the current line
@@ -399,6 +397,8 @@ void do_end(void)
if (need_horizontal_scroll(was_column, openfile->placewewant))
update_line(openfile->current, openfile->current_x);
ensure_line_is_visible();
}
/* If scroll_only is FALSE, move up one line. If scroll_only is TRUE,
@@ -409,11 +409,8 @@ void do_up(bool scroll_only)
/* If we're at the top of the file, or if scroll_only is TRUE and
* the top of the file is onscreen, get out. */
if (openfile->current == openfile->fileage
#ifndef NANO_TINY
|| (scroll_only && openfile->edittop == openfile->fileage)
#endif
)
if (openfile->current == openfile->fileage ||
(scroll_only && openfile->edittop == openfile->fileage))
return;
assert(ISSET(SOFTWRAP) || openfile->current_y == openfile->current->lineno - openfile->edittop->lineno);
@@ -423,21 +420,12 @@ void do_up(bool scroll_only)
openfile->current_x = actual_x(openfile->current->data,
openfile->placewewant);
/* If scroll_only is FALSE and if we're on the first line of the
* edit window, scroll the edit window up one line if we're in
* smooth scrolling mode, or up half a page if we're not. If
* scroll_only is TRUE, scroll the edit window up one line
* unconditionally. */
if (openfile->current_y == 0
#ifndef NANO_TINY
|| (ISSET(SOFTWRAP) && openfile->edittop->lineno == openfile->current->next->lineno) || scroll_only
#endif
)
edit_scroll(UPWARD,
#ifndef NANO_TINY
(ISSET(SMOOTH_SCROLL) || scroll_only) ? 1 :
#endif
editwinrows / 2 + 1);
/* When the cursor was on the first line of the edit window (or when just
* scrolling without moving the cursor), scroll the edit window up -- one
* line if we're in smooth scrolling mode, and half a page otherwise. */
if (openfile->current->next == openfile->edittop || scroll_only)
edit_scroll(UPWARD, (ISSET(SMOOTH_SCROLL) || scroll_only) ?
1 : editwinrows / 2 + 1);
/* If the lines weren't already redrawn, see if they need to be. */
if (openfile->current_y > 0) {
@@ -477,18 +465,20 @@ void do_down(bool scroll_only)
#ifndef NANO_TINY
if (ISSET(SOFTWRAP)) {
/* Compute the number of lines to scroll. */
amount = strlenpt(openfile->current->data) / COLS - xplustabs() / COLS +
strlenpt(openfile->current->next->data) / COLS +
amount = strlenpt(openfile->current->data) / editwincols -
xplustabs() / editwincols +
strlenpt(openfile->current->next->data) / editwincols +
openfile->current_y - editwinrows + 2;
topline = openfile->edittop;
/* Reduce the amount when there are overlong lines at the top. */
for (enough = 1; enough < amount; enough++) {
amount -= strlenpt(topline->data) / COLS;
if (amount <= 0) {
amount -= strlenpt(topline->data) / editwincols;
if (amount > 0)
topline = topline->next;
if (amount < enough) {
amount = enough;
break;
}
topline = topline->next;
}
}
#endif
@@ -503,26 +493,23 @@ void do_down(bool scroll_only)
* smooth scrolling mode, or down half a page if we're not. If
* scroll_only is TRUE, scroll the edit window down one line
* unconditionally. */
if (openfile->current_y == editwinrows - 1
#ifndef NANO_TINY
|| amount > 0 || scroll_only
#endif
) {
#ifndef NANO_TINY
if (openfile->current_y == editwinrows - 1 || amount > 0 || scroll_only) {
if (amount < 1 || scroll_only)
amount = 1;
#endif
edit_scroll(DOWNWARD,
#ifndef NANO_TINY
(ISSET(SMOOTH_SCROLL) || scroll_only) ? amount :
#endif
editwinrows / 2 + 1);
edit_scroll(DOWNWARD, (ISSET(SMOOTH_SCROLL) || scroll_only) ?
amount : editwinrows / 2 + 1);
if (ISSET(SOFTWRAP)) {
refresh_needed = TRUE;
return;
}
}
#else
if (openfile->current_y == editwinrows - 1)
edit_scroll(DOWNWARD, editwinrows / 2 + 1);
#endif
/* If the lines weren't already redrawn, see if they need to be. */
if (openfile->current_y < editwinrows - 1) {
@@ -586,15 +573,19 @@ void do_right(void)
openfile->current_x);
else if (openfile->current != openfile->filebot) {
openfile->current_x = 0;
openfile->placewewant = 0;
if (need_horizontal_scroll(was_column, 0))
update_line(openfile->current, 0);
do_down_void();
return;
#ifndef NANO_TINY
if (ISSET(SOFTWRAP))
openfile->current_y -= strlenpt(openfile->current->data) / editwincols;
#endif
}
openfile->placewewant = xplustabs();
if (need_horizontal_scroll(was_column, openfile->placewewant))
update_line(openfile->current, openfile->current_x);
if (openfile->current_x == 0)
do_down_void();
else
ensure_line_is_visible();
}

View File

@@ -78,8 +78,6 @@ filestruct *copy_node(const filestruct *src)
{
filestruct *dst;
assert(src != NULL);
dst = (filestruct *)nmalloc(sizeof(filestruct));
dst->data = mallocstrcpy(NULL, src->data);
@@ -96,8 +94,6 @@ filestruct *copy_node(const filestruct *src)
/* Splice a new node into an existing linked list of filestructs. */
void splice_node(filestruct *afterthis, filestruct *newnode)
{
assert(afterthis != NULL && newnode != NULL);
newnode->next = afterthis->next;
newnode->prev = afterthis;
if (afterthis->next != NULL)
@@ -112,8 +108,6 @@ void splice_node(filestruct *afterthis, filestruct *newnode)
/* Disconnect a node from a linked list of filestructs and delete it. */
void unlink_node(filestruct *fileptr)
{
assert(fileptr != NULL);
if (fileptr->prev != NULL)
fileptr->prev->next = fileptr->next;
if (fileptr->next != NULL)
@@ -129,8 +123,6 @@ void unlink_node(filestruct *fileptr)
/* Free the data structures in the given node. */
void delete_node(filestruct *fileptr)
{
assert(fileptr != NULL && fileptr->data != NULL);
free(fileptr->data);
#ifndef DISABLE_COLOR
free(fileptr->multidata);
@@ -143,8 +135,6 @@ filestruct *copy_filestruct(const filestruct *src)
{
filestruct *head, *copy;
assert(src != NULL);
copy = copy_node(src);
copy->prev = NULL;
head = copy;
@@ -237,7 +227,6 @@ partition *partition_filestruct(filestruct *top, size_t top_x,
/* Remove all text before top_x at the top of the partition. */
charmove(top->data, top->data + top_x, strlen(top->data) - top_x + 1);
align(&top->data);
/* Return the partition. */
return p;
@@ -395,7 +384,7 @@ void move_to_filestruct(filestruct **file_top, filestruct **file_bot,
/* If the top of the edit window was inside the old partition, put
* it in range of current. */
if (edittop_inside) {
edit_update(STATIONARY);
adjust_viewport(STATIONARY);
refresh_needed = TRUE;
}
@@ -480,11 +469,6 @@ void copy_from_filestruct(filestruct *somebuffer)
/* Add the number of characters in the copied text to the file size. */
openfile->totsize += get_totsize(openfile->fileage, openfile->filebot);
/* Update the current y-coordinate to account for the number of
* lines the copied text has, less one since the first line will be
* tacked onto the current line. */
openfile->current_y += openfile->filebot->lineno - 1;
/* If we pasted onto the first line of the edit window, the corresponding
* struct has been freed, so... point at the start of the copied text. */
if (edittop_inside)
@@ -513,8 +497,7 @@ openfilestruct *make_new_opennode(void)
/* Unlink a node from the rest of the openfilestruct, and delete it. */
void unlink_opennode(openfilestruct *fileptr)
{
assert(fileptr != NULL && fileptr->prev != NULL && fileptr->next != NULL &&
fileptr != fileptr->prev && fileptr != fileptr->next);
assert(fileptr != fileptr->prev && fileptr != fileptr->next);
fileptr->prev->next = fileptr->next;
fileptr->next->prev = fileptr->prev;
@@ -525,8 +508,6 @@ void unlink_opennode(openfilestruct *fileptr)
/* Free all the memory in the given open-file node. */
void delete_opennode(openfilestruct *fileptr)
{
assert(fileptr != NULL && fileptr->filename != NULL && fileptr->fileage != NULL);
free(fileptr->filename);
free_filestruct(fileptr->fileage);
#ifndef NANO_TINY
@@ -797,13 +778,11 @@ void print_opt_full(const char *shortflag
void usage(void)
{
printf(_("Usage: nano [OPTIONS] [[+LINE,COLUMN] FILE]...\n\n"));
printf(
#ifdef HAVE_GETOPT_LONG
_("Option\t\tGNU long option\t\tMeaning\n")
printf(_("Option\t\tGNU long option\t\tMeaning\n"));
#else
_("Option\t\tMeaning\n")
printf(_("Option\t\tMeaning\n"));
#endif
);
print_opt(_("+LINE,COLUMN"), "",
/* TRANSLATORS: The next forty or so strings are option descriptions
* for the --help output. Try to keep them at most 40 characters. */
@@ -884,6 +863,9 @@ void usage(void)
print_opt("-i", "--autoindent", N_("Automatically indent new lines"));
print_opt("-k", "--cut", N_("Cut from cursor to end of line"));
#endif
#ifdef ENABLE_LINENUMBERS
print_opt("-l", "--linenumbers", N_("Show line numbers in front of the text"));
#endif
#ifndef DISABLE_MOUSE
print_opt("-m", "--mouse", N_("Enable the use of the mouse"));
#endif
@@ -962,6 +944,9 @@ void version(void)
#ifdef HAVE_LIBMAGIC
printf(" --enable-libmagic");
#endif
#ifdef ENABLE_LINENUMBERS
printf(" --enable-linenumbers");
#endif
#ifndef DISABLE_MOUSE
printf(" --enable-mouse");
#endif
@@ -1008,6 +993,9 @@ void version(void)
#ifndef HAVE_LIBMAGIC
printf(" --disable-libmagic");
#endif
#ifndef ENABLE_LINENUMBERS
printf(" --disable-linenumbers");
#endif
#ifdef DISABLE_MOUSE
printf(" --disable-mouse");
#endif
@@ -1026,6 +1014,9 @@ void version(void)
#ifdef DISABLE_TABCOMP
printf(" --disable-tabcomp");
#endif
#ifndef ENABLE_WORDCOMPLETION
printf(" --disable-wordcomp");
#endif
#ifdef DISABLE_WRAPPING
printf(" --disable-wrapping");
#endif
@@ -1051,21 +1042,6 @@ void version(void)
printf("\n");
}
/* Indicate that the current file has no name, in a way that gets the
* user's attention. This is used when trying to save a file with no
* name with the TEMP_FILE flag set, just before the filename prompt. */
void no_current_file_name_warning(void)
{
/* Warn that the current file has no name. */
statusbar(_("No file name"));
beep();
/* Ensure that we see the warning. */
napms(1800);
curs_set(1);
}
/* If the current file buffer has been modified, and the TEMP_FILE flag
* isn't set, ask whether or not to save the file buffer. If the
* TEMP_FILE flag is set and the current file has a name, save it
@@ -1089,7 +1065,7 @@ void do_exit(void)
/* If the TEMP_FILE flag is set, and the current file doesn't
* have a name, warn the user before prompting for a name. */
if (ISSET(TEMP_FILE))
no_current_file_name_warning();
warn_and_shortly_pause(_("No file name"));
i = do_yesno_prompt(FALSE, _("Save modified buffer? "
"(Answering \"No\" will DISCARD changes.) "));
@@ -1178,9 +1154,9 @@ void stdin_pager(void)
tcsetattr(0, TCSANOW, &oldterm);
fprintf(stderr, _("Reading from stdin, ^C to abort\n"));
#ifndef NANO_TINY
/* Enable interpretation of the special control keys so that
* we get SIGINT when Ctrl-C is pressed. */
#ifndef NANO_TINY
enable_signals();
#endif
@@ -1297,12 +1273,8 @@ RETSIGTYPE do_continue(int signal)
* and restore the terminal to its previous state in the process. */
regenerate_screen();
#else
/* Restore the terminal to its previous state. */
/* Restore the state of the terminal and redraw the whole screen. */
terminal_init();
/* Redraw the contents of the windows that need it. */
blank_statusbar();
wnoutrefresh(bottomwin);
total_refresh();
#endif
}
@@ -1312,7 +1284,7 @@ RETSIGTYPE do_continue(int signal)
RETSIGTYPE handle_sigwinch(int signal)
{
/* Let the input routine know that a SIGWINCH has occurred. */
sigwinch_counter++;
the_window_resized = TRUE;
}
/* Reinitialize and redraw the screen completely. */
@@ -1322,6 +1294,9 @@ void regenerate_screen(void)
int fd, result = 0;
struct winsize win;
/* Reset the trigger. */
the_window_resized = FALSE;
if (tty == NULL)
return;
fd = open(tty, O_RDWR);
@@ -1340,6 +1315,7 @@ void regenerate_screen(void)
COLS = win.ws_col;
LINES = win.ws_row;
#endif
editwincols = COLS - margin;
#ifdef USE_SLANG
/* Slang curses emulation brain damage, part 1: If we just do what
@@ -1408,39 +1384,33 @@ void do_toggle(int flag)
signal_init();
break;
case WHITESPACE_DISPLAY:
titlebar(NULL);
edit_refresh();
break;
titlebar(NULL); /* Fall through. */
#ifndef DISABLE_COLOR
case NO_COLOR_SYNTAX:
#endif
#ifdef ENABLE_LINENUMBERS
case LINE_NUMBERS:
#endif
case SOFTWRAP:
edit_refresh();
refresh_needed = TRUE;
break;
}
enabled = ISSET(flag);
if (flag == NO_HELP
#ifndef DISABLE_WRAPPING
|| flag == NO_WRAP
#endif
#ifndef DISABLE_COLOR
|| flag == NO_COLOR_SYNTAX
#endif
)
if (flag == NO_HELP || flag == NO_WRAP || flag == NO_COLOR_SYNTAX)
enabled = !enabled;
statusline(HUSH, "%s %s", _(flagtostr(flag)),
enabled ? _("enabled") : _("disabled"));
}
#endif /* !NANO_TINY */
/* Bleh. */
void do_toggle_void(void)
{
;
}
#endif /* !NANO_TINY */
/* Disable extended input and output processing in our terminal
* settings. */
@@ -1542,18 +1512,18 @@ void terminal_init(void)
#endif
}
#if !defined(NANO_TINY) && defined(HAVE_KEY_DEFINED)
/* Ask ncurses for a keycode, or assign a default one. */
int get_keycode(const char *keyname, const int standard)
{
#ifdef HAVE_KEY_DEFINED
const char *keyvalue = tigetstr(keyname);
if (keyvalue == 0 || keyvalue == (char *)-1)
return standard;
else
if (keyvalue != 0 && keyvalue != (char *)-1)
return key_defined(keyvalue);
}
else
#endif
return standard;
}
/* Say that an unbound key was struck, and if possible which one. */
void unbound_key(int code)
@@ -1671,7 +1641,9 @@ int do_input(bool allow_funcs)
}
}
if (have_shortcut) {
if (!have_shortcut)
pletion_line = NULL;
else {
const subnfunc *f = sctofunc(s);
if (ISSET(VIEW_MODE) && f && !f->viewok) {
@@ -1688,6 +1660,10 @@ int do_input(bool allow_funcs)
)
preserve = TRUE;
#ifdef ENABLE_WORDCOMPLETION
if (s->scfunc != complete_a_word)
pletion_line = NULL;
#endif
#ifndef NANO_TINY
if (s->scfunc == do_toggle_void) {
do_toggle(s->toggle);
@@ -1720,13 +1696,7 @@ int do_input(bool allow_funcs)
if (f && !f->viewok)
reset_multis(openfile->current, FALSE);
#endif
if (refresh_needed) {
#ifdef DEBUG
fprintf(stderr, "running edit_refresh() as refresh_needed is true\n");
#endif
edit_refresh();
refresh_needed = FALSE;
} else if (s->scfunc == do_delete || s->scfunc == do_backspace)
if (!refresh_needed && (s->scfunc == do_delete || s->scfunc == do_backspace))
update_line(openfile->current, openfile->current_x);
}
}
@@ -1757,74 +1727,67 @@ int do_mouse(void)
int mouse_x, mouse_y;
int retval = get_mouseinput(&mouse_x, &mouse_y, TRUE);
/* If the click is wrong or already handled, we're done. */
if (retval != 0)
/* The click is wrong or already handled. */
return retval;
/* We can click on the edit window to move the cursor. */
/* If the click was in the edit window, put the cursor in that spot. */
if (wmouse_trafo(edit, &mouse_y, &mouse_x, FALSE)) {
bool sameline;
/* Did they click on the line with the cursor? If they
* clicked on the cursor, we set the mark. */
bool sameline = (mouse_y == openfile->current_y);
/* Whether the click was on the line where the cursor is. */
filestruct *current_save = openfile->current;
#ifndef NANO_TINY
size_t current_x_save = openfile->current_x;
#endif
sameline = (mouse_y == openfile->current_y);
#ifdef DEBUG
fprintf(stderr, "mouse_y = %d, current_y = %ld\n", mouse_y, (long)openfile->current_y);
#endif
#ifndef NANO_TINY
if (ISSET(SOFTWRAP)) {
size_t i = 0;
for (openfile->current = openfile->edittop;
openfile->current->next && i < mouse_y;
openfile->current = openfile->current->next, i++) {
openfile->current_y = i;
i += strlenpt(openfile->current->data) / COLS;
}
#ifdef DEBUG
fprintf(stderr, "do_mouse(): moving to current_y = %ld, index i = %lu\n",
(long)openfile->current_y, (unsigned long)i);
fprintf(stderr, " openfile->current->data = \"%s\"\n", openfile->current->data);
#endif
ssize_t current_row = 0;
if (i > mouse_y) {
openfile->current = openfile->current->prev;
openfile->current_x = actual_x(openfile->current->data, mouse_x + (mouse_y - openfile->current_y) * COLS);
#ifdef DEBUG
fprintf(stderr, "do_mouse(): i > mouse_y, mouse_x = %d, current_x to = %lu\n",
mouse_x, (unsigned long)openfile->current_x);
#endif
} else {
openfile->current_x = actual_x(openfile->current->data, mouse_x);
#ifdef DEBUG
fprintf(stderr, "do_mouse(): i <= mouse_y, mouse_x = %d, setting current_x to = %lu\n",
mouse_x, (unsigned long)openfile->current_x);
#endif
openfile->current = openfile->edittop;
while (openfile->current->next != NULL && current_row < mouse_y) {
current_row += strlenpt(openfile->current->data) / editwincols + 1;
openfile->current = openfile->current->next;
}
if (current_row > mouse_y) {
openfile->current = openfile->current->prev;
current_row -= strlenpt(openfile->current->data) / editwincols + 1;
openfile->current_x = actual_x(openfile->current->data,
((mouse_y - current_row) * editwincols) + mouse_x);
} else
openfile->current_x = actual_x(openfile->current->data, mouse_x);
openfile->current_y = current_row;
ensure_line_is_visible();
refresh_needed = TRUE;
} else
#endif /* NANO_TINY */
{
ssize_t current_row = openfile->current_y;
/* Move to where the click occurred. */
for (; openfile->current_y < mouse_y && openfile->current !=
openfile->filebot; openfile->current_y++)
while (current_row < mouse_y && openfile->current->next != NULL) {
openfile->current = openfile->current->next;
for (; openfile->current_y > mouse_y && openfile->current !=
openfile->fileage; openfile->current_y--)
current_row++;
}
while (current_row > mouse_y && openfile->current->prev != NULL) {
openfile->current = openfile->current->prev;
current_row--;
}
openfile->current_x = actual_x(openfile->current->data,
get_page_start(xplustabs()) + mouse_x);
get_page_start(xplustabs()) + mouse_x);
}
#ifndef NANO_TINY
/* Clicking where the cursor is toggles the mark, as does
* clicking beyond the line length with the cursor at the end of
* the line. */
/* Clicking where the cursor is toggles the mark, as does clicking
* beyond the line length with the cursor at the end of the line. */
if (sameline && openfile->current_x == current_x_save)
do_mark();
else
@@ -1832,7 +1795,8 @@ int do_mouse(void)
/* The cursor moved; clean the cutbuffer on the next cut. */
cutbuffer_reset();
edit_redraw(current_save);
if (!ISSET(SOFTWRAP))
edit_redraw(current_save);
}
/* No more handling is needed. */
@@ -1849,11 +1813,8 @@ void do_output(char *output, size_t output_len, bool allow_cntrls)
#ifndef NANO_TINY
size_t orig_lenpt = 0;
#endif
char *char_buf = charalloc(mb_cur_max());
int char_buf_len;
assert(openfile->current != NULL && openfile->current->data != NULL);
int char_len;
current_len = strlen(openfile->current->data);
@@ -1863,42 +1824,37 @@ void do_output(char *output, size_t output_len, bool allow_cntrls)
#endif
while (i < output_len) {
/* If control codes are allowed, encode a verbatim null as a newline,
* and let a verbatim ^J create a whole new line. */
if (allow_cntrls) {
if (output[i] == '\0')
output[i] = '\n';
else if (output[i] == '\n') {
do_enter();
i++;
continue;
}
}
/* Encode an embedded NUL byte as 0x0A. */
if (output[i] == '\0')
output[i] = '\n';
/* Get the next multibyte character. */
char_buf_len = parse_mbchar(output + i, char_buf, NULL);
char_len = parse_mbchar(output + i, char_buf, NULL);
i += char_buf_len;
i += char_len;
/* If controls are not allowed, ignore an ASCII control character. */
if (!allow_cntrls && is_ascii_cntrl_char(*(output + i - char_buf_len)))
if (!allow_cntrls && is_ascii_cntrl_char(*(output + i - char_len)))
continue;
/* If we're adding to the magicline, create a new magicline. */
if (!ISSET(NO_NEWLINES) && openfile->filebot == openfile->current)
if (!ISSET(NO_NEWLINES) && openfile->filebot == openfile->current) {
new_magicline();
if (margin > 0)
refresh_needed = TRUE;
}
assert(openfile->current_x <= current_len);
/* Make room for the new character and copy it into the line. */
openfile->current->data = charealloc(openfile->current->data,
current_len + char_buf_len + 1);
charmove(openfile->current->data + openfile->current_x + char_buf_len,
current_len + char_len + 1);
charmove(openfile->current->data + openfile->current_x + char_len,
openfile->current->data + openfile->current_x,
current_len - openfile->current_x + 1);
strncpy(openfile->current->data + openfile->current_x, char_buf,
char_buf_len);
current_len += char_buf_len;
char_len);
current_len += char_len;
openfile->totsize++;
set_modified();
@@ -1908,28 +1864,29 @@ void do_output(char *output, size_t output_len, bool allow_cntrls)
/* Note that current_x has not yet been incremented. */
if (openfile->mark_set && openfile->current == openfile->mark_begin &&
openfile->current_x < openfile->mark_begin_x)
openfile->mark_begin_x += char_buf_len;
openfile->mark_begin_x += char_len;
#endif
openfile->current_x += char_buf_len;
openfile->current_x += char_len;
#ifndef NANO_TINY
update_undo(ADD);
#endif
#ifndef DISABLE_WRAPPING
/* If we're wrapping text, we need to call edit_refresh(). */
if (!ISSET(NO_WRAP))
if (do_wrap(openfile->current))
refresh_needed = TRUE;
/* If text gets wrapped, the edit window needs a refresh. */
if (!ISSET(NO_WRAP) && do_wrap(openfile->current))
refresh_needed = TRUE;
#endif
}
#ifndef NANO_TINY
/* Well, we might also need a full refresh if we've changed the
* line length to be a new multiple of COLS. */
ensure_line_is_visible();
/* If the number of screen rows that a softwrapped line occupies
* has changed, we need a full refresh. */
if (ISSET(SOFTWRAP) && refresh_needed == FALSE)
if (strlenpt(openfile->current->data) / COLS != orig_lenpt / COLS)
if (strlenpt(openfile->current->data) / editwincols != orig_lenpt / editwincols)
refresh_needed = TRUE;
#endif
@@ -1941,10 +1898,7 @@ void do_output(char *output, size_t output_len, bool allow_cntrls)
reset_multis(openfile->current, FALSE);
#endif
if (refresh_needed == TRUE) {
edit_refresh();
refresh_needed = FALSE;
} else
if (!refresh_needed)
update_line(openfile->current, openfile->current_x);
}
@@ -1989,7 +1943,13 @@ int main(int argc, char **argv)
#endif
{"constantshow", 0, NULL, 'c'},
{"rebinddelete", 0, NULL, 'd'},
#ifndef DISABLE_BROWSER
{"showcursor", 0, NULL, 'g'},
#endif
{"help", 0, NULL, 'h'},
#ifdef ENABLE_LINENUMBERS
{"linenumbers", 0, NULL, 'l'},
#endif
#ifndef DISABLE_MOUSE
{"mouse", 0, NULL, 'm'},
#endif
@@ -2068,6 +2028,10 @@ int main(int argc, char **argv)
SET(NO_WRAP);
#endif
/* If the executable's name starts with 'r', activate restricted mode. */
if (*(tail(argv[0])) == 'r')
SET(RESTRICTED);
while ((optchr =
#ifdef HAVE_GETOPT_LONG
getopt_long(argc, argv,
@@ -2083,7 +2047,6 @@ int main(int argc, char **argv)
case 'b':
case 'e':
case 'f':
case 'g':
case 'j':
/* Pico compatibility flags. */
break;
@@ -2192,6 +2155,9 @@ int main(int argc, char **argv)
case 'd':
SET(REBIND_DELETE);
break;
case 'g':
SET(SHOW_CURSOR);
break;
#ifndef NANO_TINY
case 'i':
SET(AUTOINDENT);
@@ -2268,6 +2234,11 @@ int main(int argc, char **argv)
case '$':
SET(SOFTWRAP);
break;
#endif
#ifdef ENABLE_LINENUMBERS
case 'l':
SET(LINE_NUMBERS);
break;
#endif
case 'h':
usage();
@@ -2278,11 +2249,6 @@ int main(int argc, char **argv)
}
}
/* If the executable filename starts with 'r', enable restricted
* mode. */
if (*(tail(argv[0])) == 'r')
SET(RESTRICTED);
/* If we're using restricted mode, disable suspending, backups,
* rcfiles, and history files, since they all would allow reading
* from or writing to files not specified on the command line. */
@@ -2341,7 +2307,7 @@ int main(int argc, char **argv)
alt_speller = NULL;
#endif
do_rcfile();
do_rcfiles();
#ifdef DEBUG
fprintf(stderr, "After rebinding keys...\n");
@@ -2527,7 +2493,7 @@ int main(int argc, char **argv)
/* Set up the terminal state. */
terminal_init();
#if defined(__linux__) && !defined(NANO_TINY)
#ifdef __linux__
/* Check whether we're running on a Linux console. */
console = (getenv("DISPLAY") == NULL);
#endif
@@ -2540,6 +2506,8 @@ int main(int argc, char **argv)
* dimensions. */
window_init();
editwincols = COLS;
/* Set up the signal handlers. */
signal_init();
@@ -2552,17 +2520,18 @@ int main(int argc, char **argv)
set_colorpairs();
#else
interface_color_pair[TITLE_BAR] = hilite_attribute;
interface_color_pair[LINE_NUMBER] = hilite_attribute;
interface_color_pair[STATUS_BAR] = hilite_attribute;
interface_color_pair[KEY_COMBO] = hilite_attribute;
interface_color_pair[FUNCTION_TAG] = A_NORMAL;
#endif
#if !defined(NANO_TINY) && defined(HAVE_KEY_DEFINED)
/* Ask ncurses for the key codes for Control+Left/Right/Up/Down. */
controlleft = get_keycode("kLFT5", CONTROL_LEFT);
controlright = get_keycode("kRIT5", CONTROL_RIGHT);
controlup = get_keycode("kUP5", CONTROL_UP);
controldown = get_keycode("kDN5", CONTROL_DOWN);
#ifndef NANO_TINY
/* Ask for the codes for Shift+Control+Left/Right/Up/Down. */
shiftcontrolleft = get_keycode("kLFT6", SHIFT_CONTROL_LEFT);
shiftcontrolright = get_keycode("kRIT6", SHIFT_CONTROL_RIGHT);
@@ -2629,7 +2598,7 @@ int main(int argc, char **argv)
else if (ISSET(POS_HISTORY)) {
ssize_t savedposline, savedposcol;
/* If edited before, restore the last cursor position. */
if (check_poshistory(argv[i], &savedposline, &savedposcol))
if (has_old_position(argv[i], &savedposline, &savedposcol))
do_gotolinecolumn(savedposline, savedposcol,
FALSE, FALSE);
}
@@ -2663,7 +2632,7 @@ int main(int argc, char **argv)
else if (ISSET(POS_HISTORY)) {
ssize_t savedposline, savedposcol;
/* If the file was edited before, restore the last cursor position. */
if (check_poshistory(argv[optind], &savedposline, &savedposcol))
if (has_old_position(argv[optind], &savedposline, &savedposcol))
do_gotolinecolumn(savedposline, savedposcol, FALSE, FALSE);
}
#endif
@@ -2675,26 +2644,50 @@ int main(int argc, char **argv)
display_buffer();
while (TRUE) {
#ifdef ENABLE_LINENUMBERS
int needed_margin = digits(openfile->filebot->lineno) + 1;
/* Only enable line numbers when there is enough room for them. */
if (ISSET(LINE_NUMBERS) && needed_margin < COLS - 3) {
if (needed_margin != margin) {
margin = needed_margin;
editwincols = COLS - margin;
/* The margin has changed -- schedule a full refresh. */
refresh_needed = TRUE;
}
} else
#endif
{
margin = 0;
editwincols = COLS;
}
if (currmenu != MMAIN)
display_main_list();
focusing = TRUE;
lastmessage = HUSH;
as_an_at = TRUE;
/* If constant cursor position display is on, and there are no
* keys waiting in the input buffer, display the current cursor
* position on the statusbar. */
/* Update the displayed current cursor position only when there
* are no keys waiting in the input buffer. */
if (ISSET(CONST_UPDATE) && get_key_buffer_len() == 0)
do_cursorpos(TRUE);
/* Refresh just the cursor position or the entire edit window. */
if (!refresh_needed) {
reset_cursor();
wnoutrefresh(edit);
} else
edit_refresh();
/* Make sure the cursor is visible. */
curs_set(1);
focusing = TRUE;
/* Forget any earlier statusbar x position. */
reinit_statusbar_x();
/* Place the cursor in the edit window and make it visible. */
reset_cursor();
curs_set(1);
wnoutrefresh(edit);
/* Read in and interpret keystrokes. */
do_input(TRUE);
}

View File

@@ -4,7 +4,7 @@
* Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, *
* 2008, 2009, 2010, 2011, 2013, 2014 Free Software Foundation, Inc. *
* Copyright (C) 2014, 2015, 2016 Benno Schulenberg *
*
* *
* GNU nano is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published *
* by the Free Software Foundation, either version 3 of the License, *
@@ -451,11 +451,13 @@ typedef struct sc {
/* Which menus this applies to. */
void (*scfunc)(void);
/* The function we're going to run. */
#ifndef NANO_TINY
int toggle;
/* If a toggle, what we're toggling. */
int ordinal;
/* The how-manieth toggle this is, in order to be able to
* keep them in sequence. */
#endif
struct sc *next;
/* Next in the list. */
} sc;
@@ -482,10 +484,18 @@ typedef struct subnfunc {
/* Next item in the list. */
} subnfunc;
#ifdef ENABLE_WORDCOMPLETION
typedef struct completion_word {
char *word;
struct completion_word *next;
} completion_word;
#endif
/* The elements of the interface that can be colored differently. */
enum
{
TITLE_BAR = 0,
LINE_NUMBER,
STATUS_BAR,
KEY_COMBO,
FUNCTION_TAG,
@@ -533,7 +543,9 @@ enum
LOCKING,
NOREAD_MODE,
MAKE_IT_UNIX,
JUSTIFY_TRIM
JUSTIFY_TRIM,
SHOW_CURSOR,
LINE_NUMBERS
};
/* Flags for the menus in which a given function should be present. */

View File

@@ -34,10 +34,8 @@ static size_t statusbar_x = HIGHEST_POSITIVE;
/* Read in a keystroke, interpret it if it is a shortcut or toggle, and
* return it. Set ran_func to TRUE if we ran a function associated with
* a shortcut key, and set finished to TRUE if we're done after running
* or trying to run a function associated with a shortcut key.
* refresh_func is the function we will call to refresh the edit window. */
int do_statusbar_input(bool *ran_func, bool *finished,
void (*refresh_func)(void))
* or trying to run a function associated with a shortcut key. */
int do_statusbar_input(bool *ran_func, bool *finished)
{
int input;
/* The character we read in. */
@@ -106,7 +104,7 @@ int do_statusbar_input(bool *ran_func, bool *finished,
if ((have_shortcut || get_key_buffer_len() == 0) && kbinput != NULL) {
/* Inject all characters in the input buffer at once, filtering out
* control characters. */
do_statusbar_output(kbinput, kbinput_len, TRUE, NULL);
do_statusbar_output(kbinput, kbinput_len, TRUE);
/* Empty the input buffer. */
kbinput_len = 0;
@@ -117,10 +115,7 @@ int do_statusbar_input(bool *ran_func, bool *finished,
if (have_shortcut) {
if (s->scfunc == do_tab || s->scfunc == do_enter)
;
else if (s->scfunc == total_refresh) {
total_redraw();
refresh_func();
} else if (s->scfunc == do_left)
else if (s->scfunc == do_left)
do_statusbar_left();
else if (s->scfunc == do_right)
do_statusbar_right();
@@ -144,18 +139,7 @@ int do_statusbar_input(bool *ran_func, bool *finished,
s->scfunc == do_backspace))
;
else if (s->scfunc == do_verbatim_input) {
bool got_newline = FALSE;
/* Whether we got a verbatim ^J. */
do_statusbar_verbatim_input(&got_newline);
/* If we got a verbatim ^J, remove it from the input buffer,
* fake a press of Enter, and indicate that we're done. */
if (got_newline) {
get_input(NULL, 1);
input = sc_seq_or(do_enter, 0);
*finished = TRUE;
}
do_statusbar_verbatim_input();
} else if (s->scfunc == do_cut_text_void)
do_statusbar_cut_text();
else if (s->scfunc == do_delete)
@@ -207,11 +191,10 @@ int do_statusbar_mouse(void)
}
#endif
/* The user typed input_len multibyte characters. Add them to the
* statusbar prompt, setting got_newline to TRUE if we got a verbatim ^J,
* and filtering out ASCII control characters if filtering is TRUE. */
/* The user typed input_len multibyte characters. Add them to the answer,
* filtering out ASCII control characters if filtering is TRUE. */
void do_statusbar_output(int *the_input, size_t input_len,
bool filtering, bool *got_newline)
bool filtering)
{
char *output = charalloc(input_len + 1);
char *char_buf = charalloc(mb_cur_max());
@@ -225,18 +208,9 @@ void do_statusbar_output(int *the_input, size_t input_len,
i = 0;
while (i < input_len) {
/* When not filtering, convert nulls and stop at a newline. */
if (!filtering) {
if (output[i] == '\0')
output[i] = '\n';
else if (output[i] == '\n') {
/* Put back the rest of the characters for reparsing,
* indicate that we got a ^J and get out. */
unparse_kbinput(output + i, input_len - i);
*got_newline = TRUE;
return;
}
}
/* Encode any NUL byte as 0x0A. */
if (output[i] == '\0')
output[i] = '\n';
/* Interpret the next multibyte character. */
char_len = parse_mbchar(output + i, char_buf, NULL);
@@ -311,7 +285,6 @@ void do_statusbar_delete(void)
charmove(answer + statusbar_x, answer + statusbar_x + char_len,
strlen(answer) - statusbar_x - char_len + 1);
align(&answer);
update_the_statusbar();
}
@@ -375,19 +348,15 @@ void do_statusbar_prev_word(void)
}
#endif /* !NANO_TINY */
/* Get verbatim input, setting got_newline to TRUE if we get a ^J as
* part of the verbatim input. */
void do_statusbar_verbatim_input(bool *got_newline)
/* Get verbatim input and inject it into the answer, without filtering. */
void do_statusbar_verbatim_input(void)
{
int *kbinput;
size_t kbinput_len;
/* Read in all the verbatim characters. */
kbinput = get_verbatim_kbinput(bottomwin, &kbinput_len);
/* Display all the verbatim characters at once, not filtering out
* control characters. */
do_statusbar_output(kbinput, kbinput_len, FALSE, got_newline);
do_statusbar_output(kbinput, kbinput_len, FALSE);
}
/* Return the zero-based column position of the cursor in the answer. */
@@ -464,9 +433,7 @@ void update_the_statusbar(void)
/* Get a string of input at the statusbar prompt. */
functionptrtype acquire_an_answer(int *actual, bool allow_tabs,
#ifndef DISABLE_TABCOMP
bool allow_files, bool *listed,
#endif
#ifndef DISABLE_HISTORIES
filestruct **history_list,
#endif
@@ -511,7 +478,7 @@ functionptrtype acquire_an_answer(int *actual, bool allow_tabs,
/* Ensure the cursor is shown when waiting for input. */
curs_set(1);
kbinput = do_statusbar_input(&ran_func, &finished, refresh_func);
kbinput = do_statusbar_input(&ran_func, &finished);
#ifndef NANO_TINY
/* If the window size changed, go reformat the prompt string. */
@@ -537,7 +504,7 @@ functionptrtype acquire_an_answer(int *actual, bool allow_tabs,
if (func == do_tab) {
#ifndef DISABLE_HISTORIES
if (history_list != NULL) {
if (last_kbinput != sc_seq_or(do_tab, TAB_CODE))
if (last_kbinput != the_code_for(do_tab, TAB_CODE))
complete_len = strlen(answer);
if (complete_len > 0) {
@@ -644,10 +611,7 @@ functionptrtype acquire_an_answer(int *actual, bool allow_tabs,
* The allow_tabs parameter indicates whether we should allow tabs to be
* interpreted. The allow_files parameter indicates whether we should
* allow all files (as opposed to just directories) to be tab completed. */
int do_prompt(bool allow_tabs,
#ifndef DISABLE_TABCOMP
bool allow_files,
#endif
int do_prompt(bool allow_tabs, bool allow_files,
int menu, const char *curranswer,
#ifndef DISABLE_HISTORIES
filestruct **history_list,
@@ -657,9 +621,7 @@ int do_prompt(bool allow_tabs,
va_list ap;
int retval;
functionptrtype func = NULL;
#ifndef DISABLE_TABCOMP
bool listed = FALSE;
#endif
/* Save a possible current statusbar x position. */
size_t was_statusbar_x = statusbar_x;
@@ -677,10 +639,7 @@ int do_prompt(bool allow_tabs,
/* Reserve five columns for colon plus angles plus answer, ":<aa>". */
null_at(&prompt, actual_x(prompt, (COLS < 5) ? 0 : COLS - 5));
func = acquire_an_answer(&retval, allow_tabs,
#ifndef DISABLE_TABCOMP
allow_files, &listed,
#endif
func = acquire_an_answer(&retval, allow_tabs, allow_files, &listed,
#ifndef DISABLE_HISTORIES
history_list,
#endif
@@ -729,30 +688,22 @@ int do_prompt(bool allow_tabs,
int do_yesno_prompt(bool all, const char *msg)
{
int response = -2, width = 16;
const char *yesstr; /* String of Yes characters accepted. */
const char *nostr; /* Same for No. */
const char *allstr; /* And All, surprise! */
int oldmenu = currmenu;
char *message = display_string(msg, 0, COLS, FALSE);
assert(msg != NULL);
/* yesstr, nostr, and allstr are strings of any length. Each string
* consists of all single-byte characters accepted as valid
* characters for that value. The first value will be the one
* displayed in the shortcuts. */
/* TRANSLATORS: For the next three strings, if possible, specify
* the single-byte shortcuts for both your language and English.
* For example, in French: "OoYy" for "Oui". */
yesstr = _("Yy");
nostr = _("Nn");
allstr = _("Aa");
* For example, in French: "OoYy", for both "Oui" and "Yes". */
const char *yesstr = _("Yy");
const char *nostr = _("Nn");
const char *allstr = _("Aa");
do {
/* The above three variables consist of all the single-byte characters
* that are accepted for the corresponding answer. Of each variable,
* the first character is displayed in the help lines. */
while (response == -2) {
int kbinput;
functionptrtype func;
#ifndef DISABLE_MOUSE
int mouse_x, mouse_y;
#endif
if (!ISSET(NO_HELP)) {
char shortstr[3];
@@ -783,31 +734,28 @@ int do_yesno_prompt(bool all, const char *msg)
onekey("^C", _("Cancel"), width);
}
/* Color the statusbar over its full width and display the question. */
wattron(bottomwin, interface_color_pair[TITLE_BAR]);
blank_statusbar();
mvwaddnstr(bottomwin, 0, 0, msg, actual_x(msg, COLS - 1));
mvwaddnstr(bottomwin, 0, 0, message, actual_x(message, COLS - 1));
wattroff(bottomwin, interface_color_pair[TITLE_BAR]);
/* Refresh edit window and statusbar before getting input. */
wnoutrefresh(edit);
wnoutrefresh(bottomwin);
/* When not replacing, show the cursor. */
if (!all)
curs_set(1);
currmenu = MYESNO;
kbinput = get_kbinput(bottomwin);
#ifndef NANO_TINY
if (kbinput == KEY_WINCH)
continue;
#endif
func = func_from_key(&kbinput);
if (func == do_cancel)
response = -1;
#ifndef DISABLE_MOUSE
else if (kbinput == KEY_MOUSE) {
int mouse_x, mouse_y;
/* We can click on the Yes/No/All shortcuts to select an answer. */
if (get_mouseinput(&mouse_x, &mouse_y, FALSE) == 0 &&
wmouse_trafo(bottomwin, &mouse_y, &mouse_x, FALSE) &&
@@ -828,10 +776,7 @@ int do_yesno_prompt(bool all, const char *msg)
}
}
#endif /* !DISABLE_MOUSE */
else if (func == total_refresh) {
total_redraw();
continue;
} else {
else {
/* Look for the kbinput in the Yes, No (and All) strings. */
if (strchr(yesstr, kbinput) != NULL)
response = 1;
@@ -840,10 +785,9 @@ int do_yesno_prompt(bool all, const char *msg)
else if (all && strchr(allstr, kbinput) != NULL)
response = 2;
}
} while (response == -2);
}
/* Restore the previously active menu. */
bottombars(oldmenu);
free(message);
return response;
}

View File

@@ -26,10 +26,10 @@
/* All external variables. See global.c for their descriptions. */
#ifndef NANO_TINY
extern volatile sig_atomic_t sigwinch_counter;
extern volatile sig_atomic_t the_window_resized;
#endif
#if defined(__linux__) && !defined(NANO_TINY)
#ifdef __linux__
extern bool console;
#endif
@@ -38,13 +38,20 @@ extern bool shift_held;
extern bool focusing;
extern bool as_an_at;
extern int margin;
extern int editwincols;
extern message_type lastmessage;
#ifndef NANO_TINY
extern filestruct *pletion_line;
extern int controlleft;
extern int controlright;
extern int controlup;
extern int controldown;
#ifndef NANO_TINY
extern int shiftcontrolleft;
extern int shiftcontrolright;
extern int shiftcontrolup;
@@ -73,9 +80,6 @@ extern int maxrows;
extern filestruct *cutbuffer;
extern filestruct *cutbottom;
#ifndef DISABLE_JUSTIFY
extern filestruct *jusbuffer;
#endif
extern partition *filepart;
extern openfilestruct *openfile;
@@ -205,7 +209,7 @@ bool is_cntrl_mbchar(const char *c);
bool is_punct_mbchar(const char *c);
bool is_word_mbchar(const char *c, bool allow_punct);
char control_rep(const signed char c);
char control_mbrep(const char *c);
char control_mbrep(const char *c, bool isdata);
int length_of_char(const char *c, int *width);
int mbwidth(const char *c);
int mb_cur_max(void);
@@ -225,16 +229,12 @@ int mbstrncasecmp(const char *s1, const char *s2, size_t n);
char *nstrcasestr(const char *haystack, const char *needle);
#endif
char *mbstrcasestr(const char *haystack, const char *needle);
#if !defined(NANO_TINY) || !defined(DISABLE_TABCOMP)
char *revstrstr(const char *haystack, const char *needle, const char
*rev_start);
#endif
#ifndef NANO_TINY
char *revstrstr(const char *haystack, const char *needle,
const char *pointer);
char *revstrcasestr(const char *haystack, const char *needle, const char
*rev_start);
char *mbrevstrcasestr(const char *haystack, const char *needle, const
char *rev_start);
#endif
size_t mbstrlen(const char *s);
#ifndef HAVE_STRNLEN
size_t nstrnlen(const char *s, size_t maxlen);
@@ -276,17 +276,11 @@ void cutbuffer_reset(void);
bool keeping_cutbuffer(void);
void cut_line(void);
#ifndef NANO_TINY
void cut_marked(void);
void cut_marked(bool *right_side_up);
void cut_to_eol(void);
void cut_to_eof(void);
#endif
void do_cut_text(
#ifndef NANO_TINY
bool copy_text, bool cut_till_eof
#else
void
#endif
);
void do_cut_text(bool copy_text, bool cut_till_eof);
void do_cut_text_void(void);
#ifndef NANO_TINY
void do_copy_text(void);
@@ -311,13 +305,6 @@ filestruct *read_line(char *buf, size_t buf_len, filestruct *prevnode);
void read_file(FILE *f, int fd, const char *filename, bool undoable, bool checkwritable);
int open_file(const char *filename, bool newfie, bool quiet, FILE **f);
char *get_next_filename(const char *name, const char *suffix);
void do_insertfile(
#ifndef NANO_TINY
bool execute
#else
void
#endif
);
void do_insertfile_void(void);
char *get_full_path(const char *origpath);
char *check_writable_directory(const char *path);
@@ -361,21 +348,21 @@ const char *tail(const char *path);
#ifndef DISABLE_HISTORIES
char *histfilename(void);
void load_history(void);
bool writehist(FILE *hist, filestruct *histhead);
bool writehist(FILE *hist, const filestruct *head);
void save_history(void);
int check_dotnano(void);
void load_poshistory(void);
void save_poshistory(void);
void update_poshistory(char *filename, ssize_t lineno, ssize_t xpos);
int check_poshistory(const char *file, ssize_t *line, ssize_t *column);
bool has_old_position(const char *file, ssize_t *line, ssize_t *column);
#endif
/* Some functions in global.c. */
size_t length_of_list(int menu);
const sc *first_sc_for(int menu, void (*func)(void));
int sc_seq_or(void (*func)(void), int defaultval);
int the_code_for(void (*func)(void), int defaultval);
functionptrtype func_from_key(int *kbinput);
void assign_keyinfo(sc *s, const char *keystring);
void assign_keyinfo(sc *s, const char *keystring, const int keycode);
void print_sclist(void);
void shortcut_init(void);
#ifndef DISABLE_COLOR
@@ -410,14 +397,13 @@ void do_para_begin_void(void);
void do_para_end(bool allow_update);
void do_para_end_void(void);
#endif
#ifndef NANO_TINY
void do_prev_block(void);
void do_next_block(void);
void do_prev_word(bool allow_punct, bool allow_update);
void do_prev_word_void(void);
bool do_next_word(bool allow_punct, bool allow_update);
void do_next_word_void(void);
#endif
void ensure_line_is_visible(void);
void do_home(void);
void do_end(void);
void do_up(bool scroll_only);
@@ -470,7 +456,6 @@ void print_opt_full(const char *shortflag
, const char *desc);
void usage(void);
void version(void);
void no_current_file_name_warning(void);
void do_exit(void);
void close_and_go(void);
void signal_init(void);
@@ -482,13 +467,7 @@ RETSIGTYPE handle_sigwinch(int signal);
void regenerate_screen(void);
void allow_sigwinch(bool allow);
void do_toggle(int flag);
#endif
void do_toggle_void(void);
void disable_extended_io(void);
#ifdef USE_SLANG
void disable_signals(void);
#endif
#ifndef NANO_TINY
void enable_signals(void);
#endif
void disable_flow_control(void);
@@ -501,14 +480,12 @@ int do_mouse(void);
#endif
void do_output(char *output, size_t output_len, bool allow_cntrls);
/* All functions in prompt.c. */
int do_statusbar_input(bool *ran_func, bool *finished,
void (*refresh_func)(void));
/* Most functions in prompt.c. */
#ifndef DISABLE_MOUSE
int do_statusbar_mouse(void);
#endif
void do_statusbar_output(int *the_input, size_t input_len,
bool filtering, bool *got_newline);
bool filtering);
void do_statusbar_home(void);
void do_statusbar_end(void);
void do_statusbar_left(void);
@@ -520,16 +497,13 @@ void do_statusbar_cut_text(void);
void do_statusbar_prev_word(void);
void do_statusbar_next_word(void);
#endif
void do_statusbar_verbatim_input(bool *got_newline);
void do_statusbar_verbatim_input(void);
size_t statusbar_xplustabs(void);
size_t get_statusbar_page_start(size_t start_col, size_t column);
void reinit_statusbar_x(void);
void reset_statusbar_cursor(void);
void update_the_statusbar(void);
int do_prompt(bool allow_tabs,
#ifndef DISABLE_TABCOMP
bool allow_files,
#endif
int do_prompt(bool allow_tabs, bool allow_files,
int menu, const char *curranswer,
#ifndef DISABLE_HISTORIES
filestruct **history_list,
@@ -542,22 +516,12 @@ int do_yesno_prompt(bool all, const char *msg);
char *parse_next_word(char *ptr);
#endif
#ifndef DISABLE_NANORC
void rcfile_error(const char *msg, ...);
char *parse_argument(char *ptr);
#ifndef DISABLE_COLOR
char *parse_next_regex(char *ptr);
void parse_syntax(char *ptr);
void parse_includes(char *ptr);
short color_to_short(const char *colorname, bool *bright);
bool parse_color_names(char *combostr, short *fg, short *bg, bool *bright);
void grab_and_store(const char *kind, char *ptr, regexlisttype **storage);
#endif
void parse_rcfile(FILE *rcstream
#ifndef DISABLE_COLOR
, bool syntax_only
#endif
);
void do_rcfile(void);
void parse_rcfile(FILE *rcstream, bool syntax_only);
void do_rcfiles(void);
#endif /* !DISABLE_NANORC */
/* All functions in search.c. */
@@ -568,31 +532,21 @@ void regexp_cleanup(void);
void not_found_msg(const char *str);
void search_replace_abort(void);
int search_init(bool replacing, bool use_answer);
int findnextstr(
#ifndef DISABLE_SPELLER
bool whole_word_only,
#endif
const filestruct *begin, size_t begin_x,
const char *needle, size_t *match_len);
int findnextstr(const char *needle, bool whole_word_only, size_t *match_len,
const filestruct *begin, size_t begin_x);
void do_search(void);
#ifndef NANO_TINY
void do_findprevious(void);
void do_findnext(void);
#endif
#if !defined(NANO_TINY) || !defined(DISABLE_BROWSER)
void do_research(void);
#endif
void go_looking(void);
#ifdef HAVE_REGEX_H
int replace_regexp(char *string, bool create);
#endif
char *replace_line(const char *needle);
ssize_t do_replace_loop(
#ifndef DISABLE_SPELLER
bool whole_word_only,
#endif
const filestruct *real_current, size_t *real_current_x,
const char *needle);
ssize_t do_replace_loop(const char *needle, bool whole_word_only,
const filestruct *real_current, size_t *real_current_x);
void do_replace(void);
void goto_line_posx(ssize_t line, size_t pos_x);
void do_gotolinecolumn(ssize_t line, ssize_t column, bool use_answer,
@@ -633,18 +587,25 @@ void do_tab(void);
void do_indent(ssize_t cols);
void do_indent_void(void);
void do_unindent(void);
#endif
bool white_string(const char *s);
#ifdef ENABLE_COMMENT
void do_comment(void);
bool comment_line(undo_type action, filestruct *f, const char *comment_seq);
#endif
void do_undo(void);
void do_redo(void);
#endif
#ifndef DISABLE_COMMENT
void do_comment(void);
#endif
void do_enter(void);
#ifndef NANO_TINY
RETSIGTYPE cancel_command(int signal);
bool execute_command(const char *command);
void discard_until(const undo *thisitem, openfilestruct *thefile);
void add_undo(undo_type action);
#ifndef DISABLE_COMMENT
void update_comment_undo(ssize_t lineno);
#endif
void update_undo(undo_type action);
#endif /* !NANO_TINY */
#ifndef DISABLE_WRAPPING
void wrap_reset(void);
bool do_wrap(filestruct *line);
@@ -688,12 +649,16 @@ void do_formatter(void);
void do_wordlinechar_count(void);
#endif
void do_verbatim_input(void);
void complete_a_word(void);
/* All functions in utils.c. */
void get_homedir(void);
#ifdef ENABLE_LINENUMBERS
int digits(ssize_t n);
#endif
bool parse_num(const char *str, ssize_t *val);
bool parse_line_column(const char *str, ssize_t *line, ssize_t *column);
void align(char **str);
void snuggly_fit(char **str);
void null_at(char **data, size_t index);
void unsunder(char *str, size_t true_len);
void sunder(char *str);
@@ -729,16 +694,11 @@ void new_magicline(void);
void remove_magicline(void);
void mark_order(const filestruct **top, size_t *top_x, const filestruct
**bot, size_t *bot_x, bool *right_side_up);
void discard_until(const undo *thisitem, openfilestruct *thefile);
void add_undo(undo_type action);
void update_undo(undo_type action);
#ifndef DISABLE_COMMENT
void update_comment_undo(ssize_t lineno);
bool comment_line(undo_type action, filestruct *f, const char *comment_seq);
#endif
#endif
size_t get_totsize(const filestruct *begin, const filestruct *end);
#ifndef NANO_TINY
filestruct *fsfromline(ssize_t lineno);
#endif
#ifdef DEBUG
void dump_filestruct(const filestruct *inptr);
void dump_filestruct_reverse(void);
@@ -778,18 +738,19 @@ char *display_string(const char *buf, size_t start_col, size_t span,
void titlebar(const char *path);
extern void set_modified(void);
void statusbar(const char *msg);
void warn_and_shortly_pause(const char *msg);
void statusline(message_type importance, const char *msg, ...);
void bottombars(int menu);
void onekey(const char *keystroke, const char *desc, int length);
void reset_cursor(void);
void edit_draw(filestruct *fileptr, const char *converted, int
line, size_t start);
void edit_draw(filestruct *fileptr, const char *converted,
int line, size_t from_col);
int update_line(filestruct *fileptr, size_t index);
bool need_horizontal_scroll(const size_t old_column, const size_t new_column);
void edit_scroll(scroll_dir direction, ssize_t nlines);
void edit_redraw(filestruct *old_current);
void edit_refresh(void);
void edit_update(update_type location);
void adjust_viewport(update_type location);
void total_redraw(void);
void total_refresh(void);
void display_main_list(void);

View File

@@ -33,8 +33,15 @@
#ifndef DISABLE_NANORC
#ifndef RCFILE_NAME
#define RCFILE_NAME ".nanorc"
#endif
static const rcoption rcopts[] = {
{"boldtext", BOLD_TEXT},
#ifdef ENABLE_LINENUMBERS
{"linenumbers", LINE_NUMBERS},
#endif
#ifndef DISABLE_JUSTIFY
{"brackets", 0},
#endif
@@ -96,6 +103,7 @@ static const rcoption rcopts[] = {
{"noconvert", NO_CONVERT},
{"quickblank", QUICK_BLANK},
{"quiet", QUIET},
{"showcursor", SHOW_CURSOR},
{"smarthome", SMART_HOME},
{"smooth", SMOOTH_SCROLL},
{"softwrap", SOFTWRAP},
@@ -107,6 +115,7 @@ static const rcoption rcopts[] = {
#endif
#ifndef DISABLE_COLOR
{"titlecolor", 0},
{"numbercolor", 0},
{"statuscolor", 0},
{"keycolor", 0},
{"functioncolor", 0},
@@ -343,9 +352,7 @@ bool is_universal(void (*func))
{
if (func == do_left || func == do_right ||
func == do_home || func == do_end ||
#ifndef NANO_TINY
func == do_prev_word_void || func == do_next_word_void ||
#endif
func == do_verbatim_input || func == do_cut_text_void ||
func == do_delete || func == do_backspace ||
func == do_tab || func == do_enter)
@@ -400,7 +407,12 @@ void parse_binding(char *ptr, bool dobind)
else if (keycopy[0] != '^' && keycopy[0] != 'M' && keycopy[0] != 'F') {
rcfile_error(N_("Key name must begin with \"^\", \"M\", or \"F\""));
goto free_copy;
} else if (keycopy[0] == '^' && (keycopy[1] < 64 || keycopy[1] > 127)) {
} else if ((keycopy[0] == 'M' && keycopy[1] != '-') ||
(keycopy[0] == '^' && ((keycopy[1] < 'A' || keycopy[1] > 'z') ||
keycopy[1] == '[' || keycopy[1] == '`' ||
(strlen(keycopy) > 2 && strcmp(keycopy, "^Space") != 0))) ||
(strlen(keycopy) > 3 && strcmp(keycopy, "^Space") != 0 &&
strcmp(keycopy, "M-Space") != 0)) {
rcfile_error(N_("Key name %s is invalid"), keycopy);
goto free_copy;
}
@@ -455,9 +467,11 @@ void parse_binding(char *ptr, bool dobind)
if (f->scfunc == newsc->scfunc)
mask = mask | f->menus;
#ifndef NANO_TINY
/* Handle the special case of the toggles. */
if (newsc->scfunc == do_toggle_void)
mask = MMAIN;
#endif
/* Now limit the given menu to those where the function exists. */
if (is_universal(newsc->scfunc))
@@ -472,7 +486,7 @@ void parse_binding(char *ptr, bool dobind)
}
newsc->menus = menu;
assign_keyinfo(newsc, keycopy);
assign_keyinfo(newsc, keycopy, 0);
/* Do not allow rebinding a frequent escape-sequence starter: Esc [. */
if (newsc->meta && newsc->keycode == 91) {
@@ -497,6 +511,7 @@ void parse_binding(char *ptr, bool dobind)
}
if (dobind) {
#ifndef NANO_TINY
/* If this is a toggle, copy its sequence number. */
if (newsc->scfunc == do_toggle_void) {
for (s = sclist; s != NULL; s = s->next)
@@ -504,6 +519,7 @@ void parse_binding(char *ptr, bool dobind)
newsc->ordinal = s->ordinal;
} else
newsc->ordinal = 0;
#endif
/* Add the new shortcut at the start of the list. */
newsc->next = sclist;
sclist = newsc;
@@ -514,35 +530,40 @@ void parse_binding(char *ptr, bool dobind)
free(keycopy);
}
/* Verify that the given file is not a folder nor a device. */
bool is_good_file(char *file)
{
struct stat rcinfo;
/* If the thing exists, it may not be a directory nor a device. */
if (stat(file, &rcinfo) != -1 && (S_ISDIR(rcinfo.st_mode) ||
S_ISCHR(rcinfo.st_mode) || S_ISBLK(rcinfo.st_mode))) {
rcfile_error(S_ISDIR(rcinfo.st_mode) ? _("\"%s\" is a directory") :
_("\"%s\" is a device file"), file);
return FALSE;
} else
return TRUE;
}
#ifndef DISABLE_COLOR
/* Read and parse one included syntax file. */
static void parse_one_include(char *file)
{
struct stat rcinfo;
FILE *rcstream;
/* Can't get the specified file's full path because it may screw up
* our cwd depending on the parent directories' permissions (see
* Savannah bug #25297). */
/* Don't open directories, character files, or block files. */
if (stat(file, &rcinfo) != -1) {
if (S_ISDIR(rcinfo.st_mode) || S_ISCHR(rcinfo.st_mode) ||
S_ISBLK(rcinfo.st_mode)) {
rcfile_error(S_ISDIR(rcinfo.st_mode) ?
_("\"%s\" is a directory") :
_("\"%s\" is a device file"), file);
}
}
if (!is_good_file(file))
return;
/* Open the new syntax file. */
if ((rcstream = fopen(file, "rb")) == NULL) {
rcfile_error(_("Error reading %s: %s"), file,
strerror(errno));
/* Open the included syntax file. */
rcstream = fopen(file, "rb");
if (rcstream == NULL) {
rcfile_error(_("Error reading %s: %s"), file, strerror(errno));
return;
}
/* Use the name and line number position of the new syntax file
/* Use the name and line number position of the included syntax file
* while parsing it, so we can know where any errors in it are. */
nanorc = file;
lineno = 0;
@@ -573,8 +594,7 @@ void parse_includes(char *ptr)
for (i = 0; i < files.gl_pathc; ++i)
parse_one_include(files.gl_pathv[i]);
} else
rcfile_error(_("Error expanding %s: %s"), option,
strerror(errno));
rcfile_error(_("Error expanding %s: %s"), option, strerror(errno));
globfree(&files);
free(expanded);
@@ -892,8 +912,8 @@ void pick_up_name(const char *kind, char *ptr, char **storage)
}
#endif /* !DISABLE_COLOR */
/* Check whether the user has unmapped every shortcut for a
* sequence we consider 'vital', like the exit function. */
/* Verify that the user has not unmapped every shortcut for a
* function that we consider 'vital' (such as "Exit"). */
static void check_vitals_mapped(void)
{
subnfunc *f;
@@ -920,13 +940,9 @@ static void check_vitals_mapped(void)
}
/* Parse the rcfile, once it has been opened successfully at rcstream,
* and close it afterwards. If syntax_only is TRUE, only allow the file
* to contain color syntax commands. */
void parse_rcfile(FILE *rcstream
#ifndef DISABLE_COLOR
, bool syntax_only
#endif
)
* and close it afterwards. If syntax_only is TRUE, allow the file to
* to contain only color syntax commands. */
void parse_rcfile(FILE *rcstream, bool syntax_only)
{
char *buf = NULL;
ssize_t len;
@@ -1103,13 +1119,15 @@ void parse_rcfile(FILE *rcstream
#endif
/* Make sure the option argument is a valid multibyte string. */
if (!is_valid_mbstring(option)) {
rcfile_error(N_("Option is not a valid multibyte string"));
rcfile_error(N_("Argument is not a valid multibyte string"));
continue;
}
#ifndef DISABLE_COLOR
if (strcasecmp(rcopts[i].name, "titlecolor") == 0)
specified_color_combo[TITLE_BAR] = option;
else if (strcasecmp(rcopts[i].name, "numbercolor") == 0)
specified_color_combo[LINE_NUMBER] = option;
else if (strcasecmp(rcopts[i].name, "statuscolor") == 0)
specified_color_combo[STATUS_BAR] = option;
else if (strcasecmp(rcopts[i].name, "keycolor") == 0)
@@ -1129,8 +1147,10 @@ void parse_rcfile(FILE *rcstream
rcfile_error(N_("Requested fill size \"%s\" is invalid"),
option);
wrap_at = -CHARS_FROM_EOL;
} else
} else {
UNSET(NO_WRAP);
free(option);
}
} else
#endif
#ifndef NANO_TINY
@@ -1209,45 +1229,43 @@ void parse_rcfile(FILE *rcstream
fclose(rcstream);
lineno = 0;
check_vitals_mapped();
return;
}
/* The main rcfile function. It tries to open the system-wide rcfile,
* followed by the current user's rcfile. */
void do_rcfile(void)
/* Read and interpret one of the two nanorc files. */
void parse_one_nanorc(void)
{
struct stat rcinfo;
FILE *rcstream;
nanorc = mallocstrcpy(nanorc, SYSCONFDIR "/nanorc");
/* Don't open directories, character files, or block files. */
if (stat(nanorc, &rcinfo) != -1) {
if (S_ISDIR(rcinfo.st_mode) || S_ISCHR(rcinfo.st_mode) ||
S_ISBLK(rcinfo.st_mode))
rcfile_error(S_ISDIR(rcinfo.st_mode) ?
_("\"%s\" is a directory") :
_("\"%s\" is a device file"), nanorc);
}
/* Don't try to open directories nor devices. */
if (!is_good_file(nanorc))
return;
#ifdef DEBUG
fprintf(stderr, "Parsing file \"%s\"\n", nanorc);
fprintf(stderr, "Going to parse file \"%s\"\n", nanorc);
#endif
/* Try to open the system-wide nanorc. */
rcstream = fopen(nanorc, "rb");
if (rcstream != NULL)
parse_rcfile(rcstream
#ifndef DISABLE_COLOR
, FALSE
#endif
);
/* If opening the file succeeded, parse it. Otherwise, only
* complain if the file actually exists. */
if (rcstream != NULL)
parse_rcfile(rcstream, FALSE);
else if (errno != ENOENT)
rcfile_error(N_("Error reading %s: %s"), nanorc, strerror(errno));
}
/* First read the system-wide rcfile, then the user's rcfile. */
void do_rcfiles(void)
{
nanorc = mallocstrcpy(nanorc, SYSCONFDIR "/nanorc");
/* Process the system-wide nanorc. */
parse_one_nanorc();
/* When configured with --disable-wrapping-as-root, turn wrapping off
* for root, so that only root's .nanorc or --fill can turn it on. */
#ifdef DISABLE_ROOTWRAPPING
/* We've already read SYSCONFDIR/nanorc, if it's there. If we're
* root, and --disable-wrapping-as-root is used, turn wrapping off
* now. */
if (geteuid() == NANO_ROOT_UID)
SET(NO_WRAP);
#endif
@@ -1257,38 +1275,16 @@ void do_rcfile(void)
if (homedir == NULL)
rcfile_error(N_("I can't find my home directory! Wah!"));
else {
#ifndef RCFILE_NAME
#define RCFILE_NAME ".nanorc"
#endif
nanorc = charealloc(nanorc, strlen(homedir) + strlen(RCFILE_NAME) + 2);
sprintf(nanorc, "%s/%s", homedir, RCFILE_NAME);
/* Don't open directories, character files, or block files. */
if (stat(nanorc, &rcinfo) != -1) {
if (S_ISDIR(rcinfo.st_mode) || S_ISCHR(rcinfo.st_mode) ||
S_ISBLK(rcinfo.st_mode))
rcfile_error(S_ISDIR(rcinfo.st_mode) ?
_("\"%s\" is a directory") :
_("\"%s\" is a device file"), nanorc);
}
/* Try to open the current user's nanorc. */
rcstream = fopen(nanorc, "rb");
if (rcstream == NULL) {
/* Don't complain about the file's not existing. */
if (errno != ENOENT)
rcfile_error(N_("Error reading %s: %s"), nanorc,
strerror(errno));
} else
parse_rcfile(rcstream
#ifndef DISABLE_COLOR
, FALSE
#endif
);
/* Process the current user's nanorc. */
parse_one_nanorc();
}
check_vitals_mapped();
free(nanorc);
nanorc = NULL;
if (errors && !ISSET(QUIET)) {
errors = FALSE;

View File

@@ -38,26 +38,22 @@ static bool history_changed = FALSE;
#ifdef HAVE_REGEX_H
static bool regexp_compiled = FALSE;
/* Have we compiled any regular expressions? */
static bool bow_anchored = FALSE;
/* Whether a regex starts with a beginning-of-word anchor. */
/* Compile the regular expression regexp to see if it's valid. Return
* TRUE if it is, or FALSE otherwise. */
/* Compile the given regular expression and store it in search_regexp.
* Return TRUE if the expression is valid, and FALSE otherwise. */
bool regexp_init(const char *regexp)
{
int rc;
int value = regcomp(&search_regexp, fixbounds(regexp),
NANO_REG_EXTENDED | (ISSET(CASE_SENSITIVE) ? 0 : REG_ICASE));
assert(!regexp_compiled);
rc = regcomp(&search_regexp, fixbounds(regexp), NANO_REG_EXTENDED
#ifndef NANO_TINY
| (ISSET(CASE_SENSITIVE) ? 0 : REG_ICASE)
#endif
);
if (rc != 0) {
size_t len = regerror(rc, &search_regexp, NULL, 0);
/* If regex compilation failed, show the error message. */
if (value != 0) {
size_t len = regerror(value, &search_regexp, NULL, 0);
char *str = charalloc(len);
regerror(rc, &search_regexp, str, len);
regerror(value, &search_regexp, str, len);
statusline(ALERT, _("Bad regex \"%s\": %s"), regexp, str);
free(str);
@@ -66,6 +62,10 @@ bool regexp_init(const char *regexp)
regexp_compiled = TRUE;
/* Remember whether the regex starts with a beginning-of-word anchor. */
bow_anchored = (strncmp(regexp, "\\<", 2) == 0 ||
strncmp(regexp, "\\b", 2) == 0);
return TRUE;
}
@@ -106,7 +106,7 @@ void search_replace_abort(void)
{
#ifndef NANO_TINY
if (openfile->mark_set)
edit_refresh();
refresh_needed = TRUE;
#endif
#ifdef HAVE_REGEX_H
regexp_cleanup();
@@ -153,29 +153,20 @@ int search_init(bool replacing, bool use_answer)
buf = mallocstrcpy(NULL, "");
/* This is now one simple call. It just does a lot. */
i = do_prompt(FALSE,
#ifndef DISABLE_TABCOMP
TRUE,
#endif
i = do_prompt(FALSE, FALSE,
replacing ? MREPLACE : MWHEREIS, backupstring,
#ifndef DISABLE_HISTORIES
&search_history,
#endif
/* TRANSLATORS: This is the main search prompt. */
edit_refresh, "%s%s%s%s%s%s", _("Search"),
#ifndef NANO_TINY
/* TRANSLATORS: The next three modify the search prompt. */
ISSET(CASE_SENSITIVE) ? _(" [Case Sensitive]") :
#endif
"",
ISSET(CASE_SENSITIVE) ? _(" [Case Sensitive]") : "",
#ifdef HAVE_REGEX_H
ISSET(USE_REGEXP) ? _(" [Regexp]") :
#endif
"",
#ifndef NANO_TINY
ISSET(BACKWARDS_SEARCH) ? _(" [Backwards]") :
#endif
"", replacing ?
ISSET(BACKWARDS_SEARCH) ? _(" [Backwards]") : "", replacing ?
#ifndef NANO_TINY
/* TRANSLATORS: The next two modify the search prompt. */
openfile->mark_set ? _(" (to replace) in selection") :
@@ -214,7 +205,6 @@ int search_init(bool replacing, bool use_answer)
func = func_from_key(&i);
#ifndef NANO_TINY
if (func == case_sens_void) {
TOGGLE(CASE_SENSITIVE);
backupstring = mallocstrcpy(backupstring, answer);
@@ -224,7 +214,6 @@ int search_init(bool replacing, bool use_answer)
backupstring = mallocstrcpy(backupstring, answer);
return 1;
} else
#endif
#ifdef HAVE_REGEX_H
if (func == regexp_void) {
TOGGLE(USE_REGEXP);
@@ -248,34 +237,31 @@ int search_init(bool replacing, bool use_answer)
* where we first started searching, at column begin_x. Return 1 when we
* found something, 0 when nothing, and -2 on cancel. When match_len is
* not NULL, set it to the length of the found string, if any. */
int findnextstr(
#ifndef DISABLE_SPELLER
bool whole_word_only,
#endif
const filestruct *begin, size_t begin_x,
const char *needle, size_t *match_len)
int findnextstr(const char *needle, bool whole_word_only, size_t *match_len,
const filestruct *begin, size_t begin_x)
{
size_t found_len;
/* The length of the match we find. */
size_t found_len = strlen(needle);
/* The length of a match -- will be recomputed for a regex. */
int feedback = 0;
/* When bigger than zero, show and wipe the "Searching..." message. */
filestruct *fileptr = openfile->current;
const char *rev_start = fileptr->data, *found = NULL;
filestruct *line = openfile->current;
const char *from = line->data, *found = NULL;
size_t found_x;
/* The x coordinate of a found occurrence. */
time_t lastkbcheck = time(NULL);
/* rev_start might end up 1 character before the start or after the
* end of the line. This won't be a problem because strstrwrapper()
/* 'from' might end up 1 character before the start or after the end
* of the line. This is fine because in that case strstrwrapper()
* will return immediately and say that no match was found, and
* rev_start will be properly set when the search continues on the
* 'from' will be properly set when the search continues on the
* previous or next line. */
rev_start +=
#ifndef NANO_TINY
ISSET(BACKWARDS_SEARCH) ?
((openfile->current_x == 0) ? -1 : move_mbleft(fileptr->data, openfile->current_x)) :
#endif
move_mbright(fileptr->data, openfile->current_x);
if (ISSET(BACKWARDS_SEARCH)) {
if (openfile->current_x == 0)
from += -1;
else
from += move_mbleft(line->data, openfile->current_x);
} else
from += move_mbright(line->data, openfile->current_x);
enable_nodelay();
@@ -307,32 +293,41 @@ int findnextstr(
}
/* Search for the needle in the current line. */
found = strstrwrapper(fileptr->data, needle, rev_start);
found = strstrwrapper(line->data, needle, from);
if (found != NULL) {
/* Remember the length of the potential match. */
found_len =
#ifdef HAVE_REGEX_H
ISSET(USE_REGEXP) ?
regmatches[0].rm_eo - regmatches[0].rm_so :
#endif
strlen(needle);
/* When doing a regex search, compute the length of the match. */
if (ISSET(USE_REGEXP)) {
found_len = regmatches[0].rm_eo - regmatches[0].rm_so;
#ifndef DISABLE_SPELLER
/* When we're spell checking, a match is only a true match when
* it is a separate word. */
if (whole_word_only) {
if (is_separate_word(found - fileptr->data, found_len,
fileptr->data))
break;
else {
/* Maybe there is a whole word in the rest of the line. */
rev_start = found + 1;
continue;
/* If the regex starts with a BOW anchor, check that the found
* match actually is the start of a word. If not, continue. */
if (bow_anchored && found != line->data) {
size_t before = move_mbleft(line->data, found - line->data);
/* If a word char is before the match, skip this match. */
if (is_word_mbchar(line->data + before, FALSE)) {
if (ISSET(BACKWARDS_SEARCH))
from = line->data + before;
else
from = found + move_mbright(found, 0);
continue;
}
}
} else
}
#endif
break;
#ifndef DISABLE_SPELLER
/* When we're spell checking, a match should be a separate word;
* if it's not, continue looking in the rest of the line. */
if (whole_word_only && !is_separate_word(found - line->data,
found_len, line->data)) {
from = found + move_mbright(found, 0);
continue;
}
#endif
/* The match is valid. */
break;
}
/* If we're back at the beginning, then there is no needle. */
@@ -343,15 +338,13 @@ int findnextstr(
}
/* Move to the previous or next line in the file. */
#ifndef NANO_TINY
if (ISSET(BACKWARDS_SEARCH))
fileptr = fileptr->prev;
line = line->prev;
else
#endif
fileptr = fileptr->next;
line = line->next;
/* If we've reached the start or end of the buffer, wrap around. */
if (fileptr == NULL) {
if (line == NULL) {
#ifndef DISABLE_SPELLER
/* When we're spell-checking, end-of-buffer means we're done. */
if (whole_word_only) {
@@ -359,12 +352,10 @@ int findnextstr(
return 0;
}
#endif
#ifndef NANO_TINY
if (ISSET(BACKWARDS_SEARCH))
fileptr = openfile->filebot;
line = openfile->filebot;
else
#endif
fileptr = openfile->fileage;
line = openfile->fileage;
statusbar(_("Search Wrapped"));
/* Delay the "Searching..." message for at least two seconds. */
@@ -372,28 +363,20 @@ int findnextstr(
}
/* If we've reached the original starting line, take note. */
if (fileptr == begin)
if (line == begin)
came_full_circle = TRUE;
/* Set the starting x to the start or end of the line. */
rev_start = fileptr->data;
#ifndef NANO_TINY
from = line->data;
if (ISSET(BACKWARDS_SEARCH))
rev_start += strlen(fileptr->data);
#endif
from += strlen(line->data);
}
found_x = found - fileptr->data;
found_x = found - line->data;
/* Ensure that the found occurrence is not beyond the starting x. */
if (came_full_circle &&
#ifndef NANO_TINY
((!ISSET(BACKWARDS_SEARCH) && found_x > begin_x) ||
(ISSET(BACKWARDS_SEARCH) && found_x < begin_x))
#else
found_x > begin_x
#endif
) {
if (came_full_circle && ((!ISSET(BACKWARDS_SEARCH) && found_x > begin_x) ||
(ISSET(BACKWARDS_SEARCH) && found_x < begin_x))) {
not_found_msg(needle);
disable_nodelay();
return 0;
@@ -402,9 +385,8 @@ int findnextstr(
disable_nodelay();
/* Set the current position to point at what we found. */
openfile->current = fileptr;
openfile->current = line;
openfile->current_x = found_x;
openfile->current_y = fileptr->lineno - openfile->edittop->lineno;
/* When requested, pass back the length of the match. */
if (match_len != NULL)
@@ -425,10 +407,8 @@ void do_search(void)
search_replace_abort();
else if (i == -2) /* Do a replace instead. */
do_replace();
#if !defined(NANO_TINY) || defined(HAVE_REGEX_H)
else if (i == 1) /* Toggled something. */
do_search();
#endif
if (i == 0)
go_looking();
@@ -459,7 +439,6 @@ void do_findnext(void)
}
#endif /* !NANO_TINY */
#if !defined(NANO_TINY) || !defined(DISABLE_BROWSER)
/* Search for the last string without prompting. */
void do_research(void)
{
@@ -485,7 +464,6 @@ void do_research(void)
go_looking();
}
#endif /* !NANO_TINY */
/* Search for the global string 'last_search'. Inform the user when
* the string occurs only once. */
@@ -500,11 +478,8 @@ void go_looking(void)
came_full_circle = FALSE;
didfind = findnextstr(
#ifndef DISABLE_SPELLER
FALSE,
#endif
openfile->current, openfile->current_x, last_search, NULL);
didfind = findnextstr(last_search, FALSE, NULL,
openfile->current, openfile->current_x);
/* If we found something, and we're back at the exact same spot
* where we started searching, then this is the only occurrence. */
@@ -613,12 +588,8 @@ char *replace_line(const char *needle)
* allow the cursor position to be updated when a word before the cursor
* is replaced by a shorter word. Return -1 if needle isn't found, -2 if
* the seeking is aborted, else the number of replacements performed. */
ssize_t do_replace_loop(
#ifndef DISABLE_SPELLER
bool whole_word_only,
#endif
const filestruct *real_current, size_t *real_current_x,
const char *needle)
ssize_t do_replace_loop(const char *needle, bool whole_word_only,
const filestruct *real_current, size_t *real_current_x)
{
ssize_t numreplaced = -1;
size_t match_len;
@@ -652,11 +623,8 @@ ssize_t do_replace_loop(
while (TRUE) {
int i = 0;
int result = findnextstr(
#ifndef DISABLE_SPELLER
whole_word_only,
#endif
real_current, *real_current_x, needle, &match_len);
int result = findnextstr(needle, whole_word_only, &match_len,
real_current, *real_current_x);
/* If nothing more was found, or the user aborted, stop looping. */
if (result < 1) {
@@ -704,18 +672,17 @@ ssize_t do_replace_loop(
if (i == -1) /* The replacing was cancelled. */
break;
else if (i == 2)
replaceall = TRUE;
}
if (i > 0 || replaceall) { /* Yes, replace it!!!! */
if (i == 1 || replaceall) { /* Yes, replace it. */
char *copy;
size_t length_change;
#ifndef NANO_TINY
add_undo(REPLACE);
#endif
if (i == 2)
replaceall = TRUE;
copy = replace_line(needle);
length_change = strlen(copy) - strlen(openfile->current->data);
@@ -757,9 +724,7 @@ ssize_t do_replace_loop(
/* Set the cursor at the last character of the replacement
* text, so that searching will continue /after/ it. Note
* that current_x might be set to (size_t)-1 here. */
#ifndef NANO_TINY
if (!ISSET(BACKWARDS_SEARCH))
#endif
openfile->current_x += match_len + length_change - 1;
/* Update the file size, and put the changed line into place. */
@@ -776,8 +741,8 @@ ssize_t do_replace_loop(
if (!replaceall) {
#ifndef DISABLE_COLOR
/* If color syntaxes are available and turned on, we
* need to call edit_refresh(). */
/* When doing syntax coloring, the replacement might require
* a change of colors, so refresh the whole edit window. */
if (openfile->colorstrings != NULL && !ISSET(NO_COLOR_SYNTAX))
edit_refresh();
else
@@ -786,6 +751,7 @@ ssize_t do_replace_loop(
}
set_modified();
as_an_at = TRUE;
numreplaced++;
}
}
@@ -816,7 +782,6 @@ void do_replace(void)
if (ISSET(VIEW_MODE)) {
print_view_warning();
search_replace_abort();
return;
}
@@ -832,11 +797,7 @@ void do_replace(void)
if (i != 0)
return;
i = do_prompt(FALSE,
#ifndef DISABLE_TABCOMP
TRUE,
#endif
MREPLACEWITH, NULL,
i = do_prompt(FALSE, FALSE, MREPLACEWITH, NULL,
#ifndef DISABLE_HISTORIES
&replace_history,
#endif
@@ -862,18 +823,13 @@ void do_replace(void)
begin = openfile->current;
begin_x = openfile->current_x;
numreplaced = do_replace_loop(
#ifndef DISABLE_SPELLER
FALSE,
#endif
begin, &begin_x, last_search);
numreplaced = do_replace_loop(last_search, FALSE, begin, &begin_x);
/* Restore where we were. */
openfile->edittop = edittop_save;
openfile->current = begin;
openfile->current_x = begin_x;
edit_refresh();
refresh_needed = TRUE;
if (numreplaced >= 0)
statusline(HUSH, P_("Replaced %lu occurrence",
@@ -906,11 +862,8 @@ void do_gotolinecolumn(ssize_t line, ssize_t column, bool use_answer,
functionptrtype func;
/* Ask for the line and column. */
int i = do_prompt(FALSE,
#ifndef DISABLE_TABCOMP
TRUE,
#endif
MGOTOLINE, use_answer ? answer : NULL,
int i = do_prompt(FALSE, FALSE, MGOTOLINE,
use_answer ? answer : NULL,
#ifndef DISABLE_HISTORIES
NULL,
#endif
@@ -970,9 +923,9 @@ void do_gotolinecolumn(ssize_t line, ssize_t column, bool use_answer,
openfile->placewewant = column - 1;
/* When the position was manually given, center the target line. */
if (interactive) {
edit_update(CENTERING);
edit_refresh();
if (interactive || ISSET(SOFTWRAP)) {
adjust_viewport(CENTERING);
refresh_needed = TRUE;
} else {
/* If the target line is close to the tail of the file, put the last
* line of the file on the bottom line of the screen; otherwise, just
@@ -981,9 +934,9 @@ void do_gotolinecolumn(ssize_t line, ssize_t column, bool use_answer,
editwinrows / 2) {
openfile->current_y = editwinrows - openfile->filebot->lineno +
openfile->current->lineno - 1;
edit_update(STATIONARY);
adjust_viewport(STATIONARY);
} else
edit_update(CENTERING);
adjust_viewport(CENTERING);
}
}
@@ -1047,7 +1000,6 @@ bool find_bracket_match(bool reverse, const char *bracket_set)
/* Set the current position to the found matching bracket. */
openfile->current = fileptr;
openfile->current_x = found - fileptr->data;
openfile->current_y = fileptr->lineno - openfile->edittop->lineno;
return TRUE;
}
@@ -1251,10 +1203,10 @@ void update_history(filestruct **h, const char *s)
/* If the history is full, delete the oldest item (the one at the
* head of the list), to make room for a new item at the end. */
if ((*hbot)->lineno == MAX_SEARCH_HISTORY + 1) {
filestruct *foo = *hage;
filestruct *oldest = *hage;
*hage = (*hage)->next;
unlink_node(foo);
unlink_node(oldest);
renumber(*hage);
}

View File

@@ -6,6 +6,7 @@
* Copyright (C) 2014, 2015 Mark Majeres *
* Copyright (C) 2016 Mike Scalora *
* Copyright (C) 2015, 2016 Benno Schulenberg *
* Copyright (C) 2016 Sumedh Pendurkar *
* *
* GNU nano is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published *
@@ -42,8 +43,17 @@ static bool prepend_wrap = FALSE;
/* Should we prepend wrapped text to the next line? */
#endif
#ifndef DISABLE_JUSTIFY
static filestruct *jusbuffer = NULL;
/* The buffer where we store unjustified text. */
static filestruct *jusbottom = NULL;
/* Pointer to the end of the justify buffer. */
/* A pointer to the end of the buffer with unjustified text. */
#endif
#ifdef ENABLE_WORDCOMPLETION
static int pletion_x = 0;
/* The x position in pletion_line of the last found completion. */
static completion_word *list_of_completions;
/* A linked list of the completions that have been attepmted. */
#endif
#ifndef NANO_TINY
@@ -61,8 +71,8 @@ void do_mark(void)
statusbar(_("Mark Unset"));
openfile->mark_begin = NULL;
openfile->mark_begin_x = 0;
refresh_needed = TRUE;
}
edit_refresh();
}
#endif /* !NANO_TINY */
@@ -92,7 +102,7 @@ void do_deletion(undo_type action)
if (openfile->current->data[openfile->current_x] != '\0') {
/* We're in the middle of a line: delete the current character. */
int char_buf_len = parse_mbchar(openfile->current->data +
int char_len = parse_mbchar(openfile->current->data +
openfile->current_x, NULL, NULL);
size_t line_len = strlen(openfile->current->data +
openfile->current_x);
@@ -108,16 +118,16 @@ void do_deletion(undo_type action)
/* Move the remainder of the line "in", over the current character. */
charmove(&openfile->current->data[openfile->current_x],
&openfile->current->data[openfile->current_x + char_buf_len],
line_len - char_buf_len + 1);
&openfile->current->data[openfile->current_x + char_len],
line_len - char_len + 1);
null_at(&openfile->current->data, openfile->current_x +
line_len - char_buf_len);
line_len - char_len);
#ifndef NANO_TINY
/* Adjust the mark if it is after the cursor on the current line. */
if (openfile->mark_set && openfile->mark_begin == openfile->current &&
openfile->mark_begin_x > openfile->current_x)
openfile->mark_begin_x -= char_buf_len;
openfile->mark_begin_x -= char_len;
#endif
/* Adjust the file size. */
openfile->totsize--;
@@ -169,8 +179,12 @@ void do_deletion(undo_type action)
return;
#ifndef NANO_TINY
ensure_line_is_visible();
/* If the number of screen rows that a softwrapped line occupies
* has changed, we need a full refresh. */
if (ISSET(SOFTWRAP) && refresh_needed == FALSE)
if (strlenpt(openfile->current->data) / COLS != orig_lenpt / COLS)
if (strlenpt(openfile->current->data) / editwincols != orig_lenpt / editwincols)
refresh_needed = TRUE;
#endif
@@ -410,7 +424,6 @@ void do_indent(ssize_t cols)
/* Throw away the undo stack, to prevent making mistakes when
* the user tries to undo something in the reindented text. */
discard_until(NULL, openfile);
openfile->current_undo = NULL;
/* Mark the file as modified. */
set_modified();
@@ -435,7 +448,6 @@ void do_unindent(void)
}
#endif /* !NANO_TINY */
#ifdef ENABLE_COMMENT
/* Test whether the string is empty or consists of only blanks. */
bool white_string(const char *s)
{
@@ -445,6 +457,7 @@ bool white_string(const char *s)
return !*s;
}
#ifdef ENABLE_COMMENT
/* Comment or uncomment the current line or the marked lines. */
void do_comment()
{
@@ -785,7 +798,7 @@ void do_undo(void)
openfile->mark_begin_x = u->mark_begin_x;
openfile->mark_set = TRUE;
goto_line_posx(u->lineno, u->begin);
cut_marked();
cut_marked(NULL);
free_filestruct(u->cutbuffer);
u->cutbuffer = cutbuffer;
u->cutbottom = cutbottom;
@@ -806,14 +819,16 @@ void do_undo(void)
break;
}
if (undidmsg)
if (undidmsg && !pletion_line)
statusline(HUSH, _("Undid action (%s)"), undidmsg);
renumber(f);
openfile->current_undo = openfile->current_undo->next;
openfile->last_action = OTHER;
openfile->mark_set = FALSE;
openfile->placewewant = xplustabs();
openfile->totsize = u->wassize;
set_modified();
}
@@ -961,13 +976,14 @@ void do_redo(void)
openfile->last_action = OTHER;
openfile->mark_set = FALSE;
openfile->placewewant = xplustabs();
openfile->totsize = u->newsize;
set_modified();
}
#endif /* !NANO_TINY */
/* Someone hits Enter *gasp!* */
void do_enter()
/* Break the current line at the cursor position. */
void do_enter(void)
{
filestruct *newnode = make_new_node(openfile->current);
size_t extra = 0;
@@ -977,45 +993,48 @@ void do_enter()
#ifndef NANO_TINY
add_undo(ENTER);
/* Do auto-indenting, like the neolithic Turbo Pascal editor. */
if (ISSET(AUTOINDENT)) {
/* If we are breaking the line in the indentation, the new
* indentation should have only current_x characters, and
* current_x should not change. */
extra = indent_length(openfile->current->data);
/* If we are breaking the line in the indentation, limit the new
* indentation to the current x position. */
if (extra > openfile->current_x)
extra = openfile->current_x;
}
#endif
newnode->data = charalloc(strlen(openfile->current->data +
openfile->current_x) + extra + 1);
openfile->current_x) + extra + 1);
strcpy(&newnode->data[extra], openfile->current->data +
openfile->current_x);
openfile->current_x);
#ifndef NANO_TINY
if (ISSET(AUTOINDENT)) {
/* Copy the whitespace from the current line to the new one. */
strncpy(newnode->data, openfile->current->data, extra);
openfile->totsize += extra;
}
#endif
null_at(&openfile->current->data, openfile->current_x);
#ifndef NANO_TINY
/* Adjust the mark if it was on the current line after the cursor. */
if (openfile->mark_set && openfile->current == openfile->mark_begin &&
openfile->current_x < openfile->mark_begin_x) {
openfile->mark_begin = newnode;
openfile->mark_begin_x += extra - openfile->current_x;
}
#endif
openfile->current_x = extra;
splice_node(openfile->current, newnode);
openfile->current = newnode;
renumber(newnode);
openfile->current = newnode;
openfile->current_x = extra;
openfile->placewewant = xplustabs();
openfile->totsize++;
set_modified();
openfile->placewewant = xplustabs();
#ifndef NANO_TINY
update_undo(ENTER);
#endif
@@ -1138,6 +1157,9 @@ void discard_until(const undo *thisitem, openfilestruct *thefile)
dropit = thefile->undotop;
}
/* Adjust the pointer to the top of the undo stack. */
thefile->current_undo = (undo *)thisitem;
/* Prevent a chain of editing actions from continuing. */
thefile->last_action = OTHER;
}
@@ -1199,16 +1221,18 @@ void add_undo(undo_type action)
case BACK:
/* If the next line is the magic line, don't ever undo this
* backspace, as it won't actually have deleted anything. */
if (openfile->current->next == openfile->filebot && openfile->current->data[0] != '\0')
if (openfile->current->next == openfile->filebot &&
openfile->current->data[0] != '\0')
u->xflags = WAS_FINAL_BACKSPACE;
case DEL:
if (u->begin != strlen(openfile->current->data)) {
if (openfile->current->data[openfile->current_x] != '\0') {
char *char_buf = charalloc(mb_cur_max() + 1);
int char_buf_len = parse_mbchar(&openfile->current->data[u->begin], char_buf, NULL);
null_at(&char_buf, char_buf_len);
int char_len = parse_mbchar(&openfile->current->data[u->begin],
char_buf, NULL);
null_at(&char_buf, char_len);
u->strdata = char_buf;
if (u->type == BACK)
u->mark_begin_x += char_buf_len;
u->mark_begin_x += char_len;
break;
}
/* Else purposely fall into the line-joining code. */
@@ -1336,8 +1360,8 @@ fprintf(stderr, " >> Updating... action = %d, openfile->last_action = %d, openf
openfile->current->data, (unsigned long)openfile->current_x, (unsigned long)u->begin);
#endif
char *char_buf = charalloc(mb_cur_max());
size_t char_buf_len = parse_mbchar(&openfile->current->data[u->mark_begin_x], char_buf, NULL);
u->strdata = addstrings(u->strdata, u->strdata ? strlen(u->strdata) : 0, char_buf, char_buf_len);
int char_len = parse_mbchar(&openfile->current->data[u->mark_begin_x], char_buf, NULL);
u->strdata = addstrings(u->strdata, u->strdata ? strlen(u->strdata) : 0, char_buf, char_len);
#ifdef DEBUG
fprintf(stderr, " >> current undo data is \"%s\"\n", u->strdata);
#endif
@@ -1348,17 +1372,17 @@ fprintf(stderr, " >> Updating... action = %d, openfile->last_action = %d, openf
case BACK:
case DEL: {
char *char_buf = charalloc(mb_cur_max());
size_t char_buf_len = parse_mbchar(&openfile->current->data[openfile->current_x], char_buf, NULL);
int char_len = parse_mbchar(&openfile->current->data[openfile->current_x], char_buf, NULL);
if (openfile->current_x == u->begin) {
/* They're deleting. */
u->strdata = addstrings(u->strdata, strlen(u->strdata), char_buf, char_buf_len);
/* They deleted more: add removed character after earlier stuff. */
u->strdata = addstrings(u->strdata, strlen(u->strdata), char_buf, char_len);
u->mark_begin_x = openfile->current_x;
} else if (openfile->current_x == u->begin - char_buf_len) {
/* They're backspacing. */
u->strdata = addstrings(char_buf, char_buf_len, u->strdata, strlen(u->strdata));
} else if (openfile->current_x == u->begin - char_len) {
/* They backspaced further: add removed character before earlier. */
u->strdata = addstrings(char_buf, char_len, u->strdata, strlen(u->strdata));
u->begin = openfile->current_x;
} else {
/* They deleted something else on the line. */
/* They deleted *elsewhere* on the line: start a new undo item. */
free(char_buf);
add_undo(u->type);
return;
@@ -1978,12 +2002,9 @@ bool begpar(const filestruct *const foo)
/* Case 2) or 5) or 4). */
if (foo->prev->data[quote_len + temp_id_len] == '\0' ||
(quote_len == 0 && indent_len > 0
#ifndef NANO_TINY
&& !ISSET(AUTOINDENT)
#endif
) || !indents_match(foo->prev->data + quote_len, temp_id_len,
foo->data + quote_len, indent_len))
(quote_len == 0 && indent_len > 0 && !ISSET(AUTOINDENT)) ||
!indents_match(foo->prev->data + quote_len, temp_id_len,
foo->data + quote_len, indent_len))
return TRUE;
return FALSE;
@@ -2105,9 +2126,6 @@ bool find_paragraph(size_t *const quote, size_t *const par)
/* Number of lines in the paragraph we search for. */
filestruct *current_save;
/* The line at the beginning of the paragraph we search for. */
ssize_t current_y_save;
/* The y-coordinate at the beginning of the paragraph we search
* for. */
#ifdef HAVE_REGEX_H
if (quoterc != 0) {
@@ -2156,7 +2174,6 @@ bool find_paragraph(size_t *const quote, size_t *const par)
* of lines in this paragraph. */
quote_len = quote_length(openfile->current->data);
current_save = openfile->current;
current_y_save = openfile->current_y;
do_para_end(FALSE);
par_len = openfile->current->lineno - current_save->lineno;
@@ -2167,7 +2184,6 @@ bool find_paragraph(size_t *const quote, size_t *const par)
if (openfile->current_x > 0)
par_len++;
openfile->current = current_save;
openfile->current_y = current_y_save;
/* Save the values of quote_len and par_len. */
assert(quote != NULL && par != NULL);
@@ -2278,8 +2294,7 @@ void do_justify(bool full_justify)
if (first_par_line == NULL) {
backup_lines(openfile->current, full_justify ?
openfile->filebot->lineno - openfile->current->lineno +
((openfile->filebot->data[0] != '\0') ? 1 : 0) :
par_len);
((openfile->filebot->data[0] != '\0') ? 1 : 0) : par_len);
first_par_line = openfile->current;
}
@@ -2333,8 +2348,7 @@ void do_justify(bool full_justify)
/* We're just about to tack the next line onto this one. If
* this line isn't empty, make sure it ends in a space. */
if (line_len > 0 &&
openfile->current->data[line_len - 1] != ' ') {
if (line_len > 0 && openfile->current->data[line_len - 1] != ' ') {
line_len++;
openfile->current->data =
charealloc(openfile->current->data, line_len + 1);
@@ -2349,8 +2363,7 @@ void do_justify(bool full_justify)
#ifndef NANO_TINY
/* If needed, adjust the coordinates of the mark. */
if (openfile->mark_set &&
openfile->mark_begin == next_line) {
if (openfile->mark_set && openfile->mark_begin == next_line) {
openfile->mark_begin = openfile->current;
openfile->mark_begin_x += line_len - indent_len;
}
@@ -2402,11 +2415,7 @@ void do_justify(bool full_justify)
/* If this paragraph is non-quoted, and autoindent isn't
* turned on, set the indentation length to zero so that the
* indentation is treated as part of the line. */
if (quote_len == 0
#ifndef NANO_TINY
&& !ISSET(AUTOINDENT)
#endif
)
if (quote_len == 0 && !ISSET(AUTOINDENT))
indent_len = 0;
/* Insert a new line after the current one. */
@@ -2446,7 +2455,6 @@ void do_justify(bool full_justify)
/* Go to the next line. */
par_len--;
openfile->current_y++;
openfile->current = openfile->current->next;
}
@@ -2457,14 +2465,12 @@ void do_justify(bool full_justify)
/* Go to the next line, if possible. If there is no next line,
* move to the end of the current line. */
if (openfile->current != openfile->filebot) {
openfile->current_y++;
openfile->current = openfile->current->next;
} else
openfile->current_x = strlen(openfile->current->data);
/* Renumber the lines of the now-justified current paragraph,
* since both find_paragraph() and edit_refresh() need the line
* numbers to be right. */
/* Renumber the now-justified paragraph, since both refreshing the
* edit window and finding a paragraph need correct line numbers. */
renumber(curr_first_par_line);
/* We've just finished justifying the paragraph. If we're not
@@ -2476,9 +2482,8 @@ void do_justify(bool full_justify)
}
/* We are now done justifying the paragraph or the file, so clean
* up. current_y and totsize have been maintained above. If we
* actually justified something, set last_par_line to the new end of
* the paragraph. */
* up. totsize has been maintained above. If we actually justified
* something, set last_par_line to the new end of the paragraph. */
if (first_par_line != NULL)
last_par_line = openfile->current;
@@ -2513,35 +2518,28 @@ void do_justify(bool full_justify)
|| func == do_undo
#endif
) {
/* Splice the justify buffer back into the file, but only if we
* actually justified something. */
/* If we actually justified something, then splice the preserved
* unjustified text back into the file, */
if (first_par_line != NULL) {
filestruct *top_save;
/* Partition the filestruct so that it contains only the
* text of the justified paragraph. */
filepart = partition_filestruct(first_par_line, 0,
last_par_line, filebot_inpar ?
strlen(last_par_line->data) : 0);
/* Remove the text of the justified paragraph, and
* replace it with the text in the justify buffer. */
/* Throw away the justified paragraph, and replace it with
* the preserved unjustified text. */
free_filestruct(openfile->fileage);
openfile->fileage = jusbuffer;
openfile->filebot = jusbottom;
top_save = openfile->fileage;
/* Unpartition the filestruct so that it contains all the
* text again. Note that the justified paragraph has been
* replaced with the unjustified paragraph. */
/* Unpartition the filestruct, to contain the entire text again. */
unpartition_filestruct(&filepart);
/* Renumber, starting with the beginning line of the old
* partition. */
renumber(top_save);
/* Renumber, from the beginning of the unjustified part. */
renumber(jusbuffer);
/* Restore the justify we just did (ungrateful user!). */
/* Restore the old position, the size, and the mark. */
openfile->edittop = edittop_save;
openfile->current = current_save;
openfile->current_x = current_x_save;
@@ -2553,12 +2551,9 @@ void do_justify(bool full_justify)
}
#endif
openfile->modified = modified_save;
/* Clear the justify buffer. */
jusbuffer = NULL;
if (!openfile->modified)
titlebar(NULL);
refresh_needed = TRUE;
}
} else {
@@ -2572,13 +2567,14 @@ void do_justify(bool full_justify)
/* Throw away the entire undo stack, to prevent a crash when
* the user tries to undo something in the justified text. */
discard_until(NULL, openfile);
openfile->current_undo = NULL;
#endif
/* Blow away the text in the justify buffer. */
/* Blow away the unjustified text. */
free_filestruct(jusbuffer);
jusbuffer = NULL;
}
/* Mark the buffer for unjustified text as empty. */
jusbuffer = NULL;
blank_statusbar();
/* Display the shortcut list with UnCut. */
@@ -2627,17 +2623,10 @@ bool do_int_spell_fix(const char *word)
/* Save the settings of the global flags. */
memcpy(stash, flags, sizeof(flags));
/* Make sure spell-check is case sensitive. */
/* Do the spell checking case sensitive, forward, and without regexes. */
SET(CASE_SENSITIVE);
#ifndef NANO_TINY
/* Make sure spell-check goes forward only. */
UNSET(BACKWARDS_SEARCH);
#endif
#ifdef HAVE_REGEX_H
/* Make sure spell-check doesn't use regular expressions. */
UNSET(USE_REGEXP);
#endif
/* Save the current search string, then set it to the misspelled word. */
save_search = last_search;
@@ -2668,7 +2657,7 @@ bool do_int_spell_fix(const char *word)
}
/* Find the first whole occurrence of word. */
result = findnextstr(TRUE, NULL, 0, word, NULL);
result = findnextstr(word, TRUE, NULL, NULL, 0);
/* If the word isn't found, alert the user; if it is, allow correction. */
if (result == 0) {
@@ -2684,11 +2673,7 @@ bool do_int_spell_fix(const char *word)
spotlight(TRUE, exp_word);
/* Let the user supply a correctly spelled alternative. */
proceed = (do_prompt(FALSE,
#ifndef DISABLE_TABCOMP
TRUE,
#endif
MSPELL, word,
proceed = (do_prompt(FALSE, FALSE, MSPELL, word,
#ifndef DISABLE_HISTORIES
NULL,
#endif
@@ -2705,7 +2690,7 @@ bool do_int_spell_fix(const char *word)
/* Replacements should happen only in the marked region. */
openfile->mark_set = old_mark_set;
#endif
do_replace_loop(TRUE, current_save, &current_x_save, word);
do_replace_loop(word, TRUE, current_save, &current_x_save);
/* TRANSLATORS: Shown after fixing misspellings in one word. */
statusbar(_("Next word..."));
@@ -2932,7 +2917,6 @@ const char *do_alt_speller(char *tempfile_name)
int alt_spell_status;
size_t current_x_save = openfile->current_x;
size_t pww_save = openfile->placewewant;
ssize_t current_y_save = openfile->current_y;
ssize_t lineno_save = openfile->current->lineno;
struct stat spellfileinfo;
time_t timestamp;
@@ -3048,6 +3032,11 @@ const char *do_alt_speller(char *tempfile_name)
#ifndef NANO_TINY
if (old_mark_set) {
filestruct *top_save = openfile->fileage;
/* If a magicline was added, remove it again. */
if (added_magicline)
remove_magicline();
/* Adjust the end point of the marked region for any change in
* length of the region's last line. */
if (right_side_up)
@@ -3055,10 +3044,6 @@ const char *do_alt_speller(char *tempfile_name)
else
openfile->mark_begin_x = strlen(openfile->filebot->data);
/* If a magicline was added, remove it again. */
if (added_magicline)
remove_magicline();
/* Unpartition the filestruct so that it contains all the text
* again. Note that we've replaced the marked text originally
* in the partition with the spell-checked marked text in the
@@ -3079,16 +3064,22 @@ const char *do_alt_speller(char *tempfile_name)
/* Go back to the old position. */
goto_line_posx(lineno_save, current_x_save);
openfile->current_y = current_y_save;
if (openfile->current_x > strlen(openfile->current->data))
openfile->current_x = strlen(openfile->current->data);
openfile->placewewant = pww_save;
edit_update(STATIONARY);
adjust_viewport(STATIONARY);
/* Stat the temporary file again, and mark the buffer as modified only
* if this file was changed since it was written. */
stat(tempfile_name, &spellfileinfo);
if (spellfileinfo.st_mtime != timestamp)
if (spellfileinfo.st_mtime != timestamp) {
set_modified();
#ifndef NANO_TINY
/* Flush the undo stack, to avoid making a mess when the user
* tries to undo things in spell-corrected lines. */
discard_until(NULL, openfile);
#endif
}
#ifndef NANO_TINY
/* Unblock SIGWINCHes again. */
allow_sigwinch(TRUE);
@@ -3386,8 +3377,6 @@ void do_linter(void)
sprintf(msg, _("This message is for unopened file %s,"
" open it in a new buffer?"),
curlint->filename);
/* Show a cursor after the question. */
curs_set(1);
i = do_yesno_prompt(FALSE, msg);
free(msg);
if (i == -1) {
@@ -3475,7 +3464,6 @@ void do_formatter(void)
FILE *temp_file;
int format_status;
ssize_t lineno_save = openfile->current->lineno;
ssize_t current_y_save = openfile->current_y;
size_t current_x_save = openfile->current_x;
size_t pww_save = openfile->placewewant;
pid_t pid_format;
@@ -3553,14 +3541,19 @@ void do_formatter(void)
/* Replace the text of the current buffer with the formatted text. */
replace_buffer(temp);
/* Restore the cursor position, and mark the file as modified. */
/* Restore the cursor position. */
goto_line_posx(lineno_save, current_x_save);
openfile->current_y = current_y_save;
if (openfile->current_x > strlen(openfile->current->data))
openfile->current_x = strlen(openfile->current->data);
openfile->placewewant = pww_save;
edit_update(STATIONARY);
adjust_viewport(STATIONARY);
set_modified();
/* Flush the undo stack, to avoid a mess or crash when
* the user tries to undo things in reformatted lines. */
discard_until(NULL, openfile);
finalstatus = _("Finished formatting");
}
@@ -3689,3 +3682,179 @@ void do_verbatim_input(void)
free(output);
}
#ifdef ENABLE_WORDCOMPLETION
/* Copy the found completion candidate. */
char *copy_completion(char *check_line, int start)
{
char *word;
int position = start, len_of_word = 0, index = 0;
/* Find the length of the word by travelling to its end. */
while (is_word_mbchar(&check_line[position], FALSE)) {
int next = move_mbright(check_line, position);
len_of_word += next - position;
position = next;
}
word = (char *)nmalloc((len_of_word + 1) * sizeof(char));
/* Simply copy the word. */
while (index < len_of_word)
word[index++] = check_line[start++];
word[index] = '\0';
return word;
}
/* Look at the fragment the user has typed, then search the current buffer for
* the first word that starts with this fragment, and tentatively complete the
* fragment. If the user types 'Complete' again, search and paste the next
* possible completion. */
void complete_a_word(void)
{
char *shard, *completion = NULL;
int start_of_shard, shard_length = 0;
int i = 0, j = 0;
completion_word *some_word;
#ifndef DISABLE_WRAPPING
bool was_set_wrapping = !ISSET(NO_WRAP);
#endif
/* If this is a fresh completion attempt... */
if (pletion_line == NULL) {
/* Clear the list of words of a previous completion run. */
while (list_of_completions != NULL) {
completion_word *dropit = list_of_completions;
list_of_completions = list_of_completions->next;
free(dropit->word);
free(dropit);
}
/* Prevent a completion from being merged with typed text. */
openfile->last_action = OTHER;
/* Initialize the starting point for searching. */
pletion_line = openfile->fileage;
pletion_x = 0;
/* Wipe the "No further matches" message. */
blank_statusbar();
wnoutrefresh(bottomwin);
} else {
/* Remove the attempted completion from the buffer. */
do_undo();
}
/* Find the start of the fragment that the user typed. */
start_of_shard = openfile->current_x;
while (start_of_shard > 0) {
int step_left = move_mbleft(openfile->current->data, start_of_shard);
if (!is_word_mbchar(&openfile->current->data[step_left], FALSE))
break;
start_of_shard = step_left;
}
/* If there is no word fragment before the cursor, do nothing. */
if (start_of_shard == openfile->current_x) {
pletion_line = NULL;
return;
}
shard = (char *)nmalloc((openfile->current_x - start_of_shard + 1) * sizeof(char));
/* Copy the fragment that has to be searched for. */
while (start_of_shard < openfile->current_x)
shard[shard_length++] = openfile->current->data[start_of_shard++];
shard[shard_length] = '\0';
/* Run through all of the lines in the buffer, looking for shard. */
while (pletion_line != NULL) {
int threshold = strlen(pletion_line->data) - shard_length - 1;
/* The point where we can stop searching for shard. */
/* Traverse the whole line, looking for shard. */
for (i = pletion_x; i < threshold; i++) {
/* If the first byte doesn't match, run on. */
if (pletion_line->data[i] != shard[0])
continue;
/* Compare the rest of the bytes in shard. */
for (j = 1; j < shard_length; j++)
if (pletion_line->data[i + j] != shard[j])
break;
/* If not all of the bytes matched, continue searching. */
if (j < shard_length)
continue;
/* If the found match is not /longer/ than shard, skip it. */
if (!is_word_mbchar(&pletion_line->data[i + j], FALSE))
continue;
/* If the match is not a separate word, skip it. */
if (i > 0 && is_word_mbchar(&pletion_line->data[
move_mbleft(pletion_line->data, i)], FALSE))
continue;
/* If this match is the shard itself, ignore it. */
if (pletion_line == openfile->current &&
i == openfile->current_x - shard_length)
continue;
completion = copy_completion(pletion_line->data, i);
/* Look among earlier attempted completions for a duplicate. */
some_word = list_of_completions;
while (some_word && strcmp(some_word->word, completion) != 0)
some_word = some_word->next;
/* If we've already tried this word, skip it. */
if (some_word != NULL) {
free(completion);
continue;
}
/* Add the found word to the list of completions. */
some_word = (completion_word *)nmalloc(sizeof(completion_word));
some_word->word = completion;
some_word->next = list_of_completions;
list_of_completions = some_word;
#ifndef DISABLE_WRAPPING
/* Temporarily disable wrapping so only one undo item is added. */
SET(NO_WRAP);
#endif
/* Inject the completion into the buffer. */
do_output(&completion[shard_length],
strlen(completion) - shard_length, FALSE);
#ifndef DISABLE_WRAPPING
/* If needed, reenable wrapping and wrap the current line. */
if (was_set_wrapping) {
UNSET(NO_WRAP);
do_wrap(openfile->current);
}
#endif
/* Set the position for a possible next search attempt. */
pletion_x = ++i;
free(shard);
return;
}
pletion_line = pletion_line->next;
pletion_x = 0;
}
/* The search has reached the end of the file. */
if (list_of_completions != NULL) {
statusline(ALERT, _("No further matches"));
refresh_needed = TRUE;
} else
/* TRANSLATORS: Shown when there are zero possible completions. */
statusline(ALERT, _("No matches"));
free(shard);
}
#endif /* ENABLE_WORDCOMPLETION */

View File

@@ -52,6 +52,39 @@ void get_homedir(void)
}
}
#ifdef ENABLE_LINENUMBERS
/* Return the number of digits that the given integer n takes up. */
int digits(ssize_t n)
{
if (n < 100000) {
if (n < 1000) {
if (n < 100)
return 2;
else
return 3;
} else {
if (n < 10000)
return 4;
else
return 5;
}
} else {
if (n < 10000000) {
if (n < 1000000)
return 6;
else
return 7;
}
else {
if (n < 100000000)
return 8;
else
return 9;
}
}
}
#endif
/* Read a ssize_t from str, and store it in *val (if val is not NULL).
* On error, we return FALSE and don't change *val. Otherwise, we
* return TRUE. */
@@ -60,8 +93,6 @@ bool parse_num(const char *str, ssize_t *val)
char *first_error;
ssize_t j;
assert(str != NULL);
/* The manual page for strtol() says this is required, and
* it looks like it is! */
errno = 0;
@@ -93,26 +124,24 @@ bool parse_line_column(const char *str, ssize_t *line, ssize_t *column)
if (comma == NULL)
return parse_num(str, line);
if (!parse_num(comma + 1, column))
return FALSE;
retval = parse_num(comma + 1, column);
if (comma == str)
return TRUE;
return retval;
firstpart = mallocstrcpy(NULL, str);
firstpart[comma - str] = '\0';
retval = parse_num(firstpart, line);
free(firstpart);
return retval;
}
/* Fix the memory allocation for a string. */
void align(char **str)
/* Reduce the memory allocation of a string to what is needed. */
void snuggly_fit(char **str)
{
assert(str != NULL);
if (*str != NULL)
*str = charealloc(*str, strlen(*str) + 1);
}
@@ -120,8 +149,6 @@ void align(char **str)
/* Null a string at a certain index and align it. */
void null_at(char **data, size_t index)
{
assert(data != NULL);
*data = charealloc(*data, index + 1);
(*data)[index] = '\0';
}
@@ -130,8 +157,6 @@ void null_at(char **data, size_t index)
* normally have newlines in it, so encode its nulls as newlines. */
void unsunder(char *str, size_t true_len)
{
assert(str != NULL);
for (; true_len > 0; true_len--, str++) {
if (*str == '\0')
*str = '\n';
@@ -142,8 +167,6 @@ void unsunder(char *str, size_t true_len)
* normally have newlines in it, so decode its newlines as nulls. */
void sunder(char *str)
{
assert(str != NULL);
for (; *str != '\0'; str++) {
if (*str == '\n')
*str = '\0';
@@ -280,11 +303,8 @@ const char *fixbounds(const char *r)
* a separate word? That is: is it not part of a longer word?*/
bool is_separate_word(size_t position, size_t length, const char *buf)
{
char *before = charalloc(mb_cur_max()), *after = charalloc(mb_cur_max());
char before[mb_cur_max()], after[mb_cur_max()];
size_t word_end = position + length;
bool retval;
assert(buf != NULL && position < strlen(buf) && position + length <= strlen(buf));
/* Get the characters before and after the word, if any. */
parse_mbchar(buf + move_mbleft(buf, position), before, NULL);
@@ -293,13 +313,8 @@ bool is_separate_word(size_t position, size_t length, const char *buf)
/* If the word starts at the beginning of the line OR the character before
* the word isn't a letter, and if the word ends at the end of the line OR
* the character after the word isn't a letter, we have a whole word. */
retval = (position == 0 || !is_alpha_mbchar(before)) &&
(word_end == strlen(buf) || !is_alpha_mbchar(after));
free(before);
free(after);
return retval;
return ((position == 0 || !is_alpha_mbchar(before)) &&
(buf[word_end] == '\0' || !is_alpha_mbchar(after)));
}
#endif /* !DISABLE_SPELLER */
@@ -317,14 +332,11 @@ const char *strstrwrapper(const char *haystack, const char *needle,
if ((start > haystack && *(start - 1) == '\0') || start < haystack)
return NULL;
assert(haystack != NULL && needle != NULL && start != NULL);
#ifdef HAVE_REGEX_H
if (ISSET(USE_REGEXP)) {
#ifndef NANO_TINY
if (ISSET(BACKWARDS_SEARCH)) {
if (regexec(&search_regexp, haystack, 1, regmatches,
0) == 0 && haystack + regmatches[0].rm_so <= start) {
if (regexec(&search_regexp, haystack, 1, regmatches, 0) == 0 &&
haystack + regmatches[0].rm_so <= start) {
const char *retval = haystack + regmatches[0].rm_so;
/* Search forward until there are no more matches. */
@@ -338,10 +350,8 @@ const char *strstrwrapper(const char *haystack, const char *needle,
regexec(&search_regexp, retval, 10, regmatches, 0);
return retval;
}
} else
#endif /* !NANO_TINY */
if (regexec(&search_regexp, start, 10, regmatches,
(start > haystack) ? REG_NOTBOL : 0) == 0) {
} else if (regexec(&search_regexp, start, 10, regmatches,
(start > haystack) ? REG_NOTBOL : 0) == 0) {
const char *retval = start + regmatches[0].rm_so;
regexec(&search_regexp, retval, 10, regmatches, 0);
@@ -350,20 +360,14 @@ const char *strstrwrapper(const char *haystack, const char *needle,
return NULL;
}
#endif /* HAVE_REGEX_H */
#if !defined(NANO_TINY) || !defined(DISABLE_SPELLER)
if (ISSET(CASE_SENSITIVE)) {
#ifndef NANO_TINY
if (ISSET(BACKWARDS_SEARCH))
return revstrstr(haystack, needle, start);
else
#endif
return strstr(start, needle);
}
#endif /* !DISABLE_SPELLER || !NANO_TINY */
#ifndef NANO_TINY
else if (ISSET(BACKWARDS_SEARCH))
} else if (ISSET(BACKWARDS_SEARCH))
return mbrevstrcasestr(haystack, needle, start);
#endif
return mbstrcasestr(start, needle);
}
@@ -439,20 +443,18 @@ char *free_and_assign(char *dest, char *src)
* get_page_start(column) < COLS). */
size_t get_page_start(size_t column)
{
if (column == 0 || column < COLS - 1)
if (column == 0 || column < editwincols - 1)
return 0;
else if (COLS > 8)
return column - 7 - (column - 7) % (COLS - 8);
else if (editwincols > 8)
return column - 7 - (column - 7) % (editwincols - 8);
else
return column - (COLS - 2);
return column - (editwincols - 2);
}
/* Return the placewewant associated with current_x, i.e. the zero-based
* column position of the cursor. */
size_t xplustabs(void)
{
assert(openfile->current != NULL);
return strnlenpt(openfile->current->data, openfile->current_x);
}
@@ -465,8 +467,6 @@ size_t actual_x(const char *text, size_t column)
size_t width = 0;
/* The screen display width to text[index], in columns. */
assert(text != NULL);
while (*text != '\0') {
int charlen = parse_mbchar(text, NULL, &width);
@@ -490,8 +490,6 @@ size_t strnlenpt(const char *text, size_t maxlen)
if (maxlen == 0)
return 0;
assert(text != NULL);
while (*text != '\0') {
int charlen = parse_mbchar(text, NULL, &width);
@@ -535,9 +533,6 @@ void remove_magicline(void)
{
if (openfile->filebot->data[0] == '\0' &&
openfile->filebot != openfile->fileage) {
assert(openfile->filebot != openfile->edittop &&
openfile->filebot != openfile->current);
openfile->filebot = openfile->filebot->prev;
free_filestruct(openfile->filebot->next);
openfile->filebot->next = NULL;
@@ -553,8 +548,6 @@ void remove_magicline(void)
void mark_order(const filestruct **top, size_t *top_x, const filestruct
**bot, size_t *bot_x, bool *right_side_up)
{
assert(top != NULL && top_x != NULL && bot != NULL && bot_x != NULL);
if ((openfile->current->lineno == openfile->mark_begin->lineno &&
openfile->current_x > openfile->mark_begin_x) ||
openfile->current->lineno > openfile->mark_begin->lineno) {
@@ -573,37 +566,6 @@ void mark_order(const filestruct **top, size_t *top_x, const filestruct
*right_side_up = FALSE;
}
}
#endif /* !NANO_TINY */
/* Calculate the number of characters between begin and end, and return
* it. */
size_t get_totsize(const filestruct *begin, const filestruct *end)
{
size_t totsize = 0;
const filestruct *f;
/* Go through the lines from begin to end->prev, if we can. */
for (f = begin; f != end && f != NULL; f = f->next) {
/* Count the number of characters on this line. */
totsize += mbstrlen(f->data);
/* Count the newline if we have one. */
if (f->next != NULL)
totsize++;
}
/* Go through the line at end, if we can. */
if (f != NULL) {
/* Count the number of characters on this line. */
totsize += mbstrlen(f->data);
/* Count the newline if we have one. */
if (f->next != NULL)
totsize++;
}
return totsize;
}
/* Given a line number, return a pointer to the corresponding struct. */
filestruct *fsfromline(ssize_t lineno)
@@ -618,13 +580,32 @@ filestruct *fsfromline(ssize_t lineno)
f = f->next;
if (f->lineno != lineno) {
statusline(ALERT, _("Internal error: can't match line %d. "
"Please save your work."), lineno);
statusline(ALERT, _("Internal error: can't match line %ld. "
"Please save your work."), (long)lineno);
return NULL;
}
return f;
}
#endif /* !NANO_TINY */
/* Count the number of characters from begin to end, and return it. */
size_t get_totsize(const filestruct *begin, const filestruct *end)
{
const filestruct *line;
size_t totsize = 0;
/* Sum the number of characters (plus a newline) in each line. */
for (line = begin; line != end->next; line = line->next)
totsize += mbstrlen(line->data) + 1;
/* The last line of a file doesn't have a newline -- otherwise it
* wouldn't be the last line -- so subtract 1 when at EOF. */
if (line == NULL)
totsize--;
return totsize;
}
#ifdef DEBUG
/* Dump the filestruct inptr to stderr. */

File diff suppressed because it is too large Load Diff

View File

@@ -20,7 +20,7 @@ color red "\"[^"]*\"" "\'[^']*\'"
color green "`[^`]*`"
# Error lines:
color black "^\*\*\*.*"
color brightred "^\*\*\*.*"
# Brackets:
color magenta "\[|\]|\(|\)"

View File

@@ -49,19 +49,19 @@ color ,green "[[:space:]]+$"
syntax "/etc/portage" "\.(accept_keywords|env|keywords|mask|unmask|use)(/.+)?$"
## Base text:
color green "^.+$"
## Use flags:
color brightred "[[:space:]]+\+?[a-zA-Z0-9_-]+"
color brightblue "[[:space:]]+-[a-zA-Z0-9_-]+"
## Likely version and slot numbers:
color magenta "-[[:digit:]].*([[:space:]]|$)"
color magenta "-[[:digit:].]+(_(alpha|beta|pre|rc|p)[[:digit:]]*)*(-r[[:digit:]]+)?([:[:space:]]|$)"
color magenta ":[^[:space:]]+([[:space:]]|$)"
## Use flags (must come after version/slot):
color brightred "[[:space:]]+\+?[A-Za-z0-9+_@-]+"
color brightblue "[[:space:]]+-[A-Za-z0-9+_@-]+"
## Accepted arches:
color white "[~-]?\<(alpha|amd64|arm|hppa|ia64|mips|ppc|ppc64|s390|sh|sparc(-fbsd)?|x86(-fbsd)?)\>"
color white "[~-]?\<(alpha|amd64|arm(64)?|hppa|ia64|m68k|mips|nios2|ppc(64)?|riscv|s390|sh|sparc|x86)(-(aix|(f|free|net|open)bsd|cygwin|hpux|interix|linux|macos|mint|solaris|winnt))?\>"
color white "[[:space:]][*~-]?\*"
## Categories:
color cyan "^[[:space:]]*.*/"
color cyan "^[[:space:]]*[^/]*/"
## Masking regulators:
color brightmagenta "^[[:space:]]*(=|~|<|<=|=<|>|>=|=>)"
color brightmagenta "^[[:space:]]*(=|~|<|<=|>|>=)"
## Comments:
color yellow "#.*$"
## Trailing space is bad!

Some files were not shown because too many files have changed in this diff Show More