itcl/plugins/org.eclipse.dltk.itcl.core/src/org/eclipse/dltk/itcl/internal/core/parser/processors/IncrTclClassCommandProcessor.java

package org.eclipse.dltk.itcl.internal.core.parser.processors;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.dltk.ast.ASTNode;
import org.eclipse.dltk.ast.Modifiers;
import org.eclipse.dltk.ast.declarations.TypeDeclaration;
import org.eclipse.dltk.ast.expressions.Expression;
import org.eclipse.dltk.ast.references.SimpleReference;
import org.eclipse.dltk.compiler.problem.ProblemSeverities;
import org.eclipse.dltk.itcl.internal.core.IIncrTclModifiers;
import org.eclipse.dltk.itcl.internal.core.classes.IncrTclClassesManager;
import org.eclipse.dltk.itcl.internal.core.parser.ast.IncrTclFieldDeclaration;
import org.eclipse.dltk.itcl.internal.core.parser.ast.IncrTclMethodDeclaration;
import org.eclipse.dltk.tcl.ast.TclStatement;
import org.eclipse.dltk.tcl.ast.expressions.TclBlockExpression;
import org.eclipse.dltk.tcl.core.AbstractTclCommandProcessor;
import org.eclipse.dltk.tcl.core.ITclParser;
import org.eclipse.dltk.tcl.core.TclParseUtil;
import org.eclipse.dltk.tcl.core.ast.ExtendedTclMethodDeclaration;

public class IncrTclClassCommandProcessor extends AbstractTclCommandProcessor {
	@Override
	public ASTNode process(TclStatement statement, ITclParser parser, ASTNode parent) {
		if (statement == null || (statement != null && statement.getCount() == 0)) {
			return null;
		}
		if (statement.getCount() != 3) {
			// error not correct arguments
			return null;
		}
		Expression classNameExpr = statement.getAt(1);
		Expression blockExpr = statement.getAt(2);
		if (classNameExpr instanceof SimpleReference && blockExpr instanceof TclBlockExpression) {
			TclBlockExpression block = (TclBlockExpression) blockExpr;
			TypeDeclaration type = new TypeDeclaration(((SimpleReference) classNameExpr).getName(),
					classNameExpr.sourceStart(), classNameExpr.sourceEnd(), statement.sourceStart(),
					statement.sourceEnd());
			type.setModifiers(IIncrTclModifiers.AccIncrTcl);
			this.addToParent(parent, type);
			// Report type to list of types.
			IncrTclClassesManager.getDefault().add(type.getName());

			List commands = block.parseBlockSimple(false);
			for (int i = 0; i < commands.size(); i++) {
				ASTNode nde = (ASTNode) commands.get(i);
				if (nde instanceof TclStatement) {
					TclStatement st = (TclStatement) nde;
					Expression commandName = st.getAt(0);
					if (commandName instanceof SimpleReference) {
						String commandNameStr = ((SimpleReference) commandName).getName();
						if ("inherit".equals(commandNameStr)) {
							handleInherit(st, type, parser);
						} else if ("public".equals(commandNameStr)) {
							handleWithModifierSub(st, type, Modifiers.AccPublic, parser);
						} else if ("protected".equals(commandNameStr)) {
							handleWithModifierSub(st, type, Modifiers.AccProtected, parser);
						} else if ("private".equals(commandNameStr)) {
							handleWithModifierSub(st, type, Modifiers.AccPrivate, parser);
						} else {
							handleWithModifier(commandNameStr, st, type, Modifiers.AccPrivate, parser);
						}
					}
				}
			}
			return type;
		}
		return null;
	}

