[mirror_edk2.git] / BaseTools / Source / C / Common / SimpleFileParsing.c

/** @file\r
Generic but simple file parsing routines.\r
\r
Copyright (c) 2004 - 2018, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
--*/\r
\r
#include <stdio.h>\r
#include <string.h>\r
#include <stdlib.h>\r
#include <ctype.h>\r
\r
#include "CommonLib.h"\r
#include "EfiUtilityMsgs.h"\r
#include "SimpleFileParsing.h"\r
\r
#ifndef MAX_PATH\r
#define MAX_PATH  255\r
#endif\r
//\r
// just in case we get in an endless loop.\r
//\r
#define MAX_NEST_DEPTH  20\r
//\r
// number of wchars\r
//\r
#define MAX_STRING_IDENTIFIER_NAME  100\r
\r
#define T_CHAR_SPACE                ' '\r
#define T_CHAR_NULL                 0\r
#define T_CHAR_CR                   '\r'\r
#define T_CHAR_TAB                  '\t'\r
#define T_CHAR_LF                   '\n'\r
#define T_CHAR_SLASH                '/'\r
#define T_CHAR_BACKSLASH            '\\'\r
#define T_CHAR_DOUBLE_QUOTE         '"'\r
#define T_CHAR_LC_X                 'x'\r
#define T_CHAR_0                    '0'\r
#define T_CHAR_STAR                 '*'\r
\r
//\r
// We keep a linked list of these for the source files we process\r
//\r
typedef struct _SOURCE_FILE {\r
  FILE                *Fptr;\r
  CHAR8               *FileBuffer;\r
  CHAR8               *FileBufferPtr;\r
  UINTN               FileSize;\r
  CHAR8               FileName[MAX_PATH];\r
  UINTN               LineNum;\r
  BOOLEAN             EndOfFile;\r
  BOOLEAN             SkipToHash;\r
  struct _SOURCE_FILE *Previous;\r
  struct _SOURCE_FILE *Next;\r
  CHAR8               ControlCharacter;\r
} SOURCE_FILE;\r
\r
typedef struct {\r
  CHAR8   *FileBufferPtr;\r
} FILE_POSITION;\r
\r
//\r
// Keep all our module globals in this structure\r
//\r
STATIC struct {\r
  SOURCE_FILE SourceFile;\r
  BOOLEAN     VerboseFile;\r
  BOOLEAN     VerboseToken;\r
} mGlobals;\r
\r
STATIC\r
UINTN\r
t_strcmp (\r
  CHAR8  *Buffer,\r
  CHAR8  *Str\r
  );\r
\r
STATIC\r
UINTN\r
t_strncmp (\r
  CHAR8  *Str1,\r
  CHAR8  *Str2,\r
  INTN    Len\r
  );\r
\r
STATIC\r
UINTN\r
t_strlen (\r
  CHAR8  *Str\r
  );\r
\r
STATIC\r
VOID\r
RewindFile (\r
  SOURCE_FILE *SourceFile\r
  );\r
\r
STATIC\r
BOOLEAN\r
IsWhiteSpace (\r
  SOURCE_FILE *SourceFile\r
  );\r
\r
STATIC\r
UINTN\r
SkipWhiteSpace (\r
  SOURCE_FILE *SourceFile\r
  );\r
\r
STATIC\r
BOOLEAN\r
EndOfFile (\r
  SOURCE_FILE *SourceFile\r
  );\r
\r
STATIC\r
VOID\r
PreprocessFile (\r
  SOURCE_FILE *SourceFile\r
  );\r
\r
STATIC\r
CHAR8   *\r
t_strcpy (\r
  CHAR8  *Dest,\r
  CHAR8  *Src\r
  );\r
\r
STATIC\r
STATUS\r
ProcessIncludeFile (\r
  SOURCE_FILE *SourceFile,\r
  SOURCE_FILE *ParentSourceFile\r
  );\r
\r
STATIC\r
STATUS\r
ProcessFile (\r
  SOURCE_FILE *SourceFile\r
  );\r
\r
STATIC\r
STATUS\r
GetFilePosition (\r
  FILE_POSITION *Fpos\r
  );\r
\r
STATIC\r
STATUS\r
SetFilePosition (\r
  FILE_POSITION *Fpos\r
  );\r
\r
STATUS\r
SFPInit (\r
  VOID\r
  )\r
/*++\r
\r
Routine Description:\r
\r
Arguments:\r
  None.\r
\r
Returns:\r
  STATUS_SUCCESS always\r
\r
--*/\r
{\r
  memset ((VOID *) &mGlobals, 0, sizeof (mGlobals));\r
  return STATUS_SUCCESS;\r
}\r
\r
UINTN\r
SFPGetLineNumber (\r
  VOID\r
  )\r
/*++\r
\r
Routine Description:\r
  Return the line number of the file we're parsing. Used\r
  for error reporting purposes.\r
\r
Arguments:\r
  None.\r
\r
Returns:\r
  The line number, or 0 if no file is being processed\r
\r
--*/\r
{\r
  return mGlobals.SourceFile.LineNum;\r
}\r
\r
CHAR8  *\r
SFPGetFileName (\r
  VOID\r
  )\r
/*++\r
\r
Routine Description:\r
  Return the name of the file we're parsing. Used\r
  for error reporting purposes.\r
\r
Arguments:\r
  None.\r
\r
Returns:\r
  A pointer to the file name. Null if no file is being\r
  processed.\r
\r
--*/\r
{\r
  if (mGlobals.SourceFile.FileName[0]) {\r
    return mGlobals.SourceFile.FileName;\r
  }\r
\r
  return NULL;\r
}\r
\r
STATUS\r
SFPOpenFile (\r
  CHAR8      *FileName\r
  )\r
