УКРАИНА-14

Тро-ло-ло - это троллинг.

А обсуждать обсуждение модерации не боитесь? Напрасно.

Я полагаю тут важнее сопоставление других чисел: какой процент составляют местные ополченцы (не население ЛДНР, а именно ополченцы) от сорокамиллионного населения Украины. Позволяет ли такое соотношение называть конфликт на Донбассе гражданской войной?

Кстати раньше (давно) можно было указывать для функции main тип void. И тогда return без возвращаемого значения мог быть:

$ cat <<EOF> hello.c
#include <stdio.h>

void main()
{
printf("Hello World!\n");
return;
}
EOF

Но сейчас это даёт ошибку (warning) компиляции:

$ gcc -o hello hello.c
hello.c: In function `main':
hello.c:4: warning: return type of 'main' is not `int'
$

А возвращаемое значение получается равное 13-ти (не могу понять почему именно это значение? есть ли в этом смысл или случайно (т.е. можно ли рассчитывать, что и на другом компиляторе также 13 получится?))

$ ./hello
Hello World!
$ echo $?
13
$

Код:

$ dis hello
disassembly for hello
 
section .plt
    _PROCEDURE_LINKAGE_TABLE_: ff 35 a0 0b 06 08  pushl  0x8060ba0
    0x805087e:              ff 25 a4 0b 06 08  jmp    *0x8060ba4
    0x8050884:              00                .byte    0
    0x8050885:              00                .byte    0
    0x8050886:              00                .byte    0
    0x8050887:              00                .byte    0
atexit()
    atexit:                ff 25 a8 0b 06 08  jmp    *0x8060ba8
    0x805088e:              68 00 00 00 00    pushl  $0x0
    0x8050893:              e9 e0 ff ff ff    jmp    -0x1b    <_PROCEDURE_LINKAGE_TABLE_>
__fpstart()
    __fpstart:              ff 25 ac 0b 06 08  jmp    *0x8060bac
    0x805089e:              68 08 00 00 00    pushl  $0x8
    0x80508a3:              e9 d0 ff ff ff    jmp    -0x2b    <_PROCEDURE_LINKAGE_TABLE_>
exit()
    exit:                  ff 25 b0 0b 06 08  jmp    *0x8060bb0
    0x80508ae:              68 10 00 00 00    pushl  $0x10
    0x80508b3:              e9 c0 ff ff ff    jmp    -0x3b    <_PROCEDURE_LINKAGE_TABLE_>
_exit()
    _exit:                  ff 25 b4 0b 06 08  jmp    *0x8060bb4
    0x80508be:              68 18 00 00 00    pushl  $0x18
    0x80508c3:              e9 b0 ff ff ff    jmp    -0x4b    <_PROCEDURE_LINKAGE_TABLE_>
    0x80508c8:              ff 25 bc 0b 06 08  jmp    *0x8060bbc
    0x80508ce:              68 20 00 00 00    pushl  $0x20
    0x80508d3:              e9 a0 ff ff ff    jmp    -0x5b    <_PROCEDURE_LINKAGE_TABLE_>
    0x80508d8:              ff 25 c4 0b 06 08  jmp    *0x8060bc4
    0x80508de:              68 28 00 00 00    pushl  $0x28
    0x80508e3:              e9 90 ff ff ff    jmp    -0x6b    <_PROCEDURE_LINKAGE_TABLE_>
    0x80508e8:              ff 25 cc 0b 06 08  jmp    *0x8060bcc
    0x80508ee:              68 30 00 00 00    pushl  $0x30
    0x80508f3:              e9 80 ff ff ff    jmp    -0x7b    <_PROCEDURE_LINKAGE_TABLE_>
printf()
    printf:                ff 25 d0 0b 06 08  jmp    *0x8060bd0
    0x80508fe:              68 38 00 00 00    pushl  $0x38
    0x8050903:              e9 70 ff ff ff    jmp    -0x8b    <_PROCEDURE_LINKAGE_TABLE_>
_get_exit_frame_monitor()
    _get_exit_frame_monitor: ff 25 d4 0b 06 08  jmp    *0x8060bd4
    0x805090e:              68 40 00 00 00    pushl  $0x40
    0x8050913:              e9 60 ff ff ff    jmp    -0x9b    <_PROCEDURE_LINKAGE_TABLE_>
 
