(DISTFILES): Comment out a few missing files.

[mono-project.git] / mcs / class / Microsoft.VisualBasic / Microsoft.VisualBasic / Microsoft.VisualBasic.CompilerServices / FlowControl.cs

 //
// FlowControl.cs
//
// Author:
//   Chris J Breisch (cjbreisch@altavista.net) 
//   Dennis Hayes (dennish@raytek.com)
//
// (C) 2002 Chris J Breisch
//
/*
  * Copyright (c) 2002-2003 Mainsoft Corporation.
  * Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
  * 
  * The above copyright notice and this permission notice shall be included in
  * all copies or substantial portions of the Software.
  * 
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  * DEALINGS IN THE SOFTWARE.
  */
/**
 * This class allows to execute loop statement of VisualBasic .NET
 */

using System;
using System.Collections;
using System.ComponentModel;

namespace Microsoft.VisualBasic.CompilerServices 
{
        [StandardModule, EditorBrowsable(EditorBrowsableState.Never)] 
        sealed public class FlowControl {
                private FlowControl () {}

                private sealed /*static (final)in mainsoft java code*/ class ObjectFor {
                        public object Counter;

                        public object Limit;

                        public object StepValue;

                        public bool PositiveStep;

                        public Type EnumType;
                }
    
                /**
                 * This method check if the loop can continued.
                 * if the StepValue is positive it check that count is smaller than the limit.
                 * if the StepValue is negative it check that count is bigger than the limit. 
                 * @param count
                 * @param limit
                 * @param StepValue
                 * @return boolean True of the for next loop can continue and false otherwise.
                 */
                public static bool ForNextCheckR4(float count, float limit, float StepValue) {
                        bool positiveStep = StepValue > 0.0F;
                        bool isCountSmallThenLimit = count <= limit;
                        return positiveStep? isCountSmallThenLimit : !isCountSmallThenLimit;
                }
    
                /**
                 * This method check if the loop can continued.
                 * if the StepValue is positive it check that count is smaller than the limit.
                 * if the StepValue is negative it check that count is bigger than the limit. 
                 * @param count
                 * @param limit
                 * @param StepValue
                 * @return boolean True of the for next loop can continue and false otherwise.
                 */
                public static bool ForNextCheckR8(double count, double limit, double StepValue) {
                        bool positiveStep = StepValue > 0.0;
                        bool isCountSmallThenLimit = count <= limit;
                        return positiveStep? isCountSmallThenLimit : !isCountSmallThenLimit;
                }

                /**
                 * This method check if the loop can continued.
                 * if the StepValue is positive it check that count is smaller than the limit.
                 * if the StepValue is negative it check that count is bigger than the limit. 
                 * @param count
                 * @param limit
                 * @param StepValue
                 * @return boolean True of the for next loop can continue and false otherwise.
                 */
                public static bool ForNextCheckDec(Decimal count, Decimal limit, Decimal StepValue) {
                        bool positiveStep = StepValue.CompareTo(Decimal.Zero) < 0;
                        bool isCountSmallThenLimit = count.CompareTo(limit) >= 0;
                        return positiveStep? isCountSmallThenLimit : !isCountSmallThenLimit; 
                }
    
