Наткнулся на статью, аж прослезился, как fasm автор опустил

halyavin
некоторый вывод можно сделать из wasm.ru/article.php?article=privalov_ru

 

10110111
> эта прога выводит себя как есть. Или я что-то упустил?
ты упустил постановку задачи.
во всех приведенных примерах программа А печатает программу B,
а должна печатать себя саму. всегда. а так мы получаем частное
решения для случая когда A == B. а примеры на Си еще страдают
тем, что не печатают инклуды, то есть A != B и, скажем, перенаправив
печать в .c/.cpp файл мы его уже не откомпилим. а если даже откомпилим,
то это будет чудом и случайным совпадением

на компилируемых языках поставленна задача неразрешима
уже в силу того, что на выходе компилятора получается совсем
не то, что было на входе. скажем, ты пишешь:
main()
{
int z = 0;
int a = 1/z;
...
код, распечатывающий программу
...
}

то в коде, распечатывающим программу, ты должен
дизассемблировать целевой компилятор, считать параметры
среды IDE, взять ключи компиляции и определить:
а чему все-таки равна переменная a?
с точки зрения Си - она равна 1/0, то есть программа
должна грохаться, потому как на ноль делить нельзя.
но откомилировав ее MS VC с ключом /Ox ты удивишься,
что она не грохается. ну все правильно, переменная a
не используется и потому компилятор ее выкинут нахих.

а ты чего тут распечатал?!
следовательно, программа, печатающая свой _исходный_ _текст_
не решает поставленную задачу, поскольку представляет собой
частный случай A == B, не учитывающий, что компилятор может
менять логику работы программы

интерпретируемые языки уже позволяют писать программы,
печтающие себя, т.к. они могут просто прочесть байт-код.
ну или машинный код, если программировать в кодах
в результате мы получим программму, которая действительно
печатает ___СЕБЯ___ а не некоторую программу похожую на нее.

 

kaspersky
Постановка задачи:

Комментарий:

Очевидно противоречие.

В данном случае программа написана на ассемблере, компилятор не будет менять её логику.

 

10110111
Я тут по твоему образчику написал:

Код (Text):

1. #include <stdio.h>
2. #define N1 5
3. #define N2 33
4. char* body[]=
5. {
6. "#include <stdio.h>",
7. "#define N1 5",
8. "#define N2 33",
9. "char* body[]=",
10. "{",
11. "};",
12. "int main(void)",
13. "{",
14. "int k; char v[2];",
15. "v[1]=0;",
16. "for (k = 0; k < N1; k++)",
17. "{",
18. "printf(body[k]);",
19. "v[0]=10; printf(v);",
20. "}",
21. "for (k = 0; k < N2-1; k++)",
22. "{",
23. "v[0]=34; printf(v);",
24. "printf(body[k]);",
25. "printf(v);",
26. "v[0]=44; printf(v);",
27. "v[0]=10; printf(v);",
28. "}",
29. "v[0]=34; printf(v);",
30. "printf(body[k]);",
31. "printf(v); v[0]=10; printf(v);",
32. "for (k = N1; k < N2; k++)",
33. "{",
34. "printf(body[k]);",
35. "v[0]=10; printf(v);",
36. "}",
37. "return 0;",
38. "}"
39. };
40. int main(void)
41. {
42. int k; char v[2];
43. v[1]=0;
44. for (k = 0; k < N1; k++)
45. {
46. printf(body[k]);
47. v[0]=10; printf(v);
48. }
49. for (k = 0; k < N2-1; k++)
50. {
51. v[0]=34; printf(v);
52. printf(body[k]);
53. printf(v);
54. v[0]=44; printf(v);
55. v[0]=10; printf(v);
56. }
57. v[0]=34; printf(v);
58. printf(body[k]);
59. printf(v); v[0]=10; printf(v);
60. for (k = N1; k < N2; k++)
61. {
62. printf(body[k]);
63. v[0]=10; printf(v);
64. }
65. return 0;
66. }

 

crypto
Недоделка:
Изначальный:

Код (Text):

1. "v[0]=10;",
2. "v[0]=34;",
3. "v[0]=44;",
4. "return 0;",
5. [b]"}",
6. };
7. int main(void)[/b]
8. {

Вывод:

Код (Text):

1. "v[0]=10;",
2. "v[0]=34;",
3. "v[0]=44;",
4. "return 0;",
5. [b]"}",
6. int main(void)[/b]

 

10110111
Подправил.

 

хочу глупый вопрос задать: а зачем проги вообще себя печатать, что делать больше нечего???:-D

 

UbIvItS
ХЗ, просто интересная задачка=)
kaspersky

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

 

А как вам такая идея-откомпилированная прога просто открывает свой исходник и выводит его в консоль?

 

такое обсуждалось по сцылке на винград. Но это не интересно.

 

10110111
если уж ты такой любитель интересных задач, вот тебе реально сложная и, самое главное, реально нужная задача: прога берёт прогу А и пишет прогу B c тем же функционалом, но в оптимайзном варианте по скорости или размеру, или соотношением: speed/size ) ============> вот это одна из задач для МОНСТРА!!!!

 

К чему обсуждения? Достаточно запомнить аксиому: FASM - остой, MASM - рулит!

 

Так все просто... Человек, вы случаем не наркоман?

