path: root/test/cases/rlhc.d/case/element3.m-C-G0--goto-backend.in

host( "working/element3.rl", 1 ) @{/*
	* @@LANG: obj-c
	*/
	
	#include <stdio.h>
	#include <Foundation/Foundation.h>
	
	struct LangEl
	{
		int key;
		char *name;
	};
	
	@@interface Fsm : 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.
	- (int) executeWithData:( struct LangEl *)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 Fsm
	
	
	
}@
array s8 _Fsm_actions( 0, 1 ) = { 0, 1, 0, 1, 1, 0 };

array s8 _Fsm_eof_actions( 0, 3 ) = { 0, 0, 0, 3, 0 };

array s8 _Fsm_nfa_targs( 0, 0 ) = { 0, 0 };

array s8 _Fsm_nfa_offsets( 0, 0 ) = { 0, 0, 0, 0, 0 };

array s8 _Fsm_nfa_push_actions( 0, 0 ) = { 0, 0 };

array s8 _Fsm_nfa_pop_trans( 0, 0 ) = { 0, 0 };

value int Fsm_start = 1;
value int Fsm_first_final = 3;
value int Fsm_error = 0;

value int Fsm_en_main = 1;

host( "working/element3.rl", 58 ) @{
	
	- (int) initFsm;
	{
	}@
	{
		cs = cast(int)Fsm_start;
	}
	host( "working/element3.rl", 62 ) @{
		return 0;
	}
	
	- (int) executeWithData:( struct LangEl *)_data len:(int)_len;
	{
		struct LangEl *p = _data;
		struct LangEl *pe = _data + _len;
		struct LangEl *eof = pe;
	}@
	{
		index s8 _acts;
		uint _nacts;
		
		if ( p == pe )
		goto _test_eof;
		if ( cs == 0 )
		goto _out;
		_resume:
		switch ( cs ) {
			case 1:
			if ( host( "-", 1 ) ={p->key}= == 1 ) {
				goto ctr0;
			}
			{
				goto ctr1;
			}
			case 0:
			goto _out;
			case 2:
			switch( host( "-", 1 ) ={p->key}= ) {
				case 2: {
					goto ctr0;
				}
				case 3: {
					goto ctr2;
				}
			}
			{
				goto ctr1;
			}
			case 3:
			{
				goto ctr1;
			}
		}
		
		ctr1: cs = 0; goto _again;
		ctr0: cs = 2; goto f0;
		ctr2: cs = 3; goto f0;
		
		f0: _acts = offset( _Fsm_actions, 1 ); goto execFuncs;
		
		execFuncs:
		_nacts = cast(uint)deref( _Fsm_actions, _acts );
		_acts += 1;
		while ( _nacts > 0 ) {
			switch ( deref( _Fsm_actions, _acts ) ) {
				case 0{
					host( "working/element3.rl", 53 ) ${printf("%s\n", p->name);}$
				}
			}
			_acts += 1;
			_nacts -= 1;
		}
		
		goto _again;
		
		_again:
		if ( cs == 0 )
		goto _out;
		p += 1;
		if ( p != pe )
		goto _resume;
		_test_eof: {}
		if ( p == eof )
		{
			index s8 __acts;
			uint __nacts;
			__acts = offset( _Fsm_actions, _Fsm_eof_actions[cs] );
			__nacts = cast(uint)deref( _Fsm_actions, __acts ); __acts += 1;
			while ( __nacts > 0 ) {
				switch ( deref( _Fsm_actions, __acts ) ) {
					case 1{
						host( "working/element3.rl", 54 ) ${printf("accept\n");}$
					}
				}
				__acts += 1;
				__nacts -= 1;
			}
		}
		
		_out: {}
	}
	host( "working/element3.rl", 71 ) @{
		
		if ( self->cs == Fsm_error ) 
		return -1;
		return ( self->cs >= Fsm_first_final ) ? 1 : 0;
	}
	
	- (int) finish;
	{
		if ( self->cs == Fsm_error ) 
		return -1;
		return ( self->cs >= Fsm_first_final ) ? 1 : 0;
	}
	
	
	@@end
	
	int main()
	{
		static Fsm *fsm;
		static struct LangEl lel[] = { 
			{1, "one"}, 
			{2, "two-a"}, 
			{2, "two-b"}, 
			{2, "two-c"}, 
			{3, "three"}
		};
		
		fsm = [[Fsm alloc] init];
		[fsm initFsm];
		[fsm executeWithData:lel len:5];
		[fsm finish];
		
		return 0;
	}
	
	@@interface Fsm2 : NSObject
	{
		// The current state may be read and written to from outside of the
		// machine.  From within action code, curs is -1 and writing to it has no
		// effect.
		@@public
		int cs;
		
		@@protected
		
	}
	
	// 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.
	- (int)
	executeWithElements:(int) elements
	length:(unsigned)length;
	
	@@end
	
	@@implementation Fsm2
	- (int)
	executeWithElements:(int)elements
	length:(unsigned)length;
	{
		return 0;
	}
	@@end
	
}@