---

ConfigFile.cpp

//  ConfigFile - interface to configuration data
//  Copyright (C) 2000 Stephan Beal & Rusty Ballinger
//                     stephan@wanderinghorse.net & rusty@sgi.com
//
//  This program is free software; you can redistribute it and/or
//  modify it under the terms of the GNU General Public License
//  as published by the Free Software Foundation; either version 2
//  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 General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

#include <qcolor.h>
#include <qregexp.h>
#include <qdict.h>
#include <qdir.h>
#include <qvaluelist.h>
#include <iostream>
#include <qregexp.h>
#include <fun/SerialTree.h>
#include <fun/Serializer.h>
#include <fun/Deserializer.h>
#include <fun/ConfigFile.h>
//#include <fun/Serializer.h>
//#include <fun/Deserializer.h>


namespace fun {
        INSTANTIATOR(ConfigFile)


                ConfigFile ConfigFile::funconfig;

        ConfigFile::ConfigFile( const QString &filename ) : PropertyList()
        {
                setFilename( filename );
                //CERR << hex << this << " instantiated! ["<<this->filename<<"]" << endl;
                //  if(boolTable.isEmpty()) initBoolTable();
        }

        ConfigFile::~ConfigFile()
        {
                //CERR << hex << this << " dying! ["<<this->filename<<"]" << endl;
                saveToXML();
        }

        bool
        ConfigFile::saveToText( std::ostream &os) const
        {
                NOT_DONE("saveToText() should be better about wrapping long lines... what it does is unsafe!");
                QString ts;
                QRegExp trailingNewline("\\n$");
                QRegExp newline("\\n");
                QRegExp tab("\\t");
                for(QValueList<QString>::ConstIterator it = order.begin(); it != order.end(); ++it)
                {
                        Entry *e = data.find(*it);
                        //XXX assert(e)?
                        if(!e->cmnt.isEmpty())
                        {
                                ts = e->cmnt;
                                ts.replace(trailingNewline, "");  //  crude.
                                ts.replace(newline, "\n#  ");
                                os << "#  " << ts << endl;
                        }
                        ts = e->val;
                        //      ts.replace(newline, "\\n");
                        //cout << "before replace, ts == \"" << ts << "\"" << endl;
                        ts.replace(newline, "\\n\\\n");  // technically unsafe as it could put
                        //cout << "  after,        ts == \"" << ts << "\"" << endl;
                        ts.replace(tab, "\\t");          // embedded #'s at the start of line.
                        //cerr << *it << " = " << ts << endl;
                        os << *it << " = " << ts << endl;
                }
                return true;
        }

