rvmegaco.syn

h.248协议源码

	-> domainAddress:addr, optionalPortNumber:port = 
	{
		RvMegacoEntityAddress *x = rvNew(RvMegacoEntityAddress)(&PCB);
		rvMegacoEntityAddressConstructA(x, rvStringGetData(addr), (RvInetPort)port, PCB.alloc);
		rvDelete(&PCB, addr);
		return x;
	}
	-> domainName:addr, optionalPortNumber:port =
	{
		RvMegacoEntityAddress *x = rvNew(RvMegacoEntityAddress)(&PCB);
		rvMegacoEntityAddressConstructA(x, rvStringGetData(addr), (RvInetPort)port, PCB.alloc);
		rvDelete(&PCB, addr);
		return x;
	}
	-> mtpAddress:mtp =
	{
		RvMegacoEntityAddress *x = rvNew(RvMegacoEntityAddress)(&PCB);
		rvMegacoEntityAddressConstructMtpA(x, rvStringGetData(mtp), PCB.alloc);
		rvDelete(&PCB, mtp);
		return x;
	}
	-> pathNAME:deviceName =
	{
		RvMegacoEntityAddress *x = rvNew(RvMegacoEntityAddress)(&PCB);
		rvMegacoEntityAddressConstructDeviceA(x, rvStringGetData(deviceName), PCB.alloc);
		rvDelete(&PCB, deviceName);
		return x;
	}

(unsigned int)
optionalPortNumber
	-> = 0;
	-> ':', shortInteger:port = port;

// ABNF allows two or more consecutive "." although it is meaningless in a domain name.
// max 64 characters between angle brackets
(RvString *)
domainName
	-> '<', domainNameMeat:name, '>' = name;

// underscores are not legal, but we will allow them in order to support WINS
(RvString *)
domainNameMeat
	-> ALPHA + DIGIT:c = rvStringPushBack(rvStringConstructAndReserve(rvNew(RvString)(&PCB), rvStringReserveSize, PCB.alloc), (char)c); 
	-> domainNameMeat:s, ALPHA + DIGIT + '_' + '-' + '.':c = rvStringPushBack(s, (char)c);


(RvMegacoContextId *)
ContextID
	-> integer:i = rvMegacoContextIdConstruct(rvNew(RvMegacoContextId)(&PCB), i);
	-> '*' = rvMegacoContextIdConstructSpecial(rvNew(RvMegacoContextId)(&PCB), RV_MEGACOCONTEXTID_ALL);
	-> '-' = rvMegacoContextIdConstructSpecial(rvNew(RvMegacoContextId)(&PCB), RV_MEGACOCONTEXTID_NULL);
	-> '$' = rvMegacoContextIdConstructSpecial(rvNew(RvMegacoContextId)(&PCB), RV_MEGACOCONTEXTID_CHOOSE);


(RvString *)
domainAddress
	-> domainAddressStart:start, {IPv4address | IPv6address}, domainAddressEnd:end =
	{
		RvString *x = rvNew(RvString)(&PCB);
		rvStringConstructN(x, start, end - start, PCB.alloc);
		return x;
	}

(const char *)
domainAddressStart
	-> '[' = PCB.pointer;

(const char *)
domainAddressEnd
	-> ']' = PCB.pointer - 1;

(void)
IPv4address
	-> integer:b3, DOT, integer:b2, DOT, integer:b1, DOT, integer:b0 =
{
	if(b3 > 255 || b2 > 255 || b1 > 255 || b0 > 255)
	{
		PCB.exit_flag = AG_SEMANTIC_ERROR_CODE;
		PCB.error_message = "Bad IP address";
	}
}

(void)
IPv6address
	-> "::"
	-> "::", hexseq
	-> "::", IPv4address
	-> "::", hexseq, ':', IPv4address
	-> hexseq
	-> hexseq, "::"
	-> hexseq, "::", hexseq
	-> hexseq, "::", IPv4address
	-> hexseq, "::", hexseq, ':', IPv4address
	-> hexseq, ':', IPv4address

(void)
hexseq
	-> hex integer
	-> hexseq, ':', hex integer

(void)
hex integer
	-> integer
	-> integer, hex section
	-> hex section

(void)
hex section
	-> HEXLET, HEXDIG...

// An mtp address is two octets long
(RvString *)
mtpAddress
	-> MTPToken, LWSP, '{', octetString:s, '}' = s;


