LINUX.ORG.RU
← Задачка из школьной олимпиады
С++ Qt4 хочу мигрировать на это добро с Java/swing →

Конечная память не тру. И вообще, напиши компилятор для него. Хоть чуточку интереснее будет

anonymous
()
Ответ на: комментарий от anonymous

Разве что транслятор в Си :-)

Но мне пока и так интересно.

ip1981 ☆☆
() автор топика
Ответ на: комментарий от ip1981

Признаю, формулировка совсем идиотская. Имелось ввиду, что ваш маленький чанк памяти кончится куда раньше, чем доступная память в вашей системе.

А насчёт компилятора как?

anonymous
()

Охохо, у меня длиннее :P

        .section .data

prog:
        .ascii ">++++++++[-<++++++++++>]<.>++++[-<++++>]<+.>++++[-<++++>]<++..\
>>+++++++[-<++++++++>]<++.>>>+[-[>+],>++++++++++[-<---------->\
]<----]>++++++++++[-<+++++++>]<+>+[-[<+],>++++++++[-<------>]<\
-]>++++++++++[-<+++++++++++>]<+>+[-[>+],>++++++++++[-<--------\
-->]<]>++++++++++[-<++++++++++>]+[-[<+],>++++++++++[-<--------\
-->]<]>++++++++[-<++++>]+[-[>+],>+++++++[-<------->]<--]>+++++\
+++++++[-<+++++++++>]<-->+[-[<+],>+++++++++++[-<---------->]<]\
<<<<<.>..>.>.>.<<<.>--.\0"
# h1dd3n

        .section .bss

        .lcomm mem, 30000


        .section .text

        .globl _start
_start:
        # eax - instruction pointer
        # ecx - memory pointer
        xorl %eax, %eax
        xorl %ecx, %ecx

main__loop:
        cmpb $0, prog(%eax)
        je main__finish
        cmpb $'>', prog(%eax)
        je main__more
        cmpb $'<', prog(%eax)
        je main__less
        cmpb $'+', prog(%eax)
        je main__plus
        cmpb $'-', prog(%eax)
        je main__minus
        cmpb $'.', prog(%eax)
        je main__point
        cmpb $',', prog(%eax)
        je main__comma
        cmpb $'[', prog(%eax)
        je main__left_bracket
        cmpb $']', prog(%eax)
        je main__right_bracket

main__loop__next_iter:
        incl %eax
        jmp main__loop

main__more:
        incl %ecx
        jmp main__loop__next_iter

main__less:
        decl %ecx
        jmp main__loop__next_iter

main__plus:
        incb mem(%ecx)
        jmp main__loop__next_iter

main__minus:
        decb mem(%ecx)
        jmp main__loop__next_iter

main__point:
        pushl %eax
        pushl %ecx

        movl $4, %eax    # write
        movl $1, %ebx    # stdout
        addl $mem, %ecx
        movl $1, %edx
        int $0x80

        popl %ecx
        popl %eax

        jmp main__loop__next_iter

main__comma:
        pushl %eax
        pushl %ecx

        movl $3, %eax    # read
        movl $0, %ebx    # stdin
        addl $mem, %ecx
        movl $1, %edx
        int $0x80

        popl %ecx
        popl %eax

        jmp main__loop__next_iter

main__left_bracket:
        cmpb $0, mem(%ecx)
        jne main__left_bracket_mem_nonzero

        incl %eax
        pushl %eax
        pushl $1
        call forward
        addl $8, %esp

        jmp main__loop

main__left_bracket_mem_nonzero:
        jmp main__loop__next_iter

main__right_bracket:
        cmpb $0, mem(%ecx)
        je main__right_bracket_mem_zero

        decl %eax
        pushl %eax
        pushl $1
        call backward
        addl $8, %esp

        jmp main__loop

main__right_bracket_mem_zero:
        jmp main__loop__next_iter

main__finish:
        movl $1, %eax
        movl $0, %ebx
        int  $0x80


        .type forward, @function
        # forward (depth, index)
forward:
        pushl %ebp
        movl %esp, %ebp

        movl 8(%ebp), %ebx
        movl 12(%ebp), %eax

forward__loop:
        cmpl $0, %ebx
        je forward__end
        cmpb $'[', prog(%eax)
        je forward__left_bracket
        cmpb $']', prog(%eax)
        je forward__right_bracket

forward__loop__next_iter:
        incl %eax
        jmp forward__loop

forward__left_bracket:
        incl %ebx
        jmp forward__loop__next_iter

forward__right_bracket:
        decl %ebx
        jmp forward__loop__next_iter

forward__end:
        movl %ebp, %esp
        popl %ebp
        ret

        .type backward, @function
        # backward (depth, index)
backward:
        pushl %ebp
        movl %esp, %ebp

        movl 8(%ebp), %ebx
        movl 12(%ebp), %eax

backward__loop:
        cmpl $0, %ebx
        je backward__end
        cmpb $'[', prog(%eax)
        je backward__left_bracket
        cmpb $']', prog(%eax)
        je backward__right_bracket

backward__loop__next_iter:
        decl %eax
        jmp backward__loop

backward__left_bracket:
        decl %ebx
        jmp backward__loop__next_iter

backward__right_bracket:
        incl %ebx
        jmp backward__loop__next_iter

backward__default:

backward__end:
        addl $2, %eax
        movl %ebp, %esp
        popl %ebp
        ret
satanic-mechanic ★
()
Ответ на: комментарий от anonymous

