IDL_FrontEnd.h

Go to the documentation of this file.

/*
* Nirvana IDL front-end library.
*
* This is a part of the Nirvana project.
*
* Author: Igor Popov
*
* Copyright (c) 2021 Igor Popov.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library.  If not, see <http://www.gnu.org/licenses/>.
*
* Send comments and/or bug reports to:
*  popov.nirvana@gmail.com
*/
#ifndef IDLFE_IDL_FRONTEND_H_
#define IDLFE_IDL_FRONTEND_H_
#pragma once
 
#include <assert.h>
#include <string>
#include <vector>
#include <iostream>
#include <filesystem>
 
namespace AST {
class Root;
class Builder;
class Interface;
}
 
namespace FE {
class Driver;
}
 
namespace simplecpp {
struct DUI;
}
 
class IDL_FrontEnd
{
public:
    int main (int argc, const char* const argv []) noexcept
    {
        return run (filename (argv [0]), argc - 1, argv + 1);
    }
 
    int run (const char* command, int argc, const char* const argv []) noexcept;
 
    static const char* filename (const char* path) noexcept;
 
    unsigned flags () const noexcept
    {
        return flags_;
    }
 
    static const unsigned FLAG_DEPRECATE_ANONYMOUS_TYPES = 1;
 
    static const unsigned FLAG_DEPRECATE_PSEUDO_INTERFACES = 2;
 
    static const unsigned FLAG_ENABLE_CONST_OBJREF = 4;
 
    std::ostream& err_out () const noexcept
    {
        return err_out_;
    }
 
protected:
    friend class FE::Driver;
    friend class AST::Builder;
 
    class CmdLine
    {
    public:
        const char* arg () const noexcept
        {
            assert (!end ());
            return *arg_;
        }
 
        bool end () const noexcept
        {
            return arg_ >= end_;
        }
 
        bool next () noexcept;
 
        const char* parameter (const char* switch_end);
 
        CmdLine (int argc, const char* const argv []) :
            arg_ (argv),
            end_ (argv + argc)
        {}
 
    private:
        const char* const* arg_;
        const char* const* end_;
    };
 
    IDL_FrontEnd (unsigned flags = 0, std::ostream& err_out = std::cerr) :
        command_ (nullptr),
        flags_ (flags),
        err_out_ (err_out),
        preprocess_to_stdout_ (false)
    {}
 
    virtual void parse_arguments (CmdLine& args);
 
    virtual bool parse_command_line (CmdLine& args);
 
    virtual void print_usage_info (const char* exe_name);
 
    std::vector <std::string>& defines () noexcept
    {
        return defines_;
    }
    
    std::vector <std::string>& undefines () noexcept
    {
        return undefines_;
    }
 
    std::vector <std::string>& include_paths () noexcept
    {
        return include_paths_;
    }
 
    std::vector <std::string>& includes () noexcept
    {
        return includes_;
    }
 
    std::vector <std::string>& files () noexcept
    {
        return files_;
    }
 
    virtual void generate_code (const AST::Root& tree) = 0;
 
    virtual void file_begin (const std::filesystem::path& file, AST::Builder& builder)
    {}
 
    virtual void interface_end (const AST::Interface& itf, AST::Builder& builder)
    {}
 
private:
    bool compile (const simplecpp::DUI& prep_params, const std::string& file);
 
private:
    const char* command_;
    unsigned flags_;
    std::vector <std::string> defines_;
    std::vector <std::string> undefines_;
    std::vector <std::string> include_paths_;
    std::vector <std::string> includes_;
    std::vector <std::string> files_;
    std::ostream& err_out_;
    bool preprocess_to_stdout_;
};
 
 
#endif