<?php

/*****************************************************************/
/** Procedural BrainFuck Assembler (PBF)                        **/
/** https://misc.daniel-marschall.de/brainfuck/procbf/rt.phps   **/
/** by Daniel Marschall, ViaThinkSoft                           **/
/** Project started 22 April 2016                               **/
/** Revision: 08 Feb 2020                                       **/
/*****************************************************************/

// r   = reference to a cell
// v   = constant value
// +z  = (only for references) cell will be zeroed
// +0  = (only for references) cell has to be zero, otherwise the program will misbehave
// +a  = array values are accepted (but single values need to be accepted too)
// +t  = Temporary
// +x  = gets modified

// ATTENTION!
// - Do not manually output BF commands using "echo" or "pbf_emit_bf". Use the predefined functions like pbf_inc() or pbf_right().
//   This framework performs optimizations (e.g. $_cur_bracket_indent) which require the control of the memory position.
// - Do not use unequal amounts of pbf_left() or pbf_right() inside a loop or if-statement.
// - By using "_zz" functions, you PROMISE that the memory cell is already zeroed. If not, the program will function incorrectly,
//   since upcoming memory allocations rely on your promise.

error_reporting(E_ALL | E_NOTICE | E_STRICT | E_DEPRECATED);

header('content-type:text/plain');

// Internal variables. Do not manually edit!
// not set = reference was never used
// 0 = currently freed
// 1 = currently freed, and value marked as zero
// 2 = reference is occupied
$_memmap = array();
$_max_memmap = 0;
$_cur_bracket_indent = 0;
$_curregister = 0;
$_to_free = array();
$_to_free_z = array();
$_bf_code = '';

# todo: oop?
# todo: überall prüfen ob referenz existiert, sonst exception
# todo: überall prüfen, wo src und dst nicht gleich sein dürfen
# todo: testing cases
# todo: doku every function
# todo: getmem zusammenhängende zellen funktionalität
# todo: array funktionalität https://esolangs.org/wiki/Brainfuck_algorithms#x.28y.29_.3D_z_.281-d_array.29_.282_cells.2Farray_element.29

$_cfg_zero_max_search_range = 128;
$_cfg_getmem_occupies_zeroed_cells = true;
$_cfg_optimize_shiftcontrol = true;
$_cfg_safe_getmem_z = true;
$_cfg_safe_memory_reservation = true;


// --- HELPER FUNCTIONS ---

function str_fix_width($str, $width) {
	$ret = '';
	while ($str != '') {
		$ret .= substr($str, 0, $width) . "\n";
		$str = substr($str, $width);
	}
	return $ret;
}

// --- PROCBF SYSTEM FUNCTIONS ---

function pbf_sys_output_script() {
	global $_bf_code;

	$code = $_bf_code;

	// Optimize code
	do {
		$a = strlen($code);
		$code = str_replace('<>', '', $code);
		$code = str_replace('><', '', $code);
		$code = str_replace('+-', '', $code);
		$code = str_replace('-+', '', $code);

		$code = str_replace('[-][-]', '', $code);

		 // A wonderful optimization would be removing the complete second bracket and all its contents
		$p = strpos($code, '[-]['); // TODO: hier könnte noch ein "." dazwischenstehen
		if ($p !== false) {
			$c = 0;
			for ($i=$p+3; $i<strlen($code); $i++) {
				if ($code[$i] == '[') $c++;
				if ($code[$i] == ']') $c--;
				if ($c == 0) break;
			}
			$code = substr($code, 0, $p).substr($code, $i+1);
		}

		$b = strlen($code);
	} while ($a != $b);

	echo str_fix_width($code, 80);
}

