Update serpent.

Disable wallet import for now.

alethzero/Main.ui

@@ -1789,6 +1789,9 @@ font-size: 14pt</string>
    </property>
   </action>
   <action name="importKeyFile">
+   <property name="enabled">
+    <bool>false</bool>
+   </property>
    <property name="text">
     <string>Claim Ether Presale &amp;Wallet...</string>
    </property>

libdevcrypto/CryptoPP.h

@@ -23,12 +23,11 @@
 
 #pragma once
 
-// need to leave this one disabled
+// need to leave this one disabled for link-time. blame cryptopp.
-//#pragma GCC diagnostic ignored "-Wunused-function"
+#pragma GCC diagnostic ignored "-Wunused-function"
 #pragma warning(push)
 #pragma warning(disable:4100 4244)
 #pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-function"
 #pragma GCC diagnostic ignored "-Wconversion"
 #pragma GCC diagnostic ignored "-Wunused-parameter"
 #pragma GCC diagnostic ignored "-Wunused-variable"
@@ -58,6 +57,7 @@ namespace crypto
 
 namespace pp
 {
+
 /// RNG used by CryptoPP
 inline CryptoPP::AutoSeededRandomPool& PRNG() { static CryptoPP::AutoSeededRandomPool prng; return prng; }
 

libpyserpent/pyserpent.cpp

@@ -120,11 +120,15 @@ std::vector<Node> cppifyNodeList(PyObject* o) {
 }
 
 PYMETHOD(ps_compile, FROMSTR, compile, pyifyString)
+PYMETHOD(ps_compile_chunk, FROMSTR, compileChunk, pyifyString)
 PYMETHOD(ps_compile_to_lll, FROMSTR, compileToLLL, pyifyNode)
+PYMETHOD(ps_compile_chunk_to_lll, FROMSTR, compileChunkToLLL, pyifyNode)
 PYMETHOD(ps_compile_lll, FROMNODE, compileLLL, pyifyString)
 PYMETHOD(ps_parse, FROMSTR, parseSerpent, pyifyNode)
 PYMETHOD(ps_rewrite, FROMNODE, rewrite, pyifyNode)
+PYMETHOD(ps_rewrite_chunk, FROMNODE, rewriteChunk, pyifyNode)
 PYMETHOD(ps_pretty_compile, FROMSTR, prettyCompile, pyifyNodeList)
+PYMETHOD(ps_pretty_compile_chunk, FROMSTR, prettyCompileChunk, pyifyNodeList)
 PYMETHOD(ps_pretty_compile_lll, FROMNODE, prettyCompileLLL, pyifyNodeList)
 PYMETHOD(ps_serialize, FROMLIST, serialize, pyifyString)
 PYMETHOD(ps_deserialize, FROMSTR, deserialize, pyifyNodeList)
@@ -134,16 +138,24 @@ PYMETHOD(ps_parse_lll, FROMSTR, parseLLL, pyifyNode)
 static PyMethodDef PyextMethods[] = {
     {"compile",  ps_compile, METH_VARARGS,
         "Compile code."},
+    {"compile_chunk",  ps_compile_chunk, METH_VARARGS,
+        "Compile code chunk (no wrappers)."},
     {"compile_to_lll",  ps_compile_to_lll, METH_VARARGS,
         "Compile code to LLL."},
+    {"compile_chunk_to_lll",  ps_compile_chunk_to_lll, METH_VARARGS,
+        "Compile code chunk to LLL (no wrappers)."},
     {"compile_lll",  ps_compile_lll, METH_VARARGS,
         "Compile LLL to EVM."},
     {"parse",  ps_parse, METH_VARARGS,
         "Parse serpent"},
     {"rewrite",  ps_rewrite, METH_VARARGS,
         "Rewrite parsed serpent to LLL"},
+    {"rewrite_chunk",  ps_rewrite_chunk, METH_VARARGS,
+        "Rewrite parsed serpent to LLL (no wrappers)"},
     {"pretty_compile",  ps_pretty_compile, METH_VARARGS,
         "Compile to EVM opcodes"},
+    {"pretty_compile_chunk",  ps_pretty_compile_chunk, METH_VARARGS,
+        "Compile chunk to EVM opcodes (no wrappers)"},
     {"pretty_compile_lll",  ps_pretty_compile_lll, METH_VARARGS,
         "Compile LLL to EVM opcodes"},
     {"serialize",  ps_serialize, METH_VARARGS,

libserpent/compiler.cpp

@@ -298,7 +298,7 @@ Node finalize(programData c) {
     Metadata m = c.code.metadata;
     // If we are using both alloc and variables, we need to pre-zfill
     // some memory
-    if (c.aux.allocUsed && c.aux.vars.size() > 0) {
+    if ((c.aux.allocUsed || c.aux.calldataUsed) && c.aux.vars.size() > 0) {
         Node nodelist[] = {
             token("0", m), 
             token(unsignedToDecimal(c.aux.vars.size() * 32 - 1)),
@@ -309,8 +309,8 @@ Node finalize(programData c) {
     // If msg.data is being used as an array, then we need to copy it
     if (c.aux.calldataUsed) {
         Node nodelist[] = {
-            token("MSIZE", m), token("CALLDATASIZE", m), token("MSIZE", m),
+            token("MSIZE", m), token("CALLDATASIZE", m), token("0", m),
-            token("0", m), token("CALLDATACOPY", m),
+            token("MSIZE", m), token("CALLDATACOPY", m),
             token(c.aux.vars["'msg.data"], m), token("MSTORE", m)
         };
         bottom.push_back(multiToken(nodelist, 7, m));

libserpent/funcs.cpp

@@ -14,6 +14,10 @@ Node compileToLLL(std::string input) {
     return rewrite(parseSerpent(input));
 }
 
+Node compileChunkToLLL(std::string input) {
+    return rewriteChunk(parseSerpent(input));
+}
+
 std::string compile(std::string input) {
     return compileLLL(compileToLLL(input));
 }
@@ -21,3 +25,11 @@ std::string compile(std::string input) {
 std::vector<Node> prettyCompile(std::string input) {
     return prettyCompileLLL(compileToLLL(input));
 }
+
+std::string compileChunk(std::string input) {
+    return compileLLL(compileChunkToLLL(input));
+}
+
+std::vector<Node> prettyCompileChunk(std::string input) {
+    return prettyCompileLLL(compileChunkToLLL(input));
+}

libserpent/funcs.h

@@ -24,6 +24,12 @@
 
 Node compileToLLL(std::string input);
 
+Node compileChunkToLLL(std::string input);
+
 std::string compile(std::string input);
 
 std::vector<Node> prettyCompile(std::string input);
+
+std::string compileChunk(std::string input);
+
+std::vector<Node> prettyCompileChunk(std::string input);

libserpent/parser.cpp

@@ -32,7 +32,7 @@ int toktype(Node tok) {
     if (v == "(" || v == "[" || v == "{") return LPAREN;
     else if (v == ")" || v == "]" || v == "}") return RPAREN;
     else if (v == ",") return COMMA;
-    else if (v == "!" || v == "not") return UNARY_OP;
+    else if (v == "!" || v == "not" || v == "neg") return UNARY_OP;
     else if (precedence(tok) >= 0) return BINARY_OP;
     if (tok.val[0] != '"' && tok.val[0] != '\'') {
 		for (unsigned i = 0; i < tok.val.length(); i++) {
@@ -91,8 +91,9 @@ std::vector<Node> shuntingYard(std::vector<Node> tokens) {
         // If binary op, keep popping from stack while higher bedmas precedence
         else if (toktyp == BINARY_OP) {
             if (tok.val == "-" && prevtyp != ALPHANUM && prevtyp != RPAREN) {
-                oq.push_back(token("0", tok.metadata));
+                stack.push_back(token("neg", tok.metadata));
             }
+            else {
                 int prec = precedence(tok);
                 while (stack.size() 
                       && (toktype(stack.back()) == BINARY_OP 
@@ -103,6 +104,7 @@ std::vector<Node> shuntingYard(std::vector<Node> tokens) {
                 }
                 stack.push_back(tok);
             }
+        }
         // Comma means finish evaluating the argument
         else if (toktyp == COMMA) {
             while (stack.size() && toktype(stack.back()) != LPAREN) {

libserpent/rewriter.cpp

@@ -28,6 +28,8 @@ std::string valid[][3] = {
     { "sha3", "1", "2" },
     { "return", "1", "2" },
     { "inset", "1", "1" },
+    { "min", "2", "2" },
+    { "max", "2", "2" },
     { "array_lit", "0", tt256 },
     { "seq", "0", tt256 },
     { "---END---", "", "" } //Keep this line at the end of the list
@@ -70,6 +72,14 @@ std::string macros[][2] = {
         "(!= $a $b)",
         "(not (eq $a $b))"
     },
+    {
+        "(min a b)",
+        "(with $1 a (with $2 b (if (lt $1 $2) $1 $2)))"
+    },
+    {
+        "(max a b)",
+        "(with $1 a (with $2 b (if (lt $1 $2) $2 $1)))"
+    },
     {
         "(if $cond $do (else $else))",
         "(if $cond $do $else)"
@@ -229,7 +239,7 @@ std::string macros[][2] = {
     },
     {
         "(msg $gas $to $val $inp $inpsz $outsz)",
-        "(with $1 (mul 32 $outsz) (with $2 (alloc (get $1)) (call $gas $to $val $inp (mul 32 $inpsz) (get $2) (get $1)) (get $2)))"
+        "(with $1 (mul 32 $outsz) (with $2 (alloc (get $1)) (seq (call $gas $to $val $inp (mul 32 $inpsz) (get $2) (get $1)) (get $2))))"
     },
     // Call stateless and msg stateless
     {
@@ -561,4 +571,8 @@ Node rewrite(Node inp) {
     return optimize(apply_rules(validate(preprocess(inp))));
 }
 
+Node rewriteChunk(Node inp) {
+    return optimize(apply_rules(validate(inp)));
+}
+
 using namespace std;

libserpent/rewriter.h

@@ -10,4 +10,7 @@
 // Applies rewrite rules
 Node rewrite(Node inp);
 
+// Applies rewrite rules adding without wrapper
+Node rewriteChunk(Node inp);
+
 #endif

libserpent/util.cpp

@@ -137,7 +137,7 @@ std::string strToNumeric(std::string inp) {
     }
     else if (inp.substr(0,2) == "0x") {
 		for (unsigned i = 2; i < inp.length(); i++) {
-            int dig = std::string("0123456789abcdef").find(inp[i]);
+            int dig = std::string("0123456789abcdef0123456789ABCDEF").find(inp[i]) % 16;
             if (dig < 0) return "";
             o = decimalAdd(decimalMul(o,"16"), unsignedToDecimal(dig));
         }

libwhisper/Common.cpp

@@ -52,7 +52,7 @@ TopicMask BuildTopicMask::toTopicMask() const
 	return ret;
 }
 /*
-web3.shh.watch({}, function(m) { env.note("New message:\n"+JSON.stringify(m)); })
+web3.shh.watch({}).arrived(function(m) { env.note("New message:\n"+JSON.stringify(m)); })
 k = web3.shh.newIdentity()
 web3.shh.post({from: k, topic: web3.fromAscii("test"), payload: web3.fromAscii("Hello world!")})
 */

sc/cmdline.cpp

@@ -3,14 +3,10 @@
 #include <iostream>
 #include <vector>
 #include <map>
-#include <string>
 #include <libserpent/funcs.h>
-#include <libdevcore/Exceptions.h>
 
-int main(int argv, char** argc)
+int main(int argv, char** argc) {
-{
+    if (argv == 1) {
-	if (argv == 1)
-	{
         std::cerr << "Must provide a command and arguments! Try parse, rewrite, compile, assemble\n";
         return 0;
     }
@@ -18,77 +14,98 @@ int main(int argv, char** argc)
     std::string command = argc[1];
     std::string input;
     std::string secondInput;
-	if (std::string(argc[1]) == "-s")
+    if (std::string(argc[1]) == "-s") {
-	{
         flag = command.substr(1);
         command = argc[2];
         input = "";
         std::string line;
-		while (std::getline(std::cin, line))
+        while (std::getline(std::cin, line)) {
-		{
             input += line + "\n";
         }
         secondInput = argv == 3 ? "" : argc[3];
     }
-	else
+    else {
-	{
+        if (argv == 2) {
-		if (argv == 2)
-		{
             std::cerr << "Not enough arguments for serpent cmdline\n";
-			BOOST_THROW_EXCEPTION(dev::Exception() << dev::errinfo_comment("Not enough arguments for serpent cmdline"));
+            throw(0);
         }
         input = argc[2];
         secondInput = argv == 3 ? "" : argc[3];
     }
     bool haveSec = secondInput.length() > 0;
-	if (command == "parse" || command == "parse_serpent")
+    if (command == "parse" || command == "parse_serpent") {
         std::cout << printAST(parseSerpent(input), haveSec) << "\n";
-	else if (command == "rewrite")
+    }
+    else if (command == "rewrite") {
         std::cout << printAST(rewrite(parseLLL(input, true)), haveSec) << "\n";
-	else if (command == "compile_to_lll")
+    }
+    else if (command == "compile_to_lll") {
         std::cout << printAST(compileToLLL(input), haveSec) << "\n";
-	else if (command == "build_fragtree")
+    }
+    else if (command == "rewrite_chunk") {
+        std::cout << printAST(rewriteChunk(parseLLL(input, true)), haveSec) << "\n";
+    }
+    else if (command == "compile_chunk_to_lll") {
+        std::cout << printAST(compileChunkToLLL(input), haveSec) << "\n";
+    }
+    else if (command == "build_fragtree") {
         std::cout << printAST(buildFragmentTree(parseLLL(input, true))) << "\n";
-	else if (command == "compile_lll")
+    }
+    else if (command == "compile_lll") {
         std::cout << binToHex(compileLLL(parseLLL(input, true))) << "\n";
-	else if (command == "dereference")
+    }
+    else if (command == "dereference") {
         std::cout << printAST(dereference(parseLLL(input, true)), haveSec) <<"\n";
-	else if (command == "pretty_assemble")
+    }
+    else if (command == "pretty_assemble") {
         std::cout << printTokens(prettyAssemble(parseLLL(input, true))) <<"\n";
-	else if (command == "pretty_compile_lll")
+    }
+    else if (command == "pretty_compile_lll") {
         std::cout << printTokens(prettyCompileLLL(parseLLL(input, true))) << "\n";
-	else if (command == "pretty_compile")
+    }
+    else if (command == "pretty_compile") {
         std::cout << printTokens(prettyCompile(input)) << "\n";
-	else if (command == "assemble")
+    }
+    else if (command == "pretty_compile_chunk") {
+        std::cout << printTokens(prettyCompileChunk(input)) << "\n";
+    }
+    else if (command == "assemble") {
         std::cout << assemble(parseLLL(input, true)) << "\n";
-	else if (command == "serialize")
+    }
+    else if (command == "serialize") {
         std::cout << binToHex(serialize(tokenize(input, Metadata(), false))) << "\n";
-	else if (command == "flatten")
+    }
+    else if (command == "flatten") {
         std::cout << printTokens(flatten(parseLLL(input, true))) << "\n";
-	else if (command == "deserialize")
+    }
+    else if (command == "deserialize") {
         std::cout << printTokens(deserialize(hexToBin(input))) << "\n";
-	else if (command == "compile")
+    }
+    else if (command == "compile") {
         std::cout << binToHex(compile(input)) << "\n";
-	else if (command == "encode_datalist")
+    }
-	{
+    else if (command == "compile_chunk") {
+        std::cout << binToHex(compileChunk(input)) << "\n";
+    }
+    else if (command == "encode_datalist") {
         std::vector<Node> tokens = tokenize(input);
         std::vector<std::string> o;
-		for (int i = 0; i < (int)tokens.size(); i++)
+        for (int i = 0; i < (int)tokens.size(); i++) {
             o.push_back(tokens[i].val);
+        }
         std::cout << binToHex(encodeDatalist(o)) << "\n";
     }
-	else if (command == "decode_datalist")
+    else if (command == "decode_datalist") {
-	{
         std::vector<std::string> o = decodeDatalist(hexToBin(input));
         std::vector<Node> tokens;
         for (int i = 0; i < (int)o.size(); i++)
             tokens.push_back(token(o[i]));
         std::cout << printTokens(tokens) << "\n";
     }
-	else if (command == "tokenize")
+    else if (command == "tokenize") {
         std::cout << printTokens(tokenize(input));
-	else if (command == "biject")
+    }
-	{
+    else if (command == "biject") {
         if (argv == 3)
              std::cerr << "Not enough arguments for biject\n";
         int pos = decimalToUnsigned(secondInput);