📄 rvmegaco.syn

📁 h.248协议源码
💻 SYN
📖 第 1 页 / 共 5 页
字号:
上一页 1 2 3 45
		return dm;
	}
	-> DigitMapToken, EQUAL, LBRKT, digitMapValue:v, RBRKT =
	{
		RvMegacoDigitMapDescriptor *dm = rvNew(RvMegacoDigitMapDescriptor)(&PCB);
		rvMegacoDigitMapDescriptorConstructA(dm, "", v, PCB.alloc);
		rvDelete(&PCB, v);
		return dm;
	}

{
const int useDefaultTimerValue = -1;
}

(RvMegacoDigitMap *)
digitMapValue
	-> startTimerValue:tStart, shortTimerValue:tShort, longTimerValue:tLong, digitMap:dm = 
	{
		if(tStart != useDefaultTimerValue) rvMegacoDigitMapSetStartTimeout(dm, tStart);
		if(tShort != useDefaultTimerValue) rvMegacoDigitMapSetShortTimeout(dm, tShort);
		if(tLong != useDefaultTimerValue)  rvMegacoDigitMapSetLongTimeout(dm, tLong);
		return dm;
	}

(int)
startTimerValue
-> "T", COLON, Timer:t, LWSP, COMMA = t;
-> = useDefaultTimerValue;

(int)
shortTimerValue
-> "S", COLON, Timer:t, LWSP, COMMA = t;
-> = useDefaultTimerValue;

(int)
longTimerValue
-> "L", COLON, Timer:t, LWSP, COMMA = t;
-> = useDefaultTimerValue;

(unsigned int)
Timer
	-> integer:i = 
	{
		if(i > 99) 
		{
			PCB.exit_flag = AG_SEMANTIC_ERROR_CODE;
			PCB.error_message = "Bad timer value";
		} 
		return i;
	}


/* this digit map allows more whitespace than spec */

(RvMegacoDigitMap *)
digitMap 
	-> digitString:ds = 
	{
		RvMegacoDigitMap *dm = rvNew(RvMegacoDigitMap)(&PCB);
		rvMegacoDigitMapConstructA(dm, PCB.alloc);
		rvMegacoDigitMapAddPattern(dm, ds);
		rvDelete(&PCB, ds);
		return dm;
	}
	->  '(', LWSP, digitStringList:dm, ')', LWSP = dm;

(RvMegacoDigitMap *)
digitStringList
	-> digitString:ds =
	{
		RvMegacoDigitMap *dm = rvNew(RvMegacoDigitMap)(&PCB);
		rvMegacoDigitMapConstructA(dm, PCB.alloc);
		rvMegacoDigitMapAddPattern(dm, ds);
		rvDelete(&PCB, ds);
		return dm;
	}
	-> digitStringList:dm, '|', LWSP, digitString:ds =
	{
		rvMegacoDigitMapAddPattern(dm, ds);
		rvDelete(&PCB, ds);
		return dm;
	}

(RvMegacoDigitString *)
digitString
	-> digitStringElement:e = 
	{ 
		RvMegacoDigitString *ds = rvNew(RvMegacoDigitString)(&PCB);
		rvMegacoDigitStringConstructA(ds, PCB.alloc);
		rvMegacoDigitStringAddElement(ds, e);
		rvDelete(&PCB, e);
		return ds;
	}
	-> digitString:ds, digitStringElement:e = 
	{
		rvMegacoDigitStringAddElement(ds, e);
		rvDelete(&PCB, e);
		return ds;
	}

(RvMegacoDigitPosition *)
digitStringElement
	-> digitPosition:p = p;
	-> digitPosition:p, DOT, LWSP = { rvMegacoDigitPositionSetMultipleFlag(p, rvTrue); return p; }

