📄 rvmegaco.syn

📁 h.248协议源码
💻 SYN
📖 第 1 页 / 共 5 页
字号:

(RvMegacoServiceState)
serviceStates
	-> ServiceStatesToken, EQUAL, serviceStateValue:v, LWSP = v;

(RvMegacoServiceState)
serviceStateValue
	-> TestToken = RV_MEGACOSERVICESTATE_TEST;
	-> OutOfSvcToken = RV_MEGACOSERVICESTATE_OUTOFSERVICE;
	-> InSvcToken = RV_MEGACOSERVICESTATE_INSERVICE;

(RvBool)
eventBufferControl
	-> BufferToken, EQUAL, eventBufferControlValue:v, LWSP = v;

(RvBool)
eventBufferControlValue
	-> "OFF" = rvFalse;
	-> LockStepToken = rvTrue;

(RvMegacoMuxDescriptor *)
muxDescriptor
	-> MuxToken, EQUAL, MuxType:m, LWSP, LBRKT, MuxTerminationID, [COMMA, MuxTerminationID]..., RBRKT = m;

(RvMegacoMuxDescriptor *)
MuxType
	-> standardMuxType:type = PCB.curMuxDescriptor = rvMegacoMuxDescriptorConstructA(rvNew(RvMegacoMuxDescriptor)(&PCB), type, PCB.alloc);
	-> extensionParameter:s = 
	{
		PCB.curMuxDescriptor = rvMegacoMuxDescriptorConstructOtherA(rvNew(RvMegacoMuxDescriptor)(&PCB), rvStringGetData(s), PCB.alloc);
		rvDelete(&PCB, s);
		return PCB.curMuxDescriptor;
	}

(RvMegacoMuxType)
standardMuxType
	-> H221Token = RV_MEGACOMUXTYPE_H221;
	-> H223Token = RV_MEGACOMUXTYPE_H223;
	-> H226Token = RV_MEGACOMUXTYPE_H226;
	-> V76Token = RV_MEGACOMUXTYPE_V76;

(void)
MuxTerminationID
	-> TerminationID:x, LWSP =
	{
		rvMegacoMuxDescriptorAddTerminationId(PCB.curMuxDescriptor, x);
		rvDelete(&PCB, x);
	}

(RvMegacoPackageItem *)
pkgdName
	-> NAME:p, SLASH, NAME:i, LWSP =
	{
		RvMegacoPackageItem *x = rvNew(RvMegacoPackageItem)(&PCB);
		rvMegacoPackageItemConstructA(x, rvStringGetData(p), rvStringGetData(i), PCB.alloc);
		rvDelete(&PCB, p);
		rvDelete(&PCB, i);
		return x;
	}
	-> NAME:p, SLASH, '*', LWSP =
	{
		RvMegacoPackageItem *x = rvNew(RvMegacoPackageItem)(&PCB);
		rvMegacoPackageItemConstructA(x, rvStringGetData(p), "*", PCB.alloc);
		rvDelete(&PCB, p);
		return x;
	}
	-> '*', SLASH, '*', LWSP = rvMegacoPackageItemConstructA(rvNew(RvMegacoPackageItem)(&PCB), "*", "*", PCB.alloc);

(RvMegacoEventsDescriptor *)
eventsDescriptor
	-> eventsDescriptorBlank, LBRKT, requestedEvent, [COMMA, requestedEvent]..., RBRKT 

(RvMegacoEventsDescriptor *)
eventsDescriptorBlank
	-> EventsToken, EQUAL, integer:requestId, LWSP =
	{
		return PCB.curEventsDescriptor = rvMegacoEventsDescriptorConstructA(
			rvNew(RvMegacoEventsDescriptor)(&PCB), requestId, PCB.alloc);
	} 

(void)
requestedEvent
	-> requestedEventBlank:e, [LBRKT, eventParameter, [COMMA, eventParameter]..., RBRKT] =
	{
		rvMegacoEventsDescriptorAddEvent(PCB.curEventsDescriptor, e);
		rvDelete(&PCB, e);
	}

