This looks fantastic, but now all builds are failing at generating the editor UI.
An idea why that is? I will check on my side.

The reason of this problem is that the final commit would remove the generated file.
As consequence, the target directory would be empty, git does not record this directory, generating fails because of the missing directory.

The flag kIgnoreOOB feels like an anomaly.
It's better imho kEnforceBounds = kEnforceLowerBound|kEnforceUpperBound, and not enforcing bounds being default.
This makes also the code more straightforward, the conditionals kIgnoreOOB can go altogether.

Nevermind I understood it wrong. I take it that kIgnoreOOB must be for enumerated values.
It raises some questions though, why is it set some parameters which are not enumerated?
(eg. compThreshold, compRatio)

No actually it's more the "ignoring vs clamping" question when you get a value out of bounds, so not for enumerated. For example what to do if you get offset=40 offset=-1? Do you keep offset at 40 or "clamp" the -1 to zero?

Do you keep offset at 40 or "clamp" the -1 to zero?

Imho a maximum of the opcode reading process should be encoded into the spec.
That includes "-1" special values, textual enumerations, normalizations to %, and so on.

I'll try to put in more.

Regarding the out-of-bounds situation, it seems sforzando has varying behaviors. For example, negative values for ampeg_attack will cause the value to be reset to the default one. Negative values for pitch_keycenter seem to screw up everything however. I think I'll remove the kIgnoreOOB flag, and in case the value is out of an enforced bound, then the read method returns nullopt. In the current parsing most of the time this will leave the value unchanged rather than reset to default, it seems better like this.

Hi,

A bit tired of this PR tbh, but here goes. Now the OpcodeSpec handles everything in the background. The prototype is as follows:

template<class T>
struct OpcodeSpec
{
    T defaultInputValue;
    Range<T> bounds;
    int flags;
    /**
     * @brief Normalizes an input as needed for the spec
     *
     * @param input
     * @return T
     */
    T normalizeInput(T input) const { .... }

    operator T() const { return normalizeInput(defaultInputValue); }
};

Flags can be

enum OpcodeFlags : int {
    kCanBeNote = 1,
    kEnforceLowerBound = 1 << 1,
    kEnforceUpperBound = 1 << 2,
    kNormalizePercent = 1 << 3,
    kNormalizeMidi = 1 << 4,
    kNormalizeBend = 1 << 5,
    kWrapPhase = 1 << 6,
    kDb2Mag = 1 << 7,
};

In usage for parsing, opcodes are initialized as

int64_t offsetRandom { Default::offsetRandom }; // offset_random

and parsed as

crossfadeVelCurve = opcode.read(Default::crossfadeCurve);

or if you need an unset optional as default

downKeyswitch = opcode.readOptional(Default::key);

The read method basically calls readOptional, and readOptional sends back nullopt if the value is e.g. out of bounds. The read method then sends back the default value if this happens. This matches ARIA's behavior. All the switching and normalization appears behind the scene. I also tried to tidy up the effects and put their defaults with the others as much as possible.

Some cleanups, commenting and testing to do still.