00:00:00 --- log: started forth/01.11.16
00:07:06 --- join: MrZzzz (~mrreach@209.181.43.190) joined #forth
00:07:12 --- nick: MrZzzz -> MrReach
00:07:37 --- mode: ChanServ set mode: +o MrReach
04:48:17 --- quit: MrReach (varley.openprojects.net irc.openprojects.net)
04:49:04 --- join: MrReach (~mrreach@209.181.43.190) joined #forth
04:49:04 --- mode: niven.openprojects.net set mode: +o MrReach
06:21:08 --- join: edrx (edrx@200.240.18.84) joined #forth
06:48:24 --- quit: MrReach (varley.openprojects.net irc.openprojects.net)
06:51:50 --- join: MrReach (~mrreach@209.181.43.190) joined #forth
06:51:50 --- mode: niven.openprojects.net set mode: +o MrReach
06:54:37 --- quit: edrx (varley.openprojects.net irc.openprojects.net)
06:56:55 --- join: edrx (edrx@200.240.18.84) joined #forth
07:15:33 --- quit: edrx ("[x]chat")
09:10:53 --- join: edrx (edrx@copacabana-ttyS24.inx.com.br) joined #forth
09:55:17 --- quit: edrx (varley.openprojects.net irc.openprojects.net)
09:57:48 --- join: edrx (edrx@copacabana-ttyS24.inx.com.br) joined #forth
10:53:12 <MrReach> *YAWN*    ... hiya!
10:53:36 <MrReach> edrx: was it you that was talking about fast-dispatch objects??
11:18:40 <edrx> MrReach: no, it wasn't me
11:18:48 <MrReach> ok
11:21:57 <edrx> btw, I have just rewritten my minimal Lua-based Forth... http://www.mat.puc-rio.br/~edrx/miniforth/mf1.lua is all its code, except for the implementation of regex and regmatch (in C, and quite standard) and the demo - http://www.mat.puc-rio.br/~edrx/miniforth/yoneda.mflua ...
11:22:42 * MrReach goes and browses, since he's still drinking his morning coffee
11:23:27 <edrx> is it really morning there, or just because you've just waken up?
11:23:42 <MrReach> just me, i tend to be a night owl
11:23:49 <MrReach> it's 11:23 here
11:24:31 <edrx> me too
11:24:46 <edrx> I've been going to about around 6:00am most nights
11:24:59 * MrReach nods
11:25:33 <MrReach> I take it ...
11:25:45 <MrReach> that the last part of the second URL is an example application?
11:25:52 <edrx> yes
11:25:59 <MrReach> no, still lua defs, I guess
11:26:37 <edrx> which part?
11:27:10 <edrx> each ::lua .. ;; line defines a new function in the dictionary, but the ... is lua code
11:27:21 * MrReach nods.
11:27:30 <edrx> the %: lines are comments
11:27:41 <MrReach> does any of this ever start to LOOK like for code?
11:27:46 <MrReach> yes, I remember
11:28:39 <edrx> not yet, because I haven't created yet any mechanism for whatever could play the role of an inner interpreter, even if it is going to be a macro facility
11:28:52 <MrReach> ok
11:30:22 <edrx> it seems that I'm the only one who decided that the essence of forth is "parse one word, then execute it, then repeat" instead of something based in interpreting bytecodes
11:30:41 <MrReach> heh, I guess so
11:31:11 <MrReach> one of those words to execute is colon, of course
11:31:23 <edrx> yes
11:31:24 <MrReach> which changes the parsing behavior somewhat
11:32:36 <edrx> yes, and we could even code that in a way that the "parser behaviour" is represented by a very simple function, and at some point it is replaced by another one with a more complex behaviour... like acting different depending on STATE
11:33:31 <MrReach> yes, and getting immediate words to behave properly
11:33:38 <edrx> yup
11:33:51 <MrReach> Pygmy never had a STATE variable
11:34:00 <edrx> at the beginning eveything is immediate...
11:34:22 <MrReach> the text interpreter was one loop ... while the colon compiler was another loop altogether
11:34:28 <edrx> really? how? ":" would parse everything by itself up to ] or ;?
11:34:50 <edrx> that seems pretty
11:35:08 <MrReach> the system stayed in the colon word until the def was done
11:35:29 <edrx> hm
11:35:41 <MrReach> right now, in most ANS systems, colon simply sets state and exits
11:35:57 <MrReach> I thought it more elegant the pygmy way
11:36:31 <MrReach> heh, until it came to pygmy's bizarre way of using vocabularies
11:36:40 <edrx> I'm trying to devise a way where there can be as many of those loops one likes, and to leave them to enter another (without nesting) one just has to return in some special way, tell where to enter next
11:36:45 <edrx> how was it?
11:37:45 <MrReach> there was only two vocabs, if a words was in one vocab, it was immediate, otherwise it was a normal word
11:38:18 <edrx> what was the search order? :)
11:38:19 <MrReach> immediate words could not be executed interactively unless there was specifically a non-immediate version of it
11:38:42 <MrReach> heh, search for immediate word, then normal word, in colon
11:38:59 <MrReach> while interpreting from keyboard, only normal words were searched
11:39:13 <edrx> aah, so : also activated the search in the second vocabulary...
11:39:19 <MrReach> yes
11:39:42 --- mode: MrReach set mode: +o edrx
11:39:48 <edrx> that's not bad - at least it is clear
11:40:13 <edrx> the ANS way with all those semantics for a word is very hard to understand
11:40:15 <MrReach> it was an odd little beast ... originally based on one of Moore's creations ... ported to x86 DOS
11:40:38 <edrx> do you know if there is a *nix version of it?
11:40:56 <MrReach> I heard somewhere that someone also ported the same forth to a microcontroller and it's currently controlling a deep-space satellite
11:41:05 <edrx> I think I have looked at its code and found it fascinationg, but couldn't ever run it
11:41:21 <MrReach> it should run under DOSEMU
11:41:45 <MrReach> especially the newer versions, as they don't do direct screen srites anymore
11:41:57 <MrReach> no, never seen a *nix version
11:42:02 <MrReach> (it metacompiles)
11:42:43 <edrx> some days ago I was discussing with someone (don't remember his name or channel) who was saying that using Forth for spaceships only did make sense when memory was at premium
11:42:59 <edrx> he was defending lisp on the ground that it doesn't crash
11:43:09 <MrReach> heh
11:43:46 <MrReach> maybe, but it can sure bork
11:44:01 <edrx> but it was pretty obvious that the Forth system in satellites and such had tricks for never crashing, but most people (includind me) don't know how
11:44:19 <MrReach> forth progs also tend to have more rigoruous testing
11:44:36 * edrx dicts bork and finds nothing
11:44:53 --- join: Speuler (akhandel@195.30.184.27) joined #forth
11:44:54 <MrReach> also, it's hard to write very complex code in forth ... so simplicity tends to be the banner flag
11:45:03 <edrx> sure, because it is so easier to get a grasp on the whole system
11:45:06 <MrReach> greetings, Speuler!
11:45:12 <edrx> hi Speuler
11:45:12 <Speuler> good day to you
11:45:15 <Speuler> hi all
11:45:18 <edrx> g'day
11:45:43 <Speuler> i won a major struggle with nasm yesterday
11:45:55 <Speuler> glad about
11:46:01 <edrx> details?
11:46:04 <MrReach> congrats ... did you discover the error in the preprocessor?
11:46:29 --- mode: MrReach set mode: +o Speuler
11:46:39 <Speuler> was bluddy difficult to get headers of a forth interpreter, written with nasm, into seperate space, consecutively
11:46:52 <Speuler> thank you mrrreach
11:47:08 <Speuler> i think i tricked it out
11:47:17 <MrReach> oh? I shouldn't think it would be ... although you'll have to put .section directive in me macros
11:47:27 <Speuler> i did
11:47:41 <Speuler> thought too that it would be easy
11:47:42 <MrReach> what made it difficult?
11:48:02 <Speuler> new sections bombed on me
11:48:17 <MrReach> oh? how so?
11:48:19 <Speuler> and when they didn't i couldn't find the data which was supposed to be there
11:48:45 <MrReach> heh, everything fine, except data not in the binary?
11:48:48 <Speuler> so now i compile headers in the .data section, in a different range than other data
11:49:03 <Speuler> now "words" almost works
11:49:12 <Speuler> almost means, some headers
11:49:55 <Speuler> another struggle i had, with the diskless x workstation, has been resolved too
11:50:02 <MrReach> I've been digging into the guts of WinPE files to learn how to make a Forth linker ... quite versatile, actually
11:50:03 <Speuler> bluddy pxe bootrom
11:50:14 <Speuler> boots now
11:50:17 <MrReach> heh, needed an upgrade?
11:50:22 <Speuler> nope
11:50:32 <Speuler> managed to do with what i had
11:50:49 <Speuler> took a while to find it though
11:50:56 <Speuler> pxelinux was the key
11:51:01 * MrReach nods.
11:51:11 <MrReach> some obscure software switch?
11:51:31 <Speuler> no tool to convert boot images into pxe compatible format
11:51:45 <edrx> I need to go to the univ to print some articles for the weekend
11:51:54 <MrReach> ok, edrx, be well
11:52:04 <edrx> see ya, take care you two
11:52:07 <MrReach> yo must live right next door to it
11:52:10 <Speuler> i found some netboot rom in pxeformat, which i could boot to boot itself :)
11:52:16 <MrReach> I sued to ... miss those days
11:52:20 <MrReach> used to
11:52:31 <Speuler> kind of metaboot
11:52:34 <MrReach> always interesting people around to talk to
11:52:47 <Speuler> leaving us already ?
11:52:57 <edrx> MrReach: not exactly, 20 mins from it...
11:52:59 <MrReach> not me, but edrx is
11:53:24 <MrReach> oh, ok, I used to live 5 mins walk from Sacramento State Univ, in California
11:54:14 <MrReach> Speuler: sounds like a complicated mess ... chicken and egg sort of thing
11:54:39 <Speuler> pxelinux is quite allright
11:54:56 <edrx> Speuler: yes, I am somewhat interested in nasm things (I used nasm to compile the bytecodes for one of my forth prototypes) but I want to print ~300 pages in articles and spiral-bind them later
11:55:05 <edrx> so
11:55:08 <edrx> later
11:55:09 --- part: edrx left #forth
11:55:23 <Speuler> gives the possibility to do pass kernel pars per client w/o the need to change the dhcp config
11:55:47 <MrReach> ah! pretty nifty!
11:56:12 <Speuler> i.e. no restart of dhcpd config necessary, just edit the pxelinux config file
11:56:30 <Speuler> and next time the ws boots, it runs with the new config
11:56:49 <MrReach> I should think that editing DHCP config for machine specifics shouldn't be too difficult
11:57:17 <MrReach> dhcp sends the kernel to boot with?
11:57:37 <Speuler> not difficult, but dhcpd doesn't use a changed config w/o restarting or signalling it
11:57:46 <MrReach> (that's a pretty complex ethernet controller, when you think about it)
11:57:51 <Speuler> with pxelinux, no need for that
11:58:00 <Speuler> no
11:58:15 <Speuler> dhcpd sends the pxelinux boot loader
11:58:22 <MrReach> ah! ok
11:58:31 <Speuler> that one downloads the boot image
11:58:39 <Speuler> it is a bootstrap
11:58:51 <MrReach> so the machine is expected to have a HD?
11:58:55 <Speuler> looks up a list of config files.
11:58:58 <Speuler> no
11:59:04 <Speuler> just bare motherboard
11:59:10 <Speuler> all on board
11:59:15 <MrReach> pxebootloader in ROM?
11:59:18 <Speuler> yes
11:59:53 <MrReach> gosh, lots of parts in computers nowadays ... thinking fondly of C64s   @:^>
12:01:06 <Speuler> if the ws get ipaddress 192.168.1.10, it tries to read the config file for ascii respresentation of 192.168.1.10, then 192.168.1, then 192.168, then 192, and finally default
12:01:15 <MrReach> so what was the prob with NASM?
12:01:31 <Speuler> i couldn't find the headers
12:01:50 <MrReach> why didn't nasm create the extra segments?
12:02:06 <Speuler> and it seems to be very difficult to put data into decending addresses
12:02:29 <MrReach> I bet THAT's true
12:02:43 <MrReach> heh, that's not the way assemblers work, generall
12:02:44 <MrReach> y
12:02:46 <Speuler> like, first headers on highest address, next header below etc
12:03:01 <Speuler> about all of them i could org to the desired address
12:03:01 <MrReach> why does it make a difference in your system?
12:03:18 <Speuler> and have a macro do the calculation, and restoring to the previous address
12:03:26 <Speuler> not with nasm
12:03:48 <Speuler> because my headers will grow downwards
12:03:54 <MrReach> why would you be doing that ?
12:03:57 <MrReach> oh?
12:04:16 <MrReach> why? what advantage does that offer?
12:04:26 <Speuler> db n,"lastheader",n,"previousheader" 
12:04:44 <Speuler> i can easily run through headers, not requiring a link field
12:04:52 <Speuler> and search last header first
12:05:25 <Speuler> actually, there's a pointer to xt in the header too
12:05:35 <Speuler> but constant size, easy to skip
12:06:02 <Speuler> with that structure i am quite flexible when rearranging headers
12:06:13 <Speuler> or casting them into a different format
12:06:36 <MrReach> heh, that 'n' *IS* a link field
12:06:49 <MrReach> they're just reltive links, rather than absolute ones
12:07:21 <MrReach> ok, so using a doubly linked list?
12:07:30 <MrReach> that's a bit different
12:07:33 <Speuler> no links
12:08:03 <Speuler> just   cell+ count 2dup type +    would loop through headers
12:08:12 <MrReach> 'link' = some field used to find the previous or next occurance
12:08:17 <Speuler> no link
12:08:26 <Speuler> the header count byte is the "link"
12:08:34 * MrReach nods.
12:08:49 <Speuler> when moving headers around, one would need to uzpdate links
12:08:55 <Speuler> or they would have to be relative
12:09:04 <Speuler> a count byte is almost a relative link
12:09:09 <Speuler> so i reuse it
12:09:25 <Speuler> byte behind a header is start of next header
12:09:47 <MrReach> oh, ok
12:10:02 <MrReach> that presumes that they will always be flush up against each other
12:10:03 <Speuler> throwing away any header would just need to move the last headers up
12:10:18 <Speuler> so i can relocate headers easily
12:11:18 <Speuler> as this header representation can be used, but can be cast into different format too, i see it as the storage format
12:11:29 <Speuler> saves me the link fields
12:11:32 <MrReach> actually ...
12:11:41 <MrReach> if you want to do that type of thing ...
12:12:02 <MrReach> it might be interesting to put either/both the header and the code into allocated memory
12:12:09 <Speuler> exactly
12:12:14 <Speuler> that's one of the reasons
12:12:14 <MrReach> so that you can delete and move around w/o effort
12:12:25 <Speuler> code, i'm not sure about
12:12:31 <Speuler> transient code, yes
12:12:33 <Speuler> probably
12:12:40 <Speuler> but code has more problems
12:12:51 <Speuler> as words may refer to code addresses
12:13:02 <Speuler> when moving around code, those references would have to be changed
12:13:10 <Speuler> that's a thing i wouldn't like to do
12:13:10 <MrReach> hard to say ... I'm still expecting someone to write a forth where redefining a word changes all previous occurances of its behavior
12:13:42 <MrReach> not me, either, but so many languages work that way
12:13:43 <Speuler> make an error, and your system stops working ...
12:14:07 <Speuler> : dup   nip  ;    -> crash
12:14:39 <Speuler> not very friendly for beginners
12:17:22 <Speuler> what would be the advantage of such a thing ?
12:17:45 <Speuler> maybe you could flag words as persistent
12:17:57 <Speuler> to keep them from being changed
12:18:33 <Speuler> or are you writing a book about 1001 interesting ways to crash a computer ?
12:18:50 <Speuler> try   0 dup base ! .
12:19:10 <Speuler> or, for that matter 1 dup base ! .
12:19:35 <Speuler> (actually, 1 base ! 2 .  would be better)
12:20:07 <MrReach> heh
12:20:24 <Speuler> pulling your teeth .. eeh toes of course
12:20:38 <MrReach> in most cases, people would not be redefining system words
12:20:55 <Speuler> what is a system word exactly ?
12:21:02 <MrReach> or, if they were, it would be to expand already existing functionality
12:21:34 <MrReach> a word that deals with input, interpreting, or output
12:22:03 <Speuler> maybe a vocabulay which redefines previous occurances, and in other vocs only the semantics for future use are changed
12:22:14 <MrReach> that might work
12:22:31 <Speuler> dup  is neither input, output, or interpreting
12:22:33 <MrReach> I'm not saying it hsould be done ... only that I expect someone to do it
12:23:03 <Speuler> or are all stack words system words ?
12:23:11 <MrReach> couldn't say
12:23:28 <Speuler> you'd open a pandora's box there
12:23:45 <MrReach> smalltalk, lisp, python, tcl all allow redefining already existing procs
12:24:14 <MrReach> I have found it useful in those languages in the past ... but not sure of its relevance to forth
12:25:14 <Speuler> maybe instant recompilation would do the trick too
12:25:27 <MrReach> what is that?
12:27:32 <MrReach> I'm thinking more along the lines of how to allow the user to read/write binary libraries to disk
12:27:44 <MrReach> (in my theoretical ponderings)
12:28:24 <MrReach> the redefinition of words was just something that popped up as a "this might be interesting someday"
12:34:34 <Speuler> brb
12:34:55 <MrReach> ok
12:41:23 <Speuler> i'll ove to another machine in a moment.
12:41:35 <MrReach> as you please
12:41:39 <Speuler> to the diskless
12:41:54 <Speuler> the server (machine next to it) becomes available in a moment
12:42:03 <MrReach> heh, ok
12:42:05 <Speuler> ( i did a kill -STOP netscape :)
12:42:15 <Speuler> people will be relocated to a better machine :)
12:42:40 <Speuler> see you later
12:42:46 --- quit: Speuler ()
12:49:04 --- join: trimesch (trimesch@passionsfrucht.icafe.spacenet.de) joined #forth
12:49:18 <trimesch> hi
12:50:06 --- nick: trimesch -> Speuler
12:53:23 <MrReach> hihi
12:53:28 <Speuler> hi again
12:53:43 <MrReach> I'm thinking more along the lines of how to allow the user to read/write binary libraries to disk
12:53:45 <MrReach> (in my theoretical ponderings)
12:53:45 <Speuler> i'm just sitting behind the diskless machine now
12:54:05 <Speuler> not easy as this is quite os dependent
12:54:14 <Speuler> or one would need a loader program
12:54:27 <Speuler> for mor or less platform independent binaries
12:55:02 <Speuler> of course also a loader for platform specific images may work
12:55:14 <MrReach> Win32 and Linux ELF formats are nearly identical
12:55:32 <MrReach> the prob isn't in getting it loaded
12:55:40 <MrReach> it's in getting the pointers right
12:55:54 <Speuler> i assumed loading means linking too
12:56:00 <MrReach> ah! ok
12:56:18 --- mode: MrReach set mode: +o Speuler
12:56:23 <Speuler> thank you
12:56:40 <MrReach> for example, moving the kernel into a .DLL or a .so is pretty trivial
12:56:40 <Speuler> how does sh3 asm look like ?
12:56:55 <MrReach> but, in doing so, the words become frozen
12:56:59 <Speuler> any cpu which resembles the sh3 ?
12:57:13 <Speuler> the kernel may be "frozen"
12:57:21 <MrReach> hmmm ... it's pretty much like any other asm
12:57:42 <MrReach> because it's risc, though, the operand size is more implicit
12:57:42 <Speuler> as soon the system sits in mem, one is free to rearrange it
12:58:01 <Speuler> i know very little about the sh3
12:58:08 <MrReach> beg parden? say that again?
12:58:34 <MrReach> rearrange a .so file?
12:58:35 <Speuler> hitachi said that they see the sa110 as the cpu they strive to be comparable with
12:58:48 <MrReach> oh, ok
12:58:50 <Speuler> the reference
12:59:15 <Speuler> acknowledging the lead
12:59:25 <Speuler> inofficially of course
12:59:46 <Speuler> no, not a file. if it is loaded into mem, it is not a file anymore
12:59:56 <Speuler> but you can write a new image to file
12:59:57 <MrReach> heh, well I'll say with some confidence that the sh3 is *WAY* easier to write a dis/assembler for than the Pentium
13:00:05 <Speuler> no doubt
13:00:30 <Speuler> it may be easier to program too
13:00:38 <MrReach> the sh3 is a bit funky with the delayed branch and jump calls, but it's workable
13:01:17 <MrReach> I have yet to sit down and translate the various addressing modes into a forth sytax
13:02:01 <MrReach> but they look pretty much addressing modes on other processors, if not a bit more limited
13:02:14 <Speuler> that's what strikes me on the h8
13:02:41 <MrReach> that's there's nothing particularly unusual?
13:02:43 <Speuler> i wouldn't mind if it would have a few more powerful addressing modes
13:02:56 <MrReach> is h8 risc?
13:02:57 <Speuler> it is risc like too
13:03:02 <MrReach> heh
13:03:15 <MrReach> that is the trademark of risc machines, though
13:03:21 <Speuler> focus on registers
13:03:27 <Speuler> no memory operations
13:03:33 * MrReach nods.
13:03:41 <Speuler> except move, and bit ops
13:03:55 <Speuler> setting a single bit in memory is easy
13:03:56 <MrReach> "feel lucky you can write something to memory at all" ... heh
13:04:19 <Speuler> bset #bitnumber, @register
13:04:43 <MrReach> sh3 has the same extention ... most ops require move to register first, but bit ops will work directly w/ memory
13:04:48 <Speuler> it has autoincrement fetch and autodecrement store, though
13:04:57 <MrReach> so does the sh3
13:05:15 <MrReach> with variable increments, depending on operand size
13:05:17 <Speuler> 7 general purpose registers ?
13:05:24 <Speuler> +1 as stack pointer ?
13:05:30 <MrReach> also, several base+index modes
13:05:42 <MrReach> erf ...
13:05:46 <MrReach> yes and no
13:05:56 <MrReach> 15 + 1 stack
13:06:05 <Speuler> 32 bit i suppose
13:06:10 <MrReach> the lower 8 are banked with shadow registers
13:06:17 <MrReach> for supervisor mode
13:06:20 <MrReach> yes
13:06:52 <MrReach> whole bunch of control registers
13:07:31 <MrReach> the sh3 has four, I think
13:07:47 <MrReach> the sh3e adds IEEE floating point support
13:08:07 <Speuler> register halves, lower half divided into 8 bit regs ?
13:08:10 <MrReach> and the sh3-DSP adds all kinds of wierd instructions I don't really understand
13:08:27 <MrReach> no
13:08:37 <Speuler> different then
13:08:43 <MrReach> you have either 8bits, 16bits, or 32bits
13:08:58 <MrReach> not an "upper 16 bits" ... etc
13:09:10 <Speuler> h8 reg is   ERn (32bit),  En  Rn  (2x16 bit)  RnH RnL  (2x8 bit)
13:09:28 <MrReach> however ... the is sign and zero extention from any one to another
13:09:36 <Speuler> organized as    En RnH RnL   
13:10:02 <MrReach> and logical left and right shifts to work with bytes elsewhere in the word
13:10:53 <Speuler> on H8 depends on whether you use shift on RnL Rn or ERn
13:11:03 <Speuler> but some strange exceptions
13:11:06 <Speuler> such as
13:11:26 <Speuler> add.w #num, reg16     is ok
13:11:34 <Speuler> add.l #num, reg32     is ok too
13:11:56 <MrReach> another thing I found interesting ...
13:12:06 <Speuler> but add.b #num, reg8     doesn't exist
13:12:09 <MrReach> is that integer divisions are done interavely
13:12:30 <MrReach> iterively?
13:12:42 <Speuler> division steps ?
13:12:51 <MrReach> yes
13:13:24 <Speuler> good
13:13:29 <MrReach> quite different than on x86, where you load the divisor and dividend into registers, issue the DIV command and the answer appears magically
13:14:14 <MrReach> but I can see where there is an advantage ... you only need to interate for the precision you need
13:14:24 <MrReach> iterate, even
13:15:42 <MrReach> so what was your question about the sh3??
13:17:11 <MrReach> IIRC your question was about the assembly, rather than the hardware itself
13:19:59 <MrReach> incidently, I think it's a bit overkill for a forth engine
13:20:22 <MrReach> forth primitives seldom need more than two registers ... so what do do with the rest?
13:21:20 <MrReach> WinCE allocates about 1/2 of them ... not sure about EPOC or PalmOS
13:23:27 <MrReach> hello?
13:40:38 --- quit: Speuler (Remote closed the connection)
14:08:09 --- join: tcn (tcn@bespin.org) joined #forth
14:15:54 --- quit: tcn ("[BX] I'm off like a prom dress...")
14:30:00 --- nick: MrReach -> MrGone
14:39:20 --- join: Speuler (l@passionsfrucht.icafe.spacenet.de) joined #forth
14:39:26 <Speuler> hi again
14:43:22 <MrGone> hi
14:43:26 --- nick: MrGone -> MrReach
14:43:31 <MrReach> what happened to you?
14:43:43 --- mode: MrReach set mode: +o Speuler
14:44:48 <Speuler> somebody needed to demonstrate the netboot
14:45:10 <MrReach> ok ...
14:45:11 <Speuler> and i did some talking since
14:45:17 <Speuler> planning
14:45:21 <MrReach> so what was your question about the sh3??
14:45:23 <Speuler> next steps
14:45:24 <MrReach> IIRC your question was about the assembly, rather than the hardware itself
14:45:27 <MrReach> incidently, I think it's a bit overkill for a forth engine
14:45:31 <MrReach> forth primitives seldom need more than two registers ... so what do do with the rest?
14:45:36 <MrReach> WinCE allocates about 1/2 of them ... not sure about EPOC or PalmOS
14:45:40 <Speuler> h8 is not ideal for forth engines
14:45:58 <Speuler> but there are worse ones
14:46:03 <Speuler> no jmp indirect
14:46:11 <Speuler> oh well it has, but a limited one
14:46:31 <MrReach> sh3 has jump to register value, for sure
14:46:32 <Speuler> only jump @address:8bit
14:46:42 <Speuler> @@adr:8
14:46:53 <Speuler> so does h8
14:46:57 <MrReach> also, sh3 call puts return value in register, have to manually load it onto stack
14:47:12 <Speuler> return value 
14:47:13 <Speuler> ?
14:47:25 <MrReach> generally ...
14:47:27 <Speuler> return address ?
14:47:47 <MrReach> CALL adr sets the PC to adr and puts previous contents of PC on return stack
14:47:49 <Speuler> like the link register on arm
14:47:50 <MrReach> yes
14:48:23 <MrReach> at lest SOME of the CALL instructions on sh3 put return adr in register
14:48:33 <MrReach> might be version to push, but not sure
14:49:09 <Speuler> direct threaded may be more efficient
14:49:12 <MrReach> are you extremely fond of the contional assemblers?
14:49:27 <MrReach> conditional assemblers?
14:49:28 <Speuler> define: "extermely"
14:49:36 <Speuler> extremely
14:50:11 <MrReach> heh, do you get angry/pissy if the IF ... ELSE ... THEN , BEGIN ... UNTIL are not in the assembler?
14:50:21 <Speuler> no not really
14:50:44 <Speuler> i prefer powerful macro capabilities to conditional asm
14:51:00 <MrReach> I ask because my preference is for "label JMP" or "label BNE"
14:51:58 <Speuler> i quite follow you there
14:52:08 <Speuler> .. don't ...
14:52:50 <MrReach> ok, many Forth assemblers use "structured conditionals" ... IF etc that don't use labels as targets
14:53:07 <Speuler> my understanding of conditional assembly is that the decision is done at assembly time
14:53:32 <Speuler> oh, i get you
14:53:49 <MrReach> I prefer labels
14:53:59 <Speuler> you mean, using hi-level control flow constructs which assemble to conditional branches
14:54:08 <MrReach> for the most part, the two systems are mutually exclusive
14:54:13 <MrReach> yes, that is what I mean
14:54:22 <Speuler> you can do that with macros
14:54:29 <Speuler> if they're powerful enough
14:54:36 <MrReach> heh, I'm not asking how to do it
14:54:49 <MrReach> I'm asking if you are fond of that type of source code
14:54:55 <Speuler> i mean, if one / me requires it, one / me can add that myself
14:55:09 <Speuler> no need to be integrated feature
14:55:34 <Speuler> it can help to write cleaner code
14:55:34 <MrReach> the only probs I'm having atm are how to implement forward branches
14:55:47 <MrReach> i.e. a branch to a label that has yet to be defined
14:55:56 <Speuler> instead of just conditionally branching wherever you like
14:56:18 <MrReach> yes, tends to encourage proper structure
14:56:52 <Speuler> if the branch offset is never shorter than an address reference, you can link all forward refs, using the branch address as link field
14:57:11 <Speuler> as soon one resolves, you replace the link against the destination
14:57:26 <Speuler> and remove the branch from the linked list
14:57:26 <MrReach> yes, but ...
14:57:47 <Speuler> problems with 8 bit offsets
14:57:57 <MrReach> suppose I write "<label> JMP" ... and <label> has yet to be defined
14:58:00 <Speuler> build a table
14:58:29 <MrReach> now I could set it up so that an unknown word added a label to the table
14:58:34 <Speuler> with hi-level forth, i implemented fwd refs this way:
14:58:42 <MrReach> but there ALL unknown words would create labels
14:58:49 <Speuler> if a word can't be found, a header in the voc "forward" is created
14:59:16 <Speuler> and the address ref in the word, unresolved, is added to a linked list of unresolved.
14:59:35 <Speuler> which starts at the word in the forward vocabulary
14:59:55 <Speuler> if a word is defined, it is checked whether it exists already in the forward voc
15:00:20 <Speuler> in that case, after creation of the word, the linked list is followed, and all references replaced
15:00:34 <Speuler> then the header in the forward voc is deleted
15:00:43 <MrReach> understood
15:01:10 <Speuler> the header structure proposed with toy forth helps
15:01:11 <MrReach> the disadvantage is that misspelled words that should cause a compiler error don't anymore
15:01:33 <Speuler> (as i can delete any header, w/o affecting others)
15:01:58 <Speuler> i have a word "unresolved" which shows the words in the forward voc
15:02:10 <Speuler> and the prompt changes if there's any word in that voc
15:02:30 <Speuler> ctrl-u executes unresolved too
15:03:06 <Speuler> they shouldn't cause compiler error, as they aren't misspelled, but await future definition
15:03:10 <MrReach> maybe I should change my coding preference
15:03:30 <MrReach> even if I don't think it's as easy to read
15:03:46 <Speuler> forgetting words is dangerous with forward refs
15:04:20 <MrReach> I'm talking about inside a CODE definition
15:04:22 <Speuler> but i'm not extermely fond of forget anyway
15:04:33 <Speuler> yes, thats different
15:04:41 <Speuler> as branch offsets can be short
15:04:51 <MrReach> heh, you either forget the whole thing, or you don't
15:05:02 <Speuler> org $-100
15:05:16 <MrReach> if you write one code word that branches into another code word, then you SHOULD get shot in the foot
15:08:10 <MrReach> (and have your hands cut off, just because    @:^)
15:09:02 <Speuler> tail recursion can be nice
15:11:47 <MrReach> heh, ok
15:12:19 <MrReach> what is your preference for specifying branch targets?
15:14:01 <MrReach> god, a Pentium dis/assembler is a complicated damn beast!!
15:17:30 <Speuler> i like to give a label. i am done with line numbers
15:17:46 <MrReach> HAHAHA!!!!
15:18:00 <Speuler> but in early phases of dev, i sometimes calculate branch offsets by hand
15:18:12 <Speuler> like    branch, -24
15:18:26 <Speuler> that's what caused my string lit bug
15:18:38 * MrReach nods.
15:18:55 <Speuler> as the string got longer than 3 chars, the branch offset for the branch back was wrong...
15:19:12 <Speuler> (trying to output string in a loop :)
15:19:39 <Speuler> string lit itself worked just fine
15:19:48 <Speuler> was looking at the wrong spot then
15:20:19 <MrReach> oh, hey ...
15:20:41 <MrReach> have you come across any auto-doc packages for Forth? are there any you're fond of?
15:22:07 <Speuler> nope, nope, and i don't know
15:22:18 <Speuler> oh, just two questions :)
15:22:22 <MrReach> want to discuss the idea?
15:22:25 <MrReach> heh
15:23:34 <MrReach> I was thinking of one that only redefined the word '\' so that it accepted optional commands ... any opinion? ... want an example?
15:25:08 <MrReach> you seem quite distracted
15:30:27 <Speuler> ehm yes
15:30:42 * MrReach grins.
15:31:08 <Speuler>  armenian and russian, they are
15:31:26 <MrReach> what? female?
15:31:35 <MrReach> coders?
15:31:43 <MrReach> drunken idiots?
15:32:31 <Speuler> ladies
15:32:53 <MrReach> sounds like fun ... more fun than forth coding   @:^>
15:32:59 * MrReach waves.
15:34:05 <Speuler> they distrust computers
15:34:14 <MrReach> why?
15:34:21 <Speuler> might be government controlled
15:34:23 <MrReach> tell them not to type anything sensitive, then
15:34:46 <MrReach> best to assume that they *ARE* govt controlled, and treat them as such
15:35:00 <MrReach> still possible to be useful and fun
15:35:32 <Speuler> one prefers vodka to computers
15:36:08 <MrReach> one of the best uses, accounting, is pretty uninteresting to govts ... they really don't care how much toilet paper you buy in a year or how many movies you go see
15:36:17 <MrReach> I agree
15:36:41 <MrReach> (about the vodka, that is ... my favorite pastime is to get drunk around a bonfire with good friends)
15:37:10 <MrReach> however, vodka and computers perform two different tasts ... and they don't interchange so easily
15:37:17 <MrReach> tasks
15:37:23 --- join: [Atlas] (fare@samaris.tunes.org) joined #forth
15:37:32 <MrReach> greetings, [Atlas]
15:37:42 <[Atlas]> Hi, MrReach!
15:37:51 <[Atlas]> wassup?
15:38:26 <MrReach> ack! you're fare! ... I thought for a minute you were one of the females that's chatting up Speuler at his internet cafe'
15:38:32 <MrReach> not much
15:38:40 <[Atlas]> sorry about it :(
15:39:02 <MrReach> I'm waiting for it to quit raining so I can go change the alternatore in the motorhome
15:39:04 <[Atlas]> Atlas isn't a female name
15:39:13 <[Atlas]> motorhome?
15:39:17 <[Atlas]> you live in a motorhome?
15:39:25 <MrReach> nope, but they are Russian and Armenian ... who knows what names they would choose for themselves
15:39:35 <MrReach> no, but I've got one
15:40:04 <MrReach> I'll be selling it this spring, have replaced it with a much larger and new 5th wheel
15:47:04 --- nick: [Atlas] -> Fare
15:49:45 <Fare> what forth hacking are you up to?
15:50:04 <MrReach> not much, right now
15:50:15 <MrReach> was thinking, though
15:50:36 <MrReach> about a multiplatorm forth that would run identically on all PCs and PDA
15:50:36 <MrReach> s
15:51:00 <Fare> low-level or high-level?
15:51:12 <Fare> a high-level thing like the HP RPL would be great
15:51:16 <MrReach> beg parden?
15:51:29 <Fare> (isn't there already some similar project aroudn?)
15:51:33 <MrReach> erm ... it's a Forth system, so both
15:51:48 <MrReach> not that I'm aware of ... Quartus seems to be the closest
15:51:58 <MrReach> but it's for PalmOS only
15:52:24 <MrReach> the forth would use whatever OS was native, if that's what you meant
15:52:45 <Fare> no, what I mean is, e.g. will it have a GC?
15:52:58 <MrReach> so it would run on Win32, Linux, MacOS, WinCE, PalmOS, and EPOC
15:53:16 <MrReach> GC = garbage collector?
15:53:49 <Fare> I think having a GC is what distinguishes high-level from low-level -- i.e. are you working with a graph of objects, or with a numbered address space.
15:53:53 <MrReach> and on x86, 68000, PPC, ARM, and SH3 processors
15:54:16 <MrReach> what is GC?
15:55:17 <Fare> garbage collection indeed
15:55:26 <Fare> I was first introduced to it by the RPL
15:55:35 <MrReach> a graph of objects would be the prefered method of writing for such forth ... but the low level stuff will ahve to be concerned about addresses
15:56:17 <MrReach> all of the OSs mentioned, I believe, use GC algs internally for allocate
15:56:52 <Fare> one thing is to have a special non-GC mode underneath -- another thing is to encourage people to use it for normal programming or not
15:56:56 <MrReach> GC means something different to Forth than it does other languages
15:57:22 <Fare> uh?
15:57:26 <MrReach> because Forth runs so close to the iron, pieces of mem are obvious to the programmer
15:57:32 <Fare> what does it mean there?
15:57:45 <Fare> yeah, standard forth is pretty low-level
15:57:46 <MrReach> I meant the *CONCEPT* of GC
15:58:09 <Fare> the HP RPL had both a user-visible high-level GCed forth, and a low-level system forth w/o GC.
15:58:32 <Fare> actually, it had several layers of forth
15:58:41 <MrReach> GC is most useful when there is a myriad of objects that can be shuffled around invisibly in the background
15:58:54 <Fare> yeah
15:59:13 <MrReach> which isn't really how Forth works at all
15:59:32 <Fare> well, there are several interesting things in the FORTH concept
15:59:47 <MrReach> Anton Ertl wrote some VERY good GC mem allocation algorythms
15:59:56 <MrReach> but they are seldom useful
16:01:34 <MrReach> what's interesting?
16:02:36 <MrReach> Speuler: if they distrust computers so much, why are they sitting in an internet cafe'? (drinking vodka?)
16:06:41 <MrReach> (more likely, their statements were conversation starters)
16:08:29 <MrReach> aargh! I forgot how low-level the glibc socket functions are
16:09:29 --- quit: Speuler (Ping timeout: 181 seconds)
16:13:13 --- nick: Fare -> Atlas_away
16:33:08 --- join: qless (~qless@clgr000977.hs.telusplanet.net) joined #forth
16:56:04 <qless> ding dong!
17:01:11 --- quit: MrReach (Ping timeout: 181 seconds)
17:14:10 --- join: MrReach (~mrreach@209.181.43.190) joined #forth
17:14:16 <MrReach> hihi!
17:14:42 --- mode: ChanServ set mode: +o MrReach
17:14:50 --- mode: MrReach set mode: +oo Atlas_away qless
17:14:57 <qless> heyya mrreach :)
17:15:05 <MrReach> how goes?
17:15:23 <qless> fine, thinking about meta compilers
17:15:33 <MrReach> oh, good topic
17:15:45 <MrReach> which part are you thinking about at the moment?
17:15:54 --- topic: set to 'all you wanted to know about metacompilers, but were afraid to ask' by qless
17:16:04 <MrReach> ain't THAT the truth
17:16:23 <qless> i don't know much about it, except that HERE becomes THERE
17:16:27 <qless> :-)
17:16:35 <MrReach> sometimes   @:^>
17:16:53 <MrReach> rank beginner?
17:17:06 <qless> rank it is
17:17:35 <MrReach> hardest part for me recently is writing Portable Executable or ELF execuatable files
17:17:58 <qless> PE is the doze format?
17:18:00 <MrReach> the actual meta-compilation is not so difficult
17:18:05 <MrReach> yes
17:18:16 <MrReach> Win32, WinNT, and WinCE
17:18:23 <qless> ah
17:18:33 <MrReach> the two formats are nearly identical
17:19:02 <qless> interesting.  in my case i just have to create a binary image...
17:19:10 <qless> ... if i make it relocatable or not remains to be seen
17:19:13 <MrReach> what platform are you considering?
17:19:25 <qless> bare bones.  forth starts from post
17:19:34 <MrReach> Win and Linux load at the same adr each time, though this is not guaranteed
17:19:44 <MrReach> ok, what architecture?
17:19:55 <qless> athlon xp
17:20:04 <MrReach> are you thinking about the forth OS thingy?
17:20:16 <qless> indeed
17:20:28 <MrReach> which threading model?
17:20:50 <qless> subroutine, with eventually inline and agressive optimization
17:21:00 <MrReach> actually, that should be a snap, comparitively speaking
17:21:29 <MrReach> do you have a good Pentium+ assembler written yet?
17:21:51 <MrReach> or are you going to go straigh ia64 micro-ops?
17:22:03 <qless> i use gas.  haven't written the assembler yet
17:22:20 <MrReach> ok, ia32 then
17:22:26 <qless> yep
17:22:50 <MrReach> complicated beastie, been thinking about writing one myself
17:23:48 <qless> there's alot to get getting to the point of being able to communicate with the system
17:24:03 <MrReach> erm ... yes and no
17:24:19 <qless> explain pls
17:24:21 <MrReach> BIOS calls for basic output should get you started
17:24:36 <qless> nono.  i go to protected mode 1st thing
17:24:37 <MrReach> once you can see what you're doing, things get MUCH easier
17:25:10 <qless> "we don't need no skeekin bios"
17:25:13 <qless> :-)
17:25:31 <MrReach> hmmm ... direct video write might be ok, most machines start in standard VGA 80x25 if I recall
17:25:45 <qless> yep at 0xb8000
17:25:49 <MrReach> they USED to anyway ... hard to now what they do now
17:26:12 <qless> can i see if i understand the basics of metacompiler theory?
17:26:19 <MrReach> sure
17:27:00 * MrReach brain-twists into a bootloader environment for IBM-PC compatibles
17:27:29 <MrReach> oh! so much space! I can see for Megabytes!
17:27:45 <qless> i've got a nucleus/kernel that was generated by gas wich incluses interpreter, compiler and disk block routines.  i have all the source for it in disk blocks.  the metacompiler would be loaded off of disk blocks, do some magic, then write an image somewhere in memory that can be writeen back to the beginning of the disk
17:28:26 <MrReach> that is correct
17:28:31 <qless> (the disk is part loadable image, and part source blocks)
17:28:42 <MrReach> rather, that is at least one way to do it
17:28:47 <qless> wow. cool! :)
17:29:32 <MrReach> I would *STRONGLY* suggest compiling the imagine elsewhere on the disk, and having the bootloader ask if you want to try it
17:29:42 <MrReach> imagine= image
17:30:00 <qless> sounds like a wise move
17:30:26 <MrReach> does you system have allocate/free yet?
17:30:39 <qless> i'll only be useing floppies until i cook and ide driver
17:30:48 <qless> no it doesn
17:30:49 <qless> t
17:30:49 * MrReach nods.
17:30:53 <MrReach> yep, been there
17:31:17 <MrReach> so, you've just got unlimited memory past PAD?
17:31:26 <MrReach> (or a rediculously large memory block)
17:31:30 <qless> correct
17:31:38 <qless> ridiculously large
17:32:03 <MrReach> ok, stick your image out there ... let it grow as large as it needs
17:32:23 <qless> sounds good
17:32:25 <MrReach> then write it to the physical disk blocks when meta is finished
17:32:41 <MrReach> it will work much better than trying to compile it in the blocks
17:33:01 <MrReach> or ...
17:33:16 <MrReach> allocate a meg or so and compile in that ... in the dict
17:33:30 <qless> so, designate a start of the image, compile all the nucleus source (dictionary) then write to floppy?
17:33:44 <MrReach> is dictionary going to be seperate from code?
17:33:58 <MrReach> yes, tht is correct
17:34:02 <qless> it might be at some point, but not presently
17:34:14 <MrReach> then, you only have to adjust everything by a single offset
17:34:21 <qless> yep
17:35:11 <MrReach> incidently ...
17:35:19 <MrReach> I wouldn't try to mess with here ...
17:35:19 <qless> ?
17:35:44 <MrReach> I'd rewrite c, c@ c! w, w@ etc to use another variable
17:36:08 <MrReach> that way, your regular dictionary stays intact
17:36:25 <MrReach> (metcompiler uses new versions, in its own vocab)
17:36:50 <MrReach> then, you use custome FIND and COMPILE,
17:37:47 <MrReach> does your forth HAVE vocabularies?
17:38:41 <qless> so, c! for instance, has an internal offset added to it?
17:39:00 <MrReach> hmmm ...
17:39:24 <MrReach> it CAN ... depends how you want your metacompiler to work
17:40:01 <MrReach> ok, I should point out a preference that I have ...
17:40:23 <qless> not as yet
17:40:27 <MrReach> and that is that metacompiled code looks EXACTLY like regular forth in my sources
17:41:09 <MrReach> so you have CODE ... END-CODE , : ... ; , VARIABLE CREAT ALLOT etc
17:41:35 <qless> hmmmm
17:41:48 <MrReach> I usually use the words TARGET and HOST to switch back and forth
17:42:31 <qless> sounds reasonable
17:43:03 <MrReach> it means a lot of defs, but it sure makes things easier to read in the sources
17:43:32 <MrReach> how are you setting up stacks, dictionary, and user variable areas?
17:44:33 <MrReach> ooops, wifey is home
17:44:39 <MrReach> time to go to the movies
17:44:40 <qless> its still early on, but the hardware stack is return, es: will be data, cs/ds dictionary
17:44:45 <qless> oh have fun
17:45:08 <qless> btw, what cpu do you use?
17:54:33 <MrReach> for what???
17:55:03 <MrReach> until recently, it's been x86 excusively ... but my new PDA uses the Hitachi SH3
17:55:28 <qless> p4?
17:56:10 <MrReach> my desktop is a K6-2/350 ... my network server is a Pentium 200
17:56:16 <qless> with my forth i would really like to use some of the funky new instructions added since pentium
17:56:35 <MrReach> yes, the MMX stuff is nice
17:56:46 <MrReach> lots and lots of registers   @:^>
17:56:54 <qless> :-)
17:57:20 <qless> cmov, and 3dnow, and sse oh my
18:02:58 <MrReach> heh, see you later
18:03:01 --- nick: MrReach -> MrGone
18:03:05 <qless> i later dude
18:03:33 --- part: qless left #forth
18:43:18 --- nick: Atlas_away -> [Atlas]
19:37:08 --- join: tcn (TomNovelli@65.170.209.50) joined #forth
19:37:26 --- part: tcn left #forth
19:57:16 --- join: Soap- (~flop@210.55.39.197) joined #forth
22:46:12 --- join: edrx (edrx@200.240.18.74) joined #forth
23:16:06 --- log: started forth/01.11.16
23:16:06 --- join: clog (nef@bespin.org) joined #forth
23:16:06 --- names: list (clog @[Atlas] Soap- edrx @MrGone)
23:21:42 --- quit: edrx (varley.openprojects.net irc.openprojects.net)
23:21:42 --- quit: Soap- (varley.openprojects.net irc.openprojects.net)
23:21:42 --- quit: [Atlas] (varley.openprojects.net irc.openprojects.net)
23:21:42 --- quit: MrGone (varley.openprojects.net irc.openprojects.net)
23:22:03 --- join: [Atlas] (fare@samaris.tunes.org) joined #forth
23:22:03 --- join: Soap- (~flop@210.55.39.197) joined #forth
23:22:03 --- join: edrx (edrx@200.240.18.74) joined #forth
23:22:03 --- join: MrGone (~mrreach@209.181.43.190) joined #forth
23:22:03 --- mode: farmer.openprojects.net set mode: +oo [Atlas] MrGone
23:28:46 --- quit: MrGone (varley.openprojects.net irc.openprojects.net)
23:28:46 --- quit: [Atlas] (varley.openprojects.net irc.openprojects.net)
23:29:24 --- join: MrReach (~mrreach@209.181.43.190) joined #forth
23:37:52 --- quit: Soap- (varley.openprojects.net irc.openprojects.net)
23:44:56 --- join: Soap- (~flop@210-55-39-197.dialup.xtra.co.nz) joined #forth
23:51:23 --- quit: Soap- (varley.openprojects.net irc.openprojects.net)
23:51:23 --- quit: edrx (varley.openprojects.net irc.openprojects.net)
23:51:44 --- join: edrx (edrx@200.240.18.74) joined #forth
23:51:44 --- join: Soap- (~flop@210-55-39-197.dialup.xtra.co.nz) joined #forth
23:59:59 --- log: ended forth/01.11.16