These bugs were shaken out by letting errors happen by not implementing
the dot operator. Now, the compiler is more robust to errors happening.
Signed-off-by: Gavin Howard <gavin@yzena.com>
This was brought to my attention by reading
https://github.com/oconnor663/duct.py/blob/master/gotchas.md#making-kill-thread-safe,
and it had a solution: set a flag.
This was made easier by the fact that I already use a mutex to protect
the map and vector of processes. I was able to leverage the lock to set
the flag safely, and then I wrote a function to call kill() that checks
the flag before actually calling kill(). Obviously, it takes the lock to
do so.
Signed-off-by: Gavin Howard <gavin@yzena.com>
This is mostly to eliminate false sharing with locks, semaphores, etc.,
which will all use atomic operations. I also made sure each of those
things were on their own cacheline.
Signed-off-by: Gavin Howard <gavin@yzena.com>
These bugs were causing aborts, and they were created by the recent
refactors. One was purely a mistake; it was correct before, and I did
some key combo in Neovim that switched the lines.
Signed-off-by: Gavin Howard <gavin@yzena.com>
The infinite loop was caused by the pointer to the found slash not being
incremented past it, so it was finding the the slash over and over.
Signed-off-by: Gavin Howard <gavin@yzena.com>
This is an important change. First, it requires keywords to also say
whether they parse declarations or not. Second, it splits packages into
two files: a package file with a bunch of declarations (only), and a
script/init file.
The package file is parsed twice to get all of the declarations in an
export file and then to generate code.
The script/init file is the "init" of the package, and it's treated as
straight code. It is parsed once, and everything must be predeclared.
Also, it cannot have straight declarations, but you can, for example,
assign functions to variables instead. That function just can't refer to
any variables/functions that are not predeclared. In other words,
scripts are one-pass and need forward declarations.
Signed-off-by: Gavin Howard <gavin@yzena.com>
This refactor is doing several things, all of which are related:
1. It is removing file stacks from lexers so that parsing multiple files
requires a different parser for each file. This is to prevent bugs
from not resetting data properly.
2. It is splitting parsing code into multiple files because parse.c was
getting big.
3. It is implementing name tracking for all scopes in a file.
4. It is implementing the start of an export file parse that will
generate declarations to be used in the regular parse such that
forward declarations are not needed.
5. It is changing the regular parse mode to use that list of
declarations.
6. It is implementing infrastructure to ensure that functions and their
callees are all defined *before first use*, as in Python.
The refactor is not yet finished, not even close. However, at the bottom
of src/yao/yao.h is the TODO list for this refactor.
This builds, but it is not tested.
Signed-off-by: Gavin Howard <gavin@yzena.com>
The bug is that files that are opened write-only should be truncated so
that when the file is overwritten, any data beyond was it written is
also erased.
I found this bug with the bug described in the previous commit. The
kjvbible.txt file was being turned into a C file, but it had nul
characters. When I fixed the previous bug, it did the job, but it didn't
erase the extra data, which existed because there were a lot of nul
characters.
The fix is dead simple: just check for write-only and add y_FILE_TRUNC
in that case.
Note that appending is *not* write-only.
Signed-off-by: Gavin Howard <gavin@yzena.com>
This was causing y_printf() and friends to print nul characters. The bug
was that I was setting length when I should have set capacity.
Signed-off-by: Gavin Howard <gavin@yzena.com>
Well, not all of them, but most of them; variables are still required to
be forward declared, but that makes sense because they have to be
initialized. Types have to be forward-declared to be used as
non-pointers in other types and to be used in functions, but that makes
sense because types have to know what size they are, and functions need
to know what they can access in the type.
However, functions don't need to be forward-declared, but they do have
to be *defined* at "first use," which means that a function has to be
defined at the point it is called first. This usually means that it has
to be defined before it is used in the "init"/"script" code for the
package or type it is a part of. Or if it is not used in that, it has to
be defined before the end of the file.
The hope is that this design will make Yao *act like* a scripting
language like Python, where functions don't have to be declared or even
defined when referred to until they are actually used.
The new design is that there is a new parse type: for creating an export
file. The export file has to be created anyway, to allow outside
packages to know what they can access. But in doing so, the private
declarations will be known as well, and we might as well use them.
But that *does* mean we have to track which functions are *actually*
defined. Yay...
It also means that user parsers have to have code for yet another parse
type, but most will not need anything for it. Those that do should have
done it anyway because otherwise, export files would be incomplete.
So while I'm unhappy with the design, it was the best one.
Signed-off-by: Gavin Howard <gavin@yzena.com>
This refactor allows keywords to present themselves as either
expressions, statements, or both. If a keyword can be a statement, and
it appears first in an expression, it is treated as an statement.
This makes it easier to implement the lack of semicolons after if
statements and such. It also acknowledges an implicit assumption I had
that there *is* a dichotomy between statements and expressions.
Sure, if statements and loops will be both, but some keywords are only
statements, such as Rig's target keyword.
Signed-off-by: Gavin Howard <gavin@yzena.com>
The error type I'm adding is to catch when client keyword functions in
Yao do not set a required value correctly. This is an invariant they
*must* keep.
However, I also do not want to panic for it because the parse should
still happen in cases like Language Server Protocol. So I'm adding an
error instead.
But I'm also changing the errors around to group ones in the same
category.
I'm also renaming the y_EXIT_INVALID_ARG category to
y_EXIT_INVARIANT_ERR because that more accurately describes what the
category is about. And I'm putting the new error in there.
Signed-off-by: Gavin Howard <gavin@yzena.com>
In this case, I remove anything extra besides the actual message,
including newlines. This is so that whereever those messages are used,
anything that uses them can wrap them however is desired.
Signed-off-by: Gavin Howard <gavin@yzena.com>
This necessitated moving the formatting code out of src/str/string.c.
This was because strings assume that nul characters will not be put into
the y_String, but they can be with sprintf()-like functions.
So I moved it and used plain vector functions instead of string ones.
The other failing test was a missing refcount increment when opening a
directory.
Signed-off-by: Gavin Howard <gavin@yzena.com>
This will make expression parsing less brittle than the one for bc's
parser.
This is also a convenient time to have keywords return the type of
subexpression they provide, and yes, I do want keywords to be able to
provide prefix, postfix, and infix operators.
Signed-off-by: Gavin Howard <gavin@yzena.com>
