00:00:00 --- log: started forth/13.11.25
00:02:14 --- join: CubicCIA (~RJones@cpe-76-179-150-229.maine.res.rr.com) joined #forth
00:07:28 --- join: Bahman (~Bahman@2.146.101.47) joined #forth
00:12:39 <jyf> is there any forth implementation that could control whether word should consume or not the data stack parameters?
02:00:30 --- join: impomatic (~digital_w@87.114.102.71) joined #forth
02:18:01 --- quit: Tod-Autojoined (Read error: Connection reset by peer)
02:19:39 --- join: TodPunk (~Tod@50-198-177-185-static.hfc.comcastbusiness.net) joined #forth
02:20:15 --- quit: CubicCIA (Ping timeout: 264 seconds)
03:05:54 --- quit: TodPunk (Read error: Connection reset by peer)
03:08:12 --- join: TodPunk (~Tod@50-198-177-185-static.hfc.comcastbusiness.net) joined #forth
03:16:32 --- quit: aksr (Ping timeout: 252 seconds)
03:30:54 --- quit: TodPunk (Read error: Connection reset by peer)
03:32:49 --- join: TodPunk (~Tod@50-198-177-185-static.hfc.comcastbusiness.net) joined #forth
03:56:22 <tangentstorm> jyf: all of them? :)
03:56:28 --- quit: true-grue (Read error: Connection reset by peer)
04:26:07 --- join: aksr (~aksr@unaffiliated/aksr) joined #forth
04:44:08 <jyf> tangentstorm: really? how ?
04:54:52 <tangentstorm> jyf: well, if the word normally consumes an item and you don't want it to, you can put the word 'dup' in front of it.
04:55:21 <tangentstorm> jyf: if it normally does not consume the item and you do want it to, you can put the word 'drop' aftter it.
05:13:10 <jyf> tangentstorm: no i am not meaning like this
05:13:56 <tangentstorm> what do you mean?
05:14:19 <jyf> i need them take the item from stack without comsume them
05:15:56 --- quit: Bahman (Quit: Leaving.)
05:15:59 --- quit: w0rm_x (Quit: if Φ Σ e : φ then Φ Σ τ' → σ' :: ∃)
05:17:15 <tangentstorm> dup
05:17:53 <jyf> its cheat
05:18:02 <tangentstorm> pick
05:18:14 <jyf> pick wont consume item?
05:18:53 <tangentstorm> i don't know why you say it's cheating.
05:18:56 <jyf> oops pick copy item, that's not my want either
05:19:32 <jyf> tangentstorm: i just want the single word that could read item from stack while not consuming them
05:19:36 <jyf> isnt that clear?
05:19:42 <tangentstorm> not really :)
05:19:46 <tangentstorm> what will it do with the item ?
05:20:00 <jyf> it depends on what it defined to do
05:20:17 <tangentstorm> do you have a specific example?
05:20:26 --- quit: aksr (Quit: aksr)
05:21:11 <jyf> yes like , there's 1 2 in stack and i type addi <enter> it has 1 2 3 in the stack now
05:21:39 <tangentstorm> : addi over over + ;
05:21:59 <jyf> i mean primetive word
05:22:41 <tangentstorm> okay then just write the same thing in assembly.
05:23:16 <tangentstorm> i'm sure there's a forth implementation out there that already does this, but you could either spend hours searching for it, or 5 minutes implementing it yourself in whatever one you're using.
05:23:20 <jyf> i dont want to pop items from stack while reading
05:23:32 <kulp> but why ?
05:23:37 <kulp> what do you gain ?
05:23:42 <jyf> just for curiouse
05:23:52 --- join: nighty-_ (~nighty@lns-bzn-49f-62-147-170-46.adsl.proxad.net) joined #forth
05:25:23 <tangentstorm> jyf: it really doesn't matter how a word works internally. if i tell you my implementation has an   ' addi ' you can use it exactly the same way no matter how it's implemented.
05:25:24 --- quit: nighty^ (Quit: leaving)
05:26:51 <tangentstorm> i could implement it in the library or implement as a native instruction. it wouldn't make any difference.
05:27:24 <jyf> no it has, but now i got the solution for this
05:36:52 --- join: true-grue (~quassel@95-24-248-209.broadband.corbina.ru) joined #forth
05:37:30 --- join: w0rm_x (~w0rm@client-82-26-214-139.pete.adsl.virginm.net) joined #forth
05:43:21 --- join: Bahman (~Bahman@2.146.101.47) joined #forth
05:54:47 --- join: lazyden (~lazyden@58.185.121.38) joined #forth
05:54:47 --- quit: lazyden (Client Quit)
05:54:54 --- join: lazyden (~lazyden@58.185.121.38) joined #forth
05:54:55 --- quit: lazyden (Client Quit)
06:33:49 --- join: asie (~textual@178235038113.elblag.vectranet.pl) joined #forth
07:02:53 --- part: w0rm_x left #forth
07:04:41 --- quit: asie (Quit: I'll probably come back in either 20 minutes or 8 hours.)
07:07:56 --- join: asie (~textual@178235038113.elblag.vectranet.pl) joined #forth
07:11:53 --- join: Bahman1 (~Bahman@2.146.52.153) joined #forth
07:14:30 --- quit: Bahman (Ping timeout: 272 seconds)
07:44:37 --- quit: TodPunk (Quit: This is me, signing off.  Probably rebooting or something.)
07:51:33 --- join: TodPunk (~Tod@50-198-177-185-static.hfc.comcastbusiness.net) joined #forth
08:11:30 --- quit: Bahman1 (Quit: Leaving.)
08:16:57 --- join: kludge` (~comet@unaffiliated/espiral) joined #forth
08:23:11 --- join: protist (~protist@17.224.69.111.dynamic.snap.net.nz) joined #forth
09:54:11 --- quit: asie (Quit: I'll probably come back in either 20 minutes or 8 hours.)
10:14:07 --- join: yiyus (1242712427@je.je.je) joined #forth
10:27:50 --- quit: yiyus (Remote host closed the connection)
10:55:23 --- join: asie (~textual@178235038113.elblag.vectranet.pl) joined #forth
11:23:17 --- quit: asie (Quit: I'll probably come back in either 20 minutes or 8 hours.)
11:24:34 --- join: asie (~textual@178235038113.elblag.vectranet.pl) joined #forth
11:25:51 <mark4> anyone awake?
11:26:02 <mark4> i got a problem with my arm forths division routines
11:26:16 <mark4> isforth:  -123 10 /mod . .  returns -13 7
11:26:28 <mark4> arm:  -123 10 /mod . . returns -1 -113
11:29:07 <tangentstorm> hrm
11:29:29 <mark4> i think once i fix this i might have a releasable version
11:29:41 <mark4> will need to test further, but i think ill be getting real close
11:31:12 <tangentstorm> gforth:  -123 10 /mod  -13 7
11:31:21 <mark4> yes isforth has it right
11:31:27 <mark4> my arm forth does not
11:32:11 <tangentstorm> how did you implement /mod?
11:32:56 <mark4> http://bpaste.net/show/152996/
11:33:08 <mark4> i forget where i snagged that code lol
11:33:28 <mark4> i think its signed tho. i need both signed and unsigned
11:33:42 <mark4> but i think this one is purely signed which is wrong for this case
11:34:47 <tangentstorm> it looks like there's actually a signed div instruction...
11:34:50 <tangentstorm> http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0552a/BABGAFJI.html
11:34:56 <tangentstorm> sdiv/udiv
11:35:21 <mark4> on the a8 yes but im trying to NOT restrict myself to the A8
11:35:44 <mark4> well. im using ONE opcode thats a8 specific but i have code that i can replace it wth for lesser cores
11:35:48 <mark4> plus
11:35:53 <mark4> that div is a 32 bit div
11:36:09 <mark4> this SPEIFICALLY needs to be a 64 bit by 32 bit division leaving a 64 bit result and 32 bit remainder
11:36:16 <tangentstorm> ok
11:36:25 <mark4> which its not :/
11:36:41 <tangentstorm> what does adc do?
11:36:47 <mark4> add with carry
11:37:21 <mark4> sub is the same as subs but the s says "remember the carry state"
11:37:37 <mark4> addcs is add with carry and generate a carry
11:38:03 <mark4> ok wait. now im confused too
11:38:12 <mark4> theres adc and addc... why does this assemble?
11:39:09 <tangentstorm> beats me :)
11:39:16 <mark4> maybe the gnu assembler allows adc as a shorthand for addc
11:39:37 <mark4> nope
11:39:37 <tangentstorm> ADC is definitely an instruction on the arm site.. i don't see ADDC though.
11:39:45 <tangentstorm> (yet)
11:39:45 <mark4> it doesnt allowa addc but it does allow addcs wtf
11:40:10 <mark4> what is add ?
11:40:17 <mark4> is there an add opcode?
11:40:57 <mark4> thers an addCS and addCC where the cs and cc are conditions for executing the opcode
11:41:11 <mark4> xyzCC says execye the xyz opcode ONLY if the carry is clear
11:41:19 <mark4> if carry is set then that opcode is a nop
11:41:43 <tangentstorm> http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0552a/BABFFEJF.html  talks about add/adc
11:41:58 <mark4> i HATE arms site
11:42:11 <mark4> it has that bullshit popup spam visual clutter
11:42:40 <mark4> yea. thers an add opcode which is add without carry
11:42:49 <mark4> so addcs says add with no carry if carry is set
11:43:04 <mark4> there does not seem to be adccs or else theres a bug in the gnu assembler
11:43:42 <tangentstorm> maybe we're looking at an old version here?
11:43:48 <mark4> no
11:43:55 <tangentstorm> this is 'cortex-m'..?
11:44:00 <mark4> i just tried them again and this time they workd  adccc adccs
11:44:06 <mark4> no the M is thumb only
11:44:11 <mark4> this is a cortex-a8
11:44:25 <mark4> problem isnt add/sub etc problem is /mod
11:44:28 <tangentstorm> no i mean these docs were for cortex-m
11:44:30 <mark4> um/mod to be more specific
11:44:46 <tangentstorm> yeah but i'm just trying to understand what the code you posted does
11:44:51 <mark4> ( ud un --- ud un )
11:44:56 <mark4> yea 
11:49:54 <tangentstorm> i can't find a reference on the a8 instruction set
11:50:22 <mark4> just take any arm instruction set and thats what im using
11:50:36 <mark4> this code should be able to run on an arm7 tdmi too
11:50:54 <tangentstorm> well i was just looking at one (the one i linked) but it didn't have anythnig about addcs or addcc
11:51:20 <mark4> addcs is a conditional add. it only does the add if the carry is set
11:51:29 <mark4> all opcodes in arm can be conditional 
11:51:33 <mark4> sort of
11:51:50 <mark4> there are a few unconditional opcodes but the rest are ALWAYS conditional
11:51:52 <tangentstorm> oh so 'c' is just a suffix you can add to anything?
11:51:58 <mark4> but you can set an "always" condition on them
11:52:13 <tangentstorm> cs = carry set, cc = carry clear?
11:52:17 <mark4> yes
11:52:36 <mark4> addhi addcs addcc addlo etc etc tc
11:52:55 <mark4> addal  <-- tho the "always" conditon is implied and i dont think it can be specified
11:53:01 <mark4> so addal is areally just "add"
11:53:04 <tangentstorm> what's with the   mov r3, #32   L
11:53:07 <tangentstorm> er ?
11:53:16 <mark4> thats a loop counter
11:53:24 <tangentstorm> for the 32 bits?
11:53:38 <mark4> which is why this is wrong too. this needs to be a 64 by 32 divide
11:54:08 <mark4> i need two versions of it too. signed and unsigned
11:54:15 <mark4> this code is signed and its supposed to be unsigned
11:55:57 <tangentstorm> does   bne 1b    jump back to the 1: ?
11:57:44 <mark4> yes
11:57:52 <mark4> b is branch. ne is "not equal"
11:58:04 <mark4> in this case it means "not equal to zero"
11:59:02 <tangentstorm> what about the b in 1b?
11:59:14 <mark4> 1: is a local label
11:59:27 <mark4> b 1b says branch backwards to local label 1
11:59:33 <mark4> you can have
11:59:33 <mark4> 1:
11:59:33 <mark4>  ...
11:59:34 <mark4>  ...
11:59:35 <mark4>   b 1b
11:59:37 <mark4>   b 1f
11:59:38 <mark4>  ..
11:59:39 <mark4>  ...
11:59:40 <mark4> 1:
11:59:44 <mark4> all in the same routine
12:00:17 <tangentstorm> ah cool
12:01:23 <tangentstorm> so r0 is your TOS ?
12:01:27 <mark4> yes
12:02:23 <tangentstorm> and next is 'go on to the next forth word?'
12:02:39 <mark4> next is actyally a mov pc, lr
12:05:59 <tangentstorm> http://bpaste.net/show/iLdKLDwfopO0GxxjkldH/
12:06:12 <tangentstorm> i think line 8 is the (or at least a) problem
12:06:35 <tangentstorm> either that or i don't understand the syntax :)
12:06:58 <mark4> r0 is initialized btw, it is the top of stac. top of stack is actually second on stack :)
12:07:24 <mark4> your comments seem right
12:07:33 <tangentstorm> hrm. what does this mean then?  ldmia sp!, { r1, r2 } 
12:07:36 <mark4> other than the r0 not being initialized 
12:07:38 <mark4> thats a pop
12:07:43 <mark4> ldm is load multiple
12:07:48 <mark4> the ia means increment after
12:08:12 <mark4> so pop item off stack into r1, increment stack pointer after the pop. then pop next item into r2 and increment after
12:08:23 <tangentstorm> why do you do that?
12:08:27 <mark4> you can have grows up or grows down stacks 
12:08:43 <mark4> thats one opcode to pop 2 items
12:08:58 <tangentstorm> i mean if you're saying r0 is the tos, then why do you pop 2 things?
12:09:00 <mark4>  ldmia sp!, { r0, r1, r2, r3, r4 }  <--- one opcode
12:09:17 <mark4> beause there are 3 things in play here
12:09:25 <mark4> or really there are two things but one of them is a doube
12:09:44 <mark4>  so r0/r1 is a double number being divided by the single number r2
12:09:49 <mark4> the result is WRONG tho
12:10:02 <mark4> it needs to be a double result and single remainder
12:10:19 <mark4> erm wait maybe not
12:10:25 <mark4> i forget which is whic
12:10:25 <tangentstorm> hang on...
12:10:28 <mark4> theres um/mod and mu/mod
12:10:44 <tangentstorm> you're putting -123 10 on the stack
12:10:55 <tangentstorm> what's in r0 ?
12:11:32 <mark4> top of stack is cached in r0. thats the high half of r0/r1
12:11:58 <mark4> -123 as a double would put -1 in r0
12:11:59 <tangentstorm> so the number 10 is going to be stored as 2 32-bit cells?
12:12:10 <mark4> no.
12:12:31 <mark4> -123 is ffffffff:ffffff85
12:12:44 <mark4> that 64 bit number is supposed to be being divided by
12:12:47 <mark4> 0000000a
12:12:51 <mark4> that 32 bit number
12:13:03 <mark4> leaving a 64 bit q and a 16 bit r
12:13:08 <mark4> which this code does not do grr
12:13:14 <mark4> erm wait
12:13:21 <mark4> im still being confused here
12:13:23 <mark4> hang on
12:13:23 <tangentstorm> but how does it know that -123 is 2 cells and 10 is 1 cell?
12:13:42 <mark4> my isforth is floating point excepting grrr
12:14:00 <mark4> beause the code is suppsed to work that way. but it doesnt 
12:14:09 <mark4> ( ud un ---- r q )  
12:14:22 <mark4> its acutlaly 64 by 32 divide with a 32 r and 32 q
12:14:36 <mark4> blarh the comment is wrong 
12:14:43 <mark4> ( ud un --- q r )
12:14:50 <mark4> i think is the right stack comment
12:15:26 <tangentstorm> okay.. i know i must seem like a moron here but can you walk me through it a little slower? :) when you type -123 , what's in r0?
12:15:52 <mark4> what is -123 in 64 bits
12:15:54 <mark4> in hex
12:16:10 <mark4> ffffffff ffffff85
12:16:18 <mark4>     ro       r1
12:16:24 <mark4> er r0 i mean
12:16:26 <tangentstorm> gforth:  decimal -123 hex . -7B  ok
12:16:41 <mark4> do -123 hex u.
12:16:50 <tangentstorm> -123 hex u. FFFFFFFFFFFFFEDD  ok
12:17:04 <tangentstorm> oh i'm already in hex though
12:17:11 <tangentstorm> decimal -123 hex u. FFFFFFFFFFFFFF85  ok
12:17:13 <tangentstorm> got it
12:17:29 <mark4> the gforth you have there must already be 64 bit
12:17:37 <tangentstorm> yeah... so r0 is 32 bits right?
12:17:40 <mark4> isforth and this arm are 32 bit forths
12:17:41 <mark4> yes
12:17:46 <mark4> all the registers are 32 bits
12:18:07 <mark4> i have r0 r1 r2 r3 r4 f5 ... ... r15
12:18:09 <tangentstorm> so half this bit pattern is in r0. which half is it, and where is the other half?
12:18:37 <mark4> r0:r1 is the 64 bit number to be divided by the 32 bit number
12:18:42 <mark4> r0 is high r1 is low
12:18:49 <tangentstorm> ok
12:19:05 <tangentstorm> so when you do the sp! { r1 r2 } aren't you overwriting that value?
12:19:22 <mark4> do this in gforth
12:19:28 <mark4> -123 s>d 10 um/mod
12:19:41 <mark4> assuming gforth HAS s>d (single to double) and um/mod
12:19:49 <mark4> unsigned mixed slash mod
12:20:03 <tangentstorm> :28: Result out of range
12:20:39 <mark4> top of stack is cached in r0. the rest of the items are on the physical stack still
12:20:48 <mark4> so that pops them into r1 and r2
12:20:59 <mark4> im im trying to divide r0:r1 by r2
12:21:16 <tangentstorm> i'm confused again.
12:21:27 <mark4> and i need a 32 bit quotiend and 32 bit remainder
12:21:31 <mark4> ok
12:21:35 <mark4> lets say you do 
12:21:35 <mark4> 1
12:21:36 <mark4> 2
12:21:36 <mark4> 3
12:21:38 <mark4> in forth
12:21:43 <mark4> you now have THREE items on the stack
12:21:48 <tangentstorm> you type -123.  now r0=ffffffff  and r1=ffffff85 right?
12:21:53 <mark4> in my arm forth that top item is left in register r0
12:21:57 <mark4> yes
12:22:00 <tangentstorm> ok
12:22:05 <tangentstorm> the next line erases r1
12:22:10 <mark4> nonono
12:22:19 <mark4> ok
12:22:21 --- quit: protist (Quit: Konversation terminated!)
12:22:32 <tangentstorm>   ldmia sp!, { r1, r2 }
12:22:36 <mark4> wait
12:22:59 <mark4> -123 in this forth is a 32 bit number.  this divide needs a 64 bit number
12:23:08 <mark4> -123
12:23:23 <mark4> that pushes r0 (what ever happens to be in it) into the stack. then loads -123 into r0
12:23:35 <tangentstorm> ok
12:23:37 <mark4> if you then do s>d (convert single to double) r0 gets pushed
12:23:47 <mark4> and then arit shifted right by 31 
12:23:55 <tangentstorm> ok
12:23:58 <mark4> so r0 is the high
12:24:02 <mark4> so wait
12:24:07 <tangentstorm> but you didn't do that in your initial code paste
12:24:29 <mark4> actually grrrr
12:24:37 <mark4> ud un ---
12:24:40 <mark4> this is actually
12:24:48 <mark4>  lo hi divisor
12:24:50 <mark4> all 32 bits
12:24:58 <mark4> so r0 is the number im dividinb BY
12:25:05 <mark4> and r1:r2 is the number being divided
12:25:09 <mark4> see even IM confuzed
12:25:15 <tangentstorm> okay that makes sense now.
12:25:19 <mark4> so:  divide r1:r2 by r0
12:25:27 <mark4> where r1 is high ahnd r2 is low
12:25:47 <mark4> lets have a race to see who can become more confuzered faster!
12:25:51 <mark4> so far im winning
12:26:01 <tangentstorm> :)
12:26:11 <tangentstorm> okay.. so let's disregard all the math in the middle for a minute.
12:26:40 <tangentstorm> does  PUSH r1  affect  r0?
12:26:46 <mark4> no
12:27:12 --- quit: asie (Quit: I'll probably come back in either 20 minutes or 8 hours.)
12:27:15 <tangentstorm> what does PUSH do? i'm guessing the all caps indicates a macro
12:27:15 <mark4> but mov r0, r2 overwrites r0 with r2. thats putting the remainder in r0 and the quotient on the stack
12:27:33 <mark4> it is a macro it does a stmia sp!, { reg }
12:27:48 <mark4> even tho its only pushing ONE item im using the store multiple opcode
12:27:53 <tangentstorm> hang on
12:27:56 <mark4> stm is store multiple, ldm is load multiple
12:28:03 <tangentstorm> why is it ldmia sp!   ?
12:28:13 <tangentstorm> shouldn't you *decrement* the stack pointer?
12:28:16 <mark4> you can use ANY register as a stack pointer
12:28:27 <mark4> sp is actually just one of the general purpose registers
12:28:40 <mark4> but its the one commonly chosen for use as a stack pointer
12:28:52 <mark4> i could do stmia r0!, { xxx, yyy, zzz }
12:28:55 <tangentstorm> but if PUSH does sp! and ldmia does sp! ... that doesn't seem right.
12:28:57 <mark4> and use r0 as a stack pointer
12:29:10 <mark4> the ! part says 
12:29:12 <tangentstorm> they shouldn't both increment
12:29:17 <mark4> 'update this stack pointer"
12:29:24 <mark4> ok wait
12:29:31 <mark4>  ldmia stima ldmdb stmdb
12:29:38 <mark4> increment after, decrement before
12:29:53 <mark4> but you can aso do stmia ldmdb
12:30:20 <mark4> i.e. you can have grows up or down. and you can leave th stack pointing to the next FULL stack item (where to pop from next) or next empty item, where to push to next
12:30:22 <tangentstorm> but you said push is doing  stmia ... store and increment after.
12:30:26 <mark4> yes
12:30:34 <tangentstorm> but it's loading and incrementing after already.
12:30:39 <mark4> erm no i lied. 
12:30:42 <tangentstorm> line 3 should be db
12:30:42 <mark4> my stacks are grows down
12:30:53 <mark4> ldmia is a pop
12:31:06 <tangentstorm> so push says  stmdb ? :)
12:31:12 <mark4> pop from the address pointed to by sp, into registers r1 and r2, increment the stack pointer after each pop,
12:31:17 <mark4> yes
12:31:20 <tangentstorm> ok
12:31:36 <mark4> arm has the concept of a full stack or an empty stack
12:31:49 <mark4> in a full stack the pointr points to the last item pushed
12:32:01 <mark4> in an empty stack the stack pointer points to the next slot to be pushed into
12:32:11 <mark4> you can also have grows up or grows down stacks
12:32:17 <mark4> ldmia stmdb  ldmdb stima
12:33:02 <mark4> you can also do a pop off the stack WITHOUT updating the pointer
12:33:12 <mark4> i.e. copy N items off the stack but leave SP unchanged
12:33:17 <tangentstorm> ok
12:33:19 <mark4> ldmia sp, { .... }
12:33:31 <tangentstorm> neat
12:33:34 <mark4> the ! part makes it update the stack
12:34:00 <mark4> internally the stack pointer is updated to do the multiple pops but when its finished sp itself is not modified
12:34:07 <mark4> unless you specify !
12:34:14 <mark4>   ldmia sp!, { .... }
12:35:28 <tangentstorm> ok
12:40:42 <tangentstorm> http://bpaste.net/show/x67U1jq5jGJFabALa5B7/
12:40:51 <tangentstorm> are my comments more accurate now?
12:40:58 <tangentstorm> or just are they accurate? :)
12:41:44 <tangentstorm> it seems odd that r4 is 0 but is only used on line 7
12:42:02 <tangentstorm> maybe my translation of line 7 is wrong?
12:42:36 <mark4> no that loosk right
12:42:59 <mark4> but i am questioning this opcodes functionality, r4 is initialized to zero
12:43:17 <mark4> so thats the same as adding r1 *2 to r1
12:43:23 <mark4> or r1 *= 3
12:43:31 <mark4> which CANT be right for the algorithm
12:45:34 <tangentstorm> maybe a line got dropped somewhere?
12:48:47 <tangentstorm> oh
12:48:52 <tangentstorm> adc actually adds the carry flag
12:48:57 <mark4> yes
12:51:29 <tangentstorm> so when you say subs remembers the carry flag... does that mean it restores the carry flag to whatever it was before the subtraction?
12:51:55 --- quit: regreg (Ping timeout: 252 seconds)
12:52:21 <mark4> no
12:53:00 <mark4> if i say add(sub) r0, r1  NO carry/borrow is generated
12:53:13 <mark4> but if i say subs then it will be
12:53:17 <tangentstorm> oh ok
12:53:21 <mark4> s says "set result flags"
12:53:52 <mark4> cmp and cmps are the same because cmp always generates a result in the status flags
12:54:00 <mark4> cmps is deprecated for this reason
12:54:22 <mark4>  cmp is actually a SUB but does not store the result, it just tores the status flags
12:55:16 <mark4> divide r1:r2 by r0.  r4 is a dedicated 0
12:56:23 <mark4> erm i got my code from riscy forths implementation. i dont think i can use this code as is, i need to implement my own
12:56:32 <mark4> i think this code is pure gpl and that makes it a virus
12:56:48 <mark4> plus this is SIGNED> i need unsigned
12:57:59 <tangentstorm> just as well since it doesn't work and we don't understand it anyway :)
12:58:08 <mark4> and its also 32 bit 
12:58:26 <mark4> actually no the comments are fibbing
12:59:05 <mark4> movs r2, r2, lsl #1 followed by adc r1, r0, r1, lsl #1
12:59:20 <mark4> says add r1 shifted left by 1 into r4 and store the result in r1
12:59:32 <mark4> so thats a 64 bit shift. r4 is always 0
12:59:48 <mark4> so add 2* R1 to R4 and store result in R1
13:01:20 <mark4> Freely available under a modified BSD/MIT/X license.
13:01:25 <mark4> not GPL maybe i can use it
13:01:26 <tangentstorm> that's what r1 := r4 + (r1 * 2) means
13:01:33 <tangentstorm> but adc also adds the carry flag.
13:01:35 <mark4> yes
13:01:43 <mark4> yes the carry is from the previous shift
13:01:44 <tangentstorm> so r1 := r4 + (r1 * 2) + c;
13:01:48 <mark4> yes
13:02:12 <tangentstorm> ok.. that's what my comment says... i'm looking at http://bpaste.net/show/EjUWVbZjF08I5N4XXXNa/ ... not sure when i last pasted the url :)
13:03:33 <mark4> that subs r1, r1, r0 is a test subtract. if r0 can be subtracted with no borrow then we add 1 to r2
13:03:43 <mark4> otherwise we undo the subtract 
13:03:50 <tangentstorm> yaeh
13:04:27 <tangentstorm> part of my problem is i don't actually know what the division algorithm should be. :)
13:04:53 * tangentstorm thinks all the way back to elementary school math ... :)
13:04:55 <mark4> it should be a floored unsigned division of a 64 bit number by a 32 bit number
13:05:41 <tangentstorm> yeah but i can't even remember the last time i did long division by hand.. let alone in binary :)
13:06:16 <mark4> i think this algorithm is b0rked i think i need to email frank seargant
13:06:31 <tangentstorm> what does unsigned division mean when applied to -123 and 10 ?
13:07:05 <tangentstorm> just that it treats it as positive FFFFFFFFFFFFFF85 ?
13:07:41 <mark4> yes
13:11:11 <tangentstorm> what does this mean in gforth? hex FFFFFFFFFFFFFF85 s>d A ud/mod . . 1999999999999999 -6666666666666673  ok
13:11:49 <tangentstorm> same as decimal -123 s>d hex A ud/mod . .
13:13:13 <mark4> gforth is a 64 bit forth here
13:13:23 <mark4> so your double number is 128 bits
13:13:32 <mark4> my forth is a 32 bit forht so my double number is 64 bits
13:14:27 <tangentstorm> ok lemme install isforth
13:16:02 <mark4> kk
13:16:08 <mark4> i just emailed frank seargant
13:16:16 <mark4> assuming he is still alive im sure he will respond :)
13:16:21 <tangentstorm> i don't know who that is
13:16:40 <mark4> frank seargant wrote pygmy forth. he has a version of it for arm called riscy pigness
13:16:47 <mark4> or riscy for short
13:17:57 <tangentstorm> ah
13:18:36 <mark4> this also explains why .date in my arm forth tries to tell me its sat, 05 Feb 2106 23:28:16 -700 
13:18:45 <mark4> when the same .date function in isforth is accurate :P
13:18:52 <mark4> i think /mod is b0rked
13:19:09 <mark4> fix this and im thinking im 99% of the way to initial release
13:23:58 --- quit: tangentstorm (Ping timeout: 240 seconds)
13:25:21 <mark4> dang he pinged out
13:27:41 --- join: tangentstorm (~michal@108.218.151.22) joined #forth
13:28:18 <mark4> wb tangentstorm 
13:28:24 <mark4> did you download isforth?
13:28:27 <mark4> can you run a test?
13:28:43 <mark4> look at src/ext/rnd.f and run that inside gforth?
13:28:55 <mark4> see what 100 rnd . 100 rnd . 100 rnd . 100 rnd . repatedly gives?
13:29:05 <tangentstorm> i downloaded it but when i tried to run it, things kind of blew up :)
13:29:06 <mark4> does it give any huge negative results?
13:29:11 <mark4> yea i know why
13:29:19 <mark4> your running ubuntu or debian or a debian based forth
13:29:23 <mark4> i can tell you how to fix
13:29:31 <tangentstorm> yeah i'm on debian
13:29:36 <tangentstorm> it didn't recognize my term at first
13:29:45 <mark4> cp -rv /lib/terminfo/* /usr/share/terminfo/
13:29:46 <mark4> then run it
13:30:17 <mark4> because debian does NOT honor the FHS and i refuse to modify isforth to fix debian breakages
13:30:30 <mark4> i.e. isforth expects ALL terminfo files to be in /usr/share/terminfo
13:30:34 <mark4> not in /lib/terminfo
13:30:36 <tangentstorm> what's fhs?
13:32:26 <mark4> filesystem heirachy standard
13:32:35 <mark4> i.e. what files belong in what locations under /
13:32:46 <mark4> terminfo belongs in /usr/share/terminfo NOT in /lib
13:32:47 <tangentstorm> ok
13:34:30 <tangentstorm> well that's slightly better
13:35:00 <tangentstorm> it shows the top line now but the bottom lines iconstantlyredrawwing and i can'ty type in it
13:35:00 <mark4> what terminal are yu using
13:35:05 <tangentstorm> tmux
13:35:19 <mark4> yea. stop using tmux or the like
13:35:21 <tangentstorm> it identifies itself as screen-256colors
13:35:26 <mark4> they have broken terminfo
13:35:33 <tangentstorm> ok... sorry, i'm just not going to use isforth :(
13:35:43 <mark4> use straight xterm or lxterm 
13:35:56 <mark4> tmux is broken and again. i refuse to modify isforth to fix it
13:36:07 <mark4> so is screen. isforth will not run inside a screen session
13:36:51 <mark4> use xfce4 terminal, that has tabs. no need for a broken multiplexer
13:38:24 <tangentstorm> okay, well sorry.
13:39:05 <tangentstorm> i know i've had isforth working in the past but it's not working for me now and i'm not going to change my whole system just to run it. sorry.
13:39:35 <mark4> well tru using rnd.f in gforth
13:39:43 <mark4> see if it returns any wildly negative results
13:39:57 <tangentstorm> just type rnd.f ?
13:40:12 <mark4> dont know how to include files in gforth
13:40:16 <tangentstorm> me either :)
13:40:18 <mark4> have gforth cmpile rnd.f
13:40:31 <tangentstorm> where's rnd.f ?
13:40:33 <mark4> but it wont compile because gforth uses "Value" where i usen "Var"
13:40:42 <tangentstorm> oh i don't even have it on the same machine
13:40:45 <mark4> u wud need to convert the seeds to 0 value seed1
13:40:46 <tangentstorm> i'm on freebsd
13:40:52 <mark4> aha
13:40:59 --- quit: true-grue (Read error: Connection reset by peer)
13:41:07 <tangentstorm> i was trying to ssh into my little tiny linux box to run the linux version of isforth
13:44:45 <tangentstorm> i had isforth running on kubuntu previously, but my kubuntu box died and i replaced it with freebsd.
13:47:00 <mark4> aha
13:53:21 <tangentstorm> okay i have isforth running centos now.
13:53:45 <tangentstorm> it's displaying correctly but... when i type  1 2 3 4 .   it shows 4 ok... then when i type . it shows 10 ok
13:53:51 <mark4> kk the colors will look wacky if your in gnome term but only because black is not 0 there
13:54:01 <tangentstorm> i'm in putty
13:54:10 <mark4> erm thats weird
13:54:16 <mark4> what does 1 2 3 4 . . . . do
13:54:29 <tangentstorm> i'm on a windows box connecting to centos via ssh (putty)
13:54:39 <mark4> ths may be a term thig still
13:54:43 --- join: Azel (~Thunderbi@125.82.69.86.rev.sfr.net) joined #forth
13:54:44 <mark4> quit out of isforth and do
13:54:48 <mark4> export TERM=xterm
13:54:50 <tangentstorm> 1 2 3 4 . . . . 4 3 2 1  ok
13:54:54 <mark4> then do the test again
13:55:06 <mark4> 1 2 3 4 . 4 ok
13:55:09 <mark4> . 3 ok >
13:55:10 <mark4> ?
13:55:19 <tangentstorm> now it works
13:55:28 <tangentstorm> i had TERM=xterm-256color before.
13:55:40 <mark4> yea ill have to test that
13:55:54 <mark4> might be a bug in the terminfo, might be a bug in isforth
13:56:13 <mark4> 100 rnd . 100 rnd . 100 rnd .  always returns a number from 1 to 100 in isforth
13:57:37 <tangentstorm> oh i tried    : test 100 do 100 rnd . loop ;
13:57:45 <tangentstorm> clearly that's not the right thing to try :)
13:57:48 <mark4> yea i do that too
13:57:51 <tangentstorm> any way to stop an infinite loop?
13:57:56 <mark4> lol
13:58:04 <mark4> i see what u mean. u had a bug
13:58:18 <mark4> ssh in again and kill it
13:58:58 <mark4> you can also do
13:59:00 <mark4> 100 rnd .
13:59:05 <mark4> then cursor up and hit enter again
13:59:17 <mark4> if cursor up does not return history just type
13:59:19 <mark4> smkx
13:59:22 <mark4> and it will do so
13:59:51 <tangentstorm> what's the right way to make the loop?
14:00:47 <tangentstorm> smkx worked... i don't see any negatives
14:01:06 <mark4> : test 100 0 do 100 rnd . loop ;
14:01:23 <mark4> that will do 100 itteratiins
14:01:34 <mark4> end start do .... loop
14:01:49 <tangentstorm> oh i was missing the second number. thanks.
14:02:17 <tangentstorm> cool
14:02:19 <tangentstorm> no negatives
14:02:31 <mark4> yup i know. it works in isforth not in my arm forth lol
14:02:49 <tangentstorm> what did you want me to try?
14:04:06 <mark4> well i wanted to know if my rng workd in gforth
14:04:28 <mark4> but in my sources where it says 0 var seed1 and 0 var seed2 you woud have to change it to 0 value seed1(2)
14:06:41 <tangentstorm> oh
14:08:39 <tangentstorm> well, i'm about out of time here. maybe later if you still need it. :)
14:10:01 --- quit: goingretro (Ping timeout: 272 seconds)
14:16:32 --- join: ASau` (~user@p54AFFD35.dip0.t-ipconnect.de) joined #forth
14:19:01 --- quit: ASau (Ping timeout: 246 seconds)
14:19:17 --- quit: impomatic (Ping timeout: 264 seconds)
14:19:42 --- join: impomatic (~digital_w@87.114.102.71) joined #forth
14:28:29 --- join: nisstyre (~yours@oftn/member/Nisstyre) joined #forth
14:31:35 --- join: goingretro (~kbmaniac@host86-157-24-207.range86-157.btcentralplus.com) joined #forth
14:50:12 --- quit: nighty-_ (Quit: Disappears in a puff of smoke)
14:50:34 --- join: nighty^ (~nighty@lns-bzn-49f-62-147-170-46.adsl.proxad.net) joined #forth
14:51:44 --- join: mnemnion (~mnemnion@8.23.141.40) joined #forth
15:04:01 --- join: LinearInterpol (~RJones@cpe-76-179-150-229.maine.res.rr.com) joined #forth
15:05:02 --- quit: mnemnion (Remote host closed the connection)
15:21:15 --- quit: nisstyre (Quit: Leaving)
17:26:24 --- quit: LinearInterpol (Read error: Connection reset by peer)
17:27:10 --- join: LinearInterpol (~RJones@cpe-76-179-150-229.maine.res.rr.com) joined #forth
17:41:05 --- join: Zarutian (~zarutian@194-144-84-110.du.xdsl.is) joined #forth
18:07:39 --- join: foucist (~foobala@c-50-178-193-111.hsd1.in.comcast.net) joined #forth
18:08:03 --- part: foucist left #forth
18:08:52 --- join: regreg (~regreg@77.81.151.155) joined #forth
18:21:26 <jyf> tangentstorm: its simple, just add a new user forth which's login shell is your isforth, and give it the permission to login via ssh
18:21:52 <jyf> tangentstorm: next time you use ssh forth@yourhost , you would got an isforth console :]
18:36:58 --- quit: LinearInterpol (Ping timeout: 241 seconds)
19:02:52 --- join: kumool (~mool@adsl-64-237-224-44.prtc.net) joined #forth
19:24:50 --- join: spoofer (~cruella@72.10.28.164) joined #forth
19:28:15 --- quit: Zarutian (Quit: Zarutian)
19:44:00 --- quit: kumool (Ping timeout: 246 seconds)
19:46:44 --- join: cem_ (75dd7e3d@gateway/web/freenode/ip.117.221.126.61) joined #forth
19:54:09 --- join: Bahman (~Bahman@2.146.52.153) joined #forth
20:15:01 --- join: nisstyre (~yours@oftn/member/Nisstyre) joined #forth
20:36:00 --- join: kumul (~mool@adsl-64-237-225-236.prtc.net) joined #forth
20:43:38 --- quit: kumul (Quit: Leaving)
20:48:16 --- quit: spoofer (Ping timeout: 265 seconds)
21:06:47 --- join: spoofer (~cruella@72.10.28.164) joined #forth
21:07:05 --- quit: spoofer (Remote host closed the connection)
21:55:32 --- quit: regreg (Ping timeout: 246 seconds)
21:59:21 --- join: asie (~textual@178235038113.elblag.vectranet.pl) joined #forth
22:04:21 --- join: regreg (~regreg@77.81.151.155) joined #forth
22:20:58 --- quit: asie (Quit: I'll probably come back in either 20 minutes or 8 hours.)
22:40:33 --- quit: cem_ (Ping timeout: 250 seconds)
23:24:43 <jyf> got a beta version notice of 8th
23:25:09 <jyf> which the author claim it would take many features with the performance still better than nodejs :]
23:26:05 <mark4> what?
23:26:20 <mark4> no idea what 8th or jodejs is
23:26:39 <jyf> 8th is an forth inspired lang
23:26:51 <jyf> i think you could guessed that fromt the name
23:27:06 <mark4> trying to say it is better than 4th
23:27:35 <mark4> lots of people have talked that talk, none have been able to walk it
23:28:07 <mark4> there are many forth inspired languages and every single one that i can tell make the language more complicated and less efficient
23:28:27 <jyf> http://aaron-tech.com/
23:30:11 <jyf> well this author is pragmatic
23:50:52 --- quit: Azel (Ping timeout: 265 seconds)
23:59:59 --- log: ended forth/13.11.25