ReactOS  0.4.14-dev-49-gfb4591c
utprint.c
Go to the documentation of this file.
1 /******************************************************************************
2  *
3  * Module Name: utprint - Formatted printing routines
4  *
5  *****************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2019, Intel Corp.
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  * notice, this list of conditions, and the following disclaimer,
16  * without modification.
17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18  * substantially similar to the "NO WARRANTY" disclaimer below
19  * ("Disclaimer") and any redistribution must be conditioned upon
20  * including a substantially similar Disclaimer requirement for further
21  * binary redistribution.
22  * 3. Neither the names of the above-listed copyright holders nor the names
23  * of any contributors may be used to endorse or promote products derived
24  * from this software without specific prior written permission.
25  *
26  * Alternatively, this software may be distributed under the terms of the
27  * GNU General Public License ("GPL") version 2 as published by the Free
28  * Software Foundation.
29  *
30  * NO WARRANTY
31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41  * POSSIBILITY OF SUCH DAMAGES.
42  */
43 
44 #include "acpi.h"
45 #include "accommon.h"
46 
47 #define _COMPONENT ACPI_UTILITIES
48  ACPI_MODULE_NAME ("utprint")
49 
50 
51 #define ACPI_FORMAT_SIGN 0x01
52 #define ACPI_FORMAT_SIGN_PLUS 0x02
53 #define ACPI_FORMAT_SIGN_PLUS_SPACE 0x04
54 #define ACPI_FORMAT_ZERO 0x08
55 #define ACPI_FORMAT_LEFT 0x10
56 #define ACPI_FORMAT_UPPER 0x20
57 #define ACPI_FORMAT_PREFIX 0x40
58 
59 
60 /* Local prototypes */
61 
62 static ACPI_SIZE
64  const char *String,
65  ACPI_SIZE Count);
66 
67 static char *
69  char *String,
70  const char *End,
71  char c);
72 
73 static char *
75  char *String,
76  char *End,
77  UINT64 Number,
78  UINT8 Base,
79  INT32 Width,
80  INT32 Precision,
81  UINT8 Type);
82 
83 static char *
85  char *String,
86  UINT64 Number,
87  UINT8 Base,
88  BOOLEAN Upper);
89 
90 
91 /*******************************************************************************
92  *
93  * FUNCTION: AcpiUtBoundStringLength
94  *
95  * PARAMETERS: String - String with boundary
96  * Count - Boundary of the string
97  *
98  * RETURN: Length of the string. Less than or equal to Count.
99  *
100  * DESCRIPTION: Calculate the length of a string with boundary.
101  *
102  ******************************************************************************/
103 
104 static ACPI_SIZE
106  const char *String,
107  ACPI_SIZE Count)
108 {
109  UINT32 Length = 0;
110 
111 
112  while (*String && Count)
113  {
114  Length++;
115  String++;
116  Count--;
117  }
118 
119  return (Length);
120 }
121 
122 
123 /*******************************************************************************
124  *
125  * FUNCTION: AcpiUtBoundStringOutput
126  *
127  * PARAMETERS: String - String with boundary
128  * End - Boundary of the string
129  * c - Character to be output to the string
130  *
131  * RETURN: Updated position for next valid character
132  *
133  * DESCRIPTION: Output a character into a string with boundary check.
134  *
135  ******************************************************************************/
136 
137 static char *
139  char *String,
140  const char *End,
141  char c)
142 {
143 
144  if (String < End)
145  {
146  *String = c;
147  }
148 
149  ++String;
150  return (String);
151 }
152 
153 
154 /*******************************************************************************
155  *
156  * FUNCTION: AcpiUtPutNumber
157  *
158  * PARAMETERS: String - Buffer to hold reverse-ordered string
159  * Number - Integer to be converted
160  * Base - Base of the integer
161  * Upper - Whether or not using upper cased digits
162  *
163  * RETURN: Updated position for next valid character
164  *
165  * DESCRIPTION: Convert an integer into a string, note that, the string holds a
166  * reversed ordered number without the trailing zero.
167  *
168  ******************************************************************************/
169 
170 static char *
172  char *String,
173  UINT64 Number,
174  UINT8 Base,
175  BOOLEAN Upper)
176 {
177  const char *Digits;
178  UINT64 DigitIndex;
179  char *Pos;
180 
181 
182  Pos = String;
184 
185  if (Number == 0)
186  {
187  *(Pos++) = '0';
188  }
189  else
190  {
191  while (Number)
192  {
193  (void) AcpiUtDivide (Number, Base, &Number, &DigitIndex);
194  *(Pos++) = Digits[DigitIndex];
195  }
196  }
197 
198  /* *(Pos++) = '0'; */
199  return (Pos);
200 }
201 
202 
203 /*******************************************************************************
204  *
205  * FUNCTION: AcpiUtScanNumber
206  *
207  * PARAMETERS: String - String buffer
208  * NumberPtr - Where the number is returned
209  *
210  * RETURN: Updated position for next valid character
211  *
212  * DESCRIPTION: Scan a string for a decimal integer.
213  *
214  ******************************************************************************/
215 
216 const char *
218  const char *String,
219  UINT64 *NumberPtr)
220 {
221  UINT64 Number = 0;
222 
223 
224  while (isdigit ((int) *String))
225  {
227  Number += *(String++) - '0';
228  }
229 
230  *NumberPtr = Number;
231  return (String);
232 }
233 
234 
235 /*******************************************************************************
236  *
237  * FUNCTION: AcpiUtPrintNumber
238  *
239  * PARAMETERS: String - String buffer
240  * Number - The number to be converted
241  *
242  * RETURN: Updated position for next valid character
243  *
244  * DESCRIPTION: Print a decimal integer into a string.
245  *
246  ******************************************************************************/
247 
248 const char *
250  char *String,
251  UINT64 Number)
252 {
253  char AsciiString[20];
254  const char *Pos1;
255  char *Pos2;
256 
257 
258  Pos1 = AcpiUtPutNumber (AsciiString, Number, 10, FALSE);
259  Pos2 = String;
260 
261  while (Pos1 != AsciiString)
262  {
263  *(Pos2++) = *(--Pos1);
264  }
265 
266  *Pos2 = 0;
267  return (String);
268 }
269 
270 
271 /*******************************************************************************
272  *
273  * FUNCTION: AcpiUtFormatNumber
274  *
275  * PARAMETERS: String - String buffer with boundary
276  * End - Boundary of the string
277  * Number - The number to be converted
278  * Base - Base of the integer
279  * Width - Field width
280  * Precision - Precision of the integer
281  * Type - Special printing flags
282  *
283  * RETURN: Updated position for next valid character
284  *
285  * DESCRIPTION: Print an integer into a string with any base and any precision.
286  *
287  ******************************************************************************/
288 
289 static char *
291  char *String,
292  char *End,
293  UINT64 Number,
294  UINT8 Base,
295  INT32 Width,
296  INT32 Precision,
297  UINT8 Type)
298 {
299  char *Pos;
300  char Sign;
301  char Zero;
302  BOOLEAN NeedPrefix;
303  BOOLEAN Upper;
304  INT32 i;
305  char ReversedString[66];
306 
307 
308  /* Parameter validation */
309 
310  if (Base < 2 || Base > 16)
311  {
312  return (NULL);
313  }
314 
315  if (Type & ACPI_FORMAT_LEFT)
316  {
318  }
319 
320  NeedPrefix = ((Type & ACPI_FORMAT_PREFIX) && Base != 10) ? TRUE : FALSE;
321  Upper = (Type & ACPI_FORMAT_UPPER) ? TRUE : FALSE;
322  Zero = (Type & ACPI_FORMAT_ZERO) ? '0' : ' ';
323 
324  /* Calculate size according to sign and prefix */
325 
326  Sign = '\0';
327  if (Type & ACPI_FORMAT_SIGN)
328  {
329  if ((INT64) Number < 0)
330  {
331  Sign = '-';
332  Number = - (INT64) Number;
333  Width--;
334  }
335  else if (Type & ACPI_FORMAT_SIGN_PLUS)
336  {
337  Sign = '+';
338  Width--;
339  }
341  {
342  Sign = ' ';
343  Width--;
344  }
345  }
346  if (NeedPrefix)
347  {
348  Width--;
349  if (Base == 16)
350  {
351  Width--;
352  }
353  }
354 
355  /* Generate full string in reverse order */
356 
357  Pos = AcpiUtPutNumber (ReversedString, Number, Base, Upper);
358  i = (INT32) ACPI_PTR_DIFF (Pos, ReversedString);
359 
360  /* Printing 100 using %2d gives "100", not "00" */
361 
362  if (i > Precision)
363  {
364  Precision = i;
365  }
366 
367  Width -= Precision;
368 
369  /* Output the string */
370 
372  {
373  while (--Width >= 0)
374  {
375  String = AcpiUtBoundStringOutput (String, End, ' ');
376  }
377  }
378  if (Sign)
379  {
381  }
382  if (NeedPrefix)
383  {
384  String = AcpiUtBoundStringOutput (String, End, '0');
385  if (Base == 16)
386  {
388  String, End, Upper ? 'X' : 'x');
389  }
390  }
391  if (!(Type & ACPI_FORMAT_LEFT))
392  {
393  while (--Width >= 0)
394  {
396  }
397  }
398 
399  while (i <= --Precision)
400  {
401  String = AcpiUtBoundStringOutput (String, End, '0');
402  }
403  while (--i >= 0)
404  {
406  ReversedString[i]);
407  }
408  while (--Width >= 0)
409  {
410  String = AcpiUtBoundStringOutput (String, End, ' ');
411  }
412 
413  return (String);
414 }
415 
416 
417 /*******************************************************************************
418  *
419  * FUNCTION: vsnprintf
420  *
421  * PARAMETERS: String - String with boundary
422  * Size - Boundary of the string
423  * Format - Standard printf format
424  * Args - Argument list
425  *
426  * RETURN: Number of bytes actually written.
427  *
428  * DESCRIPTION: Formatted output to a string using argument list pointer.
429  *
430  ******************************************************************************/
431 
432 int
434  char *String,
435  ACPI_SIZE Size,
436  const char *Format,
437  va_list Args)
438 {
439  UINT8 Base;
440  UINT8 Type;
441  INT32 Width;
442  INT32 Precision;
443  char Qualifier;
444  UINT64 Number;
445  char *Pos;
446  char *End;
447  char c;
448  const char *s;
449  const void *p;
450  INT32 Length;
451  int i;
452 
453 
454  Pos = String;
455  End = String + Size;
456 
457  for (; *Format; ++Format)
458  {
459  if (*Format != '%')
460  {
462  continue;
463  }
464 
465  Type = 0;
466  Base = 10;
467 
468  /* Process sign */
469 
470  do
471  {
472  ++Format;
473  if (*Format == '#')
474  {
476  }
477  else if (*Format == '0')
478  {
480  }
481  else if (*Format == '+')
482  {
484  }
485  else if (*Format == ' ')
486  {
488  }
489  else if (*Format == '-')
490  {
492  }
493  else
494  {
495  break;
496  }
497 
498  } while (1);
499 
500  /* Process width */
501 
502  Width = -1;
503  if (isdigit ((int) *Format))
504  {
506  Width = (INT32) Number;
507  }
508  else if (*Format == '*')
509  {
510  ++Format;
511  Width = va_arg (Args, int);
512  if (Width < 0)
513  {
514  Width = -Width;
516  }
517  }
518 
519  /* Process precision */
520 
521  Precision = -1;
522  if (*Format == '.')
523  {
524  ++Format;
525  if (isdigit ((int) *Format))
526  {
528  Precision = (INT32) Number;
529  }
530  else if (*Format == '*')
531  {
532  ++Format;
533  Precision = va_arg (Args, int);
534  }
535 
536  if (Precision < 0)
537  {
538  Precision = 0;
539  }
540  }
541 
542  /* Process qualifier */
543 
544  Qualifier = -1;
545  if (*Format == 'h' || *Format == 'l' || *Format == 'L')
546  {
547  Qualifier = *Format;
548  ++Format;
549 
550  if (Qualifier == 'l' && *Format == 'l')
551  {
552  Qualifier = 'L';
553  ++Format;
554  }
555  }
556 
557  switch (*Format)
558  {
559  case '%':
560 
561  Pos = AcpiUtBoundStringOutput (Pos, End, '%');
562  continue;
563 
564  case 'c':
565 
566  if (!(Type & ACPI_FORMAT_LEFT))
567  {
568  while (--Width > 0)
569  {
570  Pos = AcpiUtBoundStringOutput (Pos, End, ' ');
571  }
572  }
573 
574  c = (char) va_arg (Args, int);
575  Pos = AcpiUtBoundStringOutput (Pos, End, c);
576 
577  while (--Width > 0)
578  {
579  Pos = AcpiUtBoundStringOutput (Pos, End, ' ');
580  }
581  continue;
582 
583  case 's':
584 
585  s = va_arg (Args, char *);
586  if (!s)
587  {
588  s = "<NULL>";
589  }
590  Length = (INT32) AcpiUtBoundStringLength (s, Precision);
591  if (!(Type & ACPI_FORMAT_LEFT))
592  {
593  while (Length < Width--)
594  {
595  Pos = AcpiUtBoundStringOutput (Pos, End, ' ');
596  }
597  }
598 
599  for (i = 0; i < Length; ++i)
600  {
601  Pos = AcpiUtBoundStringOutput (Pos, End, *s);
602  ++s;
603  }
604 
605  while (Length < Width--)
606  {
607  Pos = AcpiUtBoundStringOutput (Pos, End, ' ');
608  }
609  continue;
610 
611  case 'o':
612 
613  Base = 8;
614  break;
615 
616  case 'X':
617 
619  /* FALLTHROUGH */
620 
621  case 'x':
622 
623  Base = 16;
624  break;
625 
626  case 'd':
627  case 'i':
628 
630 
631  case 'u':
632 
633  break;
634 
635  case 'p':
636 
637  if (Width == -1)
638  {
639  Width = 2 * sizeof (void *);
641  }
642 
643  p = va_arg (Args, void *);
645  Pos, End, ACPI_TO_INTEGER (p), 16, Width, Precision, Type);
646  continue;
647 
648  default:
649 
650  Pos = AcpiUtBoundStringOutput (Pos, End, '%');
651  if (*Format)
652  {
654  }
655  else
656  {
657  --Format;
658  }
659  continue;
660  }
661 
662  if (Qualifier == 'L')
663  {
664  Number = va_arg (Args, UINT64);
665  if (Type & ACPI_FORMAT_SIGN)
666  {
667  Number = (INT64) Number;
668  }
669  }
670  else if (Qualifier == 'l')
671  {
672  Number = va_arg (Args, unsigned long);
673  if (Type & ACPI_FORMAT_SIGN)
674  {
675  Number = (INT32) Number;
676  }
677  }
678  else if (Qualifier == 'h')
679  {
680  Number = (UINT16) va_arg (Args, int);
681  if (Type & ACPI_FORMAT_SIGN)
682  {
683  Number = (INT16) Number;
684  }
685  }
686  else
687  {
688  Number = va_arg (Args, unsigned int);
689  if (Type & ACPI_FORMAT_SIGN)
690  {
691  Number = (signed int) Number;
692  }
693  }
694 
696  Width, Precision, Type);
697  }
698 
699  if (Size > 0)
700  {
701  if (Pos < End)
702  {
703  *Pos = '\0';
704  }
705  else
706  {
707  End[-1] = '\0';
708  }
709  }
710 
711  return ((int) ACPI_PTR_DIFF (Pos, String));
712 }
713 
714 
715 /*******************************************************************************
716  *
717  * FUNCTION: snprintf
718  *
719  * PARAMETERS: String - String with boundary
720  * Size - Boundary of the string
721  * Format, ... - Standard printf format
722  *
723  * RETURN: Number of bytes actually written.
724  *
725  * DESCRIPTION: Formatted output to a string.
726  *
727  ******************************************************************************/
728 
729 int
731  char *String,
732  ACPI_SIZE Size,
733  const char *Format,
734  ...)
735 {
736  va_list Args;
737  int Length;
738 
739 
740  va_start (Args, Format);
742  va_end (Args);
743 
744  return (Length);
745 }
746 
747 
748 /*******************************************************************************
749  *
750  * FUNCTION: sprintf
751  *
752  * PARAMETERS: String - String with boundary
753  * Format, ... - Standard printf format
754  *
755  * RETURN: Number of bytes actually written.
756  *
757  * DESCRIPTION: Formatted output to a string.
758  *
759  ******************************************************************************/
760 
761 int
763  char *String,
764  const char *Format,
765  ...)
766 {
767  va_list Args;
768  int Length;
769 
770 
771  va_start (Args, Format);
773  va_end (Args);
774 
775  return (Length);
776 }
777 
778 
779 #ifdef ACPI_APPLICATION
780 /*******************************************************************************
781  *
782  * FUNCTION: vprintf
783  *
784  * PARAMETERS: Format - Standard printf format
785  * Args - Argument list
786  *
787  * RETURN: Number of bytes actually written.
788  *
789  * DESCRIPTION: Formatted output to stdout using argument list pointer.
790  *
791  ******************************************************************************/
792 
793 int
794 vprintf (
795  const char *Format,
796  va_list Args)
797 {
799  int Length;
800 
801 
802  Flags = AcpiOsAcquireLock (AcpiGbl_PrintLock);
803  Length = vsnprintf (AcpiGbl_PrintBuffer,
804  sizeof (AcpiGbl_PrintBuffer), Format, Args);
805 
806  (void) fwrite (AcpiGbl_PrintBuffer, Length, 1, ACPI_FILE_OUT);
807  AcpiOsReleaseLock (AcpiGbl_PrintLock, Flags);
808 
809  return (Length);
810 }
811 
812 
813 /*******************************************************************************
814  *
815  * FUNCTION: printf
816  *
817  * PARAMETERS: Format, ... - Standard printf format
818  *
819  * RETURN: Number of bytes actually written.
820  *
821  * DESCRIPTION: Formatted output to stdout.
822  *
823  ******************************************************************************/
824 
825 int
826 printf (
827  const char *Format,
828  ...)
829 {
830  va_list Args;
831  int Length;
832 
833 
834  va_start (Args, Format);
835  Length = vprintf (Format, Args);
836  va_end (Args);
837 
838  return (Length);
839 }
840 
841 
842 /*******************************************************************************
843  *
844  * FUNCTION: vfprintf
845  *
846  * PARAMETERS: File - File descriptor
847  * Format - Standard printf format
848  * Args - Argument list
849  *
850  * RETURN: Number of bytes actually written.
851  *
852  * DESCRIPTION: Formatted output to a file using argument list pointer.
853  *
854  ******************************************************************************/
855 
856 int
857 vfprintf (
858  FILE *File,
859  const char *Format,
860  va_list Args)
861 {
863  int Length;
864 
865 
866  Flags = AcpiOsAcquireLock (AcpiGbl_PrintLock);
867  Length = vsnprintf (AcpiGbl_PrintBuffer,
868  sizeof (AcpiGbl_PrintBuffer), Format, Args);
869 
870  (void) fwrite (AcpiGbl_PrintBuffer, Length, 1, File);
871  AcpiOsReleaseLock (AcpiGbl_PrintLock, Flags);
872 
873  return (Length);
874 }
875 
876 
877 /*******************************************************************************
878  *
879  * FUNCTION: fprintf
880  *
881  * PARAMETERS: File - File descriptor
882  * Format, ... - Standard printf format
883  *
884  * RETURN: Number of bytes actually written.
885  *
886  * DESCRIPTION: Formatted output to a file.
887  *
888  ******************************************************************************/
889 
890 int
891 fprintf (
892  FILE *File,
893  const char *Format,
894  ...)
895 {
896  va_list Args;
897  int Length;
898 
899 
900  va_start (Args, Format);
902  va_end (Args);
903 
904  return (Length);
905 }
906 #endif
static ACPI_SIZE AcpiUtBoundStringLength(const char *String, ACPI_SIZE Count)
Definition: utprint.c:105
#define ACPI_TO_INTEGER(p)
Definition: actypes.h:553
#define ACPI_FORMAT_PREFIX
Definition: utprint.c:57
#define ACPI_FORMAT_LEFT
Definition: utprint.c:55
#define TRUE
Definition: types.h:120
ACPI_CPU_FLAGS AcpiOsAcquireLock(ACPI_SPINLOCK Handle)
Definition: osl.c:498
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
const char AcpiGbl_UpperHexDigits[]
Definition: utglobal.c:93
ACPI_STATUS AcpiUtShortMultiply(UINT64 InMultiplicand, UINT32 Multiplier, UINT64 *Outproduct)
Definition: utmath.c:88
Type
Definition: Type.h:6
static char * AcpiUtBoundStringOutput(char *String, const char *End, char c)
Definition: utprint.c:138
_In_opt_ ULONG Base
Definition: rtlfuncs.h:2343
ush Pos
Definition: deflate.h:92
#define ACPI_PTR_DIFF(a, b)
Definition: actypes.h:548
#define ACPI_CPU_FLAGS
Definition: actypes.h:252
_Inout_ __drv_aliasesMem PSLIST_ENTRY _Inout_ PSLIST_ENTRY _In_ ULONG Count
Definition: exfuncs.h:1015
int vsnprintf(char *String, ACPI_SIZE Size, const char *Format, va_list Args)
Definition: utprint.c:433
Definition: msg.c:1064
static WCHAR String[]
Definition: stringtable.c:55
_Check_return_opt_ _CRTIMP size_t __cdecl fwrite(_In_reads_bytes_(_Size *_Count) const void *_Str, _In_ size_t _Size, _In_ size_t _Count, _Inout_ FILE *_File)
static char * AcpiUtPutNumber(char *String, UINT64 Number, UINT8 Base, BOOLEAN Upper)
Definition: utprint.c:171
#define ACPI_FORMAT_SIGN_PLUS
Definition: utprint.c:52
#define ACPI_FORMAT_SIGN
Definition: utprint.c:51
#define ACPI_FILE_OUT
Definition: acenv.h:390
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define va_end(ap)
Definition: acmsvcex.h:90
unsigned int UINT32
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
#define ACPI_MODULE_NAME(Name)
Definition: acoutput.h:216
int sprintf(char *String, const char *Format,...)
Definition: utprint.c:762
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
unsigned char
Definition: typeof.h:29
char * va_list
Definition: acmsvcex.h:78
char ** Args
Definition: acdebug.h:343
#define isdigit(c)
Definition: acclib.h:68
int snprintf(char *String, ACPI_SIZE Size, const char *Format,...)
Definition: utprint.c:730
_Check_return_opt_ _CRTIMP int __cdecl vprintf(_In_z_ _Printf_format_string_ const char *_Format, va_list _ArgList)
#define ACPI_UINT32_MAX
Definition: actypes.h:66
const GLubyte * c
Definition: glext.h:8905
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
signed long long INT64
GLdouble s
Definition: gl.h:2039
const char AcpiGbl_LowerHexDigits[]
Definition: utglobal.c:92
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
_In_opt_ PENTER_STATE_SYSTEM_HANDLER _In_opt_ PVOID _In_ LONG _In_opt_ LONG volatile * Number
Definition: ntpoapi.h:204
#define va_arg(ap, T)
Definition: acmsvcex.h:89
static char * AcpiUtFormatNumber(char *String, char *End, UINT64 Number, UINT8 Base, INT32 Width, INT32 Precision, UINT8 Type)
Definition: utprint.c:290
unsigned short UINT16
#define va_start(ap, A)
Definition: acmsvcex.h:91
#define ACPI_FORMAT_SIGN_PLUS_SPACE
Definition: utprint.c:53
IN PVCB IN VBO IN ULONG OUT PBCB OUT PVOID IN BOOLEAN IN BOOLEAN Zero
Definition: fatprocs.h:402
void AcpiOsReleaseLock(ACPI_SPINLOCK Handle, ACPI_CPU_FLAGS Flags)
Definition: osl.c:516
#define c
Definition: ke_i.h:80
signed int INT32
#define ACPI_FORMAT_UPPER
Definition: utprint.c:56
const char * AcpiUtPrintNumber(char *String, UINT64 Number)
Definition: utprint.c:249
Definition: File.h:15
unsigned long long UINT64
GLfloat GLfloat p
Definition: glext.h:8902
_Check_return_opt_ _CRTIMP int __cdecl vfprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format, va_list _ArgList)
unsigned char UINT8
#define ACPI_FORMAT_ZERO
Definition: utprint.c:54
ACPI_STATUS AcpiUtDivide(UINT64 InDividend, UINT64 InDivisor, UINT64 *OutQuotient, UINT64 *OutRemainder)
Definition: utmath.c:402
#define printf
Definition: config.h:203
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
const char * AcpiUtScanNumber(const char *String, UINT64 *NumberPtr)
Definition: utprint.c:217
ACPI_BUFFER *RetBuffer ACPI_BUFFER *RetBuffer char ACPI_WALK_RESOURCE_CALLBACK void *Context ACPI_BUFFER *RetBuffer UINT16 ACPI_RESOURCE **ResourcePtr ACPI_GENERIC_ADDRESS *Reg UINT32 *ReturnValue UINT8 UINT8 *Slp_TypB ACPI_PHYSICAL_ADDRESS PhysicalAddress64 UINT32 UINT32 *TimeElapsed UINT32 ACPI_STATUS const char * Format
Definition: acpixf.h:1206
signed short INT16