Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	src/air/string.c	Lines:	126	156	80.8 %
Date:	2017-05-26	Branches:	77	114	67.5 %


/*
  Teem: Tools to process and visualize scientific data and images             .
  Copyright (C) 2013, 2012, 2011, 2010, 2009  University of Chicago
  Copyright (C) 2008, 2007, 2006, 2005  Gordon Kindlmann
  Copyright (C) 2004, 2003, 2002, 2001, 2000, 1999, 1998  University of Utah

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public License
  (LGPL) as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
  The terms of redistributing and/or modifying this software also
  include exceptions to the LGPL that facilitate static linking.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with this library; if not, write to Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "air.h"

/* this has to default to false in order for airStrtok to be a
   functional substitute for strtok() */
int airStrtokQuoting = AIR_FALSE;

/*
******** airStrdup()
**
** because they didn't put strdup() in ANSI.
** This will return NULL if given NULL.
*/
char *
airStrdup(const char *s) {
  char *ret;

  if (!s) {
    ret = NULL;
  }
  else {
    ret = (char *)malloc(strlen(s)+1);
    if (ret) {
      strcpy(ret, s);
    }
  }
  return ret;
}

/*
******** airStrlen()
**
** just like strlen, but safe to call on NULL (for which return is 0)
*/
size_t
airStrlen(const char *s) {
  size_t ret;

  if (!s) {
    ret = 0;
  }
  else {
    ret = strlen(s);
  }
  return ret;
}

/* ---- BEGIN non-NrrdIO */
/*
******** airStrcmp
**
** like strcmp, but:
** safe to call with NULL strings,
** and, a NULL string is treated same as an empty string
*/
int
airStrcmp(const char *_s1, const char *_s2) {
  static const char empty[]="";
  const char *s1, *s2;
  int ret;

  s1 = _s1 ? _s1 : empty;
  s2 = _s2 ? _s2 : empty;
  /*
  fprintf(stderr, "airStrcmp: _s1=|%s|->s1=|%s| _s2=|%s|->s2=|%s|\n",
          _s1 ? _s1 : "(NULL)", s1,
          _s2 ? _s2 : "(NULL)", s2);
  */
  ret = strcmp(s1, s2);
  return ret;
}

/* ---- END non-NrrdIO */
/*
******** airStrtok()
**
** thread-safe strtok() replacement.  Use just like strtok(), but on
** each call to parse a given string, pass as the last argument the
** address of a char*, to be used for saving state while the string is
** traversed.  Like strtok(), this will alter the "s" array passed to
** it on the first call, and like strtok(), this returns pointers into
** this string (rather than allocating new strings for each token).
*/
char *
airStrtok(char *s, const char *ct, char **last) {
  char *h, *e, *q;

  if (!(ct && last)) {
    /* can't do any work, bail */
    return NULL;
  }
  h = s ? s : *last;
  if (!airStrlen(h))
    return NULL;
  h += strspn(h, ct);
  if ('\"' == *h && airStrtokQuoting) {
    /* something is trying to be quoted, and, we'll respect that */
    /* have to find the next un-escaped '\"' */
    h++;
    q = h;
    while (*q && !('\"' == *q && '\\' != q[-1])) {
      q++;
    }
    if (*q) {
      /* we found an unescaped '\"' */
      e = q;
    } else {
      /* give up; pretend we never tried to do this quoting stuff */
      e = h + strcspn(h, ct);
    }
  } else {
    e = h + strcspn(h, ct);
  }
  if ('\0' == *e) {
    *last = e;
  }
  else {
    *e = '\0';
    *last = e + 1;
  }
  return h;
}

/*
******** airStrntok()
**
** returns the number of tokens parsable by airStrtok(), but does
** NOT alter the given string
*/
unsigned int
airStrntok(const char *_s, const char *ct) {
  char *s, *t, *l=NULL;
  unsigned int n = 0;

  if (_s && ct) {
    s = airStrdup(_s);
    t = airStrtok(s, ct, &l);
    while (t) {
      n++;
      t = airStrtok(NULL, ct, &l);
    }
    airFree(s);  /* no NULL assignment to s, else compile warnings */
  }
  return n;
}

