shared_source/c_datd/fcmiof.c

//$Header$
//-------------------------------------------------------------------------------------------------
//This file is part of "David T. Ashley's Shared Source Code", a set of shared components
//integrated into many of David T. Ashley's projects.
//-------------------------------------------------------------------------------------------------
//This source code and any program in which it is compiled/used is provided under the MIT License,
//reproduced below.
//-------------------------------------------------------------------------------------------------
//Permission is hereby granted, free of charge, to any person obtaining a copy of
//this software and associated documentation files(the "Software"), to deal in the
//Software without restriction, including without limitation the rights to use,
//copy, modify, merge, publish, distribute, sublicense, and / or sell copies of the
//Software, and to permit persons to whom the Software is furnished to do so,
//subject to the following conditions :
//
//The above copyright notice and this permission notice shall be included in all
//copies or substantial portions of the Software.
//
//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
//SOFTWARE.
//-------------------------------------------------------------------------------------------------
#define MODULE_FCMIOF

#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <time.h>

#include "fcmiof.h"


#define FCMIOF_HORIZONTAL_BAR_SEP_CHAR    ('-')
#define FCMIOF_LINE_LEN                   (78)


//08/16/01:  Visual inspection OK.
int FCMIOF_get_line_len(void)
   {
   return(FCMIOF_LINE_LEN);
   }


//08/16/01:  Visual inspection OK.
void FCMIOF_stream_repchar(FILE *s, char c, unsigned n)
   {
   assert(s != NULL);

   while(n--)
           fprintf(s, "%c", c);
   }


//08/16/01:  Visual inspection OK.
void FCMIOF_repchar(char c, unsigned n)
   {
   while(n--)
           printf("%c", c);
   }


//08/16/01:  Visual inspection OK.
void FCMIOF_hline(void)
   {
   FCMIOF_repchar(FCMIOF_HORIZONTAL_BAR_SEP_CHAR, FCMIOF_LINE_LEN);
   printf("\n");
   }


//08/16/01:  Visual inspection OK.
void FCMIOF_stream_hline(FILE *s)
   {
   assert(s != NULL);

   FCMIOF_stream_repchar(s, FCMIOF_HORIZONTAL_BAR_SEP_CHAR, FCMIOF_LINE_LEN);
   fprintf(s, "\n");
   }


//08/16/01:  Visual inspection OK.
void FCMIOF_stream_bannerheading(FILE *f,
                                 char *s, 
                                 int n_extra_lines)
   {
   const int lr_padding = 3;
      /* The number of spaces on each side of what is printed.
      */
   int i;
      /* General iteration variable.
      */

   int n_asterisks;
   int input_arg_len;
   int n_left_spaces;
   int n_right_spaces;

   /* Check the file pointer, string pointer, and other par.
   */
   assert(f != NULL);
   assert(s != NULL);
   assert(n_extra_lines >= 0);

   /* Print the right number of solid lines of asterisks to the
   ** standard output.
   */
   for (i=0; i<n_extra_lines; i++)
      {
      FCMIOF_stream_repchar(f, '*', FCMIOF_LINE_LEN);
      fprintf(f, "\n");
      }

   /* Figure out how many asterisks to print on each side of the
   ** argument, and how many spaces.  We also need to figure out
   ** how many characters of the input argument to print--if there
   ** are too many characters, we need to truncate.
   */
   input_arg_len = strlen(s);
   if(input_arg_len > (FCMIOF_LINE_LEN - 2 * lr_padding - 2))
      input_arg_len = FCMIOF_LINE_LEN - 2 * lr_padding - 2;

   n_asterisks = (FCMIOF_LINE_LEN - 2*lr_padding - input_arg_len)/2;

   n_left_spaces = lr_padding;

   if ((FCMIOF_LINE_LEN - 2*lr_padding - input_arg_len) % 2)
      {
      /* Odd, need to pad the right by one. */
      n_right_spaces = lr_padding+1;
      }
   else
      {
      n_right_spaces = lr_padding;
      }

   /* Print the text. */
   FCMIOF_stream_repchar(f, '*', n_asterisks);
   FCMIOF_stream_repchar(f, ' ', n_left_spaces);
   for (i=0; i<input_arg_len; i++)
      fprintf(f, "%c", s[i]);
   FCMIOF_stream_repchar(f, ' ', n_right_spaces);
   FCMIOF_stream_repchar(f, '*', n_asterisks);
   fprintf(f, "\n");

   /* Print the right number of solid lines of asterisks to the
   ** standard output.
   */
   for (i=0; i<n_extra_lines; i++)
      {
      FCMIOF_stream_repchar(f, '*', FCMIOF_LINE_LEN);
      fprintf(f, "\n");
      }
   }


