pattern.cpp

LL1通用语法分析器

/************************************************************************
                        Copyright IBMTC Written by Xinxi Wang
**************************************************************************/

#include <cassert>
#include "Pattern.h"

using namespace std;

Pattern::Pattern()
{
}


Pattern::Pattern(const Token* p)
{
    tokens.push_back(const_cast<Token *>(p));
}


Pattern::Pattern(const Pattern & p)
{
    deepCopy(p);
}


Pattern::Pattern(const vector<Token *>& t) : tokens(t)
{
}


/**
 * The pointer should not be deleteed!
 * @return vector<Token *>
 */
vector<Token *> Pattern::getTokens ( ) const 
{
    return tokens;
}


/**
 * @param  t
 */
void Pattern::setTokens (const vector<Token *>& t )
{    
    dealloc();
    tokens = t;
}


/**
 * 返回两个句型是否相等
 */
bool Pattern::operator==(const Pattern &other) const
{
    if(tokens.size() != other.tokens.size())
        return false;    

    for(size_t i = 0; i < tokens.size(); i++){
        if(!(*tokens[i] == *other.tokens[i]))
            return false;
    }

    return true;
}


/**
 * @brief 赋值运算符
 */
Pattern& Pattern::operator=(const Pattern& p)
{
    deepCopy(p);
    return *this;
}


/**
 * 释放内存
 */
void Pattern::dealloc()
{
    for(size_t i = 0; i < tokens.size(); i++)
        delete tokens[i];
}


/**
 * 深拷贝
 */
void Pattern::deepCopy(const Pattern &p)
{
    dealloc();
    tokens = vector<Token *>(p.tokens.size(), 0);
    
    for(size_t i = 0; i < p.tokens.size(); i++){
        tokens[i] = p.tokens[i]->clone();
    }
}

/**
 * @brief 获取Pattern中第idx个符号
 */
Token * Pattern::at(int index) const
{
    return tokens[index];
}



/**
 * @brief 删除[start, end)间的符号
 */
void Pattern::deleteTokens(int start, int end)
{
    assert(end > start);
    
    for(int i = start; i < end && i < tokens.size(); i++)
        delete tokens[i];

    
    if(start >= tokens.size())
        return;
    
    vector<Token *>::iterator s = tokens.begin() + start;
    vector<Token *>::iterator e = tokens.begin() + end;

    if(end >= tokens.size()){
        e = tokens.end();
    }
    
    tokens.erase(s, e);
}
    

/**
 * @brief 插入符号于pos前面
 */
void Pattern::insertTokens(std::vector<Token*> t, int pos)
{
    vector<Token *>::iterator p = tokens.begin() + pos;

    if(pos >= tokens.size())
       p = tokens.end();
    
    tokens.insert(p, t.begin(), t.end());
}


/**
 * @brief 插入一个符号于pos前面
 */
void Pattern::insertToken(const Token * t, int pos)
{
    vector<Token *>::iterator p = tokens.begin() + pos;
    
    if(pos >= tokens.size())
        p = tokens.end();
    
    tokens.insert(p, const_cast<Token *>(t));
}


/**
 * @brief 在pos前面插入另一个句型
 */
void Pattern::insertPattern(const Pattern& p, int pos)
{
    vector<Token *> t;
    for(int i = 0; i < p.tokens.size(); i++)
        t.push_back(p.tokens[i]->clone());
    
    insertTokens(t, pos);
}

/**
 * @brief 句式长度
 */
size_t Pattern::length() const
{
    return tokens.size();
}


Pattern::~Pattern()
{
    for(size_t i = 0; i < tokens.size(); i++)
        delete tokens[i];
}