if (readCnt == 1)            {            /* data was read, so process */            scanCode = atScanCode;            if ((scanCode & UGL_PCKBD_EXTENDED_KEY) == UGL_PCKBD_EXTENDED_KEY)                pKbdData->extendedKey = (scanCode & ~UGL_PCKBD_EXTENDED_KEY) + 1;            else                {                newLedValue = pKbdData->ledValue;                modifiers = pService->inputModifiers;                /* Key Up? */                if (scanCode & UGL_PCKBD_MAKE_FLAG)                    {                    keyDown = UGL_FALSE;                    modifiers &= ~UGL_KEYBOARD_KEYDOWN;                    scanCode &= ~UGL_PCKBD_MAKE_FLAG;                    }                else                    {                    keyDown = UGL_TRUE;                    modifiers |= UGL_KEYBOARD_KEYDOWN;                    }                /* processing extended key sequence ? */                if (pKbdData->extendedKey > 0)                    {                    scanCode |= UGL_PCKBD_EXT_FLAG;                    if (--pKbdData->extendedKey)                        return (UGL_STATUS_DROP);                    }                /* Update modifier states. */                switch (scanCode)                    {                    case UGL_PCKBD_LEFT_ALT:                        if (keyDown)                             modifiers |= UGL_KEYBOARD_LEFT_ALT;                        else                            modifiers &= ~UGL_KEYBOARD_LEFT_ALT;                        scanCode |= UGL_PCKBD_MOD_KEY;                        break;                    case UGL_PCKBD_RIGHT_ALT:                        if (keyDown)                             modifiers |= UGL_KEYBOARD_RIGHT_ALT;                        else                            modifiers &= ~UGL_KEYBOARD_RIGHT_ALT;                        scanCode |= UGL_PCKBD_MOD_KEY;                        break;                    case UGL_PCKBD_LEFT_CTRL:                        if (keyDown)                             modifiers |= UGL_KEYBOARD_LEFT_CTRL;                        else                            modifiers &= ~UGL_KEYBOARD_LEFT_CTRL;                        scanCode |= UGL_PCKBD_MOD_KEY;                        break;                    case UGL_PCKBD_RIGHT_CTRL:                        if (keyDown)                             modifiers |= UGL_KEYBOARD_RIGHT_CTRL;                        else                            modifiers &= ~UGL_KEYBOARD_RIGHT_CTRL;                        scanCode |= UGL_PCKBD_MOD_KEY;                        break;                    case UGL_PCKBD_LEFT_SHIFT:                        if (keyDown)                             modifiers |= UGL_KEYBOARD_LEFT_SHIFT;                        else                            modifiers &= ~UGL_KEYBOARD_LEFT_SHIFT;                        scanCode |= UGL_PCKBD_MOD_KEY;                        break;                    case UGL_PCKBD_RIGHT_SHIFT:                        if (keyDown)                             modifiers |= UGL_KEYBOARD_RIGHT_SHIFT;                        else                            modifiers &= ~UGL_KEYBOARD_RIGHT_SHIFT;                        scanCode |= UGL_PCKBD_MOD_KEY;                        break;                    case UGL_PCKBD_CAPS_LOCK:                        if (keyDown)                            {                            if (modifiers & UGL_KEYBOARD_CAPS_LOCK)                                 {                                modifiers &= ~UGL_KEYBOARD_CAPS_LOCK;                                newLedValue &= ~UGL_KEYBOARD_LED_CAPS_LOCK;                                }                            else                                {                                modifiers |= UGL_KEYBOARD_CAPS_LOCK;                                newLedValue |= UGL_KEYBOARD_LED_CAPS_LOCK;                                }                            scanCode |= UGL_PCKBD_MOD_KEY;                            }                        break;                    case UGL_PCKBD_NUM_LOCK:                        if (keyDown)                            {                            if (modifiers & UGL_KEYBOARD_NUM_LOCK)                                 {                                modifiers &= ~UGL_KEYBOARD_NUM_LOCK;                                newLedValue &= ~UGL_KEYBOARD_LED_NUM_LOCK;                                }                            else                                {                                modifiers |= UGL_KEYBOARD_NUM_LOCK;                                newLedValue |= UGL_KEYBOARD_LED_NUM_LOCK;                                }                            scanCode |= UGL_PCKBD_MOD_KEY;                            }                        break;                    case UGL_PCKBD_SCROLL_LOCK:                        if (keyDown)                            {                            if (modifiers & UGL_KEYBOARD_SCROLL_LOCK)                                 {                                modifiers &= ~UGL_KEYBOARD_SCROLL_LOCK;                                newLedValue &= ~UGL_KEYBOARD_LED_SCROLL_LOCK;                                }                            else                                {                                modifiers |= UGL_KEYBOARD_SCROLL_LOCK;                                newLedValue |= UGL_KEYBOARD_LED_SCROLL_LOCK;                                }                            scanCode |= UGL_PCKBD_MOD_KEY;                            }                        break;                    }                /* Update the keyboard leds */                if ((pKbdData->ledValue != newLedValue) &&                                     (pKbdData->ledControl))                    ioctl (pDevice->fd, CONIOLEDS, newLedValue);                pKbdData->ledValue = newLedValue;                /* build input event */                pInputEvent->header.type = UGL_EVENT_TYPE_KEYBOARD;                pInputEvent->header.category = UGL_EVENT_CATEGORY_INPUT;                pInputEvent->modifiers = modifiers;                pInputEvent->type.keyboard.scanCode = scanCode;                /* convert scan code to unicode */                pInputEvent->type.keyboard.key = MapKeyValue (scanCode, modifiers);                if (pInputEvent->type.keyboard.key == 0)                    status = UGL_STATUS_DROP;                else                    status = UGL_STATUS_OK;                return (status);                }            }        }    return (status);    }/******************************************************************************** MapKeyValue - map a scan code to Unicode value** This routien maps a scan code to a unicode value.  The <keyValue> which* is a PC AT scan code is mapped to the corresonding unicode value, adjusted* by the current state of the key modifiers (shift, num lock, etc.) which* is present in <modifiers>.** RETURNS:  mapped unicode value when mapping available, otherwise zero** ERRNO: N/A** SEE ALSO: */UGL_LOCAL UGL_UINT16 MapKeyValue    (    UGL_UINT16   keyValue,       /* scan code */    UGL_UINT32  modifiers       /* modifier state */     )    {    int unshiftedKeyValue;    int shiftedKeyValue;    UGL_BOOL numLock = modifiers & UGL_KEYBOARD_NUM_LOCK;    UGL_BOOL capsLock = modifiers & UGL_KEYBOARD_CAPS_LOCK;    UGL_BOOL shift = modifiers & UGL_KEYBOARD_SHIFT;    UGL_BOOL ctrl = modifiers & UGL_KEYBOARD_CTRL;    UGL_BOOL modChg = keyValue & UGL_PCKBD_MOD_KEY;/* Select the keyboard mapping */#ifdef  INCLUDE_KMAP_ENGLISH_US    PC_KBD_KEYMAP * pKbdKeyMapTable = pcKbdUsKeyMapTable;    size_t sizeOfKmap = sizeOfUsKmap;#endif /* INCLUDE_KMAP_ENGLISH_US */#ifdef  INCLUDE_KMAP_ENGLISH_UK    PC_KBD_KEYMAP * pKbdKeyMapTable = pcKbdUkKeyMapTable;    size_t sizeOfKmap = sizeOfUkKmap;#endif /* INCLUDE_KMAP_ENGLISH_UK */#ifdef  INCLUDE_KMAP_GERMAN    PC_KBD_KEYMAP * pKbdKeyMapTable = pcKbdDeKeyMapTable;    size_t sizeOfKmap = sizeOfDeKmap;#endif /* INCLUDE_KMAP_GERMAN */#ifdef  INCLUDE_KMAP_ITALIAN    PC_KBD_KEYMAP * pKbdKeyMapTable = pcKbdItKeyMapTable;    size_t sizeOfKmap = sizeOfItKmap;#endif /* INCLUDE_KMAP_ITALIAN */#ifdef  INCLUDE_KMAP_FRENCH    PC_KBD_KEYMAP * pKbdKeyMapTable = pcKbdFrKeyMapTable;    size_t sizeOfKmap = sizeOfFrKmap;#endif /* INCLUDE_KMAP_FRENCH */#ifdef  INCLUDE_KMAP_SWEDISH    PC_KBD_KEYMAP * pKbdKeyMapTable = pcKbdSwKeyMapTable;    size_t sizeOfKmap = sizeOfSwKmap;#endif /* INCLUDE_KMAP_SWEDISH */#ifdef  INCLUDE_KMAP_NONE    PC_KBD_KEYMAP * pKbdKeyMapTable = pcKbdNoKeyMapTable;    size_t sizeOfKmap = sizeOfNoKmap;#endif /* INCLUDE_KMAP_NONE */    keyValue &= ~UGL_PCKBD_MOD_KEY;    if (keyValue & UGL_PCKBD_EXT_FLAG)        {        /* turn off extended flag */        keyValue &= ~UGL_PCKBD_EXT_FLAG;        /* Don't process the extra 0x2a/0xaa on some extended keys */        if (keyValue == 0x2a)            return 0;        if (keyValue < sizeOfKmap /               sizeof(struct pckbdKeyMapStruct))            return ( pKbdKeyMapTable[keyValue].extendedKeyValue);        else            return 0;        }    else if (keyValue < sizeOfKmap /             sizeof(struct pckbdKeyMapStruct))        {        unshiftedKeyValue = pKbdKeyMapTable[keyValue].unshiftedKeyValue;        shiftedKeyValue = pKbdKeyMapTable[keyValue].shiftedKeyValue;        if (modChg)             return (unshiftedKeyValue);        else if (ctrl)            return (unshiftedKeyValue);        else if (numLock && shiftedKeyValue >= '0' && shiftedKeyValue <= '9')            return (shift ? unshiftedKeyValue : shiftedKeyValue);        else if (capsLock)            {            keyValue = (shift ? shiftedKeyValue : unshiftedKeyValue);            if (shift)                return (tolower(keyValue));            else                return (toupper(keyValue));            }        else            return (shift ? shiftedKeyValue : unshiftedKeyValue);        }    else        return 0;    }