//<title Lex Schemas>
//<toctitle LexSchemas>
//<keywords lexClass>
//
// Summary:
//  *   Lex class description *
//
//  <B>lexClass</B> object is a block of text with defined begin and end sequence;
//  for which can be specified some font and colors attributes.
//  One lex class can contain others inside itself;
//  also it can have some relations to other classes.
//
//  lex schema is defined as a set of lexClasses.
//  It contains a root class with parent type 'file'
//  (which defines a files extensions to apply this schema to,
//  and some global schema attributes).
//
//  - Lex schemes -
//
//  Lex schemes are defined in *.schclass files.
//  Lex class properties (attributes) can be compound, like:
//  <P><C>parent:dyn, previous:tag:separators.</C>
//
//  - Multiple values -
//
//  For multiple value properties the following syntax is allowed:
//
//  <P><C>  propertyX = value1, value2, value3, .... </C>
//  <P><C>  propertyX = valueA1, valueA2, ... </C>
//  <P><C>  propertyX = valueN1 </C>
//  <P><C>  propertyX = valueN2 </C>
//  <P><C>          .... </C>
//
//  - String values -
//
//  String(character) values are defined in single quotation marks:
//  <P>'stringValue'<P>
//  There are a few special chars (as in C++):
//  <P>'\\', '\'', '\t', '\r', '\n'
//
//  And predefined constants:
//
//  <P><C> @alpha   = a-z, A-Z </C>
//  <P><C> @digit   = 0-9 </C>
//  <P><C> @HexDdigit = 0-9, a-f, A-F </C>
//  <P><C> @specs   = ~!@#$%^&*()_-+=\|{}[];:'",.<>/? </C>
//  <P><C> @EOL     = End Of Line </C>
//
//  <P><P>NOT operation supported for constants comparisons,
//  <P>like: <C> @alpha:not </C>
//
//  - Comments -
//  <B> <COLOR 00c000> // </COLOR> </B>
//  <P>Two slashes are used to define a single line comment in Lex schema files.
//  (same as in C++)
//
//  - Lex Class Section -
//  <P>
//  <B>lexClass:</B>
//  <P>This keyword begins a lex class section.
//
//  - name \- Property (required) -
//
//  Define a lexClass name. Must be unique withing same lex schema (*.schclass file).
//  <PRE>
//  lexClass:
//      name = c_CPPString
//  </PRE>
// <P>
//
//  - parent \- Property (required) -
//
//  <B>parent </B>
//  <P>Defines a direct parent of lex class. (parent class name)
//
//  <P><B>parent:dyn</B>
//  <P>Defines a dynamic parent of lex class. (parent class name)
//  Dynamic means that parent class can be not only direct parent,
//  but parent of its parent [of parent ...] until the top class/block.
//
//  <P><B>parent:file</B>
//  <P>Defines a top schema class. (as file extensions list <*.ext1|*.ext2>)
//  <P>
//  <P>Only one of mentioned above 'parent' properties can be used for each class.
//
//  <PRE>
//  parent:file = <*.c|*.cpp|*.h|*.inl|*.tli|*.tlh|*.rc|*.rc2>
//  parent      = c_CPP
//  parent:dyn  = c_CPP
//  </PRE>
//
//  - children \- Property (optional) -
//
//  <B>children</B>
//  <P>Defines an allowed direct children for lex class
//  (as comma separated class names or zero to restrict any child).
//
//  <P>Parent-child relation is defined by 'parent' property.  This property helps
//  to restrict create parent-child relation for classes other than specified
//  or define that class has no children.
//
//  <PRE>
//  children = 0 // has no children
//  children = class1, class2, ...
//  </PRE>
//
//  - RecurrenceDepth \- Property  (optional) -
//
//  <B>RecurrenceDepth</B>
//  <P>Defines maximum depth of nested classes (blocks).
//  <P>(as a number, default value 1).
//  <P>
//  <P>Class A can be parent for class B. And Class B can be parent for class A.
//  Possible situation when A=B. (for example '{}' block in C++)
//  This property defines maximum depth of A->B->A->B->... nested construction.
//
//  <PRE>
//  RecurrenceDepth = 32
//  </PRE>
//
//  - previous \- Property (optional) -
//
//  'previous' property used to set condition to start lex class as previous
//  tag or class. The difference from 'start' property that objects specified
//  in this property is not included in class(block).
//  Can be used alone or together with 'start' property.
//
//  <P><B>previous:class</B>
//  <P>This class is started only if previous determined class name in collection
//  specified in this property.
//  <P>(as one or more class names)
//
//  <P><B>previous:tag</B>
//  <P>This class is started only if start condition is true and previous tag is
//  in collection specified in this property.
//  <P>(as one or more tags)
//
//  <P><B>previous:tag:separators</B>
//  <P>separators set for previous:tag values.
//
//  <P>Previous 'tag' and 'class' conditions can be specified separately or together.
//
//  <PRE>
//  previous:class  = c_HTMLelement_SCRIPT_lang_VB, c_HTMLelement_SCRIPT_lang_JS
//  previous:tag            = '='
//  previous:tag:separators = ' ', '\t', @eol
//  </PRE>
//
//  - start \- Property  (optional) -
//
//  'start' property used to set condition to start lex class as tag or class.
//  The difference from 'previous' property that objects specified in this
//  property is included in class(block).
//  <P>Can be used alone or together with 'previous' property.
//
//  <P><B>start:class</B>
//  <P>This class is started only if previous determined class name in collection
//  specified in this property.
//  <P>(as one or more class names)
//
//  <P><B>start:Tag</B>
//  <P>This class is started if current tag is in collection specified in this property.
//  <P>(as one or more tags)
//
//  <P>Start 'tag' and 'class' conditions can be specified separately or together.
//
//  - end \- Property (optional) -
//
//  'end' property used to set end lex class condition as tag or class.
//
//  <P><B>end:class</B>
//  <P>This class is ended if previous determined class name in collection
//  specified in this property.
//  <P>(as one or more class names)
//
//  <P><B>end:Tag</B>
//  <P>This class is ended if current tag is in collection specified in this property.
//  <P>(as one or more tags)
//
//  <P><B>end:separators</B>
//  <P>This class is ended if tag after current position is in collection specified
//  in this property. Difference from end:Tag is that end:Tag specify tags before
//  current position and end:Tag included in this block but end:separators not
//  included.
//  <P>(as one or more tags)
//
//  <P>End 'class', 'tag' and 'separators' conditions can be specified separately or together.
//
//  - skip \- Property  (optional) -
//
//  <B>skip:Tag</B>
//  <P>Used to skip some tags from parsing. Useful to support special tags
//  part of which can be a begin of end tag.
//  <P>(as one or more tags)
//
//  <PRE>
//  EXAMPLES (for start, end, skip):
//
//  start:Tag   ='/*'
//  end:Tag     ='*/'
//
//  //-------------------------------------------
//  start:Tag       = '"'
//  skip:Tag        = '\\"', '\\\r\n', '\\\n\r', '\\\n', '\\\r'
//  end:Tag         = '"', @eol
//
//  //-------------------------------------------
//  start:tag   = @alpha
//  skip:tag    = @digit
//  end:separators = @alpha:not
//
//  //-------------------------------------------
//  start:CLASS = c_CPPAfxInsertBlock_Start
//  end:CLASS   = c_CPPAfxInsertBlock_End
//  </PRE>
//
//  - token \- Property  (optional) -
//
//  'token' property is used to set lex class as some token(s).
//  It could be useful to define keywords.
//  Can be used alone or together with 'previous' property.
//  It must not be used together with 'start'-'end' condition.
//
//  <P><B>token:tag</B>
//  <P>This class is a word from this collection.
//  <P>(as one or more tags)
//
//  <P><B>Token:start:separators</B>
//  <P>Start separators set for token:tag values.
//
//  <P><B>Token:end:separators</B>
//  <P>End separators set for token:tag values.
//
//  <P>Token 'tag' is main condition. Token 'separators' additional conditions.
//  <P>'separators' without 'tag' have no sense.
//
//  <PRE>
//  token:start:separators  = ' ', '\t', '<%=', '<%', @specs, @eol
//  token:end:separators    = ' ', '\t', '%>', @specs, @eol
//
//  token:tag = 'if', 'for', 'while', 'do'
//  token:tag = 'break'
//  token:tag = 'case'
//  token:tag = 'catch'
//  </PRE>
//  <P>
//
//  * TEXT Attributes *
//
//  txt:XXX defines a few text properties for lex class (block of text).
//  All of them are optional and if some text attribute is not specified -
//  it is inherited from parent class or set to default value for a top (file) lex class.
//
//  <P><B>txt:colorFG</B>
//      <P>Fore color value in hex format (like 0xffc0c0).
//      <P>default: black
//
//  <P><B>txt:colorBK</B>
//      <P>Background color value in hex format (like 0xffFFff).
//      <P>default: white
//
//  <P><B>txt:colorSelFG</B>
//      <P>Selected text fore color value in hex format (like 0xffFFff).
//      <P>default: white
//
//  <P><B>txt:colorSelBK</B>
//      <P>Selected text background color value in hex format (like 0xab0077).
//      <P>default: black
//
//  <P><B>txt:Bold</B>
//      <P>Bold font attribute. Values {1, 0}
//      <P>default: 0
//
//  <P><B>txt:Italic</B>
//      <P>Italic font attribute. Values {1, 0}
//      <P>default: 0
//
//  <P><B>txt:Underline</B>
//      <P>Underline font attribute. Values {1, 0}
//      <P>default: 0
//
//  <PRE>
//  txt:colorFG = 0x0fc0c0
//  txt:colorBK = 0xffffff
//
//  txt:colorSelFG  = 0xffffff
//  txt:colorSelBK  = 0x0fc0c0
//
//  txt:Bold    = 1
//  txt:Italic  = 0
//  txt:Underline = 1
//  </PRE>
//
//  * caseSensitive \- Property  (optional) *
//
//  <B>caseSensitive</B>
//  <P>Define compare method for this lex class tags: case sensitive or insensitive.
//  <P>Inheritable from parent class.
//  <P>Values {1, 0}
//  <P>default: 0
//
//  * Collapsable \- Property  (optional) *
//
//  <B>Collapsable</B>
//  <P>Define is this block Collapsable or not. Inheritable from parent class.
//  <P>Values {1, 0}
//  <P>default: 0
//
//  * CollapsedText \- Property  (optional) *
//
//  <B>CollapsedText</B>
//  <P>Collapsed block string (as quoted string value).
//  <P>default: '[..]'
//
//  * ParseOnScreen \- Property  (optional) *
//
//  <B>ParseOnScreen</B>
//  <P>Values {1, 0}
//  <P>default: 0
//  <P>If set to 1 - lex class will be parsed only before drawing on the screen in
//  the main thread. Useful for keywords and other single line text blocks, which
//  are parsed very fast.
//
//  - \*\*\* Global attributes \*\*\* -
//
//  'global' attributes let to adjust some common parser parameters for each
//  lex schema separately. They can be used only in top layer lex class
//  (parent type file).
//
//  <P><B>global:FirstParseInSeparateThread</B>
//  <P>Values {1, 0}
//  <P>default: 1
//  <P>Define is first parse (when file opening) will run in the main or
//  additional thread.
//
//  <P><B>global:EditReparceInSeparateThread</B>
//  <P>Values {1, 0}
//  <P>default: 1
//  <P>Define is reparse after text edited will run in the main or
//  additional thread.
//
//  <P><B>global:ConfigChangedReparceInSeparateThread</B>
//  <P>Values {1, 0}
//  <P>default: 1
//  <P>Define is reparse text after schema file (*.schclass) will run
//  in the main or additional thread.
//
//  <P><B>global:EditReparceTimeout_ms</B>
//  <P>as time in milliseconds;
//  <P>default: 500
//  <P>Time out to start reparse after last key was pressed.
//
//  <P><B>global:MaxBackParseOffset</B>
//  <P>as number (chars);
//  <P>default: 100
//  <P>Some times parser look back for the text from current position.
//  This parameter define maximum back buffer size.
//
//  <P><B>global:OnScreenSchCacheLifeTime_sec</B>
//  <P>as time in seconds; -1 and 0 means infinite;
//  <P>default= 180
//  <P>When piece of text is displayed, edit control run parser to parse
//  lexClasses with 'ParseOnScreen' attribute set and cache this
//  information to do not run parser every time for this lines. For each
//  entry in this cache last access time is stored.
//  This parameter define time period from last access time after which
//  cached entries will be removed (for memory using optimization).
//
//  <P><B>global:ParserThreadIdleLifeTime_sec</B>
//  <P>as time in seconds; -1 and 0 means infinite;
//  <P>default: 60
//  <P>Idle time out for parser thread. If no parse requests (no editing operations)
//  additional parser thread will be exited. It will be recreated again
//  when necessary (to system resources optimization).