utils.php

Go to the documentation of this file.

<?php
# This file is part of the Savane project
# <http://gna.org/projects/savane/>
#
# $Id: utils.php 5500 2006-02-26 12:11:12Z toddy $
#
#  Copyright 1999-2000 (c) The SourceForge Crew
#  Copyright 2000-2003 (c) Free Software Foundation
#
#  Copyright 2002-2006 (c) Mathieu Roy <yeupou--gnu.org>,
#                          Tobias Toedter <t.toedter--gmx.net>
#
# The Savane project is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# The Savane project is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with the Savane project; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

function utils_safeinput ($string)
{
  return safeinput($string);
}


# This function permit including site specific content with ease
function utils_get_content ($file)
{
  if (is_file($GLOBALS['sys_incdir'].'/'.$file.'.'.$GLOBALS['locale']))
    {
      # there is localized version of the file :
      include($GLOBALS['sys_incdir'].'/'.$file.'.'.$GLOBALS['locale']);
    }
  elseif (is_file($GLOBALS['sys_incdir'].'/'.$file.'.txt'))
    {
      include($GLOBALS['sys_incdir'].'/'.$file.'.txt');
    }
  else
    {
      fb(sprintf(_("Warning: Savane was not able to read \"%s\" site-specific information, please contact administrators"), $file), 1);
    }
}

# Make sure that to avoid malicious file paths
function utils_check_path ($path)
{
  if (eregi(".*\.\.\/.*", $path))
    {
      exit_error('Error','Malformed url');
    }
}

# In a string, replace %PROJECT by the group_name
# (useful for group type configuration)
function utils_makereal ($data, $string="%PROJECT", $replacement=0)
{
  if (!$replacement)
    { $replacement = $GLOBALS[group_name]; }
  return ereg_replace($string, $replacement, $data);
}

# Add unavailable css class to a link if required
function utils_link ($url, $title, $defaultclass=0, $available=1, $help=0)
{
  if (!$available)
    { $defaultclass = 'unavailable'; }

  $return = '<a href="'.$url.'"';

  if ($defaultclass)
    { $return .= ' class="'.$defaultclass.'"'; }
  if ($help)
    { $return .= ' title="'.$help.'"'; }
  $return .= '>'.$title.'</a>';
  return $return;
}

# make an clean email link depending on the authentification level of the user
function utils_email ($address, $nohtml=0)
{
  if (user_isloggedin())
    {
      if ($nohtml)
        { return $address; }

      return '<a href="mailto:'.$address.'">'.$address.'</a>';

    }
  else
    {
      if ($nohtml)
        { return _("-unavailable-"); }

      return utils_help(_("-unavailable-"),
                        _("This information is not provided to anonymous users"),
                        1);
    }

}

# Found out if a string is pure ASCII or not
function utils_is_ascii ($string)
{
  return preg_match('%^(?: [\x09\x0A\x0D\x20-\x7E] )*$%xs', $string);
}

# Alias function
function utils_altrow ($i)
{
  return html_get_alt_row_color ($i);
}

function utils_cutstring ($string, $lenght=35)
{
  $string = rtrim($string);
  if (strlen($string) > $lenght)
    {
      $string = substr($string, 0, $lenght);
      $string = substr($string, 0, strrpos($string, ' '));
      $string .= "...";
    }
  return $string;
}

function format_date($format="default", $timestamp, $default_value='-')
{
  return utils_format_date($timestamp, $format);
}

function utils_format_date($timestamp, $format="default")
{
  global $sys_datefmt;
  if ($timestamp == 0)
    {
      return '-';
    }

  # The installation configured a specific date format. This is not nice
  # this will prevent locales from being used
  if ($sys_datefmt)
    {
      return strftime($sys_datefmt, $timestamp);
    }

  ## Go at task #2614 to discuss about this
  # Used by default
  switch ($format)
    {
    case 'short':
      {
        # To be used in tables, nowhere else
        return strftime('%a %x, %R', $timestamp);
      }
    case 'minimal':
      {
        # To be used where place is really lacking, like in feature boxes.
        # (Nowhere else, it is too uninformative)
        return strftime('%x', $timestamp);
      }
    default:
      {
        # Used by default
        # Mention timezone to non-logged in users or in printer mode.
        # Logged-in users have this as account setting, so we can assume they
        # now and dont want time wasted by that
        if (user_isloggedin() && !defined(PRINTER))
          {
            return strftime('%A %x '._("at").' %R', $timestamp);
          }
        else
          {
            return strftime('%A %x '._("at").' %R %Z', $timestamp);
          }
      }
    }

  return false;
}


# Convert a date as used in the bug tracking system and other services (YYYY-MM-DD)
# into a Unix time
# Returns a list with two values: the unix time and a boolean saying whether the conversion
# went well (true) or bad (false)
function utils_date_to_unixtime ($date)
{
  $res = preg_match("/\s*(\d+)-(\d+)-(\d+)/",$date,$match);
  if ($res == 0)
    { return array(0,false); }
  list(,$year,$month,$day) = $match;
  $time = mktime(0, 0, 0, $month, $day, $year);
  dbg("DBG Matching date $date -> year $year, month $month,day $day -> time = $time<br />");
  return array($time,true);
}