(RvMegacoDigitPosition *)
digitPosition
	-> digitMapEvent:d, LWSP = 
		{
			RvMegacoDigitPosition *p = rvNew(RvMegacoDigitPosition)(&PCB);
			rvMegacoDigitPositionConstruct(p);
			rvMegacoDigitPositionAddEvents(p, (char)d, (char)d);
			return p;
		}
	-> 'x', LWSP =
		{
			RvMegacoDigitPosition *p = rvNew(RvMegacoDigitPosition)(&PCB);
			rvMegacoDigitPositionConstruct(p);
			rvMegacoDigitPositionAddEvents(p, '0', '9');
			return p;
		}
	-> shortTimerModifier, LWSP = 
		{ 
			RvMegacoDigitPosition *p = rvNew(RvMegacoDigitPosition)(&PCB);
			rvMegacoDigitPositionConstruct(p);
			rvMegacoDigitPositionSetTimerMode(p, RV_MEGACODIGITPOSITION_SHORTTIMER); 
			return p;
		}
	-> longTimerModifier, LWSP = 
		{ 
			RvMegacoDigitPosition *p = rvNew(RvMegacoDigitPosition)(&PCB);
			rvMegacoDigitPositionConstruct(p);
			rvMegacoDigitPositionSetTimerMode(p, RV_MEGACODIGITPOSITION_LONGTIMER); 
			return p;
		}
	-> longDurationModifier, LWSP =
		{ 
			RvMegacoDigitPosition *p = rvNew(RvMegacoDigitPosition)(&PCB);
			rvMegacoDigitPositionConstruct(p);
			rvMegacoDigitPositionSetLongDurationFlag(p, rvTrue); 
			return p;
		}
	-> startRange:p, [digitPositionRangeItems..., LWSP], RSBRKT = p;

(RvMegacoDigitPosition *)
startRange
	-> LSBRKT = PCB.curDigitPositionRange = rvMegacoDigitPositionConstruct(rvNew(RvMegacoDigitPosition)(&PCB));

(void)
digitPositionRangeItems
	-> DIGIT:d1, '-', DIGIT:d2 = 
		{ 
			if(d2 < d1) 
			{
				PCB.exit_flag = AG_SEMANTIC_ERROR_CODE;
				PCB.error_message = "Bad digit map";
			}
			else
			{
				rvMegacoDigitPositionAddEvents(PCB.curDigitPositionRange, (char)d1, (char)d2); 
			}
		}
	-> digitMapEvent:d = { rvMegacoDigitPositionAddEvents(PCB.curDigitPositionRange, (char)d, (char)d); }
	-> shortTimerModifier = { rvMegacoDigitPositionSetTimerMode(PCB.curDigitPositionRange, RV_MEGACODIGITPOSITION_SHORTTIMER); }
	-> longTimerModifier = { rvMegacoDigitPositionSetTimerMode(PCB.curDigitPositionRange, RV_MEGACODIGITPOSITION_LONGTIMER); }
	-> longDurationModifier = { rvMegacoDigitPositionSetLongDurationFlag(PCB.curDigitPositionRange, rvTrue); }

digitMapEvent = DIGIT + 'a-k' + 'A-K' 
shortTimerModifier = 's' + 'S'  
longTimerModifier = 'l' + 'L'
longDurationModifier = 'z' + 'Z' 


(RvMegacoServiceChangeDescriptor *)
serviceChangeDescriptor
	-> serviceChangeDescriptorBlank, LBRKT, serviceChangeParm, [COMMA, serviceChangeParm]..., RBRKT

(RvMegacoServiceChangeDescriptor *)
serviceChangeReplyDescriptor
	-> serviceChangeDescriptorBlank, LBRKT, servChgReplyParm, [COMMA, servChgReplyParm]..., RBRKT

(RvMegacoServiceChangeDescriptor *)
serviceChangeDescriptorBlank
	-> ServicesToken, LWSP = PCB.curServiceChangeDescriptor = rvMegacoServiceChangeDescriptorConstructA(rvNew(RvMegacoServiceChangeDescriptor)(&PCB), PCB.alloc);

(void)
serviceChangeParm
	-> serviceChangeMethod
	-> serviceChangeReason
	-> serviceChangeDelay
	-> serviceChangeAddress
	-> serviceChangeProfile
	-> serviceChangeMgcId
	-> serviceChangeVersion
	-> extension:x =
		{
			rvMegacoServiceChangeDescriptorSetParameter(PCB.curServiceChangeDescriptor,
				rvMegacoPackageItemGetItem(rvMegacoParameterGetName(x)), rvMegacoParameterGetValue(x));
			rvDelete(&PCB, x);
		}
	-> TimeStamp:ts = 
		{
			rvMegacoServiceChangeDescriptorSetTimeStamp(PCB.curServiceChangeDescriptor, ts);
			rvDelete(&PCB, ts);
		}

(void)
servChgReplyParm
	-> serviceChangeAddress
	-> serviceChangeMgcId
	-> serviceChangeProfile
	-> serviceChangeVersion

(void)
serviceChangeMethod
	-> MethodToken, EQUAL, serviceChangeMethodValue, LWSP

