| Age | Commit message (Collapse) | Author |
|---|
|
Previously I used hash tables, which consume too much memory. Now the
critical parts are replaced by a new hand-written library called
"tuple.h". Now we can easily parse larger inputs. I haven't tested
its limits, though.
|
|
Hash tables take too much space!
If I use hash tables, the length of the input will be severely
limited, to an unacceptable extent. So we have to use arrays
instead.
|
|
Now we need to implement predicates, in order to have practical
applications.
|
|
I now have a working algorithm in test/check_cnp. It can correctly
parse the grammar for an esoteric language called "Brainfuck". This
language does not matter. What matters is that it contains
parentheses. So this shows that at least for grammars as complex as
parentheses, this parser works well. Haha.
|
|
THat file implements support functions for the CNP algorithm, not the
algorithm itself.
|
|
CRF and process descriptors seem to work now. It only remains to
implement the set of pending actions before I can work on the driver
program.
|
|
A prototype of BSR is roughly finished.
|
|
|
|
Just to save some work.
|
|
It is a very basic and simple hash table. It is so simple that I
hesitate to call it a hash table. Anyways, I think it suffices for my
purposes here.
* Makefile.am: Add necessary files.
* grammar.c (new_tnt_string): Formatting.
* ht.c (new_ht): Constructor
(destroy_ht): Destructor
(ht_expand): Rehash
(ht_insert, ht_delete, ht_find): Main functions.
* list.c (add_to_list, list_assure_size): Modify the use of realloc.
* test/check_ht.c: Ensure this is working correctly.
* util.c (read_entire_file): Modify the use of realloc.
|
|
Now we have the potential to recognize character classes. But the
most important task for us now is to experiment with ((B)RN)GLR
algorithms, so we leave the character classes at the present state for
a moment.
|
|
Now some problems are fixed.
It can now read grammar correctly (hopefully) from a file, in the BNF
format. And strings (terminals) are handled fine as well. So glad
that there are no leak problems now.
|
|
Now we can read grammars from a file.
But we need to check if it works for reading strings still.
|
|
The current representation of the grammar is the most primitive BNF.
This is the simplest to implement, but is difficult to cope with user
requirements. Moreover, I find another paper describing the GLR
algorithm, so I need to think about the representation of the grammar
more. In particular, I would like the generation of the grammar to be
incremental, so per chance its data type should be adapted
accordingly.
|
|
|
|
Now the rough framework is established and the grammar class is sort
of ready.
It remains to write a general input reading mechanism.
|
