#+title: 8 -- Conversão de strings numéricas para inteiros
#+author: Blau Araujo
#+email: cursos@blauaraujo.com

#+options: toc:3

* Objetivos

- Diferenciar as expressões numéricas em texto dos números que representam.
- Conhecer a relação entre tipos numéricos e tamanhos de dados.
- Criar sub-rotinas reaproveitáveis para conversões de caracteres para números.

* Todos os dados externos são recebidos como caracteres

Se consideramos como /dados externos/:

- Argumentos de linha de comando;
- Variáveis exportadas para o ambiente do processo;
- Dados digitados pelo usuário;
- Dados lidos por redirecionamentos e pipes;
- Dados lidos de arquivos em geral...

Todos eles têm em comum o fato de serem recebidos nos nossos programas
como cadeias de caracteres, mesmo que representem números. Consequentemente,
para utilizá-los em operações numéricas, será necessário convertê-los nos
valores que representam.

** Entendendo o problema

Para entendermos melhor o problema, vamos analisar o que acontece no programa
abaixo (=exemplo.c=) com o GDB.

Arquivo: [[exemplos/08/exemplo.c][exemplo.c]]

#+begin_src c :tangle exemplos/08/exemplo.c
#include <stdio.h>

int main(void) {

    int a = 123;
    char *b = "123";
    int *c = (int *)b; // Casting do valor no endereço 'b' para inteiro
        
    printf("Inteiro a: %d\n", a);
    printf("String  b: %s\n", b);
    printf("Inteiro c: %d\n", *c); // Imprime o valor no endereço 'c'
    
    return 0;
}
#+end_src

*Compilação e execução:*

#+begin_example
:~$ gcc -g exemplo.c
:~$ ./a.out
Inteiro a: 123
String  b: 123
Inteiro c: 3355185
#+end_example

Note que o ponteiro =c=, que recebeu endereço dos bytes da string no ponteiro
=b= (="123"=), aponta para um valor inteiro totalmente diferente do que está
representado pelos dígitos da string (o inteiro =3355185=).

*Abertura e execução com o GDB:*

Para examinar os conteúdo da memória em hexadecimal, nós vamos marcar a
unção =main= como ponto de parada, executar o programa e avançar a execução
em 3 linhas, para que as variáveis sejam inciadas, o nos levará ao ponto
anterior à chamada da função =printf=:

#+begin_example
:~$ gdb a.out
Reading symbols from a.out...
(gdb) break main
Breakpoint 1 at 0x1141: file exemplo.c, line 5.
(gdb) run
Starting program: /home/blau/git/pbn/curso/exemplos/08/a.out
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".

Breakpoint 1, main () at exemplo.c:5
warning: Source file is more recent than executable.
5	    int a = 123;
(gdb) next 3
9	    printf("Inteiro a: %d\n", a);
(gdb)
#+end_example

O que queremos observar é a diferença entre os valores numéricos dos três
dados na memória, como se todos eles fossem inteiros (formato =w= no GDB):

#+begin_example
(gdb) x /1wx &a
0x7fffffffdecc:	0x0000007b
(gdb) x /1wx b
0x555555556004:	0x00333231
(gdb) x /1wx c
0x555555556004:	0x00333231
#+end_example

Veja que os bytes da string apontada por 'b' são, como esperado, os mesmos
do inteiro apontado por 'c', mas ambos são totalmente diferentes do valor
em hexadecimal do inteiro em =a= (=123=).

** A ordem dos bytes

Nós também podemos examinar o conteúdo byte a byte desses dados a partir de
seus endereços iniciais:

#+begin_example
(gdb) x /4bx &a
0x7fffffffdecc:	0x7b	0x00	0x00	0x00
(gdb) x /4bx b
0x555555556004:	0x31	0x32	0x33	0x00
(gdb) x /4bx c
0x555555556004:	0x31	0x32	0x33	0x00
#+end_example

Isso ajuda a demonstrar que os bytes de inteiros, como os de qualquer outro
tipo diferente de =char=, são escritos em ordem inversa (/little endian/) na
memória. Portanto, quando os bytes da string foram interpretados como os
4 bytes de um inteiro, eles também foram invertidos:

#+begin_example
(gdb) x /4bx c
0x555555556004:	0x31	0x32	0x33	0x00
(gdb) x /1wx c
0x555555556004:	0x00333231
#+end_example

O tipo =char= é composto por apenas um byte e a ordem /little endian/ só afeta
a disposição de bytes: é por isso que somente os dados de tipos com dois ou
mais bytes são invertidos. Além disso, na montagem dos dados na memória,
o que importa é o tamanho de cada dado, não o que eles formam. Então, como
strings são formadas por cadeias de caracteres terminadas com o caractere
nulo (='\0'=), a ordem de seus bytes não é invertida.

** Dígitos na tabela ASCII

Os valores dos bytes da string ="123"= (além do terminador nulo ='\0'=, de valor
=0x00=) foram determinados pela convenção de representação de caracteres da
tabela ASCII:

| Caractere | Hexadecimal | Octal | Decimal |
|-----------+-------------+-------+---------|
| =\0=        |        0x00 |     0 |       0 |
| =0=         |        0x30 |   060 |      48 |
| =1=         |        0x31 |   061 |      49 |
| =2=         |        0x32 |   062 |      50 |
| =3=         |        0x33 |   063 |      51 |
| =4=         |        0x34 |   064 |      52 |
| =5=         |        0x35 |   065 |      53 |
| =6=         |        0x36 |   066 |      54 |
| =7=         |        0x37 |   067 |      55 |
| =8=         |        0x38 |   070 |      56 |
| =9=         |        0x39 |   071 |      57 |

Em comparação aos valores dos caracteres em outras bases, a representação em
hexadecimal é bastante conveniente, pois basta subtrair =0x30= para saber qual
é o dígito correspondente.

** Considerações sobre os tipos numéricos

Em baixo nível, nós trabalhamos diretamente com tamanhos de dados. Os tipos
das linguagens de alto nível, como a linguagem C, são apenas abstrações para
ajudar a definir o tamanho dos dados e as regras de seus usos. Sendo assim,
existe uma equivalência entre as formas de representar tamanhos de dados em
Assembly com os tipos, por exemplo, da linguagem C.

Considerando a arquitetura x86_64:

