DRAKON.SU

‘Создаем массив Integer A
Integer A "Change Value" ‘Две подписки на событие “Change Value”

‘В первой сравниваем текущий элемент со следующим
{A [Index] ~ A [Index+1]) > A [Index+1]:=: A [Index] ‘Если событие > то меняем.

‘Во второй подписке сравниваем текущий элемент с предыдущим
A [Index] ~ A [Index-1]) < A [Index]:=: A [Index -1] ‘Если < то меняем
} [] ‘Определение массива Integer

// два входных объекта-канала, имеют "событие" OnChange в виде указателя на функцию,
// выполняемую в случае возникновения соответствующего ввода
input
  Cmd: channel of bool; // "командная клавиша"
  Char: channel of int; // "символьные клавиши"

var
  // в переменной фиксируется факт нажатия управляющей клавиши
  PreCmd: bool := false;

  // в переменной фиксируется факт запрета обработки символьных клавиш
  DisableChar: bool := false;

// императивная часть
begin
  // установка обработчиков событий

  // реакция на ввод командной клавиши
  Cmd.OnChange := function () {
    if DisableChar then // если был запрет обработки символьных клавиш
      DisableChar := false;
      PreCmd := false;
    elif PreCmd then  // был зафиксирован факт нажатия упр. клавиши
      DisableChar := true;  // установить запрет обработки симв. клавиш
    else
      PreCmd := true;  // фиксируем факт нажатия упр. клавиши
    end
  };

  // реакция на ввод символьных клавиш
  Char.OnChange := function (c: int) {
    if not DisableChar then // если нет запрета обработки
      if PreCmd then        // ранее была нажата упр. клавиша
        print(toUpper(c));
        PreCmd := false;    // "сбрасываем" флаг "предыдущего нажатия" упр. клавиши
      else
        print(c);
      end
    end
  };
 
  // "главный управляющий" цикл, организующий работу целевой подсистемы ("добыча и выдача" ввода/вывода),
  // в данном случае неважно как именно
  loop
    ...
  end;
end;

input
  Cmd: channel of bool;
  Char: channel of int;

var
  PreCmd: bool := false;

// обработчик упр. клавиши
function HandleCmd() {
  if Char.OnChange = null then   // обработка "симв. клавиш" неустановлена
    Char.OnChange := HandleChar; // ... установить
    PreCmd := false;
  elif PreCmd then
    Char.OnChange := null;       // ... отключить
  else
    PreCmd := true;
  end
};

// обработка симв. клавиш
function HandleChar(c: int) {
  if PreCmd then               // уже нет проверок на "запреты"
    print(toUpper(c));
    PreCmd := false;
  else
    print(c);
  end
};

begin
  Cmd.OnChange := HandleCmd;
  Char.OnChange := HandleChar;

  loop
    ...
  end;
end;

type
  // Тип-enum, выражающий текущее состояние "события":
  // - неактивное (необнаруженное);
  // - установленное (но доступное "потребителям" на следующем такте);
  // - активное (доступное "потребителям")
  EventState = {Inactive, Stated, Active};

  // enum как "автоматное" состояние процесса печати символов
  PrintState = {Active, Idle};

var
  // состояние "события" нажатия управл. клавиши
  EventCmd: EventState := Inactive;
  // состояние "события" нажатия симв. клавиш
  EventChar: EventState := Inactive;
  // код веденного символа
  Char: int = 0;
  // флаг для фиксации события "предыдущего" нажатия управл. клавиши
  PreCmd: bool := false;
  // текущее "автоматное" состояние процесса печати символов
  ProcPrintState: PrintState := Active;

// процесс обработки состояний "событий" в конце каждой итерации системы
// для подготовки следующего такта:
// Если событие было "активным", то оно "переводится" в "неактивное",
// если было "обнаруженным" -- в "активное"
// (также фиксируется "предыдущее нажатие" управл. клавиши)
function ProcessEvents() {
  if EventCmd = Active then
    EventCmd := Inactive;
    PreCmd := true;
  elif EventCmd = Stated then
    EventCmd := Active;
  else
    PreCmd := false;
  end;

  if EventChar = Active then
    EventChar := Inactive;
  elif EventChar = Stated then
    EventChar := Active;
  end;
};

// функция для фиксации "обнаружения" ("установки") события нажатия управл. клавиши
function SetCmd() {
  EventCmd := Stated;
}

//...символьной. клавиши
function SetChar(c: int) {
  EventChar := Stated;
  Char := c;
}

// функция для опроса "получения" (или "существования установки") события нажатия упр. клавиши
function RecvCmd(): bool {
  return EventCmd = Active;
}

//...символьной. клавиши
function RecvChar(): bool {
  return EventChar = Active;
}

// Процесс обнаружения нажатия управл. клавиши
function ProcessCmd() {
  ...
  if cond then // каким-то образом обнаруживаем "внешний ввод нажатия"
    SetCmd();
  end;
};

//...символьной. клавиши
function ProcessChar() {
  ...
  if cond then
    SetChar(GetChar());
  end;
};

// Процесс печати символов в виде "автомата" из двух состояний.
// Основная логика управления ключевым "прикладным" процессом
// теперь собрана в одном месте (в разрезе конкретных автоматных состояний,
// и "переходом" в эти состояния теперь занимается лишь сам данный процесс),
// в т.ч. с учётом того, что во время такта системы могут
// отсутствовать "целевые" события.
function ProcessPrint() {
  case ProcPrintState of
  | Active:
      if RecvCmd() & PreCmd then
          ProcPrintState := Idle;
      elif RecvChar() & PreCmd then
          print(toUpper(Char));
      elif RecvChar() then
        print(Char);
      end;

  | Idle:
      if RecvCmd() then
          ProcPrintState := Active;
      end;
  end;
};

// главная императивная часть в виде некоего "управляющего" цикла
// (каждая итерация есть "такт" системы)
begin
  loop
    ProcessCmd();
    ProcessChar();
    ProcessPrint();
    ProcessEvents();
  end;
end;

let ProcessPrint(cmd: bool, char: int) = void where
    automaton
    | Active =>
        do
            if char & pre(cmd) then print(toUpper(char))
            elif char then print(char)
        unless cmd & pre(cmd) then Idle

    | Idle =>   
        do () unless cmd then Active
    end