function utils_read_file($filename)
{
  @$fp = fopen($filename, "r");
  if ($fp)
    {
      $val = fread($fp, filesize($filename));
      fclose ($fp);
      return $val;
    }
  return false;
}

function utils_filesize($filename, $file_size=0)
{
  # If file size is defined, assume that we just want an unit conversion.
  if (!$file_size)
    {   $file_size = filesize($filename); }

  if ($file_size >= 1048576)
    {
      $file_size = round($file_size / 1048576 * 100) / 100 . _("MB");
    }
  elseif ($file_size >= 1024)
    {
      $file_size = round($file_size / 1024 * 100) / 100 . _("KB");
    }
  else
    {
      $file_size = $file_size . _("B");
    }

  return $file_size;
}

function utils_fileextension($filename)
{

  $ext = substr(basename($filename), strrpos(basename($filename),".") + 1);
  if ($ext==gz || $ext==bz2)
    {
      $ext = substr(basename($filename), strrpos(basename($filename),".") - 3);
    }
  if ($ext==rpm)
    {
      $long_ext = _("rpm package");
    }
  if ($ext==deb)
    {
      $long_ext = _("debian package");
    }
  if ($ext==deb || $ext==rpm)
    {
      $arch_type = substr(basename($filename), strrpos(basename($filename),".") - 3);
      if ($arch_type == "src.".$ext)
        {
          $long_ext = sprintf(_("source %s"), $long_ext);
        }
      if ($arch_type == "rch.".$ext)
        {
          $long_ext = sprintf(_("arch independant %s"), $long_ext);
        }
      if ($arch_type == "386.".$ext)
        {
          $long_ext = sprintf(_("%s for i386 (ix86)"), $long_ext);
        }
      if ($arch_type == "586.".$ext)
        {
          $long_ext = sprintf(_("%s for i586"), $long_ext);
        }
      if ($arch_type == "686.".$ext)
        {
          $long_ext = sprintf(_("%s for i686"), $long_ext);
        }
      if ($arch_type == "a64.".$ext)
        {
          $long_ext = sprintf(_("%s for Itanium 64"), $long_ext);
        }
      if ($arch_type == "arc.".$ext)
        {
          $long_ext = sprintf(_("%s for Sparc"), $long_ext);
        }
      if ($arch_type == "pha.".$ext)
        {
          $long_ext = sprintf(_("%s for Alpha"), $long_ext);
        }
      if ($arch_type == "ppc.".$ext)
        {
          $long_ext = sprintf(_("%s for PowerPC"), $long_ext);
        }
      if ($arch_type == "390.".$ext)
        {
          $long_ext = sprintf(_("%s for s390"), $long_ext);
        }
      $ext = $long_ext;
    }
  return $ext;
}

function utils_prep_string_for_sendmail($body)
{
  $body=str_replace("\\","\\\\",$body);
  $body=str_replace("\"","\\\"",$body);
  $body=str_replace("\$","\\\$",$body);
  $body=str_replace("`","\\`",$body);
  return $body;
}

function utils_unconvert_htmlspecialchars($string)
{
  if (strlen($string) < 1)
    {
      return '';
    }
  else
    {
      $string=str_replace('&nbsp;',' ',$string);
      $string=str_replace('&quot;','"',$string);
      $string=str_replace('&gt;','>',$string);
      $string=str_replace('&lt;','<',$string);
      $string=str_replace('&amp;','&',$string);
      return $string;
    }
}

function utils_remove_htmlheader($string)
{
  $string = eregi_replace('(^.*<html[^>]*>.*<body[^>]*>)|(</body[^>]*>.*</html[^>]*>.*$)', '', $string);
  return $string;
}

function utils_result_column_to_array($result, $col=0)
{
  /*
                Takes a result set and turns the optional column into
                an array
  */
  $rows=db_numrows($result);

  if ($rows > 0)
    {
      $arr=array();
      for ($i=0; $i<$rows; $i++)
        {
          $arr[$i]=db_result($result,$i,$col);
        }
    }
  else
    {
      $arr=array();
    }
  return $arr;
}

function result_column_to_array($result, $col=0)
{
  /*
                backwards compatibility
  */
  return utils_result_column_to_array($result, $col);
}

function utils_wrap_find_space($string,$wrap)
{
  $start=$wrap-5;
  $try=1;
  $found=false;

  while (!$found)
    {
      #find the first space starting at $start
      $pos=@strpos($string,' ',$start);

      #if that space is too far over, go back and start more to the left
      if (($pos > ($wrap+5)) || !$pos)
        {
          $try++;
          $start=($wrap-($try*5));
          #if we've gotten so far left , just truncate the line
          if ($start<=10)
            {
              return $wrap;
            }
          $found=false;
        }
      else
        {
          $found=true;
        }
    }

  return $pos;
}