| Tipo em C | Tamanho | Tamanho em Assembly |
|-----------+---------+---------------------|
| =char=      | 1 byte  | /byte/                |
| =short=     | 2 bytes | /word/                |
| =int=     | 4 bytes | /double-word/         |
| =long=      | 8 bytes | /quad-word/           |
| =float=     | 4 bytes | /double-word/         |
| =double=    | 8 bytes | /quad-word/           |

#+begin_quote
Esses tamanhos são especificados na ABI do System V AM64, usada pelo Linux
em arquitetura x86_64 e garantidos, na prática, pelo GCC e em sistemas
baseados na =glibc=.
#+end_quote

Em Assembly, portanto, definir uma lista de /double-words/ (=dd=) tem o mesmo
efeito de definir um vetor de inteiros na linguagem C, inclusive na ordem
em que os bytes são dispostos na memória. Ou então, o dado em um registrador
de 64 bits, se tomado como um todo, terá o tamanho de uma /quad-word/ e será
equivalente ao tipo =long= da linguagem C.

** Pesos posicionais

Falando apenas de inteiros sem sinal por enquanto, cada byte de uma string
numérica decimal representa um algarismo do número multiplicado pelo seu
/peso posicional/, por exemplo:

#+begin_example
0x31 0x32 0x33  => '1' '2' '3'

0x31 - 0x30 * 100 = 100 (centenas)
0x32 - 0x30 * 10  =  20 (dezenas)
0x33 - 0x30 * 1   =   3 (unidades)

100 + 20 + 3 = 123
#+end_example

Manualmente, este é um procedimento de conversão bastante simples, mas a sua
implementação em uma rotina de baixo nível não é tão intuitiva, embora também
não seja nada muito complicado. O /"pulo do gato"/ está em alcançar os pesos
posicionais de cada algarismo progressivamente:

#+begin_example
031 0x32 033 => '1' '2' '3'

val = 0x31 - 0x30 = 1
val = (val * 10) + (0x32 - 0x30) = 10 + 2 = 12 
val = (val * 10) + (0x33 - 0x30) = 120 + 3 = 123
#+end_example

Ou, de uma forma mais regular:

#+begin_example
val = 0
val = (val * 10) + (0x31 - 0x30) =   0 + 1 = 1
val = (val * 10) + (0x32 - 0x30) =  10 + 2 = 12 
val = (val * 10) + (0x33 - 0x30) = 120 + 3 = 123
#+end_example

Esse procedimento, facilmente implementável em Assembly, contempla tudo que
vimos sobre o problema:

- Percorre os bytes da string na ordem em que estão na memória;
- Converte os dígitos ASCII para os valores que representam;
- Aplica os pesos posicionais corretos a cada algarismo encontrado.

Com isso, nós já podemos escrever uma rotina de conversão para strings que
representam números decimais sem sinal de todos os tipos compatíveis com
=int= (=char=, =short= e =long=, por exemplo).

* Conversão para inteiros sem sinal em alto nível

Em linguagem C, sem utilizar as funções especializadas da biblioteca padrão
e com base no procedimento que elaboramos, nós poderíamos implementar uma
função de conversão para inteiros sem sinal deste modo:

#+begin_src c
unsigned int str_to_uint(char *str) {
    int dig;               // Recebe o dígito convertido
    unsigned int conv = 0; // Recebe a parcial da conversão
    
    for (int i = 0; str[i] != '\0'; i++) {
        if (str[i] < '0' || str[i] > '9') break;
        dig = str[i] - '0'; 
        conv = (conv * 10) + dig;
    }
    return conv;
}
#+end_src

Embora funcional para a maioria dos casos, essa abordagem tem alguns problemas:

- Não verifica se o valor convertido excede o limite máximo para inteiros sem
  sinal da plataforma;
- Não verifica se o ponteiro para a string é nulo (=NULL=);
- Retorna =0= tanto para a conversão da string ="0"= quanto para uma string sem
  dígitos nos primeiros caracteres.

Todos esses problemas poderiam ser solucionados com verificações e o retorno
de um valor de erro: mas que valor seria esse? Tipicamente, utilizaríamos =-1=,
mas o retorno da função tem que ser =unsigned=. Também poderíamos sacrificar um
número válido, como o valor do próprio limite máximo de inteiros sem sinal,
definido na =glibc= em =UINT_MAX=, no cabeçalho =limits.h=, mas isso requereria
uma nota sobre essa limitação.

Uma terceira opção, que me parece bem mais razoável, seria incluir um segundo
parâmetro para receber o estado de término da função:

#+begin_src c
unsigned int str_to_uint(char *str, int *err);
#+end_src

Deste modo, a função poderia ser utilizada assim:

#+begin_src c
char *str_num = "123";   // String a ser convertida.
int status;              // Recebe o estado de término da função.

unsigned int num = str_to_uint(str_num, &status);
if (!status) ...;        // Consequências do erro...
#+end_src

Para os casos de uso onde o tratamento de erros não for importante, nós
podemos dar a opção de passar =NULL= como argumento de =*err= e trabalhar a
implementação para definir um estado padrão =0= (erro), condicionado ao
ponteiro recebido, e alterá-lo para =1= somente antes de terminar com
sucesso:

#+begin_src c
unsigned int str_to_uint(char *str, int *err /* nullable */) {
    // Inicia a função com estado de erro, mas só se '*err' não for NULL...
    if (err) *err = 0;

    // Outras verificações e rotina de conversão...

    // Altera o estado antes de terminar com sucesso (1)...
    if (err) *err = 1;
    return conv;
}
#+end_src

Assim, caso =*err= seja =NULL=, nenhum estado de término será definido.

** Erro de ponteiro nulo

Caso o endereço da string (=*str=) seja passada como um ponteiro nulo, nós
simplesmente terminaremos a função com retorno =0= sem alterar o valor de
=*err=, que também é =0= (erro):

#+begin_src c
// Inicia a função com estado de erro, mas só se '*err' não for NULL...
if (err) *err = 0;

// Termina com erro (0) e valor 0 se str==NULL...
if (str == NULL) return 0;
#+end_src

** Erro de byte inicial fora faixa de dígitos

Apesar de ser uma verificação redundante, por ser repetida mais adiante no
código, ela é necessária para determinar quando a função retorna =0= por ter
convertido apenas uma string ="0"= ou devido a não haver dígitos para converter
no início da string, ou seja:

