00:00:00 --- log: started forth/19.01.16
00:08:40 --- quit: pierpal (Ping timeout: 268 seconds)
00:20:41 --- quit: gravicappa (Ping timeout: 244 seconds)
00:21:52 --- join: gravicappa (~gravicapp@h109-187-251-146.dyn.bashtel.ru) joined #forth
00:29:57 --- join: xek (~xek@apn-31-0-23-83.dynamic.gprs.plus.pl) joined #forth
01:52:30 --- quit: smokeink (Quit: Leaving)
02:04:20 --- quit: ashirase (Ping timeout: 258 seconds)
02:07:42 --- join: ashirase (~ashirase@modemcable098.166-22-96.mc.videotron.ca) joined #forth
02:38:59 --- join: pierpal (~pierpal@host53-189-dynamic.17-79-r.retail.telecomitalia.it) joined #forth
02:48:02 --- quit: gravicappa (Ping timeout: 258 seconds)
02:57:12 <crc> yunfan: 83.  http://forthworks.com/forth/papers/compare.pdf
03:33:04 --- quit: proteusguy (Ping timeout: 250 seconds)
03:36:03 --- join: dddddd (~dddddd@unaffiliated/dddddd) joined #forth
03:55:53 --- join: gravicappa (~gravicapp@h109-187-251-146.dyn.bashtel.ru) joined #forth
04:07:09 --- quit: pierpal (Ping timeout: 272 seconds)
04:08:13 --- join: pierpal (~pierpal@host53-189-dynamic.17-79-r.retail.telecomitalia.it) joined #forth
04:10:08 --- quit: pierpal (Read error: Connection reset by peer)
04:10:19 --- join: pierpal (~pierpal@host53-189-dynamic.17-79-r.retail.telecomitalia.it) joined #forth
05:23:31 --- quit: pierpal (Quit: Poof)
05:23:47 --- join: pierpal (~pierpal@host53-189-dynamic.17-79-r.retail.telecomitalia.it) joined #forth
05:30:40 <dave0> i tried really hard to avoid double numbers, but i caved and implemented um* and um/mod cos they're really powerful
05:31:50 <dave0> and they map well onto the mul and div instructions on x86
05:36:12 --- quit: pierpal (Quit: Poof)
05:36:29 --- join: pierpal (~pierpal@host53-189-dynamic.17-79-r.retail.telecomitalia.it) joined #forth
05:48:53 --- join: proteusguy (~proteus-b@cm-58-10-155-188.revip7.asianet.co.th) joined #forth
05:48:53 --- mode: ChanServ set +v proteusguy
05:58:56 --- quit: dddddd (Ping timeout: 258 seconds)
06:04:28 --- join: dddddd (~dddddd@unaffiliated/dddddd) joined #forth
06:04:34 --- quit: dave0 (Quit: dave's not here)
06:10:31 --- quit: pierpal (Quit: Poof)
06:10:52 --- join: pierpal (~pierpal@host53-189-dynamic.17-79-r.retail.telecomitalia.it) joined #forth
06:33:43 --- join: Kumool (~Khwerz@adsl-64-237-239-252.prtc.net) joined #forth
07:28:26 --- quit: nighty- (Remote host closed the connection)
07:30:07 --- join: tabemann_ (~tabemann@2602:30a:c0d3:1890:ed08:95af:b87f:6b5c) joined #forth
07:35:03 --- quit: tabemann_ (Ping timeout: 268 seconds)
08:04:06 * Zarutian is slowly composing an simple virtual machine runtime in a single .c file to run his forth variant
08:25:37 <PoppaVic> hm.. Muri is.. interesting.
08:26:30 <proteusguy> Muri?
08:26:45 <PoppaVic> yeah, the Nga assembler
08:26:50 <proteusguy> Zarutian, gonna be the next Jones forth? :-) 
08:28:02 <Zarutian> proteusguy: well, it is an virtual machine implementation of a canoncial dual stack machine inspired by Stackmachines The New Waves book
08:28:31 <proteusguy> Zarutian, I'm a huge fan of Koopman's work!
08:28:50 <proteusguy> You getting free function returns in your design?
08:29:06 <proteusguy> PoppaVic, I hadn't heard of Nga before remarkably. Looks cool.
08:29:53 <PoppaVic> Oh, I remember ngaro and nga from crc & retro In The Long Ago.. I just had not perused it for years.
08:30:41 <PoppaVic> Not sure I grok his 'bundles' well, though.. The "small example" is weird.
08:41:40 <PoppaVic> htm, maybe I did grok it.
08:51:44 <crc> PoppaVic: a bundle is just a group of four instructions packed into a single memory location
08:52:57 <PoppaVic> Yeah, I was having issues 'reading' the lilica.. example.. I could see the 'd' data, but the 'r' threw me for awhile.
08:53:16 <crc> ahh, r for reference to a label
08:53:31 <PoppaVic> so, it's executing the tokens, left to right - advancing the IP as required.
08:53:53 <crc> yes
08:54:10 <PoppaVic> crc: right, I had a bulb-moment and thought "using [d 'reference] would read better"
08:55:52 <PoppaVic> Not sure what END does, though - it looks like a variation on the equally irksome HALT
08:55:55 <crc> I prefer having separate handlers (simplifies parsing)
08:56:09 <PoppaVic> yeah, I got where you were going with it
08:56:33 <crc> END is used to tell the VM to shut down.
08:56:48 <PoppaVic> it's merely that it's still d)ata and 'label would reflect forth-think
08:57:01 <PoppaVic> crc: oh, exit-engine?
08:57:04 <crc> yes
08:57:08 <PoppaVic> gotcha
08:58:24 <PoppaVic> It's cute enough to warrant further examination.. My greatest bitch with working on atmega and such is suffering the goddamned compiler/linker hells.
08:59:25 <PoppaVic> "you can't do that - you need a linker script" wtf, it's a dinky little controller - just slam these bytes over there and here and..
08:59:36 <crc> I may replace END with something else in the future if the need for another instruction arises. It's mostly a carryover from the intial development work.
09:00:20 <PoppaVic> crc: yeah, it'd be a convenience for your debugging. I'd think of it as a syscall or ioctl doohicky.
09:02:01 <PoppaVic> I was going to say "where's 'branch'?" - and realized I was also staring at 'jump' - although a zjmp is also handy.. I'll be mulling over this ;-)
09:03:19 <crc> yes. I have jump, call, and conditional call. no low level conditional branch, so that's something I may want eventually.
09:04:20 <PoppaVic> Yeah.. I'm looking at it and will muse while at work. If I can get it down to a nybble of ops, it's more convenient for 16-bit tokens
09:12:39 <crc> fwiw, I have a second (older) assembler for nga as well. it's a little more conventional looking in terms of syntax.
09:13:51 <crc> https://forthworks.com/share/e8502283a6dad640bfcac05dc4d0dfa8 shows both a sample in each, side by side
09:15:23 <crc> gopher://forthworks.com/0/share/6cccf8a3b93823b8ee3b82d87761c9fe is the source. (note: this doesn't have the i/o instructions as they were added more recently)
09:23:03 <PoppaVic> yeah, I downloaded the tarball for further reading. Appreciated
09:24:03 <crc> I think if I was adapting for a 16-bit target I'd use 5 bits for the opcodes (3 per cell), leaving the last bit in the cell to allow for something like treating the entire cell as a 15-bit literal or call
09:24:30 <PoppaVic> Yeah, that was a definite possibility
09:25:13 <PoppaVic> I've been trying to get my head around the ARM and THumb stuff as well, so it became more interesting.
09:26:58 <PoppaVic> It might even be of use to consider full bytes, with opcode-fields - not sure what that would mean to the instruction-set. I need to glare.
09:41:48 --- quit: Kumool (Quit: EXIT)
09:45:53 --- join: dys (~dys@tmo-123-8.customers.d1-online.com) joined #forth
10:20:29 * PoppaVic sighs
11:27:52 --- join: Kumool (~Khwerz@adsl-64-237-239-252.prtc.net) joined #forth
11:31:02 --- quit: gravicappa (Ping timeout: 250 seconds)
11:44:08 --- quit: Kumool (Read error: No route to host)
11:44:59 --- join: Kumool (~Khwerz@adsl-64-237-239-252.prtc.net) joined #forth
12:05:41 --- quit: xek (Remote host closed the connection)
12:06:05 --- join: xek (~xek@apn-31-0-23-83.dynamic.gprs.plus.pl) joined #forth
12:48:20 --- quit: X-Scale (Ping timeout: 245 seconds)
13:13:06 --- quit: xek (Ping timeout: 244 seconds)
14:06:12 <WilhelmVonWeiner> pointfree: how would `dup` work in a FIFO? `b a dup` would leave `a b a` or `a a b`?
14:11:59 --- join: X-Scale (~ARM@46.50.7.66) joined #forth
14:13:18 <pointfree> WilhelmVonWeiner: I sometimes use a non-destructive `d@` word along with `d>` e.g, `a b d@ d>` gives `b a a`
14:14:06 <pointfree> drop can be done like this  : _ d> drop ;
14:14:44 <WilhelmVonWeiner> understanding FIFO operations is like understanding stack operations all over again
14:14:49 <WilhelmVonWeiner> but in reverse
14:14:51 <WilhelmVonWeiner> and upside down
14:15:07 <WilhelmVonWeiner> Okay I get that
14:15:35 <WilhelmVonWeiner> so `b a dup` would be `a b b`
14:16:10 <WilhelmVonWeiner> I guess dup is non-destructive so `b a b`
14:18:25 <pointfree> : d@ depth 1- pick ; ( or implement it with parameter stack pointers)
14:18:25 <pointfree> WilhelmVonWeiner: Yeah, non-destructive, that makes sense.
14:20:01 <WilhelmVonWeiner> I'm writing a c-based vm with two stacks *and* a fifo just to play with
14:20:09 <WilhelmVonWeiner> so I need to understand my fifo
14:20:49 --- quit: dddddd (Ping timeout: 246 seconds)
14:35:17 <WilhelmVonWeiner> unrelated to that, in normal Forth happenings
14:35:39 <WilhelmVonWeiner> "c@ dup 5F = if drop dup then =" turned into "c@ dup 5F = >R = R> or"
14:35:52 <WilhelmVonWeiner> came to me in a daydream about removing conditionals
14:39:22 <WilhelmVonWeiner> getting better at forth and forth-thinking
14:40:21 --- join: dddddd (~dddddd@unaffiliated/dddddd) joined #forth
14:49:35 <pointfree> WilhelmVonWeiner: filter parameters, parser combinators of sorts `2 3 4 5   2 = _ 4 = 5 = .s   ( 2 4 5 )`   `: = d@ = d> and ;`
14:51:38 <WilhelmVonWeiner> yeah was looking at my code and thinking how FIFOs takes a bunch of stuff out
14:51:56 <WilhelmVonWeiner> I use a lot of pushing and popping to manage TOS
15:00:40 --- quit: presiden (Quit: WeeChat 2.3)
15:00:45 --- quit: WilhelmVonWeiner (Remote host closed the connection)
15:12:55 --- quit: dys (Ping timeout: 245 seconds)
15:14:02 --- quit: jedb (Ping timeout: 272 seconds)
15:15:19 --- join: WilhelmVonWeiner (dch@ny1.hashbang.sh) joined #forth
15:23:23 <pointfree> Now I kinda want to set the parameter stack pointers to some string, so I can parse and pattern match on the string with regular forth words as a parameter stack/fifo. How about parsing a compiled dictionary definition this way, perhaps for an implementation of SEE?
15:29:45 --- join: presiden (fwiw@unaffiliated/matematikaadit) joined #forth
15:37:05 --- join: Croran (~quassel@2601:601:1801:6dde:a024:a39a:633c:7ee8) joined #forth
15:42:19 <WilhelmVonWeiner> I honestly have no idea what that sentence means
15:44:07 <john_cephalopoda> pointfree: Stacks usually begin at a high memory position and end at a low one. You'd have the string backwards.
15:44:41 <john_cephalopoda> pointfree: Also when you are parsing, it is really advantageous if you can move freely within the string without having to manage it like a stack.
15:44:54 <WilhelmVonWeiner> define "backwards" when you choose the order you fetch and store cells in 
15:45:26 <WilhelmVonWeiner> although, little-endian IS retarded
15:47:43 --- join: [1]MrMobius (~default@c-73-134-82-217.hsd1.va.comcast.net) joined #forth
15:48:16 <pointfree> Yeah parsing like that might clobber memory around it
15:50:36 --- quit: MrMobius (Ping timeout: 250 seconds)
15:50:36 --- nick: [1]MrMobius -> MrMobius
15:50:44 <WilhelmVonWeiner> zero-operand CPUs are awesome
15:50:46 --- join: darithorn (~darithorn@75.174.238.174) joined #forth
15:51:11 <WilhelmVonWeiner> writing one is always so enjoyable 
15:52:03 --- quit: darithorn (Client Quit)
15:56:57 --- join: dave0 (~dave0@193.060.dsl.syd.iprimus.net.au) joined #forth
15:57:24 <dave0> hi
15:58:29 <PoppaVic> heh.. I remember big-endian biting my ass with Sun & Solaris.. Getting a powerbook was useful ;-)
16:01:29 <WilhelmVonWeiner> hello dave0 what's up
16:01:39 <dave0> hi WilhelmVonWeiner 
16:03:13 <dave0> not much, i did a bit of coding yesterday
16:05:56 <dave0> i tried to NOT have any double-number words because a cell is already 64 bit and i thought leaving out double-numbers would simplify things
16:06:59 <dave0> alas i was wrong
16:07:12 <PoppaVic> heh
16:08:02 <PoppaVic> WilhelmVonWeiner: just remember, FIFO is just a queue.. You can pop/push the top; you append.. If you think 'Priority' you also want an insert
16:09:15 <dave0> if i have the choice between a stack and a queue i usually pick queue
16:09:43 <dave0> they're about as hard to code as eachother
16:09:47 <PoppaVic> <shrug> Different widgets; just slightly different/more operations
16:10:17 <PoppaVic> Certainly queues are more useful for 'events'
16:10:34 <PoppaVic> (although I suppose many would use a ring-buffer anyway)
16:12:03 <WilhelmVonWeiner> I get FIFOs are queues, it's just the order of operations is still initially a bit weird. 
16:12:16 <PoppaVic> yah
16:12:40 <PoppaVic> append/pop is your basic two.
16:12:41 <pointfree> WilhelmVonWeiner: create nums 2 , 2 , 3 , 3 , nums sp! * , * , + . ( 13)
16:13:57 <WilhelmVonWeiner> pointfree: now that would be cool
16:15:57 <pointfree> john_cephalopoda: backwards string is convenient for me
16:16:56 <PoppaVic> hey, wtf is the '~' in gforth? Bitwise inversion. INVERT seems to result in wtf.
16:17:08 <rdrop-exit> Good morning Forthwrights c[]
16:17:30 <pointfree> morning
16:17:34 <PoppaVic> I was trying to do a NAND word in gforth and wanted to punch someone - it's been that sorta' day.
16:18:06 <dave0> my gforth doesn't know ~ :-(
16:18:18 <PoppaVic> your C compiler does
16:18:41 <dave0> bitwise-not
16:19:53 <PoppaVic> hence "trying to write NAND in gforth - wtf?"
16:20:06 <rdrop-exit> : nand and invert ;
16:20:21 <PoppaVic> rdrop-exit: I tried that and it looked just.. wrong.
16:20:30 <rdrop-exit> really
16:20:37 <PoppaVic> INVERT is bitwise?
16:21:10 <rdrop-exit> I believe its the ANS standard for bitwise not
16:21:27 <rdrop-exit> I use NOT myself, but that's non-standard
16:21:39 <PoppaVic> hmm.. lemme run the test again - yeah, I aliased INVERT to NOT
16:22:10 <dave0> =0 seems to be the "logical" not
16:22:22 <rdrop-exit> 0=
16:22:26 <PoppaVic> see? makes my head explode
16:22:28 <dave0> oh heh
16:23:00 <rdrop-exit> 0= should be logical not
16:24:12 <rdrop-exit> I have all 16 dyadic bitwise operators defined in my umbilical host Forth
16:26:22 <PoppaVic> I was curious, because if you pack tokens, then NAND gets you all the binary ops.
16:27:43 <rdrop-exit> Yes, nor as well
16:27:54 <PoppaVic> correct
16:28:59 <rdrop-exit> But if you base them all off a single op, it will be slower
16:30:01 <PoppaVic> <shrug> That would not be my point. The point would be simplifying down the set of ops necessary to do the job
16:31:01 <PoppaVic> You already would be fetching 2,3,4,6 or 8 ops at a time.
16:31:13 <rdrop-exit> Here's something I posted on bitwise ops:
16:31:15 <rdrop-exit> https://www.reddit.com/r/Forth/comments/957i86/fun_with_circular_stacks/
16:33:10 <siraben> rdrop-exit:  what do you mean again by an umbilical forth?
16:33:51 <PoppaVic> the words/interpreter is on the host.
16:34:21 <rdrop-exit> AKA a tethered Forth
16:35:22 <rdrop-exit> Just a sec
16:36:03 <rdrop-exit> back
16:37:05 <rdrop-exit> You run a Forth on your PC as an IDE which you use to interactively cross-assemble/cross-compile programs on a target across a serial line
16:37:33 <rdrop-exit> SwiftX from Forth Inc is an example of an umbilical Forth
16:37:49 <rdrop-exit> https://www.forth.com/embedded/
16:38:42 <PoppaVic> well, you run "some program" on your host, anyway
16:40:30 <siraben> huh, so I guess my forth is umbilical
16:40:32 <siraben> Somewhat
16:40:36 <PoppaVic> I thought about using gforth on the host, but it just gets in my damned way. I'll likely just write someing in C and be done with it.
16:40:42 <siraben> Wait no, the assembling happens on the host for me
16:40:47 <rdrop-exit> The main purpose of the PC hosted Forth is to produce target machine code and/or target Forths.
16:41:01 <siraben> the interpreter/compiler runs on the calculator
16:41:23 <PoppaVic> siraben: sure, compiling there makes sense. The target MAY also have monitor-like support, like "3 instruction forth".
16:41:33 <siraben> 3 instruction forth?
16:41:55 <PoppaVic> Frank Sergants (sp?) article.
16:42:20 <PoppaVic> You can think of it as a bootloader/monitor, too.
16:42:34 <rdrop-exit> 3 instruction Forth is the umbilical monitor used with Pygmy Forth
16:42:43 <PoppaVic> you can tell the target to store, fetch, or execute.
16:43:04 <PoppaVic> Mind you, his target seemed to be mostly ram.
16:43:29 <siraben> I see
16:43:48 <rdrop-exit> In an umbilical Forth the host Forth dialect is used within the host development environement to communicate with targets and interactively cross-develop to targets. The code you cross-develop to a target can be anything
16:43:51 <rdrop-exit>  from minimal machine code routines to your own custom onboard
16:44:33 <rdrop-exit> Your Host Forth can be completely different from your target Forth.
16:45:06 <rdrop-exit> You can even not have a target Forth, and just cross-assemble.
16:45:50 --- join: nighty- (~nighty@b157153.ppp.asahi-net.or.jp) joined #forth
16:45:59 <rdrop-exit> For example your host Forth could be a 64 bit PC Forth, while the target is 16 bits.
16:47:18 <rdrop-exit> from minimal machine code routines to your own custom
16:47:23 <rdrop-exit>                     onboard Forth
16:48:07 <rdrop-exit> Sorry was missing the final word from earleir post
16:50:35 <rdrop-exit> The main Forth products, SwiftX from Forth Inc, and Forth 7 from MPE are both umbilical
16:52:52 <siraben> I see.
16:53:03 <siraben> What instruction set does your Forth target?
16:53:53 --- quit: Kumool (Quit: EXIT)
16:54:06 <rdrop-exit> Any really, since your host Forth can have different assembler vocabularies for different targets
16:54:21 --- join: Kumool (~Khwerz@adsl-64-237-239-252.prtc.net) joined #forth
16:54:26 --- join: jedb (~jedb@199.66.90.113) joined #forth
16:55:18 <rdrop-exit> The host Forth acts as an IDE
16:55:39 --- quit: john_cephalopoda (Ping timeout: 250 seconds)
16:57:37 --- join: john_cephalopoda (~john@unaffiliated/john-cephalopoda/x-6407167) joined #forth
16:59:07 --- join: Keshl_ (~Purple@24.115.185.149.res-cmts.gld.ptd.net) joined #forth
16:59:22 <rdrop-exit> bbiab
16:59:30 --- quit: Keshl (Read error: Connection reset by peer)
17:32:25 <PoppaVic> rdrop-exit: well, this looks like the equivs: https://pastebin.com/2sw4tCh8
17:33:02 --- quit: pierpal (Quit: Poof)
17:33:23 --- join: pierpal (~pierpal@host53-189-dynamic.17-79-r.retail.telecomitalia.it) joined #forth
17:38:47 <PoppaVic> I certainly may have screwed-up xlating from infix to postfix, but it felt right.
17:54:01 <rdrop-exit> Is it worth the trouble though, I think OR, XOR, AND are a more practical minimum bitwise operator set for an ISA.
17:54:48 <PoppaVic> very possible - still useful to know, though
17:55:18 <rdrop-exit> Yes
17:56:32 <rdrop-exit> You could leave out NOT like Chuck does, : not -1 xor ;
18:00:20 <rdrop-exit> I particularly like the effect of using a circular stack on the usefulness of certain bitwise ops
18:02:14 <rdrop-exit> On my PC forth I went the opposite direction and included all 16 dyadic bitwise operators as primitive ops
18:03:23 <dave0> i did xor as   : xor over invert over and >r over over invert and r> or ;
18:03:43 <dave0> it's pretty long for xor :-/
18:04:25 <rdrop-exit> XOR and XNOR (EQV) are the longest to synthesize from universal NAND or NOR gates
18:07:15 <rdrop-exit> All the full set of 16 can be implemented in hardware using a single word-width x 2-1 mux
18:11:54 <rdrop-exit> The wikipedia page on XOR gates has diagrams for both NAND and NOR constructions of a XOR gate:
18:12:01 <rdrop-exit> https://en.wikipedia.org/wiki/XOR_gate
18:15:52 * dave0 clicks
18:16:50 <rdrop-exit> Note the part where it says "For the NAND constructions, the upper arrangement requires fewer gates."
18:18:37 <PoppaVic> rdrop-exit: I only included them for a side-by-side compare.
18:22:00 <dave0> i think i'm going to change invert name to not
18:22:27 <PoppaVic> yeah, I dunno' wtf snowflake thought "invert" was mobetta
18:22:32 <dave0> that wikipedia page says not-gate
18:24:19 <dave0> so i will have NOT is bitwise-not and 0= is logical-not
18:24:29 <dave0> and forget about invert
18:25:08 <PoppaVic> yeah the logicals should always deal with zero and not 0
18:26:42 <rdrop-exit> In the Forth 79 standard NOT was a logical not (0=) while in the Forth 83 standard NOT was a bitwise NOT. So with the ANS standard they decided to punt by using INVERT for biwise NOT.
18:32:37 <rdrop-exit> Personally, I'm sticking to the 83 convention
18:34:36 --- join: tabemann (~tabemann@rrcs-162-155-170-75.central.biz.rr.com) joined #forth
18:36:24 --- quit: dddddd (Ping timeout: 258 seconds)
18:38:41 <PoppaVic> Yeah, I don't need a clusterfuck of commies pretending to PC-up stuff.
18:39:35 <PoppaVic> of course, I'm also partial to the C operators, so... When all else fails, write a New Standard.
18:41:48 <rdrop-exit> The Verilog operators have a nice addition to the usual C set: ~^ for XOR, and ~| for OR.
18:42:07 <rdrop-exit> Sorry ~| for NOR
18:42:25 <rdrop-exit> ~^ for XNOR
18:42:35 <PoppaVic> yeah, I was thinking that latter ;-)
18:42:47 <PoppaVic> otherwise, the pair was "wrong" lookin'
18:43:12 <rdrop-exit> :)
18:43:40 --- join: `presiden (~presiden@unaffiliated/matematikaadit) joined #forth
18:45:11 <rdrop-exit> I've always prefered the name EQV for XNOR, for bitwise equivalency.
18:45:42 <PoppaVic> I dunno XQV, and never used the latter anyway
18:45:46 <PoppaVic> EQV
18:46:37 --- quit: cheater (*.net *.split)
18:46:37 --- quit: jn__ (*.net *.split)
18:46:37 --- quit: catern (*.net *.split)
18:46:54 <rdrop-exit> It makes it easier to remember what the operator does, for each pair of incoming bits the result is 1 if they are equilavent.
18:46:59 --- join: cheater (~cheater@unaffiliated/cheater) joined #forth
18:47:06 <rdrop-exit> * equivalent
18:48:22 --- join: jn__ (~nope@aftr-109-90-232-48.unity-media.net) joined #forth
18:49:39 <rdrop-exit> Same reason I prefer ANDC to NIMP, CAND to NIF, COR to IMP, etc...
18:50:28 --- join: dddddd (~dddddd@unaffiliated/dddddd) joined #forth
18:50:40 <rdrop-exit> Easier to remember that ANDC is ANDing with a complement, then to remember what NIMP does for example.
18:51:56 <PoppaVic> those oddities make my head ache.
18:53:21 <`presiden> morning forthniter
18:53:32 <rdrop-exit> Another good example is dyadic bitwise operator #10 which is NIPC, i.e. NIP then Complement.
18:55:46 <rdrop-exit> In Forth, dyadic bitwise function #5 is actually NIP.
18:55:56 <rdrop-exit> Hi `presiden
18:58:55 <rdrop-exit> bbiab
18:59:01 --- join: catern (~catern@catern.com) joined #forth
19:33:33 <rdrop-exit> Earlier I said "word-width x 2-1 mux", meant to say "word-width x 4-1 mux"
19:36:33 --- quit: tabemann (Ping timeout: 268 seconds)
19:42:50 --- quit: dddddd (Remote host closed the connection)
19:48:37 <PoppaVic> I don't mux-about much.. It's either bits, bytes, words or cells ;-)
19:49:42 <rdrop-exit> :)
19:53:21 <rdrop-exit> I find a 2-1 cell-wide MUX operator handy to have in Forth:
19:53:59 <rdrop-exit> mux ( x1 x2 mask -- x )
19:54:19 <rdrop-exit> mux    64x2-1 mux, i.e. x=(~mask&x1)|(mask&x2)
19:55:03 <rdrop-exit> I have it as a primitive
19:55:27 <PoppaVic> I dunno, maybe if I saw the C or gforth for your set of widgets I'd be able to grok it.
19:56:19 <dave0> oh i see
19:56:32 <dave0> where there's a 0 in mask, put x1, where there's a 1 in mask, put x2
19:56:33 <rdrop-exit> The C is (~mask&x1)|(mask&x2)
19:56:46 <dave0> i've seen that in graphics
19:56:52 <rdrop-exit> exactonumdo dave0
19:57:19 <PoppaVic> oh, it's a single bit?
19:57:31 <rdrop-exit> It's basically a bitwise if-else
19:57:56 <rdrop-exit> No its a full bitwise operation
19:58:03 <rdrop-exit> cell-wide
19:58:48 <rdrop-exit> In my case 64x2-1 meaning 64 bits wide 2-1 multiplexer
20:00:15 <rdrop-exit> For each bit position, if the mask is 0 use the corresponding bit from x1, if the mask is 1 use the corresponding bit from x2
20:00:38 --- quit: `presiden (Ping timeout: 250 seconds)
20:01:02 --- join: `presiden (~presiden@unaffiliated/matematikaadit) joined #forth
20:01:42 <PoppaVic> ok, so you iterate over the cell
20:02:34 <PoppaVic> sounds very painful. I think I'd prefer a root-canal - or getting another molar pulled.
20:03:39 <rdrop-exit> No iteration, "~" and "&" in C are full-width bitwise operators just like in Forth
20:04:43 <rdrop-exit> with INVERT/NOT and AND
20:07:19 <rdrop-exit> I'll cobble together some high level "standard" Forth, just a sec
20:08:35 <rdrop-exit> warning untested:
20:08:37 <rdrop-exit>  : mux ( x1 x2 mask -- x )  dup >r and  swap r> invert and or ;
20:09:14 <rdrop-exit> Much more useful as a primitive of course
20:11:43 <rdrop-exit> The mask can have any value, not just 0 or -1
20:12:58 <rdrop-exit> Like I said it's basically a bitwise branchless if-else
20:14:06 --- join: tabemann (~tabemann@172-13-49-137.lightspeed.milwwi.sbcglobal.net) joined #forth
20:14:26 <rdrop-exit>  >offset  Replace low 10 bits of <u> with low 10 bits of
20:14:26 <rdrop-exit>           <offset>.
20:14:36 <rdrop-exit> : >offset ( u offset -- u' ) 1023 mux ;inline
20:18:51 <tabemann> hey
20:19:02 <rdrop-exit> Hi tabemann
20:19:06 * tabemann is writing a multitasker for hashforth
20:19:17 <rdrop-exit> Cool
20:19:17 <tabemann> this time it's cooperative :)
20:19:25 <rdrop-exit> Very cool
20:19:44 <tabemann> and I figured out a way to handle IO cleanly so each task thinks it has blocking IO
20:19:48 <rdrop-exit> Lunch is served. chat again later. Keep on Forthin'
20:19:53 <tabemann> see ya
20:20:06 --- quit: rdrop-exit (Quit: Lost terminal)
20:24:32 <proteusguy> everyone's doing multi-tasking now!
20:24:41 --- nick: Keshl_ -> Keshl
20:27:49 --- join: gravicappa (~gravicapp@109.187.251.146) joined #forth
20:29:30 --- quit: pierpal (Quit: Poof)
20:29:51 --- join: pierpal (~pierpal@host53-189-dynamic.17-79-r.retail.telecomitalia.it) joined #forth
20:30:12 --- quit: proteusguy (Ping timeout: 244 seconds)
20:42:53 --- quit: pierpal (Quit: Poof)
20:43:09 --- join: pierpal (~pierpal@host53-189-dynamic.17-79-r.retail.telecomitalia.it) joined #forth
20:45:34 --- join: proteusguy (~yaaic@2001:44c8:4201:8436:1:2:71d3:f3df) joined #forth
20:45:34 --- mode: ChanServ set +v proteusguy
21:36:28 --- join: dys (~dys@80.187.111.28) joined #forth
21:51:58 --- quit: Kumool (Quit: EXIT)
21:53:15 --- quit: proteusguy (Read error: Connection reset by peer)
21:53:31 --- join: proteusguy (~yaaic@mx-ll-180.183.125-167.dynamic.3bb.co.th) joined #forth
21:53:31 --- mode: ChanServ set +v proteusguy
21:57:31 --- quit: proteusguy (Ping timeout: 244 seconds)
22:00:48 --- join: proteusguy (~yaaic@2001:44c8:4201:8436:1:2:71d3:f3df) joined #forth
22:00:48 --- mode: ChanServ set +v proteusguy
22:15:24 --- join: proteus-guy (~proteus-b@mx-ll-180.183.125-167.dynamic.3bb.co.th) joined #forth
22:15:45 --- quit: proteusguy (Read error: Connection reset by peer)
22:16:01 --- join: proteusguy (~yaaic@mx-ll-180.183.125-167.dynamic.3bb.co.th) joined #forth
22:16:01 --- mode: ChanServ set +v proteusguy
22:16:13 --- quit: proteusguy (Client Quit)
22:16:25 --- nick: proteus-guy -> proteusguy
22:16:53 --- mode: ChanServ set +v proteusguy
23:14:28 --- quit: pierpal (Read error: Connection reset by peer)
23:14:37 --- join: pierpal (~pierpal@host53-189-dynamic.17-79-r.retail.telecomitalia.it) joined #forth
23:18:23 --- quit: pierpal (Read error: Connection reset by peer)
23:19:41 --- quit: dys (Ping timeout: 258 seconds)
23:59:59 --- log: ended forth/19.01.16