        bool
        ConfigFile::loadFromText( std::istream &is)
        {
                //debug( "========== loading..." );
                //  stomp our current contents.
                data.clear();
                order.clear();
                setNeedsSave( false );

                char line[1000];  //  no lines longer than that, ok?
                //  QRegExp continuedLine("(^\\\\|[^\\\\]\\\\)$");  //  not quite right, as
                QRegExp continuedLine("\\\\$");                 //  not quite right, as
                QRegExp trailingSlash("\\\\$");                 //  \\\ shouldn't continue
                QRegExp noNonSpace("^\\s*$");
                QRegExp leadingComment("^# ? ?");
                QRegExp nonFirstLineComment("\\n# ? ?");  // horrible
                QRegExp slashT("\\\\t");      //  none of these are quite right, as we
                QRegExp slashN("\\\\n");      //  don't want \\t and \\\\t to match.
                QString buf;
                QString cbuf;  //  preceding comment buffer
                QString key, val;
                int len;
                int lno = 0;
                bool inval = false;
                while(++lno)  //  first line below exits loop.
                {
                        if(!is.getline(line, sizeof(line)).good()) break;
                        //cout << "read \"" << line << "\"" << endl;
                        if(line[0] == '#')
                        {
                                if(buf.isEmpty())
                                {
                                        cbuf += line;  //  otherwise this is in a multi-
                                        cbuf += "\n";  //  line value, and gets tossed.
                                }
                                //  Otherwise this comment is embedded in a multi-line value; we
                                //  don't really have any place to put it.
                                continue;
                        }
                        len = strlen(line);
                        buf += line;
                        //cout << "  concat, buf now \"" << buf << "\"" << endl;
                        if(buf.contains(continuedLine))
                        {
                                buf.replace(trailingSlash, "");
                                //cout << "  continued, buf now \"" << buf << "\"" << endl;
                                continue;
                        }
                        if(buf.isEmpty() || buf.contains(noNonSpace))
                        {
                                buf = cbuf = "";
                                continue;
                        }
                        //  Otherwise, we're still here, so buf contains a complete entry,
                        //  and we'll try to split it into key & value, replace escaped
                        //  chars, etc.
                        int epos = buf.find("=");
                        if(epos == -1)
                        {
                                NOT_DONE("loadFromText doesn't handle missing \"=\" in entry ending on line " << dec << lno);
                                return false;
                        }
                        key = buf.left(epos).stripWhiteSpace();
                        val = buf.right(buf.length() - epos - 1).stripWhiteSpace();
                        //cout << "  key == \"" << key << "\", val == \"" << val << "\"" << endl;
                        if(key.isEmpty())
                        {
                                NOT_DONE("loadFromText doesn't handle null key in entry ending on line " << dec << lno);
                                return false;
                        }
                        val.replace(slashT, "\t");
                        val.replace(slashN, "\n");
                        //cout << "  after replace, val == \"" << val << "\"" << endl;
                        set(key, val);
                        if(!cbuf.isEmpty())
                        {
                                cbuf.replace(leadingComment, "");
                                cbuf.replace(nonFirstLineComment, "\n");
                                setComment(key, cbuf);
                        }
                        buf = cbuf = "";
                }
                //debug( "========== Done reading ini file." );
                return true;
        }




        bool
        ConfigFile::loadFromXML(const QString &fn )
        {
                if( !fn.isEmpty() ) setFilename( fn ); // arguable, to set it before seeing if we can save there.
                SerialTree *tree = SerialTree::loadFromXMLFile(filename);
                if(tree == NULL)
                {
                        //CERR << "ConfigFile::loadFromXML(" << filename.data()<<"): SerialTree == NULL" << endl;
                        return false;
                }
                ConfigFile *cf = 0;
                cf = dynamic_cast<ConfigFile *>( tree->getSerializable("configfile") );
                if ( ! cf ) 
                {
                        //CERR << "ConfigFile::deserialize() could not find configfile node!" << endl;
                        return false;
                }
                //  cf->deserialize( *tree ); // ???
                mergeIn( cf );
                delete( cf );

                return true;
        }

        void ConfigFile::deserialize(const Deserializer &ser)
        {
                PropertyList::deserialize(ser);
        }

        bool
        ConfigFile::saveToXML(const QString &fn) const
        {
                if( ! fn.isEmpty() ) this->filename = fn; // arguable, to set it before seeing if we can save there.
                if( filename.isEmpty() ) return false;
                //CERR << "saveToXML( "<<fn<<" == "<<filename<<" )"<<endl;
                SerialTree tree;
                tree.putSerializable( "configfile", *this );
                return tree.saveToXMLFile( filename );
        }

        void ConfigFile::serialize(Serializer &ser) const
        {
                PropertyList::serialize(ser);
                ser.setSerializableClass("ConfigFile");
        }


        void 
        ConfigFile::setFilename( const QString &fn )
        {
                //  CERR << hex << this << "["<<this->filename<< "] new filename: ["<<fn<<"]" << endl;
                this->filename = fn;
        }

        QString
        ConfigFile::getFilename()
        {
                return this->filename;
        }

        // static 
        ConfigFile &
        ConfigFile::funConfig()
        {
                if( funconfig.getFilename().isEmpty() )
                {
                        //         CERR << "funconfig starting up." << endl;
                        funconfig.loadFromXML( QDir::homeDirPath() + QDir::separator() + ".libfun.conf" );
                }
                return funconfig;
        }

        bool
        ConfigFile::save()
        {
                return this->saveToXML();
        }

        bool
        ConfigFile::load()
        {
                return this->loadFromXML();
        }

}; // namespace fun

---