Esempio n. 1
0
		} // ArrayConstructorFunction
	
	
	// Implementation for calling the Array constructor as a constructor.
	public static object ArrayConstructor(object this_, params object[] args)
		{
		JArrayObject arrayObj = new JArrayObject();
		
		if (args.Length == 1 && JObject.Typeof(args[0]) == "number")
			{
			// Treat the one argument as a length, and create an array of
			// that length.
			UInt32 newLength = JConvert.ToUInt32(args[0]);
			if (newLength != JConvert.ToNumber(args[0]))
				throw new RangeError("array length in constructor is outside the UInt32 range");
			
			arrayObj.arrayLength = newLength;
			}
		else
			{
			// Create an array with the entries specified in the args array.
			foreach (object curArg in args)
				arrayObj.entries.Add(curArg);
			
			arrayObj.arrayLength = (uint) args.Length;
			}
		
		return arrayObj;
		} // ArrayConstructor
Esempio n. 2
0
		} // split (implicit limit)
	
	
	// Overload of split where the separator and limit parameters are not specified.
	public static JArrayObject split(string _this)
		{
		JArrayObject A = new JArrayObject();
		A.Add(_this);
		return A;
		} // split (implicit separator, limit)
Esempio n. 3
0
		} // toLocaleString
	
	
	// If obj is a JArrayObject, append its contents to array.  Otherwise,
	// append obj to array.
	private static void AppendToArray(JArrayObject array, object obj)
		{
		if (obj is JArrayObject)
			{
			JArrayObject objAsArray = (JArrayObject)obj;
			uint arrayLen = objAsArray.ArrayLength;
			
			for (uint i=0; i<arrayLen; i++)
				{
				object curEntry = objAsArray.Get(JArrayObject.ArrayIndexToString(i));
				if (!(curEntry is JUndefinedObject))
					array.Add(curEntry);
				else
					array.IncrementLength();
				
				}
			
			}
		else
			array.Add(obj);
		
		} // AppendToArray
Esempio n. 4
0
		} // slice (implicit end)
	
	
	// Returns an Array object into which substrings of the result of converting
	// this object to a string have been stored.  The substrings are determined
	// by searching from left to right for occurrences of separator; these
	// occurrences are not part of any substring in the returned array, but
	// serve to divide up the string value.  The value of separator may be a
	// string of any length or it may be a RegExp object.
	public static JArrayObject split(string _this, string separator, uint limit)
		{
		// HACK snewman 10/17/01: add support for RegExpr separators.
		
		JArrayObject A = new JArrayObject();
		if (limit == 0)
			return A;
		
		int len = _this.Length;
		int matchEnd;
		if (len == 0)
			{
			matchEnd = SplitMatch(separator, _this, 0);
			if (matchEnd < 0)
				A.Add(_this);
			return A;
			}
		
		// Look for split positions.
		int fragmentStart = 0;
		while (true)
			{
			bool foundFrag = false;
			for (int searchPos = fragmentStart+1; searchPos < len; searchPos++)
				{
				matchEnd = SplitMatch(separator, _this, searchPos);
				if (matchEnd >= 0)
					{
					A.Add(_this.Substring(fragmentStart, searchPos-fragmentStart));
					
					if (A.ArrayLength >= limit)
						return A;
					
					fragmentStart = matchEnd;
					foundFrag = true;
					break;
					}
				
				}
			
			if (!foundFrag)
				break;
			
			} // while (true)

		A.Add(_this.Substring(fragmentStart, len-fragmentStart));
		return A;

		// HACK snewman 10/2/01: the spec states that "the length property of
		// the split method is 2".  Need to implement this.
		} // split
