ide.cs

compiler programming, code something

			Debug.Assert(selected.Tag != null,"Tree node has no tag value.");
			if(selected.Tag.GetType() == typeof(ProjectFile))
			{
				ProjectFile file = selected.Tag as ProjectFile;
				if(!m_ProjectFiles.Contains(file))
					m_ProjectFiles.Add(file);
				else
				{
					Crownwood.Magic.Controls.TabPage tabPage = file.Tab;
					m_Files.SelectedTab = tabPage;
				}
			}			
		}

		/// <summary>
		///		UI command to close a file.
		/// </summary>
		private void OnFilesClosed(object sender, EventArgs e)
		{
			if(m_Files.TabPages.Count == 0)
				return;
			m_ProjectFiles.Remove(m_Files.SelectedTab.Tag as ProjectFile);
		}


		/// <summary>
		///		UI command that modified the source code of a file.
		/// </summary>
		private void OnProjectFileTextChanged(object sender, EventArgs e)
		{
			ProjectFile file = ((TextAreaControl)sender).Tag as ProjectFile;
			file.IsChanged = true;
		}

		/// <summary>
		///		UI command that displayed a new source tab page.
		/// </summary>
		private void OnPageGotFocus(object sender, EventArgs e)
		{
			m_ProjectFile = m_Files.SelectedTab.Tag as ProjectFile;
			UpdateUIState();
		}

		/// <summary>
		///		UI command to build the parse tree for the current file.
		/// </summary>
		private void OnBuildParseTree(object sender, EventArgs e)
		{
			if(m_ProjectFile == null)
				return;

			m_ProjectFile.Source.SaveFile(m_ProjectFile.Path);
			m_ProjectFile.IsChanged = false;

			Scanner scanner = new Scanner(m_ProjectFile.Path,m_Language);
			Parser parser = new Parser(scanner,m_Language);

			ParseTreeNode root = parser.CreateParseTree ();

			if(root == null)
			{
				UI.Error("Cannot build parse tree from file [" + m_ProjectFile.Name + "] because its not grammatical");
				return;
			}

			//
			// Show parse tree
			//

			m_tvParseTree.Nodes.Clear();
			TreeNode rootNode = new TreeNode(root.Name,(int)IconIndex.NonTerminal,(int)IconIndex.NonTerminal);
			BuildParseTreeNode(rootNode,root.Children);
			m_tvParseTree.Nodes.Add(rootNode);
		}

		private void BuildParseTreeNode(TreeNode parent, ParseTreeNode [] children)
		{
			if(children == null)
				return;
			foreach(ParseTreeNode child in children)
			{

				TreeNode node = new TreeNode(child.Name);
				node.SelectedImageIndex = node.ImageIndex = child.Children == null ? (int)IconIndex.Terminal : (int)IconIndex.NonTerminal;
				if(child.Children != null)
					BuildParseTreeNode(node,child.Children);
				parent.Nodes.Add(node);
			}
		}

		/// <summary>
		///		UI command to build the parse tree for the current file.
		/// </summary>
		private void OnBuildSyntaxTree(object sender, EventArgs e)
		{
			if(m_ProjectFile == null)
				return;

			m_ProjectFile.Source.SaveFile(m_ProjectFile.Path);
			m_ProjectFile.IsChanged = false;

			Scanner scanner = new Scanner(m_ProjectFile.Path,m_Language);
			Parser parser = new Parser(scanner,m_Language);

			parser.Error += new ParserEventHandler(OnError);

			Module module = parser.CreateSyntaxTree();

			if(module == null)
			{
				UI.Error("Cannot build syntax tree from file [" + m_ProjectFile.Name + "] because its not grammatical");
				return;
			}

			//
			// Show parse tree
			//

			m_tvSyntaxTree.Nodes.Clear();
			TreeNode rootNode = new TreeNode("Syntax Tree",(int)IconIndex.Parse_Tree,(int)IconIndex.Parse_Tree);
			BuildSyntaxTreeNode(rootNode,module);
			m_tvSyntaxTree.Nodes.Add(rootNode);
		}

		private void BuildSyntaxTreeNode(TreeNode parent, object node)
		{
			if(node == null)
				return;

			if(node.GetType() == typeof(Module))
			{
				Module module = (Module)node;

				TreeNode moduleNode = new TreeNode("Module : " + module.Name,(int)IconIndex.Module,(int)IconIndex.Module);
				BuildSyntaxTreeNode(moduleNode,module.Body);
				parent.Nodes.Add(moduleNode);
			}
			else if(node.GetType() == typeof(Body))
			{
				Body body = (Body)node;
				TreeNode bodyNode = new TreeNode("Body",(int)IconIndex.Body,(int)IconIndex.Body);
				if(body.Structures != null)
					foreach(Structure structure in body.Structures)
						BuildSyntaxTreeNode(bodyNode,structure);
				if(body.Functions != null)
					foreach(Function function in body.Functions)
						BuildSyntaxTreeNode(bodyNode,function);
				if(body.Statements != null)
					foreach(Statement statement in body.Statements)
						BuildSyntaxTreeNode(bodyNode,statement);
				parent.Nodes.Add(bodyNode);
			}
			else if(node.GetType() == typeof(Function))
			{
				Function function = (Function)node;
				TreeNode functionNode = new TreeNode("Function : " + function.Name,(int)IconIndex.Function,(int)IconIndex.Function);
				BuildSyntaxTreeNode(functionNode,function.Type);
				TreeNode parametersNode = new TreeNode("Parameters",(int)IconIndex.Expression,(int)IconIndex.Expression);
				if(function.Parameters != null)
					foreach(Parameter parameter in function.Parameters)
						BuildSyntaxTreeNode(parametersNode,parameter);
				functionNode.Nodes.Add(parametersNode);
				BuildSyntaxTreeNode(functionNode,function.Body);
				parent.Nodes.Add(functionNode);
			}
			else if(node.GetType() == typeof(Variable))
			{
				Variable variable = (Variable)node;
				TreeNode variableNode = new TreeNode("Variable : " + variable.Name,(int)IconIndex.Variable,(int)IconIndex.Variable);
				BuildSyntaxTreeNode(variableNode,variable.Type);
				TreeNode valueNode = new TreeNode("Value",7,7);
				BuildSyntaxTreeNode(valueNode,variable.Value);
				variableNode.Nodes.Add(valueNode);
				parent.Nodes.Add(variableNode);
			}
			else if(node.GetType() == typeof(Structure))
			{
				Structure structure = (Structure)node;
				TreeNode structureNode = new TreeNode("Structure : " + structure.Name,(int)IconIndex.Structure,(int)IconIndex.Structure);
				TreeNode variablesNode = new TreeNode("Variables",7,7);
				if(structure.Variables != null)
					foreach(Variable variable in structure.Variables)
						BuildSyntaxTreeNode(variablesNode,variable);
				structureNode.Nodes.Add(variablesNode);
				parent.Nodes.Add(structureNode);
			}
			else if(node.GetType() == typeof(Core.Type))
			{
				Core.Type type = (Core.Type)node;
				TreeNode typeNode = new TreeNode("Type",7,7);
				typeNode.Nodes.Add(new TreeNode("Primitive Type : " + type.PrimitiveType.ToString(),7,7));
				typeNode.Nodes.Add(new TreeNode("Variable Type : " + type.VariableType.ToString(),7,7));
				parent.Nodes.Add(typeNode);
			}
			else if(node.GetType() == typeof(Parameter))
			{
				Parameter parameter = (Parameter)node;
				TreeNode parameterNode = new TreeNode("Parameter : " + parameter.Name,7,7);
				BuildSyntaxTreeNode(parameterNode,parameter.Type);
				parameterNode.Nodes.Add(new TreeNode("Pass Method : " + parameter.PassMethod.ToString(),7,7));
				parent.Nodes.Add(parameterNode);
			}
			else if(node.GetType() == typeof(Assignment))
			{
				Assignment assignment = (Assignment)node;
				TreeNode assignmentNode = new TreeNode("Assignment : " + assignment.Name,(int)IconIndex.Expression,(int)IconIndex.Expression);
				TreeNode val = new TreeNode("Value",(int)IconIndex.Expression,(int)IconIndex.Expression);
				BuildSyntaxTreeNode(val,assignment.Value);
				assignmentNode.Nodes.Add(val);
				parent.Nodes.Add(assignmentNode);
			}
			else if(node.GetType() == typeof(If))
			{
				If ifStatement = (If)node;
				TreeNode ifNode = new TreeNode("if",7,7);
				TreeNode condition = new TreeNode("Condition",(int)IconIndex.Expression,(int)IconIndex.Expression);
				BuildSyntaxTreeNode(condition,ifStatement.Condition);
				TreeNode ifBody = new TreeNode("If Body",(int)IconIndex.Body,(int)IconIndex.Body);
				BuildSyntaxTreeNode(ifBody,ifStatement.IfBody);
				TreeNode elseBody = new TreeNode("Else Body",(int)IconIndex.Body,(int)IconIndex.Body);
				BuildSyntaxTreeNode(elseBody,ifStatement.ElseBody);
				ifNode.Nodes.Add(condition);
				ifNode.Nodes.Add(ifBody);
				ifNode.Nodes.Add(elseBody);
				parent.Nodes.Add(ifNode);
			}
			else if(node.GetType() == typeof(While))
			{
				While whileStatement = (While)node;
				TreeNode whileNode = new TreeNode("while",7,7);
				TreeNode condition = new TreeNode("Condition",(int)IconIndex.Expression,(int)IconIndex.Expression);
				BuildSyntaxTreeNode(condition,whileStatement.Condition);
				whileNode.Nodes.Add(condition);
				BuildSyntaxTreeNode(whileNode,whileStatement.Body);
				parent.Nodes.Add(whileNode);
			}
			else if(node.GetType() == typeof(Do))
			{
				Do doStatement = (Do)node;
				TreeNode doNode = new TreeNode("do",7,7);
				TreeNode condition = new TreeNode("Condition",(int)IconIndex.Expression,(int)IconIndex.Expression);
				BuildSyntaxTreeNode(condition,doStatement.Condition);
				doNode.Nodes.Add(condition);
				BuildSyntaxTreeNode(doNode,doStatement.Body);
				parent.Nodes.Add(doNode);
			}
			else if(node.GetType() == typeof(For))
			{
				For forStatement = (For)node;
				TreeNode forNode = new TreeNode("for",7,7);

				TreeNode initializer = new TreeNode("Initializer",(int)IconIndex.Expression,(int)IconIndex.Expression);
				BuildSyntaxTreeNode(initializer,forStatement.Initializer);
				forNode.Nodes.Add(initializer);

				TreeNode condition = new TreeNode("Condition",(int)IconIndex.Expression,(int)IconIndex.Expression);
				BuildSyntaxTreeNode(condition,forStatement.Condition);
				forNode.Nodes.Add(condition);

				TreeNode counter = new TreeNode("Counter",(int)IconIndex.Expression,(int)IconIndex.Expression);
				BuildSyntaxTreeNode(counter,forStatement.Counter);
				forNode.Nodes.Add(counter);

				BuildSyntaxTreeNode(forNode,forStatement.Body);
				parent.Nodes.Add(forNode);
			}
			else if(node.GetType() == typeof(BinaryExpression))
			{
				BinaryExpression binaryExpression = (BinaryExpression)node;
				TreeNode binaryExpressionNode = new TreeNode("Binary Expression : " + binaryExpression.BinaryOperatorType.ToString(),7,7);
				TreeNode left = new TreeNode("Left",(int)IconIndex.Expression,(int)IconIndex.Expression);
				BuildSyntaxTreeNode(left,binaryExpression.Left);

				TreeNode right = new TreeNode("Right",(int)IconIndex.Expression,(int)IconIndex.Expression);
				BuildSyntaxTreeNode(right,binaryExpression.Right);

				binaryExpressionNode.Nodes.Add(left);
				binaryExpressionNode.Nodes.Add(right);
				parent.Nodes.Add(binaryExpressionNode);
			}
			else if(node.GetType() == typeof(UnaryExpression))
			{
				UnaryExpression unaryExpression = (UnaryExpression)node;
				TreeNode unaryExpressionNode = new TreeNode("Unary Expression : " + unaryExpression.UnaryOperatorType.ToString(),7,7);
				
				TreeNode val = new TreeNode("Value",(int)IconIndex.Expression,(int)IconIndex.Expression);
				BuildSyntaxTreeNode(val,unaryExpression.Value);
				
				TreeNode indexer = new TreeNode("Indexer",(int)IconIndex.Expression,(int)IconIndex.Expression);
				BuildSyntaxTreeNode(indexer,unaryExpression.Indexer);

				unaryExpressionNode.Nodes.Add(val);
				unaryExpressionNode.Nodes.Add(indexer);
				parent.Nodes.Add(unaryExpressionNode);
			}	
			else if(node.GetType() == typeof(Literal))
			{
				Literal literal = (Literal)node;
				TreeNode literalNode = new TreeNode("Literal : " + literal.Value,(int)IconIndex.Expression,(int)IconIndex.Expression);
				TreeNode literalTypeNode = new TreeNode("Literal Type : " + literal.LiteralType.ToString(),7,7);
				literalNode.Nodes.Add(literalTypeNode);
				parent.Nodes.Add(literalNode);
			}
			else if(node.GetType() == typeof(Call))
			{
				Call call = (Call)node;
				TreeNode callNode = new TreeNode("Call : " + call.Name,(int)IconIndex.Function,(int)IconIndex.Function);
				TreeNode argumentsNode = new TreeNode("Arguments",7,7);
				if(call.Arguments != null)
					foreach(Argument argument in call.Arguments)
						BuildSyntaxTreeNode(argumentsNode,argument);
				callNode.Nodes.Add(argumentsNode);
				parent.Nodes.Add(callNode);
			}
			else if(node.GetType() == typeof(Name))
			{
				Name name = (Name)node;
				TreeNode nameNode = new TreeNode("Name : " + name.Value,(int)IconIndex.Expression,(int)IconIndex.Expression);
				parent.Nodes.Add(nameNode);
			}
			else if(node.GetType() == typeof(Argument))
			{
				Argument argument = (Argument)node;
				
				TreeNode argumentNode = new TreeNode("Argument",7,7);
				TreeNode valueNode = new TreeNode("Value",7,7);
				BuildSyntaxTreeNode(valueNode,argument.Value);

				argumentNode.Nodes.Add(valueNode);
				argumentNode.Nodes.Add(new TreeNode("Pass Method : " + argument.PassMethod.ToString(),7,7));
				parent.Nodes.Add(argumentNode);
			}
		}


		void OnError(Token token, string message)
		{
			WriteAndScroll(m_Output,"[" + token.Line + "," + token.Column + "] " + message + " : '" + token.Text + "'\n");
		}

		void OnWarning(Token token, string message)
		{

		}

		//
		// Events generated by the project.
		//

		/// <summary>
		///		Modify UI elements for the changed file.
		/// </summary>
		private void OnProjectFileChanged(ProjectFile file)
		{
			Crownwood.Magic.Controls.TabPage tabPage = file.Tab;
			
			if(file.IsChanged)
				tabPage.Title = file.Name + " *";
			else
				tabPage.Title = file.Name;
		}


		/// <summary>
		///		Add UI elements for the added file.
		/// </summary>
		private void OnProjectFileAdded(ProjectFile file)
		{
			TreeNode tnProject = (TreeNode)file.Project.Node;
			TreeNode tnFile = new TreeNode(Path.GetFileName(file.Path),(int)IconIndex.File,(int)IconIndex.File);
			tnFile.Tag = file;
			file.Node = tnFile;
			tnProject.Nodes.Add(tnFile);
			tnProject.Expand();
		}


		/// <summary>
		///		Remove UI elements for the removed file.
		/// </summary>
		private void OnProjectFileRemoved(ProjectFile file)
		{
			TreeNode tnFile = file.Node;
			tnFile.Remove();
		}

		/// <summary>
		///		Add UI elements for the file to be opened for editing.
		/// </summary>
		private void OnProjectFileOpened(ProjectFile file)
		{
			if(!File.Exists(file.Path))
			{
				MessageBox.Show("File not found.");
				return;
			}

			Crownwood.Magic.Controls.TabPage tabPage = new Crownwood.Magic.Controls.TabPage(file.Name);
			TextAreaControl editor = new ICSharpCode.TextEditor.TextAreaControl();
			editor.Tag = file;
			editor.LoadFile(file.Path);
			editor.Changed += new EventHandler(OnProjectFileTextChanged);
			tabPage.Control = editor;
			tabPage.Tag = file;
			tabPage.ImageList = m_ImageList;
			tabPage.ImageIndex = (int)IconIndex.File;
			file.Tab = tabPage;
			file.Source = editor;
			file.Changed += new ProjectFileEventHandler(OnProjectFileChanged);
			m_Files.TabPages.Add(tabPage);
			m_Files.SelectedTab = tabPage;
			file.IsChanged = false;

		}

		/// <summary>
		///		Remove UI elements for the file to be closed.
		/// </summary>
		private void OnProjectFileClosed(ProjectFile file)
		{
			m_Files.TabPages.Remove(file.Tab);

			file.Source = null;
			file.Tab = null;

			if(m_Files.SelectedTab != null)
				m_ProjectFile = m_Files.SelectedTab.Tag as ProjectFile;
			else
				m_ProjectFile = null;
			UpdateUIState();
		}
	}
}