![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xprop.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / clients / xprop|
Return to xprop.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / clients / xprop |
1.1 root 1: #include <X11/Xlib.h>
2: #include <X11/Xutil.h>
3: #include <string.h>
4: #include <stdio.h>
5: #include <ctype.h>
6:
7: #include <X11/Xatom.h>
8:
9: #include "dsimple.h"
10:
11: #define MAXSTR 10000
12:
13: #define min(a,b) ((a) < (b) ? (a) : (b))
14:
15: /*
16: *
17: * The Thunk Manager - routines to create, add to, and free thunk lists
18: *
19: */
20:
21: typedef struct {
22: int thunk_count;
23: long value;
24: char *extra_value;
25: char *format;
26: char *dformat;
27: } thunk;
28:
29: thunk *Create_Thunk_List()
30: {
31: thunk *tptr;
32:
33: tptr = (thunk *) Malloc( sizeof(thunk) );
34:
35: tptr->thunk_count = 0;
36:
37: return(tptr);
38: }
39:
40: Free_Thunk_List(list)
41: thunk *list;
42: {
43: free(list);
44: }
45:
46: thunk *Add_Thunk(list, t)
47: thunk *list;
48: thunk t;
49: {
50: int i;
51:
52: i = list->thunk_count;
53:
54: list = (thunk *) realloc(list, (i+1)*sizeof(thunk) );
55: if (!list)
56: Fatal_Error("Out of memory!");
57:
58: list[i++] = t;
59: list->thunk_count = i;
60:
61: return(list);
62: }
63:
64: /*
65: * Misc. routines
66: */
67:
68: char *Copy_String(string)
69: char *string;
70: {
71: char *new;
72: int length;
73:
74: length = strlen(string) + 1;
75:
76: new = (char *) Malloc(length);
77: bcopy(string, new, length);
78:
79: return(new);
80: }
81:
82: int Read_Char(stream)
83: FILE *stream;
84: {
85: int c;
86:
87: c = getc(stream);
88: if (c==EOF)
89: Fatal_Error("Bad format file: Unexpected EOF.");
90: return(c);
91: }
92:
93: Read_White_Space(stream)
94: FILE *stream;
95: {
96: int c;
97:
98: while ((c=getc(stream))==' ' || c=='\n' || c=='\t');
99: ungetc(c, stream);
100: }
101:
102: static char _large_buffer[MAXSTR+10];
103:
104: char *Read_Quoted(stream)
105: FILE *stream;
106: {
107: char *ptr;
108: int c, length;
109:
110: Read_White_Space(stream);
111: if (Read_Char(stream)!='\'')
112: Fatal_Error("Bad format file format: missing dformat.");
113:
114: ptr = _large_buffer; length=MAXSTR;
115: for (;;) {
116: if (length<0)
117: Fatal_Error("Bad format file format: dformat too long.");
118: c = Read_Char(stream);
119: if (c==(int) '\'')
120: break;
121: ptr++[0]=c; length--;
122: if (c== (int) '\\') {
123: c=Read_Char(stream);
124: if (c=='\n') {
125: ptr--; length++;
126: } else
127: ptr++[0]=c; length--;
128: }
129: }
130: ptr++[0]='\0';
131:
132: return(Copy_String(_large_buffer));
133: }
134:
135: /*
136: *
137: * Atom to format, dformat mapping Manager
138: *
139: */
140:
141: #define D_FORMAT "0x" /* Default format for properties */
142: #define D_DFORMAT " = $0+\n"; /* Default display pattern for properties */
143:
144: static thunk *_property_formats = 0; /* Holds mapping */
145:
146: Apply_Default_Formats(format, dformat)
147: char **format;
148: char **dformat;
149: {
150: if (!*format)
151: *format = D_FORMAT;
152: if (!*dformat)
153: *dformat = D_DFORMAT;
154: }
155:
156: Lookup_Formats(atom, format, dformat)
157: Atom atom;
158: char **format;
159: char **dformat;
160: {
161: int i;
162:
163: if (_property_formats)
164: for (i=_property_formats->thunk_count-1; i>=0; i--)
165: if (_property_formats[i].value==atom) {
166: if (!*format)
167: *format = _property_formats[i].format;
168: if (!*dformat)
169: *dformat = _property_formats[i].dformat;
170: break;
171: }
172: }
173:
174: Add_Mapping(atom, format, dformat)
175: Atom atom;
176: char *format;
177: char *dformat;
178: {
179: thunk t;
180:
181: if (!_property_formats)
182: _property_formats = Create_Thunk_List();
183:
184: t.value=atom;
185: t.format=format;
186: t.dformat=dformat;
187:
188: _property_formats = Add_Thunk(_property_formats, t);
189: }
190:
191: /*
192: *
193: * Setup_Mapping: Routine to setup default atom to format, dformat mapping:
194: *
195: */
196:
197: typedef struct { Atom atom; char *format; char *dformat } _default_mapping;
198: _default_mapping _default_mappings[] = {
199:
200: /*
201: * General types:
202: */
203: { XA_INTEGER, "0i", 0 },
204: { XA_CARDINAL, "0c", 0 },
205: { XA_STRING, "8s", 0 },
206: { XA_ATOM, "32a", 0 },
207:
208: { XA_POINT, "16ii", " = $0, $1\n" },
209: { XA_RECTANGLE, "16iicc", ":\n\t\tupper left corner: $0, $1\n\
210: \t\tsize: $2 by $3\n" },
211: { XA_ARC, "16iiccii", ":\n\t\tarc at $0, $1\n\
212: \t\tsize: $2 by $3\n\
213: \t\tfrom angle $4 to angle $5\n" },
214:
215: { XA_FONT, "32x", ": font id # $0\n" },
216: { XA_DRAWABLE, "32x", ": drawable id # $0\n" },
217: { XA_WINDOW, "32x", ": window id # $0\n" },
218: { XA_PIXMAP, "32x", ": pixmap id # $0\n" },
219: { XA_BITMAP, "32x", ": bitmap id # $0\n" },
220: { XA_VISUALID, "32x", ": visual id # $0\n" },
221: { XA_COLORMAP, "32x", ": colormap id # $0\n" },
222: { XA_CURSOR, "32x", ": cursor id # $0\n" },
223:
224: { XA_RGB_COLOR_MAP, "32xccccccc", ":\n\
225: \t\tcolormap id #: $0\n\
226: \t\tred-max: $1\n\
227: \t\tred-mult: $2\n\
228: \t\tgreen-max: $3\n\
229: \t\tgreen-mult: $4\n\
230: \t\tblue-max: $5\n\
231: \t\tblue-mult: $6\n\
232: \t\tbase-pixel: $7\n" },
233:
234: /*
235: * Window manager types:
236: */
237: { XA_WM_COMMAND, "8s", " = { $0+ }\n" },
238: { XA_WM_HINTS, "32mbcxxxii", ":\n\
239: ?m0(\t\tApplication accepts input\\?: $1\n)\
240: ?m1(\t\tInitial state is \
241: ?$2=0(Don't Care State)\
242: ?$2=1(Normal State)\
243: ?$2=2(Zoomed State)\
244: ?$2=3(Iconic State)\
245: ?$2=4(Inactive State)\
246: .\n)\
247: ?m2(\t\tpixmap id # to use for icon: $3\n)\
248: ?m5(\t\tbitmap id # of mask for icon: $5\n)\
249: ?m3(\t\twindow id # to use for icon: $4\n)\
250: ?m4(\t\tstarting position for icon: $6, $7\n)" },
251: { XA_WM_SIZE_HINTS, "32mii", ":\n\
252: ?m0(\t\tuser specified location: $1, $2\n)\
253: ?m2(\t\tprogram specified location: $1, $2\n)\
254: ?m1(\t\tuser specified size: $3 by $4\n)\
255: ?m3(\t\tprogram specified size: $3 by $4\n)\
256: ?m4(\t\tprogram specified minimum size: $5 by $6\n)\
257: ?m5(\t\tprogram specified maximum size: $7 by $8\n)\
258: ?m6(\t\tprogram specified resize increment: $9 by $10\n)\
259: ?m7(\t\tprogram specified minimum ascept ratio: $11/$12\n\
260: \t\tprogram specified maximum ascept ratio: $13/$14\n)" },
261: { XA_WM_ICON_SIZE, "32cccccc", ":\n\
262: \t\tminimum icon size: $0 by $1\n\
263: \t\tmaximum icon size: $2 by $3\n\
264: \t\tincremental size change: $4 by $5\n" },
265:
266: /*
267: * Font specific mapping of property names to types:
268: */
269: { XA_MIN_SPACE, "32c", 0 },
270: { XA_NORM_SPACE, "32c", 0 },
271: { XA_MAX_SPACE, "32c", 0 },
272: { XA_END_SPACE, "32c", 0 },
273: { XA_SUPERSCRIPT_X, "32i", 0 },
274: { XA_SUPERSCRIPT_Y, "32i", 0 },
275: { XA_SUBSCRIPT_X, "32i", 0 },
276: { XA_SUBSCRIPT_Y, "32i", 0 },
277: { XA_UNDERLINE_POSITION, "32i", 0 },
278: { XA_UNDERLINE_THICKNESS, "32c", 0 },
279: { XA_STRIKEOUT_ASCENT, "32i", 0 },
280: { XA_STRIKEOUT_DESCENT, "32i", 0 },
281: { XA_ITALIC_ANGLE, "32i", 0 },
282: { XA_X_HEIGHT, "32i", 0 },
283: { XA_QUAD_WIDTH, "32i", 0 },
284: { XA_WEIGHT, "32c", 0 },
285: { XA_POINT_SIZE, "32c", 0 },
286: { XA_RESOLUTION, "32c", 0 },
287: { XA_COPYRIGHT, "32a", 0 },
288: { XA_NOTICE, "32a", 0 },
289: { XA_FONT_NAME, "32a", 0 },
290: { XA_FAMILY_NAME, "32a", 0 },
291: { XA_FULL_NAME, "32a", 0 },
292:
293: { 0, 0, 0 } };
294:
295: Setup_Mapping()
296: {
297: _default_mapping *dmap = _default_mappings;
298:
299: while (dmap->format) {
300: Add_Mapping( dmap->atom, dmap->format, dmap->dformat );
301: dmap++;
302: }
303: }
304:
305: /*
306: * Read_Mapping: routine to read in additional mappings from a stream
307: * already open for reading.
308: */
309:
310: Read_Mappings(stream)
311: FILE *stream;
312: {
313: char format_buffer[100];
314: char name[1000], *dformat, *format;
315: int count, c;
316: Atom atom, Parse_Atom();
317:
318: while ((count=fscanf(stream," %990s %90s ",name,format_buffer))!=EOF) {
319: if (count != 2)
320: Fatal_Error("Bad format file format.");
321:
322: atom = Parse_Atom(name, False);
323: format = Copy_String(format_buffer);
324:
325: Read_White_Space(stream);
326: dformat = D_DFORMAT;
327: c = getc(stream);
328: ungetc(c, stream);
329: if (c==(int)'\'')
330: dformat = Read_Quoted(stream);
331:
332: Add_Mapping(atom, format, dformat);
333: }
334: }
335:
336: /*
337: *
338: * Formatting Routines: a group of routines to translate from various
339: * values to a static read-only string useful for output.
340: *
341: * Routines: Format_Hex, Format_Unsigned, Format_Signed, Format_Atom,
342: * Format_Mask_Word, Format_Bool, Format_String, Format_Len_String.
343: *
344: * All of the above routines take a long except for Format_String and
345: * Format_Len_String.
346: *
347: */
348: static char _formatting_buffer[MAXSTR+100];
349: static char _formatting_buffer2[10];
350:
351: char *Format_Hex(word)
352: long word;
353: {
354: sprintf(_formatting_buffer2, "0x%lx", word);
355: return(_formatting_buffer2);
356: }
357:
358: char *Format_Unsigned(word)
359: long word;
360: {
361: sprintf(_formatting_buffer2, "%lu", word);
362: return(_formatting_buffer2);
363: }
364:
365: char *Format_Signed(word)
366: long word;
367: {
368: sprintf(_formatting_buffer2, "%ld", word);
369: return(_formatting_buffer2);
370: }
371:
372: char *Format_Atom(atom)
373: Atom atom;
374: {
375: char *name;
376:
377: name=XGetAtomName(dpy, atom);
378: if (!name)
379: sprintf(_formatting_buffer, "undefined atom # 0x%lx", atom);
380: else
381: strncpy(_formatting_buffer, name, MAXSTR);
382:
383: return(_formatting_buffer);
384: }
385:
386: char *Format_Mask_Word(word)
387: long word;
388: {
389: long bit_mask, bit;
390: int seen = 0;
391:
392: strcpy(_formatting_buffer, "{MASK: ");
393: for (bit=0, bit_mask=1; bit<=sizeof(long)*8; bit++, bit_mask<<=1) {
394: if (bit_mask & word) {
395: if (seen) {
396: strcat(_formatting_buffer, ", ");
397: }
398: seen=1;
399: strcat(_formatting_buffer, Format_Unsigned(bit));
400: }
401: }
402: strcat(_formatting_buffer, "}");
403:
404: return(_formatting_buffer);
405: }
406:
407: char *Format_Bool(value)
408: long value;
409: {
410: if (!value)
411: return("False");
412:
413: return("True");
414: }
415:
416: static char *_buf_ptr;
417: static int _buf_len;
418:
419: _put_char(c)
420: char c;
421: {
422: if (--_buf_len<0) {
423: _buf_ptr[0]='\0';
424: return;
425: }
426: _buf_ptr++[0] = c;
427: }
428:
429: _format_char(c)
430: char c;
431: {
432: switch (c) {
433: case '\\':
434: case '\"':
435: _put_char('\\');
436: _put_char(c);
437: break;
438: case '\n':
439: _put_char('\\');
440: _put_char('n');
441: break;
442: case '\t':
443: _put_char('\\');
444: _put_char('t');
445: break;
446: default:
447: if (c<' ') {
448: _put_char('\\');
449: sprintf(_buf_ptr, "%o", (int) c);
450: _buf_ptr += strlen(_buf_ptr);
451: _buf_len -= strlen(_buf_ptr);
452: } else
453: _put_char(c);
454: }
455: }
456:
457: char *Format_String(string)
458: char *string;
459: {
460: char c;
461:
462: _buf_ptr = _formatting_buffer;
463: _buf_len = MAXSTR;
464: _put_char('\"');
465:
466: while (c = string++[0])
467: _format_char(c);
468:
469: _buf_len += 3;
470: _put_char('\"');
471: _put_char('\0');
472: return(_formatting_buffer);
473: }
474:
475: char *Format_Len_String(string, len)
476: char *string;
477: int len;
478: {
479: char *data, *result;
480:
481: data = (char *) Malloc(len+1);
482:
483: bcopy(string, data, len);
484: data[len]='\0';
485:
486: result = Format_String(data);
487: free(data);
488:
489: return(result);
490: }
491:
492: /*
493: *
494: * Parsing Routines: a group of routines to parse strings into values
495: *
496: * Routines: Parse_Atom, Scan_Long, Skip_Past_Right_Paran, Scan_Octal
497: *
498: * Routines of the form Parse_XXX take a string which is parsed to a value.
499: * Routines of the form Scan_XXX take a string, parse the beginning to a value,
500: * and return the rest of the string. The value is returned via. the last
501: * parameter. All numeric values are longs!
502: *
503: */
504:
505: char *Skip_Digits(string)
506: char *string;
507: {
508: while (isdigit(string[0])) string++;
509: return(string);
510: }
511:
512: char *Scan_Long(string, value)
513: char *string;
514: long *value;
515: {
516: if (!isdigit(*string))
517: Fatal_Error("Bad number: %s.", string);
518:
519: *value = atol(string);
520: return(Skip_Digits(string));
521: }
522:
523: char *Scan_Octal(string, value)
524: char *string;
525: long *value;
526: {
527: if (sscanf(string, "%lo", value)!=1)
528: Fatal_Error("Bad octal number: %s.", string);
529: return(Skip_Digits(string));
530: }
531:
532: Atom Parse_Atom(name, only_if_exists)
533: char *name;
534: int only_if_exists;
535: {
536: Atom atom;
537:
538: if ((atom = XInternAtom(dpy, name, only_if_exists))==None)
539: return(0);
540:
541: return(atom);
542: }
543:
544: char *Skip_Past_Right_Paran(string)
545: char *string;
546: {
547: char c;
548: int nesting=0;
549:
550: while (c=string++[0], c!=')' || nesting)
551: switch (c) {
552: case '\0':
553: Fatal_Error("Missing ')'.");
554: case '(':
555: nesting++;
556: break;
557: case ')':
558: nesting--;
559: break;
560: case '\\':
561: string++;
562: break;
563: }
564: return(string);
565: }
566:
567: /*
568: *
569: * The Format Manager: a group of routines to manage "formats"
570: *
571: */
572:
573: int Is_A_Format(string)
574: char *string;
575: {
576: return(isdigit(string[0]));
577: }
578:
579: int Get_Format_Size(format)
580: char *format;
581: {
582: long size;
583:
584: Scan_Long(format, &size);
585:
586: /* Check for legal sizes */
587: if (size != 0 && size != 8 && size != 16 && size != 32)
588: Fatal_Error("bad format: %s", format);
589:
590: return((int) size);
591: }
592:
593: char Get_Format_Char(format, i)
594: char *format;
595: int i;
596: {
597: long size;
598:
599: /* Remove # at front of format */
600: format = Scan_Long(format, &size);
601: if (!*format)
602: Fatal_Error("bad format: %s", format);
603:
604: /* Last character repeats forever... */
605: if (i>=strlen(format))
606: i=strlen(format)-1;
607:
608: return(format[i]);
609: }
610:
611: char *Format_Thunk(t, format_char)
612: thunk t;
613: char format_char;
614: {
615: long value;
616: value = t.value;
617:
618: switch (format_char) {
619: case 's':
620: return(Format_Len_String(t.extra_value, t.value));
621: case 'x':
622: return(Format_Hex(value));
623: case 'c':
624: return(Format_Unsigned(value));
625: case 'i':
626: return(Format_Signed(value));
627: case 'b':
628: return(Format_Bool(value));
629: case 'm':
630: return(Format_Mask_Word(value));
631: case 'a':
632: return(Format_Atom(value));
633: default:
634: Fatal_Error("bad format character: %c", format_char);
635: }
636: }
637:
638: char *Format_Thunk_I(thunks, format, i)
639: thunk *thunks;
640: char *format;
641: int i;
642: {
643: if (i >= thunks->thunk_count)
644: return("<field not available>");
645:
646: return(Format_Thunk(thunks[i], Get_Format_Char(format, i)));
647: }
648:
649: long Mask_Word(thunks, format)
650: thunk *thunks;
651: char *format;
652: {
653: int j;
654:
655: for (j=0; j<strlen(format); j++)
656: if (Get_Format_Char(format, j) == 'm')
657: return(thunks[j].value);
658: return(0L);
659: }
660:
661: /*
662: *
663: * The Display Format Manager:
664: *
665: */
666:
667: int Is_A_DFormat(string)
668: char *string;
669: {
670: return( string[0] && string[0]!='-' && !isalpha(string[0]) );
671: }
672:
673: char *Handle_Backslash(dformat)
674: char *dformat;
675: {
676: char c;
677: long i;
678:
679: if (!(c = *(dformat++)))
680: return(dformat);
681:
682: switch (c) {
683: case 'n':
684: putchar('\n');
685: break;
686: case 't':
687: putchar('\t');
688: break;
689: case '0':
690: case '1':
691: case '2':
692: case '3':
693: case '4':
694: case '5':
695: case '6':
696: case '7':
697: dformat = Scan_Octal(dformat, &i);
698: putchar((int) i);
699: break;
700: default:
701: putchar(c);
702: break;
703: }
704: return(dformat);
705: }
706:
707: char *Handle_Dollar_sign(dformat, thunks, format)
708: char *dformat;
709: thunk *thunks;
710: char *format;
711: {
712: long i;
713:
714: dformat = Scan_Long(dformat, &i);
715:
716: if (dformat[0]=='+') {
717: int seen=0;
718: dformat++;
719: for (; i<thunks->thunk_count; i++) {
720: if (seen)
721: printf(", ");
722: seen = 1;
723: printf("%s", Format_Thunk_I(thunks, format, (int) i));
724: }
725: } else
726: printf("%s", Format_Thunk_I(thunks, format, (int) i));
727:
728: return(dformat);
729: }
730:
731: int Mask_Bit_I(thunks, format, i)
732: thunk *thunks;
733: char *format;
734: int i;
735: {
736: long value;
737:
738: value = Mask_Word(thunks, format);
739:
740: value = value & (1L<<i);
741: if (value)
742: value=1;
743: return(value);
744: }
745:
746: char *Scan_Term(string, thunks, format, value)
747: thunk *thunks;
748: char *string, *format;
749: long *value;
750: {
751: long i;
752:
753: *value=0;
754:
755: if (isdigit(*string))
756: string = Scan_Long(string, value);
757: else if (*string=='$') {
758: string = Scan_Long(++string, &i);
759: if (i>=thunks->thunk_count)
760: i=thunks->thunk_count;
761: *value = thunks[i].value;
762: } else if (*string=='m') {
763: string = Scan_Long(++string, &i);
764: *value = Mask_Bit_I(thunks, format, (int) i);
765: } else
766: Fatal_Error("Bad term: %s.", string);
767:
768: return(string);
769: }
770:
771: char *Scan_Exp(string, thunks, format, value)
772: thunk *thunks;
773: char *string, *format;
774: long *value;
775: {
776: long temp;
777:
778: if (string[0]=='(') {
779: string = Scan_Exp(++string, thunks, format, value);
780: if (string[0]!=')')
781: Fatal_Error("Missing ')'");
782: return(++string);
783: }
784: if (string[0]=='!') {
785: string = Scan_Exp(++string, thunks, format, value);
786: *value = !*value;
787: return(string);
788: }
789:
790: string = Scan_Term(string, thunks, format, value);
791:
792: if (string[0]=='=') {
793: string = Scan_Exp(++string, thunks, format, &temp);
794: *value = *value == temp;
795: }
796:
797: return(string);
798: }
799:
800: char *Handle_Question_Mark(dformat, thunks, format)
801: thunk *thunks;
802: char *dformat, *format;
803: {
804: long true;
805:
806: dformat = Scan_Exp(dformat, thunks, format, &true);
807:
808: if (*dformat!='(')
809: Fatal_Error("Bad conditional: '(' expected: %s.", dformat);
810: ++dformat;
811:
812: if (!true)
813: dformat = Skip_Past_Right_Paran(dformat);
814:
815: return(dformat);
816: }
817:
818: Display_Property(thunks, dformat, format)
819: thunk *thunks;
820: char *dformat, *format;
821: {
822: char c;
823:
824: while (c = *(dformat++))
825: switch (c) {
826: case ')':
827: continue;
828: case '\\':
829: dformat = Handle_Backslash(dformat);
830: continue;
831: case '$':
832: dformat = Handle_Dollar_sign(dformat, thunks, format);
833: continue;
834: case '?':
835: dformat = Handle_Question_Mark(dformat, thunks, format);
836: continue;
837: default:
838: putchar(c);
839: continue;
840: }
841: }
842:
843: /*
844: *
845: * Routines to convert property data to and from thunks
846: *
847: */
848:
849: long Extract_Value(pointer, length, size, signedp)
850: char **pointer;
851: int *length;
852: int size;
853: {
854: long value, mask;
855:
856: switch (size) {
857: case 8:
858: value = (long) * (char *) *pointer;
859: *pointer += 1;
860: *length -= 1;
861: mask = 0xff;
862: break;
863: case 16:
864: value = (long) * (short *) *pointer;
865: *pointer += 2;
866: *length -= 2;
867: mask = 0xffff;
868: break;
869: default:
870: /* Error */
871: case 32:
872: value = (long) * (long *) *pointer;
873: *pointer += 4;
874: *length -= 4;
875: mask = 0xffffffff;
876: break;
877: }
878: if (!signedp)
879: value &= mask;
880: return(value);
881: }
882:
883: long Extract_Len_String(pointer, length, size, string)
884: char **pointer;
885: int *length;
886: int size;
887: char **string;
888: {
889: int len;
890:
891: if (size!=8)
892: Fatal_Error("can't use format character 's' with any size except 8.");
893: len=0; *string = *pointer;
894: while ((len++, --*length, *((*pointer)++)) && *length>0);
895:
896: return(len);
897: }
898:
899: thunk *Break_Down_Property(pointer, length, format, size)
900: char *pointer, *format;
901: int length, size;
902: {
903: thunk *thunks;
904: thunk t;
905: int i;
906: char format_char;
907:
908: thunks = Create_Thunk_List();
909: i=0;
910:
911: while (length>=(size/8)) {
912: format_char = Get_Format_Char(format, i);
913: if (format_char=='s')
914: t.value=Extract_Len_String(&pointer,&length,size,&t.extra_value);
915: else
916: t.value=Extract_Value(&pointer,&length,size,format_char=='i');
917: thunks = Add_Thunk(thunks, t);
918: i++;
919: }
920:
921: return(thunks);
922: }
923:
924: /*
925: *
926: * Routines for parsing command line:
927: *
928: */
929:
930: usage()
931: {
932: outl("\n%s: usage: %s [<select option>] <option>* <mapping>* <spec>*",
933: program_name, program_name);
934: outl("\n\tselect option ::= -root | -id <id> | -font <font> | -name <name>\
935: \n\toption ::= -len <n> | -notype | -spy | {-formats|-fs} <format file>\
936: \n\tmapping ::= {-f|-format} <atom> <format> [<dformat>]\
937: \n\tspec ::= [<format> [<dformat>]] <atom>\
938: \n\tformat ::= {0|8|16|32}{a|b|c|i|m|s|x}*\
939: \n\tdformat ::= <unit><unit>* (can't start with a letter or '-')\
940: \n\tunit ::= ?<exp>(<unit>*) | $<n> | <display char>\
941: \n\texp ::= <term> | <term>=<exp> | !<exp>\
942: \n\tterm ::= <n> | $<n> | m<n>\
943: \n\tdisplay char ::= <normal char> | \\<non digit char> | \\<octal number>\
944: \n\tnormal char ::= <any char except a digit, $, ?, \\, or )>\
945: \n\n");
946: exit(1);
947: }
948:
949: Parse_Format_Mapping(argc, argv)
950: int *argc;
951: char ***argv;
952: #define ARGC (*argc)
953: #define ARGV (*argv)
954: #define OPTION ARGV[0]
955: #define NXTOPT if (++ARGV, --ARGC==0) usage()
956: {
957: char *type_name, *format, *dformat;
958:
959: NXTOPT; type_name = OPTION;
960:
961: NXTOPT; format = OPTION;
962: if (!Is_A_Format(format))
963: Fatal_Error("Bad format: %s.", format);
964:
965: dformat=0;
966: if (ARGC>0 && Is_A_DFormat(ARGV[1])) {
967: ARGV++; ARGC--; dformat=OPTION;
968: }
969:
970: Add_Mapping( Parse_Atom(type_name, False), format, dformat);
971: }
972:
973: /*
974: *
975: * The Main Program:
976: *
977: */
978:
979: Window target_win=0;
980: int notype=0;
981: int spy=0;
982: int max_len=MAXSTR;
983: XFontStruct *font;
984:
985: main(argc, argv)
986: int argc;
987: char **argv;
988: {
989: FILE *stream;
990: char *name, *getenv();
991: thunk *props, *Handle_Prop_Requests();
992:
993: INIT_NAME;
994:
995: /* Handle display name, opening the display */
996: Setup_Display_And_Screen(&argc, argv);
997:
998: /* Handle selecting the window to display properties for */
999: target_win = Select_Window_Args(&argc, argv);
1000:
1001: /* Set up default atom to format, dformat mapping */
1002: Setup_Mapping();
1003: if (name = getenv("XPROPFORMATS")) {
1004: if (!(stream=fopen(name, "r")))
1005: Fatal_Error("unable to open file %s for reading.", name);
1006: Read_Mappings(stream);
1007: fclose(stream);
1008: }
1009:
1010: /* Handle '-' options to setup xprop, select window to work on */
1011: while (argv++, --argc>0 && **argv=='-') {
1012: if (!strcmp(argv[0], "-"))
1013: continue;
1014: if (!strcmp(argv[0], "-notype")) {
1015: notype=1;
1016: continue;
1017: }
1018: if (!strcmp(argv[0], "-spy")) {
1019: spy=1;
1020: continue;
1021: }
1022: if (!strcmp(argv[0], "-len")) {
1023: if (++argv, --argc==0) usage();
1024: max_len = atoi(argv[0]);
1025: continue;
1026: }
1027: if (!strcmp(argv[0], "-formats") || !strcmp(argv[0], "-fs")) {
1028: if (++argv, --argc==0) usage();
1029: if (!(stream=fopen(argv[0], "r")))
1030: Fatal_Error("unable to open file %s for reading.", argv[0]);
1031: Read_Mappings(stream);
1032: fclose(stream);
1033: continue;
1034: }
1035: if (!strcmp(argv[0], "-font")) {
1036: if (++argv, --argc==0) usage();
1037: font = Open_Font(argv[0]);
1038: target_win = -1;
1039: continue;
1040: }
1041: if (!strcmp(argv[0], "-f") || !strcmp(argv[0], "-format")) {
1042: Parse_Format_Mapping(&argc, &argv);
1043: continue;
1044: }
1045: usage();
1046: }
1047:
1048: if (target_win==0)
1049: target_win = Select_Window(dpy);
1050:
1051: props=Handle_Prop_Requests(argc, argv);
1052:
1053: if (spy && target_win != -1) {
1054: XEvent event;
1055: char *format, *dformat;
1056:
1057: XSelectInput(dpy, target_win, PropertyChangeMask);
1058: for (;;) {
1059: XNextEvent(dpy, &event);
1060: format = dformat = NULL;
1061: if (props) {
1062: int i;
1063: for (i=0; i<props->thunk_count; i++)
1064: if (props[i].value == event.xproperty.atom)
1065: break;
1066: if (i>=props->thunk_count)
1067: continue;
1068: format = props[i].format;
1069: dformat = props[i].dformat;
1070: }
1071: Show_Prop(format, dformat, Format_Atom(event.xproperty.atom));
1072: }
1073: }
1074: }
1075:
1076: /*
1077: *
1078: * Other Stuff (temp.):
1079: *
1080: */
1081:
1082: thunk *Handle_Prop_Requests(argc, argv)
1083: int argc;
1084: char **argv;
1085: {
1086: char *format, *dformat, *prop;
1087: thunk *thunks, t;
1088:
1089: thunks = Create_Thunk_List();
1090:
1091: /* if no prop referenced, by default list all properties for given window */
1092: if (!argc) {
1093: Show_All_Props();
1094: return(NULL);
1095: }
1096:
1097: while (argc>0) {
1098: format = 0;
1099: dformat = 0;
1100:
1101: /* Get overriding formats, if any */
1102: if (Is_A_Format(argv[0])) {
1103: format = argv++[0]; argc--;
1104: if (!argc) usage();
1105: }
1106: if (Is_A_DFormat(argv[0])) {
1107: dformat = argv++[0]; argc--;
1108: if (!argc) usage();
1109: }
1110:
1111: /* Get property name */
1112: prop = argv++[0]; argc--;
1113:
1114: t.value = Parse_Atom(prop, True);
1115: t.format = format;
1116: t.dformat = dformat;
1117: if (t.value)
1118: thunks = Add_Thunk(thunks, t);
1119: Show_Prop(format, dformat, prop);
1120: }
1121: return(thunks);
1122: }
1123:
1124: Show_All_Props()
1125: {
1126: Atom *atoms, atom;
1127: char *name;
1128: int count, i;
1129:
1130: if (target_win!=-1) {
1131: atoms = XListProperties(dpy, target_win, &count);
1132: for (i=0; i<count; i++) {
1133: name = Format_Atom(atoms[i]);
1134: Show_Prop(0, 0, name);
1135: }
1136: } else
1137: for (i=0; i<font->n_properties; i++) {
1138: atom = font->properties[i].name;
1139: name = Format_Atom(atom);
1140: Show_Prop(0, 0, name);
1141: }
1142: }
1143:
1144: Set_Prop(format, dformat, prop, mode, value)
1145: char *format, *dformat, *prop, *value;
1146: char mode;
1147: {
1148: outl("Seting prop %s(%s) using %s mode %c to %s",
1149: prop, format, dformat, mode, value);
1150: }
1151:
1152: static unsigned long _font_prop;
1153:
1154: char *Get_Font_Property_Data_And_Type(atom, length, type, size)
1155: Atom atom;
1156: long *length;
1157: Atom *type;
1158: int *size;
1159: {
1160: int i;
1161:
1162: *type = 0;
1163:
1164: for (i=0; i<font->n_properties; i++)
1165: if (atom==font->properties[i].name) {
1166: _font_prop=font->properties[i].card32;
1167: *length=4;
1168: *size=32;
1169: return((char *) &_font_prop);
1170: }
1171: return(0);
1172: }
1173:
1174: char *Get_Window_Property_Data_And_Type(atom, length, type, size)
1175: Atom atom;
1176: long *length;
1177: Atom *type;
1178: int *size;
1179: {
1180: Atom actual_type;
1181: int actual_format;
1182: long nitems;
1183: long bytes_after;
1184: char *prop;
1185: int status;
1186:
1187: status = XGetWindowProperty(dpy, target_win, atom, 0, (max_len+3)/4,
1188: False, AnyPropertyType, &actual_type,
1189: &actual_format, &nitems, &bytes_after,
1190: &prop);
1191: if (status==BadWindow)
1192: Fatal_Error("window id # 0x%lx does not exists!", target_win);
1193: if (status!=Success)
1194: Fatal_Error("XGetWindowProperty failed!");
1195:
1196: *length = min(nitems * actual_format/8, max_len);
1197: *type = actual_type;
1198: *size = actual_format;
1199: return(prop);
1200: }
1201:
1202: char *Get_Property_Data_And_Type(atom, length, type, size)
1203: Atom atom;
1204: long *length;
1205: Atom *type;
1206: int *size;
1207: {
1208: if (target_win == -1)
1209: return(Get_Font_Property_Data_And_Type(atom, length, type, size));
1210: else
1211: return(Get_Window_Property_Data_And_Type(atom, length, type, size));
1212: }
1213:
1214: Show_Prop(format, dformat, prop)
1215: char *format, *dformat, *prop;
1216: {
1217: char *data;
1218: long length;
1219: Atom atom, type;
1220: thunk *thunks;
1221: int size, fsize;
1222:
1223: printf("%s", prop);
1224: if (!(atom = Parse_Atom(prop, True))) {
1225: printf(": not defined.\n");
1226: return;
1227: }
1228:
1229: data = Get_Property_Data_And_Type(atom, &length, &type, &size);
1230: if (!size) {
1231: puts(": not defined.");
1232: return;
1233: }
1234:
1235: if (!notype && type)
1236: printf("(%s)", Format_Atom(type));
1237:
1238: Lookup_Formats(atom, &format, &dformat);
1239: if (type)
1240: Lookup_Formats(type, &format, &dformat);
1241: Apply_Default_Formats(&format, &dformat);
1242:
1243: fsize=Get_Format_Size(format);
1244: if (fsize!=size && fsize!=0) {
1245: printf(": Type mismatch: assumed size %d bits, actual size %d bits.\n",
1246: fsize, size);
1247: return;
1248: }
1249:
1250: thunks = Break_Down_Property(data, length, format, size);
1251:
1252: Display_Property(thunks, dformat, format);
1253: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.