	private void handleDestructor(TclStatement statement, TypeDeclaration type, ITclParser parser) {
		if (statement.getCount() != 2) {
			this.report(parser, "Wrong number of arguments", statement.sourceStart(), statement.sourceEnd(),
					ProblemSeverities.Error);
			addToParent(type, statement);
			return;
		}
		Expression procCode = statement.getAt(1);

		ExtendedTclMethodDeclaration method = new ExtendedTclMethodDeclaration(statement.sourceStart(),
				statement.sourceEnd());
		method.setName("destructor");
		Expression o = statement.getAt(0);
		method.setNameStart(o.sourceStart());
		method.setNameEnd(o.sourceEnd());
		method.setModifier(IIncrTclModifiers.AccIncrTcl | IIncrTclModifiers.AccDestructor);
		method.setDeclaringType(type);
		IncrTclUtils.parseBlockAdd(parser, procCode, method);
		type.getMethodList().add(method);
		this.addToParent(type, method);
	}

	private void handleWithModifierSub(TclStatement statement, TypeDeclaration type, int modifier, ITclParser parser) {
		List expressions = statement.getExpressions();
		List newExpressions = new ArrayList();
		newExpressions.addAll(expressions);
		if (newExpressions.size() > 0) {
			newExpressions.remove(0);
		}
		TclStatement sub = new TclStatement(newExpressions);
		Expression commandName = sub.getAt(0);
		if (commandName instanceof SimpleReference) {
			handleWithModifier(((SimpleReference) commandName).getName(), sub, type, modifier, parser);
		}
	}

	private void handleConstructor(TclStatement statement, TypeDeclaration type, ITclParser parser) {
		if (statement.getCount() < 3) {
			this.report(parser, "Wrong number of arguments", statement.sourceStart(), statement.sourceEnd(),
					ProblemSeverities.Error);
			addToParent(type, statement);
			return;
		}
		Expression procArguments = statement.getAt(1);
		Expression procCode = null;
		// Expression procInit = null;
		if (statement.getCount() == 3) {
			procCode = statement.getAt(2);
		} else if (statement.getCount() == 4) {
			procCode = statement.getAt(3);
			// procInit = statement.getAt(2);
		}

		List arguments = IncrTclUtils.extractMethodArguments(procArguments);

		ExtendedTclMethodDeclaration method = new ExtendedTclMethodDeclaration(statement.sourceStart(),
				statement.sourceEnd());
		method.setDeclaringType(type);
		method.setName("constructor");
		Expression o = statement.getAt(0);
		method.setNameStart(o.sourceStart());
		method.setNameEnd(o.sourceEnd());
		method.acceptArguments(arguments);
		method.setModifier(IIncrTclModifiers.AccIncrTcl | IIncrTclModifiers.AccConstructor);
		IncrTclUtils.parseBlockAdd(parser, procCode, method);
		type.getMethodList().add(method);
		this.addToParent(type, method);
	}

	private void handleWithModifier(String commandNameStr, TclStatement statement, TypeDeclaration type, int modifier,
			ITclParser parser) {

		if ("method".equals(commandNameStr)) {
			handleMethod(statement, type, modifier, parser);
		} else if ("proc".equals(commandNameStr)) {
			handleMethod(statement, type, modifier | IIncrTclModifiers.AccIncrTclProc, parser);
		} else if ("variable".equals(commandNameStr)) {
			handleVariable(statement, type, modifier, parser);
		} else if ("common".equals(commandNameStr)) {
			handleCommon(statement, type, modifier, parser);
		} else if ("set".equals(commandNameStr)) {
			handleSet(statement, type, modifier, parser);
		} else if ("array".equals(commandNameStr)) {
			handleArray(statement, type, modifier);
		} else if ("constructor".equals(commandNameStr)) {
			handleConstructor(statement, type, parser);
		} else if ("destructor".equals(commandNameStr)) {
			handleDestructor(statement, type, parser);
		}
	}

	private void handleSet(TclStatement statement, TypeDeclaration type, int modifier, ITclParser parser) {
		processVariable(statement, type, modifier, parser);
	}

