rmagick 2.13.2 → 4.2.2

data/ext/RMagick/rmenum.c

@@ -65,47 +65,65 @@ rm_enum_new(VALUE class, VALUE sym, VALUE val)
     return rb_obj_freeze(rb_class_new_instance(2, argv, class));
 }
 
+/**
+ * Retrieve C string value of Enum.
+ *
+ * No Ruby usage (internal function)
+ *
+ * @param enum_type the Enum object
+ * @return the C string value of Enum object
+ */
+static const char *
+rm_enum_to_cstr(VALUE enum_type)
+{
+    MagickEnum *magick_enum;
+
+    Data_Get_Struct(enum_type, MagickEnum, magick_enum);
+    return rb_id2name(magick_enum->id);
+}
 
 /**
- * Enum class alloc function.
+ * Free Enum or Enum subclass object
  *
  * No Ruby usage (internal function)
  *
- * @param class the Ruby class to use
- * @return a new enumerator
+ * @param magick_enum the enum
+ */
+static void rm_enum_free(void *magick_enum)
+{
+    xfree(magick_enum);
+}
+/**
+ * Enum class alloc function.
+ *
+ * @return [Magick::Enum] a new enumerator
  */
 VALUE
 Enum_alloc(VALUE class)
 {
-   MagickEnum *magick_enum;
-   volatile VALUE enumr;
+    MagickEnum *magick_enum;
+    VALUE enumr;
 
-   enumr = Data_Make_Struct(class, MagickEnum, NULL, NULL, magick_enum);
-   rb_obj_freeze(enumr);
-   return enumr;
+    enumr = Data_Make_Struct(class, MagickEnum, NULL, rm_enum_free, magick_enum);
+    rb_obj_freeze(enumr);
+
+    return enumr;
 }
 
 
 /**
  * "Case equal" operator for Enum.
  *
- * Ruby usage:
- *   - @verbatim Enum#=== @endverbatim
- *
- * Notes:
- *   - Yes, I know "case equal" is a misnomer.
- *
- * @param self this object
- * @param other the other object
- * @return true or false
+ * @param other [Object] the other object
+ * @return [Boolean] true or false
  */
 VALUE
 Enum_case_eq(VALUE self, VALUE other)
 {
-    MagickEnum *this, *that;
-
     if (CLASS_OF(self) == CLASS_OF(other))
     {
+        MagickEnum *this, *that;
+
         Data_Get_Struct(self, MagickEnum, this);
         Data_Get_Struct(other, MagickEnum, that);
         return this->val == that->val ? Qtrue : Qfalse;
@@ -118,64 +136,53 @@ Enum_case_eq(VALUE self, VALUE other)
 /**
  * Initialize a new Enum instance.
  *
- * Ruby usage:
- *   - @verbatim Enum#initialize(sym,val) @endverbatim
- *
- * @param self this object
- * @param sym the symbol
- * @param val the value for the symbol
- * @return self
+ * @param sym [Symbol] the symbol as enum name
+ * @param val [Numeric] the value for enum
+ * @return [Magick::Enum] self
  */
 VALUE
 Enum_initialize(VALUE self, VALUE sym, VALUE val)
 {
-   MagickEnum *magick_enum;
+    MagickEnum *magick_enum;
 
-   Data_Get_Struct(self, MagickEnum, magick_enum);
-   magick_enum->id = rb_to_id(sym); /* convert symbol to ID */
-   magick_enum->val = NUM2INT(val);
+    Data_Get_Struct(self, MagickEnum, magick_enum);
+    magick_enum->id = rb_to_id(sym); /* convert symbol to ID */
+    magick_enum->val = NUM2INT(val);
 
-   return self;
+    return self;
 }
 
 
 /**
  * Return the value of an enum.
  *
- * Ruby usage:
- *   - @verbatim Enum#to_i @endverbatim
- *
- * @param self this object
- * @return this object's value
+ * @return [Numeric] this object's value
  */
 VALUE
 Enum_to_i(VALUE self)
 {
-   MagickEnum *magick_enum;
+    MagickEnum *magick_enum;
 
-   Data_Get_Struct(self, MagickEnum, magick_enum);
-   return INT2NUM(magick_enum->val);
+    Data_Get_Struct(self, MagickEnum, magick_enum);
+    return INT2NUM(magick_enum->val);
 }
 
 
 /**
  * Support Comparable module in Enum.
  *
- * Ruby usage:
- *   - @verbatim Enum#<=> @endverbatim
- *
- * Notes:
- *   - Enums must be instances of the same class to be equal.
- *
- * @param self this object
- * @param other the other object
- * @return -1, 0, 1, or nil
+ * @param other [Object] the other object
+ * @return [-1, 0, 1, nil] the result of compare
  */
 VALUE
 Enum_spaceship(VALUE self, VALUE other)
 {
     MagickEnum *this, *that;
 
+    if(CLASS_OF(self) != CLASS_OF(other)) {
+        return Qnil;
+    }
+
     Data_Get_Struct(self, MagickEnum, this);
     Data_Get_Struct(other, MagickEnum, that);
 
@@ -188,51 +195,67 @@ Enum_spaceship(VALUE self, VALUE other)
         return INT2FIX(-1);
     }
 
-    // Values are equal, check class.
-
-    return rb_funcall(CLASS_OF(self), rm_ID_spaceship, 1, CLASS_OF(other));
+    return INT2FIX(0);
 }
 
+/**
+ * Bitwise OR for enums
+ *
+ * @param another [Magick::Enum] the another enum
+ * @return [Magick::Enum] new Enum instance
+ */
+VALUE
+Enum_bitwise_or(VALUE self, VALUE another)
+{
+    VALUE new_enum, cls;
+    MagickEnum *this, *that, *new_enum_data;
+
+    cls = CLASS_OF(self);
+    if (CLASS_OF(another) != cls)
+    {
+        rb_raise(rb_eArgError, "Expected class %s but got %s", rb_class2name(cls), rb_class2name(CLASS_OF(another)));
+    }
+
+    new_enum = Enum_alloc(cls);
+
+    Data_Get_Struct(self, MagickEnum, this);
+    Data_Get_Struct(another, MagickEnum, that);
+    Data_Get_Struct(new_enum, MagickEnum, new_enum_data);
+
+    new_enum_data->id = rb_to_id(rb_sprintf("%s|%s", rb_id2name(this->id), rb_id2name(that->id)));
+    new_enum_data->val = this->val | that->val;
+
+    return new_enum;
+}
 
 /**
  * Return the name of an enum.
  *
- * Ruby usage:
- *   - @verbatim Enum#to_s @endverbatim
- *
- * @param self this object
- * @return the name
+ * @return [String] the name of an enum
  */
 VALUE
 Enum_to_s(VALUE self)
 {
-   MagickEnum *magick_enum;
-
-   Data_Get_Struct(self, MagickEnum, magick_enum);
-   return rb_str_new2(rb_id2name(magick_enum->id));
+    return rb_str_new2(rm_enum_to_cstr(self));
 }
 
 
 /**
  * Initialize method for all Enum subclasses.
  *
- * Ruby usage:
- *   - @verbatim xxx#initialize(sym,val) @endverbatim
- *
- * @param self this object
- * @param sym the symbol
- * @param val the value of the symbol
- * @return self
+ * @param sym [Symbol] the symbol as enum name
+ * @param val [Numeric] the value for enum
+ * @return [Magick::Enum] self
  */
 VALUE
 Enum_type_initialize(VALUE self, VALUE sym, VALUE val)
 {
     VALUE super_argv[2];
-    volatile VALUE enumerators;
+    VALUE enumerators;
 
     super_argv[0] = sym;
     super_argv[1] = val;
-    (void) rb_call_super(2, (const VALUE *)super_argv);
+    rb_call_super(2, (const VALUE *)super_argv);
 
     if (rb_cvar_defined(CLASS_OF(self), rb_intern(ENUMERATORS_CLASS_VAR)) != Qtrue)
     {
@@ -240,7 +263,9 @@ Enum_type_initialize(VALUE self, VALUE sym, VALUE val)
     }
 
     enumerators = rb_cv_get(CLASS_OF(self), ENUMERATORS_CLASS_VAR);
-    (void) rb_ary_push(enumerators, self);
+    rb_ary_push(enumerators, self);
+
+    RB_GC_GUARD(enumerators);
 
     return self;
 }
@@ -249,11 +274,7 @@ Enum_type_initialize(VALUE self, VALUE sym, VALUE val)
 /**
  * Enum subclass #inspect.
  *
- * Ruby usage:
- *   - @verbatim xxx#inspect @endverbatim
- *
- * @param self this object
- * @return string representation of self
+ * @return [String] representation of self
  */
 static VALUE
 Enum_type_inspect(VALUE self)
@@ -262,7 +283,7 @@ Enum_type_inspect(VALUE self)
     MagickEnum *magick_enum;
 
     Data_Get_Struct(self, MagickEnum, magick_enum);
-    sprintf(str, "%.48s=%d", rb_id2name(magick_enum->id), magick_enum->val);
+    snprintf(str, sizeof(str), "%.48s=%d", rb_id2name(magick_enum->id), magick_enum->val);
 
     return rb_str_new2(str);
 }
