From e3ce954582f56b9d853ea379c783cf6cd5571c83 Mon Sep 17 00:00:00 2001 From: Eelco Dolstra Date: Mon, 4 Sep 2006 21:36:15 +0000 Subject: * Compile the lexer as C++ code. Remove all the redundant C/C++ marshalling code. --- src/libexpr/parser.y | 212 ++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 191 insertions(+), 21 deletions(-) (limited to 'src/libexpr/parser.y') diff --git a/src/libexpr/parser.y b/src/libexpr/parser.y index 7714a5911165..1f141c7bb09a 100644 --- a/src/libexpr/parser.y +++ b/src/libexpr/parser.y @@ -6,6 +6,7 @@ %parse-param { ParseData * data } %lex-param { yyscan_t scanner } + %{ #include #include @@ -13,19 +14,21 @@ #include #include "parser-tab.hh" -extern "C" { -#include "lexer-tab.h" -} +#include "lexer-tab.hh" #include "aterm.hh" +#include "util.hh" #include "nixexpr.hh" #include "nixexpr-ast.hh" + using namespace nix; + namespace nix { - + + struct ParseData { Expr result; @@ -34,33 +37,52 @@ struct ParseData string error; }; -void setParseResult(ParseData * data, ATerm t); -void parseError(ParseData * data, char * error, int line, int column); -ATerm absParsedPath(ParseData * data, ATerm t); -ATerm fixAttrs(int recursive, ATermList as); -const char * getPath(ParseData * data); -Expr unescapeStr(const char * s); - -extern "C" { - void backToString(yyscan_t scanner); -} - -} -void yyerror(YYLTYPE * loc, yyscan_t scanner, ParseData * data, char * s) +static ATerm fixAttrs(int recursive, ATermList as) { - parseError(data, s, loc->first_line, loc->first_column); + ATermList bs = ATempty, cs = ATempty; + ATermList * is = recursive ? &cs : &bs; + for (ATermIterator i(as); i; ++i) { + ATermList names; + Expr src; + ATerm pos; + if (matchInherit(*i, src, names, pos)) { + bool fromScope = matchScope(src); + for (ATermIterator j(names); j; ++j) { + Expr rhs = fromScope ? makeVar(*j) : makeSelect(src, *j); + *is = ATinsert(*is, makeBind(*j, rhs, pos)); + } + } else bs = ATinsert(bs, *i); + } + if (recursive) + return makeRec(bs, cs); + else + return makeAttrs(bs); } + +void backToString(yyscan_t scanner); + + static Pos makeCurPos(YYLTYPE * loc, ParseData * data) { - return makePos(toATerm(getPath(data)), + return makePos(toATerm(data->path), loc->first_line, loc->first_column); } #define CUR_POS makeCurPos(yylocp, data) +} + + +void yyerror(YYLTYPE * loc, yyscan_t scanner, ParseData * data, char * error) +{ + data->error = (format("%1%, at `%2%':%3%:%4%") + % error % data->path % loc->first_line % loc->first_column).str(); +} + + /* Make sure that the parse stack is scanned by the ATerm garbage collector. */ static void * mallocAndProtect(size_t size) @@ -107,7 +129,7 @@ static void freeAndUnprotect(void * p) %% -start: expr { setParseResult(data, $1); }; +start: expr { data->result = $1; }; expr: expr_function; @@ -165,7 +187,7 @@ expr_simple else if (ATgetNext($2) == ATempty) $$ = ATgetFirst($2); else $$ = makeConcatStrings(ATreverse($2)); } - | PATH { $$ = makePath(absParsedPath(data, $1)); } + | PATH { $$ = makePath(toATerm(absPath(aterm2String($1), data->basePath))); } | URI { $$ = makeUri($1); } | '(' expr ')' { $$ = $2; } /* Let expressions `let {..., body = ...}' are just desugared @@ -224,3 +246,151 @@ formal ; %% + + +#include "eval.hh" + +#include +#include +#include +#include + + +namespace nix { + + +static void checkAttrs(ATermMap & names, ATermList bnds) +{ + for (ATermIterator i(bnds); i; ++i) { + ATerm name; + Expr e; + ATerm pos; + if (!matchBind(*i, name, e, pos)) abort(); /* can't happen */ + if (names.get(name)) + throw EvalError(format("duplicate attribute `%1%' at %2%") + % aterm2String(name) % showPos(pos)); + names.set(name, name); + } +} + + +static void checkAttrSets(ATerm e) +{ + ATermList formals; + ATerm body, pos; + if (matchFunction(e, formals, body, pos)) { + ATermMap names(ATgetLength(formals)); + for (ATermIterator i(formals); i; ++i) { + ATerm name; + ATerm d1, d2; + if (!matchFormal(*i, name, d1, d2)) abort(); + if (names.get(name)) + throw EvalError(format("duplicate formal function argument `%1%' at %2%") + % aterm2String(name) % showPos(pos)); + names.set(name, name); + } + } + + ATermList bnds; + if (matchAttrs(e, bnds)) { + ATermMap names(ATgetLength(bnds)); + checkAttrs(names, bnds); + } + + ATermList rbnds, nrbnds; + if (matchRec(e, rbnds, nrbnds)) { + ATermMap names(ATgetLength(rbnds) + ATgetLength(nrbnds)); + checkAttrs(names, rbnds); + checkAttrs(names, nrbnds); + } + + if (ATgetType(e) == AT_APPL) { + int arity = ATgetArity(ATgetAFun(e)); + for (int i = 0; i < arity; ++i) + checkAttrSets(ATgetArgument(e, i)); + } + + else if (ATgetType(e) == AT_LIST) + for (ATermIterator i((ATermList) e); i; ++i) + checkAttrSets(*i); +} + + +static Expr parse(EvalState & state, + const char * text, const Path & path, + const Path & basePath) +{ + yyscan_t scanner; + ParseData data; + data.basePath = basePath; + data.path = path; + + yylex_init(&scanner); + yy_scan_string(text, scanner); + int res = yyparse(scanner, &data); + yylex_destroy(scanner); + + if (res) throw EvalError(data.error); + + try { + checkVarDefs(state.primOps, data.result); + } catch (Error & e) { + throw EvalError(format("%1%, in `%2%'") % e.msg() % path); + } + + checkAttrSets(data.result); + + return data.result; +} + + +Expr parseExprFromFile(EvalState & state, Path path) +{ + SwitchToOriginalUser sw; + + assert(path[0] == '/'); + +#if 0 + /* Perhaps this is already an imploded parse tree? */ + Expr e = ATreadFromNamedFile(path.c_str()); + if (e) return e; +#endif + + /* If `path' is a symlink, follow it. This is so that relative + path references work. */ + struct stat st; + if (lstat(path.c_str(), &st)) + throw SysError(format("getting status of `%1%'") % path); + if (S_ISLNK(st.st_mode)) path = absPath(readLink(path), dirOf(path)); + + /* If `path' refers to a directory, append `/default.nix'. */ + if (stat(path.c_str(), &st)) + throw SysError(format("getting status of `%1%'") % path); + if (S_ISDIR(st.st_mode)) + path = canonPath(path + "/default.nix"); + + /* Read the input file. We can't use SGparseFile() because it's + broken, so we read the input ourselves and call + SGparseString(). */ + AutoCloseFD fd = open(path.c_str(), O_RDONLY); + if (fd == -1) throw SysError(format("opening `%1%'") % path); + + if (fstat(fd, &st) == -1) + throw SysError(format("statting `%1%'") % path); + + char text[st.st_size + 1]; + readFull(fd, (unsigned char *) text, st.st_size); + text[st.st_size] = 0; + + return parse(state, text, path, dirOf(path)); +} + + +Expr parseExprFromString(EvalState & state, + const string & s, const Path & basePath) +{ + return parse(state, s.c_str(), "(string)", basePath); +} + + +} -- cgit 1.4.1