autodoc/source/parser/cpp/pe_base.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_base.cxx,v $
  10  * $Revision: 1.8 $
  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_base.hxx"
  33
  34
  35 // NOT FULLY DECLARED SERVICES
  36 #include <cosv/tpl/tpltools.hxx>
  37 #include <ary/cpp/c_gate.hxx>
  38 #include <ary/cpp/c_type.hxx>
  39 #include "pe_type.hxx"
  40
  41
  42
  43
  44 namespace cpp
  45 {
  46
  47
  48 static const PE_Base::Base aNullBase_;
  49
  50
  51 PE_Base::PE_Base( Cpp_PE * i_pParent )
  52     :   Cpp_PE(i_pParent),
  53         pStati(new PeStatusArray<PE_Base>)
  54         // aBaseIds,
  55         // pSpType,
  56         // pSpuBaseName
  57 {
  58     Setup_StatusFunctions();
  59     aBaseIds.reserve(4);
  60
  61     pSpType             = new SP_Type(*this);
  62     pSpuBaseName        = new SPU_BaseName(*pSpType, 0, &PE_Base::SpReturn_BaseName);
  63 }
  64
  65
  66 PE_Base::~PE_Base()
  67 {
  68 }
  69
  70 void
  71 PE_Base::Call_Handler( const cpp::Token & i_rTok )
  72 {
  73     pStati->Cur().Call_Handler(i_rTok.TypeId(), i_rTok.Text());
  74 }
  75
  76 void
  77 PE_Base::Setup_StatusFunctions()
  78 {
  79     typedef CallFunction<PE_Base>::F_Tok        F_Tok;
  80     static F_Tok stateF_startOfNext[] =         { &PE_Base::On_startOfNext_Identifier,
  81                                               &PE_Base::On_startOfNext_public,
  82                                               &PE_Base::On_startOfNext_protected,
  83                                               &PE_Base::On_startOfNext_private,
  84                                               &PE_Base::On_startOfNext_virtual,
  85                                               &PE_Base::On_startOfNext_DoubleColon };
  86     static INT16 stateT_startOfNext[] =         { Tid_Identifier,
  87                                               Tid_public,
  88                                               Tid_protected,
  89                                               Tid_private,
  90                                               Tid_virtual,
  91                                               Tid_DoubleColon };
  92     static F_Tok stateF_inName[] =                      { &PE_Base::On_inName_Identifier,
  93                                               &PE_Base::On_inName_virtual,
  94                                               &PE_Base::On_inName_SwBracket_Left,
  95                                               &PE_Base::On_inName_DoubleColon,
  96                                               &PE_Base::On_inName_Comma };
  97     static INT16 stateT_inName[] =                      { Tid_Identifier,
  98                                               Tid_virtual,
  99                                               Tid_SwBracket_Left,
 100                                               Tid_DoubleColon,
 101                                               Tid_Comma };
 102
 103     SEMPARSE_CREATE_STATUS(PE_Base, startOfNext, Hdl_SyntaxError);
 104     SEMPARSE_CREATE_STATUS(PE_Base, inName, Hdl_SyntaxError);
 105 }
 106
 107 void
 108 PE_Base::Hdl_SyntaxError( const char * i_sText)
 109 {
 110     StdHandlingOfSyntaxError(i_sText);
 111 }
 112
 113 void
 114 PE_Base::InitData()
 115 {
 116     pStati->SetCur(startOfNext);
 117     csv::erase_container(aBaseIds);
 118     aBaseIds.push_back(aNullBase_);
 119 }
 120
 121 void
 122 PE_Base::TransferData()
 123 {
 124     // Does nothing.
 125 }
 126
 127 void
 128 PE_Base::SpReturn_BaseName()
 129 {
 130     CurObject().nId = pSpuBaseName->Child().Result_Type().Id();
 131
 132     static StreamStr aBaseName(100);
 133     aBaseName.seekp(0);
 134     pSpuBaseName->Child().Result_Type().Get_Text( aBaseName, Env().AryGate() );
 135
 136     Env().Event_Class_FinishedBase(aBaseName.c_str());
 137 }
 138
 139 void
 140 PE_Base::On_startOfNext_public(const char *)
 141 {
 142     SetTokenResult(done, stay);
 143     pStati->SetCur(inName);
 144
 145     CurObject().eProtection = ary::cpp::PROTECT_public;
 146 }
 147
 148 void
 149 PE_Base::On_startOfNext_protected(const char *)
 150 {
 151     SetTokenResult(done, stay);
 152     pStati->SetCur(inName);
 153
 154     CurObject().eProtection = ary::cpp::PROTECT_protected;
 155 }
 156
 157 void
 158 PE_Base::On_startOfNext_private(const char *)
 159 {
 160     SetTokenResult(done, stay);
 161     pStati->SetCur(inName);
 162
 163     CurObject().eProtection = ary::cpp::PROTECT_private;
 164 }
 165
 166 void
 167 PE_Base::On_startOfNext_virtual(const char *)
 168 {
 169     SetTokenResult(done, stay);
 170
 171     CurObject().eVirtuality = ary::cpp::VIRTUAL_virtual;
 172 }
 173
 174 void
 175 PE_Base::On_startOfNext_Identifier(const char * )
 176 {
 177     pSpuBaseName->Push(not_done);
 178 }
 179
 180 void
 181 PE_Base::On_startOfNext_DoubleColon(const char *)
 182 {
 183     pSpuBaseName->Push(not_done);
 184 }
 185
 186 void
 187 PE_Base::On_inName_Identifier(const char * )
 188 {
 189     pSpuBaseName->Push(not_done);
 190 }
 191
 192 void
 193 PE_Base::On_inName_virtual(const char *)
 194 {
 195     SetTokenResult(done, stay);
 196
 197     CurObject().eVirtuality = ary::cpp::VIRTUAL_virtual;
 198 }
 199
 200 void
 201 PE_Base::On_inName_DoubleColon(const char *)
 202 {
 203     pSpuBaseName->Push(not_done);
 204 }
 205
 206 void
 207 PE_Base::On_inName_Comma(const char *)
 208 {
 209     SetTokenResult(done, stay);
 210     pStati->SetCur(startOfNext);
 211
 212     aBaseIds.push_back( aNullBase_ );
 213 }
 214
 215 void
 216 PE_Base::On_inName_SwBracket_Left(const char *)
 217 {
 218     SetTokenResult(not_done, pop_success);
 219 }
 220
 221
 222 }   // namespace cpp
 223
 224
 225
 226
 227