Здравствуйте, WolfHound, Вы писали:

WH>Нет тут все на много проще... компилятор просто выкидывает вызов функции которая ни чего не возвращает и не содержит побочных эффектов...

Ну, это возможно. Но если не выкинит, то 0 сек. обеспечено в следствии вылета.

Здравствуйте, Nick_, Вы писали:

N_>Здравствуйте, VladD2, Вы писали:

VD>>Здравствуйте, Nick_, Вы писали:

N_>>>Синтаксический анализ невозможно сделать до лукапа, а лукап до инстанциации.

VD>>Синтаксический как раз легко. Ты говоришь о разрешение имен.

N_>В том примере, который я приводил синтаксический анализ существенно зависит от того, что такое T::x.

Ёлы-плаы. Ну, загляни в гугль. Погляди чем синтаксический анализ отличается от семантического. Ну, и что такое вообще синтаксический анализ.

N_> Его нельзя провести, если не сделать предположение о том, что T::x — не тип.

Да пофигу для синтаксического разбора чем будет эта конструкция. Тип, не тип — это уже семантика.

Ну, а макросы они вообще без синтаксического разбора работают. Это просто текстовые операции.

N_>Легко провести лексический анализ, что компиляторы и делают. С каждым шаблоном ассоциируется цепочка лексем. А синтаксический анализ проводится при инстанциации.

Нда. Гугль тебе в руки. Ты все перепутал.

N_>Но это не суть. Я все это к тому, что шаблоны в С++ недалеко ушли от макросов.

Да далеко. Но не доконца. Проблем хватает. Но тут оно как. Очень многие недостатки являются продолжениями достоинств. Если гибко, то обязательно будет небезопасно. И наоборот. Вот в дженериках проблем с поздними проврками нет. Но и гибкость ниже.

Здравствуйте, Alexey Chen, Вы писали:

AC>Включите. Это будет здорово! Хотя, со временем хтелось бы развернутую статью именно по F# с точки зрения его полжения в семействе # и как этим успешно пользоваться.

Дык не зная что такое ОКамл будет практически невозможно понять, что такое F#.

AC>Как мне например вынести из приложения на C# или C++ реально функциональный код и написать его на F#-е. Это было бы очень интересно.

Ну, это вроде как довольно просто. F# порождает стандартные дотнтные сборки. Так что достаточно оформить нужные входные точки (на F#) и использовать эти функции из Шарпа подключив сборку созданную на F# к Шарповскому прокту.

Здравствуйте, Quintanar, Вы писали:

Q>У меня, например, есть пара парсеров на OCaml. Один интерпретор примитивного языка, а другой конвертатор из bnf в sml yacc. Могу их выложить, хотя я ими не очень доволен, писал их когда еще слабо разбирался в функциональном стиле.

Выкладывай. Хуже не будет. А пример есть пример.

Здравствуйте, FR, Вы писали:

FR>А вообще пусть компиляторы "жульничают" при условии что выдают корректные результаты.

Для этого результаты должны быть осмысленными и предсказауемыми.

Здравствуйте, VladD2, Вы писали:

VD>Код вообще некорректен и рабоать вряд ли сможет.
Хм, чем это он некорректен? Полностью соответствует стандарту.

VD>Ну, и столь вольные допущения компиляторы пока что не делают.
Для самых любознательных привожу ассемблерный вид, к которому преобразовал эту программу VC7.1

00401000  xor         eax,eax 
00401002  ret

Как думаешь, сколько времени это будет выполняться?

А вот еще пример из той же оперы:

int CalcSuperNumber(int n)
{
    for( int i=0, k=0; i < 500000000; ++i ) // ПЯТЬСОТ миллионов!!!!!!!
    {
        k += n;
    }
    return k;
}
int main()
{
    printf( "%i", CalcSuperNumber(10) );
    return 0;
}

Тут программа уже посложнее, имеется побочный эффект — вывод результата на консоль. Сколько же она будет работать? Минуту, две? .
А нисколько!
Потому как компилятор нынче пошел на редкость умен и сообразителен. Вот что получим на выходе:

00401070  push        2A05F200h         ; А вот это и есть готовый результат :)
00401075  push        offset KERNEL32_NULL_THUNK_DATA+2Ch (4060FCh) 
0040107A  call        printf (4010CDh) 
0040107F  add         esp,8 
00401082  xor         eax,eax

Какая досада, комнилятор сразу подставил готорый результат еще во время компиляции

Здравствуйте, prVovik, Вы писали:

