roka/bds.mr.jtg
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial check in

Browse Source
This commit is contained in:
Róka Miklós
2026-01-08 19:12:06 +01:00
commit a30568e2a9
35 changed files with 11750 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src.jtag/svf/grammar/jtag.svfLexer.g
+247
View File
@@ -0,0 +1,247 @@
unit jtag.svfLexer;
// ----------------------------------------------------------------------------
// This section is used for generating "uses" clause in the unit 'svfLexer'.
// Every unit name must be terminated with ';'
// e.g:
//
// uses
// {
// Classes;
// SysUtils;
// }
// ----------------------------------------------------------------------------
uses
{
}
// ----------------------------------------------------------------------------
// This section is used for generating "const" clause in the unit 'svfLexer'.
// The content of the section is verbatim copied into the generated code.
// ----------------------------------------------------------------------------
//const
//{
//}
// ----------------------------------------------------------------------------
// This section is used for generating "type" clause in the unit 'svfLexer'.
// The content of the section is verbatim copied into the generated code.
// ----------------------------------------------------------------------------
type
{
}
// ============================================================================
// Lexer class declaration
// ============================================================================
lexer TsvfLexer;
// ----------------------------------------------------------------------------
// Lexer options
// ----------------------------------------------------------------------------
options
{
k = 2;
exportVocab = jtag.svfLexer;
caseSensitive = false;
}
// ----------------------------------------------------------------------------
// Lexer tokens. Usualy string literals.
// ----------------------------------------------------------------------------
tokens
{
// ------------
// SVF Commands
// ------------
"ENDDR";
"ENDIR";
"FREQUENCY";
"HDR";
"HIR";
"PIO";
"PIOMAP";
"RUNTEST";
"SDR";
"SIR";
"STATE";
"TDR";
"TIR";
"TRST";
// ------------
// TAP States
// ------------
"RESET";
"IDLE";
"DRSELECT";
"DRCAPTURE";
"DRSHIFT";
"DRPAUSE";
"DREXIT1";
"DREXIT2";
"DRUPDATE";
"IRSELECT";
"IRCAPTURE";
"IRSHIFT";
"IRPAUSE";
"IREXIT1";
"IREXIT2";
"IRUPDATE";
"HZ";
"TDI";
"TDO";
"MASK";
"SMASK";
"IN";
"OUT";
"INOUT";
"SEC";
"MAXIMUM";
"ENDSTATE";
"TCK";
"SCK";
"ON";
"OFF";
"Z";
"ABSENT";
INT;
FLOAT;
}
// ----------------------------------------------------------------------------
// Lexer member declarations.
// All user defined member declarations should be placed here.
// The content of the section is verbatim copied into the generated code.
// ----------------------------------------------------------------------------
memberdecl
{
protected
fOnNewline : TNotifyEvent;
public
property OnNewline : TNotifyEvent read fOnNewline write fOnNewline;
}
// ============================================================================
// Begin rule definitions
//
// Remember: All lexer rule names must begin with UPPERCASE letter!
// ============================================================================
SEMI : ';';
LPAREN : '(';
RPAREN : ')';
ID
options
{
testLiterals = true;
}
: ('A'..'Z' | 'a'..'z') ('A'..'Z' | 'a'..'z' | '0'..'9')*
;
NUMBER
:
DIGITS { _ttype := TT_INT; }
( '.' DIGITS { _ttype := TT_FLOAT;} )?
( EXP (SIGN)? DIGITS { _ttype := TT_FLOAT;} )?
;
protected
VECTOR
:
'H' | 'L' | 'Z' | 'U' | 'D' | 'X' |
'h' | 'l' | 'z' | 'u' | 'd' | 'x'
;
protected
EXP
: 'E' | 'e'
;
protected
SIGN
: '+' | '-'
;
protected DIGIT : '0'..'9';
protected DIGITS : (DIGIT)+ ;
//protected XDIGIT : 'a'..'f' | 'A'..'F' | '0'..'9';
//protected XDIGITS : (XDIGIT)+ ;
// ----------------------------------------------------------------------------
// SLCOMMENT
// ----------------------------------------------------------------------------
SLCOMMENT
:
("//" | '!')
( ~( '\r' | '\n') )*
(
options
{
generateAmbigWarnings = false;
}
: '\r' '\n' { newLine; if Assigned( fOnNewline) then fOnNewline(self); }
| '\r' { newLine; if Assigned( fOnNewline) then fOnNewline(self); }
| '\n' { newLine; if Assigned( fOnNewline) then fOnNewline(self); }
)
{
_ttype := TT_SKIP;
}
;
// ----------------------------------------------------------------------------
// NEWLINE
// ----------------------------------------------------------------------------
NEWLINE
:
(
options
{
generateAmbigWarnings = false;
}
: '\r' '\n' { newLine; if Assigned( fOnNewline) then fOnNewline(self); }
| '\r' { newLine; if Assigned( fOnNewline) then fOnNewline(self); }
| '\n' { newLine; if Assigned( fOnNewline) then fOnNewline(self); }
)
{
_ttype := TT_SKIP;
}
;
// ----------------------------------------------------------------------------
// WHITESPACE
// ----------------------------------------------------------------------------
WHITESPACE
:
(
' '
| '\t' { tab; }
)
{
_ttype := TT_SKIP;
}
;
// ============================================================================
// End rule definitions
// ============================================================================
// ----------------------------------------------------------------------------
// This section is used for generating member defintions in the unit 'svfLexer'.
// The content of the section is verbatim copied into the generated code.
// ----------------------------------------------------------------------------
memberdef
{
}
src.jtag/svf/grammar/jtag.svfLexer.pas
+785
View File
@@ -0,0 +1,785 @@
// ============================================================================
// This file is generated by the Delphi Parser Generator.
// ----------------------------------------------------------------------------
// DPG version: 2.1.0.0r
// Grammar: jtag.svfLexer.g
// ============================================================================
unit jtag.svfLexer;
interface
uses
System.Classes,
dpgrtl.lexer,
dpgrtl.types,
jtag.svfLexerTokens,
SysUtils;
type
// =========================================================================
// Type declarations from grammar.
// =========================================================================
// =========================================================================
// Class TsvfLexer declaration
// =========================================================================
TsvfLexer = class( TLexer)
protected
fOnNewline : TNotifyEvent;
public
property OnNewline : TNotifyEvent read fOnNewline write fOnNewline;
protected // Internals
procedure initialize; override;
public // Protected grammar rules
// Must callable from parser too
procedure mDIGITS ( pCreate: boolean);
procedure mEXP ( pCreate: boolean);
procedure mSIGN ( pCreate: boolean);
procedure mVECTOR ( pCreate: boolean);
procedure mDIGIT ( pCreate: boolean);
public // Public grammar rules
procedure mSEMI ( pCreate: boolean);
procedure mLPAREN ( pCreate: boolean);
procedure mRPAREN ( pCreate: boolean);
procedure mID ( pCreate: boolean);
procedure mNUMBER ( pCreate: boolean);
procedure mSLCOMMENT ( pCreate: boolean);
procedure mNEWLINE ( pCreate: boolean);
procedure mWHITESPACE ( pCreate: boolean);
public
function NextToken: IToken; override;
end;
implementation
uses
dpgrtl.exception,
dpgrtl.token;
// ============================================================================
// mSEMI
// ============================================================================
procedure TsvfLexer.mSEMI( pCreate: boolean);
var
_begin: integer;
_save: integer;
_token: IToken;
_ttype: integer;
begin
_begin := Length( TokenText) +1;
_token := nil;
_ttype := TT_SEMI;
match(';');
if (_ttype <> TT_SKIP) and (pCreate = true) then
begin
_token := makeToken( _ttype);
_token.TokenText := Copy( TokenText, _begin, Length(TokenText)-_begin+1);
end;
ReturnToken := _token;
end;
// ============================================================================
// mLPAREN
// ============================================================================
procedure TsvfLexer.mLPAREN( pCreate: boolean);
var
_begin: integer;
_save: integer;
_token: IToken;
_ttype: integer;
begin
_begin := Length( TokenText) +1;
_token := nil;
_ttype := TT_LPAREN;
match('(');
if (_ttype <> TT_SKIP) and (pCreate = true) then
begin
_token := makeToken( _ttype);
_token.TokenText := Copy( TokenText, _begin, Length(TokenText)-_begin+1);
end;
ReturnToken := _token;
end;
// ============================================================================
// mRPAREN
// ============================================================================
procedure TsvfLexer.mRPAREN( pCreate: boolean);
var
_begin: integer;
_save: integer;
_token: IToken;
_ttype: integer;
begin
_begin := Length( TokenText) +1;
_token := nil;
_ttype := TT_RPAREN;
match(')');
if (_ttype <> TT_SKIP) and (pCreate = true) then
begin
_token := makeToken( _ttype);
_token.TokenText := Copy( TokenText, _begin, Length(TokenText)-_begin+1);
end;
ReturnToken := _token;
end;
// ============================================================================
// mID
// ============================================================================
procedure TsvfLexer.mID( pCreate: boolean);
var
_begin: integer;
_save: integer;
_token: IToken;
_ttype: integer;
begin
_begin := Length( TokenText) +1;
_token := nil;
_ttype := TT_ID;
if (( LA(1) in ['A'..'Z'])) then
begin
match( ['A'..'Z']);
end
else if (( LA(1) in ['a'..'z'])) then
begin
match( ['a'..'z']);
end
else
Raise EMismatchedChar.Create( LA(1), ['A'..'Z','a'..'z'], InputState.FileName, InputState.Line, InputState.Column);
while(true) do
begin
if (( LA(1) in ['A'..'Z'])) then
begin
match( ['A'..'Z']);
end
else if (( LA(1) in ['a'..'z'])) then
begin
match( ['a'..'z']);
end
else if (( LA(1) in ['0'..'9'])) then
begin
match( ['0'..'9']);
end
else
break;
end;
_ttype := TestLiteral( _ttype);
if (_ttype <> TT_SKIP) and (pCreate = true) then
begin
_token := makeToken( _ttype);
_token.TokenText := Copy( TokenText, _begin, Length(TokenText)-_begin+1);
end;
ReturnToken := _token;
end;
// ============================================================================
// mNUMBER
// ============================================================================
procedure TsvfLexer.mNUMBER( pCreate: boolean);
var
_begin: integer;
_save: integer;
_token: IToken;
_ttype: integer;
begin
_begin := Length( TokenText) +1;
_token := nil;
_ttype := TT_NUMBER;
mDIGITS(false);
_ttype := TT_INT;
if (( LA(1) in ['.'])) then
begin
match('.');
mDIGITS(false);
_ttype := TT_FLOAT;
end;
if (( LA(1) in ['E','e'])) then
begin
mEXP(false);
if (( LA(1) in ['+','-'])) then
begin
mSIGN(false);
end;
mDIGITS(false);
_ttype := TT_FLOAT;
end;
if (_ttype <> TT_SKIP) and (pCreate = true) then
begin
_token := makeToken( _ttype);
_token.TokenText := Copy( TokenText, _begin, Length(TokenText)-_begin+1);
end;
ReturnToken := _token;
end;
// ============================================================================
// mDIGITS
// ============================================================================
procedure TsvfLexer.mDIGITS( pCreate: boolean);
var
_begin: integer;
_cnt_18: integer;
_save: integer;
_token: IToken;
_ttype: integer;
begin
_begin := Length( TokenText) +1;
_token := nil;
_ttype := TT_DIGITS;
_cnt_18 := 0;
while(true) do
begin
if (( LA(1) in ['0'..'9'])) then
begin
mDIGIT(false);
end
else
begin
if _cnt_18 >= 1 then
break
else
Raise EMismatchedChar.Create( LA(1), ['0'..'9'], InputState.FileName, InputState.Line, InputState.Column);
end;
INC(_cnt_18);
end;
if (_ttype <> TT_SKIP) and (pCreate = true) then
begin
_token := makeToken( _ttype);
_token.TokenText := Copy( TokenText, _begin, Length(TokenText)-_begin+1);
end;
ReturnToken := _token;
end;
// ============================================================================
// mEXP
// ============================================================================
procedure TsvfLexer.mEXP( pCreate: boolean);
var
_begin: integer;
_save: integer;
_token: IToken;
_ttype: integer;
begin
_begin := Length( TokenText) +1;
_token := nil;
_ttype := TT_EXP;
if (( LA(1) in ['E'])) then
begin
match('E');
end
else if (( LA(1) in ['e'])) then
begin
match('e');
end
else
Raise EMismatchedChar.Create( LA(1), ['E','e'], InputState.FileName, InputState.Line, InputState.Column);
if (_ttype <> TT_SKIP) and (pCreate = true) then
begin
_token := makeToken( _ttype);
_token.TokenText := Copy( TokenText, _begin, Length(TokenText)-_begin+1);
end;
ReturnToken := _token;
end;
// ============================================================================
// mSIGN
// ============================================================================
procedure TsvfLexer.mSIGN( pCreate: boolean);
var
_begin: integer;
_save: integer;
_token: IToken;
_ttype: integer;
begin
_begin := Length( TokenText) +1;
_token := nil;
_ttype := TT_SIGN;
if (( LA(1) in ['+'])) then
begin
match('+');
end
else if (( LA(1) in ['-'])) then
begin
match('-');
end
else
Raise EMismatchedChar.Create( LA(1), ['+','-'], InputState.FileName, InputState.Line, InputState.Column);
if (_ttype <> TT_SKIP) and (pCreate = true) then
begin
_token := makeToken( _ttype);
_token.TokenText := Copy( TokenText, _begin, Length(TokenText)-_begin+1);
end;
ReturnToken := _token;
end;
// ============================================================================
// mVECTOR
// ============================================================================
procedure TsvfLexer.mVECTOR( pCreate: boolean);
var
_begin: integer;
_save: integer;
_token: IToken;
_ttype: integer;
begin
_begin := Length( TokenText) +1;
_token := nil;
_ttype := TT_VECTOR;
if (( LA(1) in ['H'])) then
begin
match('H');
end
else if (( LA(1) in ['L'])) then
begin
match('L');
end
else if (( LA(1) in ['Z'])) then
begin
match('Z');
end
else if (( LA(1) in ['U'])) then
begin
match('U');
end
else if (( LA(1) in ['D'])) then
begin
match('D');
end
else if (( LA(1) in ['X'])) then
begin
match('X');
end
else if (( LA(1) in ['h'])) then
begin
match('h');
end
else if (( LA(1) in ['l'])) then
begin
match('l');
end
else if (( LA(1) in ['z'])) then
begin
match('z');
end
else if (( LA(1) in ['u'])) then
begin
match('u');
end
else if (( LA(1) in ['d'])) then
begin
match('d');
end
else if (( LA(1) in ['x'])) then
begin
match('x');
end
else
Raise EMismatchedChar.Create( LA(1), ['D','H','L','U','X','Z','d','h','l','u','x','z'], InputState.FileName, InputState.Line, InputState.Column);
if (_ttype <> TT_SKIP) and (pCreate = true) then
begin
_token := makeToken( _ttype);
_token.TokenText := Copy( TokenText, _begin, Length(TokenText)-_begin+1);
end;
ReturnToken := _token;
end;
// ============================================================================
// mDIGIT
// ============================================================================
procedure TsvfLexer.mDIGIT( pCreate: boolean);
var
_begin: integer;
_save: integer;
_token: IToken;
_ttype: integer;
begin
_begin := Length( TokenText) +1;
_token := nil;
_ttype := TT_DIGIT;
match( ['0'..'9']);
if (_ttype <> TT_SKIP) and (pCreate = true) then
begin
_token := makeToken( _ttype);
_token.TokenText := Copy( TokenText, _begin, Length(TokenText)-_begin+1);
end;
ReturnToken := _token;
end;
// ============================================================================
// mSLCOMMENT
// ============================================================================
procedure TsvfLexer.mSLCOMMENT( pCreate: boolean);
var
_begin: integer;
_save: integer;
_token: IToken;
_ttype: integer;
begin
_begin := Length( TokenText) +1;
_token := nil;
_ttype := TT_SLCOMMENT;
if (( LA(1) in ['/'])) then
begin
match('//');
end
else if (( LA(1) in ['!'])) then
begin
match('!');
end
else
Raise EMismatchedChar.Create( LA(1), ['!','/'], InputState.FileName, InputState.Line, InputState.Column);
while(true) do
begin
if (( LA(1) in [#1..#9,#11..#12,#14..#255])) then
begin
match( [#1..#9,#11..#12,#14..#255]);
end
else
break;
end;
if (( LA(1) in [#13]) and (LA(2) in [#10])) then
begin
match(#13);
match(#10);
newLine; if Assigned( fOnNewline) then fOnNewline(self);
end
else if (( LA(1) in [#13])) then
begin
match(#13);
newLine; if Assigned( fOnNewline) then fOnNewline(self);
end
else if (( LA(1) in [#10])) then
begin
match(#10);
newLine; if Assigned( fOnNewline) then fOnNewline(self);
end
else
Raise EMismatchedChar.Create( LA(1), [#10,#13], InputState.FileName, InputState.Line, InputState.Column);
_ttype := TT_SKIP;
if (_ttype <> TT_SKIP) and (pCreate = true) then
begin
_token := makeToken( _ttype);
_token.TokenText := Copy( TokenText, _begin, Length(TokenText)-_begin+1);
end;
ReturnToken := _token;
end;
// ============================================================================
// mNEWLINE
// ============================================================================
procedure TsvfLexer.mNEWLINE( pCreate: boolean);
var
_begin: integer;
_save: integer;
_token: IToken;
_ttype: integer;
begin
_begin := Length( TokenText) +1;
_token := nil;
_ttype := TT_NEWLINE;
if (( LA(1) in [#13]) and (LA(2) in [#10])) then
begin
match(#13);
match(#10);
newLine; if Assigned( fOnNewline) then fOnNewline(self);
end
else if (( LA(1) in [#13])) then
begin
match(#13);
newLine; if Assigned( fOnNewline) then fOnNewline(self);
end
else if (( LA(1) in [#10])) then
begin
match(#10);
newLine; if Assigned( fOnNewline) then fOnNewline(self);
end
else
Raise EMismatchedChar.Create( LA(1), [#10,#13], InputState.FileName, InputState.Line, InputState.Column);
_ttype := TT_SKIP;
if (_ttype <> TT_SKIP) and (pCreate = true) then
begin
_token := makeToken( _ttype);
_token.TokenText := Copy( TokenText, _begin, Length(TokenText)-_begin+1);
end;
ReturnToken := _token;
end;
// ============================================================================
// mWHITESPACE
// ============================================================================
procedure TsvfLexer.mWHITESPACE( pCreate: boolean);
var
_begin: integer;
_save: integer;
_token: IToken;
_ttype: integer;
begin
_begin := Length( TokenText) +1;
_token := nil;
_ttype := TT_WHITESPACE;
if (( LA(1) in [' '])) then
begin
match(' ');
end
else if (( LA(1) in [#9])) then
begin
match(#9);
tab;
end
else
Raise EMismatchedChar.Create( LA(1), [#9,' '], InputState.FileName, InputState.Line, InputState.Column);
_ttype := TT_SKIP;
if (_ttype <> TT_SKIP) and (pCreate = true) then
begin
_token := makeToken( _ttype);
_token.TokenText := Copy( TokenText, _begin, Length(TokenText)-_begin+1);
end;
ReturnToken := _token;
end;
// ----------------------------------------------------------------------------
// NextToken
// ----------------------------------------------------------------------------
function TsvfLexer.NextToken : IToken;
var
_first : TCharSet;
begin
_first := [#9..#10,#13,' '..'!','('..')','/'..'9',';','A'..'Z','a'..'z'];
while( true) do
begin
ResetText;
try
if (( LA(1) in [';'])) then
begin
mSEMI(true);
result := ReturnToken;
end
else if (( LA(1) in ['('])) then
begin
mLPAREN(true);
result := ReturnToken;
end
else if (( LA(1) in [')'])) then
begin
mRPAREN(true);
result := ReturnToken;
end
else if (( LA(1) in ['A'..'Z','a'..'z'])) then
begin
mID(true);
result := ReturnToken;
end
else if (( LA(1) in ['0'..'9'])) then
begin
mNUMBER(true);
result := ReturnToken;
end
else if (( LA(1) in ['!','/'])) then
begin
mSLCOMMENT(true);
result := ReturnToken;
end
else if (( LA(1) in [#10,#13])) then
begin
mNEWLINE(true);
result := ReturnToken;
end
else if (( LA(1) in [#9,' '])) then
begin
mWHITESPACE(true);
result := ReturnToken;
end
else
begin
if LA(1) = EOF_CHAR then
begin
uponEof;
result := TToken.Create(TT_EOF);
end
else
Raise EMismatchedChar.Create(LA(1), _first, InputState.FileName, InputState.Line, InputState.Column);
end;
// --------------------------------------------------------------
// If we found a SKIP token, then try again...
// --------------------------------------------------------------
if result = nil then
continue;
// --------------------------------------------------------------
// Now we have a valid token, so exit the function
// --------------------------------------------------------------
break;
except
Raise;
end;
end;
end;
// ----------------------------------------------------------------------------
// InitLiterals
// ----------------------------------------------------------------------------
procedure TsvfLexer.initialize;
begin
fCaseSensitive := false;
fLiterals.CaseSensitive := false;
fLiterals['drselect' ] := 20;
fLiterals['pio' ] := 9;
fLiterals['mask' ] := 37;
fLiterals['absent' ] := 50;
fLiterals['idle' ] := 19;
fLiterals['drupdate' ] := 26;
fLiterals['tdo' ] := 36;
fLiterals['hdr' ] := 7;
fLiterals['ircapture' ] := 28;
fLiterals['enddr' ] := 4;
fLiterals['out' ] := 40;
fLiterals['drpause' ] := 23;
fLiterals['off' ] := 48;
fLiterals['tir' ] := 16;
fLiterals['drexit2' ] := 25;
fLiterals['irupdate' ] := 33;
fLiterals['tdr' ] := 15;
fLiterals['on' ] := 47;
fLiterals['inout' ] := 41;
fLiterals['sdr' ] := 12;
fLiterals['irexit1' ] := 31;
fLiterals['state' ] := 14;
fLiterals['drexit1' ] := 24;
fLiterals['irpause' ] := 30;
fLiterals['endir' ] := 5;
fLiterals['drshift' ] := 22;
fLiterals['maximum' ] := 43;
fLiterals['tdi' ] := 35;
fLiterals['frequency' ] := 6;
fLiterals['hir' ] := 8;
fLiterals['hz' ] := 34;
fLiterals['runtest' ] := 11;
fLiterals['smask' ] := 38;
fLiterals['in' ] := 39;
fLiterals['tck' ] := 45;
fLiterals['z' ] := 49;
fLiterals['reset' ] := 18;
fLiterals['sck' ] := 46;
fLiterals['sir' ] := 13;
fLiterals['irselect' ] := 27;
fLiterals['trst' ] := 17;
fLiterals['irshift' ] := 29;
fLiterals['irexit2' ] := 32;
fLiterals['endstate' ] := 44;
fLiterals['drcapture' ] := 21;
fLiterals['piomap' ] := 10;
fLiterals['sec' ] := 42;
end;
end.
src.jtag/svf/grammar/jtag.svfLexerTokens.pas
+77
View File
@@ -0,0 +1,77 @@
// ============================================================================
// This file is generated by the Delphi Parser Generator.
// ----------------------------------------------------------------------------
// DPG version: 2.1.0.0r
// Grammar: jtag.svfLexer.g
// ============================================================================
unit jtag.svfLexerTokens;
interface
const
LT_DRSELECT = 20;
LT_PIO = 9;
LT_MASK = 37;
LT_ABSENT = 50;
TT_ID = 56;
TT_NEWLINE = 64;
TT_EOF = 1;
TT_SEMI = 53;
TT_DIGIT = 61;
LT_IDLE = 19;
LT_DRUPDATE = 26;
LT_TDO = 36;
LT_HDR = 7;
LT_IRCAPTURE = 28;
LT_ENDDR = 4;
LT_OUT = 40;
LT_DRPAUSE = 23;
LT_OFF = 48;
LT_TIR = 16;
LT_DREXIT2 = 25;
TT_SIGN = 60;
LT_IRUPDATE = 33;
LT_TDR = 15;
TT_RPAREN = 55;
LT_ON = 47;
LT_INOUT = 41;
LT_SDR = 12;
LT_IREXIT1 = 31;
LT_STATE = 14;
TT_DIGITS = 62;
LT_DREXIT1 = 24;
LT_IRPAUSE = 30;
TT_SLCOMMENT = 63;
LT_ENDIR = 5;
LT_DRSHIFT = 22;
LT_MAXIMUM = 43;
LT_TDI = 35;
LT_FREQUENCY = 6;
LT_HIR = 8;
LT_HZ = 34;
LT_RUNTEST = 11;
LT_SMASK = 38;
LT_IN = 39;
LT_TCK = 45;
LT_Z = 49;
LT_RESET = 18;
TT_INT = 51;
LT_SCK = 46;
TT_FLOAT = 52;
TT_VECTOR = 58;
LT_SIR = 13;
TT_EXP = 59;
LT_IRSELECT = 27;
LT_TRST = 17;
LT_IRSHIFT = 29;
TT_LPAREN = 54;
TT_NUMBER = 57;
LT_IREXIT2 = 32;
TT_WHITESPACE = 65;
LT_ENDSTATE = 44;
LT_DRCAPTURE = 21;
LT_PIOMAP = 10;
LT_SEC = 42;
implementation
end.
src.jtag/svf/grammar/jtag.svfLexerTokens.txt
+65
View File
@@ -0,0 +1,65 @@
// $Delphi Parser Generator: jtag.svfLexer.g -> jtag.svfLexer.gTokens.txt$
TsvfLexer
LT_DRSELECT="DRSELECT"=20
LT_PIO="PIO"=9
LT_MASK="MASK"=37
LT_ABSENT="ABSENT"=50
TT_ID=56
TT_NEWLINE=64
TT_EOF=1
TT_SEMI=53
TT_DIGIT=61
LT_IDLE="IDLE"=19
LT_DRUPDATE="DRUPDATE"=26
LT_TDO="TDO"=36
LT_HDR="HDR"=7
LT_IRCAPTURE="IRCAPTURE"=28
LT_ENDDR="ENDDR"=4
LT_OUT="OUT"=40
LT_DRPAUSE="DRPAUSE"=23
LT_OFF="OFF"=48
LT_TIR="TIR"=16
LT_DREXIT2="DREXIT2"=25
TT_SIGN=60
LT_IRUPDATE="IRUPDATE"=33
LT_TDR="TDR"=15
TT_RPAREN=55
LT_ON="ON"=47
LT_INOUT="INOUT"=41
LT_SDR="SDR"=12
LT_IREXIT1="IREXIT1"=31
LT_STATE="STATE"=14
TT_DIGITS=62
LT_DREXIT1="DREXIT1"=24
LT_IRPAUSE="IRPAUSE"=30
TT_SLCOMMENT=63
LT_ENDIR="ENDIR"=5
LT_DRSHIFT="DRSHIFT"=22
LT_MAXIMUM="MAXIMUM"=43
LT_TDI="TDI"=35
LT_FREQUENCY="FREQUENCY"=6
LT_HIR="HIR"=8
LT_HZ="HZ"=34
LT_RUNTEST="RUNTEST"=11
LT_SMASK="SMASK"=38
LT_IN="IN"=39
LT_TCK="TCK"=45
LT_Z="Z"=49
LT_RESET="RESET"=18
TT_INT=51
LT_SCK="SCK"=46
TT_FLOAT=52
TT_VECTOR=58
LT_SIR="SIR"=13
TT_EXP=59
LT_IRSELECT="IRSELECT"=27
LT_TRST="TRST"=17
LT_IRSHIFT="IRSHIFT"=29
TT_LPAREN=54
TT_NUMBER=57
LT_IREXIT2="IREXIT2"=32
TT_WHITESPACE=65
LT_ENDSTATE="ENDSTATE"=44
LT_DRCAPTURE="DRCAPTURE"=21
LT_PIOMAP="PIOMAP"=10
LT_SEC="SEC"=42
src.jtag/svf/grammar/jtag.svfParser.g
+376
View File
@@ -0,0 +1,376 @@
unit jtag.svfParser;
// ----------------------------------------------------------------------------
// This section is used for generating "uses" clause in the unit 'svfParser'.
// Every unit name must be terminated with ';'
// e.g:
//
// uses
// {
// Classes;
// SysUtils;
// }
// ----------------------------------------------------------------------------
uses
{
jtag.svfScanLexer;
jtag.svfProgram;
jtag.svfAstNode;
jtag.svfAstEndDR;
jtag.svfAstEndIR;
jtag.svfAstState;
jtag.svfAstScan;
jtag.svfAstRuntest;
dpgrtl.tokenbuffer;
dpgrtl.parserstate;
}
// ----------------------------------------------------------------------------
// This section is used for generating "const" clause in the unit 'svfParser'.
// The content of the section is verbatim copied into the generated code.
// ----------------------------------------------------------------------------
//const
//{
//}
// ----------------------------------------------------------------------------
// This section is used for generating "type" clause in the unit 'svfParser'.
// The content of the section is verbatim copied into the generated code.
// ----------------------------------------------------------------------------
type
{
}
// ============================================================================
// Parser class declaration
// ============================================================================
parser TsvfParser;
// ----------------------------------------------------------------------------
// Parser options
// ----------------------------------------------------------------------------
options
{
k = 2;
importVocab = jtag.svfScanLexer;
exportVocab = jtag.svfParser;
}
// ----------------------------------------------------------------------------
// Parser member declarations.
// All user defined member declarations should be placed here.
// The content of the section is verbatim copied into the generated code.
// ----------------------------------------------------------------------------
memberdecl
{
protected
fProgram : TsvfProgram;
fScanLexer : TsvfScanLexer;
fOldPS : IParserState;
fNewPS : IParserState;
public
procedure AfterConstruction; override;
procedure BeforeDestruction; override;
protected
procedure AddENDDR( Value : byte);
procedure AddENDIR( Value : byte);
procedure AddFREQ( t : IToken);
}
// ============================================================================
// Begin rule definitions
//
// Remember: All parser rule names must begin with LOWERCASE letter!
// ============================================================================
svf[scan: TsvfScanLexer] returns [TsvfProgram]
local
{
ntb : ITokenBuffer;
}
{
fScanLexer := scan;
ntb := TTokenBuffer.Create( fScanLexer);
fOldPS := InputState;
fNewPS := TParserState.Create( ntb);
}
:
(command SEMI)*
{
result := fProgram;
}
;
command
local
{
xstate : byte;
sstate : byte;
trst : AnsiString;
s : AnsiString;
astScan : TsvfAstScan;
astState : TsvfAstState;
astRun : TsvfAstRuntest;
}
{
xstate := stNONDEF; // intermediate state
sstate := stNONDEF; // stable state
trst := '';
t := nil;
n := nil;
}
:
"ENDDR" sstate=stable_state { AddENDDR( sstate); }
| "ENDIR" sstate=stable_state { AddENDIR( sstate); }
| (t:"HDR" | t:"HIR" | t:"TDR" | t:"TIR" | t:"SDR" | t:"SIR" ) n:INT
{
astScan := TsvfAstScan.Create( t.TokenText, n.TokenText);
}
(
("TDI" scandata[0,astScan])
| ("TDO" scandata[1,astScan])
| ("MASK" scandata[2,astScan])
| ("SMASK" scandata[3,astScan])
)*
{
fProgram.AddStatement( astScan);
}
// -----------------------------------------------------
// STATE
// -----------------------------------------------------
| "STATE"
{
astState := TsvfAstState.Create;
astState.BeginData;
}
(
xstate=state
{
astState.AddState( xstate);
}
)*
sstate=stable_state
{
astState.AddState( sstate);
astState.EndData;
fProgram.AddStatement( astState);
}
// ---------------------------------------------------------------
// RUNTEST
// ---------------------------------------------------------------
| "RUNTEST"
{
astRun := TsvfAstRuntest.Create;
astRun.BeginData;
}
(
sstate=stable_state
{
astRun.RunState := sstate;
}
)?
(
t:INT s=run_clk
{
astRun.RunCount := t.Tokentext;
astRun.RunClock := s;
}
(
(t:INT | t:FLOAT) "SEC"
{
astRun.MinTime := t.TokenText;
}
(
"MAXIMUM" t:INT "SEC"
{
astRun.MaxTime := t.Tokentext;
}
)?
)?
|
(t:INT | t:FLOAT) "SEC"
{
astRun.MinTime := t.TokenText;
}
(
"MAXIMUM" t:INT "SEC"
{
astRun.MaxTime := t.Tokentext;
}
)?
)
(
"ENDSTATE" sstate=stable_state
{
astRun.EndState := sstate;
}
)?
{
astRun.EndData;
fProgram.AddStatement( astRun);
}
// ---------------------------
// Not implemented commands...
// ---------------------------
| "TRST" trst=trst_val
| "FREQUENCY" f:FLOAT "HZ"
| "PIO" VECTOR
| "PIOMAP" LPAREN (direction ID)+ RPAREN
;
run_clk returns [AnsiString]
:
"TCK" { result := 'TCK'; }
| "SCK" { result := 'SCK'; }
;
trst_val returns [AnsiString]
:
"ON" { result := 'ON'; }
| "OFF" { result := 'OFF'; }
| "Z" { result := 'Z'; }
| "ABSENT" { result := 'ABSENT'; }
;
state returns [byte]
:
"RESET" { result := stRESET; }
| "IDLE" { result := stIDLE; }
| "DRSELECT" { result := stDRSELECT; }
| "DRCAPTURE" { result := stDRCAPTURE; }
| "DRSHIFT" { result := stDRSHIFT; }
| "DRPAUSE" { result := stDRPAUSE; }
| "DREXIT1" { result := stDREXIT1; }
| "DREXIT2" { result := stDREXIT2; }
| "DRUPDATE" { result := stDRUPDATE; }
| "IRSELECT" { result := stIRSELECT; }
| "IRCAPTURE" { result := stIRCAPTURE; }
| "IRSHIFT" { result := stIRSHIFT; }
| "IRPAUSE" { result := stIRPAUSE; }
| "IREXIT1" { result := stIREXIT1; }
| "IREXIT2" { result := stIREXIT2; }
| "IRUPDATE" { result := stIRUPDATE; }
;
stable_state returns [byte]
:
"RESET" { result := stRESET; }
| "IDLE" { result := stIDLE; }
| "DRPAUSE" { result := stDRPAUSE; }
| "IRPAUSE" { result := stIRPAUSE; }
;
// ============================================================================
// This is the tricky part... Use another lexer for scandata parsing.
// ============================================================================
scandata [idx: byte; scan: TsvfAstScan]
:
LPAREN
{
InputState := fNewPS;
scan.BeginData;
}
(
t:XDIGITS
{
case idx of
0: scan.AddTDI( t.TokenText);
1: scan.AddTDO( t.TokenText);
2: scan.AddMASK( t.TokenText);
3: scan.AddSMASK( t.TokenText);
end;
}
)+
RPAREN
{
scan.EndData;
InputState := fOldPS;
}
;
direction
:
"IN" | "OUT" | "INOUT"
;
// ============================================================================
// End rule definitions
// ============================================================================
// ----------------------------------------------------------------------------
// This section is used for generating member defintions in the unit 'svfParser'.
// The content of the section is verbatim copied into the generated code.
// ----------------------------------------------------------------------------
memberdef
{
// ============================================================================
// AfterConstruction
// ============================================================================
procedure TsvfParser.AfterConstruction;
begin
fProgram := TsvfProgram.Create;
end;
// ============================================================================
// BeforeDestruction
// ============================================================================
procedure TsvfParser.BeforeDestruction;
begin
fProgram.Free;
end;
// ============================================================================
// ENDDR
// ============================================================================
procedure TsvfParser.AddENDDR( Value: byte);
begin
fProgram.AddStatement( TsvfAstEndDR.Create( Value));
end;
// ============================================================================
// ENDIR
// ============================================================================
procedure TsvfParser.AddENDIR( Value: byte);
begin
fProgram.AddStatement( TsvfAstEndIR.Create( Value));
end;
// ============================================================================
// FREQUENCY
// ============================================================================
procedure TsvfParser.AddFREQ( t: IToken);
begin
end;
}
src.jtag/svf/grammar/jtag.svfParser.pas
+688
View File
@@ -0,0 +1,688 @@
// ============================================================================
// This file is generated by the Delphi Parser Generator.
// ----------------------------------------------------------------------------
// DPG version: 2.1.0.0r
// Grammar: jtag.svfParser.g
// ============================================================================
unit jtag.svfParser;
interface
uses
Classes,
dpgrtl.llkparser,
dpgrtl.parserstate,
dpgrtl.tokenbuffer,
dpgrtl.types,
jtag.svfAstEndDR,
jtag.svfAstEndIR,
jtag.svfAstNode,
jtag.svfAstRuntest,
jtag.svfAstScan,
jtag.svfAstState,
jtag.svfParserTokens,
jtag.svfProgram,
jtag.svfScanLexer,
SysUtils;
type
// =========================================================================
// Type declarations from grammar.
// =========================================================================
// =========================================================================
// Class TsvfParser declaration
// =========================================================================
TsvfParser = class( TLLkParser)
protected
fProgram : TsvfProgram;
fScanLexer : TsvfScanLexer;
fOldPS : IParserState;
fNewPS : IParserState;
public
procedure AfterConstruction; override;
procedure BeforeDestruction; override;
protected
procedure AddENDDR( Value : byte);
procedure AddENDIR( Value : byte);
procedure AddFREQ( t : IToken);
public // Public grammar rules
function svf ( scan: TsvfScanLexer): TsvfProgram;
procedure command ;
function stable_state : byte;
procedure scandata ( idx: byte; scan: TsvfAstScan);
function state : byte;
function run_clk : AnsiString;
function trst_val : AnsiString;
procedure direction ;
end;
implementation
uses
dpgrtl.exception,
dpgrtl.token;
// ============================================================================
// svf
// ============================================================================
function TsvfParser.svf( scan: TsvfScanLexer): TsvfProgram;
var
ntb : ITokenBuffer;
begin
fScanLexer := scan;
ntb := TTokenBuffer.Create( fScanLexer);
fOldPS := InputState;
fNewPS := TParserState.Create( ntb);
while(true) do
begin
if (( LA(1) in [LT_ENDDR..LT_TRST])) then
begin
command;
match(TT_SEMI);
end
else
break;
end;
result := fProgram;
end;
// ============================================================================
// command
// ============================================================================
procedure TsvfParser.command;
var
_cnt_23: integer;
f: IToken;
n: IToken;
t: IToken;
xstate : byte;
sstate : byte;
trst : AnsiString;
s : AnsiString;
astScan : TsvfAstScan;
astState : TsvfAstState;
astRun : TsvfAstRuntest;
begin
xstate := stNONDEF; // intermediate state
sstate := stNONDEF; // stable state
trst := '';
t := nil;
n := nil;
if (( LA(1) in [LT_ENDDR])) then
begin
match(LT_ENDDR);
sstate := stable_state;
AddENDDR( sstate);
end
else if (( LA(1) in [LT_ENDIR])) then
begin
match(LT_ENDIR);
sstate := stable_state;
AddENDIR( sstate);
end
else if (( LA(1) in [LT_HDR..LT_HIR,LT_SDR..LT_SIR,LT_TDR..LT_TIR])) then
begin
if (( LA(1) in [LT_HDR])) then
begin
t := LT(1);
match(LT_HDR);
end
else if (( LA(1) in [LT_HIR])) then
begin
t := LT(1);
match(LT_HIR);
end
else if (( LA(1) in [LT_TDR])) then
begin
t := LT(1);
match(LT_TDR);
end
else if (( LA(1) in [LT_TIR])) then
begin
t := LT(1);
match(LT_TIR);
end
else if (( LA(1) in [LT_SDR])) then
begin
t := LT(1);
match(LT_SDR);
end
else if (( LA(1) in [LT_SIR])) then
begin
t := LT(1);
match(LT_SIR);
end
else
Raise EMismatchedToken.Create( LT(1), [LT_HDR..LT_HIR,LT_SDR..LT_SIR,LT_TDR..LT_TIR], InputState.FileName);
n := LT(1);
match(TT_INT);
astScan := TsvfAstScan.Create( t.TokenText, n.TokenText);
while(true) do
begin
if (( LA(1) in [LT_TDI])) then
begin
match(LT_TDI);
scandata(0,astScan);
end
else if (( LA(1) in [LT_TDO])) then
begin
match(LT_TDO);
scandata(1,astScan);
end
else if (( LA(1) in [LT_MASK])) then
begin
match(LT_MASK);
scandata(2,astScan);
end
else if (( LA(1) in [LT_SMASK])) then
begin
match(LT_SMASK);
scandata(3,astScan);
end
else
break;
end;
fProgram.AddStatement( astScan);
end
else if (( LA(1) in [LT_STATE])) then
begin
match(LT_STATE);
astState := TsvfAstState.Create;
astState.BeginData;
while(true) do
begin
if (( LA(1) in [LT_RESET..LT_IRUPDATE]) and (LA(2) in [LT_RESET..LT_IRUPDATE])) then
begin
xstate := state;
astState.AddState( xstate);
end
else
break;
end;
sstate := stable_state;
astState.AddState( sstate);
astState.EndData;
fProgram.AddStatement( astState);
end
else if (( LA(1) in [LT_RUNTEST])) then
begin
match(LT_RUNTEST);
astRun := TsvfAstRuntest.Create;
astRun.BeginData;
if (( LA(1) in [LT_RESET..LT_IDLE,LT_DRPAUSE,LT_IRPAUSE])) then
begin
sstate := stable_state;
astRun.RunState := sstate;
end;
if (( LA(1) in [TT_INT]) and (LA(2) in [LT_TCK..LT_SCK])) then
begin
t := LT(1);
match(TT_INT);
s := run_clk;
astRun.RunCount := t.Tokentext;
astRun.RunClock := s;
if (( LA(1) in [TT_INT..TT_FLOAT])) then
begin
if (( LA(1) in [TT_INT])) then
begin
t := LT(1);
match(TT_INT);
end
else if (( LA(1) in [TT_FLOAT])) then
begin
t := LT(1);
match(TT_FLOAT);
end
else
Raise EMismatchedToken.Create( LT(1), [TT_INT..TT_FLOAT], InputState.FileName);
match(LT_SEC);
astRun.MinTime := t.TokenText;
if (( LA(1) in [LT_MAXIMUM])) then
begin
match(LT_MAXIMUM);
t := LT(1);
match(TT_INT);
match(LT_SEC);
astRun.MaxTime := t.Tokentext;
end;
end;
end
else if (( LA(1) in [TT_INT..TT_FLOAT]) and (LA(2) in [LT_SEC])) then
begin
if (( LA(1) in [TT_INT])) then
begin
t := LT(1);
match(TT_INT);
end
else if (( LA(1) in [TT_FLOAT])) then
begin
t := LT(1);
match(TT_FLOAT);
end
else
Raise EMismatchedToken.Create( LT(1), [TT_INT..TT_FLOAT], InputState.FileName);
match(LT_SEC);
astRun.MinTime := t.TokenText;
if (( LA(1) in [LT_MAXIMUM])) then
begin
match(LT_MAXIMUM);
t := LT(1);
match(TT_INT);
match(LT_SEC);
astRun.MaxTime := t.Tokentext;
end;
end
else
Raise EMismatchedToken.Create( LT(1), [TT_INT..TT_FLOAT], InputState.FileName);
if (( LA(1) in [LT_ENDSTATE])) then
begin
match(LT_ENDSTATE);
sstate := stable_state;
astRun.EndState := sstate;
end;
astRun.EndData;
fProgram.AddStatement( astRun);
end
else if (( LA(1) in [LT_TRST])) then
begin
match(LT_TRST);
trst := trst_val;
end
else if (( LA(1) in [LT_FREQUENCY])) then
begin
match(LT_FREQUENCY);
f := LT(1);
match(TT_FLOAT);
match(LT_HZ);
end
else if (( LA(1) in [LT_PIO])) then
begin
match(LT_PIO);
match(TT_VECTOR);
end
else if (( LA(1) in [LT_PIOMAP])) then
begin
match(LT_PIOMAP);
match(TT_LPAREN);
_cnt_23 := 0;
while(true) do
begin
if (( LA(1) in [LT_IN..LT_INOUT])) then
begin
direction;
match(TT_ID);
end
else
begin
if _cnt_23 >= 1 then
break
else
Raise EMismatchedToken.Create( LT(1), [LT_IN..LT_INOUT], InputState.FileName);
end;
INC(_cnt_23);
end;
match(TT_RPAREN);
end
else
Raise EMismatchedToken.Create( LT(1), [LT_ENDDR..LT_TRST], InputState.FileName);
end;
// ============================================================================
// stable_state
// ============================================================================
function TsvfParser.stable_state: byte;
begin
if (( LA(1) in [LT_RESET])) then
begin
match(LT_RESET);
result := stRESET;
end
else if (( LA(1) in [LT_IDLE])) then
begin
match(LT_IDLE);
result := stIDLE;
end
else if (( LA(1) in [LT_DRPAUSE])) then
begin
match(LT_DRPAUSE);
result := stDRPAUSE;
end
else if (( LA(1) in [LT_IRPAUSE])) then
begin
match(LT_IRPAUSE);
result := stIRPAUSE;
end
else
Raise EMismatchedToken.Create( LT(1), [LT_RESET..LT_IDLE,LT_DRPAUSE,LT_IRPAUSE], InputState.FileName);
end;
// ============================================================================
// scandata
// ============================================================================
procedure TsvfParser.scandata( idx: byte; scan: TsvfAstScan);
var
_cnt_30: integer;
t: IToken;
begin
match(TT_LPAREN);
InputState := fNewPS;
scan.BeginData;
_cnt_30 := 0;
while(true) do
begin
if (( LA(1) in [TT_XDIGITS])) then
begin
t := LT(1);
match(TT_XDIGITS);
case idx of
0: scan.AddTDI( t.TokenText);
1: scan.AddTDO( t.TokenText);
2: scan.AddMASK( t.TokenText);
3: scan.AddSMASK( t.TokenText);
end;
end
else
begin
if _cnt_30 >= 1 then
break
else
Raise EMismatchedToken.Create( LT(1), [TT_XDIGITS], InputState.FileName);
end;
INC(_cnt_30);
end;
match(TT_RPAREN);
scan.EndData;
InputState := fOldPS;
end;
// ============================================================================
// state
// ============================================================================
function TsvfParser.state: byte;
begin
if (( LA(1) in [LT_RESET])) then
begin
match(LT_RESET);
result := stRESET;
end
else if (( LA(1) in [LT_IDLE])) then
begin
match(LT_IDLE);
result := stIDLE;
end
else if (( LA(1) in [LT_DRSELECT])) then
begin
match(LT_DRSELECT);
result := stDRSELECT;
end
else if (( LA(1) in [LT_DRCAPTURE])) then
begin
match(LT_DRCAPTURE);
result := stDRCAPTURE;
end
else if (( LA(1) in [LT_DRSHIFT])) then
begin
match(LT_DRSHIFT);
result := stDRSHIFT;
end
else if (( LA(1) in [LT_DRPAUSE])) then
begin
match(LT_DRPAUSE);
result := stDRPAUSE;
end
else if (( LA(1) in [LT_DREXIT1])) then
begin
match(LT_DREXIT1);
result := stDREXIT1;
end
else if (( LA(1) in [LT_DREXIT2])) then
begin
match(LT_DREXIT2);
result := stDREXIT2;
end
else if (( LA(1) in [LT_DRUPDATE])) then
begin
match(LT_DRUPDATE);
result := stDRUPDATE;
end
else if (( LA(1) in [LT_IRSELECT])) then
begin
match(LT_IRSELECT);
result := stIRSELECT;
end
else if (( LA(1) in [LT_IRCAPTURE])) then
begin
match(LT_IRCAPTURE);
result := stIRCAPTURE;
end
else if (( LA(1) in [LT_IRSHIFT])) then
begin
match(LT_IRSHIFT);
result := stIRSHIFT;
end
else if (( LA(1) in [LT_IRPAUSE])) then
begin
match(LT_IRPAUSE);
result := stIRPAUSE;
end
else if (( LA(1) in [LT_IREXIT1])) then
begin
match(LT_IREXIT1);
result := stIREXIT1;
end
else if (( LA(1) in [LT_IREXIT2])) then
begin
match(LT_IREXIT2);
result := stIREXIT2;
end
else if (( LA(1) in [LT_IRUPDATE])) then
begin
match(LT_IRUPDATE);
result := stIRUPDATE;
end
else
Raise EMismatchedToken.Create( LT(1), [LT_RESET..LT_IRUPDATE], InputState.FileName);
end;
// ============================================================================
// run_clk
// ============================================================================
function TsvfParser.run_clk: AnsiString;
begin
if (( LA(1) in [LT_TCK])) then
begin
match(LT_TCK);
result := 'TCK';
end
else if (( LA(1) in [LT_SCK])) then
begin
match(LT_SCK);
result := 'SCK';
end
else
Raise EMismatchedToken.Create( LT(1), [LT_TCK..LT_SCK], InputState.FileName);
end;
// ============================================================================
// trst_val
// ============================================================================
function TsvfParser.trst_val: AnsiString;
begin
if (( LA(1) in [LT_ON])) then
begin
match(LT_ON);
result := 'ON';
end
else if (( LA(1) in [LT_OFF])) then
begin
match(LT_OFF);
result := 'OFF';
end
else if (( LA(1) in [LT_Z])) then
begin
match(LT_Z);
result := 'Z';
end
else if (( LA(1) in [LT_ABSENT])) then
begin
match(LT_ABSENT);
result := 'ABSENT';
end
else
Raise EMismatchedToken.Create( LT(1), [LT_ON..LT_ABSENT], InputState.FileName);
end;
// ============================================================================
// direction
// ============================================================================
procedure TsvfParser.direction;
begin
if (( LA(1) in [LT_IN])) then
begin
match(LT_IN);
end
else if (( LA(1) in [LT_OUT])) then
begin
match(LT_OUT);
end
else if (( LA(1) in [LT_INOUT])) then
begin
match(LT_INOUT);
end
else
Raise EMismatchedToken.Create( LT(1), [LT_IN..LT_INOUT], InputState.FileName);
end;
// ============================================================================
// AfterConstruction
// ============================================================================
procedure TsvfParser.AfterConstruction;
begin
fProgram := TsvfProgram.Create;
end;
// ============================================================================
// BeforeDestruction
// ============================================================================
procedure TsvfParser.BeforeDestruction;
begin
fProgram.Free;
end;
// ============================================================================
// ENDDR
// ============================================================================
procedure TsvfParser.AddENDDR( Value: byte);
begin
fProgram.AddStatement( TsvfAstEndDR.Create( Value));
end;
// ============================================================================
// ENDIR
// ============================================================================
procedure TsvfParser.AddENDIR( Value: byte);
begin
fProgram.AddStatement( TsvfAstEndIR.Create( Value));
end;
// ============================================================================
// FREQUENCY
// ============================================================================
procedure TsvfParser.AddFREQ( t: IToken);
begin
end;
end.
src.jtag/svf/grammar/jtag.svfParserTokens.pas
+79
View File
@@ -0,0 +1,79 @@
// ============================================================================
// This file is generated by the Delphi Parser Generator.
// ----------------------------------------------------------------------------
// DPG version: 2.1.0.0r
// Grammar: jtag.svfParser.g
// ============================================================================
unit jtag.svfParserTokens;
interface
const
LT_DRSELECT = 20;
LT_PIO = 9;
LT_MASK = 37;
LT_ABSENT = 50;
TT_ID = 56;
TT_NEWLINE = 64;
TT_EOF = 1;
TT_SEMI = 53;
TT_DIGIT = 61;
LT_TDO = 36;
LT_DRUPDATE = 26;
LT_OUT = 40;
LT_HDR = 7;
LT_OFF = 48;
LT_IRCAPTURE = 28;
LT_ENDDR = 4;
LT_DRPAUSE = 23;
LT_IDLE = 19;
TT_XDIGIT = 66;
LT_TIR = 16;
LT_DREXIT2 = 25;
TT_SIGN = 60;
LT_IRUPDATE = 33;
TT_RPAREN = 55;
LT_TDR = 15;
LT_ON = 47;
LT_INOUT = 41;
LT_SDR = 12;
LT_IREXIT1 = 31;
LT_STATE = 14;
TT_DIGITS = 62;
LT_DREXIT1 = 24;
LT_IRPAUSE = 30;
TT_SLCOMMENT = 63;
LT_ENDIR = 5;
LT_DRSHIFT = 22;
LT_MAXIMUM = 43;
LT_SMASK = 38;
LT_FREQUENCY = 6;
LT_TCK = 45;
LT_HZ = 34;
LT_RUNTEST = 11;
LT_HIR = 8;
LT_IN = 39;
TT_INT = 51;
LT_Z = 49;
LT_TDI = 35;
LT_RESET = 18;
LT_SCK = 46;
TT_VECTOR = 58;
TT_XDIGITS = 67;
LT_SIR = 13;
TT_EXP = 59;
LT_IRSELECT = 27;
LT_TRST = 17;
LT_IRSHIFT = 29;
TT_FLOAT = 52;
TT_LPAREN = 54;
TT_NUMBER = 57;
LT_IREXIT2 = 32;
TT_WHITESPACE = 65;
LT_ENDSTATE = 44;
LT_PIOMAP = 10;
LT_DRCAPTURE = 21;
LT_SEC = 42;
implementation
end.
src.jtag/svf/grammar/jtag.svfParserTokens.txt
+67
View File
@@ -0,0 +1,67 @@
// $Delphi Parser Generator: jtag.svfParser.g -> jtag.svfParser.gTokens.txt$
TsvfParser
LT_DRSELECT="DRSELECT"=20
LT_PIO="PIO"=9
LT_MASK="MASK"=37
LT_ABSENT="ABSENT"=50
TT_ID=56
TT_NEWLINE=64
TT_EOF=1
TT_SEMI=53
TT_DIGIT=61
LT_TDO="TDO"=36
LT_DRUPDATE="DRUPDATE"=26
LT_OUT="OUT"=40
LT_HDR="HDR"=7
LT_OFF="OFF"=48
LT_IRCAPTURE="IRCAPTURE"=28
LT_ENDDR="ENDDR"=4
LT_DRPAUSE="DRPAUSE"=23
LT_IDLE="IDLE"=19
TT_XDIGIT=66
LT_TIR="TIR"=16
LT_DREXIT2="DREXIT2"=25
TT_SIGN=60
LT_IRUPDATE="IRUPDATE"=33
TT_RPAREN=55
LT_TDR="TDR"=15
LT_ON="ON"=47
LT_INOUT="INOUT"=41
LT_SDR="SDR"=12
LT_IREXIT1="IREXIT1"=31
LT_STATE="STATE"=14
TT_DIGITS=62
LT_DREXIT1="DREXIT1"=24
LT_IRPAUSE="IRPAUSE"=30
TT_SLCOMMENT=63
LT_ENDIR="ENDIR"=5
LT_DRSHIFT="DRSHIFT"=22
LT_MAXIMUM="MAXIMUM"=43
LT_SMASK="SMASK"=38
LT_FREQUENCY="FREQUENCY"=6
LT_TCK="TCK"=45
LT_HZ="HZ"=34
LT_RUNTEST="RUNTEST"=11
LT_HIR="HIR"=8
LT_IN="IN"=39
TT_INT=51
LT_Z="Z"=49
LT_TDI="TDI"=35
LT_RESET="RESET"=18
LT_SCK="SCK"=46
TT_VECTOR=58
TT_XDIGITS=67
LT_SIR="SIR"=13
TT_EXP=59
LT_IRSELECT="IRSELECT"=27
LT_TRST="TRST"=17
LT_IRSHIFT="IRSHIFT"=29
TT_FLOAT=52
TT_LPAREN=54
TT_NUMBER=57
LT_IREXIT2="IREXIT2"=32
TT_WHITESPACE=65
LT_ENDSTATE="ENDSTATE"=44
LT_PIOMAP="PIOMAP"=10
LT_DRCAPTURE="DRCAPTURE"=21
LT_SEC="SEC"=42
src.jtag/svf/grammar/jtag.svfScanLexer.g
+137
View File
@@ -0,0 +1,137 @@
unit jtag.svfScanLexer;
// ----------------------------------------------------------------------------
// This section is used for generating "uses" clause in the unit 'svfScanLexer'.
// Every unit name must be terminated with ';'
// e.g:
//
// uses
// {
// Classes;
// SysUtils;
// }
// ----------------------------------------------------------------------------
uses
{
}
// ----------------------------------------------------------------------------
// This section is used for generating "type" clause in the unit 'svfScanLexer'.
// The content of the section is verbatim copied into the generated code.
// ----------------------------------------------------------------------------
type
{
}
// ============================================================================
// Lexer class declaration
// ============================================================================
lexer TsvfScanLexer;
// ----------------------------------------------------------------------------
// Lexer options
// ----------------------------------------------------------------------------
options
{
k = 2;
importVocab = jtag.svfLexer;
exportVocab = jtag.svfScanLexer;
caseSensitive = false;
}
// ----------------------------------------------------------------------------
// Lexer tokens. Usualy string literals.
// ----------------------------------------------------------------------------
tokens
{
}
// ----------------------------------------------------------------------------
// Lexer member declarations.
// All user defined member declarations should be placed here.
// The content of the section is verbatim copied into the generated code.
// ----------------------------------------------------------------------------
memberdecl
{
protected
fOnNewline : TNotifyEvent;
public
property OnNewline : TNotifyEvent read fOnNewline write fOnNewline;
}
// ============================================================================
// Begin rule definitions
//
// Remember: All lexer rule names must begin with UPPERCASE letter!
// ============================================================================
RPAREN: ')';
protected XDIGIT: '0'..'9' | 'a'..'f' | 'A'..'F' ;
XDIGITS: (XDIGIT)+;
// ----------------------------------------------------------------------------
// SLCOMMENT
// ----------------------------------------------------------------------------
SLCOMMENT
:
"//"
( ~( '\r' | '\n') )*
(
options
{
generateAmbigWarnings = false;
}
: '\r' '\n' { newLine; if Assigned( fOnNewline) then fOnNewline(self); }
| '\r' { newLine; if Assigned( fOnNewline) then fOnNewline(self); }
| '\n' { newLine; if Assigned( fOnNewline) then fOnNewline(self); }
)
{
_ttype := TT_SKIP;
}
;
// ----------------------------------------------------------------------------
// NEWLINE
// ----------------------------------------------------------------------------
NEWLINE
:
(
options
{
generateAmbigWarnings = false;
}
: '\r' '\n' { newLine; if Assigned( fOnNewline) then fOnNewline(self); }
| '\r' { newLine; if Assigned( fOnNewline) then fOnNewline(self); }
| '\n' { newLine; if Assigned( fOnNewline) then fOnNewline(self); }
)
{
_ttype := TT_SKIP;
}
;
// ----------------------------------------------------------------------------
// WHITESPACE
// ----------------------------------------------------------------------------
WHITESPACE
:
(
' '
| '\t' { tab; }
)
{
_ttype := TT_SKIP;
}
;
// ============================================================================
// End rule definitions
// ============================================================================
// ----------------------------------------------------------------------------
// This section is used for generating member defintions in the unit 'svfScanLexer'.
// The content of the section is verbatim copied into the generated code.
// ----------------------------------------------------------------------------
memberdef
{
}
src.jtag/svf/grammar/jtag.svfScanLexer.pas
+448
View File
@@ -0,0 +1,448 @@
// ============================================================================
// This file is generated by the Delphi Parser Generator.
// ----------------------------------------------------------------------------
// DPG version: 2.1.0.0r
// Grammar: jtag.svfscanLexer.g
// ============================================================================
unit jtag.svfScanLexer;
interface
uses
Classes,
dpgrtl.lexer,
dpgrtl.types,
jtag.svfScanLexerTokens,
SysUtils;
type
// =========================================================================
// Type declarations from grammar.
// =========================================================================
// =========================================================================
// Class TsvfScanLexer declaration
// =========================================================================
TsvfScanLexer = class( TLexer)
protected
fOnNewline : TNotifyEvent;
public
property OnNewline : TNotifyEvent read fOnNewline write fOnNewline;
protected // Internals
procedure initialize; override;
public // Protected grammar rules
// Must callable from parser too
procedure mXDIGIT ( pCreate: boolean);
public // Public grammar rules
procedure mRPAREN ( pCreate: boolean);
procedure mXDIGITS ( pCreate: boolean);
procedure mSLCOMMENT ( pCreate: boolean);
procedure mNEWLINE ( pCreate: boolean);
procedure mWHITESPACE ( pCreate: boolean);
public
function NextToken: IToken; override;
end;
implementation
uses
dpgrtl.exception,
dpgrtl.token;
// ============================================================================
// mRPAREN
// ============================================================================
procedure TsvfScanLexer.mRPAREN( pCreate: boolean);
var
_begin: integer;
_save: integer;
_token: IToken;
_ttype: integer;
begin
_begin := Length( TokenText) +1;
_token := nil;
_ttype := TT_RPAREN;
match(')');
if (_ttype <> TT_SKIP) and (pCreate = true) then
begin
_token := makeToken( _ttype);
_token.TokenText := Copy( TokenText, _begin, Length(TokenText)-_begin+1);
end;
ReturnToken := _token;
end;
// ============================================================================
// mXDIGIT
// ============================================================================
procedure TsvfScanLexer.mXDIGIT( pCreate: boolean);
var
_begin: integer;
_save: integer;
_token: IToken;
_ttype: integer;
begin
_begin := Length( TokenText) +1;
_token := nil;
_ttype := TT_XDIGIT;
if (( LA(1) in ['0'..'9'])) then
begin
match( ['0'..'9']);
end
else if (( LA(1) in ['a'..'f'])) then
begin
match( ['a'..'f']);
end
else if (( LA(1) in ['A'..'F'])) then
begin
match( ['A'..'F']);
end
else
Raise EMismatchedChar.Create( LA(1), ['0'..'9','A'..'F','a'..'f'], InputState.FileName, InputState.Line, InputState.Column);
if (_ttype <> TT_SKIP) and (pCreate = true) then
begin
_token := makeToken( _ttype);
_token.TokenText := Copy( TokenText, _begin, Length(TokenText)-_begin+1);
end;
ReturnToken := _token;
end;
// ============================================================================
// mXDIGITS
// ============================================================================
procedure TsvfScanLexer.mXDIGITS( pCreate: boolean);
var
_begin: integer;
_cnt_5: integer;
_save: integer;
_token: IToken;
_ttype: integer;
begin
_begin := Length( TokenText) +1;
_token := nil;
_ttype := TT_XDIGITS;
_cnt_5 := 0;
while(true) do
begin
if (( LA(1) in ['0'..'9','A'..'F','a'..'f'])) then
begin
mXDIGIT(false);
end
else
begin
if _cnt_5 >= 1 then
break
else
Raise EMismatchedChar.Create( LA(1), ['0'..'9','A'..'F','a'..'f'], InputState.FileName, InputState.Line, InputState.Column);
end;
INC(_cnt_5);
end;
if (_ttype <> TT_SKIP) and (pCreate = true) then
begin
_token := makeToken( _ttype);
_token.TokenText := Copy( TokenText, _begin, Length(TokenText)-_begin+1);
end;
ReturnToken := _token;
end;
// ============================================================================
// mSLCOMMENT
// ============================================================================
procedure TsvfScanLexer.mSLCOMMENT( pCreate: boolean);
var
_begin: integer;
_save: integer;
_token: IToken;
_ttype: integer;
begin
_begin := Length( TokenText) +1;
_token := nil;
_ttype := TT_SLCOMMENT;
match('//');
while(true) do
begin
if (( LA(1) in [#1..#9,#11..#12,#14..#255])) then
begin
match( [#1..#9,#11..#12,#14..#255]);
end
else
break;
end;
if (( LA(1) in [#13]) and (LA(2) in [#10])) then
begin
match(#13);
match(#10);
newLine; if Assigned( fOnNewline) then fOnNewline(self);
end
else if (( LA(1) in [#13])) then
begin
match(#13);
newLine; if Assigned( fOnNewline) then fOnNewline(self);
end
else if (( LA(1) in [#10])) then
begin
match(#10);
newLine; if Assigned( fOnNewline) then fOnNewline(self);
end
else
Raise EMismatchedChar.Create( LA(1), [#10,#13], InputState.FileName, InputState.Line, InputState.Column);
_ttype := TT_SKIP;
if (_ttype <> TT_SKIP) and (pCreate = true) then
begin
_token := makeToken( _ttype);
_token.TokenText := Copy( TokenText, _begin, Length(TokenText)-_begin+1);
end;
ReturnToken := _token;
end;
// ============================================================================
// mNEWLINE
// ============================================================================
procedure TsvfScanLexer.mNEWLINE( pCreate: boolean);
var
_begin: integer;
_save: integer;
_token: IToken;
_ttype: integer;
begin
_begin := Length( TokenText) +1;
_token := nil;
_ttype := TT_NEWLINE;
if (( LA(1) in [#13]) and (LA(2) in [#10])) then
begin
match(#13);
match(#10);
newLine; if Assigned( fOnNewline) then fOnNewline(self);
end
else if (( LA(1) in [#13])) then
begin
match(#13);
newLine; if Assigned( fOnNewline) then fOnNewline(self);
end
else if (( LA(1) in [#10])) then
begin
match(#10);
newLine; if Assigned( fOnNewline) then fOnNewline(self);
end
else
Raise EMismatchedChar.Create( LA(1), [#10,#13], InputState.FileName, InputState.Line, InputState.Column);
_ttype := TT_SKIP;
if (_ttype <> TT_SKIP) and (pCreate = true) then
begin
_token := makeToken( _ttype);
_token.TokenText := Copy( TokenText, _begin, Length(TokenText)-_begin+1);
end;
ReturnToken := _token;
end;
// ============================================================================
// mWHITESPACE
// ============================================================================
procedure TsvfScanLexer.mWHITESPACE( pCreate: boolean);
var
_begin: integer;
_save: integer;
_token: IToken;
_ttype: integer;
begin
_begin := Length( TokenText) +1;
_token := nil;
_ttype := TT_WHITESPACE;
if (( LA(1) in [' '])) then
begin
match(' ');
end
else if (( LA(1) in [#9])) then
begin
match(#9);
tab;
end
else
Raise EMismatchedChar.Create( LA(1), [#9,' '], InputState.FileName, InputState.Line, InputState.Column);
_ttype := TT_SKIP;
if (_ttype <> TT_SKIP) and (pCreate = true) then
begin
_token := makeToken( _ttype);
_token.TokenText := Copy( TokenText, _begin, Length(TokenText)-_begin+1);
end;
ReturnToken := _token;
end;
// ----------------------------------------------------------------------------
// NextToken
// ----------------------------------------------------------------------------
function TsvfScanLexer.NextToken : IToken;
var
_first : TCharSet;
begin
_first := [#9..#10,#13,' ',')','/'..'9','A'..'F','a'..'f'];
while( true) do
begin
ResetText;
try
if (( LA(1) in [')'])) then
begin
mRPAREN(true);
result := ReturnToken;
end
else if (( LA(1) in ['0'..'9','A'..'F','a'..'f'])) then
begin
mXDIGITS(true);
result := ReturnToken;
end
else if (( LA(1) in ['/'])) then
begin
mSLCOMMENT(true);
result := ReturnToken;
end
else if (( LA(1) in [#10,#13])) then
begin
mNEWLINE(true);
result := ReturnToken;
end
else if (( LA(1) in [#9,' '])) then
begin
mWHITESPACE(true);
result := ReturnToken;
end
else
begin
if LA(1) = EOF_CHAR then
begin
uponEof;
result := TToken.Create(TT_EOF);
end
else
Raise EMismatchedChar.Create(LA(1), _first, InputState.FileName, InputState.Line, InputState.Column);
end;
// --------------------------------------------------------------
// If we found a SKIP token, then try again...
// --------------------------------------------------------------
if result = nil then
continue;
// --------------------------------------------------------------
// Now we have a valid token, so exit the function
// --------------------------------------------------------------
break;
except
Raise;
end;
end;
end;
// ----------------------------------------------------------------------------
// InitLiterals
// ----------------------------------------------------------------------------
procedure TsvfScanLexer.initialize;
begin
fCaseSensitive := false;
fLiterals.CaseSensitive := false;
fLiterals['drselect' ] := 20;
fLiterals['pio' ] := 9;
fLiterals['mask' ] := 37;
fLiterals['absent' ] := 50;
fLiterals['drupdate' ] := 26;
fLiterals['idle' ] := 19;
fLiterals['out' ] := 40;
fLiterals['hdr' ] := 7;
fLiterals['ircapture' ] := 28;
fLiterals['enddr' ] := 4;
fLiterals['off' ] := 48;
fLiterals['drpause' ] := 23;
fLiterals['tdo' ] := 36;
fLiterals['tir' ] := 16;
fLiterals['drexit2' ] := 25;
fLiterals['irupdate' ] := 33;
fLiterals['tdr' ] := 15;
fLiterals['sdr' ] := 12;
fLiterals['inout' ] := 41;
fLiterals['on' ] := 47;
fLiterals['irexit1' ] := 31;
fLiterals['state' ] := 14;
fLiterals['drexit1' ] := 24;
fLiterals['irpause' ] := 30;
fLiterals['endir' ] := 5;
fLiterals['drshift' ] := 22;
fLiterals['maximum' ] := 43;
fLiterals['tdi' ] := 35;
fLiterals['frequency' ] := 6;
fLiterals['hir' ] := 8;
fLiterals['hz' ] := 34;
fLiterals['runtest' ] := 11;
fLiterals['smask' ] := 38;
fLiterals['in' ] := 39;
fLiterals['tck' ] := 45;
fLiterals['z' ] := 49;
fLiterals['reset' ] := 18;
fLiterals['sck' ] := 46;
fLiterals['sir' ] := 13;
fLiterals['irselect' ] := 27;
fLiterals['trst' ] := 17;
fLiterals['irshift' ] := 29;
fLiterals['irexit2' ] := 32;
fLiterals['endstate' ] := 44;
fLiterals['drcapture' ] := 21;
fLiterals['piomap' ] := 10;
fLiterals['sec' ] := 42;
end;
end.
src.jtag/svf/grammar/jtag.svfScanLexerTokens.pas
+79
View File
@@ -0,0 +1,79 @@
// ============================================================================
// This file is generated by the Delphi Parser Generator.
// ----------------------------------------------------------------------------
// DPG version: 2.1.0.0r
// Grammar: jtag.svfscanLexer.g
// ============================================================================
unit jtag.svfScanLexerTokens;
interface
const
LT_DRSELECT = 20;
LT_PIO = 9;
LT_MASK = 37;
LT_ABSENT = 50;
TT_ID = 56;
TT_NEWLINE = 64;
TT_EOF = 1;
TT_SEMI = 53;
TT_DIGIT = 61;
LT_DRUPDATE = 26;
LT_IDLE = 19;
LT_OUT = 40;
LT_HDR = 7;
LT_IRCAPTURE = 28;
LT_ENDDR = 4;
LT_OFF = 48;
LT_DRPAUSE = 23;
LT_TDO = 36;
TT_XDIGIT = 66;
LT_TIR = 16;
LT_DREXIT2 = 25;
TT_SIGN = 60;
LT_IRUPDATE = 33;
LT_TDR = 15;
TT_RPAREN = 55;
LT_SDR = 12;
LT_INOUT = 41;
LT_ON = 47;
LT_IREXIT1 = 31;
LT_STATE = 14;
TT_DIGITS = 62;
LT_DREXIT1 = 24;
LT_IRPAUSE = 30;
TT_SLCOMMENT = 63;
LT_ENDIR = 5;
LT_DRSHIFT = 22;
LT_MAXIMUM = 43;
LT_TDI = 35;
LT_FREQUENCY = 6;
LT_HIR = 8;
LT_HZ = 34;
LT_RUNTEST = 11;
LT_SMASK = 38;
LT_IN = 39;
LT_TCK = 45;
LT_Z = 49;
LT_RESET = 18;
TT_INT = 51;
LT_SCK = 46;
TT_FLOAT = 52;
TT_VECTOR = 58;
LT_SIR = 13;
TT_EXP = 59;
LT_IRSELECT = 27;
LT_TRST = 17;
LT_IRSHIFT = 29;
TT_XDIGITS = 67;
TT_LPAREN = 54;
TT_NUMBER = 57;
LT_IREXIT2 = 32;
TT_WHITESPACE = 65;
LT_ENDSTATE = 44;
LT_DRCAPTURE = 21;
LT_PIOMAP = 10;
LT_SEC = 42;
implementation
end.
src.jtag/svf/grammar/jtag.svfScanLexerTokens.txt
+67
View File
@@ -0,0 +1,67 @@
// $Delphi Parser Generator: jtag.svfscanLexer.g -> jtag.svfscanLexer.gTokens.txt$
TsvfScanLexer
LT_DRSELECT="DRSELECT"=20
LT_PIO="PIO"=9
LT_MASK="MASK"=37
LT_ABSENT="ABSENT"=50
TT_ID=56
TT_NEWLINE=64
TT_EOF=1
TT_SEMI=53
TT_DIGIT=61
LT_DRUPDATE="DRUPDATE"=26
LT_IDLE="IDLE"=19
LT_OUT="OUT"=40
LT_HDR="HDR"=7
LT_IRCAPTURE="IRCAPTURE"=28
LT_ENDDR="ENDDR"=4
LT_OFF="OFF"=48
LT_DRPAUSE="DRPAUSE"=23
LT_TDO="TDO"=36
TT_XDIGIT=66
LT_TIR="TIR"=16
LT_DREXIT2="DREXIT2"=25
TT_SIGN=60
LT_IRUPDATE="IRUPDATE"=33
LT_TDR="TDR"=15
TT_RPAREN=55
LT_SDR="SDR"=12
LT_INOUT="INOUT"=41
LT_ON="ON"=47
LT_IREXIT1="IREXIT1"=31
LT_STATE="STATE"=14
TT_DIGITS=62
LT_DREXIT1="DREXIT1"=24
LT_IRPAUSE="IRPAUSE"=30
TT_SLCOMMENT=63
LT_ENDIR="ENDIR"=5
LT_DRSHIFT="DRSHIFT"=22
LT_MAXIMUM="MAXIMUM"=43
LT_TDI="TDI"=35
LT_FREQUENCY="FREQUENCY"=6
LT_HIR="HIR"=8
LT_HZ="HZ"=34
LT_RUNTEST="RUNTEST"=11
LT_SMASK="SMASK"=38
LT_IN="IN"=39
LT_TCK="TCK"=45
LT_Z="Z"=49
LT_RESET="RESET"=18
TT_INT=51
LT_SCK="SCK"=46
TT_FLOAT=52
TT_VECTOR=58
LT_SIR="SIR"=13
TT_EXP=59
LT_IRSELECT="IRSELECT"=27
LT_TRST="TRST"=17
LT_IRSHIFT="IRSHIFT"=29
TT_XDIGITS=67
TT_LPAREN=54
TT_NUMBER=57
LT_IREXIT2="IREXIT2"=32
TT_WHITESPACE=65
LT_ENDSTATE="ENDSTATE"=44
LT_DRCAPTURE="DRCAPTURE"=21
LT_PIOMAP="PIOMAP"=10
LT_SEC="SEC"=42