>>>> Integral Type Syntax
    <assignment> :
    <array> :
    <array_size> :            [<integer>]
    <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> :               [0-9]+
    <mathexpr> :
    <modifier> :              mutable    // With: arg may be set per test object execution, Without: arg set once; "const" instead ?
    <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>

    // Presence of optional <array_size> requires righthand side of [<expr>, ...]
    // Defer to IEEE std 754 regarding treatment of +-Infinity and NaN
    // Allow for complicated unit types ? e.g., I2R (I squared R) instead of V or Volts ?
    Amperes      <amperes_mathexpr_id>       (<array_size>)? = <amperes_mathexpr>|Infinity|NaN;
    Bool         <bool_id>                   (<array_size>)? = True|False;
    Category     <category_id>               (<array_size>)? = <category>;
    Coulombs     <coulombs_mathexpr_id>      (<array_size>)? = <coulombs_mathexpr>|Infinity|NaN;
    DCLevels     <dclevels_id>               (<array_size>)? = <dclevels>;
    Farads       <farads_mathexpr_id>        (<array_size>)? = <farads_mathexpr>|Infinity|NaN;
    Hertz        <hertz_mathexpr_id>         (<array_size>)? = <hertz_mathexpr>|Infinity|NaN;
    Integer      <integer_id>                (<array_size>)? = <integer>;
    MathExpr     <mathexpr_id>               (<array_size>)? = <mathexpr>;  // e.g., I^2*R, may or may not be reducible to basic units
    NrwUnits     <nrwunits_id>               (<array_size>)? = <nrwunits>;  // e.g., 1.5V, 1.5A2Ohms ?
    Ohms         <ohms_mathexpr_id>          (<array_size>)? = <ohms_mathexpr>|Infinity|NaN;
    PatternBurst <patternburst_id>           (<array_size>)? = <patternburst>;
    Real         <real_mathexpr_id>          (<array_size>)? = <real_mathexpr>|Infinity|NaN;
    Seconds      <seconds_mathexpr_id>       (<array_size>)? = <seconds_mathexpr>|Infinity|NaN
    Selector     <selector_id>               (<array_size>)? = <selector>;
    SignalGroup  <signalgroup_id>|<signal_id>(<array_size>)? = <signalgroup>|<signal>|EmptySignalGroup
    String       <string_id>                 (<array_size>)? = <string>;
    Timing       <timing_id>                 (<array_size>)? = <timing>;
    Volts        <volts_mathexpr_id>         (<array_size>)? = <volts_mathexpr>|Infinity|NaN;
    Watts        <watts_mathexpr_id>         (<array_size>)? = <watts_mathexpr>|Infinity|NaN;

    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)
	    }
	)*
    }

    SymTbl
    {
        // Presence of optional <array_size> requires righthand side of [<expr>, ...]
        <modifier>)? <datatype> <id> (<array_size>)? = <expr>;
    }

    Method Test
    {
        (SymTbl { ... }?    // Same as syntax above: see alternative Private below
    
        // Optional <modifier> indicates whether parameter can be changed during flow
	// Presence of optional <array_size> requires righthand side of [<expr>, ...] or &<symbol_id> referring to matching array size symbol
        (In      (<modifier>)? <datatype> <id> (<array_size>)? = &<symbol_id>|<expr>;)*       // Set default value   
        (InOut   (<modifier>)? <datatype> <id> (<array_size>)? = &<symbol_id>;)*              // Set default read/write reference to <symbol_id>
        (Out     (<modifier>)? <datatype> <id> (<array_size>)? = &<symbol_id>|<expr>;)*       // Set default value
        (Private (<modifier>)? <datatype> <id> (<array_size>)? = &<symbol_id>|<expr>;)*       // Set default value
        Ports
        {
            Entry
	        {
		(Actions { 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;
	<test_object_instantiation> // Test object local to group.  See syntax below
        (FlowNode <flownode_id>*
        {
            (Execute
                (<test_object_id>                 // Reference to previously defined Test (instantiation of Method)
                    {
                    (In    <id> = Default|&<symbol_id>|<expr>;)*       // Override default non-const parameter value
                    (InOut <id> = Default|&<symbol_id>;)*              // Override default non-const read/write reference to <symbol_id>
                    (Out   <id> = Default|&<symbol_id>|<expr>;)*       // Override default non-const parameter value
                    })|
                (<method_id>                      // Anonymous instantiation of Method
                    {
                    (In    <id> = &<symbol_id>|<expr>;)*       // Set default/only value
                    (InOut <id> = &<symbol_id>;)*              // Set default/only read/write reference to <symbol_id>
                    (Out   <id> = &<symbol_id>|<expr>;)*       // Set default/only value
                    })
            )
            (Ports
                {
                (Entry
		    {
		    (Actions { ((NoActionExit <condition_name>)|<preactions>)? })?
		    }
		)*
                (Exit <condition_name>
                    {
                    (Condition <bool_expr>;)?
                    (NextNode  <port_connection>;)
                    (Actions { <postactions> })?
                    })+
                })
        })*
    }
    
    // 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

        (In    (<modifier>)? <datatype> <id> = &<symbol_id>|<expr>;)*       // Set default value   
        (InOut (<modifier>)? <datatype> <id> = &<symbol_id>;)*              // Set default read/write reference to <symbol_id>
        (Out   (<modifier>)? <datatype> <id> = &<symbol_id>|<expr>;)*       // Set default value
    }

// Test Object Instantiation
// <test_object_instantiation> used above

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