| Age | Commit message (Collapse) | Author |
|---|
|
Slight optimizations: instead of storing archive members, just keep
the modification time, as we don't care for the rest of the archive
information. Lazily compute mtime, stash ascii date instead, and convert
to mtime when needed (storing an out_of_date value to mark the unconverted
values).
Archive handling is atrocious and need some clean-up.
Thanks to miod@ who took the time to review those patches.
|
|
Replace the time stamp hash in dir.c with an open hashing structure.
In doing so, remove some nasty casts, simplify code a bit:
Dir_MTime can return a modification time, since make does not make
a distinction between out-of-date and non-existent files.
|
|
open hashing.
An interesting optimization is that the open hashing interface is more
fine-grained, hence we can compute the correct hash value at the start
of Dir_FindFile, and reuse it for each hash structure into which we look
(the effect is measurable on large directories along with objdir/VPATH).
Remove a few unnecessary Lst_Open/Lst_Close that serve no purpose except
obfuscating the code.
The interface to dir.h changes slightly, hence tedious includes changes...
|
|
the disk or from a cache.
- use it in Dir_AddDir, and directly to set up dot.
- change Dir_AddDir to use string intervals, as this simplifies
dependend functions.
- set up an open-hashing cache for opened directory names.
- add_dirpath() function in main, to simplify code.
- simplify cleaning-up directories, as Dir_ClearPath is overkill.
|
|
Scrap the list of all targets: it only slows make down.
The only visible difference is that the list of all targets is not
shown in order when debugging.
|
|
|
|
iterate_words: light-weight equivalent to brk_string,
which does not need to copy the string, and does not do \ interpretation
which are only needed for the string.
escape_dup: handles escape sequence in a systematic way.
This speeds up variable modifiers.
This also makes .for loops more consistent, as they use the same definition
of `a word' as the rest of make.
|
|
- UNUSED macro that expands to __attribute__((unused)) for gcc
- move rcsid around so that they can be tagged UNUSED.
- activate -Wunused.
- use UNUSED instead of kludgy junk for function arguments.
- add extern to all extern prototypes.
- update comments in lst.h.
- clean up var.c a little bit, constifying arguments, updating comments...
|
|
Obvious fix.
Problem reported by Gregory Steuck, thanks a lot !
|
|
MAKEFLAGS
|
|
|
|
Code to pass variable definitions to submakes through make flags.
Not activated yet, need to fix src/ first.
|
|
|
|
- need braces, as we don't want to change what $$A means,
- this assumes this kind of construct is very infrequent, thus
this does NOT copy the variable name needlessly.
- the expansion code is in a separate function for clarity.
Reviewed by miod@, as previous patches.
|
|
- simplify Var_Parse: use varfind, then leverage on the result
to recognize `special case' dynamic parsing.
VarModifiers_Apply need to be called on NULL strings, to be able to parse
modifiers applied to non-existent variables.
(Alternately, we could call VarModifiers_Apply on a dummy string, but
this is less efficient).
|
|
This does finally make var handling somewhat readable.
|
|
VarModifiers_apply function.
for env lookup, create variable structure first, so that we can get away
without terminating the variable name in main Var_Parse.
|
|
than 1 or 0.
|
|
intervals, and \\ in intervals.
Accordingly, var.c no longer needs to copy the :Marg to replace \: with :
We don't use fnmatch(3) because of various optimizations which are harder
to achieve in a generic setting.
Also add regression suite for the Str_Match function.
|
|
Replace a few int -> size_t
Reviewed by miod@
|
|
- introduce VarFind_interval function. This avoids having to copy variable
names in VarParse,
- expose internals of VarFind* function (not used yet, but this will avoid
multiple lookups in VarParse),
- constify a few functions.
Reviewed by miod@
|
|
variable substitution is.
|
|
|
|
|
|
Ensure make prints sane error messages when obj/ exists.
|
|
make -n mode.
Currently works only in sequential make mode. In parallel make mode,
it's just a no-op.
Useful to debug recursive Makefiles, and part of POSIX.
|
|
hv is a u_int32_t.
Add __BEGIN_DECLS/__END_DECLS
Remove unused macro (hash_to_info).
Add documentation for the hash functions.
|
|
Also forgot a few CLEANFILES.
|
|
In particular, Dir_MakeFlags is abusing str_concat, and works much better
with buffers.
|
|
There is no code change in this patch, we just move the remaining
`lowparse' functions to the right file, and adjust the interface file
accordingly.
Reviewed by miod@
|
|
This does introduce a proper stack of IFiles to handle included files:
instead of having the current file be a special case, it's also an IFile.
The corresponding code is slightly unobfuscated, removing the error-prone
ParseEOF function, freeing the filename systematically (thus, main.c needs
to strdup stdin), and merging both include functions lookup into one.
The speed gain comes from changing the IFile structure to merge with
fgetln seamlessly.
The low-level parse code is mostly moved to a new file, lowparse.c, to
make things easier to read (see next patch as well).
Accordingly, util.c gains a fgetln.
Note the interaction between Parse_File, Dir_FindFile, and ReadMakefile in
main.c. This patch closes a subtle memory hole (only the Makefile names,
so rather small).
Reviewed by miod@.
|
|
Use the open hashing functions for global contexts instead of List in
var.c.
All the preliminary work to trim down local contexts means that we don't
suffer from the heavy initialization work that a hash table entails.
There is some make kludgery to:
- build the hashing functions as a library,
- recreate hashconsts.h, even if make depend was not invoked.
One point of the hashing scheme written was to separate the computation
of the hash function, and the hash lookup itself. This is very convenient
for make, because of those pesky special variables. hashconsts.h is there
to pre-hash the correct values, which replaces a few expensive string
comparisons with quick hash value comparisons, followed by one expensive
string comparison. The modulus MAGICSLOTS chosen in the Makefile is
ad-hoc: it is small enough to write a small switch without collision,
and will need changing if the hash function changes...
The function quick_lookup is the most important:
it either returns an index, for a local variable, or it does compute a
hashing value, and returns -1.
Another somewhat controversial decision is the use of string intervals.
This avoids either copying a string, or twiddling with a byte for cases
such as ${VAR}.
Finally, the variable name is stored within the variable itself. Since
a given variable name never changes, this makes sense. All that was needed
was a hash library with support for this. Note that the hashing table
holds only a variable pointer AND the corresponding hashing value, WITHOUT
a modulo hashtablesize. Two reasons:
- hash resizes can be done faster, without having to recompute hashing values.
- locality of access. The hash table fits into memory without problem. Once
a candidate slot is found, we check the complete hashing value. Probability
of a collision is very small (32 bits...). So bringing up the whole
variable in memory at once is good: the name will almost always match, in
which case we want the variable value as well, so it makes sense to put
them together.
The ohash functions implement open hashing, as described in Knuth, but with
a variable table size. Choosing powers of 2 sizes does not yield more
collisions, but it makes the hashing scheme much simpler. The thresholds at
which to expand/shrink the tables seem to work well in practice. The
default sizes were chosen such that the tables hardly ever shrink or expand
anyways (though I've tried with smaller/larger sizes to verify that the
shrinking/expanding worked correctly): larger Makefiles hold roughly
500/600 variables, which fits without trouble into a 1024-sized variable.
Disregard #ifdef STATS_HASH, this is some internal scaffolding I'm using
to measure make performance.
The only known issue with open-hashing is that deletions cannot create
empty slots, but do leave slots marked as `occupied once' so that lookup
works. We use a well-known optimization which records those pseudo-empty
slots while looking up values. If the value is not found, the pseudo-empty
slot is returned to be filled. If the value is found, it is swapped with
the pseudo-empty slot. This is an improvement in both cases, since this
shortens the length of lookup chains, eventually pushing the pseudo-empty
slots to the end.
Reviewed by millert@ and miod@
|
|
Some interface work to make it as fast as possible.
|
|
Apart from a few casts, VAR_GLOBAL and friends are separate
data structures, so we use a small array for local variables.
We also junk allVars, since TargFreeGN can release local nodes,
and var.c has explicit lists for its variables already.
Reviewed millert@ and miod@.
|
|
since lookup will start with VAR_CMD in any case.
This fixes VarFind and Var_Parse to handle ctxt == NULL correctly, and
replace those confusing VAR_CMD with proper NULL pointers.
This patch also handles three small details:
- .CURDIR is necessarily set in VAR_GLOBAL,
- suffix handling for archives copies two hard-coded variables, for
which it can use a quick path,
- typos in TargFreeGN.
Reviewed millert@, miod@.
|
|
the GNode's context directly. We rename that special Lst to `SymTable *'
in prevision of things to come.
Along the line, we lose the special GNodes affected to VAR_CMD, VAR_GLOBAL,
VAR_ENV, which become simple Lsts... This is not a problem, except when
getting to a context's name for debugging (handled very nicely by
offsetof).
Again, this is a preparatory patch, which does not gain anything except
for cleaning up issues...
Reviewed by millert@ and miod@, like the previous patch
|
|
This patch may seem a bit non-sensical at first. It simply introduces some
new interface. Specifically, recognizes that some variable names
(.TARGET/$@, .OODATE/$?, .ALLSRC/$>, .IMPSRC/$<, .PREFIX/$*, .ARCHIVE/$!,
.MEMBER/$%) are `special' (the actual variables which are local to a
target, e.g. GNode).
Currently, The Varq functions (for Varquick access) are only stubs to the
normal functions.
This fixes a very important detail before proceeding to turn variable lists
into hash tables: if every GNode holds a hash table, initialization times
for those will be very costly. But generic GNodes only hold those seven
special variables... which can be stored directly into a small array;
the only general cases are the environment, the command line and
global variables.
|
|
- audit code for Lst_Datum, it's never applied to an empty pointer,
so check can be removed -> turn into a macro,
- Lst_First, Lst_Last can become macro as well
- specialized version of Lst_Succ (Lst_Adv) to use in loops where it cannot
fail,
- Lst_Open can no longer fail. Trim down corresponding code.
Reviewed millert@, miod@
|
|
|
|
- replaces Lst_Duplicate with Lst_Clone, which does not allocate storage
- split Lst_Concat into Lst_Concat/Lst_ConcatDestroy
Thus, all the LstValid checks are gone, since we always invoke list
functions with valid pointers.
Note that dynamic list allocation accounted for roughly 20% of all calls
to malloc. The extraneous calls to malloc left are now mostly in parse.c,
which makes some wasteful usage of temporary buffers.
With those few patches, the code is sturdier, and easier to maintain.
Reviewed by millert@
|
|
- in Dir_Expand, path is a misnomer. Use a temp variable instead...
Reformat code for readability.
- Change Parse_MainName/Targ_FindList so that they fill arguments instead
of allocating new lists.
- nuke Targ_FindList(TG_NOCREATE), as this is never used.
- close a small memory hole (forgot to free sysMkPath if CLEANUP).
Reviewed by millert@
|
|
Lst_Init (constructor) and Lst_New (allocation + construction)
Lst_Destroy (destructor) and Lst_Delete (deallocation + destruction),
and uses that to turn most dynamic allocation of lists (Lst pointers)
into static structures (LIST).
Most of this is mundane, except for allGNs in targ.c, where the code must
be checked to verify that Targ_Init is called soon enough.
Lst_New is a temporary addition. All lists will soon be static.
Reviewed by millert@, like the previous patch.
|
|
C is not well-suited for opaque data structures.
Then it proceeds by removing a lot of non-sensical casts and white space.
There are two motivations behind this change:
* small functions like Lst_First can now be redefined as macros safely
(otherwise, the cast would mean that you might write Lst_First(5) and
find out about it rather late)
* the size of the Lst data structure is exposed to user code. This will
be used to allocate lists statically, instead of malloc/free them like
crazy.
|
|
|
|
|
|
In fact, it can become a macro based on Lst_ForEachFrom.
This also introduces Lst_Every, as a shortcut for the very common case where
Lst_ForEach does not need any user data.
Finally, make consistent use of a few function typedefs, instead of having
explicit void (*)(Lst) arguments all over the place.
|
|
sense is reversed (Lst_Find returns when proc says 0, whereas Lst_ForEach
goes on while proc says 0).
This patch turns a number of Lst_ForEach into Lst_Find.
Specifically, all Lst_ForEach that actually may return quickly as proc
does not always returns zero.
Of course, the corresponding proc need to be tweaked to swap 0 and 1...
|
|
|
|
|
|
Indicate what went wrong for commands like
@exit 1
|
