STIL Reference Guide IEEE Std.

1450-1999

STIL 1.0;
Header {
STIL.0 - Basic STIL; approved by IEEE in 1999 ( Title "TITLE_STRING"; )
STIL.1 - Design extension; draft D19, June 17, 2003 ( Date "DATE_STRING"; )
STIL.2 - DC Levels; approved by IEEE in 2002 ( Source "SOURCE_STRING"; )
STIL.3 - TRC extension (Tester Resource Constraints); draft D8, Apr 11, 2003 ( History { } )
STIL.4 - Flow extension; not included }
STIL.5 - Test Method extension; not included
STIL.6 - CTL extension (Core Test Language), draft D1.2, Aug 2004 Include "file_name" (IfNeed <blocktype>);
Ann {* ANNOTATION *}

UserKeywords (USER_KEYWORDS)+;
Lexical Environment UserFunctions (USER_KEYWORDS)+;

Simple statement construct:

Keyword (OPTIONAL_TOKENS)*; Signals {
( SIG_NAME < In | Out | InOut | Supply | Pseudo >; )*
Block statement construct: ( SIG_NAME < In | Out | InOut | Supply | Pseudo > {
Keyword (OPTIONAL_TOKENS)* { (OPTIONAL_MORE_STATEMENTS)* } ( Termination
< TerminateHigh | TerminateLow | TerminateOff | TerminateUnknown > ; )
Whitespace: ( DefaultState < U | D | Z | ForceUp | ForceDown | ForceOff > ; )
space ( Base < Hex | Dec > WAVEFORM_CHARACTER_LIST ; )
\t tab ( Alignment <MSB | LSB> ; )
\n newline character ( ScanIn (DECIMAL_INTEGER) ; )
( ScanOut (DECIMAL_INTEGER) ; )
Comments: ( DataBitCount DECIMAL_INTEGER ; )
// LINE COMMENT- line comments are terminated by newline } )*
/* BLOCK }
COMMENT */- block comments may span multiple lines

SignalGroups (DOMAIN_NAME) {
( GROUPNAME = sigref_expr; )*
( GROUPNAME = sigref_expr { ( Termination
< TerminateHigh | TerminateLow | TerminateOff | TerminateUnknown > ; )
( DefaultState < U | D | Z | ForceUp | ForceDown | ForceOff > ; )
( Base < Hex | Dec > WAVEFORM_CHARACTER_LIST ; )
( Alignment <MSB | LSB> ; )
( ScanIn (DECIMAL_INTEGER); )
( ScanOut (DECIMAL_INTEGER); )
( DataBitCount DECIMAL_INTEGER; )
} )*
}

D03 1 9/7/04
PatternExec (PAT_EXEC_NAME) { ( WFC_LIST {
( Category CATEGORY_NAME ; )* ( InheritWaveform (((TIM.)WFT.)WAV.)WFC; )*
( Selector SELECTOR_NAME ; )* (( EVENT_LABEL: ) ( time_expr )
( Timing TIMING_NAME ; ) ( <event_list ( [EVENT_NUM] ) | event > ) ; )*
( PatternBurst PAT_BURST_NAME ; ) } )* // end wfc_list
} ( <WFC | WFC_LIST> { (( EVENT_LABEL: ) ( time_expr ) (\rN)
< SUB_WF_LAB ;
PatternBurst PAT_BURST_NAME { | SUB_WF_LAB[N] ;
( SignalGroups GROUPS_DOMAIN ; )* | SUB_WF_LAB[#] ; > )* } )*
( MacroDefs MACROS_DOMAIN ; )* } )* // end wfc | wfc_list
( Procedures PROCEDURES_DOMAIN ; )* } // end sigref_expr
( ScanStructures SCAN_NAME ; )* } )* // end Waveforms
( Start PAT_LABEL ; ) } // end Waveforms
( Stop PAT_LABEL ; ) ( SubWaveforms {
( Termination { ( sigref_expr ( SUB_WF_LAB: Duration time_expr {
< TerminateHigh | TerminateLow | TerminateOff | TerminateUnknown > ; )* (( EVENT_LABEL: )( time_expr )
} ) // end Termination ( <EVENT_LIST ( [EVENT_NUM] ) | event > ) ; )*
( PatList { } )* // end Duration
( PAT_NAME_OR_BURST_NAME ; )* } ) // end SubWaveforms
( PAT_NAME_OR_BURST_NAME { }) // end WaveformTable
( SignalGroups GROUPS_DOMAIN ; )* } // end Timing
( MacroDefs MACROS_DOMAIN ; )*
( Procedures PROCEDURES_DOMAIN ; )*
( ScanStructures SCAN_NAME ; )* Spec (SPEC_NAME) {// this block statement defines variable values for a given category
( Start PAT_LABEL ; ) ( Category CAT_NAME {
( Stop PAT_LABEL ; ) ( VAR_NAME = time_expr; )*// define only the Typ value
( Termination { ( sigref_expr ( VAR_NAME {
<TerminateHigh |TerminateLow |TerminateOff |TerminateUnknown>;)* (Min time_expr;) (Typ time_expr;) (Max time_expr;) } )*
} ) // end Termination } )+
} )* // end of Pat_name_or_Burst_name }
} )+ // end of PatList
} // end of PatternBurst
Spec (SPEC_NAME) {// this block statement defines category values for a given variable
Timing ( TIM_DOMAIN_NAME ) { ( Variable VAR_NAME {
( SignalGroups GROUPS_DOMAIN ; )* ( CAT_NAME = time_expr; )*// define only the Typ value
( WaveformTable WFT { ( CAT_NAME {
( Period time_expr; ) (Min time_expr;) (Typ time_expr;) (Max time_expr;) } )*
( InheritWaveformTable (TIM.)WFT ; )* } )+
Waveforms { }
( sigref_expr (WAV) {
( InheritWaveform ((TIM.)WFT.)WAV ; )* Selector SELECTOR_NAME {
( WFC { ( VAR_NAME < Min | Typ | Max | Meas >; )* }
( InheritWaveform (((TIM.)WFT.)WAV.)WFC ; )*
(( EVENT_LABEL: ) ( time_expr ) ( event ) ; )*
} )* // end wfc

D03 2 9/7/04
ScanStructures (SCAN_NAME) {
( ScanChain CHAINNAME { Procedures ( PROCEDURE_DOMAIN_NAME ) {
ScanLength DECIMAL_INTEGER; ( PROCEDURE_NAME {
( ScanOutLength DECIMAL_INTEGER; ) ( PATTERN-STATEMENT )*
( ScanCells CELLNAME-LIST ; ) } )*
( ScanIn SIGNALNAME; ) }
( ScanOut SIGNALNAME; )
( ScanMasterClock SIGNALNAME-LIST ; ) MacroDefs ( MACRO_DOMAIN_NAME ) {
( ScanSlaveClock SIGNALNAME-LIST; ) ( MACRO_NAME {
( ScanInversion < 0 | 1 >; ) ( PATTERN-STATEMENT )*
} )* } )*
} }

Pattern PATTERN_NAME {
( LABEL : )
( TimeUnit ‘TIME_DEF ’; )
( V(ector) { ( cyclized-data )* ( non-cyclized-data )* } )
( W(aveformTable) NAME ; )
( C(ondition) { ( cyclized-data )* ( non-cyclized-data )* } )
( Call PROCNAME ; )
( Call PROCNAME { ( scan-data )* ( cyclized-data )* ( non-cyclized-data )* } )
( Macro MACRONAME ; )
( Macro MACRONAME { ( scan-data )* ( cyclized-data )* ( non-cyclized-data )* } )
( Loop LOOPCNT { ( pattern-statements )* } )
( MatchLoop < LOOPCNT | Infinite > {
(pattern-statements)+
( BreakPoint { (pattern-statements)+ } )
} ) // end MatchLoop
(Goto LABELNAME ; )
(BreakPoint; )
(BreakPoint { ( PATTERN-STATEMENTS )* } )
(IddqTestPoint; )
(Stop ; )
(ScanChain CHAINNAME ; )
} // end Pattern

vec_data:
\w - WaveformChar format (\w0100 xxxx qqqQQQ).
\rN XXX - Repeat the next group of characters N times (\r60 01).
\h - Hexadecimal format (\h E4B2).
\hCHARS - Hexadecimal format with a local WaveformChar association (\h01 69BC).
\d - Decimal format ( \d 79)
\dCHARS - Decimal format with local WaveformChar association (\dHL 375).
\lN - Shift data passed in procedure or macro calls, or multiple-bit data passed into
waveforms that contain square-bracket constructs.

D03 3 9/7/04
 IEEE P1450.1, Draft 16, June 19, 2003 ( Variables VARIABLES_DOMAIN; )*
} )* // end pat_name_or_burst_name
STIL 1.0 { } )* // end PatSet
( ParallelPatList ( SyncStart | Independent | LockStep ) {
( Design D19; ) ( PAT_NAME_OR_BURST_NAME ; )*
} // end STIL ( PAT_NAME_OR_BURST_NAME {
( Variables VARIABLES_DOMAIN; )*
Variables (VARIABLES_DOMAIN) { ( Extend; )
( IntegerConstant CONST_NAME := DECIMAL_INTEGER ; )* ( If boolean_expr ; )
( Integer VAR_NAME; )* ( While boolean_expr ; )
( Integer VAR_NAME { } )* // end pat_name_or_burst_name
( Usage Test; ) } )* // end ParallelPatList
( InitialValue integer_expr ; )
} )* // end Integer
( SignalVariable VAR_NAME; )*
( SignalVariable VAR_NAME { Timing TIMING_NAME {
( Base < Hex | Dec> WFC_LIST ; ) ( Variables VARIABLES_DOMAIN; )*
( Alignment < MSB | LSB > ; )
( InitialValue vec_data ; ) ScanStructures (SCAN_STRUCT_NAME) {
} )* // end SignalVariable ( InheritScanStructures SCAN_STRUCT_NAME ; )
( WFCConstant CONST_NAME = WFC_LIST ; )* ( ScanChain CHAIN_NAME {
} // end Variables ScanLength integer_expr ;
( ScanOutLength integer_expr ; )
Signals { ( ScanEnable logic_expr ; )
( SIG_NAME < In | Out | InOut | Supply | Pseudo > { ( ScanCellType (CELL_TYPE_NAME) {
( WFCMap { ( (If boolean_expr) CellIn STATE-ELEMENT-LIST ; )*
( FROM_WFC -> TO_WFC( TO_WFC )+ ; )* ( (If boolean_expr) CellOut STATE-ELEMENT ; )*
( FROM_WFC1 (FROM_WFC2) -> TO_WFC ; )* }
} ) // end WFCMap ( ScanCells {
} )* ( cell_ref (CELL_TYPE_NAME) ; )*
} } ) // end ScanCells
( Base Hex; ) // optional for cell groups
SignalGroups { ( Alignment <MSB|LSB>; ) // optional for cell groups
( GROUPNAME = sigref_expr { } )* // end ScanChain
( WFCMap { ( ScanChainGroups {
( FROM_WFC -> TO_WFC( TO_WFC )+ ; )* ( GROUP_NAME { (GROUP_OR_CHAIN_NAME; )* } )*
( FROM_WFC1 FROM_WFC2 -> TO_WFC ; )* }) // end ScanChainGroups
} ) // end WFCMap } // end ScanStructures
} )*
} // end SignalGroups Environment (ENV_NAME) {
( InheritEnvironment ENV_NAME ; )*
PatternBurst PAT_BURST_NAME { ( NameMaps (MAP_NAME) {
( Variables VARIABLES_DOMAIN; )* InheritNameMap (ENV_NAME::) (MAP_NAME) ;
( Fixed { (cyclized-data)* } ) InheritNameMap (ENV_NAME::) (MAP_NAME) {
( PatList { ( Prefix "PREFIX_STRING"; )
( PAT_NAME_OR_BURST_NAME { ( Separator "SEPARATOR_STRING"; )
( Variables VARIABLES_DOMAIN; )* ( ScanCells { (SCAN_CELL_NAME ;)* } )*
( If boolean_expr ; ) } // end InheritNameMap
( While boolean_expr ; ) ( Prefix "PREFIX_STRING"; )
} )* // end pat_name_or_burst_name ( Separator "SEPARATOR_STRING"; )
} )* // end PatList ( ScanCells { ((SCAN_CELL_NAME) "MAP_STRING"; )* } )*
( PatSet { ( Signals { (SIG_NAME "MAP_STRING"; )* } )*
( PAT_NAME_OR_BURST_NAME ; )* ( SignalGroups (DOMAIN_NAME) { (GROUP_NAME "MAP_STRING"; )* } )*
( PAT_NAME_OR_BURST_NAME { ( Variable { (VAR_NAME "MAP_STRING"; )* } )*

D03 4 9/7/04
 ( AllNames { (ANY_NAME "MAP_STRING"; )* } )* Vector data mapping and joining - \m, \j
} )* // end NameMaps
( FileReference "FILE_PATH_NAME"; )* This subclause defines syntax for use within pattern data for either mapping wfcs to
( FileReference "FILE_PATH_NAME" { other wfcs or for combining wfcs into a single wfc. The syntax is defined as:
Type FILE_TYPE ;
Format FILE_FORMAT ; SIGNAL = \m wfc;
Version "VERSION_NUMBER" ; GROUP = \m wfc-list;
} )* // end FileReference SIGNAL = \j wfc-1; signal = \j wfc-2;
(ENVIRONMENT_DEFINED_STATEMENTS)* GROUP = \j wfclist-1; \j wfclist-2;
} // end Environment Where:
SIGNAL, GROUP - represent the signal that are to be mapped or joined in the pattern
Data content read back - \C, \D, \E, \S, \U, \W data
wfc - represent a FROM_WFC that is to be mapped according to a WFCMap state-
\readback_function SIGNAL_NAME ment for a signal
\readback_function SIGNAL_GROUP_NAME
\readback_function SIGNAL_VARIABLE_NAME wfc-list - represent a string of FROM_WFCS that are to be mapped according to a
\readback_function WFCCONSTANT_NAME WFCMap for a signal group
\C SIGNAL-OR-GROUP-NAME - return the last compare event. In the case of a group, wfc-1, wfc-2 - represent two FROM_WFC characters that are to be joined according
return a string of the last compare event for each signal of the group. If no compare to a WFCMap for a signal
event has been established, then return ’~’ (the tilde character). wfclist-1, wfclist-2 - represent two strings of FROM_WFCS that are to be joined
\D SIGNAL-OR-GROUP-NAME - return the last drive event. In the case of a group, according to a WFCMap for a signal group.
return a string of the last compare event for each signal of the group. If no compare Pattern statements:
event has been established, then return ’~’ (the tilde character). ( LABEL : ) If boolean_expr { (PATTERN_STATEMENTS)* } ( Else {
(PATTERN_STATEMENTS)* } )
\E SIGNAL-OR-GROUP-NAME - return the last expect event. In the case of a group, ( LABEL : ) While boolean_expr { (PATTERN_STATEMENTS)* }
return a string of the last compare event for each signal of the group. If no compare ( LABEL : ) F(ixed) { (cyclized-data)* (non-cyclized-data)* }
event has been established, then return ’~’ (the tilde character). ( LABEL : ) E(quivalent) ( (\m) sigref_expr )* ;
( LABEL : ) LoopData { ( PATTERN-STATEMENTS )* }
\S SIGNAL-OR-GROUP-NAME - return the last wfc/wfc-list that was established using ( LABEL : ) Loop integer_expr { ( PATTERN_STATEMENTS )* }
a substitute (s or S) event in a waveform. In the case of a group, return a string of ( LABEL : ) ActiveScanChains (GROUP_OR_CHAIN_NAME)+ ;
wfcs for each signal of the group. The actual wfc is determined by the WFCMap ( LABEL : ) AllowInterleave sigref_expr;
statement. If no substitute has been established, then return ’~’ (the tilde char). For ( LABEL : ) BreakPoint {}
( LABEL : ) X < IDENTIFIER | INTEGER > ;
further information, see CompareSubstitute (subclause 14.2) and WFCMap state-
ment (subclause 11.1). Pragma (NAME) {* ... APPLICATION DEPENDANT SYNTAX ... *}
\U SIGNAL-OR-GROUP-NAME - return the last undefined event. In the case of a
PatternFailReport (REPORT_NAME) {
group, return a string of the last compare event for each signal of the group. If no
( DeviceID "IDENTIFYING INFORMATION"; )
compare event has been established, then return ’~’ (the tilde character). ( TestConditions { } )
\W SIGNAL-OR-GROUP-OR-SIGNALVARIABLE-OR-WFCCONSTANT-NAME - return the ( Pattern PAT_NAME; )
( Pattern PAT_NAME {
last wfc/wfc-list that was established using a V or a C statement. In the case of a
( Start (PAT_LABEL) (CYCLE_COUNT) ; )
group, return a string of wfcs for each signal of the group. If the last wfc was estab- ( Stop (PAT_LABEL) (CYCLE_COUNT) ; )
lished by a parameter using # or %, then the substituted wfc is returned. If no wfc })
has been established, then return ’~’ (the tilde character). Note: this should never ( PatternBurst PAT_BURST_NAME; )
happen on the readback of a signal or group since it is required that an initial wfc be ( PatternBurst PAT_BURST_NAME {
defined on the first vector of any pattern. ( Start (PAT_LABEL) (CYCLE_COUNT) ; )
( Stop (PAT_LABEL) (CYCLE_COUNT) ; )
}
( PatternExec PAT_EXEC_NAME; )

D03 5 9/7/04
 FailData { IEEE Std. 1450.2-2002
( <IDENTIFIER|INTEGER> ( . <IDENTIFIER|INTEGER> )*
SIG_NAME
( CYCLE_OFFSET ( ’observed_data’ ) )* ;
)* // end fail data record STIL 1.0 {
} // end FailData ( DCLevels 2002; )+
} // end PatternFailReport
}

PatternExec (PAT_EXEC_NAME) {
(DCLevels (DC_LEVELS_NAME);)
(DCSets (DC_SETS_NAME);) 15
}

(DCLevels (DC_LEVELS_NAME) { // DCLevels block

(InheritDCLevels DC_LEVELS_REF;)*
(SignalGroups GROUPS_DOMAIN;)*
(sigref_expr { // Signals of type In, Out, InOut, Supply
(VIH (dc_expr)+;) (VIL (dc_expr)+;)
(VICM dc_expr;) (VID dc_expr;)
(VIHD dc_expr;) (VILD dc_expr;)
(ForceHi;) (ForceLo;)
(InitHi;) (InitLo;)
(VIHSlew dc_expr;) (VILSlew dc_expr;)
(VOH (dc_expr)+;) (VOL (dc_expr)+;)
(VOCM dc_expr;) (VOD dc_expr;)
(VOHD dc_expr;) (VOLD dc_expr;)
(IOH dc_expr;) (IOL dc_expr;)
(LoadVRef dc_expr;) (ClampHi dc_expr;)
(ClampLo dc_expr;) (ResistiveTermination dc_expr;)
(TermVRef dc_expr;) (VForce dc_expr;)
(IClamp dc_expr;) (IForce dc_expr;)
(VClamp dc_expr;) })* // end sigref_expr
})* // end DCLevels

(DCSets (DC_SET_NAME) {
(DCLevels (DC_LEVELS_REF);)*
})*

D03 6 9/7/04
(DCSequence (<InitialSetup | PowerRaise | PowerLower | EndOfProgram | IEEE P1450.3, Draft 8, Apr 11 2003
User USER_DEFINED>) {
(SignalGroups GROUPS_DOMAIN;)* STIL 1.0 { TRC D08; }
(time_expr sigref_expr { // Each sigref_expr is sequenced together
(Connect (<Supply | PMU | Driver | Comparator| Load | Termination Resource (TESTER_IDENTIFIER)+ ; // list of target testers
|Clamp>)*;)* // Physical connection (e.g., relay) < (RESOURCE_ID)+ >
(Disconnect (<Supply | PMU | Driver | Comparator | Load | Termination }
|Clamp>)*;)*
(Apply (dc_expr);)* // optional voltage or current value Environment (ENV_NAME) {
(Ramp time_expr (dc_expr);)* // ramp duration, optional voltage target ( NameMaps (MAP_NAME) {
})* // end time_expr ( Signals { (SIG_NAME “MAP_STRING”; )* } )*
})* // end DCSequence } // end NameMaps
} // end Environment

Environment (ENV_NAME) {
( TRC (TRC_NAME) {
( Category (CAT_NAME)+ ;)
( Selector (SEL_NAME)+ ;)
( NameChecks (NAM_CHK_NAME) { } )*
( PatternCharacteristics PAT_CHAR_NAME { } )*
( PeriodCharacteristics PER_CHAR_NAME { } )*
( SignalCharacteristics (signal_attributes)+ { } )*
( SystemCharacteristics {
( MultipleDevices integer_expr;)
( MultipleSites integer_expr;)
})
( Usage < Constraints | PatternReport > ; )
( WaveformCharacteristics WAV_CHAR_NAME { } )*
( WaveformDescriptions WAV_DESC_NAME (Explicit) { } )*
})* // end TestResourceConstraints
} // end Environment

SignalCharacteristics
(<Data| Clock | Scan| In | Out| InOut | SplitIO| Asynchronous
| User USER_DEFINED>)+ {
( DCResourceCharacteristics DC_CHAR_NAME; )
( FanOut integer_expr; )
( InOut < WithinCycle | OnCycleBoundary | Static >;)
( MaxScanMemory integer_expr;)
( MaxCaptureMemory integer_expr (<FailOnly | Result>)+ ;)
( MaxScanChainLength integer_expr ; )
( MaxSignals integer_expr;)
( MaxVectorMemory integer_expr;)
( PatternCharacteristics PAT_CHAR_NAME ;)
( PeriodCharacteristics PER_CHAR_NAME (<Synchronous | Asynchronous>)+ ;)

D03 7 9/7/04
 ( UndrivenInOut < Yes | No >;) (<U|D|Z|P>(/<U|D|Z|P>)*)+
( WaveformCharacteristics WAV_CHAR_NAME ;) (integer_expr (integer_expr)) ; )* // number events, number substitutes
( WaveformDescriptions WAV_DESC_NAME ;) // use the following syntax to define MaxShapes
} // end SignalCharacteristics ( FormatSelect < In | Out | InOut > {
( MaxShapes integer_expr (< Dynamic | Static >); )
DCResourceCharacteristics (DC_RESOURCE_NAME) { ( MaxShapes integer_expr (< Dynamic | Static >) {
( PerPinConfiguration ( SignalsPer integer_exp; )
(<Supply | PMU | Driver | Comparator | Load | Termination | Clamp>)+; ) } // end MaxShapes
( DifferentialConfiguration (<Driver | Comparator>)+;) } // end FormatSelect (with MaxShapes)
( NumberTesterChannels integer_expr;) // use following syntax in place MaxShapes (above)
( DCLimits ( FormatSelect < In | Out | InOut > {
< VIH | VIL | VICM | VID | VIHD | VILD | VIHSlew | VILSlew ( MaxTimeSets integer_expr (< Dynamic | Static >) ; )
| VOH | VOL | VOCM | VOD | VOHD | VOLD ( MaxTimeSets integer_expr (< Dynamic | Static >) {
| IOH | IOL | LoadVRef | ClampHi | ClampLo ( SignalsPer integer_exp; )
| ResistiveTermination | TermVRef ( PerTimingGenerator; )
| VForce | IClamp | IForce | VClamp > } ) // end MaxTimeSets
{ ( Min dc_expr; ) ( Max dc_expr;) } )* ( MaxTimingGenerators integer_expr (< Dynamic | Static >) ; )
( NumberLevels (< VIH | VIL | VOH | VOL >)+ integer_expr; )* ( MaxTimingGenerators integer_expr (< Dynamic | Static >) {
( NumberDCLevels integer_expr; ) ( SignalsPer integer_exp; )
( NumberDCLevels integer_expr { } ) // MaxTimingGenerators
SignalsPer integer_expr; ( MaxData <Drive|Compare|DriveCompare> integer_expr (<Dynamic|Static>);
} ( MaxData <Drive|Compare|DriveCompare> integer_expr (<Dynamic|Static> {
} ( SignalsPer integer_exp; )
} ) // end MaxData
PeriodCharacteristics (PER_CHAR_NAME) { ( MaxIO integer_expr integer_expr (< Dynamic | Static >); )
(Accuracy time_expr;) ( MaxIO integer_expr integer_expr (< Dynamic | Static >) {
(MaxPeriods integer_expr;) ( SignalsPer integer_exp; )
(MaxPeriodGenerators integer_expr (< Dynamic | Static >) ; ) } ) // end MaxIO
(MaxPeriodGenerators integer_expr (< Dynamic | Static >) { ( MaxMask integer_expr (< Dynamic | Static >); )
( SignalsPer integer_exp; ) ( MaxMask integer_expr (< Dynamic | Static >) {
} // end MaxPeriodGenerators ( SignalsPer integer_exp; )
( PeriodSelectMemory integer_expr; ) } ) // end MaxMask
( PeriodSelectMemory integer_expr { })* // end FormatSelect
( SignalsPer integer_exp; ) ( MaxEdgeTime time_expr;)
} ) // end PeriodSelectMemory ( MinCompareWindow time_expr;)
( TimeLimits boolean_expr; ) ( MinCompareToDriveOn time_expr;)
(Resolution time_expr;) ( MinEdgeReTrigger time_expr (<Drive | Compare>)* ;)*
} // end PeriodCharacteristics ( MinDriveOffTime time_expr;)
( MinDriveOffToCompare time_expr;)
WaveformCharacteristics (WAV_CHAR_NAME) { ( MinDriveOnTime time_expr;)
( Accuracy <Edge|EdgeToEdge> time_expr;)* ( MinDrivePulse time_expr;)
( CompareEvents ( ReplicateSubWaveform integer_expr; )
(<H|L|X|V|T|h|l|x|v|t>(/<H|L|X|V|T|h|l|x|v|t>)*)+ ( Resolution time_expr;)
(integer_expr (integer_expr)) ; )* // number events, number substitutes ( TimeLimits boolean_expr; )
( DriveEvents ( WaveformSelectMemory integer_expr ; )

D03 8 9/7/04
 ( WaveformSelectMemory integer_expr { } )* // end InstructionCharacteristics
( SignalsPer integer_exp; ) ( Macro < Yes | No | WithParameters >;)
( SelectWithPeriod; ) ( MaxRunTime time_expr;)
} ) // end WaveformSelectMemory ( MaxVectors integer_expr;)
} // end WaveformCharacteristics ( MultiBitData (< InWaveforms | InPatterns | No >)+ ;)
( NonCyclized < Yes | No >;)
WaveformDescriptions (WAV_DESC_NAME) (Explicit) { ( NumberCaptureCycles (integer_expr ( integer_expr)) ;)
( < In | Out | InOut > WFNAME { ( NumberPatternUnits integer_expr ;)
( NumberData integer_expr ; ) ( NumberVectorsPerShift (integer_expr) ( integer_expr);)
( NumberIO integer_expr ; ) ( PatternVariables (< Integer | IntegerConstant | SignalVariable | Spec | All >* ;)
( NumberMask integer_expr ; ) ( ProcedureCalls < Yes | No| WithParameters > ;)
( NumberPeriods integer_expr;) ( Shift < Yes | No >;)
( NumberShapes integer_expr ; ) ( STILPatterns < Yes | No >;)
( NumberSignals integer_expr;) ( VectorModulus integer_expr; )
( NumberTimeSets integer_expr ; ) } // end PatternCharacteristics
Shape {
( (TRC_LABEL:) ( time_expr ) < event | event_list> ;)* PatternInformation {
} )* // end Shape < Pattern | PatternBurst > PAT_OR_BURST_NAME {
})* // end < In | Out | InOut > ( PatternCharacteristics { } )
} // end WaveformDescriptions }
PatternCharacteristics (PAT_CHAR_NAME) { NameChecks NAM_CHECKS_NAME {
( Base < Hex | Dec | HexDec > integer;) ( Contents (STIL_BLOCK_NAME)+ ; )
( BreakPoint < Yes | No >;) ( Block STIL_BLOCK_NAME ; )*
( ConditionalStatements < Yes | No > ;) ( CharacterContent ’regular_expr’ ; )
( CoreUsageReady < Yes | No > ;) ( Length integer_expr ; )
( DeltaChangeVectorData < Yes | No >;) ( Scope (STIL_BLOCK_NAME)+ ; )
( GoTo < Yes | No >;) }
( IddqTestPoints < Yes | No >;)
( InstructionCharacteristics {
( AllowedWhen boolean_expr; )
( AppliesTo (< Condition | GoTo | Loop | MatchLoop | Call | Shift >)+ ;)
( LoopCharacteristics LOOP_NAME {
( Infinite; )
( MaxIteration integer_expr; )
( MaxLength integer_expr; )
( MaxNest integer_expr; )
( MinIteration integer_expr; )
( MinLength integer_expr; )
( MinTimeAfterMatch time_expr; )
( MinVectorsAfterMatch integer_expr; )
( VectorModulus integer_expr; )
} )* // end LoopCharacteristics
( MinVectorsAfter integer_expr; )
( MinVectorsBefore integer_expr; )
( MinVectorsBetween integer_expr; )

D03 9 9/7/04
 IEEE P1450.6, Draft D1.2, Aug 2004
MacroDefs (MACRO_DOMAIN_NAME) {
STIL 1.0 { Design D20; CTL D1.2; } ( MACRO_NAME (LockStep) {
(PATTERN_STATEMENT)*
PatternBurst PAT_BURST_NAME { })*
(Protocol <Macro MACRONAME (SETUP_MACRONAME) }
| Procedure PROCNAME (SETUP_PROCNAME)>;) Procedures (PROCEDURE_DOMAIN_NAME) {
(<PatList | PatSet | ( PROCEDURE_NAME (LockStep) {
ParallelPatList (SyncStart | Independent | LockStep)> (PATTERN_STATEMENT)*
{ })*
(PAT_NAME_OR_BURST_NAME { }
(Protocol <Macro MACRONAME (SETUP_MACRONAME)
| Procedure PROCNAME (SETUP_PROCNAME)>;) (CoreType CORE_TYPE_NAME {
})* ( CoreEnvironment CORE_ENV_NAME; )
})+ ( CoreInstance CORE_TYPE_NAME {
} (CORE_INSTANCE_NAME;)+
} )* // end Inherited CoreType- Instance definition
// ONLY syntax allowed in Patterns ( Signals {
Pattern PATTERN_NAME { core_signal_definitions
( Setup { (sigref_expr = value_variable_expr;)* }) } ) // end Signals
<((LABEL:) P;)* | ( SignalGroups (DOMAIN_NAME) {
((LABEL:) P { (sigref_expr = value_variable_expr;)*})*> core_signal_group_definitions
// Pattern-statements that are allowed from the ones } )* // end SignalGroups
defined in ( ScanStructures (SCAN_STRUCT_NAME) {
// IEEE Std. 1450-1999 and 1450.1 core_scan_structure_definitions
((LABEL:) Loop LOOPCNT { (P-statements)* })* } )* // end ScanStructures
((LABEL:) Goto LABELNAME;)* })*// end CoreType
((LABEL:) BreakPoint;)*
((LABEL:) X TAG;)* ( CoreInstance CORE_TYPE_NAME {
} (CORE_INSTANCE_NAME;)+
// OR })*
Pattern PATTERN_NAME {
// Pattern-statements that are allowed from the ones ( FileReference “FILE_PATH_NAME”; )*
defined in ( FileReference “FILE_PATH_NAME” {
// IEEE Std. 1450-1999 and 1450.1 Type file_type ;
((LABEL:) Macro MACRONAME;)* Format <pattern_file_format | design_file_format | layout_file_format |
((LABEL:) Macro MACRONAME { (sigref_expr = value_variable_expr;)*})* fault_list_file_format | script_file_format | doc_file_format>;
((LABEL:) Call PROCNAME;)* Version “VERSION_NUMBER” ;
((LABEL:) Call PROCNAME { (sigref_expr = value_variable_expr;)*})* } )* // end FileReference
((LABEL:) Loop LOOPCNT { (Macro-or-Procedure-calls)* })*
((LABEL:) Goto LABELNAME;)* file_type =
((LABEL:) BreakPoint;)* < Pattern | Design
((LABEL:) X TAG;)* | Layout | FaultList
} | Script | Documentation
| User USER_DEFINED >

D03 10 9/7/04
 test_mode_enum =
pattern_file_format = < Bypass | Controller
< STIL | WGL | Debug | ExternalTest
| Verilog | VHDL | ForInheritOnly | InternalTest
| VCD | User USER_DEFINED > | Isolate | Normal
| PowerOff | PowerOn
design_file_format = | PreLoad | Quiet
< CTL | EDIF | Repair | Sample
| Verilog | VHDL | Transparent | User USER_DEFINED >
| User USER_DEFINED >
exec_enum =
layout_file_format = < Characterization | Diagnostic
< GDSII | DEF | Production | Verification
| LEF | Oasis | User USER_DEFINED >
| User USER_DEFINED >
pattern_or_burst_enum =
fault_list_file_format = < AtSpeed | ChainContinuity
< DTIF | User USER_DEFINED > | CompatibilityInformation | Endurance
| EstablishMode | IDDQ
script_file_format = | LogicBIST | MemoryBIST
< AWK | Perl | Padding | Parametric
| SED | TCL | Retention | Scan
| User USER_DEFINED > | TerminateMode | User USER_DEFINED >

doc_file_format = Environment (ENV_NAME) {

< HTML | PDF ( CTLMode (CTLMODE_NAME) {
| Postscript | RTF ( CoreInternal {} )
| Text | User USER_DEFINED > ( DomainReferences ( CORE_INSTANCE_NAME)* {
( Category (CATEGORY_NAME)+; )
(NameMaps (MAP_NAME) { ( MacroDefs ( MACRO_DEF_NAME )+ ; )
(CoreType CORE_TYPE_NAME { ( Procedures ( PROCEDURE_NAME )+ ; )
(CoreInstance {(CORE_INSTANCE_NAME “map_string”;)+}) ( Selector ( SELECTOR_NAME)+;)
(Signals { (SIGNALNAME “map_string”;)+}) ( SignalGroups ( SIGNALGROUPS_NAME )+ ; )
(ScanCells { (CELLNAME “map_string”;)+ }) ( ScanStructures ( SCAN_STRUCT_NAME )+ ; )
})* ( Timing ( TIMING_NAME )+ ; )
(CoreInstance { (CORE_INSTANCE_NAME “map_string”;)+ }) ( Variables ( VARIABLES_NAME)+; )
}) } )* // end DomainReferences
( External { } )
( Family (NAME)+ ; )
( Focus ( Top) (CoreInstance (CORE_INSTANCE_NAME)+ ) {
( PatternTypes (pattern_or_burst_enum)+ ; )
( CTLMode CORE_INSTANCE_NAME CTLMODE_NAME; )*
( TestMode (test_mode_enum)+ ; )
( Usage (exec_enum)+ ; )
} )* // end Focus

D03 11 9/7/04
 ( InheritCTLMode CTLMODE_NAME; ) testdata_subtype_enum =
( Internal { } ) < MemoryAddress ( Row | Column)*
( PatternInformation { } ) | MemoryData
( Relation { } ) | Indicator ( TestDone | TestFail | TestInvalid)*
( ScanInternal { } ) | Regular
( ScanRelation { } ) | ScanDataIn
( TestMode (test_mode_enum)+ ; ) | ScanDataOut>
( TestMode (test_mode_enum)+ {
AlternateTestMode (CTLMODE_NAME)+ ; cell_enum =
}) // end of TestMode < <(WC_S | WH_S) <D|F># | WH_C |WH_CI>
( TestModeForWrapper WRAPPER_TEST_MODE TEST_MODE_CODE; ) (_C<<I|O|B><I|O|U>|N>)
( Vendor (NAME)+ ; ) (_U<D|F>) (_O) (<_G0|_G1>)
( Compliancy < IEEE1500 EXT_VERSION <Wrapped | Unwrapped> | User USER_DEFINED >
| None | User USER_DEFINED > ; )
} )* // end CTLMode relation_enum =
} // end Environment <Bus | Common
| Corresponding | Differential
data_type_enum = | Equivalent | Independent
< Asynchronous | Synchronous | InOutSet | MuxSet
| In | Out | NotEquivalent | OneCold
| InOut | Constant | OneHot | Port
| TestMode | Unused | ZeroOneHot | ZeroOneCold
| UnusedDuringTest | Functional | User USER_DEFINED >
| TestControl ( testcontrol_subtype_enum )*
| TestData ( testdata_subtype_enum )* ScanDataType_enum =
| User USER_DEFINED > < AddressGenerator | Boundary
| Bypass | Counter
testcontrol_subtype_enum = | DataGenerator | Identification
< CaptureClock | CoreSelect | Instruction | Internal
| ClockEnable | InOutControl | ResponseCompactor | User USER_DEFINED >
| Oscillator | OutDisable
| OutEnable | MasterClock Environment { CTLMode (CTLMODE_NAME) {
| MemoryRead | MemoryWrite Internal {
| SlaveClock | Reset ( sigref_expr {
| ScanEnable | ScanMasterClock ( DataType ( data_type_enum )+ ; )
| ScanSlaveClock | TestAlgorithm ( DataType ( data_type_enum )+ {
| TestInterrupt | TestPortSelect ( ActiveState
| TestRun | TestWrapperControl > < ForceDown | ForceUp
| ForceOff | ForceValid
| ExpectLow | ExpectHigh
| ExpectOff | ExpectValid > (Weak); )
( DataRateForProtocol <Average|Maximum> INTEGER;)
( AssumedInitialState
< ForceDown | ForceUp
| ForceOff | ForceValid

D03 12 9/7/04
 | ExpectLow | ExpectHigh ( IsGatedBy <LogicAnd | LogicOr | LogicXor> logic_expr {
| ExpectOff | ExpectValid > (Weak) ; ) ( LOGICSIGNAME {
( ScanDataType ( ScanDataType_enum )+ ; ) Type < Signal | StateElement Scan | StateElement NonScan |
( ValueRange INTEGER INTEGER (CORE_INSTANCE_NAME)+; )* CoreSignal >;
( UnusedRange INTEGER INTEGER;)* Name <SIGNAME | CELLNAME >;
} )* // end DataType } )+ // end logicsigname
( DisableState } )* // end IsGatedBy
< ExpectOff | ExpectLow ( IsGatedBy < Macro | Procedure > NAME ; )*
| ExpectHigh | ExpectValid ( TestAccess (<
> ( Weak ) ; ) Control
( DriveRequirements { | Observe
( TimingNonSensitive; ) | User USER_DEFINED >)+
( TimingSensitive { < Macro | Procedure > NAME; )*
( Period < Min | Max > time_expr; )* ( < LaunchClock | CaptureClock | Reset > SIGNAME {
( Pulse < High | Low > < Min | Max > time_expr; )* ( <LeadingEdge | TrailingEdge> (LevelSensitive); )
( Precision time_expr; ) ( <Direct | Transitive>; )
( EarliestTime time_expr; ) ( StateAfterEvent <
( LatestTime time_expr; ) Connection | ExpectLow
( Reference sigref_expr { | ExpectHigh | ExpectUnknown
( SelfEdge | ExpectValid | Hold
< Leading | Trailing | LeadingTrailing > (INTEGER); ) | Invert | ShiftState
( ReferenceEdge | User USER_DEFINED > ; )
< Leading | Trailing | LeadingTrailing > (INTEGER); ) })* // end LaunchClock
( Hold time_expr; ) ( Signal (sigref_expr) ; )
( Setup time_expr; ) ( StateElement <Scan | NonScan> (cellref_expr) ; )
( Period real_expr;) ( Transform {
( Precision time_expr; ) ( WaveformTable (WFT_NAME)+; )
} )* // end Reference ( Invert ; )
(Waveform;) ( WFCMap FROM_WFC -> TO_WFC; )*
} ) // end TimingSensitive ( DelayCycles INTEGER;)
} ) // end DriveRequirements })* // end Transform
( ElectricalProperty ( Wrapper <IEEE1500 | None | User USER_DEFINED > ( CellID
< Digital | Analog cell_enum) ; )
| Power | Ground } )* // end IsConnected
> (ELECTRICAL_PROPERTY_ID) ; ) ( IsDisabledBy <In|Out> Logic logic_expr {
( InputProperty ( LOGICSIGNAME {
( < Edge | GlitchFree Type < Signal | StateElement Scan | StateElement NonScan |
| PullDown | PullUp CoreSignal >;
| Relation relation_enum | ScanStable Name <SIGNAME | CELLNAME > ;
| ScanUnstable | SynchFF })+
| SynchLatch | Transitions (INTEGER) } )* // end IsDisabledBy
| Window | User USER_DEFINED ( IsDisabledBy <In|Out> < Macro | Procedure > NAME ; )*
> )+ ; ) ( < LaunchClock | CaptureClock > SIGNAME {
( IsConnected <In|Out> (<Direct | Transitive>) { ( <LeadingEdge | TrailingEdge> (LevelSensitive);)
( CoreSignal (sigref_expr) ; ) })* // end LaunchClock

D03 13 9/7/04
 ( OutputProperty ( ValueRange INTEGER INTEGER (CORE_INSTANCE_NAME)+; )*
( < Edge | PullDown ( UnusedRange INTEGER INTEGER;)*
| PullUp | Relation relation_enum } )* // end DataType
| ScanStable | ScanUnstable ( IsConnected < In|Out > {
| SynchFF | SynchLatch ( CoreSignal sigref_expr ; )
| ThreeState | TwoState0Z ( StateElement <Scan | NonScan> (cellref_expr) ; )
| TwoState1Z | Transition INTEGER ( IsGatedBy <LogicAnd | LogicOr | LogicXor> logic_expr {
| Window | User USER_DEFINED > )+ ;) ( LOGICSIGNAME {
( StrobeRequirements { Type < Signal | StateElement Scan | StateElement NonScan |
( TimingNonSensitive; ) CoreSignal >;
( TimingSensitive { Name <SIGNAME | CELLNAME | SYMBOLNAME>;
( Precision time_expr; ) } )+ // end logicsigname
( EarliestTimeValid time_expr; ) } )* // end IsGatedBy
( LatestTimeValid time_expr; ) ( IsGatedBy < Macro | Procedure > NAME ; )*
( EarliestChange time_expr; ) ( < LaunchClock | CaptureClock | Reset > SIGNAME {
( Reference sigref_expr { ( <LeadingEdge | TrailingEdge> (LevelSensitive); )
( SelfEdge < Leading | Trailing | LeadingTrailing > INTEGER; ) ( <Direct | Transitive>; )
( ReferenceEdge < Leading | Trailing | LeadingTrailing > ( StateAfterEvent <
INTEGER; ) Connection | ExpectLow
( EarliestTimeValid time_expr; ) | ExpectHigh | ExpectUnknown
( LatestTimeValid time_expr; ) | ExpectValid | Hold
( EarliestChange time_expr;) | Invert | ShiftState
( Precision time_expr; ) | User USER_DEFINED > ; )
} )* // end Reference })* // end LaunchClock
(Waveform;) (ScanDataType (ScanDataType_enum)+);
} ) // end TimingSensitive ( TestAccess <
} ) // end StrobeRequirements (Control | Observe
( ScanStyle < MultiplexedData | MultiplexedClock > (LevelSensitive) ; ) | User USER_DEFINED )+ >
( Wrapper <IEEE1500 | None | User USER_DEFINED > ( PinID < Macro | Procedure > NAME; )*
USER_DEFINED_PIN_ID ) ; ) ( Transform {
})+ // end sigref_expr ( WaveformTable (WFT_NAME)+; )
} // end Internal ( Invert ; )
}} // end Environment, CTLMode ( WFCMap FROM_WFC -> TO_WFC; )*
( DelayCycles INTEGER;)
Environment { CTLMode (CTLMODE_NAME) { } )* // end Transform
ScanInternal { } )* // end IsConnected
( cellref_expr { } )+ // end cellref_expr
( DataType ( data_type_enum )+ ; ) } // end ScanInternal
( DataType ( data_type_enum )+ { }} // end Environment, CTLMode
( ActiveState
< ForceDown | ForceUp Environment { CTLMode (CTLMODE_NAME) {
| ForceOff | ForceValid CoreInternal {
| ExpectLow | ExpectHigh ( sigref_expr { // format = coreinstance:signame
| ExpectOff | ExpectValid > ; ) ( DataType ( data_type_enum )+ ; )
( ScanDataType ( ScanDataType_enum )+ ; ) ( DataType ( data_type_enum )+ {

D03 14 9/7/04
 ( ActiveState ( MuxSet sigref_expr (sigref_expr { tag })+ ; )*
< ForceDown | ForceUp ( NotEquivalent sigref_expr sigref_expr; )*
| ForceOff | ForceValid ( OneCold sigref_expr; ) *
| ExpectLow | ExpectHigh ( OneHot sigref_expr; ) *
| ExpectOff | ExpectValid >;) ( Port sigref_expr (integer) ; )* // port data, port select value
( ScanDataType ( ScanDataType_enum )+ ; ) ( ZeroOneCold sigref_expr; ) *
( ValueRange INTEGER INTEGER (CORE_INSTANCE_NAME)+; )* ( ZeroOneHot sigref_expr; ) *
( UnusedRange INTEGER INTEGER;)* } // end Relation
}} // end Environment, CTLMode
} )* // end DataType
( IsConnected < In|Out > { Environment { CTLMode (CTLMODE_NAME) {
( CoreSignal sigref_expr ; ) ScanRelation {
( IsGatedBy <LogicAnd | LogicOr | LogicXor> logic_expr { ( Differential cellref_expr (cellref_expr) ; )*
( LOGICSIGNAME { ( Equivalent cellref_expr (cellref_expr); )*
Type < Signal | StateElement Scan | StateElement NonScan | ( OneCold cellref_expr; ) *
CoreSignal >; ( OneHot cellref_expr; ) *
Name <SIGNAME | CELLNAME | SYMBOLNAME>; ( ZeroOneCold cellref_expr; ) *
} )+ // end logicsigname ( ZeroOneHot cellref_expr; ) *
} )* // end IsGatedBy } // end ScanRelation
( IsGatedBy < Macro | Procedure > NAME ; )* }} // end Environment, CTLMode
( TestAccess
(Control Environment { CTLMode (CTLMODE_NAME) {
| Observe External {
| User USER_DEFINED )+ ( sigref_expr {
< Macro | Procedure > NAME; )* ( AllowSharedConnection {
( Transform { ( Core NAME (sigref_expr) ; )*
( WaveformTable (WFT_NAME)+; ) ( DataType (data_type_enum)+ ; )
( Invert ; ) ( Family (NAME)+ ; )
( WFCMap FROM_WFC -> TO_WFC; )* ( OutputFunction <And | Or | Xor> ; )
( DelayCycles INTEGER;) ( Self sigref_expr ; )
} )* // end Transform ( Vendor (NAME)+ ; )
} )* // end IsConnected } )* // end AllowSharedConnection
} )+ // end cellref_expr ( ConnectTo {
} // end CoreInternal ( Core NAME sigref_expr; )
}} // end Environment, CTLMode ( DataType (data_type_enum)+ ; )
( Fanout INTEGER; )
Environment { CTLMode (CTLMODE_NAME) { ( Instruction; )
Relation { ( NoRebuffering;)
( Bus sigref_expr (BUSNAME);)* ( Symbolic (SYMBOLIC_NAME)+; )
( Common sigref_expr ; )* ( TAM; )
( Corresponding sigref_expr ; )* ( Termination < TerminateHigh | TerminateLow | TerminateOff |
( Differential sigref_expr (sigref_expr) ; )* TerminateUnknown >
( Equivalent sigref_expr (sigref_expr); )* (TERMINATION_VALUE);)
( Independent sigref_expr (sigref_expr (Set) ); )* ( Safe; )
( InOutSet signame signame (signame); )* // enable, output name, input name ( WBR; )

D03 15 9/7/04
 ( Wrapper ( Identifiers { } )* // see below for Identifiers block syntax
<IEEE1500 | None | User USER_DEFINED > ( Protocol <Macro | Procedure>
(< CellID cell_enum | PinID USER_DEFINED_PIN_ID >) ; ) MACRO_OR_PROC_NAME (SETUP_MACRO_OR_PROC_NAME); )
} )* // end ConnectTo } )* // end Pattern | PatternBurst
} )+ // end sigref_expr ( PatternExec (EXEC_NAME) {
} // end External (Purpose (exec_enum)+ ;)
}} // end Environment, CTLMode ( PatternBurst (BURST_NAME)+ ; )
( CycleCount integer;)
procedure_or_macro_enum = ( Power power_expr < Average | Maximum > ; )*
< Capture | Control ( Fault { } )* // see below for Fault block syntax
| DoTest | DoTestOverlap } )* // end PatternExec
| Hold | Instruction ( < Procedure | Macro > PROCEDURE_OR_MACRO_NAME {
| MemoryPrecharge | MemoryRead ( Purpose ( procedure_or_macro_enum )+ ;)
| MemoryReadModifyWrite | MemoryRefresh ( ScanChain (CHAINNAME)+;)*
| MemoryWrite | ModeControl ( UseByPattern (pattern_or_burst_enum)+; )
| Observe | Operate ( Identifiers { } )* // see below for Identifiers block syntax
| ShiftIn | ShiftOut } )* // end Procedure | Macro
| Transfer | Update ( WaveformTable (WFT)+ {
| User USER_DEFINED > (Purpose (< Shift | Capture | Data | User USER_DEFINED >)+ ;)
( WaveformChar (WFC)+
identifier_event_enum= (< Level | Pulse | DoublePulse | Complex >)
<Capture | Control ( < Critical | NonCritical >)
| ControlObserve | DataFromCurrentActivity ( Measure); )*
| DataFromPriorActivity | DataFromCurrentAndPriorActivity } )* // end WaveformTable
| Hold | Measure } // end PatternInformation
| Observe | TestPatternUnit }} // end Environment, CTLMode
| Reference | Transfer
| Update | User USER_DEFINED > Identifiers (PATTERN_OR_BURST_ENUM)* {
( EventType identifier_event_enum {
Environment { CTLMode (CTLMODE_NAME) { <( < Label | Xref > LABEL_ID {
PatternInformation { ( < Prefix | Complete > ; )
( < Pattern | PatternBurst > (pat_or_burst_name) { ( <Begin | During | End> ; )
(Purpose (pattern_or_burst_enum)+ ;) ( SequenceNumber INTEGER; )
( CoreInstance (CORE_INSTANCE_NAME)+; ) ( EventValue (time_expr)+; )
( CycleCount integer;) } )+// end Label | Xref
( Power power_expr < Average | Maximum > ; )* | ( Variable (VAR_NAME (values)*); )+>
( Fault { } )* // see below for Fault block syntax } )* // end EventType
( FileName FILE_NAME ;) } )* // end Identifiers
( ForeignPatterns {
( BlockName NAME; )
( BeginLine LINE_NUM; )
( EndLine LINE_NUM; )
( BeginLabel LABEL; )
( EndLabel LABEL; )
} ) // end ForeignPatterns

D03 16 9/7/04
Fault {
( Type
< Toggle | StuckAt STIL name spaces
| StuckOpen | Transition
| Path | Bridge STIL block Type of Name Domain restrictions
| PseudoStuckAt | User USER_DEFINED >
(<Collapsed | UnCollapsed | Estimated>);) Environment Environment domain Supports a single unnamed block
( Boundary < Cell | Primitive >; ) names and domain named blocks. Domain
( FaultCount integer; ) names shall be unique across all
( FaultsDetected integer ; ) Environment blocks.
( FaultsDetected integer {
(Simulation integer;) Variables Variables domain Supports a single unnamed block
(Implication integer;) names and domain named blocks. Domain
(Robustly integer;) names shall be unique across all
}) Variables blocks.
( FaultsPossiblyDetected integer;) // detection credit with X Variables, Signals, Signal names Names are present in this name
( FaultsPossiblyDetected integer { SignalGroups, SignalGroup names space are dependent on the domain
(PossibleX integer ; ) Spec SignalVariable names reference statements in the Pattern-
(Oscillatory integer ; ) Spec variable names Burst (SignalGroups domains,
(Hypertrophic integer ; ) Integer names Variables domains) and the Pat-
}) IntegerConstant names ternExec (Category domains).
( FaultsUntestable integer;) WFCConstant names It is an error for defined Variable,
( FaultsUntestable integer { or Constant names to conflict with
(Dangling integer;) Signals, SignalGroups, or Spec
(FixedValues integer;) variable names accessible in the
(Blocked integer;) same context.
(Redundant integer;)
}) ScanStructures ScanCell names Names present in this space are
( FaultsNotDetected integer;) ScanChain names (also dependent on the domain reference
( FaultsNotDetected integer { used for scan segments statements for ScanStructures in
(Uncontrolled integer;) and cell groups) the PatternBurst. Scan cell names,
(Unobserved integer;) scan chain names, and cell group
(ATPGlimitations integer; ) names in this common name space
(Oscillatory integer ; ) are unique except if an unnamed
(Hypertrophic integer ; ) ScanStructures block exists. Then
}) the names present in that unnamed
( MultiplyDetected integer { block are available unless hidden
FaultsDetected ... by a definition of the same name in
FaultsPossiblyDetected ... a named and referenced ScanStruc-
FaultsUntestable ... ture block.
FaultsNotDetected ...
})*
} // end Fault

D03 17 9/7/04
 Operators and functions allowed in expressions

stmt token
Operators and functions allowed in expressions

bool-arith

user func
bool-sig
integer

sigvar
sigref
logic
time
real
Op Definition

stmt token
bool-arith

user func
bool-sig
integer

sigvar
sigref
logic
time
real
Op Definition
:: double colon - used as a Y
domain reference operator:
min () minimum value Y Y Y ddd::yyy means name
’yyy’ within domain ’ddd’
max ( ) maximum value Y Y Y ! negation (boolean value) Y Y

~ bit-wise negation Y Y Y
Merged- boolean function that Y Y Y Y
Scan ( ) returns true to select @ timing event reference Y
BreakPoint or other option
0x used to define hexadecimal Y
during scan operation (sub-
constants - 0xFF
clause 6.10).
. dot operator used as string Y
() parenthesis Y Y Y Y Y Y
concatenation (for long
, comma - used as a separa- Y strings):
tor in user functions xxx.yyy yields string xxx-
yyy
table 3, SI units & prefixes Y Y
table 4 of / divide Y Y Y Y
STIL.0
* multiply Y Y Y Y
. dot - used as a domain ref- Y
% modulus Y Y
erence operator:
xxx.yyy means item yyy + add Y Y Y Y Y
within object xxx (used
only in Timing context of - subtract Y Y Y Y Y
STIL.0)
< less than (boolean value) Y Y Y Y
: single colon - reserved for
> greater than (boolean Y Y Y Y
referencing sub-compo-
value)
nents of a design (i.e.,
embedded cores). When <= less or equal (boolean Y Y Y Y
used in conjunction with value)
double colon, the usage
shall be as follows: >= greater or equal (boolean Y Y Y Y
ccc:ddd::xxx means name value)
’xxx’ within core ’ccc’
&& and (boolean value) Y Y Y
with domain ’ddd’.

D03 18 9/7/04
 Operators and functions allowed in expressions
Backslash pattern data operators

stmt token
bool-arith

user func
bool-sig
integer

sigvar
sigref
logic
time
real
Op Definition

Operator

Result
Std Function Usagea
(defined in bnf)
|| or (boolean value) Y Y Y
\d wfc STIL.0 decimal representa- \d integer term
== equal (boolean, wfc) Y
tion of WFC’s
!= not equal (boolean, wfc) Y
\e event STIL.0 list of events \e event_list term
:== equal (boolean, real and Y
integer) \h wfc STIL.0 hex representation of \h hex_number term
WFC’s
:!= not equal (boolean, real Y
\j wfc STIL.1 join WFC’s on two \j < wfc_ref > term
and integer)
signals
& bit-wise and Y Y
\l wfc STIL.0 length specifier \l integer
| bit-wise inclusive or Y Y < wfc_ref | \h hex_number | \d
integer | \e event_list >
^ bit-wise exclusive or Y Y term
^~, ~^ bit-wise equivalence Y Y \m wfc STIL.1 map WFC to WFC \m < wfc_ref > term
?: conditional expression Y Y Y Y Y Y \r wfc STIL.0 repeat list of WFC’s \r integer
< wfc_ref | \h hex_number | \d
= assignment (wfc) Y Y
integer | \e event_list >
:= assignment (real and inte- Y Y Y term
ger)
\w wfc STIL.0 list of WFC’s \w wfc_list term
.. range operator (ellipsis) Y Y
\C event STIL.1 return list of compare \C wfc_container term
events

\D event STIL.1 return list of compare \D wfc_container term

events

\E event STIL.1 return list of compare \E wfc_container term

events

\S wfc STIL.1 return substitute \S wfc_container term

WFC’s (i.e. read
back)

\U event STIL.1 return list of compare \U wfc_container term

events

\W wfc STIL.1 return list of WFC’s \W wfc_container term

D03 19 9/7/04
 a. The following syntax definitions apply: Waveform events in pattern data - using \e
*_name = as defined in STIL.0 subclause 6.10 (note: allows "name" and
name[n..m] formats) Drive Compare
integer = as defined in STIL.0 subclause 6.12 D C
Action Action
hex_number = as defined in STIL.0 subclause 6.12
wfc_list = as defined in STIL.0 subclause 6.15 High U drive high at start of H, h H = high edge strobe at period
wfc_container = < signal_name | signal_group_name | period start; h = start high window
signal_variable_name | wfc_constant_name > compare at period start
wfc_ref = < wfc_list | \m wfc_list | "\W"wfc_container > term
drive_event = < "D" | "U" | "Z" | "P" > Low D drive low at start of L, l L = low edge strobe at period
compare_event = < "L" | "H" | "X" | "x" | "T" | "V" | "l" | "h" | "t" | "v" | "S" | period start; l = start low window com-
"s" > pare at period start
expect_event = < "R" | "G" | "Q" | "M" >
unresolved event = < "N" | "S" | "A" | "B" | "F" | "?" > Off Z drive off at start of T, t T = tri-state edge strobe at
event_list = (< drive_event | compare_event | expect_event | unresolved period period start; t = start tri-state
event >)+ window compare at period start
term = < " " | ";" > Don’t n/ n/a X, x don’t compare; terminate win-
compare a dow compare; takes effect at
period start

Unspecified N drive high or low S, s S = compare H/L/T at period

(application can start; s = start window compare
choose) h/l/t at period start; actual state
unknown; also used for block
read

Unknown ? input/output and ? input/output and level are

level are unknown unknown

D03 20 9/7/04
 Engineering Units
Pre Descr Mult Unit Description
E exa 10 18
A Amperes
P peta 10 15
Cel Degrees Celsius
T tera 1012
F Farads
G giga 109
H Henrys (inductance)
M mega 106
Hz Hertz
k kilo 103
m milli m Meter
10-3
u micro Ohm Ohms
10-6
n nano 10-9 s Seconds
p pico 10-12 W Watts
f femto 10-15 V Volts
a atto 10-18

Events
Drive Compare Expect
D ForceDown L CompareLow R ExpectLow
U ForceUp H CompareHigh G ExpectHigh
Z ForceOff X CompareUnknown Q ExpectOff
P ForcePrior x M Marker
T CompareOff
V CompareValid
l CompareLowWin- Unresolved
dow N ForceUnknown
h CompareHighWin- A LogicLow
dow B LogicHigh
t CompareOffWindow F LogicZ
v CompareValidWin- ? Unknown
dow
S CompareSubstitute
s CompareSubsti-
tuteWindow

D03 21 9/7/04