preprocessor.js

Browser independent JavaScript SDK. ClassLoader to lazy load JavaScript classes, extensions to core

/*
 * JavaScript Software Development Kit - what JavaScript should be and can be - js-sdk.sourceforge.net
 * Copyright (C) 2006-2007 Mathew Sheets
 *
 * == BEGIN LICENSE ==
 *
 * Licensed under the terms of any of the following licenses at your
 * choice:
 *
 *  - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
 *    http://www.gnu.org/licenses/lgpl.html
 *
 * == END LICENSE ==
 */

runtime.PreProcessor = function(){this.initialize.apply(this, arguments);};
runtime.PreProcessor.prototype =
{

	CORE_CLASSES : ["Array", "Boolean", "Date", "Function", "Math", "Number", "Object", "RegExp", "String"],

	// namespace
	PACKAGE_TXT : "package ",
	// dependency
	IMPORT_TXT : "import ",
	// class def
	CLASS_TXT : "class ",
	// parent def
	EXTENDS_TXT : "extends ",
	// behavior contract
	IMPLEMENTS_TXT : "implements ",
	// module functionality
	MIXINS_TXT : "mixin ",

	// parent init
	SUPER_INIT : "super(",
	// parent call
	SUPER_TXT : "super.",
	// instance method
	INSTANCE_TXT : "instance ",
	// static method
	STATIC_TXT : "static ",
	// abstract method
	ABSTRACT_TXT : "abstract ",

    initialize : function(_classTransporter)
    {
    	this.classTransporter = _classTransporter;

		// ########################################
		// ##########  FIX NAMESPACING ############
		// strings before search
		var newBeforeSearch = "new ";
		var parenAfter = "(";

		var assignBeforeSearch = "=";
		var assignSpaceBeforeSearch = "= ";
		var spaceAssignBeforeSearch = " =";
		var spaceAssignSpaceBeforeSearch = " = ";

		// strings around search
		var dotAfterSearch = ".";
		var spaceBefore = " ";
		var plusBefore = "+";
		var parenBefore = "(";
		var tabBefore = "\t";
		var newLineBefore = "\n";
		var returnBefore = "\r";
		var formFeedBefore = "\f";
		this.fixNamespacing = function(aSearched, aFind, aReplace)
		{
			var result;
			var newText = "";
			var start = 0;
			var end = 0;
			var reqexp = new RegExp(aFind, "g");
			while((result = reqexp.exec(aSearched)) != null)
			{
				end = result.index;

				newText += aSearched.substring(start, end);

				if(
					(end == 0) ||
						(
							(aSearched.substring(end-newBeforeSearch.length, end) == newBeforeSearch) &&
							(aSearched.substring((end+aFind.length), ((end+aFind.length)+parenAfter.length)) == parenAfter)

						) ||
					(aSearched.substring(end-assignBeforeSearch.length, end) == assignBeforeSearch) ||
					(aSearched.substring(end-assignSpaceBeforeSearch.length, end) == assignSpaceBeforeSearch) ||
					(aSearched.substring(end-spaceAssignBeforeSearch.length, end) == spaceAssignBeforeSearch) ||
					(aSearched.substring(end-spaceAssignSpaceBeforeSearch.length, end) == spaceAssignSpaceBeforeSearch) ||
						(
							(aSearched.substring((end+aFind.length), ((end+aFind.length)+dotAfterSearch.length)) == dotAfterSearch)
							&&
							(
								(aSearched.substring(end-spaceBefore.length, end) == spaceBefore) ||
								(aSearched.substring(end-plusBefore.length, end) == plusBefore) ||
								(aSearched.substring(end-parenBefore.length, end) == parenBefore) ||
								(aSearched.substring(end-tabBefore.length, end) == tabBefore) ||
								(aSearched.substring(end-newLineBefore.length, end) == newLineBefore) ||
								(aSearched.substring(end-returnBefore.length, end) == returnBefore) ||
								(aSearched.substring(end-formFeedBefore.length, end) == formFeedBefore)
							)
						)
					)
				{
					newText += aReplace;
				}
				else
				{
					newText += aFind;
				}

				start = reqexp.lastIndex;
			}
			newText += aSearched.substring(start, aSearched.length);

			return newText;
		}
		// ########################################
		// ########################################

		// ########################################
		// ############# FIX FUNCTIONS ##############
		this.getName = function(_srcCode, _index, _searchFor, _endIndex)
		{
			return _srcCode.substring((_index+_searchFor.length), _endIndex);
		}
		this.getFunctionArgs = function(_srcCode, _index, _searchFor, _functionName, _endIndex)
		{
			return _srcCode.substring((_index+_searchFor.length+_functionName.length+1),
							_srcCode.indexOf(")", _endIndex));
		}
		this.replaceCode = function(_srcCode, _searchFor, _searchTo, _block)
		{
			var sIndex = 0;
			var eIndex = 0;
			while(_srcCode.indexOf(_searchFor, sIndex) > -1)
			{
				var index = _srcCode.indexOf(_searchFor, sIndex);
				eIndex = _srcCode.indexOf(_searchTo, index);

				if(eIndex <= -1) break;

				var parts = _block(_srcCode, index, _searchFor, eIndex);

				_srcCode = _srcCode.replace(parts.oldCode, parts.newCode);
				sIndex = eIndex;
			}

			return _srcCode;
		}
		// ########################################
		// ########################################
    },

    preprocess : function(_jsCode, _loadedClasses)
    {
		var me = this;

		var pakage = "";
		var clazz = "";
		var fqClass = "";
		var superClass = "";
		var fqSuperClass = "";
		var imports = [];
		var mixins = [];
		var interfaces = [];

		// start of text parsing
		var startIndex = 0;
		var endIndex = 0;

		// get the package
		var packageIndex = _jsCode.indexOf(this.PACKAGE_TXT, startIndex);
		if(packageIndex > -1)
		{
			endIndex = _jsCode.indexOf(";", packageIndex);

			pakage = _jsCode.substring((packageIndex+this.PACKAGE_TXT.length), endIndex);
		}
		startIndex = endIndex;

		// get the imports and handle wildcards
		while(_jsCode.indexOf(this.IMPORT_TXT, startIndex) > -1)
		{
			var importIndex = _jsCode.indexOf(this.IMPORT_TXT, startIndex);

			endIndex = _jsCode.indexOf(";", importIndex);

			var a_import = _jsCode.substring((importIndex+this.IMPORT_TXT.length), endIndex);

			if(a_import.indexOf("*") == -1) // handle wildcard
			{
				imports[imports.length] =
					{
						fqclazz : a_import,
						clazz : a_import.substring(a_import.lastIndexOf(".")+1, a_import.length)
					};
			}
			else
			{
					var classes = this.classTransporter.getClassesInPkg(a_import);
					for(var i=0;i<classes.length;i++)
					{
						var _fqclazz = classes[i];
						var _clazz = _fqclazz.substring(_fqclazz.lastIndexOf(".")+1, _fqclazz.length);

						imports[imports.length] = {fqclazz : _fqclazz, clazz : _clazz};
					}
			}

			startIndex = endIndex;
		}

		// array of Class Names from the imports to match against the interfaces and mixins classes
		var classImports = [];
		for(var i=0;i<imports.length;i++)
		{
			classImports[classImports.length] = imports[i].clazz;
		}

		// get the class
		var classIndex = _jsCode.indexOf(this.CLASS_TXT, startIndex);
		var classDef = "";
		if(classIndex > -1)
		{
			endIndex = _jsCode.indexOf("{", classIndex);
			classDef = _jsCode.substring((classIndex+this.CLASS_TXT.length), endIndex);
		}

		startIndex = endIndex;

		// get the super, interface, and mixin classes
		var extendsIndex = classDef.indexOf(this.EXTENDS_TXT);
		var implementsIndex = classDef.indexOf(this.IMPLEMENTS_TXT);
		var mixinIndex = classDef.indexOf(this.MIXINS_TXT);
		if(extendsIndex > -1 || mixinIndex > -1 || implementsIndex > -1)
		{
			if(extendsIndex > -1)
			{
				clazz = runtime.trimString(classDef.substring(0, extendsIndex));

				var superEndIndex = classDef.length;
				if(implementsIndex > -1 || mixinIndex > -1)
				{
					superEndIndex = classDef.indexOf(" ", extendsIndex+this.EXTENDS_TXT.length);
				}

				superClass = runtime.trimString(classDef.substring((extendsIndex+this.EXTENDS_TXT.length), superEndIndex));