#+begin_example
String: "abc123" --> Converte para 0 com estado 1
String: ""       --> Converte para 0 com estado 1
String: "0"      --> Converte para 0 com estado 1
Erros            --> Retornam conversão para 0, mas com estado 0
#+end_example

A ideia é que os dois primeiros casos (="abc123"= e =""=) retornem =0= om estado
de término =0= (erro), portanto...

#+begin_src c
// Inicia a função com estado de erro, mas só se '*err' não for NULL...
if (err) *err = 0;

// Termina com erro (0) e valor 0 se str==NULL...
if (str == NULL) return 0;

// Termina com erro (0) e valor 0 se primeiro byte não for um dígito...
if (str[0] < '0' || str[0] > '9') return 0;
#+end_src

Nós podemos, inclusive, combinar as duas verificações numa só:

#+begin_src c
// Inicia a função com estado de erro, mas só se '*err' não for NULL...
if (err) *err = 0;

// Termina com erro (0) e valor 0 se str==NULL
// ou se o primeiro byte não for um dígito...
if (str == NULL || str[0] < '0' || str[0] > '9') return 0;
#+end_src

** Erro de estouro do limite do tipo

Nós podemos utilizar o valor de =UINT_MAX= como referência para determinar se
o próximo valor parcial do ciclo de conversões excederá ou não o limite
máximo para números inteiros sem sinal. A cada ciclo, a conversão é feita
com:

#+begin_example
valor = (valor * 10) + dígito;
#+end_example

Para determinar se isso excederá o valor de =UNIT_MAX=, basta calcular qual
seria o valor corrente máximo para que a próxima conversão resulte em algo
dentro do limite:

#+begin_example
valor * 10 + dígito < UINT_MAX
valor * 10 < UINT_MAX - dígito
valor < (UINT_MAX - dígito) / 10
#+end_example

No código, isso pode ser escrito no loop de conversão como:

#+begin_src c
// Converte o dígito corrente...
dig = str[i] - '0';
    
// Termina com erro e valor 0 se a próxima conversão exceder UINT_MAX...
if (conv > (UINT_MAX - dig) / 10) return 0;

// Processa a parcial da conversão...
conv = (conv * 10) + dig;
#+end_src

** Implementação final em C

Aqui está a implementação final, com as verificações e os procedimentos
atualizados:

#+begin_src c
#include <limits.h> // Requerido para obter UINT_MAX da plataforma

unsigned int str_to_uint(char *str, int *err /* nullable */) {

    if (err) *err = 0;  // Estado padrão é de erro (0 = falso)!
    
    // Termina com erro e valor 0 se str==NULL ou se '0'>str[0]>'9'...
    if (str == NULL || str[0] < '0' || str[0] > '9') return 0;
   
    int dig;               // Recebe o dígito convertido
    unsigned int conv = 0; // Recebe a parcial da conversão
    
    for (int i = 0; str[i] != '\0'; i++) {
        // Se o caractere não for um dígito, termina a conversão...
        if (str[i] < '0' || str[i] > '9') break;
        
        // Converte o dígito corrente...
        dig = str[i] - '0';
        
        // Termina com erro e valor 0 se a próxima conversão exceder UINT_MAX...
        if (conv > (UINT_MAX - dig) / 10) return 0;

        // Processa a parcial da conversão...
        conv = (conv * 10) + dig;
    }
    
    if (err) *err = 1;  // Altera estado para sucesso (1 = verdadeiro)
    return conv;
}
#+end_src

** Exemplo de uso

Arquivo: [[exemplos/08/uint.c][uint.c]]

#+begin_src c :tangle exemplos/08/uint.c
/*
 * Arquivo   : uint.c
 * Compilação: gcc -Wall uint.c -o uintc
 */
#include <stdio.h>
#include <limits.h> // Requerido para obter UINT_MAX da plataforma

unsigned int str_to_uint(char *str, int *err /* nullable */);

int main(int argc, char **argv) {
    if (argc == 1) {
        fprintf(stderr, "Uso: %s NÚMERO\n", argv[0]);
        return 1;
    }

    int status;
    unsigned int num = str_to_uint(argv[1], &status);

    if (status) {
        printf("String: %s\nNúmero: %u\n", argv[1], num);
    } else {
        fprintf(stderr, "Erro de conversão!\n");
        return 1;
    }

    return 0;
}

unsigned int str_to_uint(char *str, int *err /* nullable */) {
    if (err) *err = 0;  // Estado padrão é de erro (0 = falso)!
    
    // Termina com erro e valor 0 se str==NULL ou se '0'>str[0]>'9'...
    if (str == NULL || str[0] < '0' || str[0] > '9') return 0;
   
    int dig;               // Recebe o dígito convertido
    unsigned int conv = 0; // Recebe a parcial da conversão
    
    for (int i = 0; str[i] != '\0'; i++) {
        // Se o caractere não for um dígito, termina a conversão...
        if (str[i] < '0' || str[i] > '9') break;
        // Converte o dígito corrente...
        dig = str[i] - '0';
        // Termina com erro e valor 0 se a próxima conversão exceder UINT_MAX...
        if (conv > (UINT_MAX - dig) / 10) return 0;
        // Processa a parcial da conversão...
        conv = (conv * 10) + dig;
    }
    
    if (err) *err = 1;  // Altera estado para sucesso (1 = verdadeiro)
    return conv;
}
#+end_src

Compilação e testes:

#+begin_example
:~$ gcc -Wall uint.c -o uintc
$ ./uintc
Uso: ./uintc NÚMERO
:~$ ./uintc 123
String: 123
Número: 123
:~$ ./uintc 123abc
String: 123abc
Número: 123
:~$ ./uintc $((2**32))
Erro de conversão!
:~$ ./uintc $((2**32 - 1))
String: 4294967295
Número: 4294967295
:~$ ./uintc ''
Erro de conversão!
:~$ ./uintc abc
Erro de conversão!
#+end_example

* Conversão para inteiros sem sinal em baixo nível

Em Assembly, o procedimento de conversão ainda é o mesmo:

#+begin_example
val = 0
val = (val * 10) + (0x31 - 0x30) =   0 + 1 = 1
val = (val * 10) + (0x32 - 0x30) =  10 + 2 = 12 
val = (val * 10) + (0x33 - 0x30) = 120 + 3 = 123
#+end_example

Que pode ser implementado, de forma genérica, com uma sub-rotina assim:

