00:00:00 --- log: started forth/02.02.26
00:54:22 --- join: nilsw (00000@ncdial1-51-2-nc.nordcom.net) joined #forth
01:08:41 --- quit: rob_ert (Read error: 113 (No route to host))
01:09:01 --- quit: adu ("BitchX: now with wings")
01:59:48 --- quit: nilsw ("Delay for N seconds")
02:54:44 --- quit: aum ()
04:01:30 --- join: rob_ert (~robert@h173n2fls33o898.telia.com) joined #forth
04:02:45 <rob_ert> Hi
04:41:35 --- join: nilsw (00000@ncdial4-84-2-nc.nordcom.net) joined #forth
05:13:16 --- join: Stepan (~stepan@Charybdis.suse.de) joined #forth
09:33:18 <rob_ert> Anyone home?
09:33:51 <rob_ert> I'd need to know a bit how forth programs work, from an assembler programmer's point of view
09:34:08 <rob_ert> How a compiled program really works
09:34:34 <rob_ert> afaik, there's a simple "intepreter" that calls the defined words
09:37:02 <nilsw> bert
09:37:35 <rob_ert> hallo, Nils :D
09:38:02 <nilsw> hey :D
09:38:20 <rob_ert> grr... what does the word '*' do?
09:38:34 <rob_ert> FUCK ME
09:38:37 <rob_ert> ehm
09:38:43 <rob_ert> sorry for overreacting
09:38:47 <rob_ert> just noticed I'm dumb
09:38:56 <rob_ert> of course it's multiplication :)
09:41:46 <nilsw> meh
09:41:48 --- quit: nilsw ("Delay for N seconds")
09:55:35 <rob_ert> I'm just curous...but it is possible to mess with the stack without using pen&paper? :)
09:59:07 --- quit: Stepan ("Do you think it is air you are breathing? Hmm?")
10:02:42 --- join: I440r (~mark4@1Cust111.tnt3.bloomington.in.da.uu.net) joined #forth
10:02:49 <rob_ert> hey
10:02:57 <I440r> this fucking rocks :)
10:03:00 <rob_ert> I'd need to know a bit how forth programs work, from an assembler programmer's point of view :-)
10:03:01 <I440r> isforth now interprets the command line
10:03:02 <rob_ert> I440r: What does?
10:03:05 <rob_ert> :)
10:03:14 <I440r> and it will also work from a shebang :)
10:03:22 <I440r> #! /bin/isforth
10:03:34 <I440r> rob ask :)
10:03:44 <I440r> what do you need to know
10:04:45 <rob_ert> I'm just wondering...
10:04:55 <I440r> do you understand nest, unnest and next ?
10:04:58 <rob_ert> How does all this shit work? :)
10:04:59 <rob_ert> Nope
10:05:00 <rob_ert> hehe
10:05:11 <I440r> as in - how they work internally
10:05:14 <rob_ert> can you paste them in asm?
10:05:15 <rob_ert> Yes
10:05:19 <rob_ert> That's what I want to know
10:05:25 <I440r> understanding them is fundamental to understanding forth
10:05:25 <I440r> ok
10:05:34 <I440r> let me give you an anolog
10:05:36 <rob_ert> That's why I want to understand them :P
10:05:43 <I440r> let me explain them
10:05:57 <I440r> ok
10:06:13 <I440r> a processor fetches instructions executes them and fetches the next instruction
10:06:31 <I440r> if the instruction is a branch it changes the address it fetchs from next
10:06:42 <I440r> forth basically works in th esame way
10:06:53 <I440r> it uses a register to hold IP (read interprative pointer)
10:07:28 <I440r> forth fetches the contents of the mempry pointed to by IP, and advances IP
10:07:42 <I440r> it then JUMPS to the address it fetched
10:07:51 <I440r> in order to do this
10:08:21 <I440r> every forth word has to end with the code that "loads the next token to execute, jump to that token"
10:08:21 <I440r> this is called a next
10:08:33 <I440r> because it executes the next token
10:08:33 <I440r> the one pointed to by IP
10:09:04 <I440r> this works perfectly if ALL the tokens in the definition are coded definitions
10:09:10 <rob_ert> how does it know if it's a low or high level word?
10:09:15 <I440r> but lets say were half way through the current definition and we execute a new COLON definition
10:09:27 <I440r> forth has to save the current IP adress in the calling word
10:09:40 <I440r> point IP at the NEW word (the one being called) 
10:09:40 <I440r> ill get to that heh
10:09:40 <I440r> but it was a good question
10:09:52 <I440r> just ignroe that for now ehhe
10:09:54 <rob_ert> sorry :-D
10:10:01 <I440r> forth saves the current IP onto the return stack
10:10:08 <I440r> this is seperate from the parameter stack
10:10:15 <I440r> heh
10:10:33 <I440r> dont appologies for asking a good question
10:10:43 <I440r> that question proved that your not just sitting there reading blah blah blah from me heh
10:10:53 <rob_ert> heeh
10:10:54 <I440r> ok
10:11:01 <I440r> firth saved the interprative pointer onto the return stack
10:11:05 <I440r> jumped to the new : definition
10:11:22 <I440r> the last thing in that definition will be an UNNEST
10:11:28 <I440r> unnest fetches the saved IP off the return stack
10:11:40 <I440r> forth now comtinues to interpret where it left off
10:11:46 <I440r> now for you question
10:11:59 <I440r> ever forth word starts with some machie code
10:12:15 <I440r> for a coded definition it just starts with the asm code for that definition
10:12:30 <I440r> coded definitions end with a NEXT - always!
10:12:38 <I440r> colon definitions start with a call to nest
10:12:47 <I440r> the "call" will leave an address on the stack
10:12:54 <I440r> that address being the address to interpret from
10:13:22 <I440r> nest pushes the current IP onto the return stack as descrived above, pops the not realy a return address off the stack
10:13:28 <I440r> and puts that in IP
10:13:34 <I440r> it then executes a next
10:13:41 <I440r> which fetches the token
10:13:41 <I440r> advances ip
10:13:47 <I440r> jumps to where the token pointed
10:14:08 <I440r> the last token in ALL colon definitions is a pointer to unnest
10:14:15 <I440r> you code asm ?
10:14:18 <rob_ert> yes
10:14:23 <I440r> x86 specificaly i mean heh
10:14:39 <rob_ert> x86, and I've got a bit into pic asm, too
10:14:39 <I440r> ok well
10:14:39 <I440r> ESI is used as IP
10:14:47 <I440r> next is defined as
10:14:47 <I440r> lodsd
10:14:47 <I440r> jmp eax
10:15:07 <I440r> the lodsd fetches the item pointed to by IP into the eax register
10:15:16 <I440r> and advances ESI (ip) to the next token
10:15:26 <I440r> the jmp eax jumps to where that toklen pointed
10:15:38 <I440r> NO FORTH CODED DEF MAY TOUCH ESI
10:15:45 <I440r> not unless it first saves it away
10:15:52 <I440r> esi is a reserved register
10:15:53 <rob_ert> hehe :-)
10:15:58 <I440r> forth uses it
10:16:06 <I440r> in isforth the ebx register is also reserved
10:16:08 <rob_ert> but I concider it a good coding style to save registers anyway
10:16:13 <I440r> that holds the top of stack item
10:16:22 <I440r> ebp is the return stack pointer
10:16:22 <I440r> all other registers are free for use
10:16:30 <I440r> not always
10:16:39 <I440r> not if you know they are scratch
10:16:56 <I440r> in forth any non reserved register is automatically scratch between definitions
10:16:56 <I440r> free for use
10:17:05 <I440r> eax, ecx and edx need not be saved
10:17:06 <rob_ert> oh, another thing... when you manipulate for example chars, do you have to load them to the 32-bit data stack before you can mess with them?
10:17:14 <I440r> saving them would be a waste
10:17:25 <I440r> and - you might not be able to save them to the stack anyway
10:17:37 <I440r> er no
10:17:42 <I440r> they are in memory
10:17:54 <I440r> lets say eds points to a string
10:18:00 <I440r>  mov eax, byte [edx]
10:18:05 <I440r> erm
10:18:05 <I440r> make taht
10:18:14 <I440r>  movzx eax, byte [edx]
10:18:19 <I440r> thatsxz move with zero extend
10:18:24 <rob_ert> yeah.
10:18:43 <I440r> you can also movsx to sign extend the bythe throughout eax
10:18:49 <rob_ert> do you have to do like that, or can you do f.e. add byte[edx],5 directly?
10:18:58 <rob_ert> I mean, using forth
10:19:13 <I440r> i add byte [edx], N all the time heh
10:19:22 <I440r> there are no "protected memory" rules in isforth heh
10:19:22 <rob_ert> where?
10:19:33 <rob_ert> I mean, where do you use that?
10:19:36 <I440r> look at the definition for store and cstore
10:19:46 <I440r> tho that doesnt quite do it that way
10:19:49 <I440r> store does
10:19:55 <I440r> pop dword [edx]
10:20:04 <I440r> erm no
10:20:10 <I440r> pop dword [eBx]
10:20:24 <I440r> pop the item at the top of the stack into the memory location pointed to by ebx
10:20:31 <I440r> cstore does
10:20:32 <I440r>  pop eax
10:20:38 <I440r>  mov byte [ebx], al
10:20:49 <rob_ert> uhm... another little thing... how can I handle strings in forth? How to declare them?
10:20:58 <I440r> you dont declare them heh
10:21:02 <I440r> you allocate them
10:21:12 <rob_ert> oh
10:21:13 <I440r> lets say you want to print "foo" to the display
10:21:18 <rob_ert> how to copy data to them?
10:21:20 <I440r> : foo ." foo" ;
10:21:22 <rob_ert> well
10:21:26 <I440r> ok
10:21:27 <I440r> watch
10:21:34 <rob_ert> if I want to f.e. print something to a file, or whatever
10:21:34 <I440r> create buffer 16 allot
10:21:46 <I440r> somestring buffer 16 cmove
10:21:55 <I440r> moves a string from somestring to buffer
10:21:59 <I440r> of 16 bytes length
10:22:05 <I440r> f.e. ?
10:22:26 <rob_ert> ok... somestring is like "Hello, world!", or?
10:22:33 <rob_ert> f.e. = e.g. :P
10:22:37 <I440r> ok if you waht to print something to a file you can use the as yet unwritten fwrite
10:22:43 <I440r> fwrite will take 2 parameters
10:22:49 <I440r> the byte to write and the file handle
10:23:02 <I440r> another way is to defer emit to some file write word
10:23:15 <I440r> so any characters emmited will be redirected to the file instead of to the terminal
10:23:22 <I440r> the terminal afterall is just a file
10:23:37 <I440r> wtf is f.e. ?
10:23:49 <rob_ert> for example ;)
10:23:52 <I440r> oh hehe
10:24:09 <I440r> e.g. i understand
10:24:13 <I440r> speak latin man!
10:24:14 <I440r> heh
10:24:19 * rob_ert speaks latin
10:24:29 <rob_ert> Exemple gratia on you, my friend!
10:24:39 <I440r> heh
10:24:51 <I440r> qed :)
10:24:55 <I440r> neway
10:24:58 <I440r> any more questions ?
10:25:09 <rob_ert> Hehe
10:25:11 <I440r> did my explanations totally fonfuze you or cear it up ?
10:25:28 <I440r> look at the sourcs to isforth
10:25:31 <I440r> in exec.1
10:25:39 <I440r> nest, next and unnest are in there
10:25:43 <rob_ert> I'm going to see if I understand all of the runtime things
10:25:46 <rob_ert> oh, nice
10:26:03 <I440r> im assuming you have the sources by now ?
10:26:15 <rob_ert> nope, hehe
10:26:17 <rob_ert> where?
10:26:26 <I440r> ok hang on
10:26:31 <I440r> ill let u grab the latest
10:26:35 <rob_ert> :-D
10:26:55 <rob_ert> when I start executing a high level word, what assembler code do I call then?
10:27:31 <I440r> call nest
10:27:34 <I440r>  dd token1
10:27:36 <I440r>  dd token2
10:27:40 <I440r>  dd tonek N
10:27:42 <I440r>  dd unnest
10:27:55 <rob_ert> oh.. thanks :-)
10:28:04 <I440r> ftp 65.224.146.111
10:28:07 <rob_ert> and nest calls token1, token2 etc.?
10:28:07 <I440r> cd pub
10:28:09 <rob_ert> ok, thankyou
10:28:14 <I440r> get the bz2 file
10:28:15 <I440r> erm
10:28:18 <I440r> are you in linux ?
10:28:25 <rob_ert> yes
10:28:28 <I440r> ok heh
10:28:33 <I440r> then you can extract a bz2 ?
10:29:04 <rob_ert> yes
10:29:14 <I440r> there are 2 ways to do next
10:29:24 <I440r> every coded definition needs a next on the end
10:29:28 <I440r> they can either jmp _next
10:29:32 <I440r> where _next is defined as
10:29:34 <I440r> _next:
10:29:36 <I440r>  lodsd
10:29:38 <I440r>  jmp eax
10:29:44 <rob_ert> hm.. who has a picture of a gun on the root of his ftp? :P
10:29:44 <I440r> or they can have next coded inline 
10:29:50 <I440r> me
10:29:51 <I440r> :)
10:29:53 <rob_ert> :)
10:29:53 <I440r> MY gun
10:29:58 <I440r> my guns even
10:30:15 <I440r> the 45 is within arms reach of me right now :P
10:30:19 <I440r> fully loaded
10:30:20 <I440r> one in the chamber
10:30:23 <I440r> safety on
10:30:50 <I440r> that way if some evil c coder tryis to come get me ill be ok :)
10:31:02 * rob_ert gets scared
10:31:03 * I440r does a shifty eyed look
10:31:22 <I440r> u grabbed that already ?
10:31:46 <rob_ert> What's the name? isforth-feb26.tar.bz2 ?
10:31:52 <I440r> yes
10:32:03 --- part: I440r left #forth
10:32:03 --- join: I440r (~mark4@1Cust111.tnt3.bloomington.in.da.uu.net) joined #forth
10:32:03 --- mode: ChanServ set +o I440r
10:32:14 <rob_ert> uhm, wb
10:32:27 --- topic: set to 'todo - write save-exe - releaseversion 1.0' by I440r
10:32:40 <I440r> hehe had to cycle to get ops to set channel topic :)
10:32:47 --- topic: set to 'todo - write save-exe - release version 1.0' by I440r
10:32:53 <rob_ert> /msg chanserv op #forth I440r
10:33:00 <rob_ert> ;-)
10:33:05 <I440r> too lazy :P
10:33:12 <I440r> just do /cycle
10:33:13 <I440r> heh
10:33:15 <rob_ert> hehe
10:35:57 <rob_ert> root:/home/robert/forth# bzip2 -d isforth-feb26.tar.bz2 
10:35:57 <rob_ert> bzip2: isforth-feb26.tar.bz2 is not a bzip2 file.
10:36:04 <I440r> grr
10:36:07 <I440r> do you have mc ?
10:36:15 <I440r> have mc try open it
10:36:23 <rob_ert> hehe
10:36:23 <I440r> and if it can - copy the isforth directory oyut
10:36:29 <rob_ert> it was just a tar file
10:36:34 <I440r> grrrr
10:36:36 <rob_ert> tar -xvf worked fine
10:36:37 <rob_ert> ;)
10:36:47 <I440r> its suppozed to be a BZIP grrr
10:36:48 <I440r> heh
10:37:08 <I440r> do you have nasm ?
10:38:36 <rob_ert> yup
10:38:40 <rob_ert> 0.98.22 I think
10:38:53 <rob_ert> "2 5 + .  . ?
10:38:54 <rob_ert> " <-- how to output? :)
10:39:40 <I440r> cd isforth
10:39:42 <I440r> make linux
10:39:57 <I440r> if it doesnt crap out on you your version if nasm is fine heh
10:40:11 <rob_ert> hmm
10:40:14 <rob_ert> suuuure
10:40:16 <rob_ert> ;)
10:40:22 <rob_ert> hm
10:41:55 <I440r> did it assemble ?
10:44:21 <I440r> oh no. my sources have sucked him in and he cant escape!
10:44:52 <rob_ert> sorry
10:44:58 <rob_ert> I was on the toilet
10:45:01 <rob_ert> it sucked me in
10:45:06 <rob_ert> and I couldn't escape
10:45:18 <rob_ert> and yes, it did assemble
10:45:48 <rob_ert> root:/home/robert/forth/isforth# make linux
10:45:50 <rob_ert> make[1]: Entering directory `/home/robert/forth/isforth/asmsrc'
10:45:50 <rob_ert> make[1]: Leaving directory `/home/robert/forth/isforth/asmsrc'
10:46:11 <rob_ert> That I accidently was root in that console shouldn't do anything, or? :-)
10:47:19 <rob_ert> do you have your own assembler, or do you use NASM?
10:49:12 <I440r> i use nasm
10:49:20 <I440r> isforth needs an assembler extention
10:49:38 <I440r> mrreach says he will write one for me :)
10:49:44 <rob_ert> :-)
10:50:15 <I440r> im closing in on the time when it would be realy needed too heh
10:50:20 <rob_ert> A forth doesn't have to have interactive mode, right?
10:50:24 <I440r> no
10:50:26 <I440r> do this
10:50:32 <I440r> ./kernel.com
10:50:46 <rob_ert> I did...and?
10:50:48 <I440r> say this when ur in thre
10:50:50 <I440r> words
10:50:55 <I440r> tell me what it says :)
10:51:09 <rob_ert> robert:~/forth/isforth# ./kernel.com 
10:51:10 <rob_ert>  ok
10:51:10 <rob_ert> words  words ?
10:51:13 <rob_ert> :-)
10:51:17 <I440r> it doesnt know words
10:51:19 <I440r> say this
10:51:23 <I440r> fload load.f
10:51:38 <rob_ert> fload load.f ..... (do-#!) ?
10:52:07 <I440r> eek!
10:52:10 <I440r> say bye
10:52:15 <I440r> cd forthsrc
10:52:21 <I440r> edit args.f
10:52:25 <I440r> search for (do-#!)
10:52:34 <I440r> change it to (do#!)
10:52:41 <I440r> quit and save heh
10:52:47 <I440r> that was my last edit
10:52:52 <I440r> do- was pissing me off heh
10:52:57 <I440r> the dash wasnt needed :P
10:53:44 <rob_ert> fload load.f ...... done 
10:53:44 <rob_ert>  ok
10:53:52 <I440r> NOW say 
10:53:53 <I440r> words
10:54:25 <I440r> those are all of the words defined in isforth
10:54:36 <rob_ert> heh
10:54:36 <I440r> the code to display them wsnt entered interactivly
10:54:39 <rob_ert> quite a lot
10:54:45 <I440r> you told forth to compile a source file
10:54:49 <I440r> actually about 4 or 5 hyehe
10:55:05 <I440r> it compiled them and you extended the capabilities of the kernel
10:55:14 <I440r> non interactivly
10:55:25 <I440r> the only interaction was to tell it what source file to use
10:55:32 <rob_ert> nice :-) I was more thinknig of a traditional compiler model for forth
10:55:45 <I440r> well im gong to get to that hehe
10:55:45 <rob_ert> you know edit-compile-try-cry-debug
10:55:46 <I440r> say byt
10:55:51 <rob_ert> byt?
10:55:51 <I440r> no
10:55:55 <I440r> forth doesnt do taht
10:55:57 <I440r> bye
10:56:00 <rob_ert> hehe
10:56:02 <I440r> you do 
10:56:05 <I440r> edit debug repeat
10:56:20 <I440r> do you have a test.f there ?
10:56:26 <rob_ert> yes
10:56:32 <I440r> ok
10:56:34 <I440r> say this 
10:56:42 <I440r> erm hangn on
10:57:03 <I440r> ok
10:57:06 <I440r> ./test.f
10:57:12 <I440r> nothing will happen yet
10:57:18 <rob_ert> robert:~/forth/isforth# ./test.f 
10:57:18 <rob_ert>  ok
10:57:24 <I440r> except the #! in the file will lauhch isforth
10:57:30 <I440r> fload load.f
10:57:41 <I440r> normally all of load.f would already be a part of your kernel
10:57:53 <I440r> you would have extended the kernel with load.f and saved it out
10:57:59 <I440r> were emulating that now
10:58:08 <I440r> whe you type ./test.f
10:58:11 <I440r> it would lo9ad isforht
10:58:18 <I440r> isforth would do its init
10:58:27 <I440r> and part of its init would be to run the word
10:58:30 <I440r> do!#
10:58:33 <I440r> type that
10:58:34 <I440r> do!#
10:58:44 <rob_ert> do!#  do!# ?
10:58:48 <I440r> yes
10:59:00 <I440r> did it do anything ?
10:59:17 <rob_ert> that was the reply ;)
10:59:23 <I440r> oh
10:59:26 <rob_ert> it didn't recognize the command
10:59:27 <I440r> did you fload load.f ?
10:59:37 <I440r> i thought i told you to do that heh
10:59:38 <rob_ert> should I load load.f?
10:59:38 <rob_ert> hehe
10:59:40 <rob_ert> I will
10:59:40 <I440r> yes
10:59:45 <I440r> i was saying
10:59:51 <I440r> load.f is the extention to the kernel
10:59:57 <I440r> but we cant save out after extending
10:59:57 <rob_ert> do #!  ok
10:59:59 <I440r> so were faking it
11:00:02 <I440r> no
11:00:04 <I440r> do#!
11:00:07 <I440r> one word not 2
11:00:09 <rob_ert> that didn't work
11:00:16 <I440r> say by
11:00:17 <I440r> byue
11:00:19 <I440r> argh
11:00:20 <I440r> bye
11:00:23 <I440r> ./test.f
11:00:26 <I440r> fload load.f
11:00:27 <I440r> do#!
11:00:28 <rob_ert> ah
11:00:50 <rob_ert> it worked :-)
11:01:00 <I440r> once we can saveexe the extended kernel would automatically run do#! in its init 
11:01:10 <I440r> IF isforth was launced from a shebang
11:01:16 <I440r> if not - it would run dotail
11:01:20 <I440r> say bye
11:01:22 <rob_ert> shebang?
11:01:28 <I440r> a shebabng is a 
11:01:35 <I440r> #! /path/interpreter
11:01:38 <rob_ert> ok
11:01:41 <I440r> at the top of a script
11:01:48 <I440r> she = sharp
11:01:51 <I440r> ! is a bang heh
11:02:04 <I440r> its unixspeek
11:02:09 <I440r> ok
11:02:09 <rob_ert> Hehe
11:02:10 <I440r> bye
11:02:13 <I440r> ./isforth
11:02:19 <I440r> er mo
11:02:20 <I440r> bye
11:02:28 <I440r> ./isforth - fload test.f
11:02:36 <rob_ert> ./kernel.com ?
11:02:38 <rob_ert> no isforth there
11:02:40 <I440r> now ere faking it again...
11:02:45 <I440r> oh no i forgot hehe
11:02:55 <I440r> ./kernel.com - fload test.f
11:03:11 <I440r> i just renemed it to kernel.com
11:03:14 <rob_ert> fload test.f  #! ?
11:03:27 <I440r> no
11:03:29 <I440r> bye
11:03:36 <I440r> kernel.com - fload test.f
11:03:43 <I440r> dont FLOAD it manualy hehe
11:03:50 <I440r> just have - fload test.f in your command line
11:03:57 <I440r> THEN run
11:03:58 <rob_ert> oh, hehe
11:04:00 <I440r> fload load.f
11:04:12 <I440r> the first thing load.f loads is comment.f
11:04:18 <I440r> THAT defines all the commenting words
11:04:23 <I440r> #! is a coment heh
11:04:32 <I440r> run do#!
11:05:00 <I440r> we wernt run from a #! so it doesnt interpret the #! command
11:05:11 <I440r> it goes on to interpret the commanbd line tail
11:05:15 <I440r> the first arg is a -
11:05:20 <I440r> that means interpret the tail
11:05:28 <I440r> if you sayd ./kernel test.f
11:05:36 <I440r> it would just mark that file asthe current file
11:05:41 <rob_ert> robert:~/forth/isforth# ./kernel.com - fload test.f
11:05:41 <rob_ert>  ok
11:05:41 <rob_ert> fload load.f ...... done 
11:05:41 <rob_ert>  ok
11:05:41 <rob_ert> do#! 
11:05:42 <rob_ert> fload open error
11:05:44 <I440r> so whe u say ed - you eedit that fikle
11:05:47 <I440r> eep
11:05:57 <I440r> what did you have on your command line exactly >
11:06:06 <rob_ert> I pasted that...
11:06:09 <I440r> ./kernel.com - fload test.f ?
11:06:14 <rob_ert> robert:~/forth/isforth# ./kernel.com - fload test.f
11:06:36 <I440r> quit forth and say ls
11:06:40 <I440r> is test.f still there ?
11:06:55 <I440r> ther was a bug that caused files to go to file size 0 but i thunked i had fixed it
11:07:05 <I440r> source files arent opend with write access by default
11:07:08 <rob_ert> -rwxr-xr-x    1 robert   users         148 Feb 26 15:59 test.f
11:07:13 <I440r> ok
11:07:22 <I440r> hrm
11:07:23 <I440r> hehe well
11:07:31 <I440r> it should have interpretd the fload
11:07:34 <I440r> loaded the file
11:07:48 <I440r> and did the test stuff again heh
11:07:51 <I440r> worked for me :P
11:07:53 <I440r> try it again
11:08:04 <I440r> ./kernel.com - fload test.f
11:08:08 <I440r> fload load.f
11:08:11 <I440r> do#!
11:08:37 <rob_ert> robert:~/forth/isforth# ./kernel.com - fload test.f
11:08:37 <rob_ert>  ok
11:08:37 <rob_ert> dload load.f  dload ?
11:08:37 <rob_ert> fload load.f ...... done 
11:08:37 <rob_ert>  ok
11:08:38 <rob_ert> do#! 
11:08:40 <rob_ert> fload open error
11:08:50 <I440r> grr
11:08:57 <I440r> it works for me :P
11:09:00 <I440r> its you
11:09:02 <rob_ert> hehe
11:09:04 <I440r> it doesnt like you  :P
11:09:05 <rob_ert> it hates me!
11:09:07 <rob_ert> exactly
11:09:11 <I440r> your not a forther yet L(
11:09:12 <I440r> :)
11:09:15 <I440r> and it knows it heh
11:09:21 <rob_ert> hehe
11:09:37 <I440r> hrm
11:09:43 <I440r> it didnt say what file it couldnt open
11:09:45 <I440r> weird
12:15:09 --- join: futhin (thin@24.64.175.123) joined #forth
12:15:36 <futhin> hihi
12:17:31 <I440r> futhin
12:17:39 <I440r> isforth is VERY close to release 1.0
12:17:42 <I440r> very close
12:17:48 <I440r> all i gotta write now is save-exe
12:18:03 <I440r> and where the futh have you been :P
12:21:34 <futhin> it's supposed to be foo-thin
12:21:38 <futhin> think of it as foo-thin :P
12:23:07 <I440r> like fu man chu but different :)
12:23:42 --- join: Speuler (~icafe@195.30.184.21) joined #forth
12:23:48 <futhin> yeah
12:23:57 <Speuler> g'day
12:24:11 <I440r> hi :)
12:24:23 <I440r> isforth can interpret the commanbd line tail
12:24:29 <I440r> ./isforth - fload foo.f
12:24:32 <I440r> works
12:24:42 <I440r> isforth can execute from a shebang
12:24:48 <I440r> #! /bin/isforth
12:24:53 <I440r>  forth source goes here
12:24:55 <I440r> works
12:24:56 <Speuler> tat's good
12:24:59 <rob_ert> back..
12:25:00 <Speuler> very useful indeed
12:25:20 <I440r> all i need now is save-exe and im going to release 1.0
12:25:28 <Speuler> i use that feature of gforth to execute some scripts for the icafe setup
12:25:36 <I440r> if isforth is launcehed from the shell it interprets the tail.
12:25:52 <I440r> if its launced from a shebang it leaves the tail for the script to interpret
12:26:10 <I440r> the shebang mechanics are FUCKED UP!!!
12:26:20 <I440r> normally when you enter a program in linux
12:26:26 <I440r> the top of stack is argc
12:26:30 <I440r> next is arg0
12:26:33 <I440r> next is argp
12:26:36 <I440r> next is envp
12:26:54 <I440r> if you are launced from a shebang and the shebang doesnt have any parameters on it
12:27:06 <I440r> argp will point at the enbvironment and envp will be null
12:27:10 <I440r> fucked in the head
12:27:17 <Speuler> we got a new candiate forth programmer here !
12:27:38 <futhin> where?
12:27:43 * rob_ert 
12:27:45 <rob_ert> :P
12:28:22 <I440r> who ?
12:28:40 <Speuler> he told ya already ...
12:28:52 <rob_ert> he's a bit slow ;)
12:28:56 <futhin> rob_ert: you are going to become a l33t f0rth hax0r!?
12:29:00 <I440r> im a bit tired :)
12:29:06 <I440r> i was up all nite coding :P
12:29:15 <futhin> well you seem to be coding pretty fast
12:29:21 <futhin> if you are so close to release 1.0
12:29:26 <I440r> i just spent the morning explaiining next, nest and unnest to him :)
12:29:33 <I440r> forth devel IS fast
12:29:36 <rob_ert> futhin: pff... exactly
12:29:42 <I440r> once i got going 
12:29:53 <futhin> rob_ert: eh?
12:30:10 <rob_ert> <futhin> rob_ert: you are going to become a l33t f0rth hax0r!?
12:30:17 <rob_ert> I was refering to that ;)
12:30:22 <I440r> once i get save-exe done isforth can be used to compile actual applications
12:30:28 --- join: nilsw (00000@ncdial1-219-1-nc.nordcom.net) joined #forth
12:30:36 <I440r> zero!
12:30:49 <Speuler> brb
12:30:51 <rob_ert> Hi Nils
12:30:56 <nilsw> mister I440r!
12:30:58 <nilsw> bert!
12:31:01 <nilsw> Speuler!
12:31:20 <I440r> :)
12:32:08 <futhin> rob_ert: got any forth projects?
12:32:21 <rob_ert> Learning a bit about forth ;-)
12:32:25 <rob_ert> And then writing a forth
12:32:52 <rob_ert> That's why I've been harassing the people in here with questions about how the runtime environment workd ;-)
12:32:54 <rob_ert> works
12:33:12 <I440r> u got nest, next and unnest sorted ?
12:33:38 <Speuler> hi nils !
12:33:42 <rob_ert> almost ;)
12:34:05 <futhin> nest, next and unnest aren't important :P
12:34:22 <futhin> i don't know them, i don't care, i am an elite forth hax0r
12:34:29 <Speuler> rob_ert: i440r doesn't mean bad, he's just naturally nasty to people :)
12:34:44 <rob_ert> Heh
12:34:48 <rob_ert> He's not nasty :-D
12:34:52 <I440r> heh
12:34:55 <I440r> grrrrr!
12:35:06 <rob_ert> btw, does "nest" get the address to go to from the data stack?
12:35:07 <I440r> specially people who use tabs in their sources :)
12:35:31 <Speuler> futhin: nest, unnest, next are THE most important thing in a forth interpreter
12:35:40 <Speuler> especially if you want to learn the inner workings
12:35:48 <Speuler> and that's required to become a good fort hprogrammer
12:36:16 <I440r> yes
12:36:21 <I440r> all : defs CALL nest
12:36:24 <I440r> in isforth anyway heh
12:36:31 <rob_ert> futhin: how old are you? You don't sound like ~40 ;D
12:36:34 <Speuler> rob_ert: no
12:36:40 <I440r> im 38
12:36:49 <Speuler> gets it from program memory, from where ip points to
12:37:02 <futhin> rob_ert: i'm 20, and i'm a day trader
12:37:07 <futhin> :D
12:37:12 <rob_ert> futhin: :D
12:37:13 <I440r> futhin you are MAD!!!!
12:37:21 <I440r> dont day trade on margin!!!! heh
12:37:40 <futhin> naw, i read a bunch of books on risk & money management
12:37:45 <rob_ert> nest:
12:37:45 <rob_ert>  sub ebp, byte 4            ;open space on return stack
12:37:45 <rob_ert>  mov [ebp], esi             ;save current interpritive pointer to it
12:37:45 <rob_ert>  pop esi                    ;get new ip and interpret from here
12:37:45 <rob_ert>  next
12:37:59 <rob_ert> pop esi <-- doesn't that pop from the data stack=
12:38:02 <rob_ert> ?
12:38:29 <Speuler> nest pushs the ip, before reloasding it with a new address
12:38:44 <futhin> lies, i don't see any push
12:38:59 <I440r> there is no push
12:39:00 <Speuler> sub ebp ... mov [ebp]
12:39:01 <I440r> its a CALL
12:39:09 <I440r> call puhses the return address automatically
12:39:26 <rob_ert> well, first it saves the IP to the return stack
12:39:28 <rob_ert> but then?
12:39:36 <rob_ert> does it get the new IP from data stack, or what?
12:39:40 <I440r> yes]
12:39:42 <Speuler> .. but uses SP which may serve well as data stack
12:39:59 <I440r> from the processor stack which is also the data (parameter) stack
12:40:19 <Speuler> bloody waste to use SP for return addresses ...
12:40:35 <I440r> and also - NOT forth
12:40:44 <I440r> thas subroutine threading and does not count :P
12:40:53 <I440r> well
12:41:00 <I440r> it wouldnt NEED to be sub threading
12:43:04 --- nick: Speuler -> PhoodPhrenzy
12:46:06 * PhoodPhrenzy will soon be known as CafeinJunky
12:47:27 <PhoodPhrenzy> do you spell cafein with two ff , like caffein ?
12:47:50 <futhin> caffeine
12:48:11 --- nick: PhoodPhrenzy -> CaffeineJunky
12:48:22 <CaffeineJunky> thank you .
12:48:27 <futhin> np
12:57:08 --- quit: CaffeineJunky ("changing machines")
13:53:00 --- join: Etaoin (~david@ljk11.sat.net) joined #forth
13:53:12 <Etaoin> gasp
13:53:30 <I440r> i eta!!
13:53:47 <I440r> gasp ??? heh
13:53:50 <futhin> hi etaoin
13:53:56 <Etaoin> hello.
13:54:44 <rob_ert> Hi :-)
13:55:03 <I440r> eta what was the gasp for heh
13:55:32 <futhin> etaoin: you have hurt our feelings :(
13:55:45 <futhin> i expect you to devote 25% of your life on this channel from now on ;)
13:56:04 <Etaoin> I was surprised that this channel existed
13:56:07 <rob_ert> only 25%?
13:56:46 <futhin> well, the other 50% is for sleeping
13:56:51 <I440r> heh
13:56:53 <futhin> and the other 25% is for eating and work
13:57:13 <I440r> eta on an x86 linux based machine  ?
13:57:30 <rob_ert> futhin: Work? :-)
14:02:45 <I440r> Etaoin: do you use an x86 based linux os 
14:02:45 <I440r> ?
14:03:47 <Etaoin> sorry, I was in the bathroom.
14:03:53 <futhin> unexcusable!
14:03:54 <Etaoin> I440r: yeah.
14:03:55 <futhin> :P
14:04:03 <futhin> <-- ignore this guy
14:04:13 <I440r> k heh
14:04:13 <I440r> do you ?
14:04:19 <I440r> do you code forthv ?
14:04:25 <I440r> im assuming mayube you do
14:04:26 <Etaoin> no, I don't know forth
14:04:31 <I440r> fu thats a given :P
14:04:37 <nilsw> hey mark
14:04:40 <nilsw> how are you?
14:04:46 <I440r> oh heh
14:04:51 <Etaoin> I haven't started coding any or looking at any examples
14:04:54 <I440r> asm ?
14:05:11 <Etaoin> a little
14:05:15 <I440r> nil - im doing ok for someone who didnt sleep last nite heh
14:05:38 <nilsw> i'm doing bad for someone who wants sex so much :|
14:05:43 <nilsw> #@^$%(*%^
14:05:56 <I440r> if yer intersted in forth - this is the place to be :)
14:06:07 <I440r> fu do yu still read the logs for this channel ?
14:06:24 <I440r> nilsw: me too - you got a cutensexy sister i can have ?? heh
14:06:33 <Etaoin> I'm interested in learning more about the language so I can see if I'm interested in it
14:06:35 <I440r> fu i got a job for you.
14:06:49 <I440r> your first REAL task for this project :)
14:06:57 <I440r> eta well thats a start :)
14:07:10 <nilsw> no I440r
14:07:15 <nilsw> i don't have brothers or sisters
14:07:30 <nilsw> maybe that's why i'm so antisocial now
14:07:31 <futhin> fu = me?  or fu = fuck you ?
14:07:43 <futhin> :P
14:07:46 <I440r> doh :P
14:07:50 <futhin> i confuse them
14:07:57 <I440r> fu = you :P
14:08:00 <futhin> heheh
14:08:08 <I440r> i got a job for you!!!
14:08:12 <futhin> no i haven't really been reading the logs
14:08:31 <I440r> go through the logs of this channel and pick out anything anyone ever said since clog has been in here - and put it in a file
14:08:43 <I440r> to be included in the distro for isforth :)
14:08:52 <futhin> spam! :P
14:09:13 <I440r> yes :)
14:09:20 <I440r> thats your job now
14:09:27 <I440r> you are the official isforth spammer :P
14:10:44 <futhin> no editing of the stuff?
14:10:54 <I440r> heh
14:10:54 <futhin> put it all into one huge file?
14:10:58 <futhin> 50 meg file? :P
14:11:02 <I440r> no
14:11:06 <I440r> dotn quote the whoe thing
14:11:14 <futhin> stuff related to isforth ?
14:11:17 <I440r> pick and chose what to quote
14:11:21 <futhin> oh
14:11:21 <I440r> anything
14:11:28 <futhin> hm
14:11:32 <I440r> funny, interesting, stupid (unless I said it :)
14:12:50 <futhin> nuh uh, you don't get special status ;)
14:13:01 <I440r> i do so too!!!!!!!!!!!!!!1
14:13:04 <I440r> rm -rf futhin
14:13:05 <I440r> heh
14:13:14 <futhin> heheh
14:13:15 <I440r> mke2fs futhink
14:13:18 <I440r> no
14:13:23 <I440r> thats too good for you
14:13:32 <I440r> mkdos futhin
14:13:32 <I440r> heh
14:13:38 <futhin> heh
14:13:39 <I440r> nkemsdos 
14:13:42 <I440r> mke even grr
14:13:48 <I440r> mental note - must learn to type
14:13:56 <futhin> rm -rf mental note
14:14:06 <futhin> er
14:14:17 <I440r> that happens automaticaly after a few minutes anyway heh
14:14:23 <I440r> garbage collection
14:14:25 <I440r> u know
14:14:34 <futhin> yeah
14:14:37 <futhin> there's a cron process
14:14:40 <futhin> running mv mental note /dev/null
14:14:44 <futhin> every now and then
14:15:27 <I440r> yup
14:15:41 <I440r> im suppries /dev/null isnt full by now :)
14:16:02 <I440r> they must be using a realy good compression method on it :)
14:16:47 <futhin> well it's a holographic universe :P
14:16:56 <I440r> :)
14:22:57 <Etaoin> yay. I have gforth installed
14:24:04 <I440r> ugh heh
14:24:12 <I440r> instal isforth - its ALMOST useable :P
14:24:32 <I440r> well i8 gtg zzz - was up all nite
14:24:37 <futhin> ok
14:24:38 <Etaoin> bye
14:24:43 <I440r> tomorrow i start coding save-exe
14:24:46 <I440r> !!
14:24:51 <futhin> !!!!
14:24:55 <Etaoin> !!!!!!
14:25:01 --- quit: I440r ("Reality Strikes Again!")
14:25:44 <rob_ert> Hmm... I'm really starting to wonder if it's even possible to do all this stack magic in your head :-)
14:26:30 <futhin> you don't really deal with more than 2 or 3 levels of stack
14:26:34 <futhin> if you are dealing with more
14:26:36 <futhin> you are doing it wrong
14:26:50 <futhin> you factor up the words, so that you keep it simple
14:27:07 <futhin> and don't pass more than 2 parameters to words.  
14:27:18 <futhin> if you pass than 2 parameters, you are doing something wrong :P
14:27:48 <rob_ert> hehe
14:27:58 <rob_ert> do you know how to declare a string?
14:28:11 <rob_ert> like... char s[10];
14:28:15 <rob_ert> and then copying something to it
14:29:18 <futhin> well.. i'm not really the right guy to ask,  but what you actually do is you create a variable..    and there's a way to make the variable bigger (which i forget).. then you can put stuff in it..
14:30:36 <rob_ert> hehe
14:31:03 <rob_ert> I more and more begin to doubt forth really is that powerful ;) Seems like ugly hacks to do simple things
14:31:18 <futhin> not really
14:31:26 <futhin> it's not really an ugly hack
14:33:28 <futhin> it's not a hack..  there's no real rules.  creating a variable and expanding it is acceptable, and probably produces nearly identical code that a C compiler would produce..
14:33:49 <futhin> forth is very flexible..  it's lowlevel and it is highlevel
14:35:31 --- quit: nilsw ("Life > computers.")
15:05:41 --- join: Speuler (l@195.30.184.52) joined #forth
15:05:52 <Speuler> 'oi
15:06:01 <rob_ert> Hi :-)
17:29:12 <Etaoin> forth is pretty low level.
17:29:27 <rob_ert> Yup
17:31:11 <futhin> it's high level too
17:31:30 <futhin> it can be described as an application oriented language..
17:31:40 <futhin> you code the language of the application
17:32:36 <Etaoin> yeah
17:33:29 <futhin> an application oriented language is actually higher level than procedural languages..
17:33:56 <futhin> with forth you can do low level and you can create a language for an application
17:34:04 <futhin> it's beautiful :)
17:34:07 <futhin> no layers
17:34:13 <futhin> no layers of interfaces
17:34:19 <futhin> just one interface between you and the computer
17:34:36 <rob_ert> assembler... :D
17:34:45 <rob_ert> oh.. you were talking about forth
17:34:57 <futhin> heh
17:35:05 <rob_ert> ;)
17:35:08 <futhin> you can have everything in forth.. the gui, the assembler
17:35:08 <futhin> etc
17:35:14 <futhin> it's all continuous
17:46:16 --- quit: Speuler (Read error: 110 (Connection timed out))
17:47:47 <Etaoin> I need something to write
17:48:21 <futhin> i recommend downloading the pygmy tutor
17:48:31 <futhin> it comes with pygmy forth
17:48:37 <Etaoin> I hate downloading
17:48:41 <futhin> hehe
17:48:53 <futhin> you are on a dialup connection?
17:48:59 <Etaoin> yes
17:49:11 <rob_ert> fprimer.zip :D
17:49:43 <futhin> i downloaded that
17:49:49 <futhin> haven't opened it up or anything yet
17:49:52 <Etaoin> I've got a doc here with all the specifications of the words, but I need an objective
17:49:55 <futhin> and that was like 6 months ago :P
17:50:22 <futhin> etaoin:  code a program that displays a pyramid of asterisks
17:50:26 <futhin> factor it up
17:50:35 <futhin> should use at least 3 words
17:50:47 <Etaoin> not like a centered pyramid?
17:51:19 <Etaoin> I mean a right triangle, not an equilateral one
17:51:20 <Etaoin> ?
17:52:24 <futhin> um
17:52:25 <futhin> like
17:52:29 <futhin>   *
17:52:32 <futhin>  ***
17:52:35 <futhin> *****
17:52:43 <Etaoin> okay
17:52:51 <futhin> make it so that you type:  20 pyramid
17:53:02 <futhin> and it prints a 20 line pyramid
18:25:16 <rob_ert> : NIGHT CR ." Good night." ;
18:25:17 <rob_ert> NIGHT
18:25:19 <rob_ert> :-)
18:26:03 --- quit: rob_ert ("Riders on the storm...")
18:55:18 <Etaoin> done
18:56:40 <futhin> heh
18:56:40 <futhin> cool
18:56:47 <futhin> show me the code :P
18:56:48 <futhin> paste it
18:57:30 <Etaoin> : pyramid-do-spaces ( n -- )
18:57:31 <Etaoin>     1 - 0 ?DO
18:57:31 <Etaoin> 	space
18:57:31 <Etaoin>     LOOP ;
18:57:31 <Etaoin> : pyramid-do-stars ( n -- )
18:57:31 <Etaoin>     2 * 1 + 0 ?DO
18:57:33 <Etaoin> 	." *"
18:57:35 <Etaoin>     LOOP ;
18:57:39 <Etaoin> : pyramid { n -- }
18:57:41 <Etaoin>     CR
18:57:43 <Etaoin>     n 0 ?DO
18:57:45 <Etaoin> 	n i - pyramid-do-spaces
18:57:47 <Etaoin> 	i pyramid-do-stars
18:57:49 <Etaoin> 	CR
18:57:51 <Etaoin>     LOOP ;
18:59:14 <futhin> looks good to me
18:59:47 <futhin> yay! you are forth coder now! ;)
18:59:50 <Etaoin> yay
18:59:56 <futhin> you can never turn back from the dark side, bwahahahah! :P
19:00:05 <Etaoin> sure I can
19:01:07 <futhin> you don't need a 0 in front of ?do
19:01:14 <futhin> it can be:  1 ?do
19:01:19 <futhin> so that you don't have to have 1 -
19:01:45 <Etaoin> in do-spaces?
19:01:56 <futhin> yeah
19:02:06 <futhin> : spaces 1 ?do space loop ;
19:02:40 <Etaoin> yup
19:02:42 <futhin> i dunno what's up with ?do
19:02:46 <futhin> i just use do :P
19:03:12 <Etaoin> ?do checks the arguments to make sure one isn't bigger than the other
19:03:21 <futhin> hm
19:03:21 <futhin> yeah
19:03:38 <futhin> now try making a diamond :P
19:04:26 <Etaoin> easy
19:05:00 <Etaoin> ack
19:11:54 <Etaoin> : diamond { n -- }
19:11:55 <Etaoin>     n pyramid
19:11:55 <Etaoin>     n 1 + 2 ?DO
19:11:55 <Etaoin> 	i pyramid-do-spaces
19:11:55 <Etaoin> 	n i - pyramid-do-stars
19:11:55 <Etaoin> 	CR
19:11:57 <Etaoin>     LOOP ;
19:12:00 <Etaoin> that works, though I don't know why
19:13:35 <futhin> heheh
19:13:47 <futhin> coding instinctively is pretty good, it's faster
19:14:05 <Etaoin> it's bad if you want to understand what you write later though
19:14:12 <futhin> yeah
19:14:25 <futhin> generally you should instinctively code and understand it :P
19:14:39 <futhin> i don't get what's up with the 2 in front of ?do
19:15:02 <Etaoin> I already told you I don't know how it works, just that it does
19:15:08 <Etaoin> :P
19:15:15 <futhin> heh
19:16:20 <futhin> : n dup ;
19:16:45 <futhin> you can define n as dup
19:16:49 <futhin> it should work
19:16:56 <futhin> hopefully you aren't defining it as a variable
19:17:06 <futhin> you don't want to abuse variables :P
19:17:15 <Etaoin> okay
19:17:26 <futhin> don't be afraid of dup swap drop, etc
19:17:36 <futhin> there's some adjustments
19:17:46 <futhin> in thinking
19:18:04 <futhin> forth code looks ugly until you understand most of it instinctively :)
19:19:18 <Etaoin> dang it
19:19:27 <futhin> : n dup ; doesn't work?
19:19:28 <Etaoin> xmms is segfaulting for no reason
19:19:40 <futhin> xmms ?
19:19:47 <Etaoin> an mp3 player
19:24:01 <futhin> ah
19:26:49 <Etaoin> I have a feeling something's messed up
19:27:09 <futhin> well
19:27:26 <futhin> the only part that seems weird is the  n 1 + 2 ?DO
19:27:37 <Etaoin> I mean with my computer
19:27:39 <futhin> do you know why a 2 is there?
19:27:40 <futhin> oh
19:33:08 <Etaoin> oh, well. see you later.
19:33:19 --- quit: Etaoin ("raise MappingError, "arg, somebody folded the maps instead of rolling them"")
20:52:32 --- join: Soap` (~flop@210-86-47-50.dialup.xtra.co.nz) joined #forth
20:58:24 --- quit: futhin ()
21:11:06 --- join: futhin (~thin@h24-64-175-123.cg.shawcable.net) joined #forth
22:53:57 --- quit: futhin ("goodnight")
23:59:59 --- log: ended forth/02.02.26