function utils_line_wrap ($text, $wrap = 78, $break = "\n")
{
  $paras = explode("\n", $text);

  $result = array();
  $i = 0;
  while ($i < count($paras))
    {
      if (strlen($paras[$i]) <= $wrap)
        {
          $result[] = $paras[$i];
          $i++;
        }
      else
        {
          $pos=utils_wrap_find_space($paras[$i],$wrap);

          $result[] = substr($paras[$i], 0, $pos);

          $new = trim(substr($paras[$i], $pos, strlen($paras[$i]) - $pos));
          if ($new != '')
            {
              $paras[$i] = $new;
              $pos=utils_wrap_find_space($paras[$i],$wrap);
            }
          else
            {
              $i++;
            }
        }
    }
  return implode($break, $result);
}



function utils_basic_markup($text)
{
  $lines = explode("\n", $text);
  $result = array();

  foreach ($lines as $line)
    {
      $result[] = _markup_inline($line);
    }

  return join("\n", $result);
}



function utils_rich_markup($text)
{
  return utils_full_markup($text, false);
}



function utils_full_markup($text, $allow_headings=true)
{
  $lines = explode("\n", $text);
  $result = array();

  # we use a stack (last in, first out) to track the current
  # context (paragraph, lists) so we can correctly close tags
  $context_stack = array();

  $quoted_text = false;
  $verbatim = false;
  foreach ($lines as $index => $line)
    {
      # the verbatim tags are not allowed to be nested, because
      # they are translated to HTML <pre>, which in turn is also
      # not allowed to be nested.
      # therefore, we don't need a counter of the level, but only
      # a simple bool flag
      if ($line == '+verbatim+' and !$verbatim)
        {
          $verbatim = true;
          # empty the context stack
          $line = join("\n", $context_stack).'<pre>';
          $context_stack = array('</pre>');
        }

      # if we're in the verbatim markup, don't apply the markup
      if ($verbatim)
        {
          # disable the +nomarkup+ tags by inserting a unique string.
          # this has to be done in the original string, because that
          # is the one which will be split upon the +nomarkup+ tags,
          # see below
          $escaped_line = str_replace('nomarkup',
            'no-1a4f67a7-4eae-4aa1-a2ef-eecd8af6a997-markup', $line);
          $lines[$index] = $escaped_line;
          $result[] = $escaped_line;
        }
      else
        {
          $result[] = _full_markup($line, $allow_headings, &$context_stack, &$quoted_text);
        }

      if ($line == '-verbatim-' and $verbatim)
        {
          $verbatim = false;
          # empty the context stack
          $line = join("\n", $context_stack);
          $context_stack = array();
          array_pop($result);
          $result[] = '</pre>';
        }
    }

  # make sure that all previously used contexts get their
  # proper closing tag by merging in the last closing tags
  $markup_text = join("\n", array_merge($result, $context_stack));

  # it's easiest to markup everything, without supporting the nomarkup
  # tag. afterwards, we replace every nomarkup tag pair with the content
  # between those tags in the original string
  $original = preg_split('/([+-]nomarkup[+-])/', join("\n", $lines), -1,
    PREG_SPLIT_DELIM_CAPTURE);
  $markup = preg_split('/([+-]nomarkup[+-])/', $markup_text, -1,
    PREG_SPLIT_DELIM_CAPTURE);
  # save the HTML tags from the last element in the markup array, see below
  $last_tags = $markup[count($markup)-1];
  $nomarkup_level = 0;

  foreach ($original as $index => $original_text)
    {
      # keep track of nomarkup tags
      if ($original_text == '+nomarkup+') $nomarkup_level++;
      if ($original_text == '-nomarkup-') $nomarkup_level--;

      # if the current match is the nomarkup tag, we don't want it to
      # show up in the markup text -> set it to an empty string
      if (preg_match('/([+-]nomarkup[+-])/', $original_text))
        {
          $markup[$index] = '';
          $original_text = '';
        }
      # while we're in a nomarkup environment, the already marked up text
      # needs to be replaced with the original content. Also, we need
      # to add <br />  tags for newlines.
      if ($nomarkup_level > 0)
        {
          $markup[$index] = nl2br($original_text);
        }
    }

  # normally, $nomarkup_level must be zero at this point. however, if
  # the user submits wrong markup and forgets to close the -nomarkup-
  # tag, we need to take care of that.
  # To do this, we need to look for closing tags which have been deleted.
  if ($nomarkup_level > 0)
    {
      $trailing_markup = array_reverse(split("\n", $last_tags));
      $restored_tags = '';
      foreach ($trailing_markup as $tag)
        {
          if (preg_match('/^\s*<\/[a-z]+>$/', $tag))
            {
              $restored_tags = "\n$tag$restored_tags";
            }
          else
            {
              $markup[] = $restored_tags;
              break;
            }
        }
    }

  # lastly, revert the escaping of +nomarkup+ tags done above
  # for verbatim environments
  return str_replace('no-1a4f67a7-4eae-4aa1-a2ef-eecd8af6a997-markup',
    'nomarkup', join('', $markup));
}



