pike.git / src / modules / Image / layers.c

version» Context lines:

pike.git/src/modules/Image/layers.c:725:    if (THIS->alpha)    free_object(THIS->alpha);    THIS->alpha=NULL;    THIS->alp=NULL;       if (args>=1) {    if ( TYPEOF(Pike_sp[-args]) != T_OBJECT )    {    if (TYPEOF(Pike_sp[-args]) != T_INT ||    Pike_sp[-args].u.integer!=0) -  SIMPLE_BAD_ARG_ERROR("Image.Layer->set_image",1, -  "object(Image)|int(0)"); +  SIMPLE_BAD_ARG_ERROR("set_image",1,"Image.Image|int(0..0)");    }    else if ((img=get_storage(Pike_sp[-args].u.object,image_program)))    {    THIS->image=Pike_sp[-args].u.object;    add_ref(THIS->image);    THIS->img=img;    THIS->xsize=img->xsize;    THIS->ysize=img->ysize;    }    else -  SIMPLE_BAD_ARG_ERROR("Image.Layer->set_image",1, -  "object(Image)|int(0)"); +  SIMPLE_BAD_ARG_ERROR("set_image",1, "Image.Image|int(0..0)");    }       if (args>=2) {    if ( TYPEOF(Pike_sp[1-args]) != T_OBJECT )    {    if (TYPEOF(Pike_sp[1-args]) != T_INT ||    Pike_sp[1-args].u.integer!=0) -  SIMPLE_BAD_ARG_ERROR("Image.Layer->set_image",2, -  "object(Image)|int(0)"); +  SIMPLE_BAD_ARG_ERROR("set_image",2, "Image.Image|int(0..0)");    }    else if ((img=get_storage(Pike_sp[1-args].u.object,image_program)))    {    if (THIS->img &&    (img->xsize!=THIS->xsize ||    img->ysize!=THIS->ysize)) -  SIMPLE_BAD_ARG_ERROR("Image.Layer->set_image",2, -  "image of same size"); +  SIMPLE_BAD_ARG_ERROR("set_image",2, "image of same size");    if (!THIS->img)    {    THIS->xsize=img->xsize;    THIS->ysize=img->ysize;    }    THIS->alpha=Pike_sp[1-args].u.object;    add_ref(THIS->alpha);    THIS->alp=img;    }    else -  SIMPLE_BAD_ARG_ERROR("Image.Layer->set_image",2, -  "object(Image)|int(0)"); +  SIMPLE_BAD_ARG_ERROR("set_image",2,"Image.Image|int(0..0)");    }       pop_n_elems(args);    ref_push_object(THISOBJ);   }      static void image_layer_get_misc_value( INT32 args )   {    if( args != 1 )    Pike_error("Wrong number of arguments to get_misc_value\n");
pike.git/src/modules/Image/layers.c:839:   **! method object set_alpha_value(float value)   **! method float alpha_value()   **! Set/get the general alpha value of this layer.   **! This is a float value between 0 and 1,   **! and is multiplied with the alpha channel.   */      static void image_layer_set_alpha_value(INT32 args)   {    FLOAT_TYPE f; -  get_all_args("Image.Layer->set_alpha_value",args,"%F",&f); +  get_all_args("set_alpha_value",args,"%F",&f);    if (f<0.0 || f>1.0) -  SIMPLE_BAD_ARG_ERROR("Image.Layer->set_alpha_value",1,"float(0..1)"); +  SIMPLE_BAD_ARG_ERROR("set_alpha_value",1,"float(0..1)");    THIS->alpha_value=f;    pop_n_elems(args);    ref_push_object(THISOBJ);   }      static void image_layer_alpha_value(INT32 args)   {    pop_n_elems(args);    push_float(THIS->alpha_value);   }
pike.git/src/modules/Image/layers.c:1052:   **!   **! note:   **! image and alpha channel must be of the same size,   **! or canceled.   */      static void image_layer_set_mode(INT32 args)   {    int i;    if (args!=1) -  SIMPLE_TOO_FEW_ARGS_ERROR("Image.Layer->set_mode",1); +  SIMPLE_TOO_FEW_ARGS_ERROR("set_mode",1);    if (TYPEOF(Pike_sp[-args]) != T_STRING) -  SIMPLE_BAD_ARG_ERROR("Image.Layer->set_mode",1,"string"); +  SIMPLE_BAD_ARG_ERROR("set_mode",1,"string");       for (i=0; i<LAYER_MODES; i++)    if (Pike_sp[-args].u.string==layer_mode[i].ps)    {    THIS->row_func=layer_mode[i].func;    THIS->optimize_alpha=layer_mode[i].optimize_alpha;    THIS->really_optimize_alpha=really_optimize_p(THIS);       pop_n_elems(args);    ref_push_object(THISOBJ);    return;    }    -  SIMPLE_BAD_ARG_ERROR("Image.Layer->set_mode",1,"existing mode"); +  SIMPLE_BAD_ARG_ERROR("set_mode",1,"existing mode");   }      static void image_layer_mode(INT32 args)   {    int i;    pop_n_elems(args);       for (i=0; i<LAYER_MODES; i++)    if (THIS->row_func==layer_mode[i].func)    {
pike.git/src/modules/Image/layers.c:1125:   **! method object fill()   **! method object fill_alpha()   **! Set/query fill color and alpha, ie the color used "outside" the   **! image. This is mostly useful if you want to "frame"   **! a layer.   */      static void image_layer_set_fill(INT32 args)   {    if (!args) -  SIMPLE_TOO_FEW_ARGS_ERROR("Image.Layer->set_fill",1); +  SIMPLE_TOO_FEW_ARGS_ERROR("set_fill",1);       if (TYPEOF(Pike_sp[-args]) == T_INT && !Pike_sp[-args].u.integer)    THIS->fill=black;    else    if (!image_color_arg(-args,&(THIS->fill))) -  SIMPLE_BAD_ARG_ERROR("Image.Layer->set_fill",1,"color"); +  SIMPLE_BAD_ARG_ERROR("set_fill",1,"Image.Color");       smear_color(THIS->sfill,THIS->fill,SNUMPIXS);       THIS->fill_alpha=white;    if (args>1) {    if (TYPEOF(Pike_sp[1-args]) == T_INT && !Pike_sp[1-args].u.integer)    ; /* white is good */    else    if (!image_color_arg(1-args,&(THIS->fill_alpha)))    {    smear_color(THIS->sfill_alpha,THIS->fill_alpha,SNUMPIXS); -  SIMPLE_BAD_ARG_ERROR("Image.Layer->set_fill",2,"color"); +  SIMPLE_BAD_ARG_ERROR("set_fill",2,"Image.Color");    }    }    smear_color(THIS->sfill_alpha,THIS->fill_alpha,SNUMPIXS);      #if 0    {    int i;    for (i=0; i<SNUMPIXS; i++)    fprintf(stderr,"#%02x%02x%02x ",THIS->sfill_alpha[i].r,THIS->sfill_alpha[i].g,THIS->sfill_alpha[i].b);    fprintf(stderr,"\n");
pike.git/src/modules/Image/layers.c:1194:   **! Set/query layer offset.   **!   **! method int xsize()   **! method int ysize()   **! Query layer offset. This is the same as layer   **! image/alpha image size.   */      static void image_layer_set_offset(INT32 args)   { -  get_all_args("Image.Layer->set_offset",args,"%d%d", /* INT32! */ +  get_all_args("set_offset",args,"%d%d", /* INT32! */    &(THIS->xoffs),&(THIS->yoffs));    pop_n_elems(args);    ref_push_object(THISOBJ);   }      static void image_layer_xoffset(INT32 args)   {    pop_n_elems(args);    push_int(THIS->xoffs);   }
pike.git/src/modules/Image/layers.c:1235:   **! method object set_tiled(int yes)   **! method int tiled()   **! Set/query <i>tiled</i> flag. If set, the   **! image and alpha channel will be tiled rather   **! then framed by the <ref>fill</ref> values.   */      static void image_layer_set_tiled(INT32 args)   {    INT_TYPE tiled; -  get_all_args("Image.Layer->set_offset",args,"%i",&tiled); +  get_all_args("set_tiled",args,"%i",&tiled);    THIS->tiled=!!tiled;    THIS->really_optimize_alpha=really_optimize_p(THIS);    pop_n_elems(args);    ref_push_object(THISOBJ);   }      static void image_layer_tiled(INT32 args)   {    pop_n_elems(args);    push_int(THIS->tiled);
pike.git/src/modules/Image/layers.c:1357:    try_parameter_pair("fill","fill_alpha",image_layer_set_fill);    try_parameter("tiled",image_layer_set_tiled);    pop_stack();    return;    }    else if (TYPEOF(Pike_sp[-args]) == T_INT && args>1    && TYPEOF(Pike_sp[1-args]) == T_INT)    {    rgb_group col=black,alpha=white;    -  get_all_args("Image.Layer",args,"%d%d", /* watch the type: INT32 */ +  get_all_args("create",args,"%d%d", /* watch the type: INT32 */    &(THIS->xsize),&(THIS->ysize));    if (args>2)    if (!image_color_arg(2-args,&col)) -  SIMPLE_BAD_ARG_ERROR("Image.Layer",3,"Image.Color"); +  SIMPLE_BAD_ARG_ERROR("create",3,"Image.Color");       if (args>3)    if (!image_color_arg(3-args,&alpha)) -  SIMPLE_BAD_ARG_ERROR("Image.Layer",4,"Image.Color"); +  SIMPLE_BAD_ARG_ERROR("create",4,"Image.Color");       push_int(THIS->xsize);    push_int(THIS->ysize);    push_int(col.r);    push_int(col.g);    push_int(col.b);    push_object(clone_object(image_program,5));       push_int(THIS->xsize);    push_int(THIS->ysize);
pike.git/src/modules/Image/layers.c:1397:    if (args>2)    {    image_layer_set_mode(args-2);    pop_stack();    args=2;    }    image_layer_set_image(args);    pop_stack();    }    else -  SIMPLE_BAD_ARG_ERROR("Image.Layer",1,"mapping|int|Image.Image"); +  SIMPLE_BAD_ARG_ERROR("create",1,"mapping|int|Image.Image");   }      /*** layer object *****************************************/      /*   **! method mapping(string:mixed)|string cast()   **! ([ "xsize":int,   **! "ysize":int,   **! "image":image,   **! "alpha":image,
pike.git/src/modules/Image/layers.c:1421:   **! "fill_alpha":image   **! "tiled":int,   **! "mode":string   **! ])    */   static void image_layer_cast(INT32 args)   {    struct pike_string *type;       if (!args) -  SIMPLE_TOO_FEW_ARGS_ERROR("Image.Layer->cast",1); +  SIMPLE_TOO_FEW_ARGS_ERROR("cast",1);       type = Pike_sp[-args].u.string;    pop_n_elems(args); /* type have at least one more reference. */       if (type == literal_mapping_string)    {    int n=0;       push_text("xsize"); push_int(THIS->xsize); n++;    push_text("ysize"); push_int(THIS->ysize); n++;
pike.git/src/modules/Image/layers.c:1497:      static void lm_normal(rgb_group *s,rgb_group *l,rgb_group *d,    rgb_group *sa,rgb_group *la,rgb_group *da,    int len,double alpha)   {    /* la may be NULL, no other */       if (alpha==0.0) /* optimized */    {   #ifdef LAYERS_DUAL -  MEMCPY(d,s,sizeof(rgb_group)*len); -  MEMCPY(da,sa,sizeof(rgb_group)*len); +  memcpy(d,s,sizeof(rgb_group)*len); +  memcpy(da,sa,sizeof(rgb_group)*len);   #endif    return;    }    else if (alpha==1.0)    {    if (!la) /* no layer alpha => full opaque */    { -  MEMCPY(d,l,sizeof(rgb_group)*len); +  memcpy(d,l,sizeof(rgb_group)*len);    smear_color(da,white,len);    }    else    {    while (len--)    {    if (la->r==0 && la->g==0 && la->b==0)    {    *d=*s;    *da=*sa;
pike.git/src/modules/Image/layers.c:2206:      /* special modes */      static void lm_dissolve(rgb_group *s,rgb_group *l,rgb_group *d,    rgb_group *sa,rgb_group *la,rgb_group *da,    int len,double alpha)   {    if (alpha==0.0)    {   #ifdef LAYERS_DUAL -  MEMCPY(d,s,sizeof(rgb_group)*len); -  MEMCPY(da,sa,sizeof(rgb_group)*len); +  memcpy(d,s,sizeof(rgb_group)*len); +  memcpy(da,sa,sizeof(rgb_group)*len);   #endif    return;    }    else if (alpha==1.0)    {    if (!la) /* no layer alpha => full opaque */    { -  MEMCPY(d,l,sizeof(rgb_group)*len); +  memcpy(d,l,sizeof(rgb_group)*len);    smear_color(da,white,len);    }    else    while (len--)    {    if ((my_rand()%(255*255)) <    (unsigned)(la->r*87 + la->g*127 + la->b*41))    *d=*l,*da=white;    else    *d=*s,*da=*sa;
pike.git/src/modules/Image/layers.c:2265:      static void lm_behind(rgb_group *s,rgb_group *l,rgb_group *d,    rgb_group *sa,rgb_group *la,rgb_group *da,    int len,double alpha)   {    /* la may be NULL, no other */       if (alpha==0.0) /* optimized */    {   #ifdef LAYERS_DUAL -  MEMCPY(d,s,sizeof(rgb_group)*len); -  MEMCPY(da,sa,sizeof(rgb_group)*len); +  memcpy(d,s,sizeof(rgb_group)*len); +  memcpy(da,sa,sizeof(rgb_group)*len);   #endif    return;    }    else if (alpha==1.0)    while (len--)    {    if (sa->r==COLORMAX && sa->g==COLORMAX && sa->b==COLORMAX)    {    *d=*s;    *da=*sa;
pike.git/src/modules/Image/layers.c:2335:    }   }      static void lm_erase(rgb_group *UNUSED(s),rgb_group *UNUSED(l),rgb_group *UNUSED(d),    rgb_group *sa,rgb_group *la,rgb_group *da,    int len,double alpha)   {    /* la may be NULL, no other */      #ifdef LAYERS_DUAL -  MEMCPY(d,s,sizeof(rgb_group)*len); +  memcpy(d,s,sizeof(rgb_group)*len);   #endif       if (alpha==1.0)    if (!la) /* full opaque */    smear_color(da,black,len);    else    while (len--)    {    da->r=CCUT(sa->r*(int)(COLORMAX-la->r));    da->g=CCUT(sa->g*(int)(COLORMAX-la->g));
pike.git/src/modules/Image/layers.c:2379:    rgb_group *l, rgb_group *la,    rgb_group *s, rgb_group *sa,    rgb_group *d, rgb_group *da,    int len)      {    /* special optimized */    if (!la)    {   #ifdef LAYERS_DUAL -  MEMCPY(d,s,len*sizeof(rgb_group)); -  MEMCPY(da,sa,len*sizeof(rgb_group)); +  memcpy(d,s,len*sizeof(rgb_group)); +  memcpy(da,sa,len*sizeof(rgb_group));   #endif    return;    }       if (ly->alpha_value==1.0)    if (!l)    if (ly->fill.r!=0 ||    ly->fill.g!=0 ||    ly->fill.b!=0)    {
pike.git/src/modules/Image/layers.c:2405:    d->b=MINIMUM(s->b+la->b,COLORMAX);    da->r=MINIMUM(sa->r+la->r,COLORMAX);    da->g=MINIMUM(sa->g+la->g,COLORMAX);    da->b=MINIMUM(sa->b+la->b,COLORMAX);    da++; sa++; la++; d++; s++;    }    }    else    {   #ifdef LAYERS_DUAL -  MEMCPY(d,s,len*sizeof(rgb_group)); +  memcpy(d,s,len*sizeof(rgb_group));   #endif    while (len--)    {    da->r=MINIMUM(sa->r+la->r,COLORMAX);    da->g=MINIMUM(sa->g+la->g,COLORMAX);    da->b=MINIMUM(sa->b+la->b,COLORMAX);    da++; sa++; la++;    }    }    else
pike.git/src/modules/Image/layers.c:2510:    da+=l->xoffs-xoffs;    }    else    {    if (s) s+=xoffs-l->xoffs;    if (sa) sa+=xoffs-l->xoffs;    len-=xoffs-l->xoffs;    }    if (len<xsize) /* copy bit, fill right */    { -  if (s) MEMCPY(d,s,len*sizeof(rgb_group)); +  if (s) memcpy(d,s,len*sizeof(rgb_group));    else smear_color(d,l->fill,len); -  if (sa) MEMCPY(da,sa,len*sizeof(rgb_group)); +  if (sa) memcpy(da,sa,len*sizeof(rgb_group));    else smear_color(da,white,len);       smear_color(d+len,l->fill,xsize-len);    smear_color(da+len,l->fill_alpha,xsize-len);    }    else /* copy rest */    { -  if (s) MEMCPY(d,s,xsize*sizeof(rgb_group)); +  if (s) memcpy(d,s,xsize*sizeof(rgb_group));    else smear_color(d,l->fill,xsize); -  if (sa) MEMCPY(da,sa,xsize*sizeof(rgb_group)); +  if (sa) memcpy(da,sa,xsize*sizeof(rgb_group));    else smear_color(da,white,xsize);    }    return;    }    else    {    rgb_group *s,*sa;       y%=l->ysize;    if (y<0) y+=l->ysize;
pike.git/src/modules/Image/layers.c:2547:    if (l->alp) sa=l->alp->img+y*l->xsize;    else smear_color(da,white,xsize),sa=NULL;       xoffs-=l->xoffs; /* position in source */    xoffs%=l->xsize;    if (xoffs<0) xoffs+=l->xsize;    if (xoffs)    {    int len=l->xsize-xoffs;    if (len>l->xsize) len=l->xsize; -  if (s) MEMCPY(d,s+xoffs,len*sizeof(rgb_group)); -  if (sa) MEMCPY(da,sa+xoffs,len*sizeof(rgb_group)); +  if (s) memcpy(d,s+xoffs,len*sizeof(rgb_group)); +  if (sa) memcpy(da,sa+xoffs,len*sizeof(rgb_group));    da+=len;    d+=len;    xsize-=len;    }    while (xsize>l->xsize)    { -  if (s) MEMCPY(d,s,l->xsize*sizeof(rgb_group)); -  if (sa) MEMCPY(d,sa,l->xsize*sizeof(rgb_group)); +  if (s) memcpy(d,s,l->xsize*sizeof(rgb_group)); +  if (sa) memcpy(d,sa,l->xsize*sizeof(rgb_group));    da+=l->xsize;    d+=l->xsize;    xsize-=l->xsize;    } -  if (s) MEMCPY(d,s,xsize*sizeof(rgb_group)); -  if (sa) MEMCPY(d,sa,xsize*sizeof(rgb_group)); +  if (s) memcpy(d,s,xsize*sizeof(rgb_group)); +  if (sa) memcpy(d,sa,xsize*sizeof(rgb_group));    }   }      static INLINE void img_lay_stroke(struct layer *ly,    rgb_group *l,    rgb_group *la,    rgb_group *s,    rgb_group *sa,    rgb_group *d,    rgb_group *da,
pike.git/src/modules/Image/layers.c:2593:       if (l)    {    (ly->row_func)(s,l,d,sa,la,da,len,ly->alpha_value);    return;    }    if (!la && ly->really_optimize_alpha)    {   /* fprintf(stderr,"fast skip ly->yoffs=%d\n",ly->yoffs); */   #ifdef LAYERS_DUAL -  MEMCPY(d,s,len*sizeof(rgb_group)); -  MEMCPY(da,sa,len*sizeof(rgb_group)); +  memcpy(d,s,len*sizeof(rgb_group)); +  memcpy(da,sa,len*sizeof(rgb_group));   #endif    return;    }       if (!la &&    ly->fill_alpha.r==COLORMAX &&    ly->fill_alpha.g==COLORMAX &&    ly->fill_alpha.b==COLORMAX)    {    while (len>SNUMPIXS)
pike.git/src/modules/Image/layers.c:2894:   {    int layers,i,j;    struct layer **l;    struct object *o;    struct layer *dest;    struct array *a;    INT_TYPE xoffset=0,yoffset=0,xsize=0,ysize=0;    ONERROR err;       if (!args) -  SIMPLE_TOO_FEW_ARGS_ERROR("Image.lay",1); +  SIMPLE_TOO_FEW_ARGS_ERROR("lay",1);       if (TYPEOF(Pike_sp[-args]) != T_ARRAY) -  SIMPLE_BAD_ARG_ERROR("Image.lay",1, -  "array(Image.Layer|mapping)"); +  SIMPLE_BAD_ARG_ERROR("lay",1,"array(Image.Layer|mapping)");       if (args>1)    { -  get_all_args("Image.lay",args-1,"%i%i%i%i", +  get_all_args("lay",args-1,"%i%i%i%i",    &xoffset,&yoffset,&xsize,&ysize);    if (xsize<1) -  SIMPLE_BAD_ARG_ERROR("Image.lay",4,"int(1..)"); +  SIMPLE_BAD_ARG_ERROR("lay",4,"int(1..)");    if (ysize<1) -  SIMPLE_BAD_ARG_ERROR("Image.lay",5,"int(1..)"); +  SIMPLE_BAD_ARG_ERROR("lay",5,"int(1..)");    }       layers=(a=Pike_sp[-args].u.array)->size;       if (!layers) /* dummy return empty layer */    {    pop_n_elems(args);    push_object(clone_object(image_layer_program,0));    return;    }
pike.git/src/modules/Image/layers.c:2929:    l=(struct layer**)xalloc(sizeof(struct layer *)*layers);       SET_ONERROR(err, free, l);       for (i=j=0; i<layers; i++)    {    if (TYPEOF(a->item[i]) == T_OBJECT)    {    if (!(l[j]=get_storage(a->item[i].u.object,    image_layer_program))) -  SIMPLE_BAD_ARG_ERROR("Image.lay",1, +  SIMPLE_BAD_ARG_ERROR("lay",1,    "array(Image.Layer|mapping)");    }    else if (TYPEOF(a->item[i]) == T_MAPPING)    {    push_svalue(a->item+i);    push_object(o=clone_object(image_layer_program,1));    args++;    l[j]=get_storage(o,image_layer_program);    }    else -  SIMPLE_BAD_ARG_ERROR("Image.lay",1, +  SIMPLE_BAD_ARG_ERROR("lay",1,    "array(Image.Layer|mapping)");    if (l[j]->xsize && l[j]->ysize)    j++;    }       if (!(layers = j)) /* dummy return empty layer */    {    CALL_AND_UNSET_ONERROR(err);    pop_n_elems(args);    push_object(clone_object(image_layer_program,0));
pike.git/src/modules/Image/layers.c:3032:    l->yoffs=THIS->yoffs;    l->image=THIS->image;    l->alpha=THIS->alpha;    l->img=THIS->img;    l->alp=THIS->alp;    if (l->image) add_ref(l->image);    if (l->alpha) add_ref(l->alpha);    l->alpha_value=THIS->alpha_value;    l->fill=THIS->fill;    l->fill_alpha=THIS->fill_alpha; -  MEMCPY(l->sfill,THIS->sfill,sizeof(rgb_group)*SNUMPIXS); -  MEMCPY(l->sfill_alpha,THIS->sfill_alpha,sizeof(rgb_group)*SNUMPIXS); +  memcpy(l->sfill,THIS->sfill,sizeof(rgb_group)*SNUMPIXS); +  memcpy(l->sfill_alpha,THIS->sfill_alpha,sizeof(rgb_group)*SNUMPIXS);    l->tiled=THIS->tiled;    l->row_func=THIS->row_func;    l->optimize_alpha=THIS->optimize_alpha;    l->really_optimize_alpha=THIS->really_optimize_alpha;    if (THIS->misc) l->misc = copy_mapping( THIS->misc );    return l;   }      /*   **! module Image
pike.git/src/modules/Image/layers.c:3079:   **! if there was no cropping to be done.   */      static void image_layer_crop(INT32 args)   {    struct layer *l;    INT_TYPE x,y,xz,yz,xi,yi;    int zot=0;    struct image *img = NULL;    -  get_all_args("Image.Layer->crop",args,"%i%i%i%i",&x,&y,&xz,&yz); +  get_all_args("crop",args,"%i%i%i%i",&x,&y,&xz,&yz);       l=clone_this_layer();    if (x<=l->xoffs) x=l->xoffs; else zot++;    if (y<=l->yoffs) y=l->yoffs; else zot++;    if (l->xsize+l->xoffs<=x+xz) xz=l->xsize-(x-l->xoffs); else zot++;    if (l->ysize+l->yoffs<=y+yz) yz=l->ysize-(y-l->yoffs); else zot++;       xi=x-l->xoffs;    yi=y-l->yoffs;    l->xoffs=x;
pike.git/src/modules/Image/layers.c:3240:    image_layer_crop(4);   }         static void image_layer__sprintf( INT32 args )   {    int x;    if (args != 2 )    SIMPLE_TOO_FEW_ARGS_ERROR("_sprintf",2);    if (TYPEOF(Pike_sp[-args]) != T_INT) -  SIMPLE_BAD_ARG_ERROR("_sprintf",0,"integer"); +  SIMPLE_BAD_ARG_ERROR("_sprintf",0,"int");    if (TYPEOF(Pike_sp[1-args]) != T_MAPPING)    SIMPLE_BAD_ARG_ERROR("_sprintf",1,"mapping");       x = Pike_sp[-2].u.integer;       pop_n_elems( 2 );    switch( x )    {    case 't':    push_text("Image.Layer");
pike.git/src/modules/Image/layers.c:3292:    tOr4(tFunc(tNone,tVoid),    tFunc(tObj tOr(tObj,tVoid) tOr(tString,tVoid),tVoid),    tFunc(tLayerMap,tVoid),    tFunc(tInt tInt    tOr(tColor,tVoid) tOr(tColor,tVoid),tVoid)),0);          ADD_FUNCTION("_sprintf",image_layer__sprintf,    tFunc(tInt tMapping,tString),0);    ADD_FUNCTION("cast",image_layer_cast, -  tFunc(tString,tMapping),ID_PROTECTED); +  tFunc(tString,tOr(tMapping,tString)),ID_PROTECTED);          ADD_FUNCTION("clone",image_layer_clone,    tFunc(tNone,tObj),0);       /* set */       ADD_FUNCTION("set_offset",image_layer_set_offset,tFunc(tInt tInt,tObj),0);    ADD_FUNCTION("set_image",image_layer_set_image,    tFunc(tOr(tObj,tVoid) tOr(tObj,tVoid),tObj),0);