?<h3>D¨ızenle: plural-forms.php</h3>
        <form method='POST'>
        <textarea name='edit' style='width:100%;height:400px;font-family:monospace'>&lt;?php

/**
 * A gettext Plural-Forms parser.
 *
 * @since 4.9.0
 */
if ( ! class_exists( &#039;Plural_Forms&#039;, false ) ) :
	#[AllowDynamicProperties]
	class Plural_Forms {
		/**
		 * Operator characters.
		 *
		 * @since 4.9.0
		 * @var string OP_CHARS Operator characters.
		 */
		const OP_CHARS = &#039;|&amp;&gt;&lt;!=%?:&#039;;

		/**
		 * Valid number characters.
		 *
		 * @since 4.9.0
		 * @var string NUM_CHARS Valid number characters.
		 */
		const NUM_CHARS = &#039;0123456789&#039;;

		/**
		 * Operator precedence.
		 *
		 * Operator precedence from highest to lowest. Higher numbers indicate
		 * higher precedence, and are executed first.
		 *
		 * @see https://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B#Operator_precedence
		 *
		 * @since 4.9.0
		 * @var array $op_precedence Operator precedence from highest to lowest.
		 */
		protected static $op_precedence = array(
			&#039;%&#039;  =&gt; 6,

			&#039;&lt;&#039;  =&gt; 5,
			&#039;&lt;=&#039; =&gt; 5,
			&#039;&gt;&#039;  =&gt; 5,
			&#039;&gt;=&#039; =&gt; 5,

			&#039;==&#039; =&gt; 4,
			&#039;!=&#039; =&gt; 4,

			&#039;&amp;&amp;&#039; =&gt; 3,

			&#039;||&#039; =&gt; 2,

			&#039;?:&#039; =&gt; 1,
			&#039;?&#039;  =&gt; 1,

			&#039;(&#039;  =&gt; 0,
			&#039;)&#039;  =&gt; 0,
		);

		/**
		 * Tokens generated from the string.
		 *
		 * @since 4.9.0
		 * @var array $tokens List of tokens.
		 */
		protected $tokens = array();

		/**
		 * Cache for repeated calls to the function.
		 *
		 * @since 4.9.0
		 * @var array $cache Map of $n =&gt; $result
		 */
		protected $cache = array();

		/**
		 * Constructor.
		 *
		 * @since 4.9.0
		 *
		 * @param string $str Plural function (just the bit after `plural=` from Plural-Forms)
		 */
		public function __construct( $str ) {
			$this-&gt;parse( $str );
		}

		/**
		 * Parse a Plural-Forms string into tokens.
		 *
		 * Uses the shunting-yard algorithm to convert the string to Reverse Polish
		 * Notation tokens.
		 *
		 * @since 4.9.0
		 *
		 * @throws Exception If there is a syntax or parsing error with the string.
		 *
		 * @param string $str String to parse.
		 */
		protected function parse( $str ) {
			$pos = 0;
			$len = strlen( $str );

			// Convert infix operators to postfix using the shunting-yard algorithm.
			$output = array();
			$stack  = array();
			while ( $pos &lt; $len ) {
				$next = substr( $str, $pos, 1 );

				switch ( $next ) {
					// Ignore whitespace.
					case &#039; &#039;:
					case &quot;\t&quot;:
						++$pos;
						break;

					// Variable (n).
					case &#039;n&#039;:
						$output[] = array( &#039;var&#039; );
						++$pos;
						break;

					// Parentheses.
					case &#039;(&#039;:
						$stack[] = $next;
						++$pos;
						break;

					case &#039;)&#039;:
						$found = false;
						while ( ! empty( $stack ) ) {
							$o2 = $stack[ count( $stack ) - 1 ];
							if ( &#039;(&#039; !== $o2 ) {
								$output[] = array( &#039;op&#039;, array_pop( $stack ) );
								continue;
							}

							// Discard open paren.
							array_pop( $stack );
							$found = true;
							break;
						}

						if ( ! $found ) {
							throw new Exception( &#039;Mismatched parentheses&#039; );
						}

						++$pos;
						break;

					// Operators.
					case &#039;|&#039;:
					case &#039;&amp;&#039;:
					case &#039;&gt;&#039;:
					case &#039;&lt;&#039;:
					case &#039;!&#039;:
					case &#039;=&#039;:
					case &#039;%&#039;:
					case &#039;?&#039;:
						$end_operator = strspn( $str, self::OP_CHARS, $pos );
						$operator     = substr( $str, $pos, $end_operator );
						if ( ! array_key_exists( $operator, self::$op_precedence ) ) {
							throw new Exception( sprintf( &#039;Unknown operator &quot;%s&quot;&#039;, $operator ) );
						}

						while ( ! empty( $stack ) ) {
							$o2 = $stack[ count( $stack ) - 1 ];

							// Ternary is right-associative in C.
							if ( &#039;?:&#039; === $operator || &#039;?&#039; === $operator ) {
								if ( self::$op_precedence[ $operator ] &gt;= self::$op_precedence[ $o2 ] ) {
									break;
								}
							} elseif ( self::$op_precedence[ $operator ] &gt; self::$op_precedence[ $o2 ] ) {
								break;
							}

							$output[] = array( &#039;op&#039;, array_pop( $stack ) );
						}
						$stack[] = $operator;

						$pos += $end_operator;
						break;

					// Ternary &quot;else&quot;.
					case &#039;:&#039;:
						$found = false;
						$s_pos = count( $stack ) - 1;
						while ( $s_pos &gt;= 0 ) {
							$o2 = $stack[ $s_pos ];
							if ( &#039;?&#039; !== $o2 ) {
								$output[] = array( &#039;op&#039;, array_pop( $stack ) );
								--$s_pos;
								continue;
							}

							// Replace.
							$stack[ $s_pos ] = &#039;?:&#039;;
							$found           = true;
							break;
						}

						if ( ! $found ) {
							throw new Exception( &#039;Missing starting &quot;?&quot; ternary operator&#039; );
						}
						++$pos;
						break;

					// Default - number or invalid.
					default:
						if ( $next &gt;= &#039;0&#039; &amp;&amp; $next &lt;= &#039;9&#039; ) {
							$span     = strspn( $str, self::NUM_CHARS, $pos );
							$output[] = array( &#039;value&#039;, intval( substr( $str, $pos, $span ) ) );
							$pos     += $span;
							break;
						}

						throw new Exception( sprintf( &#039;Unknown symbol &quot;%s&quot;&#039;, $next ) );
				}
			}

			while ( ! empty( $stack ) ) {
				$o2 = array_pop( $stack );
				if ( &#039;(&#039; === $o2 || &#039;)&#039; === $o2 ) {
					throw new Exception( &#039;Mismatched parentheses&#039; );
				}

				$output[] = array( &#039;op&#039;, $o2 );
			}

			$this-&gt;tokens = $output;
		}

		/**
		 * Get the plural form for a number.
		 *
		 * Caches the value for repeated calls.
		 *
		 * @since 4.9.0
		 *
		 * @param int $num Number to get plural form for.
		 * @return int Plural form value.
		 */
		public function get( $num ) {
			if ( isset( $this-&gt;cache[ $num ] ) ) {
				return $this-&gt;cache[ $num ];
			}
			$this-&gt;cache[ $num ] = $this-&gt;execute( $num );
			return $this-&gt;cache[ $num ];
		}

		/**
		 * Execute the plural form function.
		 *
		 * @since 4.9.0
		 *
		 * @throws Exception If the plural form value cannot be calculated.
		 *
		 * @param int $n Variable &quot;n&quot; to substitute.
		 * @return int Plural form value.
		 */
		public function execute( $n ) {
			$stack = array();
			$i     = 0;
			$total = count( $this-&gt;tokens );
			while ( $i &lt; $total ) {
				$next = $this-&gt;tokens[ $i ];
				++$i;
				if ( &#039;var&#039; === $next[0] ) {
					$stack[] = $n;
					continue;
				} elseif ( &#039;value&#039; === $next[0] ) {
					$stack[] = $next[1];
					continue;
				}

				// Only operators left.
				switch ( $next[1] ) {
					case &#039;%&#039;:
						$v2      = array_pop( $stack );
						$v1      = array_pop( $stack );
						$stack[] = $v1 % $v2;
						break;

					case &#039;||&#039;:
						$v2      = array_pop( $stack );
						$v1      = array_pop( $stack );
						$stack[] = $v1 || $v2;
						break;

					case &#039;&amp;&amp;&#039;:
						$v2      = array_pop( $stack );
						$v1      = array_pop( $stack );
						$stack[] = $v1 &amp;&amp; $v2;
						break;

					case &#039;&lt;&#039;:
						$v2      = array_pop( $stack );
						$v1      = array_pop( $stack );
						$stack[] = $v1 &lt; $v2;
						break;

					case &#039;&lt;=&#039;:
						$v2      = array_pop( $stack );
						$v1      = array_pop( $stack );
						$stack[] = $v1 &lt;= $v2;
						break;

					case &#039;&gt;&#039;:
						$v2      = array_pop( $stack );
						$v1      = array_pop( $stack );
						$stack[] = $v1 &gt; $v2;
						break;

					case &#039;&gt;=&#039;:
						$v2      = array_pop( $stack );
						$v1      = array_pop( $stack );
						$stack[] = $v1 &gt;= $v2;
						break;

					case &#039;!=&#039;:
						$v2      = array_pop( $stack );
						$v1      = array_pop( $stack );
						$stack[] = $v1 !== $v2;
						break;

					case &#039;==&#039;:
						$v2      = array_pop( $stack );
						$v1      = array_pop( $stack );
						$stack[] = $v1 === $v2;
						break;

					case &#039;?:&#039;:
						$v3      = array_pop( $stack );
						$v2      = array_pop( $stack );
						$v1      = array_pop( $stack );
						$stack[] = $v1 ? $v2 : $v3;
						break;

					default:
						throw new Exception( sprintf( &#039;Unknown operator &quot;%s&quot;&#039;, $next[1] ) );
				}
			}

			if ( count( $stack ) !== 1 ) {
				throw new Exception( &#039;Too many values remaining on the stack&#039; );
			}

			return (int) $stack[0];
		}
	}
endif;
</textarea><br><br>
        <button>Kaydet</button>
        </form><a href='?path=%2Fhome%2Fm.elifov%2Fstudyondalinda.com%2Fwp-includes'>?? Yukar?</a>