genmake.c

Next BIOS Source code : Extensible Firmware Interface

/*++

Copyright (c)  1999 - 2002 Intel Corporation. All rights reserved
This software and associated documentation (if any) is furnished
under a license and may only be used or copied in accordance
with the terms of the license. Except as permitted by such
license, no part of this software or documentation may be
reproduced, stored in a retrieval system, or transmitted in any
form or by any means without the express written consent of
Intel Corporation.


Module Name:

  genmake.c

Abstract:

  Utility used to generate makefiles for building EFI 1.1 components.
  
--*/  
#include <stdio.h>
#include <stdlib.h>
#include <direct.h>
#include <windows.h>

#include "efi.h"

#define EFI_NT_EMUL
#include "efilib.h"

#define MAX_FILE_NAME   500

UCHAR   BuildDir[MAX_FILE_NAME];        // e.g. ..\build\ntdbg
PUCHAR  EfiSource;                      // e.g. d:\source\efi (with or without drive letter)
PUCHAR  BuildPath;                      // from EfiSource (e.g. build\ntdbg)

typedef struct {
    LIST_ENTRY      Link;
    PUCHAR          ProcDir;
    UCHAR           Filename[1];        // without extension
} A_FILE;

typedef struct {
    LIST_ENTRY      Link;
    UCHAR           Line[1];
} A_LINE;

typedef struct {
    LIST_ENTRY      C;                  // C files
    LIST_ENTRY      S;                  // S files IPF EM code
    LIST_ENTRY      A;                  // Asm files
    LIST_ENTRY      H;                  // H files
    LIST_ENTRY      INC;                // INC files
} FILE_LIST;

typedef struct {
    FILE_LIST       Comm;               // Common files
    FILE_LIST       Ia32;               // Ia32 files
    FILE_LIST       Ipf;                // Ipf files
    FILE_LIST       Ebc;                // EBC files
    LIST_ENTRY      Includes;
    LIST_ENTRY      Libraries;
    LIST_ENTRY      NMake;
} MAKE_INFO;


//
//
//

VOID
Init (
    VOID
    );

VOID
Done (
    VOID
    );

VOID
ProcessDir (
    IN ULONG    NameIndex,
    IN ULONG    DirLevel    
    );

VOID
ProcessMakeInfo (
    IN PCHAR    DirName,
    IN ULONG    DirLevel
    );


//
//
//


int
main (
  int     argc,
  char    *argv[]
  )
{
  Init ();
  ProcessDir (0, 1);
  Done ();
  return 0;
}

VOID
Done (
    VOID
    )
{
    FILE    *fp;
    UCHAR   FileName[MAX_FILE_NAME];

    sprintf (FileName, "%s\\output\\makedone", BuildDir);
    fp = fopen (FileName, "w+");
    if (!fp) {
        printf ("Failed to create %s\n", FileName);
        _getcwd(BuildDir, sizeof(BuildDir));
        printf ("cwd %s\n", BuildDir);
        exit (1);
    }
    fclose (fp);

    sprintf (FileName, "%s\\bin", BuildDir);
    mkdir (FileName);

    printf ("Make files generated\n");
}


VOID
Init (
    VOID
    )
{
    FILE        *Fp;
    BOOLEAN     f;
    char        *pDest;
    int         result;

    // Verify we are at a build point
    Fp = fopen ("master.mak", "r");
    if (!Fp) {
        printf ("genmak not run from build point\n");
        exit (1);
    }
    fclose (Fp);

    // Get the current directory and EFI_SOURCE root
    EfiSource = getenv("EFI_SOURCE");
    if (!EfiSource) {
        printf ("EFI_SOURCE enviroment variable not set\n");
        exit (1);
    }

    // _getcwd returns with drive letter
    _getcwd(BuildDir, sizeof(BuildDir));

    // if EfiSource has drive letter, then we can index into
    // builddir array with strlen of efisource
    // if EfiSource doesn't have drive letter, then strip the
    // drive letter from builddir as well, so that we can
    // index to efisource properly to get buildpath
    result = 0;
    pDest = strchr(EfiSource, ':');
    if(pDest == NULL) {
        // EfiSource does not have a drive letter
        pDest = strchr(BuildDir,':');
        result = pDest - BuildDir + 1;
    }
    
    // Advance to the buildpath directory
    BuildPath = BuildDir + strlen(EfiSource) + result;

    // Set the current dir to be the EFI_SOURCE root
    f = SetCurrentDirectory (EfiSource);
    if (!f) {
        printf ("Could not find EFI_SOURCE\n");
    }
}


