struct FilterAnalyzer {}; //! \brief AnalyzeFilter handles a complete filter Analyzing


FilterAnalyzer createFilterAnalyzer (Module mdlCurrent) {
	Skip skpData = createString();
	put (skpData, "mdlCurrent", mdlCurrent);
	return ((addr_(skpData)) FilterAnalyzer);
}

void deleteFilterAnalyzer(FilterAnalyzer fa) {
	Skip skpData = ((addr_(fa)) Skip);
	delete (skpData);
}

void addParseReactionError(FilterAnalyzer fa, void logMessage(string)) {
	Skip skpData = ((addr_(fa)) Skip);
	int iLogFatalCommand = addr_(logMessage);
	put (skpData, "iLogFatalCommand", iLogFatalCommand);
}

void addParseReactionForNot(FilterAnalyzer fa, void reactBeforeNot(FilterAnalyzer), void reactAfterNot(FilterAnalyzer)) {
	Skip skpData = ((addr_(fa)) Skip);
	int iReactBeforeNot = addr_(reactBeforeNot);
	int iReactAfterNot = addr_(reactAfterNot);
	put (skpData, "iReactBeforeNot", iReactBeforeNot);
	put (skpData, "iReactAfterNot", iReactAfterNot);
}

void addParseReactionForAnd(FilterAnalyzer fa, void reactBeforeAnd(FilterAnalyzer), 
								void reactInsideAnd(FilterAnalyzer), void reactAfterAnd(FilterAnalyzer)) {
	Skip skpData = ((addr_(fa)) Skip);
	int iReactBeforeAnd = addr_(reactBeforeAnd);
	int iReactInsideAnd = addr_(reactInsideAnd);
	int iReactAfterAnd = addr_(reactAfterAnd);
	put (skpData, "iReactBeforeAnd", iReactBeforeAnd);
	put (skpData, "iReactInsideAnd", iReactInsideAnd);
	put (skpData, "iReactAfterAnd", iReactAfterAnd);
}

void addParseReactionForOr(FilterAnalyzer fa, void reactBeforeOr(FilterAnalyzer), void reactInsideOr(FilterAnalyzer), void reactAfterOr(FilterAnalyzer)) {
	Skip skpData = ((addr_(fa)) Skip);
	int iReactBeforeOr = addr_(reactBeforeOr);
	int iReactInsideOr = addr_(reactInsideOr);
	int iReactAfterOr = addr_(reactAfterOr);
	put (skpData, "iReactBeforeOr", iReactBeforeOr);
	put (skpData, "iReactInsideOr", iReactInsideOr);
	put (skpData, "iReactAfterOr", iReactAfterOr);
}

void addAttributeFilterReaction(FilterAnalyzer fa, void reactAfterAttributeFilter(FilterAnalyzer)) {
	Skip skpData = ((addr_(fa)) Skip);
	int iReactAfterAttributeFilter = addr_(reactAfterAttributeFilter);
	put (skpData, "iReactAfterAttributeFilter", iReactAfterAttributeFilter);
}

void addLinkFilterReaction(FilterAnalyzer fa, void reactAfterLinkFilter(FilterAnalyzer)) {
	Skip skpData = ((addr_(fa)) Skip);
	int iReactAfterLinkFilter = addr_(reactAfterLinkFilter);
	put (skpData, "iReactAfterLinkFilter", iReactAfterLinkFilter);
}

void addObjectFilterReaction(FilterAnalyzer fa, void reactAfterObjectFilter(FilterAnalyzer)) {
	Skip skpData = ((addr_(fa)) Skip);
	int iReactAfterObjectFilter = addr_(reactAfterObjectFilter);
	put (skpData, "iReactAfterObjectFilter", iReactAfterObjectFilter);
}

void addColumnFilterReaction(FilterAnalyzer fa, void reactAfterColumnFilter(FilterAnalyzer)) {
	Skip skpData = ((addr_(fa)) Skip);
	int iReactAfterColumnFilter = addr_(reactAfterColumnFilter);
	put (skpData, "iReactAfterColumnFilter", iReactAfterColumnFilter);
}

