



		    discard_.pl1                    08/14/86  1450.1rew 08/14/86  1422.0      119844



/****^  ***********************************************************
        *                                                         *
        * Copyright, (C) Honeywell Information Systems Inc., 1982 *
        *                                                         *
        * Copyright (c) 1972 by Massachusetts Institute of        *
        * Technology and Honeywell Information Systems, Inc.      *
        *                                                         *
        *********************************************************** */

/* format: style4,delnl,insnl,ifthenstmt,indnoniterend */

/* Modified 05/15/84 by Jim Lippard to free attach data on detach */


/****^  HISTORY COMMENTS:
  1) change(86-06-20,Kissel), approve(86-07-23,MCR7455), audit(86-07-31,Ex),
     install(86-08-14,MR12.0-1126):
     Modified to handle all opening modes and IOX operations.  Also added the
     correct cleanup protocol around calls to hcs_$(set reset)_ips_mask.
                                                   END HISTORY COMMENTS */


discard_:
     proc ();

RETURN:
	return;

/* Parameters. */

dcl  actlen fixed bin (21) parameter;
dcl  args (*) char (*) varying parameter;
dcl  buflen fixed (21) parameter;
dcl  bufptr ptr parameter;
dcl  Code fixed bin (35) parameter;
dcl  extend_bit bit (1) aligned parameter;
dcl  infptr ptr parameter;
dcl  Iocb_ptr ptr parameter;
dcl  key char (256) varying parameter;
dcl  len fixed (21) parameter;
dcl  loud_sw bit (1) aligned parameter;
dcl  mode fixed bin parameter;
dcl  newmode char (*) parameter;
dcl  oldmode char (*) parameter;
dcl  order char (*) parameter;
dcl  position_type fixed bin parameter;
dcl  position_n fixed bin (21) parameter;

/* Automatic. */

dcl  blkptr ptr;
dcl  iocb_ptr ptr;
dcl  mask bit (36) aligned;

/* Based. */

dcl  based_area area based;

dcl  1 IOCB aligned like iocb based (iocb_ptr);

dcl  1 blk aligned based (blkptr),
       2 attach char (8) varying,
       2 open char (31) varying;

/* Procedures. */

dcl  com_err_ entry () options (variable);
dcl  continue_to_signal_ entry (fixed bin (35));
dcl  get_system_free_area_ entry () returns (ptr);
dcl  hcs_$set_ips_mask entry (bit (36) aligned, bit (36) aligned);
dcl  hcs_$reset_ips_mask entry (bit (36) aligned, bit (36) aligned);

/* Constants. */

dcl  error_table_$bad_mode fixed (35) ext;
dcl  error_table_$end_of_info fixed bin (35) ext static;
dcl  error_table_$no_record fixed (35) ext;
dcl  error_table_$not_detached fixed (35) ext;
dcl  error_table_$wrong_no_of_args fixed (35) ext;
dcl  error_table_$no_operation fixed (35) ext;

/* Built-in. */

dcl  (addr, hbound, lbound, null, substr) builtin;

/* Conditions. */

dcl  any_other condition;
dcl  cleanup condition;

/* End of declarations. */

/* Beginning of entry point ..... discard_discard_attach(Iocb_ptr,args,loud_sw) ..... */

discard_attach:
     entry (Iocb_ptr, args, loud_sw, Code);

	mask = ""b;
	iocb_ptr = Iocb_ptr;
	on cleanup call Cleanup_Handler ();
	on any_other call Any_Other_Handler ();
	call hcs_$set_ips_mask (""b, mask);

	if IOCB.attach_descrip_ptr ^= null () then do;
	     call Cleanup_Handler ();
	     if loud_sw then call com_err_ (error_table_$not_detached, "discard_");
	     Code = error_table_$not_detached;
	     end;
	else do;
	     allocate blk in (get_system_free_area_ () -> based_area) set (blkptr);
	     blk.attach = "discard_";
	     blk.open = "";
	     IOCB.attach_descrip_ptr = addr (blk.attach);
	     IOCB.attach_data_ptr = blkptr;
	     IOCB.detach_iocb = discard_detach;
	     IOCB.open = discard_open;
	     IOCB.modes = iox_$err_not_open;
	     IOCB.control = iox_$err_not_open;
	     call iox_$propagate (iocb_ptr);
	     call hcs_$reset_ips_mask (mask, mask);
	     Code = 0;
	     end;
	call GOTO_RETURN ();