@@ -271,21 +292,20 @@ Enum_type_inspect(VALUE self)
 /**
  * Behaves like #each if a block is present, otherwise like #to_a.
  *
- * Ruby usage:
- *   - @verbatim xxx.values @endverbatim
- *   - @verbatim xxx.values {|v| } @endverbatim
- *
- * Notes:
- *   - Defined for each Enum subclass
+ * @overload values
+ *   @return [Array<Magick::Enum>] the enum values
  *
- * @param class the subclass
- * @return iterator over values if given block, a copy of the values otherwise
+ * @overload values
+ *   iterator over values if given block
+ *   @yield [val]
+ *   @yieldparam val [Magick::Enum] an enum
+ *   @return [Magick::Enum] self
  */
 static VALUE
 Enum_type_values(VALUE class)
 {
-    volatile VALUE enumerators, copy;
-    volatile VALUE rv;
+    VALUE enumerators, copy;
+    VALUE rv;
     int x;
 
     enumerators = rb_cv_get(class, ENUMERATORS_CLASS_VAR);
@@ -294,7 +314,7 @@ Enum_type_values(VALUE class)
     {
         for (x = 0; x < RARRAY_LEN(enumerators); x++)
         {
-            (void) rb_yield(rb_ary_entry(enumerators, x));
+            rb_yield(rb_ary_entry(enumerators, x));
         }
         rv = class;
     }
@@ -303,460 +323,222 @@ Enum_type_values(VALUE class)
         copy = rb_ary_new2(RARRAY_LEN(enumerators));
         for (x = 0; x < RARRAY_LEN(enumerators); x++)
         {
-            (void) rb_ary_push(copy, rb_ary_entry(enumerators, x));
+            rb_ary_push(copy, rb_ary_entry(enumerators, x));
         }
         rb_obj_freeze(copy);
         rv = copy;
     }
 
+    RB_GC_GUARD(enumerators);
+    RB_GC_GUARD(copy);
+    RB_GC_GUARD(rv);
+
     return rv;
 }
 
-
 /**
- * Construct a ClassType enum object for the specified value.
+ * Find enum object for the specified value.
  *
  * No Ruby usage (internal function)
  *
- * @param cls the class type
- * @return a new enumerator
+ * @param class the class type
+ * @param value the value for enum
+ * @return a enumerator
  */
-VALUE
-ClassType_new(ClassType cls)
-{
-    const char *name;
-
-    switch(cls)
-    {
-        default:
-        case UndefinedClass:
-            name = "UndefineClass";
-            break;
-        case DirectClass:
-            name = "DirectClass";
-            break;
-        case PseudoClass:
-            name = "PseudoClass";
-            break;
-    }
 
-    return rm_enum_new(Class_ClassType, ID2SYM(rb_intern(name)), INT2FIX(cls));
-}
-
-
-/**
- * Construct a ColorspaceType enum object for the specified value.
- *
- * No Ruby usage (internal function)
- *
- * @param cs the ColorspaceType
- * @return a new ColorspaceType enumerator
- */
 VALUE