char *
airStrtrans(char *s, char from, char to) {
  size_t i, l;

  if (s) {
    l = strlen(s);
    for (i=0; i<l; i++) {
      if (s[i] == from) {
        s[i] = to;
      }
    }
  }
  return s;
}

/*
******** airStrcpy
**
** Like strncpy but logic is different (and perhaps more useful), being:
** "dst is allocated for dstSize chars. Copy as much of src as can
** "fit in dst, and always 0-terminate the resulting dst.",
** instead of strncpy's "Copy at most n characters, blah blah blah,
** and you still have to 0-terminate the rest yourself".
**
** E.g. with declaration buff[AIR_STRLEN_SMALL], you call
** airStrcpy(buff, AIR_STRLEN_SMALL, src), and know that then
** strlen(buff) <= AIR_STRLEN_SMALL-1. (see note in air.h about
** the meaning of the STRLEN #defines).
**
** Returns NULL if there was a problem (NULL dst or dstSize zero),
** otherwise returns dst
*/
char *
airStrcpy(char *dst, size_t dstSize, const char *src) {
  size_t ii, copyLen, srcLen;

  if (!(dst && dstSize > 0)) {
    return NULL;
  }
  srcLen = airStrlen(src);
  if (1 == dstSize || !srcLen) {
    dst[0] = '\0';
    return dst;
  }
  /* else dstSize > 1  AND src is a non-empy string */
  copyLen = AIR_MIN(dstSize-1, srcLen);
  for (ii=0; ii<copyLen; ii++) {
    dst[ii] = src[ii];
  }
  dst[copyLen] = '\0';
  return dst;
}

/*
******** airEndsWith
**
** if "s" ends with "suff", then returns 1, 0 otherwise
*/
int
airEndsWith(const char *s, const char *suff) {

  if (!(s && suff))
    return 0;
  if (!(strlen(s) >= strlen(suff)))
    return 0;
  if (!strncmp(s + strlen(s) - strlen(suff), suff, strlen(suff)))
    return 1;
  else
    return 0;
}

/*
******** airUnescape()
**
** unescapes \\ and \n in place in a given string.
** Always returns the same pointer as given
*/
char *
airUnescape(char *s) {
  size_t i, j, len;
  int found=0;

  len = airStrlen(s);
  if (!len)
    return s;

  for (i=1, j=0; i<len; i++, j++) {
    if (s[i-1] == '\\' && s[i] == '\\') {
      s[j] = '\\'; i++; found = 1;
    } else if (s[i-1] == '\\' && s[i] == 'n') {
      s[j] = '\n'; i++; found = 1;
    } else {
      s[j] = s[i-1]; found = 0;
    }
  }
  if (i == len || !found) s[j++] = s[len-1];
  s[j] = 0;

  return s;
}

/*
******** airOneLinify()
**
** converts all contiguous white space (as determined by isspace()) to
** a single ' ', entirely removes non-printable (as determined by
** isprint()) characters, and entirely removes white space contiguous
** with the end of the string, even if that means shrinking the string
** to "".
**
** Useful for cleaning up lines of text to be saved as strings in
** fields of other structs.
**
** Whatever happens, this returns the pointer passed to it
*/
char *
airOneLinify(char *s) {
  size_t i, j, len;

  len = airStrlen(s);
  if (!len)
    return s;

  /* convert white space to space (' '), and delete unprintables */
  for (i=0; i<len && s[i]; i++) {
    if (isspace(AIR_CAST(int, s[i]))) {
      s[i] = ' ';
      continue;
    }
    if (!isprint(AIR_CAST(int, s[i]))) {
      for (j=i; j<len; j++) {
        /* this will copy the '\0' at the end */
        s[j] = s[j+1];
      }
      i--;
      continue;
    }
  }

  /* compress all contiguous spaces into one */
  for (i=0; i<len; i++) {
    while (' ' == s[i] && ' ' == s[i+1]) {
      for (j=i+1; j<len; j++) {
        s[j] = s[j+1];
      }
    }
  }

  /* lose trailing white space */
  i = airStrlen(s);
  if (' ' == s[i-1]) {
    s[i-1] = '\0';
  }

  return s;
}

