home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1991 / 06 / tricks / viewerr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-02-25  |  9.5 KB  |  331 lines
  1. /* ------------------------------------------------------ */
  2. /*                     VIEWERR.C                          */
  3. /*   Compilieren: cl /AL viewerr.c                        */
  4. /*            (c) 1991 V.Iuorno & TOOLBOX                 */
  5. /* ------------------------------------------------------ */
  6. #include <stdlib.h>
  7. #include <stdio.h>
  8. #include <conio.h>
  9. #include <string.h>
  10. #include <ctype.h>
  11.  
  12. #define HOME   'G'             /* Home bei getch()        */
  13. #define END    'O'             /* End  bei getch()        */
  14. #define CURSUP 'H'             /* Cursor up   bei getch() */
  15. #define CURSDN 'P'             /* Cursor down bei getch() */
  16. #define ESCAPE 27
  17. /* Cursor-Positionieren */
  18. #define CURSOR(line, pos) printf("%c[%02d;%02df", \
  19.                                  ESCAPE, line, pos)
  20. #define CURHOME printf("%c[0;0f", ESCAPE)
  21. #define CURPOS CURSOR(LAST_BILD_LINE, 80)
  22. #define INVERS_ON printf("%c[1;7m", ESCAPE)
  23. #define INVERS_OFF printf("%c[1;0m", ESCAPE)
  24. #define LAST_BILD_LINE 25
  25. #define LAST_SOURCE_LINE 19
  26. #define FIRST_ERROR_LINE 21
  27. #define LAST_ERROR_LINE 24
  28. #define ANZERROR 4
  29. #define MAX_LINE 100
  30. #define TRENNZEILE \
  31.         "----------------------------------------\
  32.          ----------------------------------------"  /* 80 */
  33. #define ENDZEILE "ESCAPE = Programm beenden"
  34. #define START_NR "("
  35.            /* String an dem die Fehler-Zeilen-Nr. anfängt */
  36.  
  37. /* --- Globale Daten ------------------------------------ */
  38. struct C_Zeile
  39.   {
  40.   char zeile[MAX_LINE];      /* C-Source-Zeile            */
  41.   struct C_Zeile *next;      /* Pointer auf nächste Zeile */
  42.   } *c;
  43. struct C_Zeile *Start_C;   /* Pointer auf 1. Source-Zeile */
  44. unsigned short iTotC = 0;  /* Total Source-Zeilen         */
  45.  
  46. struct E_Zeile
  47.   {
  48.   char zeile[MAX_LINE];    /* Fehler-Zeile                */
  49.   struct E_Zeile *next;    /* Pointer auf nächste Zeile   */
  50.   struct E_Zeile *prior;   /* Pointer auf vorherige Zeile */
  51.   } *e;
  52. struct E_Zeile *Start_E, *Ende_E, *First_Bild_E, *Akt_E;
  53. unsigned short iAktE = 0;
  54.                     /* Position der aktuellen Fehlerzeile */
  55. unsigned short iTotE = 0;          /* Total Fehler-Zeilen */
  56.  
  57. /* --- Funktions-Prototypen ----------------------------- */
  58. void   DispSource (struct C_Zeile *);
  59. void   DispError  (struct E_Zeile *);
  60. void   ZeigeFehler(struct E_Zeile *);
  61. struct C_Zeile * PositionC(short nr);
  62. void   Invers(int line, int pos, char *str);
  63.  
  64. /* --- Hauptprogramm ------------------------------------ */
  65. void main(int argc, char *argv[])
  66. {
  67. FILE *C_fp;                               /* Source-Datei */
  68. FILE *E_fp;                               /* Fehler-File  */
  69. char ErrorZeile[80];
  70.          /* String um eine Fehler-Zeile zu identifizieren */
  71. char zeile[MAX_LINE];         /* Puffer für Fehler-Zeilen */
  72. struct C_Zeile *C_Temp;
  73. struct E_Zeile *E_Temp;
  74. char ch;
  75. register i;                   /* allgemeine Laufvariable  */
  76.  
  77. /* --- Richtige Anzahl Argumente prüfen ----------------- */
  78. if(argc != 3)
  79.   {
  80.   fprintf(stderr, "\nAufruf: %s C_pgm.c errfile", argv[0]);
  81.   exit(1);
  82.   }
  83.  
  84. /* --- C-Source und Fehler-File öffnen ------------------ */
  85. if(! (C_fp = fopen(argv[1], "r")))
  86.   {
  87.   fprintf(stderr, "Kann File %s nicht öffnen!", argv[1]);
  88.   exit(1);
  89.   }
  90. if(! (E_fp = fopen(argv[2], "r")))
  91.   {
  92.   fprintf(stderr, "\nKann File %s nicht öffnen!", argv[2]);
  93.   exit(1);
  94.   }
  95.  
  96. /* String bilden, um eine Fehlerzeile zu identifizieren   */
  97. /* String besteht aus C-Source-Namen und START_NR         */
  98. for(i = strlen(argv[1]) - 1; *(argv[1]+i) != '\\'
  99.     && *(argv[1]+i) != ':' && i; i--);
  100. if(i) i++;
  101. strcpy(ErrorZeile, argv[1]+i);
  102. strcat(ErrorZeile, START_NR);
  103.  
  104. /* Fehler-Zeilen einlesen                                 */
  105. /* Speicher für erste Zeile anfordern                     */
  106. if(! (Start_E = (struct E_Zeile *)
  107.                  malloc(sizeof(struct E_Zeile))))
  108.   {
  109.   fprintf(stderr,"\nNicht genug freier Speicher!");
  110.   exit(1);
  111.   }
  112. Start_E->next = 0; Start_E->prior = 0;
  113. e = E_Temp = Start_E;
  114.  
  115. while(fgets(zeile, MAX_LINE, E_fp))
  116.   {
  117.   if(strlen(zeile) > 80)               /* Zeile begrenzen */
  118.      *(zeile+80) = '\0';
  119.   if(strstr(zeile, ErrorZeile))        /* Fehlerzeile?    */
  120.     {                                  /* ja              */
  121.     strcpy(e->zeile, zeile);
  122.     /*** Speicher für nächste Zeile anfordern ***/
  123.     if(! (e->next = (struct E_Zeile *)
  124.                      malloc(sizeof(struct E_Zeile))))
  125.       {
  126.       fprintf(stderr,"\nNicht genug freier Speicher!");
  127.       exit(1);
  128.       }
  129.     e->prior = E_Temp;
  130.     E_Temp = e;
  131.     e = e->next;
  132.     iTotE++;
  133.     }
  134.   }
  135. Ende_E = E_Temp;                        /* Letzte Zeile   */
  136. E_Temp->next = NULL;
  137. fclose(E_fp);
  138. if(! iTotE)
  139.   {
  140.   fprintf(stderr, "\nKeine Fehler in %s ", argv[1]);
  141.   exit(0);
  142.   }
  143. First_Bild_E = Start_E;
  144.  
  145. /* C-Source-Zeilen einlesen ----------------------------- */
  146. /* Speicher für erste Zeile anfordern                     */
  147. if(! (Start_C = (struct C_Zeile *)
  148.                  malloc(sizeof(struct C_Zeile))))
  149.   {
  150.   fprintf(stderr,"\nNicht genug freier Speicher!");
  151.   exit(1);
  152.   }
  153. Start_C->next = 0;
  154. c = C_Temp = Start_C;
  155.  
  156. while(fgets(c->zeile, MAX_LINE, C_fp))
  157.   {
  158.   if(strlen(c->zeile) > 80)            /* Zeile begrenzen */
  159.      *(c->zeile+80) = '\0';
  160.   /*** Speicher für nächste Zeile anfordern ***/
  161.   if(! (c->next = (struct C_Zeile *)
  162.                    malloc(sizeof(struct C_Zeile))))
  163.     {
  164.     fprintf(stderr,"\nNicht genug freier Speicher!");
  165.     exit(1);
  166.     }
  167.   C_Temp = c;
  168.   c = c->next;
  169.   iTotC++;
  170.   }
  171. C_Temp->next = NULL;                      /* Letzte Zeile */
  172. fclose(C_fp);
  173.  
  174. /* --- Trenn- und Endzeile anzeigen --------------------- */
  175. CURSOR(LAST_SOURCE_LINE+1, 0); printf("%-80s", TRENNZEILE);
  176. CURSOR(LAST_BILD_LINE, 0);     printf("%-79s", ENDZEILE);
  177.  
  178. /* --- Fehler-Zeilen anzeigen --------------------------- */
  179. DispError(Start_E);
  180.  
  181. /* --- Erste Fehlerhafte Zeile anzeigen ----------------- */
  182. ZeigeFehler(Start_E);
  183. Akt_E = Start_E;
  184. iAktE = 1;
  185. Invers(FIRST_ERROR_LINE, 0, Akt_E->zeile);
  186.  
  187. /* --- Main Loop ---------------------------------------- */
  188. while((ch = getch()) != ESCAPE)     /* Abbruch mit ESCAPE */
  189.   {
  190.   if(ch == CURSDN && Akt_E->next)
  191.     {
  192.     if(iAktE == 4)
  193.       {
  194.       First_Bild_E = First_Bild_E->next;
  195.       DispError(First_Bild_E);
  196.       Invers(LAST_ERROR_LINE, 0, Akt_E->next->zeile);
  197.       }
  198.     else
  199.       {
  200.       iAktE++;
  201.       DispError(First_Bild_E);
  202.       Invers(FIRST_ERROR_LINE+iAktE-1,
  203.                                     0, Akt_E->next->zeile);
  204.       }
  205.     Akt_E = Akt_E->next;
  206.     ZeigeFehler(Akt_E);
  207.     }
  208.   else if(ch == CURSUP && Akt_E->prior)
  209.     {
  210.     if(iAktE == 1)
  211.       {
  212.       First_Bild_E = First_Bild_E->prior;
  213.       DispError(First_Bild_E);
  214.       Invers(FIRST_ERROR_LINE, 0, Akt_E->prior->zeile);
  215.       }
  216.     else
  217.       {
  218.       iAktE--;
  219.       DispError(First_Bild_E);
  220.       Invers(FIRST_ERROR_LINE+iAktE-1,
  221.                                     0, Akt_E->prior->zeile);
  222.       }
  223.     Akt_E = Akt_E->prior;
  224.     ZeigeFehler(Akt_E);
  225.     }
  226.   else if(ch == HOME && Akt_E->prior)
  227.     {
  228.     iAktE = 1;
  229.     First_Bild_E = Akt_E = Start_E;
  230.     DispError(First_Bild_E);
  231.     Invers(FIRST_ERROR_LINE, 0, Akt_E->zeile);
  232.     ZeigeFehler(Akt_E);
  233.     }
  234.   else if(ch == END && Akt_E->next)
  235.     {
  236.     iAktE = 1;
  237.     First_Bild_E = Akt_E = Ende_E;
  238.     DispError(First_Bild_E);
  239.     Invers(FIRST_ERROR_LINE, 0, Akt_E->zeile);
  240.     ZeigeFehler(Akt_E);
  241.     }
  242.   }
  243. }
  244.  
  245. /* --- Source-Zeilen anzeigen --------------------------- */
  246. void DispSource(struct C_Zeile *Anzeigen)
  247. {
  248. struct C_Zeile *Disp;
  249. register i;
  250.  
  251. CURHOME; for(i = 1; i <= LAST_SOURCE_LINE; i++)
  252.            printf("%80s", "");
  253. CURHOME; for(Disp = Anzeigen, i = 1;
  254.            Disp && i <= LAST_SOURCE_LINE; i++)
  255.   {
  256.   printf("%s", Disp->zeile);
  257.   Disp = Disp->next;
  258.   }
  259. }
  260.  
  261. /* --- Fehler-Zeilen anzeigen --------------------------- */
  262. void DispError(struct E_Zeile *Anzeigen)
  263. {
  264. struct E_Zeile *Disp;
  265. register i;
  266.  
  267. CURSOR(FIRST_ERROR_LINE, 0);
  268. for(i = FIRST_ERROR_LINE; i <= LAST_ERROR_LINE; i++)
  269.   printf("%80s", "");
  270. CURSOR(FIRST_ERROR_LINE, 0);
  271. for(Disp = Anzeigen, i = FIRST_ERROR_LINE;
  272.     Disp && i <= LAST_ERROR_LINE; i++)
  273.   {
  274.   printf("%s", Disp->zeile);
  275.   Disp = Disp->next;
  276.   }
  277. }
  278.  
  279. /* --- Fehlerhafte Zeile anzeigen ----------------------- */
  280. void ZeigeFehler(struct E_Zeile *Anzeigen)
  281. {
  282. short first = 0, line;
  283. struct C_Zeile *AnzFirst, *AnzFehler;
  284. register i;
  285. char *p, str[20];
  286. int znr;
  287. static int oldnr = 0;
  288.  
  289. p = strstr(Anzeigen->zeile, START_NR);
  290. p++;
  291. for(i = 0; isdigit(*p); p++, i++) *(str+i) = *p;
  292.                                   /* Zeilen-Nr. speichern */
  293. str[i] = '\0';
  294. znr = atoi(str);
  295. if(oldnr != znr && znr <= iTotC + 1)
  296.   {
  297.   oldnr = znr;
  298.   first = znr - LAST_SOURCE_LINE / 2;
  299.                           /* Fehlerhafte Zeile zentrieren */
  300.   if(first < 1) first = 1;
  301.   line = first > 1 ? LAST_SOURCE_LINE / 2 + 1 : znr;
  302.   AnzFirst = PositionC(first);
  303.   AnzFehler = PositionC(znr);
  304.   DispSource(AnzFirst);
  305.   Invers(line, 0, AnzFehler->zeile);
  306.   }
  307. }
  308.  
  309. /* --- Auf eine bestimmte Source-Zeile positionieren ---- */
  310. struct C_Zeile * PositionC(short nr)
  311. {
  312. struct C_Zeile *Find = Start_C;
  313. register i;
  314.  
  315. for(i = 1; Find && i != nr; i++)
  316.   Find = Find->next;
  317. return Find;
  318. }
  319.  
  320. /* --- Einen String invers anzeigen --------------------- */
  321. void Invers(int line, int pos, char *str)
  322. {
  323. INVERS_ON;
  324. CURSOR(line, pos); printf("%-80s", "");
  325. CURSOR(line, pos); printf("%s", str);
  326. INVERS_OFF; CURPOS;
  327. }
  328. /* ------------------------------------------------------ */
  329. /*              Ende von VIEWERR.C                        */
  330.  
  331.