-ColorspaceType_new(ColorspaceType cs)
+Enum_find(VALUE class, int val)
 {
-    const char *name;
+    VALUE enumerators;
+    MagickEnum *magick_enum;
+    int x;
 
-    switch(cs)
+    enumerators = rb_cv_get(class, ENUMERATORS_CLASS_VAR);
+    enumerators = rm_check_ary_type(enumerators);
+
+    for (x = 0; x < RARRAY_LEN(enumerators); x++)
     {
-        default:
-        case UndefinedColorspace:
-            name = "UndefinedColorspace";
-            break;
-        case RGBColorspace:
-            name = "RGBColorspace";
-            break;
-        case GRAYColorspace:
-            name = "GRAYColorspace";
-            break;
-        case TransparentColorspace:
-            name = "TransparentColorspace";
-            break;
-        case OHTAColorspace:
-            name = "OHTAColorspace";
-            break;
-        case XYZColorspace:
-            name = "XYZColorspace";
-            break;
-        case YCbCrColorspace:
-            name = "YCbCrColorspace";
-            break;
-        case YCCColorspace:
-            name = "YCCColorspace";
-            break;
-        case YIQColorspace:
-            name = "YIQColorspace";
-            break;
-        case YPbPrColorspace:
-            name = "YPbPrColorspace";
-            break;
-        case YUVColorspace:
-            name = "YUVColorspace";
-            break;
-        case CMYKColorspace:
-            name = "CMYKColorspace";
-            break;
-        case sRGBColorspace:
-            name = "sRGBColorspace";
-            break;
-        case HSLColorspace:
-            name = "HSLColorspace";
-            break;
-        case HWBColorspace:
-            name = "HWBColorspace";
-            break;
-        case HSBColorspace:
-            name = "HSBColorspace";
-            break;
-        case LABColorspace:
-            name = "LABColorspace";
-            break;
-        case Rec601YCbCrColorspace:
-            name = "Rec601YCbCrColorspace";
-            break;
-        case Rec601LumaColorspace:
-            name = "Rec601LumaColorspace";
-            break;
-        case Rec709LumaColorspace:
-            name = "Rec709LumaColorspace";
-            break;
-        case Rec709YCbCrColorspace:
-            name = "Rec709YCbCrColorspace";
-            break;
-        case LogColorspace:
-            name = "LogColorspace";
-            break;
-        case CMYColorspace:
-            name = "CMYColorspace";
-            break;
+        VALUE enumerator = rb_ary_entry(enumerators, x);
+        Data_Get_Struct(enumerator, MagickEnum, magick_enum);
+        if (magick_enum->val == val)
+        {
+            return enumerator;
+        }
     }
 
-    return rm_enum_new(Class_ColorspaceType, ID2SYM(rb_intern(name)), INT2FIX(cs));
-
+    return Qnil;
 }
 
 
 /**
- * Return the name of a CompositeOperator enum as a string.
+ * Returns a ClassType enum object for the specified value.
  *
  * No Ruby usage (internal function)
  *
- * @param op the CompositeOperator
- * @return the name
+ * @param cls the class type
+ * @return a new enumerator
  */
-static const char *
-CompositeOperator_name(CompositeOperator op)
+VALUE
+ClassType_find(ClassType cls)
 {
-    switch (op)
-    {
-        ENUM_TO_NAME(UndefinedCompositeOp)
-        ENUM_TO_NAME(NoCompositeOp)
-        ENUM_TO_NAME(AddCompositeOp)
-        ENUM_TO_NAME(AtopCompositeOp)
-#if defined(HAVE_ENUM_BLURCOMPOSITEOP)
-        ENUM_TO_NAME(BlurCompositeOp)
-#endif
-        ENUM_TO_NAME(BumpmapCompositeOp)
-        ENUM_TO_NAME(ChangeMaskCompositeOp)
-        ENUM_TO_NAME(ClearCompositeOp)
-        ENUM_TO_NAME(ColorBurnCompositeOp)
-        ENUM_TO_NAME(BlendCompositeOp)
-        ENUM_TO_NAME(ColorDodgeCompositeOp)
-        ENUM_TO_NAME(ExclusionCompositeOp)
-        ENUM_TO_NAME(HardLightCompositeOp)
-        ENUM_TO_NAME(SoftLightCompositeOp)
-        ENUM_TO_NAME(ColorizeCompositeOp)
-        ENUM_TO_NAME(CopyBlueCompositeOp)
-        ENUM_TO_NAME(CopyCompositeOp)
-        ENUM_TO_NAME(CopyCyanCompositeOp)
-        ENUM_TO_NAME(CopyMagentaCompositeOp)
-        ENUM_TO_NAME(CopyYellowCompositeOp)
-        ENUM_TO_NAME(CopyBlackCompositeOp)
-        ENUM_TO_NAME(CopyGreenCompositeOp)
-        ENUM_TO_NAME(CopyOpacityCompositeOp)
-        ENUM_TO_NAME(CopyRedCompositeOp)
-        ENUM_TO_NAME(DarkenCompositeOp)
-#if defined(HAVE_ENUM_DISTORTCOMPOSITEOP)
-        ENUM_TO_NAME(DistortCompositeOp)
-#endif
-        ENUM_TO_NAME(DivideCompositeOp)
-        ENUM_TO_NAME(DstAtopCompositeOp)
-        ENUM_TO_NAME(DstCompositeOp)
-        ENUM_TO_NAME(DstInCompositeOp)
-        ENUM_TO_NAME(DstOutCompositeOp)
-        ENUM_TO_NAME(DstOverCompositeOp)
-        ENUM_TO_NAME(DifferenceCompositeOp)
-        ENUM_TO_NAME(DisplaceCompositeOp)
-        ENUM_TO_NAME(DissolveCompositeOp)
-        ENUM_TO_NAME(HueCompositeOp)
-        ENUM_TO_NAME(InCompositeOp)
-        ENUM_TO_NAME(LightenCompositeOp)
-#if defined(HAVE_ENUM_LINEARBURNCOMPOSITEOP)
-        ENUM_TO_NAME(LinearBurnCompositeOp)
-#endif
-#if defined(HAVE_ENUM_LINEARDODGECOMPOSITEOP)
-        ENUM_TO_NAME(LinearDodgeCompositeOp)
-#endif
-        ENUM_TO_NAME(LinearLightCompositeOp)
-        ENUM_TO_NAME(LuminizeCompositeOp)
-#if defined(HAVE_ENUM_MATHEMATICSCOMPOSITEOP)
-        ENUM_TO_NAME(MathematicsCompositeOp)
-#endif
-        ENUM_TO_NAME(MinusCompositeOp)
-        ENUM_TO_NAME(ModulateCompositeOp)
-        ENUM_TO_NAME(MultiplyCompositeOp)
-        ENUM_TO_NAME(OutCompositeOp)
-        ENUM_TO_NAME(OverCompositeOp)
-        ENUM_TO_NAME(OverlayCompositeOp)
-#if defined(HAVE_ENUM_PEGTOPLIGHTCOMPOSITEOP)
-        ENUM_TO_NAME(PegtopLightCompositeOp)
-#endif
-#if defined(HAVE_ENUM_PINLIGHTCOMPOSITEOP)
-        ENUM_TO_NAME(PinLightCompositeOp)
-#endif
-        ENUM_TO_NAME(PlusCompositeOp)
-        ENUM_TO_NAME(ReplaceCompositeOp)
-        ENUM_TO_NAME(SaturateCompositeOp)
-        ENUM_TO_NAME(ScreenCompositeOp)
-        ENUM_TO_NAME(SrcAtopCompositeOp)
-        ENUM_TO_NAME(SrcCompositeOp)
-        ENUM_TO_NAME(SrcInCompositeOp)
-        ENUM_TO_NAME(SrcOutCompositeOp)
-        ENUM_TO_NAME(SrcOverCompositeOp)
-        ENUM_TO_NAME(SubtractCompositeOp)
-        ENUM_TO_NAME(ThresholdCompositeOp)
-#if defined(HAVE_ENUM_VIVIDLIGHTCOMPOSITEOP)
-        ENUM_TO_NAME(VividLightCompositeOp)
-#endif
-        ENUM_TO_NAME(XorCompositeOp)
-    }
-
-    return "UndefinedCompositeOp";
+    return Enum_find(Class_ClassType, cls);
 }
 
 
 /**
- * Construct a CompositeOperator enum object for the specified value.
+ * Returns a ColorspaceType enum object for the specified value.
  *
  * No Ruby usage (internal function)
  *
- * @param op the CompositeOperator
- * @return a new CompositeOperator enumerator
+ * @param cs the ColorspaceType
+ * @return a new ColorspaceType enumerator
  */
 VALUE
