IniParser.h

Go to the documentation of this file.

#ifndef __IniParser_h__
#define __IniParser_h__

#include <unistd.h>
#include <ctype.h>
#include <stdio.h>
#include <regex.h>
#include <locale.h>

#include <y2util/RepDef.h>
#include <YCP.h>

#include <iosfwd>
#include <fstream>
#include <string>
#include <vector>
#include <set>

#include "IniFile.h"

using std::string;
using std::vector;
using std::ifstream;
using std::ofstream;
using std::set;

DEFINE_BASE_POINTER (Regex_t);

#pragma GCC visibility push(hidden)

// It is restored when we go out of scope.
class TemporaryLocale
{
public:
    TemporaryLocale (int category, const char * locale);
    ~TemporaryLocale ();
private:
    char *my_setlocale(int category, const char *locale);

    int _category;
    char * _oldlocale;
};
#pragma GCC visibility pop

class Regex_t : virtual public Rep
{
    REP_BODY (Regex_t); 
private:
    friend class Regex;

    regex_t regex;              
    bool live; 

public:
    Regex_t ():
        live (false) {}
    ~Regex_t () {
        if (live)
        {
            regfree (&regex);
        }
    }
    int compile (const string& pattern, bool ignore_case) {
        int ret = -1;
        if (live)
        {
            y2error ("Regex_t @%p already compiled", this);
        }
        else
        {
            // #177560: [A-Za-z] excludes some ASCII letters in Estonian
            TemporaryLocale tl (LC_ALL, "C");

            ret = regcomp (&regex, pattern.c_str (),
                           REG_EXTENDED | (ignore_case ? REG_ICASE : 0));
            if (ret)
            {
                char error[256];
                regerror (ret, &regex, error, 256);
                y2error ("Regex_t %s error: %s", pattern.c_str (), error);
            }
            else
            {
                live = true;
            }
        }
        return ret;
    }
};

class Regex
{
    Regex_tPtr rxtp;
public:
    Regex (): rxtp (0) {}
    int compile (const string& pattern, bool ignore_case) {
        if (rxtp)
        {
            y2error ("Regex_t @%p already compiled", this);
            return -1;
        }
        else
        {
            rxtp = new Regex_t;
            return rxtp->compile (pattern, ignore_case);
        }
    }
    const regex_t * regex () const { return & rxtp->regex; }
};

class RegexMatch
{
public:
    vector<string> matches;
    string rest;

    const string& operator[] (size_t i) { return matches[i]; }
    operator bool () { return matches.size () > 0; }

    RegexMatch (const Regex& rx, const string& s, size_t nmatch = 20) {
        // allocate at least for the whole match
        if (nmatch == 0)
        {
            nmatch = 1;
        }
        regmatch_t rm_matches[nmatch];
        if (0 == regexec (rx.regex (), s.c_str (), nmatch, rm_matches, 0))
        {
            // match
            matches.reserve (nmatch);
            rest = s.substr (0, rm_matches[0].rm_so) +
                s.substr (rm_matches[0].rm_eo);
        }
        else
        {
            // no match
            rm_matches[0].rm_so = -1;
            rest = s;
        }

        size_t i;
        for (i = 0; i < nmatch && rm_matches[i].rm_so != -1; ++i)
        {
            matches.push_back (s.substr (rm_matches[i].rm_so,
                                         rm_matches[i].rm_eo - rm_matches[i].rm_so));
        }
    }
    
};

struct IoPattern
{
    Regex rx;
    string out;
};

struct section
{
    IoPattern begin;
    IoPattern end;
    bool end_valid;
};

struct param
{
    IoPattern line;
    Regex begin;
    Regex end;
    bool multiline_valid;
};

struct FileDescr
{
    string fn;
    string sn;
    time_t timestamp;
    FileDescr (char*fn);
    bool changed ();
    FileDescr () {}
};

class IniParser
{
private:
    time_t timestamp;
    map<string,FileDescr> multi_files;
    string file;
    time_t getTimeStamp();
    bool line_can_continue;
    bool ignore_case_regexps;
    bool ignore_case;
    bool prefer_uppercase;
    bool first_upper;
    bool no_nested_sections;
    bool global_values;
    bool repeat_names;
    bool comments_last;
    bool join_multiline;
    bool no_finalcomment_kill;
    bool read_only;
    bool flat;
    bool shell_quoted_value;

    string subindent;
    vector<Regex> linecomments;
    vector<Regex> comments;
    vector<section> sections;
    vector<param> params;
    vector<IoPattern> rewrites;

    ifstream scanner;
    string scanner_file;
    int scanner_line;

    bool started;

    bool multiple_files;
    vector<string> files;

    int scanner_start(const char*fn);
    void scanner_stop();
    int scanner_get(string&s);

    int parse_helper(IniSection&ini);
    int write_file(const string & filename, IniSection & section);
    int write_helper(IniSection&ini, ofstream&of,int depth);

public:
    set<string> deleted_sections;
    IniSection inifile;
    // apparently the uninitialized members are filled in
    // by the grammar definition
    IniParser () :
        timestamp (0),
        linecomments (), comments (),
        sections (), params (), rewrites (),
        started (false), multiple_files (false),
//      inifile ("toplevel")
        inifile (this)
            {}
    ~IniParser ();
    void initFiles (const char*fn);
    void initFiles (const YCPList&f);
    int initMachine (const YCPMap&scr);
    bool isStarted() { return started; }

    int parse();
    void UpdateIfModif ();

    int write ();

    bool sectionNeedsEnd (int i) { return sections[i].end_valid; }

    string getFileName (const string&sec, int rb) const;
    bool HaveRewrites () const { return rewrites.size () > 0; }

    bool repeatNames () const { return repeat_names; }
    bool isFlat () const { return flat; }

    string changeCase (const string&str) const;
};

#endif//__IniParser_h__