Merge pull request #3295 from mcdee/develop

Remove warnings in examples

1 files changed, 9 insertions, 9 deletions

diff --git a/docs/assembly.rst b/docs/assembly.rst
index a4fa88c6..825892b3 100644
--- a/docs/assembly.rst
+++ b/docs/assembly.rst
@@ -23,7 +23,7 @@ arising when writing manual assembly by the following features:
 
 * functional-style opcodes: ``mul(1, add(2, 3))`` instead of ``push1 3 push1 2 add push1 1 mul``
 * assembly-local variables: ``let x := add(2, 3)  let y := mload(0x40)  x := add(x, y)``
-* access to external variables: ``function f(uint x) { assembly { x := sub(x, 1) } }``
+* access to external variables: ``function f(uint x) public { assembly { x := sub(x, 1) } }``
 * labels: ``let x := 10  repeat: x := sub(x, 1) jumpi(repeat, eq(x, 0))``
 * loops: ``for { let i := 0 } lt(i, x) { i := add(i, 1) } { y := mul(2, y) }``
 * if statements: ``if slt(x, 0) { x := sub(0, x) }``
@@ -54,7 +54,7 @@ idea is that assembly libraries will be used to enhance the language in such way
     pragma solidity ^0.4.0;
 
     library GetCode {
-        function at(address _addr) returns (bytes o_code) {
+        function at(address _addr) public returns (bytes o_code) {
             assembly {
                 // retrieve the size of the code, this needs assembly
                 let size := extcodesize(_addr)
@@ -83,7 +83,7 @@ you really know what you are doing.
     library VectorSum {
         // This function is less efficient because the optimizer currently fails to
         // remove the bounds checks in array access.
-        function sumSolidity(uint[] _data) returns (uint o_sum) {
+        function sumSolidity(uint[] _data) public returns (uint o_sum) {
             for (uint i = 0; i < _data.length; ++i)
                 o_sum += _data[i];
         }
@@ -91,7 +91,7 @@ you really know what you are doing.
         // We know that we only access the array in bounds, so we can avoid the check.
         // 0x20 needs to be added to an array because the first slot contains the
         // array length.
-        function sumAsm(uint[] _data) returns (uint o_sum) {
+        function sumAsm(uint[] _data) public returns (uint o_sum) {
             for (uint i = 0; i < _data.length; ++i) {
                 assembly {
                     o_sum := add(o_sum, mload(add(add(_data, 0x20), mul(i, 0x20))))
@@ -100,7 +100,7 @@ you really know what you are doing.
         }
 
         // Same as above, but accomplish the entire code within inline assembly.
-        function sumPureAsm(uint[] _data) returns (uint o_sum) {
+        function sumPureAsm(uint[] _data) public returns (uint o_sum) {
             assembly {
                // Load the length (first 32 bytes)
                let len := mload(_data)
@@ -388,7 +388,7 @@ changes during the call, and thus references to local variables will be wrong.
 
     contract C {
         uint b;
-        function f(uint x) returns (uint r) {
+        function f(uint x) public returns (uint r) {
             assembly {
                 r := mul(x, sload(b_slot)) // ignore the offset, we know it is zero
             }
@@ -462,7 +462,7 @@ be just ``0``, but it can also be a complex functional-style expression.
     pragma solidity ^0.4.0;
 
     contract C {
-        function f(uint x) returns (uint b) {
+        function f(uint x) public returns (uint b) {
             assembly {
                 let v := add(x, 1)
                 mstore(0x80, v)
@@ -574,7 +574,7 @@ Simply leave the initialization and post-iteration parts empty.
             x := add(x, mload(i))
             i := add(i, 0x20)
         }
-    } 
+    }
 
 Functions
 ---------
@@ -713,7 +713,7 @@ We consider the runtime bytecode of the following Solidity program::
     pragma solidity ^0.4.0;
 
     contract C {
-      function f(uint x) returns (uint y) {
+      function f(uint x) public returns (uint y) {
         y = 1;
         for (uint i = 0; i < x; i++)
           y = 2 * y;