/*-------------------------------------------------------------------------------*/ /* MessageCoorParser.cpp 7-Oct-99 28-Oct-99 Coor Command Parsing split onto separate files */ /*-------------------------------------------------------------------------------*/ #include "stdafx.h" #include "GlobalConstants.h" #include "CustomDataTypes.h" #include "MessageCommand.h" #include "MessageCoorParser.h" #include "MessageKeywordsCoorL1FW.h" #include "MessageKeywordsCoorL1CT.h" #include "MessageKeywordsTrgMgr.h" #include "HandleConsole.h" #include "UtilsStrings.h" /*-------------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------------*/ CMessageCoorParser::CMessageCoorParser () { ///////////////////////////////////////////////////////////////////// #define ADD_COMMAND( COMMAND ) \ m_oKeywordDictionary.AddEntry ( Ks_CoorCmd_##COMMAND##, \ Ki_CoorCmd_##COMMAND## ) ; \ ///////////////////////////////////////////////////////////////////// #define ADD_SUB_COMMAND( SUB_COMMAND ) \ m_oKeywordDictionary.AddEntry ( Ks_CoorSubCmd_##SUB_COMMAND##, \ Ki_CoorSubCmd_##SUB_COMMAND## );\ ///////////////////////////////////////////////////////////////////// #define ADD_KEYWORD( SUB_COMMAND ) \ m_oKeywordDictionary.AddEntry ( Ks_CoorKeyword_##SUB_COMMAND##, \ Ki_CoorKeyword_##SUB_COMMAND##);\ ///////////////////////////////////////////////////////////////////// ADD_COMMAND ( L1FW_Configure ) ADD_COMMAND ( L1FW_Initialize ) ADD_COMMAND ( Init ) ADD_COMMAND ( SCL_Initialize ) ADD_COMMAND ( Start_run ) ADD_COMMAND ( Stop_run ) ADD_COMMAND ( Begin_block ) ADD_COMMAND ( End_block ) ADD_COMMAND ( Configure ) ADD_COMMAND ( Abort ) ADD_COMMAND ( Pause_Run ) ADD_COMMAND ( Resume_Run ) ADD_COMMAND ( L1FW_Pause ) ADD_COMMAND ( L1FW_Resume ) ADD_COMMAND ( Begin_store ) ADD_COMMAND ( End_store ) ADD_COMMAND ( L1FW_Expo_Group ) ADD_COMMAND ( L1FW_Spec_Trig ) ADD_SUB_COMMAND ( And_Or_List ) ADD_SUB_COMMAND ( Geo_Sect_List ) ADD_SUB_COMMAND ( Expo_Group ) ADD_SUB_COMMAND ( L1_Qualifier ) ADD_SUB_COMMAND ( Obey_FE_Busy ) ADD_SUB_COMMAND ( Obey_Correlated_Disable ) ADD_SUB_COMMAND ( Obey_DeCorrelated_Disable ) ADD_SUB_COMMAND ( Obey_Individual_Disable ) ADD_SUB_COMMAND ( Auto_Disabled ) ADD_SUB_COMMAND ( Auto_Disable ) ADD_SUB_COMMAND ( Re_Enable ) ADD_SUB_COMMAND ( Coor_Enable ) ADD_SUB_COMMAND ( Prescale ) ADD_SUB_COMMAND ( Deallocate ) ADD_COMMAND ( L1CT_Ref_Set ) ADD_SUB_COMMAND ( EM_Et_Ref_Set ) ADD_SUB_COMMAND ( HD_Veto_Ref_Set ) ADD_SUB_COMMAND ( TOT_Et_Ref_Set ) ADD_SUB_COMMAND ( Large_Tile_Ref_Set ) ADD_COMMAND ( L1CT_Count_Threshold ) ADD_SUB_COMMAND ( EM_Et_Towers ) ADD_SUB_COMMAND ( TOT_Et_Towers ) ADD_COMMAND ( L1CT_Energy_Threshold ) ADD_SUB_COMMAND ( EM_Et ) ADD_SUB_COMMAND ( HD_Et ) ADD_SUB_COMMAND ( TOT_Et ) ADD_SUB_COMMAND ( Miss_Pt ) ADD_COMMAND ( L1CT_Exclude ) ADD_SUB_COMMAND ( EM_Tower ) ADD_SUB_COMMAND ( HD_Tower ) ADD_KEYWORD ( Ref_Set ) ADD_KEYWORD ( Comparator ) ADD_KEYWORD ( Value ) ADD_KEYWORD ( TT_Eta ) ADD_KEYWORD ( TT_Phi ) } /*-------------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------------*/ CMessageCoorParser::~CMessageCoorParser () { } /*-------------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------------*/ ECoorMessageStatus CMessageCoorParser::ParseCoorMessage ( CMessageCommandLine* _poCoorCommandLine ) { ECoorMessageStatus eReturnStatus = Reply_Ok ; ECoorMessageStatus eStatus ; //\\// // first step is to break this line down into tokens //////////////////////////////////////////////////// eStatus = ParseTokenize ( _poCoorCommandLine ) ; if ( eStatus != Reply_Ok ) { eReturnStatus = eStatus ; goto Done ; } // second step is to interpret the tokens // and turn them into one or more commands ////////////////////////////////////////////// //We have already enforced during the tokenization that the first token is a Keyword if ( _poCoorCommandLine->m_lTokenList.FirstEntry()->GetValue() <= Ki_CoorCmd_MaxID_L1FW ) eStatus = ParseInterpret_L1FW ( _poCoorCommandLine ) ; else eStatus = ParseInterpret_L1CT ( _poCoorCommandLine ) ; if ( eStatus != Reply_Ok ) { eReturnStatus = eStatus ; goto Done ; } Done: return eReturnStatus ; } /*-------------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------------*/ ECoorMessageStatus CMessageCoorParser::ParseTokenize ( CMessageCommandLine* _poCoorCommandLine ) { ECoorMessageStatus eReturnStatus = Reply_Ok ; char sToken[KiMaxLengthKeywordInMessageCommand] ; TBinomialEntry< char, unsigned int > * poKeywordEntry ; ETokenType eValueModifier = TokenIsNotDefined ; ETokenType eLastValueModifier = TokenIsNotDefined ; char sReplyText[KiMaxLengthReplyTextToCoor] ; TokenLocAndType oTokenLocAndType ; //\\// //first check there is a command on the line _poCoorCommandLine->GetNextToken ( sToken ) ; if ( sToken[0] == NULL ) { eReturnStatus = Reply_Bad ; strcpy ( sReplyText, "" ) ; CConsoleAccess::ErrorLine ( sReplyText ) ; _poCoorCommandLine->CopyReplyText ( sReplyText ) ; goto Done ; } else { if ( m_oKeywordDictionary.LocateEntry ( sToken ) == NULL ) { eReturnStatus = Reply_Bad ; strcpy ( sReplyText, "" ) ; CConsoleAccess::ErrorLine ( sReplyText ) ; _poCoorCommandLine->CopyReplyText ( sReplyText ) ; goto Done ; } } //then take one token at a time and record it while ( sToken[0] != NULL ) { // See if this is a number if ( ( sToken[0] >= '0') && ( sToken[0] <= '9' ) ) { // The first character was a number. // Now ALL characters should be numbers if ( strspn ( sToken, "1234567890" ) != strlen ( sToken ) ) { eReturnStatus = Reply_Bad ; strcpy ( sReplyText, "CurTokenCharNum() ) ) ; strcat ( sReplyText, " in Command String>" ) ; CConsoleAccess::ErrorLine ( sReplyText ) ; _poCoorCommandLine->CopyReplyText ( sReplyText ) ; goto Done ; } // If there was no hint of the token type for this number // (i.e. negated, or upper bound,..), it is simply asserted if ( eValueModifier == TokenIsNotDefined ) eValueModifier = TokenIsValueAsserted ; // register this number, with modifier prepared earlier oTokenLocAndType.uiCharNum = _poCoorCommandLine->CurTokenCharNum() ; oTokenLocAndType.eTokenType = eValueModifier ; _poCoorCommandLine->m_lTokenList.AddEntry ( oTokenLocAndType, A_to_uI ( sToken ) ) ; // reset Value modifier eValueModifier = TokenIsNotDefined ; } // See if this is the decimal point else if ( sToken[0] == '.' ) { eLastValueModifier = _poCoorCommandLine->m_lTokenList.LastEntry()->GetKey().eTokenType ; if ( eLastValueModifier != TokenIsValueAsserted ) { eReturnStatus = Reply_Bad ; strcpy ( sReplyText, "CurTokenCharNum() ) ) ; strcat ( sReplyText, " in Command String>" ) ; CConsoleAccess::ErrorLine ( sReplyText ) ; _poCoorCommandLine->CopyReplyText ( sReplyText ) ; goto Done ; } // prepare the token type for the next token to be the decimal field part of a number eValueModifier = TokenIsValueDecimal ; } // See if this is the special character of Negation/Veto else if ( sToken[0] == '-' ) { // check that there is no conflict with a previous declared porarity if ( eValueModifier == TokenIsValueAsserted ) { eReturnStatus = Reply_Bad ; strcpy ( sReplyText, "CurTokenCharNum() ) ) ; strcat ( sReplyText, " in Command String>" ) ; CConsoleAccess::ErrorLine ( sReplyText ) ; _poCoorCommandLine->CopyReplyText ( sReplyText ) ; goto Done ; } // prepare the token type for the next token to be a negated number if ( eValueModifier == TokenIsValueUpper ) eValueModifier = TokenIsValueUpperNeg ; else eValueModifier = TokenIsValueNegated ; } // See if this is the special character of Assertion // it is not required, and mostly ignored, // but recording its occurence will prevent (almost) all illegal usage else if ( sToken[0] == '+' ) { // check that there is no conflict with a previous declared porarity if ( ( eValueModifier == TokenIsValueNegated ) || ( eValueModifier == TokenIsValueUpperNeg ) ) { eReturnStatus = Reply_Bad ; strcpy ( sReplyText, "CurTokenCharNum() ) ) ; strcat ( sReplyText, " in Command String>" ) ; CConsoleAccess::ErrorLine ( sReplyText ) ; _poCoorCommandLine->CopyReplyText ( sReplyText ) ; goto Done ; } if ( eValueModifier != TokenIsValueUpper ) eValueModifier = TokenIsValueAsserted ; } // See if this is an open parenthesis character else if ( sToken[0] == '(' ) { if ( eValueModifier != TokenIsNotDefined ) { eReturnStatus = Reply_Bad ; strcpy ( sReplyText, "CurTokenCharNum() ) ) ; strcat ( sReplyText, " in Command String>" ) ; CConsoleAccess::ErrorLine ( sReplyText ) ; _poCoorCommandLine->CopyReplyText ( sReplyText ) ; goto Done ; } // register this syntax character oTokenLocAndType.uiCharNum = _poCoorCommandLine->CurTokenCharNum() ; oTokenLocAndType.eTokenType = TokenIsOpenParenthesis ; _poCoorCommandLine->m_lTokenList.AddEntry ( oTokenLocAndType, (unsigned int) 0 ) ; } // See if this is a close parenthesis character else if ( sToken[0] == ')' ) { if ( eValueModifier != TokenIsNotDefined ) { eReturnStatus = Reply_Bad ; strcpy ( sReplyText, "CurTokenCharNum() ) ) ; strcat ( sReplyText, " in Command String>" ) ; CConsoleAccess::ErrorLine ( sReplyText ) ; _poCoorCommandLine->CopyReplyText ( sReplyText ) ; goto Done ; } // register this syntax character oTokenLocAndType.uiCharNum = _poCoorCommandLine->CurTokenCharNum() ; oTokenLocAndType.eTokenType = TokenIsCloseParenthesis ; _poCoorCommandLine->m_lTokenList.AddEntry ( oTokenLocAndType, (unsigned int) 0 ) ; } // See if this is the special character of Value Range else if ( sToken[0] == ':' ) { eLastValueModifier = _poCoorCommandLine->m_lTokenList.LastEntry()->GetKey().eTokenType ; if ( ( eLastValueModifier != TokenIsValueAsserted ) && ( eLastValueModifier != TokenIsValueNegated ) ) { eReturnStatus = Reply_Bad ; strcpy ( sReplyText, "CurTokenCharNum() ) ) ; strcat ( sReplyText, " in Command String>" ) ; CConsoleAccess::ErrorLine ( sReplyText ) ; _poCoorCommandLine->CopyReplyText ( sReplyText ) ; goto Done ; } // Change the Token type for the previous number to be a Lower Bound oTokenLocAndType.uiCharNum = _poCoorCommandLine->m_lTokenList.LastEntry()->GetKey().uiCharNum ; if ( eLastValueModifier == TokenIsValueAsserted ) oTokenLocAndType.eTokenType = TokenIsValueLower ; else //( eLastValueModifier == TokenIsValueNegated ) oTokenLocAndType.eTokenType = TokenIsValueLowerNeg ; _poCoorCommandLine->m_lTokenList.ModifyLastEntryKey ( oTokenLocAndType ) ; // Prepare the token type for the next token to be an upper bound number eValueModifier = TokenIsValueUpper ; } else //otherwise it must be a keyword { if ( eValueModifier != TokenIsNotDefined ) { eReturnStatus = Reply_Bad ; strcpy ( sReplyText, "CurTokenCharNum() ) ) ; strcat ( sReplyText, " in Command String>" ) ; CConsoleAccess::ErrorLine ( sReplyText ) ; _poCoorCommandLine->CopyReplyText ( sReplyText ) ; goto Done ; } poKeywordEntry = m_oKeywordDictionary.LocateEntry ( sToken ) ; if ( poKeywordEntry != NULL ) { oTokenLocAndType.uiCharNum = _poCoorCommandLine->CurTokenCharNum() ; oTokenLocAndType.eTokenType = TokenIsKeyword ; _poCoorCommandLine->m_lTokenList.AddEntry ( oTokenLocAndType, poKeywordEntry->GetValue() ) ; } else { eReturnStatus = Reply_Bad ; strcpy ( sReplyText, "CurTokenCharNum() ) ) ; strcat ( sReplyText, " in Command String>" ) ; CConsoleAccess::ErrorLine ( sReplyText ) ; _poCoorCommandLine->CopyReplyText ( sReplyText ) ; goto Done ; } } // Go find the next token on the line, if any _poCoorCommandLine->GetNextToken ( sToken ) ; } Done: return eReturnStatus ; } /*-------------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------------*/ //Macros for error messages used in the ParseInterpret_L1FW and ParseInterpret_L1CT below ///////////////////////////////////////////////////////////////////////////// #define ERROR_COMMON_PRE() \ { eReturnStatus = Reply_Bad ; \ ///////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// #define ERROR_COMMON_POST() \ strcat ( sReplyText, " at Char #" ) ; \ if ( poTokenEntry == NULL ) \ poTokenEntry = _poCoorCommandLine->m_lTokenList.LastEntry( ) ; \ strcat ( sReplyText, I_to_A (poTokenEntry->GetKey().uiCharNum) ) ; \ strcat ( sReplyText, " in Command String>" ) ; \ CConsoleAccess::ErrorLine ( sReplyText ) ; \ _poCoorCommandLine->CopyReplyText ( sReplyText ) ; \ goto Done ; \ } \ ///////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// #define ERROR_UNEXPECTED_TOKEN() \ ERROR_COMMON_PRE() \ strcpy ( sReplyText, "" ) ; \ CConsoleAccess::ErrorLine ( sReplyText ) ; \ _poCoorCommandLine->CopyReplyText ( sReplyText ) ; \ goto Done ; \ } \ ///////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// #define SWAP_UI_VALUES( uiValue1, uiValue2 ) \ { \ unsigned int uitemp ; \ uitemp = uiValue1 ; \ uiValue1 = uiValue2 ; \ uiValue2 = uitemp ; \ } \ ///////////////////////////////////////////////////////////////////////////// /*-------------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------------*/ ECoorMessageStatus CMessageCoorParser::ParseInterpret_L1FW ( CMessageCommandLine* _poCoorCommandLine ) { ECoorMessageStatus eReturnStatus = Reply_Ok ; char sReplyText[KiMaxLengthReplyTextToCoor] ; TBinomialEntry< TokenLocAndType, unsigned int > * poTokenEntry ; TBinomialEntry< TokenLocAndType, unsigned int > * poTokenFirstSubCommand ; TList < unsigned int, EItemPolarity > lObjectList ; TBinomialEntry < unsigned int, EItemPolarity >* poObjectEntry ; CMessageCommand* poCoorCommand ; ETokenType eTokenType ; unsigned int uiCoorCmdCode ; unsigned int uiCoorCmdSubCode ; unsigned int uiValue ; unsigned int uiObjectIndex ; unsigned int uiObjectIndexLower ; unsigned int uiObjectIndexUpper ; EItemPolarity eObjectPolarity ; EItemPolarity eItemPolarity ; unsigned int uiItemIndex ; unsigned int uiItemIndexLower ; unsigned int uiItemIndexUpper ; //\\// poTokenEntry = _poCoorCommandLine->m_lTokenList.FirstEntry( ) ; //We have already enforced during the tokenization that the first token is a Keyword uiCoorCmdCode = poTokenEntry->GetValue ( ) ; //Create the first command in the Command List _poCoorCommandLine->m_lCommandList.AddEntry ( new CMessageCommand, new unsigned int (0) ) ; //Get at the Created command poCoorCommand = _poCoorCommandLine->m_lCommandList.LastEntry()->GetAtKey( ) ; //record the command Code poCoorCommand->m_uiCoorCmdCode = uiCoorCmdCode ; poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; switch ( uiCoorCmdCode ) { ///////////////////////////////////////////////////////////////////////////// // single keyword commands ///////////////////////////////////////////////////////////////////////////// case Ki_CoorCmd_L1FW_Configure ://[L1FW_Configure] case Ki_CoorCmd_Init ://[Init] case Ki_CoorCmd_SCL_Initialize ://[SCL_Initialize] case Ki_CoorCmd_L1FW_Pause ://[L1fw_Pause] case Ki_CoorCmd_L1FW_Resume ://[L1fw_Resume] case Ki_CoorCmd_Begin_block ://[Begin_Block] -- No Reply case Ki_CoorCmd_End_block ://[End_Block] -- No Reply case Ki_CoorCmd_Configure ://[Configure] -- No Reply case Ki_CoorCmd_Abort ://[Abort] -- No Reply { if ( poTokenEntry != NULL ) ERROR_UNEXPECTED_TOKEN() ; } ; break ; ///////////////////////////////////////////////////////////////////////////// // single keyword with single number ///////////////////////////////////////////////////////////////////////////// case Ki_CoorCmd_Pause_Run ://[Pause_Run runno] case Ki_CoorCmd_Resume_Run ://[Resume_Run runno] case Ki_CoorCmd_Stop_run ://[Stop_Run runno] case Ki_CoorCmd_Begin_store ://[Begin_Store storenum] case Ki_CoorCmd_End_store ://[End_Store storenum] { if ( poTokenEntry == NULL ) ERROR_MISSING_NUMBER() ; eTokenType = poTokenEntry->GetKey().eTokenType ; if ( eTokenType != TokenIsValueAsserted ) ERROR_NUMBER_NOT_ASSERTED() ; poCoorCommand->m_uiValue = poTokenEntry->GetValue ( ) ; poCoorCommand->m_eValuePolarity = ItemAsserted ; poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; if ( poTokenEntry != NULL ) ERROR_UNEXPECTED_TOKEN() ; } ; break ; ///////////////////////////////////////////////////////////////////////////// // single keyword with single number and Item List ///////////////////////////////////////////////////////////////////////////// case Ki_CoorCmd_Start_run ://[Start_Run runno spectrigs] { if ( poTokenEntry == NULL ) ERROR_MISSING_NUMBER() ; eTokenType = poTokenEntry->GetKey().eTokenType ; if ( eTokenType != TokenIsValueAsserted ) ERROR_NUMBER_NOT_ASSERTED() ; poCoorCommand->m_uiValue = poTokenEntry->GetValue ( ) ; poCoorCommand->m_eValuePolarity = ItemAsserted ; poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; if ( poTokenEntry == NULL ) ERROR_MISSING_NUMBER_LIST() ; while ( poTokenEntry != NULL ) { eTokenType = poTokenEntry->GetKey().eTokenType ; if ( ( eTokenType != TokenIsValueAsserted ) && ( eTokenType != TokenIsValueLower ) ) ERROR_NUMBER_NOT_ASSERTED() ; if ( eTokenType != TokenIsValueLower ) { uiItemIndex = poTokenEntry->GetValue ( ) ; if ( uiItemIndex > KiMaxIndexInCoorCmd_SpecTrig ) ERROR_OBJECT_NUMBER_OUT_OF_RANGE() ; poCoorCommand->m_aubItemPolarity[uiItemIndex] = ItemAsserted ; } else { uiItemIndexLower = poTokenEntry->GetValue ( ) ; poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; if ( poTokenEntry == NULL ) ERROR_MISSING_UPPER_BOUND() ; eTokenType = poTokenEntry->GetKey().eTokenType ; if ( eTokenType != TokenIsValueUpper ) ERROR_MISSING_UPPER_BOUND() ; uiItemIndexUpper = poTokenEntry->GetValue ( ) ; if ( ( uiItemIndexLower > KiMaxIndexInCoorCmd_SpecTrig ) || ( uiItemIndexUpper > KiMaxIndexInCoorCmd_SpecTrig ) ) ERROR_OBJECT_NUMBER_OUT_OF_RANGE() ; if ( uiItemIndexLower > uiItemIndexUpper ) SWAP_UI_VALUES( uiItemIndexLower, uiItemIndexUpper ) ; for ( uiItemIndex = uiItemIndexLower ; uiItemIndex <= uiItemIndexUpper ; uiItemIndex ++ ) poCoorCommand->m_aubItemPolarity[uiItemIndex] = ItemAsserted ; } poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; } } ; break ; ///////////////////////////////////////////////////////////////////////////// // complex commands with first a list of numbers, then another keyword ///////////////////////////////////////////////////////////////////////////// case Ki_CoorCmd_L1FW_Expo_Group ://[L1FW_Expo_Group] case Ki_CoorCmd_L1FW_Spec_Trig ://[L1FW_Spec_Trig] { //there must be at least one number if ( poTokenEntry == NULL ) ERROR_MISSING_NUMBER() ; eTokenType = poTokenEntry->GetKey().eTokenType ; if ( ( eTokenType != TokenIsValueAsserted ) && ( eTokenType != TokenIsValueNegated ) && ( eTokenType != TokenIsValueLower ) && ( eTokenType != TokenIsValueLowerNeg ) ) ERROR_MISSING_NUMBER() ; //there may be more than one number or range while ( poTokenEntry != NULL ) { eTokenType = poTokenEntry->GetKey().eTokenType ; if ( ( eTokenType != TokenIsValueAsserted ) && ( eTokenType != TokenIsValueNegated ) && ( eTokenType != TokenIsValueLower ) && ( eTokenType != TokenIsValueLowerNeg ) ) break ; // we are done with the object list, now on to the keywords switch ( eTokenType ) { case TokenIsValueAsserted : eObjectPolarity = ItemAsserted ; break ; case TokenIsValueNegated : eObjectPolarity = ItemNegated ; break ; case TokenIsValueLower : eObjectPolarity = ItemAsserted ; break ; case TokenIsValueLowerNeg : eObjectPolarity = ItemNegated ; break ; } uiObjectIndexLower = poTokenEntry->GetValue ( ) ; if ( ( eTokenType == TokenIsValueLower ) || ( eTokenType == TokenIsValueLowerNeg ) ) { poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; if ( poTokenEntry == NULL ) ERROR_MISSING_UPPER_BOUND() ; eTokenType = poTokenEntry->GetKey().eTokenType ; if ( ( eTokenType != TokenIsValueUpper ) && ( eTokenType != TokenIsValueUpperNeg ) ) ERROR_MISSING_UPPER_BOUND() ; if ( ( ( eObjectPolarity == ItemAsserted ) && ( eTokenType != TokenIsValueUpper ) ) || ( ( eObjectPolarity == ItemNegated ) && ( eTokenType != TokenIsValueUpperNeg ) ) ) ERROR_OPPOSITE_POLARITIES() ; uiObjectIndexUpper = poTokenEntry->GetValue ( ) ; } else uiObjectIndexUpper = uiObjectIndexLower ; if ( ( ( uiCoorCmdCode == Ki_CoorCmd_L1FW_Expo_Group ) && ( ( uiObjectIndexLower > KiMaxIndexInCoorCmd_ExpGroup ) || ( uiObjectIndexUpper > KiMaxIndexInCoorCmd_ExpGroup ) ) ) || ( ( uiCoorCmdCode == Ki_CoorCmd_L1FW_Spec_Trig ) && ( ( uiObjectIndexLower > KiMaxIndexInCoorCmd_SpecTrig ) || ( uiObjectIndexUpper > KiMaxIndexInCoorCmd_SpecTrig ) ) ) ) ERROR_OBJECT_NUMBER_OUT_OF_RANGE() ; if ( uiObjectIndexLower > uiObjectIndexUpper ) SWAP_UI_VALUES( uiObjectIndexLower, uiObjectIndexUpper ) ; for ( uiObjectIndex = uiObjectIndexLower ; uiObjectIndex <= uiObjectIndexUpper ; uiObjectIndex ++ ) lObjectList.AddEntry ( uiObjectIndex, eObjectPolarity ) ; poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; } if ( poTokenEntry == NULL ) ERROR_MISSING_SUB_KEYWORD() ; eTokenType = poTokenEntry->GetKey().eTokenType ; if ( eTokenType != TokenIsKeyword ) ERROR_MISSING_SUB_KEYWORD() ; // ************************************************************* // *** The label below is is where we jump back to accept // *** multiple specific trigger numbers // *** e.g. L1FW_Spec_Trig 0 -1 3 Obey_FE_Busy // *** We start with the first Object in the list, // *** and remember the current position in the token list // *** to restore and parse the line again // ************************************************************* poObjectEntry = lObjectList.FirstEntry ( ) ; poTokenFirstSubCommand = poTokenEntry ; ParseAllSubCommands : poTokenEntry = poTokenFirstSubCommand ; uiObjectIndex = poObjectEntry->GetKey() ; eObjectPolarity = poObjectEntry->GetValue() ; // ************************************************************* // *** this is where we jump back to accept multiple sub commands // *** e.g. L1FW_Spec_Trig 0 Prescale 1000 Coor_enable // ************************************************************* ParseNextSubCommand : uiCoorCmdSubCode = poTokenEntry->GetValue ( ) ; //Get at the Current command poCoorCommand = _poCoorCommandLine->m_lCommandList.LastEntry()->GetAtKey( ) ; //copy the command Code and object description to the command which may be new poCoorCommand->m_uiCoorCmdCode = uiCoorCmdCode ; poCoorCommand->m_uiObjectIndex = uiObjectIndex ; poCoorCommand->m_eObjectPolarity = eObjectPolarity ; poCoorCommand->m_uiCoorSubCmdCode = uiCoorCmdSubCode ; if ( ( ( uiCoorCmdCode == Ki_CoorCmd_L1FW_Expo_Group ) && ( ( uiCoorCmdSubCode != Ki_CoorSubCmd_Deallocate ) && ( uiCoorCmdSubCode != Ki_CoorSubCmd_Geo_Sect_List ) && ( uiCoorCmdSubCode != Ki_CoorSubCmd_And_Or_List ) ) ) || ( ( uiCoorCmdCode == Ki_CoorCmd_L1FW_Spec_Trig ) && ( ( uiCoorCmdSubCode != Ki_CoorSubCmd_Deallocate ) && ( uiCoorCmdSubCode != Ki_CoorSubCmd_Obey_FE_Busy ) && ( uiCoorCmdSubCode != Ki_CoorSubCmd_Obey_Correlated_Disable ) && ( uiCoorCmdSubCode != Ki_CoorSubCmd_Obey_DeCorrelated_Disable ) && ( uiCoorCmdSubCode != Ki_CoorSubCmd_Obey_Individual_Disable ) && ( uiCoorCmdSubCode != Ki_CoorSubCmd_Auto_Disabled ) && ( uiCoorCmdSubCode != Ki_CoorSubCmd_Re_Enable ) && ( uiCoorCmdSubCode != Ki_CoorSubCmd_Coor_Enable ) && ( uiCoorCmdSubCode != Ki_CoorSubCmd_Prescale ) && ( uiCoorCmdSubCode != Ki_CoorSubCmd_Expo_Group ) && ( uiCoorCmdSubCode != Ki_CoorSubCmd_L1_Qualifier ) && ( uiCoorCmdSubCode != Ki_CoorSubCmd_And_Or_List ) ) ) ) ERROR_ILLEGAL_SUB_KEYWORD() ; // Now that we know the sub-command we need to GO BACK TO CHECK // whether the Item was specified asserted or negated. // Only a few commands accept a negated item number if ( ( eObjectPolarity == ItemNegated ) // negated SpTrg only allowed for... && ( uiCoorCmdSubCode != Ki_CoorSubCmd_Obey_FE_Busy ) // ... Obey_FE_Busy && ( uiCoorCmdSubCode != Ki_CoorSubCmd_Obey_Correlated_Disable ) // ... Obey_Correlated_Disable && ( uiCoorCmdSubCode != Ki_CoorSubCmd_Obey_DeCorrelated_Disable ) // ... Obey_DeCorrelated_Disable && ( uiCoorCmdSubCode != Ki_CoorSubCmd_Obey_Individual_Disable ) // ... Obey_Individual_Disable && ( uiCoorCmdSubCode != Ki_CoorSubCmd_Auto_Disabled ) // ... Auto_Disabled && ( uiCoorCmdSubCode != Ki_CoorSubCmd_Coor_Enable ) ) // ... Coor_enable ERROR_SUB_KEYWORD_ONLY_FOR_ASSERTED_OBJECTS() ; poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; switch ( uiCoorCmdSubCode ) { ///////////////////////////////////////////////////////////////////////////// // single sub keyword commands ///////////////////////////////////////////////////////////////////////////// case Ki_CoorSubCmd_Deallocate ://[L1FW_ExposGroup N Deallocate] //[L1FW_Spec_Trig N Deallocate] case Ki_CoorSubCmd_Obey_FE_Busy ://[L1FW_Spec_Trig N Obey_FE_Busy] case Ki_CoorSubCmd_Auto_Disabled ://[L1FW_Spec_Trig N Auto_Disabled] case Ki_CoorSubCmd_Re_Enable ://[L1FW_Spec_Trig N Re_Enable] case Ki_CoorSubCmd_Coor_Enable ://[L1FW_Spec_Trig N Coor_enable] { if ( poTokenEntry != NULL ) { eTokenType = poTokenEntry->GetKey().eTokenType ; if ( eTokenType != TokenIsKeyword ) ERROR_UNEXPECTED_TOKEN() ; //Create another command in the Command List _poCoorCommandLine->m_lCommandList.AddEntry ( new CMessageCommand, new unsigned int (0) ) ; goto ParseNextSubCommand ; } } ; break ; ///////////////////////////////////////////////////////////////////////////// // single sub keyword with single number ///////////////////////////////////////////////////////////////////////////// case Ki_CoorSubCmd_Prescale ://[L1FW_Spec_Trig N Prescale PrescaleRatio] case Ki_CoorSubCmd_Expo_Group ://[L1FW_Spec_Trig N Expo_Group egnumber] case Ki_CoorSubCmd_Obey_Correlated_Disable ://[L1FW_Spec_Trig N Obey_Correlated_Disable CorrDisNum] case Ki_CoorSubCmd_Obey_DeCorrelated_Disable ://[L1FW_Spec_Trig N Obey_DeCorrelated_Disable CorrDisNum] case Ki_CoorSubCmd_Obey_Individual_Disable ://[L1FW_Spec_Trig N Obey_Individual_Disable IndivDisNum] { if ( poTokenEntry == NULL ) ERROR_MISSING_NUMBER() ; eTokenType = poTokenEntry->GetKey().eTokenType ; if ( eTokenType != TokenIsValueAsserted ) // !!! accept decimal value for prescale ERROR_NUMBER_NOT_ASSERTED() ; poCoorCommand->m_eValuePolarity = ItemAsserted ; uiValue = poTokenEntry->GetValue ( ) ; if ( ( ( uiCoorCmdSubCode == Ki_CoorSubCmd_Prescale ) && ( uiValue > KiMaxIndexInCoorCmd_Prescale ) ) || ( ( uiCoorCmdSubCode == Ki_CoorSubCmd_Expo_Group ) && ( uiValue > KiMaxIndexInCoorCmd_ExpGroup ) ) || ( ( uiCoorCmdSubCode == Ki_CoorSubCmd_Obey_Correlated_Disable ) && ( uiValue > KiMaxIndexInCoorCmd_CorrDis ) ) || ( ( uiCoorCmdSubCode == Ki_CoorSubCmd_Obey_DeCorrelated_Disable ) && ( uiValue > KiMaxIndexInCoorCmd_DeCorrDis ) ) || ( ( uiCoorCmdSubCode == Ki_CoorSubCmd_Obey_Individual_Disable ) && ( uiValue > KiMaxIndexInCoorCmd_IndivDis ) ) ) ERROR_OBJECT_NUMBER_OUT_OF_RANGE() ; poCoorCommand->m_uiValue = uiValue ; poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; if ( poTokenEntry != NULL ) { eTokenType = poTokenEntry->GetKey().eTokenType ; if ( eTokenType != TokenIsKeyword ) ERROR_UNEXPECTED_TOKEN() ; //Create another command in the Command List _poCoorCommandLine->m_lCommandList.AddEntry ( new CMessageCommand, new unsigned int (0) ) ; goto ParseNextSubCommand ; } } ; break ; ///////////////////////////////////////////////////////////////////////////// // single keyword with Item List ///////////////////////////////////////////////////////////////////////////// case Ki_CoorSubCmd_And_Or_List ://[L1FW_Expo_Group N And_Or_List aoterm-list] //[L1FW_Spec_Trig N And_Or_List aoterm-list] case Ki_CoorSubCmd_Geo_Sect_List ://[L1FW_Expo_Group N Geo_Sect_List geosect-list] case Ki_CoorSubCmd_L1_Qualifier ://[L1FW_Spec_Trig N L1_Qualifier l1qual-list] { if ( poTokenEntry == NULL ) ERROR_MISSING_NUMBER() ; while ( poTokenEntry != NULL ) { eTokenType = poTokenEntry->GetKey().eTokenType ; if ( ( eTokenType != TokenIsValueAsserted ) && ( eTokenType != TokenIsValueNegated ) && ( eTokenType != TokenIsValueLower ) && ( eTokenType != TokenIsValueLowerNeg ) ) { if ( eTokenType != TokenIsKeyword ) ERROR_UNEXPECTED_TOKEN() ; //Create another command in the Command List _poCoorCommandLine->m_lCommandList.AddEntry ( new CMessageCommand, new unsigned int (0) ) ; goto ParseNextSubCommand ; } switch ( eTokenType ) { case TokenIsValueAsserted : eItemPolarity = ItemAsserted ; break ; case TokenIsValueNegated : eItemPolarity = ItemNegated ; break ; case TokenIsValueLower : eItemPolarity = ItemAsserted ; break ; case TokenIsValueLowerNeg : eItemPolarity = ItemNegated ; break ; } if ( ( eItemPolarity == ItemNegated ) // negated/veto numbers only allowed here for ... && ( uiCoorCmdSubCode != Ki_CoorSubCmd_And_Or_List ) ) // ... andor terms ERROR_NUMBER_NOT_ASSERTED() ; uiItemIndexLower = poTokenEntry->GetValue ( ) ; if ( ( eTokenType == TokenIsValueLower ) || ( eTokenType == TokenIsValueLowerNeg ) ) { poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; if ( poTokenEntry == NULL ) ERROR_MISSING_UPPER_BOUND() ; eTokenType = poTokenEntry->GetKey().eTokenType ; if ( ( eTokenType != TokenIsValueUpper ) && ( eTokenType != TokenIsValueUpperNeg ) ) ERROR_MISSING_UPPER_BOUND() ; if ( ( ( eItemPolarity == ItemAsserted ) && ( eTokenType != TokenIsValueUpper ) ) || ( ( eItemPolarity == ItemNegated ) && ( eTokenType != TokenIsValueUpperNeg ) ) ) ERROR_OPPOSITE_POLARITIES() ; uiItemIndexUpper = poTokenEntry->GetValue ( ) ; } else uiItemIndexUpper = uiItemIndexLower ; if ( ( ( uiCoorCmdSubCode == Ki_CoorSubCmd_And_Or_List ) && ( ( uiItemIndexLower > KiMaxIndexInCoorCmd_AndorTerm ) || ( uiItemIndexUpper > KiMaxIndexInCoorCmd_AndorTerm ) ) ) || ( ( uiCoorCmdSubCode == Ki_CoorSubCmd_Geo_Sect_List ) && ( ( uiItemIndexLower > KiMaxIndexInCoorCmd_GeoSect ) || ( uiItemIndexUpper > KiMaxIndexInCoorCmd_GeoSect ) ) ) || ( ( uiCoorCmdSubCode == Ki_CoorSubCmd_L1_Qualifier ) && ( ( uiItemIndexLower > KiMaxIndexInCoorCmd_ExpGroup ) || ( uiItemIndexUpper > KiMaxIndexInCoorCmd_ExpGroup ) ) ) ) ERROR_OBJECT_NUMBER_OUT_OF_RANGE() ; if ( uiItemIndexLower > uiItemIndexUpper ) SWAP_UI_VALUES( uiItemIndexLower, uiItemIndexUpper ) ; for ( uiItemIndex = uiItemIndexLower ; uiItemIndex <= uiItemIndexUpper ; uiItemIndex ++ ) poCoorCommand->m_aubItemPolarity[uiItemIndex] = eItemPolarity ; poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; } } ; break ; // case Ki_CoorSubCmd_Geo_Sect_List & Ki_CoorSubCmd_L1_Qualifier } // switch SubCommandCode // now see if there were more Objects specified on this command line poObjectEntry = lObjectList.NextEntry( poObjectEntry ) ; if ( poObjectEntry != NULL ) { //Create another command in the Command List _poCoorCommandLine->m_lCommandList.AddEntry ( new CMessageCommand, new unsigned int (0) ) ; goto ParseAllSubCommands ; } } ; break ; ///////////////////////////////////////////////////////////////////////////// default : ERROR_KEYWORD_ILLEGAL_AT_START() ; } ; Done: return eReturnStatus ; } /*-------------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------------*/ ECoorMessageStatus CMessageCoorParser::ParseInterpret_L1CT ( CMessageCommandLine* _poCoorCommandLine ) { ECoorMessageStatus eReturnStatus = Reply_Ok ; char sReplyText[KiMaxLengthReplyTextToCoor] ; TBinomialEntry< TokenLocAndType, unsigned int > * poTokenEntry ; // TBinomialEntry< ETokenType, unsigned int > * poTokenFirstSubCommand ; TList < unsigned int, EItemPolarity > lObjectList ; // TBinomialEntry < unsigned int, EItemPolarity >* poObjectEntry ; CMessageCommand* poCoorCommand ; ETokenType eTokenType ; unsigned int uiCoorCmdCode ; unsigned int uiCoorCmdSubCode ; unsigned int uiKeyword ; unsigned int uiRefSetNum ; unsigned int uiObjectIndex ; unsigned int uiItemIndex ; unsigned int uiItemIndexLower ; unsigned int uiItemIndexUpper ; ETT_Eta_Sign ePolarityIndexLower ; ETT_Eta_Sign ePolarityIndexUpper ; //\\// poTokenEntry = _poCoorCommandLine->m_lTokenList.FirstEntry( ) ; //We have already enforced during the tokenization that the first token is a Keyword uiCoorCmdCode = poTokenEntry->GetValue ( ) ; //Create the first command in the Command List _poCoorCommandLine->m_lCommandList.AddEntry ( new CMessageCommand, new unsigned int (0) ) ; //Get at the Created command poCoorCommand = _poCoorCommandLine->m_lCommandList.LastEntry()->GetAtKey( ) ; //record the command Code poCoorCommand->m_uiCoorCmdCode = uiCoorCmdCode ; poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; switch ( uiCoorCmdCode ) { ///////////////////////////////////////////////////////////////////////////// // Reference Set Difinition //[L1CT_Ref_Set EM_Et_Ref_Set 0 TT_Eta(-20:20) TT_Phi(1:32) Value 10.0] //[L1CT_Ref_Set HD_Veto_Ref_Set 0 TT_Eta(-20:20) TT_Phi(1:32) Value 10.0] //[L1CT_Ref_Set TOT_Et_Ref_Set 0 TT_Eta(-20:20) TT_Phi(1:32) Value 10.0] //[L1CT_Ref_Set Large_Tile_Ref_Set 0 TT_Eta(-20:20) TT_Phi(1:32) Value 10.0] ///////////////////////////////////////////////////////////////////////////// case Ki_CoorCmd_L1CT_Ref_Set ://[Ki_CoorCmd_L1CT_Ref_Set] { // next keyword should be the type of reference set if ( poTokenEntry == NULL ) ERROR_MISSING_SUB_KEYWORD() ; eTokenType = poTokenEntry->GetKey().eTokenType ; if ( eTokenType != TokenIsKeyword ) ERROR_MISSING_SUB_KEYWORD() ; uiCoorCmdSubCode = poTokenEntry->GetValue ( ) ; if ( ( uiCoorCmdSubCode != Ki_CoorSubCmd_EM_Et_Ref_Set ) && ( uiCoorCmdSubCode != Ki_CoorSubCmd_HD_Veto_Ref_Set ) && ( uiCoorCmdSubCode != Ki_CoorSubCmd_TOT_Et_Ref_Set ) && ( uiCoorCmdSubCode != Ki_CoorSubCmd_Large_Tile_Ref_Set ) ) ERROR_ILLEGAL_SUB_KEYWORD() ; //copy the SubCommand Code poCoorCommand->m_uiCoorSubCmdCode = uiCoorCmdSubCode ; // next keyword should be the reference set number poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; // next keyword should be the reference set number if ( poTokenEntry == NULL ) ERROR_MISSING_NUMBER() ; eTokenType = poTokenEntry->GetKey().eTokenType ; if ( eTokenType != TokenIsValueAsserted ) ERROR_NUMBER_NOT_ASSERTED() ; uiRefSetNum = poTokenEntry->GetValue ( ) ; if ( ( ( uiCoorCmdSubCode != Ki_CoorSubCmd_Large_Tile_Ref_Set ) && ( uiRefSetNum > KiMaxIndexInCoorCmd_TTRefSet ) ) || ( ( uiCoorCmdSubCode == Ki_CoorSubCmd_Large_Tile_Ref_Set ) && ( uiRefSetNum > KiMaxIndexInCoorCmd_LTRefSet ) ) ) ERROR_OBJECT_NUMBER_OUT_OF_RANGE() ; //copy the Ref Set Number poCoorCommand->m_uiRefSetNum = uiRefSetNum ; // Next Token may be either "TT_Eta", "TT_Phi", or directly 'Value" // or "Deallocate" poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; Look_For_TT_Range_RefSet : if ( poTokenEntry == NULL ) ERROR_MISSING_SUB_KEYWORD() ; eTokenType = poTokenEntry->GetKey().eTokenType ; if ( eTokenType != TokenIsKeyword ) ERROR_MISSING_SUB_KEYWORD() ; uiKeyword = poTokenEntry->GetValue ( ) ; if ( uiKeyword == Ki_CoorSubCmd_Deallocate ) { switch ( uiCoorCmdSubCode ) { case Ki_CoorSubCmd_EM_Et_Ref_Set : poCoorCommand->m_uiCoorSubCmdCode = Ki_CoorSubCmd_EM_Et_Ref_Set_Deallocate ; break ; case Ki_CoorSubCmd_HD_Veto_Ref_Set : poCoorCommand->m_uiCoorSubCmdCode = Ki_CoorSubCmd_HD_Veto_Ref_Set_Deallocate ; break ; case Ki_CoorSubCmd_TOT_Et_Ref_Set : poCoorCommand->m_uiCoorSubCmdCode = Ki_CoorSubCmd_TOT_Et_Ref_Set_Deallocate ; break ; case Ki_CoorSubCmd_Large_Tile_Ref_Set : poCoorCommand->m_uiCoorSubCmdCode = Ki_CoorSubCmd_Large_Tile_Ref_Set_Deallocate ; break ; } // there should be no more tokens on the line poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; if ( poTokenEntry != NULL ) ERROR_UNEXPECTED_TOKEN() ; goto Done ; } ///////////////////////////////////////////////////////////////////////////////////////////////// #define PARSE_TT_RANGE( LABEL_Look_For_TT_Range ) \ /*** Next Token should be an open parenthesis ***/\ poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; \ \ if ( poTokenEntry == NULL ) \ ERROR_MISSING_OPEN_PARENTHESIS() ; \ \ eTokenType = poTokenEntry->GetKey().eTokenType ; \ \ if ( eTokenType != TokenIsOpenParenthesis ) \ ERROR_MISSING_OPEN_PARENTHESIS() ; \ \ \ /*** Next Token should be a Positive or Negative Value or Lower Bound ***/\ poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; \ \ while ( poTokenEntry != NULL ) \ { \ \ eTokenType = poTokenEntry->GetKey().eTokenType ; \ \ uiItemIndex = poTokenEntry->GetValue ( ) ; \ \ /*** check index magnitude ***/\ if ( ( ( uiKeyword == Ki_CoorKeyword_TT_Eta ) \ && ( uiItemIndex > KiMax_TT_Eta_Magn ) ) \ || ( ( uiKeyword == Ki_CoorKeyword_TT_Phi ) \ && ( uiItemIndex > KiMax_TT_Phi ) ) ) \ ERROR_OBJECT_NUMBER_OUT_OF_RANGE() ; \ \ switch ( eTokenType ) \ { \ /*** plain indices ***/\ case TokenIsValueAsserted : \ if ( uiKeyword == Ki_CoorKeyword_TT_Eta ) \ poCoorCommand->m_xTT.aalTT_Eta[eTT_Eta_Pos][uiItemIndex] = true ; \ else /* ( uiKeyword == Ki_CoorKeyword_TT_Phi ) */ \ poCoorCommand->m_xTT.alTT_Phi[uiItemIndex] = true ; \ break ; \ \ case TokenIsValueNegated : \ if ( uiKeyword == Ki_CoorKeyword_TT_Eta ) \ poCoorCommand->m_xTT.aalTT_Eta[eTT_Eta_Neg][uiItemIndex] = true ; \ else /* ( uiKeyword == Ki_CoorKeyword_TT_Phi ) */ \ ERROR_NUMBER_NOT_ASSERTED() ; \ break ; \ \ /*** Lower Bounds ***/\ case TokenIsValueLower : \ case TokenIsValueLowerNeg : \ \ uiItemIndexLower = uiItemIndex ; \ \ /*** Remember if the lower bound was a positive or negative ***/\ if ( eTokenType == TokenIsValueLower ) \ ePolarityIndexLower = eTT_Eta_Pos ; \ else /* eTokenType == TokenIsValueLowerNeg ) */ \ ePolarityIndexLower = eTT_Eta_Neg ; \ \ /*** Next token should be the upper bound ***/\ poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry(poTokenEntry);\ \ if ( poTokenEntry == NULL ) \ ERROR_MISSING_UPPER_BOUND() ; \ \ eTokenType = poTokenEntry->GetKey().eTokenType ; \ \ /*** Remember if the upper bound was a positive or negative ***/\ if ( eTokenType == TokenIsValueUpper ) \ ePolarityIndexUpper = eTT_Eta_Pos ; \ else if ( eTokenType == TokenIsValueUpperNeg ) \ ePolarityIndexUpper = eTT_Eta_Neg ; \ else \ ERROR_MISSING_UPPER_BOUND() ; \ \ /*** Remember if the lower bound was a positive or negative ***/\ uiItemIndexUpper = poTokenEntry->GetValue ( ) ; \ \ /*** check index magnitude ***/\ if ( ( ( uiKeyword == Ki_CoorKeyword_TT_Eta ) \ && ( uiItemIndexUpper > KiMax_TT_Eta_Magn ) ) \ || ( ( uiKeyword == Ki_CoorKeyword_TT_Phi ) \ && ( uiItemIndexUpper > KiMax_TT_Phi ) ) ) \ ERROR_OBJECT_NUMBER_OUT_OF_RANGE() ; \ \ /*** fill Eta Range while watching for crossing index zero ***/\ if ( uiKeyword == Ki_CoorKeyword_TT_Eta ) \ { \ if ( ePolarityIndexLower == ePolarityIndexUpper ) \ { \ if ( uiItemIndexLower > uiItemIndexUpper ) \ SWAP_UI_VALUES( uiItemIndexLower, uiItemIndexUpper ) ; \ \ for ( uiItemIndex = uiItemIndexLower ; \ uiItemIndex <= uiItemIndexUpper ; \ uiItemIndex ++ ) \ poCoorCommand->m_xTT.aalTT_Eta[ePolarityIndexLower][uiItemIndex]\ = true ; \ } \ else /* ( ePolarityIndexLower != ePolarityIndexUpper ) */ \ { \ for ( uiItemIndex = 1 ; \ uiItemIndex <= uiItemIndexLower ; \ uiItemIndex ++ ) \ poCoorCommand->m_xTT.aalTT_Eta[ePolarityIndexLower][uiItemIndex]\ = true ; \ \ for ( uiItemIndex = 1 ; \ uiItemIndex <= uiItemIndexUpper ; \ uiItemIndex ++ ) \ poCoorCommand->m_xTT.aalTT_Eta[ePolarityIndexUpper][uiItemIndex]\ = true ; \ } \ } \ /*** fill Phi Range ***/\ else /* ( uiKeyword == Ki_CoorKeyword_TT_Phi ) */ \ { \ if ( ( ePolarityIndexLower != Asserted ) \ || ( ePolarityIndexUpper != Asserted ) ) \ ERROR_NUMBER_NOT_ASSERTED() ; \ \ if ( uiItemIndexLower > uiItemIndexUpper ) \ SWAP_UI_VALUES( uiItemIndexLower, uiItemIndexUpper ) ; \ \ for ( uiItemIndex = uiItemIndexLower ; \ uiItemIndex <= uiItemIndexUpper ; \ uiItemIndex ++ ) \ poCoorCommand->m_xTT.alTT_Phi[uiItemIndex] = true ; \ } \ break ; \ \ \ case TokenIsCloseParenthesis : \ \ /*** Get the next token before jumping to interpret rest of command ***/\ poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry(poTokenEntry);\ goto LABEL_Look_For_TT_Range ; \ break ; \ \ default : \ ERROR_UNEXPECTED_TOKEN() ; \ \ } /* switch ( eTokenType ) */ \ \ /*** Get the next token before "while" test ***/\ poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; \ \ }/* while ( poTokenEntry != NULL ) */ \ \ ERROR_MISSING_CLOSE_PARENTHESIS() ; \ ///////////////////////////////////////////////////////////////////////////////////////////////// if ( ( uiKeyword == Ki_CoorKeyword_TT_Eta ) || ( uiKeyword == Ki_CoorKeyword_TT_Phi ) ) { PARSE_TT_RANGE( Look_For_TT_Range_RefSet ) ; } else if ( uiKeyword != Ki_CoorKeyword_Value ) ERROR_UNEXPECTED_TOKEN() ; //Get the Threshold Value ///////////////////////////////////////////////////////////////////////////////////////////////// #define GET_THRESHOLD_FLOAT_VALUE() \ /*** first token is always the integral part of the threhold ***/\ poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; \ \ if ( poTokenEntry == NULL ) \ ERROR_MISSING_NUMBER() ; \ \ eTokenType = poTokenEntry->GetKey().eTokenType ; \ \ if ( eTokenType != TokenIsValueAsserted ) \ ERROR_NUMBER_NOT_ASSERTED() ; \ \ /*** copy the integer part of the Ref Set Threshold Value ***/\ poCoorCommand->m_fdThreshold = (double) poTokenEntry->GetValue ( ) ; \ \ /*** there may be an additional token for the decimal part ***/\ poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; \ \ if ( poTokenEntry != NULL ) \ { \ eTokenType = poTokenEntry->GetKey().eTokenType ; \ \ if ( eTokenType == TokenIsValueDecimal ) \ { \ \ /*** compute the location of the decimal point ***/\ const char* pcDecimalPoint ; \ pcDecimalPoint = _poCoorCommandLine->GetAtChar( \ poTokenEntry->GetKey().uiCharNum - 1 ) ; \ /*** convert the string to double float and add it to the integral part ***/\ char* pcEndChar ; \ poCoorCommand->m_fdThreshold += strtod ( pcDecimalPoint, &pcEndChar ) ; \ \ /*** get the next token ***/\ poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; \ } \ } \ ///////////////////////////////////////////////////////////////////////////////////////////////// GET_THRESHOLD_FLOAT_VALUE() ; // there should be no more tokens on the line if ( poTokenEntry != NULL ) ERROR_UNEXPECTED_TOKEN() ; // if the Eta range was omitted, this means all Eta values are selected ///////////////////////////////////////////////////////////////////////////////////////////////// #define FILL_ETA_RANGE_IF_OMITTED() \ { \ bool lEtaRangeEmpty = true ; \ for ( uiItemIndex = 1 ; uiItemIndex <= KiMax_TT_Eta_Magn ; uiItemIndex ++ ) \ if ( ( poCoorCommand->m_xTT.aalTT_Eta[eTT_Eta_Pos][uiItemIndex] == true ) \ || ( poCoorCommand->m_xTT.aalTT_Eta[eTT_Eta_Neg][uiItemIndex] == true ) ) \ { \ lEtaRangeEmpty = false ; \ break ; \ } \ if ( lEtaRangeEmpty ) \ for ( uiItemIndex = 1 ; uiItemIndex <= KiMax_TT_Eta_Magn ; uiItemIndex ++ ) \ { \ poCoorCommand->m_xTT.aalTT_Eta[eTT_Eta_Pos][uiItemIndex] = true ; \ poCoorCommand->m_xTT.aalTT_Eta[eTT_Eta_Neg][uiItemIndex] = true ; \ } \ } \ ///////////////////////////////////////////////////////////////////////////////////////////////// FILL_ETA_RANGE_IF_OMITTED() ; // if the Phi range was omitted, this means all Phi values are selected ///////////////////////////////////////////////////////////////////////////////////////////////// #define FILL_PHI_RANGE_IF_OMITTED() \ { \ bool lPhiRangeEmpty = true ; \ for ( uiItemIndex = 1 ; uiItemIndex <= KiMax_TT_Phi ; uiItemIndex ++ ) \ if ( poCoorCommand->m_xTT.alTT_Phi[uiItemIndex] == true ) \ { \ lPhiRangeEmpty = false ; \ break ; \ } \ if ( lPhiRangeEmpty ) \ for ( uiItemIndex = 1 ; uiItemIndex <= KiMax_TT_Phi ; uiItemIndex ++ ) \ poCoorCommand->m_xTT.alTT_Phi[uiItemIndex] = true ; \ } \ ///////////////////////////////////////////////////////////////////////////////////////////////// FILL_PHI_RANGE_IF_OMITTED() ; //one last thing to check for large tile ref sets //that is whether the TT range does not cut any LT boundary if ( uiCoorCmdSubCode == Ki_CoorSubCmd_Large_Tile_Ref_Set ) { unsigned int uiRelItemIndex ; bool lTTRangeIllegal = false ; for ( uiItemIndex = 1 ; uiItemIndex <= KiMax_TT_Phi ; uiItemIndex += KiMax_LT_Phi_Width ) for ( uiRelItemIndex = 0 ; uiRelItemIndex < KiMax_LT_Phi_Width ; uiRelItemIndex++ ) if ( poCoorCommand->m_xTT.alTT_Phi[uiItemIndex] != poCoorCommand->m_xTT.alTT_Phi[uiItemIndex+uiRelItemIndex] ) lTTRangeIllegal = true ; for ( uiItemIndex = 1 ; uiItemIndex <= KiMax_TT_Eta_Magn ; uiItemIndex += KiMax_LT_Eta_Width ) for ( uiRelItemIndex = 0 ; uiRelItemIndex < KiMax_LT_Eta_Width ; uiRelItemIndex++ ) if ( ( poCoorCommand->m_xTT.aalTT_Eta[eTT_Eta_Pos][uiItemIndex] != poCoorCommand->m_xTT.aalTT_Eta[eTT_Eta_Pos][uiItemIndex+uiRelItemIndex] ) || ( poCoorCommand->m_xTT.aalTT_Eta[eTT_Eta_Neg][uiItemIndex] != poCoorCommand->m_xTT.aalTT_Eta[eTT_Eta_Neg][uiItemIndex+uiRelItemIndex] ) ) lTTRangeIllegal = true ; if ( lTTRangeIllegal ) ERROR_ILLEGAL_LARGE_TILE_RANGE() ; } } break ; ///////////////////////////////////////////////////////////////////////////// // Global Count Threshold //[L1CT_Count_Threshold EM_Et_Towers Ref_Set 0 Comparator 1 Value 1] //[L1CT_Count_Threshold TOT_Et_Towers Ref_Set 0 Comparator 1 Value 1] ///////////////////////////////////////////////////////////////////////////// case Ki_CoorCmd_L1CT_Count_Threshold ://[Ki_CoorCmd_L1CT_Count_Threshold] // next keyword should be the type of reference set if ( poTokenEntry == NULL ) ERROR_MISSING_SUB_KEYWORD() ; eTokenType = poTokenEntry->GetKey().eTokenType ; if ( eTokenType != TokenIsKeyword ) ERROR_MISSING_SUB_KEYWORD() ; uiCoorCmdSubCode = poTokenEntry->GetValue ( ) ; if ( ( uiCoorCmdSubCode != Ki_CoorSubCmd_EM_Et_Towers ) && ( uiCoorCmdSubCode != Ki_CoorSubCmd_TOT_Et_Towers ) ) ERROR_ILLEGAL_SUB_KEYWORD() ; //copy the SubCommand Code poCoorCommand->m_uiCoorSubCmdCode = uiCoorCmdSubCode ; // next keyword should be the word "ref_set" poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; if ( poTokenEntry == NULL ) ERROR_MISSING_SUB_KEYWORD() ; eTokenType = poTokenEntry->GetKey().eTokenType ; if ( eTokenType != TokenIsKeyword ) ERROR_MISSING_SUB_KEYWORD() ; if ( poTokenEntry->GetValue() != Ki_CoorKeyword_Ref_Set ) ERROR_ILLEGAL_SUB_KEYWORD() ; // next keyword should be the reference set number poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; if ( poTokenEntry == NULL ) ERROR_MISSING_NUMBER() ; eTokenType = poTokenEntry->GetKey().eTokenType ; if ( eTokenType != TokenIsValueAsserted ) ERROR_NUMBER_NOT_ASSERTED() ; uiRefSetNum = poTokenEntry->GetValue ( ) ; if ( uiRefSetNum > KiMaxIndexInCoorCmd_TTRefSet ) ERROR_OBJECT_NUMBER_OUT_OF_RANGE() ; //copy the Ref Set Number poCoorCommand->m_uiRefSetNum = uiRefSetNum ; // next keyword should be "Comparator" followed by a number ///////////////////////////////////////////////////////////////////////////////////////////////// #define GET_COMPARATOR() \ /*** next keyword should be the word "Comparator" ***/\ poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; \ \ if ( poTokenEntry == NULL ) \ ERROR_MISSING_SUB_KEYWORD() ; \ \ eTokenType = poTokenEntry->GetKey().eTokenType ; \ \ if ( eTokenType != TokenIsKeyword ) \ ERROR_MISSING_SUB_KEYWORD() ; \ \ if ( poTokenEntry->GetValue() != Ki_CoorKeyword_Comparator ) \ ERROR_ILLEGAL_SUB_KEYWORD() ; \ \ /*** next keyword should be the Comparator number ***/\ poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; \ \ if ( poTokenEntry == NULL ) \ ERROR_MISSING_NUMBER() ; \ \ eTokenType = poTokenEntry->GetKey().eTokenType ; \ \ if ( eTokenType != TokenIsValueAsserted ) \ ERROR_NUMBER_NOT_ASSERTED() ; \ \ uiObjectIndex = poTokenEntry->GetValue ( ) ; \ \ if ( uiObjectIndex > KiMaxIndexInCoorCmd_CompCount ) \ ERROR_OBJECT_NUMBER_OUT_OF_RANGE() ; \ \ /*** copy the Comparator Number ***/\ poCoorCommand->m_uiObjectIndex = uiObjectIndex ; \ ///////////////////////////////////////////////////////////////////////////////////////////////// GET_COMPARATOR() ; // next keyword should be Value followed by a number poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; if ( poTokenEntry == NULL ) ERROR_MISSING_SUB_KEYWORD() ; eTokenType = poTokenEntry->GetKey().eTokenType ; if ( eTokenType != TokenIsKeyword ) ERROR_MISSING_SUB_KEYWORD() ; if ( poTokenEntry->GetValue() != Ki_CoorKeyword_Value ) ERROR_ILLEGAL_SUB_KEYWORD() ; // Get the Threshold Value // Count thresholds must always be integral (not float) poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; if ( poTokenEntry == NULL ) ERROR_MISSING_NUMBER() ; eTokenType = poTokenEntry->GetKey().eTokenType ; if ( eTokenType != TokenIsValueAsserted ) ERROR_NUMBER_NOT_ASSERTED() ; // copy the Threshold Value poCoorCommand->m_uiValue = poTokenEntry->GetValue ( ) ; // there should be no more tokens on the line poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; if ( poTokenEntry != NULL ) ERROR_UNEXPECTED_TOKEN() ; break ; ///////////////////////////////////////////////////////////////////////////// // Global Energy Threshold //[L1CT_Energy_Threshold EM_Et Comparator 0 Value 40.0] //[L1CT_Energy_Threshold HD_Et Comparator 0 Value 55.5] //[L1CT_Energy_Threshold TOT_Et Comparator 0 Value 55.5] //[L1CT_Energy_Threshold Miss_Pt Comparator 0 Value 40.0] ///////////////////////////////////////////////////////////////////////////// case Ki_CoorCmd_L1CT_Energy_Threshold ://[Ki_CoorCmd_L1CT_Energy_Threshold] // next keyword should be the type of Energy Quantity if ( poTokenEntry == NULL ) ERROR_MISSING_SUB_KEYWORD() ; eTokenType = poTokenEntry->GetKey().eTokenType ; if ( eTokenType != TokenIsKeyword ) ERROR_MISSING_SUB_KEYWORD() ; uiCoorCmdSubCode = poTokenEntry->GetValue ( ) ; if ( ( uiCoorCmdSubCode != Ki_CoorSubCmd_EM_Et ) && ( uiCoorCmdSubCode != Ki_CoorSubCmd_HD_Et ) && ( uiCoorCmdSubCode != Ki_CoorSubCmd_TOT_Et ) && ( uiCoorCmdSubCode != Ki_CoorSubCmd_Miss_Pt ) ) ERROR_ILLEGAL_SUB_KEYWORD() ; //copy the SubCommand Code poCoorCommand->m_uiCoorSubCmdCode = uiCoorCmdSubCode ; // next keyword should be "Comparator" followed by a number GET_COMPARATOR() ; // next keyword should be "Value" followed by a number poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; if ( poTokenEntry == NULL ) ERROR_MISSING_SUB_KEYWORD() ; eTokenType = poTokenEntry->GetKey().eTokenType ; if ( eTokenType != TokenIsKeyword ) ERROR_MISSING_SUB_KEYWORD() ; if ( poTokenEntry->GetValue() != Ki_CoorKeyword_Value ) ERROR_ILLEGAL_SUB_KEYWORD() ; // Get the Threshold Value GET_THRESHOLD_FLOAT_VALUE() ; // there should be no more tokens on the line if ( poTokenEntry != NULL ) ERROR_UNEXPECTED_TOKEN() ; break ; ///////////////////////////////////////////////////////////////////////////// // Exclude Trigger Tower //[L1CT_Exclude EM_Tower TT_Eta(20) TT_Phi(23)] //[L1CT_Exclude HD_Tower TT_Eta(20) TT_Phi(23)] ///////////////////////////////////////////////////////////////////////////// case Ki_CoorCmd_L1CT_Exclude ://[Ki_CoorCmd_L1CT_Exclude] // next keyword should be the type of Trigger Tower if ( poTokenEntry == NULL ) ERROR_MISSING_SUB_KEYWORD() ; eTokenType = poTokenEntry->GetKey().eTokenType ; if ( eTokenType != TokenIsKeyword ) ERROR_MISSING_SUB_KEYWORD() ; uiCoorCmdSubCode = poTokenEntry->GetValue ( ) ; if ( ( uiCoorCmdSubCode != Ki_CoorSubCmd_EM_Tower ) && ( uiCoorCmdSubCode != Ki_CoorSubCmd_HD_Tower ) ) ERROR_ILLEGAL_SUB_KEYWORD() ; //copy the SubCommand Code poCoorCommand->m_uiCoorSubCmdCode = uiCoorCmdSubCode ; // Next Token may be either "TT_Eta", "TT_Phi", or even nothing poTokenEntry = _poCoorCommandLine->m_lTokenList.NextEntry( poTokenEntry ) ; Look_For_TT_Range_Exclude : if ( poTokenEntry != NULL ) { eTokenType = poTokenEntry->GetKey().eTokenType ; if ( eTokenType != TokenIsKeyword ) ERROR_MISSING_SUB_KEYWORD() ; uiKeyword = poTokenEntry->GetValue ( ) ; if ( ( uiKeyword == Ki_CoorKeyword_TT_Eta ) || ( uiKeyword == Ki_CoorKeyword_TT_Phi ) ) { PARSE_TT_RANGE( Look_For_TT_Range_Exclude ) ; } else ERROR_UNEXPECTED_TOKEN() ; } // if the Eta range was omitted, this means all Eta values are selected FILL_ETA_RANGE_IF_OMITTED() ; // if the Phi range was omitted, this means all Phi values are selected FILL_PHI_RANGE_IF_OMITTED() ; break ; ///////////////////////////////////////////////////////////////////////////// default : ERROR_KEYWORD_ILLEGAL_AT_START() ; } ; Done: return eReturnStatus ; }