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 short open tags is what allows to write code like this <?=”algo”?> instead of having to write <?php echo “algo”?>. Something REALLY INTERESTING, it makes PHP code really clear when looking at templates from my point of view.

I think PHP people has not made the right choice here. From what I understood, they disabled this because of the ambiguity when parsing XML documents, which starts by <?xml. I’ll better stop talking.

Anyway, everything is because I have a class called jview which loads the PHP view templates in my system, and lots of the templates (if not all) use this tags, so I wanted to keep writing the code like that without changing the short tags in the template files. You can think on WordPress templates to get an idea of how my templates look like.

Just to make an example of the whole problem, have a look at the following PHP code:

<?php echo "hello"?> <?= "world"?>

When short_open_tags is enabled, the PHP output is:

hello world

But when short_open_tags is disabled, then PHP produces this ugly output:

hello <?= "world"?>

BTW, I had two alternatives for solving this problem:

• Copy the template file into a temporal file, replace all ‘<?=’ by ‘<?php ‘, include the temporal file as a PHP file, and finally remove the file
• Make a PHP interpreter in PHP where I replace ‘<?=’ by ‘<?php ‘

If you know me, you know I’ve chosen the second option ;D

It only took me 20 minutes!! Less than I expected!

Here is the code:

  function include_emulating_short_tags ($viewFile)
  {
    // Alternate method for making <?= valid
    $raw = file_get_contents ($viewFile);
    $raw = str_replace ('<?=', '<?php echo ', $raw); 
 
    $html = '';
    $phptokens = @token_get_all ($raw);
 
    $mode    = 'text';
    $phpcode = '';
    foreach ($phptokens as $ptoken)
    {
      if (($mode == 'text') && is_array ($ptoken) && ($ptoken[0] === T_OPEN_TAG)) {
        $mode = 'php';
        continue;
      }
 
      if (($mode == 'php') && is_array ($ptoken) && ($ptoken[0] === T_CLOSE_TAG)) {
        ob_start();
        eval ($phpcode . ';');
        $html .= ob_get_contents();
        ob_end_clean();
 
        $mode    = 'text';
        $phpcode = '';
        continue;
      }
 
      if ($mode == 'text') { 
        $html .= is_array ($ptoken) ? $ptoken[1] : $ptoken;
      }
      else {
        $phpcode .= is_array ($ptoken) ? $ptoken[1] : $ptoken;
      }
    }
 
    if (($mode == 'php') && ($phpcode !== '')) {
      ob_start();
      eval ($phpcode);
      $html .= ob_get_contents();
      ob_end_clean();
    }
 
    return $html;
  }

At the end, the variable $html returned, contains the HTML code that will otherwise be flushed to standard output. This way, you can do with the output whatever you want.

Finally, if we use include_emulating_short_tags when short_open_tags=0 with the original example, the output will be “hello world”, what I wanted . I can see a couple of inconveniences (that could be work-arounded by writing something more elaborate), but for practical uses, it works perfectly well.

The truth is that the plugin is awesome. It works great! The only thing I missed was the lack of support for keeping separate comments, so the users reading the post in English only see the comments that the English-readers version made, and so for the Spanish readers/commenters. To me it seemed logic to keep separate comments since an English person will probably not understand Spanish, and he could get discouraged to leave a comment if he sees that all the comments are in Spanish. The opposite case is also true.

Some time ago  I asked Anthony Petitbois, the original writer of the plugin (awesome work), if he could make a couple of improvements to the plugin.

This request was around 10 months ago, and I wanted this functionality of keeping separate comments for a new blog, so I though:

“Hey! I never did a WordPress  plugin, the ZdMultilang is Open Source… it should not be that hard! Let’s contribute to the project!”

Around 4 hours and a half later, the plugin was completely written and this blog was updated. After several tests it seems that everything works like a charm! Then, hopefully it should work perfectly for any version of WordPress >= 2.8.x

What improvements are included?

• zd_multilang_get_locale(): it’s a function to get the current language(Inglés, Español, …), before that, you had to use the global $locale
• The ability to keep separate comments for each language
• The ability to keep all comments in the same thread, to behave as the plugin was already behaving

Please note that ALL existing comments, prior to the installation and activation of this plugin improvement, will be shown for ALL languages. From my point of view it makes sense to show all comments since I have no idea of which language where those comments written.

Please note as well that I added a new option to the translation preferences, so the user (you) can control whether you want to enable this functionality or you want the blog to behave as always (with all the comments for all the languages).  Anyway, whatever option you choose, ALL comments will be visible from the administration panel, so you could easily administer comments in ALL languages