// Total length of pathNAME must not exceed 64 characters
(RvString *)
pathNAME
	-> pathNAME_X1:p = p;
	-> '*', pathNAME_X1:p =
	{
		RvString *s = rvNew(RvString)(&PCB);
		rvStringConstruct(s, "*", PCB.alloc);
		rvStringConcatenateString(s, p);
		rvDelete(&PCB, p);
		return s;
	}

(RvString *)
pathNAME_X1
	-> pathNAME_X2:p = p;
	-> pathNAME_X2:p, '@', pathDomainName:d =
	{
		rvStringPushBack(p, '@');
		rvStringConcatenateString(p, d);
		rvDelete(&PCB, d);
		return p;
	}

(RvString *)
pathNAME_X2
	-> NAME:n = n;
	-> NAME:n, pathNAME_X3:s =
	{
		rvStringConcatenateString(n, s);
		rvDelete(&PCB, s);
		return n;
	}

(RvString *)
pathNAME_X3
	-> '/' + '*' + '$':c = rvStringPushBack(rvStringConstructAndReserve(rvNew(RvString)(&PCB), rvStringReserveSize, PCB.alloc), (char)c); 
	-> pathNAME_X3:s, ALPHA + DIGIT + '_' + '/' + '*' + '$':c = rvStringPushBack(s, (char)c);

// ABNF allows two or more consecutive "." although it is meaningless in a path domain name.
(RvString *)
pathDomainName
	-> ALPHA + DIGIT + '*':c = rvStringPushBack(rvStringConstructAndReserve(rvNew(RvString)(&PCB), rvStringReserveSize, PCB.alloc), (char)c); 
	-> pathDomainName:s, ALPHA + DIGIT + '-' + '*' + '.':c = rvStringPushBack(s, (char)c);

(RvMegacoTerminationId *)
TerminationID
	-> pathNAME:n =
	{
		RvMegacoTerminationId *x = rvNew(RvMegacoTerminationId)(&PCB);
		rvMegacoTerminationIdConstructA(x, rvStringGetData(n), PCB.alloc);
		rvDelete(&PCB, n);
		return x;
	}
	-> "ROOT" = rvMegacoTerminationIdConstructRootA(rvNew(RvMegacoTerminationId)(&PCB), PCB.alloc);
	-> '$' = rvMegacoTerminationIdConstructA(rvNew(RvMegacoTerminationId)(&PCB), "$", PCB.alloc);
	-> '*' = rvMegacoTerminationIdConstructA(rvNew(RvMegacoTerminationId)(&PCB), "*", PCB.alloc);

(RvMegacoMediaDescriptor *)
mediaDescriptor
	-> MediaDescriptorBlank:d, LBRKT, mediaParm, [COMMA, mediaParm]..., RBRKT = d;

(RvMegacoMediaDescriptor *)
MediaDescriptorBlank
	-> MediaToken, LWSP = 
	{ 
		PCB.curStream = NULL; 
		PCB.curMedia = rvNew(RvMegacoMediaDescriptor)(&PCB);
		rvMegacoMediaDescriptorConstructA(PCB.curMedia, PCB.alloc);
		return PCB.curMedia;
	}

(void)
mediaParm
	-> streamParm
	-> streamDescriptor:d = 
	{
		rvMegacoMediaDescriptorAddStream(PCB.curMedia, d);
		rvDelete(&PCB, d);
	}
	-> terminationStateDescriptor:d =
	{
		rvMegacoMediaDescriptorSetTerminationState(PCB.curMedia, d);
		rvDelete(&PCB, d);
	}

(RvMegacoStreamDescriptor *)
streamDescriptor
	-> streamDescriptorBlank:d, LBRKT, streamParm, [COMMA, streamParm]..., RBRKT = 
	{
		PCB.curStream = NULL; 
		return d;
	}

(RvMegacoStreamDescriptor *)
streamDescriptorBlank
	-> StreamToken, EQUAL, shortInteger:id, LWSP =
	{
		PCB.curStream = rvNew(RvMegacoStreamDescriptor)(&PCB);
		rvMegacoStreamDescriptorConstructA(PCB.curStream, id, PCB.alloc);
		return PCB.curStream;
	} 

