开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
dbug_ana.c
资源名称：myodbc-2_50_17a-src.zip　[点击查看]
上传用户：jmzj888
上传日期：2007-01-02
资源大小：220k
文件大小：19k
源码类别：

MySQL数据库

开发平台：

Visual C++

dbug_ana.c：源码内容
  1. /*
  2.  * Analyze the profile file (cmon.out) written out by the dbug
  3.  * routines with profiling enabled.
  4.  *
  5.  * Copyright June 1987, Binayak Banerjee
  6.  * All rights reserved.
  7.  *
  8.  * This program may be freely distributed under the same terms and
  9.  * conditions as Fred Fish's Dbug package.
  10.  *
  11.  * Compile with -- cc -O -s -o %s analyze.c
  12.  *
  13.  * Analyze will read an trace file created by the dbug package
  14.  * (when run with traceing enabled).  It will then produce a
  15.  * summary on standard output listing the name of each traced
  16.  * function, the number of times it was called, the percentage
  17.  * of total calls, the time spent executing the function, the
  18.  * proportion of the total time and the 'importance'.  The last
  19.  * is a metric which is obtained by multiplying the proportions
  20.  * of calls and the proportions of time for each function.  The
  21.  * greater the importance, the more likely it is that a speedup
  22.  * could be obtained by reducing the time taken by that function.
  23.  *
  24.  * Note that the timing values that you obtain are only rough
  25.  * measures.  The overhead of the dbug package is included
  26.  * within.  However, there is no need to link in special profiled
  27.  * libraries and the like.
  28.  *
  29.  * CHANGES:
  30.  *
  31.  * 2-Mar-89: fnf
  32.  * Changes to support tracking of stack usage.  This required
  33.  * reordering the fields in the profile log file to make
  34.  * parsing of different record types easier.  Corresponding
  35.  * changes made in dbug runtime library.  Also used this
  36.  * opportunity to reformat the code more to my liking (my
  37.  * apologies to Binayak Banerjee for "uglifying" his code).
  38.  *
  39.  * 24-Jul-87: fnf
  40.  * Because I tend to use functions names like
  41.  * "ExternalFunctionDoingSomething", I've rearranged the
  42.  * printout to put the function name last in each line, so
  43.  * long names don't screw up the formatting unless they are
  44.  * *very* long and wrap around the screen width...
  45.  *
  46.  * 24-Jul-87: fnf
  47.  * Modified to put out table very similar to Unix profiler
  48.  * by default, but also puts out original verbose table
  49.  * if invoked with -v flag.
  50.  */
  52. #include <global.h>
  54. static char *my_name;
  55. static int verbose;
  57. /*
  58.  * Structure of the stack.
  59.  */
  61. #define PRO_FILE "dbugmon.out" /* Default output file name */
  62. #define STACKSIZ 100 /* Maximum function nesting */
  63. #define MAXPROCS 10000 /* Maximum number of function calls */
  65. # ifdef BSD
  66. # include <sysexits.h>
  67. # else
  68. # define EX_SOFTWARE 1
  69. # define EX_DATAERR 1
  70. # define EX_USAGE 1
  71. # define EX_OSERR 1
  72. # define EX_IOERR 1
  73. # define EX_OK 0
  74. # endif
  76. #define __MERF_OO_ "%s: Malloc Failed in %s: %dn"
  78. #define MALLOC(Ptr,Num,Typ) do /* Malloc w/error checking & exit */ 
  79. if (!(Ptr = (Typ *)malloc((Num)*(sizeof(Typ))))) 
  80. {fprintf(stderr,__MERF_OO_,my_name,__FILE__,__LINE__);
  81. exit(EX_OSERR);} while(0)
  83. #define Malloc(Ptr,Num,Typ) do /* Weaker version of above */
  84. if (!(Ptr = (Typ *)malloc((Num)*(sizeof(Typ))))) 
  85. fprintf(stderr,__MERF_OO_,my_name,__FILE__,__LINE__);
  86.  while(0)
  88. #define FILEOPEN(Fp,Fn,Mod) do /* File open with error exit */ 
  89. if (!(Fp = fopen(Fn,Mod)))
  90. {fprintf(stderr,"%s: Couldn't open %sn",my_name,Fn);
  91. exit(EX_IOERR);} while(0)
  93. #define Fileopen(Fp,Fn,Mod) do /* Weaker version of above */ 
  94. if(!(Fp = fopen(Fn,Mod))) 
  95. fprintf(stderr,"%s: Couldn't open %sn",my_name,Fn);
  96. while(0)
  99. struct stack_t {
  100.     unsigned int pos; /* which function? */
  101.     unsigned long time; /* Time that this was entered */
  102.     unsigned long children; /* Time spent in called funcs */
  103. };
  105. static struct stack_t fn_stack[STACKSIZ+1];
  107. static unsigned int stacktop = 0; /* Lowest stack position is a dummy */
  109. static unsigned long tot_time = 0;
  110. static unsigned long tot_calls = 0;
  111. static unsigned long highstack = 0;
  112. static unsigned long lowstack = (ulong) ~0;
  114. /*
  115.  * top() returns a pointer to the top item on the stack.
  116.  * (was a function, now a macro)
  117.  */
  119. #define top() &fn_stack[stacktop]
  121. /*
  122.  * Push - Push the given record on the stack.
  123.  */
  125. void push (name_pos, time_entered)
  126. register unsigned int name_pos;
  127. register unsigned long time_entered;
  128. {
  129.     register struct stack_t *t;
  131.     DBUG_ENTER("push");
  132.     if (++stacktop > STACKSIZ) {
  133. fprintf (DBUG_FILE,"%s: stack overflow (%s:%d)n",
  134. my_name, __FILE__, __LINE__);
  135. exit (EX_SOFTWARE);
  136.     }
  137.     DBUG_PRINT ("push", ("%d %ld",name_pos,time_entered));
  138.     t = &fn_stack[stacktop];
  139.     t -> pos = name_pos;
  140.     t -> time = time_entered;
  141.     t -> children = 0;
  142.     DBUG_VOID_RETURN;
  143. }
  145. /*
  146.  * Pop - pop the top item off the stack, assigning the field values
  147.  * to the arguments. Returns 0 on stack underflow, or on popping first
  148.  * item off stack.
  149.  */
  151. unsigned int pop (name_pos, time_entered, child_time)
  152. register unsigned int *name_pos;
  153. register unsigned long *time_entered;
  154. register unsigned long *child_time;
  155. {
  156.     register struct stack_t *temp;
  157.     register unsigned int rtnval;
  159.     DBUG_ENTER ("pop");
  161.     if (stacktop < 1) {
  162. rtnval = 0;
  163.     } else {
  164. temp =  &fn_stack[stacktop];
  165. *name_pos = temp->pos;
  166. *time_entered = temp->time;
  167. *child_time = temp->children;
  168. DBUG_PRINT ("pop", ("%d %d %d",*name_pos,*time_entered,*child_time));
  169. rtnval = stacktop--;
  170.     }
  171.     DBUG_RETURN (rtnval);
  172. }
  174. /*
  175.  * We keep the function info in another array (serves as a simple
  176.  * symbol table)
  177.  */
  179. struct module_t {
  180.     char *name;
  181.     unsigned long m_time;
  182.     unsigned long m_calls;
  183.     unsigned long m_stkuse;
  184. };
  186. static struct module_t modules[MAXPROCS];
  188. /*
  189.  * We keep a binary search tree in order to look up function names
  190.  * quickly (and sort them at the end.
  191.  */
  193. struct bnode {
  194.     unsigned int lchild; /* Index of left subtree */
  195.     unsigned int rchild; /* Index of right subtree */
  196.     unsigned int pos; /* Index of module_name entry */
  197. };
  199. static struct bnode s_table[MAXPROCS];
  201. static unsigned int n_items = 0; /* No. of items in the array so far */
  203. /*
  204.  * Need a function to allocate space for a string and squirrel it away.
  205.  */
  207. char *strsave (s)
  208. char *s;
  209. {
  210.     register char *retval;
  211.     register unsigned int len;
  213.     DBUG_ENTER ("strsave");
  214.     DBUG_PRINT ("strsave", ("%s",s));
  215.     if (!s || (len = strlen (s)) == 0) {
  216. DBUG_RETURN (0);
  217.     }
  218.     MALLOC (retval, ++len, char);
  219.     strcpy (retval, s);
  220.     DBUG_RETURN (retval);
  221. }
  223. /*
  224.  * add() - adds m_name to the table (if not already there), and returns
  225.  * the index of its location in the table.  Checks s_table (which is a
  226.  * binary search tree) to see whether or not it should be added.
  227.  */
  229. unsigned int add (m_name)
  230. char *m_name;
  231. {
  232.     register unsigned int ind = 0;
  233.     register int cmp;
  235.     DBUG_ENTER ("add");
  236.     if (n_items == 0) { /* First item to be added */
  237. s_table[0].pos = ind;
  238. s_table[0].lchild = s_table[0].rchild = MAXPROCS;
  239. addit:
  240. modules[n_items].name = strsave (m_name);
  241. modules[n_items].m_time = 0;
  242. modules[n_items].m_calls = 0;
  243. modules[n_items].m_stkuse = 0;
  244. DBUG_RETURN (n_items++);
  245.     }
  246.     while (cmp = strcmp (m_name,modules[ind].name)) {
  247. if (cmp < 0) { /* In left subtree */
  248.     if (s_table[ind].lchild == MAXPROCS) {
  249. /* Add as left child */
  250. if (n_items >= MAXPROCS) {
  251.     fprintf (DBUG_FILE,
  252.     "%s: Too many functions being profiledn",
  253.      my_name);
  254.     exit (EX_SOFTWARE);
  255. }
  256. s_table[n_items].pos = s_table[ind].lchild = n_items;
  257. s_table[n_items].lchild = s_table[n_items].rchild = MAXPROCS;
  258. #ifdef notdef
  259. modules[n_items].name = strsave (m_name);
  260. modules[n_items].m_time = modules[n_items].m_calls = 0;
  261. DBUG_RETURN (n_items++);
  262. #else
  263. goto addit;
  264. #endif
  266.     }
  267.     ind = s_table[ind].lchild; /* else traverse l-tree */
  268. } else {
  269.     if (s_table[ind].rchild == MAXPROCS) {
  270. /* Add as right child */
  271. if (n_items >= MAXPROCS) {
  272.     fprintf (DBUG_FILE,
  273.      "%s: Too many functions being profiledn",
  274.      my_name);
  275.     exit (EX_SOFTWARE);
  276. }
  277. s_table[n_items].pos = s_table[ind].rchild = n_items;
  278. s_table[n_items].lchild = s_table[n_items].rchild = MAXPROCS;
  279. #ifdef notdef
  280. modules[n_items].name = strsave (m_name);
  281. modules[n_items].m_time = modules[n_items].m_calls = 0;
  282. DBUG_RETURN (n_items++);
  283. #else
  284. goto addit;
  285. #endif
  287.     }
  288.     ind = s_table[ind].rchild; /* else traverse r-tree */
  289. }
  290.     }
  291.     DBUG_RETURN (ind);
  292. }
  294. /*
  295.  * process() - process the input file, filling in the modules table.
  296.  */
  298. void process (inf)
  299. FILE *inf;
  300. {
  301.   char buf[BUFSIZ];
  302.   char fn_name[64]; /* Max length of fn_name */
  303.   unsigned long fn_time;
  304.   unsigned long fn_sbot;
  305.   unsigned long fn_ssz;
  306.   unsigned long lastuse;
  307.   unsigned int pos;
  308.   unsigned long time;
  309.   unsigned int oldpos;
  310.   unsigned long oldtime;
  311.   unsigned long oldchild;
  312.   struct stack_t *t;
  314.   DBUG_ENTER ("process");
  315.   while (fgets (buf,BUFSIZ,inf) != NULL) {
  316.     switch (buf[0]) {
  317.     case 'E':
  318.       sscanf (buf+2, "%ld %64s", &fn_time, fn_name);
  319.       DBUG_PRINT ("erec", ("%ld %s", fn_time, fn_name));
  320.       pos = add (fn_name);
  321.       push (pos, fn_time);
  322.       break;
  323.     case 'X':
  324.       sscanf (buf+2, "%ld %64s", &fn_time, fn_name);
  325.       DBUG_PRINT ("xrec", ("%ld %s", fn_time, fn_name));
  326.       pos = add (fn_name);
  327.       /*
  328.        * An exited function implies that all stacked
  329.        * functions are also exited, until the matching
  330.        * function is found on the stack.
  331.        */
  332.       while (pop (&oldpos, &oldtime, &oldchild)) {
  333. DBUG_PRINT ("popped", ("%d %d", oldtime, oldchild));
  334. time = fn_time - oldtime;
  335. t = top ();
  336. t -> children += time;
  337. DBUG_PRINT ("update", ("%s", modules[t -> pos].name));
  338. DBUG_PRINT ("update", ("%d", t -> children));
  339. time -= oldchild;
  340. modules[oldpos].m_time += time;
  341. modules[oldpos].m_calls++;
  342. tot_time += time;
  343. tot_calls++;
  344. if (pos == oldpos) {
  345.   goto next_line; /* Should be a break2 */
  346. }
  347.       }
  348.       /*
  349.        * Assume that item seen started at time 0.
  350.        * (True for function main).  But initialize
  351.        * it so that it works the next time too.
  352.        */
  353.       t = top ();
  354.       time = fn_time - t -> time - t -> children;
  355.       t -> time = fn_time; t -> children = 0;
  356.       modules[pos].m_time += time;
  357.       modules[pos].m_calls++;
  358.       tot_time += time;
  359.       tot_calls++;
  360.       break;
  361.     case 'S':
  362.       sscanf (buf+2, "%lx %lx %64s", &fn_sbot, &fn_ssz, fn_name);
  363.       DBUG_PRINT ("srec", ("%lx %lx %s", fn_sbot, fn_ssz, fn_name));
  364.       pos = add (fn_name);
  365.       lastuse = modules[pos].m_stkuse;
  366. #if 0
  367.       /*
  368.        *  Needs further thought.  Stack use is determined by
  369.        *  difference in stack between two functions with DBUG_ENTER
  370.        *  macros.  If A calls B calls C, where A and C have the
  371.        *  macros, and B doesn't, then B's stack use will be lumped
  372.        *  in with either A's or C's.  If somewhere else A calls
  373.        *  C directly, the stack use will seem to change.  Just
  374.        *  take the biggest for now...
  375.        */
  376.       if (lastuse > 0 && lastuse != fn_ssz) {
  377. fprintf (stderr,
  378.  "warning - %s stack use changed (%lx to %lx)n",
  379.  fn_name, lastuse, fn_ssz);
  380.       }
  381. #endif
  382.       if (fn_ssz > lastuse) {
  383. modules[pos].m_stkuse = fn_ssz;
  384.       }
  385.       if (fn_sbot > highstack) {
  386. highstack = fn_sbot;
  387.       } else if (fn_sbot < lowstack) {
  388. lowstack = fn_sbot;
  389.       }
  390.       break;
  391.     default:
  392.       fprintf (stderr, "unknown record type '%s'n", buf[0]);
  393.       break;
  394.     }
  395.   next_line:;
  396.   }
  398.   /*
  399.    * Now, we've hit eof.  If we still have stuff stacked, then we
  400.    * assume that the user called exit, so give everything the exited
  401.    * time of fn_time.
  402.    */
  403.   while (pop (&oldpos,&oldtime,&oldchild)) {
  404.     time = fn_time - oldtime;
  405.     t = top ();
  406.     t -> children += time;
  407.     time -= oldchild;
  408.     modules[oldpos].m_time += time;
  409.     modules[oldpos].m_calls++;
  410.     tot_time += time;
  411.     tot_calls++;
  412.   }
  413.   DBUG_VOID_RETURN;
  414. }
  416. /*
  417.  * out_header () -- print out the header of the report.
  418.  */
  420. void out_header (outf)
  421. FILE *outf;
  422. {
  423.     DBUG_ENTER ("out_header");
  424.     if (verbose) {
  425. fprintf (outf, "Profile of Executionn");
  426. fprintf (outf, "Execution times are in millisecondsnn");
  427. fprintf (outf, "    Callsttt    Timen");
  428. fprintf (outf, "    -----ttt    ----n");
  429. fprintf (outf, "TimestPercentagetTime SpenttPercentagen");
  430. fprintf (outf, "Calledtof totaltin Functiontof total    ImportancetFunctionn");
  431. fprintf (outf, "======t==========t===========t==========  ==========t========tn");
  432.     } else {
  433. fprintf (outf, "%ld bytes of stack used, from %lx down to %lxnn",
  434.  highstack - lowstack, highstack, lowstack);
  435. fprintf (outf,
  436.  "   %%time     sec   #call ms/call  %%calls  weight   stack  namen");
  437.     }
  438.     DBUG_VOID_RETURN;
  439. }
  441. /*
  442.  * out_trailer () - writes out the summary line of the report.
  443.  */
  445. void out_trailer (outf,sum_calls,sum_time)
  446. FILE *outf;
  447. unsigned long int sum_calls, sum_time;
  448. {
  449.     DBUG_ENTER ("out_trailer");
  450.     if (verbose) {
  451. fprintf (outf, "======t==========t===========t==========t========n");
  452. fprintf (outf, "%6dt%10.2ft%11dt%10.2ftt%-15sn",
  453. sum_calls, 100.0, sum_time, 100.0, "Totals");
  454.     }
  455.     DBUG_VOID_RETURN;
  456. }
  458. /*
  459.  * out_item () - prints out the output line for a single entry,
  460.  * and sets the calls and time fields appropriately.
  461.  */
  463. void out_item (outf, m,called,timed)
  464. FILE *outf;
  465. register struct module_t *m;
  466. unsigned long int *called, *timed;
  467. {
  468.     char *name = m -> name;
  469.     register unsigned int calls = m -> m_calls;
  470.     register unsigned long time = m -> m_time;
  471.     register unsigned long stkuse = m -> m_stkuse;
  472.     unsigned int import;
  473.     double per_time = 0.0;
  474.     double per_calls = 0.0;
  475.     double ms_per_call, ftime;
  477.     DBUG_ENTER ("out_item");
  479.     if (tot_time > 0) {
  480. per_time = (double) (time * 100) / (double) tot_time;
  481.     }
  482.     if (tot_calls > 0) {
  483. per_calls = (double) (calls * 100) / (double) tot_calls;
  484.     }
  485.     import = (unsigned int) (per_time * per_calls);
  487.     if (verbose) {
  488. fprintf (outf, "%6dt%10.2ft%11dt%10.2f  %10dt%-15sn",
  489. calls, per_calls, time, per_time, import, name);
  490.     } else {
  491. ms_per_call = time;
  492. ms_per_call /= calls;
  493. ftime = time;
  494. ftime /= 1000;
  495. fprintf (outf, "%8.2f%8.3f%8u%8.3f%8.2f%8u%8u  %-sn",
  496. per_time, ftime, calls, ms_per_call, per_calls, import,
  497.  stkuse, name);
  498.     }
  499.     *called = calls;
  500.     *timed = time;
  501.     DBUG_VOID_RETURN;
  502. }
  504. /*
  505.  * out_body (outf, root,s_calls,s_time) -- Performs an inorder traversal
  506.  * on the binary search tree (root).  Calls out_item to actually print
  507.  * the item out.
  508.  */
  510. void out_body (outf, root,s_calls,s_time)
  511. FILE *outf;
  512. register unsigned int root;
  513. register unsigned long int *s_calls, *s_time;
  514. {
  515.     unsigned long int calls, time;
  517.     DBUG_ENTER ("out_body");
  518.     DBUG_PRINT ("out_body", ("%d,%d",*s_calls,*s_time));
  519.     if (root == MAXPROCS) {
  520. DBUG_PRINT ("out_body", ("%d,%d",*s_calls,*s_time));
  521.     } else {
  522. while (root != MAXPROCS) {
  523.     out_body (outf, s_table[root].lchild,s_calls,s_time);
  524.     out_item (outf, &modules[s_table[root].pos],&calls,&time);
  525.     DBUG_PRINT ("out_body", ("-- %d -- %d --", calls, time));
  526.     *s_calls += calls;
  527.     *s_time += time;
  528.     root = s_table[root].rchild;
  529. }
  530. DBUG_PRINT ("out_body", ("%d,%d", *s_calls, *s_time));
  531.     }
  532.     DBUG_VOID_RETURN;
  533. }
  535. /*
  536.  * output () - print out a nice sorted output report on outf.
  537.  */
  539. void output (outf)
  540. FILE *outf;
  541. {
  542.     unsigned long int sum_calls = 0;
  543.     unsigned long int sum_time = 0;
  545.     DBUG_ENTER ("output");
  546.     if (n_items == 0) {
  547. fprintf (outf, "%s: No functions to tracen", my_name);
  548. exit (EX_DATAERR);
  549.     }
  550.     out_header (outf);
  551.     out_body (outf, 0,&sum_calls,&sum_time);
  552.     out_trailer (outf, sum_calls,sum_time);
  553.     DBUG_VOID_RETURN;
  554. }
  557. #define usage() fprintf (DBUG_FILE,"Usage: %s [-v] [prof-file]n",my_name)
  559. extern int optind, getopt _A((int argc, char **argv, char *opts));
  560. extern char *optarg;
  562. int main (argc, argv, environ)
  563. int argc;
  564. char *argv[], *environ[];
  565. {
  566.     register int c;
  567.     int badflg = 0;
  568.     FILE *infile;
  569.     FILE *outfile = {stdout};
  571.     DBUG_ENTER ("main");
  572.     DBUG_PROCESS (argv[0]);
  573.     my_name = argv[0];
  574.     while ((c = getopt (argc,argv,"#:v")) != EOF) {
  575. switch (c) {
  576.     case '#': /* Debugging Macro enable */
  577. DBUG_PUSH (optarg);
  578. break;
  579.     case 'v': /* Verbose mode */
  580. verbose++;
  581. break;
  582.     default:
  583. badflg++;
  584. break;
  585. }
  586.     }
  587.     if (badflg) {
  588. usage ();
  589. DBUG_RETURN (EX_USAGE);
  590.     }
  591.     if (optind < argc) {
  592. FILEOPEN (infile, argv[optind], "r");
  593.     } else {
  594. FILEOPEN (infile, PRO_FILE, "r");
  595.     }
  596.     process (infile);
  597.     output (outfile);
  598.     DBUG_RETURN (EX_OK);
  599. }
  601. #if !unix && !xenix /* If not unix, getopt() is probably not available */
  603. /*
  604.  * From std-unix@ut-sally.UUCP (Moderator, John Quarterman) Sun Nov  3 14:34:15 1985
  605.  * Relay-Version: version B 2.10.3 4.3bsd-beta 6/6/85; site gatech.CSNET
  606.  * Posting-Version: version B 2.10.2 9/18/84; site ut-sally.UUCP
  607.  * Path: gatech!akgua!mhuxv!mhuxt!mhuxr!ulysses!allegra!mit-eddie!genrad!panda!talcott!harvard!seismo!ut-sally!std-unix
  608.  * From: std-unix@ut-sally.UUCP (Moderator, John Quarterman)
  609.  * Newsgroups: mod.std.unix
  610.  * Subject: public domain AT&T getopt source
  611.  * Message-ID: <3352@ut-sally.UUCP>
  612.  * Date: 3 Nov 85 19:34:15 GMT
  613.  * Date-Received: 4 Nov 85 12:25:09 GMT
  614.  * Organization: IEEE/P1003 Portable Operating System Environment Committee
  615.  * Lines: 91
  616.  * Approved: jsq@ut-sally.UUCP
  617.  *
  618.  * Here's something you've all been waiting for:  the AT&T public domain
  619.  * source for getopt(3).  It is the code which was given out at the 1985
  620.  * UNIFORUM conference in Dallas.  I obtained it by electronic mail
  621.  * directly from AT&T.  The people there assure me that it is indeed
  622.  * in the public domain.
  623.  *
  624.  * There is no manual page.  That is because the one they gave out at
  625.  * UNIFORUM was slightly different from the current System V Release 2
  626.  * manual page.  The difference apparently involved a note about the
  627.  * famous rules 5 and 6, recommending using white space between an option
  628.  * and its first argument, and not grouping options that have arguments.
  629.  * Getopt itself is currently lenient about both of these things White
  630.  * space is allowed, but not mandatory, and the last option in a group can
  631.  * have an argument.  That particular version of the man page evidently
  632.  * has no official existence, and my source at AT&T did not send a copy.
  633.  * The current SVR2 man page reflects the actual behavor of this getopt.
  634.  * However, I am not about to post a copy of anything licensed by AT&T.
  635.  *
  636.  * I will submit this source to Berkeley as a bug fix.
  637.  *
  638.  * I, personally, make no claims or guarantees of any kind about the
  639.  * following source.  I did compile it to get some confidence that
  640.  * it arrived whole, but beyond that you're on your own.
  641.  *
  642.  */
  644. /*LINTLIBRARY*/
  646. int opterr = 1;
  647. int optind = 1;
  648. int optopt;
  649. char *optarg;
  651. static void _ERR(s,c,argv)
  652. char *s;
  653. int c;
  654. char *argv[];
  655. {
  656. char errbuf[3];
  658. if (opterr) {
  659. errbuf[0] = c;
  660. errbuf[1] = 'n';
  661. (void) fprintf(stderr, "%s", argv[0]);
  662. (void) fprintf(stderr, "%s", s);
  663. (void) fprintf(stderr, "%s", errbuf);
  664. }
  665. }
  667. int getopt(argc, argv, opts)
  668. int argc;
  669. char **argv, *opts;
  670. {
  671. static int sp = 1;
  672. register int c;
  673. register char *cp;
  675. if(sp == 1)
  676. if(optind >= argc ||
  677.    argv[optind][0] != '-' || argv[optind][1] == '')
  678. return(EOF);
  679. else if(strcmp(argv[optind], "--") == 0) {
  680. optind++;
  681. return(EOF);
  682. }
  683. optopt = c = argv[optind][sp];
  684. if(c == ':' || (cp=strchr(opts, c)) == NULL) {
  685. _ERR(": illegal option -- ", c, argv);
  686. if(argv[optind][++sp] == '') {
  687. optind++;
  688. sp = 1;
  689. }
  690. return('?');
  691. }
  692. if(*++cp == ':') {
  693. if(argv[optind][sp+1] != '')
  694. optarg = &argv[optind++][sp+1];
  695. else if(++optind >= argc) {
  696. _ERR(": option requires an argument -- ", c, argv);
  697. sp = 1;
  698. return('?');
  699. } else
  700. optarg = argv[optind++];
  701. sp = 1;
  702. } else {
  703. if(argv[optind][++sp] == '') {
  704. sp = 1;
  705. optind++;
  706. }
  707. optarg = NULL;
  708. }
  709. return(c);
  710. }
  712. #endif /* !unix && !xenix */