Source for file Tokenizer.php

Documentation is available at Tokenizer.php

  1. <?php
  2. /*
  3.  *  $Id: From.php 1080 2007-02-10 18:17:08Z romanb $
  4.  *
  5.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  6.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  7.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  8.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  9.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  10.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  11.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  12.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  13.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  14.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  15.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  16.  *
  17.  * This software consists of voluntary contributions made by many individuals
  18.  * and is licensed under the LGPL. For more information, see
  19.  * <http://www.phpdoctrine.com>.
  20.  */
  21.  
  22. /**
  23.  * Doctrine_Tokenizer
  24.  *
  25.  * @package     Doctrine
  26.  * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
  27.  * @category    Object Relational Mapping
  28.  * @link        www.phpdoctrine.com
  29.  * @since       1.0
  30.  * @version     $Revision: 1080 $
  31.  * @author      Konsta Vesterinen <kvesteri@cc.hut.fi>
  32.  */
  33. {
  34.     public function __construct(
  35.     {
  36.         
  37.     }
  38.     public function tokenize(
  39.     {
  40.  
  41.     }
  42.     /**
  43.      * trims brackets
  44.      *
  45.      * @param string $str 
  46.      * @param string $e1        the first bracket, usually '('
  47.      * @param string $e2        the second bracket, usually ')'
  48.      */
  49.     public static function bracketTrim($str$e1 '('$e2 ')')
  50.     {
  51.         if (substr($str01=== $e1 && substr($str-1=== $e2{
  52.             return substr($str1-1);
  53.         else {
  54.             return $str;
  55.         }
  56.     }
  57.     /**
  58.      * bracketExplode
  59.      *
  60.      * example:
  61.      *
  62.      * parameters:
  63.      *      $str = (age < 20 AND age > 18) AND email LIKE 'John@example.com'
  64.      *      $d = ' AND '
  65.      *      $e1 = '('
  66.      *      $e2 = ')'
  67.      *
  68.      * would return an array:
  69.      *      array("(age < 20 AND age > 18)",
  70.      *            "email LIKE 'John@example.com'")
  71.      *
  72.      * @param string $str 
  73.      * @param string $d         the delimeter which explodes the string
  74.      * @param string $e1        the first bracket, usually '('
  75.      * @param string $e2        the second bracket, usually ')'
  76.      *
  77.      */
  78.     public static function bracketExplode($str$d ' '$e1 '('$e2 ')')
  79.     {
  80.         if(is_array($d)) {
  81.             $a preg_split('/('.implode('|'$d).')/'$str);
  82.             $d stripslashes($d[0]);
  83.         else {
  84.             $a explode($d$str);
  85.         }
  86.  
  87.         $i 0;
  88.         $term array();
  89.         foreach($a as $key=>$val{
  90.             if (empty($term[$i])) {
  91.                 $term[$itrim($val);
  92.                 $s1 substr_count($term[$i]$e1);
  93.                 $s2 substr_count($term[$i]$e2);
  94.                 
  95.                 if($s1 == $s2{
  96.                     $i++;
  97.                 }
  98.             else {
  99.                 $term[$i.= $d trim($val);
  100.                 $c1 substr_count($term[$i]$e1);
  101.                 $c2 substr_count($term[$i]$e2);
  102.                 
  103.                 if($c1 == $c2
  104.                     $i++;
  105.                 }
  106.             }
  107.         }
  108.         return $term;
  109.     }
  110.     /**
  111.      * quoteExplode
  112.      *
  113.      * example:
  114.      *
  115.      * parameters:
  116.      *      $str = email LIKE 'John@example.com'
  117.      *      $d = ' AND '
  118.      *
  119.      * would return an array:
  120.      *      array("email", "LIKE", "'John@example.com'")
  121.      *
  122.      * @param string $str 
  123.      * @param string $d         the delimeter which explodes the string
  124.      */
  125.     public static function quoteExplode($str$d ' ')
  126.     {
  127.         if (is_array($d)) {
  128.             $a preg_split('/('.implode('|'$d).')/'$str);
  129.             $d stripslashes($d[0]);
  130.         else {
  131.             $a explode($d$str);
  132.         }
  133.  
  134.         $i 0;
  135.         $term array();
  136.         foreach ($a as $key => $val{
  137.             if (empty($term[$i])) {
  138.                 $term[$itrim($val);
  139.  
  140.                 if (substr_count($term[$i]"'"1)) {
  141.                     $i++;
  142.                 }
  143.             else {
  144.                 $term[$i.= $d trim($val);
  145.  
  146.                 if (substr_count($term[$i]"'"1)) {
  147.                     $i++;
  148.                 }
  149.             }
  150.         }
  151.         return $term;
  152.     }
  153.     /**
  154.      * sqlExplode
  155.      *
  156.      * explodes a string into array using custom brackets and
  157.      * quote delimeters
  158.      *
  159.      *
  160.      * example:
  161.      *
  162.      * parameters:
  163.      *      $str = "(age < 20 AND age > 18) AND name LIKE 'John Doe'"
  164.      *      $d   = ' '
  165.      *      $e1  = '('
  166.      *      $e2  = ')'
  167.      *
  168.      * would return an array:
  169.      *      array('(age < 20 AND age > 18)',
  170.      *            'name',
  171.      *            'LIKE',
  172.      *            'John Doe')
  173.      *
  174.      * @param string $str 
  175.      * @param string $d         the delimeter which explodes the string
  176.      * @param string $e1        the first bracket, usually '('
  177.      * @param string $e2        the second bracket, usually ')'
  178.      *
  179.      * @return array 
  180.      */
  181.     public static function sqlExplode($str$d ' '$e1 '('$e2 ')')
  182.     {
  183.         if ($d == ' '{
  184.             $d array(' ''\s');
  185.         }
  186.         if (is_array($d)) {
  187.             $d array_map('preg_quote'$d);
  188.  
  189.             if (in_array(' '$d)) {
  190.                 $d['\s';
  191.             }
  192.  
  193.             $split '§(' implode('|'$d')§';
  194.  
  195.             $str preg_split($split$str);
  196.             $d stripslashes($d[0]);
  197.         else {
  198.             $str explode($d$str);
  199.         }
  200.  
  201.         $i 0;
  202.         $term array();
  203.  
  204.         foreach ($str as $key => $val{
  205.             if (empty($term[$i])) {
  206.                 $term[$itrim($val);
  207.  
  208.                 $s1 substr_count($term[$i]$e1);
  209.                 $s2 substr_count($term[$i]$e2);
  210.  
  211.                 if (strpos($term[$i]'('!== false{
  212.                     if($s1 == $s2{
  213.                         $i++;
  214.                     }
  215.                 else {
  216.                     if (substr_count($term[$i]"'"1&&
  217.                          (substr_count($term[$i]"\""1)) {
  218.                         $i++;
  219.                     }
  220.                 }
  221.             else {
  222.                 $term[$i.= $d trim($val);
  223.                 $c1 substr_count($term[$i]$e1);
  224.                 $c2 substr_count($term[$i]$e2);
  225.  
  226.                 if (strpos($term[$i]'('!== false{
  227.                     if($c1 == $c2{
  228.                         $i++;
  229.                     }
  230.                 else {
  231.                     if (substr_count($term[$i]"'"1&&
  232.                          (substr_count($term[$i]"\""1)) {
  233.                         $i++;
  234.                     }
  235.                 }
  236.             }
  237.         }
  238.         return $term;
  239.     }
  240.     /**
  241.      * clauseExplode
  242.      *
  243.      * explodes a string into array using custom brackets and
  244.      * quote delimeters
  245.      *
  246.      *
  247.      * example:
  248.      *
  249.      * parameters:
  250.      *      $str = "(age < 20 AND age > 18) AND name LIKE 'John Doe'"
  251.      *      $d   = ' '
  252.      *      $e1  = '('
  253.      *      $e2  = ')'
  254.      *
  255.      * would return an array:
  256.      *      array('(age < 20 AND age > 18)',
  257.      *            'name',
  258.      *            'LIKE',
  259.      *            'John Doe')
  260.      *
  261.      * @param string $str 
  262.      * @param string $d         the delimeter which explodes the string
  263.      * @param string $e1        the first bracket, usually '('
  264.      * @param string $e2        the second bracket, usually ')'
  265.      *
  266.      * @return array 
  267.      */
  268.     public static function clauseExplode($strarray $d$e1 '('$e2 ')')
  269.     {
  270.         if (is_array($d)) {
  271.             $d array_map('preg_quote'$d);
  272.  
  273.             if (in_array(' '$d)) {
  274.                 $d['\s';
  275.             }
  276.  
  277.             $split '§(' implode('|'$d')§';
  278.  
  279.             $str preg_split($split$str-1PREG_SPLIT_DELIM_CAPTURE);
  280.         }
  281.  
  282.         $i 0;
  283.         $term array();
  284.  
  285.         foreach ($str as $key => $val{
  286.             if ($key 1{
  287.                 if (isset($term[($i 1)]&& is_array($term[($i 1)])) {
  288.                     $term[($i 1)array($term[($i 1)]$val);
  289.                 }
  290.                 continue;
  291.             }
  292.             if (empty($term[$i])) {
  293.                 $term[$i$val;
  294.             else {
  295.                 $term[$i.= $str[($key 1)$val;
  296.             }
  297.  
  298.             $c1 substr_count($term[$i]$e1);
  299.             $c2 substr_count($term[$i]$e2);
  300.  
  301.             if (strpos($term[$i]'('!== false{
  302.                 if($c1 == $c2{
  303.                     $i++;
  304.                 }
  305.             else {
  306.                 if (substr_count($term[$i]"'"1&&
  307.                      (substr_count($term[$i]"\""1)) {
  308.                     $i++;
  309.                 }
  310.             }
  311.         }
  312.         $term[$i 1array($term[$i 1]'');
  313.  
  314.         return $term;
  315.     }
  316. }