if we defer the duplicate argument check for lambda formals we can use more
efficient data structures for the formals set, and we can get rid of the
duplication of formals names to boot. instead of a list of formals we've seen
and a set of names we'll keep a vector instead and run a sort+dupcheck step
before moving the parsed formals into a newly created lambda. this improves
performance on search and rebuild by ~1%, pure parsing gains more (about 4%).
this does reorder lambda arguments in the xml output, but the output is still
stable. this shouldn't be a problem since argument order is not semantically
important anyway.
before
nix search --no-eval-cache --offline ../nixpkgs hello
Time (mean ± σ): 8.550 s ± 0.060 s [User: 6.470 s, System: 1.664 s]
Range (min … max): 8.435 s … 8.666 s 20 runs
nix eval -f ../nixpkgs/pkgs/development/haskell-modules/hackage-packages.nix
Time (mean ± σ): 346.7 ms ± 2.1 ms [User: 312.4 ms, System: 34.2 ms]
Range (min … max): 343.8 ms … 353.4 ms 20 runs
nix eval --raw --impure --expr 'with import <nixpkgs/nixos> {}; system'
Time (mean ± σ): 2.720 s ± 0.031 s [User: 2.415 s, System: 0.231 s]
Range (min … max): 2.662 s … 2.780 s 20 runs
after
nix search --no-eval-cache --offline ../nixpkgs hello
Time (mean ± σ): 8.462 s ± 0.063 s [User: 6.398 s, System: 1.661 s]
Range (min … max): 8.339 s … 8.542 s 20 runs
nix eval -f ../nixpkgs/pkgs/development/haskell-modules/hackage-packages.nix
Time (mean ± σ): 329.1 ms ± 1.4 ms [User: 296.8 ms, System: 32.3 ms]
Range (min … max): 326.1 ms … 330.8 ms 20 runs
nix eval --raw --impure --expr 'with import <nixpkgs/nixos> {}; system'
Time (mean ± σ): 2.687 s ± 0.035 s [User: 2.392 s, System: 0.228 s]
Range (min … max): 2.626 s … 2.754 s 20 runs
186 lines
5.5 KiB
C++
186 lines
5.5 KiB
C++
#include "value-to-xml.hh"
|
|
#include "xml-writer.hh"
|
|
#include "eval-inline.hh"
|
|
#include "util.hh"
|
|
|
|
#include <cstdlib>
|
|
|
|
|
|
namespace nix {
|
|
|
|
|
|
static XMLAttrs singletonAttrs(const string & name, const string & value)
|
|
{
|
|
XMLAttrs attrs;
|
|
attrs[name] = value;
|
|
return attrs;
|
|
}
|
|
|
|
|
|
static void printValueAsXML(EvalState & state, bool strict, bool location,
|
|
Value & v, XMLWriter & doc, PathSet & context, PathSet & drvsSeen,
|
|
const Pos & pos);
|
|
|
|
|
|
static void posToXML(XMLAttrs & xmlAttrs, const Pos & pos)
|
|
{
|
|
xmlAttrs["path"] = pos.file;
|
|
xmlAttrs["line"] = (format("%1%") % pos.line).str();
|
|
xmlAttrs["column"] = (format("%1%") % pos.column).str();
|
|
}
|
|
|
|
|
|
static void showAttrs(EvalState & state, bool strict, bool location,
|
|
Bindings & attrs, XMLWriter & doc, PathSet & context, PathSet & drvsSeen)
|
|
{
|
|
StringSet names;
|
|
|
|
for (auto & i : attrs)
|
|
names.insert(i.name);
|
|
|
|
for (auto & i : names) {
|
|
Attr & a(*attrs.find(state.symbols.create(i)));
|
|
|
|
XMLAttrs xmlAttrs;
|
|
xmlAttrs["name"] = i;
|
|
if (location && a.pos != ptr(&noPos)) posToXML(xmlAttrs, *a.pos);
|
|
|
|
XMLOpenElement _(doc, "attr", xmlAttrs);
|
|
printValueAsXML(state, strict, location,
|
|
*a.value, doc, context, drvsSeen, *a.pos);
|
|
}
|
|
}
|
|
|
|
|
|
static void printValueAsXML(EvalState & state, bool strict, bool location,
|
|
Value & v, XMLWriter & doc, PathSet & context, PathSet & drvsSeen,
|
|
const Pos & pos)
|
|
{
|
|
checkInterrupt();
|
|
|
|
if (strict) state.forceValue(v, pos);
|
|
|
|
switch (v.type()) {
|
|
|
|
case nInt:
|
|
doc.writeEmptyElement("int", singletonAttrs("value", (format("%1%") % v.integer).str()));
|
|
break;
|
|
|
|
case nBool:
|
|
doc.writeEmptyElement("bool", singletonAttrs("value", v.boolean ? "true" : "false"));
|
|
break;
|
|
|
|
case nString:
|
|
/* !!! show the context? */
|
|
copyContext(v, context);
|
|
doc.writeEmptyElement("string", singletonAttrs("value", v.string.s));
|
|
break;
|
|
|
|
case nPath:
|
|
doc.writeEmptyElement("path", singletonAttrs("value", v.path));
|
|
break;
|
|
|
|
case nNull:
|
|
doc.writeEmptyElement("null");
|
|
break;
|
|
|
|
case nAttrs:
|
|
if (state.isDerivation(v)) {
|
|
XMLAttrs xmlAttrs;
|
|
|
|
Bindings::iterator a = v.attrs->find(state.symbols.create("derivation"));
|
|
|
|
Path drvPath;
|
|
a = v.attrs->find(state.sDrvPath);
|
|
if (a != v.attrs->end()) {
|
|
if (strict) state.forceValue(*a->value, *a->pos);
|
|
if (a->value->type() == nString)
|
|
xmlAttrs["drvPath"] = drvPath = a->value->string.s;
|
|
}
|
|
|
|
a = v.attrs->find(state.sOutPath);
|
|
if (a != v.attrs->end()) {
|
|
if (strict) state.forceValue(*a->value, *a->pos);
|
|
if (a->value->type() == nString)
|
|
xmlAttrs["outPath"] = a->value->string.s;
|
|
}
|
|
|
|
XMLOpenElement _(doc, "derivation", xmlAttrs);
|
|
|
|
if (drvPath != "" && drvsSeen.insert(drvPath).second)
|
|
showAttrs(state, strict, location, *v.attrs, doc, context, drvsSeen);
|
|
else
|
|
doc.writeEmptyElement("repeated");
|
|
}
|
|
|
|
else {
|
|
XMLOpenElement _(doc, "attrs");
|
|
showAttrs(state, strict, location, *v.attrs, doc, context, drvsSeen);
|
|
}
|
|
|
|
break;
|
|
|
|
case nList: {
|
|
XMLOpenElement _(doc, "list");
|
|
for (auto v2 : v.listItems())
|
|
printValueAsXML(state, strict, location, *v2, doc, context, drvsSeen, pos);
|
|
break;
|
|
}
|
|
|
|
case nFunction: {
|
|
if (!v.isLambda()) {
|
|
// FIXME: Serialize primops and primopapps
|
|
doc.writeEmptyElement("unevaluated");
|
|
break;
|
|
}
|
|
XMLAttrs xmlAttrs;
|
|
if (location) posToXML(xmlAttrs, v.lambda.fun->pos);
|
|
XMLOpenElement _(doc, "function", xmlAttrs);
|
|
|
|
if (v.lambda.fun->hasFormals()) {
|
|
XMLAttrs attrs;
|
|
if (!v.lambda.fun->arg.empty()) attrs["name"] = v.lambda.fun->arg;
|
|
if (v.lambda.fun->formals->ellipsis) attrs["ellipsis"] = "1";
|
|
XMLOpenElement _(doc, "attrspat", attrs);
|
|
for (auto & i : v.lambda.fun->formals->lexicographicOrder())
|
|
doc.writeEmptyElement("attr", singletonAttrs("name", i.name));
|
|
} else
|
|
doc.writeEmptyElement("varpat", singletonAttrs("name", v.lambda.fun->arg));
|
|
|
|
break;
|
|
}
|
|
|
|
case nExternal:
|
|
v.external->printValueAsXML(state, strict, location, doc, context, drvsSeen, pos);
|
|
break;
|
|
|
|
case nFloat:
|
|
doc.writeEmptyElement("float", singletonAttrs("value", (format("%1%") % v.fpoint).str()));
|
|
break;
|
|
|
|
case nThunk:
|
|
doc.writeEmptyElement("unevaluated");
|
|
}
|
|
}
|
|
|
|
|
|
void ExternalValueBase::printValueAsXML(EvalState & state, bool strict,
|
|
bool location, XMLWriter & doc, PathSet & context, PathSet & drvsSeen,
|
|
const Pos & pos) const
|
|
{
|
|
doc.writeEmptyElement("unevaluated");
|
|
}
|
|
|
|
|
|
void printValueAsXML(EvalState & state, bool strict, bool location,
|
|
Value & v, std::ostream & out, PathSet & context, const Pos & pos)
|
|
{
|
|
XMLWriter doc(true, out);
|
|
XMLOpenElement root(doc, "expr");
|
|
PathSet drvsSeen;
|
|
printValueAsXML(state, strict, location, v, doc, context, drvsSeen, pos);
|
|
}
|
|
|
|
|
|
}
|