Welcome to the Lounge

• break - goto the end of a switch or terminate the closest enclosing iteration statement
  
• continue - start a new iteration of the closest enclosing iteration statement
  
• return - exit the function in which it appears and return to the caller
  

Ravi Bhavnani wrote:

And most (I suspect all) modern compilers won't allow specifying the target of a goto into another block

void f(int n)
{
    if(n > 1)
      goto foo;
      // do stuff
     if( ... )
     {
        // some stuff
        if ( ... )
            goto foo;     // jumps down to inside next if block
        // other stuff
     } 
     if(  ... )
     {
       foo:
       // do more stuff
     }
} 

void foo()
{
   foo_label:
   // ...
}

void bar()
{
   // ...
   goto foo_label;  // invalid non-local goto
}

trønderen wrote:

If you have any reason at all to relate to the generated code. Trading readability and maintainability for "slightly faster code" is generally a bad move.

Object = "{"
ObjectEnd = "}"
Array = "["
ArrayEnd = "]"
FieldSeparator = ":"
Comma = ","
Number = '-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?'
Boolean = 'true|false'
Null = "null"
String = '"([^\n"\\]|\\([btrnf"\\/]|(u[0-9A-Fa-f]{4})))*"'
WhiteSpace = '[ \t\r\n]+'

private FAMatch _NextImpl(
#if FALIB_SPANS
	ReadOnlySpan<char> s
#else
	string s
#endif
	)
{
	int tlen;
	int tto;
	int prlen;
	int pmin;
	int pmax;
	int i;
	int j;
	int state = 0;
	int acc;
	if (position == -1)
	{
		// first read
		++position;
	}
	int len = 0;
	long cursor_pos = position;
	int line = this.line;
	int column = this.column;
	int ch = -1;
	Advance(s, ref ch, ref len, true);
	start_dfa:
	acc = _dfa[state];
	++state;
	tlen = _dfa[state];
	++state;
	for (i = 0; i < tlen; ++i)
	{
		tto = _dfa[state];
		++state;
		prlen = _dfa[state];
		++state;
		for (j = 0; j < prlen; ++j)
		{
			pmin = _dfa[state];
			++state;
			pmax = _dfa[state];
			++state;
			if (ch < pmin)
			{
				state += ((prlen - (j + 1)) * 2);
				j = prlen;
			}
			else if (ch <= pmax)
			{
				Advance(s, ref ch, ref len, false);
				state = tto;
				goto start_dfa;
			}
		}
	}
	if (acc != -1)
	{
		int sym = acc;
		int[] be = (_blockEnds != null && _blockEnds.Length > acc) ? _blockEnds[acc] : null;
		if (be != null)
		{
			state = 0;
			start_be_dfa:
			acc = be[state];
			++state;
			tlen = be[state];
			++state;
			for (i = 0; i < tlen; ++i)
			{
				tto = be[state];
				++state;
				prlen = be[state];
				++state;
				for (j = 0; j < prlen; ++j)
				{
					pmin = be[state];
					++state;
					pmax = be[state];
					++state;
					if (ch < pmin)
					{
						state += ((prlen - (j + 1)) * 2);
						j = prlen;
					}
					else if (ch <= pmax)
					{
						Advance(s, ref ch, ref len, false);
						state = tto;
						goto start_be_dfa;
					}
				}
			}
			if (acc != -1)
			{
				return FAMatch.Create(sym,
#if FALIB_SPANS
					s.Slice(unchecked((int)cursor_pos), len).ToString()
#else
					s.Substring(unchecked((int)cursor_pos), len)
#endif
					, cursor_pos, line, column);
			}
			if (ch == -1)
			{
				return FAMatch.Create(-1,
#if FALIB_SPANS
					s.Slice(unchecked((int)cursor_pos), len).ToString()
#else
					s.Substring(unchecked((int)cursor_pos), len)
#endif
					, cursor_pos, line, column);
			}
			Advance(s, ref ch, ref len, false);
			state = 0;
			goto start_be_dfa;
		}
		return FAMatch.Create(acc,
#if FALIB_SPANS
					s.Slice(unchecked((int)cursor_pos), len).ToString()
#else
					s.Substring(unchecked((int)cursor_pos), len)
#endif
			, cursor_pos, line, column);
	}
	// error. keep trying until we find a potential transition.
	while (ch != -1)
	{
		var moved = false;
		state = 1;
		tlen = _dfa[state];
		++state;
		for (i = 0; i < tlen; ++i)
		{
			++state;
			prlen = _dfa[state];
			++state;
			for (j = 0; j < prlen; ++j)
			{
				pmin = _dfa[state];
				++state;
				pmax = _dfa[state];
				++state;
				if (ch < pmin)
				{
					state += ((prlen - (j + 1)) * 2);
					j = prlen;
				}
				else if (ch <= pmax)
				{
					moved = true;
				}
			}
		}
		if (moved)
		{
			break;
		}
		Advance(s, ref ch, ref len, false);
	}
	if (len == 0)
	{
		return FAMatch.Create(-2, null, 0, 0, 0);
	}
	return FAMatch.Create(-1,
#if FALIB_SPANS
					s.Slice(unchecked((int)cursor_pos), len).ToString()
#else
					s.Substring(unchecked((int)cursor_pos), len)
#endif
		, cursor_pos, line, column);
}

trønderen wrote:

To me, the SM table is not the result delivered by a generator - it is a modeling tool for the human developer. The driver is typically a score code statements, independent of the model (a.k.a. transition table). I certainly agree that an editor tailored to transition table editing is a great thing to have. I have tried to maintain a compile time initialized C++ array for a transition table, using Np++. Even for trivial SMs, that is almost impossible (unless you just copy the table from e.g. a standard document and it will be carved in stone).

trønderen wrote:

If I were given the responsibility for a state machine implementation like that, I would immediately run to my boss asking for permission to rewrite the whole thing as a table driven machine.

#include <stdio.h>
#include <conio.h>

// Fn ptrs defs
typedef  void (*RT)( int input );
typedef  RT (*TER)( int input );

// Forward declarations
extern TER state1( int input );
extern TER state2( int input );
extern TER state3( int input );

// First state
TER state1( int input )
{
    printf( "one\t" );
    return input < 10 ? (TER)&state2 : (TER)NULL;
}

// Second state
TER state2( int input )
{
	printf( "two\t" );
	return (TER)&state3;
}

// Third state
TER state3( int input )
{
    printf( "three\t" );
    return (TER)&state1;
}

int main(int argc, char* argv[])
{
    int n;

    // Set Start state
    TER state = (TER)&state1;

    // Exercises the state machine. Ends when state == NULL
    for ( n = 0 ; state ; ++n ) {
        // Executes the current state (state variable) then goes to the next state
        state = (TER)( state( n ) );
    }

    printf( "\n\nPress any key\n" );
    getch();

	return 0;
}

honey the codewitch wrote:

with impossible to follow pointer arrays

honey the codewitch wrote:

I hate function pointer dispatch code in general.

Because at some point you'll have to debug and maintain it, and you end up with impossible to follow pointer arrays hiding the flow of your app.

honey the codewitch wrote:

at some point you'll have to debug and maintain it

then you will do peek and poke on the generated code.