Added support for Solidity (#2031)

This adds support for the Solidity language.

https://solidity.readthedocs.io/en/v0.4.23/

components.json

@@ -865,6 +865,11 @@
 			"require": "markup-templating",
 			"owner": "Golmote"
 		},
+		"solidity": {
+			"title": "Solidity (Ethereum)",
+			"require": "clike",
+			"owner": "glachaud"
+		},
 		"soy": {
 			"title": "Soy (Closure Template)",
 			"require": "markup-templating",

components/prism-solidity.js

@@ -0,0 +1,20 @@
+Prism.languages.solidity = Prism.languages.extend('clike', {
+	'class-name': {
+		pattern: /(\b(?:contract|enum|interface|library|new|struct|using)\s+)(?!\d)[\w$]+/,
+		lookbehind: true
+	},
+	'keyword': /\b(?:_|anonymous|as|assembly|assert|break|calldata|case|constant|constructor|continue|contract|default|delete|do|else|emit|enum|event|external|for|from|function|if|import|indexed|inherited|interface|internal|is|let|library|mapping|memory|modifier|new|payable|pragma|private|public|pure|require|returns?|revert|selfdestruct|solidity|storage|struct|suicide|switch|this|throw|using|var|view|while)\b/,
+	'operator': /=>|->|:=|=:|\*\*|\+\+|--|\|\||&&|<<=?|>>=?|[-+*/%^&|<>!=]=?|[~?]/
+});
+
+Prism.languages.insertBefore('solidity', 'keyword', {
+	'builtin': /\b(?:address|bool|string|u?int(?:8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?|byte|bytes(?:[1-9]|[12]\d|3[0-2])?)\b/
+});
+
+Prism.languages.insertBefore('solidity', 'number', {
+	'version': {
+		pattern: /([<>]=?|\^)\d+\.\d+\.\d+\b/,
+		lookbehind: true,
+		alias: 'number',
+	}
+});

examples/prism-solidity.html

@@ -0,0 +1,151 @@
+<h2>Full example</h2>
+<pre><code>pragma solidity >=0.4.22 &lt;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 &lt; 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 &lt; 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;
+	}
+}</code></pre>

plugins/autoloader/prism-autoloader.js

@@ -98,6 +98,7 @@
 		"scala": "java",
 		"shell-session": "bash",
 		"smarty": "markup-templating",
+		"solidity": "clike",
 		"soy": "markup-templating",
 		"swift": "clike",
 		"tap": "yaml",

plugins/show-language/prism-show-language.js

@@ -123,6 +123,7 @@
 		"sass": "Sass (Sass)",
 		"scss": "Sass (Scss)",
 		"shell-session": "Shell session",
+		"solidity": "Solidity (Ethereum)",
 		"soy": "Soy (Closure Template)",
 		"splunk-spl": "Splunk SPL",
 		"sql": "SQL",