←2005-11-24 2005-11-25 2005-11-26→ ↑2005 ↑all
02:25:30 -!- calamari has joined.
02:25:34 <calamari> hi
02:32:09 -!- kipple has quit (Read error: 104 (Connection reset by peer)).
02:34:32 -!- kipple has joined.
03:04:59 -!- kipple has changed nick to rune.
03:05:16 -!- rune has changed nick to kipple.
04:56:39 -!- GregorR-L has joined.
05:00:18 <calamari> hi Gregor
05:00:25 <GregorR-L> 'ello
05:01:26 <calamari> did you celebrate the holiday by eating until you nearly popped?
05:01:31 <GregorR-L> Yup 8-D
05:01:39 <calamari> me too :D
05:01:49 <GregorR-L> Hoopla!
05:02:25 <calamari> need to finish the bf interpreter for Linguine then I'll put it up
05:02:49 <calamari> (for the TC proof)
05:12:09 -!- kipple has quit (Read error: 110 (Connection timed out)).
05:56:55 <calamari> almost 80 in here.. my brain is threatening to shut down :(
06:09:49 <GregorR-L> 80 ... C? ;)
06:19:07 <calamari> lol
06:31:12 <GregorR-L> MUST ... NOT ... GIVE IN TO TRIPTOFAN (sp)!!!!
06:44:52 <calamari> ;) http://www.snopes.com/food/ingredient/turkey.asp
06:49:03 <calamari> good thing I'm writing the bf interp.. just found a language annoyance I need to fix :)
06:49:09 <GregorR-L> lol
06:51:33 <calamari> I needed to do a double deref but I was only allowing one *
06:51:47 <calamari> so now it should allow unlimited derefs
07:18:22 <calamari> yay.. done
07:18:47 <calamari> bf is a good test.. always seems to find problems :)
07:32:48 <calamari> http://kidsquid.com/compilers/linguine
07:39:43 <calamari> okay I'm tired.. I'll write the wiki page later
07:39:54 -!- calamari has quit ("bbl").
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:26:21 -!- GregorR-L has quit ("Chatzilla [Firefox 1.0.6/20050716]").
11:24:50 -!- jix has joined.
14:02:18 -!- kipple has joined.
17:12:46 -!- Keymaker has joined.
17:12:52 <Keymaker> hello
17:13:11 <jix> moin Keymaker
17:13:25 <Keymaker> hi jix
17:50:06 <kipple> hi guys
18:00:31 -!- wooby has joined.
18:14:44 <Keymaker> hi
18:15:32 <lament> hi
18:22:11 -!- wooby has quit (Read error: 104 (Connection reset by peer)).
18:46:39 -!- CXI has joined.
18:47:57 <Keymaker> hmmm
18:48:34 <Keymaker> if i remember correct (which i may not), was someone here making c compiler or interpreter in c sometime?
18:48:41 <Keymaker> over year ago
18:49:19 <kipple> why would you want to make a c compiler? there are tons of those... unless it's for some very obscure hardware
18:50:59 <jix> i'm working on a parser for german text adventures
18:51:42 <jix> and anyone that is going to use my parser engine for source-code is stupid..
18:55:09 <Keymaker> kipple: no idea, i wouldn't waste my time on that :)
19:06:05 <jix> HAH! no one cares about my projects...
19:07:57 <Keymaker> :)
19:10:46 <jix> you can use my parser for non german too
19:11:02 <jix> but it's complexity is O(n^3) so it's stupid to parse long things using it
19:11:18 <Keymaker> sorry, i don't need it for anything
19:11:30 <Keymaker> i mean i don't need a parser
19:11:34 <jix> you don't want to parse finnish?
19:11:43 <Keymaker> mmh. no :p
19:11:48 <lindi-> finnish?
19:12:00 <Keymaker> it's too esoteric to parse
19:12:28 <jix> is that a problem?
19:12:34 <lindi-> www.hunspell-fi.org/ is on a crusade to parse finnish :)
19:12:34 <Keymaker> for me, yes
19:13:52 <jix> WOW! finnish is really too esoteric (taivutuspäätteitä ???!?!?!(looks very esoteric))
19:14:39 <Keymaker> hehe
19:14:42 <lindi-> "pte" is suffix
19:16:06 <jix> a funny german sentence (for english speaking people): die, die die, die die Diebe gefangen haben, beleidigt haben, sitzen jetzt im Gefägnis
19:16:39 <Keymaker> well, what's the funny part? :D
19:16:46 <jix> die, die die die die die....
19:16:50 <Keymaker> hm
19:16:52 <Keymaker> :\
19:17:01 <Keymaker> i guessed
19:43:40 -!- kipple has quit (Read error: 104 (Connection reset by peer)).
19:44:40 -!- kipple has joined.
19:50:43 <Keymaker> if you see calamari around tell him to check his e-mail :) (in case i don't see him today)
19:52:42 <Keymaker> i sent him a linguine quine, but since i don't have interpreter here i'm not 100% sure it works
19:56:51 -!- calamari has joined.
19:56:57 <calamari> hi
19:57:34 <calamari> Keymaker: just ran your quine.. it worked perfectly! Awesome job, especially considering that you didn't test it
20:00:05 <Keymaker> hey, awesome :D
20:00:15 <Keymaker> feel free to post it on your site, if you want to.. ;)
20:00:25 <calamari> okay
20:00:46 <calamari> is it still a quine if it has a comment giving you credit?
20:01:25 <Keymaker> not really, but you can add "(remove this line before executing)" or something
20:01:57 <Keymaker> or credit outside the file, for example "click <here> to see a quine by keymaker" :)
20:02:23 <calamari> yeah I'll do that..
20:02:30 <Keymaker> ok
20:02:41 <Keymaker> i'm very happy it works as supposed to
20:03:21 <calamari> I still haven't figured out the secret of quines yet.. although it's been explained to me a few times :)
20:03:28 <Keymaker> :)
20:03:51 <Keymaker> i'm happy i realized the secret before reading it up :)
20:04:04 <Keymaker> my first quine ever was in brainfuck, and weighted 7000+ instructions
20:04:21 <Keymaker> but almost all of that was data part
20:06:20 <calamari> http://kidsquid.com/compilers/linguine/
20:07:54 <Keymaker> :)
20:11:08 <jix> c=>linguine is maybe possible...
20:11:49 <Keymaker> that'd be interesting
20:11:51 <jix> there was a way to dump the gcc gimple tree (for making a c => linguine compiler)
20:21:07 -!- ihope has joined.
20:21:27 <jix> i think it would be possible but i'm not going to do that
20:21:43 <jix> maybe a self-made lang => linguine but not ansi-c
20:21:58 <Keymaker> yeah
20:21:59 <ihope> I'm slowly converting Haskell's getLine function into Lazy K.
20:30:32 <jix> linguine basic!
20:31:59 <Keymaker> well, it's basic :)
20:32:34 <jix> bbl
20:34:44 <calamari> haha
20:35:26 <calamari> someday I'd like to learn how to write backends for gcc (with the goal of a BF backend).. perhaps Linguine would be an easier start
20:37:31 <calamari> well I've started the wiki article, but I need to do other work now, so it's missing the program description and commands. Maybe I can just copy and paste out of the spec, since I wrote it :)
20:38:14 <Keymaker> hehe
20:38:44 <Keymaker> calamari: there's no way to print value directly, without first saving it to memory?
20:38:55 <calamari> that's right
20:38:58 <Keymaker> ok
20:39:08 <calamari> because x is always referring to a memory location
20:39:12 <Keymaker> yeah
20:39:13 <Keymaker> then, what two stars ** does?
20:39:21 <calamari> I've only used ** one time
20:39:28 <Keymaker> yeah, but what it does?
20:39:45 <calamari> I had a value in the cell -1 which was the IP for BF
20:39:57 <calamari> so I wanted the command at the IP.. that is *-1
20:40:15 <calamari> but I wanted to store the command in another cell.. so I did -3=**-1
20:40:23 <Keymaker> ah
20:40:36 <calamari> If I just did -3=*-1 it would be storing the ip again
20:40:53 <Keymaker> ok
20:41:06 <calamari> wasn't technically necessary to allow multiple *'s, but it was easy so I did it
20:41:14 <Keymaker> ok
20:41:25 <Keymaker> the brainfuck interpreter written it is quite compact
20:41:37 <calamari> yeah I was happy about that
20:42:23 <calamari> I'm not sure how esoteric the language really is.. but I think it's closer to how I would have wanted Spaghetti to be
20:43:34 <Keymaker> yeah
20:43:44 <calamari> except the multiple commands per line
20:43:59 <Keymaker> isn't that a good feature?!
20:44:24 <calamari> I did that because of the meaning of the word linguine.. and I like the feature a lot.. but I think it makes it a tad less esoteric
20:45:20 <Keymaker> yes, in a way..
20:45:26 <Keymaker> but it's esoteric language enough :)
20:45:46 <calamari> glad to hear that.. thank you :)
20:49:50 <calamari> ok.. afk then :)
20:52:28 <Keymaker> *checks wikipedia* ok
20:55:41 -!- Sgep has joined.
21:27:44 <Keymaker> hah, some of these bash quotes are actually funny :)
21:35:17 <Sgep> keyhmm?
21:35:47 <Keymaker> hm?
21:35:55 <Sgep> <Keymaker> hah, some of these bash quotes are actually funny :)
21:36:22 <Keymaker> yes..? :) i don't understand..
21:36:29 <Sgep> Which bash quotes
21:36:45 <Keymaker> hmm, let's see..
21:36:59 <Keymaker> for example this one http://bash.org/?3169
21:37:22 <ihope> Heh.
21:37:32 <Keymaker> :) but, there's naturally a lot crap
21:37:48 <Keymaker> people seem to say allkinds of stupid on some channels..
21:45:25 <Keymaker> :D http://bash.org/?112863
21:46:12 <ihope> Hah.
21:48:34 <jix> ok i'm going to do a mini c-alike => linguine compiler
21:51:01 <Keymaker> nice
21:51:07 <Keymaker> in c?
21:51:12 <jix> no in ruby
21:51:16 <Keymaker> ok
21:51:30 <jix> parsing in c is somewhat ARGHGHGHG!HGHDGHDGHAGDHAUDFIi,sogvfjz.k.........
21:51:39 <Keymaker> :)
21:51:44 <jix> in ruby i have regexp and a parser generator (not the one i wrote)
21:52:12 <Keymaker> i could only parse one-byte sequences, perhaps :)
21:53:29 <Keymaker> http://bash.org/?75229
21:56:50 <Keymaker> rhh.. too much information
21:56:59 <Keymaker> erh, data i mean
22:08:32 * jix is reading c standard ...
22:09:22 * ihope would never understand such a document
22:09:34 <jix> some parts are really simple
22:09:43 <jix> i'm just searching the c operator precedence
22:11:31 <jix> nah.. stupid c standard (me is searching the ruby sources for the ruby operator precedence)
22:11:37 <jix> implementation > spec
22:11:43 <ihope> :-)
22:12:03 <ihope> Maybe you should have grabbed a language like Lazy K instead...
22:12:22 <Sgep> Lazy K?
22:12:40 <jix> lazy k isn't well suited for compiling to linguine
22:12:54 <jix> found the ruby operator precedence table
22:12:56 <ihope> Oh right.
22:13:00 <ihope> Malbolge, maybe?
22:13:02 <jix> ruby > c MUAHAHAHAHA
22:13:40 <ihope> How about Brooks?
22:14:43 <Sgep> linguine?
22:14:55 <Keymaker> calamari's new language
22:17:07 <ihope> ls -R > /dev/null
22:17:38 <jix> pretty well suited for c compiling
22:18:32 <fizzie> There are dozens of C operator precedence tables in the 'web.
22:18:59 <jix> yes but i have the ruby one on my hard disk
22:19:02 <jix> and i'm used to the ruby one
22:19:22 <jix> and i'm not making a c compiler but a LinC compiler...
22:19:40 <jix> you won't be able to compile ansi-c code
22:19:49 <jix> but if you know how to code c you will be able to code linc
22:19:53 <Sgep> linc?
22:20:03 <jix> Lin(guine)C
22:20:10 <fizzie> The precedence for bitwise &|^ in C doesn't make any sense, anyway.
22:20:21 <fizzie> And &|^ is probably a valid operator in perl 6.
22:20:37 <Keymaker> what it does?
22:20:43 <jix> fizzie: tell me a good operator precedence table
22:21:31 <fizzie> "Good" as in "sensible", or as in "valid <whatever-language>"?
22:22:01 <jix> the first one
22:22:07 <ihope> Prefix notation needs no operator precedence.
22:22:28 <fizzie> You can just do the precedence tables the way you'd expect them to be.
22:22:39 <fizzie> And people'll use parenthesises if they're unsure.
22:22:50 <fizzie> '@array ^_= "foo"' in perl 6 will concatenate "foo" to all elements of array.
22:23:00 <jix> fizzie: i don't expect anything besides + - * / to have some precedence...
22:23:18 <jix> i expect and and or to have some pretty high precedence but that's all...
22:23:32 <ihope> Hmm... catfoo x = [a ++ "foo" | a <- x]
22:23:42 <jix> haskell?
22:24:05 <fizzie> _= is also a perl 6 operator, although I don't know what it does, and it might not render correctly, since those two characters are not ascii.
22:24:15 <fizzie> I think <<_=>> is an accepted way to write that one.
22:24:25 <jix> lazy evaluation is funny.. i wrote a haskell code to generate a list with ALL primes in it...
22:25:08 <ihope> ...And something happened?
22:25:52 <jix> i told haskell to print the list AFTER generating them... you can't do that without lazy evaluation
22:26:15 <Sgep> lazy evaluation?
22:26:52 <ihope> Evaluate just what you need to produce a result.
22:27:45 <ihope> Suppose you have the psuedocode "Return 3, not the highest prime". Eager evaluation would calculate the highest prime and return 3; lazy would just return 3.
22:28:50 <Sgep> not the highest prime?
22:29:29 <ihope> Well, the psuedocode says not to return the highest prime :-)
22:29:54 <fizzie> Here's one version of precedences: assignment - (ternary ?: if you want it) - logical || - logical && - equality tests (==, !=) - relational tests (<, >, <=, >=) - bitwise or/xor - bitwise and - bitshifts - add/sub - mul/div/mod - "the rest" (dereference, address-of, pre/postdecrement/increments) - member-selection (".", "->")
22:30:09 <jix> thanks
22:32:09 <fizzie> That one is still a bit iffy about the bitwise operations. "a + b << 4" is parsed as "(a + b) << 4", but at least "a == b & 5" is parsed as "a == (b & 5)", unlike C. (In C it would mean "(a == b) & 5".)
22:33:05 <jix> i'm going to make my own....
22:33:19 <jix> i have to do more essential thinks first anyway....
22:34:04 <jix> LinC has no function prototypes!
22:34:45 <jix> (because there is no need for them in the parsing or compiling task of lincc)
22:37:21 <lament> lazy evalution is cool.
22:37:26 <ihope> Aye.
22:37:44 <lament> now to make a lazily-evaluated brainfuck...
22:38:19 <ihope> Eek.
22:38:27 <jix> i once thought about that
22:44:54 <calamari> jix: you might not be able to do function pointers easily, as pointers only refer to data not to code
22:48:50 * Sgep considerates writing an esolang that uses metakit somehow
22:56:04 <ihope> Hey, I didn't write the spec for FCELL yet, did I?
22:56:12 <Keymaker> nope
22:57:06 <Sgep> FCELL?
22:57:12 <ihope> FCELL, the First-Class Execution Language (lol), where the basic data type is the syntax element.
22:58:19 <lament> sounds like lisp
22:59:03 <ihope> Not very much like it.
23:00:16 <ihope> Programs look like [([)[xxx][xxx]]] over here.
23:00:28 <lament> looks like lisp :)
23:00:37 <ihope> Does it?
23:01:09 <lament> yes...
23:01:25 <ihope> Well, that program outputs "xxx[[". Very obvious, aye?
23:01:40 <lament> no, but neither is lisp :)
23:01:46 <ihope> Heh...
23:03:15 <ihope> The "Hello, world!" program is "[H[Heelloo,, wwoorrlldd!Hello, world!]]".
23:04:18 <ihope> Hmm, no it's not, is it?
23:05:28 <ihope> I guess it's [H[Heelloo,, wwoorrlld@Hello,world!]].
23:06:00 <ihope> Oh right. The "Hello, world!" program is "Hello, world!"
23:06:19 <lament> that's false!
23:06:23 <lament> F!"Hello, world!"
23:06:23 <falsebot> Hello, world!
23:06:45 <ihope> Without the quotes.
23:07:20 <lament> ah.
23:09:02 <ihope> A syntax error in FCELL outputs the junk that didn't parse. Since no character in "Hello, world!" is valid, this will output itself.
23:09:31 <Keymaker> mmh.. quine..
23:09:48 <ihope> "This is a quine." is a quine :-)
23:10:20 <ihope> If you want to output something with a right bracket in it, you have to put ] before the output.
23:10:47 <ihope> Outputting a backslash requires ]], and a closing bracket requires ]]].
23:10:59 * Sgep faints
23:11:07 * Sgep is hyper
23:11:13 <Sgep> and just talking to heam himself talk
23:11:18 <ihope> Faintly hyper?
23:11:54 <ihope> ]]]This [program] will out\put its own source code, except for the first three closing brackets.
23:13:22 <jix> struct test { int a = 1; int b; }; struct test2 { int c = 2; int d; } => [[:struct, "test", [["int", "a", 1], ["int", "b", nil]]], [:struct, "test2", [["int", "c", 2], ["int", "d", nil]]]]
23:13:40 * Sgep believes that he is writing an esolang where each execution step[?] will result in another program in that same language that will pick up where the other left off
23:13:56 <ihope> Who--you or me? :-)
23:14:00 <Sgep> me
23:14:10 <ihope> Well, that's exactly what FCELL does...
23:15:00 * Sgep 's esolang is going to use metakit
23:15:11 <lament> Sgep: pretty much any language can be looked at in that way...
23:15:16 <Sgep> oh
23:15:19 <lament> well
23:15:39 <lament> somewhot :)
23:15:41 <lament> somewhat
23:15:52 <ihope> Now, jix's program remaps "[" to "[:" and pops "[s" onto the stack, then pops it back off the stack, then pops off all the three predefineds.
23:16:37 <jix> that's a tree build from ruby arrays.... not a program...
23:16:52 <ihope> It's a valid FCELL program, though.
23:17:05 <Sgep> So far, my language is making it much easier to get input at a time defined at compile-time..
23:17:05 <jix> isn't everything a valid FCELL program?
23:17:32 <ihope> Yes.
23:17:47 <ihope> So it outputs "struct test { int a = 1; int b; }; struct test2 ( int c = 2; int d; } => struct, "test", [["int", "a", 1 ["int", "
23:17:57 <ihope> (oops)
23:19:05 <ihope> I'm not sure what it outputs.
23:19:34 <Sgep> Also, my language is not going to be easy to provide examples for
23:25:49 <ihope> Why not?
23:26:01 <Sgep> Binary
23:26:19 <Sgep> Using http://www.equi4.com/metakit.html
23:26:27 <Sgep> So any examples wouldn't be plaintext
23:26:55 <ihope> Ooh boy.
23:30:19 <Sgep> move[time:I,branch:S,itable:S,itime:I,ibranch:S,irest:S,otable:S,otime:I,obranch:S,orest:S]
23:30:38 <Sgep> ^^^ one of the tables[?] that programs need to have
23:30:54 <ihope> Eep
23:32:12 <Sgep> Forget the irest
23:32:17 <Sgep> err
23:32:19 <Sgep> Don't
23:32:20 <Sgep> hmm
23:32:24 <Keymaker> me bed, read crime fiction
23:32:30 <Keymaker> *go
23:32:31 <Sgep> bye Keymaker
23:32:33 <Keymaker> bye
23:32:38 <Keymaker> night all
23:32:41 <ihope> Byebye
23:32:44 -!- Keymaker has quit ("Funkadelic!").
23:33:56 <Sgep> "Hello world" will be trivial
23:34:19 <ihope> As trivial as in FCELL?
23:34:28 <Sgep> Not quite
23:36:01 <Sgep> To have branches reset time, or not to have branches reset time, that is the question...
23:37:10 <ihope> Have branches reset everything.
23:37:37 <Sgep> not everything
23:37:38 <Sgep> just time
23:37:59 <jix> gn8
23:38:09 <Sgep> bye jix
23:38:10 <ihope> What's time used for?
23:38:14 <ihope> Bye
23:38:31 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
23:38:40 <Sgep> The first instruction-like thing is executed at time 0
23:38:43 <Sgep> for example
23:38:52 <Sgep> Certain things can set the branch
23:39:22 <ihope> Okay. Reset the time.
23:39:37 <Sgep> ok
23:42:43 -!- Sgep has quit (Read error: 104 (Connection reset by peer)).
23:44:40 -!- Sgep has joined.
23:44:51 <Sgep> Bleh
23:44:53 <Sgep> computer went insane on me
23:45:07 * Sgep abolishes the move table
←2005-11-24 2005-11-25 2005-11-26→ ↑2005 ↑all