/*
******** airToLower()
**
** calls tolower() on all characters in a string, and returns the same
** pointer that it was given
*/
char *
airToLower(char *str) {
  char *c;

  if (str) {
    c = str;
    while (*c) {
      *c = AIR_CAST(char, tolower(AIR_INT(*c)));
      c++;
    }
  }
  return str;
}

/*
******** airToUpper()
**
** calls toupper() on all characters in a string, and returns the same
** pointer that it was given
*/
char *
airToUpper(char *str) {
  char *c;

  if (str) {
    c = str;
    while (*c) {
      *c = AIR_CAST(char, toupper(AIR_INT(*c)));
      c++;
    }
  }
  return str;
}

/*
******** airOneLine()
**
** gets one line from "file", putting it into an array of given size.
** "size" must be the size of line buffer "line": the size which
** "line" was allocated for, not the number of non-null characters it
** was meant to hold.  "size" must be at least 3.  Always
** null-terminates the contents of the array (except if the arguments
** are invalid).  The idea is that the null-termination replaces the
** line termination.
**
** 0: if saw EOF before seeing a newline, or arguments are invalid
** 1: if line was a single newline
** n; n <= size: if line was n-1 characters followed by newline
** size+1: if didn't see a newline within size-1 characters
**
** So except for returns of -1 and size+1, the return is the number of
** characters comprising the line, including the newline character.
**
** For all you DOS\Windows\Cygwin users, this will quietly pretend that
** a "\r\n" pair is really just "\n", including the way that characters
** comprising the line are counted.  However, there is no pretension
** that on those platforms, "\n" by itself does not actually count as
** a newline.
**
** Finally, for those trafficking in legacy Mac text files (for which
** the line termination is only "\r", the same applies- these are also
** effectively treated the same as a newline.
*/
unsigned int
airOneLine(FILE *file, char *line, unsigned int size) {
  int cc=0;
  unsigned int ii;

  if (!(size >= 3  /* need room for a character and a Windows newline */
        && line && file)) {
    return 0;
  }
  /* c is always set at least once, but not so for any char in line[]  */
  for (ii=0;
       (ii <= size-2              /* room for line[ii] and \0 after that */
        && EOF != (cc=getc(file)) /* didn't hit EOF trying to read char */
        && cc != '\n'             /* char isn't newline */
        && cc != '\r');           /* char isn't carriage return */
       ++ii) {
    line[ii] = AIR_CAST(char, cc);
  }

  if (EOF == cc) {
    /* for-loop terminated because we hit EOF */
    line[0] = '\0';
    return 0;
  } else if ('\r' == cc || '\n' == cc) {
    /* for-loop terminated because we hit '\n' or '\r' */
    /* if it was '\r', see if next character is '\n' */
    if ('\r' == cc) {
      cc = getc(file);
      if (EOF != cc && '\n' != cc) {
        /* oops, we got something, and it was not a '\n'; put it back */
        ungetc(cc, file);
      }
    }
    line[ii] = '\0';
    return ii+1;
  } else {
    /* for-loop terminated because we got to end of buffer (ii == size-1) */
    cc = getc(file);
    /* but see if we were about to get '\r', "\r\n", or '\n' */
    if ('\r' == cc) {
      int dd;
      dd = getc(file);
      if (EOF != dd && '\n' != dd) {
        /* oops, put it back */
        ungetc(dd, file);
      }
      line[ii] = '\0';
      return ii+1;
    } else if ('\n' == cc) {
      line[ii] = '\0';
      return ii+1;
    } else {
      /* weren't about to get a line termination,
         we really did run out of buffer */
      if (EOF != cc) {
        ungetc(cc, file);  /* we're allowed one ungetc on ANY stream */
      }
      line[size-1] = '\0';
      return size+1;
    }
  }
}



Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/*
2			Teem: Tools to process and visualize scientific data and images .
3			Copyright (C) 2013, 2012, 2011, 2010, 2009 University of Chicago
4			Copyright (C) 2008, 2007, 2006, 2005 Gordon Kindlmann
5			Copyright (C) 2004, 2003, 2002, 2001, 2000, 1999, 1998 University of Utah
6
7			This library is free software; you can redistribute it and/or
8			modify it under the terms of the GNU Lesser General Public License
9			(LGPL) as published by the Free Software Foundation; either
10			version 2.1 of the License, or (at your option) any later version.
11			The terms of redistributing and/or modifying this software also
12			include exceptions to the LGPL that facilitate static linking.
13
14			This library is distributed in the hope that it will be useful,
15			but WITHOUT ANY WARRANTY; without even the implied warranty of
16			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17			Lesser General Public License for more details.
18
19			You should have received a copy of the GNU Lesser General Public License
20			along with this library; if not, write to Free Software Foundation, Inc.,
21			51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22			*/
23
24			#include "air.h"
25
26			/* this has to default to false in order for airStrtok to be a
27			functional substitute for strtok() */
28			int airStrtokQuoting = AIR_FALSE;
29
30			/*
31			******** airStrdup()
32			**
33			** because they didn't put strdup() in ANSI.
34			** This will return NULL if given NULL.
35			*/
36			char *
37			airStrdup(const char *s) {
38			char *ret;
39
40	✓✓	27438	if (!s) {
41			ret = NULL;
42		1659	}
43			else {
44		12060	ret = (char *)malloc(strlen(s)+1);
45	✓✗	12060	if (ret) {
46		12060	strcpy(ret, s);
47		12060	}
48			}
49		13719	return ret;
50			}
51
52			/*
53			******** airStrlen()
54			**
55			** just like strlen, but safe to call on NULL (for which return is 0)
56			*/
57			size_t
58			airStrlen(const char *s) {
59			size_t ret;
60
61	✓✓	646118	if (!s) {
62			ret = 0;
63		105583	}
64			else {
65		217476	ret = strlen(s);
66			}
67		323059	return ret;
68			}
69
70			/* ---- BEGIN non-NrrdIO */
71			/*
72			******** airStrcmp
73			**
74			** like strcmp, but:
75			** safe to call with NULL strings,
76			** and, a NULL string is treated same as an empty string
77			*/
78			int
79			airStrcmp(const char _s1, const char _s2) {
80			static const char empty[]="";
81			const char s1, s2;
82			int ret;
83
84		24230	s1 = _s1 ? _s1 : empty;
85		12115	s2 = _s2 ? _s2 : empty;
86			/*
87			fprintf(stderr, "airStrcmp: _s1=\|%s\|->s1=\|%s\| _s2=\|%s\|->s2=\|%s\|\n",
88			_s1 ? _s1 : "(NULL)", s1,
89			_s2 ? _s2 : "(NULL)", s2);
90			*/
91		12115	ret = strcmp(s1, s2);
92		12115	return ret;
93			}
94
95			/* ---- END non-NrrdIO */
96			/*
97			******** airStrtok()
98			**
99			** thread-safe strtok() replacement. Use just like strtok(), but on
100			** each call to parse a given string, pass as the last argument the
101			** address of a char*, to be used for saving state while the string is
102			** traversed. Like strtok(), this will alter the "s" array passed to
103			** it on the first call, and like strtok(), this returns pointers into
104			** this string (rather than allocating new strings for each token).
105			*/
106			char *
107			airStrtok(char s, const char ct, char **last) {
108			char h, e, *q;
109
110	✗✓	99776	if (!(ct && last)) {
111			/* can't do any work, bail */
112			return NULL;
113			}
114	✓✓	149664	h = s ? s : *last;
115	✓✓	49888	if (!airStrlen(h))
116		1557	return NULL;
117		48331	h += strspn(h, ct);
118	✗✓	48331	if ('\"' == *h && airStrtokQuoting) {
119			/* something is trying to be quoted, and, we'll respect that */
120			/* have to find the next un-escaped '\"' */
121			h++;
122			q = h;
123			while (q && !('\"' == q && '\\' != q[-1])) {
124			q++;
125			}
126			if (*q) {
127			/* we found an unescaped '\"' */
128			e = q;
129			} else {
130			/* give up; pretend we never tried to do this quoting stuff */
131			e = h + strcspn(h, ct);
132			}
133			} else {
134		48331	e = h + strcspn(h, ct);
135			}
136	✓✓	48331	if ('\0' == *e) {
137		3174	*last = e;
138		3174	}
139			else {
140		45157	*e = '\0';
141		45157	*last = e + 1;
142			}
143		48331	return h;
144		49888	}
145
146			/*
147			******** airStrntok()
148			**
149			** returns the number of tokens parsable by airStrtok(), but does
150			** NOT alter the given string
151			*/
152			unsigned int
153			airStrntok(const char _s, const char ct) {
154		2674	char s, t, *l=NULL;
155			unsigned int n = 0;
156
157	✓✗	1337	if (_s && ct) {
158		1337	s = airStrdup(_s);
159		1337	t = airStrtok(s, ct, &l);
160	✓✓	49164	while (t) {
161		23245	n++;
162		23245	t = airStrtok(NULL, ct, &l);
163			}
164		1337	airFree(s); /* no NULL assignment to s, else compile warnings */
165		1337	}
166		1337	return n;
167		1337	}
168
169			char *
170			airStrtrans(char *s, char from, char to) {
171			size_t i, l;
172
173	✓✗	46156	if (s) {
174		23078	l = strlen(s);
175	✓✓	313856	for (i=0; i<l; i++) {
176	✓✓	133850	if (s[i] == from) {
177		1910	s[i] = to;
178		1910	}
179			}
180			}
181		23078	return s;
182			}
183
184			/*
185			******** airStrcpy
186			**
187			** Like strncpy but logic is different (and perhaps more useful), being:
188			** "dst is allocated for dstSize chars. Copy as much of src as can
189			** "fit in dst, and always 0-terminate the resulting dst.",
190			** instead of strncpy's "Copy at most n characters, blah blah blah,
191			** and you still have to 0-terminate the rest yourself".
192			**
193			** E.g. with declaration buff[AIR_STRLEN_SMALL], you call
194			** airStrcpy(buff, AIR_STRLEN_SMALL, src), and know that then
195			** strlen(buff) <= AIR_STRLEN_SMALL-1. (see note in air.h about
196			** the meaning of the STRLEN #defines).
197			**
198			** Returns NULL if there was a problem (NULL dst or dstSize zero),
199			** otherwise returns dst
200			*/
201			char *
202			airStrcpy(char dst, size_t dstSize, const char src) {
203			size_t ii, copyLen, srcLen;
204
205	✗✓	115772	if (!(dst && dstSize > 0)) {
206			return NULL;
207			}
208		57886	srcLen = airStrlen(src);
209	✓✓	57886	if (1 == dstSize \|\| !srcLen) {
210		2	dst[0] = '\0';
211		2	return dst;
212			}
213			/* else dstSize > 1 AND src is a non-empy string */
214		57884	copyLen = AIR_MIN(dstSize-1, srcLen);
215	✓✓	1106670	for (ii=0; ii<copyLen; ii++) {
216		495451	dst[ii] = src[ii];
217			}
218		57884	dst[copyLen] = '\0';
219		57884	return dst;
220		57886	}
221
222			/*
223			******** airEndsWith
224			**
225			** if "s" ends with "suff", then returns 1, 0 otherwise
226			*/
227			int
228			airEndsWith(const char s, const char suff) {
229
230	✗✓	50	if (!(s && suff))
231			return 0;
232	✗✓	25	if (!(strlen(s) >= strlen(suff)))
233			return 0;
234	✓✓	25	if (!strncmp(s + strlen(s) - strlen(suff), suff, strlen(suff)))
235		12	return 1;
236			else
237		13	return 0;
238		25	}
239
240			/*
241			******** airUnescape()
242			**
243			** unescapes \\ and \n in place in a given string.
244			** Always returns the same pointer as given
245			*/
246			char *
247			airUnescape(char *s) {
248			size_t i, j, len;
249			int found=0;
250
251		12	len = airStrlen(s);
252	✗✓	6	if (!len)
253			return s;
254
255	✓✓	86184	for (i=1, j=0; i<len; i++, j++) {
256	✓✓✓✓	45926	if (s[i-1] == '\\' && s[i] == '\\') {
257		1429	s[j] = '\\'; i++; found = 1;
258	✓✓✓✗	44497	} else if (s[i-1] == '\\' && s[i] == 'n') {
259		1411	s[j] = '\n'; i++; found = 1;
260		1411	} else {
261		40246	s[j] = s[i-1]; found = 0;
262			}
263			}
264	✓✗	12	if (i == len \|\| !found) s[j++] = s[len-1];
265		6	s[j] = 0;
266
267		6	return s;
268		6	}
269
270			/*
271			******** airOneLinify()
272			**
273			** converts all contiguous white space (as determined by isspace()) to
274			** a single ' ', entirely removes non-printable (as determined by
275			** isprint()) characters, and entirely removes white space contiguous
276			** with the end of the string, even if that means shrinking the string
277			** to "".
278			**
279			** Useful for cleaning up lines of text to be saved as strings in
280			** fields of other structs.
281			**
282			** Whatever happens, this returns the pointer passed to it
283			*/
284			char *
285			airOneLinify(char *s) {
286			size_t i, j, len;
287
288		1674	len = airStrlen(s);
289	✗✓	837	if (!len)
290			return s;
291
292			/* convert white space to space (' '), and delete unprintables */
293	✓✓✓✗	677268	for (i=0; i<len && s[i]; i++) {
294	✓✓	225198	if (isspace(AIR_CAST(int, s[i]))) {
295		15053	s[i] = ' ';
296		15053	continue;
297			}
298	✗✓	210145	if (!isprint(AIR_CAST(int, s[i]))) {
299			for (j=i; j<len; j++) {
300			/* this will copy the '\0' at the end */
301			s[j] = s[j+1];
302			}
303			i--;
304			continue;
305			}
306			}
307
308			/* compress all contiguous spaces into one */
309	✓✓	452070	for (i=0; i<len; i++) {
310	✓✓✓✓	240612	while (' ' == s[i] && ' ' == s[i+1]) {
311	✓✓	16362972	for (j=i+1; j<len; j++) {
312		8181125	s[j] = s[j+1];
313			}
314			}
315			}
316
317			/* lose trailing white space */
318		837	i = airStrlen(s);
319	✓✓	837	if (' ' == s[i-1]) {
320		5	s[i-1] = '\0';
321		5	}
322
323		837	return s;
324		837	}
325
326			/*
327			******** airToLower()
328			**
329			** calls tolower() on all characters in a string, and returns the same
330			** pointer that it was given
331			*/
332			char *
333			airToLower(char *str) {
334			char *c;
335
336	✓✗	648866	if (str) {
337			c = str;
338	✓✓	7092424	while (*c) {
339		3221779	c = AIR_CAST(char, tolower(AIR_INT(c)));
340		3221779	c++;
341			}
342			}
343		324433	return str;
344			}
345
346			/*
347			******** airToUpper()
348			**
349			** calls toupper() on all characters in a string, and returns the same
350			** pointer that it was given
351			*/
352			char *
353			airToUpper(char *str) {
354			char *c;
355
356			if (str) {
357			c = str;
358			while (*c) {
359			c = AIR_CAST(char, toupper(AIR_INT(c)));
360			c++;
361			}
362			}
363			return str;
364			}
365
366			/*
367			******** airOneLine()
368			**
369			** gets one line from "file", putting it into an array of given size.
370			** "size" must be the size of line buffer "line": the size which
371			** "line" was allocated for, not the number of non-null characters it
372			** was meant to hold. "size" must be at least 3. Always
373			** null-terminates the contents of the array (except if the arguments
374			** are invalid). The idea is that the null-termination replaces the
375			** line termination.
376			**
377			** 0: if saw EOF before seeing a newline, or arguments are invalid
378			** 1: if line was a single newline
379			** n; n <= size: if line was n-1 characters followed by newline
380			** size+1: if didn't see a newline within size-1 characters
381			**
382			** So except for returns of -1 and size+1, the return is the number of
383			** characters comprising the line, including the newline character.
384			**
385			** For all you DOS\Windows\Cygwin users, this will quietly pretend that
386			** a "\r\n" pair is really just "\n", including the way that characters
387			** comprising the line are counted. However, there is no pretension
388			** that on those platforms, "\n" by itself does not actually count as
389			** a newline.
390			**
391			** Finally, for those trafficking in legacy Mac text files (for which
392			** the line termination is only "\r", the same applies- these are also
393			** effectively treated the same as a newline.
394			*/
395			unsigned int
396			airOneLine(FILE file, char line, unsigned int size) {
397			int cc=0;
398			unsigned int ii;
399
400		774	if (!(size >= 3 /* need room for a character and a Windows newline */
401	✗✓	387	&& line && file)) {
402			return 0;
403			}
404			/* c is always set at least once, but not so for any char in line[] */
405	✓✓	371122	for (ii=0;
406		185561	(ii <= size-2 /* room for line[ii] and \0 after that */
407	✓✓	371044	&& EOF != (cc=getc(file)) /* didn't hit EOF trying to read char */
408	✓✓	185483	&& cc != '\n' /* char isn't newline */
409		185174	&& cc != '\r'); /* char isn't carriage return */
410		185174	++ii) {
411		185174	line[ii] = AIR_CAST(char, cc);
412			}
413
414	✓✓	387	if (EOF == cc) {
415			/* for-loop terminated because we hit EOF */
416		6	line[0] = '\0';
417		6	return 0;
418	✓✓	381	} else if ('\r' == cc \|\| '\n' == cc) {
419			/* for-loop terminated because we hit '\n' or '\r' */
420			/* if it was '\r', see if next character is '\n' */
421	✗✓	303	if ('\r' == cc) {
422			cc = getc(file);
423			if (EOF != cc && '\n' != cc) {
424			/* oops, we got something, and it was not a '\n'; put it back */
425			ungetc(cc, file);
426			}
427			}
428		303	line[ii] = '\0';
429		303	return ii+1;
430			} else {
431			/* for-loop terminated because we got to end of buffer (ii == size-1) */
432		78	cc = getc(file);
433			/* but see if we were about to get '\r', "\r\n", or '\n' */
434	✗✓	78	if ('\r' == cc) {
435			int dd;
436			dd = getc(file);
437			if (EOF != dd && '\n' != dd) {
438			/* oops, put it back */
439			ungetc(dd, file);
440			}
441			line[ii] = '\0';
442			return ii+1;
443	✓✓	78	} else if ('\n' == cc) {
444		2	line[ii] = '\0';
445		2	return ii+1;
446			} else {
447			/* weren't about to get a line termination,
448			we really did run out of buffer */
449	✓✗	76	if (EOF != cc) {
450		76	ungetc(cc, file); /* we're allowed one ungetc on ANY stream */
451		76	}
452		76	line[size-1] = '\0';
453		76	return size+1;
454			}
455			}
456		387	}
457