2023-07-27 01:57:57 <xelxebar    > That looks like Turkish.
2023-07-27 03:32:08 <iyzsong     > xelxebar: hello, yes, i did a quick fasm through jonesforth, but lost my mind during later part..
2023-07-27 03:34:34 <iyzsong     > https://git.envs.net/iyzsong/jonesforth-fasmg, should do it again later.  well i should focus on boot duskos first lol
2023-07-27 03:37:47 <siesta      > iyzsong: try camel86 forth in dos tasm
2023-07-27 03:38:06 <iyzsong     > 
ACTION search it

2023-07-27 03:38:08 <siesta      > much easier
2023-07-27 03:39:07 <siesta      > http://www.camelforth.com/page.php?7
2023-07-27 03:39:28 <iyzsong     > thx, maybe later (put in my random todos)
2023-07-27 03:40:07 <iyzsong     > i wiped freedos install on a HP t5100 (32MiB disk), and want to boot duskos, but failed :\
2023-07-27 03:40:39 <siesta      > i havent tried duskos yet
2023-07-27 03:41:13 <siesta      > but ive tried collapseos
2023-07-27 03:41:27 <siesta      > and uxn
2023-07-27 03:42:23 <iyzsong     > siesta: maybe you should try it!  I played with uxn too, but don't know what to write applications for myself yet, lacking desire..
2023-07-27 03:43:05 <xelxebar    > iyzsong: What did you find particularly brain melting about JonesForth's latter part?
2023-07-27 03:43:26 <xelxebar    > Lobbing questions here would be fun :D
2023-07-27 03:49:11 <iyzsong     > xelxebar: it's my own faults.. for longer routinue like INTERPRET, i haven't be slow enough to understand it in details, only do a quick copy/paste.  and I didn't follow the controls words (IF/UNTIL/WHILE/etc) deeply.  now i'd say i forget 80% of it, so i can't write one without look/copy from the original code.
2023-07-27 03:52:55 <xelxebar    > Yeah, not really any way around energy investment.
2023-07-27 03:53:35 <xelxebar    > Wanna join me in the SmithForth club? Can go through x86 architecture and opcode encodings and asm and sycall interface stuff together :)
2023-07-27 03:53:41 <iyzsong     > xelxebar: a qusetion for duskos, am i right to think 'd)' ( si 0 d) mov, -> mov, [si] ) can be used in realmode too?  https://git.sr.ht/~vdupras/duskos/tree/master/item/fs/asm/i386.fs#L73   the bios13.fs (which i'll try today night to see if my hardware have int13 issues) use d), but got error since it's realmode..
2023-07-27 03:54:10 <iyzsong     > that sound great! how to join?
2023-07-27 03:55:04 <xelxebar    > Unfortunately, I've not actually gotten as far as looking at DuskOS or CollapseOS. Trying to grok Forth first ;p
2023-07-27 03:55:56 <xelxebar    > Joining the club just requires dedicating actual time to trying to grok and unabashedly asking questions when you're lost.
2023-07-27 03:56:19 <iyzsong     > in this channel?  ah, okay. count me in!
2023-07-27 03:58:19 <xelxebar    > Yeah, this is as good a place as any! I just DMed you an email address where you can reach me, for more async communication when needed.
2023-07-27 04:01:17 <iyzsong     > sure, i could contact you later at home (now in working without my email access..)
2023-07-27 04:08:44 <iyzsong     > xelxebar: i'm on fediversity (https://kbin.social/u/iyzsong) and matrix too
2023-07-27 04:39:37 <xelxebar    > Nice. Just followed.
2023-07-27 04:46:01 <xelxebar    > By the way, about `jmp   0x7c00` as the first instruction, memory location 0x7c00 corresponds to "where the bootloader lives". Since the bootloader starts after bios, it has to be careful to not overwrite bios stuff, so the short answer is that it's just high enough in memory to avoid stepping on the bios' toes.
2023-07-27 04:47:05 <iyzsong     > okay, thank you :)
2023-07-27 04:48:01 <iyzsong     > well, that be wrong (jmp 0x7c00 is a halt loop there) due to the bios13.img is unable to assembly correctly..
2023-07-27 04:49:09 <iyzsong     > ofc not you said is wrong, but that instruction should be 'jmp lbstart'
2023-07-27 04:53:35 <iyzsong     > i haven't look at the encoding of 'jmp', it seems it's relavite, what happended is it get encoded as 'jmp 0' first, without a reach of 'lbstart forward!' (in duskos to rewrite the former 'jmp' instruction with current addr), so it's broken..
2023-07-27 04:53:42 <xelxebar    > Just looking at fs/xcomp/i386/pc/bios13.fs, I don't really follow. Looks like a Virgil's assembler stuff, perhaps.
2023-07-27 04:54:03 <iyzsong     > yes, it's a i386 assembler...
2023-07-27 04:55:18 <iyzsong     > assembler in 'fs/asm/i386.fs', the bios13.fs is to assemble a image for diag int13 issue which i think i'm having.
2023-07-27 04:56:03 <xelxebar    > And we se $7c00 right there on line 5.
2023-07-27 04:56:11 <xelxebar    > Ah, okay, thanks for the pointer.
2023-07-27 04:56:42 <xelxebar    > BTW, jmp is relative in normal situations, but in real mode (i.e. at boot time) it's absolute, IIRC
2023-07-27 04:57:21 <iyzsong     > oh, that may be the reason why Virgil disable d) for realmode..
2023-07-27 04:58:24 <iyzsong     > the issue is bios13.fs have 'si 0 d) mov', which failed to assemble, due to i386.fs forbidden it in the definiton of d)
2023-07-27 04:58:42 <xelxebar    > Argh. make pcrun failing to find cc.
2023-07-27 04:58:57 <iyzsong     > you can run it with 'make CC=gcc'
2023-07-27 04:59:37 <xelxebar    > Ah, good. So it does use the envar. Nice
2023-07-27 05:00:26 <xelxebar    > How did you generate the boot13.img?
2023-07-27 05:00:32 <iyzsong     > make bios13.img
2023-07-27 05:00:49 <xelxebar    > Rather, I'm not following where you see the jmp to 0x7c00.
2023-07-27 05:01:11 <iyzsong     > it's the first 2 bytes of the result bios13.img
2023-07-27 05:02:09 <xelxebar    > Oh, "bios", not "boot". I R GUD AT REEDING
2023-07-27 05:02:42 <iyzsong     > i did 'rizin -b 16 -m 0x7c00 bios13.img', then 'pd 8' to see the assembly, since i can't don't have the skill to disasm x86 instructions lol
2023-07-27 05:03:30 <iyzsong     > yeah, that's where i'm now...
2023-07-27 05:03:46 <xelxebar    > Cool. Now I'm with you. Have bios13.img.
2023-07-27 05:04:44 <iyzsong     > well, that bios13.img is incompleted, "asm error ok" in the log mean there is error, which i found..
2023-07-27 05:05:00 <xelxebar    > Whoa. You're right. EB FE, that's jmp .
2023-07-27 05:05:07 <iyzsong     > yes
2023-07-27 05:05:43 <iyzsong     > xelxebar: work done, i'll riding home now, maybe see you later :)
2023-07-27 05:05:53 <xelxebar    > iyzsong: Roger!
2023-07-27 05:05:57 <xelxebar    > Safe driving.
2023-07-27 05:44:28 <xelxebar    > This is cute, the assembly mnemonics in DuskOS are named with a trailing comma, so you write `ax bx mov, ax ax xor, ...` and the commas act as nice separators.
2023-07-27 05:49:57 <next4th     > xelxebar: hello, i'm iyzsong's another nick at home 🤓
2023-07-27 05:50:20 <xelxebar    > next4th: Welcome back.
2023-07-27 05:50:29 <xelxebar    > So I made a bit of headway into understanding things.
2023-07-27 05:51:15 <next4th     > cool, where you get?
2023-07-27 05:51:34 <xelxebar    > So pc.img works fine, but if you disassemble it with rizin, you quickly get nonsense because the top of the image has a bunch of data embedded in it.
2023-07-27 05:52:18 <next4th     > pc.img not works for my real hardware, i think it have int13h issue..  i'm about to comment out the notreal# check in d) and try bios13.img
2023-07-27 05:52:27 <xelxebar    > The jmp -2 in bios13.img is correctly disassembled, so that's still mysterious.
2023-07-27 05:53:16 <xelxebar    > Are you able to get pc.img working under qemu?
2023-07-27 05:53:22 <next4th     > yes i can
2023-07-27 05:54:23 <xelxebar    > Looking at the it's xxd output, the first jump instruction just jumps over the embedded data at the beginning.
2023-07-27 05:54:46 <xelxebar    > Following through, it's clearly just doing setup stuff like clearing regs and flags.
2023-07-27 05:54:59 <next4th     > jmp -2 is from 'forward8 jmp,', but it doesn't reach 'lblstart forward!' due to d)
2023-07-27 05:55:28 <next4th     > yes, 'jmp -2' in bios13 should be replace with 'jmp xxx' which xxx is the addr at 'lblstart forward!'
2023-07-27 05:56:48 <next4th     > yes, in duksos.img it then will read files from FAT using int13h, but on my hp t5100 thin client it just hang there..
2023-07-27 05:57:22 <xelxebar    > Maybe? The beginning of the working pc.img actually does a double jmp. Inistial instruction jumps to another jmp, which *then* hits lblstart
2023-07-27 05:58:05 <next4th     > i don't know where it hang...
2023-07-27 06:01:40 <next4th     > okay, i get bios13.img boot fine after remove 'notreal#' in 'd)'..
2023-07-27 06:03:50 <xelxebar    > next4th: Dang! You found that quick... How?!
2023-07-27 06:04:58 <next4th     > it's ': d) notreal# _d) ... ;' in i386.fs, i just remove the check with hopefully think that it will works in realmode without real understanding what _d) does...
2023-07-27 06:05:51 <xelxebar    > Ah, now pc.img is broken :P
2023-07-27 06:07:41 <xelxebar    > dip and tuck. I forgot what stack manips those were.
2023-07-27 06:08:19 <next4th     > i only know swap and over :\
2023-07-27 06:10:37 <next4th     > i think my next debug step is using bios13.img to read all sectors (ideally in the same way as pc.img) until it error or check the result with actually binary..  which seems will need a lot time 🥲
2023-07-27 06:12:05 <xelxebar    > Yeah, you seem to be making good headway, though.
2023-07-27 06:13:18 <xelxebar    > Okay, I can't get sucked deeper into this. Already have my hands in too many cookie jars.
2023-07-27 06:13:34 <xelxebar    > next4th: Let me know when you start looking at SmithForth!
2023-07-27 06:13:36 <next4th     > yeah, thank you for disscuss
2023-07-27 06:13:55 <next4th     > i could start this weekend
2023-07-27 06:15:03 <next4th     > xelxebar: sure, happy hacking, looking forward to it!
2023-07-27 09:31:43 <veltas      > KipIngram: Is there a summary somewhere of the exotic control flow words you've got?
2023-07-27 09:33:32 <KipIngram   > No, I haven't really written them up.  But they're straightfoward.  Essentially, I don't use words that "make flags" for the most part.  I combine the test and the action into single words.  The basic paradigm is illustrated by, say, =;
2023-07-27 09:33:40 <KipIngram   > That returns if the two top stack items are equal.
2023-07-27 09:34:01 <KipIngram   > I also have =;; which double returns, and =me which loops back to the start of the word if the stack items are equal.
2023-07-27 09:34:11 <KipIngram   > The items are consumed in these cases, just as you'd expect.
2023-07-27 09:34:29 <KipIngram   > If I prefix the word with a . like .=; then the deepest item that would be consumed is not.
2023-07-27 09:34:43 <KipIngram   > So A B .=; consumes B but not A.
2023-07-27 09:34:58 <KipIngram   > I cover all the cases: < <= = != >= >
2023-07-27 09:35:21 <KipIngram   > And I have the possibility of an implied 0 argument.  Those would be 0=; or .0=;
2023-07-27 09:35:49 <KipIngram   > And finally I can put a u (after the . but before the 0):
2023-07-27 09:36:04 <KipIngram   > u<; .u<; .u0<; etc.
2023-07-27 09:36:17 <KipIngram   > Actually it may be .0u<;
2023-07-27 09:36:32 <KipIngram   > I'd have to check my order on the 0 and the u - I don't use the unsinged ones very often.
2023-07-27 09:37:43 <KipIngram   > From my word list:
2023-07-27 09:37:46 <KipIngram   > .0u>me .0u>;; .0u>; 0u>me 0u>;; 0u>; .u>me .u>;; .u>; u>me u>;; u>; .0u>=me .0u>=;; .0u>=; 0u>=me 0u>=;; 0u>=; .u>=me .u>=;; .u>=; u>=me u>=;; u>=; .0u<=me .0u<=;; .0u<=; 0u<=me 0u<=;; 0u<=; .u<=me .u<=;; .u<=; u<=me u<=;; u<=; .0u<me .0u<;; .0u<; 0u<me 0u<;; 0u<; .u<me .u<;; .u<; u<me u<;; u<; .0>me .0>;; .0>; 0>me 0>;; 0>; .>me .>;; .>; >me >;; >; .0>=me .0>=;; .0>=; 0>=me 0>=;; 0>=; .>=me .>=;; .>=; >=me
2023-07-27 09:37:48 <KipIngram   > >=;; >=; .0!=me .0!=;; .0!=; 0!=me 0!=;; 0!=; .!=me .!=;; .!=; !=me !=;; !=; .0=me .0=;; .0=; 0=me 0=;; 0=; .=me .=;; .=; =me =;; =; .0<=me .0<=;; .0<=; 0<=me 0<=;; 0<=; .<=me .<=;; .<=; <=me <=;; <=; .0<me .0<;; .0<; 0<me 0<;; 0<; .<me .<;; .<; <me <;; <;
2023-07-27 09:38:24 <KipIngram   > Obviously I could have gotten by with a lot less.
2023-07-27 10:06:31 <xelxebar    > That looks pretty good. Having a solid scheme effectively reduces the space of words to the orthogonal pieces, so really you have . and me "operators", spiritually at least.
2023-07-27 10:06:42 <xelxebar    > What does me stand for, though?
2023-07-27 10:07:00 <xelxebar    > next4th: Welcome to the DuskOS ML, btw :)
2023-07-27 10:10:45 <KipIngram   > Yes.
2023-07-27 10:11:14 <KipIngram   > I generate the source for all of those with a Python script.
2023-07-27 10:11:25 <KipIngram   > Oh, me.
2023-07-27 10:11:39 <KipIngram   > Ok, so me was "inspired" by the way the word "self" is used in OO languages.
2023-07-27 10:11:51 <KipIngram   > So, it's "jump to self," but me is shorter than self.
2023-07-27 10:12:01 <KipIngram   > Me, this word that we're running right now.
2023-07-27 10:12:28 <KipIngram   > What it actually does is look in the dictionary at the most recently defined name, and jumps to its first definition cell.
2023-07-27 10:14:27 <xelxebar    > Haha. That's cute.
2023-07-27 10:15:18 <KipIngram   > I really like them.  I've used them for quite a lot of code writing now, and I don't miss IF ... THEN and so on at all.
2023-07-27 10:15:39 <KipIngram   > But you're right about "orthogonal."
2023-07-27 10:15:57 <KipIngram   > There are the conditional operations, and there are the "flow" operations ; ;; and me.
2023-07-27 10:16:11 <KipIngram   > And then 0 and . are "options."  And they all go together in pretty much any combination.
2023-07-27 10:16:46 <KipIngram   > In fact, if I look through that list I'll probably find both = and u= words, and != and u!=, which is... wrong.
2023-07-27 10:16:56 <KipIngram   > u makes no difference for =
2023-07-27 10:17:16 <KipIngram   > But I don't think I put that refinement in the script.
2023-07-27 10:17:40 <KipIngram   > It's been a while.
2023-07-27 10:17:58 <KipIngram   > It would be pretty easy to fix of course.
2023-07-27 10:18:20 <veltas      > KipIngram: Thanks for your summary
2023-07-27 10:18:27 <KipIngram   > Sure thing.
2023-07-27 10:18:42 <veltas      > I like and dislike aspects of it. I suppose my only real dislike is that there are so many of them
2023-07-27 10:18:43 <KipIngram   > Oh, and there is a header bit that I set for all these words.
2023-07-27 10:18:47 <veltas      > Otherwise I like the pattern
2023-07-27 10:18:55 <xelxebar    > Any reason you're using python to code generate those words and not forth itself?
2023-07-27 10:18:59 <KipIngram   > Well, for the me words - not for the ; and ;; words.
2023-07-27 10:19:11 <KipIngram   > The me words require an offset to be compiled after the word, and that header bit controls that.
2023-07-27 10:19:12 <veltas      > xelxebar: That assumes it's a cross forth
2023-07-27 10:19:29 <KipIngram   > It let me avoid having to do the usual dance with an immediate word and a runtime word.
2023-07-27 10:19:31 <veltas      > There's not much point writing forth building stuff in forth unless it's a cross forth, anyway
2023-07-27 10:20:03 <KipIngram   > Well, I think the idea of being able to change your system and restart with the new changes is pretty nice.
2023-07-27 10:20:05 <xelxebar    > veltas: Really? I'd assume this could also all be done at runtime as part of the initialization process.
2023-07-27 10:21:08 <veltas      > I suppose so
2023-07-27 10:22:07 <xelxebar    > KipIngram: This personal forth of yours, it's not publicly available anywhere for us to scry lessons from is it?
2023-07-27 10:54:35 <KipIngram   > :-(  No, not yet, and I've been beaten up a little over that.
2023-07-27 10:54:50 <KipIngram   > I do intend to post it, but after I'm "done."
2023-07-27 10:58:54 <KipIngram   > Well, I just downloaded the arm development toolchain; wow - lot of files in there.
2023-07-27 11:00:25 <thrig       > my god... it's full of files
2023-07-27 11:00:46 <KipIngram   > I think the big hurdle on either this ItsyBitsy M4 Express board or the Maxim one I have on order will be getting enough init in place to be able to talk with the thing over the USB serial console.  Once I can get to there, then I'll be able to use that interaction to get further - from a working serial port to a working Forth won't actually involve any further "peripheral work," so I'd later be able to use
2023-07-27 11:00:48 <KipIngram   > Forth to bring up the remaining peripherals.
2023-07-27 11:00:57 <KipIngram   > Cue the 2001 riff...
2023-07-27 11:05:10 <veltas      > What might be worth doing is just removing C code until you've got a minimal working example
2023-07-27 11:05:21 <veltas      > Then you know what you need to port
2023-07-27 11:05:27 <veltas      > 
ACTION beats up KipIngram

2023-07-27 11:05:58 <veltas      > Not sure if that's a code of conduct violation, to affectionately beat someone as an action on IRC
2023-07-27 11:07:24 <thrig       > shoving kindness
2023-07-27 11:14:53 <KipIngram   > Yeah; that might be the best way to get started.
2023-07-27 11:15:50 <KipIngram   > I felt no offense.  Skin isn't that thin...  :-)
2023-07-27 11:16:00 <KipIngram   > Earlier generation.
2023-07-27 11:18:19 <xelxebar    > KipIngram: Okey dokey. Sounds like other people have expressed interest (in various ways) already.
2023-07-27 11:19:53 <xelxebar    > Are there any canonically "top quality" forth code base that would be worth studying? I'm thinking in the same way that sqlite is considered top quality C, or xmonad good Haskell.
2023-07-27 11:52:32 <KipIngram   > I think a good first target on either of these little boards would just be an "echo function."  Be able to connect via USB serial and start typing, and have the unit echo that text right back to me.
2023-07-27 11:52:49 <KipIngram   > Once that's working, I can then "go from there" - start actually putting in Forth.
2023-07-27 11:53:02 <KipIngram   > Not Forth source - I mean the code for a Forth.
2023-07-27 15:20:03 <KipIngram   > Looks like the full details of the Maxim gadget are here:
2023-07-27 15:20:05 <KipIngram   > https://www.analog.com/media/en/technical-documentation/user-guides/max32655-user-guide.pdf
2023-07-27 15:31:57 <KipIngram   > Wow - this thing has the power supply circuitry integrated into the chip.  Just slap a lithium battery on and configure.
2023-07-27 15:32:12 <KipIngram   > Four buck switching regulators.
2023-07-27 15:34:31 <KipIngram   > Clock enables for all of the peripherals.