1. #include <stdio.h>
  2. #include <string.h>
  3.  
  4. #define MAXLEN 1000
  5. #define MAXLINES 5000
  6.  
  7. char *lineptr[MAXLINES];
  8.  
  9. void writelines(char *[], int nlines);
  10. void writelines1(char *[], int nlines);
  11. int readlines(char *[], int);
  12. int readlines1(char *[], int);
  13.  
  14. void qsort(char *[], int, int);
  15.  
  16. main()
  17. {
  18. 	int nlines;
  19. 	char line[MAXLEN];
  20. 	char *lines[MAXLINES];
  21.  
  22. 	//read lines and print them
  23. 	while ((nlines = readlines1(lines, MAXLINES)) > 0)
  24. 		writelines(lines, nlines);
  25. }
  26.  
  27. //print input lines
  28. void writelines(char *lines[], int nlines)
  29. {
  30. 	int i;
  31.  
  32. 	for (i = 0; i < nlines; ++i) 
  33. 		printf("%s\n", lines[i]);
  34. }
  35.  
  36. //print input lines
  37. void writelines1(char *lines[], int nlines)
  38. {
  39. 	int i;
  40.  
  41. 	for (i = 0; i < nlines; ++i) 
  42. 		printf("%s\n", lines[i]);
  43. }
  44.  
  45. void my_strcpy(char *, char *);
  46. int readline(char [], int);
  47. char *alloc(int);
  48.  
  49. //get input lines
  50. int readlines(char *lines[], int maxlines)
  51. {
  52. 	int len, nlines;
  53. 	char *p, line[MAXLEN];
  54.  
  55. 	nlines = 0;
  56. 	while ((len = readline(line, MAXLEN)) > 0)	
  57. 		if (nlines >= maxlines || (p = alloc(len)) == NULL)
  58. 			return -1;
  59. 		else {
  60. 			line[len-1] = '\0';
  61. 			my_strcpy(p, line);
  62. 			lines[nlines++] = p;
  63. 		}
  64. 	return nlines;
  65. }
  66.  
  67. //get input lines
  68. int readlines1(char *lines[], int maxlines)
  69. {
  70. 	int len, nlines;
  71. 	char *p, line[MAXLEN];
  72. 	char b[MAXLEN];
  73.  
  74. 	p = b;
  75. 	nlines = 0;
  76. 	while ((len = readline(line, MAXLEN)) > 0)
  77. 		if (nlines >= maxlines)
  78. 			return -1;
  79. 		else {
  80. 			line[len-1] = '\0';
  81. 			my_strcpy(p, line);
  82. 			lines[nlines++] = p;
  83. 		}
  84. 	return nlines;
  85. }
  86.  
  87. //copy t to s
  88. void my_strcpy(char *s, char *t)
  89. {
  90. 	while (*t != '\0')
  91. 		*s++ = *t++;
  92. 	*s = '\0';
  93. }
  94.  
  95. //get input line
  96. int readline(char s[], int max)
  97. {
  98.   int c, i;
  99.  
  100.   for (i = 0; i<max-1 && (c = getchar())!=EOF && c!='\n'; ++i)
  101. 	s[i] = c;
  102.   if (c == '\n')
  103. 	s[i++] = c;
  104.   s[i] = '\0';
  105.   return i;
  106. }
  107.  
  108. #define ALLOCSIZE 1000
  109.  
  110. static char allocbuf[ALLOCSIZE];
  111. static char *allocp = allocbuf;
  112.  
  113. //allocate storage
  114. char *alloc(int n)
  115. {
  116. 	if (allocbuf + ALLOCSIZE - allocp >= n) {
  117. 		allocp += n;
  118. 		return allocp - n;
  119. 	} 
  120. 	else
  121. 		return 0;
  122. }
  123.  
  124. int my_strcmp(char *, char *);
  125. void swap(char *[], int, int);
  126.  
  127. //quicksort lines
  128. void qsort(char *v[], int left, int right)
  129. {
  130. 	int i, last;
  131.  
  132. 	if (left >= right)
  133. 		return;
  134. 	swap(v, left, (left + right) / 2);
  135. 	last = left;
  136. 	for (i = left + 1; i <= right; ++i)
  137. 		if (my_strcmp(v[i], v[left]) < 0)
  138. 			swap(v, ++last, i);
  139. 	swap(v, left, last);
  140. 	qsort(v, left, last - 1);
  141. 	qsort(v, last + 1, right);
  142. }
  143.  
  144. //compare lines 
  145. int my_strcmp(char *s, char *t)
  146. {
  147. 	while (*s == *t) { 
  148. 		++s, ++t;
  149. 		if (*s == '\0') 
  150. 			return 0;
  151. 	}
  152. 	return *s - *t;
  153. }
  154.  
  155. //swap lines
  156. void swap(char *v[], int i, int j)
  157. {
  158. 	char *temp = v[i];
  159. 	v[i] = v[j];
  160. 	v[j] = temp;
  161. }