Identifier.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "AstUtil/IdentifierAPI.hpp"
#include "AstUtil/StringView.hpp"
#include <string>
#include <memory.h>
#include <cstring>
#include <new>              //  for ::operator delete
 
AST_NAMESPACE_BEGIN
 
 
class Identifier {
private:
    uint32_t length_;         // 字符串长度（字节数）
    char data_[1];          // 内联数据（柔性数组）
    
    // 禁止拷贝和赋值
    Identifier(const Identifier&) = delete;
    Identifier& operator=(const Identifier&) = delete;
    
    // 私有构造函数，只能通过IdentifierTable创建
    explicit Identifier(uint32_t len) : length_(len) {}
    
public:
    // 获取数据指针
    const char* data() const { return data_; }
    char* data()  { return data_; }
 
    
    // 获取长度
    uint32_t length() const { return length_; }
    
    // 转换为C字符串
    const char* c_str() const {
        return data_;
    }
 
    // 释放内存
    // 注意：标识符由 IdentifierTable 变长分配（::operator new(sizeof(Identifier) + length)），
    // 分配尺寸大于 sizeof(Identifier)，而编译器为 delete 生成的 sized deallocation
    // 传入的尺寸是 sizeof(Identifier)，两者不符，ASan 会报 new-delete-type-mismatch。
    // 这里提供类级 operator delete 并转发到无尺寸的全局版本。
    // 有尺寸的版本必须一并声明：只声明无尺寸版本时，若实现仍选中全局 sized delete，问题依旧。
    static void operator delete(void* ptr) noexcept { ::operator delete(ptr); }
    static void operator delete(void* ptr, size_t) noexcept { ::operator delete(ptr); }
 
    // 转换为std::string
    std::string toString() const {
        return std::string(data_, length_);
    }
    
    // 比较操作
    bool equals(const char* str, size_t len) const {
        if (len != length_) return false;
        return memcmp(data_, str, len) == 0;
    }
    
    bool equals(const char* str) const {
        return equals(str, std::char_traits<char>::length(str));
    }
    
    bool equals(const std::string& str) const {
        return equals(str.c_str(), str.length());
    }
    
    bool equals(StringView sv) const {
        return equals(sv.data(), sv.size());
    }
 
    static size_t hash(const char* data, size_t len) {
        // DJB2哈希算法
        size_t h = 5381;
        for (size_t i = 0; i < len; ++i) {
            h = ((h << 5) + h) + static_cast<unsigned char>(data[i]);
        }
        return h;
    }
 
    // 计算哈希值
    size_t hash() const {
        // DJB2哈希算法
        return hash(data_, length_);
    }
    
    
    // 检查是否以特定前缀开头
    bool starts_with(const char* prefix) const {
        size_t prefix_len = strlen(prefix);
        if (static_cast<size_t>(length_) < prefix_len) return false;
        return memcmp(data_, prefix, prefix_len) == 0;
    }
    
    bool starts_with(const std::string& prefix) const {
        return starts_with(prefix.c_str());
    }
    
    // 检查是否以特定后缀结尾
    bool ends_with(const char* suffix) const {
        size_t suffix_len = strlen(suffix);
        if (static_cast<size_t>(length_) < suffix_len) return false;
        return memcmp(data_ + length_ - suffix_len, suffix, suffix_len) == 0;
    }
    
    bool ends_with(const std::string& suffix) const {
        return ends_with(suffix.c_str());
    }
    
    // 友元类，允许IdentifierTable访问私有构造函数
    friend class IdentifierTable;
};
 
 
AST_NAMESPACE_END