gherkin-objective-c-implementation.razor

// ------------------------------------------------------------------------------
//  <auto-generated>
//      This code was generated by Berp (http://https://github.com/gasparnagy/berp/).
// 
//      Changes to this file may cause incorrect behavior and will be lost if
//      the code is regenerated.
//  </auto-generated>
// ------------------------------------------------------------------------------

@using Berp;
@helper CallProduction(ProductionRule production)
{
    switch(production.Type)
    {
        case ProductionRuleType.Start:
        @:[self startRuleWithContext: theContext ruleType: GHRuleType@(production.RuleName)];
            break;
        case ProductionRuleType.End:
        @:[self endRuleWithContext: theContext ruleType: GHRuleType@(production.RuleName)];
            break;
        case ProductionRuleType.Process:
        @:[self buildWithContext: theContext token: theToken];
            break;
    }
}
@helper HandleParserError(IEnumerable<string> expectedTokens, State state)
{<text>
    NSString * stateComment = @@"State: @state.Id - @Raw(state.Comment)";
    [theToken detach];
    NSArray<NSString *> * expectedTokens = [[NSArray<NSString *> alloc] initWithObjects: @@"@Raw(string.Join("\", @\"", expectedTokens))", nil];
    id error = [theToken isEOF] ? (GHParserException *)[[GHUnexpectedEOFException alloc] initWithToken: theToken expectedTokenTypes: expectedTokens stateComment: stateComment] : [[GHUnexpectedTokenException alloc] initWithToken: theToken expectedTokenTypes: expectedTokens stateComment: stateComment];
    if (stopAtFirstError)
        @@throw error;
    
    [self addError: error withContext: theContext];
    return @state.Id;
</text>}
@helper MatchToken(TokenType tokenType)
{<text>[self match@(tokenType)WithContext: theContext token: theToken]</text>}

#import "GHParser.h"

#import "GHAstBuilder.h"
#import "GHToken.h"
#import "GHParserException.h"

@@implementation GHParserContext

@@synthesize tokenScanner;
@@synthesize tokenMatcher;
@@synthesize tokenQueue;
@@synthesize errors;

@@end

@@implementation GH@(Model.ParserClassName)
{
    id<GHAstBuilderProtocol>    astBuilder;
}

@@synthesize stopAtFirstError;

- (id)init
{
    return [self initWithAstBuilder: [[GHAstBuilder alloc] init]];
}

- (id)initWithAstBuilder:(id<GHAstBuilderProtocol>)theAstBuilder
{
    if (self = [super init])
    {
        astBuilder = theAstBuilder;
    }

    return self;
}

- (id)parseWithTokenScanner:(id<GHTokenScannerProtocol>)theTokenScanner
{
    return [self parseWithTokenScanner: theTokenScanner tokenMatcher: [[GHTokenMatcher alloc] init]];
}

- (id)parseWithTokenScanner:(id<GHTokenScannerProtocol>)theTokenScanner tokenMatcher:(id<GHTokenMatcherProtocol>)theTokenMatcher
{
    [theTokenMatcher reset];
    [astBuilder reset];

    GHParserContext * context = [[GHParserContext alloc] init];
    [context setTokenScanner: theTokenScanner];
    [context setTokenMatcher: theTokenMatcher];
    [context setTokenQueue: [[NSMutableArray<GHToken *> alloc] init]];
    [context setErrors: [[NSMutableArray<GHParserException *> alloc] init]];

    [self startRuleWithContext: context ruleType: GHRuleType@(Model.RuleSet.StartRule.Name)];
    NSUInteger state = 0;
    GHToken * token;
    do
    {
        token = [self readTokenWithContext: context];
        state = [self matchToken: token withState: state context: context];
    } while(![token isEOF]);

    [self endRuleWithContext: context ruleType: GHRuleType@(Model.RuleSet.StartRule.Name)];

    if ([[context errors] count])
    {
        @@throw [[GHCompositeParserException alloc] initWithErrors: [context errors]];
    }

    return [self resultWithContext: context];
}

- (void)addError:(GHParserException *)theParserError withContext:(GHParserContext *)theContext
{
    [[theContext errors] addObject: theParserError];
    if ([[theContext errors] count] > 10)
        @@throw [[GHCompositeParserException alloc] initWithErrors: [theContext errors]];
}

- (void)handleAstErrorWithContext:(GHParserContext *)theContext actionBlock:(void (^)(void))theActionBlock
{
    [self handleExternalErrorWithContext: theContext actionBlock: ^() { theActionBlock(); return YES; } defaultValue: NO];
}

