95 lines
2.8 KiB
TypeScript
95 lines
2.8 KiB
TypeScript
import { BooleanExpression } from "../../expressions/BooleanExpression";
|
|
import { StringValueMatcher, LitaralMatcher, RegExpMatcher } from "../../expressions/StringMatcher";
|
|
import { Arrays } from "../../tools/Arrays";
|
|
import { LexerEvent } from "./LexerEvent";
|
|
import { LexerSequence } from "./LexerSequence";
|
|
import { LexerType } from "./LexerType";
|
|
|
|
export class LiteralLexerEventTypeMatcher extends LitaralMatcher<LexerEvent,string>
|
|
{
|
|
getStringValue( l:LexerEvent){return l.type;}
|
|
}
|
|
|
|
export class RegExpLexerEventTypeMatcher extends RegExpMatcher<LexerEvent>
|
|
{
|
|
getStringValue( l:LexerEvent){return l.type;}
|
|
}
|
|
|
|
export class LiteralLexerEventValueMatcher extends LitaralMatcher<LexerEvent,string>
|
|
{
|
|
getStringValue( l:LexerEvent){return l.match;}
|
|
}
|
|
|
|
export class RegExpLexerEventValueMatcher extends RegExpMatcher<LexerEvent>
|
|
{
|
|
getStringValue( l:LexerEvent){return l.match;}
|
|
}
|
|
|
|
export class LexerEventMatcherTools
|
|
{
|
|
static createTypeAndValueMatcher<Type extends LexerType>( type:Type, value:string )
|
|
{
|
|
let typeMatcher = new LiteralLexerEventTypeMatcher( type );
|
|
let valueMatcher = new LiteralLexerEventValueMatcher( value );
|
|
|
|
return typeMatcher.AND( valueMatcher );
|
|
}
|
|
|
|
static convertToExpression<Type extends LexerType>( value:BooleanExpression<LexerEvent>|Type[]|string ):BooleanExpression<LexerEvent>
|
|
{
|
|
if ( typeof value === "string" )
|
|
{
|
|
return new LiteralLexerEventValueMatcher( value )
|
|
}
|
|
else if ( Array.isArray( value ) )
|
|
{
|
|
let types = value as LexerType[];
|
|
let outputMatcher:BooleanExpression<LexerEvent> = null;
|
|
|
|
for ( let i = 0; i < types.length; i++ )
|
|
{
|
|
let matcher = new LiteralLexerEventTypeMatcher( types[ i ] );
|
|
|
|
if ( outputMatcher )
|
|
{
|
|
outputMatcher = outputMatcher.OR( matcher );
|
|
}
|
|
else
|
|
{
|
|
outputMatcher = matcher;
|
|
}
|
|
}
|
|
|
|
return outputMatcher;
|
|
}
|
|
|
|
return value as BooleanExpression<LexerEvent>;
|
|
}
|
|
|
|
static createMatchSequence<Type extends LexerType>( matcherDefinition:(BooleanExpression<LexerEvent>|Type[]|string)[],
|
|
ignoreDefinition:(BooleanExpression<LexerEvent>|Type[]|string)[] )
|
|
{
|
|
let matchers = matcherDefinition.map( md => LexerEventMatcherTools.convertToExpression<Type>( md ) );
|
|
let ignores = ignoreDefinition.map( id => LexerEventMatcherTools.convertToExpression<Type>( id ) );
|
|
|
|
|
|
let ignore = null;
|
|
|
|
if ( ignores.length === 1 )
|
|
{
|
|
ignore = ignores[ 0 ];
|
|
}
|
|
else if ( ignores.length > 1 )
|
|
{
|
|
ignore = ignores[ 0 ].OR_ANY( Arrays.copyRangeFromStart( ignores, 1 ) );
|
|
}
|
|
|
|
let sequence = new LexerSequence();
|
|
sequence.sequence = matchers;
|
|
sequence.ignore = ignore;
|
|
|
|
return sequence;
|
|
}
|
|
}
|
|
|