(void)
streamParm
	-> localDescriptor:s =
	{
		parseSdpMessages(PCB.curStream != NULL ? PCB.curStream :
			rvMegacoMediaDescriptorGetDefaultStream(PCB.curMedia), s, rvFalse, &PCB);
		rvDelete(&PCB, s);
	}
	-> remoteDescriptor:s =
	{
		parseSdpMessages(PCB.curStream != NULL ? PCB.curStream :
			rvMegacoMediaDescriptorGetDefaultStream(PCB.curMedia), s, rvTrue, &PCB);
		rvDelete(&PCB, s);
	}
	-> localControlDescriptor

(RvString *)
localDescriptor
	-> LocalToken, LWSP, '{', octetString:s, RBRKT = s;

(RvString *)
remoteDescriptor
	-> RemoteToken, LWSP, '{', octetString:s, RBRKT = s;

(void)
localControlDescriptor
	-> LocalControlToken, LWSP, LBRKT, localParm, [COMMA, localParm]..., RBRKT

(void)
localParm
	-> streamMode:m =
	{
		rvMegacoStreamDescriptorSetMode(
			PCB.curStream != NULL ? PCB.curStream : rvMegacoMediaDescriptorGetDefaultStream(PCB.curMedia), m);
	}
	-> propertyParm:p =
	{
		rvMegacoStreamDescriptorSetParameter(
			PCB.curStream != NULL ? PCB.curStream : rvMegacoMediaDescriptorGetDefaultStream(PCB.curMedia),
			rvMegacoParameterGetName(p), rvMegacoParameterGetValue(p));
		rvDelete(&PCB, p);
	}
	-> reservedValueMode:m =
	{
		rvMegacoStreamDescriptorSetReserveValueMode(
			PCB.curStream != NULL ? PCB.curStream : rvMegacoMediaDescriptorGetDefaultStream(PCB.curMedia), m);
	}
	-> reservedGroupMode:m =
	{
		rvMegacoStreamDescriptorSetReserveGroupMode(
			PCB.curStream != NULL ? PCB.curStream : rvMegacoMediaDescriptorGetDefaultStream(PCB.curMedia), m);
	}

(RvMegacoStreamMode)
streamMode
	-> ModeToken, EQUAL, streamModes:m, LWSP = m;

(RvMegacoStreamMode)
streamModes
	-> SendonlyToken = RV_MEGACOSTREAMMODE_SENDONLY;
	-> RecvonlyToken = RV_MEGACOSTREAMMODE_RECVONLY;
	-> SendrecvToken = RV_MEGACOSTREAMMODE_SENDRECV;
	-> InactiveToken = RV_MEGACOSTREAMMODE_INACTIVE;
	-> LoopbackToken = RV_MEGACOSTREAMMODE_LOOPBACK;

(RvMegacoParameter *)
propertyParm
	-> pkgdName:n, parmValue:v =
	{
		RvMegacoParameter *p = rvNew(RvMegacoParameter)(&PCB);
		rvMegacoParameterConstructA(p, n, v, PCB.alloc);
		rvDelete(&PCB, n);
		rvDelete(&PCB, v);
		return p;
	}

(RvMegacoParameterValue *)
parmValue
	-> '=', LWSP, alternativeValue:p = p;
	-> INEQUAL:r, VALUE:v, LWSP =
	{
		RvMegacoParameterValue *p = rvNew(RvMegacoParameterValue)(&PCB);
		rvMegacoParameterValueConstructSpecialA(p, rvStringGetData(v), r, PCB.alloc);
		rvDelete(&PCB, v);
		return p;
	}
   
(RvMegacoParameterValue *)
alternativeValue
	-> VALUE:v, LWSP = 
	{
		RvMegacoParameterValue *p = rvNew(RvMegacoParameterValue)(&PCB);
		rvMegacoParameterValueConstructA(p, rvStringGetData(v), PCB.alloc);
		rvDelete(&PCB, v);
		return p;
	}
	-> LSBRKT, VALUE:v1, COLON, VALUE:v2, LWSP, RSBRKT =
	{
		RvMegacoParameterValue *p = rvNew(RvMegacoParameterValue)(&PCB);
		rvMegacoParameterValueConstructRangeA(p, rvStringGetData(v1), rvStringGetData(v2), PCB.alloc);
		rvDelete(&PCB, v1);
		rvDelete(&PCB, v2);
		return p;
	}
	-> LSBRKT, valueList:list, RSBRKT =
	{
		size_t i;
		RvMegacoParameterValue *p = rvNew(RvMegacoParameterValue)(&PCB);
		rvMegacoParameterValueConstructListA(p, RV_RELATION_AND, PCB.alloc);
		for(i=0; i<rvStringListGetSize(list); ++i)
			rvMegacoParameterValueAddToList(p, rvStringListGetElem(list, i));
		rvDelete(&PCB, list);
		return p;
	}
	-> LBRKT, valueList:list, RBRKT = 
	{
		size_t i;
		RvMegacoParameterValue *p = rvNew(RvMegacoParameterValue)(&PCB);
		rvMegacoParameterValueConstructListA(p, RV_RELATION_OR, PCB.alloc);
		for(i=0; i<rvStringListGetSize(list); ++i)
			rvMegacoParameterValueAddToList(p, rvStringListGetElem(list, i));
		rvDelete(&PCB, list);
		return p;
	}

