#---------------------------------------------------------------------------*
#
#  @file arxmlmetaparser_syntax.galgas
#
#  @section desc File description
#
#  Syntax for AUTOSAR's arxml's meta-data parsing.
#
#  @section copyright Copyright
#
#  Goil OIL compiler, part of Trampoline RTOS
#
#  Trampoline is copyright (c) CNRS, University of Nantes,
#  Ecole Centrale de Nantes
#  Trampoline is protected by the French intellectual property law.
#
#  This software is distributed under the GNU Public Licence V2.
#  Check the LICENSE file in the root directory of Trampoline
#
#  $Date$
#  $Rev$
#  $Author$
#  $URL$
#
#---------------------------------------------------------------------------*

syntax arxmlmetaparser_syntax (arxmlmetaparser_scanner) {

#------------------------------------------------------------------------------

rule <arxmlmetaparser_start_symbol>
  !@arxmlMetaClassMap iClassMap
  ?@bool create_class_file
{
  @arxmlMetaClassMap classMap = {}
  @arxmlMetaClassGraph classGraph = .emptyGraph

# Parse the file and fill the maps
  <xml_header>
  <xsd_schema> !?classMap !?classGraph

# Add parameters following the Legacy of each classes
  fillLegacy(!?classMap !?classGraph)

# Compute debug files if requested
  if create_class_file then
    # Class file
    @string classString = ""
    [classMap display !?classString]
    [classString writeToFile !"arxml_ecuc_classes.galgas"]

    # Graph file
    let @string graphString = [classGraph graphviz]
    [graphString writeToFile !"arxml_ecuc_graph.dot"]
  end

# Set outputs
  iClassMap = classMap
}

rule <xml_header>
{
  $<?xml$
  <xsd_ignore_attributes>
  $?>$
}

###############################################################################
# Good link to understand the xml's xsd's format :
# http://www.w3schools.com/xml/schema_elements_ref.asp

###############################################################################
## xsd_annotation
##
rule <xsd_annotation>
  ?!@arxmlMetaClassMap classMap
  ?!@arxmlMetaClassGraph classGraph
  ?@lstring parentClass
{
  <xsd_ignore_attributes>
  select $>$
    repeat
    while $<xsd:$
      select $appinfo$
        <xsd_appinfo> !?classMap !?classGraph !parentClass
      or $documentation$
        <xsd_documentation> !?classMap !?classGraph !parentClass
      end
    end
    # End marker
    $</xsd:$
    $annotation$
    $>$
  or $/>$
  end
}

###############################################################################
## xsd_appinfo
##
rule <xsd_appinfo>
  ?!@arxmlMetaClassMap unused classMap
  ?!@arxmlMetaClassGraph unused classGraph
  ?@lstring unused parentClass
{
  <xsd_ignore_attributes>
  select $>$
    # End marker
    $</xsd:$
    $appinfo$
    $>$
  or $/>$
  end
}
###############################################################################
## xsd_attribute
##
rule <xsd_attribute>
  ?!@arxmlMetaClassMap classMap
  ?!@arxmlMetaClassGraph classGraph
  ?@lstring parentClass
{
  lstringhere(?@lstring attributeType !"")
  lstringhere(?@lstring attributeName !"")
  lstringhere(?@lstring attributeRef  !"")
  lstringhere(?@lstring attributePrefix  !"")
  lstringhere(?@lstring attributeUse  !"")

  repeat
  while $ref$
    # Unsed to signal a whitespace will be present after. Unused
    $=$
    $xmlTagValue$ ?attributeRef
  while $type$
    let @lstring fullType
    $=$
    $xmlTagValue$ ?fullType
    # The Type is either "Prefix:Type" or "Type"
    if [fullType.string containsCharacter !':'] then
      let @stringlist parsed = [fullType.string componentsSeparatedByString !":"]
      @string parsedString
      [parsed first ?parsedString]
      attributePrefix.string = parsedString
      attributePrefix.location = fullType.location
      [parsed last ?parsedString]
      attributeType.string = parsedString
      attributeType.location = fullType.location
    else
      attributeType = fullType
    end
  while $name$
    $=$
    $xmlTagValue$ ?attributeName
    attributeName.string = [attributeName.string stringByReplacingStringByString !"<" !""]
    attributeName.string = [attributeName.string stringByReplacingStringByString !">" !""]
  while $use$
    $=$
    $xmlTagValue$ ?attributeUse
  end

  if attributeName.string != "" then
    let @arxmlMetaAttribute newAttribute = @arxmlMetaAttribute.new{
                                                                 !attributeName
                                                                 !attributeType
                                                                 !attributePrefix
                                                                 !attributeUse
                                                               }
    [!?classMap addClassAttribute !parentClass !newAttribute]
  end

  select $>$
    repeat
    while $<xsd:$
      select $annotation$
        <xsd_annotation> !?classMap !?classGraph !parentClass
      or $simpleType$
        <xsd_simpleType> !?classMap !?classGraph !parentClass
      end
    end
    # End marker
    $</xsd:$
    $attribute$
    $>$
  or $/>$
  end
}

###############################################################################
## xsd_attributeGroup
##
rule <xsd_attributeGroup>
  ?!@arxmlMetaClassMap classMap
  ?!@arxmlMetaClassGraph classGraph
  ?@lstring parentClass
{
  # Parse the attributes
  @lstring className
  let @lstring nextParentClass
  select $name$
    # The class does not exists => create it
    $=$
    $xmlTagValue$ ?className            # Get the classname from the file
    className.string = [className.string stringByReplacingStringByString !"<" !""]
    className.string = [className.string stringByReplacingStringByString !">" !""]
    lstringhere(?let @lstring desc !"")     # The description is filled later

    if not [classMap hasKey !className] then
      let @arxmlMetaClass newClass = @arxmlMetaClass.new{
                                                       !className
                                                       !true
                                                       !{} !{}
                                                       !{} !{}
                                                       !desc
                                                     }
      [!?classMap insertKey !className !newClass]
      [!?classGraph addNode !className !className]
    end

    nextParentClass = className
  or $ref$
    $=$
    $xmlTagValue$ ?let @lstring fullClassName
    className = fullClassName
    # The Type is either "Prefix:Type" or "Type"
    if [fullClassName.string containsCharacter !':'] then
      let @stringlist parsed = [fullClassName.string componentsSeparatedByString !":"]
      [parsed last ?let @string parsedString]
      className.string = parsedString
    end

    # Add to the Graph
    if parentClass.string != className.string then
      [!?classGraph addEdge !className !parentClass]
    end

    nextParentClass = parentClass
  end

  select $>$
    repeat
    while $<xsd:$
      select $annotation$
        <xsd_annotation> !?classMap !?classGraph !nextParentClass
      or $attribute$
        <xsd_attribute> !?classMap !?classGraph !nextParentClass
      or $attributeGroup$
        <xsd_attributeGroup> !?classMap !?classGraph !nextParentClass
      or $choice$
        <xsd_choice> !?classMap !?classGraph !nextParentClass
      or $sequence$
        <xsd_sequence> !?classMap !?classGraph !nextParentClass
      end
    end
    # End marker
    $</xsd:$
    $attributeGroup$
    $>$
  or $/>$
  end
}

###############################################################################
## xsd_choice
##
rule <xsd_choice>
  ?!@arxmlMetaClassMap classMap
  ?!@arxmlMetaClassGraph classGraph
  ?@lstring parentClass
{
  <xsd_ignore_attributes>
  select $>$
    repeat
    while $<xsd:$
      select $annotation$
        <xsd_annotation> !?classMap !?classGraph !parentClass
      or $choice$
        <xsd_choice> !?classMap !?classGraph !parentClass
      or $sequence$
        <xsd_sequence> !?classMap !?classGraph !parentClass
      or $element$
        <xsd_element> !?classMap !?classGraph !parentClass
      or $group$
        <xsd_group> !?classMap !?classGraph !parentClass
      end
    end
    # End marker
    $</xsd:$
    $choice$
    $>$
  or $/>$
  end
}

###############################################################################
## xsd_complexType
##
rule <xsd_complexType>
  ?!@arxmlMetaClassMap classMap
  ?!@arxmlMetaClassGraph classGraph
  ?@lstring parentClass
{
  lstringhere(?@lstring complexAbstract !"")
  lstringhere(?@lstring complexMixed !"")
  lstringhere(?@lstring complexName !"")

  repeat
  while $abstract$
    $=$
    $xmlTagValue$ ?complexAbstract
  while $mixed$
    $=$
    $xmlTagValue$ ?complexMixed
  while $name$
    $=$
    $xmlTagValue$ ?complexName
    complexName.string = [complexName.string stringByReplacingStringByString !"<" !""]
    complexName.string = [complexName.string stringByReplacingStringByString !">" !""]
  end

  if complexName.string == "" then
    # The complexType node is inside an element node
    # => We have to create this element's class
    complexName = parentClass
  end

  if not [classMap hasKey !complexName] then
    lstringhere(?let @lstring desc !"")
    let @arxmlMetaClass newClass = @arxmlMetaClass.new{
                                                     !complexName
                                                     !false
                                                     !{} !{}
                                                     !{} !{}
                                                     !desc
                                                   }
    [!?classMap insertKey !complexName !newClass]
    [!?classGraph addNode !complexName !complexName]
  end

  select $>$
    repeat
    while $<xsd:$
      select $annotation$
        <xsd_annotation> !?classMap !?classGraph !complexName
      or $attribute$
        <xsd_attribute> !?classMap !?classGraph !complexName
      or $attributeGroup$
        <xsd_attributeGroup> !?classMap !?classGraph !complexName
      or $choice$
        <xsd_choice> !?classMap !?classGraph !complexName
      or $sequence$
        <xsd_sequence> !?classMap !?classGraph !complexName
      or $group$
        <xsd_group> !?classMap !?classGraph !complexName
      or $simpleContent$
        <xsd_simpleContent> !?classMap !?classGraph !complexName
      end
    end
    # End marker
    $</xsd:$
    $complexType$
    $>$
  or $/>$
  end
}

###############################################################################
## xsd_documentation
##
rule <xsd_documentation>
  ?!@arxmlMetaClassMap unused classMap
  ?!@arxmlMetaClassGraph unused classGraph
  ?@lstring unused parentClass
{
  <xsd_ignore_attributes>
  select $>$
    # TODO : Get the description between '>' and '<'
    # End marker
    $</xsd:$
    $documentation$
    $>$
  or $/>$
  end
}

###############################################################################
## xsd_element
##
rule <xsd_element>
  ?!@arxmlMetaClassMap classMap
  ?!@arxmlMetaClassGraph classGraph
  ?@lstring parentClass
{
  let @arxmlMetaElement newElement
  lstringhere(?@lstring elementType !"")
  lstringhere(?@lstring elementName !"")
  lstringhere(?@lstring elementMin  !"")
  lstringhere(?@lstring elementMax  !"")
  lstringhere(?@lstring elementPrefix  !"")

  repeat
  while $maxOccurs$
    $=$
    $xmlTagValue$ ?elementMax
  while $minOccurs$
    $=$
    $xmlTagValue$ ?elementMin
  while $type$
    let @lstring fullType
    $=$
    $xmlTagValue$ ?fullType
    # The Type is either "Prefix:Type" or "Type"
    if [fullType.string containsCharacter !':'] then
      let @stringlist parsed = [fullType.string componentsSeparatedByString !":"]
      @string parsedString
      [parsed first ?parsedString]
      elementPrefix.string = parsedString
      elementPrefix.location = fullType.location
      [parsed last ?parsedString]
      elementType.string = parsedString
      elementType.location = fullType.location
    else
      elementType = fullType
    end
  while $name$
    $=$
    $xmlTagValue$ ?elementName
    elementName.string = [elementName.string stringByReplacingStringByString !"<" !""]
    elementName.string = [elementName.string stringByReplacingStringByString !">" !""]
  end

  if elementName.string == "" then
    error .here : "An xsd:element must have a name."
  end

  # TODO : We currently don't support the "xsd_choice" statement, so we're not
  # checking the number of elements inside a choice element by setting the min
  # to 0 and max to unbounded if not referenced (instead of 1 as required from
  # xsd).
  if elementMax.string == "" then
    lstringhere(?elementMax !"unbounded")
  end
  if elementMin.string == "" then
    lstringhere(?elementMin !"0")
  end

  if elementType.string == "" then
    elementType = elementName
  else
    [!?classGraph addEdge !elementType !elementName]
  end

  if not [classMap hasKey !elementName] then
    lstringhere(?let @lstring desc !"")
    let @arxmlMetaClass newClass = @arxmlMetaClass.new{
                                                   !elementName
                                                   !false
                                                   !{} !{}
                                                   !{} !{}
                                                   !desc
                                                  }
    [!?classMap insertKey !elementName !newClass]
    [!?classGraph addNode !elementName !elementName]
  end

  newElement = @arxmlMetaElement.new{!elementName
                                 !elementType
                                 !elementMin
                                 !elementMax
                                 !elementPrefix
                                }
  [!?classMap addClassElement !parentClass !newElement]

  select $>$
    repeat
    while $<xsd:$
      select $annotation$
        <xsd_annotation> !?classMap !?classGraph !elementName
      or $complexType$
        <xsd_complexType> !?classMap !?classGraph !elementName
      or $simpleType$
        <xsd_simpleType> !?classMap !?classGraph !elementName
      end
    end
    # End marker
    $</xsd:$
    $element$
    $>$
  or $/>$
  end
}

###############################################################################
## xsd_enumeration
##
rule <xsd_enumeration>
  ?!@arxmlMetaClassMap classMap
  ?!@arxmlMetaClassGraph classGraph
  ?@lstring parentClass
  ?!@arxmlMetaSimpletype restriction
{
  $value$
  $=$
  $xmlTagValue$ ?let @lstring enumValue
  [!?restriction addValue !enumValue]

  select $>$
    repeat
    while $<xsd:$
      $annotation$
      <xsd_annotation> !?classMap !?classGraph !parentClass
    end
    # End marker
    $</xsd:$
    $enumeration$
    $>$
  or $/>$
  end
}

###############################################################################
## xsd_extension
##
rule <xsd_extension>
  ?!@arxmlMetaClassMap classMap
  ?!@arxmlMetaClassGraph classGraph
  ?@lstring parentClass
{
  <xsd_ignore_attributes>

  select $>$
    repeat
    while $<xsd:$
      select $annotation$
        <xsd_annotation> !?classMap !?classGraph !parentClass
      or $attribute$
        <xsd_attribute> !?classMap !?classGraph !parentClass
      or $attributeGroup$
        <xsd_attributeGroup> !?classMap !?classGraph !parentClass
      or $choice$
        <xsd_choice> !?classMap !?classGraph !parentClass
      or $sequence$
        <xsd_sequence> !?classMap !?classGraph !parentClass
      or $group$
        <xsd_group> !?classMap !?classGraph !parentClass
      end
    end
    # End marker
    $</xsd:$
    $extension$
    $>$
  or $/>$
  end
}

###############################################################################
## xsd_group
##
rule <xsd_group>
  ?!@arxmlMetaClassMap classMap
  ?!@arxmlMetaClassGraph classGraph
  ?@lstring parentClass
{
  # Parse the attributes
  @lstring className
  let @lstring nextParentClass
  select $name$
    # The class does not exists => create it
    $=$
    $xmlTagValue$ ?className            # Get the classname from the file
    className.string = [className.string stringByReplacingStringByString !"<" !""]
    className.string = [className.string stringByReplacingStringByString !">" !""]
    lstringhere(?let @lstring desc !"")     # The description is filled later

    if not [classMap hasKey !className] then
      let @arxmlMetaClass newClass = @arxmlMetaClass.new{
                                                     !className
                                                     !false
                                                     !{} !{}
                                                     !{} !{}
                                                     !desc
                                                    }
      [!?classMap insertKey !className !newClass]
      [!?classGraph addNode !className !className]
    end

    nextParentClass = className
  or $ref$
    $=$
    $xmlTagValue$ ?let @lstring fullClassName
    className = fullClassName
    # The Type is either "Prefix:Type" or "Type"
    if [fullClassName.string containsCharacter !':'] then
      let @stringlist parsed = [fullClassName.string componentsSeparatedByString !":"]
      [parsed last ?let @string parsedString]
      className.string = parsedString
    end

    # Add to the Graph
    if parentClass.string != className.string then
      [!?classGraph addEdge !className !parentClass]
    end

    nextParentClass = parentClass
  end

  # End of the attributes
  select $>$
    repeat
    while $<xsd:$
      select $annotation$
        <xsd_annotation> !?classMap !?classGraph !nextParentClass
      or $choice$
        <xsd_choice> !?classMap !?classGraph !nextParentClass
      or $sequence$
        <xsd_sequence> !?classMap !?classGraph !nextParentClass
      or $element$
        <xsd_element> !?classMap !?classGraph !nextParentClass
      end
    end
    # End marker
    $</xsd:$
    $group$
    $>$
  or $/>$
  end
}
###############################################################################
## xsd_import
##
rule <xsd_import>
  ?!@arxmlMetaClassMap classMap
  ?!@arxmlMetaClassGraph classGraph
  ?@lstring parentClass
{
  <xsd_ignore_attributes>
  select $>$
    repeat
    while $<xsd:$
      $annotation$
      <xsd_annotation> !?classMap !?classGraph !parentClass
    end
    # End marker
    $</xsd:$
    $annotation$
    $>$
  or $/>$
  end
}

###############################################################################
## xsd_restriction
##
rule <xsd_restriction>
  ?!@arxmlMetaClassMap classMap
  ?!@arxmlMetaClassGraph classGraph
  ?@lstring parentClass
  ?!@arxmlMetaSimpletype restriction
{
  $base$
  $=$
  $xmlTagValue$ ?let @lstring baseType

  if "xsd:string"  == baseType.string
  || "xsd:NMTOKEN" == baseType.string
  || "xsd:NMTOKENS" == baseType.string then
    [!?restriction setBase !.restrictionString]
    [!?restriction setType !.restrictionSimple]
  elsif "xsd:unsignedInt" == baseType.string then
    [!?restriction setBase !.restrictionUint]
    [!?restriction setType !.restrictionSimple]
  elsif "xsd:double" == baseType.string then
    [!?restriction setBase !.restrictionDouble]
    [!?restriction setType !.restrictionSimple]
  else
    error .here : "Undefined/unimplemented base type " + baseType.string
  end

  select $>$
    repeat
    while $<xsd:$
      select $annotation$
        <xsd_annotation> !?classMap !?classGraph !parentClass
      or $attribute$
        $TODO$
        <xsd_attribute> !?classMap !?classGraph !parentClass
        [!?restriction setType !.restrictionUnused]
      or $attributeGroup$
        $TODO$
        <xsd_attributeGroup> !?classMap !?classGraph !parentClass
        [!?restriction setType !.restrictionUnused]
      or $choice$
        $TODO$
        <xsd_choice> !?classMap !?classGraph !parentClass
        [!?restriction setType !.restrictionUnused]
      or $sequence$
        $TODO$
        <xsd_sequence> !?classMap !?classGraph !parentClass
        [!?restriction setType !.restrictionUnused]
      or $group$
        $TODO$
        <xsd_group> !?classMap !?classGraph !parentClass
        [!?restriction setType !.restrictionUnused]
      or $simpleType$
        <xsd_simpleType> !?classMap !?classGraph !parentClass
        [!?restriction setType !.restrictionUnused]
      or $whiteSpace$
        # Asks a string to keep the whitespaces. Ignored.
        if not [[restriction type] isRestrictionSimple]
        && not [[restriction base] isRestrictionString] then
          error .here : "Pattern condition to something not a string."
        end
        <xsd_whiteSpace> !?classMap !?classGraph !parentClass
      or $maxLength$
        # Gives a limit to a string. Ignored
        if not [[restriction type] isRestrictionSimple]
        && not [[restriction base] isRestrictionString] then
          error .here : "Pattern condition to something not a string."
        end
        <xsd_maxLength> !?classMap !?classGraph !parentClass
      or $pattern$
        # Gives a condition to a string. Ignored.
        if not [[restriction type] isRestrictionSimple]
        && not [[restriction base] isRestrictionString] then
          error .here : "Pattern condition to something not a string."
        end
        <xsd_pattern> !?classMap !?classGraph !parentClass
      or $enumeration$
        if not [[restriction type] isRestrictionEnum]
        && not [[restriction type] isRestrictionSimple] then
          error .here : "Multiple type in a same restriction."
        end
        if not [[restriction base] isRestrictionString] then
          error .here : "Enumeration while restriction base not set to string."
        end
        <xsd_enumeration> !?classMap !?classGraph !parentClass !?restriction
        [!?restriction setType !.restrictionEnum]
      end
    end
    # End marker
    $</xsd:$
    $restriction$
    $>$
  or $/>$
  end
}

###############################################################################
## xsd_schema
##
rule <xsd_schema>
  ?!@arxmlMetaClassMap classMap
  ?!@arxmlMetaClassGraph classGraph
{
  $<xsd:$
  $schema$
  <xsd_ignore_attributes>
  $>$

  # We create here the root class. It is required because AUTOSAR defines
  # a global variable for its main node "AUTOSAR". Basically we're going to put
  # only the AUTOSAR node in this root class and give the root class definition
  # as an output at the end of the parsing.
  lstringhere(?let @lstring rootClassName !"root")
  lstringhere(?let @lstring desc !"Root class containing the main AUTOSAR node")

  let @arxmlMetaClass rootClass = @arxmlMetaClass.new{
                                                      !rootClassName
                                                      !false
                                                      !{} !{}
                                                      !{} !{}
                                                      !desc
                                                     }
  [!?classMap insertKey !rootClassName !rootClass]
  [!?classGraph addNode !rootClassName !rootClassName]

  repeat
  while $<xsd:$
    select $annotation$     #TODO see xsd:documentation
      <xsd_annotation> !?classMap !?classGraph !rootClassName
    or $attribute$
      <xsd_attribute> !?classMap !?classGraph !rootClassName
    or $attributeGroup$
      <xsd_attributeGroup> !?classMap !?classGraph !rootClassName
    or $complexType$
      <xsd_complexType> !?classMap !?classGraph !rootClassName
    or $element$
      <xsd_element> !?classMap !?classGraph !rootClassName
    or $group$
      <xsd_group> !?classMap !?classGraph !rootClassName
    or $import$             #Unused
      <xsd_import> !?classMap !?classGraph !rootClassName
    or $simpleType$
      <xsd_simpleType> !?classMap !?classGraph !rootClassName
    end
  end

  # End marker
  $</xsd:$
  $schema$
  $>$

}

###############################################################################
## xsd_sequence
##
rule <xsd_sequence>
  ?!@arxmlMetaClassMap classMap
  ?!@arxmlMetaClassGraph classGraph
  ?@lstring parentClass
{
  select $>$
    repeat
    while $<xsd:$
      select $annotation$
        <xsd_annotation> !?classMap !?classGraph !parentClass
      or $choice$
        <xsd_choice> !?classMap !?classGraph !parentClass
      or $sequence$
        <xsd_sequence> !?classMap !?classGraph !parentClass
      or $element$
        <xsd_element> !?classMap !?classGraph !parentClass
      or $group$
        <xsd_group> !?classMap !?classGraph !parentClass
      end
    end
    # End marker
    $</xsd:$
    $sequence$
    $>$
  or $/>$
  end
}

###############################################################################
## xsd_simpleContent
## restriction is never called by the simpleContent in AUTOSAR
rule <xsd_simpleContent>
  ?!@arxmlMetaClassMap classMap
  ?!@arxmlMetaClassGraph classGraph
  ?@lstring parentClass
{
  #lstringhere(?@lstring typeName !"")
  #@arxmlMetaSimpletype restriction = @arxmlMetaSimpletype.new{
  #                                                    !typeName
  #                                                    !.restrictionUnused
  #                                                    !.restrictionUndef
  #                                                    !{}
  #                                                   }

  select $>$
    repeat
    while $<xsd:$
      select $annotation$
        <xsd_annotation> !?classMap !?classGraph !parentClass
      or $extension$
        <xsd_extension> !?classMap !?classGraph !parentClass
  #    or $restriction$
  #      <xsd_restriction> !?classMap !?classGraph !parentClass !?restriction
      end
    end
    # End marker
    $</xsd:$
    $simpleContent$
    $>$
  or $/>$
  end
}

###############################################################################
## xsd_simpleType
##
rule <xsd_simpleType>
  ?!@arxmlMetaClassMap classMap
  ?!@arxmlMetaClassGraph classGraph
  ?@lstring parentClass
{
  # TODO : The case when the simpletype is not called by xsd:schema is not
  #        treated (never happens in AUTOSAR).
  lstringhere(?@lstring typeName !"")

  repeat
  while $name$
    $=$
    $xmlTagValue$ ?typeName
    typeName.string = [typeName.string stringByReplacingStringByString !"<" !""]
    typeName.string = [typeName.string stringByReplacingStringByString !">" !""]
  end

  if parentClass.string == "root" && typeName.string == "" then
    error .here : "The name attribute is required if the simpleType element is"
                + " a child of the schema element"
  end

  @arxmlMetaSimpletype restriction = @arxmlMetaSimpletype.new{
                                                      !typeName
                                                      !.restrictionUnused
                                                      !.restrictionUndef
                                                      !{}
                                                     }

  if not [classMap hasKey !typeName] then
    lstringhere(?let @lstring desc !"")
    let @arxmlMetaClass newClass = @arxmlMetaClass.new{
                                                   !typeName
                                                   !false
                                                   !{} !{}
                                                   !{} !{}
                                                   !desc
                                                  }
    [!?classMap insertKey !typeName !newClass]
    [!?classGraph addNode !typeName !typeName]
  end

  select $>$
    repeat
    while $<xsd:$
      select $annotation$
        <xsd_annotation> !?classMap !?classGraph !typeName
      or $restriction$
        <xsd_restriction> !?classMap !?classGraph !typeName !?restriction
      end
    end
    # End marker
    $</xsd:$
    $simpleType$
    $>$
  or $/>$
  end

  #[!?classMap insertKey !typeName !restriction]
  #[!?classGraph addNode !typeName !typeName]
}

###############################################################################
## xsd_maxLength
##        This forces the string to have a character number limit
##        It is actually ignored.
rule <xsd_maxLength>
  ?!@arxmlMetaClassMap classMap
  ?!@arxmlMetaClassGraph classGraph
  ?@lstring parentClass
{
  <xsd_ignore_attributes>
  select $>$
    repeat
    while $<xsd:$
      $annotation$
      <xsd_annotation> !?classMap !?classGraph !parentClass
    end
    # End marker
    $</xsd:$
    $maxLength$
    $>$
  or $/>$
  end
}

###############################################################################
## xsd_pattern
##        This forces a pattern for a string.
##        Ex : Forces ADDRESS--SIMPLE's string to be written as "0x[0-9][a-z]"
##        It is actually ignored.
rule <xsd_pattern>
  ?!@arxmlMetaClassMap classMap
  ?!@arxmlMetaClassGraph classGraph
  ?@lstring parentClass
{
  <xsd_ignore_attributes>
  select $>$
    repeat
    while $<xsd:$
      $annotation$
      <xsd_annotation> !?classMap !?classGraph !parentClass
    end
    # End marker
    $</xsd:$
    $pattern$
    $>$
  or $/>$
  end
}

###############################################################################
## xsd_whiteSpace
##        This forces the string to not ignore the white spaces
##        It is actually ignored.
rule <xsd_whiteSpace>
  ?!@arxmlMetaClassMap classMap
  ?!@arxmlMetaClassGraph classGraph
  ?@lstring parentClass
{
  <xsd_ignore_attributes>
  select $>$
    repeat
    while $<xsd:$
      $annotation$
      <xsd_annotation> !?classMap !?classGraph !parentClass
    end
    # End marker
    $</xsd:$
    $whiteSpace$
    $>$
  or $/>$
  end
}

rule <xsd_ignore_attributes>
{
  repeat
  while $abstract$
    $=$
    $xmlTagValue$ ?*
  while $attributeFormDefault$
    $=$
    $xmlTagValue$ ?*
  while $attributeRef$
    $=$
    $xmlTagValue$ ?*
  while $base$
    $=$
    $xmlTagValue$ ?*
  while $category$
    $=$
    $xmlTagValue$ ?*
  while $CATEGORY$
    $=$
    $xmlTagValue$ ?*
  while $color$
    $=$
    $xmlTagValue$ ?*
  while $customType$
    $=$
    $xmlTagValue$ ?*
  while $elementFormDefault$
    $=$
    $xmlTagValue$ ?*
  while $encoding$
    $=$
    $xmlTagValue$ ?*
  while $enforceMinMultiplicity$
    $=$
    $xmlTagValue$ ?*
  while $globalElement$
    $=$
    $xmlTagValue$ ?*
  while $id$
    $=$
    $xmlTagValue$ ?*
  while $latestBindingTime$
    $=$
    $xmlTagValue$ ?*
  while $maxOccurs$
    $=$
    $xmlTagValue$ ?*
  while $minOccurs$
    $=$
    $xmlTagValue$ ?*
  while $mixed$
    $=$
    $xmlTagValue$ ?*
  while $name$
    $=$
    $xmlTagValue$ ?*
  while $namePlural$
    $=$
    $xmlTagValue$ ?*
  while $namespace$
    $=$
    $xmlTagValue$ ?*
  while $noteType$
    $=$
    $xmlTagValue$ ?*
  while $nsPrefix$
    $=$
    $xmlTagValue$ ?*
  while $qualifiedName$
    $=$
    $xmlTagValue$ ?*
  while $recommendedPackage$
    $=$
    $xmlTagValue$ ?*
  while $ref$
    $=$
    $xmlTagValue$ ?*
  while $roleElement$
    $=$
    $xmlTagValue$ ?*
  while $roleWrapperElement$
    $=$
    $xmlTagValue$ ?*
  while $schemaLocation$
    $=$
    $xmlTagValue$ ?*
  while $sequenceOffset$
    $=$
    $xmlTagValue$ ?*
  while $source$
    $=$
    $xmlTagValue$ ?*
  while $Splitkey$
    $=$
    $xmlTagValue$ ?*
  while $Status$
    $=$
    $xmlTagValue$ ?*
  while $StatusRevisionBegin$
    $=$
    $xmlTagValue$ ?*
  while $targetNamespace$
    $=$
    $xmlTagValue$ ?*
  while $type$
    $=$
    $xmlTagValue$ ?*
  while $typeElement$
    $=$
    $xmlTagValue$ ?*
  while $typeWrapperElement$
    $=$
    $xmlTagValue$ ?*
  while $use$
    $=$
    $xmlTagValue$ ?*
  while $value$
    $=$
    $xmlTagValue$ ?*
  while $version$
    $=$
    $xmlTagValue$ ?*
  while $xmlns:AR$
    $=$
    $xmlTagValue$ ?*
  while $xmlns:xsd$
    $=$
    $xmlTagValue$ ?*
  end
}

#------------------------------------------------------------------------------

}

proc lstringhere
  !@lstring string
  ?@string  value
{
  string = @lstring.new{!value !@location.here{}}
}

proc fillLegacy
  ?!@arxmlMetaClassMap classMap
  ?!@arxmlMetaClassGraph classGraph
{
  let @stringlist sortedInfoList = [classGraph keyList]

  for (@string sClassName) in sortedInfoList do
    lstringhere(?let @lstring lClassName !sClassName)
    @arxmlMetaClass lClass
    [classMap searchKey !lClassName ?lClass]

    # Get successors
    @lstringlist fromList = {}
    [!?fromList insertAtIndex ![lClass name] !0]
    let @stringset empty = .emptySet
    let @lstringlist successorList = [classGraph accessibleNodesFrom !fromList !empty]

    # Add this class's elements and attributes to each of the successors class
    [!?lClass legacyAddParameters !?classMap !successorList]
  end
}