-CompositeOperator_new(CompositeOperator op)
+ColorspaceType_find(ColorspaceType cs)
 {
-    const char *name = CompositeOperator_name(op);
-    return rm_enum_new(Class_CompositeOperator, ID2SYM(rb_intern(name)), INT2FIX(op));
+    return Enum_find(Class_ColorspaceType, cs);
 }
 
 
 /**
- * Return the name of a CompressionType enum as a string.
+ * Return the string representation of a ComplianceType value.
  *
  * No Ruby usage (internal function)
  *
- * @param ct the CompressionType
- * @return the name
+ * Notes:
+ *   - xMagick will OR multiple compliance types so we have to arbitrarily pick
+ *     one name.
+ *   - Set the compliance argument to the selected value.
+ *
+ * @param c the ComplianceType value
+ * @return the string
  */
-static const char *
-CompressionType_name(CompressionType ct)
+const char *
+ComplianceType_name(ComplianceType *c)
 {
-    switch (ct)
+    if ((*c & (SVGCompliance|X11Compliance|XPMCompliance))
+        == (SVGCompliance|X11Compliance|XPMCompliance))
     {
-        ENUM_TO_NAME(UndefinedCompression)
-        ENUM_TO_NAME(NoCompression)
-#if defined(HAVE_ENUM_B44COMPRESSION)
-        ENUM_TO_NAME(B44Compression)
-#endif
-#if defined(HAVE_ENUM_B44ACOMPRESSION)
-        ENUM_TO_NAME(B44ACompression)
-#endif
-        ENUM_TO_NAME(BZipCompression)
-#if defined(HAVE_ENUM_DXT1COMPRESSION)
-        ENUM_TO_NAME(DXT1Compression)
-#endif
-#if defined(HAVE_ENUM_DXT3COMPRESSION)
-        ENUM_TO_NAME(DXT3Compression)
-#endif
-#if defined(HAVE_ENUM_DXT5COMPRESSION)
-        ENUM_TO_NAME(DXT5Compression)
-#endif
-        ENUM_TO_NAME(FaxCompression)
-        ENUM_TO_NAME(Group4Compression)
-        ENUM_TO_NAME(JPEGCompression)
-        ENUM_TO_NAME(JPEG2000Compression)
-        ENUM_TO_NAME(LosslessJPEGCompression)
-        ENUM_TO_NAME(LZWCompression)
-#if defined(HAVE_ENUM_PIZCOMPRESSION)
-        ENUM_TO_NAME(PizCompression)
-#endif
-#if defined(HAVE_ENUM_PXR24COMPRESSION)
-        ENUM_TO_NAME(Pxr24Compression)
-#endif
-        ENUM_TO_NAME(RLECompression)
-        ENUM_TO_NAME(ZipCompression)
-#if defined(HAVE_ENUM_ZIPSCOMPRESSION)
-        ENUM_TO_NAME(ZipSCompression)
-#endif
-        }
-
-    return "UndefinedCompression";
+        return "AllCompliance";
+    }
+    else if (*c & SVGCompliance)
+    {
+        *c = SVGCompliance;
+        return "SVGCompliance";
+    }
+    else if (*c & X11Compliance)
+    {
+        *c = X11Compliance;
+        return "X11Compliance";
+    }
+    else if (*c & XPMCompliance)
+    {
+        *c = XPMCompliance;
+        return "XPMCompliance";
+    }
+    else if (*c == NoCompliance)
+    {
+        *c = NoCompliance;
+        return "NoCompliance";
+    }
+    else
+    {
+        *c = UndefinedCompliance;
+        return "UndefinedCompliance";
+    }
 }
 
 
 /**
- * Construct a CompressionType enum object for the specified value.
+ * Returns a ComplianceType enum object for the specified value.
  *
  * No Ruby usage (internal function)
  *
- * @param ct the CompressionType
- * @return a new CompressionType enumerator
+ * @param compliance the C ComplianceType value
+ * @return the Ruby ComplianceType enum object
  */
 VALUE
-CompressionType_new(CompressionType ct)
+ComplianceType_find(ComplianceType compliance)
 {
-    const char *name = CompressionType_name(ct);
-    return rm_enum_new(Class_CompressionType, ID2SYM(rb_intern(name)), INT2FIX(ct));
-}
-
+    ComplianceType c;
 
