[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: Release plans

From: Thomas Lord
Subject: Re: Release plans
Date: Fri, 29 Aug 2008 12:13:51 -0700
User-agent: Thunderbird (X11/20060808)

Bruce Stephens wrote:
Is this an abstract discussion or is it concretely about Emacs and
CEDET?  (I'm struggling to imagine what realistic benefit CEDET might
get from a dynamic extension to Emacs.  Maybe linking with SQLite?)

That's an interesting idea.   I was thinking about tools for incremental
parsing as an example.   Fast and good support for small databases
makes sense, too.

Other people mentioned other applications of a dynamic loader,
too, not necessarily IDE related (e.g., image manipulation, network
protocols, etc.)

In general, anytime you want the coroutine to use a lot of data
that normally sits in Emacs memory (e.g., buffer contents) -- and
you want that coroutine to randomly access that data or in other
ways have fast access to it -- a dynamic loader would be handy.

I don't claim, by the way, that a dynamic loader makes perfect
technical sense for GNU Emacs as it stands today.   It *might*
and it *might not*.  I do claim that that fears of non-free add-ons
aren't argument enough against a dynamic loader.  So, the discussion
is abstract in that sense, I guess.

Surely XRefactory's big advantage over CEDET is use of an EDG-based
parser (which costs money)?  So in that sense the restrictions on how
the core gcc project develops (whether it can provide suitable dumps
of parse trees and the like) are more significant than restrictions on

It could be.

Hmm.  There is an architecture to consider:  Imagine dynamically
loadable parsers for your favorite languages.   Might there be a
reasonable API design such that a single parsing tool can do both
incremental parsing / re-parsing and efficient straight-through parsing,
producing output (in the form of API calls or return values) suitable
for both building GCC trees and updating text properties and database
values in an IDE?

If so, can tools such as Bison be extended to support generation
of the incremental (re-) parsing parts (e.g., with suitable ways of
handling parse errors and recovery in an incremental context)?

The resulting "kit" of Emacs w/DL + GCC w/DL +  extended Bison
could be very fun to play with.


reply via email to

[Prev in Thread] Current Thread [Next in Thread]