# -*- coding: utf-8 -*-
from urllib import urlencode
import httplib
import sys

api_url="u.nu"
var = urlencode({'url':sys.argv[1]})
args = "/unu-api-simple?%s" % (var)
conn = httplib.HTTPConnection(api_url)
conn.request("GET",args)
ret = conn.getresponse()
print ret.read()

Download the script here.

Just run passing the URL, for example:

$ python u.py www.coding.com.br

http://u.nu/72mpd

Easy your life by putting the script on your $PATH and execution (+x) file mode. Worth check the API from other services:

• bit.ly
• migre.me (brazilian company)
• is.gd
• tiny.cc
• tinyurl

]]> http://www.coding.com.br/blog/shortening-url/feed/ 0 http://www.coding.com.br/blog/a-brief-on-designated-initializers/ http://www.coding.com.br/blog/a-brief-on-designated-initializers/#comments Tue, 13 Jul 2010 06:01:27 +0000 Tiago Maluta http://www.coding.com.br/?p=1155 The GNU Compiler Collection (GCC) for C language doesn’t initialize variables zeroed. For simple variables types like int or float is just equal to 0 or 0.0 respectively. Now, suppose that you have a “large” struct and doesn’t want to set each member  individually… you could just type “={0}” which means that the first member is explicitly initialized to zero and the remaining members are implicitly initialized, also zero. Let’s see an example:

typedef struct
{
int a;
char c;
char s[10];
int *ptr;
} data;

When you initialize with:

data d;

You got some random value like:

{a = -1208298748, c = -12 ‘\364′, s = “\317\372\267\230\353\377\277\351\203\004″, ptr = 0xb7e94cc5}

When you type:

data d = {0};

You’ll have each struct member initialized to zero.

{a = 0, c = 0 ‘\000′, s = “\000\000\000\000\000\000\000\000\000″, ptr = 0×0}

You can learn much more about designated inits [section 6.26] on GCC docs.

Embed Python Inside Latex (pdf ~ 100KB)

Update: I also published online through Scribd, check here.

]]> http://www.coding.com.br/linux/embed-python-inside-latex/feed/ 0 http://www.coding.com.br/embarcado/opcode-stats/ http://www.coding.com.br/embarcado/opcode-stats/#comments Fri, 25 Jun 2010 00:09:50 +0000 Tiago Maluta http://www.coding.com.br/?p=1128 I was trying some GCC options and decided see how they affect assembly code generated. I’ve created a simple Python script that parses .s output and put in a human readable way. Suppose the classical Hello World program. The output will be something like:

$ python stats_opcodes.py file

For Cortex-m3 (check previous post):

At my laptop (x86):

Download the script here.

$ arm-none-eabi-gcc main.c -ggdb -mcpu=cortex-m3 -mthumb -T generic-m-hosted.ld
$ qemu-arm -cpu cortex-m3 ./a.out

You can download Code Sourcery toolchain here and QEmu here (also available from package management system of your favorite Linux distribution). Just unpack the toolchain associating the arm-201XqX/bin with your $PATH and run qemu.

I haven’t found the solution for my problem (for wordpress, drupal and joomla there are so many) so I resolved it and now I’m posting if somebody can’t do it or just wanna some copy/paste

1
2
3
4
5
6
7
8
9
10
11
12
13

 location ~ ^/wiki {
 	root /path/to/wiki;
 	index wikka.php;
 
 	if (!-e $request_filename) {
 		rewrite ^/wiki/images/(.*)$ /images/$1 break;
		rewrite ^/wiki/templates/(.*)$ /templates/$1 break;
 		rewrite ^/wiki/3rdparty/plugins/freemind/(.*)$ /3rdparty/plugins/freemind/$1 break;
 		rewrite ^/wiki/3rdparty/plugins/wikkaedit/(.*)$ /3rdparty/plugins/wikkaedit/$1 break;
 		rewrite ^/wiki/(.*)$ /wiki/wikka.php?wakka=$1 break;
 		break;
 	}
 }

A brief explanation:

