modules/visualize_backtrace/visualize_backtrace.module

<?php
// $Id: visualize_backtrace.module,v 1.1.2.2.2.1 2008/11/07 02:10:45 kentbye Exp $

/**
 * Implementation of hook_menu
 */
function visualize_backtrace_menu() {
  $items = array();

  $items['view_source'] = array(
    'title' => t('source'),
    'page callback' => 'visualize_backtrace_view_source_code',
    'access arguments' => array('administer visualize backtrace'),
    'type' => MENU_CALLBACK,
  );

  $items['visualize_backtrace'] = array(
    'title' => t('Backtrace Graphs of Drupal Function Calls'),
    'page callback' => 'visualize_backtrace_generate',
    'access arguments' => array('administer visualize backtrace'),
    'type' => MENU_CALLBACK,
  );

  $items['view_traces'] = array(
    'title' => t('XDebug Traces'),
    'page callback' => 'visualize_backtrace_display_latest_traces',
    'access arguments' => array('administer visualize backtrace'),
    'type' => MENU_CALLBACK,
  );

  $items['test_xdebug'] = array(
    'title' => t('Test to See if XDebug is Creating Trace Files'),
    'page callback' => 'visualize_backtrace_test_xdebug',
    'access arguments' => array('administer visualize backtrace'),
    'type' => MENU_CALLBACK,
  );

  $items['admin/settings/visualize_backtrace'] = array(
    'title' => 'Visualize Backtrace Settings',
    'description' => 'Settings to display more function call information.',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('visualize_backtrace_admin_settings'),
    'access arguments' => array('administer site configuration'),
    'type' => MENU_NORMAL_ITEM,
  );

 $items['visualize_backtrace_color_codes'] = array(
    'title' => t('Color Code Key for the Drupal Function Filenames'),
    'page callback' => 'visualize_backtrace_color_codes',
    'access arguments' => array('administer visualize backtrace'),
    'type' => MENU_CALLBACK,
  );

  return $items;
}

/**
 * Implementation of hook_help().
 */
function visualize_backtrace_help($path, $arg) {
  switch ($path) {
    case 'admin/settings/visualize_backtrace':
      return '<p>'. t('First test to see if you have XDebug properly set up and generating trace files by visiting this !test_page. <br />More detailed set-up instructions can be found in the INSTALL.txt file. <br />The "Visualize Backtrace" can then be turned on via the !block page.<br />View the !colorcodepage for Drupal Functions in the Backtraces.', array('!test_page' => l(t('XDebug Test Page'), 'test_xdebug'), '!block' => l(t('block administration'), 'admin/build/block'), '!colorcodepage' => l(t('Color Code Page'), 'visualize_backtrace_color_codes'))) .'</p>';
    case 'view_traces':
      return '<p>'. t('The most recent trace files are listed at the top, and are shown in reverse chronological order.  If these files are stored in your /tmp directory, then they may be purged if you reboot your computer. The generated *.dot files stored in the files directory will need to be manually purged from time to time.') .'</p>';
  }
}

/**
 * Implementation of hook_admin_settings().
 */
function visualize_backtrace_admin_settings() {
  $form['visualize_backtrace_execution_threshold'] = array(
    '#type' => 'textfield',
    '#title' => t('Highlight Drupal Functions Longer Than'),
    '#description' => t('Enter an integer in milliseconds. Any Drupal function which takes longer than this many milliseconds will be highlighted red in the callstack table.  This is also the threshold for marking the total time of the capture function and all of its children functions.'),
    '#default_value' => variable_get('visualize_backtrace_execution_threshold', 5),
    '#size' => 4,
    '#maxlength' => 4,
  );

  $form['visualize_backtrace_contrib_module_filepath'] = array(
    '#type' => 'textfield',
    '#title' => t('Capture Contributed Module Functions at this Location'),
    '#default_value' => variable_get('visualize_backtrace_contrib_module_filepath', 'sites/'),
    '#description' => t('Enter the directory that contains the module functions that you want to capture through the shortcut link "Graph the Contributed Module Function Backtraces". The default directory will capture all contributed module functions, but it is possible to enter a specific module or theme directory here as well (i.e. "themes/garland" or "sites/all/modules/views").'),
    '#size' => 40,
  );  

  $form['visualize_backtrace_create_main_subsections'] = array(
    '#type' => 'checkbox',
    '#title' => t('Split the Main Section into Three Subsections'),
    '#default_value' => variable_get('visualize_backtrace_create_main_subsections', 1),
    '#description' => t("Sometimes the Main Section is too big to be plotted all at once, and this option splits up the main section into three equal sections, which makes it quicker and easier to plot in smaller segments.  Turning this off will not create these three main subsection *.dot files whenever a new trace file is parsed")  
  );

  $form['visualize_backtrace_source_code_link_location'] = array(
    '#type' => 'select',
    '#title' => t('Display Source Code Located at'),
    '#default_value' => variable_get('visualize_backtrace_source_code_link_location', 'local'),
    '#options' => array(
      'local' => t('Local copy'),
      'drupal60_cvs' => t('Drupal 6.0 CVS'),
    ),
    '#description' => t('Chose whether to dynamically link to locally-stored copies of source code on your computer or to the static versions from cvs.drupal.org'),
  );

  $form['visualize_backtrace_source_code_font_size'] = array(
    '#type' => 'textfield',
    '#title' => t('View Source Code Font Size'),
    '#description' => t('The default font size for displaying the source code is 12px.'),
    '#default_value' => variable_get('visualize_backtrace_source_code_font_size', 12),
    '#size' => 4,
    '#maxlength' => 4,
  );
  
  $form['visualize_backtrace_zgrviewer_location'] = array(
    '#type' => 'textfield',
    '#title' => t('Path Containing ZGRViewer'),
    '#default_value' => variable_get('visualize_backtrace_zgrviewer_location', '/usr/local/bin/zgrviewer'),
    '#description' => t('This is the unix path where the ZGRViewer is installed.  The ZGRViewer is a java program that can be run from the command line to plot the *.dot flowchart visualizations. The INSTALL.txt contains more instructions for setting it up.'),
    '#size' => 40,
  );  
  
  $form['visualize_backtrace_hide_repeating_functions'] = array(
    '#type' => 'checkbox',
    '#title' => t('Hide Repeating Functions'),
    '#default_value' => variable_get('visualize_backtrace_hide_repeating_functions', 1),
    '#description' => t("Detect and consolidate repeating looping pairs of 1, 2 or 3 functions in order to make the flowcharts easier to read and quicker to load.")  
  );

  $form['visualize_backtrace_debug_duplication'] = array(
    '#type' => 'checkbox',
    '#title' => t('Display debugging information for the repeating function detection algorithm'),
    '#default_value' => variable_get('visualize_backtrace_debug_duplication', 0),
    '#description' => t("Display some additional information in the Full Function Callstack table to help debug the visualize_backtrace_detect_repeating_functions() code. Only relevent when the Repeating Functions are being hidden.")  
  );
  
  
  return system_settings_form($form);
}


/**
 * Implementation of hook_block().
 * 
 */
