00:00:00 --- log: started forth/09.09.24
00:12:11 --- quit: kar8nga (Remote closed the connection)
00:14:00 --- quit: gogonkt (Read error: 104 (Connection reset by peer))
00:14:01 --- join: gogonkt_ (n=info@59.39.12.69) joined #forth
00:16:24 --- nick: gogonkt_ -> gogonkt
01:00:08 --- quit: gogonkt (Read error: 104 (Connection reset by peer))
01:01:02 --- join: gogonkt (n=info@59.39.12.69) joined #forth
01:34:29 --- join: segher (n=rehges@84-105-60-153.cable.quicknet.nl) joined #forth
02:11:40 --- quit: k-man (hubbard.freenode.net irc.freenode.net)
02:11:40 --- quit: malyn (hubbard.freenode.net irc.freenode.net)
02:11:40 --- quit: Al2O3 (hubbard.freenode.net irc.freenode.net)
02:11:40 --- quit: madwork (hubbard.freenode.net irc.freenode.net)
02:11:41 --- quit: Frek (hubbard.freenode.net irc.freenode.net)
02:11:41 --- quit: aguai (hubbard.freenode.net irc.freenode.net)
02:11:41 --- quit: schme (hubbard.freenode.net irc.freenode.net)
02:11:41 --- quit: probonono (hubbard.freenode.net irc.freenode.net)
02:11:41 --- quit: scj (hubbard.freenode.net irc.freenode.net)
02:11:41 --- quit: _Jordan_ (hubbard.freenode.net irc.freenode.net)
02:11:52 --- quit: segher (hubbard.freenode.net irc.freenode.net)
02:11:52 --- quit: ASau (hubbard.freenode.net irc.freenode.net)
02:11:52 --- quit: f[x] (hubbard.freenode.net irc.freenode.net)
02:11:52 --- quit: Snoopy_1611 (hubbard.freenode.net irc.freenode.net)
02:11:53 --- quit: uiu (hubbard.freenode.net irc.freenode.net)
02:12:07 --- quit: mathrick (hubbard.freenode.net irc.freenode.net)
02:14:44 --- quit: gogonkt (Read error: 145 (Connection timed out))
02:15:00 --- join: k-man (n=jason@unaffiliated/k-man) joined #forth
02:15:00 --- join: malyn (n=malyn@unaffiliated/malyn) joined #forth
02:15:00 --- join: Al2O3 (n=Al2O3@c-24-9-43-112.hsd1.co.comcast.net) joined #forth
02:15:00 --- join: madwork (n=madgarde@204.138.110.15) joined #forth
02:15:00 --- join: aguai (i=aguai@114-32-77-124.HINET-IP.hinet.net) joined #forth
02:15:00 --- join: Frek (n=FAAO@81-225-142-146-no36.tbcn.telia.com) joined #forth
02:15:00 --- join: schme (n=marcus@sxemacs/devel/schme) joined #forth
02:15:00 --- join: probonono (n=User@unaffiliated/probonono) joined #forth
02:15:00 --- join: _Jordan_ (n=jcooper@173-45-228-22.slicehost.net) joined #forth
02:15:00 --- join: scj (i=syljo361@static-ip-62-75-255-125.inaddr.server4you.de) joined #forth
02:15:19 --- join: mathrick (n=mathrick@users177.kollegienet.dk) joined #forth
02:16:12 --- join: gogonkt (n=info@59.39.12.69) joined #forth
02:27:12 --- quit: nighty__ ("leaving")
02:28:08 --- join: segher (n=rehges@84-105-60-153.cable.quicknet.nl) joined #forth
02:28:08 --- join: ASau (n=user@smtp.hosting.microtest.ru) joined #forth
02:28:08 --- join: f[x] (n=user@95.132.190.11) joined #forth
02:28:08 --- join: Snoopy_1611 (i=Snoopy_1@dslb-084-059-118-076.pools.arcor-ip.net) joined #forth
02:28:08 --- join: uiu (n=ian@HSI-KBW-078-042-132-111.hsi3.kabel-badenwuerttemberg.de) joined #forth
03:03:44 --- join: Qcoder00 (n=chatzill@212.225.97.124) joined #forth
03:03:49 <Qcoder00> Hi
03:04:17 <Qcoder00> Anyone here know  what COMPILE, does internally? (I am trying to extend BB4WFORTH)
03:07:37 --- join: GeDaMo (n=gedamo@212.225.115.96) joined #forth
03:13:34 <segher> in usual threaded systems, it simply takes an xt (from the data stack) and puts it in the currently being assembled definition
03:13:45 <segher> in the simplest systems, it is just the same as  ,
03:14:42 <Qcoder00> OK
03:14:58 <Qcoder00> Why is it defined seperatly though?
03:15:11 <segher> how do you mean, separately from what
03:15:28 <Qcoder00> In ANS FORTH , and COMPILE, are seperate words
03:15:32 <segher> yes
03:15:39 <segher> they aren't the same thing at all
03:15:54 <Qcoder00> OK
03:15:55 <segher> in the simplest systems, they happen to have the same implementation, that's a;;
03:15:57 <segher> all
03:16:13 <segher> compile,  adds an xt to a definition
03:16:24 <segher> ,  adds a cell to data
03:17:21 <Qcoder00> Agh...
03:17:23 <Qcoder00> :)
03:17:35 <Qcoder00> OK
03:17:44 <Qcoder00> Sorry for sounding like a noob
03:18:02 <Qcoder00> I thought COMPILE was more complex
03:18:09 <Qcoder00> COMPILE, sorry
03:18:24 <GeDaMo> It can be on some systems
03:18:28 <Qcoder00> Don't you have to check that xt points to the DOES> portion of a word though?
03:19:44 <GeDaMo> COMPILE, might generate machine code or add a node to an AST for later optimization
03:21:19 <Qcoder00> BB4WFORTH is very simple so I should be able to just do : COMPILE, , ;
03:21:40 <Qcoder00> Thanks :)
03:26:15 <ASau> It is on many systems.
03:29:25 <Qcoder00> Well I was asking about COMPILE,  because the code here uses it - http://www.jwdt.com/~paysan/screenful.html
03:30:05 <Qcoder00> I was looking at that code because it MAY simplify some coding I was planning on doing in relation to Win32 stuff :)
03:30:15 <Qcoder00> (MiniOOF in particular)
03:31:17 --- join: neceve (n=ncv@unaffiliated/neceve) joined #forth
03:47:46 --- part: Qcoder00 left #forth
04:29:06 --- quit: GeDaMo ("Leaving.")
05:08:38 --- quit: jauaor ()
05:26:59 --- quit: neceve (Remote closed the connection)
05:27:21 <gogonkt> which encode use in russia windows system?
05:28:08 <segher> you mean, what is the russian codepage for mswindows?
05:28:33 <gogonkt> M$ win
05:28:40 <gogonkt> yah
05:29:50 <segher> 1251 i think.  do you know about this thing called "google", btw?
05:30:23 <gogonkt> cp1251,thx
05:32:11 --- quit: gogonkt ("leaving")
05:32:30 --- join: gogonkt (n=info@59.39.12.69) joined #forth
05:37:59 <ASau> 1251
05:38:35 <ASau> In reality it depends on the mode.
05:38:45 <ASau> In console mode it uses cp866.
05:40:37 <gogonkt> i read in spf source ,i set wrong encoding i think
05:40:40 <gogonkt> :)
05:48:47 <gogonkt> is 1251
06:01:08 --- quit: probonono (Read error: 110 (Connection timed out))
06:12:57 --- quit: f[x] (Read error: 104 (Connection reset by peer))
06:30:10 --- join: DrunkTomato (n=DEDULO@ext-gw.wellcom.tomsk.ru) joined #forth
06:49:09 --- join: GeDaMo (n=gedamo@212.225.115.96) joined #forth
07:02:50 --- quit: gogonkt (Read error: 104 (Connection reset by peer))
07:03:35 --- join: gogonkt (n=info@59.39.12.69) joined #forth
07:35:15 --- quit: Quartus` (Read error: 110 (Connection timed out))
07:46:25 --- quit: ASau ("off")
07:51:50 --- join: gogonkt_ (n=info@59.39.12.69) joined #forth
08:00:38 --- quit: gogonkt (Read error: 110 (Connection timed out))
08:23:14 --- join: Qcoder00 (n=chatzill@212.225.97.124) joined #forth
08:23:17 <Qcoder00> OK
08:24:00 <Qcoder00> I think I've have an idea on how to do both POSTPONE and COMPILE, in BB4WFORTH
09:00:03 --- join: kar8nga (n=kar8nga@80.13.78.79) joined #forth
09:00:30 <Qcoder00> But was wondering if there was some reference implementation i could check my logic against?
09:04:29 <GeDaMo> POSTPONE is basically parse a word out of the input stream, look it up then COMPILE, the xt
09:07:00 <GeDaMo> : postpone ' compile, ; immediate
09:07:16 <GeDaMo> That's off the top of my head, not tested etc. :P
09:26:17 --- join: ASau (n=user@83.69.227.32) joined #forth
09:26:19 --- join: f[x] (n=user@95.133.197.160) joined #forth
09:37:23 --- quit: ASau (Remote closed the connection)
09:37:47 --- join: ASau (n=user@83.69.227.32) joined #forth
09:44:43 --- join: crcx (i=d8012b82@gateway/web/freenode/x-qjwkalyymqvmjgqb) joined #forth
09:47:09 * crcx doesn't know if  simple ' compile can replace postpone since postpone is supposed to lay down code for the compilation semantics of a word
09:47:45 <GeDaMo> It'll depend a lot on the implementation - Gforth complains about ticking compile-only words
09:48:39 <GeDaMo> But the principle of parse, lookup, compile should be right
09:48:55 <GeDaMo> Unless I'm missing something obvious (which wouldn't be unusual :P)
10:02:54 <Qcoder00> Question, Do Execution tokens change if there's a DOES> involved?
10:03:04 <crc> mine don't
10:03:21 <Qcoder00> Or when you query the word do you get correct xt (ie dodoes rather than docolon?)
10:03:47 <crc> my does> implementation is non-traditional
10:04:12 <crcx> I don't have a docolon or dodoes
10:04:13 <Qcoder00> BB4WFORTH currently has netiher COMPILE, or POSTPONE...
10:04:30 <Qcoder00> It uses <BUILDS ... DOES> type sysntax for some defining words
10:04:33 <Qcoder00> :(
10:04:34 <crcx> each word has a class handler associated with it; does> creates a new class and assigns it to words
10:05:00 * crcx only has POSTPONE in the ANS layer; not in the core since I don't use it
10:05:54 <Qcoder00> I've been scratching my head on and off for a few days , and having to conclude I don't understand FORTH as well as I thought I did
10:06:12 --- quit: kar8nga (Remote closed the connection)
10:07:07 <crcx> my current does> is at http://github.com/crcx/wheke/blob/master/contrib/does.retro
10:11:56 <segher> all my recent VMs have docolon only, so it's implicit even :-)
10:12:53 <Qcoder00> OK
10:13:32 <Qcoder00> I'm having to conclude I don't understand COMPILE, or DOES> well enough yet
10:13:48 <Qcoder00> So sorry for having wasted your time it seems
10:14:08 <Qcoder00> I'll probably HTH when I do work it out though
10:16:58 --- quit: Qcoder00 ("ChatZilla 0.9.85 [Firefox 2.0.0.20/2008121709]")
10:18:42 --- quit: crcx ("Page closed")
10:27:22 <segher> DOES> sure takes a while to understand, heh
10:29:10 --- join: neceve (n=ncv@unaffiliated/neceve) joined #forth
10:44:29 <I440r> qcoder does> isnt difficult to understand to USE its quite easy once you figure it out
10:44:43 <I440r> : constant crete , does> @ ; is a good example
10:45:15 <I440r> the word constant is split into two halvs. the first have creates a new constant. the second half is whats executed when you execute the constant it created
10:45:38 <I440r> does words are usualy in the form of : wordname create , does> ..... ;
10:46:19 <I440r> so the words created with them are like variables. but you also define what operation is to be performed when you reference that varible
10:47:04 <I440r> and compile and [compile] have been replaced with "postpone" these days 
10:47:13 <I440r> i hate postpone but ans fanboys love it :)
10:48:36 <I440r> the word compile is kind of easy. lets say you have a word that you are creating.  its already partially made
10:49:24 <I440r> if you execute a word  : foo compile bar ;  <--- this word has two execution tokens in it.  the first XT is 'compile'. the second xt is 'bar'
10:49:46 <I440r> when you execute that word the word 'compile' will pick up the second xt and compile it into the word that you are creating
10:50:28 <I440r> so the word compile COMPILES the next XT from the execution stream.  in the above example the word bar is NOT executed when you execute foo
10:50:52 <I440r> the word [compile] is similar except instead of taking a token out of the execution stream it parses the input stream
10:51:15 <I440r> [compile] is an immediate word so it will execute inside a : definition
10:51:18 <gogonkt_> I440r: you sould add above line too you site, I like it, easy understand :)
10:51:29 --- nick: gogonkt_ -> gogonkt
10:51:31 <I440r> its there already :P
10:51:52 <I440r> http://www.isforth.com/docs.php?t=ans&p=10
10:52:51 <gogonkt> maybe "easy understand forth words searials" is a good idea
10:53:21 <gogonkt> :P
10:53:35 <I440r> : foo [compile] bar .... ;  the definition for foo wont contain [compile] but it will contain an XT for bar even if bar is immediate
10:53:59 <I440r> which is what [compile] is for.  if bar were immediate and you didnt use [compile] then bar would EXECUTE during compilation of foo
10:54:21 <I440r> forth IS easy once you hear or figure out the explanation for it
10:54:32 <I440r> ans forth on the other hand is counter intuative
10:55:04 <I440r> i dont use words like 'postpone'. i HATE that word
10:55:16 <I440r> its an overcompication of a feature that was never broken
10:55:36 <gogonkt> yah, I need a guilder
10:55:36 <I440r> whats broken about compile and [compile] is an ans standard team that thinks were too stupid to understand them
10:55:40 <I440r> so "lets fix it" !
10:55:47 <I440r> guilder?
10:59:56 <gogonkt> road guild or ... spell wrong... - -b...
10:59:58 --- quit: DrunkTomato ()
11:00:48 <gogonkt> oh, guide
11:01:12 <gogonkt> guider :)
11:09:06 <gogonkt> I440r: can you add a example code in word explan? code easy understand than english.
11:10:37 <gogonkt> like : ' : foo compile bar ;'
11:19:33 <I440r> hi yea sorry went afk to get coffee heh
11:19:41 <I440r> and then my dad cornered me on something
11:20:15 <I440r> the definition for foo is used to compile the execution for bar into your code. tho... foo should really be immediate
11:20:22 <I440r> : foo compile bar ; immediate
11:20:33 <I440r> but this is kind of a trivial (silly) example
11:20:39 <I440r> : blah ..... foo ..... ;
11:20:50 <I440r> instead of FOO being compiled into blah the word BAR will be
11:21:36 <I440r> which kind of obfuscates whats happening so its not really a good example heh
11:21:50 <gogonkt> :)
11:22:02 <gogonkt> time to bed, nite
11:22:20 <gogonkt> 2:24 am here
11:22:36 <gogonkt> heh
11:24:24 <I440r> i should really put example usage in isforth.com some time
11:27:38 <gogonkt> I will find out how find something express in isforth.com 
11:27:53 <gogonkt> tomorror
11:28:43 <gogonkt> maybe mirror it and use GREP
11:30:29 <gogonkt> google 'Comments site:www.isforth.com' work
11:30:41 --- join: impomatic (n=John@nat66.mia.three.co.uk) joined #forth
11:31:15 <impomatic> Hi :-)
11:32:01 <gogonkt> hi
12:35:05 <flash__> :)
12:57:03 --- join: kleinjt (n=kleinjt@tarsonis.dhcp.rose-hulman.edu) joined #forth
13:27:03 --- join: kar8nga (n=kar8nga@LRouen-152-83-15-79.w80-13.abo.wanadoo.fr) joined #forth
13:38:39 --- join: ahelon (n=hmmmmm@unaffiliated/ahelon) joined #forth
13:39:21 --- quit: impomatic ("mov.i #1,1")
13:47:55 --- quit: f[x] (Read error: 110 (Connection timed out))
13:58:49 --- quit: GeDaMo ("Leaving.")
14:18:21 --- join: dgou (n=dgou@c-24-23-119-48.hsd1.pa.comcast.net) joined #forth
14:18:32 --- quit: dgou (Remote closed the connection)
14:23:01 --- join: aguai_ (i=aguai@114-36-114-96.dynamic.hinet.net) joined #forth
14:29:56 --- quit: aguaithefreak (Read error: 145 (Connection timed out))
14:32:29 <flash__> learning, from new to handle, is understanding really important? or we just need practices?
14:38:28 --- join: ENKI-][ (n=weechat@c-71-234-190-248.hsd1.ct.comcast.net) joined #forth
14:41:48 --- quit: neceve (Remote closed the connection)
14:43:07 <ASau> With compile and [compile] you have more chances to get unexpected and undesirable result.
14:43:11 --- part: drhodes left #forth
14:48:00 <I440r> yes. specially if you dont know the language in which you are programming
14:48:18 <ASau> It's not the question of language.
14:48:19 --- quit: kar8nga (Remote closed the connection)
14:48:23 <I440r> asau give me a specific instance however that backs up that claim
14:48:28 <ASau> You have to know all details of underlying layers.
14:48:43 <I440r> beacuse after almost 20 years of coding forth ive never seen a side effect of using compile or [compile]
14:48:45 <ASau> See Ertl's article.
14:48:53 <I440r> but i can see how it would confuse ans forth users
14:49:01 <ASau> That's because you didn't do complex things.
14:49:05 <I440r> oh no. we need to know what words are and are not immediate (PANIC!)
14:49:32 <I440r> if things are that complex that you cant handle the use of compile and [compile] you SERIOUSLY need to totally rethink your solution
14:49:39 <ASau> You need to know specific details of implementation.
14:49:46 <ASau> Sure.
14:50:08 <ASau> That's why you need "postpone", which solves both problems and more.
14:50:12 <I440r> asau and knowing the implementation you are using is a complete and utter NON issue
14:50:36 <ASau> That's because you didn't do complex things.
14:50:47 <I440r> you keep saying that
14:50:48 <ASau> Again, the talk isn't about implementation.
14:50:55 <ASau> It is about all details.
14:51:07 <I440r> you have no idea what i have and have not done with forth
14:51:11 <ASau> Note the word "all".
14:51:28 <ASau> If you say that you don't need "postpone", that's enough.
14:51:45 <ASau> You can program Fortran in any language.
14:51:58 <ASau> Even in Forth.
14:52:14 <I440r> postpone is a complex solution to a very simple problem that compile and [compile] can solve in a simple elegant way
14:52:16 <ASau> And (surprise!) Fortran doesn't have immediate words.
14:52:53 <ASau> "Postpone" is solution for quite another problem, which
14:52:53 <ASau> "compile" and "[compile]" handle badly if handle at all.
14:52:57 <I440r> asau your argument here is like taht old joke about how many surrealists does it take to screw in a lightbulb with the answer being "a fish"
14:53:54 <ASau> If you like to think in analogies, then think about static memory allocation.
14:54:05 <ASau> Can you program using only static allocation?
14:54:06 <ASau> Sure.
14:54:13 <ASau> But this becomes hard at some level.
14:54:31 <ASau> That's why you need dynamic allocator.
14:54:59 <I440r> you dont need one.  forth has been used to create very simple solutions to very complex problems wtih no postpone and no dynamic memory manager
14:55:02 <ASau> And this dynamic allocator voids the need for custom
14:55:03 <ASau> allocators you write in code.
14:55:14 <ASau> Sure.
14:55:21 <ASau> Again, you can write Fortran in any language.
14:56:17 <ASau> And Fortran knows nothing about immediate words.
14:56:19 <flash__> twice
14:57:12 --- join: Snoopy_1711 (i=Snoopy_1@dslb-088-068-204-165.pools.arcor-ip.net) joined #forth
14:57:25 <ASau> Fortran can't change syntax, it can't dynamically compile code.
14:57:49 <flash__> I440r, why you stop before the the compiler ? are there something, you CANT understand? or think through?
14:57:52 <ASau> There're no concepts similar to "compile" and "[compile]".
14:58:04 <ASau> But you can do anything in it.
14:58:20 <I440r> flash why i cant stop what?
14:58:35 <I440r> i didnt undestand what you just said lol
14:58:45 <flash__> :)
14:59:12 <flash__> I440r, I am finding a fast way of learning.
14:59:36 <Quiznos> he's axing why you stalled development
14:59:52 <Quiznos> flash__ his real life bytes
14:59:58 <I440r> because i need an assembler and ive had major difficulties in developing one i can use
15:00:05 <I440r> that too
15:01:00 <flash__> I440r, can you DIY one?
15:01:18 <flash__> Quiznos,  his real life bytes <-- cant understand
15:01:21 <Quiznos> he cant grok it
15:01:23 <I440r> ive tried. repeatedly. im actually trying NOW but its difficult
15:01:34 <Quiznos> flash__ s/bytes/sucks
15:01:46 <flash__> Quiznos, nod
15:02:51 <flash__> I440r, It's not difficult at all, you thought it's difficult then it will. 
15:03:12 <I440r> flash its difficult because of certain requirements i INSIST on
15:03:37 <Quiznos> he wants FPC's assembler
15:03:38 <I440r> i.e. the assembler absolutely MUST be able to take the E X I S T I N G sources and comple them, with little to no major modifications
15:04:04 <I440r> no that wont work. fpc's assembler relies on asm, list, text and headers all going into different sections
15:04:11 <Quiznos> k
15:04:33 <flash__> You are waiting for a real hardware?
15:04:40 <I440r> ?
15:04:59 <flash__>  its difficult because of certain requirements i INSIST on <--?
15:05:27 <I440r> i said. any assembler i use MUST be able to take the existing NASM soruce files and assemble them pretty much AS IS
15:05:30 <ASau> He means that he wrote a good deal of code and doesn't want
15:05:30 <ASau> to adapt it.
15:05:43 <I440r> asau for a reason
15:06:04 <flash__> ASau, lol, he is a lazy man.
15:06:13 <I440r> i dont want some bullshit "were going to change the assembly syntax to fit forth". i want an assembler that an assembly level coder will be able to use
15:06:20 --- quit: I440r ("Leaving")
15:06:31 <Quiznos> heh; well slam a guy and quit why dontcha
15:06:49 <Quiznos> i dint know he was mad at me
15:06:54 <flash__> :)
15:07:13 <ASau> No idea.
15:07:23 <Quiznos> nods
15:07:26 <ASau> I remember him writing the same isforth 7 years ago.
15:07:28 <ASau> or so.
15:07:41 <flash__> next topic, hehe
15:08:56 <flash__> How to become a COPY CAT?  learn and handle something quicker than before.
15:10:25 <flash__> I found, practices and interest .
15:14:32 --- quit: Snoopy_1611 (Read error: 110 (Connection timed out))
15:14:56 <Quiznos> personally, i think it unfortunate that Mark doesnt want to change his source to maintain his code; it might perhaps be possible to write a text to text translator to support either a new syntax or another assembler.
15:15:08 <Quiznos> he's locked in and doesnt want to change
15:15:14 <Quiznos> nor break new ground
15:17:11 <flash__> if you dig a deep hole, you cant climb up by yourself.
15:17:20 <Quiznos> nods
15:18:17 <flash__> :)
15:22:43 --- quit: ASau (Read error: 113 (No route to host))
15:32:32 --- nick: Snoopy_1711 -> Snoopy_1611
15:50:51 --- join: jauaor (n=araujo@gentoo/developer/araujo) joined #forth
16:01:17 --- join: tathi (n=josh@216.227.91.166) joined #forth
16:08:12 --- join: ASau (n=user@83.69.227.32) joined #forth
16:12:44 <jauaor> hello
16:12:47 <jauaor> mm....
16:13:02 * jauaor thinks that designing a language involves so many details :P
16:36:33 <tathi> that it does...
17:19:07 <flash__> :)
17:19:35 <flash__> hi tathi 
17:26:03 <tathi> 2hey
17:26:39 <flash__> hehe, learning forth at sting handle
17:27:51 <tathi> sting handle?
17:29:35 <flash__> nod, I want to write cgi with forth
17:29:55 <flash__> when I got some parameters, I need handle them :)
17:30:08 <tathi> ah
17:30:57 --- join: I440r (n=me@c-69-136-171-118.hsd1.in.comcast.net) joined #forth
17:31:53 <flash__> http://forth.pastebin.ca/1578539  
17:32:08 <flash__> like this
17:34:35 --- join: nighty__ (n=nighty@210.188.173.245) joined #forth
17:35:35 <Quiznos> jauaor read "thinking forth"
17:35:44 <Quiznos> about lexicon building; it's easy.
17:35:50 <Quiznos> once you can think in forth
17:36:20 <flash__> hi, I440r 
17:37:33 <I440r> hey
17:37:40 <tathi> You might have a look at `skip` and `scan`, in gforth (kernel/basics.fs)
17:45:57 <flash__> tathi, thx for advice
18:03:57 <flash__> scan is hard to understand but easy to use :)
18:07:08 <tathi> heh.  Low-level Forth words can be like that
18:08:42 <tathi> The formatting in that source doesn't help anything either.
18:10:57 <I440r> i hate clusterfuck source formatting lol
18:11:18 <Quiznos> I440r are you mad because of me?
18:11:21 <I440r> no
18:11:24 <Quiznos> ok
18:11:33 <I440r> i wasnt mad i just needed to get away lol
18:11:42 <Quiznos> your aprting comment earlier seemed to indicate otherwise
18:11:44 <I440r> im trying to write this damned assembler and im having a very difficult time
18:11:45 <Quiznos> part*
18:11:48 <Quiznos> ok
18:11:50 <I440r> nono your fine :)
18:11:55 <Quiznos> nods
18:12:03 <I440r> uim getting frustrated. not with YOU :P
18:12:28 <Quiznos> focus on the easy noomonics first; the ones that take 0-byte and 1-byte operands. 
18:12:46 <Quiznos> the bitmaps can be tackled last
18:12:54 <Quiznos> then the higher level stuff after that.
18:12:54 <I440r> no. that doesnt help
18:12:57 <I440r> those are trivial
18:13:03 <Quiznos> sure it does. it's incrementalism :)
18:13:35 <I440r> whats non trivial is supporting [reg]  or [mem]  or [reg+mem] or [reg+scale*reg+mem] or WORSE... [mem+reg*scale]
18:13:45 <Quiznos> after the 1-byes; do the ones that take offsets (jmp and mov off, reg)
18:14:10 <Quiznos> you're not partitioning the task properly then
18:14:30 <Quiznos> btw, think IN octal, NOT hex!!! when dealing with the ops
18:14:34 <Quiznos> look at the page i sent you
18:14:57 <I440r> im doing it all in octal
18:15:02 <Quiznos> partition the op-names as an enum 0..7
18:15:07 <Quiznos> and shift into position
18:15:22 <Quiznos> that's for ops < x0f and for 80xx ops
18:15:50 <Quiznos> I440r still here?
18:16:43 <I440r> off and on :)
18:16:46 <Quiznos> ok
18:16:51 <Quiznos> here's my last:
18:16:54 <Quiznos> that's for ops < x0f and for 80xx ops
18:17:22 <Quiznos> also, i find that sorting the file paragraphs by op and value helps immenely
18:17:35 <Quiznos> to get a picture of how the "masks" works within
18:17:43 <Quiznos> also sort alphabetical
18:17:46 <tathi> flash__: actually scan is pretty simple; here's the definition with a couple of comments: http://forth.pastebin.ca/1578635
18:17:59 <Quiznos> use mc's internal editor; very quik to sort
18:18:16 <flash__> tathi, thx， reading
18:19:11 <Quiznos> I440r for ops < x0f, the lowest two bits are for sign and someth else (forgot) but can be figered out by sorting
18:19:18 <Quiznos> same for x80
18:20:38 <Quiznos> I440r a question about the addresing mode might help me guide you
18:20:43 <jauaor> oh
18:20:56 <jauaor> Quiznos: thanks for the recommendation .... but i mean .. designing a new language from scratch ....
18:21:06 <flash__> I just dont understand the c@ and while loop very well. 
18:21:11 <Quiznos> jauaor huh?  (need context)
18:21:22 <Quiznos> flash__ it's a byte read from address on stack
18:21:27 <jauaor> Quiznos: right now I am designing and implementing a new language
18:21:33 <Quiznos> pop di; mov ax, [di]
18:21:44 <Quiznos> jauaor oh reading the book; and lexicons
18:21:50 <Quiznos> you really need to do that
18:21:59 <jauaor> Quiznos: oooh yes, i meant about that recommendation :)
18:22:02 <flash__> read byte by byte in the while loop ?
18:22:09 <tathi> flash__: yes
18:22:18 <flash__> :D
18:22:19 <Quiznos> flash__ reading what?
18:22:32 <tathi> the `1 /string` adds one to the address and subtracts one from the length
18:22:44 <Quiznos> why?
18:23:01 <Quiznos> a generalised `trim'?
18:23:01 <flash__> 1 /string is really cool.
18:23:12 <tathi> Quiznos: scan (and skip)
18:23:14 <I440r> its not really a LENGTH. its more accuratly a "number of characters left to parse in string"
18:23:15 <flash__> Quiznos, reading : http://forth.pastebin.ca/1578635
18:23:17 <Quiznos> or `trailing'
18:23:24 <Quiznos> i'm not surfing tonite :)
18:23:31 <jauaor> http://pastebin.ca/1578471
18:23:46 <jauaor> an example of how structs and objects look like in the language
18:24:01 * jauaor got this working yesterday
18:24:07 <jauaor> though I had to fix a bug today :P
18:24:10 <tathi> scan ( addr u char -- addr' u' )  skip leading chars not matching the delimiter.
18:25:53 --- quit: tathi ("leaving")
18:29:34 * jauaor goes and gets something to eat
18:29:40 <jauaor> brb
18:29:41 <jauaor> :)
18:42:06 <flash__> http://forth.pastebin.ca/1578635  , i cant understand why it use a second WHILE in BEGIN ... WHILE...REPEAT.
18:42:45 <flash__> a WHILE in a WHILE , makes me confuse.
18:43:13 <Quiznos> it's a double loop; just like in C
18:44:41 <flash__> I know that's a double loop; but ....   when it goes to <> while 1 /string , where will it go?
18:46:59 <Quiznos> you wrote the code, dint you?
18:47:50 <flash__> no, the scan code ,is from the source of gforth
18:49:40 <Quiznos> ok
19:27:28 --- nick: Quiznos -> PurpleSmurf
19:28:04 --- nick: PurpleSmurf -> Fire|bird
19:28:08 --- part: k-man left #forth
19:33:49 --- nick: Fire|bird -> Quiznos
19:40:56 <flash__> are there some example of : how to use hash in gforth?
20:00:21 --- part: flash__ left #forth
20:00:34 --- join: flash__ (i=flash@222.131.176.160) joined #forth
20:00:47 <flash__> where can i find the #channel of gforth?
20:01:41 * crc doesn't think there is one
20:02:57 <flash__> thx
20:03:23 <crc> ask on comp.lang.forth 
20:03:45 <flash__> ok
20:07:17 * jauaor back
20:25:31 <gogonkt> http://www.forth.org/fd/hash.html #Hashing in Forth
20:29:41 <gogonkt> http://ffl.dvoudheusden.net/docs/hnt.html #hnt - Generic Hash Table
20:31:25 <flash__> thx
20:38:06 --- quit: flash__ (Remote closed the connection)
22:06:26 --- quit: ASau ("off")
22:14:36 * madgarden is away: aseepin'
22:17:43 --- join: foxes (i=flash@222.131.176.160) joined #forth
22:30:16 --- quit: segher (Remote closed the connection)
22:45:41 --- join: zzo38 (n=zzo38@h24-207-48-53.dlt.dccnet.com) joined #forth
22:46:09 <zzo38> How to do extremely low-level FPGA programming, like just the individual gates, not VHDL or Verilog?
22:47:04 <zzo38> Also, because of the way the CHAR command and constants works in MegaZeux Forth, there is a simple way to do include once based on some quirky features
22:47:06 <zzo38>   : INCL-ONCE IF BEGIN CHAR 0= UNTIL ELSE 1 CONSTANT THEN ;
22:47:21 <zzo38> But using CHAR in Gforth doesn't act the same way. Is there a way to do like this?
22:56:39 <I440r> ok i give up on the assembler
22:56:56 <gogonkt> :P
22:57:24 <I440r> i have too much information thats just totally fucked up, slimmed down to simplify and thus leaves great big gaping fucking holes or is just totall gobbldegook
22:57:57 <zzo38> Explain?
23:02:11 --- join: neceve (n=ncv@unaffiliated/neceve) joined #forth
23:02:43 <gogonkt> i found that ffl dont compactable isforth.
23:03:44 <gogonkt> http://code.google.com/p/ffl/wiki/Engines
23:03:54 --- quit: zzo38 (Remote closed the connection)
23:04:37 <I440r> ?
23:05:05 <gogonkt> FFL will not run on the following forth engines : 
23:05:10 <gogonkt> isforth   Missing ANS words
23:05:32 <I440r> whats ffl?
23:06:01 <gogonkt> The Forth Foundation Library (FFL) is a general purpose forth library. Its main purpose is to make it easier to develop applications.
23:06:29 <I440r> erm. rite. sounds like a mountain of a solution for a mole hill problem
23:07:26 <I440r> anyway im out
23:10:27 <gogonkt> find out this when searching 'hash forth'
23:13:15 <gogonkt> in not mean good,out not mean bad :P
23:22:55 --- join: ASau (n=user@77.246.230.131) joined #forth
23:34:28 --- quit: I440r ("Leaving")
23:34:41 --- join: kar8nga (n=kar8nga@80.13.78.79) joined #forth
23:40:20 --- quit: neceve (Remote closed the connection)
23:42:25 --- quit: madgarden (Read error: 110 (Connection timed out))
23:45:24 --- join: madgarden (n=madgarde@CPE001d7e527f89-CM00159a65a870.cpe.net.cable.rogers.com) joined #forth
23:59:59 --- log: ended forth/09.09.24