---

componentfile_preprocess.cpp

Go to the documentation of this file.

/*
        ClanGUI, copyrights by various people. Have a look in the CREDITS file.
        
        This sourcecode is distributed using the Library GNU Public Licence,
        version 2 or (at your option) any later version. Please read LICENSE
        for details.
*/

#include "precomp.h"
#include <algorithm>

#include "API/Core/System/error.h"
#include "API/GUI/component_manager.h"

#include "componentfile_preprocess.h"
#include "component_tokenizer.h"

CL_Componentfile_Preprocess::CL_Componentfile_Preprocess(
        const std::string &_data,
        const std::string &filename) : data(_data)
{
        CL_ComponentTokenizer lexer(data, filename);
        EParseState state = PARSE_GLOBAL;
        EParseState instantiation_dest_state = PARSE_GLOBAL;

        typedef std::map<std::string, TemplateDefinition *> TMAP;
        TMAP template_map;

        int offset;
        int body_scoping_count = 0;
        int cur_template_arg = 0;
//      bool copy_to_output = true;
        std::string template_name;
        std::string last_variable_name;
        int last_variable_offset = 0;
        std::string last_token;
        int last_offset = 0;
        TemplateDefinition *cur = NULL;

        TMAP::iterator cur_instantiation;
        std::vector<std::string> template_arg_vals;
        std::string cur_template_arg_val;

        std::vector<TemplateReplacement> replacements_local;
        std::vector<TemplateReplacement> replacements_global;
        std::vector<TemplateReplacement> *cur_replacement_list = NULL;

        while (true)
        {
                bool pop_token = true;
                const std::string &token = lexer.peek_next_token(&offset);
                if (token == "") break;

                if (token == "=")
                {
                        last_variable_name = last_token;
                        last_variable_offset = last_offset;
                }
                last_token = token;
                last_offset = offset;
                
                switch (state)
                {
                case PARSE_GLOBAL:
                        if (token == "template")
                        {
                                state = PARSE_TEMPLATE;
                                cur = new TemplateDefinition;
                                cur->file_offset = offset;
                        }
                        else
                        {
                                TMAP::iterator f_it = template_map.find(token);
                                if (f_it != template_map.end())
                                {
                                        state = PARSE_TEMPLATE_INSTANTIATION;
                                        instantiation_dest_state = PARSE_GLOBAL;
                                        cur_instantiation = f_it;
                                        cur_replacement_list = &replacements_global;
                                }
                        }
                        break;
                case PARSE_TEMPLATE:
                        if (token == "<")
                        {
                                state = PARSE_TEMPLATE_ARG;
                                cur_template_arg = 0;
                        }
                        else
                        {
                                state = PARSE_TEMPLATE_NAMEDEF;
                                pop_token = false;
                        }
                        break;
                case PARSE_TEMPLATE_ARG:
                        {
                                const std::string &peek = lexer.peek_next_token();
                                if (peek == ",")
                                {
                                        // nop!
                                }
                                else if (peek == ">")
                                {
                                        state = PARSE_TEMPLATE_NAMEDEF;
                                }
                                else
                                {
                                        throw CL_Error(lexer.write_error("Invalid template syntax"));
                                }
                                cur->conversions[token] = std::make_pair(cur_template_arg, std::list<int>());
                                cur_template_arg++;
                        }
                        break;
                case PARSE_TEMPLATE_NAMEDEF:
                        cur->definition_copy_offset = offset;
                        if (CL_ComponentManager::component_types.find(token) != CL_ComponentManager::component_types.end())
                        {
                                const std::string &peek = lexer.peek_next_token(&offset);
                                if (peek == "{") throw CL_Error(lexer.write_error("Missing name"));
                                template_name = peek;
                                cur->name_offset = offset - cur->file_offset;
                                state = PARSE_TEMPLATE_BODY;
                                body_scoping_count = 0;
                        }
                        else
                        {
                                throw CL_Error(lexer.write_error("Missing component type"));
                        }
                        break;
                case PARSE_TEMPLATE_BODY:
                        if (token == "{")
                        {
                                body_scoping_count++;
                        }
                        else if (token == "}")
                        {
                                body_scoping_count--;
                                if (body_scoping_count == 0)
                                {
                                        cur->definition = std::string(
                                                &data.c_str()[cur->file_offset], 
                                                offset+token.length() - cur->file_offset);

                                        TemplateReplacement s;
                                        s.erase_length = cur->definition.length();
                                        s.offset = cur->file_offset;
                                        replacements_global.push_back(s);

                                        perform_replacements(cur->definition, replacements_local, cur->file_offset);
                                        replacements_local.clear();

//                                      std::cout << "Template: '" << cur->definition.c_str() << std::endl;
                                        state = PARSE_GLOBAL;
                                        template_map[template_name] = cur;
                                        cur = NULL;
                                }
                        }
                        else if (cur->conversions.find(token) != cur->conversions.end())
                        {
                                cur->conversions[token].second.push_back(offset - cur->file_offset);
                        }
                        else
                        {
                                TMAP::iterator f_it = template_map.find(token);
                                if (f_it != template_map.end())
                                {
                                        state = PARSE_TEMPLATE_INSTANTIATION;
                                        instantiation_dest_state = PARSE_TEMPLATE_BODY;
                                        cur_instantiation = f_it;
                                        cur_replacement_list = &replacements_local;
                                }
                        }
                        break;
                case PARSE_TEMPLATE_INSTANTIATION:
                        if (token != "<")
                        {
                                throw CL_Error(lexer.write_error("Missing '<' following use of template"));
                        }
                        state = PARSE_TEMPLATE_INSTANTIATION_ARG;
                        cur_template_arg = 0;
                        break;
                case PARSE_TEMPLATE_INSTANTIATION_ARG:
                        {
                                if (token != "," && token != ">")
                                {
                                        cur_template_arg_val.append(token);
                                        cur_template_arg_val.append(1, ' ');
                                }
                                else
                                {
                                        cur_template_arg_val.erase(cur_template_arg_val.length()-1, 1);
                                        template_arg_vals.push_back(cur_template_arg_val);
                                        cur_template_arg_val = "";
                                        cur_template_arg++;

                                        if (token == ">")
                                        {
                                                if (lexer.peek_next_token(&offset) != ";")
                                                {
                                                        throw CL_Error(lexer.write_error("Missing ';' following template instantiation"));
                                                }
                                                state = instantiation_dest_state;
                                                int template_instantiation_length = offset - last_variable_offset + 1;
                                                std::string expanded_template_instantiation = (*cur_instantiation).second->definition;

                                                std::vector<TemplateReplacement> replacements;

                                                TemplateDefinition *cur_definition = (*cur_instantiation).second;
                                                std::string cur_definition_name = (*cur_instantiation).first;
                                                for (int i=0;i<(int) template_arg_vals.size();i++)
                                                {
                                                        TemplateDefinition::CONV_MAP::iterator it = cur_definition->conversions.begin();
                                                        for (;it!=cur_definition->conversions.end();it++)
                                                        {
                                                                if ((*it).second.first == i)
                                                                {
                                                                        int name_length = (*it).first.length();
                                                                        std::list<int> &clist = (*it).second.second;
                                                                        std::list<int>::iterator c_it = clist.begin();
                                                                        std::list<int>::iterator c_it_end = clist.end();
                                                                        for (;c_it!=c_it_end;c_it++)
                                                                        {
                                                                                TemplateReplacement s;
                                                                                s.offset = *c_it;
                                                                                s.erase_length = name_length;
                                                                                s.new_text = template_arg_vals[i];
                                                                                replacements.push_back(s);
                                                                        }
                                                                }
                                                        }
                                                }
                                                perform_replacements(expanded_template_instantiation, replacements, 0);

                                                expanded_template_instantiation.erase(cur_definition->name_offset, cur_definition_name.length());
                                                expanded_template_instantiation.insert(cur_definition->name_offset, last_variable_name);
                                                expanded_template_instantiation.erase(0, cur_definition->definition_copy_offset - cur_definition->file_offset);

        //                                      std::cout << expanded_template_instantiation.c_str() << std::endl;

                                                TemplateReplacement s;
                                                s.erase_length = template_instantiation_length;
                                                s.new_text = expanded_template_instantiation;
                                                s.offset = last_variable_offset;
                                                cur_replacement_list->push_back(s);

                                                template_arg_vals.clear();
                                        }
                                }
                        }
                        break;
                default:
                        throw CL_Error(lexer.write_error("Internal component manager preprocessor error"));
                }

                if (pop_token) lexer.pop_to_peek();
        }

        perform_replacements(data, replacements_global, 0);
}
        
void CL_Componentfile_Preprocess::perform_replacements(
        std::string &string_data,
        std::vector<TemplateReplacement> &replacements,
        int global_offset)
{
        std::sort(replacements.begin(), replacements.end(), SortTemplateReplacementByLocationDescending());
        std::vector<TemplateReplacement>::iterator it = replacements.begin();
        std::vector<TemplateReplacement>::iterator it_end = replacements.end();
        for (;it!=it_end;it++)
        {
                TemplateReplacement &s = *it;
                string_data.erase(s.offset-global_offset, s.erase_length);
                string_data.insert(s.offset-global_offset, s.new_text);
        }
}

---