/*
 * mdextend.c
 *
 * Summary:  Implement routines prototyped in mdextend.h
 *
 * Author:  David Hardy
 */

#include "mdsim.h"


MD_Errcode MD_set_isdone(MD_Sim *sim, MD_Int (*isdone)(MD_Sim *))
{
  if (sim->version != MD_API_VERSION) {
    ERR(sim, MD_ERR_VERSION, "MD_set_isdone");
    return MD_FAIL;
  }
  else if (sim->iscreated) {
    ERR(sim, MD_ERR_USE, "MD_set_isdone");
    return MD_FAIL;
  }
  sim->isdone = isdone;
  return 0;
}


MD_Errcode MD_set_wait(MD_Sim *sim, MD_Errcode (*wait)(MD_Sim *))
{
  if (sim->version != MD_API_VERSION) {
    ERR(sim, MD_ERR_VERSION, "MD_set_wait");
    return MD_FAIL;
  }
  else if (sim->iscreated) {
    ERR(sim, MD_ERR_USE, "MD_set_wait");
    return MD_FAIL;
  }
  sim->wait = wait;
  return 0;
}


MD_Errcode MD_set_prcb(MD_Sim *sim, MD_Errcode (*prcb)(MD_Sim *, MD_Callback *))
{ 
  if (sim->version != MD_API_VERSION) {
    ERR(sim, MD_ERR_VERSION, "MD_set_prcb");
    return MD_FAIL;
  }
  else if (sim->iscreated) {
    ERR(sim, MD_ERR_USE, "MD_set_prcb");
    return MD_FAIL;
  }
  sim->prcb = prcb;
  return 0;
}
  
    
MD_Errcode MD_set_isdoneprcb(MD_Sim *sim, MD_Int (*isdoneprcb)(MD_Sim *))
{ 
  if (sim->version != MD_API_VERSION) {
    ERR(sim, MD_ERR_VERSION, "MD_set_isdoneprcb");
    return MD_FAIL;
  }
  else if (sim->iscreated) {
    ERR(sim, MD_ERR_USE, "MD_set_isdoneprcb");
    return MD_FAIL;
  }
  sim->isdoneprcb = isdoneprcb;
  return 0;
}


