source: dev/trunk/ab5.0/abdev/ab_common/include/Lexical/Source.h

#pragma once

int ChangeReturnCodeImpl(char *buffer);

class IncludedFilesRelation
{
    std::vector<std::string> filePaths;
    std::vector<int> lineFileNumbers;

    // XMLシリアライズ用
private:
    friend class boost::serialization::access;
    template<class Archive> void serialize(Archive& ar, const unsigned int version)
    {
        ar & BOOST_SERIALIZATION_NVP( filePaths );
        ar & BOOST_SERIALIZATION_NVP( lineFileNumbers );
    }

public:
    IncludedFilesRelation()
    {
    }
    IncludedFilesRelation(IncludedFilesRelation const& y)
        : filePaths(y.filePaths)
        , lineFileNumbers(y.lineFileNumbers)
    {
    }
    IncludedFilesRelation(IncludedFilesRelation&& y)
        : filePaths(std::move(y.filePaths))
        , lineFileNumbers(std::move(y.lineFileNumbers))
    {
    }
    ~IncludedFilesRelation()
    {
    }
    IncludedFilesRelation& operator =(IncludedFilesRelation&& y)
    {
        filePaths = std::move(y.filePaths);
        lineFileNumbers = std::move(y.lineFileNumbers);
        return *this;
    }

    IncludedFilesRelation& operator =(IncludedFilesRelation const& y)
    {
        return *this = std::move(IncludedFilesRelation(y));
    }

    const int GetFileNumber( int lineNumber ) const
    {
        return lineFileNumbers[lineNumber];
    }
    const std::string &GetFilePath( int lineNumber ) const
    {
        return filePaths[GetFileNumber( lineNumber )];
    }
    const std::string &GetFilePathFromFileNumber( int fileNumber ) const
    {
        return filePaths[fileNumber];
    }
    int GetFileCounts() const
    {
        return (int)filePaths.size();
    }

    int AddFile( const std::string &filePath )
    {
        filePaths.push_back( filePath );
        return (int)filePaths.size()-1;
    }
    void AddLine( int fileNumber )
    {
        lineFileNumbers.push_back( fileNumber );
    }

    int GetLineCounts() const
    {
        return (int)lineFileNumbers.size();
    }
};

class Text{
protected:
    char *buffer;
    int length;

public:

    Text(){
        buffer = (char *)calloc( 1, 1 );
        length = 0;
    }
    Text( const Text &text )
        : length( text.length )
    {
        buffer = (char *)malloc( length + 1 );
        memcpy( buffer, text.buffer, length );
        buffer[length] = 0;
    }
    Text(Text&& text)
        : length( text.length )
    {
        buffer = text.buffer;
        text.buffer = static_cast<char*>(calloc(1, 1));
        text.length = 0;
    }
    Text& operator =(Text&& y)
    {
        SwapImpl(*this, y);
        return *this;
    }
    Text& operator =(Text const& y)
    {
        return *this = std::move(Text(y));
    }
    ~Text(){
        free( buffer );
    }
    void Clear()
    {
        length = 0;
    }
    void Add( const std::string &str )
    {
        buffer = (char *)realloc( buffer, length + str.size() + 1 );
        strcpy( buffer + length, str.c_str() );
        length += (int)str.size();
    }
    void Add( const std::vector<char> &str )
    {
        buffer = (char *)realloc( buffer, length + str.size() + 1 );
        strcpy( buffer + length, &str[0] );
        length += (int)str.size();
    }

    bool ReadFile( const std::string &filePath );

    static void SlideString(char *buffer, int slide){
        memmove(buffer+slide, buffer, strlen(buffer)+1);
    }

protected:
    static void SwapImpl(Text& lhs, Text& rhs)
    {
        std::swap(lhs.buffer, rhs.buffer);
        std::swap(lhs.length, rhs.length);
    }
};

class BasicSource : public Text
{
    static const std::string generateDirectiveName;

    IncludedFilesRelation includedFilesRelation;

    // XMLシリアライズ用
private:
    friend class boost::serialization::access;
    BOOST_SERIALIZATION_SPLIT_MEMBER();
    template<class Archive> void load(Archive& ar, const unsigned int version)
    {
        std::string _buffer;
        ar & BOOST_SERIALIZATION_NVP( _buffer );
        ar & BOOST_SERIALIZATION_NVP( length );
        ar & BOOST_SERIALIZATION_NVP( includedFilesRelation );

        // 読み込み後の処理
        Realloc( length );
        for( int i=0; i<length; i++ )
        {
            ULONG_PTR l1 = ( ( _buffer[i*3] >= 'a' ) ? ( _buffer[i*3] - 'a' + 0x0a ) : ( _buffer[i*3] - '0' ) ) * 0x10;
            ULONG_PTR l2 = ( _buffer[i*3+1] >= 'a' ) ? ( _buffer[i*3+1] - 'a' + 0x0a ) : ( _buffer[i*3+1] - '0' );
            ULONG_PTR l = l1 + l2;
            buffer[i] = static_cast<char>(l);
        }
        buffer[length] = 0;
    }
    template<class Archive> void save(Archive& ar, const unsigned int version) const
    {
        // 保存準備
        char *tempCode = (char *)calloc( (length+1) * 3, 1 );
        for( int i=0; i<length; i++ )
        {
            char temp[32];
            sprintf( temp, "%02x,", (unsigned char)buffer[i] );
            tempCode[i*3] = temp[0];
            tempCode[i*3+1] = temp[1];
            tempCode[i*3+2] = temp[2];
        }

        std::string _buffer = tempCode;
        free( tempCode );

        ar & BOOST_SERIALIZATION_NVP( _buffer );
        ar & BOOST_SERIALIZATION_NVP( length );
        ar & BOOST_SERIALIZATION_NVP( includedFilesRelation );
    }

private:
    void Realloc( int newLength )
    {
        bool isEqualBasbuf = false;
        extern char *basbuf;
        if( basbuf == buffer + 2 )
        {
            isEqualBasbuf = true;
        }

        buffer = (char *)realloc( buffer, newLength + 255 );

        length = newLength;

        if( isEqualBasbuf )
        {
            basbuf = buffer + 2;
        }
    }

