00:00:00 --- log: started forth/02.03.08
03:10:53 --- join: rob_ert (~robert@h173n2fls33o898.telia.com) joined #forth
03:11:02 <onetom> <yawn>
03:11:43 <rob_ert> Hey :-)
03:15:09 <onetom> how about the tower?
03:15:34 * rob_ert hides :P
03:15:44 <rob_ert> I've been coding and reading too much
03:16:05 <onetom> just like me, doont worry
03:17:50 <rob_ert> :)
03:17:56 <rob_ert> I've written my own forth compiler now.
03:18:03 <rob_ert> With a few extentions
03:18:23 <onetom> >-|
03:18:28 <onetom> kidding?
03:18:28 <rob_ert> :-D
03:18:33 <rob_ert> Nope..
03:19:00 <onetom> show me!
03:19:10 <rob_ert> uhm.. it sucks, but it works ;)
03:19:18 <rob_ert> I'll start my other computer and upload it.
03:19:20 <onetom> show me! show me
03:19:30 <rob_ert> Calm down :P
03:19:49 <rob_ert> It's not 100% done yet, you can't use the 3rd stack ;)
03:19:51 <onetom> too much words too few uploads :)
03:20:04 <onetom> wha? 3rd stack?
03:20:10 <rob_ert> Bah, the computer I have it on isn't even up yet
03:20:14 <rob_ert> Yah :P
03:20:41 <rob_ert> Parameter stack, so parameters are kept until a function (word) ends
03:21:15 <onetom> ???
03:21:30 <onetom> but what r the other stacks than?
03:22:30 <rob_ert> the normal data and return stacks
03:22:54 <rob_ert> the thing is, when you modify the data stack, the parameter stack is unchanged
03:26:09 <onetom> sounds weired, but i ll c
03:26:57 <rob_ert> bozos.sf.net/files/nourth.tar.gz
03:27:06 <rob_ert> it _is_ weird
03:27:10 <rob_ert> :)
03:27:20 <rob_ert> But I don't think it's less useless than forth.
03:42:45 <onetom> hm, so u r an active sf.net user :)
03:45:03 --- join: Stepan (~stepan@Charybdis.suse.de) joined #forth
03:45:08 <Stepan> moin
03:48:36 <onetom> hi
03:48:40 <onetom> Stepan
03:49:15 <Stepan> Hey onetom :)
03:49:23 <Stepan> how's life? going back and forth?
03:49:35 <onetom> rob_ert: u have coded a really strange thing ;)
03:50:25 <onetom> Stepan: eh, dont have time to make the research on preemtive multitasking forth :(
03:50:56 <onetom> Stepan: dont u know by chance where can i get ddjcd?
03:52:02 <onetom> there was an article about a preemptive eforth variant
03:52:24 <onetom> in the 1996.03 issue of ddj magazine
03:53:18 <onetom> but i only have the srces and can find the related article just nowhere
03:53:29 <Stepan> ddjcd?
03:53:38 <Stepan> what's ddj? 
03:53:40 <onetom> dr dobb's journal
03:53:47 <Stepan> i can ask here whether we have that..
03:53:57 <Stepan> hm.. never heard of it.. is it forth specific?
03:53:59 <onetom> wow, sounds great
03:54:03 <onetom> nooo
03:54:13 <onetom> its a general programming mag
03:54:46 <onetom> u can find its archives in any simtel arch under hte ddjmag directory
03:54:55 <onetom> but only up to 1994
03:56:24 <Stepan> what's the name of the mag? "Dr. Dobb's Magazine" or just "Dr Dobb's"?
03:57:02 <onetom> Dr. Dobb's Journal i guess
03:58:23 <rob_ert> onetom: Yeah, it's very strange ;-)
04:05:53 <Stepan> onetom: i sent out a mail to our internal list.. maybe someone will answer.. but i cant promise
04:12:30 <onetom> Stepan: oh, thx a lot in advance
05:03:37 --- join: rob__ert (~robert@h173n2fls33o898.telia.com) joined #forth
05:04:34 --- quit: rob_ert (Killed (NickServ (Ghost: rob__ert!~robert@h173n2fls33o898.telia.com)))
05:04:39 --- nick: rob__ert -> rob_ert
05:11:56 --- join: rob__ert (~robert@h173n2fls33o898.telia.com) joined #forth
05:11:59 --- quit: rob__ert (Remote closed the connection)
05:36:53 <Stepan> oneton: i found one guy with a lot of dobbs magazines at home.. he'll check if he has it.. 
05:52:09 <onetom> ooh, u r wonderful, maaan :>
05:52:28 <onetom> how large is that company u r working in?
05:52:35 <onetom> s/in/for/
05:53:58 <onetom> meanwhile ive cheated the primitive preprocessor of gpasm
05:54:38 <onetom> and i replaced it w m4. do u know m4?
05:54:40 <onetom> define(`curFreg', 0)dnl
05:54:40 <onetom> define(`Forg',`define(`curFreg',$1)')dnl
05:54:40 <onetom> define(`Falloc',`define(`curFreg',eval(curFreg+$1))')dnl
05:54:40 <onetom> define(`Fname',`define(`$1',curFreg)')dnl
05:54:40 <onetom> define(`Freg',`Fname(`$1')Falloc($2)')dnl
05:55:06 <rob_ert> gpasm, that's the free variant of microchip's picasm, right?
05:55:28 <onetom> microchip's mpasm, yes
05:55:33 <rob_ert> ah, sorry
05:55:55 <onetom> rob_ert: so do u know m4?
05:56:24 <rob_ert> Nope :9
05:56:52 <onetom> and dont u even know what is it @ all?
06:00:11 <rob_ert> No.
06:00:48 <onetom> if not yet, than i have2 say: u definitely should ;)
06:01:13 <rob_ert> What is it?.
06:01:15 <onetom> its a language independent macro language
06:01:17 <rob_ert> s/.//
06:01:54 <rob_ert> it can be used as preprocessor for any language then?
06:02:00 <onetom> u can use it to "extend" any lang w macroing capability
06:02:08 <onetom> exactly
06:02:45 <onetom> so u dont have to bother yrself implementin marco handling 4 yr brand new lang :)
06:03:22 <rob_ert> :)
06:04:24 <onetom> eg. ive written a 4th2asm native code compiler
06:04:42 <Stepan> re
06:04:44 <onetom> entirely in bash,awk&m4
06:07:07 <onetom> hmm, no, i was wrong i used m4 for my assembler. it handles the labels and the instruction pointer, afaik
06:08:13 <onetom> now, i go 2 have a shower
06:10:21 --- join: Speuler (~l@a161161.upc-a.chello.nl) joined #forth
06:10:55 <rob_ert> hoi
06:11:00 <Speuler> g'day
06:11:05 <Speuler> hi rob
06:11:07 <Speuler> _ert
06:11:12 <rob_ert> :)
06:11:26 <Speuler> ]O=
06:11:34 <Speuler> (haegar)
06:12:06 <Speuler> isn't he cute ?
06:12:52 <Speuler> ]:O=   ( this one better ? )
06:13:32 <rob_ert> (_:(|)~~
06:13:42 <Speuler> judy ?
06:13:58 <Speuler> or bart's dad ?
06:14:20 <rob_ert> Homer, yeah
06:23:11 <Speuler> i just finished reading "the book of going forth" this morning
06:24:21 <Speuler> it says:
06:24:35 <Speuler> "going forth is easy"
06:24:50 <Speuler> "going back requires (cont. on next wall) ...
06:25:10 <Speuler> ""An effort of will, because it is much harder. Thank you"
06:25:48 <rob_ert> :-)
06:25:49 <Speuler> (page 358)
06:26:48 <Speuler> that"s just before two armies fight against each other, by building wood horses
08:02:08 --- quit: Stepan ("Do you think it is air you are breathing? Hmm?")
08:37:59 --- join: I440r (~mark4@1Cust5.tnt1.bloomington.in.da.uu.net) joined #forth
08:37:59 --- mode: ChanServ set +o I440r
08:38:10 <I440r> watch this
08:38:20 <I440r> argh segfaulted on this server grr
08:38:40 <I440r> this sux!
08:38:46 <I440r> it connects fine to ircu :P
08:39:36 <I440r> argh
08:58:24 <onetom> argh? is it like argv or argc? ;)
08:58:59 <I440r> no its liek DOH!
09:07:36 <onetom> come on, i know, just joking (@least tryin 2 joke :)
09:09:59 <I440r> from :)
09:10:14 <I440r> erm where did the "from" come from there heh
09:10:15 <I440r> ugh
09:10:23 <I440r> i KNOW i didnt type it :P)
09:14:24 --- quit: rob_ert (Read error: 110 (Connection timed out))
09:14:35 --- join: rob_ert (~robert@h173n2fls33o898.telia.com) joined #forth
10:17:07 --- join: futhin (~thin@h24-64-175-123.cg.shawcable.net) joined #forth
10:17:19 <futhin> boo!
10:17:28 * futhin runs and hides!
10:17:32 <futhin> peek a boo!
10:19:14 * futhin conjures some forth code, and it dances across the meadow!
10:19:53 --- quit: Speuler (Remote closed the connection)
10:20:43 <I440r> futhin is acting gay today :P
10:20:49 <I440r> what u been smokin ?
10:20:50 <I440r> heh
10:23:35 <futhin> gay gay gay!
10:24:00 <futhin> it's a gay day today, be gay, jolly, merry
10:24:03 <futhin> blah blah blah
10:24:14 <futhin> where's your irc bot dammit?! :P
10:25:12 <I440r> trying to get it to connect here
10:25:20 <futhin> i'm shifting blame onto your bot for the gayness of this channel!
10:25:42 <I440r> having to rewrite the socket read code because this irc server is fucked in the head :P
10:26:21 <futhin> i can telnet into this server because i am l33t
10:26:44 <futhin> infact! i'm telneted right now!  /ctcp futhin version !
10:27:30 <I440r> :)
10:27:32 <I440r> yea
10:27:35 <I440r> mirc :P
10:27:39 <futhin> <-- leet!!
10:27:42 <I440r> heh
10:28:00 <futhin> no, i sent you an mirc response! it's fake! try again ;)
10:28:07 <futhin> heheh
10:29:16 <I440r> bs :P
10:29:19 <I440r> im busy
10:29:23 <I440r> want my bot connecting here
10:29:34 <I440r> was connecting FINE on my ircu
10:29:45 <I440r> but it was segfaulting here half way thru the login
10:30:22 --- quit: onetom (Read error: 110 (Connection timed out))
10:30:25 <futhin> bah, why does it segfault?
10:30:43 <futhin> it should _never_ segfault! it should just give you a real error message :P
10:30:58 <futhin> seems like you didn't put much error-checking/prevention code in it? 
10:33:02 <I440r> thats not the forth way dood :P
10:33:57 <futhin> heh
10:34:01 <futhin> lies!
10:34:10 <futhin> abort" hey stupid idiot, this is gonna make me segfault"
10:34:20 <futhin> ;)
10:34:31 <futhin> code with an attitude!
10:35:30 <futhin> hrm, brb
10:35:33 --- quit: futhin ("brb")
10:36:15 --- join: futhin (~thin@h24-64-175-123.cg.shawcable.net) joined #forth
10:37:09 <I440r> ok wait
10:38:00 <I440r> ok the bot connects 
10:38:07 <I440r> brb
10:38:14 <I440r> ill try get it to join here
10:39:06 * futhin just typed /whois forthbot nope, no forthbot! damn! :P
10:39:54 <futhin> he's gone
10:40:01 * futhin cries for Forth
10:40:13 <futhin> he's back!
10:40:18 * futhin cheers!
10:40:25 <futhin> time to start the forth orgy!
10:40:45 <I440r> doh hehe hang on
10:40:53 <futhin> he's gone again!
10:40:55 <futhin> oh the excitement!
10:42:15 <I440r> nope
10:42:20 <I440r> they have fucked with the message format
10:42:23 <I440r> its totally different
10:42:26 <futhin> eh?
10:42:29 <I440r> i cant even fucking tokenize the messages
10:42:36 <I440r> irc messages ALEAYS follow the same format
10:42:43 <futhin> mirc works fine on this server, why shouldn't your bot?
10:43:12 <I440r> :source <space> type <space> target <space> message body 
10:43:29 <I440r> if i try seperate the message out into its component parts i fucking segfault here
10:43:42 <futhin> weird
10:44:08 <futhin> well, i guess you have to find out what the message format is now?
10:44:28 <futhin> there's a perl bot around here somewhere
10:44:33 <futhin> maybe the guy knows the message format
10:44:57 <futhin> um, speuler had a bot actually..
10:46:17 --- quit: I440r ("Reality Strikes Again")
10:46:42 --- join: onetom (tom@adsl52070.vnet.hu) joined #forth
10:47:03 <futhin> howdy onetom
10:47:20 <onetom> me sleepy
10:48:20 <onetom> but last night - that is this veryearlymorning - ive checked that preemptive eForth
10:49:03 <onetom> an it look absolutely usable 4 me
10:49:34 <futhin> heheh :)
10:49:39 <onetom> though the corresponding article could help a lot more
10:49:57 <futhin> yeah
10:50:05 <onetom> but dont b so happy, i was right :P
10:50:07 <futhin> you have to buy the article from them or somehthing
10:50:42 <onetom> that eforth has a preemptive 4th kernel
10:50:52 <futhin> what about the example THREAD code ?
10:51:02 <futhin> that had nothing to do with the kernel i don't think ??
10:51:19 <onetom> thats just prepares the proper data struct
10:51:27 <futhin> oh
10:51:32 <onetom> what is interpreted by this kernel
10:51:50 <onetom> but just take a look @ the kernel.asm
10:51:53 <futhin> are you sure?  "forth can do anything" :P
10:52:03 <onetom> absolutely sure
10:52:19 <futhin> you should be able to do multitasking without the kernel
10:52:20 <onetom> ive written some 4ths already ;)
10:52:21 <futhin> i'd think
10:52:55 <futhin> everybody talks about how forth is a vm :P
10:52:57 <onetom> the kernel is the code what runs through the threaded code, right?
10:53:33 <futhin> eh?
10:53:42 <futhin> you mean  : THREAD  <kernel code here> ; ?
10:54:10 <futhin> of course you can use the words the kernels provide
10:54:12 <onetom> nooo :)) sure i dont mean it
10:54:14 <futhin> to make a multitasking..
10:55:04 <onetom> the 4th kernel is the - usually - virtual processor that interprets threaded code
10:55:34 <onetom> threaded code is the "binary" form of forth programs
10:55:46 <onetom> a thread is a list of pointers
10:56:03 <onetom> a list of pointers 2 words
10:56:25 <onetom> and such a list makes up a word
10:56:34 <futhin> all i was saying is that you don't need to be able to modify the kernel (or need its source code)  if you wanted to make it multitasking.   you can use all the words the kernel provides, and create a multitasking program on top of the kernel, and then run programs inside the multitasking program..
10:56:38 <onetom> this list defines the "meaning of a word"
10:57:16 <futhin> i think..
10:57:17 <onetom> i absolutely understand what u r saying
10:57:46 <onetom> and im just trying to teach u why its not absolutely right
10:57:48 <onetom> what u state
10:58:19 <onetom> so did u understand my pervious sentences?
10:58:53 <onetom> if u let me tell u some more, u will understand what am i talkin about
10:59:13 <futhin> go ahead, pls continue
10:59:21 <onetom> k
10:59:47 <onetom> & dont worry, im trin 2 b very concise
11:00:37 <onetom> so, the 4th processor (=4th kernel=inner-interpreter) interprets these threads
11:00:52 <onetom> for this task it needs some registers
11:01:09 <onetom> and some memory
11:01:45 <onetom> it has an instruction pointer (IP)
11:02:16 <onetom> this points to an element of the currently executed chain
11:02:35 --- join: I440r (~mark4@1Cust5.tnt1.bloomington.in.da.uu.net) joined #forth
11:02:52 <I440r> grr fucking thing :(
11:02:54 <onetom> & it has two stack pointers
11:03:00 <onetom> I440r: hi
11:03:24 <onetom> 1 for parameter stack  & for return
11:03:43 <onetom> (PSP, RSP)
11:03:59 <I440r> i just call them sp and rp :)
11:04:01 <onetom> and probably it has a working register (W)
11:04:26 <onetom> thats all what a - usually - vitrual 4th processor have
11:04:28 <I440r> ugh - the "w" register is a realy realy shitty idea
11:04:38 <I440r> even if you have a "working" register you should CALL IT WHAT IT IS
11:04:43 <I440r> not "w"
11:04:56 <I440r> that just obfuscates the fuck out of the sources
11:05:22 <onetom> I440r: ok, lets call them sp, rp instead (thats more conventional)
11:05:26 <I440r> any time i try looking at someone elses sources in do a global search and replace on W and change it to what ever the fuck the actuall register is
11:05:56 <I440r> i hate it when people obfuscate their code by trying to be "cool"
11:06:02 <onetom> I440r: hey, man! stop cluttering up my "lesson"
11:06:06 <I440r> heh
11:06:07 <I440r> sorry :)
11:06:13 * I440r shuts up heh
11:06:21 <onetom> its not a question of coolness
11:06:51 <I440r> the idea for the W register is flawed imho
11:06:54 <onetom> im just trying to give names 2 the things im gonna talk about
11:07:12 <futhin> which register is usually used as the Working register?
11:07:18 <onetom> just think of a geometry class
11:07:20 <I440r> in an x86 its eax
11:07:36 <futhin> i thought ax and bx were for the data stack?
11:07:38 <onetom> when u draw a triangle u can name its corners
11:07:39 <I440r> in 68k it can be ANY register at all
11:07:41 <onetom> as A B C
11:07:53 <onetom> but also P1 P2 P3
11:07:54 <I440r> usually one of the D registers tho d0 thru d7
11:08:03 <onetom> i choose to name i W
11:08:06 <I440r> but a0 thru a6 would work nicely too
11:08:10 <I440r> cant use a7 - thats sp :P
11:08:22 <onetom> and plz, hold on
11:08:33 <onetom> u dont know what im talkin bout now
11:08:50 <onetom> "there is no spoon" in this example
11:09:08 * futhin runs and hides! scared of matrix quotes!
11:09:14 <onetom> im defining a - usually - virtual forth processor
11:09:51 <onetom> futhin: i havent said it 2 u :)
11:10:20 <futhin> :)
11:10:25 <onetom> I440r: so plz dont come up w various specific processors
11:10:33 <I440r> :)
11:10:41 <I440r> he asked - i answered hehe sorry :)
11:10:53 <onetom> now, let me show what does the inner-interpreter do
11:10:57 <onetom> shit, ive a phone call
11:11:18 <onetom> k, me back
11:11:26 <rob_ert> :)
11:12:20 <futhin> instruction pointer (pointer to currently executed chain), stack pointer, return point, working register
11:13:15 <onetom> ip @ @ @ 
11:13:39 <onetom> this retrieves the head of a thread (a word)
11:14:15 <onetom> oh, i forgot to give examples of the memory areas this processor works on
11:14:41 <onetom> certainly we have a dictionary and two stack areas too
11:15:02 <onetom> variable dict dict-size allot
11:15:23 <onetom> variable ps ps-size allot
11:15:30 <onetom> variable rs rs-size allot
11:15:49 <onetom> ps ps-size + sp0 !
11:15:56 <onetom> rs rs-size + rp0 !
11:16:27 <onetom> variable ip
11:16:47 <onetom> variable w ( probably we need it, but we will c)
11:17:11 <onetom> variable rp variable sp
11:17:33 <onetom> entry-point ip !
11:18:11 <onetom> this is the init is roughly...
11:18:27 <futhin> yeah
11:18:44 <onetom> now let me show a dictionary entry (a definition of a word)
11:19:15 <onetom> word-type , word1 , word2 , next ,
11:20:02 <onetom> (it was a long time ago when ive coded a 4th kernel... and i havent do it in 4th b4 :)
11:20:28 <onetom> so a dict entry has a head
11:20:48 <futhin> it's good practice! forth should only be coded in forth! none of that pansy-assed assembly! :D
11:21:39 <onetom> thats it. u got the point
11:22:17 <futhin> eh? you're finished? 
11:22:24 <onetom> so, this head describes who should the body part interpreted
11:22:29 <futhin> ok, you aren't
11:22:58 <onetom> no, im not finished until we put 2gether a very minimal 4th engine
11:23:26 <onetom> but i hope it takes not more than 15mins
11:24:16 <onetom> so, the header could tell that the definition (the body) of the word is
11:24:57 <onetom> a thread of pointers oooor it is a list of primitive words
11:25:44 <onetom> no docol, dovar, do-this, do-that...
11:26:05 <onetom> (i think) its enough to have this 2 types
11:26:57 <onetom> now lets see the main cycle of the inner-interpreter
11:27:01 <onetom> : int
11:27:50 <onetom> this will interpret a threaded code
11:28:15 <onetom> so we assume ip points somewhere into a thread
11:28:30 <onetom> ip @ ( look up where does it point 2 )
11:28:48 <onetom> @ ( get the address from the thread )
11:29:12 <onetom> @ ( retrive the header of the word pointed by it )
11:29:34 <onetom> dup head-threaded = if
11:30:49 <onetom> ip cell + rp @ ! ( save return address onto the return stack )
11:31:29 <onetom> -1 cells rp +! ( update return stack pointer )
11:31:37 <onetom> rob_ert: r u also here?
11:32:06 <rob_ert> yeah
11:32:30 <onetom> is everything clear up to this point?
11:32:48 <onetom> futhin: am i understandable?
11:33:01 <futhin> sure, i've follwed everything up to "head-threaded"
11:33:17 <futhin> dup ?is-this-head-threaded = if 
11:33:23 <futhin> is that what it's supposed to be?
11:34:27 <onetom> aha, i think u understand it
11:36:05 <onetom> (sec. some clean up... im coping the code snippets into a file to help meself)
11:36:21 <futhin> heh :)
11:36:39 <futhin> feel free to edit it up and paste the whole thing back into the channel  (for the logs)
11:37:25 <onetom> now we can step onto another thread located one level deeper
11:37:37 <onetom> ok, i will do
11:38:18 <onetom> (  -- head-pointer-of-the-new-word )
11:38:30 <onetom> ip !
11:38:33 <onetom> else
11:39:18 <onetom> ( else we have 2 deal with a primitive word list )
11:39:32 <onetom> execute
11:39:37 <onetom> then
11:40:10 <onetom> oops...
11:40:16 <onetom> cell + execute
11:40:38 <onetom> because we were standing on the header yet
11:40:58 <onetom> so we have to step 1 cell forward
11:41:30 <onetom> now, lets define the word NEXT
11:42:11 <onetom> this will gonna use up the pointer saved onto the return stack
11:42:17 <onetom> : next
11:42:30 <onetom> cell rp +!
11:42:37 <onetom> rp @
11:42:42 <onetom> ip !
11:42:43 <onetom> ;
11:45:38 <onetom> (arranging the code... preparing to paste it back)
11:46:42 --- join: Forth (~Forth@1Cust5.tnt1.bloomington.in.da.uu.net) joined #forth
11:46:53 <I440r> :)
11:47:08 <rob_ert> Hej Forth.
11:47:18 <I440r> das me bot!!!
11:48:18 <I440r> she doesnt understand privmsg's yet or ctcp's
11:48:21 <I440r> thats next
11:48:27 <futhin> no! first the coding!
11:48:34 <futhin> : blah ." blah ;
11:48:37 <futhin> : blah ." blah ;
11:48:39 <I440r> heh
11:48:40 <futhin> : blah ." blah" ;
11:48:42 <futhin> blah
11:48:44 <futhin> wtF?! :P
11:48:53 <I440r> those would go to it via privmsgs
11:49:02 <I440r> even messages to a channel are privmsgs
11:49:22 <I440r> :nick!user@host PRIVMSG #channel :message body goes here
11:49:57 <onetom> give us a realy example!
11:50:08 <I440r> a reply to what
11:50:19 <I440r> ctcps are privmsgs too
11:50:35 <I440r> but the first character of a ctcp message body is always a \001
11:54:06 <onetom> http://213.163.52.70/~tom/kernel.fs
11:54:22 <onetom> its getting too long to paste back
11:54:43 <onetom> but it will really function finally!
11:54:56 <onetom> tell me if the link doesnt work
11:58:29 <onetom> ah, i forgot about creating a dict pointer
11:58:43 <onetom> at this point we dont definetly need one because
11:59:08 <onetom> we dont have any compiler, but for manualy compilation
11:59:32 <onetom> i create 1 to help building a sample dict
12:05:28 <onetom> hmm, its a bit confusing 2 write a 4th in 4th :-/
12:10:38 <onetom> ahhhhaaa!
12:11:20 <onetom> hmm, nooo bad idea. thinking...
12:12:23 <onetom> :( i got confused
12:12:30 <futhin> question for you
12:12:32 <I440r> very easilly done heh
12:12:45 <futhin> you do:
12:12:45 <futhin> <onetom> dup head-threaded = if
12:12:45 <futhin> <onetom> ip cell + rp @ ! ( save return address onto the return stack )
12:12:45 <futhin> <onetom> -1 cells rp +! ( update return stack pointer )
12:12:57 <onetom> yes?
12:13:08 <futhin> and then you do:
12:13:09 <futhin> <onetom> (  -- head-pointer-of-the-new-word )
12:13:09 <futhin> <onetom> ip !
12:13:09 <futhin> <onetom> else
12:13:09 <futhin> <onetom> ( else we have 2 deal with a primitive word list )
12:13:09 <futhin> <onetom> execute
12:13:13 <futhin> and some more code
12:13:16 <futhin> didn't paste it all..
12:13:27 <futhin> how are the first bit and the second bit related?
12:13:37 <futhin> dup head-threaded = if
12:13:45 <futhin> and then:
12:13:46 <futhin> ip !
12:13:47 <futhin> else 
12:13:48 <futhin> ???
12:13:55 <onetom> the r colocated
12:14:15 <onetom> but check the url i gave u
12:14:25 <futhin> i did..
12:14:26 <onetom> : THREAD-INTERPRETER (  --  )
12:14:26 <onetom>   ( this will interpret a threaded code )
12:14:26 <onetom>   ( so we assume ip points somewhere into a thread )
12:14:26 <onetom>   ip @ ( look up where does it point 2 )
12:14:26 <onetom>   @ ( get the address from the thread )
12:14:26 <onetom>   @ ( retrive the header of the word pointed by it )
12:14:28 <onetom>   dup threaded-word = if
12:14:30 <onetom>     ip cell + rp @ ! ( save return address onto the return stack )
12:14:32 <onetom>     -1 cells rp +! ( update return stack pointer )
12:14:34 <onetom>     ip !
12:14:36 <onetom>   else
12:14:38 <onetom>     1 cell+ @ execute
12:14:40 <onetom>   then
12:14:42 <onetom> ;
12:14:51 <futhin> epic
12:14:52 <futhin> nevermind
12:14:58 <onetom> why?
12:15:03 <onetom> whats wrong w it?
12:15:05 <futhin> i versioned you
12:15:10 <futhin> "epic, nevermind"
12:15:12 <onetom> yeah i saw itr
12:15:33 <onetom> thats why i asked: why? whats wrong w it? 
12:15:34 <futhin> the paste wasn't all at once
12:15:37 <futhin> it slowed down
12:15:59 <onetom> no, i pasted it in two ....
12:16:08 <onetom> two sessions
12:16:33 <onetom> to prevent meself from being kick out
12:16:41 <onetom> because of flooding
12:19:21 <onetom> ok, listen
12:19:53 <onetom> its not clear what does a primitive word look like
12:20:07 <futhin> you wouldn't get kicked out
12:20:09 <futhin> not on this channel
12:20:14 <onetom> if we have a native 4th processor
12:20:31 <onetom> futhin: really? i didnt know it
12:20:46 <onetom> there is no paste limit?
12:20:54 <futhin> i'm pretty sure there's no paste limit
12:21:11 <onetom> ("welcome to speed limit!" - u know the joke dont u.)
12:21:13 --- quit: futhin (Excess Flood)
12:21:19 --- join: futhin (thin@h24-64-175-123.cg.shawcable.net) joined #forth
12:21:21 <onetom> lolllllllll
12:21:37 <futhin> there's a paste limit..  but it's like 20 words
12:21:39 <futhin> er. 20 lines
12:21:43 <onetom> ah
12:22:04 <onetom> ok, now we know it too
12:22:14 <onetom> so
12:23:08 <onetom> ive decided to create a "table" of primitives
12:24:29 <onetom> for this i define the definition of a primitive word like this:
12:25:01 <onetom> primitive-word ,, 4th-processor-opcode ,,
12:25:49 <onetom> this way we have assigned dictionary addresses to the various 4th opcodes
12:26:46 <onetom> and from now on, we can use the native instruction-set of out forth processor
12:26:55 <onetom> s/out/our/
12:27:18 <onetom> in the body of threaded words
12:27:55 <onetom> and now i feel, my example will reach the finish soon
12:28:31 <onetom> as u could see under the specified url
12:29:00 <onetom> ive defined some aux words to help meself in fill the dict up w data
12:29:50 <onetom> these words need some variables
12:29:56 <onetom> variable dp
12:29:56 <onetom> dict dp !
12:30:01 <onetom> : ,, ( n --  )
12:30:01 <onetom>   dp @ ! ( store data where dict pointer points 2 )
12:30:01 <onetom>   cell dp +! ( advance dict pointer )
12:30:01 <onetom> ;
12:30:07 <onetom> ( we also need help for naming specific dictionary locations )
12:30:07 <onetom> : :: ( "name" --  )
12:30:07 <onetom>   create dp @ ,
12:30:08 <onetom> does>
12:30:10 <onetom>   @
12:30:12 <onetom> ;
12:30:20 <onetom> AAAAAAAANNNND
12:30:50 <onetom> now we r ready to define a basic instructionset for our brand new 4th processor
12:30:56 <onetom> completly written in 4th
12:31:24 <onetom> :: op1 primitive-word ,, ' (op1) ,,
12:31:29 <onetom> :: op2 primitive-word ,, ' (op2) ,,
12:32:39 <onetom> they will do nothing else but help us to trace the route of execution
12:32:40 <onetom> : (op1) cr ." op1" ;
12:32:40 <onetom> : (op2) cr ." op2" ;
12:33:57 <onetom> ah, and we also need a word that "marks" - actually handles - the end of threads
12:34:31 <onetom> :: ;; primitive-word ,, ' NEXT ,,
12:39:06 * onetom troubleshooting the net at home
12:45:04 <onetom> hey, sybody, plz say sg!
12:45:44 <onetom> i dont know whether our net connection is functioning or not
12:46:44 * futhin is afk for a bit, bbl
12:47:06 <onetom> ok, so it worx...
12:49:14 <onetom> just the nameservers deny answering....
12:49:42 <onetom> but every hungarian nameserver :( 1 by 1
12:50:05 <onetom> i can ping them, but they dont answer to nslookup/host requests
13:02:49 <futhin> we've gotten so side tracked
13:03:38 <futhin> i weep for the world
13:03:41 <futhin> waaa waa waa
13:03:43 <futhin> <-- shutsup
13:03:47 <futhin> ignore me 
13:20:39 <onetom> ok, i took a break
13:20:45 <onetom> but now im back
13:21:02 <onetom> check out the code ive put together
13:21:17 <onetom> and lets create a main-loop 4 it finally
13:22:16 <onetom> i feel its complete now, and we can start reconstructing it
13:22:26 <onetom> to handle multitasking
13:26:03 <onetom> ive just noticed ive deviated from the standard naming conventions of the 4th kernel
13:26:27 <onetom> (memories started coming back)
13:27:03 <onetom> the standard name of the inner-interpreter is NEXT
13:27:53 <onetom> but then whats the name of the word that finishes a thread?...
13:28:27 <onetom> semis? ...
13:28:51 <onetom> cant remember what is the std name 4 it
13:29:01 <onetom> anybody out there?
13:40:43 <I440r> next isnt realy the inner interpreter
13:41:01 <I440r> next is just the instruction fetch in the virtual machine example
13:41:11 <I440r> i would call quit the inner interpreter
13:43:17 <onetom> u sure?
13:43:57 <onetom> ah, really...
13:44:08 <onetom> it is called quit usually...
13:44:50 <onetom> tho, i never understood why...
13:45:03 <onetom> i always implemented forth kernels just for
13:45:20 <onetom> showing people how easy is it
13:45:57 <onetom> and always used nonstandard variable,word and function names
13:47:31 <onetom> i think, i will name the main cycle MAIN instead of QUIT 
13:47:49 <onetom> until i understand why is it called quit
13:49:59 <I440r> i never understood why they called it quit either heh
13:51:03 --- join: Etaoin (~david@ljk2-11.sat.net) joined #forth
13:51:19 <I440r> hi eta
13:51:25 <Etaoin> hello
13:51:33 <I440r> i got my isforth bot to log in :)
13:51:37 <I440r> cant do anything yet
13:51:38 <I440r> heh
13:51:41 <I440r> but there it is :P
13:51:47 <Etaoin> does anyone have anything that's neat and short that I can look at?
13:52:14 <Etaoin> via irc?
13:52:34 <I440r> yes. its in here now - called Forth heh
13:52:46 <Etaoin> oh
13:52:49 <I440r> forth is isforth with an irc bot extention :)
13:52:51 <Etaoin> Forth: hello
13:53:21 <I440r> ill add the ability to write forth in here and have it interpret it in here
13:55:29 <Etaoin> couldn't that be dangerous?
13:55:51 <I440r> yes :)
13:56:08 <Etaoin> so it'll be restricted, right?
13:56:09 <I440r> it will have to be a trusted user - added to the bot.
13:56:11 <I440r> yes
13:56:15 <I440r> very restricted heh
13:56:15 <futhin> don't worry, we're all experienced coders ;)
13:56:23 <I440r> sure.... sure....
13:57:09 <onetom> Etaoin: http://213.163.52.70/~tom/kernel.fs
13:57:30 <onetom> Etaoin: hi. thats the seed of a forth written in forth
13:57:46 <Etaoin> uh?
13:58:32 <Etaoin> native code comiler?
13:58:43 <onetom> n
13:58:44 <onetom> no
13:59:10 <onetom> its just what i say: a 4th kernel written in 4th
13:59:57 <onetom> it can (will b able 2) execute threaded code
14:00:08 <Etaoin> ah
14:00:14 <onetom> nothing for the 1st time
14:00:51 <onetom> but its just enough 2 evolve it into a multitasking capable kernel
14:01:09 <onetom> and so it also in pure 4th!!!
14:01:26 <onetom> so it will b absolutely portably
14:01:28 <Etaoin> I've never seen these :: ,, and ;;
14:02:16 <onetom> oh, i named them this way to avoid redefinition
14:02:33 <onetom> its an unimportant part of the kernel
14:02:40 <onetom> its just a test
14:03:15 <onetom> and those r helper words for putting an example dict content together
14:04:38 <onetom> they can actually b considerd belonging 2 the "metacompilation level"
14:05:17 <onetom> and its now yet complete certainly but it will b in some secs
14:12:38 <onetom> ive cleaned the code up a bit
14:13:05 <onetom> some more mins & it will b ready 2 test it
14:15:00 <Etaoin> okay.
14:51:55 --- join: aum (~david@l76-154.world-net.co.nz) joined #forth
14:52:05 --- part: aum left #forth
14:53:20 <I440r> hi aum!
14:53:30 <I440r> forth is a bot i wrote for isforth :)
14:54:38 <Etaoin> he's gone
14:57:24 <onetom> hi aum
14:58:52 <I440r> oopts so he is
15:31:57 <onetom> nah, back again
15:32:36 <onetom> everybody just phoned/icqed/irced 2 me
15:33:10 --- quit: Etaoin ("raise SystemExit")
15:33:16 <onetom> kernel.fs now compiles fine, tho doesnt work yet
15:33:24 <onetom> but its not far from it
15:33:42 <onetom> ive cleaned the code up more, added some comments
16:26:41 --- join: Etaoin (~david@ljk2-11.sat.net) joined #forth
16:27:06 <rob_ert> Helloo
16:27:30 <Etaoin> hi
16:34:50 <onetom> hello
16:35:31 <onetom> its really not just a few sec to write a 4th kernel :)
16:35:39 <Etaoin> okay
16:35:42 <Etaoin> good deal
16:35:51 <onetom> tho, im almost done now
16:36:10 <Etaoin> slightly more than a few seconds, I guess
16:36:23 <onetom> im only working on how to detect the end of the program
16:36:42 <onetom> nooo, not that much
16:37:00 <onetom> im just doing it about for an hour
16:38:04 <onetom> & its quite easy writing it in 4th
16:40:03 <onetom> basicly it also worx yet, anyway
16:40:25 <Etaoin> great
16:42:00 <onetom> if u download NOW
16:42:12 <onetom> and say MAIN
16:42:45 <onetom> it does sg and doesnt even drop u an error msg
16:43:07 <onetom> & if u say some times more NEXT
16:43:30 <onetom> it completes its job just fine
16:44:23 <onetom> http://213.163.52.70/~tom/kernel.fs
16:45:16 <onetom> rob_ert: its also could b useful for u to understand the internals of 4th
16:45:32 <rob_ert> cool, I'll check it out
16:46:04 <rob_ert> lol, you write like this in your programs too
16:46:53 <rob_ert> looks like greece to me :)
16:47:00 <onetom> erm... well i actually dont write like this in comments
16:47:18 <Etaoin> I suppose those aren't comments, then
16:47:19 <onetom> but this project has started on irc
16:47:59 <onetom> and ive simply copied the code from irc
16:48:53 <onetom> actually i consider this hack as a conversation
16:48:55 <Etaoin> that doesn't make any sense to me
16:49:03 <onetom> (or rather a monolog :)
16:49:34 <onetom> writen in a platonian like style...
16:49:58 <onetom> what makes no sense 2 u?
16:50:18 <Etaoin> "this project has started on irc and ive simply copied the code from irc"
16:51:16 <onetom> ah
16:51:52 <onetom> ive started to "speak" in 4th here when
16:52:28 <onetom> ive tried to explain to futhin that who does a 4th processor works
16:53:04 <onetom> so 1st i wrote the main components of the kernel
16:53:26 <onetom> on irc
16:53:38 <onetom> embedded to our conversation
16:53:39 <Etaoin> oh
16:55:04 <onetom> than i started writing kernel.fs by coping the code snippets from the irc log
16:55:28 <Etaoin> I see
16:56:21 <onetom>   rp @ rp0 >
16:56:33 <onetom> this is the correct end condition
16:57:09 <onetom> now, it worx, rockz and the like ;)
16:57:47 <Etaoin> it's amazing that you can add object-orientedness to forth with 11 lines
16:57:49 <onetom> i cant dare 2 state that its bugfree, but
16:57:56 <Etaoin> 12 lines
16:58:00 <onetom> the sample code just runs fine in it
16:58:17 <onetom> mini-oof?
16:58:20 <Etaoin> yeah
16:58:33 <onetom> :) yes, thats a lovely piece of code
16:58:48 <onetom> and it does the job quite well
16:59:05 <onetom> ive used it a bit once
16:59:29 <onetom> when i was writing a 4th 2 asm compiler
17:00:00 <I440r> onetom x86 asm ?
17:00:43 <onetom> noooo :)
17:00:51 <onetom> pic asm!
17:01:20 <I440r> doh :)
17:01:56 <onetom> u know, i simply overwrote the colon and the semicolon
17:02:17 <onetom> and thats all! (roughly :)
17:02:48 <I440r> :)
17:03:21 <onetom> ive also ripped the text-interpreter out of gforth
17:03:49 <onetom> and modified it to generate the proper code
17:04:05 <onetom> for pushing the numbers onto the stack
17:04:40 <onetom> and print calls on unknown words
17:05:39 <onetom> this way u could have attached an asm library of basic 4th words to the
17:06:09 <onetom> beginning of the code and they r automaticly called
17:08:32 <onetom> ---------------
17:08:44 <rob_ert> night good .
17:08:56 <onetom> all: what object model do u prefer?
17:09:03 <onetom> rob_ert: gnight
17:09:24 <onetom> rob_ert: now theres a final working version of kernel.fs
17:09:36 <rob_ert> OK, I'll check it tommorrow.
17:09:45 <onetom> rob_ert: u can test it w "test run"
17:09:55 --- quit: rob_ert ("Peace. That's an order.")
17:16:21 --- quit: futhin ("bye")
17:18:04 <Etaoin> can I do something like :noname [ :noname 1 + . ; ] ;  ?
17:18:37 <onetom> pardon? :)
17:18:39 <I440r> heh
17:19:11 <Etaoin> a function returning a function
17:20:12 <onetom> : x 1 + . ;
17:20:17 <I440r> nested functions hehe
17:20:24 <I440r> a function within a function?
17:20:26 <onetom> : y ['] x ;
17:20:44 <Etaoin> what if I want them unnamed?
17:21:03 <onetom> :noname x 1 + ;
17:21:13 <onetom> constant y
17:21:48 <onetom> coz noname-defining a word
17:22:02 <onetom> results an execution-token on the stack
17:22:15 <Etaoin> so there'd be a word-clash in that nestled example?
17:23:06 <onetom> that example is absolutely wrong
17:23:31 <Etaoin> but why?
17:23:40 <onetom> u cannot start a word-definition b4 finishing a previous 1
17:23:53 <Etaoin> uh huh.
17:24:03 <Etaoin> how silly
17:24:35 <onetom> why?
17:24:47 <Etaoin> because it would make it easier if I could
17:25:17 <onetom> hmmm...
17:25:32 <onetom> u r not forth minded enough :P
17:26:18 <Etaoin> you mean twisted
17:26:24 <Etaoin> er untwisted rather
17:26:26 <onetom> yeah :)))
17:26:31 <onetom> but look:
17:26:41 <Etaoin> I'm not untwisted enough
17:26:50 <onetom> func1 (param, param, param) {
17:27:02 <onetom> f1();
17:27:06 <onetom> f2();
17:27:41 <onetom> nested_func() { asd(); qwe(); }
17:27:45 <onetom> f3();
17:27:46 <onetom> }
17:27:57 <onetom> what does it do in c?
17:28:09 <Etaoin> why compare to c?
17:28:16 <onetom> why not?
17:28:41 <onetom> im just trying to compare it 2 someting well known
17:28:54 <onetom> 2 ease the discussion
17:29:12 <onetom> brb
17:29:44 <Etaoin> well, I though :noname just created a word and returned the execution token.
17:32:13 <I440r> you cant nest functions in c heh
17:32:20 <Etaoin> no
17:32:43 <Etaoin> I have lisp on the brain
17:32:44 <I440r> functions dont nest in c
17:32:49 <I440r> heh
17:33:08 <Etaoin> (map (lambda (x) (print x)) myvector)
17:33:16 <I440r> i wish if/switch etc statements didnt nest either :P
17:34:19 <I440r> well im outa here
17:34:27 --- quit: Forth (Remote closed the connection)
17:34:31 <I440r> :)
17:34:45 <I440r> gota go write some more bot sht :)
17:34:55 <Etaoin> okay
17:35:08 --- quit: I440r ("abort" moo!"")
17:44:13 <onetom> back
17:45:11 <onetom> (noname(x) print x)
17:45:31 <onetom> (map (noname) yourvector)
17:45:56 <Etaoin> got it to work
17:46:14 <onetom> r these equvivalent?
17:46:22 <onetom> wow, how?
17:46:26 <Etaoin> then I pollute the namespace with "noname"
17:46:28 <onetom> & what? :)
17:47:11 <Etaoin> you have gforth?
17:47:31 <onetom> amongst the others, yup :)
17:47:41 <Etaoin> http://braznet.com/david/files/oovect.fs
17:47:45 <onetom> but actively im using gforth
17:47:47 <Etaoin> it uses mini-oof
17:47:57 <onetom> and mastering noe
17:48:03 <onetom> none of them :)
17:48:11 <Etaoin> line 48 is where I had the problem
17:48:20 <Etaoin> 50 actually
17:52:37 <onetom> ok, ive read it through
17:53:08 <onetom> and whats your problem?
17:53:09 <Etaoin> any glaring nono's?
17:54:28 <onetom> nono?
17:54:45 <Etaoin> a noun coming from "no no"
17:55:07 <Etaoin> (something that I shouldn't be doing)
17:55:16 <onetom> k, i think ive understand what u said
17:55:41 <onetom> but i dont understand why r u saying that
17:55:49 <Etaoin> it's not a real word, I think
17:56:10 <onetom> nono is just ok
17:56:23 <onetom> we also say it the same way in hungary
17:56:34 <onetom> and also mean the same by that
17:56:52 <Etaoin> neat
17:57:26 <Etaoin> what are you doing now?
17:57:32 <onetom> but why on earth did u ask "any glaring nono's?"
17:57:42 <onetom> typing as u can c ;)
17:57:59 <onetom> anyway, do actually nothing important
17:58:13 <Etaoin> I'm asking if there was anything wrong with what I wrote
17:58:14 <onetom> browsed the eForth resources on the net
17:58:39 <Etaoin> wrong in the sense that it's unforthish
17:58:54 <onetom> ugh, u mean u wrote oovect.fs?
17:59:10 <Etaoin> yes.
17:59:18 <onetom> :))) ohhhh god
17:59:29 <Etaoin> what?
17:59:41 <onetom> i thought uve found it as an example :)))
17:59:50 <onetom> it was so clean & nice ;)
18:00:02 <Etaoin> but uncommented
18:00:38 <onetom> uncommented, but simple enough 2 b uncommented
18:01:21 <Etaoin> now I've got to finish adding some vector operators
18:01:28 <onetom> so, its just perfect
18:01:40 <Etaoin> and then comptemplate matricies
18:02:01 <Etaoin> comptemplate is probably spelled wrong
18:02:01 <onetom> r u doing this as a practice?
18:02:19 <Etaoin> and so I can use it later if I feel like it
18:02:29 <Etaoin> see how fast I can get forth to raytrace
18:02:40 <Etaoin> and still be pretty
18:02:42 <onetom> hm, nice vision ;)
18:03:07 <onetom> nah, u gave me a god idea!
18:03:20 <Etaoin> oh? what's that?
18:03:37 <onetom> 1 can use a 4th written in 4th 2 profile algorithms
18:04:02 <Etaoin> a profiler?
18:04:06 <onetom> because 1 can easily modify the kernel - in 4th language - to
18:04:16 <onetom> produce profiling info
18:05:09 <onetom> eg. we can get an exact and "platform independent" measurement number
18:05:32 <onetom> for your raytracing program for example
18:05:40 <Etaoin> yay.
18:05:48 <Etaoin> it's still not written, btw
18:05:56 <Etaoin> not in forth anyway
18:06:01 <onetom> that doesnt matter ;)
18:06:09 <onetom> im the man of theories :)))
18:06:49 <onetom> tho, as u could c, sometimes i also do some coding
18:07:29 <onetom> because i can, tho i dont like
18:07:48 <Etaoin> is it customary to allot memory and not put it back?
18:08:13 <onetom> thinking is more funny than hunting silly bugs in the specific implementations
18:08:20 <Etaoin> heh
18:08:34 <onetom> in what environment?
18:08:42 <onetom> eg. in gforth ?
18:08:51 <Etaoin> any
18:09:00 <onetom> it depends on
18:09:12 <Etaoin> like, 5 allot blah blah and then never -5 allot
18:09:21 <onetom> in java, yes, u dont have to care about releasing allocated mem
18:09:40 <onetom> erm, dont mix allot and alloc
18:09:55 <Etaoin> okay
18:09:56 <onetom> allot is dp +!
18:10:25 <onetom> it reserves mem on the top of the dict
18:10:52 <Etaoin> "the dictionary" :) I still don't have a clear idea of what that is.
18:11:10 <Etaoin> is alloc a word?
18:11:26 <onetom> well, thats why u should understand that sample code ive written this night
18:11:51 <onetom> type "see alloc" in gforth
18:11:55 <onetom> and u will c
18:12:30 <Etaoin> okay. thanks
18:12:53 <onetom> anyway allocate is the base word 4
18:13:06 <onetom> allocating arbitrary mem blocks
18:14:02 <onetom> (but ive seen alloc defined somewhere... probably in some other forth than gforth...)
18:15:34 <Etaoin> if I had a word that I wanted to detect whether two vectors have the same length, should it return an exception number or a flag?
18:16:14 <onetom> exception number?????????
18:16:25 <onetom> give me an example
18:16:43 <Etaoin> s" Vector length mismatch!" exception constant vect-len-mismatch
18:17:54 <Etaoin> : vect-len-match? ( o1 o2 -- wior )
18:17:54 <Etaoin> 	vect-len @ swap vect-len @
18:17:54 <Etaoin> 	= if
18:17:54 <Etaoin> 		0
18:17:54 <Etaoin> 	else
18:17:55 <Etaoin> 		vect-len-mismatch
18:17:57 <Etaoin> 	then
18:17:59 <Etaoin> ;
18:18:46 <onetom> ok, but how do u plan to use this word?
18:19:21 <Etaoin> 2dup vect-len-match? throw
18:19:22 <onetom> u use exceptions only when an error occurs
18:19:43 <onetom> aha...
18:20:25 <onetom> well, its not easy 2 explain this situation
18:21:39 <onetom> in this case vect-len-match? does nothing actually
18:21:59 <onetom> what can go wrong
18:22:12 <Etaoin> the lengths of the two vectors can not be the same
18:22:47 <Etaoin> in which case some operators aren't defined
18:23:02 <onetom> u generate exception when something unwanted, sg exceptional happens
18:23:25 <onetom> what deviates from the normal flow of things
18:23:45 <onetom> aahhhhaaa!
18:24:03 <onetom> now im gettin closer 2  the problem :)
18:24:32 <Etaoin> good
18:24:35 <onetom> well, in this case, it will do
18:25:21 <onetom> though its a lil bit weired...
18:25:50 <Etaoin> I'm used to exceptions
18:25:56 <onetom> but i cant tell it now whats wrong w it
18:25:58 <Etaoin> I'm exceptional!
18:26:04 <onetom> :))
18:26:28 <onetom> i never used exceptions but in delphi b4
18:26:46 <onetom> tho, ive also tried to use it in gforth
18:27:00 <onetom> it did strange things 4 me
18:27:03 <Etaoin> try python. It's nice.
18:27:19 <onetom> more than nice, thats just perfect ;)
18:27:36 <Etaoin> except that it's not very fast
18:27:57 <onetom> but i have 2 stick w 4th because its much more portable than a python
18:28:17 <Etaoin> and much more ugly looking
18:28:31 <onetom> tho, i have python on my palm IIIe :)
18:28:44 <Etaoin> write a python interpreter in forth
18:28:45 <onetom> but still better than asm
18:29:20 <onetom> and lightyrs more portable than asm - but its obvious :))
18:29:42 <onetom> suuure :)))
18:30:32 <onetom> there r nice parsing tools written in 4th exist
18:30:45 <Etaoin> oh?
18:30:47 <onetom> so i would b not that hard
18:30:55 <onetom> do u know tile-forth?
18:31:00 <Etaoin> no
18:31:17 <onetom> thats an ancient for, i guess, but it has an
18:31:27 <onetom> amazing documentation
18:31:42 <onetom> and beautiful sourcecode
18:32:37 <onetom> imean, it has a handcrafted library of tools
18:32:51 <onetom> totally written in forth83
18:33:17 <onetom> and its doc is that what is just perfect
18:34:01 <onetom> -rw-rw-r--    1 tom      tom        149007 DEC  5 18:31 tile-forth-2.1.tar.gz
18:34:12 <onetom> wanna get it?
18:34:45 <Etaoin> nah
18:34:52 <onetom> it has the nicest man pages ive ever cn 4 a 4th
18:35:04 <onetom> nah, means no?
18:35:18 <Etaoin> correct
18:35:35 <onetom> ooookay
18:36:41 <onetom> (but thats very small... )
18:36:47 <onetom> (and even...)
18:37:59 <Etaoin> I'm busy coding me a vector classw
18:38:09 <onetom> (has multitasking support. semaphores, channels, etc)
18:38:13 <onetom> ok
18:39:58 <Etaoin> no fsqrt ?
18:41:45 <Etaoin> nm
18:41:57 <Etaoin> it does seem to exist after all
19:02:16 <Etaoin> what are you doing now?
19:05:18 <Etaoin> onetom: pst
19:19:06 --- join: qless (~cerberus@clgr000977.hs.telusplanet.net) joined #forth
19:19:23 <qless> howdy folks
19:19:41 <qless> anybody awake?
19:21:28 <Etaoin> yes
19:21:29 <Etaoin> hello
19:21:43 <qless> heya etaoin
19:24:10 <Etaoin> what's happening?
19:24:22 * qless is recovering from a disk failure disaster
19:25:19 * qless what fun, what fun :-|
19:25:27 <Etaoin> I can imagine
19:26:55 <qless> how's your fun with forth?
19:27:10 <Etaoin> it's easier to think using mini-oof
19:27:22 <Etaoin> my mind is mostly intact atm
19:27:36 <qless> mini-oof?
19:27:54 <Etaoin> mini object oriented forth
19:28:04 <qless> oh that does sound fun
19:28:29 <Etaoin> 12 lines of forth for a polymorphic, single inheritance object system
19:28:55 <qless> nifty.  is this a publicly available system?
19:29:01 <Etaoin> yes.
19:29:06 <qless> url?
19:29:06 <Etaoin> it's distributed with gforth
19:29:13 <qless> oh ok
19:29:47 <Etaoin> http://braznet.com/david/files/mini-oof.fs
19:30:05 <Etaoin> ignore that part at the bottom. that's me trying to make it better. it's half done
19:31:32 <Etaoin> http://braznet.com/david/files/oovect.fs
19:31:36 <Etaoin> that's what I'm working on
19:32:29 <qless> nifty
19:41:26 <qless> well i have to shutdown before things overheat.  cheerio
19:41:29 --- part: qless left #forth
19:58:51 <Etaoin> well. forth is a rather interesting language
20:26:33 --- join: futhin (~thin@h24-64-175-123.cg.shawcable.net) joined #forth
20:28:00 <Etaoin> hi
20:29:44 <futhin> hello
20:29:51 <futhin> anything happening?
20:31:04 <onetom> ive fell asleep
20:31:09 <onetom> bye bye
20:31:12 <Etaoin> bye
20:31:21 <Etaoin> I'm writing code
20:32:21 <onetom> futhin: check the final kernel.fs!
20:33:35 <onetom> futhin: u can test it w "test run"
20:34:41 <futhin> heheh
20:34:42 <futhin> url?
20:36:33 <futhin> all the threading code proves is that you can code multitasking ontop of the kernel, without modifying the kernel, as long as you have CODE UNCODE
20:36:50 <futhin> ugh, wtf, you shouldn't even need CODE UNCODE
20:37:06 <futhin> i don't know what the heck we are arguing about
20:37:48 <futhin> <-- is saying that you can implement multitasking ontop of the kernel, without modifying the kernel, doing it all in Forth code, no CODE UNCODE..  you haven't proven otherwise :)
20:37:56 <futhin> or maybe you have to have CODE UNCODE
20:37:58 <futhin> but still..
20:38:10 <futhin> that is perfectly acceptable with what I was saying before
20:38:30 <Etaoin> or else the two definitions of "kernel" are not the same
20:40:05 <futhin> kernel = the default forth they give you, including all the primitives and all the words that it comes with..
20:40:28 <futhin> anything you code, is "on top" of the kernel ;)
20:40:35 <Etaoin> I agree with you
20:40:41 <futhin> (i know, this is bad defining..)
20:40:43 <Etaoin> I have a feeling that's not what onetom was saying
20:41:07 <futhin> etaoin: the problem is that _anytime_ you code in forth, you are actually modifying the forth language. .
20:41:36 <Etaoin> futhin: hooray
20:42:55 <futhin> yeah, it's good, but it ends up with people having different definitions for some of the words.. such as forth kernel :P
20:46:36 <Etaoin> forth is an interesting language
20:48:50 <futhin> yup :)
20:49:28 <futhin> it is such an amazing language
20:52:04 <futhin> chuck moore is probably a genius, just for creating a language that is so simple and powerful, but more than that, is a very different way of thinking & approaching problems
20:56:07 <futhin> although, in some ways, it is similar to lisp
20:56:45 <Etaoin> yeah
20:56:47 <futhin> he learned lisp and he was a hardcore assembly programmer.  so forth was kind of the combination of both
20:56:58 <futhin> but the fact that he is so focused on simplicity
20:57:15 <futhin> i truely believe in the saying "it takes a genius to be simple"  i think that is 100% true!
20:57:51 <futhin> people are so prone to obfuscating things, and making things more complicated, and coming up with the more complex solution to a given problem
21:01:22 <futhin> onetom
21:01:26 <futhin> are you there? :)
21:03:30 <Etaoin> I'm here
21:03:42 <Etaoin> and it's the start of a new hour
21:04:34 <futhin> i just wanted to talk a little bit about my forth mud, the database & the code & the objects in it..
21:10:23 * futhin has been going thru the log and re-reading the conversation re: the forth kernel. i now understand what onetom meant by forth kernel
21:12:26 <Etaoin> what did he mean?
21:13:33 <futhin> um..  the first part of forth, before all the primitives & words are made.  basically, the loop, dictionary, stack, etc..
21:14:53 <Etaoin> I now have a fatal bug in used-to-work code :(
21:19:17 <futhin> forth code?
21:19:21 <Etaoin> yes
21:19:27 <futhin> want me to check it?
21:19:35 <Etaoin> I dunno
21:19:47 <Etaoin> it's an address error
21:20:15 <futhin> it can't hurt to get it checked :P
21:20:51 <Etaoin> might waste your time though
21:21:04 <futhin> naw
21:21:14 <futhin> i'd be happy to
21:21:19 <Etaoin> http://braznet.com/david/files/oovect.fs
21:21:22 <futhin> i really want to look at everybody's forth code :)
21:21:43 <futhin> if i look at lots of forth code, i'll learn some more forth :)
21:22:41 <futhin> ooh
21:22:49 <futhin> your forth code looks very interesting :)
21:23:12 <futhin> i haven't seen much forth code..  and i haven't seen forth coding that has tons of :noname in it :)
21:23:42 <futhin> what is the purpose of the code ?
21:23:49 <futhin> what is it supposed to do?
21:24:19 <Etaoin> to make a general purpose vector class
21:25:30 <futhin> what's a vector class.. ? 
21:26:50 <Etaoin> http://braznet.com/david/files/mini-oof.fs if you don't have it
21:27:18 <Etaoin> are you familiar with object oriented programming?
21:27:57 <futhin> yes, roughly.  i know c++ & about classes & structs
21:28:24 <Etaoin> okay. I'm making a vector object that will be able to do stuff
21:29:28 <futhin> "vector object" and "vector class"  doesn't mean anything to me..  just explain it briefly.. i  probably understand the underlying concepts..
21:29:52 <futhin> <-- tends to forget OOP concepts..  like polymorphism, classes, etc :P
21:30:04 <Etaoin> an object is a bundle of data and methods on that data
21:30:46 <futhin> yeah
21:30:49 <futhin> but the "vector" part..
21:30:50 <Etaoin> my bundle of data is an array of floats and my methods do vector stuff
21:31:05 <Etaoin> a vector is a methematical thing
21:31:11 <futhin> yeah 
21:31:11 <futhin> ok
21:31:16 <futhin> uh
21:31:34 <futhin> what, the vector class is so that you can do math on vectors ??
21:31:42 <Etaoin> yes
21:31:51 * futhin was thinking something totally different, like a spanking new concept
21:32:05 <futhin> not something as simple as doing math :P
21:32:12 <Etaoin> heh
21:32:22 <futhin> so how will it work?
21:32:28 <Etaoin> how it's written
21:32:39 <futhin> how will you calculate some vector?
21:32:39 <futhin> what would the code look like?
21:32:39 <futhin> using the vector class
21:33:04 <Etaoin> vector instantiate 3 over init
21:33:04 <Etaoin> dup copy
21:33:04 <Etaoin> vect-add-copy
21:33:04 <Etaoin> dup print
21:33:39 <Etaoin> that makes a vector and then copies it and then adds the two and then prints it
21:33:43 <futhin> um, no, i mean, how are you going to input the numbers
21:33:48 <Etaoin> no idea
21:33:50 <futhin> for the vector..
21:34:22 <Etaoin> 0.0e1 0 element@ f!
21:34:41 <Etaoin> ( o -- )
21:35:41 <futhin> you've learned a lot of forth pretty quickly?
21:35:54 <Etaoin> only the syntax
21:36:02 <Etaoin> and thinking in stacks
21:36:12 <Etaoin> I don't know a lot about the internals
21:36:37 <futhin> yeah..  but your forth code seems a little more complex..  you might want to factor everything out..  make smaller words (so that it is easier to debug, etc)
21:37:14 <Etaoin> I was doing that, but I missed something somewhere and now stuff doesn't work
21:37:33 <futhin> chuck moore says that a word should only have one or two lines of code, any more, and you are just making it more complex..
21:37:48 <futhin> s/any more/any more than that
21:38:20 <futhin> also, he says you shouldn't have to think about the stack in more than 2 or 3 depth :)
21:38:40 <futhin> <-- my first code was a real exercise in stack thinking!
21:39:00 <Etaoin> yeah, I don't think deeper than 2 or 3
21:39:30 <futhin> yeah, some of the guidelines are: small words,  don't pass more than 2 parameters to a word, etc..
21:41:44 <futhin> i'm not familiar with all of the forth words..  like "instantiate"  or "f@"  etc..
21:41:58 <futhin> you seem to be putting loop into the code without any IF ? :)
21:42:12 <Etaoin> instantiate is in mini-oof
21:42:27 <Etaoin> f@ deals with the floating point stack
21:42:43 <futhin> eh? there's a 3rd stack ?
21:43:01 <Etaoin> optional
21:43:29 <futhin> it depends on the forth you have doesn't it?  you are using gforth right ?
21:43:44 <Etaoin> yes
21:44:43 <futhin> your code can be considered slightly obfuscated, mainly because you have the "loop" all on its own :P
21:45:03 <Etaoin> hm?
21:46:00 <futhin> nevermind
21:46:11 <futhin> i guess that's the power of forth
21:46:16 <Etaoin> surely
21:48:15 <futhin> onetom idle 5 secs ??
21:48:23 <futhin> onetom you there?
21:49:03 <futhin> i guess his client prevents him from going idle too long, in case the server kicks him
21:49:42 <Etaoin> probably
21:53:26 <futhin> eh?
21:53:35 <futhin> you are going to raytrace in forth? :D
21:53:47 <Etaoin> I was thinking about it
21:54:08 <futhin> fun fun.. any reasons why?
21:54:28 <futhin> doing it for fun?  or because of some strength that forth has ?
21:54:59 <Etaoin> I've already done a simple one in two other languages, so I don't have to learn anything about how to design it
21:55:07 <Etaoin> for fun
21:55:22 <Etaoin> and to see how fast forth may be
22:00:08 <futhin> yup
22:00:42 <futhin> not sure how fast it is compared to C compiler since C compiler has better optimizing technology..
22:01:01 <futhin> a lot of forth coders on this chan have told me forth is faster
22:02:06 <futhin> the comp.lang.forth FAQ  gives this url  http://www.complang.tuwien.ac.at/forth/performance.html
22:02:22 <futhin> a benchmark comparing forth & C
22:02:52 <futhin> actually
22:02:59 <futhin> read section 3.5 of  http://www.faqs.org/faqs/computer-lang/forth-faq/part1/   
22:05:22 <futhin> However, there are many reports of cases where Forth programs beat
22:05:22 <futhin>   others in size and/or speed. My guess is that the added flexibility of
22:05:22 <futhin>   Forth helps programmers produce faster and/or smaller programs.
22:07:38 <futhin> ..
22:07:38 <futhin> ..
22:08:14 <Etaoin> okay
22:08:18 <futhin> i wonder if it would be important to use an optimizing forth in a forth os  (if this forth os were to become really big, and used by many people)
22:10:56 <futhin> lol.. 72 lines of code for bubble in forth,  1100 lines of C code for bubble
22:13:37 <futhin> i440r dislikes optimizing forth because it ruins the 1:1 correlation between the code and object..
22:14:26 <futhin> forth should be fast enough in the long run.. for bigger programs, they should end up smaller and simpler, and therefore faster..
22:21:27 <Etaoin> "Dictionary overflow"
22:23:09 <futhin> heh? your code?
22:23:16 <Etaoin> no
22:23:23 <Etaoin> something's screwy
22:23:57 <Etaoin> it didn't do that before
22:24:01 <futhin> did you try "see alloc"  in gforth ??
22:24:08 <futhin> gforth doesn't have see does it?
22:24:18 <Etaoin> yes, it does
22:24:28 <futhin> eh??
22:24:32 <futhin> i'm in gforth right now
22:24:37 <futhin> it just gives me backflow error..
22:25:39 <Etaoin> see see 
22:25:39 <Etaoin> : see  
22:25:39 <Etaoin>   name find-name dup 0= 
22:25:39 <Etaoin>   IF     drop -13 throw 
22:25:39 <Etaoin>   THEN 
22:25:40 <Etaoin>   name-see ; ok
22:25:48 <Etaoin> works here
22:25:54 <Etaoin> 0.5.0
22:26:01 <futhin> hm, i have gforth 0.5.0 too
22:26:05 <futhin> what the heck
22:26:14 <futhin> do you change vocabulary or something?
22:26:29 <Etaoin> no
22:28:24 <futhin> there is no alloc
22:28:26 <futhin> true?
22:29:04 <futhin> weird
22:29:20 <Etaoin> firght
22:29:22 <Etaoin> right
22:29:26 <Etaoin> that was his point
22:29:30 <futhin> yup
22:29:31 <futhin> heh
22:34:00 <futhin> etaoin: i'm trying out oovect.fs in gforth
22:34:07 <futhin> but it doesn't recognize the word copy
22:34:22 <futhin> you have a line that says "dup copy"
22:34:27 <futhin> near the bottom
22:36:11 <Etaoin> now why wouldn't it?
22:36:34 <futhin> because there's no such thing as COPY ??
22:36:56 <Etaoin> it should be made on line 80
22:41:33 <futhin> well it doesn't appear to be assigning copy or something..
22:42:33 <futhin> which is interesting, because it should give the error earlier (because you have copy inside some of the other words)
22:42:46 <futhin> like vect-add-copy
22:42:52 <futhin> or maybe it doesn't matter..
22:42:52 <futhin> hmm
22:43:24 <futhin> vect-add-copy
22:43:24 <futhin> *the terminal*:1: Invalid memory address
22:43:24 <futhin> vect-add-copy
22:43:24 <futhin> ^^^^^^^^^^^^^
22:43:24 <futhin> Backtrace:
22:43:25 <futhin> $DEE387C @
22:43:27 <futhin> $DEE4074 copy
22:43:27 <Etaoin> I get "Invalid memory address" with @ and element@ on the top of the stack
22:43:31 <futhin> yup
22:43:45 <futhin> what did you change? :)
22:43:55 <Etaoin> I dunno
22:44:16 <futhin> @ is fetch right
22:44:23 <Etaoin> yes
22:44:43 <futhin> seriously though, do you remember modifying element@ or somesuch ?
22:44:56 <Etaoin> yes
22:45:01 <futhin> don't you keep old copies of your source around? ;)
22:45:13 <Etaoin> no
22:45:32 <Etaoin> I usually use languages that don't baffle me
22:45:37 <futhin> heh
22:46:12 <futhin> vect-first-element should be defined before element@ is..  ?
22:46:50 <Etaoin> that would be silly
22:47:23 <futhin> eh? i can't find vect-first-element?
22:47:48 <Etaoin> it's magic in the class definition at the top
22:47:59 <futhin> vect-first-element isn't defined ?
22:48:16 <futhin> oh?  var?
22:48:21 <Etaoin> yes
22:49:04 <futhin> give me an example of using init
22:49:30 <Etaoin> just once right after the object is created
22:49:40 <futhin> no, i mean, the parameters you pass to init
22:49:53 <Etaoin> vector instantiate 3 over init
22:51:22 <futhin> a b init >  a b a b > a b a (vect-len) > a b a b (over) > a b ( floats allocate) > a b a (dup) > b a a (rot) > b a (vect-first-element)
22:51:56 <futhin> i dunno if i got the stack right..  
22:52:27 <futhin> jeez, what a mess, you might want to factor it up so that you can track the stack easier
22:52:34 <futhin> heh :)
22:52:52 <futhin> overrall i'm just as impressed with your code as onetom was
22:53:46 <Etaoin> I wrote a bunch of it after he saw it
22:54:20 <futhin> is vector a number? is instantiate a number?  i just want to know how many stack items there are on the stack for init? 
22:54:47 <Etaoin> when? before the function is called there should be 2
22:55:07 <futhin> there should be only 2 numbers on the stack for init?
22:55:33 <Etaoin> yes, the second one being a pointer to some data
22:56:29 <futhin> is "vector instantiate" going to leave any numbers on the stack?
22:56:45 <futhin> a pointer right ?
22:56:52 <Etaoin> yes
22:57:00 <futhin> ok
22:57:47 <futhin> stack looks like:   p 3 >  p 3 p (over) > p 3 p 3 p (2dup)  etc
22:57:51 <futhin> is that fine so far?
22:58:16 <futhin> there's actually 3 numbers on the stack right before init is called
22:58:36 <Etaoin> yes. one of them is there so I can use that pointer later
22:58:40 <futhin> ok
22:59:24 <futhin> ok, i'm just going to go thru the stack flow
23:00:07 <futhin> p 3 p 3 ( vect-len !) > p 3 p 3 p (over)
23:00:11 <futhin> what does floats do?
23:00:17 <futhin> does it take 2 numbers off stack?
23:00:20 <Etaoin> it's like cells
23:00:38 <futhin> p 3 p (floats)  ?
23:00:44 <futhin> would that be right ?
23:01:00 <futhin> floats takes off 2 stack items ?
23:01:09 <Etaoin> no
23:01:14 <Etaoin> only one
23:01:23 <Etaoin> and puts one back on
23:01:38 <futhin> allocate and throw don't affect the stack items right ?
23:01:52 <futhin> floats converts it
23:01:52 <Etaoin> yeah, they do
23:01:56 <futhin> ok i remember
23:02:01 <futhin> floats converts it
23:04:30 <futhin> p 3 p 3 pf (floats) > p 3 p 3 ( allocate throw ) > p 3 p 3 p (dup ) > p 3 3 p p (rot) > p 3 3 p (vector-first element !)
23:04:33 <futhin> does that look right?
23:06:43 <Etaoin> I don't think so
23:06:50 <Etaoin> I'm having trouble thinking.
23:06:54 <Etaoin> it's late
23:07:10 <futhin> allocate throw takes one number off stack right?
23:07:18 <futhin> takes off the number that floats converted
23:07:26 <Etaoin> right
23:07:30 <futhin> throw just quits the whole program
23:07:31 <futhin> ok
23:07:33 <Etaoin> and puts an address on the stack
23:07:36 <futhin> oh
23:07:39 <futhin> ok
23:08:13 <Etaoin> allocate ( u -- addr wior )
23:08:20 <Etaoin> throw ( wior -- )
23:08:37 <futhin> p 3 p 3 a > p 3 p 3 a a > p 3 p a 3 a > p 3 p a 3 (vector-first-element !)
23:13:07 <Etaoin> I think I've found the problem
23:13:46 <futhin> p 3 p 3 a 0 do loop
23:13:57 <futhin> address 0 ?do loop
23:14:05 <futhin> is that right ?
23:14:16 <futhin> do you want the ?do loop to use the address number ?
23:14:19 <Etaoin> probably not
23:14:24 <futhin> given by allocate
23:16:17 <futhin> you want it to be 3 0 ?do loop right ?
23:16:48 <Etaoin> right
23:17:06 <Etaoin> the loop will initialize the float array to 0
23:17:26 <futhin> oops
23:17:29 <futhin> nevermind
23:17:35 <futhin> it is 3 0 ?do loop
23:17:50 <futhin> but inside the loop, the addr is getting dupped
23:19:25 <Etaoin> ahahahahahaha!
23:19:35 <Etaoin> works
23:19:58 <futhin> heh
23:20:06 <futhin> <-- not helpful :P
23:20:13 <futhin> eh?
23:20:20 <futhin> what did you change/fix ?
23:20:25 <Etaoin> not hurtful
23:20:58 <Etaoin> I changed the ordering of the arguments to element@ back to the way they were before it got broke
23:21:20 <Etaoin> seems that the object pointer must be on the top of the stack when calling a method
23:21:37 <futhin> heh
23:22:22 <Etaoin> now would be a good time for sleep
23:22:26 <futhin> ok
23:22:29 <futhin> good night then :)
23:22:34 <Etaoin> good night
23:22:40 --- quit: Etaoin ("raise CreativityError, "can't find a good exit message"")
23:28:39 --- quit: futhin ("sleep")
23:59:59 --- log: ended forth/02.03.08