##
# Mimics the behaviour of http_build_query PHP function
# This method can be useful for sending data to flash applications
##################################################
def http_build_query(params, topkey = ''):
  from urllib import quote
 
  if len(params) == 0:
    return ""
 
  result = ""
 
  # is a dictionary?
  if type (params) is dict:
    for key in params.keys():
      newkey = quote (key)
      if topkey != '':
        newkey = topkey + quote('[' + key + ']')
 
      if type(params[key]) is dict:
        result += http_build_query (params[key], newkey)
 
      elif type(params[key]) is list:
        i = 0
        for val in params[key]:
          result += newkey + quote('[' + str(i) + ']') + "=" + quote(str(val)) + "&"
          i = i + 1
 
      # boolean should have special treatment as well
      elif type(params[key]) is bool:
        result += newkey + "=" + quote (str(int(params[key]))) + "&"
 
      # assume string (integers and floats work well)
      else:
        result += newkey + "=" + quote (str(params[key])) + "&"
 
  # remove the last '&'
  if (result) and (topkey == '') and (result[-1] == '&'):
    result = result[:-1]
 
  return result

If you find the code useful, feel free to use it in any kind of software product, be it commercial or not

Anyway, we are all grown ups, so you know what you are doing. Now, imagine you need to know this. There are several ways (the more creative you are, the more ways you will find). The first way, and most simple and complete, is by using the php_uname function. The php_uname is similar to the unix command uname, and with this function we can know the  operating system, the version of the OS, the release number, the host name, and the hardware architecture  (i386, amd64, …). It has all that you need

On the other hand, if you don’t want to use this pretty command, you can directly use the PHP_OS constant, which only includes the operating system name, but in most cases will be enough (it is equivalent to call php_uname(’s’)).

Now you can try these two examples:

echo php_uname() . "\n";
echo PHP_OS . "\n";

The funny thing is that probably you would never need to know the OS, so you can skip the whole post

The first thing that came to my mind was the PDFlib extension included in PHP since version 4. The problem with this library is that  I thought it was kind of low-level, and I didn’t had any idea on where to start.

In fact, the list of functions of PDFlib is quite big, and probably you can do about anything, but I did not want to be writing a hundred of lines to do a simple PDF, I just wanted to put a background image and write some lines in there.

Anyway, I decided to continue looking more information about this library and I end up finding a library called TCPDF, which is totally free, and seemed a lot more complete and simple. I really don’t know if it’s better or not than the PDFlib, but at least TCPDF has lots of examples. There are super-simple examples of about any aspect of the PDF, so doing your first PDF is a matter of copy-pasting from several examples. Really easy!

The truth is, that I did my FIRST prototype in about 15 minutes. Not bad at all. With this TCPDF library you can generate the PDF as if it was like a HTML file. You can pass the text using HTML tags (even CSS), and then the library internally converts that to the PDF, so you don’t have to think much about generating the PDF.

The only “problem” I see with this library is that the size of the zip file you have to download is around 10MB, which are around 16 MB once uncompressed. Anyway, almost all the size of the library comes from several fonts it includes, documentation and examples. If you remove the documentation and you keep only those fonts you are going to use, this library could be minified to 1 MB only.  Although for web development I think it does not worth to make it smaller. The size does not matter.

For more information about this library you can take a look at www.tcpdf.org

the…

wait for it….

wait for it….

wait for it….

GOTO

It’s amazing how PHP team is including in the same release high-level features, as well as a low-level feature like that (BTW most of the people will consider this feature harmful). They should have felt a great pressure from people or something, because I cannot find any reasonable reason for them to include it…

In the PHP goto documentation you will see that at least, they are funny about it:

  function isAnimatedGif($filename)
  {
    $filecontents=file_get_contents($filename);
 
    $str_loc=0;
    $count=0;
 
    // There is no point in continuing after we find a 2nd frame
    while ($count < 2) 
    {
      $where1=strpos($filecontents,"\x00\x21\xF9\x04", $str_loc);
      if ($where1 === FALSE) {
        break;
      }
 
      $str_loc = $where1+1;
      $where2  = strpos($filecontents,"\x00\x2C",$str_loc);
      if ($where2 === FALSE) {
        break;
      }
      else {
        if ($where1+8 == $where2) {
          $count++;
        }
        $str_loc = $where2+1;
      }
    }
 
    // gif is animated when it has two or more frames
    return ($count >= 2); 
  }