/* End of entry point ..... discard_$discard_attach(Iocb_ptr,args,loud_sw) ..... */





/* Handler for the 'detach_iocb' I/O operation. */

discard_detach:
     entry (Iocb_ptr, Code);
	mask = ""b;
	iocb_ptr = Iocb_ptr;
	on cleanup call Cleanup_Handler ();
	on any_other call Any_Other_Handler ();
	call hcs_$set_ips_mask (""b, mask);
	blkptr = IOCB.attach_data_ptr;
	IOCB.attach_descrip_ptr, IOCB.attach_data_ptr = null ();
	IOCB.detach_iocb = iox_$err_not_attached;
	IOCB.open = iox_$err_not_attached;
	call iox_$propagate (iocb_ptr);
	call hcs_$reset_ips_mask (mask, mask);
	Code = 0;
	free blkptr -> blk;
	call GOTO_RETURN ();

/* End of 'detach_iocb' handler. */





/* Handler for the 'open' I/O operation. */

discard_open:
     entry (Iocb_ptr, mode, extend_bit, Code);
	mask = ""b;
	on cleanup call Cleanup_Handler ();
	on any_other call Any_Other_Handler ();
	call hcs_$set_ips_mask (""b, mask);
	iocb_ptr = Iocb_ptr -> iocb.actual_iocb_ptr;
	blkptr = IOCB.attach_data_ptr;

	if mode > lbound (iox_modes, 1) & mode < hbound (iox_modes, 1)
	then blk.open = iox_modes (mode);
	else do;
	     call Cleanup_Handler ();
	     Code = error_table_$bad_mode;
	     call GOTO_RETURN ();
	     end;

	if mode = Stream_input then do;
	     IOCB.get_line = discard_get_chars;		/* We always return 0 anyway. */
	     IOCB.get_chars = discard_get_chars;
	     IOCB.position = discard_position;
	     end;

	else if mode = Stream_output then IOCB.put_chars = discard_put_chars;

	else if mode = Stream_input_output then do;
	     IOCB.get_line = discard_get_chars;		/* We always return 0 anyway. */
	     IOCB.get_chars = discard_get_chars;
	     IOCB.put_chars = discard_put_chars;
	     IOCB.position = discard_position;
	     end;

	else if mode = Sequential_input then do;
	     IOCB.read_record = discard_read;
	     IOCB.read_length = discard_read_length;
	     IOCB.position = discard_position;
	     end;

	else if mode = Sequential_output then do;
	     IOCB.write_record = discard_write;
	     IOCB.position = discard_position;
	     end;

	else if mode = Sequential_input_output then do;
	     IOCB.read_record = discard_read;
	     IOCB.read_length = discard_read_length;
	     IOCB.write_record = discard_write;
	     IOCB.position = discard_position;
	     end;

	else if mode = Sequential_update then do;
	     IOCB.read_record = discard_read;
	     IOCB.read_length = discard_read_length;
	     IOCB.write_record = discard_write;
	     IOCB.rewrite_record = discard_write;	/* It's all the same to us. */
	     IOCB.delete_record = discard_delete;
	     IOCB.position = discard_position;
	     end;

	else if mode = Keyed_sequential_input then do;
	     IOCB.read_record = discard_read;
	     IOCB.read_length = discard_read_length;
	     IOCB.position = discard_position;
	     IOCB.seek_key = discard_seek_key;
	     IOCB.read_key = discard_seek_key;		/* They have the same calling sequence. */
	     end;

	else if mode = Keyed_sequential_output then do;
	     IOCB.write_record = discard_write;
	     IOCB.seek_key = discard_seek_key;
	     end;

	else if mode = Keyed_sequential_update then do;
	     IOCB.read_record = discard_read;
	     IOCB.delete_record = discard_delete;
	     IOCB.read_length = discard_read_length;
	     IOCB.position = discard_position;
	     IOCB.seek_key = discard_seek_key;
	     IOCB.read_key = discard_seek_key;		/* They have the same calling sequence. */
	     IOCB.write_record = discard_write;
	     IOCB.rewrite_record = discard_write;	/* It's all the same to us. */
	     end;

	else if mode = Direct_input then do;
	     IOCB.read_record = discard_read;
	     IOCB.read_length = discard_read_length;
	     IOCB.seek_key = discard_seek_key;
	     end;

	else if mode = Direct_output then do;
	     IOCB.write_record = discard_write;
	     IOCB.seek_key = discard_seek_key;
	     end;

	else if mode = Direct_update then do;
	     IOCB.read_record = discard_read;
	     IOCB.rewrite_record = discard_write;	/* It's all the same to us. */
	     IOCB.delete_record = discard_delete;
	     IOCB.read_length = discard_read_length;
	     IOCB.seek_key = discard_seek_key;
	     IOCB.write_record = discard_write;
	     end;

	else ;					/* We already checked the mode above. */

	if extend_bit then blk.open = blk.open || " -extend";

	IOCB.open_descrip_ptr = addr (blk.open);
	IOCB.detach_iocb = iox_$err_not_closed;
	IOCB.open = iox_$err_not_closed;
	IOCB.close = discard_close;
	IOCB.modes = discard_modes;
	IOCB.control = discard_control;

	call iox_$propagate (iocb_ptr);
	call hcs_$reset_ips_mask (mask, mask);

	Code = 0;
	call GOTO_RETURN ();

