home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume3 / sort-.newsrc < prev    next >
Encoding:
C/C++ Source or Header  |  1989-02-03  |  12.7 KB  |  440 lines
  1. Path: xanth!mcnc!gatech!bloom-beacon!husc6!spdcc!ima!necntc!ncoast!allbery
  2. From: paulsc@radio_flyer.gwd.tek.com (Paul Scherf)
  3. Newsgroups: comp.sources.misc
  4. Subject: v03i084: .newsrc shrinking/sorting programs
  5. Keywords: .newsrc, sort, shrink
  6. Message-ID: <10166@tekecs.TEK.COM>
  7. Date: 14 Jul 88 23:36:36 GMT
  8. Sender: allbery@ncoast.UUCP
  9. Reply-To: paulsc@radio_flyer.gwd.tek.com (Paul Scherf)
  10. Organization: Tektronix, Inc., Wilsonville, OR
  11. Lines: 426
  12. Approved: allbery@ncoast.UUCP
  13.  
  14. Posting-number: Volume 3, Issue 84
  15. Submitted-by: "Paul Scherf" <paulsc@radio_flyer.gwd.tek.com>
  16. Archive-name: sort-.newsrc
  17.  
  18. Did I post this correctly?
  19. [Yup.  ++bsa]
  20.  
  21. #!/bin/sh
  22. # run this as a Bourne shell script
  23. # to extract the files archived here
  24. echo x - README
  25. sed -e 's/^!!/!/' > README <<'!Funky!Stuff!'
  26. Once upon a time, I wrote a sed command to mark all the skipped
  27. articles (in unsubscribed to groups), as if I had read them.
  28.  
  29. Another day (about the time all the news group names changed), I
  30. started telling rn just to add new groups at the end of my .newsrc.
  31. The idea was that I would edit my .newsrc later.
  32.  
  33. Yet another day, I realized that I didn't want to edit my 463 line
  34. .newsrc file, to make sure a couple new groups were in the "right"
  35. place.  So I whipped together a program that would "sort" my .newsrc
  36. the way I like it.
  37.  
  38. Today, I wondered if anyone else might be interested in having these
  39. programs for their own use, hacking, lint testing, bird cage lining (-:
  40. or other amusement.
  41.  
  42. You probably have a different set of regional "distributions"
  43. (categories), or you just like them in a different order, so you will
  44. probably want to edit the categories[] table to suit your tastes and
  45. locale.  You probably have different preferences on how to order the
  46. groups, so you probably want to edit the rest of the program.  I'm
  47. posting this program mostly to publish the idea of sorting (or
  48. shrinking) your .newsrc file as a convenience (or a way to waste more
  49. disk space by storing this program, than is saved by using this program
  50. (-: ).
  51.  
  52. Anyone who wants to can copy this program and change it any way they
  53. wish. (How am I going to stop you?)  I don't think anyone would buy a
  54. program as trivial as this, so I don't care, if you try to sell it.  If
  55. you manage to get someone to buy this from you, I would find it
  56. amusing.
  57.  
  58. If you come up with an interesting variation, I am interested in
  59. hearing about it.
  60.  
  61. I have run this only on 4.2BSD-based machines, so there is probably
  62. some machine somewhere out there where it won't run unchanged.  There
  63. may well be machines where it doesn't work right.  I haven't run it
  64. through lint for a long time, so you might get a bunch of complaints
  65. from lint.  This program works fine for me, but your mileage may vary.
  66. Use this program at your own peril.
  67.  
  68. Paul Scherf, Tektronix, Box 1000, MS 61-033, Wilsonville, OR, USA
  69. paulsc@orca.GWD.Tek.COM            tektronix!orca!paulsc
  70. !Funky!Stuff!
  71. echo x - shrink.newsrc
  72. sed -e 's/^!!/!/' > shrink.newsrc <<'!Funky!Stuff!'
  73. #!/bin/sh
  74. # Usage: shrink.newsrc
  75. #
  76. # Shrink out all the commas in unsubscribed to groups.
  77. #    (i.e. mark skipped articles as read)
  78. # Sort the groups into the desired order.
  79. #
  80. # It would have been nice to use a pipe from the sed part to the
  81. # sort.newsrc part, but sh, on the machines I run this on at least, only
  82. # yields the exit status of the last program on the pipeline.  I want to
  83. # make sure every stage of the pipeline succeeds.
  84.  
  85. sed < $HOME/.newsrc 's/^\([^!]*![^,-]*\).*[,-]\(.*\)/\1-\2/' > /tmp/newsrc$$ &&
  86. mv /tmp/newsrc$$ $HOME/.newsrc &&
  87. sort.newsrc < $HOME/.newsrc > /tmp/newsrc$$ &&
  88. mv /tmp/newsrc$$ $HOME/.newsrc
  89. !Funky!Stuff!
  90. echo x - sort.newsrc.c
  91. sed -e 's/^!!/!/' > sort.newsrc.c <<'!Funky!Stuff!'
  92. /* re-order the .newsrc according to my likes */
  93.  
  94. #include <stdio.h>
  95. #include <strings.h>
  96.  
  97. /*
  98.  * misc utility routines
  99.  */
  100.  
  101. /* like malloc, except emalloc() will abort instead of returning NULL */
  102. static char *emalloc(len)
  103. int len;    /* number of bytes to allocate */
  104. {
  105.     char *malloc();
  106.     char *new = malloc(len);
  107.  
  108.     if (!new) {
  109.         fprintf(stderr, "Out of memory\n");
  110.         exit(1);
  111.     }
  112.  
  113.     return new;
  114. }
  115.  
  116. /* return a copy of string str */
  117. static char *stralloc(str)
  118. char *str;    /* string to copy */
  119. {
  120.     return strcat(emalloc(strlen(str) + 1), str);
  121. }
  122.  
  123. /* like strncmp, except the lengths of both strings are supplied */
  124. static int mystrncmp(str1, str1len, str2, str2len)
  125. char *str1;    /* first string */
  126. int str1len;    /* str1 length */
  127. char *str2;    /* second string */
  128. int str2len;    /* str2 length */
  129. {
  130.     if (str1len < str2len) {
  131.         int tmp = strncmp(str1, str2, str1len);
  132.  
  133.         if (tmp == 0)    /* longest prefix is equal */
  134.             return -1;
  135.         return tmp;
  136.  
  137.     } else if (str1len > str2len) {
  138.         int tmp = strncmp(str1, str2, str2len);
  139.  
  140.         if (tmp == 0)    /* longest prefix is equal */
  141.             return 1;
  142.         return tmp;
  143.  
  144.     } /* else str1len == str2len */
  145.  
  146.     return strncmp(str1, str2, str1len);
  147. }
  148.  
  149. /*
  150.  * low level group list routines/data
  151.  */
  152.  
  153. /* return the category index for category at grp and catlen characters long */
  154. /* return -1 if category is not found */
  155. static int catindex(grp, catlen)
  156. char *grp;    /* group name string */
  157. int catlen;    /* category name length */
  158. {
  159.     char **cat;                /* loop index */
  160.     static char *categories[] = {        /* the category names */
  161.         /* edit to taste and locale */
  162.  
  163.         /* most local to all but most global */
  164.         "gwd",
  165.         "tekwv",
  166.         "tek",
  167.         "pdx",
  168.         "uwcsa",
  169.         "or",
  170.         "pnw",
  171.  
  172.         /* among the most global, */
  173.         /* interesting/important to boring/worthless */
  174.         "news",
  175.         "comp",
  176.         "sci",
  177.         "misc",
  178.         "alt",
  179.         "gnu",
  180.         "rec",
  181.         "soc",
  182.         "talk",
  183.         "control",
  184.         "junk",
  185.         "test",
  186.     };
  187. /* number of entries in categories[] */
  188. #define NCATEGORIES    (sizeof categories / sizeof categories[0])
  189.  
  190.     for (cat = categories; cat < &categories[NCATEGORIES]; ++cat) {
  191.         if (catlen == strlen(*cat) && strncmp(grp, *cat, catlen) == 0)
  192.             return cat - categories;
  193.     }
  194.     return -1;
  195. }
  196.  
  197. /* a group list element */
  198. struct group {    /* a doubly-linked list for easy insertion */
  199.     struct    group *next;    /* next struct group in list */
  200.     struct    group *prev;    /* previous struct group in list */
  201.     char    *group;        /* the original input line */
  202.     int    catindex;    /* corresponding index into categories */
  203.     int    categorylen;    /* length of category prefix */
  204.     int    grouplen;    /* length of group prefix */
  205. };
  206.  
  207. struct group *groups = NULL;    /* pointer to the head of the group list */
  208. struct group *end_groups = NULL; /* pointer to the tail of the group list */
  209.  
  210. /* loop to iterate through the groups, indexed by cur */
  211. #define FOREACH_GROUP(cur) for (cur = groups; cur; cur = cur->next)
  212.  
  213. #ifdef    DEBUG    /* for debugging */
  214. /* print the data in a struct group */
  215. static void groupprint(grp)
  216. struct group *grp;        /* pointer to the group to print */
  217. {
  218.     printf("%x next %x prev %x cat %d catlen %d grplen %d %s", grp,
  219.         grp->next, grp->prev, grp->catindex, grp->categorylen,
  220.         grp->grouplen, grp->group);
  221. }
  222.  
  223. /* print all groups */
  224. static void groupallprint()
  225. {
  226.     struct group *grp;    /* loop index */
  227.  
  228.     FOREACH_GROUP(grp) groupprint(grp);
  229. }
  230. #endif    /* DEBUG */
  231.  
  232. /* return a struct group, initialized from line, abort if out of memory */
  233. static struct group *groupalloc(line)
  234. char *line;    /* the .newsrc line to "parse" */
  235. {
  236.     register struct group *new; /* pointer to the "parsed" .newsrc line */
  237.  
  238.     /* allocate/initialize a new group entry */
  239.  
  240.     new = (struct group *)emalloc(sizeof(struct group));
  241.     new->group = stralloc(line);
  242.  
  243.     /* find group length (first [:!\n]) */
  244.     new->grouplen = strcspn(line, ":!\n");
  245.  
  246.     /* find category length (first [.:!\n]) */
  247.     new->categorylen = strcspn(line, ".:!\n");
  248.  
  249.     /* error checking */
  250.     if ((new->catindex = catindex(line, new->categorylen)) < 0) {
  251.         /* If this message comes out, edit the categories[] array */
  252.         fprintf(stderr, "Unknown category: %.*s\n",
  253.             new->categorylen, line);
  254.     }
  255.  
  256.     new->next = NULL;
  257.     new->prev = NULL;
  258.  
  259.     return new;
  260. }
  261.  
  262. /* insert grp just before cur (at tail, if cur == NULL) */
  263. static void groupinsert(grp, cur)
  264. register struct group *grp; /* group to insert */
  265. register struct group *cur; /* group to be just after grp, ow/ NULL */
  266. {
  267.     grp->next = cur;
  268.     if (cur) {            /* insert just before cur */
  269.         grp->prev = cur->prev;
  270.         if (cur->prev)        /* grp is after cur->prev */
  271.             cur->prev->next = grp;
  272.         else            /* grp is now the first group */
  273.             groups = grp;
  274.         cur->prev = grp;
  275.  
  276.     } else {            /* insert at tail */
  277.         grp->prev = end_groups;
  278.         if (end_groups)
  279.             end_groups->next = grp;
  280.         else            /* group list was empty */
  281.             groups = grp;    /* grp is now also the first group */
  282.         end_groups = grp;
  283.     }
  284. }
  285.  
  286. /* return logical: "Is grp a *.tail group (or the group 'tail')?" */
  287. static int grptailcmp(grp, tail)
  288. struct group *grp;    /* the group to test */
  289. char *tail;        /* the tail to test for (e.g. "general", "misc") */
  290. {
  291.     char *tmp = rindex(grp->group, '.');    /* pointer to tail of grp */
  292.     int taillen = strlen(tail);        /* length of tail */
  293.  
  294.     if (tmp)    /* Is grp a *.tail group? */
  295.         return grp->group + grp->grouplen == ++tmp + taillen
  296.             && strncmp(tmp, tail, taillen) == 0;
  297.     else        /* Is grp the group "tail"? */
  298.         return grp->grouplen == taillen
  299.             && strncmp(grp->group, tail, taillen) == 0;
  300. }
  301.  
  302. /* like strcmp(), except for checking ordering of group heads (X.*) */
  303. /* Does not know about categories, or *.general, *.misc, ... */
  304. static int grpheadcmp(grp1, grp2)
  305. struct group *grp1;    /* first group to compare */
  306. struct group *grp2;    /* second group to compare */
  307. {
  308.     char *head1tail;    /* pointer to "tail" of grp1 */
  309.     char *head2tail;    /* pointer to "tail" of grp2 */
  310.  
  311. #ifdef    KNOW_CATEGORIES
  312.     if (grp1->catindex > grp2->catindex) {
  313.         return 1;
  314.     }
  315.     if (grp1->catindex < grp2->catindex) {
  316.         return -1;
  317.     }
  318.     /* hereafter: categories are equal */
  319. #else    /* KNOW_CATEGORIES */
  320.     /* assume categories are equal or don't matter */
  321. #endif    /* KNOW_CATEGORIES */
  322.  
  323.     head1tail = rindex(grp1->group, '.');
  324.     head2tail = rindex(grp2->group, '.');
  325.     if (head1tail == head2tail)    /* grp1 is grp2 */
  326.         return 0;
  327.     if (!head1tail)            /* only grp1 has no head */
  328.         return -1;
  329.     if (!head2tail)            /* only grp2 has no head */
  330.         return 1;
  331.  
  332.     /* finally, the implied comparison */
  333.     return mystrncmp(grp1->group, head1tail - grp1->group,
  334.         grp2->group, head2tail - grp2->group);
  335. }
  336.  
  337. /*
  338.  * high level group routines
  339.  */
  340.  
  341. /* like strcmp(), except it compares "struct group"'s instead of strings */
  342. static int grpcmp(grp1, grp2)
  343. struct group *grp1;    /* first group to compare */
  344. struct group *grp2;    /* second group to compare */
  345. {
  346.     /* optimization */
  347.     /* . the categories are in a specified order */
  348.     if (grp2->catindex > grp1->catindex)
  349.         return -1;    /* grp1 is before grp2 */
  350.     if (grp2->catindex < grp1->catindex)
  351.         return 1;    /* grp1 is after grp2 */
  352.  
  353.     /* hereafter: grp2->catindex == grp1->catindex */
  354.  
  355. #ifdef    PREFIX_GOES_AFTER    /* e.g. comp.sources after comp.sources.bugs */
  356.     /* . X is after all other X.* */
  357.     if (grp1->grouplen < grp2->grouplen) {
  358.         /* if grp1 is a prefix of grp2 ... */
  359.         if (grp2->group[grp1->grouplen] == '.' &&
  360.             strncmp(grp1->group, grp2->group, grp1->grouplen) == 0)
  361.             return 1;
  362.  
  363.     /* . X is after all other X.* */
  364.     } else if (grp1->grouplen > grp2->grouplen) {
  365.         /* if grp2 is a prefix of grp1 ... */
  366.         if (grp1->group[grp2->grouplen] == '.' &&
  367.             strncmp(grp1->group, grp2->group, grp2->grouplen) == 0)
  368.             return -1;
  369.     }
  370. #endif    /* PREFIX_GOES_AFTER */
  371.  
  372.     /* . X.general is before all other X* */
  373.     if (grptailcmp(grp1, "general")) {
  374.         if (grpheadcmp(grp1, grp2) == 0)
  375.             return -1;    /* grp1 <= grp2 */
  376.  
  377.     /* . X.misc is after all other X* */
  378.     } else if (grptailcmp(grp1, "misc")) {
  379.         if (grpheadcmp(grp1, grp2) == 0)
  380.             return 1;    /* grp1 >= grp2 */
  381.     }
  382.  
  383.     /* . X.general is before all other X* */
  384.     if (grptailcmp(grp2, "general")) {
  385.         if (grpheadcmp(grp1, grp2) == 0)
  386.             return 1;    /* grp1 >= grp2 */
  387.  
  388.     /* . X.misc is after all other X* */
  389.     } else if (grptailcmp(grp2, "misc")) {
  390.         if (grpheadcmp(grp1, grp2) == 0)
  391.             return -1;    /* grp1 <= grp2 */
  392.     }
  393.  
  394.     /* . other groups within one category are sorted as if by "sort" */
  395.     return mystrncmp(grp1->group, grp1->grouplen,
  396.         grp2->group, grp2->grouplen);
  397. }
  398.  
  399. /* add line from .newsrc to group list at the proper place */
  400. static void addgroup(line)
  401. char *line;    /* .newsrc line to insert */
  402. {
  403.     struct group *new = groupalloc(line);    /* "parsed" version of line */
  404.     struct group *cur;            /* search loop index */
  405.  
  406.     /* optimization, the list is usually "almost" already sorted */
  407.     if (!end_groups || grpcmp(new, end_groups) > 0) {
  408.         groupinsert(new, (struct group *)NULL);
  409.         return;
  410.     }
  411.  
  412.     /* find insertion point */
  413.     FOREACH_GROUP(cur)
  414.         if (grpcmp(new, cur) < 0) break;
  415.  
  416.     /* insert new just before cur (at tail, if cur == NULL) */
  417.     groupinsert(new, cur);
  418. }
  419.  
  420. /* Read a .newsrc from stdin.  Write a sorted .newsrc to stdout. */
  421. main()
  422. {
  423.     struct group *cur;    /* loop index */
  424.     static char line[512];    /* hopefully more than long enough */
  425.  
  426.     /* read in .newsrc, (bubble) sorting on the fly */
  427.     while (fgets(line, sizeof line, stdin))
  428.         addgroup(line);
  429.  
  430.     /* write .newsrc */
  431.     FOREACH_GROUP(cur) printf("%s", cur->group);
  432.  
  433.     exit(0);
  434. }
  435. !Funky!Stuff!
  436. exit 0
  437.  
  438. Paul Scherf, Tektronix, Box 1000, MS 61-033, Wilsonville, OR, USA
  439. paulsc@orca.GWD.Tek.COM            tektronix!orca!paulsc
  440.