So I have a program whose purpose is to take text files and parse them into a binary format that an embedded system understands. However, the text format I've inherited that I need to parse is sufficiently complex enough that after refactoring the main `parse` routine I'm left with a class with more than 50 methods that almost all look something like `parseChannel`, `parseWCommand`, `parseVCommand`, `parsePCommand`, `parseLoop`, `parseHex`, `parseInt`, etc. etc. etc.

Needless to say, the class, from its declaration, looks huge and daunting.

However, the methods to interface with the class are extremely simple, just `parse` (compile the text, figure out its compiled size) and `link` (fix the pointers once the location in memory is known, return the finalized raw binary data). Really, to the user the class has virtually no other reason for existence besides those two functions, but there's so much seemingly useless fluff in the class declaration that it's hard to even see what it's supposed to do. There's a similar situation going on with the rather massive number of data members that, again, are useless to everything but the class's internal methods that need them to talk to each other, though I don't know if that's as much of an issue.

I've considered making a separate class solely for parsing that's used within the `parse` method, but it seems strange to me to build an entirely separate class that's only used in a single method in a single class. It seems a bit...superfluous, I guess? And I don't even know if that's attacking the right problem.

I guess in the end, here's what I'm asking:

1. Is this seemingly-huge class actually a problem? I don't think it's strictly a "god object", but it superficially looks like one.
2. If it is a problem, what are the best method(s) to fix it?