* Compile the lexer as C++ code. Remove all the redundant C/C++

marshalling code.

src/libexpr/parser.y

@@ -6,6 +6,7 @@
 %parse-param { ParseData * data }
 %lex-param { yyscan_t scanner }
 
+
 %{
 #include <stdio.h>
 #include <stdlib.h>
@@ -13,19 +14,21 @@
 #include <aterm2.h>
 
 #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 <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+
+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);
+}
+
+ 
+}