WebSVN – Kolibri OS – Blame – /drivers/devman/acpica/utilities/utclib.c

Rev	Author	Line No.	Line
1498	serge	1	/******************************************************************************
		2	*
		3	* Module Name: cmclib - Local implementation of C library functions
		4	*
		5	*****************************************************************************/
		6
		7	/******************************************************************************
		8	*
		9	* 1. Copyright Notice
		10	*
2216	Serge	11	* Some or all of this work - Copyright (c) 1999 - 2011, Intel Corp.
1498	serge	12	* All rights reserved.
		13	*
		14	* 2. License
		15	*
		16	* 2.1. This is your license from Intel Corp. under its intellectual property
		17	* rights. You may have additional license terms from the party that provided
		18	* you this software, covering your right to use that party's intellectual
		19	* property rights.
		20	*
		21	* 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
		22	* copy of the source code appearing in this file ("Covered Code") an
		23	* irrevocable, perpetual, worldwide license under Intel's copyrights in the
		24	* base code distributed originally by Intel ("Original Intel Code") to copy,
		25	* make derivatives, distribute, use and display any portion of the Covered
		26	* Code in any form, with the right to sublicense such rights; and
		27	*
		28	* 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
		29	* license (with the right to sublicense), under only those claims of Intel
		30	* patents that are infringed by the Original Intel Code, to make, use, sell,
		31	* offer to sell, and import the Covered Code and derivative works thereof
		32	* solely to the minimum extent necessary to exercise the above copyright
		33	* license, and in no event shall the patent license extend to any additions
		34	* to or modifications of the Original Intel Code. No other license or right
		35	* is granted directly or by implication, estoppel or otherwise;
		36	*
		37	* The above copyright and patent license is granted only if the following
		38	* conditions are met:
		39	*
		40	* 3. Conditions
		41	*
		42	* 3.1. Redistribution of Source with Rights to Further Distribute Source.
		43	* Redistribution of source code of any substantial portion of the Covered
		44	* Code or modification with rights to further distribute source must include
		45	* the above Copyright Notice, the above License, this list of Conditions,
		46	* and the following Disclaimer and Export Compliance provision. In addition,
		47	* Licensee must cause all Covered Code to which Licensee contributes to
		48	* contain a file documenting the changes Licensee made to create that Covered
		49	* Code and the date of any change. Licensee must include in that file the
		50	* documentation of any changes made by any predecessor Licensee. Licensee
		51	* must include a prominent statement that the modification is derived,
		52	* directly or indirectly, from Original Intel Code.
		53	*
		54	* 3.2. Redistribution of Source with no Rights to Further Distribute Source.
		55	* Redistribution of source code of any substantial portion of the Covered
		56	* Code or modification without rights to further distribute source must
		57	* include the following Disclaimer and Export Compliance provision in the
		58	* documentation and/or other materials provided with distribution. In
		59	* addition, Licensee may not authorize further sublicense of source of any
		60	* portion of the Covered Code, and must include terms to the effect that the
		61	* license from Licensee to its licensee is limited to the intellectual
		62	* property embodied in the software Licensee provides to its licensee, and
		63	* not to intellectual property embodied in modifications its licensee may
		64	* make.
		65	*
		66	* 3.3. Redistribution of Executable. Redistribution in executable form of any
		67	* substantial portion of the Covered Code or modification must reproduce the
		68	* above Copyright Notice, and the following Disclaimer and Export Compliance
		69	* provision in the documentation and/or other materials provided with the
		70	* distribution.
		71	*
		72	* 3.4. Intel retains all right, title, and interest in and to the Original
		73	* Intel Code.
		74	*
		75	* 3.5. Neither the name Intel nor any other trademark owned or controlled by
		76	* Intel shall be used in advertising or otherwise to promote the sale, use or
		77	* other dealings in products derived from or relating to the Covered Code
		78	* without prior written authorization from Intel.
		79	*
		80	* 4. Disclaimer and Export Compliance
		81	*
		82	* 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
		83	* HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
		84	* IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
		85	* INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
		86	* UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
		87	* IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
		88	* PARTICULAR PURPOSE.
		89	*
		90	* 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
		91	* OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
		92	* COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
		93	* SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
		94	* CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
		95	* HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
		96	* SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
		97	* LIMITED REMEDY.
		98	*
		99	* 4.3. Licensee shall not export, either directly or indirectly, any of this
		100	* software or system incorporating such software without first obtaining any
		101	* required license or other approval from the U. S. Department of Commerce or
		102	* any other agency or department of the United States Government. In the
		103	* event Licensee exports any such software from the United States or
		104	* re-exports any such software from a foreign destination, Licensee shall
		105	* ensure that the distribution and export/re-export of the software is in
		106	* compliance with all laws, regulations, orders, or other restrictions of the
		107	* U.S. Export Administration Regulations. Licensee agrees that neither it nor
		108	* any of its subsidiaries will export/re-export any technical data, process,
		109	* software, or service, directly or indirectly, to any country for which the
		110	* United States government or any agency thereof requires an export license,
		111	* other governmental approval, or letter of assurance, without first obtaining
		112	* such license, approval or letter.
		113	*
		114	*****************************************************************************/
		115
		116
		117	#define __CMCLIB_C__
		118
		119	#include "acpi.h"
		120	#include "accommon.h"
		121
		122	/*
		123	* These implementations of standard C Library routines can optionally be
		124	* used if a C library is not available. In general, they are less efficient
		125	* than an inline or assembly implementation
		126	*/
		127
		128	#define _COMPONENT ACPI_UTILITIES
		129	ACPI_MODULE_NAME ("cmclib")
		130
		131
		132	#ifndef ACPI_USE_SYSTEM_CLIBRARY
		133
		134	#define NEGATIVE 1
		135	#define POSITIVE 0
		136
		137
		138	/*******************************************************************************
		139	*
		140	* FUNCTION: AcpiUtMemcmp (memcmp)
		141	*
		142	* PARAMETERS: Buffer1 - First Buffer
		143	* Buffer2 - Second Buffer
		144	* Count - Maximum # of bytes to compare
		145	*
		146	* RETURN: Index where Buffers mismatched, or 0 if Buffers matched
		147	*
		148	* DESCRIPTION: Compare two Buffers, with a maximum length
		149	*
		150	******************************************************************************/
		151
		152	int
		153	AcpiUtMemcmp (
		154	const char *Buffer1,
		155	const char *Buffer2,
		156	ACPI_SIZE Count)
		157	{
		158
		159	for ( ; Count-- && (Buffer1 == Buffer2); Buffer1++, Buffer2++)
		160	{
		161	}
		162
		163	return ((Count == ACPI_SIZE_MAX) ? 0 : ((unsigned char) *Buffer1 -
		164	(unsigned char) *Buffer2));
		165	}
		166
		167
		168	/*******************************************************************************
		169	*
		170	* FUNCTION: AcpiUtMemcpy (memcpy)
		171	*
		172	* PARAMETERS: Dest - Target of the copy
		173	* Src - Source buffer to copy
		174	* Count - Number of bytes to copy
		175	*
		176	* RETURN: Dest
		177	*
		178	* DESCRIPTION: Copy arbitrary bytes of memory
		179	*
		180	******************************************************************************/
		181
		182	void *
		183	AcpiUtMemcpy (
		184	void *Dest,
		185	const void *Src,
		186	ACPI_SIZE Count)
		187	{
		188	char New = (char ) Dest;
		189	char Old = (char ) Src;
		190
		191
		192	while (Count)
		193	{
		194	New = Old;
		195	New++;
		196	Old++;
		197	Count--;
		198	}
		199
		200	return (Dest);
		201	}
		202
		203
		204	/*******************************************************************************
		205	*
		206	* FUNCTION: AcpiUtMemset (memset)
		207	*
		208	* PARAMETERS: Dest - Buffer to set
		209	* Value - Value to set each byte of memory
		210	* Count - Number of bytes to set
		211	*
		212	* RETURN: Dest
		213	*
		214	* DESCRIPTION: Initialize a buffer to a known value.
		215	*
		216	******************************************************************************/
		217
		218	void *
		219	AcpiUtMemset (
		220	void *Dest,
		221	UINT8 Value,
		222	ACPI_SIZE Count)
		223	{
		224	char New = (char ) Dest;
		225
		226
		227	while (Count)
		228	{
		229	*New = (char) Value;
		230	New++;
		231	Count--;
		232	}
		233
		234	return (Dest);
		235	}
		236
		237
		238	/*******************************************************************************
		239	*
		240	* FUNCTION: AcpiUtStrlen (strlen)
		241	*
		242	* PARAMETERS: String - Null terminated string
		243	*
		244	* RETURN: Length
		245	*
		246	* DESCRIPTION: Returns the length of the input string
		247	*
		248	******************************************************************************/
		249
		250
		251	ACPI_SIZE
		252	AcpiUtStrlen (
		253	const char *String)
		254	{
		255	UINT32 Length = 0;
		256
		257
		258	/* Count the string until a null is encountered */
		259
		260	while (*String)
		261	{
		262	Length++;
		263	String++;
		264	}
		265
		266	return (Length);
		267	}
		268
		269
		270	/*******************************************************************************
		271	*
		272	* FUNCTION: AcpiUtStrcpy (strcpy)
		273	*
		274	* PARAMETERS: DstString - Target of the copy
		275	* SrcString - The source string to copy
		276	*
		277	* RETURN: DstString
		278	*
		279	* DESCRIPTION: Copy a null terminated string
		280	*
		281	******************************************************************************/
		282
		283	char *
		284	AcpiUtStrcpy (
		285	char *DstString,
		286	const char *SrcString)
		287	{
		288	char *String = DstString;
		289
		290
		291	/* Move bytes brute force */
		292
		293	while (*SrcString)
		294	{
		295	String = SrcString;
		296
		297	String++;
		298	SrcString++;
		299	}
		300
		301	/* Null terminate */
		302
		303	*String = 0;
		304	return (DstString);
		305	}
		306
		307
		308	/*******************************************************************************
		309	*
		310	* FUNCTION: AcpiUtStrncpy (strncpy)
		311	*
		312	* PARAMETERS: DstString - Target of the copy
		313	* SrcString - The source string to copy
		314	* Count - Maximum # of bytes to copy
		315	*
		316	* RETURN: DstString
		317	*
		318	* DESCRIPTION: Copy a null terminated string, with a maximum length
		319	*
		320	******************************************************************************/
		321
		322	char *
		323	AcpiUtStrncpy (
		324	char *DstString,
		325	const char *SrcString,
		326	ACPI_SIZE Count)
		327	{
		328	char *String = DstString;
		329
		330
		331	/* Copy the string */
		332
		333	for (String = DstString;
		334	Count && (Count--, (String++ = SrcString++)); )
		335	{;}
		336
		337	/* Pad with nulls if necessary */
		338
		339	while (Count--)
		340	{
		341	*String = 0;
		342	String++;
		343	}
		344
		345	/* Return original pointer */
		346
		347	return (DstString);
		348	}
		349
		350
		351	/*******************************************************************************
		352	*
		353	* FUNCTION: AcpiUtStrcmp (strcmp)
		354	*
		355	* PARAMETERS: String1 - First string
		356	* String2 - Second string
		357	*
		358	* RETURN: Index where strings mismatched, or 0 if strings matched
		359	*
		360	* DESCRIPTION: Compare two null terminated strings
		361	*
		362	******************************************************************************/
		363
		364	int
		365	AcpiUtStrcmp (
		366	const char *String1,
		367	const char *String2)
		368	{
		369
		370
		371	for ( ; (String1 == String2); String2++)
		372	{
		373	if (!*String1++)
		374	{
		375	return (0);
		376	}
		377	}
		378
		379	return ((unsigned char) String1 - (unsigned char) String2);
		380	}
		381
		382
		383	#ifdef ACPI_FUTURE_IMPLEMENTATION
		384	/* Not used at this time */
		385	/*******************************************************************************
		386	*
		387	* FUNCTION: AcpiUtStrchr (strchr)
		388	*
		389	* PARAMETERS: String - Search string
		390	* ch - character to search for
		391	*
		392	* RETURN: Ptr to char or NULL if not found
		393	*
		394	* DESCRIPTION: Search a string for a character
		395	*
		396	******************************************************************************/
		397
		398	char *
		399	AcpiUtStrchr (
		400	const char *String,
		401	int ch)
		402	{
		403
		404
		405	for ( ; (*String); String++)
		406	{
		407	if ((*String) == (char) ch)
		408	{
		409	return ((char *) String);
		410	}
		411	}
		412
		413	return (NULL);
		414	}
		415	#endif
		416
		417	/*******************************************************************************
		418	*
		419	* FUNCTION: AcpiUtStrncmp (strncmp)
		420	*
		421	* PARAMETERS: String1 - First string
		422	* String2 - Second string
		423	* Count - Maximum # of bytes to compare
		424	*
		425	* RETURN: Index where strings mismatched, or 0 if strings matched
		426	*
		427	* DESCRIPTION: Compare two null terminated strings, with a maximum length
		428	*
		429	******************************************************************************/
		430
		431	int
		432	AcpiUtStrncmp (
		433	const char *String1,
		434	const char *String2,
		435	ACPI_SIZE Count)
		436	{
		437
		438
		439	for ( ; Count-- && (String1 == String2); String2++)
		440	{
		441	if (!*String1++)
		442	{
		443	return (0);
		444	}
		445	}
		446
		447	return ((Count == ACPI_SIZE_MAX) ? 0 : ((unsigned char) *String1 -
		448	(unsigned char) *String2));
		449	}
		450
		451
		452	/*******************************************************************************
		453	*
		454	* FUNCTION: AcpiUtStrcat (Strcat)
		455	*
		456	* PARAMETERS: DstString - Target of the copy
		457	* SrcString - The source string to copy
		458	*
		459	* RETURN: DstString
		460	*
		461	* DESCRIPTION: Append a null terminated string to a null terminated string
		462	*
		463	******************************************************************************/
		464
		465	char *
		466	AcpiUtStrcat (
		467	char *DstString,
		468	const char *SrcString)
		469	{
		470	char *String;
		471
		472
		473	/* Find end of the destination string */
		474
		475	for (String = DstString; *String++; )
		476	{ ; }
		477
		478	/* Concatenate the string */
		479
		480	for (--String; (String++ = SrcString++); )
		481	{ ; }
		482
		483	return (DstString);
		484	}
		485
		486
		487	/*******************************************************************************
		488	*
		489	* FUNCTION: AcpiUtStrncat (strncat)
		490	*
		491	* PARAMETERS: DstString - Target of the copy
		492	* SrcString - The source string to copy
		493	* Count - Maximum # of bytes to copy
		494	*
		495	* RETURN: DstString
		496	*
		497	* DESCRIPTION: Append a null terminated string to a null terminated string,
		498	* with a maximum count.
		499	*
		500	******************************************************************************/
		501
		502	char *
		503	AcpiUtStrncat (
		504	char *DstString,
		505	const char *SrcString,
		506	ACPI_SIZE Count)
		507	{
		508	char *String;
		509
		510
		511	if (Count)
		512	{
		513	/* Find end of the destination string */
		514
		515	for (String = DstString; *String++; )
		516	{ ; }
		517
		518	/* Concatenate the string */
		519
		520	for (--String; (String++ = SrcString++) && --Count; )
		521	{ ; }
		522
		523	/* Null terminate if necessary */
		524
		525	if (!Count)
		526	{
		527	*String = 0;
		528	}
		529	}
		530
		531	return (DstString);
		532	}
		533
		534
		535	/*******************************************************************************
		536	*
		537	* FUNCTION: AcpiUtStrstr (strstr)
		538	*
		539	* PARAMETERS: String1 - Target string
		540	* String2 - Substring to search for
		541	*
		542	* RETURN: Where substring match starts, Null if no match found
		543	*
		544	* DESCRIPTION: Checks if String2 occurs in String1. This is not really a
		545	* full implementation of strstr, only sufficient for command
		546	* matching
		547	*
		548	******************************************************************************/
		549
		550	char *
		551	AcpiUtStrstr (
		552	char *String1,
		553	char *String2)
		554	{
		555	char *String;
		556
		557
		558	if (AcpiUtStrlen (String2) > AcpiUtStrlen (String1))
		559	{
		560	return (NULL);
		561	}
		562
		563	/* Walk entire string, comparing the letters */
		564
		565	for (String = String1; *String2; )
		566	{
		567	if (String2 != String)
		568	{
		569	return (NULL);
		570	}
		571
		572	String2++;
		573	String++;
		574	}
		575
		576	return (String1);
		577	}
		578
		579
		580	/*******************************************************************************
		581	*
		582	* FUNCTION: AcpiUtStrtoul (strtoul)
		583	*
		584	* PARAMETERS: String - Null terminated string
		585	* Terminater - Where a pointer to the terminating byte is
		586	* returned
		587	* Base - Radix of the string
		588	*
		589	* RETURN: Converted value
		590	*
		591	* DESCRIPTION: Convert a string into a 32-bit unsigned value.
		592	* Note: use AcpiUtStrtoul64 for 64-bit integers.
		593	*
		594	******************************************************************************/
		595
		596	UINT32
		597	AcpiUtStrtoul (
		598	const char *String,
		599	char **Terminator,
		600	UINT32 Base)
		601	{
		602	UINT32 converted = 0;
		603	UINT32 index;
		604	UINT32 sign;
		605	const char *StringStart;
		606	UINT32 ReturnValue = 0;
		607	ACPI_STATUS Status = AE_OK;
		608
		609
		610	/*
		611	* Save the value of the pointer to the buffer's first
		612	* character, save the current errno value, and then
		613	* skip over any white space in the buffer:
		614	*/
		615	StringStart = String;
		616	while (ACPI_IS_SPACE (String) \|\| String == '\t')
		617	{
		618	++String;
		619	}
		620
		621	/*
		622	* The buffer may contain an optional plus or minus sign.
		623	* If it does, then skip over it but remember what is was:
		624	*/
		625	if (*String == '-')
		626	{
		627	sign = NEGATIVE;
		628	++String;
		629	}
		630	else if (*String == '+')
		631	{
		632	++String;
		633	sign = POSITIVE;
		634	}
		635	else
		636	{
		637	sign = POSITIVE;
		638	}
		639
		640	/*
		641	* If the input parameter Base is zero, then we need to
		642	* determine if it is octal, decimal, or hexadecimal:
		643	*/
		644	if (Base == 0)
		645	{
		646	if (*String == '0')
		647	{
		648	if (AcpiUtToLower (*(++String)) == 'x')
		649	{
		650	Base = 16;
		651	++String;
		652	}
		653	else
		654	{
		655	Base = 8;
		656	}
		657	}
		658	else
		659	{
		660	Base = 10;
		661	}
		662	}
		663	else if (Base < 2 \|\| Base > 36)
		664	{
		665	/*
		666	* The specified Base parameter is not in the domain of
		667	* this function:
		668	*/
		669	goto done;
		670	}
		671
		672	/*
		673	* For octal and hexadecimal bases, skip over the leading
		674	* 0 or 0x, if they are present.
		675	*/
		676	if (Base == 8 && *String == '0')
		677	{
		678	String++;
		679	}
		680
		681	if (Base == 16 &&
		682	*String == '0' &&
		683	AcpiUtToLower (*(++String)) == 'x')
		684	{
		685	String++;
		686	}
		687
		688	/*
		689	* Main loop: convert the string to an unsigned long:
		690	*/
		691	while (*String)
		692	{
		693	if (ACPI_IS_DIGIT (*String))
		694	{
		695	index = (UINT32) ((UINT8) *String - '0');
		696	}
		697	else
		698	{
		699	index = (UINT32) AcpiUtToUpper (*String);
		700	if (ACPI_IS_UPPER (index))
		701	{
		702	index = index - 'A' + 10;
		703	}
		704	else
		705	{
		706	goto done;
		707	}
		708	}
		709
		710	if (index >= Base)
		711	{
		712	goto done;
		713	}
		714
		715	/*
		716	* Check to see if value is out of range:
		717	*/
		718
		719	if (ReturnValue > ((ACPI_UINT32_MAX - (UINT32) index) /
		720	(UINT32) Base))
		721	{
		722	Status = AE_ERROR;
		723	ReturnValue = 0; /* reset */
		724	}
		725	else
		726	{
		727	ReturnValue *= Base;
		728	ReturnValue += index;
		729	converted = 1;
		730	}
		731
		732	++String;
		733	}
		734
		735	done:
		736	/*
		737	* If appropriate, update the caller's pointer to the next
		738	* unconverted character in the buffer.
		739	*/
		740	if (Terminator)
		741	{
		742	if (converted == 0 && ReturnValue == 0 && String != NULL)
		743	{
		744	Terminator = (char ) StringStart;
		745	}
		746	else
		747	{
		748	Terminator = (char ) String;
		749	}
		750	}
		751
		752	if (Status == AE_ERROR)
		753	{
		754	ReturnValue = ACPI_UINT32_MAX;
		755	}
		756
		757	/*
		758	* If a minus sign was present, then "the conversion is negated":
		759	*/
		760	if (sign == NEGATIVE)
		761	{
		762	ReturnValue = (ACPI_UINT32_MAX - ReturnValue) + 1;
		763	}
		764
		765	return (ReturnValue);
		766	}
		767
		768
		769	/*******************************************************************************
		770	*
		771	* FUNCTION: AcpiUtToUpper (TOUPPER)
		772	*
		773	* PARAMETERS: c - Character to convert
		774	*
		775	* RETURN: Converted character as an int
		776	*
		777	* DESCRIPTION: Convert character to uppercase
		778	*
		779	******************************************************************************/
		780
		781	int
		782	AcpiUtToUpper (
		783	int c)
		784	{
		785
		786	return (ACPI_IS_LOWER(c) ? ((c)-0x20) : (c));
		787	}
		788
		789
		790	/*******************************************************************************
		791	*
		792	* FUNCTION: AcpiUtToLower (TOLOWER)
		793	*
		794	* PARAMETERS: c - Character to convert
		795	*
		796	* RETURN: Converted character as an int
		797	*
		798	* DESCRIPTION: Convert character to lowercase
		799	*
		800	******************************************************************************/
		801
		802	int
		803	AcpiUtToLower (
		804	int c)
		805	{
		806
		807	return (ACPI_IS_UPPER(c) ? ((c)+0x20) : (c));
		808	}
		809
		810
		811	/*******************************************************************************
		812	*
		813	* FUNCTION: is* functions
		814	*
		815	* DESCRIPTION: is* functions use the ctype table below
		816	*
		817	******************************************************************************/
		818
		819	const UINT8 _acpi_ctype[257] = {
		820	_ACPI_CN, /* 0x0 0. */
		821	_ACPI_CN, /* 0x1 1. */
		822	_ACPI_CN, /* 0x2 2. */
		823	_ACPI_CN, /* 0x3 3. */
		824	_ACPI_CN, /* 0x4 4. */
		825	_ACPI_CN, /* 0x5 5. */
		826	_ACPI_CN, /* 0x6 6. */
		827	_ACPI_CN, /* 0x7 7. */
		828	_ACPI_CN, /* 0x8 8. */
		829	_ACPI_CN\|_ACPI_SP, /* 0x9 9. */
		830	_ACPI_CN\|_ACPI_SP, /* 0xA 10. */
		831	_ACPI_CN\|_ACPI_SP, /* 0xB 11. */
		832	_ACPI_CN\|_ACPI_SP, /* 0xC 12. */
		833	_ACPI_CN\|_ACPI_SP, /* 0xD 13. */
		834	_ACPI_CN, /* 0xE 14. */
		835	_ACPI_CN, /* 0xF 15. */
		836	_ACPI_CN, /* 0x10 16. */
		837	_ACPI_CN, /* 0x11 17. */
		838	_ACPI_CN, /* 0x12 18. */
		839	_ACPI_CN, /* 0x13 19. */
		840	_ACPI_CN, /* 0x14 20. */
		841	_ACPI_CN, /* 0x15 21. */
		842	_ACPI_CN, /* 0x16 22. */
		843	_ACPI_CN, /* 0x17 23. */
		844	_ACPI_CN, /* 0x18 24. */
		845	_ACPI_CN, /* 0x19 25. */
		846	_ACPI_CN, /* 0x1A 26. */
		847	_ACPI_CN, /* 0x1B 27. */
		848	_ACPI_CN, /* 0x1C 28. */
		849	_ACPI_CN, /* 0x1D 29. */
		850	_ACPI_CN, /* 0x1E 30. */
		851	_ACPI_CN, /* 0x1F 31. */
		852	_ACPI_XS\|_ACPI_SP, /* 0x20 32. ' ' */
		853	_ACPI_PU, /* 0x21 33. '!' */
		854	_ACPI_PU, /* 0x22 34. '"' */
		855	_ACPI_PU, /* 0x23 35. '#' */
		856	_ACPI_PU, /* 0x24 36. '$' */
		857	_ACPI_PU, /* 0x25 37. '%' */
		858	_ACPI_PU, /* 0x26 38. '&' */
		859	_ACPI_PU, /* 0x27 39. ''' */
		860	_ACPI_PU, /* 0x28 40. '(' */
		861	_ACPI_PU, /* 0x29 41. ')' */
		862	_ACPI_PU, /* 0x2A 42. '' /
		863	_ACPI_PU, /* 0x2B 43. '+' */
		864	_ACPI_PU, /* 0x2C 44. ',' */
		865	_ACPI_PU, /* 0x2D 45. '-' */
		866	_ACPI_PU, /* 0x2E 46. '.' */
		867	_ACPI_PU, /* 0x2F 47. '/' */
		868	_ACPI_XD\|_ACPI_DI, /* 0x30 48. '0' */
		869	_ACPI_XD\|_ACPI_DI, /* 0x31 49. '1' */
		870	_ACPI_XD\|_ACPI_DI, /* 0x32 50. '2' */
		871	_ACPI_XD\|_ACPI_DI, /* 0x33 51. '3' */
		872	_ACPI_XD\|_ACPI_DI, /* 0x34 52. '4' */
		873	_ACPI_XD\|_ACPI_DI, /* 0x35 53. '5' */
		874	_ACPI_XD\|_ACPI_DI, /* 0x36 54. '6' */
		875	_ACPI_XD\|_ACPI_DI, /* 0x37 55. '7' */
		876	_ACPI_XD\|_ACPI_DI, /* 0x38 56. '8' */
		877	_ACPI_XD\|_ACPI_DI, /* 0x39 57. '9' */
		878	_ACPI_PU, /* 0x3A 58. ':' */
		879	_ACPI_PU, /* 0x3B 59. ';' */
		880	_ACPI_PU, /* 0x3C 60. '<' */
		881	_ACPI_PU, /* 0x3D 61. '=' */
		882	_ACPI_PU, /* 0x3E 62. '>' */
		883	_ACPI_PU, /* 0x3F 63. '?' */
		884	_ACPI_PU, /* 0x40 64. '@' */
		885	_ACPI_XD\|_ACPI_UP, /* 0x41 65. 'A' */
		886	_ACPI_XD\|_ACPI_UP, /* 0x42 66. 'B' */
		887	_ACPI_XD\|_ACPI_UP, /* 0x43 67. 'C' */
		888	_ACPI_XD\|_ACPI_UP, /* 0x44 68. 'D' */
		889	_ACPI_XD\|_ACPI_UP, /* 0x45 69. 'E' */
		890	_ACPI_XD\|_ACPI_UP, /* 0x46 70. 'F' */
		891	_ACPI_UP, /* 0x47 71. 'G' */
		892	_ACPI_UP, /* 0x48 72. 'H' */
		893	_ACPI_UP, /* 0x49 73. 'I' */
		894	_ACPI_UP, /* 0x4A 74. 'J' */
		895	_ACPI_UP, /* 0x4B 75. 'K' */
		896	_ACPI_UP, /* 0x4C 76. 'L' */
		897	_ACPI_UP, /* 0x4D 77. 'M' */
		898	_ACPI_UP, /* 0x4E 78. 'N' */
		899	_ACPI_UP, /* 0x4F 79. 'O' */
		900	_ACPI_UP, /* 0x50 80. 'P' */
		901	_ACPI_UP, /* 0x51 81. 'Q' */
		902	_ACPI_UP, /* 0x52 82. 'R' */
		903	_ACPI_UP, /* 0x53 83. 'S' */
		904	_ACPI_UP, /* 0x54 84. 'T' */
		905	_ACPI_UP, /* 0x55 85. 'U' */
		906	_ACPI_UP, /* 0x56 86. 'V' */
		907	_ACPI_UP, /* 0x57 87. 'W' */
		908	_ACPI_UP, /* 0x58 88. 'X' */
		909	_ACPI_UP, /* 0x59 89. 'Y' */
		910	_ACPI_UP, /* 0x5A 90. 'Z' */
		911	_ACPI_PU, /* 0x5B 91. '[' */
		912	_ACPI_PU, /* 0x5C 92. '\' */
		913	_ACPI_PU, /* 0x5D 93. ']' */
		914	_ACPI_PU, /* 0x5E 94. '^' */
		915	_ACPI_PU, /* 0x5F 95. '_' */
		916	_ACPI_PU, /* 0x60 96. '`' */
		917	_ACPI_XD\|_ACPI_LO, /* 0x61 97. 'a' */
		918	_ACPI_XD\|_ACPI_LO, /* 0x62 98. 'b' */
		919	_ACPI_XD\|_ACPI_LO, /* 0x63 99. 'c' */
		920	_ACPI_XD\|_ACPI_LO, /* 0x64 100. 'd' */
		921	_ACPI_XD\|_ACPI_LO, /* 0x65 101. 'e' */
		922	_ACPI_XD\|_ACPI_LO, /* 0x66 102. 'f' */
		923	_ACPI_LO, /* 0x67 103. 'g' */
		924	_ACPI_LO, /* 0x68 104. 'h' */
		925	_ACPI_LO, /* 0x69 105. 'i' */
		926	_ACPI_LO, /* 0x6A 106. 'j' */
		927	_ACPI_LO, /* 0x6B 107. 'k' */
		928	_ACPI_LO, /* 0x6C 108. 'l' */
		929	_ACPI_LO, /* 0x6D 109. 'm' */
		930	_ACPI_LO, /* 0x6E 110. 'n' */
		931	_ACPI_LO, /* 0x6F 111. 'o' */
		932	_ACPI_LO, /* 0x70 112. 'p' */
		933	_ACPI_LO, /* 0x71 113. 'q' */
		934	_ACPI_LO, /* 0x72 114. 'r' */
		935	_ACPI_LO, /* 0x73 115. 's' */
		936	_ACPI_LO, /* 0x74 116. 't' */
		937	_ACPI_LO, /* 0x75 117. 'u' */
		938	_ACPI_LO, /* 0x76 118. 'v' */
		939	_ACPI_LO, /* 0x77 119. 'w' */
		940	_ACPI_LO, /* 0x78 120. 'x' */
		941	_ACPI_LO, /* 0x79 121. 'y' */
		942	_ACPI_LO, /* 0x7A 122. 'z' */
		943	_ACPI_PU, /* 0x7B 123. '{' */
		944	_ACPI_PU, /* 0x7C 124. '\|' */
		945	_ACPI_PU, /* 0x7D 125. '}' */
		946	_ACPI_PU, /* 0x7E 126. '~' */
		947	_ACPI_CN, /* 0x7F 127. */
		948
		949	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x80 to 0x8F */
		950	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x90 to 0x9F */
		951	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xA0 to 0xAF */
		952	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xB0 to 0xBF */
		953	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xC0 to 0xCF */
		954	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xD0 to 0xDF */
		955	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xE0 to 0xEF */
		956	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* 0xF0 to 0x100 */
		957	};
		958
		959
		960	#endif /* ACPI_USE_SYSTEM_CLIBRARY */
		961

Subversion Repositories Kolibri OS

(root)/drivers/devman/acpica/utilities/utclib.c @ 2254 – Rev 2216