![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rcv_asr.py CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / vt|
Return to rcv_asr.py CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / vt |
1.1 root 1: -- VTPM: decode ASR PDU
2:
3: -- $Header: /f/osi/vt/RCS/rcv_asr.py,v 7.0 89/11/23 22:31:36 mrose Rel $
4: --
5: --
6: -- $Log: rcv_asr.py,v $
7: -- Revision 7.0 89/11/23 22:31:36 mrose
8: -- Release 6.0
9: --
10:
11: --
12: -- NOTICE
13: --
14: -- Acquisition, use, and distribution of this module and related
15: -- materials are subject to the restrictions of a license agreement.
16: -- Consult the Preface in the User's Manual for the full terms of
17: -- this agreement.
18: --
19: --
20:
21:
22: ASRPDU DEFINITIONS ::=
23:
24: %{
25: #include <stdio.h>
26: #include "sector1.h"
27:
28: #undef PEPYPARM
29: #define PEPYPARM int *
30:
31: #undef PEPYTEST
32:
33: static int l,m,n,q;
34:
35: #ifdef PEPYTEST
36:
37: ASR_MSG udr;
38:
39: rcv_asr(pe)
40: PE pe;
41: {
42:
43: int i;
44:
45: if(unbuild_ASRPDU_ASRpdu(pe,1,NULLIP,NULLVP,&udr) == NOTOK)
46: {
47: (void)printf("Can't unbuild ASR PDU\n");
48: return;
49: }
50:
51: (void)printf("Result = %d\n",udr.result);
52: (void)printf("Version.bitcount = %d; Version = %x\n",
53: udr.version.bitcount,udr.version.bitstring);
54: (void)printf("F.U. bitcount = %d; F.U. = %x\n",
55: udr.func_units.bitcount,udr.func_units.bitstring);
56: if(udr.valid_coll)
57: (void)printf("valid_coll = %d; coll_winner = %d\n",
58: udr.valid_coll,udr.coll_winner);
59: (void)printf("Valid_reason = %d\n",udr.valid_reason);
60: (void)printf("Sp Obj = %d CDS Obj = %d CSS Obj = %d DEV Obj = %d\n",
61: udr.arg_list.num_sp_param,udr.arg_list.num_cds_objects,
62: udr.arg_list.num_css_objects,udr.arg_list.num_dev_objects);
63:
64: for(l=0; l<udr.arg_list.num_sp_param; l++)
65: {
66: (void)printf("\n");
67: (void)printf("Special Num = %d Special Type = %d",
68: udr.arg_list.sp_val[l].param_num,
69: udr.arg_list.sp_val[l].param_type);
70: if(udr.arg_list.sp_val[l].param_type == 0)
71: {
72: (void)printf("Boolean Type = %d\n",
73: udr.arg_list.sp_val[l].args.bool_arg);
74: }
75: else if(udr.arg_list.sp_val[l].param_type == 1)
76: {
77: (void)printf("Integer Type = %d\n",
78: udr.arg_list.sp_val[l].args.int_arg);
79: }
80: else
81: (void)printf("Bad Special Param Type\n");
82: }
83:
84: for(l=0;l<udr.arg_list.num_cds_objects; l++)
85: {
86: (void)printf("\n\nObject Name = %s\n",udr.arg_list.cds_val[l].obj_name);
87: (void)printf("Valid:\n");
88: (void)printf("\tdimen(%d) x_dim(%d) y_dim(%d) z_dim(%d)\n",
89: udr.arg_list.cds_val[l].dimensions,
90: udr.arg_list.cds_val[l].valid_x_dim,
91: udr.arg_list.cds_val[l].valid_y_dim,
92: udr.arg_list.cds_val[l].valid_z_dim);
93: (void)printf("\terase(%d) repertoire(%d) emph(%d) fore(%d)\n",
94: udr.arg_list.cds_val[l].valid_erasure,
95: udr.arg_list.cds_val[l].valid_rep_list,
96: udr.arg_list.cds_val[l].valid_emp_list,
97: udr.arg_list.cds_val[l].valid_fore_color);
98: (void)printf("\tback(%d) access right(%d)\n",
99: udr.arg_list.cds_val[l].valid_back_color,
100: udr.arg_list.cds_val[l].valid_access_right);
101: (void)printf("X Dimension:\n");
102: (void)printf("\tBound(%d) addressing(%d) absolute(%d) window(%d)\n",
103: udr.arg_list.cds_val[l].x_dim.bound_type,
104: udr.arg_list.cds_val[l].x_dim.valid_addr,
105: udr.arg_list.cds_val[l].x_dim.valid_abs,
106: udr.arg_list.cds_val[l].x_dim.window_type);
107: (void)printf("\twindow size = %d\n",udr.arg_list.cds_val[l].x_dim.window);
108: (void)printf("Repertoires: (Number = %d)\n",
109: udr.arg_list.cds_val[l].rep_value.num_reps);
110: for(i=0;i<udr.arg_list.cds_val[l].rep_value.num_reps;i++)
111: {
112: (void)printf("\ttype(%d) rep(%s) capability(%d) fonts(%d)\n",
113: udr.arg_list.cds_val[l].rep_value.repertoire[i].rep_type,
114: udr.arg_list.cds_val[l].rep_value.repertoire[i].rep_assign,
115: udr.arg_list.cds_val[l].rep_value.repertoire[i].valid_font_cap,
116: udr.arg_list.cds_val[l].rep_value.repertoire[i].num_fonts);
117: }
118: }
119:
120: }
121:
122: #endif
123:
124:
125: #define bitstr2int(arg,val,cnt) \
126: { \
127: char *cp; \
128: \
129: cp = bitstr2strb (arg, &cnt); \
130: val = strb2int (cp, cnt); \
131: free (cp); \
132: }
133:
134: %}
135:
136: BEGIN
137:
138: SECTIONS none unbuild none
139:
140: ASRpdu ::= CHOICE
141:
142: {
143: asrpdu [1] IMPLICIT ASRcontent [[p (PEPYPARM)parm]]
144: }
145:
146: ASRcontent
147: %{
148: ASR_MSG *arg = (ASR_MSG *)parm;
149: %}
150: ::= SEQUENCE
151: %{
152: arg->valid_reason = 0;
153: arg->valid_imp = 0;
154: arg->valid_coll = 0;
155: arg->version.bitcount = 0;
156: arg->func_units.bitcount = 0;
157: arg->arg_list.num_sp_param = 0;
158: %}
159: {
160:
161: userReason [0] IMPLICIT PrintableString [[s arg->reason.usr_reason]]
162: %{arg->reason.type = 0;
163: arg->valid_reason = 1;%}
164: OPTIONAL,
165:
166: provReason [1] IMPLICIT INTEGER [[i arg->reason.provider_reason]]
167: %{arg->reason.type = 1;
168: arg->valid_reason = 1;%}
169: OPTIONAL,
170:
171: [2] IMPLICIT INTEGER [[i arg->result]],
172:
173: [3] IMPLICIT ImplemIdent [[p (PEPYPARM)&(arg->imp_id)]]
174: %{arg->valid_imp = 1;%}
175: OPTIONAL,
176:
177: [4] IMPLICIT BITSTRING
178: %{ bitstr2int ($$, arg->version.bitstring, arg->version.bitcount); %},
179:
180: [5] IMPLICIT ArgumValueList [[p (PEPYPARM)&(arg->arg_list)]],
181:
182: [6] IMPLICIT BITSTRING
183: %{ bitstr2int ($$, arg->func_units.bitstring, arg->func_units.bitcount) ;%},
184:
185: [7] IMPLICIT INTEGER [[i arg->coll_winner]]
186: %{arg->valid_coll = 1;%}
187: OPTIONAL
188: }
189:
190: ImplemIdent
191: %{
192: IMPLEM_ID *arg = (IMPLEM_ID *)parm;
193: %}
194: ::= SEQUENCE
195: %{
196: arg->oid_true = 0;
197: arg->name_true = 0;
198: arg->version_true = 0;
199: %}
200: {
201: impIdent [0] IMPLICIT OBJECT IDENTIFIER
202: [[O arg->imp_oid]]
203: %{arg->oid_true = 1;%},
204:
205: impName [1] IMPLICIT PrintableString
206: [[s arg->name]]
207: %{arg->name_true = 1;%},
208:
209: impVersion [2] IMPLICIT PrintableString
210: [[s arg->version]]
211: %{arg->version_true = 1;%}
212: }
213:
214: ArgumValueList
215: %{
216: ARG_VAL_LIST *arg = (ARG_VAL_LIST *)parm;
217: %}
218: ::= SET OF %{q = arg->num_sp_param;%} Squat [[p parm]]
219:
220:
221: Squat ::= CHOICE
222: {
223: specArgs [0] IMPLICIT SpecialArgs [[p parm]],
224: vteParams [1] IMPLICIT ParamValueList [[p parm]]
225: }
226:
227: SpecialArgs
228: %{
229: ARG_VAL_LIST *arg = (ARG_VAL_LIST *)parm;
230: %}
231: ::= SEQUENCE
232: {
233: identifier INTEGER [[i arg->sp_val[q].param_num]],
234: value CHOICE
235: {
236: BOOLEAN [[b arg->sp_val[q].args.bool_arg]]
237: %{arg->sp_val[q].param_type = 0;%},
238: INTEGER [[i arg->sp_val[q].args.int_arg]]
239: %{arg->sp_val[q].param_type = 1;%},
240: PrintableString[[s arg->sp_val[q].args.string_arg]]
241: %{arg->sp_val[q].param_type = 2;%}
242: }
243:
244: %{++arg->num_sp_param;
245: if(arg->num_sp_param >= MAXSPARGS) return(OK);
246: %}
247: }
248:
249: ParamValueList
250: %{
251: ARG_VAL_LIST *arg = (ARG_VAL_LIST *)parm;
252: %}
253: ::= SEQUENCE
254: %{
255: /* arg->num_cds_objects = 0;*/
256: %}
257: {
258: displayObjects [0] IMPLICIT CDSValues [[p parm]]
259: OPTIONAL,
260:
261: -- controlObjects [1] IMPLICIT CSSValues [[p parm]]
262: -- OPTIONAL,
263:
264: -- deviceObjects [2] IMPLICIT DEVValues [[p parm]]
265: -- OPTIONAL,
266:
267: deliveryControl [3] IMPLICIT INTEGER
268: [[i arg->del_ctrl]]
269: OPTIONAL
270: }
271:
272: --Note Problem with IMPLICIT SEQUENCE Definition below. PEPY does not accept
273: --it as defined in 9041 and in fact that definition is ridiculous. At the
274: --moment it is not clear if even hand coding available in ISODE 3.0 can
275: --produce the requirement of 9041.
276:
277: CDSValues
278: %{
279: ARG_VAL_LIST *arg = (ARG_VAL_LIST *)parm;
280: %}
281: ::=
282: SET OF %{l = arg->num_cds_objects;%} SEQUENCE
283: {
284: objectName PrintableString
285: [[s arg->cds_val[l].obj_name]],
286:
287: ObjectOffer [[p (PEPYPARM)&(arg->cds_val[l])]]
288: %{ ++arg->num_cds_objects;
289: if(arg->num_cds_objects >= MAXCDSOBJ) return(OK);
290: %}
291: }
292:
293: CSSValues ::= NULL --Unused for now--
294:
295: DEVValues ::= NULL --Unused for now--
296:
297: ObjectOffer
298: %{
299: CDS_VALUE *arg = (CDS_VALUE *)parm;
300: %}
301: ::= SEQUENCE
302: %{
303: arg->dimensions = 0;
304: arg->valid_x_dim = 0;
305: arg->valid_y_dim = 0;
306: arg->valid_z_dim = 0;
307: arg->valid_erasure = 0;
308: arg->valid_rep_list = 0;
309: arg->valid_emp_list = 0;
310: arg->valid_fore_color = 0;
311: arg->valid_back_color = 0;
312: arg->valid_access_right = 0;
313: %}
314: {
315: dimensionValue [0] IMPLICIT INTEGER
316: [[i arg->dimensions]]
317: OPTIONAL,
318:
319: xParamValue [1] IMPLICIT DimValue [[p (PEPYPARM)&(arg->x_dim)]]
320: %{arg->valid_x_dim = 1;%}
321: OPTIONAL,
322:
323: yParamValue [2] IMPLICIT DimValue [[p (PEPYPARM)&(arg->y_dim)]]
324: %{arg->valid_y_dim = 1;%}
325: OPTIONAL,
326:
327: zParamValue [3] IMPLICIT DimValue [[p (PEPYPARM)&(arg->z_dim)]]
328: %{arg->valid_z_dim = 1;%}
329: OPTIONAL,
330:
331: -- erasurevalue [4] IMPLICIT BOOLEAN
332: -- [[b arg->erasure]]
333: -- %{arg->valid_erasure = 1;%}
334: -- OPTIONAL,
335:
336: repValueList [5] IMPLICIT CompRepValue [[p (PEPYPARM)&(arg->rep_value)]]
337: %{arg->valid_rep_list = 1;%}
338: OPTIONAL,
339:
340: -- empValueList [6] IMPLICIT CompEmpValue [[p (PEPYPARM)&(arg->emp_value)]]
341: -- %{arg->valid_emp_list = 1;%}
342: -- OPTIONAL,
343:
344: -- foreColorVal [7] IMPLICIT ColorValue [[p (PEPYPARM)&(arg->fore_color_list)]]
345: -- %{arg->valid_fore_color = 1;%}
346: -- OPTIONAL,
347:
348: -- backColorVal [8] IMPLICIT ColorValue [[p (PEPYPARM)&(arg->back_color_list)]]
349: -- %{arg->valid_back_color = 1;%}
350: -- OPTIONAL,
351:
352: objectAccRight [9] IMPLICIT INTEGER
353: [[i arg->access_right]]
354: %{arg->valid_access_right = 1;%}
355: OPTIONAL
356: }
357:
358: DimValue
359: %{
360: DIMEN_VALUE *arg = (DIMEN_VALUE *)parm;
361: %}
362: ::= SEQUENCE
363: %{
364: arg->bound_type = 0;
365: arg->valid_addr = 0;
366: arg->valid_abs = 0;
367: arg->window_type = 0;
368: %}
369: {
370: bound [0] CHOICE
371: {
372: unbounded NULL
373: %{arg->bound_type = 1;%},
374:
375: limit INTEGER
376: [[i arg->bound]]
377: %{arg->bound_type = 2;%}
378: }
379: OPTIONAL,
380:
381: addressing [1] IMPLICIT INTEGER
382: [[i arg->addressing]]
383: OPTIONAL,
384:
385: absolute [2] IMPLICIT INTEGER
386: [[i arg->absolute]]
387: OPTIONAL,
388:
389: window [3] CHOICE
390: {
391: unbounded NULL
392: %{arg->window_type = 1;%},
393:
394: limit INTEGER
395: [[i arg->window]]
396: %{arg->window_type = 2;%}
397: }
398: OPTIONAL
399: }
400:
401: CompRepValue
402: %{
403: REP_VALUE *arg = (REP_VALUE *)parm;
404: %}
405: ::= SEQUENCE
406: %{
407: arg->valid_cap = 0;
408: arg->num_reps = 0;
409: %}
410: {
411: repCapability [0] IMPLICIT INTEGER
412: [[i arg->capability]]
413: %{arg->valid_cap = 1;%}
414: OPTIONAL,
415: [1] IMPLICIT SEQUENCE OF
416: %{m = arg->num_reps;%}
417: RepFontValue [[p (PEPYPARM)&(arg->repertoire[m])]]
418: %{++arg->num_reps;
419: if(arg->num_reps >= MAXREPS) return(OK);
420: %}
421: OPTIONAL
422: }
423:
424: RepFontValue
425: %{
426: FONT_VALUE *arg = (FONT_VALUE *)parm;
427: %}
428: ::=
429: CHOICE
430: %{
431: arg->valid_font_cap = 0;
432: arg->num_fonts = 0;
433: arg->rep_assign = 0;
434: %}
435: {
436: NULL
437: %{arg->rep_type = 1;%},
438:
439: SEQUENCE
440: {
441: repertoire [0] IMPLICIT PrintableString
442: [[s arg->rep_assign]]
443: OPTIONAL,
444:
445: fontCapability [1] IMPLICIT INTEGER
446: [[i arg->capability]]
447: %{++arg->valid_font_cap;%}
448: OPTIONAL,
449:
450: [2] IMPLICIT SEQUENCE OF
451: %{n = arg->num_fonts;%}
452: PrintableString
453: [[s arg->font_names[n] ]]
454: %{
455: ++arg->num_fonts;
456: if(arg->num_fonts >= MAXFONTS) return(OK);
457: %}
458: OPTIONAL
459: }
460: }
461:
462: --CompEmpValue
463: --%{
464: -- EMP_VALUE *arg = (EMP_VALUE *)parm;
465: --%}
466: -- ::= SEQUENCE
467: --%{arg->valid_cap = 0;
468: -- arg->num_emps = 0;
469: --%}
470: --{
471: -- empCap [0] IMPLICIT INTEGER
472: -- [[i arg->capability]]
473: -- %{arg->valid_cap = 1;%}
474: -- OPTIONAL,
475:
476: -- SEQUENCE OF %{m = arg->num_emps;%}
477: -- PrintableString
478: -- [[s arg->emp_string[m] ]]
479: -- %{++arg->num_emps;
480: -- if(arg->num_emps >= MAXEMPS) return(OK);
481: -- %}
482: -- OPTIONAL
483: --}
484:
485: --ColorValue
486: --%{
487: -- COLOR_VALUE *arg = (COLOR_VALUE *)parm;
488: --%}
489: -- ::= SEQUENCE
490: --%{
491: -- arg->valid_cap = 0;
492: -- arg->num_colors = 0;
493: --%}
494: --{
495: -- colorCap [0] IMPLICIT INTEGER
496: -- [[i arg->capability]]
497: -- %{arg->valid_cap = 1;%}
498: -- OPTIONAL,
499:
500: -- colorNames SEQUENCE OF %{m = arg->num_colors;%}
501: -- PrintableString
502: -- [[s arg->color_string[m] ]]
503: -- %{++arg->num_colors;
504: -- if(arg->num_colors >= MAXCOLORS) return(OK);
505: -- %}
506: --}
507:
508: END
509:
510: %{
511:
512:
513: %}
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.