function pbf_dbg_memstat() {
	global $_memmap,
	       $_curreference,
	       $_max_memmap;

	$ret = '';

	for ($i=0; $i<=$_max_memmap; $i++) {
		if ($_curreference == $i) $ret .= '[';
		if (!isset($_memmap[$i])) {
			$ret .= '.';
		} else if ($_memmap[$i] == 0) {
			$ret .= '_';
		} else if ($_memmap[$i] == 1) {
			$ret .= '0';
		} else if ($_memmap[$i] == 2) {
			$ret .= 'X';
		} else {
			throw new Exception("Unknown memmap state ".ord($_memmap[$i])." at offset $i\n");
		}
		if ($_curreference == $i) $ret .= ']';
	}

	echo str_fix_width($ret, 80);
}

// --- LOW LEVEL FUNCTIONS ---

// Description:       Outputs raw brainfuck code (DO NOT CALL THIS FUNCTION UNLESS YOU REALLY KNOW WHAT YOU ARE DOING!)
// Input parameters:  (String constant)  brainfuck code
// Moves pointer to:  Moves depending on the brainfuck symbol(s)
function pbf_emit_bf($code) {
	global $_bf_code;
	for ($i=0; $i<strlen($code); $i++) {
		$symbol = $code[$i];
		if (($symbol != '[') && ($symbol != ']') && ($symbol != '+') && ($symbol != '-') && ($symbol != '<') && ($symbol != '>') && ($symbol != '.') && ($symbol != ',')) {
			throw new Exception("Invalid brainfuck symbol '$symbol'!");
		}
		$_bf_code .= $symbol;
	}
}

// Description:       Moves the current pointer by the value (rDst-rSrc) to the right
// Input parameters:  (Integer constant)  rSrc
//                    (Integer constant)  rDst
//                    Note: References $rSrc and $rDst do not need to be allocated references. They are just reference points.
// Moves pointer to:  Current pointer + rDst - rSrc
function pbf_deltamove($rSrc, $rDst) {
	if ($rDst > $rSrc) {
		pbf_right($rDst-$rSrc);
	} else if ($rDst < $rSrc) {
		pbf_left($rSrc-$rDst);
	} else {
		// The references are equal. Nothing to do.
	}
}

// Description:       Adds or subtracts until the current cell value will be $vDst
// Input parameters:  (Integer constant)  vSrc
//                    (Integer constant)  vDst
// Moves pointer to:  Does not move pointer
function pbf_deltainc($vSrc, $vDst) {
	if ($vDst > $vSrc) {
		pbf_inc($vDst-$vSrc);
	} else if ($vDst > $vSrc) {
		pbf_dec($vSrc-$vDst);
	} else {
		// The values are equal. Nothing to do.
	}
}

// Description:       Goes to the cell referenced with rReference
// Input parameters:  (Reference)  rReference
// Moves pointer to:  rReference
function pbf_goto($rReference) {
	global $_curreference;
	pbf_deltamove($_curreference, $rReference);
	$_curreference = $rReference;
}

// Description:       Returns the reference to the current pointer. Does only work if the pointer is consistent
// Input parameters:  None
// Moves pointer to:  Pointer will not be moved
function pbf_get_cur_reg() {
	global $_curreference;
	return $_curreference;
}

// Description:       Allocates a cell having the value $vValue, and returns the reference
// Input parameters:  None
// Moves pointer to:  Newly allocated reference
function pbf_getmem_v($vValue) {
	$rOut = pbf_getmem_z();
	pbf_goto($rOut);
	pbf_inc($vValue);
	return $rOut;
}