-/**
- * Return the name of a DisposeType enum as a string.
- *
- * No Ruby usage (internal function)
- *
- * @param type the DisposeType
- * @return the name
- */
-static const char *
-DisposeType_name(DisposeType type)
-{
-    switch(type)
+    // Turn off undefined bits
+    if ((compliance & (SVGCompliance|X11Compliance|XPMCompliance))
+        == (SVGCompliance|X11Compliance|XPMCompliance))
     {
-        ENUM_TO_NAME(UndefinedDispose)
-        ENUM_TO_NAME(BackgroundDispose)
-        ENUM_TO_NAME(NoneDispose)
-        ENUM_TO_NAME(PreviousDispose)
+        c = SVGCompliance|X11Compliance|XPMCompliance;
     }
-
-    return "UndefinedDispose";
+    else if (compliance & SVGCompliance)
+    {
+        c = SVGCompliance;
+    }
+    else if (compliance & X11Compliance)
+    {
+        c = X11Compliance;
+    }
+    else if (compliance & XPMCompliance)
+    {
+        c = XPMCompliance;
+    }
+    else if (compliance == NoCompliance)
+    {
+        c = NoCompliance;
+    }
+    else
+    {
+        c = UndefinedCompliance;
+    }
+    return Enum_find(Class_ComplianceType, c);
 }
 
 
 /**
- * Construct a DisposeType enum object for the specified value..new.
+ * Returns a CompositeOperator enum object for the specified value.
  *
  * No Ruby usage (internal function)
  *
- * @param type the DisposeType
- * @return a new DisposeType enumerator
+ * @param op the CompositeOperator
+ * @return a new CompositeOperator enumerator
  */
 VALUE
-DisposeType_new(DisposeType type)
+CompositeOperator_find(CompositeOperator op)
 {
-    const char *name = DisposeType_name(type);
-    return rm_enum_new(Class_DisposeType, ID2SYM(rb_intern(name)), INT2FIX(type));
-}
-
-
-/**
- * Return the name of a FilterTypes enum as a string.
- *
- * No Ruby usage (internal function)
- *
- * @param type the FilterTypes
- * @return the name
- */
-static const char *
-FilterTypes_name(FilterTypes type)
-{
-    switch(type)
-    {
-        ENUM_TO_NAME(UndefinedFilter)
-        ENUM_TO_NAME(PointFilter)
-        ENUM_TO_NAME(BoxFilter)
-        ENUM_TO_NAME(TriangleFilter)
-        ENUM_TO_NAME(HermiteFilter)
-        ENUM_TO_NAME(HanningFilter)
-        ENUM_TO_NAME(HammingFilter)
-        ENUM_TO_NAME(BlackmanFilter)
-        ENUM_TO_NAME(GaussianFilter)
-        ENUM_TO_NAME(QuadraticFilter)
-        ENUM_TO_NAME(CubicFilter)
-        ENUM_TO_NAME(CatromFilter)
-        ENUM_TO_NAME(MitchellFilter)
-        ENUM_TO_NAME(LanczosFilter)
-        ENUM_TO_NAME(BesselFilter)
-        ENUM_TO_NAME(SincFilter)
-#if defined(HAVE_ENUM_KAISERFILTER)
-        ENUM_TO_NAME(KaiserFilter)
-#endif
-#if defined(HAVE_ENUM_WELSHFILTER)
-        ENUM_TO_NAME(WelshFilter)
-#endif
-#if defined(HAVE_ENUM_PARZENFILTER)
-        ENUM_TO_NAME(ParzenFilter)
-#endif
-#if defined(HAVE_ENUM_LAGRANGEFILTER)
-        ENUM_TO_NAME(LagrangeFilter)
-#endif
-#if defined(HAVE_ENUM_BOHMANFILTER)
-        ENUM_TO_NAME(BohmanFilter)
-#endif
-#if defined(HAVE_ENUM_BARTLETTFILTER)
-        ENUM_TO_NAME(BartlettFilter)
-#endif
-#if defined(HAVE_ENUM_SENTINELFILTER)
-        // not a real filter name - defeat gcc warning message
-        case SentinelFilter:
-            break;
-#endif
-    }
-
-    return "UndefinedFilter";
+    return Enum_find(Class_CompositeOperator, op);
 }
 
 
 /**
- * Construct an FilterTypes enum object for the specified value.
+ * Returns a CompressionType enum object for the specified value.
  *
  * No Ruby usage (internal function)
  *
- * @param type the FilterTypes
- * @return a new FilterTypes enumerator
+ * @param ct the CompressionType
+ * @return a new CompressionType enumerator
  */
 VALUE
-FilterTypes_new(FilterTypes type)
+CompressionType_find(CompressionType ct)
 {
-    const char *name = FilterTypes_name(type);
-    return rm_enum_new(Class_FilterTypes, ID2SYM(rb_intern(name)), INT2FIX(type));
+    return Enum_find(Class_CompressionType, ct);
 }
 
 
 /**
- * Return the name of a EndianType enum as a string.
+ * Returns a DisposeType enum object for the specified value..new.
  *
  * No Ruby usage (internal function)
  *
- * @param type the EndianType
- * @return the name
+ * @param type the DisposeType
+ * @return a new DisposeType enumerator
  */
-static const char *
-EndianType_name(EndianType type)
+VALUE
+DisposeType_find(DisposeType type)
 {
-    switch(type)
-    {
-        ENUM_TO_NAME(UndefinedEndian)
-        ENUM_TO_NAME(LSBEndian)
-        ENUM_TO_NAME(MSBEndian)
-    }
-    return "UndefinedEndian";
+    return Enum_find(Class_DisposeType, type);
 }
 
 
 /**
- * Construct an EndianType enum object.
+ * Returns an EndianType enum object.
  *
  * No Ruby usage (internal function)
  *
@@ -764,46 +546,29 @@ EndianType_name(EndianType type)
  * @return a new EndianType enumerator
  */
 VALUE
