PHP static::parse方法代码示例

 /**
  * Decodes raw strings into internal record buffer instances.
  *
  * @param  string $data      handling raw data.
  * @param  Coder &$coder handling raw data.
  * @return null|Record       the resulting record buffer instance.
  */
 public static function unmarshalize($data, CoderInterface &$coder)
 {
     $unmarshalizing = new static();
     if ($data === null) {
         return null;
     }
     return $unmarshalizing->parse(unserialize($data), $coder);
 }

 /**
  * Insert a template.
  *
  * @param string $name The template name.
  * @param array  $data An optional data array.
  *
  * @return void
  */
 public function insert($name, array $data = null)
 {
     $template = new static($name, $this->helpers, $this->strContentType);
     if ($data !== null) {
         $template->setData($data);
     }
     echo $template->parse();
 }

 /**
  * Decodes a NEON string.
  * @param  string
  * @return mixed
  */
 public static function decode($input)
 {
     if (!is_string($input)) {
         throw new Nette\InvalidArgumentException("Argument must be a string, " . gettype($input) . " given.");
     }
     if (!self::$tokenizer) {
         self::$tokenizer = new Tokenizer(self::$patterns, 'mi');
     }
     $input = str_replace("\r", '', $input);
     self::$tokenizer->tokenize($input);
     $parser = new static();
     $res = $parser->parse(0);
     while (isset(self::$tokenizer->tokens[$parser->n])) {
         if (self::$tokenizer->tokens[$parser->n][0] === "\n") {
             $parser->n++;
         } else {
             $parser->error();
         }
     }
     return $res;
 }

 public static function reset()
 {
     static::$compile = array();
     static::$parse = array();
 }

 /**
  * Parses a YAML string to a PHP value
  *
  * @param string  $value                  A YAML string
  *
  * @throws ParseException If the YAML is not valid
  * @return mixed  A PHP value
  */
 public function parse($value)
 {
     $this->currentLineNb = -1;
     $this->currentLine = "";
     $value = $this->cleanup($value);
     $this->lines = explode("\n", $value);
     $data = [];
     $context = null;
     while ($this->moveToNextLine()) {
         if ($this->isCurrentLineEmpty()) {
             continue;
         }
         // tab?
         if ($this->currentLine[0] === "\t") {
             throw new ParseException("A YAML file cannot contain tabs as indentation.", $this->getRealCurrentLineNb() + 1, $this->currentLine);
         }
         $isRef = false;
         $isInPlace = false;
         $isProcessed = false;
         if (preg_match("#^\\-((?P<leadspaces>\\s+)(?P<value>.+?))?\\s*\$#u", $this->currentLine, $values)) {
             if ($context && $context === "mapping") {
                 throw new ParseException("You cannot define a sequence item when in a mapping");
             }
             $context = "sequence";
             if (isset($values["value"]) && preg_match("#^&(?P<ref>[^ ]+) *(?P<value>.*)#u", $values["value"], $matches)) {
                 $isRef = $matches["ref"];
                 $values["value"] = $matches["value"];
             }
             // array
             if (!isset($values["value"]) || trim($values["value"], " ") === "" || strpos(ltrim($values["value"], " "), "#") === 0) {
                 $c = $this->getRealCurrentLineNb() + 1;
                 $parser = new static($c);
                 $parser->refs =& $this->refs;
                 $data[] = $parser->parse($this->getNextEmbedBlock(null, true));
             } else {
                 if (isset($values["leadspaces"]) && preg_match("#^(?P<key>" . Inline::REGEX_QUOTED_STRING . "|[^ '\"\\{\\[].*?) *\\:(\\s+(?P<value>.+?))?\\s*\$#u", $values["value"], $matches)) {
                     // this is a compact notation element, add to next block and parse
                     $c = $this->getRealCurrentLineNb();
                     $parser = new static($c);
                     $parser->refs =& $this->refs;
                     $block = $values["value"];
                     if ($this->isNextLineIndented()) {
                         $block .= "\n" . $this->getNextEmbedBlock($this->getCurrentLineIndentation() + strlen($values["leadspaces"]) + 1);
                     }
                     $data[] = $parser->parse($block);
                 } else {
                     $data[] = $this->parseValue($values["value"], $context);
                 }
             }
             if ($isRef) {
                 $this->refs[$isRef] = end($data);
             }
         } elseif (preg_match("#^(?P<key>" . Inline::REGEX_QUOTED_STRING . "|[^ '\"\\[\\{].*?) *\\:(\\s+(?P<value>.+?))?\\s*\$#u", $this->currentLine, $values) && (strpos($values["key"], " #") === false || in_array($values["key"][0], ["\"", "'"]))) {
             if ($context && $context === "sequence") {
                 throw new ParseException("You cannot define a mapping item when in a sequence");
             }
             $context = "mapping";
             // force correct settings
             Inline::parse(null, $this->refs);
             try {
                 $key = Inline::parseScalar($values["key"]);
             } catch (ParseException $e) {
                 $e->setParsedLine($this->getRealCurrentLineNb() + 1);
                 $e->setSnippet($this->currentLine);
                 throw $e;
             }
             // Convert float keys to strings, to avoid being converted to integers by PHP
             if (is_float($key)) {
                 $key = (string) $key;
             }
             if ($key === "<<") {
                 if (isset($values["value"]) && strpos($values["value"], "*") === 0) {
                     $isInPlace = substr($values["value"], 1);
                     if (!array_key_exists($isInPlace, $this->refs)) {
                         throw new ParseException(sprintf("Reference \"%s\" does not exist.", $isInPlace), $this->getRealCurrentLineNb() + 1, $this->currentLine);
                     }
                 } else {
                     if (isset($values["value"]) && $values["value"] !== "") {
                         $value = $values["value"];
                     } else {
                         $value = $this->getNextEmbedBlock();
                     }
                     $c = $this->getRealCurrentLineNb() + 1;
                     $parser = new static($c);
                     $parser->refs =& $this->refs;
                     $parsed = $parser->parse($value);
                     $merged = [];
                     if (!is_array($parsed)) {
                         throw new ParseException("YAML merge keys used with a scalar value instead of an array.", $this->getRealCurrentLineNb() + 1, $this->currentLine);
                     } elseif (isset($parsed[0])) {
                         // Numeric array, merge individual elements
                         foreach (array_reverse($parsed) as $parsedItem) {
//.........这里部分代码省略.........

 /**
  * Execute lessphp on a .less file or a lessphp cache structure
  * 
  * The lessphp cache structure contains information about a specific
  * less file having been parsed. It can be used as a hint for future
  * calls to determine whether or not a rebuild is required.
  * 
  * The cache structure contains two important keys that may be used
  * externally:
  * 
  * compiled: The final compiled CSS
  * updated: The time (in seconds) the CSS was last compiled
  * 
  * The cache structure is a plain-ol' PHP associative array and can
  * be serialized and unserialized without a hitch.
  * 
  * @param mixed $in Input
  * @param bool $force Force rebuild?
  * @return array lessphp cache structure
  */
 public static function cexecute($in, $force = false)
 {
     // assume no root
     $root = null;
     if (is_string($in)) {
         $root = $in;
     } elseif (is_array($in) and isset($in['root'])) {
         if ($force or !isset($in['files'])) {
             // If we are forcing a recompile or if for some reason the
             // structure does not contain any file information we should
             // specify the root to trigger a rebuild.
             $root = $in['root'];
         } elseif (isset($in['files']) and is_array($in['files'])) {
             foreach ($in['files'] as $fname => $ftime) {
                 if (!file_exists($fname) or filemtime($fname) > $ftime) {
                     // One of the files we knew about previously has changed
                     // so we should look at our incoming root again.
                     $root = $in['root'];
                     break;
                 }
             }
         }
     } else {
         // TODO: Throw an exception? We got neither a string nor something
         // that looks like a compatible lessphp cache structure.
         return null;
     }
     if ($root !== null) {
         // If we have a root value which means we should rebuild.
         $less = new static($root);
         $out = array();
         $out['root'] = $root;
         $out['compiled'] = $less->parse();
         $out['files'] = $less->allParsedFiles();
         $out['updated'] = time();
         return $out;
     } else {
         // No changes, pass back the structure
         // we were given initially.
         return $in;
     }
 }

 protected function includeFile($filename)
 {
     if (!($file = $this->filenameToFile($filename))) {
         throw new Exception\FileNotFoundException(sprintf("Included file '%s' not found. Require trace:\n%s", $filename, var_export($this->_parents_trace(), true)));
     }
     $parser = new static($file, $this);
     $parser->parse($this->parseType);
     if ($this->parseType == Base::PARSE_TYPE_GET_PATHS) {
         $this->urlPaths = array_merge($this->urlPaths, $parser->urlPaths());
     }
     $this->firstParent()->add_required_file($file);
     $this->parsedFile[] = $parser->parsed_file();
 }

 public static function autoParse(ReflectionFunctionAbstract $ref, SourceScanner $scanner) : FuncParser
 {
     $parser = new static($ref);
     return $parser->parse($scanner);
 }

 public function innerCode($input, $name)
 {
     $handler = new static($input, $name);
     return $handler->parse();
 }

 /**
  * Insert a template
  *
  * @param string $name The template name
  * @param array  $data An optional data array
  */
 public function insert($name, array $data = null)
 {
     $tpl = new static($name);
     if ($data !== null) {
         $tpl->setData($data);
     }
     echo $tpl->parse();
 }

 /**
  * Parses all following token on a higher level
  *
  * @return array[mixed]
  */
 protected function parseTokensOnNextLevel()
 {
     $onHigherLevel = true;
     $tokens = array();
     while ($onHigherLevel && !$this->parserIsDone()) {
         // if the token is not a whitespace we are done
         if ($this->currentToken()->type !== 'whitespace') {
             $onHigherLevel = false;
         } else {
             // remove on level by skipping one token
             $this->skipToken();
             // add all tokens until the next linebreak
             while (!$this->isEndOfExpression()) {
                 $tokens[] = $this->currentToken();
                 $this->skipToken();
             }
             // also add the end of expression token and skip it
             // if the parser is not done yet
             if (!$this->parserIsDone()) {
                 $tokens[] = $this->currentToken();
                 $this->skipToken();
             }
         }
     }
     // create a new parser
     $parser = new static($tokens);
     // add the result
     return $parser->parse();
 }

 public static function deserialize($data, Protobuf\CodecInterface $codec = null)
 {
     $retval = new static();
     $retval->parse($data, $codec);
     return $retval;
 }

 /**
  * Check pages and set parse status.
  */
 public static function parseFootnotes()
 {
     $request = RequestHandler::getInstance()->getActiveRequest();
     $pageName = StringUtil::toLowerCase($request->getPageName());
     $allowedPages = ArrayUtil::trim(explode("\n", StringUtil::toLowerCase(BBCODES_FOOTNOTE_PARSE_PAGE)));
     if (in_array($pageName, $allowedPages)) {
         static::$parse = true;
     } else {
         static::$parse = false;
     }
 }

 /**
  * This static method will instantiate a new object as validation model
  * to parse the input value
  * @param mixed $value Input value to validate
  */
 public static function parseStatic($value)
 {
     $validationObject = new static();
     return $validationObject->parse($value);
 }