Ты тут много чего про форум высказал... Много нехороших слов... Знаешь, есть поговорка - "в чужой монастырь со своим уставом не лезь". Вот попробуй, своими мозгами, постичь то, о чем в ней говорится. У каждого свое мнение об этом форуме, и пусть этот "каждый" оставит его при себе, если пытается задавать тут какие-то вопросы.
Это элементарное "человеческое" правило, будь добр - соблюдай.

 

zoool
> Достаточно запомнить аксиому: FASM - остой, MASM - рулит!
что для нижних потолок, то для верхних - пол
а если серьезно, то разные задачи требуют разных инструментов.
FASM отстоем быть не может, хотя бы уже потому, что он собрал
вокруг себя достаточно большое кол-во поклонников, число
которых только растет. если бы он был отстоем, то все бы уже
давно забили на него и разбежались. такое бывает с некоторыми
программами. сначала всплеск интереса, а потом обавльное
падение популярности и продукт списывается в морг...


10110111
постановка задачи "программа печатающей саму себя" возникла
в те времена, когда проводились эксперименты (мысленные в
основном) с самовоспроизводящимися автоматами, собирающими
себя по своему образу и подобию с учетом мутаций, возникающих
при этом. позитивные мутации - сохраняются, негативные - гробят
автомат и он уже больше ничего не производит. таким образом,
мы получаем "машинную эволюцию". сейчас мы не будем говорить
о том как реализовать мутации в конкретном коде, т.к. это далеко
выходит за рамки изначальной постановки задачи, но вот что тут
получается... если автомат собирает себя не по своему образу и
подобию, а по заложенному в него чертежу самого себя, то тут...
мутации _не_ передаются, то есть передаются, но не те которые
были у автомата. скажем, произошла мутация в чертеже и теперь
автомат клепает галимых потомков, которые даже не запускаются.
и что? он и дальше будет их клепать равно как и наборот, если
у самого автомата появилась полезная мутация, обеспечивающая
ему выживание, то она не будет передана потомкам, т.к. ее нет в
"чертеже"... так что, для решения поставленной задачи, автомат
должен иметь способ копировать самого себя.

когда же эта задача попала в широкие массы она вульгализировалась.
решение на бейсике оператором LIST, очевидно, не есть решение
с математической точки зрения, поскольку, за нас все делает язык.
хотя это верное решение с инженерной точки зрения, т.к. программа
действительно печтает саму себя...

а вот решение на Си - это просто "увертка", обусловленная не вполне
корректной постановкой задачи, вернее, неправильным ее пониманием.
формально задача решена, но на самом деле требовалось нечто иное,
чем освободиться от бесконечной рекурсии типа print print print....
которая "разрывается" путем введения переменных или как-то еще.
а это уже совсем не та задача

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

в исходной формулировке данная задача не решена до сих пор,
а все имеющиеся "решения" основаны на разных увертах
и отмазках... ну это как если бы предложили найти способ
разложения чисел на множетели в общем виде, а вы бы
сказали: а какая проблема?! вот я даже программу написал
а что тут писать?!

PRINT РАЗЛОЖИ_ЧИСЛО_НА_МНОЖИТЕЛИ(A)

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

 

fasm'у не хватает гибкости определения набора команд, типа ".686", или какое-нибудь "use\dontuse".

 

kaspersky
Согласен, реализация несколько в стороне Но вот зацепил меня бинарный формучанин своим решением, сон не шел ни в какую, пришлось сесть за комп, чтобы мозги прочистить.
ЗЫ
В результате все равно не удалось поспать - мозги занялись поиском более "изящного" решения.
UbIvItS
Делать много чего есть, но кое-кто (не будем показывать пальцем, но это был Убивец) ИМХО тоже фигней любит страдать.

 

Как компилируемая программа может сама себя вывести на экран, если для этого нжно написать программму, котороя выводит текст программы, которая выводит текст программы, которая выводит текст программы, которая, в свою очередь, выводит текст программы и т.д.?!

 

о, я наконец-то понял все то, о чем выше kaspersky так трепетно распинался.

вспомнил, что класс таких программ наз. "Quines" ("Квайны").
о Квайнах можно почитать на Википедии.
здесь, в Википедии, говорится, что

и еще:

т.е. Квайнам вообще не нужно заниматься всем этим анализом, про который kaspersky выше объяснял, т.к. это уже будет не Квайн, а какой-то другой вид программ, которым пока что нету названия

так что получается, что любая программа на любом ЯП (как компилируемом, так и интерпретируемом), выводящая весь свой листинг на экран (в консоль итд) является валидным Квайном. и ей воообще не нужно заниматься реализацией действий алгоритма исходной программы (как то: вычислять значения каких-нибудь переменных, ф-ций, блоков кода, итд), т.к. такого требования в определении Квайна _нет_.
ей нужно всего лишь вывести свой сорец на экран(в консоль итд).

 

это не мы отмазались, это в определении самого Квайна эта отмазка изначально имела место быть. а "мы" её експлуатируем только)

так что, давайте найдем и попинаем того перца, который изначально наделил само понятие "Квайн" таким примитивным смыслом, тем самым лишив всех программеров "удовольствия" ломания своих мозгов попытками реализации автодизассемблеров, автодекомпиляторов и т.д для реализации Мегаквайнов_Которые_Могли_Бы_Требовать_Реализации_В_Себе_Всех_Действий_Самих_Себя, Но_Вопреки_Текущему_Определению_Квайна_-_Не_Требуют_Такой_Хренотени )