(void)
serviceChangeMethodValue
	-> FailoverToken = { rvMegacoServiceChangeDescriptorSetMethod(PCB.curServiceChangeDescriptor, RV_MEGACOSERVICECHANGEMETHOD_FAILOVER); }
	-> ForcedToken = { rvMegacoServiceChangeDescriptorSetMethod(PCB.curServiceChangeDescriptor, RV_MEGACOSERVICECHANGEMETHOD_FORCED); }
	-> GracefulToken = { rvMegacoServiceChangeDescriptorSetMethod(PCB.curServiceChangeDescriptor, RV_MEGACOSERVICECHANGEMETHOD_GRACEFUL); }
	-> RestartToken = { rvMegacoServiceChangeDescriptorSetMethod(PCB.curServiceChangeDescriptor, RV_MEGACOSERVICECHANGEMETHOD_RESTART); }
	-> DisconnectedToken = { rvMegacoServiceChangeDescriptorSetMethod(PCB.curServiceChangeDescriptor, RV_MEGACOSERVICECHANGEMETHOD_DISCONNECTED); }
	-> HandOffToken = { rvMegacoServiceChangeDescriptorSetMethod(PCB.curServiceChangeDescriptor, RV_MEGACOSERVICECHANGEMETHOD_HANDOFF); }
	-> extensionParameter:x = 
	{ 
		rvMegacoServiceChangeDescriptorSetOtherMethod(PCB.curServiceChangeDescriptor, rvStringGetData(x)); 
		rvDelete(&PCB, x);
	}

(void)
serviceChangeReason
	-> ReasonToken, EQUAL, VALUE:s, LWSP = 
	{
		int reason = atoi(rvStringGetData(s));
		if(reason != 0)
		{
			rvMegacoServiceChangeDescriptorSetReason(PCB.curServiceChangeDescriptor, reason);
		}
		else
		{
			PCB.exit_flag = AG_SEMANTIC_ERROR_CODE;
			PCB.error_message = "Bad service change reason";
		}
		rvDelete(&PCB, s);
	}

(void)
serviceChangeDelay
	-> DelayToken, EQUAL, integer:i, LWSP = { rvMegacoServiceChangeDescriptorSetDelay(PCB.curServiceChangeDescriptor, i); }

(void)
serviceChangeAddress
	-> ServiceChangeAddressToken, EQUAL, VALUE:s, LWSP =
	{
		rvMegacoServiceChangeDescriptorSetAddress(PCB.curServiceChangeDescriptor, rvStringGetData(s));
		rvDelete(&PCB, s);
	}

(void)
serviceChangeMgcId
	-> MgcIdToken, EQUAL, mId:addr, LWSP =
	{
		rvMegacoServiceChangeDescriptorSetMgc(PCB.curServiceChangeDescriptor, addr);
		rvDelete(&PCB, addr);
	}

(void)
serviceChangeProfile
	-> ProfileToken, EQUAL, NAME:n, SLASH, Version:v, LWSP =
	{
		rvMegacoServiceChangeDescriptorSetProfile(PCB.curServiceChangeDescriptor, rvStringGetData(n));
		rvMegacoServiceChangeDescriptorSetProfileVersion(PCB.curServiceChangeDescriptor, v);
		rvDelete(&PCB, n);
	}

(void)
serviceChangeVersion
	-> VersionToken, EQUAL, Version:i, LWSP = { rvMegacoServiceChangeDescriptorSetVersion(PCB.curServiceChangeDescriptor, i); }

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

(RvMegacoPackagesDescriptor *)
packagesDescriptor
	-> packagesDescriptorBlank:p, LBRKT, packagesItem, [COMMA, packagesItem]..., RBRKT = p; 

(RvMegacoPackagesDescriptor *)
packagesDescriptorBlank
	-> PackagesToken, LWSP = PCB.curPackagesDescriptor = rvMegacoPackagesDescriptorConstructA(rvNew(RvMegacoPackagesDescriptor)(&PCB), PCB.alloc);

(void)
packagesItem
	-> NAME:n, '-', Version:v, LWSP = 
	{ 
		rvMegacoPackagesDescriptorAddPackage(PCB.curPackagesDescriptor, rvStringGetData(n), v);
		rvDelete(&PCB, n);
	}

(unsigned int)
Version
	-> integer:i = 
	{ 
		if(i > 99)
		{
			PCB.exit_flag = AG_SEMANTIC_ERROR_CODE;
			PCB.error_message = "Bad version number"; 
		}
		return i;
	}

