- tray.pl (zf): lower floor by another mm, leaving 3-4 mm of material
- tray.pl (vd): increase vial diameter by 0.1 mm to allow for vial
tolerance and material expansion. Also, working from the inside to the
outside (instead of plunging into uncut material first) decreased the
hole radius slightly.
- tray.pl (do_cols, do_circles): removed exclusion of the first column
radius after vial
tolerance,
- doit (GEN): corrected name of toolpath generator
- doit (rdata): fixed typo ("rdate" vs. "rdata")
- doit (Z): set Z depth here, to avoid manual depth adjustment
- doit: don't use cameo - we compensate for the tool size in tray.pl
- doit: increased feed rate from 2 mm/s to 4 mm/s
- doit: clearance is above top layer, so 5 mm are more than enough
- tray.pl (zf): increase floor depth from very conservative 15 mm to
17 mm
- tray.pl (zs): increase depth step from 2 mm to 2.5 mm to accelerate
milling
- tray.pl (mw): increase wall thickness from 2 mm to 2.5 mm in order to
enlarge gap between sides (was smaller than tool diameter)
- tray.pl (r1): stop 2 steps before the edge, since we have the outline
as another radius-like step
- tray.pl (do_col): account for tool radius
- tray.pl (do_circles): lift the tool after each disc, not only after
each column
- tray.pl (do_cols, do_circles): temporarily skip 1st column
- tray.pl (main): do circles before the outline, to reduce chatter when
cutting the outline
- tray.pl (main): since we're no longer using "cameo" here, don't print
directives for it
This doesn't work yet. In particular, going through "cameo" doesn't seem
the most convenient choice, since "cameo" requires paths to be closed,
which is something the paths we use here aren't. (Conceptually, thet are
closed, but the implementation skips some small segments.)
This commit is just a snapshot before I experiment with changing the
algorithm.
- prereq.c (resolve): do not consider installing virtual packages
(forgotten in previous commit)
- prereq.c (resolve): renamed "next_dep" to "next_deps" to emphasize that
this is a list
- prereq.c (resolve): use "break" instead of "return" to abandon a
non-optimal path, so that we'll run future cleanup code
- prereq.c (resolve): fixed typos in explanation of QPKG_ADDING cleanup
- prereq.c (resolve): reference test/bug-adding in explanation
- pkg.h (enum flags): new flags QPKG_PROVIDED to indicate that the
package is only a provision, not an installable package
- fixup.h, fixup.c (complete_provisions): search for provisions that do
not have a real package associated with them, create a package for
them, and mark it as QPKG_PROVIDED
- qpkg.c (do_fixups): invoke complete_provisions
- pkg.h (struct pkg): add list of (virtual or real) packages a given
package provides
- pkg.c (new_pkg): initialize pkg->provides
- pkg.c (free_pkg): deallocate pkg->provides
- gobble.c (gobble_buf): parse the list of packages a package provides
- TODO: updated status of Provides support
- Makefile (OBJS_qpkg): added pkg.o
- gobble.c (gobble_buf): moved "struct pkg" allocation to function new_pkg
in pkg.c
- qpkg.h: moved "struct pkg" and subordinate structures to pkg.h
- pkg.h, pkg.c (new_pkg, free_pkg): provide package structure definition,
allocation, and deallocation
- fixup.c, gobble.c, prereq.c, qpkg.c: include "pkg.h"
- gobble.c (finish_pkg): use free_pkg instead of just "free" to avoid
leaking memory
- prereq.c (conflicts, resolve, prereq): renamed "conflicts" to
"old_conflicts"
- prereq.c (new_conflicts, resolve, prereq): also test whether any of the
conflicts of the package we're about to add matches an installed or
considered package
- test/conflict, test/instconf: test for conflicts introduced by package
about to be added
- prereq.c (installed_conflicts, free_conflicts, prereq): collect list of
pre-existing conflicts in installed packages
- prereq.c (prereq): check if package being requested already conflicts
- test/instconf: regression test for conflicts with installed packages
- TODO: updated for full support of conflicts. Mention that we're not
terribly efficient with handling conflicts.
- prereq.c (conflicts): detect conflicts
- prereq.c (prereq): pass list of conflicts of initial package
- test/conflict: regression test for basic conflict handling
- TODO: updated for partial implementation of conflicts
- Makefile (OBJS_qpkg): added fixup.o
- fixup.h, fixup.c (sort_versions): sort package versions
- qpkg.c (do_fixups, main): do fixups when done gobbling
- qpkg.h: need to include id.h to be self-contained
- test/sortver: test version sorting
- qpkg.c (list_all_packages): jrb indicates end-of-tree with pointer to
jrb_nil(), not NULL
- qpkg.c (list_all_packages, list_one_package): use ID2PF
- qpkg.c (list_all_packages): iterate over versions
- prereq.c: added section titles
- prereq.c (debug), qpkg.h, qpkg.c: made variable "debug" global and moved
it to qpkg.c
- qpkg.c (usage, main): new option -d to enable debugging
We define a cyclic dependency as the possibility (!) of the prerequisites
of a package X including a package that depends on X, and issue an error
if encountering such a situation.
Note that, if the dependencies of X can be resolved in a manner that does
not include the cyclic dependency, qpkg will still fail if it encounters
the cycle. Also note that qpkg (at least so far) does no perform an
exhaustive search to ferret out cyclic dependencies.
Furthermore, we don't consider that a cyclic dependency may not necessarily
imply a real life problem. E.g., if a package A contains elements X and
Y, with X needing package B, and the content of package B has a run-time
dependency on Y, the cyclic dependency between A and B would not exist
when considering its constituents. Since we don't have this information, we
just err on the side of caution.
- qpkg.h (enum flags): divide flags into categories (parse-time and
run-time) and add flag QPKG_ADDING to mark packets whose dependencies we
are processing
- prereq.c (resolve, prereq): track which packages we're tentatively
considering for installation and detect cyclic dependencies
- test/cyclic: regression test for detection of cyclic dependencies
- TODO: updated with recent changes
Until now, when considering adding a package, we processed its
dependencies after completing the current list of dependencies. E.g.,
if we had a package A that depended on B and C, B depended on D, and C
depended on E, then the sequence would have been A, B, C, ...
We now process the dependencies of a package immediately after
considering the package, so the sequence above would become A, B, D,
C, ...
The advantage of the new order is that it becomes easier to follow the
dependency tree, which will be beneficial for loop detection and for
ordering packages by installation order.
- prereq.c (resolve): change prerequisite resolution order such that the
dependencies of the package being considered are processed immediately,
instead of deferring them until the end of the current dependency list
- prereq.c (prereq): we can now pass the list of dependencies directly,
without needing a list of lists element
- test/resorder: test resolution order
- gobble.c (gobble_buf): list_with_version reversed the order of the list
items. It makes the behaviour of later algorithms more intuitive if we
maintain the file order.
The original idea was to just copy "stack" (now called "installed") to
"best" when done. In this case, "best" would remain NULL if "install"
had no entries, which would then be interpreted as a failure to resolve
the prerequisites.
However, since we allocate a new list for "best" anyway, this concern
no longer exists, and we can also get rid of the contorted mechanism
that was designed to work around this problem. (It was never put into
action because I wanted to make a regression test for it first.)
- prereq.c (prereq): removed commented-out and nonsensical avoidance of
false error
- test/prereq: added test case with no prerequisite
- Makefile (test, tests, valgrind): new targets to run regression tests
- test/Common: test harness (adapted from fped)
- test/minpkg: test minimum package definition
- test/prereq: test basic prerequisite queries
- gobble.c (compact_pkg, gobble_buf): renamed compact_pkg to finish_pkg
- gobble.c (finish_pkg): check that the package has a version
- gobble.c (finish_pkg): check that the package has an architecture
- gobble.c (finish_pkg): check that the package either has a file name or
is installed
- qpkg.h (struct pkg): added "arch" field for the architecture
- gobble.c (gobble_buf): record the architecture
- gobble.c (gobble_buf): fail if trying to set the file name twice
- qpkg.c (main): initialize trees before doing anything else, so that the
argument processing stays together
- id.h, id.c (make_id): return a "struct jrb *", so that we have access to
key and value
- gobble.c (ID, gobble_buf): adapt to above change
- gobble.c (compact_pkg, gobble_buf): keep the RB node reference instead
of awkwardly regenerating it via pkg->id->jrb
- id.h, id.c (first_id, next_id): removed
- qpkg.c (list_all_packages): use jrb_first/jrb_next instead of
first_id/next_id
- id.h, id.c (find_id): return the RB tree node instead of the ID
- qpkg.c (list_one_package, find_prereq): adapted for above change
- id.h: explain the role of key and value
- qpkg.h (enum flags, struct pkg): replaced "installed" with "flags", one
of them being QPKG_INSTALLED
- gobble.c (compact_pkg, gobble_buf), prereq.c (push, resolve): adapted
for above change
- TODO: added section for tasks done
- TODO: search tree optimization is done
- TODO: added idea of supporting other database formats in the same family
- Makefile: added automatic dependenceies (needs SHELL = /bin/bash)
- Makefile: added non-verbose builds
- Makefile (jlime): set CC_normal instead of CC, so that also cross-builds
can be non-verbose
- Makefile (openwrt): new target to cross-compile for OpenWRT with uClibc
- Makefile (spotless): added "spotless" target
- gobble.c: uClibc may not have posix_madvise, so replace it with a dummy
if building for uClibc
If the package database is sane, then we don't need to check that all
the field names match what we expect. This saves a few more CPU cycles.
However, if anything goes wrong, the consequences may be unpleasant.
Thus, we default to the slow but safe approach.
- jrb.h, jrb.c (jrb_find_or_insert): new function to look for a node and
to insert a new one if not found
- id.c (make_id): use jrb_find_or_insert to avoid looking up new nodes
twice
- TODO: report the improvement