Following function does the same but in a more compact way:

function isAnimatedGif($filename) {
    return (bool)preg_match('#(\x00\x21\xF9\x04.{4}\x00\x2C.*){2,}#s', file_get_contents($filename));
}

I have modified slightly the first function, but both of them come originally from the comments at http://es2.php.net/manual/en/function.imagecreatefromgif.php

Nowadays there are thousands of libraries for any general purpose language that can perform the scaling of an image. The question is ¿which are the new width and height for the image?

Following there is this simple code, that have been tested using javascript, but should work in PHP, Python, Java, Perl, C, or whatever language you want to try

if (w < h) {
  h = (h * maxWidth) / w;
  w = maxWidth;
}
else {
  w = (w * maxHeight) / h;
  h = maxHeight;
}

w represents the image width

h represents the image height

maxWidth represents the maximum width boundary where the image is going to be embedded

maxHeight represents the maximum height boundary where the image is going to be embedded

As a final example, although is a copy-paste, imagine you have an image of size (w, h) and you have to fit it in an area of 640×480:

var maxWidth = 640, maxHeight = 480;
if (w > maxWidth || h > maxHeight) {
  if (w < h) {
    h = (h * maxWidth) / w;
    w = maxWidth;
  }
  else {
    w = (w * maxHeight) / h;
    h = maxHeight;
  }
}

I think I will probably be sharing the class for string manipulation that I’ve been coding (which of course is 100% compatible with UTF-8).

For now, I’m going to share a simple function to split a UTF-8 string into an array of strings. This is not something you want to do all over your code, because arrays consume a HUGE amount of memory in PHP, but sometimes it an be useful for specific purposes.

Converting a UTF-8 string into an array, in any version before PHP 6 has two big advantages:

• each element of the array represents a unique character (the same that when you do $string[$i])
• count would be equivalent to mb_strlen over the original string

The bad news are the time spent on conversion and the memory consumption (as you will be using an array instead of a native string).

Yesterday I wrote a couple of functions, and I borrowed this one that a user had shared on PHP manuals

These are the three versions in PHP:

function getCharArray1 ($jstring)
{
  $len = mb_strlen ($jstring, 'UTF-8');
  if (mb_strlen ($jstring, 'UTF-8') == 0)
    return array();
 
  $ret = array();
  for ($i = 0; $i < $len; $i++) {
    $char = mb_substr ($jstring, $i, 1, 'UTF-8');
    array_push ($ret, $char);
  }
 
  return $ret;
}
 
// code from: http://uk3.php.net/manual/en/function.mb-split.php#80046
function getCharArray2 ($jstring)
{
  $len = mb_strlen ($jstring, 'UTF-8');
  if (mb_strlen ($jstring, 'UTF-8') == 0)
    return array();
 
  while ($len) {
    $ret[]  = mb_substr($jstring,0,1,"UTF-8");
    $jstring = mb_substr($jstring,1,$len,"UTF-8");
    $len = mb_strlen($jstring);
  }
  return $ret;
}
 
// using mb_check_encoding instead of mb_substr ;)
function getCharArray3 ($jstring)
{
  if (mb_strlen ($jstring, 'UTF-8') == 0)
    return array();
 
  $ret  = array ();
  $alen = strlen ($jstring);
  $char = '';
  for ($i = 0; $i < $alen; $i++) {
    $char .= $jstring[$i];
    if (mb_check_encoding ($char, 'UTF-8')) {
      array_push ($ret, $char);
      $char = '';
    }
  }
 
  return $ret;
}

The fastest function is the latter, that uses a small trick I thought (and in fact worked great).

The following chart represents the execution times of each function for a set of iterations over the functions on a huge string.

Leyenda:

• getCharArray1: in red
• getCharArray2: in green
• getCharArray3: in blue

As you can see, getCharArray3 (blue) is the fastest (around 4x faster than getCharArray1, and 6x faster than getCharArray2).

