Yalantis/uCrop · error · CImgArgumentException

[cimg_appname_math_parser] CImg<%s>::%s: %s: Too %s argument

Error message

[cimg_appname_math_parser] CImg<%s>::%s: %s: Too %s arguments specified, in expression '%s'.

What it means

This is the generic argument-count check in the CImg math parser's opcode dispatcher: a named function/opcode was invoked with a number of arguments outside its accepted range. The `default:` arm of a switch over argument counts reports 'Too few' when opcode._height<5 and 'Too much' otherwise. It means the expression used a supported function but with the wrong arity.

Source

Thrown at ucrop/src/main/jni/CImg.h:20749

                  CImg<ulongT>::vector(*opcode,opcode[1],opcode[2],opcode[3],opcode[4],
                                       opcode[5],opcode[6],opcode[7],0,opcode[8],opcode[9],opcode[10],~0U,
                                       _cimg_mp_boundary).move_to(opcode);
                  arg1 = 9; break;
                case 12 :
                  CImg<ulongT>::vector(*opcode,opcode[1],opcode[2],opcode[3],opcode[4],
                                       opcode[5],opcode[6],opcode[7],0,opcode[8],opcode[9],opcode[10],~0U,
                                       opcode[11]).move_to(opcode);
                  arg1 = 9; break;
                case 13 :
                  CImg<ulongT>::vector(*opcode,opcode[1],opcode[2],opcode[3],opcode[4],
                                       opcode[5],opcode[6],opcode[7],opcode[8],opcode[9],opcode[10],opcode[11],
                                       opcode[12],_cimg_mp_boundary).move_to(opcode);
                  arg1 = 10; break;
                case 14 :
                  arg1 = 10; break;
                default : // Error -> too few or too much arguments
                  _cimg_mp_strerr;
                  throw CImgArgumentException("[" cimg_appname "_math_parser] "
                                              "CImg<%s>::%s: %s: Too %s arguments specified, "
                                              "in expression '%s'.",
                                              pixel_type(),_cimg_mp_calling_function,s_op,
                                              opcode._height<5?"few":"much",s0);
                }

                _cimg_mp_check_const_scalar((unsigned int)opcode[1],2,3); // w
                opcode[1] = (ulongT)mem[opcode[1]];
                _cimg_mp_check_const_scalar((unsigned int)opcode[2],3,3); // h
                opcode[2] = (ulongT)mem[opcode[2]];
                _cimg_mp_check_const_scalar((unsigned int)opcode[3],4,3); // d
                opcode[3] = (ulongT)mem[opcode[3]];
                _cimg_mp_check_const_scalar((unsigned int)opcode[4],5,3); // s
                opcode[4] = (ulongT)mem[opcode[4]];
                p1 = size((unsigned int)opcode[0]);
                arg2 = (unsigned int)opcode[1];
                arg3 = (unsigned int)opcode[2];
                arg4 = (unsigned int)opcode[3];

View on GitHub (pinned to f788b534b4)

Solutions

  1. Count the arguments in the failing expression against the documented signature of the function being called.
  2. Remove stray/extra commas or duplicated arguments (they create empty or surplus opcode slots).
  3. Update the expression for the current library version if the function signature changed (check CImg changelog).
  4. Split complex expressions and test the offending function call in isolation with the correct arity.

Example fix

// before
fill(median(v,)) // stray comma -> 'Too much arguments'
// after
fill(median(v,3))
Defensive patterns

Strategy: validation

Validate before calling

// count arguments before invoking
size_t nargs = std::count(expr.begin(), expr.end(), ',') + 1;
if (nargs < 4) throw std::runtime_error("function requires at least 4 arguments");

Try / catch

try {
  img.fill(expr.c_str());
} catch (const CImgArgumentException& e) {
  std::cerr << "expression error: " << e.what() << std::endl;
}

Prevention

When it happens

Trigger: Writing an expression that calls a math-parser function with the wrong number of comma-separated arguments, e.g. a function expecting exactly 4+ arguments called with 1-3, or one with a fixed maximum called with extra trailing arguments (e.g. stray commas `f(a,b,,)` adding empty slots).

Common situations: Hand-written G'MIC/CImg expressions with typos, extra commas from copy-paste, or arguments left empty; version changes where a function gained or lost optional parameters so an old expression now has the wrong count.

Understand the failure class

Background: "missing required argument" and "the following required arguments were not provided": what required-argument errors mean and how to fix them — this error's family across 20 libraries.

Related errors

AI-assisted analysis of Yalantis/uCrop@f788b534b4 (2026-09-08). Data as JSON: /api/errors/553b5c1883355d87. Report an issue: GitHub.