Debug - работает, Release - не работает - Nemerle

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

KK>Библиотека-парсер, написана на PEG, несколько достаточно больших грамматик. Debug версия занимает — 500 кб, Relese — 1700 кб. Debug — работает, Release — не работает. Куда копать, дело в Peg или это более общая проблема?

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

В чем заключается неработоспособность? Не компилируется грамматика? Или прасер парсит не верно?

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

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

KK>>Библиотека-парсер, написана на PEG, несколько достаточно больших грамматик. Debug версия занимает — 500 кб, Relese — 1700 кб. Debug — работает, Release — не работает. Куда копать, дело в Peg или это более общая проблема?

VD>В релизе делается ряд оптимизаций. В том числе генерируются ДКА для разбора токенов. В Peg поведение токенов в релизе и дебаге могло отличаться. Возможно в этом дело. А возможно просто баг.

VD>В чем заключается неработоспособность? Не компилируется грамматика? Или прасер парсит не верно?

Все компилируется, но не парсится.

VD>В Peg поведение токенов в релизе и дебаге могло отличаться. Возможно в этом дело. А возможно просто баг.
Такое различие само по себе разве не баг?

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

KK>Все компилируется, но не парсится.

Покажи грамматику и на чем она падает. Оптимально, если сможешь выделить минимальный пример.

VD>>В Peg поведение токенов в релизе и дебаге могло отличаться. Возможно в этом дело. А возможно просто баг.
KK>Такое различие само по себе разве не баг?

Ну, если и баг, то в дизайне. Просто в дебаге ДКА не использвется и вместо этого используются правила ПЕГ. А в дебаге, для ускорения, испоьзуются ДКА. А они не так гибки.

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

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

KK>>Все компилируется, но не парсится.

VD>Покажи грамматику и на чем она падает. Оптимально, если сможешь выделить минимальный пример.

Постараюсь выделить.

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

KK>Постараюсь выделить.

Это первое что нужно сделать для отладки. Возможно сразу поймешь в чем дело. Ну, или мы сможем взглянув на грамматику сказать, что не так.

Далее нужно попробовать вот эту строчку:

      _isDebug  = _typer.Manager.Options.IsConstantDefined("DEBUG");

махнуть на:

      _isDebug  = true;

Если это даст положительный эффект, то дело в оптимизации.

VD>Это первое что нужно сделать для отладки. Возможно сразу поймешь в чем дело. Ну, или мы сможем взглянув на грамматику сказать, что не так.

VD>Далее нужно попробовать вот эту строчку:
VD>

VD>      _isDebug  = _typer.Manager.Options.IsConstantDefined("DEBUG");
VD>

VD>махнуть на:
VD>

VD>      _isDebug  = true;
VD>

VD>Если это даст положительный эффект, то дело в оптимизации.

Где искать эту строчку?

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

KK>Где искать эту строчку?

В поиске по файлам, лучше всего.

nemerle\snippets\peg-parser\Nemerle.Peg.Macros\Compiler\GrammarCompiler\Constructor.n

Свел грамматику близко к минимальному примеру.

using Nemerle.Collections;
using Nemerle.Text;
using Nemerle.Utility;

using System;
using System.Collections.Generic;
using System.Console;
using Nemerle;
using Nemerle.Peg;

module Program
{
    [  PegGrammar
        (  Option=None,
            ROOT_r,
            grammar
            {
                anychar_p= ['\u0000'..'\uFFFF'];
                digit_p= [Nd];
                sp:void= ' '*;

                group_b_r:int=digit_p+;
                group_a_r:int=(digit_p+ (sp digit_p+ "X" digit_p+)?);
                
                ROOT_r:int=(!line_r (raw_line_r) sp)* line_r;
                      
                    line_r:int= group_a_r sp group_b_r sp (!"&" anychar_p)* "&" sp;
                   raw_line_r:int= (!'&' anychar_p)* '&';
            }
        )
    ]
    class Grammar
    {
        group_a_r(_ : NToken, _ : option[(NToken * NToken * NToken)]):int
        {
            1
        }
            
        group_b_r(_:NToken):int
        {
            1
                
        }
                  
        raw_line_r(_:NToken, _:NToken):int
        {
           1
        }

        ROOT_r(_:List[int], _:int):int
        {
            1
        }

        line_r(_:int, _:int, _:NToken, _:NToken):int
 