-EndianType_new(EndianType type)
+EndianType_find(EndianType type)
 {
-    const char *name = EndianType_name(type);
-    return rm_enum_new(Class_EndianType, ID2SYM(rb_intern(name)), INT2FIX(type));
+    return Enum_find(Class_EndianType, type);
 }
 
 
 /**
- * Return the name of a GravityType enum as a string.
+ * Returns a FilterType enum object for the specified value.
  *
  * No Ruby usage (internal function)
  *
- * @param type the GravityType
- * @return the name
+ * @param type the FilterType
+ * @return a new FilterType enumerator
  */
-static const char *
-GravityType_name(GravityType type)
+VALUE
+FilterType_find(FilterType type)
 {
-    switch(type)
-    {
-        ENUM_TO_NAME(ForgetGravity)
-        ENUM_TO_NAME(NorthWestGravity)
-        ENUM_TO_NAME(NorthGravity)
-        ENUM_TO_NAME(NorthEastGravity)
-        ENUM_TO_NAME(WestGravity)
-        ENUM_TO_NAME(CenterGravity)
-        ENUM_TO_NAME(EastGravity)
-        ENUM_TO_NAME(SouthWestGravity)
-        ENUM_TO_NAME(SouthGravity)
-        ENUM_TO_NAME(SouthEastGravity)
-        ENUM_TO_NAME(StaticGravity)
-    }
-
-    // Defeat "duplicate case value" error.
-    return "UndefinedGravity";
+    return Enum_find(Class_FilterType, type);
 }
 
 
 /**
- * Construct an GravityType enum object for the specified value.
+ * Returns a GravityType enum object for the specified value.
  *
  * No Ruby usage (internal function)
  *
@@ -811,46 +576,14 @@ GravityType_name(GravityType type)
  * @return a new GravityType enumerator
  */
 VALUE
-GravityType_new(GravityType type)
-{
-    const char *name = GravityType_name(type);
-    return rm_enum_new(Class_GravityType, ID2SYM(rb_intern(name)), INT2FIX(type));
-}
-
-
-/**
- * Return the name of a ImageType enum as a string.
- *
- * No Ruby usage (internal function)
- *
- * @param type the ImageType
- * @return the name
- */
-static const char *
-ImageType_name(ImageType type)
+GravityType_find(GravityType type)
 {
-    switch(type)
-    {
-        ENUM_TO_NAME(UndefinedType)
-        ENUM_TO_NAME(BilevelType)
-        ENUM_TO_NAME(GrayscaleType)
-        ENUM_TO_NAME(GrayscaleMatteType)
-        ENUM_TO_NAME(PaletteType)
-        ENUM_TO_NAME(PaletteMatteType)
-        ENUM_TO_NAME(TrueColorType)
-        ENUM_TO_NAME(TrueColorMatteType)
-        ENUM_TO_NAME(ColorSeparationType)
-        ENUM_TO_NAME(ColorSeparationMatteType)
-        ENUM_TO_NAME(OptimizeType)
-        ENUM_TO_NAME(PaletteBilevelMatteType)
-    }
-
-    return "UndefinedType";
+    return Enum_find(Class_GravityType, type);
 }
 
 
 /**
- * Construct an ImageType enum object for the specified value.
+ * Returns an ImageType enum object for the specified value.
  *
  * No Ruby usage (internal function)
  *
@@ -858,42 +591,14 @@ ImageType_name(ImageType type)
  * @return a new ImageType enumerator
  */
 VALUE
-ImageType_new(ImageType type)
+ImageType_find(ImageType type)
 {
-    const char *name = ImageType_name(type);
-    return rm_enum_new(Class_ImageType, ID2SYM(rb_intern(name)), INT2FIX(type));
+    return Enum_find(Class_ImageType, type);
 }
 
 
 /**
- * Return the name of a InterlaceType enum as a string.
- *
- * No Ruby usage (internal function)
- *
- * @param interlace the InterlaceType
- * @return the name
- */
-static const char *
-InterlaceType_name(InterlaceType interlace)
-{
-    switch(interlace)
-    {
-        ENUM_TO_NAME(UndefinedInterlace)
-        ENUM_TO_NAME(GIFInterlace)
-        ENUM_TO_NAME(JPEGInterlace)
-        ENUM_TO_NAME(PNGInterlace)
-        ENUM_TO_NAME(NoInterlace)
-        ENUM_TO_NAME(LineInterlace)
-        ENUM_TO_NAME(PlaneInterlace)
-        ENUM_TO_NAME(PartitionInterlace)
-    }
-
-    return "UndefinedInterlace";
-}
-
-
-/**
- * Construct an InterlaceType enum object for the specified value.
+ * Returns an InterlaceType enum object for the specified value.
  *
  * No Ruby usage (internal function)
  *
@@ -901,315 +606,164 @@ InterlaceType_name(InterlaceType interlace)
  * @return a new InterlaceType enumerator
  */
 VALUE
-InterlaceType_new(InterlaceType interlace)
+InterlaceType_find(InterlaceType interlace)
 {
-    const char *name = InterlaceType_name(interlace);
-    return rm_enum_new(Class_InterlaceType, ID2SYM(rb_intern(name)), INT2FIX(interlace));
+    return Enum_find(Class_InterlaceType, interlace);
 }
 
 
 /**
- * Return the name of a InterpolatePixelMethod enum as a string.
+ * Returns an OrientationType enum object for the specified value.
  *
  * No Ruby usage (internal function)
  *
- * @param interpolate the InterpolatePixelMethod
- * @return the name
- */
-static const char *
-InterpolatePixelMethod_name(InterpolatePixelMethod interpolate)
-{
-    switch(interpolate)
-    {
-        ENUM_TO_NAME(UndefinedInterpolatePixel)
-        ENUM_TO_NAME(AverageInterpolatePixel)
-        ENUM_TO_NAME(BicubicInterpolatePixel)
-        ENUM_TO_NAME(BilinearInterpolatePixel)
-        ENUM_TO_NAME(FilterInterpolatePixel)
-        ENUM_TO_NAME(IntegerInterpolatePixel)
-        ENUM_TO_NAME(MeshInterpolatePixel)
-        ENUM_TO_NAME(NearestNeighborInterpolatePixel)
-        ENUM_TO_NAME(SplineInterpolatePixel)
-    }
-
-    return "UndefinedInterpolatePixel";
-}
-
-
-/**
- * Construct an InterpolatePixelMethod enum object for the specified value.
- *
- * No Ruby usage (internal function)
- *
- * @param interpolate the InterpolatePixelMethod
- * @return a new InterpolatePixelMethod enumerator
+ * @param type the OrientationType
+ * @return a new OrientationType enumerator
  */
 VALUE
