[00:09:29] <vlad2> В смысле? :)
[00:10:49] <valexey> в прямом. трейса нет.
[00:11:18] <valexey> есть функция. общая. у нее в аргументах - указатели на другие функции.
[00:11:27] <valexey> оно их дергает и проверяет некое постусловие. ассертом, ога
[00:11:50] <valexey> в случае ассерта - приложение просто выходит. (с распечаткой на какой строке этот ассерт произошел, ога)
[00:11:56] <valexey> эта функцию вызывается из 100500 мест.
[00:12:03] <valexey> вот и гадай из за чего лажа случилась.
[00:12:17] <valexey> ну, то есть даже в gdb фиг отловишь
[00:12:31] <valexey> /me заменил ассерт на разименовывание нулевого указателя, и стало хорошо.
[00:19:29] <vlad2> Дык, это, пусть падает нормально :)
[00:19:38] <vlad2> Со стэком как положено.
[00:19:49] <vlad2> или ты про стандартный сишный assert?
[00:19:54] <vlad2> Так им никтон е пользуется :)
[00:20:34] <vlad2> Кстати, компилтяор snt,t ругаются на разыменование нулевого указателя ;)
[00:20:39] <vlad2> теперь
[00:20:48] <vlad2> Типа умные стали.
[00:20:53] <vlad2> clang
[00:21:43] <vlad2> Он говорит: если хотите крэшнутся здесь, то вызовите вот такую функцию, а ваше разыменованием я все равно проигнорирую :)
[00:23:37] <vlad2> У нас, кстати, по этой причине переопределены всякие terminate, pure virtual function call и т.п. - чтоб оно нормально крэшалось, а не просто exit(-1) делало.
[00:23:49] <valexey> гы. ну, gcc тоже варнинг кажет. но таки падает прога как надо :-)
[00:24:18] <valexey> собственно в плюсах вроде в стандарте есть правильные функции для краша
[00:39:12] <valexey> ну вот и напоролся ровно на то о чем я говорил. На ту проблему которую Олег (да и ilovb) упорно отрицали.
[00:41:17] <valexey> в проге, для переносимости (ога, в языке то нет нужных типов!) был определен свой собственный тип Uns32
[00:41:35] <valexey> Ну, понятно что это был алиас на какой-нибудь long int
[00:41:43] <valexey> *unsigned long int
[00:42:14] <valexey> И вот случилось чудо! Собираю на 64битной машине, а там long это 64 бита а нифига не 32. И всё. Привет-приплыли. sizeof(Uns32) == 8
[00:55:10] <vlad2> Просто там не было BOOST_STATIC_ASSERT(sizeof Uns32 == 4);
[00:55:12] <vlad2> ;)
[00:57:48] <valexey> vlad2: эта прога - чисто Сишная.
[00:58:09] <valexey> Более того - оно походу на C89 была :-) Сделал фикс - теперь С99 :-D
[00:58:22] <valexey> (сделал typedef'ы через stdint.h)
[00:59:13] <valexey> Идеалогия Оберона сейчас болтается где-то между С89 и Java образца 1995 года :-)
[00:59:32] <vlad2> Клевета зашитана ;)
[05:21:15] <vlad3> КлевЕта ;)
[22:17:41] <ilov_boris> :D
[22:17:45] <ilov_boris> "На ту проблему которую Олег (да и ilovb) упорно отрицали"
[22:17:51] <ilov_boris> Это о чем?
[22:20:06] <ilov_boris> То, что в с есть такая проблема не отрицаю :)
[22:20:16] <ilov_boris> в Си
[22:31:03] <ilov_boris> http://s2.developerslife.ru/public/images/gifs/78245043-ae83-4ca3-b296-0b96b4bf8ed2.gif
[22:36:03] <valexey> в обероне :-)
[22:36:31] <valexey> впрочем, в Обероне-07 проблемы нет - там же нельзя типы свои создавать :-) поэтому там другие проблемы которые блокируют эту
[22:37:04] <ilov_boris> так в чем проблема то?
[22:37:08] <ilov_boris> я так и не понял
[22:37:51] <ilov_boris> то что int32 не гарантирует 32 бита?
[22:38:12] <ilov_boris> так в обероне нет такой проблемы
[22:38:24] <valexey> то что если в языке или стандартной либе нет int32, то любой костыль, как предлагает Олег, рано или поздно выстрелит
[22:38:41] <valexey> костыль это когда ты берешь и пишешь TYPE Int32 = INTEGER;
[22:38:42] <valexey> в спец. модуле.
[22:38:44] <ilov_boris> какой костыль?
[22:39:05] <ilov_boris> ну это только сам себе враг может такое написать
[22:39:25] <ilov_boris> тип i32 должен быть в SYSTEM определен
[22:39:25] <valexey> естественно для другой платформы считается что у нас будет другой модуль с определениями этих типов
[22:40:09] <valexey> нет. он должен быть определен в стандартном модуле, но не SYSTEM. В SYSTEM должны быть определены опасные инструменты. собственно это один из пунктов критики Оберона самими создателями оного оберона
[22:40:20] <valexey> что нельзя и системозависимое и опасное пихать в один и тот же модуль
[22:40:37] <ilov_boris> i32 и есть опасная штука
[22:40:39] <ilov_boris> разве нет?
[22:40:44] <valexey> нет
[22:40:54] <ilov_boris> почему?
[22:41:14] <valexey> INTEGER с неизвестной ёмкостью куда более опасная штука.
[22:41:21] <ilov_boris> :D
[22:41:24] <valexey> потому что его поведение не определено :-)
[22:41:46] <ilov_boris> Да ладно? O_o
[22:42:09] <valexey> угу. INTEGER a; a:=1+1; (* какое значение будет в a? *)
[22:42:17] <valexey> тьху. ну ты понял.
[22:42:18] <ilov_boris> значения от MIN(INTEGER) до MAX(INTEGER)
[22:42:39] <valexey> круто. а как на этапе компиляции это проверить? :-)
[22:42:55] <ilov_boris> что проверить?
[22:43:17] <valexey> проверить свойства оного INTEGER'a и понять будет работать наш алгоритм при таких его свойствах или же не будет.
[22:43:27] <valexey> рантайм проверки не предлагать. ибо убого и не надежно.
[22:43:47] <ilov_boris> конкретный пример можно?
[22:44:07] <ilov_boris> в каком месте нужна проверка
[22:44:35] <valexey> ну например при адаптивном алгоритме хаффмана.
[22:44:47] <ilov_boris> блин
[22:44:53] <ilov_boris> строчку кода можно?
[22:44:59] <ilov_boris> в которой нужна проверка
[22:45:02] <valexey> если у нас int 64битный, то переполнения не будет на разумных размерах файла
[22:45:13] <valexey> если он внезапно 8ми битный, то привет переполнения.
[22:45:58] <ilov_boris> проверку переполнения оберон делает
[22:45:59] <valexey> там строчка кода будет скучная. вида a := b+c;
[22:46:28] <ilov_boris> и ты хочешь чтобы компилятор проверил можно ли так?
[22:46:29] <valexey> во первых не делает. во-вторых проверка в рантайме ничего не даст. программа будет не валидная сразу после компиляции если int у нас 8 бит.
[22:46:41] <ilov_boris> с чего это не делает?
[22:47:20] <valexey> еще раз. я знаю свойства алгоритма. я знаю что мне нужно минимум 32 бита под целое. если мне компилятор такой тип обеспечить не может, у меня должна быть ошибка компиляции
[22:47:29] <valexey> при этом никакого SYSTEM'а естественно быть не должно.
[22:48:35] <valexey> эти типы являются предусловием для компиляции.
[22:48:38] <ilov_boris> ну определил ты
[22:48:41] <ilov_boris> int32
[22:48:45] <ilov_boris> что дальше?
[22:48:54] <ilov_boris> что должен компилер проверить?
[22:49:10] <ilov_boris> a := b + c
[22:49:21] <ilov_boris> как это должно проверяться?
[22:49:28] <valexey> что значит я определил? если int32 определил я, как TYPE int32 = FooBar; то всё, привет-прикплыли
[22:49:44] <ilov_boris> ну ты же хочешь как в аде
[22:50:07] <valexey> если же в стандартной либе, или в языке есть возмжность либо явно указать битность, либо задать диапазон, то всё будет хорошо.
[22:50:17] <ilov_boris> ну вот я про это
[22:50:21] <valexey> просто потому, что я, как разработчик алгоритма знаю какой диапазон значений мне нужен.
[22:50:28] <ilov_boris> отлично
[22:50:32] <ilov_boris> что дальше?
[22:50:38] <ilov_boris> [22:48:48] <ilov_boris> что должен компилер проверить?
[22:49:04] <ilov_boris> a := b + c
[22:50:41] <valexey> всё. дальше все работает.
[22:51:02] <ilov_boris> что мне компилер может проверить?
[22:51:05] <valexey> в случае a:= b+c оно должно проверить совместимость типов
[22:51:19] <valexey> еще раз, по АЛГОРИТМУ, сумма b+c не превышает число влазящее в int32
[22:51:20] <ilov_boris> совместимость чего с чем?
[22:51:40] <ilov_boris> как ькомпилер узнает что превышает?
[22:52:18] <ilov_boris> может у меня там b = 0 и c = 0 в этот момент
[22:52:50] <valexey> я, как разработчик алгоритма знаю что b+c должно помещаться в int32 и не помещется в int16. Мне компилятор должен гарантировать что a у меня будет минимум 32 бита. Или, если он это не может гарантировать, то пусть будет ошибка компиляции. Всё. Больше мне от него ничего не надо.
[22:52:54] <valexey> И рантайм проверок не надо.
[22:53:10] <ilov_boris> пипец
[22:53:20] <valexey> угу. алгоритмика она такая.
[22:53:30] <ilov_boris> как компилер узнает что b+c не помещается в 32 бита??????
[22:53:33] <valexey> ты учти, что это не единственная строчка, и b и c там не произвольные
[22:53:48] <valexey> b+c помещается в 32 бита. железно.
[22:53:55] <valexey> в 16 бит не помещается
[22:54:10] <valexey> поэтому я пишу что a должно иметь тип int32 или больше.
[22:54:14] <ilov_boris> ты пьян? :)
[22:54:21] <valexey> о чем сообщаю компилятору явным образом.
[22:54:26] <valexey> что не понятно то?
[22:54:28] <ilov_boris> можешь на конкретный вопрос ответить?
[22:54:40] <valexey> на какой?
[22:54:44] <ilov_boris> что должен сделать компилер на строчке a := b + c?
[22:55:02] <ilov_boris> как он проверит что она правильная/неправильная?
[22:55:18] <valexey> На конкретно этой строчке - ничего. Но в этой строчке возникнет проблема если он не гарантирует мне что a это int32
[22:57:27] <valexey> в смысле? дык я же знаю что сумма b+c никогда не превышает int32
[22:57:46] <ilov_boris> забавные вы сишники :D
[22:57:46] <valexey> ну, то есть в некоторых языках это можно доказать (та же Agda), но в те дебри мы не полезем :-)
[22:58:04] <valexey> нет. алгоритмисты :-)
[22:58:04] <ilov_boris> "я знаю" - это не гарантия
[22:58:16] <ilov_boris> за это си и ругают
[22:58:34] <ilov_boris> что программисты сишникики слишком высокого мнения о себе
[22:58:35] <valexey> а где гарантия что инвариант цикла составлен правильно и что оно не зациклится нафик при пузырьковой сортировке?
[22:58:54] <ilov_boris> нет нарантии
[22:59:02] <ilov_boris> гарантия - это ASSERT
[22:59:22] <ilov_boris> обсуждалось в коровне уже тысячу раз
[22:59:24] <valexey> и какой же ASSERT ты вставишь в сортировку пузырьком?
[22:59:38] <valexey> и где гарантии что ты правильный ASSERT вставишь?
[23:01:05] <ilov_boris> приведи код
[23:01:08] <valexey> ладно, пойду, посплю после пробежки :-)
[23:01:16] <ilov_boris> и покажи в каком случае может зациклиться
[23:01:28] <ilov_boris> и тогда я покажу тебе где нужен ассерт
[23:01:49] <ilov_boris> давай