Если левый двигатель в норме, то мы включаем плазменный реактор. Так и должно быть. Здесь нет никакой ошибки

	В экран не влезает

struct String
{
    char* Buffer;
    int Length;
};

int String_Compare(
    const struct String* left,
    const struct String* right
) {
    // item 237
    int i;
    int leftChar, rightChar;
    int result = 200;

    // item 229
    if (left == 0) {
        /* item 230 */
        printf("String_Compare: left is null.\n");
        abort();
    } else {
    }

    // item 233
    if (right == 0) {
        /* item 234 */
        printf("String_Compare: right is null.\n");
        abort();
    } else {
    }

    // item 665
    if (left == right) {
        /* item 666 */
        result = 0;
        goto item_677;
    } else {
        /* item 238 */
        i = 0;
    }

    item_239 :
    if ((i < left->Length) && (i < right->Length)) {
        /* item 244 */
        leftChar = left->Buffer[i];
        rightChar = right->Buffer[i];
    } else {
        /* item 259 */
        goto item_253;
    }

    // item 245
    if (leftChar < rightChar) {
        goto item_249;
    } else {
    }

    // item 246
    if (leftChar > rightChar) {
        /* item 248 */
        result = 1;
        goto item_677;
    } else {
        /* item 251 */
        i++;
        goto item_239;
    }

    item_253 :
    if (left->Length < right->Length) {
    } else {
        goto item_254;
    } 

    item_249 :
    result = -1;
    goto item_677;

    item_254 :
    if (left->Length > right->Length) {
        /* item 256 */
        result = 1;
    } else {
        /* item 257 */
        result = 0;
    }

    item_677 :
    return result;

}

int String_Compare(
    const struct String* left,
    const struct String* right
)
{
    int result = 0;
    for ( int i = 0; i < left->Length && i < right->Length && !result; i++)
        result = left->Buffer[ i ] - right->Buffer[ i ];
        
    if ( !result )
        result = left->Length - right->Length;

    // Что бы возвращаемый результат был в том же виде, что и у сгенерированной функции.
    if ( result < 0 )
        result = -1;
    else if ( result > 0 )
        result = 1;
        
    return result;
}

Как улучшить блок-схемы алгоритмов по ГОСТ 19.701-90? Эргономичный визуальный алгоритмический язык ДРАКОН. Критерии

AN>int String_Compare(
AN>    const struct String* left,
AN>    const struct String* right
AN>)
AN>{
AN>    int result = 0;
AN>    for ( int i = 0; i < left->Length && i < right->Length && !result; i++)
AN>        result = left->Buffer[ i ] - right->Buffer[ i ];
        
AN>    if ( !result )
AN>        result = left->Length - right->Length;

AN>    // Что бы возвращаемый результат был в том же виде, что и у сгенерированной функции.
AN>    if ( result < 0 )
AN>        result = -1;
AN>    else if ( result > 0 )
AN>        result = 1;
        
AN>    return result;
AN>}
AN>

Compare(xs : string, ys : string) : int
{
   | (x : tailX,  y : tailY) when x != y => x - y                 // строка состоит из символов префиксов и продолжения и префиксы не равны
   | (x : tailX,  y : tailY) when x == y => Compare(tailX, tailY) // тоже самое но префиксы равны, продолжаем рекурсивно...
   | ([],  _ : _) => 1  // xs содержит пустой список, а ys - нет.
   | (_ : _, [])  => -1 // наоборот
   | ([], [])     => 0  // все символы равны и списки пусты
}

«Актуальные вопросы развития и применения автоматизированных систем управления комплексом технических средств жизнеобеспечения объектов военной инфраструктуры»

Русский визуальный язык ДРАКОН — инструмент для быстрой и надёжной разработки алгоритмов систем управления

В ОКБ АМУР 3 разрабатывается широкий спектр управляющих алгоритмов для ПЛК, для разнообразных промышленных, инфраструктурных и коммунальных объектов.

По нашему опыту, все языки МЭК мало приспособлены для быстрой и надёжной разработки алгоритмов управления.

Они не отображают наглядно состояния управляющей системы, переходы между ними, различные сценарии и исходы каждого логического блока. Управление через дополнительные логические переменные ещё сильнее снижает наглядность.

Как следствие – разработка ведется «методом проб и ошибок», с последующей «агонией отладки».

Мы постоянно встречаем в открытых библиотеках на языке ST пропуски целых логических веток, игнорирование особых случаев – а ведь эти библиотеки используются на тысячах реальных объектов.

