Este blog agora funciona sem JavaScript

2024-04-05T14:39:42.000Z

No leiaute deste blog existiam 3 arquivos JavaScript que eram carregados basicamente para deixar o menu colapsado em telas pequenas. Eu removi esses arquivos e adotei uma solução muito mais simples e inteligente que é a de nunca esconder o menu. Agora, em telas pequenas, ele é exibido por completo abaixo do título do blog.

Porém, existem duas exceções. A primeira é para as publicações da série de Músicas Aleatórias de #sexta¹, pois elas possuem vídeos incorporados de outros sites que podem carregar scripts externos. Mas o link para os vídeos sempre está disponível na publicação, portanto é possível assistir diretamente no site original. A segunda é que para navegadores antigos (mais especificamente Internet Explorer 8 ou inferior), onde o JavaScript ainda é necessário por conta da incompatibilidade com funcionalidades do HTML5 e CSS3.

Outra semiexceção é que duas fontes personalizadas que são usadas no leiaute, e estas podem ser bloqueadas caso exista alguma extensão como o NoScript² instalada no navegador. Caso isso aconteça, são carregadas fontes padrão do sistema, então, novamente, sem muitos problemas.

Eu também troquei o Bootstrap para uma versão hospedada no próprio domínio, assim não é necessário acessar CDNs externos. Em algum momento vou tentar remover este também e criar estilos totalmente personalizados, mas esse dia não será hoje.

1.
Série “Músicas Aleatórias de #sexta”.↩
2.
Link: https://noscript.net (em inglês).↩

Lista de dados em C/C++ com X macros

2023-09-18T12:41:34.000Z

Recentemente enquanto assistia a um vídeo do Tsoding(em inglês) fui apresentado a uma técnica extremamente útil e relativamente simples para geração código a partir de uma lista de dados. A técnica chamada de “X macro” utiliza o pré-processador do C e C++ para criar uma lista de macros a ser definida no momento da utilização. Por exemplo, suponha-se que seja necessária uma lista fixa de arquivos que precisam ser utilizados pela aplicação. Inicialmente cria-se uma macro que define uma lista de utilizações de uma outra macro X que ainda não foi definida:

#define LISTA_ARQUIVOS                                        \
    X("C:\\\\Users\\juninho-pimpao\\Documents\\arquivo1.txt") \
    X("C:\\\\Users\\juninho-pimpao\\Documents\\arquivo2.txt") \
    X("C:\\\\Users\\juninho-pimpao\\Documents\\arquivo3.txt")

Esta macro não pode ser utilizada enquanto a macro X não for definida. A definição fica a cargo da utilização em um contexto específico. O nome X é só uma convenção, pode ser qualquer coisa desde que seja o mesmo nome para todos os valores definidos.

O exemplo seguinte imprime os nomes dos arquivos no console:

#define X(nome) printf("- " nome "\n");
    LISTA_ARQUIVOS
#undef X

Na primeira linha é definida uma macro X que imprime no console uma linha com valor passado precedido de "- ". A segunda linha expande a macro original substituindo cada linha pelo que foi definido na macro X. Por último, a macro X é “desdefinida” para que possa ser utilizada novamente em outro lugar. O código acima gera a seguinte linha:

printf("- " "C:\\\\Users\\juninho-pimpao\\Documents\\arquivo1.txt" "\n");
printf("- " "C:\\\\Users\\juninho-pimpao\\Documents\\arquivo2.txt" "\n");
printf("- " "C:\\\\Users\\juninho-pimpao\\Documents\\arquivo3.txt" "\n");

O código todo é gerado na mesma linha, mas o ponto e vírgula garante que as expressões sejam interpretadas corretamente. Segue o exemplo completo:

#include <stdio.h>

#define LISTA_ARQUIVOS                                        \
    X("C:\\\\Users\\juninho-pimpao\\Documents\\arquivo1.txt") \
    X("C:\\\\Users\\juninho-pimpao\\Documents\\arquivo2.txt") \
    X("C:\\\\Users\\juninho-pimpao\\Documents\\arquivo3.txt")

int main() {
    printf("Arquivos a serem carregados:\n");

#define X(nome) printf("- " nome "\n");
    LISTA_ARQUIVOS
#undef X

    return 0;
}

que imprime isso no console:

Arquivos a serem carregados:
- C:\\Users\juninho-pimpao\Documents\arquivo1.txt
- C:\\Users\juninho-pimpao\Documents\arquivo2.txt
- C:\\Users\juninho-pimpao\Documents\arquivo3.txt

O que pode ser feito fica a cargo da imaginação do programador e dos limites do pré-processador. O código a seguir complementa o anterior imprimindo também o conteúdo dos arquivos:

#include <stdio.h>
#include <stdlib.h>

#define LISTA_ARQUIVOS                                        \
    X("C:\\\\Users\\juninho-pimpao\\Documents\\arquivo1.txt") \
    X("C:\\\\Users\\juninho-pimpao\\Documents\\arquivo2.txt") \
    X("C:\\\\Users\\juninho-pimpao\\Documents\\arquivo3.txt")

