Question

I am trying to harvest all inclusion directives from a PHP file using a regular expression (in Java).

The expression should pick up only those which have file names expressed as unconcatenated string literals. Ones with constants or variables are not necessary.

Detection should work for both single and double quotes, include-s and require-s, plus the additional trickery with _once and last but not least, both keyword- and function-style invocations.

A rough input sample:

<?php

require('a.php');
require 'b.php';
require("c.php");
require "d.php";

include('e.php');
include 'f.php';
include("g.php");
include "h.php";

require_once('i.php');
require_once 'j.php';
require_once("k.php");
require_once "l.php";

include_once('m.php');
include_once 'n.php';
include_once("o.php");
include_once "p.php";

?>

And output:

["a.php","b.php","c.php","d.php","f.php","g.php","h.php","i.php","j.php","k.php","l.php","m.php","n.php","o.php","p.php"]

Any ideas?

Answer 1

To do this accurately, you really need to fully parse the PHP source code. This is because the text sequence: require('a.php'); can appear in places where it is not really an include at all – such as in comments, strings and HTML markup. For example, the following are NOT real PHP includes, but will be matched by the regex:

<?php // Examples where a regex solution gets false positives:
    /* PHP multi-line comment with: require('a.php'); */
    // PHP single-line comment with: require('a.php');
    $str = "double quoted string with: require('a.php');";
    $str = 'single quoted string with: require("a.php");';
?>
    <p>HTML paragraph with: require('a.php');</p>

That said, if you are happy with getting a few false positives, the following single regex solution will do a pretty good job of scraping all the filenames from all the PHP include variations:

// Get all filenames from PHP include variations and return in array.
function getIncludes($text) {
    $count = preg_match_all('/
        # Match PHP include variations with single string literal filename.
        \b              # Anchor to word boundary.
        (?:             # Group for include variation alternatives.
          include       # Either "include"
        | require       # or "require"
        )               # End group of include variation alternatives.
        (?:_once)?      # Either one may be the "once" variation.
        \s*             # Optional whitespace.
        (               # $1: Optional opening parentheses.
          \(            # Literal open parentheses,
          \s*           # followed by optional whitespace.
        )?              # End $1: Optional opening parentheses.
        (?|             # "Branch reset" group of filename alts.
          \'([^\']+)\'  # Either $2{1]: Single quoted filename,
        | "([^"]+)"     # or $2{2]: Double quoted filename.
        )               # End branch reset group of filename alts.
        (?(1)           # If there were opening parentheses,
          \s*           # then allow optional whitespace
          \)            # followed by the closing parentheses.
        )               # End group $1 if conditional.
        \s*             # End statement with optional whitespace
        ;               # followed by semi-colon.
        /ix', $text, $matches);
    if ($count > 0) {
        $filenames = $matches[2];
    } else {
        $filenames = array();
    }
    return $filenames;
}

Additional 2011-07-24 It turns out the OP wants a solution in Java not PHP. Here is a tested Java program which is nearly identical. Note that I am not a Java expert and don’t know how to dynamically size an array. Thus, the solution below (crudely) sets a fixed size array (100) to hold the array of filenames.

import java.util.regex.*;
public class TEST {
    // Set maximum size of array of filenames.
    public static final int MAX_NAMES = 100;
    // Get all filenames from PHP include variations and return in array.
    public static String[] getIncludes(String text)
    {
        int count = 0;                          // Count of filenames.
        String filenames[] = new String[MAX_NAMES];
        String filename;
        Pattern p = Pattern.compile(
            "# Match include variations with single string filename. \n" +
            "\\b             # Anchor to word boundary.              \n" +
            "(?:             # Group include variation alternatives. \n" +
            "  include       # Either 'include',                     \n" +
            "| require       # or 'require'.                         \n" +
            ")               # End group of include variation alts.  \n" +
            "(?:_once)?      # Either one may have '_once' suffix.   \n" +
            "\\s*            # Optional whitespace.                  \n" +
            "(?:             # Group for optional opening paren.     \n" +
            "  \\(           # Literal open parentheses,             \n" +
            "  \\s*          # followed by optional whitespace.      \n" +
            ")?              # Opening parentheses are optional.     \n" +
            "(?:             # Group for filename alternatives.      \n" +
            "  '([^']+)'     # $1: Either a single quoted filename,  \n" +
            "| \"([^\"]+)\"  # or $2: a double quoted filename.      \n" +
            ")               # End group of filename alternativess.  \n" +
            "(?:             # Group for optional closing paren.     \n" +
            "  \\s*          # Optional whitespace,                  \n" +
            "  \\)           # followed by the closing parentheses.  \n" +
            ")?              # Closing parentheses is optional .     \n" +
            "\\s*            # End statement with optional ws,       \n" +
            ";               # followed by a semi-colon.               ",
            Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE | Pattern.COMMENTS);
        Matcher m = p.matcher(text);
        while (m.find() && count < MAX_NAMES) {
            // The filename is in either $1 or $2
            if (m.group(1) != null) filename = m.group(1);
            else                    filename = m.group(2);
            // Add this filename to array of filenames.
            filenames[count++] = filename;
        }
        return filenames;
    }
    public static void main(String[] args)
    {
        // Test string full of various PHP include statements.
        String text = "<?php\n"+
            "\n"+
            "require('a.php');\n"+
            "require 'b.php';\n"+
            "require(\"c.php\");\n"+
            "require \"d.php\";\n"+
            "\n"+
            "include('e.php');\n"+
            "include 'f.php';\n"+
            "include(\"g.php\");\n"+
            "include \"h.php\";\n"+
            "\n"+
            "require_once('i.php');\n"+
            "require_once 'j.php';\n"+
            "require_once(\"k.php\");\n"+
            "require_once \"l.php\";\n"+
            "\n"+
            "include_once('m.php');\n"+
            "include_once 'n.php';\n"+
            "include_once(\"o.php\");\n"+
            "include_once \"p.php\";\n"+
            "\n"+
            "?>\n";
        String filenames[] = getIncludes(text);
        for (int i = 0; i < MAX_NAMES && filenames[i] != null; i++) {
            System.out.print(filenames[i] +"\n");
        }
    }
}