V>Какая досада, комнилятор сразу подставил готорый результат еще во время компиляции

Знал бы ты какой ценой это дается разработчикам компиляторов.
Сначала программа переводится в SSA форму, над которой потом делаются оптимизации.
Так вот сюрпиз! SSA форма — это функциональная программа
http://citeseer.ist.psu.edu/appel98ssa.html

В функциональных языках сделать такие оптимизации на порядок проще, потому что компилятору легче вытянуть смысл из того, что написал программист.

Здравствуйте, VladD2, Вы писали:

VD>Ёлы-плаы. Ну, загляни в гугль. Погляди чем синтаксический анализ отличается от семантического. Ну, и что такое вообще синтаксический анализ.

N_>> Его нельзя провести, если не сделать предположение о том, что T::x — не тип.

VD>Да пофигу для синтаксического разбора чем будет эта конструкция. Тип, не тип — это уже семантика.

Почитай на досуге грамматику С++ или С.

Для синтаксического анализа как раз важно, чем является символ — идентификатором или типом.
например:
x y;
Если x — не тип, то возникнет синтаксическая ошибка. До семантического анализа даже не дойдет.
Еще один пример:
если в выражении после `(' стоит тип, то это c-style cast, и по синтаксису, после `)' должно быть выражение.
а если после `(' не тип, то это просто скобки подвыражения, и после них может быть `;'
Хочешь сказать, что это семантика?

Здравствуйте, Nick_, Вы писали:

N_>Здравствуйте, prVovik, Вы писали:

V>>Какая досада, комнилятор сразу подставил готорый результат еще во время компиляции

N_>Знал бы ты какой ценой это дается разработчикам компиляторов.
N_>Сначала программа переводится в SSA форму, над которой потом делаются оптимизации.
N_>Так вот сюрпиз! SSA форма — это функциональная программа
N_>http://citeseer.ist.psu.edu/appel98ssa.html

N_>В функциональных языках сделать такие оптимизации на порядок проще, потому что компилятору легче вытянуть смысл из того, что написал программист.
ты хотя раз видел этот ssa?

а вот в gcc 4 появится ещё одно промежуточное представление императивное(GIMPLE) c С подобным синтаксисом, они говорят после этого возможности оптимизации увеличатся на порядок.

Здравствуйте, naje, Вы писали:

N>Здравствуйте, Nick_, Вы писали:

N_>>Здравствуйте, prVovik, Вы писали:

V>>>Какая досада, комнилятор сразу подставил готорый результат еще во время компиляции

N_>>Знал бы ты какой ценой это дается разработчикам компиляторов.
N_>>Сначала программа переводится в SSA форму, над которой потом делаются оптимизации.
N_>>Так вот сюрпиз! SSA форма — это функциональная программа
N_>>http://citeseer.ist.psu.edu/appel98ssa.html

N_>>В функциональных языках сделать такие оптимизации на порядок проще, потому что компилятору легче вытянуть смысл из того, что написал программист.
N>ты хотя раз видел этот ssa?

вот кстати rtl дамп програмки используемой в статье:

;; Function int main(int, char **)
(note 2 0 3 "" NOTE_INSN_DELETED)
(note 3 2 4 "" NOTE_INSN_DELETED)
(note 4 3 5 "" NOTE_INSN_FUNCTION_BEG)
(note 5 4 7 "" NOTE_INSN_DELETED)
(note 7 5 8 0 NOTE_INSN_BLOCK_BEG)
(note 8 7 11 "" NOTE_INSN_DELETED)
(insn 11 8 12 (set (mem/f:SI (plus:SI (reg:SI 18)
                (const_int -4 [0xfffffffc])) 0)
        (const_int 1 [0x1])) -1 (nil)
    (nil))

(note 12 11 15 "" NOTE_INSN_DELETED)
(insn 15 12 16 (set (mem/f:SI (plus:SI (reg:SI 18)
                (const_int -8 [0xfffffff8])) 0)
        (const_int 1 [0x1])) -1 (nil)
    (nil))
(note 16 15 19 "" NOTE_INSN_DELETED)
(insn 19 16 21 (set (mem/f:SI (plus:SI (reg:SI 18)
                (const_int -12 [0xfffffff4])) 0)
        (const_int 1 [0x1])) -1 (nil)
    (nil))