The only additional thing you will have to do, to get this new functionality working, is to update the comments.php file in the current theme you are using, and change the form for posting comments:

From this:

action=”<?php echo get_option(’siteurl’); ?>/wp-comments-post.php”

to this:

action=”<?php echo get_option(’siteurl’); ?>/wp-comments-post.php?lang=<?=zd_multilang_get_locale()?>“

In the following link you could download a TGZ that contains the DIFF of the zdmultilang.php changes, the zdmultilang.php with the changes, and the readme.txt file:

• Download the improved ZdMultilang that keeps separate comments

Finally, I updated the version to 1.2.5, although this can produce “future” problems, unless I convice Anthony to include these improvements on the next version of the plugin

]]> http://www.codigomanso.com/en/2009/10/improved-multi-lingual-support-for-wordpress/feed/ 1866 http://www.codigomanso.com/en/2009/06/detect-an-animated-gif-in-php/ http://www.codigomanso.com/en/2009/06/detect-an-animated-gif-in-php/#comments Sun, 28 Jun 2009 19:50:33 +0000 Pau Sanchez http://www.codigomanso.com/es/?p=679 Following function detects if the GIF contains an animation (it has more than 1 frame) or is just a static file.

  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

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.

To start with a simple example, let’s say I’m doing a web site related to the motor industry, and as any other good website, I use a database. In that database there are two tables: brand and model. In the table brand there is a row for each car brand (Toyota, Honda, Hyunday, Mercedes, Chrysler, BMW, Audi, Lexus,…), and in the table model there is one row for each car model. For example, some models for Audi will be A6 2.0 TDIe , A5 2.0 TDI, A4, TT …, and the list grows and grows for each brand.

The think is, that in the front-end of my website I want to list the models of a brand in a specific order (the order I defined).

You will think, well, that’s easy, it’s just adding a field called sort_order in the model table, or if you love to have the tables normalized, then you will create an extra table with two foreign keys to model and brand, and then a field called sort_order.

It does not matter which solution you choose, the final concept is that there is a field name sort_order that is set manually on the backend, which defines the order used to list models in the frontend. Let’s see an example of these tables:

This was just an informal introduction, let’s get started!

In order to simplify things even more, imagine we are always talking about Audi (just to name one), and imagine we are working only with 4 models in the database: A3, A4, A5 y TT. From now on, we will forget about brands. So at the end, our table model looks like this:

Now, when I do a SELECT in my website, and I sort using the sort_order, then the models will be listed this way: A3, A4, A5 and finally Audi TT.

The problem:

¿What do I do if I want Audi TT to be the first in the website?

Please note that I want to move Audi TT to the first position, but I don’t want the A3, A4 and A5 change their respective orders; also note I said the first position, but I could have said I want TT to be placed between A3 and A4.

Solution 1: the easy onel

Well, so the first that comes to mind (at least to me) is basically to increment all rows whose sort_order is greater or equal to the position where I want to place the element I want to move, and then update the element I want to move. Let’s see in SQL:

UPDATE model SET sort_order = sort_order + 1 WHERE sort_order >= 1;
UPDATE model SET sort_order = 1 WHERE name = 'TT';

Above you can see two queries: the first one has a linear complexity because it has to update every single row in the table whose sort order is greater than the position (but all rows should be checked); the other query is just to update the row of the TT.

The problem with this solution is the part where ALL rows should be checked and lots of them updated. Then I though of another solution.

Solution 2: the magic of floats

An idea came to my mind: ¿What if instead of integers I use real numbers?

If the field sort_order was a real number, then maybe I could somehow update just the row I want, and leave the rest untouched. Please keep in mind that I use an interface on the backend as well for listing the products and updating the order, so for all elements I know which is the sort_order for the previous and the next elements, as well as for the element itself.

Now, imagine our initial configuration is (A3, A4, A5, TT), and we want to move the TT between A3 and A4. Then I only have to choose a sort_order value between A3 and A4, and magically the TT will be listed between both values. Let’s see the table after choose the middle value:

Basically I’ve done (1.0 + 2.0) / 2 to get the intermediate value between A3 and A4.

Notice you can also do this as many times as you want, and not only the order will always be preserved, but you will “never find” two rows having the same sort_order.

Let’s see another example, imagine now we want the A4 to be placed between A3 and TT, then the sort_order for A4 will be (1.0 + 1.5)/2 = 1.25.

It’s easy, ¿isn’t it? And you just have to update a single row.

Now there are lots of questions. This is so easy and cool, but ¿what happens if you want to place an element in the first position? If we asume the sort_order starts at 1 for the first element, then the previous element should be choosen as 0.00 (and the same rules will work).

