carbidev/com.nokia.tools.variant.confml.expressions_1.0.0.v20090225_01-11/src/com/nokia/tools/variant/confml/expressions/confml/grammar/Confml.g
changeset 0 30eb2d538f02
child 1 fe41c66bacc7
equal deleted inserted replaced
-1:000000000000 0:30eb2d538f02
       
     1 /*
       
     2  * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
       
     3  * All rights reserved.
       
     4  * This component and the accompanying materials are made available
       
     5  * under the terms of the License "Symbian Foundation License v1.0"
       
     6  * which accompanies this distribution, and is available
       
     7  * at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
       
     8  * 
       
     9  * Initial Contributors:
       
    10  * Nokia Corporation - Initial contribution
       
    11  * 
       
    12  * Contributors:
       
    13  * 
       
    14  * Description: This file is part of com.nokia.tools.variant.confml.expressions component.
       
    15  */ 
       
    16 grammar Confml;
       
    17  
       
    18 @header { 
       
    19   package com.nokia.tools.variant.confml.expressions.confml.grammar;
       
    20   
       
    21   import com.nokia.tools.variant.content.confml.*;
       
    22   import org.eclipse.emf.common.util.*;
       
    23 }
       
    24 
       
    25 @members {
       
    26   private View view;
       
    27 
       
    28   public void setView(View view) {
       
    29     this.view = view;
       
    30   }
       
    31   
       
    32   public View getView() {
       
    33     return view;
       
    34   }
       
    35 
       
    36   private SequenceItem sequenceItem;
       
    37   
       
    38   public SequenceItem getSequenceItem() {
       
    39     return sequenceItem;
       
    40   }
       
    41   
       
    42   public void setSequenceItem(SequenceItem si) {
       
    43     this.sequenceItem = si;
       
    44   }
       
    45 
       
    46 /*
       
    47   private String currentRef;
       
    48   
       
    49   public void setCurrentRef(String currentRef) {
       
    50     this.currentRef = currentRef;
       
    51   }
       
    52   
       
    53   public String getCurrentRef() {
       
    54     return currentRef;
       
    55   }
       
    56 */  
       
    57   private Setting setting;
       
    58   
       
    59   public void setSetting(Setting setting) {
       
    60     this.setting = setting;
       
    61   }
       
    62   
       
    63   public Setting getSetting() {
       
    64     return setting;
       
    65   }
       
    66   
       
    67   
       
    68   private String featureRef;
       
    69   
       
    70   public void setFeatureRef(String featureRef) {
       
    71     this.featureRef = featureRef;
       
    72   }
       
    73   
       
    74   public String getFeatureRef() {
       
    75     return featureRef; 
       
    76   }
       
    77   
       
    78 	  public boolean areObjectsEqual(Object o1, Object o2) {
       
    79 		  try {
       
    80 			  if (o1 instanceof Boolean) {
       
    81 				  Boolean b1 = (Boolean) o1;
       
    82 				  if (o2 instanceof Boolean) {
       
    83 					  return b1.equals(o2);
       
    84 				  } else if (o2 instanceof String) {
       
    85 					  String s2 = (String) o2;
       
    86 					  return b1.equals(Boolean.parseBoolean(s2));
       
    87 				  } else {
       
    88 					  return false;
       
    89 				  }
       
    90 			  } else if (o1 instanceof String) {
       
    91 				  String s1 = (String) o1;
       
    92 				  if (o2 instanceof Boolean) {
       
    93 					  Boolean b2 = (Boolean) o2;
       
    94 					  return s1.equals(b2.toString());
       
    95 				  } else if (o2 instanceof String) {
       
    96 					  return s1.equals(o2);
       
    97 				  } else if (o2 instanceof Double) {
       
    98 					  return new Double(s1).toString().equals(((Double)o2).toString());
       
    99 				  }
       
   100 			  } else if (o1 instanceof Double) {
       
   101 				  Double d1 = (Double) o1;
       
   102 				  if (o2 instanceof String) {
       
   103 					  String s2 = (String) o2;
       
   104 					  return d1.equals(Double.parseDouble(s2));
       
   105 				  } else if (o2 instanceof Double) {
       
   106 					  return d1.equals(o2);
       
   107 				  }
       
   108 			  }
       
   109 		  } catch (Throwable t) {
       
   110 			  ;
       
   111 		  }
       
   112 		  return false;
       
   113 	  }
       
   114   
       
   115   
       
   116 }
       
   117 
       
   118 @lexer::header {
       
   119   package com.nokia.tools.variant.confml.expressions.confml.grammar;
       
   120 }
       
   121 
       
   122 // ##################### BASIC EXPRESSIONS
       
   123 expr returns [Object value]: 
       
   124   (orExpr NEWLINE {value = $orExpr.value;})*
       
   125 ;
       
   126 
       
   127 // ##################### BOOLEAN EXPRESSIONS
       
   128 orExpr returns [Object value]:
       
   129   e = andExpr                     { value = e; }
       
   130   (
       
   131     'or'  e2 = andExpr            { value = (new Boolean(e.toString()) || new Boolean(e2.toString())); }
       
   132   )*
       
   133 ;
       
   134 
       
   135 andExpr returns [Object value]:
       
   136   e = equalityExpr                { value = e; }
       
   137   (
       
   138     'and' e2 = equalityExpr       { value = (new Boolean(e.toString()) && new Boolean(e2.toString())); }
       
   139   )*
       
   140 ;
       
   141 
       
   142 equalityExpr returns [Object value]: 
       
   143   e = relationalExpr              { value = e; }
       
   144   (
       
   145     '='   e2 = relationalExpr     { value = areObjectsEqual(e, e2); }
       
   146     
       
   147     
       
   148     
       
   149     
       
   150   | '!='  e2 = relationalExpr     { value = !areObjectsEqual(e, e2); }
       
   151   )*
       
   152 ;
       
   153 
       
   154 relationalExpr returns [Object value]:
       
   155   e = additiveExpr                { value = e; }
       
   156   (
       
   157     '<'   e2 = additiveExpr       		   {
       
   158                                             value = (Double.valueOf(e.toString()).compareTo(Double.valueOf(e2.toString()))) == -1;    
       
   159                                            }
       
   160                                            
       
   161   | '>'   e2 = additiveExpr       		   {
       
   162                                             value = (Double.valueOf(e.toString()).compareTo(Double.valueOf(e2.toString()))) == 1;
       
   163                                            }
       
   164                                            
       
   165   | '<='   e2 = additiveExpr       		   {
       
   166                                             value = (Double.valueOf(e.toString()).compareTo(Double.valueOf(e2.toString()))) <= 0; 
       
   167                                            }
       
   168                                            
       
   169   | '>='   e2 = additiveExpr               {
       
   170                                            value = (Double.valueOf(e.toString()).compareTo(Double.valueOf(e2.toString()))) >= 0;
       
   171                                            }
       
   172   )*
       
   173 ;
       
   174   
       
   175 // ################# Numeric Expressions
       
   176 additiveExpr returns [Object value] : 
       
   177 	multiplicativeExpr              { value = $multiplicativeExpr.value;}
       
   178 	(
       
   179 	  '+'   e = multiplicativeExpr  { value = Double.parseDouble(value.toString()) + Double.parseDouble(e.toString()); } 
       
   180     | '-'   e = multiplicativeExpr  { value = Double.parseDouble(value.toString()) - Double.parseDouble(e.toString()); } 
       
   181 	)*
       
   182 ;
       
   183 
       
   184 multiplicativeExpr returns [Object value]: 
       
   185 	e = unaryExpr                   { value = e; }
       
   186 	(
       
   187 	  '*'   e2 = unaryExpr          { value = Double.parseDouble(value.toString()) * Double.parseDouble(e2.toString()); }
       
   188 	| 'div' e2 = unaryExpr          { value = Double.parseDouble(value.toString()) / Double.parseDouble(e2.toString()); }
       
   189 	| 'mod' e2 = unaryExpr          { value = Double.parseDouble(value.toString()) % Double.parseDouble(e2.toString()); }
       
   190 	)* 
       
   191 ;
       
   192 
       
   193 unaryExpr returns [Object value]: 
       
   194   primaryExpr                     { value = $primaryExpr.value ; }
       
   195   | '-' primaryExpr               { value = -Double.parseDouble($primaryExpr.value.toString()) ; }
       
   196 ;
       
   197 
       
   198 primaryExpr returns [Object value]: 
       
   199   settingValueRef                 { value = $settingValueRef.value; }
       
   200   | '(' orExpr ')'                { value = $orExpr.value ; }
       
   201   | Literal                       {
       
   202                                     value = $Literal.text;
       
   203                                     String str = value.toString();
       
   204                     
       
   205 								                    if (str.contains("&amp;")) {
       
   206 								                      value = str.replaceAll("&amp;", "&");
       
   207 								                    }
       
   208 								                    
       
   209 								                    if ((str.startsWith("\"") && str.endsWith("\"")) || (str.startsWith("\'") && str.endsWith("\'"))) {
       
   210 								                      value = str.substring(1, $Literal.text.length() - 1);                     
       
   211 								                    } else if (str.startsWith("&apos;") && str.endsWith("&apos;")) {
       
   212 								                      value = str.replaceAll("&apos;", "");
       
   213 								                    } else if (str.startsWith("&quot;") && str.endsWith("&quot;")) {
       
   214 								                      value = str.replaceAll("&quot;", "");
       
   215 								                    }
       
   216                                   }
       
   217   | Number                        { value = $Number.text ; }
       
   218 ;
       
   219 
       
   220 // ################# Expression Lexical Structure
       
   221 
       
   222 settingValueRef returns [Object value]: 
       
   223   '.'                                         {
       
   224                                               value = ((SimpleSetting)getSetting()).getValue();
       
   225                                               }
       
   226   | r = Ref                                   {
       
   227                                                 Setting s = getSetting();
       
   228                                                 String currentFeatureRef = getFeatureRef();
       
   229                                                 
       
   230                                                 EList<Setting> allSettings = view.getSharedSettingInstances();
       
   231                                                 if (s != null) {// Context is Setting
       
   232 	                                                String absRef = s.getAbsRef();
       
   233 	                                                String[] refs = absRef.split("/");
       
   234 	                                                if (refs.length == 2) {// simple setting context
       
   235 		                                                String featureRef = absRef.substring(0, absRef.indexOf('/'));
       
   236 		                                                String searchSettingAbsRef = featureRef + "/" + r.getText();
       
   237 		                                                for (int i = 0 ; i < allSettings.size() ; i++) {
       
   238 		                                                  Setting si = allSettings.get(i);
       
   239 		                                                  if (si.getAbsRef().equals(searchSettingAbsRef)) {
       
   240 		                                                    value = ((SimpleSetting)si).getValue(); 
       
   241 		                                                    break;
       
   242 		                                                  }
       
   243 		                                                }
       
   244 	                                                } else {// subsetting context
       
   245 	                                                  String searchSubsettingRef = r.getText();
       
   246 	                                                  SequenceItem si = getSequenceItem();
       
   247 	                                                  EList<Setting> subsettings = si.getSetting();
       
   248 	                                                  for (int i = 0 ; i < subsettings.size() ; i++) {
       
   249 	                                                    Setting ss = subsettings.get(i);
       
   250 	                                                    if (ss.getSettingRef().equals(r.getText())) {
       
   251   	                                                      if (ss instanceof SimpleSetting) {
       
   252                     	                                    value = ((SimpleSetting)ss).getValue();
       
   253                     	                                    break;
       
   254                     	                                  }
       
   255                       	                                }
       
   256 	                                                  }
       
   257 	                                                  
       
   258 	                                                }
       
   259                                                 } else if (currentFeatureRef != null) {
       
   260                                                   String searchedSettingAbsRef = currentFeatureRef + "/" + r.getText();
       
   261                                                   for (int i = 0 ; i < allSettings.size() ; i++) {
       
   262                                                     Setting si = allSettings.get(i);
       
   263                                                     if (si.getAbsRef().equals(searchedSettingAbsRef)) {
       
   264                                                       value = ((SimpleSetting)si).getValue();
       
   265                                                       break;
       
   266                                                     }
       
   267                                                   }
       
   268                                                 }
       
   269                                               }
       
   270   | (r1 = Ref '/' r2 = Ref)                   {
       
   271                                               String absRef = r1.getText() + "/" + r2.getText();
       
   272                                               EList<Setting> settings = view.getSharedSettingInstances();
       
   273                                               Setting s = null;
       
   274                                               for (int i = 0 ; i < settings.size() ; i++) {
       
   275                                                 Setting x = settings.get(i);
       
   276                                                 if (x.getAbsRef().equals(absRef)) {
       
   277                                                   s=x;
       
   278                                                   break;
       
   279                                                 }
       
   280                                                 
       
   281                                               }
       
   282                                                
       
   283                                               if (s instanceof SimpleSetting) {
       
   284                                                 SimpleSetting ss = (SimpleSetting) s;
       
   285                                                 String val = ss.getValue();
       
   286                                                 value = val;
       
   287                                               }
       
   288                                             }
       
   289 
       
   290 
       
   291   | (r1 = Ref '/' rx = Ref '[' n = Number ']' '/' rs = Ref)  {
       
   292                                               int index = Integer.parseInt(n.getText());
       
   293                                               String absRef = r1.getText() + "/" + rx.getText();
       
   294                                               EList<Setting> settings = view.getSharedSettingInstances();
       
   295                                               Setting s = null;
       
   296                                               for (int i = 0 ; i < settings.size() ; i++) {
       
   297                                                 Setting x = settings.get(i);
       
   298                                                 if (x.getAbsRef().equals(absRef)) {
       
   299                                                   s=x;
       
   300                                                   break;
       
   301                                                 }
       
   302                                                 
       
   303                                               }
       
   304                                                
       
   305                                               if (s instanceof SequenceSetting) {
       
   306                                                 SequenceSetting ss = (SequenceSetting) s;
       
   307                                                 String subSettingAbsRef = absRef + "/" + rs.getText();
       
   308                                                 EList<SequenceItem> items = ss.getSequenceItem();
       
   309                                                 SequenceItem si = items.get(index);
       
   310                                                 EList<Setting> subsettings = si.getSetting();
       
   311                                                 for (int i = 0 ; i < subsettings.size() ; i++) {
       
   312                                                   Setting subSetting = subsettings.get(i);
       
   313                                                   if (subSetting.getAbsRef().equals(subSettingAbsRef)) {
       
   314                                                     if (subSetting instanceof SimpleSetting) {
       
   315                                                       value = ((SimpleSetting)subSetting).getValue();
       
   316 		                                              break; 
       
   317             	                                    }
       
   318               	                                  }
       
   319                                                 }
       
   320                                                   
       
   321                                               }
       
   322                                             }
       
   323 
       
   324 
       
   325   | r1 = Ref '/' r2 = Ref '/' r3 = Ref      {  
       
   326   
       
   327                                               String absRef = r1.getText() + "/" + r2.getText();
       
   328                                               EList<Setting> settings = view.getSharedSettingInstances();
       
   329                                               Setting s = null;
       
   330                                               for (int i = 0 ; i < settings.size() ; i++) {
       
   331                                                 Setting x = settings.get(i);
       
   332                                                 if (x.getAbsRef().equals(absRef)) {
       
   333                                                   s=x;
       
   334                                                   break;
       
   335                                                 }
       
   336                                                 
       
   337                                               }
       
   338                                                
       
   339                                               if (s instanceof FileSystemEntrySetting) {
       
   340                                                 FileSystemEntrySetting fs = (FileSystemEntrySetting) s;
       
   341                                                 if (r3.getText().equals("localPath")) {
       
   342                                                   value = fs.getSourcePath();
       
   343                                                 } else if (r3.getText().equals("targetPath")) {
       
   344                                                   value = fs.getTargetPath();
       
   345                                                 }
       
   346                                               }
       
   347                                             }
       
   348   ;
       
   349  
       
   350 
       
   351 //IndexedRef : ('a'..'z' | 'A'..'Z' ) ('a'..'z' | 'A'..'Z' | '0'..'9' | '.' | '-')* ('*' | ('[' Number ']'))   {};
       
   352                                              
       
   353                                              
       
   354 Ref :        ('a'..'z' | 'A'..'Z' ) ('a'..'z' | 'A'..'Z' | '0'..'9' | '.' | '-' | '_')*
       
   355 //Ref : (('a'..'z' | 'A'..'Z' ) (('a'..'z' | 'A'..'Z' ) | ('0'..'9') | '.' | '-')*) ('*' | ('[' Number ']'))?
       
   356 ;
       
   357 
       
   358 Literal :
       
   359     '"' .* '"'
       
   360   | '\'' .* '\''
       
   361   | '&apos;' .* '&apos;'
       
   362   | '&quot;' .* '&quot;'
       
   363 ;
       
   364 
       
   365 Number : ('0'..'9')+ ('.' ('0'..'9')+)?
       
   366   | '.' ('0'..'9')+
       
   367 ;
       
   368 
       
   369 NEWLINE : '\r' ? '\n'
       
   370 ;
       
   371 
       
   372 WS : (' ' |'\t' |'\n' |'\r' )+ {skip();}
       
   373 ;
       
   374 
       
   375 //NameChar    :   Letter | Digit | '.' | '..' | '_' | ':' | CombiningChar | Extender;  
       
   376 //Name    :   (Letter | '_' | ':') (NameChar)*; 
       
   377 //Names    :    Name ('\u0020' Name)*; 
       
   378 //Nmtoken    :    (NameChar)+ ;
       
   379 //Nmtokens    :   Nmtoken ('\u0020' Nmtoken)*; 
       
   380 
       
   381 //CombiningChar    :    ('\u0300'..'\u0345') | ('\u0360'..'\u0361') | ('\u0483'..'\u0486') | ('\u0591'..'\u05A1') | ('\u05A3'..'\u05B9') | ('\u05BB'..'\u05BD') | '\u05BF' | ('\u05C1'..'\u05C2') | '\u05C4' | ('\u064B'..'\u0652') | '\u0670' | ('\u06D6'..'\u06DC') | ('\u06DD'..'\u06DF') | ('\u06E0'..'\u06E4') | ('\u06E7'..'\u06E8') | ('\u06EA'..'\u06ED') | ('\u0901'..'\u0903') | '\u093C' | ('\u093E'..'\u094C') | '\u094D' | ('\u0951'..'\u0954') | ('\u0962'..'\u0963') | ('\u0981'..'\u0983') | '\u09BC' | '\u09BE' | '\u09BF' | ('\u09C0'..'\u09C4') | ('\u09C7'..'\u09C8') | ('\u09CB'..'\u09CD') | '\u09D7' | ('\u09E2'..'\u09E3') | '\u0A02' | '\u0A3C' | '\u0A3E' | '\u0A3F' | ('\u0A40'..'\u0A42') | ('\u0A47'..'\u0A48') | ('\u0A4B'..'\u0A4D') | ('\u0A70'..'\u0A71') | ('\u0A81'..'\u0A83') | '\u0ABC' | ('\u0ABE'..'\u0AC5') | ('\u0AC7'..'\u0AC9') | ('\u0ACB'..'\u0ACD') | ('\u0B01'..'\u0B03') | '\u0B3C' | ('\u0B3E'..'\u0B43') | ('\u0B47'..'\u0B48') | ('\u0B4B'..'\u0B4D') | ('\u0B56'..'\u0B57') | ('\u0B82'..'\u0B83') | ('\u0BBE'..'\u0BC2') | ('\u0BC6'..'\u0BC8') | ('\u0BCA'..'\u0BCD') | '\u0BD7' | ('\u0C01'..'\u0C03') | ('\u0C3E'..'\u0C44') | ('\u0C46'..'\u0C48') | ('\u0C4A'..'\u0C4D') | ('\u0C55'..'\u0C56') | ('\u0C82'..'\u0C83') | ('\u0CBE'..'\u0CC4') | ('\u0CC6'..'\u0CC8') | ('\u0CCA'..'\u0CCD') | ('\u0CD5'..'\u0CD6') | ('\u0D02'..'\u0D03') | ('\u0D3E'..'\u0D43') | ('\u0D46'..'\u0D48') | ('\u0D4A'..'\u0D4D') | '\u0D57' | '\u0E31' | ('\u0E34'..'\u0E3A') | ('\u0E47'..'\u0E4E') | '\u0EB1' | ('\u0EB4'..'\u0EB9') | ('\u0EBB'..'\u0EBC') | ('\u0EC8'..'\u0ECD') | ('\u0F18'..'\u0F19') | '\u0F35' | '\u0F37' | '\u0F39' | '\u0F3E' | '\u0F3F' | ('\u0F71'..'\u0F84') | ('\u0F86'..'\u0F8B') | ('\u0F90'..'\u0F95') | '\u0F97' | ('\u0F99'..'\u0FAD') | ('\u0FB1'..'\u0FB7') | '\u0FB9' | ('\u20D0'..'\u20DC') | '\u20E1' | ('\u302A'..'\u302F') | '\u3099' | '\u309A'  ;
       
   382 //Digit    :    ('\u0030'..'\u0039') | ('\u0660'..'\u0669') | ('\u06F0'..'\u06F9') | ('\u0966'..'\u096F') | ('\u09E6'..'\u09EF') | ('\u0A66'..'\u0A6F') | ('\u0AE6'..'\u0AEF') | ('\u0B66'..'\u0B6F') | ('\u0BE7'..'\u0BEF') | ('\u0C66'..'\u0C6F') | ('\u0CE6'..'\u0CEF') | ('\u0D66'..'\u0D6F') | ('\u0E50'..'\u0E59') | ('\u0ED0'..'\u0ED9') | ('\u0F20'..'\u0F29')  ;
       
   383 //Extender    :    '\u00B7' | '\u02D0' | '\u02D1' | '\u0387' | '\u0640' | '\u0E46' | '\u0EC6' | '\u3005' | ('\u3031'..'\u3035') | ('\u309D'..'\u309E') | ('\u30FC'..'\u30FE')  ;