//08/16/01:  Visual inspection OK.
void FCMIOF_bannerheading(char *s, int n_extra_lines)
   {
   assert(s != NULL);
   assert(n_extra_lines >= 0);

   FCMIOF_stream_bannerheading(stdout, s, n_extra_lines);
   }


void FCMIOF_time_stream(FILE *s, time_t ltime)
   {
   char *p;

   assert(s != NULL);

   time(&ltime);

   p = ctime(&ltime);

   if (p)
      {
      int i;

      for (i=11; i<19; i++)
         fprintf(s, "%c", p[i]);
      fprintf(s, " ");
      for (i=0; i<10; i++)
         fprintf(s, "%c", p[i]);
      fprintf(s, " ");
      for (i=20; i<24; i++)
         fprintf(s, "%c", p[i]);
      }
   else
      {
      fprintf(s, "??? ??? ?? ??:??:?? ????");
      }
   }


//08/16/01:  Visual inspection OK.
const char *FCMIOF_cvcinfo(void)
   {
   return("$Header$");
   }


//08/16/01:  Visual inspection OK.
const char *FCMIOF_hvcinfo(void)
   {
   return(FCMIOF_H_VERSION);
   }

//End of fcmiof.c.
1	dashley	56	//$Header$
2	dashley	25	//-------------------------------------------------------------------------------------------------
3	dashley	56	//This file is part of "David T. Ashley's Shared Source Code", a set of shared components
4			//integrated into many of David T. Ashley's projects.
5	dashley	25	//-------------------------------------------------------------------------------------------------
6	dashley	56	//This source code and any program in which it is compiled/used is provided under the MIT License,
7			//reproduced below.
8			//-------------------------------------------------------------------------------------------------
9			//Permission is hereby granted, free of charge, to any person obtaining a copy of
10			//this software and associated documentation files(the "Software"), to deal in the
11			//Software without restriction, including without limitation the rights to use,
12			//copy, modify, merge, publish, distribute, sublicense, and / or sell copies of the
13			//Software, and to permit persons to whom the Software is furnished to do so,
14			//subject to the following conditions :
15	dashley	25	//
16	dashley	56	//The above copyright notice and this permission notice shall be included in all
17			//copies or substantial portions of the Software.
18	dashley	25	//
19	dashley	56	//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20			//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21			//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
22			//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23			//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24			//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25			//SOFTWARE.
26	dashley	25	//-------------------------------------------------------------------------------------------------
27			#define MODULE_FCMIOF
28
29			#include <assert.h>
30			#include <stdio.h>
31			#include <string.h>
32			#include <time.h>
33
34			#include "fcmiof.h"
35
36
37			#define FCMIOF_HORIZONTAL_BAR_SEP_CHAR ('-')
38			#define FCMIOF_LINE_LEN (78)
39
40
41			//08/16/01: Visual inspection OK.
42			int FCMIOF_get_line_len(void)
43			{
44			return(FCMIOF_LINE_LEN);
45			}
46
47
48			//08/16/01: Visual inspection OK.
49			void FCMIOF_stream_repchar(FILE *s, char c, unsigned n)
50			{
51			assert(s != NULL);
52
53			while(n--)
54			fprintf(s, "%c", c);
55			}
56
57
58			//08/16/01: Visual inspection OK.
59			void FCMIOF_repchar(char c, unsigned n)
60			{
61			while(n--)
62			printf("%c", c);
63			}
64
65
66			//08/16/01: Visual inspection OK.
67			void FCMIOF_hline(void)
68			{
69			FCMIOF_repchar(FCMIOF_HORIZONTAL_BAR_SEP_CHAR, FCMIOF_LINE_LEN);
70			printf("\n");
71			}
72
73
74			//08/16/01: Visual inspection OK.
75			void FCMIOF_stream_hline(FILE *s)
76			{
77			assert(s != NULL);
78
79			FCMIOF_stream_repchar(s, FCMIOF_HORIZONTAL_BAR_SEP_CHAR, FCMIOF_LINE_LEN);
80			fprintf(s, "\n");
81			}
82
83
84			//08/16/01: Visual inspection OK.
85			void FCMIOF_stream_bannerheading(FILE *f,
86			char *s,
87			int n_extra_lines)
88			{
89			const int lr_padding = 3;
90			/* The number of spaces on each side of what is printed.
91			*/
92			int i;
93			/* General iteration variable.
94			*/
95
96			int n_asterisks;
97			int input_arg_len;
98			int n_left_spaces;
99			int n_right_spaces;
100
101			/* Check the file pointer, string pointer, and other par.
102			*/
103			assert(f != NULL);
104			assert(s != NULL);
105			assert(n_extra_lines >= 0);
106
107			/* Print the right number of solid lines of asterisks to the
108			** standard output.
109			*/
110			for (i=0; i<n_extra_lines; i++)
111			{
112			FCMIOF_stream_repchar(f, '*', FCMIOF_LINE_LEN);
113			fprintf(f, "\n");
114			}
115
116			/* Figure out how many asterisks to print on each side of the
117			** argument, and how many spaces. We also need to figure out
118			** how many characters of the input argument to print--if there
119			** are too many characters, we need to truncate.
120			*/
121			input_arg_len = strlen(s);
122			if(input_arg_len > (FCMIOF_LINE_LEN - 2 * lr_padding - 2))
123			input_arg_len = FCMIOF_LINE_LEN - 2 * lr_padding - 2;
124
125			n_asterisks = (FCMIOF_LINE_LEN - 2*lr_padding - input_arg_len)/2;
126
127			n_left_spaces = lr_padding;
128
129			if ((FCMIOF_LINE_LEN - 2*lr_padding - input_arg_len) % 2)
130			{
131			/* Odd, need to pad the right by one. */
132			n_right_spaces = lr_padding+1;
133			}
134			else
135			{
136			n_right_spaces = lr_padding;
137			}
138
139			/* Print the text. */
140			FCMIOF_stream_repchar(f, '*', n_asterisks);
141			FCMIOF_stream_repchar(f, ' ', n_left_spaces);
142			for (i=0; i<input_arg_len; i++)
143			fprintf(f, "%c", s[i]);
144			FCMIOF_stream_repchar(f, ' ', n_right_spaces);
145			FCMIOF_stream_repchar(f, '*', n_asterisks);
146			fprintf(f, "\n");
147
148			/* Print the right number of solid lines of asterisks to the
149			** standard output.
150			*/
151			for (i=0; i<n_extra_lines; i++)
152			{
153			FCMIOF_stream_repchar(f, '*', FCMIOF_LINE_LEN);
154			fprintf(f, "\n");
155			}
156			}
157
158
159			//08/16/01: Visual inspection OK.
160			void FCMIOF_bannerheading(char *s, int n_extra_lines)
161			{
162			assert(s != NULL);
163			assert(n_extra_lines >= 0);
164
165			FCMIOF_stream_bannerheading(stdout, s, n_extra_lines);
166			}
167
168
169			void FCMIOF_time_stream(FILE *s, time_t ltime)
170			{
171			char *p;
172
173			assert(s != NULL);
174
175			time(&ltime);
176
177			p = ctime(&ltime);
178
179			if (p)
180			{
181			int i;
182
183			for (i=11; i<19; i++)
184			fprintf(s, "%c", p[i]);
185			fprintf(s, " ");
186			for (i=0; i<10; i++)
187			fprintf(s, "%c", p[i]);
188			fprintf(s, " ");
189			for (i=20; i<24; i++)
190			fprintf(s, "%c", p[i]);
191			}
192			else
193			{
194			fprintf(s, "??? ??? ?? ??:??:?? ????");
195			}
196			}
197
198
199
200			//08/16/01: Visual inspection OK.
201			const char *FCMIOF_cvcinfo(void)
202			{
203	dashley	56	return("$Header$");
204	dashley	25	}
205
206
207			//08/16/01: Visual inspection OK.
208			const char *FCMIOF_hvcinfo(void)
209			{
210			return(FCMIOF_H_VERSION);
211			}
212
213	dashley	56	//End of fcmiof.c.