Implementing >NUMBER without parts of the Double-Word set

[SirWumpus]

Curious how one would implement the core word >NUMBER? It would seem that one would need portions of the optional double word set to handle portions of the conversion, eg.

: >NUMBER ( ud1 caddr len -- ud2 caddr' len' )
	BEGIN
	  DUP 0>			\ S: udl udh caddr len
	WHILE
	  OVER C@			\ S: udl udh caddr len char
	  _digit_value			\ S: udl udh caddr len digit
	  DUP BASE @ >= IF		\ S: udl udh caddr len digit
	    DROP EXIT			\ S: ud' caddr' len'
          THEN				\ S: udl udh caddr len digit
	  ROT CHAR+ ROT 1-		\ S: ud1 udh digit caddr' len'
	  2>R >R BASE @			\ S: udl udh base	R: caddr' len' digit
	  UM* ROT BASE @		\ S: hl hh udl base	R: caddr' len' digit
	  UM*				\ S: hl hh ll lh	R: caddr' len' digit
	  R> M+				\ S: hl hh ll' lh'	R: caddr' len'
	  D+ 2R>			\ S: udl' udh' caddr' len'
	REPEAT
;

It works, but seems like a cheat. How would this be done without parts of the double word set? Do implementers just add D+ and M+ (figuring they'll be needed eventually)? Or is there some clever trick I'm not seeing with just the core words?

Shouldn't the Core Word Set contain all the words necessary (like M+) to implement core words that are not built-in primitives? In which case those words are misplaced in the 2012 standard and draft?

[MitchBradley]

">NUMBER" does not have to be implemented in Forth. It could be in C, or ASM, or whatever language the core is written in.

I suspect that most if not all useable Forth implementations - as opposed to proofs of concept that nobody really uses and are probably not fully conformant - do implement double numbers. If that is correct, the question is largely hypothetical and the "misplaced" thing is essentially nit-picking.

[ruv]

Just for reference, >NUMBER from SP-Forth/4 does not employ M+ directly, and it looks slightly simpler:

: >NUMBER ( ud1 c-addr1 u1 -- ud2 c-addr2 u2 ) 
  BEGIN
    DUP
  WHILE
    >R
    DUP >R
    C@ BASE @ DIGIT 0=     \ ud n flag
    IF R> R> EXIT THEN     \ ud n  ( ud = udh udl )
    SWAP BASE @ UM* DROP   \ udl n udh*base
    ROT BASE @ UM* D+      \ (n udh*base)+(udl*baseD)
    R> CHAR+ R> 1-
  REPEAT
;

The words D+ can be implemented in a lazy way as follows:

: CARRY ( u1 u2 -- 1|0 )
  NEGATE -1 + U> ABS
;  
: D+ ( d1 d2 -- d3 )
  ROT + >R 2DUP CARRY >R + 2R> +
;

And the word UM* is in the CORE word set — it's obligated.

Therefore, >NUMBER can be implemented in the basis of CORE words set only.