// Description:       Allocates a cell (having an arbitary value), and returns the reference
// Input parameters:  None
// Moves pointer to:  Pointer will not be moved
function pbf_getmem() {
	global $_curreference,
	       $_memmap,
	       $_cfg_getmem_occupies_zeroed_cells,
	       $_max_memmap;

	if (!isset($_memmap[$_curreference])) {
		// Bingo
		$_memmap[$_curreference] = 2; // occupied
		$_max_memmap = max($_max_memmap, $_curreference);
		return $_curreference;
	}

	$m = $_cfg_getmem_occupies_zeroed_cells ? 2 : 1;

	for ($i=$_curreference+1; true; $i++) {
		if (!isset($_memmap[$i]) || ($_memmap[$i] < $m)) {
			$steps_right = $i-$_curreference;
			$reg_right = $i;
			break;
		}
	}

	$reg_left = null;
	for ($i=$_curreference-1; $i>=0; $i--) {
		if (!isset($_memmap[$i]) || ($_memmap[$i] < $m)) {
			$steps_left = $_curreference-$i;
			$reg_left = $i;
			break;
		}
	}

	if (isset($reg_left) && ($steps_right > $steps_left)) {
		$_memmap[$reg_left] = 2; // occupied
		$_max_memmap = max($_max_memmap, $reg_left);
		return $reg_left;
	} else {
		$_memmap[$reg_right] = 2; // occupied
		$_max_memmap = max($_max_memmap, $reg_right);
		return $reg_right;
	}
}

// Description:       Allocates a cell with the value being guaranteed zero, and returns the reference
// Input parameters:  None
// Moves pointer to:  UNDEFINED! You must use _go() or any other statement to get a consistant memory pointer again
function pbf_getmem_z() {
	global $_curreference,
	       $_memmap,
	       $_cfg_zero_max_search_range,
	       $_max_memmap,
	       $_cfg_safe_getmem_z,
	       $_cur_bracket_indent;

	if (isset($_memmap[$_curreference]) && ($_memmap[$_curreference] == 1)) {
		// Bingo
		$_memmap[$_curreference] = 2; // occupied
		$_max_memmap = max($_max_memmap, $_curreference);

		// we need explicit zeroing, because during a loop in runtime, the cell (which is reserved during compile time) is multiple times used.
		if ($_cfg_safe_getmem_z && ($_cur_bracket_indent > 0)) pbf_zero($_curreference);

		return $_curreference;
	}

	$reg_right = null;
	for ($i=$_curreference+1; $i<$_curreference+1+$_cfg_zero_max_search_range; $i++) {
		if (isset($_memmap[$i]) && ($_memmap[$i] == 1)) {
			$steps_right = $i-$_curreference;
			$reg_right = $i;
			break;
		}
	}

	$reg_left = null;
	for ($i=$_curreference-1; $i>=max(-1,$_curreference-1-$_cfg_zero_max_search_range); $i--) {
		if (isset($_memmap[$i]) && ($_memmap[$i] == 1)) {
			$steps_left = $_curreference-$i;
			$reg_left = $i;
			break;
		}
	}

	if (isset($reg_left) && ($steps_right > $steps_left)) {
		$_memmap[$reg_left] = 2; // occupied
		$_max_memmap = max($_max_memmap, $reg_left);
		if ($_cfg_safe_getmem_z && ($_cur_bracket_indent > 0)) pbf_zero($reg_left);
		return $reg_left;
	} else if (isset($reg_right)) {
		$_memmap[$reg_right] = 2; // occupied
		$_max_memmap = max($_max_memmap, $reg_right);
		if ($_cfg_safe_getmem_z && ($_cur_bracket_indent > 0)) pbf_zero($reg_right);
		return $reg_right;
	} else {
		// Nothing found around $max_search_range
		$reg = pbf_getmem();
		pbf_zero($reg);
		$_max_memmap = max($_max_memmap, $reg);
		if ($_cfg_safe_getmem_z && ($_cur_bracket_indent > 0)) pbf_zero($reg);
		return $reg;
	}
}

// Description:       Frees the cell reference, so the cell can be re-allocated using a getmem() function later
// Input parameters:  (Reference)  rReference
// Moves pointer to:  Does not move pointer
function pbf_freemem($rReference) {
	global $_memmap,
	       $_cur_bracket_indent,
	       $_to_free,
	       $_cfg_safe_memory_reservation;
	if ($_cfg_safe_memory_reservation && ($_cur_bracket_indent > 0)) {
		// We need to free the memory later, since we are in a loop, which can only be evaluated in runtime.
		$_to_free[] = $rReference;
	} else {
		$_memmap[$rReference] = 0;
	}
}

