about summary refs log tree commit diff
path: root/src/nix.cc
blob: fae3175ba4dce1f453425815b53992cd10a1facf (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
#include <iostream>

#include "config.h"

#include "globals.hh"
#include "values.hh"
#include "eval.hh"


typedef void (* Operation) (Strings opFlags, Strings opArgs);


/* Parse a supposed value argument.  This can be a hash (the simple
   case), a symbolic name (in which case we do a lookup to obtain the
   hash), or a file name (which we import to obtain the hash).  Note
   that in order to disambiguate between symbolic names and file
   names, a file name should contain at least one `/'. */
Hash parseValueArg(string s)
{
    try {
        return parseHash(s);
    } catch (BadRefError e) { };

    if (s.find('/') != string::npos) {
        return addValue(s);
    } else {
        throw Error("not implemented");
    }
}


/* Evaluate values. */
static void opEvaluate(Strings opFlags, Strings opArgs)
{
    if (!opFlags.empty()) throw UsageError("unknown flag");

    for (Strings::iterator it = opArgs.begin();
         it != opArgs.end(); it++)
    {
        Hash hash = parseValueArg(*it);
        Expr e = ATmake("Deref(Hash(<str>))", ((string) hash).c_str());
        cerr << printExpr(evalValue(e)) << endl;
    }
}


static void opDelete(Strings opFlags, Strings opArgs)
{
    cerr << "delete!\n";
}


/* Add values to the Nix values directory and print the hashes of
   those values. */
static void opAdd(Strings opFlags, Strings opArgs)
{
    if (!opFlags.empty()) throw UsageError("unknown flag");

    for (Strings::iterator it = opArgs.begin();
         it != opArgs.end(); it++)
        cout << (string) addValue(*it) << endl;
}


/* Initialise the Nix databases. */
static void opInit(Strings opFlags, Strings opArgs)
{
    if (!opFlags.empty()) throw UsageError("unknown flag");
    if (!opArgs.empty())
        throw UsageError("--init does not have arguments");
    initDB();
}


/* Nix syntax:

   nix [OPTIONS...] [ARGUMENTS...]

   Operations:

     --evaluate / -e: evaluate values
     --delete / -d: delete values
     --query / -q: query stored values
     --add: add values
     --verify: verify Nix structures
     --dump: dump a value
     --init: initialise the Nix database
     --version: output version information
     --help: display help

   Operations that work on values accept the hash code of a value, the
   symbolic name of a value, or a file name of a external value that
   will be added prior to the operation.

   Query suboptions:

     Selection:

     --all / -a: query all stored values, otherwise given values

     Information:

     --info / -i: general value information

   Options:

     --verbose / -v: verbose operation
*/

/* Initialize, process arguments, and dispatch to the right
   operation. */
void run(Strings::iterator argCur, Strings::iterator argEnd)
{
    Strings opFlags, opArgs;
    Operation op = 0;

    /* Setup Nix paths. */
    nixValues = NIX_VALUES_DIR;
    nixLogDir = NIX_LOG_DIR;
    nixDB = (string) NIX_STATE_DIR + "/nixstate.db";

    /* Scan the arguments; find the operation, set global flags, put
       all other flags in a list, and put all other arguments in
       another list. */

    while (argCur != argEnd) {
        string arg = *argCur++;

        Operation oldOp = op;

        if (arg == "--evaluate" || arg == "-e")
            op = opEvaluate;
        else if (arg == "--delete" || arg == "-d")
            op = opDelete;
        else if (arg == "--add")
            op = opAdd;
        else if (arg == "--init")
            op = opInit;
        else if (arg[0] == '-')
            opFlags.push_back(arg);
        else
            opArgs.push_back(arg);

        if (oldOp && oldOp != op)
            throw UsageError("only one operation may be specified");
    }

    if (!op) throw UsageError("no operation specified");

    op(opFlags, opArgs);
}


int main(int argc, char * * argv)
{
    /* ATerm setup. */
    ATerm bottomOfStack;
    ATinit(argc, argv, &bottomOfStack);

    try {

        Strings args;
        while (argc--) args.push_back(*argv++);
        run(args.begin() + 1, args.end());

    } catch (UsageError & e) {
        cerr << "error: " << e.what() << endl
             << "Try `nix --help' for more information.\n";
        return 1;
    } catch (exception & e) {
        cerr << "error: " << e.what() << endl;
        return 1;
    }

    return 0;
}