A linguagem

Léxico

Identificadores, comentários, literais e as palavras reservadas — como o fonte é lido.

Caixa e identificadores#

Fenner é sensível a maiúsculas. Nome e nome são identificadores diferentes, e cada palavra reservada tem uma única grafia: quase todas em minúsculas (begin, end, if), e algumas em maiúscula inicial (Exit, Break, Continue, True, False, TypeOf). Escrever Begin não é palavra reservada, e o compilador diz isso:

texto

p.fxp(2,1): Erro: esperado 'begin', mas encontrado identificador "Begin"

Break, Continue e Exit também são reservadas só com maiúscula inicial: break em minúscula é um identificador qualquer, e o compilador responde identificador não declarado: "break".

Um identificador começa por letra ou _ e segue com letras, dígitos e _. Para usar uma palavra reservada como nome, prefixe com & (&begin é um identificador).

Comentários#

Fenner

// comentário de linha

{ comentário de bloco }

(* outro comentário de bloco *)

O comentário com chaves aninha: uma chave de abertura dentro dele sobe um nível, e ele só fecha quando a conta volta a zero. É o que permite comentar um trecho que contém uma diretiva:

Fenner

{ comentando isto:
    {$ifdef TRACE}
      Registra;
    {$endif}
  o comentário continua até aqui }

{$...} (e (*$...*)) não é comentário: é uma diretiva do compilador.

Números#

Fenner

const
  Million = 1_000_000;     // o "_" só separa dígitos
  Mask = 0b1010_1010;      // binário
  Permissions = 0o755;     // octal
  Color = 0xFF8800;        // hexadecimal
  Old = $FF8800;           // o hexadecimal do Pascal continua valendo
  Real = 1_234.567_8;      // vale também na fração e no expoente
  Small = 1.5e-3;

O _ tem de ficar entre dígitos: 1_ e 1__0 são erro, não um número seguido de outra coisa. O prefixo de base (0b, 0o, 0x) só vale com um dígito válido daquela base logo depois, o que garante que nenhum fonte antigo mude de sentido.

Um literal com ponto não passa por Float64 quando o destino é moeda: o compilador lê o texto do literal e monta o valor exato (veja Tipos).

Cadeias e caracteres#

Fenner

'texto simples'
'it''s'                  // a aspa dobrada é uma aspa
#13#10                   // caracteres pelo código (#$0D também vale)
'linha' + #13#10 + 'outra'

Há duas formas de cadeia de várias linhas. A regra do recuo é a do Delphi 12: a indentação do fecho diz quanto sai de cada linha do corpo, e o recuo relativo fica. A quebra depois da abertura e a de antes do fecho não entram no valor.

Fenner

const
  Query =
    '''
    select * from clientes
    where nome like '%silva%'
    ''';

  Raw = `
    aqui nada é escapado: '' "" \n
    `;

''' abre quando vem seguido do fim da linha.
A crase (` ``) numa linha só é uma cadeia crua; sozinha no fim da linha, abre a forma de várias linhas. Dentro dela não há escape nenhum: o apóstrofo e a barra são literais, o que a torna boa para SQL e JSON.

Um nome entre aspas duplas ("Nome.Do.Namespace") não é cadeia: é um nome de namespace, usado em using.

Palavras reservadas#

São as que o analisador léxico reconhece, em qualquer posição.

Grupo	Palavras
Programa e módulos	`program` `library` `unit` `interface` `implementation` `uses` `exports` `initialization` `finalization` `namespace` `using` `region` `rad_region`
Declarações	`const` `var` `threadvar` `type` `label` `record` `class` `object` `property` `constructor` `destructor` `function` `procedure` `array` `of` `void` `attribute`
Blocos e comandos	`begin` `end` `if` `then` `else` `while` `do` `for` `to` `downto` `downin` `repeat` `until` `case` `scase` `icase` `uscase` `uicase` `sync` `try` `finally` `except` `raise` `on` `goto` `with` `in` `Break` `Continue` `Exit`
Objetos	`inherited` `is` `as` `weak` `exact` `final` `default` `strict` `private` `protected` `public` `published` `async` `await` `TypeOf`
Operadores	`div` `mod` `divmod` `and` `or` `xor` `not` `shl` `shr`
Valores	`nil` `True` `False`
Código de baixo nível	`asm` `llvm` `cpp` `cpp_region`
Otimização	`pure` `impure` `vital` `force` `discardable` `preserve` `abi_win` `abi_posix` `noreturn`

Diretivas contextuais#

Estas palavras só têm sentido numa posição determinada (depois de uma declaração de rotina, por exemplo) e podem ser usadas como identificadores em outro lugar:

module package absolute abstract align cdecl chain constref delayed deprecated dynamic experimental external forward helper index inject inline intrinsic late managed message meta name nosideonly open operator out overload override packed platform read reference register reintroduce safecall static stdcall varargs virtual weaklink write

Ref, Refs, ChainRoot, Chain, Delegate, late e absolute não são palavras reservadas: só na posição do tipo de um campo (ou colada num begin, no caso de late) elas mudam de sentido.

Self e Result são identificadores predefinidos, não palavras reservadas.