// Description:       Frees the cell reference, so the cell can be re-allocated using a getmem() function later
// Input parameters:  (Reference)  r0Reference (cell has to be zero!)
// Moves pointer to:  Does not move pointer
function pbf_freemem_0($r0Reference) {
	global $_memmap,
	       $_cur_bracket_indent,
	       $_to_free_z,
	       $_cfg_safe_memory_reservation;
	if ($_cfg_safe_memory_reservation && ($_cur_bracket_indent > 0)) {
		// We need to free the memory later, since we are in a loop, which can only be evaluated in runtime.
		$_to_free_z[] = $r0Reference;
	} else {
		$_memmap[$r0Reference] = 1;
	}
}

// Description:       Adds a constant integer to the currently selected cell
// Input parameters:  (Integer constant)  vAmount : Amount to add
// Moves pointer to:  Currently selected cell
function pbf_inc($vAmount=1) {
	pbf_emit_bf(str_repeat('+', $vAmount));
}

// Description:       Substracts a constant integer to the currently selected cell
// Input parameters:  (Integer constant)  vAmount : Amount to substract
// Moves pointer to:  Currently selected cell
function pbf_dec($vAmount=1) {
	pbf_emit_bf(str_repeat('-', $vAmount));
}

// Description:       Moves the pointer vAmount times to the left
// Input parameters:  (Integer constant)  vAmount
// Moves pointer to:  vAmount cells to the left
function pbf_left($vAmount=1) {
	global $_cur_bracket_indent,
	       $_curreference,
	       $_cfg_optimize_shiftcontrol;
	if ($_cfg_optimize_shiftcontrol && ($_cur_bracket_indent == 0)) $_curreference -= $vAmount;
	pbf_emit_bf(str_repeat('<', $vAmount));
}

// Description:       Moves the pointer vAmount times to the right
// Input parameters:  (Integer constant)  vAmount
// Moves pointer to:  vAmount cells to the right
function pbf_right($vAmount=1) {
	global $_cur_bracket_indent,
	       $_curreference,
	       $_cfg_optimize_shiftcontrol;
	if ($_cfg_optimize_shiftcontrol && ($_cur_bracket_indent == 0)) $_curreference += $vAmount;
	pbf_emit_bf(str_repeat('>', $vAmount));
}

// Description:       Start marker of a loop at cell referenced by $rReference
// Input parameters:  (Reference)  rReference
// Moves pointer to:  rReference if $rReference is set, otherwise stay at current cell
function pbf_beginloop($rReference=null) {
	global $_cur_bracket_indent;
	if (!is_null($rReference)) pbf_goto($rReference);
	$_cur_bracket_indent++;
	pbf_emit_bf('[');
}

// Description:       End marker of a loop at cell referenced by $rReference
// Input parameters:  (Reference)  rReference
// Moves pointer to:  rReference if $rReference is set, otherwise stay at current cell
function pbf_endloop($rReference=null) {
	global $_cur_bracket_indent,
	       $_to_free,
	       $_to_free_z;
	if (!is_null($rReference)) pbf_goto($rReference);
	$_cur_bracket_indent--;

	if ($_cur_bracket_indent == 0) {
		foreach ($_to_free as $r) {
			pbf_freemem($r);
		}
		$_to_free = array();

		foreach ($_to_free_z as $rz) {
			pbf_freemem_0($rz);
		}
		$_to_free_z = array();
	}

	pbf_emit_bf(']');
}

function pbf_out($vAmount=1) {
	pbf_emit_bf(str_repeat('.', $vAmount));
}

function pbf_in($vAmount=1) {
	pbf_emit_bf(str_repeat(',', $vAmount));
}

// --- HIGHER LEVEL FUNCTIONS ---