    void IncludeFiles();

    void ChangeReturnLineChar();

    void RemoveComments();

    bool ReadFile_InIncludeDirective( const std::string &filePath );
    void DirectiveIncludeOrRequire( const std::string &mainSourceFilePath, const std::string &includeDirPath );

    void RemoveReturnLineUnderbar();

    void Initialize( const std::string &source );

public:
    BasicSource(){}
    BasicSource( const BasicSource &basicSource )
        : Text( basicSource )
        , includedFilesRelation( basicSource.includedFilesRelation )
    {
    }
    BasicSource(BasicSource&& basicSource)
        : Text(std::move(basicSource))
        , includedFilesRelation(std::move(basicSource.includedFilesRelation))
    {
    }
    BasicSource( const std::string &source )
    {
        Initialize( source );
    }
    ~BasicSource(){}

    char *GetBuffer(){
        return buffer+2;
    }
    const char *GetBuffer() const
    {
        return buffer+2;
    }
    int GetLength() const
    {
        return length-2;
    }
    void _ResetLength()
    {
        length = static_cast<int>(strlen( buffer ));
    }

    // 指定したインデックスが何行目かを取得
    bool GetLineFromIndex( int index, int &result ) const;

    const IncludedFilesRelation &GetIncludedFilesRelation() const
    {
        return includedFilesRelation;
    }

    void SetBuffer( const char *buffer );

    bool ReadFile( const std::string &filePath, bool isDebug, bool isDll, bool isUnicode, int majorVer, const std::string &mainSourceFilePath, const std::string &includeDirPath );

    void Addition( const char *buffer );

    bool GetLineInfo( int sourceCodePos, int &line, std::string &fileName ) const;

    BasicSource& operator =(const BasicSource &source)
    {
        Realloc( source.length );
        strcpy( buffer, source.buffer );
        return *this;
    }
    BasicSource& operator =(BasicSource&& source)
    {
        Text::SwapImpl(*this, source);
        return *this;
    }

    char operator[]( int index ) const
    {
        if( index>GetLength() )
        {
            Jenga::Throw( "BasicSource bad access" );
        }
        return buffer[2+index];
    }

    std::string cannotIncludePath;
    int cannotIncludeSourcePos;
};
class BasicSources
    : public std::vector<BasicSource>
    , public Jenga::Common::BoostSerializationSupport<BasicSources>
{
    // XMLシリアライズ用
private:
    virtual const char *RootTagName() const
    {
        return "basicSources";
    }
    friend class boost::serialization::access;
    template<class Archive> void serialize(Archive& ar, const unsigned int version)
    {
        ar & boost::serialization::make_nvp("vector_BasicSource", boost::serialization::base_object<std::vector<BasicSource>>(*this));
    }

public:
    BasicSources() {}
    BasicSources(BasicSources&& y) : std::vector<BasicSource>(std::move(y)) {}
    BasicSources(BasicSources const& y) : std::vector<BasicSource>(y) {}
    BasicSources operator =(BasicSources&& y)
    {
        std::vector<BasicSource>::operator =(std::move(y));
        return *this;
    }
    BasicSources operator =(BasicSources const& y)
    {
        return *this = std::move(BasicSources(y));
    }
};

class SourceCodePosition
{
    int relationalObjectModuleIndex;
    int pos;

    // XMLシリアライズ用
private:
    friend class boost::serialization::access;
    template<class Archive> void serialize(Archive& ar, const unsigned int version)
    {
        ar & BOOST_SERIALIZATION_NVP( relationalObjectModuleIndex );
        ar & BOOST_SERIALIZATION_NVP( pos );
    }

public:
    SourceCodePosition( int relationalObjectModuleIndex, int pos )
        : relationalObjectModuleIndex( relationalObjectModuleIndex )
        , pos( pos )
    {
    }
    SourceCodePosition()
        : relationalObjectModuleIndex( -1 )
        , pos( -1 )
    {
    }
    SourceCodePosition(SourceCodePosition const& y)
        : relationalObjectModuleIndex(y.relationalObjectModuleIndex)
        , pos(y.pos)
    {
    }

    SourceCodePosition& operator =(SourceCodePosition const& y)
    {
        relationalObjectModuleIndex = y.relationalObjectModuleIndex;
        pos = y.pos;
        return *this;
    }

    int GetRelationalObjectModuleIndex() const;
    void SetRelationalObjectModuleIndex( int relationalObjectModuleIndex )
    {
        this->relationalObjectModuleIndex = relationalObjectModuleIndex;
    }
    int GetPos() const
    {
        return pos;
    }
    void SetPos( int pos )
    {
        this->pos = pos;
    }

    bool IsNothing() const;
};