| Commit message (Collapse) | Author | Age | Files | Lines |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
This one test case requires restructuring. The handling for
the @(or ...) operator is now very different. To support @(or
...), there is now a new variant of the match-guard object
called guard disjunction, which contains multiple match-guard
chains. Furthermore, the separation between both guard-chain
lists and compiled-match having a test expression and
variables is being obliterated. For now, what we do is in a
:postinit handler on compiled-match, we immediately convert
the test-expr, vars and var-exprs slots into a match-guard
object, which is placed into the guard-chain, and then we
clear these slots. They are now vestigial only and will be
removed.
* tests/011/patmatch.tl: New test case which shows
that (@(or foo bar) ...) does not short immediately short
circuit to a failure when the corresponding element is
neither foo nor bar. Matching proceeds to the right,
wasting cycles and possibly causing errors.
* share/txr/stdlib/match.tl (*match-var*): Move to top, above
structs. There are some methods which refer to this variable
now for throwing internal errors.
(guard-disjunction): New object that is compatible with a
match-guard, and placed into guard-lists as if it were a
match-guard. This handles the bifurcation logic of an
OR match.
(compiled-match): New :postinit handler converts local vars,
var-exprs and test-expr into a match-guard placed into the
chain, and then clears these values. The compilation of code
is done purely from the guard-chain.
(compiled-match get-vars): This method is now complicated due
to the guard-disjunction objects, and so uses a helper
function called get-guard-values.
(compiled-match get-var-exprs): New method accompanying
get-vars to get the accompanying init expressions.
(compiled-match wrap-guards): Two changes are going on here.
One is that the funccion takes on more of the responsibility
which was previously carried out by the callers. The callers
were interpolating the test-expr and vars from a
compiled-match into a piece of code, which was then passed to
wrap-guards. Hence the naming: the job was just to wrap some
guards. Now, wrap-guards is called just with the body forms,
and does all of the work. Secondly, wrap-guards is complicated
due to the handling of the guard-disjunction items.
Also, there is some case handling to generate better code;
we avoid generating an empty (let () ...) and (alet () ...).
(compiled-match add-guard-pre, compiled-match add-guards-pre,
compiled-match add-guards-post): New methods for adding guards
after construction. These interfaces replace hacks of pushing
new variables, tweaking the test-expr, or explicitly pushing
guards onto the list.
(get-guard-values): New function for iterating over a
guard-chain, including match-guard and guard-disjunction
items, retrieving a particular list-valued slot from each one
using the fun argument, and returning a list of all those
lists catenated together.
(compile-struct-match, compile-vec-match,
compile-range-match): Eliminate test-expr, replacing it with
the harmless t.
(compile-op-match): We don't try to extend the test-expr of
the compiled var. Rather we add our guard expressin using the
add-guard-pre interface.
(compile-dwim-predicate-match): Likewise, and also, we
do not calculate the test-expr for the output compiled-match
from the constituent match test-exprs. We ignore those and
just set the test-expr pat-match.obj-var. The constituent
test-exprs have been converted to guard-chain items already,
so there is no point in referring to them.
(compile-predicate-match): Use add-guard-pre method to add
guard instead of pushing it on list.
(compile-cons-structure): Eliminate test-expr being calculated
from constituent test-exprs, and just stub it out to t.
(compile-require-match): Use add-guards-post to push
match-guard onto compiled child mach, instead of tweaking its
test-expr.
(compile-let-match): Oblierate calculation of test-expr from
child test-exprs, replacing with t stub.
(compile-loop-match): Call wrap-guards in the new way,
without generating assignments or test-expr.
(compile-parallel-match): This method is removed; there are
now separate compile-or-match and compile-and-match methods.
(compile-or-match): New method: compiles consitituent
expressions, and converts them into multiple guard-chains
for a guard-disjunction object. Then wrap-guards will finish
the job of emitting the or logic out of those chains.
(compile-and-match): This shares some common logic with
compile-or-match, but is substantially simpler. Pattern
matching is implicitly AND-based: in a pattern, all the
sub-patterns have to match. So there isn't much to do beyond
just evaluating all the patterns against the same object.
They can all be thrown into one combined flat guard chain.
(compile-not-match): Adjust to new wrap-guards interface.
Nothing left to do here but pass the expression t to it.
(copmile-hash-mach): The post-constructon manipulations of
the child compiled matches are done with the appropriate
add-guards-pre. The test-expr is eliminated, replaced with t.
(compile-match): Wire or and and to the new separate methods
compile-or-match and compile-and-match.
(when-match, if-match, match-case): Simplified due to
when-match interface change. The macros depend on a lot less
implementation detail now: they bind the required vars and
generate the code.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
* share/txr/stdlib/compiler.tl (expand-each): The algorithm
for appending is completely wrong. Not only does it
destructively mutate, it doesn't look like it will behave like
the interpreted append-each operator, since it assumes
it can rplacd the tail cons of the output list, which won't
work for non-list sequence types.
* share/txr/stdlib/compiler.tl (expand-each): New translation
strategy: append-each each will now accumulate the values of
the body expression into a list, exactly like collect-each
does. Then it will apply the sys:append function to that list.
This ensures the "as if" semantics (append-each behaves like
the append function), and non-destructive behavior: everything
is copied that needs to be, except that a list tail can share
substructure.
|
|
|
|
|
|
|
| |
* share/txr/stdlib/match.tl (compile-hash-match): In the
trivial key case, we are wastefully installing the same
expression as both a guard in the guard-chain and as a
test-expr. We should not be frobbing vm.test-expr.
|
|
|
|
|
| |
* share/txr/stdlib/match.tl (compile-predicate-match): Promote
condition from test-expr into guard-chain.
|
|
|
|
|
| |
* tests/011/patmatch.tl: Predicates must also be tested
earlier, as guard conditions.
|
|
|
|
|
|
| |
* share/txr/stdlib/match.tl (compile-atom-match): Do not
express the match for the atom via test-expr. That is
too late. It needs to be a guard in the guard chain.
|
|
|
|
|
|
|
| |
* tests/011/patmatch.tl: Even though bar mismatches
foo, the second element @(all) is processed and
tries to collect the list. This results in an
error due to the list being improper.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
With this commit, the new broken test case passes.
The main issue is not clearly separating temporary variables
in mach-guards from public variables.
* share/txr/stdlib/match.tl (match-vars): Remove pure-vars and
pure-var-exprs from this inheritance base, as well as the
related lets method.
(match-guard): Add the "pure" slots here, under new names:
pure-temps and pure-temp-exprs. This renaming is for clarity.
Add the lets method here, based on these new variables.
Add new slots temps, representing the impure temps.
There is no temp-exprs because impure temps are bound
to nil and later assigned.
(compiled-match get-temps): Method removed.
(compiled-match get-vars): Rewritten to avoid using get-temps
which doesn't exist any more. This method has a clear purpose:
to all the public variables coming from the patterns themselves,
whether those variables are promoted into a guard-chain for
early binding or whether they are attached on the
compiled-match object.
(compiled-match wrap-guards): Ensure that the new temps
from the guard-chain objects are bound with let.
(compile-struct-match, compile-vec-match,
compile-range-match, compile-dwim-predicate-match,
compile-cons-structure, compile-hash-match): pure-vars rename.
(compile-loop-match): We no longer bind cm.(get-temps) here.
That method doesn't exist. If we are not doing @(some), we
bind cm-vars: the public vars collected from cm. We need
local copies of them to catch their values and accumulate them
into list. In the match-guard constructor, we move the
collect-gens into temps; they are not public variables.
(compile-parallel-match): Drop ^(let ,pm.(get-temps) ...) from
the expansion.
|
|
|
|
|
|
| |
* tests/011/patmatch.tl: It looks like there is still
a problem with scoping. An inner x is assigned the correct
value, leaving the outer x nil.
|
|
|
|
|
|
|
|
|
|
| |
* share/txr/stdlib/match.tl (compile-loop-match): We must use
the get-vars method of a compiled-match to get a list of its
vars, and not directly access the vars slot.
The list of vars must include all the non-temporary variables
from the guard-chain. This is important in these rules because
they specially treat the guard-chain and do not integrate
it into their own guard chain directly.
|
|
|
|
|
| |
The matcher has a bug: the loop patterns are not collecting
the variables from enclosed parallel patterns.
|
|
|
|
|
|
| |
* share/txr/stdlib/compiler.tl (compiler comp-let): The eenv
variable is used only in one place; the immediately next
binding for fenv. Let's eliminate it.
|
|
|
|
|
|
|
|
| |
* share/txr/stdlib/optimize.tl (rewrite-case): New macro,
combining rewrite, lambda and match-case.
(basic-blocks thread-jumps): Condense using rewrite-case,
and unfold some of the expressions into longer lines,
since everything has moved quite a bit to the left.
|
|
|
|
|
| |
* share/txr/stdlib/optimize.tl (basic-blocks thread-jumps):
Wrap long pattern expressions.
|
|
|
|
|
|
|
| |
* share/txr/stdlib/compiler.tl (comp-switch): Convert the list
of labels for the switch instruction from vector to list.
This ends up a vector due to contagion from the sys:switch
special operator syntax.
|
|
|
|
|
|
| |
* share/txr/stdlib/compiler.tl (compiler comp-lambda-impl):
Use the same "l" prefix for the skip label that is used
elsewhere in the compiler.
|
|
|
|
|
|
|
|
| |
* share/txr/stdlib/optimize.tl (basic-blocks thread-jumps):
Also thread the implicit branch performed by close
instructions. If a close instruction branches to an
unconditional jump, then rewrite the close to jump that jump's
target.
|
|
|
|
|
|
|
|
|
| |
* share/txr/stdlib/optimize.tl (basic-blocks thread-jumps): If
an (ifq RX RY label-X) instruction branches to an
(ifq RX RY label-Y) instruction, replace it with that
instruction. Moreover, if (if RX RY label-X) jumps to a
(jmp label-Y) instruction, also replace it with
(if RX RY label-Y).
|
|
|
|
|
|
|
|
| |
* share/txr/stdlib/compiler.tl: Load the new optimize module.
(compiler optimize): New method.
(compile-toplevel): Pass code through optimize method.
* share/txr/stdlib/optimize.tl: New file.
|
|
|
|
|
|
|
|
|
|
|
|
| |
* share/txr/stdlib/match.tl (compile-dwim-predicate-match):
Drop redundant bindable check of sym, since compile-var-match
checks this. Support third argument which gives a pattern or
variable which captures the value from the predicate function,
which might be interesting (not just true/false).
* tests/011/patmatch.tl: New tests.
* txr.1: Documented.
|
|
|
|
|
|
|
|
|
| |
* share/txr/stdlib/match.tl (compile-dwim-predicate-match):
New function.
(compile-match): Route dwim symbol to
compile-dwim-predicate-match.
* txr.1: Documented.
|
|
|
|
|
| |
* txr.1: Under Pattern operator hash, include range
patterns wih non-trivial contents as being non-trivial.
|
|
|
|
|
|
|
|
|
|
| |
* checkman.txr (check-meti): New pattern function
which simply diagnoses any .meti. This relies on the fact that
.mono/.onom blocks are matched and consumed by by another rule.
All valid .meti lines are consumed as part of these blocks,
so any .meti that remain must be outside.
* txr.1: Fix numerous occurrences of this.
|
|
|
|
|
|
| |
* txr.1: Fix typo under Range match. Remove the documentation
for the nonexistent pattern operator @(rcons ...) that
was supposed to be removed before release 249.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
This addresses a bug manifesting itself as a regression in the
behavior of @(freeform), which was reported by Frank Schwidom.
The sub_str operation calls lazy_subs_str for a lazy string.
But lazy_sub_str again relies on sub_str for extracting part
of the lazy string prefix. But sub_str can potentially return
the whole object rather than a copy of a substring of it.
In this case, lazy_sub_str produces a new lazy string object
which shares the prefix string object with the original
lazy string. This is incorrect because the lazy string data
type destructively manipulates the prefix. It means that
operations one one lazy string are mucking with the prefix of
another lazy string.
* lib.c (lazy_sub_str): When creating the new lazy string
object, make a copy of the prefix string pulled from the
original. We do the carefully: the copy of the prefix is made
before the make_obj call which allocates the new lazy string,
otherwise we create a wrong-way assignment from the
perspective of generational GC.
* tests/006/freeform-4.txr: New test case, from Frank.
* tests/006/freeform-4.expected: Expected output of test case.
|
|
|
|
|
|
|
|
|
|
|
| |
* lib.c (sub_str): If compatibility is requested, with a value
of 215 or less, then disable the optimization of returning
the original string without making a copy. This was found
to break the @(freeform) directive. That regression alerts me
to the fact that I should have made this subject to
compatibility; some user code could be affected.
* txr.1: New compat note added, under 215.
|
|
|
|
|
|
|
|
|
|
| |
* RELNOTES: Updated.
* configure, txr.1: Bumped version and date.
* share/txr/stdlib/ver.tl: Likewise.
* txr.vim, tl.vim: Regenerated.
|
|
|
|
|
|
|
| |
* txr.1: Add anote that a pattern a..b matches rcons syntax,
and add examples.
* tests/011/patmatch.tl: new examples from doc added as tests.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
There is no longer any way to write a @(rcons ...)
pattern using the range syntax, so there is no point in
supporting that operator. The silly syntax @@a..@b
which previously worked was actually due to a mistaken
requirement in the parser.
* share/txr/stdlib/match.tl (compile-range-match): Function
moved closer to compile-atom-match, below compile-vec-match.
The argument is now a range object containing patterns, so we
pull it apart with from and to.
(compile-atom-match): Pass range directly to
compile-range-match; no need to construct (rcons ...) syntax.
* tests/011/patmatch.tl: Add range tests from documentation
and a few others.
* txr.1: References to @(rcons ...) pattern scrubbed.
One wrong #R pattern example corrected.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
This fixes the following print-read consistency issue.
Both of these objects print as @a..@b.
1> '@(rcons a b)
@a..b
2> '(rcons @a b)
@a..b
We want only the second case. After the this fix:
1> '(rcons @a b)
@a..b
2> '@(rcons a b)
@(rcons a b)
* lib.c (obj_print_impl): In the sys:expr case, we check
whether the head of the argument is rcons. If so, we adjust a
few local variables and branch directly to the generic list
case via goto to print the argument as (rcons ...) without
conversion to dotdot range notation.
|
|
|
|
|
|
| |
* lib.c (obj_print_impl): Capture some values into local
variables to avoid repeating the type-checked accesses.
Many of the cases access the first argument, and such.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Whereas @a..@b parses and transforms to (rcons @a @a),
@(a)..@(a) goes to @(rcons a @(a)).
* parser.l (grammar): Under 248 compatibility or lower, the @
character now produces the OLD_AT token. Otherwise it produces
the '@' character, as before.
* parser.y (OLD_AT): New token replaces the '@' at the old
low precedence position. '@' is now at the highest precedence,
together with OLD_DOTDOT. (We don't care about interactions
between '@' and OLD_DOTDOT, because OLD_DOTDOT only exists in
185 compatibility, in which '@' is OLD_AT).
(meta): The two rules have to be unfortunately duplicated for
OLD_AT, since there is no BNF OR operator in Yacc.
* txr.1: Compat note added.
* lex.yy.c.shipped: Updated.
* y.tab.c.shipped, y.tab.h.shipped: Likewise.
|
|
|
|
| |
* Makefile (%.shipped): New pattern rule.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
* share/txr/stdlib/match.tl (match-vars): New slots, pure-vars
and pure-var-exprs.
(match-vars lets): New method.
(compiled-match wrap-guards): Generate an alet that binds the
temporaries, and then does the assignments of the regular
variables.
(compile-vec-match, compile-cons-structure,
compile-hash-match, compile-range-match): Use the pure-vars
for match-guard temporaries that are bound and not assigned,
rather than vars.
(when-match, if-match): Use alet for obj-var.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
The following form fails to expand:
(let (a) (set a '#1=(#1#)))
This is due to macro ancestor propagation which wants to
traverse the entire (set ...) form in order to indicate its
macro ancestor.
* share/txr/stdlib/place.tl (sys:propagate-ancestor): We check
whether to-tree already has a macro ancestor, and only recurse
if it doesn't.
|
|
|
|
|
| |
* lisplib.c (place_set_entries): Fix misspelling of
call-delete-expander entry: stray parenthesis.
|
|
|
|
|
|
|
|
|
|
|
| |
* share/txr/stdlib/match.tl (compile-atom-match): Handle range
type, via transformation to rcons operator and
compile-range-mach.
(compile-range-match): New function.
(compile-match): Hook in compile-range-match for @(rcons).
(non-triv-pat-p): Handle range case.
* txr.1: Documented.
|
|
|
|
|
| |
* txr.1: Under Structural Pattern Matching, fix "instance
instance".
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
The previous commit made the general pattern matcher dependent
on calling non-triv-pat-p function. But that function needs
the matcher to work in order to be defined. This has left the
code base uncompilable.
* share/txr/stdlib/match.tl (non-triv-pat-p): Precede the
real definition of non-triv-pat-p with a temporary one which
returns a conservative t value, which suspects all syntx to
be non-trivial. This means that the real non-triv-pat-p can
use match-case, because match-case's expander will be using
the temporary version of the function. non-triv-pat-p won't
benefit from the optimizations arising from identifying
trivial patterns: but since it doesn't have any such patterns,
so it makes no difference.
|
|
|
|
|
|
|
|
|
|
|
|
| |
* share/txr/stdlib/match.tl (compile-atom-match): Test whether
a vector is really a non-trivial pattern, or a trivial
piece of datum. If it is trivial, then compile it
as an atom, which is matched by a simple call to equal,
which is way less code bloat, and implemented in C.
(compile-match): Similarly, check whether the cons structure
case is nontrivial and only then treat it as a cons
pattern, otherwise compile it as an atom, which will
just match it with equal.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
This change causes a key-value pattern like (@a @b)
to be treated specially when @a already has a binding from a
previous pattern. In this case, it behaves like the
trivial key case: the value of @a is looked up to try to find
a single value. If @a is not bound, then the exhaustive
search takes place, using equal equality.
* share/txr/stdlib/match.tl (compile-hash-match): Implement
special case.
(var-pat-p): New function.
* tests/011/patmatch.tl: Existing test case now changes
value. New test case added.
* txr.1: Documented.
|
|
|
|
|
|
|
|
|
|
|
| |
Hash pattern matching must not assume that if gethash returns
nil, the item is not found. That's just a convenience that can
be coded in some situations, not in a general mechanism.
* share/txr/stdlib/match.tl (compile-hash-match): Allocate a
gensym that serves as a unique object. Pass this to gethash
as the alt argument, and then check whether gethash has
returned this value to indicate failure.
|
|
|
|
| |
* txr.1: fix typoo under if-match.
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
* share/txr/stdlib/match.tl (compile-hash-match): Follow
rename of is-pattern function to non-triv-pat-p.
(is-pattern): Renamed to non-triv-pat-p, to follow terminology
in the reference manual. A bug is fixed here: we must
recognize cons patterns with operators and variables in the
dotted position as non-trivial.
* tests/011/patmatch.tl: New hash test case, from doc.
* txr.1: Documented hash pattern operator.
|
|
|
|
|
|
|
|
|
| |
* hash.c (hash_revget): Default to equal, except in
compatibility mode.
(hash_keys_of): Also default to equal. This function is too
new to bother with compatibility switching.
* txr.1: Documented, with compat notes.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
This commit fixes the inadequacy that all variables occurring
in a pattern under @(all ...) or @(coll ...) are blindly
collated into lists, ignoring the fact that they may be
previously bound variables that must back-reference and not be
colleced into lists (just like in the TXR Pattern language!)
* share/txr/stdlib/match.tl (compile-loop-match): Calculate
the subset of variables in the pattern that have been freshly
bound. Only generate the collection gensyms for those
variables and only collect and nreverse those variables.
* tests/011/patmatch.tl: Some test cases that backreference
into an @(all).
* txr.1: Documented.
|
|
|
|
|
|
|
|
|
| |
* share/txr/stdlib/match.tl (struct match-guard): guard-expr
slot defaults to t, so the guard defauls open.
Guards are sometimes used just for binding temporaries and not
imposing any condition.
(compile-parallel-match, compile-hash-match): Omit
initial value of t for guard-expr.
|
|
|
|
| |
* txr.1: 2020 -> 2021.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Firstly, I'm fixing an odd bug here: cobjclassp returns 1
instead of t to represent true. This affects: carrayp, hashp,
random-state-p, regexp and struct-type-p, all of which
return 1 when the test is true. For some bizarre reason, I
chose this weird solution back in 2019 because this function
has some calls at init time when t is not yet available;
simply returning t causes a segfault.
Secondly, I'm fixing the way we deal with t at initialization
time. We simply give it a temporary value of 1 until it is
replaced with the real symbol. This fixes all the original
problems with t being nil until initialized. Now, we cannot
do this:
val t = one;
because one is not a constant expression due to the cast,
even though one is a de-facto constant. That's probably what
distraced me away from the obvious second-best solution of
just assigning it at some early point in the execution.
* lib.c (cobjclassp): Fix odd bug here: returning one to
indicate true instead of t. (make_sym): Don't test value of t here any more.
(make_package_common): Don't use lit("t") instead of t any
more in the make_hash calls.
(make_package): Don't test value of t here.
(obj_init): t can now be initialized using the straightforward
expression t = intern(lit("t"), user_package), similarly
to other symbols.
(init): set t to the integer 1 before making any init calls.
|
|
|
|
|
|
|
|
|
| |
* share/txr/stdlib/match.tl (compile-hash-match): New
function.
(compile-match): Hook in hash operator.
(is-pattern): New function: uses match-case, and is used in
the implementation of the hash operator. This works because
the function doesn't use @(hash ...) anywhere.
|