www/plugins/yaml/spyc/spyc-php4.php

   1 <?php
   2 /**
   3    * Spyc -- A Simple PHP YAML Class
   4    * @version 0.4.5
   5    * @author Vlad Andersen <vlad.andersen@gmail.com>
   6    * @author Chris Wanstrath <chris@ozmm.org>
   7    * @link http://code.google.com/p/spyc/
   8    * @copyright Copyright 2005-2006 Chris Wanstrath, 2006-2009 Vlad Andersen
   9    * @license http://www.opensource.org/licenses/mit-license.php MIT License
  10    * @package Spyc
  11    */
  12
  13 if (!function_exists('spyc_load')) {
  14   /**
  15    * Parses YAML to array.
  16    * @param string $string YAML string.
  17    * @return array
  18    */
  19   function spyc_load ($string) {
  20     return Spyc::YAMLLoadString($string);
  21   }
  22 }
  23
  24 if (!function_exists('spyc_load_file')) {
  25   /**
  26    * Parses YAML to array.
  27    * @param string $file Path to YAML file.
  28    * @return array
  29    */
  30   function spyc_load_file ($file) {
  31     return Spyc::YAMLLoad($file);
  32   }
  33 }
  34
  35 /**
  36    * The Simple PHP YAML Class.
  37    *
  38    * This class can be used to read a YAML file and convert its contents
  39    * into a PHP array.  It currently supports a very limited subsection of
  40    * the YAML spec.
  41    *
  42    * Usage:
  43    * <code>
  44    *   $Spyc  = new Spyc;
  45    *   $array = $Spyc->load($file);
  46    * </code>
  47    * or:
  48    * <code>
  49    *   $array = Spyc::YAMLLoad($file);
  50    * </code>
  51    * or:
  52    * <code>
  53    *   $array = spyc_load_file($file);
  54    * </code>
  55    * @package Spyc
  56    */
  57 class Spyc {
  58
  59   // SETTINGS
  60
  61   /**
  62    * Setting this to true will force YAMLDump to enclose any string value in
  63    * quotes.  False by default.
  64    *
  65    * @var bool
  66    */
  67   var $setting_dump_force_quotes = false;
  68
  69   /**
  70    * Setting this to true will forse YAMLLoad to use syck_load function when
  71    * possible. False by default.
  72    * @var bool
  73    */
  74   var $setting_use_syck_is_possible = false;
  75
  76
  77
  78   /**#@+
  79   * @access private
  80   * @var mixed
  81   */
  82   var $_dumpIndent;
  83   var $_dumpWordWrap;
  84   var $_containsGroupAnchor = false;
  85   var $_containsGroupAlias = false;
  86   var $path;
  87   var $result;
  88   var $LiteralPlaceHolder = '___YAML_Literal_Block___';
  89   var $SavedGroups = array();
  90   var $indent;
  91   /**
  92    * Path modifier that should be applied after adding current element.
  93    * @var array
  94    */
  95   var $delayedPath = array();
  96
  97   /**#@+
  98   * @access public
  99   * @var mixed
 100   */
 101   var $_nodeId;
 102
 103 /**
 104  * Load a valid YAML string to Spyc.
 105  * @param string $input
 106  * @return array
 107  */
 108   function load ($input) {
 109     return $this->__loadString($input);
 110   }
 111
 112  /**
 113  * Load a valid YAML file to Spyc.
 114  * @param string $file
 115  * @return array
 116  */
 117   function loadFile ($file) {
 118     return $this->__load($file);
 119   }
 120
 121   /**
 122      * Load YAML into a PHP array statically
 123      *
 124      * The load method, when supplied with a YAML stream (string or file),
 125      * will do its best to convert YAML in a file into a PHP array.  Pretty
 126      * simple.
 127      *  Usage:
 128      *  <code>
 129      *   $array = Spyc::YAMLLoad('lucky.yaml');
 130      *   print_r($array);
 131      *  </code>
 132      * @access public
 133      * @return array
 134      * @param string $input Path of YAML file or string containing YAML
 135      */
 136   function YAMLLoad($input) {
 137     $Spyc = new Spyc;
 138     return $Spyc->__load($input);
 139   }
 140
 141   /**
 142      * Load a string of YAML into a PHP array statically
 143      *
 144      * The load method, when supplied with a YAML string, will do its best
 145      * to convert YAML in a string into a PHP array.  Pretty simple.
 146      *
 147      * Note: use this function if you don't want files from the file system
 148      * loaded and processed as YAML.  This is of interest to people concerned
 149      * about security whose input is from a string.
 150      *
 151      *  Usage:
 152      *  <code>
 153      *   $array = Spyc::YAMLLoadString("---\n0: hello world\n");
 154      *   print_r($array);
 155      *  </code>
 156      * @access public
 157      * @return array
 158      * @param string $input String containing YAML
 159      */
 160   function YAMLLoadString($input) {
 161     $Spyc = new Spyc;
 162     return $Spyc->__loadString($input);
 163   }
 164
 165   /**
 166      * Dump YAML from PHP array statically
 167      *
 168      * The dump method, when supplied with an array, will do its best
 169      * to convert the array into friendly YAML.  Pretty simple.  Feel free to
 170      * save the returned string as nothing.yaml and pass it around.
 171      *
 172      * Oh, and you can decide how big the indent is and what the wordwrap
 173      * for folding is.  Pretty cool -- just pass in 'false' for either if
 174      * you want to use the default.
 175      *
 176      * Indent's default is 2 spaces, wordwrap's default is 40 characters.  And
 177      * you can turn off wordwrap by passing in 0.
 178      *
 179      * @access public
 180      * @return string
 181      * @param array $array PHP array
 182      * @param int $indent Pass in false to use the default, which is 2
 183      * @param int $wordwrap Pass in 0 for no wordwrap, false for default (40)
 184      */
 185   function YAMLDump($array,$indent = false,$wordwrap = false) {
 186     $spyc = new Spyc;
 187     return $spyc->dump($array,$indent,$wordwrap);
 188   }
 189
 190
 191   /**
 192      * Dump PHP array to YAML
 193      *
 194      * The dump method, when supplied with an array, will do its best
 195      * to convert the array into friendly YAML.  Pretty simple.  Feel free to
 196      * save the returned string as tasteful.yaml and pass it around.
 197      *
 198      * Oh, and you can decide how big the indent is and what the wordwrap
 199      * for folding is.  Pretty cool -- just pass in 'false' for either if
 200      * you want to use the default.
 201      *
 202      * Indent's default is 2 spaces, wordwrap's default is 40 characters.  And
 203      * you can turn off wordwrap by passing in 0.
 204      *
 205      * @access public
 206      * @return string
 207      * @param array $array PHP array
 208      * @param int $indent Pass in false to use the default, which is 2
 209      * @param int $wordwrap Pass in 0 for no wordwrap, false for default (40)
 210      */
 211   function dump($array,$indent = false,$wordwrap = false) {
 212     // Dumps to some very clean YAML.  We'll have to add some more features
 213     // and options soon.  And better support for folding.
 214
 215     // New features and options.
 216     if ($indent === false or !is_numeric($indent)) {
 217       $this->_dumpIndent = 2;
 218     } else {
 219       $this->_dumpIndent = $indent;
 220     }
 221
 222     if ($wordwrap === false or !is_numeric($wordwrap)) {
 223       $this->_dumpWordWrap = 40;
 224     } else {
 225       $this->_dumpWordWrap = $wordwrap;
 226     }
 227
 228     // New YAML document
 229     $string = "---\n";
 230
 231     // Start at the base of the array and move through it.
 232     if ($array) {
 233       $array = (array)$array;
 234       $first_key = key($array);
 235
 236       $previous_key = -1;
 237       foreach ($array as $key => $value) {
 238         $string .= $this->_yamlize($key,$value,0,$previous_key, $first_key);
 239         $previous_key = $key;
 240       }
 241     }
 242     return $string;
 243   }
 244
 245   /**
 246      * Attempts to convert a key / value array item to YAML
 247      * @access private
 248      * @return string
 249      * @param $key The name of the key
 250      * @param $value The value of the item
 251      * @param $indent The indent of the current node
 252      */
 253   function _yamlize($key,$value,$indent, $previous_key = -1, $first_key = 0) {
 254     if (is_array($value)) {
 255       if (empty ($value))
 256         return $this->_dumpNode($key, array(), $indent, $previous_key, $first_key);
 257       // It has children.  What to do?
 258       // Make it the right kind of item
 259       $string = $this->_dumpNode($key, NULL, $indent, $previous_key, $first_key);
 260       // Add the indent
 261       $indent += $this->_dumpIndent;
 262       // Yamlize the array
 263       $string .= $this->_yamlizeArray($value,$indent);
 264     } elseif (!is_array($value)) {
 265       // It doesn't have children.  Yip.
 266       $string = $this->_dumpNode($key, $value, $indent, $previous_key, $first_key);
 267     }
 268     return $string;
 269   }
 270
 271   /**
 272      * Attempts to convert an array to YAML
 273      * @access private
 274      * @return string
 275      * @param $array The array you want to convert
 276      * @param $indent The indent of the current level
 277      */
 278   function _yamlizeArray($array,$indent) {
 279     if (is_array($array)) {
 280       $string = '';
 281       $previous_key = -1;
 282       $first_key = key($array);
 283       foreach ($array as $key => $value) {
 284         $string .= $this->_yamlize($key, $value, $indent, $previous_key, $first_key);
 285         $previous_key = $key;
 286       }
 287       return $string;
 288     } else {
 289       return false;
 290     }
 291   }
 292
 293   /**
 294      * Returns YAML from a key and a value
 295      * @access private
 296      * @return string
 297      * @param $key The name of the key
 298      * @param $value The value of the item
 299      * @param $indent The indent of the current node
 300      */
 301   function _dumpNode($key, $value, $indent, $previous_key = -1, $first_key = 0) {
 302     // do some folding here, for blocks
 303     if (is_string ($value) && ((strpos($value,"\n") !== false || strpos($value,": ") !== false || strpos($value,"- ") !== false ||
 304       strpos($value,"*") !== false || strpos($value,"#") !== false || strpos($value,"<") !== false || strpos($value,">") !== false ||
 305       strpos($value,"[") !== false || strpos($value,"]") !== false || strpos($value,"{") !== false || strpos($value,"}") !== false) || substr ($value, -1, 1) == ':')) {
 306       $value = $this->_doLiteralBlock($value,$indent);
 307     } else {
 308       $value  = $this->_doFolding($value,$indent);
 309       if (is_bool($value)) {
 310         $value = ($value) ? "true" : "false";
 311       }
 312     }
 313
 314     if ($value === array()) $value = '[ ]';
 315
 316     $spaces = str_repeat(' ',$indent);
 317
 318     if (is_int($key) && $key - 1 == $previous_key && $first_key===0) {
 319       // It's a sequence
 320       $string = $spaces.'- '.$value."\n";
 321     } else {
 322       // Ligne ci-dessous désactivée car non compatible PHP4
 323           //if ($first_key===0)  throw new Exception('Keys are all screwy.  The first one was zero, now it\'s "'. $key .'"');
 324       // It's mapped
 325       if (strpos($key, ":") !== false) { $key = '"' . $key . '"'; }
 326       $string = $spaces.$key.': '.$value."\n";
 327     }
 328     return $string;
 329   }
 330
 331   /**
 332      * Creates a literal block for dumping
 333      * @access private
 334      * @return string
 335      * @param $value
 336      * @param $indent int The value of the indent
 337      */
 338   function _doLiteralBlock($value,$indent) {
 339     if (strpos($value, "\n") === false && strpos($value, "'") === false) {
 340       return sprintf ("'%s'", $value);
 341     }
 342     if (strpos($value, "\n") === false && strpos($value, '"') === false) {
 343       return sprintf ('"%s"', $value);
 344     }
 345     $exploded = explode("\n",$value);
 346     $newValue = '|';
 347     $indent  += $this->_dumpIndent;
 348     $spaces   = str_repeat(' ',$indent);
 349     foreach ($exploded as $line) {
 350       $newValue .= "\n" . $spaces . trim($line);
 351     }
 352     return $newValue;
 353   }
 354
 355   /**
 356      * Folds a string of text, if necessary
 357      * @access private
 358      * @return string
 359      * @param $value The string you wish to fold
 360      */
 361   function _doFolding($value,$indent) {
 362     // Don't do anything if wordwrap is set to 0
 363
 364     if ($this->_dumpWordWrap !== 0 && is_string ($value) && strlen($value) > $this->_dumpWordWrap) {
 365       $indent += $this->_dumpIndent;
 366       $indent = str_repeat(' ',$indent);
 367       $wrapped = wordwrap($value,$this->_dumpWordWrap,"\n$indent");
 368       $value   = ">\n".$indent.$wrapped;
 369     } else {
 370       if ($this->setting_dump_force_quotes && is_string ($value))
 371         $value = '"' . $value . '"';
 372     }
 373
 374
 375     return $value;
 376   }
 377
 378 // LOADING FUNCTIONS
 379
 380   function __load($input) {
 381     $Source = $this->loadFromSource($input);
 382     return $this->loadWithSource($Source);
 383   }
 384
 385   function __loadString($input) {
 386     $Source = $this->loadFromString($input);
 387     return $this->loadWithSource($Source);
 388   }
 389
 390   function loadWithSource($Source) {
 391     if (empty ($Source)) return array();
 392     if ($this->setting_use_syck_is_possible && function_exists ('syck_load')) {
 393       $array = syck_load (implode ('', $Source));
 394       return is_array($array) ? $array : array();
 395     }
 396
 397     $this->path = array();
 398     $this->result = array();
 399
 400     $cnt = count($Source);
 401     for ($i = 0; $i < $cnt; $i++) {
 402       $line = $Source[$i];
 403
 404       $this->indent = strlen($line) - strlen(ltrim($line));
 405       $tempPath = $this->getParentPathByIndent($this->indent);
 406       $line = $this->stripIndent($line, $this->indent);
 407       if ($this->isComment($line)) continue;
 408       if ($this->isEmpty($line)) continue;
 409       $this->path = $tempPath;
 410
 411       $literalBlockStyle = $this->startsLiteralBlock($line);
 412       if ($literalBlockStyle) {
 413         $line = rtrim ($line, $literalBlockStyle . " \n");
 414         $literalBlock = '';
 415         $line .= $this->LiteralPlaceHolder;
 416
 417         while (++$i < $cnt && $this->literalBlockContinues($Source[$i], $this->indent)) {
 418           $literalBlock = $this->addLiteralLine($literalBlock, $Source[$i], $literalBlockStyle);
 419         }
 420         $i--;
 421       }
 422
 423       while (++$i < $cnt && $this->greedilyNeedNextLine($line)) {
 424         $line = rtrim ($line, " \n\t\r") . ' ' . ltrim ($Source[$i], " \t");
 425       }
 426       $i--;
 427
 428
 429
 430       if (strpos ($line, '#')) {
 431         if (strpos ($line, '"') === false && strpos ($line, "'") === false)
 432           $line = preg_replace('/\s+#(.+)$/','',$line);
 433       }
 434
 435       $lineArray = $this->_parseLine($line);
 436
 437       if ($literalBlockStyle)
 438         $lineArray = $this->revertLiteralPlaceHolder ($lineArray, $literalBlock);
 439
 440       $this->addArray($lineArray, $this->indent);
 441
 442       foreach ($this->delayedPath as $indent => $delayedPath)
 443         $this->path[$indent] = $delayedPath;
 444
 445       $this->delayedPath = array();
 446
 447     }
 448     return $this->result;
 449   }
 450
 451   function loadFromSource ($input) {
 452     if (!empty($input) && strpos($input, "\n") === false && file_exists($input))
 453     return file($input);
 454
 455     return $this->loadFromString($input);
 456   }
 457
 458   function loadFromString ($input) {
 459     $lines = explode("\n",$input);
 460     foreach ($lines as $k => $_) {
 461       $lines[$k] = rtrim ($_, "\r");
 462     }
 463     return $lines;
 464   }
 465
 466   /**
 467      * Parses YAML code and returns an array for a node
 468      * @access private
 469      * @return array
 470      * @param string $line A line from the YAML file
 471      */
 472   function _parseLine($line) {
 473     if (!$line) return array();
 474     $line = trim($line);
 475
 476     if (!$line) return array();
 477     $array = array();
 478
 479     $group = $this->nodeContainsGroup($line);
 480     if ($group) {
 481       $this->addGroup($line, $group);
 482       $line = $this->stripGroup ($line, $group);
 483     }
 484
 485     if ($this->startsMappedSequence($line))
 486       return $this->returnMappedSequence($line);
 487
 488     if ($this->startsMappedValue($line))
 489       return $this->returnMappedValue($line);
 490
 491     if ($this->isArrayElement($line))
 492      return $this->returnArrayElement($line);
 493
 494     if ($this->isPlainArray($line))
 495      return $this->returnPlainArray($line);
 496
 497
 498     return $this->returnKeyValuePair($line);
 499
 500   }
 501
 502   /**
 503      * Finds the type of the passed value, returns the value as the new type.
 504      * @access private
 505      * @param string $value
 506      * @return mixed
 507      */
 508   function _toType($value) {
 509     if ($value === '') return null;
 510     $first_character = $value[0];
 511     $last_character = substr($value, -1, 1);
 512
 513     $is_quoted = false;
 514     do {
 515       if (!$value) break;
 516       if ($first_character != '"' && $first_character != "'") break;
 517       if ($last_character != '"' && $last_character != "'") break;
 518       $is_quoted = true;
 519     } while (0);
 520
 521     if ($is_quoted)
 522       return strtr(substr ($value, 1, -1), array ('\\"' => '"', '\'\'' => '\'', '\\\'' => '\''));
 523
 524     if (strpos($value, ' #') !== false)
 525       $value = preg_replace('/\s+#(.+)$/','',$value);
 526
 527     if ($first_character == '[' && $last_character == ']') {
 528       // Take out strings sequences and mappings
 529       $innerValue = trim(substr ($value, 1, -1));
 530       if ($innerValue === '') return array();
 531       $explode = $this->_inlineEscape($innerValue);
 532       // Propagate value array
 533       $value  = array();
 534       foreach ($explode as $v) {
 535         $value[] = $this->_toType($v);
 536       }
 537       return $value;
 538     }
 539
 540     if (strpos($value,': ')!==false && $first_character != '{') {
 541       $array = explode(': ',$value);
 542       $key   = trim($array[0]);
 543       array_shift($array);
 544       $value = trim(implode(': ',$array));
 545       $value = $this->_toType($value);
 546       return array($key => $value);
 547     }
 548
 549     if ($first_character == '{' && $last_character == '}') {
 550       $innerValue = trim(substr ($value, 1, -1));
 551       if ($innerValue === '') return array();
 552       // Inline Mapping
 553       // Take out strings sequences and mappings
 554       $explode = $this->_inlineEscape($innerValue);
 555       // Propagate value array
 556       $array = array();
 557       foreach ($explode as $v) {
 558         $SubArr = $this->_toType($v);
 559         if (empty($SubArr)) continue;
 560         if (is_array ($SubArr)) {
 561           $array[key($SubArr)] = $SubArr[key($SubArr)]; continue;
 562         }
 563         $array[] = $SubArr;
 564       }
 565       return $array;
 566     }
 567
 568     if ($value == 'null' || $value == 'NULL' || $value == 'Null' || $value == '' || $value == '~') {
 569       return null;
 570     }
 571
 572     if (intval($first_character) > 0 && preg_match ('/^[1-9]+[0-9]*$/', $value)) {
 573       $intvalue = (int)$value;
 574       if ($intvalue != PHP_INT_MAX)
 575         $value = $intvalue;
 576       return $value;
 577     }
 578
 579     if (in_array($value,
 580                  array('true', 'on', '+', 'yes', 'y', 'True', 'TRUE', 'On', 'ON', 'YES', 'Yes', 'Y'))) {
 581       return true;
 582     }
 583
 584     if (in_array(strtolower($value),
 585                  array('false', 'off', '-', 'no', 'n'))) {
 586       return false;
 587     }
 588
 589     if (is_numeric($value)) {
 590       if ($value === '0') return 0;
 591       if (trim ($value, 0) === $value)
 592         $value = (float)$value;
 593       return $value;
 594     }
 595
 596     return $value;
 597   }
 598
 599   /**
 600      * Used in inlines to check for more inlines or quoted strings
 601      * @access private
 602      * @return array
 603      */
 604   function _inlineEscape($inline) {
 605     // There's gotta be a cleaner way to do this...
 606     // While pure sequences seem to be nesting just fine,
 607     // pure mappings and mappings with sequences inside can't go very
 608     // deep.  This needs to be fixed.
 609
 610     $seqs = array();
 611     $maps = array();
 612     $saved_strings = array();
 613
 614     // Check for strings
 615     $regex = '/(?:(")|(?:\'))((?(1)[^"]+|[^\']+))(?(1)"|\')/';
 616     if (preg_match_all($regex,$inline,$strings)) {
 617       $saved_strings = $strings[0];
 618       $inline  = preg_replace($regex,'YAMLString',$inline);
 619     }
 620     unset($regex);
 621
 622     $i = 0;
 623     do {
 624
 625     // Check for sequences
 626     while (preg_match('/\[([^{}\[\]]+)\]/U',$inline,$matchseqs)) {
 627       $seqs[] = $matchseqs[0];
 628       $inline = preg_replace('/\[([^{}\[\]]+)\]/U', ('YAMLSeq' . (count($seqs) - 1) . 's'), $inline, 1);
 629     }
 630
 631     // Check for mappings
 632     while (preg_match('/{([^\[\]{}]+)}/U',$inline,$matchmaps)) {
 633       $maps[] = $matchmaps[0];
 634       $inline = preg_replace('/{([^\[\]{}]+)}/U', ('YAMLMap' . (count($maps) - 1) . 's'), $inline, 1);
 635     }
 636
 637     if ($i++ >= 10) break;
 638
 639     } while (strpos ($inline, '[') !== false || strpos ($inline, '{') !== false);
 640
 641     $explode = explode(', ',$inline);
 642     $stringi = 0; $i = 0;
 643
 644     while (1) {
 645
 646     // Re-add the sequences
 647     if (!empty($seqs)) {
 648       foreach ($explode as $key => $value) {
 649         if (strpos($value,'YAMLSeq') !== false) {
 650           foreach ($seqs as $seqk => $seq) {
 651             $explode[$key] = str_replace(('YAMLSeq'.$seqk.'s'),$seq,$value);
 652             $value = $explode[$key];
 653           }
 654         }
 655       }
 656     }
 657
 658     // Re-add the mappings
 659     if (!empty($maps)) {
 660       foreach ($explode as $key => $value) {
 661         if (strpos($value,'YAMLMap') !== false) {
 662           foreach ($maps as $mapk => $map) {
 663             $explode[$key] = str_replace(('YAMLMap'.$mapk.'s'), $map, $value);
 664             $value = $explode[$key];
 665           }
 666         }
 667       }
 668     }
 669
 670
 671     // Re-add the strings
 672     if (!empty($saved_strings)) {
 673       foreach ($explode as $key => $value) {
 674         while (strpos($value,'YAMLString') !== false) {
 675           $explode[$key] = preg_replace('/YAMLString/',$saved_strings[$stringi],$value, 1);
 676           unset($saved_strings[$stringi]);
 677           ++$stringi;
 678           $value = $explode[$key];
 679         }
 680       }
 681     }
 682
 683     $finished = true;
 684     foreach ($explode as $key => $value) {
 685       if (strpos($value,'YAMLSeq') !== false) {
 686         $finished = false; break;
 687       }
 688       if (strpos($value,'YAMLMap') !== false) {
 689         $finished = false; break;
 690       }
 691       if (strpos($value,'YAMLString') !== false) {
 692         $finished = false; break;
 693       }
 694     }
 695     if ($finished) break;
 696
 697     $i++;
 698     if ($i > 10)
 699       break; // Prevent infinite loops.
 700     }
 701
 702     return $explode;
 703   }
 704
 705   function literalBlockContinues ($line, $lineIndent) {
 706     if (!trim($line)) return true;
 707     if (strlen($line) - strlen(ltrim($line)) > $lineIndent) return true;
 708     return false;
 709   }
 710
 711   function referenceContentsByAlias ($alias) {
 712     do {
 713       if (!isset($this->SavedGroups[$alias])) { echo "Bad group name: $alias."; break; }
 714       $groupPath = $this->SavedGroups[$alias];
 715       $value = $this->result;
 716       foreach ($groupPath as $k) {
 717         $value = $value[$k];
 718       }
 719     } while (false);
 720     return $value;
 721   }
 722
 723   function addArrayInline ($array, $indent) {
 724       $CommonGroupPath = $this->path;
 725       if (empty ($array)) return false;
 726
 727       foreach ($array as $k => $_) {
 728         $this->addArray(array($k => $_), $indent);
 729         $this->path = $CommonGroupPath;
 730       }
 731       return true;
 732   }
 733
 734   function addArray ($incoming_data, $incoming_indent) {
 735
 736    // print_r ($incoming_data);
 737
 738     if (count ($incoming_data) > 1)
 739       return $this->addArrayInline ($incoming_data, $incoming_indent);
 740
 741     $key = key ($incoming_data);
 742     $value = isset($incoming_data[$key]) ? $incoming_data[$key] : null;
 743     if ($key === '__!YAMLZero') $key = '0';
 744
 745     if ($incoming_indent == 0 && !$this->_containsGroupAlias && !$this->_containsGroupAnchor) { // Shortcut for root-level values.
 746       if ($key || $key === '' || $key === '0') {
 747         $this->result[$key] = $value;
 748       } else {
 749         $this->result[] = $value; end ($this->result); $key = key ($this->result);
 750       }
 751       $this->path[$incoming_indent] = $key;
 752       return;
 753     }
 754
 755
 756
 757     $history = array();
 758     // Unfolding inner array tree.
 759     $history[] = $_arr = $this->result;
 760     foreach ($this->path as $k) {
 761       $history[] = $_arr = $_arr[$k];
 762     }
 763
 764     if ($this->_containsGroupAlias) {
 765       $value = $this->referenceContentsByAlias($this->_containsGroupAlias);
 766       $this->_containsGroupAlias = false;
 767     }
 768
 769
 770     // Adding string or numeric key to the innermost level or $this->arr.
 771     if (is_string($key) && $key == '<<') {
 772       if (!is_array ($_arr)) { $_arr = array (); }
 773       $_arr = array_merge ($_arr, $value);
 774     } else if ($key || $key === '' || $key === '0') {
 775       $_arr[$key] = $value;
 776     } else {
 777       if (!is_array ($_arr)) { $_arr = array ($value); $key = 0; }
 778       else { $_arr[] = $value; end ($_arr); $key = key ($_arr); }
 779     }
 780
 781     $reverse_path = array_reverse($this->path);
 782     $reverse_history = array_reverse ($history);
 783     $reverse_history[0] = $_arr;
 784     $cnt = count($reverse_history) - 1;
 785     for ($i = 0; $i < $cnt; $i++) {
 786       $reverse_history[$i+1][$reverse_path[$i]] = $reverse_history[$i];
 787     }
 788     $this->result = $reverse_history[$cnt];
 789
 790     $this->path[$incoming_indent] = $key;
 791
 792     if ($this->_containsGroupAnchor) {
 793       $this->SavedGroups[$this->_containsGroupAnchor] = $this->path;
 794       if (is_array ($value)) {
 795         $k = key ($value);
 796         if (!is_int ($k)) {
 797           $this->SavedGroups[$this->_containsGroupAnchor][$incoming_indent + 2] = $k;
 798         }
 799       }
 800       $this->_containsGroupAnchor = false;
 801     }
 802
 803   }
 804
 805   function startsLiteralBlock ($line) {
 806     $lastChar = substr (trim($line), -1);
 807     if ($lastChar != '>' && $lastChar != '|') return false;
 808     if ($lastChar == '|') return $lastChar;
 809     // HTML tags should not be counted as literal blocks.
 810     if (preg_match ('#<.*?>$#', $line)) return false;
 811     return $lastChar;
 812   }
 813
 814   function greedilyNeedNextLine($line) {
 815     $line = trim ($line);
 816     if (!strlen($line)) return false;
 817     if (substr ($line, -1, 1) == ']') return false;
 818     if ($line[0] == '[') return true;
 819     if (preg_match ('#^[^:]+?:\s*\[#', $line)) return true;
 820     return false;
 821   }
 822
 823   function addLiteralLine ($literalBlock, $line, $literalBlockStyle) {
 824     $line = $this->stripIndent($line);
 825     $line = rtrim ($line, "\r\n\t ") . "\n";
 826     if ($literalBlockStyle == '|') {
 827       return $literalBlock . $line;
 828     }
 829     if (strlen($line) == 0)
 830       return rtrim($literalBlock, ' ') . "\n";
 831     if ($line == "\n" && $literalBlockStyle == '>') {
 832       return rtrim ($literalBlock, " \t") . "\n";
 833     }
 834     if ($line != "\n")
 835       $line = trim ($line, "\r\n ") . " ";
 836     return $literalBlock . $line;
 837   }
 838
 839    function revertLiteralPlaceHolder ($lineArray, $literalBlock) {
 840      foreach ($lineArray as $k => $_) {
 841       if (is_array($_))
 842         $lineArray[$k] = $this->revertLiteralPlaceHolder ($_, $literalBlock);
 843       else if (substr($_, -1 * strlen ($this->LiteralPlaceHolder)) == $this->LiteralPlaceHolder)
 844                $lineArray[$k] = rtrim ($literalBlock, " \r\n");
 845      }
 846      return $lineArray;
 847    }
 848
 849   function stripIndent ($line, $indent = -1) {
 850     if ($indent == -1) $indent = strlen($line) - strlen(ltrim($line));
 851     return substr ($line, $indent);
 852   }
 853
 854   function getParentPathByIndent ($indent) {
 855     if ($indent == 0) return array();
 856     $linePath = $this->path;
 857     do {
 858       end($linePath); $lastIndentInParentPath = key($linePath);
 859       if ($indent <= $lastIndentInParentPath) array_pop ($linePath);
 860     } while ($indent <= $lastIndentInParentPath);
 861     return $linePath;
 862   }
 863
 864
 865   function clearBiggerPathValues ($indent) {
 866
 867
 868     if ($indent == 0) $this->path = array();
 869     if (empty ($this->path)) return true;
 870
 871     foreach ($this->path as $k => $_) {
 872       if ($k > $indent) unset ($this->path[$k]);
 873     }
 874
 875     return true;
 876   }
 877
 878
 879   function isComment ($line) {
 880     if (!$line) return false;
 881     if ($line[0] == '#') return true;
 882     if (trim($line, " \r\n\t") == '---') return true;
 883     return false;
 884   }
 885
 886   function isEmpty ($line) {
 887     return (trim ($line) === '');
 888   }
 889
 890
 891   function isArrayElement ($line) {
 892     if (!$line) return false;
 893     if ($line[0] != '-') return false;
 894     if (strlen ($line) > 3)
 895       if (substr($line,0,3) == '---') return false;
 896
 897     return true;
 898   }
 899
 900   function isHashElement ($line) {
 901     return strpos($line, ':');
 902   }
 903
 904   function isLiteral ($line) {
 905     if ($this->isArrayElement($line)) return false;
 906     if ($this->isHashElement($line)) return false;
 907     return true;
 908   }
 909
 910
 911   function unquote ($value) {
 912     if (!$value) return $value;
 913     if (!is_string($value)) return $value;
 914     if ($value[0] == '\'') return trim ($value, '\'');
 915     if ($value[0] == '"') return trim ($value, '"');
 916     return $value;
 917   }
 918
 919   function startsMappedSequence ($line) {
 920     return ($line[0] == '-' && substr ($line, -1, 1) == ':');
 921   }
 922
 923   function returnMappedSequence ($line) {
 924     $array = array();
 925     $key         = $this->unquote(trim(substr($line,1,-1)));
 926     $array[$key] = array();
 927     $this->delayedPath = array(strpos ($line, $key) + $this->indent => $key);
 928     return array($array);
 929   }
 930
 931   function returnMappedValue ($line) {
 932     $array = array();
 933     $key         = $this->unquote (trim(substr($line,0,-1)));
 934     $array[$key] = '';
 935     return $array;
 936   }
 937
 938   function startsMappedValue ($line) {
 939     return (substr ($line, -1, 1) == ':');
 940   }
 941
 942   function isPlainArray ($line) {
 943     return ($line[0] == '[' && substr ($line, -1, 1) == ']');
 944   }
 945
 946   function returnPlainArray ($line) {
 947     return $this->_toType($line);
 948   }
 949
 950   function returnKeyValuePair ($line) {
 951     $array = array();
 952     $key = '';
 953     if (strpos ($line, ':')) {
 954       // It's a key/value pair most likely
 955       // If the key is in double quotes pull it out
 956       if (($line[0] == '"' || $line[0] == "'") && preg_match('/^(["\'](.*)["\'](\s)*:)/',$line,$matches)) {
 957         $value = trim(str_replace($matches[1],'',$line));
 958         $key   = $matches[2];
 959       } else {
 960         // Do some guesswork as to the key and the value
 961         $explode = explode(':',$line);
 962         $key     = trim($explode[0]);
 963         array_shift($explode);
 964         $value   = trim(implode(':',$explode));
 965       }
 966       // Set the type of the value.  Int, string, etc
 967       $value = $this->_toType($value);
 968       if ($key === '0') $key = '__!YAMLZero';
 969       $array[$key] = $value;
 970     } else {
 971       $array = array ($line);
 972     }
 973     return $array;
 974
 975   }
 976
 977
 978   function returnArrayElement ($line) {
 979      if (strlen($line) <= 1) return array(array()); // Weird %)
 980      $array = array();
 981      $value   = trim(substr($line,1));
 982      $value   = $this->_toType($value);
 983      $array[] = $value;
 984      return $array;
 985   }
 986
 987
 988   function nodeContainsGroup ($line) {
 989     $symbolsForReference = 'A-z0-9_\-';
 990     if (strpos($line, '&') === false && strpos($line, '*') === false) return false; // Please die fast ;-)
 991     if ($line[0] == '&' && preg_match('/^(&['.$symbolsForReference.']+)/', $line, $matches)) return $matches[1];
 992     if ($line[0] == '*' && preg_match('/^(\*['.$symbolsForReference.']+)/', $line, $matches)) return $matches[1];
 993     if (preg_match('/(&['.$symbolsForReference.']+)$/', $line, $matches)) return $matches[1];
 994     if (preg_match('/(\*['.$symbolsForReference.']+$)/', $line, $matches)) return $matches[1];
 995     if (preg_match ('#^\s*<<\s*:\s*(\*[^\s]+).*$#', $line, $matches)) return $matches[1];
 996     return false;
 997
 998   }
 999
1000   function addGroup ($line, $group) {
1001     if ($group[0] == '&') $this->_containsGroupAnchor = substr ($group, 1);
1002     if ($group[0] == '*') $this->_containsGroupAlias = substr ($group, 1);
1003     //print_r ($this->path);
1004   }
1005
1006   function stripGroup ($line, $group) {
1007     $line = trim(str_replace($group, '', $line));
1008     return $line;
1009   }
1010 }
1011
1012 // Enable use of Spyc from command line
1013 // The syntax is the following: php spyc.php spyc.yaml
1014
1015 define ('SPYC_FROM_COMMAND_LINE', false);
1016
1017 do {
1018   if (!SPYC_FROM_COMMAND_LINE) break;
1019   if (empty ($_SERVER['argc']) || $_SERVER['argc'] < 2) break;
1020   if (empty ($_SERVER['PHP_SELF']) || $_SERVER['PHP_SELF'] != 'spyc.php') break;
1021   $file = $argv[1];
1022   printf ("Spyc loading file: %s\n", $file);
1023   print_r (spyc_load_file ($file));
1024 } while (0);