2003-10-21 Arnaud Charlet <charlet@act-europe.fr>

	* 3psoccon.ads, 3veacodu.adb, 3vexpect.adb, 3vsoccon.ads,
	3vsocthi.adb, 3vsocthi.ads, 3vtrasym.adb, 3zsoccon.ads,
	3zsocthi.adb, 3zsocthi.ads, 50system.ads, 51system.ads,
	55system.ads, 56osinte.adb, 56osinte.ads, 56taprop.adb,
	56taspri.ads, 56tpopsp.adb, 57system.ads, 58system.ads,
	59system.ads, 5aml-tgt.adb, 5bml-tgt.adb, 5csystem.ads,
	5dsystem.ads, 5fosinte.adb, 5gml-tgt.adb, 5hml-tgt.adb,
	5isystem.ads, 5lparame.adb, 5msystem.ads, 5psystem.ads,
	5sml-tgt.adb, 5sosprim.adb, 5stpopsp.adb, 5tsystem.ads,
	5usystem.ads, 5vml-tgt.adb, 5vsymbol.adb, 5vtraent.adb,
	5vtraent.ads, 5wml-tgt.adb, 5xparame.ads, 5xsystem.ads,
	5xvxwork.ads, 5yparame.ads, 5ytiitho.adb, 5zinit.adb,
	5zml-tgt.adb, 5zparame.ads, 5ztaspri.ads, 5ztfsetr.adb,
	5zthrini.adb, 5ztiitho.adb, 5ztpopsp.adb, 7stfsetr.adb,
	7straces.adb, 7strafor.adb, 7strafor.ads, 7stratas.adb,
	a-excach.adb, a-exexda.adb, a-exexpr.adb, a-exextr.adb,
	a-exstat.adb, a-strsup.adb, a-strsup.ads, a-stwisu.adb,
	a-stwisu.ads, bld.adb, bld.ads, bld-io.adb,
	bld-io.ads, clean.adb, clean.ads, ctrl_c.c,
	erroutc.adb, erroutc.ads, errutil.adb, errutil.ads,
	err_vars.ads, final.c, g-arrspl.adb, g-arrspl.ads,
	g-boubuf.adb, g-boubuf.ads, g-boumai.ads, g-bubsor.adb,
	g-bubsor.ads, g-comver.adb, g-comver.ads, g-ctrl_c.ads,
	g-dynhta.adb, g-dynhta.ads, g-eacodu.adb, g-excact.adb,
	g-excact.ads, g-heasor.adb, g-heasor.ads, g-memdum.adb,
	g-memdum.ads, gnatclean.adb, gnatsym.adb, g-pehage.adb,
	g-pehage.ads, g-perhas.ads, gpr2make.adb, gpr2make.ads,
	gprcmd.adb, gprep.adb, gprep.ads, g-semaph.adb,
	g-semaph.ads, g-string.adb, g-string.ads, g-strspl.ads,
	g-wistsp.ads, i-vthrea.adb, i-vthrea.ads, i-vxwoio.adb,
	i-vxwoio.ads, Makefile.generic, Makefile.prolog, Makefile.rtl,
	prep.adb, prep.ads, prepcomp.adb, prepcomp.ads,
	prj-err.adb, prj-err.ads, s-boarop.ads, s-carsi8.adb,
	s-carsi8.ads, s-carun8.adb, s-carun8.ads, s-casi16.adb,
	s-casi16.ads, s-casi32.adb, s-casi32.ads, s-casi64.adb,
	s-casi64.ads, s-casuti.adb, s-casuti.ads, s-caun16.adb,
	s-caun16.ads, s-caun32.adb, s-caun32.ads, s-caun64.adb,
	s-caun64.ads, scng.adb, scng.ads, s-exnint.adb,
	s-exnllf.adb, s-exnlli.adb, s-expint.adb, s-explli.adb,
	s-geveop.adb, s-geveop.ads, s-hibaen.ads, s-htable.adb,
	s-htable.ads, sinput-c.adb, sinput-c.ads, s-memcop.ads,
	socket.c, s-purexc.ads, s-scaval.adb, s-stopoo.adb,
	s-strcom.adb, s-strcom.ads, s-strxdr.adb, s-rident.ads,
	s-thread.adb, s-thread.ads, s-tpae65.adb, s-tpae65.ads,
	s-tporft.adb, s-traent.adb, s-traent.ads, styleg.adb,
	styleg.ads, styleg-c.adb, styleg-c.ads, s-veboop.adb,
	s-veboop.ads, s-vector.ads, symbols.adb, symbols.ads,
	tb-alvms.c, tb-alvxw.c, tempdir.adb, tempdir.ads,
	vms_conv.ads, vms_conv.adb, vms_data.ads,
	vxaddr2line.adb: Files added. Merge with ACT tree.

	* 4dintnam.ads, 4mintnam.ads, 4uintnam.ads, 52system.ads,
	5dosinte.ads, 5etpopse.adb, 5mosinte.ads, 5qosinte.adb,
	5qosinte.ads, 5qstache.adb, 5qtaprop.adb, 5qtaspri.ads,
	5stpopse.adb, 5uintman.adb, 5uosinte.ads, adafinal.c,
	g-enblsp.adb, io-aux.c, scn-nlit.adb, scn-slit.adb,
	s-exnflt.ads, s-exngen.adb, s-exngen.ads, s-exnlfl.ads,
	s-exnlin.ads, s-exnsfl.ads, s-exnsin.ads, s-exnssi.ads,
	s-expflt.ads, s-expgen.adb, s-expgen.ads, s-explfl.ads,
	s-explin.ads, s-expllf.ads, s-expsfl.ads, s-expsin.ads,
	s-expssi.ads, style.adb: Files removed. Merge with ACT tree.

	* 1ic.ads, 31soccon.ads, 31soliop.ads, 3asoccon.ads,
	3bsoccon.ads, 3gsoccon.ads, 3hsoccon.ads, 3ssoccon.ads,
	3ssoliop.ads, 3wsoccon.ads, 3wsocthi.adb, 3wsocthi.ads,
	3wsoliop.ads, 41intnam.ads, 42intnam.ads, 4aintnam.ads,
	4cintnam.ads, 4gintnam.ads, 4hexcpol.adb, 4hintnam.ads,
	4lintnam.ads, 4nintnam.ads, 4ointnam.ads, 4onumaux.ads,
	4pintnam.ads, 4sintnam.ads, 4vcaldel.adb, 4vcalend.adb,
	4vintnam.ads, 4wexcpol.adb, 4wintnam.ads, 4zintnam.ads,
	51osinte.adb, 51osinte.ads, 52osinte.adb, 52osinte.ads,
	53osinte.ads, 54osinte.ads, 5aosinte.adb, 5aosinte.ads,
	5asystem.ads, 5ataprop.adb, 5atasinf.ads, 5ataspri.ads,
	5atpopsp.adb, 5avxwork.ads, 5bosinte.adb, 5bosinte.ads,
	5bsystem.ads, 5cosinte.ads, 5esystem.ads, 5fintman.adb,
	5fosinte.ads, 5fsystem.ads, 5ftaprop.adb, 5ftasinf.ads,
	5ginterr.adb, 5gintman.adb, 5gmastop.adb, 5gosinte.ads,
	5gproinf.ads, 5gsystem.ads, 5gtaprop.adb, 5gtasinf.ads,
	5gtpgetc.adb, 5hosinte.adb, 5hosinte.ads, 5hsystem.ads,
	5htaprop.adb, 5htaspri.ads, 5htraceb.adb, 5iosinte.adb,
	5itaprop.adb, 5itaspri.ads, 5ksystem.ads, 5kvxwork.ads,
	5lintman.adb, 5lml-tgt.adb, 5losinte.ads, 5lsystem.ads,
	5mvxwork.ads, 5ninmaop.adb, 5nintman.adb, 5nosinte.ads,
	5ntaprop.adb, 5ntaspri.ads, 5ointerr.adb, 5omastop.adb,
	5oosinte.adb, 5oosinte.ads, 5oosprim.adb, 5oparame.adb,
	5osystem.ads, 5otaprop.adb, 5otaspri.ads, 5posinte.ads,
	5posprim.adb, 5pvxwork.ads, 5sintman.adb, 5sosinte.adb,
	5sosinte.ads, 5ssystem.ads, 5staprop.adb, 5stasinf.ads,
	5staspri.ads, 5svxwork.ads, 5tosinte.ads, 5vasthan.adb,
	5vinmaop.adb, 5vinterr.adb, 5vintman.adb, 5vintman.ads,
	5vmastop.adb, 5vosinte.adb, 5vosinte.ads, 5vosprim.adb,
	5vsystem.ads, 5vtaprop.adb, 5vtaspri.ads, 5vtpopde.adb,
	5vtpopde.ads, 5wgloloc.adb, 5wintman.adb, 5wmemory.adb,
	5wosprim.adb, 5wsystem.ads, 5wtaprop.adb, 5wtaspri.ads,
	5ysystem.ads, 5zinterr.adb, 5zintman.adb, 5zosinte.adb,
	5zosinte.ads, 5zosprim.adb, 5zsystem.ads, 5ztaprop.adb,
	6vcpp.adb, 6vcstrea.adb, 6vinterf.ads, 7sinmaop.adb,
	7sintman.adb, 7sosinte.adb, 7sosprim.adb, 7staprop.adb,
	7staspri.ads, 7stpopsp.adb, 7straceb.adb, 9drpc.adb,
	a-caldel.adb, a-caldel.ads, a-charac.ads, a-colien.ads,
	a-comlin.adb, adaint.c, adaint.h, ada-tree.def,
	a-diocst.adb, a-diocst.ads, a-direio.adb, a-except.adb,
	a-except.ads, a-excpol.adb, a-exctra.adb, a-exctra.ads,
	a-filico.adb, a-interr.adb, a-intsig.adb, a-intsig.ads,
	ali.adb, ali.ads, ali-util.adb, ali-util.ads,
	a-ngcefu.adb, a-ngcoty.adb, a-ngelfu.adb, a-nudira.adb,
	a-nudira.ads, a-nuflra.adb, a-nuflra.ads, a-reatim.adb,
	a-reatim.ads, a-retide.ads, a-sequio.adb, a-siocst.adb,
	a-siocst.ads, a-ssicst.adb, a-ssicst.ads, a-strbou.adb,
	a-strbou.ads, a-strfix.adb, a-strmap.adb, a-strsea.ads,
	a-strunb.adb, a-strunb.ads, a-ststio.adb, a-stunau.adb,
	a-stunau.ads, a-stwibo.adb, a-stwibo.ads, a-stwifi.adb,
	a-stwima.adb, a-stwiun.adb, a-stwiun.ads, a-tags.adb,
	a-tags.ads, a-tasatt.adb, a-taside.adb, a-teioed.adb,
	a-textio.adb, a-textio.ads, a-tienau.adb, a-tifiio.adb,
	a-tiflau.adb, a-tiflio.adb, a-tigeau.adb, a-tigeau.ads,
	a-tiinau.adb, a-timoau.adb, a-tiocst.adb, a-tiocst.ads,
	atree.adb, atree.ads, a-witeio.adb, a-witeio.ads,
	a-wtcstr.adb, a-wtcstr.ads, a-wtdeio.adb, a-wtedit.adb,
	a-wtenau.adb, a-wtflau.adb, a-wtinau.adb, a-wtmoau.adb,
	bcheck.adb, binde.adb, bindgen.adb, bindusg.adb,
	checks.adb, checks.ads, cio.c, comperr.adb,
	comperr.ads, csets.adb, cstand.adb, cstreams.c,
	debug_a.adb, debug_a.ads, debug.adb, decl.c,
	einfo.adb, einfo.ads, errout.adb, errout.ads,
	eval_fat.adb, eval_fat.ads, exp_aggr.adb, expander.adb,
	expander.ads, exp_attr.adb, exp_ch11.adb, exp_ch13.adb,
	exp_ch2.adb, exp_ch3.adb, exp_ch3.ads, exp_ch4.adb,
	exp_ch5.adb, exp_ch6.adb, exp_ch7.adb, exp_ch7.ads,
	exp_ch8.adb, exp_ch9.adb, exp_code.adb, exp_dbug.adb,
	exp_dbug.ads, exp_disp.adb, exp_dist.adb, expect.c,
	exp_fixd.adb, exp_imgv.adb, exp_intr.adb, exp_pakd.adb,
	exp_prag.adb, exp_strm.adb, exp_strm.ads, exp_tss.adb,
	exp_tss.ads, exp_util.adb, exp_util.ads, exp_vfpt.adb,
	fe.h, fmap.adb, fmap.ads, fname.adb,
	fname.ads, fname-uf.adb, fname-uf.ads, freeze.adb,
	freeze.ads, frontend.adb, g-awk.adb, g-awk.ads,
	g-busora.adb, g-busora.ads, g-busorg.adb, g-busorg.ads,
	g-casuti.adb, g-casuti.ads, g-catiio.adb, g-catiio.ads,
	g-cgi.adb, g-cgi.ads, g-cgicoo.adb, g-cgicoo.ads,
	g-cgideb.adb, g-cgideb.ads, g-comlin.adb, g-comlin.ads,
	g-crc32.adb, g-crc32.ads, g-debpoo.adb, g-debpoo.ads,
	g-debuti.adb, g-debuti.ads, g-diopit.adb, g-diopit.ads,
	g-dirope.adb, g-dirope.ads, g-dyntab.adb, g-dyntab.ads,
	g-except.ads, g-exctra.adb, g-exctra.ads, g-expect.adb,
	g-expect.ads, g-hesora.adb, g-hesora.ads, g-hesorg.adb,
	g-hesorg.ads, g-htable.adb, g-htable.ads, gigi.h,
	g-io.adb, g-io.ads, g-io_aux.adb, g-io_aux.ads,
	g-locfil.adb, g-locfil.ads, g-md5.adb, g-md5.ads,
	gmem.c, gnat1drv.adb, gnatbind.adb, gnatchop.adb,
	gnatcmd.adb, gnatfind.adb, gnatkr.adb, gnatlbr.adb,
	gnatlink.adb, gnatls.adb, gnatmake.adb, gnatmem.adb,
	gnatname.adb, gnatprep.adb, gnatprep.ads, gnatpsta.adb,
	gnatxref.adb, g-os_lib.adb, g-os_lib.ads, g-regexp.adb,
	g-regexp.ads, g-regist.adb, g-regist.ads, g-regpat.adb,
	g-regpat.ads, g-soccon.ads, g-socket.adb, g-socket.ads,
	g-socthi.adb, g-socthi.ads, g-soliop.ads, g-souinf.ads,
	g-speche.adb, g-speche.ads, g-spipat.adb, g-spipat.ads,
	g-spitbo.adb, g-spitbo.ads, g-sptabo.ads, g-sptain.ads,
	g-sptavs.ads, g-table.adb, g-table.ads, g-tasloc.adb,
	g-tasloc.ads, g-thread.adb, g-thread.ads, g-traceb.adb,
	g-traceb.ads, g-trasym.adb, g-trasym.ads, hostparm.ads,
	i-c.ads, i-cobol.adb, i-cpp.adb, i-cstrea.ads,
	i-cstrin.adb, i-cstrin.ads, impunit.adb, init.c,
	inline.adb, interfac.ads, i-pacdec.ads, itypes.adb,
	itypes.ads, i-vxwork.ads, lang.opt, lang-specs.h,
	layout.adb, lib.adb, lib.ads, lib-list.adb,
	lib-load.adb, lib-load.ads, lib-sort.adb, lib-util.adb,
	lib-writ.adb, lib-writ.ads, lib-xref.adb, lib-xref.ads,
	link.c, live.adb, make.adb, make.ads,
	Makefile.adalib, Makefile.in, Make-lang.in, makeusg.adb,
	mdll.adb, mdll-fil.adb, mdll-fil.ads, mdll-utl.adb,
	mdll-utl.ads, memroot.adb, memroot.ads, memtrack.adb,
	misc.c, mkdir.c, mlib.adb, mlib.ads,
	mlib-fil.adb, mlib-fil.ads, mlib-prj.adb, mlib-prj.ads,
	mlib-tgt.adb, mlib-tgt.ads, mlib-utl.adb, mlib-utl.ads,
	namet.adb, namet.ads, namet.h, nlists.ads,
	nlists.h, nmake.adt, opt.adb, opt.ads,
	osint.adb, osint.ads, osint-b.adb, osint-c.adb,
	par.adb, par-ch10.adb, par-ch11.adb, par-ch2.adb,
	par-ch3.adb, par-ch4.adb, par-ch5.adb, par-ch6.adb,
	par-ch9.adb, par-endh.adb, par-labl.adb, par-load.adb,
	par-prag.adb, par-sync.adb, par-tchk.adb, par-util.adb,
	prj.adb, prj.ads, prj-attr.adb, prj-attr.ads,
	prj-com.adb, prj-com.ads, prj-dect.adb, prj-dect.ads,
	prj-env.adb, prj-env.ads, prj-ext.adb, prj-ext.ads,
	prj-makr.adb, prj-makr.ads, prj-nmsc.adb, prj-nmsc.ads,
	prj-pars.adb, prj-pars.ads, prj-part.adb, prj-part.ads,
	prj-pp.adb, prj-pp.ads, prj-proc.adb, prj-proc.ads,
	prj-strt.adb, prj-strt.ads, prj-tree.adb, prj-tree.ads,
	prj-util.adb, prj-util.ads, raise.c, raise.h,
	repinfo.adb, repinfo.h, restrict.adb, restrict.ads,
	rident.ads, rtsfind.adb, rtsfind.ads, s-addima.ads,
	s-arit64.adb, s-assert.adb, s-assert.ads, s-atacco.adb,
	s-atacco.ads, s-auxdec.adb, s-auxdec.ads, s-bitops.adb,
	scans.ads, scn.adb, scn.ads, s-crc32.adb,
	s-crc32.ads, s-direio.adb, sem.adb, sem.ads,
	sem_aggr.adb, sem_attr.adb, sem_attr.ads, sem_case.adb,
	sem_case.ads, sem_cat.adb, sem_cat.ads, sem_ch10.adb,
	sem_ch11.adb, sem_ch12.adb, sem_ch12.ads, sem_ch13.adb,
	sem_ch13.ads, sem_ch3.adb, sem_ch3.ads, sem_ch4.adb,
	sem_ch5.adb, sem_ch5.ads, sem_ch6.adb, sem_ch6.ads,
	sem_ch7.adb, sem_ch7.ads, sem_ch8.adb, sem_ch8.ads,
	sem_ch9.adb, sem_disp.adb, sem_disp.ads, sem_dist.adb,
	sem_elab.adb, sem_eval.adb, sem_eval.ads, sem_intr.adb,
	sem_maps.adb, sem_mech.adb, sem_prag.adb, sem_prag.ads,
	sem_res.adb, sem_res.ads, sem_type.adb, sem_type.ads,
	sem_util.adb, sem_util.ads, sem_warn.adb, s-errrep.adb,
	s-errrep.ads, s-exctab.adb, s-exctab.ads, s-exnint.ads,
	s-exnllf.ads, s-exnlli.ads, s-expint.ads, s-explli.ads,
	s-expuns.ads, s-fatflt.ads, s-fatgen.adb, s-fatgen.ads,
	s-fatlfl.ads, s-fatllf.ads, s-fatsfl.ads, s-fileio.adb,
	s-fileio.ads, s-finimp.adb, s-finimp.ads, s-finroo.adb,
	s-finroo.ads, sfn_scan.adb, s-gloloc.adb, s-gloloc.ads,
	s-imgdec.adb, s-imgenu.adb, s-imgrea.adb, s-imgwch.adb,
	sinfo.adb, sinfo.ads, s-inmaop.ads, sinput.adb,
	sinput.ads, sinput-d.adb, sinput-l.adb, sinput-l.ads,
	sinput-p.adb, sinput-p.ads, s-interr.adb, s-interr.ads,
	s-intman.ads, s-maccod.ads, s-mastop.adb, s-mastop.ads,
	s-memory.adb, s-memory.ads, snames.adb, snames.ads,
	snames.h, s-osprim.ads, s-parame.ads, s-parint.ads,
	s-pooloc.adb, s-pooloc.ads, s-poosiz.adb, sprint.adb,
	s-proinf.ads, s-scaval.ads, s-secsta.adb, s-secsta.ads,
	s-sequio.adb, s-shasto.adb, s-shasto.ads, s-soflin.ads,
	s-stache.adb, s-stache.ads, s-stalib.adb, s-stalib.ads,
	s-stoele.ads, s-stopoo.ads, s-stratt.adb, s-stratt.ads,
	s-strops.adb, s-strops.ads, s-taasde.adb, s-taasde.ads,
	s-tadeca.adb, s-tadeca.ads, s-tadert.adb, s-tadert.ads,
	s-taenca.adb, s-taenca.ads, s-taprob.adb, s-taprob.ads,
	s-taprop.ads, s-tarest.adb, s-tarest.ads, s-tasdeb.adb,
	s-tasdeb.ads, s-tasinf.adb, s-tasinf.ads, s-tasini.adb,
	s-tasini.ads, s-taskin.adb, s-taskin.ads, s-tasque.adb,
	s-tasque.ads, s-tasren.adb, s-tasren.ads, s-tasres.ads,
	s-tassta.adb, s-tassta.ads, s-tasuti.adb, s-tasuti.ads,
	s-tataat.adb, s-tataat.ads, s-tpinop.adb, s-tpinop.ads,
	s-tpoben.adb, s-tpoben.ads, s-tpobop.adb, s-tpobop.ads,
	s-tposen.adb, s-tposen.ads, s-traceb.adb, s-traceb.ads,
	stringt.adb, stringt.ads, stringt.h, style.ads,
	stylesw.adb, stylesw.ads, s-unstyp.ads, s-vaflop.ads,
	s-valrea.adb, s-valuti.adb, s-vercon.adb, s-vmexta.adb,
	s-wchcnv.ads, s-wchcon.ads, s-widcha.adb, switch.adb,
	switch.ads, switch-b.adb, switch-c.adb, switch-m.adb,
	s-wwdcha.adb, s-wwdwch.adb, sysdep.c, system.ads,
	table.adb, table.ads, targparm.adb, targparm.ads,
	targtyps.c, tbuild.adb, tbuild.ads, tracebak.c,
	trans.c, tree_io.adb, treepr.adb, treeprs.adt,
	ttypes.ads, types.ads, types.h, uintp.adb,
	uintp.ads, uintp.h, uname.adb, urealp.adb,
	urealp.ads, urealp.h, usage.adb, utils2.c,
	utils.c, validsw.adb, validsw.ads, widechar.adb,
	xeinfo.adb, xnmake.adb, xref_lib.adb, xref_lib.ads,
	xr_tabls.adb, xr_tabls.ads, xtreeprs.adb, xsnames.adb,
	einfo.h, sinfo.h, treeprs.ads, nmake.ads, nmake.adb,
	gnatvsn.ads: Merge with ACT tree.

	* gnatvsn.adb: Rewritten in a simpler and more efficient way.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@72751 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 1811 insertions, 0 deletions

