/home/subzero/sqliteman/trunk/Sqliteman/sqliteman/sqlparser/tosqlparse.h

Go to the documentation of this file.

/*
For general Sqliteman copyright and licensing information please refer
to the COPYING file provided with the program. Following this notice may exist
a copyright and/or license notice that predates the release of Sqliteman
for which a new license (GPL+exception) is in place.

This file is based on the TOra source code. http://tora.sf.net
*/
/*****
*
* TOra - An Oracle Toolkit for DBA's and developers
* Copyright (C) 2003-2005 Quest Software, Inc
* Portions Copyright (C) 2005 Other Contributors
*
* 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;  only version 2 of
* the License is valid for this program.
*
* 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.
*
*      As a special exception, you have permission to link this program
*      with the Oracle Client libraries and distribute executables, as long
*      as you follow the requirements of the GNU GPL in regard to all of the
*      software in the executable aside from Oracle client libraries.
*
*      Specifically you are not permitted to link this program with the
*      Qt/UNIX, Qt/Windows or Qt Non Commercial products of TrollTech.
*      And you are not permitted to distribute binaries compiled against
*      these libraries without written consent from Quest Software, Inc.
*      Observe that this does not disallow linking to the Qt Free Edition.
*
*      You may link this product with any GPL'd Qt library such as Qt/Free
*
* All trademarks belong to their respective owners.
*
*****/

#ifndef TOSQLPARSE_H
#define TOSQLPARSE_H

// #include "config.h"

#include <list>
#include <algorithm>
// #include <qstring.h>
#include <QString>

// class toConnection;
// class toMarkedText;
// class toSyntaxAnalyzer;
class SqlEditorWidget;

class toSQLParse
{
public:
    struct settings
    {
        bool ExpandSpaces;
        bool CommaBefore;
        bool BlockOpenLine;
        bool OperatorSpace;
        bool KeywordUpper;
        bool RightSeparator;
        bool EndBlockNewline;
        int IndentLevel;
        int CommentColumn;
    };

    class statement
    {
        std::list<statement> *SubTokens;
    public:
        enum type
        {
            Block,
            Statement,
            List,
            Keyword,
            Token,
            Raw
        } Type;
        QString Comment;
        QString String;
        int Line;
        statement(type ntype = Token, const QString &token = QString::null, int cline = -1);
        std::list<statement> &subTokens();
        statement(const statement &);
        const statement &operator = (const statement &);
        bool operator == (const statement &) const;
        bool operator != (const statement &stat) const
        {
            return !((*this) == stat);
        }
        ~statement();
    };

    class tokenizer
    {
    private:
//         toSyntaxAnalyzer *Analyzer;
    protected:
        int Offset;
        int Line;
    public:
        tokenizer(int offset = 0, int line = 0)
        {
            Line = line;
            Offset = offset;
//             Analyzer = NULL;
        }
//         tokenizer(toSyntaxAnalyzer &analyzer, int offset = 0, int line = 0)
//         {
//             Line = line;
//             Offset = offset;
//             Analyzer = &analyzer;
//         }
        virtual ~tokenizer()
        { }
        virtual QString getToken(bool forward = true, bool comment = false) = 0;
/*        virtual void setAnalyzer(toSyntaxAnalyzer &analyzer)
        {
            Analyzer = &analyzer;
        }
        virtual toSyntaxAnalyzer &analyzer();*/
        virtual int line(void)
        {
            return Line;
        }
        virtual int offset(void)
        {
            return Offset;
        }
        virtual void setOffset(int offset)
        {
            Offset = offset;
        }
        virtual void setLine(int line)
        {
            Line = line;
        }
        virtual QString remaining(bool eol) = 0;
    };

class stringTokenizer : public tokenizer
    {
        QString String;
    public:
        stringTokenizer(const QString &str, int offset = 0, int line = 0)
                : tokenizer(offset, line)
        {
            String = str;
        }
        virtual QString getToken(bool forward = true, bool comment = false);
        virtual QString remaining(bool eol);
    };

class editorTokenizer : public tokenizer
    {
        SqlEditorWidget *Editor;
    public:
        editorTokenizer(SqlEditorWidget *editor, int offset = 0, int line = 0);
        virtual QString getToken(bool forward = true, bool comment = false);
        virtual QString remaining(bool eol);
    };

    static std::list<statement> parse(tokenizer &tokens);
    static std::list<statement> parse(const QString &str)
    {
        stringTokenizer tokens(str);
        return parse(tokens);
    }

    static statement parseStatement(tokenizer &tokens);
    static statement parseStatement(const QString &str)
    {
        stringTokenizer tokens(str);
        return parseStatement(tokens);
    }

    static QString indent(const QString &str);
    static QString indentStatement(statement &stat, int level = 0);

    static QString indentString(int level);

    static QString indent(std::list<statement> &stat);

    static int countIndent(const QString &str, int &chars);
//     static QString indent(const QString &str, toSyntaxAnalyzer &syntax);
//     static QString indent(std::list<statement> &stat, toSyntaxAnalyzer &syntax);
private:
    static settings Settings;
    static statement parseStatement(tokenizer &tokens,
                                    bool declare, bool lst);
//     static QString indentStatement(statement &stat, int level, toSyntaxAnalyzer &conn);
public:
    static settings getSetting(void)
    {
        return Settings;
    }
    static void setSetting(const settings &setting)
    {
        Settings = setting;
    }
};

#endif

---