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.
Just a small tip to test code generated for ARM Cortex-M3 using QEmu:
$ 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’m posting it here, because I started a few weeks ago working with Nginx (if you don’t know that, you really should), a very powerful and fast webserver (lets leave it for another post), but I faced a problem with redirects for Wikka Wiki, I’m not a beginner on regular expressions or mod_rewrite, but sometimes we get in trouble working on something new.
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
O arquivo /usr/src/linux/include/linux/module.h define as licenças aceitáveis para um módulo (ou driver) seja reconhecido como software livre.
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:
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.
If you use NFS to mount your root filesystem you should probably faced with this problem:
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.
Tudo começou numa tentativa que fiz para automatizar uma tarefa - reiniciar o AirPort no MacOSX - em 10 minutos no Google consegui as informações necessárias para fazer um script na linguagem AppleScript. Isso me fez pensar em algumas coisas sobre a interatividade que obtemos nos ambientes atuais e as possibilidades nos ambientes livres.
Veja um exemplo feito no AppleScript simples para mostrar a janela com as preferências de rede (System Preferences -> Network).
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:
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.
para não acontecer certos erros que vi por aí…
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:
Estou utilizando o Vim et all, para escrever o texto do meu trabalho de conclusão de curso (conhecido também como trabalho de diploma, td), são basicamente as ferramentas:
A norma (!) diz que as palavras estrangeiras devem ser escritas em itálico. Como é um texto técnico, há o uso frequente de palavras in english e o risco de deixar uma para trás é grande. Como a motivação para não escrever é maior, dispersei e acabei fazendo um programa que a partir de uma entrada (CSV) varre o texto e insere o itálico quando for necessário. O protótipo até agora esta assim:
O código ainda não está limpo para torná-lo acessível num repositório on-line. Além disso, acho que há outras maneiras mais eficazes: sed, python, etc. Como não sei quando vou ter tempo para torná-lo útil de verdade, vou colar aqui as duas partes do código que achei interessante.
A alteração no texto é simples: primeiro varremos o texto procurando pelo termo (*palavra é um iteraror da QStringList) e associamos um índice para cada ocorrência (indexOf) adicionando em uma lista (pos é um QList<int>). Antes de fazermos a troca (replace) comparamos com outra lista (blacklist) se essa inserção já não está dentro de um \textit. Se isso não acontecer, pode existir casos do tipo: \textit{\textit{itálico}}.
while ((i=s.indexOf(*palavra,i+1)) != -1) pos << i; for (index=0, offset=0; index < pos.length() ; index++) if (blacklist.contains(pos.at(index)) == false) { str = "\\textit{" + *palavra + "}"; s.replace(pos.at(index)+offset,(*palavra).length(),str); offset += 9; }
A construção da blacklist pode também ser aproveitada para evitar outros contextos, como notas de rodapé. Apenas trocar o \\textit pelo \\footnote.
while ((a=s.indexOf("\\textit{",b+1)) != -1) { b = s.indexOf("}",a); if ((c=s.indexOf(*palavra,a)) < b) blacklist << s.indexOf(*palavra,a); }
Conclusão: esse post nem era para existir, mas quem sabe eu não invento algum programa que escreva o texto sozinho 
Até mais!