function _full_markup($line, $allow_headings, &$context_stack, &$quoted_text)
{
  #############################################################
  # context formatting
  #
  # the code below marks up recognized special characters,
  # by starting a new context (e.g. headings and lists)
  #############################################################

  # generally, we want to start a new paragraph. this will be set
  # to false, if a new paragraph is no longer appropriate, like
  # for headings or lists
  $start_paragraph = true;

  # Match the headings, e.g. === heading ===
  if ($allow_headings)
    {
      $line = _markup_headings($line, &$context_stack, &$start_paragraph);
    }

  # Match list items
  $line = _markup_lists($line, &$context_stack, &$start_paragraph);

  # replace at least four '-' sign with a horizontal ruler
  if (preg_match('/^----+\s*$/', $line))
    {
      $line = join("\n", $context_stack).'<hr />';
      $context_stack = array();
      $start_paragraph = false;
    }

  #############################################################
  # inline formatting
  #
  # the code below marks up recognized special characters,
  # without starting a new context (e.g. <strong> and <em>)
  #############################################################

  $line = _markup_inline($line);

  #############################################################
  # paragraph formatting
  #
  # the code below is responsible for doing the Right Thing(tm)
  # by either starting a new paragraph and closing any previous
  # context or continuing an existing paragraph
  #############################################################

  # change the quoteing mode when the line start with '>'
  if (substr($line, 0, 4) == '&gt;')
    {
      # if the previous line was not quoted, start a new quote paragraph
      if (!$quoted_text)
        {
          $line = join("\n", $context_stack)."<p class=\"quote\">$line";
          # empty the stack
          $context_stack = array('</p>');
          $start_paragraph = false;
        }
      $quoted_text = true;
    }
  else
    {
      # if the previous line was quoted, end the quote paragraph
      if ($quoted_text and $start_paragraph and $line != '')
        {
          $line = join("\n", $context_stack)."\n<p>$line";
          # empty the stack
          $context_stack = array('</p>');
        }
      $quoted_text = false;
    }

  # don't start a new paragraph again, if we already did that
  if ($context_stack[0] == '</p>')
    {
      $start_paragraph = false;
    }

  # add proper closing tags when we encounter an empty line.
  # note that there might be no closing tags, in this case
  # the line will remain emtpy.
  if ($line == '')
    {
      $line = join("\n", $context_stack)."$line";
      # empty the stack
      $context_stack = array();
      $start_paragraph = false;
    }

  # Finally start a new paragraph if appropriate
  if ($start_paragraph)
    {
      # make sure that all previously used contexts get their
      # proper closing tag
      $line = join("\n", $context_stack)."<p>$line";
      # empty the stack
      $context_stack = array('</p>');
    }

  # append a linebreak while in paragraph mode
  if ($context_stack[0] == '</p>')
    {
      $line .= '<br />';
    }

  return $line;
}



function _markup_headings($line, &$context_stack, &$start_paragraph)
{
  if (preg_match(
    # find one to four '=' signs at the start of a line
    '/^(={1,4})'
    # followed by exactly one space
    .' '
    # followed by any character
    .'(.+)'
    # followed by exactly one space
    .' '
    # followed by one to four '=' signs at the end of a line (whitespace allowed)
    .'(={1,4})\s*$/', $line, $matches))
    {
      $header_level_start = max(min(strlen($matches[1]), 4), 1);
      $header_level_end = strlen($matches[3]);
      if ($header_level_start == $header_level_end)
        {
          # if the user types '= heading =' (one '=' sign), it will
          # actually be rendered as a level 3 heading <h3>
          $header_level_start += 2;
          $header_level_end += 2;

          $line = "<h$header_level_start>$matches[2]</h$header_level_end>";
          # make sure that all previously used contexts get their
          # proper closing tag
          $line = join("\n", $context_stack).$line;
          # empty the stack
          $context_stack = array();
          $start_paragraph = false;
        }
    }
  return $line;
}



function _markup_lists($line, &$context_stack, &$start_paragraph)
{
  if (preg_match('/^([*0]+) (.+)$/', $line, $matches))
    {
      # determine the list level currently in use
      $current_list_level = 0;
      foreach ($context_stack as $context)
        {
          if ($context == '</ul>' or $context == '</ol>')
            {
              $current_list_level++;
            }
        }

      # determine whether the user list levels match the list
      # level we have in our context stack
      #
      # this will catch (potential) errors of the following form:
      # * list start
      # 0 maybe wrong list character
      # * list end
      $markup_position = 0;
      foreach (array_reverse($context_stack) as $context)
        {
          # we only care for the list types
          if ($context != '</ul>' and $context != '</ol>')
            {
              continue;
            }

          $markup_character = substr($matches[1], $markup_position, 1);

          if (($markup_character === '*' and $context != '</ul>')
            or ($markup_character === '0' and $context != '</ol>'))
            {
              # force a new and clean list start
              $current_list_level = 0;
              break;
            }
          else
            {
              $markup_position++;
            }
        }

      # if we're not in a list, close the previous context
      $line = '';
      if ($current_list_level == 0)
        {
          $line = join("\n", $context_stack);
          $context_stack = array();
        }

      # determine the list level the user wanted
      $wanted_list_level = strlen($matches[1]);

      # here we start a new list and make sure that the markup
      # is valid, even if the user did skip one or more list levels
      $list_level_counter = $current_list_level;
      while ($list_level_counter < $wanted_list_level)
        {
          switch (substr($matches[1], $list_level_counter, 1))
            {
              case '*':
                $tag = 'ul';
                break;
              case '0':
                $tag = 'ol';
                break;
            }
          $line .= "<$tag>\n<li>";
          array_unshift($context_stack, "</$tag>");
          array_unshift($context_stack, "</li>");
          $list_level_counter++;
        }

      # here we end a previous list and make sure that the markup
      # is valid, even if the user did skip one or more list levels
      $list_level_counter = $current_list_level;
      while ($list_level_counter > $wanted_list_level)
        {
          $line .= array_shift($context_stack)."\n"
            .array_shift($context_stack)."\n";
          $list_level_counter--;
        }

      # prepare the next item of the same list level
      if ($current_list_level >= $wanted_list_level)
        {
          $line .= "</li>\n<li>";
        }

      # finally, append the list item
      $line .= $matches[2];
      $start_paragraph = false;
    }
  return $line;
}