int main() {
    printf("Arquivos a serem carregados:\n");

#define X(nome) printf("- " nome "\n");
    LISTA_ARQUIVOS
#undef X

    printf("\nConteúdo dos arquivos\n");

#define X(nome)                                                   \
    {                                                             \
        printf("***************************\n");                  \
        printf(nome "\n");                                        \
        FILE* arquivo = fopen(nome, "r");                         \
        if (!arquivo) {                                           \
            printf("\nArquivo não encontrado!\n");                \
        } else {                                                  \
            char *conteudo = NULL;                                \
            size_t tamanho = 0;                                   \
            while (getline(&conteudo, &tamanho, arquivo) != -1) { \
                printf("%s", conteudo);                           \
            }                                                     \
        }                                                         \
    }

LISTA_ARQUIVOS
#undef X

    return 0;
}

Esta técnica é bastante útil para definir recursos (assets) em um jogo:

#include <stdlib.h>

#define TEXTURAS                             \
    X(1, TEXTURA_1, "imagens\\textura1.png") \
    X(2, TEXTURA_2, "imagens\\textura2.png") \
    X(3, TEXTURA_3, "imagens\\textura3.png") \
    X(4, TEXTURA_4, "imagens\\textura4.png")

#define X(id, nome, caminho) const unsigned int nome##_ID = id;
    TEXTURAS
#undef X

struct Texturas {
#define X(id, nome, caminho) void * nome##_ptr;
    TEXTURAS
#undef X
};

extern void * carrega_textura(const char * nome_arquivo);
extern void destroi_textura(void * textura);

int main() {

#define X(id, nome, caminho) void * nome##_ptr = carrega_textura(caminho);
    TEXTURAS
#undef X

    struct Texturas texturas;
#define X(id, nome, caminho) texturas.nome##_ptr = nome##_ptr;
    TEXTURAS
#undef X

#define X(id, nome, caminho)     \
    destroi_textura(nome##_ptr); \
    texturas.nome##_ptr = NULL;

    TEXTURAS
#undef X

    return 0;
}

que vai gerar o seguinte código (que foi formatado para facilitar a leitura):

#include <stdlib.h>

const unsigned int TEXTURA_1_ID = 1;
const unsigned int TEXTURA_2_ID = 2;
const unsigned int TEXTURA_3_ID = 3;
const unsigned int TEXTURA_4_ID = 4;

struct Texturas {
    void * TEXTURA_1_ptr;
    void * TEXTURA_2_ptr;
    void * TEXTURA_3_ptr;
    void * TEXTURA_4_ptr;
};

extern void * carrega_textura(const char * nome_arquivo);
extern void destroi_textura(void * textura);

int main() {

    void * TEXTURA_1_ptr = carrega_textura("imagens\\textura1.png");
    void * TEXTURA_2_ptr = carrega_textura("imagens\\textura2.png");
    void * TEXTURA_3_ptr = carrega_textura("imagens\\textura3.png");
    void * TEXTURA_4_ptr = carrega_textura("imagens\\textura4.png");

    struct Texturas texturas;

    texturas.TEXTURA_1_ptr = TEXTURA_1_ptr;
    texturas.TEXTURA_2_ptr = TEXTURA_2_ptr;
    texturas.TEXTURA_3_ptr = TEXTURA_3_ptr;
    texturas.TEXTURA_4_ptr = TEXTURA_4_ptr;

    destroi_textura(TEXTURA_1_ptr);
    texturas.TEXTURA_1_ptr = NULL;

    destroi_textura(TEXTURA_2_ptr);
    texturas.TEXTURA_2_ptr = NULL;

    destroi_textura(TEXTURA_3_ptr);
    texturas.TEXTURA_3_ptr = NULL;

    destroi_textura(TEXTURA_4_ptr);
    texturas.TEXTURA_4_ptr = NULL;

    return 0;
}

Algumas observações:

O código acima não vai compilar pois as funções carrega_textura e destroi_textura não foram definidas.
O pré-processador também vai substituir as chamadas as utilizações da macro NULL e #include <stdlib.h>, porém estas alterações foram omitidas para melhoras a legibilidade.

No exemplo a quantidade código gerado é semelhante que à utilizada na geração, mas é preciso lembrar que em uma aplicação real a quantidade de arquivos a ser carregada provavelmente seria muito maior. Além disso, a quantidade de código duplicado é reduzida, reduzindo também a possibilidade de erros de digitação e de “copia e cola”.

Teste

2023-09-12T13:12:00.000Z

A palavra “teste” vem originalmente do latim testum¹ (-a, -ae)² e significa “vaso de terra”, se referindo ao processo para determinar a pureza de metais os derretendo em vasos de barro cozido. Este processo estava relacionado à ideia de “verificar se está adequado”. Curiosamente, a palavra “testa” tem origem no mesmo termo e era utilizada de modo jocoso para descrever o “vaso da cabeça”. O termo em latim, por sua vez, está relacionada ao radical *téks-³ do proto-indo-europeu, que significa “tecer” ou “fabricar” e está presente em palavras como “tecnologia”⁴, “arquitetura”⁵, “tecido”⁶ e “texto”⁷.

1.
https://www.etymonline.com/word/test (em inglês)↩
2.
https://www.etymonline.com/word/tete (em inglês)↩
3.
https://www.etymonline.com/word/*teks- (em inglês)↩
4.
https://etimologia.com.br/tecnologia ↩
5.
https://etimologia.com.br/arquitetura/↩
6.
https://www.dicionarioetimologico.com.br/tecido/↩
7.
https://www.dicionarioetimologico.com.br/texto/↩

The Kass Boy - Tech

Este blog agora funciona sem JavaScript

Lista de dados em C/C++ com X macros

Teste