Welcome to the Lounge

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 clearly misunderstood you. Sorry.