void addComplexFilterBracketReactions(FilterAnalyzer fa, void reactComplexFilterStart(FilterAnalyzer), void reactComplexFilterEnd(FilterAnalyzer)) {
	Skip skpData = ((addr_(fa)) Skip);
	int iReactComplexFilterStart = addr_(reactComplexFilterStart);
	int iReactComplexFilterEnd = addr_(reactComplexFilterEnd);
	put (skpData, "iReactComplexFilterStart", iReactComplexFilterStart);
	put (skpData, "iReactComplexFilterEnd", iReactComplexFilterEnd);
}

void reactEmpty(FilterAnalyzer fa) {};

Module getCurrentModule(FilterAnalyzer filterAnalyzer) {
	int iH = (int addr_(filterAnalyzer));
	print "1:" iH "\n";
	Skip skpData = ((addr_(filterAnalyzer)) Skip);
	Module mdlCurrent = null;
	if (find (skpData, "mdlCurrent", mdlCurrent)) {
		return (mdlCurrent);
	} else {
		return (null);
	}
}

void analyzeFilter(FilterAnalyzer fa, Filter fltrWork) {
	
	void logErrorMessage(int iAdressOfFunction, string sLogMessage) {
		void logErrorMessage_(int function(string), string sLogMessage) {
			function(sLogMessage);
		}
		if (iAdressOfFunction == -1) { return };
		logErrorMessage_(addr_(iAdressOfFunction), sLogMessage);
	}
	
	void react(int iAdressOfFunction, FilterAnalyzer fa) {
		void react_(int function(FilterAnalyzer), FilterAnalyzer fa) {
			function(fa);
		}
		if (iAdressOfFunction == -1) { return };
		react_(addr_(iAdressOfFunction), fa)
	}
	
	int iInvalidFilterType = -1;
	
	if (fltrWork == null) { return };
	
	int iFltType = getCompoundFilterType_(fltrWork);
	
	Skip skpData = ((addr_(fa)) Skip);
	Module mdlCurrent = null;
	find (skpData, "mdlCurrent", mdlCurrent);
	int iLogFatalCommand = -1;
	find (skpData, "iLogFatalCommand", iLogFatalCommand);

	int iReactBeforeNot = -1;
	find (skpData, "iReactBeforeNot", iReactBeforeNot);
	int iReactAfterNot = -1;
	find (skpData, "iReactAfterNot", iReactAfterNot);

	int iReactBeforeAnd = -1;
	find (skpData, "iReactBeforeAnd", iReactBeforeAnd);
	int iReactInsideAnd = -1;
	find (skpData, "iReactInsideAnd", iReactInsideAnd);
	int iReactAfterAnd = -1;
	find (skpData, "iReactAfterAnd", iReactAfterAnd);

	int iReactBeforeOr = -1;
	find (skpData, "iReactBeforeOr", iReactBeforeOr);
	int iReactInsideOr = -1;
	find (skpData, "iReactInsideOr", iReactInsideOr);
	int iReactAfterOr = -1;
	find (skpData, "iReactAfterOr", iReactAfterOr);

	int iReactComplexFilterStart = -1;
	find (skpData, "iReactComplexFilterStart", iReactComplexFilterStart);
	int iReactComplexFilterEnd = -1;
	find (skpData, "iReactComplexFilterEnd", iReactComplexFilterEnd);
	
	
	
	if (iFltType == filterTypeAnd) {
		Filter fltr0 = getComponentFilter_(fltrWork, 0);
		Filter fltr1 = getComponentFilter_(fltrWork, 1);
		bool isSimleFltr0 = getSimpleFilterType_(fltr0) != iInvalidFilterType;
		bool isSimleFltr1 = getSimpleFilterType_(fltr1) != iInvalidFilterType;
		react(iReactBeforeAnd, fa);
		if (!isSimleFltr0) { react(iReactComplexFilterStart, fa) };
		analyzeFilter(fa, fltr0);
		if (!isSimleFltr0) { react(iReactComplexFilterEnd, fa) };
		react(iReactInsideAnd, fa);
		if (!isSimleFltr1) { react(iReactComplexFilterStart, fa) };
		analyzeFilter(fa, fltr1);
		if (!isSimleFltr1) { react(iReactComplexFilterEnd, fa) };
		react(iReactAfterAnd, fa);
		return();
	}
	if (iFltType == filterTypeOr) {
		Filter fltr0 = getComponentFilter_(fltrWork, 0);
		Filter fltr1 = getComponentFilter_(fltrWork, 1);
		bool isSimleFltr0 = getSimpleFilterType_(fltr0) != iInvalidFilterType;
		bool isSimleFltr1 = getSimpleFilterType_(fltr1) != iInvalidFilterType;
		react(iReactBeforeOr, fa);
		if (!isSimleFltr0) { react(iReactComplexFilterStart, fa) };
		analyzeFilter(fa, fltr0);
		if (!isSimleFltr0) { react(iReactComplexFilterEnd, fa) };
		react(iReactInsideOr, fa);
		if (!isSimleFltr1) { react(iReactComplexFilterStart, fa) };
		analyzeFilter(fa, fltr1);
		if (!isSimleFltr1) { react(iReactComplexFilterEnd, fa) };
		react(iReactAfterOr, fa);
		return();
	}
	if (iFltType == filterTypeNot) {
		Filter fltr0 = getComponentFilter_(fltrWork, 0);
		bool isSimleFltr0 = getSimpleFilterType_(fltr0) != iInvalidFilterType;
		react(iReactBeforeNot, fa);
		if (!isSimleFltr0) { react(iReactComplexFilterStart, fa) };
		analyzeFilter(fa, fltr0);
		if (!isSimleFltr0) { react(iReactComplexFilterEnd, fa) };
		react(iReactAfterNot, fa);
		return();
	}
	
	int iSimpleFilterType = getSimpleFilterType_(fltrWork);
	if (iSimpleFilterType == iInvalidFilterType) {
		string sMessage = "Rückgabewert 'getSimpleFilterType_(" stringOf(mdlCurrent, fltrWork) ")' ist ungültig";
		logErrorMessage (iLogFatalCommand, sMessage);
		return();
	}
	
	static int iAttributeFilterType = 0;
	static int iLinkFilterType = 1;
	static int iObjectFilterType = 2;
	static int iColumnFilterType = 3;
	
	if (iSimpleFilterType == iAttributeFilterType) {
		// Attribute Filter!
		string sAttributeName = "";
		int iComparisonType = 0;
		string sComparisonValue = "";
		bool bMatchCase = false;
		bool bUseRegexp = false;
		bool bShallBeTrue = getAttributeFilterSettings_(mdlCurrent, fltrWork, 
								sAttributeName, iComparisonType, sComparisonValue, bMatchCase, bUseRegexp);
		if (!bShallBeTrue) {
			logErrorMessage (iLogFatalCommand, "ddd");
			return();
		}

		if (find(skpData, "fltrWork")) {
			delete(skpData, "fltrWork");
		}
		put (skpData, "fltrWork", fltrWork);

		if (find(skpData, "sAttributeName")) {
			delete(skpData, "sAttributeName");
		}
		put (skpData, "sAttributeName", sAttributeName);

		if (find(skpData, "iComparisonType")) {
			delete(skpData, "iComparisonType");
		}
		put (skpData, "iComparisonType", iComparisonType);

		if (find(skpData, "sComparisonValue")) {
			delete(skpData, "sComparisonValue");
		}
		put (skpData, "sComparisonValue", sComparisonValue);

		if (find(skpData, "bMatchCase")) {
			delete(skpData, "bMatchCase");
		}
		put (skpData, "bMatchCase", bMatchCase);

		if (find(skpData, "bUseRegexp")) {
			delete(skpData, "bUseRegexp");
		}
		put (skpData, "bUseRegexp", bUseRegexp);
		
		int iReactAfterAttributeFilter = -1;
		find (skpData, "iReactAfterAttributeFilter", iReactAfterAttributeFilter);	
		react(iReactAfterAttributeFilter, fa);
		return ();
	}

	if (iSimpleFilterType == iLinkFilterType) {
		// Link Filter!
		bool bMustHaveLinks = false;
		int iLinkType = 0;
			static int iRelatesToInAndOutlinks = 2;
			static int iRelatesToInlinks = 0;
			static int iRelatesToOutlinks = 1;
		string sLinkModuleName = "";
		bool bShallBeTrue = getLinkFilterSettings_(mdlCurrent, fltrWork,
							bMustHaveLinks, iLinkType, sLinkModuleName); 

		if (find(skpData, "fltrWork")) {
			delete(skpData, "fltrWork");
		}
		put (skpData, "fltrWork", fltrWork);

		if (find(skpData, "bMustHaveLinks")) {
			delete(skpData, "bMustHaveLinks");
		}
		put (skpData, "bMustHaveLinks", bMustHaveLinks);

		if (find(skpData, "iLinkType")) {
			delete(skpData, "iLinkType");
		}
		put (skpData, "iLinkType", iLinkType);

		if (find(skpData, "sLinkModuleName")) {
			delete(skpData, "sLinkModuleName");
		}
		put (skpData, "sLinkModuleName", sLinkModuleName);
		
		int iReactAfterLinkFilter = -1;
		find (skpData, "iReactAfterLinkFilter", iReactAfterLinkFilter);	
		react(iReactAfterLinkFilter, fa);
		return ();
	}
	
	if (iSimpleFilterType == iObjectFilterType) {
		// Object Filter!
		int iObjectFilterType = 0;
			static int iLeaves = 0;
			static int iNonLeaves = 1;
			static int iIncludeCurrent = 2;
			static int iExcludeCurrent = 3;
		bool bShallBeTrue =  getObjectFilterSettings_(mdlCurrent, fltrWork, iObjectFilterType);

		if (find(skpData, "fltrWork")) {
			delete(skpData, "fltrWork");
		}
		put (skpData, "fltrWork", fltrWork);

		if (find(skpData, "iObjectFilterType")) {
			delete(skpData, "iObjectFilterType");
		}
		put (skpData, "iObjectFilterType", iObjectFilterType);

		int iReactAfterObjectFilter = -1;
		find (skpData, "iReactAfterObjectFilter", iReactAfterObjectFilter);	
		react(iReactAfterObjectFilter, fa);
		return ();
	}
	
	if (iSimpleFilterType == iColumnFilterType) {
		// Column Filter!
		string sColumnName = "";
		string sComparisonValue = "";
		bool bMatchCase = false;
		bool bUseRegexp = false;
		bool bShallBeTrue =  getColumnFilterSettings_(mdlCurrent, fltrWork, sColumnName, 
							sComparisonValue, bMatchCase, bUseRegexp);

		if (find(skpData, "fltrWork")) {
			delete(skpData, "fltrWork");
		}
		put (skpData, "fltrWork", fltrWork);

		if (find(skpData, "sColumnName")) {
			delete(skpData, "sColumnName");
		}
		put (skpData, "sColumnName", sColumnName);

		if (find(skpData, "sComparisonValue")) {
			delete(skpData, "sComparisonValue");
		}
		put (skpData, "sComparisonValue", sComparisonValue);

		if (find(skpData, "bMatchCase")) {
			delete(skpData, "bMatchCase");
		}
		put (skpData, "bMatchCase", bMatchCase);

		if (find(skpData, "bUseRegexp")) {
			delete(skpData, "bUseRegexp");
		}
		put (skpData, "bUseRegexp", bUseRegexp);

		int iReactAfterColumnFilter = -1;
		find (skpData, "iReactAfterColumnFilter", iReactAfterColumnFilter);	
		react(iReactAfterColumnFilter, fa);
		return ();
	}
	
	string sMessage = "Unbekannter Rückgabewert 'getSimpleFilterType_(" stringOf(mdlCurrent, fltrWork) ")' = " iSimpleFilterType ".";
	logErrorMessage (iLogFatalCommand, sMessage);
}