hpfuncmisc.java

来自「一个简单的visio程序。」· Java 代码 · 共 2,139 行 · 第 1/4 页

		return false;
	}

	public static boolean ISARRAY(float variant) throws HpException {
		return false;
	}

	public static boolean ISARRAY(boolean variant) throws HpException {
		return false;
	}

	public static boolean ISARRAY(String variant) throws HpException {
		return false;
	}

	public static boolean ISARRAY(fixedString variant) throws HpException {
		return false;
	}

	public static boolean ISARRAY(VObject variant) throws HpException {
		return false;
	}

	public static boolean ISARRAY(VNull variant) throws HpException {
		return false;
	}

	public static boolean ISARRAY(HDate variant) throws HpException {
		return false;
	}

	public static boolean ISARRAY(HCurr variant) throws HpException {
		return false;
	}

	public static boolean ISARRAY(VArray variant) throws HpException {
		return true;
	}

	public static boolean ISARRAY(Variant  v) throws HpException {
		if (v.getType() == Variant.V_ARR )
			return true;
		return false;
	}

   /**
	* @Function: ISOBJECT(expression)
	* Returns a Boolean value indicating whether an expression
	* references a valid OLE Automation object.
	*/
	public static boolean ISOBJECT(short variant) throws HpException {
		return false;
	}

	public static boolean ISOBJECT(int variant) throws HpException {
		return false;
	}

	public static boolean ISOBJECT(HByte variant) throws HpException {
		return false;
	}

	public static boolean ISOBJECT(double variant) throws HpException {
		return false;
	}

	public static boolean ISOBJECT(float variant) throws HpException {
		return false;
	}

	public static boolean ISOBJECT(boolean variant) throws HpException {
		return false;
	}

	public static boolean ISOBJECT(String variant) throws HpException {
		return false;
	}

	public static boolean ISOBJECT(fixedString variant) throws HpException {
		return false;
	}

	public static boolean ISOBJECT(VObject variant) throws HpException {
		return true;
	}

	public static boolean ISOBJECT(VNull variant) throws HpException {
		return false;
	}

	public static boolean ISOBJECT(HDate variant) throws HpException {
		return false;
	}

	public static boolean ISOBJECT(HCurr variant) throws HpException {
		return false;
	}

	public static boolean ISOBJECT(VArray variant) throws HpException {
		return false;
	}

	public static boolean ISOBJECT(Variant v) throws HpException {
		if (v.getType() == Variant.V_OBJ) // || v.getType() == Variant.V_FORM)
			return true;
		return false;
	}

   /**
	* @Function: LBound(arrayname[, dimension])
	* Returns the smallest available subscript for the indicated
	* dimension of an array.
	*/
	public static int LBOUND(VArray array) throws HpException {
		return LBOUND(array, 1);
	}

	public static int LBOUND(Variant arrayname) throws HpException {
		return LBOUND(arrayname, 1);
	}

	public static int LBOUND(VArray array, int dimension) throws HpException {
		int dim_num = array.getDims();  //get arrayname's dimesion
		if (dimension <= 0 || dimension > dim_num)
			throw new HpException(9, "Subscript out of range");

		Vector arr_lowdims = array.getLowdims();
		Integer arrElem = (Integer)arr_lowdims.elementAt(dimension - 1);
		return arrElem.intValue();
	}
	public static int LBOUND(Variant arrayname, int dimension) throws HpException
	{
		if (arrayname.getType() != Variant.V_ARR)
			throw new HpException(13, "Type mismatch");

		return LBOUND(arrayname.getArray(), dimension);
	}

   /**
	* @Function: UBound(arrayname[, dimension])
	* Returns the largest available subscript for the indicated
	* dimension of an array.
	*/
	public static int UBOUND(VArray  array) throws HpException {
		return UBOUND(array, 1);
	}

	public static int UBOUND(Variant  arrayname) throws HpException	{
		return UBOUND(arrayname, 1);
	}

	public static int UBOUND(VArray array, int dimension) throws HpException {
		int dim_num = array.getDims();
		if (dimension > dim_num || dimension < 0)
			throw new HpException(9,"Subscript out of range");

		Vector sub = array.getHighdims();
		Integer arrElem = (Integer)sub.elementAt(dimension - 1);
		return arrElem.intValue();
	}

	public static int UBOUND(Variant arrayname, int dimension) throws HpException
	{
		if (arrayname.getType() != Variant.V_ARR )
			throw new HpException(13, "Type mismatch");

		return UBOUND(arrayname.getArray(), dimension);
	}

   /**
	* @Function: TypeName(varname)
	* Returns a string that provides information about a variable.
	*/
	public static String TYPENAME(VNull varname) throws HpException {
		return "Null";
	}

	public static String TYPENAME(short varname) throws HpException {
		return "Integer";
	}

	public static String TYPENAME(int varname) throws HpException {
		return "Long";
	}

	public static String TYPENAME(double varname) throws HpException {
		return "Double";
	}

	public static String TYPENAME(float varname) throws HpException {
		return "Single";
	}

	public static String TYPENAME(HCurr varname) throws HpException {
		return "Currency";
	}
	public static String TYPENAME(HDate varname) throws HpException {
		return "Date";
	}

	public static String TYPENAME(String varname) throws HpException {
		return "String";
	}

	public static String TYPENAME(fixedString varname) throws HpException {
		return "String";
	}

	public static String TYPENAME(boolean varname) throws HpException {
		return "Bool";
	}

	public static String TYPENAME(VObject varname) throws HpException {
		String classType = "Nothing";
		try {
			Object obj = varname.objValue(); //Wrapper  obj = varname.getObject();
			if (obj == null)
				classType = "Nothing";
			else
				classType = varname.getClassType(); //varname.getRunClassName();

			if (classType.equalsIgnoreCase("err"))
				classType = "ErrObject";
			if (classType.equalsIgnoreCase("1 2 3 nothing"))
				classType = "Nothing";
		} catch(Exception err ) {;}
		return classType;
	}

	public static String TYPENAME(HByte varname) throws HpException {
		return "Byte";
	}

	public static String TYPENAME(VArray varname) throws HpException {
		
		switch (varname.getType()) {
			case Variant.V_VAR:
				return "Variant()";

			case Variant.V_NULL:
				return "Null";

			case Variant.V_INT:
				return "Integer()";

			case Variant.V_LONG:
				return "Long()";

			case Variant.V_SINGLE:
				return "Single()";

			case Variant.V_DBL:
				return "Double()";

			case Variant.V_CURR:
				return "Currency()";

			case Variant.V_DATE:
				return "Date()";

			case Variant.V_FIX_STR:
			case Variant.V_STR:
				return "String()";

			case Variant.V_OBJ:
				try	{
					Object obj2 = varname.getobj(); //Wrapper  obj2 = varname.getObject();
					if (obj2 == null)
						return "Nothing";
					else
						return varname.getvobj().getClassType() + "()";
				} catch(Exception err) {;}

			case Variant.V_ERR:
				return "Error" + "()";

			case Variant.V_BOL:
				return "Bool()";

			case Variant.V_BYTE:
				return "Byte()";

			/*
			case Variant.V_FORM:
				if (varname.get_form() == null)
					return "Nothing";
				else if (varname.get_form() instanceof form) {
					form   fom = (form)varname.get_form();
					return fom.getName() + "()";
				}
				else {
					IB4JApplet apt = (IB4JApplet)varname.getForm();
					return apt.getName() + "()";
				}
			*/
		}
		return "Null";
	}

	public static String TYPENAME(Variant varname) throws HpException
	{
			switch (varname.getType()) {
			case Variant.V_EMPTY:
				return "Empty";

			case Variant.V_NULL:
				return "Null";

			case Variant.V_INT:
				return "Integer";

			case Variant.V_LONG:
				return "Long";

			case Variant.V_SINGLE:
				return "Single";

			case Variant.V_DBL:
				return "Double";

			case Variant.V_CURR:        //  7
				return "Currency";

			case Variant.V_DATE:      //  8
				return "Date";

			case Variant.V_FIX_STR:
			case Variant.V_STR:
				return "String";

			case Variant.V_OBJ:
				return TYPENAME((VObject)varname);

			case Variant.V_ERR:
				return "Error";

			case Variant.V_BOL:
				return "Bool";

			case Variant.V_ARR:
				return TYPENAME(varname.getArray());

			case Variant.V_BYTE:
				return "Byte";

			/*
			case Variant.V_FORM:
				if (varname.get_form() == null)
					return "Nothing";
				else if ((varname.get_form()) instanceof form) {
					form   fom = (form)varname.get_form();
					return fom.getName();
				}
				else {
					IB4JApplet apt = (IB4JApplet)varname.getForm();
					return apt.getName();
				}
			*/

			default:
				throw new HpException( 13, "Type mismatch");
		}
		//return null;
	}

   /*
	* @Function: Error(number)
	* Returns the error message that corresponds to a given error number.
	*/
	public static Variant ERROR(int number) throws HpException {
		return new VString(ERROR$(number));
	}

	public static Variant ERROR() throws HpException {
		return new VString("");
	}

	public static String ERROR$(int number) throws HpException
	{
		String  errmsg = "";

		if (number < 0)
			throw new HpException(95, "Invalid procedure call");
		if (number > 65535)
			throw new HpException(6, "Overflow");

		/*
		HandleErr errfunc = new HandleErr();
		if (number != 0)
		{
			errmsg = errfunc.find_ErrMessage(number);
			if (errmsg == null)
				errmsg = "Application_defined or object_defined error";
		}
		*/
		return errmsg;
	}

	public static String ERROR$() throws HpException {
		return "";
	}

   /**
	* @Function: Array(arglist)
	* Returns a Variant containing an array.
	*/
	public static Variant ARRAY() throws HpException
	{  
	   VArray array= new VArray();
	   return new Variant(array);
	}

	public static Variant ARRAY(VArray arglist) throws HpException
	{
		try {
			int number = arglist.getArrayLength();
			//System.out.println("number = " + number);
			Object obj = arglist.getArrayHash().get(new Integer(0).toString());
			int index = (int)str2dbl(obj.toString());
			//System.out.println("index = " + index);
			VArray arr = new VArray(1, Variant.V_VAR);
			arr.push((double)index, (index == 0)?(double)number-1:(double)number);

			for(int i = 1; i < number; i++) {
				Object element = arglist.getArrayHash().get(new Integer(i).toString());
				String clsname = element.getClass().getName();
				//System.out.println("obj = " + element+", string = " + clsname);
				if(clsname.equals("java.lang.Short"))
					arr.add(((Short)element).shortValue());
				else if(clsname.equals("java.lang.Integer"))
					arr.add(((Integer)element).intValue()); 
				else if(clsname.equals("java.lang.Double"))
					arr.add(((Double)element).doubleValue());
				else if(clsname.equals("java.lang.Boolean"))
					arr.add(((Boolean)element).booleanValue());
				else if(clsname.equals("java.lang.String"))
					arr.add(((String)element).toString());
				else if(clsname.equals("java.lang.Float"))
					arr.add(((Float)element).floatValue());
				else
					arr.add((Variant)element);
			}
			return new Variant(arr);

		} catch(Exception e) { e.printStackTrace();}
		return new VNull();
	}

   /**
	* @Function: Choose(arglist)
	* Selects and returns a value from a list of arguments.
	*/
	public static Variant CHOOSE(Variant arglist) throws HpException {
		if (arglist.getType() == Variant.V_EMPTY || arglist.getType() == Variant.V_NULL)
			throw new HpException(94, "Invalid use of Null");
		return CHOOSE(arglist.getArray());
	}

	public static Variant CHOOSE(VArray arglist) throws HpException
	{
		int number = arglist.getArrayLength();

		if (number == 1)
			//return new VNull();
			throw new HpException(94, "Invalid use of Null");

		//int index = (int)arglist.pop(0).getlng();
		Object obj = arglist.getArrayHash().get(new Integer(0).toString());
		int index = (int)str2dbl(obj.toString());
		if (index >= number || index <= 0)
			return new VNull();

		//return arglist.pop(index).getvar();
		return new VString((arglist.getArrayHash().get(new Integer(index).toString())).toString());
	}

   /**
	* @Function: Switch(arglist)
	* Evaluates a list of expressions and returns a value or an
	* expression associated with the first expression in the list
	* that is True.
	*/
	public static Variant SWITCH(VArray arglist)throws HpException
	{
		int number = arglist.getArrayLength();

		if (number == 0)
			return new VNull();
		else if ((number % 2) != 0)
			throw new HpException(5, "Invalid procedure call");

		int i = 0;
		for (i = 0; i < number; i++) {
			Object obj = arglist.getArrayHash().get(new Integer(i).toString());
			//System.out.println("boolean = " + obj.toString()+", obj="+obj);
			if ((i == 0 || i % 2 == 0) && (obj.toString().equalsIgnoreCase("true")))
				//return  Switch(arglist.getArrayHash().get(new Integer(i+1).toString()));
				return new VString((arglist.getArrayHash().get(new Integer(i+1).toString())).toString());
		}

		//if (i == number)
		//	throw new HpException(94,"Invalid use of null");

		return new VNull();
	}
 
	public static Variant SWITCH() throws HpException {
		return new VNull();
	}

   /**
	* @Function: Shell(pathname[, windowstyle])
	* Runs an executable program.
	*/
	public static Variant SHELL(String pathname, int windowstyle) throws HpException
	{
		if ( windowstyle < 0 || windowstyle > 9 )
			throw new HpException(5, "Invalid procedure call");

		Runtime  r = Runtime.getRuntime();
		try	{
			Process proc = r.exec(pathname);
		} catch(Exception e) {
			throw new HpException(53, "File not found");
		}
		r.gc();

		return new VDouble(-240413);
	}

	public static Variant SHELL(String pathname) throws HpException	{
		return SHELL(pathname, 2);
	}
}