Changed ERC20 .sol files' syntax and formatting

erc20faucet/contracts/ERC20/ERC20.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.4.24;
+pragma solidity ^0.4.25;
 
 import "./IERC20.sol";
 import "../math/SafeMath.sol";
@@ -11,201 +11,172 @@ import "../math/SafeMath.sol";
  * Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
  */
 contract ERC20 is IERC20 {
-  using SafeMath for uint256;
 
-  mapping (address => uint256) private _balances;
+   using SafeMath for uint256;
 
-  mapping (address => mapping (address => uint256)) private _allowed;
+   uint256 private _totalSupply;
 
-  uint256 private _totalSupply;
+   mapping (address => uint256) private balances;
+   mapping (address => mapping (address => uint256)) private allowed;
 
-  /**
-  * @dev Total number of tokens in existence
-  */
-  function totalSupply() public view returns (uint256) {
-    return _totalSupply;
-  }
-
-  /**
-  * @dev Gets the balance of the specified address.
-  * @param owner The address to query the balance of.
-  * @return An uint256 representing the amount owned by the passed address.
-  */
-  function balanceOf(address owner) public view returns (uint256) {
-    return _balances[owner];
-  }
-
-  /**
-   * @dev Function to check the amount of tokens that an owner allowed to a spender.
-   * @param owner address The address which owns the funds.
-   * @param spender address The address which will spend the funds.
-   * @return A uint256 specifying the amount of tokens still available for the spender.
-   */
-  function allowance(
-    address owner,
-    address spender
-   )
-    public
-    view
-    returns (uint256)
-  {
-    return _allowed[owner][spender];
-  }
-
-  /**
-  * @dev Transfer token for a specified address
-  * @param to The address to transfer to.
-  * @param value The amount to be transferred.
-  */
-  function transfer(address to, uint256 value) public returns (bool) {
-    _transfer(msg.sender, to, value);
-    return true;
-  }
-
-  /**
-   * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
-   * Beware that changing an allowance with this method brings the risk that someone may use both the old
-   * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
-   * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
-   * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
-   * @param spender The address which will spend the funds.
-   * @param value The amount of tokens to be spent.
-   */
-  function approve(address spender, uint256 value) public returns (bool) {
-    require(spender != address(0));
-
-    _allowed[msg.sender][spender] = value;
-    emit Approval(msg.sender, spender, value);
-    return true;
-  }
-
-  /**
-   * @dev Transfer tokens from one address to another
-   * @param from address The address which you want to send tokens from
-   * @param to address The address which you want to transfer to
-   * @param value uint256 the amount of tokens to be transferred
+   /**
+    * @dev Total number of tokens in existence
    */
-  function transferFrom(
-    address from,
-    address to,
-    uint256 value
-  )
-    public
-    returns (bool)
-  {
-    require(value <= _allowed[from][msg.sender]);
-
-    _allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
-    _transfer(from, to, value);
-    return true;
-  }
-
-  /**
-   * @dev Increase the amount of tokens that an owner allowed to a spender.
-   * approve should be called when allowed_[_spender] == 0. To increment
-   * allowed value is better to use this function to avoid 2 calls (and wait until
-   * the first transaction is mined)
-   * From MonolithDAO Token.sol
-   * @param spender The address which will spend the funds.
-   * @param addedValue The amount of tokens to increase the allowance by.
+   function totalSupply() public view returns (uint256) {
+      return _totalSupply;
+   }
+
+   /**
+    * @dev Gets the balance of the specified address.
+    * @param _owner The address to query the balance of.
+    * @return An uint256 representing the amount owned by the passed address.
    */
-  function increaseAllowance(
-    address spender,
-    uint256 addedValue
-  )
-    public
-    returns (bool)
-  {
-    require(spender != address(0));
-
-    _allowed[msg.sender][spender] = (
-      _allowed[msg.sender][spender].add(addedValue));
-    emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
-    return true;
-  }
+   function balanceOf(address _owner) public view returns (uint256) {
+      return balances[_owner];
+   }
+
+   /**
+    * @dev Function to check the amount of tokens that an owner allowed to a spender.
+    * @param _owner address The address which owns the funds.
+    * @param _spender address The address which will spend the funds.
+    * @return A uint256 specifying the amount of tokens still available for the spender.
+    */
+   function allowance(address _owner, address _spender) public view returns (uint256) {
+      return allowed[_owner][_spender];
+   }
+
+   /**
+    * @dev Transfer token for a specified address
+    * @param _to The address to transfer to.
+    * @param _value The amount to be transferred.
+    */
+   function transfer(address _to, uint256 _value) public returns (bool) {
+      require(_value <= balances[msg.sender]);
+      require(_to != address(0));
+
+      balances[msg.sender] = balances[msg.sender].sub(_value);
+      balances[_to] = balances[_to].add(_value);
+      emit Transfer(msg.sender, _to, _value);
+      return true;
+   }
+
+   /**
+    * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
+    * Beware that changing an allowance with this method brings the risk that someone may use both the old
+    * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
+    * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
+    * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
+    * @param _spender The address which will spend the funds.
+    * @param _value The amount of tokens to be spent.
+    */
+   function approve(address _spender, uint256 _value) public returns (bool) {
+      require(_spender != address(0));
+
+      allowed[msg.sender][_spender] = _value;
+      emit Approval(msg.sender, _spender, _value);
+      return true;
+   }
+
+   /**
+    * @dev Transfer tokens from one address to another
+    * @param _from address The address which you want to send tokens from
+    * @param _to address The address which you want to transfer to
+    * @param _value uint256 the amount of tokens to be transferred
+    */
+   function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
+      require(_value <= balances[_from]);
+      require(_value <= allowed[_from][msg.sender]);
+      require(_to != address(0));
+
+      balances[_from] = balances[_from].sub(_value);
+      balances[_to] = balances[_to].add(_value);
+      allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+      emit Transfer(_from, _to, _value);
+      return true;
+   }
+
+   /**
+    * @dev Increase the amount of tokens that an owner allowed to a spender.
+    * approve should be called when allowed_[_spender] == 0. To increment
+    * allowed value is better to use this function to avoid 2 calls (and wait until
+    * the first transaction is mined)
+    * From MonolithDAO Token.sol
+    * @param _spender The address which will spend the funds.
+    * @param _addedValue The amount of tokens to increase the allowance by.
+    */
+   function increaseAllowance(address _spender, uint256 _addedValue) public returns (bool) {
+      require(_spender != address(0));
+
+      allowed[msg.sender][_spender] = (
+      allowed[msg.sender][_spender].add(_addedValue));
+      emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+      return true;
+   }
 
   /**
    * @dev Decrease the amount of tokens that an owner allowed to a spender.
    * approve should be called when allowed_[_spender] == 0. To decrement
    * allowed value is better to use this function to avoid 2 calls (and wait until
    * the first transaction is mined)
    * From MonolithDAO Token.sol
-   * @param spender The address which will spend the funds.
-   * @param subtractedValue The amount of tokens to decrease the allowance by.
-   */
-  function decreaseAllowance(
-    address spender,
-    uint256 subtractedValue
-  )
-    public
-    returns (bool)
-  {
-    require(spender != address(0));
-
-    _allowed[msg.sender][spender] = (
-      _allowed[msg.sender][spender].sub(subtractedValue));
-    emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
-    return true;
-  }
-
-  /**
-  * @dev Transfer token for a specified addresses
-  * @param from The address to transfer from.
-  * @param to The address to transfer to.
-  * @param value The amount to be transferred.
-  */
-  function _transfer(address from, address to, uint256 value) internal {
-    require(value <= _balances[from]);
-    require(to != address(0));
-
-    _balances[from] = _balances[from].sub(value);
-    _balances[to] = _balances[to].add(value);
-    emit Transfer(from, to, value);
-  }
-
-  /**
-   * @dev Internal function that mints an amount of the token and assigns it to
-   * an account. This encapsulates the modification of balances such that the
-   * proper events are emitted.
-   * @param account The account that will receive the created tokens.
-   * @param value The amount that will be created.
+   * @param _spender The address which will spend the funds.
+   * @param _subtractedValue The amount of tokens to decrease the allowance by.
    */
