home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / EFFO / forum7.lzh / C / RDOC / rdoc.c < prev    next >
C/C++ Source or Header  |  1988-07-15  |  21KB  |  555 lines
  1. /****************************************************************************
  2. * Progrmname :     rdoc.c                                                   *
  3. * Programmierer :  W. Reese aus C't 1988 Heft 7                             *
  4. * Projekt :        Rueckdocumentation                                       *
  5. * Datum :          11. 05. 1988                                             *
  6. *                                                                           *
  7. ****************************************************************************/
  8. # include <stdio.h>
  9.  
  10. /* Definition der Codes fuer Zeilenteiltypen */
  11. #define ZEILENENDE            0     /* Ende der Zeile */
  12. #define REST                  1     /* Rest-Wort */
  13. #define KOMSTART              2     /* Kommentarstart */
  14. #define KOMRUMPF              3     /* Kommentarrumpf */
  15. #define KOMENDE               4     /* Kommentarende */
  16. #define BLOCKSTART            10    /* Blockstart = "{" */
  17. #define BLOCKENDE             11    /* Blockende = "}" */
  18. #define IF                    20    /* Schluesselwort if */
  19. #define ELSE                  21    /* Schluesselwort else */
  20. #define WHILE                 22    /* Schluesselwort while */
  21. #define FOR                   23    /* Schluesselwort for */
  22. #define DO                    24    /* Schluesselwort do */
  23. #define CONTINUE              25    /* Schluesselwort continue */
  24. #define BREAK                 26    /* Schluesselwort break */
  25. #define RETURN                27    /* Schluesselwort return */
  26. #define GOTO                  28    /* Schluesselwort goto */
  27. #define CASE                  29    /* Schluesselwort case */
  28. #define SWITCH                30    /* Schluesselwort switch */
  29. #define DEFAULT               31    /* Schluesselwort default */
  30. #define LABEL                 32    /* Schluesselwort label */
  31.  
  32. #define TAB                   0x09  /* Horizontaler Tabulator */
  33.  
  34. /* Lesen bis \n einschl. c Zeichen */
  35. #define readline(a,b,c) fgets(b,c,a)
  36.  
  37. /* Schreiben aus dem Puffer a bis \n maximal b Zeichen auf */
  38. #define writeline(a,b)  writeln(1,a,b)
  39.  
  40. #define ERRFNAM "rdoc.err"           /* Filename Errorfile */
  41.  
  42. /* ======================= main ==================================== */
  43. main(argc,argv)
  44. int argc;
  45. char *argv[];
  46. {   
  47. char buf[200];
  48. int nschlw,nkomm,nrest,nblockst;
  49. static int bold=0,altblock=0,zakt=0,blockerr=0,schlerr=0,sumkom=0;
  50. int i;
  51. FILE *file,*fopen(),*errfile;
  52.  
  53. /* -------- Filename und Optionen aus Kommandozeile */
  54. if(argc < 2) { /* Filename  nicht vorhanden */
  55.                /* Abbruch mit Fehlermeldung */
  56.                fprintf(stdout,"Parameter Filename fehlt\n");
  57.                exit(10);
  58.              }
  59. if((file=fopen(argv[1],"r")) == NULL)   {    /* Open error */
  60.    /* -------Abbruch mit Fehlermeldung */
  61.                fprintf(stdout,"File kann nicht geoeffnet werden\n");
  62.                exit(10);
  63.              }
  64. if((errfile=fopen(ERRFNAM,"w")) == NULL)  { /* Open error */
  65.    /* -------- Abbruch mit Fehlermeldung */
  66.                fprintf(stdout,"Error-File kann nicht geoeffnet werden\n");
  67.                exit(10);
  68.              }             
  69. if(argc>=3 && scomp("-b",argv[2]) ==0)  /* Option -b vorhanden */
  70.     bold = 1;   /* Merker Fettdruck Schluesselworte setzen */
  71.     
  72.  
  73. /* --------  Textrumpf bearbeiten   */
  74. while(readline(file,buf,200) != NULL)  {  /* nicht Fileende  */
  75.     /* -----Zeile bearbeiten  */
  76.     zakt++; /* Zeilenzaehler aktualisieren */
  77.     nschlw=nkomm=nrest=nblockst=0;
  78.     zeile(buf,bold,&nschlw,&nkomm,&nrest,&nblockst);
  79.     /* ------- Update Statistik */
  80.     if(altblock == 1)   /* Blockstart in letzter Zeile */
  81.       if(nkomm == 0) {  /* Kein Kommentar in aktueller Zeile */
  82.          /* ---- Fehlerbearbeitung : Blockstart ohne Kommentar */
  83.          fprintf(errfile,
  84.              "%d : Kein Kommentar nach Blockstart\n",zakt);
  85.          blockerr++;
  86.         }
  87.     if(nblockst != 0)  /* Blockstart in Zeile  */
  88.        altblock = 1;   /* Merker Blockstart setzen  */
  89.     else               /* Kein Blockstart in Zeile */
  90.        altblock = 0;   /* Merker Blockstart ruecksetzen */
  91.     if(nschlw!=0 && nkomm==0)  { /* Schluesselw. ohne Kommentar  */
  92.       /* --------- Fehlerbearbeitung : Schluesselwort ohne Kommentar  */ 
  93.       fprintf(errfile,"%d : Schluesselwort ohne Kommentar\n",zakt);
  94.       schlerr++;
  95.       }
  96.     if(nkomm != 0)    /* Kommentar in Zeile  */
  97.        sumkom++;      /* Update Kommentarzeilenzaehler  */ 
  98.     } 
  99. /* ------ Statistik bearbeiten  */
  100. fprintf(errfile,
  101.    "******** Statistische Informationen *********\n\n");
  102. fprintf(errfile,
  103.    "  Anzahl der Programmzeilen ............... : %d\n",zakt);
  104. fprintf(errfile,
  105.    "  Davon Zeilen mit Kommentar .............. : %d\n",sumkom);
  106. fprintf(errfile,
  107.    "  Anzahl der Blockstarts ohne Kommentar ... : %d\n",blockerr);
  108. fprintf(errfile,
  109.    "  Anzahl der Schluesselworte ohne Kommentar : %d\n",schlerr);
  110. }
  111.  
  112.  
  113.  
  114. /* ==================== Zeile ============================================ */
  115. /* Funktionsumfang:
  116.         Zeilenrumpf suchen, bearbeiten (Schluesselworte und Kommentare
  117.         herausziehen) und -- wenn noch Reste vorhanden ausgeben.
  118.    
  119.    Eingabedaten:
  120.         *zstart = Zeiger (char *) auf Start der Orginalzeile 
  121.         bold    = Fettdruck Schluesselworte 0/1
  122.    
  123.    Ausgabedaten:
  124.         *nschlw  = Anzahl (int *) der Schluesselworte in der Zeile
  125.         *nkomm   = Anzahl (int *) der Kommentare in der Zeile
  126.         *nrest   = Anzahl (int *) der Restelemente in der Zeile
  127.         *blockst = Anzahl (int *) der Blckstarts in der Zeile
  128.         
  129.    Rueckgabe : 0, wenn Zeile nicht leer, sonst -1  */
  130.    
  131. zeile(zstart,bold,nschlw,nkomm,nrest,nblockst)
  132. char *zstart;
  133. int bold;
  134. int *nschlw,*nkomm,*nrest,*nblockst;
  135. {
  136.     char *z,*z1, *zrumpf();
  137.     int lang;
  138.     
  139.     /* ----------- Zeilenstart suchen */
  140.     z = zstart;
  141.     while(*z==TAB || *z==' ')          /* Zeichen gleich TAB oder SPACE */
  142.         z++;
  143.     lang = z-zstart;                   /* Laenge Zeilenstart */
  144.                                        /* Zeilenrumpf bearbeiten */
  145.     z1 = zrumpf(z,bold,nschlw,nkomm,nrest,nblockst);
  146.     if(z1 != (char *)NULL)   {         /* Zeile nicht leer */
  147.                                        /* Ausgabe der Zeile */
  148.           writeline(zstart,lang);      /* Ausgabe Zeilenstart */
  149.           writeline(z1,200);           /* Ausgabe Zeilenrumpf */
  150.           return(0);                   /* Return: keine Leerzeile */
  151.         }
  152.     else      /* Leerzeile */
  153.           return(-1);                  /* Return: Leerzeile */
  154. }
  155.  
  156. /* ===================== zrumpf ========================================== */
  157. /* Funktionumfang:
  158.         Der Zeilenrumpf wird in Zeilenbreite aufgespalten. Schluesselworte
  159.         und Kommentare werden mit einem Zwischenraum von zwei Leerzeichen
  160.         zu einem neuen Zeilenrumpf zusammengesetzt. Ev. Steuerzeichen fuer
  161.         Fettdruck der Schluesselworte werden eingefuegt. zrumpf merkt sich,
  162.         ob ein Kommentar in einer Zeile beeindet wurde.
  163.         
  164.    Eingabedaten:
  165.         *rstart  = Zeiger auf Start Zeilenrumpf in Orgi.zeile
  166.         bold     = Fettdruck Schluesselworte 0/1
  167.         
  168.    Ausgabedaten:
  169.         *nschlw  = Anzahl (int *) der Schluesselworte
  170.         *nkomm   = Anzahl (int *) der Kommentarruempfe
  171.         *nrest   = Anzahl (int *) der Restelemente
  172.         *nblockst= Anzahl (int *) der Blockstarts        
  173.         
  174.    Rueckgabe :
  175.         OK : Zeiger auf Start des bearbeiteten Zeilenrumpfs
  176.         Leerrumpf : Zeiger (char * auf NULL */
  177.  
  178. char *zrumpf(rstart,bold,nschlw,nkomm,nrest,nblockst)
  179. char *rstart;
  180. int bold,*nschlw,*nkomm,*nrest,*nblockst;
  181. {
  182. register int i;             /* schneller Schleifenzaehler */
  183. static int altkom = 0;      /* Merker alter Kommentar nicht beendet */
  184. static char buf[200];       /* Puffer bearbeiteter Zeilenrumpf */
  185. char *bp;                   /* Pufferzeiger bearbeiteter Zeilenrumpf */
  186. int leerrumpf,laenge,code;
  187.  
  188. /* ------ Initialisierung von Variablen  */
  189. bp = buf;
  190. leerrumpf = 1;                   /* Leerrumpfmerker setzen */
  191. *nschlw = *nkomm = *nrest = *nblockst = 0; /* Zaehler ruecksetzen */
  192.  
  193. /* ----- Zeilenrumpf abarbeiten */
  194. while((code = zeilenteil(rstart,altkom,&laenge))!=ZEILENENDE) {
  195.     /* ---- Zeilenteil bearbeiten */
  196.     if(code == KOMSTART) { /* Kommentarstart */
  197.        /* ----Bypass, Merker setzen */
  198.        leerrumpf = 0; /* Leerrumpfmerker ruecksetzen */
  199.        altkom = 1;    /* Kommentarstart merken */
  200.        rstart += laenge;    /* Bypass Kommentarstart */          
  201.        }
  202.     else if(code == KOMENDE)  {  /* Kommentarende */
  203.        /* ----- Bypass, Merker setzen */
  204.        altkom = 0;       /* Merker Kommentarstart zuruecksetzen */
  205.        rstart += laenge;  /* Bypass Kommentarende */
  206.        *(bp++) = ' '; *(bp++) = ' ';      /* Space einkopieren */
  207.        }
  208.     else if(code == KOMRUMPF) {   /* Kommentarrumpf */
  209.        /* ----- Kommentarrumpf einkopieren  */ 
  210.        leerrumpf = 0;      /* Leerrumpfmerker ruecksetzen */
  211.        /* Kommentarrumpf einkopieren  */
  212.        while(*rstart == ' ') { /* Fuehrendes Leerzeichen  */
  213.           /* --------- Bypass fuehrendes Leerzeichen */
  214.           rstart++;
  215.           laenge--;
  216.           } 
  217.        for(i=0;i<laenge;i++)       /* Ganzen Kommentarrumpf */
  218.          *(bp++) = *(rstart++);    /* Kopieren */
  219.        *(bp++) = ' '; *(bp++) = ' ';     /* Space einkopieren */
  220.        (*nkomm)++;                 /* Inkrement Kommentarzaehler */
  221.        }
  222.     else if(code == BLOCKSTART) {  /* Blockstart */
  223.       /* -------- Blockstart einkopieren */
  224.       if (bold == 1)       /* Breitschrift */
  225.            boldface(&bp,1);     /* Code Bold-On einkopieren */
  226.       for(i=0;i<laenge;i++)  *(bp++) = *(rstart++);    /* Kopie {  */
  227.       if(bold == 1)    /* Breitschrift */
  228.          boldface(&bp,0);    /* Code Bold-Off einkopieren  */
  229.       *(bp++) = ' ';*(bp++) = ' ';   /* Space einkopieren */
  230.       (*nblockst)++;  /* Inkrement Blockstartzaehl   */
  231.       leerrumpf = 0;   /* Leerrumpfmerker ruecksetzen  */
  232.       } 
  233.     else if(code == BLOCKENDE)  {     /*  Blockende  */
  234.       /* ------- Blockende einkopieren */
  235.       if(bold == 1)   /* Breitschrift  */
  236.         boldface(&bp,1);     /* Code Bold-on einkopieren */
  237.       for (i=0;i<laenge;i++)    /* Blockendezeichenlaenge  */
  238.         *(bp++) = *(rstart++);    /* Kopie } */
  239.       if(bold == 1)      /* Breitschrift */
  240.         boldface(&bp,0);    /* Code Bold-Off einkopieren */
  241.       leerrumpf = 0;   /* Leerrumpfmerker ruecksetzen */
  242.       *(bp++) = ' '; *(bp++) = ' ';     /* Space einkopieren */
  243.       }  
  244.     else if(code>=IF && code <=LABEL) {   /* Schluesselwort */
  245.        /* -------- Schluesselwort einkopieren */
  246.        if(bold == 1)     /* Breitschrift */
  247.          boldface(&bp,1);      /* Code Bold-On einkopieren   */
  248.        for(i=0;i<laenge;i++)      /* Laenge Schluesselwort  */
  249.          *(bp++) = *(rstart++);  /* Schluesselwort einkopieren  */
  250.        if(bold == 1)    /* Breitschrift */
  251.          boldface(&bp,0);    /* Code Bold-Off einkopieren  */
  252.        *(bp++) = ' ';*(bp++) = ' ';       /* Space einkopieren  */
  253.        (*nschlw)++;     /* Inkrement Schluesselwortzaehler */
  254.        leerrumpf = 0;     /* Leerrumpfmerker ruecksetzen */
  255.        } 
  256.     else {   /* Rest-Element  */
  257.        /* ------ Bypass Rest-Element */
  258.        rstart += laenge;
  259.        (*nrest)++;
  260.        }  
  261.     }  
  262. if(leerrumpf==1 && *nrest!=0)    /* Leerrumpfmerker u. Restelement */
  263.    return((char *)NULL);    /* Rueckgabe : Leerrumpf   */
  264. else   {      /* Kein Leerrumpf   */
  265.   /* ------ Zeilenende einkopieren, Return: Buffer  */
  266.   *bp = '\n';
  267.   return(buf);     /* Rueckgabe   : Buffer   */
  268.   } 
  269. }
  270.  
  271. /* ==================== zeilenteil ==================================== */
  272. /* Funktionsumfang:
  273.    Suchen des naecsten Zeilenteils.
  274.       - Schluesselworte werden von einem Zeichen ungleich 
  275.         "letter" beendet.
  276.       - Kommentarstart und Kommentarende C-Standard
  277.       - Restworte werden durch "letter" beendet, wenn sie 
  278.         mit ungleich "letter" begonnen haben, und durch
  279.         ungleich "letter" beendet, wenn sie mit "letter"
  280.         begonnen haben.
  281.         
  282.    Eingabedaten:
  283.       *tstart = Zeiger (char *) auf Start Suche im Zeilenrumpf
  284.       altkomm = Alter Kommentar beendet (int) 0/1
  285.       
  286.    Ausgabedaten:
  287.       *laenge = Anzahl der Bytes (int *) des Zeilenteils
  288.       
  289.    Rueckgabe:
  290.       Code fuer Zeilenteil (int) */
  291.       
  292. zeilenteil(tstart,altkomm,laenge)
  293. char *tstart;
  294. int altkomm,*laenge;
  295. {
  296. register int i;
  297. int code;
  298. char *c1;
  299. static char aletter = '\n'; /* Endekennung eines Schluesselwortes */
  300.  
  301. if(altkomm != 0) {    /* Unbekannter Kommentar  */
  302.     /* Kommentarende suchen */
  303.     if(scomp("*/",tstart) == 0)  {  /* Kommentarende erkannt  */
  304.       /* ------ Code und Laenge uebergeben  */
  305.       code = KOMENDE;
  306.       *laenge = 2;
  307.       }
  308.     else if(*tstart == '\n')  {  /* Zeilenende erkannt  */
  309.       /* ----- Code und Laenge uebergeben */
  310.       code = ZEILENENDE;
  311.       *laenge = 1;
  312.       } 
  313.     else {    /* Kommentarrumpf erkannt  */            
  314.       /* ------- Kommentarende oder Zeilenende suchen */
  315.       c1 = tstart;
  316.       while(*(++c1) != '\n') { /* Ungleich Zeilenende */
  317.         /* ---- Bis ev. Zeilenende suchen */
  318.         if(scomp("*",c1) == 0)  /* Kommentarende  */
  319.              break;  /* Scleifenabbruch  */
  320.         }
  321.       *laenge = c1-tstart;           
  322.       code = KOMRUMPF;    /* Kommentarrumpfmerker  */
  323.       }
  324.     } 
  325. else {     /* Kein unbeendeter Kommentar */
  326.     /* ------- Schluesselworte und Kommentare suchen */
  327.     if(*tstart == '\n')   { /*  Zeilenende erkannt  */
  328.         /* ----- Code und Laenge uebergeben   */
  329.         code = ZEILENENDE;
  330.         *laenge = 1;
  331.         aletter = '\n';
  332.         }
  333.     else if(scomp("/*",tstart) == 0)  {  /* Kommentarstart erkannt */
  334.         /* ---- Code und Laenge uebergeben  */
  335.         code = KOMSTART;
  336.         *laenge = 2;
  337.         aletter = '*';
  338.         }
  339.     else if(*tstart == '{')  { /* Klammer "{" erkannt  */
  340.         /* ---- Code und Laenge uebergeben */
  341.         code = BLOCKSTART;
  342.         *laenge = 1;
  343.         aletter = '{';
  344.         }
  345.     else if(*tstart == '}')  {  /* Klammer "}" erkannt  */
  346.         /*  Code und Laenge uebergeben */
  347.         code = BLOCKENDE;
  348.         *laenge = 1;
  349.         aletter = '}';
  350.         }
  351.     else if(*tstart=='"' && aletter!='\'')  {  /* Stringstart  */
  352.         /* ------ String als Rest-Zeichenkette abarbeiten  */
  353.         c1 = tstart+1;
  354.         aletter = '"';
  355.         while(*c1 !='"')  {  /* Kein zweites Anfuehrungszeichen  */
  356.           /* --- Bzpass String */
  357.           if(*c1 == '\n')  {  /* Zeilenende erkant  */
  358.              /* ---- Sonderbehandlung durch unbeendeten String  */
  359.              c1--;
  360.              aletter = '\n';
  361.              break;   /* Schleifenabbruch  */
  362.              }
  363.           c1++;
  364.           }
  365.         code = REST;    /* Rest-Merker  */
  366.         *laenge = c1-tstart+1;   /* Laenge des Strings  */
  367.         }
  368.      else if(letter(aletter)!=0    /* Letz. Zeichen nicht Typ letter  */
  369.         &&(i=schlwort(tstart,&code))!=0) { /*  Scl.-Wort erkannt  */ 
  370.           /*  ------ Laenge uebergeben */
  371.           *laenge = i;   /* Laenge Schluesselwort  */
  372.           aletter = *(tstart+i-1);
  373.           }
  374.     else {   /* Rest-Yeichen, Laenge immer 1  */
  375.        /* ---- Code und Laenge uebergeben  */
  376.        code = REST;
  377.        *laenge = 1;
  378.        aletter = *tstart;
  379.        }
  380.     }
  381. return(code);   /* Rueckgabe : Code fuer Zeilenteil  */
  382. }
  383.  
  384. /* =====================  schlwort ====================================== */
  385. /* Funktionsumfang:
  386.           Test auf c-Schluesselwort in einem String
  387.           
  388.    Eingabedaten:
  389.          *str = Zeiger auf den zu untersuchenden String (char *)
  390.          
  391.    Ausgabedaten:T
  392.   T       *code = code des gefundenen Schluesselwortes (int *)
  393.          
  394.    Rueckgabe:
  395.          Laenge des gefundenen Schluesselwortes (int)
  396.          0, wenn kein Schluesselwort gefunden wurde. In diesem
  397.          Fall wird *code auch nicht veraendert.                    */
  398.  
  399. schlwort(str,code)
  400. char *str;
  401. int *code;
  402. {
  403.     
  404. static char *schlw[] = {"if","else","while","for","do",
  405.                         "continue","break","return","goto","case",
  406.                         "switch","default","main"};
  407.  
  408. register int i,match,lang;
  409. char *c1;
  410.  
  411. match = 0;   /* Merker kein Schluesselwort  */
  412. for(i=0;i<13;i++)   {   /* Alle  Schluesselworte  /
  413.    /*  --- Test auf Uebereinstimmung mit Schluesselwort  */
  414.    lang = strlen(schlw[i]);   /*  laenge Schluesselwort  */
  415.    if(scomp(schlw[i],str)==0 && letter(*(str+lang))!=0)  { /* Schluesselw. */
  416.       /* ------  Merker und Code setzen */
  417.       match =1;  /* merker schluesselwort setzen */
  418.       *code = i+20;   /* Offset 20 in defines fuer Codes  */
  419.       break;   /*Schleifenabbruch  */
  420.       }     
  421.    }
  422. if(match == 0)  {  /* Bisher kein Schluesselwort gefunden  */
  423.      /* ---- Testauf Label  */
  424.      if(letter(*str) == 0)  {  /* 1.Zeichen Typ letter  */
  425.          /* ------ Auf Label untersuchen  */
  426.          for(i=2,c1=str+1;*c1!='\n';i++,c1++)   {  /* Bis Z.Ende   */
  427.            /* ----- Bis ev.  \n suchen  */
  428.            if(*c1 == ':')   {  /* Ende Label  */
  429.                /* ----- Merker Label und Code setzen  */
  430.                match = 1;   /* Merker Schluesselwort  */
  431.                *code = LABEL;
  432.                lang = i;
  433.                break;   /* Schleifenabbruch  */
  434.                }
  435.            if(letter(*c1) != 0)  /* Typ ungleich letter  */
  436.                break;  /*  Schleifenabbruch  */
  437.            }
  438.          }
  439.       }
  440. if(match == 1)   /* Schluesselwort gefunden  */
  441.    return(lang);   /* returns:  Laenge des Schluesselwortes  */
  442. else  /* Kein Schluesselwort gefunden  */
  443.    return(0);    /* returns: 0, wenn kein Schluesselwort   */
  444. }
  445.  
  446.  
  447.  
  448. /* =========================  letter  ==============================  */
  449. /* Funktionsumfang:
  450.            Erkennen der Zeichen vom Typ letter :
  451.            _, a..z, A..Z, 0..9
  452.            
  453.    Eingabedaten:
  454.            z  (char) = Zu untersuchendes Zeichen
  455.            
  456.    Ausgabedaten:
  457.            
  458.           
  459.    Rueckgabe :
  460.            0 (int) wenn Zeichen vom Typ "letter"
  461.            -1(int) wenn Zeichen nicht vom Typ "letter"   */
  462.            
  463. letter(z)
  464. char z;
  465. {
  466. if(z=='_' || (z>='a'&&z<='z')  || (z>='A'&&z<='Z') || (z>='0'&&z<='9'))
  467.                   /* Zeichentyp "letter"  */
  468.    return(0);  /* Rueckgabe  : Typ letter  */
  469. else     /* Zeichen nicht vom Typ "letter"  */
  470.    return(-1);   /* Rueckgabe :  Nicht Letter  */
  471. }
  472.  
  473.  
  474.  
  475. /* =====================  scomp ========================================== */
  476. /* Funktionsumfang:
  477.      Vergleich eines Strings mit einem zweiten String.
  478.      Der erste String muss nullterminiert sein.
  479.      
  480.    Eingangsdaten:
  481.        *str1 = Zeiger vom Typ (char *) auf den ersten String
  482.        *str2 = Zeiger vom Typ (char *) auf den zweiten String
  483.        
  484.    Ausgangsdaten:
  485.        -
  486.        
  487.    Rueckgabe :
  488.        (int) 0 = Strings identisch
  489.        (int)-1 = Strings nicht identisch  */
  490.  
  491.  
  492. scomp(str1,str2)
  493. char *str1,*str2;
  494. {
  495. char c;
  496. while((c=*(str1++)) != 0) {  /* KeinStringende  */
  497.     /*  ------ Strings zeichenweise vergleichen  */
  498.     if(c != *(str2++))  /* String1 ungleich String2  */
  499.         return(-1);     /* Return: Strings ungleich  */
  500.     }
  501. return(0);    /* Return:  Strings gleich  */
  502. }
  503.  
  504.  
  505. /*  =========================  boldface  ===============================  */
  506. /* Funktionsumfang:
  507.           In einen String werden SteuerZeichen zum Ein- bzw Ausschalten des
  508.           hervorgehobenen Drucks beim Drucker STAR SR-XX einkopiert
  509.           
  510.    Eingabedaten:
  511.           start = 0/1 (int) 0: Stop-, 1: Startsequenz
  512.           
  513.    Ausgabedaten:
  514.           **str  : Veraenderter Zeiger auf einen Zeiger auf den String
  515.           
  516.    Rueckgabe :
  517.           -           */
  518.           
  519.  
  520. boldface(str,start)
  521. char **str;
  522. int start;
  523. {
  524.     
  525. if(start == 1)   {  /* Startsequenz   */
  526.      /* ------- Startsequenz einkopieren  */
  527.      *((*str)++) = 0x1B;
  528.      *((*str)++) = 'G';
  529.      }
  530. else    {  /* Stoppsequenz  */
  531.      /*  ---- Stoppsequenz einkopieren  */
  532.      *((*str)++) = 0x1b;
  533.      *((*str)++) = 'H';
  534.      }
  535. }
  536.  
  537.  
  538.                                                            
  539.                                                                            
  540.                                                                           
  541.                                                                          
  542.                                                                         
  543.                                                                                
  544.  
  545.                      
  546.  
  547.                        
  548.                      
  549.            
  550.            
  551.            
  552.           
  553.          
  554.                                          
  555.