textcommandparser.java

关于 RFID 读写器的相关内容

			helper.setCommand(CMD_GET_ALL_NOTIFICATION_TRIGGERS);
			break;
		}
		case CMD_READ_QUEUED_DATA:
		{
			match(CMD_READ_QUEUED_DATA);
			helper.setCommand(CMD_READ_QUEUED_DATA);
			break;
		}
		case CMD_RQD:
		{
			match(CMD_RQD);
			helper.setCommand(CMD_READ_QUEUED_DATA);
			break;
		}
		case CMD_ADD_FIELD_NAMES:
		{
			match(CMD_ADD_FIELD_NAMES);
			helper.setCommand(CMD_ADD_FIELD_NAMES);
			break;
		}
		case CMD_AFN:
		{
			match(CMD_AFN);
			helper.setCommand(CMD_ADD_FIELD_NAMES);
			break;
		}
		case CMD_REMOVE_FIELD_NAMES:
		{
			match(CMD_REMOVE_FIELD_NAMES);
			helper.setCommand(CMD_REMOVE_FIELD_NAMES);
			break;
		}
		case CMD_RFN:
		{
			match(CMD_RFN);
			helper.setCommand(CMD_REMOVE_FIELD_NAMES);
			break;
		}
		case CMD_REMOVE_ALL_FIELD_NAMES:
		{
			match(CMD_REMOVE_ALL_FIELD_NAMES);
			helper.setCommand(CMD_REMOVE_ALL_FIELD_NAMES);
			break;
		}
		case CMD_RAFN:
		{
			match(CMD_RAFN);
			helper.setCommand(CMD_REMOVE_ALL_FIELD_NAMES);
			break;
		}
		case CMD_GET_ALL_FIELD_NAMES:
		{
			match(CMD_GET_ALL_FIELD_NAMES);
			helper.setCommand(CMD_GET_ALL_FIELD_NAMES);
			break;
		}
		case CMD_GAFN:
		{
			match(CMD_GAFN);
			helper.setCommand(CMD_GET_ALL_FIELD_NAMES);
			break;
		}
		case CMD_ADD_EVENT_FILTERS:
		{
			match(CMD_ADD_EVENT_FILTERS);
			helper.setCommand(CMD_ADD_EVENT_FILTERS);
			break;
		}
		case CMD_AEF:
		{
			match(CMD_AEF);
			helper.setCommand(CMD_ADD_EVENT_FILTERS);
			break;
		}
		case CMD_REMOVE_EVENT_FILTERS:
		{
			match(CMD_REMOVE_EVENT_FILTERS);
			helper.setCommand(CMD_REMOVE_EVENT_FILTERS);
			break;
		}
		case CMD_REF:
		{
			match(CMD_REF);
			helper.setCommand(CMD_REMOVE_EVENT_FILTERS);
			break;
		}
		case CMD_REMOVE_ALL_EVENT_FILTERS:
		{
			match(CMD_REMOVE_ALL_EVENT_FILTERS);
			helper.setCommand(CMD_REMOVE_ALL_EVENT_FILTERS);
			break;
		}
		case CMD_RAEF:
		{
			match(CMD_RAEF);
			helper.setCommand(CMD_REMOVE_ALL_EVENT_FILTERS);
			break;
		}
		case CMD_GET_ALL_EVENT_FILTERS:
		{
			match(CMD_GET_ALL_EVENT_FILTERS);
			helper.setCommand(CMD_GET_ALL_EVENT_FILTERS);
			break;
		}
		case CMD_GAEF:
		{
			match(CMD_GAEF);
			helper.setCommand(CMD_GET_ALL_EVENT_FILTERS);
			break;
		}
		case CMD_ADD_TAG_FIELD_NAMES:
		{
			match(CMD_ADD_TAG_FIELD_NAMES);
			helper.setCommand(CMD_ADD_TAG_FIELD_NAMES);
			break;
		}
		case CMD_ATFN:
		{
			match(CMD_ATFN);
			helper.setCommand(CMD_ADD_TAG_FIELD_NAMES);
			break;
		}
		case CMD_REMOVE_TAG_FIELD_NAMES:
		{
			match(CMD_REMOVE_TAG_FIELD_NAMES);
			helper.setCommand(CMD_REMOVE_TAG_FIELD_NAMES);
			break;
		}
		case CMD_RTFN:
		{
			match(CMD_RTFN);
			helper.setCommand(CMD_REMOVE_TAG_FIELD_NAMES);
			break;
		}
		case CMD_REMOVE_ALL_TAG_FIELD_NAMES:
		{
			match(CMD_REMOVE_ALL_TAG_FIELD_NAMES);
			helper.setCommand(CMD_REMOVE_ALL_TAG_FIELD_NAMES);
			break;
		}
		case CMD_RATFN:
		{
			match(CMD_RATFN);
			helper.setCommand(CMD_REMOVE_ALL_TAG_FIELD_NAMES);
			break;
		}
		case CMD_GET_ALL_TAG_FIELD_NAMES:
		{
			match(CMD_GET_ALL_TAG_FIELD_NAMES);
			helper.setCommand(CMD_GET_ALL_TAG_FIELD_NAMES);
			break;
		}
		case CMD_GATFN:
		{
			match(CMD_GATFN);
			helper.setCommand(CMD_GET_ALL_TAG_FIELD_NAMES);
			break;
		}
		case CMD_GET_SUPPORTED_TYPES:
		{
			match(CMD_GET_SUPPORTED_TYPES);
			helper.setCommand(CMD_GET_SUPPORTED_TYPES);
			break;
		}
		case CMD_GST:
		{
			match(CMD_GST);
			helper.setCommand(CMD_GET_SUPPORTED_TYPES);
			break;
		}
		case CMD_GET_SUPPORTED_NAMES:
		{
			match(CMD_GET_SUPPORTED_NAMES);
			helper.setCommand(CMD_GET_SUPPORTED_NAMES);
			break;
		}
		case CMD_GSN:
		{
			match(CMD_GSN);
			helper.setCommand(CMD_GET_SUPPORTED_NAMES);
			break;
		}
		case CMD_GET_TAG_FIELD_NAME:
		{
			match(CMD_GET_TAG_FIELD_NAME);
			helper.setCommand(CMD_GET_TAG_FIELD_NAME);
			break;
		}
		case CMD_GTFN:
		{
			match(CMD_GTFN);
			helper.setCommand(CMD_GET_TAG_FIELD_NAME);
			break;
		}
		case CMD_SET_TAG_FIELD_NAME:
		{
			match(CMD_SET_TAG_FIELD_NAME);
			helper.setCommand(CMD_SET_TAG_FIELD_NAME);
			break;
		}
		case CMD_STFN:
		{
			match(CMD_STFN);
			helper.setCommand(CMD_SET_TAG_FIELD_NAME);
			break;
		}
		case CMD_GET_MEMORY_BANK:
		{
			match(CMD_GET_MEMORY_BANK);
			helper.setCommand(CMD_GET_MEMORY_BANK);
			break;
		}
		case CMD_GMB:
		{
			match(CMD_GMB);
			helper.setCommand(CMD_GET_MEMORY_BANK);
			break;
		}
		case CMD_SET_MEMORY_BANK:
		{
			match(CMD_SET_MEMORY_BANK);
			helper.setCommand(CMD_SET_MEMORY_BANK);
			break;
		}
		case CMD_SMB:
		{
			match(CMD_SMB);
			helper.setCommand(CMD_SET_MEMORY_BANK);
			break;
		}
		case CMD_GET_OFFSET:
		{
			match(CMD_GET_OFFSET);
			helper.setCommand(CMD_GET_OFFSET);
			break;
		}
		case CMD_GOFF:
		{
			match(CMD_GOFF);
			helper.setCommand(CMD_GET_OFFSET);
			break;
		}
		case CMD_SET_OFFSET:
		{
			match(CMD_SET_OFFSET);
			helper.setCommand(CMD_SET_OFFSET);
			break;
		}
		case CMD_SOFF:
		{
			match(CMD_SOFF);
			helper.setCommand(CMD_SET_OFFSET);
			break;
		}
		case CMD_GET_LENGTH:
		{
			match(CMD_GET_LENGTH);
			helper.setCommand(CMD_GET_LENGTH);
			break;
		}
		case CMD_GLEN:
		{
			match(CMD_GLEN);
			helper.setCommand(CMD_GET_LENGTH);
			break;
		}
		case CMD_SET_LENGTH:
		{
			match(CMD_SET_LENGTH);
			helper.setCommand(CMD_SET_LENGTH);
			break;
		}
		case CMD_SLEN:
		{
			match(CMD_SLEN);
			helper.setCommand(CMD_SET_LENGTH);
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
	}
	
	public final void parameter_list() throws RecognitionException, TokenStreamException {
		
		
				Parameter p = null;
			
		
		p=parameter();
		
					helper.writeParameter(p);
				
		{
		_loop927:
		do {
			if ((LA(1)==COMMA)) {
				match(COMMA);
				p=parameter();
				
					 		helper.writeParameter(p);
					 	
			}
			else {
				break _loop927;
			}
			
		} while (true);
		}
	}
	
	public final int  dec_val() throws RecognitionException, TokenStreamException {
		int r;
		
		Token  i = null;
		
			r = 0;
		
		
		i = LT(1);
		match(INT);
		r = Integer.parseInt(i.getText());
		return r;
	}
	
	public final Parameter  parameter() throws RecognitionException, TokenStreamException {
		Parameter param;
		
		Token  i = null;
		Token  s = null;
		
					Parameter valParam = null;
					ListParameter listParam = null;
					ListParameter workingList = null;
					PairParameter pairParam = null;
					param = null;
					String hex = null;
					
				
		
		switch ( LA(1)) {
		case IDENT:
		case INT:
		{
			{
			switch ( LA(1)) {
			case INT:
			{
				i = LT(1);
				match(INT);
				
							int r = Integer.parseInt(i.getText());
							valParam = new ValueParameter(r);
						
				break;
			}
			case IDENT:
			{
				s = LT(1);
				match(IDENT);
				{
				switch ( LA(1)) {
				case ASSIGN:
				{
					match(ASSIGN);
					hex=hex_val();
					break;
				}
				case LF:
				case COMMA:
				case RBRACKET:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
				}
				
							if (s != null && hex != null) {
								//it's a field-value-pair
								valParam = new PairParameter(s.getText(), hex);
							} else {
								//it's a normal ValueParameter
								valParam = new ValueParameter(s.getText());
							}
						
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			
						if (helper.topState() == TextCommandParserHelper.STATE_LIST_PARAMETER) {
							//Add a parameter to the current working list
							try {
								workingList = helper.popList();
								workingList.addParameter(valParam);
								helper.pushList(workingList);
								param = workingList;
							} catch (TextCommandParserException e) {/* nothing to handle */}
							//TODO: Evtl. recognition exception werfen
						} else {
							param = valParam;
						}
					
			break;
		}
		case LBRACKET:
		{
			listParam=list_val();
			
						if (helper.topState() == TextCommandParserHelper.STATE_LIST_PARAMETER) {
							//We have a nested list, add the current list to the (parent) working list
							try {
								workingList = helper.popList();
								workingList.addParameter(listParam);
								param = workingList;
							} catch (TextCommandParserException e) {/* nothing to handle */}
							//TODO: Evtl. recognition exception werfen
						} else {
							//Normal case, push list to the parameter stack
							param = listParam;
						}		
					
			break;
		}
		default:
			if ((_tokenSet_3.member(LA(1)))) {
				valParam=keyword2ident();
				
							/* because a keyword has higher priority than an identifier, command_name is 
							   matched here mistakenly. Just handle it as a normal identifier. */
							if (helper.topState() == TextCommandParserHelper.STATE_LIST_PARAMETER) {
								//Add a parameter to the current working list
								try {
									workingList = helper.popList();
									workingList.addParameter(valParam);
									helper.pushList(workingList);
									param = workingList;
								} catch (TextCommandParserException e) {/* nothing to handle */}
								//TODO: Evtl. recognition exception werfen
							} else {
								param = valParam;
							}  
							   
						
			}
		else {
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		return param;
	}
	
	public final String  hex_val() throws RecognitionException, TokenStreamException {
		String hex;
		
		Token  s = null;
		Token  i = null;
		
				hex = null;
			
		
		switch ( LA(1)) {
		case IDENT:
		{
			s = LT(1);
			match(IDENT);
			
						hex = s.getText();
					
			break;
		}
		case INT:
		{
			i = LT(1);
			match(INT);
			
						hex = i.getText();
					
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		return hex;
	}
	
	public final ListParameter  list_val() throws RecognitionException, TokenStreamException {
		ListParameter listParam;
		
		
				Parameter p = null;
				listParam = null;
				ListParameter workingList = null;
			
		
		match(LBRACKET);
		
					//Create a new list and push it to the list stack to use it as the working list
					workingList = new ListParameter();
					//workingList.addParameter(p);
					helper.pushList(workingList);
					helper.pushState(TextCommandParserHelper.STATE_LIST_PARAMETER);
				
		{
		if ((_tokenSet_2.member(LA(1)))) {
			p=parameter();
			{
			_loop936:
			do {
				if ((LA(1)==COMMA)) {
					match(COMMA);
					parameter();
				}
				else {
					break _loop936;
				}
				
			} while (true);
			}
		}
		else if ((LA(1)==RBRACKET)) {
		}
		else {
			throw new NoViableAltException(LT(1), getFilename());
		}
		
		}
		match(RBRACKET);
		
					//Remove the working list and return it
					try {
						workingList = helper.popList();
						helper.popState();
						listParam = workingList;
					} catch (TextCommandParserException e) { /* nothing to handle here */ }
					//TODO: Evtl. RecognitionException werfen	
				
				
		return listParam;
	}
	
	public final ValueParameter  keyword2ident() throws RecognitionException, TokenStreamException {
		ValueParameter p;
		
			p = null;	
		
		
					Token s = LT(1);
					p = new ValueParameter(s.getText());
				
		{
		switch ( LA(1)) {
		case READERDEVICE:
		{
			match(READERDEVICE);
			break;
		}
		case RD:
		{
			match(RD);
			break;
		}
		case SOURCE:
		{
			match(SOURCE);
			break;
		}
		case SRC:
		{
			match(SRC);
			break;
		}
		case READPOINT:
		{
			match(READPOINT);
			break;
		}
		case RP:
		{
			match(RP);
			break;
		}
		case TAGSELECTOR:
		{
			match(TAGSELECTOR);
			break;
		}
		case TS:
		{
			match(TS);
			break;
		}
		case DATASELECTOR:
		{
			match(DATASELECTOR);
			break;
		}
		case DS:
		{
			match(DS);
			break;
		}
		case NOTIFICATIONCHANNEL:
		{
			match(NOTIFICATIONCHANNEL);
			break;
		}
		case NC:
		{
			match(NC);
			break;
		}
		case TRIGGER:
		{
			match(TRIGGER);
			break;
		}
		case TRG:
		{
			match(TRG);
			break;
		}
		case COMMANDCHANNEL:
		{
			match(COMMANDCHANNEL);
			break;
		}
		case CC:
		{
			match(CC);
			break;
		}
		case EVENTTYPE:
		{
			match(EVENTTYPE);
			break;
		}
		case ET:
		{
			match(ET);
			break;
		}
		case TRIGGERTYPE:
		{
			match(TRIGGERTYPE);
			break;
		}
		case TT:
		{
			match(TT);
			break;
		}
		case FIELDNAME:
		{
			match(FIELDNAME);
			break;
		}
		case FN:
		{
			match(FN);
			break;
		}
		case IOPORTS:
		{
			match(IOPORTS);
			break;
		}
		case IOP:
		{
			match(IOP);
			break;
		}
		case TAGFIELD:
		{
			match(TAGFIELD);
			break;
		}
		case TF:
		{
			match(TF);
			break;
		}
		case CMD_CREATE:
		{
			match(CMD_CREATE);
			break;
		}
		case CMD_C:
		{
			match(CMD_C);
			break;
		}
		case CMD_GETEPC:
		{
			match(CMD_GETEPC);
			break;
		}
		case CMD_GE:
		{
			match(CMD_GE);
			break;
		}
		case CMD_GETMANUFACTURER:
		{
			match(CMD_GETMANUFACTURER);
			break;
		}
		case CMD_GMAN:
		{
			match(CMD_GMAN);
			break;
		}
		case CMD_GETMODEL:
		{
			match(CMD_GETMODEL);
			break;
		}
		case CMD_GMOD:
		{
			match(CMD_GMOD);
			break;
		}