/* End of 'open' handler. */





/* Handler for the 'close' I/O operation. */

discard_close:
     entry (Iocb_ptr, Code);
	mask = ""b;
	on cleanup call Cleanup_Handler ();
	on any_other call Any_Other_Handler ();
	call hcs_$set_ips_mask (""b, mask);
	iocb_ptr = Iocb_ptr -> iocb.actual_iocb_ptr;
	blkptr = IOCB.attach_data_ptr;
	IOCB.open_descrip_ptr = null ();
	IOCB.detach_iocb = discard_detach;
	IOCB.open = discard_open;
	IOCB.close = iox_$err_not_open;
	IOCB.get_line = iox_$err_not_open;
	IOCB.get_chars = iox_$err_not_open;
	IOCB.put_chars = iox_$err_not_open;
	IOCB.modes = iox_$err_not_open;
	IOCB.position = iox_$err_not_open;
	IOCB.control = iox_$err_not_open;
	IOCB.read_record = iox_$err_not_open;
	IOCB.write_record = iox_$err_not_open;
	IOCB.rewrite_record = iox_$err_not_open;
	IOCB.delete_record = iox_$err_not_open;
	IOCB.seek_key = iox_$err_not_open;
	IOCB.read_key = iox_$err_not_open;
	IOCB.read_length = iox_$err_not_open;
	call iox_$propagate (iocb_ptr);
	call hcs_$reset_ips_mask (mask, mask);
	Code = 0;
	call GOTO_RETURN ();

/* End of 'close' handler. */





/* Handler for the 'get_line' and  'get_chars' I/O operations. */

discard_get_chars:
     entry (Iocb_ptr, bufptr, buflen, actlen, Code);
	actlen = 0;
	Code = error_table_$end_of_info;
	call GOTO_RETURN ();

/* End of 'get_line' and  'get_chars' handlers. */





/* Handler for the 'put_chars' I/O operation. */

discard_put_chars:
     entry (Iocb_ptr, bufptr, buflen, Code);
	Code = 0;
	call GOTO_RETURN ();

/* End of 'put_chars' handler. */





/* Handler for the 'modes' I/O operation. */

discard_modes:
     entry (Iocb_ptr, newmode, oldmode, Code);
	oldmode = "";
	Code = 0;
	call GOTO_RETURN ();

/* End of 'modes' handler. */





/* Handler for the 'position' I/O operation. */

discard_position:
     entry (Iocb_ptr, position_type, position_n, Code);
	Code = 0;
	call GOTO_RETURN ();

/* End of 'position' handler. */





/* Handler for the 'control' I/O operation. */

discard_control:
     entry (Iocb_ptr, order, infptr, Code);
	if order = "io_call"
	then Code = error_table_$no_operation;
	else Code = 0;
	call GOTO_RETURN ();

/* End of 'control' handler. */





/* Handler for the 'read_record' I/O operation. */

discard_read:
     entry (Iocb_ptr, bufptr, buflen, actlen, Code);
	actlen = 0;
	Code = error_table_$end_of_info;
	call GOTO_RETURN ();

/* End of 'read_record' handler. */





