path: root/test/cases/rlhc.d/case/erract4.m-C-T1--goto-backend.exp

#include <stdio.h>
#include <Foundation/Foundation.h>

#define IDENT_BUFLEN 256

@interface ErrAct : NSObject
{
	@public
	int cs;
};

// Initialize the machine. Invokes any init statement blocks. Returns 0
// if the machine begins in a non-accepting state and 1 if the machine
// begins in an accepting state.
- (int) initFsm;

// Execute the machine on a block of data. Returns -1 if after processing
// the data, the machine is in the error state and can never accept, 0 if
// the machine is in a non-accepting state and 1 if the machine is in an
// accepting state.
- (void) executeWithData:(const char *)data len:(int)len;

// Indicate that there is no more data. Returns -1 if the machine finishes
// in the error state and does not accept, 0 if the machine finishes
// in any other non-accepting state and 1 if the machine finishes in an
// accepting state.
- (int) finish;

@end

@implementation ErrAct



static const char  _ErrAct_key_offsets [] = { 0, 2, 3, 5, 7, 9, 11, 0 ,  };
static const char  _ErrAct_trans_keys [] = { 10, 104, 10, 10, 101, 10, 108, 10, 108, 10, 111, 10, 0 ,  };
static const char  _ErrAct_single_lengths [] = { 2, 1, 2, 2, 2, 2, 1, 0 ,  };
static const char  _ErrAct_range_lengths [] = { 0, 0, 0, 0, 0, 0, 0, 0 ,  };
static const char  _ErrAct_index_offsets [] = { 0, 3, 5, 8, 11, 14, 17, 0 ,  };
static const char  _ErrAct_trans_cond_spaces [] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0 ,  };
static const char  _ErrAct_trans_offsets [] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 0 ,  };
static const char  _ErrAct_trans_lengths [] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 ,  };
static const char  _ErrAct_cond_keys [] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ,  };
static const char  _ErrAct_cond_targs [] = { 1, 2, 1, 1, 1, 1, 3, 1, 1, 4, 1, 1, 5, 1, 1, 6, 1, 0, 1, 0 ,  };
static const char  _ErrAct_cond_actions [] = { 2, 0, 1, 3, 0, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 3, 1, 0 ,  };
static const char  _ErrAct_eof_actions [] = { 0, 0, 1, 1, 1, 1, 1, 0 ,  };
static const char  _ErrAct_nfa_targs [] = { 0, 0 ,  };
static const char  _ErrAct_nfa_offsets [] = { 0, 0, 0, 0, 0, 0, 0, 0 ,  };
static const char  _ErrAct_nfa_push_actions [] = { 0, 0 ,  };
static const char  _ErrAct_nfa_pop_trans [] = { 0, 0 ,  };
static const int  ErrAct_start  = 0;
static const int  ErrAct_first_final  = 0;
static const int  ErrAct_error  = -1;
static const int  ErrAct_en_main  = 0;
- (int) initFsm;
{

	{
		cs = ( int ) ErrAct_start;
	}
	return 1;
}