MD_Errcode MD_flip_bytes(MD_Sim *sim, void *vbuf, MD_Int nelems, MD_Int typenum)
{
  char *buf = (char *) vbuf;
  MD_Int index = INDEX(typenum);
  MD_Int *flipoffset;
  MD_Int flipoffsetlen;
  MD_Int i, j;
  char tmp;

  /* check validity of typenum */
  if (index < 0 || index >= sim->typelen
      || typenum != sim->type[index].typenum) {
    ERR(sim, MD_ERR_TYPENUM, "MD_reverse_byteorder");
    return MD_FAIL;
  }

  flipoffset = sim->type[index].flipoffset;
  flipoffsetlen = sim->type[index].flipoffsetlen;

  switch (typenum & MD_FLIP_MASK) {
  case MD_FLIP_NONE:
    return 0;

  case MD_FLIP_4_BYTE:
    for (i = 0;  i < nelems;  i++) {
      tmp=buf[0]; buf[0]=buf[3]; buf[3]=tmp;
      tmp=buf[1]; buf[1]=buf[2]; buf[2]=tmp;
      buf += 4;
    }
    break;

  case MD_FLIP_8_BYTE:
    for (i = 0;  i < nelems;  i++) {
      tmp=buf[0]; buf[0]=buf[7]; buf[7]=tmp;
      tmp=buf[1]; buf[1]=buf[6]; buf[6]=tmp;
      tmp=buf[2]; buf[2]=buf[5]; buf[5]=tmp;
      tmp=buf[3]; buf[3]=buf[4]; buf[4]=tmp;
      buf += 8;
    }
    break;

  case MD_FLIP_12_BYTE:
    for (i = 0;  i < nelems;  i++) {
      tmp=buf[0]; buf[0]=buf[3]; buf[3]=tmp;
      tmp=buf[1]; buf[1]=buf[2]; buf[2]=tmp;
      tmp=buf[4]; buf[4]=buf[7]; buf[7]=tmp;
      tmp=buf[5]; buf[5]=buf[6]; buf[6]=tmp;
      tmp=buf[8]; buf[8]=buf[11]; buf[11]=tmp;
      tmp=buf[9]; buf[9]=buf[10]; buf[10]=tmp;
      buf += 12;
    }
    break;

  case MD_FLIP_24_BYTE:
    for (i = 0;  i < nelems;  i++) {
      tmp=buf[0]; buf[0]=buf[7]; buf[7]=tmp;
      tmp=buf[1]; buf[1]=buf[6]; buf[6]=tmp;
      tmp=buf[2]; buf[2]=buf[5]; buf[5]=tmp;
      tmp=buf[3]; buf[3]=buf[4]; buf[4]=tmp;
      tmp=buf[8]; buf[8]=buf[15]; buf[15]=tmp;
      tmp=buf[9]; buf[9]=buf[14]; buf[14]=tmp;
      tmp=buf[10]; buf[10]=buf[13]; buf[13]=tmp;
      tmp=buf[11]; buf[11]=buf[12]; buf[12]=tmp;
      tmp=buf[16]; buf[16]=buf[23]; buf[23]=tmp;
      tmp=buf[17]; buf[17]=buf[22]; buf[22]=tmp;
      tmp=buf[18]; buf[18]=buf[21]; buf[21]=tmp;
      tmp=buf[19]; buf[19]=buf[20]; buf[20]=tmp;
      buf += 24;
    }
    break;

  case MD_FLIP_COMPOSITE:
    for (i = 0;  i < nelems;  i++) {
      for (j = 0;  j < flipoffsetlen;  j++) {
        buf += (flipoffset[j] & 0xFFFF);
        switch (flipoffset[j] & MD_FLIP_MASK) {
        case MD_FLIP_4_BYTE:
          tmp=buf[0]; buf[0]=buf[3]; buf[3]=tmp;
          tmp=buf[1]; buf[1]=buf[2]; buf[2]=tmp;
          break;
        case MD_FLIP_8_BYTE:
          tmp=buf[0]; buf[0]=buf[7]; buf[7]=tmp;
          tmp=buf[1]; buf[1]=buf[6]; buf[6]=tmp;
          tmp=buf[2]; buf[2]=buf[5]; buf[5]=tmp;
          tmp=buf[3]; buf[3]=buf[4]; buf[4]=tmp;
          break;
        case MD_FLIP_12_BYTE:
          tmp=buf[0]; buf[0]=buf[3]; buf[3]=tmp;
          tmp=buf[1]; buf[1]=buf[2]; buf[2]=tmp;
          tmp=buf[4]; buf[4]=buf[7]; buf[7]=tmp;
          tmp=buf[5]; buf[5]=buf[6]; buf[6]=tmp;
          tmp=buf[8]; buf[8]=buf[11]; buf[11]=tmp;
          tmp=buf[9]; buf[9]=buf[10]; buf[10]=tmp;
          break;
        case MD_FLIP_24_BYTE:
          tmp=buf[0]; buf[0]=buf[7]; buf[7]=tmp;
          tmp=buf[1]; buf[1]=buf[6]; buf[6]=tmp;
          tmp=buf[2]; buf[2]=buf[5]; buf[5]=tmp;
          tmp=buf[3]; buf[3]=buf[4]; buf[4]=tmp;
          tmp=buf[8]; buf[8]=buf[15]; buf[15]=tmp;
          tmp=buf[9]; buf[9]=buf[14]; buf[14]=tmp;
          tmp=buf[10]; buf[10]=buf[13]; buf[13]=tmp;
          tmp=buf[11]; buf[11]=buf[12]; buf[12]=tmp;
          tmp=buf[16]; buf[16]=buf[23]; buf[23]=tmp;
          tmp=buf[17]; buf[17]=buf[22]; buf[22]=tmp;
          tmp=buf[18]; buf[18]=buf[21]; buf[21]=tmp;
          tmp=buf[19]; buf[19]=buf[20]; buf[20]=tmp;
          break;
        default:
          ERR(sim, MD_ERR_TYPENUM, "MD_flip_bytes: invalid flipoffset");
          return MD_FAIL;
        }
      } /* end for j loop */
      buf += flipoffset[j];  /* the (j+1) term is defined */
    } /* end for i loop */
    break;

  default:
    ERR(sim, MD_ERR_TYPENUM, "MD_flip_bytes: incorrect flip flags");
    return MD_FAIL;
  }
  return 0;
}