/* Handler for the 'write_record' and 'rewrite_record I/O operations. */

discard_write:
     entry (Iocb_ptr, bufptr, buflen, Code);
	Code = 0;
	call GOTO_RETURN ();

/* End of 'write_record' and 'rewrite_record' handlers. */





/* Handler for the 'delete_record' I/O operation. */

discard_delete:
     entry (Iocb_ptr, Code);
	Code = error_table_$no_record;
	call GOTO_RETURN ();

/* End of 'delete_record' handler. */





/* Handler for the 'seek_key' and 'read_key' I/O operations. */

discard_seek_key:
     entry (Iocb_ptr, key, len, Code);
	len = 0;
	Code = error_table_$no_record;
	call GOTO_RETURN ();

/* End of 'seek_key' and 'read_key' handlers. */





/* Handler for the 'read_length' I/O operation. */

discard_read_length:
     entry (Iocb_ptr, actlen, Code);
	actlen = 0;
	Code = error_table_$no_record;
	call GOTO_RETURN ();

/* End of 'read_length' handler. */

/* format: ^indcomtxt */

/*****************************************************************************/
/*							       */
/*   PROCEDURE:  Any_Other_Handler				       */
/*							       */
/*   This procedure restores the IPS mask if necessary and continues to      */
/*   signal whatever the problem was.				       */
/*							       */
/*****************************************************************************/

Any_Other_Handler:
     proc ();

	if substr (mask, 36, 1) then call hcs_$reset_ips_mask (mask, mask);

	call continue_to_signal_ ((0));		/* Ignore the code. */

	return;

     end Any_Other_Handler;

/*****************************************************************************/
/*							       */
/*   PROCEDURE:  Cleanup_Handler				       */
/*							       */
/*   This procedure restores the IPS mask if necessary.		       */
/*							       */
/*****************************************************************************/

Cleanup_Handler:
     proc ();

	if substr (mask, 36, 1) then call hcs_$reset_ips_mask (mask, mask);

	return;

     end Cleanup_Handler;

/*****************************************************************************/
/*							       */
/*   PROCEDURE:  GOTO_RETURN					       */
/*							       */
/*   This procedure only exists to aid debugging, and centralize the return. */
/*							       */
/*****************************************************************************/

GOTO_RETURN:
     proc ();

	goto RETURN;				/* A non-local goto to the main return. */

     end GOTO_RETURN;

/* format: revert */
%page;
%include iocb;
%include iox_dcls;
%include iox_modes;

     end discard_;




		    signal_io_.pl1                  11/29/84  1138.2rew 11/28/84  1034.0      129285



/* ***********************************************************
   *                                                         *
   * Copyright, (C) Honeywell Information Systems Inc., 1984 *
   *                                                         *
   *********************************************************** */
/* io module for admin commands that traps input */

/* format: style2 */
signal_io_:
     procedure;
	return;


/* Written 1984-10-12 BIM, from tty_ */

/* Parameters */

	dcl     arg_iocbp		 ptr;		/* ptr to iocb (input) */
	dcl     arg_buffer_ptr	 pointer;
	dcl     arg_buffer_length	 fixed bin (21);
	dcl     arg_n_read		 fixed bin (21);
	dcl     arg_pos_type	 fixed bin;
	dcl     arg_pos_amt		 fixed bin (35);
	dcl     arg_order_name	 char (*);
	dcl     arg_order_info_ptr	 pointer;
	dcl     arg_old_modes	 char (*);
	dcl     arg_new_modes	 char (*);
	dcl     arg_key		 char (256) varying;

	dcl     code		 fixed bin (35);	/* Multics standard error code (output) */
	dcl     com_err_switch	 bit (1);		/* ON if should call com_err_ for errors (input) */
	dcl     extend_bit		 bit (1);		/* Obsolete open argument */
	dcl     mode		 fixed bin;
	dcl     option_array	 (*) char (*) var;

/* Automatic */

	dcl     actual_iocbp	 ptr;		/* copy of iocb.actual_ioc_ptr */
	dcl     device		 char (32);
	dcl     i			 fixed bin;
	dcl     iocbp		 ptr;		/* copy of arg_iocb_ptr */
	dcl     mask		 bit (36) aligned;	/* ips mask */
	dcl     system_free_area_ptr	 pointer;