section .text
_start()
    _start:                6a 00              pushl  $0x0
    _start+0x2:            6a 00              pushl  $0x0
    _start+0x4:            8b ec              movl  %esp,%ebp
    _start+0x6:            b8 d8 0b 06 08    movl  $0x8060bd8,%eax
    _start+0xb:            85 c0              testl  %eax,%eax
    _start+0xd:            74 09              je    +0xb    <_start+0x18>
    _start+0xf:            52                pushl  %edx
    _start+0x10:            e8 5b ff ff ff    call  -0xa0    <atexit>
    _start+0x15:            83 c4 04          addl  $0x4,%esp
    _start+0x18:            68 70 0b 05 08    pushl  $0x8050b70
    _start+0x1d:            e8 4e ff ff ff    call  -0xad    <atexit>
    _start+0x22:            83 c4 04          addl  $0x4,%esp
    _start+0x25:            8d 05 0c 0d 06 08  leal  0x8060d0c,%eax
    _start+0x2b:            8b 00              movl  (%eax),%eax
    _start+0x2d:            85 c0              testl  %eax,%eax
    _start+0x2f:            74 15              je    +0x17    <_start+0x46>
    _start+0x31:            8d 05 10 0d 06 08  leal  0x8060d10,%eax
    _start+0x37:            8b 00              movl  (%eax),%eax
    _start+0x39:            85 c0              testl  %eax,%eax
    _start+0x3b:            74 09              je    +0xb    <_start+0x46>
    _start+0x3d:            50                pushl  %eax
    _start+0x3e:            e8 2d ff ff ff    call  -0xce    <atexit>
    _start+0x43:            83 c4 04          addl  $0x4,%esp
    _start+0x46:            8b 45 08          movl  0x8(%ebp),%eax
    _start+0x49:            8b 15 04 0d 06 08  movl  0x8060d04,%edx
    _start+0x4f:            85 d2              testl  %edx,%edx
    _start+0x51:            75 0a              jne    +0xc    <_start+0x5d>
    _start+0x53:            8d 54 85 10        leal  0x10(%ebp,%eax,4),%edx
    _start+0x57:            89 15 04 0d 06 08  movl  %edx,0x8060d04
    _start+0x5d:            83 e4 f0          andl  $0xfffffff0,%esp
    _start+0x60:            52                pushl  %edx
    _start+0x61:            8d 55 0c          leal  0xc(%ebp),%edx
    _start+0x64:            89 15 08 0d 06 08  movl  %edx,0x8060d08
    _start+0x6a:            52                pushl  %edx
    _start+0x6b:            50                pushl  %eax
    _start+0x6c:            e8 0f ff ff ff    call  -0xec    <__fpstart>
    _start+0x71:            e8 22 00 00 00    call  +0x27    <__fsr>
    _start+0x76:            e8 bd 01 00 00    call  +0x1c2    <_init>
    _start+0x7b:            e8 58 01 00 00    call  +0x15d    <main>
    _start+0x80:            83 c4 0c          addl  $0xc,%esp
    _start+0x83:            50                pushl  %eax
    _start+0x84:            50                pushl  %eax
    _start+0x85:            e8 06 ff ff ff    call  -0xf5    <exit>
    _start+0x8a:            83 c4 04          addl  $0x4,%esp
    _start+0x8d:            e8 0e ff ff ff    call  -0xed    <_exit>
    _start+0x92:            83 c4 04          addl  $0x4,%esp
    _start+0x95:            f4                hlt
    0x80509ae:              90                nop
    0x80509af:              90                nop