#+begin_src asm
_str_to_uitn:
    ; ------------------------------------------------------
    ; Entrada: RSI = Endereço da string (char * str)
    ; Saída  : RAX = Valor convertido (unsigned int)
    ; ------------------------------------------------------
    ; Preparação...
    ; ------------------------------------------------------
    push rbx              ; Salva conteúdo de rbx
    xor rax, rax          ; rax = 0 (acumula a conversão)
    xor rbx, rbx          ; rbx = 0 (recebe os caracteres no loop)
    ; ------------------------------------------------------
.conv_loop:
    ; ------------------------------------------------------
    ; Condições de término do loop...
    ; ------------------------------------------------------
    mov bl, [rsi]         ; Lê o primeiro byte
    test bl, bl           ; Compara primeiro byte com o terminador '\0'
    je .done              ; Se 0x00, termina o loop
    cmp bl, 0x30          ; Compara primeiro byte com '0'
    jl .done              ; Se menor, termina o loop
    cmp bl, 0x39          ; Compara primeiro byte com '9'
    jg .done              ; Se maior, termina o loop
    ; ------------------------------------------------------
    ; Conversão...
    ; ------------------------------------------------------
    sub rbx, 0x30         ; Subtrai '0' do byte (dígito convertido)
    imul rax, rax, 10     ; rax *= 10 (deslocamento do peso posicional)
    add rax, rbx          ; rax += dígito convertido
    inc rsi               ; Avança rdi para o próximo byte
    jmp .conv_loop        ; Volta ao início do loop de conversão
    ; ------------------------------------------------------
.done:
    ; ------------------------------------------------------
    pop rbx               ; Restaura rbx
    ret
#+end_src

Isso equivale à primeira versão da função em C e traz os mesmos problemas:

- Não verifica se o valor convertido excede o limite máximo para inteiros sem
  sinal da plataforma;
- Não verifica se o ponteiro para a string é nulo (=NULL=);
- Retorna =0= tanto para a conversão da string ="0"= quanto para uma string sem
  dígitos nos primeiros caracteres.

Além disso, se quisermos adaptar a sub-rotina para uso em um programa em C
(em um objeto compartilhado, por exemplo) ela precisa seguir as convenções
da ABI. Do jeito que está, ela já poderia ser utilizada, porque recebe o
primeiro argumento em =rdi= e retorna o valor convertido em =rax=, mas ainda
precisamos decidir como implementar a sinalização de erros. Na função em C,
isso é feito com um ponteiro opcional (/nullable/) para a variável que receberá
o estado de erro:

#+begin_src c
unsigned int str_to_uint(char *str, int *err /* nullable */);
#+end_src

A ABI determina que o segundo argumento deve ser recebido em =rdx=, então a
assinatura da sub-rotina passaria a ser:

#+begin_src asm
_str_to_uitn:
    ; ------------------------------------------------------
    ; Entrada:
    ;     RSI = Endereço da string (char * str)
    ;     RDX = Endereço da variável de erro (int *err)
    ; Saída  :
    ;     RAX = Valor convertido (unsigned int)
    ;     Se sucesso: *err = 1 (verdadeiro)
    ;     Se erro   : *err = 0 (falso)
    ; ------------------------------------------------------
#+end_src

Ainda na função em C, nós decidimos definir o estado de =*err= logo no início
e só alterá-lo antes do retorno com sucesso. Como o argumento pode receber
um ponteiro nulo (=NULL=), o estado de término foi definido condicionalmente:

#+begin_src c
if (err) *err = 0;  // Estado padrão é de erro (0 = falso)!
// ...
if (err) *err = 1;  // Altera estado para sucesso (1 = verdadeiro)
return conv;
#+end_src

Além disso, sempre que a função terminava com erro, o valor retornado era
definido com =0=, e isso também deve ser implementado na sub-rotina:

#+begin_src asm
_str_to_uitn:
    ; ------------------------------------------------------
    ; Entrada:
    ;     RSI = Endereço da string (char * str)
    ;     RDX = Endereço da variável de erro (int *err /* nullable */)
    ; Saída  :
    ;     RAX = Valor convertido (unsigned int)
    ;     Se sucesso: *err = 1 (verdadeiro)
    ;     Se erro   : *err = 0 (falso)
    ; ------------------------------------------------------
    ; Definição condicional do estado inicial de erro...
    ; ------------------------------------------------------
    test rdx, rdx         ; Se *err = NULL, rdx = 0
    jz .skip_error        ; Se for 0, pula a definição do erro
    mov dword [rdx], 0    ; *err = 0 => estado inicial é de erro (falso)
    ; ------------------------------------------------------
.skip_error:
    ; ------------------------------------------------------

    ; ...

    ; ------------------------------------------------------
.error:
    ; ------------------------------------------------------
    xor rax, rax          ; Retorna 0 em caso de erro
    jmp .done
    ; ------------------------------------------------------
.success:
    ; ------------------------------------------------------
    ; Redefinição condicional do estado final de sucesso...
    ; ------------------------------------------------------
    test rdx, rdx         ; Se *err = NULL, rdx = 0
    jz .done              ; Se for 0, pula a definição de sucesso
    mov dword [rdx], 1    ; *err = 1 => estado final é de sucesso (verdadeiro)
    ; ------------------------------------------------------
.done:
    ; ------------------------------------------------------
    pop rbx               ; Restaura rbx
    ret
#+end_src

Com o procedimento de tratamento de erros definido, nós podemos prosseguir
com a implementação das validações necessárias.

** Erro de ponteiro nulo

A primeira verificação que faremos é para o caso de =rsi= ter recebido um
ponteiro nulo na chamada:

#+begin_src asm
    ; ------------------------------------------------------
    ; Teste de ponteiro nulo...
    ; ------------------------------------------------------
    test rsi, rsi      ; verifica se enderçeo é nulo (0)
    jz .error          ; se for, termina retornando -1 (erro)
#+end_src

Deste modo, se =rsi= receber =0= (=NULL=, numa chamada em C), a sub-rotina salta
para o rótulo local =.error= e termina retornando =0= em =rax= e =1= no endereço
em =rdx=, se =*err= estiver definido.

** Erro de byte inicial fora da faixa de dígitos

Para que o primeiro byte seja verificado, ele precisa ser lido. Portanto,
a verificação da faixa de dígitos deve ser feita logo após a preparação
dos registradores utilizados, antes do /loop/ de conversão:

