compiler.h

// Name:        compiler.h
// Purpose:     wxCompilerSettings - compilers supported by wxPackage API
// Author:      Francesco Montorsi
// Modified by:
// Created:     2006-11-07
// RCS-ID:      $Id: compiler.h,v 1.3 2007/01/28 15:56:10 frm Exp $
// Copyright:   (c) Francesco Montorsi
// Licence:     wxWidgets licence

#ifndef _COMPILER_H_
#define _COMPILER_H_

// Includes
#include "wx/tokenzr.h"
#include "wxp/wxputils.h"

// Forward declarations
class wxStringHashMap;
class wxPackageCommandOptionArray;
class wxConfigBase;
class wxPackageInfo;
class wxPackageArray;


// ----------------------------------------------------------------------------
// enums
// ----------------------------------------------------------------------------

enum wxPackageBuildSystemStage
{
    wxPBSS_INVALID = -1,

    wxPBSS_BUILD = 1,
    wxPBSS_INSTALL = 2,
    wxPBSS_UNINSTALL = 4,
    wxPBSS_CLEAN = 8,

    wxPBSS_MAX = 4
};

enum wxPackageBuildSystemType
{
    wxPBST_INVALID = -1,

    wxPBST_BAKEFILE = 1,
    wxPBST_CMAKE = 2,
    wxPBST_SCONS = 4,
    wxPBST_MAKEFILE = 8,

    wxPBST_MAX = 4
};

enum wxPackageCompilerFormat
{
    wxPCF_INVALID = -1,

    // win32 main makefile formats
    wxPCF_BORLAND = 1,
    wxPCF_MSVC = 2,
    wxPCF_WATCOM = 4,
    wxPCF_MINGW = 8,
    wxPCF_MSYS = 16,

    // unix main formats
    wxPCF_GNUMAKEFILE = 32,
    wxPCF_AUTOCONF = 64,

    wxPCF_MAX = 7
};

enum wxPackageCompilerPathType
{
    wxPCPT_INVALID = -1,

    wxPCPT_BIN,
    wxPCPT_INCLUDE,
    wxPCPT_LIB,

    wxPCPT_MAX
};

wxDEFINE_STRING2COMBINEABLE_ENUM(PackageBuildSystemStage)
wxDEFINE_STRING2COMBINEABLE_ENUM(PackageBuildSystemType)
wxDEFINE_STRING2COMBINEABLE_ENUM(PackageCompilerFormat)
wxDEFINE_STRING2ENUM(PackageCompilerPathType)


// additional global utilities:

bool wxIsCompilerFormatSupportedBy(wxPackageCompilerFormat fmt,
                                   wxPackageBuildSystemType buildsys);

int wxGetBuildSystemsSupportingCompilerFormat(wxPackageCompilerFormat fmt);

bool wxIsCompilerFormatSupportedByThisPlatform(wxPackageCompilerFormat fmt);


// ----------------------------------------------------------------------------
// wxCompilerSettings
// ----------------------------------------------------------------------------

class wxCompilerSettings
{
protected:          // static

    static wxPathList s_paths[wxPCF_MAX][wxPCPT_MAX];

    static wxPackageCompilerFormat s_defaultFormat;

protected:

    // NOTE: there isn't a selected build system variable in this class
    //       because a package always have a single build system !

    wxPackageCompilerFormat s_selFormat;

public:

    wxCompilerSettings()
        { s_selFormat=s_defaultFormat; }


public:     // static getters

    static wxPathList &GetCompilerPaths(wxPackageCompilerFormat n,
                                        wxPackageCompilerPathType t)
        { return s_paths[wxPackageCompilerFormat2Idx(n)][t]; }

    static wxPackageCompilerFormat GetDefaultFormat()
        { return s_defaultFormat; }

public:     // static setters

    static void SetDefaultFormat(wxPackageCompilerFormat newfmt)
        { s_defaultFormat=newfmt; }


public:     // non-static getters

    wxPathList GetCompilerPaths(wxPackageCompilerPathType t) const
        { return GetCompilerPaths(s_selFormat, t); }

    wxPackageCompilerFormat GetSelFormat() const
        { return s_selFormat; }

    void SetSelFormat(wxPackageCompilerFormat newfmt)
        { wxASSERT(newfmt!=wxPCF_INVALID); s_selFormat=newfmt; }

public:     // options

    wxStringHashMap GetOptionsWithDefaults(wxPackageBuildSystemType) const;

public:     // static paths utilities

    static bool IsValidPathList(wxPackageCompilerFormat fmt, const wxPathList &);

    static wxString GetToolPath(wxPackageCompilerFormat fmt, const wxString &program)
        { return s_paths[fmt][wxPCPT_BIN].FindAbsoluteValidPath(program); }

    static wxArrayString GetRequiredToolsList(wxPackageCompilerFormat fmt);

    static void SetCompilerPaths(wxPackageCompilerFormat n, 
                                 wxPackageCompilerPathType t,
                                 const wxPathList &str)
        { s_paths[wxPackageCompilerFormat2Idx(n)][t] = str; }

    static void AddPath(wxPackageCompilerFormat f, 
                        wxPackageCompilerPathType t,
                        const wxString &str)
        { s_paths[wxPackageCompilerFormat2Idx(f)][t].Add(str); }

public:     // non-static paths utilities

    bool IsValidPathList(const wxPathList &pl) const
        { return IsValidPathList(s_selFormat, pl); }

    wxArrayString GetRequiredToolsList() const
        { return GetRequiredToolsList(s_selFormat); }

    wxString GetToolPath(const wxString &program) const
        { return GetToolPath(s_selFormat, program); }

    void UpdateEnvVars();
    void UpdateEnvVar(const wxString &name, wxPackageCompilerPathType t);

    wxStringHashMap GetSubstitutionHashMap(wxPackageBuildSystemType t = wxPBST_INVALID) const;

public:     // load/save

    bool Load(wxConfigBase *, const wxString &path);

    void Save(wxConfigBase *, const wxString &path) const;

    static bool LoadGlobals(wxConfigBase *, const wxString &path);

    static void SaveGlobals(wxConfigBase *, const wxString &path);
};

#endif      // _COMPILER_H_

---