Modified units-and-global-variables.rst

Corrected syntax for inline code

docs/units-and-global-variables.rst

@@ -7,23 +7,23 @@ Units and Globally Available Variables
 Ether Units
 ===========
 
-A literal number can take a suffix of `wei`, `finney`, `szabo` or `ether` to convert between the subdenominations of Ether, where Ether currency numbers without a postfix are assumed to be "wei", e.g. `2 ether == 2000 finney` evaluates to `true`.
+A literal number can take a suffix of :code:`wei`, :code:`finney`, :code:`szabo` or :code:`ether` to convert between the subdenominations of Ether, where Ether currency numbers without a postfix are assumed to be "wei", e.g. :code:`2 ether == 2000 finney` evaluates to :code:`true`.
 
 .. index:: time, seconds, minutes, hours, days, weeks, years
 
 Time Units
 ==========
 
-Suffixes of `seconds`, `minutes`, `hours`, `days`, `weeks` and
+Suffixes of :code:`seconds`, :code:`minutes`, :code:`hours`, :code:`days`, :code:`weeks` and
 `years` after literal numbers can be used to convert between units of time where seconds are the base
 unit and units are considered naively in the following way:
 
- * `1 == 1 second`
- * `1 minutes == 60 seconds`
- * `1 hours == 60 minutes`
- * `1 days == 24 hours`
- * `1 weeks = 7 days`
- * `1 years = 365 days`
+ * :code:`1 == 1 second`
+ * :code:`1 minutes == 60 seconds`
+ * :code:`1 hours == 60 minutes`
+ * :code:`1 days == 24 hours`
+ * :code:`1 weeks = 7 days`
+ * :code:`1 years = 365 days`
 
 Take care if you perform calendar calculations using these units, because
 not every year equals 365 days and not even every day has 24 hours
@@ -50,29 +50,29 @@ namespace and are mainly used to provide information about the blockchain.
 Block and Transaction Properties
 ------------------------------------
 
- - `block.coinbase` (`address`): current block miner's address
- - `block.difficulty` (`uint`): current block difficulty
- - `block.gaslimit` (`uint`): current block gaslimit
- - `block.number` (`uint`): current block number
- - `block.blockhash` (`function(uint) returns (bytes32)`): hash of the given block - only for 256 most recent blocks
- - `block.timestamp` (`uint`): current block timestamp
- - `msg.data` (`bytes`): complete calldata
- - `msg.gas` (`uint`): remaining gas
- - `msg.sender` (`address`): sender of the message (current call)
- - `msg.sig` (`bytes4`): first four bytes of the calldata (i.e. function identifier)
- - `msg.value` (`uint`): number of wei sent with the message
- - `now` (`uint`): current block timestamp (alias for `block.timestamp`)
- - `tx.gasprice` (`uint`): gas price of the transaction
- - `tx.origin` (`address`): sender of the transaction (full call chain)
+ - :code:`block.coinbase` (:code:`address`): current block miner's address
+ - :code:`block.difficulty` (:code:`uint`): current block difficulty
+ - :code:`block.gaslimit` (:code:`uint`): current block gaslimit
+ - :code:`block.number` (:code:`uint`): current block number
+ - :code:`block.blockhash` (:code:`function(uint) returns (bytes32)`): hash of the given block - only for 256 most recent blocks
+ - :code:`block.timestamp` (:code:`uint`): current block timestamp
+ - :code:`msg.data` (:code:`bytes`): complete calldata
+ - :code:`msg.gas` (:code:`uint`): remaining gas
+ - :code:`msg.sender` (:code:`address`): sender of the message (current call)
+ - :code:`msg.sig` (:code:`bytes4`): first four bytes of the calldata (i.e. function identifier)
+ - :code:`msg.value` (:code:`uint`): number of wei sent with the message
+ - :code:`now` (:code:`uint`): current block timestamp (alias for :code:`block.timestamp`)
+ - :code:`tx.gasprice` (:code:`uint`): gas price of the transaction
+ - :code:`tx.origin` (:code:`address`): sender of the transaction (full call chain)
 
 .. note::
