declare	builtin_function	entry(pointer,(128) pointer,fixed bin(15))
			returns(pointer);
			/* parameter 1:	(input)	symbol node pointer		*/
			/* parameter 2:	(input)	argument tree pointers	*/
			/* parameter 3:	(input)	number of arguments		*/
			/* return:	(output)	operator node pointer	*/

declare	builtin_function$declare_entry entry(pointer)
			returns(pointer);
			/* parameter 1:	(input)	symbol node pointer		*/
			/* return:	(output)	symbol node pointer		*/

declare	builtin_function$lookup entry(pointer)
			returns(bit(1) aligned);
			/* parameter 1:	(input)	symbol node pointer		*/
			/* return:	(output)	matching indicator bit	*/

declare	builtin_function$lookup_external entry(pointer)
			returns (bit(1) aligned);
			/* parameter 1:	(input)	symbol node pointer		*/
			/* return:	(output)	matching indicator bit	*/

declare	cardlex		entry(pointer,fixed bin(15));
			/* parameter 1:	(output)	token node pointer		*/
			/* parameter 2:	(output)	character index		*/

declare	cardlex$initialize_lex entry(pointer,fixed bin(15));
			/* parameter 1:	(input)	source segment pointer	*/
			/* parameter 2:	(input)	source string length	*/

declare	cardlex$write_last_line entry;

declare	dcl$declaration_processor entry;

declare	dcl$implicit_parse	entry;

declare	dcl$make_declaration entry(pointer)
			returns(pointer);
			/* parameter 1:	(input)	token node pointer		*/
			/* return:	(output)	reference node pointer	*/

declare	declaration_parse$abnormal_parse entry;

declare	declaration_parse$automatic_parse entry;

declare	declaration_parse$character_parse entry;

declare	declaration_parse$common_parse entry;

declare	declaration_parse$complex_parse entry;

declare	declaration_parse$data_parse entry;

declare	declaration_parse$dimension_parse entry;

declare	declaration_parse$double_precision_parse entry;

declare	declaration_parse$equivalence_parse entry;

declare	declaration_parse$external_parse entry;

declare	declaration_parse$integer_parse entry;

declare	declaration_parse$logical_parse entry;

declare	declaration_parse$namelist_parse entry;

declare	declaration_parse$real_parse entry;

declare	flex		entry(pointer,fixed bin(15));
			/* parameter 1:	(output)	token node pointer		*/
			/* parameter 2:	(output)	character index		*/

declare	flex$initialize_lex entry(pointer,fixed bin(15));
			/* parameter 1:	(input)	source segment pointer	*/
			/* parameter 2:	(input)	source string length	*/

declare	flex$write_last_line entry;

declare	fortran_assign_parse entry(pointer,pointer,fixed bin(15));
			/* parameter 1:	(input)	statement node pointer	*/
			/* parameter 2:	(input)	block node pointer		*/
			/* parameter 3:	(input)	fortran statement type code	*/

declare	fortran_crse_parse	entry(pointer,pointer,fixed bin(15));
			/* parameter 1:	(input)	statement node pointer	*/
			/* parameter 2:	(input)	block node pointer		*/
			/* parameter 3:	(input)	fortran statement type code	*/

declare	fortran_do_parse	entry(pointer);
			/* parameter 1:	(input)	statement node pointer	*/

declare	fortran_do_parse$end_test entry;

declare	fortran_expression_parse entry(pointer,pointer)
			returns(bit(1) aligned);
			/* parameter 1:	(input)	token node pointer		*/
			/* parameter 2:	(output)	expression pointer		*/
			/* return:	(output)	error bit			*/

declare	fortran_operator_semantics	entry(pointer)
			returns(pointer);
			/* parameter 1:	(input)	expression pointer		*/
			/* return:	(output)	expression pointer		*/

declare	fortran_format_parse entry(pointer);
			/* parameter 1:	(input)	statement node pointer	*/

declare	fortran_if_parse	entry(pointer,pointer,fixed bin(15));
			/* parameter 1:	(input)	statement node pointer	*/
			/* parameter 2:	(input)	block node pointer		*/
			/* parameter 3:	(input)	fortran statement type code	*/

declare	fortran_io_parse	entry(pointer,pointer,fixed bin(15));
			/* parameter 1:	(input)	statement node pointer	*/
			/* parameter 2:	(input)	block node pointer		*/
			/* parameter 3:	(input)	fortran statement type code	*/

declare	fortran_parse	entry(pointer,pointer,fixed bin(18));
			/* parameter 1:	(output)	block node pointer		*/
			/* parameter 2:	(input)	source segment pointer	*/
			/* parameter 3:	(input)	source string length	*/

declare	fortran_parse$abort entry(fixed bin(15),pointer);
			/* parameter 1:	(input)	error message number	*/
			/* parameter 2:	(input)	token node pointer		*/

declare	fortran_parse$call_es entry;

declare	fortran_parse$error entry(fixed bin(15),pointer);
			/* parameter 1:	(input)	error message number	*/
			/* parameter 2:	(input)	token node pointer		*/

declare	fortran_reference_parse	entry(pointer,pointer)
			returns(bit(1) aligned);
			/* parameter 1:	(i/o)	token node pointer		*/
			/* parameter 2:	(output)	reference node pointer	*/
			/* return:	(output)	error bit			*/

declare	fortran_reference_parse$call entry(pointer,pointer)
			returns(bit(1) aligned);
			/* parameter 1:	(i/o)	token node pointer		*/
			/* parameter 2:	(output)	reference node pointer	*/
			/* return:	(output)	error bit			*/