#+begin_src asm
    ; ------------------------------------------------------
    ; Preparação...
    ; ------------------------------------------------------
    push rbx           ; salva rbx na pilha
    xor rax, rax       ; rax = 0 (acumula o resultado)
    xor rbx, rbx       ; rbx = 0 (recebe os caracteres no loop)
    mov bl, [rsi]      ; lê o primeiro byte
    ; ------------------------------------------------------
    ; Validação do primeiro byte...
    ; ------------------------------------------------------
    cmp bl, 0x30       ; compara com menor byte válido
    jl .error          ; se menor, termina retornando -1
    cmp bl, 0x39       ; compara com maior byte válido
    jg .error          ; se maior, termina retornando -1
#+end_src

Assim, a sub-rotina salta para =.error= se o byte for menor que =0x30= (caractere
='0'=) ou maior que =0x39= (caractere ='9'=). 

** Erro de estouro do limite do tipo

Como vimos, o cálculo do maior valor que pode ser multiplicado por 10 na
conversão é feito com:

#+begin_example
(UINT_MAX - dígito) / 10
#+end_example

Contudo, essa verificação é um pouco mais complicada em Assembly, por alguns
motivos:

- Nós não temos um limite definido para a plataforma, como a constante
  simbólica =UINT_MAX=, da =glibc=.
- É possível definir =UINT_MAX= com uma macro no Assembly, mas não podemos
  contar com isso no caso de reutilização da sub-rotina, a menos que ela
  esteja em uma biblioteca que também contenha definições de macros.
- Também teremos que utilizar registradores auxiliares adicionais, porque,
  numa divisão, =rax= recebe o quociente e =rdx= o resto, e ambos estão em
  uso.

Mas /"complicada"/ não é /"impossível"/, e nós podemos assumir alguns critérios:

- A ABI define que inteiros terão 4 bytes (32 bits) em arquiteturas x86_64
  e as implementações da linguagem C no GCC e na Glibc garantem isso.
- O valor de =UINT_MAX= pode ser armazenado em =rcx= como =0xffffffff=, o maior
  número sem sinal que pode ser escrito com 4 bytes.
- Os registradores =r8= e =r10= podem ser usados para salvar e restaurar os
  dados em =rax= e =rdx=.
- O registrador =r9= pode ser usado para auxiliar nos cálculos.

Portanto, esta é uma implementação possível:

#+begin_src asm
; ------------------------------------------------------
; Limite válido: conv < (UINT_MAX - dígito) / 10
; ------------------------------------------------------
mov r8, rax           ; Salva parcial da conversão em r8
mov r10, rdx          ; Salva ponteiro de erro em r10

mov eax, -1           ; rax = 0x00000000ffffffff (UINT_MAX)
sub eax, ebx          ; rax = UINT_MAX - dígito (dividendo)

xor rdx, rdx          ; prepara rdx para receber o resto da divisão
mov r9, 10            ; divisor
div r9                ; limite(rax) = (UINT_MAX - dígito) / 10

cmp r8, rax           ; se parcial > limite, teremos um estouro
jg .error             ; se maior, termina com erro
	
mov rdx, r10          ; restaura rdx (pontiero para erros)
mov rax, r8           ; restaura rax (parcial da conversão)
#+end_src

** Implementação final em Assembly

Com alguns ajustes estéticos e na documentação, aqui está a implementação
completa...

Arquivo: [[exemplos/08/uint.asm][uint.asm]]

#+begin_src asm :tangle exemplos/08/uint.asm
; ----------------------------------------------------------
; Arquivo : uint.asm
; Montagem: nasm -g -f elf64 uint.asm
; Ligação : ls uint.o -o uint
; ----------------------------------------------------------
section .data
; ----------------------------------------------------------
    num_str db "123", 0   ; string numérica
; ----------------------------------------------------------
section .bss
; ----------------------------------------------------------
    num resd 1            ; 4 bytes para o valor UINT32
    status resd 1         ; 4 bytes para o estado de término
; ----------------------------------------------------------
section .text
global _start
; ----------------------------------------------------------
_start:
; ----------------------------------------------------------
; Teste de chamada (verificar com o GDB)...
; ----------------------------------------------------------
    mov rsi, num_str      ; copia endereço da string em rsi
    mov rdx, status       ; copia o endereço do estado de erro em rdx
    call _str_to_uint     ; chama a sub-rotina de conversão
    mov dword [num], eax  ; copia o resultado como int para [num]
; ----------------------------------------------------------
_exit:
; ----------------------------------------------------------
    mov rax, 60
    mov rdi, 0
    syscall
; ----------------------------------------------------------
; Sub-rotinas...
; ----------------------------------------------------------
_str_to_uint:
; ----------------------------------------------------------
; Converte string numérica em inteiro sem sinal (uint32_t).
; Entradas:
;   RSI = Endereço da string (char *str)
;   RDX = Endereço para estado de erro (int *err /* nullable */)
; Saída:
;   RAX = valor convertido (uint32_t) ou 0, no caso de erro
;   Sucesso: *rdx = 1
;   Erro:    *rdx = 0
; ----------------------------------------------------------
    ; Definição condicional do estado inicial de erro...
    ; ------------------------------------------------------
    test rdx, rdx         ; Se *err = NULL, rdx = 0
    jz .skip_error        ; Se for 0, pula a definição do erro
    mov dword [rdx], 0    ; *err = 0 => estado inicial é de erro (falso)
    ; ------------------------------------------------------
.skip_error:
    ; ------------------------------------------------------
    ; Teste de ponteiro nulo...
    ; ------------------------------------------------------
    test rsi, rsi         ; verifica se enderçeo é nulo (0)
    jz .error             ; se for, termina retornando -1 (erro)
    ; ------------------------------------------------------
    ; Preparação...
    ; ------------------------------------------------------
    push rbx              ; salva rbx na pilha
    xor rax, rax          ; rax = 0 (acumula o resultado)
    xor rbx, rbx          ; rbx = 0 (recebe os caracteres no loop)
    mov bl, [rsi]         ; lê o primeiro byte
    ; ------------------------------------------------------
    ; Validação do primeiro byte...
    ; ------------------------------------------------------
    cmp bl, 0x30          ; compara com menor byte válido
    jl .error             ; se menor, termina retornando -1
    cmp bl, 0x39          ; compara com maior byte válido
    jg .error             ; se maior, termina retornando -1
