public static void EmitAddFrame(ILEmitter/*!*/ il, IPlace/*!*/ scriptContextPlace, int typeArgCount, int argCount,
		  Action<ILEmitter, int> typeArgEmitter, Action<ILEmitter, int>/*!*/ argEmitter)
		{
			Debug.Assert(typeArgCount == 0 || typeArgEmitter != null);

			// type args:
			if (typeArgCount > 0)
			{
				scriptContextPlace.EmitLoad(il);
				il.Emit(OpCodes.Ldfld, Fields.ScriptContext_Stack);

				il.EmitOverloadedArgs(Types.DTypeDesc[0], typeArgCount, Methods.PhpStack.AddTypeFrame.ExplicitOverloads, typeArgEmitter);
			}

			// args:
			scriptContextPlace.EmitLoad(il);
			il.Emit(OpCodes.Ldfld, Fields.ScriptContext_Stack);

			il.EmitOverloadedArgs(Types.Object[0], argCount, Methods.PhpStack.AddFrame.ExplicitOverloads, argEmitter);

			il.Emit(OpCodes.Call, Methods.PhpStack.AddFrame.Overload(argCount));

			// AddFrame adds empty type frame by default, so if there are no type parameters, we can skip AddTypeFrame call:
			if (typeArgCount > 0)
				il.Emit(OpCodes.Call, Methods.PhpStack.AddTypeFrame.Overload(typeArgCount));
		}

 public IArc AddArc(IPlace place, ITransition transition)
 {
     IArc arc=new Arc(version++,place,transition);
     this.arcs.Add(arc);
     this.graph.AddEdge(arc);
     return arc;
 }

 public Arc(int id,ITransition transition,IPlace place)
     : base(id,transition,place)
 {
     this.place=place;
     this.transition=transition;
     this.isInputArc=false;
 }

 public IArc AddArc(ITransition transition, IPlace place)
 {
     IArc arc = new Arc(this.version++, transition, place);
     this.arcs.Add(arc);
     this.graph.AddEdge(transition, place);
     return arc;
 }

		public ClrStubBuilder(ILEmitter/*!*/ il, IPlace/*!*/ scriptContextPlace, int paramCount, int paramOffset)
		{
			this.il = il;
			this.scriptContextPlace = scriptContextPlace;
			this.paramOffset = paramOffset;

			this.referenceLocals = new LocalBuilder[paramCount];
		}

 public Arc(int id, ITransition transition, IPlace place)
     : base(id, transition, place)
 {
     this.annotation = new IdentityExpression();
     this.place = place;
     this.transition = transition;
     this.isInputArc = false;
 }

 public LegoStoragePlace(IPlace placeInFront)
 {
     Above = LegoStoragePlace.None;
     Underneath = LegoStoragePlace.None;
     PlaceInFront = placeInFront;
     Empty = true;
     Container = null;
     Level = 1;
 }

 public Location(int x, int y, IPlace o)
 {
     X = x;
     Y = y;
     Block = o;
     Visible = false;
     Script = null;
     symbol = Block.Symbol();
 }

		public LinqBuilder(CodeGenerator/*!*/ cg)
		{
			this.cg = cg;

			IPlace this_place = new IndexedPlace(PlaceHolder.Argument, 0);

			this.rtVariablesPlace = new Place(this_place, Fields.LinqContext_variables);
			this.scriptContextPlace = new Place(this_place, Fields.LinqContext_context);
			this.classContextPlace = new Place(this_place, Fields.LinqContext_typeHandle);
			this.selfPlace = new Place(this_place, Fields.LinqContext_outerType);
		}

		public static void EmitArgFullPostCall(ILEmitter/*!*/ il, IPlace/*!*/ stack, LocalBuilder locArgsCount)
		{
			// args-aware:
			if (locArgsCount != null)
			{
				// CALL stack.RemoveArgsAwareFrame(count);
				stack.EmitLoad(il);
				il.Ldloc(locArgsCount);
				il.Emit(OpCodes.Call, Methods.PhpStack.RemoveArgsAwareFrame);
			}
		}

        public void AddPlace(IPlace place)
        {
            if (place == null)
            {
                throw new ArgumentNullException("The place connot be null.");
            }
            if (this.CheckExistingElement(place.Name))
            {
                throw new AlreadyExistingElementException("This name already exists.");
            }

            this.places.Add(place);
        }

 public double Execute(ICar car, IPlace place, double journeyDuration)
 {
     ITrafficLight trafficLight = (ITrafficLight)place;
     double timetaken = 0;
     double waitingTime  = trafficLight.GetWaitingTime(journeyDuration);
     if (waitingTime > 0)
     {
         timetaken += car.Stop();
         timetaken += waitingTime;
         timetaken += car.Start();
     }
     return timetaken;
 }

 public IPresenter GetPresenter(IPlace place)
 {
     if (place is Empty.EmptyPlace)
     {
         return new Empty.EmptyPresenter((Empty.EmptyPlace)place, services);
     }
     else if (place is Test.TestPlace)
     {
         return new Test.TestPresenter((Test.TestPlace)place, services);
     }
     else
     {
         throw new ArgumentException();
     }
 }

 private void OK_Click(object sender, EventArgs e)
 {
     if (searchMode)
     {
         RunSearch();
     }
     else
     {
         if (resultsListbox.SelectedIndex > -1)
         {
             Result = (IPlace)resultsListbox.SelectedItem;
             DialogResult = DialogResult.OK;
             Close();
         }
     }
 }

 public static void AddParts(string key, IPlace place)
 {
     key = key.ToLower();
     autoCompleteList.Add(key, place);
     var parts = key.Split(new[] { ' ' });
     if (parts.Length > 1)
     {
         foreach (var part in parts)
         {
             if (!string.IsNullOrEmpty(part))
             {
                 autoCompleteList.Add(part, place);
             }
         }
     }
 }

        internal void AddFigurePoint(IPlace place)
        {
            TreeNode parent;
            var pnt = new Linepoint(place.RA * 15 - 180, place.Dec, PointType.Line, place.Name != Language.GetLocalizedText(90, "No Object") ? place.Name : null);
            if (figureTree.SelectedNode.Tag is Linepoint)
            {
                parent = figureTree.SelectedNode.Parent;

                var ls = (Lineset)parent.Tag;

                var lp = (Linepoint)figureTree.SelectedNode.Tag;

                var index = ls.Points.FindIndex(delegate(Linepoint target) { return target == lp; }) + 1;

                ls.Points.Insert(index, pnt);

                TreeNode child;
                if (index >= parent.Nodes.Count)
                {
                    child = parent.Nodes.Add(pnt.ToString());
                }
                else
                {
                    child = parent.Nodes.Insert(index, pnt.ToString());
                }
                child.Tag = pnt;
                child.Checked = pnt.PointType != PointType.Move;
                figureTree.SelectedNode = child;
                Earth3d.MainWindow.constellationsFigures.ResetConstellation(ls.Name);
            }
            else
            {
                parent = figureTree.SelectedNode;
                var ls = (Lineset)figureTree.SelectedNode.Tag;
                ls.Points.Add( pnt);
                var child = parent.Nodes.Add( pnt.ToString());
                child.Tag = pnt;
                child.Checked = pnt.PointType != PointType.Move;
                figureTree.SelectedNode = child;
                Earth3d.MainWindow.constellationsFigures.ResetConstellation(ls.Name);
            }
        }

		public static void EmitArgFullPreCall(ILEmitter/*!*/ il, IPlace/*!*/ stack, bool argsAware,
		  int formalParamCount, int formalTypeParamCount, out LocalBuilder locArgsCount)
		{
			if (argsAware)
			{
				locArgsCount = il.DeclareLocal(typeof(int));

				// locArgsCount = stack.MakeArgsAware(<formal tpye param count | formal param count>);
				stack.EmitLoad(il);
				il.LdcI4((formalTypeParamCount << 16) | formalParamCount);
				il.Emit(OpCodes.Call, Methods.PhpStack.MakeArgsAware);
				il.Stloc(locArgsCount);
			}
			else
			{
				locArgsCount = null;

				// CALL stack.RemoveFrame();
				stack.EmitLoad(il);
				il.Emit(OpCodes.Call, Methods.PhpStack.RemoveFrame);
			}
		}

        private IDrivingStrategy SelectDrivingStrategy(IPlace place)
        {
            IDrivingStrategy drivingStrategy = null;

            if (place is IRoadStretch)
            {
                if (_roadDrivingStrategy == null)
                {
                    _roadDrivingStrategy = new RoadDrivingStrategy();
                }
                drivingStrategy = _roadDrivingStrategy;
            }
            else if (place is ITrafficLight)
            {
                if (_traficLightDrivingStrategy == null)
                {
                    _traficLightDrivingStrategy = new TrafficLightDrivingStrategy();
                }
                drivingStrategy = _traficLightDrivingStrategy;
            }

            return drivingStrategy;
        }

        public TweetObj(string text, string creatorName, string screenName, DateTime time, ICoordinates coords, IPlace place, List<IHashtagEntity> hashtags)
        {
            this.text = text;
            if (creatorName == ""){
                this.creatorName = " ";
            } else {
                this.creatorName = creatorName;
            }
            if (screenName == "")
            {
                this.screenName = " ";
            }
            else {
                this.screenName = screenName;
            }
            this.time = time;

            if (coords != null)
            {
                this.coords = coords;
            }
            else
            {
                this.coords = new Coordinates(0.0,0.0);
            }
            if (place != null) { 
                this.country = place.Country;
            } else{
                country = " ";
            }
            this.hashtags = new List<String>();
            for (int i= 0; i < hashtags.Count; i++)
            {
                this.hashtags.Add(hashtags[i].Text);
            }
        }

		/// <summary>
		/// Loads a value from a specified place on the evaluation stack and boxes it if it is of a value type.
		/// </summary>
		/// <param name="place">The place where to load a value from.</param>
		public void LoadBoxed(IPlace/*!*/ place)
		{
			Type type = place.PlaceType;

			place.EmitLoad(this);
			if (type.IsValueType)
				il.Emit(OpCodes.Box, type);
		}