Ignore:
Timestamp:
Oct 11, 2015, 1:45:52 PM (4 years ago)
Author:
nmedfort
Message:

Back-up check in

File:
1 edited

Legend:

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

    r4442 r4829  
    1111#include "re_intersect.h"
    1212#include "re_assertion.h"
     13#include <iostream>
     14#include <re/printer_re.h>
    1315#include <limits.h>
    1416
    1517namespace re {
    1618
    17 bool isByteLength(RE * re) {
    18     if (Alt * alt = dyn_cast<Alt>(re)) {
    19         for (RE * re : *alt) {
     19bool isByteLength(const RE * re) {
     20    if (const Alt * alt = dyn_cast<Alt>(re)) {
     21        for (const RE * re : *alt) {
    2022            if (!isByteLength(re)) {
    2123                return false;
     
    2426        return true;
    2527    }
    26     else if (Seq * seq = dyn_cast<Seq>(re)) {
     28    else if (const Seq * seq = dyn_cast<Seq>(re)) {
    2729        return (seq->size() == 1) && isByteLength(&seq[0]);
    2830    }
    29     else if (Rep * rep = dyn_cast<Rep>(re)) {
     31    else if (const Rep * rep = dyn_cast<Rep>(re)) {
    3032        return (rep->getLB() == 1) && (rep->getUB() == 1) && isByteLength(rep->getRE());
    3133    }
     
    3335        return false;
    3436    }
    35     else if (Diff * diff = dyn_cast<Diff>(re)) {
     37    else if (const Diff * diff = dyn_cast<Diff>(re)) {
    3638        return isByteLength(diff->getLH()) && isByteLength(diff->getRH());
    3739    }
    38     else if (Intersect * e = dyn_cast<Intersect>(re)) {
     40    else if (const Intersect * e = dyn_cast<Intersect>(re)) {
    3941        return isByteLength(e->getLH()) && isByteLength(e->getRH());
    4042    }
     
    4244        return false;
    4345    }
    44     else if (Name * n = dyn_cast<Name>(re)) {
     46    else if (const Name * n = dyn_cast<Name>(re)) {
    4547        return (n->getType() == Name::Type::Byte);
    4648    }
     
    4850}
    4951
    50 bool isUnicodeUnitLength(RE * re) {
    51     if (Alt * alt = dyn_cast<Alt>(re)) {
    52         for (RE * re : *alt) {
     52bool isUnicodeUnitLength(const RE * re) {
     53    if (const Alt * alt = dyn_cast<Alt>(re)) {
     54        for (const RE * re : *alt) {
    5355            if (!isUnicodeUnitLength(re)) {
    5456                return false;
     
    5759        return true;
    5860    }
    59     else if (Seq * seq = dyn_cast<Seq>(re)) {
     61    else if (const Seq * seq = dyn_cast<Seq>(re)) {
    6062        return (seq->size() == 1) && isUnicodeUnitLength(&seq[0]);
    6163    }
    62     else if (Rep * rep = dyn_cast<Rep>(re)) {
     64    else if (const Rep * rep = dyn_cast<Rep>(re)) {
    6365        return (rep->getLB() == 1) && (rep->getUB() == 1) && isUnicodeUnitLength(rep->getRE());
    6466    }
     
    6668        return false;
    6769    }
    68     else if (Diff * diff = dyn_cast<Diff>(re)) {
     70    else if (const Diff * diff = dyn_cast<Diff>(re)) {
    6971        return isUnicodeUnitLength(diff->getLH()) && isUnicodeUnitLength(diff->getRH());
    7072    }
    71     else if (Intersect * e = dyn_cast<Intersect>(re)) {
     73    else if (const Intersect * e = dyn_cast<Intersect>(re)) {
    7274        return isUnicodeUnitLength(e->getLH()) && isUnicodeUnitLength(e->getRH());
    7375    }
     
    7577        return true;
    7678    }
    77     else if (Name * n = dyn_cast<Name>(re)) {
     79    else if (const Name * n = dyn_cast<Name>(re)) {
    7880        // Eventually names might be set up for not unit length items.
    7981        return (n->getType() == Name::Type::Unicode || n->getType() == Name::Type::UnicodeProperty || n->getType() == Name::Type::Byte);
    8082    }
    8183    return false; // otherwise
     84}
     85
     86std::pair<int, int> getUnicodeUnitLengthRange(const RE * re) {
     87    if (const Alt * alt = dyn_cast<Alt>(re)) {
     88        std::pair<int, int> range = std::make_pair(std::numeric_limits<int>::max(), 0);
     89        for (const RE * re : *alt) {
     90            auto r = getUnicodeUnitLengthRange(re);
     91            range.first = std::min<int>(range.first, r.first);
     92            range.second = std::max<int>(range.second, r.second);
     93        }
     94        return range;
     95    } else if (const Seq * seq = dyn_cast<Seq>(re)) {
     96        std::pair<int, int> range = std::make_pair(0, 0);
     97        for (const RE * re : *seq) {
     98            auto tmp = getUnicodeUnitLengthRange(re);
     99            if (LLVM_LIKELY(tmp.first < std::numeric_limits<int>::max() - range.first)) {
     100                range.first += tmp.first;
     101            } else {
     102                range.first = std::numeric_limits<int>::max();
     103            }
     104            if (LLVM_LIKELY(tmp.second < std::numeric_limits<int>::max() - range.second)) {
     105                range.second += tmp.second;
     106            } else {
     107                range.second = std::numeric_limits<int>::max();
     108            }
     109        }
     110        return range;
     111    } else if (const Rep * rep = dyn_cast<Rep>(re)) {
     112        auto range = getUnicodeUnitLengthRange(rep->getRE());
     113        if (LLVM_LIKELY(rep->getLB() != Rep::UNBOUNDED_REP && range.first < std::numeric_limits<int>::max())) {
     114            range.first *= rep->getLB();
     115        } else {
     116            range.first = std::numeric_limits<int>::max();
     117        }
     118        if (LLVM_LIKELY(rep->getUB() != Rep::UNBOUNDED_REP && range.second < std::numeric_limits<int>::max())) {
     119            range.second *= rep->getUB();
     120        } else {
     121            range.second = std::numeric_limits<int>::max();
     122        }
     123        return range;
     124    } else if (isa<Assertion>(re) || isa<Start>(re) || isa<End>(re)) {
     125        return std::make_pair(0, 0);
     126    } else if (const Diff * diff = dyn_cast<Diff>(re)) {
     127        const auto r1 = getUnicodeUnitLengthRange(diff->getLH());
     128        const auto r2 = getUnicodeUnitLengthRange(diff->getRH());
     129        return std::make_pair(std::min(r1.first, r2.first), std::max(r1.second, r2.second));
     130    } else if (const Intersect * i = dyn_cast<Intersect>(re)) {
     131        const auto r1 = getUnicodeUnitLengthRange(i->getLH());
     132        const auto r2 = getUnicodeUnitLengthRange(i->getRH());
     133        return std::make_pair(std::min(r1.first, r2.first), std::max(r1.second, r2.second));
     134    } else if (const Name * n = dyn_cast<Name>(re)) {
     135        // Eventually names might be set up for not unit length items.
     136        switch (n->getType()) {
     137            case Name::Type::Byte:
     138            case Name::Type::Unicode:
     139            case Name::Type::UnicodeProperty:
     140                return std::make_pair(1, 1);
     141            case Name::Type::Unknown:
     142                return std::make_pair(0, std::numeric_limits<int>::max());
     143        }
     144    }
     145    return std::make_pair(1, 1);
    82146}
    83147   
Note: See TracChangeset for help on using the changeset viewer.