on line 1 we setup where our wiki is located, on our case /wiki, so in line 2 we give full path to where the wiki’s file are located on the filesystem and line 3 we says our index will be wikka.php once Wikka Wiki just redirect index.php to wikka.php (ok I don’t mind why they don’t put the contents of wikka.php on index.php and its over ).

line 5-12 we configure the rewrite rules, on line 5 is the condition what to do when there is no file or symbolic link when a URL is acessed, if its matched the following rules are processed:
line 6-10: rules to ensure that static content like css, js and images won’t be redirected to wikka.php.
line 11: the main rule, that will redirect all URLs to wikka.php so it process and show the output for each wiki page.

I don’t why (I’m new to Nginx) even using the condition if(!-e $request_filename) I need to put the rules to ensure that static content will be reached, if I discover, I update this post, but these rules are working for me under Nginx 0.7.67 and Wikka 1.2-p1

• GPL - GNU Public License v2 or later
• GPL v2 - GNU Public License v2
• GPL and additional rights - GNU Public License v2 rights and more
• Dual BSD/GPL - GNU Public License v2  or BSD license choice
• Dual MIT/GPL - GNU Public License v2 or MIT license choice
• Dual MPL/GPL - GNU Public License v2 or Mozilla license choice

Como vocês podem notar, há componentes que podem ser definidos com licenças duplas, contudo quando executado no Linux apenas a GPL é relevante. Algumas razões para definir a licença:

1. O modinfo pode mostrar informações para usuários que desejam avaliar as licenças dos módulos sua instalação.
2. A comunidade pode ignorar relatórios de bugs dos módulos proprietários.
3. Os fabricantes podem fazer o mesmo com suas próprias políticas.

Para inserir a licença, basta colocar no seu código-fonte a macro  ”MODULE_LICENCE”. Exemplo:

  MODULE_LICENCE("GPL");

Lembre-se que alguns recursos do kernel são disponíveis apenas se seu código é livre.

Um exemplo é o sysfs (através da macro EXPORT_SYMBOL_GPL) que por questões de manutenção e consistência exige que você licencie seu módulo em alguma licença compatível com a GPL.

Root-NFS: Unable to get mountd port number from server, using default
Root-NFS: Server returned error -5 while mounting /my/nfs/server/path/
VFS: Unable to mount root fs via NFS, trying floppy.

The -5 and -13 are the most common on my daily usage, but I always forgot what this number means… So, I decided to get it from source by checking nfs-utils package. The following values where extracted  from utils/mount/error.c.

EPERM  ........................................ -1

ENOENT ........................................ -2

EIO ........................................... -3

ENXIO ......................................... -4

EACCESS ....................................... -5 

EEXIST ........................................ -6

ENODEV ........................................ -7

ENOTDIR ....................................... -8

EISDIR ........................................ -9

EINVAL ........................................ -10

EFBIG ......................................... -11

ENOSPC  ....................................... -12

EROFS ......................................... -13

ENAMETOOLONG .................................. -14

ENOTEMPTY ..................................... -15

EDQUOT ........................................ -16

ESTALE ........................................ -17

EWFLUSH ....................................... -18

Knowing what each error status means allow you quick fix the problems.

Veja um exemplo feito no AppleScript simples para mostrar a janela com as preferências de rede (System Preferences -> Network).

Nota: (1) se o você for testar e seu sistema estiver em Português, lembre-se de traduzir os nomes entre aspas.  (2) Para rodar os scripts é preciso marcar a opção Enable access for assistive Devices em System Preferences -> Universal Access

tell application "System Preferences"
	activate
	set current pane to pane "com.apple.preference.network"
end tell

Para desligar/ligar o AirPort:

tell application "System Events"
	tell process "System Preferences"
		tell window "Network"
			tell group 1
				if (exists button "Turn Airport Off") then
					click button "Turn AirPort Off"
					delay 3
				end if
				if (exists button "Turn Airport On") then
					click button "Turn AirPort On"
				end if
			end tell
		end tell
	end tell
end tell

Veja que é uma tradução em palavras (praticamente verbos no imperativo) do que seria o processo feito no modo gráfico. Se você programa em Python, existe um comparativo.

