mmiplaintextparserlogic.jj

Sun公司Dream项目

	Token value;
	StringBuffer sb = new StringBuffer();
} 
{
	<CONTENTID> <EQUAL> value=<STRING> 
	{
		sb.append(value.image);
	}
	(
		<COMMA> value=<STRING> 
		{
			sb.append(",");
			sb.append(value.image);
		}
	)*
	{
		return new ContentId(sb.toString());
	}
}

ServiceId ServiceId() : 
{
	Token value;
}
{
	<SERVICEID> <EQUAL> value=<STRING>
	{
		return new ServiceId(value.image);
	}
}

VerbElement VerbElement() : 
{
	VerbElement verbElement = new VerbElement();
	VerbElementId verbElementId;
	Verb verb;
	Count count;
	Duration duration;
	Period period;
	VerbSpecificArgs verbSpecificArgs;
	Vector<VerbSpecificArgs> v = new Vector<VerbSpecificArgs>();
}
{
	RightsElemPrefix() verbElementId=VerbElementId() 
	{
		verbElement.setVerbElementId(verbElementId);
	}
	RightsVerbPrefix() verb=Verb()
	{
		verbElement.setVerb(verb);
	} 
	[
		(
			RightsVerbPrefix() count=Count()
		)
		{
			verbElement.setCount(count);
		}
	] 
	[
		(
			RightsVerbPrefix() 
			(
				duration=Duration() 
				{
					verbElement.setDuration(duration);
				}
				| 
				period=Period()
				{
					verbElement.setPeriod(period);
				}
			)
		)
	] 
	(
		RightsVerbPrefix() verbSpecificArgs=VerbSpecificArgs()
		{
			v.add(verbSpecificArgs);
		}
	)*
	{
		if(!v.isEmpty()) {
			verbElement.setVerbSpecificArgs((VerbSpecificArgs[])v.toArray(new VerbSpecificArgs[0]));
		}
		return verbElement;
	}
}

VerbElementId VerbElementId() : 
{
	Token value;	
}
{
	<VERBID> <EQUAL> value=<STRING>
	{
		return new VerbElementId(value.image);
	}
}

void RightsVerbPrefix() : {}
{
	RightsElemPrefix() <STRING> <DOT>
}

Verb Verb() : 
{
	Token value;
}
{
	<VERB> <EQUAL> value=<STRING>
	{
		return new Verb(value.image);
	}
}

Count Count() : 
{
	Token value;
}
{
	<COUNT> <EQUAL> value=<STRING>
	{
		return new Count(value.image);
	}
}

Duration Duration() : 
{
	Token value;
}
{
	<DURATION> <EQUAL> value=<STRING>
	{
		return new Duration(value.image);
	}
}	

Period Period() : 
{
	Token value;
}
{
	<PERIOD> <EQUAL> value=<STRING>
	{
		return new Period(value.image);
	}
}

VerbSpecificArgs VerbSpecificArgs()	: 
{
	VerbSpecificArgs verbSpecificArgs = new VerbSpecificArgs();
	Token arg;
	Token value;
}
{
	arg=<STRING> 
	{
		verbSpecificArgs.setVerbSpecificArgName(arg.image);
	}
	[
		<EQUAL> 
		(
			value=<STRING> 
			{
				verbSpecificArgs.setVerbSpecificArgValue(value.image);
			}
			| 
			value=<STRING>
			{
				verbSpecificArgs.setVerbSpecificArgValue(value.image);
			}
		)
	]
	{
		return verbSpecificArgs;
	}
}

SignatureSegment SignatureSegment() : 
{
	SignatureSegment signatureSegment = new SignatureSegment();
	SigAlg sigAlg;
	Signature signature;
}
{
	SignaturePrefix() sigAlg=SigAlg() 
	{
		signatureSegment.setSigAlg(sigAlg);
	}
	SignaturePrefix() signature=Signature()
	{
		signatureSegment.setSignature(signature);
	}
	{
		return signatureSegment;
	}
}

void SignaturePrefix() : {}
{
	<SIGNATURE> <DOT>
}

SigAlg SigAlg() : 
{
	String strValue;
	SigAlg sigAlg = null;
}
{
	<SIGALG> <EQUAL> strValue=URI()
	{
		try { 
			sigAlg = new SigAlg(strValue);
		} catch (InvalidMMIObjectException imoe) {
			imoe.printStackTrace();
		} finally {
			return sigAlg;
		}
	}
}