(note 21 19 60 "" NOTE_INSN_LOOP_BEG)
(note 60 21 22 "" NOTE_INSN_LOOP_CONT)
(code_label 22 60 23 3 "" [num uses: 0])
(note 23 22 24 "" NOTE_INSN_DELETED)
(insn 24 23 25 (set (cc0)
        (compare (mem/f:SI (plus:SI (reg:SI 18)
                    (const_int -12 [0xfffffff4])) 0)
            (const_int 99 [0x63]))) -1 (nil)
    (nil))
(jump_insn 25 24 26 (set (pc)
        (if_then_else (le (cc0)
                (const_int 0 [0x0]))
            (label_ref 28)
            (pc))) -1 (nil)
    (nil))
(jump_insn 26 25 27 (set (pc)
        (label_ref 64)) -1 (nil)
    (nil))
(barrier 27 26 28)
(code_label 28 27 29 5 "" [num uses: 0])
(note 29 28 31 "" NOTE_INSN_DELETED)
(note 31 29 32 "" NOTE_INSN_DELETED)
(insn 32 31 33 (set (cc0)
        (compare (mem/f:SI (plus:SI (reg:SI 18)
                    (const_int -8 [0xfffffff8])) 0)
            (const_int 19 [0x13]))) -1 (nil)
    (nil))
(jump_insn 33 32 35 (set (pc)
        (if_then_else (gt (cc0)
                (const_int 0 [0x0]))
            (label_ref 47)
            (pc))) 349 {bleu+1} (nil)
    (nil))
(note 35 33 37 "" NOTE_INSN_DELETED)
(note 37 35 39 "" NOTE_INSN_DELETED)
(insn 39 37 40 (set (reg:SI 22)
        (mem/f:SI (plus:SI (reg:SI 18)
                (const_int -4 [0xfffffffc])) 0)) -1 (nil)
    (nil))
(insn 40 39 42 (set (mem/f:SI (plus:SI (reg:SI 18)
                (const_int -8 [0xfffffff8])) 0)
        (reg:SI 22)) -1 (nil)
    (nil))
(note 42 40 44 "" NOTE_INSN_DELETED)
(insn 44 42 45 (set (mem/f:SI (plus:SI (reg:SI 18)
                (const_int -12 [0xfffffff4])) 0)
        (plus:SI (mem/f:SI (plus:SI (reg:SI 18)
                    (const_int -12 [0xfffffff4])) 0)
            (const_int 1 [0x1]))) -1 (nil)
    (nil))
(jump_insn 45 44 46 (set (pc)
        (label_ref 59)) -1 (nil)
    (nil))
(barrier 46 45 47)
(code_label 47 46 49 6 "" [num uses: 0])
(note 49 47 51 "" NOTE_INSN_DELETED)
(note 51 49 53 "" NOTE_INSN_DELETED)
(insn 53 51 54 (set (reg:SI 23)
        (mem/f:SI (plus:SI (reg:SI 18)
                (const_int -12 [0xfffffff4])) 0)) -1 (nil)
    (nil))
(insn 54 53 56 (set (mem/f:SI (plus:SI (reg:SI 18)
                (const_int -8 [0xfffffff8])) 0)
        (reg:SI 23)) -1 (nil)
    (nil))
(note 56 54 58 "" NOTE_INSN_DELETED)
(insn 58 56 59 (set (mem/f:SI (plus:SI (reg:SI 18)
                (const_int -12 [0xfffffff4])) 0)
        (plus:SI (mem/f:SI (plus:SI (reg:SI 18)
                    (const_int -12 [0xfffffff4])) 0)
            (const_int 2 [0x2]))) -1 (nil)
    (nil))
(code_label 59 58 61 7 "" [num uses: 0])
(jump_insn 61 59 62 (set (pc)
        (label_ref 22)) -1 (nil)
    (nil))
(barrier 62 61 63)
(note 63 62 64 "" NOTE_INSN_LOOP_END)
(code_label 64 63 66 4 "" [num uses: 0])
(note 66 64 68 "" NOTE_INSN_DELETED)
(insn 68 66 70 (set (reg:SI 25)
        (mem/f:SI (plus:SI (reg:SI 18)
                (const_int -8 [0xfffffff8])) 0)) -1 (nil)
    (nil))
(insn 70 68 71 (set (reg/i:SI 0 %eax)
        (reg:SI 25)) -1 (nil)
    (nil))
(insn 71 70 72 (use (reg/i:SI 0 %eax)) -1 (nil)
    (nil))
(jump_insn 72 71 73 (set (pc)
        (label_ref 83)) -1 (nil)
    (nil))
