autodoc/source/parser/cpp/pe_param.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: pe_param.cxx,v $
  10  * $Revision: 1.11 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include <precomp.h>
  32 #include "pe_param.hxx"
  33
  34
  35 // NOT FULLY DEFINED SERVICES
  36 #include <cosv/tpl/tpltools.hxx>
  37 #include <ary/cpp/c_gate.hxx>
  38 #include <ary/cpp/cp_type.hxx>
  39 #include "pe_type.hxx"
  40 #include "pe_vari.hxx"
  41
  42
  43 namespace cpp {
  44
  45
  46
  47 //***********************               PE_Parameter            ***********************//
  48
  49
  50 PE_Parameter::PE_Parameter( Cpp_PE * i_pParent )
  51     :   Cpp_PE(i_pParent),
  52         pStati( new PeStatusArray<PE_Parameter> )
  53         // pSpType,
  54         // pSpuType,
  55         // pSpVariable,
  56         // pSpuVariable,
  57         // aResultParamInfo
  58 {
  59     Setup_StatusFunctions();
  60
  61     pSpType         = new SP_Type(*this);
  62     pSpuType        = new SPU_Type(*pSpType, &PE_Parameter::SpInit_Type, &PE_Parameter::SpReturn_Type);
  63     pSpVariable     = new SP_Variable(*this);
  64     pSpuVariable    = new SPU_Variable(*pSpVariable, &PE_Parameter::SpInit_Variable, &PE_Parameter::SpReturn_Variable);
  65 }
  66
  67 PE_Parameter::~PE_Parameter()
  68 {
  69 }
  70
  71 void
  72 PE_Parameter::Call_Handler( const cpp::Token & i_rTok )
  73 {
  74     pStati->Cur().Call_Handler(i_rTok.TypeId(), i_rTok.Text());
  75 }
  76
  77 void
  78 PE_Parameter::Setup_StatusFunctions()
  79 {
  80     typedef CallFunction<PE_Parameter>::F_Tok   F_Tok;
  81     static F_Tok stateF_start[] =                       { &PE_Parameter::On_start_Type,
  82                                               &PE_Parameter::On_start_Type,
  83                                               &PE_Parameter::On_start_Type,
  84                                               &PE_Parameter::On_start_Type,
  85                                               &PE_Parameter::On_start_Type,
  86
  87                                               &PE_Parameter::On_start_Type,
  88                                               &PE_Parameter::On_start_Type,
  89                                               &PE_Parameter::On_start_Bracket_Right,
  90                                               &PE_Parameter::On_start_Type,
  91                                               &PE_Parameter::On_start_Ellipse,
  92
  93                                               &PE_Parameter::On_start_Type,
  94                                               &PE_Parameter::On_start_Type,
  95                                               &PE_Parameter::On_start_Type };
  96     static INT16 stateT_start[] =               { Tid_Identifier,
  97                                               Tid_class,
  98                                               Tid_struct,
  99                                               Tid_union,
 100                                               Tid_enum,
 101
 102                                               Tid_const,
 103                                               Tid_volatile,
 104                                               Tid_Bracket_Right,
 105                                               Tid_DoubleColon,
 106                                               Tid_Ellipse,
 107
 108                                               Tid_typename,
 109                                               Tid_BuiltInType,
 110                                               Tid_TypeSpecializer };
 111
 112     static F_Tok stateF_expectName[] =          { &PE_Parameter::On_expectName_Identifier,
 113                                               &PE_Parameter::On_expectName_ArrayBracket_Left,
 114                                               &PE_Parameter::On_expectName_Bracket_Right,
 115                                               &PE_Parameter::On_expectName_Comma,
 116                                               &PE_Parameter::On_afterName_Assign  };
 117     static INT16 stateT_expectName[] =          { Tid_Identifier,
 118                                               Tid_ArrayBracket_Left,
 119                                               Tid_Bracket_Right,
 120                                               Tid_Comma,
 121                                               Tid_Assign };
 122     static F_Tok stateF_afterName[] =           { &PE_Parameter::On_afterName_ArrayBracket_Left,
 123                                               &PE_Parameter::On_afterName_Bracket_Right,
 124                                               &PE_Parameter::On_afterName_Comma,
 125                                               &PE_Parameter::On_afterName_Assign };
 126     static INT16 stateT_afterName[] =           { Tid_ArrayBracket_Left,
 127                                               Tid_Bracket_Right,
 128                                               Tid_Comma,
 129                                               Tid_Assign };
 130     static F_Tok stateF_finished[] =            { &PE_Parameter::On_finished_Comma,
 131                                               &PE_Parameter::On_finished_Bracket_Right };
 132     static INT16 stateT_finished[] =            { Tid_Bracket_Right,
 133                                               Tid_Comma };
 134
 135     SEMPARSE_CREATE_STATUS(PE_Parameter, start, Hdl_SyntaxError);
 136     SEMPARSE_CREATE_STATUS(PE_Parameter, expectName, Hdl_SyntaxError);
 137     SEMPARSE_CREATE_STATUS(PE_Parameter, afterName, Hdl_SyntaxError);
 138     SEMPARSE_CREATE_STATUS(PE_Parameter, finished, Hdl_SyntaxError);
 139 }
 140
 141
 142 void
 143 PE_Parameter::InitData()
 144 {
 145     pStati->SetCur(start);
 146     aResultParamInfo.Empty();
 147 }
 148
 149 void
 150 PE_Parameter::TransferData()
 151 {
 152     pStati->SetCur(size_of_states);
 153 }
 154
 155 void
 156 PE_Parameter::Hdl_SyntaxError( const char * i_sText)
 157 {
 158     StdHandlingOfSyntaxError(i_sText);
 159 }
 160
 161 void
 162 PE_Parameter::SpInit_Type()
 163 {
 164     // Does nothing.
 165 }
 166
 167 void
 168 PE_Parameter::SpInit_Variable()
 169 {
 170     // Does nothing.
 171 }
 172
 173 void
 174 PE_Parameter::SpReturn_Type()
 175 {
 176     aResultParamInfo.nType = pSpuType->Child().Result_Type().Id();
 177     pStati->SetCur(expectName);
 178 }
 179
 180 void
 181 PE_Parameter::SpReturn_Variable()
 182 {
 183     if (pSpuVariable->Child().Result_Pattern() > 0)
 184     {
 185         aResultParamInfo.sSizeExpression = pSpuVariable->Child().Result_SizeExpression();
 186         aResultParamInfo.sInitExpression = pSpuVariable->Child().Result_InitExpression();
 187     }
 188 }
 189
 190 void
 191 PE_Parameter::On_start_Type(const char *)
 192 {
 193     pSpuType->Push(not_done);
 194 }
 195
 196 void
 197 PE_Parameter::On_start_Bracket_Right(const char *)
 198 {
 199     SetTokenResult(not_done, pop_success);
 200 }
 201
 202 void
 203 PE_Parameter::On_start_Ellipse(const char *)
 204 {
 205     SetTokenResult(done, pop_success);
 206
 207     aResultParamInfo.nType = Env().AryGate().Types().Tid_Ellipse();
 208 }
 209
 210 void
 211 PE_Parameter::On_expectName_Identifier(const char * i_sText)
 212 {
 213     SetTokenResult(done, stay);
 214     pStati->SetCur(afterName);
 215
 216     aResultParamInfo.sName = i_sText;
 217 }
 218
 219 void
 220 PE_Parameter::On_expectName_ArrayBracket_Left(const char * i_sText)
 221 {
 222     On_afterName_ArrayBracket_Left(i_sText);
 223 }
 224
 225 void
 226 PE_Parameter::On_expectName_Bracket_Right(const char * i_sText)
 227 {
 228     On_afterName_Bracket_Right(i_sText);
 229 }
 230
 231 void
 232 PE_Parameter::On_expectName_Comma(const char * i_sText)
 233 {
 234     On_afterName_Comma(i_sText);
 235 }
 236
 237 void
 238 PE_Parameter::On_afterName_ArrayBracket_Left(const char *)
 239 {
 240     pSpuVariable->Push(not_done);
 241 }
 242
 243 void
 244 PE_Parameter::On_afterName_Bracket_Right(const char *)
 245 {
 246     SetTokenResult(not_done, pop_success);
 247 }
 248
 249 void
 250 PE_Parameter::On_afterName_Comma(const char *)
 251 {
 252     SetTokenResult(not_done, pop_success);
 253 }
 254
 255 void
 256 PE_Parameter::On_afterName_Assign(const char *)
 257 {
 258     pSpuVariable->Push(not_done);
 259 }
 260
 261 void
 262 PE_Parameter::On_finished_Bracket_Right(const char *)
 263 {
 264     SetTokenResult(not_done, pop_success);
 265 }
 266
 267 void
 268 PE_Parameter::On_finished_Comma(const char *)
 269 {
 270     SetTokenResult(not_done, pop_success);
 271 }
 272
 273
 274 }   // namespace cpp
 275
 276
 277
 278
 279
 280
 281
 282
 283