/* builtins */

	dcl     (addr, hbound, length, null, string)
				 builtin;

/* Internal Static */

	dcl     ME		 char (32) int static options (constant) init ("signal_io_");
						/* used by com_err_ and setting attach descrip */

/* Based */

	dcl     system_free_area	 area based (system_free_area_ptr);

/* External Static */

	dcl     (
	        error_table_$action_not_performed,
	        error_table_$too_many_args,
	        error_table_$inconsistent,
	        error_table_$badopt,
	        error_table_$bad_mode,
	        error_table_$noarg,
	        error_table_$not_detached,
	        error_table_$wrong_no_of_args
	        )			 fixed bin (35) ext;

	dcl     (any_other, cleanup)	 condition;

/* Procedures */

	dcl     com_err_		 entry options (variable);
	dcl     get_system_free_area_	 entry () returns (pointer);
	dcl     hcs_$reset_ips_mask	 entry (bit (36) aligned, bit (36) aligned);
	dcl     hcs_$set_ips_mask	 entry (bit (36) aligned, bit (36) aligned);
	declare signal_		 entry () options (variable);

	declare 1 sgii		 aligned like signal_io_info;

	declare attach_data_ptr	 pointer;
	declare 1 attach_data	 aligned based (attach_data_ptr),
		2 attach_description char (200) varying,
		2 open_description	 char (200) varying;

%page;


signal_io_attach:
     entry (arg_iocbp, option_array, com_err_switch, code);

	code = 0;
	mask = ""b;
	iocbp = arg_iocbp;

	attach_data_ptr = null ();
	on cleanup call clean_up_attach;

	if hbound (option_array, 1) ^= 0
	then call error (error_table_$noarg, "Usage: signal_io_");

	if iocbp -> iocb.attach_descrip_ptr ^= null ()
	then call error (error_table_$not_detached, "");

	system_free_area_ptr = get_system_free_area_ ();
	allocate attach_data in (system_free_area);

	attach_data.attach_description = "signal_io_";
	attach_data.open_description = "";

	on any_other call handler;			/* should be on */

	call hcs_$set_ips_mask (""b, mask);
	iocbp -> iocb.attach_descrip_ptr = addr (attach_data.attach_description);
	iocbp -> iocb.attach_data_ptr = attach_data_ptr;
	iocbp -> iocb.detach_iocb = signal_io_detach;
	iocbp -> iocb.open = signal_io_open;
	iocbp -> iocb.control = signal_io_control;
	call iox_$propagate (iocbp);
	revert any_other;
	call hcs_$reset_ips_mask (mask, mask);

RETURN:
	return;


/*  Error calls com_err_ if the loud switch is set and goes to the attach return */

error:
     proc (err_code, message);

	dcl     err_code		 fixed bin (35);	/* Multics standard error code */
	dcl     message		 char (*);	/* Additional error information */

	if com_err_switch
	then call com_err_ (err_code, ME, "^a  ^a", iocbp -> iocb.name, message);
	code = err_code;

	call clean_up_attach;
	goto RETURN;

     end error;
%page;

signal_io_detach:
     entry (arg_iocbp, code);

	call set_up;				/* set no lock, but get actual_iocb_ptr */

	on any_other call handler;			/* should be on */
	call hcs_$set_ips_mask (""b, mask);
	actual_iocbp -> iocb.attach_descrip_ptr = null ();
	actual_iocbp -> iocb.attach_data_ptr = null ();
	actual_iocbp -> iocb.detach_iocb = iox_$err_not_attached;
	actual_iocbp -> iocb.open = iox_$err_not_attached;
	actual_iocbp -> iocb.control = iox_$err_not_attached;
	call iox_$propagate (actual_iocbp);
	call hcs_$reset_ips_mask (mask, mask);
	revert any_other;				/* avoid unneccessary fatal errors */
	free attach_data;
	return;
%page;
/*  This entry sets the open description and the legal operation entries in the iocb.  The operations permitted:

   all the time:	close, control, modes
   input:		get_chars, get_line, position
   output:	put_chars
*/

