>>>> Integral Type Syntax
    <assignment> :
    <axis_id> :               <nrwunits>|<string>
    <bin> :                   Bin|Bin(<bin_id>)   // Bin means bin as per test object, Bin(Undefined) is the same as not binning
    <boolexpr> :
    <compound_statement> :    {<statement>*}
    <conditional_statement> : if (<boolexpr>) <statement>|<compound_statement>
    <datatype> :              Bool|Category|DCLevels|Integer|MathExpr|NrwUnits|PatternBurstSelector|SignalGroup|String|Timing
    <condition_name> :        <id>
    <hardware_bin> :          <integer>
    <id> :                    [a-zA-Z][a-zA-Z0-9_]*
    <integer> :
    <mathexpr> :
    <modifier> :              mutable    // With: arg may be set per test object execution, Without: arg set once
    <nrwunits> :
    <postactions> :           <statement>
    <port_connection> :       GroupExit|NextNode|<flownode_id> // <flownode_id> within Group, last FlowNode's NextNode=GroupExit
    <preactions> :            <statement>    
    <statement> :             (<assignment>;)*|(<bin>;)?
    <string> :                "<visible_ascii_chars>"
    <symbol_id> :             <amperes_mathexpr_id>|<bool_id>|<category_id>|<coulombs_mathexpr_id>|<dclevels_id>|
			      <farads_mathexpr_id>|<hertz_mathexpr_id>|<integer_id>|<mathexpr_id>|<nrwunits_id>|
			      <ohms_mathexpr_id>|<patternburst_id>|<real_mathexpr_id>|<seconds_mathexpr_id>|<selector_id>|
			      <signalgroup_id>|<signal_id>|<string_id>|<timing_id>|<volts_mathexpr_id>|<watts_mathexpr_id>
    <test_condition> :        Pass|Fail
    <test_object_id> :        <id>


    Amperes      <amperes_mathexpr_id>        = <amperes_mathexpr>|Infinity;
    Bool         <bool_id>                    = True|False;
    Category     <category_id>                = <category>;
    Coulombs     <coulombs_mathexpr_id>       = <coulombs_mathexpr>|Infinity;
    DCLevels     <dclevels_id>                = <dclevels>;
    Farads       <farads_mathexpr_id>         = <farads_mathexpr>|Infinity;
    Hertz        <hertz_mathexpr_id>          = <hertz_mathexpr>|Infinity;
    Integer      <integer_id>                 = <integer>;
    MathExpr     <mathexpr_id>                = <mathexpr>;  // e.g., I^2*R
    NrwUnits     <nrwunits_id>                = <nrwunits>;  // e.g., 1.5V, 1.5A2Ohms ?
    Ohms         <ohms_mathexpr_id>           = <ohms_mathexpr>|Infinity;
    PatternBurst <patternburst_id>            = <patternburst>;
    Real         <real_mathexpr_id>           = <real_mathexpr>|Infinity;
    Seconds      <seconds_mathexpr_id>        = <seconds_mathexpr>|Infinity
    Selector     <selector_id>                = <selector>;
    SignalGroup  <signalgroup_id>|<signal_id> = <signalgroup>|<signal>|EmptySignalGroup
    String       <string_id>                  = <string>;
    Timing       <timing_id>                  = <timing>;
    Volts        <volts_mathexpr_id>          = <volts_mathexpr>|Infinity;
    Watts        <watts_mathexpr_id>          = <watts_mathexpr>|Infinity;

    PassBinMap|FailBinMap
    {
        (Axis <axis_id>
	{
	    (Bin <bin_id>
	        {
		(Descriptor = <string>;)*         // Absence implies Descriptor = <empty_string>
		(PerRunCounter = <integer>;)*     // Absence implies Counter = 0, reinitialized with each run
		})*
	})*
        (Handler <handler_name>
	    {
	    [axis1, ..., axisN] <hardware_bin>;   // Nr of lines req'd = size(axis1)* ... *size(axisN)
	    }
	)*
    }

    FlowNode <flownode_id>
    {
        (Execute
            (<test_object_id>                 // Reference to previously defined Test
                {
                (In    <id> = <expr>;)*       // Override default non-const parameter value
                (InOut <id> = <symbol_id>;)*  // Override default non-const read/write reference to <symbol_id>
                (Out   <id> = <expr>;)*       // Override default non-const parameter value
                })|
	    (<method_id>                      // Anonymous instantiation of Method
                {
                (In    <id> = <expr>;)*       // Set default/only value
                (InOut <id> = <symbol_id>;)*  // Set default/only read/write reference to <symbol_id>
                (Out   <id> = <expr>;)*       // Set default/only value
                })
        )
        (Ports
            {
            (EntryActions { ((NoActionExit <condition_name>)|<preactions>)? })*
            (Exit <condition_name>
                {
                (Condition <bool_expr>;)?
                (NextNode  <port_connection>;)
                (Actions { <postactions> })?
                })+
            })
    }

    Method Test
    {
        // <modifier> indicates whether parameter can be changed during flow
        (In    <modifier> <datatype> <id> = <expr>;)*       // Set default value   
        (InOut <modifier> <datatype> <id> = <symbol_id>;)*  // Set default read/write reference to <symbol_id>
        (Out   <modifier> <datatype> <id> = <expr>;)*       // Set default value
        Ports
        {
            EntryActions { NoActionExit|<preactions> }
            Exit
	        {
		Condition Fail <bool_expr>
		    {
		    (Actions { <postactions>; })*
		    }
		Condition Pass    // No <bool_expr> (necessary|permitted) on last Condition
		    {
		    (Actions { <postactions>; })*
		    }
		}
        }
    }

    // A Group may in principle contain 0 or more FlowNodes but STIL's integral
    // type contains none.
    Method Group
    {
        IsA Test;
    }
    
    // A Flow may in principle contain 0 or more FlowNodes by virtue of being a
    // Group but STIL's integral type contains none.
    Method Flow
    {
        IsA Group;
    }

// STIL and User Defined Methods

    Method <method_id>
    {
        // Absence of statement implies 'IsA Test'.  IsA Test|Group inherits
        // functions and data.  Multiple inheritance is virtual, i.e., only one
        // copy of Test|Group|Method data is ever inherited.

        (IsA Test|Group|<method_id2>;)* // Method can't inherit from itself
    }

// Test Object Instantiation

    Test <method_id> <test_object_id>
    {
        (In    <id> = <expr>;)*         // Setting default value for parameter defined in Method
        (InOut <id> = <symbol_id>;)*    // Setting read/write reference parameter defined in Method
        (Out   <id> = <expr>;)*         // Setting default value for parameter defined in Method
    }