text: #!/usr/bin/env python
  # -*- coding: utf-8 -*-
  
  # Copyright (c) 2014, The MITRE Corporation. All rights reserved.
  # See LICENSE.txt for complete terms.
  
  #
  # Generated Tue Apr 09 11:15:00 2013 by generateDS.py version 2.9a.
  #
  
  import sys
  import getopt
  import re as re_
  
  import win_handle_object
  import semaphore_object
  import cybox_common
  import base64
  from datetime import datetime, tzinfo, timedelta
  
  etree_ = None
  Verbose_import_ = False
  (   XMLParser_import_none, XMLParser_import_lxml,
      XMLParser_import_elementtree
      ) = range(3)
  XMLParser_import_library = None
  try:
      # lxml
      from lxml import etree as etree_
      XMLParser_import_library = XMLParser_import_lxml
      if Verbose_import_:
          print("running with lxml.etree")
  except ImportError:
      try:
          # cElementTree from Python 2.5+
          import xml.etree.cElementTree as etree_
          XMLParser_import_library = XMLParser_import_elementtree
          if Verbose_import_:
              print("running with cElementTree on Python 2.5+")
      except ImportError:
          try:
              # ElementTree from Python 2.5+
              import xml.etree.ElementTree as etree_
              XMLParser_import_library = XMLParser_import_elementtree
              if Verbose_import_:
                  print("running with ElementTree on Python 2.5+")
          except ImportError:
              try:
                  # normal cElementTree install
                  import cElementTree as etree_
                  XMLParser_import_library = XMLParser_import_elementtree
                  if Verbose_import_:
                      print("running with cElementTree")
              except ImportError:
                  try:
                      # normal ElementTree install
                      import elementtree.ElementTree as etree_
                      XMLParser_import_library = XMLParser_import_elementtree
                      if Verbose_import_:
                          print("running with ElementTree")
                  except ImportError:
                      raise ImportError(
                          "Failed to import ElementTree from any known place")
  
  def parsexml_(*args, **kwargs):
      if (XMLParser_import_library == XMLParser_import_lxml and
          'parser' not in kwargs):
          # Use the lxml ElementTree compatible parser so that, e.g.,
          #   we ignore comments.
          kwargs['parser'] = etree_.ETCompatXMLParser(huge_tree=True)
      doc = etree_.parse(*args, **kwargs)
      return doc
  
  #
  # User methods
  #
  # Calls to the methods in these classes are generated by generateDS.py.
  # You can replace these methods by re-implementing the following class
  #   in a module named generatedssuper.py.
  
  try:
      from generatedssuper import GeneratedsSuper
  except ImportError, exp:
  
      class GeneratedsSuper(object):
          tzoff_pattern = re_.compile(r'(\+|-)((0\d|1[0-3]):[0-5]\d|14:00)$')
          class _FixedOffsetTZ(tzinfo):
              def __init__(self, offset, name):
                  self.__offset = timedelta(minutes = offset)
                  self.__name = name
              def utcoffset(self, dt):
                  return self.__offset
              def tzname(self, dt):
                  return self.__name
              def dst(self, dt):
                  return None
          def gds_format_string(self, input_data, input_name=''):
              return input_data
          def gds_validate_string(self, input_data, node, input_name=''):
              return input_data
          def gds_format_base64(self, input_data, input_name=''):
              return base64.b64encode(input_data)
          def gds_validate_base64(self, input_data, node, input_name=''):
              return input_data
          def gds_format_integer(self, input_data, input_name=''):
              return '%d' % input_data
          def gds_validate_integer(self, input_data, node, input_name=''):
              return input_data
          def gds_format_integer_list(self, input_data, input_name=''):
              return '%s' % input_data
          def gds_validate_integer_list(self, input_data, node, input_name=''):
              values = input_data.split()
              for value in values:
                  try:
                      fvalue = float(value)
                  except (TypeError, ValueError), exp:
                      raise_parse_error(node, 'Requires sequence of integers')
              return input_data
          def gds_format_float(self, input_data, input_name=''):
              return '%f' % input_data
          def gds_validate_float(self, input_data, node, input_name=''):
              return input_data
          def gds_format_float_list(self, input_data, input_name=''):
              return '%s' % input_data
          def gds_validate_float_list(self, input_data, node, input_name=''):
              values = input_data.split()
              for value in values:
                  try:
                      fvalue = float(value)
                  except (TypeError, ValueError), exp:
                      raise_parse_error(node, 'Requires sequence of floats')
              return input_data
          def gds_format_double(self, input_data, input_name=''):
              return '%e' % input_data
          def gds_validate_double(self, input_data, node, input_name=''):
              return input_data
          def gds_format_double_list(self, input_data, input_name=''):
              return '%s' % input_data
          def gds_validate_double_list(self, input_data, node, input_name=''):
              values = input_data.split()
              for value in values:
                  try:
                      fvalue = float(value)
                  except (TypeError, ValueError), exp:
                      raise_parse_error(node, 'Requires sequence of doubles')
              return input_data
          def gds_format_boolean(self, input_data, input_name=''):
              return ('%s' % input_data).lower()
          def gds_validate_boolean(self, input_data, node, input_name=''):
              return input_data
          def gds_format_boolean_list(self, input_data, input_name=''):
              return '%s' % input_data
          def gds_validate_boolean_list(self, input_data, node, input_name=''):
              values = input_data.split()
              for value in values:
                  if value not in ('true', '1', 'false', '0', ):
                      raise_parse_error(node,
                          'Requires sequence of booleans '
                          '("true", "1", "false", "0")')
              return input_data
          def gds_validate_datetime(self, input_data, node, input_name=''):
              return input_data
          def gds_format_datetime(self, input_data, input_name=''):
              if isinstance(input_data, basestring):
                  return input_data
              if input_data.microsecond == 0:
                  _svalue = input_data.strftime('%Y-%m-%dT%H:%M:%S')
              else:
                  _svalue = input_data.strftime('%Y-%m-%dT%H:%M:%S.%f')
              if input_data.tzinfo is not None:
                  tzoff = input_data.tzinfo.utcoffset(input_data)
                  if tzoff is not None:
                      total_seconds = tzoff.seconds + (86400 * tzoff.days)
                      if total_seconds == 0:
                          _svalue += 'Z'
                      else:
                          if total_seconds < 0:
                              _svalue += '-'
                              total_seconds *= -1
                          else:
                              _svalue += '+'
                          hours = total_seconds // 3600
                          minutes = (total_seconds - (hours * 3600)) // 60
                          _svalue += '{0:02d}:{1:02d}'.format(hours, minutes)
              return _svalue
          def gds_parse_datetime(self, input_data, node, input_name=''):
              tz = None
              if input_data[-1] == 'Z':
                  tz = GeneratedsSuper._FixedOffsetTZ(0, 'GMT')
                  input_data = input_data[:-1]
              else:
                  results = GeneratedsSuper.tzoff_pattern.search(input_data)
                  if results is not None:
                      tzoff_parts = results.group(2).split(':')
                      tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1])
                      if results.group(1) == '-':
                          tzoff *= -1
                      tz = GeneratedsSuper._FixedOffsetTZ(
                          tzoff, results.group(0))
                      input_data = input_data[:-6]
              if len(input_data.split('.')) > 1:
                  dt = datetime.strptime(
                          input_data, '%Y-%m-%dT%H:%M:%S.%f')
              else:
                  dt = datetime.strptime(
                          input_data, '%Y-%m-%dT%H:%M:%S')
              return dt.replace(tzinfo = tz)
  
          def gds_validate_date(self, input_data, node, input_name=''):
              return input_data
          def gds_format_date(self, input_data, input_name=''):
              if isinstance(input_data, basestring):
                  return input_data
              _svalue = input_data.strftime('%Y-%m-%d')
              if input_data.tzinfo is not None:
                  tzoff = input_data.tzinfo.utcoffset(input_data)
                  if tzoff is not None:
                      total_seconds = tzoff.seconds + (86400 * tzoff.days)
                      if total_seconds == 0:
                          _svalue += 'Z'
                      else:
                          if total_seconds < 0:
                              _svalue += '-'
                              total_seconds *= -1
                          else:
                              _svalue += '+'
                          hours = total_seconds // 3600
                          minutes = (total_seconds - (hours * 3600)) // 60
                          _svalue += '{0:02d}:{1:02d}'.format(hours, minutes)
              return _svalue
          def gds_parse_date(self, input_data, node, input_name=''):
              tz = None
              if input_data[-1] == 'Z':
                  tz = GeneratedsSuper._FixedOffsetTZ(0, 'GMT')
                  input_data = input_data[:-1]
              else:
                  results = GeneratedsSuper.tzoff_pattern.search(input_data)
                  if results is not None:
                      tzoff_parts = results.group(2).split(':')
                      tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1])
                      if results.group(1) == '-':
                          tzoff *= -1
                      tz = GeneratedsSuper._FixedOffsetTZ(
                          tzoff, results.group(0))
                      input_data = input_data[:-6]
              return datetime.strptime(input_data,
                  '%Y-%m-%d').replace(tzinfo = tz)
          def gds_str_lower(self, instring):
              return instring.lower()
          def get_path_(self, node):
              path_list = []
              self.get_path_list_(node, path_list)
              path_list.reverse()
              path = '/'.join(path_list)
              return path
          Tag_strip_pattern_ = re_.compile(r'\{.*\}')
          def get_path_list_(self, node, path_list):
              if node is None:
                  return
              tag = GeneratedsSuper.Tag_strip_pattern_.sub('', node.tag)
              if tag:
                  path_list.append(tag)
              self.get_path_list_(node.getparent(), path_list)
          def get_class_obj_(self, node, default_class=None):
              class_obj1 = default_class
              if 'xsi' in node.nsmap:
                  classname = node.get('{%s}type' % node.nsmap['xsi'])
                  if classname is not None:
                      names = classname.split(':')
                      if len(names) == 2:
                          classname = names[1]
                      class_obj2 = globals().get(classname)
                      if class_obj2 is not None:
                          class_obj1 = class_obj2
              return class_obj1
          def gds_build_any(self, node, type_name=None):
              return None
  
  
  #
  # If you have installed IPython you can uncomment and use the following.
  # IPython is available from http://ipython.scipy.org/.
  #
  
  ## from IPython.Shell import IPShellEmbed
  ## args = ''
  ## ipshell = IPShellEmbed(args,
  ##     banner = 'Dropping into IPython',
  ##     exit_msg = 'Leaving Interpreter, back to program.')
  
  # Then use the following line where and when you want to drop into the
  # IPython shell:
  #    ipshell('<some message> -- Entering ipshell.\nHit Ctrl-D to exit')
  
  #
  # Globals
  #
  
  ExternalEncoding = 'utf-8'
  Tag_pattern_ = re_.compile(r'({.*})?(.*)')
  String_cleanup_pat_ = re_.compile(r"[\n\r\s]+")
  Namespace_extract_pat_ = re_.compile(r'{(.*)}(.*)')
  
  #
  # Support/utility functions.
  #
  
  def showIndent(lwrite, level, pretty_print=True):
      if pretty_print:
  
              lwrite('    ' * level)
  
  def quote_xml(inStr):
      if not inStr:
          return ''
      s1 = (isinstance(inStr, basestring) and inStr or
            '%s' % inStr)
      s1 = s1.replace('&', '&amp;')
      s1 = s1.replace('<', '&lt;')
      s1 = s1.replace('>', '&gt;')
      return unicode(s1).encode(ExternalEncoding)
  
  def quote_attrib(inStr):
      s1 = (isinstance(inStr, basestring) and inStr or
            '%s' % inStr)
      s1 = s1.replace('&', '&amp;')
      s1 = s1.replace('<', '&lt;')
      s1 = s1.replace('>', '&gt;')
      if '"' in s1:
          if "'" in s1:
              s1 = '"%s"' % s1.replace('"', "&quot;")
          else:
              s1 = "'%s'" % s1
      else:
          s1 = '"%s"' % s1
      return unicode(s1).encode(ExternalEncoding)
  
  def quote_python(inStr):
      s1 = inStr
      if s1.find("'") == -1:
          if s1.find('\n') == -1:
              return "'%s'" % s1
          else:
              return "'''%s'''" % s1
      else:
          if s1.find('"') != -1:
              s1 = s1.replace('"', '\\"')
          if s1.find('\n') == -1:
              return '"%s"' % s1
          else:
              return '"""%s"""' % s1
  
  def get_all_text_(node):
      if node.text is not None:
          text = node.text
      else:
          text = ''
      for child in node:
          if child.tail is not None:
              text += child.tail
      return text
  
  def find_attr_value_(attr_name, node):
      attrs = node.attrib
      attr_parts = attr_name.split(':')
      value = None
      if len(attr_parts) == 1:
          value = attrs.get(attr_name)
      elif len(attr_parts) == 2:
          prefix, name = attr_parts
          namespace = node.nsmap.get(prefix)
          if namespace is not None:
              value = attrs.get('{%s}%s' % (namespace, name, ))
      return value
  
  
  class GDSParseError(Exception):
      pass
  
  def raise_parse_error(node, msg):
      if XMLParser_import_library == XMLParser_import_lxml:
          msg = '%s (element %s/line %d)' % (
              msg, node.tag, node.sourceline, )
      else:
          msg = '%s (element %s)' % (msg, node.tag, )
      raise GDSParseError(msg)
  
  
  class MixedContainer:
      # Constants for category:
      CategoryNone = 0
      CategoryText = 1
      CategorySimple = 2
      CategoryComplex = 3
      # Constants for content_type:
      TypeNone = 0
      TypeText = 1
      TypeString = 2
      TypeInteger = 3
      TypeFloat = 4
      TypeDecimal = 5
      TypeDouble = 6
      TypeBoolean = 7
      TypeBase64 = 8
      def __init__(self, category, content_type, name, value):
          self.category = category
          self.content_type = content_type
          self.name = name
          self.value = value
      def getCategory(self):
          return self.category
      def getContenttype(self, content_type):
          return self.content_type
      def getValue(self):
          return self.value
      def getName(self):
          return self.name
      def export(self, lwrite, level, name, namespace, pretty_print=True):
          if self.category == MixedContainer.CategoryText:
              # Prevent exporting empty content as empty lines.
              if self.value.strip():
                  lwrite(self.value)
          elif self.category == MixedContainer.CategorySimple:
              self.exportSimple(lwrite, level, name)
          else:    # category == MixedContainer.CategoryComplex
              self.value.export(lwrite, level, namespace, name, pretty_print)
      def exportSimple(self, lwrite, level, name):
          if self.content_type == MixedContainer.TypeString:
              lwrite('<%s>%s</%s>' %
                  (self.name, self.value, self.name))
          elif self.content_type == MixedContainer.TypeInteger or \
                  self.content_type == MixedContainer.TypeBoolean:
              lwrite('<%s>%d</%s>' %
                  (self.name, self.value, self.name))
          elif self.content_type == MixedContainer.TypeFloat or \
                  self.content_type == MixedContainer.TypeDecimal:
              lwrite('<%s>%f</%s>' %
                  (self.name, self.value, self.name))
          elif self.content_type == MixedContainer.TypeDouble:
              lwrite('<%s>%g</%s>' %
                  (self.name, self.value, self.name))
          elif self.content_type == MixedContainer.TypeBase64:
              lwrite('<%s>%s</%s>' %
                  (self.name, base64.b64encode(self.value), self.name))
      def to_etree(self, element):
          if self.category == MixedContainer.CategoryText:
              # Prevent exporting empty content as empty lines.
              if self.value.strip():
                  if len(element) > 0:
                      if element[-1].tail is None:
                          element[-1].tail = self.value
                      else:
                          element[-1].tail += self.value
                  else:
                      if element.text is None:
                          element.text = self.value
                      else:
                          element.text += self.value
          elif self.category == MixedContainer.CategorySimple:
              subelement = etree_.SubElement(element, '%s' % self.name)
              subelement.text = self.to_etree_simple()
          else:    # category == MixedContainer.CategoryComplex
              self.value.to_etree(element)
      def to_etree_simple(self):
          if self.content_type == MixedContainer.TypeString:
              text = self.value
          elif (self.content_type == MixedContainer.TypeInteger or
                  self.content_type == MixedContainer.TypeBoolean):
              text = '%d' % self.value
          elif (self.content_type == MixedContainer.TypeFloat or
                  self.content_type == MixedContainer.TypeDecimal):
              text = '%f' % self.value
          elif self.content_type == MixedContainer.TypeDouble:
              text = '%g' % self.value
          elif self.content_type == MixedContainer.TypeBase64:
              text = '%s' % base64.b64encode(self.value)
          return text
      def exportLiteral(self, lwrite, level, name):
          if self.category == MixedContainer.CategoryText:
              showIndent(lwrite, level)
              lwrite('model_.MixedContainer(%d, %d, "%s", "%s"),\n'
                  % (self.category, self.content_type, self.name, self.value))
          elif self.category == MixedContainer.CategorySimple:
              showIndent(lwrite, level)
              lwrite('model_.MixedContainer(%d, %d, "%s", "%s"),\n'
                  % (self.category, self.content_type, self.name, self.value))
          else:    # category == MixedContainer.CategoryComplex
              showIndent(lwrite, level)
              lwrite('model_.MixedContainer(%d, %d, "%s",\n' % \
                  (self.category, self.content_type, self.name,))
              self.value.exportLiteral(lwrite, level + 1)
              showIndent(lwrite, level)
              lwrite(')\n')
  
  
  class MemberSpec_(object):
      def __init__(self, name='', data_type='', container=0):
          self.name = name
          self.data_type = data_type
          self.container = container
      def set_name(self, name): self.name = name
      def get_name(self): return self.name
      def set_data_type(self, data_type): self.data_type = data_type
      def get_data_type_chain(self): return self.data_type
      def get_data_type(self):
          if isinstance(self.data_type, list):
              if len(self.data_type) > 0:
                  return self.data_type[-1]
              else:
                  return 'xs:string'
          else:
              return self.data_type
      def set_container(self, container): self.container = container
      def get_container(self): return self.container
  
  def _cast(typ, value):
      if typ is None or value is None:
          return value
      return typ(value)
  
  #
  # Data representation classes.
  #
  
  class WindowsSemaphoreObjectType(semaphore_object.SemaphoreObjectType):
      """The WindowsSemaphoreObjectType is intended to characterize Windows
      semaphore (synchronization) objects."""
      
      subclass = None
      superclass = semaphore_object.SemaphoreObjectType
      def __init__(self, object_reference=None, Custom_Properties=None, xsi_type=None, named=None, Current_Count=None, Maximum_Count=None, Name=None, Handle=None, Security_Attributes=None):
          super(WindowsSemaphoreObjectType, self).__init__(object_reference, Custom_Properties, named, Current_Count, Maximum_Count, Name, )
          self.Handle = Handle
          self.Security_Attributes = Security_Attributes
      def factory(*args_, **kwargs_):
          if WindowsSemaphoreObjectType.subclass:
              return WindowsSemaphoreObjectType.subclass(*args_, **kwargs_)
          else:
              return WindowsSemaphoreObjectType(*args_, **kwargs_)
      factory = staticmethod(factory)
      def get_Handle(self): return self.Handle
      def set_Handle(self, Handle): self.Handle = Handle
      def get_Security_Attributes(self): return self.Security_Attributes
      def set_Security_Attributes(self, Security_Attributes): self.Security_Attributes = Security_Attributes
      def validate_StringObjectPropertyType(self, value):
          # Validate type cybox_common.StringObjectPropertyType, a restriction on None.
          pass
      def hasContent_(self):
          if (
              self.Handle is not None or
              self.Security_Attributes is not None or
              super(WindowsSemaphoreObjectType, self).hasContent_()
              ):
              return True
          else:
              return False
      def export(self, lwrite, level, namespace_='WinSemaphoreObj:', name_='WindowsSemaphoreObjectType', namespacedef_='', pretty_print=True):
          if pretty_print:
              eol_ = '\n'
          else:
              eol_ = ''
          showIndent(lwrite, level, pretty_print)
          lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
          already_processed = set()
          self.exportAttributes(lwrite, level, already_processed, namespace_, name_='WindowsSemaphoreObjectType')
          if self.hasContent_():
              lwrite('>%s' % (eol_, ))
              self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print)
              showIndent(lwrite, level, pretty_print)
              lwrite('</%s%s>%s' % (namespace_, name_, eol_))
          else:
              lwrite('/>%s' % (eol_, ))
      def exportAttributes(self, lwrite, level, already_processed, namespace_='WinSemaphoreObj:', name_='WindowsSemaphoreObjectType'):
          super(WindowsSemaphoreObjectType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='WindowsSemaphoreObjectType')
      def exportChildren(self, lwrite, level, namespace_='WinSemaphoreObj:', name_='WindowsSemaphoreObjectType', fromsubclass_=False, pretty_print=True):
          super(WindowsSemaphoreObjectType, self).exportChildren(lwrite, level, 'WinSemaphoreObj:', name_, True, pretty_print=pretty_print)
          if pretty_print:
              eol_ = '\n'
          else:
              eol_ = ''
          if self.Handle is not None:
              self.Handle.export(lwrite, level, 'WinSemaphoreObj:', name_='Handle', pretty_print=pretty_print)
          if self.Security_Attributes is not None:
              self.Security_Attributes.export(lwrite, level, 'WinSemaphoreObj:', name_='Security_Attributes', pretty_print=pretty_print)
      def build(self, node):
          already_processed = set()
          self.buildAttributes(node, node.attrib, already_processed)
          for child in node:
              nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
              self.buildChildren(child, node, nodeName_)
      def buildAttributes(self, node, attrs, already_processed):
          super(WindowsSemaphoreObjectType, self).buildAttributes(node, attrs, already_processed)
      def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
          if nodeName_ == 'Handle':
              obj_ = win_handle_object.WindowsHandleObjectType.factory()
              obj_.build(child_)
              self.set_Handle(obj_)
          elif nodeName_ == 'Security_Attributes':
              obj_ = cybox_common.StringObjectPropertyType.factory()
              obj_.build(child_)
              self.set_Security_Attributes(obj_)
          super(WindowsSemaphoreObjectType, self).buildChildren(child_, node, nodeName_, True)
  # end class WindowsSemaphoreObjectType
  
  GDSClassesMapping = {
      'Build_Utility': cybox_common.BuildUtilityType,
      'Errors': cybox_common.ErrorsType,
      'Time': cybox_common.TimeType,
      'Certificate_Issuer': cybox_common.StringObjectPropertyType,
      'Semaphore': semaphore_object.SemaphoreObjectType,
      'Metadata': cybox_common.MetadataType,
      'Hash': cybox_common.HashType,
      'Information_Source_Type': cybox_common.ControlledVocabularyStringType,
      'Block_Hash_Value': cybox_common.HashValueType,
      'Fuzzy_Hash_Structure': cybox_common.FuzzyHashStructureType,
      'SubDatum': cybox_common.MetadataType,
      'Segment_Hash': cybox_common.HashValueType,
      'Digital_Signature': cybox_common.DigitalSignatureInfoType,
      'Code_Snippets': cybox_common.CodeSnippetsType,
      'Value': cybox_common.StringObjectPropertyType,
      'Length': cybox_common.IntegerObjectPropertyType,
      'Encoding': cybox_common.ControlledVocabularyStringType,
      'Internationalization_Settings': cybox_common.InternationalizationSettingsType,
      'Tool_Configuration': cybox_common.ToolConfigurationType,
      'Security_Attributes': cybox_common.StringObjectPropertyType,
      'Object_Address': cybox_common.UnsignedLongObjectPropertyType,
      'Compiler': cybox_common.CompilerType,
      'Functions': cybox_common.FunctionsType,
      'String_Value': cybox_common.StringObjectPropertyType,
      'Pointer_Count': cybox_common.UnsignedLongObjectPropertyType,
      'Build_Utility_Platform_Specification': cybox_common.PlatformSpecificationType,
      'Compiler_Informal_Description': cybox_common.CompilerInformalDescriptionType,
      'System': cybox_common.ObjectPropertiesType,
      'Platform': cybox_common.PlatformSpecificationType,
      'Usage_Context_Assumptions': cybox_common.UsageContextAssumptionsType,
      'Type': cybox_common.ControlledVocabularyStringType,
      'Compilers': cybox_common.CompilersType,
      'Tool_Type': cybox_common.ControlledVocabularyStringType,
      'String': cybox_common.ExtractedStringType,
      'Tool': cybox_common.ToolInformationType,
      'Build_Information': cybox_common.BuildInformationType,
      'Tool_Hashes': cybox_common.HashListType,
      'Compiler_Platform_Specification': cybox_common.PlatformSpecificationType,
      'Current_Count': cybox_common.UnsignedIntegerObjectPropertyType,
      'Error_Instances': cybox_common.ErrorInstancesType,
      'Data_Segment': cybox_common.StringObjectPropertyType,
      'Certificate_Subject': cybox_common.StringObjectPropertyType,
      'Language': cybox_common.StringObjectPropertyType,
      'Property': cybox_common.PropertyType,
      'Strings': cybox_common.ExtractedStringsType,
      'File_System_Offset': cybox_common.IntegerObjectPropertyType,
      'Maximum_Count': cybox_common.PositiveIntegerObjectPropertyType,
      'Reference_Description': cybox_common.StructuredTextType,
      'User_Account_Info': cybox_common.ObjectPropertiesType,
      'Configuration_Settings': cybox_common.ConfigurationSettingsType,
      'Simple_Hash_Value': cybox_common.SimpleHashValueType,
      'Byte_String_Value': cybox_common.HexBinaryObjectPropertyType,
      'Instance': cybox_common.ObjectPropertiesType,
      'Import': cybox_common.StringObjectPropertyType,
      'Access_Mask': cybox_common.UnsignedLongObjectPropertyType,
      'Identifier': cybox_common.PlatformIdentifierType,
      'Tool_Specific_Data': cybox_common.ToolSpecificDataType,
      'Execution_Environment': cybox_common.ExecutionEnvironmentType,
      'Search_Distance': cybox_common.IntegerObjectPropertyType,
      'Dependencies': cybox_common.DependenciesType,
      'Offset': cybox_common.IntegerObjectPropertyType,
      'Date': cybox_common.DateRangeType,
      'Hashes': cybox_common.HashListType,
      'Segments': cybox_common.HashSegmentsType,
      'Segment_Count': cybox_common.IntegerObjectPropertyType,
      'Usage_Context_Assumption': cybox_common.StructuredTextType,
      'Block_Hash': cybox_common.FuzzyHashBlockType,
      'Dependency': cybox_common.DependencyType,
      'Error': cybox_common.ErrorType,
      'Trigger_Point': cybox_common.HexBinaryObjectPropertyType,
      'Environment_Variable': cybox_common.EnvironmentVariableType,
      'Byte_Run': cybox_common.ByteRunType,
      'Contributors': cybox_common.PersonnelType,
      'Image_Offset': cybox_common.IntegerObjectPropertyType,
      'Imports': cybox_common.ImportsType,
      'Library': cybox_common.LibraryType,
      'References': cybox_common.ToolReferencesType,
      'Windows_Handle': win_handle_object.WindowsHandleObjectType,
      'Internal_Strings': cybox_common.InternalStringsType,
      'Configuration_Setting': cybox_common.ConfigurationSettingType,
      'Libraries': cybox_common.LibrariesType,
      'Function': cybox_common.StringObjectPropertyType,
      'Handle': win_handle_object.WindowsHandleObjectType,
      'Description': cybox_common.StructuredTextType,
      'Code_Snippet': cybox_common.ObjectPropertiesType,
      'Build_Configuration': cybox_common.BuildConfigurationType,
      'Address': cybox_common.HexBinaryObjectPropertyType,
      'Search_Within': cybox_common.IntegerObjectPropertyType,
      'Segment': cybox_common.HashSegmentType,
      'English_Translation': cybox_common.StringObjectPropertyType,
      'Name': cybox_common.StringObjectPropertyType,
      'Signature_Description': cybox_common.StringObjectPropertyType,
      'Block_Size': cybox_common.IntegerObjectPropertyType,
      'ID': cybox_common.UnsignedIntegerObjectPropertyType,
      'Fuzzy_Hash_Value': cybox_common.FuzzyHashValueType,
      'Data_Size': cybox_common.DataSizeType,
      'Dependency_Description': cybox_common.StructuredTextType,
      'Contributor': cybox_common.ContributorType,
      'Tools': cybox_common.ToolsInformationType,
      'Custom_Properties': cybox_common.CustomPropertiesType,
  }
  
  USAGE_TEXT = """
  Usage: python <Parser>.py [ -s ] <in_xml_file>
  """
  
  def usage():
      print USAGE_TEXT
      sys.exit(1)
  
  def get_root_tag(node):
      tag = Tag_pattern_.match(node.tag).groups()[-1]
      rootClass = GDSClassesMapping.get(tag)
      if rootClass is None:
          rootClass = globals().get(tag)
      return tag, rootClass
  
  def parse(inFileName):
      doc = parsexml_(inFileName)
      rootNode = doc.getroot()
      rootTag, rootClass = get_root_tag(rootNode)
      if rootClass is None:
          rootTag = 'Win_Semaphore'
          rootClass = WindowsSemaphoreObjectType
      rootObj = rootClass.factory()
      rootObj.build(rootNode)
      # Enable Python to collect the space used by the DOM.
      doc = None
  #    sys.stdout.write('<?xml version="1.0" ?>\n')
  #    rootObj.export(sys.stdout.write, 0, name_=rootTag,
  #        namespacedef_='',
  #        pretty_print=True)
      return rootObj
  
  def parseEtree(inFileName):
      doc = parsexml_(inFileName)
      rootNode = doc.getroot()
      rootTag, rootClass = get_root_tag(rootNode)
      if rootClass is None:
          rootTag = 'Win_Semaphore'
          rootClass = WindowsSemaphoreObjectType
      rootObj = rootClass.factory()
      rootObj.build(rootNode)
      # Enable Python to collect the space used by the DOM.
      doc = None
      rootElement = rootObj.to_etree(None, name_=rootTag)
      content = etree_.tostring(rootElement, pretty_print=True,
          xml_declaration=True, encoding="utf-8")
      sys.stdout.write(content)
      sys.stdout.write('\n')
      return rootObj, rootElement
  
  def parseString(inString):
      from StringIO import StringIO
      doc = parsexml_(StringIO(inString))
      rootNode = doc.getroot()
      rootTag, rootClass = get_root_tag(rootNode)
      if rootClass is None:
          rootTag = 'Win_Semaphore'
          rootClass = WindowsSemaphoreObjectType
      rootObj = rootClass.factory()
      rootObj.build(rootNode)
      # Enable Python to collect the space used by the DOM.
      doc = None
  #    sys.stdout.write('<?xml version="1.0" ?>\n')
  #    rootObj.export(sys.stdout.write, 0, name_="Win_Semaphore",
  #        namespacedef_='')
      return rootObj
  
  def main():
      args = sys.argv[1:]
      if len(args) == 1:
          parse(args[0])
      else:
          usage()
  
  if __name__ == '__main__':
      #import pdb; pdb.set_trace()
      main()
  
  __all__ = [
      "WindowsSemaphoreObjectType"
      ]
  