VOID
ProcessDir (
  IN ULONG                NameIndex,
  IN ULONG                DirLevel
  )
{
    HANDLE                  h;
    static WIN32_FIND_DATA  FileData;
    static UCHAR            NameBuffer[100];

    NameBuffer[NameIndex] = 0;

    // Don't process $(EFI_SOURCE)\build
    if (strcmp (NameBuffer, "build") == 0) {
        return ;
    }

    //
    ProcessMakeInfo(NameBuffer, DirLevel);

    //
    // Process directories
    //

    h = FindFirstFile ("*", &FileData);
    do {
        // must be a directory
        if (FileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
            if (strcmp (FileData.cFileName, ".") && strcmp (FileData.cFileName, "..")) {
                // put entry in the directory list
                if (SetCurrentDirectory (FileData.cFileName)) {
                    strlwr (FileData.cFileName);
                    if (NameIndex) {
                        sprintf (NameBuffer+NameIndex, "\\%s", FileData.cFileName);
                    } else {
                        sprintf (NameBuffer, "%s", FileData.cFileName);
                    }

                    ProcessDir (strlen (NameBuffer), DirLevel + 1);
                    NameBuffer[NameIndex] = 0;

                    SetCurrentDirectory ("..");
                }
            }
        }
    } while (FindNextFile (h, &FileData)) ;
    FindClose (h);
}



VOID
InitMakeInfo (
    IN OUT MAKE_INFO    *MakInfo
    )
{
    InitializeListHead (&MakInfo->Comm.C);
    InitializeListHead (&MakInfo->Comm.S);
    InitializeListHead (&MakInfo->Comm.A);
    InitializeListHead (&MakInfo->Comm.H);
    InitializeListHead (&MakInfo->Comm.INC);

    InitializeListHead (&MakInfo->Ia32.C);
    InitializeListHead (&MakInfo->Ia32.S);
    InitializeListHead (&MakInfo->Ia32.A);
    InitializeListHead (&MakInfo->Ia32.H);
    InitializeListHead (&MakInfo->Ia32.INC);

    InitializeListHead (&MakInfo->Ipf.C);
    InitializeListHead (&MakInfo->Ipf.S);
    InitializeListHead (&MakInfo->Ipf.A);
    InitializeListHead (&MakInfo->Ipf.H);
    InitializeListHead (&MakInfo->Ipf.INC);

    InitializeListHead (&MakInfo->Ebc.C);
    InitializeListHead (&MakInfo->Ebc.S);
    InitializeListHead (&MakInfo->Ebc.A);
    InitializeListHead (&MakInfo->Ebc.H);
    InitializeListHead (&MakInfo->Ebc.INC);

    InitializeListHead (&MakInfo->Includes);
    InitializeListHead (&MakInfo->Libraries);
    InitializeListHead (&MakInfo->NMake);
}

VOID
FreeMakeInfoList (
    IN PLIST_ENTRY      Head
    )
{
    PLIST_ENTRY         Link, Last;

    Link=Head->Flink; 
    while (Link != Head->Flink) {
        Last = Link;
        Link = Link->Flink;
        RemoveEntryList(Last);
        free (Last);
    }
}


VOID
FreeMakeInfo (
    IN OUT MAKE_INFO    *MakInfo
    )
{
    FreeMakeInfoList (&MakInfo->Comm.C);
    FreeMakeInfoList (&MakInfo->Comm.S);
    FreeMakeInfoList (&MakInfo->Comm.A);
    FreeMakeInfoList (&MakInfo->Comm.H);
    FreeMakeInfoList (&MakInfo->Comm.INC);

    FreeMakeInfoList (&MakInfo->Ia32.C);
    FreeMakeInfoList (&MakInfo->Ia32.S);
    FreeMakeInfoList (&MakInfo->Ia32.A);
    FreeMakeInfoList (&MakInfo->Ia32.H);
    FreeMakeInfoList (&MakInfo->Ia32.INC);

    FreeMakeInfoList (&MakInfo->Ipf.C);
    FreeMakeInfoList (&MakInfo->Ipf.S);
    FreeMakeInfoList (&MakInfo->Ipf.A);
    FreeMakeInfoList (&MakInfo->Ipf.H);
    FreeMakeInfoList (&MakInfo->Ipf.INC);

    FreeMakeInfoList (&MakInfo->Ebc.C);
    FreeMakeInfoList (&MakInfo->Ebc.S);
    FreeMakeInfoList (&MakInfo->Ebc.A);
    FreeMakeInfoList (&MakInfo->Ebc.H);
    FreeMakeInfoList (&MakInfo->Ebc.INC);

    FreeMakeInfoList (&MakInfo->Includes);
    FreeMakeInfoList (&MakInfo->Libraries);
    FreeMakeInfoList (&MakInfo->NMake);
}

BOOLEAN
CopyFileData (
    IN FILE     *FpIn,
    IN FILE     *FpOut
    )
{
    UCHAR       s[1000];


    while (fgets (s, sizeof(s)-1, FpIn)) {
        fputs (s, FpOut);
    }

    return FALSE;
}


