14:06 <TimFreeman> Is there an expression in OCAML that's analogous to __FILE__ in C, which returns the current file name?

14:06 <TimFreeman> ...current *source* file name, that is.

20:54 <Yurik> re

21:00 <Yurik> belman: hi

21:03 <Yurik> malc: hi

21:03 <malc> Yurik: lo

21:21 <Yurik> re

21:52 <volatile> anyone awake?

21:53 <exarkun> awake, aye

21:54 <volatile> I'm thinking about converting my ftp server written in c into ocaml

21:55 <exarkun> Cool

21:55 <volatile> I'm just learning ocaml, and wanted to know if there is a way to specify variables of a certain size (8 bit, 16 etc)

21:55 <exarkun> integer vars?

21:56 <volatile> well the character var is by default 8 bits right?

21:56 <exarkun> yup

21:57 <volatile> is that a standard or just a coincedence?

21:57 <volatile> in ocaml i mean

21:57 <exarkun> I think it's always 1 byte, but I'm pretty new to ocaml myself :)

21:58 <exarkun> That's a good point. What in an ftp server needs integers of a particular size?

21:59 <volatile> data must be transfered in 1 byte sizes, but actually I don't think there is any need for 16 bit or 32 bit specifically sized integers

22:02 <mr_bubbs> the great thing is there are things in OCaml that hide that for you, and they are portable, to boot

22:02 <mr_bubbs> and they even do it efficiently!

22:04 <volatile> the chief reason I'm thinking about converting it to ocaml is the buffer protection (no buffer exploits are possible) and that the code runs fast. C# and Java were also choices but the mono port doesn't compile code directly to x86 and java is, well... java, not exactly the speed demon

22:06 <exarkun> libsafe protects you from buffer overruns

22:08 <mr_bubbs> volatile: so you have the whole thing written in C, eh?

22:08 <mr_bubbs> exarkun: how's the twisted progress

22:08 <mr_bubbs> volatile: I mean.. it's finished and such

22:09 <volatile> mr_bubbs: no, actually its only about 50% done

22:09 <mr_bubbs> well, guess it's not too bad

22:09 <exarkun> mr_bubbs: paused while I consider possible approaches to the Jelly module

22:09 <mr_bubbs> I'd say if you already have the thing in another language, it might be kinda costly to rewrite it, depending on its size

22:10 <mr_bubbs> exarkun: yeah.. I have an httpd written in Python.. I'm really trying to not just port it to another language... I'm rather rethinking the ideas based on strengths of OCaml that were nonexistent with Python

22:10 <volatile> its pretty small, not that many lines at all. However so far its pretty portable between windows and linux

22:11 <volatile> how come libsafe is so unused?

22:11 <mr_bubbs> good question

22:11 <mr_bubbs> I don't use it and I wonder why I'm not, myself

22:11 <volatile> I don't see wu-ftpd , apache, etc using it by debian or other distro mainterners. Or freebsd or openbsd

22:12 <exarkun> I guess people don't really care about security.

22:12 <exarkun> :)

22:12 <mr_bubbs> heck, I don't see it in ports unless I'm overlooking

22:12 <mr_bubbs> I think there are a few variants on a theme in regards to protecting overflows and such

22:13 <mr_bubbs> oh

22:13 <mr_bubbs> this doesn't help

22:13 <mr_bubbs> http://online.securityfocus.com/bid/4326

22:14 <exarkun> blink

22:14 <mr_bubbs> Wojciech Purczynski discovered that format string protection in libsafe can be

22:14 <mr_bubbs> easily bypassed by using flag characters that are implemented in glibc but are

22:14 <mr_bubbs> implemented in libsafe. It was also discovered that *printf function wrappers

22:14 <mr_bubbs> incorrectly parse argument indexing in format strings, making some incorrect

22:14 <mr_bubbs> assumptions on the number of arguments and conversion specifications.

22:14 <mr_bubbs> hehe

22:14 <exarkun> heh

22:15 <volatile> as far as ocaml goes, there is no way to have a buffer overrun correct?

22:15 <mr_bubbs> I know there's a way to turn off bounds-checking with the native compiler

22:17 <mr_bubbs> can't think of anything else, off-hand

22:17 <mr_bubbs> I haven't been using the language too long, though

22:19 <volatile> doesn't seem to be very popular unfortunately

22:19 <volatile> seems to be very clean

22:20 <exarkun> clean?

22:20 <exarkun> I think its syntax is its worst feature :)

22:22 <volatile> modify to make it look more C++ maybe? ;)

22:22 <exarkun> Have you guys looked at the new syntax specification at all? caml4 or something like that, forget what it was called exactly

22:23 <volatile> *hardly

22:27 <smkl> revised syntax

23:38 <mr_bubbs> hmm, cool

23:38 <mr_bubbs> volatile was from my state

23:39 <mr_bubbs> not everyday you know someone close to you who likes OCaml :)

23:39 <exarkun> heh

23:40 <mr_bubbs> for the first week or two using OCaml, I couldn't make a single thing work!

23:40 <mr_bubbs> now it seems so easy, heh

23:41 <mr_bubbs> I went nuts over the immutable part, heh

23:41 <exarkun> hooray for immutability

23:42 <mr_bubbs> :P

23:42 <mr_bubbs> fun stuff

23:44 <mr_bubbs> hah

23:55 <mr_bubbs> Fatal error: exception Invalid_argument("Thread.kill: not implemented")

23:55 <mr_bubbs> neat

23:58 <mr_bubbs> [budbud@bb 7:58PM](~/ml)$ ocamlc -o str_array_test str_array_test.ml

23:58 <mr_bubbs> [budbud@bb 7:58PM](~/ml)$ ./str_array_test

23:58 <mr_bubbs> Fatal error: exception Invalid_argument("Array.get")

23:58 <mr_bubbs> [budbud@bb 7:58PM](~/ml)$ ocamlopt -o str_array_test str_array_test.ml

23:58 <mr_bubbs> [budbud@bb 7:58PM](~/ml)$ ./str_array_test

23:58 <mr_bubbs> Fatal error: exception Invalid_argument("out-of-bound array or string access")

23:58 <mr_bubbs> why doth that happen?

23:59 <mr_bubbs> now I'll have to match for Invalid_argument _

23:59 <mr_bubbs> hehe