.conv_loop:
    ; ------------------------------------------------------
    ; Condições de término da conversão ...
    ; ------------------------------------------------------
    test bl, bl           ; verifica se o byte é o terminador 0x00
    je .success           ; se for, termina com sucesso
    cmp bl, 0x30          ; compara o byte em rbx com o menor dígito
    jl .success           ; se for menor, termina com sucesso
    cmp bl, 0x39          ; compara o byte em rbx com o maior dígito
    jg .success           ; se for maior, termina com sucesso
    ; ------------------------------------------------------
    ; Conversão do dígito corrente...
    ; ------------------------------------------------------
    sub rbx, 0x30         ; converte o dígito para seu valor numérico
    ; ------------------------------------------------------
    ; Limite válido: conv < (UINT_MAX - dígito) / 10
    ; ------------------------------------------------------
    mov r8, rax           ; Salva parcial da conversão em r8
    mov r10, rdx          ; Salva ponteiro de erro em r10
    
    mov eax, -1           ; eax = 0xffffffff (UINT_MAX - 32 bits)
    sub eax, ebx          ; rax = UINT_MAX - dígito (dividendo)
    
    xor rdx, rdx          ; prepara rdx para receber o resto da divisão
    mov r9, 10            ; divisor
    div r9                ; limite(rax) = (UINT_MAX - dígito) / 10
    
    cmp r8, rax           ; se parcial > limite, teremos um estouro
    jg .error             ; se maior, termina com erro
    	
    mov rdx, r10          ; restaura rdx (pontiero para erros)
    mov rax, r8           ; restaura rax (parcial da conversão)
    ; ------------------------------------------------------
    ; Processa a parcial da conversão...
    ; ------------------------------------------------------
    imul rax, rax, 10     ; rax *= 10 (deslocamento do peso posicional)
    add rax, rbx          ; rax += novo algarismo
    inc rsi               ; avança para o próximo byte
    mov bl, [rsi]         ; carrega o dígito corrente em rbx
    jmp .conv_loop
    ; ------------------------------------------------------
.error:
    ; ------------------------------------------------------
    xor rax, rax          ; Retorna 0 em caso de erro
    jmp .done
    ; ------------------------------------------------------
.success:
    ; ------------------------------------------------------
    ; Redefinição condicional do estado final de sucesso...
    ; ------------------------------------------------------
    test rdx, rdx         ; Se *err = NULL, rdx = 0
    jz .done              ; Se for 0, pula a definição de sucesso
    mov dword [rdx], 1    ; *err = 1 => estado final é de sucesso (verdadeiro)
    ; ------------------------------------------------------
.done:
    ; ------------------------------------------------------
    pop rbx               ; Restaura rbx
    ret
#+end_src

** Teste com o GDB

Nosso objetivo é testar se a string em =num_str= é convertida corretamente
pela análise dos valores em =rax= e =rdx= (=status=) após a chamada da sub-rotina
neste trecho do programa:

#+begin_src asm
; ----------------------------------------------------------
section .data
; ----------------------------------------------------------
    num_str db "123", 0   ; string numérica
; ----------------------------------------------------------
section .bss
; ----------------------------------------------------------
    num resd 1            ; 4 bytes para o valor UINT32
    status resd 1         ; 4 bytes para o estado de término
; ----------------------------------------------------------
section .text
global _start
; ----------------------------------------------------------
_start:
; ----------------------------------------------------------
; Teste de chamada (verificar com o GDB)...
; ----------------------------------------------------------
    mov rsi, num_str      ; copia endereço da string em rsi
    mov rdx, status       ; copia o endereço do estado de erro em rdx
    call _str_to_uint     ; chama a sub-rotina de conversão
    mov dword [num], eax  ; copia o resultado como int para [num]
#+end_src

*Montagem e execução no GDB:*

#+begin_example
:~$ nasm -g -f elf64 uint.asm
:~$ ld uint.o -o uint
:~$ gdb ./uint
Reading symbols from ./uint...
(gdb) break _start
Breakpoint 1 at 0x401000: file uint.asm, line 22.
(gdb) run
Starting program: /home/blau/git/pbn/curso/exemplos/08/uint

Breakpoint 1, _start () at uint.asm:22
22	    mov rsi, num_str      ; copia endereço da string em rsi
(gdb)
#+end_example

*Execução e verificações antes da chamada:*

#+begin_example
(gdb) n 2
24	    call _str_to_uint     ; chama a sub-rotina de conversão
(gdb) info registers rax rdx rsi
rax            0x0                 0
rdx            0x402008            4202504
rsi            0x402000            4202496
(gdb) x /1wx &num_str
0x402000 <num_str>:	0x00333231
(gdb) x /1s &num_str
0x402000 <num_str>:	"123"
(gdb) x /1wx &num_
No symbol "num_" in current context.
(gdb) x /1wx &num
0x402004 <num>:	0x00000000
(gdb) x /1wx &status
0x402008 <status>:	0x00000000
#+end_example

*Execução e verificações após a chamada:*

#+begin_example
(gdb) n
25	    mov dword [num], eax  ; copia o resultado para [num]
(gdb) n
_exit () at uint.asm:29
29	    mov rax, 60
(gdb) info registers rax rdx rsi
rax            0x7b                123
rdx            0x402008            4202504
rsi            0x402003            4202499
(gdb) x /1wx &num
0x402004 <num>:	0x0000007b
(gdb) print (int)num
$1 = 123
(gdb) x /1wx &status
0x402008 <status>:	0x00000001
#+end_example

* Conversão para inteiros com sinal

No Assembly x86_64, números com sinal são representados usando o método do
/complemento de dois/. Tomando um inteiro de 32 bits como exemplo, se o bit
mais significativo (MSB, o bit mais a esquerda) for =0=, o número é interpretado
como positivo ou zero; se for =1=, o número é negativo. Em outras palavras, o
bit mais a esquerda de um número é o seu sinal.

O complemento de dois de um número binário é obtido pela inversão de todos
os seus bits (com uma operação =NOT= bit a bit) seguida da soma de 1:

#+begin_example
       00000000 00000000 00000000 00000101 =  5  (0x0005)
NOT -> 11111111 11111111 11111111 11111010 = -6  (0xFFFA)
 +1 -> 11111111 11111111 11111111 11111011 = -5  (0xFFFB)
#+end_example

** Interpretação do sinal

