{ Category Archives }

programming

Eterm com cores aleatorias

Ainda uso o Eterm.
Nao tem suporte a UTF-8, é velho, e tdo mais… mas ainda uso, junto com o e17.
costumo usa-lo com este scriptzinho, feito a muiiiito tempo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#!/usr/bin/perl
foreach $arg (@ARGV){
        $cmd_options="$cmd_options $arg";
}
 
$offset = 60;
$base = 80;
$limit = 400;
 
$red = int($base + rand($limit - $offset));
$green = int($base + rand($limit - $offset));
$blue = int($base + rand($limit - $offset));
 
$options = "--cmod-red $red --cmod-green $green --cmod-blue $blue";
 
exec ("Eterm $options $cmd_options");
#exec ("Eterm $options $cmd_options -T \"`fortune  -n50 -s`\"");

2008 05 07

Desktop
admin stuff
programming

Comments (0)

Permalink

cgo.py

Lembram-se do cgo.sh?
Agora existe o cgo.py.
Faz a mesma coisa… só que em python:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

#!/usr/bin/env python
# Copyright (C) 2008, Felippe Bueno <bueno>
# GNUv2 licence
# Enjoy
import sys,os
 
if len(sys.argv) &lt; 2:
    print "Use:     "+ sys.argv[0] +' server1 server2 server3... serverN'
    print "or:      "+ sys.argv[0] +' server* to use ~/.ssh/known_hosts'
    print "or:      "+ sys.argv[0] +' server 1 20 to use \'server\' as prefix, and increment from 1 to 20 (server1 server2 server3 ... server20)'
    sys.exit(1)   
 
def use_knownhosts(prefix):
    import string
    servers=""
    known_file=file(os.getenv('HOME')+'/.ssh/known_hosts','r')
    for line in known_file.readlines():
        hostname=string.split(line.split()[0], sep=',')[0]
        if prefix in hostname:
            servers=servers+' '+hostname
    args=servers.split()
    args.sort()
    cargs=""
    for s in args:
        cargs=cargs+' '+s
    return cargs
 
def use_prefixsequence(prefix,start,end):
    servers=""
    i=start
    while i &lt;= end:
        servers=servers+' '+prefix+str(i)
        i=int(i)+1
    return servers
 
if '*' in sys.argv[1]:
    import string
    os.system("cssh "+use_knownhosts(string.split(sys.argv[1],sep='*')[0]))
    sys.exit(0)
 
if len(sys.argv) == 2:
    servers=""
    i=1
    while i &lt; len(sys.argv):
        servers=servers+' '+sys.argv[i]
        i=i+1
    os.system("cssh "+servers)
    sys.exit(0)
 
try:
    int(sys.argv[2])
    int(sys.argv[3])
    os.system("cssh "+use_prefixsequence(sys.argv[1],int(sys.argv[2]),int(sys.argv[3])))
except ValueError:
    servers=""
    i=1
    while i &lt; len(sys.argv):
        servers=servers+' '+sys.argv[i]
        i=i+1
    os.system("cssh "+servers)
    sys.exit(0)</bueno>

2008 05 07

Desktop
Python
admin stuff
programming

Comments (0)

Permalink

Agora com Python

A mesma coisa do post anterior, porem usando python e dicionario.

Enviado por Alex:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#!/usr/bin/env python
 
import sys
 
def func1(arg):
    print 'here is func1: %s' % arg
 
def func2(arg):
    print 'here is func2: %s' % arg
 
funcptr = {
    'aa': func1,
    'bb': func2,
}
 
if __name__ == '__main__':
    try:
        funcptr[sys.argv[1]](sys.argv[2])
    except IndexError:
        print 'use: %s [%s] str' % (sys.argv[0], '|'.join(funcptr.keys()))

2008 03 26

Python
programming

Comments (0)

Permalink

Handler de funcoes em C

Qd se faz um programa que compara a entrada padrao (ou parte dela) com varios comandos/funcoes

é comum pensar primeiro em if e logo em seguida em case.

Mas isso alem de ser ‘feio’ e complicar a leitura/compreensao do codigo, torna dificil sua manutencao.

Para isso existe o conceito de handler de funcoes, onde se cria uma estrutura com 2 campos:

o nome da funcao que sera utilizado para fazer o match com o comando (o nome do comando deve ser o mesmo que o comando informado), e um campo void que é um ponteiro para a funcao propriamente dita:

1
2
3
4
5
6
7
8

typedef struct {
   char *name;
   void (*func)(char *what, char *which, int connfd);
} handler_t;
 
const handler_t handlers[] = {
       {"add","add"}, {NULL}
};

crei um estrutura (handler_t) com o campo ‘name’, e o campo ‘(*func)’ o
‘(char *what, char *which, int connfd);’ sao os argumentos da funcao, claro q vc deve alterar para as suas necessidades.
logo em seguida eu defini um vetor do tipo ‘handler_t’ (minha estrutura) que contem um unico comando dentro:
add. Neste caso coloquei o name com o mesmo nome da funcao, isso pq claro, a funcao tem nome ‘add’.
agora pra fazer o match eh o mais simples:

1
2
3
4
5

for(i=0; handlers[i].name != NULL; i++)
{
	if(strcmp(handlers[i].name, cline.cmd) &gt;= 0)
        	handlers[i].func(cline.what, cline.which);
}

Ou seja, ele cai na iteracao, e enquanto o campo ‘name’ nao for NULL, ele vai andando pelo vetor, e comparando o que encontra dentro do campo ‘name’ com o cline.cmd (outra estrutura que é alimentada por outra parte do codigo, mas imagine o seguinte: cline.cmd é o comando em questao, add, remove ou qq outro q vc configurou). qd o comando ‘add’ for encontrado ele vai executar a funcao com os argumentos (que foram tratados em outra parte do codigo).

Pronto, codigo limpo, economia de linhas, e facilimo para adcionar ou remover um ou outro comando/funcao. Basta editar o vetor handlers com o nome apropriado da funcao :) e claro certificarse que a funcao exista no codigo.

Thanks to Froz :)

2008 03 25

c
programming

Comments (1)

Permalink