História da Linguagem C: Parte 2

No princípio... não, não, não. Antes do princípio, quando C era considerada a terceira letra do alfabeto e o que tínhamos eram linguagens experimentais para todos os lados, dois famigerados senhores dos Laboratórios Bell, K. Thompson e D. Ritchie, criaram uma linguagem chamada B. E B era bom.

O bom de B era sua rica expressividade e sua simples gramática. Tão simples que o manual da linguagem consistia de apenas 30 páginas. Isso é menos do que as 32 palavras reservadas de C. As instruções eram definidas em termos de ifs e gotos e as variáveis eram definidas em termos de um padrão de bits de tamanho fixo, geralmente a word, ou palavra, da plataforma, que utilizada em expressões definiam seu tipo. Esse padrão de bits era chamado rvalue. Imagine a linguagem C de hoje em dia com apenas um tipo: int.

Como esse padrão de bits nunca muda de tamanho, todas as rotinas da biblioteca recebiam e retornavam sempre valores do mesmo tamanho na memória. Isso na linguagem C quer dizer que o char da época ocupava tanto quanto o int. Existia inclusive uma função que retornava o caractere de uma string na posição especificada:

c = char(string, i); /* the i-th character of the string is returned */

Sim! Char era uma função, um conversor de "tipos". No entanto a própria variável que armazenava um char tinha o tamanho de qualquer objeto da linguagem. Esse é o motivo pelo qual, tradicionalmente, as seguintes funções recebem e retornam ints em C e C++:

int getchar( void ); // read a character from stdin
int putchar( int c ); // writes a character to stdout
void *memset( void *dest, int c, size_t count ); // sets buffers to a specified character

Segue o exemplo de uma função na linguagem B, hoje muito famosa:

/* The following function is a general formatting, printing, and
   conversion subroutine.  The first argument is a format string.
   Character sequences of the form `%x' are interpreted and cause
   conversion of type 'x' of the next argument, other character
   sequences are printed verbatim.   Thus

  printf("delta is %d*n", delta);

  will convert the variable delta to decimal (%d) and print the
  string with the converted form of delta in place of %d.   The
  conversions %d-decimal, %o-octal, *s-string and %c-character
  are allowed.

  This program calls upon the function `printn'. (see section
  9.1) */

printf(fmt, x1,x2,x3,x4,x5,x6,x7,x8,x9) {
  extrn printn, char, putchar;
  auto adx, x, c, i, j;

  i= 0;  /* fmt index */
  adx = &x1;  /* argument pointer */
loop :
  while((c=char(fmt,i++) ) != `%') {
    if(c == `*e')
      return;
    putchar(c);
  }
  x = *adx++;
  switch c = char(fmt,i++) {

  case `d': /* decimal */
  case `o': /* octal */
    if(x < O) {
      x = -x ;
      putchar('-');
    }
    printn(x, c=='o'?8:1O);
    goto loop;

  case 'c' : /* char */
    putchar(x);
    goto loop;

  case 's': /* string */
    while(c=char(x, j++)) != '*e')
      putchar(c);
    goto loop;
  }
  putchar('%') ;
  i--;
  adx--;
  goto loop;
}

Como podemos ver, vários elementos (se não todos) da linguagem C já estão presentes na B.