O GCJ é uma competição onde são lançados desafios que devem ser resolvidos utilizando alguma linguagem de programação. No caso a linguagem que me sinto mais confortavel é o PHP.
Olhei o score board da competição e não vi nenhum competidor utilizar PHP, a maioria utiliza C++, Java, C ou Python. Foram as únicas linguagens que ví.

O motivo é o desempenho, essas linguagens são bem mais rápidas que o PHP por exemplo.

Bom... por isso achei interessante publicar o artigo com a resolução em php. A grande vantagem que eu vejo no PHP é a facilidade para manipular arrays e strings. Mas o desempenho php não é muito bom.
O bom é que o desempenho só serve como critério de desempate. Talvez a produtividade do php seja suficientemente boa para não precisar utilizar critério de desempate.

Mas vamos ao que interessa. Nesse artigo resolverei o primeiro desafio da rodada de qualificação do GCJ 2009.

Copiei a descrição do desafio logo abaixo, mas se quiserem podem acessar o link http://code.google.com/codejam/contest/dashboard?c=90101#s=p0

Problem

After years of study, scientists at Google Labs have discovered an alien language transmitted from a faraway planet. The alien language is very unique in that every word consists of exactly L lowercase letters. Also, there are exactly D words in this language.

Once the dictionary of all the words in the alien language was built, the next breakthrough was to discover that the aliens have been transmitting messages to Earth for the past decade. Unfortunately, these signals are weakened due to the distance between our two planets and some of the words may be misinterpreted. In order to help them decipher these messages, the scientists have asked you to devise an algorithm that will determine the number of possible interpretations for a given pattern.

A pattern consists of exactly L tokens. Each token is either a single lowercase letter (the scientists are very sure that this is the letter) or a group of unique lowercase letters surrounded by parenthesis ( and ). For example: (ab)d(dc) means the first letter is either a or b, the second letter is definitely d and the last letter is either d or c. Therefore, the pattern (ab)d(dc) can stand for either one of these 4 possibilities: add, adc, bdd, bdc.

Input

The first line of input contains 3 integers, L, D and N separated by a space. D lines follow, each containing one word of length L. These are the words that are known to exist in the alien language. N test cases then follow, each on its own line and each consisting of a pattern as described above. You may assume that all known words provided are unique.

Output

For each test case, output

Case #X: K

where X is the test case number, starting from 1, and K indicates how many words in the alien language match the pattern.

Limits

Small dataset

1 ≤ L ≤ 10
1 ≤ D ≤ 25
1 ≤ N ≤ 10

Large dataset

1 ≤ L ≤ 15
1 ≤ D ≤ 5000
1 ≤ N ≤ 500

Sample

Uma, dentre muitas soluções é utilizar expressões regulares. Esses testes são praticamente a expressão regular que precisamos, basta substituirmos os parêntes por colchetes.

Fazemos um loop dos testes, e testamos ele para todas as palavras.

segue abaixo o código php:

#!/usr/bin/php
<?php
/**
  * Mathias Grimm
<mathiasgrimm@gmail.com>
  * http://mathiasgrimm.com.br
  * http://phpempregos.com.br
  */
 
//error level
ini_set('display_errors','on');
error_reporting(E_ALL);
 
//debug
function x(){print_r(func_get_args());}
function xd(){print_r(func_get_args());die;}
 
//read input
$arLinhas   = explode("\n",file_get_contents('input.in','r'));
$arVars     = explode(" ",array_shift($arLinhas));
$words      = $arVars[1];
$tests      = $arVars[2];
$arWords    = array_slice($arLinhas,0,$words);
$arTests    = array_slice($arLinhas,$words);
 
array_pop($arTests);
 
$case       = 1;
$out        = ""; 
 
foreach($arTests as $test)
{
    $pattern    = "/".str_replace(array('(',')'),array('[',']'),$test)."/";
    $count      = 0;
 
    foreach($arWords as $word)
    {
        if(preg_match($pattern,$word))
        {
            $count++;
        }
    }   
 
    $out.=sprintf("Case #%d: %d\n",$case++,$count);
}
 
file_put_contents('output.out',$out);
 

Estou utilizando php-cli pois não preciso instalar apache nem nada. Também estou utilizando o Ubuntu 9.10 e para instalar o php-cli basta digitar sudo apt-get install php5-cli

Disponibilizarei a solução dos desafios assim que eu for fazendo.

Agradeço a presença de todos e voltem sempre!

O Gerador é bem interessante, pois apesar de ser escrito em php, ele pode gerar qualquer tipo de código,
ou seja, php,javascript,html,java ou qualquer outra linguagem. Já fiz até alguns testes para gerar csv e funcionou,
mas de fato, o foco era e é geração de código fonte.

Nesse artigo vou demonstrar como gerar um VO (Value Object) que é conhecido pela maioria dos desenvolvedores.

Chamei o gerador de Dreamm, fazendo um trocadilho com Dream (Sonho) e Grimm(Mathias Grimm), mas é apenas uma brincadeira.

Utilizei uma técnica que demostrei num artigo anterior, que é sobre template engines. O funcionamento é bem parecido,
basicamente substituição de strings.

Para gerar um código fonte você ira precisar escrever um Parser e um Template. O seu parser não vai se preocupar com nada mais do que
retornar as strings corretamente para cara variável/região definidas dentro do template.

O template é constituido por variáveis e regiões.

As variáveis serão apenas substituídas e são definidas por /*variavel*/ onde 'variavel' é o nome da variável.
Por Padrão defini que as variáveis devem estar entre /* e */, mas elas podem ser alteradas, como veremos mais a frente.

As regiões são regiões que serão substituidas dentro de um loop, e dentro delas pode-se utilizar variáveis.
O Delimitador da regiao é /*#regiao#*/ conteudo /*#regiao#*/, onde regiao é o nome da regiao e o conteúdo é o conteúdo que será repetido

Para cada região ou variável, deve existir um método correspondente dentro do seu Parser

abaixo vou mostrar o template do nosso VO.

<?php
class /*class*/
{
	/*#PROPRIEDADES#*/
	/**
	 * /*descricaoPropriedade*/
	 *
	 * @var /*tipoVariavelPropriedade*/
	 */
	private $/*nomePropriedade*/;
	/*#PROPRIEDADES#*/
 
	/*#GETS#*/
	/**
	 * /*descricaoGet*/
	 *
	 * @return /*tipoRetornoGet*/
	 */
	public function get/*nomeFuncaoGet*/()
	{
		return $this->/*nomePropriedadeGet*/;
	}
	/*#GETS#*/
 
	/*#SETS#*/
	/**
	 * /*descricaoSet*/
	 *
	 * @param mixed
	 * @return void
	 */
	public function set/*nomeFuncaoSet*/($param)
	{
		$this->/*nomePropriedadeSet*/ = $param;
	}
	/*#SETS#*/
}
?>
 

Vamos identificar agora algumas variáveis e regiões para ficar mais claro.
Logo no início temos a variável /*class*/ e regiao /*#PROPRIEDADES#*/.
A variável /*class*/ vai ser substituida por o nome da classe e deverá ter um método parseClass dentro da classe ValueObjectParser.
A região /*#PROPRIEDADES#*/ irá definir cada propriedade do VO, ou seja, os atributos do vo, com os respectivos comentarios e tipo de variável
e não precisará ter um método definido.

Para nosso artigo, criei um formulário, representando a tabela 'produto' que terá os campos ID_PRODUTO,CD_PRODUTO e DS_PROTUDO.
passaremos esses dados para nosso parser para gerar nosso VO. No artigo esse formuário é estático, mas na prática estou carregando
os dados dinamicamente do banco de dados.

Código fonte do formulario:

<?php
header('Content-Type: text/html; charset=utf-8');
?>
<style>
.formulario label { display:inline-table;width:200px; }
.formulario input,select {width:300px;}
</style>
<form method="post" action="processa_formulario.php" class="formulario">
	<fieldset>
		<label>Tabela</label>
<input type="text" name="tabela" value="produto" readonly="readonly">
 
		<fieldset>
			<legend>ID_PRODUTO</legend>
 
			<label>Descrição Propriedade</label> 
<input type="text" name="campos[ID_PRODUTO][descricaoPropriedade]">
			<br/>
 
			<label>Tipo da variável</label>
<select name="campos[ID_PRODUTO][tipoDaPropriedade]">
				<option value="mixed">Mixed</option>
				<option value="string">String</option>
				<option value="int">Int</option>
				<option value="double">double</option>
				<option value="boolean">Boolean</option>
				<option value="array">Array</option>
			</select>
 
			<br/>
 
		</fieldset>
 
		<fieldset>
			<legend>CD_PRODUTO</legend>
 
			<label>Descrição Propriedade</label> 
