ph_processor.h

#pragma once
 
#include <string>
#include <vector>
#include <fstream>
#include "variables.h"
#include "command_token.h"
#include <cgv/utils/advanced_scan.h>
 
#include "lib_begin.h"
 
namespace cgv {
    namespace ppp {
        class CGV_API ph_processor
        {
            using token = cgv::utils::token;
 
        protected:
            friend class expression_processor;
            bool found_error;
            unsigned nr_functions;
            char special;
            bool generate_output;
            bool content_is_external;
            std::ostream* os;
            std::ostream* es;
            const std::string* content;
            std::string file_name;
            std::vector<cgv::utils::line> lines;
            std::vector<command_token> commands;
            int recursion_depth;
 
            std::vector<std::string>* inserted_shader_file_names;
 
            unsigned int get_line_number(const token& loc) const;
            void error(const std::string& text, const token& loc, unsigned int error_number = 0);
            bool check_evaluation_error(unsigned int i, unsigned int ei);
 
            bool process(unsigned int i, unsigned int j);
            bool parse();
            bool parse_without_special(unsigned nr_skip = 0);
        public:
            static std::string my_getenv(const char* name);
            std::string find_include_file(const std::string& fn, bool local) const;
        protected:
            bool process_include(unsigned int i, bool is_cinclude = false, bool insert = false);
            bool process_list(unsigned int i);
 
            bool debug_reflection;
            variant* reflect_info;
            enum ReflectionParenthesis { RP_COMPOUND, RP_NAMESPACE };
            std::vector<ReflectionParenthesis> rp_stack;
            std::vector<std::string> namespace_stack;
            std::vector<variant*>    compound_stack;
            std::vector<std::string> compound_access_type_stack;
            variant construct_namespace_list() const;
            std::string construct_namespace_sequence() const;
            void ensure_reflect_info();
            bool reflect(const token& code, const token& comment);
 
            bool recursive_dir(std::string rel_directory,
                std::string actual_directory, std::string filter,
                bool rel_path, variant& desc_list, bool recursive);
            std::string additional_include_path;
            bool search_recursive;
        public:
            ph_processor(const std::string& _additional_include_path = "", bool _search_recursive = false, char _special = '@');
            ~ph_processor();
            int exit_code;
            void swap_output(ph_processor& pp);
            char get_special() const { return special; }
            void configure_insert_to_shader(std::vector<std::string>* _inserted_shader_file_names);
 
 
            void set_error_stream(std::ostream& error_stream);
 
            bool parse_string(const std::string& text);
            bool parse_file(const std::string& file_name);
 
            bool process_to_string(std::string& output);
            int process_to_file(const std::string& _file_name, long long last_write_time = 0);
            bool process_without_output();
            /*
                enum ProcessingOptions {
 
                int process_input_to_string(const std::string& inp_file, std::string& output, int processing_options);
                int process_input_to_file(const std::string& inp_file, const std::string& out_file, int processing_options, );
                */
            void close();
        };
 
    }
}
#include <cgv/config/lib_end.h>