doc_examples.sol

// Examples taken from the Solidity documentation online.

// for pragma version numbers, see https://docs.npmjs.com/misc/semver#versions
pragma solidity 0.4.0;
pragma solidity v0.4.0; // like npm
pragma solidity ^0.4.0;
pragma solidity >= 0.4.0;
pragma solidity <= 0.4.0;
pragma solidity < 0.4.0;
pragma solidity > 0.4.0;
pragma solidity != 0.4.0;
pragma solidity >=0.4.0 <0.4.8; // from https://github.com/ethereum/solidity/releases/tag/v0.4.0

import "SomeFile.sol";
import "SomeFile.sol" as SomeOtherFile;
import * as SomeSymbol from "AnotherFile.sol";
import {symbol1 as alias, symbol2} from "File.sol";

interface i {
  function f();
}

contract c {
  function c()
  {
      val1 = 1 wei;    // 1
      val2 = 1 szabo;  // 1 * 10 ** 12
      val3 = 1 finney; // 1 * 10 ** 15
      val4 = 1 ether;  // 1 * 10 ** 18
 }
  uint256 val1;
  uint256 val2;
  uint256 val3;
  uint256 val4;
}

contract test {
    enum ActionChoices { GoLeft, GoRight, GoStraight, SitStill }

    function test()
    {
        choices = ActionChoices.GoStraight;
    }
    function getChoice() returns (uint d)
    {
        d = uint256(choices);
    }
    ActionChoices choices;
}

contract Base {
    function Base(uint i)
    {
        m_i = i;
    }
    uint public m_i;
}
contract Derived is Base(0) {
    function Derived(uint i) Base(i) {}
}

contract C {
  uint248 x; // 31 bytes: slot 0, offset 0
  uint16 y; // 2 bytes: slot 1, offset 0 (does not fit in slot 0)
  uint240 z; // 30 bytes: slot 1, offset 2 bytes
  uint8 a; // 1 byte: slot 2, offset 0 bytes
  struct S {
    uint8 a; // 1 byte, slot +0, offset 0 bytes
    uint256 b; // 32 bytes, slot +1, offset 0 bytes (does not fit)
  }
  S structData; // 2 slots, slot 3, offset 0 bytes (does not really apply)
  uint8 alpha; // 1 byte, slot 4 (start new slot after struct)
  uint16[3] beta; // 3*16 bytes, slots 5+6 (start new slot for array)
  uint8 gamma; // 1 byte, slot 7 (start new slot after array)
}

contract test {
  function f(uint x, uint y) returns (uint z) {
    var c = x + 3;
    var b = 7 + (c * (8 - 7)) - x;
    return -(-b | 0);
  }
}

contract test {
  function f(uint x, uint y) returns (uint z) {
    return 10;
  }
}

contract c {
  function () returns (uint) { return g(8); }
  function g(uint pos) internal returns (uint) { setData(pos, 8); return getData(pos); }
  function setData(uint pos, uint value) internal { data[pos] = value; }
  function getData(uint pos) internal { return data[pos]; }
  mapping(uint => uint) data;
}

contract Sharer {
    function sendHalf(address addr) returns (uint balance) {
        if (!addr.send(msg.value/2))
            throw; // also reverts the transfer to Sharer
        return address(this).balance;
    }
}

/// @dev Models a modifiable and iterable set of uint values.
library IntegerSet
{
  struct data
  {
    /// Mapping item => index (or zero if not present)
    mapping(uint => uint) index;
    /// Items by index (index 0 is invalid), items with index[item] == 0 are invalid.
    uint[] items;
    /// Number of stored items.
    uint size;
  }
  function insert(data storage self, uint value) returns (bool alreadyPresent)
  {
    uint index = self.index[value];
    if (index > 0)
      return true;
    else
    {
      if (self.items.length == 0) self.items.length = 1;
      index = self.items.length++;
      self.items[index] = value;
      self.index[value] = index;
      self.size++;
      return false;
    }
  }
  function remove(data storage self, uint value) returns (bool success)
  {
    uint index = self.index[value];
    if (index == 0)
      return false;
    delete self.index[value];
    delete self.items[index];
    self.size --;
  }
  function contains(data storage self, uint value) returns (bool)
  {
    return self.index[value] > 0;
  }
  function iterate_start(data storage self) returns (uint index)
  {
    return iterate_advance(self, 0);
  }
  function iterate_valid(data storage self, uint index) returns (bool)
  {
    return index < self.items.length;
  }
  function iterate_advance(data storage self, uint index) returns (uint r_index)
  {
    index++;
    while (iterate_valid(self, index) && self.index[self.items[index]] == index)
      index++;
    return index;
  }
  function iterate_get(data storage self, uint index) returns (uint value)
  {
      return self.items[index];
  }
}