// Description:       Calculates  [raDst] <- [rzSrc]
//                                [rzSrc] <- 0
// Input parameters:  (Reference[s])  raDst
//                    (Reference)     rzSrc (becomes zeroed)
// Moves pointer to:  rzSrc
function pbf_mov_z($raDst, $rzSrc) {
	if (!is_array($raDst)) $raDst = array($raDst);
	if (in_array($rzSrc, $raDst)) {
		throw new Exception("Src and Dst must be different references.\n");
	}

	pbf_zero($raDst);
	pbf_add_z($raDst, $rzSrc);
}

// Description:       Calculates  [raDst] <- [rzSrc]
// Input parameters:  (Reference[s])  raDst
//                    (Reference)     rSrc
// Moves pointer to:  rtzTmp
function pbf_cpy($raDst, $rSrc) {
	// doesn't work because of circular reference between pbf_cpy() and pbf_add()
	/*
	pbf_zero($raDst);
	pbf_add($raDst, $rSrc);
	return;
	*/

	if (!is_array($raDst)) $raDst = array($raDst);

	$rtzTmp = pbf_getmem();

	$a = $raDst;
	$a[] = $rtzTmp;

	pbf_mov_z($a, $rSrc);

	pbf_add_z($rSrc, $rtzTmp);

	pbf_freemem_0($rtzTmp);
}

// Description:       Calculates  [raDst] <- [rzSrc]
//                                [rzSrc] <- 0
// Input parameters:  (Reference[s])  raDst
//                    (Reference)     rzSrc (becomes zeroed)
// Moves pointer to:  rzSrc
function pbf_add_z($raDst, $rzSrc) {
	if (!is_array($raDst)) $raDst = array($raDst);
	if (in_array($rzSrc, $raDst)) {
		throw new Exception("Src and Dst must be different references.\n");
	}

	pbf_beginloop($rzSrc);
		pbf_dec();
		foreach ($raDst as $rDst) {
			pbf_goto($rDst);
			pbf_inc();
		}
	pbf_endloop($rzSrc);
}

// Description:       Calculates [raDst] <- [raDst] + vAmount
// Input parameters:  (Reference[s])      raDst
//                    (Integer constant)  vAmount
// Moves pointer to:  raDst
function pbf_add_v($raDst, $vAmount) {
	if (!is_array($raDst)) $raDst = array($raDst);

	foreach ($raDst as $rDst) {
		pbf_goto($rDst);
		pbf_inc($vAmount);
	}
}

// Description:       Calculates [raDst] <- [raDst] + [rSrc]
// Input parameters:  (Reference[s])  raDst
//                    (Reference)     rSrc
// Moves pointer to:  rtzSrcBak
function pbf_add($raDst, $rSrc) {
	$rtzSrcBak = pbf_getmem();
	pbf_cpy($rtzSrcBak, $rSrc);

	pbf_add_z($raDst, $rtzSrcBak);

	pbf_freemem_0($rtzSrcBak);
}

// Description:       Prints a string
// Input parameters:  (String constant)  vStr
// Moves pointer to:  Moves pointer to freed cell
function pbf_printstr($vStr) {
	if ($vStr == '') return;

	$rChar = pbf_getmem_z();
	pbf_goto($rChar);

	$c_prev = 0;
	for ($i=0; $i<strlen($vStr); $i++) {
		$c = ord(substr($vStr, $i, 1));

		pbf_deltainc($c_prev, $c);
		pbf_out();

		$c_prev = $c;
	}

	if ($c == 0) {
		pbf_freemem_0($rChar);
	} else {
		pbf_freemem($rChar);
	}
}

// Description:       Repeats the string $vStr n-times with n being the contents of the cell referenced by rzAmount
// Input parameters:  (String constant)  vStr
//                    (Reference)        rzAmount (becomes zeroed)
// Moves pointer to:  rzAmount
function pbf_strrepeat_z($vStr, $rzAmount) {
	pbf_beginloop($rzAmount);
		pbf_printstr($vStr);
		pbf_goto($rzAmount);
		pbf_dec();
	pbf_endloop($rzAmount);
}