signal_io_open:
     entry (arg_iocbp, mode, extend_bit, code);

	call set_up;

	attach_data.open_description = iox_modes (mode);

	on any_other call handler;
	call hcs_$set_ips_mask (""b, mask);

	actual_iocbp -> iocb.open_descrip_ptr = addr (attach_data.open_description);
	actual_iocbp -> iocb.detach_iocb = iox_$err_not_closed;
	actual_iocbp -> iocb.open = iox_$err_not_closed;
	actual_iocbp -> iocb.close = signal_io_close;
	actual_iocbp -> iocb.modes = signal_io_modes;

	if mode = Stream_input_output | mode = Stream_input | mode = Stream_output
	then do;

		if mode ^= Stream_output
		then do;
			actual_iocbp -> iocb.get_line = signal_io_get_line;
			actual_iocbp -> iocb.get_chars = signal_io_get_chars;
			actual_iocbp -> iocb.position = signal_io_position;
		     end;

		if mode ^= Stream_input
		then actual_iocbp -> iocb.put_chars = signal_io_put_chars;
	     end;

	if mode = Sequential_input_output | mode = Sequential_input | mode = Sequential_output
	then do;

		if mode = Sequential_input | mode = Sequential_input_output | mode = Sequential_update
		then do;
			actual_iocbp -> iocb.read_record = signal_io_read_record;
			actual_iocbp -> iocb.read_length = signal_io_read_length;
			actual_iocbp -> iocb.position = signal_io_position;
		     end;

		if mode = Sequential_output | mode = Sequential_input_output | mode = Sequential_update
		then actual_iocbp -> iocb.write_record = signal_io_write_record;
		if mode = Sequential_update
		then do;
			actual_iocbp -> iocb.rewrite_record = signal_io_rewrite_record;
			actual_iocbp -> iocb.delete_record = signal_io_delete_record;

		     end;

	     end;
	if mode = Keyed_sequential_input | mode = Keyed_sequential_output
	then do;

		actual_iocbp -> iocb.seek_key = signal_io_seek_key;

		if mode = Keyed_sequential_input | mode = Keyed_sequential_update
		then do;
			actual_iocbp -> iocb.read_record = signal_io_read_record;
			actual_iocbp -> iocb.read_length = signal_io_read_length;
			actual_iocbp -> iocb.position = signal_io_position;
			actual_iocbp -> iocb.read_key = signal_io_read_key;
		     end;

		if mode = Keyed_sequential_output | mode = Keyed_sequential_update
		then actual_iocbp -> iocb.write_record = signal_io_write_record;
		if mode = Keyed_sequential_update
		then do;
			actual_iocbp -> iocb.rewrite_record = signal_io_rewrite_record;
			actual_iocbp -> iocb.delete_record = signal_io_delete_record;

		     end;
	     end;
	if mode = Direct_input | mode = Direct_output
	then do;
		actual_iocbp -> iocb.seek_key = signal_io_seek_key;
		if mode = Direct_input | mode = Direct_update
		then do;
			actual_iocbp -> iocb.read_record = signal_io_read_record;
			actual_iocbp -> iocb.read_length = signal_io_read_length;
		     end;

		if mode = Direct_output | mode = Direct_update
		then actual_iocbp -> iocb.write_record = signal_io_write_record;
		if mode = Direct_update
		then do;
			actual_iocbp -> iocb.rewrite_record = signal_io_rewrite_record;
			actual_iocbp -> iocb.delete_record = signal_io_delete_record;

		     end;
	     end;
	call iox_$propagate (actual_iocbp);
	call hcs_$reset_ips_mask (mask, mask);
	revert any_other;

	code = 0;
	return;
%page;
/*  This procedure closes the io switch and returns a zero code. 
*/

signal_io_close:
     entry (arg_iocbp, code);

	call set_up;


	on any_other call handler;			/* should be on */
	call hcs_$set_ips_mask (""b, mask);

	actual_iocbp -> iocb.open_descrip_ptr = null;
	actual_iocbp -> iocb.detach_iocb = signal_io_detach;
	actual_iocbp -> iocb.open = signal_io_open;
	actual_iocbp -> iocb.modes = iox_$err_not_open;

	call iox_$propagate (actual_iocbp);

	call hcs_$reset_ips_mask (mask, mask);
	return;
%page;

signal_io_get_chars:
     entry (arg_iocbp, arg_buffer_ptr, arg_buffer_length, arg_n_read, code);
	call set_up_io (SGI_OP_GET_CHARS);
	sgii.data_ptr = arg_buffer_ptr;
	sgii.data_length = arg_buffer_length;
	call signal ();
	arg_n_read = sgii.returned_data_length;
	code = sgii.returned_error_code;
	return;