function visualize_backtrace_block($op = 'list', $delta = 0) {
  if ($op == 'list') {
    $blocks[0]['info'] = t('View Backtrace Graphs');
    return $blocks;
  }
  else if ($op == 'view') {
    switch ($delta) {
      case 0:
        if (user_access('administer visualize backtrace')) {
          $block['subject'] = t('Visualize Backtrace');
            // Get the trace log number by striping out number from /tmp/trace.####.xt file.
            $current_trace_number = explode('.', xdebug_get_tracefile_name());
            $current_trace_number = $current_trace_number[1];
          $links[] = l('Generate Backtrace Data for this Page Load', 'visualize_backtrace/'. $current_trace_number .'/hide_callstack/all_sections');
          $links[] .= l('View All Past Trace Files', 'view_traces');
          $links[] .= l('Color Code Key', 'visualize_backtrace_color_codes');
          $links[] .= l('Admin Settings', 'admin/settings/visualize_backtrace');
        }
        if ($links) {
          $block['content'] = theme('item_list', $links);
        }
        break;
    }
    return $block;
  }
}

/**
 * Implementation of hook_perm
 */
function visualize_backtrace_perm() {
  return array('administer visualize backtrace');
}

/**
 * Displays the Drupal source code stored on your localhost in the browswer so
 * that you can toggle between the function call graph and the specific source
 * code line number.  It provides permalink anchors to each line of your Drupal
 * source code along with proper PHP syntax highlighting
 */
function visualize_backtrace_view_source_code() {
  // For security considerations, prevent the settings.php file being displayed
  // There should be a better way to do this -- as I think it's throwing a lot of error handlers
  //return "test";
  if (arg(3) != "settings.php") $handle = @fopen(arg(1) ."/". arg(2) ."/". arg(3) ."/". arg(4) ."/". arg(5) 
                                          ."/". arg(6) ."/". arg(7) ."/". arg(8) ."/". arg(9) ."/". arg(10) ."/", "r");
  if ($handle) {
    $i = 1;

    $total_buffer = "";

    while (!feof($handle)) {
      $buffer = fgets($handle, 4096);
      // Add in extra spaces before the colon so that the code will be aligned
      // independent of extra spaces due to counter digit increases (i.e. 9 to 10)
      $right_align = "";
      if ($i < 1000) $right_align = " ";
      if ($i < 100) $right_align = "  ";
      if ($i < 10) $right_align = "   ";
      $total_buffer .= "XXX_BEGIN_XXX". $i ."XXX_END_XXX". $i . $right_align .": ". $buffer;
      $i++;
    }
    
    // Add a few more line breaks to separate the devel query info
    $total_buffer .= "XXX_REPLACE_WITH_LINE_BREAKS_XXX";
    
    // Do the PHP Syntax highlighting
    $total_buffer = highlight_string($total_buffer, 1);

    // Get rid of extra line breaks -- via codefilter.module @codefilter_process_php()
    $total_buffer = str_replace("\n", '', $total_buffer);

    // fix spaces -- via codefilter.module @codefilter_fix_spaces()
    $total_buffer = preg_replace('@&nbsp;(?!&nbsp;)@', ' ', $total_buffer);
    
    // Replace the placeholder XXX_BEGIN_XXX and XXX_END_XXX with anchor info (e.g. <a name ="45"></a> for line #45)
    $total_buffer = str_replace("XXX_BEGIN_XXX", '<a name="', $total_buffer);
    $total_buffer = str_replace("XXX_END_XXX", '"></a>', $total_buffer);
    $total_buffer = str_replace("XXX_REPLACE_WITH_LINE_BREAKS_XXX", '<br /><br />', $total_buffer);
    $total_buffer = '<div style="font-size: '. variable_get('visualize_backtrace_source_code_font_size', 12) .'px">'. $total_buffer .'</div>';

    echo $total_buffer;
    fclose($handle);
  }
}

/**
 * This is the main function that parses the trace file data into graphable
 * flowcharts. The full function call backtrace is split into three sections:
 * Bootstrap, Main, and Theme -- along with three optional subsections for the
 * Main section if it is too large to graph at once. It is also possible to view
 * the backtrace table and flowchart for a specific function
 *
 * Here are the URL Arguments:
 * arg(0) = 'visualize_backtrace' initializes this fuction via menu_callback
 * arg(1) = XDebug trace number to be parsed
 * arg(2) = Flag to display a text table of all of the fuction calls that 
 *          includes links to graph the backtraces of specific function calls
 * arg(3) = $subsection_argument: Automatically graphs the flowchart of a
 *          specified section and displays just that portion of the callstack
 *          table. (i.e. "section_2")
 *          It also could be a flag to display either the
 *          backtrace or forwardtrace for a specific function
 *          (i.e. "show_function_backtrace" or "show_function_forwardtrace")
 *          It can also be a flag to display all of the functions referenced
 *          from a specific module filename
 *          (i.e "show_filename_backtrace" or "show_filename_forwardtrace")
 * arg(4) = Show either the backtrace or forwardtrace of this specified function
 *          or specified filename.
 *          It could also be a flag to to display all of the functions that
 *          appear in filenames in the contributed module sites-all directory
 *          (i.e. "capture_all_contrib_functions")
 *
 * Quickly create the graphviz *.dot files with this splash page default view:
 * /visualize_backtrace/1191366294/hide_callstack/all_sections/
 *
 * Create the *.dot files and display all of the function calls in table form:
 * /visualize_backtrace/1191366294/view_callstack/all_sections/
 *
 * Create the *.dot files, display a subsection of the function calls in table
 * form and automatically plot the backtrace flowchart for this section:
 * /visualize_backtrace/1191366294/view_callstack/section_1
 * 
 * Create the *.dot files, display the backtraces for a specific function call,
 * and automatically plots them
 * /visualize_backtrace/1191366294/view_callstack/show_function_backtrace/db_query/
 *
 * Create the *.dot files, display the backtraces & the forwardtraces for a
 * specific function call, and automatically plots them.
 * /visualize_backtrace/1191366294/view_callstack/show_function_forwardtrace/db_query/
 *
 * Create the *.dot files, display the backtrace for all of the functions from
 * a specific module filename and automatically plots them.
 * visualize_backtrace/1191366294/view_callstack/show_filename_backtrace/includes-menu.inc
 * 
 * Create the *.dot files, display all the backtraces for all of the functions
 * that are called from a contributed module filename & automatically plots them
 * visualize_backtrace/1191366294/view_callstack/show_filename_backtrace/capture_all_contrib_functions
 *  
 * NOTE: XDebug must be installed & properly configured for this to work.
 * See the INSTALL.txt or http://xdebug.org for more information
 */
