Welcome to the Lounge

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.

If you really are as ignorant of the code generated by Visual FA as you are of the code generated by the gcc compiler

trønderen wrote:

But you state that you do see a need to maintain the Visual FA generated code. So you do not trust your generator/compiler.

honey the codewitch wrote:

That would be fair, if I ever said that. However, I did not say that.

trønderen wrote:

our subject line clearly suggests that you expect to have full control over the gotos produced by your Visual FA generator.