Para sua utilidade ser máxima, as caixas de som devem ficar na frente da origem dos ruidos, por exemplo, na frente da janela. Quando isso não é possível, indica-se o uso de fones de ouvido.

Gerando ruído branco no Linux

Escutando enquanto é gerado

Antes, é necessário instalar um programa chamado sox. Ele é o responsável por fazer o ruído e depois por adicionar alguns efeitos para deixar o ruído mais “interessante”. Esses efeitos posteriores não são obrigatórios, mas ajudam a deixar o som mais suave.

Basicamente, o código é:

 sox -t sl -r 44100 -c 2 /dev/zero -t ossdsp /dev/dsp synth "1:00:00" brownnoise 

O "1:00:00" indica por quanto tempo o ruído será gerado, uma hora no caso. Além disso, no exemplo a cima foi usada a opção brownnoise que é similar ao ruído branco, mas mais agradável por ter menos agudos. Pode-se trocar a opção brownnoise por whitenoise para se ter ruído branco.

Com os efeitos, o código fica:

  sox -t sl -r 44100 -c 2 /dev/zero \ -t ossdsp /dev/dsp \ synth "1:00:00" brownnoise : \ band -n 2200 200 : \ reverb : \ flanger : \ chorus 0.7 0.9 : \ earwax : \ phaser 0.89 0.85 1 0.24 2 -t : \ vol 0.5 

As quebras de linha não são necessarias, servem apenas para mostrar os efeitos e facilitar a leitura.

Salvando em um arquivo

Caso se queira salvar o arquivo, basta trocar o -t ossdsp /dev/dsp do código a cima pelo nome do arquivo que se deseja criar. Para se criar o arquivo ruido.wav, fica:

 sox -t sl -r 44100 -c 2 /dev/zero \ ruido.wav \ synth "1:00:00" brownnoise : \ band -n 2200 200 : \ reverb : \ flanger : \ chorus 0.7 0.9 : \ earwax : \ phaser 0.89 0.85 1 0.24 2 -t : \ vol 0.5 

by Andre Ramaciotti

Teclado

Diferente de alguns notebooks que vieram com o / e o ? nas teclas Q e W, este notebook funcionará perfeitamente com um layout para teclado ABNT2. Inclusive as teclas Fn+alguma coisa.

Webcam

A webcam funcionou de primeira até no Arch Linux. Caso não tenha funcionado na sua distro por algum motivo qualquer, o módulo necessário é o uvcvideo.

 # modprobe uvcvideo OU $ sudo modprobe uvcvideo 

Particionando o disco

A primeira vez que tentei particionar o disco com o cfdisk dava erro e ele saía. A solução foi usar o fdisk para apagar a tabela de partições do disco e então usar o cfdisk. Digite ‘m’ e ele mostrará os comandos. O comando para deletar é ‘d’ e o comando para sair, salvando as alterações, é ‘w’. Não se preocupe muito com o fdisk: apague tudo e depois divirta-se com o cfdisk.

Não cheguei a testar, mas outra alternativa é o gparted.

Salvando o disco

Algum tempo atrás surgiu um artigo no Slashdot sobre o Ubuntu estar diminuindo a vida útil de discos rígidos por estar usando regras muito agressivas de spin down. Isso reduz o consumo de bateria, mas o resultado é uma diminuição na vida útil do seu HD. Para desativar isso no Arch Linux, instale o pacote hdparm e rode:

 hdparm -B 255 /dev/sda 

No entanto, isso deve ser rodado toda vez que o computador for iniciado. Portanto, adicione a linha a cima ao seu /etc/rc.local também.

Wireless

Existem duas possibilidades. Se sua placa for uma Broadcom (cheque com lspci), dê uma olhada no AUR pelo pacote broadcom-wl. Usuários de outras distros podem baixar o driver da própria Broadcom, mas procure antes se não há um método mais fácil de fazer a instalação na sua distribuição.

A outra possibilidade é que sua placa seja da Intel, nesse caso…

Áudio

Tanto o ALSA quanto o OSS4 funcionam (no sentido que com os dois você conseguirá escutar música). Há quem diga que a qualidade de som no OSS4 é muito melhor, há quem defenda que se há diferença, esta é imperceptível (eu, por exemplo).

No fim eu acabei preferindo o ALSA, já que com ele há suporte às duas saídas de fone de ouvido ao mesmo tempo e consegui utilizar tanto o microfone built-in, quanto o jack para microfone externo.

