DataMuseum.dk

top - metrics - download

    Length: 8866 (0x22a2)
    Types: TextFile
    Names: »send_asr.py«

└─⟦3d0c2be1b⟧ Bits:30001254 ISODE-5.0 Tape
    └─⟦eba4602b1⟧ »./isode-5.0.tar.Z« 
        └─⟦d3ac74d73⟧ 
            └─⟦this⟧ »isode-5.0/vt/send_asr.py« 

TextFile

-- VTPM: encode ASR PDU

-- $Header: /f/osi/vt/RCS/send_asr.py,v 6.0 89/03/18 23:46:17 mrose Rel $
--
--
-- $Log:	send_asr.py,v $
-- Revision 6.0  89/03/18  23:46:17  mrose
-- Release 5.0
-- 

--
--				  NOTICE
--
--    Acquisition, use, and distribution of this module and related
--    materials are subject to the restrictions of a license agreement.
--    Consult the Preface in the User's Manual for the full terms of
--    this agreement.
--
--


ASRPDU DEFINITIONS ::=

%{
#include <stdio.h>
#include "sector1.h"

#undef PEPYPARM
#define PEPYPARM int *

#undef	PEPYTEST

static int l,m;

#ifdef	PEPYTEST

char *myname;
ASR_MSG ud;
static char my_version = 0x01;
static char my_fu = 0x1c;

main(argc,argv)
int argc;
char **argv;
{

	PE pe;
	int i;

	myname = argv[0];

	ud.valid_reason = 0;
	ud.result = 1;
	ud.valid_imp = 0;
	ud.valid_arg_list = 1;
	ud.version.bitstring  = my_version;
	ud.version.bitcount = 1;
	ud.arg_list.num_sp_param = 1;
	ud.arg_list.num_cds_objects = 2;
	ud.arg_list.num_css_objects = 0;
	ud.arg_list.num_dev_objects = 0;
	ud.arg_list.sp_val[0].param_num = 1;
	ud.arg_list.sp_val[0].param_type = 1;
	ud.arg_list.sp_val[0].args.int_arg = 80;
	ud.arg_list.cds_val[0].obj_name = "KB";
	ud.arg_list.cds_val[1].obj_name = "DI";
	for(i=0; i<ud.arg_list.num_cds_objects; i++)
	{
		ud.arg_list.cds_val[i].dimensions = 0;
		ud.arg_list.cds_val[i].valid_x_dim = 0;
		ud.arg_list.cds_val[i].valid_y_dim = 0;
		ud.arg_list.cds_val[i].valid_z_dim = 0;
		ud.arg_list.cds_val[i].valid_erasure = 0;
		ud.arg_list.cds_val[i].valid_rep_list = 1;
		ud.arg_list.cds_val[i].valid_emp_list = 0;
		ud.arg_list.cds_val[i].valid_fore_color = 0;
		ud.arg_list.cds_val[i].valid_back_color = 0;
		ud.arg_list.cds_val[i].valid_access_right = 0;
		ud.arg_list.cds_val[i].rep_value.valid_cap = 1;
		ud.arg_list.cds_val[i].rep_value.capability = 1;
		ud.arg_list.cds_val[i].rep_value.num_reps = 1;
		ud.arg_list.cds_val[i].rep_value.repertoire[0].rep_type = 2;
		ud.arg_list.cds_val[i].rep_value.repertoire[0].rep_assign = 
					"ABC";
		ud.arg_list.cds_val[i].rep_value.repertoire[0].valid_font_cap =
					0;
	}
	ud.func_units.bitstring = my_fu;
	ud.func_units.bitcount = 5;

	build_ASRPDU_ASRpdu(&pe,1,NULL,NULLCP,&ud);

	print_ASRPDU_ASRpdu(pe,1,NULLIP,NULLVP,&ud);

	rcv_asr(pe);

	exit(0);
}

#endif

%}

BEGIN

SECTIONS build none none

ASRpdu ::= CHOICE <<1>>

{
	asrpdu [1] IMPLICIT ASRcontent [[p (PEPYPARM)parm]]
}

ASRcontent 
%{
	ASR_MSG	*arg = (ASR_MSG *)parm;
%}
	::= SEQUENCE
{
	userReason [0] IMPLICIT PrintableString [[s arg->reason.usr_reason]]
	OPTIONAL <<(arg->valid_reason && (arg->reason.type == 0))>>,

	provReason [1] IMPLICIT INTEGER [[i arg->reason.provider_reason]]
	OPTIONAL <<(arg->valid_reason && (arg->reason.type == 1))>>,

	[2] IMPLICIT INTEGER [[i arg->result]],

	[3] IMPLICIT ImplemIdent [[p (PEPYPARM)&(arg->imp_id)]]
	OPTIONAL <<arg->valid_imp>>,

	[4] IMPLICIT BITSTRING
	[[x int2strb (arg->version.bitstring, arg->version.bitcount)
	  $ arg->version.bitcount]],

	[5] IMPLICIT ArgumValueList [[p (PEPYPARM)&(arg->arg_list)]]
	OPTIONAL <<arg->valid_arg_list>>,

	[6] IMPLICIT BITSTRING
	[[x int2strb (arg->func_units.bitstring, arg->func_units.bitcount)
	  $ arg->func_units.bitcount]],

	[7] IMPLICIT INTEGER [[i arg->coll_winner]]
	OPTIONAL <<arg->valid_coll>>
}

