- Dynamically generate a strategy matrix based on the list of changed
files in this push/pull_request. If the changed files are restricted
to implementations then only generate a matrix with those
implementations. If the changes are to tests or other
non-documentation files (runtest.py, IMPLS.yml, .github/*, etc) then
run the full set. The matrix generation is done in get-ci-matrix.py.
- Split the implementation list for Github Actions out into a separate
yaml file IMPLS.yml
- Reduce the travis file to just the OS X / XCode related builds that
aren't supported on Github Actions.
- Rename the .travis_test.sh script to ci.sh since it is the general
CI script used for both Travis CI and Github Actions.
- Reorder README to have implementation list after "learning tool"
bullet.
- This also moves tests/ and libs/ into impls. It would be preferrable
to have these directories at the top level. However, this causes
difficulties with the wasm implementations which need pre-open
directories and have trouble with paths starting with "../../". So
in lieu of that, symlink those directories to the top-level.
- Move the run_argv_test.sh script into the tests directory for
general hygiene.
This commit adds a new Python 3 implementation of MAL. This
implementation passes all non-optional tests, with the exception
that the travis test script doesn't like the period in the
directory name. During development, this was called "py3" and
it passed Travis tests.
This implementation is different from the main python implementation.
First, it heavily uses type annotations making for a code style
more similar to Java. Second, it uses the Arpeggio parser library
to parse MAL syntax.
This commit also includes unit tests that show roughly the order
of things that were interactively tested and debugged during
development.
To allow the same BASIC source (and in particular, LIBRARY statements)
to work on both Unix and RISC OS (the latter of which doesn't allow '.'
in file names), create symlinks to all the libraries from their
unadorned names.
The `_map?` function was introduced when transitioning the macro
property being stored in metadata to uinsg a regular map with
a special key. The `_map?` function causes issues in a few places but
the biggest issue is that it breaks the `_macro?` function for the
second order self-hosted mal instance. The `_macro?` function contains
a `(map? x)` call that returns false resulting in the `_macro?` call
returning false. I'll push something later that fixes this and also
that activates second order self-hosted tests so we can catch this
sort of issue in the future.
Add a regression run to Travis that enables hard deferrables but
omits optionals so that we can test to make sure that all the
requirements are met for self-hosting in stepA.
Cleanup up some of the soft/deferrable/optional markings.
Deferrables are what will be needed eventually to self host but aren't
needed for the immediate next steps. Optional aren't even needed for
self-hosting but are nice things to have.
Also:
- Sync dart step9 and stepA with step8. Do not eval macroexpanded
forms in macroexpand form.
- Fix stepA of factor which was missing some fixes from step9.
- Increase test timeouts in top-level Makefile for guile and io.
- clojure (cljs): self-host arity fix. Apparently ClojureScript
functions that have metadata attached only support arity of 20. This
is problem during self-host because the main EVAL cond macro is 22
items so it blows up when applied in macroexpand. So we preserve the
origin unadorned function through to macroexpand and use it there
instead of the adorned function/macro.
- basic: fix build when in self-host qbasic mode.
- coffee, cs, dart, elisp, hy, rexx, vb: fix self-host reader errs. Preserve
or extract the correct error message in try*/catch* loops so that it
works for self-host error message printing as well.
- mal: pathing issue in ./run script that affected the wasm
implementation path permissions
- miniMAL: remove extraneous command line printing of "nil".
- ps: inc function was not actually defined.
- rust: write warning about missing .mal-history to stderr to fix
self-host failure in step6.
- wasm: the map function was stopping on nil values; fix the list end
check. Double the macroexpand stack so that sumdown test in stepA
tests passes without mac stack overflow.
- yorick: read from /dev/stdin in readline builtin function.
- If the branch name is "self-host-test" then do self-hosted test.
- Fix pass through of *_MODE values during self-hosting.
- Add capability to skip of build/test/perf during self-host.
- Skip self-host for basic, io, logo, make.
- Reformat travis.yml list for better alignment
I needed to learn Vala in order to work on an existing program written
in it, and since Ben Harris had been enthusing about mal to me
recently, I thought this would be a good way to learn the language.
In other words, this is my first Vala project, so I can't promise it's
perfectly idiomatic by the standards of experienced Vala programmers!
Also, the style isn't all that consistent. For example, sometimes I
implement a function for every value type by adding a method to the
Mal.Val base class, and sometimes instead I do it by having a function
(e.g. pr_str) dynamically test all the possible subtypes in a chain of
else-ifs.
Those decisions were partly because of the source file structure
required by this project (pr_str is supposed to live in its own file);
partly because for my own learning goals I wanted to try both
strategies and find out how easy they both were; and mostly just
because of indecision and bad planning.
Needs wace from https://github.com/kanaka/wac to run.
wastpp.py processes the listed modules and outputs a single combined
module. It finds inline strings and hoists them to the top into a data
section and creates pointer variables into that memory and replaces
the inline strings with pointer lookups.
Since the iter count increases by 1 each time through the "loop", when
we hit more than 10 seconds elapsed time we can just return the
previous iter count rather than doing a percentage calculation. This
fixes results for basic modes which couldn't do the percent
calculation because itermediate values were greater than 32,768 which
is the limit for basic MODES.
Also, the mal implementation now runs and returns legit results so
re-enable perf^impl.
This rewrites the rust implementation to use many new features of the
current version of rust.
The refactor is much more concise (only 2/3rds the size) and switches
to using a lot of the more functional features (iterators, closures,
etc) that have been added or improved in rust.
Unfortunately, the implementation is a fair bit slower (about 30% on
perf3). It's not clear why this is the case but concision and being
more idiomatic wins over performance.