Finally, you can check the benchmark script I’ve used for generating the chart.

The thing is that for some of the components I needed to parse some data (look at parser definition), and for that task I needed a PHP tokenizer (or PHP lexer if you prefer).

As PHP is a interpreted language, the faster the implementation, the best. So I have two possibilities: start from scratch, using the standard string functions that come with PHP (it seems to me that is going to be slow); or, on the other hand, use token_get_all which is available since PHP 4.2.0.

Personally I’ve tried the later. token_get_all it is intended to tokenize PHP code, but what I’ve done is to create a wrapper class that encapsulates a call to that function, and returns a normalized list of identifiers and text entries for each id.

The trick to call to token_get_all is to add “<?php “ at the beginning of the string you want to parse, and append “?>” at the end (probably the “?>” at the end is optional).

If the tokens you need for your personal tokenizer, are a subset of the tokens that PHP supports, then using this function is your best choice. Otherwise you will have to work a little harder on another implementation (which I think would be slower). Fortunately, I think PHP grammar and tokens are standard enough to work for most of the people and needs.

The problem of token_get_all function is that it returns a weird array. Sometimes it returns a simple string item, while others return an array containing a PHP identifier and the text for that token.

Let’s go to see a possible implementation:

<?php
class jtokenizer {
  const TK_UNKNOWN  = 0x0000;
  const TK_ID       = 0x0001;
  const TK_STRING   = 0x0002;
 
  const TK_PLUS     = 0x0003;
  const TK_MINUS    = 0x0004;
 
  // ...
 
  public static function tokenize ($string) {
    $tokens = array();
    $phptokens = token_get_all ('<?php ' . $string . '?>');
 
    foreach ($phptokens as $ptoken) {
      $id = self::TK_UNKNOWN;
      if (is_string ($ptoken)) {
        $text = $ptoken;
        switch ($ptoken) {
          case '+': $id = self::TK_PLUS;  break;
          case '-': $id = self::TK_MINUS; break;
 
          ////////////////////////////////////////
          // Add more tokens here!
          // E.g: '.', ',', ';', ':', '=', ...
          ////////////////////////////////////////
 
          default: /** handle error here! */ break;
        }
      }
      else { // this should be an array (tokenid, text)
        list ($tokenid, $text) = $ptoken;
        switch ($tokenid) {
          // ignore opening/closing tag
          case T_OPEN_TAG:   $id = NULL; break;
          case T_CLOSE_TAG:  $id = NULL; break;
 
          // ignore white spaces
          case T_WHITESPACE: $id = NULL; break;
 
          case T_CONSTANT_ENCAPSED_STRING:
            $id = self::TK_STRING;
            // remove ' or " at the beginning and at the end
            $text = trim($text, $text[0]); 
            break;
 
          case T_STRING:
            $id = self::TK_ID;
            break;
 
          ///////////////////////////////////////////
          // Add more tokens here!
          // Get a complete list from:
          // http://uk3.php.net/manual/en/tokens.php
          ///////////////////////////////////////////
 
          default: /** handle error here! */ break;
        }        
      }
 
      // append the token
      if ($id !== NULL) {
        array_push ($tokens, array ($id, $text));
      }
    }
 
    return $tokens;
  }
}

The code above is a really simple skeleton that exemplifies how easy is to make a parser based on that native PHP function. There are lots of things to be done on that function, of course, but you get an idea, ¿right?

Then, tokenizing a string would be as easy as jtokenizer::tokenize ($string)

The advantage is that handling the array returned by jtokenizer::tokenize method is really easy (the first element would be an ID, while the second is always the text). And we can define our own tokens, so if you want interpret “return” as a normal ID, you could do it, by returning jtokenizer::TK_ID.

I think that example is enough to anybody that wants to make it’s own parser, and anyway, if you do not want to return an array of arrays, feel free to change the code to return whatever you think is better to you

For more information, take a look at the PHP documentation:

• token_get_all function in php.net
• PHP tokenizer
• List of tokens returned by token_get_all (very useful if you plan to extend the skeleton above)

Note:If you want a faster tokenizer, then use associative arrays instead of switches (you could take a look to is it better use associative arrays or switches? – unfortunately there is no english translation yet)