The previous code would skip parsing with sub-parsers so these would not
work. Running full createTagsWithFallback1() in this case would cause
two problems:
1. We would have to propagate the extra callback arguments to
runParserInNarrowedInputStream()
2. And the callbacks after each pass should not actually be called in this
case because the caller expects these are called for the master parser,
not the sub-parsers.
So instead just do simple parsing without re-tries which are used only in
the C and Fortran parsers which lack sub-parser capability anyway.
Library users probably want all found tags and decide themselves whether
the tag is interesting for them or not. Revert "enabled" values in c.c
to their previous values to match uctags as these are ignored now.
First, make sure that when calling cppGetc() and cppUngetc() the signature
is properly updated.
Second, make sure that signature is cleared when preparing for new token
read.
This commit basically just moves stuff from tm_ctags_wrappers.c/h to
ctags. The "api.h" file has been renamed to "ctags-api.h" to make it
clearer it belongs to ctags when included.
The code also tries to completely isolate ctags from the caller;
previously we were using tagEntryInfo to pass information to Geany. This
however required including entry.h which added lots of other stuff we
don't want in the API. Instead create an auxiliary struct that holds
all the needed information from tagEntryInfo (currently only the stuff
used by Geany) and copy all the info from tagEntryInfo before invoking
the callback.
Protect library-specific stuff by CTAGS_LIB macro which also makes it
better visible what changes had to be made to convert ctags into library.
Changes which need further Geany sync and aren't library-related aren't
protected by the macro.
Move things from geany.c/h to the locations where they belong and rename
geany.c/h to api.c/h into which API-like functions will be moved in the
next commits (mostly things from tm_ctags_wrappers.c/h).
Add complete main.c from uctags and just remove main() using the CTAGS_LIB
macro.
See
cd460f4c19bf940fc4290b5ceca1dba873baf7cb
eb347f8fe08ac0d5467b4020aceb1a5ecbdd12aa
That said the readLineRaw() is completely mad and wrong. In the first
iteration pLastChar is set to position -2 where it's assigned '\0' so
there's invalid memory access.
Since iFileGetLine() uses mio_gets() too, we should unify the two.
If we don't define the DEBUG macro (which we don't), all the assert
operations will be NOOPs. The asserts aren't that terribly useful
(usually the crash happens just the following line) and uctags should
be reasonably well tested by the uctags project so we can drop them.
At this point the only remaining files with big changes are parser.c/h
and nestlevel.c/h. However, the amount of changes is big and these
changes cannot be easily separated into individual small patches. Fortunately
by looking at parse.c there doesn't seem to be anything really valuable
in Geany's version and we can just simply take over the ctags one and
only apply the necessary changes on top of that. nestlevel.c/h has to
be synced at the same time as the changes are related to cork introduction
which was done in both of them.
A few points:
createTagsWithFallback1() and createTagsWithFallback() have been modified
so they don't do anything with the output tags file which we don't use.
Because they contain all the reparsing logic we originally had in
tm_ctags_parse(), this function got simplified and just calls
createTagsWithFallback().
In Options EX_PATTERN has been changed to EX_LINENUM (there's some strange
thing with EX_PATTERN in uctags as it always checks the previous line
in the output tags file - and we don't have output tags file so it
crashes).
Lots of previously commented-out lines (because we didn't have all the
functions from uctags at that point) could be uncommented.
lxpath.c has been added.
Parsers had to be adjusted to work with the updated nestlevel and cork.
Changes in asciidoc and rest were based on the "rst.c" parser from uctags.
txt2tags has been modified manually. The ruby changes wer taken directly
from the uctags ruby parser and the python ones were based on the last
commit before the introduction of the token-based parser.
The parser now respects if kinds are enabled/disabled so prototypes
and externvars had to be enabled in the c.c parser to get the same output.
The parse2() function now returns rescanReason union instead of simple
bool to indicate reparsing should happen - c.c and fortran have been
changed accordingly.
tm_ctags_init() has been changed to call all the initialization that
happens in uctags except of output tag file initialization which we don't
use. In addition it calls
initializeParser (LANG_AUTO)
This forces all parsers to get initialized. Without it parsers get
initialized lazily as they are used but the problem is code like
isInputLanguage (Lang_java)
in c.c which just does ((lang) == getInputLanguage ()) works incorrectly
because getInputLanguage () returns 0 for C and when uninitialized,
Lang_java is also 0 and we have a problem. This problem isn't present in
uctags because there the 0th parser is always CTagsSelfTestParser
so this cannot happen.
I didn't check in detail what the changes are but since no GRegex code is
involved and since everything seems to work after the patch, I think it's OK.
In addition, add automatic memory MIO opening to read.c for small files
and remove the same optimization from Geany. Simplify tm_ctags_parse()
as the memory/file branches are identical now.