Signature Signature() : 
{
	Token value;
}
{
	<SIGNATURE> <EQUAL> value=<STRING>
	{
		return new Signature(value.image);
	}
}

MMIResponse MMIResponse() : 
{
	MMIResponse mmiResponse = new MMIResponse();
	Status status;
	MMIRightsResponseElement mmiRightsResponseElement;
	RequestHashSegment requestHashSegment;
	ResponseId responseId;
	SignatureSegment signatureSegment;
	Vector<Status> v1 = new Vector<Status>();
	Vector<MMIRightsResponseElement> v2 = new Vector<MMIRightsResponseElement>();
}
{
	(status=Status() {v1.add(status);})+ 
	{
		mmiResponse.setStatus((Status[])v1.toArray(new Status[0]));
	}
	(mmiRightsResponseElement=MMIRightsResponseElement() {v2.add(mmiRightsResponseElement);})+ 
	{
		mmiResponse.setMMIRightsResponseElement((MMIRightsResponseElement[])v2.toArray(new MMIRightsResponseElement[0]));
	}
	[requestHashSegment=RequestHashSegment() 
		{
			mmiResponse.setRequestHashSegment(requestHashSegment);
		}	
	] 
	[responseId=ResponseId()
		{
			mmiResponse.setResponseId(responseId);
		}
	] 
	signatureSegment=SignatureSegment()
	{
		mmiResponse.setSignatureSegment(signatureSegment);
		return mmiResponse;	
	}
}

Status Status() : 
{
	Token token;
}
{
	<STATUS> <EQUAL> token=<STRING>
	{
		return new Status(token.image);
	}
}

MMIRightsResponseElement MMIRightsResponseElement() : {
	MMIRightsResponseElement mmiRightsResponseElement = new MMIRightsResponseElement();
	ReqElemId reqElemId;
	Notification notification;
	Hint hint;
	Keys keys;
	RightsErrorStatus rightsErrorStatus;
	Vector<Hint> v1 = new Vector<Hint>();
	Vector<RightsErrorStatus> v2 = new Vector<RightsErrorStatus>();
}
{	
	ResponsePrefix() reqElemId=ReqElemId() 
	{
		mmiRightsResponseElement.setReqElemId(reqElemId);
	}
	ResponseElemPrefix() notification=Notification() 
	{
		mmiRightsResponseElement.setNotification(notification);
	}
	(hint=Hint()
		{
			v1.add(hint);
		}	
	)* 
	{
		if(!v1.isEmpty()) {
			mmiRightsResponseElement.setHint((Hint[])v1.toArray(new Hint[0]));
		}
	}
	[(ResponseElemPrefix() keys=Keys() 
		{
			mmiRightsResponseElement.setKeys(keys);
		}
	)]
	(ResponseElemPrefix() rightsErrorStatus=RightsErrorStatus()
		{
			v2.add(rightsErrorStatus);
		}
	)* 
	{
		if(!v2.isEmpty()) {
			mmiRightsResponseElement.setRightsErrorStatus((RightsErrorStatus[])v2.toArray(new RightsErrorStatus[0]));
		}
		return mmiRightsResponseElement;
	}
}

void ResponsePrefix() : {}
{
	<RESPONSE> <DOT>
}

void ResponseElemPrefix() : {}
{
	ResponsePrefix() <STRING> <DOT>
}

Notification Notification() : 
{
	Token token;
}
{
	<NOTIFICATION> <EQUAL> token=<STRING>
	{
		return new Notification(token.image);
	}
}

Hint Hint() : 
{
	Hint hint=new Hint();
	HintIndexNum hintIndexNum;
	Label label;
	ContentId contentId;
	VerbElement verbElement;
	Vector<ContentId> v1=new Vector<ContentId>();
	Vector<VerbElement> v2=new Vector<VerbElement>();
}
{
	ResponseHintPrefix() hintIndexNum=HintIndexNum()
	{
		hint.setHintIndexNum(hintIndexNum);
	}
	ResponseHintIndexPrefix() label=Label() 
	{
		hint.setLabel(label);
	}
	(ResponseHintIndexPrefix() contentId=ResponseContentId()
	{
		v1.add(contentId);
	}
	)* 
	{
		if(!v1.isEmpty()) {
			hint.setContentId((ContentId[])v1.toArray(new ContentId[0]));
		}
	}
	(verbElement=ResponseVerbElement()
	{
		v2.add(verbElement);
	}
	)*
	{
		if(!v2.isEmpty()) {
			hint.setVerbElement((VerbElement[])v2.toArray(new VerbElement[0]));
		}
		return hint;
	}
}

