<?php

# This program is in the public domain within the United States. Additionally,
# we waive copyright and related rights in the work worldwide through the CC0
# 1.0 Universal public domain dedication, which can be found at
# http://creativecommons.org/publicdomain/zero/1.0/


# pass an integer, returns the suffix
function ordinal_suffix($i) {
	# teens are all __th
	if(strlen($i) > 1 && substr($i, -2, 1) === '1') {
		return 'th';
	}
	switch(substr($i, -1)) {
		case '':
			return '';
		case '1':
			return 'st';
		case '2':
			return 'nd';
		case '3':
			return 'rd';
		default;
			return 'th';
	}
}

# ordinalize(1) => "1st"
# ordinalize(2) => "2nd"
# ordinalize(3) => "3rd"
# ordinalize(111) => "111th"
# ordinalize("62") => "62nd"
function ordinalize($i) {
	return $i . ordinal_suffix($i);
}

# remove the $key from $_REQUEST and return it's value (or null if it's not there)
function _REQUEST_cut($key) {
	if(!isset($_REQUEST[$key])) {
		return null;
	}
	$ret = $_REQUEST[$key];
	unset($_REQUEST[$key]);
	return $ret;
}

# returns an array containing just the elements of $pipes that are readable (without blocking)
# timeout 0 means don't wait, timeout NULL means wait indefinitely
function readable_sockets($pipes, $timeout = 0){
	$read = array_values($pipes);
	$ret = stream_select($read, $write = NULL, $exceptions = NULL, $timeout);
	if($ret === false) {
		return false;
	}
	if($ret) {
		return $read;
	} else {
		return array();
	}
}


# Parameters:
#     command
#     stdin
# Returns: (as array)
#     exit code
#     stdout
function exec_pipe($command, $stdin) {
	$descriptorspec = array(
   	   0 => array('pipe', 'r'),  // stdin is a pipe that the child will read from
   	   1 => array('pipe', 'w'),  // stdout is a pipe that the child will write to
   	   2 => array('file', '/dev/null', 'w')   // stderr is a pipe that the child will write to
	);

	$process = proc_open($command, $descriptorspec, $pipes);

	if (is_resource($process)) {
		fwrite($pipes[0], $stdin);
		fclose($pipes[0]);

		while (!feof($pipes[1])) {
			$chunk = fread($pipes[1], 1024);
			$stdout .= $chunk;
			sleep(0.5);
		}

		fclose($pipes[1]);

		// It is important that you close any pipes before calling
		// proc_close in order to avoid a deadlock
		$return_value = proc_close($process);

		return array($return_value, $stdout);
	}
}


function unix_newlines($str) {
	$str = str_replace("\r\n", "\n", $str);
	return str_replace("\r", "\n", $str);
}


# return current year (all 4 digits)
function this_year() {
	return strftime('%Y');
}

# return the number of the current month (1..12)
function this_month() {
	return preg_replace('|^0|', '', strftime('%m'));
}

# return today's date in yyyy-mm-dd format
function today_ymd() {
	return strftime('%Y-%m-%d');
}

function now_yyyymmdd() {
	return strftime('%Y-%m-%d');
}

function now_yyyymmddhhmmss() {
	return strftime('%Y-%m-%d %H:%M:%S');
}


function get_text_between($text, $start_text, $end_text) {
	$start = strpos($text, $start_text);
	if($start === false) {
		return false;
	}
	$text = substr($text, $start + strlen($start_text));
	$end = strpos($text, $end_text);
	if($end === false) {
		return false;
	}
	return substr($text, 0, $end);
}

# Make it easy to insert an array into the template data structure so that each
# element of the array gets its own row.
#
# passed this: columnize(array('a', 'b', 'c'), 'k');
# it returns: array(array('k' => 'a'),
#                   array('k' => 'b'),
#                   array('k' => 'c'));
# passed this: columnize(array(), 'k');
# it returns: false
function columnize($arr, $key = 'data') {
	if(!$arr) {
		return false;
	}
	$ret = array();
	foreach($arr as $val) {
		$ret[] = array($key => $val);
	}
	return $ret;
}

# php4 is broken, in that you cannot set a default value for a parameter that
# is passed by reference. So, this is set up to use the following screwy
# syntax:
#
# function foo($bar = 0) {
#   if($bar !== 0) {
#     $bar = $bar->ref;
#   }
#	...
# }
#
# foo();
# foo(ref($baz));

class stupid_reference {
	var $ref;
	function stupid_reference(&$ref) {
		$this->ref = &$ref;
	}
}
function ref(&$foo) {
	return new stupid_reference($foo);
}

function &last(&$array) {
	if(count($array)) return $array[count($array) - 1];
}