-InterpolatePixelMethod_new(InterpolatePixelMethod interpolate)
+OrientationType_find(OrientationType type)
 {
-    const char *name = InterpolatePixelMethod_name(interpolate);
-    return rm_enum_new(Class_InterpolatePixelMethod, ID2SYM(rb_intern(name)), INT2FIX(interpolate));
+    return Enum_find(Class_OrientationType, type);
 }
 
 
 /**
- * Return the name of a MagickLayerMethod enum as a string.
+ * Returns a PixelInterpolateMethod enum object for the specified value.
  *
  * No Ruby usage (internal function)
  *
- * @param method the MagickLayerMethod
- * @return the name
- */
-static const char *
-LAYERMETHODTYPE_NAME(LAYERMETHODTYPE method)
-{
-    switch(method)
-    {
-        ENUM_TO_NAME(UndefinedLayer)
-        ENUM_TO_NAME(CompareAnyLayer)
-        ENUM_TO_NAME(CompareClearLayer)
-        ENUM_TO_NAME(CompareOverlayLayer)
-        ENUM_TO_NAME(OptimizeLayer)
-        ENUM_TO_NAME(OptimizePlusLayer)
-        ENUM_TO_NAME(CoalesceLayer)
-        ENUM_TO_NAME(DisposeLayer)
-        ENUM_TO_NAME(OptimizeTransLayer)
-        ENUM_TO_NAME(OptimizeImageLayer)
-        ENUM_TO_NAME(RemoveDupsLayer)
-        ENUM_TO_NAME(RemoveZeroLayer)
-        ENUM_TO_NAME(CompositeLayer)
-#if defined(HAVE_ENUM_MERGELAYER)
-        ENUM_TO_NAME(MergeLayer)
-#endif
-#if defined(HAVE_ENUM_MOSAICLAYER)
-        ENUM_TO_NAME(MosaicLayer)
-#endif
-#if defined(HAVE_ENUM_FLATTENLAYER)
-        ENUM_TO_NAME(FlattenLayer)
-#endif
-#if defined(HAVE_ENUM_TRIMBOUNDSLAYER)
-        ENUM_TO_NAME(TrimBoundsLayer)
-#endif
-    }
-
-    return "UndefinedLayer";
-}
-
-
-/**
- * Construct an MagickLayerMethod enum object for the specified value.
- *
- * No Ruby usage (internal function)
- *
- * @param method the MagickLayerMethod
- * @return a new MagickLayerMethod enumerator
+ * @param interpolate the PixelInterpolateMethod
+ * @return a new PixelInterpolateMethod enumerator
  */
 VALUE
-LAYERMETHODTYPE_NEW(LAYERMETHODTYPE method)
+PixelInterpolateMethod_find(PixelInterpolateMethod interpolate)
 {
-    const char *name = LAYERMETHODTYPE_NAME(method);
-    return rm_enum_new(CLASS_LAYERMETHODTYPE, ID2SYM(rb_intern(name)), INT2FIX(method));
+    return Enum_find(Class_PixelInterpolateMethod, interpolate);
 }
 
 
 /**
- * Return the name of a OrientationType enum as a string.
+ * Construct an RenderingIntent enum object for the specified value.
  *
  * No Ruby usage (internal function)
  *
- * @param type the OreintationType
- * @return the name
+ * @param intent the RenderingIntent
+ * @return a new RenderingIntent enumerator
  */
-static const char *
-OrientationType_name(OrientationType type)
+VALUE
+RenderingIntent_find(RenderingIntent intent)
 {
-    switch(type)
-    {
-        ENUM_TO_NAME(UndefinedOrientation)
-        ENUM_TO_NAME(TopLeftOrientation)
-        ENUM_TO_NAME(TopRightOrientation)
-        ENUM_TO_NAME(BottomRightOrientation)
-        ENUM_TO_NAME(BottomLeftOrientation)
-        ENUM_TO_NAME(LeftTopOrientation)
-        ENUM_TO_NAME(RightTopOrientation)
-        ENUM_TO_NAME(RightBottomOrientation)
-        ENUM_TO_NAME(LeftBottomOrientation)
-    }
-
-    return "UndefinedOrientation";
+    return Enum_find(Class_RenderingIntent, intent);
 }
 
 
 /**
- * Construct an OrientationType enum object for the specified value.
+ * Returns a ResolutionType enum object for the specified value.
  *
  * No Ruby usage (internal function)
  *
- * @param type the OrientationType
- * @return a new OrientationType enumerator
+ * @param type the ResolutionType
+ * @return a new ResolutionType enumerator
  */
 VALUE
-OrientationType_new(OrientationType type)
+ResolutionType_find(ResolutionType type)
 {
-    const char *name = OrientationType_name(type);
-    return rm_enum_new(Class_OrientationType, ID2SYM(rb_intern(name)), INT2FIX(type));
+    return Enum_find(Class_ResolutionType, type);
 }
 
 
 /**
- * Return the name of a RenderingIntent enum as a string.
+ * Return the string representation of a StorageType value.
  *
  * No Ruby usage (internal function)
  *
- * @param intent the RenderingIntent
+ * @param type the StorageType
  * @return the name
  */
-static const char *
-RenderingIntent_name(RenderingIntent intent)
+const char *
+StorageType_name(StorageType type)
 {
-    switch(intent)
+    VALUE storage = Enum_find(Class_StorageType, type);
+    if (NIL_P(storage))
     {
-        ENUM_TO_NAME(UndefinedIntent)
-        ENUM_TO_NAME(SaturationIntent)
-        ENUM_TO_NAME(PerceptualIntent)
-        ENUM_TO_NAME(AbsoluteIntent)
-        ENUM_TO_NAME(RelativeIntent)
+        return "UndefinedPixel";
     }
-
-    return "UndefinedIntent";
-}
-
-
-/**
- * Construct an RenderingIntent enum object for the specified value.
- *
- * No Ruby usage (internal function)
- *
- * @param intent the RenderingIntent
- * @return a new RenderingIntent enumerator
- */
-VALUE
-RenderingIntent_new(RenderingIntent intent)
-{
-    const char *name = RenderingIntent_name(intent);
-    return rm_enum_new(Class_RenderingIntent, ID2SYM(rb_intern(name)), INT2FIX(intent));
+    return rm_enum_to_cstr(storage);
 }
 
 
 /**
- * Return the name of a ResolutionType enum as a string.
+ * Return the string representation of a StretchType value.
  *
  * No Ruby usage (internal function)
  *
- * @param type the ResolutionType
- * @return the name
+ * @param stretch the StretchType value
+ * @return the string
  */