<input type="text" name="campos[CD_PRODUTO][descricaoPropriedade]">
			<br/>
 
			<label>Tipo da variável</label>
<select name="campos[CD_PRODUTO][tipoDaPropriedade]">
				<option value="mixed">Mixed</option>
				<option value="string">String</option>
				<option value="int">Int</option>
				<option value="double">double</option>
				<option value="boolean">Boolean</option>
				<option value="array">Array</option>
			</select>
 
			<br/>
 
		</fieldset>
 
		<fieldset>
			<legend>DS_PRODUTO</legend>
 
			<label>Descrição Propriedade</label> 
<input type="text" name="campos[DS_PRODUTO][descricaoPropriedade]">
			<br/>
 
			<label>Tipo da variável</label>
<select name="campos[DS_PRODUTO][tipoDaPropriedade]">
				<option value="mixed">Mixed</option>
				<option value="string">String</option>
				<option value="int">Int</option>
				<option value="double">double</option>
				<option value="boolean">Boolean</option>
				<option value="array">Array</option>
			</select>
 
			<br/>
 
		</fieldset>
 
		<button>Dreamm!</button>
	</fieldset>
</form>
 

Observer que definimos o nome dos inputs de uma maneira um pouco diferente, mas fundamental para esse artigo.

 
<input name="campos[ID_PRODUTO][descricaoPropriedade]">

O name de todos inputs e selects deverão ficar dentro do array 'campos' e indexados pelo nome da coluna.

No php receberemos o post da seguinte maneira:

print_r($_POST);
Array
(
    [tabela] => produto
    [campos] => Array
        (
            [ID_PRODUTO] => Array
                (
                    [descricaoPropriedade] => Chave primária
                    [tipoDaPropriedade] => int
                )

            [CD_PRODUTO] => Array
                (
                    [descricaoPropriedade] => Código do produto
                    [tipoDaPropriedade] => string
                )

            [DS_PRODUTO] => Array
                (
                    [descricaoPropriedade] => Descrição do produto
                    [tipoDaPropriedade] => string
                )

        )

)

Veja logo abaixo a estrutura de diretórios do Dreamm.

O ValueObjectParser.php e qualquer outro parser que for criado, deve ficar na pasta 'parsers'.
O ValueObject.php é nosso template (forma) e assim ele deve ficar dentro da pasta 'templates',da mesma maneira que outros templates.
O formulário.php é nosso formulário.
O Parser.php é a classe principal do Dreamm. Todos parsers devem estender dessa classe.
O processa_formuário.php é que recebe os dados do formulário e passa para o parser, assim como informa qual template deverá ser utilizado.

Segue abaixo o código fonte do processa_formulário.php

<?php
error_reporting(E_ALL);
ini_set('display_errors','on');
header('Content-Type: text/html; charset=utf-8');
 
include 'Parser.php';
 
$template 			= 'ValueObject.php';
$arDadosRecebidos	= $_POST;
 
$source = Parser::run($template,$arDadosRecebidos);
 
highlight_string($source);
 
?>
 

O nome do template poderia ser algo que ficasse no formulário também, mas nesse caso não utilizei desse maneira.

Basta definir o nome do template e passar o POST para dentro do parser.
O Parser ira buscar o parser e automaticamente assumira que o nome da classe do parser é o mesmo nome do template concatenado com a palavra Parser no final.
Nesse caso temos o ValueObject.php que é o template. O parser procurará a classe ValueObjectParser.php

A estrutura básica de todos parsers deve ser conforme a seguir:

<?php
class ValueObjectParser extends Parser
{
	public function inicializarDados()
	{
		$this->arDadosRegiao   = $this->arDadosRecebidos['campos'];
	}
}
 

Observe que no momento nosso parser só tem um método, que é responsável por inicializar os dados.
Devemos inicializar o array de dados das regiaões, nesse caso, dentro do formulario os campos estão dentro do array campos, mostrado anteriormente no formulário.

Vamos rodar nossa parser agora e ver o que acontece.
Será exibida uma mensagem que alguns métodos não foram implementados.
Lembram das variáveis do template ??? Para cada uma delas deverá existir um método correspondente,
e é exatamente isso que o parser está nos falando, e no caso, já esta mostrando TODOS os métodos que devem ser implementados.

veja a seguir:

Vamos copiar e colar todos esses métodos dentro da nossa classe ValueObjectParser.

<?php
class ValueObjectParser extends Parser
{
	public function inicializarDados()
	{
		$this->arDadosRegiao    = $this->arDadosRecebidos['campos'];
	}
 
	protected function parseDescricaoPropriedade()
    {
        return "'parseDescricaoPropriedade()'";
    } 
 
    protected function parseTipoVariavelPropriedade()
    {
        return "'parseTipoVariavelPropriedade()'";
    } 
 
    protected function parseNomePropriedade()
    {
        return "'parseNomePropriedade()'";
    } 
 
    protected function parseDescricaoGet()
    {
        return "'parseDescricaoGet()'";
    } 
 
    protected function parseTipoRetornoGet()
    {
        return "'parseTipoRetornoGet()'";
    } 
 
    protected function parseNomeFuncaoGet()
    {
        return "'parseNomeFuncaoGet()'";
    } 
 
    protected function parseNomePropriedadeGet()
    {
        return "'parseNomePropriedadeGet()'";
    } 
 
    protected function parseDescricaoSet()
    {
        return "'parseDescricaoSet()'";
    } 
 
    protected function parseNomeFuncaoSet()
    {
        return "'parseNomeFuncaoSet()'";
    } 
 
    protected function parseNomePropriedadeSet()
    {
        return "'parseNomePropriedadeSet()'";
    } 
 
    protected function parseClass()
    {
        return "'parseClass()'";
    }
}
 

e agora vamos rodar novamente e ver oque acontece!!

Eis aí o código fonte que foi gerado!
Ele não é exatamente o que estamos tentando gerar mas já é o começo!
O que precisamos agora é retornar as strings corretas.

<?php
class 'parseClass()'
{
    /**
     * 'parseDescricaoPropriedade()'
     *
     * @var 'parseTipoVariavelPropriedade()'
     */
    private $'parseNomePropriedade()';
    /**
     * 'parseDescricaoPropriedade()'
     *
     * @var 'parseTipoVariavelPropriedade()'
     */
    private $'parseNomePropriedade()';
    /**
     * 'parseDescricaoPropriedade()'
     *
     * @var 'parseTipoVariavelPropriedade()'
     */
    private $'parseNomePropriedade()'; 
 
    /**
     * 'parseDescricaoGet()'
     *
     * @return 'parseTipoRetornoGet()'
     */
    public function get'parseNomeFuncaoGet()'()
    {
        return $this->'parseNomePropriedadeGet()';
    }
    /**
     * 'parseDescricaoGet()'
     *
     * @return 'parseTipoRetornoGet()'
     */
    public function get'parseNomeFuncaoGet()'()
    {
        return $this->'parseNomePropriedadeGet()';
    }
    /**
     * 'parseDescricaoGet()'
     *
     * @return 'parseTipoRetornoGet()'
     */
    public function get'parseNomeFuncaoGet()'()
    {
        return $this->'parseNomePropriedadeGet()';
    } 
 
    /**
     * 'parseDescricaoSet()'
     *
     * @param mixed
     * @return void
     */
    public function set'parseNomeFuncaoSet()'($param)
    {
        $this->'parseNomePropriedadeSet()' = $param;
    }
    /**
     * 'parseDescricaoSet()'
     *
     * @param mixed
     * @return void
     */
    public function set'parseNomeFuncaoSet()'($param)
    {
        $this->'parseNomePropriedadeSet()' = $param;
    }
    /**
     * 'parseDescricaoSet()'
     *
     * @param mixed
     * @return void
     */
    public function set'parseNomeFuncaoSet()'($param)
    {
        $this->'parseNomePropriedadeSet()' = $param;
    }
}
?>
 

Vamos agora preencher o formulário e também implementar os métodos dentro da nossa classe para ver oque acontece.

Veja os formulário preenchido

Implementação do nosso ValueObjectParser:

<?php
class ValueObjectParser extends Parser
{
	public function inicializarDados()
	{
		$this->arDadosRegiao    = $this->arDadosRecebidos['campos'];
	}
 
	protected function parseDescricaoPropriedade()
    {
        return $this->iteracaoAtual['descricaoPropriedade'];
    } 
 
    protected function parseTipoVariavelPropriedade()
    {
        return $this->iteracaoAtual['tipoDaPropriedade'];
    } 
 
    protected function parseNomePropriedade()
    {
        return $this->camelizeCol($this->indiceIteracaoAtual,FALSE);
    } 
 
    protected function parseDescricaoGet()
    {
        return "Retorna ".$this->iteracaoAtual['descricaoPropriedade'];
    } 
 
