Merge pull request #953 from Denton-L/fallback-stuff

Write about what fallback functions cannot do

docs/contracts.rst

@@ -211,18 +211,18 @@ storage and is not able to call ``f``. Contract ``E`` is derived from ``C`` and
 
     contract D {
         function readData() {
-    	    C c = new C();
+            C c = new C();
-    	    local = c.f(7); // error: member "f" is not visible
+            local = c.f(7); // error: member "f" is not visible
-	        c.setData(3);
+            c.setData(3);
-	        uint local = c.getData();
+            uint local = c.getData();
-	        local = c.compute(3,5); // error: member "compute" is not visible
+            local = c.compute(3,5); // error: member "compute" is not visible
-	    }
+        }
     }
 
     contract E is C {
         function g() {
-    	    C c = new C();
+            C c = new C();
-    	    uint val = compute(3,5);  // acces to internal member (from derivated to parent contract)
+            uint val = compute(3,5);  // acces to internal member (from derivated to parent contract)
         }
     }
 
@@ -244,12 +244,12 @@ be done at declaration.
     contract C {
         uint public data = 42;
     }
-    
+
     contract Caller {
-    	C c = new C();
+        C c = new C();
-    	function f() {
+        function f() {
-    	    uint local = c.data();
+            uint local = c.data();
-    	}
+        }
     }
 
 The accessor functions have external visibility. If the
@@ -260,11 +260,11 @@ it is evaluated as state variable and if it is accessed externally
 ::
 
     contract C {
-    	uint public data;
+        uint public data;
-    	function x() {
+        function x() {
-    	    data = 3; // internal access
+            data = 3; // internal access
-    	    uint val = this.data(); // external access
+            uint val = this.data(); // external access
-    	}
+        }
     }
 
 The next example is a bit more complex:
@@ -435,6 +435,15 @@ Ether (without data).  In such a context, there is very little gas available to
 the function call (to be precise, 2300 gas), so it is important to make fallback functions as cheap as
 possible.
 
+In particular, the following operations will consume more gas than the stipend provided to a fallback function:
+
+- Writing to storage
+- Creating a contract
+- Calling an external function which consumes a large amount of gas
+- Sending Ether
+
+Please ensure you test your fallback function thoroughly to ensure the execution cost is less than 2300 gas before deploying a contract.
+
 ::
 
     contract Test {