- (BOOL)handleExternalErrorWithContext:(GHParserContext *)theContext actionBlock:(BOOL (^)(void))theActionBlock defaultValue:(BOOL)theDefaultValue
{
    if (stopAtFirstError)
    {
        return theActionBlock();
    }

    @@try
    {
        return theActionBlock();
    }
    @@catch (GHCompositeParserException * compositeParserException)
    {
        for (GHParserException * error in [compositeParserException errors])
        {
            [self addError: error withContext: theContext];
        }
    }
    @@catch (GHParserException * error)
    {
        [self addError: error withContext: theContext];
    }
    return theDefaultValue;
}

- (void)buildWithContext:(GHParserContext *)theContext token:(GHToken *)theToken
{
    [self handleAstErrorWithContext: theContext actionBlock: ^() { [self->astBuilder buildWithToken: theToken]; }];
}

- (void)startRuleWithContext:(GHParserContext *)theContext ruleType:(GHRuleType)theRuleType
{
    [self handleAstErrorWithContext: theContext actionBlock: ^() { [self->astBuilder startRuleWithType: theRuleType]; }];
}

- (void)endRuleWithContext:(GHParserContext *)theContext ruleType:(GHRuleType)theRuleType
{
    [self handleAstErrorWithContext: theContext actionBlock: ^() { [self->astBuilder endRuleWithType: theRuleType]; }];
}

- (id)resultWithContext:(GHParserContext *)theContext
{
    return [astBuilder result];
}

- (GHToken *)readTokenWithContext:(GHParserContext *)theContext
{
    if ([[theContext tokenQueue] count] > 0)
    {
        id firstObject = [[theContext tokenQueue] firstObject];
        [[theContext tokenQueue] removeObjectAtIndex: 0];
        return firstObject;
    }
    else
        return [[theContext tokenScanner] read];
}

@foreach(var rule in Model.RuleSet.TokenRules)
{<text>
- (BOOL)match@(rule.Name.Replace("#", ""))WithContext:(GHParserContext *)theContext token:(GHToken *)theToken
{
    @if (rule.Name != "#EOF")
    {
    @:if ([theToken isEOF]) return NO;
    }
    return [self handleExternalErrorWithContext: theContext actionBlock: ^() { return [[theContext tokenMatcher] match@(rule.Name.Replace("#", ""))WithToken: theToken]; } defaultValue: NO];
}</text>
}

- (NSUInteger)matchToken:(GHToken *)theToken withState:(NSUInteger)theState context:(GHParserContext *)theContext
{
    NSUInteger newState;
    switch (theState)
    {
    @foreach(var state in Model.States.Values.Where(s => !s.IsEndState))
    {
        @:case @state.Id:
            @:newState = [self matchTokenAt_@(state.Id): theToken context: theContext];
            @:break;
    }
        default:
            @@throw [NSException exceptionWithName: NSInvalidArgumentException reason: [@@"Unknown state: " stringByAppendingFormat: @@"%d", (int)theState] userInfo: nil];
    }
    return newState;
}

@foreach(var state in Model.States.Values.Where(s => !s.IsEndState))
{
<text>
// @Raw(state.Comment)
- (int)matchTokenAt_@(state.Id):(GHToken *)theToken context:(GHParserContext *)theContext
{
    @foreach(var transition in state.Transitions)
    {
    @:if (@MatchToken(transition.TokenType))
    @:{
        if (transition.LookAheadHint != null)
        {
        @:if ([self lookAheadWithContext_@(transition.LookAheadHint.Id): theContext token: theToken])
        @:{
        }
        foreach(var production in transition.Productions)
        {
            @CallProduction(production)
        }
        @:return @transition.TargetState;
        if (transition.LookAheadHint != null)
        {
        @:}
        }
    @:}
    }
    @HandleParserError(state.Transitions.Select(t => "#" + t.TokenType.ToString()).Distinct(), state)
}
</text>
}

@foreach(var lookAheadHint in Model.RuleSet.LookAheadHints)
{
<text>
- (BOOL)lookAheadWithContext_@(lookAheadHint.Id):(GHParserContext *)theContext token:(GHToken *)currentToken
{
    [currentToken detach];
    GHToken * theToken;
    NSMutableArray<GHToken *> * tokenBuffer = [[NSMutableArray<GHToken *> alloc] init];
    BOOL match = NO;
    do
    {
        theToken = [self readTokenWithContext: theContext];
        [theToken detach];
        [tokenBuffer addObject: theToken];

        if (NO
        @foreach(var tokenType in lookAheadHint.ExpectedTokens)
        {
            @:|| @MatchToken(tokenType)
        }
        )
        {
            match = YES;
            break;
        }
    } while (NO
    @foreach(var tokenType in lookAheadHint.Skip)
    {
        @:|| @MatchToken(tokenType)
    }
    );
    for (GHToken * token in tokenBuffer)
    {
        [[theContext tokenQueue] addObject: token];
    }
    return match;
}
</text>
}

@@end