                /**
                 * This method method updates the LoopFor reference and the Counter reference
                 * object according to the given params and returns if this loop can continue. 
                 * @param Counter this loop counter value
                 * @param Start this loop start value 
                 * @param Limit this loop limitation value
                 * @param StepValue this loop step value
                 * @param lfr the LoopFor reference object
                 * @param cr the Counter object reference 
                 * @return boolean is the returned LoopFor object can continue.
                 */
                public static bool ForLoopInitObj(
                        object Counter,
                        object Start,
                        object Limit,
                        object StepValue,
                        ref System.Object lfr,
                        ref System.Object cr) {

                        object CounterResult = cr;

                        if (Start == null) {
                                throw new ArgumentException("Argument_InvalidNullValue1 " + " Start");
                        }
                        if (Limit == null) {
                                throw new ArgumentException("Argument_InvalidNullValue1 " + " Limit");
                        }
                        if (StepValue == null) {
                                throw new ArgumentException("Argument_InvalidNullValue1 " + " Step");
                        }
                        //gets the type of all the given parameters
                        Type startType = Start.GetType();
                        Type limitType = Limit.GetType();
                        Type stepType = StepValue.GetType();

                        //gets the widest common type code
                
                        TypeCode commonTypeCode = ObjectType.GetWidestType(Start, Limit, false);
                        commonTypeCode = ObjectType.GetWidestType(StepValue, commonTypeCode);
                        if (commonTypeCode == TypeCode.String) {
                                commonTypeCode = TypeCode.Double;
                        }
                        if (commonTypeCode == TypeCode.Object) {
                                //TODO:
                                //throw new ArgumentException(
                                //      Utils.GetResourceString(
                                //      "ForLoop_CommonType3",
                                //      Utils.VBFriendlyName(startType),
                                //      Utils.VBFriendlyName(limitType),
                                //      Utils.VBFriendlyName(StepValue)));
                                throw new ArgumentException("ForLoop_CommonType3 startType limitType StepValue");
                        }

                        ObjectFor objectFor = new ObjectFor();
                        TypeCode startTypeCode = Type.GetTypeCode(startType);
                        TypeCode limitTypeCode = Type.GetTypeCode(limitType);
                        TypeCode stepTypeCode = Type.GetTypeCode(stepType);
                        Type enumType = null;

                        bool isStartTypeValidEnum =  (startTypeCode == commonTypeCode) && (startType.IsEnum);
                        bool isLimitTypeValidEnum =  (limitTypeCode == commonTypeCode) && (limitType.IsEnum);
                        bool isStepTypeValidEnum =  (stepTypeCode == commonTypeCode) && (stepType.IsEnum);
        
                        bool isStartAndStepTypeEqual = (startType == stepType);
                        bool isStartAndLimitTypeEqual = (startType == limitType);
                        bool isStepAndLimitTypeEqual = (stepType == limitType);

                        //the For loop has enum type in the following case
                        //1. step is enum and it's type code equal to commonTypeCode and start and 
                        //  limit don't meet this condition.
                        //2. step and start are enum and their type code equal to commonTypeCode and
                        //  their types are equal. limit doesn't meet this condition about been enum
                        //  or about been equal to commonTypeCode.
                        //3. step and limit are enum and their type code equal to commonTypeCode and
                        //  their types are equal. start doesn't meet this condition about been enum
                        //  or about been equal to commonTypeCode.
                        //4. step and limit and start are enum and their type code equal to commonTypeCode and
                        //  their types are equal.
                        //5. start is enum and it's type code equal to commonTypeCode .step and 
                        //  limit don't meet this condition.
                        //6. limit is enum and it's type code equal to commonTypeCode .step and 
                        //  start don't meet this condition.
                        //7.start and limit are enum and their type code equal to commonTypeCode and
                        //  their types are equal. step doesn't meet this condition about been enum
                        //  or about been equal to commonTypeCode.
                        //
        
                        if (isStartTypeValidEnum && isLimitTypeValidEnum && isStepTypeValidEnum
                                &&  isStartAndStepTypeEqual && isStartAndLimitTypeEqual)
                                enumType = startType;
                        else if (isStartTypeValidEnum && isStepTypeValidEnum && isStartAndStepTypeEqual)
                                enumType = startType;
                        else if (isStartTypeValidEnum && isStepTypeValidEnum && isStartAndStepTypeEqual)
                                enumType = startType;
                        else if (isStartTypeValidEnum && isLimitTypeValidEnum && isStartAndLimitTypeEqual)
                                enumType = startType;
                        else if (isStartTypeValidEnum && !isLimitTypeValidEnum && !isStepTypeValidEnum)
                                enumType = startType;
                        else if (!isStartTypeValidEnum && isLimitTypeValidEnum && !isStepTypeValidEnum)
                                enumType = limitType; 
                        else if (!isStartTypeValidEnum && !isLimitTypeValidEnum && isStepTypeValidEnum)
                                enumType = stepType;            
        
                        objectFor.EnumType = enumType;
        
                        //set the counter field of objectFor with Start value transleted to 
                        // the widest common type code
                        objectFor.Counter = convertType(Start, commonTypeCode,"Start");
                        //set the Limit field of objectFor with Limit value transleted to 
                        // the widest common type code
                        objectFor.Limit = convertType(Limit, commonTypeCode,"Limit");
                        //set the StepValue field of objectFor with StepValue value transleted to 
                        // the widest common type code
                        objectFor.StepValue = convertType(StepValue, commonTypeCode,"Step");
                        //local is the value of zero in the widest common type code

                        object local = ObjectType.CTypeHelper(0, commonTypeCode);
        
                        IComparable iComparable = (IComparable)objectFor.StepValue;
                        objectFor.PositiveStep = iComparable.CompareTo(local) >= 0;

                        // sets the loop for reference 
                        lfr = objectFor;
        
                        //sets the counter reference
                        if (objectFor.EnumType != null) {
                                cr = Enum.ToObject(objectFor.EnumType, objectFor.Counter);
                        }
                        else {
                                cr = objectFor.Counter;
                        }        
                        return CheckContinueLoop(objectFor);
                }
    