(barrier 73 72 74)
(note 74 73 75 0 NOTE_INSN_BLOCK_END)
(note 75 74 77 "" NOTE_INSN_DELETED)
(insn 77 75 78 (set (reg/i:SI 0 %eax)
        (const_int 0 [0x0])) -1 (nil)
    (nil))
(insn 78 77 79 (use (reg/i:SI 0 %eax)) -1 (nil)
    (nil))
(jump_insn 79 78 80 (set (pc)
        (label_ref 83)) -1 (nil)
    (nil))
(barrier 80 79 81)
(note 81 80 83 "" NOTE_INSN_FUNCTION_END)
(code_label 83 81 0 2 "" [num uses: 0])

как видно от функциональных языков остаётся только схемовский синтаксис и всё, в остальном это просто платформенно независимы асемблер, или кто-то скажет что jump_insn это функциональная конструкция?

Здравствуйте, naje, Вы писали:

N_>>В функциональных языках сделать такие оптимизации на порядок проще, потому что компилятору легче вытянуть смысл из того, что написал программист.
N>ты хотя раз видел этот ssa?
Да.

N>а вот в gcc 4 появится ещё одно промежуточное представление императивное(GIMPLE) c С подобным синтаксисом, они говорят после этого возможности оптимизации увеличатся на порядок.
Просто так оптимизации в компиляторы не вставляют. Для любой оптимизации надо сначала доказать, что она не меняет семантику кода. А для этого в свою очередь нужен способ, который бы позволил сказать, что два разных алгоритма делают одно и то же. В общем случае, эта задача алгоритмически неразрешима. Но для более узких типов эквивалентности алгоритмов это можно сделать. Кроме того алгоритм должет быть как-то записан. Для некоторых форм записи провести доказательство правильности оптимизации проще чем для других. SSA — это уже де-факто стандартная форма записи алгоритмов. Большинство доказательств корректности оптимизаций делается для оптимизайций SSA формы. В большинстве современных компиляторов используется SSA форма, как внутреннее представление программы.

PS: Ну а gcc для меня не авторитет.

Здравствуйте, naje, Вы писали:

N>вот кстати rtl дамп програмки используемой в статье:

N>как видно от функциональных языков остаётся только схемовский синтаксис и всё, в остальном это просто платформенно независимы асемблер, или кто-то скажет что jump_insn это функциональная конструкция?

register transfer language — это действительно, переносимый ассемблер. высокоуровневые оптимизации на этом представлении не сделаешь. И то, что в gcc используется только rtl для представления программы ему чести не делает.

Здравствуйте, Nick_, Вы писали:

N_>Здравствуйте, naje, Вы писали:

N>>вот кстати rtl дамп програмки используемой в статье:

N>>как видно от функциональных языков остаётся только схемовский синтаксис и всё, в остальном это просто платформенно независимы асемблер, или кто-то скажет что jump_insn это функциональная конструкция?

N_>register transfer language — это действительно, переносимый ассемблер. высокоуровневые оптимизации на этом представлении не сделаешь. И то, что в gcc используется только rtl для представления программы ему чести не делает.

вобще-то rtl это какраз и есть представление ssa
я вот только не пойму, если верить той статье, то компилятор из нормальный цикл переводит в рекурсию, после чего обратно в цикл, может покажешь мне продолжение этой статьи, о том как компиляторы из рекурсий в ssa оптять делают циклы?

Здравствуйте, prVovik, Вы писали:

VD>>Код вообще некорректен и рабоать вряд ли сможет.
V>Хм, чем это он некорректен? Полностью соответствует стандарту.

Массив не инициализирован и превышает размеры стэка.

VD>>Ну, и столь вольные допущения компиляторы пока что не делают.
V>Для самых любознательных привожу ассемблерный вид, к которому преобразовал эту программу VC7.1

V>

V>00401000  xor         eax,eax 
V>00401002  ret  
V>

Дык, ты результат верни и погляди что получится. А так он просто выбрасил с дури код и все.

V>Как думаешь, сколько времени это будет выполняться?

Думаю, что смысла в таком коде еще мешьше чем в заявлениях сделанных на его основе.

V>А вот еще пример из той же оперы:
V>

V>int CalcSuperNumber(int n)
V>{
V>    for( int i=0, k=0; i < 500000000; ++i ) // ПЯТЬСОТ миллионов!!!!!!!
V>    {
V>        k += n;
V>    }
V>    return k;
V>}
V>int main()
V>{
V>    printf( "%i", CalcSuperNumber(10) );
V>    return 0;
V>}
V>

