# Unsigned Integers

``` BBS: Inland Empire Archive
Date: 03-04-93 (08:17)             Number: 348
From: ZACK JONES                   Refer#: NONE
To: CORIDON HENSHAW               Recvd: NO
Subj: Unsigned Integers              Conf: (2) Quik_Bas```
```Coridon,

Recently you were talking about unsigned integers in QB.  Well here's and
article I clipped out of Basic Pro Magazine.  See if it makes any sense to
you.  It really doesn't to me - I'm not much for bits and stuff like that.

Take Care, Zack Jones.

Beginning of article
**************************************************
As I mentioned earlier, Basic's INTEGER type has a range of +/- 32K.
There are times, though, when you need to use a two-byte variable to
represent an unsigned number with a range of 0 to 65,535, such as when
calling C routine to DOS services.

Basic uses the high bit of an integer to indicate the sign of the number,
so whenever such a variable exceeds 32,767, bit 16 is set and it's
interpreted as a negative number.  The key to faking an unsigned
integer, then, is to test the value and adjust the sign bit manually.
Say you want to use CALL INTERRUPT to readk 48K bytes from a file.  Since
48K is outside the rand of a Basic integer, you'll have to convert this
value to an unsiged integer to get to get it into the CX register for the
call.  Here's the brute-force method:

Bytes& = 49152
IF Bytes& > 32767 THEN
CX% = Bytes% - 65536
ELSE
CX% = Bytes&
END IF

This code simply checks the value of Bytes& and if it's too large, flips the
sign bit by subtracting 65536.

When CALL INTERRUPT returns, CX% will contain the number of bytes actually
read from the file.  If this number is greater then 32K, it will look to
Basic like a negative number, so you'll have to make the conversion in the
opposite direction:

Bytes& = CX% + 65536
ELSE
Bytes& = CX%
END IF

This addition and subtraction technique is perfectly valid and no one will
laugh at your code if you use it.  But if you're as obsessive about size and
speed as I am, you'll love the alternative!

The code snippet below stores the value of Bytes& in CX% as an unsigned
integer.  (see if you can figure out how it works):

CX% = Bytes& and &H7FFF
CX% = CX% OR -(Bytes& AND &H8000)

Give up?  The secret is the bitwise operators, AND and OR.

When you AND two numbers, the result in a given bit position is True
(denoted by a binary 1)  only when that bit is set in both numbers.
Conversely, the result of and OR is True if a given bit is set in either
number.

So the first line in the above code ANDs the contents of Bytes& with the
hexadecimal value of 7FFF (binary 01111111111111111).  This clears the
sign bit, and stores the lower 15 bits in CX%.  The second line ANDs
Bytes& with 8000 hex, which returns the state of the sign bit.  That
result is OR'd with CX%, thereby setting it's 16th bit to  match that of
Bytes&.

The only question that remains is Why is there a minus sign in front of
Bytes& and &H8000)?  If bit 16 is set, the result of this operation will
be 65,636 (2^15), and ORing CX% with that value will cause an overflow
error.  But by negating the result of the AND, you reduce the equation to:

CX% = CX% or -1

This handly avoids the overflow error, and adds only two bytes of code!

Converting an unsigned value back to a signed one is even simpler:

Bytes& = CX% and &HFFF&

This superimposes the binary image of CX% on the lower 16 bits of a long
integer (yes, the training & is vital!), and stores the result in Bytes&.

Either of these methods will work in QB, PDS and both versions of VB.  The
addition/subtraction approach is straight forward - it's immediately
apparent what's happening when you look at the code.  But if efficiency is
more imporant to you than readibility, you'll be interested to know the
code employing bitwise operators compiles 12 bytes smaller and runs 40%
faster then that using arithmetic.
*****************************************************
End of article.

___ Blue Wave/QWK v2.12

--- Maximus 2.01wb
* Origin: Zack's Shack ZyXEL 16.8! (210) 653-2115 (1:387/641)
```

Echo Basic Postings

Books at Amazon:

Back to BASIC: The History, Corruption, and Future of the Language

Hackers: Heroes of the Computer Revolution (including Tiny BASIC)

Go to: The Story of the Math Majors, Bridge Players, Engineers, Chess Wizards, Scientists and Iconoclasts who were the Hero Programmers of the Software Revolution

The Advent of the Algorithm: The Idea that Rules the World

Moths in the Machine: The Power and Perils of Programming

Mastering Visual Basic .NET