home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / pub / scripts / ckermit / hextodec < prev    next >
Encoding:
Text File  |  2020-01-01  |  10.2 KB  |  337 lines
  1. # Macros to convert signed decimal numbers to two's complement hexadecimal
  2. # notation.  This version does not use machine arithmetic; it does everything
  3. # with strings, so is able to handle integers of any size.  As written it
  4. # accommodates word sizes of 4, 8, 16, 32, 64, and 128 bits.  Other word
  5. # sizes can be added by changing the definitions at the top.
  6. # 
  7. # Because machine arithmetic is not used, this version is considerably slower
  8. # than the first one but it works for numbers that don't fit in 32 bits in
  9. # Kermit 95 and in 32-bit versions of C-Kermit.
  10. #
  11. # F. da Cruz, Columbia University, 7 January 2008
  12.  
  13. .legal = :4:8:16:32:64:128:             # Legal word sizes
  14.  
  15. # Largest positive integer for the supported word sizes
  16.  
  17. .maxint<4> = 7
  18. .maxint<8> = 127
  19. .maxint<16> = 32767
  20. .maxint<32> = 2147483647
  21. .maxint<64> = 9223372036854775807
  22. .maxint<128> = 340282366920938463463374607431768211455
  23.  
  24. # Ditto plus one (because we can't necessarily do arithmetic on big numbers)
  25.  
  26. .maxplusone<4> = 8
  27. .maxplusone<8> = 128
  28. .maxplusone<16> = 32768
  29. .maxplusone<32> = 2147483648
  30. .maxplusone<64> = 9223372036854775808
  31. .maxplusone<128> = 340282366920938463463374607431768211456
  32.  
  33. # Powers of 16 (need to add mor to get up to 128 bits)
  34.  
  35. local &p
  36. dcl \&p[] = 16 -
  37.  256 -
  38.  4096 -
  39.  65536 -
  40.  1048576 -
  41.  16777216 -
  42.  268435456 -
  43.  4294967296 -
  44.  68719476736 -
  45.  1099511627776 -
  46.  17592186044416 -
  47.  281474976710656 -
  48.  4503599627370496 -
  49.  72057594037927936 -
  50.  1152921504606846976 -
  51.  18446744073709551616
  52. .\&p[0] = 1
  53.  
  54. # Macro BINTOHEX converts a binary string to hex.
  55. #   \%1 = binary number (string)
  56. #   \%2 = word size in bits
  57. # 
  58. # \fradix() is constrained by machine integer word length
  59. # so we do it in pieces in case the number is too big.
  60. #
  61. define BINTOHEX {
  62.     undef \%6                                # Result accumulator
  63.     .\%1 := \flpad(\%1,\%2,0)                # Pad to size if necessary
  64.     for \%9 1 \%2 4 {                        # Do four bits at at a time
  65.         .\%8 := \fsubstr(\%1,\%9,4)          # Get chunk of 4
  66.         if not def \%8 break                 # Make sure we have one
  67.         .\%7 := \fradix(\%8,2,16)            # Convert to Hex digit
  68.         .\%6 := \%6\%7                       # Accumulate
  69.     }
  70.     return \%6
  71. }
  72.  
  73. def DIV2 {                                   # Divide decimal string by two
  74.     local \%i
  75.     undef \%6 \%7 result
  76.     for \%i 1 \flen(\%1) 1 {                 # One digit at a time.
  77.         .\%9 := \%7\:(\%1[\%i:1])            # Get a digit.
  78.         .\%8 ::= \%9/2                       # Divide it by 2
  79.         .\%7 ::= \%9%2                       # Get remainder
  80.         .\%6 := \%6\%8                       # Accumulate result
  81.     }
  82.     .result := \%6                           # Make result 
  83.     .remainder := \%7                        # and remainder visible
  84. }
  85.  
  86. def DTOB {                                   # Convert decimal string to binary
  87.     while true {                             # without using machine 
  88.         div2 \%1                             # arithmetic.
  89.         .\%6 := \m(remainder)\%6
  90.         .\%1 := \m(result)                    
  91.         if not \fverify(0,\%1) break
  92.     }        
  93.     return \%6
  94. }
  95. # Macro DECTOHEX converts a signed decimal number to 2's complement hex,
  96. # using the macros defined above as workers.
  97. #   \%1 = decimal number string (default 0)
  98. #   \%2 = word size in bits
  99. #         (must be a power of two, 4 or greater, default 32, max 128)
  100. #   Returns result in \v(result) and/or as value of \fexec(dectohex arg arg).
  101. #
  102. define DECTOHEX {
  103.     local digits
  104.     if not def \%1 .\%1 = 0                  # Supply default if no arg given
  105.     if not numeric \%1 return NOT_A_NUMBER:\%1  # Check that arg is a number
  106.     if not def \%2 .\%2 := 32                   # Use 32 bits if no second arg
  107.     if not \findex(:\%2:,\m(legal)) end 1 "UNSUPPORTED WORD SIZE - \%2"
  108.     .digits := \flen(\m(maxint<\%2>))           # Number of digits in it
  109.  
  110.     if eq "\fsubstr(\%1,1,1)" "+" .\%1 := \fsubstr(\%1,2) # strip any + sign
  111.     if not eq "\fsubstr(\%1,1,1)" "-" {      # If argument is not signed...
  112.         if lgt \flpad(\%1,\m(digits),0) \m(maxint<\%2>) return OVERFLOW
  113.         dtob \%1                             # Convert from decimal to binary
  114.         bintohex \v(return) \%2              # And from binary to hex
  115.         return \flpad(\v(return),(\%2/4),0)  # Return padded result
  116.     }
  117.     .\%1 := \fsubstr(\%1,2)                  # Negative number - remove sign
  118.     .\%1 := \flpad(\%1,\flen(\m(maxint<\%2>)),0) # Must use lexical comparison
  119.     if llt \m(maxplusone<\%2>) \%1 return UNDERFLOW # Check magnitude
  120.     dtob \%1                                 # Convert to binary
  121.     .\%9 := \flpad(\v(return),\%2,0)         # and pad
  122.     .\%8 ::= \frindex(1,\%9) - 1             # Find first 1 on the right
  123.     if == \%8 -1 return \frepeat(0,\%2 / 4)  # Watch out for negative 0
  124.     .\%7 := \fsubstr(\%9,1,\%8)              # Split string here
  125.     .\%6 := \fsubstitute(\%7,01,10)          # Complement bits in left part
  126.     .\%5 := \%6\fsubstr(\%9,\%8+1)           # Put back with right part
  127.     .\%4 := \fexec(bintohex \%5 \%2)         # Convert to hex
  128.     return \%4
  129. }
  130.  
  131. # Returns the 2's complement of the given binary string
  132. define TWOSCOMPLEMENT {
  133.     .\%2 = \flen(\%1)
  134.     .\%9 := \flpad(\%1,\%2,0)
  135.     .\%8 ::= \frindex(1,\%9) - 1             # Find first 1 on the right
  136.     if == \%8 -1 return \frepeat(0,\%2 / 4)  # Watch out for negative 0
  137.     .\%7 := \fsubstr(\%9,1,\%8)              # Split string here
  138.     .\%6 := \fsubstitute(\%7,01,10)          # Complement bits in left part
  139.     .\%5 := \%6\fsubstr(\%9,\%8+1)           # Put back with right part
  140.     return \%5
  141. }
  142.  
  143. # Converts hex string to binary
  144. define HEXTOBIN {
  145.     undef \%7
  146.     for \%9 1 \flen(\%1) 1 {
  147.         .\%7 := \%7\flpad(\fradix(\:(\%1[\%9:1]),16,2),4,0)
  148.     }
  149.     return \%7    
  150. }
  151.  
  152. # Not used - Could be used for optimization if necessary
  153. def IS32BIT { 
  154.     .\%1 := \flpad(\ftrim(\%1,0),10,0)
  155.     if lgt \%1 2147483647 return 0
  156.     return 1
  157. }
  158.  
  159. # Add two unsigned decimal strings regardless of magnitude
  160. #
  161. def DECIMALADD {
  162.     local \%s \%c
  163.     .\%9 := \fmax(\flen(\%1),\flen(\%2))
  164.     .\%1 := \flpad(\%1,\%9,0)
  165.     .\%2 := \flpad(\%2,\%9,0)
  166.     .\%c = 0
  167.     undef \%s
  168.     for \%9 \flen(\%1) 1 -1 {    
  169.         .\%6 := \:(\%1[\%9:1]) 
  170.         .\%7 := \:(\%2[\%9:1]) 
  171.         increment \%6 \%7+\%c
  172.     .\%5 ::= \%6 % 10
  173.     .\%c ::= \%6 / 10
  174.     .\%s := \%5\%s
  175.     }
  176.     if \%c .\%s := \%c\%s
  177.     return \%s
  178. }
  179.  
  180. # Multitply two decimal strings regardless of magnitude by repetitive
  181. # addition.  Practical only when one of the factors is small and the other
  182. # one is (or the result would be) bigger than the hardware integer size.
  183. #
  184. def DECIMALTIMES {
  185.     local \%s \%c
  186.     if > \%1 \%2 { .\%9 := \%1, .\%1 := \%2, .\%2 := \%9 }
  187.     .\%s = 0
  188.     for \%9 1 \%1 1 {
  189.         .\%s := \fexec(decimaladd \%2 \%s)
  190.     }    
  191.     return \%s
  192. }
  193.  
  194. # Convert a two's complement hexadecimal string into a signed
  195. # decimal string.  Currently works only up 64 bit word sizes, but that's
  196. # just a matter of adding more definitions at the top plus a few minor
  197. # adjustments.  Does not use machine arithmetic except where it is known
  198. # to be safe, so works for 64-bit quantities on 32-bit architectures.
  199. #
  200. define HEXTODEC {
  201.     local digits \%b \%d \%p
  202.     .digits := \flen(\%1)
  203.     if not \m(digits) end 1 "\%0: NO ARGUMENT GIVEN"
  204.     .\%1 := \fupper(\%1)
  205.     if \fverify(0123456789ABCDEF,\%1) end 1 "\%0: '\%1' NOT A HEX STRING"
  206.     if not \findex(\:(\%1[1:1]),89ABCDEF) {  # Positive number
  207.         .\%d = 0
  208.         .\%p = 0
  209.         for \%9 \flen(\%1) 1 -1 {  # Loop through digits right to left
  210.             .\%6 := \:(\%1[\%9:1])                    # Hex digit
  211.             .\%6 := \fradix(\%6,16,10)                # Decimal value
  212.             .\%6 := \fexec(decimaltimes \&p[\%p] \%6) # Times power of 16
  213.             .\%d := \fexec(decimaladd \%6 \%d)        # Add to result
  214.             increment \%p                             # Next power of 16
  215.         }
  216.         return \%d
  217.     }
  218.     # Negative number (bit 0 set)
  219.     if = 1 \findex(\%1,800000000000000000000000000) { # Special case
  220.         .\%b ::= \flen(\%1) * 4         # Look this one up in our table
  221.         .\%b := \m(maxplusone<\%b>)     # to avoid infinite recursion
  222.         if not def \%b .\%b = ERROR
  223.         return -\%b
  224.     }
  225.     .\%b := \fexec(hextobin \%1)        # Normal case - convert to binary
  226.     .\%7 := \flen(\%b)                  # Get length of binary
  227.     .\%b := \fexec(twoscomplement \%b)  # Get two's complement
  228.     .\%b := \fexec(bintohex \%b \%7)    # Convert to hex
  229.     .\%d := \fexec(hextodec \%b)        # Call ourselves to convert to decimal
  230.     return -\%d
  231. }
  232.  
  233. # Test HEXTODEC...
  234.  
  235. echo ****************
  236. echo TESTING HEXTODEC...
  237. echo ****************
  238. def try {
  239.     .t1 := \v(ftime)                    # Current time
  240.     .result := \fexec(hextodec \%1)
  241.     .t2 := \v(ftime)                    # New time
  242.     (setq t3 (- t2 t1))                 # Difference
  243.     echo HEX \%1 = DEC \m(result) [\ffpround(\m(t3),2) sec] # Print
  244. }
  245.  
  246. try 0
  247. try 7
  248. try 8
  249. try F
  250. try 1234
  251. try 80
  252. try 83
  253. try xxx
  254. try ffff
  255. try 8000
  256. try 8001
  257. try 5555
  258. try 12345
  259. try fffffffffffffffe
  260.  
  261. # TEST DECTOHEX...
  262.  
  263. echo ****************
  264. echo TESTING DECTOHEX...
  265. echo ****************
  266. def try {
  267.     # Note \v(time) lacks the fractional part in Windows for some reason.
  268.     .t1 := \v(ftime)                    # Current time
  269.     .result := \fexec(dectohex \%1 \%2) # Do the conversion
  270.     .t2 := \v(ftime)                    # New time
  271.     (setq t3 (- t2 t1))                 # Difference
  272.     echo \%1[\%2] = \m(result) [\ffpround(\m(t3),2) sec] # Print
  273. }
  274. try 7          # No word size specified
  275.  
  276. try  7 4       # 4-bit word
  277. try  8 4
  278. try -8 4
  279. try -9 4
  280. try 99 4
  281.  
  282. try  0 8        # 8-bit word
  283. try -0 8
  284. try  1 8
  285. try +1 8
  286. try  2 8
  287. try  3 8
  288. try  4 8
  289. try  5 8
  290. try  6 8
  291. try  7 8
  292. try -1 8
  293. try -2 8
  294. try -3 8
  295. try -4 8
  296. try -5 8
  297. try -6 8
  298. try -7 8
  299. try -8 8
  300. try 64 8
  301. try 65 8
  302. try -128 8
  303.  
  304. try 0 16       # 16-bit word
  305. try 64 16
  306. try 65 16
  307. try -128 16
  308. try -32768 16
  309. try 99999 16
  310. try -99999 16
  311.  
  312. try 0 32       # 32-bit word
  313. try 1 32
  314. try 16383 32
  315. try 2147483647 32
  316. try -1 32
  317. try -2 32
  318. try -2147483647 32
  319. try -2147483648 32
  320.  
  321. try 0 64       # 64-bit word
  322. try 2147483647 64
  323. try -1 64
  324. try -2 64
  325. try  1234567890 64
  326. try -2147483647 64
  327. try -2147483648 64
  328. try  8224373093854475231 64
  329.  
  330. try 0 128      # 128-bit word
  331. try 1 128
  332. try -1 128
  333. try -2 128
  334. try 317282366902934863643347307341786875499 128
  335.  
  336. if c-kermit exit
  337.