Changeset 4819


Ignore:
Timestamp:
Oct 4, 2015, 4:59:28 PM (2 years ago)
Author:
nmedfort
Message:

First stage of CC_NameMap removal

Location:
icGREP/icgrep-devel/icgrep
Files:
1 deleted
8 edited
1 moved

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/UCD/ucd_compiler.cpp

    r4814 r4819  
    22#include <cc/cc_compiler.h>
    33#include <UCD/unicode_set.h>
     4#include <re/re_name.h>
    45#include <utf8_encoder.h>
    56
  • icGREP/icgrep-devel/icgrep/cc/cc_namemap.cpp

    r4673 r4819  
    99#include <re/re_assertion.h>
    1010#include <UCD/resolve_properties.h>
     11#include <re/printer_re.h>
    1112
    1213using namespace re;
     
    6162            return f->second;
    6263        }
    63         return insert(std::move(classname), (type == ByteClass) ? makeByteName(classname, cc) : makeName(classname, cc));
     64        return insert(std::move(classname), makeName(classname, cc));
    6465    }
    6566    return re;
  • icGREP/icgrep-devel/icgrep/re/re_compiler.cpp

    r4818 r4819  
    1818#include <re/re_assertion.h>
    1919#include <re/re_analysis.h>
     20#include <re/printer_re.h>
    2021#include <cc/cc_namemap.hpp>
    2122#include <pablo/codegenstate.h>
  • icGREP/icgrep-devel/icgrep/re/re_memoizer.hpp

    r4818 r4819  
    22#define RE_NAMEDICTIONARY_H
    33
     4#include <re/re_name.h>
     5#include <set>
     6
    47namespace re {
    58
    6 class NameDictionary
    7 {
    8 public:
    9     NameDictionary();
     9namespace {
     10
     11struct MemoizerComparator {
     12    inline bool operator() (const RE * lh, const RE * rh) const{
     13        if (LLVM_LIKELY(isa<Name>(lh) && isa<Name>(rh))) {
     14            return *cast<Name>(lh) < *cast<Name>(rh);
     15        } else if (isa<Name>(lh)) {
     16            return *cast<Name>(lh) < *cast<CC>(rh);
     17        }
     18        return !(*cast<Name>(rh) < *cast<CC>(lh));
     19    }
     20};
     21
     22}
     23
     24struct Memoizer : private std::set<RE *, MemoizerComparator> {
     25
     26    inline Name * memoize(CC * cc) {
     27        auto f = find(cc);
     28        if (f != end()) {
     29            return cast<Name>(*f);
     30        } else {
     31            Name * name = makeName(cc->canonicalName(CC_type::UnicodeClass), cc);
     32            insert(name);
     33            return name;
     34        }
     35    }
     36
     37    inline Name * memoize(Name * name) {
     38        return cast<Name>(*insert(name).first);
     39    }
    1040};
    1141
  • icGREP/icgrep-devel/icgrep/re/re_name.h

    r4818 r4819  
    55#include <re/re_cc.h>
    66#include <string>
    7 #include <re/printer_re.h>
    87
    98namespace pablo {
     
    4342        mCompiled = var;
    4443    }
     44    bool operator<(const Name & other) const;
     45    bool operator<(const CC & other) const;
    4546    void setDefinition(RE * definition);
    4647    virtual ~Name() {}
    4748protected:
    4849    friend Name * makeName(const std::string &, RE *);
    49     friend Name * makeByteName(const std::string &, RE *);
    5050    friend Name * makeName(const std::string &, const Type);
    5151    friend Name * makeName(const std::string &, const std::string &, const Type);
     
    106106}
    107107
     108inline bool Name::operator < (const Name & other) const {
     109    if (mDefinition && other.mDefinition && isa<CC>(mDefinition) && isa<CC>(other.mDefinition)) {
     110        return *cast<CC>(mDefinition) < *cast<CC>(other.mDefinition);
     111    } else if (mNamespaceLength < other.mNamespaceLength) {
     112        return true;
     113    } else if (mNamespaceLength > other.mNamespaceLength) {
     114        return false;
     115    } else if (mNameLength < other.mNameLength) {
     116        return true;
     117    } else if (mNameLength > other.mNameLength) {
     118        return false;
     119    }
     120    const auto diff = std::memcmp(mNamespace, other.mNamespace, mNamespaceLength);
     121    if (diff < 0) {
     122        return true;
     123    } else if (diff > 0) {
     124        return false;
     125    }
     126    return (std::memcmp(mName, other.mName, mNameLength) < 0);
     127}
     128
     129inline bool Name::operator < (const CC & other) const {
     130    if (mDefinition && isa<CC>(mDefinition)) {
     131        return *cast<CC>(mDefinition) < other;
     132    }
     133    return false;
     134}
     135
    108136inline Name * makeName(const std::string & name, const Name::Type type) {
    109137    return new Name(nullptr, 0, name.c_str(), name.length(), type, nullptr);
     
    125153}
    126154
    127 inline Name * makeByteName(const std::string & name, RE * cc) {
    128     if (isa<Name>(cc)) {
    129         return cast<Name>(cc);
    130     }
    131     else {
    132         return new Name(nullptr, 0, name.c_str(), name.length(), Name::Type::Byte, cc);
    133     }
    134 }
    135 
    136155}
    137156
  • icGREP/icgrep-devel/icgrep/re/re_parser.cpp

    r4812 r4819  
    137137            case ']':
    138138                if (LEGACY_UNESCAPED_RBRAK_RBRACE_ALLOWED) {
    139                     return build_CC(parse_utf8_codepoint());
     139                    return createCC(parse_utf8_codepoint());
    140140                }
    141141                else throw ParseFailure("Use  \\] for literal ].");
     
    145145                }
    146146                else if (LEGACY_UNESCAPED_RBRAK_RBRACE_ALLOWED) {
    147                     return build_CC(parse_utf8_codepoint());
     147                    return createCC(parse_utf8_codepoint());
    148148                }
    149149                else throw ParseFailure("Use \\} for literal }.");
     
    158158                return parse_escaped();
    159159            default:
    160                 return build_CC(parse_utf8_codepoint());
     160                return createCC(parse_utf8_codepoint());
    161161        }
    162162    }
     
    383383      return parseEscapedSet();
    384384    else
    385       return build_CC(parse_escaped_codepoint());
     385      return createCC(parse_escaped_codepoint());
    386386}
    387387
     
    495495}
    496496
    497 Name * RE_Parser::parsePropertyExpression() {
     497RE * RE_Parser::parsePropertyExpression() {
    498498    const cursor_t start = _cursor;
    499499    while (_cursor != _end && *_cursor != '}' and *_cursor != ':' and *_cursor != '=') {
     
    513513}
    514514
    515 Name * RE_Parser::createName(const std::string value) {
    516 
    517     auto key = std::make_pair("", value);
    518     auto f = mNameMap.find(key);
    519     if (f != mNameMap.end()) {
    520         return f->second;
    521     }
    522     Name * property = makeName(value, Name::Type::UnicodeProperty);
    523     mNameMap.insert(std::make_pair(std::move(key), property));
    524     return property;
    525 }
    526 
    527 Name * RE_Parser::createName(const std::string prop, const std::string value) {
    528     auto key = std::make_pair(prop, value);
    529     auto f = mNameMap.find(key);
    530     if (f != mNameMap.end()) {
    531         return f->second;
    532     }
    533     Name * property = makeName(prop, value, Name::Type::UnicodeProperty);
    534     mNameMap.insert(std::make_pair(std::move(key), property));
    535     return property;
    536 }
    537 
    538 CC * RE_Parser::parseNamePatternExpression(){
    539 
    540     re::ModeFlagSet outerFlags = fModeFlagSet;
     515RE * RE_Parser::parseNamePatternExpression(){
     516
     517    ModeFlagSet outerFlags = fModeFlagSet;
    541518    fModeFlagSet = 1;
    542519
     
    554531
    555532    // Embed the nameRE in ";.*$nameRE" to skip the codepoint field of Uname.txt
    556     RE * embedded = makeSeq({re::makeCC(0x3B), re::makeRep(re::makeAny(), 0, Rep::UNBOUNDED_REP), nameRE});
     533    RE * embedded = makeSeq({mMemoizer.memoize(makeCC(0x3B)), makeRep(makeAny(), 0, Rep::UNBOUNDED_REP), nameRE});
    557534    Encoding encoding(Encoding::Type::UTF_8, 8);
    558535    embedded = regular_expression_passes(encoding, embedded);
     
    571548    catch (std::runtime_error e) {
    572549        releaseSlabAllocatorMemory();
    573         std::cerr << "Runtime error: " << e.what() << std::endl;
    574         exit(1);
     550        throw e;
    575551    }
    576552#ifndef NDEBUG
     
    586562    void * icgrep_MCptr = engine->getPointerToFunction(nameSearchIR);
    587563   
    588     CC * nameSearchResult = nullptr;
     564    CC * result = nullptr;
    589565    if (icgrep_MCptr) {
    590566        GrepExecutor grepEngine(icgrep_MCptr);
    591567        grepEngine.setParseCodepointsOption();
    592568        grepEngine.doGrep("../Uname.txt");
    593         nameSearchResult = grepEngine.getParsedCodepoints();
    594     }
    595    
    596     //engine->freeMachineCodeForFunction(nameSearchIR); // This function only prints a "not supported" message. Reevaluate with LLVM 3.6.
     569        result = grepEngine.getParsedCodepoints();
     570    }
    597571    delete engine;
    598     return nameSearchResult;
     572    return mMemoizer.memoize(result);
    599573}
    600574
     
    672646    // if and only if it appears immediately after the opening [ or [^
    673647    if ( *_cursor == ']' && LEGACY_UNESCAPED_RBRAK_RBRACE_ALLOWED) {
    674         cc->insert(']');
     648        insert(cc, ']');
    675649        lastItemKind = CodepointItem;
    676650        lastCodepointItem = static_cast<codepoint_t> (']');
     
    679653    else if ( *_cursor == '-' && LEGACY_UNESCAPED_HYPHEN_ALLOWED) {
    680654        ++_cursor;
    681         cc->insert('-');
     655        insert(cc, '-');
    682656        lastItemKind = CodepointItem;
    683657        lastCodepointItem = static_cast<codepoint_t> ('-');
     
    694668                    throw ParseFailure("Set operator has no left operand.");
    695669                }
    696                 if (cc->begin() != cc->end()) {
    697                     subexprs.push_back(cc);
     670                if (!cc->empty()) {
     671                    subexprs.push_back(mMemoizer.memoize(cc));
    698672                }
    699673                RE * newOperand = makeAlt(subexprs.begin(), subexprs.end());
     
    720694                    throw ParseFailure("Set operator has no right operand.");
    721695                }
    722                 if (cc->begin() != cc->end()) {
    723                     subexprs.push_back(cc);
     696                if (!cc->empty()) {
     697                    subexprs.push_back(mMemoizer.memoize(cc));
    724698                }
    725699                RE * newOperand = makeAlt(subexprs.begin(), subexprs.end());
     
    742716            case posixPropertyOpener: {
    743717                if (lastItemKind != NoItem) {
    744                     if (cc->begin() != cc->end()) subexprs.push_back(cc);
     718                    if (!cc->empty()) {
     719                        subexprs.push_back(mMemoizer.memoize(cc));
     720                    }
    745721                    RE * newOperand = makeAlt(subexprs.begin(), subexprs.end());
    746722                    subexprs.clear();
     
    783759                    throw ParseFailure("Range operator - has illegal left operand.");
    784760                }
    785                 cc->insert_range(lastCodepointItem, parse_codepoint());
     761                insert_range(cc, lastCodepointItem, parse_codepoint());
    786762                lastItemKind = RangeItem;
    787763                break;
    788764            case hyphenChar:
    789                 cc->insert('-');
     765                insert(cc, '-');
    790766                lastItemKind = CodepointItem;
    791767                lastCodepointItem = static_cast<codepoint_t> ('-');
    792768                break;
    793769            case ampChar:
    794                 cc->insert('&');
     770                insert(cc, '&');
    795771                lastItemKind = CodepointItem;
    796772                lastCodepointItem = static_cast<codepoint_t> ('&');
     
    804780                else {
    805781                    lastCodepointItem = parse_escaped_codepoint();
    806                     cc->insert(lastCodepointItem);
     782                    insert(cc, lastCodepointItem);
    807783                    lastItemKind = CodepointItem;
    808784                }
     
    810786            case emptyOperator:
    811787                lastCodepointItem = parse_utf8_codepoint();
    812                 cc->insert(lastCodepointItem);
     788                insert(cc, lastCodepointItem);
    813789                lastItemKind = CodepointItem;
    814790                break;
     
    957933}
    958934
    959 CC * RE_Parser::build_CC(codepoint_t cp) {
    960     CC * cc = makeCC();
    961     CC_add_codepoint(cc, cp);
    962     return cc;
    963 }
    964 
    965 void RE_Parser::CC_add_codepoint(CC * cc, codepoint_t cp) {
     935inline Name * RE_Parser::createCC(const codepoint_t cp) {
     936    CC * cc = nullptr;
     937    if (fModeFlagSet & CASE_INSENSITIVE_MODE_FLAG) {
     938        cc = makeCC();
     939        caseInsensitiveInsert(cc, cp);
     940    } else {
     941        cc = makeCC(cp);
     942    }
     943    return mMemoizer.memoize(cc);
     944}
     945
     946inline void RE_Parser::insert(CC * cc, const codepoint_t cp) {
    966947    if (fModeFlagSet & CASE_INSENSITIVE_MODE_FLAG) {
    967948        caseInsensitiveInsert(cc, cp);
     
    971952}
    972953
    973 void RE_Parser::CC_add_range(CC * cc, codepoint_t lo, codepoint_t hi) {
     954inline void RE_Parser::insert_range(CC * cc, const codepoint_t lo, const codepoint_t hi) {
    974955    if (fModeFlagSet & CASE_INSENSITIVE_MODE_FLAG) {
    975956        caseInsensitiveInsertRange(cc, lo, hi);
     
    995976}
    996977
    997 inline Name * RE_Parser::makeDigitSet() {
     978inline RE * RE_Parser::makeDigitSet() {
    998979    return createName("nd");
    999980}
    1000981
    1001 inline Name * RE_Parser::makeAlphaNumeric() {
     982inline RE * RE_Parser::makeAlphaNumeric() {
    1002983    return createName("alnum");
    1003984}
    1004985
    1005 inline Name * RE_Parser::makeWhitespaceSet() {
     986inline RE * RE_Parser::makeWhitespaceSet() {
    1006987    return createName("whitespace");
    1007988}
    1008989
    1009 inline Name * RE_Parser::makeWordSet() {
     990inline RE * RE_Parser::makeWordSet() {
    1010991    return createName("word");
    1011992}
    1012993
    1013 }
     994RE * RE_Parser::createName(const std::string value) {
     995    auto key = std::make_pair("", value);
     996    auto f = mNameMap.find(key);
     997    if (f != mNameMap.end()) {
     998        return f->second;
     999    }
     1000    RE * const property = mMemoizer.memoize(makeName(value, Name::Type::UnicodeProperty));
     1001    mNameMap.insert(std::make_pair(std::move(key), property));
     1002    return property;
     1003}
     1004
     1005RE * RE_Parser::createName(const std::string prop, const std::string value) {
     1006    auto key = std::make_pair(prop, value);
     1007    auto f = mNameMap.find(key);
     1008    if (f != mNameMap.end()) {
     1009        return f->second;
     1010    }
     1011    RE * const property = mMemoizer.memoize(makeName(prop, value, Name::Type::UnicodeProperty));
     1012    mNameMap.insert(std::make_pair(std::move(key), property));
     1013    return property;
     1014}
     1015
     1016}
  • icGREP/icgrep-devel/icgrep/re/re_parser.h

    r4809 r4819  
    1616#include <memory>
    1717#include <map>
    18 
     18#include <re/re_memoizer.hpp>
    1919
    2020namespace re {
     
    4343private:
    4444
    45     using NameMap = std::map<std::pair<std::string, std::string>, re::Name *>;
     45    using NameMap = std::map<std::pair<std::string, std::string>, re::RE *>;
    4646
    47     typedef std::string::const_iterator cursor_t;
     47    using cursor_t = std::string::const_iterator;
    4848
    4949    RE_Parser(const std::string & regular_expression);
     
    7373    codepoint_t parse_utf8_codepoint();
    7474
    75     Name * parsePropertyExpression();
     75    RE * parsePropertyExpression();
    7676
    77     CC * parseNamePatternExpression();
     77    RE * parseNamePatternExpression();
    7878
    7979    RE * makeComplement(RE * s);
    8080    RE * makeWordBoundary();
    8181    RE * makeWordNonBoundary();
    82     Name * makeDigitSet();
    83     Name * makeAlphaNumeric();
    84     Name * makeWhitespaceSet();
    85     Name * makeWordSet();
     82    RE * makeDigitSet();
     83    RE * makeAlphaNumeric();
     84    RE * makeWhitespaceSet();
     85    RE * makeWordSet();
    8686
    87     Name * createName(const std::string value);
    88     Name * createName(const std::string prop, const std::string value);
     87    RE * createName(const std::string value);
     88    RE * createName(const std::string prop, const std::string value);
    8989
    9090    CharsetOperatorKind getCharsetOperator();
     
    103103
    104104    // CC insertion dependent on case-insensitive flag.
    105     CC * build_CC(codepoint_t cp);
    106 
    107     void CC_add_codepoint(CC * cc, codepoint_t cp);
    108 
    109     void CC_add_range(CC * cc, codepoint_t lo, codepoint_t hi);
     105    Name * createCC(const codepoint_t cp);
     106    void insert(CC * cc, const codepoint_t cp);
     107    void insert_range(CC * cc, const codepoint_t lo, const codepoint_t hi);
    110108
    111109    static std::string canonicalize(const cursor_t begin, const cursor_t end);
     
    118116    bool                        fNested;
    119117    NameMap                     mNameMap;
     118    Memoizer                    mMemoizer;
    120119};
    121120
  • icGREP/icgrep-devel/icgrep/toolchain.cpp

    r4815 r4819  
    100100        std::cerr << "RemoveNullableSuffix:" << std::endl << Printer_RE::PrintRE(re_ast) << std::endl;
    101101    }
    102    
    103     cc::CC_NameMap nameMap;
    104     re_ast = nameMap.process(re_ast, re::UnicodeClass);
    105    
    106     // std::cerr << "-----------------------------" << std::endl;
    107    
    108     if (PrintAllREs || PrintNamedREs) {
    109         std::cerr << "Namer:" << std::endl << Printer_RE::PrintRE(re_ast) << std::endl;
    110         std::cerr << "NameMap:\n" << nameMap.printMap() << std::endl;
    111     }
    112102
    113103    re_ast = re::RE_Simplifier::simplify(re_ast);
  • icGREP/icgrep-devel/icgrep/utf8_encoder.h

    r4814 r4819  
    88#define UTF8_ENCODER_H
    99
    10 //Regular Expressions
    1110#include <re/re_cc.h>
    12 #include <cc/cc_namemap.hpp>
    1311
    1412namespace cc {
    15 
    16 class CC_NameMap;
    1713
    1814struct UTF8_Encoder {
Note: See TracChangeset for help on using the changeset viewer.