| File: | x2pmp.c |
| Location: | line 250, column 3 |
| Description: | Result of 'calloc' is converted to a pointer of type 'unsigned char', which is incompatible with sizeof operand type 'char' |
| 1 | /* x2pmp.c: Translate xwd window dump format into PMP format for the |
| 2 | * IBM 3812 PagePrinter. |
| 3 | */ |
| 4 | #include <stdio.h> |
| 5 | #include <X11/Xlib.h> |
| 6 | #include <X11/XWDFile.h> |
| 7 | #include <X11/Xfuncs.h> |
| 8 | #include <errno(*__error()).h> |
| 9 | #include <string.h> |
| 10 | |
| 11 | #include "pmp.h" |
| 12 | #include "xpr.h" |
| 13 | |
| 14 | #define max_(a, b)((a) > (b) ? (a) : (b)) ((a) > (b) ? (a) : (b)) |
| 15 | #define min_(a, b)((a) < (b) ? (a) : (b)) ((a) < (b) ? (a) : (b)) |
| 16 | #define abs_(a)((a) < 0 ? -(a) : (a)) ((a) < 0 ? -(a) : (a)) |
| 17 | |
| 18 | |
| 19 | /* Local prototypes */ |
| 20 | static unsigned char *magnification_table(int scale); |
| 21 | static int bits_set(int n); |
| 22 | static void leave(const char *s) _X_NORETURN__attribute((noreturn)); |
| 23 | static void p_move_abs(FILE *p, int x, int y); |
| 24 | static void p_save_cursor(FILE *p, int reg); |
| 25 | static void p_restore_cursor(FILE *p, int reg); |
| 26 | static void p_set_orientation(FILE *p, enum orientation orient); |
| 27 | static void p_bitmap( |
| 28 | FILE *p, |
| 29 | unsigned int h, int w, |
| 30 | unsigned long buflen, |
| 31 | unsigned char *buf); |
| 32 | |
| 33 | static int plane = 0; |
| 34 | #define FONT_HEIGHT40 40 |
| 35 | #define FONT_HEIGHT_PIXELS(40*75/240) (FONT_HEIGHT40*75/PPI240) |
| 36 | #define FONT_WIDTH24 24 |
| 37 | |
| 38 | void x2pmp(FILE *in, FILE *out, |
| 39 | int scale, |
| 40 | int p_width, int p_length, int x_pos, int y_pos, /* in pels (units of PPI) */ |
| 41 | char *head, char *foot, |
| 42 | enum orientation orient, |
| 43 | int invert) |
| 44 | { |
| 45 | unsigned char *buffer, *win_name; |
| 46 | unsigned int win_name_size, width, height, ncolors; |
| 47 | unsigned int buffer_size, one_plane_size, byte_width, fixed_width; |
| 48 | int no_of_bits; |
| 49 | unsigned long swaptest = 1; |
| 50 | XWDFileHeader header; |
| 51 | |
| 52 | /* Read header from file */ |
| 53 | if (fread((char *)&header, sizeof(header), 1, in) != 1) { |
| 54 | if (feof(in)) |
| 55 | return; |
| 56 | else |
| 57 | leave("fread"); |
| 58 | } |
| 59 | if (*(char *) &swaptest) |
| 60 | _swaplong((char *) &header, sizeof(header)); |
| 61 | |
| 62 | if (header.file_version != XWD_FILE_VERSION7) { |
| 63 | fprintf(stderr__stderrp,"%s: file format version %d, not %d\n", progname, |
| 64 | (int)header.file_version, XWD_FILE_VERSION7); |
| 65 | } |
| 66 | |
| 67 | win_name_size = abs_(header.header_size - sizeof(header))((header.header_size - sizeof(header)) < 0 ? -(header.header_size - sizeof(header)) : (header.header_size - sizeof(header))); |
| 68 | if ((win_name = (unsigned char *) |
| 69 | calloc(win_name_size, (unsigned) sizeof(char))) == NULL((void*)0)) |
| 70 | leave("Can't calloc window name storage."); |
| 71 | |
| 72 | /* Read window name from file */ |
| 73 | if (fread((char *) win_name, sizeof(char), (int) win_name_size, in) != |
| 74 | win_name_size) |
| 75 | leave("Unable to read window name from dump file."); |
| 76 | DEBUG(>= 1)if (debug >= 1) |
| 77 | fprintf(stderr__stderrp,"win_name =%s\n", win_name); |
| 78 | |
| 79 | width = header.pixmap_width; |
| 80 | height = header.pixmap_height; |
| 81 | fixed_width = 8 * (byte_width = header.bytes_per_line); |
| 82 | one_plane_size = byte_width * height; |
| 83 | buffer_size = one_plane_size * |
| 84 | ((header.pixmap_format == ZPixmap2)? header.pixmap_depth: 1); |
| 85 | |
| 86 | /* Determine orientation and scale if not specified */ |
| 87 | if (orient == UNSPECIFIED) |
| 88 | orient = (fixed_width <= height)? PORTRAIT: LANDSCAPE; |
| 89 | if (scale <= 0) { |
| 90 | int real_height = height; |
| 91 | if (head) real_height += FONT_HEIGHT_PIXELS(40*75/240) << 1; |
| 92 | if (foot) real_height += FONT_HEIGHT_PIXELS(40*75/240) << 1; |
| 93 | switch(orient) { |
| 94 | default: |
| 95 | case PORTRAIT: |
| 96 | case UPSIDE_DOWN: |
| 97 | scale = min_((p_width - 2*x_pos) / fixed_width,(((p_width - 2*x_pos) / fixed_width) < ((p_length - 2*y_pos ) / real_height) ? ((p_width - 2*x_pos) / fixed_width) : ((p_length - 2*y_pos) / real_height)) |
| 98 | (p_length - 2*y_pos) / real_height)(((p_width - 2*x_pos) / fixed_width) < ((p_length - 2*y_pos ) / real_height) ? ((p_width - 2*x_pos) / fixed_width) : ((p_length - 2*y_pos) / real_height)); |
| 99 | break; |
| 100 | case LANDSCAPE: |
| 101 | case LANDSCAPE_LEFT: |
| 102 | scale = min_((p_length - 2*y_pos) / fixed_width,(((p_length - 2*y_pos) / fixed_width) < ((p_width - 2*x_pos ) / real_height) ? ((p_length - 2*y_pos) / fixed_width) : ((p_width - 2*x_pos) / real_height)) |
| 103 | (p_width - 2*x_pos) / real_height)(((p_length - 2*y_pos) / fixed_width) < ((p_width - 2*x_pos ) / real_height) ? ((p_length - 2*y_pos) / fixed_width) : ((p_width - 2*x_pos) / real_height)); |
| 104 | break; |
| 105 | } |
| 106 | if (scale <= 0) |
| 107 | leave("PixMap doesn't fit on page."); |
| 108 | else DEBUG(>1)if (debug >1) |
| 109 | fprintf(stderr__stderrp, "scaling by %d to yield %d x %d image\n", |
| 110 | scale, fixed_width*scale, height*scale); |
| 111 | } |
| 112 | |
| 113 | ncolors = header.ncolors; |
| 114 | if (ncolors) { |
| 115 | int i; |
| 116 | XColor *colors = (XColor *)malloc((unsigned) (header.ncolors * sizeof(XColor))); |
| 117 | |
| 118 | if (fread((char *)colors, sizeof(XColor), ncolors, in) != ncolors) |
| 119 | leave("Unable to read colormap from dump file."); |
| 120 | |
| 121 | if (*(char *) &swaptest) { |
| 122 | for (i = 0; i < ncolors; i++) { |
| 123 | _swaplong((char *) &colors[i].pixel, (long)sizeof(long)); |
| 124 | _swapshort((char *) &colors[i].red, (long) (3 * sizeof(short))); |
| 125 | } |
| 126 | } |
| 127 | if (ncolors == 2 && INTENSITY(&colors[0])(30L*(int)(&colors[0])->red + 59L*(int)(&colors[0] )->green + 11L*(int)(&colors[0])->blue) > INTENSITY(&colors[1])(30L*(int)(&colors[1])->red + 59L*(int)(&colors[1] )->green + 11L*(int)(&colors[1])->blue)) |
| 128 | invert = !invert; |
| 129 | free( colors ); |
| 130 | } |
| 131 | |
| 132 | invert = !invert; /* 3812 puts ink (i.e. black) on 1-bits */ |
| 133 | |
| 134 | if ((buffer = (unsigned char *) calloc(buffer_size, 1)) == NULL((void*)0)) |
| 135 | leave("Can't calloc data buffer."); |
| 136 | bzero((char *) buffer, (int) buffer_size)__builtin___memset_chk ((char *) buffer, 0, (int) buffer_size , __builtin_object_size ((char *) buffer, 0)); |
| 137 | |
| 138 | /* Read bitmap from file */ |
| 139 | if (fread((char *) buffer, sizeof(char), (int) buffer_size, in) |
| 140 | != buffer_size) |
| 141 | leave("Unable to read pixmap from dump file."); |
| 142 | |
| 143 | if (header.bitmap_bit_order == LSBFirst0) |
| 144 | { |
| 145 | unsigned char bitswap[256], *bp; |
| 146 | int c; |
| 147 | for(c = 256; c--;) { |
| 148 | bitswap[c] = ((c & 01) << 7) + ((c & 02) << 5) + ((c & 04) << 3) + |
| 149 | ((c & 010) << 1) + ((c & 020) >> 1) + ((c & 040) >> 3) + |
| 150 | ((c & 0100) >> 5) + ((c & 0200) >> 7); |
| 151 | if (invert) |
| 152 | bitswap[c] = ~bitswap[c]; |
| 153 | } |
| 154 | /* Here's where we do the bitswapping. */ |
| 155 | for(bp = buffer+buffer_size; bp-- > buffer;) |
| 156 | *bp = bitswap[*bp]; |
| 157 | } |
| 158 | else if (invert) { |
| 159 | unsigned char *bp; |
| 160 | for(bp = buffer+buffer_size; bp-- > buffer;) |
| 161 | *bp = ~*bp; |
| 162 | } |
| 163 | |
| 164 | /* we don't want the last bits up to the byte/word alignment set */ |
| 165 | if ((no_of_bits = fixed_width - width)) { |
| 166 | int i, j, mask = ~bits_set(no_of_bits % 8); |
| 167 | for(i = 0; i < height; i++) { |
| 168 | unsigned char *s = buffer + (i+1) * byte_width ; |
| 169 | |
| 170 | for(j = no_of_bits / 8; j--;) |
| 171 | *--s = 0; |
| 172 | *--s &= mask; |
| 173 | } |
| 174 | } |
| 175 | |
| 176 | DEBUG(>= 1)if (debug >= 1) |
| 177 | fprintf(stderr__stderrp,"read %d bytes for a %d (%d bytes) x %d image\n", |
| 178 | buffer_size, (int) width, byte_width, (int) height); |
| 179 | /* Scale the bitmap */ |
| 180 | if (scale > 1) { |
| 181 | unsigned char *tbl = magnification_table(scale); |
| 182 | unsigned char *scale_buf; |
| 183 | int i, j, k; |
| 184 | |
| 185 | if ((scale_buf = (unsigned char *) |
| 186 | calloc((unsigned) (buffer_size *= scale*scale), sizeof(char))) |
| 187 | == NULL((void*)0)) |
| 188 | leave("Can't calloc scaled buffer."); |
| 189 | for(i = 0; i < height; i++) { |
| 190 | unsigned char *src, *ss; |
| 191 | src = buffer + i * byte_width ; |
| 192 | ss = scale_buf + i * scale * scale * byte_width; |
| 193 | for(j = 0; j < byte_width; j++) { |
| 194 | unsigned char *dst = ss+j*scale; |
| 195 | unsigned char *expansion = tbl+scale*src[j]; |
| 196 | for(k = 0; k < scale; k++, dst += byte_width*scale) { |
| 197 | memmove((char *) dst, (char *) expansion, scale)__builtin___memmove_chk ((char *) dst, (char *) expansion, scale , __builtin_object_size ((char *) dst, 0)); |
| 198 | } |
| 199 | } |
| 200 | } |
| 201 | free((char *) buffer); |
| 202 | free((char *) tbl); |
| 203 | buffer = scale_buf; |
| 204 | byte_width *= scale; |
| 205 | width *= scale; |
| 206 | fixed_width *= scale; |
| 207 | height *= scale; |
| 208 | one_plane_size *= scale*scale; |
| 209 | } |
| 210 | DEBUG(==3)if (debug ==3) { |
| 211 | int i, j, k; |
| 212 | unsigned char *s; |
| 213 | |
| 214 | fprintf(stderr__stderrp, "dumping %d x %d grid\n", fixed_width, height); |
| 215 | for(i = 0; i < height; i++) { |
| 216 | s = buffer + i * byte_width ; |
| 217 | for(j = 0; j < byte_width; j++) |
| 218 | for(k = 8; k--;) |
| 219 | (void) putc((s[j] & 1<<k)? '*': '-', stderr__stderrp); |
| 220 | (void) putc('\n', stderr__stderrp); |
| 221 | } |
| 222 | } |
| 223 | p_set_orientation(out, orient); |
| 224 | p_restore_cursor(out, 0); |
| 225 | p_save_cursor(out, 3); |
| 226 | if (head != NULL((void*)0)) { |
| 227 | p_move_abs( out, x_pos + (width - strlen(foot)*FONT_WIDTH24) >> 1, |
| 228 | y_pos - FONT_HEIGHT40 ); |
| 229 | fprintf(out, "%s\n", head); |
| 230 | } |
| 231 | if (foot != NULL((void*)0)) { |
| 232 | p_move_abs( out, x_pos + (width - strlen(foot)*FONT_WIDTH24) >> 1, |
| 233 | y_pos + height + (FONT_HEIGHT40 << 1) ); |
| 234 | fprintf(out, "%s\n", foot); |
| 235 | } |
| 236 | p_move_abs(out, x_pos, y_pos); |
| 237 | p_bitmap(out, height, fixed_width, (unsigned long) one_plane_size, |
| 238 | buffer + plane * one_plane_size); |
| 239 | free((char *) win_name); |
| 240 | free((char *) buffer); |
| 241 | } |
| 242 | |
| 243 | static |
| 244 | unsigned char *magnification_table(int scale) |
| 245 | { |
| 246 | unsigned char *tbl; |
| 247 | int c; |
| 248 | |
| 249 | if ((tbl = (unsigned char *) |
| 250 | calloc((unsigned) (scale*256), sizeof(char))) == NULL((void*)0)) |
Result of 'calloc' is converted to a pointer of type 'unsigned char', which is incompatible with sizeof operand type 'char' | |
| 251 | leave("Can't calloc magnification table."); |
| 252 | bzero((char *) tbl, scale*256)__builtin___memset_chk ((char *) tbl, 0, scale*256, __builtin_object_size ((char *) tbl, 0)); |
| 253 | for(c = 256; c--;) { |
| 254 | int b = c, bit; |
| 255 | unsigned char *entry = tbl+c*scale; |
| 256 | |
| 257 | while (b) { |
| 258 | int i, last, mask; |
| 259 | bit = 1; |
| 260 | mask = b; |
| 261 | while (! (mask & 1)) { |
| 262 | bit++; |
| 263 | mask = mask >> 1; |
| 264 | } |
| 265 | last = scale*(bit-1); |
| 266 | for(i = scale*bit; i-- > last ;) |
| 267 | entry[(scale - 1) - i / 8] |= 1 << (i % 8); |
| 268 | b &= ~(1 << bit-1); |
| 269 | } |
| 270 | } |
| 271 | return tbl; |
| 272 | } |
| 273 | |
| 274 | /* returns 2^n-1, i.e. a number with bits n-1 through 0 set. |
| 275 | * (zero for n == 0) */ |
| 276 | static |
| 277 | int bits_set(int n) |
| 278 | { |
| 279 | int ans = 0; |
| 280 | while(n--) |
| 281 | ans |= 1 << n; |
| 282 | return ans; |
| 283 | } |
| 284 | |
| 285 | static |
| 286 | void leave(const char *s) |
| 287 | { |
| 288 | fprintf(stderr__stderrp, "\n%s: ", progname); |
| 289 | if (errno(*__error()) != 0) |
| 290 | perror(s); |
| 291 | else |
| 292 | fprintf(stderr__stderrp, "%s", s); |
| 293 | fprintf(stderr__stderrp, "\n"); |
| 294 | exit(EXIT_FAILURE1); |
| 295 | } |
| 296 | |
| 297 | /* move to coordinates x, y (in pels) */ |
| 298 | static |
| 299 | void p_move_abs(FILE *p, int x, int y) |
| 300 | { |
| 301 | if (x >= 0) { |
| 302 | PMP(p, 3){ fprintf(p, "\033[C"); { (void) putc(((3) & 0xFF), (p)); (void) putc((((3) & 0xFF00) >>8), (p)); }; }; |
| 303 | (void) putc('\340', p); |
| 304 | p_wput(x, p){ (void) putc((((x) & 0xFF00) >>8), (p)); (void) putc (((x) & 0xFF), (p)); }; |
| 305 | } |
| 306 | if (y >= 0) { |
| 307 | PMP(p, 3){ fprintf(p, "\033[C"); { (void) putc(((3) & 0xFF), (p)); (void) putc((((3) & 0xFF00) >>8), (p)); }; }; |
| 308 | (void) putc('\341', p); |
| 309 | p_wput(y, p){ (void) putc((((y) & 0xFF00) >>8), (p)); (void) putc (((y) & 0xFF), (p)); }; |
| 310 | } |
| 311 | } |
| 312 | |
| 313 | /* save current cursor position into (printer) register reg */ |
| 314 | static |
| 315 | void p_save_cursor(FILE *p, int reg) |
| 316 | { |
| 317 | PMP(p, 1){ fprintf(p, "\033[C"); { (void) putc(((1) & 0xFF), (p)); (void) putc((((1) & 0xFF00) >>8), (p)); }; }; |
| 318 | (void) putc(reg + '\200', p); |
| 319 | } |
| 320 | |
| 321 | /* restore current cursor position from (printer) register reg */ |
| 322 | static |
| 323 | void p_restore_cursor(FILE *p, int reg) |
| 324 | { |
| 325 | PMP(p, 1){ fprintf(p, "\033[C"); { (void) putc(((1) & 0xFF), (p)); (void) putc((((1) & 0xFF00) >>8), (p)); }; }; |
| 326 | (void) putc(reg + '\220', p); |
| 327 | } |
| 328 | |
| 329 | /* set the page orientation to orient (see pmp.h) */ |
| 330 | static |
| 331 | void p_set_orientation(FILE *p, enum orientation orient) |
| 332 | { |
| 333 | PMP(p, 2){ fprintf(p, "\033[C"); { (void) putc(((2) & 0xFF), (p)); (void) putc((((2) & 0xFF00) >>8), (p)); }; }; |
| 334 | fprintf(p, "\322%c", (int) orient); |
| 335 | } |
| 336 | |
| 337 | /* generate bitmap */ |
| 338 | static |
| 339 | void p_bitmap( |
| 340 | FILE *p, |
| 341 | unsigned int h, int w, |
| 342 | unsigned long buflen, |
| 343 | unsigned char *buf) |
| 344 | { |
| 345 | PMP(p, 9){ fprintf(p, "\033[C"); { (void) putc(((9) & 0xFF), (p)); (void) putc((((9) & 0xFF00) >>8), (p)); }; }; |
| 346 | (void) fwrite("\365\0", 1, 2, p); |
| 347 | puthl2(h, p){ (void) putc(((((h)) & 0xFF00) >>8), (p)); (void) putc ((((h)) & 0xFF), (p)); }; |
| 348 | puthl2(w, p){ (void) putc(((((w)) & 0xFF00) >>8), (p)); (void) putc ((((w)) & 0xFF), (p)); }; |
| 349 | puthl3(buflen, p){ (void) putc(((((buflen)) & 0xFF0000) >>16), (p)); (void) putc(((((buflen)) & 0xFF00) >>8), (p)); (void ) putc((((buflen)) & 0xFF), (p)); }; |
| 350 | |
| 351 | while(buflen) { |
| 352 | int len; |
| 353 | |
| 354 | len = min(buflen, MAX_VECTOR_LEN)((buflen) < (65535)? (buflen) : (65535)); |
| 355 | PMP(p, len){ fprintf(p, "\033[C"); { (void) putc(((len) & 0xFF), (p) ); (void) putc((((len) & 0xFF00) >>8), (p)); }; }; |
| 356 | (void) fwrite((char *) buf, 1, len, p); |
| 357 | buf += len; |
| 358 | buflen -= len; |
| 359 | } |
| 360 | (void) fflush(p); |
| 361 | } |