Return to gd_io.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / gd / libgd

Annotation of embedaddon/php/ext/gd/libgd/gd_io.c, revision 1.1.1.1

1.1       misho       1: 
                      2: 
                      3: /*
                      4:    * io.c
                      5:    *
                      6:    * Implements the simple I/O 'helper' routines.
                      7:    *
                      8:    * Not really essential, but these routines were used extensively in GD,
                      9:    * so they were moved here. They also make IOCtx calls look better...
                     10:    *
                     11:    * Written (or, at least, moved) 1999, Philip Warner.
                     12:    *
                     13:  */
                     14: 
                     15: #include <math.h>
                     16: #include <string.h>
                     17: #include <stdlib.h>
                     18: #include "gd.h"
                     19: 
                     20: /* Use this for commenting out debug-print statements. */
                     21: /* Just use the first '#define' to allow all the prints... */
                     22: /*#define IO_DBG(s) (s) */
                     23: #define IO_DBG(s)
                     24: 
                     25: 
                     26: #define GD_IO_EOF_CHK(r)       \
                     27:        if (r == EOF) {         \
                     28:                return 0;       \
                     29:        }                       \
                     30: 
                     31: /*
                     32:  * Write out a word to the I/O context pointer
                     33:  */
                     34: void Putword (int w, gdIOCtx * ctx)
                     35: {
                     36:        unsigned char buf[2];
                     37: 
                     38:        buf[0] = w & 0xff;
                     39:        buf[1] = (w / 256) & 0xff;
                     40:        (ctx->putBuf) (ctx, (char *) buf, 2);
                     41: }
                     42: 
                     43: void Putchar (int c, gdIOCtx * ctx)
                     44: {
                     45:        (ctx->putC) (ctx, c & 0xff);
                     46: }
                     47: 
                     48: void gdPutC (const unsigned char c, gdIOCtx * ctx)
                     49: {
                     50:        (ctx->putC) (ctx, c);
                     51: }
                     52: 
                     53: void gdPutWord (int w, gdIOCtx * ctx)
                     54: {
                     55:        IO_DBG (php_gd_error("Putting word..."));
                     56:        (ctx->putC) (ctx, (unsigned char) (w >> 8));
                     57:        (ctx->putC) (ctx, (unsigned char) (w & 0xFF));
                     58:        IO_DBG (php_gd_error("put."));
                     59: }
                     60: 
                     61: void gdPutInt (int w, gdIOCtx * ctx)
                     62: {
                     63:        IO_DBG (php_gd_error("Putting int..."));
                     64:        (ctx->putC) (ctx, (unsigned char) (w >> 24));
                     65:        (ctx->putC) (ctx, (unsigned char) ((w >> 16) & 0xFF));
                     66:        (ctx->putC) (ctx, (unsigned char) ((w >> 8) & 0xFF));
                     67:        (ctx->putC) (ctx, (unsigned char) (w & 0xFF));
                     68:        IO_DBG (php_gd_error("put."));
                     69: }
                     70: 
                     71: int gdGetC (gdIOCtx * ctx)
                     72: {
                     73:        return ((ctx->getC) (ctx));
                     74: }
                     75: 
                     76: int gdGetByte (int *result, gdIOCtx * ctx)
                     77: {
                     78:        int r;
                     79:        r = (ctx->getC) (ctx);
                     80:        GD_IO_EOF_CHK(r);
                     81:        *result = r;
                     82:        return 1;
                     83: }
                     84: 
                     85: int gdGetWord (int *result, gdIOCtx * ctx)
                     86: {
                     87:        int r;
                     88:        r = (ctx->getC) (ctx);
                     89:        GD_IO_EOF_CHK(r);
                     90:        *result = r << 8;
                     91:        r = (ctx->getC) (ctx);
                     92:        GD_IO_EOF_CHK(r);
                     93:        *result += r;
                     94:        return 1;
                     95: }
                     96: 
                     97: 
                     98: int gdGetInt (int *result, gdIOCtx * ctx)
                     99: {
                    100:        int r;
                    101:        r = (ctx->getC) (ctx);
                    102:        GD_IO_EOF_CHK(r);
                    103:        *result = r << 24;
                    104: 
                    105:        r = (ctx->getC) (ctx);
                    106:        GD_IO_EOF_CHK(r);
                    107:        *result += r << 16;
                    108: 
                    109:        r = (ctx->getC) (ctx);
                    110:        if (r == EOF) {
                    111:                return 0;
                    112:        }
                    113:        *result += r << 8;
                    114: 
                    115:        r = (ctx->getC) (ctx);
                    116:        GD_IO_EOF_CHK(r);
                    117:        *result += r;
                    118: 
                    119:        return 1;
                    120: }
                    121: 
                    122: int gdPutBuf (const void *buf, int size, gdIOCtx * ctx)
                    123: {
                    124:        IO_DBG (php_gd_error("Putting buf..."));
                    125:        return (ctx->putBuf) (ctx, buf, size);
                    126:        IO_DBG (php_gd_error("put."));
                    127: }
                    128: 
                    129: int gdGetBuf (void *buf, int size, gdIOCtx * ctx)
                    130: {
                    131:        return (ctx->getBuf) (ctx, buf, size);
                    132: }
                    133: 
                    134: int gdSeek (gdIOCtx * ctx, const int pos)
                    135: {
                    136:        IO_DBG (php_gd_error("Seeking..."));
                    137:        return ((ctx->seek) (ctx, pos));
                    138:        IO_DBG (php_gd_error("Done."));
                    139: }
                    140: 
                    141: long gdTell (gdIOCtx * ctx)
                    142: {
                    143:        IO_DBG (php_gd_error("Telling..."));
                    144:        return ((ctx->tell) (ctx));
                    145:        IO_DBG (php_gd_error ("told."));
                    146: }