#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <strings.h>

#include <X11/X.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>

extern const char *__progname;

static char *displayname;
static int arg_id;
static int arg_screen;
static int arg_depth;
static char *arg_class;
static int arg_redmask;
static int arg_greenmask;
static int arg_bluemask;
static int arg_cmapsize;
static int arg_bitsperrgb;

static int gave_id;
static int gave_screen;
static int gave_depth;
static int gave_class;
static int gave_redmask;
static int gave_greenmask;
static int gave_bluemask;
static int gave_cmapsize;
static int gave_bitsperrgb;

static int just_root;
static const char *fmt =
	"ID ~i: screen ~s, depth ~d, class ~c,~?d"
		" masks R=~mr G=~mg B=~mb,"
	"~?."
	" colormap-size ~z, bits-per-rgb ~b";

static Display *disp;
static int nvis;
static XVisualInfo *vis;
static long int template_mask;
static XVisualInfo template;

static void handleargs(int ac, char **av)
{
 int skip;
 int errs;
 static struct {
	  const char *name;
	  int *gave;
	  int *value;
	  } numargs[] = { { "-id",         &gave_id,         &arg_id         },
			  { "-screen",     &gave_screen,     &arg_screen     },
			  { "-depth",      &gave_depth,      &arg_depth      },
			  { "-redmask",    &gave_redmask,    &arg_redmask    },
			  { "-greenmask",  &gave_greenmask,  &arg_greenmask  },
			  { "-bluemask",   &gave_bluemask,   &arg_bluemask   },
			  { "-cmapsize",   &gave_cmapsize,   &arg_cmapsize   },
			  { "-bitsperrgb", &gave_bitsperrgb, &arg_bitsperrgb },
			  { 0, 0, 0 } };
 int i;

 skip = 0;
 errs = 0;
 for (ac--,av++;ac;ac--,av++)
  { if (skip > 0)
     { skip --;
       continue;
     }
    if (**av != '-')
     { fprintf(stderr,"%s: unrecognized argument `%s'\n",__progname,*av);
       errs ++;
       continue;
     }
    if (0)
     {
needarg:;
       fprintf(stderr,"%s: %s needs a following argument\n",__progname,*av);
       errs ++;
       continue;
     }
#define WANTARG() do { if (++skip >= ac) goto needarg; } while (0)
    if (!strcmp(*av,"-display"))
     { WANTARG();
       displayname = av[skip];
       continue;
     }
    if (!strcmp(*av,"-class"))
     { WANTARG();
       arg_class = av[skip];
       gave_class = 1;
       continue;
     }
    if (!strcmp(*av,"-root"))
     { just_root = 1;
       continue;
     }
    if (!strcmp(*av,"-fmt"))
     { WANTARG();
       fmt = av[skip];
       continue;
     }
    for (i=0;numargs[i].name;i++)
     { if (!strcmp(*av,numargs[i].name))
	{ int v;
	  char *ep;
	  WANTARG();
	  v = strtol(av[skip],&ep,0);
	  if (*ep || (ep == av[skip]))
	   { fprintf(stderr,"%s: bad %s number `%s'\n",__progname,*av,av[skip]);
	     errs ++;
	   }
	  else
	   { *numargs[i].value = v;
	     *numargs[i].gave = 1;
	   }
	  break;
	}
     }
    if (numargs[i].name) continue;
#undef WANTARG
    fprintf(stderr,"%s: unrecognized option `%s'\n",__progname,*av);
    errs ++;
  }
 if (errs)
  { exit(1);
  }
}

static const char *classname(int class)
{
 static char badbuf[64];

 switch (class)
  { default:
       sprintf(&badbuf[0],"?%d",class);
       return(&badbuf[0]);
       break;
    case StaticGray:
       return("StaticGray");
       break;
    case StaticColor:
       return("StaticColor");
       break;
    case TrueColor:
       return("TrueColor");
       break;
    case GrayScale:
       return("GrayScale");
       break;
    case PseudoColor:
       return("PseudoColor");
       break;
    case DirectColor:
       return("DirectColor");
       break;
  }
}

static int class(char *name)
{
 if (!strcasecmp(name,"DirectColor")) return(DirectColor);
 if (!strcasecmp(name,"GrayScale"))   return(GrayScale);
 if (!strcasecmp(name,"PseudoColor")) return(PseudoColor);
 if (!strcasecmp(name,"StaticColor")) return(StaticColor);
 if (!strcasecmp(name,"StaticGray"))  return(StaticGray);
 if (!strcasecmp(name,"TrueColor"))   return(TrueColor);
 fprintf(stderr,"%s: `%s' is an unknown class name\n",__progname,name);
 exit(1);
}

