diff --git a/regression_test/XML/XmlWorkflow/XmlTest_expectedTtcns/www_example_org_defaultforempty_e.ttcn b/regression_test/XML/XmlWorkflow/XmlTest_expectedTtcns/www_example_org_defaultforempty_e.ttcn
index 1983998e872299ac1f0c7f9e95e1579d073e3164..1fd51311142e58f320508e9e180a78d26e9128f1 100644
--- a/regression_test/XML/XmlWorkflow/XmlTest_expectedTtcns/www_example_org_defaultforempty_e.ttcn
+++ b/regression_test/XML/XmlWorkflow/XmlTest_expectedTtcns/www_example_org_defaultforempty_e.ttcn
@@ -1,7 +1,7 @@
 /*******************************************************************************
 * Copyright (c) 2000-2017 Ericsson Telecom AB
 *
-* XSD to TTCN-3 Translator                       
+* XSD to TTCN-3 Translator
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
@@ -73,31 +73,70 @@ const XSD.Boolean c_defaultForEmpty_9 := true;
 const XSD.Boolean c_defaultForEmpty_10 := false;
 
 
-const MyString_1 c_defaultForEmpty_11 := "fix";
+const XSD.AnySimpleType c_defaultForEmpty_11 := "1.0.0";
 
 
-const MyString2_1 c_defaultForEmpty_12 := "fix";
+const MyString_1 c_defaultForEmpty_12 := "fix";
 
 
-const EnumString c_defaultForEmpty_13 := a;
+const MyString2_1 c_defaultForEmpty_13 := "fix";
 
 
-const EnumDate c_defaultForEmpty_14 := x1888_01_01;
+const EnumString c_defaultForEmpty_14 := a;
 
 
-const EnumFloat c_defaultForEmpty_15 := infinity;
+const EnumDate c_defaultForEmpty_15 := x1888_01_01;
 
 
-const EnumFloat c_defaultForEmpty_16 := not_a_number;
+const EnumFloat c_defaultForEmpty_16 := infinity;
 
 
-const EnumFloat c_defaultForEmpty_17 := 1.0;
+const EnumFloat c_defaultForEmpty_17 := not_a_number;
 
 
-const EnumInteger c_defaultForEmpty_18 := int3;
+const EnumFloat c_defaultForEmpty_18 := 1.0;
 
 
-const EnumInteger c_defaultForEmpty_19 := int_3;
+const EnumInteger c_defaultForEmpty_19 := int3;
+
+
+const EnumInteger c_defaultForEmpty_20 := int_3;
+
+
+const LocalEnumAttributeDefault1 c_defaultForEmpty_21 := false_;
+
+
+const LocalEnumAttributeFixed1 c_defaultForEmpty_22 := false_;
+
+
+const LocalEnumAttributeDefault2 c_defaultForEmpty_23 := false_;
+
+
+const LocalEnumAttributeFixed2 c_defaultForEmpty_24 := false_;
+
+
+const LocalEnumElementDefault1 c_defaultForEmpty_25 := false_;
+
+
+const LocalEnumElementFixed1 c_defaultForEmpty_26 := false_;
+
+
+const LocalEnumElementDefault2 c_defaultForEmpty_27 := false_;
+
+
+const LocalEnumElementFixed2 c_defaultForEmpty_28 := false_;
+
+
+const Element.sequence_list[-].localEnumElementDefault1 c_defaultForEmpty_29 := false_;
+
+
+const Element.sequence_list[-].localEnumElementDefault2 c_defaultForEmpty_30 := false_;
+
+
+const Element.progress_notes_requested c_defaultForEmpty_31 := false_;
+
+
+const Element.progress_notes_requested2 c_defaultForEmpty_32 := false_;
 
 
 /* Basic defaultForEmpty */
@@ -269,6 +308,59 @@ with {
 };
 
 
+type XSD.AnySimpleType AnySimpleTypeDefault
+with {
+  variant "defaultForEmpty as c_defaultForEmpty_11";
+  variant "element";
+};
+
+
+type XSD.AnySimpleType AnySimpleTypeFixed (c_defaultForEmpty_11)
+with {
+  variant "defaultForEmpty as c_defaultForEmpty_11";
+  variant "element";
+};
+
+
+/* Unsupported anytype and QName */
+
+
+type XSD.AnyType AnyTypeDefault
+with {
+  variant "element";
+};
+
+
+type XSD.AnyType AnyTypeFixed
+with {
+  variant "element";
+};
+
+
+type XSD.AnyType AnyTypeDefault2
+with {
+  variant "element";
+};
+
+
+type XSD.AnyType AnyTypeFixed2
+with {
+  variant "element";
+};
+
+
+type XSD.QName QNameDefault
+with {
+  variant "element";
+};
+
+
+type XSD.QName QNameFixed
+with {
+  variant "element";
+};
+
+
 /* Check if the name conversion follows to the constants too */
 
 