Параметры -s и -d --- размеры стека и данных.

ip1981 ☆☆
() автор топика
Ответ на: комментарий от anonymous

> А насчёт компилятора как?

Сначала этот отлажу, а потом - может быть.

ip1981 ☆☆
() автор топика

Отладил :-)

# echo ',[.-];5' | ./brainfuck
5
4
3
2
1

ip1981 ☆☆
() автор топика

Настоящий интерпретатор брейнфака должен быть написан на брейнфаке. На Си любой дурак может написать.

Reset ★★★★★
()
Ответ на: комментарий от Reset

А ещё пять звёзд.

Ещё скажите, что для настоящего языка компьютер не нужен.

ip1981 ☆☆
() автор топика
Ответ на: комментарий от ip1981

действительно, люди пишут на bf исключительно в практических целях

gavv
()
Ответ на: комментарий от ip1981

>Мсье знает, что МозгоЙоп работает с состояниями, а для Хаскеля состояния - чужеродны?

не пиши глупостей. Это тут не при чем. И бесконечную ленту брейнфаковскую можно красивее, чем на Си сделать.

Waterlaz ★★★★★
()
Ответ на: комментарий от anonymous

Скучные вы :-) Зачем вас рожали, и так людей хватает.

ip1981 ☆☆
() автор топика
Ответ на: комментарий от ip1981

МозгоЙоп - это банально. Вот я видал компилер некоего подмножества схемы в Funge98. Вот это уже гораздо интереснее.

anonymous
()

http://github.com/ip1981/brainfuck

Я добавил отладчик (параметр -t)

Пример - сдвинуть указатель на заданное число ячеек вправо:

# echo ', [-[->+<]>];4' | ./brainfuck -u -t
,: [4]
[: [4]
-: [3]
[: [3]
-: [2]
>: 2 [0]
+: 2 [1]
<: [2] 1
]: [2] 1
[: [2] 1
-: [1] 1
>: 1 [1]
+: 1 [2]
<: [1] 2
]: [1] 2
[: [1] 2
-: [0] 2
>: 0 [2]
+: 0 [3]
<: [0] 3
]: [0] 3
[: [0] 3
>: 0 [3]
]: 0 [3]
[: 0 [3]
-: 0 [2]
[: 0 [2]
-: 0 [1]
>: 0 1 [0]
+: 0 1 [1]
<: 0 [1] 1
]: 0 [1] 1
[: 0 [1] 1
-: 0 [0] 1
>: 0 0 [1]
+: 0 0 [2]
<: 0 [0] 2
]: 0 [0] 2
[: 0 [0] 2
>: 0 0 [2]
]: 0 0 [2]
[: 0 0 [2]
-: 0 0 [1]
[: 0 0 [1]
-: 0 0 [0]
>: 0 0 0 [0]
+: 0 0 0 [1]
<: 0 0 [0] 1
]: 0 0 [0] 1
[: 0 0 [0] 1
>: 0 0 0 [1]
]: 0 0 0 [1]
[: 0 0 0 [1]
-: 0 0 0 [0]
[: 0 0 0 [0]
>: 0 0 0 0 [0]
]: 0 0 0 0 [0]
[: 0 0 0 0 [0]

ip1981 ☆☆
() автор топика
Ответ на: комментарий от ip1981

а где пошаговая отладка и флаги оптимизаций?

l5k
()

Выбор наибольшего из двух чисел:

вводим первое число:
, # |a|0|0|0|0|0|

копируем его во вторую и пятую ячейки:
[->+>>>+<<<<] # |0|a|0|0|a|0|

вводим второе число:
, # |b|a|0|0|a|0|

копируем его в третью и шестую ячейки:
[->>+>>>+<<<<<] # |0|a|b|0|a|b|

переходим ко второй ячейке:





Ищем максимум

уменьшаем обе ячейки (2 и 3) на единицу одновременно,
ждём пока одна из них не обнулится:
[[->]<<]


конечное положение указателя зависит от того, какое число больше,
перемещаемся на 4 ячейки:




попадаем на ответ и печатаем его:
.


Например:
echo ',[->+>>>+<<<<] ,[->>+>>>+<<<<<] > [[->]<<] >>>>. ; 121 33' | ./brainfuck

ip1981 ☆☆
() автор топика

Интерпретатор brainfuck - слишком скучно и не интересно. Хотя бы потому что пишется с пол пинка и не требует каких либо умственных усилий.

Куда более интересная задача (но всё также весьма тривиальная), это написать калькулятор, принимающий на вход строку-выражение типа «12 + (56e-2 * 44.8) ^ 2 - sin(40)». Тут хоть можно чуть-чуть подумать размять извилины над парсером.

NightmareZ
()
Ответ на: комментарий от ip1981

Разомните извилины над раскодированием комментариев ;-)

ip1981 ☆☆
() автор топика
Ответ на: комментарий от ip1981

> Это я дела ещё на втором курсе. На Паскале.

Довольно симпатично всё выглядит.

А интерпретатор чего-нить более серьёзного не пробывал писать? Например, урезанного бейсика.

NightmareZ
()
Ответ на: комментарий от NightmareZ

> А интерпретатор чего-нить более серьёзного не пробовал писать?

Нет :-)

ip1981 ☆☆
() автор топика
Вы не можете добавлять комментарии в эту тему. Тема перемещена в архив.
← Задачка из школьной олимпиады
Development
С++ Qt4 хочу мигрировать на это добро с Java/swing →