Tipos

program Types;

// Os nomes dos tipos dizem a largura: nada de Integer, Cardinal ou Extended.

const
  Million = 1_000_000;     // o "_" só separa dígitos
  Mask = 0b1010_1010;      // binário
  Permissions = 0o755;     // octal
  Color = 0xFF8800;        // hexadecimal ($FF8800, do Pascal, também vale)

var
  Small: Int8;
  Wide: UInt64;
  Huge: Int256;
  Price: Currency64;
  Ratio: Float64;
begin
  Small := 127;
  Wide := 18_446_744_073_709_551_615;
  WriteLn('Int8:   ', Small, ' (', SizeOf(Int8), ' byte)');
  WriteLn('UInt64: ', Wide, ' (', SizeOf(UInt64), ' bytes)');

  // inteiros largos: a aritmética é nativa, sem biblioteca de números grandes
  Huge := 1_000_000_000_000_000_000;
  Huge := Huge * Huge * Huge;
  WriteLn('10^54 = ', Huge, ' (', SizeOf(Int256), ' bytes)');
  WriteLn('10^54 div 10^18 = ', Huge div 1_000_000_000_000_000_000);

  // moeda: ponto fixo; o literal não passa por Float64
  Price := 19.99;
  WriteLn('19.99 * 3 = ', Price * 3);
  Ratio := 1 / 3;
  WriteLn('1 / 3 = ', Ratio);

  WriteLn(Million, ' ', Mask, ' ', Permissions, ' ', Color);
end.

program Strings;

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

var
  U: UString;      // UTF-16
  U8: U8String;    // UTF-8
  L: LString;      // bytes, sem codificação declarada
begin
  U := 'Olá, mundo';
  U8 := U;         // conversão implícita entre codificações conhecidas
  WriteLn('UString:  ', Length(U), ' caracteres');
  WriteLn('U8String: ', Length(U8), ' bytes');

  L := 'abc';
  WriteLn(L + '-' + LString(U8));   // LString só converte com cast explícito

  WriteLn(Copy(U, 1, 3), ' | ', Pos('mundo', U));
  U := U + '!' + #13#10 + 'segunda linha';
  WriteLn(U);

  // cadeia de várias linhas: o recuo do fecho sai de cada linha
  WriteLn('[', Query, ']');
end.

program EnumsSets;

type
  TColor = (Red, Green, Blue);
  TColors = set of TColor;

  TStatus = (
    Stopped = 0,
    Running = 5,
    Paused = 7
  );

var
  C: TColor;
  S: TColors;
  St: TStatus;
begin
  // o escopo do enum é obrigatório: TColor.Green
  C := TColor.Green;
  S := [TColor.Red, TColor.Green];

  WriteLn(C in S);
  WriteLn(TColor.Blue in S);
  WriteLn(TColor.Blue not in S);

  Include(S, TColor.Blue);
  Exclude(S, TColor.Red);
  WriteLn(TColor.Red in S);

  // no rótulo do case, o seletor já fixa o tipo: Green: vale sem o escopo
  case C of
    Red:   WriteLn('vermelho');
    Green: WriteLn('verde');
    Blue:  WriteLn('azul');
  end case;

  St := TStatus.Running;
  WriteLn(Ord(St));          // valores explícitos, em qualquer ordem
  WriteLn(Ord(TStatus.Paused));
end.

program Arrays;

type
  TByteRange = 0..255;                    // vira UInt8: a faixa é checada em compilação
  TMatrix = array[1..2, 1..3] of Int32;

function Sum(const AValues: array of Int32): Int32;    // vetor aberto
var
  I: Int32;
begin
  Result := 0;
  for I := 0 to High(AValues) do
    Inc(Result, AValues[I]);
end function;

var
  Fixed: array[0..4] of Int32;            // estático
  Names: array of UString;                // dinâmico (contagem de referências)
  Matrix: TMatrix;
  Short: SString[10];                     // cadeia curta: o tamanho vai no byte 0
  R: TByteRange;
  I, J: Int32;
begin
  for I := 0 to 4 do
    Fixed[I] := I * I;
  WriteLn(Length(Fixed), ' elementos, de ', Low(Fixed), ' a ', High(Fixed));

  SetLength(Names, 2);
  Names[0] := 'um';
  Names[1] := 'dois';
  SetLength(Names, 3);                    // cresce preservando o conteúdo
  WriteLn(Length(Names), ' nomes; o segundo é ', Names[1]);

  for I := 1 to 2 do
    for J := 1 to 3 do
      Matrix[I, J] := I * 10 + J;
  WriteLn('Matrix[2, 3] = ', Matrix[2, 3]);

  Short := 'cadeia curta demais';
  WriteLn(Short, ' (', Length(Short), ')');

  R := 200;
  WriteLn(R, ' cabe em ', SizeOf(TByteRange), ' byte');

  WriteLn(Sum([1, 2, 3, 4]));             // literal de vetor passado a um vetor aberto
end.

program Variants;

var
  V: Variant;
begin
  V := 10;
  V := V * 3;                 // aritmética: o Variant é um record gerenciado da RTL
  WriteLn(UString(V));

  V := 'agora é texto';       // o mesmo Variant, outro conteúdo
  WriteLn(UString(V));
end.

program Pointers;

type
  PNode = ^TNode;               // ponteiro para um tipo declarado depois
  TNode = record
    Value: Int32;
    Next: PNode;
  end record;

var
  Head, Node: PNode;
  I, Sum: Int32;
  X: Int32;
  PX: ^Int32;
begin
  X := 41;
  PX := @X;
  PX^ := PX^ + 1;
  WriteLn('X via ponteiro: ', X);

  // lista ligada: insere na frente
  Head := nil;
  for I := 1 to 5 do
  begin
    New(Node);
    Node^.Value := I * 10;
    Node^.Next := Head;
    Head := Node;
  end for;

  Sum := 0;
  Node := Head;
  while Node <> nil do
  begin
    Sum := Sum + Node^.Value;
    Node := Node^.Next;
  end while;
  WriteLn('soma da lista: ', Sum);

  while Head <> nil do
  begin
    Node := Head^.Next;
    Dispose(Head);
    Head := Node;
  end while;
end.