Skip to content

Commit

Permalink
libnixt: fix uninitialized use
Browse files Browse the repository at this point in the history
  • Loading branch information
@inclyc
inclyc committed Apr 8, 2024
1 parent db03e8a commit ccf2d1f
Show file tree
Hide file tree
Showing 2 changed files with 283 additions and 14 deletions.
293 changes: 280 additions & 13 deletions libnixt/include/nixt/HookExpr.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -9,18 +9,285 @@ namespace nixt {
using ValueMap = std::map<std::uintptr_t, nix::Value>;
using EnvMap = std::map<std::uintptr_t, nix::Env *>;

#define NIX_EXPR(EXPR) \
struct Hook##EXPR : nix::EXPR { \
ValueMap &VMap; \
EnvMap &EMap; \
std::uintptr_t Handle; \
Hook##EXPR(nix::EXPR E, ValueMap &VMap, EnvMap &EMap, \
std::uintptr_t Handle) \
: nix::EXPR(E), VMap(VMap), EMap(EMap), Handle(Handle) {} \
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override; \
std::string getName(); \
};
#include "Nodes.inc"
#undef NIX_EXPR
struct HookExprAssert : nix::ExprAssert {
ValueMap &VMap;
EnvMap &EMap;
std::uintptr_t Handle;
HookExprAssert(nix::ExprAssert E, ValueMap &VMap, EnvMap &EMap,
std::uintptr_t Handle)
: nix::ExprAssert(std::move(E)), VMap(VMap), EMap(EMap), Handle(Handle) {}
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override;
std::string getName();
};

struct HookExprAttrs : nix::ExprAttrs {
ValueMap &VMap;
EnvMap &EMap;
std::uintptr_t Handle;
HookExprAttrs(nix::ExprAttrs E, ValueMap &VMap, EnvMap &EMap,
std::uintptr_t Handle)
: nix::ExprAttrs(std::move(E)), VMap(VMap), EMap(EMap), Handle(Handle) {}
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override;
std::string getName();
};

struct HookExprCall : nix::ExprCall {
ValueMap &VMap;
EnvMap &EMap;
std::uintptr_t Handle;
HookExprCall(nix::ExprCall E, ValueMap &VMap, EnvMap &EMap,
std::uintptr_t Handle)
: nix::ExprCall(std::move(E)), VMap(VMap), EMap(EMap), Handle(Handle) {}
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override;
std::string getName();
};

struct HookExprConcatStrings : nix::ExprConcatStrings {
ValueMap &VMap;
EnvMap &EMap;
std::uintptr_t Handle;
HookExprConcatStrings(nix::ExprConcatStrings E, ValueMap &VMap, EnvMap &EMap,
std::uintptr_t Handle)
: nix::ExprConcatStrings(std::move(E)), VMap(VMap), EMap(EMap),
Handle(Handle) {}
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override;
std::string getName();
};

struct HookExprFloat : nix::ExprFloat {
ValueMap &VMap;
EnvMap &EMap;
std::uintptr_t Handle;
HookExprFloat(nix::ExprFloat E, ValueMap &VMap, EnvMap &EMap,
std::uintptr_t Handle)
: nix::ExprFloat(std::move(E)), VMap(VMap), EMap(EMap), Handle(Handle) {}
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override;
std::string getName();
};

struct HookExprIf : nix::ExprIf {
ValueMap &VMap;
EnvMap &EMap;
std::uintptr_t Handle;
HookExprIf(nix::ExprIf E, ValueMap &VMap, EnvMap &EMap, std::uintptr_t Handle)
: nix::ExprIf(std::move(E)), VMap(VMap), EMap(EMap), Handle(Handle) {}
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override;
std::string getName();
};

struct HookExprInt : nix::ExprInt {
ValueMap &VMap;
EnvMap &EMap;
std::uintptr_t Handle;
HookExprInt(nix::ExprInt E, ValueMap &VMap, EnvMap &EMap,
std::uintptr_t Handle)
: nix::ExprInt(std::move(E)), VMap(VMap), EMap(EMap), Handle(Handle) {}
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override;
std::string getName();
};

