1 /*

     2 * Copyright (c) 2004-2008 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 "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 using System;

    19 using System.Text;

    20 using SymBuildParsingLib.Tree;

    21 using SymBuildParsingLib.Token;

    22 using SymBuildParsingLib.Parser.Framework;

    23 using SymBuildParsingLib.Parser.Framework.Utils;

    24 using SymBuildParsingLib.Parser.Framework.Workers;

    25 using SymBuildParsingLib.Parser.PreProcessor.Nodes;

    26 using SymBuildParsingLib.Common.Objects;

    27 using SymbianTree;

    28 

    29 namespace SymBuildParsingLib.Parser.PreProcessor.Workers

    30 {

    31 	public sealed class SymPreProcessorWorkerDefine : SymParserWorkerConsumer

    32 	{

    33 		#region Constructors & destructor

    34 		public SymPreProcessorWorkerDefine( SymParserWorkerContext aContext )

    35 			: base( aContext, SymToken.TClass.EClassNewLine )

    36 		{

    37 			iFunctionParser.RegisterFunctionParserTokens();

    38 

    39 			// Set up event handlers

    40 			iFunctionParser.EventArgumentAvailableHandler += new SymBuildParsingLib.Parser.Framework.Utils.SymFunctionParser.ArgumentAvailable( FunctionParserEventArgumentAvailableHandler );

    41 			iFunctionParser.EventLevelStarted += new SymBuildParsingLib.Token.SymTokenBalancer.LevelChangeEventHandler( TokenBalancerEventLevelStarted );

    42 			iFunctionParser.EventLevelFinished += new SymBuildParsingLib.Token.SymTokenBalancer.LevelChangeEventHandler( TokenBalancerEventLevelFinished );

    43 			iFunctionParser.EventLevelsBalanced += new SymBuildParsingLib.Token.SymTokenBalancer.LevelsBalancedEventHandler( TokenBalancerEventLevelsBalanced );

    44 			iFunctionParser.EventLevelsImbalanced += new SymBuildParsingLib.Token.SymTokenBalancer.LevelsImbalancedEventHandler( TokenBalancerEventLevelsImbalanced );

    45 		}

    46 		#endregion

    47 

    48 		#region Internal enumerations

    49 		private enum TState

    50 		{

    51 			EStateInitialWhiteSpace = 0,

    52 			EStateDefineName,

    53 			EStateDefineArguments,

    54 			EStateMiddleWhiteSpace,

    55 			EStateDefineValue

    56 		}

    57 		#endregion

    58 

    59 		#region From SymParserWorker

    60 		public override SymParserWorker.TTokenConsumptionType OfferToken( SymToken aToken )

    61 		{

    62 			SymParserWorker.TTokenConsumptionType ret = SymParserWorker.TTokenConsumptionType.ETokenNotConsumed;

    63 			//

    64 			while( ret == SymParserWorker.TTokenConsumptionType.ETokenNotConsumed )

    65 			{

    66 				TState currentState = State;

    67 				switch( State )

    68 				{

    69 					case TState.EStateInitialWhiteSpace:

    70 						ret = OnStateInitialWhiteSpace( aToken );

    71 						break;

    72 					case TState.EStateDefineName:

    73 						ret = OnStateDefineName( aToken );

    74 						break;

    75 					case TState.EStateDefineArguments:

    76 						ret = OnStateDefineArguments( aToken );

    77 						break;

    78 					case TState.EStateMiddleWhiteSpace:

    79 						ret = OnStateMiddleWhiteSpace( aToken );

    80 						break;

    81 					case TState.EStateDefineValue:

    82 						ret = OnStateDefineValue( aToken );

    83 						break;

    84 					default:

    85 						break;

    86 				}

    87 

    88 				TState newState = State;

    89 				bool statesDidNotChange = ( currentState == newState );

    90 				if	( statesDidNotChange )

    91 				{

    92 					// If the state handlers didn't want the token, then we 

    93 					// offer it to the base class instead

    94 					if	( ret == SymParserWorker.TTokenConsumptionType.ETokenNotConsumed )

    95 					{

    96 						ret = base.OfferToken( aToken );

    97 					}

    98 				}

    99 			}

   100 

   101 			return ret;

   102 		}

   103 		#endregion

   104 

   105 		#region From SymParserWorkerConsumer

   106 		protected override void HandleTerminatingConditionMatch( SymToken aToken )

   107 		{

   108 			switch( State )

   109 			{

   110 			case TState.EStateInitialWhiteSpace:

   111 				break;

   112 			case TState.EStateDefineName:

   113 				MakeDefineName();

   114 				break;

   115 			case TState.EStateDefineArguments:

   116 				break;

   117 			case TState.EStateMiddleWhiteSpace:

   118 				break;

   119 			case TState.EStateDefineValue:

   120 				MakeDefineValue();

   121 				break;

   122 			default:

   123 				break;

   124 			}

   125 

   126 			// Do we have a valid define?

   127 			if	( iDefine.IsValid )

   128 			{

   129 				SymNodePreProcessorDefine defineNode = new SymNodePreProcessorDefine();

   130 				defineNode.DefineDefinition = iDefine;

   131 				//

   132 				WorkerContext.CurrentNode.Add( defineNode );

   133 				WorkerContext.DefineDirectory.Add( iDefine );

   134 			}

   135 		}

   136 		#endregion

   137 

   138 		#region Internal properties

   139 		private TState State

   140 		{

   141 			get { return iState; }

   142 			set { iState = value; }

   143 		}

   144 		#endregion

   145 

   146 		#region Internal state handlers

   147 		private SymParserWorker.TTokenConsumptionType OnStateInitialWhiteSpace( SymToken aToken )

   148 		{

   149 			SymParserWorker.TTokenConsumptionType ret = SymParserWorker.TTokenConsumptionType.ETokenNotConsumed;

   150 			//

   151 			if	( aToken.Class == SymToken.TClass.EClassWhiteSpace )

   152 			{

   153 				// Skip leading whitespace

   154 				ret = SymParserWorker.TTokenConsumptionType.ETokenConsumed;

   155 			}

   156 			else

   157 			{

   158 				// Change state

   159 				State = TState.EStateDefineName;

   160 				ResetTokenContainer();

   161 			}

   162 			//

   163 			return ret;

   164 		}

   165 

   166 		private SymParserWorker.TTokenConsumptionType OnStateDefineName( SymToken aToken )

   167 		{

   168 			SymParserWorker.TTokenConsumptionType ret = SymParserWorker.TTokenConsumptionType.ETokenNotConsumed;

   169 			//

   170 			if	( aToken.Class == SymToken.TClass.EClassWhiteSpace )

   171 			{

   172 				// Got some whitespace - so we're going to bail

   173 				MakeDefineName();

   174 				State = TState.EStateMiddleWhiteSpace;

   175 			}

   176 			else if ( aToken.Class == SymToken.TClass.EClassNewLine || aToken.Class == SymToken.TClass.EClassContinuation )

   177 			{

   178 				// Do nothing - new line is handled by base class (so we must not consume it)

   179 				// and continuations are ignored.

   180 			}

   181 			else

   182 			{

   183 				// Keep reading tokens until we hit some whitespace

   184 				bool consumed = iFunctionParser.OfferToken( aToken );

   185 				if	( consumed == true )

   186 				{

   187 					ret = SymParserWorker.TTokenConsumptionType.ETokenConsumed;

   188 				}

   189 			}

   190 			//

   191 			return ret;

   192 		}

   193 

   194 		private SymParserWorker.TTokenConsumptionType OnStateDefineArguments( SymToken aToken )

   195 		{

   196 			SymParserWorker.TTokenConsumptionType ret = SymParserWorker.TTokenConsumptionType.ETokenNotConsumed;

   197 			//

   198 			if	( aToken.Class == SymToken.TClass.EClassWhiteSpace && iFunctionParser.CurrentLevelNumber == 0 )

   199 			{

   200 				// Got some whitespace - so we're going to bail

   201 				MakeDefineArgument();

   202 				State = TState.EStateMiddleWhiteSpace;

   203 			}

   204 			else if ( aToken.Class == SymToken.TClass.EClassNewLine || aToken.Class == SymToken.TClass.EClassContinuation )

   205 			{

   206 				// Do nothing - new line is handled by base class (so we must not consume it)

   207 				// and continuations are ignored.

   208 			}

   209 			else

   210 			{

   211 				// Keep reading tokens until we hit some whitespace

   212 				bool consumed = iFunctionParser.OfferToken( aToken );

   213 				if	( consumed == true )

   214 				{

   215 					ret = SymParserWorker.TTokenConsumptionType.ETokenConsumed;

   216 				}

   217 			}

   218 			//

   219 			return ret;

   220 		}

   221 

   222 		private SymParserWorker.TTokenConsumptionType OnStateMiddleWhiteSpace( SymToken aToken )

   223 		{

   224 			SymParserWorker.TTokenConsumptionType ret = SymParserWorker.TTokenConsumptionType.ETokenNotConsumed;

   225 			//

   226 			if	( aToken.Class == SymToken.TClass.EClassWhiteSpace )

   227 			{

   228 				// Skip leading whitespace

   229 				ret = SymParserWorker.TTokenConsumptionType.ETokenConsumed;

   230 			}

   231 			else

   232 			{

   233 				// Change state

   234 				State = TState.EStateDefineValue;

   235 				ResetTokenContainer();

   236 			}

   237 			//

   238 			return ret;

   239 		}

   240 

   241 		private SymParserWorker.TTokenConsumptionType OnStateDefineValue( SymToken aToken )

   242 		{

   243 			SymParserWorker.TTokenConsumptionType ret = SymParserWorker.TTokenConsumptionType.ETokenNotConsumed;

   244 			//

   245 			if	( aToken.Class != SymToken.TClass.EClassNewLine )

   246 			{

   247 				iTokens.Append( aToken );

   248 				ret = SymParserWorker.TTokenConsumptionType.ETokenConsumed;

   249 			}

   250 			//

   251 			return ret;

   252 		}

   253 		#endregion

   254 

   255 		#region Internal token balancer/function parser event handlers

   256 		private void FunctionParserEventArgumentAvailableHandler( SymArgument aArgument, SymToken aDelimitingToken )

   257 		{

   258 			MakeDefineArgument( aArgument );

   259 		}

   260 

   261 		private void TokenBalancerEventLevelStarted( int aLevelCount, SymNode aOldLevel, SymNode aNewLevel )

   262 		{

   263 			switch( State )

   264 			{

   265 			case TState.EStateDefineName:

   266 				MakeDefineName();

   267 				State = TState.EStateDefineArguments;

   268 				break;

   269 			case TState.EStateDefineArguments:

   270 				break;

   271 			case TState.EStateDefineValue:

   272 			case TState.EStateInitialWhiteSpace:

   273 			case TState.EStateMiddleWhiteSpace:

   274 			default:

   275 				System.Diagnostics.Debug.Assert( false );

   276 				break;

   277 			}

   278 		}

   279 

   280 		private void TokenBalancerEventLevelFinished( int aLevelCount, SymNode aOldLevel, SymNode aNewLevel )

   281 		{

   282 			switch( State )

   283 			{

   284 				case TState.EStateDefineName:

   285 					MakeDefineName();

   286 					State = TState.EStateDefineArguments;

   287 					break;

   288 				case TState.EStateDefineArguments:

   289 					if	( aLevelCount == 0 )

   290 					{

   291 						MakeDefineArgument();

   292 						State = TState.EStateMiddleWhiteSpace;

   293 					}

   294 					break;

   295 				case TState.EStateDefineValue:

   296 				case TState.EStateInitialWhiteSpace:

   297 				case TState.EStateMiddleWhiteSpace:

   298 				default:

   299 					System.Diagnostics.Debug.Assert( false );

   300 					break;

   301 			}

   302 		}

   303 

   304 		private void TokenBalancerEventLevelsBalanced()

   305 		{

   306 		}

   307 

   308 		private void TokenBalancerEventLevelsImbalanced()

   309 		{

   310 			//TODO

   311 		}

   312 		#endregion

   313 

   314 		#region Internal temp buffer related methods

   315 		public void ResetTokenContainer()

   316 		{

   317 			iTokens.Reset();

   318 			iFunctionParser.Reset();

   319 		}

   320 

   321 		public void AddToken( SymToken aToken )

   322 		{

   323 			iTokens.Append( aToken );

   324 		}

   325 		#endregion

   326 

   327 		#region Misc internal helpers

   328 		private void MakeDefineName()

   329 		{

   330 			iDefine.Name = iFunctionParser.MakeFunctionName();

   331 		}

   332 

   333 		private void MakeDefineArgument()

   334 		{

   335 			SymArgument argument = iFunctionParser.MakeArgument();

   336 			MakeDefineArgument( argument );

   337 		}

   338 

   339 		private void MakeDefineArgument( SymArgument aArgument )

   340 		{

   341 			// Convert generic argument into define-specific argument

   342 			SymDefineArgument defineArgument = new SymDefineArgument( aArgument );

   343 			iDefine.AddArgument( defineArgument );

   344 		}

   345 

   346 		private void MakeDefineValue()

   347 		{

   348 			iDefine.Value = iTokens;

   349 			iTokens = new SymTokenContainer();

   350 		}

   351 		#endregion

   352 

   353 		#region Data members

   354 		private TState iState = TState.EStateInitialWhiteSpace;

   355 		private SymDefineDefinition iDefine = new SymDefineDefinition();

   356 		private SymTokenContainer iTokens = new SymTokenContainer();

   357 		private SymFunctionParser iFunctionParser = new SymFunctionParser();

   358 		#endregion

   359 	}

   360 }