    protected function parseTipoRetornoGet()
    {
        return $this->iteracaoAtual['tipoDaPropriedade'];
    } 
 
    protected function parseNomeFuncaoGet()
    {
        return $this->camelizeCol($this->indiceIteracaoAtual,TRUE);
    } 
 
    protected function parseNomePropriedadeGet()
    {
        return $this->camelizeCol($this->indiceIteracaoAtual,FALSE);
    } 
 
    protected function parseDescricaoSet()
    {
        return "Define ".$this->iteracaoAtual['descricaoPropriedade'];
    } 
 
    protected function parseNomeFuncaoSet()
    {
        return $this->camelizeCol($this->indiceIteracaoAtual,TRUE);
    } 
 
    protected function parseNomePropriedadeSet()
    {
        return $this->camelizeCol($this->indiceIteracaoAtual,FALSE);
    } 
 
    protected function parseClass()
    {
         return $this->camelizeCol($this->arDadosRecebidos['tabela'],TRUE);
    }
}
 

O código gerado ficará assim

<?php
class Produto
{
    /**
     * Chave primária
     *
     * @var int
     */
    private $idProduto;
    /**
     * Código do produto
     *
     * @var string
     */
    private $cdProduto;
    /**
     * Descrição do produto
     *
     * @var string
     */
    private $dsProduto; 
 
    /**
     * Retorna Chave primária
     *
     * @return int
     */
    public function getIdProduto()
    {
        return $this->idProduto;
    }
    /**
     * Retorna Código do produto
     *
     * @return string
     */
    public function getCdProduto()
    {
        return $this->cdProduto;
    }
    /**
     * Retorna Descrição do produto
     *
     * @return string
     */
    public function getDsProduto()
    {
        return $this->dsProduto;
    } 
 
    /**
     * Define Chave primária
     *
     * @param mixed
     * @return void
     */
    public function setIdProduto($param)
    {
        $this->idProduto = $param;
    }
    /**
     * Define Código do produto
     *
     * @param mixed
     * @return void
     */
    public function setCdProduto($param)
    {
        $this->cdProduto = $param;
    }
    /**
     * Define Descrição do produto
     *
     * @param mixed
     * @return void
     */
    public function setDsProduto($param)
    {
        $this->dsProduto = $param;
    }
}
?>
 

Alguns métodos e variáveis desconhecidas foram utilizadas dentro da nosso parcer. Vou explicar um pouco.

O método 'camelizeCol' transforma uma string do formato ID_PRODUTO para idProduto ou IdProduto. O primeiro argumento é a string a ser transformada
e o segundo é se a primeira letra da string ficará maíuscula ou não. Isso é útil para montar tanto nome de métodos como de propriedades.

A variável '$this->iteracaoAtual' tem o array de dados referente ao campo atual que esta sendo itarado, como você viu, o nosso formário foi todo declarado no formato de array.

A variável '$this->indiceIteracaoAtual' é referente ao nome do campo atual

A variável '$this->arDadosRecebidos' tem todos dados recebidos do formlário

Não vou me aprofundar mais nesse artigo, mas lembre-se, para cada template existe um parser. Para cada variável dentro do template
deve existir um método dentro do Parser. O resto é aprender na prática!!!

Pelo menos agora vocês tem no mínimo um gerador de VO.

O ideal é montar um formulário dinamicamente e disponibilizar mais opções no formulário.
Criem seus templates e parsers a vontade!

Bom, por hoje é só. Para baixar o código fonte utilizado nesse artigo clique aqui!

Desculpem qualquer erro ou falta de didática. Qualquer dúvida é só entrar em contato.

No próximo artigo demonstrarei como utilizar uma iteração condicional, para definir se um campo vai ser gerado ou não etc e tal...

Agradeço a todos e voltem sempre!

Resolvi estudar um pouco a criação de extensões do php, e publicar um "hello Wolrd" para vcs.
Achei um pouco complexo para um simples hello world mas no final acabei me acostumando.

Bom, desenvolvi a extensão num ubuntu 8.10 server e um php 5.2.8.
Vamos ao que interessa...

Primeiro você precisa baixar o código fonte do php, baixe a versão tar.bz2 pois é menor por ter uma compactação mais otimizada, mas se quiser baixar a versão .tar.gz da na mesma, só que demora mais pra baixar. Agora descompacte usando tar xvjf  php-5.2.8.tar.bz2. Esse nome pode variar de acordo com a versão baixada. Também será necessário conhecimento em C pois o código fonte do php é em C.

Agora entre na pasta digitando cd php-5.2.8. Dentro da pasta existem varios arquivos (mais de 10 mil eu acho) subdivididos em algumas pastas. As extensões ficam na pasta php-5.2.8/ext/ que é onde vc criará a sua! Pronto! Agora vamos criar o arquivo de definição da sua função. Crie dentro da pasta ext um arquivo chamado mg_teste.def (mg_teste sera o nome da extensão) e dentro dele coloque o seguinte texto: string hello_world(string name) e salve o arquivo. Esse arquivo é utilizado para o php gerar um template para seu plugin.

Agora dentro da pasta ext digite o seguinte comando (como root, ou com sudo) ./ext_skel --extname=mg_teste --proto=mg_teste.def . Tal comando gera a estrutura de diretórios e os arquivos template dentro desses diretórios.

Nossa extensão se chamará mg_teste, então após o comando ./ext_skel anterior será gerado a pasta mg_teste dentro de ext

Após o ext_skel é mostrado um texto mandando executar os seguintes comandos:

cd ..
vi ext/mg_teste/config.m4
./buildconf
./configure --[with|enable]-mg_teste
make
./php -f ext/mg_teste/mg_teste.php
vi ext/mg_teste/mg_teste.c
make

Bom, vou passo a passo:
o cd.. eh para vc "cair" na pasta php-5.2.8

o vi ext/mg_teste/config.m4 é um dos arquivos gerados... nele vc deve descomentar 2 linhas para que o plugin funcione.
Descomente as linhas PHP_ARG_ENABLE(mg_teste, whether to enable mg_teste support,
e  [  --enable-mg_teste           Enable mg_teste support])
Aqui estavam na linha 16 e 18 mas talvez não seja o seu caso.

Agora o comando ./buildconf só funcionou com a opção --force, ficando ./buildconf --force

O comando ./configure --enable-mg_teste deve ser usado para verificar as depenências e também habilitar a extensão que estamos criando.. provavelmente nesse momento vc tera alguns problemas. Eu tive que instalar o pacote libxml2-dev pois estava faltando. Instalei utilizando apt-get install libxml2-dev

O make também tive que instalar. apt-get install make
O make é que compila todo o php juntamente com sua extensão. A compilação demorou um pouco aqui... uns 5 minutos eu acho, ou mais.

O comando ./php -f ext/mg_teste/mg_teste.php não funcionou aqui pois o executavel do php foi salvo em /home/mathias/php-5.2.8/sapi/cli/php então tive que rodar com /home/mathias/php-5.8.2/sapi/cli/php -f /home/mathias/php-5.2.8/ext/mg_teste/mg_teste.php

O Comando vi ext/mg_teste/mg_teste.c é sugerido para que vc implemente sua função, caso contrário ela conterá um código que só emite um erro falando que ela ainda não foi implementada.Foi aí que implementei o hello world.

Sempre que você alterar o mg_teste.c deve executar o make para compilar. Sempre execute o make na raiz do php, ou seja , em /home/mathias/php-5.2.8/ . Essa compilação foi mais rápida, leva uns 20 segundos eu acho.

É isso... esse são os passos para criar a extensão. Pra testar criei um arquivo teste.php dentro de /home/mathias

<?php
    echo hello_world("Mathias Grimm");
?>

Para executa-lo usei o comando /home/mathias/php-5.2.8/sapi/cli/php -f /home/mathias/teste.php

Segue o código do mg_teste.c:

/*
  +----------------------------------------------------------------------+
  | PHP Version 5                                                        |
  +----------------------------------------------------------------------+
  | Copyright (c) 1997-2007 The PHP Group                                |
  +----------------------------------------------------------------------+
  | This source file is subject to version 3.01 of the PHP license,      |
  | that is bundled with this package in the file LICENSE, and is        |
  | available through the world-wide-web at the following url:           |
  | http://www.php.net/license/3_01.txt                                  |
  | If you did not receive a copy of the PHP license and are unable to   |
  | obtain it through the world-wide-web, please send a note to          |
  | license@php.net so we can mail you a copy immediately.               |
  +----------------------------------------------------------------------+
  | Author:                                                              |
  +----------------------------------------------------------------------+
*/
 
/* $Id: header,v 1.16.2.1.2.1 2007/01/01 19:32:09 iliaa Exp $ */
 
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
 
#include "php.h"
#include "php_ini.h"
#include "ext/standard/info.h"
#include "php_mg_teste.h"
 