function _markup_inline($line)
{
  # Group_id may be necessary for recipe #nnn links
  global $group_id;

  if ($group_id)
    {
      $comingfrom = "&amp;comingfrom=$group_id";
    }

  if (strlen($line) == 0)
    {
      return;
    }

  # 1 and 2 could maybe be replaced by a better regexp, as they may in
  # some very rare case, break content. But we havent found such case.
  # Feel free to propose better regexp.

  # 1. Don't mess with HTML links already there by escaping
  # the protocol separator with ":##"
  $line = eregi_replace("(<a href=\"[a-z]+)://([^<[:space:]]+)://([^<[:space:]]+)</a>",
    '\1:##\2:##\3</a>', $line);
  $line = eregi_replace("(<a href=\"[a-z]+)://([^<\"[:space:]]+)\"",
    '\1:##\2"', $line);

  # 2. Dont mess with links surrounded by < >
  # (Which are in fact html special chars)
  $line = str_replace('&gt;', ' ##>', $line);
  $line = str_replace('&lt;', '<## ', $line);

  # Prepare usual links: prefix every "www." with "http://"
  $line = preg_replace('/(^|\s+)(www\.)/i', '$1http://$2', $line);

  # replace the @ sign with an HTML entity, if it is used within
  # an url (e.g. for pointers to mailing lists). This way, the
  # @ sign doesn't get mangled in the e-mail markup code
  # below. See bug #2689 on http://gna.org/ for reference.
  $line = eregi_replace("([a-z]+://[^<>[:space:]]+)@", "\\1&#64;", $line);

  # Prepare the markup for normal links, e.g. http://test.org, by
  # surrounding them with braces []
  $line = preg_replace('/(^|[^\[a-z])([a-z]+:\/\/[^<>\s]+[a-z0-9\/]+)/i',
    '$1[$2]', $line);

  # do a markup for mail links, e.g. info@support.org
  $line = eregi_replace("([a-z0-9_+-.]+@([a-z0-9_+-]+\.)+[a-z]+)",
    utils_email('\1'), $line);

  # Revert the escaping of already provided HTML links, done above
  $line = str_replace(":##", "://", $line);
  $line = str_replace(' ##>', '&gt;', $line);
  $line = str_replace('<## ', '&lt;', $line);

  # Links between items
  # FIXME: it should be i18n, but in a clever way, meaning that everytime
  # a form is submitted with such string, the string get converted in
  # english so we always get the links found without having a regexp
  # including every possible language.
  $trackers = array (
      "bugs?" => "bugs/?",
      "support|sr" => "support/?",
      "tasks?" => "task/?",
      "recipes?|rcp" => "cookbook/?func=detailitem$comingfrom&amp;item_id=",
      "patch" => "patch/?",
      # In this case, we make the link pointing to support, it wont matter,
      # the download page is in every tracker and does not check if the tracker
      # is actually used
      "files?" => "support/download.php?file_id=",
  );
  foreach ($trackers as $regexp => $link)
    {
      $line = preg_replace("/(^|\s+)($regexp)\s*#([0-9]+)/i",
        '$1<em><a href="'.$GLOBALS['sys_home']
        .$link.'$3">$2&nbsp;#$3</a></em>', $line);
    }

  # add an internal link for comments
  $line = preg_replace('/(comments?)\s*#([0-9]+)/i',
    '<em><a href="#comment$2">$1&nbsp;#$2</a></em>', $line);

  # Add support for named hyperlinks, e.g.
  # [http://gna.org/ Text] -> <a href="http://gna.org/">Text</a>
  $line = preg_replace(
    # find the opening brace '['
    '/\['
    # followed by the protocol, either http:// or https://
    .'(https?:\/\/'
    # match any character except whitespace or the closing
    # brace ']' for the actual link
    .'[^\s\]]+)'
    # followed by at least one whitespace
    .'\s+'
    # followed by any character (non-greedy) and the
    # next closing brace ']'
    .'(.+?)\]/', '<a href="$1">$2</a>', $line);

  # Add support for unnamed hyperlinks, e.g.
  # [http://gna.org/] -> <a href="http://gna.org/">http://gna.org/</a>
  $line = preg_replace(
    # find the opening brace '['
    '/\['
    # followed by the protocol, either http:// or https://
    .'(https?:\/\/'
    # match any character except whitespace (non-greedy) for
    # the actual link, followed by the closing brace ']'
    .'[^\s]+?)\]/', '<a href="$1">$1</a>', $line);

  # *word* -> <strong>word</strong>
  $line = preg_replace(
    # find an asterisk
    '/\*'
    # then one character (except a space or asterisk)
    .'([^* ]'
    # then (optionally) any character except asterisk
    .'[^*]*?)'
    # then an asterisk
    .'\*/', '<strong>$1</strong>', $line);

  # _word_ -> <em>word</em>
  $line = preg_replace(
    # allow for the pattern to start at the beginning of a line.
    # if it doesn't start there, the character before the slash
    # must be either whitespace or the closing brace '>', to
    # allow for nested html tags (e.g. <p>_markup_</p>).
    '/(^|\s+|>)'
    # match the underscore
    .'_'
    # match any character (non-greedy)
    .'(.+?)'
    # match the ending underscore and either end of line or
    # a non-word character
    .'_(\W|$)/', '$1<em>$2</em>$3', $line);

  return $line;
}