signal_io_get_line:
     entry (arg_iocbp, arg_buffer_ptr, arg_buffer_length, arg_n_read, code);
	call set_up_io (SGI_OP_GET_LINE);
	sgii.data_ptr = arg_buffer_ptr;
	sgii.data_length = arg_buffer_length;
	call signal ();
	arg_n_read = sgii.returned_data_length;
	code = sgii.returned_error_code;
	return;

signal_io_put_chars:
     entry (arg_iocbp, arg_buffer_ptr, arg_buffer_length, code);
	call set_up_io (SGI_OP_PUT_CHARS);
	sgii.data_ptr = arg_buffer_ptr;
	sgii.data_length = arg_buffer_length;
	call signal ();
	code = sgii.returned_error_code;
	return;

signal_io_modes:
     entry (arg_iocbp, arg_new_modes, arg_old_modes, code);
	call set_up_io (SGI_OP_MODES);
	sgii.new_modes.pointer = addr (arg_new_modes);
	sgii.new_modes.length = length (arg_new_modes);
	sgii.old_modes.pointer = addr (arg_old_modes);
	sgii.old_modes.length = length (arg_old_modes);
	call signal ();
	code = sgii.returned_error_code;
	return;

signal_io_position:
     entry (arg_iocbp, arg_pos_type, arg_pos_amt, code);
	call set_up_io (SGI_OP_POSITION);
	sgii.position_type = arg_pos_type;
	sgii.position_amount = arg_pos_amt;
	call signal ();
	code = sgii.returned_error_code;
	return;

signal_io_control:
     entry (arg_iocbp, arg_order_name, arg_order_info_ptr, code);
	call set_up_io (SGI_OP_CONTROL);
	sgii.control_order_info_ptr = arg_order_info_ptr;
	sgii.data_ptr = addr (arg_order_name);
	sgii.data_length = length (arg_order_name);
	call signal ();
	code = sgii.returned_error_code;
	return;

signal_io_write_record:
     entry (arg_iocbp, arg_buffer_ptr, arg_buffer_length, code);
	call set_up_io (SGI_OP_WRITE_RECORD);
	sgii.data_ptr = arg_buffer_ptr;
	sgii.data_length = arg_buffer_length;
	call signal ();
	code = sgii.returned_error_code;
	return;

signal_io_read_record:
     entry (arg_iocbp, arg_buffer_ptr, arg_buffer_length, arg_n_read, code);
	call set_up_io (SGI_OP_READ_RECORD);
	sgii.data_ptr = arg_buffer_ptr;
	sgii.data_length = arg_buffer_length;
	call signal ();
	arg_n_read = sgii.returned_data_length;
	code = sgii.returned_error_code;
	return;

signal_io_rewrite_record:
     entry (arg_iocbp, arg_buffer_ptr, arg_buffer_length, code);
	call set_up_io (SGI_OP_REWRITE_RECORD);
	sgii.data_ptr = arg_buffer_ptr;
	sgii.data_length = arg_buffer_length;
	call signal ();
	code = sgii.returned_error_code;
	return;

signal_io_delete_record:
     entry (arg_iocbp, code);
	call set_up_io (SGI_OP_DELETE_RECORD);
	call signal ();
	code = sgii.returned_error_code;
	return;

signal_io_seek_key:
     entry (arg_iocbp, arg_key, arg_n_read, code);
	call set_up_io (SGI_OP_SEEK_KEY);
	sgii.key = arg_key;
	call signal ();
	arg_n_read = sgii.returned_data_length;
	code = sgii.returned_error_code;
	return;

signal_io_read_key:
     entry (arg_iocbp, arg_key, arg_n_read, code);
	call set_up_io (SGI_OP_READ_KEY);
	call signal ();
	arg_key = sgii.key;
	arg_n_read = sgii.returned_data_length;
	code = sgii.returned_error_code;
	return;

signal_io_read_length:
     entry (arg_iocbp, arg_n_read, code);
	call set_up_io (SGI_OP_READ_LENGTH);
	call signal ();
	arg_n_read = sgii.returned_data_length;
	code = sgii.returned_error_code;
	return;

