00:00:00 --- log: started forth/05.11.21
01:13:07 --- join: amca (n=plump@as-bri-4-1-128.ozonline.com.au) joined #forth
01:14:05 <amca> Hello
04:10:18 --- quit: amca ("d34d")
05:34:48 --- quit: ianp (Remote closed the connection)
05:35:01 --- join: ianp (i=ian@82.165.242.39) joined #forth
05:35:05 --- join: virl (n=hmpf@chello062178085149.1.12.vie.surfer.at) joined #forth
05:53:59 --- quit: Ray_work ("Stupid NetSplit")
06:15:37 --- join: Ray_work (n=vircuser@adsl-66-142-171-177.dsl.rcsntx.swbell.net) joined #forth
06:34:16 --- join: PoppaVic (n=pete@0-3pool196-197.nas30.chicago4.il.us.da.qwest.net) joined #forth
07:00:08 --- nick: Raystm2_ -> nanstm
07:07:46 --- quit: snowrichard ("Leaving")
08:19:35 <PoppaVic> The more I tinker, the more I keep seeing "Build us once to build us" *sigh*
08:38:19 --- join: snowrichard (n=richard@adsl-69-155-177-154.dsl.lgvwtx.swbell.net) joined #forth
08:42:47 --- quit: PoppaVic ("Pulls the pin...")
08:44:28 --- join: PoppaVic (n=pete@0-2pool198-103.nas30.chicago4.il.us.da.qwest.net) joined #forth
08:48:27 --- nick: virl -> opfer
08:48:36 --- nick: opfer -> virl
08:53:33 --- quit: snowrichard ("Leaving")
09:36:34 --- join: snowrichard (n=richard@adsl-69-155-177-154.dsl.lgvwtx.swbell.net) joined #forth
09:38:27 --- quit: snowrichard (Client Quit)
09:48:27 --- quit: PoppaVic ("Pulls the pin...")
11:00:27 --- join: Robert__ (n=robert@c-ac7be055.17-1-64736c10.cust.bredbandsbolaget.se) joined #forth
11:00:28 --- quit: Robert (Read error: 104 (Connection reset by peer))
11:02:36 --- nick: Robert__ -> Robert
11:56:40 --- join: snowrichard (n=richard@adsl-69-155-177-154.dsl.lgvwtx.swbell.net) joined #forth
12:22:23 --- nick: nanstm -> tiff
12:32:25 --- join: snoopy_17 (i=snoopy_1@dslb-084-058-153-165.pools.arcor-ip.net) joined #forth
12:33:11 --- quit: Snoopy42 (Nick collision from services.)
12:33:47 --- nick: snoopy_17 -> Snoopy42
14:26:34 --- join: amca (n=plump@as-bri-2-21.ozonline.com.au) joined #forth
14:29:31 --- part: amca left #forth
15:30:27 --- join: thinkinginbinary (n=tom@pool-68-163-146-102.bos.east.verizon.net) joined #forth
15:30:32 <thinkinginbinary> hey, anyone around?
15:30:35 <Robert> Yeah.
15:30:52 <thinkinginbinary> i'm working on a Forth implementation in J2ME so I can play with Forth on my phone.
15:31:41 <Quartus> That sounds painful in a number of ways.
15:31:48 <thinkinginbinary> Quartus: ;-)
15:32:01 <Robert> Forth.. pain.. Really? :)
15:32:10 <thinkinginbinary> Quartus: ((Integer)(stack.pop())).intValue() // you bet!
15:32:15 <Robert> Heh.
15:32:18 * Robert shrugs.
15:32:23 <Robert> I just did some Java homework.
15:32:27 <thinkinginbinary> I'm going to convert it to use an int array instead
15:32:49 <Robert> But since the task said that I'm allowed to rewrite the code from scratch, I did.
15:32:56 <Robert> ...and no language was specified. >:)
15:33:54 <thinkinginbinary> but anyway, i'm trying to understand the compilation vs. execution semantics of Forth... right now I handle control-flow things (like IF/THEN, BEGIN/WHILE/REPEAT, etc...) specially in the compiler.
15:34:33 <thinkinginbinary> i'd like to change it so the dictionary holds both compile-time and execute-time commands, which can also be either Java-native (for things like dup) or defined as other FORTH words.
15:34:38 <thinkinginbinary> any ideas?
15:35:31 <thinkinginbinary> i've seen a lot of explanations about how Forth does compile vs. execute semantics, but nothing that explains how things like "this instruction compiles the next word in the input stream as an execution token" are actually implemented.
15:36:25 <thinkinginbinary> I mean, if I'm making a toy Forth, is it "okay" to implement the dictionary and stack(s) as structures in the host language?
15:36:52 <Quartus> Well, what's your implementation model?  How do you lay down code?
15:37:10 <Robert> I made a simple demonstration Forth for this.
15:37:45 <Robert> << 1000 lines of code, and I started writing a tutorial about the internals.
15:37:53 <thinkinginbinary> Quartus: i have a "Code" object that holds a series of Instructions.  Instructions are (right now, subject to change) objects that hold an opcode, and optionally a String and/or int argument (the String is for forward word references... probably not needed).
15:37:59 <Robert> Not really sure how easy it is to understand.
15:38:02 <thinkinginbinary> Quartus: and the dictionary is a Hashtable of Code objects.
15:40:19 <thinkinginbinary> now, in "normal" Forth, it's impossible to refer to non-existant words, right?
15:41:30 <Robert> Well, that's pretty philosophical. ;)
15:41:33 <thinkinginbinary> so i can replace the String argument with an int, and use it to refer to an index in an array
15:41:39 <thinkinginbinary> Robert: hehe
15:41:41 <Robert> You can refer to 123 before creating it.
15:41:44 <thinkinginbinary> Robert: :-b
15:42:09 <thinkinginbinary> Robert: so an instruction can now just be a pair of ints
15:42:49 <thinkinginbinary> Robert: which could, ideally, be stored in an array instead (bytecodes with args will have the arg after them, bytecodes without will just have the next instruction [or maybe 0 if i'm lazy])
15:42:57 <thinkinginbinary> Robert: i bet this would make it faster to
15:43:15 <thinkinginbinary> now a dictionary entry needs a name, a compile/execute-time flag, and a Code reference
15:44:45 --- quit: virl (Remote closed the connection)
15:45:01 <Robert> Array of what?
15:45:07 <Robert> ints?
15:45:12 <thinkinginbinary> Robert: yeah
15:45:16 <thinkinginbinary> Robert: ooh, another idea
15:45:49 <Quartus> thinkinginbinary, no, you can't refer to nonexistant words in Forth.
15:45:56 <thinkinginbinary> Robert: Java is always signed, so positive ints will indicate user-defined words (the index into the array of words), and negative values will indicate built-in words (like dup)
15:46:05 <Quartus> Branching requires you to have a conditional branch opcode in your virtual machine.
15:46:55 <Robert> Writing a Forth in java is probably worse than writing one in BASIC.
15:47:16 <thinkinginbinary> Robert: i could implement BASIC in Java, and then Forth in BASIC, but it would be too slow :-b
15:47:24 <Quartus> I can see how you could do it, but you'd be running Forth inside a seriously rubber-walled room.
15:47:32 <thinkinginbinary> Quartus: i know ;-)
15:47:39 <thinkinginbinary> Quartus: it's only for my own amusement
15:47:46 <Quartus> It'll be slower than molassass on a February morning.
15:47:54 <thinkinginbinary> Quartus: I KNOW!
15:48:02 <thinkinginbinary> Quartus: jeez, my phone's probably like 16 MHz or something
15:48:19 <Robert> That's not bad.
15:48:21 <Quartus> Anyway, assuming you have a conditional forward and reverse branch opcode, all the conditional and branching Forth structures become trivial.
15:48:25 <thinkinginbinary> the array-of-ints one will probably be faster, just by virtue of not having to look up words all the time
15:48:27 <Robert> About the same clock speed as my 386.
15:48:58 <thinkinginbinary> Quartus: yeah, those are IF and UNTIL, right?
15:49:18 <Quartus> Right.  If you also have an unconditional branch opcode, you can use that for AHEAD and AGAIN, things like that.
15:50:28 <thinkinginbinary> Quartus: what about WHILE/UNTIL?  aren't they some combination of IF and AHEAD?
15:50:33 <Quartus> Start simply.  IF lays down a conditional branch instruction, leaving the target address blank, and puts the current address on the control-flow stack (the data stack is normally used for this purpose).  THEN picks up that address, and properly resolves the branch.
15:51:04 <thinkinginbinary> Quartus: oh, i never thought of using the data stack... well that's probably because my compiler is a separate class
15:51:29 <thinkinginbinary> Quartus: but if i'm going to represent references to other words as array indices, then it needs to be able to look inside the machine
15:51:52 <Quartus> Well, that's weird all by itself.  The stack needs to be globally accessible.  And the interpreter loop does the compiling; it's not commonly found (and certainly isn't standard) to have : do its own compilation.  It just sets a flag.
15:52:36 <thinkinginbinary> Quartus: yes, this is what i need help with... things like what ":" actually does, implementation-wise.
15:52:53 <Quartus> : creates a new header that can't yet be found in the dictionary, and sets STATE to indicate compilation.
15:53:15 <thinkinginbinary> Quartus: on a normal forth system, are things interpreted, or compiled and then run immediately?  the latter would seem easier...
15:53:17 <Quartus> That value in STATE causes the interpreter loop to compile instead of execute.
15:53:27 <thinkinginbinary> Quartus: ah
15:53:34 <Quartus> On a Standard Forth system, things are interpreted; they're not compiled and then run.
15:54:34 <thinkinginbinary> Quartus: so instead of doing instruction.execute(), it adds instruction.execute() to the word being compiled.  (basically)
15:55:28 <Quartus> ... not sure I follow.
15:55:48 <thinkinginbinary> Quartus: instead of immediately executing the instruction, it adds the instruction to the word being compiled.
15:55:59 <Quartus> Right.
15:56:04 <Quartus> That's the nature of compilation.
15:56:14 <thinkinginbinary> Quartus: so what happens when you compile a word that has no compile-time semantics?  it just compiles a instruction to execute it?
15:56:16 <Quartus> Unless the word is flagged immediate.
15:56:29 <thinkinginbinary> Quartus: wait, immediate does what?
15:56:42 <thinkinginbinary> Quartus: compile means execute when compiling.
15:56:55 <thinkinginbinary> Quartus: what's immediate then?
15:57:00 <Quartus> Hang on one sec.
15:57:40 <thinkinginbinary> Quartus: thanks for all the help... this is one of the best channels on freenode... as busy as #gentoo, without the flamewars
15:58:54 <Robert> Haha.
15:59:14 <Robert> It's a great channel, I agree.
15:59:25 <Quartus> Sorry. Here I am.  IMMEDIATE means execute when compiling.
15:59:53 <Quartus> IF, for instance, is flagged IMMEDIATE. 
16:00:58 <Quartus> Take a simple word, for instance   : foo 42 . ;    
16:01:07 <Quartus> Now, compiling foo into another word:       : bah foo ;
16:01:18 <Quartus> Here, foo is compiled as a call to foo.
16:01:33 <Quartus> If foo were flagged immediate, thusly:      : foo 42 . ; immediate
16:01:36 <Quartus> Then,      : bah foo ;
16:01:52 <Quartus> Would result in the display of 42 on the screen during the compilation of bah, and no code would be laid down for it.
16:01:55 <thinkinginbinary> Quartus: so immediate = compile-time semantics
16:02:21 <thinkinginbinary> ?
16:02:22 <Quartus> Yes, in a straightforward Forth system, immediacy is used to implement compile-time semantics.
16:02:31 <thinkinginbinary> Quartus: straightforward? ;-)
16:02:48 <Quartus> There are hairy ways to implement it too, but that's the simplest mechanism.
16:03:50 <Quartus> Quartus Forth does that, along with an 'inline' flag that causes code-copying, partly for optimization, but partly to simplify the implementation of certain words.  INLINE isn't standard or required, it could have all been done with simple immediacy.
16:04:44 <thinkinginbinary> Quartus: ooh, i was thinking about an inline flag...
16:05:08 <Quartus> I suggest you get your core compiler running properly first, hopefully passing the coretest.fs.
16:06:19 <thinkinginbinary> Quartus: comments, i assume, are done by a skip_stuff_until_end_of_comment-type flag
16:06:57 <Quartus> No.  ( parses the input buffer up to the next ), and discards it.  \ parses the entire rest of the input buffer, and discards that.
16:06:59 <Quartus> No flags.
16:07:05 <thinkinginbinary> Quartus: ah, okay
16:07:10 <thinkinginbinary> Quartus: input buffer = line?
16:07:25 <Quartus> Putting aside certain subtleties, yes.
16:07:26 <thinkinginbinary> Quartus: wait, will ) work like this: ( this is a comment with no space at the end)
16:07:30 <Quartus> Right.
16:07:47 <thinkinginbinary> Quartus: ok
16:07:59 <thinkinginbinary> Quartus: but the open parenthesis has to be a word unto itself?
16:08:02 <Quartus> Right.
16:08:10 <thinkinginbinary> Quartus: and is it normal to save comments somewhere, or do they only get kept in source?
16:08:14 <Quartus> They're not saved.
16:08:48 <Quartus>  I'm speaking of Standard Forth; if you want to implement something vaguely Forth-like of your own design, of course you can go any direction you like.
16:08:49 <thinkinginbinary> Quartus: ok
16:09:10 <thinkinginbinary> Quartus: well, i want to stay as standard as possible, but i'm not aiming for total compliane
16:09:14 <thinkinginbinary> ^vec
16:09:15 <thinkinginbinary> ^ce
16:09:18 <thinkinginbinary> jeez i can't type
16:09:25 <Quartus> You should aim for at least CORE compliance, it's really not tough.
16:09:44 <Quartus> That way you can use other people's code without having to use a shoe-horn each time.
16:10:15 <thinkinginbinary> Quartus: ok
16:10:23 <thinkinginbinary> Quartus: remember, it's a cell phone ;-)
16:10:45 <thinkinginbinary> Quartus: i assume it's good, on a small device, to just allocate a predefined stack size?
16:11:11 <Quartus> Always do that.  I don't know of any Forth system that dynamically resizes the stack.
16:11:14 <thinkinginbinary> Quartus: good
16:11:15 <Quartus> 32 elements should suffice.
16:11:23 <thinkinginbinary> Quartus: really?  only 32?
16:11:31 <thinkinginbinary> Quartus: what about return stack?
16:11:31 <Robert> Some people would say 16.
16:11:40 <Robert> 16 each will most likely be enough.
16:11:43 <Quartus> You're constrained already, and 32 is plenty for just about anything.  Return-stack, go nuts; 64.
16:11:47 <Robert> 32 each will VERY likely be enough.
16:12:01 <Robert> Unless you're doing too much non-tail recursion.
16:12:04 <thinkinginbinary> okay
16:12:12 <thinkinginbinary> Robert: how do you do tail recursion in forth?
16:12:32 <Robert> Just compile a branch to the start of the word.
16:12:44 <Robert> Using the "last" variable, usually.
16:13:01 <Quartus> Quartus Forth has a 1024-cell stack, but that's because the same stack is also used for interfacing to the Palm OS.
16:13:32 <Quartus> thinkinginbinary, tail-call elimination is an optimization you can do later, if at all -- you replace the last call in a word with a jump instead.
16:15:05 <thinkinginbinary> Quartus: um, because of the way i'm storing words, each has its own address space (each is an array of bytecodes), so i can't do that.
16:15:22 <Quartus> I fail to see why.
16:15:58 <thinkinginbinary> Quartus: each word is stored as an array of bytecodes... separate arrays, so i can't jump to the *address* of another one, since it doesn't have a global address
16:16:13 <Quartus> How do you plan to execute code, then?
16:17:13 <Quartus> Are you going to code-copy each word into each definition that uses it?
16:17:37 <thinkinginbinary> Quartus: no, each word has an id (the index into an array of word objects), and it uses those
16:17:52 <Quartus> So when you call a word from inside another word, what's your sequence of steps?
16:17:52 <thinkinginbinary> Quartus: i guess i could make a jump-to-another-word command
16:18:05 <Quartus> Well, sure you can.  A jump is just a call that doesn't store a return address.
16:18:09 <thinkinginbinary> Quartus: well this is all hypothetical, my current version looks up a String in a Hashtable ;-)
16:18:16 <thinkinginbinary> Quartus: right now, what i do is different.
16:18:42 <Quartus> Well, it would serve you well to approximate a normal Forth VM; you'll get from here to there a lot faster, and then you can start adding in funky things.
16:18:54 <thinkinginbinary> Quartus: i plan to store something like CALL_BYTECODE, <id_of_word_to_call> in the bytecode array
16:19:11 <Quartus> In a normal Forth VM, code is laid down in a contiguous memory space; doing so will make implementing control structures straightfoward, among other things.
16:19:22 <thinkinginbinary> Quartus: hmm... but then i have to explicitly allocate it
16:19:25 <Quartus> Yes.
16:19:33 <thinkinginbinary> Quartus: how big is a good size?
16:19:39 <Quartus> How much space can you afford to use?
16:19:52 <thinkinginbinary> Quartus: no clue, lemme check.
16:19:53 <Quartus> How big a Forth app do you ever expect to run on your phone?
16:19:59 <thinkinginbinary> Quartus: not very big.
16:20:04 <thinkinginbinary> Quartus: you think 4K is enough for now?
16:20:09 --- nick: tiff -> Raystm2
16:20:10 <Quartus> Sure, get yourself started.
16:20:21 <Quartus> You can pass coretest.fs in 4K.
16:20:23 <thinkinginbinary> Quartus: i gotta code a little
16:20:44 <thinkinginbinary> Quartus: okay, so somewhere i need a table of names vs. addresses of words, right?
16:20:49 <Quartus> That's the dictionary.
16:21:07 <thinkinginbinary> Quartus: yeah
16:21:07 <Quartus> Each word has a name, an address, and a flag (immediate or not).  Other things can come later.
16:21:32 <Quartus> The address of a word, in a Standard system, is called the 'xt'.
16:21:36 <thinkinginbinary> Quartus: so do you store that in the same memory space?
16:21:42 <thinkinginbinary> Quartus: execution token?
16:21:51 <Quartus> You can store the dictionary in hyperspace, if you like; it doesn't have to share space with codespace, or dataspace.
16:22:13 <thinkinginbinary> Quartus: ok
16:22:17 <Quartus> xt is execution token.
16:22:32 <Quartus> So allocate a dataspace, and a codespace.  If you wish, you can make those the same space.
16:22:40 <Quartus> If it's easier not to, you can go that way too.
16:22:53 <Quartus> The dictionary can be any convenient mechanism that behaves the way a Forth dictionary does.
16:23:01 <thinkinginbinary> Quartus: is dataspace for the stack, or for variables, or both?
16:23:35 <Quartus> The stack can be in its own space, independant of dataspace and codespace, or it can be part of dataspace; it's not important, so long as it also behaves as expected.
16:23:48 <Quartus> Dataspace is where data allocations, variables included, live.
16:23:49 <thinkinginbinary> Quartus: so then what is in dataspace?  variables?
16:23:58 <thinkinginbinary> Quartus: ok
16:25:13 <Quartus> In Quartus Forth, the stack, dataspace, codespace, and dictionary space are all separate spaces.  It doesn't have to be that way, but it works out best for Quartus Forth.  Originally, in the prototype PilotFORTH, dataspace and codespace and stack space were all one.
16:25:28 <Quartus> Dictionary space, too. 
16:25:51 <thinkinginbinary> Quartus: yeah, that seems better to be
16:25:53 <thinkinginbinary> s/be/me/;
16:26:13 <Quartus> I find it simplifies certain aspects of the implementation.
16:26:21 <thinkinginbinary> Quartus: local variables?
16:27:32 <Quartus> Forget locals for now.
16:27:35 <thinkinginbinary> Quartus: ok
16:28:03 <Quartus> Focus on CORE.
16:28:13 <thinkinginbinary> Quartus: ok
16:28:36 <Quartus> I'm not suggesting Standard Forth is the only way to go -- but starting there means you know when you've got it working, and you can use that as a reference implementation.
16:30:55 <thinkinginbinary> Quartus: okay, so when it loads, i define things like "+" as words that just execute the bytecode for +?
16:31:23 <Quartus> + has to be a routine that adds the top two values on the stack together, and leaves the result there.
16:31:44 <Quartus> How you cause that to happen I can't say, can't see your implementation from here. :)
16:33:30 <thinkinginbinary> Quartus: how do you keep track of the location into which you're compiling a word?
16:33:38 <thinkinginbinary> Quartus: the program counter?
16:34:02 <Quartus> The codespace pointer.
16:34:14 <Quartus> In Quartus Forth I call it cshere, to differentiate it from the dataspace pointer called HERE.
16:35:47 <thinkinginbinary> Quartus: how do you clean out old versions of words?
16:35:57 <Quartus> You restart the compiler.
16:36:15 <thinkinginbinary> Quartus: you mean like recompiling everything?
16:36:27 <Quartus> There's a Standard mechanism called MARKER that lets you roll the whole dictionary state back to a marked point, but you don't neccessarily need it.
16:36:34 <Quartus> thinkinginbinary, yes. Forth compilation is really, really fast.
16:47:50 * Raystm2 says " neat convo"
16:48:00 <Raystm2> hi Quartus hi Robert hi thinkinginbinary :)
16:48:16 <Robert> Hi, Ray.
16:48:42 <Raystm2> How have you been Robert, it's been a couple weeks since i've personally heard from you?
16:48:44 * Robert yawns a bit, 2am here... maybe bedtime is soon. :)
16:49:10 <Quartus> Hi rRay.
16:49:15 <Robert> Yeah, I've been pretty busy with schoolwork, and other non-Forth tasks. But lately I've been doing fun things again.
16:49:34 <Raystm2> good. :)
16:50:23 <thinkinginbinary> Quartus: how does : fetch the name of the new word.
16:51:11 <Quartus> Parses it from the input buffe.
16:51:12 <Quartus> r.
16:51:44 <thinkinginbinary> Quartus: but how does an instruction access the input buffer?
16:51:49 <Raystm2> : = immediate word that works on the input stream?
16:52:06 <Quartus> The input buffer is a globally accessible section of dataspace.
16:52:10 * Raystm2 plays devils advocate.
16:52:12 <Quartus> Raystm2, yes.
16:52:19 <Quartus> Raystm2, sorry, no. Not immediate.
16:52:32 <Raystm2> excellent
16:53:14 <Raystm2> its a called word that works on the input stream?
16:53:29 <thinkinginbinary> Quartus: but how, mechanically, does : access it?
16:54:25 <Quartus> By calling a word that's usually called PARSE-WORD, that fetches the subsequent characters from the input buffer (indexed to by the >IN variable) until it reaches the next whitespace character.
16:55:08 <Quartus> PARSE-WORD returns a c-addr and u on the stack; the c-addr is the dataspace character address of the name in the input buffer, and u is its length.
16:55:21 <thinkinginbinary> Quartus: that's messy... i'm going to implement ":" in Java ;-)
16:55:23 <Raystm2> could that also be named WSPARSE in some forths ( for white-space-parse)?
16:56:10 <Quartus> thinkinginbinary, you stand no chance of implementing a compliant CORE system without a normally-accessible input buffer.  Also, being able to access the input buffer opens up a range of programming techniques you'll be cutting yourself off from.
16:56:39 <Quartus> If you want Forth, go Forth.
16:56:55 <Quartus> If you want something faintly Forth-like, you'll be missing the boat.
16:57:09 <thinkinginbinary> Quartus: where is CORE, so i can read it?
16:57:15 <Quartus> http://quartus.net/dpans
16:58:34 <thinkinginbinary> Quartus: i think, just to make this reasonably fast on a phone, i'm going to have to sacrifice full CORE compatibility
16:58:58 <thinkinginbinary> Quartus: i mean, parsing the input buffer using Forth will probably be 10x slower than parsing it using Java.
16:59:06 <Quartus> You'll be surprised.
16:59:07 <Raystm2> I'm not conversant in Quartus' forth for the PALM but it sounds like your doing a similar task, 
16:59:20 <thinkinginbinary> Raystm2: yeah, for J2ME on phones
16:59:44 <Raystm2> another great forth to get ideas from is RETROFORTH by Charles Childers over at /join #retro.
16:59:57 <thinkinginbinary> Quartus: if DUP is a word, what is "DUP" in the input buffer called?  a token?
17:00:07 <Quartus> Parsing source is not a heavyweight undertaking in Forth. Stay with the standard mechanisms, if it falls over, then optimize accordingly. It won't fall over.
17:00:26 <Quartus> DUP is the name of a word.  It's called a name.
17:00:30 <thinkinginbinary> oh ok
17:00:56 <Quartus> I advise you not to optimize prematurely, and not to eliminate fundamental components of Forth before you've had the chance to understand why they're there.
17:01:48 <Quartus> Or you'll wind up with something faintly Forth-like, but without the power.
17:01:54 <Raystm2> A very interesting aspect of the current generation of Retroforth for version 8.3 and beyound is the something called the Rx core.
17:02:04 <Raystm2> it has no i/o, you bring that yourself.
17:02:11 <Raystm2> it has everything else, 
17:02:15 <Raystm2> even moduals for ans
17:02:21 <Raystm2> modules even
17:03:37 <Quartus> afaik complete compliance isn't a goal for rf, which is fine -- but thinkinginbinary is starting out with his first Forth.
17:03:38 <Raystm2> This means that if you can do the i/o and then use the retro core, you will pretty much have accomplished your task.
17:03:54 <Quartus> Isn't the rf core x86-specific?
17:04:02 <Raystm2> there is that ;)
17:04:29 <Raystm2> but i'm sure crc would be interested in the project and would advise.
17:04:40 * Raystm2 speaking for others again
17:04:58 <Raystm2> still, I bet he'd be interested in getting his forth on a phone.
17:09:53 <thinkinginbinary> Quartus: what's a good thing to print when a word is unknown?
17:11:08 <Quartus> Undefined word
17:11:17 <thinkinginbinary> Quartus: and the word i assume
17:11:51 <Raystm2> some forths print the word followed by a question mark
17:12:12 <thinkinginbinary> Raystm2: ooh, that sounds good
17:12:46 <Quartus> Usually the word, yes. Early forths just used the ?.
17:13:20 <Quartus> Standard Forths with exception handling have it defined as one of the standard error strings, so that gets used instead. 
17:13:56 <thinkinginbinary> Quartus: would it be reasonable to define that each "byte"code is a pair of ints (bytecode and arg)
17:14:08 <Quartus> That entirely depends on how you're setting up your vm.
17:14:23 <Quartus> Lots of opcodes in a Forth vm don't need args.
17:14:43 <Quartus> Explicit ones, that is. Implicit args come from the stack.
17:14:59 <thinkinginbinary> Quartus: that's true, most won't
17:15:19 <thinkinginbinary> Quartus: what's the size (in bytes) of numbers on the stack?
17:16:17 <Quartus> Depends on your cell-width.  16-bits is a minimum, you'll probably want 32-bits, which means a 4-byte wide cell.
17:17:07 <thinkinginbinary> Quartus: okay
17:17:13 <thinkinginbinary> Quartus: that's, i think, what an int is anyway
17:17:14 <Raystm2> How big are the registers on the phone? isnt that the determination for bit-width?
17:17:23 <thinkinginbinary> Raystm2: registers?  i'm programming in java.
17:17:25 --- quit: snowrichard ("Leaving")
17:18:36 <thinkinginbinary> Quartus: ooh, i'll encode whether an instruction takes an arg in a bit of its opcode!
17:18:53 <Raystm2> Okay, I suppose in a vm, a "register" can be as big as you want, but to optimize, wouldn't you need to know the register width?
17:19:11 <Quartus> He'll never get down that far.
17:19:18 <Quartus> He's working with mittens on.
17:19:22 <thinkinginbinary> Quartus: ;-)
17:19:26 <Raystm2> :)
17:19:31 * Raystm2 needs mittens, 
17:19:46 <Quartus> Put it this way, you'd never write a Java VM in Java for a phone, would you?
17:19:46 <Raystm2> thinkinginbinary, sell me yours when you're done?
17:19:51 <thinkinginbinary> Raystm2: sell?
17:20:03 <thinkinginbinary> Raystm2: it's going to be open-source probably.
17:20:31 <Raystm2> I've not written my first forth yet, I need mittens. I've paid for books, i'd pay for mittens.
17:20:45 <thinkinginbinary> Raystm2: wait, i'm not writing the mittens
17:20:58 <thinkinginbinary> Raystm2: i'm just writing a non-standard Forth for a cell phone
17:21:01 <Raystm2> they came with the phone.
17:21:27 <Quartus> No, he's writing Forth on top of a Java VM, which is a fantastically unfortunate choice of platform, necessary though it may be.
17:22:09 <Raystm2> Java on a phone. No freaking wonder...
17:22:26 <Quartus> ]That's the mittens.  I mean he can't handle small details deftly.  
17:22:30 <Raystm2> I often wondered what phones were written in.
17:22:43 <Raystm2> right, i got the mittens right off the bat.
17:23:41 <Raystm2> Why, why why....
17:24:10 <Raystm2> Why doesn't a bunch of highly trained forth coders just get off there lazy duffs and re-code the world?
17:24:16 <thinkinginbinary> Raystm2: ;-)
17:24:43 <Raystm2> CM been talking about a colorforth browser for like 5 years...
17:25:21 <Raystm2> any body get to go to svfig?
17:25:40 <Raystm2> I threated to fly out there...
17:26:19 <Raystm2> threatened even?
17:27:01 <Raystm2> instead, i've decided to re-pipe the entire house.
17:28:40 <Raystm2> Re-code the world project. I either have to be a "stuffed shirt" ( as i'm highly trained in that dept) or an intern, work for nothing.
17:29:34 <Raystm2> So, in an effort to get some kind of pay, i'll be the COO.
17:29:47 <Raystm2> Whose CIO?
17:30:00 <Raystm2> oops Who's CIO?
17:32:35 <thinkinginbinary> Quartus: when you recognize a word, you take the address, and you either jump to it or add it to the word being created... but if you encounter a number to be pushed, what do you do?
17:32:57 <Raystm2> goes on the data stack
17:33:08 <Raystm2> tipically with a word like >number
17:33:15 <OrngeTide> CH Ting has some $50 ForthStamp boards: http://www.forth.org/svfig/kk/11-2005.html (about 1 page down)
17:33:35 <Raystm2> Oh wow! thanks OrngeTide :)
17:33:37 <OrngeTide> it's just an ADuC7020 on a tiny little PCB
17:33:37 <Quartus> If executing, you put the number on the stack using the current value of BASE.  If you're compiling, you compile code that will later place that value on the stack.
17:33:53 <OrngeTide> with a forth Ting ported to it
17:34:11 <Quartus> <python> I see you have the Forth that goes 'Ting'! </python>
17:34:22 <OrngeTide> ahha
17:34:30 <Raystm2> lollollollol
17:35:01 <OrngeTide> I assume it's just a port of eForth.
17:36:17 <Quartus> Likely.
17:43:30 <thinkinginbinary> Raystm2: but how does >number get *its* argument?
17:45:06 <Quartus> See above.  parse-word returns a c-addr u from the input buffer.
17:47:47 <Quartus> The Forth system relies on its own words to operate; those same facilities are also available to the developer.
18:21:57 <thinkinginbinary> Quartus: question... if already-defined words refer to word FOO by its address in codespace, and i redefine FOO, the new version is at a new address... how does it know to use the new one?
18:22:40 <thinkinginbinary> Quartus: you there?
18:36:57 --- join: snowrichard (n=richard@adsl-69-155-177-154.dsl.lgvwtx.swbell.net) joined #forth
18:42:07 <Quartus> Yes, sorry.
18:42:24 <Quartus> It knows to use the new one because that's the one the dictionary returns on a search.  New names override old ones.
18:43:34 <Quartus> To clarify, if I do      : foo 42 . ;  : bar foo ;  : foo 23 . ;
18:43:47 <Quartus> bar will print 42, not 23. It uses the old definition. There's no retroactive fixup.
18:50:00 --- quit: snowrichard ("Leaving")
18:53:50 <thinkinginbinary> Quartus: are you serious?!?
18:54:07 <thinkinginbinary> Quartus: that's insane, you have to reinstall every piece of code that uses a word when you change it?
18:54:19 <thinkinginbinary> Quartus: is that a feature, a bug, or a problem?
19:05:46 <thinkinginbinary> Quartus: you there?
19:05:57 <thinkinginbinary> Quartus: if i were to implement an input buffer 
19:06:05 <thinkinginbinary> Quartus: how would i allocate it to avoid overwriting variables?
19:09:46 --- join: swalters (n=swalters@6532183hfc82.tampabay.res.rr.com) joined #forth
19:22:13 --- quit: thinkinginbinary ("leaving")
19:37:05 <Quartus> Impatient fellow.
19:41:52 <_james> heh
19:46:27 <Quartus> It's hard to know where to start... I don't know why some folks want to implement Forth before they've ever used it.
20:15:43 --- join: FiLa (i=LNIX@12-208-98-237.client.insightBB.com) joined #forth
20:30:19 --- join: airbrush (n=morph@216-237-213-157-access-r24-ad.northstate.net) joined #forth
21:26:34 --- quit: saon (Read error: 110 (Connection timed out))
21:29:00 --- quit: saon|fbsd (Read error: 110 (Connection timed out))
21:32:08 --- join: tathi (n=josh@pdpc/supporter/bronze/tathi) joined #forth
21:46:55 --- quit: tathi ("leaving")
23:15:08 --- part: airbrush left #forth
23:59:59 --- log: ended forth/05.11.21