function visualize_backtrace_generate() {
  menu_rebuild();
  global $base_url;
  
  // The argument that is passed in is the trace number
  $trace_number = arg(1);

  // Determine the XDebug trace file path by parsing the result of the
  // xdebug_get_tracefile_name() function
  $trace_file = visualize_backtrace_get_xdebug_tracefile_path();
  
  // Add the trace number to duplicate the full path (e.g. $trace_file = "/tmp/trace.1189698885.xt") 
  $trace_file .= "trace.". $trace_number .".xt";
    
  // After determining the XDebug tracefile from the arguments, then parse out the relevent columns with an
  // awk shell command. The following awk variables read in the tab-separated data created by XDebug w/ the
  // following values: $1 = level, $2 = function_number, $3 = always_zero, $4 = time_index, $5 = memory,
  // $6 = function_name, $7 = defined_function, $8 = via_filename,
  // if ($10 exists) then {$9 = included_file; $10 = line_number} else {$9 = line_number}
  // See this page to verify all of the information that XDebug should be outputting:
  // http://xdebug.org/docs/all_settings#trace_format
  // We're interested in the Drupal function data (i.e. $3 = 0 & $7 = 1), but the awk command
  // also appends the previous PHP function data if the Drupal function's line number = 0.
  // This command creates a new trace file w/ "parsed" appended to the name (i.e. "/tmp/trace.1189698885.xtparsed")
  // Here is the full command $ cat -v /tmp/trace.1191544445.xt | awk {'if($3==0 && $7==0) {level = $1; function_number = $2; function_name = $6; line_number = $9; via_filename = $8; time_index = previous_time_index; memory = previous_memory} if($3 == 0 && $7 == 1 && $10) {if($10==0) {print $1 "\t" $2 "\t" $6 "\t" $9 "\t" $10 "\t" previous_time_index "\t" previous_memory "\t" function_name "\t" level "\t" function_number "\t" via_filename "\t" line_number "\t" time_index "\t" memory} else {print $1 "\t" $2 "\t" $6 "\t" $9 "\t" $10 "\t" previous_time_index "\t" previous_memory}} if($3 == 0 && $7 == 1 && !$10) {if($9==0) {print $1 "\t" $2 "\t" $6 "\t" $8 "\t" $9 "\t" previous_time_index "\t" previous_memory "\t" function_name "\t" level "\t" function_number "\t" via_filename "\t" line_number "\t" time_index "\t" memory} else {print $1 "\t" $2 "\t" $6 "\t" $8 "\t" $9 "\t" previous_time_index "\t" previous_memory}} if($5) {previous_time_index = $4; previous_memory = $5;} if($1 > 0 && $2 > 0 && !$4) {print $1 "\t" $2}'} > /tmp/trace.1191544445.xtparsed
  $parse_trace_command = 'cat -v '. $trace_file .' | ';
  $parse_trace_command .= 'awk {\'';
                            // Save the data for each non-Drupal PHP function to be able to reference it if a procedural hook is called
                            // The time index and memory values are after the function has run,
                            // and so shift them to the next row where they will represent the beginning
                            // & so that the time & memory delta will be ($function_count+1)-$function_count 
  $parse_trace_command .=   'if($3==0 && $7==0) {';
  $parse_trace_command .=     'level = $1; function_number = $2; function_name = $6; line_number = $9; via_filename = $8; time_index = previous_time_index; memory = previous_memory';
  $parse_trace_command .=   '} ';
                            // Check to see if this is a Drupal function (i.e. $3 = 0 & $7 = 1)
                            // If there is a value for column $10, then that means that an include file is being added,
                            // which means that $9 = via_filename & $10 = line_number
  $parse_trace_command .=   'if($3 == 0 && $7 == 1 && $10) {';
                               // If the line number is 0, then add in the previous PHP function data
  $parse_trace_command .=      'if($10==0) {';
  $parse_trace_command .=        'print $1 "\t" $2 "\t" $6 "\t" $9 "\t" $10 "\t" previous_time_index "\t" previous_memory "\t" function_name "\t" level "\t" function_number "\t" via_filename "\t" line_number "\t" time_index "\t" memory';
  $parse_trace_command .=      '} ';
  $parse_trace_command .=      'else {';
  $parse_trace_command .=        'print $1 "\t" $2 "\t" $6 "\t" $9 "\t" $10 "\t" previous_time_index "\t" previous_memory';
  $parse_trace_command .=      '}';
  $parse_trace_command .=   '} ';
                            // Most of the Drupal function won't have a column $10, which means that $8 = via_filename & $9 = line_number
  $parse_trace_command .=   'if($3 == 0 && $7 == 1 && !$10) {';
                              // If the line number is 0, then add in the previous PHP function data
  $parse_trace_command .=     'if($9==0) {';
  $parse_trace_command .=       'print $1 "\t" $2 "\t" $6 "\t" $8 "\t" $9 "\t" previous_time_index "\t" previous_memory "\t" function_name "\t" level "\t" function_number "\t" via_filename "\t" line_number "\t" time_index "\t" memory';
  $parse_trace_command .=     '} ';
  $parse_trace_command .=     'else {';
  $parse_trace_command .=       'print $1 "\t" $2 "\t" $6 "\t" $8 "\t" $9 "\t" previous_time_index "\t" previous_memory';
  $parse_trace_command .=     '}';
  $parse_trace_command .=   '} ';
                            // Store this row's end time and end memory
                            // It will be used as the next row's beginning time and beginning memory
  $parse_trace_command .=   'if($5) {';
  $parse_trace_command .=     'previous_time_index = $4; previous_memory = $5;';
  $parse_trace_command .=   '} ';
                            // This will print out the final Time and Memory values on the 2nd to last line
                            // It will also inadvertantly output the XDebug version info from the first line,
                            // but it will be filtered out when it's read back in
  $parse_trace_command .=   'if($1 > 0 && $2 > 0 && !$4) {';
  $parse_trace_command .=     'print $1 "\t" $2';
  $parse_trace_command .=   '}';
  
  $parse_trace_command .= '\'} > '. $trace_file .'parsed';
  shell_exec($parse_trace_command);

  // Flowchart nodes can be hypertext linked to the specific source code line where the function calls was executed
  // If the link location variable is set to local, then it will use the visualize_backtrace_view_source_code() callback for viewing local copies of code
  // The "local" option is primarily for viewing local copies of code for that is being written for custom modules or core development
  // before a CVS commit has been made.
  // The "Drupal52_CVS" option is for creating hyperlinked SVG files that have accessible permalinks to the CVS.drupal.org source code lines
  // Primarily for documentation purposes, and the specific version numbers for Drupal 5.2 are included in the $lookup_table()
  $source_code_link_location = variable_get('visualize_backtrace_source_code_link_location', 'local');
  $lookup_table = visualize_backtrace_get_lookup_table_values($source_code_link_location);

  // intitialize variables
  $row = 0;
  $function_call_data = array();
  $function_call_data[1]['time_index'] = 0;
  $function_call_data[1]['memory'] = 0;

  // Extraneous filename path data will be stripped out (i.e. "/Library/WebServer/Documents/d52/") by subtracting out the length of UNIX base_path
  // TODO: Possibly replace some of these things with The Drupal core functions...
  $unix_base_path = shell_exec("pwd");

  // Open up the parsed trace file
  $handle = fopen($trace_file ."parsed", "r");
  while (($data = fgetcsv($handle, 1000, "\t")) !== FALSE) {
    // If there is a fifth column then that means that the Line = 0 for this function because it was called by
    // a previously-called PHP function -- usually either preg_replace_callback or call_user_func_array
    $data_length = count($data);
    // If a row has 14 columns, then it has line = 8 and need to save the PHP function first.
    // The first row of data also has 14 columns, but the last 9 columns are blank
    if ($row > 0 && $data_length > 8) {
      // Add the PHP function data to the function call list only if it is a previous level than the Drupal Function
      // Also don't add the previous PHP function if the function is an error_handler
      if ($data[8] < $data[0] && $data[2] != "error_handler") {  
        // First add in an additional row for the PHP function so that the levels will be plotted out correctly
        $row++;
        $function_call_data[$row]['PHP_function'] = TRUE;
        $function_call_data[$row]['level'] = $data[8];
        $function_call_data[$row]['function_number'] = $data[9];
        // This is the PHP function name
        $function_call_data[$row]['function_name'] = $data[7];
        // Strip out the base path info from the via_filename in order to normalize the file path for the lookup arrays
        $function_call_data[$row]['via_filename'] = substr($data[10], (strlen($data[10])-strlen($unix_base_path))*-1);
        $function_call_data[$row]['line_number'] = $data[11];
        $function_call_data[$row]['time_index'] = $data[12];
        $function_call_data[$row]['memory'] = $data[13];
        $function_call_data[$row]['via_PHP_function'] = "";
      }

      // Then add in the Drupal function
      $row++;
      $function_call_data[$row]['PHP_function'] = FALSE;
      $function_call_data[$row]['level'] = $data[0];
      $function_call_data[$row]['function_number'] = $data[1];
      $function_call_data[$row]['function_name'] = $data[2];
      $function_call_data[$row]['via_filename'] = substr($data[3], (strlen($data[3])-strlen($unix_base_path))*-1);
      $function_call_data[$row]['line_number'] = $data[4];
      $function_call_data[$row]['time_index'] = $data[5];
      $function_call_data[$row]['memory'] = $data[6];
      // Add data that will later be used as a label to indicate that this function was called from a PHP function
      $function_call_data[$row]['via_PHP_function']='\n* via: ';
      
    }
    else {
      // Add in the metadata for the Drupal functions called by other Drupal functions
      // Filter out eval function names since the drupal_eval code yields irregular trace file data
      // The final time and memory values only have two columns, and so make sure the fourth column has a number
      // Also filter out the the erroneous "Version:" info on the first line of the parsed file
      //if ($data[2] != "eval" && $data[0] != "Version:" && is_numeric($data[4])) {
      if ($data_length > 2) {
        if ($data[2] != "eval") {
          $row++;
          $function_call_data[$row]['PHP_function'] = FALSE;
          $function_call_data[$row]['level'] = $data[0];
          $function_call_data[$row]['function_number'] = $data[1];
          $function_call_data[$row]['function_name'] = $data[2];
          $function_call_data[$row]['via_filename'] = substr($data[3], (strlen($data[3])-strlen($unix_base_path))*-1);
          $function_call_data[$row]['line_number'] = $data[4];
          $function_call_data[$row]['time_index'] = $data[5];
          $function_call_data[$row]['memory'] = $data[6];
          $function_call_data[$row]['via_PHP_function']="";
        }
      }
      elseif ($data[0] != "Version:") {
        $final_time = $data[0];
        $final_memory = $data[1];
      }
    }
  }

  // Save the total number of $rows to loop through after the duplicate functions have been removed.
  $total_rows = $row;
  
  // Close the parsed trace file.
  fclose($handle);

  // Detect whenever 1, 2 or 3 functions iteratively repeat
  // The function all data is returned with a 'function_repeat' flag set to 1 if
  // the function is part of a single, double or triple iterating loop
  // Added an admin option to determine whether repeating functions should be filtered out
  if (variable_get('visualize_backtrace_hide_repeating_functions', 1)) {
    $function_call_data = visualize_backtrace_detect_repeating_functions($function_call_data);
  }
  
  // Initialize Variables
  // Check arg(3) to see if the backtrace for a specific function should be graphed and output into a table
  $subsection_argument = arg(3);
  if ($subsection_argument == "show_function_backtrace" || $subsection_argument == "show_function_forwardtrace") {
    $capture_function = arg(4);
    $capture_function_backtrace_flag = TRUE;
    $subgraph_cluster_count = 0;
    $capture_function_count = 0;
    if ($subsection_argument == "show_function_forwardtrace") {
      $capture_function_forwardtrace_flag = TRUE;
    }
    $capture_contrib_functions = FALSE;
    // Make sure that functions with null filenames don't get marked as a capture function
    $capture_filename = "xxx";
  }
  // Use the same capture_function codebase to capture all instances of a specific module filename
  elseif ($subsection_argument == "show_filename_backtrace" || $subsection_argument == "show_filename_forwardtrace") {
    // Restore the '/' filepath argument delimiters by replacing any inserted '-' delimiters
    $capture_filename = preg_replace('/-/', '/', arg(4));
    // Check to see if a special flag has been set in arg(4) to capture all contributed functions
    $capture_contrib_functions = FALSE;
    if ($capture_filename == 'capture_all_contrib_functions') {
      // This variable can be defined in the admin section
      $contrib_module_filepath = variable_get('visualize_backtrace_contrib_module_filepath', 'sites/');
      $capture_contrib_functions = TRUE;
    }
    $capture_function_backtrace_flag = TRUE;
    $subgraph_cluster_count = 0;
    $capture_function_count = 0;
    if ($subsection_argument == "show_filename_forwardtrace") {
      $capture_function_forwardtrace_flag = TRUE;
    }
  }
  else {
    $capture_function_backtrace_flag = FALSE;
    $capture_contrib_functions = FALSE;
  }
  
  $function_call_stack = array();
  // Create a 0-level index value for the function call stack to connect level=1 functions at the end
  $function_call_stack[0] = "index.php";

  // Keep track of whether or not the theme() function was executed from index.php
  $index_theme_executed = FALSE;

  // Intialize the *.dot output arrays
  $output_to_dot_all = array();
  $output_to_dot_function = array();

  $row=1;
  $function_count = 0;
  
  // Loop through the results to store the time and memory values in an array with a $key of the $function_count
  // This makes it possible to calculate the deltas with ($function_count + 1) without knowing
  // which future $row number is the next non-repeating function
  // (i.e. $time_delta = $time_index_array[($function_count+1)] - $time_index_array[$function_count] )
  while ($row <= $total_rows) {
    if (!$function_call_data[$row]['function_repeat']) {
      $function_count++;
      $time_index_array[$function_count] = $function_call_data[$row]['time_index'];
      $memory_array[$function_count] = $function_call_data[$row]['memory'];
    }
    $row++;
  }
  // Add the final time and memory values at the end of the array in order to properly calculate the last function's values
  $time_index_array[($function_count+1)] = $final_time;
  $memory_array[($function_count+1)] = $final_memory;

  // Re-Initialize the $row & $function_count
  $row=1;
  $function_count = 0;
  $capture_function_depth = 1;
  $drupal_version = floor(VERSION);
  $time_threshold = variable_get('visualize_backtrace_execution_threshold', 5);
  
  /**
    * Generate the *.dot syntax for each function call by looping through all of
    * the nodes & skipping over the repeating functions
    * Optionally capture the backtrace or forwardtrace data for specific functions
    */
  while ($row <= $total_rows) {
    // Verify that this row has not been flagged as a repeating function
    if (!$function_call_data[$row]['function_repeat']) {
      $level = $function_call_data[$row]['level'];
      $function_number = $function_call_data[$row]['function_number'];
      $function_name = $function_call_data[$row]['function_name'];
      $via_filename = $function_call_data[$row]['via_filename'];
      $line_number = $function_call_data[$row]['line_number'];
      $via_PHP_function = $function_call_data[$row]['via_PHP_function'];
      $repeating_function_label = $function_call_data[$row]['repeating_function_label'];

      // This function count counts the number of non-repeating functions so that it can be shown on the flowchart as
      // "f" plus the function count number.
      // The function count also serves as the array index for the output data to be written to the *.dot file.
      $function_count++;
      $function_call_data[$row]['function_count'] = $function_count;
      
      // If this was a procedural Drupal hook function, then use the previous level's function_id to determine
      // the correct via_filename & line_number -- as well as correct referential function_name for the via_PHP_function label 
      if ($via_PHP_function) {
        // The function id is delimited by a double underscore so explode it to determine the correct PHP reference info
        $previous_level_function_id = $output = explode('__', $function_call_stack[$level-1]);
        $via_filename = $previous_level_function_id[1];
        $line_number = $previous_level_function_id[2];
        // Tack on the correct previous function to the via_PHP_function label
        $via_PHP_function .= $previous_level_function_id[0];
      }

      // The function_id uniquely identifies this function by combining the Function name + filename reference +
      // line number + function call count.  The function call count prevents commonly run functions from making
      // the output both clustered and more complicated to follow
      // Functions with a line number of 0 use the line number of the previous PHP function to make it easier
      // to link to the source code location where procedural hooks are called
      $function_id = $function_name ."__". $via_filename ."__". $line_number ."__". $function_count;
      
      // This array keeps track of the call stack tree for any given function call.
      // It is used for creating the nodal connections
      $function_call_stack[$level] = $function_id;
     
      // The node color & the source code Links Permalinks for each filename
      // If the CVS permalink w/ version number isn't defined, then either manually add it to the
      // $lookup_table array in visualize_backtrace_get_lookup_table_values() section of code.
      // Otherwise, it will default to the local copy, but the lines won't be accessible for
      // documentation purposes (i.e. in creating a hypertext linked SVG)
      if ($source_code_link_location == "local") {
        $lookup_table[$via_filename]["source_code_line_url"] = $base_url ."/view_source/". $via_filename ."#";
      }
      else {
        if ($lookup_table[$via_filename]["source_code_line_url"] == "") {
          $lookup_table[$via_filename]["source_code_line_url"] = $base_url ."/view_source/". $via_filename ."#";
        }
      }

      // The node connection colors are sequentially alternated in order to help match the correct
      // label to each line, which helps in cluttered graphs.
      // Get the last digit of the function_count to determine the color for the node connection
      $node_connection_color = $lookup_table["node_connection_color"][$function_count % 10];

      // Create the node connection data for each row.
      // The *.dot syntax will end up looking like the following:
      // "{main}_1_1" -> "require_once__index.php_12_2" [label="f2" href="http://api.drupal.org/api/function/require_once/5" color="#FF0000" fontcolor="#FF0000"];
      $node_connection_data = '"'. $function_call_stack[$level-1] .'" -> "'. $function_id .'" [label="f'. $function_count .'" href="http://api.drupal.org/api/function/'. 
                              $function_name .'/'. $drupal_version .'" color="'. $node_connection_color .'" fontcolor="'. $node_connection_color .'"]; ';

      $time_delta[$function_count] = round(($time_index_array[($function_count+1)] - $time_index_array[$function_count])*1000, 3);
      $memory_delta[$function_count] = round(($memory_array[($function_count+1)] - $memory_array[$function_count])/1000, 3);
            
      // Create the node label with the function name, filename, line number & function number,
      // as well as the node color and a hypertext link to the specific line number code.
      // Procedural Drupal Hooks are labeled with a $via_PHP_function label
      // Looping sets of 1, 2 or 3 functions are also labeled with how many times they repeat.
      // The label will end up looking something like:
      // "require_once__index.php_12_2" [label="require_once\nindex.php\nline: 12\nf2" color="#C7E9B4" href="http://cvs.drupal.org/viewvc.py/drupal/drupal/index.php?annotate=1.91#l12"];
      $node_label = '"'. $function_id .'" [label="'. $function_name .'\n'. $via_filename . $via_PHP_function . $repeating_function_label .'\nline: '. $line_number .'\nf'. $function_count .' -- '. $time_delta[$function_count] .'ms" "'. $level .' "color="'. 
                    $lookup_table[$via_filename]["node_color_hex"] .'" href="'. $lookup_table[$via_filename]["source_code_line_url"] . $line_number .'"];';
      $output_to_dot_all[$function_count] = $node_connection_data . $node_label;
      
      /**
        * If a capture function is passed in via arg(4), then capture the backtrace & forwardtrace data
        * (i.e. backtrace = parent functions & forwardtrace = children functions)
        */
      if ($capture_function_backtrace_flag) {
        if ($capture_contrib_functions) {
          // Check to see if this function is called from a contributed module filename
          // (i.e. if via_filename begins with 'sites/' -- or whatever the $contrib_module_filepath is)
          if (substr($via_filename, 0, strlen($contrib_module_filepath)) == $contrib_module_filepath) {
            $capture_contrib_functions_flag = TRUE;
          }
        }
        // Initialize the variable that will flag the capture functions
        $capture_function_flag[$function_count] = FALSE;
        
        // Each time the $capture_function is called, then capture the parent backtrace functions
        if ($function_name == $capture_function || $via_filename == $capture_filename || $capture_contrib_functions_flag) {
          $function_level_loop = $level;
          
          // Loop backwards down through the previous function call stack levels
          // to extract the function count numbers of all of the functions in the backtrace
          while ($function_level_loop > 0) {
            // explode the function_id to get the function count
            $previous_function_count = explode('__', $function_call_stack[$function_level_loop]);
            // Save the *.dot syntax code for that particular function count
            // If it is the captured function, then highlight it with a pink box (i.e. a GraphViz subgraph cluster)
            // if $capture_function_flag is already TRUE, then the captured function is a child of itself &
            // appears in its own backtrace so don't overwrite the label & inserted box
            if (!$capture_function_flag[$previous_function_count[3]]) {
              // Flag the captured function so that it can be marked with a box later on
              // The captured function happens when the function_level_loop = the current $level
              // Also keep track of the total number of times that the function occurs
              if ($function_level_loop == $level) {
                
                $subgraph_cluster_count++;
                $output_to_dot_function[$previous_function_count[3]] = $output_to_dot_all[$previous_function_count[3]];
                
                // Keep track of the captured function's function count to highlight in the callstack table
                $capture_function_flag[$previous_function_count[3]] = TRUE;

                // Keep track of the total number of times this function has been called
                // including any number of repeats calculated in the visualize_backtrace_detect_repeating_functions() function
                if ($function_call_data[$row]['repeating_function_count']) {
                  $capture_function_count = $capture_function_count + $function_call_data[$row]['repeating_function_count'];
                }
                // This instance of the capture function is not in a repeating loop
                else {
                  $capture_function_count++;
                }
                                
                // Check to see if this is a nested instance of the captured function by first
                // checking to see if the $capture_function_children_flag is still set to TRUE
                if ($capture_function_children_flag) {
                  // If the current level is greater than the level stored in the captured function level array,
                  // then add another level to the depth index.
                  if ($level > $capture_function_level_array[$capture_function_depth]) {
                    $capture_function_depth++;
                    // Add this nested child captured function to the parent capture function's count & time sum
                    // Start at one less the current depth and go down to the bottom level (i.e. top parent)
                    $capture_function_depth_key = $capture_function_depth - 1;
                    while ($capture_function_depth_key >= 1) {
                      $subgraph_cluster_count_index = $capture_function_cluster_number[$capture_function_depth_key];
                      $capture_function_children_time_sum[$subgraph_cluster_count_index] = $capture_function_children_time_sum[$subgraph_cluster_count_index] + $time_delta[$function_count];
                      $capture_function_children_count[$subgraph_cluster_count_index]++;
                      $capture_function_depth_key--;
                    }
                  }
                  // If the depth is greater than one, then first check to see if the depth needs to be reduced,
                  // and then determine whether or not to add in this function's time to the previous depths (i.e. parent functions)
                  elseif ($capture_function_depth > 1) {
                    // Check to see if the depth needs to be iteratively reduced
                    // (i.e. whenever a nested function's forwardtrace tree ends)
                    $reduce_depth_flag = TRUE;
                    while ($reduce_depth_flag) {
                      // Check to see if the current level is less than or equal to the stored level at the previous depth --
                      // while making sure not to decrement the depth down to 0
                      if ($level <= $capture_function_level_array[$capture_function_depth-1] && $capture_function_depth >= 1) {
                        // This marks the end of a previous nested capture function forward trace,
                        // and so reduce the capture function depth & zero out the stored level array at that depth
                        $capture_function_level_array[$capture_function_depth] = 0;
                        $capture_function_depth--;
                      }
                      else {
                        // Stop reducing the depth since this function's $level is now equal to or
                        // greater than $capture_function_level_array[$capture_function_depth]
                        $reduce_depth_flag = FALSE;
                      }
                    }
                    // Add this function's time data & count to its parent captured function(s) by looping through the previous depths
                    $capture_function_depth_key = $capture_function_depth - 1;
                    while ($capture_function_depth_key >= 1) {
                      $subgraph_cluster_count_index = $capture_function_cluster_number[$capture_function_depth_key];
                      $capture_function_children_time_sum[$subgraph_cluster_count_index] = $capture_function_children_time_sum[$subgraph_cluster_count_index] + $time_delta[$function_count];
                      $capture_function_children_count[$subgraph_cluster_count_index]++;
                      $capture_function_depth_key--;
                    }
                  }
                }
                
                // Set the flag to start capturing data on the children functions of this capture function
                $capture_function_children_flag = TRUE;

                // Save both the level & count of this captured function in case there are any captured function children
                $capture_function_level_array[$capture_function_depth] = $level;
                $capture_function_cluster_number[$capture_function_depth] = $subgraph_cluster_count;
                
                // Determine the number of and elapsed time of all of the functions that come after the captured function -- if any
                $capture_function_children_time_sum[$subgraph_cluster_count] = 0;
                $capture_function_children_count[$subgraph_cluster_count] = 0;
                
                // Keep track of where this captured function's function count for inserting the children time sum and count later on
                $capture_function_index[$subgraph_cluster_count] = $function_count;

              }
              // Save the backtrace nodal connections for this instance of the captured function as it loops backwards through the backtrace levels
              else {
                $output_to_dot_function[$previous_function_count[3]] = $output_to_dot_all[$previous_function_count[3]];
              }
            }
            $function_level_loop--;
          }
        }

        /**
          * Now gather the forwardtrace data for the captured function
          * Capture the total count and length of time it takes of the children functions of the captured function
          * Stop capturing children function data when the current row's $level is equal to or less than the $capture_function_level
          * Graph the children functions to the $output_to_dot_function array if arg(3) = 'show_function_forwardtrace' --
          * otherwise the children function count and length of run time is plotted on the backtrace graph
          */
        else {
          if ($capture_function_children_flag) {
            // Check to see if the current level is lower than the last captured function depth
            // If so, then either reduce the capture function level depth if it is a nested function
            // or stop capturing the child functions of the forwardtraced capture function
            if ($level <= $capture_function_level_array[$capture_function_depth]) {
              // Check to see if it is at the initial depth, or if the depth needs to be reduced.
              if ($capture_function_depth == 1) {
                // The current $level is equal to or less than the capture function & is not a nested capture function
                // and so stop marking functions as children of the capture function
                $capture_function_children_flag = FALSE;
              }
              else {
                // The previous nested capture function tree has ended, and so reduce the depth to the previous level
                $reduce_depth_flag = TRUE;
                while ($reduce_depth_flag) {
                  // Check to see if the current level is less than or equal to the stored level at the previous depth --
                  // while making sure not to decrement the depth down to 0
                  if ($level <= $capture_function_level_array[$capture_function_depth-1] && $capture_function_depth >= 1) {
                    // This marks the end of a previous nested capture function forward trace,
                    // and so reduce the capture function depth & zero out the stored level array at that depth
                    $capture_function_level_array[$capture_function_depth] = 0;
                    $capture_function_depth--;
                  }
                  else {
                    // Stop reducing the depth because this function's $level is now equal to or
                    // greater than $capture_function_level_array[$capture_function_depth]
                    $reduce_depth_flag = FALSE;
                  }
                }
                // Do a final check after reducing the depth to see if the $level is equal to or less than
                // the stored level @ capture_function_depth=1
                if ($level <= $capture_function_level_array[$capture_function_depth]) {
                  // Stop marking functions as children of the capture function
                  $capture_function_children_flag = FALSE;
                }
              }
            }

            // Store the child data for this $capture_function
            if ($capture_function_children_flag) {
              // Save the children functions to the *.dot file if the Forwardtrace flag is set
              if ($capture_function_forwardtrace_flag) {  
                $output_to_dot_function[$function_count] = $output_to_dot_all[$function_count];
              }
              // Sum the total length of all of the children functions of the capture function
              // Start at the lowest depth and loop through up to the current depth
              $capture_function_depth_key = 1;
              while ($capture_function_depth_key <= $capture_function_depth) {
                $subgraph_cluster_count_index = $capture_function_cluster_number[$capture_function_depth_key];
                $capture_function_children_time_sum[$subgraph_cluster_count_index] = $capture_function_children_time_sum[$subgraph_cluster_count_index] + $time_delta[$function_count];
                $capture_function_children_count[$subgraph_cluster_count_index]++;
                $capture_function_depth_key++;
              }
            }
          }
        }
        $capture_contrib_functions_flag = FALSE;
      }  // END of capturing the backtrace parent functions & forwardtrace children functions
    
      // Capture all of the functions in between {main} and menu_execute_active_handler @ level=2
      // This contains the Drupal bootstrap section which doesn't have a lot of variations
      if ($function_name == "{main}") {
        $section_endpoint[1]['begin'] = $function_count;
      }
      // Capture all of the functions in between menu_execute_active_handler @ level=3 and theme @ level=2
      // This section is usually the bulk of the relevent functions and may need to be broken up in order to be plotted all at once
      // Section two is broken up into three equal sections in section numbers 4, 5 & 6
      if ($function_name == "menu_execute_active_handler" && $level == 2) {
        $section_endpoint[1]['end'] = $function_count-1;
        $section_endpoint[2]['begin'] = $function_count;
      }
      // Capture all of the functions in between theme @ level=2 and the end
      // This contains a lot of the theming-specific code.
      if ($function_name == "theme" && $level == 2) {
        $index_theme_executed = TRUE;
        $section_endpoint[2]['end'] = $function_count-1;
        $section_endpoint[3]['begin'] = $function_count;
      }      
    } 
    $row++;
  } 
  // Determine the final $row number for the last subsection
  if ($index_theme_executed) {
    $section_endpoint[3]['end'] = $function_count;
  }
  else {
    $section_endpoint[2]['end'] = $function_count;
  }

  // Sometimes the Main Section is too big to be plotted all at once, and so split it up into three equal sections
  // Creating three main subsecions is an option that can be turned off in the admin section
  $create_main_subsections = variable_get('visualize_backtrace_create_main_subsections', 1);
  if ($create_main_subsections) {
    $section_endpoint[4]['begin'] = $section_endpoint[2]['begin'];
    $section_endpoint[4]['end'] = round(($section_endpoint[2]['end']-$section_endpoint[2]['begin'])/3) + $section_endpoint[4]['begin'];
    $section_endpoint[5]['begin'] = $section_endpoint[4]['end'];
    $section_endpoint[5]['end'] = round(($section_endpoint[2]['end']-$section_endpoint[2]['begin'])/3) + $section_endpoint[5]['begin'];
    $section_endpoint[6]['begin'] = $section_endpoint[5]['end'];
    $section_endpoint[6]['end'] = $section_endpoint[2]['end'];
    $section = 6;
    $main_sections = 6;
  }
  else {
    $section = 3;
    $main_sections = 3;
  }
  
  //// DEBUGGING: Print the start and stop row numbers for each of the 6 sections
  //$i=1;
  //while ($i <= $section) {
  //  print $i ." begin = ". $section_endpoint[$i]['begin']. " end = ".  $section_endpoint[$i]['end'] ."<br>";
  //  $i++;
  //}

  // Loop through each of the section numbers
  $section_number = 0;
  $output_to_dot = array();

  // Section 0 contains all of the all three subsections
  $output_to_dot[0] = 'digraph G {graph [ordering="out"]; node [style=filled];'. implode("", $output_to_dot_all) .'}';
  $section_length[0] = count($output_to_dot_all);


  // Add another section for the captured backtrace for a specific function if the
  // arg(3) is either 'show_function_backtrace' or 'show_function_forwardtrace'
  if ($capture_function_backtrace_flag) {
    // Insert a box around the captured functions that includes the total number and length of child functions of each captured function
    // The box is a "subgraph cluster" that is inserted after the nodal connection & before the node label
    // This is done by replacing '"]; "' with the subgraph code of '"]; subgraph cluster1{color="#000000"; label="Function #01 w/ 8 children = 1.068ms" "'
    foreach ($capture_function_index as $subcluster_count_key => $function_count_value) {
      if ($capture_function_children_count[$subcluster_count_key] > 0) {
        if ($capture_function_children_time_sum[$subcluster_count_key] > $time_threshold) {
          // Place a red box around the functions that exceed the time threshold (default threshold is 5 ms)
          $box_color = "#FF9BD1";
          $add_mark = TRUE;
        }
        else {
          // Place a green box around all of the other functions that are below the time threshold
          $box_color = "#7FCDBB";
          $add_mark = FALSE;
        }
        // Place a leading 0 before the fuction numbers less than 10
        if ($subcluster_count_key < 10) {
          // Re-save this capture function child data w/ the function count as the array index to display in the callstack table
          $capture_function_child_data[$function_count_value] = 'Function #0'. $subcluster_count_key .' w/ '. $capture_function_children_count[$subcluster_count_key] .' children = '. $capture_function_children_time_sum[$subcluster_count_key] .'ms';
        }
        else {
          // Re-save this capture function child data w/ the function count as the array index to display in the callstack table
          $capture_function_child_data[$function_count_value] = 'Function #'. $subcluster_count_key .' w/ '. $capture_function_children_count[$subcluster_count_key] .' children = '. $capture_function_children_time_sum[$subcluster_count_key] .'ms';
        }
      }
      // Add a green box around the functions that have no child functions
      else {
        $box_color = "#7FCDBB";
        $add_mark = FALSE;
        if ($subcluster_count_key < 10) {
          $capture_function_child_data[$function_count_value] = 'Function #0'. $subcluster_count_key .' w/ 0 children';
        }
        else {
          $capture_function_child_data[$function_count_value] = 'Function #'. $subcluster_count_key .' w/ 0 children';
        }
      }
      $insert_string = '"]; subgraph cluster'. $subcluster_count_key .'{color="'. $box_color .'"; label="'. $capture_function_child_data[$function_count_value] .'" "';
      $output_to_dot_function[$function_count_value] = preg_replace('/"]; "/', $insert_string, $output_to_dot_function[$function_count_value]) .'}';
      // Highlight this data red when displayed in the table
      if ($add_mark) {
        $capture_function_child_data[$function_count_value] = '<span class="marker">'. $capture_function_child_data[$function_count_value] .'</span>';
      }
      // Calculate the average time of each captured function + it's children and divide by the total number of captured function clusters at the end
      $capture_function_children_time_average = $capture_function_children_time_sum[$subcluster_count_key] + $time_delta[$function_count_value] + $capture_function_children_time_average;
    }
    $capture_function_children_time_total = $capture_function_children_time_average;
    $capture_function_children_time_average = round($capture_function_children_time_average / $subgraph_cluster_count, 3);

    // If there are three main subsections, then create a total of 7 *.dot sections.
    if ($create_main_subsections) {
      $section = 7;
    }
    else {
      $section = 4;
    }
    $output_to_dot[$section] = 'digraph G {graph [ordering="out"]; node [style=filled];'. implode("", $output_to_dot_function) .'}';
  }

  $zgrviewer_location = variable_get('visualize_backtrace_zgrviewer_location', '/usr/local/bin/zgrviewer');

  // Create the *.dot file for each subsection
  while ($section_number <= $section) {
    // The *.dot files for the six main sections are created by taking an array_slice of output_to_dot_all
    // And the *.dot file for the captured function is created from the output_to_dot_function
    if ($section_number > 0 && $section_number <= $main_sections) {
      // Calculate how many function calls were made in each section
      $section_length[$section_number] = $section_endpoint[$section_number]['end']-$section_endpoint[$section_number]['begin'];
    
      // Generate the *.dot file for each of three sub-sections
      $output_to_dot[$section_number] = 'digraph G {graph [ordering="out"]; node [style=filled];'.
                                          implode("", array_slice($output_to_dot_all, $section_endpoint[$section_number]['begin']-1, $section_length[$section_number]+1))
                                       .'}';
    }
                       
    // There is an extra space at the end of $unix_base_path that needs to be deleted.
    $default_file_path = file_directory_path();    
    $dot_file[$section_number] = trim($unix_base_path) ."/". $default_file_path ."/". $trace_number ."_section". $section_number .".dot";
    $output_file = fopen($dot_file[$section_number], 'w');
    fwrite($output_file, $output_to_dot[$section_number]);
    fclose($output_file);
    $command[$section_number] = $zgrviewer_location ."/run.sh --Pdot ". $dot_file[$section_number] ."; ";
    $section_number++;
  }

  // ** OUTPUT THE LINKS TO THE GRAPHS & OUTPUT THE DATA **
  // Clear out some of the large arrays
  $output_to_dot = array();
  $output_to_dot_all = array();
  
  $add_footnote = FALSE;

  // Get the file sizes by piping in "ls -l" into awk and extracting the fifth column
  // ls -l /Library/WebServer/Documents/d52/files/1189710511* | awk '{print $5}'
  $get_file_sizes_command = "ls -l ". trim($unix_base_path) ."/files/". $trace_number ."* | awk '{print $5}'";
  exec($get_file_sizes_command, $files_output);
  
  // Add a note to any file sizes that are greater than 1000000 bytes
  foreach ($files_output as $section_key => $filesize_value) {
    if ($filesize_value > 1000000) {
      $files_output[$section_key] = $files_output[$section_key] .' bytes [*]';
      $add_footnote = TRUE;
    }
    else {
      $files_output[$section_key] = $files_output[$section_key] .' bytes';
    }
  }

  // Indicate where the trace file originated if it was called directly from the page load
  // Don't display the HTTP reference if the previous a page had visualize_backtrace as arg(0)
  // Determine which array position arg(0) is located in the exploded HTTP_REFERER array
  // by counting the length of the exploded $base_url
  $http_reference = explode('/', $_SERVER['HTTP_REFERER']);
  if ($http_reference[count(explode('/', $base_url))] != "visualize_backtrace") {
    $output = '<br />Graph of '. l($_SERVER['HTTP_REFERER'], $_SERVER['HTTP_REFERER']) .'<br />';
  }
  else {
    $output = '';
  }
  
  $output .= t('The %trace_file page load executed in %final_time milleseconds<br />', array('%trace_file' => $trace_file, '%final_time' => round($final_time * 1000, 3))); // DELETED FOR NOW: with a memory footprint of '. round($final_memory / 1000, 3) .' kB. 
  // $output .= 'The page load for this trace executed in <em>'. round($final_time * 1000, 3) .'</em> milleseconds<br />'; // DELETED FOR NOW: with a memory footprint of '. round($final_memory / 1000, 3) .' kB. 
  $output .= t('%total_rows Total Drupal Functions appearing in %section_length clusters after consolidating the repeating function loops.', array('%total_rows' => $total_rows, '%section_length' => $section_length[0])) .'<br />';
  
  $output .= '<br /><h3>Backtrace Graphs</h3>';
  // TODO: Possibly replace this hardcoded table with the Drupal table theming as in devel_query_table($queries, $counts);
  $output .= '<table>';
  $output .= '<tr><td>0.) Full Backtrace</td><td>'. $section_length[0] .' functions</td><td>'. $files_output[0] .' </td><td>'. l('Graph Full Backtrace', 'visualize_backtrace/'. $trace_number .'/view_callstack/section_0') .'</td></tr>';
  // Indent each table to make the parent/child relationships clear
  // The section lengths calculated above were for the correct partitioning of the $output_to_dot_all data
  // through the array_slice & implosion when creating the *.dot files, and so add 1 to get the correct section lengths
  $output .= '<tr><td> &nbsp;&nbsp;&nbsp;&nbsp; 1.) Drupal Bootstrap</td><td> &nbsp;&nbsp;&nbsp;&nbsp; '. ($section_length[1] + 1) .' functions</td><td> &nbsp;&nbsp;&nbsp;&nbsp; '. $files_output[1] .' </td><td> &nbsp;&nbsp;&nbsp;&nbsp; '. l('Graph Bootstrap Section Backtrace', 'visualize_backtrace/'. $trace_number .'/view_callstack/section_1') .'</td></tr>';
  $output .= '<tr><td> &nbsp;&nbsp;&nbsp;&nbsp; 2.) Main Section</td><td> &nbsp;&nbsp;&nbsp;&nbsp; '. ($section_length[2] + 1) .' functions</td><td> &nbsp;&nbsp;&nbsp;&nbsp;'. $files_output[2] .' </td><td> &nbsp;&nbsp;&nbsp;&nbsp; '. l('Graph Main Section Backtrace', 'visualize_backtrace/'. $trace_number .'/view_callstack/section_2') .'</td></tr>';
  if ($create_main_subsections) {
    $output .= '<tr><td> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 4.) Main (Part 1/3)</td><td> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; '. $section_length[4] .' functions</td><td> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; '. $files_output[4] .' </td><td> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; '. l('Graph Main Section 1', 'visualize_backtrace/'. $trace_number .'/view_callstack/section_4') .'</td></tr>';
    $output .= '<tr><td> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 5.) Main (Part 2/3)</td><td> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; '. $section_length[5] .' functions</td><td> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; '. $files_output[5] .' </td><td> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; '. l('Graph Main Section 2', 'visualize_backtrace/'. $trace_number .'/view_callstack/section_5') .'</td></tr>';
    $output .= '<tr><td> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 6.) Main (Part 3/3)</td><td> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; '. ($section_length[6] + 1) .' functions</td><td> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; '. $files_output[6] .' </td><td> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; '. l('Graph Main Section 3', 'visualize_backtrace/'. $trace_number .'/view_callstack/section_6') .'</td></tr>';
  }
  // Check to see if the theme() function was even called from index.php.  If the section length is 0, then don't output a link to it.
  if ($section_length[3] > 0) {
    $output .= '<tr><td> &nbsp;&nbsp;&nbsp;&nbsp; 3.) Theming</td><td> &nbsp;&nbsp;&nbsp;&nbsp;'. ($section_length[3] + 1) .' functions</td><td> &nbsp;&nbsp;&nbsp;&nbsp; '. $files_output[3] .' </td><td> &nbsp;&nbsp;&nbsp;&nbsp; '. l('Graph Theme Section Backtrace', 'visualize_backtrace/'. $trace_number .'/view_callstack/section_3') .'</td></tr>';
  }
  $output .= '</table>';

  // Add a footnote if if there are any files larger than 1000000 bytes
  if ($add_footnote) $output .= '<em>[*] - Indicates a large file size, which either takes longer to plot or doesn\'t plot at all.<br /><br /></em>';
  
  // If any function or filename backtraces were captured, then publish another header with more details and links
  if ($capture_function_backtrace_flag) {
    if ($capture_function_forwardtrace_flag) {
      $add_text = ' and Forwardtraces';
    }
    // Create the header information for when a specific function is passed in via arg(4)
    if ($subsection_argument == "show_function_backtrace" || $subsection_argument == "show_function_forwardtrace") {
      $output .= '<h3>Backtraces'. $add_text .' for the Function "'. $capture_function .'"</h3>';
      // TODO: Possibly replace this hardcoded table with the Drupal table theming as in devel_query_table($queries, $counts);
      $output .= '<table><tr><td>'. $section .'.) "'. $capture_function .'"</td><td>'. count($output_to_dot_function) .' total functions</td><td>'. $files_output[7] .' </td><td>'. 
      l('Graph Backtrace', 'visualize_backtrace/'. $trace_number .'/view_callstack/show_function_backtrace/'. $capture_function) .'<br />'. 
      l('Graph Forwardtrace', 'visualize_backtrace/'. $trace_number .'/view_callstack/show_function_forwardtrace/'. $capture_function) .'</td></tr></table>';
    }
    else {
      // Create the header information for when all of the contributed module functions are being captured
      // (i.e. arg(4) = "capture_all_contrib_functions")
      if ($capture_filename == 'capture_all_contrib_functions') {
        if ($contrib_module_filepath == 'sites/') {
          $argument_label = "All Contributed Module Functions";
        }
        else {
          $argument_label = 'Functions from '. $contrib_module_filepath;
        }
        
        $output .= '<h3>Backtraces'. $add_text .' of '. $argument_label .'</h3>';
        // TODO: Possibly replace this hardcoded table with the Drupal table theming as in devel_query_table($queries, $counts);
        $output .= '<table><tr><td>'. $section .'.) '. $argument_label .'</td><td>'. count($output_to_dot_function) .' total functions</td><td>'. $files_output[7] .' </td><td>'. 
        l('Graph Backtrace', 'visualize_backtrace/'. $trace_number .'/view_callstack/show_filename_backtrace/capture_all_contrib_functions') .'<br />'. 
        l('Graph Forwardtrace', 'visualize_backtrace/'. $trace_number .'/view_callstack/show_filename_forwardtrace/capture_all_contrib_functions') .'</td></tr></table>';
      }
      // Otherwise print out the header information for when a specific filename is being captured
      else {
        // Replace the filepath '/' with '-' to create one URL argument
        $graph_filename = preg_replace('/\//', '-', $capture_filename);
        $output .= '<h3>Backtraces'. $add_text .' of All Functions from the Filename "'. $capture_filename .'"</h3>';
        // TODO: Possibly replace this hardcoded table with the Drupal table theming as in devel_query_table($queries, $counts);
        $output .= '<table><tr><td>'. $section .'.) "'. $capture_filename .'"</td><td>'. count($output_to_dot_function) .' total functions</td><td>'. $files_output[7] .' </td><td>'. 
        l('Graph Backtrace', 'visualize_backtrace/'. $trace_number .'/view_callstack/show_filename_backtrace/'. $graph_filename) .'<br />'. 
        l('Graph Forwardtrace', 'visualize_backtrace/'. $trace_number .'/view_callstack/show_filename_forwardtrace/'. $graph_filename) .'</td></tr></table>';
      }
    }
  }

  // Print out the all of the function call stack data
  $output .= '<h3>Function Call Stack</h3>';

  // Determine if arg(3) passes in a specific function number (e.g. 's