ImplemIdent 
%{
	IMPLEM_ID	*arg = (IMPLEM_ID *)parm;
%}
	::= SEQUENCE
{
	impIdent [0] IMPLICIT OBJECT IDENTIFIER
	[[O arg->imp_oid]]
	OPTIONAL <<arg->oid_true>>,

	impName [1] IMPLICIT PrintableString
	[[s arg->name]]
	OPTIONAL <<arg->name_true>>,

	impVersion [2] IMPLICIT PrintableString
	[[s arg->version]]
	OPTIONAL <<arg->version_true>>
}

ArgumValueList 
%{
	ARG_VAL_LIST	*arg = (ARG_VAL_LIST *)parm;
%}
	::= SET OF <<l=0; l<(arg->num_sp_param
			+ (arg->num_cds_objects?1:0)); l++>> Goobers [[p parm]]

Goobers 
%{
	ARG_VAL_LIST	*arg = (ARG_VAL_LIST *)parm;
%}
	::= CHOICE <<(l < arg->num_sp_param) ? 1 : 2>>
{
	[0] IMPLICIT SpecialArgs [[p (PEPYPARM)&(arg->sp_val[l])]],
	vteParams [1] IMPLICIT ParamValueList [[p parm]]
}

SpecialArgs 
%{
	SPECIAL_VALUE	*arg = (SPECIAL_VALUE *)parm;
%}
	::= SEQUENCE
{
	identifier INTEGER [[i arg->param_num]],
	value CHOICE <<arg->param_type + 1>>
	{
		BOOLEAN [[b arg->args.bool_arg]],
		INTEGER [[i arg->args.int_arg]],
		PrintableString[[s arg->args.string_arg]]
	}
}

ParamValueList 
%{
	ARG_VAL_LIST	*arg = (ARG_VAL_LIST *)parm;
%}
	::= SEQUENCE
{
	displayObjects 	[0] IMPLICIT CDSValues [[p parm]]
	OPTIONAL <<arg->num_cds_objects>>,

--	controlObjects	[1] IMPLICIT CSSValues [[p parm]]
--	OPTIONAL <<arg->num_css_objects>>,

--	deviceObjects	[2] IMPLICIT DEVValues [[p parm]]
--	OPTIONAL <<arg->num_dev_objects>>,

	deliveryControl	[3] IMPLICIT INTEGER
	[[i arg->del_ctrl]]
	OPTIONAL <<arg->del_ctrl>>
}

--Note Problem with IMPLICIT SEQUENCE Definition below.  PEPY does not accept
--it as defined in 9041 and in fact that definition is ridiculous.  At the
--moment it is not clear if even hand coding available in ISODE 3.0 can
--produce the requirement of 9041.

CDSValues
%{
	ARG_VAL_LIST	*arg = (ARG_VAL_LIST *)parm;
%}
	::= SET OF <<l=0; l<arg->num_cds_objects; l++>> SEQUENCE
{
	objectName PrintableString
		[[s arg->cds_val[l].obj_name]],

	ObjectOffer [[p (PEPYPARM)&(arg->cds_val[l])]]
}

CSSValues ::= NULL --Unused for now--

DEVValues ::= NULL --Unused for now--

ObjectOffer 
%{
	CDS_VALUE	*arg = (CDS_VALUE *)parm;
%}
	::= SEQUENCE
{
	dimensionValue [0]	IMPLICIT INTEGER
	[[i arg->dimensions]]
	OPTIONAL <<arg->dimensions>>,

	xParamValue [1]		IMPLICIT DimValue [[p 
	(PEPYPARM)&(arg->x_dim)]]
	OPTIONAL <<arg->valid_x_dim>>,

	yParamValue [2]		IMPLICIT DimValue [[p (PEPYPARM)&(arg->y_dim)]]
	OPTIONAL <<arg->valid_y_dim>>,

	zParamValue [3]		IMPLICIT DimValue [[p (PEPYPARM)&(arg->z_dim)]]
	OPTIONAL <<arg->valid_z_dim>>,

--	erasurevalue [4]	IMPLICIT BOOLEAN
--	[[b arg->erasure]]
--	OPTIONAL <<arg->valid_erasure>>,

	repValueList [5]	IMPLICIT CompRepValue [[p (PEPYPARM)&(arg->rep_value)]]
	OPTIONAL <<arg->valid_rep_list>>,

--	empValueList [6]	IMPLICIT CompEmpValue [[p (PEPYPARM)&(arg->emp_value)]]
--	OPTIONAL <<arg->valid_emp_list>>,

--	foreColorVal [7]	IMPLICIT ColorValue [[p (PEPYPARM)&(arg->fore_color_list)]]
--	OPTIONAL <<arg->valid_fore_color>>,

--	backColorVal [8]	IMPLICIT ColorValue [[p (PEPYPARM)&(arg->back_color_list)]]
--	OPTIONAL <<arg->valid_back_color>>,

	objectAccRight [9]	IMPLICIT INTEGER
	[[i arg->access_right]]
	OPTIONAL <<arg->valid_access_right>>
}

