source/tools/acpiexec/aemain.c

   1 /******************************************************************************
   2  *
   3  * Module Name: aemain - Main routine for the AcpiExec utility
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2013, 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 "aecommon.h"
  45
  46 #define _COMPONENT          ACPI_TOOLS
  47         ACPI_MODULE_NAME    ("aemain")
  48
  49
  50 /* Local prototypes */
  51
  52 static int
  53 AeDoOptions (
  54     int                     argc,
  55     char                    **argv);
  56
  57 static ACPI_STATUS
  58 AcpiDbRunBatchMode (
  59     void);
  60
  61 static char *
  62 FlStrdup (
  63     char                    *String);
  64
  65 static char **
  66 AsDoWildcard (
  67     char                    *DirectoryPathname,
  68     char                    *FileSpecifier);
  69
  70
  71 #define AE_BUFFER_SIZE              1024
  72 #define ASL_MAX_FILES               256
  73
  74 /* Execution modes */
  75
  76 #define AE_MODE_COMMAND_LOOP        0   /* Normal command execution loop */
  77 #define AE_MODE_BATCH_MULTIPLE      1   /* -b option to execute a command line */
  78 #define AE_MODE_BATCH_SINGLE        2   /* -m option to execute a single control method */
  79
  80
  81 /* Globals */
  82
  83 UINT8                       AcpiGbl_RegionFillValue = 0;
  84 BOOLEAN                     AcpiGbl_IgnoreErrors = FALSE;
  85 BOOLEAN                     AcpiGbl_DbOpt_NoRegionSupport = FALSE;
  86 BOOLEAN                     AcpiGbl_DebugTimeout = FALSE;
  87 UINT8                       AcpiGbl_UseHwReducedFadt = FALSE;
  88 BOOLEAN                     AcpiGbl_DoInterfaceTests = FALSE;
  89 static UINT8                AcpiGbl_ExecutionMode = AE_MODE_COMMAND_LOOP;
  90 static char                 BatchBuffer[AE_BUFFER_SIZE];    /* Batch command buffer */
  91 static char                 *FileList[ASL_MAX_FILES];
  92 static AE_TABLE_DESC        *AeTableListHead = NULL;
  93
  94 #define AE_SUPPORTED_OPTIONS        "?b:d:e:f:ghm^orv:x:"
  95
  96
  97 /******************************************************************************
  98  *
  99  * FUNCTION:    usage
 100  *
 101  * PARAMETERS:  None
 102  *
 103  * RETURN:      None
 104  *
 105  * DESCRIPTION: Print a usage message
 106  *
 107  *****************************************************************************/
 108
 109 static void
 110 usage (
 111     void)
 112 {
 113
 114     ACPI_USAGE_HEADER ("acpiexec [options] AMLfile1 AMLfile2 ...");
 115
 116     ACPI_OPTION ("-b \"CommandLine\"",  "Batch mode command line execution (cmd1;cmd2;...)");
 117     ACPI_OPTION ("-h -?",               "Display this help message");
 118     ACPI_OPTION ("-m [Method]",         "Batch mode method execution. Default=MAIN");
 119     printf ("\n");
 120
 121     ACPI_OPTION ("-da",                 "Disable method abort on error");
 122     ACPI_OPTION ("-di",                 "Disable execution of STA/INI methods during init");
 123     ACPI_OPTION ("-do",                 "Disable Operation Region address simulation");
 124     ACPI_OPTION ("-dr",                 "Disable repair of method return values");
 125     ACPI_OPTION ("-dt",                 "Disable allocation tracking (performance)");
 126     printf ("\n");
 127
 128     ACPI_OPTION ("-ef",                 "Enable display of final memory statistics");
 129     ACPI_OPTION ("-ei",                 "Enable additional tests for ACPICA interfaces");
 130     ACPI_OPTION ("-em",                 "Enable Interpreter Serialized Mode");
 131     ACPI_OPTION ("-es",                 "Enable Interpreter Slack Mode");
 132     ACPI_OPTION ("-et",                 "Enable debug semaphore timeout");
 133     printf ("\n");
 134
 135     ACPI_OPTION ("-f <Value>",          "Operation Region initialization fill value");
 136     ACPI_OPTION ("-r",                  "Use hardware-reduced FADT V5");
 137     ACPI_OPTION ("-vi",                 "Verbose initialization output");
 138     ACPI_OPTION ("-vr",                 "Verbose region handler output");
 139     ACPI_OPTION ("-x <DebugLevel>",     "Debug output level");
 140 }
 141
 142
 143 /******************************************************************************
 144  *
 145  * FUNCTION:    AeDoOptions
 146  *
 147  * PARAMETERS:  argc/argv           - Standard argc/argv
 148  *
 149  * RETURN:      Status
 150  *
 151  * DESCRIPTION: Command line option processing
 152  *
 153  *****************************************************************************/
 154
 155 static int
 156 AeDoOptions (
 157     int                     argc,
 158     char                    **argv)
 159 {
 160     int                     j;
 161
 162
 163     while ((j = AcpiGetopt (argc, argv, AE_SUPPORTED_OPTIONS)) != EOF) switch (j)
 164     {
 165     case 'b':
 166
 167         if (strlen (AcpiGbl_Optarg) > (AE_BUFFER_SIZE -1))
 168         {
 169             printf ("**** The length of command line (%u) exceeded maximum (%u)\n",
 170                 (UINT32) strlen (AcpiGbl_Optarg), (AE_BUFFER_SIZE -1));
 171             return (-1);
 172         }
 173         AcpiGbl_ExecutionMode = AE_MODE_BATCH_MULTIPLE;
 174         strcpy (BatchBuffer, AcpiGbl_Optarg);
 175         break;
 176
 177     case 'd':
 178
 179         switch (AcpiGbl_Optarg[0])
 180         {
 181         case 'a':
 182
 183             AcpiGbl_IgnoreErrors = TRUE;
 184             break;
 185
 186         case 'i':
 187
 188             AcpiGbl_DbOpt_ini_methods = FALSE;
 189             break;
 190
 191         case 'o':
 192
 193             AcpiGbl_DbOpt_NoRegionSupport = TRUE;
 194             break;
 195
 196         case 'r':
 197
 198             AcpiGbl_DisableAutoRepair = TRUE;
 199             break;
 200
 201         case 't':
 202
 203             #ifdef ACPI_DBG_TRACK_ALLOCATIONS
 204                 AcpiGbl_DisableMemTracking = TRUE;
 205             #endif
 206             break;
 207
 208         default:
 209
 210             printf ("Unknown option: -d%s\n", AcpiGbl_Optarg);
 211             return (-1);
 212         }
 213         break;
 214
 215     case 'e':
 216
 217         switch (AcpiGbl_Optarg[0])
 218         {
 219         case 'f':
 220
 221             #ifdef ACPI_DBG_TRACK_ALLOCATIONS
 222                 AcpiGbl_DisplayFinalMemStats = TRUE;
 223             #endif
 224             break;
 225
 226         case 'i':
 227
 228             AcpiGbl_DoInterfaceTests = TRUE;
 229             break;
 230
 231         case 'm':
 232
 233             AcpiGbl_AllMethodsSerialized = TRUE;
 234             printf ("Enabling AML Interpreter serialized mode\n");
 235             break;
 236
 237         case 's':
 238
 239             AcpiGbl_EnableInterpreterSlack = TRUE;
 240             printf ("Enabling AML Interpreter slack mode\n");
 241             break;
 242
 243         case 't':
 244
 245             AcpiGbl_DebugTimeout = TRUE;
 246             break;
 247
 248         default:
 249
 250             printf ("Unknown option: -e%s\n", AcpiGbl_Optarg);
 251             return (-1);
 252         }
 253         break;
 254
 255     case 'f':
 256
 257         AcpiGbl_RegionFillValue = (UINT8) strtoul (AcpiGbl_Optarg, NULL, 0);
 258         break;
 259
 260     case 'g':
 261
 262         AcpiGbl_DbOpt_tables = TRUE;
 263         AcpiGbl_DbFilename = NULL;
 264         break;
 265
 266     case 'h':
 267     case '?':
 268
 269         usage();
 270         return (0);
 271
 272     case 'm':
 273
 274         AcpiGbl_ExecutionMode = AE_MODE_BATCH_SINGLE;
 275         switch (AcpiGbl_Optarg[0])
 276         {
 277         case '^':
 278
 279             strcpy (BatchBuffer, "MAIN");
 280             break;
 281
 282         default:
 283
 284             strcpy (BatchBuffer, AcpiGbl_Optarg);
 285             break;
 286         }
 287         break;
 288
 289     case 'o':
 290
 291         AcpiGbl_DbOpt_disasm = TRUE;
 292         AcpiGbl_DbOpt_stats = TRUE;
 293         break;
 294
 295     case 'r':
 296
 297         AcpiGbl_UseHwReducedFadt = TRUE;
 298         printf ("Using ACPI 5.0 Hardware Reduced Mode via version 5 FADT\n");
 299         break;
 300
 301     case 'v':
 302
 303         switch (AcpiGbl_Optarg[0])
 304         {
 305         case 'i':
 306
 307             AcpiDbgLevel |= ACPI_LV_INIT_NAMES;
 308             break;
 309
 310         case 'r':
 311
 312             AcpiGbl_DisplayRegionAccess = TRUE;
 313             break;
 314
 315         default:
 316
 317             printf ("Unknown option: -v%s\n", AcpiGbl_Optarg);
 318             return (-1);
 319         }
 320         break;
 321
 322     case 'x':
 323
 324         AcpiDbgLevel = strtoul (AcpiGbl_Optarg, NULL, 0);
 325         AcpiGbl_DbConsoleDebugLevel = AcpiDbgLevel;
 326         printf ("Debug Level: 0x%8.8X\n", AcpiDbgLevel);
 327         break;
 328
 329     default:
 330
 331         usage();
 332         return (-1);
 333     }
 334
 335     return (0);
 336 }
 337
 338
 339 /******************************************************************************
 340  *
 341  * FUNCTION:    main
 342  *
 343  * PARAMETERS:  argc, argv
 344  *
 345  * RETURN:      Status
 346  *
 347  * DESCRIPTION: Main routine for AcpiExec utility
 348  *
 349  *****************************************************************************/
 350
 351 int ACPI_SYSTEM_XFACE
 352 main (
 353     int                     argc,
 354     char                    **argv)
 355 {
 356     ACPI_STATUS             Status;
 357     UINT32                  InitFlags;
 358     ACPI_TABLE_HEADER       *Table = NULL;
 359     UINT32                  TableCount;
 360     AE_TABLE_DESC           *TableDesc;
 361     char                    **WildcardList;
 362     char                    *Filename;
 363     char                    *Directory;
 364     char                    *FullPathname;
 365
 366
 367     ACPI_DEBUG_INITIALIZE (); /* For debug version only */
 368
 369     printf (ACPI_COMMON_SIGNON ("AML Execution/Debug Utility"));
 370     if (argc < 2)
 371     {
 372         usage ();
 373         return (0);
 374     }
 375
 376     signal (SIGINT, AeCtrlCHandler);
 377
 378     /* Init globals */
 379
 380     AcpiDbgLevel = ACPI_NORMAL_DEFAULT;
 381     AcpiDbgLayer = 0xFFFFFFFF;
 382
 383     /* Init ACPI and start debugger thread */
 384
 385     Status = AcpiInitializeSubsystem ();
 386     AE_CHECK_OK (AcpiInitializeSubsystem, Status);
 387     if (ACPI_FAILURE (Status))
 388     {
 389         return (-1);
 390     }
 391
 392     /* Get the command line options */
 393
 394     if (AeDoOptions (argc, argv))
 395     {
 396         return (-1);
 397     }
 398
 399     /* The remaining arguments are filenames for ACPI tables */
 400
 401     if (argv[AcpiGbl_Optind])
 402     {
 403         AcpiGbl_DbOpt_tables = TRUE;
 404         TableCount = 0;
 405
 406         /* Get each of the ACPI table files on the command line */
 407
 408         while (argv[AcpiGbl_Optind])
 409         {
 410             /* Split incoming path into a directory/filename combo */
 411
 412             Status = FlSplitInputPathname (argv[AcpiGbl_Optind],
 413                 &Directory, &Filename);
 414             if (ACPI_FAILURE (Status))
 415             {
 416                 return (-1);
 417             }
 418
 419             /* Expand wildcards (Windows only) */
 420
 421             WildcardList = AsDoWildcard (Directory, Filename);
 422             if (!WildcardList)
 423             {
 424                 return (-1);
 425             }
 426
 427             while (*WildcardList)
 428             {
 429                 FullPathname = AcpiOsAllocate (
 430                     strlen (Directory) + strlen (*WildcardList) + 1);
 431
 432                 /* Construct a full path to the file */
 433
 434                 strcpy (FullPathname, Directory);
 435                 strcat (FullPathname, *WildcardList);
 436
 437                 /* Get one table */
 438
 439                 Status = AcpiDbReadTableFromFile (FullPathname, &Table);
 440                 if (ACPI_FAILURE (Status))
 441                 {
 442                     printf ("**** Could not get input table %s, %s\n",
 443                         FullPathname, AcpiFormatException (Status));
 444                     goto EnterDebugger;
 445                 }
 446
 447                 AcpiOsFree (FullPathname);
 448                 AcpiOsFree (*WildcardList);
 449                 *WildcardList = NULL;
 450                 WildcardList++;
 451
 452                 /* Ignore non-AML tables, we can't use them. Except for an FADT */
 453
 454                 if (!ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_FADT) &&
 455                     !AcpiUtIsAmlTable (Table))
 456                 {
 457                     ACPI_WARNING ((AE_INFO,
 458                         "Table %4.4s is not an AML table, ignoring",
 459                         Table->Signature));
 460                     AcpiOsFree (Table);
 461                     continue;
 462                 }
 463
 464                 /* Allocate and link a table descriptor */
 465
 466                 TableDesc = AcpiOsAllocate (sizeof (AE_TABLE_DESC));
 467                 TableDesc->Table = Table;
 468                 TableDesc->Next = AeTableListHead;
 469                 AeTableListHead = TableDesc;
 470
 471                 TableCount++;
 472             }
 473
 474             AcpiGbl_Optind++;
 475         }
 476
 477         /* Build a local RSDT with all tables and let ACPICA process the RSDT */
 478
 479         Status = AeBuildLocalTables (TableCount, AeTableListHead);
 480         if (ACPI_FAILURE (Status))
 481         {
 482             return (-1);
 483         }
 484
 485         Status = AeInstallTables ();
 486         if (ACPI_FAILURE (Status))
 487         {
 488             printf ("**** Could not load ACPI tables, %s\n",
 489                 AcpiFormatException (Status));
 490             goto EnterDebugger;
 491         }
 492
 493         /*
 494          * Install most of the handlers.
 495          * Override some default region handlers, especially SystemMemory
 496          */
 497         Status = AeInstallEarlyHandlers ();
 498         if (ACPI_FAILURE (Status))
 499         {
 500             goto EnterDebugger;
 501         }
 502
 503         /* Setup initialization flags for ACPICA */
 504
 505         InitFlags = (ACPI_NO_HANDLER_INIT | ACPI_NO_ACPI_ENABLE);
 506         if (!AcpiGbl_DbOpt_ini_methods)
 507         {
 508             InitFlags |= (ACPI_NO_DEVICE_INIT | ACPI_NO_OBJECT_INIT);
 509         }
 510
 511         /*
 512          * Main initialization for ACPICA subsystem
 513          * TBD: Need a way to call this after the ACPI table "LOAD" command
 514          */
 515         Status = AcpiEnableSubsystem (InitFlags);
 516         if (ACPI_FAILURE (Status))
 517         {
 518             printf ("**** Could not EnableSubsystem, %s\n",
 519                 AcpiFormatException (Status));
 520             goto EnterDebugger;
 521         }
 522
 523         /*
 524          * Install handlers for "device driver" space IDs (EC,SMBus, etc.)
 525          * and fixed event handlers
 526          */
 527         AeInstallLateHandlers ();
 528
 529         /* Finish the ACPICA initialization */
 530
 531         Status = AcpiInitializeObjects (InitFlags);
 532         if (ACPI_FAILURE (Status))
 533         {
 534             printf ("**** Could not InitializeObjects, %s\n",
 535                 AcpiFormatException (Status));
 536             goto EnterDebugger;
 537         }
 538
 539         AeMiscellaneousTests ();
 540     }
 541
 542 EnterDebugger:
 543
 544     /* Exit if error above and we are in one of the batch modes */
 545
 546     if (ACPI_FAILURE (Status) && (AcpiGbl_ExecutionMode > 0))
 547     {
 548         return (-1);
 549     }
 550
 551     /* Run a batch command or enter the command loop */
 552
 553     switch (AcpiGbl_ExecutionMode)
 554     {
 555     default:
 556     case AE_MODE_COMMAND_LOOP:
 557
 558         AcpiDbUserCommands (ACPI_DEBUGGER_COMMAND_PROMPT, NULL);
 559         break;
 560
 561     case AE_MODE_BATCH_MULTIPLE:
 562
 563         AcpiDbRunBatchMode ();
 564         break;
 565
 566     case AE_MODE_BATCH_SINGLE:
 567
 568         AcpiDbExecute (BatchBuffer, NULL, NULL, EX_NO_SINGLE_STEP);
 569         break;
 570     }
 571
 572     return (0);
 573 }
 574
 575
 576 /******************************************************************************
 577  *
 578  * FUNCTION:    AcpiDbRunBatchMode
 579  *
 580  * PARAMETERS:  BatchCommandLine    - A semicolon separated list of commands
 581  *                                    to be executed.
 582  *                                    Use only commas to separate elements of
 583  *                                    particular command.
 584  * RETURN:      Status
 585  *
 586  * DESCRIPTION: For each command of list separated by ';' prepare the command
 587  *              buffer and pass it to AcpiDbCommandDispatch.
 588  *
 589  *****************************************************************************/
 590
 591 static ACPI_STATUS
 592 AcpiDbRunBatchMode (
 593     void)
 594 {
 595     ACPI_STATUS             Status;
 596     char                    *Ptr = BatchBuffer;
 597     char                    *Cmd = Ptr;
 598     UINT8                   Run = 0;
 599
 600
 601     AcpiGbl_MethodExecuting = FALSE;
 602     AcpiGbl_StepToNextCall = FALSE;
 603
 604     while (*Ptr)
 605     {
 606         if (*Ptr == ',')
 607         {
 608             /* Convert commas to spaces */
 609             *Ptr = ' ';
 610         }
 611         else if (*Ptr == ';')
 612         {
 613             *Ptr = '\0';
 614             Run = 1;
 615         }
 616
 617         Ptr++;
 618
 619         if (Run || (*Ptr == '\0'))
 620         {
 621             (void) AcpiDbCommandDispatch (Cmd, NULL, NULL);
 622             Run = 0;
 623             Cmd = Ptr;
 624         }
 625     }
 626
 627     Status = AcpiTerminate ();
 628     return (Status);
 629 }
 630
 631
 632 /******************************************************************************
 633  *
 634  * FUNCTION:    FlStrdup
 635  *
 636  * DESCRIPTION: Local strdup function
 637  *
 638  *****************************************************************************/
 639
 640 static char *
 641 FlStrdup (
 642     char                    *String)
 643 {
 644     char                    *NewString;
 645
 646
 647     NewString = AcpiOsAllocate (strlen (String) + 1);
 648     if (!NewString)
 649     {
 650         return (NULL);
 651     }
 652
 653     strcpy (NewString, String);
 654     return (NewString);
 655 }
 656
 657
 658 /******************************************************************************
 659  *
 660  * FUNCTION:    FlSplitInputPathname
 661  *
 662  * PARAMETERS:  InputFilename       - The user-specified ASL source file to be
 663  *                                    compiled
 664  *              OutDirectoryPath    - Where the directory path prefix is
 665  *                                    returned
 666  *              OutFilename         - Where the filename part is returned
 667  *
 668  * RETURN:      Status
 669  *
 670  * DESCRIPTION: Split the input path into a directory and filename part
 671  *              1) Directory part used to open include files
 672  *              2) Filename part used to generate output filenames
 673  *
 674  *****************************************************************************/
 675
 676 ACPI_STATUS
 677 FlSplitInputPathname (
 678     char                    *InputPath,
 679     char                    **OutDirectoryPath,
 680     char                    **OutFilename)
 681 {
 682     char                    *Substring;
 683     char                    *DirectoryPath;
 684     char                    *Filename;
 685
 686
 687     *OutDirectoryPath = NULL;
 688     *OutFilename = NULL;
 689
 690     if (!InputPath)
 691     {
 692         return (AE_OK);
 693     }
 694
 695     /* Get the path to the input filename's directory */
 696
 697     DirectoryPath = FlStrdup (InputPath);
 698     if (!DirectoryPath)
 699     {
 700         return (AE_NO_MEMORY);
 701     }
 702
 703     /* Convert backslashes to slashes in the entire path */
 704
 705     UtConvertBackslashes (DirectoryPath);
 706
 707     /* Backup to last slash or colon */
 708
 709     Substring = strrchr (DirectoryPath, '/');
 710     if (!Substring)
 711     {
 712         Substring = strrchr (DirectoryPath, ':');
 713     }
 714
 715     /* Extract the simple filename */
 716
 717     if (!Substring)
 718     {
 719         DirectoryPath[0] = 0;
 720         Filename = FlStrdup (InputPath);
 721     }
 722     else
 723     {
 724         Filename = FlStrdup (Substring + 1);
 725         *(Substring + 1) = 0;
 726     }
 727
 728     if (!Filename)
 729     {
 730         return (AE_NO_MEMORY);
 731     }
 732
 733     *OutDirectoryPath = DirectoryPath;
 734     *OutFilename = Filename;
 735     return (AE_OK);
 736 }
 737
 738
 739 /******************************************************************************
 740  *
 741  * FUNCTION:    AsDoWildcard
 742  *
 743  * PARAMETERS:  DirectoryPathname   - Path to parent directory
 744  *              FileSpecifier       - the wildcard specification (*.c, etc.)
 745  *
 746  * RETURN:      Pointer to a list of filenames
 747  *
 748  * DESCRIPTION: Process files via wildcards. This function is for the Windows
 749  *              case only.
 750  *
 751  *****************************************************************************/
 752
 753 static char **
 754 AsDoWildcard (
 755     char                    *DirectoryPathname,
 756     char                    *FileSpecifier)
 757 {
 758 #ifdef WIN32
 759     void                    *DirInfo;
 760     char                    *Filename;
 761     int                     FileCount;
 762
 763
 764     FileCount = 0;
 765
 766     /* Open parent directory */
 767
 768     DirInfo = AcpiOsOpenDirectory (DirectoryPathname, FileSpecifier,
 769         REQUEST_FILE_ONLY);
 770     if (!DirInfo)
 771     {
 772         /* Either the directory or file does not exist */
 773
 774         printf ("File or directory \"%s%s\" does not exist\n",
 775             DirectoryPathname, FileSpecifier);
 776         return (NULL);
 777     }
 778
 779     /* Process each file that matches the wildcard specification */
 780
 781     while ((Filename = AcpiOsGetNextFilename (DirInfo)))
 782     {
 783         /* Add the filename to the file list */
 784
 785         FileList[FileCount] = AcpiOsAllocate (strlen (Filename) + 1);
 786         strcpy (FileList[FileCount], Filename);
 787         FileCount++;
 788
 789         if (FileCount >= ASL_MAX_FILES)
 790         {
 791             printf ("Max files reached\n");
 792             FileList[0] = NULL;
 793             return (FileList);
 794         }
 795     }
 796
 797     /* Cleanup */
 798
 799     AcpiOsCloseDirectory (DirInfo);
 800     FileList[FileCount] = NULL;
 801     return (FileList);
 802
 803 #else
 804     if (!FileSpecifier)
 805     {
 806         return (NULL);
 807     }
 808
 809     /*
 810      * Linux/Unix cases - Wildcards are expanded by the shell automatically.
 811      * Just return the filename in a null terminated list
 812      */
 813     FileList[0] = AcpiOsAllocate (strlen (FileSpecifier) + 1);
 814     strcpy (FileList[0], FileSpecifier);
 815     FileList[1] = NULL;
 816
 817     return (FileList);
 818 #endif
 819 }