ABI en/decoding for strings

src/Language/Yul.hs

@@ -98,7 +98,7 @@ hlist, vlist, nvlist, pprBlock :: Pretty a => [a] -> Doc
 hlist = hsep . map ppr
 vlist = vcat . map ppr
 nvlist = nest 2 . vlist
-pprBlock stmts = lbrace $$ nvlist stmts $$ rbrace
+pprBlock stmts = braces(nvlist stmts)
 
 
 instance Pretty YulObject where
@@ -142,9 +142,8 @@ instance Pretty YulStmt where
       $$ maybe empty (\stmts -> text "default" <+> pprBlock stmts) def
     where pprCase (lit, stmts) = text "case" <+> ppr lit <+> pprBlock stmts
   ppr (YFor pre cond post stmts) =
-    text "for" <+> braces (hlist pre)
-               <+> ppr cond
-               <+> hlist post <+> pprBlock stmts
+    text "for" <+> braces (hlist pre) <+> ppr cond <+> braces (hlist post)
+               $$ pprBlock stmts
   ppr YBreak = text "break"
   ppr YContinue = text "continue"
   ppr YLeave = text "leave"

src/Language/Yul/Parser.hs

@@ -71,6 +71,7 @@ yulStmt = sc *> choice
     , yulFun
     , YLet <$> (pKeyword "let" *> commaSep pName) <*> optional (symbol ":=" *> yulExp)
     , YIf <$> (pKeyword "if" *> yulExp) <*> yulBlock
+    , YFor <$> (pKeyword "for" *> yulBlock) <*> yulExp <*> yulBlock <*> yulBlock
     , YSwitch <$>
         (pKeyword "switch" *> yulExp) <*>
         many yulCase <*>

src/Solcore/Primitives/Primitives.hs

@@ -214,7 +214,7 @@ yulPrimOps = [ (Name "stop", monotype unit)
              , (Name "callvalue", monotype word)
              , (Name "calldataload", monotype (word :-> word))
              , (Name "calldatasize", monotype word)
-             , (Name "calldatacopy", monotype (word :-> word :-> word :-> word))
+             , (Name "calldatacopy", monotype (word :-> word :-> word :-> unit))
              , (Name "codesize", monotype word)
              , (Name "codecopy", monotype (word :-> word :-> word :-> unit))
              , (Name "datasize", monotype (string :-> word))

std/dispatch.solc

@@ -38,6 +38,17 @@ instance ():ABIString {
     }
 }
 
+instance memory(string):ABIString {
+    function append(head : word, tail : word, prx : Proxy(memory(string))) -> word {
+        let size : word = 6;
+        assembly {
+            mstore(head, add(mload(head), size))
+            mstore(tail, 0x737472696e670000000000000000000000000000000000000000000000000000)
+        }
+        return Add.add(tail, size);
+    }
+}
+
 function append_left_bracket(head : word, tail : word) -> word {
     let size = 1;
     assembly {
@@ -183,12 +194,15 @@ forall payability args rets fn
     // abi encode rets to memory
     let ptr = abi_encode(rets);
 
-    // TODO: this is broken for dynamically sized types...
-    let retSz : word = ABIAttribs.headSize(prets);
+    // let retSz : word = ABIAttribs.headSize(prets);
+    // the approach above does not work for dynamically sized types...
+    // ...instead we take the size of memory allocated by the encoding
     let start : word = Typedef.rep(ptr);
-
+    let encStart : word = Typedef.rep(ptr); // cannot be called start - see #252
+    let end : word = get_free_memory();
+    let retSz : word = Sub.sub(end, encStart);
     assembly {
-        return(start,retSz)
+        return(encStart, retSz)
     }
 }