__fsr()
    __fsr:                  55                pushl  %ebp
    __fsr+0x1:              8b ec              movl  %esp,%ebp
    __fsr+0x3:              52                pushl  %edx
    __fsr+0x4:              51                pushl  %ecx
    __fsr+0x5:              83 ec 04          subl  $0x4,%esp
    __fsr+0x8:              b9 00 00 00 00    movl  $0x0,%ecx
    __fsr+0xd:              d1 e9              shrl  $0x1,%ecx
    __fsr+0xf:              83 f9 00          cmpl  $0x0,%ecx
    __fsr+0x12:            74 60              je    +0x62    <__fsr+0x74>
    __fsr+0x14:            9b                fwait
    __fsr+0x15:            d9 7c 24 00        fnstcw 0x0(%esp)
    __fsr+0x19:            8b d1              movl  %ecx,%edx
    __fsr+0x1b:            83 e2 1f          andl  $0x1f,%edx
    __fsr+0x1e:            8a 82 14 0d 06 08  movb  0x8060d14(%edx),%al
    __fsr+0x24:            20 44 24 00        andb  %al,0x0(%esp)
    __fsr+0x28:            f7 c1 00 02 00 00  testl  $0x200,%ecx
    __fsr+0x2e:            74 05              je    +0x7    <__fsr+0x35>
    __fsr+0x30:            80 64 24 00 fd    andb  $0xfd,0x0(%esp)
    __fsr+0x35:            8b d1              movl  %ecx,%edx
    __fsr+0x37:            83 e2 60          andl  $0x60,%edx
    __fsr+0x3a:            74 18              je    +0x1a    <__fsr+0x54>
    __fsr+0x3c:            8b c2              movl  %edx,%eax
    __fsr+0x3e:            83 e0 20          andl  $0x20,%eax
    __fsr+0x41:            d1 e0              shll  $0x1,%eax
    __fsr+0x43:            33 d0              xorl  %eax,%edx
    __fsr+0x45:            c1 e2 05          shll  $0x5,%edx
    __fsr+0x48:            66 81 64 24 00 ff  andw  $0xf3ff,0x0(%esp)
                            f3
    __fsr+0x4f:            66 09 54 24 00    orw    %dx,0x0(%esp)
    __fsr+0x54:            81 e1 80 01 00 00  andl  $0x180,%ecx
    __fsr+0x5a:            74 14              je    +0x16    <__fsr+0x70>
    __fsr+0x5c:            81 f1 80 01 00 00  xorl  $0x180,%ecx
    __fsr+0x62:            d1 e1              shll  $0x1,%ecx
    __fsr+0x64:            66 81 64 24 00 ff  andw  $0xfcff,0x0(%esp)
                            fc
    __fsr+0x6b:            66 09 4c 24 00    orw    %cx,0x0(%esp)
    __fsr+0x70:            d9 6c 24 00        fldcw  0x0(%esp)
    __fsr+0x74:            83 c4 04          addl  $0x4,%esp
    __fsr+0x77:            59                popl  %ecx
    __fsr+0x78:            5a                popl  %edx
    __fsr+0x79:            5d                popl  %ebp
    __fsr+0x7a:            c3                ret
    0x8050a2b:              90                nop
_mcount()
    _mcount:                c3                ret
    0x8050a2d:              90                nop
    0x8050a2e:              90                nop
    0x8050a2f:              90                nop
__do_global_dtors_aux()
    __do_global_dtors_aux:  55                pushl  %ebp
    0x8050a31:              89 e5              movl  %esp,%ebp
    0x8050a33:              53                pushl  %ebx
    0x8050a34:              e8 00 00 00 00    call  +0x5    <0x8050a39>
    0x8050a39:              5b                popl  %ebx
    0x8050a3a:              81 c3 63 01 01 00  addl  $0x10163,%ebx
    0x8050a40:              52                pushl  %edx
    0x8050a41:              80 bb b8 01 00 00  cmpb  $0x0,0x1b8(%ebx)
                            00
    0x8050a48:              74 0d              je    +0xf    <0x8050a57>
    0x8050a4a:              eb 3a              jmp    +0x3c    <0x8050a86>
    0x8050a4c:              83 c0 04          addl  $0x4,%eax
    0x8050a4f:              89 83 b4 01 00 00  movl  %eax,0x1b4(%ebx)
    0x8050a55:              ff d2              call  *%edx
    0x8050a57:              8b 83 b4 01 00 00  movl  0x1b4(%ebx),%eax
    0x8050a5d:              8b 10              movl  (%eax),%edx
    0x8050a5f:              85 d2              testl  %edx,%edx
    0x8050a61:              75 e9              jne    -0x15    <0x8050a4c>
    0x8050a63:              8b 83 1c 00 00 00  movl  0x1c(%ebx),%eax
    0x8050a69:              85 c0              testl  %eax,%eax
    0x8050a6b:              74 12              je    +0x14    <0x8050a7f>
    0x8050a6d:              83 ec 0c          subl  $0xc,%esp
    0x8050a70:              8d 83 64 01 00 00  leal  0x164(%ebx),%eax
    0x8050a76:              50                pushl  %eax
    0x8050a77:              e8 4c fe ff ff    call  -0x1af    <0x80508c8>
    0x8050a7c:              83 c4 10          addl  $0x10,%esp
    0x8050a7f:              c6 83 b8 01 00 00  movb  $0x1,0x1b8(%ebx)
                            01
    0x8050a86:              8b 5d fc          movl  -0x4(%ebp),%ebx
    0x8050a89:              c9                leave
    0x8050a8a:              c3                ret
    0x8050a8b:              90                nop