                private static object convertType(object original, TypeCode typeCode, string fieldName) {
                        try {
                                return ObjectType.CTypeHelper(original, typeCode);
                        }
                        catch /*(Exception e)*/ {
                                throw new ArgumentException("ForLoop_ConvertToType3 " + fieldName);
                        }
                }

                public static bool ForNextCheckObj(object Counter, object LoopObj,
                        ref System.Object CounterResult) {// throws java.lang.Exception
                        TypeCode generalTypeCode = 0;

                        if (LoopObj == null) {
                                //TODO: use resource for the correct execption.
                                throw new Exception("VB error message #92 ForNextCheckObj LoopObj cannot be null");
                                //throw ExceptionUtils.VbMakeException(92);//correct java version
                        }
                        if (Counter == null) {
                                throw new NullReferenceException("Argument_InvalidNullValue1 " + " Counter");
                                //TODO:
                                //throw new NullReferenceException(
                                //    Utils.GetResourceString(
                                //        "Argument_InvalidNullValue1",
                                //        "Counter"));
                        }
                         ObjectFor objectFor = (ObjectFor) LoopObj;

                        IConvertible iConvertible_counter = (IConvertible)Counter;
                        IConvertible iConvertible_step = (IConvertible) objectFor.StepValue;

                        TypeCode counterTypeCode = iConvertible_counter.GetTypeCode();
                        TypeCode stepTypeCode = iConvertible_step.GetTypeCode();
                        
                        if (counterTypeCode == stepTypeCode && counterTypeCode != TypeCode.String) {
                                generalTypeCode = counterTypeCode;
                        }
                        else {
                                generalTypeCode = ObjectType.GetWidestType(counterTypeCode, stepTypeCode);
                                if (generalTypeCode == TypeCode.String) {
                                        generalTypeCode = TypeCode.Double;
                                }
                                Counter = convertType(Counter, generalTypeCode,"Start");
                                objectFor.Limit = convertType(objectFor.Limit, generalTypeCode,"Limit");
                                objectFor.StepValue = convertType(objectFor.StepValue, generalTypeCode,"Step");
                        }
                        //changes the counter field to be the sum of step and counter 
                        objectFor.Counter = ObjectType.AddObj(Counter, objectFor.StepValue);
                        IConvertible iConvertible_objectCounter = (IConvertible)objectFor.Counter;
                        TypeCode objectCounterTypeCode = iConvertible_objectCounter.GetTypeCode();

                        //setting the counter in counter reference.
                        //if the for is enum type change counter to enum. 
                        if (objectFor.EnumType != null) {
                                CounterResult = Enum.ToObject(objectFor.EnumType, objectFor.Counter);
                        }
                        else {
                                CounterResult = objectFor.Counter;
                        }
        
                        //if the counter after the change didn't change it's type return true if 
                        // the for  object can continue loop and false otherwise.
                        //if the counter changed it's type change all for object fields to counter
                        //current type and return false. 
                        if (objectCounterTypeCode == generalTypeCode) {
                                return CheckContinueLoop(objectFor);
                        }
                        else {
                                objectFor.Limit = ObjectType.CTypeHelper(objectFor.Limit, objectCounterTypeCode);
        
                                objectFor.StepValue =
                                        ObjectType.CTypeHelper(objectFor.StepValue, objectCounterTypeCode);
                                return false;
                        }
                }
    
