home *** CD-ROM | disk | FTP | other *** search
/ Vectronix 2 / VECTRONIX2.iso / FILES_01 / ST_GUIDE.LZH / STG-UTIL / MAN2STG / MAN2STG.C next >
C/C++ Source or Header  |  1994-04-27  |  6KB  |  322 lines
  1. #line 1/*ACE 4 0074 */
  2.  
  3. extern long gemdos();
  4.  
  5. #define  Cconws(s)         gemdos(9,s)
  6. #define  Fwrite(h,cnt,buf) gemdos(64,h,cnt,buf)
  7. #define  Fcreate(fn,mode)  gemdos(60,fn,mode)
  8. #define  Fclose(h)         gemdos(62,h)
  9.  
  10. typedef struct {
  11.    char d_reserved[21];    /* reserviert */
  12.    char d_attrib;          /* Datei-Attribut */
  13.    int  d_time;            /* Uhrzeit */
  14.    int  d_date;            /* Datum */
  15.    long d_length;          /* Datei-Länge */
  16.    char d_fname[14];       /* Dateiname */
  17. } DTA;
  18. #define  Fsetdta(dta)               gemdos(26,dta)
  19. #define  Fgetdta()                  (DTA *)gemdos(47)
  20. #define  Fsfirst(filespec,attr)     gemdos(78,filespec,attr)
  21. #define  Fsnext()                   gemdos(79)
  22.  
  23. #define NL "\r\n"
  24. extern char *getenv(), *suffix();
  25. extern void *malloc();
  26.  
  27. typedef struct {
  28.     char dir[14];       // so hei₧t der Ordner
  29.     char desc[26];      // diese Bedeutung haben die Dateien
  30.     char suff[6];       // Suffix, z.B. '(1M)'
  31.     char flags;         // ham wir oder ham wir nicht
  32. } CAT;
  33.  
  34. CAT cat[] = {
  35.     "CAT1M", "Mupfelinterne Kommandos", "(1M)", 0,
  36.     "CAT1", "Benutzerkommandos", "(1)", 0,          // user commands
  37.     "CAT2", "System Funktionen", "(2)", 0,          // system calls
  38.     "CAT3", "Unterfunktionen", "(3)", 0,            // subroutines
  39.     "CAT4", "Geräte(treiber)", "(4)", 0,            // devices
  40.     "CAT5", "Dateiformate", "(5)", 0,               // file formats
  41.     "CAT6", "Spiele", "(6)", 0,                     // games
  42.     "CAT7", "Sonstiges (Misc)", "(7)", 0,           // miscellaneous
  43.     "CAT8", "Systemverwaltung", "(8)", 0,           // system administration
  44.     "CATN", "Neuigkeiten", "(N)", 0                 // news
  45. };
  46. #define CATCNT 10
  47.  
  48. typedef struct _FILES {
  49.     char            file[14];
  50.     char            node[14];
  51.     int             flags;
  52.     struct _FILES   *next;
  53. } FILES;
  54.  
  55. FILES *base;
  56.  
  57. typedef struct _NAMES {
  58.     char            name[14];
  59.     struct _NAMES   *next;
  60. } NAMES;
  61.  
  62. NAMES *names;
  63.  
  64. int handle;
  65. DTA new;
  66.  
  67. fputs(char *str)
  68. {
  69.     Fwrite(handle, (long)strlen(str), str);
  70. }
  71.  
  72.  
  73. /*
  74.  > Datei in die Liste einsortieren
  75.  */
  76. FILES *AddFile(char *file)
  77. {
  78.     register FILES *new = malloc(sizeof(FILES));
  79.     register FILES *p;
  80.  
  81.     if (new==0L) {
  82.         Cconws("MAN2STG: out of memory." NL);
  83.         _exit(1);
  84.     }
  85.     strcpy(new->file, file);
  86.     new->flags = 0;
  87.  
  88.     if (base==0L) {
  89.         base = new;
  90.         new->next = 0L;
  91.     }
  92.     else if (strcmp(base->file, file) > 0) {
  93.         new->next = base;
  94.         base = new;
  95.     }
  96.     else {
  97.         p = base;
  98.         while (p->next) {
  99.             if (strcmp(p->next->file, file) > 0) break;
  100.             p = p->next;
  101.         }
  102.         new->next = p->next;
  103.         p->next = new;
  104.     }
  105.  
  106.     return(new);
  107. }
  108.  
  109.  
  110. /*
  111.  > Mal sehen, ob es den gewünschten Namen bereits gibt
  112.  */
  113. int Nodename(n)
  114. register char *n;
  115. {
  116.     register NAMES *p = names;
  117.     int             rv=0;
  118.  
  119.     while (p) {
  120.         if (strcmp(p->name, n) == 0) {
  121.             rv = 1;
  122.             break;
  123.         }
  124.         p = p->next;
  125.     }
  126.     if (p==0L) {
  127.         p = malloc(sizeof(NAMES));
  128.         strcpy(p->name, n);
  129.         p->next = names;
  130.         names = p;
  131.     }
  132.  
  133.     return(rv);
  134. }
  135.  
  136.  
  137. /*
  138.  > Für alle Dateien eines Kapitels
  139.  > jeweils eine node schreiben
  140.  */
  141. AllFiles(CAT *c)
  142. {
  143.     register FILES  *f = base, *n;
  144.     char            line[255], *t;
  145.  
  146.     while (f) {
  147.         sprintf(line, "@node %s%s@toc %s" NL, f->node, NL, c->dir);
  148.         fputs(line);
  149.  
  150.         /*
  151.          * erste Node in der Liste hat keinen Vorgänger
  152.          */
  153.         if (f==base) {
  154.             sprintf(line, "@prev %s" NL, f->node);
  155.             fputs(line);
  156.         }
  157.  
  158.         /*
  159.          * letzte Node in der Liste hat keinen Nachfolger
  160.          */
  161.         if (f->next == 0) {
  162.             sprintf(line, "@next %s" NL, f->node);
  163.             fputs(line);
  164.         }
  165.  
  166.         /*
  167.          * falls der Nodename der des Kommandos ist, schreiben
  168.          * wir den direkt, ansonsten mu₧ ein link her
  169.          */
  170.         if (f->flags==0) {
  171.             sprintf(line, "@symbol %s%s" NL, f->node, c->suff);
  172.         }
  173.         else {
  174.             t = f->node;
  175.             while (*t++ != '(');
  176.             t[-1] = 0;
  177.             sprintf(line, "@symbol RI %s" NL, f->node);
  178.         }
  179.         fputs(line);
  180.  
  181.         /*
  182.          * jetzt noch die Datei includen und das Nodeende setzen
  183.          */
  184.         sprintf(line, "@include %s/%s%s@endnode" NL NL,
  185.                 c->dir, f->file, NL);
  186.         fputs(line);
  187.         n = f->next;
  188.         free(f);
  189.         f = n;
  190.     }
  191.     base = 0L;
  192. }
  193.  
  194.  
  195. /*
  196.  > Alle Dateien eines Kapitels einlesen
  197.  */
  198. GetFiles(char *path, CAT *c)
  199. {
  200.     int             rv;
  201.     register char   *n;
  202.     FILES           *b;
  203.  
  204.     rv = Fsfirst(path, 63);
  205.     n = new.d_fname;
  206.     while (rv==0) {
  207.         if (n[0] != '.') {                  // '.' und '..' überlesen
  208.             b = AddFile(n);
  209.             *suffix(n) = 0;
  210.             strlwr(n);
  211.             strcpy(b->node, n);
  212.             if (Nodename(n)) {              // gibts den Namen schon?
  213.                 strcat(b->node, c->suff);   // ja: Endung dranhängen
  214.                 b->flags = 1;               // und merken
  215.             }
  216.         }
  217.         rv = Fsnext();
  218.     }
  219. }
  220.  
  221.  
  222. /*
  223.  > Lokales Inhaltsverzeichnis für ein Kapitel schreiben
  224.  */
  225. Toc(CAT *c)
  226. {
  227.     register FILES *f = base;
  228.     int             cnt, l;
  229.     char            line[128];
  230.  
  231.     cnt = 0;
  232.     while (f) {
  233.         if (f->flags==0)
  234.             sprintf(line, "%-8s  ", f->node);
  235.         else {
  236.             l = 9-strlen(f->node);
  237.  
  238.             sprintf(line, "@{%s link %s%s} %*.*s", f->node,
  239.                     f->node, c->suff, l, l, "        ");
  240.         }
  241.         fputs(line);
  242.         if (++cnt >= 7) {
  243.             fputs(NL);
  244.             cnt=0;
  245.         }
  246.         f = f->next;
  247.     }
  248.     if (cnt) fputs(NL);
  249. }
  250.  
  251.  
  252. _main()
  253. {
  254.     char            *p = getenv("MANPATH");
  255.     register char   *n;
  256.     register CAT    *c;
  257.     char            path[128], line[128];
  258.     DTA             *old;
  259.     int             i, rv, cnt;
  260.  
  261.     Cconws("MAN2STG V("__DATE__"): manual hypertext creator" NL
  262.            "        by Holger Weets using SOZOBON-C V2.00x10" NL NL);
  263.  
  264.     if (p==0L) {
  265.         Cconws("MAN2STG: $MANPATH not set." NL);
  266.         _exit(1);
  267.     }
  268.     strcpy(path, p);
  269.     p = path+strlen(path);
  270.     if (p[-1] != '\\') {
  271.         *p++ = '\\';
  272.         *p = 0;
  273.     }
  274.  
  275.     strcpy(p, "MAN.STG");
  276.     if ((handle = Fcreate(path, 0))<5) {
  277.         Cconws("MAN2STG: can't open outfile" NL);
  278.         _exit(1);
  279.     }
  280.     Cconws("writing file ");
  281.     Cconws(path);
  282.     Cconws(NL);
  283.  
  284.     old = Fgetdta();
  285.     Fsetdta(&new);
  286.  
  287.     fputs("@database Manual-Pages" NL
  288.           "@subject Dokumentation/Shells" NL
  289.           "@author \"automatisch erzeugt\"" NL
  290.           "@options -s+zz" NL NL
  291.           "@node Main \"Manual-Pages\"" NL NL);
  292.     c = cat;
  293.     for (i=0; i<CATCNT; i++, c++) {
  294.         strcpy(p, c->dir);
  295.         if (Fsfirst(path, 63)==0) {
  296.             c->flags = 1;
  297.             sprintf(line, " %-8s %s" NL, c->dir, c->desc);
  298.             fputs(line);
  299.         }
  300.     }
  301.     fputs("@endnode" NL NL);
  302.  
  303.     c = cat;
  304.     for (i=0; i<CATCNT; i++, c++) {
  305.         if (c->flags) {
  306.             sprintf(line, "@node %s \"%s\"" NL, c->dir, c->desc);
  307.             fputs(line);
  308.             sprintf(p, "%s\\*.*", c->dir);
  309.             GetFiles(path, c);
  310.             Toc(c);
  311.             fputs("@endnode" NL NL);
  312.             AllFiles(c);
  313.         }
  314.     }
  315.     Fclose(handle);
  316.     Fsetdta(old);
  317.     _exit(0);
  318. }
  319.  
  320.  
  321.  
  322.