static Display *open_display(char *disp)
{
 Display *rv;

 rv = XOpenDisplay(disp);
 if (rv == 0)
  { fprintf(stderr,"%s: can't open display %s\n",__progname,XDisplayName(disp));
    exit(1);
  }
 return(rv);
}

static void print_visual(XVisualInfo *v)
{
 __label__ ret;

 const char *fp;
 unsigned int cs;
 unsigned int cd;
 int cond;

 static void done(void)
  { putchar('\n');
    goto ret;
  }

 fp = fmt;
 cd = 0;
 cs = 1;
 while (1)
  { switch (*fp)
     { case '\0':
	  done();
	  break;
       case '~':
	  switch <"esc"> (*++fp)
	   { case '\0':
		done();
		break;
	     case '?':
		switch (*++fp)
		 { case '\0':
		      done();
		      break;
		   case 'd':
		      switch (v->class)
		       { case DirectColor: case TrueColor: cond = 1; break;
			 default: cond = 0; break;
		       }
		      break;
		   case '|':
		      if (cd > 0) cs ^= 1;
		      break <"esc">;
		   case '.':
		      if (cd > 0)
		       { cd --;
			 cs >>= 1;
		       }
		      break <"esc">;
		 }
		cs = (cs << 1) | cond;
		cd ++;
		break;
	     case 'b':
		if (cs & 1) printf("%d",v->bits_per_rgb);
		break;
	     case 'c':
		if (cs & 1) printf("%s",classname(v->class));
		break;
	     case 'd':
		if (cs & 1) printf("%u",v->depth);
		break;
	     case 'i':
		if (cs & 1) printf("0x%x",(unsigned int)v->visualid);
		break;
	     case 'm':
		 { unsigned long int mask;
		   unsigned long int all;
		   int width;
		   switch (*++fp)
		    { case 'r': mask = v->red_mask;   break;
		      case 'g': mask = v->green_mask; break;
		      case 'b': mask = v->blue_mask;  break;
		      default: mask = 0; break;
		    }
		   if (cs & 1)
		    { all = v->red_mask | v->green_mask | v->blue_mask;
		      for (width=1;all>>=4;width++) ;
		      printf("0x%0*lx",width,mask);
		    }
		 }
		break;
	     case 's':
		if (cs & 1) printf("%d",v->screen);
		break;
	     case 'z':
		if (cs & 1) printf("%d",v->colormap_size);
		break;
	   }
	  fp ++;
	  break;
       default:
	  if (cs & 1) putchar(*fp);
	  fp ++;
	  break;
     }
  }
ret:;
}

int main(int, char **);
int main(int ac, char **av)
{
 int i;

 handleargs(ac,av);
 disp = open_display(displayname);
 if (just_root)
  { template_mask = VisualIDMask;
    template.visualid = XVisualIDFromVisual(XDefaultVisualOfScreen(XDefaultScreenOfDisplay(disp)));
  }
 else
  { template_mask = 0;
    if (gave_id)         { template_mask |= VisualIDMask;           template.visualid      = arg_id;           }
    if (gave_screen)     { template_mask |= VisualScreenMask;       template.screen        = arg_screen;       }
    if (gave_depth)      { template_mask |= VisualDepthMask;        template.depth         = arg_depth;        }
    if (gave_class)      { template_mask |= VisualClassMask;        template.class         = class(arg_class); }
    if (gave_redmask)    { template_mask |= VisualRedMaskMask;      template.red_mask      = arg_redmask;      }
    if (gave_greenmask)  { template_mask |= VisualGreenMaskMask;    template.green_mask    = arg_greenmask;    }
    if (gave_bluemask)   { template_mask |= VisualBlueMaskMask;     template.blue_mask     = arg_bluemask;     }
    if (gave_cmapsize)   { template_mask |= VisualColormapSizeMask; template.colormap_size = arg_cmapsize;     }
    if (gave_bitsperrgb) { template_mask |= VisualBitsPerRGBMask;   template.bits_per_rgb  = arg_bitsperrgb;   }
  }
 vis = XGetVisualInfo(disp,template_mask,&template,&nvis);
 for (i=0;i<nvis;i++) print_visual(&vis[i]);
 exit(nvis<1);
}