rsc/source/parser/rscyacc.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: rscyacc.cxx,v $
  10  * $Revision: 1.10 $
  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 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_rsc.hxx"
  33 #include <stdio.h>
  34 #include <ctype.h>
  35 #include <string.h>
  36
  37 #include <tools/rc.h>
  38 #include <rscerror.h>
  39 #include <rsctools.hxx>
  40 #include <rscclass.hxx>
  41 #include <rsccont.hxx>
  42 #include <rsctree.hxx>
  43 #include <rscdb.hxx>
  44 #include <rscdef.hxx>
  45 #include <rscpar.hxx>
  46
  47 #include "rsclex.hxx"
  48
  49 /************** V a r i a b l e n ****************************************/
  50 ObjectStack                                     S;
  51 RscTop *                                                pCurClass;
  52 sal_uInt32                                              nCurMask;
  53 char                                                    szErrBuf[ 100 ];
  54
  55 /************** H i l f s F u n k t i o n e n ****************************/
  56 RSCINST GetVarInst( const RSCINST & rInst, const char * pVarName )
  57 {
  58     RSCINST aInst;
  59
  60     aInst = rInst.pClass->GetVariable( rInst, pHS->getID( pVarName ),
  61                                        RSCINST() );
  62
  63     if( !aInst.pData )
  64         pTC->pEH->Error( ERR_NOVARIABLENAME, rInst.pClass, RscId() );
  65
  66     return( aInst );
  67 }
  68
  69 void SetNumber( const RSCINST & rInst, const char * pVarName, INT32 lValue )
  70 {
  71     RSCINST aInst;
  72
  73     aInst = GetVarInst( rInst, pVarName );
  74
  75     if( aInst.pData ){
  76         ERRTYPE aError;
  77         aError = aInst.pClass->SetNumber( aInst, lValue );
  78
  79         if( aError.IsError() )
  80             pTC->pEH->Error( aError, aInst.pClass, RscId() );
  81     }
  82 }
  83
  84 void SetConst( const RSCINST & rInst, const char * pVarName,
  85                Atom nValueId, INT32 nVal )
  86 {
  87     RSCINST aInst;
  88
  89     aInst = GetVarInst( rInst, pVarName );
  90     if( aInst.pData )
  91     {
  92         ERRTYPE aError;
  93         aError = aInst.pClass->SetConst( aInst, nValueId, nVal );
  94
  95         if( aError.IsError() )
  96             pTC->pEH->Error( aError, aInst.pClass, RscId() );
  97     }
  98 }
  99
 100 void SetString( const RSCINST & rInst, const char * pVarName, const char * pStr )
 101 {
 102     RSCINST aInst;
 103
 104     aInst = GetVarInst( rInst, pVarName );
 105     if( aInst.pData ){
 106         ERRTYPE aError;
 107         aError = aInst.pClass->SetString( aInst, pStr );
 108
 109         if( aError.IsError() )
 110             pTC->pEH->Error( aError, aInst.pClass, RscId() );
 111     }
 112 }
 113
 114 RscId MakeRscId( RscExpType aExpType )
 115 {
 116     if( !aExpType.IsNothing() ){
 117         INT32           lValue;
 118
 119         if( !aExpType.Evaluate( &lValue ) )
 120             pTC->pEH->Error( ERR_ZERODIVISION, NULL, RscId() );
 121         if( lValue < 1 || lValue > (INT32)0x7FFF )
 122         {
 123             pTC->pEH->Error( ERR_IDRANGE, NULL, RscId(),
 124                              ByteString::CreateFromInt32( lValue ).GetBuffer() );
 125         }
 126
 127         if( aExpType.IsDefinition() )
 128             return RscId( aExpType.aExp.pDef );
 129         else
 130             return RscId( lValue );
 131     }
 132     return RscId();
 133 }
 134
 135 BOOL DoClassHeader( RSCHEADER * pHeader, BOOL bMember )
 136 {
 137     RSCINST aCopyInst;
 138     RscId aName1 = MakeRscId( pHeader->nName1 );
 139     RscId aName2 = MakeRscId( pHeader->nName2 );
 140
 141     if( pHeader->pRefClass )
 142         aCopyInst.pClass = pHeader->pRefClass;
 143     else
 144         aCopyInst.pClass = pHeader->pClass;
 145
 146     if( TYPE_COPY == pHeader->nTyp )
 147     {
 148         ObjNode * pCopyObj = aCopyInst.pClass->GetObjNode( aName2 );
 149
 150         if( !pCopyObj )
 151         {
 152             ByteString aMsg( pHS->getString( aCopyInst.pClass->GetId() ) );
 153             aMsg += ' ';
 154             aMsg += aName2.GetName();
 155             pTC->pEH->Error( ERR_NOCOPYOBJ, pHeader->pClass, aName1,
 156                              aMsg.GetBuffer() );
 157         }
 158         else
 159             aCopyInst.pData = pCopyObj->GetRscObj();
 160     }
 161
 162     if( bMember )
 163     {
 164         // Angabe von Superklassen oder abgeleiteten Klassen ist jetzt erlaubt
 165         if( S.Top().pClass->InHierarchy( pHeader->pClass )
 166           ||  pHeader->pClass->InHierarchy( S.Top().pClass) )
 167         {
 168             if( aCopyInst.IsInst() )
 169             {
 170                 RSCINST aTmpI( S.Top() );
 171                 aTmpI.pClass->Destroy( aTmpI );
 172                 aTmpI.pClass->Create( &aTmpI, aCopyInst );
 173             };
 174         }
 175         else
 176             pTC->pEH->Error( ERR_FALSETYPE, S.Top().pClass, aName1,
 177                              pHS->getString( pHeader->pClass->GetId() ) );
 178     }
 179     else
 180     {
 181         if( S.IsEmpty() )
 182         {
 183             if( (INT32)aName1 < 256 )
 184                 pTC->pEH->Error( WRN_GLOBALID, pHeader->pClass, aName1 );
 185
 186             if( aCopyInst.IsInst() )
 187                 S.Push( pHeader->pClass->Create( NULL, aCopyInst ) );
 188             else
 189                 S.Push( pHeader->pClass->Create( NULL, RSCINST() ) );
 190
 191             ObjNode * pNode = new ObjNode( aName1, S.Top().pData,
 192                                            pFI->GetFileIndex() );
 193                         pTC->pEH->StdOut( ".", RscVerbosityVerbose );
 194
 195             if( !aName1.IsId() )
 196                 pTC->pEH->Error( ERR_IDEXPECTED, pHeader->pClass, aName1 );
 197             else if( !pHeader->pClass->PutObjNode( pNode ) )
 198                 pTC->pEH->Error( ERR_DOUBLEID, pHeader->pClass, aName1 );
 199         }
 200         else
 201         {
 202             RSCINST aTmpI;
 203             ERRTYPE aError;
 204
 205             if( (INT32)aName1 >= 256 && aName1.IsId() )
 206                 pTC->pEH->Error( WRN_LOCALID, pHeader->pClass, aName1 );
 207             aError = S.Top().pClass->GetElement( S.Top(), aName1,
 208                                                  pHeader->pClass, aCopyInst, &aTmpI );
 209
 210             if( aError.IsWarning() )
 211                 pTC->pEH->Error( aError, pHeader->pClass, aName1 );
 212             else if( aError.IsError() )
 213             {
 214                 if( ERR_CONT_INVALIDTYPE == aError )
 215                     pTC->pEH->Error( aError, S.Top().pClass, aName1,
 216                                      pHS->getString( pHeader->pClass->GetId() ) );
 217                 else
 218                     pTC->pEH->Error( aError, S.Top().pClass, aName1 );
 219                 S.Top().pClass->GetElement( S.Top(), RscId(),
 220                                             pHeader->pClass, RSCINST(), &aTmpI );
 221
 222                 if( !aTmpI.IsInst() )
 223                     return( FALSE );
 224             }
 225             S.Push( aTmpI );
 226         };
 227     };
 228     if( TYPE_REF == pHeader->nTyp )
 229     {
 230         ERRTYPE aError;
 231
 232         aError = S.Top().pClass->SetRef( S.Top(), aName2 );
 233         pTC->pEH->Error( aError, S.Top().pClass, aName1 );
 234     }
 235
 236     return( TRUE );
 237 }
 238
 239 RSCINST GetFirstTupelEle( const RSCINST & rTop )
 240 { // Aufwaertskompatible, Tupel probieren
 241     RSCINST aInst;
 242     ERRTYPE aErr;
 243
 244     aErr = rTop.pClass->GetElement( rTop, RscId(), NULL, RSCINST(), &aInst );
 245     if( !aErr.IsError() )
 246         aInst = aInst.pClass->GetTupelVar( aInst, 0, RSCINST() );
 247     return aInst;
 248 }
 249
 250 /************** Y a c c   C o d e ****************************************/
 251 //#define YYDEBUG 1
 252
 253 #define TYPE_Atom                         0
 254 #define TYPE_RESID                                1
 255
 256 #ifdef UNX
 257 #define YYMAXDEPTH                              2000
 258 #else
 259 #ifdef W30
 260 #define YYMAXDEPTH                              300
 261 #else
 262 #define YYMAXDEPTH                              800
 263 #endif
 264 #endif
 265
 266 #if defined _MSC_VER
 267 #pragma warning(push, 1)
 268 #pragma warning(disable:4129 4273 4701)
 269 #endif
 270 #include "yyrscyacc.cxx"
 271 #if defined _MSC_VER
 272 #pragma warning(pop)
 273 #endif
 274