	private void processVariable(TclStatement statement, TypeDeclaration type, int modifier, ITclParser parser) {
		if (statement.getCount() < 2) {
			this.report(parser, "Syntax error: at least one argument expected.", statement, ProblemSeverities.Error);
			return;
		}
		Expression variableName = statement.getAt(1);
		Expression variableValue = null;
		if (statement.getCount() == 3)
			variableValue = statement.getAt(2);
		if (variableName == null) {
			throw new RuntimeException("empty variable name");
		}
		SimpleReference variable = TclParseUtil.makeVariable(variableName);
		if (variable != null) {
			IncrTclFieldDeclaration var = new IncrTclFieldDeclaration(variable.getName(), variable.sourceStart(),
					variable.sourceEnd(), statement.sourceStart(), statement.sourceEnd());
			var.setModifier(IIncrTclModifiers.AccIncrTcl | modifier);
			var.setDeclaringType(type);
			this.addToParent(type, var);
			type.getFieldList().add(var);
		}
	}

	private void handleArray(TclStatement statement, TypeDeclaration type, int modifier) {
		// processVariable(statement, type, modifier, parser);
	}

	private void handleCommon(TclStatement statement, TypeDeclaration type, int modifier, ITclParser parser) {
		if (statement.getCount() < 2) {
			this.report(parser, "Syntax error: one argument expected.", statement, ProblemSeverities.Error);
			return;
		}
		Expression variableName = statement.getAt(1);
		if (variableName == null) {
			throw new RuntimeException("empty variable name");
		}
		SimpleReference variable = TclParseUtil.makeVariable(variableName);
		if (variable != null) {
			IncrTclFieldDeclaration var = new IncrTclFieldDeclaration(variable.getName(), variable.sourceStart(),
					variable.sourceEnd(), statement.sourceStart(), statement.sourceEnd());
			var.setModifier(IIncrTclModifiers.AccIncrTcl | modifier);
			var.setDeclaringType(type);
			this.addToParent(type, var);
		}
	}

	private void handleVariable(TclStatement statement, TypeDeclaration type, int modifier, ITclParser parser) {
		processVariable(statement, type, modifier, parser);
	}

	private void handleMethod(TclStatement statement, TypeDeclaration type, int modifier, ITclParser parser) {
		if (statement.getCount() < 2) {
			this.report(parser, "Wrong number of arguments", statement.sourceStart(), statement.sourceEnd(),
					ProblemSeverities.Error);
			addToParent(type, statement);
			return;
		}
		Expression procName = statement.getAt(1);

		String sName = IncrTclUtils.extractMethodName(procName);
		if (sName == null || sName.length() == 0) {
			this.report(parser, "Wrong number of arguments", statement.sourceStart(), statement.sourceEnd(),
					ProblemSeverities.Error);
			addToParent(type, statement);
			return;
		}
		Expression procArguments = null;// statement.getAt(2);
		Expression procCode = null;// statement.getAt(3);
		if (statement.getCount() >= 3) {
			procArguments = statement.getAt(2);
		}
		if (statement.getCount() == 4) {
			procCode = statement.getAt(3);
		}

		List arguments = IncrTclUtils.extractMethodArguments(procArguments);

		IncrTclMethodDeclaration method = new IncrTclMethodDeclaration(statement.sourceStart(), statement.sourceEnd());
		method.setName(sName);
		method.setNameStart(procName.sourceStart());
		method.setNameEnd(procName.sourceEnd());
		method.acceptArguments(arguments);
		method.setModifier(IIncrTclModifiers.AccIncrTcl | modifier);
		method.setDeclaringType(type);
		if ((modifier & IIncrTclModifiers.AccIncrTclProc) != 0) {
			method.setKind(ExtendedTclMethodDeclaration.KIND_PROC);
		} else {
			method.setKind(ExtendedTclMethodDeclaration.KIND_INSTPROC);
		}
		IncrTclUtils.parseBlockAdd(parser, procCode, method);
		type.getMethodList().add(method);

		this.addToParent(type, method);
	}

	private void handleInherit(TclStatement statement, TypeDeclaration type, ITclParser parser) {
		for (int i = 1; i < statement.getCount(); i++) {
			Expression expr = statement.getAt(i);
			if (expr instanceof SimpleReference) {
				type.addSuperClass(expr);
			}
		}
	}
}