Changeset 5619


Ignore:
Timestamp:
Aug 26, 2017, 2:07:52 PM (4 weeks ago)
Author:
nmedfort
Message:

Memory leak fixes + minor optimization of RE_local.

Location:
icGREP/icgrep-devel/icgrep/re
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/re/re_local.cpp

    r5575 r5619  
    1212#include <UCD/resolve_properties.h>
    1313#include <boost/container/flat_set.hpp>
     14#include <boost/range/adaptor/reversed.hpp>
    1415#include <map>
    1516
     
    1920namespace re {
    2021 
    21 UCD::UnicodeSet* RE_Local::first(RE * re) {
     22inline void combine(CC *& a, CC * b) {
     23    if (a && b) {
     24        a = makeCC(a, b);
     25    } else if (b) {
     26        a = b;
     27    }
     28}
     29
     30CC * RE_Local::first(RE * re) {
    2231    if (Name * name = dyn_cast<Name>(re)) {
    2332        if (LLVM_LIKELY(name->getDefinition() != nullptr)) {
    24             if (CC * cc = dyn_cast<CC>(name->getDefinition())) {
    25                 UCD::UnicodeSet * sets = cast<UCD::UnicodeSet>(cc);
    26                 return sets;
    27             } else {
    28                 return first(name->getDefinition());
    29             }
     33            return first(name->getDefinition());
    3034        } else {
    3135            throw std::runtime_error("All non-unicode-property Name objects should have been defined prior to Unicode property resolution.");
    3236        }
    3337    } else if (CC * cc = dyn_cast<CC>(re)) {
    34         UCD::UnicodeSet * sets = cast<UCD::UnicodeSet>(cc);
    35         return sets;
     38        return cc;
    3639    } else if (Seq * seq = dyn_cast<Seq>(re)) {
    37         UCD::UnicodeSet * UnicodeSets = new UCD::UnicodeSet();
    38         UCD::UnicodeSet UnicodeSets_seq = UCD::UnicodeSet();
    39         for (auto si = seq->begin(); si != seq->end(); ++si) {
    40             if (isNullable(*si) && first(*si) != nullptr) {
    41                 UnicodeSets_seq = UnicodeSets_seq + *(first(*si));
    42             } else if (isNullable(*si) && first(*si) == nullptr) {
    43                 continue;
    44             } else if (!isNullable(*si) && first(*si) != nullptr){
    45                 UnicodeSets_seq = UnicodeSets_seq + *(first(*si));
     40        CC * cc = nullptr;
     41        for (auto & si : *seq) {
     42            combine(cc, first(si));
     43            if (!isNullable(si)) {
    4644                break;
    47             } else {
    48                 break;
    49             }
    50         }
    51         *UnicodeSets = UnicodeSets_seq;
    52         return UnicodeSets_seq.empty() ? nullptr : UnicodeSets;
     45            }
     46        }
     47        return cc;
    5348    } else if (Alt * alt = dyn_cast<Alt>(re)) {
    54         UCD::UnicodeSet * UnicodeSets = new UCD::UnicodeSet();
    55         UCD::UnicodeSet UnicodeSets_alt = UCD::UnicodeSet();
    56         for (auto ai = alt->begin(); ai != alt->end(); ++ai) {
    57             if (first(*ai) != nullptr) {
    58                 UnicodeSets_alt = UnicodeSets_alt + *(first(*ai));
    59             }
    60         }
    61         *UnicodeSets = UnicodeSets_alt;
    62         return UnicodeSets_alt.empty() ? nullptr : UnicodeSets;
     49        CC * cc = nullptr;
     50        for (auto & ai : *alt) {
     51            combine(cc, first(ai));
     52        }
     53        return cc;
    6354    } else if (Rep * rep = dyn_cast<Rep>(re)) {
    6455        return first(rep->getRE());
    6556    } else if (Diff * diff = dyn_cast<Diff>(re)) {
    66         UCD::UnicodeSet * UnicodeSets = new UCD::UnicodeSet();
    67         UCD::UnicodeSet UnicodeSets_diff = UCD::UnicodeSet();
    68         if (first(diff->getLH()) && first(diff->getRH())) {
    69             UnicodeSets_diff = *(first(diff->getLH())) - *(first(diff->getRH()));
    70         }
    71         *UnicodeSets = UnicodeSets_diff;
    72         return UnicodeSets;
     57        if (CC * lh = first(diff->getLH())) {
     58            if (CC * rh = first(diff->getRH())) {
     59                return subtractCC(lh, rh);
     60            }
     61        }
    7362    } else if (Intersect * ix = dyn_cast<Intersect>(re)) {
    74         UCD::UnicodeSet * UnicodeSets = new UCD::UnicodeSet();
    75         UCD::UnicodeSet UnicodeSets_inter = UCD::UnicodeSet();
    76         if (first(ix->getLH()) && first(ix->getRH())) {
    77             UnicodeSets_inter = *(first(ix->getLH())) & *(first(ix->getRH()));
    78         }
    79         *UnicodeSets = UnicodeSets_inter;
    80         return UnicodeSets;
     63        if (CC * lh = first(ix->getLH())) {
     64            if (CC * rh = first(ix->getRH())) {
     65                return intersectCC(lh, rh);
     66            }
     67        }
    8168    }
    8269    return nullptr;
    83 
    84 }
    85 
    86 UCD::UnicodeSet* RE_Local::final(RE * re) {
     70}
     71
     72CC * RE_Local::final(RE * re) {
    8773    if (Name * name = dyn_cast<Name>(re)) {
    8874        if (LLVM_LIKELY(name->getDefinition() != nullptr)) {
    89             if (CC * cc = dyn_cast<CC>(name->getDefinition())) {
    90                 UCD::UnicodeSet * sets = cast<UCD::UnicodeSet>(cc);
    91                 return sets;
    92             } else {
    93                 return final(name->getDefinition());
    94             }
     75            return final(name->getDefinition());
    9576        } else {
    9677            throw std::runtime_error("All non-unicode-property Name objects should have been defined prior to Unicode property resolution.");
    9778        }
    9879    } else if (CC * cc = dyn_cast<CC>(re)) {
    99         UCD::UnicodeSet * sets = cast<UCD::UnicodeSet>(cc);
    100         return sets;
     80        return cc;
    10181    } else if (Seq * seq = dyn_cast<Seq>(re)) {
    102         UCD::UnicodeSet * UnicodeSets = new UCD::UnicodeSet();
    103         UCD::UnicodeSet UnicodeSets_seq = UCD::UnicodeSet();
    104         for (auto si = seq->rbegin(); si != seq->rend(); ++si) {
    105             if (isNullable(*si) && final(*si) != nullptr) {
    106                 UnicodeSets_seq = UnicodeSets_seq + *(final(*si));
    107             } else if (isNullable(*si) && final(*si) == nullptr) {
    108                 continue;
    109             } else if (!isNullable(*si) && final(*si) != nullptr){
    110                 UnicodeSets_seq = UnicodeSets_seq + *(final(*si));
     82        CC * cc = nullptr;
     83        for (auto & si : boost::adaptors::reverse(*seq)) {
     84            combine(cc, first(si));
     85            if (!isNullable(si)) {
    11186                break;
    112             } else {
    113                 break;
    114             }
    115         }
    116         *UnicodeSets = UnicodeSets_seq;
    117         return UnicodeSets_seq.empty() ? nullptr : UnicodeSets;
     87            }
     88        }
     89        return cc;
    11890    } else if (Alt * alt = dyn_cast<Alt>(re)) {
    119         UCD::UnicodeSet * UnicodeSets = new UCD::UnicodeSet();
    120         UCD::UnicodeSet UnicodeSets_alt = UCD::UnicodeSet();
    121         for (auto ai = alt->begin(); ai != alt->end(); ++ai) {
    122             if (final(*ai) != nullptr) {
    123                 UnicodeSets_alt = UnicodeSets_alt + *(final(*ai));
    124             }
    125         }
    126         *UnicodeSets = UnicodeSets_alt;
    127         return UnicodeSets_alt.empty() ? nullptr : UnicodeSets;
     91        CC * cc = nullptr;
     92        for (auto & ai : *alt) {
     93            combine(cc, final(ai));
     94        }
     95        return cc;
    12896    } else if (Rep * rep = dyn_cast<Rep>(re)) {
    12997        return final(rep->getRE());
    13098    } else if (Diff * diff = dyn_cast<Diff>(re)) {
    131         UCD::UnicodeSet * UnicodeSets = new UCD::UnicodeSet();
    132         UCD::UnicodeSet UnicodeSets_diff = UCD::UnicodeSet();
    133         if (final(diff->getLH()) && final(diff->getRH())) {
    134             UnicodeSets_diff = *(final(diff->getLH())) - *(final(diff->getRH()));
    135         }
    136         *UnicodeSets = UnicodeSets_diff;
    137         return UnicodeSets;
     99        if (CC * lh = final(diff->getLH())) {
     100            if (CC * rh = final(diff->getRH())) {
     101                return subtractCC(lh, rh);
     102            }
     103        }
    138104    } else if (Intersect * ix = dyn_cast<Intersect>(re)) {
    139         UCD::UnicodeSet * UnicodeSets = new UCD::UnicodeSet();
    140         UCD::UnicodeSet UnicodeSets_inter = UCD::UnicodeSet();
    141         if (final(ix->getLH()) && final(ix->getRH())) {
    142             UnicodeSets_inter = *(final(ix->getLH())) & *(final(ix->getRH()));
    143         }
    144         *UnicodeSets = UnicodeSets_inter;
    145         return UnicodeSets;
     105        if (CC * lh = final(ix->getLH())) {
     106            if (CC * rh = final(ix->getRH())) {
     107                return intersectCC(lh, rh);
     108            }
     109        }
    146110    }
    147111    return nullptr;
  • icGREP/icgrep-devel/icgrep/re/re_local.h

    r5568 r5619  
    1111class RE_Local {
    1212public:
    13         static UCD::UnicodeSet* first(RE * re);
    14         static UCD::UnicodeSet* final(RE * re);
     13    static CC * first(RE * re);
     14    static CC * final(RE * re);
    1515        static void follow(RE * re, std::map<UCD::UnicodeSet*, UCD::UnicodeSet*> &follow_map);
    1616        static bool isLocalLanguage(RE * re);
  • icGREP/icgrep-devel/icgrep/re/re_multiplex.cpp

    r5565 r5619  
    3333Memoizer                mMemoizer_multiplex;
    3434   
    35 RE * multiplex(RE * re, std::vector<UCD::UnicodeSet> UnicodeSets,
    36                 std::vector<std::vector<unsigned>> exclusiveSetIDs,
    37                 std::vector<UCD::UnicodeSet> multiplexedCCs) {
     35RE * multiplex(RE * const re,
     36               const std::vector<UCD::UnicodeSet> & UnicodeSets,
     37               const std::vector<std::vector<unsigned>> & exclusiveSetIDs,
     38               const std::vector<UCD::UnicodeSet> & multiplexedCCs) {
    3839    if (Name * name = dyn_cast<Name>(re)) {
    3940        auto f = mMemoizer_multiplex.find(name);
  • icGREP/icgrep-devel/icgrep/re/re_multiplex.h

    r5565 r5619  
    99    class Name;
    1010
    11     RE * multiplex(RE * re, std::vector<UCD::UnicodeSet> UnicodeSets,
    12                     std::vector<std::vector<unsigned>> exclusiveSetIDs,
    13                     std::vector<UCD::UnicodeSet> multiplexedCCs);
     11    RE * multiplex(RE * const re, const std::vector<UCD::UnicodeSet> & UnicodeSets,
     12                    const std::vector<std::vector<unsigned>> & exclusiveSetIDs,
     13                    const std::vector<UCD::UnicodeSet> & multiplexedCCs);
    1414
    1515}
Note: See TracChangeset for help on using the changeset viewer.