- (void) executeWithData:(const char *)_data len:(int)_len;
{
	const char *p = _data;
	const char *pe = _data + _len;
	const char *eof = pe;
	
	{
		int _klen;
		const char  *_keys;
		const char  *_ckeys;
		int _cpc;
		unsigned int _trans = 0;
		unsigned int _cond = 0;
		if ( p == pe  )
		goto _test_eof;
		
		_resume :
		_keys = _ErrAct_trans_keys + _ErrAct_key_offsets[cs];
		_trans = ( unsigned int  ) _ErrAct_index_offsets[cs];
		_klen = ( int ) _ErrAct_single_lengths[cs];
		if ( _klen > 0  )
		{
			const char  *_lower;
			const char  *_mid;
			const char  *_upper;
			_lower = _keys;
			_upper = _keys + _klen - 1;
			while ( 1 )
			{
				if ( _upper < _lower  )
				break;
				
				
				_mid = _lower + ((_upper-_lower)>> 1);
				if ( ((*( p  ))
				)< (*( _mid  ))
				)
				_upper = _mid - 1;
				
				else if ( ((*( p  ))
				)> (*( _mid  ))
				)
				_lower = _mid + 1;
				
				else
				{
					_trans += ( unsigned int  ) (_mid - _keys);
					goto _match;
				}
				
			}
			
			_keys += _klen;
			_trans += ( unsigned int  ) _klen;
		}
		
		
		_klen = ( int ) _ErrAct_range_lengths[cs];
		if ( _klen > 0  )
		{
			const char  *_lower;
			const char  *_mid;
			const char  *_upper;
			_lower = _keys;
			_upper = _keys + (_klen<<1)- 2;
			while ( 1 )
			{
				if ( _upper < _lower  )
				break;
				
				
				_mid = _lower + (((_upper-_lower)>> 1)& ~1);
				if ( ((*( p  ))
				)< (*( _mid  ))
				)
				_upper = _mid - 2;
				
				else if ( ((*( p  ))
				)> (*( _mid + 1  ))
				)
				_lower = _mid + 2;
				
				else
				{
					_trans += ( unsigned int  ) ((_mid - _keys)>>1);
					goto _match;
				}
				
			}
			
			_trans += ( unsigned int  ) _klen;
		}
		
		
		
		_match :
		_ckeys = _ErrAct_cond_keys + _ErrAct_trans_offsets[_trans];
		_klen = ( int ) _ErrAct_trans_lengths[_trans];
		_cond = ( unsigned int  ) _ErrAct_trans_offsets[_trans];
		_cpc = 0;
		{
			const char  *_lower;
			const char  *_mid;
			const char  *_upper;
			_lower = _ckeys;
			_upper = _ckeys + _klen - 1;
			while ( 1 )
			{
				if ( _upper < _lower  )
				break;
				
				
				_mid = _lower + ((_upper-_lower)>> 1);
				if ( _cpc < ( int ) (*( _mid  ))
				)
				_upper = _mid - 1;
				
				else if ( _cpc > ( int ) (*( _mid  ))
				)
				_lower = _mid + 1;
				
				else
				{
					_cond += ( unsigned int  ) (_mid - _ckeys);
					goto _match_cond;
				}
				
			}
			
			cs = -1;
			goto _again;
		}
		
		_match_cond :
		cs = ( int ) _ErrAct_cond_targs[_cond];
		if ( _ErrAct_cond_actions[_cond]== 0  )
		goto _again;
		
		
		switch ( _ErrAct_cond_actions[_cond] ) {
			case 1 :
			{
				printf("hello fails\n");
			}
			
			break;
			case 3 :
			{
				printf("newline\n");
			}
			
			break;
			case 2 :
			{
				printf("newline\n");
			}
			{
				printf("hello fails\n");
			}
			
			break;
			
		}
		
		_again :
		p += 1;
		if ( p != pe  )
		goto _resume;
		
		
		_test_eof :
		{}
		if ( p == eof  )
		{
			switch ( _ErrAct_eof_actions[cs] ) {
				case 1 :
				{
					printf("hello fails\n");
				}
				
				break;
				
			}
		}
		
		
		
	}
}

- (int) finish;
{
	if ( cs == ErrAct_error )
	return -1;
	else if ( cs >= ErrAct_first_final )
	return 1;
	return 0;
}

@end

#include <stdio.h>
#include <string.h>
#define BUFSIZE 2048

ErrAct *fsm;
char buf[BUFSIZE];

void test( char *buf )
{
	int len = strlen(buf);
	fsm = [[ErrAct alloc] init];
	
	[fsm initFsm];
	[fsm executeWithData:buf len:len];
	if ( [fsm finish] > 0 )
	printf("ACCEPT\n");
	else
	printf("FAIL\n");
}


int main()
{
	test(
	"hello\n"
	"hello\n"
	"hello\n"
	);
	
	test(
	"hello\n"
	"hello\n"
	"hello there\n"
	);
	
	test(
	"hello\n"
	"hello\n"
	"he"	);
	
	test( "" );
	
	return 0;
}