Changeset 5080 for icGREP/icgrep-devel


Ignore:
Timestamp:
Jul 4, 2016, 8:54:48 PM (3 years ago)
Author:
cameron
Message:

Initial support for capture groups/back references; back reference simply repeats regexp

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

Legend:

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

    r4841 r5080  
    3535        return isByteLength(e->getLH()) && isByteLength(e->getRH());
    3636    } else if (const Name * n = dyn_cast<Name>(re)) {
    37         return (n->getType() == Name::Type::Byte);
     37        if (n->getType() == Name::Type::Byte) {
     38            return true;
     39        }
     40        else if (n->getType() == Name::Type::Capture || n->getType() == Name::Type::Reference) {
     41            return isByteLength(n->getDefinition());
     42        }
     43        return false;
    3844    }
    3945    return false; // otherwise
     
    6268    } else if (const Name * n = dyn_cast<Name>(re)) {
    6369        // Eventually names might be set up for not unit length items.
    64         return (n->getType() == Name::Type::Unicode || n->getType() == Name::Type::UnicodeProperty || n->getType() == Name::Type::Byte);
     70        if (n->getType() == Name::Type::Unicode || n->getType() == Name::Type::UnicodeProperty || n->getType() == Name::Type::Byte) {
     71            return true;
     72        }
     73        else if (n->getType() == Name::Type::Capture || n->getType() == Name::Type::Reference) {
     74            return isUnicodeUnitLength(n->getDefinition());
     75        }
     76        return false;
    6577    }
    6678    return false; // otherwise
     
    122134            case Name::Type::UnicodeProperty:
    123135                return std::make_pair(1, 1);
     136            case Name::Type::Capture:
     137            case Name::Type::Reference:
     138                return getUnicodeUnitLengthRange(n->getDefinition());
    124139            case Name::Type::Unknown:
    125140                return std::make_pair(0, std::numeric_limits<int>::max());
     
    165180        return 1;
    166181    }
    167     else if (isa<Name>(re)) {
    168         return 1;
     182    else if (const Name * n = dyn_cast<Name>(re)) {
     183    // Eventually names might be set up for not unit length items.
     184        switch (n->getType()) {
     185            case Name::Type::Byte:
     186            case Name::Type::Unicode:
     187            case Name::Type::UnicodeProperty:
     188                return 1;
     189            case Name::Type::Capture:
     190            case Name::Type::Reference:
     191                return minMatchLength(n->getDefinition());
     192            case Name::Type::Unknown:
     193                return 0;
     194        }
    169195    }
    170196    return 0; // otherwise
  • icGREP/icgrep-devel/icgrep/re/re_compiler.cpp

    r5063 r5080  
    453453
    454454inline MarkerType RE_Compiler::compileName(Name * name, MarkerType marker, PabloBuilder & pb) {
    455     MarkerType nameMarker = compileName(name, pb);
    456     MarkerType nextPos;
    457     if (markerPos(marker) == MarkerPosition::FinalPostPositionUnit) {
    458         nextPos = marker;
    459     } else if (name->getType() == Name::Type::Byte) {
    460         nextPos = AdvanceMarker(marker, MarkerPosition::InitialPostPositionUnit, pb);
    461     } else {
    462         nextPos = AdvanceMarker(marker, MarkerPosition::FinalPostPositionUnit, pb);
    463     }
    464     nameMarker.stream = pb.createAnd(markerVar(nextPos), markerVar(nameMarker), name->getName());
    465     return nameMarker;
     455    if (isUnicodeUnitLength(name)) {
     456        MarkerType nameMarker = compileName(name, pb);
     457        MarkerType nextPos;
     458        if (markerPos(marker) == MarkerPosition::FinalPostPositionUnit) {
     459            nextPos = marker;
     460        } else if (name->getType() == Name::Type::Byte) {
     461            nextPos = AdvanceMarker(marker, MarkerPosition::InitialPostPositionUnit, pb);
     462        } else {
     463            nextPos = AdvanceMarker(marker, MarkerPosition::FinalPostPositionUnit, pb);
     464        }
     465        nameMarker.stream = pb.createAnd(markerVar(nextPos), markerVar(nameMarker), name->getName());
     466        return nameMarker;
     467    }
     468    else {
     469        return process(name->getDefinition(), marker, pb);
     470    }
    466471}
    467472
  • icGREP/icgrep-devel/icgrep/re/re_name.h

    r4831 r5080  
    2525        , Unicode
    2626        , UnicodeProperty
     27        , Capture
     28        , Reference
    2729        , Unknown
    2830    };
     
    3941protected:
    4042    friend Name * makeName(const std::string & name, RE * cc);
     43    friend Name * makeCapture(const std::string & name, RE * captured);
     44    friend Name * makeReference(const std::string & name, RE * captureName);
    4145    friend Name * makeName(CC * const cc);
    4246    friend Name * makeName(const std::string &, const Type);
     
    156160}
    157161
     162inline Name * makeCapture(const std::string & name, RE * captured) {
     163    return new Name(nullptr, 0, name.c_str(), name.length(), Name::Type::Capture, captured);
     164}
     165   
     166inline Name * makeReference(const std::string & name, RE * captureName) {
     167    return new Name(nullptr, 0, name.c_str(), name.length(), Name::Type::Reference, captureName);
     168}
     169
    158170}
    159171
  • icGREP/icgrep-devel/icgrep/re/re_parser.cpp

    r5037 r5080  
    2121#include <grep_engine.h>
    2222#include <sstream>
     23#include <iostream>
     24#include <string>
    2325#include <algorithm>
    2426
     
    3739    parser.fModeFlagSet = initialFlags;
    3840    parser.fNested = false;
     41    parser.mCaptureGroupCount = 0;
    3942    RE * re = parser.parse_RE();
    4043    if (re == nullptr) {
     
    4548
    4649inline RE_Parser::RE_Parser(const std::string & regular_expression)
    47     : mCursor(regular_expression)
    48     , fModeFlagSet(0)
     50    : fModeFlagSet(0)
    4951    , fNested(false)
     52    , mCursor(regular_expression)
     53    , mCaptureGroupCount(0)
    5054    {
    5155
     
    220224                throw ParseFailure("Illegal (? syntax.");
    221225        }
    222     } else { // Capturing paren group, but ignore capture in icgrep.
    223         group_expr = parse_alt();
     226    } else { // Capturing paren group.
     227        RE * captured = parse_alt();
     228        mCaptureGroupCount++;
     229        std::string captureName = "\\" + std::to_string(mCaptureGroupCount);
     230        Name * const capture  = mMemoizer.memoize(makeCapture(captureName, captured));
     231        auto key = std::make_pair("", captureName);
     232        mNameMap.insert(std::make_pair(std::move(key), capture));
     233        group_expr = capture;
    224234    }
    225235    if (*mCursor != ')') {
     
    316326    return c >= 0x40 && c <= 0x7F && ((setEscapeCharacters >> (c - 0x40)) & 1) == 1;
    317327}
     328                                 
    318329
    319330inline RE * RE_Parser::parse_escaped() {
     331   
    320332    if (isSetEscapeChar(*mCursor)) {
    321333        return parseEscapedSet();
     334    }
     335    else if (isdigit(*mCursor)) {
     336        mCursor++;
     337        std::string backref = std::string(mCursor.pos()-2, mCursor.pos());
     338        auto key = std::make_pair("", backref);
     339        auto f = mNameMap.find(key);
     340        if (f != mNameMap.end()) {
     341            return makeReference(backref, f->second);
     342        }
     343        else {
     344            throw ParseFailure("Back reference " + backref + " without prior capture group.");
     345        }
    322346    }
    323347    else {
     
    946970    mNameMap.insert(std::make_pair(std::move(key), property));
    947971    return property;
    948 }
     972    }
    949973
    950974Name * RE_Parser::createName(std::string && prop, std::string && value) {
  • icGREP/icgrep-devel/icgrep/re/re_parser.h

    r4852 r5080  
    171171private:
    172172
    173     Cursor                      mCursor;
    174173    ModeFlagSet                 fModeFlagSet;
    175174    bool                        fNested;
     175    Cursor                      mCursor;
     176    unsigned                    mCaptureGroupCount;
    176177    NameMap                     mNameMap;
    177178    Memoizer                    mMemoizer;
Note: See TracChangeset for help on using the changeset viewer.