Para que as coisas funcionem, adicione a segunda linha a seu /etc/modprobe.conf:

options snd-hda-intel model=dell-bios

e depois fuce no alsamixer, e lembre-se adicionar alsa aos seus DAEMONS no /etc/rc.conf e de tirar as caixas de som do mudo.

Kernel Mode Setting

Synaptics

by Andre Ramaciotti

Barra de título só quando floating

Pediram em um tópico do fórum do Arch Linux como fazer a barra de título aparecer em janelas que estivessem “flutuando” no awesome. A idéia é boa e permite que tenhamos o melhor dos dois mundos: de um lado, o tiling continua funcionando normalmente; do outro, nós temos controle sobre programas que estejam “flutuando” de forma bastante similar ao que teríamos em gerenciadores de janela comuns, tais como o Openbox, o do GNOME e o do KDE.

A implementação disso é bastante simples, basta adicionar ao fim de seu rc.lua:

 awful.hooks.property.register(function (c, prop) -- Remove the titlebar if fullscreen if c.fullscreen then awful.titlebar.remove(c) elseif not c.fullscreen then -- Add title bar for floating apps if c.titlebar == nil and awful.client.floating.get(c) then awful.titlebar.add(c, { modkey = modkey }) -- Remove title bar, if it's not floating elseif c.titlebar and not awful.client.floating.get(c) then awful.titlebar.remove(c) end end end) 

by Andre Ramaciotti

 ;;; Put all auto-save files in the same place (defvar autosave-dir "/home/andre/.local/.emacs.d/auto-save-files/") (make-directory autosave-dir t) (defun make-auto-save-file-name () (concat autosave-dir "#" (buffer-name) "#")) (setq make-backup-files nil) ;;; Save position in file (setq save-place-file "/home/andre/.local/.emacs.d/saveplace") (setq-default save-place t) (require 'saveplace) ;;; Other configs (load "/home/andre/.local/.emacs.d/color-schemes/my.el" nil t t) (require 'color-theme) (setq color-theme-is-global t) (color-theme-i-me-mine) (setq default-frame-alist '((font-backend . "xft") (font . "Envy Code R-8") (cursor-color . "white"))) (setq-default fill-column 80) (mouse-wheel-mode t) (set-cursor-color "white") (column-number-mode 1) (line-number-mode 1) (setq show-paren-delay 0) (show-paren-mode 1) (setq show-paren-style 'expression) (set-face-background 'show-paren-match-face "#444444") ;;; C Mode (add-hook 'c-mode-hook '(lambda () (c-set-style "bsd"))) ;;; LaTeX Mode (load "auctex.el" nil t t) (load "preview-latex.el" nil t t) (defun auto-fill-mode-on () (auto-fill-mode 1)) (add-hook 'LaTeX-mode-hook 'auto-fill-mode-on) (add-hook 'latex-mode-hook 'auto-fill-mode-on) (add-hook 'TeX-mode-hook 'auto-fill-mode-on) (add-hook 'tex-mode-hook 'auto-fill-mode-on) ;;; Lua Mode (setq auto-mode-alist (cons '("\.lua$" . lua-mode) auto-mode-alist)) (autoload 'lua-mode "lua-mode" "Lua editing mode." t) ;;; Haskell Mode (setq auto-mode-alist (append auto-mode-alist '(("\\.[hg]s$" . haskell-mode) ("\\.hi$" . haskell-mode) ("\\.l[hg]s$" . literate-haskell-mode)))) (autoload 'haskell-mode "haskell-mode" "Major mode for editing Haskell scripts." t) (autoload 'literate-haskell-mode "haskell-mode" "Major mode for editing literate Haskell scripts." t) (add-hook 'haskell-mode-hook 'turn-on-haskell-decl-scan) (add-hook 'haskell-mode-hook 'turn-on-haskell-doc-mode) (add-hook 'haskell-mode-hook 'turn-on-haskell-indent) (setq haskell-lieterate-default 'tex) ;;; Slime (Lisp development) (setq inferior-lisp-program "/usr/bin/sbcl") (add-to-list 'load-path "/usr/share/emacs/site-lisp/slime/") (require 'slime) (slime-setup) (custom-set-variables ;; custom-set-variables was added by Custom. ;; If you edit it by hand, you could mess it up, so be careful. ;; Your init file should contain only one such instance. ;; If there is more than one, they won't work right. '(column-number-mode t) '(inhibit-startup-screen t) '(initial-scratch-message nil) '(show-paren-mode t)) (put 'upcase-region 'disabled nil) (custom-set-faces ;; custom-set-faces was added by Custom. ;; If you edit it by hand, you could mess it up, so be careful. ;; Your init file should contain only one such instance. ;; If there is more than one, they won't work right. ) 

by Andre Ramaciotti

Definição

Regras

Derivada de uma constante

Derivada da função identidade

Trigonométricas

Se algumas passagens parecerem obscuras, revise algumas propriedades trigonométricas.

Seno

Dado¹:

Temos que:

Cosseno

Sabendo que:

Sendo e usando a regra da composição:

by Andre Ramaciotti

 (defun num->list (num &optional (lst nil)) (if (zerop num) lst (num->list (floor num 10) (push (mod num 10) lst)))) (print (reduce #'+ (num->list (expt 2 1000)))) 

by Andre Ramaciotti

Usando Cálculo

Definida uma função , tal que , temos que a derivada de , usando a regra do produto é:

Portanto, deve ser uma função constante. Como sabemos qual o valor de , sabemos qual o valor para qualquer real. Assim,

Multiplicando ambos os lados por , temos:

c.q.d.

by Andre Ramaciotti

O gnuplot é um ótimo programa para fazer gráficos, seja de funções ou de uma (ou mais) tabela de dados.

Funções paramétricas

As funções paramétricas são funções que dependem de um parâmetro (matematicamente, geralmente ele é representado pela letra ). Para entrarmos no modo paramétrico, primeiro rodamos:

 set parametric 

Aparecerá uma mensagem dizendo que t é para gráficos no plano e u e v para gráficos tridimensionais. Podemos definir o quanto essas variaveis podem variar com o comando set:

 set trange [-10:10] set urange [-2*pi:2*pi] set vrange [0:10] 

Então podemos fazer o gráfico de um círculo, por exemplo:

 plot cos(x),sin(x) 

Ou então de uma mola:

 splot u,cos(u),sin(u) 

by Andre Ramaciotti

A termios.h é uma biblioteca especificada pelo padrão POSIX que permite que nós alteremos as opções do terminal em que o programa está sendo executado. O exemplo mais típico é quando vamos fazer o login em um console virtual e quando digitamos a senha não aparece nada; isso pode ser feito tirando a “opção” ECHO do terminal que estamos usando.

Exemplos

Detectando eventos no terminal

Digamos que um software esteja sendo desenvolvido (para o terminal) e que em um dado momento, o usuário deve escolher uma opção, alguma coisa parecida com isto:

 Houve um erro na hora de executar asdf: [R]epetir [C]ontinuar [A]bortar 

Usando getchar ou scanf ou qualquer outra função da biblioteca stdio.h, a leitura será feita linha por linha. Por isso, mesmo que nós queiramos apenas um caractere, o usuário terá que apertar esse caractere e depois Enter. Eu queria uma forma de fazer isso em que o usuário simplesmente digitasse ‘r’ ou ‘c’, enfim, apenas uma tecla. Pensei em usar ncurses até, mas achei essa solução exagerada, e além disso, como o ncurses faz isso?

A solução apareceu com o uso de termios.h e de uma função de leitura também especificada pelos padrões POSIX, mas na biblioteca unistd.h, a função read().

Código

 #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <termios.h> void silent(struct termios *init_setting, struct termios *new_setting); void verbose(struct termios *init_setting); unsigned char get_char(void); int main(int argc, char *argv[]) { struct termios init_setting, new_setting; unsigned char ch = 0; printf("Houve um erro na execução de foo.\n[C]ontinuar\t[R]epetir\t[A]bortar\n"); silent(&init_setting, &new_setting); while(ch != 'a' && ch != 'A') { ch = get_char(); switch(ch) { case 'r': case 'R': verbose(&init_setting); printf("Repetindo...\n"); printf("Houve um erro na execução de foo.\n[C]ontinuar\t[R]epetir\t[A]bortar\n"); silent(&init_setting, &new_setting); break; case 'c': case 'C': verbose(&init_setting); printf("Continuando...\n"); sleep(2); printf("Houve um erro na execução de foo.\n[C]ontinuar\t[R]epetir\t[A]bortar\n"); silent(&init_setting, &new_setting); break; } } verbose(&init_setting); return(0); } void silent(struct termios *init_setting, struct termios *new_setting) { tcgetattr(fileno(stdin), init_setting); new_setting = init_setting; new_setting->c_lflag &= ~(ICANON | ECHO | ISIG); new_setting->c_cc[VMIN] = 1; new_setting->c_cc[VTIME] = 0; tcsetattr(fileno(stdin), TCSADRAIN, new_setting); } void verbose(struct termios *init_setting) { tcsetattr(fileno(stdin), TCSADRAIN, init_setting); } unsigned char get_char() { unsigned char ch; read(fileno(stdin), &ch, sizeof(unsigned char)); return ch; } 

Explicações

Para que a idéia funcione, precisamos alterar algumas opções do terminal, e é aí que entra a biblioteca termios.h. Vamos definir duas funções, verbose(), que volta as configurações ao normal, e silent(), que tira o echo do terminal. O comportamento desejado é que quando o usuário aperte uma tecla, ela não apareça na tela, mas isso traz uma consequência: se você tentar usar o printf() ou qualquer outra função do tipo, ela também não aparecerá. Por isso, temos que ficar alternando entre os modos.

O echo é desativado na linha “new_setting->c_lflag &= ~(ICANON | ECHO);“, onde nós também desligamos o modo canônico, o que nos permite fazer a leitura caractere por caractere, ao invés de linha por linha, como é o padrão.

Outro detalhe importante são as linhas new_setting->c_cc[]. A função read() é uma função que bloqueia a execução do programa até que certa condição seja encontrada. No caso, definimos que ela só pode retornar após ler 1 caractere (VMIN), não importa quanto tempo (em décimos de segundo) isso demore (VTIME). Neste exemplo, poderíamos também usar c_cc[VMIN] = 0 e c_cc[VTIME] = 100, que faz com que a função retorne assim que receber o primeiro caractere ou depois de 10 segundos, permitindo que o programa continue com uma opção padrão.

Um último detalhe é o tipo de loop que eu usei. De maneira geral, um loop do tipo while(1) pode maximizar o uso de uma das CPUs, mas no caso não temos esse problema, já que read() é uma função que bloqueia a execução do programa até que ela retorne.

Calculadora RPN

Uma calculadora que usa notação polonesa reversa para o terminal que eu escrevi usando a biblioteca usando termios.h

by Andre Ramaciotti

 python time-it.py <número de vezes> <comando> 

Por exemplo, para saber a média de se executar a.out 5 vezes:

 python time-it.py 5 ./a.out 

Ele calcula o tempo que demorou para executar o comando e depois calcula uma média aritmética e uma média desconsiderando o valor mais alto e o mais baixo.

O Código

 #!/usr/bin/env python import time import sys import subprocess import math if len(sys.argv) < 3: print "time-it.py <num of runs> <what to run>" exit() runs = int(sys.argv[1]) command = sys.argv[2:] def mean(lst): global runs return (math.fsum(lst) / float(runs)) def san_mean(lst): global runs lst.sort() return (math.fsum(lst[1:-1]) / float(runs-2)) time.sleep(2) count = 0 timing = [] while count < runs: t1 = time.time() subprocess.call(command) t2 = time.time() timing.append(t2-t1) count += 1 time.sleep(1) count = 0 print " ".join(command) while count < runs: print "%g" % timing[count] count += 1 print "mean: %g" % mean(timing) print "sanatized mean: %g" % san_mean(timing) print #linha em branco 

Pode-se questionar a necessidade dos sleeps, mas fiz assim para que o processo de carregar o python não interferisse nos resultados, e para que uma execução não interferisse na outra.

by Andre Ramaciotti

Usando threads podemos dividir o trabalho entre os dois ou mais processadores que estivermos usando. De maneira geral, o uso delas é bastante simples, os problemas só aparecem quando uma thread depende do resultado de outra, ou então as duas estão acessando o mesmo recurso (uma conexão a um banco de dados, por exemplo).

Pthreads

Pthreads são as threads como especificadas pelo padrão POSIX. Aqui veremos apenas um exemplo simples de como usá-las, mas dá para pegar a idéia geral de como utilizá-las.

Tipos e funções

Aqui só usaremos um tipo de variável e duas funções, mas é claro que as pthreads podem fazer muito mais que isso. O tipo que usaremos é o pthread_t que guarda informações sobre uma thread e as funções são pthread_create e pthread_join. A primeira cria uma nova thread, guardando informações sobre ela no seu primeiro argumento, lendo atributos do segundo (não os usaremos), chamando a função do terceiro argumento e passando o quarto argumento como argumento para função. A segunda associa o valor retornado por uma thread determinada pelo primeiro argumento no segundo argumento.

Implementação

A função que usei no caso foi o fatorial, simples e rápida, e por isso os detalhes relativos à implementação de threads ficam mais aparentes. Ei-la:

 /* gcc -pthread */ #include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <unistd.h> /* sleep() */ struct nums { int num[3]; }; void *fac(void *arg) { struct nums *args = arg; struct nums *result = malloc(sizeof(struct nums)); int i; result->num[0] = 1; result->num[1] = 1; result->num[2] = 1; for(i = args->num[0]; i > 0; i--) { result->num[0] *= i; } printf("%d\n", result->num[0]); sleep(1); for(i = args->num[1]; i > 0; i--) { result->num[1] *= i; } printf("%d\n", result->num[1]); sleep(1); for(i = args->num[2]; i > 0; i--) { result->num[2] *= i; } printf("%d\n", result->num[2]); sleep(1); return((void *) result); } int main(int argc, char *argv[]) { struct nums arg1; struct nums arg2; struct nums *res1; struct nums *res2; int ret = 0; pthread_t thread1, thread2; arg1.num[0] = 5; arg1.num[1] = 15; arg1.num[2] = 12; arg2.num[0] = 7; arg2.num[1] = 8; arg2.num[2] = 10; pthread_create(&thread1, NULL, &fac, &arg1); pthread_create(&thread2, NULL, &fac, &arg2); ret = pthread_join(thread1, (void *) &res1); if(ret == 0) { printf("returned: %d, %d, %d\n", res1->num[0], res1->num[1], res1->num[2]); } ret = pthread_join(thread2, (void *) &res2); if(ret == 0) { printf("returned: %d, %d, %d\n", res2->num[0], res2->num[1], res2->num[2]); } return(0); } 

fac

Temos uma função fac que aceita um argumento do tipo void* e que retorna um valor do tipo void*. Infelizmente, até onde sei, não há como passar mais argumentos, então, se for necessário, o melhor é usar uma struct, como eu fiz.

A “pegadinha” aqui são esses void*s. Uma função do tipo void não retorna nada, logo, devemos supor, void* é um ponteiro que aponta para nada, ou seja, se ele aponta para nada, ele não aponta, então não é um ponteiro. Ele é o ponteiro que é e não é ao mesmo tempo.

Mentira, um void* é um ponteiro para qualquer coisa, int, char, um struct qualquer, por isso que o usamos neste caso.

Então temos o código em si do fatorial e depois um sleep(). O motivo pelo qual o coloquei é que quando escrevi o código eu não tinha um processador dual-core, então eu não teria como saber se as threads estão sendo executadas simultaneamente. Com o sleep(), como elas não fazem nada enquanto dormem, uma thread pode calcular o fatorial enquanto a outra dorme.

E por último, temos que retornar o valor, mas como o tipo da função é void* e não struct nums*, temos que fazer um cast, uma mudança de tipo. Por isso aquele (void *) dentro de return().

main

Na função main(), a primeira coisa que merece destaque é o pthread_t. Como eu falei antes, são eles que vão guardar informações sobre as threads.

Depois, temos a chamada de pthread_create(). Os argumentos são &thread1, que é um pthread_t, NULL, já que não vamos passar “opções” na hora de criar a thread, &fac que é a nossa função e &arg1 que é nossa struct com os argumentos. Fazemos basicamente a mesma coisa de novo, mas agora com a segunda thread.

Depois, nós pegamos os valores retornados pelas threads com pthread_join. O valor que ela retorna, no caso “ret” é para sabermos se houve erro ou não. O primeiro argumento é a thread que queremos (mas sem o & agora) e onde o valor de retorno será guardado, no caso, em res1.

Compilando

No fim, para compilar:

 gcc arquivo.c -pthread 

by Andre Ramaciotti

Falando sobre mim, nasci em 1990 e acabei de ingressar na faculdade de Engenharia Elétrica. Meu interesse por dispositivos eletrônicos começou quando eu era pequeno e abria coisas para ver como funcionavam. Isso não significa, é claro, que elas sempre voltavam a funcionar depois ;) . Já nessa época eu me interessava por computadores também, mas na época eu estava mais interessado em jogos.

Meu interesse por ambos aumentou quando comecei a tocar guitarra, com 11 anos. A causa mais direta é guitarras dependerem de equipamentos elétricos para funcionarem completamente. Além disso, alguns anos depois, descobri simuladores de amplificadores para guitarra no computador. Insatisfeito com a qualidade das simulações, resolvi aprender a programar. Você deve estar se perguntando “E aí? Conseguiu fazer uma melhor?”. Bom… não. Mas também nem tentei.

Aprendendo programação, apareceram outros interesses. Um dos mais importantes é o Linux, que tornou-se meu único SO há dois anos. Comecei com o Slackware, mas a falta de um gerenciador de pacotes mais avançado me fez buscar outra distro. Hoje uso o Archlinux e sei umas tantas linguagens (as que sei melhor: python, C e lisp).

Além disso, me interesso por línguas (humanas), em especial as que não usam o alfabeto latino. No momento, falo bem português e inglês e estudo francês. Sei algumas poucas coisas de russo e japonês também.

by Andre Ramaciotti

 #include <stdio.h> #include <stdlib.h> #include <unistd.h> int main(int argc, char *argv[]) { int i = 0; FILE *fptr = fopen("/tmp/daemon-test","w"); daemon(0, 0); for(;i<11;i++) { fprintf(fptr,"%d\n",i); sleep(10); } fclose(fptr); return(0); } 

O primeiro argumento da função daemon() determina o diretório ativo: se for 0, o diretório será o /; qualquer outro número será o diretório em que o daemon foi iniciado. O segundo argumento determina o que será feito com as saídas e entradas (stdin, stdout e stderr): 0 as redireciona para /dev/null e qualquer valor não nulo não as redireciona.

by Andre Ramaciotti

Para uma calculadora RPN 100% funcional, recomendo a galculator, em GTK+.

 #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <termios.h> #define CTOI(x) (x-48) void silent(struct termios *init_setting, struct termios *new_setting); void verbose(struct termios *init_setting); void push_stack(int number, int *stack); void make_number(int *number, int new_digit); unsigned char get_char(void); int do_operation(int *number, int *stack, unsigned char operation); int main(int argc, char *argv[]) { struct termios init_setting, new_setting; unsigned char pressed = '', last = ''; int current_number = 0; int stack[3]; stack[0] = 0; stack[1] = 0; stack[2] = 0; printf("Basic RPN Calculator. Press 'q' to quit.\n"); silent(&init_setting, &new_setting); while(pressed != 'q') { last = pressed; pressed = get_char(); switch(pressed) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': verbose(&init_setting); write(fileno(stdin), &pressed, 1); if(last == '+' || last == '-' || last == '*' || last == '/') { push_stack(current_number, stack); current_number = CTOI(pressed); } else if(last == '\n') { current_number = CTOI(pressed); } else { make_number(&current_number, CTOI(pressed)); } silent(&init_setting, &new_setting); break; case '\n': verbose(&init_setting); write(fileno(stdin), &pressed, 1); push_stack(current_number, stack); silent(&init_setting, &new_setting); break; case '+': case '-': case '*': case '/': verbose(&init_setting); printf("\n%c\t%d\n", pressed, do_operation(&current_number, stack, pressed)); silent(&init_setting, &new_setting); break; default: break; } } verbose(&init_setting); return(0); } void silent(struct termios *init_setting, struct termios *new_setting) { tcgetattr(fileno(stdin), init_setting); new_setting = init_setting; new_setting->c_lflag &= ~(ICANON | ECHO | ISIG); new_setting->c_cc[VMIN] = 1; new_setting->c_cc[VTIME] = 0; tcsetattr(fileno(stdin), TCSADRAIN, new_setting); } void verbose(struct termios *init_setting) { tcsetattr(fileno(stdin), TCSADRAIN, init_setting); } void push_stack(int number, int *stack) { stack[2] = stack[1]; stack[1] = stack[0]; stack[0] = number; } void make_number(int *number, int new_digit) { *number = (*number*10) + new_digit; } unsigned char get_char() { unsigned char ch; read(fileno(stdin), &ch, sizeof(unsigned char)); return ch; } int do_operation(int *number, int *stack, unsigned char operation) { switch(operation) { case '+': *number = *number + stack[0]; break; case '-': *number = stack[0] - *number; break; case '*': *number = *number * stack[0]; break; case '/': *number = stack[0] / *number; break; } stack[0] = stack[1]; stack[1] = stack[2]; stack[2] = 0; return(*number); } 

by Andre Ramaciotti