V>Тут программа уже посложнее, имеется побочный эффект — вывод результата на консоль. Сколько же она будет работать? Минуту, две? .
V>А нисколько!
V>Потому как компилятор нынче пошел на редкость умен и сообразителен.

О! Умища палата. Вот только достаточно переменную в классик вынести или малейшие зачатки разума в алгоритм заложить и вся прыть компилятора куда-то улитучивается.

V>Какая досада, комнилятор сразу подставил готорый результат еще во время компиляции

Вот именно по этому синтетические тесты не имеют смысла. У тебя даже заведомо бессмысленный код скомпилируется. А на рельный код это ровным счетом никакого влияние не окажет.

Здравствуйте, naje, Вы писали:

N>вобще-то rtl это какраз и есть представление ssa
Да? А как же jump'ы?

N>я вот только не пойму, если верить той статье, то компилятор из нормальный цикл переводит в рекурсию, после чего обратно в цикл, может покажешь мне продолжение этой статьи, о том как компиляторы из рекурсий в ssa оптять делают циклы?
А зачем?

Здравствуйте, Nick_, Вы писали:

N_>Здравствуйте, naje, Вы писали:

N>>вобще-то rtl это какраз и есть представление ssa
N_>Да? А как же jump'ы?

ты можешь привести какое-нибудь другое представление без jump'ов?

N>>я вот только не пойму, если верить той статье, то компилятор из нормальный цикл переводит в рекурсию, после чего обратно в цикл, может покажешь мне продолжение этой статьи, о том как компиляторы из рекурсий в ssa оптять делают циклы?
N_>А зачем?

а зачем это ocalm например пытается делать?

Здравствуйте, naje, Вы писали:
N>>>вобще-то rtl это какраз и есть представление ssa
N_>>Да? А как же jump'ы?

N>ты можешь привести какое-нибудь другое представление без jump'ов?
Граф.

N>>>я вот только не пойму, если верить той статье, то компилятор из нормальный цикл переводит в рекурсию, после чего обратно в цикл, может покажешь мне продолжение этой статьи, о том как компиляторы из рекурсий в ssa оптять делают циклы?
N_>>А зачем?

N>а зачем это ocalm например пытается делать?
Не знаю. Это надо спросить кого-нибудь кто знает ocaml.
Возможно имеется в виду, что рекурсия в ocaml так же эффективна как цикл в Си. Просто многие считают, что рекурсия это плохо, основываясь на своем опыте программирования в Си, где действительно каждый вызов функции приводит к работе со стеком. Поэтому и говорят, что ocaml превращает рекурсию в цикл.

Здравствуйте, Nick_, Вы писали:

N_>Почитай на досуге грамматику С++ или С.

Ну, спасибо дорогой! А то то я думал что мне почитать на досуге. Блин, я фигею.

Я тут между делом как раз парсеры разрабатываю: http://gzip.rsdn.ru/?article/rsharp/rsharp.xml

Автор(ы): Чистяков Влад (VladD2)
Дата: 28.01.2004

И уверяю тебя что кое-что в этом понимаю. Ты перепутал понятия синтаксического разбора (собственно парсинга) и семантического анализа.

N_>Хочешь сказать, что это семантика?

Даже говорить ничего не хочу. Если тебя интересует этот вопрос, то учебников по построению компиляторов море.

Здравствуйте, Nick_, Вы писали:

N>>а зачем это ocalm например пытается делать?
N_>Не знаю. Это надо спросить кого-нибудь кто знает ocaml.
N_>Возможно имеется в виду, что рекурсия в ocaml так же эффективна как цикл в Си. Просто многие считают, что рекурсия это плохо, основываясь на своем опыте программирования в Си, где действительно каждый вызов функции приводит к работе со стеком. Поэтому и говорят, что ocaml превращает рекурсию в цикл.

Что? Где? А...

Tail recursion

Здравствуйте, VladD2, Вы писали:

VD>Здравствуйте, Nick_, Вы писали:

VD>Я тут между делом как раз парсеры разрабатываю: http://gzip.rsdn.ru/?article/rsharp/rsharp.xml

Автор(ы): Чистяков Влад (VladD2)
Дата: 28.01.2004

Хочешь письками помериться?

VD>И уверяю тебя что кое-что в этом понимаю. Ты перепутал понятия синтаксического разбора (собственно парсинга) и семантического анализа.
А я тебя уверяю, что я ничего не напутал.

N_>>Хочешь сказать, что это семантика?

VD>Даже говорить ничего не хочу. Если тебя интересует этот вопрос, то учебников по построению компиляторов море.
То-есть аргументированно возразить уже не можешь?