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

O>Поздравляю!
Ну то есть ты признаешь что занимаешься monkey driven development'ом.
Сочувствую.

O>По сравнению с тем, что код написан на немерле — это мелочи.
И что же такого страшного в немерле?
Почему он хуже чем например Coco/R или ANTLR?

O>Когда это актуально можно и по пегу сишарп сгенерить.
Те рукопашный велосипед который нужно поддерживать и развивать лучше чем отлаженное и проверенное на очень сложных грамматиках (C#4) решение?
МДД во всей красе.
Да и скорость разбора ты такую не получишь. Ибо я очень много времени потратил на то чтобы ускорить парсер.
Например сколько времени у тебя уйдет на автоматическую генерацию минимальных конечных автоматов для "лексерных" правил? Не забывая про то что приходится иметь дело с юникодом.
А ты знаешь как сделать мемоизацию которая будет ускорять разбор, а не тормозить его?
А как ты собераешься выдавать пользователю сообщения об ошибках?
А как ты собераешься делать востановление после ошибок?

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

O>Обычно неактуально, вот пег и не используется.
Обычно регексы не нужны. Я ими по делу только логи grep'ал.
Но вот как только появляется что-то сложнее лога то регексов уже становится мало.

WH>По тому что текстовый препроцессор не может давать хорошие сообщения об ошибках.

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

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

DG>про грамматику может, а вот про ошибки в обработчиках да не может, т.к. они обычно пишутся на целевом языке, а не на языке парсера.
А у меня это один язык. Причем с поддержкой IDE что текстовым препроцессорам и не снилось ибо очень большой объем работы.

WH>А у меня это один язык.

очень спорное утверждение.

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

N>Адекватность интерпретации проверяется тестами. Покажи тест, который перловый движок выполняет иначе (то есть даёт другие результаты), чем положено по спецификации, и я соглашусь. Если нет — останусь при своём мнении.

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

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxlmnopqrstuvwyz
^.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*l+m+n+o+p+q+r+s+t+u+v+w+y+z+$

Элементарно, Ватсон.

N>Зачэм груби, дарагой? Всего лишь прямолинейная констатация факта: ты не знал, что могут быть другие результаты, но настоял, что все движки без ограничения должны страдать от этого. Я показал живой, тривиально проверяемый пример — ты не соглашаешься — мол, он что-то нарушает.

А мне больше делать нечего — изучать хаки каждого конкретного движка из десятков существующих. Мне достаточно знать, что такая проблема присуща всем регэксам как классу. Любой регэкс движок можно подвесить, остальное — мелкие детали.

N>Почему бы тебе не предположить, что это именно ты что-то не знаешь, а не те умные и опытные ребята, что пишут Perl?

А почему бы тебе не попробовать думать своей головой?

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

Чем?

N>Зачем мне PEG? Он не даёт ничего нового...

Это у тебя просто от невежества.

N>Хорошо, явно задамся задачей именно оправдать применение PEG. Получается одна относительно специфическая задача — грамматический разбор текста с построением дерева разбора. Так?

Не так. PEG можно применять везде, где применяются регэксы, yacc, bison или antlr.

N>Отлично. Осталось понять, на кой аккредитив вообще тебе потребовалось показывать заведомо искусственный пример

Ты начал про это говорить. Али склероз мучает?

N>`.*' это удачная находка? Дело ваше, конечно, но я неоднократно слышал/читал жалобы именно на эту конструкцию как на "базовый кошмар" регэкспов.

Не то чтобы особо удачная, но зато привычная

N>Почему бы не взять вместо этого один из стандартных/распространённых синтаксисов BNF?

Предлагай варианты.

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

WH>А ты знаешь как сделать мемоизацию которая будет ускорять разбор, а не тормозить его?

Интересно, из-за чего может получаться замедление? Может, просто реализация мемоизации не очень удачная?

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

N>Зачэм груби, дарагой? Всего лишь прямолинейная констатация факта: ты не знал, что могут быть другие результаты, но настоял, что все движки без ограничения должны страдать от этого. Я показал живой, тривиально проверяемый пример — ты не соглашаешься — мол, он что-то нарушает. Почему бы тебе не предположить, что это именно ты что-то не знаешь, а не те умные и опытные ребята, что пишут Perl?

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

Now, Perl's regexps "aren't" -- that is, they aren't "regular" because backreferences per sed and grep are also supported, which renders the language no longer strictly regular and so forbids "pure" DFA implementations.

http://www.perl.com/doc/FMTEYEWTK/regexps.html

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

K>>А, понял.
K>>Как оно обычно реализуется? Просто тупо матрица M*N?
H>Пакрат обычно не реализуется вообще — он дико медленный

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

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

ВВ>Почему? Идея пакрата, как я понимаю, это "мемоизируем все". Т.е. по идее это не должно бы приводить к "дико медленный". К тому же автор декларировал линейное время парсинга, откуда бы взяться тормозам?

От линейного времени O(N) с большим коэффициентом N. Если мемоизировать все правила, то да, время будет линейным, но уж очень большим.

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

O>>Собери, выложи пример использования из C#
WH>Пишем парсер на немерле.
WH>Подключаем к проекту на C#.
WH>Используем.
WH>Ты что никогда не видел как используют класс описанный в другой ДЛЛ?

Ну а как все же это выглядит? Грамматика передается в виде строки? И как работает сам ПЕГ? Генерирует что-то в райнтайме?

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

L>Есть, например, PEG, который превосходит регэксы во всем.
L>Как минимум одно радикальное преимущество — это возможность делать декомпозицию. Что избавляет от необходимости писать такие вот жутики: http://stackoverflow.com/questions/2245282/what-is-the-longest-regular-expression-you-have-seen
L>Синтаксис приятнее, легче читается.
L>И тем не менее, основная масса по прежнему использует регэксы. Почему??

Потому что их хватает, чтобы решать мои задачи.

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

ВВ>>Почему? Идея пакрата, как я понимаю, это "мемоизируем все". Т.е. по идее это не должно бы приводить к "дико медленный". К тому же автор декларировал линейное время парсинга, откуда бы взяться тормозам?

H>От линейного времени O(N) с большим коэффициентом N. Если мемоизировать все правила, то да, время будет линейным, но уж очень большим.

А если мемоизировать не все, то будет быстрее линейнего что ли?

Мне интересно:
— Пакрат реально дает O(n) или это только в теории, а на практике это не O(n)? Если да, то почему так происходит.
— Если излишняя мемоизация вредна, но по каким критерием определяется, что мемоизировать, а что нет?

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

L>Есть, например, PEG, который превосходит регэксы во всем.
L>Как минимум одно радикальное преимущество — это возможность делать декомпозицию. Что избавляет от необходимости писать такие вот жутики: http://stackoverflow.com/questions/2245282/what-is-the-longest-regular-expression-you-have-seen
L>Синтаксис приятнее, легче читается.
L>И тем не менее, основная масса по прежнему использует регэксы. Почему??

А есть готовые библиотеки для C/C++?

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

WH>>А ты знаешь как сделать мемоизацию которая будет ускорять разбор, а не тормозить его?
L>Интересно, из-за чего может получаться замедление? Может, просто реализация мемоизации не очень удачная?
Если парсер тормоз то мемоизацию сделать легко.
Но если весь код парсера вылизан то сделать мемоизацию которая работает быстрее чем разбор уже намного сложнее.

Вот собственно единственный не тормозящий варинт мемоизации который я придумал:
Правило:

namespaceMemberDeclarations : NamespaceNodeList = namespaceMemberDeclaration*;

Во что оно превращается:

//Это поля объекта грамматики
//Эти для мемоизации
private mutable mutable __GENERATED_PEG__Memeoize_Pos__namespaceMemberDeclarations__ : int

private mutable mutable __GENERATED_PEG__Memeoize_End__namespaceMemberDeclarations__ : int

private mutable mutable __GENERATED_PEG__Memeoize_Res__namespaceMemberDeclarations__ : list[CSharpParser.NamespaceNode]
//Это для сообщений об ошибках.
private mutable mutable __GENERATED_PEG__MaxRollback___namespaceMemberDeclarations__ : int
//Это собственно метод который разбирает описанное выше правило
private __GENERATED_PEG__RULE__namespaceMemberDeclarations__(pos : int, text : string, result : ref list[CSharpParser.NamespaceNode]) : int
{
  unchecked 
  {
    mutable (c : char);
    _  = c;
    
    {
      mutable token_1;
      if (__GENERATED_PEG__Memeoize_Pos__namespaceMemberDeclarations__ == pos) 
      {
        when (__GENERATED_PEG__Memeoize_End__namespaceMemberDeclarations__ >= 0) result = __GENERATED_PEG__Memeoize_Res__namespaceMemberDeclarations__;
        __GENERATED_PEG__Memeoize_End__namespaceMemberDeclarations__
      }; else 
      {
        def newPos = 
        {
          token_1 = SCG.List();
          mutable token_2;
          def rep (pos : int)  
          {
            def newPos = __GENERATED_PEG__RULE__namespaceMemberDeclaration__(pos, text, ref token_2);
            if (newPos >= 0) 
            {
              token_1.Add(token_2);
              rep(newPos)
            }; else pos
          } : _ ;
          rep(pos)
        };
        __GENERATED_PEG__Memeoize_Pos__namespaceMemberDeclarations__ = pos;
        __GENERATED_PEG__Memeoize_End__namespaceMemberDeclarations__ = newPos;
        if (newPos >= 0) 
        {
          result = namespaceMemberDeclarations(token_1);
          ();
          __GENERATED_PEG__Memeoize_Res__namespaceMemberDeclarations__ = result
        }; else when (__GENERATED_PEG__MaxRollback___namespaceMemberDeclarations__ < pos) __GENERATED_PEG__MaxRollback___namespaceMemberDeclarations__ = pos;
        newPos
      }
    }
  }
}

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

ВВ>Ну а как все же это выглядит? Грамматика передается в виде строки? И как работает сам ПЕГ? Генерирует что-то в райнтайме?
Ну если ты любишь извращения то можно и так.
Генерируешь исходный код. Поднимаешь компилятор немерла и готово.
Вот только нормальный человек создат проект на немерле и получит интелесенс и море других плюшек.

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

S>А есть готовые библиотеки для C/C++?
http://www.boost.org/doc/libs/1_45_0/libs/spirit/doc/html/index.html

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

WH>Вот собственно единственный не тормозящий варинт мемоизации который я придумал:

Боюсь, что я этот ваш Немерле недостаточно понимаю
Можно объяснить идею словами?

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

L>Боюсь, что я этот ваш Немерле недостаточно понимаю
А что там понимать? Он не так уж и сильно от C# отличается.

L>Можно объяснить идею словами?
Создаем в объекте парсера поля для запоминания только последнего применения правила.
И если это провило будет опять применено в тойже позиции то используем запомненный результат.
Это помогает вот в таких случаях

      constantDeclaration : TypeMember = attributes? modifiers? "const"S anyType constantDeclarators semicolon;

      fieldDeclaration    : TypeMember = attributes? modifiers? anyType variableDeclarators semicolon;

      methodDeclaration : TypeMember = attributes? modifiers? anyType typeMemberIdentifier typeParameterList? "("s formalParameterList? ")"s typeParameterConstraintsClauses? methodBody;

      propertyDeclaration     : TypeMember        = attributes? modifiers? anyType typeMemberIdentifier "{"s accessorDeclarations "}"s;

      eventDeclaration_1  : TypeMember = attributes? modifiers? "event"S anyType typeMemberIdentifier "{"s eventAccessorDeclarations "}"s;
      eventDeclaration_2  : TypeMember = attributes? modifiers? "event"S anyType variableDeclarators semicolon;
      eventDeclaration    : TypeMember = eventDeclaration_1 / eventDeclaration_2;

      indexerDeclaration  : TypeMember = attributes? modifiers? anyType (typeMemberIdentifier "."s)? "this"S "["s formalParameterList? "]"s "{"s accessorDeclarations "}"s;

      operatorDeclaration : TypeMember = attributes? modifiers? operatorDeclarator "("s formalParameterList? ")"s methodBody;

      constructorDeclaration : TypeMember = attributes? modifiers? identifier "("s formalParameterList? ")"s constructorInitializer? methodBody;

      destructorDeclaration  : TypeMember = attributes? modifiers? "~"s identifier "("s formalParameterList? ")"s methodBody;

      nestedTypeDeclaration  : TypeMember = typeDeclaration;

      typeMemberDeclaration  : TypeMember = methodDeclaration
                                          / propertyDeclaration 
                                          / fieldDeclaration
                                          / constantDeclaration
                                          / constructorDeclaration
                                          / eventDeclaration
                                          / operatorDeclaration
                                          / indexerDeclaration
                                          / destructorDeclaration
                                          / nestedTypeDeclaration
                                          / fixedSizeBufferDeclaration;

Обрати внимание все правила ничинаются с "attributes? modifiers?" соответственно эта пара правил будет разобрана один раз.

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

WH>Ну то есть ты признаешь что занимаешься monkey driven development'ом.
WH>Сочувствую.
Спасибо. Ты нереально крут, я тебе завидую.

WH>И что же такого страшного в немерле?
То, что для его использования в нормальном девелопмонте нужно прилагать нереальные усилия.

WH>Те рукопашный велосипед который нужно поддерживать и развивать лучше чем отлаженное и проверенное на очень сложных грамматиках (C#4) решение?
Этот "велосипед" встроен в дотнет фреймворк и работает более чем нормально для 99% применений. Велосипед — это немерле.

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

WH>Вот только нормальный человек создат проект на немерле и получит интелесенс и море других плюшек.
Таких "нормальных" людей можно пересчитать по пальцам