summaryrefslogtreecommitdiff
path: root/libps/write.c
blob: b28ccca63de644ec6764af373244d5f0aef2be78 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
/* Some helper functions for writing output fields.

   Copyright (C) 1995 Free Software Foundation, Inc.

   Written by Miles Bader <miles@gnu.ai.mit.edu>

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2, or (at
   your option) any later version.

   This program 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
   General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

#include "ps.h"
#include "common.h"

/* ---------------------------------------------------------------- */

/* Write at most MAX_LEN characters of STRING to STREAM (if MAX_LEN > the
   length of STRING, then write all of it; if MAX_LEN == -1, then write all
   of STRING regardless).  If COUNT is non-NULL, the number of characters
   written is added to the integer it points to.  If an error occurs, the
   error code is returned, otherwise 0.  */
error_t
ps_write_string(char *string, int max_len, FILE *stream, int *count)
{
  int len = strlen(string);

  if (max_len > 0 && len > max_len)
    len = max_len;

  if (len > 0)
    {
      int output = fwrite(string, 1, len, stream);
      if (output == 0)
	return errno;
      if (count)
	*count += output;
    }

  return 0;
}

/* Write NUM spaces to STREAM.  If COUNT is non-NULL, the number of spaces
   written is added to the integer it points to.  If an error occurs, the
   error code is returned, otherwise 0.  */
error_t
ps_write_spaces(int num, FILE *stream, int *count)
{
  static char spaces[] = "                                ";
#define spaces_len (sizeof(spaces) - 1)

  while (num > spaces_len)
    {
      error_t err = ps_write_string(spaces, spaces_len, stream, count);
      if (err)
	return err;
      num -= spaces_len;
    }

  if (num > 0)
    return ps_write_string(spaces, num, stream, count);
  else
    return 0;
}

/* Write as many spaces to STREAM as required to make a field of width SOFAR
   be at least WIDTH characters wide (the absolute value of WIDTH is used).
   If COUNT is non-NULL, the number of spaces written is added to the integer
   it points to.  If an error occurs, the error code is returned, otherwise
   0.  */
error_t
ps_write_padding(int sofar, int width, FILE *stream, int *count)
{
  width = ABS(width);
  if (sofar < width)
    return ps_write_spaces(width - sofar, stream, count);
  else
    return 0;
}

/* Write the string BUF to STREAM, padded on one side with spaces to be at
   least the absolute value of WIDTH long: if WIDTH >= 0, then on the left
   side, otherwise on the right side.  If COUNT is non-NULL, the number of
   characters written is added to the integer it points to.  If an error
   occurs, the error code is returned, otherwise 0.  */
error_t
ps_write_field(char *buf, int width, FILE *stream, int *count)
{
  error_t err;
  int len = strlen(buf);

  if (width > len)
    {
      err = ps_write_string(buf, -1, stream, count);
      if (!err)
	err = ps_write_spaces(width - len, stream, count);
    }
  else if (-width > len)
    {
      err = ps_write_spaces(-width - len, stream, count);
      if (!err)
	err = ps_write_string(buf, -1, stream, count);
    }
  else
    err = ps_write_string(buf, -1, stream, count);

  return err;
}

/* Write the decimal representation of VALUE to STREAM, padded on one side
   with spaces to be at least the absolute value of WIDTH long: if WIDTH >=
   0, then on the left side, otherwise on the right side.  If COUNT is
   non-NULL, the number of characters written is added to the integer it
   points to.  If an error occurs, the error code is returned, otherwise 0.  */
error_t
ps_write_int_field(int value, int width, FILE *stream, int *count)
{
  char buf[20];
  sprintf(buf, "%d", value);
  return ps_write_field(buf, width, stream, count);
}