while not end_of_stream:
    read_socket()
    if checksum == fails:
    raise_hacker_alert()
    break
    if number_of_bytes_read() > MAX_DATA_ALLOWED: break
    process_data()

while not end_of_stream
    read_socket
    if checksum == fails
    raise_hacker_alert
    break
    if number_of_bytes_read>MAX_DATA_ALLOWED break
    process_data

* i i * i * i i * * i * i * i

П>>Ну и где хваленое превышение в разы?

while (!end_of_stream) {
    read_socket();
    if (checksum == fails) {
    raise_hacker_alert();
    break;
    }
    if (number_of_bytes_read() > MAX_DATA_ALLOWED)
    break;
    process_data();
}

AVC>Остается добавить, что операции одного приоритета выполняются слева направо. И все. Что, сложно?

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

M>>while(!stream.eof())
M>>{
M>>  // code
M>>}
M>>

M>>LOOP
M>>  IF ~stream.end THEN
M>>    {* code *}
M>>  END
M>>END
M>>

Multiple points of exit

The original structural programming advocated dividing programs into subsections that have single point of entry, and single point of exit. While usually there aren't many reasons to have multiple points of entry, very few programs naturally follow the single point of exit paradigm.

A typical example of a simple procedure would be reading data from a file and processing it:

open file;
while (reading not finished)
{
  read some data;
  if(error){
    stop the subprogram, inform rest of the program about the error;
    }
}
process read data;
finish the subprogram;

The "stop and inform" may be achieved by throwing an exception, second return from the procedure, labelled loop break, or even a goto. As the procedure has 2 exit points, it breaks the rules of Dijkstra's structured programming. Coding it in accordance with single point of exit rule would be very cumbersome. If there were more possible error conditions, with different cleanup rules, single exit point procedure would be extremely hard to read and understand, very likely even more so than an unstructured one with control handled by goto statements. On the other hand, structural programming without such a rule would result in very clean and readable code.

Most languages have adapted the multiple points of exit form of structural programming. C allows multiple paths to a structure's exit (such as "continue", "break", and "return"), newer languages have also "labelled breaks" (similar to the former, but allowing breaking out of more than just the innermost loop) and exceptions.

While using those abilities may bring both advantages and disadvantages to the readability, providing them is clearly advantageous, as the programmer may use them when they're fit and simply not use them when a single point of exit structure would be more appropriate.