(RvStringList *)
valueList
	-> VALUE:v, LWSP =
	{
		RvStringList *x = rvNew(RvStringList)(&PCB);
		rvStringListConstructA(x, PCB.alloc);
		rvStringListAddString(x, v);
		rvDelete(&PCB, v);
		return x;
	}
	-> valueList:x, COMMA, VALUE:v, LWSP =
	{
		rvStringListAddString(x, v);
		rvDelete(&PCB, v);
		return x;
	}

(RvBool)
reservedValueMode
	-> ReservedValueToken, EQUAL, toggle:b, LWSP = b;

(RvBool)
reservedGroupMode
	-> ReservedGroupToken, EQUAL, toggle:b, LWSP = b;

(RvBool)
toggle
	-> "ON" = rvTrue;
	-> "OFF" = rvFalse;

(RvMegacoEventBufferDescriptor *)
eventBufferDescriptor
	-> eventBufferDescriptorBlank:x, LBRKT, eventSpec, [COMMA, eventSpec]..., RBRKT = x;

(RvMegacoEventBufferDescriptor *)
eventBufferDescriptorBlank
	-> EventBufferToken, LWSP =
	{
		return PCB.curEventBufferDescriptor = rvMegacoEventBufferDescriptorConstructA(
			rvNew(RvMegacoEventBufferDescriptor)(&PCB), PCB.alloc);
	}

(void)
eventSpec
	-> eventSpecBlank:e, [LBRKT, eventSpecParameter, [COMMA, eventSpecParameter]..., RBRKT] = 
	{
		rvMegacoEventBufferDescriptorAddEvent(PCB.curEventBufferDescriptor, e);
		rvDelete(&PCB, e);
	}

(RvMegacoEvent *)
eventSpecBlank
	-> pkgdName:x =
	{
		PCB.curEvent = rvMegacoEventConstructA(rvNew(RvMegacoEvent)(&PCB), x, PCB.alloc);
		rvDelete(&PCB, x);
		return PCB.curEvent;
	}

(void)
eventSpecParameter
	-> eventStream:id = { rvMegacoEventSetStreamId(PCB.curEvent, id); }
	-> eventOther:p =
	{
		rvMegacoEventSetParameter(PCB.curEvent, rvMegacoPackageItemGetItem(rvMegacoParameterGetName(p)), rvMegacoParameterGetValue(p));
		rvDelete(&PCB, p);
	}

(RvMegacoTerminationStateDescriptor *)
terminationStateDescriptor
	-> terminationStateDescriptorBlank:x, LBRKT, terminationStateParm, [COMMA, terminationStateParm]..., RBRKT = x;

(RvMegacoTerminationStateDescriptor *)
terminationStateDescriptorBlank
	-> TerminationStateToken, LWSP =
	{
		return PCB.curTerminationStateDescriptor = rvMegacoTerminationStateDescriptorConstructA(
			rvNew(RvMegacoTerminationStateDescriptor)(&PCB), PCB.alloc);
	}

(void)
terminationStateParm
	-> propertyParm:p =
	{
		rvMegacoTerminationStateDescriptorSetParameter(PCB.curTerminationStateDescriptor, rvMegacoParameterGetName(p), rvMegacoParameterGetValue(p));
		rvDelete(&PCB, p);
	}
	-> serviceStates:s = { rvMegacoTerminationStateDescriptorSetServiceState(PCB.curTerminationStateDescriptor, s); }
	-> eventBufferControl:c = { rvMegacoTerminationStateDescriptorSetLockstepMode(PCB.curTerminationStateDescriptor, c); }