/* If you declare any globals in php_mg_teste.h uncomment this:
ZEND_DECLARE_MODULE_GLOBALS(mg_teste)
*/
 
/* True global resources - no need for thread safety here */
static int le_mg_teste;
 
/* {{{ mg_teste_functions[]
 *
 * Every user visible function must have an entry in mg_teste_functions[].
 */
zend_function_entry mg_teste_functions[] = {
	PHP_FE(confirm_mg_teste_compiled,	NULL)		/* For testing, remove later. */
	PHP_FE(hello_world,	NULL)
	{NULL, NULL, NULL}	/* Must be the last line in mg_teste_functions[] */
};
/* }}} */
 
/* {{{ mg_teste_module_entry
 */
zend_module_entry mg_teste_module_entry = {
#if ZEND_MODULE_API_NO >= 20010901
	STANDARD_MODULE_HEADER,
#endif
	"mg_teste",
	mg_teste_functions,
	PHP_MINIT(mg_teste),
	PHP_MSHUTDOWN(mg_teste),
	PHP_RINIT(mg_teste),		/* Replace with NULL if there's nothing to do at request start */
	PHP_RSHUTDOWN(mg_teste),	/* Replace with NULL if there's nothing to do at request end */
	PHP_MINFO(mg_teste),
#if ZEND_MODULE_API_NO >= 20010901
	"0.1", /* Replace with version number for your extension */
#endif
	STANDARD_MODULE_PROPERTIES
};
/* }}} */
 
#ifdef COMPILE_DL_MG_TESTE
ZEND_GET_MODULE(mg_teste)
#endif
 
/* {{{ PHP_INI
 */
/* Remove comments and fill if you need to have entries in php.ini
PHP_INI_BEGIN()
    STD_PHP_INI_ENTRY("mg_teste.global_value",      "42", PHP_INI_ALL, OnUpdateLong, global_value, zend_mg_teste_globals, mg_teste_globals)
    STD_PHP_INI_ENTRY("mg_teste.global_string", "foobar", PHP_INI_ALL, OnUpdateString, global_string, zend_mg_teste_globals, mg_teste_globals)
PHP_INI_END()
*/
/* }}} */
 
/* {{{ php_mg_teste_init_globals
 */
/* Uncomment this function if you have INI entries
static void php_mg_teste_init_globals(zend_mg_teste_globals *mg_teste_globals)
{
	mg_teste_globals->global_value = 0;
	mg_teste_globals->global_string = NULL;
}
*/
/* }}} */
 
/* {{{ PHP_MINIT_FUNCTION
 */
PHP_MINIT_FUNCTION(mg_teste)
{
	/* If you have INI entries, uncomment these lines
	REGISTER_INI_ENTRIES();
	*/
	return SUCCESS;
}
/* }}} */
 
/* {{{ PHP_MSHUTDOWN_FUNCTION
 */
PHP_MSHUTDOWN_FUNCTION(mg_teste)
{
	/* uncomment this line if you have INI entries
	UNREGISTER_INI_ENTRIES();
	*/
	return SUCCESS;
}
/* }}} */
 
/* Remove if there's nothing to do at request start */
/* {{{ PHP_RINIT_FUNCTION
 */
PHP_RINIT_FUNCTION(mg_teste)
{
	return SUCCESS;
}
/* }}} */
 
/* Remove if there's nothing to do at request end */
/* {{{ PHP_RSHUTDOWN_FUNCTION
 */
PHP_RSHUTDOWN_FUNCTION(mg_teste)
{
	return SUCCESS;
}
/* }}} */
 
/* {{{ PHP_MINFO_FUNCTION
 */
PHP_MINFO_FUNCTION(mg_teste)
{
	php_info_print_table_start();
	php_info_print_table_header(2, "mg_teste support", "enabled");
	php_info_print_table_end();
 
	/* Remove comments if you have entries in php.ini
	DISPLAY_INI_ENTRIES();
	*/
}
/* }}} */
 
/* Remove the following function when you have succesfully modified config.m4
   so that your module can be compiled into PHP, it exists only for testing
   purposes. */
 
/* Every user-visible function in PHP should document itself in the source */
/* {{{ proto string confirm_mg_teste_compiled(string arg)
   Return a string to confirm that the module is compiled in */
PHP_FUNCTION(confirm_mg_teste_compiled)
{
	char *arg = NULL;
	int arg_len, len;
	char *strg;
 
	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arg_len) == FAILURE) {
		return;
	}
 
	len = spprintf(&strg, 0, "Congratulations! You have successfully modified ext/%.78s/config.m4. Module %.78s is now compiled into PHP.", "mg_teste", arg);
	RETURN_STRINGL(strg, len, 0);
}
/* }}} */
/* The previous line is meant for vim and emacs, so it can correctly fold and
   unfold functions in source code. See the corresponding marks just before
   function definition, where the functions purpose is also documented. Please
   follow this convention for the convenience of others editing your code.
*/
 
/* {{{ proto string hello_world(string name)
    */
PHP_FUNCTION(hello_world)
{
	char *name = NULL;
	int argc = ZEND_NUM_ARGS();
	int name_len = 0;
 
	if (zend_parse_parameters(argc TSRMLS_CC, "s", &name, &name_len) == FAILURE)
	{
		return;
	}
 
	RETURN_STRING(name, 1);
}
/* }}} */
 
/*
 * Local variables:
 * tab-width: 4
 * c-basic-offset: 4
 * End:
 * vim600: noet sw=4 ts=4 fdm=marker
 * vim<600: noet sw=4 ts=4
 */

Vc deverá editar a função PHP_FUNCTION(hello_world) localizada na linha 176

Agora é só brincar...
Todo esse código foi gerado automaticamente pelo ext_skel e para entende-lo precisaremos entender as macros que já foram criadas pelo pessoal do php.

Verifique agora que sua extensão aparece no php.ini digitando /home/mathias/php-5.2.8/sapi/cli/php -r 'phpinfo();' |grep -i mg_teste .

Para baixar os arquivo utilizados clique aqui!
Descompatece os arquivos dentro da pasta ext.

Agradeço a presença de todos e voltem sempre!

Alguns php template engines existentes são: Smarty, Integrated Template, PHPTAL, Savant, Sigma, TinyButStrong e vlibTemplate

Bom, na verdade os único que utilizei foi o smarty, os demais foram retirados do livro PHP PROFISSIONAL.
Desenvolvi então um template engine didático =) apenas para terem idéia do que se passa por dentro de um template engine.
Basicamente o que acontece é uma substituição de variaveis.
Meu template engine só faz 2 coisas, registra variáveis e controla labels de internacionalização.
Vou chamar meu template engine de TE de agora em diante, para facilitar. o TE tem apenas uma classe TemplateEngine.
Teremos 1 página, com labels em 2 idiomas pt_BR e en_US. Para isso teremos um arquivo chamado teste.php que será o controlador.Nela instanciaremos a classe
TemplateEngine e definiremos as variaveis.Teremos o arquivo do template e os 2 arquivos de internacionalização

Segue Abaixo o código do controlador:

<?php
	include_once 'TemplateEngine.php';
 
	//pt_BR
	$obTE = new TemplateEngine(TemplateEngine::pt_BR);
	$obTE->assign('name'	,'Mathias Grimm');
	$obTE->assign('site'	,'http://mathiasgrimm.com.br');
	$obTE->assign('comment'	,'Hello World!');
	echo $obTE->fetch('index');
 
	//en_US
	$obTE = new TemplateEngine(TemplateEngine::en_US);
	$obTE->assign('name'	,'Mathias Grimm');
	$obTE->assign('site'	,'http://mathiasgrimm.com.br');
	$obTE->assign('comment'	,'Hello World!');
	echo $obTE->fetch('index');
?>

Agora vou tentar explicar um pouco.
Linha 2:Temos o include do TE,após isso,na linha 5 instanciamos o TE, que recebe como argumento o idioma que será utilizado.
Nesse caso o código escrito está primeiramente em pt_BR e em seguida em en_US, justamente para demonstrar a funcionalidade da internacionalização.
Os idiomas disponíveis estão definidos como constantes da classe TemplateEngine.
Linha 6:Estamos criando uma variavel 'nome', que estará disponível no template
Linha 9:É onde falamos ao TE para compilar o template (na verdade,no TE, essa compilacao acontece em tempo de execução). index é o nome do template
que será buscado pelo compilador.

Agora mostrarei o template (HTML) e explicarei logo abaixo:

{config}index{/config}
 