-static const char *
-ResolutionType_name(ResolutionType type)
+const char *
+StretchType_name(StretchType type)
 {
-    switch(type)
+    VALUE stretch = Enum_find(Class_StretchType, type);
+    if (NIL_P(stretch))
     {
-        ENUM_TO_NAME(UndefinedResolution)
-        ENUM_TO_NAME(PixelsPerInchResolution)
-        ENUM_TO_NAME(PixelsPerCentimeterResolution)
+        return "UndefinedStretch";
     }
-
-    return "UndefinedResolution";
+    return rm_enum_to_cstr(stretch);
 }
 
 
 /**
- * Construct an ResolutionType enum object for the specified value.
+ * Returns a StretchType enum for a specified StretchType value.
  *
  * No Ruby usage (internal function)
  *
- * @param type the ResolutionType
- * @return a new ResolutionType enumerator
+ * @param stretch the C StretchType value
+ * @return a Ruby StretchType enum
  */
 VALUE
-ResolutionType_new(ResolutionType type)
+StretchType_find(StretchType stretch)
 {
-    const char *name = ResolutionType_name(type);
-    return rm_enum_new(Class_ResolutionType, ID2SYM(rb_intern(name)), INT2FIX(type));
+    return Enum_find(Class_StretchType, stretch);
 }
 
 
 /**
- * Return the string representation of a StorageType value.
+ * Return the string representation of a StyleType value.
  *
  * No Ruby usage (internal function)
  *
- * @param type the StorageType
- * @return the name
+ * @param style the StyleType value
+ * @return the string
  */
 const char *
-StorageType_name(StorageType type)
+StyleType_name(StyleType type)
 {
-    switch (type)
+    VALUE style = Enum_find(Class_StyleType, type);
+    if (NIL_P(style))
     {
-        ENUM_TO_NAME(UndefinedPixel)
-        ENUM_TO_NAME(CharPixel)
-        ENUM_TO_NAME(DoublePixel)
-        ENUM_TO_NAME(FloatPixel)
-        ENUM_TO_NAME(IntegerPixel)
-        ENUM_TO_NAME(LongPixel)
-        ENUM_TO_NAME(QuantumPixel)
-        ENUM_TO_NAME(ShortPixel)
+        return "UndefinedStyle";
     }
-
-    return "UndefinedPixel";
+    return rm_enum_to_cstr(style);
 }
 
 
 /**
- * Return the string representation of a VirtualPixelMethod value.
+ * Returns a StyleType enum for a specified StyleType value.
  *
  * No Ruby usage (internal function)
  *
- * @param method the VirtualPixelMethod
- * @return the name
+ * @param style the C StyleType value
+ * @return a Ruby StyleType enum
  */
-static const char *
-VirtualPixelMethod_name(VirtualPixelMethod method)
+VALUE
+StyleType_find(StyleType style)
 {
-    switch (method)
-    {
-        ENUM_TO_NAME(UndefinedVirtualPixelMethod)
-        ENUM_TO_NAME(EdgeVirtualPixelMethod)
-        ENUM_TO_NAME(MirrorVirtualPixelMethod)
-        ENUM_TO_NAME(TileVirtualPixelMethod)
-        ENUM_TO_NAME(TransparentVirtualPixelMethod)
-        ENUM_TO_NAME(BackgroundVirtualPixelMethod)
-        ENUM_TO_NAME(DitherVirtualPixelMethod)
-        ENUM_TO_NAME(RandomVirtualPixelMethod)
-        ENUM_TO_NAME(ConstantVirtualPixelMethod)
-        ENUM_TO_NAME(MaskVirtualPixelMethod)
-        ENUM_TO_NAME(BlackVirtualPixelMethod)
-        ENUM_TO_NAME(GrayVirtualPixelMethod)
-        ENUM_TO_NAME(WhiteVirtualPixelMethod)
-#if defined(HAVE_ENUM_HORIZONTALTILEVIRTUALPIXELMETHOD)
-        ENUM_TO_NAME(HorizontalTileVirtualPixelMethod)
-#endif
-#if defined(HAVE_ENUM_VERTICALTILEVIRTUALPIXELMETHOD)
-        ENUM_TO_NAME(VerticalTileVirtualPixelMethod)
-#endif
-#if defined(HAVE_ENUM_HORIZONTALTILEEDGEVIRTUALPIXELMETHOD)
-        ENUM_TO_NAME(HorizontalTileEdgeVirtualPixelMethod)
-#endif
-#if defined(HAVE_ENUM_VERTICALTILEEDGEVIRTUALPIXELMETHOD)
-        ENUM_TO_NAME(VerticalTileEdgeVirtualPixelMethod)
-#endif
-#if defined(HAVE_ENUM_CHECKERTILEVIRTUALPIXELMETHOD)
-        ENUM_TO_NAME(CheckerTileVirtualPixelMethod)
-#endif
-    }
-
-    return "UndefinedVirtualPixelMethod";
+    return Enum_find(Class_StyleType, style);
 }
 
 
 /**
- * Construct a VirtualPixelMethod enum for a specified VirtualPixelMethod value.
+ * Returns a VirtualPixelMethod enum for a specified VirtualPixelMethod value.
  *
  * No Ruby usage (internal function)
  *
@@ -1217,8 +771,7 @@ VirtualPixelMethod_name(VirtualPixelMethod method)
  * @return a new VirtualPixelMethod enumerator
  */
 VALUE
-VirtualPixelMethod_new(VirtualPixelMethod style)
+VirtualPixelMethod_find(VirtualPixelMethod style)
 {
-    const char *name = VirtualPixelMethod_name(style);
-    return rm_enum_new(Class_VirtualPixelMethod, ID2SYM(rb_intern(name)), INT2FIX(style));
+    return Enum_find(Class_VirtualPixelMethod, style);
 }