00:00:00 --- log: started forth/10.03.22
00:20:35 --- quit: proteusguy (Ping timeout: 260 seconds)
00:33:41 --- join: proteusguy (~proteusgu@zeppelin.proteus-tech.com) joined #forth
00:48:36 --- join: ygrek (debian-tor@gateway/tor-sasl/ygrek) joined #forth
00:52:01 --- join: ASau` (~user@77.246.231.71) joined #forth
01:46:24 --- quit: proteusguy (Ping timeout: 240 seconds)
01:59:41 --- join: proteusguy (~proteusgu@zeppelin.proteus-tech.com) joined #forth
03:13:55 --- quit: proteusguy (Ping timeout: 260 seconds)
03:14:31 --- quit: johnl_ (Ping timeout: 246 seconds)
03:26:38 --- join: proteusguy (~proteusgu@zeppelin.proteus-tech.com) joined #forth
04:22:50 <ASau`> ABORT" doesn't work :D
04:22:54 <ASau`> That's nice!
04:31:31 --- quit: proteusguy (Ping timeout: 246 seconds)
04:44:05 --- join: proteusguy (~proteusgu@zeppelin.proteus-tech.com) joined #forth
04:57:49 --- join: nighty (~nighty@x122091.ppp.asahi-net.or.jp) joined #forth
04:59:52 --- quit: nighty (Client Quit)
05:26:03 <segher> hrm...  what is the usual name (is there any?) for  ( a b c -- a b c a b )
05:35:09 <ASau`> : pluck 2 pick ;
05:35:52 <segher> but twice that
05:36:08 <ASau`> You won't believe it!
05:36:12 <ASau`> pluck pluck
05:36:19 <segher> 2pluck :-P
05:36:55 <ASau`> Intuitively, it does "pluck" to double cells.
05:37:11 <ASau`> Cf. "2over"
05:37:28 <segher> yeah, but "over" a single cell
05:38:00 <ASau`> "2rot" doesn't rotate over a single cell.
05:40:13 <segher> of course not
05:40:36 <segher> all the "2" words do what the "single" words do, but to pairs
05:41:42 <ASau`> that's why "2pluck" does this: ( a b c d e f -- a b c d e f a b )
05:42:14 <segher> yeah
05:42:37 <segher> but that's just crazy
05:42:54 <segher> i find  ( a b c -- a b c a b )  crazy already, heh
05:43:07 <ASau`> I do this frequently.
05:43:40 <segher> really?  what do you call it
05:43:51 <segher> 2pick 2pick ?
05:44:31 <ASau`> <ASau`> : pluck 2 pick ;
05:44:45 --- join: johnl_ (~johnl@217.78.4.44) joined #forth
05:45:10 <segher> yeah, i mean, what do you use for abc-abcab -- you don't factor that?
05:46:49 <ASau`> <ASau`> You won't believe it!
05:46:49 <ASau`> <ASau`> pluck pluck
05:46:55 <ASau`> Why should I factor that?
05:47:01 <ASau`> It is rare enough.
05:47:09 <segher> yeah i guess
05:48:01 <segher> but my question was, if you _do_ factor it, what do you call it?
05:48:20 <ASau`> "I don't."(tm)
05:48:33 <ASau`> Why do you want it?
05:48:49 <segher> i'm reverse engineering some forth code
05:49:04 <segher> and i don't have headers
05:49:33 <ASau`> Leave it as is.
05:50:27 <segher> i need a name for it, duh
05:50:57 <segher> it's not terribly readable if every word has some hex as name :-)
05:51:11 <ASau`> well afair, someone proposed "2over1" or something that ugly.
05:52:04 <segher> oh that is nice and descriptive
05:52:08 <segher> ugly, sure
05:52:13 <segher> but i'll go for that
05:52:14 <segher> thanks
05:53:33 <ASau`> I think that I have broken "postpone".
05:59:56 --- quit: Deformative (Ping timeout: 265 seconds)
06:07:43 --- part: TR2N left #forth
06:09:36 --- quit: proteusguy (Ping timeout: 265 seconds)
06:21:48 --- join: proteusguy (~proteusgu@zeppelin.proteus-tech.com) joined #forth
07:13:18 --- nick: TreyB_ -> TreyB
07:14:40 --- quit: proteusguy (Ping timeout: 276 seconds)
07:14:59 --- join: Snoopy_1711 (Snoopy_161@dslb-084-059-120-012.pools.arcor-ip.net) joined #forth
07:19:06 --- join: TreyB_ (~trey@adsl-76-240-63-203.dsl.hstntx.sbcglobal.net) joined #forth
07:24:26 --- quit: Snoopy_1611 (*.net *.split)
07:24:26 --- quit: gogonkt (*.net *.split)
07:24:26 --- quit: TreyB (*.net *.split)
07:24:26 --- quit: maht (*.net *.split)
07:24:42 --- join: maht (~maht__@85-189-31-174.proweb.managedbroadband.co.uk) joined #forth
07:25:52 --- join: proteusguy (~proteusgu@zeppelin.proteus-tech.com) joined #forth
07:51:06 --- quit: madwork (Read error: Connection reset by peer)
07:52:09 --- join: Deformative (~joe@bursley-185022.reshall.umich.edu) joined #forth
08:06:08 --- nick: gnomon_ -> gnomon
08:18:31 --- join: madwork (~madgarden@204.138.110.15) joined #forth
08:25:25 --- quit: proteusguy (Ping timeout: 265 seconds)
08:37:48 --- join: proteusguy (~proteusgu@zeppelin.proteus-tech.com) joined #forth
08:41:08 <KipIngram> segher: I finally decided to keep the A and B registers, and settled on the following words: a!, a@, b!, !a+, !b+, (@a+, (@b+, @).
08:41:36 <KipIngram> The (@a+ and (@b+ words just clock the address into the FPGA RAM.  @) puts the RAM output onto the stack.
08:42:36 <KipIngram> I tried at first to be tricky and "pre detect" those fetch operations so that I could do it all in one word, but that kept popping up problem after problem.
08:43:02 <Deformative> Neat.
08:43:24 <Deformative> I am wondering, how will you implement '?
08:43:30 <Deformative> It took me 4 registers.
08:43:43 <KipIngram> Refresh my memory on what that does.
08:43:53 <Deformative> '
08:43:55 <Deformative> TICK
08:44:08 <KipIngram> Oh; I thought you were indicating a '? word.  I see now.
08:44:10 <Deformative> Linear search on dictionary, strcmps.
08:44:20 <Deformative> Yeah, poor communication on my part.
08:44:35 <KipIngram> I suppose I will use memory locations if I can't do it on the stack conveniently.
08:45:23 <Deformative> Ah, yeah, I suppose you could push things like what entry you are currently working with to the stack.
08:45:40 * Deformative shrugs.  I suppose I just "optimized" my tick slightly.
08:46:15 <KipIngram> I don't plan to fret too much over how I implement that stuff.  I mostly plan to follow the (ASau - please turn away) FIG definitions.
08:46:20 <segher> it is convenient to be able to use the RTOS as address reg as well
08:46:42 <KipIngram> I do have some free opcodes at the moment, so I could do that.
08:47:09 <KipIngram> What I really want to do now is take some more bits from nested call/jump cells and use them as conditional predicates.
08:47:16 <Deformative> KipIngram: Are the FIG definitions available somewhere?
08:47:20 <KipIngram> That would free several more opcodes and compact my code.
08:47:21 <segher> you can probably get away with not having a B reg at all then
08:47:30 <KipIngram> Oh, yes they are.  Forth Fundamentals volume 2.
08:47:44 <Deformative> I am nearing the point where my bootstrap should be able to support them soon.
08:47:50 <Deformative> That's what I feared.
08:47:55 <Deformative> My library only has volume 1.
08:48:13 <KipIngram> You can also get them from FIG assembly listings, but they're much harder to decipher that way.
08:48:15 <segher> if you want speed, you want an opcode that does MOVE with your A and B
08:48:20 <KipIngram> In FF v2 they're given as Forth definitions.
08:48:37 <segher> and FILL (with words)
08:49:12 <KipIngram> I can do move just as fast with unext and the existing instructions, because I can already operate on the memory once per clock cycle that way.
08:49:33 <segher> oh, you have insn groups
08:49:56 <KipIngram> Yes, I can have up to six opcodes in a unext loop (including the unext code).
08:50:13 <segher> that should work out fine then :-)
08:50:31 <KipIngram> Well, at the moment it has to be 4, 5, or 6, but I plan a simple optimization to allow for one-cell loops as well.
08:51:31 <KipIngram> I'm torn, though, over the conditional bit thing.
08:51:42 <KipIngram> I have 16-bit cells now.
08:51:58 <KipIngram> MSB is used to differentiate between "three opcodes" and "address."
08:52:46 <KipIngram> In the address case, the next bit down differentiates between "call" and "jump".  That gets the tail recursion case, eliminates the need for a jump opcode, etc.
08:52:54 <KipIngram> But cuts my code space in half.
08:52:56 <KipIngram> It seemed worth it.
08:53:04 <KipIngram> But now to take more bits for conditionals...
08:53:28 <Deformative> Be back later.
08:53:29 <Deformative> Class.
08:53:32 <KipIngram> Eliminates more opcodes (conditional jumps), makes code smaller and faster, etc.
08:53:40 <KipIngram> But cuts code space in half again for every bit. :-(
08:53:52 <KipIngram> With no conditionals I'm down to 32kB (16k cells).
08:54:24 <KipIngram> I can make the memory words wider (I am in an FPGA, and the RAM layout is very flexible).  For instance, I could have 18-bit cells.
08:54:33 <KipIngram> But that makes me non-standard with external memory.
08:54:47 <KipIngram> And to go to 32 bits...  seems like a really big step.
08:57:51 --- quit: Deformative (Ping timeout: 260 seconds)
09:01:02 <segher> i have relative jumps only, and usually very small
09:01:30 <segher> same for calls, but those can be bigger
09:02:21 <segher> you can do bigger jumps as   (lit) >r exit
09:06:25 <ASau`> KipIngram: using common way is easier and more portable.
09:07:08 <ASau`> FIG dictionary entries suffer from:
09:07:12 <ASau`> a) under-factoring;
09:07:33 <ASau`> b) high-bit disease;
09:07:38 <ASau`> c) isolation problems.
09:13:39 --- quit: ASau` (Quit: off)
09:15:03 --- join: Deformative (~joe@67-194-33-18.wireless.umnet.umich.edu) joined #forth
09:15:18 <KipIngram> But I have the FIG definitions available to me and I'm familiar with them.
09:15:31 <KipIngram> They represent the path of least work and resistance.
09:15:41 <KipIngram> And the portability and efficiency of my interpreter is not an issue for me.
09:15:52 <KipIngram> That will run on a host with plenty of memory.
09:16:12 <KipIngram> I'll just use it to target code onto my FPGA platform.  The interpreter itself won't run on the FPGA.
09:16:26 <KipIngram> So it's a case of "good enough is good enough."
09:38:31 <Deformative> Is it worth ordering a copy of FF2 or is there some other reasource I could easily use?
09:38:38 <Deformative> I mean, I could engineer them all myself.
09:38:46 <Deformative> That is always an option.
09:44:16 <KipIngram> Yes, you can do them yourself.  FF v2 just lets you be lazy.  You will learn more if you study FF v1 and build them yourself.
09:44:29 <KipIngram> Or do something similar with a "more modern structure".
09:44:31 <KipIngram> :-)
09:44:39 <KipIngram> I just happen to have these references handy.
09:45:10 <KipIngram> I found volume 1 "enlightening"; volume 2 was just convenient.
09:45:12 <Deformative> Mmm, sure would be nice if I could be lazy.
09:45:21 <Deformative> Because I have to assign tasks to my group members.
09:45:33 <Deformative> So it would be easy to say, "figure out how to port these words, here are examples."
09:45:56 <KipIngram> Yes, that would be easy.
09:46:37 <Deformative> I am doing all/most of the 'hard' bootstrap words.
09:46:48 <Deformative> I tried assigning one of them drivers, and he didn't do so good. :/
09:46:58 <Deformative> But he did save me quite a bit of time.
09:47:05 <Deformative> His errors were immediately fixable.
10:04:35 --- quit: Deformative (Ping timeout: 258 seconds)
10:13:19 --- join: jabb (~4a73b064@gateway/web/freenode/x-cvolnfqeaxxbgmru) joined #forth
11:03:06 --- join: qFox (~C00K13S@5356B263.cable.casema.nl) joined #forth
11:04:39 --- join: kar8nga (~kar8nga@jol13-1-82-66-176-74.fbx.proxad.net) joined #forth
11:25:32 --- join: forther (~forther@207.47.34.100.static.nextweb.net) joined #forth
11:41:06 --- quit: jabb (Quit: Page closed)
11:52:13 --- join: boscop_ (~boscop@f050146173.adsl.alicedsl.de) joined #forth
11:52:39 --- quit: boscop (Ping timeout: 260 seconds)
11:52:59 --- nick: boscop_ -> boscop
12:22:08 --- nick: Snoopy_1711 -> Snoopy_1611
12:43:58 --- quit: gnomon (Ping timeout: 264 seconds)
12:44:16 --- join: gnomon (~gnomon@CPE0022158a8221-CM000f9f776f96.cpe.net.cable.rogers.com) joined #forth
12:52:06 --- join: tgunr (~tgunr@polymicro.net) joined #forth
13:02:55 --- join: Quartus` (~Quartus`@74.198.8.57) joined #forth
13:13:52 --- join: Deformative (~joe@bursley-185022.reshall.umich.edu) joined #forth
13:52:33 --- join: crc (~charlesch@71.23.210.149) joined #forth
13:55:58 --- quit: crc_ (Ping timeout: 264 seconds)
14:03:22 --- quit: proteusguy (Ping timeout: 246 seconds)
14:16:31 --- join: proteusguy (~proteusgu@zeppelin.proteus-tech.com) joined #forth
15:09:42 --- join: skas (~skas@eth488.act.adsl.internode.on.net) joined #forth
15:10:27 --- quit: ygrek (Ping timeout: 245 seconds)
15:17:22 --- quit: skas (Quit: Leaving)
15:20:42 --- join: alex4nder (~alexander@dsl093-145-168.sba1.dsl.speakeasy.net) joined #forth
15:20:47 <alex4nder> yoh
15:45:33 --- quit: qFox (Quit: Time for cookies!)
15:49:48 --- quit: kar8nga (Remote host closed the connection)
16:13:35 --- quit: forther (Quit: Leaving)
16:16:59 --- join: skas (~skas@eth488.act.adsl.internode.on.net) joined #forth
16:36:51 --- quit: alex4nder (Quit: brb)
16:44:15 --- join: alex4nder (~user@dsl093-145-168.sba1.dsl.speakeasy.net) joined #forth
16:45:55 <alex4nder> re..
16:59:25 --- quit: madgarden (Quit: Leaving)
17:13:42 <Deformative> What would be the equivalent of : DOUBLE DUP + ; without using a colon definition?
17:14:07 <Deformative> I thought it would be like CREATE DOUBLE ' DUP , ' + , ' EXIT ,  But you cannot tick EXIT...
17:14:30 <crc> that would be implementation specific
17:15:02 <Deformative> In gforth how is it done/
17:15:04 <Deformative> ?
17:16:48 <crc> I don't know
17:17:10 <Deformative> Hmm, are there forths where CREATE DOUBLE ' DUP , ' + , ' EXIT , works?
17:18:11 --- join: madgarden (~madgarden@CPE001d7e527f89-CM00159a65a870.cpe.net.cable.rogers.com) joined #forth
17:18:40 <Deformative> Or how would it be done in most forths?
17:19:12 <crc> in retro, I can do:  create double ' dup , ' + , ' ;; execute ' .word reclass
17:19:16 <crc> or: create double ' dup , ' + , 9 , ' .word reclass
17:20:03 <crc> you can't assume that this will work on any forth
17:20:12 <crc> the threading model is not guaranteeded
17:20:14 <Deformative> Hmm.
17:20:27 <Deformative> Does CREATE's codeword by default function as a colon definition?
17:20:32 <Deformative> O.o
17:20:39 <Deformative> Probably not.
17:21:04 <crc> in retro, it creates a header pointing to here with a class of .data
17:43:24 <segher> in some Forths, you can say   CREATE double DOES> dup + ;
17:43:52 <segher> it will almost never compile to the same thing as a colon def
17:44:58 <Deformative> Why won't it compile to the same thing?
17:45:12 <segher> because it doesn't
17:46:20 <segher> well, even ignoring my obvious bug, heh
17:47:23 <Deformative> CREATE double DOES> dup + ; 3 double . redefined double  281036551842416  ok
17:47:25 <Deformative> In gforth.
17:47:25 <Deformative> I am pretty sure 281036551842416 != 6
17:47:35 <Deformative> Obvious bug?
17:47:47 <segher> you need a really good optimiser to work out that a) there is not another DOES> following; b) no data space is added later; c) both pieces of code mean the same thing
17:47:59 <segher> yes, it should be   DOES> drop dup + ;
17:48:20 <Deformative> Oh, CREATE leaves a pointer?
17:48:24 <Deformative> I forgot about that.
17:52:04 --- join: jeremy_c (jeremy@cowgar.com) joined #forth
18:09:06 <KipIngram> I think that the default behavior of a CREATEd word is just that: to put the address on the stack.  But no data space is allocated by default.
18:09:34 <KipIngram> So : VARIABLE CREATE 2 ALLOT ;
18:23:10 --- quit: alex4nder (Remote host closed the connection)
18:29:35 <segher> : CREATE  ....... DOES> ;
18:32:10 <KipIngram> ?
18:32:41 <KipIngram> That looks like a skeleton colan definition of CREATE.
18:33:10 <segher> yes
18:33:57 <KipIngram> You're saying that the definition of CREATE actually contains DOES> ?  I left my book at the office.
18:34:06 <segher> my point is that the default behaviour of a CREATEd word is exactly as-if it had an empty DOES> applied to it
18:34:20 <KipIngram> Ah.
18:34:25 <segher> it might actually be like that, it might not
18:34:38 <KipIngram> Yes, because you get the address placed on the stack anyway, and then DOES> extends that functionality.
18:34:41 <KipIngram> Sorry.
18:35:19 <segher> i actually have DOES> put that address on the stack
18:35:59 <segher> well, what is compiled by DOES> does that :-)
18:36:31 <KipIngram> Ok.
18:36:39 <KipIngram> Seems like as good a place as any to do it.
18:37:42 <segher> my CREATEd words are actually colon words :-)
18:37:57 <KipIngram> segher: were you on when I posted my final resolution of the A/B register thing?
18:37:59 <Deformative> Is there a way to do it without changing the mode to compile mode?
18:38:04 <Deformative> I want to do everything in immediate word.
18:38:16 <Deformative> s/word/mode
18:39:11 <KipIngram> Oh, yes you were I think.  You mentioned that being able to fetch from an address on the return stack was useful too.
18:39:11 <segher> kipingram: yeah think so
18:39:13 <KipIngram> Right?
18:39:19 <segher> yah
18:39:27 <KipIngram> So can you auto-increment that address?
18:39:37 <crc> Deformative: why?
18:39:51 <KipIngram> crc: I wondered why too.
18:39:58 <Deformative> I don't have compile mode setup yet.
18:40:17 <KipIngram> Oh, you're looking for the shortest path to a full system.
18:44:12 <crc> Deformative: is the interpreter finished?
18:44:38 <Deformative> crc: Depends on what you consider the interpreter.
18:45:11 <Deformative> What do you mean?
18:45:22 <crc> a searchable dictionary of names/pointers that can be called interactively and support for parsing numbers
18:45:45 <Deformative> Everything but parsing numbers.
18:46:03 <Deformative> But that's rather trivial.
18:46:04 <crc> have you decided on a threading model?
18:46:12 <Deformative> Indirect.
18:47:02 <crc> ok
18:48:45 <Deformative> So... Now what?
18:48:58 <crc> 1) a word to create a header2
18:49:07 <Deformative> CREATE, yes?
18:49:32 <crc> create is what I use
18:49:47 <crc> 2) something like ] to set the compiler flag variable to true3
18:50:22 <crc> 3) extend the interpreter loop to compile pointers to the headers found rather than calling the words if the flag is set to true
18:52:32 <crc> 3a) the interpreter also has to recognize words like ; that are immediate and execute rather than compile them
18:54:45 <crc> ; would be needed to compile the code to exit a word and set the compiler flag back to false (via ] normally)
18:54:59 <crc> that should cover the basic concept
18:59:50 <Deformative> Hm, ok.
19:00:11 <Deformative> My bootstrap is much larger than I had planned.
19:00:18 <Deformative> But I suppose that makes it faster.
19:12:35 --- join: TR2N (email@89-180-227-92.net.novis.pt) joined #forth
19:27:25 <KipIngram> How large?  Just out of curiosity.
19:49:03 --- quit: segher (Quit: This computer has gone to sleep)
19:51:36 --- join: jabb (~grue@71.94.31.166) joined #forth
19:56:43 <Deformative> KipIngram: Hm?
19:56:54 <Deformative> How large is what?
19:58:41 <crc> your bootstrap
19:59:14 <Deformative> Mmm. I cannot size it.
19:59:30 <Deformative> I have it fully utilize 16 kwords.
19:59:42 <Deformative> I mean, I can remove my buffers and things then re-assemble.
19:59:43 <Deformative> But meh.
20:53:45 --- quit: proteusguy (Read error: Operation timed out)
21:06:45 --- join: proteusguy (~proteusgu@zeppelin.proteus-tech.com) joined #forth
21:33:19 --- quit: proteusguy (Ping timeout: 276 seconds)
21:45:50 --- join: proteusguy (~proteusgu@zeppelin.proteus-tech.com) joined #forth
22:53:45 --- join: ygrek (debian-tor@gateway/tor-sasl/ygrek) joined #forth
23:59:59 --- log: ended forth/10.03.22