home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1989 / 12 / praxis / sdr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-09-08  |  12.7 KB  |  441 lines
  1. /* ------------------------------------------------------ */
  2. /*                        SDR.C                           */
  3. /*              Search, Delete, Replace                   */
  4. /*         (c) 1989 A. Krempl   &  TOOLBOX                */
  5. /* ------------------------------------------------------ */
  6. #include <stdio.h>
  7. #include <string.h>
  8. #include <ctype.h>
  9.  
  10. /* -------------- Definitionen -------------------------- */
  11. #define COPYRIGHT    " (c) 1989 A.Krempl & TOOLBOX"
  12. #define BOOL         int
  13. #define TRUE         1
  14. #define FALSE        0
  15. #define MAX_STRING   255
  16.  
  17. /* -------------- Funktionsdeklarationen ---------------- */
  18. void param_check(int, char **); /* Parameter-Auswertung   */
  19. void mode_check(int, char **);  /* Mode-Einstellung       */
  20. void open_input(int, char **);  /* Eing. Datei öffnen     */
  21. void open_output(int, char **); /* Ausg. Datei öffnen     */
  22. void ascii_mode(int, char **);  /* ASCII-Bearbeitung      */
  23. void usage(char *);             /* Hilfetext              */
  24.  
  25. /* String Functionen */
  26. int  str_index(char *, char *, BOOL);
  27. int  remove_substring(char *, int, int);
  28. int  insert_string(char *, char *, int);
  29.  
  30. /* -------------- Globale Deklarationen ----------------- */
  31. FILE *fopen(),
  32.      *input_file,               /* ASCII Filepointer      */
  33.      *output_file;
  34.  
  35. char readmode[4],
  36.      writemode[4];
  37.  
  38. /* -------------- Schalter (Parameter Status) ----------- */
  39. BOOL search      = FALSE;       /* Such Modus             */
  40. BOOL delete      = FALSE;       /* Lösch Modus            */
  41. BOOL replace     = FALSE;       /* Ersetzen Modus         */
  42. BOOL replaceplus = FALSE;       /* Ersetzen+ Modus        */
  43. BOOL u_case      = FALSE;       /* Groß-, Kleinschreibung */
  44.  
  45. /* -------------- Veränderbare Parameterpositionen ------ */
  46. int  switch_index  = 1;         /* Schalter in argv[]     */
  47. int  line_index    = 2;         /* Zeilen-Suchstring      */
  48. int  search_index  = 2;         /* Suchstring in argv[]   */
  49. int  replace_index = 3;         /* Ersatzstring in argv[] */
  50. int  input_index   = 3;         /* Eingangsfile in argv[] */
  51. int  output_index  = 4;         /* Ausgangsfile in argv[] */
  52.  
  53.  
  54. /* -------------  Hauptprogramm  ------------------------ */
  55. main(argc, argv)
  56.  
  57. int  argc;
  58. char *argv[];
  59. {
  60.                   /* Vorbereitung         */
  61.    param_check(argc, argv);       /* Parameter-Auswertung */
  62.    mode_check(argc, argv);        /* Mode-Einstellung     */
  63.    open_input(argc, argv);        /* Eingangsdatei öffnen */
  64.    open_output(argc, argv);       /* Ausgangsdatei öffnen */
  65.  
  66.    ascii_mode(argc, argv);        /* ASCII-Bearbeitung    */
  67.  
  68.    exit(0);
  69. }
  70.  
  71. /* ------------  Parameter Prüfung  --------------------- */
  72. void param_check(arg_c, arg_v)
  73. int  arg_c;
  74. char *arg_v[];
  75. {
  76.                /* Argumentenanzahl überprüfen */
  77.    if(arg_c < 4)
  78.    {
  79.      usage(arg_v[0]);
  80.    }
  81.                /* Schalter feststellen        */
  82.                /* Suchen                      */
  83.    if(str_index("-s-S", arg_v[switch_index], FALSE) != -1)
  84.    {
  85.      search = TRUE;
  86.      if(strcmp(arg_v[switch_index], "-S") == 0)
  87.        u_case = TRUE;
  88.    }
  89.                /* Löschen                     */
  90.    else if(str_index("-d-D", arg_v[switch_index],
  91.        FALSE) != -1)
  92.    {
  93.      delete = TRUE;
  94.      if(strcmp(arg_v[switch_index], "-D") == 0)
  95.        u_case = TRUE;
  96.    }
  97.                /* Ersetzen                    */
  98.    else if(str_index("-r-R", arg_v[switch_index],
  99.        FALSE) != -1)
  100.    {
  101.      replace = TRUE;
  102.      if(strcmp(arg_v[switch_index], "-R") == 0)
  103.        u_case = TRUE;
  104.      input_index++;        /* Eingangsdatei in argv[]     */
  105.      output_index++;       /* Ausgangsdatei in argv[]     */
  106.    }
  107.                /* Zeilen - Ersetzen           */
  108.    else if(str_index("+r+R", arg_v[switch_index],
  109.        FALSE) != -1)
  110.    {
  111.      replaceplus = TRUE;
  112.      if(strcmp(arg_v[switch_index], "+R") == 0)
  113.        u_case = TRUE;
  114.      search_index++;       /* Suchstring in argv[]        */
  115.      replace_index++;      /* Ersatzstring in argv[]      */
  116.      input_index++;        /* Eingangsdatei in argv[]     */
  117.      input_index++;
  118.      output_index++;       /* Ausgangsdatei in argv[]     */
  119.      output_index++;
  120.    }
  121.                /* Nicht gültiger Parameter    */
  122.    else
  123.    {
  124.      usage(arg_v[0]);
  125.    }
  126. }
  127.  
  128. /* ------------  Modus überprüfen  ---------------------- */
  129. void mode_check(arg_c, arg_v)
  130. int  arg_c;
  131. char *arg_v[];
  132. {
  133.    arg_c = arg_c;          /* Dummy, falls noch gebraucht */
  134.  
  135.        /* Bei SEARCH Dateinamen auf Gleichheit prüfen */
  136.    if(search)
  137.    {
  138.      if(strcmp(arg_v[input_index], arg_v[output_index])
  139.     == 0)
  140.      {
  141.        printf("Bei [-s] darf Quelle und Ziel nicht ");
  142.        printf("gleich sein.\n");
  143.        exit(-1);
  144.      }
  145.    }
  146.              /* File-Eröffnungsmode festlegen */
  147.    strcpy(readmode, "r+");
  148.    strcpy(writemode, "w+");
  149. }
  150.  
  151. /* ---------  Eingangsdatei eröffnen  ------------------- */
  152. void open_input(arg_c, arg_v)
  153. int  arg_c;
  154. char *arg_v[];
  155. {
  156.             /* Angabe auf Eingabedatei überprüfen */
  157.    if(search && (arg_c < 4))
  158.      usage(arg_v[0]);
  159.    else if(delete && (arg_c < 4))
  160.      usage(arg_v[0]);
  161.    else if(replace && (arg_c < 5))
  162.      usage(arg_v[0]);
  163.    else if(replaceplus && (arg_c < 6))
  164.      usage(arg_v[0]);
  165.    else
  166.    {
  167.             /* Eingabedatei auf öffnen prüfen */
  168.      if((input_file = fopen(arg_v[input_index],
  169.     readmode)) == NULL)
  170.      {
  171.        printf("\nFehler bei öffnen von %s\n",
  172.           arg_v[input_index]);
  173.        exit(-1);
  174.      }
  175.    }
  176. }
  177.  
  178. /* ----------  Ausgangsdatei eröffnen  ------------------ */
  179. void open_output(arg_c, arg_v)
  180. int  arg_c;
  181. char *arg_v[];
  182. {
  183.        /* Auf Ausgangsdatei prüfen oder auf stdout setzen */
  184.     if(search && (arg_c == 4))
  185.       output_file = stdout;
  186.     else if(delete && (arg_c == 4))
  187.       output_file = stdout;
  188.     else if(replace && (arg_c == 5))
  189.       output_file = stdout;
  190.     else if(replaceplus && (arg_c == 6))
  191.       output_file = stdout;
  192.     else
  193.     {
  194.             /* Ausgabedatei auf öffnen prüfen */
  195.       if((output_file = fopen(arg_v[output_index],
  196.      writemode)) == NULL)
  197.       {
  198.     printf("\nFehler bei öffnen von %s\n",
  199.            arg_v[output_index]);
  200.     exit(-1);
  201.        }
  202.     }
  203. }
  204.  
  205. /* --------  Bearbeitung im ASCII Modus  ---------------- */
  206. void ascii_mode(arg_c, arg_v)
  207. int  arg_c;
  208. char *arg_v[];
  209. {
  210.    BOOL line = FALSE;          /* Bei +r Zeile gefunden ? */
  211.    int  location,
  212.     length;                /* Länge Teilzeichenkette  */
  213.                /* aus Datei gelesene Zeichenkette */
  214.    unsigned char string[MAX_STRING];
  215.  
  216.    arg_c = arg_c;          /* Dummy, falls noch gebraucht */
  217.  
  218.              /* Länge des Suchstrings feststellen */
  219.    length = strlen(arg_v[search_index]);
  220.  
  221.                  /* Suchen, löschen, ersetzen */
  222.    if(!replaceplus)
  223.    {
  224.      while(fgets(string, MAX_STRING, input_file))
  225.      {
  226.              /* solange Teilstring enthalten  */
  227.        while((location = str_index(string,
  228.          arg_v[search_index], u_case)) != -1)
  229.        {
  230.      if(search)
  231.      {
  232.                /* nichts ändern, String schreiben */
  233.        fputs(string, output_file);
  234.        break;
  235.      }
  236.      else if(delete)
  237.      {
  238.                /* Entferne den zu löschenden Teil */
  239.        remove_substring(string, location, length);
  240.      }
  241.      else if(replace)
  242.      {
  243.               /* Entferne den zu ersetzenden Teil */
  244.        remove_substring(string, location, length);
  245.  
  246.                   /* Füge neuen Substring ein */
  247.        insert_string(string, arg_v[replace_index],
  248.              location);
  249.      }
  250.        }
  251.        if(!search)
  252.        {
  253.              /* Neuen String wieder schreiben */
  254.      fputs(string, output_file);
  255.        }
  256.      }     /* while(fgets ... */
  257.    }       /* if(!replaceplus) */
  258.  
  259.               /* Suchen, ersetzen mit Zeilenindex */
  260.    if(replaceplus)
  261.    {
  262.      while(fgets(string, MAX_STRING, input_file))
  263.      {
  264.                    /* Zuerst Zeile suchen */
  265.        while((location = str_index(string,
  266.          arg_v[line_index], u_case)) != -1)
  267.        {
  268.      line = TRUE;
  269.      break;
  270.        }
  271.                /* Nur bei gefundener Zeile ändern */
  272.        if(line)
  273.        {
  274.               /* solange Teilstring enthalten */
  275.      while((location = str_index(string,
  276.            arg_v[search_index], u_case)) != -1)
  277.      {
  278.               /* Entferne den zu ersetzenden Teil */
  279.        remove_substring(string, location, length);
  280.  
  281.                   /* Füge neuen Substring ein */
  282.        insert_string(string, arg_v[replace_index],
  283.              location);
  284.  
  285.      }   /* while((location ... */
  286.        }     /* if(line) */
  287.  
  288.              /* Neuen String wieder schreiben */
  289.        fputs(string, output_file);
  290.        line = FALSE;
  291.  
  292.      }    /* while(fgets ... */
  293.    }      /* if(replaceplus) */
  294.  
  295.    fclose(input_file);
  296.    fclose(output_file);
  297.  
  298. }
  299.  
  300. /* -------------  Anwendungshilfe  ---------------------- */
  301. void usage(name)
  302. char *name;
  303. {
  304.    printf("\n");
  305.    printf("%s\n\n", COPYRIGHT);
  306.    printf(" Usage: %s  -[s][d][r]  String  ", name);
  307.    printf("[String]  Quelle [Ziel]\n\n"),
  308.    printf("       Suchen   [-s]:\n");
  309.    printf("        %s  -s  String  Quelle\n", name);
  310.    printf("       Löschen  [-d]:\n");
  311.    printf("        %s  -d  String  Quelle\n", name);
  312.    printf("       Ersetzen [-r]:\n");
  313.    printf("        %s  -r  String1  String2  ", name);
  314.    printf("Quelle  Ziel\n");
  315.    printf("       Ersetzen [+r]: Nur in Zeilen mit ");
  316.    printf("String1 (Nur ASCII)\n");
  317.    printf("        %s  +r  String1  String2  ", name);
  318.    printf("String3  Quelle  Ziel\n\n"),
  319.    printf(" -s, -d, -r  Groß-, Kleinschreibung aktiv\n");
  320.    printf(" -S, -D, -R       -- \" --           ");
  321.    printf("ausgeschaltet\n");
  322.    printf(" Die Zeilenlänge ist auf 255 Zeichen ");
  323.    printf("beschränkt (ASCII-Datei).");
  324.    printf(" Bei Ersatz durch\n");
  325.    printf(" längere  Strings ist darauf zu achten.  ");
  326.    printf("Wird keine  Zieldatei ");
  327.    printf(" angegeben, gilt\n");
  328.    printf(" Standard-Out.  Falls  Zieldatei = ");
  329.    printf("Quelldatei, nach Möglichkeit");
  330.    printf(" gleiche String-\n");
  331.    printf(" längen benutzen. Leerzeichen und ");
  332.    printf("Sonderzeichen als Parameter");
  333.    printf(" müßen unter Hoch-\n");
  334.    printf(" komma gesetzt werden.\n");
  335.  
  336.    exit(-1);
  337. }
  338.  
  339. /* -------  Position von Substring zurückgeben  --------- */
  340. int str_index(string, substring, u_case)
  341. char string[];
  342. char substring[];
  343. int  u_case;
  344.  
  345. {
  346.    int i, j, k;
  347.  
  348.    if(u_case == FALSE)
  349.    {
  350.      for(i = 0; string[i] != NULL; i++)
  351.      {
  352.        for(j = i, k = 0; substring[k] == string[j];
  353.        k++, j++)
  354.        {
  355.      if(substring[k + 1] == NULL)
  356.        return(i);         /* Substring wurde gefunden */
  357.        }
  358.      }
  359.      return(-1);              /* Substring nicht gefunden */
  360.    }
  361.    else
  362.    {
  363.      for(i = 0; string[i] != NULL; i++)
  364.      {
  365.        for(j = i, k = 0; toupper(substring[k]) ==
  366.        toupper(string[j]); k++, j++)
  367.        {
  368.      if(substring[k + 1] == NULL)
  369.        return(i);         /* Substring wurde gefunden */
  370.        }
  371.      }
  372.      return(-1);              /* Substring wurde gefunden */
  373.    }
  374. }
  375.  
  376. /* -------  Substring aus String herausnehmen  ---------- */
  377. int remove_substring(string, first, num_char)
  378. char string[];
  379. int  first;           /* Pos. des ersten zu entf. Zeichen */
  380. int  num_char;        /* Anzahl der zu entf. Zeichen      */
  381.  
  382. {
  383.    int length;        /* Länge von String                 */
  384.    int index1;        /* zeigt auf 1. zu entf. Zeichen    */
  385.    int index2;        /* zeigt auf 1. verbl. Zeichen      */
  386.  
  387.    length = strlen(string);
  388.    if(first >= length || first < 0)
  389.      return(-1);             /* ungültige Anfangsposition */
  390.  
  391.    if(first + num_char <= length)
  392.      index2 = first + num_char;
  393.    else
  394.      index2 = length;        /* lösche nur bis NULL       */
  395.  
  396.                          /* entfernen */
  397.    for(index1 = first; (string[index1] = string[index2])
  398.        != '\0'; index1++)
  399.    {
  400.      index2++;
  401.    }
  402. }
  403.  
  404. /* -------- Substring in String einfügen ---------------- */
  405. int insert_string(string, substring, location)
  406. char string[];
  407. char substring[];             /* einzufügender Teilstring */
  408. int  location;
  409.  
  410. {
  411.    int  index1;          /* Index innerhalb von string    */
  412.    int  index2;          /* Index innerhalb von substring */
  413.    int  index_temp;      /* Index innerhalb von temp      */
  414.    char temp[MAX_STRING]   ;  /* Temporärer String        */
  415.  
  416.             /* Überprüfen der Positionsangabe */
  417.    if(location >= strlen(string))
  418.      return(-1);
  419.  
  420.             /* Zeichen auf temp kopieren      */
  421.    for(index_temp = 0, index1 = 0; index1 < location;
  422.        index1++, index_temp++)
  423.    {
  424.      temp[index_temp] = string[index1];
  425.    }
  426.  
  427.                 /* substring an temp anhängen */
  428.    for(index2 = 0; substring[index2] != NULL; ++index2,
  429.        index_temp++)
  430.    {
  431.      temp[index_temp] = substring[index2];
  432.    }
  433.  
  434.               /* Rest von string an temp anhängen */
  435.    while((temp[index_temp++] = string[index1++]) != '\0');
  436.  
  437.             /* Zurückgeben von temp an string */
  438.    strcpy(string, temp);
  439. }
  440. /* ------------------------------------------------------ */
  441. /*                 Ende von SDR.C                         */