1 <?php

     2 /*

     3  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

     4  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

     5  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

     6  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

     7  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

     8  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

     9  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

    10  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

    11  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    12  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

    13  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    14  *

    15  * This software consists of voluntary contributions made by many individuals

    16  * and is licensed under the LGPL. For more information, see

    17  * <http://www.doctrine-project.org>.

    18  */

    19 

    20 namespace Doctrine\Common\Annotations;

    21 

    22 use Doctrine\Common\Lexer;

    23 

    24 /**

    25  * Simple lexer for docblock annotations.

    26  *

    27  * @author Benjamin Eberlei <kontakt@beberlei.de>

    28  * @author Guilherme Blanco <guilhermeblanco@hotmail.com>

    29  * @author Jonathan Wage <jonwage@gmail.com>

    30  * @author Roman Borschel <roman@code-factory.org>

    31  * @author Johannes M. Schmitt <schmittjoh@gmail.com>

    32  */

    33 final class DocLexer extends Lexer

    34 {

    35     const T_NONE                = 1;

    36     const T_IDENTIFIER          = 2;

    37     const T_INTEGER             = 3;

    38     const T_STRING              = 4;

    39     const T_FLOAT               = 5;

    40 

    41     const T_AT                  = 101;

    42     const T_CLOSE_CURLY_BRACES  = 102;

    43     const T_CLOSE_PARENTHESIS   = 103;

    44     const T_COMMA               = 104;

    45     const T_EQUALS              = 105;

    46     const T_FALSE               = 106;

    47     const T_NAMESPACE_SEPARATOR = 107;

    48     const T_OPEN_CURLY_BRACES   = 108;

    49     const T_OPEN_PARENTHESIS    = 109;

    50     const T_TRUE                = 110;

    51     const T_NULL                = 111;

    52 

    53     /**

    54      * @inheritdoc

    55      */

    56     protected function getCatchablePatterns()

    57     {

    58         return array(

    59             '[a-z_][a-z0-9_:]*',

    60             '(?:[0-9]+(?:[\.][0-9]+)*)(?:e[+-]?[0-9]+)?',

    61             '"(?:[^"]|"")*"',

    62         );

    63     }

    64 

    65     /**

    66      * @inheritdoc

    67      */

    68     protected function getNonCatchablePatterns()

    69     {

    70         return array('\s+', '\*+', '(.)');

    71     }

    72 

    73     /**

    74      * @inheritdoc

    75      */

    76     protected function getType(&$value)

    77     {

    78         $type = self::T_NONE;

    79 

    80         // Checking numeric value

    81         if (is_numeric($value)) {

    82             return (strpos($value, '.') !== false || stripos($value, 'e') !== false)

    83                 ? self::T_FLOAT : self::T_INTEGER;

    84         }

    85 

    86         if ($value[0] === '"') {

    87             $value = str_replace('""', '"', substr($value, 1, strlen($value) - 2));

    88 

    89             return self::T_STRING;

    90         } else {

    91             switch (strtolower($value)) {

    92                 case '@':

    93                     return self::T_AT;

    94 

    95                 case ',':

    96                     return self::T_COMMA;

    97 

    98                 case '(':

    99                     return self::T_OPEN_PARENTHESIS;

   100 

   101                 case ')':

   102                     return self::T_CLOSE_PARENTHESIS;

   103 

   104                 case '{':

   105                     return self::T_OPEN_CURLY_BRACES;

   106 

   107                 case '}':

   108                     return self::T_CLOSE_CURLY_BRACES;

   109 

   110                 case '=':

   111                     return self::T_EQUALS;

   112 

   113                 case '\\':

   114                     return self::T_NAMESPACE_SEPARATOR;

   115 

   116                 case 'true':

   117                     return self::T_TRUE;

   118 

   119                 case 'false':

   120                     return self::T_FALSE;

   121 

   122                 case 'null':

   123                     return self::T_NULL;

   124 

   125                 default:

   126                     if (ctype_alpha($value[0]) || $value[0] === '_') {

   127                         return self::T_IDENTIFIER;

   128                     }

   129 

   130                     break;

   131             }

   132         }

   133 

   134         return $type;

   135     }

   136 }