(RvMegacoRequestedEvent *)
requestedEventBlank
	-> pkgdName:n =
	{
		RvMegacoRequestedEvent *e = rvNew(RvMegacoRequestedEvent)(&PCB);
		rvMegacoRequestedEventConstructA(e, n, PCB.alloc);
		rvDelete(&PCB, n);
		return PCB.curRequestedEvent = e;		
	}

(void)
eventParameter
	-> KeepActiveToken, LWSP = { rvMegacoRequestedEventSetKeepActiveFlag(PCB.curRequestedEvent, rvTrue); }
	-> eventStream:id = { rvMegacoRequestedEventSetStreamId(PCB.curRequestedEvent, id); }
	-> eventDM:dm =
	{
		rvMegacoRequestedEventSetEmbDigitMap(PCB.curRequestedEvent, dm);
		rvDelete(&PCB, dm);
	}
	-> eventOther:x =
	{
		rvMegacoRequestedEventSetParameter(PCB.curRequestedEvent, rvMegacoPackageItemGetItem(rvMegacoParameterGetName(x)), rvMegacoParameterGetValue(x));
		rvDelete(&PCB, x);
	}
	-> EmbedToken, LWSP, LBRKT, signalsDescriptor:s, RBRKT =
	{
		rvMegacoRequestedEventSetEmbSignals(PCB.curRequestedEvent, s);
		rvDelete(&PCB, s);
	}
	-> EmbedToken, LWSP, LBRKT, embedFirst:ev, RBRKT =
	{
		rvMegacoRequestedEventSetEmbEvents(PCB.curRequestedEvent, ev);
		rvDelete(&PCB, ev);
	}
	-> EmbedToken, LWSP, LBRKT, signalsDescriptor:s, COMMA, embedFirst:ev, RBRKT =
	{
		rvMegacoRequestedEventSetEmbSignals(PCB.curRequestedEvent, s);
		rvMegacoRequestedEventSetEmbEvents(PCB.curRequestedEvent, ev);
		rvDelete(&PCB, s);
		rvDelete(&PCB, ev);
	}


(RvMegacoEventsDescriptor *)
embedFirst
	-> embedFirstBlank:x, LBRKT, secondRequestedEvent, [COMMA, secondRequestedEvent]..., RBRKT = x;

(RvMegacoEventsDescriptor *)
embedFirstBlank
	-> EventsToken, EQUAL, integer:requestId, LWSP =
	{
		return PCB.curEmbedEventsDescriptor = rvMegacoEventsDescriptorConstructA(
			rvNew(RvMegacoEventsDescriptor)(&PCB), requestId, PCB.alloc);
	}

(void)
secondRequestedEvent
	-> secondRequestedEventBlank:e, [LBRKT, secondEventParameter, [COMMA, secondEventParameter]..., RBRKT] =
	{
		rvMegacoEventsDescriptorAddEvent(PCB.curEmbedEventsDescriptor, e);
		rvDelete(&PCB, e);
	}

(RvMegacoRequestedEvent *)
secondRequestedEventBlank
	-> pkgdName:n = 
	{
		RvMegacoRequestedEvent *e = rvNew(RvMegacoRequestedEvent)(&PCB);
		rvMegacoRequestedEventConstructA(e, n, PCB.alloc);
		rvDelete(&PCB, n);
		return PCB.curEmbEvent = e;
	}

(void)
secondEventParameter
	-> KeepActiveToken, LWSP = { rvMegacoRequestedEventSetKeepActiveFlag(PCB.curEmbEvent, rvTrue); }
	-> eventStream:id = { rvMegacoRequestedEventSetStreamId(PCB.curEmbEvent, id); }
	-> embedSig:s =
	{
		rvMegacoRequestedEventSetEmbSignals(PCB.curEmbEvent, s);
		rvDelete(&PCB, s);
	}
	-> eventDM:dm =
	{
		rvMegacoRequestedEventSetEmbDigitMap(PCB.curEmbEvent, dm);
		rvDelete(&PCB, dm);
	}
	-> eventOther:x =
	{
		rvMegacoRequestedEventSetParameter(PCB.curEmbEvent, rvMegacoPackageItemGetItem(rvMegacoParameterGetName(x)), rvMegacoParameterGetValue(x));
		rvDelete(&PCB, x);
	}

