Line data Source code
1 : %{
2 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
3 : /*
4 : * This file is part of the LibreOffice project.
5 : *
6 : * This Source Code Form is subject to the terms of the Mozilla Public
7 : * License, v. 2.0. If a copy of the MPL was not distributed with this
8 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
9 : *
10 : * This file incorporates work covered by the following license notice:
11 : *
12 : * Licensed to the Apache Software Foundation (ASF) under one or more
13 : * contributor license agreements. See the NOTICE file distributed
14 : * with this work for additional information regarding copyright
15 : * ownership. The ASF licenses this file to you under the Apache
16 : * License, Version 2.0 (the "License"); you may not use this file
17 : * except in compliance with the License. You may obtain a copy of
18 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
19 : */
20 :
21 : #include "sal/config.h"
22 :
23 : #include <stdio.h>
24 : #include <ctype.h>
25 : #include <string.h>
26 :
27 : #include <rtl/strbuf.hxx>
28 : #include <tools/rc.h>
29 : #include <rscerror.h>
30 : #include <rsctools.hxx>
31 : #include <rscclass.hxx>
32 : #include <rsccont.hxx>
33 : #include <rsctree.hxx>
34 : #include <rscdb.hxx>
35 : #include <rscdef.hxx>
36 : #include <rscpar.hxx>
37 :
38 : #include <rsclex.hxx>
39 :
40 417 : ObjectStack S;
41 : RscTop * pCurClass;
42 : sal_uInt32 nCurMask;
43 : char szErrBuf[ 100 ];
44 :
45 1555 : RSCINST GetVarInst( const RSCINST & rInst, const char * pVarName )
46 : {
47 1555 : RSCINST aInst;
48 :
49 : aInst = rInst.pClass->GetVariable( rInst, pHS->getID( pVarName ),
50 1555 : RSCINST() );
51 :
52 1555 : if( !aInst.pData )
53 0 : pTC->pEH->Error( ERR_NOVARIABLENAME, rInst.pClass, RscId() );
54 :
55 1555 : return aInst;
56 : }
57 :
58 1036 : void SetNumber( const RSCINST & rInst, const char * pVarName, sal_Int32 lValue )
59 : {
60 1036 : RSCINST aInst;
61 :
62 1036 : aInst = GetVarInst( rInst, pVarName );
63 :
64 1036 : if( aInst.pData )
65 : {
66 1036 : ERRTYPE aError;
67 1036 : aError = aInst.pClass->SetNumber( aInst, lValue );
68 :
69 1036 : if( aError.IsError() )
70 0 : pTC->pEH->Error( aError, aInst.pClass, RscId() );
71 : }
72 1036 : }
73 :
74 518 : void SetConst( const RSCINST & rInst, const char * pVarName,
75 : Atom nValueId, sal_Int32 nVal )
76 : {
77 518 : RSCINST aInst;
78 :
79 518 : aInst = GetVarInst( rInst, pVarName );
80 518 : if( aInst.pData )
81 : {
82 518 : ERRTYPE aError;
83 518 : aError = aInst.pClass->SetConst( aInst, nValueId, nVal );
84 :
85 518 : if( aError.IsError() )
86 0 : pTC->pEH->Error( aError, aInst.pClass, RscId() );
87 : }
88 518 : }
89 :
90 1 : void SetString( const RSCINST & rInst, const char * pVarName, const char * pStr )
91 : {
92 1 : RSCINST aInst;
93 :
94 1 : aInst = GetVarInst( rInst, pVarName );
95 1 : if( aInst.pData ){
96 1 : ERRTYPE aError;
97 1 : aError = aInst.pClass->SetString( aInst, pStr );
98 :
99 1 : if( aError.IsError() )
100 0 : pTC->pEH->Error( aError, aInst.pClass, RscId() );
101 : }
102 1 : }
103 :
104 84736 : RscId MakeRscId( RscExpType aExpType )
105 : {
106 84736 : if( !aExpType.IsNothing() )
107 : {
108 33214 : sal_Int32 lValue(0);
109 :
110 33214 : if( !aExpType.Evaluate( &lValue ) )
111 0 : pTC->pEH->Error( ERR_ZERODIVISION, NULL, RscId() );
112 33214 : if( lValue < 1 || lValue > (sal_Int32)0x7FFF )
113 : {
114 : pTC->pEH->Error( ERR_IDRANGE, NULL, RscId(),
115 0 : rtl::OString::number(lValue).getStr() );
116 : }
117 :
118 33214 : if( aExpType.IsDefinition() )
119 0 : return RscId( aExpType.aExp.pDef );
120 : else
121 33214 : return RscId( lValue );
122 : }
123 51522 : return RscId();
124 : }
125 :
126 42368 : bool DoClassHeader( RSCHEADER * pHeader, bool bMember )
127 : {
128 42368 : RSCINST aCopyInst;
129 42368 : RscId aName1 = MakeRscId( pHeader->nName1 );
130 84736 : RscId aName2 = MakeRscId( pHeader->nName2 );
131 :
132 42368 : if( pHeader->pRefClass )
133 0 : aCopyInst.pClass = pHeader->pRefClass;
134 : else
135 42368 : aCopyInst.pClass = pHeader->pClass;
136 :
137 42368 : if( TYPE_COPY == pHeader->nTyp )
138 : {
139 0 : ObjNode * pCopyObj = aCopyInst.pClass->GetObjNode( aName2 );
140 :
141 0 : if( !pCopyObj )
142 : {
143 0 : rtl::OStringBuffer aMsg( pHS->getString( aCopyInst.pClass->GetId() ) );
144 0 : aMsg.append(' ');
145 0 : aMsg.append(aName2.GetName());
146 : pTC->pEH->Error( ERR_NOCOPYOBJ, pHeader->pClass, aName1,
147 0 : aMsg.getStr() );
148 : }
149 : else
150 0 : aCopyInst.pData = pCopyObj->GetRscObj();
151 : }
152 :
153 42368 : if( bMember )
154 : {
155 : // Angabe von Superklassen oder abgeleiteten Klassen ist jetzt erlaubt
156 2016 : if( S.Top().pClass->InHierarchy( pHeader->pClass ) ||
157 0 : pHeader->pClass->InHierarchy( S.Top().pClass) )
158 : {
159 2016 : if( aCopyInst.IsInst() )
160 : {
161 0 : RSCINST aTmpI( S.Top() );
162 0 : aTmpI.pClass->Destroy( aTmpI );
163 0 : aTmpI.pClass->Create( &aTmpI, aCopyInst );
164 : }
165 : }
166 : else
167 0 : pTC->pEH->Error( ERR_FALSETYPE, S.Top().pClass, aName1,
168 0 : pHS->getString( pHeader->pClass->GetId() ).getStr() );
169 : }
170 : else
171 : {
172 40352 : if( S.IsEmpty() )
173 : {
174 18992 : if( (sal_Int32)aName1 < 256 )
175 0 : pTC->pEH->Error( WRN_GLOBALID, pHeader->pClass, aName1 );
176 :
177 18992 : if( aCopyInst.IsInst() )
178 0 : S.Push( pHeader->pClass->Create( NULL, aCopyInst ) );
179 : else
180 18992 : S.Push( pHeader->pClass->Create( NULL, RSCINST() ) );
181 :
182 18992 : pTC->pEH->StdOut( ".", RscVerbosityVerbose );
183 :
184 18992 : if( !aName1.IsId() )
185 0 : pTC->pEH->Error( ERR_IDEXPECTED, pHeader->pClass, aName1 );
186 : else
187 : {
188 18992 : ObjNode * pNode = new ObjNode( aName1, S.Top().pData,
189 18992 : pFI->GetFileIndex() );
190 18992 : if( !pHeader->pClass->PutObjNode( pNode ) )
191 0 : pTC->pEH->Error( ERR_DOUBLEID, pHeader->pClass, aName1 );
192 : }
193 : }
194 : else
195 : {
196 21360 : RSCINST aTmpI;
197 21360 : ERRTYPE aError;
198 :
199 21360 : if( (sal_Int32)aName1 >= 256 && aName1.IsId() )
200 4562 : pTC->pEH->Error( WRN_LOCALID, pHeader->pClass, aName1 );
201 :
202 64080 : aError = S.Top().pClass->GetElement( S.Top(), aName1,
203 42720 : pHeader->pClass, aCopyInst, &aTmpI );
204 :
205 21360 : if( aError.IsWarning() )
206 : {
207 0 : pTC->pEH->Error( aError, pHeader->pClass, aName1 );
208 : }
209 21360 : else if( aError.IsError() )
210 : {
211 0 : if( ERR_CONT_INVALIDTYPE == aError )
212 0 : pTC->pEH->Error( aError, S.Top().pClass, aName1,
213 0 : pHS->getString( pHeader->pClass->GetId() ).getStr() );
214 : else
215 0 : pTC->pEH->Error( aError, S.Top().pClass, aName1 );
216 :
217 0 : S.Top().pClass->GetElement( S.Top(), RscId(),
218 0 : pHeader->pClass, RSCINST(), &aTmpI );
219 :
220 0 : if( !aTmpI.IsInst() )
221 0 : return false;
222 : }
223 21360 : S.Push( aTmpI );
224 : }
225 : }
226 42368 : if( TYPE_REF == pHeader->nTyp )
227 : {
228 2 : ERRTYPE aError;
229 :
230 2 : aError = S.Top().pClass->SetRef( S.Top(), aName2 );
231 2 : pTC->pEH->Error( aError, S.Top().pClass, aName1 );
232 : }
233 :
234 84736 : return true ;
235 : }
236 :
237 93 : RSCINST GetFirstTupelEle( const RSCINST & rTop )
238 : { // Aufwaertskompatible, Tupel probieren
239 93 : RSCINST aInst;
240 93 : ERRTYPE aErr;
241 :
242 93 : aErr = rTop.pClass->GetElement( rTop, RscId(), NULL, RSCINST(), &aInst );
243 93 : if( !aErr.IsError() )
244 93 : aInst = aInst.pClass->GetTupelVar( aInst, 0, RSCINST() );
245 93 : return aInst;
246 : }
247 :
248 : //#define YYDEBUG 1
249 :
250 : #ifdef UNX
251 : #define YYMAXDEPTH 2000
252 : #else
253 : #define YYMAXDEPTH 800
254 : #endif
255 :
256 : #if defined _MSC_VER
257 : #pragma warning(push, 1)
258 : #pragma warning(disable:4129 4273 4701 4702)
259 : #endif
260 : #ifdef __GNUC__
261 : #pragma GCC diagnostic ignored "-Wwrite-strings"
262 : #endif
263 : %}
264 :
265 : /* Compilerstack */
266 :
267 : %union {
268 : Atom varid;
269 : struct {
270 : Atom hashid;
271 : sal_Int32 nValue;
272 : } constname;
273 : RscTop * pClass;
274 : RSCHEADER header;
275 : struct {
276 : CLASS_DATA pData;
277 : RscTop * pClass;
278 : } instance;
279 : sal_Int32 value;
280 : sal_uInt16 ushort;
281 : short exp_short;
282 : char * string;
283 : bool svbool;
284 : REF_ENUM copyref;
285 : RscDefine * defineele;
286 : rtl_TextEncoding charset;
287 : RscExpType macrostruct;
288 : }
289 :
290 : /* Token */
291 : %token <value> NUMBER
292 : %token <string> SYMBOL
293 : %token <defineele> RSCDEFINE
294 : %token <string> STRING
295 : %token <string> INCLUDE_STRING
296 : %token <character> CHARACTER
297 : %token <svbool> BOOLEAN
298 :
299 : %token LINE
300 : %token AUTO_ID
301 : %token NOT
302 : %token XSCALE
303 : %token YSCALE
304 : %token RGB
305 : %token GEOMETRY
306 : %token POSITION
307 : %token DIMENSION
308 : %token INZOOMOUTPUTSIZE
309 : %token FLOATINGPOS
310 : %token DEFINE
311 : %token INCLUDE
312 : %token MACROTARGET
313 : %token DEFAULT
314 :
315 :
316 : %token <pClass> CLASSNAME
317 : %token <varid> VARNAME
318 : %token <constname> CONSTNAME
319 : %token CLASS
320 : %token EXTENDABLE
321 : %token WRITEIFSET
322 :
323 :
324 : %type <macrostruct> macro_expression
325 : %type <macrostruct> id_expression
326 : %type <value> long_expression
327 : %type <string> string_multiline
328 :
329 : %type <pClass> type
330 : %type <pClass> type_base
331 : %type <header> class_header_body
332 : %type <header> class_header
333 : %type <header> var_header_class
334 : %type <copyref> copy_ref
335 : %type <ushort> type_flags
336 :
337 :
338 : %left '|'
339 : %left '&'
340 : %left LEFTSHIFT RIGHTSHIFT
341 : %left '+' '-'
342 : %left '*' '/'
343 : %left UNARYMINUS
344 : %left UNARYPLUS
345 : %left ','
346 : %left '(' ')'
347 :
348 :
349 : /* Grammatik */
350 :
351 : %start resource_definitions
352 :
353 : %%
354 :
355 : resource_definitions
356 : :
357 : | resource_definitions resource_definition
358 : | MACROTARGET macro_expression
359 : {
360 : RscExpType aExpType;
361 : sal_Int32 lValue;
362 :
363 0 : aExpType.cUnused = false;
364 0 : aExpType.cType = RSCEXP_NOTHING;
365 0 : pExp = new RscExpression( aExpType, '+', $2 );
366 0 : if( !pExp->Evaluate( &lValue ) )
367 : {
368 0 : pTC->pEH->Error( ERR_ZERODIVISION, NULL, RscId() );
369 : }
370 0 : delete pExp;
371 : }
372 0 : ;
373 :
374 : resource_definition
375 : : line_number
376 : | '#' DEFINE SYMBOL macro_expression
377 : {
378 0 : bool bError = false;
379 :
380 0 : if( $4.IsNumber() )
381 : {
382 0 : if( !pTC->aFileTab.NewDef( pFI->GetFileIndex(),
383 0 : rtl::OString( $3 ),
384 0 : $4.GetLong(), ULONG_MAX ) )
385 0 : bError = true;
386 : }
387 0 : else if( $4.IsDefinition() )
388 : {
389 : RscExpType aExpType;
390 : RscExpression * pExpr;
391 :
392 0 : aExpType.cUnused = false;
393 0 : aExpType.cType = RSCEXP_NOTHING;
394 0 : aExpType.SetLong( 0 );
395 0 : aExpType.cType = RSCEXP_LONG;
396 0 : pExpr = new RscExpression( aExpType, '+', $4 );
397 :
398 0 : if( !pTC->aFileTab.NewDef( pFI->GetFileIndex(),
399 0 : rtl::OString( $3 ), pExpr, ULONG_MAX ) )
400 : {
401 0 : bError =true;
402 : }
403 : }
404 0 : else if( $4.IsExpression() )
405 : {
406 0 : if( !pTC->aFileTab.NewDef( pFI->GetFileIndex(),
407 0 : rtl::OString( $3 ), $4.aExp.pExp,
408 0 : ULONG_MAX ) )
409 : {
410 0 : bError = true;
411 : }
412 : }
413 :
414 0 : if( bError )
415 : {
416 0 : pTC->pEH->Error( ERR_DECLAREDEFINE, NULL, RscId(), $3 );
417 : }
418 : }
419 0 : | '#' DEFINE RSCDEFINE macro_expression
420 : {
421 0 : pTC->pEH->Error( ERR_DOUBLEDEFINE, NULL, RscId(), $3->GetName().getStr() );
422 : }
423 0 : | '#' INCLUDE STRING
424 : {
425 : }
426 0 : | '#' INCLUDE INCLUDE_STRING
427 : {
428 : }
429 0 : | class_definition ';'
430 : {
431 : #ifdef D40
432 : void * pMem;
433 : pMem = rtl_allocateMemory( 20000 );
434 : rtl_freeMemory( pMem );
435 : #endif
436 : }
437 18992 : | new_class_definition_header '{' new_class_definition_body '}' ';'
438 : | new_class_definition_header ';'
439 : ;
440 :
441 : new_class_definition_header
442 : : CLASS SYMBOL id_expression ':' CLASSNAME
443 : {
444 : sal_Int32 lType;
445 :
446 0 : $3.Evaluate( &lType );
447 :
448 : // Klasse anlegen
449 0 : Atom nId = pHS->getID( $2 );
450 0 : pCurClass = new RscClass( nId, lType, $5 );
451 0 : nCurMask = 1;
452 0 : pTC->aNmTb.Put( nId, CLASSNAME, pCurClass );
453 0 : pTC->GetRoot()->Insert( pCurClass );
454 : }
455 0 : | CLASS CLASSNAME id_expression ':' CLASSNAME
456 : {
457 0 : pCurClass = $2;
458 0 : nCurMask = 1;
459 : }
460 0 : ;
461 :
462 : new_class_definition_body
463 : :
464 : | property_definition ';' new_class_definition_body
465 : ;
466 :
467 : property_definition
468 : : type_flags type SYMBOL
469 : {
470 : // Variable anlegen
471 0 : Atom nId = pTC->aNmTb.Put( $3, VARNAME );
472 0 : pCurClass->SetVariable( nId, $2, NULL, $1, nCurMask );
473 0 : nCurMask <<= 1;
474 : }
475 0 : | type_flags type VARNAME
476 : {
477 0 : pCurClass->SetVariable( $3, $2, NULL, $1, nCurMask );
478 0 : nCurMask <<= 1;
479 : }
480 0 : ;
481 :
482 : type_flags
483 : : type_flags EXTENDABLE
484 : {
485 0 : $$ = $1 | VAR_EXTENDABLE;
486 : }
487 0 : | type_flags WRITEIFSET
488 : {
489 0 : $$ = $1 | VAR_SVDYNAMIC;
490 : }
491 0 : |
492 : {
493 0 : $$ = 0;
494 : }
495 0 : ;
496 :
497 : type
498 : : type_base
499 : {
500 0 : $$ = $1;
501 : }
502 0 : | type_base '[' ']'
503 : {
504 0 : if( $1 )
505 : {
506 0 : rtl::OString aTypeName = rtl::OStringBuffer(pHS->getString($1->GetId())).
507 0 : append("[]").makeStringAndClear();
508 0 : $$ = pTC->SearchType( pHS->getID( aTypeName.getStr(), true ) );
509 0 : if( !$$ )
510 : {
511 : RscCont * pCont;
512 0 : pCont = new RscCont( pHS->getID( aTypeName.getStr() ), RSC_NOTYPE );
513 0 : pCont->SetTypeClass( $1 );
514 0 : pTC->InsertType( pCont );
515 0 : $$ = pCont;
516 0 : }
517 : }
518 : else
519 : {
520 0 : $$ = NULL;
521 : }
522 : }
523 0 : ;
524 :
525 : type_base
526 : : CLASSNAME
527 : {
528 0 : $$ = $1;
529 : }
530 0 : | SYMBOL
531 : {
532 0 : RscTop * pType = pTC->SearchType( pHS->getID( $1, true ) );
533 0 : if( !pType )
534 0 : pTC->pEH->Error( ERR_NOTYPE, pCurClass, RscId() );
535 0 : $$ = pType;
536 : }
537 0 : ;
538 :
539 : class_definition
540 : : class_header class_body
541 : {
542 40352 : if( TYPE_REF == $1.nTyp )
543 : {
544 0 : pTC->pEH->Error( ERR_REFNOTALLOWED, S.Top().pClass,
545 0 : RscId( $1.nName1 ) );
546 : }
547 40352 : S.Pop();
548 : }
549 40352 : | class_header
550 : {
551 0 : ERRTYPE aError;
552 0 : RscId aRscId( $1.nName1 );
553 :
554 0 : if( TYPE_NOTHING == $1.nTyp && aRscId.IsId() )
555 0 : aError = S.Top().pClass->SetRef( S.Top(), aRscId );
556 0 : else if( TYPE_COPY == $1.nTyp )
557 0 : aError = ERR_COPYNOTALLOWED;
558 0 : if( aError.IsError() || aError.IsWarning() )
559 0 : pTC->pEH->Error( aError, S.Top().pClass, aRscId );
560 0 : S.Pop();
561 0 : }
562 0 : ;
563 :
564 : class_header
565 : : class_header_body
566 : {
567 40352 : if( !DoClassHeader( &$1, false ) )
568 0 : return ERR_ERROR;
569 40352 : $$ = $1;
570 : }
571 40352 : ;
572 :
573 : copy_ref
574 : : '<'
575 : {
576 0 : $$ = TYPE_COPY;
577 : }
578 0 : | ','
579 : {
580 2 : $$ = TYPE_REF;
581 : }
582 2 : ;
583 :
584 : class_header_body
585 : : CLASSNAME id_expression copy_ref CLASSNAME id_expression
586 : {
587 0 : $$.pClass = $1;
588 0 : $$.nName1 = $2;
589 0 : $$.nTyp = $3;
590 0 : $$.pRefClass = $4;
591 0 : $$.nName2 = $5;
592 : }
593 0 : | CLASSNAME id_expression copy_ref id_expression
594 : {
595 0 : $$.pClass = $1;
596 0 : $$.nName1 = $2;
597 0 : $$.nTyp = $3;
598 0 : $$.pRefClass = NULL;
599 0 : $$.nName2 = $4;
600 : }
601 0 : | CLASSNAME id_expression
602 : {
603 33212 : $$.pClass = $1;
604 33212 : $$.nName1 = $2;
605 33212 : $$.nTyp = TYPE_NOTHING;
606 33212 : $$.pRefClass = NULL;
607 33212 : $$.nName2.cType = RSCEXP_NOTHING;
608 : }
609 33212 : | CLASSNAME copy_ref id_expression
610 : {
611 2 : $$.pClass = $1;
612 2 : $$.nName1.cType = RSCEXP_NOTHING;
613 2 : $$.nTyp = $2;
614 2 : $$.pRefClass = NULL;
615 2 : $$.nName2 = $3;
616 : }
617 2 : | CLASSNAME copy_ref CLASSNAME id_expression
618 : {
619 0 : $$.pClass = $1;
620 0 : $$.nName1.cType = RSCEXP_NOTHING;
621 0 : $$.nTyp = $2;
622 0 : $$.pRefClass = $3;
623 0 : $$.nName2 = $4;
624 : }
625 0 : | CLASSNAME
626 : {
627 9154 : $$.pClass = $1;
628 9154 : $$.nName1.cType = RSCEXP_NOTHING;
629 9154 : $$.nTyp = TYPE_NOTHING;
630 9154 : $$.nName2.cType = RSCEXP_NOTHING;
631 : }
632 9154 : ;
633 :
634 : class_body
635 : : '{' var_definitions '}'
636 : | '{' '}'
637 : | string_multiline
638 : {
639 1 : SetString( S.Top(), "TEXT", $1 );
640 : }
641 1 : ;
642 :
643 : var_definitions
644 : : var_definition
645 : | var_definitions var_definition
646 : ;
647 :
648 : xy_mapmode
649 : : CONSTNAME
650 : {
651 230 : SetConst( S.Top(), "_XYMAPMODE", $1.hashid, $1.nValue );
652 : }
653 230 : |
654 : ;
655 :
656 : wh_mapmode
657 : : CONSTNAME
658 : {
659 288 : SetConst( S.Top(), "_WHMAPMODE", $1.hashid, $1.nValue );
660 : }
661 288 : |
662 : ;
663 :
664 : xywh_mapmode
665 : : CONSTNAME
666 : {
667 0 : SetConst( S.Top(), "_XYMAPMODE", $1.hashid, $1.nValue );
668 0 : SetConst( S.Top(), "_WHMAPMODE", $1.hashid, $1.nValue );
669 : }
670 0 : |
671 : ;
672 :
673 : var_definition
674 : : line_number
675 : | var_header var_body ';'
676 : {
677 70751 : S.Pop();
678 : }
679 70751 : | class_definition ';'
680 : | var_header_class class_body ';'
681 : {
682 2014 : if( TYPE_REF == $1.nTyp )
683 0 : pTC->pEH->Error( ERR_REFNOTALLOWED, S.Top().pClass,
684 0 : RscId( $1.nName1 ) );
685 :
686 2014 : if( S.Top().pClass->GetCount( S.Top() ) )
687 0 : pTC->pEH->Error( WRN_SUBINMEMBER, S.Top().pClass,
688 0 : RscId( $1.nName1 ) );
689 :
690 2014 : S.Pop();
691 : }
692 2014 : | var_header_class ';'
693 : {
694 2 : ERRTYPE aError;
695 2 : RscId aRscId( $1.nName1 );
696 :
697 2 : if( TYPE_NOTHING == $1.nTyp && aRscId.IsId() )
698 0 : aError = S.Top().pClass->SetRef( S.Top(), aRscId );
699 2 : else if( TYPE_COPY == $1.nTyp )
700 0 : aError = ERR_COPYNOTALLOWED;
701 2 : if( S.Top().pClass->GetCount( S.Top() ) )
702 0 : aError = WRN_SUBINMEMBER;
703 2 : if( aError.IsError() || aError.IsWarning() )
704 0 : pTC->pEH->Error( aError, S.Top().pClass, aRscId );
705 :
706 2 : S.Pop();
707 2 : }
708 2 : | XSCALE '=' '(' long_expression ',' long_expression ')' ';'
709 : {
710 0 : SetNumber( S.Top(), "_XNUMERATOR", $4 );
711 0 : SetNumber( S.Top(), "_XDENOMINATOR", $6 );
712 : }
713 0 : | YSCALE '=' '(' long_expression ',' long_expression ')' ';'
714 : {
715 0 : SetNumber( S.Top(), "_YNUMERATOR", $4 );
716 0 : SetNumber( S.Top(), "_YDENOMINATOR", $6 );
717 : }
718 0 : | RGB '=' '(' long_expression ',' long_expression
719 : ',' long_expression ')' ';'
720 : {
721 0 : SetNumber( S.Top(), "RED", $4 );
722 0 : SetNumber( S.Top(), "GREEN", $6 );
723 0 : SetNumber( S.Top(), "BLUE", $8 );
724 : }
725 0 : | GEOMETRY '=' xywh_mapmode '(' long_expression ',' long_expression ','
726 : long_expression ',' long_expression ')' ';'
727 : {
728 0 : SetNumber( S.Top(), "_X", $5 );
729 0 : SetNumber( S.Top(), "_Y", $7 );
730 0 : SetNumber( S.Top(), "_WIDTH", $9 );
731 0 : SetNumber( S.Top(), "_HEIGHT", $11 );
732 : }
733 0 : | POSITION '=' xy_mapmode '(' long_expression ',' long_expression
734 : ')' ';'
735 : {
736 230 : SetNumber( S.Top(), "_X", $5 );
737 230 : SetNumber( S.Top(), "_Y", $7 );
738 : }
739 230 : | DIMENSION '=' wh_mapmode '(' long_expression ',' long_expression
740 : ')' ';'
741 : {
742 288 : SetNumber( S.Top(), "_WIDTH", $5 );
743 288 : SetNumber( S.Top(), "_HEIGHT", $7 );
744 : }
745 288 : | INZOOMOUTPUTSIZE '=' CONSTNAME '(' long_expression ',' long_expression
746 : ')' ';'
747 : {
748 0 : SetConst( S.Top(), "_ZOOMINMAPMODE", $3.hashid, $3.nValue );
749 0 : SetNumber( S.Top(), "_ZOOMINWIDTH", $5 );
750 0 : SetNumber( S.Top(), "_ZOOMINHEIGHT", $7 );
751 : }
752 0 : | INZOOMOUTPUTSIZE '=' '(' long_expression ',' long_expression ')' ';'
753 : {
754 0 : SetNumber( S.Top(), "_ZOOMINWIDTH", $4 );
755 0 : SetNumber( S.Top(), "_ZOOMINHEIGHT", $6 );
756 : }
757 0 : | FLOATINGPOS '=' CONSTNAME '(' long_expression ',' long_expression
758 : ')' ';'
759 : {
760 0 : SetConst( S.Top(), "_FLOATINGPOSMAPMODE", $3.hashid, $3.nValue );
761 0 : SetNumber( S.Top(), "_FLOATINGPOSX", $5 );
762 0 : SetNumber( S.Top(), "_FLOATINGPOSY", $7 );
763 : }
764 0 : | FLOATINGPOS '=' '(' long_expression ',' long_expression ')' ';'
765 : {
766 0 : SetNumber( S.Top(), "_FLOATINGPOSX", $4 );
767 0 : SetNumber( S.Top(), "_FLOATINGPOSY", $6 );
768 : }
769 0 : ;
770 :
771 : var_header_class
772 : : VARNAME '=' class_header_body
773 : {
774 2016 : RSCINST aInst;
775 :
776 2016 : aInst = S.Top().pClass->GetVariable( S.Top(), $1, RSCINST(), false, $3.pClass );
777 :
778 2016 : if( aInst.pData )
779 2016 : S.Push( aInst );
780 : else
781 : {
782 0 : pTC->pEH->Error( ERR_NOVARIABLENAME, S.Top().pClass, RscId(),
783 0 : pHS->getString( $1 ).getStr() );
784 0 : return ERR_ERROR;
785 : }
786 :
787 2016 : if( !DoClassHeader( &$3, true ) )
788 0 : return ERR_ERROR;
789 2016 : $$ = $3;
790 : }
791 2016 : | VARNAME '[' CONSTNAME ']' '=' class_header_body
792 : {
793 0 : RSCINST aInst;
794 :
795 0 : aInst = S.Top().pClass->GetVariable( S.Top(), $1, RSCINST() );
796 :
797 0 : if( aInst.pData )
798 : {
799 0 : ERRTYPE aError;
800 0 : RSCINST aIdxInst;
801 :
802 0 : aError = aInst.pClass->GetArrayEle( aInst, $3.hashid, NULL, &aIdxInst );
803 0 : if( aError.IsError() || aError.IsWarning() )
804 0 : pTC->pEH->Error( aError, S.Top().pClass, RscId() );
805 0 : if( aError.IsError() )
806 0 : return ERR_ERROR;
807 0 : S.Push( aIdxInst );
808 : }
809 : else
810 : {
811 0 : pTC->pEH->Error( ERR_NOVARIABLENAME, S.Top().pClass, RscId(),
812 0 : pHS->getString( $1 ).getStr() );
813 0 : return ERR_ERROR;
814 : }
815 0 : if( !DoClassHeader( &$6, true ) )
816 0 : return ERR_ERROR;
817 0 : $$ = $6;
818 : }
819 0 : | VARNAME '[' SYMBOL ']' '=' class_header_body
820 : {
821 0 : RSCINST aInst;
822 :
823 0 : aInst = S.Top().pClass->GetVariable( S.Top(), $1, RSCINST() );
824 :
825 0 : if( aInst.pData )
826 : {
827 0 : long nNewLang = pTC->AddLanguage( $3 );
828 0 : ERRTYPE aError;
829 0 : RSCINST aIdxInst;
830 :
831 0 : aError = aInst.pClass->GetArrayEle( aInst, nNewLang, NULL, &aIdxInst );
832 0 : if( aError.IsError() || aError.IsWarning() )
833 0 : pTC->pEH->Error( aError, S.Top().pClass, RscId() );
834 0 : if( aError.IsError() )
835 0 : return ERR_ERROR;
836 0 : S.Push( aIdxInst );
837 : }
838 : else
839 : {
840 0 : pTC->pEH->Error( ERR_NOVARIABLENAME, S.Top().pClass, RscId(),
841 0 : pHS->getString( $1 ).getStr() );
842 0 : return ERR_ERROR;
843 : }
844 0 : if( !DoClassHeader( &$6, true ) )
845 0 : return ERR_ERROR;
846 0 : $$ = $6;
847 : }
848 0 : ;
849 :
850 : var_header
851 : : VARNAME '='
852 : {
853 39598 : RSCINST aInst;
854 :
855 39598 : aInst = S.Top().pClass->GetVariable( S.Top(), $1, RSCINST() );
856 :
857 39598 : if( aInst.pData )
858 39598 : S.Push( aInst );
859 : else
860 : {
861 0 : pTC->pEH->Error( ERR_NOVARIABLENAME, S.Top().pClass, RscId(),
862 0 : pHS->getString( $1 ).getStr() );
863 0 : return ERR_ERROR;
864 : }
865 : }
866 39598 : | VARNAME '[' CONSTNAME ']' '='
867 : {
868 31153 : RSCINST aInst;
869 :
870 31153 : aInst = S.Top().pClass->GetVariable( S.Top(), $1, RSCINST() );
871 :
872 31153 : if( aInst.pData )
873 : {
874 31153 : ERRTYPE aError;
875 31153 : RSCINST aIdxInst;
876 :
877 31153 : aError = aInst.pClass->GetArrayEle( aInst, $3.hashid, NULL, &aIdxInst );
878 31153 : if( aError.IsError() || aError.IsWarning() )
879 0 : pTC->pEH->Error( aError, S.Top().pClass, RscId() );
880 31153 : if( aError.IsError() )
881 0 : return ERR_ERROR;
882 31153 : S.Push( aIdxInst );
883 : }
884 : else
885 : {
886 0 : pTC->pEH->Error( ERR_NOVARIABLENAME, S.Top().pClass, RscId(),
887 0 : pHS->getString( $1 ).getStr() );
888 0 : return ERR_ERROR;
889 : }
890 : }
891 31153 : | VARNAME '[' SYMBOL ']' '='
892 : {
893 0 : RSCINST aInst;
894 :
895 0 : aInst = S.Top().pClass->GetVariable( S.Top(), $1, RSCINST() );
896 :
897 0 : if( aInst.pData )
898 : {
899 0 : long nNewLang = pTC->AddLanguage( $3 );
900 0 : ERRTYPE aError;
901 0 : RSCINST aIdxInst;
902 :
903 0 : aError = aInst.pClass->GetArrayEle( aInst, nNewLang, NULL, &aIdxInst );
904 0 : if( aError.IsError() || aError.IsWarning() )
905 0 : pTC->pEH->Error( aError, S.Top().pClass, RscId() );
906 0 : if( aError.IsError() )
907 0 : return ERR_ERROR;
908 0 : S.Push( aIdxInst );
909 : }
910 : else
911 : {
912 0 : pTC->pEH->Error( ERR_NOVARIABLENAME, S.Top().pClass, RscId(),
913 0 : pHS->getString( $1 ).getStr() );
914 0 : return ERR_ERROR;
915 : }
916 : }
917 0 : ;
918 :
919 : tupel_header0
920 : :
921 : {
922 3438 : RSCINST aInst;
923 :
924 3438 : aInst = S.Top().pClass->GetTupelVar( S.Top(), 0, RSCINST() );
925 3438 : if( aInst.pData )
926 3438 : S.Push( aInst );
927 : else
928 : {
929 0 : pTC->pEH->Error( ERR_NOTUPELNAME, S.Top().pClass, RscId() );
930 0 : return ERR_ERROR;
931 : }
932 : }
933 3438 : ;
934 :
935 : tupel_header1
936 : :
937 : {
938 2923 : RSCINST aInst;
939 :
940 2923 : aInst = S.Top().pClass->GetTupelVar( S.Top(), 1, RSCINST() );
941 2923 : if( aInst.pData )
942 2923 : S.Push( aInst );
943 : else
944 : {
945 0 : pTC->pEH->Error( ERR_NOTUPELNAME, S.Top().pClass, RscId() );
946 0 : return ERR_ERROR;
947 : }
948 : }
949 2923 : ;
950 :
951 : tupel_header2
952 : :
953 : {
954 0 : RSCINST aInst;
955 :
956 0 : aInst = S.Top().pClass->GetTupelVar( S.Top(), 2, RSCINST() );
957 0 : if( aInst.pData )
958 0 : S.Push( aInst );
959 : else
960 : {
961 0 : pTC->pEH->Error( ERR_NOTUPELNAME, S.Top().pClass, RscId() );
962 0 : return ERR_ERROR;
963 : }
964 : }
965 0 : ;
966 :
967 : tupel_header3
968 : :
969 : {
970 0 : RSCINST aInst;
971 :
972 0 : aInst = S.Top().pClass->GetTupelVar( S.Top(), 3, RSCINST() );
973 0 : if( !aInst.pData )
974 : {
975 0 : pTC->pEH->Error( ERR_NOTUPELNAME, S.Top().pClass, RscId() );
976 0 : return ERR_ERROR;
977 : }
978 0 : S.Push( aInst );
979 : }
980 0 : ;
981 :
982 : tupel_body
983 : : var_body
984 : {
985 6361 : S.Pop();
986 : }
987 6361 : ;
988 :
989 : var_list_header
990 : :
991 : {
992 3438 : ERRTYPE aError;
993 3438 : RSCINST aInst;
994 :
995 10314 : aError = S.Top().pClass->GetElement( S.Top(), RscId(),
996 10314 : NULL, RSCINST(), &aInst );
997 3438 : if( aError.IsError() || aError.IsWarning() )
998 0 : pTC->pEH->Error( aError, S.Top().pClass, RscId() );
999 3438 : if( aError.IsError() )
1000 : { // unbedingt Instanz auf den Stack bringen
1001 0 : aInst = S.Top().pClass->Create( NULL, RSCINST() );
1002 : }
1003 3438 : S.Push( aInst );
1004 : }
1005 3438 : ;
1006 :
1007 : list_body
1008 : : var_bodycomplex
1009 : {
1010 3438 : S.Pop();
1011 : }
1012 3438 : ;
1013 :
1014 : list_header
1015 : :
1016 : {
1017 2180 : sal_uInt32 nCount = S.Top().pClass->GetCount( S.Top() );
1018 : sal_uInt32 i;
1019 :
1020 2180 : for( i = nCount; i > 0; i-- )
1021 0 : S.Top().pClass->DeletePos( S.Top(), i -1 );
1022 : }
1023 2180 : ;
1024 :
1025 : list
1026 : : list var_list_header list_body ';'
1027 : | list var_bodysimple ';'
1028 : | list class_definition ';'
1029 : | list line_number
1030 : |
1031 : ;
1032 :
1033 : var_bodysimple
1034 : : macro_expression
1035 : {
1036 : sal_Int32 l;
1037 14824 : ERRTYPE aError;
1038 :
1039 14824 : if( !$1.Evaluate( &l ) )
1040 0 : pTC->pEH->Error( ERR_ZERODIVISION, NULL, RscId() );
1041 : else
1042 : {
1043 14824 : aError = S.Top().pClass->SetRef( S.Top(), RscId( $1 ) );
1044 14824 : if( aError.IsError() )
1045 : {
1046 8139 : aError.Clear();
1047 8139 : aError = S.Top().pClass->SetNumber( S.Top(), l );
1048 : }
1049 14824 : if( aError.IsError() )
1050 : { // Aufwaertskompatible, Tupel probieren
1051 0 : RSCINST aInst = GetFirstTupelEle( S.Top() );
1052 0 : if( aInst.pData )
1053 : {
1054 0 : aError.Clear(); // Fehler zuruecksetzen
1055 0 : aError = aInst.pClass->SetRef( aInst, RscId( $1 ) );
1056 0 : if( aError.IsError() )
1057 : {
1058 0 : aError.Clear();
1059 0 : aError = aInst.pClass->SetNumber( aInst, l );
1060 : }
1061 : }
1062 : }
1063 : }
1064 :
1065 14824 : if( $1.IsExpression() )
1066 0 : delete $1.aExp.pExp;
1067 :
1068 14824 : if( aError.IsError() || aError.IsWarning() )
1069 0 : pTC->pEH->Error( aError, S.Top().pClass, RscId() );
1070 : }
1071 14824 : | CONSTNAME
1072 : {
1073 225 : ERRTYPE aError;
1074 225 : aError = S.Top().pClass->SetConst( S.Top(), $1.hashid, $1.nValue );
1075 225 : if( aError.IsError() )
1076 : { // Aufwaertskompatible, Tupel probieren
1077 0 : RSCINST aInst = GetFirstTupelEle( S.Top() );
1078 0 : if( aInst.pData )
1079 : {
1080 0 : aError.Clear(); // Fehler zuruecksetzen
1081 0 : aError = aInst.pClass->SetConst( aInst, $1.hashid, $1.nValue );
1082 : }
1083 : }
1084 :
1085 225 : if( aError.IsError() || aError.IsWarning() )
1086 0 : pTC->pEH->Error( aError, S.Top().pClass, RscId() );
1087 : }
1088 225 : | NOT CONSTNAME
1089 : {
1090 0 : ERRTYPE aError;
1091 0 : aError = S.Top().pClass->SetNotConst( S.Top(), $2.hashid );
1092 0 : if( aError.IsError() )
1093 : { // Aufwaertskompatible, Tupel probieren
1094 0 : RSCINST aInst = GetFirstTupelEle( S.Top() );
1095 0 : if( aInst.pData )
1096 : {
1097 0 : aError.Clear(); // Fehler zuruecksetzen
1098 0 : aError = aInst.pClass->SetNotConst( aInst, $2.hashid );
1099 : }
1100 : }
1101 :
1102 0 : if( aError.IsError() || aError.IsWarning() )
1103 0 : pTC->pEH->Error( aError, S.Top().pClass, RscId() );
1104 : }
1105 0 : | BOOLEAN
1106 : {
1107 2077 : ERRTYPE aError;
1108 2077 : aError = S.Top().pClass->SetBool( S.Top(), $1 );
1109 2077 : if( aError.IsError() )
1110 : { // Aufwaertskompatible, Tupel probieren
1111 0 : RSCINST aInst = GetFirstTupelEle( S.Top() );
1112 0 : if( aInst.pData )
1113 : {
1114 0 : aError.Clear(); // Fehler zuruecksetzen
1115 0 : aError = aInst.pClass->SetBool( aInst, $1 );
1116 : }
1117 : }
1118 :
1119 2077 : if( aError.IsError() || aError.IsWarning() )
1120 0 : pTC->pEH->Error( aError, S.Top().pClass, RscId() );
1121 : }
1122 2077 : | string_multiline
1123 : {
1124 63181 : ERRTYPE aError;
1125 63181 : aError = S.Top().pClass->SetString( S.Top(), $1 );
1126 63181 : if( aError.IsError() )
1127 : { // Aufwaertskompatible, Tupel probieren
1128 93 : RSCINST aInst = GetFirstTupelEle( S.Top() );
1129 93 : if( aInst.pData )
1130 : {
1131 93 : aError.Clear(); // Fehler zuruecksetzen
1132 93 : aError = aInst.pClass->SetString( aInst, $1 );
1133 : }
1134 : }
1135 :
1136 63181 : if( aError.IsError() || aError.IsWarning() )
1137 0 : pTC->pEH->Error( aError, S.Top().pClass, RscId() );
1138 : }
1139 63181 : | DEFAULT
1140 : ;
1141 :
1142 : var_bodycomplex
1143 : : '{' list_header list '}'
1144 : | '<' tupel_header0 tupel_body ';' '>'
1145 : | '<' tupel_header0 tupel_body ';' tupel_header1 tupel_body ';' '>'
1146 : | '<' tupel_header0 tupel_body ';' tupel_header1 tupel_body ';'
1147 : tupel_header2 tupel_body ';' '>'
1148 : | '<' tupel_header0 tupel_body ';' tupel_header1 tupel_body ';'
1149 : tupel_header2 tupel_body ';' tupel_header3 tupel_body ';' '>'
1150 : ;
1151 :
1152 : var_body
1153 : : var_bodysimple
1154 : | var_bodycomplex
1155 : ;
1156 :
1157 : string_multiline
1158 : : STRING
1159 : {
1160 63182 : $$ = $1;
1161 : }
1162 63182 : | string_multiline STRING
1163 : {
1164 1061 : rtl::OStringBuffer aBuf( 256 );
1165 1061 : aBuf.append( $1 );
1166 1061 : aBuf.append( $2 );
1167 1061 : $$ = const_cast<char*>(pStringContainer->putString( aBuf.getStr() ));
1168 1061 : }
1169 1061 : ;
1170 :
1171 : long_expression
1172 : : macro_expression
1173 : {
1174 1036 : if( !$1.Evaluate( &$$ ) )
1175 0 : pTC->pEH->Error( ERR_ZERODIVISION, NULL, RscId() );
1176 1036 : if( $1.IsExpression() )
1177 0 : delete $1.aExp.pExp;
1178 : }
1179 1036 : ;
1180 :
1181 : macro_expression
1182 : : RSCDEFINE
1183 : {
1184 0 : $$.cType = RSCEXP_DEF;
1185 0 : $$.aExp.pDef = $1;
1186 : }
1187 0 : | NUMBER
1188 : {
1189 84073 : $$.cType = RSCEXP_LONG;
1190 84073 : $$.SetLong( $1 );
1191 : }
1192 84073 : | '-' macro_expression %prec UNARYMINUS
1193 : {
1194 6 : if( $2.IsNumber() ){
1195 6 : $$.cType = $2.cType;
1196 6 : $$.SetLong( - $2.GetLong() );
1197 : }
1198 : else
1199 : {
1200 : RscExpType aLeftExp;
1201 :
1202 0 : aLeftExp.cType = RSCEXP_NOTHING;
1203 0 : $$.cType = RSCEXP_EXP;
1204 0 : $$.aExp.pExp = new RscExpression( aLeftExp, '-', $2 );
1205 : }
1206 : }
1207 6 : | '+' macro_expression %prec UNARYPLUS
1208 : {
1209 0 : $$ = $2;
1210 : }
1211 0 : | macro_expression '+' macro_expression
1212 : {
1213 32935 : if( $1.IsNumber() && $3.IsNumber() )
1214 : {
1215 32935 : $$.cType = RSCEXP_LONG;
1216 32935 : $$.SetLong( $1.GetLong() + $3.GetLong() );
1217 : }
1218 : else
1219 : {
1220 0 : $$.cType = RSCEXP_EXP;
1221 0 : $$.aExp.pExp = new RscExpression( $1, '+', $3 );
1222 : }
1223 : }
1224 32935 : | macro_expression '-' macro_expression
1225 : {
1226 55 : if( $1.IsNumber() && $3.IsNumber() )
1227 : {
1228 55 : $$.cType = RSCEXP_LONG;
1229 55 : $$.SetLong( $1.GetLong() - $3.GetLong() );
1230 : }
1231 : else
1232 : {
1233 0 : $$.cType = RSCEXP_EXP;
1234 0 : $$.aExp.pExp = new RscExpression( $1, '-', $3 );
1235 : }
1236 : }
1237 55 : | macro_expression '*' macro_expression
1238 : {
1239 111 : if( $1.IsNumber() && $3.IsNumber() )
1240 : {
1241 111 : $$.cType = RSCEXP_LONG;
1242 111 : $$.SetLong( $1.GetLong() * $3.GetLong() );
1243 : }
1244 : else
1245 : {
1246 0 : $$.cType = RSCEXP_EXP;
1247 0 : $$.aExp.pExp = new RscExpression( $1, '*', $3 );
1248 : }
1249 : }
1250 111 : | macro_expression '/' macro_expression
1251 : {
1252 0 : if( $1.IsNumber() && $3.IsNumber() )
1253 : {
1254 0 : if( 0 == $3.GetLong() )
1255 : {
1256 0 : $$.cType = RSCEXP_EXP;
1257 0 : $$.aExp.pExp = new RscExpression( $1, '/', $3 );
1258 : }
1259 : else
1260 : {
1261 0 : $$.cType = RSCEXP_LONG;
1262 0 : $$.SetLong( $1.GetLong() / $3.GetLong() );
1263 : }
1264 : }
1265 : else
1266 : {
1267 0 : $$.cType = RSCEXP_EXP;
1268 0 : $$.aExp.pExp = new RscExpression( $1, '/', $3 );
1269 : }
1270 : }
1271 0 : | macro_expression '&' macro_expression
1272 : {
1273 295 : if( $1.IsNumber() && $3.IsNumber() )
1274 : {
1275 295 : $$.cType = RSCEXP_LONG;
1276 295 : $$.SetLong( $1.GetLong() & $3.GetLong() );
1277 : }
1278 : else
1279 : {
1280 0 : $$.cType = RSCEXP_EXP;
1281 0 : $$.aExp.pExp = new RscExpression( $1, '&', $3 );
1282 : }
1283 : }
1284 295 : | macro_expression '|' macro_expression
1285 : {
1286 772 : if( $1.IsNumber() && $3.IsNumber() )
1287 : {
1288 772 : $$.cType = RSCEXP_LONG;
1289 772 : $$.SetLong( $1.GetLong() | $3.GetLong() );
1290 : }
1291 : else
1292 : {
1293 0 : $$.cType = RSCEXP_EXP;
1294 0 : $$.aExp.pExp = new RscExpression( $1, '|', $3 );
1295 : }
1296 : }
1297 772 : | '(' macro_expression ')'
1298 : {
1299 40419 : $$ = $2;
1300 : }
1301 40419 : | macro_expression LEFTSHIFT macro_expression
1302 : {
1303 831 : if( $1.IsNumber() && $3.IsNumber() )
1304 : {
1305 831 : $$.cType = RSCEXP_LONG;
1306 831 : $$.SetLong( $1.GetLong() << $3.GetLong() );
1307 : }
1308 : else
1309 : {
1310 0 : $$.cType = RSCEXP_EXP;
1311 0 : $$.aExp.pExp = new RscExpression( $1, 'l', $3 );
1312 : }
1313 : }
1314 831 : | macro_expression RIGHTSHIFT macro_expression
1315 : {
1316 0 : if( $1.IsNumber() && $3.IsNumber() )
1317 : {
1318 0 : $$.cType = RSCEXP_LONG;
1319 0 : $$.SetLong( $1.GetLong() >> $3.GetLong() );
1320 : }
1321 : else
1322 : {
1323 0 : $$.cType = RSCEXP_EXP;
1324 0 : $$.aExp.pExp = new RscExpression( $1, 'r', $3 );
1325 : }
1326 : }
1327 0 : ;
1328 :
1329 : id_expression
1330 : : id_expression line_number
1331 : | macro_expression
1332 : { // pExpession auswerten und loeschen
1333 33214 : if( RSCEXP_EXP == $1.cType )
1334 : {
1335 : sal_Int32 lValue;
1336 :
1337 0 : if( !$1.Evaluate( &lValue ) )
1338 0 : pTC->pEH->Error( ERR_ZERODIVISION, NULL, RscId() );
1339 0 : delete $1.aExp.pExp;
1340 0 : $$.cType = RSCEXP_LONG;
1341 0 : $$.SetLong( lValue );
1342 : }
1343 : else
1344 : {
1345 33214 : $$ = $1;
1346 : }
1347 : }
1348 33214 : ;
1349 :
1350 : DUMMY_NUMBER
1351 : : NUMBER
1352 : {
1353 : }
1354 0 : |
1355 : {
1356 : }
1357 363 : ;
1358 :
1359 : line_number
1360 : : '#' LINE NUMBER STRING
1361 : {
1362 : RscFile * pFName;
1363 :
1364 0 : pFI->SetLineNo( $3 );
1365 0 : pFI->SetFileIndex( pTC->aFileTab.NewCodeFile( rtl::OString( $4 ) ) );
1366 0 : pFName = pTC->aFileTab.Get( pFI->GetFileIndex() );
1367 0 : pFName->bLoaded = true;
1368 0 : pFName->bScanned = true;
1369 : }
1370 0 : | '#' NUMBER STRING DUMMY_NUMBER
1371 : {
1372 : RscFile * pFName;
1373 :
1374 363 : pFI->SetLineNo( $2 );
1375 363 : pFI->SetFileIndex( pTC->aFileTab.NewCodeFile( rtl::OString( $3 ) ) );
1376 363 : pFName = pTC->aFileTab.Get( pFI->GetFileIndex() );
1377 363 : pFName->bLoaded = true;
1378 363 : pFName->bScanned = true;
1379 : }
1380 363 : | '#' NUMBER
1381 : {
1382 1379 : pFI->SetLineNo( $2 );
1383 : }
1384 1379 : ;
1385 :
1386 : %%
1387 : #if defined _MSC_VER
1388 : #pragma warning(pop)
1389 : #endif
1390 :
1391 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
1392 :
1393 :
|
