00:00:00 --- log: started forth/01.06.04
00:43:06 --- quit: aaronl (Read error to aaronl[vitelus.com]: Connection reset by peer)
00:43:12 --- join: aaronl_ (aaronl@vitelus.com) joined #forth
01:08:51 --- join: aaronl__ (aaronl@vitelus.com) joined #forth
01:09:36 --- nick: aaronl__ -> aaronlz
01:09:40 --- quit: aaronl_ (Ping timeout for aaronl_[vitelus.com])
01:10:10 --- quit: lar1 (Ping timeout for lar1[adsl-63-203-73-199.dsl.snfc21.pacbell.net])
01:13:48 --- join: lar1 (lar1@adsl-63-203-73-199.dsl.snfc21.pacbell.net) joined #forth
01:43:13 --- quit: adu (IRCStep)
03:12:06 --- quit: lar1 (Ping timeout for lar1[adsl-63-203-73-199.dsl.snfc21.pacbell.net])
03:12:30 --- join: lar1 (lar1@adsl-63-203-73-199.dsl.snfc21.pacbell.net) joined #forth
04:01:07 --- quit: lar1 (Ping timeout for lar1[adsl-63-203-73-199.dsl.snfc21.pacbell.net])
04:01:26 --- join: lar1 (lar1@adsl-63-203-73-199.dsl.snfc21.pacbell.net) joined #forth
04:20:04 --- quit: [9of7] (using sirc version 2.211+4KSIRC/1.1)
05:13:26 --- join: Fare (fare@ppp81-net1-idf2-bas1.isdnet.net) joined #forth
05:41:35 --- join: cleverdra (jfondren@1Cust8.tnt3.florence.sc.da.uu.net) joined #forth
05:49:17 --- join: Trey (Baxter@ns.TreySoft.com) joined #forth
09:05:33 --- quit: cleverdra (Ping timeout for cleverdra[1Cust8.tnt3.florence.sc.da.uu.net])
10:21:33 --- join: MrReach (mrreach@209.181.43.190) joined #forth
10:21:52 <MrReach> anyone here work on a Mac?
10:23:05 <futhin> nope, i've got a crappy 133mhz pc :)
10:23:32 <MrReach> I've been considering ....
10:24:09 <MrReach> cross developing a Forth for Linux, Win32, and Mac ... Saw a Mac II SC at the trift store ... 40 meg drive, MacOS 7.0.0
10:24:23 <MrReach> how compatible would that be with modern Macs?
10:24:32 <MrReach> (4 meg mem)
10:25:07 <MrReach> in the PC world, I'd guess that to be roughly the same as a 386/40
10:26:24 <MrReach> how compatible would that be with modern Macs?
10:27:18 <MrReach> duh! I should ask in #Mac on EFNet
10:27:38 <futhin> hrm
10:27:40 <futhin> it doesn't matter
10:27:46 <futhin> you code in forth
10:27:50 <futhin> then compile on each computer
10:27:55 <futhin> it should be fine more or less
10:28:24 <MrReach> yes, but if I were to code for a Win2.1 machine, nobodies going to be able to use the code
10:29:06 <MrReach> or the code would suffer from not being able to use the new OS features
10:31:16 <futhin> what exactly are you trying to make?  a forth program  or a forth compiler or what?
10:31:40 <MrReach> would be making a system independant forth system
10:32:11 <MrReach> I'd like to creat the equivelant of TCL/Tk in the forth world.
10:33:54 <futhin> well you are going to have to code a specific part of it for each specific platform you implement it on.
10:34:35 <futhin> you could create the core part of the system, and then have some code that loads it up, and make that code on linux,windoze,mac
10:34:40 <MrReach> yes, and I'm willing to write a forth assembler for each platform to match
10:37:22 <MrReach> that is almost exactly what I intend to do
10:37:44 <futhin> aren't there already cross-platform forth compilers or something?
10:37:57 <MrReach> not across the board, no
10:38:37 <MrReach> also, TCL provides a very robust environment ... networking, command line, environments, etc
10:38:48 <MrReach> events
10:40:17 <MrReach> leaving aside that a Tk (windowing) application runs nearly identically across all platforms w/o modification
10:42:28 <futhin> make the specifications for your forth system then make the forth system some kind of portable module and run it ontop of some forth code that gets implemented on each system and deals with all the calls to the os for graphics, etc..    that's what i think :)
10:42:55 <MrReach> of course
10:43:16 <MrReach> the switching keyboard game is a total nuisance
10:43:36 <futhin> eh? switching from pc to mac keyboard?
10:43:42 <MrReach> but in any case, I need to know if the Mac II Sc is an acceptable development platform
10:43:49 <MrReach> futh: yes
10:44:50 <MrReach> if done correctly, the kernel can be built FOR any machine, ON any machine
10:45:05 <futhin> the Mac II sc probably isn't an acceptable development platform.  check what macos version it is and find out how backward compatible the most current macoses are..
10:45:33 <futhin> but i don't think it's a very good system, dunno..
10:45:43 <MrReach> when metacompiling, I'll probably go ahead and load the extentions before saving the kernel image ... it avoids two steps in the recomp process
10:45:48 <futhin> find out if code developed on that system can run on the current macoses
10:46:02 <MrReach> that what I was thinking
10:46:38 <futhin> or just get an account on somebody's mac and develop thru a telnet connection or something :)
10:46:43 <MrReach> heh, that's what I came here to do   @:^>
10:46:51 <futhin> heh
10:47:13 <MrReach> well, that's another option I've been considering ... simply handing the the MacOS devel to someone else
10:47:19 <futhin> yeah
10:47:42 <futhin> if you do it right you can worry about the macos devel later and focus on the linux/win32 first
10:47:46 <MrReach> but we'd be certain to disagree about threading model, memory management, the granularity of look-and-feel
10:48:59 <MrReach> actually, I don't want to do that ...
10:49:02 <futhin> well
10:49:32 <futhin> maybe the part of code that is developed on each system can deal with most of the threading model and memory management..
10:49:38 <futhin> but
10:49:51 <MrReach> because from the start I want it to look and feel identical on all platforms, which may force compromises on Linux/Win32 in order to accomodate MacOS
10:50:23 <futhin> hmm
10:50:30 <MrReach> it will hurt the distribution to make those compromises later rather than earlier
10:50:43 <futhin> well it looks like you need to find a forth coder on #mac or a mac user on #forth :)
10:51:34 <futhin> there's the newsgroup comp.lang.forth.mac
10:51:36 <MrReach> actually, I'll just check in #Mac or #MacOS on EFNet later this eve
10:51:40 <MrReach> yes, there is
10:51:57 <futhin> and there's probably some forth coding on mac pages, you could email somebody :)
10:52:29 <MrReach> all I need to know is that progs written on this thrift store special either will or will not run effeciently on newer machines
10:52:51 <MrReach> that's an excellent idea, actually ...
10:53:02 <MrReach> it would also enroll others in the project
10:53:07 <futhin> how much is that mac II sc?
10:53:14 <MrReach> $30
10:53:30 <Fare> sc ?
10:53:39 <futhin> you said sc?
10:53:44 <Fare> I know IIfx, IIx, IIsi
10:53:46 <MrReach> but the last thing I need is yet ANOTHER computer sitting around that I'm not using.
10:54:09 <MrReach> yes, it's ancient ... early 90s vintage I'd guess
10:54:33 <futhin> Fare: you know anything about Macs?
10:54:44 <MrReach> not a damn thing
10:55:00 <futhin> the question was for Fare :)
10:55:25 <MrReach> i _did_ see a doc once detailing the format of exec files, so I know I can write the kernel image
10:55:30 <MrReach> oh, so it was, sorry
11:07:56 <Trey> MrReach: All of the Macs you mentioned use 68K CPUs.
11:08:32 <MrReach> is that good or bad?
11:08:49 <Trey> Writing code for pre-PowerMac machines doesn't make much sense.
11:08:56 <MrReach> I presume that all of the Macs are backward compatible, to some degree
11:09:09 <MrReach> ok, thanks, that's what I needed to know
11:09:37 <Trey> PowerMacs have a 68K emulator.
11:09:48 <MrReach> I expect that If I want to do this right, I'll probably have to spend $1800 for a maodern machine
11:10:24 <Trey> I understand that the low-end iMacs can cost in the $1100 range.
11:10:40 <MrReach> ok, that's better, of course
11:12:34 <MrReach> thank you
11:13:00 <futhin> actually, i was looking at iMacs and i found one for something like 700 bucks canadian  (a used imac)  in town
11:13:26 <futhin> so i'd think you should be able to find a nice used iMac for like 400 to 600
11:14:01 <MrReach> heh, it's not like I need any real computing power    @:^>
11:14:31 <MrReach> most forths are completely swamped with processing power on the modern machines, it's funny to see
11:14:50 <futhin> eh?  too much processing power for forths? 
11:15:16 <MrReach> not "too much" ... more like "1000x that needed to run most forth apps"
11:15:44 <MrReach> even for windowing stuff
11:16:42 <futhin> yeah, but that's no excuse to not do your best to create tight code every time.. 
11:16:42 <MrReach> I saw the machines that ran Rancho Seco nuclear powerplant ... 80286's with 2MB ram ... run forth native
11:17:29 <MrReach> one machine controlled 80 data points, including the door security and gate motors
11:17:34 <MrReach> sorry, typo
11:17:37 <futhin> i have a 133mhz pentium with 32 megs of ram.  it always pisses me off when windows is slow cause i know that for the stuff that it is doing, it is ridiculously slow
11:17:44 <MrReach> one machine controlled _800_ data points, including the door security and gate motors
11:17:53 <futhin> heh
11:17:55 <futhin> cool
11:18:26 <MrReach> and there where 3 machines, side-by-side ... two out of three had to agree on what to do before it was actually done
11:19:14 <MrReach> so not only did one machine controll 800 datapoints, it was contanstly asking for 2nd opinions from it peers
11:19:14 <futhin> hrm, interesting
11:19:27 <futhin> that probably made it very robust
11:19:43 <MrReach> well, it WAS a nuclear powerplant, after all
11:20:18 <MrReach> all the code was written by one man working for 8 months
11:21:14 <MrReach> it was an awesome system, and I simply couldn't believe he did it all on a '286/12
11:22:31 <MrReach> now, compare THAT to an Athalon 1Ghz and 1 gig mem ... it's insane
11:22:52 <futhin> yeah
11:23:10 <MrReach> hell, you could run the entire world with that one machine    @:^>
11:23:23 <futhin> good code always give me a warm fuzzy feeling, even if somebody else did it.  :)
11:24:16 <MrReach> heh, the Athalon prob has more L2 cache than the entire mem of the '286 system
11:24:38 <futhin> heh
11:25:02 <futhin> you've gotten me wondering if there are many forth embedded systems..
11:25:33 <MrReach> in what?
11:25:39 <futhin> my dad does some work on embedded microcontrolers.  but i don't think he's worked on a forth one
11:26:00 <futhin> if there was an embedded microcontroller programmable with forth that should be nice
11:26:04 <MrReach> god, forth is used everywhere
11:26:46 <MrReach> it's in cars, missiles, the NASA shuttle controllers are a networked bunch of forth controllers
11:27:32 <MrReach> I first had to use it when I was repairing MilSpec weather stations
11:28:00 <futhin> yeah, the microcontrollers my dad uses are fairly basic building controllers or machinery controllers for like pulp mills and stuff
11:28:26 <MrReach> if he's not using forth, he should be ... that is where it shines best
11:28:33 <MrReach> what language is he using now?
11:28:34 <futhin> but i don't know of any company that produces forth microcontrollers..?
11:28:56 <futhin> i dunno, it's some basic-like language..  maybe similar to fortran or something.. dunno
11:29:08 <MrReach> LMI, Forth Inc, MPE all produce forths for various microcontrollers
11:29:49 <MrReach> sounds like he's he's using 8051MPus ... they have a built-in BASIC look-like
11:29:52 <futhin> the microcontroller he gets has its own programming language..  he wouldn't really be able to put forth on it
11:30:07 <MrReach> heh
11:30:29 <MrReach> yes, he can, but it's a bit of a nuisance ... burning a PROM and all that
11:30:48 <futhin> yeah
11:31:20 <MrReach> he already has his libraries, mem management, and tasking set up on his machines, little need to change
11:31:22 <futhin> but it'd be easier for him if he could just buy the microcontroller from a company that has forth and all the necessary hardware on it..
11:33:31 <MrReach> indeed, but he still has a personal learning curve
11:33:52 <futhin> my dad uses http://www.multinet.reliable.bc.ca/
11:34:42 <futhin> the mach1 controller has 8 inputs and 8 outputes
11:34:44 <MrReach> actually, he probably already has a PROM burner capable of loading the flash-ram of modern microcontrollers, so ...
11:34:44 <futhin> the mach1 controller has 8 inputs and 8 outputs
11:34:51 <futhin> no
11:34:59 <futhin> there's a plugin for the controller
11:35:08 <futhin> so he can download the code onto it
11:35:37 <futhin> but there's already code in the rom so that it runs the code he downloads onto it
11:35:38 <MrReach> once he has a kernel he likes, it's a 10 minute job to pop the chip in the burner and start the software to load any system he likes
11:35:46 <MrReach> ok, that works, too
11:37:11 <futhin> there's a rom chip on the microcontroller that has the assembly code, and it only supports a particular coding language..
11:37:33 <futhin> and i don't think the rom is popable :)
11:38:13 <MrReach> yeah, he's kinda locked-in to whatever language that company likes
11:38:52 <MrReach> and he's prob not ready to start doing his own board layouts
11:39:22 <futhin> he uses these fairly simple microcontrollers with like 8 inputs and 8 outputs
11:40:00 <futhin> i'm curious if you know of any really microcontrollers with 8 inputs and 8 outputs and networkable with other microcontrollers and forth-usable and cheap? :)
11:40:31 <MrReach> probable
11:41:41 <MrReach> in 1992 I saw a small Z80 cmos board, hand built, with stackable modules for RS232, keyboard, FireWire, display, I/O, etc
11:41:47 <MrReach> it was pretty nifty
11:42:19 <MrReach> firewire is like 2Mb/s, right?
11:42:39 <MrReach> I can't imagine how he got that little processor to handle that kind of throughput
11:42:51 <futhin> heh, cool
11:44:13 <MrReach> this guy would use these board to prototype ... for final product he'd either stick the boards in a box, or lay out a single, integrated board if he wanted it to look proprietary
11:44:50 <MrReach> he had it down to a science
11:46:21 <MrReach> it ran Forth, of course, I saw the demonstration at a FIG meeting
11:47:24 <MrReach> the debugging was REALLY sophisticated ... single-stepping through an umbilical to a PC
11:51:45 <futhin> heh
11:51:47 <futhin> cool
11:52:16 <Fare> MrReach: aren't there things like 32 MHz Z80's, these days?
11:52:22 <MrReach> yep
11:52:35 <MrReach> all kinds of things inbetween, too
11:53:08 <MrReach> have you seen the PSC1000s from Patriot Systems? designed to run forth and javascript natively
12:00:16 <MrReach> I can't find it on their web page now ... too bad
12:00:49 <MrReach> here's some stuff that quotes Elizabeth Rather ... http://industry.java.sun.com/javanews/stories/print/0,1797,6259,00.html
12:01:31 <futhin> what's the biggest makers of small microcontrollers that run forth natively?
12:01:41 <futhin> so i can check out a website..
12:02:51 <MrReach> harris semiconductor, probably ... they used to build the Novix series that Charles Moore designed
12:03:05 <MrReach> not sure they're still making them, though
12:03:31 <MrReach> ok, you really don't want a native forth chip ... they are rare and expensive
12:04:19 <MrReach> what you want is a FAMILY of generic processors with lots of memory and i/o configurations
12:04:44 <futhin> yes, one that you can hook up the computer to and download forth code
12:04:47 <MrReach> then either burn forth into an extrenal (E)PROM or into the internal flash ram
12:05:41 <MrReach> oh, god, it's been AGES since I did any research in this area ... there's prob better solutions now
12:06:17 <MrReach> quest.com is a good place to browse comparative capabilities, IIRC
12:09:50 <MrReach> I can't find quest now, try icmaster.com
12:17:57 <MrReach> EDN - Electronic Design News - often publishes references about where to find good info
13:53:32 <futhin> what's the forth command to display a value?
13:53:42 <futhin> like print or notify or ?
14:01:00 <Trey> . consumes the TOS and prints it in the current base.
14:01:33 <Trey> .s will non-destructively print the entire stack.
14:05:19 <futhin> ok, thnx
14:07:07 --- join: cleverdra (jfondren@1Cust116.tnt3.florence.sc.da.uu.net) joined #forth
14:08:24 <futhin> hrm, i want a small forth machine
14:08:54 <cleverdra> machine as in hardware?
14:08:55 <Fare> get the F21 emulator for x86
14:09:05 <Fare> faster than a F21.
14:09:35 <futhin> hardware
14:09:43 <futhin> i want a little hardware piece just for the hell of it :)
14:09:56 <cleverdra> futhin - well, there's the F21 =)
14:10:13 <futhin> how big is it?
14:10:17 <cleverdra> or (I'm not sure what you mean yet) Enth/Flux makes for a good stand-alone OS on x86
14:10:25 <futhin> how cheap?  where to i buy it?
14:10:26 <cleverdra> www.ultratechnology.com, futhin
14:10:28 <futhin> a machine/hardware
14:12:22 <Fare> there's the PSC1000 -- more serious than a F21
14:12:33 <Fare> or you can use this free 16-bit FPGA forth cpu
14:12:47 --- quit: Fare (Connection reset by pear)
14:17:34 <Trey> I tried booting Enth/Flux on a dual-P2 266, but it never made it all the way up.
14:18:10 <cleverdra> I've booted Enth/Flux on several systems, including a 486DX
14:18:20 <cleverdra> Have you tried the latest version?  What did it fail on?
14:55:52 --- join: kanzeon (srpollo@195.57.122.214) joined #forth
15:01:43 <MrReach> greets, hanz
15:01:50 <MrReach> kanz, even    @:^>
15:04:57 --- quit: cleverdra (Read error to cleverdra[1Cust116.tnt3.florence.sc.da.uu.net]: Connection reset by peer)
15:04:57 --- quit: MrReach (Read error to MrReach[209.181.43.190]: Connection reset by peer)
15:06:10 --- join: MrReach (mrreach@209.181.43.190) joined #forth
15:29:32 --- quit: kanzeon ([x]chat)
15:33:20 * Trey is away: life, etc. [17:33]
15:54:05 --- nick: aaronlz -> aaronl
15:55:25 --- quit: MrReach (Read error to MrReach[209.181.43.190]: Connection reset by peer)
15:56:30 --- join: MrReach (mrreach@209.181.43.190) joined #forth
17:22:26 --- quit: lar1 (farmer.openprojects.net pratchett.openprojects.net)
17:23:33 --- join: lar1 (lar1@adsl-63-203-73-199.dsl.snfc21.pacbell.net) joined #forth
17:23:34 --- quit: lar1 (farmer.openprojects.net pratchett.openprojects.net)
17:30:21 --- join: lar1 (lar1@adsl-63-203-73-199.dsl.snfc21.pacbell.net) joined #forth
18:26:59 <MrReach> has anyone here wrote a forth that writes the .EXE file directly ???
18:27:11 <MrReach> for Win32, I should say
18:52:23 <futhin> are we talking a win32 console program or are we talking win32 gui stuff?
18:52:33 <MrReach> console is fine
18:52:37 <MrReach> for now
18:53:07 <futhin> is that what you want with the forth system that you want to make?  or do you want gui support?
18:53:38 <MrReach> I _will_ want gui
18:53:43 <MrReach> but not initially
18:54:35 <futhin> isn't there a windows forth compiler?
18:58:00 <futhin> um, have you looked at bigForth and gForth?
18:58:15 <MrReach> they use a C wrapper
18:58:25 <futhin> <--- doesn't know anything :P
18:58:44 <MrReach> gforth does, anyway, I presume bigforth does, too
18:58:59 <MrReach> as does Win32For
18:59:04 <futhin> bigFORTH is a native code Forth. It is available for Linux and Windows 95/98/NT in pre-beta-test under GPL. The most striking feature is the graphical user interface MINOS and the form editor Theseus. These are the other features of bigFORTH:
18:59:35 <MrReach> ok, lemme check the .ZIP for .C files
18:59:37 <futhin> doesn't sound like bigForth ubigFORTH is a native code Forth. It is available for Linux and Windows 95/98/NT in pre-beta-test under GPL. The most striking feature is the graphical user interface MINOS and the form editor Theseus. These are the other features of bigFORTH:
18:59:40 <futhin> oops!
18:59:53 <MrReach> huh?
19:00:00 <futhin> heh
19:00:04 <futhin> nevermind :)
19:00:13 <futhin> accidental shift insert or something weird
19:01:03 <futhin> hrm
19:01:14 <futhin> you want a free forth implemented under windows?
19:01:38 <futhin> cause swiftforth has support for .dlls and stuff 
19:02:23 <MrReach> yep, bigforth uses a C wrapper, good idea, though
19:02:44 <MrReach> dll support is realatively easy
19:03:15 <MrReach> no, I want a cross-platform forth analogous to TCL/Tk
19:03:25 <MrReach> Linux, Windoze, MacOS
19:03:45 <futhin> it shouldn't take too long to implement?
19:03:53 <futhin> a week? :P
19:04:14 <MrReach> the ONLY idea I'm a bit hesitant about in TCL is thhe way they did the shared library interfaces with "stubs"
19:04:52 <MrReach> but, I'm sure that if I look into how stubs works and why they chose that method that I'll agree with its neccessity
19:05:16 * MrReach shrugs, "It's a hobby."
19:07:28 <futhin> did you check sp forth?
19:07:43 <MrReach> what's the URL? never heard of it.
19:09:54 <futhin> http://sourceforge.net/projects/spf/
19:10:04 <MrReach> danke
19:12:34 <futhin> hrm, Jax Forth
19:12:51 <futhin> did you try Aztec Forth?
19:12:59 <MrReach> yes, C wrapper
19:14:05 <futhin> do you know assembly?
19:14:20 <MrReach> yes
19:14:23 <MrReach> well ...
19:14:41 <MrReach> Z80, 6502, MC68000 and x86
19:14:50 <futhin> heh ok :)
19:16:23 <MrReach> I can't seem to be able to open the .RAR file that spforth is packaged in
19:16:30 <MrReach> what OS is it written for?
19:16:55 <MrReach> the .TXT files in the CVS tree at sourcforge are unreadable, too
19:17:43 <futhin> eh
19:17:58 <futhin> don't you have a rar uncompressor program?
19:18:13 <MrReach> doesn't winzip handle rar?
19:18:17 <futhin> no
19:18:20 <futhin> hafta get winrar
19:18:24 <futhin> or something like that
19:18:25 <MrReach> no, I guess I don't ... *sigh*
19:18:32 <futhin> heh :)
19:18:33 <MrReach> nm
19:18:47 <futhin> i have like a whole bunch of rar files and i'm too damn lazy to download winrar! :P
19:19:24 <futhin> what's wrong with a C wrapper anyways?
19:20:07 <MrReach> it means that the forth cannot metacompile itself
19:20:07 <futhin> write a forth compiler ontop of the win32 forth compilers :)
19:20:17 <MrReach> I'm going to
19:20:19 <futhin> hm
19:21:08 <MrReach> win32for does pretty good about it ... it's basically an empty .EXE that loads the image file, and then jumps into it
19:21:20 <MrReach> but still, can't write the .EXE
19:21:26 <futhin> eh?
19:22:11 <MrReach> ok
19:22:38 <MrReach> most programs load as a .EXE
19:23:04 <MrReach> which means they can link both static and dynamic libraries at the linker lever (and at load time)
19:23:59 <MrReach> in windows, at LEAST three libraries need to be linked at load-time ... KERNEL32 USER32 and GDI (?)
19:24:39 <MrReach> this gets a little complicated when building the .EXE file, and Tom Zimmer simply couldn't (or didn't have time to) figure it out
19:25:42 <MrReach> so he wrote a C program that does nothing be get the address of these libraries, and then jumps to the image assembled by the forth assembler
19:25:44 <futhin> take a look at swiftforth, apparently you can get an evaluation version
19:26:06 <MrReach> yes, but not the meta compiler ... I've looked into it
19:26:19 <futhin> The only limitation on this evaluation version is that you cannot save "turnkey" images of your compiled programs, and the source supplied is limited to program options and examples.
19:26:22 <MrReach> they're pretty proprietary with their source
19:26:38 <futhin> you get the full source if you purchase it :)
19:26:48 <MrReach> if you buy it, you get source for the kernel and the extentions, but still not the metacompiler ...
19:26:55 <futhin> hm
19:27:06 <MrReach> if you buy the "Pro" version, then you get the metacompiler ...
19:27:23 <MrReach> but you have to sign an NDA
19:27:28 <futhin> hm
19:27:39 <MrReach> and there's no guarantee they're not using a C wrapper, also
19:28:21 <futhin> don't you think that swiftforth can metacompile itself?
19:28:42 <MrReach> blah, I'll just muddle my through the Portable Execuable Format with trial and error until I finally figure out how it's all pasted together
19:29:16 <MrReach> futh: it might, like win32for can, but still requires that one copy the .EXE file verbatim
19:29:45 <futhin> i don't know much forth, i practically learned a forth-like language like 3 weeks ago and now i'm going to get into forth
19:29:56 <MrReach> be back in a few minutes, need to go buy a pizza
19:34:42 <futhin> check this page http://www.concentric.net/~jkelm/win32for/
19:34:49 <futhin> scroll down a little bit
19:34:59 <futhin> he works on linux, mac, windows
19:35:38 <futhin> he seems like a possible person to talk to
19:35:58 <futhin> dunno
19:38:40 <futhin> have you checked kforth or pforth
19:41:24 <futhin> what the hell, i don't understand
19:41:29 <futhin> you don't want a C wrapper
19:41:43 <futhin> but all the forth compilers are written in C or C++ or something like that
19:49:20 <MrReach> back
19:49:57 <MrReach> that's because no-one wants to mess with the complexity of Win32 Portable Executable formats
19:55:46 <MrReach> oooh! nice controls on that page you sent me to
20:02:55 <MrReach> ever do any tk programming?
20:02:58 <futhin> nope
20:03:17 <MrReach> hmm ... tk has a convention that I'm not sure how to port to forth
20:03:20 <futhin> what controls on the page?
20:03:43 <MrReach> http://www.concentric.net/~jkelm/win32for/classidx2/example.htm
20:03:53 <futhin> ah
20:04:21 <MrReach> you see, tk starts with a toplevel window, named "." ... in which you create child windows, or widgets
20:05:14 <futhin> um, windows was coded in c++ pretty much, so you do need to use c++ to code a forth compiler that takes advantage of win32 stuff.    unless you want to code it in assembly?
20:05:20 <MrReach> each wiget is named from the parent like .child1 .child2 .frame1.child3A .frame1.child3b ... etc
20:05:50 <futhin> so you want your forth system to have widgets? :)
20:06:03 <futhin> hrm
20:06:13 <MrReach> the kernel will be about 40 words coded in assembly ... probably about 40 words in high-level (just enough to get INCLUDED to work
20:06:30 <MrReach> futh: the widgets make Tk programming effortless
20:07:24 <futhin> show me a one line sample of code that uses a widget?
20:07:30 <futhin> in tk
20:07:36 <MrReach> ok ...
20:08:41 <MrReach>    button .button1 -text "Push me to exit" -action exit
20:09:13 <MrReach>    pack .button1 -anchor nw
20:09:15 <MrReach> [end]
20:09:41 <futhin> -anchor nw puts it in the northwest corner of the screen?
20:10:00 <MrReach> that puts a button in the upper left corner of the toplevel window ... when you push the button, it abruptly kills the program
20:10:11 <MrReach> yes, that is what that option does
20:10:25 <futhin> don't you have stronger control over where to put the button?
20:10:50 <MrReach> of course you do, but you wanted a one-liner and I didn't feel like a lot of typing
20:10:57 <futhin> heh, ok :)
20:11:24 <futhin> i expected something like -gotoxy 10,10
20:11:47 <MrReach> there are options to set fore and background colors, what the cursor looks like when it's over it, whether to expand to fill it's parant window, padding around the button and on and on
20:13:05 * futhin is trying to think of something :)
20:15:13 <futhin> maybe you just drop the .  and have:  child1 button button <options> endbutton   
20:15:19 <futhin> or something weird like that heh
20:15:39 <futhin> button button1.child1   ->   child 1 button1 button
20:15:59 <futhin> where button is a word
20:16:08 <futhin> and endbutton is the complementary word that takes in the options?
20:16:15 <futhin> what do you think?
20:19:34 <MrReach> hmmm
20:19:54 <MrReach> the forth object way would be ...
20:20:09 <MrReach> button myButton
20:20:23 <MrReach> UL setCorner: myButton 
20:20:36 <MrReach> red setColor: myButton
20:21:17 <MrReach> getHandle: myButton   addChildWidget: parent
20:21:26 <MrReach> update: parent
20:21:33 <MrReach> [end example]
20:23:05 <futhin> huh
20:23:30 <futhin> huh!?
20:23:44 <futhin> where's the word? the command the function?
20:23:53 <MrReach> heh, ok ...
20:23:57 <futhin> forth is rpn! :)
20:24:24 <MrReach> "button myButton" this creates an object of type button, named myBotton
20:24:45 <MrReach> "UL setCorner: myButton " ...
20:24:58 <MrReach> UL is a constant, used internally, it's placed on the stack
20:25:25 <MrReach> setCorner: is a word that sends a message to the button object
20:25:53 <MrReach> "getHandle: myButton   addChildWidget: parent"
20:26:06 <futhin> shouldn't it be "myButton button"  ?  (after all, it's rpn here) :)
20:26:20 <MrReach> the getHandle: message tells the widget to return whatever handle its known by on the top of stack
20:26:41 <MrReach> no, button is a word that creates an object of its type
20:26:54 <MrReach> it parses the input stream for "myButton"
20:27:06 <MrReach> "getHandle: myButton   addChildWidget: parent"
20:27:09 <MrReach> the getHandle: message tells the widget to return whatever handle its known by on the top of stack
20:27:45 <MrReach> the addChildWidget tells an object to place a child within itself, it may send the child 100s of messages in doing so
20:28:02 <MrReach> but addChildWiget needs the child's handle on TOS
20:28:53 <futhin> huh, it parses the input stream for myButton?
20:29:10 <MrReach> yes, like the words CREATE and VARIABLE
20:29:51 <futhin> i saw some BNF parser code for forth
20:30:26 <futhin> i think i know what you mean :)
20:30:42 <futhin> btw, the BNF parser code was only a screenful
20:30:59 <futhin> in the traditional sense of screen as like only a 16 lines or something
20:31:01 * MrReach nods
20:31:01 <futhin> i dunno
20:31:11 <MrReach> going to go eat pizza, be back in an hour
20:31:18 <futhin> ok, see ya
21:06:36 <futhin> back
21:06:49 <futhin> let me know when you are
21:41:36 <MrReach> back
21:41:59 <MrReach> that's the last time I order breadsticks with the bake-at-home pizza
21:42:18 <MrReach> the house absolutely REEKS of garlic ... yuck!
21:42:23 <futhin> heh
21:42:31 <futhin> did you not eat the breadsticks?
21:42:48 <MrReach> no, I cooked them for wifey
21:43:02 <futhin> well if you eat the garlic you don't smell it any more..
21:43:05 <futhin> more or less
21:43:24 <MrReach> true, a skunk doesn't smell his own stink
21:44:37 <futhin> so go eat some garlic if it's annoying you :)
21:57:39 <MrReach> heh
22:04:12 <futhin> so did i help you with the whole .child thing?
22:16:45 --- join: adu (andrew@adsl-63-201-91-148.dsl.snfc21.pacbell.net) joined #forth
22:23:04 * aaronl is away: I'm busy
22:33:43 * aaronl is back (gone 00:10:39)
23:17:23 * aaronl is away: I'm busy
23:59:59 --- log: ended forth/01.06.04