cerc-io/solidity
16
0
Fork 0
mirror of https://github.com/ethereum/solidity synced 2023-10-03 13:03:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #1167 from ethereum/when_solidity_throws

Browse Source 
Adding "When Solidity Throws" section in the documentation
This commit is contained in:
Yoichi Hirai 2016-10-13 15:13:17 +02:00 committed by GitHub
commit 2951c1eba9
1 changed files with 9 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
docs/control-structures.rst
View File

@ -322,14 +322,16 @@ In the following example, we show how ``throw`` can be used to easily revert an
} }
} }
Currently, there are six situations, where exceptions happen automatically in Solidity: Currently, there are situations, where exceptions happen automatically in Solidity:
1. If you access an array beyond its length (i.e. ``x[i]`` where ``i >= x.length``). 1. If you access an array at a too large or negative index (i.e. ``x[i]`` where ``i >= x.length`` or ``i < 0``).
2. If a function called via a message call does not finish properly (i.e. it runs out of gas or throws an exception itself). 2. If you access a fixed-length ``bytesN`` at a too large or negative index.
3. If a non-existent function on a library is called or Ether is sent to a library. 3. If you call a function via a message call but it does not finish properly (i.e. it runs out of gas, has no matching function, or throws an exception itself), except when a low level operation ``call``, ``send``, ``delegatecall`` or ``callcode`` is used. The low level operations never throw exceptions but indicate failures by returning ``false``.
4. If you divide or modulo by zero (e.g. ``5 / 0`` or ``23 % 0``). 4. If you create a contract using the ``new`` keyword but the contract creation does not finish properly (see above for the definition of "not finish properly").
5. If you perform an external function call targeting a contract that contains no code. 5. If you divide or modulo by zero (e.g. ``5 / 0`` or ``23 % 0``).
6. If a contract-creation call using the ``new`` keyword fails. 6. If you perform an external function call targeting a contract that contains no code.
7. If your contract receives Ether via a public function without ``payable`` modifier (including the constructor and the fallback function).
8. If your contract receives Ether via a public accessor function.
Internally, Solidity performs an "invalid jump" when an exception is thrown and thus causes the EVM to revert all changes made to the state. The reason for this is that there is no safe way to continue execution, because an expected effect did not occur. Because we want to retain the atomicity of transactions, the safest thing to do is to revert all changes and make the whole transaction (or at least call) without effect. Internally, Solidity performs an "invalid jump" when an exception is thrown and thus causes the EVM to revert all changes made to the state. The reason for this is that there is no safe way to continue execution, because an expected effect did not occur. Because we want to retain the atomicity of transactions, the safest thing to do is to revert all changes and make the whole transaction (or at least call) without effect.