How to get an entire function from a file

The specified Sarfraz PHP token is a good idea, especially if you are going to rewrite a lot of code outside of what you mentioned here.

However, this case can be quite simple, you won't need it.

A php function, if well formed, should have:

1) "Head", which looks like function funcname($arg1,...,$argn)

. You can probably find this and pull it out with a regex.

2) Following the head, a "body" that will consist of everything after the head, which comes in a pair of matched curly braces. So, you have to figure out how to match them. One way to do this is by specifying a variable $curlyBraceDepth

. Start it at 0, and then, starting at the curly brace that opens the body of the function, step through the code one character at a time. Increase every time you encounter an opening parenthesis $curlyBraceDepth

. Every time you encounter a closing parenthesis, shrink it. When$curlyBraceDepth < 1

(for example, when you go back to depth 0), you end up traversing the body of the function. While you are checking each character, you either need to accumulate every character you read into an array, or if you've already got it all in a string in memory, marking the start and end position, so you can pull it out later.

Now there is a big caveat here: if any of your functions treats the unmatched curly braces as characters within strings - not exactly normal, but perfectly legal and possible php - then you will also have to add conditional code to parse the strings as separate tokens. While you could write your own code to handle this, if you're worried about it as a corner, Tokenizer is probably the reliable way to go.

But you would use something like the algorithm I gave above when you go through the markers, anyway - find the markers that represent the head, sort the markers that contain the body counting T_CURLY_OPEN and T_CURLY_CLOSE to keep track of the depth of your parenthesis by accumulating markers. when you go and concatenate them when you reach zero depth of the parenthesis.

UPDATE (with Tokenizer)

token_get_all

takes care of combining individual source characters into syntactically meaningful PHP markers. Here's a quick example. Let's say we have the following PHP source line:

$s = '<?php function one() { return 1; }';

      

        
        
        
      

    

And we run it through token_get_all

:

$tokens = token_get_all($s);

      

        
        
        
      

    

If you do print_r

on this, here's what you'll see (with some inline comments):

Array
(
    [0] => Array
        (
            [0] => 367      // token number (also known by constant T_OPEN_TAG)
            [1] => <?php    // token literal as found in source
            [2] => 1        
        )

    [1] => Array
        (
            [0] => 333      // token number (also known by constant T_FUNCTION)
            [1] => function // token literal as found in source
            [2] => 1       
        )

    [2] => Array
        (
            [0] => 370      // token number (aka T_WHITESPACE)
            [1] =>          // you can't see it, but it there. :)
            [2] => 1
        )

    [3] => Array
        (
            [0] => 307      // token number (aka T_STRING)
            [1] => one      // hey, it the name of our function
            [2] => 1
        )

    [4] => (                // literal token - open paren
    [5] => )                // literal token - close paren
    [6] => Array
        (
            [0] => 370
            [1] =>  
            [2] => 1
        )

    [7] => {
    [8] => Array
        (
            [0] => 370
            [1] =>  
            [2] => 1
        )

    [9] => Array
        (
            [0] => 335
            [1] => return
            [2] => 1
        )

    [10] => Array
        (
            [0] => 370
            [1] =>  
            [2] => 1
        )

    [11] => Array
        (
            [0] => 305
            [1] => 1
            [2] => 1
        )

    [12] => ;
    [13] => Array
        (
            [0] => 370
            [1] =>  
            [2] => 1
        )

    [14] => }
    [15] => Array
        (
            [0] => 370
            [1] =>  
            [2] => 1
        )

    [16] => Array
        (
            [0] => 369
            [1] => ?>
            [2] => 1
        )

)

      

        
        
        
      

    

Note that some of the array elements are character literals (parentheses and parentheses, in fact, which makes this easier than I thought). Others are arrays containing a "token number" at index 0 and a literal token at index 1 (don't know what the value "1" is at 2nd index). If you want a "token name" - indeed a PHP constant that evaluates to a token number, you can use a function token_name

. For example, this familiar first token, 367, is referred to by its name and PHP constant T_OPEN_TAG.

If you want to use this to copy the source of function "one" from file A to file B, you can do $tokens = token_get_all(file_get_contents('file_A'))

and then search for a sequence of literal tokens denoting the start of that function - in our case T_FUNCTION, T_WHITESPACE and T_STRING equal to "one" ... So:

for($i=0,$z=count($tokens); $i<$z; $i++)
   if( is_array($tokens[$i]) 
    && $tokens[$i][0] == T_FUNCTION
    && is_array($tokens[$i+1])
    && $tokens[$i+1][0] == T_WHITESPACE
    && is_array($tokens[$i+2])
    && $tokens[$i+2][1] == 'one')
      break;

      

        
        
        
      

    

At this point, you will do what I described earlier: start with an opening curly brace for the function body with an indentation level of 1, watch the curly braces, track the depth, and accumulate tokens:

$accumulator = array();
// collect tokens from function head through opening brace
while($tokens[$i] != '{' && ($i < $z)) { 
   $accumulator[] = is_array($tokens[$i]) ? $tokens[$i][1] : $tokens[$i];
   $i++;
}
if($i == $z) {
    // handle error
} else {
   // note, accumulate, and position index past brace
   $braceDepth = 1; 
   $accumulator[] = '{';
   $i++;
}
while($braceDepth > 0 && ($i < $z)) {
   if(is_array($tokens[$i]))
      $accumulator[] = $tokens[$i][1];
   else {
      $accumulator[] = $tokens[i];
      if($tokens[$i] == '{') $braceDepth++;
      else if($tokens[i] == '}') $braceDepth--;
   }
}
$functionSrc = implode(null,$accumulator);