You ask, "Is there any way to maintain a list of source words?" But you do not specify what you mean by "maintain".
Here is one possibility that comes to mind, wrt maintaining a list of completion source words: Take a look at the very old but still useful and interesting (IMO) library completion.el, which has long been (and still is) part of Emacs.
The only documentation for it is its Commentary.
The idea is that (if completion-mode is on) a "database" (file) of source words is automatically filled out and updated as you type or as you move the cursor over text.
In addition, completion.el optionally provides dabbrev-style completion. From comments in completion.el:
This method is used if there are no useful stored completions. It is
based on dabbrev-expand with these differences :
1) Faster (we don't use regexps)
2) case coercion handled correctly
This is called cdabbrev to differentiate it.
We simply search backwards through the file looking for words which
start with the same letters we are trying to complete.
By default, the updated set of source words is saved to disk when you end an Emacs session, and by default it is loaded into a subsequent session.
So this is one kind of source-words "maintaining": automatic updating as you "use" words interactively. In addition, you can easily update the source words using Lisp -- see functions add-completions-from-buffer, add-completions-from-lisp-file, and add-completions-from-tags-table. And there are commands to add or remove source words interactively.
Because few people know about this feature and it is not documented (you really have to know it is there and then open completion.el, to learn about it), I repeat the Commentary from the file here.
What to put in .emacs
-----------------------
(dynamic-completion-mode)
Documentation [Slightly out of date]
---------------------------------------------------------------------------
(also check the documentation string of the functions)
Introduction
---------------
After you type a few characters, pressing the "complete" key inserts
the rest of the word you are likely to type.
This watches all the words that you type and remembers them. When
typing a new word, pressing "complete" (meta-return) "completes" the
word by inserting the most recently used word that begins with the
same characters. If you press meta-return repeatedly, it cycles
through all the words it knows about.
If you like the completion then just continue typing, it is as if you
entered the text by hand. If you want the inserted extra characters
to go away, type control-w or delete. More options are described below.
The guesses are made in the order of the most recently "used". Typing
in a word and then typing a separator character (such as a space) "uses"
the word. So does moving a cursor over the word. If no words are found,
it uses an extended version of the dabbrev style completion.
You automatically save the completions you use to a file between
sessions.
Completion enables programmers to enter longer, more descriptive
variable names while typing fewer keystrokes than they normally would.
Full documentation
---------------------
A "word" is any string containing characters with either word or symbol
syntax. [E.G. Any alphanumeric string with hyphens, underscores, etc.]
Unless you change the constants, you must type at least three characters
for the word to be recognized. Only words longer than 6 characters are
saved.
When you load this file, completion will be on. I suggest you use the
compiled version (because it is noticeably faster).
M-x completion-mode toggles whether or not new words are added to the
database by changing the value of enable-completion.
SAVING/LOADING COMPLETIONS
Completions are automatically saved from one session to another
(unless save-completions-flag or enable-completion is nil).
Activating this minor-mode (calling completion-initialize) loads
a completions database for a saved completions file
(default: ~/.completions). When you exit, Emacs saves a copy of the
completions that you often use. When you next start, Emacs loads in
the saved completion file.
The number of completions saved depends loosely on
*saved-completions-decay-factor*. Completions that have never been
inserted via "complete" are not saved. You are encouraged to experiment
with different functions (see compute-completion-min-num-uses).
Some completions are permanent and are always saved out. These
completions have their num-uses slot set to T. Use
add-permanent-completion to do this
Completions are saved only if enable-completion is T. The number of old
versions kept of the saved completions file is controlled by
completions-file-versions-kept.
COMPLETE KEY OPTIONS
The complete function takes a numeric arguments.
control-u :: leave the point at the beginning of the completion rather
than the middle.
a number :: rotate through the possible completions by that amount
`-' :: same as -1 (insert previous completion)
HOW THE DATABASE IS MAINTAINED
<write>
UPDATING THE DATABASE MANUALLY
m-x kill-completion
kills the completion at point.
m-x add-completion
m-x add-permanent-completion
UPDATING THE DATABASE FROM A SOURCE CODE FILE
m-x add-completions-from-buffer
Parses all the definition names from a C or LISP mode buffer and
adds them to the completion database.
m-x add-completions-from-lisp-file
Parses all the definition names from a C or Lisp mode file and
adds them to the completion database.
UPDATING THE DATABASE FROM A TAGS TABLE
m-x add-completions-from-tags-table
Adds completions from the current tags-table-buffer.
HOW A COMPLETION IS FOUND
<write>
STRING CASING
Completion is string case independent if case-fold-search has its
normal default of T. Also when the completion is inserted the case of the
entry is coerced appropriately.
[E.G. APP --> APPROPRIATELY app --> appropriately
App --> Appropriately]
INITIALIZATION
The form `(completion-initialize)' initializes the completion system by
trying to load in the user's completions. After the first call, further
calls have no effect so one should be careful not to put the form in a
site's standard site-init file.
And here is some more doc in the form of comments from completion.el:
---------------------------------------------------------------------------
"Symbol" parsing functions
---------------------------------------------------------------------------
The functions symbol-before-point, symbol-under-point, etc. quickly return
an appropriate symbol string. The strategy is to temporarily change
the syntax table to enable fast symbol searching. There are three classes
of syntax in these "symbol" syntax tables ::
syntax (?_) - "symbol" chars (e.g. alphanumerics)
syntax (?w) - symbol chars to ignore at end of words (e.g. period).
syntax (? ) - everything else
Thus by judicious use of scan-sexps and forward-word, we can get
the word we want relatively fast and without consing.
Why do we need a separate category for "symbol chars to ignore at ends" ?
For example, in LISP we want starting :'s trimmed
so keyword argument specifiers also define the keyword completion. And,
for example, in C we want `.' appearing in a structure ref. to
be kept intact in order to store the whole structure ref.; however, if
it appears at the end of a symbol it should be discarded because it is
probably used as a period.
Here is the default completion syntax ::
Symbol chars :: A-Z a-z 0-9 @ / \ * + ~ $ < > %
Symbol chars to ignore at ends :: _ : . -
Separator chars. :: <tab> <space> ! ^ & ( ) = ` | { } [ ] ; " ' #
, ? <Everything else>
Mode specific differences and notes ::
LISP diffs ->
Symbol chars :: ! & ? = ^
C diffs ->
Separator chars :: + * / : %
A note on the hyphen (`-'). Perhaps the hyphen should also be a separator
char., however, we wanted to have completion symbols include pointer
references. For example, "foo->bar" is a symbol as far as completion is
concerned.
FORTRAN diffs ->
Separator chars :: + - * / :
Pathname diffs ->
Symbol chars :: .
Of course there is no pathname "mode" and in fact we have not implemented
this table. However, if there was such a mode, this is what it would look
like.