// Description:       Repeats the string $vStr n-times with n being the contents of the cell referenced by rzAmount
// Input parameters:  (String constant)  vStr
//                    (Reference)        rAmount
// Moves pointer to:  An now unused cell
function pbf_strrepeat($vStr, $rAmount) {
	$rtzAmountBak = pbf_getmem();
	pbf_cpy($rtzAmountBak, $rAmount);

	pbf_strrepeat_z($vStr, $rtzAmountBak);

	pbf_freemem_0($rtzAmountBak);
}

// Description:       Calculates [raDst] <- [raDst] - [rzSrc]
//                               [rzSrc] <- 0
// Input parameters:  (Reference[s]) raDst
//                    (Reference)    rzSrc (becomes zeroed)
// Moves pointer to:  rzSrc
function pbf_sub_z($raDst, $rzSrc) {
	if (!is_array($raDst)) $raDst = array($raDst);
	if (in_array($rzSrc, $raDst)) {
		throw new Exception("Src and Dst must be different references.\n");
	}

	pbf_beginloop($rzSrc);
		pbf_dec();
		foreach ($raDst as $rDst) {
			pbf_goto($rDst);
			pbf_dec();
		}
	pbf_endloop($rzSrc);
}

// Description:       Calculates [raDst] <- [raDst] - vAmount
// Input parameters:  (Register[s])       raDst
//                    (Integer constant)  vAmount
// Moves pointer to:  raDst
function pbf_sub_v($raDst, $vAmount) {
	if (!is_array($raDst)) $raDst = array($raDst);

	foreach ($raDst as $rDst) {
		pbf_goto($rDst);
		pbf_dec($vAmount);
	}
}

// Description:       Calculates [raDst] <- [raDst] - [rSrc]
// Input parameters:  (Reference[s]) raDst
//                    (Reference)    rSrc
// Moves pointer to:  free zeroed memory cell
function pbf_sub($raDst, $rSrc) {
	$rtzSrcBak = pbf_getmem();
	pbf_cpy($rtzSrcBak, $rSrc);

	pbf_sub_z($raDst, $rtzSrcBak);

	pbf_freemem_0($rtzSrcBak);
}

// Description:       Calculates [razSrc] <- 0
// Input parameters:  (Reference[s]) razSrc (becomes zerored)
// Moves pointer to:  razSrc
function pbf_zero($razSrc) {
	if (!is_array($razSrc)) $razSrc = array($razSrc);

	foreach ($razSrc as $rzSrc) {
		pbf_beginloop($rzSrc);
			pbf_dec();
		pbf_endloop($rzSrc);
	}
}

// Description:       Calculates [raDst] <- vValue
// Input parameters:  (Reference[s])      raDst
//                    (Integer constant)  vValue
// Moves pointer to:  raDst
function pbf_set_v($raDst, $vValue) {
	pbf_zero($raDst);
	pbf_add_v($raDst, $vValue);
}

// Description:       Calculates [rInOut] <- [rInOut] * vVal
// Input parameters:  (Reference)         rInOut
//                    (Integer constant)  vVal
// Moves pointer to:  rInOut
function pbf_multiply_v($rInOut, $vVal) {
	$rtTmp = pbf_getmem();
	pbf_mov_z($rtTmp, $rInOut);

	for ($i=0; $i<$vVal; $i++) {
		pbf_add($rInOut, $rtTmp);
	}

	pbf_freemem($rtTmp);
}

