Ignore:
Timestamp:
Oct 9, 2017, 9:28:24 AM (20 months ago)
Author:
cameron
Message:

Refactoring progress: \N uses name property; delay resolution of recursive property expressions, property object regexp support

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

Legend:

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

    r5673 r5679  
    2222#include <re/re_assertion.h>
    2323#include <re/printer_re.h>
    24 #include <UCD/UnicodeNameData.h>
    2524#include <UCD/resolve_properties.h>
    2625#include <UCD/CaseFolding.h>
     
    676675            }
    677676            ++mCursor;
    678             return parseRegexPropertyValue(canonicalize(start, prop_end), std::string(val_start, current));
     677            //return parseRegexPropertyValue(canonicalize(start, prop_end), std::string(val_start, current));
     678            return createName(canonicalize(start, prop_end), std::string(val_start-1, current));
    679679        }
    680680    }
     
    682682}
    683683
    684 RE * RE_Parser::parseRegexPropertyValue(const std::string & propName, const std::string& regexValue) {
    685     RE * propValueRe = RE_Parser::parse("^" + regexValue + "$", fModeFlagSet, mReSyntax);
    686     const auto matches = grep::grepPropertyValues(propName, propValueRe);
    687     if (matches.empty()) {
    688         ParseFailure("regex " + regexValue + " match no property values");
    689     } else if (matches.size() == 1) {
    690         return createName(propName, matches.front());
    691     } else {
    692         std::vector<re::RE *> alt;
    693         for (auto value : matches) {
    694             alt.push_back(createName(propName, value));
    695         }
    696         return makeAlt(alt.begin(), alt.end());
    697     }
    698 }
    699 
    700684Name * RE_Parser::parseNamePatternExpression(){
    701685
    702     ModeFlagSet outerFlags = fModeFlagSet;
    703     fModeFlagSet = 1;
    704 
    705     bool outerNested = fNested;
    706     fNested = true;
    707 
    708     RE * nameRE = parse_RE();
    709 
    710     // Reset outer parsing state.
    711     fModeFlagSet = outerFlags;
    712     fNested = outerNested;
    713 
    714     // Embed the nameRE in ";.*$nameRE" to skip the codepoint field of Uname.txt
    715     RE * embedded = makeSeq({mMemoizer.memoize(makeCC(0x3B)), makeRep(makeAny(), 0, Rep::UNBOUNDED_REP), nameRE});
    716    
    717     CC * codepoints = grep::grepCodepoints(embedded, getUnicodeNameDataPtr(), getUnicodeNameDataSize());
    718    
    719     if (codepoints) {
    720         Name * const result = mMemoizer.memoize(codepoints);
    721         assert (*cast<CC>(result->getDefinition()) == *codepoints);
    722         return result;
    723     }
    724     return nullptr;
     686    const auto start = mCursor.pos();
     687    while (mCursor.more()) {
     688        if (*mCursor == '\\') {
     689            ++mCursor;
     690            if (!mCursor.more()) {
     691                break;
     692            }
     693        }
     694        else if (*mCursor == '}') {
     695            break;
     696        }
     697        ++mCursor;
     698    }
     699    std::string nameRegexp = "/(?i)" + std::string(start, mCursor.pos());
     700    return createName("na", nameRegexp);
    725701}
    726702
  • icGREP/icgrep-devel/icgrep/re/re_parser.h

    r5646 r5679  
    2121
    2222enum ModeFlagType : unsigned {
    23     NONE = 0,
     23    DEFAULT_MODE = 0,
    2424    CASE_INSENSITIVE_MODE_FLAG = 1,
    2525    MULTILINE_MODE_FLAG = 2,      // not currently implemented
     
    141141
    142142    virtual RE * parsePropertyExpression();
    143     RE * parseRegexPropertyValue(const std::string& propName, const std::string& regexValue);
    144143
    145144    Name * parseNamePatternExpression();
  • icGREP/icgrep-devel/icgrep/re/re_parser_bre.cpp

    r5267 r5679  
    290290            ++mCursor;
    291291        }
    292         if (*mCursor == '=') {
    293             // We have a property-name = value expression
    294             const auto prop_end = mCursor.pos();
    295             mCursor++;
    296             auto val_start = mCursor.pos();
    297             if (*val_start != '\\' || !isCharAhead('/')) {
    298                 // property-value is normal string
    299                 while (mCursor.more()) {
    300                     if (isEscapedCharAhead('}') || *mCursor == ':') {
    301                         break;
    302                     }
    303                     ++mCursor;
    304                 }
    305                 return createName(canonicalize(start, prop_end), canonicalize(val_start, mCursor.pos()));
    306             } else {
    307                 // property-value is another regex
    308                 ++mCursor;
    309                 auto previous = val_start;
    310                 auto current = (++mCursor).pos();
    311                 val_start = current;
    312 
    313                 while (true) {
    314                     if (*current == '/' && *previous == '\\') {
    315                         break;
    316                     }
    317 
    318                     if (!mCursor.more()) {
    319                         ParseFailure("Malformed property expression");
    320                     }
    321 
    322                     previous = current;
    323                     current = (++mCursor).pos();
    324                 }
    325                 ++mCursor;
    326                 return parseRegexPropertyValue(canonicalize(start, prop_end), canonicalize(val_start, previous));
    327             }
    328         }
    329292        return createName(canonicalize(start, mCursor.pos()));
    330293    }
Note: See TracChangeset for help on using the changeset viewer.