@@ -299,9 +391,9 @@ with {
 };
 
 
-type MyString_1 MyStringFixed (c_defaultForEmpty_11)
+type MyString_1 MyStringFixed (c_defaultForEmpty_12)
 with {
-  variant "defaultForEmpty as c_defaultForEmpty_11";
+  variant "defaultForEmpty as c_defaultForEmpty_12";
   variant "element";
 };
 
@@ -312,16 +404,16 @@ with {
 };
 
 
-type MyString2_1 MyStringFixed2 (c_defaultForEmpty_12)
+type MyString2_1 MyStringFixed2 (c_defaultForEmpty_13)
 with {
-  variant "defaultForEmpty as c_defaultForEmpty_12";
+  variant "defaultForEmpty as c_defaultForEmpty_13";
   variant "element";
 };
 
 
-type MyString_1 AttrfixedMyString3_1 (c_defaultForEmpty_11)
+type MyString_1 AttrfixedMyString3_1 (c_defaultForEmpty_12)
 with {
-  variant "defaultForEmpty as c_defaultForEmpty_11";
+  variant "defaultForEmpty as c_defaultForEmpty_12";
   variant "name as 'AttrfixedMyString3'";
   variant "attribute";
 };
@@ -330,25 +422,25 @@ with {
 type record Complex
 {
 	XSD.Integer attrfixedInteger (c_defaultForEmpty_4) optional,
-	MyString2_1 attrfixedMyString2 (c_defaultForEmpty_12) optional,
+	MyString2_1 attrfixedMyString2 (c_defaultForEmpty_13) optional,
 	AttrfixedMyString3_1 attrfixedMyString3 optional,
 	MyString_1 birthPlaceAttrGroup optional,
-	MyString_1 myStringFixed (c_defaultForEmpty_11),
-	MyString2_1 myStringFixed2 (c_defaultForEmpty_12)
+	MyString_1 myStringFixed (c_defaultForEmpty_12),
+	MyString2_1 myStringFixed2 (c_defaultForEmpty_13)
 }
 with {
   variant (attrfixedInteger) "defaultForEmpty as c_defaultForEmpty_4";
   variant (attrfixedInteger) "name as capitalized";
   variant (attrfixedInteger) "attribute";
-  variant (attrfixedMyString2) "defaultForEmpty as c_defaultForEmpty_12";
+  variant (attrfixedMyString2) "defaultForEmpty as c_defaultForEmpty_13";
   variant (attrfixedMyString2) "name as capitalized";
   variant (attrfixedMyString2) "attribute";
   variant (attrfixedMyString3) "name as capitalized";
   variant (attrfixedMyString3) "attribute";
   variant (birthPlaceAttrGroup) "attribute";
-  variant (myStringFixed) "defaultForEmpty as c_defaultForEmpty_11";
+  variant (myStringFixed) "defaultForEmpty as c_defaultForEmpty_12";
   variant (myStringFixed) "name as capitalized";
-  variant (myStringFixed2) "defaultForEmpty as c_defaultForEmpty_12";
+  variant (myStringFixed2) "defaultForEmpty as c_defaultForEmpty_13";
   variant (myStringFixed2) "name as capitalized";
 };
 
@@ -356,9 +448,9 @@ with {
 /* Enumerations */
 
 
-type EnumString EnumStringFixed (c_defaultForEmpty_13)
+type EnumString EnumStringFixed (c_defaultForEmpty_14)
 with {
-  variant "defaultForEmpty as c_defaultForEmpty_13";
+  variant "defaultForEmpty as c_defaultForEmpty_14";
   variant "element";
 };
 
@@ -374,9 +466,9 @@ with {
 };
 
 
-type EnumDate EnumDateFixed (c_defaultForEmpty_14)
+type EnumDate EnumDateFixed (c_defaultForEmpty_15)
 with {
-  variant "defaultForEmpty as c_defaultForEmpty_14";
+  variant "defaultForEmpty as c_defaultForEmpty_15";
   variant "element";
 };
 
@@ -392,30 +484,30 @@ with {
 };
 
 
-type EnumFloat EnumFloatFixed (c_defaultForEmpty_15)
+type EnumFloat EnumFloatFixed (c_defaultForEmpty_16)
 with {
-  variant "defaultForEmpty as c_defaultForEmpty_15";
+  variant "defaultForEmpty as c_defaultForEmpty_16";
   variant "element";
 };
 
 
-type EnumFloat EnumFloatFixed2 (c_defaultForEmpty_16)
+type EnumFloat EnumFloatFixed2 (c_defaultForEmpty_17)
 with {
-  variant "defaultForEmpty as c_defaultForEmpty_16";
+  variant "defaultForEmpty as c_defaultForEmpty_17";
   variant "element";
 };
 
 
-type EnumFloat EnumFloatFixed3 (c_defaultForEmpty_17)
+type EnumFloat EnumFloatFixed3 (c_defaultForEmpty_18)
 with {
-  variant "defaultForEmpty as c_defaultForEmpty_17";
+  variant "defaultForEmpty as c_defaultForEmpty_18";
   variant "element";
 };
 
 
-type EnumFloat EnumFloatFixed4 (c_defaultForEmpty_17)
+type EnumFloat EnumFloatFixed4 (c_defaultForEmpty_18)
 with {
-  variant "defaultForEmpty as c_defaultForEmpty_17";
+  variant "defaultForEmpty as c_defaultForEmpty_18";
   variant "element";
 };
 
@@ -423,16 +515,16 @@ with {
 type XSD.Float EnumFloat (1.0, infinity, not_a_number);
 
 
-type EnumInteger EnumIntegerFixed (c_defaultForEmpty_18)
+type EnumInteger EnumIntegerFixed (c_defaultForEmpty_19)
 with {
-  variant "defaultForEmpty as c_defaultForEmpty_18";
+  variant "defaultForEmpty as c_defaultForEmpty_19";
   variant "element";
 };
 
 
-type EnumInteger EnumIntegerFixed2 (c_defaultForEmpty_19)
+type EnumInteger EnumIntegerFixed2 (c_defaultForEmpty_20)
 with {
-  variant "defaultForEmpty as c_defaultForEmpty_19";
+  variant "defaultForEmpty as c_defaultForEmpty_20";
   variant "element";
 };
 
@@ -447,6 +539,162 @@ with {
 };
 
 
+type enumerated LocalEnumAttributeDefault1
+{
+	false_,
+	true_
+}
+with {
+  variant "text 'false_' as 'false'";
+  variant "text 'true_' as 'true'";
+  variant "defaultForEmpty as c_defaultForEmpty_21";
+  variant "attribute";
+};
+
+
+type enumerated LocalEnumAttributeFixed1
+{
+	false_,
+	true_
+}
+with {
+  variant "text 'false_' as 'false'";
+  variant "text 'true_' as 'true'";
+  variant "defaultForEmpty as c_defaultForEmpty_22";
+  variant "attribute";
+};
+
+
+type XSD.String Mystring
+with {
+  variant "name as uncapitalized";
+};
+
+
+type enumerated LocalEnumAttributeDefault2
+{
+	false_,
+	true_
+}
+with {
+  variant "text 'false_' as 'false'";
+  variant "text 'true_' as 'true'";
+  variant "defaultForEmpty as c_defaultForEmpty_23";
+  variant "attribute";
+};
+
+
+type enumerated LocalEnumAttributeFixed2
+{
+	false_,
+	true_
+}
+with {
+  variant "text 'false_' as 'false'";
+  variant "text 'true_' as 'true'";
+  variant "defaultForEmpty as c_defaultForEmpty_24";
+  variant "attribute";
+};
+
+
+type enumerated LocalEnumElementDefault1
+{
+	false_,
+	true_
+}
+with {
+  variant "text 'false_' as 'false'";
+  variant "text 'true_' as 'true'";
+  variant "defaultForEmpty as c_defaultForEmpty_25";
+  variant "attribute";
+};
+
+
+type enumerated LocalEnumElementFixed1
+{
+	false_,
+	true_
+}
+with {
+  variant "text 'false_' as 'false'";
+  variant "text 'true_' as 'true'";
+  variant "defaultForEmpty as c_defaultForEmpty_26";
+  variant "attribute";
+};
+
+
+type enumerated LocalEnumElementDefault2
+{
+	false_,
+	true_
+}
+with {
+  variant "text 'false_' as 'false'";
+  variant "text 'true_' as 'true'";
+  variant "defaultForEmpty as c_defaultForEmpty_27";
+  variant "attribute";
+};
+
+
+type enumerated LocalEnumElementFixed2
+{
+	false_,
+	true_
+}
+with {
+  variant "text 'false_' as 'false'";
+  variant "text 'true_' as 'true'";
+  variant "defaultForEmpty as c_defaultForEmpty_28";
+  variant "attribute";
+};
+
+
+type record Element
+{
+	enumerated {
+		false_,
+		true_
+	} progress_notes_requested optional,
+	enumerated {
+		false_,
+		true_
+	} progress_notes_requested2 optional,
+	record length(1 .. 5) of record {
+		enumerated {
+			true_,
+			false_
+		} localEnumElementDefault1,
+		enumerated {
+			true_,
+			false_
+		} localEnumElementDefault2
+	} sequence_list
+}
+with {
+  variant "element";
+  variant (progress_notes_requested) "text 'false_' as 'false'";
+  variant (progress_notes_requested) "text 'true_' as 'true'";
+  variant (progress_notes_requested) "defaultForEmpty as c_defaultForEmpty_31";
+  variant (progress_notes_requested) "name as 'progress-notes-requested'";
+  variant (progress_notes_requested) "attribute";
+  variant (progress_notes_requested2) "text 'false_' as 'false'";
+  variant (progress_notes_requested2) "text 'true_' as 'true'";
+  variant (progress_notes_requested2) "defaultForEmpty as c_defaultForEmpty_32";
+  variant (progress_notes_requested2) "name as 'progress-notes-requested2'";
+  variant (progress_notes_requested2) "attribute";
+  variant (sequence_list) "untagged";
+  variant (sequence_list[-]) "untagged";
+  variant (sequence_list[-].localEnumElementDefault1) "defaultForEmpty as c_defaultForEmpty_29";
+  variant (sequence_list[-].localEnumElementDefault1) "name as capitalized";
+  variant (sequence_list[-].localEnumElementDefault1) "text 'false_' as 'false'";
+  variant (sequence_list[-].localEnumElementDefault1) "text 'true_' as 'true'";
+  variant (sequence_list[-].localEnumElementDefault2) "defaultForEmpty as c_defaultForEmpty_30";
+  variant (sequence_list[-].localEnumElementDefault2) "name as capitalized";
+  variant (sequence_list[-].localEnumElementDefault2) "text 'false_' as 'false'";
+  variant (sequence_list[-].localEnumElementDefault2) "text 'true_' as 'true'";
+};
+
+
 }
 with {
   encode "XML";
diff --git a/regression_test/XML/XmlWorkflow/src/xmlTest_Testcases.ttcn b/regression_test/XML/XmlWorkflow/src/xmlTest_Testcases.ttcn
index 940362d7804cb698c5e5aa1c572c6a74c95f381b..9215fe7f1bf50e14812b9385cca63c5554753899 100644
--- a/regression_test/XML/XmlWorkflow/src/xmlTest_Testcases.ttcn
+++ b/regression_test/XML/XmlWorkflow/src/xmlTest_Testcases.ttcn
@@ -2413,7 +2413,7 @@ group Elements{
 
   testcase tc_defaultforempty() runs on xmlTest_CT {
 
-    f_shellCommandWithVerdict(xsd2ttcn_command & " defaultforempty.xsd","",c_shell_successWithoutWarningAndError)
+    f_shellCommandWithVerdict(xsd2ttcn_command & " defaultforempty.xsd","",c_shell_successWithWarning)
 
     if(getverdict==pass) {
       f_compareFiles(
diff --git a/regression_test/XML/XmlWorkflow/xsd/defaultforempty.xsd b/regression_test/XML/XmlWorkflow/xsd/defaultforempty.xsd
index e08c9fa2619faf19ec7a270be1817400ceed8dd5..3c7e072263878ebd2b478791de2c753c71fa0448 100644
--- a/regression_test/XML/XmlWorkflow/xsd/defaultforempty.xsd
+++ b/regression_test/XML/XmlWorkflow/xsd/defaultforempty.xsd
@@ -49,7 +49,22 @@
 
 <xs:element name="BooleanFixed3" type="xs:boolean" fixed="0"/>
 
+<xs:element name='AnySimpleTypeDefault' type="xs:anySimpleType" default='1.0.0'/>
 
+<xs:element name='AnySimpleTypeFixed' type="xs:anySimpleType" fixed='1.0.0'/>
+
+<!-- Unsupported anytype and QName -->
+<xs:element name='AnyTypeDefault' default='1.0.0'/>
+
+<xs:element name='AnyTypeFixed' fixed='1.0.0'/>
+
+<xs:element name='AnyTypeDefault2' type="xs:anyType" default='1.0.0'/>
+
+<xs:element name='AnyTypeFixed2' type="xs:anyType" fixed='1.0.0'/>
+
+<xs:element name='QNameDefault' type="xs:QName" default='Name'/>
+
+<xs:element name='QNameFixed' type="xs:QName" fixed='Name'/>
 
 <!-- Check if the name conversion follows to the constants too -->
 <xs:element name="AttrfixedMyString3_"/>
@@ -136,5 +151,122 @@
 	</xs:restriction>
 </xs:simpleType>
 
+<xs:attribute name="LocalEnumAttributeDefault1" default='false'>
+	<xs:simpleType>
+		<xs:restriction base='xs:string'>
+			<xs:enumeration value='true'/>
+			<xs:enumeration value='false'/>
+		</xs:restriction>
+	</xs:simpleType>
+</xs:attribute>
+
+<xs:attribute name="LocalEnumAttributeFixed1" fixed='false'>
+	<xs:simpleType>
+		<xs:restriction base='xs:string'>
+			<xs:enumeration value='true'/>
+			<xs:enumeration value='false'/>
+		</xs:restriction>
+	</xs:simpleType>
+</xs:attribute>
+
+<xs:simpleType name="mystring">
+	<xs:restriction base="xs:string"/>
+</xs:simpleType>
+
+<xs:attribute name="LocalEnumAttributeDefault2" default='false'>
+	<xs:simpleType>
+		<xs:restriction base='dfe:mystring'>
+			<xs:enumeration value='true'/>
+			<xs:enumeration value='false'/>
+		</xs:restriction>
+	</xs:simpleType>
+</xs:attribute>
+
+<xs:attribute name="LocalEnumAttributeFixed2" fixed='false'>
+	<xs:simpleType>
+		<xs:restriction base='dfe:mystring'>
+			<xs:enumeration value='true'/>
+			<xs:enumeration value='false'/>
+		</xs:restriction>
+	</xs:simpleType>
+</xs:attribute>
+
+<xs:attribute name="LocalEnumElementDefault1" default='false'>
+	<xs:simpleType>
+		<xs:restriction base='xs:string'>
+			<xs:enumeration value='true'/>
+			<xs:enumeration value='false'/>
+		</xs:restriction>
+	</xs:simpleType>
+</xs:attribute>
+
+<xs:attribute name="LocalEnumElementFixed1" fixed='false'>
+	<xs:simpleType>
+		<xs:restriction base='xs:string'>
+			<xs:enumeration value='true'/>
+			<xs:enumeration value='false'/>
+		</xs:restriction>
+	</xs:simpleType>
+</xs:attribute>
+
+<xs:attribute name="LocalEnumElementDefault2" default='false'>
+	<xs:simpleType>
+		<xs:restriction base='dfe:mystring'>
+			<xs:enumeration value='true'/>
+			<xs:enumeration value='false'/>
+		</xs:restriction>
+	</xs:simpleType>
+</xs:attribute>
+
+<xs:attribute name="LocalEnumElementFixed2" fixed='false'>
+	<xs:simpleType>
+		<xs:restriction base='dfe:mystring'>
+			<xs:enumeration value='true'/>
+			<xs:enumeration value='false'/>
+		</xs:restriction>
+	</xs:simpleType>
+</xs:attribute>
+
+
+<xs:element name='Element'>
+	<xs:complexType>
+		<xs:sequence maxOccurs="5">
+			<xs:element name='LocalEnumElementDefault1' default='false'>
+				<xs:simpleType>
+					<xs:restriction base='xs:string'>
+						<xs:enumeration value='true'/>
+						<xs:enumeration value='false'/>
+					</xs:restriction>
+				</xs:simpleType>
+			</xs:element>
+			<xs:element name='LocalEnumElementDefault2' default='false'>
+				<xs:simpleType>
+					<xs:restriction base='dfe:mystring'>
+						<xs:enumeration value='true'/>
+						<xs:enumeration value='false'/>
+					</xs:restriction>
+				</xs:simpleType>
+			</xs:element>
+		</xs:sequence>
+		<xs:attribute name='progress-notes-requested' default='false'>
+			<xs:simpleType>
+				<xs:restriction base='xs:string'>
+					<xs:enumeration value='true'/>
+					<xs:enumeration value='false'/>
+				</xs:restriction>
+			</xs:simpleType>
+		</xs:attribute>
+		<xs:attribute name='progress-notes-requested2' default='false'>
+			<xs:simpleType>
+				<xs:restriction base='dfe:mystring'>
+					<xs:enumeration value='true'/>
+					<xs:enumeration value='false'/>
+				</xs:restriction>
+			</xs:simpleType>
+		</xs:attribute>
+	</xs:complexType>
+</xs:element>
+
+
 
 </xs:schema>
\ No newline at end of file
diff --git a/xsdconvert/AttributeType.cc b/xsdconvert/AttributeType.cc
index f4b8d7bd05d84479bc1748df96d931c13c06a975..17da67ba12298073a8442283f6ce335b8aa1850f 100644
--- a/xsdconvert/AttributeType.cc
+++ b/xsdconvert/AttributeType.cc
@@ -217,7 +217,7 @@ void AttributeType::printToFile(FILE* file, unsigned level) {
     printMinOccursMaxOccurs(file, false);
     fprintf(file, "enumerated {\n");
     enumeration.sortFacets();
-    enumeration.printToFile(file);
+    enumeration.printToFile(file, level);
     indent(file, level);
     fprintf(file, "\n} %s", name.convertedValue.c_str());
   } else if (enumeration.modified) {
@@ -229,7 +229,7 @@ void AttributeType::printToFile(FILE* file, unsigned level) {
     } else {
       fprintf(file, "enumerated {\n");
       enumeration.sortFacets();
-      enumeration.printToFile(file);
+      enumeration.printToFile(file, level);
       fprintf(file, "\n");
       indent(file, level);
       fprintf(file, "} %s", name.convertedValue.c_str());
diff --git a/xsdconvert/AttributeType.hh b/xsdconvert/AttributeType.hh
index 262e883bad5c6c4142ef6da82a8c4bf1af054cc2..189d1d454f3cc49bb031d62d2e6281a48beaa3e9 100644
--- a/xsdconvert/AttributeType.hh
+++ b/xsdconvert/AttributeType.hh
@@ -98,6 +98,10 @@ public:
   bool isAnyAttribute() const {
     return isAnyAttr;
   }
+  
+  Mstring getPath() {
+    return actualPath;
+  }
 
   void printToFile(FILE* file) {
     printToFile(file, 0);
diff --git a/xsdconvert/ComplexType.cc b/xsdconvert/ComplexType.cc
index ffc27638894e6330f184fc90cb2d4ff388747148..fef0604d99aa022b961b43c1fe5f917b2821fb79 100644
--- a/xsdconvert/ComplexType.cc
+++ b/xsdconvert/ComplexType.cc
@@ -21,6 +21,7 @@
 #include "TTCN3Module.hh"
 #include "TTCN3ModuleInventory.hh"
 #include "Annotation.hh"
+#include "Constant.hh"
 
 #include <assert.h>
 
@@ -1097,11 +1098,6 @@ void ComplexType::subFinalModification() {
       delete field->Data;
       field->Data = NULL;
       attribfields.remove(field);
-    } else if (field->Data->getUseVal() == prohibited || !field->Data->isVisible()) {
-      //Not visible attribute removed
-      delete field->Data;
-      field->Data = NULL;
-      attribfields.remove(field);
     } else {
       field->Data->SimpleType::finalModification();
     }
@@ -1144,8 +1140,16 @@ void ComplexType::subFinalModification2() {
     //Recursive call
     field->Data->subFinalModification2();
   }
-  for (List<AttributeType*>::iterator field = attribfields.begin(); field; field = field->Next) {
-    field->Data->SimpleType::finalModification2();
+  for (List<AttributeType*>::iterator field = attribfields.begin(), nextField; field; field = nextField) {
+    nextField = field->Next;
+    if (field->Data->getUseVal() == prohibited || !field->Data->isVisible()) {
+      //Not visible attribute removed
+      delete field->Data;
+      field->Data = NULL;
+      attribfields.remove(field);
+    } else {
+      field->Data->SimpleType::finalModification2();
+    }
   }
 }
 
@@ -1699,6 +1703,7 @@ void ComplexType::resolveAttribute(AttributeType* attr) {
   if (attr->getXsdtype() == n_attribute && !attr->getReference().empty()) {
     SimpleType * st = (SimpleType*) TTCN3ModuleInventory::getInstance().lookup(attr, want_BOTH);
     if (st != NULL) {
+      attr->setBuiltInBase(st->getBuiltInBase());
       if (attr->isFromRef()) {
         addNameSpaceAsVariant(attr, st);
         attr->setTypeOfField(st->getName().convertedValue);
diff --git a/xsdconvert/ComplexType.hh b/xsdconvert/ComplexType.hh
index db2e398d6e569aa53e1c4fbaea8c86839b328c44..12eec8bad6cdf1b0ba5c43e522f0564ff80cf662 100644
--- a/xsdconvert/ComplexType.hh
+++ b/xsdconvert/ComplexType.hh
@@ -154,6 +154,7 @@ public:
   void modifyList();
   void setNameDep(SimpleType * dep) { nameDep = dep; }
   void setParentTypeSubsGroup(ComplexType * dep) { parentTypeSubsGroup = dep; }
+  Mstring getPath() { return actualPath; }
 
   void dump(unsigned int depth) const;
 
diff --git a/xsdconvert/Constant.cc b/xsdconvert/Constant.cc
index 20a3cd485add538798475afe962f122057034d12..2c085e2a697a69e6f649883e2376399bcdcd1354 100644
--- a/xsdconvert/Constant.cc
+++ b/xsdconvert/Constant.cc
@@ -10,16 +10,18 @@
  *
  ******************************************************************************/
 #include "Constant.hh"
+#include "ComplexType.hh"
 
 
 Constant::Constant(SimpleType* p_parent, Mstring p_type, Mstring p_value)
   : RootType(p_parent->getParser(), p_parent->getModule(), p_parent->getConstruct())
 {
   parent = p_parent;
-  type.upload(p_type);
+  type.upload(p_type, false);
   value = p_value;
   alterego = NULL;
   checked = false;
+  unsupported = false;
 }
 
 void Constant::nameConversion(const NameConversionMode conversion_mode, const List<NamespaceType> & ns) {
@@ -89,6 +91,23 @@ void Constant::finalModification() {
     tmp_type = type.originalValueWoPrefix;
   }
   
+  // If the element or attribute is an unnamed enumeration and has default
+  // or fixed attribute
+  if (parent->getEnumeration().modified &&
+     (parent->getReference().get_ref() == NULL ||
+      !((SimpleType*)(parent->getReference().get_ref()))->getEnumeration().modified)) {
+    Mstring newtype = Mstring("");
+    // If the unnamed enumeration is a field of a type
+    if (parent->getMainType() != NULL) {
+      newtype = parent->getMainType()->getName().convertedValue + ".";
+      newtype += parent->getPath();
+    } else {
+      // If the unnamed enumeration is a top level attribute or element
+      newtype = parent->getName().convertedValue;
+    }
+    type.upload(newtype);
+  }
+  
   // String and time types need the quote character around the value
   if (parent->getEnumeration().modified ||
      (parent->getReference().get_ref() != NULL &&
@@ -117,7 +136,7 @@ void Constant::finalModification() {
         j++;
       }
     }
-  } else if (isStringType(tmp_type) || isTimeType(tmp_type)) {
+  } else if (isStringType(tmp_type) || isTimeType(tmp_type) || tmp_type == "anySimpleType") {
     value = Mstring("\"") + value + Mstring("\"");
   } else if (isFloatType(tmp_type)) {
     value = xmlFloat2TTCN3FloatStr(value);
@@ -129,12 +148,11 @@ void Constant::finalModification() {
     }
   } else if (isQNameType(tmp_type) || isAnyType(tmp_type)) {
     // These are not supported by TITAN.
-    // Do not generate constant to a Qname or anytype fixed or default value
-    // Little hack: set the name of the constant to the value with apostrophes
-    name.convertedValue = "'" + value + "'";
-    // Set the constant to invisible so it won't be generated into the code
-    // but in the defaultForEmpty variant the name will be generated which
-    // contains the value for the defaultForempty
+    // Reset the default value and fixed value
+    parent->getValue().default_value = "";
+    parent->getValue().fixed_value = "";
+    unsupported = true;
+    // Set the constant to invisible so it won't be generated into the code.
     setInvisible();
   }
   checked = true;
diff --git a/xsdconvert/Constant.hh b/xsdconvert/Constant.hh
index 6b006260ad750dbe0f06413a6321db65b7207921..3c4d1a448db014e5a739c94cad7227928e42f03e 100644
--- a/xsdconvert/Constant.hh
+++ b/xsdconvert/Constant.hh
@@ -21,6 +21,7 @@ class Constant : public RootType {
   // Points to the constant which have the same type and value as this
   Constant* alterego; // not owned
   bool checked;
+  bool unsupported;
   
   public:  
     Constant(SimpleType* p_parent, Mstring p_type, Mstring p_value);
@@ -51,6 +52,10 @@ class Constant : public RootType {
       }
     }
     
+    bool isUnsupported() const {
+      return unsupported;
+    }
+    
     // Remove 'equal' constants and give them names.
     static void finalFinalModification(List<RootType*> constantDefs);
 };
diff --git a/xsdconvert/RootType.cc b/xsdconvert/RootType.cc
index e0c132102ddc290cbd62ef92cdf03dbf08991ce2..6b2ea2cc0ccd9184b1519f16fd21b399e0df646b 100644
--- a/xsdconvert/RootType.cc
+++ b/xsdconvert/RootType.cc
@@ -293,6 +293,11 @@ void TypeType::checkBuintInTypeReference() {
       }
     }
   }
+  
+  // Third chance. NoTargetNamespace module without a prefix.
+  if (t_module->getTargetNamespace() == "NoTargetNamespace" && refPrefix.empty()) {
+    found = true;
+  }
   if (!found) {
     printError(t_module->getSchemaname(), t_parser->getActualLineNumber(), Mstring("Cannot find the namespace of type: ") + originalValueWoPrefix);
     t_parser->incrNumErrors();
diff --git a/xsdconvert/SimpleType.cc b/xsdconvert/SimpleType.cc
index dbc53a083bcfa0ac95b4e08066a8dc66d7361bba..72f6d4341fbf6c7637bc63b2c096d4e5c5fb9aa1 100644
--- a/xsdconvert/SimpleType.cc
+++ b/xsdconvert/SimpleType.cc
@@ -847,7 +847,7 @@ void SimpleType::finalModification() {
 void SimpleType::finalModification2() {
   // Delayed adding the defaultForEmpty variant after the nameconversion
   // happened on the constants
-  if (defaultForEmptyConstant != NULL) {
+  if (defaultForEmptyConstant != NULL && !defaultForEmptyConstant->isUnsupported()) {
     TTCN3Module * mod = parent != NULL ? parent->getModule() : getModule();
     addVariant(V_defaultForEmpty, defaultForEmptyConstant->getAlterego()->getConstantName(mod));
   }
@@ -881,6 +881,15 @@ bool SimpleType::hasRestrictionOrExtension() const {
     whitespace.modified;
 }
 
+ ComplexType * SimpleType::getMainType() {
+    ComplexType * par = parent;
+    if (par == NULL) return NULL;
+    while (par->parent != NULL) {
+      par = par->parent;
+    }
+    return par;
+  }
+
 void SimpleType::printToFile(FILE * file) {
   if (!visible) {
     return;
@@ -1536,7 +1545,7 @@ void ValueType::applyFacets() // only for integer and float types
     if (facet_maxInclusive != DBL_MAX && upper > facet_maxInclusive) upper = facet_maxInclusive;
     if (facet_minExclusive != -DBL_MAX && lower < facet_minExclusive) lower = facet_minExclusive;
     if (facet_maxExclusive != DBL_MAX && upper > facet_maxExclusive) upper = facet_maxExclusive;
-  } else if (isAnyType(base) || isTimeType(base) || isBooleanType(base)) {
+  } else if ((isAnyType(base) && base.getValueWithoutPrefix(':') != "anyType") || isTimeType(base) || isBooleanType(base)) {
   } else if (isStringType(base) && (
     base.getValueWithoutPrefix(':') != "hexBinary" && base.getValueWithoutPrefix(':') != "base64Binary")) {
   } else if (base.empty()) {
diff --git a/xsdconvert/SimpleType.hh b/xsdconvert/SimpleType.hh
index 5d6513bb7cdf2f34f4c06bb5a0e39e4a7db21298..e3714960563ff58fa4e7565ef534a6cd33dd3c35 100644
--- a/xsdconvert/SimpleType.hh
+++ b/xsdconvert/SimpleType.hh
@@ -305,6 +305,10 @@ public:
     return length;
   }
 
+  ValueType & getValue() {
+    return value;
+  }
+  
   const ValueType & getValue() const {
     return value;
   }
@@ -418,6 +422,12 @@ public:
   // Returns true if the type really restricts or extends the type not
   // just aliases it.
   bool hasRestrictionOrExtension() const;
+  
+  ComplexType* getMainType();
+  
+  virtual Mstring getPath() {
+    return Mstring("");
+  }
 
 };
 
diff --git a/xsdconvert/XMLParser.cc b/xsdconvert/XMLParser.cc
index 17842852c0b0f70ec33d94f2b5bd8a76f39074d3..89fc9068c87887e064cdd5b20367ec6affc9b78d 100644
--- a/xsdconvert/XMLParser.cc
+++ b/xsdconvert/XMLParser.cc
@@ -326,7 +326,9 @@ void XMLParser::startelementHandler(const xmlChar * localname,
         }
         if(actualTagName == n_annotation ||
           actualTagName == n_appinfo ||
-          actualTagName == n_documentation){
+          actualTagName == n_documentation ||
+          actualTagName == n_label ||
+          actualTagName == n_definition){
           inside_annotation.push_back(actualTagName);
           module->getLastMainType().loadWithValues();
         }else if(inside_annotation.empty()){
@@ -383,7 +385,9 @@ void XMLParser::endelementHandler(const xmlChar * localname) {
 
   if(tag == n_annotation ||
      tag == n_appinfo ||
-     tag == n_documentation){
+     tag == n_documentation ||
+     tag == n_label ||
+     tag == n_definition) {
     inside_annotation.pop_back();
   }
   
diff --git a/xsdconvert/converter.cc b/xsdconvert/converter.cc
index 0cb2ac44ced2f572aa1cd23672c0a3931622ecd3..9494ad5bb9507f0fba43c99d69ca2bcdbeed2db7 100644
--- a/xsdconvert/converter.cc
+++ b/xsdconvert/converter.cc
@@ -137,10 +137,10 @@ int main(int argc, char **argv) {
     }
   }
 
-  int first_module = f_flag_used ? 0 : optind;
   int last_module = f_flag_used ? 0 : argc;
   char **module_names = f_flag_used ? NULL : argv;
   try {
+    int first_module = f_flag_used ? 0 : optind;
     if (f_flag_used) {
       // Idea from CR_TR00015706.
       module_names = readModulesFromFile(from_file, &last_module);