Line data    Source code

       1             : /***************************************************************************//**
       2             : 
       3             :   @file         string.c
       4             : 
       5             :   @author       Stephen Brennan
       6             : 
       7             :   @date         Created Friday, 10 July 2015
       8             : 
       9             :   @brief        Libstephen string utilities!
      10             : 
      11             :   @copyright    Copyright (c) 2015-2016, Stephen Brennan.  Released under the
      12             :                 Revised BSD License.  See LICENSE.txt for details.
      13             : 
      14             : *******************************************************************************/
      15             : 
      16             : #include <stdio.h>
      17             : #include <wchar.h>
      18             : 
      19             : #include "libstephen/ll.h"
      20             : #include "libstephen/cb.h"
      21             : 
      22           1 : char *read_file(FILE *f)
      23             : {
      24             :   cbuf cb;
      25             :   int c;
      26           1 :   cb_init(&cb, 1024);
      27             : 
      28          73 :   while ((c = fgetc(f)) != EOF) {
      29          71 :     cb_append(&cb, c);
      30             :   }
      31             : 
      32           1 :   cb_trim(&cb);
      33           1 :   return cb.buf;
      34             : }
      35             : 
      36           1 : wchar_t *read_filew(FILE *f)
      37             : {
      38             :   wcbuf wcb;
      39             :   wint_t wc;
      40           1 :   wcb_init(&wcb, 1024);
      41             : 
      42          73 :   while ((wc = fgetwc(f)) != WEOF) {
      43          71 :     wcb_append(&wcb, wc);
      44             :   }
      45             : 
      46           1 :   wcb_trim(&wcb);
      47           1 :   return wcb.buf;
      48             : }
      49             : 
      50           3 : char *read_line(FILE *file)
      51             : {
      52             :   cbuf cb;
      53             :   int c;
      54           3 :   cb_init(&cb, 256);
      55             : 
      56          75 :   while ((c = fgetc(file)) != EOF && c != '\n') {
      57          69 :     cb_append(&cb, c);
      58             :   }
      59             : 
      60           3 :   cb_trim(&cb);
      61           3 :   return cb.buf;
      62             : }
      63             : 
      64           3 : wchar_t *read_linew(FILE *file)
      65             : {
      66             :   wcbuf wcb;
      67             :   wint_t wc;
      68           3 :   wcb_init(&wcb, 256);
      69             : 
      70          75 :   while ((wc = fgetwc(file)) != WEOF && wc != L'\n') {
      71          69 :     wcb_append(&wcb, wc);
      72             :   }
      73             : 
      74           3 :   wcb_trim(&wcb);
      75           3 :   return wcb.buf;
      76             : }
      77             : 
      78           2 : smb_ll *split_lines(char *source)
      79             : {
      80             :   char *start;
      81             :   smb_ll *list;
      82             :   DATA d;
      83             : 
      84             :   /*
      85             :     We go through `source` looking for every newline, replace it with NUL, and
      86             :     add the beginnig of the line to the list.
      87             :    */
      88           2 :   start = source;
      89           2 :   list = ll_create();
      90          39 :   while (*source != '\0') {
      91          35 :     if (*source == '\n') {
      92             :       // Add line to list.
      93           5 :       d.data_ptr = start;
      94           5 :       ll_append(list, d);
      95             :       // Null-terminate the line.
      96           5 :       *source = '\0';
      97             :       // Next string starts at the next character.
      98           5 :       start = source + 1;
      99             :     }
     100          35 :     source++;
     101             :   }
     102           2 :   if (start != source) {
     103           1 :     d.data_ptr = start;
     104           1 :     ll_append(list, d);
     105             :   }
     106           2 :   return list;
     107             : }
     108             : 
     109           2 : smb_ll *split_linesw(wchar_t *source)
     110             : {
     111             :   wchar_t *start;
     112             :   smb_ll *list;
     113             :   DATA d;
     114             : 
     115             :   /*
     116             :     We go through `source` looking for every newline, replace it with NUL, and
     117             :     add the beginnig of the line to the list.
     118             :    */
     119           2 :   start = source;
     120           2 :   list = ll_create();
     121          39 :   while (*source != L'\0') {
     122          35 :     if (*source == L'\n') {
     123             :       // Add line to list.
     124           5 :       d.data_ptr = start;
     125           5 :       ll_append(list, d);
     126             :       // Null-terminate the line.
     127           5 :       *source = L'\0';
     128             :       // Next string starts at the next character.
     129           5 :       start = source + 1;
     130             :     }
     131          35 :     source++;
     132             :   }
     133           2 :   if (start != source) {
     134           1 :     d.data_ptr = start;
     135           1 :     ll_append(list, d);
     136             :   }
     137           2 :   return list;
     138             : }