diff --git a/gcc/ada/s-strxdr.adb b/gcc/ada/s-strxdr.adb
new file mode 100644
index 00000000000..0a13cf38850
--- /dev/null
+++ b/gcc/ada/s-strxdr.adb
@@ -0,0 +1,1811 @@
+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT RUNTIME COMPONENTS                          --
+--                                                                          --
+--             S Y S T E M . S T R E A M _ A T T R I B U T E S              --
+--                                                                          --
+--                                 B o d y                                  --
+--                                                                          --
+--         Copyright (C) 1996-2003 Free Software Foundation, Inc.           --
+--                                                                          --
+-- GARLIC is free software;  you can redistribute it and/or modify it under --
+-- terms of the  GNU General Public License  as published by the Free Soft- --
+-- ware Foundation;  either version 2,  or (at your option)  any later ver- --
+-- sion.  GARLIC is distributed  in the hope that  it will be  useful,  but --
+-- WITHOUT ANY WARRANTY;  without even the implied warranty of MERCHANTABI- --
+-- LITY or  FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public  --
+-- License  for more details.  You should have received  a copy of the GNU  --
+-- General Public License  distributed with GARLIC;  see file COPYING.  If  --
+-- not, write to the Free Software Foundation, 59 Temple Place - Suite 330, --
+-- Boston, MA 02111-1307, USA.                                              --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- GNAT was originally developed  by the GNAT team at  New York University. --
+-- Extensive contributions were provided by Ada Core Technologies Inc.      --
+--                                                                          --
+------------------------------------------------------------------------------
+
+--  This file is an alternate version of s-stratt.adb based on the XDR
+--  standard. It is especially useful for exchanging streams between two
+--  different systems with different basic type representations and endianess.
+
+with Ada.Streams;              use Ada.Streams;
+with Ada.Unchecked_Conversion;
+
+package body System.Stream_Attributes is
+
+   pragma Suppress (Range_Check);
+   pragma Suppress (Overflow_Check);
+
+   use UST;
+
+   Data_Error : exception;
+   --  Exception raised if insufficient data read.
+
+   SU : constant := System.Storage_Unit;
+   --  XXXXX pragma Assert (SU = 8);
+
+   BB : constant := 2 ** SU;           --  Byte base
+   BL : constant := 2 ** SU - 1;       --  Byte last
+   BS : constant := 2 ** (SU - 1);     --  Byte sign
+
+   US : constant := Unsigned'Size;     --  Unsigned size
+   UB : constant := (US - 1) / SU + 1; --  Unsigned byte
+   UL : constant := 2 ** US - 1;       --  Unsigned last
+
+   subtype SE  is Ada.Streams.Stream_Element;
+   subtype SEA is Ada.Streams.Stream_Element_Array;
+   subtype SEO is Ada.Streams.Stream_Element_Offset;
+
+   generic function UC renames Ada.Unchecked_Conversion;
+
+   type Field_Type is
+      record
+         E_Size       : Integer; --  Exponent bit size
+         E_Bias       : Integer; --  Exponent bias
+         F_Size       : Integer; --  Fraction bit size
+         E_Last       : Integer; --  Max exponent value
+         F_Mask       : SE;      --  Mask to apply on first fraction byte
+         E_Bytes      : SEO;     --  N. of exponent bytes completly used
+         F_Bytes      : SEO;     --  N. of fraction bytes completly used
+         F_Bits       : Integer; --  N. of bits used on first fraction word
+      end record;
+
+   type Precision is (Single, Double, Quadruple);
+
+   Fields : constant array (Precision) of Field_Type := (
+
+               --  Single precision
+
+              (E_Size  => 8,
+               E_Bias  => 127,
+               F_Size  => 23,
+               E_Last  => 2 ** 8 - 1,
+               F_Mask  => 16#7F#,                  --  2 ** 7 - 1,
+               E_Bytes => 2,
+               F_Bytes => 3,
+               F_Bits  => 23 mod US),
+
+               --  Double precision
+
+              (E_Size  => 11,
+               E_Bias  => 1023,
+               F_Size  => 52,
+               E_Last  => 2 ** 11 - 1,
+               F_Mask  => 16#0F#,                  --  2 ** 4 - 1,
+               E_Bytes => 2,
+               F_Bytes => 7,
+               F_Bits  => 52 mod US),
+
+               --  Quadruple precision
+
+              (E_Size  => 15,
+               E_Bias  => 16383,
+               F_Size  => 112,
+               E_Last  => 2 ** 8 - 1,
+               F_Mask  => 16#FF#,                  --  2 ** 8 - 1,
+               E_Bytes => 2,
+               F_Bytes => 14,
+               F_Bits  => 112 mod US));
+
+   --  The representation of all items requires a multiple of four bytes
+   --  (or 32 bits) of data. The bytes are numbered 0 through n-1. The bytes
+   --  are read or written to some byte stream such that byte m always
+   --  precedes byte m+1. If the n bytes needed to contain the data are not
+   --  a multiple of four, then the n bytes are followed by enough (0 to 3)
+   --  residual zero bytes, r, to make the total byte count a multiple of 4.
+
+   --  An XDR signed integer is a 32-bit datum that encodes an integer
+   --  in the range [-2147483648,2147483647]. The integer is represented
+   --  in two's complement notation. The most and least significant bytes
+   --  are 0 and 3, respectively. Integers are declared as follows:
+   --
+   --        (MSB)                   (LSB)
+   --      +-------+-------+-------+-------+
+   --      |byte 0 |byte 1 |byte 2 |byte 3 |
+   --      +-------+-------+-------+-------+
+   --      <------------32 bits------------>
+
+   SSI_L : constant := 1;
+   SI_L  : constant := 2;
+   I_L   : constant := 4;
+   LI_L  : constant := 8;
+   LLI_L : constant := 8;
+
+   subtype XDR_S_SSI is SEA (1 .. SSI_L);
+   subtype XDR_S_SI  is SEA (1 .. SI_L);
+   subtype XDR_S_I   is SEA (1 .. I_L);
+   subtype XDR_S_LI  is SEA (1 .. LI_L);
+   subtype XDR_S_LLI is SEA (1 .. LLI_L);
+
+   function Short_Short_Integer_To_XDR_S_SSI is
+      new Ada.Unchecked_Conversion (Short_Short_Integer, XDR_S_SSI);
+   function XDR_S_SSI_To_Short_Short_Integer is
+      new Ada.Unchecked_Conversion (XDR_S_SSI, Short_Short_Integer);
+
+   function Short_Integer_To_XDR_S_SI is
+      new Ada.Unchecked_Conversion (Short_Integer, XDR_S_SI);
+   function XDR_S_SI_To_Short_Integer is
+      new Ada.Unchecked_Conversion (XDR_S_SI, Short_Integer);
+
+   function Integer_To_XDR_S_I is
+      new Ada.Unchecked_Conversion (Integer, XDR_S_I);
+   function XDR_S_I_To_Integer is
+     new Ada.Unchecked_Conversion (XDR_S_I, Integer);
+
+   function Long_Long_Integer_To_XDR_S_LI is
+      new Ada.Unchecked_Conversion (Long_Long_Integer, XDR_S_LI);
+   function XDR_S_LI_To_Long_Long_Integer is
+      new Ada.Unchecked_Conversion (XDR_S_LI, Long_Long_Integer);
+
+   function Long_Long_Integer_To_XDR_S_LLI is
+      new Ada.Unchecked_Conversion (Long_Long_Integer, XDR_S_LLI);
+   function XDR_S_LLI_To_Long_Long_Integer is
+      new Ada.Unchecked_Conversion (XDR_S_LLI, Long_Long_Integer);
+
+   --  An XDR unsigned integer is a 32-bit datum that encodes a nonnegative
+   --  integer in the range [0,4294967295]. It is represented by an unsigned
+   --  binary number whose most and least significant bytes are 0 and 3,
+   --  respectively. An unsigned integer is declared as follows:
+   --
+   --        (MSB)                   (LSB)
+   --      +-------+-------+-------+-------+
+   --      |byte 0 |byte 1 |byte 2 |byte 3 |
+   --      +-------+-------+-------+-------+
+   --      <------------32 bits------------>
+
+   SSU_L : constant := 1;
+   SU_L  : constant := 2;
+   U_L   : constant := 4;
+   LU_L  : constant := 8;
+   LLU_L : constant := 8;
+
+   subtype XDR_S_SSU is SEA (1 .. SSU_L);
+   subtype XDR_S_SU  is SEA (1 .. SU_L);
+   subtype XDR_S_U   is SEA (1 .. U_L);
+   subtype XDR_S_LU  is SEA (1 .. LU_L);
+   subtype XDR_S_LLU is SEA (1 .. LLU_L);
+
+   type XDR_SSU is mod BB ** SSU_L;
+   type XDR_SU  is mod BB ** SU_L;
+   type XDR_U   is mod BB ** U_L;
+
+   function Short_Unsigned_To_XDR_S_SU is
+      new Ada.Unchecked_Conversion (Short_Unsigned, XDR_S_SU);
+   function XDR_S_SU_To_Short_Unsigned is
+      new Ada.Unchecked_Conversion (XDR_S_SU, Short_Unsigned);
+
+   function Unsigned_To_XDR_S_U is
+      new Ada.Unchecked_Conversion (Unsigned, XDR_S_U);
+   function XDR_S_U_To_Unsigned is
+      new Ada.Unchecked_Conversion (XDR_S_U, Unsigned);
+
+   function Long_Long_Unsigned_To_XDR_S_LU is
+      new Ada.Unchecked_Conversion (Long_Long_Unsigned, XDR_S_LU);
+   function XDR_S_LU_To_Long_Long_Unsigned is
+      new Ada.Unchecked_Conversion (XDR_S_LU, Long_Long_Unsigned);
+
+   function Long_Long_Unsigned_To_XDR_S_LLU is
+      new Ada.Unchecked_Conversion (Long_Long_Unsigned, XDR_S_LLU);
+   function XDR_S_LLU_To_Long_Long_Unsigned is
+      new Ada.Unchecked_Conversion (XDR_S_LLU, Long_Long_Unsigned);
+
+   --  The standard defines the floating-point data type "float" (32 bits
+   --  or 4 bytes). The encoding used is the IEEE standard for normalized
+   --  single-precision floating-point numbers.
+
+   --  The standard defines the encoding for the double-precision
+   --  floating-point data type "double" (64 bits or 8 bytes). The
+   --  encoding used is the IEEE standard for normalized double-precision
+   --  floating-point numbers.
+
+   SF_L  : constant := 4;   --  Single precision
+   F_L   : constant := 4;   --  Single precision
+   LF_L  : constant := 8;   --  Double precision
+   LLF_L : constant := 16;  --  Quadruple precision
+
+   TM_L : constant := 8;
+   subtype XDR_S_TM is SEA (1 .. TM_L);
+   type XDR_TM is mod BB ** TM_L;
+
+   type XDR_SA is mod 2 ** Standard'Address_Size;
+   function To_XDR_SA is new UC (System.Address, XDR_SA);
+   function To_XDR_SA is new UC (XDR_SA, System.Address);
+
+   --  Enumerations have the same representation as signed integers.
+   --  Enumerations are handy for describing subsets of the integers.
+
+   --  Booleans are important enough and occur frequently enough to warrant
+   --  their own explicit type in the standard. Booleans are declared as
+   --  an enumeration, with FALSE = 0 and TRUE = 1.
+
+   --  The standard defines a string of n (numbered 0 through n-1) ASCII
+   --  bytes to be the number n encoded as an unsigned integer (as described
+   --  above), and followed by the n bytes of the string. Byte m of the string
+   --  always precedes byte m+1 of the string, and byte 0 of the string always
+   --  follows the string's length. If n is not a multiple of four, then the
+   --  n bytes are followed by enough (0 to 3) residual zero bytes, r, to make
+   --  the total byte count a multiple of four.
+
+   --  To fit with XDR string, do not consider character as an enumeration
+   --  type.
+
+   C_L   : constant := 1;
+   subtype XDR_S_C is SEA (1 .. C_L);
+
+   --  Consider Wide_Character as an enumeration type
+
+   WC_L  : constant := 4;
+   subtype XDR_S_WC is SEA (1 .. WC_L);
+   type XDR_WC is mod BB ** WC_L;
+
+   --  Optimization: if we already have the correct Bit_Order, then some
+   --  computations can be avoided since the source and the target will be
+   --  identical anyway. They will be replaced by direct unchecked
+   --  conversions.
+
+   Optimize_Integers : constant Boolean :=
+     Default_Bit_Order = High_Order_First;
+
+   ----------
+   -- I_AD --
+   ----------
+
+   function I_AD (Stream : access RST) return Fat_Pointer is
+      FP : Fat_Pointer;
+
+   begin
+      FP.P1 := I_AS (Stream).P1;
+      FP.P2 := I_AS (Stream).P1;
+
+      return FP;
+   end I_AD;
+
+   ----------
+   -- I_AS --
+   ----------
+
+   function I_AS (Stream : access RST) return Thin_Pointer is
+      S : XDR_S_TM;
+      L : SEO;
+      U : XDR_TM := 0;
+
+   begin
+      Ada.Streams.Read (Stream.all, S, L);
+
+      if L /= S'Last then
+         raise Data_Error;
+      else
+         for N in S'Range loop
+            U := U * BB + XDR_TM (S (N));
+         end loop;
+
+         return (P1 => To_XDR_SA (XDR_SA (U)));
+      end if;
+   end I_AS;
+
+   ---------
+   -- I_B --
+   ---------
+
+   function I_B (Stream : access RST) return Boolean is
+   begin
+      case I_SSU (Stream) is
+         when 0      => return False;
+         when 1      => return True;
+         when others => raise Data_Error;
+      end case;
+   end I_B;
+
+   ---------
+   -- I_C --
+   ---------
+
+   function I_C (Stream : access RST) return Character is
+      S : XDR_S_C;
+      L : SEO;
+
+   begin
+      Ada.Streams.Read (Stream.all, S, L);
+
+      if L /= S'Last then
+         raise Data_Error;
+      else
+
+         --  Use Ada requirements on Character representation clause
+
+         return Character'Val (S (1));
+      end if;
+   end I_C;
+
+   ---------
+   -- I_F --
+   ---------
+
+   function I_F (Stream : access RST) return Float is
+      I       : constant Precision := Single;
+      E_Size  : Integer  renames Fields (I).E_Size;
+      E_Bias  : Integer  renames Fields (I).E_Bias;
+      E_Last  : Integer  renames Fields (I).E_Last;
+      F_Mask  : SE       renames Fields (I).F_Mask;
+      E_Bytes : SEO      renames Fields (I).E_Bytes;
+      F_Bytes : SEO      renames Fields (I).F_Bytes;
+      F_Size  : Integer  renames Fields (I).F_Size;
+
+      Positive   : Boolean;
+      Exponent   : Long_Unsigned;
+      Fraction   : Long_Unsigned;
+      Result     : Float;
+      S          : SEA (1 .. F_L);
+      L          : SEO;
+
+   begin
+      Ada.Streams.Read (Stream.all, S, L);
+
+      if L /= S'Last then
+         raise Data_Error;
+      end if;
+
+      --  Extract Fraction, Sign and Exponent
+
+      Fraction := Long_Unsigned (S (F_L + 1 - F_Bytes) and F_Mask);
+      for N in F_L + 2 - F_Bytes .. F_L loop
+         Fraction := Fraction * BB + Long_Unsigned (S (N));
+      end loop;
+      Result := Float'Scaling (Float (Fraction), -F_Size);
+
+      if BS <= S (1) then
+         Positive := False;
+         Exponent := Long_Unsigned (S (1) - BS);
+      else
+         Positive := True;
+         Exponent := Long_Unsigned (S (1));
+      end if;
+
+      for N in 2 .. E_Bytes loop
+         Exponent := Exponent * BB + Long_Unsigned (S (N));
+      end loop;
+      Exponent := Shift_Right (Exponent, Integer (E_Bytes) * SU - E_Size - 1);
+
+      --  NaN or Infinities
+
+      if Integer (Exponent) = E_Last then
+         raise Constraint_Error;
+
+      elsif Exponent = 0 then
+
+         --  Signed zeros
+
+         if Fraction = 0 then
+            null;
+
+         --  Denormalized float
+
+         else
+            Result := Float'Scaling (Result, 1 - E_Bias);
+         end if;
+
+      --  Normalized float
+
+      else
+         Result := Float'Scaling
+           (1.0 + Result, Integer (Exponent) - E_Bias);
+      end if;
+
+      if not Positive then
+         Result := -Result;
+      end if;
+
+      return Result;
+   end I_F;
+
+   ---------
+   -- I_I --
+   ---------
+
+   function I_I (Stream : access RST) return Integer is
+      S : XDR_S_I;
+      L : SEO;
+      U : XDR_U := 0;
+
+   begin
+      Ada.Streams.Read (Stream.all, S, L);
+
+      if L /= S'Last then
+         raise Data_Error;
+
+      elsif Optimize_Integers then
+         return XDR_S_I_To_Integer (S);
+
+      else
+         for N in S'Range loop
+            U := U * BB + XDR_U (S (N));
+         end loop;
+
+         --  Test sign and apply two complement notation
+
+         if S (1) < BL then
+            return Integer (U);
+
+         else
+            return Integer (-((XDR_U'Last xor U) + 1));
+         end if;
+      end if;
+   end I_I;
+
+   ----------
+   -- I_LF --
+   ----------
+
+   function I_LF (Stream : access RST) return Long_Float is
+      I       : constant Precision := Double;
+      E_Size  : Integer  renames Fields (I).E_Size;
+      E_Bias  : Integer  renames Fields (I).E_Bias;
+      E_Last  : Integer  renames Fields (I).E_Last;
+      F_Mask  : SE       renames Fields (I).F_Mask;
+      E_Bytes : SEO      renames Fields (I).E_Bytes;
+      F_Bytes : SEO      renames Fields (I).F_Bytes;
+      F_Size  : Integer  renames Fields (I).F_Size;
+
+      Positive   : Boolean;
+      Exponent   : Long_Unsigned;
+      Fraction   : Long_Long_Unsigned;
+      Result     : Long_Float;
+      S          : SEA (1 .. LF_L);
+      L          : SEO;
+
+   begin
+      Ada.Streams.Read (Stream.all, S, L);
+
+      if L /= S'Last then
+         raise Data_Error;
+      end if;
+
+      --  Extract Fraction, Sign and Exponent
+
+      Fraction := Long_Long_Unsigned (S (LF_L + 1 - F_Bytes) and F_Mask);
+      for N in LF_L + 2 - F_Bytes .. LF_L loop
+         Fraction := Fraction * BB + Long_Long_Unsigned (S (N));
+      end loop;
+
+      Result := Long_Float'Scaling (Long_Float (Fraction), -F_Size);
+
+      if BS <= S (1) then
+         Positive := False;
+         Exponent := Long_Unsigned (S (1) - BS);
+      else
+         Positive := True;
+         Exponent := Long_Unsigned (S (1));
+      end if;
+
+      for N in 2 .. E_Bytes loop
+         Exponent := Exponent * BB + Long_Unsigned (S (N));
+      end loop;
+
+      Exponent := Shift_Right (Exponent, Integer (E_Bytes) * SU - E_Size - 1);
+
+      --  NaN or Infinities
+
+      if Integer (Exponent) = E_Last then
+         raise Constraint_Error;
+
+      elsif Exponent = 0 then
+
+         --  Signed zeros
+
+         if Fraction = 0 then
+            null;
+
+         --  Denormalized float
+
+         else
+            Result := Long_Float'Scaling (Result, 1 - E_Bias);
+         end if;
+
+      --  Normalized float
+
+      else
+         Result := Long_Float'Scaling
+           (1.0 + Result, Integer (Exponent) - E_Bias);
+      end if;
+
+      if not Positive then
+         Result := -Result;
+      end if;
+
+      return Result;
+   end I_LF;
+
+   ----------
+   -- I_LI --
+   ----------
+
+   function I_LI (Stream : access RST) return Long_Integer is
+      S : XDR_S_LI;
+      L : SEO;
+      U : Unsigned := 0;
+      X : Long_Unsigned := 0;
+
+   begin
+      Ada.Streams.Read (Stream.all, S, L);
+
+      if L /= S'Last then
+         raise Data_Error;
+
+      elsif Optimize_Integers then
+         return Long_Integer (XDR_S_LI_To_Long_Long_Integer (S));
+
+      else
+
+         --  Compute using machine unsigned
+         --  rather than long_long_unsigned
+
+         for N in S'Range loop
+            U := U * BB + Unsigned (S (N));
+
+            --  We have filled an unsigned
+
+            if N mod UB = 0 then
+               X := Shift_Left (X, US) + Long_Unsigned (U);
+               U := 0;
+            end if;
+         end loop;
+
+         --  Test sign and apply two complement notation
+
+         if S (1) < BL then
+            return Long_Integer (X);
+         else
+            return Long_Integer (-((Long_Unsigned'Last xor X) + 1));
+         end if;
+
+      end if;
+   end I_LI;
+
+   -----------
+   -- I_LLF --
+   -----------
+
+   function I_LLF (Stream : access RST) return Long_Long_Float is
+      I       : constant Precision := Quadruple;
+      E_Size  : Integer  renames Fields (I).E_Size;
+      E_Bias  : Integer  renames Fields (I).E_Bias;
+      E_Last  : Integer  renames Fields (I).E_Last;
+      E_Bytes : SEO      renames Fields (I).E_Bytes;
+      F_Bytes : SEO      renames Fields (I).F_Bytes;
+      F_Size  : Integer  renames Fields (I).F_Size;
+
+      Positive   : Boolean;
+      Exponent   : Long_Unsigned;
+      Fraction_1 : Long_Long_Unsigned := 0;
+      Fraction_2 : Long_Long_Unsigned := 0;
+      Result     : Long_Long_Float;
+      HF         : constant Natural := F_Size / 2;
+      S          : SEA (1 .. LLF_L);
+      L          : SEO;
+
+   begin
+      Ada.Streams.Read (Stream.all, S, L);
+
+      if L /= S'Last then
+         raise Data_Error;
+      end if;
+
+      --  Extract Fraction, Sign and Exponent
+
+      for I in LLF_L - F_Bytes + 1 .. LLF_L - 7 loop
+         Fraction_1 := Fraction_1 * BB + Long_Long_Unsigned (S (I));
+      end loop;
+
+      for I in SEO (LLF_L - 6) .. SEO (LLF_L) loop
+         Fraction_2 := Fraction_2 * BB + Long_Long_Unsigned (S (I));
+      end loop;
+
+      Result := Long_Long_Float'Scaling (Long_Long_Float (Fraction_2), -HF);
+      Result := Long_Long_Float (Fraction_1) + Result;
+      Result := Long_Long_Float'Scaling (Result, HF - F_Size);
+
+      if BS <= S (1) then
+         Positive := False;
+         Exponent := Long_Unsigned (S (1) - BS);
+      else
+         Positive := True;
+         Exponent := Long_Unsigned (S (1));
+      end if;
+
+      for N in 2 .. E_Bytes loop
+         Exponent := Exponent * BB + Long_Unsigned (S (N));
+      end loop;
+
+      Exponent := Shift_Right (Exponent, Integer (E_Bytes) * SU - E_Size - 1);
+
+      --  NaN or Infinities
+
+      if Integer (Exponent) = E_Last then
+         raise Constraint_Error;
+
+      elsif Exponent = 0 then
+
+         --  Signed zeros
+
+         if Fraction_1 = 0 and then Fraction_2 = 0 then
+            null;
+
+         --  Denormalized float
+
+         else
+            Result := Long_Long_Float'Scaling (Result, 1 - E_Bias);
+         end if;
+
+      --  Normalized float
+
+      else
+         Result := Long_Long_Float'Scaling
+           (1.0 + Result, Integer (Exponent) - E_Bias);
+      end if;
+
+      if not Positive then
+         Result := -Result;
+      end if;
+
+      return Result;
+   end I_LLF;
+
+   -----------
+   -- I_LLI --
+   -----------
+
+   function I_LLI (Stream : access RST) return Long_Long_Integer is
+      S : XDR_S_LLI;
+      L : SEO;
+      U : Unsigned := 0;
+      X : Long_Long_Unsigned := 0;
+
+   begin
+      Ada.Streams.Read (Stream.all, S, L);
+
+      if L /= S'Last then
+         raise Data_Error;
+      elsif Optimize_Integers then
+         return XDR_S_LLI_To_Long_Long_Integer (S);
+      else
+
+         --  Compute using machine unsigned for computing
+         --  rather than long_long_unsigned.
+
+         for N in S'Range loop
+            U := U * BB + Unsigned (S (N));
+
+            --  We have filled an unsigned
+
+            if N mod UB = 0 then
+               X := Shift_Left (X, US) + Long_Long_Unsigned (U);
+               U := 0;
+            end if;
+         end loop;
+
+         --  Test sign and apply two complement notation
+
+         if S (1) < BL then
+            return Long_Long_Integer (X);
+         else
+            return Long_Long_Integer (-((Long_Long_Unsigned'Last xor X) + 1));
+         end if;
+      end if;
+   end I_LLI;
+
+   -----------
+   -- I_LLU --
+   -----------
+
+   function I_LLU (Stream : access RST) return Long_Long_Unsigned is
+      S : XDR_S_LLU;
+      L : SEO;
+      U : Unsigned := 0;
+      X : Long_Long_Unsigned := 0;
+
+   begin
+      Ada.Streams.Read (Stream.all, S, L);
+
+      if L /= S'Last then
+         raise Data_Error;
+      elsif Optimize_Integers then
+         return XDR_S_LLU_To_Long_Long_Unsigned (S);
+      else
+
+         --  Compute using machine unsigned
+         --  rather than long_long_unsigned.
+
+         for N in S'Range loop
+            U := U * BB + Unsigned (S (N));
+
+            --  We have filled an unsigned
+
+            if N mod UB = 0 then
+               X := Shift_Left (X, US) + Long_Long_Unsigned (U);
+               U := 0;
+            end if;
+         end loop;
+
+         return X;
+      end if;
+   end I_LLU;
+
+   ----------
+   -- I_LU --
+   ----------
+
+   function I_LU (Stream : access RST) return Long_Unsigned is
+      S : XDR_S_LU;
+      L : SEO;
+      U : Unsigned := 0;
+      X : Long_Unsigned := 0;
+
+   begin
+      Ada.Streams.Read (Stream.all, S, L);
+
+      if L /= S'Last then
+         raise Data_Error;
+      elsif Optimize_Integers then
+         return Long_Unsigned (XDR_S_LU_To_Long_Long_Unsigned (S));
+      else
+
+         --  Compute using machine unsigned
+         --  rather than long_unsigned.
+
+         for N in S'Range loop
+            U := U * BB + Unsigned (S (N));
+
+            --  We have filled an unsigned
+
+            if N mod UB = 0 then
+               X := Shift_Left (X, US) + Long_Unsigned (U);
+               U := 0;
+            end if;
+         end loop;
+
+         return X;
+      end if;
+   end I_LU;
+
+   ----------
+   -- I_SF --
+   ----------
+
+   function I_SF (Stream : access RST) return Short_Float is
+      I       : constant Precision := Single;
+      E_Size  : Integer  renames Fields (I).E_Size;
+      E_Bias  : Integer  renames Fields (I).E_Bias;
+      E_Last  : Integer  renames Fields (I).E_Last;
+      F_Mask  : SE       renames Fields (I).F_Mask;
+      E_Bytes : SEO      renames Fields (I).E_Bytes;
+      F_Bytes : SEO      renames Fields (I).F_Bytes;
+      F_Size  : Integer  renames Fields (I).F_Size;
+
+      Exponent   : Long_Unsigned;
+      Fraction   : Long_Unsigned;
+      Positive   : Boolean;
+      Result     : Short_Float;
+      S          : SEA (1 .. SF_L);
+      L          : SEO;
+
+   begin
+      Ada.Streams.Read (Stream.all, S, L);
+
+      if L /= S'Last then
+         raise Data_Error;
+      end if;
+
+      --  Extract Fraction, Sign and Exponent
+
+      Fraction := Long_Unsigned (S (SF_L + 1 - F_Bytes) and F_Mask);
+      for N in SF_L + 2 - F_Bytes .. SF_L loop
+         Fraction := Fraction * BB + Long_Unsigned (S (N));
+      end loop;
+      Result := Short_Float'Scaling (Short_Float (Fraction), -F_Size);
+
+      if BS <= S (1) then
+         Positive := False;
+         Exponent := Long_Unsigned (S (1) - BS);
+      else
+         Positive := True;
+         Exponent := Long_Unsigned (S (1));
+      end if;
+
+      for N in 2 .. E_Bytes loop
+         Exponent := Exponent * BB + Long_Unsigned (S (N));
+      end loop;
+      Exponent := Shift_Right (Exponent, Integer (E_Bytes) * SU - E_Size - 1);
+
+      --  NaN or Infinities
+
+      if Integer (Exponent) = E_Last then
+         raise Constraint_Error;
+
+      elsif Exponent = 0 then
+
+         --  Signed zeros
+
+         if Fraction = 0 then
+            null;
+
+         --  Denormalized float
+
+         else
+            Result := Short_Float'Scaling (Result, 1 - E_Bias);
+         end if;
+
+      --  Normalized float
+
+      else
+         Result := Short_Float'Scaling
+           (1.0 + Result, Integer (Exponent) - E_Bias);
+      end if;
+
+      if not Positive then
+         Result := -Result;
+      end if;
+
+      return Result;
+   end I_SF;
+
+   ----------
+   -- I_SI --
+   ----------
+
+   function I_SI (Stream : access RST) return Short_Integer is
+      S : XDR_S_SI;
+      L : SEO;
+      U : XDR_SU := 0;
+
+   begin
+      Ada.Streams.Read (Stream.all, S, L);
+
+      if L /= S'Last then
+         raise Data_Error;
+
+      elsif Optimize_Integers then
+         return XDR_S_SI_To_Short_Integer (S);
+
+      else
+         for N in S'Range loop
+            U := U * BB + XDR_SU (S (N));
+         end loop;
+
+         --  Test sign and apply two complement notation
+
+         if S (1) < BL then
+            return Short_Integer (U);
+         else
+            return Short_Integer (-((XDR_SU'Last xor U) + 1));
+         end if;
+      end if;
+   end I_SI;
+
+   -----------
+   -- I_SSI --
+   -----------
+
+   function I_SSI (Stream : access RST) return Short_Short_Integer is
+      S : XDR_S_SSI;
+      L : SEO;
+      U : XDR_SSU;
+
+   begin
+      Ada.Streams.Read (Stream.all, S, L);
+
+      if L /= S'Last then
+         raise Data_Error;
+      elsif Optimize_Integers then
+         return XDR_S_SSI_To_Short_Short_Integer (S);
+      else
+         U := XDR_SSU (S (1));
+
+         --  Test sign and apply two complement notation
+
+         if S (1) < BL then
+            return Short_Short_Integer (U);
+         else
+            return Short_Short_Integer (-((XDR_SSU'Last xor U) + 1));
+         end if;
+      end if;
+   end I_SSI;
+
+   -----------
+   -- I_SSU --
+   -----------
+
+   function I_SSU (Stream : access RST) return Short_Short_Unsigned is
+      S : XDR_S_SSU;
+      L : SEO;
+      U : XDR_SSU := 0;
+
+   begin
+      Ada.Streams.Read (Stream.all, S, L);
+
+      if L /= S'Last then
+         raise Data_Error;
+      else
+         U := XDR_SSU (S (1));
+
+         return Short_Short_Unsigned (U);
+      end if;
+   end I_SSU;
+
+   ----------
+   -- I_SU --
+   ----------
+
+   function I_SU (Stream : access RST) return Short_Unsigned is
+      S : XDR_S_SU;
+      L : SEO;
+      U : XDR_SU := 0;
+
+   begin
+      Ada.Streams.Read (Stream.all, S, L);
+
+      if L /= S'Last then
+         raise Data_Error;
+      elsif Optimize_Integers then
+         return XDR_S_SU_To_Short_Unsigned (S);
+      else
+         for N in S'Range loop
+            U := U * BB + XDR_SU (S (N));
+         end loop;
+
+         return Short_Unsigned (U);
+      end if;
+   end I_SU;
+
+   ---------
+   -- I_U --
+   ---------
+
+   function I_U (Stream : access RST) return Unsigned is
+      S : XDR_S_U;
+      L : SEO;
+      U : XDR_U := 0;
+
+   begin
+      Ada.Streams.Read (Stream.all, S, L);
+
+      if L /= S'Last then
+         raise Data_Error;
+
+      elsif Optimize_Integers then
+         return XDR_S_U_To_Unsigned (S);
+
+      else
+         for N in S'Range loop
+            U := U * BB + XDR_U (S (N));
+         end loop;
+
+         return Unsigned (U);
+      end if;
+   end I_U;
+
+   ----------
+   -- I_WC --
+   ----------
+
+   function I_WC (Stream : access RST) return Wide_Character is
+      S : XDR_S_WC;
+      L : SEO;
+      U : XDR_WC := 0;
+
+   begin
+      Ada.Streams.Read (Stream.all, S, L);
+
+      if L /= S'Last then
+         raise Data_Error;
+      else
+         for N in S'Range loop
+            U := U * BB + XDR_WC (S (N));
+         end loop;
+
+         --  Use Ada requirements on Wide_Character representation clause
+
+         return Wide_Character'Val (U);
+      end if;
+   end I_WC;
+
+   ----------
+   -- W_AD --
+   ----------
+
+   procedure W_AD (Stream : access RST; Item : in Fat_Pointer) is
+      S : XDR_S_TM;
+      U : XDR_TM;
+
+   begin
+      U := XDR_TM (To_XDR_SA (Item.P1));
+      for N in reverse S'Range loop
+         S (N) := SE (U mod BB);
+         U := U / BB;
+      end loop;
+
+      Ada.Streams.Write (Stream.all, S);
+
+      U := XDR_TM (To_XDR_SA (Item.P2));
+      for N in reverse S'Range loop
+         S (N) := SE (U mod BB);
+         U := U / BB;
+      end loop;
+
+      Ada.Streams.Write (Stream.all, S);
+
+      if U /= 0 then
+         raise Data_Error;
+      end if;
+   end W_AD;
+
+   ----------
+   -- W_AS --
+   ----------
+
+   procedure W_AS (Stream : access RST; Item : in Thin_Pointer) is
+      S : XDR_S_TM;
+      U : XDR_TM := XDR_TM (To_XDR_SA (Item.P1));
+
+   begin
+      for N in reverse S'Range loop
+         S (N) := SE (U mod BB);
+         U := U / BB;
+      end loop;
+
+      Ada.Streams.Write (Stream.all, S);
+
+      if U /= 0 then
+         raise Data_Error;
+      end if;
+   end W_AS;
+
+   ---------
+   -- W_B --
+   ---------
+
+   procedure W_B (Stream : access RST; Item : in Boolean) is
+   begin
+      if Item then
+         W_SSU (Stream, 1);
+      else
+         W_SSU (Stream, 0);
+      end if;
+   end W_B;
+
+   ---------
+   -- W_C --
+   ---------
+
+   procedure W_C (Stream : access RST; Item : in Character) is
+      S : XDR_S_C;
+
+      pragma Assert (C_L = 1);
+
+   begin
+
+      --  Use Ada requirements on Character representation clause
+
+      S (1) := SE (Character'Pos (Item));
+
+      Ada.Streams.Write (Stream.all, S);
+   end W_C;
+
+   ---------
+   -- W_F --
+   ---------
+
+   procedure W_F (Stream : access RST; Item : in Float) is
+      I       : constant Precision := Single;
+      E_Size  : Integer  renames Fields (I).E_Size;
+      E_Bias  : Integer  renames Fields (I).E_Bias;
+      E_Bytes : SEO      renames Fields (I).E_Bytes;
+      F_Bytes : SEO      renames Fields (I).F_Bytes;
+      F_Size  : Integer  renames Fields (I).F_Size;
+      F_Mask  : SE       renames Fields (I).F_Mask;
+
+      Exponent : Long_Unsigned;
+      Fraction : Long_Unsigned;
+      Positive : Boolean;
+      E        : Integer;
+      F        : Float;
+      S        : SEA (1 .. F_L) := (others => 0);
+
+   begin
+      if not Item'Valid then
+         raise Constraint_Error;
+      end if;
+
+      --  Compute Sign
+
+      Positive := (0.0 <= Item);
+      F := abs (Item);
+
+      --  Signed zero
+
+      if F = 0.0 then
+         Exponent := 0;
+         Fraction := 0;
+
+      else
+         E := Float'Exponent (F) - 1;
+
+         --  Denormalized float
+
+         if E <= -E_Bias then
+            F := Float'Scaling (F, F_Size + E_Bias - 1);
+            E := -E_Bias;
+         else
+            F := Float'Scaling (Float'Fraction (F), F_Size + 1);
+         end if;
+
+         --  Compute Exponent and Fraction
+
+         Exponent := Long_Unsigned (E + E_Bias);
+         Fraction := Long_Unsigned (F * 2.0) / 2;
+      end if;
+
+      --  Store Fraction
+
+      for I in reverse F_L - F_Bytes + 1 .. F_L loop
+         S (I) := SE (Fraction mod BB);
+         Fraction := Fraction / BB;
+      end loop;
+
+      --  Remove implicit bit
+
+      S (F_L - F_Bytes + 1) := S (F_L - F_Bytes + 1) and F_Mask;
+
+      --  Store Exponent (not always at the beginning of a byte)
+
+      Exponent := Shift_Left (Exponent, Integer (E_Bytes) * SU - E_Size - 1);
+      for N in reverse 1 .. E_Bytes loop
+         S (N) := SE (Exponent mod BB) + S (N);
+         Exponent := Exponent / BB;
+      end loop;
+
+      --  Store Sign
+
+      if not Positive then
+         S (1) := S (1) + BS;
+      end if;
+
+      Ada.Streams.Write (Stream.all, S);
+   end W_F;
+
+   ---------
+   -- W_I --
+   ---------
+
+   procedure W_I (Stream : access RST; Item : in Integer) is
+      S : XDR_S_I;
+      U : XDR_U;
+
+   begin
+      if Optimize_Integers then
+         S := Integer_To_XDR_S_I (Item);
+      else
+
+         --  Test sign and apply two complement notation
+
+         if Item < 0 then
+            U := XDR_U'Last xor XDR_U (-(Item + 1));
+         else
+            U := XDR_U (Item);
+         end if;
+
+         for N in reverse S'Range loop
+            S (N) := SE (U mod BB);
+            U := U / BB;
+         end loop;
+
+         if U /= 0 then
+            raise Data_Error;
+         end if;
+      end if;
+
+      Ada.Streams.Write (Stream.all, S);
+   end W_I;
+
+   ----------
+   -- W_LF --
+   ----------
+
+   procedure W_LF (Stream : access RST; Item : in Long_Float) is
+      I       : constant Precision := Double;
+      E_Size  : Integer  renames Fields (I).E_Size;
+      E_Bias  : Integer  renames Fields (I).E_Bias;
+      E_Bytes : SEO      renames Fields (I).E_Bytes;
+      F_Bytes : SEO      renames Fields (I).F_Bytes;
+      F_Size  : Integer  renames Fields (I).F_Size;
+      F_Mask  : SE       renames Fields (I).F_Mask;
+
+      Exponent : Long_Unsigned;
+      Fraction : Long_Long_Unsigned;
+      Positive : Boolean;
+      E        : Integer;
+      F        : Long_Float;
+      S        : SEA (1 .. LF_L) := (others => 0);
+
+   begin
+      if not Item'Valid then
+         raise Constraint_Error;
+      end if;
+
+      --  Compute Sign
+
+      Positive := (0.0 <= Item);
+      F := abs (Item);
+
+      --  Signed zero
+
+      if F = 0.0 then
+         Exponent := 0;
+         Fraction := 0;
+
+      else
+         E := Long_Float'Exponent (F) - 1;
+
+         --  Denormalized float
+
+         if E <= -E_Bias then
+            E := -E_Bias;
+            F := Long_Float'Scaling (F, F_Size + E_Bias - 1);
+         else
+            F := Long_Float'Scaling (F, F_Size - E);
+         end if;
+
+         --  Compute Exponent and Fraction
+
+         Exponent := Long_Unsigned (E + E_Bias);
+         Fraction := Long_Long_Unsigned (F * 2.0) / 2;
+      end if;
+
+      --  Store Fraction
+
+      for I in reverse LF_L - F_Bytes + 1 .. LF_L loop
+         S (I) := SE (Fraction mod BB);
+         Fraction := Fraction / BB;
+      end loop;
+
+      --  Remove implicit bit
+
+      S (LF_L - F_Bytes + 1) := S (LF_L - F_Bytes + 1) and F_Mask;
+
+      --  Store Exponent (not always at the beginning of a byte)
+
+      Exponent := Shift_Left (Exponent, Integer (E_Bytes) * SU - E_Size - 1);
+      for N in reverse 1 .. E_Bytes loop
+         S (N) := SE (Exponent mod BB) + S (N);
+         Exponent := Exponent / BB;
+      end loop;
+
+      --  Store Sign
+
+      if not Positive then
+         S (1) := S (1) + BS;
+      end if;
+
+      Ada.Streams.Write (Stream.all, S);
+   end W_LF;
+
+   ----------
+   -- W_LI --
+   ----------
+
+   procedure W_LI (Stream : access RST; Item : in Long_Integer) is
+      S : XDR_S_LI;
+      U : Unsigned;
+      X : Long_Unsigned;
+
+   begin
+      if Optimize_Integers then
+         S := Long_Long_Integer_To_XDR_S_LI (Long_Long_Integer (Item));
+      else
+
+         --  Test sign and apply two complement notation
+
+         if Item < 0 then
+            X := Long_Unsigned'Last xor Long_Unsigned (-(Item + 1));
+         else
+            X := Long_Unsigned (Item);
+         end if;
+
+         --  Compute using machine unsigned
+         --  rather than long_unsigned.
+
+         for N in reverse S'Range loop
+
+            --  We have filled an unsigned
+
+            if (LU_L - N) mod UB = 0 then
+               U := Unsigned (X and UL);
+               X := Shift_Right (X, US);
+            end if;
+
+            S (N) := SE (U mod BB);
+            U := U / BB;
+         end loop;
+
+         if U /= 0 then
+            raise Data_Error;
+         end if;
+      end if;
+
+      Ada.Streams.Write (Stream.all, S);
+   end W_LI;
+
+   -----------
+   -- W_LLF --
+   -----------
+
+   procedure W_LLF (Stream : access RST; Item : in Long_Long_Float) is
+      I       : constant Precision := Quadruple;
+      E_Size  : Integer  renames Fields (I).E_Size;
+      E_Bias  : Integer  renames Fields (I).E_Bias;
+      E_Bytes : SEO      renames Fields (I).E_Bytes;
+      F_Bytes : SEO      renames Fields (I).F_Bytes;
+      F_Size  : Integer  renames Fields (I).F_Size;
+
+      HFS : constant Integer := F_Size / 2;
+
+      Exponent   : Long_Unsigned;
+      Fraction_1 : Long_Long_Unsigned;
+      Fraction_2 : Long_Long_Unsigned;
+      Positive   : Boolean;
+      E          : Integer;
+      F          : Long_Long_Float := Item;
+      S          : SEA (1 .. LLF_L) := (others => 0);
+
+   begin
+      if not Item'Valid then
+         raise Constraint_Error;
+      end if;
+
+      --  Compute Sign
+
+      Positive := (0.0 <= Item);
+      if F < 0.0 then
+         F := -Item;
+      end if;
+
+      --  Signed zero
+
+      if F = 0.0 then
+         Exponent   := 0;
+         Fraction_1 := 0;
+         Fraction_2 := 0;
+
+      else
+         E := Long_Long_Float'Exponent (F) - 1;
+
+         --  Denormalized float
+
+         if E <= -E_Bias then
+            F := Long_Long_Float'Scaling (F, E_Bias - 1);
+            E := -E_Bias;
+         else
+            F := Long_Long_Float'Scaling
+              (Long_Long_Float'Fraction (F), 1);
+         end if;
+
+         --  Compute Exponent and Fraction
+
+         Exponent   := Long_Unsigned (E + E_Bias);
+         F          := Long_Long_Float'Scaling (F, F_Size - HFS);
+         Fraction_1 := Long_Long_Unsigned (Long_Long_Float'Floor (F));
+         F          := Long_Long_Float (F - Long_Long_Float (Fraction_1));
+         F          := Long_Long_Float'Scaling (F, HFS);
+         Fraction_2 := Long_Long_Unsigned (Long_Long_Float'Floor (F));
+      end if;
+
+      --  Store Fraction_1
+
+      for I in reverse LLF_L - F_Bytes + 1 .. LLF_L - 7 loop
+         S (I) := SE (Fraction_1 mod BB);
+         Fraction_1 := Fraction_1 / BB;
+      end loop;
+
+      --  Store Fraction_2
+
+      for I in reverse LLF_L - 6 .. LLF_L loop
+         S (SEO (I)) := SE (Fraction_2 mod BB);
+         Fraction_2 := Fraction_2 / BB;
+      end loop;
+
+      --  Store Exponent (not always at the beginning of a byte)
+
+      Exponent := Shift_Left (Exponent, Integer (E_Bytes) * SU - E_Size - 1);
+      for N in reverse 1 .. E_Bytes loop
+         S (N) := SE (Exponent mod BB) + S (N);
+         Exponent := Exponent / BB;
+      end loop;
+
+      --  Store Sign
+
+      if not Positive then
+         S (1) := S (1) + BS;
+      end if;
+
+      Ada.Streams.Write (Stream.all, S);
+   end W_LLF;
+
+   -----------
+   -- W_LLI --
+   -----------
+
+   procedure W_LLI (Stream : access RST; Item : in Long_Long_Integer) is
+      S : XDR_S_LLI;
+      U : Unsigned;
+      X : Long_Long_Unsigned;
+
+   begin
+      if Optimize_Integers then
+         S := Long_Long_Integer_To_XDR_S_LLI (Item);
+      else
+
+         --  Test sign and apply two complement notation
+
+         if Item < 0 then
+            X := Long_Long_Unsigned'Last xor Long_Long_Unsigned (-(Item + 1));
+         else
+            X := Long_Long_Unsigned (Item);
+         end if;
+
+         --  Compute using machine unsigned
+         --  rather than long_long_unsigned.
+
+         for N in reverse S'Range loop
+
+            --  We have filled an unsigned
+
+            if (LLU_L - N) mod UB = 0 then
+               U := Unsigned (X and UL);
+               X := Shift_Right (X, US);
+            end if;
+
+            S (N) := SE (U mod BB);
+            U := U / BB;
+         end loop;
+
+         if U /= 0 then
+            raise Data_Error;
+         end if;
+      end if;
+
+      Ada.Streams.Write (Stream.all, S);
+   end W_LLI;
+
+   -----------
+   -- W_LLU --
+   -----------
+
+   procedure W_LLU (Stream : access RST; Item : in Long_Long_Unsigned) is
+      S : XDR_S_LLU;
+      U : Unsigned;
+      X : Long_Long_Unsigned := Item;
+
+   begin
+      if Optimize_Integers then
+         S := Long_Long_Unsigned_To_XDR_S_LLU (Item);
+      else
+         --  Compute using machine unsigned
+         --  rather than long_long_unsigned.
+
+         for N in reverse S'Range loop
+
+            --  We have filled an unsigned
+
+            if (LLU_L - N) mod UB = 0 then
+               U := Unsigned (X and UL);
+               X := Shift_Right (X, US);
+            end if;
+
+            S (N) := SE (U mod BB);
+            U := U / BB;
+         end loop;
+
+         if U /= 0 then
+            raise Data_Error;
+         end if;
+      end if;
+
+      Ada.Streams.Write (Stream.all, S);
+   end W_LLU;
+
+   ----------
+   -- W_LU --
+   ----------
+
+   procedure W_LU (Stream : access RST; Item : in Long_Unsigned) is
+      S : XDR_S_LU;
+      U : Unsigned;
+      X : Long_Unsigned := Item;
+
+   begin
+      if Optimize_Integers then
+         S := Long_Long_Unsigned_To_XDR_S_LU (Long_Long_Unsigned (Item));
+      else
+         --  Compute using machine unsigned
+         --  rather than long_unsigned.
+
+         for N in reverse S'Range loop
+
+            --  We have filled an unsigned
+
+            if (LU_L - N) mod UB = 0 then
+               U := Unsigned (X and UL);
+               X := Shift_Right (X, US);
+            end if;
+            S (N) := SE (U mod BB);
+            U := U / BB;
+         end loop;
+
+         if U /= 0 then
+            raise Data_Error;
+         end if;
+      end if;
+
+      Ada.Streams.Write (Stream.all, S);
+   end W_LU;
+
+   ----------
+   -- W_SF --
+   ----------
+
+   procedure W_SF (Stream : access RST; Item : in Short_Float) is
+      I       : constant Precision := Single;
+      E_Size  : Integer  renames Fields (I).E_Size;
+      E_Bias  : Integer  renames Fields (I).E_Bias;
+      E_Bytes : SEO      renames Fields (I).E_Bytes;
+      F_Bytes : SEO      renames Fields (I).F_Bytes;
+      F_Size  : Integer  renames Fields (I).F_Size;
+      F_Mask  : SE       renames Fields (I).F_Mask;
+
+      Exponent : Long_Unsigned;
+      Fraction : Long_Unsigned;
+      Positive : Boolean;
+      E        : Integer;
+      F        : Short_Float;
+      S        : SEA (1 .. SF_L) := (others => 0);
+
+   begin
+      if not Item'Valid then
+         raise Constraint_Error;
+      end if;
+
+      --  Compute Sign
+
+      Positive := (0.0 <= Item);
+      F := abs (Item);
+
+      --  Signed zero
+
+      if F = 0.0 then
+         Exponent := 0;
+         Fraction := 0;
+
+      else
+         E := Short_Float'Exponent (F) - 1;
+
+         --  Denormalized float
+
+         if E <= -E_Bias then
+            E := -E_Bias;
+            F := Short_Float'Scaling (F, F_Size + E_Bias - 1);
+         else
+            F := Short_Float'Scaling (F, F_Size - E);
+         end if;
+
+         --  Compute Exponent and Fraction
+
+         Exponent := Long_Unsigned (E + E_Bias);
+         Fraction := Long_Unsigned (F * 2.0) / 2;
+      end if;
+
+      --  Store Fraction
+
+      for I in reverse SF_L - F_Bytes + 1 .. SF_L loop
+         S (I) := SE (Fraction mod BB);
+         Fraction := Fraction / BB;
+      end loop;
+
+      --  Remove implicit bit
+
+      S (SF_L - F_Bytes + 1) := S (SF_L - F_Bytes + 1) and F_Mask;
+
+      --  Store Exponent (not always at the beginning of a byte)
+
+      Exponent := Shift_Left (Exponent, Integer (E_Bytes) * SU - E_Size - 1);
+      for N in reverse 1 .. E_Bytes loop
+         S (N) := SE (Exponent mod BB) + S (N);
+         Exponent := Exponent / BB;
+      end loop;
+
+      --  Store Sign
+
+      if not Positive then
+         S (1) := S (1) + BS;
+      end if;
+
+      Ada.Streams.Write (Stream.all, S);
+   end W_SF;
+
+   ----------
+   -- W_SI --
+   ----------
+
+   procedure W_SI (Stream : access RST; Item : in Short_Integer) is
+      S : XDR_S_SI;
+      U : XDR_SU;
+
+   begin
+      if Optimize_Integers then
+         S := Short_Integer_To_XDR_S_SI (Item);
+      else
+
+         --  Test sign and apply two complement's notation
+
+         if Item < 0 then
+            U := XDR_SU'Last xor XDR_SU (-(Item + 1));
+         else
+            U := XDR_SU (Item);
+         end if;
+
+         for N in reverse S'Range loop
+            S (N) := SE (U mod BB);
+            U := U / BB;
+         end loop;
+
+         if U /= 0 then
+            raise Data_Error;
+         end if;
+      end if;
+
+      Ada.Streams.Write (Stream.all, S);
+   end W_SI;
+
+   -----------
+   -- W_SSI --
+   -----------
+
+   procedure W_SSI (Stream : access RST; Item : in Short_Short_Integer) is
+      S : XDR_S_SSI;
+      U : XDR_SSU;
+
+   begin
+      if Optimize_Integers then
+         S := Short_Short_Integer_To_XDR_S_SSI (Item);
+      else
+
+         --  Test sign and apply two complement's notation
+
+         if Item < 0 then
+            U := XDR_SSU'Last xor XDR_SSU (-(Item + 1));
+         else
+            U := XDR_SSU (Item);
+         end if;
+
+         S (1) := SE (U);
+      end if;
+
+      Ada.Streams.Write (Stream.all, S);
+   end W_SSI;
+
+   -----------
+   -- W_SSU --
+   -----------
+
+   procedure W_SSU (Stream : access RST; Item : in Short_Short_Unsigned) is
+      S : XDR_S_SSU;
+      U : XDR_SSU := XDR_SSU (Item);
+
+   begin
+      S (1) := SE (U);
+
+      Ada.Streams.Write (Stream.all, S);
+   end W_SSU;
+
+   ----------
+   -- W_SU --
+   ----------
+
+   procedure W_SU (Stream : access RST; Item : in Short_Unsigned) is
+      S : XDR_S_SU;
+      U : XDR_SU := XDR_SU (Item);
+
+   begin
+      if Optimize_Integers then
+         S := Short_Unsigned_To_XDR_S_SU (Item);
+      else
+         for N in reverse S'Range loop
+            S (N) := SE (U mod BB);
+            U := U / BB;
+         end loop;
+
+         if U /= 0 then
+            raise Data_Error;
+         end if;
+      end if;
+
+      Ada.Streams.Write (Stream.all, S);
+   end W_SU;
+
+   ---------
+   -- W_U --
+   ---------
+
+   procedure W_U (Stream : access RST; Item : in Unsigned) is
+      S : XDR_S_U;
+      U : XDR_U := XDR_U (Item);
+
+   begin
+      if Optimize_Integers then
+         S := Unsigned_To_XDR_S_U (Item);
+      else
+         for N in reverse S'Range loop
+            S (N) := SE (U mod BB);
+            U := U / BB;
+         end loop;
+
+         if U /= 0 then
+            raise Data_Error;
+         end if;
+      end if;
+
+      Ada.Streams.Write (Stream.all, S);
+   end W_U;
+
+   ----------
+   -- W_WC --
+   ----------
+
+   procedure W_WC (Stream : access RST; Item : in Wide_Character) is
+      S : XDR_S_WC;
+      U : XDR_WC;
+
+   begin
+
+      --  Use Ada requirements on Wide_Character representation clause
+
+      U := XDR_WC (Wide_Character'Pos (Item));
+
+      for N in reverse S'Range loop
+         S (N) := SE (U mod BB);
+         U := U / BB;
+      end loop;
+
+      Ada.Streams.Write (Stream.all, S);
+
+      if U /= 0 then
+         raise Data_Error;
+      end if;
+   end W_WC;
+
+end System.Stream_Attributes;