Welcome to the Lounge

Greg Utas wrote:

my guess is that you haven't yet found a division of responsibilities that yields good encapsulation. And it might just be that there isn't one.

Greg Utas wrote:

When I parse C++ to do static analysis, I also "execute" it using operand and operator stacks, which can emit a sort of stack machine pseudo-code to verify that the code was properly understood.

bool Parser::HandleParentheses(ExprPtr& expr)
{
   //  The left parenthesis has already been parsed.  It could introduce a
   //  function call, a C-style cast, or simply parentheses for precedence
   //  (evaluation order).
   //
   auto back = expr->Back();

   //  A function name must precede the arguments for a function call.  The
   //  name could follow a selection operator, as in a.f() or a->f(), which
   //  is why Back(), and not just back(), is used.
   //
   if((back != nullptr) && (back->Type() == Cxx::QualName))
   {
      TokenPtr call;

      if(GetArgList(call))
      {
         expr->AddItem(call);
         return true;
      }
   }

   if(GetCast(expr)) return true;
   return GetPrecedence(expr);
}

// possibly a cast, or possibly a subexpression
// we can't know for sure so this gets *really* complicated
// basically we need to backtrack.
CodeExpression expr = null;
var pc2 = pc.GetLookAhead();
pc2.EnsureStarted();
try
{
	expr = _ParseCast(pc2);
}
catch { }
if(null!=expr)
{
	// now advance our actual pc
	// TODO: see if we can't add a dump feature
	// to the lookahead so we don't have to 
	// parse again. Minor, but sloppy.
	return _ParseCast(pc);

} else
{
	try
	{
		if (!pc.Advance())
			_Error("Unterminated cast or subexpression", pc.Current);
		expr=_ParseExpression(pc);
		_SkipComments(pc);
		if(ST.rparen!=pc.SymbolId)
			_Error("Invalid cast or subexpression", pc.Current);
		pc.Advance();
		return expr;
	}
	catch(Exception eex)
	{
		throw eex;
	}
}

(int, string, double, double, DateTime, bool) Generate(int X, (int, string, bool) Parameters)
{
  ....
}