// Description:       Calculates [rInOut] <- [rInOut] * [rzCounter]
//                               [rzCounter] <- 0
// Input parameters:  (Reference) rInOut
//                    (Reference) rzCounter
// Moves pointer to:  rzCounter
function pbf_multiply_z($rInOut, $rzCounter) {
	$rtTmp = pbf_getmem();
	pbf_mov_z($rtTmp, $rInOut);

	pbf_beginloop($rzCounter);
		pbf_dec();
		pbf_add($rInOut, $rtTmp);
	pbf_endloop($rzCounter);

	pbf_freemem($rtTmp);
}

// Description:       Calculates [rInOut] <- [rInOut] * [rCounter]
// Input parameters:  (Reference) rInOut
//                    (Reference) rCounter
// Moves pointer to:  free zeroed memory cell
function pbf_multiply($rInOut, $rCounter) {
	$rtzCounterBak = pbf_getmem();

	pbf_cpy($rtzCounterBak, $rCounter);
	pbf_multiply_z($rInOut, $rtzCounterBak);

	pbf_freemem_0($rtzCounterBak);
}

// Description:       Creates an endless loop
// Input parameters:  None
// Moves pointer to:  n/a
function pbf_halt() {
	$r = pbf_getmem_v(1);
	pbf_beginloop($r);
	pbf_endloop($r);
}

// Description:       Use this function as "if" statement in an "if" block (that doesn't contain "else")
// Input parameters:  (Reference) rCond
// Moves pointer to:  rCond
function pbf_simpleif($rCond) {
	pbf_beginloop($rCond);
}

// Description:       Use this function as "end" statement in an "if" block (that doesn't contain "else")
// Input parameters:  (Reference) rzCond
// Moves pointer to:  rzCond
function pbf_simpleif_end($rzCond) {
	pbf_zero($rzCond); // prevent that the if-code is executed again
	pbf_endloop($rzCond);
}

// Description:       Use this function as "if" statement in an "if else" block
// Input parameters:  (Reference) rCond
// Moves pointer to:  rCond
function pbf_ifelse_if($rCond) {
	$rIfContext = pbf_getmem_v(1);
	pbf_simpleif($rCond);
	return $rIfContext; // important: it is necessary, so you can use the "else" block
}

// Description:       Use this function as "else" statement in an "if else" block
// Input parameters:  (Reference) rCond
//                    (Reference) rIfContext : Identifies the "if else" block
// Moves pointer to:  rIfContext
function pbf_ifelse_else($rCond, $rIfContext) {
	pbf_goto($rIfContext);
	pbf_dec(); // $rIfContext is now 0

	pbf_simpleif_end($rCond);

	pbf_simpleif($rIfContext);
}

// Description:       Use this function as "end" statement in an "if else" block
// Input parameters:  (Reference) rIfContext : Identifies the "if else" block
// Moves pointer to:  rIfContext (which is now zeroed and freed)
function pbf_ifelse_end($rIfContext) {
	// This code is faster than pbf_simpleif($rIfContext), because we know that rIfContext is 1; so we do not need [-]
	pbf_goto($rIfContext);
	pbf_dec(); // $rIfContext is now 0
	pbf_endloop($rIfContext);

	pbf_freemem_0($rIfContext);
}

// --- EXAMPLE CODE ---

$a = pbf_getmem();
pbf_set_v($a, 10);

$b = pbf_getmem();
pbf_set_v($b, 5);

pbf_multiply($a, $b);

pbf_freemem($b);

$c = pbf_getmem();
pbf_set_v($c, 3);

pbf_add($a, $c);

pbf_goto($a);
pbf_out();

pbf_sub_v($a, 50);
pbf_strrepeat("X", $a);
pbf_add_v($a, 50);

pbf_out();

$ifctx = pbf_ifelse_if($a);
	pbf_printstr("not zero");
pbf_ifelse_else($a, $ifctx);
	pbf_printstr("zero");
pbf_ifelse_end($ifctx);

pbf_freemem($a);
pbf_freemem($c);


pbf_sys_output_script();
echo "\n";
echo "\n";
pbf_dbg_memstat();
echo "\n";