/// How to use it:
contract User
{
  /// Just a struct holding our data.
  IntegerSet.data data;
  /// Insert something
  function insert(uint v) returns (uint size)
  {
    /// Sends `data` via reference, so IntegerSet can modify it.
    IntegerSet.insert(data, v);
    /// We can access members of the struct - but we should take care not to mess with them.
    return data.size;
  }
  /// Computes the sum of all stored data.
  function sum() returns (uint s)
  {
    for (var i = IntegerSet.iterate_start(data); IntegerSet.iterate_valid(data, i); i = IntegerSet.iterate_advance(data, i))
      s += IntegerSet.iterate_get(data, i);
  }
}

// This broke it at one point (namely the modifiers).
contract DualIndex {
  mapping(uint => mapping(uint => uint)) data;
  address public admin;

  modifier restricted { if (msg.sender == admin) _; }

  function DualIndex() {
    admin = msg.sender;
  }

  function set(uint key1, uint key2, uint value) restricted {
    uint[2][4] memory defaults; // "memory" broke things at one time.
    data[key1][key2] = value;
  }

  function transfer_ownership(address _admin) restricted {
    admin = _admin;
  }

  function lookup(uint key1, uint key2) returns(uint) {
    return data[key1][key2];
  }
}

contract A {

}

contract B {

}

contract C is A, B {

}

contract TestPrivate
{
  uint private value;
}

contract TestInternal
{
  uint internal value;
}

contract FromSolparse is A, B, TestPrivate, TestInternal {
  function() {
    uint a = 6 ** 9;
    var (x) = 100;
    uint y = 2 days;
  }
}

contract CommentedOutFunction {
  // FYI: This empty function, as well as the commented
  // out function below (bad code) is important to this test.
  function() {

  }

  // function something()
  //  uint x = 10;
  // }
}

library VarHasBrackets {
	string constant specialRight = "}";
	//string storage specialLeft = "{";
}

library UsingExampleLibrary {
  function sum(uint[] storage self) returns (uint s) {
    for (uint i = 0; i < self.length; i++)
      s += self[i];
  }
}

contract UsingExampleContract {
  using UsingExampleLibrary for uint[];
}

contract NewStuff {
  uint[] b;

  function someFunction() payable {
    string storage a = hex"ab1248fe";
    b[2+2];
  }
}

// modifier with expression
contract MyContract {
  function fun() mymodifier(foo.bar()) {}
}

library GetCode {
    function at(address _addr) returns (bytes o_code) {
        assembly {
            // retrieve the size of the code, this needs assembly
            let size := extcodesize(_addr)
            // allocate output byte array - this could also be done without assembly
            // by using o_code = new bytes(size)
            o_code := mload(0x40)
            // new "memory end" including padding
            mstore(0x40, add(o_code, and(add(add(size, 0x20), 0x1f), not(0x1f))))
            // store length in memory
            mstore(o_code, size)
            // actually retrieve the code, this needs assembly
            extcodecopy(_addr, add(o_code, 0x20), 0, size)
        }
    }
}

contract assemblyLocalBinding {
  function test(){
    assembly {
      let v := 1
      let x := 0x00
      let y := x
      let z := "hello" 
    }
  }
}

contract assemblyReturn {
  uint a = 10;

  function get() constant returns(uint) {
    assembly {
        mstore(0x40, sload(0))
        byte(0)
        address(0)
        return(0x40,32)
    }
  }
}

contract usesConst {
  uint const = 0;
}

contract memoryArrays {
  uint seven = 7;

  function returnNumber(uint number) returns (uint){
    return number;
  }

  function alloc() {
    uint[] memory a = new uint[](7);
    uint[] memory b = new uint[](returnNumber(seven));
  }
}

contract DeclarativeExpressions {
  uint a;
  uint b = 7;
  uint b2=0;
  uint public c;
  uint constant public d;
  uint public constant e;
  uint private constant f = 7;
  struct S { uint q;}

  function ham(S storage s1, uint[] storage arr) internal {
    uint x;
    uint y = 7;
    S storage s2 = s1;
    uint[] memory stor;
    uint[] storage stor2 = arr;
  }
}

contract VariableDeclarationTuple {
  function getMyTuple() returns (bool, bool){
    return (true, false);
  }
  
  function ham (){
    var (x, y) = (10, 20);
    var (a, b) = getMyTuple();
    var (,c) = (10, 20);
    var (d,,) = (10, 20, 30);
    var (,e,,f,) = (10, 20, 30, 40, 50);

    var (
      num1, num2,
      num3, ,num5
    ) = (10, 20, 30, 40, 50);
  }
}

contract TypeIndexSpacing {
  uint [ 7 ] x;
  uint  []  y;
}

contract Ballot {

    struct Voter {
        uint weight;
        bool voted;
    }

    function abstain() returns (bool) {
      return false;
    }

    function foobar() payable owner (myPrice) returns (uint[], address myAdd, string[] names) {}
    function foobar() payable owner (myPrice) returns (uint[], address myAdd, string[] names);

    Voter you = Voter(1, true);

    Voter me = Voter({
        weight: 2,
        voted: abstain()
    });

    Voter airbnb = Voter({
      weight: 2,
      voted: true,
    });
}

contract multilineReturn {
  function a() returns (uint x) {
    return
      5;
  }
}