(RvMegacoSignalsDescriptor *)
embedSig
	-> EmbedToken, LWSP, LBRKT, signalsDescriptor:s, RBRKT = s;

(unsigned int)
eventStream
	-> StreamToken, EQUAL, shortInteger:id, LWSP = id;

(RvMegacoParameter *)
eventOther
	-> NAME:n, LWSP, parmValue:v =
	{
		RvMegacoParameter *p = rvNew(RvMegacoParameter)(&PCB);
		RvMegacoPackageItem item;
		rvMegacoPackageItemConstructA(&item, "", rvStringGetData(n), PCB.alloc);
		rvMegacoParameterConstructA(p, &item, v, PCB.alloc);
		rvMegacoPackageItemDestruct(&item);
		rvDelete(&PCB, n);
		rvDelete(&PCB, v);
		return p;
	}

(RvMegacoDigitMapDescriptor *)
eventDM
	-> DigitMapToken, EQUAL, NAME:n, LWSP =
	{
		RvMegacoDigitMapDescriptor *dm = rvNew(RvMegacoDigitMapDescriptor)(&PCB);
		RvMegacoDigitMap v;
		rvMegacoDigitMapConstructA(&v, PCB.alloc);
		rvMegacoDigitMapDescriptorConstructA(dm, rvStringGetData(n), &v, PCB.alloc);
		rvMegacoDigitMapDestruct(&v);
		rvDelete(&PCB, n);
		return dm;
	}
	-> DigitMapToken, LWSP, LBRKT, digitMapValue:v, RBRKT =
	{
		RvMegacoDigitMapDescriptor *dm = rvNew(RvMegacoDigitMapDescriptor)(&PCB);
		rvMegacoDigitMapDescriptorConstructA(dm, "", v, PCB.alloc);
		rvDelete(&PCB, v);
		return dm;
	}

(RvMegacoSignalsDescriptor *)
signalsDescriptor
	-> signalsDescriptorBlank:s, LBRKT, [signalParm, [COMMA, signalParm]...], RBRKT = s;

(RvMegacoSignalsDescriptor *)
signalsDescriptorBlank
	-> SignalsToken, LWSP =
	{
		return PCB.curSignalsDescriptor = rvMegacoSignalsDescriptorConstructA(
			rvNew(RvMegacoSignalsDescriptor)(&PCB), PCB.alloc);
	}

(void)
signalParm
	-> signalList:x = 
	{
		rvMegacoSignalsDescriptorAddSignalList(PCB.curSignalsDescriptor, x);
		rvDelete(&PCB, x);
	}
	-> signalRequest:x =
	{
		rvMegacoSignalsDescriptorAddSignal(PCB.curSignalsDescriptor, x);
		rvDelete(&PCB, x);
	}

(RvMegacoSignalList *)
signalList
	-> signalListBlank:x, LBRKT, signalListElement, [COMMA, signalListElement]..., RBRKT = x;

(RvMegacoSignalList *)
signalListBlank
	-> SignalListToken, EQUAL, shortInteger:id, LWSP =
	{
		return PCB.curSignalList = rvMegacoSignalListConstructA(
			rvNew(RvMegacoSignalList)(&PCB), id, PCB.alloc);
	}

(void)
signalListElement
	-> signalRequest:x = 
	{
		rvMegacoSignalListAdd(PCB.curSignalList, x);
		rvDelete(&PCB, x);
	}

(RvMegacoSignal *)
signalRequest
	-> signalRequestBlank:s, [LBRKT, signalParameter, [COMMA, signalParameter]..., RBRKT] = s;

(RvMegacoSignal *)
signalRequestBlank
	-> pkgdName:n =
	{
		RvMegacoSignal *s = rvNew(RvMegacoSignal)(&PCB);
		rvMegacoSignalConstructA(s, n, PCB.alloc);
		rvDelete(&PCB, n);
		return PCB.curSignal = s;
	}