                /**
                 * This method returns IEnumertator for a given array
                 * @param ary the given array
                 * @return IEnumerator the array's Enumerator
                 */
                public static IEnumerator ForEachInArr(Array ary) {// throws java.lang.Exception
                        IEnumerator iEnumerator = (IEnumerator)ary;//is ArrayStaticWrapper.GetEnumerator(ary); in java code.
                        if (iEnumerator != null)
                                return iEnumerator;
                        throw ExceptionUtils.VbMakeException(92);
                }
    
                /**
                 * This method gets IEnumerator for a given object that implements IEnumerable
                 * @param obj the object that implements IEnumerable
                 * @return IEnumerator the object's IEnumerator.
                 */
                public static IEnumerator ForEachInObj(object obj) {// throws java.lang.Exception
                        if (obj == null)
                                throw ExceptionUtils.VbMakeException(91);

                        IEnumerable iEnumerable = (IEnumerable)obj;
                        if (iEnumerable != null) {
                                IEnumerator iEnumerator = iEnumerable.GetEnumerator();
                                if (iEnumerator != null)
                                        return iEnumerator;
                        }
                        string s = obj.GetType().ToString();
                        ExceptionUtils.ThrowException1(100, s);
                        return null;
                }
    
                /**
                 * This method set the next value of teh Enumerator in the reference.
                 * if there isn't next value , null is been set in the referece. 
                 * @param obj
                 * @param enumerator
                 * @return boolean returns the value of enumerator.MoveNext().
                 */
                public static bool ForEachNextObj(ref System.Object obj, IEnumerator enumerator) {
                        if (enumerator.MoveNext()) {
                                obj = enumerator.Current;
                                return true;
                        }
                        obj = null;
                        return false;
                }
    
                /**
                 * This method check if the loop can continued.
                 * if the step is positive it check that the counter is smaller than the limit.
                 * if the step is negative it check that the counter is bigger than the limit. 
                 * @param LoopFor
                 * @return boolean
                 */
                private static bool CheckContinueLoop(ObjectFor LoopFor) {
                        //TODO:
                        //throw new NotImplementedException("MSVB.Compilerservices.flowcontrol needs help");
                        IComparable iComparable = (IComparable)LoopFor.Counter;
                        
                        if (iComparable != null) {
                                int i = iComparable.CompareTo(LoopFor.Limit);
                                bool isCountSmallThenLimit = i<=0;
                                return LoopFor.PositiveStep ? isCountSmallThenLimit : !isCountSmallThenLimit;
                        }
                        throw new ArgumentException("Argument_IComparable2 loop control variable"); // + Utils.VBFriendlyName(LoopFor.Counter)));
                                //TODO: verify this and the above are the same and remove.
                                //throw new ArgumentException(Utils.GetResourceString(
                                //      "Argument_IComparable2", "loop control variable",
                                //      Utils.VBFriendlyName(LoopFor.Counter)));
                        }
    
                /**
                 * This method throws exception if the input is Valuetype  
                 * @param obj the object that need to be checked
                 */
                public static void CheckForSyncLockOnValueType(object obj) {
                        //TODO:
                        //throw new NotImplementedException("MSVB.Compilerservices.flowcontrol needs help");
                        if (obj != null && obj.GetType().IsValueType)
                                throw new ArgumentException(Utils.GetResourceString("SyncLockRequiresReferenceType1 "));
                        //TODO: verify this and the above are the same and remove.
                        //if (obj != null && ObjectStaticWrapper.GetType(obj).get_IsValueType())
                        //      throw new ArgumentException(Utils.GetResourceString(
                        //              "SyncLockRequiresReferenceType1",Utils.VBFriendlyName(obj)));
                }
        }
}