/*++\r
\r
Routine Description:\r
  Open a file for parsing.\r
\r
Arguments:\r
  FileName  - name of the file to parse\r
\r
Returns:\r
\r
\r
--*/\r
{\r
  STATUS  Status;\r
  t_strcpy (mGlobals.SourceFile.FileName, FileName);\r
  Status = ProcessIncludeFile (&mGlobals.SourceFile, NULL);\r
  return Status;\r
}\r
\r
BOOLEAN\r
SFPIsToken (\r
  CHAR8  *Str\r
  )\r
/*++\r
\r
Routine Description:\r
  Check to see if the specified token is found at\r
  the current position in the input file.\r
\r
Arguments:\r
  Str - the token to look for\r
\r
Returns:\r
  TRUE - the token is next\r
  FALSE - the token is not next\r
\r
Notes:\r
  We do a simple string comparison on this function. It is\r
  the responsibility of the caller to ensure that the token\r
  is not a subset of some other token.\r
\r
  The file pointer is advanced past the token in the input file.\r
\r
--*/\r
{\r
  UINTN  Len;\r
  SkipWhiteSpace (&mGlobals.SourceFile);\r
  if (EndOfFile (&mGlobals.SourceFile)) {\r
    return FALSE;\r
  }\r
\r
  if ((Len = t_strcmp (mGlobals.SourceFile.FileBufferPtr, Str)) > 0) {\r
    mGlobals.SourceFile.FileBufferPtr += Len;\r
    if (mGlobals.VerboseToken) {\r
      printf ("Token: '%s'\n", Str);\r
    }\r
\r
    return TRUE;\r
  }\r
\r
  return FALSE;\r
}\r
\r
BOOLEAN\r
SFPIsKeyword (\r
  CHAR8  *Str\r
  )\r
/*++\r
\r
Routine Description:\r
  Check to see if the specified keyword is found at\r
  the current position in the input file.\r
\r
Arguments:\r
  Str - keyword to look for\r
\r
Returns:\r
  TRUE - the keyword is next\r
  FALSE - the keyword is not next\r
\r
Notes:\r
  A keyword is defined as a "special" string that has a non-alphanumeric\r
  character following it.\r
\r
--*/\r
{\r
  UINTN  Len;\r
  SkipWhiteSpace (&mGlobals.SourceFile);\r
  if (EndOfFile (&mGlobals.SourceFile)) {\r
    return FALSE;\r
  }\r
\r
  if ((Len = t_strcmp (mGlobals.SourceFile.FileBufferPtr, Str)) > 0) {\r
    if (isalnum ((int)mGlobals.SourceFile.FileBufferPtr[Len])) {\r
      return FALSE;\r
    }\r
\r
    mGlobals.SourceFile.FileBufferPtr += Len;\r
    if (mGlobals.VerboseToken) {\r
      printf ("Token: '%s'\n", Str);\r
    }\r
\r
    return TRUE;\r
  }\r
\r
  return FALSE;\r
}\r
\r
BOOLEAN\r
SFPGetNextToken (\r
  CHAR8  *Str,\r
  UINTN  Len\r
  )\r
/*++\r
\r
Routine Description:\r
  Get the next token from the input stream.\r
\r
Arguments:\r
  Str - pointer to a copy of the next token\r
  Len - size of buffer pointed to by Str\r
\r
Returns:\r
  TRUE  - next token successfully returned\r
  FALSE - otherwise\r
\r
Notes:\r
  Preceding white space is ignored.\r
  The parser's buffer pointer is advanced past the end of the\r
  token.\r
\r
--*/\r
{\r
  UINTN  Index;\r
  CHAR8  TempChar;\r
\r
  SkipWhiteSpace (&mGlobals.SourceFile);\r
  if (EndOfFile (&mGlobals.SourceFile)) {\r
    return FALSE;\r
  }\r
  //\r
  // Have to have enough string for at least one char and a null-terminator\r
  //\r
  if (Len < 2) {\r
    return FALSE;\r
  }\r
  //\r
  // Look at the first character. If it's an identifier, then treat it\r
  // as such\r
  //\r
  TempChar = mGlobals.SourceFile.FileBufferPtr[0];\r
  if (((TempChar >= 'a') && (TempChar <= 'z')) || ((TempChar >= 'A') && (TempChar <= 'Z')) || (TempChar == '_')) {\r
    Str[0] = TempChar;\r
    mGlobals.SourceFile.FileBufferPtr++;\r
    Index = 1;\r
    while (!EndOfFile (&mGlobals.SourceFile) && (Index < Len)) {\r
      TempChar = mGlobals.SourceFile.FileBufferPtr[0];\r
      if (((TempChar >= 'a') && (TempChar <= 'z')) ||\r
          ((TempChar >= 'A') && (TempChar <= 'Z')) ||\r
          ((TempChar >= '0') && (TempChar <= '9')) ||\r
          (TempChar == '_')\r
          ) {\r
        Str[Index] = mGlobals.SourceFile.FileBufferPtr[0];\r
        mGlobals.SourceFile.FileBufferPtr++;\r
        Index++;\r
      } else {\r
        //\r
        // Invalid character for symbol name, so break out\r
        //\r
        break;\r
      }\r
    }\r
    //\r
    // Null terminate and return success\r
    //\r
    Str[Index] = 0;\r
    return TRUE;\r
  } else if ((TempChar == ')') || (TempChar == '(') || (TempChar == '*')) {\r
    Str[0] = mGlobals.SourceFile.FileBufferPtr[0];\r
    mGlobals.SourceFile.FileBufferPtr++;\r
    Str[1] = 0;\r
    return TRUE;\r
  } else {\r
    //\r
    // Everything else is white-space (or EOF) separated\r
    //\r
    Index = 0;\r
    while (!EndOfFile (&mGlobals.SourceFile) && (Index < Len)) {\r
      if (IsWhiteSpace (&mGlobals.SourceFile)) {\r
        if (Index > 0) {\r
          Str[Index] = 0;\r
          return TRUE;\r
        }\r
\r
        return FALSE;\r
      } else {\r
        Str[Index] = mGlobals.SourceFile.FileBufferPtr[0];\r
        mGlobals.SourceFile.FileBufferPtr++;\r
        Index++;\r
      }\r
    }\r
    //\r
    // See if we just ran out of file contents, but did find a token\r
    //\r
    if ((Index > 0) && EndOfFile (&mGlobals.SourceFile)) {\r
      Str[Index] = 0;\r
      return TRUE;\r
    }\r
  }\r
\r
  return FALSE;\r
}\r
\r
BOOLEAN\r
SFPGetGuidToken (\r
  CHAR8  *Str,\r
  UINT32 Len\r
  )\r
