if (Check(a)) then...

X>Я почти написал уже прогу для конверта прог на пасе в блок-схемы. Дело в том, что это мой курсач, а мне препод попался зашибись. Наши споры из-за блока "Предопределённый процесс" перерастают в драки .

     
    |
 -------
|   I   |
 ------- 
    |
 -------
|   C   |------------------
 -------                   |
    |                      |
    /\           _______   |
  /  C \ _______|   A   |__|
  \    /        |_______|
    \/
     |

X>Я почти написал уже прогу для конверта прог на пасе в блок-схемы. Дело в том, что это мой курсач, а мне препод попался зашибись. Наши споры из-за блока "Предопределённый процесс" перерастают в драки .

for i := Start() to Finish() do
  Something();

{ эквивалентно }

s := Start(); { единожды }
f := Finish(); { единожды }
if s < f then begin { если диапазон пуст - вообще ничего делать не будем }
  i := s; { поехали }
  repeat
    Something(); { тело цикла }

    i := i+1;
  until i = f;
  { по окончании цикла индекс останется на финише }
end;
{ хотя, вообще-то, значение индекса по выходу из цикла - не определено }

var s, f, i: integer;

function start() : integer;
begin
  writeln("вычиляем start!");
  start := s;
end;

function finish() : integer;
begin
  writeln("вычиляем finish!");
  finish := f;
end;

procedure something(i: integer)
begin
  writeln("i = ", i);
end;

procedure play;
begin
  i := 100;
  writeln("for i := ", s, " to ", f);
  for i := start() to finish() do something(i);
  writeln("finally, i = ", i);
end;

begin
  s := 1; f := 5; play;
  s := 5; f := 1; play;
end.

     
UgN>    |
UgN> -------
UgN>|   I   |
UgN> ------- 
UgN>    |
UgN> -------
UgN>|   C   |------------------
UgN> -------                   |
UgN>    |                      |
UgN>    /\           _______   |
UgN>  /  C \ _______|   A   |__|
UgN>  \    /        |_______|
UgN>    \/
UgN>     |
UgN>

  --------    -------------
 /   A    \   |           |
|          |  |     A     |
|  COND    |   \---------/
------------

----------------------
| |                | |
| |  Имя_функции   | |
| |                | |
----------------------

...
if Chreck(a) then Routine(b);
...

for( init(); condition(); step() ) body();

        |
    +-------+
    | init  |
    +-------+
        |
+------>+
|       |
|  /---------\
| < condition >-+
|  \---------/  |
|       |       |
|   +-------+   |
|   | body  |   |
|   +-------+   |
|       |       |
|   +-------+   |
|   | step  |   |
|   +-------+   |
|       |       |
+-------+       |
                |
        +<------+
        |

++-----++
|| g() ||
++-----++
    |
++-----++
|| h() ||
++-----++
    |
++-----++
|| f() ||
++-----++
Это будет неправда, так как порядок следования вызовов g и h - это добрая воля компилятора.

++------------++
|| f(g(),h()) ||
++------------++
А так скроется факт исполнения трех процедур.

X>  --------    -------------
X> /   A    \   |           |
X>|          |  |     A     |
X>|  COND    |   \---------/
X>------------

### for i := start() to end() do body ###

+-------------+
| s := start()|
| e := end()  |
+-------------+
       |
/-------------\
|     :A:     |
| for i:=s..e |
+-------------+
       |
+-------------+
|     body    |
+-------------+
       |
   +-------+
   |  :A:  |
   \-------/

### while cond() do body ###

/-------------\
|     :A:     |
|    cond()   |
+-------------+
       |
+-------------+
|     body    |
+-------------+
       |
   +-------+
   |  :A:  |
   \-------/

### repeat body until cond() ###

   /-------\
   |  :A:  |
   +-------+
       |
+-------------+
|     body    |
+-------------+
       |
+-------------+
|     :A:     |
|    cond()   |
\-------------/

X>----------------------
X>| |                | |
X>| |  Имя_функции   | |
X>| |                | |
X>----------------------

X>...
X>if Chreck(a) then Routine(b);
X>...

c:=check(a);
if с then
  routine(b)
else
  begin end; { пустая ветка - пойдет параллельно }