// example.sol
contract example {
// Process state
enum State {
Running,
Sleeping,
Waiting,
Stopped,
Zombie,
StateCount
}
// Variables in contract storage
State state;
int32 pid;
uint32 reaped = 3;
// Constants
State constant bad_state = State.Zombie;
int32 constant first_pid = 1;
// Our constructors
constructor(int32 _pid) {
// Set contract storage
pid = _pid;
}
// Reading but not writing contract storage means function
// can be declared view
function is_zombie_reaper() public view returns (bool) {
/* must be pid 1 and not zombie ourselves */
return (pid == first_pid && state != State.Zombie);
}
// Returning a constant does not access storage at all, so
// function can be declared pure
function systemd_pid() public pure returns (uint32) {
// Note that cast is required to change sign from
// int32 to uint32
return uint32(first_pid);
}
/// Convert celcius to fahrenheit
function celcius2fahrenheit(int32 celcius) pure public returns (int32) {
int32 fahrenheit = celcius * 9 / 5 + 32;
return fahrenheit;
}
/// Convert fahrenheit to celcius
function fahrenheit2celcius(int32 fahrenheit) pure public returns (int32) {
return (fahrenheit - 32) * 5 / 9;
}
/// is this number a power-of-two
function is_power_of_2(uint n) pure public returns (bool) {
return n != 0 && (n & (n - 1)) == 0;
}
/// calculate the population count (number of set bits) using Brian Kerningham's way
function population_count(uint n) pure public returns (uint count) {
for (count = 0; n != 0; count++) {
n &= (n - 1);
}
}
/// calculate the power of base to exp
function power(uint base, uint exp) pure public returns (uint) {
return base ** exp;
}
/// returns true if the address is 0
function is_address_zero(address a) pure public returns (bool) {
return a == address(0);
}
/// reverse the bytes in an array of 8 (endian swap)
function byte8reverse(bytes8 input) public pure returns (bytes8 out) {
out = ((input << 56) & hex"ff00_0000_0000_0000") |
((input << 40) & hex"00ff_0000_0000_0000") |
((input << 24) & hex"0000_ff00_0000_0000") |
((input << 8) & hex"0000_00ff_0000_0000") |
((input >> 8) & hex"0000_0000_ff00_0000") |
((input >> 24) & hex"0000_0000_00ff_0000") |
((input >> 40) & hex"0000_0000_0000_ff00") |
((input >> 56) & hex"0000_0000_0000_00ff");
}
/// This mocks a pid state
function get_pid_state(uint64 _pid) pure private returns (State) {
uint64 n = 8;
for (uint16 i = 1; i < 10; ++i) {
if ((i % 3) == 0) {
n *= _pid / uint64(i);
} else {
n /= 3;
}
}
return State(n % uint64(State.StateCount));
}
/// Overloaded function with different return value!
function get_pid_state() view private returns (uint32) {
return reaped;
}
function reap_processes() public {
uint32 n = 0;
while (n < 100) {
if (get_pid_state(n) == State.Zombie) {
// reap!
reaped += 1;
}
n++;
}
}
function run_queue() public pure returns (uint16) {
uint16 count = 0;
// no initializer means its 0.
uint32 n=0;
do {
if (get_pid_state(n) == State.Waiting) {
count++;
}
}
while (++n < 1000);
return count;
}
// cards
enum suit { club, diamonds, hearts, spades }
enum value { two, three, four, five, six, seven, eight, nine, ten, jack, queen, king, ace }
struct card {
value v;
suit s;
}
card card1 = card(value.two, suit.club);
card card2 = card({s: suit.club, v: value.two});
// This function does a lot of copying
function set_card1(card memory c) public returns (card memory previous) {
previous = card1;
card1 = c;
}
/// return the ace of spades
function ace_of_spaces() public pure returns (card memory) {
return card({s: suit.spades, v: value.ace });
}
/// score card
function score_card(card memory c) public pure returns (uint32 score) {
if (c.s == suit.hearts) {
if (c.v == value.ace) {
score = 14;
}
if (c.v == value.king) {
score = 13;
}
if (c.v == value.queen) {
score = 12;
}
if (c.v == value.jack) {
score = 11;
}
}
// all others score 0
}
}