home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / fontutils-0.6 / pbm / libpbm1.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-09-14  |  7.9 KB  |  448 lines
  1. /* libpbm1.c - pbm utility library part 1
  2. **
  3. ** Copyright (C) 1988 by Jef Poskanzer.
  4. **
  5. ** Permission to use, copy, modify, and distribute this software and its
  6. ** documentation for any purpose and without fee is hereby granted, provided
  7. ** that the above copyright notice appear in all copies and that both that
  8. ** copyright notice and this permission notice appear in supporting
  9. ** documentation.  This software is provided "as is" without express or
  10. ** implied warranty.
  11. **
  12. ** Minor configuration changes for GNU --karl.
  13. */
  14.  
  15. #include "pbm.h"
  16. #include "libpbm.h"
  17. #include <varargs.h>
  18.  
  19. #if 0 /* karl */
  20. extern char *malloc ();
  21. extern void free ();
  22. extern void exit ();
  23. #endif
  24.  
  25. /* Variable-sized arrays. */
  26.  
  27. char*
  28. pm_allocrow( cols, size )
  29.     int cols, size;
  30.     {
  31.     register char* itrow;
  32.  
  33.     itrow = (char*) malloc( cols * size );
  34.     if ( itrow == (char*) 0 )
  35.     pm_error( "out of memory allocating a row", 0,0,0,0,0 );
  36.     return itrow;
  37.     }
  38.  
  39. void
  40. pm_freerow( itrow )
  41.     char* itrow;
  42.     {
  43.     free( itrow );
  44.     }
  45.  
  46.  
  47. char**
  48. pm_allocarray( cols, rows, size )
  49.     int cols, rows;
  50.     int size;
  51.     {
  52.     char** its;
  53.     int i;
  54.  
  55.     its = (char**) malloc( rows * sizeof(char*) );
  56.     if ( its == (char**) 0 )
  57.     pm_error( "out of memory allocating an array", 0,0,0,0,0 );
  58.     its[0] = (char*) malloc( rows * cols * size );
  59.     if ( its[0] == (char*) 0 )
  60.     pm_error( "out of memory allocating an array", 0,0,0,0,0 );
  61.     for ( i = 1; i < rows; ++i )
  62.     its[i] = &(its[0][i * cols * size]);
  63.     return its;
  64.     }
  65.  
  66. void
  67. pm_freearray( its, rows )
  68.     char** its;
  69.     int rows;
  70.     {
  71.     free( its[0] );
  72.     free( its );
  73.     }
  74.  
  75.  
  76. /* Case-insensitive keyword matcher. */
  77.  
  78. int
  79. pm_keymatch( str, keyword, minchars )
  80.     char* str;
  81.     char* keyword;
  82.     int minchars;
  83.     {
  84.     register int len;
  85.  
  86.     len = strlen( str );
  87.     if ( len < minchars )
  88.     return 0;
  89.     while ( --len >= 0 )
  90.     {
  91.     register char c1, c2;
  92.  
  93.     c1 = *str++;
  94.     c2 = *keyword++;
  95.     if ( c2 == '\0' )
  96.         return 0;
  97.     if ( isupper( c1 ) )
  98.         c1 = tolower( c1 );
  99.     if ( isupper( c2 ) )
  100.         c1 = tolower( c2 );
  101.     if ( c1 != c2 )
  102.         return 0;
  103.     }
  104.     return 1;
  105.     }
  106.  
  107.  
  108. /* Log base two hacks. */
  109.  
  110. int
  111. pm_maxvaltobits( maxval )
  112.     int maxval;
  113.     {
  114.     if ( maxval <= 1 )
  115.     return 1;
  116.     else if ( maxval <= 3 )
  117.     return 2;
  118.     else if ( maxval <= 7 )
  119.     return 3;
  120.     else if ( maxval <= 15 )
  121.     return 4;
  122.     else if ( maxval <= 31 )
  123.     return 5;
  124.     else if ( maxval <= 63 )
  125.     return 6;
  126.     else if ( maxval <= 127 )
  127.     return 7;
  128.     else if ( maxval <= 255 )
  129.     return 8;
  130.     else if ( maxval <= 511 )
  131.     return 9;
  132.     else if ( maxval <= 1023 )
  133.     return 10;
  134.     else if ( maxval <= 2047 )
  135.     return 11;
  136.     else if ( maxval <= 4095 )
  137.     return 12;
  138.     else if ( maxval <= 8191 )
  139.     return 13;
  140.     else if ( maxval <= 16383 )
  141.     return 14;
  142.     else if ( maxval <= 32767 )
  143.     return 15;
  144.     else if ( maxval <= 65535 )
  145.     return 16;
  146.     else
  147.     pm_error( "maxval of %d is too large!", maxval, 0,0,0,0 );
  148.     return 0; /* Avoid dumb warning.  */
  149.     }
  150.  
  151. int
  152. pm_bitstomaxval( bits )
  153.     int bits;
  154.     {
  155.     return ( 1 << bits ) - 1;
  156.     }
  157.  
  158.  
  159. /* Initialization. */
  160.  
  161. static char* pm_progname;
  162.  
  163. void
  164. pm_init( argcP, argv )
  165.     int* argcP;
  166.     char* argv[];
  167.     {
  168.     pm_progname = rindex( argv[0], '/');
  169.     if ( pm_progname == NULL )
  170.     pm_progname = argv[0];
  171.     else
  172.     ++pm_progname;
  173.     }
  174.  
  175. void
  176. pbm_init( argcP, argv )
  177.     int* argcP;
  178.     char* argv[];
  179.     {
  180.     pm_init( argcP, argv );
  181.     }
  182.  
  183. /* Error handling. */
  184.  
  185. /* I'd use varargs here, but it can't be done portably, because (a) vfprintf()
  186. ** is not very widespread, and (b) varargs itself is not powerful enough to
  187. ** allow me to include a portable vfprintf().
  188. **
  189. ** So instead, we have the gross hack of a fixed number of args.  It's not
  190. ** even clear how portable this hack is, but it does seem to work everywhere
  191. ** I've tried it.
  192. */
  193.  
  194. void
  195. pm_message( fmt, v1, v2, v3, v4, v5 )
  196.     char* fmt;
  197.     char *v1, *v2, *v3, *v4, *v5;
  198.     {
  199.     fprintf( stderr, "%s: ", pm_progname );
  200.     fprintf( stderr, fmt, v1, v2, v3, v4, v5 );
  201.     fputc( '\n', stderr );
  202.     }
  203.  
  204. void
  205. pm_error( fmt, v1, v2, v3, v4, v5 )
  206.     char* fmt;
  207.     char *v1, *v2, *v3, *v4, *v5;
  208.     {
  209.     pm_message( fmt, v1, v2, v3, v4, v5 );
  210.     exit( 1 );
  211.     }
  212.  
  213. void
  214. pm_perror( reason )
  215.     char* reason;
  216.     {
  217.     extern char* sys_errlist[];
  218.     extern int errno;
  219.     char* e;
  220.  
  221.     e = sys_errlist[errno];
  222.  
  223.     if ( reason != 0 && reason[0] != '\0' )
  224.     pm_error( "%s - %s", reason, e, 0,0,0 );
  225.     else
  226.     pm_error( "%s", e, 0,0,0,0 );
  227.     }
  228.  
  229. void
  230. pm_usage( usage )
  231.     char* usage;
  232.     {
  233.     fprintf( stderr, "usage:  %s %s\n", pm_progname, usage );
  234.     exit( 1 );
  235.     }
  236.  
  237.  
  238. /* File open/close that handles "-" as stdin and checks errors. */
  239.  
  240. FILE*
  241. pm_openr( name )
  242.     char* name;
  243.     {
  244.     FILE* f;
  245.  
  246.     if ( strcmp( name, "-" ) == 0 )
  247.     f = stdin;
  248.     else
  249.     {
  250. #ifdef MSDOS
  251.     f = fopen( name, "rb" );
  252. #else /*MSDOS*/
  253.     f = fopen( name, "r" );
  254. #endif /*MSDOS*/
  255.     if ( f == NULL )
  256.         {
  257.         pm_perror( name );
  258.         exit( 1 );
  259.         }
  260.     }
  261.     return f;
  262.     }
  263.  
  264. FILE*
  265. pm_openw( name )
  266.     char* name;
  267.     {
  268.     FILE* f;
  269.  
  270. #ifdef MSDOS
  271.     f = fopen( name, "wb" );
  272. #else /*MSDOS*/
  273.     f = fopen( name, "w" );
  274. #endif /*MSDOS*/
  275.     if ( f == NULL )
  276.     {
  277.     pm_perror( name );
  278.     exit( 1 );
  279.     }
  280.     return f;
  281.     }
  282.  
  283. void
  284. pm_close( f )
  285.     FILE* f;
  286.     {
  287.     if ( f != stdin )
  288.     if ( fclose( f ) != 0 )
  289.         pm_perror( "fclose" );
  290.     }
  291.  
  292. /* Broken putc() fix. */
  293.  
  294. #ifdef PBMPLUS_BROKENPUTC2
  295. int
  296. putc( c, stream )
  297.     char c;
  298.     FILE* stream;
  299.     {
  300.     return fwrite( &c, 1, 1, stream ) == 1 ? c : EOF;
  301.     }
  302. #endif /*PBMPLUS_BROKENPUTC2*/
  303.  
  304. /* Endian I/O.
  305. */
  306.  
  307. int
  308. pm_readbigshort( in, sP )
  309.     FILE* in;
  310.     short* sP;
  311.     {
  312.     int c;
  313.  
  314.     if ( (c = getc( in )) == EOF )
  315.     return -1;
  316.     *sP = ( c & 0xff ) << 8;
  317.     if ( (c = getc( in )) == EOF )
  318.     return -1;
  319.     *sP |= c & 0xff;
  320.     return 0;
  321.     }
  322.  
  323. #if __STDC__
  324. int
  325. pm_writebigshort( FILE* out, short s )
  326. #else /*not __STDC__*/
  327. int
  328. pm_writebigshort( out, s )
  329.     FILE* out;
  330.     short s;
  331. #endif /*not __STDC__*/
  332.     {
  333.     if ( putc( ( s >> 8 ) & 0xff, out ) == EOF )
  334.     return -1;
  335.     if ( putc( s & 0xff, out ) == EOF )
  336.     return -1;
  337.     return 0;
  338.     }
  339.  
  340. int
  341. pm_readbiglong( in, lP )
  342.     FILE* in;
  343.     long* lP;
  344.     {
  345.     int c;
  346.  
  347.     if ( (c = getc( in )) == EOF )
  348.     return -1;
  349.     *lP = ( c & 0xff ) << 24;
  350.     if ( (c = getc( in )) == EOF )
  351.     return -1;
  352.     *lP |= ( c & 0xff ) << 16;
  353.     if ( (c = getc( in )) == EOF )
  354.     return -1;
  355.     *lP |= ( c & 0xff ) << 8;
  356.     if ( (c = getc( in )) == EOF )
  357.     return -1;
  358.     *lP |= c & 0xff;
  359.     return 0;
  360.     }
  361.  
  362. int
  363. pm_writebiglong( out, l )
  364.     FILE* out;
  365.     long l;
  366.     {
  367.     if ( putc( ( l >> 24 ) & 0xff, out ) == EOF )
  368.     return -1;
  369.     if ( putc( ( l >> 16 ) & 0xff, out ) == EOF )
  370.     return -1;
  371.     if ( putc( ( l >> 8 ) & 0xff, out ) == EOF )
  372.     return -1;
  373.     if ( putc( l & 0xff, out ) == EOF )
  374.     return -1;
  375.     return 0;
  376.     }
  377.  
  378. int
  379. pm_readlittleshort( in, sP )
  380.     FILE* in;
  381.     short* sP;
  382.     {
  383.     int c;
  384.  
  385.     if ( (c = getc( in )) == EOF )
  386.     return -1;
  387.     *sP = c & 0xff;
  388.     if ( (c = getc( in )) == EOF )
  389.     return -1;
  390.     *sP |= ( c & 0xff ) << 8;
  391.     return 0;
  392.     }
  393.  
  394. #if __STDC__
  395. int
  396. pm_writelittleshort( FILE* out, short s )
  397. #else /*not __STDC__*/
  398. int
  399. pm_writelittleshort( out, s )
  400.     FILE* out;
  401.     short s;
  402. #endif /*not __STDC__*/
  403.     {
  404.     if ( putc( s & 0xff, out ) == EOF )
  405.     return -1;
  406.     if ( putc( ( s >> 8 ) & 0xff, out ) == EOF )
  407.     return -1;
  408.     return 0;
  409.     }
  410.  
  411. int
  412. pm_readlittlelong( in, lP )
  413.     FILE* in;
  414.     long* lP;
  415.     {
  416.     int c;
  417.  
  418.     if ( (c = getc( in )) == EOF )
  419.     return -1;
  420.     *lP = c & 0xff;
  421.     if ( (c = getc( in )) == EOF )
  422.     return -1;
  423.     *lP |= ( c & 0xff ) << 8;
  424.     if ( (c = getc( in )) == EOF )
  425.     return -1;
  426.     *lP |= ( c & 0xff ) << 16;
  427.     if ( (c = getc( in )) == EOF )
  428.     return -1;
  429.     *lP |= ( c & 0xff ) << 24;
  430.     return 0;
  431.     }
  432.  
  433. int
  434. pm_writelittlelong( out, l )
  435.     FILE* out;
  436.     long l;
  437.     {
  438.     if ( putc( l & 0xff, out ) == EOF )
  439.     return -1;
  440.     if ( putc( ( l >> 8 ) & 0xff, out ) == EOF )
  441.     return -1;
  442.     if ( putc( ( l >> 16 ) & 0xff, out ) == EOF )
  443.     return -1;
  444.     if ( putc( ( l >> 24 ) & 0xff, out ) == EOF )
  445.     return -1;
  446.     return 0;
  447.     }
  448.