BOOLEAN
ParseInput (
  IN FILE             *FpIn,
  IN OUT MAKE_INFO    *MakInfo
  )
{
    PUCHAR              p, p1, p2;
    PUCHAR              ProcDir, DefProcDir;
    PLIST_ENTRY         FList, LineList;
    FILE_LIST           *DefFileList, *FileList;
    A_LINE              *LInfo;
    A_FILE              *FInfo;
    UCHAR               s[1000];

    DefFileList = NULL;
    LineList = NULL;
    while (fgets (s, sizeof(s)-1, FpIn)) {
        // strip white space
        for (p=s; *p  && *p <= ' '; p++) ;

        p2 = p;
        for (p1=p; *p1; p1++) {
            if (*p1 > ' ') {
                p2 = p1;
            }
        }
        p2[1] = 0;

        if (p[0] == 0 || p[0] == '#') {
            continue;
        }

        if (p[0] == '[') {
            
            DefFileList = NULL;
            LineList = NULL;

            DefProcDir = "";
            if (stricmp (p, "[sources]") == 0) {
                DefFileList = &MakInfo->Comm;

            } else if (stricmp (p, "[ia32sources]") == 0) {
                DefFileList = &MakInfo->Ia32;
                DefProcDir = "Ia32\\";

            } else if (stricmp (p, "[ipfsources]") == 0) {
                DefFileList = &MakInfo->Ipf;
                DefProcDir = "Ipf\\";

            } else if (stricmp (p, "[ebcsources]") == 0) {
                DefFileList = &MakInfo->Ebc;
                DefProcDir = "Ebc\\";

            } else if (stricmp (p, "[includes]") == 0) {
                LineList = &MakInfo->Includes;

            } else if (stricmp (p, "[libraries]") == 0) {
                LineList = &MakInfo->Libraries;

            } else if (stricmp (p, "[nmake]") == 0) {
                LineList = &MakInfo->NMake;

            } else {
                printf ("FAILED: Unknown section in make.inf '%s'\n", p);
                return TRUE;

            }
            continue;
        }   

        // save data
        if (DefFileList) {
            strlwr (p);

            // check if filename is for a specific processor type
            // and override to default 
            
            FileList = DefFileList;
            ProcDir = DefProcDir;
            if (strstr (p, "\\ia32\\")) {
                FileList = &MakInfo->Ia32;
                ProcDir = "";
            } 
            if (strstr (p, "\\ipf\\")) {
                FileList = &MakInfo->Ipf;
                ProcDir = "";
            }
            if (strstr (p, "\\ebc\\")) {
                FileList = &MakInfo->Ebc;
                ProcDir = "";
            }

            // find extension for this file
            p2 = ".";
            for (p1=p; *p1; p1++) {
                if (*p1 == '.') {
                    p2 = p1;
                }
            }

            // bin the file based on it's extension
            if (stricmp (p2, ".c") == 0) {
                FList = &FileList->C;
            } else if (stricmp (p2, ".s") == 0) {
                FList = &FileList->S;
            } else if (stricmp (p2, ".h") == 0) {
                FList = &FileList->H;
            } else if (stricmp (p2, ".inc") == 0) {
                FList = &FileList->INC;
            } else if (stricmp (p2, ".asm") == 0) {
                FList = &FileList->A;
            } else {
                printf ("  FAILED: Unknown source file extension type '%s'\n", p);
                return TRUE;
            }
            
            *p2 = 0;
            FInfo = malloc (sizeof(A_FILE) + strlen (p) + 1);
            FInfo->ProcDir = ProcDir;
            strcpy (FInfo->Filename, p);
            InsertTailList (FList, &FInfo->Link);
            continue;
        }
        
        if (LineList) {
			if (LineList == &MakInfo->NMake && *p != '!')
			{
				p1 = p;
				while (*p1 && *p1 != ' ' && *p1 != '=' && *p1 != ':') p1++;
				while (*p1 && *p1 == ' ') p1++;
				if (*p1 != '=' && *p1 != ':')
					p = s;
			}
            LInfo = malloc (sizeof(A_LINE) + strlen (p) + 1);
            strcpy (LInfo->Line, p);
            InsertTailList (LineList, &LInfo->Link);
            continue;
        }

        printf ("FAILED: Unknown data '%s'\n", p);
        return TRUE;
    }

    return FALSE;
}

VOID
DumpFileInfo (
    IN FILE         *FpOut,
    IN FILE_LIST    *FileList
    )
{
    PLIST_ENTRY     Link;
    A_FILE          *FInfo;


    // Each C file depends on each OBJ file
    for (Link=FileList->C.Flink; Link != &FileList->C; Link=Link->Flink) {
        FInfo = CONTAINING_RECORD (Link, A_FILE, Link);

        fprintf (FpOut, "$(BUILD_DIR)\\%s%s.obj : $(SOURCE_DIR)\\%s%s.c $(INC_DEPS)\n",
            FInfo->ProcDir, FInfo->Filename,
            FInfo->ProcDir, FInfo->Filename
            );

        fprintf (FpOut, "    $(CC) $(C_FLAGS) $(MODULE_CFLAGS) /c $(SOURCE_DIR)\\%s%s.c /Fo$@ /FR$(@R).SBR\n",
            FInfo->ProcDir, FInfo->Filename
            );