?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
merge the formfield patch from ooo-build
[ooovba.git] / rsc / source / parser / rscyacc.y
blob032e775177999d661986cfe4ece3ab852f42b95a
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: header.hxx,v $
10 * $Revision: 1.1 $
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 %{
32 #if defined __GNUC__
33 #pragma GCC system_header
34 #elif defined __SUNPRO_CC
35 #pragma disable_warn
36 #endif
37 %}
38
39 /* Compilerstack */
40
41 %union {
42 Atom varid;
43 struct {
44 Atom hashid;
45 INT32 nValue;
46 } constname;
47 RscTop * pClass;
48 RSCHEADER header;
49 struct {
50 CLASS_DATA pData;
51 RscTop * pClass;
52 } instance;
53 INT32 value;
54 USHORT ushort;
55 short exp_short;
56 char * string;
57 BOOL svbool;
58 REF_ENUM copyref;
59 RscDefine * defineele;
60 CharSet charset;
61 RscExpType macrostruct;
62 }
63
64 /* Token */
65 %token <value> NUMBER
66 %token <string> SYMBOL
67 %token <defineele> RSCDEFINE
68 %token <string> STRING
69 %token <string> INCLUDE_STRING
70 %token <character> CHARACTER
71 %token <svbool> BOOLEAN
72
73 %token LINE
74 %token AUTO_ID
75 %token NOT
76 %token XSCALE
77 %token YSCALE
78 %token RGB
79 %token GEOMETRY
80 %token POSITION
81 %token DIMENSION
82 %token INZOOMOUTPUTSIZE
83 %token FLOATINGPOS
84 %token DEFINE
85 %token INCLUDE
86 %token MACROTARGET
87 %token DEFAULT
88
89
90 %token <pClass> CLASSNAME
91 %token <varid> VARNAME
92 %token <constname> CONSTNAME
93 %token CLASS
94 %token EXTENDABLE
95 %token WRITEIFSET
96
97
98 %type <macrostruct> macro_expression
99 %type <macrostruct> id_expression
100 %type <value> long_expression
101 %type <string> string_multiline
102
103 %type <pClass> type
104 %type <pClass> type_base
105 %type <header> class_header_body
106 %type <header> class_header
107 %type <header> var_header_class
108 %type <copyref> copy_ref
109 %type <ushort> type_flags
110
111
112 %left '|'
113 %left '&'
114 %left LEFTSHIFT RIGHTSHIFT
115 %left '+' '-'
116 %left '*' '/'
117 %left UNARYMINUS
118 %left UNARYPLUS
119 %left ','
120 %left '(' ')'
121
122
123 /* Grammatik */
124
125 %start resource_definitions
126
127 %%
128
129 /********************** D E F I N I T I O N S ****************************/
130 resource_definitions
131 :
132 | resource_definitions resource_definition
133 | MACROTARGET macro_expression
134 {
135 RscExpType aExpType;
136 INT32 lValue;
137
138 aExpType.cType = RSCEXP_NOTHING;
139 pExp = new RscExpression( aExpType, '+', $2 );
140 if( !pExp->Evaluate( &lValue ) )
141 pTC->pEH->Error( ERR_ZERODIVISION, NULL, RscId() );
142 }
143 ;
144
145 resource_definition
146 : line_number
147 | '#' DEFINE SYMBOL macro_expression
148 {
149 BOOL bError = FALSE;
150
151 if( $4.IsNumber() ){
152 if( !pTC->aFileTab.NewDef( pFI->GetFileIndex(),
153 ByteString( $3 ),
154 $4.GetLong(), LIST_APPEND ) )
155 bError = TRUE;
156 }
157 else if( $4.IsDefinition() ){
158 RscExpType aExpType;
159 RscExpression * pExpr;
160
161 aExpType.cType = RSCEXP_NOTHING;
162 aExpType.SetLong( 0 );
163 aExpType.cType = RSCEXP_LONG;
164 pExpr = new RscExpression( aExpType, '+', $4 );
165
166 if( !pTC->aFileTab.NewDef( pFI->GetFileIndex(),
167 ByteString( $3 ), pExpr, LIST_APPEND ) )
168 bError = TRUE;
169 }
170 else if( $4.IsExpression() ){
171 if( !pTC->aFileTab.NewDef( pFI->GetFileIndex(),
172 ByteString( $3 ), $4.aExp.pExp,
173 LIST_APPEND ) )
174 bError = TRUE;
175 }
176
177 if( bError ){
178 pTC->pEH->Error( ERR_DECLAREDEFINE, NULL, RscId(), $3 );
179 }
180 }
181 | '#' DEFINE RSCDEFINE macro_expression
182 {
183 pTC->pEH->Error( ERR_DOUBLEDEFINE, NULL, RscId(), $3->GetName().GetBuffer() );
184 }
185 | '#' INCLUDE STRING
186 {
187 }
188 | '#' INCLUDE INCLUDE_STRING
189 {
190 }
191 | class_definition ';'
192 {
193 #ifdef D40
194 void * pMem;
195 pMem = rtl_allocateMemory( 20000 );
196 rtl_freeMemory( pMem );
197 #endif
198 }
199 | new_class_definition_header '{' new_class_definition_body '}' ';'
200 | new_class_definition_header ';'
201 ;
202
203 new_class_definition_header
204 : CLASS SYMBOL id_expression ':' CLASSNAME
205 {
206 INT32 lType;
207
208 $3.Evaluate( &lType );
209
210 // Klasse anlegen
211 Atom nId = pHS->getID( $2 );
212 pCurClass = new RscClass( nId, lType, $5 );
213 nCurMask = 1;
214 pTC->aNmTb.Put( nId, CLASSNAME, pCurClass );
215 pTC->GetRoot()->Insert( pCurClass );
216 }
217 | CLASS CLASSNAME id_expression ':' CLASSNAME
218 {
219 pCurClass = $2;
220 nCurMask = 1;
221 }
222 ;
223
224 new_class_definition_body
225 :
226 | property_definition ';' new_class_definition_body
227 ;
228
229 property_definition
230 : type_flags type SYMBOL
231 {
232 // Variable anlegen
233 Atom nId = pTC->aNmTb.Put( $3, VARNAME );
234 pCurClass->SetVariable( nId, $2, NULL, $1, nCurMask );
235 nCurMask <<= 1;
236 }
237 | type_flags type VARNAME
238 {
239 pCurClass->SetVariable( $3, $2, NULL, $1, nCurMask );
240 nCurMask <<= 1;
241 }
242 ;
243
244 type_flags
245 : type_flags EXTENDABLE
246 {
247 $$ = $1 | VAR_EXTENDABLE;
248 }
249 | type_flags WRITEIFSET
250 {
251 $$ = $1 | VAR_SVDYNAMIC;
252 }
253 |
254 {
255 $$ = 0;
256 }
257 ;
258
259 type
260 : type_base
261 {
262 $$ = $1;
263 }
264 | type_base '[' ']'
265 {
266 if( $1 )
267 {
268 ByteString aTypeName = pHS->getString( $1->GetId() );
269 aTypeName += "[]";
270 $$ = pTC->SearchType( pHS->getID( aTypeName.GetBuffer(), true ) );
271 if( !$$ )
272 {
273 RscCont * pCont;
274 pCont = new RscCont( pHS->getID( aTypeName.GetBuffer() ), RSC_NOTYPE );
275 pCont->SetTypeClass( $1 );
276 pTC->InsertType( pCont );
277 $$ = pCont;
278 }
279 }
280 else
281 $$ = NULL;
282 }
283 ;
284
285 type_base
286 : CLASSNAME
287 {
288 $$ = $1;
289 }
290 | SYMBOL
291 {
292 RscTop * pType = pTC->SearchType( pHS->getID( $1, true ) );
293 if( !pType )
294 pTC->pEH->Error( ERR_NOTYPE, pCurClass, RscId() );
295 $$ = pType;
296 }
297 ;
298
299 class_definition
300 : class_header class_body
301 {
302 if( TYPE_REF == $1.nTyp )
303 pTC->pEH->Error( ERR_REFNOTALLOWED, S.Top().pClass,
304 RscId( $1.nName1 ) );
305 S.Pop();
306 }
307 | class_header
308 {
309 ERRTYPE aError;
310 RscId aRscId( $1.nName1 );
311
312 if( TYPE_NOTHING == $1.nTyp && aRscId.IsId() )
313 aError = S.Top().pClass->SetRef( S.Top(), aRscId );
314 else if( TYPE_COPY == $1.nTyp )
315 aError = ERR_COPYNOTALLOWED;
316 if( aError.IsError() || aError.IsWarning() )
317 pTC->pEH->Error( aError, S.Top().pClass, aRscId );
318 S.Pop();
319 }
320 ;
321
322 class_header
323 : class_header_body
324 {
325 if( !DoClassHeader( &$1, FALSE ) )
326 return( ERR_ERROR );
327 $$ = $1;
328 }
329 ;
330
331 copy_ref
332 : '<'
333 {
334 $$ = TYPE_COPY;
335 }
336 | ','
337 {
338 $$ = TYPE_REF;
339 }
340 ;
341
342 class_header_body
343 : CLASSNAME id_expression copy_ref CLASSNAME id_expression
344 {
345 $$.pClass = $1;
346 $$.nName1 = $2;
347 $$.nTyp = $3;
348 $$.pRefClass = $4;
349 $$.nName2 = $5;
350 }
351 | CLASSNAME id_expression copy_ref id_expression
352 {
353 $$.pClass = $1;
354 $$.nName1 = $2;
355 $$.nTyp = $3;
356 $$.pRefClass = NULL;
357 $$.nName2 = $4;
358 }
359 | CLASSNAME id_expression
360 {
361 $$.pClass = $1;
362 $$.nName1 = $2;
363 $$.nTyp = TYPE_NOTHING;
364 $$.pRefClass = NULL;
365 $$.nName2.cType = RSCEXP_NOTHING;
366 }
367 | CLASSNAME copy_ref id_expression
368 {
369 $$.pClass = $1;
370 $$.nName1.cType = RSCEXP_NOTHING;
371 $$.nTyp = $2;
372 $$.pRefClass = NULL;
373 $$.nName2 = $3;
374 }
375 | CLASSNAME copy_ref CLASSNAME id_expression
376 {
377 $$.pClass = $1;
378 $$.nName1.cType = RSCEXP_NOTHING;
379 $$.nTyp = $2;
380 $$.pRefClass = $3;
381 $$.nName2 = $4;
382 }
383 | CLASSNAME
384 {
385 $$.pClass = $1;
386 $$.nName1.cType = RSCEXP_NOTHING;
387 $$.nTyp = TYPE_NOTHING;
388 $$.nName2.cType = RSCEXP_NOTHING;
389 }
390 ;
391
392 class_body
393 : '{' var_definitions '}'
394 | '{' '}'
395 | string_multiline
396 {
397 SetString( S.Top(), "TEXT", $1 );
398 }
399 ;
400
401 var_definitions
402 : var_definition
403 | var_definitions var_definition
404 ;
405
406 xy_mapmode
407 : CONSTNAME
408 {
409 SetConst( S.Top(), "_XYMAPMODE", $1.hashid, $1.nValue );
410 }
411 |
412 ;
413
414 wh_mapmode
415 : CONSTNAME
416 {
417 SetConst( S.Top(), "_WHMAPMODE", $1.hashid, $1.nValue );
418 }
419 |
420 ;
421
422 xywh_mapmode
423 : CONSTNAME
424 {
425 SetConst( S.Top(), "_XYMAPMODE", $1.hashid, $1.nValue );
426 SetConst( S.Top(), "_WHMAPMODE", $1.hashid, $1.nValue );
427 }
428 |
429 ;
430
431 var_definition
432 : line_number
433 | var_header var_body ';'
434 {
435 S.Pop();
436 }
437 | class_definition ';'
438 | var_header_class class_body ';'
439 {
440 if( TYPE_REF == $1.nTyp )
441 pTC->pEH->Error( ERR_REFNOTALLOWED, S.Top().pClass,
442 RscId( $1.nName1 ) );
443
444 if( S.Top().pClass->GetCount( S.Top() ) )
445 pTC->pEH->Error( WRN_SUBINMEMBER, S.Top().pClass,
446 RscId( $1.nName1 ) );
447
448 S.Pop();
449 }
450 | var_header_class ';'
451 {
452 ERRTYPE aError;
453 RscId aRscId( $1.nName1 );
454
455 if( TYPE_NOTHING == $1.nTyp && aRscId.IsId() )
456 aError = S.Top().pClass->SetRef( S.Top(), aRscId );
457 else if( TYPE_COPY == $1.nTyp )
458 aError = ERR_COPYNOTALLOWED;
459 if( S.Top().pClass->GetCount( S.Top() ) )
460 aError = WRN_SUBINMEMBER;
461 if( aError.IsError() || aError.IsWarning() )
462 pTC->pEH->Error( aError, S.Top().pClass, aRscId );
463
464 S.Pop();
465 }
466 | XSCALE '=' '(' long_expression ',' long_expression ')' ';'
467 {
468 SetNumber( S.Top(), "_XNUMERATOR", $4 );
469 SetNumber( S.Top(), "_XDENOMINATOR", $6 );
470 }
471 | YSCALE '=' '(' long_expression ',' long_expression ')' ';'
472 {
473 SetNumber( S.Top(), "_YNUMERATOR", $4 );
474 SetNumber( S.Top(), "_YDENOMINATOR", $6 );
475 }
476 | RGB '=' '(' long_expression ',' long_expression
477 ',' long_expression ')' ';'
478 {
479 SetNumber( S.Top(), "RED", $4 );
480 SetNumber( S.Top(), "GREEN", $6 );
481 SetNumber( S.Top(), "BLUE", $8 );
482 }
483 | GEOMETRY '=' xywh_mapmode '(' long_expression ',' long_expression ','
484 long_expression ',' long_expression ')' ';'
485 {
486 SetNumber( S.Top(), "_X", $5 );
487 SetNumber( S.Top(), "_Y", $7 );
488 SetNumber( S.Top(), "_WIDTH", $9 );
489 SetNumber( S.Top(), "_HEIGHT", $11 );
490 }
491 | POSITION '=' xy_mapmode '(' long_expression ',' long_expression
492 ')' ';'
493 {
494 SetNumber( S.Top(), "_X", $5 );
495 SetNumber( S.Top(), "_Y", $7 );
496 }
497 | DIMENSION '=' wh_mapmode '(' long_expression ',' long_expression
498 ')' ';'
499 {
500 SetNumber( S.Top(), "_WIDTH", $5 );
501 SetNumber( S.Top(), "_HEIGHT", $7 );
502 }
503 | INZOOMOUTPUTSIZE '=' CONSTNAME '(' long_expression ',' long_expression
504 ')' ';'
505 {
506 SetConst( S.Top(), "_ZOOMINMAPMODE", $3.hashid, $3.nValue );
507 SetNumber( S.Top(), "_ZOOMINWIDTH", $5 );
508 SetNumber( S.Top(), "_ZOOMINHEIGHT", $7 );
509 }
510 | INZOOMOUTPUTSIZE '=' '(' long_expression ',' long_expression ')' ';'
511 {
512 SetNumber( S.Top(), "_ZOOMINWIDTH", $4 );
513 SetNumber( S.Top(), "_ZOOMINHEIGHT", $6 );
514 }
515 | FLOATINGPOS '=' CONSTNAME '(' long_expression ',' long_expression
516 ')' ';'
517 {
518 SetConst( S.Top(), "_FLOATINGPOSMAPMODE", $3.hashid, $3.nValue );
519 SetNumber( S.Top(), "_FLOATINGPOSX", $5 );
520 SetNumber( S.Top(), "_FLOATINGPOSY", $7 );
521 }
522 | FLOATINGPOS '=' '(' long_expression ',' long_expression ')' ';'
523 {
524 SetNumber( S.Top(), "_FLOATINGPOSX", $4 );
525 SetNumber( S.Top(), "_FLOATINGPOSY", $6 );
526 }
527 ;
528
529 var_header_class
530 : VARNAME '=' class_header_body
531 {
532 RSCINST aInst;
533
534 aInst = S.Top().pClass->GetVariable( S.Top(), $1, RSCINST(), FALSE, $3.pClass );
535
536 if( aInst.pData )
537 S.Push( aInst );
538 else
539 {
540 pTC->pEH->Error( ERR_NOVARIABLENAME, S.Top().pClass, RscId(),
541 pHS->getString( $1 ) );
542 return( ERR_ERROR );
543 };
544
545 if( !DoClassHeader( &$3, TRUE ) )
546 return( ERR_ERROR );
547 $$ = $3;
548 }
549 | VARNAME '[' CONSTNAME ']' '=' class_header_body
550 {
551 RSCINST aInst;
552
553 aInst = S.Top().pClass->GetVariable( S.Top(), $1, RSCINST() );
554
555 if( aInst.pData )
556 {
557 ERRTYPE aError;
558 RSCINST aIdxInst;
559
560 aError = aInst.pClass->GetArrayEle( aInst, $3.hashid, NULL, &aIdxInst );
561 if( aError.IsError() || aError.IsWarning() )
562 pTC->pEH->Error( aError, S.Top().pClass, RscId() );
563 if( aError.IsError() )
564 return( ERR_ERROR );
565 S.Push( aIdxInst );
566 }
567 else
568 {
569 pTC->pEH->Error( ERR_NOVARIABLENAME, S.Top().pClass, RscId(),
570 pHS->getString( $1 ) );
571 return( ERR_ERROR );
572 };
573 if( !DoClassHeader( &$6, TRUE ) )
574 return( ERR_ERROR );
575 $$ = $6;
576 }
577 | VARNAME '[' SYMBOL ']' '=' class_header_body
578 {
579 RSCINST aInst;
580
581 aInst = S.Top().pClass->GetVariable( S.Top(), $1, RSCINST() );
582
583 if( aInst.pData )
584 {
585 long nNewLang = pTC->AddLanguage( $3 );
586 ERRTYPE aError;
587 RSCINST aIdxInst;
588
589 aError = aInst.pClass->GetArrayEle( aInst, nNewLang, NULL, &aIdxInst );
590 if( aError.IsError() || aError.IsWarning() )
591 pTC->pEH->Error( aError, S.Top().pClass, RscId() );
592 if( aError.IsError() )
593 return( ERR_ERROR );
594 S.Push( aIdxInst );
595 }
596 else
597 {
598 pTC->pEH->Error( ERR_NOVARIABLENAME, S.Top().pClass, RscId(),
599 pHS->getString( $1 ) );
600 return( ERR_ERROR );
601 };
602 if( !DoClassHeader( &$6, TRUE ) )
603 return( ERR_ERROR );
604 $$ = $6;
605 }
606 ;
607
608 var_header
609 : VARNAME '='
610 {
611 RSCINST aInst;
612
613 aInst = S.Top().pClass->GetVariable( S.Top(), $1, RSCINST() );
614
615 if( aInst.pData )
616 S.Push( aInst );
617 else{
618 pTC->pEH->Error( ERR_NOVARIABLENAME, S.Top().pClass, RscId(),
619 pHS->getString( $1 ) );
620 return( ERR_ERROR );
621 };
622 }
623 | VARNAME '[' CONSTNAME ']' '='
624 {
625 RSCINST aInst;
626
627 aInst = S.Top().pClass->GetVariable( S.Top(), $1, RSCINST() );
628
629 if( aInst.pData )
630 {
631 ERRTYPE aError;
632 RSCINST aIdxInst;
633
634 aError = aInst.pClass->GetArrayEle( aInst, $3.hashid, NULL, &aIdxInst );
635 if( aError.IsError() || aError.IsWarning() )
636 pTC->pEH->Error( aError, S.Top().pClass, RscId() );
637 if( aError.IsError() )
638 return( ERR_ERROR );
639 S.Push( aIdxInst );
640 }
641 else{
642 pTC->pEH->Error( ERR_NOVARIABLENAME, S.Top().pClass, RscId(),
643 pHS->getString( $1 ) );
644 return( ERR_ERROR );
645 };
646 }
647 | VARNAME '[' SYMBOL ']' '='
648 {
649 RSCINST aInst;
650
651 aInst = S.Top().pClass->GetVariable( S.Top(), $1, RSCINST() );
652
653 if( aInst.pData )
654 {
655 long nNewLang = pTC->AddLanguage( $3 );
656 ERRTYPE aError;
657 RSCINST aIdxInst;
658
659 aError = aInst.pClass->GetArrayEle( aInst, nNewLang, NULL, &aIdxInst );
660 if( aError.IsError() || aError.IsWarning() )
661 pTC->pEH->Error( aError, S.Top().pClass, RscId() );
662 if( aError.IsError() )
663 return( ERR_ERROR );
664 S.Push( aIdxInst );
665 }
666 else{
667 pTC->pEH->Error( ERR_NOVARIABLENAME, S.Top().pClass, RscId(),
668 pHS->getString( $1 ) );
669 return( ERR_ERROR );
670 };
671 }
672 ;
673 tupel_header0
674 :
675 {
676 RSCINST aInst;
677
678 aInst = S.Top().pClass->GetTupelVar( S.Top(), 0, RSCINST() );
679 if( aInst.pData )
680 S.Push( aInst );
681 else
682 {
683 pTC->pEH->Error( ERR_NOTUPELNAME, S.Top().pClass, RscId() );
684 return( ERR_ERROR );
685 };
686 }
687 ;
688
689 tupel_header1
690 :
691 {
692 RSCINST aInst;
693
694 aInst = S.Top().pClass->GetTupelVar( S.Top(), 1, RSCINST() );
695 if( aInst.pData )
696 S.Push( aInst );
697 else
698 {
699 pTC->pEH->Error( ERR_NOTUPELNAME, S.Top().pClass, RscId() );
700 return( ERR_ERROR );
701 };
702 }
703 ;
704
705 tupel_header2
706 :
707 {
708 RSCINST aInst;
709
710 aInst = S.Top().pClass->GetTupelVar( S.Top(), 2, RSCINST() );
711 if( aInst.pData )
712 S.Push( aInst );
713 else
714 {
715 pTC->pEH->Error( ERR_NOTUPELNAME, S.Top().pClass, RscId() );
716 return( ERR_ERROR );
717 };
718 }
719 ;
720
721 tupel_header3
722 :
723 {
724 RSCINST aInst;
725
726 aInst = S.Top().pClass->GetTupelVar( S.Top(), 3, RSCINST() );
727 if( !aInst.pData )
728 {
729 pTC->pEH->Error( ERR_NOTUPELNAME, S.Top().pClass, RscId() );
730 return( ERR_ERROR );
731 };
732 S.Push( aInst );
733 }
734 ;
735
736 tupel_body
737 : var_body
738 {
739 S.Pop();
740 }
741 ;
742
743 var_list_header
744 :
745 {
746 ERRTYPE aError;
747 RSCINST aInst;
748
749 aError = S.Top().pClass->GetElement( S.Top(), RscId(),
750 NULL, RSCINST(), &aInst );
751 if( aError.IsError() || aError.IsWarning() )
752 pTC->pEH->Error( aError, S.Top().pClass, RscId() );
753 if( aError.IsError() )
754 { // unbedingt Instanz auf den Stack bringen
755 aInst = S.Top().pClass->Create( NULL, RSCINST() );
756 }
757 S.Push( aInst );
758 }
759 ;
760
761 list_body
762 : var_bodycomplex
763 {
764 S.Pop();
765 }
766 ;
767
768 list_header
769 :
770 {
771 sal_uInt32 nCount = S.Top().pClass->GetCount( S.Top() );
772 sal_uInt32 i;
773
774 for( i = nCount; i > 0; i-- )
775 S.Top().pClass->DeletePos( S.Top(), i -1 );
776 }
777 ;
778
779 list
780 : list var_list_header list_body ';'
781 | list var_bodysimple ';'
782 | list class_definition ';'
783 | list line_number
784 |
785 ;
786
787 var_bodysimple
788 : macro_expression
789 {
790 INT32 l;
791 ERRTYPE aError;
792
793 if( !$1.Evaluate( &l ) )
794 pTC->pEH->Error( ERR_ZERODIVISION, NULL, RscId() );
795 else
796 {
797 aError = S.Top().pClass->SetRef( S.Top(), RscId( $1 ) );
798 if( aError.IsError() )
799 {
800 aError.Clear();
801 aError = S.Top().pClass->SetNumber( S.Top(), l );
802 }
803 if( aError.IsError() )
804 { // Aufwaertskompatible, Tupel probieren
805 RSCINST aInst = GetFirstTupelEle( S.Top() );
806 if( aInst.pData )
807 {
808 aError.Clear(); // Fehler zuruecksetzen
809 aError = aInst.pClass->SetRef( aInst, RscId( $1 ) );
810 if( aError.IsError() )
811 {
812 aError.Clear();
813 aError = aInst.pClass->SetNumber( aInst, l );
814 }
815 }
816 }
817 }
818
819 if( $1.IsExpression() )
820 delete $1.aExp.pExp;
821
822 if( aError.IsError() || aError.IsWarning() )
823 pTC->pEH->Error( aError, S.Top().pClass, RscId() );
824 }
825 | CONSTNAME
826 {
827 ERRTYPE aError;
828 aError = S.Top().pClass->SetConst( S.Top(), $1.hashid, $1.nValue );
829 if( aError.IsError() )
830 { // Aufwaertskompatible, Tupel probieren
831 RSCINST aInst = GetFirstTupelEle( S.Top() );
832 if( aInst.pData )
833 {
834 aError.Clear(); // Fehler zuruecksetzen
835 aError = aInst.pClass->SetConst( aInst, $1.hashid, $1.nValue );
836 }
837 }
838
839 if( aError.IsError() || aError.IsWarning() )
840 pTC->pEH->Error( aError, S.Top().pClass, RscId() );
841 }
842 | NOT CONSTNAME
843 {
844 ERRTYPE aError;
845 aError = S.Top().pClass->SetNotConst( S.Top(), $2.hashid );
846 if( aError.IsError() )
847 { // Aufwaertskompatible, Tupel probieren
848 RSCINST aInst = GetFirstTupelEle( S.Top() );
849 if( aInst.pData )
850 {
851 aError.Clear(); // Fehler zuruecksetzen
852 aError = aInst.pClass->SetNotConst( aInst, $2.hashid );
853 }
854 }
855
856 if( aError.IsError() || aError.IsWarning() )
857 pTC->pEH->Error( aError, S.Top().pClass, RscId() );
858 }
859 | BOOLEAN
860 {
861 ERRTYPE aError;
862 aError = S.Top().pClass->SetBool( S.Top(), $1 );
863 if( aError.IsError() )
864 { // Aufwaertskompatible, Tupel probieren
865 RSCINST aInst = GetFirstTupelEle( S.Top() );
866 if( aInst.pData )
867 {
868 aError.Clear(); // Fehler zuruecksetzen
869 aError = aInst.pClass->SetBool( aInst, $1 );
870 }
871 }
872
873 if( aError.IsError() || aError.IsWarning() )
874 pTC->pEH->Error( aError, S.Top().pClass, RscId() );
875 }
876 | string_multiline
877 {
878 ERRTYPE aError;
879 aError = S.Top().pClass->SetString( S.Top(), $1 );
880 if( aError.IsError() )
881 { // Aufwaertskompatible, Tupel probieren
882 RSCINST aInst = GetFirstTupelEle( S.Top() );
883 if( aInst.pData )
884 {
885 aError.Clear(); // Fehler zuruecksetzen
886 aError = aInst.pClass->SetString( aInst, $1 );
887 }
888 }
889
890 if( aError.IsError() || aError.IsWarning() )
891 pTC->pEH->Error( aError, S.Top().pClass, RscId() );
892 }
893 | DEFAULT
894 ;
895
896 var_bodycomplex
897 : '{' list_header list '}'
898 | '<' tupel_header0 tupel_body ';' '>'
899 | '<' tupel_header0 tupel_body ';' tupel_header1 tupel_body ';' '>'
900 | '<' tupel_header0 tupel_body ';' tupel_header1 tupel_body ';'
901 tupel_header2 tupel_body ';' '>'
902 | '<' tupel_header0 tupel_body ';' tupel_header1 tupel_body ';'
903 tupel_header2 tupel_body ';' tupel_header3 tupel_body ';' '>'
904 ;
905
906 var_body
907 : var_bodysimple
908 | var_bodycomplex
909 ;
910
911 /********************** work on yacc stack *******************************/
912 string_multiline
913 : STRING
914 {
915 $$ = $1;
916 }
917 | string_multiline STRING
918 {
919 rtl::OStringBuffer aBuf( 256 );
920 aBuf.append( $1 );
921 aBuf.append( $2 );
922 $$ = (char*)pStringContainer->putString( aBuf.getStr() );
923 }
924 ;
925
926 long_expression
927 : macro_expression
928 {
929 if( !$1.Evaluate( &$$ ) )
930 pTC->pEH->Error( ERR_ZERODIVISION, NULL, RscId() );
931 if( $1.IsExpression() )
932 delete $1.aExp.pExp;
933 }
934 ;
935
936 macro_expression
937 : RSCDEFINE
938 {
939 $$.cType = RSCEXP_DEF;
940 $$.aExp.pDef = $1;
941 }
942 | NUMBER
943 {
944 $$.cType = RSCEXP_LONG;
945 $$.SetLong( $1 );
946 }
947 | '-' macro_expression %prec UNARYMINUS
948 {
949 if( $2.IsNumber() ){
950 $$.cType = $2.cType;
951 $$.SetLong( - $2.GetLong() );
952 }
953 else{
954 RscExpType aLeftExp;
955
956 aLeftExp.cType = RSCEXP_NOTHING;
957 $$.cType = RSCEXP_EXP;
958 $$.aExp.pExp = new RscExpression( aLeftExp, '-', $2 );
959 }
960 }
961 | '+' macro_expression %prec UNARYPLUS
962 {
963 $$ = $2;
964 }
965 | macro_expression '+' macro_expression
966 {
967 if( $1.IsNumber() && $3.IsNumber() ){
968 $$.cType = RSCEXP_LONG;
969 $$.SetLong( $1.GetLong() + $3.GetLong() );
970 }
971 else{
972 $$.cType = RSCEXP_EXP;
973 $$.aExp.pExp = new RscExpression( $1, '+', $3 );
974 }
975 }
976 | macro_expression '-' macro_expression
977 {
978 if( $1.IsNumber() && $3.IsNumber() ){
979 $$.cType = RSCEXP_LONG;
980 $$.SetLong( $1.GetLong() - $3.GetLong() );
981 }
982 else{
983 $$.cType = RSCEXP_EXP;
984 $$.aExp.pExp = new RscExpression( $1, '-', $3 );
985 }
986 }
987 | macro_expression '*' macro_expression
988 {
989 if( $1.IsNumber() && $3.IsNumber() ){
990 $$.cType = RSCEXP_LONG;
991 $$.SetLong( $1.GetLong() * $3.GetLong() );
992 }
993 else{
994 $$.cType = RSCEXP_EXP;
995 $$.aExp.pExp = new RscExpression( $1, '*', $3 );
996 }
997 }
998 | macro_expression '/' macro_expression
999 {
1000 if( $1.IsNumber() && $3.IsNumber() ){
1001 if( 0 == $3.GetLong() ){
1002 $$.cType = RSCEXP_EXP;
1003 $$.aExp.pExp = new RscExpression( $1, '/', $3 );
1004 }
1005 else{
1006 $$.cType = RSCEXP_LONG;
1007 $$.SetLong( $1.GetLong() / $3.GetLong() );
1008 }
1009 }
1010 else{
1011 $$.cType = RSCEXP_EXP;
1012 $$.aExp.pExp = new RscExpression( $1, '/', $3 );
1013 }
1014 }
1015 | macro_expression '&' macro_expression
1016 {
1017 if( $1.IsNumber() && $3.IsNumber() ){
1018 $$.cType = RSCEXP_LONG;
1019 $$.SetLong( $1.GetLong() & $3.GetLong() );
1020 }
1021 else{
1022 $$.cType = RSCEXP_EXP;
1023 $$.aExp.pExp = new RscExpression( $1, '&', $3 );
1024 }
1025 }
1026 | macro_expression '|' macro_expression
1027 {
1028 if( $1.IsNumber() && $3.IsNumber() ){
1029 $$.cType = RSCEXP_LONG;
1030 $$.SetLong( $1.GetLong() | $3.GetLong() );
1031 }
1032 else{
1033 $$.cType = RSCEXP_EXP;
1034 $$.aExp.pExp = new RscExpression( $1, '|', $3 );
1035 }
1036 }
1037 | '(' macro_expression ')'
1038 {
1039 $$ = $2;
1040 }
1041 | macro_expression LEFTSHIFT macro_expression
1042 {
1043 if( $1.IsNumber() && $3.IsNumber() ){
1044 $$.cType = RSCEXP_LONG;
1045 $$.SetLong( $1.GetLong() << $3.GetLong() );
1046 }
1047 else{
1048 $$.cType = RSCEXP_EXP;
1049 $$.aExp.pExp = new RscExpression( $1, 'l', $3 );
1050 }
1051 }
1052 | macro_expression RIGHTSHIFT macro_expression
1053 {
1054 if( $1.IsNumber() && $3.IsNumber() ){
1055 $$.cType = RSCEXP_LONG;
1056 $$.SetLong( $1.GetLong() >> $3.GetLong() );
1057 }
1058 else{
1059 $$.cType = RSCEXP_EXP;
1060 $$.aExp.pExp = new RscExpression( $1, 'r', $3 );
1061 }
1062 }
1063 ;
1064
1065 id_expression
1066 : id_expression line_number
1067 | macro_expression
1068 { // pExpession auswerten und loeschen
1069 if( RSCEXP_EXP == $1.cType ){
1070 INT32 lValue;
1071
1072 if( !$1.Evaluate( &lValue ) )
1073 pTC->pEH->Error( ERR_ZERODIVISION, NULL, RscId() );
1074 delete $1.aExp.pExp;
1075 $$.cType = RSCEXP_LONG;
1076 $$.SetLong( lValue );
1077 }
1078 else
1079 $$ = $1;
1080 }
1081 ;
1082
1083 DUMMY_NUMBER
1084 : NUMBER
1085 {
1086 }
1087 |
1088 {
1089 }
1090 ;
1091
1092 line_number
1093 : '#' LINE NUMBER STRING
1094 {
1095 RscFile * pFName;
1096
1097 pFI->SetLineNo( $3 );
1098 pFI->SetFileIndex( pTC->aFileTab.NewCodeFile( ByteString( $4 ) ) );
1099 pFName = pTC->aFileTab.Get( pFI->GetFileIndex() );
1100 pFName->bLoaded = TRUE;
1101 pFName->bScanned = TRUE;
1102 }
1103 | '#' NUMBER STRING DUMMY_NUMBER
1104 {
1105 RscFile * pFName;
1106
1107 pFI->SetLineNo( $2 );
1108 pFI->SetFileIndex( pTC->aFileTab.NewCodeFile( ByteString( $3 ) ) );
1109 pFName = pTC->aFileTab.Get( pFI->GetFileIndex() );
1110 pFName->bLoaded = TRUE;
1111 pFName->bScanned = TRUE;
1112 }
1113 | '#' NUMBER
1114 {
1115 pFI->SetLineNo( $2 );
1116 }
1117 ;
1118
1119
1120
1121
vba interoperability for OOo