struct HookExprLambda : nix::ExprLambda {
ValueMap &VMap;
EnvMap &EMap;
std::uintptr_t Handle;
HookExprLambda(nix::ExprLambda E, ValueMap &VMap, EnvMap &EMap,
std::uintptr_t Handle)
: nix::ExprLambda(std::move(E)), VMap(VMap), EMap(EMap), Handle(Handle) {}
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override;
std::string getName();
};

struct HookExprLet : nix::ExprLet {
ValueMap &VMap;
EnvMap &EMap;
std::uintptr_t Handle;
HookExprLet(nix::ExprLet E, ValueMap &VMap, EnvMap &EMap,
std::uintptr_t Handle)
: nix::ExprLet(std::move(E)), VMap(VMap), EMap(EMap), Handle(Handle) {}
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override;
std::string getName();
};

struct HookExprList : nix::ExprList {
ValueMap &VMap;
EnvMap &EMap;
std::uintptr_t Handle;
HookExprList(nix::ExprList E, ValueMap &VMap, EnvMap &EMap,
std::uintptr_t Handle)
: nix::ExprList(std::move(E)), VMap(VMap), EMap(EMap), Handle(Handle) {}
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override;
std::string getName();
};

struct HookExprOpAnd : nix::ExprOpAnd {
ValueMap &VMap;
EnvMap &EMap;
std::uintptr_t Handle;
HookExprOpAnd(nix::ExprOpAnd E, ValueMap &VMap, EnvMap &EMap,
std::uintptr_t Handle)
: nix::ExprOpAnd(std::move(E)), VMap(VMap), EMap(EMap), Handle(Handle) {}
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override;
std::string getName();
};

struct HookExprOpConcatLists : nix::ExprOpConcatLists {
ValueMap &VMap;
EnvMap &EMap;
std::uintptr_t Handle;
HookExprOpConcatLists(nix::ExprOpConcatLists E, ValueMap &VMap, EnvMap &EMap,
std::uintptr_t Handle)
: nix::ExprOpConcatLists(std::move(E)), VMap(VMap), EMap(EMap),
Handle(Handle) {}
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override;
std::string getName();
};

struct HookExprOpEq : nix::ExprOpEq {
ValueMap &VMap;
EnvMap &EMap;
std::uintptr_t Handle;
HookExprOpEq(nix::ExprOpEq E, ValueMap &VMap, EnvMap &EMap,
std::uintptr_t Handle)
: nix::ExprOpEq(std::move(E)), VMap(VMap), EMap(EMap), Handle(Handle) {}
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override;
std::string getName();
};

struct HookExprOpHasAttr : nix::ExprOpHasAttr {
ValueMap &VMap;
EnvMap &EMap;
std::uintptr_t Handle;
HookExprOpHasAttr(nix::ExprOpHasAttr E, ValueMap &VMap, EnvMap &EMap,
std::uintptr_t Handle)
: nix::ExprOpHasAttr(std::move(E)), VMap(VMap), EMap(EMap),
Handle(Handle) {}
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override;
std::string getName();
};

struct HookExprOpImpl : nix::ExprOpImpl {
ValueMap &VMap;
EnvMap &EMap;
std::uintptr_t Handle;
HookExprOpImpl(nix::ExprOpImpl E, ValueMap &VMap, EnvMap &EMap,
std::uintptr_t Handle)
: nix::ExprOpImpl(std::move(E)), VMap(VMap), EMap(EMap), Handle(Handle) {}
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override;
std::string getName();
};

struct HookExprOpNEq : nix::ExprOpNEq {
ValueMap &VMap;
EnvMap &EMap;
std::uintptr_t Handle;
HookExprOpNEq(nix::ExprOpNEq E, ValueMap &VMap, EnvMap &EMap,
std::uintptr_t Handle)
: nix::ExprOpNEq(std::move(E)), VMap(VMap), EMap(EMap), Handle(Handle) {}
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override;
std::string getName();
};

struct HookExprOpNot : nix::ExprOpNot {
ValueMap &VMap;
EnvMap &EMap;
std::uintptr_t Handle;
HookExprOpNot(nix::ExprOpNot E, ValueMap &VMap, EnvMap &EMap,
std::uintptr_t Handle)
: nix::ExprOpNot(std::move(E)), VMap(VMap), EMap(EMap), Handle(Handle) {}
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override;
std::string getName();
};

