Changeset 5667 for icGREP

Timestamp:

Oct 5, 2017, 7:56:16 AM (19 months ago)

Author:

cameron

Message:

Fix Mac OS compile bugs and some property object issues

Location:

icGREP/icgrep-devel/icgrep/UCD

Files:

• PropertyObjects.cpp (modified) (6 diffs)
• PropertyObjects.h (modified) (5 diffs)
• resolve_properties.cpp (modified) (3 diffs)

icGREP/icgrep-devel/icgrep/UCD/PropertyObjects.cpp

@@ -1 +1 @@
 /*
- *  Copyright (c) 2014 International Characters, Inc.
+ *  Copyright (c) 2017 International Characters, Inc.
  *  This software is licensed to the public under the Open Software License 3.0.
  *  icgrep is a trademark of International Characters, Inc.
@@ -14 +14 @@
 #include <llvm/Support/raw_ostream.h>
 #include <llvm/Support/ErrorHandling.h>
-#include <uchar.h>
-
 using namespace llvm;
 
@@ -32 +30 @@
 }
 
-int PropertyObject::GetPropertyValueEnumCode(const std::string & value_spec) {
-    llvm::report_fatal_error("Property " + value_spec + " unsupported.");
-}
 const std::string & PropertyObject::GetPropertyValueGrepString() {
     llvm::report_fatal_error("Property Value Grep String unsupported.");
 }
 
-const UnicodeSet UnsupportedPropertyObject::GetCodepointSet(const std::string &) {
-    llvm::report_fatal_error("Property " + UCD::property_full_name[the_property] + " unsupported.");
-}
-
-UnicodeSet UnsupportedPropertyObject::GetCodepointSet(const int) {
+const UnicodeSet PropertyObject::GetCodepointSet(const std::string &) {
     llvm::report_fatal_error("Property " + UCD::property_full_name[the_property] + " unsupported.");
 }
@@ -146 +137 @@
 
 int ExtensionPropertyObject::GetPropertyValueEnumCode(const std::string & value_spec) {
-    return property_object_table[base_property]->GetPropertyValueEnumCode(value_spec);
+    return cast<EnumeratedPropertyObject>(property_object_table[base_property])->GetPropertyValueEnumCode(value_spec);
 }
 
@@ -187 +178 @@
 }
     
-
-
+const unsigned firstCodepointLengthAndVal(const std::string & s, codepoint_t & cp) {
+    size_t lgth = s.length();
+    if (lgth == 0) return 0;
+    unsigned char s0 = s[0];
+    cp = static_cast<codepoint_t>(s0);
+    if (s0 < 0x80) return 1;
+    if (lgth == 1) return 0;  // invalid UTF-8
+    cp = ((cp & 0x1F) << 6) | (s[1] & 0x3F);
+    if ((s0 >= 0xC2) && (s0 <= 0xDF)) return 2;
+    if (lgth == 2) return 0;  // invalid UTF-8
+    cp = ((cp & 0x3FFF) << 6) | (s[2] & 0x3F);
+    if ((s0 >= 0xE0) && (s0 <= 0xEF)) return 3;
+    if (lgth == 3) return 0;  // invalid UTF-8
+    cp = ((cp & 0x7FFF) << 6) | (s[3] & 0x3F);
+    if ((s0 >= 0xF0) && (s0 <= 0xF4)) return 4;
+    return 0;
+}
+    
 const UnicodeSet StringPropertyObject::GetCodepointSet(const std::string & value_spec) {
     if (value_spec == "") return mNullCodepointSet;
@@ -194 +201 @@
         UnicodeSet result_set;
         unsigned val_bytes = value_spec.length();
+        codepoint_t cp;
+        if (val_bytes == firstCodepointLengthAndVal(value_spec, cp)) {
+            if (mSelfCodepointSet.contains(cp)) {
+                result_set.insert(cp);
+            }
+        }
         const char * value_str = value_spec.c_str();
-        std::mbstate_t state{};
-        char32_t c32;
-        size_t cvtcode = mbrtoc32(&c32, value_str, val_bytes, &state);
-        if (cvtcode == val_bytes) {
-            // A single Unicode character.  Check the reflexive set.
-            if (mSelfCodepointSet.contains(static_cast<codepoint_t>(c32))) {
-                result_set.insert(static_cast<codepoint_t>(c32));
-            }
-        }
         const char * search_str = mStringBuffer;
         unsigned buffer_line = 0;

icGREP/icgrep-devel/icgrep/UCD/PropertyObjects.h

@@ -42 +42 @@
     PropertyObject(property_t p, ClassTypeId k) : the_property(p), the_kind(k) {}
     virtual const UnicodeSet GetCodepointSet(const std::string &);
-    virtual int GetPropertyValueEnumCode(const std::string & value_spec);
     virtual const std::string & GetPropertyValueGrepString();
     property_t the_property;
@@ -61 +60 @@
 
     }
-    const UnicodeSet GetCodepointSet(const std::string &) override;
-    UnicodeSet GetCodepointSet(const int);
 };
 
@@ -91 +88 @@
 
     virtual int GetPropertyValueEnumCode(const std::string & value_spec);
-    virtual const std::string & GetPropertyValueGrepString();
+    const std::string & GetPropertyValueGrepString() override;
     const UnicodeSet GetCodepointSet(const std::string & value_spec) override;
     const UnicodeSet & GetCodepointSet(const int property_enum_val) const;
@@ -140 +137 @@
     iterator end() const;
 
-    virtual int GetPropertyValueEnumCode(const std::string & value_spec);
-    virtual const std::string & GetPropertyValueGrepString();
+    int GetPropertyValueEnumCode(const std::string & value_spec);
+    const std::string & GetPropertyValueGrepString() override;
     const UnicodeSet GetCodepointSet(const std::string & value_spec) override;
     const UnicodeSet & GetCodepointSet(const int property_enum_val) const;
@@ -167 +164 @@
     const UnicodeSet GetCodepointSet(const std::string & value_spec) override;
     const UnicodeSet & GetCodepointSet(const int property_enum_val);
-    virtual const std::string & GetPropertyValueGrepString();
+    const std::string & GetPropertyValueGrepString() override;
 private:
     bool mNoUninitialized;

icGREP/icgrep-devel/icgrep/UCD/resolve_properties.cpp

@@ -24 +24 @@
 using namespace llvm;
 
-inline int GetPropertyValueEnumCode(const UCD::property_t type, const std::string & value) {
-    return property_object_table[type]->GetPropertyValueEnumCode(value);
-}
-
 namespace UCD {
     
@@ -119 +115 @@
 }
 
-std::string resolvePropertyFunction(Name * const property) {
-    const std::string value = property->getName();
-    std::string functionName;
-    if (property->hasNamespace()) {
-        auto propit = alias_map.find(property->getNamespace());
-        if (propit == alias_map.end()) {
-            UnicodePropertyExpressionError("Expected a property name but '" + property->getNamespace() + "' was found instead");
-        }
-        auto theprop = propit->second;
-        if (EnumeratedPropertyObject * p = dyn_cast<EnumeratedPropertyObject>(property_object_table[theprop])){
-            int valcode = p->GetPropertyValueEnumCode(value);
-            if (valcode < 0) {
-                UnicodePropertyExpressionError("Erroneous property value '" + value + "' for " + property_full_name[theprop] + " property");
-            }
-            functionName = "__get_" + property_enum_name[theprop] + "_" + p->GetValueEnumName(valcode);
-        }
-        else if (theprop == scx) {
-            // Script extension property identified
-            int valcode = GetPropertyValueEnumCode(sc, value);
-            if (valcode < 0) {
-                UnicodePropertyExpressionError("Erroneous property value for script_extension property");
-            }
-            functionName = "__get_scx_" + SC_ns::enum_names[valcode];
-        }
-        else if (isa<BinaryPropertyObject>(property_object_table[theprop])){
-            auto valit = Binary_ns::aliases_only_map.find(value);
-            if (valit == Binary_ns::aliases_only_map.end()) {
-                UnicodePropertyExpressionError("Erroneous property value for binary property " + property_full_name[theprop]);
-            }
-            if (valit->second == Binary_ns::Y) {
-                functionName = "__get_" + property_enum_name[theprop] + "_Y";
-            } else {
-                UnicodePropertyExpressionError("Unexpected property value for binary property " + property_full_name[theprop]);
-            }
-        }
-        else {
-            UnicodePropertyExpressionError("Property " + property_full_name[theprop] + " recognized but not supported in icgrep 1.0");
-        }
-    } else { // No namespace (property) name.
-        // Try as a general category, script or binary property.
-        int valcode;
-        if ((valcode = GetPropertyValueEnumCode(gc, value)) >= 0) {
-            functionName = "__get_gc_" + GC_ns::enum_names[valcode];
-        }
-        else if ((valcode = GetPropertyValueEnumCode(sc, value)) >= 0) {
-            functionName = "__get_sc_" + SC_ns::enum_names[valcode];
-        }
-        else { // Try as a binary property.
-            auto propit = alias_map.find(value);
-            if (propit != alias_map.end()) {
-                auto theprop = propit->second;
-                if (isa<BinaryPropertyObject>(property_object_table[theprop])) {
-                    functionName = "__get_" + property_enum_name[theprop] + "_Y";
-                }
-                else {
-                    UnicodePropertyExpressionError("Error: property " + property_full_name[theprop] + " specified without a value");
-                }
-            }
-            else {
-                UnicodePropertyExpressionError("Expected a general category, script or binary property name but '" + value + "' was found instead");
-            }
-        }
-    }
-    assert (functionName.length() > 0);
-    return functionName;
-}
-
 const std::string & getPropertyValueGrepString(const std::string & prop) {
     auto propit = alias_map.find(canonicalize_value_name(prop));
@@ -216 +145 @@
         else {
             // No namespace (property) name.   Try as a general category.
-            int valcode = GetPropertyValueEnumCode(gc, value);
+            const auto & gcobj = cast<EnumeratedPropertyObject>(property_object_table[gc]);
+            int valcode = gcobj->GetPropertyValueEnumCode(value);
             if (valcode >= 0) {
-                return cast<EnumeratedPropertyObject>(property_object_table[gc])->GetCodepointSet(valcode);
-            }
-            valcode = GetPropertyValueEnumCode(sc, value);
+                return gcobj->GetCodepointSet(valcode);
+            }
+            const auto & scObj = cast<EnumeratedPropertyObject>(property_object_table[sc]);
+            valcode = scObj->GetPropertyValueEnumCode(value);
             if (valcode >= 0) {
-                return cast<EnumeratedPropertyObject>(property_object_table[sc])->GetCodepointSet(valcode);
+                return scObj->GetCodepointSet(valcode);
             }
             // Try as a binary property.