includes/svnlib.php

   1 <?php
   2 /*=====================================================================*\
   3 || ################################################################### ||
   4 || # ViewSVN [#]version[#]
   5 || # --------------------------------------------------------------- # ||
   6 || # Copyright ©2002-[#]year[#] by Iris Studios, Inc. All Rights Reserved. # ||
   7 || # This file may not be reproduced in any way without permission.  # ||
   8 || # --------------------------------------------------------------- # ||
   9 || # User License Agreement at http://www.iris-studios.com/license/  # ||
  10 || ################################################################### ||
  11 \*=====================================================================*/
  12
  13 /**
  14 * Command line interface with the SVN commands
  15 *
  16 * @package      ViewSVN
  17 */
  18
  19 /**
  20 * Interacts with the command line subsystem to
  21 * access SVN information
  22 *
  23 * @package      ViewSVN
  24 * @version      $Id$
  25 */
  26 class SVNLib
  27 {
  28         /**
  29         * Path to the SVN binary
  30         * @var  string
  31         */
  32         var $svnpath;
  33
  34         /**
  35         * Common command system
  36         * @var  object
  37         */
  38         var $common;
  39
  40         /**
  41         * Constructor: validate SVN path
  42         *
  43         * @param        string  Path to SVN binary
  44         */
  45         function SVNLib($svnpath)
  46         {
  47                 global $viewsvn;
  48
  49                 $this->svnpath = $viewsvn->shell->cmd($svnpath);
  50
  51                 $this->common =& new SVNCommon();
  52
  53                 $access = $viewsvn->shell->exec($this->svnpath . ' --version');
  54
  55                 if (!$access)
  56                 {
  57                         $viewsvn->trigger->error('svn binary could not be found');
  58                 }
  59
  60                 if (!preg_match('#^svn, version (.*?)\)$#i', trim($access[0])))
  61                 {
  62                         $viewsvn->trigger->error('svn binary does not pass test');
  63                 }
  64         }
  65
  66         /**
  67         * Prepares data for output
  68         *
  69         * @access       public
  70         *
  71         * @param        string  Standard data
  72         *
  73         * @return       string  Output-ready data
  74         */
  75         function format($string)
  76         {
  77                 // convert entities
  78                 $string = htmlspecialchars($string);
  79
  80                 // tabs to 5 spaces
  81                 $string = str_replace("\t", '     ', $string);
  82
  83                 // spaces to nbsp
  84                 $string = str_replace(' ', '&nbsp;', $string);
  85
  86                 // convert advanced diff
  87                 $string = str_replace(array('{@++}', '{@--}'), array('<span class="diff_add">', '<span class="diff_del">'), $string);
  88                 $string = str_replace(array('{/@++}', '{/@--}'), '</span>', $string);
  89
  90                 // nl2br
  91                 $string = nl2br($string);
  92
  93                 return $string;
  94         }
  95
  96         /**
  97         * Executes the SVN binary
  98         *
  99         * @access       private
 100         *
 101         * @param        string  Command
 102         *
 103         * @return       array   Output
 104         */
 105         function svn($command)
 106         {
 107                 global $viewsvn;
 108
 109                 $output = $viewsvn->shell->exec($this->svnpath . ' ' . $command . ' 2>&1');
 110                 $temp = implode("\n", $output);
 111                 if (strpos($temp, '(apr_err=') !== false)
 112                 {
 113                         $viewsvn->trigger->error(nl2br($temp));
 114                 }
 115                 return $output;
 116         }
 117
 118         /**
 119         * SVN Wrapper: standard command system
 120         *
 121         * @access       private
 122         *
 123         * @param        string  SVN command
 124         * @param        string  Repository
 125         * @param        string  Path
 126         * @param        integer Revision
 127         *
 128         * @return       array   Lines of output
 129         */
 130         function std($command, $repos, $path, $revision)
 131         {
 132                 global $viewsvn;
 133
 134                 $revision = $this->rev($revision);
 135                 $repospath = $viewsvn->repos->fetch_path($repos, false);
 136
 137                 return $this->svn($command . ' -r' . $revision . ' ' . $repospath . $path);
 138         }
 139
 140         /**
 141         * SVN Wrapper: blame
 142         *
 143         * @access       protected
 144         *
 145         * @param        string  Repository
 146         * @param        string  Path
 147         * @param        integer Revision
 148         *
 149         * @return       array   Lines of blame output
 150         */
 151         function blame($repos, $path, $revision)
 152         {
 153                 return $this->std('blame', $repos, $path, $revision);
 154         }
 155
 156         /**
 157         * SVN Wrapper: cat
 158         *
 159         * @access       protected
 160         *
 161         * @param        string  Repository
 162         * @param        string  Path
 163         * @param        integer Revision
 164         *
 165         * @return       array   Lines of cat output
 166         */
 167         function cat($repos, $path, $revision)
 168         {
 169                 return $this->std('cat', $repos, $path, $revision);
 170         }
 171
 172         /**
 173         * SVN Wrapper: diff
 174         *
 175         * @access       protected
 176         *
 177         * @param        string  Repository
 178         * @param        string  Path
 179         * @param        integer Lower revision
 180         * @param        integer Higher revision
 181         *
 182         * @return       array   Lines of diff output
 183         */
 184         function diff($repos, $path, $lorev, $hirev)
 185         {
 186                 global $viewsvn;
 187
 188                 $hirev = $this->rev($hirev);
 189                 $lorev = $this->rev($lorev);
 190                 if ($lorev == 'HEAD')
 191                 {
 192                         $lorev = 1;
 193                 }
 194
 195                 if (is_integer($hirev) AND is_integer($lorev))
 196                 {
 197                         if ($lorev > $hirev)
 198                         {
 199                                 $lorev = $hirev - 1;
 200                         }
 201                         if ($lorev == $hirev)
 202                         {
 203                                 $lorev = 0;
 204                         }
 205                 }
 206
 207                 $repospath = $viewsvn->repos->fetch_path($repos, false);
 208
 209                 return $this->svn('diff -r' . $lorev . ':' . $hirev . ' ' . $repospath . $path);
 210         }
 211
 212         /**
 213         * SVN Wrapper: log
 214         *
 215         * @access       protected
 216         *
 217         * @param        string  Repository
 218         * @param        string  Path
 219         * @param        integer Lower revision
 220         * @param        integer Higher revision
 221         *
 222         * @return       array   Lines of log output
 223         */
 224         function log($repos, $path, $lorev, $hirev)
 225         {
 226                 global $viewsvn;
 227
 228                 $hirev = $this->rev($hirev);
 229                 $lorev = $this->rev($hirev);
 230                 if ($lorev == 'HEAD')
 231                 {
 232                         $lorev = 0;
 233                 }
 234
 235                 if (is_integer($hirev) AND is_integer($lorev))
 236                 {
 237                         if ($lorev > $hirev)
 238                         {
 239                                 $lorev = $hirev - 1;
 240                         }
 241                         if ($lorev == $hirev)
 242                         {
 243                                 $lorev = 0;
 244                         }
 245                 }
 246
 247                 $repospath = $viewsvn->repos->fetch_path($repos, false);
 248
 249                 return $this->svn('log -v -r' . $hirev . ':' . $lorev . ' ' . $repospath . $path);
 250         }
 251
 252         /**
 253         * SVN Wrapper: ls (list)
 254         *
 255         * @access       protected
 256         *
 257         * @param        string  Repository
 258         * @param        string  Path
 259         * @param        integer Revision
 260         *
 261         * @return       array   Lines of list output
 262         */
 263         function ls($repos, $path, $revision)
 264         {
 265                 return $this->std('list', $repos, $path, $revision);
 266         }
 267
 268         /**
 269         * Generates a clean revision number
 270         *
 271         * @access       public
 272         *
 273         * @param        integer Revision number
 274         *
 275         * @return       mixed   Cleaned revision or HEAD
 276         */
 277         function rev($revision)
 278         {
 279                 if (($revision = intval($revision)) < 1)
 280                 {
 281                         $revision = 'HEAD';
 282                 }
 283                 return $revision;
 284         }
 285 }
 286
 287 /**
 288 * Commonly executed SVN commands that return data
 289 * used in many parts of the system
 290 *
 291 * @package      ViewSVN
 292 * @version      $Id$
 293 */
 294 class SVNCommon
 295 {
 296         /**
 297         * Registry object
 298         * @var  object
 299         */
 300         var $registry;
 301
 302         /**
 303         * List of revisions
 304         * @var  array
 305         */
 306         var $revisions;
 307
 308         /**
 309         * List of logs
 310         * @var  array
 311         */
 312         var $logs;
 313
 314         /**
 315         * Constructor: bind with registry
 316         */
 317         function SVNCommon()
 318         {
 319                 global $viewsvn;
 320
 321                 $this->registry =& $viewsvn;
 322         }
 323
 324         /**
 325         * Checks to see if the given universal path is
 326         * a directory
 327         *
 328         * @access       public
 329         *
 330         * @param        string  Universal path
 331         *
 332         * @return       bool    Directory or not
 333         */
 334         function isdir($path)
 335         {
 336                 $output = $this->registry->svn->std('info', $this->registry->paths->fetch_repos($path), $this->registry->paths->fetch_path($path), 'HEAD');
 337
 338                 foreach ($output AS $line)
 339                 {
 340                         if (preg_match('#^Node Kind: (.*)#', $line, $matches))
 341                         {
 342                                 if (trim(strtolower($matches[1])) == 'directory')
 343                                 {
 344                                         return true;
 345                                 }
 346                         }
 347                 }
 348
 349                 return false;
 350         }
 351
 352         /**
 353         * Get a list of revisions for a path
 354         *
 355         * @access       public
 356         *
 357         * @param        string  Universal path
 358         *
 359         * @return       array   Key revisions
 360         */
 361         function fetch_revs($path)
 362         {
 363                 if (!isset($this->revisions["$path"]))
 364                 {
 365                         $log = $this->fetch_logs($path);
 366
 367                         $revs = array_keys($log);
 368
 369                         $this->revisions["$path"] = array(
 370                                 'HEAD'  => $revs[0],
 371                                 'START' => $revs[ count($revs) - 1 ],
 372                                 'revs'  => $revs
 373                         );
 374                 }
 375
 376                 return $this->revisions["$path"];
 377         }
 378
 379         /**
 380         * Gets the revision that is marked as HEAD
 381         *
 382         * @access       public
 383         *
 384         * @param        string  Universal path
 385         *
 386         * @return       integer Revision
 387         */
 388         function fetch_head_rev($path)
 389         {
 390                 $revs = $this->fetch_revs($path);
 391                 return $revs['HEAD'];
 392         }
 393
 394         /**
 395         * Returns the previous revision to the one given
 396         *
 397         * @access       public
 398         *
 399         * @param        string  Universal path
 400         * @param        integer Arbitrary revision
 401         *
 402         * @return       integer Previous revision (-1 if none)
 403         */
 404         function fetch_prev_rev($path, $current)
 405         {
 406                 $revs = $this->fetch_revs($path);
 407
 408                 if ($current == 'HEAD')
 409                 {
 410                         $current = $this->fetch_head_rev($path);
 411                 }
 412
 413                 $index = array_search($current, $revs['revs']);
 414                 if ($current === false)
 415                 {
 416                         $message->trigger->error('revision ' . $current . ' is not in ' . $path);
 417                 }
 418
 419                 if (isset($revs['revs'][ $index + 1 ]))
 420                 {
 421                         return $revs['revs'][ $index + 1 ];
 422                 }
 423                 else
 424                 {
 425                         return -1;
 426                 }
 427         }
 428
 429         /**
 430         * Get a list of logs
 431         *
 432         * @access       public
 433         *
 434         * @param        string  Universal path
 435         *
 436         * @return       array   Log data
 437         */
 438         function fetch_logs($path)
 439         {
 440                 if (!isset($this->logs["$path"]))
 441                 {
 442                         $log = new SVNLog($this->registry->paths->fetch_repos($path), $this->registry->paths->fetch_path($path), 0, 0);
 443
 444                         $this->logs["$path"] = $log->fetch();
 445                 }
 446
 447                 return $this->logs["$path"];
 448         }
 449
 450         /**
 451         * Returns a given log entry for a path
 452         * and revision
 453         *
 454         * @access       public
 455         *
 456         * @param        string  Universal path
 457         * @param        integer Arbitrary revision
 458         *
 459         * @return       array   Log entry
 460         */
 461         function fetch_log($path, $rev)
 462         {
 463                 $logs = $this->fetch_logs($path);
 464
 465                 $rev = $this->registry->svn->rev($rev);
 466                 if ($rev == 'HEAD')
 467                 {
 468                         $rev = $this->fetch_head_rev($path);
 469                 }
 470
 471                 if (isset($logs["$rev"]))
 472                 {
 473                         return $logs["$rev"];
 474                 }
 475                 else
 476                 {
 477                         return null;
 478                 }
 479         }
 480 }
 481
 482 /**
 483 * Annotation/blame system; constructs an array
 484 * that is ready for output
 485 *
 486 * @package      ViewSVN
 487 * @version      $Id$
 488 */
 489 class SVNBlame
 490 {
 491         /**
 492         * Array of blame information
 493         * @var  array
 494         */
 495         var $blame = array();
 496
 497         /**
 498         * Raw "svn blame" output
 499         * @var  array
 500         */
 501         var $rawoutput;
 502
 503         /**
 504         * Constructor: create blame and store data
 505         *
 506         * @param        string  Repository
 507         * @param        string  Path
 508         * @param        integer Revision
 509         */
 510         function SVNBlame($repos, $path, $revision)
 511         {
 512                 global $viewsvn;
 513
 514                 $this->rawoutput = $viewsvn->svn->blame($repos, $path, $revision);
 515                 $this->process();
 516         }
 517
 518         /**
 519         * Returns blame for display
 520         *
 521         * @access       public
 522         *
 523         * @return       array   Blame data
 524         */
 525         function fetch()
 526         {
 527                 return $this->blame;
 528         }
 529
 530         /**
 531         * Parses the blame data
 532         *
 533         * @access       private
 534         */
 535         function process()
 536         {
 537                 $lineno = 1;
 538
 539                 foreach ($this->rawoutput AS $line)
 540                 {
 541                         if (preg_match('#^\s+([0-9]+)\s+([\w\.\-_]+)\s(.*)$#', $line, $matches))
 542                         {
 543                                 $this->blame[] = array(
 544                                         'rev'           => $matches[1],
 545                                         'author'        => $matches[2],
 546                                         'line'          => $matches[3],
 547                                         'lineno'        => $lineno++
 548                                 );
 549                         }
 550                         // a blank line
 551                         else if (preg_match('#^\s+([0-9]+)\s+([\w\.\-_]+)$#', $line, $matches))
 552                         {
 553                                 $this->blame[] = array(
 554                                         'rev'           => $matches[1],
 555                                         'author'        => $matches[2],
 556                                         'line'          => '',
 557                                         'lineno'        => $lineno++
 558                                 );
 559                         }
 560                 }
 561         }
 562 }
 563
 564 /**
 565 * Log management system; creates a complex list
 566 * of SVN log information
 567 *
 568 * @package      ViewSVN
 569 * @version      $Id$
 570 */
 571 class SVNLog
 572 {
 573         /**
 574         * Array of logs
 575         * @var  array
 576         */
 577         var $logs = array();
 578
 579         /**
 580         * Raw "svn log" output
 581         * @var  array
 582         */
 583         var $rawoutput;
 584
 585         /**
 586         * Constructor: create log store for the given file
 587         *
 588         * @param        string  Repository
 589         * @param        string  Path
 590         * @param        integer Lower revision
 591         * @param        integer Higher revision
 592         */
 593         function SVNLog($repos, $path, $lorev, $hirev)
 594         {
 595                 global $viewsvn;
 596
 597                 $this->rawoutput = $viewsvn->svn->log($repos, $path, $lorev, $hirev);
 598                 $this->process();
 599         }
 600
 601         /**
 602         * Returns logs for display
 603         *
 604         * @access       public
 605         *
 606         * @return       array   Log data
 607         */
 608         function fetch()
 609         {
 610                 return $this->logs;
 611         }
 612
 613         /**
 614         * Splits up the raw output into a usable log
 615         *
 616         * @access       private
 617         */
 618         function process()
 619         {
 620                 $lastrev = 0;
 621
 622                 for ($i = 1; $i <= count($this->rawoutput) - 1; $i++)
 623                 {
 624                         $line = $this->rawoutput["$i"];
 625
 626                         if (preg_match('#^r([0-9]*) \| (.*?) \| (....-..-.. ..:..:..) ([0-9\-]*) \((.*?)\) \| ([0-9]*) lines?$#', $line, $matches))
 627                         {
 628                                 if (isset($this->logs["$lastrev"]))
 629                                 {
 630                                         $this->logs["$lastrev"]['message'] = $this->strip_last_line($this->logs["$lastrev"]['message']);
 631                                 }
 632
 633                                 $this->logs["$matches[1]"] = array(
 634                                         'rev'           => $matches[1],
 635                                         'author'        => $matches[2],
 636                                         'date'          => $matches[3],
 637                                         'timezone'      => $matches[4],
 638                                         'lines'         => $matches[6],
 639                                         'message'       => ''
 640                                 );
 641
 642                                 $lastrev = $matches[1];
 643                         }
 644                         else if (preg_match('#^\s+([ADMR])\s(.*)#', $line, $matches))
 645                         {
 646                                 $this->logs["$lastrev"]['files'][] = array(
 647                                         'action'        => $matches[1],
 648                                         'file'          => $matches[2]
 649                                 );
 650                         }
 651                         else
 652                         {
 653                                 if (trim($line) != 'Changed paths:')
 654                                 {
 655                                         $this->logs["$lastrev"]['message'] .= $line . "\n";
 656                                 }
 657                         }
 658                 }
 659
 660                 if (isset($this->logs["$lastrev"]))
 661                 {
 662                         $this->logs["$lastrev"]['message'] = $this->strip_last_line($this->logs["$lastrev"]['message']);
 663                 }
 664         }
 665
 666         /**
 667         * Trims the last dash line off a message
 668         *
 669         * @access       private
 670         *
 671         * @param        string  Message with annoying-ass line
 672         *
 673         * @return       string  Clean string
 674         */
 675         function strip_last_line($string)
 676         {
 677                 return trim(preg_replace("#\n(.*?)\n$#", '', $string));
 678         }
 679 }
 680
 681 /**
 682 * Diff system; constructs a diff array that
 683 * is ready for output
 684 *
 685 * @package      ViewSVN
 686 */
 687 class SVNDiff
 688 {
 689         /**
 690         * Array of diff information
 691         * @var  array
 692         */
 693         var $diff = array();
 694
 695         /**
 696         * Raw "svn diff" output
 697         * @var  array
 698         */
 699         var $rawoutput;
 700
 701         /**
 702         * Constructor: create and store diff data
 703         *
 704         * @param        string  Repository
 705         * @param        string  Path
 706         * @param        integer Lower revision
 707         * @param        integer Higher revision
 708         */
 709         function SVNDiff($repos, $path, $lorev, $hirev)
 710         {
 711                 global $viewsvn;
 712
 713                 $this->rawoutput = $viewsvn->svn->diff($repos, $path, $lorev, $hirev);
 714                 $this->process();
 715         }
 716
 717         /**
 718         * Returns diffs for display
 719         *
 720         * @access       public
 721         *
 722         * @return       array   Diff data
 723         */
 724         function fetch()
 725         {
 726                 return $this->diff;
 727         }
 728
 729         /**
 730         * Processes and prepares diff data
 731         *
 732         * @access       private
 733         */
 734         function process()
 735         {
 736                 $chunk = 0;
 737                 $indexcounter = null;
 738
 739                 $lastact = '';
 740                 $lastcontent = '';
 741
 742                 foreach ($this->rawoutput AS $line)
 743                 {
 744                         if (preg_match('#^@@ \-([0-9]*),([0-9]*) \+([0-9]*),([0-9]*) @@$#', $line, $bits))
 745                         {
 746                                 $lastact = '';
 747                                 $lastcontent = '';
 748
 749                                 $this->diff["$index"][ ++$chunk ]['hunk'] = array('old' => array('line' => $bits[1], 'count' => $bits[2]), 'new' => array('line' => $bits[3], 'count' => $bits[4]));
 750                                 $lines['old'] = $this->diff["$index"]["$chunk"]['hunk']['old']['line'] - 1;
 751                                 $lines['new'] = $this->diff["$index"]["$chunk"]['hunk']['new']['line'] - 1;
 752                                 continue;
 753                         }
 754
 755                         if ($indexcounter <= 5 AND $indexcounter !== null)
 756                         {
 757                                 $indexcounter++;
 758                                 continue;
 759                         }
 760                         else if ($indexcounter == 5)
 761                         {
 762                                 $indexcounter = null;
 763                                 continue;
 764                         }
 765
 766                         if (preg_match('#^([\+\- ])(.*)#', $line, $matches))
 767                         {
 768                                 $act = $matches[1];
 769                                 $content = $matches[2];
 770
 771                                 if ($act == ' ')
 772                                 {
 773                                         $this->diff["$index"]["$chunk"][] = array(
 774                                                 'line'          => $content,
 775                                                 'act'           => '',
 776                                                 'oldlineno'     => ++$lines['old'],
 777                                                 'newlineno'     => ++$lines['new']
 778                                         );
 779                                 }
 780                                 else if ($act == '+')
 781                                 {
 782                                         // potential line delta
 783                                         if ($lastact == '-')
 784                                         {
 785                                                 if ($delta = @$this->fetch_diff_extent($lastcontent, $content))
 786                                                 {
 787                                                         // create two sets of ends for the two contents
 788                                                         $delta['endo'] = strlen($lastcontent) - $delta['end'];
 789                                                         $delta['endn'] = strlen($content) - $delta['end'];
 790
 791                                                         $diffo = $delta['endo'] - $delta['start'];
 792                                                         $diffn = $delta['endn'] - $delta['start'];
 793
 794                                                         if (strlen($lastcontent) > $delta['endo'] - $diffo)
 795                                                         {
 796                                                                 $removed = substr($lastcontent, $delta['start'], $diffo);
 797                                                                 $this->diff["$index"]["$chunk"][ count($this->diff["$index"]["$chunk"]) - 2 ]['line'] = substr_replace($lastcontent, '{@--}' . $removed . '{/@--}', $delta['start'], $diffo);
 798                                                         }
 799
 800                                                         if (strlen($content) > $delta['endn'] - $diffn)
 801                                                         {
 802                                                                 $added = substr($content, $delta['start'], $diffn);
 803                                                                 $content = substr_replace($content, '{@++}' . $added . '{/@++}', $delta['start'], $diffn);
 804                                                         }
 805                                                 }
 806                                         }
 807
 808                                         $this->diff["$index"]["$chunk"][] = array(
 809                                                 'line'          => $content,
 810                                                 'act'           => '+',
 811                                                 'oldlineno'     => '',
 812                                                 'newlineno'     => ++$lines['new']
 813                                         );
 814                                 }
 815                                 else if ($act == '-')
 816                                 {
 817                                         $lastcontent = $content;
 818
 819                                         $this->diff["$index"]["$chunk"][] = array(
 820                                                 'line'          => $content,
 821                                                 'act'           => '-',
 822                                                 'oldlineno'     => ++$lines['old'],
 823                                                 'newlineno'     => ''
 824                                         );
 825                                 }
 826
 827                                 $lastact = $act;
 828                         }
 829                         // whitespace lines
 830                         else
 831                         {
 832                                 if (preg_match('#^Index: (.*?)$#', $line, $matches))
 833                                 {
 834                                         $index = $matches[1];
 835                                         $indexcounter = 1;
 836                                         $chunk = 0;
 837                                         continue;
 838                                 }
 839
 840                                 $lastact = '';
 841
 842                                 $this->diff["$index"]["$chunk"][] = array(
 843                                         'line'          => '',
 844                                         'act'           => '',
 845                                         'oldlineno'     => ++$lines['old'],
 846                                         'newlineno'     => ++$lines['new']
 847                                 );
 848                         }
 849                 }
 850         }
 851
 852         /**
 853         * Returns the amount of change that occured
 854         * between two lines
 855         *
 856         * @access       private
 857         *
 858         * @param        string  Old line
 859         * @param        string  New line
 860         *
 861         * @return       array   Difference of positions
 862         */
 863         function fetch_diff_extent($old, $new)
 864         {
 865                 $start = 0;
 866                 $min = min(strlen($old), strlen($new));
 867
 868                 for ($start = 0; $start < $min; $start++)
 869                 {
 870                         if ($old{"$start"} != $new{"$start"})
 871                         {
 872                                 break;
 873                         }
 874                 }
 875
 876                 $max = max(strlen($old), strlen($new));
 877
 878                 for ($end = 0; $end < $min; $end++)
 879                 {
 880                         $oldpos = strlen($old) - $end;
 881                         $newpos = strlen($new) - $end;
 882
 883                         if ($old{"$oldpos"} != $new{"$newpos"})
 884                         {
 885                                 break;
 886                         }
 887                 }
 888
 889                 $end--;
 890
 891                 if ($start == 0 AND $end == $max)
 892                 {
 893                         return false;
 894                 }
 895
 896                 return array('start' => $start, 'end' => $end);
 897         }
 898 }
 899
 900 /*=====================================================================*\
 901 || ###################################################################
 902 || # $HeadURL$
 903 || # $Id$
 904 || ###################################################################
 905 \*=====================================================================*/
 906 ?>