home *** CD-ROM | disk | FTP | other *** search
/ Vectronix 2 / VECTRONIX2.iso / FILES_01 / ST_GUIDE.LZH / STG-UTIL / 1ST_CONV / 1ST_CONV.C next >
C/C++ Source or Header  |  1994-04-27  |  16KB  |  819 lines
  1. #line 1/*ACE 4 0685 */
  2.  
  3. extern void *malloc();
  4. extern char *suffix(), *basename(), *strdup();
  5.  
  6. typedef struct flist {
  7.     char            *file;
  8.     char            *name;
  9.     char            *title;
  10.     int             flags;
  11.     struct flist    *next;
  12. } FLIST;
  13.  
  14. typedef struct {
  15.     unsigned version;
  16.     unsigned headlen;
  17.     unsigned nplanes;
  18.     unsigned patlen;
  19.     unsigned pixelw;
  20.     unsigned pixelh;
  21.     unsigned linew;
  22.     unsigned lines;
  23.     unsigned palette[16];
  24. } IMGHEADER;
  25.  
  26. typedef unsigned char   uchar;
  27. typedef unsigned int    uint;
  28.  
  29. extern long gemdos();
  30. #define  Cconws(s)          gemdos(9,s)
  31. #define  Dsetdrv(d)         gemdos(14,d)
  32. #define  Dsetpath(path)     gemdos(59,path)
  33. #define  Fcreate(fn,mode)   gemdos(60,fn,mode)
  34. #define  Fopen(fn,mode)     gemdos(61,fn,mode)
  35. #define  Fclose(h)          gemdos(62,h)
  36. #define  Fread(h,cnt,buf)   gemdos(63,h,cnt,buf)
  37. #define  Fwrite(h,cnt,buf)  gemdos(64,h,cnt,buf)
  38. #define  Fseek(where,h,how) gemdos(66,where,h,how)
  39. #define NL  "\r\n"
  40.  
  41. FLIST   *FBase = 0L;        // Basis der Dateiliste
  42. int     inhandle;           // Handle der aktuellen Eingabedatei
  43. uchar   inbuf[4096];        // Dateibuffer fuer Eingabe
  44. uchar   *inptr;
  45. long    inlen;
  46. uchar   inpath[128];        // Pfad der Eingabedatei
  47. uchar   mainpath[128];      // Pfad der Hauptdatei
  48. int     outhandle;          // Handle der Ausgabedatei
  49. uchar   outbuf[4096];       // Dateibuffer fuer Ausgabe
  50. uchar   *outptr;
  51. uint    maxlines;
  52. uint    Lineno;
  53. uchar   output[128];        // Name der Ausgabedatei
  54. int     ExtCnt;
  55. int     NeedNL;             // vor Warnung NL ausgeben
  56. int     use_filenames;      // Dateinamen als nodenamen nutzen
  57. int     code;
  58. int     quiet;
  59. int     NoAuto;
  60. char    *CurrFile;
  61.  
  62. /*
  63.  * Fehler melden und terminieren
  64.  */
  65. Message(str1, str2)
  66. char *str1, *str2;
  67. {
  68.     Cconws(str1);
  69.     if (str2) Cconws(str2);
  70.     Cconws(NL);
  71. }
  72.  
  73.  
  74. error(s1, s2)
  75. char *s1, *s2;
  76. {
  77.     Message(s1, s2);
  78.     if (outhandle) Fclose(outhandle);
  79.     if (inhandle) Fclose(inhandle);
  80.     _exit(1);
  81. }
  82.  
  83.  
  84. /*
  85.  * Ausgabedatei oeffnen
  86.  */
  87. Wopen(char *outfile)
  88. {
  89.     if ((outhandle=Fcreate(outfile, 0)) > 5)
  90.         outptr = outbuf;
  91.     else
  92.         error("can't open ", outfile);
  93.     Lineno = 0;
  94. }
  95.  
  96.  
  97. /*
  98.  * Datei zum Lesen oeffnen
  99.  */
  100. Ropen()
  101. {
  102.     register FLIST  *p;
  103.     register char   *suf;
  104.     char            tmp[150];
  105.  
  106. again:
  107.     p = FBase;
  108.     while (p) {
  109.         if (p->flags==0) break;         // ersten suchen, der noch
  110.         p = p->next;                    // nicht gelesen wurde
  111.     }
  112.     if (p == 0L) return(0);             // Ende der Liste erreicht
  113.     p->flags = 1;                       // als gelesen markieren
  114.  
  115.     strcpy(inpath, p->file);            // Pfad der Eingabe merken
  116.     *basename(inpath) = 0;
  117.     if (*inpath == 0)
  118.         strcpy(inpath, mainpath);
  119.  
  120.     if ((inhandle=Fopen(p->file, 0))<5) // Datei oeffnen
  121.         error("can't open ", p->file);
  122.  
  123.     CurrFile = p->file;
  124.     if (quiet==0) {
  125.         Cconws("reading ");
  126.         Cconws(p->file);
  127.         Cconws("\033K\r");
  128.         NeedNL = 1;
  129.     }
  130.  
  131.     if (p == FBase) {                       // erste Datei?
  132.         fputs("@options \"+x -s");
  133.         if (NoAuto) fputs("a");
  134.         fputs("\"" NL NL);
  135.     }
  136.  
  137.     fputs("@node \"");                      // Name der Seite
  138.     strcpy(tmp, p->name);
  139.     ConvKey(tmp);
  140.     fputs(tmp);
  141.     fputs("\"");
  142.     if (p->title) {                         // evtl. Titel
  143.         fputs(" \"");
  144.         strcpy(tmp, p->title);
  145.         ConvKey(tmp);
  146.         fputs(tmp);
  147.         fputs("\"");
  148.     }
  149.     fputs(NL);
  150.  
  151.     inlen = -1;
  152.     inptr = inbuf;                      // Lesezeiger init.
  153.  
  154.     /*
  155.      * wenn es ein Bild ist, das der HCP lesen kann,
  156.      * dann binden wir es ein
  157.      */
  158.     suf = suffix(p->file);
  159.     if (strcmp(suf, ".IMG") == 0) {
  160.         ImagePage(p);
  161.         goto again;
  162.     }
  163.  
  164.     return(1);                          // OK
  165. }
  166.  
  167.  
  168. /*
  169.  > INF-Datei für aktuellen 1stGuide-Text lesen
  170.  */
  171. OpenINF(char *path)
  172. {
  173.     char    line[128];
  174.  
  175.     strcpy(line, path);
  176.     strcpy(suffix(line), ".prj");
  177.     if ((inhandle=Fopen(line, 0)) > 0) {
  178.         inlen = -1;
  179.         inptr = inbuf;                      // Lesezeiger init.
  180.         while (fgets(line)) {
  181.             fputs(line);
  182.             fputs(NL);
  183.         }
  184.         xclose(inhandle);
  185.     }
  186. }
  187.  
  188.  
  189. /*
  190.  * Datei schliessen, dabei evtl. Buffer flushen
  191.  */
  192. xclose(handle)
  193. int handle;
  194. {
  195.     long len;
  196.  
  197.     if (handle == outhandle) {
  198.         len = (long)(outptr-outbuf);
  199.         if (len) {
  200.             if (Fwrite(handle, len, outbuf) != len)
  201.                 error("write error", 0L);
  202.         }
  203.     }
  204.  
  205.     Fclose(handle);
  206. }
  207.  
  208.  
  209. int fgets(line)
  210. register uchar *line;
  211. {
  212.     register uchar  *p = inptr;
  213.     int             rv = 1, cnt=0;
  214.  
  215.     do {
  216.         if (inlen <= 0L) {
  217.             inlen = Fread(inhandle, 4096L, inbuf);
  218.             if (inlen < 0L)                 // Fehler?
  219.                 error("read error", 0L);
  220.  
  221.             if (inlen == 0L) {              // nix gelesen?
  222.                 rv = 0;                     // DateiEnde
  223.                 break;
  224.             }
  225.             inptr = p = inbuf;
  226.         }
  227.         if (*p == 10) {             // NL
  228.             --inlen;
  229.             ++p;
  230.             break;
  231.         }
  232.  
  233.         if (*p != 13) {             // CR nicht kopieren
  234.             *line++ = *p;
  235.             ++cnt;
  236.         }
  237.  
  238.         --inlen;                    // einer weniger
  239.         ++p;
  240.     } while (cnt<255);
  241.  
  242.     *line = 0;                      // Zeile abschliessen
  243.     inptr = p;                      // Pos. naechstes Zeichen
  244.     return(rv||cnt);                // und fertig
  245. }
  246.  
  247.  
  248. fputs(line)
  249. register uchar  *line;
  250. {
  251.     register uchar  *p = outptr;
  252.  
  253.     while (*line) {
  254.         if (*line == '\n') ++Lineno;
  255.         if ( (long)(p-outbuf) == 4096L) {
  256.             if (Fwrite(outhandle, 4096L, outbuf) != 4096L)
  257.                 error("write error", 0L);
  258.             p = outptr = outbuf;
  259.         }
  260.         *p++ = *line++;
  261.     }
  262.     outptr = p;
  263. }
  264.  
  265.  
  266. /*******************************************************************/
  267.  
  268. /*
  269.  * Seitenende erzeugen
  270.  * Falls Datei zu lang, neue erzeugen
  271.  */
  272. EndNode()
  273. {
  274.     char    file[128];
  275.  
  276.     fputs("@endnode" NL NL NL);
  277.     xclose(inhandle);                   // Eingabe schliessen
  278.  
  279.     if (maxlines && Lineno>maxlines) {
  280.         strcpy(file, output);
  281.         itoa(++ExtCnt, suffix(file)+1, 10);
  282.         xclose(outhandle);
  283.         Wopen(file);
  284.     }
  285. }
  286.  
  287.  
  288. ImagePage(p)
  289. FLIST   *p;
  290. {
  291.     IMGHEADER   *img = (IMGHEADER *)inbuf;
  292.     uchar       *str = inbuf+100;
  293.     int         cnt;
  294.  
  295.     Fread(inhandle, (long)sizeof(IMGHEADER), img);
  296.     cnt = (img->lines+15)/16;
  297.     fputs("@image ");
  298.     fputs(p->file);
  299.     fputs(" 1 ");
  300.     ltoa((long)((img->linew+7)/8), str, 10);    // Breite in Zeichen
  301.     fputs(str);
  302.     fputs(" ");
  303.     ltoa((long)cnt, str, 10);                   // Höhe in Zeichen
  304.     fputs(str);
  305.     fputs(NL);
  306.  
  307.     EndNode();
  308. }
  309.  
  310. char *Find(char *key)
  311. {
  312.     register FLIST  *p;
  313.  
  314.     p = FBase;
  315.     while (p) {
  316.         if (strcmp(p->name, key)==0)
  317.             return(0);
  318.         p = p->next;
  319.     }
  320.     return(1);
  321. }
  322.  
  323.  
  324. char *GetName(name, key)
  325. char    *name, *key;
  326. {
  327.     char buf[20], *rv;
  328.  
  329.     /*
  330.      * wenn gwünscht, dann immer den Dateinamen als
  331.      * Seitennamen verwenden
  332.      */
  333.     if (use_filenames) {
  334.         rv = name;
  335.         goto ende;
  336.     }
  337.  
  338.     if (Find(key)) {                    // suchen nach Titel
  339.         rv = key;
  340.     }
  341.     else {
  342.         strcpy(buf, basename(name));
  343.         *suffix(buf) = 0;
  344.         if (Find(buf))                  // Datei ohne Endung
  345.             rv = buf;
  346.         else {
  347.             strcpy(buf, basename(name));
  348.             if (Find(buf))              // Datei mit Endung
  349.                 rv = buf;
  350.             else {
  351.                 rv = name;
  352.             }
  353.         }
  354.     }
  355. ende:
  356.     return(strdup(rv));
  357. }
  358.  
  359.  
  360. #if 0
  361. char *GetName(name, key, flg)
  362. char    *name, *key;
  363. int     flg;
  364. {
  365.     register FLIST  *p;
  366.     char            buf[20];
  367.     register char   *new;
  368.     int             flag;
  369.  
  370.     flag=0;
  371.     new = key;                      // zuerst testen wir das Schlüsselwort
  372.  
  373. again:
  374.     p = FBase;
  375.     while (p) {
  376.         if (strcmp(p->name, new) == 0) {
  377.             if (flag==2)            // test auf Dateiname?
  378.                 return(0L);         // ja: geht alles nicht
  379. chk:
  380.             ++flag;                 // war test auf Schlüsselwort
  381.             new = buf;              // jetzt probieren wir den Dateinamen
  382.             strcpy(new, basename(name));
  383.             if (flag==1) *suffix(new) = 0;
  384.             goto again;
  385.         }
  386.         p = p->next;
  387.     }
  388.     if (flg==0) {
  389.         flg=1;
  390.         goto chk;
  391.     }
  392.     return(strdup(new));            // gefundenen Nodenamen zurück
  393. }
  394. #endif
  395.  
  396. /*
  397.  * Neuen Dateinamen an die Liste zu lesender
  398.  * Dateien anhaengen, falls sie noch nicht ex.
  399.  */
  400. FLIST *AddFile(name, key)
  401. char    *name, *key;
  402. {
  403.     register FLIST  *p = FBase, *last = p;
  404.  
  405.     while (p) {
  406.         if (strcmp(p->file, name) == 0) return(p);
  407.         last = p;
  408.         p = p->next;
  409.     }
  410.     p = malloc(sizeof(FLIST));
  411.     if (p == 0L)                    // Fehler
  412.         error("out of memory", 0L);
  413.     p->name = GetName(name, key);
  414.     p->file = strdup(name);         // Namen kopieren
  415.     if (strcmp(p->name, key)) {     // wenn nodename != key
  416.         p->title = strdup(key);     // dann key als Titel nehmen
  417.     }
  418.     else
  419.         p->title = 0L;
  420.     p->flags = 0;                   // noch nicht gelesen
  421.     p->next = 0L;                   // immer der letzte
  422.  
  423.     if (last) {
  424.         last->next = p;
  425.     }
  426.     else {                          // erstes Element
  427.         FBase = p;
  428.     }
  429.     return(p);
  430. }
  431.  
  432. /**********************************************************/
  433.  
  434. #define IS_ASCII    1
  435. #define NO_TYPE     2
  436.  
  437. int FileType(file, key)
  438. char    *file, *key;
  439. {
  440.     char            path[128];
  441.     register char   *p, *save;
  442.     int             h;
  443.     FLIST           *q;
  444.  
  445.     /*
  446.      * Dateinamen in Gro₧buchstaben wandeln
  447.      * und Pfad ergänzen.
  448.      */
  449.     strupr(file);
  450.     strcpy(path, inpath);
  451.     strcat(path, file);
  452.  
  453.     /*
  454.      * Der Pfad könnte '..' Teile enthalten, wegen
  455.      * des Vergleiches der Namen löschen wir diese
  456.      * Teile
  457.      */
  458. again:
  459.     p = path;
  460.     save = p;
  461.     while (*p) {
  462.         if (*p == '\\') {
  463.             if (p[1] == '.' && p[2] == '.') {
  464.                 h = *save == '\\' ? 3 : 4;
  465.                 strcpy(save, p+h);
  466.                 goto again;
  467.             }
  468.             save = p;   // letzter Slash
  469.         }
  470.         ++p;
  471.     }
  472.  
  473.     /*
  474.      * damit die Datei nicht so lang wird, schneiden
  475.      * wir den Pfad jetzt noch so weit ab, dass er relativ
  476.      * zur Hauptdatei ist
  477.      */
  478.     save = (char *)mainpath;
  479.     p = path;
  480.     while (*p == *save) {
  481.         ++p;
  482.         ++save;
  483.     }
  484.  
  485.     strcpy(file, p);
  486.     p = suffix(file);
  487.  
  488.     /*
  489.      * mal sehen, ob es sich um einen der vom 1stView
  490.      * unterstützten Dateitypen handelt...
  491.      * Wenn ja, dann kann der Compiler damit nichts
  492.      * anfangen (keine ASCII-Datei) und wir liefern
  493.      * NO_TYPE
  494.      */
  495.     if (   strcmp(p, ".RSC") == 0
  496.         || strcmp(p, ".GEM") == 0
  497.         || strcmp(p, ".SAM") == 0
  498.         || strcmp(p, ".SND") == 0
  499.         || strcmp(p, ".OUT") == 0
  500.         || strcmp(p, ".DOK") == 0
  501. //-         || strcmp(p, ".IMG") == 0
  502.         || strcmp(p, ".IFF") == 0
  503.         )
  504.         return(NO_TYPE);
  505.  
  506.     /*
  507.      * ...dann ist es wohl eine ASCII-Datei;
  508.      * in diesem Fall wollen wir sie nachher noch lesen,
  509.      * also kommt sie in die Liste, falls sie geöffnet
  510.      * werden kann
  511.      */
  512.     if ((h=Fopen(file, 0))>0)
  513.         Fclose(h);
  514.     else {
  515.         if (NeedNL) {
  516.             Cconws(NL);
  517.             NeedNL = 0;
  518.         }
  519.         Cconws("*** warning in '");
  520.         Cconws(CurrFile);
  521.         Message("': missing file ", file);
  522.         code = 2;
  523.         return(NO_TYPE);
  524.     }
  525.  
  526.     q = AddFile(file, key);
  527.     strcpy(file, q->name);
  528.     return(IS_ASCII);
  529. }
  530.  
  531.  
  532. /*
  533.  * Sichtbaren Verweis konvertieren
  534.  */
  535. int ConvKey(key)
  536. char *key;
  537. {
  538.     char    buf[100];
  539.     register char   *src = key, *dst = buf;
  540.     int             rv=1;
  541.  
  542.     if (*src == '@' || NoAuto) rv=0;      // link erzwingen
  543.  
  544.     while (*src) {
  545.         if (*src == '"' || *src == '\\') {
  546.             *dst++ = '\\';
  547.             rv=0;
  548.         }
  549.         *dst++ = *src++;
  550.     }
  551.     *dst = 0;
  552.     strcpy(key, buf);
  553.     return(rv);
  554. }
  555.  
  556.  
  557. int HasBlanks(p)
  558. register char *p;
  559. {
  560.     while (*p) {
  561.         if (*p == ' ') return(1);
  562.         ++p;
  563.     }
  564.     return(0);
  565. }
  566.  
  567. DoList()
  568. {
  569.     uchar           line[255], buf[512], file[128], key[100];
  570.     register uchar  *src, *dst, *p;
  571.     uchar           *save;
  572.     int             cnt;
  573.  
  574.     while (Ropen()) {                       // ueber alle Dateien
  575. again:
  576.         while (fgets(line)) {               // alle Zeilen
  577.             src = line;
  578.             dst = buf;
  579.  
  580.             /*
  581.              * falls die Zeile ein Infoblock ist, dann
  582.              * ignorieren wir sie einfach
  583.              */
  584.             if (*src == 0x1F) goto again;
  585.  
  586.             /*
  587.              * falls am Anfang ein Kommentarzeichen steht,
  588.              * rücken wir es einfach ein, damit der Compiler
  589.              * es ignoriert
  590.              */
  591.             if (*src == '#' && src[1] == '#')
  592.                 *dst++ = ' ';
  593.  
  594.             while (*src) {                  // alle Zeichen
  595.                 switch (*src) {
  596.                     case 0x1C:              // streckendes Leerzeichen
  597.                     case 0x1D:              // Einzugsleerzeichen
  598.                     case 0x1E:              // variables Leerzeichen
  599.                         *dst++ = ' ';
  600.                         ++src;
  601.                         break;
  602.                     case 27:
  603.                         ++src;
  604.                         if (*src>=0x80) {
  605.                             *dst++ = '@';
  606.                             *dst++ = '{';
  607.                             *src -= 0x80;
  608.                             if (*src==0)    *dst++ = '0';   // alles aus
  609.                             if (*src & 1)   *dst++ = 'B';   // Fett
  610.                             if (*src & 2)   *dst++ = 'G';   // Hell
  611.                             if (*src & 4)   *dst++ = 'I';   // Kursiv
  612.                             if (*src & 8)   *dst++ = 'U';   // Underlined
  613.                             *dst++ = '}';
  614.                         }
  615.                         else {
  616.                             *dst++ = 27;
  617.                             *dst++ = *src;
  618.                         }
  619.                         ++src;
  620.                         break;
  621.                     case '@':
  622.                         *dst++ = '@';
  623.                         /* fall thru */
  624.                     default:
  625.                         *dst++ = *src++;
  626.                         break;
  627.                     case '▌':
  628.                         p = key;
  629.                         cnt=0;
  630.                         save = dst;
  631.                         do {
  632.                             *dst++ = *src++;
  633.                             if (*src == '▌') {
  634.                                 *p = 0;
  635.                                 if (cnt==1) {
  636.                                     ++src;
  637.                                     break;
  638.                                 }
  639.                                 else {
  640.                                     p = file;
  641.                                     *dst++ = *src++;
  642.                                 }
  643.                                 ++cnt;
  644.                             }
  645.                             if (*src == 0) goto more;
  646.                             *p++ = *src;
  647.                         } while (1);
  648.                         dst = save;
  649.                         if (FileType(file, key) != IS_ASCII)
  650.                             p = (uchar *)"\\Main";
  651.                         else {
  652.                             p = 0L;
  653.                             cnt = ConvKey(key);
  654.                             /*
  655.                              * falls der Autoreferenzer diese
  656.                              * Stelle auch alleine findet, lassen
  657.                              * wir ihn das machen
  658.                              */
  659.                             if (cnt && *src < '0' && dst[-1] < '0'
  660.                                 && (HasBlanks(file)==0)
  661.                                 && strcmp(key, file) == 0) {
  662.                                 strcpy(dst, key);
  663.                                 while (*dst++);
  664.                                 --dst;
  665.                                 break;
  666.                             }
  667.                         }
  668.                         *dst++ = '@';
  669.                         *dst++ = '{';
  670.                         *dst++ = '"';
  671.                         strcpy(dst, key);
  672.                         while (*dst++);
  673.                         --dst;
  674.                         strcpy(dst, "\" link ");
  675.                         dst += 7;
  676.                         ConvKey(file);
  677.                         *dst++ = '"';
  678.                         strcpy(dst, file);
  679.                         while (*dst++);
  680.                         --dst;
  681.                         if (p) {
  682.                             strcpy(dst, p);
  683.                             while (*dst++);
  684.                             --dst;
  685.                         }
  686.                         *dst++ = '"';
  687.                         *dst++ = '}';
  688.                         break;
  689.                 }
  690.             }
  691. more:
  692.             *dst=0;
  693.             fputs(buf);
  694.             fputs(NL);
  695.         }
  696.         EndNode();
  697.     }
  698. }
  699.  
  700.  
  701. AddIncludes()
  702. {
  703.     char    buf[128];
  704.     int     i;
  705.  
  706.     strcpy(buf, output);
  707.     outhandle = Fopen(buf, 1);
  708.     outptr = outbuf;
  709.     Fseek(0L, outhandle, 2);
  710.  
  711.     for (i=1; i<=ExtCnt; i++) {
  712.         strcpy(buf, output);
  713.         itoa(i, suffix(buf)+1, 10);
  714.         fputs(NL "@include ");
  715.         fputs(buf);
  716.     }
  717.     fputs(NL);
  718.     xclose(outhandle);
  719. }
  720.  
  721.  
  722.  
  723. /**************************************************************/
  724.  
  725. extern int  _argc;
  726. extern char **_argv;
  727. _main()
  728. {
  729.     main(_argc, _argv);
  730. }
  731.  
  732.  
  733. main(argc, argv)
  734. int argc;
  735. char **argv;
  736. {
  737.     char            outfile[128];
  738.     register char   *p;
  739.     int             save;
  740.  
  741.     maxlines = 0;
  742.  
  743.     if (argc < 2) {
  744.         error("usage: 1stConv [-NNN -f -q -a] file" NL
  745.               "       -NNN: max lines per file" NL
  746.               "       -f  : use filenames as nodenames" NL
  747.               "       -q  : be quiet" NL
  748.               "       -a  : explicit links only" NL
  749.               , 0L);
  750.         _exit(1);
  751.     }
  752.  
  753.     save = 0;
  754.     do {
  755.         ++argv;
  756.         --argc;
  757.         if (**argv == '-') {
  758.             p = *argv+1;
  759.             if (*p == 'f') {
  760.                 save = 1;
  761.             }
  762.             else if (*p == 'q')
  763.                 ++quiet;
  764.             else if (*p == 'a')
  765.                 ++NoAuto;
  766.             else
  767.                 maxlines = atoi(p);
  768.         }
  769.         else {
  770.             if (quiet==0) {
  771.                 Message("1stConv: V(" __DATE__ ") 1stGuide --> ST-Guide sources" NL
  772.                         "         Written by Holger Weets using SOZOBON-C V2.00x10" NL
  773.                         , 0L);
  774.             }
  775.  
  776.             /*
  777.              * Ausgabedatei bestimmen
  778.              */
  779.             strupr(*argv);                      // falls aus CLI
  780.             strcpy(outfile, *argv);
  781.             AddFile(basename(outfile), "Main"); // nur Dateinamen eintragen
  782.             use_filenames = save;
  783.             p = (char *)mainpath;               // Pfad merken
  784.             strcpy(p, outfile);
  785.             *basename(p) = 0;
  786.  
  787.             /*
  788.              * wir setzen das Verzeichnis der Hauptdatei
  789.              * als aktuelles Verzeichnis, damit die Pfade
  790.              * relativ angegeben werden können und somit
  791.              * die Ausgabedatei kürzer und transportabler
  792.              * wird.
  793.              */
  794.             if (p[1] == ':')
  795.                 Dsetdrv(*p-'A');
  796.             Dsetpath(p);
  797.  
  798.             strcpy(suffix(outfile), ".stg");
  799.             Wopen(outfile);
  800.             OpenINF(outfile);
  801.             strcpy(output, outfile);
  802.             ExtCnt=0;
  803.             DoList();
  804.             xclose(outhandle);
  805.  
  806.             if (ExtCnt) AddIncludes();
  807.  
  808.             if (NeedNL) Cconws(NL);
  809.             break;
  810.         }
  811.     } while (argc>1);
  812.     _exit(code);
  813. }
  814.  
  815.  
  816.  
  817.  
  818.  
  819.