(void)
signalParameter
	-> sigStream:s = { rvMegacoSignalSetStreamId(PCB.curSignal, s); }
	-> sigSignalType:type = { rvMegacoSignalSetType(PCB.curSignal, type); }
	-> sigDuration:d = { rvMegacoSignalSetDuration(PCB.curSignal, d); }
	-> notifyCompletion:r = { rvMegacoSignalSetNotifyReasons(PCB.curSignal, r); }
	-> KeepActiveToken, LWSP = { rvMegacoSignalSetKeepActiveFlag(PCB.curSignal, rvTrue); }
	-> sigOther

(unsigned int)
sigStream
	-> StreamToken, EQUAL, shortInteger:id, LWSP = id;

(RvMegacoSignalType)
sigSignalType
	-> SignalTypeToken, EQUAL, signalType:type, LWSP = type;

(RvMegacoSignalType)
signalType
	-> OnOffToken = RV_MEGACOSIGNAL_ONOFF;
	-> TimeOutToken = RV_MEGACOSIGNAL_TIMEOUT;
	-> BriefToken = RV_MEGACOSIGNAL_BRIEF;

(unsigned int)
sigDuration
	-> DurationToken, EQUAL, shortInteger:i, LWSP = i;

(void)
sigOther
	-> NAME:n, LWSP, parmValue:v =
	{
		rvMegacoSignalSetParameter(PCB.curSignal, rvStringGetData(n), v);
		rvDelete(&PCB, n);
		rvDelete(&PCB, v);
	}

(RvMegacoSignalNotificationReasons)
notifyCompletion
	-> NotifyCompletionToken, EQUAL, LBRKT, notificationReasons:x, RBRKT = x;

(RvMegacoSignalNotificationReasons)
notificationReasons
	-> notificationReason:r, LWSP = r;
	-> notificationReasons:x, COMMA, notificationReason:r, LWSP = x | r;

(RvMegacoSignalNotificationReasons)
notificationReason
	-> TimeOutToken = RV_MEGACOSIGNAL_COMPLETED;
	-> InterruptByEventToken = RV_MEGACOSIGNAL_GOTEVENT;
	-> InterruptByNewSignalsDescrToken = RV_MEGACOSIGNAL_NEWSIGDESCR;
	-> OtherReasonToken = RV_MEGACOSIGNAL_OTHERREASON;

(RvMegacoObservedEventsDescriptor *)
observedEventsDescriptor
	-> observedEventsDescriptorBlank:x, LBRKT, observedEvent, [COMMA, observedEvent]..., RBRKT = x;

(RvMegacoObservedEventsDescriptor *)
observedEventsDescriptorBlank
	-> ObservedEventsToken, EQUAL, integer:requestId, LWSP = 
	{
		return PCB.curObservedEventsDescriptor = rvMegacoObservedEventsDescriptorConstructA(
			rvNew(RvMegacoObservedEventsDescriptor)(&PCB), requestId, PCB.alloc);
	}

(void)
observedEvent
	-> observedEventBlank:e, [LBRKT, observedEventParameter, [COMMA, observedEventParameter]..., RBRKT] =
	{
		rvMegacoObservedEventsDescriptorAddEvent(PCB.curObservedEventsDescriptor, e);
		rvDelete(&PCB, e);
	}

(RvMegacoObservedEvent *)
observedEventBlank
	-> observedEventTimeStamp:ts, pkgdName:n = 
	{
		RvMegacoObservedEvent *e = rvNew(RvMegacoObservedEvent)(&PCB);
		rvMegacoObservedEventConstructA(e, n, ts, PCB.alloc);
		rvDelete(&PCB, n);
		rvDelete(&PCB, ts);
		return PCB.curObservedEvent = e;
	}

(RvTimeStamp *)
observedEventTimeStamp
	-> = rvTimeStampConstructBlank(rvNew(RvTimeStamp)(&PCB));
	-> TimeStamp:ts, COLON, LWSP = ts;

