00:00:00 --- log: started retro/12.12.14
02:24:52 --- quit: harrison (Ping timeout: 240 seconds)
03:31:23 --- quit: karswell_ (Ping timeout: 255 seconds)
03:35:52 --- join: karswell_ (~coat@93-97-29-243.zone5.bethere.co.uk) joined #retro
05:43:21 <crc> tangentstorm: in the pl0 compiler, test 10 fails  (see http://sprunge.us/ddCN )
05:49:54 <tangentstorm> nice
07:05:09 <tangentstorm> okay. i just enhanced that the test script so you don't have to run the test files manually anymore
07:05:17 <tangentstorm> now to actually fix the compiler :)
07:12:45 <beretta> 'morning tangentstorm 
07:37:18 <tangentstorm> hey beretta 
07:38:45 <tangentstorm> crc : should all be working again now : https://github.com/tangentstorm/PL0-Language-Tools/commit/b7dabd3b7d8632c14ea028e31f964aed78f7a593
07:44:44 <tangentstorm> hmm. nope. still broken.
07:45:06 <tangentstorm> it doesn't complain but it puts the constant's name instead of the actual value
07:50:43 <tangentstorm> ok. fixed, and also added expected *.rx output for all the test programs
09:16:53 --- join: harrison (~quassel@li89-226.members.linode.com) joined #retro
09:35:18 <crc> tangentstorm: looks good
09:45:32 <crc> tangentstorm: I ported the changes to the parable implementation
09:46:56 <tangentstorm> :)
10:28:41 <crc> now I'm looking at plzero.pas, wondering if I can adapt that to generate parable/retro code...
11:46:10 <tangentstorm> it should be pretty close to the python version, except for the comment syntax.
11:46:18 <tangentstorm> his oberon0 language is a little bit more advanced, with records and arrays.
11:46:44 <tangentstorm> http://www.inf.ethz.ch/personal/wirth/Articles/CompilerConstruction/index.html
11:50:27 --- join: kumul (~kumul@cvx-ppp-66-50-141-36.coqui.net) joined #retro
12:32:36 --- quit: tangentstorm (Ping timeout: 250 seconds)
12:37:21 --- join: tangentstorm (~michal@108-218-151-22.lightspeed.rcsntx.sbcglobal.net) joined #retro
12:49:38 --- join: intothev01d (~intothev0@unaffiliated/intothev01d) joined #retro
14:08:05 --- join: Mat2 (~Claude@91-65-144-133-dynip.superkabel.de) joined #retro
14:08:22 <Mat2> hello
14:10:52 <tangentstorm> heya :)
14:13:49 <Mat2> hi tangentstorm
14:14:11 <Mat2> I hope you have relaxed a bit
14:14:37 <tangentstorm> yeah :) i don't really feel prepared for ludum dare here but my eyeballs have recovered :)
14:22:11 <Mat2> that's good
14:23:26 <Mat2> I'm just back from work and hungry so take a little break in the kitchen
14:23:37 --- nick: Mat2 -> Mat2-lunch
14:39:59 --- nick: Mat2-lunch -> Mat2
14:50:05 <Mat2> so, what are your plans for ludum ?
14:54:42 <tangentstorm> good question :)
14:55:08 <Mat2> pac-man or pong ?
14:56:05 <tangentstorm> i did kind of like the text adventure game idea, but i'm not married to it
14:56:19 <tangentstorm> getting a sprite engine working with retro would be cool too :)
14:56:50 <tangentstorm> kind of just depends on who all shows up and what they want to do :)
14:58:32 <Mat2> the problem I see is the time left before this contest start
14:58:55 <Mat2> I will see what I can do
14:59:31 <tangentstorm> well i was planning to do the 72-hour jam, and to aim pretty low on the game no matter what it is
14:59:46 <tangentstorm> i want to ship a simple game but mostly focus on the tools
15:00:26 <Mat2> ok, let's take the pascal vm and write a shape engine first, that should be easy
15:00:50 <Mat2> retro would be a good fit for an adventure
15:00:54 <tangentstorm> what kind of shapes?
15:02:08 <Mat2> rectangular shapes, some graphics which can be mapped onto a screen though a simple xor operation
15:02:41 <Mat2> this is fast, easy and monochrome
15:03:00 <Mat2> and exactly the way prites are simulated on the zx spectrum
15:03:11 <Mat2> ^sprites
15:03:23 <Mat2> the rest is art design
15:03:35 <tangentstorm> we could also use http://zengl.org/ :)
15:08:38 <tangentstorm> not interested?
15:16:06 <Mat2> looks nice, I stundy the interface
15:17:20 <Mat2> ok, let's use it
15:17:21 <tangentstorm> what if we had some ram inside of retro set aside for "video memory"
15:17:30 <tangentstorm> but instead of drawing pixels...
15:18:22 <tangentstorm> we could just have a big array of ( x, y, dx, dy, sprite_id ) records or something?
15:18:31 <Mat2> the video memory is already there but indirectly addressed though the VDP code
15:20:43 <Mat2> accessing is done similar to the real v98xx chip of the msx2 series
15:20:44 <tangentstorm> i guess i'm not really talking about video ram... i don't know what to call it
15:21:02 <tangentstorm> like a hardware sprite device
15:22:38 <Mat2> you want to reserve some ports as interface for acessing sprites though coordinates ?
15:22:52 <Mat2> sounds like a vertex buffer
15:22:53 <tangentstorm> yeah, but not necessarily a port
15:23:21 <tangentstorm> like i was picturing how in the old days on dos, you would write directly to video ram to put characters on the screen
15:23:45 <tangentstorm> and the vga card would actually read that whole block of memory directly
15:24:39 <Mat2> ok if you have a say fixed array of coordinates and a routine for plot that at vsync to screen, that's the way the Amiga chipset works
15:25:44 <tangentstorm> what about a fixed array of sprites?
15:25:56 <tangentstorm> like reserve 1000 sprite records
15:26:11 <tangentstorm> and then you can have up to 1000 sprites on the screen
15:27:01 <Mat2> exactly. I think this feature was called copper list and array (AMIGA terminology)
15:27:54 <tangentstorm> and if you want to move sprite number 5, you just write to: sprite_base + (spritesize * 5) + (offset of x )
15:29:51 <Mat2> should work, but beware this would cost some performance if implemented in software
15:30:50 <tangentstorm> spritesize would be the size of the record ( x, y, image_number, dx, dy ) ... not the actual image
15:31:01 <tangentstorm> the actual image would be in the device
15:32:24 <tangentstorm> ( reading about the copper ... looks like that was the co-processor and did all kinds of things )
15:35:48 <Mat2> yes, because of the performance demands implementing it
15:40:36 <tangentstorm> we could also just use SDL, since we already have that set up :D
15:41:33 <tangentstorm> i guess really they're all the same, as long as we can figure out how to make a bitmap and show it on the display
15:41:43 <Mat2> I have prepared the VDP code for a graphic mode, all needed is primary to extend the character map (to 64 kB)
15:52:39 <Mat2> ok, I think 256 colours are enough ?
15:52:55 <tangentstorm> works for me
15:55:16 <tangentstorm> https://www.assembla.com/code/avm/ <- 404 ???
15:56:01 <tangentstorm> https://www.assembla.com/code/michalwallace-avm-fork/git/nodes <- also 404
15:56:07 <tangentstorm> what the heck?!
15:56:25 <tangentstorm> the site is there but git is gone :/
15:57:22 * tangentstorm will push a copy to github
15:58:16 <Mat2> hmm, I think there have a serious server problem
16:00:26 <Mat2> good I have make a backup yesterday
16:00:47 <tangentstorm> well the nice thing about git is it stores the entire history 
16:01:07 <Mat2> yes, that's an useful feature
16:01:42 <Mat2> ok, I include a graphic mode in the VDP code tomorrow
16:02:19 <Mat2> then let's search the best way for some shape or sprite support in retro
16:02:30 <tangentstorm> it's back already
16:02:41 <tangentstorm> on assembla i mean
16:03:00 <tangentstorm> well we have the canvas...
16:03:40 <tangentstorm> i had been thinking about aggpas
16:04:15 <tangentstorm> but for a 72-hour game i'm perfectly happy with rectangular sprites if you are
16:07:36 <Mat2> yes, that's easy to implement 
16:07:54 <tangentstorm> do you have a google account?
16:08:09 <tangentstorm> https://docs.google.com/document/d/17tXStyPkBdfnIl0cu_PmQBaA4ipus-vmZ7yZE0XcyKM/edit  <- setting up a document here
16:08:54 <Mat2> yes
16:18:36 <Mat2> dambere@web.de
16:19:15 <tangentstorm> you should have an invite now
16:20:53 <Mat2> ah where ?
16:22:29 <tangentstorm> at that email address?
16:22:31 <tangentstorm> no? :/
16:22:58 <tangentstorm> it says you can edit...
16:23:12 <tangentstorm> but you're logged in as "anonymous" instead of that account...
16:27:45 <Mat2> ok seems to work now
17:14:12 --- join: essial (essial@72-28-188-183-dhcp.aik.sc.atlanticbb.net) joined #retro
17:14:21 <essial> where's the rest of the design document :)
17:16:14 <essial> tangentstorm
17:16:50 <tangentstorm> the magic of ludum dare is that you start on the actual game when the timer starts :)
17:17:03 <tangentstorm> essial: which is in 43 minutes :)
17:17:17 <essial> I know pascal but know nothing of retro
17:17:54 <essial> also I'm on windows 8, if that makes a difference either way
17:20:27 <essial> i guess I'll just keep working on my emulator then :p
17:20:30 --- part: essial left #retro
17:22:50 <Mat2> probably an TRS-80 emulator
17:38:28 --- quit: docl (*.net *.split)
17:38:29 --- quit: ivan``_ (*.net *.split)
17:38:29 --- quit: oPless (*.net *.split)
17:38:29 --- quit: SimonRC (*.net *.split)
17:38:30 --- quit: tangentstorm (*.net *.split)
17:38:31 --- quit: Mat2 (*.net *.split)
17:38:32 --- quit: kumul (*.net *.split)
17:38:32 --- quit: intothev01d (*.net *.split)
17:38:33 --- quit: yiyus (*.net *.split)
17:38:34 --- quit: karswell_ (*.net *.split)
17:38:34 --- quit: crc (*.net *.split)
17:38:34 --- quit: saper (*.net *.split)
17:38:35 --- quit: beretta (*.net *.split)
17:38:36 --- quit: ChanServ (*.net *.split)
17:57:05 --- join: yiyus (1242712427@je.je.je) joined #retro
17:57:05 --- join: crc (~crc@li125-93.members.linode.com) joined #retro
17:57:05 --- join: saper (saper@wikipedia/saper) joined #retro
17:57:05 --- join: beretta (~beretta@cpe-107-8-120-84.columbus.res.rr.com) joined #retro
17:57:05 --- join: kumul (~kumul@cvx-ppp-66-50-141-36.coqui.net) joined #retro
17:57:05 --- join: intothev01d (~intothev0@unaffiliated/intothev01d) joined #retro
17:57:05 --- join: Mat2 (~Claude@91-65-144-133-dynip.superkabel.de) joined #retro
17:57:05 --- join: tangentstorm (~michal@108-218-151-22.lightspeed.rcsntx.sbcglobal.net) joined #retro
17:57:05 --- mode: asimov.freenode.net set +o crc
18:02:37 --- join: ivan``_ (~ivan@unaffiliated/ivan/x-000001) joined #retro
18:02:38 * Mat2 back in ten minutes
18:02:38 --- join: carefish (~carefish@095-096-156-068.static.chello.nl) joined #retro
18:02:38 --- quit: Mat2 (*.net *.split)
18:02:40 --- quit: kumul (*.net *.split)
18:02:40 --- quit: intothev01d (*.net *.split)
18:02:41 --- quit: yiyus (*.net *.split)
18:02:41 --- quit: crc (*.net *.split)
18:02:41 --- quit: carefish (*.net *.split)
18:02:42 --- quit: saper (*.net *.split)
18:02:43 --- quit: beretta (*.net *.split)
18:02:44 --- join: karswell_ (~coat@93-97-29-243.zone5.bethere.co.uk) joined #retro
18:02:44 --- join: oPless (~oPless@lart.doosh.net) joined #retro
18:02:44 --- join: SimonRC (~sc@fof.durge.org) joined #retro
18:02:46 --- quit: karswell_ (Write error: Broken pipe)
18:02:46 --- quit: oPless (*.net *.split)
18:02:46 --- quit: SimonRC (*.net *.split)
18:03:27 --- quit: tangentstorm (*.net *.split)
18:03:28 --- quit: ivan``_ (*.net *.split)
18:03:53 --- join: SimonRC (~sc@fof.durge.org) joined #retro
18:03:53 --- join: oPless (~oPless@lart.doosh.net) joined #retro
18:03:53 --- join: ChanServ (ChanServ@services.) joined #retro
18:03:53 --- join: docl (~docl@unaffiliated/docl) joined #retro
18:03:53 --- join: carefish (~carefish@095-096-156-068.static.chello.nl) joined #retro
18:03:53 --- join: yiyus (1242712427@je.je.je) joined #retro
18:03:53 --- join: crc (~crc@li125-93.members.linode.com) joined #retro
18:03:53 --- join: saper (saper@wikipedia/saper) joined #retro
18:03:53 --- join: beretta (~beretta@cpe-107-8-120-84.columbus.res.rr.com) joined #retro
18:03:53 --- join: kumul (~kumul@cvx-ppp-66-50-141-36.coqui.net) joined #retro
18:03:53 --- join: intothev01d (~intothev0@unaffiliated/intothev01d) joined #retro
18:03:53 --- join: Mat2-afk (~Claude@91-65-144-133-dynip.superkabel.de) joined #retro
18:03:53 --- mode: asimov.freenode.net set +oo ChanServ crc
18:05:09 --- join: tangentstorm (~michal@108-218-151-22.lightspeed.rcsntx.sbcglobal.net) joined #retro
18:05:25 --- join: ivan``_ (~ivan@unaffiliated/ivan/x-000001) joined #retro
18:07:59 --- join: karswell_ (~coat@93-97-29-243.zone5.bethere.co.uk) joined #retro
18:18:16 --- join: erider (~chatzilla@unaffiliated/erider) joined #retro
18:18:39 <erider> hi all 
18:25:21 --- quit: kumul (Ping timeout: 265 seconds)
18:35:31 <tangentstorm> hey erider
18:38:21 --- join: Seewhen (~IceChat9@ti0008a380-dhcp0637.bb.online.no) joined #retro
18:39:08 --- part: Seewhen left #retro
18:39:30 <intothev01d> alright, so should it automatically look for tests to load and run when the vm starts up? or should it be interactive somehow
18:42:44 <tangentstorm> intothev01d: do you have retro installed?
18:43:27 <intothev01d> prob not. i just downloaded the ngaro thing
18:44:09 <tangentstorm> we have a mirror in the lpmc directory
18:44:37 <tangentstorm> https://github.com/LearnProgramming/retro-language
18:47:21 --- join: kumul (~kumul@cvx-ppp-66-50-141-36.coqui.net) joined #retro
18:47:59 <erider> hi tangentstorm 
18:49:15 <tangentstorm> erider: we're making a game in retro + pascal for ludum dare
18:49:32 <tangentstorm> https://docs.google.com/document/d/17tXStyPkBdfnIl0cu_PmQBaA4ipus-vmZ7yZE0XcyKM/edit#
18:58:18 <erider> that was the text base game you were talking about right 
19:42:45 <tangentstorm> yeah... it looks like we're going to shoot for making a sprite engine though
19:43:39 <tangentstorm> i'd still like to use the fiction module for maps.. maybe extend it to hold a tile map or something
19:45:49 <tangentstorm> okay... was just showing intothev01d around the test suite. he's volunteered to help with getting the javascript version of ngaro to work with the test cases
19:46:50 <tangentstorm> carefish has been putting together some ideas for a possible story... which hopefully he'll be adding to the doc? :)
19:47:31 <erider> good deal 
19:47:56 <tangentstorm> i'm going to install zengl here and then try to prototype my idea for a sprite engine device
19:55:24 <erider> talk to you tomorrow 
19:55:28 <erider> caio 
19:55:37 --- quit: erider (Quit: ChatZilla 0.9.89 [Firefox 17.0.1/20121129162756])
20:03:53 --- quit: karswell_ (Remote host closed the connection)
20:14:15 --- join: karswell_ (~coat@93-97-29-243.zone5.bethere.co.uk) joined #retro
20:15:21 <tangentstorm> looks like zengl ships with precompiled binary files for various platforms
20:15:43 <tangentstorm> he even keeps *.o *.a in the svn repo... weird
20:20:33 --- quit: docl (Remote host closed the connection)
20:32:59 <carefish> how do you assign variables when you make a function?
20:33:22 <carefish> : foo variables|10 a: 20 b: | ; ?
20:35:59 <carefish> oh, variables| a: 10 | @a putn
20:37:24 <carefish> wah O-o
20:39:32 <tangentstorm> i've never done that :)
20:40:16 <tangentstorm> forth code doesn't use a lot of variables... instead you just take stuff off the stack
20:41:26 <tangentstorm> in the pl/0 compiler, i replaced the function-local variables with {{ ... }}
20:41:35 <carefish> well, i'm severely crippled here :D i've been trying to just do 128 * 512 (as an example)
20:41:43 <carefish> and not really gettin that to work
20:42:07 <tangentstorm> 128 512 *
20:42:12 <tangentstorm> putn 
20:42:33 <tangentstorm> https://github.com/tangentstorm/PL0-Language-Tools/blob/master/tests/40_procedures.pl0
20:43:03 <tangentstorm> https://github.com/tangentstorm/PL0-Language-Tools/blob/master/expect/40_procedures.rx
20:43:33 --- quit: karswell_ (Remote host closed the connection)
20:43:38 <tangentstorm> the second link shows what the compiler generates when compiling the code at the first link
20:44:06 <tangentstorm> the formatting is ugly because it's generated code
20:44:21 <tangentstorm> but if you put them side by side it makes sense
20:45:15 <tangentstorm> see, they're not really "variables" like you have in c/java/pascal
20:45:28 <tangentstorm> everything is just a word
20:46:00 <tangentstorm> : isn't special, it's just a word in the dictionary like any other
20:46:10 <tangentstorm> it just happens to flip the compiler on
20:46:31 <tangentstorm> and calls the function to read a word 
20:46:53 <carefish> soo
20:46:58 <carefish> 128 test !
20:47:03 <carefish> 512 wutevz !
20:47:16 <carefish> wutevz @ test @ * putn
20:47:24 <carefish> that's 128 * 512?
20:47:42 <tangentstorm> yes, provided you've created those as "variables"
20:48:16 <tangentstorm> what a "variable" is really is a word that pushes an address onto the data stack
20:48:28 <carefish> ooh, so that's how i could assign those in : whatever ( n-n ) variables|test wutevz| ?
20:48:28 <tangentstorm> you can see the stack with .s
20:48:54 <tangentstorm> see you can't really do it inside a colon definition
20:49:25 <tangentstorm> : sum a @ b @ + ;
20:49:44 <tangentstorm> you can't define "a" and "b" inside that because you're already defining "sum"
20:49:59 <tangentstorm> let's say we want "a" to be at memory address 1234
20:50:03 <tangentstorm> here's what a is:
20:50:09 <tangentstorm> : a 1234 ;
20:50:23 <tangentstorm> then if you type    555 a ! 
20:50:35 <tangentstorm> it'll store the number 555 in address 1234
20:50:42 <tangentstorm> and if you type:
20:50:47 <tangentstorm> 1234 @ putn
20:50:50 <tangentstorm> it'll then say 555
20:51:05 <carefish> oh, pointer-like?
20:51:07 <tangentstorm> yes
20:51:19 <tangentstorm> when you say   variables| a b |  
20:51:23 <tangentstorm> it's doing the exact same thing
20:51:45 <beretta> ah... forth lessons... free!
20:52:03 <tangentstorm> except there's a special variable/pointer called HERE that picks the address for you
20:52:15 <tangentstorm> and each time you allocate some ram, HERE gets that much bigger
20:52:28 <tangentstorm> in fact if you do that:     variables| a b |
20:52:31 <tangentstorm> and then you type:
20:52:41 <tangentstorm> a b HERE .s
20:52:45 <tangentstorm> you'll see the pattern 
20:52:57 <tangentstorm> beretta: :)
20:53:23 <tangentstorm> uhh.. it might be lower case. "here"
20:53:48 --- join: karswell_ (~coat@93-97-29-243.zone5.bethere.co.uk) joined #retro
20:54:45 <tangentstorm> hmm.
20:55:26 <tangentstorm> easier to see with 3
20:55:42 <tangentstorm> variables| a b c | a b c here .s 
20:55:55 <tangentstorm> you'll see the header is 7 cells 
20:56:12 <tangentstorm> and that here points to the cell right after c 
20:56:38 <tangentstorm> i guess the header is 6 cells, the value is 1 cell
20:57:06 <tangentstorm> and if you use longer variable names, the header will get longer
20:57:45 <beretta> retro stores header and code in the same area?
20:57:50 <tangentstorm> variables| xx yy zz | yy zz -
20:57:56 <tangentstorm> yes
20:58:02 <tangentstorm> sure looks that way to me
20:58:13 <tangentstorm> in fact i know it does
20:58:59 <tangentstorm> it's one long database
20:59:59 <carefish> aha
21:00:01 <tangentstorm> the header contains the name ( terminated with a 0 ), the type, a pointer to the *previous* header... um...
21:00:05 <tangentstorm> and some other stuff
21:00:06 <carefish> here here here here .s
21:00:08 <tangentstorm> oh the doc string
21:00:41 <tangentstorm> at memory location 2 ( "last" ) there is a pointer to the last header defined
21:02:00 <tangentstorm> the pointer to the previous header is the first value in the header
21:02:03 <tangentstorm> so you can actually say
21:02:16 <tangentstorm> last @ @ @ d->name puts
21:02:31 <tangentstorm> keep changing the number of @'s and you'll browse the dictionary
21:05:13 <carefish> i feel dumb xD really can't understand the syntax
21:05:22 <tangentstorm> carefish: there isn't any syntax :)
21:05:27 <tangentstorm> it's just one word after another
21:05:34 <tangentstorm> last puts the number 2 on the stack
21:05:49 <tangentstorm> @ looks at the value at memory address 2 and leaves that on the stack
21:06:01 <tangentstorm> @ looks at whatever's at that address and puts that on the stack
21:06:07 <tangentstorm> @ looks at whatever's at that address and puts that on the stack
21:06:36 <tangentstorm> d->name is a word that takes a value on the stack, assumes there's a dictionary entry there, and jumps to where the name would be
21:06:43 <tangentstorm> then puts that address on the stack
21:06:53 <tangentstorm> (each of these consumes the previous value, btw)
21:07:21 <carefish> so you'd need to do @ @ @ d->name again ?
21:07:24 <tangentstorm> puts takes a number off the stack, assumes it's a pointer to a string, and prints each value it sees as a character until it finds a zero
21:07:39 <tangentstorm> yes
21:07:48 <carefish> w/o the last?
21:07:51 <carefish> or w/?
21:07:56 <tangentstorm> if you want to keep a copy of the number, you can use "dup"
21:07:57 <beretta> ah... asciz strings... neat.
21:08:40 <tangentstorm> the convention is that each word consumes its input, so it's the *caller's* responsibility to use "dup"
21:08:58 <beretta> don't worry about stack juggling .... it get easier with practice.
21:09:33 <tangentstorm> carefish: yes, you need the word "last" and the first "@" to get the address of the last item in the dictionary
21:09:50 <carefish> the concept of 'consume' is weird for me :D
21:09:51 <tangentstorm> the dictionary being the linked list of headers 
21:10:09 <tangentstorm> yeah :)
21:10:11 <carefish> does that mean it stops existing?
21:10:20 <tangentstorm> try it:
21:10:23 <carefish> or that i need to put it back on the stack?
21:10:31 <tangentstorm> 2 .s 3 .s + .s 
21:10:41 <tangentstorm> "reset" clears the entire stack
21:11:27 <tangentstorm> + consumes the 2 and the 3 and replaces it with a 5
21:11:34 <tangentstorm> hence ( nn-n )
21:11:49 <carefish> oh that's what you mean by consome
21:12:02 <tangentstorm> :)
21:12:04 <carefish> so the variable itself wont exist after use?
21:12:21 <carefish> but i'd need to retrieve it w/ a couple of @'s?
21:12:29 <carefish> (well, the value at the variable)
21:12:38 <tangentstorm> the value is still there in ram
21:12:46 <tangentstorm> and the name is still there in the dictionary
21:12:46 <carefish> yeah that's what i mean
21:12:57 <tangentstorm> so if it was named "a" you can use it again
21:13:07 <tangentstorm> just by using the word "a" again
21:13:34 <tangentstorm> but it's removed from the data stack
21:13:51 <tangentstorm> there are two stacks
21:14:03 <tangentstorm> the data stack is for the data you're working with
21:14:30 <tangentstorm> and the address stack is primarily for nested procedures
21:14:42 <tangentstorm> it's where you go back to when you return from a function
21:14:57 <tangentstorm> function is the wrong word. it's just a "word"
21:15:07 <tangentstorm> ";" is return
21:15:32 <tangentstorm> so in a definition like...    : sum + ; 
21:15:44 <tangentstorm> ; adds a "return" instruction to the word's definition
21:15:49 <tangentstorm> and then turns off the compiler
21:16:14 <tangentstorm> the compiler is just writing instructions to ram and incrementing that "here" variable
21:16:50 <tangentstorm> this is why you can't define local variables inside the word definition
21:17:18 <tangentstorm> they would just get written inside the definition of the sum function rather than to the dictionary
21:17:51 <tangentstorm> ...
21:18:16 <tangentstorm> well... actually, that's not accurate
21:18:43 <carefish> : mult a b * ; 
21:18:57 <carefish> so how do i tell retro what a and b are?
21:19:11 <tangentstorm> you need to define them before you define that function
21:19:22 <tangentstorm> : a 2 ;
21:19:31 <tangentstorm> or    2 constant a
21:20:08 <tangentstorm> if you use variable| a b | then remember a and b will be words that push addresses onto the stack rather than values
21:20:27 <tangentstorm> but really you would not write it that way
21:20:31 <tangentstorm> you would just do:
21:20:36 <tangentstorm> : mult * ;
21:20:42 <tangentstorm> then:    a b mult
21:20:57 <carefish> and to print the value?
21:21:05 <tangentstorm> a b mult putn
21:21:30 <tangentstorm> the forth way of thinking is : lots of simple words chained together :)
21:24:02 <tangentstorm> okay... i'm gonna get some sleep here... 
21:24:13 <carefish> sleep well :P
21:24:24 <carefish> i'll fiddle some more with it
21:24:50 <tangentstorm> Mat2-afk: the ZenGL thing looks pretty cool. i ran the lazarus demos, and there's a nice demo of the sprite engine. i think we can definitely work with this
21:25:00 <tangentstorm> have fun. see you guys tomorrow :)
21:25:07 --- nick: tangentstorm -> tangentsleep
21:41:48 --- quit: intothev01d (Quit: intothev01d)
22:07:45 --- quit: kumul (Quit: WeeChat 0.3.9.2)
22:46:45 --- nick: Mat2-afk -> Mat2
22:46:49 <Mat2> hello
22:49:01 <Mat2> get some sleep
22:49:18 --- quit: Mat2 (Quit: Verlassend)
23:59:59 --- log: ended retro/12.12.14