/******************************************************************************
* Copyright (c) 2004, 2014  Ericsson AB
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
*   Zoltan Jasz - initial implementation and initial documentation
*   Abhishek Gupta
*   Attila Balasko
*   Endre Kulcsar
*   Gabor Bettesch
*   Gabor Szalai
*   Janos Kovesdi
*   Sandor Palugyai
*   Tibor Csondes
******************************************************************************/
//
//  File:          XSD.ttcn
//  Rev:           R9A
//  Prodnr:        CNL 113 368
//
////////////////////////////////////////////////////////////////////////////////
module XSD {

import from UsefulTtcn3Types all;

//These constants are used in the XSD date/time type definitions
const charstring
  dash := "-",
  cln  := ":",
  year := "(0(0(0[1-9]|[1-9][0-9])|[1-9][0-9][0-9])|[1-9][0-9][0-9][0-9])",
  yearExpansion := "(-([1-9][0-9]#(0,))#(,1))#(,1)",
  month := "(0[1-9]|1[0-2])",
  dayOfMonth := "(0[1-9]|[12][0-9]|3[01])",
  hour := "([01][0-9]|2[0-3])",
  minute := "([0-5][0-9])",
  second := "([0-5][0-9])",
  sFraction := "(.[0-9]#(1,))#(,1)",
  endOfDayExt := "24:00:00(.0#(1,))#(,1)",
  nums := "[0-9]#(1,)",
  ZorTimeZoneExt := "(Z|[+-]((0[0-9]|1[0-3]):[0-5][0-9]|14:00))#(,1)",
  durTime := "(T[0-9]#(1,)"&
             "(H([0-9]#(1,)(M([0-9]#(1,)(S|.[0-9]#(1,)S))#(,1)|.[0-9]#(1,)S|S))#(,1)|"&
             "M([0-9]#(1,)(S|.[0-9]#(1,)S)|.[0-9]#(1,)M)#(,1)|"&
             "S|"&
             ".[0-9]#(1,)S))"

//anySimpleType

type XMLCompatibleString AnySimpleType
with {
variant "XSD:anySimpleType";
};

//anyType;

type record AnyType
{
	record of String attr,
	record of String elem_list
}
with {
variant "XSD:anyType";
variant (attr) "anyAttributes";
variant (elem_list) "anyElement";
};
// String types

type XMLCompatibleString String
with {
variant "XSD:string";
};

type XMLStringWithNoCRLFHT NormalizedString
with {
variant "XSD:normalizedString";
};

type NormalizedString Token
with {
variant "XSD:token";
};

type XMLStringWithNoWhitespace Name
with {
variant "XSD:Name";
};

type XMLStringWithNoWhitespace NMTOKEN
with {
variant "XSD:NMTOKEN";
};

type Name NCName
with {
variant "XSD:NCName";
};

type NCName ID
with {
variant "XSD:ID";
};

type NCName IDREF
with {
variant "XSD:IDREF";
};

type NCName ENTITY
with {
variant "XSD:ENTITY";
};

type octetstring HexBinary
with {
variant "XSD:hexBinary";
};

type octetstring Base64Binary
with {
variant "XSD:base64Binary";
};

type XMLStringWithNoCRLFHT AnyURI
with {
variant "XSD:anyURI";
};

type charstring Language (pattern "[a-zA-Z]#(1,8)(-\w#(1,8))#(0,)")
with {
variant "XSD:language";
};
// Integer types

type integer Integer
with {
variant "XSD:integer";
};

type integer PositiveInteger (1 .. infinity)
with {
variant "XSD:positiveInteger";
};

type integer NonPositiveInteger (-infinity .. 0)
with {
variant "XSD:nonPositiveInteger";
};

type integer NegativeInteger (-infinity .. -1)
with {
variant "XSD:negativeInteger";
};

type integer NonNegativeInteger (0 .. infinity)
with {
variant "XSD:nonNegativeInteger";
};

type longlong Long
with {
variant "XSD:long";
};

type unsignedlonglong UnsignedLong
with {
variant "XSD:unsignedLong";
};

type long Int
with {
variant "XSD:int";
};

type unsignedlong UnsignedInt
with {
variant "XSD:unsignedInt";
};

type short Short
with {
variant "XSD:short";
};

type unsignedshort UnsignedShort
with {
variant "XSD:unsignedShort";
};

type byte Byte
with {
variant "XSD:byte";
};

type unsignedbyte UnsignedByte
with {
variant "XSD:unsignedByte";
};

// Float types

type float Decimal
with {
variant "XSD:decimal";
};

type IEEE754float Float
with {
variant "XSD:float";
};

type IEEE754double Double
with {
variant "XSD:double";
};

// Time types

type charstring Duration (pattern
  "{dash}#(,1)P({nums}(Y({nums}(M({nums}D{durTime}#(,1)|{durTime}#(,1))|D{durTime}#(,1))|" &
  "{durTime}#(,1))|M({nums}D{durTime}#(,1)|{durTime}#(,1))|D{durTime}#(,1))|{durTime})")
with {
variant "XSD:duration";
};

type charstring DateTime (pattern
  "{yearExpansion}{year}{dash}{month}{dash}{dayOfMonth}T({hour}{cln}{minute}{cln}{second}" &
 "{sFraction}|{endOfDayExt}){ZorTimeZoneExt}" )
with {
variant "XSD:dateTime";
};

type charstring Time (pattern
  "({hour}{cln}{minute}{cln}{second}{sFraction}|{endOfDayExt}){ZorTimeZoneExt}" )
with {
variant "XSD:time";
};

type charstring Date (pattern
  "{yearExpansion}{year}{dash}{month}{dash}{dayOfMonth}{ZorTimeZoneExt}" )
with {
variant "XSD:date";
};

type charstring GYearMonth (pattern
  "{yearExpansion}{year}{dash}{month}{ZorTimeZoneExt}" )
with {
variant "XSD:gYearMonth";
};

type charstring GYear (pattern
  "{yearExpansion}{year}{ZorTimeZoneExt}" )
with {
variant "XSD:gYear";
};

type charstring GMonthDay (pattern
 "{dash}{dash}{month}{dash}{dayOfMonth}{ZorTimeZoneExt}" )
with {
variant "XSD:gMonthDay";
};

type charstring GDay (pattern
  "{dash}{dash}{dash}{dayOfMonth}{ZorTimeZoneExt}" )
with {
variant "XSD:gDay";
};

type charstring GMonth (pattern
  "{dash}{dash}{month}{ZorTimeZoneExt}" )
with {
variant "XSD:gMonth";
};

// Sequence types

type record of NMTOKEN NMTOKENS
with {
variant "XSD:NMTOKENS";
};

type record of IDREF IDREFS
with {
variant "XSD:IDREFS";
};

type record of ENTITY ENTITIES
with {
variant "XSD:ENTITIES";
};

type record QName
{
	AnyURI uri  optional,
	NCName name
}
with {
variant "XSD:QName";
};

// Boolean type

type boolean Boolean
with {
variant "XSD:boolean";
};

//TTCN-3 type definitions supporting the mapping of W3C XML Schema built-in datatypes

type utf8string XMLCompatibleString
(
	char(0,0,0,9)..char(0,0,0,9),
	char(0,0,0,10)..char(0,0,0,10),
	char(0,0,0,12)..char(0,0,0,12),
  	char(0,0,0,32)..char(0,0,215,255),
  	char(0,0,224,0)..char(0,0,255,253),
  	char(0,1,0,0)..char(0,16,255,253)
)

type utf8string XMLStringWithNoWhitespace
(
	char(0,0,0,33)..char(0,0,215,255),
  	char(0,0,224,0)..char(0,0,255,253),
  	char(0,1,0,0)..char(0,16,255,253)
)

type utf8string XMLStringWithNoCRLFHT
(
	char(0,0,0,32)..char(0,0,215,255),
 	char(0,0,224,0)..char(0,0,255,253),
  	char(0,1,0,0)..char(0,16,255,253)
)

}
with{
encode "XML"
}