/*++\r
\r
Routine Description:\r
  Parse a GUID from the input stream. Stop when you discover white space.\r
\r
Arguments:\r
  Str - pointer to a copy of the next token\r
  Len - size of buffer pointed to by Str\r
\r
Returns:\r
  TRUE  - GUID string returned successfully\r
  FALSE - otherwise\r
\r
--*/\r
{\r
  UINT32  Index;\r
  SkipWhiteSpace (&mGlobals.SourceFile);\r
  if (EndOfFile (&mGlobals.SourceFile)) {\r
    return FALSE;\r
  }\r
\r
  Index = 0;\r
  while (!EndOfFile (&mGlobals.SourceFile) && (Index < Len)) {\r
    if (IsWhiteSpace (&mGlobals.SourceFile)) {\r
      if (Index > 0) {\r
        Str[Index] = 0;\r
        return TRUE;\r
      }\r
\r
      return FALSE;\r
    } else {\r
      Str[Index] = mGlobals.SourceFile.FileBufferPtr[0];\r
      mGlobals.SourceFile.FileBufferPtr++;\r
      Index++;\r
    }\r
  }\r
\r
  return FALSE;\r
}\r
\r
BOOLEAN\r
SFPSkipToToken (\r
  CHAR8  *Str\r
  )\r
{\r
  UINTN  Len;\r
  CHAR8         *SavePos;\r
  Len     = t_strlen (Str);\r
  SavePos = mGlobals.SourceFile.FileBufferPtr;\r
  SkipWhiteSpace (&mGlobals.SourceFile);\r
  while (!EndOfFile (&mGlobals.SourceFile)) {\r
    if (t_strncmp (Str, mGlobals.SourceFile.FileBufferPtr, Len) == 0) {\r
      mGlobals.SourceFile.FileBufferPtr += Len;\r
      return TRUE;\r
    }\r
\r
    mGlobals.SourceFile.FileBufferPtr++;\r
    SkipWhiteSpace (&mGlobals.SourceFile);\r
  }\r
\r
  mGlobals.SourceFile.FileBufferPtr = SavePos;\r
  return FALSE;\r
}\r
\r
BOOLEAN\r
SFPGetNumber (\r
  UINTN *Value\r
  )\r
/*++\r
\r
Routine Description:\r
  Check the token at the current file position for a numeric value.\r
  May be either decimal or hex.\r
\r
Arguments:\r
  Value  - pointer where to store the value\r
\r
Returns:\r
  FALSE    - current token is not a number\r
  TRUE     - current token is a number\r
\r
--*/\r
{\r
  int Val;\r
\r
  SkipWhiteSpace (&mGlobals.SourceFile);\r
  if (EndOfFile (&mGlobals.SourceFile)) {\r
    return FALSE;\r
  }\r
\r
  if (isdigit ((int)mGlobals.SourceFile.FileBufferPtr[0])) {\r
    //\r
    // Check for hex value\r
    //\r
    if ((mGlobals.SourceFile.FileBufferPtr[0] == T_CHAR_0) && (mGlobals.SourceFile.FileBufferPtr[1] == T_CHAR_LC_X)) {\r
      if (!isxdigit ((int)mGlobals.SourceFile.FileBufferPtr[2])) {\r
        return FALSE;\r
      }\r
\r
      mGlobals.SourceFile.FileBufferPtr += 2;\r
      sscanf (mGlobals.SourceFile.FileBufferPtr, "%x", &Val);\r
      *Value = (UINT32) Val;\r
      while (isxdigit ((int)mGlobals.SourceFile.FileBufferPtr[0])) {\r
        mGlobals.SourceFile.FileBufferPtr++;\r
      }\r
\r
      return TRUE;\r
    } else {\r
      *Value = atoi (mGlobals.SourceFile.FileBufferPtr);\r
      while (isdigit ((int)mGlobals.SourceFile.FileBufferPtr[0])) {\r
        mGlobals.SourceFile.FileBufferPtr++;\r
      }\r
\r
      return TRUE;\r
    }\r
  } else {\r
    return FALSE;\r
  }\r
}\r
\r
STATUS\r
SFPCloseFile (\r
  VOID\r
  )\r