declare	fortran_reference_parse$left_side entry(pointer,pointer)
			returns(bit(1) aligned);
			/* parameter 1:	(i/o)	token node pointer		*/
			/* parameter 2:	(output)	reference node pointer	*/
			/* return:	(output)	error bit			*/

declare	fortran_reference_parse$sf	entry(pointer,pointer)
			returns(bit(1) aligned);
			/* parameter 1:	(i/o)	token node pointer		*/
			/* parameter 2:	(output)	reference node pointer	*/
			/* return:	(output)	error bit			*/

declare	fortran_reference_parse$make_call	entry(pointer, pointer, (128) pointer, fixed bin, bit(1) aligned)
			returns(pointer);
			/* parameter 1:	(input)	reference of function return value */
			/* parameeter 2:	(input)	entry name reference */
			/* parameter 3:	(input)	argument list excluding return value */
			/* parameter 4:	(input)	argument list count excluding return value */
			/* parameter 5:	(input)	On if descriptors are required */
			/* return:	(output)	pointer to std_call operator */

declare	fortran_reserve$declare_lib entry(fixed bin(15))
			returns(pointer);
			/* parameter 1:	(input)	library entry index		*/
			/* return:	(output)	reference node pointer	*/

declare	fortran_reserve$read_lib	entry(fixed bin(15))
			returns(pointer);
			/* parameter 1:	(input)	library entry index		*/
			/* return:	(output)	token node pointer		*/

declare	fortran_subroutine_parse entry(pointer,pointer,fixed bin(15));
			/* parameter 1:	(input)	statement node pointer	*/
			/* parameter 2:	(input)	block node pointer		*/
			/* parameter 3:	(input)	fortran statement type code	*/

declare	fortran_subscripter	entry(pointer,fixed bin(15),(128) pointer)
			returns(pointer);
			/* parameter 1:	(input)	symbol node pointer		*/
			/* parameter 2:	(input)	number of subscripts	*/
			/* parameter 3:	(input)	subscript expression pointers	*/
			/* return:	(output)	reference node pointer	*/

declare	general_format_parse_ entry(character(1024) aligned, character(2048) aligned, fixed bin(15));
			/* parameter 1:	(input)	string to be parsed		*/
			/* parameter 2:	(output)	result of parse		*/
			/* parameter 3:	(output)	error code		*/

declare	go_to_parse	entry(pointer);
			/* parameter 1:	(input)	statement node pointer	*/

declare	initial_attribute	entry(pointer,pointer);
			/* parameter 1:	(input)	declaration list pointer	*/
			/* parameter 2:	(i/o)	token node pointer		*/

declare	make_format	entry(pointer)
			returns(pointer);
			/* parameter 1:	(input)	token node pointer		*/
			/* return:	(output)	symbol node pointer		*/

declare	make_label entry(pointer)
			returns(pointer);
			/* parameter 1:	(input)	token node pointer		*/
			/* return:	(output)	pointer to label node	*/

declare	prologue_entry$auto_initial entry(pointer);
			/* parameter 1:	(input)	symbol node pointer		*/

declare	replace_parameters	entry(pointer,(128) pointer,fixed bin(15))
			returns(pointer);
			/* parameter 1:	(input)	statement function pointer	*/
			/* parameter 2:	(input)	statement func arg pointers	*/
			/* parameter 3:	(input)	number of arguments		*/
			/* return:	(output)	expression pointer		*/

declare	set_parameters	entry(pointer,pointer)
			returns(pointer);
			/* parameter 1:	(input)	statement func expr pointer	*/
			/* parameter 2:	(input)	list node pointer		*/
			/* return:	(output)	statement func expr pointer	*/

declare	statement_recognizer entry(pointer)
			returns(fixed bin(8));
			/* parameter 1:	(output)	statement node pointer	*/
			/* return:	(output)	fortran statement type code	*/

declare	statement_recognizer$back_up entry(fixed bin(15))
			returns(pointer);
			/* parameter 1:	(input)	token count		*/
			/* return:	(output)	token node pointer		*/

declare	statement_recognizer$back_up_statement entry
			returns(pointer);
			/* return:	(output)	token node pointer		*/

declare	statement_recognizer$from_if_parse entry(pointer)
			returns(fixed bin(8));
			/* parameter 1:	(output)	statement node pointer	*/
			/* return:	(output)	fortran statement type code	*/

declare	statement_recognizer$init entry(pointer,pointer)
			returns(fixed bin(8));
			/* parameter 1:	(output)	statement node pointer	*/
			/* parameter 2:	(input)	block node pointer		*/
			/* return:	(output)	fortran statement type code	*/

declare	statement_recognizer$next_token entry
			returns(pointer);
			/* return:	(output)	token node pointer		*/

declare	statement_recognizer$top_of_stack entry
			returns(pointer);
			/* return:	(output)	token node pointer		*/

declare	stmnt_func_parse	entry(bit(1) aligned,pointer);
			/* parameter 1:	(output)	assignm stmnt type		*/
			/* parameter 2:	(input)	statement node pointer	*/

declare	type$fix_array_sizes entry(pointer,fixed bin(24),fixed bin(24));
			/* parameter 1:	(input)	symbol node pointer		*/
			/* parameter 2:	(input)	word size			*/
			/* parameter 3:	(input)	bit size			*/


*/
                                          -----------------------------------------------------------


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

*/