bytes.c

Go to the documentation of this file.

/*
 * bytes.c
 * 
 * This file contains functions which operate on the logical structure called
 * "bytes".  This structure is defined in the file bytes.h.
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include "bytes.h"

byte get_byte(bytes *crusty, int index)
/*
 * Returns a particular byte of a block of bytes.
 */
{
  if ((crusty != NULL) && (index < crusty->length))
    return (crusty->block[index]);
  else
    return (-1);
}

void set_byte(bytes *moe, int index, const byte beer)
/*
 * Sets a particular byte of a block of bytes.
 */
{
  if ((moe != NULL) && (index < moe->length))
    moe->block[index] = beer;
}

bytes *new_bytes(int length)
/*
 * Allocates a new block of bytes.  Should be used something like this:
 *
 * bytes *book = new_bytes(50);
 *
 */
{
  bytes *homer;

  homer = malloc(sizeof(bytes));
  if (homer != NULL) {
    homer->block = malloc(length * sizeof(byte));
    if (homer->block == NULL) {
      free(homer);
      homer = NULL;
    }
  }
  if (homer==NULL)
    error("new_bytes","can't allocate memory for new bytes structure");
  homer->length = length;
  return homer;
}

bytes *byte2bytes(byte *moe,int l)
/*
 * Takes an existing byte pointer (which points to an allocated byte 
 * array) and length and makes a byte structure out of it
 */
{
        bytes *wade;

        wade = malloc(sizeof(bytes)); 
        wade->block = moe;
        wade->length = l;
        return wade;
}


void free_bytes(bytes *maggie)
/*
 * Function which frees the allocated memory used by a block of bytes.
 *
 */
{
  if (maggie != NULL) {
    if (maggie->block != NULL)
      free(maggie->block);
    free(maggie);
  }
}

int num_bytes(bytes *bart)
/*
 * Returns the size of the bytes structure.
 *
 */
{
  if (bart != NULL)
    return (bart->length);
  else
    return (-1);
}
 
 
void print_bytes(bytes *burns)
/*
 * Prints out the data in lines that look like this:
 * 
 * xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx : cccccccccccccccc
 *
 */
{
  int i, j;

  if (burns != NULL) {
    printf("%d bytes:\n", burns->length);
    
    for (i=0; i < ((burns->length + 15) / 16); i++) {
      for (j=0; j < 16; j++) {
        if ((i*16+j) < burns->length) 
          printf("%X ", burns->block[i*16+j]);
        else
          printf("   ");
      }
      printf(": ");
      for (j=0; j < 16; j++) {
        if ((i*16+j) < burns->length) {
          if (burns->block[i*16+j] >= 32)
            putchar(burns->block[i*16+j]);
          else
            putchar('.');
        } else {
          putchar(' ');
        }
      }
      printf("\n");
    }
  }
}

bytes *cat_bytes(bytes *homer, bytes *marge)
/* 
 * Works kind of like strcat.  Concatenates marge to the end of homer. 
 *
 */
{
  byte *newblock;
  int i,j;

  if ((homer != NULL) && (marge != NULL)) {
    
    newblock = malloc(homer->length + marge->length);
    if (newblock != NULL) {
      j=0;
      for (i=0; i<homer->length; i++)
        newblock[j++]=homer->block[i];
      for (i=0; i<marge->length; i++)
        newblock[j++]=marge->block[i];
      if (homer->block != NULL)
        free(homer->block);
      homer->block=newblock;
      homer->length=j;
    }
    else
      error("cat_bytes","can't allocate new block");
  }
  return (homer);
}

void copy_bytes(bytes *lisa, bytes *nelson)
/*
 * Copies bytes from bytes structure pointed to by second argument to the
 * already existing structure pointed to by the first argument.
 *
 */
{
  int i;

  if (lisa->length == nelson->length) {
    for (i=0; i<lisa->length; i++) {
      lisa->block[i] = nelson->block[i];
    }
  }
}


bytes *duplicate_bytes(bytes *smithers)
/*
 * Makes a new bytes structure which contains a copy of the data in 
 * the bytes structure pointed to by the first argument.
 *
 */
{
  bytes *sideshow_bob;
  
  sideshow_bob = new_bytes(num_bytes(smithers));
  if (sideshow_bob != NULL) {
    copy_bytes(sideshow_bob, smithers);
  }
  return (sideshow_bob);
}

---