(RvTimeStamp *)
TimeStamp // per ISO 8601:1988 - Date, 'T', Time, LWSP - Date = yyyymmdd, Time = hhmmssss
	-> DIGIT:y3, DIGIT:y2, DIGIT:y1, DIGIT:y0, DIGIT:mo1, DIGIT:mo0, DIGIT:d1, DIGIT:d0, 'T', 
	DIGIT:h1, DIGIT:h0, DIGIT:mi1, DIGIT:mi0, DIGIT:s3, DIGIT:s2, DIGIT:s1, DIGIT:s0, LWSP =
	{
		return rvTimeStampConstruct(rvNew(RvTimeStamp)(&PCB),
			1000 * (y3 - '0') + 100 * (y2 - '0') + 10 * (y1 - '0') +	(y0 - '0'),
			10 * (mo1 - '0') + (mo0 - '0'),	10 * (d1 - '0') + (d0 - '0'),
			10 * (h1 - '0') +	(h0 - '0'),	10 * (mi1 - '0') + (mi0 - '0'),
			1000 * (s3 - '0') +	100 * (s2 - '0') + 10 * (s1 - '0') + (s0 - '0'));
	}

(RvMegacoStatisticsDescriptor *)
statisticsDescriptor
	-> StatsToken, LWSP, LBRKT, statisticsParameterList:v, RBRKT = v;

(RvMegacoStatisticsDescriptor *)
statisticsParameterList
	-> pkgdName:n, '=', LWSP, VALUE:v, LWSP =
	{ 
		RvMegacoStatisticsDescriptor *s = rvNew(RvMegacoStatisticsDescriptor)(&PCB);
		rvMegacoStatisticsDescriptorConstructA(s, PCB.alloc);
		rvMegacoStatisticsDescriptorAddStatistic(s, n, rvStringGetData(v));
		rvDelete(&PCB, n);
		rvDelete(&PCB, v);
		return s; 
	}
	-> statisticsParameterList:s, COMMA, pkgdName:n, '=', LWSP, VALUE:v, LWSP =
	{ 
		rvMegacoStatisticsDescriptorAddStatistic(s, n, rvStringGetData(v));
		rvDelete(&PCB, n);
		rvDelete(&PCB, v);
		return s; 
	}

(RvMegacoTopologyDescriptor *)
topologyDescriptor
	-> topologyDescriptorBlank:x, LBRKT, topologyTriple, [COMMA, topologyTriple]..., RBRKT = x;

(RvMegacoTopologyDescriptor *)
topologyDescriptorBlank
	-> TopologyToken, LWSP = PCB.curTopologyDescriptor = rvMegacoTopologyDescriptorConstructA(rvNew(RvMegacoTopologyDescriptor)(&PCB), PCB.alloc);

(void)
topologyTriple
	-> TerminationID:termA, LWSP, COMMA, TerminationID:termB, LWSP, COMMA, topologyDirection:dir, LWSP =
	{
		rvMegacoTopologyDescriptorAdd(PCB.curTopologyDescriptor, termA, termB, dir);
		rvDelete(&PCB, termA);
		rvDelete(&PCB, termB);
	}

(RvDirection)
topologyDirection
	-> BothwayToken = RV_DIRECTION_BOTHWAYS;
	-> OnewayToken = RV_DIRECTION_ONEWAY;
	-> IsolateToken = RV_DIRECTION_ISOLATE;

(unsigned int)
priority
	-> PriorityToken, EQUAL, shortInteger:i, LWSP = i;

(RvString *)
extensionParameter
	-> 'X', '-' + '+':sep, ALPHA + DIGIT:c =
	{
		RvString *s = rvNew(RvString)(&PCB);
		rvStringConstruct(s, "X", PCB.alloc); 
		rvStringPushBack(s, (char)sep);
		rvStringPushBack(s, (char)c);
		return s;
	}
	-> extensionParameter:s, ALPHA + DIGIT:c = rvStringPushBack(s, (char)c);

// octetString is used to describe SDP defined in RFC2327.
// Caution should be taken if CRLF in RFC2327 is used.
// To be safe, use EOL in this ABNF.
// Whenever "}" appears in SDP, it is escaped by "\", e.g., "\}"

(RvString *)
octetString
	-> = rvStringConstructAndReserve(rvNew(RvString)(&PCB), rvStringReserveSize, PCB.alloc); 
	-> octetString:s, "\\}" = rvStringPushBack(s, '}');
	-> octetString:s, 0x01..0xFF - '}':c = rvStringPushBack(s, (char)c);

(unsigned int)
shortInteger
	-> integer:i = 
	{ 
		if(i >= 1 << 16) 
		{
			PCB.exit_flag = AG_SEMANTIC_ERROR_CODE;
			PCB.error_message = "Integer out of range"; 
		}
		return i; 
	}

(unsigned int)
integer
	-> DIGIT:d = d - '0';
	-> integer:i, DIGIT:d = 10 * i + d - '0';

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

(RvString *)
上一页 1 2 3 45
⌨️ 快捷键说明

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