%page;
set_up_io:
     procedure (op);

	declare op		 char (32);

	sgii.version = 0;
	sgii.header.length = currentsize (sgii);
	sgii.action_flags = "0"b;			/* can restart */
	sgii.info_string = op;			/* we could do better */
	sgii.status_code = 0;
	sgii.operation = op;
	sgii.iocb_ptr = arg_iocbp;			/* in the case of syn_, give the original */
	sgii.iocb_name = arg_iocbp -> iocb.name;	/* since the handler can always fetch iocb.actual */
	sgii.control_order_info_ptr, sgii.data_ptr = null ();
	sgii.data_length, sgii.returned_data_length = 0;
	sgii.returned_error_code = error_table_$action_not_performed;
	sgii.old_modes.pointer, sgii.new_modes.pointer = null ();
	sgii.old_modes.length, sgii.new_modes.length = 0;
	sgii.key = "";
	return;
     end set_up_io;

signal:
     procedure;

	call signal_ ("signal_io_", null (), addr (sgii));
	return;
     end signal;

/*  Internal procedure to handle faults while IPS interrupts are masked.  For a fault while masked, the process
   is terminated (with the reason "unable to do critical I/O") because the I/O control blocks are in an
   inconsistent state.
*/
terminate_the_process:
     entry (code);
	call terminate_this_process (code);

handler:
     procedure options (non_quick);			/* visible in ifd */

	dcl     error_table_$unable_to_do_io
				 fixed (35) ext;
	if mask ^= ""b
	then call terminate_this_process (error_table_$unable_to_do_io);
     end handler;


terminate_this_process:
     procedure (cd);

	dcl     cd		 fixed bin (35);
	dcl     terminate_process_	 ext entry (char (*), ptr);
	dcl     1 ti		 aligned automatic,
		2 version		 fixed,
		2 code		 fixed (35);


	ti.version = 0;
	ti.code = cd;
	call terminate_process_ ("fatal_error", addr (ti));

     end terminate_this_process;

set_up:
     procedure;

	code = 0;
	mask = ""b;
	actual_iocbp = arg_iocbp -> iocb.actual_iocb_ptr;
	attach_data_ptr = actual_iocbp -> iocb.attach_data_ptr;
	return;

     end set_up;

clean_up_attach:
     procedure;

	if attach_data_ptr = null ()
	then return;
	free attach_data;
     end clean_up_attach;
%page;
%include iox_entries;
%include iox_modes;
%include iocb;
%include condition_info_header;
%include signal_io_info;

     end signal_io_;







		    bull_copyright_notice.txt       08/30/05  1008.4r   08/30/05  1007.3    00020025

                                          -----------------------------------------------------------


Historical Background

This edition of the Multics software materials and documentation is provided and donated
to Massachusetts Institute of Technology by Group Bull including Bull HN Information Systems Inc. 
as a contribution to computer science knowledge.  
This donation is made also to give evidence of the common contributions of Massachusetts Institute of Technology,
Bell Laboratories, General Electric, Honeywell Information Systems Inc., Honeywell Bull Inc., Groupe Bull
and Bull HN Information Systems Inc. to the development of this operating system. 
Multics development was initiated by Massachusetts Institute of Technology Project MAC (1963-1970),
renamed the MIT Laboratory for Computer Science and Artificial Intelligence in the mid 1970s, under the leadership
of Professor Fernando Jose Corbato.Users consider that Multics provided the best software architecture for 
managing computer hardware properly and for executing programs. Many subsequent operating systems
incorporated Multics principles.
Multics was distributed in 1975 to 2000 by Group Bull in Europe , and in the U.S. by Bull HN Information Systems Inc., 
as successor in interest by change in name only to Honeywell Bull Inc. and Honeywell Information Systems Inc. .

                                          -----------------------------------------------------------

Permission to use, copy, modify, and distribute these programs and their documentation for any purpose and without
fee is hereby granted,provided that the below copyright notice and historical background appear in all copies
and that both the copyright notice and historical background and this permission notice appear in supporting
documentation, and that the names of MIT, HIS, Bull or Bull HN not be used in advertising or publicity pertaining
to distribution of the programs without specific prior written permission.
    Copyright 1972 by Massachusetts Institute of Technology and Honeywell Information Systems Inc.
    Copyright 2006 by Bull HN Information Systems Inc.
    Copyright 2006 by Bull SAS
    All Rights Reserved