¿And what happens if you want to insert the A6 model? As there are 4 elements, the sort_order for A6 will be 5.0 (to avoid colision, just use number of rows + 1).

And the very good question is: “floating point numbers had limitations, ¿didn’t they? ¿what happens if there is an overflow?” Yes man! this is the question!

Making sort_order to overflow is as easy as keep moving all elements to the same position, over and over again. For example, if we move the element with sort order 3, between the elements with sort order 1 and 2, then the order will be 1.0, 1.5, 2.0, then if we move the 2.0 between 1 and 1.5, we will have 1.0, 1.25, 1.5, if we do repeat the last operation we will have 1.0, 1.125, 1.25, and if you repeat this several times you will get lots of decimals.

This gets us to the third solution

Solution 3: the workaround

Solution 3.1: the background process

One solution could be to have a process once a day,week or month to sort all elements and update the sort_order by their index once sorted, that will remove all decimals for all rows. But if you are going to do this, better implement the first solution.

Solution 3.2: updating to integer when possible

This solution is the same as the solution 2, but rounding numbers to integers before updating, and checking that the number is between (but not equal) to the previous and the next position where we want to be placed.

Let’s see an example starting with following set of rows:

Then if I move A3, between A4 and A5, using solution two I will do the following: (1.7628 + 3.78)/2 = 2.7714. But, if I round 2.7714 down I get 2, and 2 is still between 1.7628 and 3.78, so instead of updating to 2.7714, it will be updated to 2. This way, if I move TT again between A3 and A5, this time instead of computing (2.7714 + 3.78) / 2, the TT position would be computed as (2 + 3.78) / 2, which contains less decimals.

Just notice that in this solution one only has to check if the number is still between the two numbers around, which are already known, and keeps the performance high. Just an update, as before, and all the computations are made on the client-side

If we assume that the movement of all elements will be almost random, using this way of computing number is less probable (but still possible) that an overflow happens.

By the way, I presented this solution using floating point numbers, but you can use integers (and I don’t mean using 10, 20, 30, and then getting intermediate values).

Conclussion

If you want a robust way, use the first solution; but if you want to update just an element each time, because there will be thousands of elements and thousand of users updating the sort order at the same time, then probably the second solution is better, although there can be problems when dealing with concurrent requests.

Finally although I’ve presented a couple of solutions (with their workarounds), I would be pleased to hear of another solutions or improvements.

Anyway, after 20 minutes debugging I have discovered a but on a website in PHP I’m developing, and when I realiced it was because a conceptual problem in a PHP function I’ve was using, then I got angry (but it was my fault).

The PHP function I’m talking about is empty, which as the manual states, determines whether a variable is empty (the concept is quite easy, I don’t understand why is not well implemented).

The problem was that I have a conditional saying if empty ($str) then do X, else do Y.

The conceptual problems comes here:  empty(“0″) is true!!

<dramatism>For God’s sake! What the hell was thinking the person who programed this?</dramatism>

Anyway, yesterday I read this blog post about suggesting solutions and not only pointing out problems, so let’s describe the problem, and let’s give a solution for all of this.

Let’s see the definition as it appears on the PHP manual:

empty — Determine whether a variable is empty

The following things are considered to be empty:

• “” (an empty string)
• 0 (0 as an integer)
• “0″ (0 as a string)
• NULL
• FALSE
• array() (an empty array)
• var $var; (a variable declared, but without a value in a class)

I undestand, according to the definition, that a NULL variable is considered as empty, the same with the FALSE value, the same as an empty array array() , and the same  with the string ” (which I think everyone understands why is empty). Even, I understand the number 0 is considered empty. Up to this point everything is consistend with the definition, it makes sense that each data type (boolean, string, array, reference) has a unique value considered as empty.

What it does not make sense is the strings having two values considered as empty. The empty string is ”, and that’s it.

I can imagine the reason why “0″ is considered as empty. In PHP you could do 322 + “17″ and internally it will transform the string “17″ in the number 17, so it will compute the numeric addition. With this in mind, when “0″ is passed to that function, there is no feasible way to know if the programmer is passing the string “0″ or the number 0 which forgot to cast to an integer.

Conclussion: the function empty should not contemplate the case of ‘0′ as true. It is wrong to assume that the programmer  is stupid enough to  forget to do a cast, and forces good people (like  me ), that understands what empty means and knows how to cast a variable in PHP, to avoid that implementation.

The original bug was my fault for using a function without knowing its behaviour in all cases, but IMHO that function should behave in another way.

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)