/*++\r
\r
Routine Description:\r
  Close the file being parsed.\r
\r
Arguments:\r
  None.\r
\r
Returns:\r
  STATUS_SUCCESS - the file was closed\r
  STATUS_ERROR   - no file is currently open\r
\r
--*/\r
{\r
  if (mGlobals.SourceFile.FileBuffer != NULL) {\r
    free (mGlobals.SourceFile.FileBuffer);\r
    memset (&mGlobals.SourceFile, 0, sizeof (mGlobals.SourceFile));\r
    return STATUS_SUCCESS;\r
  }\r
\r
  return STATUS_ERROR;\r
}\r
\r
STATIC\r
STATUS\r
ProcessIncludeFile (\r
  SOURCE_FILE *SourceFile,\r
  SOURCE_FILE *ParentSourceFile\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Given a source file, open the file and parse it\r
\r
Arguments:\r
\r
  SourceFile        - name of file to parse\r
  ParentSourceFile  - for error reporting purposes, the file that #included SourceFile.\r
\r
Returns:\r
\r
  Standard status.\r
\r
--*/\r
{\r
  STATIC UINTN NestDepth = 0;\r
  CHAR8               FoundFileName[MAX_PATH];\r
  STATUS              Status;\r
\r
  Status = STATUS_SUCCESS;\r
  NestDepth++;\r
  //\r
  // Print the file being processed. Indent so you can tell the include nesting\r
  // depth.\r
  //\r
  if (mGlobals.VerboseFile) {\r
    fprintf (stdout, "%*cProcessing file '%s'\n", (int)NestDepth * 2, ' ', SourceFile->FileName);\r
    fprintf (stdout, "Parent source file = '%s'\n", ParentSourceFile->FileName);\r
  }\r
\r
  //\r
  // Make sure we didn't exceed our maximum nesting depth\r
  //\r
  if (NestDepth > MAX_NEST_DEPTH) {\r
    Error (NULL, 0, 3001, "Not Supported", "%s exceeds max nesting depth (%u)", SourceFile->FileName, (unsigned) NestDepth);\r
    Status = STATUS_ERROR;\r
    goto Finish;\r
  }\r
  //\r
  // Try to open the file locally, and if that fails try along our include paths.\r
  //\r
  strcpy (FoundFileName, SourceFile->FileName);\r
  if ((SourceFile->Fptr = fopen (LongFilePath (FoundFileName), "rb")) == NULL) {\r
    return STATUS_ERROR;\r
  }\r
  //\r
  // Process the file found\r
  //\r
  ProcessFile (SourceFile);\r
Finish:\r
  //\r
  // Close open files and return status\r
  //\r
  if (SourceFile->Fptr != NULL) {\r
    fclose (SourceFile->Fptr);\r
    SourceFile->Fptr = NULL;\r
  }\r
\r
  return Status;\r
}\r
\r
STATIC\r
STATUS\r
ProcessFile (\r
  SOURCE_FILE *SourceFile\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Given a source file that's been opened, read the contents into an internal\r
  buffer and pre-process it to remove comments.\r
\r
Arguments:\r
\r
  SourceFile        - structure containing info on the file to process\r
\r
Returns:\r
\r
  Standard status.\r
\r
--*/\r
{\r
  //\r
  // Get the file size, and then read the entire thing into memory.\r
  // Allocate extra space for a terminator character.\r
  //\r
  fseek (SourceFile->Fptr, 0, SEEK_END);\r
  SourceFile->FileSize = ftell (SourceFile->Fptr);\r
  if (mGlobals.VerboseFile) {\r
    printf ("FileSize = %u (0x%X)\n", (unsigned) SourceFile->FileSize, (unsigned) SourceFile->FileSize);\r
  }\r
\r
  fseek (SourceFile->Fptr, 0, SEEK_SET);\r
  SourceFile->FileBuffer = (CHAR8  *) malloc (SourceFile->FileSize + sizeof (CHAR8 ));\r
  if (SourceFile->FileBuffer == NULL) {\r
    Error (NULL, 0, 4001, "Resource: memory cannot be allocated", NULL);\r
    return STATUS_ERROR;\r
  }\r
\r
  fread ((VOID *) SourceFile->FileBuffer, SourceFile->FileSize, 1, SourceFile->Fptr);\r
  SourceFile->FileBuffer[(SourceFile->FileSize / sizeof (CHAR8 ))] = T_CHAR_NULL;\r
  //\r
  // Pre-process the file to replace comments with spaces\r
  //\r
  PreprocessFile (SourceFile);\r
  SourceFile->LineNum = 1;\r
  return STATUS_SUCCESS;\r
}\r
\r
STATIC\r
VOID\r
PreprocessFile (\r
  SOURCE_FILE *SourceFile\r
  )\r
/*++\r
\r
Routine Description:\r
  Preprocess a file to replace all carriage returns with NULLs so\r
  we can print lines (as part of error messages) from the file to the screen.\r
\r
Arguments:\r
  SourceFile - structure that we use to keep track of an input file.\r
\r
Returns:\r
  Nothing.\r
\r
--*/\r
{\r
  BOOLEAN InComment;\r
  BOOLEAN SlashSlashComment;\r
  int     LineNum;\r
\r
  RewindFile (SourceFile);\r
  InComment         = FALSE;\r
  SlashSlashComment = FALSE;\r
  while (!EndOfFile (SourceFile)) {\r
    //\r
    // If a line-feed, then no longer in a comment if we're in a // comment\r
    //\r
    if (SourceFile->FileBufferPtr[0] == T_CHAR_LF) {\r
      SourceFile->FileBufferPtr++;\r
      SourceFile->LineNum++;\r
      if (InComment && SlashSlashComment) {\r
        InComment         = FALSE;\r
        SlashSlashComment = FALSE;\r
      }\r
    } else if (SourceFile->FileBufferPtr[0] == T_CHAR_CR) {\r
      //\r
      // Replace all carriage returns with a NULL so we can print stuff\r
      //\r
      SourceFile->FileBufferPtr[0] = 0;\r
      SourceFile->FileBufferPtr++;\r
      //\r
      // Check for */ comment end\r
      //\r
    } else if (InComment &&\r
             !SlashSlashComment &&\r
             (SourceFile->FileBufferPtr[0] == T_CHAR_STAR) &&\r
             (SourceFile->FileBufferPtr[1] == T_CHAR_SLASH)\r
            ) {\r
      SourceFile->FileBufferPtr[0] = T_CHAR_SPACE;\r
      SourceFile->FileBufferPtr++;\r
      SourceFile->FileBufferPtr[0] = T_CHAR_SPACE;\r
      SourceFile->FileBufferPtr++;\r
      InComment = FALSE;\r
    } else if (InComment) {\r
      SourceFile->FileBufferPtr[0] = T_CHAR_SPACE;\r
      SourceFile->FileBufferPtr++;\r
      //\r
      // Check for // comments\r
      //\r
    } else if ((SourceFile->FileBufferPtr[0] == T_CHAR_SLASH) && (SourceFile->FileBufferPtr[1] == T_CHAR_SLASH)) {\r
      InComment         = TRUE;\r
      SlashSlashComment = TRUE;\r
      //\r
      // Check for /* comment start\r
      //\r
    } else if ((SourceFile->FileBufferPtr[0] == T_CHAR_SLASH) && (SourceFile->FileBufferPtr[1] == T_CHAR_STAR)) {\r
      SourceFile->FileBufferPtr[0] = T_CHAR_SPACE;\r
      SourceFile->FileBufferPtr++;\r
      SourceFile->FileBufferPtr[0] = T_CHAR_SPACE;\r
      SourceFile->FileBufferPtr++;\r
      SlashSlashComment = FALSE;\r
      InComment         = TRUE;\r
    } else {\r
      SourceFile->FileBufferPtr++;\r
    }\r
  }\r
  //\r
  // Could check for end-of-file and still in a comment, but\r
  // should not be necessary. So just restore the file pointers.\r
  //\r
  RewindFile (SourceFile);\r
  //\r
  // Dump the reformatted file if verbose mode\r
  //\r
  if (mGlobals.VerboseFile) {\r
    LineNum = 1;\r
    printf ("%04d: ", LineNum);\r
    while (!EndOfFile (SourceFile)) {\r
      if (SourceFile->FileBufferPtr[0] == T_CHAR_LF) {\r
        printf ("'\n%04d: '", ++LineNum);\r
      } else {\r
        printf ("%c", SourceFile->FileBufferPtr[0]);\r
      }\r
\r
      SourceFile->FileBufferPtr++;\r
    }\r
\r
    printf ("'\n");\r
    printf ("FileSize = %u (0x%X)\n", (unsigned)SourceFile->FileSize, (unsigned)SourceFile->FileSize);\r
    RewindFile (SourceFile);\r
  }\r
}\r
\r
BOOLEAN\r
SFPGetQuotedString (\r
  CHAR8       *Str,\r
  INTN         Length\r
  )\r
/*++\r
\r
Routine Description:\r
  Retrieve a quoted-string from the input file.\r
\r
Arguments:\r
  Str    - pointer to a copy of the quoted string parsed\r
  Length - size of buffer pointed to by Str\r
\r
Returns:\r
  TRUE    - next token in input stream was a quoted string, and\r
            the string value was returned in Str\r
  FALSE   - otherwise\r
\r
--*/\r
{\r
  SkipWhiteSpace (&mGlobals.SourceFile);\r
  if (EndOfFile (&mGlobals.SourceFile)) {\r
    return FALSE;\r
  }\r
\r
  if (mGlobals.SourceFile.FileBufferPtr[0] == T_CHAR_DOUBLE_QUOTE) {\r
    mGlobals.SourceFile.FileBufferPtr++;\r
    while (Length > 0) {\r
      if (EndOfFile (&mGlobals.SourceFile)) {\r
        return FALSE;\r
      }\r
      //\r
      // Check for closing quote\r
      //\r
      if (mGlobals.SourceFile.FileBufferPtr[0] == T_CHAR_DOUBLE_QUOTE) {\r
        mGlobals.SourceFile.FileBufferPtr++;\r
        *Str = 0;\r
        return TRUE;\r
      }\r
\r
      *Str = mGlobals.SourceFile.FileBufferPtr[0];\r
      Str++;\r
      Length--;\r
      mGlobals.SourceFile.FileBufferPtr++;\r
    }\r
  }\r
  //\r
  // First character was not a quote, or the input string length was\r
  // insufficient to contain the quoted string, so return failure code.\r
  //\r
  return FALSE;\r
}\r
\r
BOOLEAN\r
SFPIsEOF (\r
  VOID\r
  )\r
/*++\r
\r
Routine Description:\r
  Return TRUE of FALSE to indicate whether or not we've reached the end of the\r
  file we're parsing.\r
\r
Arguments:\r
  NA\r
\r
Returns:\r
  TRUE    - EOF reached\r
  FALSE   - otherwise\r
\r
--*/\r
{\r
  SkipWhiteSpace (&mGlobals.SourceFile);\r
  return EndOfFile (&mGlobals.SourceFile);\r
}\r
\r
#if 0\r
STATIC\r
CHAR8  *\r
GetQuotedString (\r
  SOURCE_FILE *SourceFile,\r
  BOOLEAN     Optional\r
  )\r
{\r
  CHAR8         *String;\r
  CHAR8         *Start;\r
  CHAR8         *Ptr;\r
  UINTN         Len;\r
  BOOLEAN       PreviousBackslash;\r
\r
  if (SourceFile->FileBufferPtr[0] != T_CHAR_DOUBLE_QUOTE) {\r
    if (Optional == FALSE) {\r
      Error (SourceFile->FileName, SourceFile->LineNum, 0, "expected quoted string", "%S", SourceFile->FileBufferPtr);\r
    }\r
\r
    return NULL;\r
  }\r
\r
  Len = 0;\r
  SourceFile->FileBufferPtr++;\r
  Start             = Ptr = SourceFile->FileBufferPtr;\r
  PreviousBackslash = FALSE;\r
  while (!EndOfFile (SourceFile)) {\r
    if ((SourceFile->FileBufferPtr[0] == T_CHAR_DOUBLE_QUOTE) && (PreviousBackslash == FALSE)) {\r
      break;\r
    } else if (SourceFile->FileBufferPtr[0] == T_CHAR_CR) {\r
      Warning (SourceFile->FileName, SourceFile->LineNum, 0, "carriage return found in quoted string", "%S", Start);\r
      PreviousBackslash = FALSE;\r
    } else if (SourceFile->FileBufferPtr[0] == T_CHAR_BACKSLASH) {\r
      PreviousBackslash = TRUE;\r
    } else {\r
      PreviousBackslash = FALSE;\r
    }\r
\r
    SourceFile->FileBufferPtr++;\r
    Len++;\r
  }\r
\r
  if (SourceFile->FileBufferPtr[0] != T_CHAR_DOUBLE_QUOTE) {\r
    Warning (SourceFile->FileName, SourceFile->LineNum, 0, "missing closing quote on string", "%S", Start);\r
  } else {\r
    SourceFile->FileBufferPtr++;\r
  }\r
  //\r
  // Now allocate memory for the string and save it off\r
  //\r
  String = (CHAR8  *) malloc ((Len + 1) * sizeof (CHAR8 ));\r
  if (String == NULL) {\r
    Error (NULL, 0, 4001, "Resource: memory cannot be allocated", NULL);\r
    return NULL;\r
  }\r
  //\r
  // Copy the string from the file buffer to the local copy.\r
  // We do no reformatting of it whatsoever at this point.\r
  //\r
  Ptr = String;\r
  while (Len > 0) {\r
    *Ptr = *Start;\r
    Start++;\r
    Ptr++;\r
    Len--;\r
  }\r
\r
  *Ptr = 0;\r
  return String;\r
}\r
#endif\r
STATIC\r
BOOLEAN\r
EndOfFile (\r
  SOURCE_FILE *SourceFile\r
  )\r
{\r
  //\r
  // The file buffer pointer will typically get updated before the End-of-file flag in the\r
  // source file structure, so check it first.\r
  //\r
  if (SourceFile->FileBufferPtr >= SourceFile->FileBuffer + SourceFile->FileSize / sizeof (CHAR8 )) {\r
    SourceFile->EndOfFile = TRUE;\r
    return TRUE;\r
  }\r
\r
  if (SourceFile->EndOfFile) {\r
    return TRUE;\r
  }\r
\r
  return FALSE;\r
}\r
\r
#if 0\r
STATIC\r
VOID\r
ProcessTokenInclude (\r
  SOURCE_FILE *SourceFile\r
  )\r
{\r
  CHAR8          IncludeFileName[MAX_PATH];\r
  CHAR8          *To;\r
  UINTN  Len;\r
  BOOLEAN       ReportedError;\r
  SOURCE_FILE   IncludedSourceFile;\r
\r
  ReportedError = FALSE;\r
  if (SkipWhiteSpace (SourceFile) == 0) {\r
    Warning (SourceFile->FileName, SourceFile->LineNum, 0, "expected whitespace following #include keyword", NULL);\r
  }\r
  //\r
  // Should be quoted file name\r
  //\r
  if (SourceFile->FileBufferPtr[0] != T_CHAR_DOUBLE_QUOTE) {\r
    Error (SourceFile->FileName, SourceFile->LineNum, 0, "expected quoted include file name", NULL);\r
    goto FailDone;\r
  }\r
\r
  SourceFile->FileBufferPtr++;\r
  //\r
  // Copy the filename as ascii to our local string\r
  //\r
  To  = IncludeFileName;\r
  Len = 0;\r
  while (!EndOfFile (SourceFile)) {\r
    if ((SourceFile->FileBufferPtr[0] == T_CHAR_CR) || (SourceFile->FileBufferPtr[0] == T_CHAR_LF)) {\r
      Error (SourceFile->FileName, SourceFile->LineNum, 0, "end-of-line found in quoted include file name", NULL);\r
      goto FailDone;\r
    }\r
\r
    if (SourceFile->FileBufferPtr[0] == T_CHAR_DOUBLE_QUOTE) {\r
      SourceFile->FileBufferPtr++;\r
      break;\r
    }\r
    //\r
    // If too long, then report the error once and process until the closing quote\r
    //\r
    Len++;\r
    if (!ReportedError && (Len >= sizeof (IncludeFileName))) {\r
      Error (SourceFile->FileName, SourceFile->LineNum, 0, "length of include file name exceeds limit", NULL);\r
      ReportedError = TRUE;\r
    }\r
\r
    if (!ReportedError) {\r
      *To = (CHAR8 ) SourceFile->FileBufferPtr[0];\r
      To++;\r
    }\r
\r
    SourceFile->FileBufferPtr++;\r
  }\r
\r
  if (!ReportedError) {\r
    *To = 0;\r
    memset ((CHAR8 *) &IncludedSourceFile, 0, sizeof (SOURCE_FILE));\r
    strcpy (IncludedSourceFile.FileName, IncludeFileName);\r
    ProcessIncludeFile (&IncludedSourceFile, SourceFile);\r
  }\r
\r
  return ;\r
FailDone:\r
  //\r
  // Error recovery -- skip to next #\r
  //\r
  SourceFile->SkipToHash = TRUE;\r
}\r
#endif\r
STATIC\r
BOOLEAN\r
IsWhiteSpace (\r
  SOURCE_FILE *SourceFile\r
  )\r
{\r
  switch (*SourceFile->FileBufferPtr) {\r
  case T_CHAR_NULL:\r
  case T_CHAR_CR:\r
  case T_CHAR_SPACE:\r
  case T_CHAR_TAB:\r
  case T_CHAR_LF:\r
    return TRUE;\r
\r
  default:\r
    return FALSE;\r
  }\r
}\r
\r
UINTN\r
SkipWhiteSpace (\r
  SOURCE_FILE *SourceFile\r
  )\r
{\r
  UINTN  Count;\r
\r
  Count = 0;\r
  while (!EndOfFile (SourceFile)) {\r
    Count++;\r
    switch (*SourceFile->FileBufferPtr) {\r
    case T_CHAR_NULL:\r
    case T_CHAR_CR:\r
    case T_CHAR_SPACE:\r
    case T_CHAR_TAB:\r
      SourceFile->FileBufferPtr++;\r
      break;\r
\r
    case T_CHAR_LF:\r
      SourceFile->FileBufferPtr++;\r
      SourceFile->LineNum++;\r
      break;\r
\r
    default:\r
      return Count - 1;\r
    }\r
  }\r
  //\r
  // Some tokens require trailing whitespace. If we're at the end of the\r
  // file, then we count that as well.\r
  //\r
  if ((Count == 0) && (EndOfFile (SourceFile))) {\r
    Count++;\r
  }\r
\r
  return Count;\r
}\r
\r
STATIC\r
UINTN\r
t_strcmp (\r
  CHAR8  *Buffer,\r
  CHAR8  *Str\r
  )\r
/*++\r
\r
Routine Description:\r
  Compare two strings for equality. The string pointed to by 'Buffer' may or may not be null-terminated,\r
  so only compare up to the length of Str.\r
\r
Arguments:\r
  Buffer  - pointer to first (possibly not null-terminated) string\r
  Str     - pointer to null-terminated string to compare to Buffer\r
\r
Returns:\r
  Number of bytes matched if exact match\r
  0 if Buffer does not start with Str\r
\r
--*/\r
{\r
  UINTN  Len;\r
\r
  Len = 0;\r
  while (*Str && (*Str == *Buffer)) {\r
    Buffer++;\r
    Str++;\r
    Len++;\r
  }\r
\r
  if (*Str) {\r
    return 0;\r
  }\r
\r
  return Len;\r
}\r
\r
STATIC\r
UINTN\r
t_strlen (\r
  CHAR8  *Str\r
  )\r
{\r
  UINTN  Len;\r
  Len = 0;\r
  while (*Str) {\r
    Len++;\r
    Str++;\r
  }\r
\r
  return Len;\r
}\r
\r
STATIC\r
UINTN\r
t_strncmp (\r
  CHAR8  *Str1,\r
  CHAR8  *Str2,\r
  INTN    Len\r
  )\r
{\r
  while (Len > 0) {\r
    if (*Str1 != *Str2) {\r
      return Len;\r
    }\r
\r
    Len--;\r
    Str1++;\r
    Str2++;\r
  }\r
\r
  return 0;\r
}\r
\r
STATIC\r
CHAR8  *\r
t_strcpy (\r
  CHAR8  *Dest,\r
  CHAR8  *Src\r
  )\r
{\r
  CHAR8   *SaveDest;\r
  SaveDest = Dest;\r
  while (*Src) {\r
    *Dest = *Src;\r
    Dest++;\r
    Src++;\r
  }\r
\r
  *Dest = 0;\r
  return SaveDest;\r
}\r
\r
STATIC\r
VOID\r
RewindFile (\r
  SOURCE_FILE *SourceFile\r
  )\r
{\r
  SourceFile->LineNum       = 1;\r
  SourceFile->FileBufferPtr = SourceFile->FileBuffer;\r
  SourceFile->EndOfFile     = 0;\r
}\r
\r
STATIC\r
UINT32\r
GetHexChars (\r
  CHAR8       *Buffer,\r
  UINT32      BufferLen\r
  )\r
{\r
  UINT32  Len;\r
  Len = 0;\r
  while (!EndOfFile (&mGlobals.SourceFile) && (Len < BufferLen)) {\r
    if (isxdigit ((int)mGlobals.SourceFile.FileBufferPtr[0])) {\r
      Buffer[Len] = mGlobals.SourceFile.FileBufferPtr[0];\r
      Len++;\r
      mGlobals.SourceFile.FileBufferPtr++;\r
    } else {\r
      break;\r
    }\r
  }\r
  //\r
  // Null terminate if we can\r
  //\r
  if ((Len > 0) && (Len < BufferLen)) {\r
    Buffer[Len] = 0;\r
  }\r
\r
  return Len;\r
}\r
\r
BOOLEAN\r
SFPGetGuid (\r
  INTN         GuidStyle,\r
  EFI_GUID    *Value\r
  )\r
/*++\r
\r
Routine Description:\r
  Parse a GUID from the input stream. Stop when you discover white space.\r
\r
Arguments:\r
  GuidStyle - Style of the following GUID token\r
  Value     - pointer to EFI_GUID struct for output\r
\r
Returns:\r
  TRUE  - GUID string parsed successfully\r
  FALSE - otherwise\r
\r
  GUID styles\r
    Style[0] 12345678-1234-5678-AAAA-BBBBCCCCDDDD\r
\r
--*/\r
{\r
  INT32         Value32;\r
  UINT32        Index;\r
  FILE_POSITION FPos;\r
  CHAR8         TempString[20];\r
  CHAR8         TempString2[3];\r
  CHAR8         *From;\r
  CHAR8         *To;\r
  UINT32        Len;\r
  BOOLEAN       Status;\r
\r
  Status = FALSE;\r
  //\r
  // Skip white space, then start parsing\r
  //\r
  SkipWhiteSpace (&mGlobals.SourceFile);\r
  GetFilePosition (&FPos);\r
  if (EndOfFile (&mGlobals.SourceFile)) {\r
    return FALSE;\r
  }\r
\r
  if (GuidStyle == PARSE_GUID_STYLE_5_FIELDS) {\r
    //\r
    // Style[0] 12345678-1234-5678-AAAA-BBBBCCCCDDDD\r
    //\r
    Len = GetHexChars (TempString, sizeof (TempString));\r
    if ((Len == 0) || (Len > 8)) {\r
      goto Done;\r
    }\r
\r
    sscanf (TempString, "%x", &Value32);\r
    Value->Data1 = Value32;\r
    //\r
    // Next two UINT16 fields\r
    //\r
    if (mGlobals.SourceFile.FileBufferPtr[0] != '-') {\r
      goto Done;\r
    }\r
\r
    mGlobals.SourceFile.FileBufferPtr++;\r
    Len = GetHexChars (TempString, sizeof (TempString));\r
    if ((Len == 0) || (Len > 4)) {\r
      goto Done;\r
    }\r
\r
    sscanf (TempString, "%x", &Value32);\r
    Value->Data2 = (UINT16) Value32;\r
\r
    if (mGlobals.SourceFile.FileBufferPtr[0] != '-') {\r
      goto Done;\r
    }\r
\r
    mGlobals.SourceFile.FileBufferPtr++;\r
    Len = GetHexChars (TempString, sizeof (TempString));\r
    if ((Len == 0) || (Len > 4)) {\r
      goto Done;\r
    }\r
\r
    sscanf (TempString, "%x", &Value32);\r
    Value->Data3 = (UINT16) Value32;\r
    //\r
    // Parse the "AAAA" as two bytes\r
    //\r
    if (mGlobals.SourceFile.FileBufferPtr[0] != '-') {\r
      goto Done;\r
    }\r
\r
    mGlobals.SourceFile.FileBufferPtr++;\r
    Len = GetHexChars (TempString, sizeof (TempString));\r
    if ((Len == 0) || (Len > 4)) {\r
      goto Done;\r
    }\r
\r
    sscanf (TempString, "%x", &Value32);\r
    Value->Data4[0] = (UINT8) (Value32 >> 8);\r
    Value->Data4[1] = (UINT8) Value32;\r
    if (mGlobals.SourceFile.FileBufferPtr[0] != '-') {\r
      goto Done;\r
    }\r
\r
    mGlobals.SourceFile.FileBufferPtr++;\r
    //\r
    // Read the last 6 bytes of the GUID\r
    //\r
    //\r
    Len = GetHexChars (TempString, sizeof (TempString));\r
    if ((Len == 0) || (Len > 12)) {\r
      goto Done;\r
    }\r
    //\r
    // Insert leading 0's to make life easier\r
    //\r
    if (Len != 12) {\r
      From            = TempString + Len - 1;\r
      To              = TempString + 11;\r
      TempString[12]  = 0;\r
      while (From >= TempString) {\r
        *To = *From;\r
        To--;\r
        From--;\r
      }\r
\r
      while (To >= TempString) {\r
        *To = '0';\r
        To--;\r
      }\r
    }\r
    //\r
    // Now parse each byte\r
    //\r
    TempString2[2] = 0;\r
    for (Index = 0; Index < 6; Index++) {\r
      //\r
      // Copy the two characters from the input string to something\r
      // we can parse.\r
      //\r
      TempString2[0]  = TempString[Index * 2];\r
      TempString2[1]  = TempString[Index * 2 + 1];\r
      sscanf (TempString2, "%x", &Value32);\r
      Value->Data4[Index + 2] = (UINT8) Value32;\r
    }\r
\r
    Status = TRUE;\r
  } else {\r
    //\r
    // Unsupported GUID style\r
    //\r
    return FALSE;\r
  }\r
\r
Done:\r
  if (Status == FALSE) {\r
    SetFilePosition (&FPos);\r
  }\r
\r
  return Status;\r
}\r
\r
STATIC\r
STATUS\r
GetFilePosition (\r
  FILE_POSITION *Fpos\r
  )\r
{\r
  Fpos->FileBufferPtr = mGlobals.SourceFile.FileBufferPtr;\r
  return STATUS_SUCCESS;\r
}\r
\r
STATIC\r
STATUS\r
SetFilePosition (\r
  FILE_POSITION *Fpos\r
  )\r
{\r
  //\r
  // Should check range of pointer\r
  //\r
  mGlobals.SourceFile.FileBufferPtr = Fpos->FileBufferPtr;\r
  return STATUS_SUCCESS;\r
}\r