#if 0
  char *buf = (char *) vbuf;
  MD_Int index = INDEX(typenum);
  MD_Int stacksize = 0;
  MD_Int i;
  char tmp;

  /* check validity of typenum */
  if (index < 0 || index >= sim->typelen
      || typenum != sim->type[index].typenum) {
    ERR(sim, MD_ERR_TYPENUM, "MD_reverse_byteorder");
    return MD_FAIL;
  }

  sim->typestack[stacksize++] = typenum;
  while (stacksize > 0) {
    typenum = sim->typestack[--stacksize];
    index = INDEX(typenum);
    switch (typenum) {
    case MD_CHAR:
    case MD_SHORT_STRING:
    case MD_STRING:
      buf += MD_SIZEOF(typenum);
      break;

    case MD_INT:
    case MD_FLOAT:
      tmp=buf[0]; buf[0]=buf[3]; buf[3]=tmp;
      tmp=buf[1]; buf[1]=buf[2]; buf[2]=tmp;
      buf += 4;
      break;

    case MD_FVEC:
      tmp=buf[0]; buf[0]=buf[3]; buf[3]=tmp;
      tmp=buf[1]; buf[1]=buf[2]; buf[2]=tmp;
      buf += 4;
      tmp=buf[0]; buf[0]=buf[3]; buf[3]=tmp;
      tmp=buf[1]; buf[1]=buf[2]; buf[2]=tmp;
      buf += 4;
      tmp=buf[0]; buf[0]=buf[3]; buf[3]=tmp;
      tmp=buf[1]; buf[1]=buf[2]; buf[2]=tmp;
      buf += 4;
      break;

    case MD_DOUBLE:
      tmp=buf[0]; buf[0]=buf[7]; buf[7]=tmp;
      tmp=buf[1]; buf[1]=buf[6]; buf[6]=tmp;
      tmp=buf[2]; buf[2]=buf[5]; buf[5]=tmp;
      tmp=buf[3]; buf[3]=buf[4]; buf[4]=tmp;
      buf += 8;
      break;

    case MD_DVEC:
      tmp=buf[0]; buf[0]=buf[7]; buf[7]=tmp;
      tmp=buf[1]; buf[1]=buf[6]; buf[6]=tmp;
      tmp=buf[2]; buf[2]=buf[5]; buf[5]=tmp;
      tmp=buf[3]; buf[3]=buf[4]; buf[4]=tmp;
      buf += 8;
      tmp=buf[0]; buf[0]=buf[7]; buf[7]=tmp;
      tmp=buf[1]; buf[1]=buf[6]; buf[6]=tmp;
      tmp=buf[2]; buf[2]=buf[5]; buf[5]=tmp;
      tmp=buf[3]; buf[3]=buf[4]; buf[4]=tmp;
      buf += 8;
      tmp=buf[0]; buf[0]=buf[7]; buf[7]=tmp;
      tmp=buf[1]; buf[1]=buf[6]; buf[6]=tmp;
      tmp=buf[2]; buf[2]=buf[5]; buf[5]=tmp;
      tmp=buf[3]; buf[3]=buf[4]; buf[4]=tmp;
      buf += 8;
      break;

    default:
      /* not a primitive type, must push its subtype array onto stack */
      /* already done in validate_type, don't need to check stack overflow */
      for (i = sim->type[index].subtypelen - 1;  i >= 0;  i--) {
        sim->typestack[stacksize++] = sim->type[index].subtype[i];
      }
    }
  }
  return 0;
}
#endif