| Age | Commit message (Collapse) | Author | Files | Lines |
|---|
|
* one would expect function key macros masked for the start
state to work after ^[ ($), but since it has its own
state now, this was broken since f08187e454f56954b41d95615ca2e370ba19667e.
* Similarily command reinsertion would reinsert too much
after $, since the parser wouldn't be in the "real" start state.
* The "escape" state should be handled like the start state
(where new commands can begin)
from the perspective of the user -- the difference is not
even documented, it's an implementation detail.
|
|
optimizationa and additional checks
* undo tokens emitted by the expression stack no longer waste
memory by pointing to the stack implementation.
This uses some ugly C++ constant template arguments but
saves 4 or 8 byte per undo token depending on the architecture.
* Round braces are counted now and the return command $$ will
use this information to discard all non-relevant brace levels.
* It is an error to close a brace when none have been opened.
* The bracing rules are still very liberal, allowing you to
close braces in macros belonging to a higher call frame
or leave them open at the end of a macro.
While this is technically possible, it is perhaps a good
idea to stricten these rules in some future release.
* Loops no longer (ab)use the expression stack to store
program counters and loop counters.
This removes flow control from the responsibility of the
expression stack which is much safer now since we can control
where we jump to.
This also eased implemented proper semantics for $$.
* It is an error to leave loops open at the end of a macro
or trying to close a loop opened in the caller of the macro.
Similarily it is only possible to close a loop from the
current invocation frame.
This means it is now impossible to accidentally jump to invalid
PCs.
* Even though loop context stacks could be attached directly to
the macro invocation frame, this would be inefficient.
Instead there's a loop frame pointer now that is part of the
invocation frame. All frames will reuse the same stack structure.
* Loops are automatically discarded when returning using $$.
* Special aggregating forms of the loop start (":<") and loop
end (":>") commands are possible now and have been implemented.
This improves SciTECO's capability as a stack-oriented language.
It is no longer necessary to write recursive macros to generate
stack values of arbitrary length dynamically or to process them.
* All expression and loop stacks are still fixed-size.
It may be a good idea to implement dynamic resizing (TODO).
* Added some G_UNLIKELYs to Execute::macro(). Should improve
the branch prediction of modern CPUs.
* Local Q-Register tables are allocated on the stack now instead
of on the heap (the bulk of a table is stored on the heap anyway).
Should improve performance of macro invocations.
* Document that "F<" will jump to the beginning of the macro
if there is no loop.
This is not in standard TECO, but I consider it a useful feature.
|
|
* <$$> is faster than jumping to the end of the macro
and enables shorter code for returning values from macros.
* this also replaces $$ as an immediate editing command.
In other words, command line termination is an ordinary command
now. The old behaviour was similar to what classic TECO did.
Classic TECO however had no choice than to track key presses
directly for command line termination as it did not keep track
about the parser state as input was typed.
This led to some glitches in the language. For instance
"FS$$" would terminate the command line, unless the second escape
was typed after backspace, etc. This behaviour is not worth copying
and SciTECO did a better job than that by making sure that at least the
second escape is only effective if it is not part of language syntax.
This still lead to some undesirable cases like "ES...$$$" that would
terminate the command line unexpectedly.
To terminate the command line after something like "FS$$", you will
now have to type "FS$$$$".
* As it is a regular command now - just executed immediately - and
its properties stay close to the macro return behaviour, command line
termination may now not always be performed when $$ is typed even
as a standalone command. E.g. "Ofoo$ !bar!$$ !foo!Obar$" will
curiously terminate the command line now.
* This also means that macros can finally terminate command lines
by using the command line editing commands ({ and }) to insert
$$ into the command line macro.
This is also of interest for function key macros.
* This implementation showed some serious shortcoming in SciTECO's
current parser that yet have to be fixed.
E.g. the macro "@^Ua{<$$>}" is currently unsafe since
loops abuse the expression stack for storing their state and $$
does not touch the expression stack. Calling "Ma>" would actually
continue the loop jumping to the beginning of the command line
since program counters referring to the macro A will be reused!
This cannot be easily solved by checking for loop termination
since being able to return that way from loops is a useful
feature. This is a problem even without loops and $$, e.g. as
in "@^Ua{1,2,3(4,5} Ma)".
Instead, a kind of expression stack frame pointer must be
added to macro invocation stack frames, pointing to the beginning
of the expression stack for the current frame.
At the end of macros or on return, the stack contents of
corresponding to the frame can be discarded while preserving the
immediate arguments at the time of the return or end-of-macro.
This would stabilize SciTECO's macro semantics.
* When a top-level macro returns in batch mode, it would
be a good idea to use the last argument to calculate the
process return code, so it can be set by SciTECO scripts (TODO).
|
|
|
|
* we cannot use G_N_ELEMENTS in attribute declarations with Clang
unless declaring C++11. In this case, since the size of the orig_color_table
is fixed anyway, the declaration was simply fixed.
* some reordering was necessary in cmdline.cpp. This should not
have any influence on GCC when optimizations are enabled.
* Scintilla/Scinterm had to be updated as well.
|
|
* this means that QRegSpecMachine::input() no longer has to return
a dummy QRegister in parse-only mode.
This saves an unnecessary QRegister table lookup and speeds up
parsing.
* QRegSpecMachine can now be easily extended to behave differently
when returning a Q-Register, e.g. simply returning NULL if a register
does not exist, or returning a register by prefix.
This is important for some planned commands.
* StateExpectQReg::got_register() now gets a QRegister *.
It can theoretically be NULL - still we don't have to check
for NULL in most cases since NULL is only passed in parse-only mode.
|
|
* ^FCLOSE is inserted when the "Close" key is pressed.
It is used by the GTK+ UI to deliver window close requests
and SIGTERM occurrences.
(this replaces the "Break" key used before in the GTK+ UI).
* The default action of ^FCLOSE is to quit SciTECO, therefore
window closing is possible even in --no-profile mode for instance.
* fixed a minor memleak in Cmdline::fnmacro()
* added ^FCLOSE implementation to fnkeys.tes to insert EX.
This currently has the disadvantage of overwriting
the error message with syntax errors if there are modified buffers
but it will at least not close the window if there are modified
buffers.
* SIGTERM will now be similar to SIGINT by default instead of
terminating SciTECO right away.
* the GTK+ UI handles SIGTERM by emulating the "close" key while
still interrupting like SIGINT.
* GTK+: SIGTERM and ^C will interrupt by sending SIGINT to the
entire process group instead of simply setting `sigint_occurred`.
This fixes interrupting EC and EG commands with long-running
or hanging programs and is relevant to the solution of #4.
|
|
* expands to the value of $HOME (the env variable instead of
the register which currently makes a slight difference).
* supported for tab-completions
* supported for all file-name accepting commands.
The expansion is done centrally in StateExpectFile::done().
A new virtual method StateExpectFile::got_file() has been
introduced to pass the expanded/processed file name to
command implementations.
* sciteco(7) has been updated: There is now a separate section
on file name arguments and file name handling in SciTECO.
This information is important but has been scattered across
the document previously.
* optimized is_glob_pattern() in glob.h
|
|
working directory
* FG stands for "Folder Go"
* FG behaves similar to a Unix shell `cd`.
Without arguments, it changes to the $HOME directory.
* The $HOME directory was previously only used by $SCITECOCONFIG on Unix.
Now it is documented on its own, since the HOME directory should also
be configurable on Windows - e.g. to adapt SciTECO to a MinGW or Cygwin
installation.
HOME is initialized just like the other environment variables.
This also means that now, the $HOME Q-Register is always defined
and can be used by platform-agnostic macros.
* FG uses a new kind of tab-completion: for directories only.
It would be annoying to complete the FG command after every
directory, so this tab-completion does not close the command
automatically. Theoretically, it would be possible to close
the command after completing a directory with no subdirectories,
but this is not supported currently.
* Filename arguments are no longer completed with " " if {} escaping
is in place as this brings no benefit. Instead no completion character
is inserted for this escape mode.
* "$" was mapped to the current directory to support an elegant way to
insert/get the current directory.
Also this allows the idiom "[$ FG...new_dir...$ ]$" for changing
the current directory temporarily.
* The Q-Register stack was extended to support restoring the string
part of special Q-Registers (that overwrite the default functionality)
when using the "[$" and "]$" commands.
* fixed minor typos (american spelling)
|
|
out beyond empty arguments
* it was annoying not to be able to rub out anything with ^W if the current string
argument was empty.
* Now, the special file name and string argument handling for ^W is effective
only if the current argument is non-empty, else we fall back to the rub-out-command
behaviour.
* So now, if you press ^W in a string argument, it is rubbed out until empty and
on the next ^W press, the entire command will be rubbed out.
|
|
* the rubout/reinsert-word behaviour of misc. string arguments
is suboptimal for file name arguments as it depends on Scintilla's
word characters.
By default, the directory separators are not considered word
characters, but this could be changed by the user.
* The behaviour of ^W in file name arguments is now fixed and
independant from the Scintilla configuration:
It always rubs out or re-inserts one hierarchy level of the
file name.
|
|
If there was a rubbed out command line and you tab completed
a file name in a string argument (TAB in ^G mode), the immediate
editing modifier was automatically reset.
This still happens if nothing could be tab completed and you
type a few characters and try to complete again (since ^G mode
will be reset). If this feature is used often, the user should perhaps
define a function key as ^G^I^G.
|
|
* fnkeys.tes has been updated to enable the command line
editing macros (cursor keys, etc.) only in the "start" state.
This avoids the annoying effect of inserting the macros
into string arguments where they have no effect and must be
rubbed out again.
|
|
* activated via bit 4 of the ED flag (enabled by default)
* automatic EOL guessing on file loading and translation to LFs.
* works with files that have inconsistent EOL sequences.
* automatic translation to original EOL sequences on file saving
* works with inconsistent EOL sequences in the buffer.
This should usually not happen if the file was read in with
automatic EOL translation enabled.
* also works with the EC and EG commands
* performance is OK, depending on the file being translated.
When reading files with UNIX EOLs, the overhead is minimal
typically-sized files. For DOS EOLs the overhead is larger
but still acceptable.
* Return (line feed) is now an immediate editing command.
This centralizes EOL sequence insertion.
Later, other features like auto-indent could be added to
the editing command.
* get_eol() has been moved to main.cpp (now called
get_eol_seq()
* Warn if file ownership could not be preserved when
saving files.
* IOView has been almost completely rewritten based
on GIOChannels. The EOL translation code is also in IOView.
|
|
* dirname and basename calculations can be done easier with
the new file_get_dirname_len()
* platform-dependant derive_dir_separator() function has been removed
|
|
We used g_path_get_dirname() which does not always return strict prefixes
of the input file name. For file names without directory, it returns "."
(the current directory). This is useful for passing that directory to
functions expecting a proper directory (like g_dir_open()) but was
unsuitable for building file name candidates for autocompletion.
Therefore, we tried to determine if the dirname is a prefix of the filename.
This however failed for "hidden" file names beginning with dot.
All in all it is easier to calculate our own directory name based on
the previously calculated basename than to handle the current-directory
case with g_path_get_dirname(). Now we'll get "" for the current directory,
so we have to handle the empty-string-is-current-dir case.
|
|
* for historic reasons, the backspace key can be transmitted as
^H by the terminal. Some terminal emulators might do that - these
are fixed by this commit.
* Use CTL_KEY('H') instead of standard C '\b' as the former is less
ambiguous given the confusion around the backspace character.
|
|
CTL_KEY_ESC_STR
* the reason for the CTL_KEY() macro is to get the control character
resulting from a CTRL+Key press -- at least this is how SciTECO
presents these key presses.
It is also a macro and may be resolved to a constant expression,
so it can be used in switch-case statements.
Sometimes it is clearer to use standard C escape sequences (like '\t').
* CTL_KEY('[') for escape is hard to read, so I always used '\x1B' which
is even more cryptic.
|
|
* the popup resetting was done after character insertion, so typing
0EB would clear the popup immediately
* the new implementation is functionally equivalent to the
old pre-reinsertion-commandline-handling, by resetting the popup
based on the immediate editing command before insertion
|
|
we are not guaranteed to reach the start parser state
again if the command is not terminated on the rubbed out
command line
|
|
|
|
* we cannot prevent GTK from delivering the function key presses,
as we can on Curses. Therefore Cmdline::fnmacro() checks again if
function keys are enabled.
|
|
* this is a Linux/glibc-only optimization
|
|
(also replaces ^T)
* CTRL+G toggles the behaviour of the rubout (Backspace, ^W, ^U) commands:
When the so called immediate editing command modifier is enabled/active,
the rubout commands will do the opposite and insert from the rubbed out
command line.
This command is somewhat similar to Emacs' C-g command.
* The CTRL+G command also replaces the ^T immediate editing command
for auto-completing filenames in any string argument.
Now the TAB key can be used for that purpose after activating the
^G modifier.
^T is a classic TECO command that will be supported sooner or later
by SciTECO, so it's good to have it available directly.
|
|
cleanup/refactoring
* characters rubbed out are not totally removed from the command line,
but only from the *effective* command line.
* The rubbed out command line is displayed after the command line cursor.
On Curses it is grey and underlined.
* When characters are inserted that are on the rubbed out part of the command line,
the cursor simply moves forward.
NOTE: There's currently no immediate editing command for reinserting the
next character/word from the rubbed out command line.
* Characters resulting in errors are no longer simply discarded but rubbed out,
so they will stay in the rubbed out part of the command line, reminding you
which character caused the error.
* Improved Cmdline formatting on Curses UI:
* Asterisk is printed bold
* Control characters are printed in REVERSE style, similar to what
Scinterm does. The controll character formatting has thus been moved
from macro_echo() in cmdline.cpp to the UI implementations.
* Updated the GTK+ UI (UNTESTED): I did only, the most important API
adaptions. The command line still does not use any colors.
* Refactored entire command line handling:
* The command line is now a class (Cmdline), and most functions
in cmdline.cpp have been converted to methods.
* Esp. process_edit_cmd() (now Cmdline::process_edit_cmd()) has been
simplified. There is no longer the possibility of a buffer overflow
because of static insertion buffer sizes
* Cleaned up usage of the cmdline_pos variable (now Cmdline::pc) which
is really a program counter that used a different origin as macro_pc
which was really confusing.
* The new Cmdline class is theoretically 8-bit clean. However all of this
will change again when we introduce Scintilla views for the command line.
* Added 8-bit clean (null-byte aware) versions of QRegisterData::set_string()
and QRegisterData::append_string()
|
|
string-utils.cpp and string-utils.h
* also improved performance of String::append() by using g_realloc()
* added String::append() variant for non-null-terminated strings
|
|
|
|
* the ^I command was altered to insert indention characters
rather than plain tabs always.
* The <TAB> immediate editing command was added for all
insertion arguments (I, ^I but also FR and FS)
* documentation was extended for a discussion of indention
|
|
Windows
* this is actually UNTESTED on Windows
|
|
optimized screen refreshing/redrawing
* pressing e.g. TAB when the popup is showing a list of auto-completions
will show the next page, eventually beginning at the first one again.
* do not redraw curses windows in the UI methods directly. this resulted
in flickering during command-line editing macros and ordinary macro calls
because the physical screen was updated immediately.
Instead, window refreshing and updated is done centrally in
event_loop_iter() only after a key has been processed.
Also we use wnoutrefresh() and doupdate() to send as little to the
terminal (emulator) as possible.
|
|
* added platform-dependant file_is_visible() function
|
|
* in batch mode, Scintilla undo actions are simply leaked memory
* Since we have more than one Scintilla view now, we must empty
the undo buffer of all scintilla views when a command line is committed ($$)
|
|
* implements the same globbing as the EB command already did
* uses Globber helper class that behaves more like UNIX glob().
glib only has a glob-style pattern matcher.
* The Globber class may be extended later to provide more
UNIX-like globbing.
* lexer.tes has been updated to make use of globbing.
Now, lexers can be automatically loaded and registered at
startup. To install a new lexer, it's sufficient to copy
a file to the lexers/ directory.
|
|
the QUIT hook is actually not that trivial and required
some architectural changes.
First, the QUIT hook execution and any error that might
occurr cannot always be attached to an existing error stack
frame. Thereforce, to give a stack frame for QUIT hooks and
to improve the readability of error traces for ED hooks in general,
a special EDHookFrame is added to every ED hook execution error.
Secondly, since QUIT hooks can themselves throw errors, we cannot
run it from an atexit() handler. Instead it's always called manually
before __successful__ program termination. An error in a QUIT hook
will result in a failure return code nevertheless.
Thirdly, errors in QUIT hooks should not prevent program termination
(in interactive mode), therefore they are only invoked from main()
and always in batch mode. I.e. if the interactive mode is terminated
(EX$$), SciTECO will switch back to batch mode and run the QUIT
hook there. This is also symmetric to program startup, which is
always in batch mode.
This means that Interface::event_loop() no longer runs indefinitely.
If it returns, this signals that the interface shut down and
batch mode may be restored by SciTECO.
|
|
Template Pattern.
* without the one-view-per-buffer designs, many Scintilla send message (SSM)
calls could be inlined
* with the new design, this was no longer possible using the abstract
base classes. the CRT pattern allows inlining again but introduces
a strange level of code obscurity.
* tests suggest that at high optimization levels, the one-view-per-buffer
design and the CRT pattern reduces typical macro runtimes by 30%
(e.g. for symbols-extract.tes).
* only updated the NCurses UI for the time being
|
|
* the GError expection has been renamed to GlibError, to avoid
nameclashes when working from the SciTECO namespace
|
|
normally, since SciTECO is not a library, this is not strictly
necessary since every library should use proper name prefixes
or namespaces for all global declarations to avoid name clashes.
However
* you cannot always rely on that
* Scintilla does violate the practice of using prefixes or namespaces.
The public APIs are OK, but it does define global functions/methods,
e.g. for "Document" that clashed with SciTECO's "TECODocument" class at
link-time.
Scintilla can put its definitions in a namespace, but this feature
cannot be easily enabled without patching Scintilla.
* a "SciTECO" namespace will be necessary if "SciTECO" is ever to be
turned into a library. Even if this library will have only a C-linkage
API, it must ensure it doesn't clutter the global namespace.
So the old "TECODocument" class was renamed back to "Document"
(SciTECO::Document).
|
|
behaves just like ^T in string arguments.
later we might add special Bash-completion support
|
|
powerful command for filtering a SciTECO buffer through an external
program. It will be described in the sciteco(7) man pages.
The implementation uses an asynchronous background process with
pipes but is platform independant thanks to glib's g_spawn functions,
GIOChannels and event loops.
There are however platform differences in how the operating system
command is interpreted/parsed.
|
|
* they have been marked deprecated in recent libglib versions (since v2.26)
* there is no alternative in recent libglib versions, so we
simply do it with a little string handling.
this works with older and newer libglib versions.
|
|
|
|
* specifications resulted in runtime errors (unexpected exception) when bad_alloc ocurred
* specs should be used scarcely: only when the errors that may be thrown are all known
and for documentary purposes
|
|
* when an error is thrown, stack frames are collected on clean up, up to
the toplevel macro
* the toplevel macro decides how to display the error
* now errors in interactive and batch mode are displayed differently
* in batch mode, a backtrace is displayed as a sequence of messages
* Execute::file() forwards errors correctly
* the correct error in the file is displayed in interactive mode
* necessary to build the stack trace
|
|
since including glib.h on LLVM-Clang (32-bit) results in NULL being
redefined to 0 and compiler warnings being emitted when NULL is used
as sentinels
|
|
tab-completions
* StateExpectFile adds no functionality (currently), but is useful for checking state types
|
|
* flow control and other structures have not been documented this ways.
I have not yet decided whether they should be documented in separate
sections or use the documentation tool.
|
|
|
|
initialization revised
* g_get_environ() appears to be broken, at least in Wine and Win2k
|
|
ensure that undo tokens for first differing characters are actually
associated with this character instead of the next.
(resulted in strange behaviour on rubout and subsequent replacements)
|
|
macros
* if enabled, when a function key is pressed it is looked up in Q-Registers ^F...
e.g. HOME key corresponds to register ^FHOME
* the string if available is inserted as if it was entered by key-presses
(later it may be entered as a single input token which may be removed in a single rubout)
* only NCurses currently, key names directly correspond to Curses key names
* on Curses if function keys are enabled ESCAPE will be inserted after a delay
(because function keys are transmitted via escape sequences).
A function key macro may be used to define an alternative escape character
|