DimValue 
%{
	DIMEN_VALUE	*arg = (DIMEN_VALUE *)parm;
%}
	::= SEQUENCE
{
	bound		[0] CHOICE
	<<arg->bound_type>>
	{
		unbounded NULL,

		limit INTEGER
		[[i arg->bound]]
	}
	OPTIONAL <<arg->bound_type>>,

	addressing	[1] IMPLICIT INTEGER
	[[i arg->addressing]]
	OPTIONAL <<arg->valid_addr>>,

	absolute	[2] IMPLICIT INTEGER
	[[i arg->absolute]]
	OPTIONAL <<arg->valid_abs>>,

	window		[3] CHOICE
	<<arg->window_type>>
	{
		unbounded NULL,

		limit INTEGER
		[[i arg->window]]
	}
	OPTIONAL <<arg->window_type>>
}

CompRepValue 
%{
	REP_VALUE	*arg = (REP_VALUE *)parm;
%}
	::= SEQUENCE
{
	repCapability	[0] IMPLICIT INTEGER
	[[i arg->capability]]
	OPTIONAL <<arg->valid_cap>>,

	[1] IMPLICIT SEQUENCE OF <<m=0; m<arg->num_reps; m++>>
		RepFontValue [[p (PEPYPARM)&(arg->repertoire[m])]]
		OPTIONAL <<arg->num_reps>>
}

RepFontValue 
%{ 
	int i; 
	FONT_VALUE	*arg = (FONT_VALUE *)parm;
%} ::= 
CHOICE <<arg->rep_type>>
{
	NULL,

	SEQUENCE
	{
		repertoire	[0] IMPLICIT PrintableString
		[[s arg->rep_assign]]
		OPTIONAL <<arg->rep_assign>>,

		fontCapability	[1] IMPLICIT INTEGER
		[[i arg->capability]]
		OPTIONAL <<arg->valid_font_cap>>,

				[2] IMPLICIT SEQUENCE OF
				<<i=0; i<arg->num_fonts; i++>>
				PrintableString
				[[s arg->font_names[i] ]]
				OPTIONAL <<arg->num_fonts>>
	}
}

--CompEmpValue 
--%{
--	int i;
--	EMP_VALUE	*arg = (EMP_VALUE *)parm;
--%} ::= SEQUENCE
--{
--	empCap		[0] IMPLICIT INTEGER
--			[[i arg->capability]]
--			OPTIONAL <<arg->valid_cap>>,

--			SEQUENCE OF <<i=0; i<arg->num_emps; i++>>
--				PrintableString
--				[[s arg->emp_string[i] ]]
--				OPTIONAL <<arg->num_emps>>
--}

--ColorValue 
--%{
--	int i;
--	COLOR_VALUE	*arg = (COLOR_VALUE *)parm;
--%} ::= SEQUENCE
--{
--	colorCap	[0] IMPLICIT INTEGER
--			[[i arg->capability]]
--			OPTIONAL <<arg->valid_cap>>,

--	colorNames	SEQUENCE OF <<i=0; i<arg->num_colors; i++>>
--				PrintableString
--				[[s arg->color_string[i] ]]
--				OPTIONAL <<arg->num_colors>>
--}

END

%{

#ifdef PEPYTEST

void advise(what,fmt,a,b,c,d,e,f,g,h,i,j)
char *what, *fmt, *a, *b, *c, *d, *e, *f, *g, *h, *i, *j;
{

	(void) fflush(stdout);

	fprintf(stderr,"%s:  ",myname);
	fprintf(stderr,fmt,a,b,c,d,e,f,g,h,i,j);
	if(what)
		(void) fputc(' ',stderr),perror(what);
	else
		(void) fputc('\n',stderr);
	(void)fflush(stderr);
}

testdebug(pe,words)
PE pe;			/*Not Really, but pretend*/
char *words;
{

	printf("%s \n",words);
}

#endif

%}