void ResponseHintPrefix() : {}
{
	ResponseElemPrefix() <HINT> <DOT>
}

HintIndexNum HintIndexNum() : 
{
	Token token;
}
{
	<HINTINDEXNUM> <EQUAL> token=<STRING>
	{
		return new HintIndexNum(token.image);
	}
}

void ResponseHintIndexPrefix() : {}
{
	ResponseHintPrefix() <STRING> <DOT>
}

Label Label() : 
{
	Token token;
}
{
	<LABEL> <EQUAL> token=<STRING>
	{
		return new Label(token.image);
	}
}

ContentId ResponseContentId() : 
{
	Token token;
}
{
	<CONTENTID> <EQUAL> token=<STRING>
	{
		return new ContentId(token.image);
	}
}

VerbElement ResponseVerbElement() : 
{
	VerbElement verbElement = new VerbElement();
	VerbElementId verbElementId;
	Verb verb;
	Count count;
	Duration duration;
	Period period;
	VerbSpecificArgs verbSpecificArgs;
	Vector<VerbSpecificArgs> v = new Vector<VerbSpecificArgs>();
}
{
	ResponseHintIndexPrefix() verbElementId=VerbElementId() 
	{
		verbElement.setVerbElementId(verbElementId);
	}	
	ResponseHintIndexVerbElemPrefix() verb=Verb() 
	{
		verbElement.setVerb(verb);
	}
	[(ResponseHintIndexVerbElemPrefix() count=Count()
		{
			verbElement.setCount(count);
		}
	)] 
	[(ResponseHintIndexVerbElemPrefix() 
		(duration=Duration() 
			{
				verbElement.setDuration(duration);
			}
		| 
		period=Period()
			{
				verbElement.setPeriod(period);
			}
		)
	)] 
	(ResponseHintIndexVerbElemPrefix() verbSpecificArgs=VerbSpecificArgs()
		{
			v.add(verbSpecificArgs);
		}
	)*
	{
		if(!v.isEmpty()) {
			verbElement.setVerbSpecificArgs((VerbSpecificArgs[])v.toArray(new VerbSpecificArgs[0]));
		}
		return verbElement;
	}
}

void ResponseHintIndexVerbElemPrefix() : {}
{
	ResponseHintIndexPrefix() <STRING> <DOT>
}

Keys Keys() : 
{
	String strToken;
}
{
	<KEYS> <EQUAL> strToken=KEY()
	{
		return new Keys(strToken);
	}
}

RightsErrorStatus RightsErrorStatus() : 
{
	Token token;
}
{
	<STATUS> <EQUAL> token=<STRING>
	{
		return new RightsErrorStatus();
	}	
}

RequestHashSegment RequestHashSegment() : 
{
	HashAlg hashAlg;
	RequestHash requestHash;
	RequestHashSegment requestHashSegment = new RequestHashSegment();
}
{
	ReqHashPrefix() hashAlg=HashAlg() 
	{
		requestHashSegment.setHashAlg(hashAlg);
	}
	ReqHashPrefix() requestHash=RequestHash()
	{
		requestHashSegment.setRequestHash(requestHash);
		return requestHashSegment;
	}
}

void ReqHashPrefix() : {}
{
	<REQHASH> <DOT>
}

HashAlg HashAlg() : 
{
	String strToken;
}
{
	<HASHALG> <EQUAL> strToken=URI()
	{
		return new HashAlg(strToken);
	}
}

RequestHash RequestHash() : 
{
	Token token;
}
{
	<REQUESTHASH> <EQUAL> token=<STRING>
	{
		return new RequestHash(token.image);
	}
}


ResponseId ResponseId() : 
{
	Token token;
}
{
	<RESPONSEID> <EQUAL> token=<STRING>
	{
		return new ResponseId(token.image);
	}
}