home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / x / volume19 / logwtchr / part01 < prev    next >
Encoding:
Text File  |  1993-04-27  |  21.8 KB  |  845 lines
  1. Newsgroups: comp.sources.x
  2. From: mengel@dcdmwm.fnal.gov (Marc W. Mengel)
  3. Subject: v19i072:  logwatcher -  a graphical monitor for dynamic {log,mail,...} files, Part01/01
  4. Message-ID: <1993Apr4.003255.1877@sparky.imd.sterling.com>
  5. X-Md4-Signature: 2cfb1a157f1b4cdfaad6cf345a298f72
  6. Date: Sun, 4 Apr 1993 00:32:55 GMT
  7. Approved: chris@sparky.imd.sterling.com
  8.  
  9. Submitted-by: mengel@dcdmwm.fnal.gov (Marc W. Mengel)
  10. Posting-number: Volume 19, Issue 72
  11. Archive-name: logwatcher/part01
  12. Environment: X11
  13.  
  14.  
  15. #!/bin/sh
  16. # This is a shell archive.  Execute this script with /bin/sh
  17. # to extract the files.
  18.  
  19. echo Extracting README
  20. sed -e 's/^X//' > README <<EOF
  21. XThis is a multiple-mailbox-widget application that lets you associate
  22. Xshell commands with clicking on various mailbox widgets, as well
  23. Xas letting you set the bitmap displayed, and placing a name under
  24. Xeach bitmap.  A simple example is the included  "xbiff.cf" config
  25. Xfile which puts up 2 mailboxes watching two mailfiles.
  26. X
  27. X Originally designed to watch console logs from the Purdue/OSU
  28. X conserver package, but has thousands of other uses.
  29. X
  30. XAuthor: Marc Mengel, Fermi National Accellerator Laboratory, 
  31. X    <mengel@fnal.fnal.gov>
  32. X
  33. XRestrictions: None really; use it as needed, but keep the copyrights in...
  34. EOF
  35. echo Extracting Imakefile
  36. sed -e 's/^X//' > Imakefile <<EOF
  37. X       INCLUDES = -I\$(TOP)
  38. XLOCAL_LIBRARIES = \$(XAWLIB) \$(XMULIB) \$(XTOOLLIB) \$(EXTENSIONLIB) \$(XLIB)
  39. X  SYS_LIBRARIES = -lm
  40. X           SRCS = gram.c main.c scan.c util.c
  41. X           OBJS = gram.o main.o scan.o util.o
  42. X
  43. XComplexProgramTarget(xbiff)
  44. X
  45. Xgram.c: gram.y
  46. X    yacc -vd gram.y; mv y.tab.c gram.c
  47. X
  48. Xscan.c: scan.l
  49. X    lex scan.l; mv lex.yy.c scan.c
  50. EOF
  51. echo Extracting Makefile
  52. sed -e 's/^X//' > Makefile <<EOF
  53. XMETA=Makefile gram.y scan.l
  54. XSRC= Machinelog.c util.c main.c
  55. XHDR= Machinelog.h MachinelogP.h
  56. XSRCg=gram.c scan.c
  57. XHDRg=y.tab.h
  58. XOBJ= gram.o util.o main.o scan.o 
  59. X
  60. XLIB= -L/usr/lpp/X11/Xamples/lib -lXaw -lXmu -lXt -lXext -lX11
  61. XINCLUDE= 
  62. XCFLAGS= -g \$(INCLUDE)
  63. X
  64. Xall: logwatcher
  65. X
  66. Xclean:
  67. X    rm  -f \$(OBJ) \$(SRCg) \$(HDRg) y.output
  68. X
  69. Xlint: lint.errs
  70. X
  71. X#- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  72. X
  73. Xlint.errs: \$(SRC) \$(SRCg)
  74. X    lint -hxn \$(SRC) \$(SRCg) > lint.errs
  75. X
  76. Xlogwatcher: \$(OBJ)
  77. X    \$(CC) -o logwatcher \$(OBJ) \$(LIB)
  78. X
  79. Xgram.c y.tab.h : gram.y
  80. X    yacc -vd gram.y
  81. X    mv y.tab.c gram.c
  82. X
  83. Xscan.c: scan.l y.tab.h
  84. X    lex scan.l
  85. X    mv lex.yy.c scan.c
  86. EOF
  87. echo Extracting gram.y
  88. sed -e 's/^X//' > gram.y <<EOF
  89. X%{
  90. X /* (c) 1993 Marc Mengel and Fermilab, who retain a nonexclusive liscence */
  91. X#include <stdio.h>
  92. X#include <X11/Xatom.h>
  93. X#include <X11/Xlib.h>
  94. X#include <X11/Intrinsic.h>
  95. X#include <X11/StringDefs.h>
  96. X#include <X11/Xaw/Form.h>
  97. X#include <X11/Xaw/Mailbox.h>
  98. X
  99. XWidget cur, temp;
  100. Xchar **ppc;
  101. X%}
  102. X
  103. X%token STRING ITEM INT HEXINT ROW COLUMN COMMAND BITMAP
  104. X
  105. X%union {
  106. X    int i;        /* integer values */
  107. X    Widget w;    /* Xaw toolkit widgets */
  108. X    char *pc;    /* character strings */
  109. X};
  110. X
  111. X%type <pc> STRING                /* from scanner */
  112. X%type <w> group_def vitem_list hitem_list    /* internal use */
  113. X%type <i> INT HEXINT                /* from scanner */
  114. X
  115. X%%
  116. Xfile     : def_list group_def ';'
  117. X    ;
  118. X
  119. Xdef_list: item_def ';'
  120. X    | def_list item_def ';'
  121. X    ;
  122. X
  123. Xitem_def: ITEM STRING BITMAP STRING
  124. X        { 
  125. X
  126. X            store(\$2, \$4, 0,0,0);
  127. X        }
  128. X    | ITEM STRING COMMAND STRING BITMAP STRING
  129. X        { 
  130. X            ppc = malloc(3*sizeof(char *));
  131. X            ppc[0] = ppc[1] = ppc[2] = \$4;
  132. X            store(\$2, \$6, 0,0,ppc);
  133. X        }
  134. X    | ITEM STRING COMMAND '(' STRING ',' STRING ',' STRING ')' BITMAP STRING
  135. X        { 
  136. X            ppc = malloc(3*sizeof(char *));
  137. X            ppc[0] = \$5;
  138. X            ppc[1] = \$7;
  139. X            ppc[2] = \$9;
  140. X            store(\$2, \$12, 0,0,ppc);
  141. X        }
  142. X    ;
  143. X
  144. Xgroup_def
  145. X    : ROW     { push(cur); cur=newform(0,0);}     '{' hitem_list '}'
  146. X        { \$\$ = cur; done(cur);  cur = pop(); }
  147. X    | COLUMN { push(cur); cur=newform(0,0);}    '{' vitem_list '}'
  148. X        { \$\$ = cur; done(cur);  cur = pop(); }
  149. X    | STRING STRING ';'
  150. X        { \$\$ = makeitem( \$1, \$2, 0, 0, 0 ); }
  151. X    | STRING STRING COMMAND STRING ';'
  152. X        { 
  153. X            ppc = malloc(3*sizeof(char *));
  154. X            ppc[0] = ppc[1] = ppc[2] = \$4;
  155. X            \$\$ = makeitem( \$1, \$2, ppc, 0, 0 ); 
  156. X        }
  157. X    | STRING STRING COMMAND '(' STRING ',' STRING ',' STRING ')' ';'
  158. X        { 
  159. X            ppc = malloc(3*sizeof(char *));
  160. X            ppc[0] = \$5;
  161. X            ppc[1] = \$7;
  162. X            ppc[2] = \$9;
  163. X            \$\$ = makeitem( \$1, \$2, ppc, 0, 0 ); 
  164. X        }
  165. X    ;
  166. X
  167. X/*
  168. X** note that hitem_list and vitem_list are identical *except* that they
  169. X** pass XtNfromVert and XtNfromHoriz to make the icons stack vertically
  170. X** or horizantally in the form.
  171. X*/
  172. X
  173. Xvitem_list
  174. X    : ROW     { push(cur); cur=newform(0,0);}     '{' hitem_list '}' ';'
  175. X        { \$\$ = cur; done(cur);  cur = pop(); }
  176. X    | COLUMN { push(cur); cur=newform(0,0);}    '{' vitem_list '}' ';'
  177. X        { \$\$ = cur; done(cur);  cur = pop(); }
  178. X    | STRING STRING ';'
  179. X        { \$\$ = makeitem( \$1, \$2, 0, 0, 0 ); }
  180. X    | STRING STRING COMMAND STRING ';'
  181. X        { \$\$ = makeitem( \$1, \$2, \$4, 0, 0 ); }
  182. X     | vitem_list ROW { push(cur); cur=newform(\$1,XtNfromVert);} '{' hitem_list '}' ';'
  183. X        { \$\$ = cur; done(cur); cur = pop(); }
  184. X     | vitem_list COLUMN {push(cur);cur=newform(\$1,XtNfromVert);} '{' vitem_list '}' ';'
  185. X        { \$\$ = cur; done(cur); cur = pop(); }
  186. X    | vitem_list STRING STRING ';'
  187. X        { \$\$ = makeitem( \$2, \$3, 0, \$1, XtNfromVert ); }
  188. X    | vitem_list STRING STRING COMMAND STRING ';'
  189. X        { 
  190. X            ppc = malloc(3*sizeof(char *));
  191. X            ppc[0] = \$5;
  192. X            ppc[1] = \$5;
  193. X            ppc[2] = \$5;
  194. X            \$\$ = makeitem( \$2, \$3, ppc, \$1, XtNfromVert ); 
  195. X        } 
  196. X    | vitem_list STRING STRING COMMAND '(' STRING ',' STRING ',' STRING ')' ';'
  197. X        { 
  198. X            ppc = malloc(3*sizeof(char *));
  199. X            ppc[0] = \$6;
  200. X            ppc[1] = \$8;
  201. X            ppc[2] = \$10;
  202. X            \$\$ = makeitem( \$2, \$3, ppc, \$1, XtNfromVert ); 
  203. X        } 
  204. X    ;
  205. X
  206. Xhitem_list
  207. X    : ROW     { push(cur); cur=newform(0,0);}     '{' hitem_list '}' ';'
  208. X        { \$\$ = cur; done(cur); cur = pop(); }
  209. X    | COLUMN { push(cur); cur=newform(0,0);}    '{' vitem_list '}' ';'
  210. X        { \$\$ = cur; done(cur); cur = pop(); }
  211. X    | STRING STRING ';'
  212. X        { \$\$ = makeitem( \$1, \$2, 0, 0, 0 ); }
  213. X    | STRING STRING COMMAND STRING ';'
  214. X        { \$\$ = makeitem( \$1, \$2, \$4, 0, 0 ); }
  215. X     | hitem_list ROW { push(cur); cur=newform(\$1,XtNfromHoriz);} '{' hitem_list '}' ';'
  216. X        { \$\$ = cur; done(cur); cur = pop(); }
  217. X     | hitem_list COLUMN {push(cur);cur=newform(\$1,XtNfromHoriz);} '{' vitem_list '}' ';'
  218. X        { \$\$ = cur; done(cur); cur = pop(); }
  219. X    | hitem_list STRING STRING ';'
  220. X        { \$\$ = makeitem( \$2, \$3, 0, \$1, XtNfromHoriz ); }
  221. X    | hitem_list STRING STRING COMMAND STRING ';'
  222. X        { 
  223. X            ppc = malloc(3*sizeof(char *));
  224. X            ppc[0] = \$5;
  225. X            ppc[1] = \$5;
  226. X            ppc[2] = \$5;
  227. X            \$\$ = makeitem( \$2, \$3, ppc, \$1, XtNfromHoriz ); 
  228. X        } 
  229. X    | hitem_list STRING STRING COMMAND '(' STRING ',' STRING ',' STRING ')' ';'
  230. X        { 
  231. X            ppc = malloc(3*sizeof(char *));
  232. X            ppc[0] = \$6;
  233. X            ppc[1] = \$8;
  234. X            ppc[2] = \$10;
  235. X            \$\$ = makeitem( \$2, \$3, ppc, \$1, XtNfromHoriz ); 
  236. X        } 
  237. X    ;
  238. X%%
  239. X
  240. Xyyerror(s) { extern int lines; fprintf(stderr,"line %d:", lines ); perror(s);}
  241. X
  242. Xyywrap() { return 1;}
  243. EOF
  244. echo Extracting logwatcher.0
  245. sed -e 's/^X//' > logwatcher.0 <<EOF
  246. XLOGWATCHER(1)                  Console Tools                     LOGWATCHER(1)
  247. X
  248. X
  249. X
  250. XNAME
  251. X   logwatcher -- a graphical monitor for dynamic {log,mail,...} files
  252. X
  253. XSYNOPSIS
  254. X   logwatcher [xoptions] configfile
  255. X   logwatcher [xoptions] < configfile
  256. X
  257. XDESCRIPTION
  258. X   logwatcher reads a configuration listing icon bitmaps, position
  259. X   information and log file names, and presents an icon for each
  260. X   file, which is highlighted when the file grows.  When the icon
  261. X   for a given log file is pressed, the command associated with
  262. X   that icon is executed; you can also configure separate commands
  263. X   for button1, button2, and button3.
  264. X
  265. X   Command strings may have a "%s" in them, which is replaced with
  266. X   the log file name before execution (via sprintf(3)).  Backslash
  267. X   escapes (like "\\n") are replaced in quoted strings.
  268. X
  269. X   Commands can be specified on a per icon-type, and/or a per file
  270. X   basis, the per file command overrides the per icon-type item.
  271. X   A list of 3 commands in parenthesis can be given to allow different
  272. X   commands for different mouse buttons.
  273. X
  274. X   The strings in bitmap definitions are names of X bitmap files a'la
  275. X   bitmap(1).
  276. X
  277. X   rows and columns of icons may be nested to group various sets of
  278. X   items together.
  279. X
  280. XEXAMPLES
  281. X   /* three way xbiff */
  282. X   icon mailbox command "xterm -e Mail -f %s" 
  283. X    bitmap /usr/include/X11/bitmaps/flagdown;
  284. X
  285. X   row {
  286. X    mailbox "/usr/mail/fred";
  287. X    mailbox "/usr/mail/joe";
  288. X    mailbox "/usr/mail/harry";
  289. X   };
  290. X
  291. X
  292. XLOGWATCHER(1)                  Console Tools                     LOGWATCHER(1)
  293. X
  294. X   
  295. XGRAMMAR
  296. X   file : def_list group_def ';'
  297. X       ;
  298. X
  299. X   def_list: item_def ';'
  300. X       | def_list item_def ';'
  301. X       ;
  302. X
  303. X   item_def: ITEM STRING BITMAP STRING
  304. X       |ITEM STRING COMMAND STRING BITMAP STRING
  305. X       |ITEM STRING COMMAND '(' STRING ',' STRING ',' STRING ')' BITMAP STRING
  306. X       ;
  307. X
  308. X   group_def
  309. X       : ROW          '{' item_list '}'
  310. X       | COLUMN     '{' item_list '}'
  311. X       ;
  312. X
  313. X   item_list
  314. X     : ROW     '{' item_list '}' ';'
  315. X     | COLUMN     '{' item_list '}' ';'
  316. X     | STRING STRING ';'
  317. X     | STRING STRING COMMAND STRING ';'
  318. X     | STRING STRING COMMAND '(' STRING ',' STRING ',' STRING ')' ';'
  319. X     | item_list ROW  '{' item_list '}' ';'
  320. X     | item_list COLUMN  '{' item_list '}' ';'
  321. X     | item_list STRING STRING ';'
  322. X     | item_list STRING STRING COMMAND STRING ';'
  323. X     | item_list STRING STRING COMMAND '(' STRING ',' STRING ',' STRING ')' ';'
  324. X     ;
  325. X
  326. XRESOURCES
  327. X   logwatcher*Font
  328. X
  329. XAUTHOR
  330. X   Marc Mengel, Fermi National Accelerator Laboratory
  331. X
  332. XSEE ALSO
  333. X   xbiff(1), printf(3), system(3), bitmap(1)
  334. X
  335. XBUGS
  336. X   There should be some way to unhighlight all of the icons, with or
  337. X   without executing their commands.
  338. X
  339. X   Rows and columns can only be nested 1024 deep.
  340. X
  341. X   "\\023" style octal escapes don't work.
  342. EOF
  343. echo Extracting logwatcher.cf
  344. sed -e 's/^X//' > logwatcher.cf <<EOF
  345. X
  346. X
  347. Xicon rs6000 command "./cons  %s" bitmap "rs6000.bm" ;
  348. X
  349. Xicon sigma bitmap "sigma.bm" ;
  350. X 
  351. Xicon blank bitmap "blank.bm" ;
  352. X
  353. Xrow {
  354. X    row {
  355. X        column {
  356. X            rs6000 /usr/farm/log/fnck00;
  357. X            rs6000 /usr/farm/log/fnck01;
  358. X            rs6000 /usr/farm/log/fnck02;
  359. X            rs6000 /usr/farm/log/fnck03;
  360. X            sigma  _;
  361. X            rs6000 /usr/farm/log/fnck04;
  362. X            rs6000 /usr/farm/log/fnck05;
  363. X            rs6000 /usr/farm/log/fnck06;
  364. X            rs6000 /usr/farm/log/fnck07;
  365. X        };
  366. X        column {
  367. X            rs6000 /usr/farm/log/fnck08;
  368. X            rs6000 /usr/farm/log/fnck09;
  369. X            rs6000 /usr/farm/log/fnck10;
  370. X            rs6000 /usr/farm/log/fnck11;
  371. X            blank  _;
  372. X            rs6000 /usr/farm/log/fnck12;
  373. X            rs6000 /usr/farm/log/fnck13;
  374. X            rs6000 /usr/farm/log/fnck14;
  375. X            rs6000 /usr/farm/log/fnck15;
  376. X        };
  377. X        column {
  378. X            rs6000 /usr/farm/log/fnck16;
  379. X            rs6000 /usr/farm/log/fnck17;
  380. X            rs6000 /usr/farm/log/fnck18;
  381. X            rs6000 /usr/farm/log/fnck19;
  382. X            sigma  _;
  383. X            rs6000 /usr/farm/log/fnck20;
  384. X            rs6000 /usr/farm/log/fnck21;
  385. X            rs6000 /usr/farm/log/fnck22;
  386. X            rs6000 /usr/farm/log/fnck23;
  387. X        };
  388. X        column {
  389. X            rs6000 /usr/farm/log/fnck24;
  390. X            rs6000 /usr/farm/log/fnck25;
  391. X            rs6000 /usr/farm/log/fnck26;
  392. X            rs6000 /usr/farm/log/fnck27;
  393. X            rs6000 /usr/farm/log/fnck28;
  394. X            rs6000 /usr/farm/log/fnck29;
  395. X            rs6000 /usr/farm/log/fnck30;
  396. X            rs6000 /usr/farm/log/fnck31;
  397. X            rs6000 /usr/farm/log/fnck32;
  398. X        };
  399. X    };
  400. X    row {
  401. X        column {
  402. X            rs6000 /usr/farm/log/fnck33;
  403. X            rs6000 /usr/farm/log/fnck34;
  404. X            rs6000 /usr/farm/log/fnck35;
  405. X            rs6000 /usr/farm/log/fnck36;
  406. X            sigma    _;
  407. X            rs6000 /usr/farm/log/fnck37;
  408. X            rs6000 /usr/farm/log/fnck38;
  409. X            rs6000 /usr/farm/log/fnck39;
  410. X            rs6000 /usr/farm/log/fnck40;
  411. X        };
  412. X        column {
  413. X            rs6000 /usr/farm/log/fnck41;
  414. X            rs6000 /usr/farm/log/fnck42;
  415. X            rs6000 /usr/farm/log/fnck43;
  416. X            rs6000 /usr/farm/log/fnck44;
  417. X            blank _;
  418. X            rs6000 /usr/farm/log/fnck45;
  419. X            rs6000 /usr/farm/log/fnck46;
  420. X            rs6000 /usr/farm/log/fnck47;
  421. X            rs6000 /usr/farm/log/fnck48;
  422. X        };
  423. X        column {
  424. X            rs6000 /usr/farm/log/fnck49;
  425. X            rs6000 /usr/farm/log/fnck50;
  426. X            rs6000 /usr/farm/log/fnck51;
  427. X            rs6000 /usr/farm/log/fnck52;
  428. X            sigma    _;
  429. X            rs6000 /usr/farm/log/fnck53;
  430. X            rs6000 /usr/farm/log/fnck54;
  431. X            rs6000 /usr/farm/log/fnck55;
  432. X            rs6000 /usr/farm/log/fnck56;
  433. X        };
  434. X        column {
  435. X            rs6000 /usr/farm/log/fnck57;
  436. X            rs6000 /usr/farm/log/fnck58;
  437. X            rs6000 /usr/farm/log/fnck59;
  438. X            rs6000 /usr/farm/log/fnck60;
  439. X            rs6000 /usr/farm/log/fnck61;
  440. X            rs6000 /usr/farm/log/fnck62;
  441. X            rs6000 /usr/farm/log/fnck63;
  442. X            rs6000 /usr/farm/log/fnck64;
  443. X        };
  444. X    };
  445. X};
  446. EOF
  447. echo Extracting main.c
  448. sed -e 's/^X//' > main.c <<EOF
  449. X /* (c) 1993 Marc Mengel and Fermilab, who retain a nonexclusive liscence */
  450. X/*
  451. X** pretty straightforward, initialize the toolkit, call the parser
  452. X** to read in the configuration and build the widgets, and then
  453. X** call the x toolkit event loop.
  454. X*/
  455. X#include <stdio.h>
  456. X#include <X11/Xatom.h>
  457. X#include <X11/Xlib.h>
  458. X#include <X11/Intrinsic.h>
  459. X#include <X11/StringDefs.h>
  460. X#include <X11/Xaw/Mailbox.h>
  461. X#include <X11/Xaw/Form.h>
  462. X#include "patchlevel.h"
  463. Xextern void exit();
  464. Xextern Widget cur;
  465. X
  466. Xchar *ProgramName;
  467. X
  468. Xstatic void Usage ()
  469. X{
  470. X    static char *help_message[] = {
  471. X"where options include:",
  472. X"    -display host:dpy              X server to contact",
  473. X"    -geometry geom                 size of machinelog",
  474. X"    -bg color                      background color",
  475. X"    -fg color                      foreground color",
  476. X"    -n name                        title",
  477. XNULL};
  478. X    char **cpp;
  479. X
  480. X    fprintf (stderr, "%s", version_id);
  481. X    fprintf (stderr, "usage:  %s [options ...] [configfile]\\n", ProgramName);
  482. X    for (cpp = help_message; *cpp; cpp++) {
  483. X    fprintf (stderr, "%s\\n", *cpp);
  484. X    }
  485. X    fprintf (stderr, "\\n");
  486. X    exit (1);
  487. X}
  488. X
  489. XXtTranslations mytranslations;
  490. X
  491. Xextern void Btn1Cmd();
  492. Xextern void Btn2Cmd();
  493. Xextern void Btn3Cmd();
  494. X
  495. Xstatic XtActionsRec actions[] = {
  496. X    {"XlogBtn1Cmd", Btn1Cmd},
  497. X    {"XlogBtn2Cmd", Btn2Cmd},
  498. X    {"XlogBtn3Cmd", Btn3Cmd},
  499. X};
  500. X
  501. XWidget toplevel;
  502. X
  503. Xvoid 
  504. Xmain (argc, argv)
  505. X    int argc;
  506. X    char **argv;
  507. X{
  508. X    Widget  w;
  509. X    int i;
  510. X    extern int yydebug;
  511. X    Arg args[5];
  512. X    char *pcname;
  513. X     
  514. X
  515. X    ProgramName = argv[0];
  516. X
  517. X    toplevel = XtInitialize ("main", "XLog", 0, 0,
  518. X                 &argc, argv);
  519. X    XtAppAddActions( XtWidgetToApplicationContext(toplevel),
  520. X            actions, XtNumber(actions));
  521. X    mytranslations = XtParseTranslationTable(
  522. X    "<MapNotify>:unset()\\n\\
  523. X     <Btn1Down>,<Btn1Up>:XlogBtn1Cmd()unset()\\n\\
  524. X     <Btn2Down>,<Btn2Up>:XlogBtn2Cmd()unset()\\n\\
  525. X     <Btn3Down>,<Btn3Up>:XlogBtn3Cmd()unset()\\n"
  526. X    );
  527. X 
  528. X    if (argc == 2) {
  529. X    freopen(argv[1],"r",stdin);
  530. X    } else if (argc != 1) {
  531. X    Usage ();
  532. X    }
  533. X
  534. X    cur = toplevel;
  535. X
  536. X    yydebug = 1;
  537. X    yyparse();
  538. X    XtRealizeWidget (toplevel);
  539. X
  540. X    XtMainLoop ();
  541. X}
  542. EOF
  543. echo Extracting patchlevel.h
  544. sed -e 's/^X//' > patchlevel.h <<EOF
  545. Xstatic char ident[] =
  546. X"@(#)logwatcher 2.3 mengel@dcdmwm ";
  547. X#define version_id      (ident+4)
  548. EOF
  549. echo Extracting scan.l
  550. sed -e 's/^X//' > scan.l <<EOF
  551. X%{
  552. X /* (c) 1993 Marc Mengel and Fermilab, who retain a nonexclusive liscence */
  553. X#define Widget int
  554. X#include "y.tab.h"
  555. X
  556. Xextern char *strcpy();
  557. Xchar *strsav(s) char *s; { return strcpy(malloc(strlen(s)+1),s); }
  558. X
  559. Xint lines = 1;
  560. X%}
  561. X
  562. X%%
  563. X
  564. Xicon            {                       return ITEM; }
  565. Xrow            {                       return ROW; }
  566. Xcolumn            {                        return COLUMN;}
  567. Xcommand            {                        return COMMAND;}
  568. Xbitmap            {                       return BITMAP; }
  569. X[-a-zA-Z/_][-a-zA-Z0-9/_]* { yylval.pc = strsav(yytext);    return STRING; }
  570. X\\"([^\\\\"]|\\\\.)*\\"    { yylval.pc = strsav(unquote(yytext));    return STRING;}
  571. X[0-9]+            { yylval.i =  (int)strtol(yytext,0,10); return INT; }
  572. X0x[0-9a-f][0-9a-f]    { yylval.i =  (int)strtol(yytext,0,16); return INT; }
  573. X[(){},;]        { return yytext[0];}
  574. X"/*"([^*]*"*")*"/"    { ; }
  575. X"#".*            { ; }
  576. X\\n            { lines++; }
  577. X.            { ; }
  578. EOF
  579. echo Extracting util.c
  580. sed -e 's/^X//' > util.c <<EOF
  581. X /* (c) 1993 Marc Mengel and Fermilab, who retain a nonexclusive liscence */
  582. X#include <X11/Xatom.h>
  583. X#include <X11/Xlib.h>
  584. X#include <X11/Intrinsic.h>
  585. X#include <X11/StringDefs.h>
  586. X#include <X11/Xaw/Form.h>
  587. X#include <X11/Xaw/Label.h>
  588. X#include <X11/Xaw/Mailbox.h>
  589. X
  590. X/*
  591. X** first a wimpy hash table symbol table to keep icon types
  592. X*/
  593. Xtypedef struct item { 
  594. X    char     *item,         /* name of icon type */
  595. X        **ppcCmds; 
  596. X    int    bitmap;     /* bitmap data for icon */
  597. X    int     width, height;  /* bitmap dimensions */
  598. X    struct item *next;     /* next item in this hash bucket */
  599. X} ITEM;
  600. X
  601. XITEM *hash[256];        /* hash table of item lists */
  602. X
  603. X/*
  604. X** wimpy hash function, xor sum...
  605. X*/
  606. Xint hashit(pc)
  607. X    unsigned char *pc;
  608. X{
  609. X    int sum = 0;
  610. X
  611. X    while (pc && *pc) {
  612. X        sum ^= *(pc++);
  613. X    }
  614. X    return sum;
  615. X}
  616. X
  617. X/*
  618. X** routine to add an item to the symbol table 
  619. X*/
  620. Xstore( item, bitmap, width, height, ppcCmds )
  621. X    char *item, **ppcCmds;
  622. X    int bitmap;
  623. X    int width, height;
  624. X{
  625. X    ITEM *p;
  626. X    int n, res;
  627. X    int d;
  628. X    extern Widget toplevel;
  629. X
  630. X    n = hashit(item);
  631. X    p = malloc(sizeof(ITEM));
  632. X    p->item = item;
  633. X    res = XReadBitmapFile(XtDisplay(toplevel),
  634. X                DefaultRootWindow(XtDisplay(toplevel)),
  635. X                bitmap,&p->width,&p->height,&p->bitmap,&d,&d);
  636. X    if (res != BitmapSuccess )
  637. X        yyerror(bitmap);
  638. X    p->ppcCmds = ppcCmds;
  639. X    p->next = hash[n];
  640. X    hash[n] = p;
  641. X}
  642. X
  643. X/*
  644. X** make an item instance, with an overriding command name (optional).
  645. X** prev and direction are the arguments for stacking inside of a
  646. X** form widget (i.e. XtNvert and the widget above it... )
  647. X*/
  648. XWidget
  649. Xmakeitem( item, name, ppcCmds, prev, direction )
  650. X    char *item, *name, **ppcCmds;
  651. X    char *direction;
  652. X{
  653. X    int n;
  654. X    ITEM *p;
  655. X    Widget w, icn;
  656. X    extern Widget cur;
  657. X    extern XtTranslations mytranslations;
  658. X    char *pcname;
  659. X 
  660. X    Arg args[20];
  661. X    int i, x,y,width,height;
  662. X
  663. X    for (p = hash[hashit(item)]; 0 != p && 0 != strcmp(p->item, item); p = p->next)
  664. X        ;
  665. X    if ( 0 == p ) {
  666. X        yyerror("nonexistant item");
  667. X    } else {
  668. X        i = 0;
  669. X        if ( 0 != prev ) {
  670. X            XtSetArg(args[i], direction, prev); i++;
  671. X        }
  672. X        XtSetArg(args[i], XtNborderWidth, 0); i++;
  673. X        XtSetArg(args[i], XtNhorizDistance, 0); i++;
  674. X        XtSetArg(args[i], XtNvertDistance, 0); i++;
  675. X        w=XtCreateManagedWidget("form",formWidgetClass,cur,args,i);
  676. X        i = 0;
  677. X        XtSetArg(args[i], XtNfullPixmap, p->bitmap ); i++;
  678. X        XtSetArg(args[i], XtNemptyPixmap, p->bitmap ); i++;
  679. X        XtSetArg(args[i], XtNwidth, p->width ); i++;
  680. X        XtSetArg(args[i], XtNheight, p->height ); i++;
  681. X        XtSetArg(args[i], XtNfile, name); i++;
  682. X        if ( ppcCmds == NULL ) {
  683. X            ppcCmds = p->ppcCmds;
  684. X        }
  685. X        XtSetArg(args[i], XtNdestroyCallback, ppcCmds); i++;
  686. X        XtSetArg(args[i], XtNborderWidth, 0); i++;
  687. X        XtSetArg(args[i], XtNhorizDistance, 0); i++;
  688. X        XtSetArg(args[i], XtNvertDistance, 0); i++;
  689. X        icn = XtCreateManagedWidget("icon",mailboxWidgetClass,w,args,i);
  690. X        XtOverrideTranslations(icn,mytranslations);
  691. X        if ( 0 != name ) {
  692. X            i = 0;
  693. X            XtSetArg(args[i], XtNlabel, lastpart(name) );i++;
  694. X            XtSetArg(args[i], XtNborderWidth, 0); i++;
  695. X            XtSetArg(args[i], XtNfromVert, icn); i++;
  696. X            XtSetArg(args[i], XtNborderWidth, 0); i++;
  697. X            XtSetArg(args[i], XtNhorizDistance, 0); i++;
  698. X            XtSetArg(args[i], XtNvertDistance, 0); i++;
  699. X            (void)XtCreateManagedWidget("label",labelWidgetClass,w,
  700. X                                args,i);
  701. X        }
  702. X    }
  703. X    return w;
  704. X}
  705. X
  706. X/*
  707. X** makes a new form to hold a column or row of other widgets; called
  708. X** by the parser when we start a row { ... } or column { ... } construction.
  709. X** 
  710. X** prev and direction are for stacking us in our parent's widget.
  711. X*/
  712. Xnewform(prev, direction)
  713. X    char *direction;
  714. X    Widget prev;
  715. X{
  716. X    Widget w;
  717. X    extern Widget cur;
  718. X    Arg args[20];
  719. X    int i,x,y,width,height;
  720. X    
  721. X    
  722. X    i = 0;
  723. X    if ( 0 != prev ) {
  724. X        XtSetArg(args[i], direction, prev); i++;
  725. X    }
  726. X        XtSetArg(args[i], XtNborderWidth, 1); i++;
  727. X        XtSetArg(args[i], XtNhorizDistance, 0); i++;
  728. X        XtSetArg(args[i], XtNvertDistance, 0); i++;
  729. X    w=XtCreateManagedWidget("form",formWidgetClass,cur,args,i);
  730. X    return w;
  731. X}
  732. X
  733. X/*
  734. X** stub routine for debugging, etc. called at the end of a column{...}
  735. X** or row{...} construction in the parser
  736. X*/
  737. Xdone(w)
  738. X    Widget w;
  739. X{
  740. X}
  741. X
  742. X/*
  743. X** now a simple widget stack for keeping track of row and column widgets
  744. X** so we can build a form within a form and then put more stuff next
  745. X** to it.  Called from the parser 'cause its more understandable than
  746. X** sticking stuff in \$1
  747. X*/
  748. XWidget stack[1024];
  749. Xint tos = 0;
  750. Xpush(w)
  751. X    Widget w;
  752. X{
  753. X    stack[tos++] = w;
  754. X}
  755. X
  756. XWidget pop()
  757. X{
  758. X    return stack[--tos];
  759. X}
  760. X
  761. X/*
  762. X** routine to convert C-style strings from the scanner, so backslashes
  763. X** etc happen like the C scanner does them.   The conversion is almos
  764. X** certainly incomplete.
  765. X*/
  766. Xunquote(s)
  767. X    char *s;
  768. X{
  769. X    int i, shift = 1;
  770. X
  771. X    for( i = 0; s[i+shift] != '"'; i++ ){
  772. X        if (s[i+shift] == '\\\\') {
  773. X            shift++;
  774. X            switch (s[i+shift]) {
  775. X            case 'n':  s[i+shift] = '\\n'; break;
  776. X            case 't':  s[i+shift] = '\\t'; break;
  777. X            case 'b':  s[i+shift] = '\\b'; break;
  778. X            case 'r':  s[i+shift] = '\\r'; break;
  779. X            case '"':  s[i+shift] = '\\"'; break;
  780. X            }
  781. X        }
  782. X        s[i] = s[i+shift];
  783. X    }
  784. X    s[i] = 0;
  785. X    return s;
  786. X}
  787. X/*
  788. X** find last component in a filename string so we get shorter labels
  789. X*/
  790. X
  791. Xlastpart(s)
  792. X    char *s;
  793. X{
  794. X    char *s2;
  795. X
  796. X    if( s2 = rindex(s,'/')) {
  797. X        return s2+1;
  798. X    } else {
  799. X        return s;
  800. X    }
  801. X}
  802. X
  803. XBtn1Cmd(w) { DoCommand(w,0);}
  804. XBtn2Cmd(w) { DoCommand(w,1);}
  805. XBtn3Cmd(w) { DoCommand(w,2);}
  806. X
  807. XDoCommand(w, n)
  808. X    Widget w;
  809. X    int n;
  810. X{
  811. X    char **ppcCmds, *pcFile;
  812. X    Arg args[20];
  813. X    char buf[256];
  814. X    int i;
  815. X
  816. X    i = 0;
  817. X    XtSetArg(args[i], XtNdestroyCallback, &ppcCmds); i++;
  818. X    XtSetArg(args[i], XtNfile, &pcFile); i++;
  819. X    XtGetValues(w, args, i);
  820. X    if (0 == strcmp(ppcCmds[n] ,"exit"))
  821. X        exit(0);
  822. X    sprintf(buf, ppcCmds[n], pcFile );
  823. X    system(buf);
  824. X}
  825. EOF
  826. echo Extracting xbiff.cf
  827. sed -e 's/^X//' > xbiff.cf <<EOF
  828. Xicon mailbox command "xterm -e Mail -f %s" 
  829. X        bitmap /usr/include/X11/bitmaps/flagdown;
  830. Xicon quit    command exit
  831. X        bitmap /usr/include/X11/bitmaps/target;
  832. X   row {
  833. X    quit    "quit";
  834. X    mailbox "/usr/mail/mengel";
  835. X    mailbox "/usr/mail/root";
  836. X   };
  837. EOF
  838.  
  839. exit 0 # Just in case...
  840. -- 
  841.   // chris@IMD.Sterling.COM            | Send comp.sources.x submissions to:
  842. \X/  Amiga - The only way to fly!      |
  843.  "It's intuitively obvious to the most |    sources-x@imd.sterling.com
  844.   casual observer..."                  |
  845.