Declarações e comandos

program Declarations;

const
  Limit = 3;                                              // constante
  Greeting: UString = 'olá';                              // constante tipada
  Names: array[0..2] of UString = ('um', 'dois', 'três'); // constante tipada de vetor

type
  TPoint = record
    X, Y: Int32;
  end record;

  TItem = class(TObject)
  public
    Value: Int32;
  end class;

var
  Total: Int32 = 100;          // global com valor inicial
  P: TPoint;

function NewItem(const AValue: Int32): TItem;
begin
  Result := TItem.Create;
  Result.Value := AValue;
end function;

procedure Demo;
var
  Fresh: default Int32;        // "default" faz a variável nascer zerada
begin
  WriteLn('Fresh = ', Fresh);
end procedure;

begin
  WriteLn(Greeting, ' ', Names[Limit - 1], ' ', Total);
  Demo;

  // with sobre um valor, com apelido: o objeto vive enquanto o bloco o usa
  with NewItem(7) as It do
    WriteLn('Item.Value = ', It.Value);

  P.X := 1;
  P.Y := 2;
  WriteLn('P = (', P.X, ', ', P.Y, ')');
end.

program InlineVars;

type
  TCounter = class(TObject)
  public
    Start: Int32;
    constructor Create(const AStart: Int32);
    destructor Destroy; override;
  end class;

constructor TCounter.Create(const AStart: Int32);
begin
  Start := AStart;
  WriteLn('  Create(', AStart, ')');
end constructor;

destructor TCounter.Destroy;
begin
  WriteLn('  Destroy(', Start, ')');
  inherited Destroy;
end destructor;

procedure Demo;
var
  C: TCounter(10);              // declarada E construída: TCounter.Create(10)
begin
  WriteLn('corpo: ', C.Start);

  if C.Start > 5 then
  begin
    var Total := C.Start * 2;   // o tipo vem do valor
    var Msg: UString := 'bloco';
    WriteLn(Msg, ' ', Total);
  end if;                          // Total e Msg morrem aqui

  for var I := 1 to 3 do
    Write(I, ' ');
  WriteLn;
end procedure;

begin
  Demo;
  WriteLn('fim');
end.

program CaseStrings;

var
  Command: UString;
begin
  Command := 'Stop';

  // scase: o case de cadeia, sensível a maiúsculas
  scase Command of
    'start': WriteLn('iniciar');
    'Stop':  WriteLn('parar');
  else
    WriteLn('comando desconhecido');
  end scase;

  // icase: o mesmo, sem diferenciar maiúsculas de minúsculas
  icase Command of
    'START': WriteLn('iniciar');
    'STOP':  WriteLn('parar (sem diferenciar a caixa)');
  else
    WriteLn('comando desconhecido');
  end icase;
end.

program Control;

var
  I, J, N: Int32;
  Q, R: Int32;
  Names: array[0..2] of UString;
  Name: UString;
begin
  Names[0] := 'Ana'; Names[1] := 'Bia'; Names[2] := 'Caio';

  // for, com e sem passo invertido
  for I := 1 to 3 do
    Write(I, ' ');
  for I := 3 downto 1 do
    Write(I, ' ');
  WriteLn;

  // for sobre faixa: a direção vem dos valores
  for var K: Int32 in 0..3 do
    Write(K, ' ');
  WriteLn;

  // for-in sobre vetor; downin percorre do fim para o começo
  for Name in Names do
    Write(Name, ' ');
  WriteLn;
  for Name downin Names do
    Write(Name, ' ');
  WriteLn;

  // laço com rótulo: Break(nome) sai do laço de fora, sem bandeira nem goto
  N := 0;
  for [outer] I := 1 to 3 do
    for [inner] J := 1 to 3 do
    begin
      Inc(N);
      if J = 2 then
        Break(outer);
    end for;
  WriteLn('passos: ', N);

  // repeat..until e while com Continue
  I := 0;
  repeat
    Inc(I);
    if Odd(I) then
      Continue;
    Write(I, ' ');
  until I >= 8;
  WriteLn;

  // quociente e resto numa conta só
  Q, R := 17 divmod 5;
  WriteLn('17 = 5 * ', Q, ' + ', R);

  // if como valor, nas duas grafias
  WriteLn(if I > 5 then 'grande' else 'pequeno');
  WriteLn(I > 5 ? 'grande' : 'pequeno');

  // case aceita faixas e listas
  case I of
    0..4: WriteLn('baixo');
    5, 6, 7: WriteLn('médio');
    8..99: WriteLn('alto');
  end case;
end.

program EndNomeado;

// O "end" pode dizer o que está fechando. O compilador confere: "end case" num "if" é erro.

type
  TPoint = record
    X: Int32;
    Y: Int32;
  end record;

  TCounter = class
  private
    FValue: Int32;
  public
    procedure Add(const AAmount: Int32);
    function Value: Int32;
  end class;

procedure TCounter.Add(const AAmount: Int32);
begin
  FValue := FValue + AAmount;
end procedure;

function TCounter.Value: Int32;
begin
  Result := FValue;
end function;

procedure Describe(const AKind: Int32);
begin
  case AKind of
    1: WriteLn('um');
    2: WriteLn('dois');
  else
    WriteLn('outro');
  end case;
end procedure;

var
  LCounter: TCounter;
  LPoint: TPoint;
  LIndex: Int32;
begin
  LCounter := TCounter.Create;
  try
    for LIndex := 1 to 3 do
    begin
      LCounter.Add(LIndex);
      if LIndex = 2 then
      begin
        WriteLn('dois!');
      end if;
    end for;
    WriteLn('soma = ', LCounter.Value);
  finally
    LCounter.Free;
  end try;

  LPoint.X := 1;
  LPoint.Y := 2;
  Describe(LPoint.X);
  Describe(LPoint.Y);
  Describe(9);
end.