1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 #include <precomp.h> 23 #include <s2_luidl/pe_enum2.hxx> 24 25 26 // NOT FULLY DECLARED SERVICES 27 #include <ary/idl/i_enum.hxx> 28 #include <ary/idl/i_enumvalue.hxx> 29 #include <ary/idl/i_gate.hxx> 30 #include <ary/idl/ip_ce.hxx> 31 #include <ary/doc/d_oldidldocu.hxx> 32 #include <s2_luidl/pe_evalu.hxx> 33 #include <s2_luidl/tk_punct.hxx> 34 #include <s2_luidl/tk_ident.hxx> 35 #include <s2_luidl/tk_keyw.hxx> 36 37 38 namespace csi 39 { 40 namespace uidl 41 { 42 43 44 #ifdef DF 45 #undef DF 46 #endif 47 #define DF &PE_Enum::On_Default 48 49 PE_Enum::F_TOK 50 PE_Enum::aDispatcher[PE_Enum::e_STATES_MAX][PE_Enum::tt_MAX] = 51 { { DF, DF }, // e_none 52 { &PE_Enum::On_expect_name_Identifier, 53 DF }, // expect_name 54 { DF, &PE_Enum::On_expect_curl_bracket_open_Punctuation }, // expect_curl_bracket_open 55 { &PE_Enum::On_expect_value_Identifier, 56 &PE_Enum::On_expect_value_Punctuation }, // expect_value 57 { DF, &PE_Enum::On_expect_finish_Punctuation } // expect_finish 58 }; 59 60 61 62 inline void 63 PE_Enum::CallHandler( const char * i_sTokenText, 64 E_TokenType i_eTokenType ) 65 { (this->*aDispatcher[eState][i_eTokenType])(i_sTokenText); } 66 67 68 69 70 PE_Enum::PE_Enum() 71 : eState(e_none), 72 sData_Name(), 73 nDataId(0), 74 pPE_Value(0), 75 sName(), 76 sAssignment() 77 { 78 pPE_Value = new PE_Value(sName, sAssignment, false); 79 } 80 81 void 82 PE_Enum::EstablishContacts( UnoIDL_PE * io_pParentPE, 83 ary::Repository & io_rRepository, 84 TokenProcessing_Result & o_rResult ) 85 { 86 UnoIDL_PE::EstablishContacts(io_pParentPE,io_rRepository,o_rResult); 87 pPE_Value->EstablishContacts(this,io_rRepository,o_rResult); 88 } 89 90 PE_Enum::~PE_Enum() 91 { 92 } 93 94 void 95 PE_Enum::ProcessToken( const Token & i_rToken ) 96 { 97 i_rToken.Trigger(*this); 98 } 99 100 void 101 PE_Enum::Process_Identifier( const TokIdentifier & i_rToken ) 102 { 103 CallHandler(i_rToken.Text(), tt_identifier); 104 } 105 106 void 107 PE_Enum::Process_Punctuation( const TokPunctuation & i_rToken ) 108 { 109 CallHandler(i_rToken.Text(), tt_punctuation); 110 } 111 112 void 113 PE_Enum::On_expect_name_Identifier(const char * i_sText) 114 { 115 sName = i_sText; 116 117 SetResult(done,stay); 118 eState = expect_curl_bracket_open; 119 } 120 121 void 122 PE_Enum::On_expect_curl_bracket_open_Punctuation(const char * i_sText) 123 { 124 if ( i_sText[0] == '{') 125 { 126 sData_Name = sName; 127 ary::idl::Enum & 128 rCe = Gate().Ces().Store_Enum(CurNamespace().CeId(), sData_Name); 129 PassDocuAt(rCe); 130 nDataId = rCe.CeId(); 131 132 SetResult(done,stay); 133 eState = expect_value; 134 } 135 else 136 { 137 On_Default(i_sText); 138 } 139 } 140 141 void 142 PE_Enum::On_expect_value_Punctuation(const char * i_sText) 143 { 144 if ( i_sText[0] == '}' ) 145 { 146 SetResult(done,stay); 147 eState = expect_finish; 148 } 149 else 150 { 151 On_Default(i_sText); 152 } 153 } 154 155 void 156 PE_Enum::On_expect_value_Identifier(const char *) 157 { 158 SetResult( not_done, push_sure, pPE_Value.Ptr() ); 159 } 160 161 void 162 PE_Enum::On_expect_finish_Punctuation(const char * i_sText) 163 { 164 if ( i_sText[0] == ';') 165 { 166 SetResult(done,pop_success); 167 eState = e_none; 168 } 169 else 170 { 171 On_Default(i_sText); 172 } 173 } 174 175 void 176 PE_Enum::On_Default(const char * ) 177 { 178 SetResult(not_done,pop_failure); 179 eState = e_none; 180 } 181 182 void 183 PE_Enum::EmptySingleValueData() 184 { 185 sName = ""; 186 sAssignment = ""; 187 } 188 189 void 190 PE_Enum::CreateSingleValue() 191 { 192 ary::idl::EnumValue & 193 rCe = Gate().Ces().Store_EnumValue( nDataId, sName, sAssignment ); 194 pPE_Value->PassDocuAt(rCe); 195 } 196 197 void 198 PE_Enum::InitData() 199 { 200 eState = expect_name; 201 202 sData_Name.clear(); 203 nDataId = 0; 204 205 EmptySingleValueData(); 206 } 207 208 void 209 PE_Enum::ReceiveData() 210 { 211 switch (eState) 212 { 213 case expect_value: 214 { 215 if (sName.length() == 0) 216 { 217 On_Default(""); 218 break; 219 } 220 221 CreateSingleValue(); 222 EmptySingleValueData(); 223 } break; 224 default: 225 SetResult(not_done, pop_failure); 226 eState = e_none; 227 } // end switch 228 } 229 230 void 231 PE_Enum::TransferData() 232 { 233 csv_assert(sData_Name.length() > 0); 234 eState = e_none; 235 } 236 237 UnoIDL_PE & 238 PE_Enum::MyPE() 239 { 240 return *this; 241 } 242 243 } // namespace uidl 244 } // namespace csi 245 246