Changeset 4660 for icGREP


Ignore:
Timestamp:
Jul 12, 2015, 12:10:59 AM (4 years ago)
Author:
nmedfort
Message:

Moved 'resolveProperties' into CC_NameMap as a single call for each unique Name.

Location:
icGREP/icgrep-devel/icgrep
Files:
10 edited
2 moved

Legend:

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

    r4658 r4660  
    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 resolve_properties.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)
    6969add_library(CCADT cc/cc_namemap.cpp cc/cc_compiler.cpp utf8_encoder.cpp UCD/CaseFolding_txt.cpp)
    70 add_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)
     70add_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 UCD/resolve_properties.cpp)
    7171
    7272
  • icGREP/icgrep-devel/icgrep/UCD/resolve_properties.cpp

    r4659 r4660  
    44 *  icgrep is a trademark of International Characters.
    55 */
    6 
    7 #include <string>
     6#include "resolve_properties.h"
    87#include <re/re_re.h>
    98#include <re/re_alt.h>
     
    2423#include "UCD/PropertyValueAliases.h"
    2524#include <boost/algorithm/string/case_conv.hpp>
    26 #include "resolve_properties.h"
     25#include <string>
     26#include <iostream>
    2727
    2828using namespace UCD;
     
    4747}
    4848
    49 void resolveProperties(RE * re) {
    50     if (Alt * alt = dyn_cast<Alt>(re)) {
    51         for (auto item : *alt) {
    52             resolveProperties(item);
     49void resolveProperty(Name * name) {
     50    const std::string prop = canonicalize_value_name(name->getNamespace());
     51    const std::string value = canonicalize_value_name(name->getName());
     52    if (prop.length() != 0) {
     53        auto propit = alias_map.find(prop);
     54        if (propit == alias_map.end()) {
     55            throw UnicodePropertyExpressionError("Expected a property name, but '" + name->getNamespace() + "' found instead");
     56        }
     57        auto theprop = propit->second;
     58        if (theprop == gc) {
     59            // General Category
     60            int valcode = GetPropertyValueEnumCode(gc, value);
     61            if (valcode < 0) {
     62                throw UnicodePropertyExpressionError("Erroneous property value for general_category property");
     63            }
     64            name->setFunctionName("__get_gc_" + GC_ns::enum_names[valcode]);
     65        }
     66        else if (theprop == sc) {
     67            // Script property identified
     68            int valcode = GetPropertyValueEnumCode(sc, value);
     69            if (valcode < 0) {
     70                throw UnicodePropertyExpressionError("Erroneous property value for script property");
     71            }
     72            name->setFunctionName("__get_sc_" + SC_ns::enum_names[valcode]);
     73        }
     74        else if (theprop == scx) {
     75            // Script extension property identified
     76            int valcode = GetPropertyValueEnumCode(sc, value);
     77            if (valcode < 0) {
     78                throw UnicodePropertyExpressionError("Erroneous property value for script_extension property");
     79            }
     80            name->setFunctionName("__get_scx_" + SC_ns::enum_names[valcode]);
     81        }
     82        else if (theprop == blk) {
     83            // Block property identified
     84            int valcode = GetPropertyValueEnumCode(blk, value);
     85            if (valcode < 0) {
     86                 throw UnicodePropertyExpressionError("Erroneous property value for block property");
     87            }
     88            name->setFunctionName("__get_blk_" + BLK_ns::enum_names[valcode]);
     89        }
     90        else if (isa<BinaryPropertyObject>(property_object_table[theprop])){
     91            auto valit = Binary_ns::aliases_only_map.find(value);
     92            if (valit == Binary_ns::aliases_only_map.end()) {
     93                throw UnicodePropertyExpressionError("Erroneous property value for binary property " + property_full_name[theprop]);
     94            }
     95            if (valit->second == Binary_ns::Y) {
     96                name->setFunctionName("__get_" + lowercase(property_enum_name[theprop]) + "_Y");
     97                return;
     98            }
     99            else {
     100                Name * binprop = makeName("__get_" + lowercase(property_enum_name[theprop]) + "_Y", Name::Type::UnicodeProperty);
     101                name->setDefinition(makeDiff(makeAny(), binprop));
     102                return;
     103            }
     104        }
     105        else {
     106            throw UnicodePropertyExpressionError("Property " + property_full_name[theprop] + " recognized, but not supported in icgrep 1.0");
    53107        }
    54108    }
    55     else if (Seq * seq = dyn_cast<Seq>(re)) {
    56         for (auto item : *seq) {
    57             resolveProperties(item);
     109    else {
     110
     111        // No namespace (property) name.   Try as a general category.
     112        int valcode = GetPropertyValueEnumCode(gc, value);
     113        if (valcode >= 0) {
     114            name->setFunctionName("__get_gc_" + GC_ns::enum_names[valcode]);
     115            return;
     116        }
     117        valcode = GetPropertyValueEnumCode(sc, value);
     118        if (valcode >= 0) {
     119            name->setFunctionName("__get_sc_" + SC_ns::enum_names[valcode]);
     120            return;
     121        }
     122        // Try as a binary property.
     123        auto propit = alias_map.find(value);
     124        if (propit != alias_map.end()) {
     125            auto theprop = propit->second;
     126            if (isa<BinaryPropertyObject>(property_object_table[theprop])) {
     127                name->setFunctionName("__get_" + lowercase(property_enum_name[theprop]) + "_Y");
     128                return;
     129            }
     130            else {
     131                throw UnicodePropertyExpressionError("Error: property " + property_full_name[theprop] + " specified without a value");
     132            }
     133        }
     134        // Now try special cases of Unicode TR #18
     135        else if (value == "any") {
     136            name->setDefinition(makeAny());
     137            return;
     138        }
     139        else if (value == "assigned") {
     140            Name * Cn = makeName("Cn", Name::Type::UnicodeProperty);
     141            name->setDefinition(makeDiff(makeAny(), Cn));
     142            return;
     143        }
     144        else if (value == "ascii") {
     145            name->setFunctionName("__get_blk_ASCII");
     146            return;
     147        }
     148        // Now compatibility properties of UTR #18 Annex C
     149        else if (value == "xdigit") {
     150            Name * Nd = makeName("Nd", Name::Type::UnicodeProperty);
     151            Name * hexdigit = makeName("Hex_digit", Name::Type::UnicodeProperty);
     152            name->setDefinition(makeAlt({Nd, hexdigit}));
     153            return;
     154        }
     155        else if (value == "alnum") {
     156            Name * digit = makeName("Nd", Name::Type::UnicodeProperty);
     157            Name * alpha = makeName("alphabetic", Name::Type::UnicodeProperty);
     158            name->setDefinition(makeAlt({digit, alpha}));
     159            return;
     160        }
     161        else if (value == "blank") {
     162            Name * space_sep = makeName("space_separator", Name::Type::UnicodeProperty);
     163            CC * tab = makeCC(0x09);
     164            name->setDefinition(makeAlt({space_sep, tab}));
     165            return;
     166        }
     167        else if (value == "graph") {
     168            Name * space = makeName("space", Name::Type::UnicodeProperty);
     169            Name * ctrl = makeName("control", Name::Type::UnicodeProperty);
     170            Name * surr = makeName("surrogate", Name::Type::UnicodeProperty);
     171            Name * unassigned = makeName("Cn", Name::Type::UnicodeProperty);
     172            Name * nongraph = makeName("[^graph]", Name::Type::UnicodeProperty);
     173            nongraph->setDefinition(makeAlt({space, ctrl, surr, unassigned}));
     174            name->setDefinition(makeDiff(makeAny(), nongraph));
     175            return;
     176        }
     177        else if (value == "print") {
     178            Name * graph = makeName("graph", Name::Type::UnicodeProperty);
     179            Name * space_sep = makeName("space_separator", Name::Type::UnicodeProperty);
     180            name->setDefinition(makeAlt({graph, space_sep}));
     181            return;
     182        }
     183        else if (value == "word") {
     184            Name * alnum = makeName("alnum", Name::Type::UnicodeProperty);
     185            Name * mark = makeName("mark", Name::Type::UnicodeProperty);
     186            Name * conn = makeName("Connector_Punctuation", Name::Type::UnicodeProperty);
     187            Name * join = makeName("Join_Control", Name::Type::UnicodeProperty);
     188            name->setDefinition(makeAlt({alnum, mark, conn, join}));
     189            return;
     190        }
     191        else {
     192            throw UnicodePropertyExpressionError("Expected a general category, script or binary property name, but '" + name->getName() + "' found instead");
    58193        }
    59194    }
    60     else if (Rep * rep = dyn_cast<Rep>(re)) {
    61         resolveProperties(rep->getRE());
    62     }
    63     else if (Assertion * a = dyn_cast<Assertion>(re)) {
    64         resolveProperties(a->getAsserted());
    65     }
    66     else if (Diff * diff = dyn_cast<Diff>(re)) {
    67         resolveProperties(diff->getRH());
    68         resolveProperties(diff->getLH());
    69     }
    70     else if (Intersect * e = dyn_cast<Intersect>(re)) {
    71         resolveProperties(e->getRH());
    72         resolveProperties(e->getLH());
    73     }
    74     else if (Name * name = dyn_cast<Name>(re)) {
    75         if (name->getType() == Name::Type::UnicodeProperty) {
    76             const std::string prop = canonicalize_value_name(name->getNamespace());
    77             const std::string value = canonicalize_value_name(name->getName());
    78             if (prop.length() != 0) {
    79                 auto propit = alias_map.find(prop);
    80                 if (propit == alias_map.end()) {
    81                     throw UnicodePropertyExpressionError("Expected a property name, but '" + name->getNamespace() + "' found instead");
    82                 }
    83                 auto theprop = propit->second;
    84                 if (theprop == gc) {
    85                     // General Category
    86                     int valcode = GetPropertyValueEnumCode(gc, value);
    87                     if (valcode < 0) {
    88                         throw UnicodePropertyExpressionError("Erroneous property value for general_category property");
    89                     }                   
    90                     name->setName("__get_gc_" + GC_ns::enum_names[valcode]);
    91                 }
    92                 else if (theprop == sc) {
    93                     // Script property identified
    94                     int valcode = GetPropertyValueEnumCode(sc, value);
    95                     if (valcode < 0) {
    96                         throw UnicodePropertyExpressionError("Erroneous property value for script property");
    97                     }
    98                     name->setName("__get_sc_" + SC_ns::enum_names[valcode]);
    99                 }
    100                 else if (theprop == scx) {
    101                     // Script extension property identified
    102                     int valcode = GetPropertyValueEnumCode(sc, value);
    103                     if (valcode < 0) {
    104                         throw UnicodePropertyExpressionError("Erroneous property value for script_extension property");
    105                     }
    106                     name->setName("__get_scx_" + SC_ns::enum_names[valcode]);
    107                 }
    108                 else if (theprop == blk) {
    109                     // Block property identified
    110                     int valcode = GetPropertyValueEnumCode(blk, value);
    111                     if (valcode < 0) {
    112                          throw UnicodePropertyExpressionError("Erroneous property value for block property");
    113                     }
    114                     name->setName("__get_blk_" + BLK_ns::enum_names[valcode]);
    115                 }
    116                 else if (isa<BinaryPropertyObject>(property_object_table[theprop])){
    117                     auto valit = Binary_ns::aliases_only_map.find(value);
    118                     if (valit == Binary_ns::aliases_only_map.end()) {
    119                         throw UnicodePropertyExpressionError("Erroneous property value for binary property " + property_full_name[theprop]);
    120                     }
    121                     if (valit->second == Binary_ns::Y) {
    122                         name->setName("__get_" + lowercase(property_enum_name[theprop]) + "_Y");
    123                         return;
    124                     }
    125                     else {
    126                         Name * binprop = makeName("__get_" + lowercase(property_enum_name[theprop]) + "_Y", Name::Type::UnicodeProperty);
    127                         name->setDefinition(makeDiff(makeAny(), binprop));
    128                         return;
    129                     }
    130                 }
    131                 else {
    132                     throw UnicodePropertyExpressionError("Property " + property_full_name[theprop] + " recognized, but not supported in icgrep 1.0");
    133                 }
    134             }
    135             else {
    136                 // No namespace (property) name.   Try as a general category.
    137                 int valcode = GetPropertyValueEnumCode(gc, value);
    138                 if (valcode >= 0) {
    139                     name->setName("__get_gc_" + GC_ns::enum_names[valcode]);
    140                     return;
    141                 }
    142                 valcode = GetPropertyValueEnumCode(sc, value);
    143                 if (valcode >= 0) {
    144                     name->setName("__get_sc_" + SC_ns::enum_names[valcode]);
    145                     return;
    146                 }
    147                 // Try as a binary property.
    148                 auto propit = alias_map.find(value);
    149                 if (propit != alias_map.end()) {
    150                     auto theprop = propit->second;
    151                     if (isa<BinaryPropertyObject>(property_object_table[theprop])) {
    152                         name->setName("__get_" + lowercase(property_enum_name[theprop]) + "_Y");
    153                         return;
    154                     }
    155                     else {
    156                         throw UnicodePropertyExpressionError("Error: property " + property_full_name[theprop] + " specified without a value");
    157                     }
    158                 }
    159                 // Now try special cases of Unicode TR #18
    160                 else if (value == "any") {
    161                     name->setDefinition(makeAny());
    162                     return;
    163                 }
    164                 else if (value == "assigned") {
    165                     Name * Cn = makeName("Cn", Name::Type::UnicodeProperty);
    166                     resolveProperties(Cn);
    167                     name->setDefinition(makeDiff(makeAny(), Cn));
    168                     return;
    169                 }
    170                 else if (value == "ascii") {
    171                     name->setName("__get_blk_ASCII");
    172                     return;
    173                 }
    174                 // Now compatibility properties of UTR #18 Annex C
    175                 else if (value == "xdigit") {
    176                     Name * Nd = makeName("Nd", Name::Type::UnicodeProperty);
    177                     resolveProperties(Nd);
    178                     Name * hexdigit = makeName("Hex_digit", Name::Type::UnicodeProperty);
    179                     resolveProperties(hexdigit);
    180                     name->setDefinition(makeAlt({Nd, hexdigit}));
    181                     return;
    182                 }
    183                 else if (value == "alnum") {
    184                     Name * digit = makeName("Nd", Name::Type::UnicodeProperty);
    185                     resolveProperties(digit);
    186                     Name * alpha = makeName("alphabetic", Name::Type::UnicodeProperty);
    187                     resolveProperties(alpha);
    188                     name->setDefinition(makeAlt({digit, alpha}));
    189                     return;
    190                 }
    191                 else if (value == "blank") {
    192                     Name * space_sep = makeName("space_separator", Name::Type::UnicodeProperty);
    193                     resolveProperties(space_sep);
    194                     CC * tab = makeCC(0x09);
    195                     name->setDefinition(makeAlt({space_sep, tab}));
    196                     return;
    197                 }
    198                 else if (value == "graph") {
    199                     Name * space = makeName("space", Name::Type::UnicodeProperty);
    200                     resolveProperties(space);
    201                     Name * ctrl = makeName("control", Name::Type::UnicodeProperty);
    202                     resolveProperties(ctrl);
    203                     Name * surr = makeName("surrogate", Name::Type::UnicodeProperty);
    204                     resolveProperties(surr);
    205                     Name * unassigned = makeName("Cn", Name::Type::UnicodeProperty);
    206                     resolveProperties(unassigned);
    207                     Name * nongraph = makeName("[^graph]", Name::Type::UnicodeProperty);
    208                     nongraph->setDefinition(makeAlt({space, ctrl, surr, unassigned}));
    209                     name->setDefinition(makeDiff(makeAny(), nongraph));
    210                     return;
    211                 }
    212                 else if (value == "print") {
    213                     Name * graph = makeName("graph", Name::Type::UnicodeProperty);
    214                     resolveProperties(graph);
    215                     Name * space_sep = makeName("space_separator", Name::Type::UnicodeProperty);
    216                     resolveProperties(space_sep);
    217                     std::vector<RE *> alts = {graph, space_sep};
    218                     name->setDefinition(makeAlt(alts.begin(), alts.end()));
    219                     return;
    220                 }
    221                 else if (value == "word") {
    222                     Name * alnum = makeName("alnum", Name::Type::UnicodeProperty);
    223                     resolveProperties(alnum);
    224                     Name * mark = makeName("mark", Name::Type::UnicodeProperty);
    225                     resolveProperties(mark);
    226                     Name * conn = makeName("Connector_Punctuation", Name::Type::UnicodeProperty);
    227                     resolveProperties(conn);
    228                     Name * join = makeName("Join_Control", Name::Type::UnicodeProperty);
    229                     resolveProperties(join);
    230                     name->setDefinition(makeAlt({alnum, mark, conn, join}));
    231                     return;
    232                 }
    233                 else {
    234                     throw UnicodePropertyExpressionError("Expected a general category, script or binary property name, but '" + name->getName() + "' found instead");
    235                 }
    236             }
    237 
    238             //name->setCompiled(compileCC(cast<CC>(d), mCG));
    239         }
    240     }
    241     else if (!isa<CC>(re) && !isa<Start>(re) && !isa<End>(re) && !isa<Any>(re)) {
    242         throw UnicodePropertyExpressionError("Unknown RE type in resolveProperties.");
    243     }
    244195}
    245196
    246197UnicodeSet resolveUnicodeSet(Name * const name) {
    247 
    248198    if (name->getType() == Name::Type::UnicodeProperty) {
    249199        std::string prop = name->getNamespace();
  • icGREP/icgrep-devel/icgrep/UCD/resolve_properties.h

    r4658 r4660  
    55
    66namespace re {
    7     class RE;
    87    class Name;
    98}
    109
    11 void resolveProperties(re::RE * re);
     10void resolveProperty(re::Name * const name);
    1211UCD::UnicodeSet resolveUnicodeSet(re::Name * const name);
    1312
  • icGREP/icgrep-devel/icgrep/cc/cc_namemap.cpp

    r4516 r4660  
    88#include <re/re_intersect.h>
    99#include <re/re_assertion.h>
    10 #include <re/printer_re.h>
    11 #include <iostream>
     10#include <UCD/resolve_properties.h>
    1211
    1312using namespace re;
     
    1514namespace cc {
    1615
    17 RE * CC_NameMap::process(RE * re, const CC_type t) {
     16RE * CC_NameMap::process(RE * re, const CC_type type) {
     17
    1818    if (Alt * alt = dyn_cast<Alt>(re)) {
    1919        for (auto i = alt->begin(); i != alt->end(); ++i) {
    20             *i = process(*i, t);
     20            *i = process(*i, type);
    2121        }
    2222    }
    2323    else if (Seq * seq = dyn_cast<Seq>(re)) {
    2424        for (auto i = seq->begin(); i != seq->end(); ++i) {
    25             *i = process(*i, t);
     25            *i = process(*i, type);
    2626        }
    2727    }
    2828    else if (Rep * rep = dyn_cast<Rep>(re)) {
    29         rep->setRE(process(rep->getRE(), t));
     29        rep->setRE(process(rep->getRE(), type));
    3030    }
    3131    else if (Assertion * a = dyn_cast<Assertion>(re)) {
    32         a->setAsserted(process(a->getAsserted(), t));
     32        a->setAsserted(process(a->getAsserted(), type));
    3333    }
    3434    else if (Diff * diff = dyn_cast<Diff>(re)) {
    35         diff->setRH(process(diff->getRH(), t));
    36         diff->setLH(process(diff->getLH(), t));
     35        diff->setRH(process(diff->getRH(), type));
     36        diff->setLH(process(diff->getLH(), type));
    3737    }
    3838    else if (Intersect * e = dyn_cast<Intersect>(re)) {
    39         e->setRH(process(e->getRH(), t));
    40         e->setLH(process(e->getLH(), t));
     39        e->setRH(process(e->getRH(), type));
     40        e->setLH(process(e->getLH(), type));
    4141    }
    42     else if (Name * nameNode = dyn_cast<Name>(re)) {
    43         RE * def = nameNode->getDefinition();
    44         if (def && !isa<CC>(def)) {
    45             nameNode->setDefinition(process(def, t));
    46         }
    47         std::string classname = nameNode->getName();
     42    else if (Name * name = dyn_cast<Name>(re)) {
     43        std::string classname = name->getName();
    4844        auto f = mNameMap.find(classname);
    4945        if (f == mNameMap.end()) {
    50             // Insert into the name map.
    51             return insert(std::move(classname), nameNode);
     46            if (name->getType() == Name::Type::UnicodeProperty) {
     47                resolveProperty(name);
     48            }
     49            RE * def = name->getDefinition();
     50            if (def) {
     51                name->setDefinition(process(def, type));
     52            }
     53            return insert(std::move(classname), name);
    5254        }
    5355        return f->second;
    5456    }
    5557    else if (CC * cc = dyn_cast<CC>(re)) {
    56         std::string classname = cc->canonicalName(t);
     58        std::string classname = cc->canonicalName(type);
    5759        auto f = mNameMap.find(classname);
    5860        if (f == mNameMap.end()) {
    59             Name * n = (t == ByteClass) ? makeByteName(classname, cc) : makeName(classname, cc);
    60             return insert(std::move(classname), n);
     61            return insert(std::move(classname), (type == ByteClass) ? makeByteName(classname, cc) : makeName(classname, cc));
    6162        }
    6263        return f->second;
     
    6869    std::string retval = "";
    6970    for (Name * name : mNameVector) {
    70         retval.append("mNameMap[" +  name->getName() + "] = " + Printer_RE::PrintRE(name->getDefinition()) + "]\n");
     71        retval.append("mNameMap[" +  name->getName() + "] = " + Printer_RE::PrintRE(name->getDefinition()) + "\n");
    7172    }
    7273    return retval;
  • icGREP/icgrep-devel/icgrep/cc/cc_namemap.hpp

    r4603 r4660  
    88#include "re/re_cc.h"
    99
    10 namespace re {
    11     class CC;
    12     class RE;
    13 }
    1410
    1511namespace cc {
     
    2622    re::RE * process(re::RE * re, const re::CC_type t);
    2723
    28     inline const re::Name * operator[](const std::string & name) const {
    29         auto f = mNameMap.find(name);
    30         if (f == mNameMap.end()) {
    31             return nullptr;
    32         }
    33         return f->second;
     24    inline void clear() {
     25        mNameMap.clear();
     26        mNameVector.clear();
    3427    }
    3528
     
    4639private:
    4740
    48     inline re::Name * insert(std::string && name, re::Name * re) {
     41    inline re::Name * insert(NameMap::key_type && name, re::Name * re) {
    4942        mNameMap.insert(std::make_pair(std::move(name), re));
    5043        mNameVector.push_back(re);
  • icGREP/icgrep-devel/icgrep/compiler.cpp

    r4659 r4660  
    2828#include "UCD/precompiled_derivedcoreproperties.h"
    2929#include "UCD/precompiled_proplist.h"
    30 #include "resolve_properties.h"
    3130#include <llvm/Support/CommandLine.h>
    3231#include <pablo/function.h>
     
    107106    }
    108107
    109     if (UsePregeneratedUnicode()) {
    110         resolveProperties(re_ast);
    111     }
    112    
    113108    CC_NameMap nameMap;
    114109    re_ast = nameMap.process(re_ast, UnicodeClass);
     110
     111    // std::cerr << "-----------------------------" << std::endl;
    115112
    116113    if (PrintAllREs || PrintNamedREs) {
  • icGREP/icgrep-devel/icgrep/do_grep.h

    r4659 r4660  
    77 */
    88
    9 #include <fstream>
    10 #include <sstream>
    11 #include <iostream>
    129#include <string>
    1310#include <stdint.h>
    14 #include <array>
    1511
    1612#include "include/simd-lib/bitblock.hpp"
  • icGREP/icgrep-devel/icgrep/icgrep-devel.files

    r4658 r4660  
    332332pablo/function.h
    333333pablo/function.cpp
     334UCD/resolve_properties.cpp
     335UCD/resolve_properties.h
  • icGREP/icgrep-devel/icgrep/re/re_compiler.cpp

    r4657 r4660  
    2222#include <pablo/codegenstate.h>
    2323#include <pablo/function.h>
    24 #include <resolve_properties.h>
     24#include <UCD/resolve_properties.h>
    2525#include <assert.h>
    2626#include <stdexcept>
     
    252252MarkerType RE_Compiler::process(Name * name, MarkerType marker, PabloBuilder & pb) {
    253253    MarkerType nextPos;
    254     if (markerPos(marker) == FinalPostPositionByte) nextPos = marker;
     254    if (markerPos(marker) == FinalPostPositionByte) {
     255        nextPos = marker;
     256    }
    255257    else if (name->getType() == Name::Type::Byte) {
    256258        nextPos = AdvanceMarker(marker, InitialPostPositionByte, pb);
     
    274276    else if (name->getType() == Name::Type::UnicodeProperty) {
    275277        if (UsePregeneratedUnicode()) {
    276             var = mPB.createCall(name->getName());
     278            var = mPB.createCall(name->getFunctionName());
    277279        }
    278280        else {
     
    287289    return var;
    288290}
    289 
    290291
    291292MarkerType RE_Compiler::process(Seq * seq, MarkerType marker, PabloBuilder & pb) {
  • icGREP/icgrep-devel/icgrep/re/re_name.h

    r4516 r4660  
    3131    std::string getNamespace() const;
    3232    std::string getName() const;
    33     void setName(const std::string &);
     33    void setFunctionName(const std::string &);
     34    std::string getFunctionName() const;
     35
    3436    Type getType() const;
    3537    RE *getDefinition() const;
     
    5355    , mNameLength(nameLength)
    5456    , mName(replicateString(name, nameLength))
     57    , mFunctionNameLength(0)
     58    , mFunctionName(nullptr)
    5559    , mType(type)
    5660    , mDefiningRE(defn)
     
    6973
    7074private:
    71     length_t            mNamespaceLength;
    72     const char *        mNamespace;
    73     length_t            mNameLength;
    74     const char *        mName;
     75    const length_t      mNamespaceLength;
     76    const char * const  mNamespace;
     77    const length_t      mNameLength;
     78    const char * const  mName;
     79    length_t            mFunctionNameLength;
     80    const char *        mFunctionName;
    7581    const Type          mType;
    7682    RE *                mDefiningRE;
     
    8692}
    8793
    88 inline void Name::setName(const std::string & n) {
    89     mNameLength = n.length();
    90     mName = replicateString(n.c_str(), n.length());
     94inline std::string Name::getFunctionName() const {
     95    return std::string(mFunctionName, mFunctionNameLength);
     96}
     97
     98inline void Name::setFunctionName(const std::string & n) {
     99    mFunctionNameLength = n.length();
     100    mFunctionName = replicateString(n.c_str(), n.length());
    91101}
    92102   
     
    103113}
    104114
    105 inline Name * makeName(const std::string & name, const Name::Type type = Name::Type::Unicode) {
     115inline Name * makeName(const std::string & name, const Name::Type type) {
    106116    return new Name(nullptr, 0, name.c_str(), name.length(), type, nullptr);
    107117}
    108118
    109 inline Name * makeName(const std::string & property, const std::string & value, const Name::Type type = Name::Type::Unicode) {
     119inline Name * makeName(const std::string & property, const std::string & value, const Name::Type type) {
    110120    return new Name(property.c_str(), property.length(), value.c_str(), value.length(),  type, nullptr);
    111121}
  • icGREP/icgrep-devel/icgrep/re/re_parser.cpp

    r4622 r4660  
    502502        return makeName(std::string(start, prop_end), std::string(val_start, _cursor), Name::Type::UnicodeProperty);
    503503    }
    504     else return makeName(std::string(start, _cursor), Name::Type::UnicodeProperty);
     504    return makeName(std::string(start, _cursor), Name::Type::UnicodeProperty);
    505505}
    506506
  • icGREP/icgrep-devel/icgrep/utf8_encoder.cpp

    r4615 r4660  
    2323        if (const CC * cc = dyn_cast_or_null<CC>(name->getDefinition())) {
    2424            if (cc->size() == 1) {
    25                 name->setDefinition(rangeToUTF8(cc->front()));
     25                RE * def = rangeToUTF8(cc->front());
     26                name->setDefinition(def);
    2627            }
    2728            else if (cc->size() > 1) {
     
    3031                    alt.push_back(rangeToUTF8(i));
    3132                }
    32                 name->setDefinition(makeAlt(alt.begin(), alt.end()));
     33                RE * def = makeAlt(alt.begin(), alt.end());
     34                name->setDefinition(def);
    3335            }
    3436        }
    3537    }
    36     ast = nameMap.process(ast, ByteClass);
    37     return ast;
     38    nameMap.clear();
     39    return nameMap.process(ast, ByteClass);
    3840}
    3941
Note: See TracChangeset for help on using the changeset viewer.