| Age | Commit message (Collapse) | Author | Files | Lines |
|---|
|
or codepoints) (refs #5)
* This is trickier than it sounds because there isn't one single place to consult.
It depends on the context.
If the string argument relates to buffer contents - as in <I>, <S>, <FR> etc. -
the buffer's encoding is consulted.
If it goes into a register (EU), the register's encoding is consulted.
Everything else (O, EN, EC, ES...) expects only Unicode codepoints.
* This is communicated through a new field teco_machine_stringbuilding_t::codepage
which must be set in the states' initial callback.
* Seems overkill just for ^EUq, but it can be used for context-sensitive
processing of all the other string building constructs as well.
* ^V and ^W cannot be supported for Unicode characters for the time being without an Unicode-aware parser
|
|
|
|
* This will naturally work with both ASCII characters and various
non-English scripts.
* Unfortunately, it cannot work with the other non-ANSI single-byte codepages.
* If we'd like to support scripts working with all sorts of codepoints,
we'd have to introduce a new command for translating individual codepoints
from the current codepage (as reported by EE) to Unicode.
|
|
* The ASCII compiler would try to escape ("\") all bytes of a multibyte
UTF-8 glyph.
* The new implementation escapes only metacharacters and passes down
all non-ANSI glyphs unchanged.
On the downside, this will work only with PCREs.
|
|
* I decoded the Scintilla charset values into codepages, at least
those used on Gtk.
* make sure that the line character index is not allocated or released
too often, as it is actually internally reference counted, which
could result in it missing when we really need it.
* The line character index still appears to be released whenever
the document pointer changes, which will happen after using
a different Q-Register.
This could be a performance bottleneck (FIXME).
|
|
teco_state_start_get() (refs #5)
|
|
There is a widespread myth that they could take up to 6 bytes.
|
|
between glyph and byte offsets (refs #5)
* ^E is heavily overloaded and can also be used to check whether a given index is valid
(as it is the same that most movement commands to internally).
Besides that, it is mainly useful for interfacing with Scintilla messages.
* EE takes a code page or 0 for ANSI/ASCII.
Currently all documents and new registers are UTF-8.
There will have to be some kind of codepage inheritance and a single-byte-only mode.
|
|
* this required adding several Q-Register vtable methods
* it should still be investigated whether the repeated calling of
SCI_ALLOCATELINECHARACTERINDEX causes any overhead.
|
|
* the locale must be initialized very early before g_option_context_parse()
* will allow UTF-8 characters in the test suite
|
|
* This works reasonably well unless lines are exceedingly long
(as on a line we always count characters).
The following test case is still slow (on Unicode buffers):
10000<@I/XX/> <%a-1:J;>
While the following is now also fast:
10000<@I/X^J/> <%a-1:J;>
* Commands with relative character offsets (C, R, A, D) have
a special optimization where they always count characters beginning
at dot, as long as the argument is now exceedingly large.
This means they are fast even on exceedingly long lines.
* The remaining commands (search, EC/EG, Xq) now accept glyph indexes.
|
|
(refs #5)
certain test cases are still way too slow:
10000<@I/X^J/> 20000<R>
or
10000<@I/X^J/> 20000<%a-1J>
SCI_ALLOCATELINECHARACTERINDEX does not help much here.
It probably speeds up only SCI_LINEFROMINDEXPOSITION and SCI_INDEXPOSITIONFROMLINE.
|
|
* All non-ASCII characters are inserted as Unicode.
On Curses, this also requires a properly set up locale.
* We still do not need any widechar Curses, as waddch() handles
multibyte characters on ncurses.
We will see whether there is any Curses variant that strictly requires
wadd_wch().
If this will be an exception, we might keep both widechar and non-widechar
support.
* By convention gsize is used exclusively for byte sizes.
Character offsets or lengths use int or long.
|
|
unsigned integer
* SCI_GETCHARAT is internally casted to `char`, which may be signed.
Characters > 127 therefore become negative and stay so when casted to sptr_t.
We therefore cast it back to guchar (unsigned char).
* The same is true whenever returning a string's character to SciTECO (teco_int_t)
as our string type is `gchar *`.
* <^^x> now also works for those characters.
Eventually, the parser will probably become UTF8-aware and this will
have to be done differently.
|
|
* You no longer have to copy contrib/scintilla, contrib/scinterm and contrib/lexilla
manually to the build directory.
* It turns out, that Scintilla/Lexilla was supporting this since 2016.
Scintilla allows pointing to a source directory (srdir) and Lexilla to a binary directory (DIR_O).
* For Scinterm I opened a pull request in order to add srcdir/basedir variables:
https://github.com/orbitalquark/scinterm/pull/21
* `make distcheck` is therefore now also fixed.
* The FreeBSD package is now allowed to build out of source.
I haven't tested it yet.
* See also https://github.com/ScintillaOrg/lexilla/issues/266
|
|
numbers now
* Instead of TECO_OP_NEW, there should perhaps simply be a flag of whether `,` was used.
|
|
* in fact, with a negative exponent the previous naive implementation would even hang indefinitely!
* Now uses the squaring algorithm.
This is slightly longer but significantly more efficient.
* added test cases
|
|
* It's generally a bad idea to pass backslashes as a glyph in macro arguments, even as `\\`
since this could easily be interpreted as an escape.
* Instead we now always use `\[rs]`.
|
|
* gboolean cannot be used since it is a signed type
* bool is still more readable, even though we mostly use glib typedefs.
* AFAIK the glib types are deprecated, so sooner or later we will switch
to stdint/stdbool types anyway.
|
|
* This is the same variable used by gtk3-nocsd, but we will now work
even without preloading any libraries.
Also, it turns out that gtk3-nocsd does not ship as a FreeBSD port
and hasn't been updated in a long time.
* Setting this in .teco_ini wouldn't have been easy since the
teco_interface_init() is called before any TECO code.
Also, you might not even want disable this globally but depending
on the window manager.
* Therefore, you are advised to `export GTK_CSD=0` in ~/.xsession.
* The --no-csd command line option is kept for the time being,
but probably serves no more purpose.
|
|
* Also turns out, I will have to use gtk_window_set_icon_list().
* This fixes icons in tabbed and st (when embedding SciTECO).
|
|
* Horizontal movements (left/right cursor keys) establish the current column
and vertical movements (up/down) will try to keep on that column.
* This has long been problematic in SciTECO as it requires state that gets
reversed when the command line replacement takes place.
* I experimented with encoding the current horizontal position into the braced
movement operations as in (123C5U$), but I decided that this was clumsy and
I generally did not want these expressions to become even larger.
* Instead I decided to add some minimal support to the C core in the form of 4EJ
which is like a number register only that it does NOT get reversed on rubout.
This is exploited by the fnkeys.tes macros by storing the current position
beyond replacements.
* In theory, this should be a property of the document, but we cannot easily
store custom parameters per document.
So instead, there is just one global variable.
When editing another buffer, it gets reset to .ESGETCOLUMN$$.
sample.teco_ini has been updated.
* The current X position only makes sense in the context of fnkeys.tes, as
TECO commands like <C> are not necessarily "horizonal" movements.
For the same reason, the core does not try to initialize 4EJ automatically
when editing new buffers.
It's entirely left to the TECO macros.
* The commandline replacement is more robust now as it checks braced
expressions at the end of the command line more thorougly.
It will no longer swallow all preceding braced expressions.
Only if they are at least 4 characters in length and end in `C)` or `R)`.
|
|
|
|
(-Wsingle-bit-bitfield-constant-conversion)
* gboolean is defined as gint which is a signed type.
A gboolean 1-bit-wide bitfield cannot have the values 0 and 1 but only 0 and -1.
* This wasn't practically a bug unless you would try to compare one of those bitfields
with TRUE.
* All of those bitfields are now guint, even though this is less self-documenting.
|
|
* passing an empty command string down to the shell would always do nothing,
so it doesn't make sense to support that.
* for the time being, we generate a proper error
* in the future, it might make sense to define some special behavior like repeating
the last command - but EC does not currently save the command line anywhere.
* The generated documentation is currently ugly (FIXME).
mandatory parameters are not properly detected by tedoc and we cannot keep apart
Q-Registers from mandatory parameters either.
Also, we should allow <param> markup in command summaries.
|
|
* This was setting only the teco_doc but wasn't calling the necessary
set_string() methods.
* The idiom [$ FG...$ ]$ to change the working directory temporarily
now works.
* Similarily you can now write [~ ^U~...$ ]~ to change the clipboard
temporarily.
* Added test suite cases. The clipboard is not tested since
it's not supported everywhere and would interfer with the host system.
* Resolved lots of redundancies in qreg.c.
The clipboard and workingdir Q-Regs have lots in common.
This is now abstracted in the "external" Q-Reg base "class"
(ie. via initializer TECO_INIT_QREG_EXTERNAL()).
It uses vtable calls which is slightly more inefficient than per
register implementations, but avoiding redundancies is probably more
important.
|
|
for debug builds
* There is cleanup that is not strictly necessary, because it only frees memory
which is freed on program termination anyway.
* However, it helps to explicitly free everything for debugging memory leaks via Valgrind.
* The new macro reduces the number of #ifdef statements.
* On NDEBUG, the code of these functions will still be eliminated.
* If functions are referenced only from the destructor, there will be no unused function
warnings, even in NDEBUG.
|
|
* Useful for packaging on platforms where we can only build from tarballs (FreeBSD)
* I don't know whether it's always safe and correct to install this file into $DATADIR/applications,
so the file is only distributed but not installed yet.
* It contains a hardcoded binary name "gsciteco". This could actually differ
depending on the concrete --program-prefix and it would be good to include the exact
installation path.
This however is not possible as long as we do not install this file.
|
|
* This is also the base of $SCITECOPATH.
* Changing it is useful for packaging where it is not possible to factor out the common
files between Curses and Gtk builds into a "sciteco-common" package.
As an alternative, you can now create disjunct sciteco-curses and sciteco-gtk packages.
* You will most likely want to use this for Gtk builds as in:
--with-interface=gtk --program-prefix=g --with-scitecodatadir=/usr/local/share/gsciteco.
|
|
* Since Scintilla no longer automatically scrolls the caret (see 941f48da6dde691a7800290cc729aaaacd051392),
the caret wouldn't always end up in the view on startup.
* Added teco_interface_refresh() which includes SCI_SCROLLCARET and
is invoked on startup. This helps with the Curses backend.
It also reduces code redundancies.
* On Gtk, the caret cannot be easily scrolled on startup as long as no size is allocated
to the window, so we also added a size-allocate callback to the
window's event box. Sizes are less often allocated to the event box than to the
window itself for some strange reason.
|
|
* This probably did not cause any bugs.
|
|
default now
* On FreeBSD both the dlmalloc replacement and poll-thread via sysctl() work
but the poll-thread has been benchmarked to be significantly faster,
at least on my machine.
You can still ./configure --enable-malloc-replacement of course.
* Interestingly, the RSS of the process visible via htop does not decrease
after OOMs or command-line terminations - with neither of the implementations.
|
|
* This especially fixes spawning on 0,128ED-mode broken since
f557af9a9112955d3b65f6ad0d54c0791189f961.
* The process is added to a job object now, which allows us to
kill the entire process tree.
Previously we we were leaving around orphaned processes.
|
|
|
|
* teco_interrupt() turned out to be unsuitable to kill child processes (eg. when <EB> hangs).
Instead, we have Win32-specific code now.
* Since SIGINT can be ignored on UNIX, pressing CTRL+C was not guaranteed to kill the
child process (eg. when <EB> hangs).
At the same time, it makes sense to send SIGINT first, so programs can terminate gracefully.
The behaviour has therefore been adapted: Interrupting with CTRL+C the first time will kill
gracefully. The second time, a more agressive signal is sent to kill the child process.
Unfortunately, this would be relatively tricky and complicated to do on Windows, so CTRL+C will always
"hard-kill" the child process.
* Moreover, teco_interrupt() killed the entire process on Windows when called the second time.
This resulted in any interruption to terminate SciTECO unexpectedly when tried the second time on Gtk/Win32.
* teco_sigint_occurred renamed to teco_interrupted:
There may be several different sources for setting this flag.
* Checking for CTRL+C on Gtk involves driving the main event loop repeatedly.
This is a very expensive operation. We now do that only every 100ms. This is still sufficient since
keyboard input comes from humans.
This optimization saves 75% runtime on Windows and 90% on Linux.
* The same optimization turned out to be contraproductive on PDCurses/WinGUI.
|
|
* test case: ECwhile true; do true; done$
* Some platforms require polling via teco_interface_is_interrupted()
for detecting interruptions, so we added an idle watcher to the
Glib event loop in spawn.c.
* On platforms that do not require polling key presses (like Unix/ncurses),
the idle watcher won't do any harm.
|
|
* The caret wasn't always kept out of the UZ and at some point would totally leave the view.
This was apparently cause by executing two SCI_SCROLLCARETs per teco_interface_cmdline_update().
* Instead, we now use a CARET_EVEN scroll policy which also works sufficiently well.
|
|
* This is using an Input Method now.
* Entering dead keys has probably always been broken in Gtk which I only did not notice
because I use a keyboard layout without dead keys.
This affects the ^ and ` keys on a German layout.
* Once we support Unicode input, it would make sense to abuse Scintilla's already existing input method support.
Unfortunately, forwarding keyboard events to the Scintilla view breaks event freezing and results in flickering.
|
|
PDCurses/WinGUI
* we can neither display, nor parse Unicode characters properly, so this does not worsen anything
* makes it harder to confuse the parser as long as we do not support Unicode.
* behaves like on Gtk: pressing a non-ASCII char will simply be ignored
* Most importantly, this fixes crashes on PDCurses/WinGUI.
It apparently couldn't handle the negative integers that resulted from passing a value >= 0x80 <= 0xFF
into gchar (which is a signed integer).
Changing everything into guchar is not worth the effort - we need full Unicode support anyway.
|
|
g_object_unref()
* Turns out that using gtk_widget_destroy(), the finalize handler never gets called!?
This means we were leaking memory.
* Using g_object_unref() fixes that and the initial Scintilla patch is no longer necessary.
* There have previously been use-after-free bugs when *not* using gtk_widget_destroy().
This has apparently been fixed in the meantime in Scintilla.
|
|
* Turns out it is impossible - or at least very tricky - to avoid undo token emission
for insert_len.
I therefore opt for stability rather than saving memory.
* The old workaround introduced in a6b5394086260c262e393dd113057916fd14134b would actually
fail if you do not rub out the string argument completely after interruption. I.e.
You type <Ihello^J$>, interrupt - insert_len may be != 0 at this point - and _partially_
rubout the insert-command and continue typing.
This could still crash the editor.
|
|
Scintilla now
* The patch avoids all automatic scrolling consistently, including in SCI_UNDO.
This speads up Undo (especially after interruptions).
* Also, the patch disables a very costly and pointless (in SciTECO) algorithm that
effectively made <Ix$> uninterruptible.
* Effectively reverts large parts of 8ef010da59743fcc4927c790f585ba414ec7b129.
I have never liked using unintuitive Scintilla messages to avoid scrolling.
|
|
* actually everything is updated to their current HEADs but the aforementioned versions are close.
* Scintilla uses threads now, so we added checks for pthread.
To be on the safe side, we imported AX_PTHREAD from the Autoconf archives.
The flags are kept out of the ordinary build system, though and used only for compiling Scintilla
and for linking.
SciTECO may also use threads, but via Glib.
* Scinterm removed SCI_COLOR_PAIR(), so we re-added it to src/interface-curses/interface.c.
* There is an Asciidoc lexer now.
* The <Ix$> interruption bug (see TODO) is not fixed by this upgrade.
Perhaps the Mac OS version runs better now. Feedback is needed (refs #12).
|
|
* In order to provoke this bug, there must be a loop with a string command.
For instance <Ifoobar^J$>.
When interrupting this loop, ctx->expectstring.insert_len might end up > 0.
This breaks an optimization that avoids undo tokens for insert_len since it
is usually reset to 0 after every keypress.
Once you rubout everything and retype `I`, you can crash SciTECO.
* I am not sure if this solution is ideal.
An alternative might be adding teco_state_expectstring_initial(),
but we would have to chain to it from some child states that have their
own initial() callback.
Of course, we could also simply teco_undo_gsize(insert_len) at the cost
of undo tokens.
|
|
* This does not make sense for most SciTECO builds, but only when you
want to optimize for size as the lexers take up 50% of the compressed binary
size.
Without Lexilla, it should be possible get it compiled in about 500kb.
* It can be useful for instance when building for embedded distributions.
* When Lexilla is disabled, symbols-scilexer.c is also not generated
(we assume that the Lexilla sources are not available and it also doesn't serve any purpose).
* Consequently, most of the lexer configuration scripts are also not installed
under --without-lexilla.
|
|
* This would sometimes rub out more than expected due to
reading undefined memory.
Actually even crashes were not impossible.
* This is because SCI_GETWORDCHARS does not null-terminate the buffer
it writes but this was assumed.
In effect, we could easily read beyond the allocated memory in wchars
if there doesn't happen to be a null-char following the buffer.
* Consequently, null-chars in word chars were also not supported,
although this would hardly trouble anybody.
* Instead, we now store the word chars in a teco_string_t which
supports non-null-terminated strings natively.
Still we null-terminate the string to keep teco_string_t's promises
about degrading to null-terminated char *.
This is currently not necessary.
* teco_is_wordchar() has been replaced by teco_string_contains().
|
|
* We no longer need special NULL-values for teco_cmdline_insert(),
as teco_cmdline_rubin() will simply take a character from the rubbed-out
command line and is equivalent to typing a character from the rubbed-out
command-line.
|
|
* The rubbed out command line should not be discarded.
* This has been broken since 432ad24e382681f1c13b07e8486e91063dd96e2e
(C conversion).
|
|
|
|
* Courier has the quirk that letter sequences like "fi" are turned into ligatures
which breaks the monospaced nature of the display.
* We assume that "Monospace" is also more portable, although it hasn't yet been tested on Windows.
* only relevant for the Gtk UI of course
* It might be a good idea to set SCI_STYLESETCHECKMONOSPACED as well (FIXME?)
|