frame_dummy()
    frame_dummy:            55                pushl  %ebp
    0x8050a8d:              89 e5              movl  %esp,%ebp
    0x8050a8f:              53                pushl  %ebx
    0x8050a90:              e8 00 00 00 00    call  +0x5    <0x8050a95>
    0x8050a95:              5b                popl  %ebx
    0x8050a96:              81 c3 07 01 01 00  addl  $0x10107,%ebx
    0x8050a9c:              50                pushl  %eax
    0x8050a9d:              8b 83 24 00 00 00  movl  0x24(%ebx),%eax
    0x8050aa3:              85 c0              testl  %eax,%eax
    0x8050aa5:              74 19              je    +0x1b    <0x8050ac0>
    0x8050aa7:              53                pushl  %ebx
    0x8050aa8:              6a 00              pushl  $0x0
    0x8050aaa:              8d 83 bc 01 00 00  leal  0x1bc(%ebx),%eax
    0x8050ab0:              50                pushl  %eax
    0x8050ab1:              8d 83 64 01 00 00  leal  0x164(%ebx),%eax
    0x8050ab7:              50                pushl  %eax
    0x8050ab8:              e8 1b fe ff ff    call  -0x1e0    <0x80508d8>
    0x8050abd:              83 c4 10          addl  $0x10,%esp
    0x8050ac0:              8b 83 b0 01 00 00  movl  0x1b0(%ebx),%eax
    0x8050ac6:              85 c0              testl  %eax,%eax
    0x8050ac8:              74 1e              je    +0x20    <0x8050ae8>
    0x8050aca:              8b 8b 2c 00 00 00  movl  0x2c(%ebx),%ecx
    0x8050ad0:              85 c9              testl  %ecx,%ecx
    0x8050ad2:              74 14              je    +0x16    <0x8050ae8>
    0x8050ad4:              83 ec 0c          subl  $0xc,%esp
    0x8050ad7:              8d 83 b0 01 00 00  leal  0x1b0(%ebx),%eax
    0x8050add:              50                pushl  %eax
    0x8050ade:              e8 05 fe ff ff    call  -0x1f6    <0x80508e8>
    0x8050ae3:              83 c4 10          addl  $0x10,%esp
    0x8050ae6:              89 f6              movl  %esi,%esi
    0x8050ae8:              8b 5d fc          movl  -0x4(%ebp),%ebx
    0x8050aeb:              c9                leave
    0x8050aec:              c3                ret
    0x8050aed:              90                nop
    0x8050aee:              90                nop
    0x8050aef:              90                nop
main()
    main:                  55                pushl  %ebp
    main+0x1:              89 e5              movl  %esp,%ebp
    main+0x3:              83 ec 08          subl  $0x8,%esp
    main+0x6:              83 e4 f0          andl  $0xfffffff0,%esp
    main+0x9:              b8 00 00 00 00    movl  $0x0,%eax
    main+0xe:              83 c0 0f          addl  $0xf,%eax
    main+0x11:              83 c0 0f          addl  $0xf,%eax
    main+0x14:              c1 e8 04          shrl  $0x4,%eax
    main+0x17:              c1 e0 04          shll  $0x4,%eax
    main+0x1a:              29 c4              subl  %eax,%esp
    main+0x1c:              83 ec 0c          subl  $0xc,%esp
    main+0x1f:              68 8c 0b 05 08    pushl  $0x8050b8c
    main+0x24:              e8 df fd ff ff    call  -0x21c    <printf>
    main+0x29:              83 c4 10          addl  $0x10,%esp
    main+0x2c:              c9                leave
    main+0x2d:              c3                ret
    0x8050b1e:              90                nop
    0x8050b1f:              90                nop
__do_global_ctors_aux()
    __do_global_ctors_aux:  55                pushl  %ebp
    0x8050b21:              89 e5              movl  %esp,%ebp
    0x8050b23:              56                pushl  %esi
    0x8050b24:              53                pushl  %ebx
    0x8050b25:              e8 00 00 00 00    call  +0x5    <0x8050b2a>
    0x8050b2a:              5b                popl  %ebx
    0x8050b2b:              81 c3 72 00 01 00  addl  $0x10072,%ebx
    0x8050b31:              8d 83 a4 01 00 00  leal  0x1a4(%ebx),%eax
    0x8050b37:              8d 70 fc          leal  -0x4(%eax),%esi
    0x8050b3a:              8b 40 fc          movl  -0x4(%eax),%eax
    0x8050b3d:              eb 08              jmp    +0xa    <0x8050b47>
    0x8050b3f:              90                nop
    0x8050b40:              83 ee 04          subl  $0x4,%esi
    0x8050b43:              ff d0              call  *%eax
    0x8050b45:              8b 06              movl  (%esi),%eax
    0x8050b47:              83 f8 ff          cmpl  $-0x1,%eax
    0x8050b4a:              75 f4              jne    -0xa    <0x8050b40>
    0x8050b4c:              5b                popl  %ebx
    0x8050b4d:              5e                popl  %esi
    0x8050b4e:              c9                leave
    0x8050b4f:              c3                ret
 