Ambientes livres

E é justamente com Python que vejo uma alternativa interessante para controlar as aplicações como o System Settings. Talvez o jeito mais fácil de fazer isso seria através de uma comunicação IPC como o D-BUS . Inclusive o system settings é exportado em org.kde.systemsettings.

$ qdbus org.kde.systemsettings

Resumindo, o acesso pode não ser tão fácil quanto no AppleScript mas o “meio” já existe em ambiente gráficos tal como KDE e  GNOME. O Python lida muito bem com este tipo de comunicação e é uma saída para quem está procurando um jeito para controlar seu ambiente de forma automatizada.

Futuro

Na minha opinião há uma deficiência para (A) pessoas leigas, se quiserem, controlar seus aplicativos de forma automatizada e (B) melhorar as formas de usabilidade nas interfaces já existentes.

Fico imaginando se não seria interessante um investimento (e pesquisa) para criar linguagens de programação que herdem construções da “fala” para acessar aplicativos, para no futuro utilizar da “voz” humana para controlar o computador.

O software livre é um terreno vasto para esse tipo de experiência. Cito algumas tecnologias que tornaria isso possível:

• D-bus para comunicação entre os aplicativos
• Python como linguagem de programação para construir as “amarras”
• NTLK (Natural Language Toolkit) para processar a linguagem

Se você trabalhar com algum tipo de pesquisa na área ou tem experiência, por favor, deixe um comentário.

Bom começo de semana a todos.

Em C++ há três maneiras de passar um parâmetro para uma função, as tradicionais herdadas da linguagem C: valor e ponteiro; além da novidade: a passagem por referência. Para ilustrar veja o seguinte exemplo, passar uma estrutura de dados “grande” (neste caso aproximadamente 10 kilobytes) para uma função:

#include<iostream>
#include <string.h>

using namespace std;

struct Big {
char text[10000];
int id;
};

void f1( Big v ) {
cout << v.text << endl;
cout << “Ox” << hex << v.id << endl;
}

void f2( const Big *v ) {
cout << v->text << endl;
cout << “Ox” << hex << v->id << endl;
}

void f3( const Big &v ) {
cout << v.text << endl;
cout << “Ox” << hex << v.id << endl;
}

int main(int /*argc*/, char * /*argv*/[]) {

Big *b0 = new Big;
Big b1;
Big &b2 = b1;

strcpy(b0->text,“asdfg asdfg asdf asdf asdf asdf”);
strcpy(b1.text,“azsxd azsxd azsxd azsxd azsxd azsxd”);

b0->id = 0xbc;
b1.id = 0xde;

f2( b0 ); /* pointer */
f1( b1 ); /* value */
f3( b2 ); /* reference */
}

Veja o código assembly gerado pelo compilador (g++) para cada um dos três casos:

1) Ponteiro

mov    -0xc(%ebp),%eax
mov    %eax,(%esp)
call   0x8048885

2) Valor

movl   $0x0,-0x2728(%ebp)
lea    -0x2720(%ebp),%eax
mov    %eax,-0x272c(%ebp)
jmp    0x8048a36
mov    -0x272c(%ebp),%ecx
mov    -0x2728(%ebp),%edx
movzbl (%ecx,%edx,1),%eax
mov    -0x2728(%ebp),%edx
mov    %al,(%esp,%edx,1)
addl   $0x1,-0x2728(%ebp)
cmpl   $0x2714,-0x2728(%ebp)
jb     0x8048a16
call   0x80488fe

3) Referência

mov    -0x8(%ebp),%eax
mov    %eax,(%esp)
call   0x804880c

Talvez seja importante:

• Se você prefere a sintaxe da intel? Mude no GDB: set disassembly-flavor intel
• Não precisa ser muito esperto para ver que a passagem por valor é a pior de todas, veja quanto código assembly foi gerado [#fail]
• A passagem por referência é inclusive mais eficiente pois aloca no %ebp (base pointer) [8 bytes ao invés de 12 bytes do ponteiro].
• A passagem por referência provê a eficiência da passagem por ponteiros com a clareza da passagem por valor.