{#name}: {$name}
 
{#site}: {$site}
 
{#comment}: {$comment}
 

Linha 1: Entre as tags {config} e {/config} temos definido quem é arquivo de internacionalizacao dos labels
Linha 3: Temos a tag {#name} que será buscada no arquivo de internacionalização do idioma que está definido no momento.
Linha 3: temos a tag {$name} que conterá o valor que foi definido na linha 6 do controlador

Agora os arquivos de internacionalização:

pt_BR :

 name 	 = Nome
 site	 = Site
 comment = Comentário

en_US:

 name	 = Name
 site	 = Site
 comment = Comment

Os arquivos de internacionalização são arquivos .ini .
O que está ao lado esquerdo do operador "=" é o nome do label, disponível no template como {#name} e o valor
a direita é o valor que será utilizado na compilação do template, assim como foi definido na linha 3 do template.

Segue agora o código do TE:

<?php
class TemplateEngine
{
	const pt_BR = 'pt_BR';
	const en_US = 'en_US';
 
	function __construct($lang)
	{
		$this->lang = $lang;
	}
 
	private $arVars = array();
	private $lang;
 
	function fetch($path)
	{
		$fp 	 = fopen($path.'.phpte','r');
		$content = fread($fp,filesize($path.'.phpte'));
 
		$this->fetchVars($content);
		$this->fetchLabels($content);
 
		return $content;
	}
 
	function assign($name,$var)
	{
		$this->arVars[$name]=$var;
	}
 
	function fetchVars(&$content)
	{
		$pattern 		= '/\{\$.{1,}\}/';
		preg_match_all($pattern,$content,$arVars);
 
		foreach($arVars[0] as $var)
		{
			$curVal 	= str_replace(array('{','}','$'),'',$var);
			$newVal 	= $this->arVars[$curVal];
			$content	= str_replace($var,$newVal,$content);
		}
	}
 
	function fetchLabels(&$content)
	{
		$pattern 		= '/\{config\}.{1,}\{\/config\}/';
 
		preg_match($pattern,$content,$arVars);
 
		$content = str_replace($arVars,'',$content);
 
		foreach($arVars as $var)
		{
			$curVal 	= str_replace(array('{config}','{/config}'),'',$var);
 
			$path 		= "lang/{$this->lang}/".$curVal.".cfgte";
			$arLabels 	= parse_ini_file($path);
			$pattern 	= '/\{\#.{1,}\}/';
			preg_match_all($pattern,$content,$internalArVars);
 
			foreach($internalArVars[0] as $var)
			{
				$curVal 	= str_replace(array('{','}','#'),'',$var);
				$newVal 	= $arLabels[$curVal];
				$content	= str_replace($var,$newVal,$content);
			}
		}
	}
}
?>

Linha 4 e 5 : Definição das constantes de internacionalização. O valor definido para essas constantes será utilizado como o caminho da pasta
de internacionalização atual
Linha 7 a 10: O construtor recebe o valor do idioma, definido nas linhas 5 e 12 do controlador
Linha 15: Onde tudo começa. Esse método é responsável por compilar o template
Após a linha 15 temos a chamada aos métodos de compilacao de variaveis e labels. Caso eu realmente fosse fazer um template engine, seria ai onde colocaria
novas funcionalidades.
Linha 26: Método assign, ele é que registra uma variável, e armazena o valor dela dentro do array arVars, definido na linha 12.
Linha 31: Método que realiza a compilação (substituição de tags por variáveis). Ele tenta encontrar tags no formato {$}, ou seja, encontra as tags
{$name},{$site} e {$comment} que foram definidas no template e substitui pelos valores registrados dentro do controlador.
Como esse artigo é apenas didático (apesar de não ser uma didática muito boa =) ), utilizei uma maneira de substituir as váriaveis de forma que ficasse tudo ok,
sem me preocupar com desempenho. Utilizei uma combinação de expressão regular com str_replace.
Linha 44: Método responsável pela substiuição dos labels, registrados nos arquivos de internacionalização.
Linha 46: Pesquiso pela tag {config}{/config} para pegar o nome do arquivo de internacionalização que foi definido na linha 1 do template.
Linha 56: Defino o caminho do arquivo de internacionalização no formato lang/idioma/nome do arquivo de internacionalização,que no caso é index.
Por convenção o arquivo de internacionalização deve ter extensão .cfgte .
Linha 59: Parse do arquivo ini.
Linha 61: Dessa linha em diante ocorre a substituição de tags {#} assim como no método de substituição de variaveis, nesse caso serão encontradas
as tags {#name},{#site} e {#comment} que serão substituidas pelos valores registrados dentro dos arquivos de internacionalização.

Dessa forma o TE substitui as variaveis e labels e retorna o conteudo do arquivo de template para o controlador.

O resultado produzido pela execução do controlador será:

Nome: Mathias Grimm

Site: http://mathiasgrimm.com.br

Comentário: Hello World!

Name: Mathias Grimm

Site: http://mathiasgrimm.com.br

Comment: Hello World!

Dessa maneira temos um template engine funcionando...
Um verdadeiro template engine permite muitas outras funcionalidades disponíveis dentro do template. Mas a idéia é essa.
Substituição de código (tags) por valores .
Fica muito mais simples qualquer um dar manutenção no código do template, sem aquele código macarrão php e html.
Dessa forma poderia ser implemento um template engine para outras linguagens também, e utilizar o mesmo template fazendo uma abstração total da camada
de visualização.

Obrigado a todos,voltem sempre!

Para baixar os arquivos utilizados nesse artigo clique AQUI

Nesse artigo pretendo demonstrar um programa de conversão de csv para xml, escrito nas linguagens C++,PHP,PYTHON,PERL e SHELL SCRIPT. O Comparativo é basicamente em relação ao desempenho e a quantidade de linhas de código.

A idéia surgiu pois outro dia fui contratado (freela) pra fazer esse conversor, para um colega. Fiz inicialmente em Shell Script, pois foi a linguagem solicitada por esse colega, e o arquivo csv original tinha mais ou menos 2500 linhas, o que fica rápido em qualquer umas das linguagens que testei. Algum tempo depois resolvi fazer em python e depois pensei em fazer esse comparativo, pois a diferença foi brutal entre python e shell script.

O TESTE:

Tentei utilizar elementos comuns a todas linguagens, mas nem tudo ficou igual.
Já queria agradecer ao meu amigo e colega de trabalho, Vasco , que desenvolveu o código em C++.

Para calcular o tempo de execução utilizei o time, comando disponível para linux, que mede o tempo de execução de programas, desde o tempo de ativação até o fim de sua execução. Executei cada programa 5 vezes para obter o tempo médio de execução.

Nos testes utilizei um arquivo csv com 100000 linhas (cem mil linhas)

Segue abaixo o código dos programas.

C++:

#include <iostream>
#include <sstream>
#include <string>
#include <time.h>
#include <iomanip>
 
using namespace std;
 
FILE * fp;
int i;
string fields[9];
 
string intToStr(int number)
{
	std::stringstream ss;
	std::string str;
	ss << number;
	ss >> str;
	return ss.str();
}
 
void init()
{
    fp = fopen("xml_from_c_plus_plus.xml", "w");
    i = 1;
}
 
void _end()
{
    fclose(fp);
}
 
void parseString(string line)
{
    int f   = 0;
    int pos = 0;
    size_t found;
 
    found=0;
    while(found != string::npos)
    {
    	found       = line.find("," , pos);
    	fields[f++] = line.substr(pos, found - pos);
    	pos         = found+1;
    }
}
 
void xmlHeader()
{
    string xmlString;
    xmlString = "\n
\n";
    fputs(xmlString.c_str(), fp);
}
 
void xmlFooter()
{
    string xmlString;
    xmlString = "";
    fputs(xmlString.c_str(), fp);
}
 
void xmlBody()
{
    string xmlString;
 
    xmlString.append("\n");
    xmlString.append("");
    xmlString.append(fields[1]);
    xmlString.append("\n");
    xmlString.append("");
    xmlString.append(fields[0]);
    xmlString.append("\n");
    xmlString.append("");
    xmlString.append(fields[3]);
    xmlString.append("\n");
    xmlString.append("");
    xmlString.append(fields[5]);
    xmlString.append("\n");
    xmlString.append("
");
    xmlString.append("");
    xmlString.append(fields[4]);
    xmlString.append("\n");
    xmlString.append("\n");
    xmlString.append("\n");
    fputs(xmlString.c_str(), fp);
 
    i++;
}
 
void csv2xml()
{
    xmlHeader();
    FILE * fpo;
    char buffer[1024];
 
    fpo = fopen("mathiasgrimm.csv", "r");
 
    while(fgets(buffer, sizeof(buffer), fpo) != 0)
    {
	parseString(buffer);
	xmlBody();
    }
 
    xmlFooter();
    fclose(fpo);
}
 
int main( int argc, char ** argv )
{
    init();
    csv2xml();
    _end();
}

PYTHON:

def init():
    global i
    global f
    f=open("xml_from_python.xml","w")
    i=1
 
def end():
    f.close()
 
def parseString(string):
    return string.split(",")
 
def xmlHeader():
    global f
 
    xmlString = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n
<prematricula centro=\"224\">\n"
    f.write(xmlString)
 
def xmlFooter():
    global f
 
    xmlString = "</prematricula>"
    f.write(xmlString)
 
def xmlBody(fields):
    global i
    global f
 
    alumnoOpenNode    = "%s%s%s"%("    <alumno id=\"ave_" ,i         ,"\">\n"        )
    nombreNode        = "%s%s%s"%("        <nombre>"      ,fields[1],"</nombre\n"   )
    apelidoNode       = "%s%s%s"%("        <apelido>"     ,fields[0],"</apelido>\n" )
    emailNode         = "%s%s%s"%("        <email>"       ,fields[3],"</email>\n"   )
    sexoNode          = "%s%s%s"%("        <sexo>"        ,fields[5],"</sexo>\n"    )
    licenciaOpenNode  = "
<licencia>\n"
    grupoNode         = "%s%s%s"%("            <grupo>"   ,fields[4],"</grupo>\n"   )
    licenciaCloseNode = "        </licencia>\n"
    alumnoClseNode    = "    </alumno>\n"
 
    xmlString ="%s%s%s%s%s%s%s%s%s"%(alumnoOpenNode,nombreNode,apelidoNode,emailNode,sexoNode,licenciaOpenNode,grupoNode,licenciaCloseNode,alumnoClseNode)
    f.write(xmlString);
    i+=1
 
def csv2xml():
    xmlHeader()
 
    for line in open('mathiasgrimm.csv').xreadlines():
           fields = parseString(line)
           xmlBody(fields)
 
    xmlFooter()
 
init()
csv2xml()
end()

PERL:

sub init
{
    $i=1;
    open(f,">xml_from_perl.xml");
}
 
sub end
{
    close(f);
}
 
sub parseString
{
    local($string) = @_;
    return split(/\,/,$string);
}
 
sub xmlHeader
{
    local($xmlString) = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n
<prematricula centro=\"224\">\n";
    print f $xmlString;
}
 
sub xmlFooter
{
    local($xmlString) = "</prematricula>";
    print f $xmlString;
}
 
sub xmlBody
{
    local(@fields) = @_;
 
    $alumnoOpenNode    = sprintf("%s%s%s","    <alumno id=\"ave_" ,$i         ,"\">\n"        );
    $nombreNode        = sprintf("%s%s%s","        <nombre>"      ,@fields[1],"</nombre>\n"   );
    $apelidoNode       = sprintf("%s%s%s","        <apelido>"     ,@fields[0],"</apelido>\n" );
    $emailNode         = sprintf("%s%s%s","        <email>"       ,@fields[3],"</email>\n"   );
    $sexoNode          = sprintf("%s%s%s","        <sexo>"        ,@fields[5] ,"</sexo>\n"    );
    $licenciaOpenNode  = "
<licencia>\n";
    $grupoNode         = sprintf("%s%s%s","            <grupo>"   ,@fields[4] ,"</grupo>\n"   );
    $licenciaCloseNode = "        </licencia>\n";
    $alumnoClseNode    = "    </alumno>\n";
 
    $xmlString =sprintf("%s%s%s%s%s%s%s%s%s",$alumnoOpenNode,$nombreNode,$apelidoNode,$emailNode,$sexoNode,$licenciaOpenNode,$grupoNode,$licenciaCloseNode,$alumnoClseNode);
    print f $xmlString;
    $i++;
}
 
sub csv2xml
{
    xmlHeader();
    open(csv,"
<mathiasgrimm.csv");
 
    while ( ($linha = <csv>) )
    {
        local(@fields) = parseString($linha);
        xmlBody(@fields);
    }
 
    close(csv);
 
    xmlFooter();
}
 
init();
csv2xml();
end();

PHP-CLI:

 
<?php
function init()
{
    global $i;
    global $f;
    $f=fopen("xml_from_php.xml","w");
    $i=1;
}
 
function _end()
{
    global $f;
    fclose($f);
}
 
function parseString($string)
{
    return explode(",",$string);
}
 
function xmlHeader()
{
    global $f;
 
    $xmlString = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n
<prematricula centro=\"224\">\n";
    fwrite($f,$xmlString);
}
 
function xmlFooter()
{
    global $f;
 
    $xmlString = "</prematricula>";
    fwrite($f,$xmlString);
}
 
function xmlBody($fields)
{
    global $i;
    global $f;
 
    $alumnoOpenNode    = sprintf("%s%s%s","    <alumno id=\"ave_" ,$i         ,"\">\n"        );
    $nombreNode        = sprintf("%s%s%s","        <nombre>"      ,$fields[1] ,"</nombre\n"   );
    $apelidoNode       = sprintf("%s%s%s","        <apelido>"     ,$fields[0] ,"</apelido>\n" );
    $emailNode         = sprintf("%s%s%s","        <email>"       ,$fields[3] ,"</email>\n"   );
    $sexoNode          = sprintf("%s%s%s","        <sexo>"        ,$fields[5] ,"</sexo>\n"    );
    $licenciaOpenNode  = "
<licencia>\n";
    $grupoNode         = sprintf("%s%s%s","            <grupo>"   ,$fields[4] ,"</grupo>\n"   );
    $licenciaCloseNode = "        </licencia>\n";
    $alumnoClseNode    = "    </alumno>\n";
 
    $xmlString =sprintf("%s%s%s%s%s%s%s%s%s",$alumnoOpenNode,$nombreNode,$apelidoNode,$emailNode,$sexoNode,$licenciaOpenNode,$grupoNode,$licenciaCloseNode,$alumnoClseNode);
    fwrite($f,$xmlString);
    $i++;
}
 
function csv2xml()
{
    xmlHeader();
    $fp = fopen('mathiasgrimm.csv','r');
 
    while($linha = fgets($fp))
    {
    	$fields = parseString($linha);
        xmlBody($fields);
    }
 
    xmlFooter();
}
 
init();
csv2xml();
_end();
?>

SHELL SCRIPT:

#!/bin/bash
init()
{
    f='xml_from_shell.xml'
    i=1
}
 
parseString()
{
    fields[0]=`echo $linha|awk -F, '{ print $1 }'`
    fields[1]=`echo $linha|awk -F, '{ print $2 }'`
    fields[2]=`echo $linha|awk -F, '{ print $3 }'`
    fields[3]=`echo $linha|awk -F, '{ print $4 }'`
    fields[4]=`echo $linha|awk -F, '{ print $5 }'`
    fields[5]=`echo $linha|awk -F, '{ print $6 }'`
}
 
xmlHeader()
{
    echo "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"    > $f
    echo "
<prematricula centro=\"224\">"		>> $f
}
 
xmlFooter()
{
    xmlString="</prematricula>";
    echo $xmlString >> $f
}
 
xmlBody()
{
    echo "    <alumno id=\"ave_$id\">"			 >> $f
    echo "        <nombre>"${fields[1]}"</nombre>"	 >> $f
    echo "        <apellido1>"${fields[0]}"</apellido1>" >> $f
    echo "        <email>"${fields[3]}"</email>"         >> $f
    echo "        <sexo>"${fields[5]}"</sexo>"           >> $f
    echo "
<licencia>"                            >> $f
    echo "            <grupo>"${fields[4]}"</grupo>"     >> $f
    echo "        </licencia>"				 >> $f
    echo "    </alumno>"				 >> $f
 
    id=`expr $id + 1`
}
 
csv2xml()
{
   xmlHeader
 
   while read linhaAtual
   do
       linha=$linhaAtual
       parseString
       xmlBody
   done < 'mathiasgrimm.csv'
 
   xmlFooter
}
 
init
csv2xml

Bom... agora vou mostrar o tempo de execução de cada linguagem.

C++:

PYTHON:

PERL:

PHP-CLI:

SHELL SCRIPT:

Tempo de execução muito alto. Não foi possivel esperar o tempo necessário ao processamento de todo arquivo.
Realizei uma medição proporcional, deixei o script rodar por 2 minutos e utilizei o total de linhas processadas para esse cálculo.

CONCLUSÃO:

C++ foi o mais rápido, SHELL SCRIPT o mais lento

PYTHON foi o menor script em quantidade de linhas, C++ o maior

Perceba que python teve um diferença bem menor que as demais linguagens, e tem o código menor. Para esse conversor, especificamente, acredito que seria a melhor opção levando em conta a facilidade de escrever em python (o que pode variar de pessoa pra pessoa).

Mas essa avaliação deve ser feita individualmente para seu objetivo, ou seja, se seu objetivo é um código rápido, utilize c++, caso o objetivo seja escrever menos, independente da linguagem, utilize python.

O objetivo do artigo era mostrar algum comparativo entre as linguagens, mas isso poderia ser feito de muitas meneiras diferentes da utilizada no artigo.

Clique AQUI para baixar os arquivos utilizados nesse artigo.

Desculpe-me por algum equívoco ou falta de precisão.

Agradeço a visita de todos e voltem sempre!

Muitas pessoas não conhecem o poder do editor Vim, mais conhecido como Vi (pronuncia vi-ai), e estou aqui para mostrar como ele pode ser útil na sua vida.

Nesse artigo construí um plugin simples, que não faz abslolutamente nada de útil, mas é a base para um plugin mais complexo. Bom.. qual a necessidade de um plugin?!? R. Facilitar a vida de quem está utilizando o editor!

Exemplos de utilizacao poderia ser integracao com CVS, leitor de notícias, ou qualquer outra coisa que se pense... usem a criatividade.

Vamos ao que interessa...
Esse plugin foi desenvolvido para sistemas unix /unix-like
Entre no terminal , no seu home e crie a pasta plugin dentro da pasta .vim e crie um arquivo teste.vim, como na imagem abaixo.

Após isso insira um código dentro do arquivo, como na imagem abaixo

Isso fará com que o vim ecreva o texto entre aspas. Para isso, salve o arquivo e abra novamente o vim.
Observe que logo de cara a mensagem é exibida.

Mas nem sempre desejamos que uma ação seja executada automaticamente, para isso criaremos uma função que poderá ser chamada sempre que quisermos.

A linguagem que é utilizada para criar os plugins está documentada no help do vim, e define que uma função sempre deve começar com uma letra maiúscula.
Agora salve o arquivo e abra o vim novamente e digite ":call HelloWorld()" e aperte ENTER

call é utilizado para chamar qualquer funcão disponível no vim, e quando criamos um plugin a função passa a existir, podendo até ser chamada por outro plugin.
Veja o resultado da chamada da função.

Agora podemos perceber que o utilizar call sempre que quisermos chamar uma função pode tornar-se algo chato, para isso criaremos um atalho, ou melhor, criaremos uma comando do vim, que chamará internamente a função que criamos.

agora basta chamar utilizando ":HelloWorld()" em vez de utilizar call HelloWorld().

Também utilizamos esses comandos para poder passar argumentos as funções.
Criaremos um argumento e imprimiremos seu valor

Esse foi um simples exemplo de criação de um plugin. Como já disse, utilize a criatividade.

Crie seu próprio player mp3, compilador personalizado,ftp ou qualquer que seja sua necessidade. Eu estou utilizando um pseudo-webservice em php integrado com um plugin do vim, que me proporciona integração com os arquivos em desenvolvimentos controlados pelo controle de versão, me proporcionando uma produtividade adicional.

Caso alguem tenha alguma crítica,dúvida ou sugestão, é só entrar em contato.
Pra variar escrevi o artigo correndo.. desculpem qualquer equívoco.

Abraço a todos e obrigado pela visita!

O funcionamento do programa é o seguinte: python pyresizer.py c:/pasta/das/fotos 640x480

Para que o python funcione corretamente no windows, você deve atualizar as variaveis de ambiente para que o comando python seja reconhecido em qualquer
diretório, digitando o seguinte comando no prompt de comando: set path=%path%;c:\Python25; .Assumindo que o diretório da instalação do python seja em c:/Python25.
Essas configurações só serão válidas para a sessão atual do prompt de comando.Existem maneiras de salvar essa configuração mas o foco do artigo não é esse.
Imagem 1:

Perceba que foi criado o diretório pyresizer dentro da pasta de fotos que foi informada, e dentro da pasta pyresizer foi criada a pasta 800x600 que é a pasta
que utilize no teste do programa.
Veja na images 2 que o aspecto das imagens foi mantido pois o programa identifica se as fotos estão com disposição paisagem ou retrato.
Imagem 2:

Segue abaixo o código do pyresizer.py

 
#author: Mathias Grimm - mathiasgrimm.com.br
#date: 24/08/2008
import Image #http://www.pythonware.com/products/pil/
import sys
import os
 
try:
	#path
	dir = sys.argv[1].replace('\\','/')
 
	if os.path.exists(dir):
		#dimension X x Y
		newXY		= sys.argv[2]
		newXY   	= newXY.lower().split('x')
		#integer is required for resize method
		newXY[0]	= int(newXY[0])
		newXY[1]	= int(newXY[1])
 
		#creating save path
		try:
			newDir = os.path.join(dir,'pyresizer')
			os.mkdir(newDir)
		except:
			print 'Can\'t create dir '+newDir
 
		#creating XxY path
		try:
			saveDir = os.path.join(newDir,sys.argv[2].lower())
			os.mkdir(saveDir)
		except:
			print 'Can\'t create dir ',saveDir
 
		if os.path.exists(saveDir):
			#path dictionary
			dcDir 		= os.listdir(dir)
 
			#files found
			total 		= len(dcDir)
 
			print 'Found %s file(s).'%(total)
 
			for file in dcDir:
				atual = os.path.join(dir,file)
				print file
 
				try:
					img = Image.open(atual)
 
					#getting current image size
					size = img.size
					x = size[0]
					y = size[1]
 
					#keeping aspect ratio
					if x > y:
						newX = newXY[0]
						newY = newXY[1]
					else:
						newX = newXY[1]
						newY = newXY[0]
 
					newImg = img.resize((newX,newY))
 
					#saving resized on currentpath/tmp
					currentSaveDir = os.path.join(saveDir,file)
					newImg.save(currentSaveDir)
 
				except:
					#not a image or don't have permission, for example...
					print 'Can\'t resize ',atual
			else:
				print
 
			print 'Files saved on '+saveDir
		else:
			print 'Can\'t create save path. Aborting...'
	else:
		print dir+' invalid dir! aborting...'
 
except IndexError:
	print 'Usage: python pyresizer.py path/to/resize/ NEWXxNEWY'
 

É isso...
clique aqui para baixar os arquivos utilizados nesse artigos.
Agradeço a visita de todos e voltem sempre!

É isso ai galera, mais um artigo rapidinho, e surgiu de uma necessidade minha também.
Tenho varios backups no computador e tem muito arquivo que está em mais de 1 backup.
Fiz um programinha que identifica todos arquivos duplicados a partir de um diretório, no meu caso só fiz para arquivos jpg,
mas pode ser facilmente trocado por qq outro tipo, ou simplesmente retirar o if para que todos arquivos sejam verificados.
Tive um problema com isso, pois tinha uma iso de 9gb e não consegui fazer funcionar, talvez seja pela falta de experiência em python.

O funcionamento é o seguinte:
1 - Uma função recursiva que varre todos diretorios e arquivos a partir do caminho informado.
2 - Um dicionario (array para os programadores php) que contém uma lista (outro array, não associativo) que tem o índice igual ao md5 do arquivo, e a lista com os valores dos caminhos dos arquivos iguais.
3 - Imprimo somente as listas nas quais possuem mais de 1 arquivo.

Veja na imagem 1 que estou na pasta /home/mathias/py e o único arquivo que existe é o diff.py
imagem 1:

Agora vou criar 2 arquivos .jpg vazios
Imagem 2:

Agora com o comando python2.5 diff.py '/home/mathias/py' eu executo o programa. caso o python2.5 não existe pode utilizar o python.
/home/mathias/py é o diretório no qual vou fazer a pesquisa, coloque o diretório que desejar.
Veja que são mostrados os 2 arquivos que são idênticos em seu conteúdo mas tem nomes diferentes.
Imagem 3:

Aqui desviei a saída para um arquivo txt pois existiam muitos arquivos ,e só vou conferir outro dia,assim deixo guardado o arquivo.
Esse comando cat mostra o conteúdo do arquivo log.txt, é um comando do linux mesmo. O arquivo poderia ser aberto em qualquer editor de texto.
Imagem 4:

Nessa próxima imagem crio outros 2 arquivos e coloco o texto 'qqcoisa' dentro deles e em seguida rodo o diff.py novamente.
Perceba que os arquivos iguais ficam agrupados mostrando o caminho completo.
Imagem 5:

Segue a abaixo o código python (ou gathon) :

 
import os
import md5
import sys
 
global arEstrutura
 
path           = sys.argv[1]
arEstrutura    = {}
arDuplicados   = {}
 
def lerEstrutura(dir):
    if os.path.isdir(dir):
        dirAtual = os.listdir(dir)
 
        for item in dirAtual:
            atual=os.path.join(dir,item)
            if os.access(atual,os.R_OK):
                if (os.path.isfile(atual)):
                    if os.path.splitext(atual.lower())[1] == '.jpg':
                        global arEstrutura
                        f 	    = open(atual,'r')
                        dump        = f.read()
                        m           = md5.new(dump)
                        f.close()
 
                        try:
                            arEstrutura[m.digest()].append(atual)
                        except KeyError:
                            arEstrutura[m.digest()]=[atual]
                else:
                    lerEstrutura(atual)
            else:
                print "You don't have permission:  "+atual
    else:
        print "Not dir: "+dir
 
def compararEstrutura():
    global arEstrutura
 
    for md5 in arEstrutura:
        try:
            if arEstrutura[md5][1]:
                for duplicado in arEstrutura[md5]:
                    global arDuplicados
                    try:
                        arDuplicados[md5].append(duplicado)
                    except KeyError:
                        arDuplicados[md5]=[duplicado]
 
        except IndexError:
            pass
 
lerEstrutura(path)
compararEstrutura()
 
for arquivos in arDuplicados:
    print '----------------------------------'
 
    for duplicado in arDuplicados[arquivos]:
        print duplicado
 
    print '----------------------------------'
 

Clique aqui para baixar o script e as imagens utilizadas nesse post

Agradeço a presença de todos e voltem sempre!
Abraço!

Tenho um arquivo csv com um milhão de linhas e preciso inserir todas linhas no banco de dados.
Poderia fazer isso de 2 formas: COPY do postgresql ou criando um script (php por exemplo) e ler o arquivo gerando um comando insert para cada linha. No script php temos como inserir os registros usando uma query passando o insert como argumento ou também podemos usar prepared statements (querys preparadas). Fiz alguns testes aqui com um arquivo de 100 mil linhas e o php estava demorando cerca de 1:20 ( um minuto e vinte segundos) com ligeira melhora de perfomance quando usado com prepare statements. Achei muito demorado e então fui dar uma lida na documentação do postgresql. Cheguei a fazer uma pgplsql que abria o arquivo e tal, mas a manipulação não tava muito fácil. Foi então que vi o quanto a função COPY do postgresql é útil e eficiente. Esse mesmo arquivo de 100 mil linhas foi importado em 12 segundos, ou seja, 1000% mais rápido, ou 10 vezes mais rápido!!! impressionante! Quando executei o comando para o arquivo de 1 milhão de linhas é que fiquei mais surpreso ainda... “Query returned successfully with no result in 26597 ms.” ou seja 26,5 segundos... para 1 milhão de linhas, lembrando que o script php inseriu 100 mil linhas em 1:20 s (um minuto e vinte segundos).
Algo a se considerar é o fato de que para validar os dados utilizando o metodo COPY é necessário criar uma trigger.. enquanto no php, no scrip mesmo você pode validar mais facilmente.

Na verda percebi uma coisa agora enquanto revisava o artigo. O comando de insert do php era gerado na hora, ou seja, nem dava um fopen no arquivo nem nada... o que com certeza
deixaria MUITO mais lento o script php.

Bom... o comando copy é simples:
COPY usuario FROM '/var/lib/postgresql/8.2/main/mathias.csv' WITH DELIMITER ',' .

usuario é a tabela na qual vou inserir os dados
/var/lib/postgresql/8.2/main/mathias.csv é o caminho do meu arquivo
WITH DELIMITER ',' especifica que o delimitador do arquivo é a vírgula. Poderia ter sido usado | (pipe) ou algum outro como ; (ponto e vírgula).

Esse comando COPY pode ser executado no pgadmin3 (meu caso) ou (eu acho, não testei) ser executado via query,psql, phppgadmin e por aí vai...

segue abaixo os códigos php que utilizei para gerar o arquivo csv de teste e os dois scripts para inserir, caso alguem queira testar.

1. Script que gera o csv com 1 milao de linhas.

<?php
	for($i=1;$i<=1000000;$i++)
	{
		file_put_contents
                (
                    '/var/lib/postgresql/8.2/main/mathias.csv',
                    "$i,mathiasgrimm,a@b.c,c4ca4238a0b923820dcc509a6f75849b\n",
                    FILE_APPEND
               );
	}
?>

2.Script de insert com Prepared Statement

<?php
	$con = pg_connect
                    (
                        "
                            host=localhost
                            port=5432
                            dbname=mathiasgrimm.com.br
                            user=postgres
                            password=postgres
                       "
                   );
	$result = pg_prepare
                        (
                            $con,
                            "my_query",
                            'INSERT INTO USUARIO (NM_USUARIO,TE_EMAIL,TE_PASSWORD) VALUES($1,$2,$3)'
                        );
 
	for($i=1;$i<=1000000;$i++)
	{
		$result = pg_execute
                                (
                                    $con,
                                    "my_query",
                                    array
                                    (
                                        "mathiasgrimm",
                                        "a@b.c",
                                       "c4ca4238a0b923820dcc509a6f75849b"
                                   )
                               );
	}
?>

3.Script de insert com query simples

<?php
	$con = pg_connect
                    (
                        "
                            host=localhost
                            port=5432
                            dbname=mathiasgrimm.com.br
                            user=postgres
                            password=postgres
                       "
                    );
 
	for($i=0;$i<1000000;$i++)
	{
		$result = pg_query
                                (
                                    $con ,
                                    'INSERT INTO
                                         USUARIO
                                         (
                                             NM_USUARIO,
                                             TE_EMAIL,
                                             TE_PASSWORD
                                         )
                                         VALUES
                                         (
                                             \'mathiasgrimm\',
                                             \'a@b.c\',\'c4ca4238a0b923820dcc509a6f75849b\'
                                          )'
                                );
	}
?>

Obs.: Os testes que fiz utilizei o php-cli ("php -f insert.php" e php -f insertps.php"), e não via browser.

A intensão do artigo não é mostrar se insert com prepared statement é mais rápida do que utilizando query, mas talvez seja um tema interessante para ser escrito em outro artigo.

Como sempre meus artigos são feitos meio na correria, desculpem alguma besteira que possa ter falado, e se possível contribuam com idéias para que eu possa estar escrevendo com mais frequencia.

Como de costume, clique aqui para baixar os arquivos utilizados.

Obrigado a todos e voltem sempre!

Como o script anterior, também não testei muito bem, mas o que testei funcionou! =) Comecei tentando usar o mod_rewrite do apache, até fiz umas bobeirinhas mas no final das contas não estava conseguindo passar variáveis para o .htaccess, tentei usar o apache_setvar() e dentro do .htaccess não consegui recuperar as variáveis %{ENV:variavel} que estava definindo no php... talvez alguém até possa me ajudar... mas no final da contas a implemetação toda em php ficou mais flexível e didática.

Bom, vamos começar a ir em direção do que interessa!
A ídeia foi criar um índice dentro da $_SESSION para cada aba,e consegui isso formatando TODOS os links do sistema. Criei uma classe utilitária para auxiliar de forma muito simples essa formatação. A classe nada mais faz do que concatenar um id único
( mktime() ) com o link e transitar ele de página em página. Essa concatenação só acontece quando não existe o id ainda no link. Dessa forma existe a possibilidade de você ter duas abas com a mesma sessão e uma com outra... ou quantas você quiser...
O que vai definir a que sessão a aba pertence é o id da sessao que está na URL

O Artigo contém 3 arquivos (duas classes e a index) e agora vou dar uma passada rápida por cada um deles

1. index.php

<?php
	error_reporting(E_ALL);
 
	session_start();
 
	include_once("LinkHelper.php");
	include_once("SessionHelper.php");
?>
<form method=post action = '<?php
					$link = "?p=index&a=login";
					$flink = LinkHelper::formatLink($link);
					echo $flink;
				?>'
 
>
	User:
<input type=text name=user>
	Password:
<input type=password name=pass>
<input type=submit value='Log me in!'>
</form>
 
<?php
	if(isset($_GET['sid']) && $_GET['sid'])
	{
		$sid = $_GET['sid'];
		$obSessionHelper = new SessionHelper($sid);
 
		$someVar = $obSessionHelper->getValue('dummy');
		$someVar+=1;
 
		$obSessionHelper->setValue('dummy',$someVar);
 
		if(isset($_POST['user']) && $_POST['user'])
		{
			$obSessionHelper->setValue('user',$_POST['user']);
		}
 
		if(!$obSessionHelper->getValue('loginTime'))
		{
			$obSessionHelper->setValue('loginTime',date('d-m-Y h:i:s'));
		}
 
		$obSessionHelper->dump();
	}
?>

A index possui um formulário de login (não exatamente!!!) e após fazer o login é possível ver algo acontecendo! Após efetuar o login faça alguns testes... clique na barra de endereço, de um ENTER e depois dê alguns reloads e veja o comportamento das variáveis de sessão. Abra uma outra aba e faça um novo login,perceba que cada login está com valores diferentes registrados em sessão.

2. SessionHelper.php

 <?php
//class to handle session
class SessionHelper
{
	private $sid;
 
	function __construct($sid)
	{
		$this->sid = $sid;
		if(!isset($_SESSION[$sid]