section .init
_init()
    _init:                  55                pushl  %ebp
    _init+0x1:              8b ec              movl  %esp,%ebp
    _init+0x3:              53                pushl  %ebx
    _init+0x4:              e8 00 00 00 00    call  +0x5    <_init+0x9>
    _init+0x9:              5b                popl  %ebx
    _init+0xa:              81 c3 43 00 01 00  addl  $0x10043,%ebx
    _init+0x10:            e8 27 ff ff ff    call  -0xd4    <frame_dummy>
    _init+0x15:            e8 b6 ff ff ff    call  -0x45    <__do_global_ctors_aux>
    _init+0x1a:            5b                popl  %ebx
    _init+0x1b:            c9                leave
    _init+0x1c:            c3                ret
 
section .fini
_fini()
    _fini:                  55                pushl  %ebp
    _fini+0x1:              8b ec              movl  %esp,%ebp
    _fini+0x3:              53                pushl  %ebx
    _fini+0x4:              e8 00 00 00 00    call  +0x5    <_fini+0x9>
    _fini+0x9:              5b                popl  %ebx
    _fini+0xa:              81 c3 23 00 01 00  addl  $0x10023,%ebx
    _fini+0x10:            e8 ab fe ff ff    call  -0x150    <__do_global_dtors_aux>
    _fini+0x15:            5b                popl  %ebx
    _fini+0x16:            c9                leave
    _fini+0x17:            c3                ret
$

P.S. Понятно. 13 - это число символов в "Hello World!" (12) и 13-й символ - конец строки.

Т.е. кодом возврата становится код возврата последней из функций в программе. Т.е. непредсказуемо.

Удаляю 2 буквы:

$ gcc -o hello hello.c
hello.c: In function `main':
hello.c:4: warning: return type of 'main' is not `int'
$ ./hello
Hello rld!
$ echo $?
11
$

Потому что printf напечатал 13 символов. Его возвращенное значение осталось на system stack.

Никто ничего не выкинул.
Возврат нуля из main говорит о нормальном завершении. Ненулевое значение - об ошибке.

Никто точно не скажет. Были где-то оценки, что ополченцев 20 - 30 тыс.. С другой стороны, приводились и оценки численности российских военных (неважно, как их называть, - "отпускниками" или только что уволившимися, или негласно засланными военспецами) в размере 20 тыс. чел. Но, мне представляется, что существеннее другое: без постоянной внешней подпитки вооружением и живой силой этот гражданский конфликт давно бы сошел на нет. А поскольку он искусственно раздувается и поддерживается извне, то я бы не стал называть его гражданским конфликтом.

А почему, если "воююет много больше", процент "иностранцев" меньше, а не больше?

Для "Hello World!" ни в чем.
Однако если у вас система посложнее, и вы мониторите как закончились автоматически активированные процессы, возврат нуля существенен. Вашему диспетчерскому процессу надо знать - успешно или с ошибкой.

Странные рассудения для математика.

Неверно. 2.

Обычно программа пишется для того, чтобы использовать её как кирпич в алгоритме более высокого уровня Например в командном файле. И код возврата важен.

Программа без кода возврата или с непредсказуемым кодом возврата - ну разве только формулу посчитать и оператору на экран выдать слово "правильно" - "не правильно"

Код:

cat "$1" | while read s
do
    echo "$s" | sed 's/^ffplay //' | grep "^http://" > /dev/null
    if [ $? -eq 0 ]
    then
        u=`echo "$s" | sed 's/^ffplay //'`

        ../t $u > /tmp/bmessage$$
        if [ $? -eq 0 ]
        then
            echo "+ ffplay $u"
            echo "ffplay $u" >> "result_$1"
        else
            echo "- ffplay $u `cat /tmp/bmessage$$ | head -1`"
        fi
        rm /tmp/bmessage$$
    else
        echo "$s" >> "result_$1"
        echo "$s"
    fi
done

Программа t в 8 строке выдаёт код возврата 0 или 1 в зависимости от "работает" (0), "не работает" (1) телевизионный сервер, URL которого задан параметром $u

Программа t выглядит так:



Дарю.