/**********************************************************************
 * File:        serialis.h  (Formerly serialmac.h)
 * Description: Inline routines and macros for serialisation functions
 * Author:      Phil Cheatle
 * Created:     Tue Oct 08 08:33:12 BST 1991
 *
 * (C) Copyright 1990, Hewlett-Packard Ltd.
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 ** http://www.apache.org/licenses/LICENSE-2.0
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.
 *
 **********************************************************************/

#include          "mfcpch.h"     //precompiled headers
#include "serialis.h"
#include "scanutils.h"

/* **************************************************************************

These are the only routines that write/read data to/from the serialisation.

"serialise_bytes" and "de_serialise_bytes" are used to serialise NON class
items.  The "make_serialise" macro generates "serialise" and "de_serialise"
member functions for the class name specified in the macro parameter.

************************************************************************** */

DLLSYM void *de_serialise_bytes(FILE *f, int size) {
  void *ptr;

  ptr = alloc_mem (size);
  /*
  printf( "De_serialising bytes\n" );
  printf( "  Addr: %d    Size: %d\n", int(ptr), size );
  */
  if (fread (ptr, size, 1, f) != 1)
    READFAILED.error ("de_serialise_bytes", ABORT, NULL);
  return ptr;
}


DLLSYM void serialise_bytes(FILE *f, void *ptr, int size) {
  /*
  printf( "Serialising bytes\n" );
  printf( "  Addr: %d    Size: %d\n", int(ptr), size );
  */
  if (fwrite (ptr, size, 1, f) != 1)
    WRITEFAILED.error ("serialise_bytes", ABORT, NULL);
}


DLLSYM void serialise_INT32(FILE *f, inT32 the_int) {
  if (fprintf (f, INT32FORMAT "\n", the_int) < 0)
    WRITEFAILED.error ("serialise_INT32", ABORT, NULL);
}


DLLSYM inT32 de_serialise_INT32(FILE *f) {
  inT32 the_int;

  if (fscanf (f, INT32FORMAT, &the_int) != 1)
    READFAILED.error ("de_serialise_INT32", ABORT, NULL);
  return the_int;
}


DLLSYM void serialise_FLOAT64(FILE *f, double the_float) {
  if (fprintf (f, "%g\n", the_float) < 0)
    WRITEFAILED.error ("serialise_FLOAT64", ABORT, NULL);
}


DLLSYM double de_serialise_FLOAT64(FILE *f) {
  double the_float;

  if (fscanf (f, "%lg", &the_float) != 1)
    READFAILED.error ("de_serialise_FLOAT64", ABORT, NULL);
  return the_float;
}

// Byte swap an inT64 or uinT64.
DLLSYM uinT64 reverse64(uinT64 num) {
  return ((uinT64)reverse32((uinT32)(num & 0xffffffff)) << 32)
    | reverse32((uinT32)((num >> 32) & 0xffffffff));
}

/**********************************************************************
 * reverse32
 *
 * Byte swap an inT32 or uinT32.
 **********************************************************************/

DLLSYM uinT32 reverse32(            //switch endian
                        uinT32 num  //number to fix
                       ) {
  return (reverse16 ((uinT16) (num & 0xffff)) << 16)
    | reverse16 ((uinT16) ((num >> 16) & 0xffff));
}


/**********************************************************************
 * reverse16
 *
 * Byte swap an inT16 or uinT16.
 **********************************************************************/

DLLSYM uinT16 reverse16(            //switch endian
                        uinT16 num  //number to fix
                       ) {
  return ((num & 0xff) << 8) | ((num >> 8) & 0xff);
}