Interlisp.maiko/src/cdrom.c

/* $Id: cdrom.c,v 1.3 1999/05/31 23:35:26 sybalsky Exp $ (C) Copyright Venue, All Rights Reserved */
static char *id = "$Id: cdrom.c,v 1.3 1999/05/31 23:35:26 sybalsky Exp $ Copyright (C) Venue";

/************************************************************************/
/*									*/
/*	(C) Copyright 1989-95 Venue. All Rights Reserved.		*/
/*	Manufactured in the United States of America.			*/
/*									*/
/*	The contents of this file are proprietary information 		*/
/*	belonging to Venue, and are provided to you under license.	*/
/*	They may not be further distributed or disclosed to third	*/
/*	parties without the specific permission of Venue.		*/
/*									*/
/************************************************************************/

#include "version.h"

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

        file: cdrom.c

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

#include <stdio.h>
#include <strings.h>
#include "lispemul.h"
#include "address.h"
#include "adr68k.h"
#include "lsptypes.h"
#include "lispmap.h"
#include "emlglob.h"
#include "lspglob.h"
#include "arith.h"
#include "cdrom.h"

int cdrom(LispPTR *args) {
  int request;
  int res;

  N_GETNUMBER(args[0], request, BAD_ARG);

#ifdef DEBUG
  printf("CD-ROM function called. function = %d\n", request);
#endif

  switch (request) {
    case CDROM_INIT_DRV: res = cdrom_init_drv(args); break;
    case CDROM_KEN_INT: res = cdrom_ken_int(args); break;
    case CDROM_CHOSAKU: res = cdrom_chosaku(args); break;
    case CDROM_MIKANA: res = cdrom_mikana(args); break;
    case CDROM_MIKANAT: res = cdrom_mikanat(args); break;
    case CDROM_SYURYO: res = cdrom_syuryo(args); break;
    default: return (NIL); break;
  }
#ifdef DEBUG
  printf("Result = %d\n", res);
#endif
  if (res == 0) {
    return (ATOM_T);
  } else {
    return (GetSmallp(res));
  }

BAD_ARG:
  return (NIL);
}

static int cdrom_init_drv(LispPTR *args)

/*
        args[0] function number
        args[1] pointer to buffer
        args[2] device name
*/
{
  int res;
  char *buff;
  char drive[80];
  LispPTR *naddress;
  char *base;
  int offset;

  if (GetTypeNumber(args[1]) == TYPE_ONED_ARRAY) {
    naddress = (LispPTR *)(Addr68k_from_LADDR(args[1]));
    base = (char *)(Addr68k_from_LADDR(((OneDArray *)naddress)->base));
    offset = (int)(((OneDArray *)naddress)->offset);
    buff = &base[offset];
  } else
    return (1);
  LispStringToCString(args[2], drive, 80);

  return (init_drv(buff, drive));
}

static int cdrom_ken_int(LispPTR *args)

/*
        args[0] function number
        args[1] shoseki number
        args[2] flag for index and sort
*/
{
  int bunno;
  int flg;

  N_GETNUMBER(args[1], bunno, BAD_ARG);
  N_GETNUMBER(args[2], flg, BAD_ARG);
#ifdef DEBUG
  printf("bunno = %x\n", bunno);
  printf("flg = %d\n", flg);
#endif
  return (ken_int(bunno, flg));

BAD_ARG:
  return (1);
}

static int cdrom_chosaku(LispPTR *args)

/*
        args[0] function number
        args[1] buffer for copy right data
        args[2] real data size
*/
{
  char *buff;
  int size;
  int *data_size;
  LispPTR *naddress;
  char *base;
  int offset;

  if (GetTypeNumber(args[1]) == TYPE_ONED_ARRAY) {
    naddress = (LispPTR *)(Addr68k_from_LADDR(args[1]));
    base = (char *)(Addr68k_from_LADDR(((OneDArray *)naddress)->base));
    offset = (int)(((OneDArray *)naddress)->offset);
    buff = &base[offset];
  } else
    return (1);
  size = (int)(((OneDArray *)naddress)->totalsize);
#ifdef DEBUG
  printf("size = %d\n", size);
#endif
  data_size = (int *)(Addr68k_from_LADDR(args[2]));
  return (chosaku(buff, size, data_size));
}

static int cdrom_mikana(LispPTR *args)

/*
        args[0] function number
        args[1] relative id number
        args[2] pointer to retrieve data
        args[3] size of retrieve data
*/
{
  int hyono;
  char *buff;
  int buff_size;
  int *data_size;
  LispPTR *naddress;
  char *base;
  int offset;

  N_GETNUMBER(args[1], hyono, BAD_ARG);
  if (GetTypeNumber(args[2]) == TYPE_ONED_ARRAY) {
    naddress = (LispPTR *)(Addr68k_from_LADDR(args[2]));
    base = (char *)(Addr68k_from_LADDR(((OneDArray *)naddress)->base));
    offset = (int)(((OneDArray *)naddress)->offset);
    buff = &base[offset];
  } else
    return (1);
  buff_size = (int)(((OneDArray *)naddress)->totalsize);
  data_size = (int *)(Addr68k_from_LADDR(args[3]));
  return (mikana(hyono, buff, buff_size, data_size));

BAD_ARG:
  return (1);
}

static int cdrom_mikanat(LispPTR *args)

/*
        args[0] function number
        args[1] pointer to a search key
        args[2] pointer to buffer
        args[3] size of searched data
        args[4] nuber of items matched to the search key
*/
{
  char key[65];
  char *buff;
  int buff_size;
  int *data_size;
  int *hitn;
  LispPTR *naddress;
  char *base;
  int offset;

  LispStringToCString2(args[1], key, 65);
  if (GetTypeNumber(args[2]) == TYPE_ONED_ARRAY) {
    naddress = (LispPTR *)(Addr68k_from_LADDR(args[2]));
    base = (char *)(Addr68k_from_LADDR(((OneDArray *)naddress)->base));
    offset = (int)(((OneDArray *)naddress)->offset);
    buff = &base[offset];
  } else
    return (1);
  buff_size = (((OneDArray *)naddress)->totalsize);
  data_size = (int *)(Addr68k_from_LADDR(args[3]));
  hitn = (int *)(Addr68k_from_LADDR(args[4]));

  return (mikanat(key, buff, buff_size, data_size, hitn));
}

static int cdrom_syuryo(LispPTR *args)

/*
        args[0] function number
*/
{
  return (syuryo());
}