Hex

Function: string hex(integer value);

Returns the hexadecimal nybbles of the signed integer value in order. Specifically returns the nybbles from most to least significant, starting with the first nonzero nybble, folding every nybble to lower case, and beginning with the nonnegative "0x" or the negative "-0x" prefix.

Parameters:

• integer

value

–

signed value to be expressed as signed hex

Note: Results with eight nybbles begin always with one of the positive signed nybbles 1 2 3 4 5 6 7, never with a zero or unsigned nybble 0 8 9 A B C D E F.

Caution: This page was a work in progress as of 2007-10. The specification, the implementations, the demo, and the sample results may not yet be totally consistent.

Implementations

Easy To Use, and Correct At A Glance

You should find this implementation feels easy to call and modify and review. Please consider sharing your experience in the discussion tab.

FIXME

Fast

You should agree this implementation feels like it could run fast in 2007 SL before Mono. Please consider contributing measures of how much faster/ smaller this code is to the discussion tab.

// http://wiki.secondlife.com/wiki/hex

string XDIGITS = "0123456789abcdef"; // could be "0123456789ABCDEF"

string hexu(integer bits)
{
    integer lsbs = (bits & 0xF);
    string nybbles = llGetSubString(XDIGITS, lsbs, lsbs);
    if ((bits = (0xfffFFFF & (bits >> 4))))
    {
        do
        {
            nybbles = llGetSubString(XDIGITS, lsbs = (bits & 0xF), lsbs) + nybbles;
        } while ((bits = (bits >> 4)));
    }
    return "0x" + nybbles;
}

string hex(integer value)
{
    if (value < 0) return "-" + hexu(-value);
    return hexu(value);
}

Small

You should agree that reworking the correct-at-a-glance implementation to make the code run faster feels like making the LSL compiler produce more byte code. Please consider contributing smaller code here.

Demo

Print the most astonishing test cases for the hex function and then also the permission masks of the script running to demo the hex function.

Code:

default
{
    state_entry()
    {
        llOwnerSay("Hello");
        llOwnerSay(hex(0) + " == 0");
        llOwnerSay(hex(0x00FEDC00 & -0x00FEDC00) + " == (0x00FEDC00 & -0x00FEDC00)");
        llOwnerSay(hex(1 << 30) + " == (1 << 30)");
        llOwnerSay(hex(0x80000000) + " == 0x80000000");
        llOwnerSay(hex(0xFEDC9876) + " == 0xFEDC9876");
        llOwnerSay(hex(-1) + " == -1");
        llOwnerSay(hex(0x123456789) + " == 0x123456789");
        llOwnerSay("OK");
        
        llOwnerSay("Hello again");
        string item = llGetScriptName();
        llOwnerSay(hex(llGetInventoryPermMask(item, MASK_BASE)) + " as base");
        llOwnerSay(hex(llGetInventoryPermMask(item, MASK_OWNER)) + " by owner");
        llOwnerSay(hex(llGetInventoryPermMask(item, MASK_GROUP)) + " by group");
        llOwnerSay(hex(llGetInventoryPermMask(item, MASK_EVERYONE)) + " by anyone");
        llOwnerSay(hex(llGetInventoryPermMask(item, MASK_NEXT)) + " by next owner");
        llOwnerSay("aka " + (string) llGetInventoryPermMask(item, MASK_NEXT));
        llOwnerSay("OK");
    }
}

Sample Results:

Hello
0x0 == 0
0x400 == (0x00FEDC00 & -0x00FEDC00)
0x40000000 == (1 << 30)
-0x80000000 == 0x80000000
-0x123678a == 0xFEDC9876
-0x1 == -1
-0x1 == 0x123456789
OK
Hello again
0x7fffffff as base
0x7fffffff by owner
0x0 by group
0x0 by anyone
0x82000 by next owner
aka 532480
OK

Specification By Consensus

We programmers divide into schools by our passionately held personal aesthetics, just like other poets. Not everyone here agrees exactly on the relative measures and importance of such fuzzy source code qualities as:

1. easy to use
2. correct at a glance
3. small
4. fast

The implementations we present here work exactly like the hex function of the Python scripting language, doc'ed deep within http://docs.python.org/lib/built-in-funcs.html after such disputes over its detailed specification as http://www.python.org/dev/peps/pep-0237/

Specifically, these implementations:

1. return lower case a b c d e f rather than upper case A B C D E F,
2. return a signed 31-bit result if negative, rather than an unsigned 32-bit result, and
3. omit the leading quads of zeroed bits, except returns "0x0" rather than "0x" when the result is zero.

In this way, these implementations reproduce how hex integer literals often appear in LSL script, conforming to such traditional AT&T C conventions as:

1. Return a meaningless "0" before the "x", as LSL and C compilers require.
2. Return the "x" on the left as in LSL and C, not the "h" on the right as in Assembly code.
3. Return the nybbles listed from most to least significant as in English, not listed from least to most significant as in Arabic.

As you read this page, you have to wade thru more than one implementation only because not all our community yet agrees that the only code you wish to see is the code from my school.

See Also

Functions

• llGetInventoryPermMask
• llGetObjectPermMask
• llIntegerToBase64
• llBase64ToInteger
• llMessageLinked
• llList2Integer
• llList2String