function utils_user_link ($username, $realname=0)
{
  if ( $username == 'None' || empty($username))
    {
      return $username;
    }
  else
    {
      $re = '<a href="'.$GLOBALS['sys_home'].'users/'.$username.'">';
      if ($realname)
        {
          $re .= $realname." &lt;".$username."&gt;";
        }
      else
        {
          $re .= $username;
        }
      $re .= '</a>';

      return $re;
    }
}

function utils_double_diff_array($arr1, $arr2)
{
  # first transform both arrays in hashes
  reset($arr1); reset($arr2);
  while ( list(,$v) = each($arr1))
    { $h1[$v] = $v; }
  while ( list(,$v) = each($arr2))
    { $h2[$v] = $v; }

  $deleted = array();
  while ( list($k,) = each($h1))
    {
      if (!isset($h2[$k]))
        { $deleted[] = $k; }
    }

  $added = array();
  while ( list($k,) = each($h2))
    {
      if (!isset($h1[$k]))
        { $added[] = $k; }
    }

  return array($deleted, $added);
}

function utils_registration_history ($unix_group_name)
{
  # Meaningless with chrooted system; all www system should be chrooted.
}

function show_priority_colors_key()
{
  print '<p class="smaller">';
  print _("Open Items Priority Colors:")."<br />&nbsp;&nbsp;&nbsp;\n";

  for ($i=1; $i<10; $i++)
    {
      print '<span class="'.utils_get_priority_color($i).'">&nbsp;'.$i.'&nbsp;</span>'."\n";
    }

  print '<br />';
  print _("Closed Items Priority Colors:")."<br />&nbsp;&nbsp;&nbsp;\n";

  for ($i=11; $i<20; $i++)
    {
      print '<span class="'.utils_get_priority_color($i).'">&nbsp;'.($i-10).'&nbsp;</span>'."\n";
    }

  print  "</p>";
}

function get_priority_color ($index, $closed="")
{ return utils_get_priority_color($index, $closed); }


function utils_get_tracker_icon ($tracker)
{
  if ($tracker == "bugs")
    { return "bug"; }
  if ($tracker == "support")
    { return "help"; }
  if ($tracker == "cookbook")
    { return "man"; }
  return $tracker;
}

function utils_get_tracker_prefix ($tracker)
{
  if ($tracker == "bugs")
    { return "bug"; }
  if ($tracker == "support")
    { return "sr"; }
  if ($tracker == "cookbook")
    { return "recipe"; }
  return $tracker;
}


function utils_get_priority_color ($index, $closed="")
{
  global $bgpri;
  # If the item is closed, add ten to the index number to get closed colors
  if ($closed == 3)
    { $index = $index + 10; }

  return $bgpri[$index];
}

function build_priority_select_box ($name="priority", $checked_val="5")
{
  /*
                Return a select box of standard priorities.
                The name of this select box is optional and so is the default checked value
  */

  print "<select name=\"$name\">\n";
  print '<option value="1"'.($checked_val=="1" ?" selected":"").'>1 - '._("Lowest").'</option>';
  print '<option value="2"'.($checked_val=="2" ?" selected":"").'>2</option>';
  print '<option value="3"'.($checked_val=="3" ?" selected":"").'>3</option>';
  print '<option value="4"'.($checked_val=="4" ?" selected":"").'>4</option>';
  print '<option value="5"'.($checked_val=="5" ?" selected":"").'>5 - '._("Medium").'</option>';
  print '<option value="6"'.($checked_val=="6" ?" selected":"").'>6</option>';
  print '<option value="7"'.($checked_val=="7" ?" selected":"").'>7</option>';
  print '<option value="8"'.($checked_val=="8" ?" selected":"").'>8</option>';
  print '<option value="9"'.($checked_val=="9" ?" selected":"").'>9 - '._("Highest").'</option>';
  print '</select>';


}

# ########################################### checkbox array
# ################# mostly for group languages and environments

function utils_buildcheckboxarray($options,$name,$checked_array)
{
  $option_count=count($options);
  $checked_count=count($checked_array);

  for ($i=1; $i<=$option_count; $i++)
    {
      print '
                        <BR><INPUT type="checkbox" name="'.$name.'" value="'.$i.'"';
      for ($j=0; $j<$checked_count; $j++)
        {
          if ($i == $checked_array[$j])
            {
              print ' CHECKED';
            }
        }
      print '> '.$options[$i];
    }
}