Esempio n. 5
0
		} // sort
	
	
	// When the splice method is called with two or more arguments start,
	// deleteCount and (optionally) item1, item2, etc., the deleteCount
	// elements of the array starting at array index start are replaced by
	// the arguments item1, item2, etc.
	// 
	// NOTE: we return a new array containing the deleted elements.  This
	// is not explicitly mentioned in the description in the spec, but it
	// is part of the algorithm contained in the spec.
	public static JArrayObject splice( object _this, int start, int deleteCount,
									   params object[] args )
		{
		JArrayObject newArray = new JArrayObject();
		uint length = JConvert.ToUInt32(Support.GetProperty(_this, "length"));
		uint argCount = (uint)args.Length;
		
		uint adjustedStart = (start < 0) ? Math.Max((uint)((int)length+start), 0)
										 : Math.Min((uint)start, length);
		
		uint adjustedDel = Math.Min( (uint)Math.Max(deleteCount,0),
									 (uint)(length-adjustedStart) );
		uint newLength = length - adjustedDel + argCount;
		
		for (int k=0; k < adjustedDel; k++)
			{
			object entry = Support.GetProperty(_this,
				JArrayObject.ArrayIndexToString((uint)(adjustedStart+k)) );
			
			if (entry is JUndefinedObject)
				newArray.IncrementLength();
			else
				newArray.Add(entry);
			}
		
		if (argCount < adjustedDel)
			{
			for (uint k = adjustedStart; k < length - adjustedDel; k++)
				{
				object tempEntry = Support.GetProperty( _this,
							JArrayObject.ArrayIndexToString(k+adjustedDel) );
				string kArgString = JArrayObject.ArrayIndexToString(k+argCount);
				if (tempEntry is JUndefinedObject)
					Support.DeleteProperty(_this, kArgString);
				else
					Support.AssignProperty(_this, kArgString, tempEntry);
				
				}
			
			for (uint k = length; k > newLength; k--)
				Support.DeleteProperty( _this,
										JArrayObject.ArrayIndexToString(k-1) );
			
			}
		else if (argCount > adjustedDel)
			{
			for (uint k = length - adjustedDel; k > adjustedStart; k--)
				{
				object tempEntry = Support.GetProperty( _this,
							JArrayObject.ArrayIndexToString(k+adjustedDel-1) );
				string kArgString = JArrayObject.ArrayIndexToString(k+argCount-1);
				if (tempEntry is JUndefinedObject)
					Support.DeleteProperty(_this, kArgString);
				else
					Support.AssignProperty(_this, kArgString, tempEntry);
				}
			
			}
		
		uint argIndex = adjustedStart;
		foreach (object curArg in args)
			{
			Support.AssignProperty( _this,
									JArrayObject.ArrayIndexToString(argIndex),
									curArg );
			argIndex++;
			}
		
		Support.AssignProperty(_this, "length", newLength);
		return newArray;
		
		// HACK snewman 10/2/01: the spec states that "the length property of
		// the splice method is 2".  Need to implement this.
		} // splice
Esempio n. 6
0
		} // join
	
	
	// The slice method takes two arguments, start and end, and returns an array
	// containing the elements of the array from element start up to, but not
	// including, element end (or through the end of the array if end is undefined).
	// If start is negative, it is treated as (length+start) where length is the
	// length of the array.  If end is negative, it is treated as (length+end)
	// where length is the length of the array.
	public static JArrayObject slice(object _this, int start, int end)
		{
		JArrayObject newArray = new JArrayObject();
		
		uint length = JConvert.ToUInt32(Support.GetProperty(_this, "length"));
		
		int adjustedStart = (start < 0) ? Math.Max((int)(length+start), 0)
										: Math.Min(start, (int)length);
		int adjustedEnd   = (end < 0) ? Math.Max((int)(length+end), 0)
									  : Math.Min(end, (int)length);
		
		uint n = 0;
		for (int k = adjustedStart; k < adjustedEnd; k++)
			{
			string kString = JArrayObject.ArrayIndexToString((uint)k);
			object entryK = Support.GetProperty(_this, kString);
			if (entryK is JUndefinedObject)
				newArray.IncrementLength();
			else
				newArray.Add(entryK);
			
			n++;
			}
		
		return newArray;
		
		// HACK snewman 10/2/01: the spec states that "the length property of
		// the join method is 2".  Need to implement this.
		} // slice
Esempio n. 7
0
		} // toLocaleString
	
	
	// When the concat method is called with zero or more arguments item1,
	// item2, etc., it returns an array containing the array elements of
	// the object followed by the array elements of each argument in order.
	public static JArrayObject concat(object _this, params object[] args)
		{
		JArrayObject newArray = new JArrayObject();
		
		AppendToArray(newArray, _this);
		foreach (object obj in args)
			AppendToArray(newArray, obj);
		
		return newArray;
		
		// HACK snewman 10/2/01: the spec states that "the length property of
		// the concat method is 1".  Need to implement this.
		} // concat
Esempio n. 8
0
		} // toString
	
	
	// The elements of the array are converted to strings using their
	// toLocaleString methods, and these strings are then concatenated,
	// separated by occurrences of a separator string that has been derived in
	// an implementation-defined locale-specific way.  The result of calling
	// this function is intended to be analogous to the result of toString,
	// except that the result of this function is intended to be locale-specific.
	public static string toLocaleString(JArrayObject _this)
		{
		return joinCore(_this, ",", true);
		} // toLocaleString
Esempio n. 9
0
	// The result of calling this function is the same as if the built-in
	// "join" method were invoked for this object with no argument.
	public static string toString(JArrayObject _this)
		{
		return join(_this);
		} // toString