diff --git a/autotests/folding/test.sol.fold b/autotests/folding/test.sol.fold
new file mode 100644
--- /dev/null
+++ b/autotests/folding/test.sol.fold
@@ -0,0 +1,153 @@
+// Solidity Sample File
+// https://solidity.readthedocs.io/en/latest/solidity-by-example.html#voting
+
+pragma solidity >=0.4.22 <0.7.0;
+
+/// @title Voting with delegation.
+contract Ballot {
+ // This declares a new complex type which will
+ // be used for variables later.
+ // It will represent a single voter.
+ struct Voter {
+ uint weight; // weight is accumulated by delegation
+ bool voted; // if true, that person already voted
+ address delegate; // person delegated to
+ uint vote; // index of the voted proposal
+ }
+
+ // This is a type for a single proposal.
+ struct Proposal {
+ bytes32 name; // short name (up to 32 bytes)
+ uint voteCount; // number of accumulated votes
+ }
+
+ address public chairperson;
+
+ // This declares a state variable that
+ // stores a `Voter` struct for each possible address.
+ mapping(address => Voter) public voters;
+
+ // A dynamically-sized array of `Proposal` structs.
+ Proposal[] public proposals;
+
+ /// Create a new ballot to choose one of `proposalNames`.
+ constructor(bytes32[] memory proposalNames) public {
+ chairperson = msg.sender;
+ voters[chairperson].weight = 1;
+
+ // For each of the provided proposal names,
+ // create a new proposal object and add it
+ // to the end of the array.
+ for (uint i = 0; i < proposalNames.length; i++) {
+ // `Proposal({...})` creates a temporary
+ // Proposal object and `proposals.push(...)`
+ // appends it to the end of `proposals`.
+ proposals.push(Proposal({
+ name: proposalNames[i],
+ voteCount: 0
+ }));
+ }
+ }
+
+ // Give `voter` the right to vote on this ballot.
+ // May only be called by `chairperson`.
+ function giveRightToVote(address voter) public {
+ // If the first argument of `require` evaluates
+ // to `false`, execution terminates and all
+ // changes to the state and to Ether balances
+ // are reverted.
+ // This used to consume all gas in old EVM versions, but
+ // not anymore.
+ // It is often a good idea to use `require` to check if
+ // functions are called correctly.
+ // As a second argument, you can also provide an
+ // explanation about what went wrong.
+ require(
+ msg.sender == chairperson,
+ "Only chairperson can give right to vote."
+ );
+ require(
+ !voters[voter].voted,
+ "The voter already voted."
+ );
+ require(voters[voter].weight == 0);
+ voters[voter].weight = 1;
+ }
+
+ /// Delegate your vote to the voter `to`.
+ function delegate(address to) public {
+ // assigns reference
+ Voter storage sender = voters[msg.sender];
+ require(!sender.voted, "You already voted.");
+
+ require(to != msg.sender, "Self-delegation is disallowed.");
+
+ // Forward the delegation as long as
+ // `to` also delegated.
+ // In general, such loops are very dangerous,
+ // because if they run too long, they might
+ // need more gas than is available in a block.
+ // In this case, the delegation will not be executed,
+ // but in other situations, such loops might
+ // cause a contract to get "stuck" completely.
+ while (voters[to].delegate != address(0)) {
+ to = voters[to].delegate;
+
+ // We found a loop in the delegation, not allowed.
+ require(to != msg.sender, "Found loop in delegation.");
+ }
+
+ // Since `sender` is a reference, this
+ // modifies `voters[msg.sender].voted`
+ sender.voted = true;
+ sender.delegate = to;
+ Voter storage delegate_ = voters[to];
+ if (delegate_.voted) {
+ // If the delegate already voted,
+ // directly add to the number of votes
+ proposals[delegate_.vote].voteCount += sender.weight;
+ } else {
+ // If the delegate did not vote yet,
+ // add to her weight.
+ delegate_.weight += sender.weight;
+ }
+ }
+
+ /// Give your vote (including votes delegated to you)
+ /// to proposal `proposals[proposal].name`.
+ function vote(uint proposal) public {
+ Voter storage sender = voters[msg.sender];
+ require(sender.weight != 0, "Has no right to vote");
+ require(!sender.voted, "Already voted.");
+ sender.voted = true;
+ sender.vote = proposal;
+
+ // If `proposal` is out of the range of the array,
+ // this will throw automatically and revert all
+ // changes.
+ proposals[proposal].voteCount += sender.weight;
+ }
+
+ /// @dev Computes the winning proposal taking all
+ /// previous votes into account.
+ function winningProposal() public view
+ returns (uint winningProposal_)
+ {
+ uint winningVoteCount = 0;
+ for (uint p = 0; p < proposals.length; p++) {
+ if (proposals[p].voteCount > winningVoteCount) {
+ winningVoteCount = proposals[p].voteCount;
+ winningProposal_ = p;
+ }
+ }
+ }
+
+ // Calls winningProposal() function to get the index
+ // of the winner contained in the proposals array and then
+ // returns the name of the winner
+ function winnerName() public view
+ returns (bytes32 winnerName_)
+ {
+ winnerName_ = proposals[winningProposal()].name;
+ }
+}
diff --git a/autotests/html/test.sol.html b/autotests/html/test.sol.html
new file mode 100644
--- /dev/null
+++ b/autotests/html/test.sol.html
@@ -0,0 +1,160 @@
+
+
+
+test.sol
+
+
+// Solidity Sample File
+// https://solidity.readthedocs.io/en/latest/solidity-by-example.html#voting
+
+pragma solidity >=0.4.22 <0.7.0;
+
+/// @title Voting with delegation.
+contract Ballot {
+ // This declares a new complex type which will
+ // be used for variables later.
+ // It will represent a single voter.
+ struct Voter {
+ uint weight; // weight is accumulated by delegation
+ bool voted; // if true, that person already voted
+ address delegate; // person delegated to
+ uint vote; // index of the voted proposal
+ }
+
+ // This is a type for a single proposal.
+ struct Proposal {
+ bytes32 name; // short name (up to 32 bytes)
+ uint voteCount; // number of accumulated votes
+ }
+
+ address public chairperson;
+
+ // This declares a state variable that
+ // stores a `Voter` struct for each possible address.
+ mapping(address => Voter) public voters;
+
+ // A dynamically-sized array of `Proposal` structs.
+ Proposal[] public proposals;
+
+ /// Create a new ballot to choose one of `proposalNames`.
+ constructor(bytes32[] memory proposalNames) public {
+ chairperson = msg.sender;
+ voters[chairperson].weight = 1;
+
+ // For each of the provided proposal names,
+ // create a new proposal object and add it
+ // to the end of the array.
+ for (uint i = 0; i < proposalNames.length; i++) {
+ // `Proposal({...})` creates a temporary
+ // Proposal object and `proposals.push(...)`
+ // appends it to the end of `proposals`.
+ proposals.push(Proposal({
+ name: proposalNames[i],
+ voteCount: 0
+ }));
+ }
+ }
+
+ // Give `voter` the right to vote on this ballot.
+ // May only be called by `chairperson`.
+ function giveRightToVote(address voter) public {
+ // If the first argument of `require` evaluates
+ // to `false`, execution terminates and all
+ // changes to the state and to Ether balances
+ // are reverted.
+ // This used to consume all gas in old EVM versions, but
+ // not anymore.
+ // It is often a good idea to use `require` to check if
+ // functions are called correctly.
+ // As a second argument, you can also provide an
+ // explanation about what went wrong.
+ require(
+ msg.sender == chairperson,
+ "Only chairperson can give right to vote."
+ );
+ require(
+ !voters[voter].voted,
+ "The voter already voted."
+ );
+ require(voters[voter].weight == 0);
+ voters[voter].weight = 1;
+ }
+
+ /// Delegate your vote to the voter `to`.
+ function delegate(address to) public {
+ // assigns reference
+ Voter storage sender = voters[msg.sender];
+ require(!sender.voted, "You already voted.");
+
+ require(to != msg.sender, "Self-delegation is disallowed.");
+
+ // Forward the delegation as long as
+ // `to` also delegated.
+ // In general, such loops are very dangerous,
+ // because if they run too long, they might
+ // need more gas than is available in a block.
+ // In this case, the delegation will not be executed,
+ // but in other situations, such loops might
+ // cause a contract to get "stuck" completely.
+ while (voters[to].delegate != address(0)) {
+ to = voters[to].delegate;
+
+ // We found a loop in the delegation, not allowed.
+ require(to != msg.sender, "Found loop in delegation.");
+ }
+
+ // Since `sender` is a reference, this
+ // modifies `voters[msg.sender].voted`
+ sender.voted = true;
+ sender.delegate = to;
+ Voter storage delegate_ = voters[to];
+ if (delegate_.voted) {
+ // If the delegate already voted,
+ // directly add to the number of votes
+ proposals[delegate_.vote].voteCount += sender.weight;
+ } else {
+ // If the delegate did not vote yet,
+ // add to her weight.
+ delegate_.weight += sender.weight;
+ }
+ }
+
+ /// Give your vote (including votes delegated to you)
+ /// to proposal `proposals[proposal].name`.
+ function vote(uint proposal) public {
+ Voter storage sender = voters[msg.sender];
+ require(sender.weight != 0, "Has no right to vote");
+ require(!sender.voted, "Already voted.");
+ sender.voted = true;
+ sender.vote = proposal;
+
+ // If `proposal` is out of the range of the array,
+ // this will throw automatically and revert all
+ // changes.
+ proposals[proposal].voteCount += sender.weight;
+ }
+
+ /// @dev Computes the winning proposal taking all
+ /// previous votes into account.
+ function winningProposal() public view
+ returns (uint winningProposal_)
+ {
+ uint winningVoteCount = 0;
+ for (uint p = 0; p < proposals.length; p++) {
+ if (proposals[p].voteCount > winningVoteCount) {
+ winningVoteCount = proposals[p].voteCount;
+ winningProposal_ = p;
+ }
+ }
+ }
+
+ // Calls winningProposal() function to get the index
+ // of the winner contained in the proposals array and then
+ // returns the name of the winner
+ function winnerName() public view
+ returns (bytes32 winnerName_)
+ {
+ winnerName_ = proposals[winningProposal()].name;
+ }
+}
+
diff --git a/autotests/input/test.sol b/autotests/input/test.sol
new file mode 100644
--- /dev/null
+++ b/autotests/input/test.sol
@@ -0,0 +1,153 @@
+// Solidity Sample File
+// https://solidity.readthedocs.io/en/latest/solidity-by-example.html#voting
+
+pragma solidity >=0.4.22 <0.7.0;
+
+/// @title Voting with delegation.
+contract Ballot {
+ // This declares a new complex type which will
+ // be used for variables later.
+ // It will represent a single voter.
+ struct Voter {
+ uint weight; // weight is accumulated by delegation
+ bool voted; // if true, that person already voted
+ address delegate; // person delegated to
+ uint vote; // index of the voted proposal
+ }
+
+ // This is a type for a single proposal.
+ struct Proposal {
+ bytes32 name; // short name (up to 32 bytes)
+ uint voteCount; // number of accumulated votes
+ }
+
+ address public chairperson;
+
+ // This declares a state variable that
+ // stores a `Voter` struct for each possible address.
+ mapping(address => Voter) public voters;
+
+ // A dynamically-sized array of `Proposal` structs.
+ Proposal[] public proposals;
+
+ /// Create a new ballot to choose one of `proposalNames`.
+ constructor(bytes32[] memory proposalNames) public {
+ chairperson = msg.sender;
+ voters[chairperson].weight = 1;
+
+ // For each of the provided proposal names,
+ // create a new proposal object and add it
+ // to the end of the array.
+ for (uint i = 0; i < proposalNames.length; i++) {
+ // `Proposal({...})` creates a temporary
+ // Proposal object and `proposals.push(...)`
+ // appends it to the end of `proposals`.
+ proposals.push(Proposal({
+ name: proposalNames[i],
+ voteCount: 0
+ }));
+ }
+ }
+
+ // Give `voter` the right to vote on this ballot.
+ // May only be called by `chairperson`.
+ function giveRightToVote(address voter) public {
+ // If the first argument of `require` evaluates
+ // to `false`, execution terminates and all
+ // changes to the state and to Ether balances
+ // are reverted.
+ // This used to consume all gas in old EVM versions, but
+ // not anymore.
+ // It is often a good idea to use `require` to check if
+ // functions are called correctly.
+ // As a second argument, you can also provide an
+ // explanation about what went wrong.
+ require(
+ msg.sender == chairperson,
+ "Only chairperson can give right to vote."
+ );
+ require(
+ !voters[voter].voted,
+ "The voter already voted."
+ );
+ require(voters[voter].weight == 0);
+ voters[voter].weight = 1;
+ }
+
+ /// Delegate your vote to the voter `to`.
+ function delegate(address to) public {
+ // assigns reference
+ Voter storage sender = voters[msg.sender];
+ require(!sender.voted, "You already voted.");
+
+ require(to != msg.sender, "Self-delegation is disallowed.");
+
+ // Forward the delegation as long as
+ // `to` also delegated.
+ // In general, such loops are very dangerous,
+ // because if they run too long, they might
+ // need more gas than is available in a block.
+ // In this case, the delegation will not be executed,
+ // but in other situations, such loops might
+ // cause a contract to get "stuck" completely.
+ while (voters[to].delegate != address(0)) {
+ to = voters[to].delegate;
+
+ // We found a loop in the delegation, not allowed.
+ require(to != msg.sender, "Found loop in delegation.");
+ }
+
+ // Since `sender` is a reference, this
+ // modifies `voters[msg.sender].voted`
+ sender.voted = true;
+ sender.delegate = to;
+ Voter storage delegate_ = voters[to];
+ if (delegate_.voted) {
+ // If the delegate already voted,
+ // directly add to the number of votes
+ proposals[delegate_.vote].voteCount += sender.weight;
+ } else {
+ // If the delegate did not vote yet,
+ // add to her weight.
+ delegate_.weight += sender.weight;
+ }
+ }
+
+ /// Give your vote (including votes delegated to you)
+ /// to proposal `proposals[proposal].name`.
+ function vote(uint proposal) public {
+ Voter storage sender = voters[msg.sender];
+ require(sender.weight != 0, "Has no right to vote");
+ require(!sender.voted, "Already voted.");
+ sender.voted = true;
+ sender.vote = proposal;
+
+ // If `proposal` is out of the range of the array,
+ // this will throw automatically and revert all
+ // changes.
+ proposals[proposal].voteCount += sender.weight;
+ }
+
+ /// @dev Computes the winning proposal taking all
+ /// previous votes into account.
+ function winningProposal() public view
+ returns (uint winningProposal_)
+ {
+ uint winningVoteCount = 0;
+ for (uint p = 0; p < proposals.length; p++) {
+ if (proposals[p].voteCount > winningVoteCount) {
+ winningVoteCount = proposals[p].voteCount;
+ winningProposal_ = p;
+ }
+ }
+ }
+
+ // Calls winningProposal() function to get the index
+ // of the winner contained in the proposals array and then
+ // returns the name of the winner
+ function winnerName() public view
+ returns (bytes32 winnerName_)
+ {
+ winnerName_ = proposals[winningProposal()].name;
+ }
+}
diff --git a/autotests/reference/test.sol.ref b/autotests/reference/test.sol.ref
new file mode 100644
--- /dev/null
+++ b/autotests/reference/test.sol.ref
@@ -0,0 +1,153 @@
+// Solidity Sample File
+// https://solidity.readthedocs.io/en/latest/solidity-by-example.html#voting
+
+pragma solidity >=0.4.22 <0.7.0;
+
+/// @title Voting with delegation.
+contract Ballot {
+ // This declares a new complex type which will
+ // be used for variables later.
+ // It will represent a single voter.
+ struct Voter {
+ uint weight; // weight is accumulated by delegation
+ bool voted; // if true, that person already voted
+ address delegate; // person delegated to
+ uint vote; // index of the voted proposal
+ }
+
+ // This is a type for a single proposal.
+ struct Proposal {
+ bytes32 name; // short name (up to 32 bytes)
+ uint voteCount; // number of accumulated votes
+ }
+
+ address public chairperson;
+
+ // This declares a state variable that
+ // stores a `Voter` struct for each possible address.
+ mapping(address => Voter) public voters;
+
+ // A dynamically-sized array of `Proposal` structs.
+ Proposal[] public proposals;
+
+ /// Create a new ballot to choose one of `proposalNames`.
+ constructor(bytes32[] memory proposalNames) public {
+ chairperson = msg.sender;
+ voters[chairperson].weight = 1;
+
+ // For each of the provided proposal names,
+ // create a new proposal object and add it
+ // to the end of the array.
+ for (uint i = 0; i < proposalNames.length; i++) {
+ // `Proposal({...})` creates a temporary
+ // Proposal object and `proposals.push(...)`
+ // appends it to the end of `proposals`.
+ proposals.push(Proposal({
+ name: proposalNames[i],
+ voteCount: 0
+ }));
+ }
+ }
+
+ // Give `voter` the right to vote on this ballot.
+ // May only be called by `chairperson`.
+ function giveRightToVote(address voter) public {
+ // If the first argument of `require` evaluates
+ // to `false`, execution terminates and all
+ // changes to the state and to Ether balances
+ // are reverted.
+ // This used to consume all gas in old EVM versions, but
+ // not anymore.
+ // It is often a good idea to use `require` to check if
+ // functions are called correctly.
+ // As a second argument, you can also provide an
+ // explanation about what went wrong.
+ require(
+ msg.sender == chairperson,
+ "Only chairperson can give right to vote."
+ );
+ require(
+ !voters[voter].voted,
+ "The voter already voted."
+ );
+ require(voters[voter].weight == 0);
+ voters[voter].weight = 1;
+ }
+
+ /// Delegate your vote to the voter `to`.
+ function delegate(address to) public {
+ // assigns reference
+ Voter storage sender = voters[msg.sender];
+ require(!sender.voted, "You already voted.");
+
+ require(to != msg.sender, "Self-delegation is disallowed.");
+
+ // Forward the delegation as long as
+ // `to` also delegated.
+ // In general, such loops are very dangerous,
+ // because if they run too long, they might
+ // need more gas than is available in a block.
+ // In this case, the delegation will not be executed,
+ // but in other situations, such loops might
+ // cause a contract to get "stuck" completely.
+ while (voters[to].delegate != address(0)) {
+ to = voters[to].delegate;
+
+ // We found a loop in the delegation, not allowed.
+ require(to != msg.sender, "Found loop in delegation.");
+ }
+
+ // Since `sender` is a reference, this
+ // modifies `voters[msg.sender].voted`
+ sender.voted = true;
+ sender.delegate = to;
+ Voter storage delegate_ = voters[to];
+ if (delegate_.voted) {
+ // If the delegate already voted,
+ // directly add to the number of votes
+ proposals[delegate_.vote].voteCount += sender.weight;
+ } else {
+ // If the delegate did not vote yet,
+ // add to her weight.
+ delegate_.weight += sender.weight;
+ }
+ }
+
+ /// Give your vote (including votes delegated to you)
+ /// to proposal `proposals[proposal].name`.
+ function vote(uint proposal) public {
+ Voter storage sender = voters[msg.sender];
+ require(sender.weight != 0, "Has no right to vote");
+ require(!sender.voted, "Already voted.");
+ sender.voted = true;
+ sender.vote = proposal;
+
+ // If `proposal` is out of the range of the array,
+ // this will throw automatically and revert all
+ // changes.
+ proposals[proposal].voteCount += sender.weight;
+ }
+
+ /// @dev Computes the winning proposal taking all
+ /// previous votes into account.
+ function winningProposal() public view
+ returns (uint winningProposal_)
+ {
+ uint winningVoteCount = 0;
+ for (uint p = 0; p < proposals.length; p++) {
+ if (proposals[p].voteCount > winningVoteCount) {
+ winningVoteCount = proposals[p].voteCount;
+ winningProposal_ = p;
+ }
+ }
+ }
+
+ // Calls winningProposal() function to get the index
+ // of the winner contained in the proposals array and then
+ // returns the name of the winner
+ function winnerName() public view
+ returns (bytes32 winnerName_)
+ {
+ winnerName_ = proposals[winningProposal()].name;
+ }
+}
diff --git a/data/syntax/solidity.xml b/data/syntax/solidity.xml
new file mode 100644
--- /dev/null
+++ b/data/syntax/solidity.xml
@@ -0,0 +1,357 @@
+
+
+
+
+
+
+
+ - bool
+ - uint
+ - uint8
+ - uint16
+ - uint24
+ - uint32
+ - uint40
+ - uint48
+ - uint56
+ - uint64
+ - uint72
+ - uint80
+ - uint88
+ - uint96
+ - uint104
+ - uint112
+ - uint120
+ - uint128
+ - uint136
+ - uint144
+ - uint152
+ - uint160
+ - uint168
+ - uint176
+ - uint184
+ - uint192
+ - uint200
+ - uint208
+ - uint216
+ - uint224
+ - uint232
+ - uint240
+ - uint248
+ - uint256
+ - int
+ - int8
+ - int16
+ - int24
+ - int32
+ - int40
+ - int48
+ - int56
+ - int64
+ - int72
+ - int80
+ - int88
+ - int96
+ - int104
+ - int112
+ - int120
+ - int128
+ - int136
+ - int144
+ - int152
+ - int160
+ - int168
+ - int176
+ - int184
+ - int192
+ - int200
+ - int208
+ - int216
+ - int224
+ - int232
+ - int240
+ - int248
+ - int256
+
+ - ufixed
+ - fixed
+ - address
+ - byte
+ - bytes
+ - bytes1
+ - bytes2
+ - bytes3
+ - bytes4
+ - bytes5
+ - bytes6
+ - bytes7
+ - bytes8
+ - bytes9
+ - bytes10
+ - bytes11
+ - bytes12
+ - bytes13
+ - bytes14
+ - bytes15
+ - bytes16
+ - bytes17
+ - bytes18
+ - bytes19
+ - bytes20
+ - bytes21
+ - bytes22
+ - bytes23
+ - bytes24
+ - bytes25
+ - bytes26
+ - bytes27
+ - bytes28
+ - bytes29
+ - bytes30
+ - bytes31
+ - bytes32
+ - string
+ - mapping
+
+
+
+
+ - wei
+ - finney
+ - szabo
+ - ether
+ - seconds
+ - minutes
+ - hours
+ - days
+ - weeks
+
+
+ - block
+ - msg
+ - now
+ - tx
+ - this
+ - super
+
+ - blockhash
+ - gasleft
+ - abi
+ - assert
+ - require
+ - revert
+ - addmod
+ - mulmod
+ - keccak256
+ - sha256
+ - ripemd160
+ - ecrecover
+ - selfdestruct
+ - type
+
+ - log0
+ - log1
+ - log2
+ - log3
+ - log4
+
+
+
+
+
+ - as
+ - from
+ - is
+ - using
+
+ - enum
+ - true
+ - false
+ - new
+ - struct
+ - constant
+
+ - internal
+ - external
+ - public
+ - private
+ - pure
+ - view
+ - payable
+ - returns
+
+ - memory
+ - storage
+ - calldata
+
+ - delete
+
+ - event
+ - indexed
+
+
+
+
+ - if
+ - else
+ - while
+ - do
+ - for
+ - break
+ - continue
+ - return
+
+ - import
+ - contract
+ - library
+ - assembly
+ - function
+ - constructor
+ - modifier
+ - emit
+
+
+
+
+ - abstract
+ - after
+ - alias
+ - apply
+ - auto
+ - case
+ - catch
+ - copyof
+ - default
+ - define
+ - final
+ - immutable
+ - implements
+ - in
+ - inline
+ - let
+ - macro
+ - match
+ - mutable
+ - null
+ - of
+ - override
+ - partial
+ - promise
+ - reference
+ - relocatable
+ - sealed
+ - sizeof
+ - static
+ - supports
+ - switch
+ - try
+ - typedef
+ - typeof
+ - unchecked
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+