-  function _mint(address account, uint256 value) internal {
-    require(account != 0);
-    _totalSupply = _totalSupply.add(value);
-    _balances[account] = _balances[account].add(value);
-    emit Transfer(address(0), account, value);
-  }
-
-  /**
-   * @dev Internal function that burns an amount of the token of a given
-   * account.
-   * @param account The account whose tokens will be burnt.
-   * @param value The amount that will be burnt.
-   */
-  function _burn(address account, uint256 value) internal {
-    require(account != 0);
-    require(value <= _balances[account]);
-
-    _totalSupply = _totalSupply.sub(value);
-    _balances[account] = _balances[account].sub(value);
-    emit Transfer(account, address(0), value);
-  }
-
-  /**
-   * @dev Internal function that burns an amount of the token of a given
-   * account, deducting from the sender's allowance for said account. Uses the
-   * internal burn function.
-   * @param account The account whose tokens will be burnt.
-   * @param value The amount that will be burnt.
-   */
-  function _burnFrom(address account, uint256 value) internal {
-    require(value <= _allowed[account][msg.sender]);
-
-    // Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
-    // this function needs to emit an event with the updated approval.
-    _allowed[account][msg.sender] = _allowed[account][msg.sender].sub(
-      value);
-    _burn(account, value);
-  }
+   function decreaseAllowance(address _spender, uint256 _subtractedValue) public returns (bool) {
+      require(_spender != address(0));
+
+      allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].sub(_subtractedValue));
+      emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+      return true;
+   }
+
+   /**
+    * @dev Internal function that mints an amount of the token and assigns it to
+    * an account. This encapsulates the modification of balances such that the
+    * proper events are emitted.
+    * @param _account The account that will receive the created tokens.
+    * @param _amount The amount that will be created.
+    */
+   function _mint(address _account, uint256 _amount) internal {
+      require(_account != 0);
+      require(_totalSupply.add(_amount) <= maxSupply);
+      _totalSupply = _totalSupply.add(_amount);
+      balances[_account] = balances[_account].add(_amount);
+      emit Transfer(address(0), _account, _amount);
+   }
+
+   /**
+    * @dev Internal function that burns an amount of the token of a given
+    * account.
+    * @param _account The account whose tokens will be burnt.
+    * @param _amount The amount that will be burnt.
+    */
+   function _burn(address _account, uint256 _amount) internal {
+      require(_account != 0);
+      require(_amount <= balances[_account]);
+
+      _totalSupply = _totalSupply.sub(_amount);
+      balances[_account] = balances[_account].sub(_amount);
+      emit Transfer(_account, address(0), _amount);
+   }
+
+   /**
+    * @dev Internal function that burns an amount of the token of a given
+    * account, deducting from the sender's allowance for said account. Uses the
+    * internal burn function.
+    * @param _account The account whose tokens will be burnt.
+    * @param _amount The amount that will be burnt.
+    */
+   function _burnFrom(address _account, uint256 _amount) internal {
+      require(_amount <= allowed[_account][msg.sender]);
+
+      // Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
+      // this function needs to emit an event with the updated approval.
+      allowed[_account][msg.sender] = allowed[_account][msg.sender].sub(_amount);
+      _burn(_account, _amount);
+   }
+
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
 }
+

erc20faucet/contracts/ERC20/ERC20Burnable.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.4.24;
+pragma solidity ^0.4.25;
 
 import "./ERC20.sol";
 

erc20faucet/contracts/ERC20/ERC20Capped.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.4.24;
+pragma solidity ^0.4.25;
 
 import "./ERC20Mintable.sol";
 

erc20faucet/contracts/ERC20/ERC20Detailed.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.4.24;
+pragma solidity ^0.4.25;
 
 import "./IERC20.sol";