-    The values of all members of `msg`, including `msg.sender` and
-    `msg.value` can change for every **external** function call.
+    The values of all members of :code:`msg`, including :code:`msg.sender` and
+    :code:`msg.value` can change for every **external** function call.
     This includes calls to library functions.
 
     If you want to implement access restrictions in library functions using
-    `msg.sender`, you have to manually supply the value of
-    `msg.sender` as an argument.
+    :code:`msg.sender`, you have to manually supply the value of
+    :code:`msg.sender` as an argument.
 
 .. note::
     The block hashes are not available for all blocks for scalability reasons.
@@ -84,17 +84,17 @@ Block and Transaction Properties
 Mathematical and Cryptographic Functions
 ----------------------------------------
 
-`addmod(uint x, uint y, uint k) returns (uint)`:
-    compute `(x + y) % k` where the addition is performed with arbitrary precision and does not wrap around at `2**256`.
-`mulmod(uint x, uint y, uint k) returns (uint)`:
-    compute `(x * y) % k` where the multiplication is performed with arbitrary precision and does not wrap around at `2**256`.
-`sha3(...) returns (bytes32)`:
+:code:`addmod(uint x, uint y, uint k) returns (uint)`:
+    compute :code:`(x + y) % k` where the addition is performed with arbitrary precision and does not wrap around at :code:`2**256`.
+:code:`mulmod(uint x, uint y, uint k) returns (uint)`:
+    compute :code:`(x * y) % k` where the multiplication is performed with arbitrary precision and does not wrap around at :code:`2**256`.
+:code:`sha3(...) returns (bytes32)`:
     compute the Ethereum-SHA-3 hash of the (tightly packed) arguments
-`sha256(...) returns (bytes32)`:
+:code:`sha256(...) returns (bytes32)`:
     compute the SHA-256 hash of the (tightly packed) arguments
-`ripemd160(...) returns (bytes20)`:
+:code:`ripemd160(...) returns (bytes20)`:
     compute RIPEMD-160 hash of the (tightly packed) arguments
-`ecrecover(bytes32 data, uint8 v, bytes32 r, bytes32 s) returns (address)`:
+:code:`ecrecover(bytes32 data, uint8 v, bytes32 r, bytes32 s) returns (address)`:
     recover the address associated with the public key from elliptic curve signature
 
 In the above, "tightly packed" means that the arguments are concatenated without padding.
@@ -106,20 +106,20 @@ This means that the following are all identical::
     sha3(6382179)
     sha3(97, 98, 99)
 
-If padding is needed, explicit type conversions can be used: `sha3("\x00\x12")` is the
-same as `sha3(uint16(0x12))`.
+If padding is needed, explicit type conversions can be used: :code:`sha3("\x00\x12")` is the
+same as :code:`sha3(uint16(0x12))`.
 
-It might be that you run into Out-of-Gas for `sha256`, `ripemd160` or `ecrecover` on a *private blockchain*. The reason for this is that those are implemented as so-called precompiled contracts and these contracts only really exist after they received the first message (although their contract code is hardcoded). Messages to non-existing contracts are more expensive and thus the execution runs into an Out-of-Gas error. A workaround for this problem is to first send e.g. 1 Wei to each of the contracts before you use them in your actual contracts. This is not an issue on the official or test net.
+It might be that you run into Out-of-Gas for :code:`sha256`, :code:`ripemd160` or :code:`ecrecover` on a *private blockchain*. The reason for this is that those are implemented as so-called precompiled contracts and these contracts only really exist after they received the first message (although their contract code is hardcoded). Messages to non-existing contracts are more expensive and thus the execution runs into an Out-of-Gas error. A workaround for this problem is to first send e.g. 1 Wei to each of the contracts before you use them in your actual contracts. This is not an issue on the official or test net.
 
 .. index:: this, selfdestruct
 
 Contract Related
 ----------------
 
-`this` (current contract's type):
+:code:`this` (current contract's type):
     the current contract, explicitly convertible to :ref:`address`
 
-`selfdestruct(address)`:
+:code:`selfdestruct(address)`:
     destroy the current contract, sending its funds to the given :ref:`address`
 
 Furthermore, all functions of the current contract are callable directly including the current function.