(void)
observedEventParameter
	-> eventStream:s = { rvMegacoObservedEventSetStreamId(PCB.curObservedEvent, s); }
	-> eventOther:p = 
	{
		rvMegacoObservedEventSetParameter(PCB.curObservedEvent, rvMegacoPackageItemGetItem(rvMegacoParameterGetName(p)), rvMegacoParameterGetValue(p));
		rvDelete(&PCB, p);
	}

(RvMegacoModemDescriptor *)
modemDescriptor
	-> modemDescriptorBlank:p, 
		{'=', LWSP, modemType, LWSP | LSBRKT, modemType, LWSP, [COMMA, modemType, LWSP]..., RSBRKT},
		[LBRKT, modemParameter, [COMMA, modemParameter]..., RBRKT] = p;

(RvMegacoModemDescriptor *)
modemDescriptorBlank
	-> ModemToken, LWSP = PCB.curModem = rvMegacoModemDescriptorConstructA(rvNew(RvMegacoModemDescriptor)(&PCB), PCB.alloc);

// at-most-once
(void)
modemType
	-> V32bisToken = { rvMegacoModemDescriptorAddType(PCB.curModem, RV_MEGACOMODEMTYPE_V32BIS); }
	-> V22bisToken = { rvMegacoModemDescriptorAddType(PCB.curModem, RV_MEGACOMODEMTYPE_V22BIS); }
	-> V18Token = { rvMegacoModemDescriptorAddType(PCB.curModem, RV_MEGACOMODEMTYPE_V18); }
	-> V22Token = { rvMegacoModemDescriptorAddType(PCB.curModem, RV_MEGACOMODEMTYPE_V22); }
	-> V32Token = { rvMegacoModemDescriptorAddType(PCB.curModem, RV_MEGACOMODEMTYPE_V32); }
	-> V34Token = { rvMegacoModemDescriptorAddType(PCB.curModem, RV_MEGACOMODEMTYPE_V34); }
	-> V90Token = { rvMegacoModemDescriptorAddType(PCB.curModem, RV_MEGACOMODEMTYPE_V90); }
	-> V91Token = { rvMegacoModemDescriptorAddType(PCB.curModem, RV_MEGACOMODEMTYPE_V91); }
	-> SynchISDNToken = { rvMegacoModemDescriptorAddType(PCB.curModem, RV_MEGACOMODEMTYPE_SYNCHISDN); }
	-> extensionParameter:x = 
	{
		rvMegacoModemDescriptorAddOtherType(PCB.curModem, rvStringGetData(x)); 
		rvDelete(&PCB, x);
	}

(void)
modemParameter
	-> NAME:n, LWSP, parmValue:v =
	{
		rvMegacoModemDescriptorSetParameter(PCB.curModem, rvStringGetData(n), v);
		rvDelete(&PCB, n);
		rvDelete(&PCB, v);
	}

(RvMegacoDigitMapDescriptor *)
digitMapDescriptor
	-> DigitMapToken, EQUAL, NAME:n, LWSP, LBRKT, digitMapValue:v, RBRKT =
	{
		RvMegacoDigitMapDescriptor *dm = rvNew(RvMegacoDigitMapDescriptor)(&PCB);
		rvMegacoDigitMapDescriptorConstructA(dm, rvStringGetData(n), v, PCB.alloc);
		rvDelete(&PCB, n);
		rvDelete(&PCB, v);
		return dm;
	}
	-> DigitMapToken, EQUAL, NAME:n, LWSP =
	{
		RvMegacoDigitMapDescriptor *dm = rvNew(RvMegacoDigitMapDescriptor)(&PCB);
		RvMegacoDigitMap v;
		rvMegacoDigitMapConstructA(&v, PCB.alloc);
		rvMegacoDigitMapDescriptorConstructA(dm, rvStringGetData(n), &v, PCB.alloc);
		rvMegacoDigitMapDestruct(&v);
		rvDelete(&PCB, n);
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -