00:00:00 --- log: started forth/18.02.19
00:16:17 --- join: dys (~dys@2003:5b:203b:100:6af7:28ff:fe06:801) joined #forth
00:16:29 --- join: mtsd (4d6e3d64@gateway/web/freenode/ip.77.110.61.100) joined #forth
01:39:08 <proteus-guy> FORTH in SPACE!!!
01:42:24 --- quit: proteus-guy (Remote host closed the connection)
02:02:55 --- join: ncv (~neceve@unaffiliated/neceve) joined #forth
02:36:57 --- quit: Darksecond (Read error: Connection reset by peer)
02:40:40 --- join: Darksecond (~darksecon@a82-94-53-70.adsl.xs4all.nl) joined #forth
03:14:03 --- join: wa5qjh (~quassel@175.158.225.199) joined #forth
03:14:03 --- quit: wa5qjh (Changing host)
03:14:04 --- join: wa5qjh (~quassel@freebsd/user/wa5qjh) joined #forth
03:14:50 --- quit: wa5qjh (Remote host closed the connection)
03:18:51 --- join: wa5qjh (~Thunderbi@freebsd/user/wa5qjh) joined #forth
03:25:19 --- join: leaverite (~quassel@freebsd/user/wa5qjh) joined #forth
03:25:21 --- nick: lisbeths -> johnnymacs
03:25:34 --- quit: wa5qjh (Ping timeout: 268 seconds)
03:25:50 <johnnymacs> One of the things I am thinking about is making my forth floating point under the hood.
03:26:32 <johnnymacs> If I want to get the same out data out if for counters I can add point zero zero zero whatever
03:27:17 --- quit: leaverite (Remote host closed the connection)
03:35:52 <jn> floating point for everything (esp. for pointers) seems like a bad idea for me. 
03:51:47 <johnnymacs> Well I would have floats that were the same number of bytes as a pointer, so I could cast from pointer to float. When you print it you'd get a float
03:51:56 <johnnymacs> Maybe it is a bad idea though.
04:29:32 --- quit: nighty- (Quit: Disappears in a puff of smoke)
04:45:43 --- join: dddddd (~dddddd@unaffiliated/dddddd) joined #forth
05:14:00 <smokeink> koisoke: holy cow, someone just explained to me that (jmp). It's not as bad or difficult as I thought!  This is how it works: we've got VIP pointing to the this JMP word/blockcode . We want to execute this JMP so we go into it, but before that we increment VIP by 4 (that's how we execute things , right?)
05:14:48 <smokeink> so we are inside the UNCONDITIONAL RELATIVE JMP routine, and our VIP points towards the next 'instruction' : actually it's not an instruction, but an offset
05:16:46 <zy]x[yz> : jmp r> dup @ + >r ;
05:17:44 <smokeink> https://www.pvk.ca/Blog/2014/03/15/sbcl-the-ultimate-assembly-code-breadboard/
05:20:04 * smokeink it's so simple that it's difficult to put it into words . 1 sec
05:24:36 <zy]x[yz> I know how jmp works.  the offset is an execution-stream parameter that comes immediately after the compiled word
05:25:18 <zy]x[yz> I just wrote for you a high level implementation of it.  you can achieve the same thing in machine code
05:28:12 <smokeink> ok I understood your code : it also needs a 4 + right ?
05:28:24 <smokeink> : jmp r> dup @ + 4 + >r ;
05:29:01 <smokeink> to account for that offset which occupies the 4 bytes after jmp's address
05:38:45 <zy]x[yz> it doesn't have to
05:39:06 <zy]x[yz> the offset could just be relative to the address immediately following the jmp word
05:39:21 <smokeink> right :) thanks man
05:44:19 --- join: lijero (~lijero@unaffiliated/lijero) joined #forth
05:48:33 --- join: nighty- (~nighty@s229123.ppp.asahi-net.or.jp) joined #forth
05:54:46 --- quit: nighty- (Max SendQ exceeded)
05:55:24 --- join: nighty- (~nighty@s229123.ppp.asahi-net.or.jp) joined #forth
07:00:45 <pointfree> jn, johnnymacs: someone once gave a talk on a floating-point/bignum only forth. It seemed very user friendly (for both int and float math)
07:08:12 <jn> i wonder how cells and raw memory access work in that forth
07:30:22 <smokeink> /quit peace
07:30:25 --- quit: smokeink (Quit: peace)
08:02:05 --- join: EvanCarroll (~ecarroll@rrcs-71-41-192-130.sw.biz.rr.com) joined #forth
08:14:53 --- quit: mtsd (Quit: Page closed)
09:38:49 --- join: Labu (~mik@mvice.pck.nerim.net) joined #forth
09:55:40 --- quit: dys (Ping timeout: 240 seconds)
10:24:34 --- join: mark4 (~mark4@cpe-75-177-17-25.triad.res.rr.com) joined #forth
10:30:19 --- quit: ncv (Ping timeout: 260 seconds)
10:36:28 --- join: azathoth99 (~g@209.6.150.53) joined #forth
10:36:41 <azathoth99> is forth and cgi for dynamic web pages hard?
10:37:39 <mark4> probably not impossible :)
10:38:01 <mark4> is cgi even still used?
10:43:04 --- quit: Zarutian_PI (Read error: Connection reset by peer)
10:43:30 --- join: Zarutian_PI (~3.1415@173-133-17-89.fiber.hringdu.is) joined #forth
10:47:22 <EvanCarroll> azathoth99: very simple if using traditional cgi
10:49:39 <EvanCarroll> you just need to have access to environmental variables
11:00:14 <pointfree> azathoth99: https://www.youtube.com/watch?v=mvrE2ZGe-rs https://bitbucket.org/kc5tja/unsuitable/src <--- Sam Falvo's blogging software in forth
11:12:33 --- join: ncv (~neceve@unaffiliated/neceve) joined #forth
11:35:31 --- quit: ncv (Remote host closed the connection)
11:36:06 --- join: ncv (~neceve@unaffiliated/neceve) joined #forth
13:12:43 --- quit: ncv (Remote host closed the connection)
13:13:19 --- join: ncv (~neceve@unaffiliated/neceve) joined #forth
13:29:19 <johnnymacs> I am pretty close to writing my compiler in itself, but it still compiles to c
13:32:29 <johnnymacs> I am very anxious to benchmark the speeds. On the one hand I expect it to operate as fast as gforth on ubuntu when compiled. On the other hand I don't know if it will be near the speeds of c or the speeds of gforth from the master branch.
13:32:42 <johnnymacs> For example I don't know if typecasting takes up any time
13:33:06 <johnnymacs> Also I don't know if it is more efficient to use functions or put everything in main
13:35:46 <johnnymacs> One thing that I learned is that in modern processors that memory addresses commonly called are cached. And so I don't think I have to worry about caching the stack, or the registers
13:38:24 <zy]x[yz> do you have immediate words working yet?
14:21:12 --- quit: dddddd (Remote host closed the connection)
14:21:14 --- quit: ncv (Remote host closed the connection)
15:34:15 <johnnymacs> No my compiler is not a colon compiler
15:35:11 <johnnymacs> My compiler finds undefined words and looks them up in the dictionary of the compiler, then inserts the text of the definition in
15:42:00 --- quit: Labu (Ping timeout: 276 seconds)
15:56:46 <zy]x[yz> so how do control flow words work?
16:01:18 <EvanCarroll> not sure if this is a bug with gforth's lshift, https://stackoverflow.com/a/48875975/124486
16:14:12 <zy]x[yz> EvanCarroll, I think you're actually seeing a quirk of x86.  the shl instruction actually masks the count operand to only the bottom five or six bits before performing the shift
16:19:12 <johnnymacs> are you asking me, zy]x[yz
16:19:24 <zy]x[yz> or maybe that applies to both shl and shr/sar, I can't remember
16:19:54 <azathoth99> thx!
16:20:02 <zy]x[yz> johnnymacs, if your forth doesn't have immediate words, how did you implement IF and THEN
16:23:51 <johnnymacs> Well since it compiles to c the if word inserts "if(pop()){/n"
16:24:35 <johnnymacs> the word named close inserts "{/n"
16:26:15 <johnnymacs> Sorry it inserts "}/n"
16:26:56 <johnnymacs> when my forth is done compiling the "dictionary" is discarded
16:29:13 <johnnymacs> the word loop inserts "while(pop()){/n" and you use close to end the loop as well
16:29:32 <johnnymacs> switch statements work similarly
16:31:50 <johnnymacs> The goal for this forth is to be as fast or faster than c so that it is a better candidate for writing ans forth in
16:32:36 <johnnymacs> to make it closer to c I gave up interpretation on the fly
16:38:51 <zy]x[yz> so how do you initialize variables
16:38:51 --- join: Gromboli (~Gromboli@static-72-88-80-103.bflony.fios.verizon.net) joined #forth
16:39:19 --- quit: EvanCarroll (Ping timeout: 248 seconds)
16:43:26 <johnnymacs> No variables. you have to write a dictionary and use strings in memory basically
16:49:24 <johnnymacs> All words must be defined at compile time
16:49:54 <johnnymacs> You can make a variable of a constant
17:00:20 <johnnymacs> define foo 7 return
17:02:34 --- join: nighty-- (~nighty@kyotolabs.asahinet.com) joined #forth
18:59:01 --- join: smokeink (~smokeink@59-125-75-78.HINET-IP.hinet.net) joined #forth
18:59:51 --- join: wa5qjh (~quassel@175.158.225.208) joined #forth
18:59:51 --- quit: wa5qjh (Changing host)
18:59:51 --- join: wa5qjh (~quassel@freebsd/user/wa5qjh) joined #forth
19:20:27 --- join: DGASAU (~user@lmpc.drb.insel.de) joined #forth
19:26:49 --- quit: smokeink (Remote host closed the connection)
19:37:36 --- quit: wa5qjh (Remote host closed the connection)
19:49:53 --- quit: mark4 (Remote host closed the connection)
19:50:32 --- join: smokeink (~smokeink@185.134.120.54) joined #forth
19:53:10 --- quit: nerfur (Ping timeout: 240 seconds)
19:53:47 --- join: nerfur (~nerfur@mail.freeside.ru) joined #forth
19:57:06 --- join: wa5qjh (~quassel@freebsd/user/wa5qjh) joined #forth
20:13:21 --- quit: wa5qjh (Remote host closed the connection)
20:35:26 --- join: EvanCarroll (~ecarroll@172.58.99.27) joined #forth
21:23:31 --- part: DGASAU left #forth
21:28:44 --- quit: Gromboli (Quit: Leaving)
23:17:02 --- join: Labu (~mik@mvice.pck.nerim.net) joined #forth
23:17:49 --- quit: zy]x[yz (Ping timeout: 240 seconds)
23:25:36 --- quit: Labu (Ping timeout: 268 seconds)
23:27:23 --- quit: lijero (Remote host closed the connection)
23:30:37 --- quit: smokeink (Ping timeout: 256 seconds)
23:42:59 --- join: Labu (~mik@mvice.pck.nerim.net) joined #forth
23:59:59 --- log: ended forth/18.02.19