Changeset 4626 for icGREP/icgrep-devel


Ignore:
Timestamp:
Jun 30, 2015, 3:12:47 PM (4 years ago)
Author:
nmedfort
Message:

Temporary check-in for dynamic unicode class compilation.

Location:
icGREP/icgrep-devel/icgrep
Files:
1 added
11 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/CMakeLists.txt

    r4623 r4626  
    6666
    6767add_library(PabloADT ${PABLO_SRC})
    68 add_library(RegExpADT re/re_re.cpp re/re_cc.cpp re/re_parser.cpp re/re_rep.cpp re/parsefailure.cpp re/re_nullable.cpp re/re_simplifier.cpp re/re_compiler.cpp re/printer_re.cpp re/re_diff.cpp re/re_intersect.cpp re/re_analysis.cpp)
     68add_library(RegExpADT re/re_re.cpp re/re_cc.cpp re/re_parser.cpp re/re_rep.cpp re/parsefailure.cpp re/re_nullable.cpp re/re_simplifier.cpp re/re_compiler.cpp re/printer_re.cpp re/re_diff.cpp re/re_intersect.cpp re/re_analysis.cpp resolve_properties.cpp)
    6969add_library(CCADT cc/cc_namemap.cpp cc/cc_compiler.cpp utf8_encoder.cpp UCD/CaseFolding_txt.cpp)
    7070add_library(UCDlib UCD/unicode_set.cpp UCD/ucd_compiler.cpp UCD/PropertyObjects.cpp UCD/precompiled_gc.cpp UCD/precompiled_sc.cpp UCD/precompiled_scx.cpp UCD/precompiled_blk.cpp UCD/precompiled_derivedcoreproperties.cpp UCD/precompiled_proplist.cpp)
  • icGREP/icgrep-devel/icgrep/UCD/PropertyObjects.cpp

    r4618 r4626  
    1111namespace UCD {
    1212
    13 std::string canonicalize_value_name(const std::string prop_or_val) {
     13std::string canonicalize_value_name(const std::string & prop_or_val) {
    1414    std::locale loc;
    1515    std::stringstream s;
     
    2222}
    2323
    24 
    25 UnicodeSet UnsupportedPropertyObject::GetCodepointSet(const std::string value_spec) {
     24UnicodeSet UnsupportedPropertyObject::GetCodepointSet(const std::string &) {
    2625    throw std::runtime_error("Property " + UCD::property_full_name[the_property] + " unsupported.");
    2726}
    2827
    29 UnicodeSet EnumeratedPropertyObject::GetCodepointSet(const std::string value_spec) {
     28UnicodeSet UnsupportedPropertyObject::GetCodepointSet(const int) {
     29    throw std::runtime_error("Property " + UCD::property_full_name[the_property] + " unsupported.");
     30}
     31
     32UnicodeSet EnumeratedPropertyObject::GetCodepointSet(const std::string & value_spec) {
    3033    int property_enum_val = GetPropertyValueEnumCode(value_spec);
    3134    if (property_enum_val == -1) {
    32             throw std::runtime_error("Enumerated Property " + UCD::property_full_name[the_property] +  ": unknown value: " + value_spec);
     35        throw std::runtime_error("Enumerated Property " + UCD::property_full_name[the_property] +  ": unknown value: " + value_spec);
    3336    }
    34     else {
    35         return property_value_sets[property_enum_val];
    36     }
     37    return GetCodepointSet(property_enum_val);
    3738}
    3839
    39 int EnumeratedPropertyObject::GetPropertyValueEnumCode(const std::string s) {
     40UnicodeSet EnumeratedPropertyObject::GetCodepointSet(const int property_enum_val) const {
     41    assert (property_enum_val >= 0);
     42    return property_value_sets[property_enum_val];
     43}
     44
     45int EnumeratedPropertyObject::GetPropertyValueEnumCode(const std::string & value_spec) {
    4046    // The canonical full names are not stored in the precomputed alias map,
    4147    // to save space in the executable.   Add them if the property is used.
    4248    if (!aliases_initialized) {
    43         for (auto v = 0; v < property_value_full_names.size(); v++) {
    44             property_value_aliases.insert({canonicalize_value_name(property_value_full_names[v]), v});
     49        for (unsigned i = 0; i != property_value_full_names.size(); i++) {
     50            property_value_aliases.insert({canonicalize_value_name(property_value_full_names[i]), i});
    4551        }
    46         for (auto v = 0; v < property_value_enum_names.size(); v++) {
    47             property_value_aliases.insert({canonicalize_value_name(property_value_enum_names[v]), v});
     52        for (unsigned i = 0; i != property_value_enum_names.size(); i++) {
     53            property_value_aliases.insert({canonicalize_value_name(property_value_enum_names[i]), i});
    4854        }
    4955        aliases_initialized = true;
    5056    }
    51     auto valit = property_value_aliases.find(s);
    52     if (valit == property_value_aliases.end()) return -1;
    53     else return valit->second;
     57    const auto valit = property_value_aliases.find(value_spec);
     58    if (valit == property_value_aliases.end())
     59        return -1;
     60    return valit->second;
    5461}
    5562
    56 UnicodeSet BinaryPropertyObject::GetCodepointSet(const std::string value_spec) {
    57     int property_enum_val = Binary_ns::Y; // default value
    58     if (value_spec != "") {
     63UnicodeSet BinaryPropertyObject::GetCodepointSet(const std::string & value_spec) const {
     64    if (value_spec.length() != 0) {
    5965        auto valit = Binary_ns::aliases_only_map.find(value_spec);
    6066        if (valit == Binary_ns::aliases_only_map.end()) {
    61                     throw std::runtime_error("Binary Property " + UCD::property_full_name[the_property] +  ": bad value: " + value_spec);
     67            throw std::runtime_error("Binary Property " + UCD::property_full_name[the_property] +  ": bad value: " + value_spec);
    6268        }
    63         else property_enum_val = valit->second;
    64         if (property_enum_val == Binary_ns::Y) return the_codepoint_set;
    65         else return uset_complement(the_codepoint_set);
     69        if (valit->second == Binary_ns::Y)
     70            return the_codepoint_set;
     71        return ~the_codepoint_set;
    6672    }
    67     else return the_codepoint_set;
     73    return the_codepoint_set;
    6874}
    6975
     76UnicodeSet BinaryPropertyObject::GetCodepointSet(const int property_enum_val) const {
     77    if (property_enum_val == Binary_ns::Y)
     78        return the_codepoint_set;
     79    return ~the_codepoint_set;
     80}
    7081
    7182}
  • icGREP/icgrep-devel/icgrep/UCD/PropertyObjects.h

    r4618 r4626  
    1717namespace UCD {
    1818
    19     std::string canonicalize_value_name(const std::string prop_or_val);
     19    std::string canonicalize_value_name(const std::string & prop_or_val);
    2020
    2121        class PropertyObject {
     
    3131                property_t the_property;
    3232                ClassTypeId the_kind;
    33                
    34         virtual UnicodeSet GetCodepointSet(const std::string value_spec) = 0;
    3533        };
    3634       
     
    4543       
    4644                UnsupportedPropertyObject(property_t p, ClassTypeId k) : PropertyObject(p, k) {}
    47         UnicodeSet GetCodepointSet(const std::string value_spec);
     45        UnicodeSet GetCodepointSet(const std::string &);
     46        UnicodeSet GetCodepointSet(const int);
    4847        };
    4948       
     
    6362                                         const std::vector<UnicodeSet> sets) :
    6463                PropertyObject(p, ClassTypeId::EnumeratedProperty), property_value_enum_names(enum_names), property_value_full_names(names), property_value_aliases(aliases), aliases_initialized(false), property_value_sets(sets) {}
    65         int GetPropertyValueEnumCode(const std::string s);
    66         UnicodeSet GetCodepointSet(const std::string value_spec);
     64        int GetPropertyValueEnumCode(const std::string & value_spec);
     65        UnicodeSet GetCodepointSet(const std::string & value_spec);
     66        UnicodeSet GetCodepointSet(const int property_enum_val) const;
    6767               
    6868        private:
     
    8484               
    8585                BinaryPropertyObject(UCD::property_t p, UnicodeSet s) : PropertyObject(p, ClassTypeId::BinaryProperty), the_codepoint_set(s) {}
    86         UnicodeSet GetCodepointSet(const std::string value_spec);
     86        UnicodeSet GetCodepointSet(const std::string & value_spec) const;
     87        UnicodeSet GetCodepointSet(const int property_enum_val) const;
    8788    private:
    8889                UnicodeSet the_codepoint_set;       
  • icGREP/icgrep-devel/icgrep/UCD/ucd_compiler.cpp

    r4625 r4626  
    33#include <UCD/unicode_set.h>
    44#include <utf8_encoder.h>
     5#include <iostream>
    56
    67using namespace cc;
  • icGREP/icgrep-devel/icgrep/UCD/unicode_set.cpp

    r4622 r4626  
    385385    assert (n == 1);   
    386386
     387    if (LLVM_UNLIKELY(mBaseCodePoint >= CC::UNICODE_MAX)) {
     388        mRunIterator = mRunEnd;
     389        mQuadIterator = mQuadEnd;
     390        mMixedRunIndex = 0;
     391        mQuadOffset = 0;
     392        return;
     393    }
     394
    387395    // Find the start of our interval
    388396    for ( ; mBaseCodePoint < CC::UNICODE_MAX; ++mRunIterator) {
     
    399407            }
    400408        }
    401         else { // if (leftypeOf(t) == Mixed)
     409        else { // if (typeOf(t) == Mixed)
    402410            bool found = false;
    403411            while (mMixedRunIndex != lengthOf(*mRunIterator)) {
     
    439447            continue;
    440448        }
    441         else { // if (leftypeOf(t) == Mixed)
     449        else { // if (typeOf(t) == Mixed)
    442450            bool found = false;
    443451            while (mMixedRunIndex != lengthOf(*mRunIterator)) {
     
    463471    }
    464472
    465 
    466473}
    467474
  • icGREP/icgrep-devel/icgrep/UCD/unicode_set.h

    r4622 r4626  
    5555        friend class boost::iterator_core_access;
    5656    protected:
    57         iterator(RunVector::const_iterator runIterator, QuadVector::const_iterator quadIterator)
     57        iterator(RunVector::const_iterator runIterator, QuadVector::const_iterator quadIterator,
     58                 RunVector::const_iterator runEnd, QuadVector::const_iterator quadEnd)
    5859        : mRunIterator(runIterator), mQuadIterator(quadIterator)
    5960        , mMixedRunIndex(0), mQuadOffset(0), mBaseCodePoint(0), mMinCodePoint(0), mMaxCodePoint(0)
     61        , mRunEnd(runEnd), mQuadEnd(quadEnd)
    6062        {
    6163
     
    7779        }
    7880    private:
    79         RunVector::const_iterator   mRunIterator;
    80         QuadVector::const_iterator  mQuadIterator;
    81         unsigned                    mMixedRunIndex;
    82         bitquad_t                   mQuadOffset;       
    83         codepoint_t                 mBaseCodePoint;
    84         codepoint_t                 mMinCodePoint;
    85         codepoint_t                 mMaxCodePoint;
     81        RunVector::const_iterator           mRunIterator;
     82        QuadVector::const_iterator          mQuadIterator;
     83        unsigned                            mMixedRunIndex;
     84        bitquad_t                           mQuadOffset;
     85        codepoint_t                         mBaseCodePoint;
     86        codepoint_t                         mMinCodePoint;
     87        codepoint_t                         mMaxCodePoint;
     88        const RunVector::const_iterator     mRunEnd;
     89        const QuadVector::const_iterator    mQuadEnd;
    8690    };
    8791
    8892    inline iterator begin() const {
    8993        // note: pre-increment is intentional to move the iterator onto the first non-Empty interval.
    90         return ++iterator(mRuns.cbegin(), mQuads.cbegin());
     94        return ++iterator(mRuns.cbegin(), mQuads.cbegin(), mRuns.cend(), mQuads.cend());
    9195    }
    9296
    9397    inline iterator end() const {
    94         return iterator(mRuns.cend(), mQuads.cend());
     98        return iterator(mRuns.cend(), mQuads.cend(), mRuns.cend(), mQuads.cend());
    9599    }
    96100
     
    113117
    114118        inline run_t run() const {
    115             const auto & t = *mRunIterator;
    116             return std::make_pair(std::get<0>(t), std::get<1>(t) - mOffset);
     119            return std::make_pair(std::get<0>(*mRunIterator), std::get<1>(*mRunIterator) - mOffset);
    117120        }
    118121
  • icGREP/icgrep-devel/icgrep/compiler.cpp

    r4622 r4626  
    2828#include "UCD/precompiled_derivedcoreproperties.h"
    2929#include "UCD/precompiled_proplist.h"
    30 
    31 #include "resolve_properties.cpp"
    32 
    33 #include "llvm/Support/CommandLine.h"
     30#include "resolve_properties.h"
     31#include <llvm/Support/CommandLine.h>
    3432#include <re/printer_re.h>
    3533#include <pablo/printer_pablos.h>
    36 
    37 
    38 cl::OptionCategory cRegexOutputOptions("Regex Dump Options",
     34#include <iostream>
     35
     36static cl::OptionCategory cRegexOutputOptions("Regex Dump Options",
    3937                                      "These options control printing of intermediate regular expression structures.");
    4038
    41 cl::OptionCategory dPabloDumpOptions("Pablo Dump Options",
     39static cl::OptionCategory dPabloDumpOptions("Pablo Dump Options",
    4240                                      "These options control printing of intermediate Pablo code.");
    4341
     
    5351
    5452
    55 cl::OptionCategory cPabloOptimizationsOptions("Pablo Optimizations",
     53static cl::OptionCategory cPabloOptimizationsOptions("Pablo Optimizations",
    5654                                              "These options control Pablo optimization passes.");
    5755
     
    107105        std::cerr << "RemoveNullableSuffix:" << std::endl << Printer_RE::PrintRE(re_ast) << std::endl;
    108106    }
    109    
    110     resolveProperties(re_ast);
    111    
     107
     108    if (IsPregeneratedUnicodeEnabled()) {
     109        resolveProperties(re_ast);
     110    }
    112111   
    113112    CC_NameMap nameMap;
     
    183182
    184183    PabloCompiler pablo_compiler(basisBits);
    185    
    186     install_property_gc_fn_ptrs(pablo_compiler);
    187     install_property_sc_fn_ptrs(pablo_compiler);
    188     install_property_scx_fn_ptrs(pablo_compiler);
    189     install_property_blk_fn_ptrs(pablo_compiler);
    190     install_property_DerivedCoreProperties_fn_ptrs(pablo_compiler);
    191     install_property_PropList_fn_ptrs(pablo_compiler);
    192 
     184    if (IsPregeneratedUnicodeEnabled()) {
     185        install_property_gc_fn_ptrs(pablo_compiler);
     186        install_property_sc_fn_ptrs(pablo_compiler);
     187        install_property_scx_fn_ptrs(pablo_compiler);
     188        install_property_blk_fn_ptrs(pablo_compiler);
     189        install_property_DerivedCoreProperties_fn_ptrs(pablo_compiler);
     190        install_property_PropList_fn_ptrs(pablo_compiler);
     191    }
    193192    try {
    194193        CompiledPabloFunction retVal = pablo_compiler.compile(main);
  • icGREP/icgrep-devel/icgrep/icgrep.cpp

    r4572 r4626  
    3838static cl::list<std::string> regexVector("e", cl::desc("Regular expression"), cl::ZeroOrMore, cl::cat(aRegexSourceOptions));
    3939static cl::opt<std::string> RegexFilename("f", cl::desc("Take regular expressions (one per line) from a file"), cl::value_desc("regex file"), cl::init(""), cl::cat(aRegexSourceOptions));
    40 
    41 
    4240
    4341
  • icGREP/icgrep-devel/icgrep/re/re_compiler.cpp

    r4625 r4626  
    2121#include <cc/cc_namemap.hpp>
    2222#include <pablo/codegenstate.h>
    23 #include <UCD/DerivedGeneralCategory.h>
     23#include <resolve_properties.h>
    2424#include <assert.h>
    2525#include <stdexcept>
     
    2929                                      "These options control the compilation of regular expressions to Pablo.");
    3030
    31 static cl::opt<bool> DisableLog2BoundedRepetition("disable-log2-bounded-repetition", cl::init(false), 
     31static cl::opt<bool> DisableLog2BoundedRepetition("disable-log2-bounded-repetition", cl::init(false),
    3232                     cl::desc("disable log2 optimizations for bounded repetition of bytes"), cl::cat(fREcompilationOptions));
    3333static cl::opt<int> IfInsertionGap("if-insertion-gap", cl::init(3), cl::desc("minimum number of nonempty elements between inserted if short-circuit tests"), cl::cat(fREcompilationOptions));
    34 static cl::opt<bool> DisableMatchStar("disable-matchstar", cl::init(false), 
     34static cl::opt<bool> DisableMatchStar("disable-matchstar", cl::init(false),
    3535                     cl::desc("disable MatchStar optimization"), cl::cat(fREcompilationOptions));
    3636static cl::opt<bool> DisableUnicodeMatchStar("disable-unicode-matchstar", cl::init(false),
     
    4141                     cl::desc("disable use of pregenerated Unicode character class sets"), cl::cat(fREcompilationOptions));
    4242
    43 
    4443using namespace pablo;
    4544
    4645namespace re {
    4746
     47bool IsPregeneratedUnicodeEnabled() {
     48    return !DisablePregeneratedUnicode;
     49}
    4850
    4951RE_Compiler::RE_Compiler(cc::CC_Compiler & ccCompiler)
     
    269271    }
    270272    else if (name->getType() == Name::Type::UnicodeProperty) {
    271         if (DisablePregeneratedUnicode) {
    272             // Note: using a fixed set while testing whether the UCD compiler works.
    273             var = mUCDCompiler.generateWithDefaultIfHierarchy(UCD::GC_ns::ll_Set, pb);
     273        if (IsPregeneratedUnicodeEnabled()) {
     274            var = mPB.createCall(name->getName());
    274275        }
    275276        else {
    276             var = mPB.createCall(name->getName());
     277            var = mUCDCompiler.generateWithDefaultIfHierarchy(resolveUnicodeSet(name), pb);
    277278        }
    278279    }
  • icGREP/icgrep-devel/icgrep/re/re_compiler.h

    r4623 r4626  
    3434
    3535namespace re {
     36
     37bool IsPregeneratedUnicodeEnabled();
    3638
    3739enum MarkerPosition {FinalMatchByte, InitialPostPositionByte, FinalPostPositionByte};
  • icGREP/icgrep-devel/icgrep/resolve_properties.cpp

    r4618 r4626  
    88#include <re/re_re.h>
    99#include <re/re_alt.h>
     10#include <re/re_any.h>
    1011#include <re/re_cc.h>
    1112#include <re/re_seq.h>
     
    2223#include "UCD/PropertyObjectTable.h"
    2324#include "UCD/PropertyValueAliases.h"
     25#include <boost/algorithm/string/case_conv.hpp>
     26#include "resolve_properties.h"
    2427
    2528using namespace UCD;
     29using namespace re;
    2630
    2731class UnicodePropertyExpressionError : public std::exception {
     
    3438};
    3539
    36 std::string canonicalize(std::string prop_or_val) {
     40inline std::string lowercase(const std::string & name) {
    3741    std::locale loc;
    38     std::string s = "";
    39     for (unsigned int i = 0; i < prop_or_val.length(); ++i) {
    40         char c = prop_or_val.at(i);
    41         if ((c != '_') && (c != ' ') && (c != '-')) {
    42             s += std::tolower(c, loc);
    43         }
    44     }
    45     return s;
     42    return boost::algorithm::to_lower_copy(name, loc);
    4643}
    47 
    48 std::string lowercase(std::string prop_or_val) {
    49     std::locale loc;
    50     std::string s = "";
    51     for (unsigned int i = 0; i < prop_or_val.length(); ++i) {
    52         char c = prop_or_val.at(i);
    53         s += std::tolower(c, loc);
    54     }
    55     return s;
    56 }
    57 
    58 using namespace re;
    5944
    6045void resolveProperties(RE * re) {
    6146    if (Alt * alt = dyn_cast<Alt>(re)) {
    62         for (auto i = alt->begin(); i != alt->end(); ++i) {
    63             resolveProperties(*i);
     47        for (auto item : *alt) {
     48            resolveProperties(item);
    6449        }
    6550    }
    6651    else if (Seq * seq = dyn_cast<Seq>(re)) {
    67         for (auto i = seq->begin(); i != seq->end(); ++i) {
    68             resolveProperties(*i);
     52        for (auto item : *seq) {
     53            resolveProperties(item);
    6954        }
    7055    }
     
    8570    else if (Name * name = dyn_cast<Name>(re)) {
    8671        if (name->getType() == Name::Type::UnicodeProperty) {
    87             std::string prop = name->getNamespace();
    88             std::string v = canonicalize_value_name(name->getName());
    89             UCD::property_t theprop;
    90             if (prop != "") {
    91                 prop = canonicalize_value_name(prop);
    92                 auto propit = UCD::alias_map.find(prop);
    93                 if (propit == UCD::alias_map.end()) {
     72            const std::string prop = canonicalize_value_name(name->getNamespace());
     73            const std::string value = canonicalize_value_name(name->getName());
     74            property_t theprop;
     75            if (prop.length() != 0) {
     76                auto propit = alias_map.find(prop);
     77                if (propit == alias_map.end()) {
    9478                    throw UnicodePropertyExpressionError("Expected a property name, but '" + name->getNamespace() + "' found instead");
    9579                }
    9680                theprop = propit->second;
    97                 if (theprop == UCD::gc) {
     81                if (theprop == gc) {
    9882                    // General Category
    99                     int valcode = dyn_cast<UCD::EnumeratedPropertyObject> (UCD::property_object_table[UCD::gc])->GetPropertyValueEnumCode(v);                   
     83                    int valcode = dyn_cast<EnumeratedPropertyObject> (property_object_table[gc])->GetPropertyValueEnumCode(value);
     84                    if (valcode < 0) {
     85                        throw UnicodePropertyExpressionError("Erroneous property value for general_category property");
     86                    }                   
     87                    name->setName("__get_gc_" + GC_ns::enum_names[valcode]);
     88                }
     89                else if (theprop == sc) {
     90                    // Script property identified
     91                    int valcode = dyn_cast<EnumeratedPropertyObject> (property_object_table[sc])->GetPropertyValueEnumCode(value);
     92                    if (valcode < 0) {
     93                        throw UnicodePropertyExpressionError("Erroneous property value for script property");
     94                    }
     95                    name->setName("__get_sc_" + SC_ns::enum_names[valcode]);
     96                }
     97                else if (theprop == scx) {
     98                    // Script extension property identified
     99                    int valcode = dyn_cast<EnumeratedPropertyObject> (property_object_table[sc])->GetPropertyValueEnumCode(value);
    100100                    if (valcode >= 0) {
    101                         name->setName("__get_gc_" + UCD::GC_ns::enum_names[valcode]);
    102                     }
    103                     else throw UnicodePropertyExpressionError("Erroneous property value for general_category property");
    104                 }
    105                 else if (theprop == UCD::sc) {
    106                     // Script property identified
    107                     int valcode = dyn_cast<UCD::EnumeratedPropertyObject> (UCD::property_object_table[UCD::sc])->GetPropertyValueEnumCode(v);                   
     101                        throw UnicodePropertyExpressionError("Erroneous property value for script_extension property");
     102                    }
     103                    name->setName("__get_scx_" + SC_ns::enum_names[valcode]);
     104                }
     105                else if (theprop == blk) {
     106                    // Block property identified
     107                    int valcode = dyn_cast<EnumeratedPropertyObject> (property_object_table[blk])->GetPropertyValueEnumCode(value);
    108108                    if (valcode >= 0) {
    109                         name->setName("__get_sc_" + UCD::SC_ns::enum_names[valcode]);
    110                     }
    111                     else throw UnicodePropertyExpressionError("Erroneous property value for script property");
    112                 }
    113                 else if (theprop == UCD::scx) {
    114                     // Script extension property identified
    115                     int valcode = dyn_cast<UCD::EnumeratedPropertyObject> (UCD::property_object_table[UCD::sc])->GetPropertyValueEnumCode(v);                   
    116                     if (valcode >= 0) {
    117                         name->setName("__get_scx_" + UCD::SC_ns::enum_names[valcode]);
    118                     }
    119                     else throw UnicodePropertyExpressionError("Erroneous property value for script_extension property");
    120                 }
    121                 else if (theprop == UCD::blk) {
    122                     // Block property identified
    123                     int valcode = dyn_cast<UCD::EnumeratedPropertyObject> (UCD::property_object_table[UCD::blk])->GetPropertyValueEnumCode(v);                   
    124                     if (valcode >= 0) {
    125                         name->setName("__get_blk_" + UCD::BLK_ns::enum_names[valcode]);
    126                     }
    127                     else throw UnicodePropertyExpressionError("Erroneous property value for block property");
    128                 }
    129                 else if (UCD::property_object_table[theprop]->the_kind == UCD::PropertyObject::ClassTypeId::BinaryProperty){
    130                     auto valit = UCD::Binary_ns::aliases_only_map.find(v);
    131                     if (valit == UCD::Binary_ns::aliases_only_map.end()) {
    132                         throw UnicodePropertyExpressionError("Erroneous property value for binary property " + UCD::property_full_name[theprop]);
    133                     }
    134                     if (valit->second == UCD::Binary_ns::Y) {
    135                         name->setName("__get_" + lowercase(UCD::property_enum_name[theprop]) + "_Y");
     109                         throw UnicodePropertyExpressionError("Erroneous property value for block property");
     110                    }
     111                    name->setName("__get_blk_" + BLK_ns::enum_names[valcode]);
     112                }
     113                else if (property_object_table[theprop]->the_kind == PropertyObject::ClassTypeId::BinaryProperty){
     114                    auto valit = Binary_ns::aliases_only_map.find(value);
     115                    if (valit == Binary_ns::aliases_only_map.end()) {
     116                        throw UnicodePropertyExpressionError("Erroneous property value for binary property " + property_full_name[theprop]);
     117                    }
     118                    if (valit->second == Binary_ns::Y) {
     119                        name->setName("__get_" + lowercase(property_enum_name[theprop]) + "_Y");
    136120                        return;
    137121                    }
    138122                    else {
    139                         re::Name * binprop = re::makeName("__get_" + lowercase(UCD::property_enum_name[theprop]) + "_Y", Name::Type::UnicodeProperty);
    140                         name->setDefinition(re::makeDiff(re::makeAny(), binprop));
     123                        Name * binprop = makeName("__get_" + lowercase(property_enum_name[theprop]) + "_Y", Name::Type::UnicodeProperty);
     124                        name->setDefinition(makeDiff(makeAny(), binprop));
    141125                        return;
    142126                    }
    143127                }
    144128                else {
    145                     throw UnicodePropertyExpressionError("Property " + UCD::property_full_name[theprop] + " recognized, but not supported in icgrep 1.0");
     129                    throw UnicodePropertyExpressionError("Property " + property_full_name[theprop] + " recognized, but not supported in icgrep 1.0");
    146130                }
    147131            }
    148132            else {
    149133                // No namespace (property) name.   Try as a general category.
    150                 int valcode = dyn_cast<UCD::EnumeratedPropertyObject> (UCD::property_object_table[UCD::gc])->GetPropertyValueEnumCode(v);
     134                int valcode = dyn_cast<EnumeratedPropertyObject> (property_object_table[gc])->GetPropertyValueEnumCode(value);
    151135                if (valcode >= 0) {
    152                     theprop = UCD::gc;
    153                     name->setName("__get_gc_" + UCD::GC_ns::enum_names[valcode]);
    154                     return;
    155                 }
    156                 valcode = dyn_cast<UCD::EnumeratedPropertyObject> (UCD::property_object_table[UCD::sc])->GetPropertyValueEnumCode(v);
     136                    theprop = gc;
     137                    name->setName("__get_gc_" + GC_ns::enum_names[valcode]);
     138                    return;
     139                }
     140                valcode = dyn_cast<EnumeratedPropertyObject> (property_object_table[sc])->GetPropertyValueEnumCode(value);
    157141                if (valcode >= 0) {
    158                     theprop = UCD::sc;
    159                     name->setName("__get_sc_" + UCD::SC_ns::enum_names[valcode]);
     142                    theprop = sc;
     143                    name->setName("__get_sc_" + SC_ns::enum_names[valcode]);
    160144                    return;
    161145                }
    162146                // Try as a binary property.
    163                 auto propit = UCD::alias_map.find(v);
    164                 if (propit != UCD::alias_map.end()) {
     147                auto propit = alias_map.find(value);
     148                if (propit != alias_map.end()) {
    165149                    theprop = propit->second;
    166                     if (UCD::property_object_table[theprop]->the_kind == UCD::PropertyObject::ClassTypeId::BinaryProperty) {
    167                         name->setName("__get_" + lowercase(UCD::property_enum_name[theprop]) + "_Y");
     150                    if (property_object_table[theprop]->the_kind == PropertyObject::ClassTypeId::BinaryProperty) {
     151                        name->setName("__get_" + lowercase(property_enum_name[theprop]) + "_Y");
    168152                        return;
    169153                    }
    170154                    else {
    171                         throw UnicodePropertyExpressionError("Error: property " + UCD::property_full_name[theprop] + " specified without a value");
     155                        throw UnicodePropertyExpressionError("Error: property " + property_full_name[theprop] + " specified without a value");
    172156                    }
    173157                }
    174158                // Now try special cases of Unicode TR #18
    175                 else if (v == "any") {
    176                     name->setDefinition(re::makeAny());
    177                     return;
    178                 }
    179                 else if (v == "assigned") {
    180                     re::Name * Cn = re::makeName("Cn", Name::Type::UnicodeProperty);
     159                else if (value == "any") {
     160                    name->setDefinition(makeAny());
     161                    return;
     162                }
     163                else if (value == "assigned") {
     164                    Name * Cn = makeName("Cn", Name::Type::UnicodeProperty);
    181165                    resolveProperties(Cn);
    182                     name->setDefinition(re::makeDiff(re::makeAny(), Cn));
    183                     return;
    184                 }
    185                 else if (v == "ascii") {
     166                    name->setDefinition(makeDiff(makeAny(), Cn));
     167                    return;
     168                }
     169                else if (value == "ascii") {
    186170                    name->setName("__get_blk_ASCII");
    187171                    return;
    188172                }
    189173                // Now compatibility properties of UTR #18 Annex C
    190                 else if (v == "xdigit") {
    191                     re::Name * Nd = re::makeName("Nd", Name::Type::UnicodeProperty);
     174                else if (value == "xdigit") {
     175                    Name * Nd = makeName("Nd", Name::Type::UnicodeProperty);
    192176                    resolveProperties(Nd);
    193                     re::Name * hexdigit = re::makeName("Hex_digit", Name::Type::UnicodeProperty);
     177                    Name * hexdigit = makeName("Hex_digit", Name::Type::UnicodeProperty);
    194178                    resolveProperties(hexdigit);
    195                     std::vector<RE *> alts = {Nd, hexdigit};
    196                     name->setDefinition(re::makeAlt(alts.begin(), alts.end()));
    197                     return;
    198                 }
    199                 else if (v == "alnum") {
    200                     re::Name * digit = re::makeName("Nd", Name::Type::UnicodeProperty);
     179                    name->setDefinition(makeAlt({Nd, hexdigit}));
     180                    return;
     181                }
     182                else if (value == "alnum") {
     183                    Name * digit = makeName("Nd", Name::Type::UnicodeProperty);
    201184                    resolveProperties(digit);
    202                     re::Name * alpha = re::makeName("alphabetic", Name::Type::UnicodeProperty);
     185                    Name * alpha = makeName("alphabetic", Name::Type::UnicodeProperty);
    203186                    resolveProperties(alpha);
    204                     std::vector<RE *> alts = {digit, alpha};
    205                     name->setDefinition(re::makeAlt(alts.begin(), alts.end()));
    206                     return;
    207                 }
    208                 else if (v == "blank") {
    209                     re::Name * space_sep = re::makeName("space_separator", Name::Type::UnicodeProperty);
     187                    name->setDefinition(makeAlt({digit, alpha}));
     188                    return;
     189                }
     190                else if (value == "blank") {
     191                    Name * space_sep = makeName("space_separator", Name::Type::UnicodeProperty);
    210192                    resolveProperties(space_sep);
    211                     re::CC * tab = re::makeCC(0x09);
    212                     std::vector<RE *> alts = {space_sep, tab};
    213                     name->setDefinition(re::makeAlt(alts.begin(), alts.end()));
    214                     return;
    215                 }
    216                 else if (v == "graph") {
    217                     re::Name * space = re::makeName("space", Name::Type::UnicodeProperty);
     193                    CC * tab = makeCC(0x09);
     194                    name->setDefinition(makeAlt({space_sep, tab}));
     195                    return;
     196                }
     197                else if (value == "graph") {
     198                    Name * space = makeName("space", Name::Type::UnicodeProperty);
    218199                    resolveProperties(space);
    219                     re::Name * ctrl = re::makeName("control", Name::Type::UnicodeProperty);
     200                    Name * ctrl = makeName("control", Name::Type::UnicodeProperty);
    220201                    resolveProperties(ctrl);
    221                     re::Name * surr = re::makeName("surrogate", Name::Type::UnicodeProperty);
     202                    Name * surr = makeName("surrogate", Name::Type::UnicodeProperty);
    222203                    resolveProperties(surr);
    223                     re::Name * unassigned = re::makeName("Cn", Name::Type::UnicodeProperty);
     204                    Name * unassigned = makeName("Cn", Name::Type::UnicodeProperty);
    224205                    resolveProperties(unassigned);
    225                     std::vector<RE *> alts = {space, ctrl, surr, unassigned};
    226                     re::Name * nongraph = re::makeName("[^graph]", Name::Type::UnicodeProperty);
    227                     nongraph->setDefinition(re::makeAlt(alts.begin(), alts.end()));
    228                     name->setDefinition(re::makeDiff(re::makeAny(), nongraph));
    229                     return;
    230                 }
    231                 else if (v == "print") {
    232                     re::Name * graph = re::makeName("graph", Name::Type::UnicodeProperty);
     206                    Name * nongraph = makeName("[^graph]", Name::Type::UnicodeProperty);
     207                    nongraph->setDefinition(makeAlt({space, ctrl, surr, unassigned}));
     208                    name->setDefinition(makeDiff(makeAny(), nongraph));
     209                    return;
     210                }
     211                else if (value == "print") {
     212                    Name * graph = makeName("graph", Name::Type::UnicodeProperty);
    233213                    resolveProperties(graph);
    234                     re::Name * space_sep = re::makeName("space_separator", Name::Type::UnicodeProperty);
     214                    Name * space_sep = makeName("space_separator", Name::Type::UnicodeProperty);
    235215                    resolveProperties(space_sep);
    236216                    std::vector<RE *> alts = {graph, space_sep};
    237                     name->setDefinition(re::makeAlt(alts.begin(), alts.end()));
    238                     return;
    239                 }
    240                 else if (v == "word") {
    241                     re::Name * alnum = re::makeName("alnum", Name::Type::UnicodeProperty);
     217                    name->setDefinition(makeAlt(alts.begin(), alts.end()));
     218                    return;
     219                }
     220                else if (value == "word") {
     221                    Name * alnum = makeName("alnum", Name::Type::UnicodeProperty);
    242222                    resolveProperties(alnum);
    243                     re::Name * mark = re::makeName("mark", Name::Type::UnicodeProperty);
     223                    Name * mark = makeName("mark", Name::Type::UnicodeProperty);
    244224                    resolveProperties(mark);
    245                     re::Name * conn = re::makeName("Connector_Punctuation", Name::Type::UnicodeProperty);
     225                    Name * conn = makeName("Connector_Punctuation", Name::Type::UnicodeProperty);
    246226                    resolveProperties(conn);
    247                     re::Name * join = re::makeName("Join_Control", Name::Type::UnicodeProperty);
     227                    Name * join = makeName("Join_Control", Name::Type::UnicodeProperty);
    248228                    resolveProperties(join);
    249                     std::vector<RE *> alts = {alnum,mark,conn,join};
    250                     name->setDefinition(re::makeAlt(alts.begin(), alts.end()));
     229                    name->setDefinition(makeAlt({alnum, mark, conn, join}));
    251230                    return;
    252231                }
     
    255234                }
    256235            }
    257            
    258                 //name->setCompiled(compileCC(cast<CC>(d), mCG));
     236
     237            //name->setCompiled(compileCC(cast<CC>(d), mCG));
    259238        }
    260239    }
     
    264243}
    265244
     245UnicodeSet resolveUnicodeSet(Name * const name) {
     246
     247    if (name->getType() == Name::Type::UnicodeProperty) {
     248        std::string prop = name->getNamespace();
     249        std::string value = canonicalize_value_name(name->getName());
     250        property_t theprop;
     251        if (prop.length() > 0) {
     252            prop = canonicalize_value_name(prop);
     253            auto propit = alias_map.find(prop);
     254            if (propit == alias_map.end()) {
     255                throw UnicodePropertyExpressionError("Expected a property name, but '" + name->getNamespace() + "' found instead");
     256            }
     257            theprop = propit->second;
     258            if (theprop == gc) {
     259                // General Category
     260                return cast<EnumeratedPropertyObject>(property_object_table[gc])->GetCodepointSet(value);
     261            }
     262            else if (theprop == sc) {
     263                // Script property identified
     264                return cast<EnumeratedPropertyObject>(property_object_table[sc])->GetCodepointSet(value);
     265            }
     266            else if (theprop == scx) {
     267                // Script extension property identified
     268                return cast<EnumeratedPropertyObject>(property_object_table[sc])->GetCodepointSet(value);
     269            }
     270            else if (theprop == blk) {
     271                // Block property identified
     272                return cast<EnumeratedPropertyObject>(property_object_table[blk])->GetCodepointSet(value);
     273            }
     274            else if (property_object_table[theprop]->the_kind == PropertyObject::ClassTypeId::BinaryProperty){
     275                auto valit = Binary_ns::aliases_only_map.find(value);
     276                if (valit == Binary_ns::aliases_only_map.end()) {
     277                    throw UnicodePropertyExpressionError("Erroneous property value for binary property " + property_full_name[theprop]);
     278                }
     279                return cast<BinaryPropertyObject>(property_object_table[theprop])->GetCodepointSet(value);
     280            }
     281            throw UnicodePropertyExpressionError("Property " + property_full_name[theprop] + " recognized but not supported in icgrep 1.0");
     282        }
     283        else {
     284            // No namespace (property) name.   Try as a general category.
     285            int valcode = cast<EnumeratedPropertyObject>(property_object_table[gc])->GetPropertyValueEnumCode(value);
     286            if (valcode >= 0) {
     287                return cast<EnumeratedPropertyObject>(property_object_table[gc])->GetCodepointSet(valcode);
     288            }
     289            valcode = cast<EnumeratedPropertyObject> (property_object_table[sc])->GetPropertyValueEnumCode(value);
     290            if (valcode >= 0) {
     291                return cast<EnumeratedPropertyObject>(property_object_table[sc])->GetCodepointSet(valcode);
     292            }
     293            // Try as a binary property.
     294            auto propit = alias_map.find(value);
     295            if (propit != alias_map.end()) {
     296                theprop = propit->second;
     297                if (property_object_table[theprop]->the_kind == PropertyObject::ClassTypeId::BinaryProperty) {
     298                    return cast<BinaryPropertyObject>(property_object_table[theprop])->GetCodepointSet(valcode);
     299                }
     300                else {
     301                    throw UnicodePropertyExpressionError("Error: property " + property_full_name[theprop] + " specified without a value");
     302                }
     303            }
     304        }
     305    }
     306    throw UnicodePropertyExpressionError("Expected a general category, script or binary property name, but '" + name->getName() + "' found instead");
     307}
Note: See TracChangeset for help on using the changeset viewer.