Как выход мы применили визуальный язык ДРАКОН (https://drakon.su/), который выводит на другой уровень наглядность и проверяемость алгоритмов управления, улучшает повторное использование логических блоков.

Становится возможной визуальная верификация алгоритма (это не исключает интерактивную отладку как дополняющий инструмент).

Ключевая особенность языка – двумерное структурное программирование, дающее большую свободу управляющих структур, чем классическое структурное программирование (см. И. Е. Ермаков, Н. А. Жигуненко. Двумерное структурное программирование; класс устремлённых графов. – https://drakon.su/_media/biblioteka_1/ermakov_zhigunenko.pdf).

ДРАКОН определяет однозначное размещение схем на плоскости, для автоматической реализации редакторами. Схема не рисуется, а быстро набирается блоками.

В продуманной до мелочей наглядности, обозримости сценариев, в расширенном структурном программировании, в строгом размещении на плоскости – отличие ДРАКОНа от всех нам известных визуальных алгоритмических схем.

Кроме того, ДРАКОН непосредственно поддерживает программирование на основе конечно-автоматной модели.

Опыт ОКБ АМУР 3 по разработке систем управления на основе ПЛК ОВЕН, с генерацией кода на ST из ДРАКОН-схем:
— насосные станции;
— станции высокого давления СОЖ;
— станции поддержания пластового давления;
— тепловые пункты и вентиляционные установки;
— водозаборно-очистительные узлы;
— туннельные водооткачивающие установки;
— сверлильные станки;
— гибочные прессы;
— координатно-режущие станки;
— пищевые производства (пивзаводы и др.);
— процессы взаимодействия ПЛК с базами данных SQL.

Мы использовали ДРАКОН-редактор предыдущего поколения (ИС ДРАКОН), который позволял чертить схемы и в полуручном режиме генерировать ST-код.

В настоящее время мы ведём разработку новой интегрированной среды программирования ПЛК на основе ДРАКОН-схем.

Её преимущества: поддержка проекта ПЛК в целом, высокопродуктивный ДРАКОН-редактор с быстрым вводом схем, поддержка сильной инкапсуляции и повторного использования блоков, экспорт проекта в формате PLCopenXML.

Результатом нашего проекта должна стать отечественная универсальная визуальная система программирования ПЛК нового поколения.

Опыт ОКБ АМУР 3 по разработке систем управления на основе ПЛК ОВЕН, с генерацией кода на ST из ДРАКОН-схем:
— насосные станции;
— станции высокого давления СОЖ;
— станции поддержания пластового давления;
— тепловые пункты и вентиляционные установки;
— водозаборно-очистительные узлы;
— туннельные водооткачивающие установки;
— сверлильные станки;
— гибочные прессы;
— координатно-режущие станки;
— пищевые производства (пивзаводы и др.);
— процессы взаимодействия ПЛК с базами данных SQL.

Да, что-то можно описывать в блок-схемах. Для детей осваивающих информатику. Или для каких-то далеких от программирования служащих от которых нужно описание бизнес процессов и можно удовлетворится примитивными описаниями.

public void Increment()
{
  if(x < 200) x = x + 1;
}

public void Decrement()
{
  if(x > 0) x = x - 1;
}

public void Reset()
{
  x = 0;
}

VD>Compare(xs : string, ys : string) : int
VD>{
VD>   | (x : tailX,  y : tailY) when x != y => x - y                 // строка состоит из символов префиксов и продолжения и префиксы не равны
VD>   | (x : tailX,  y : tailY) when x == y => Compare(tailX, tailY) // тоже самое но префиксы равны, продолжаем рекурсивно...
VD>   | ([],  _ : _) => 1  // xs содержит пустой список, а ys - нет.
VD>   | (_ : _, [])  => -1 // наоборот
VD>   | ([], [])     => 0  // все символы равны и списки пусты
VD>}
VD>

Compare(xs : string, ys : string) : int
{
   | (x : tailA,  x : tailB) => Compare(tailA, tailB) // префиксы равны, продолжаем рекурсивно...
   | (x : tailX,  y : tailY) => x - y                 // префиксы не равны
   | ([],  _ : _) => 1  // xs содержит пустой список, а ys - нет.
   | (_ : _, [])  => -1 // наоборот
   | ([], [])     => 0  // все символы равны и списки пусты
}

S>Compare(xs : string, ys : string) : int
S>{
S>   | (x : tailA,  x : tailB) => Compare(tailA, tailB) // префиксы равны, продолжаем рекурсивно...
S>   | (x : tailX,  y : tailY) => x - y                 // префиксы не равны
S>   | ([],  _ : _) => 1  // xs содержит пустой список, а ys - нет.
S>   | (_ : _, [])  => -1 // наоборот
S>   | ([], [])     => 0  // все символы равны и списки пусты
S>}
S>

| (x : tailX,  y : tailY) when x != y // это паттерн сопоставляется когда оба списка не пусты и первые символы строки не равны.
| (x : tailX,  y : tailY) when x == y // это паттерн сопоставляется когда оба списка не пусты и первые символы строки равны.
| ([],  _ : _) => 1                   // это паттерн сопоставляется когда первый список пуст, а второй содержит по меньшей мере один элемент
| (_ : _, [])  => -1                  // это паттерн сопоставляется когда первый список содержит по меньшей мере один элемент, а второй пуст
| ([], [])     => 0                   // это паттерн сопоставляется когда оба списка пусты