# deprecated name
function GraphResult($result,$title)
{
  utils_graph_result($result, $title);
}

# DEPRECATED:
function utils_graph_result ($result,$title)
{

  /*
        GraphResult by Tim Perdue, PHPBuilder.com

        Takes a database result set.
        The first column should be the name,
        and the second column should be the values

        ####
        ####   Be sure to include (HTML_Graphs.php) before hitting these graphing functions
        ####
  */

  /*
                db_ should be replaced with your database, aka mysql_ or pg_
  */
  $rows=db_numrows($result);

  if ((!$result) || ($rows < 1))
    {
      print 'None Found.';
    }
  else
    {
      $names=array();
      $values=array();

      for ($j=0; $j<db_numrows($result); $j++)
        {
          if (db_result($result, $j, 0) != '' && db_result($result, $j, 1) != '' )
            {
              $names[$j]= db_result($result, $j, 0);
              $values[$j]= db_result($result, $j, 1);
            }
        }

      /*
                This is another function detailed below
      */
      GraphIt($names,$values,$title);
    }
}


# DEPRECATED: deprecated name
function GraphIt ($name_string,$value_string,$title)
{
  utils_graph_it($name_string,$value_string,$title);
}


# DEPRECATED:
function utils_graph_it ($name_string,$value_string,$title)
{

  /*
                GraphIt by Tim Perdue, PHPBuilder.com
  */
  $counter=count($name_string);

  /*
                Can choose any color you wish
  */
  $bars=array();

  for ($i = 0; $i < $counter; $i++)
    {
      $bars[$i]=$GLOBALS['COLOR_LTBACK1'];
    }

  $counter=count($value_string);

  /*
                Figure the max_value passed in, so scale can be determined
  */

  $max_value=0;

  for ($i = 0; $i < $counter; $i++)
    {
      if ($value_string[$i] > $max_value)
        {
          $max_value=$value_string[$i];
        }
    }

  if ($max_value < 1)
    {
      $max_value=1;
    }

  /*
                I want my graphs all to be 800 pixels wide, so that is my divisor
  */

  $scale=(400/$max_value);

  /*
                I create a wrapper table around the graph that holds the title
  */

  $title_arr=array();
  $title_arr[]=$title;

  print html_build_list_table_top ($title_arr);
  print '<TR><TD>';
  /*
                Create an associate array to pass in. I leave most of it blank
  */

  $vals =  array(
                 'vlabel'=>'',
                 'hlabel'=>'',
                 'type'=>'',
                 'cellpadding'=>'',
                 'cellspacing'=>'0',
                 'border'=>'',
                 'width'=>'',
                 'background'=>'',
                 'vfcolor'=>'',
                 'hfcolor'=>'',
                 'vbgcolor'=>'',
                 'hbgcolor'=>'',
                 'vfstyle'=>'',
                 'hfstyle'=>'',
                 'noshowvals'=>'',
                 'scale'=>$scale,
                 'namebgcolor'=>'',
                 'valuebgcolor'=>'',
                 'namefcolor'=>'',
                 'valuefcolor'=>'',
                 'namefstyle'=>'',
                 'valuefstyle'=>'',
                 'doublefcolor'=>'');

  /*
                This is the actual call to the HTML_Graphs class
  */

  html_graph($name_string,$value_string,$bars,$vals);

  print '
                </TD></TR></TABLE>
                <!-- end outer graph table -->';
}



function utils_show_result_set ($result,$title="Untitled",$linkify=false)
{
  global $group_id,$HTML;
  /*
                Very simple, plain way to show a generic result set
                Accepts a result set and title
                Makes certain items into HTML links
  */

  if  ($result)  {
    $rows  =  db_numrows($result);
    $cols  =  db_numfields($result);

    # Show title
    print "<h4>$title</h4>\n";
    print '<table border="0" width="100%" summary="'.$title.'">'."\n";

    /*  Create  the  headers  */
    print "<tr>\n";
    for ($i=0; $i < $cols; $i++)
      {
        print '<th>'.db_fieldname($result,  $i)."</th>\n";
      }
    print "</tr>\n";

    /*  Create the rows  */
    for ($j = 0; $j < $rows; $j++)
      {
        print '<tr class="'. html_get_alt_row_color($j) .'">';
        for ($i = 0; $i < $cols; $i++)
          {
            if ($linkify && $i == 0)
              {
                $link = '<a href="'.$PHP_SELF.'?';
                $linkend = '</a>';
                if ($linkify == "bug_cat")
                  {
                    $link .= 'group_id='.$group_id.'&bug_cat_mod=y&bug_cat_id='.db_result($result, $j, 'bug_category_id').'">';
                  } else if($linkify == "bug_group")
                    {
                      $link .= 'group_id='.$group_id.'&bug_group_mod=y&bug_group_id='.db_result($result, $j, 'bug_group_id').'">';
                    } else if($linkify == "patch_cat")
                      {
                        $link .= 'group_id='.$group_id.'&patch_cat_mod=y&patch_cat_id='.db_result($result, $j, 'patch_category_id').'">';
                      } else if($linkify == "support_cat")
                        {
                          $link .= 'group_id='.$group_id.'&support_cat_mod=y&support_cat_id='.db_result($result, $j, 'support_category_id').'">';
                        } else if($linkify == "pm_project")
                          {
                            $link .= 'group_id='.$group_id.'&project_cat_mod=y&project_cat_id='.db_result($result, $j, 'group_project_id').'">';
                          }
                else
                  {
                    $link = $linkend = '';
                  }
              }
            else
              {
                $link = $linkend = '';
              }
            print '<td>'.$link . db_result($result,  $j,  $i) . $linkend.'</td>';

          }
        print '</tr>';
      }
    print "</table>\n";
  }
  else
    {
      print db_error();
    }
}