Se o MSB de um número for =1=, o que acontecerá sempre que o byte (não bit)
mais significativo de seu valor em hexadecimal iniciar com =8= ou mais, o
número poderá ser interpretado como negativo ou positivo -- tudo depende
do contexto. Por exemplo, o número 2.147.483.648, se escrito com 4 bytes
em hexa, será =0x80000000= e seu equivalente binário será:

#+begin_example
10000000 00000000 00000000 00000000 = 0x80 00 00 00 = 2.147.483.648
#+end_example

Digamos que esse número seja escrito em =edx= (32 bits) e seja utilizado em
uma chamada de função que espera um argumento inteiro sem sinal. Neste caso,
o valor será tomado como positivo, mesmo que o binário inicie com =1=. Porém,
considere esta situação:

#+begin_src asm
mov eax, 0x80000000
cmp eax, 0
#+end_src

A instrução =cmp= calcula =eax - 0= e configura as flags de acordo com o valor
em =eax= e o resultado da operação:

- Flag =SF=: foi definida com =1= porque o MSB do resultado é =1= (negativo).
- Flag =OF=: como não houve /overflow/ na operação, seu valor foi definido como =0=.
- Flag =CF=: como a operação não provocou um "vai um" ou um empréstimo fora
  do limite representável em 32 bits (capacidade de =eax=), seu valor foi
  definido como =0=.

Neste ponto, a interpretação do sinal do valor em =eax= vai depender do que
faremos com o resultado da comparação. Observe esta possibilidade:

#+begin_src asm
	mov eax, 0x80000000
	cmp eax, 0  ; resulta 0x80000000 -> SF=1 e OF=0
	jl .menor   ; Se SF != OF, o salto acontece
	; ...
.menor:
	; ...
#+end_src

A instrução =jl= (/jump if less/) avalia se as flags =SF= e =OF= são diferentes: se
forem, o salto é feito. Portanto, =jl= levaria em conta o sinal do resultado
da subtração e salto aconteceria porque =eax < 0=. Mas, e neste caso?

#+begin_src asm
	mov eax, 0x80000000
	cmp eax, 0  ; resulta 0x80000000 -> SF=1 e OF=0
	jb .menor   ; Se CF = 1, o salto acontece
	; ...
.menor:
	; ...
#+end_src

Já a instrução =jb= (/jump if below/) só salta se =CF=1=, mas o resultado da
subtração (=eax-0=) não provocou um "vai um" ou um empréstimo fora do limite
do registrador: portanto, seu valor será =0= e o salto não acontecerá. Isso
significa que, como =jb= não leva em conta o sinal, =0x80000000= foi interpretado
como um valor acima de zero.

Por outro lado, se utilizássemos =rax= em vez de =eax=...

#+begin_src asm
	mov rax, 0x80000000 ; 0x0000000080000000
	cmp rax, 0          ; CF=0 SF=0 e OF=0
	jb .menor           ; CF=0, não salta
	jl .menor           ; SF=OF, não salta
	; ...
.menor:
	; ...
#+end_src

Desta forma, não há ambiguidades quanto à interpretação do sinal.

** Uma nota sobre as flags

É importante entender corretamente o conceito por detrás da /carry flag/,
porque, em operações sem sinal, é ela que indica se um número é menor do
que outro.

Então, vejamos: =10= é menor do que =14=?

#+begin_src asm
mov al, 10  ; 10 = 1010 = 0x0A
cmp al, 14  ; 14 = 1110 = 0xFE
#+end_src

A instrução =cmp= fará a subtração...

#+begin_example
   Aqui, temos que fazer um empréstimo e o MSB de 10 será 0...
   ↓
  1010
- 1110
------
    00

  Agora é o MSB que requer um empréstimo!
  ↓
  0110
- 1110
------
  ?100
#+end_example

Numa situação desas, onde não há mais de onde emprestar um bit =1= mais a
esquerda, o processador efetua a subtração, como se houvesse de onde tirar
o bit 1 de que precisa, sobe a flag =CF= (indicando que houve um empréstimo
fora do limite dos operandos) e a flag =SF= (indicando que o resultado é
negativo). Ao mesmo tempo, =OF= e =ZF= receberiam =0=, porque não houve estouro
do limite do valor representável com sinal e o resultado não foi zero.

Na operação acima, nós teríamos:

#+begin_example
  CF=1
  ↓
 (1)0110
  - 1110
  ------
    1100 = -4 ← ZF=0 (não é zero)
    ↑
    SF=1
    OF=0 (é possível escrever em 4 bits)
#+end_example

#+begin_quote
O processador não possui circuitos capazes de efetuar subtrações e, por isso,
não executaria a operação desta forma, e sim calculando o complemento de dois
de =-14= (=0010=) para, em seguida, somar com =10=: ~1010+0010 = 1100 (-4)~.
#+end_quote

** Limites de inteiros com sinal

Assumindo que inteiros são escritos com 4 bytes, o maior valor absoluto
que podemos representar ainda é =0xFFFFFFFF=, mas ele teria que ser visto
como um número negativo. Calculando seu complemento de dois...

#+begin_example
       11111111 11111111 11111111 11111111 (0xFFFFFFFF)
NOT -> 00000000 00000000 00000000 00000000
 +1 -> 00000000 00000000 00000000 00000001 => (1)
#+end_example

Portanto, levando em conta o sinal, =0xFFFFFFFF= é =-1=.

Como o bit mais significativo representa o sinal, o primeiro dígito do byte
mais significativo do maior número positivo que pode ser escrito em hexa tem
que ser =7=:

#+begin_example
Maior byte positivo: 0x7f = 0111 1111 = 127
#+end_example

Se somarmos =1= a =0x7F=, nós chegaremos a =0x80= (128), que será interpretado como
um número negativo: 

#+begin_example
0x7F -> 0111 1111
  +1 -> 1000 0000 = 0x80 = -128
        ↑                  ↑
        SF=1 -------------´
#+end_example

Então, se o inteiro com sinal tiver 1 byte, seus limites serão:

#+begin_example
0x7F = 0111 1111 = +127
0x7E = 0111 1110 = +126
...
0x01 = 0000 0001 =   +1
0x00 = 0000 0000 =    0
0xFF = 1111 1111 =   -1
...
0x81 = 1000 0001 = -127
0x80 = 1000 0000 = -128
#+end_example

Transpondo o princípio para o tamanho de um inteiro na arquitetura x86_64,
os limites são:

#+begin_example
0x7FFFFFFF ->  2.147.483.647
0x80000000 -> -2.147.483.648
#+end_example