struct HookExprOpOr : nix::ExprOpOr {
ValueMap &VMap;
EnvMap &EMap;
std::uintptr_t Handle;
HookExprOpOr(nix::ExprOpOr E, ValueMap &VMap, EnvMap &EMap,
std::uintptr_t Handle)
: nix::ExprOpOr(std::move(E)), VMap(VMap), EMap(EMap), Handle(Handle) {}
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override;
std::string getName();
};

struct HookExprOpUpdate : nix::ExprOpUpdate {
ValueMap &VMap;
EnvMap &EMap;
std::uintptr_t Handle;
HookExprOpUpdate(nix::ExprOpUpdate E, ValueMap &VMap, EnvMap &EMap,
std::uintptr_t Handle)
: nix::ExprOpUpdate(std::move(E)), VMap(VMap), EMap(EMap),
Handle(Handle) {}
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override;
std::string getName();
};

struct HookExprPath : nix::ExprPath {
ValueMap &VMap;
EnvMap &EMap;
std::uintptr_t Handle;
HookExprPath(nix::ExprPath E, ValueMap &VMap, EnvMap &EMap,
std::uintptr_t Handle)
: nix::ExprPath(std::move(E)), VMap(VMap), EMap(EMap), Handle(Handle) {
v.mkPath(&*accessor, s.c_str());
}
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override;
std::string getName();
};

struct HookExprPos : nix::ExprPos {
ValueMap &VMap;
EnvMap &EMap;
std::uintptr_t Handle;
HookExprPos(nix::ExprPos E, ValueMap &VMap, EnvMap &EMap,
std::uintptr_t Handle)
: nix::ExprPos(std::move(E)), VMap(VMap), EMap(EMap), Handle(Handle) {}
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override;
std::string getName();
};

struct HookExprSelect : nix::ExprSelect {
ValueMap &VMap;
EnvMap &EMap;
std::uintptr_t Handle;
HookExprSelect(nix::ExprSelect E, ValueMap &VMap, EnvMap &EMap,
std::uintptr_t Handle)
: nix::ExprSelect(std::move(E)), VMap(VMap), EMap(EMap), Handle(Handle) {}
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override;
std::string getName();
};

struct HookExprString : nix::ExprString {
ValueMap &VMap;
EnvMap &EMap;
std::uintptr_t Handle;
HookExprString(nix::ExprString E, ValueMap &VMap, EnvMap &EMap,
std::uintptr_t Handle)
: nix::ExprString(std::move(E)), VMap(VMap), EMap(EMap), Handle(Handle) {
v.mkString(s.data());
}
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override;
std::string getName();
};

struct HookExprVar : nix::ExprVar {
ValueMap &VMap;
EnvMap &EMap;
std::uintptr_t Handle;
HookExprVar(nix::ExprVar E, ValueMap &VMap, EnvMap &EMap,
std::uintptr_t Handle)
: nix::ExprVar(std::move(E)), VMap(VMap), EMap(EMap), Handle(Handle) {}
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override;
std::string getName();
};

struct HookExprWith : nix::ExprWith {
ValueMap &VMap;
EnvMap &EMap;
std::uintptr_t Handle;
HookExprWith(nix::ExprWith E, ValueMap &VMap, EnvMap &EMap,
std::uintptr_t Handle)
: nix::ExprWith(std::move(E)), VMap(VMap), EMap(EMap), Handle(Handle) {}
void eval(nix::EvalState &State, nix::Env &Env, nix::Value &V) override;
std::string getName();
};
} // namespace nixt
4 changes: 3 additions & 1 deletion libnixt/lib/ASTReader.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -123,7 +123,9 @@ nix::ExprVar ASTDeserializer::eatExprVar(nix::PosIdx Pos,
std::string_view &Data) {
auto Name = eat<std::string>(Data);
nix::Symbol Sym = Ctx.STable.create(Name);
return {Pos, Sym};
nix::ExprVar Ret{Pos, Sym};
Ret.fromWith = false; // nix does not initialized this field!
return Ret;
}

nix::AttrPath ASTDeserializer::eatAttrPath(std::string_view &Data) {
Expand Down

0 comments on commit ccf2d1f

Please sign in to comment.