# Clean up email address (remove spaces...) and put to lower case
function utils_cleanup_emails ($addresses)
{
  return strtolower(preg_replace("/\s/","", $addresses));
}

# Clean up email address (remove spaces...) and add @... if it is a simple
# login name
function utils_normalize_email ($address)
{
  $address = utils_cleanup_emails($address);
  if (validate_email($address))
    return $address;
  else
    return $address."@".$GLOBALS['sys_default_domain'];
}


# Clean up email address (remove spaces...) and split comma separated emails
function utils_split_emails($addresses)
{
  $addresses = utils_cleanup_emails($addresses);
  $addresses = ereg_replace(";", ",", $addresses);
  return split(',',$addresses);
}

# Email Verification
function validate_email ($address)
{
  return (ereg('^[-!#$%&\'*+\\./0-9=?A-Z^_`a-z{|}~]+'. '@'. '[-!#$%&\'*+\\/0-9=?A-Z^_`a-z{|}~]+\.' . '[-!#$%&\'*+\\./0-9=?A-Z^_`a-z{|}~]+$', $address));
}

# Verification of comma separated list of email addresses
function validate_emails ($addresses)
{
  $arr = utils_split_emails($addresses);
  while (list(, $addr) = each ($arr))
    {
      if (!validate_email($addr))
        { return false;}
    }
  return true;
}

function utils_is_valid_filename ($file)
{
  if (ereg("[]~`! ~@#\"$%^,&*();=|[{}<>?/]",$file))
    {
      return false;
    }
  else
    {
      if (strstr($file,'..'))
        {
          return false;
        }
      else
        {
          return true;
        }
    }
}

# alias
function util_debug ($msg)
{
  dbg($msg);
}

# alias
function debug ($msg)
{
  dbg($msg);
}

# add debugging information
function dbg ($msg)
{
  if ($GLOBALS['sys_debug_on'])
    {
      $GLOBALS['debug'] .= "<br /><br />latest func called: ".ereg_replace($_SERVER["DOCUMENT_ROOT"].$GLOBALS['sys_home'], "",$GLOBALS['sys_debug_where']);
      $GLOBALS['debug'] .= "<br />msg: $msg";
    }
}


# alias
function util_feedback ($msg, $error=0)
{
  fb($msg, $error);
}

# alias
function feedback ($msg, $error=0)
{
  fb($msg, $error);
}

# add feedback information
function fb ($msg, $error=0, $enablehtml=0)
{
  # If ware in enablehtml mode, it means that the feedback may contain real
  # html.
  # It means that we need to remove previous feedback to avoid malicious usage
  # of the feedback form.
  # This should be used on rare occasions.
  # We will also set feedback_html.
  if ($enablehtml)
    {
      unset($GLOBALS['feedback'], $GLOBALS['ffeedback']);
      $GLOBALS['feedback_html'] = 1;
    }

  # Increment feedback count
  $GLOBALS['feedback_count']++;

  # Remove the dot at the end, if existing
  if (substr($msg, -1) == ".")
    {
      $msg = substr($msg, 0, (strlen($msg)-1));
    }


  # First letter capitalized, that's all
  $msg = strtoupper(substr($msg, 0, 1)).strtolower(substr($msg, 1, strlen($msg)));

  if ($GLOBALS['sys_debug_on'])
    {
      $msg .= ' [#'.$GLOBALS['feedback_count'].']';
      dbg("Add feedback #".$GLOBALS['feedback_count']);
    }

  $msg .= _(";").' ';

  # feed
  if (!$error)
    {
      $GLOBALS['feedback'] .= $msg;
    }
  else
    {
      $GLOBALS['ffeedback'] .= $msg;
    }
}

# fb function to be used about database error when context of error is obvious
function fb_dberror()
{
  fb(_("Error updating database"),1);
}

# fb function to be used about database error when context of error is obvious
function fb_dbsuccess()
{
  fb(_("Database successfully updated"));
}


# alias
function utils_help ($text, $explanation_array, $noarray=0)
{
  return help($text, $explanation_array, $noarray);
}

# print help about a word
#   $text  is the sentence where ballons are
#   $explanation_array is the table word->explanation, must be in the
#   array syntax.
function help ($text, $explanation_array, $noarray=0)
{
  if (!$noarray)
    {
      while (list($word,$explanation) = each($explanation_array))
        {
          $text = str_replace($word,
                              '<span class="help" title="'.$explanation.'">'.$word.'</span>',
                              $text);
        }
      return $text;
    }


  return '<span class="help"