** Procedimento de conversão para inteiros com sinal

As diferenças em relação à conversão de strings para inteiros sem sinal são:

- Antes da conversão, nós precisamos detectar a presença dos caracteres
  de sinal (=+= e =-=);
- Depois do valor absoluto encontrado, nós teremos que verificar se ele está
  na faixa de valores inteiros com sinal (entre =0x7FFFFFFF= e =0x80000000=);
- No final, se o número passar na verificação, nós teremos que calcular seu
  complemento de dois, o que pode ser feito multiplicando o valor por =-1= ou,
  de forma ainda mais compacta e eficiente, utilizando a instrução =neg=.

Todo o restante do procedimento é idêntico, tanto que podemos reutilizar
as mesmas funções de antes para a etapa de conversão.

** Conversão em alto nível

Com base no procedimento geral, esta seria uma forma de implementar a
conversão de inteiros com sinal em linguagem C reutilizando a função que
criamos para converter inteiros sem sinal:

#+begin_src c
#include <limits.h> // Requerido para obter INT_MAX e INT_MIN da plataforma

int str_to_sint(char *str, int *err) {
    if (err) *err = 0;          // Flag de estado de término: 0 = erro
    if (str == NULL) return 0;  // Teste do ponteiro para a string

    // Verificação e atrubuição do sinal da string...
    char sig = '+';             // Sinal padrão
    if (str[0] == '+' || str[0] == '-') {
        sig = str[0];
        str++;                  // Avança o ponteiro da string
    }

    // Chama a função de conversão de inteiros sem sinal...
    unsigned conv = str_to_uint(str, err);
    if (!*err) return 0;

    // Verificação da faixa de inteiros com sinal...
    if (sig == '-') {
        // INT_MIN=-2147483648, que em unsigned é 2147483648
        if (conv > (unsigned)INT_MAX + 1) return 0;    
        if (err) *err = 1;    // Flag de estado de término: 1 = sucesso
        return -(int)conv;
    } else {
       if (conv > INT_MAX) return 0;
       if (err) *err = 1;    // Flag de estado de término: 1 = sucesso
       return (int)conv; 
    }
}
#+end_src

#+begin_quote
Agora cabe a você, como parte dos exercícios propostos, elaborar e executar
os testes e os ajustes, se forem necessários.
#+end_quote

** Conversão em baixo nível

Esta seria uma solução equivalente implementada como uma sub-rotina que
depende de =_str_to_uint=, criada e testada anteriormente:

#+begin_src asm
; ----------------------------------------------------------
_str_to_sint:
; ----------------------------------------------------------
; Converte string numérica com sinal em inteiro (int32_t).
; Entradas:
;   RSI = Endereço da string (char *str)
;   RDX = Endereço para estado de erro (int *err /* nullable */)
; Saída:
;   RAX = valor convertido (int32_t)
;   Sucesso: *rdx = 1
;   Erro:    *rdx = 0
; ----------------------------------------------------------
    push rbx             ; salva rbx
    push rcx             ; salva rcx
    xor rcx, rcx         ; rcx = 0 (sinal: 0 = positivo, 1 = negativo)
    ; ------------------------------------------------------
    ; Testa ponteiro nulo
    ; ------------------------------------------------------
    test rsi, rsi
    jz .error
    ; ------------------------------------------------------
    ; Verifica o sinal na string
    ; ------------------------------------------------------
    mov bl, [rsi]
    cmp bl, '-'          ; caractere de sinal negativo?
    jne .check_plus
    inc rcx              ; rcx = 1 => negativo
    inc rsi              ; avança o ponteiro
    jmp .convert
.check_plus:
    cmp bl, '+'          ; caractere de sinal positivo?
    jne .convert
    inc rsi              ; ignora '+'
.convert:
    ; ------------------------------------------------------
    ; Chama _str_to_uint
    ; ------------------------------------------------------
    call _str_to_uint    ; RSI = str, RDX = err, RAX = resultado (uint32_t)
    ; ------------------------------------------------------
    ; Verifica se _str_to_uint retornou erro
    ; ------------------------------------------------------
    test rdx, rdx
    jz .check_sign
    cmp dword [rdx], 0
    je .error
.check_sign:
    test rcx, rcx        ; se rcx = 1, é número negativo
    jz .check_range_pos
    ; ------------------------------------------------------
    ; Verifica se valor cabe em int32_t negativo
    ; ------------------------------------------------------
    cmp eax, 0x80000000
    ja .error            ; se maior que INT_MAX + 1 -> erro

    neg eax              ; aplica o sinal negativo
    jmp .success
.check_range_pos:
    ; ------------------------------------------------------
    ; Verifica se valor cabe em int32_t positivo
    ; ------------------------------------------------------
    cmp eax, 0x7fffffff
    ja .error            ; maior que INT_MAX -> erro
.success:
    test rdx, rdx
    jz .done
    mov dword [rdx], 1   ; *err = 1
    jmp .done
.error:
    xor eax, eax         ; valor de erro = 0
    test rdx, rdx
    jz .done
    mov dword [rdx], 0   ; *err = 0
.done:
    pop rcx
    pop rbx
    ret
#+end_src

#+begin_quote
Também faz parte dos exercícios propostos, elaborar e executar os testes
e os ajustes, se forem necessários.
#+end_quote

* Exercícios propostos

1. Tanto a função quanto a sub-rotina têm alguns problemas práticos não contemplados, como:
   - Não tratam strings iniciadas com espaços em branco;
   - Não tratam números com zeros à esquerda.
   Inclua esses tratamentos em ambas as implementações de conversão.  
2. Altere o valor em =num_str=, nos testes da sub-rotina =_str_to_uint=, e
   analise os resultados com o GDB.
3. Em C, crie as funções =str_to_ulong= (string para inteiros longos sem sinal)
   e =str_to_slong= (string para inteiros longos com sinal).
4. Em Assembly, crie as sub-rotinas =_str_to_ulong= e =_str_to_slong=.
5. Implemente predicados (funções que retornam verdadeiro ou falso) para detectar:
   - Se a string representa um número (=is_num=);
   - Se o número representado é do tipo =int= (=is_int=);
   - Se o número representado é do tipo =long= (=is_long=);
   - Se o número representado é positivo (=is_pos=).
6. Só para aproveitar o embalo, crie uma função para detectar se uma cadeia de
   caracteres é uma string (=is_string=).