        {
            1
        }
    }

    Main():void
    {
        def parser=Grammar();
        
        match(parser.Parse("111 2222&"))
        {
        |Some()=> WriteLine("OK")     //Debug
        |None()=> WriteLine("Error")  //Release
        }
        
        _ = ReadLine();
    }
}

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

KK>Свел грамматику близко к минимальному примеру.

Строку для разбора приведи, на которой падет.

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

KK>Свел грамматику близко к минимальному примеру.

KK>

KK>module Program
KK>{
KK>    [  PegGrammar
KK>        (  Option=None,

KK>

Советую использовать в отладочных целях: Options = EmitDebugSources

VD>Строку для разбора приведи, на которой падет.

Все приведено. В самом низу, в функции main.

Так что с этой проблемой? Будете исправлять?

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

Проблема возникает из-за этого правила:

raw_line_r:int= (!'&' anychar_p)* '&';

Если вместо anychar_p вписать другое, что не присутствует в строке, то релиз проходит.

Нужно найти более простой пример и отлаживать оптимизацию Nemerle.Peg.

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

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

_NN>Проблема возникает из-за этого правила:
_NN>

_NN>raw_line_r:int= (!'&' anychar_p)* '&';
_NN>

_NN>Если вместо anychar_p вписать другое, что не присутствует в строке, то релиз проходит.

_NN>Нужно найти более простой пример и отлаживать оптимизацию Nemerle.Peg.

Не все так просто. Я не зря привел такой сложный пример.

Если заменить правило

group_a_r:int=(digit_p+ (sp digit_p+ "X" digit_p+)?);

на правило

group_a_r:int=(digit_p+);

то релиз так же проходит.

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

KK>то релиз так же проходит.
Видимо выбора не остается, нужно отлаживать Nemerle.Peg.

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

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

KK>

                ROOT_r:int=(!line_r (raw_line_r) sp)* line_r;
                      
                line_r:int= group_a_r sp group_b_r sp (!"&" anychar_p)* "&" sp;
                   raw_line_r:int= (!'&' anychar_p)* '&';

Кажись грамматика противоречивая. line_r от raw_line_r отличается только пробелом в конце. В root_r внутри скобок этот последний пробел не принимается: !line_r
но принимается raw_line_r и ожидается пробел: (raw_line_r) sp

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

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

KK>>

А>                ROOT_r:int=(!line_r (raw_line_r) sp)* line_r;
                      
А>                line_r:int= group_a_r sp group_b_r sp (!"&" anychar_p)* "&" sp;
А>                   raw_line_r:int= (!'&' anychar_p)* '&';
А>

А>Кажись грамматика противоречивая. line_r от raw_line_r отличается только пробелом в конце. В root_r внутри скобок этот последний пробел не принимается: !line_r
А>но принимается raw_line_r и ожидается пробел: (raw_line_r) sp

Не важно. Это осталось от исходной грамматики. Можно убрать пробел в конце правила line_r и все равно поведение сохранится.

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

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

KK>>то релиз так же проходит.
_NN>Видимо выбора не остается, нужно отлаживать Nemerle.Peg.

_NN>Компилятор для этого собирать не нужно, достаточно собрать peg в отдельном проекте и проверять.

Мне интересно, новый PEG aka N2 корректно себя ведет в этой ситуации или нет?

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

KK>Не важно. Это осталось от исходной грамматики. Можно убрать пробел в конце правила line_r и все равно поведение сохранится.

Сперва надо разобраться в правильности грамматики и только потом разбираться в различии дебага с релизом. Попробуй свою грамматику написать в визуальном редакторе грамматик и проверить правильность. Например на antlr.

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

KK>Мне интересно, новый PEG aka N2 корректно себя ведет в этой ситуации или нет?
Скорее да чем нет, но проверить нам не дано =)
Что-то мне подсказывает, что там и другой синтаксис и другие проблемы.

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

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

KK>>Не важно. Это осталось от исходной грамматики. Можно убрать пробел в конце правила line_r и все равно поведение сохранится.

А>Сперва надо разобраться в правильности грамматики и только потом разбираться в различии дебага с релизом. Попробуй свою грамматику написать в визуальном редакторе грамматик и проверить правильность. Например на antlr.

Что значит неправильная грамматика? Под Debug она ведет так как и ожидается? Под Release явно глючит.

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

KK>Что значит неправильная грамматика? Под Debug она ведет так как и ожидается? Под Release явно глючит.

Неправильная грамматика означает, что она не разбирает все возможные правильные последовательности символов.
То что твоя грамматика работает на каком-то ограниченном наборе в какой-то неизвестной реализации пег

, да еще только в дебаге, это означает что тебе сильно повезло.

Если убрать пробел в конце у line, тебе придется переделать root.
Если убрать пробел в конце у line, то line отличается от raw_line только тем, он принимает чуть ограниченный набор начальных символов. То есть line = digit_groups + raw_line. То есть тебе надо как-то "нормализовать" правила, дальше "упростить".

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

KK>Так что с этой проблемой? Будете исправлять?

Я в отпуске. Буду полу 22го.

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

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

KK>>Что значит неправильная грамматика? Под Debug она ведет так как и ожидается? Под Release явно глючит.

А>Неправильная грамматика означает, что она не разбирает все возможные правильные последовательности символов.
А>То что твоя грамматика работает на каком-то ограниченном наборе в какой-то неизвестной реализации пег

, да еще только в дебаге, это означает что тебе сильно повезло.
А>Если убрать пробел в конце у line, тебе придется переделать root.
А>Если убрать пробел в конце у line, то line отличается от raw_line только тем, он принимает чуть ограниченный набор начальных символов. То есть line = digit_groups + raw_line. То есть тебе надо как-то "нормализовать" правила, дальше "упростить".

Я не понимаю такой терминологии — неправильная грамматика.

Приведенная мною грамматика не претендует на какую-то универсальность. Это конкретный набор правил для конкретного генератора парсеров — PEG. Интерпретация правил генератором парсеров описаны здесь http://www.rsdn.ru/article/nemerle/PegGrammar.xml. Если вы сопоставите описание генератора парсеров по ссылке и приведенные мной правила разбора вы удостоверитесь в том, что сгенерированный парсер должен принимать строку из примера.

Пробел по недосмотру остался от исходной грамматики и не влияет на конечное положение дел. Язык описанный правилом raw_line_r включает в себя язык описанный правилом line_r, но не наоборот.

ROOT_r:int=(!line_r (raw_line_r) sp)* line_r;

Поэтому парсер ROOT_r будет принимать raw_line_r одну за другой через пробел, пока эта raw_line_r "не похожа" line_r. Далее он перейдет к попытке применить правило line_r.

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

KK>Я не понимаю такой терминологии — неправильная грамматика.

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

KK>Пробел по недосмотру остался от исходной грамматики и не влияет на конечное положение дел. Язык описанный правилом raw_line_r включает в себя язык описанный правилом line_r, но не наоборот.

То есть изначально грамматика "по недосмотру" неправильная. Есть смысл разбираться правильно ли он работает?

KK>

KK>ROOT_r:int=(!line_r (raw_line_r) sp)* line_r;
KK>

KK>Поэтому парсер ROOT_r будет принимать raw_line_r одну за другой через пробел, пока эта raw_line_r "не похожа" line_r. Далее он перейдет к попытке применить правило line_r.

Так если нет пробела в конце, то эту строку может принять только raw_line. Твоя грамматика не должна принимать строку "111 22222&", тк как нет пробела в конце строки. То что она работает в дебаге, говорит о том что или грамматика неправильная, или реализация пег неправильная, или кто-то говорит неправду.

А>То есть изначально грамматика "по недосмотру" неправильная. Есть смысл разбираться правильно ли он работает?
А>Так если нет пробела в конце, то эту строку может принять только raw_line. Твоя грамматика не должна принимать строку "111 22222&", тк как нет пробела в конце строки. То что она работает в дебаге, говорит о том что или грамматика неправильная, или реализация пег неправильная, или кто-то говорит неправду.

Правило должно быть такое:

line_r:int= group_a_r sp group_b_r sp (!"&" anychar_p)* "&";

При этом грамматика должна разбирать строку "111 2222&". Но под Release не разбирает.

Текст программы со скорректированным правилом должен быть такой

using Nemerle.Collections;
using Nemerle.Text;
using Nemerle.Utility;

using System;
using System.Collections.Generic;
using System.Console;
using Nemerle;
using Nemerle.Peg;

module Program
{
    [  PegGrammar
        (  Option=None,
            ROOT_r,
            grammar
            {
                anychar_p= ['\u0000'..'\uFFFF'];
                digit_p= [Nd];
                sp:void= ' '*;

                group_b_r:int=digit_p+;
                group_a_r:int=(digit_p+ (sp digit_p+ "X" digit_p+)?);
                
                ROOT_r:int=(!line_r (raw_line_r) sp)* line_r;
                      
                line_r:int= group_a_r sp group_b_r sp (!"&" anychar_p)* "&";
                raw_line_r:int= (!'&' anychar_p)* '&';
            }
        )
    ]
    class Grammar
    {
        group_a_r(_ : NToken, _ : option[(NToken * NToken * NToken)]):int
        {
            1
        }
            
        group_b_r(_:NToken):int
        {
            1
                
        }
                  
        raw_line_r(_:NToken, _:NToken):int
        {
           1
        }

        ROOT_r(_:List[int], _:int):int
        {
            1
        }

        line_r(_:int, _:int, _:NToken, _:NToken):int
 
        {
            1
        }
    }

    Main():void
    {
        def parser=Grammar();
        
        match(parser.Parse("111 2222&"))
        {
        |Some()=> WriteLine("OK")     //Debug
        |None()=> WriteLine("Error")  //Release
        }
        
        _ = ReadLine();
    }
}

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

Я что интерактивный редактор грамматики?

Я уже предложил хорошую тулзу. ДЖумаю процесс написания правильной грамматики значительно ускорится.

KK>

                group_b_r:int=digit_p+;
                group_a_r:int=(digit_p+ (sp digit_p+ "X" digit_p+)?);
                
                line_r:int= group_a_r sp group_b_r sp (!"&" anychar_p)* "&";

Мне вот этот кусок не нравится. Думаю, тут есть неоднозначность выбора group_a, group_b или anychar*.

KK>>

_>                group_b_r:int=digit_p+;
_>                group_a_r:int=(digit_p+ (sp digit_p+ "X" digit_p+)?);
                
_>                line_r:int= group_a_r sp group_b_r sp (!"&" anychar_p)* "&";
_>

_>Мне вот этот кусок не нравится. Думаю, тут есть неоднозначность выбора group_a, group_b или anychar*.

Тут нет никакого выбора, правила применяются последовательно. Почитайте http://www.rsdn.ru/article/nemerle/PegGrammar.xml, проанализируйте мою грамматику, и все сомнения уйдут.

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

KK>>>

_>>                group_b_r:int=digit_p+;
_>>                group_a_r:int=(digit_p+ (sp digit_p+ "X" digit_p+)?);
                
_>>                line_r:int= group_a_r sp group_b_r sp (!"&" anychar_p)* "&";
_>>

_>>Мне вот этот кусок не нравится. Думаю, тут есть неоднозначность выбора group_a, group_b или anychar*.

KK>Тут нет никакого выбора, правила применяются последовательно. Почитайте http://www.rsdn.ru/article/nemerle/PegGrammar.xml, проанализируйте мою грамматику, и все сомнения уйдут.

Всех тонкостей пег не помню. Выбор неоднозначных правил в пег может работать по разному в зависимости от реализации.
В данном случае если на входе будет "111 111 " (цифры пробел цифры пробел), то разбор может обломаться на "X" (droup_a). А может и откатится назад и перейти к group_b. Скорее всего в релизе из-за оптимизации не работает откат и разбор обламывается. И тот и другой случай корректны для пег, все зависит от конкретной реализации. И это один из минусов пег, он скрывает ошибки грамматики.

	От:	WolfHound
	Дата:	16.06.13 18:09
	Оценка:	9 (2) +1

	От:	Ka3a4oK
	Дата:	16.06.13 18:13
	Оценка:	147 (1)

	От:	Ka3a4oK
	Дата:	07.06.13 16:55
	Оценка:

От:	VladD2	www.nemerle.org
Дата:	07.06.13 17:09
Оценка:

	От:	Ka3a4oK
	Дата:	07.06.13 17:21
	Оценка:

От:	_NN_	www.nemerleweb.com
Дата:	09.06.13 07:21
Оценка:

	От:	Аноним
	Дата:	15.06.13 13:40
	Оценка:

	От:	Аноним
	Дата:	15.06.13 15:12
	Оценка:

	От:	Аноним
	Дата:	15.06.13 16:49
	Оценка: